Система принятия решений и/или Нечеткая логика(FuzzyLogic)

local co = coroutine.create(function()
    for i = 1, 5 do
        print("Работаю...", i)
        coroutine.yield() -- приостанавливаем "поток"
    end
end)

while coroutine.status(co) ~= "dead" do
    coroutine.resume(co) -- возобновляем
    sleep(100)
end

--- Пример «лёгкого фонового потока» в QUIK

local is_run = true

-- "Лёгкий поток" для фоновой задачи
local function background_task()
    local count = 0
    while is_run do
        count = count + 1
        message("Фоновая задача: шаг " .. count)
        coroutine.yield()  -- уступаем управление
    end
end

function main()
    local co = coroutine.create(background_task)
    message("Запуск фонового лёгкого потока...")
    while is_run do
        coroutine.resume(co)  -- возобновляем поток
        sleep(1000)           -- имитация "асинхронного" поведения
    end
end

function OnStop()
    is_run = false
    message("Остановка фонового потока.")
end


-- * Корутину можно считать лёгким потоком Lua — она живёт, имеет собственный контекст и исполняется пошагово.

-- "Лёгкий поток" для фоновой задачиlocal function background_task()
    local count = 0
    while is_run do
        count = count + 1
        message("Фоновая задача: шаг " .. count)
        coroutine.yield()  -- уступаем управление
    end
end

- Pобот - торговый менеджер с реальным риск-контролем QUIK
--[[ Цель. Создать систему, которая:

1. Определяет начальный капитал (из QUIK).
2. Каждые несколько секунд получает текущую оценку капитала.
3. Вычисляет просадку в процентах от начального капитала.
4. Если просадка превышает лимит (например, 2%), —
       останавливает все стратегии, фиксирует в логах и выводит уведомление.
--]]
--[[Пример: простая стратегия на основе корутины!

Идея: Следим за ценой инструмента (SBER), и 
   если она падает больше чем на "drop_trigger %" от последней зафиксированной — покупаем 1 лот.
   Если поднимается больше чем на "drop_trigger %"% — продаём 1 лот.
   
Все операции выполняются пошагово, без блокировки основного потока. --]]

local is_run = true

------------------------------------------------------------
-- === Конфигурация ===
------------------------------------------------------------
local ACCOUNT     = ""
local CLIENT_CODE = ""
local FIRM_ID     = "" 

local    order_type = "LIMIT"
local    time_in_force = "GTC"

local LIMIT_KIND  = 0            -- 0 = по деньгам
local RISK_LIMIT  = -0.02        -- максимум 2% просадки
local LOT_SIZE    = 1

local drop_trigger = 0.001
local take_profit  = 0.002
local stop_loss    = 0.001

local instruments = {
    { class = "TQBR", sec = "SBER" },
    { class = "TQBR", sec = "GAZP" },
    { class = "TQBR", sec = "ROSN" },
}

------------------------------------------------------------
-- === Логирование ===
------------------------------------------------------------

-- Объявляем log_file глобально для скрипта
local log_file; --= getScriptPath() .. "\\robot_capital_risk_log.txt"

-- Функция для логирования
local function log(msg)
    local line = os.date("%Y-%m-%d %H:%M:%S") .. " | " .. msg
    message(line)
    local f = io.open(log_file, "a")
    if f then
        f:write(line .. "\n")
        f:close()
    else
        message("x Не удалось открыть файл для записи: " .. log_file)
    end
end

--[[ ЭЛЕГАНТНАЯ ФУНКЦИЯ ОКРУГЛЕНИЯ удалением ,0]]--
local round = function (num, idp)
    
    -- Если num некорректное, вернуть как есть
    if not num or type(num) ~= "number" then return num end
    -- добавbv обработку очень малых чисел:
    if math.abs(num) < 1e-10 then return 0 end  -- ДОБАВИТЬ
    
    -- Если idp не указан, использовать 0 (округление до целого числа)
    idp = idp or 0 
    local mult = 10^idp

    -- Универсальное Округление для любого числа 
    local rounded = num >= 0 and math.floor(num * mult + 0.5) / mult or num < 0 and math.ceil(num * mult - 0.5) / mult or 0
    
    -- Если число целое, убрать .0
    if rounded == math.floor(rounded) then
        return math.floor(rounded)
    end

    return rounded
end
local function fit(price, step, scale)

  local result = math.floor(price / step) * step;
  log('result = '..tostring(round(result, scale)) );
  return round(result, scale)
end

------------------------------------------------------------
-- === Модуль Risk Manager (по реальному капиталу) ===
------------------------------------------------------------

-- Получаем текущий капитал клиента (денежный баланс в рублях или общие активы)
local function get_current_capital()

--* Свободно - Доступно для вывода средств при сохранении обеспеченности позиций либо открытия позиций по немаржинальным активам, с учетом заблокированных средств под активные заявки, с точностью валюты цены инструмента. Соответствует значению параметра «НаПокупкуНеМаржин» в таблице «Клиентский портфель». Для срочного рынка соответствует значению параметра «План. чист. поз.» в таблице «Ограничения по клиентским счетам» 
-- lim_non_margin STRING Оценка денежных средств, доступных для покупки немаржинальных инструментов 

  if instruments and instruments[1] and instruments[1].class == "TQBR" then
    -- Если не удалось — пробуем через портфель
    local pf = getPortfolioInfoEx(FIRM_ID, CLIENT_CODE, 2)
    if pf and pf.lim_non_margin then
        -- return tonumber(pf.assets)
      --message( "Свободные средства для покупки немаржинальных активов: ".. tostring(pf.lim_non_margin) )
      return tonumber(pf.lim_non_margin)
    end
  end

  if instruments and instruments[1] and instruments[1].class == "SPBFUT" then
   local limits = getLimitInfo(FIRM_ID, CLIENT_CODE)
    if limits and limits["План. чист. поз."] then
        local free_for_futures = tonumber(limits["План. чист. поз."])
        message(string.format("Свободные средства для открытия чистых позиций на срочном рынке: %.2f руб.", free_for_futures))
    else
        message("Не удалось получить информацию о свободных средствах для открытия позиций на срочном рынке.")
    end
  end

    -- Если ничего не удалось получить — вернём nil
    return nil
end

local Risk = {
    start_capital = nil,
    current_capital = nil,
    total_change = 0.0
}
-- Инициализация начального капитала
function Risk:init()
    self.start_capital = get_current_capital()
    if not self.start_capital then
        log("x Не удалось определить начальный капитал!" .. tostring(self.start_capital) )
        self.start_capital = 1
    else
        log(string.format("v Стартовый капитал: %.2f руб.", self.start_capital))
    end
end
-- Проверка текущего состояния
function Risk:check()
    local capital = get_current_capital()
    if not capital then
        coroutine.yield()
        return
    end
    self.current_capital = capital
    self.total_change = (capital - self.start_capital) / self.start_capital
    log(string.format("v Текущий капитал: %.2f руб. (%.2f%%)",
        capital, self.total_change * 100))

    if self.total_change <= RISK_LIMIT then
        log(string.format("v Просадка %.2f%% превысила лимит %.2f%% — остановка торгов!",
            self.total_change * 100, RISK_LIMIT * 100))
        is_run = false
    end
end

------------------------------------------------------------
-- === Отправка заявок ===
------------------------------------------------------------
local function send_order(class, sec, direction, price)
    local order = {
        CLASSCODE   = class,
        SECCODE     = sec,
        ACCOUNT     = ACCOUNT,
        CLIENT_CODE = CLIENT_CODE,
        OPERATION   = direction,
        PRICE       = tostring(price),
        QUANTITY    = tostring(LOT_SIZE),
        TYPE        = "L",
      ACTION      = "NEW_ORDER",
        TRANS_ID    = tostring(math.random(1000000, 9999999))
    }

    local res = sendTransaction(order)
    if res ~= "" then
        log(string.format("[%s] x Ошибка при заявке: %s", sec, res))
    else
        log(string.format("[%s] v %s по %.2f (%d)", sec,
            direction == "B" and "Куплено" or "Продано", price, LOT_SIZE))
    end
end

------------------------------------------------------------
-- === Стратегия по одному инструменту ===
------------------------------------------------------------
local function strategy(class, sec)
    local base_price = nil
    log(string.format("[%s] v Старт стратегии", sec))
    local step = tonumber(getParamEx(class, sec, "sec_price_step").param_value)
    local scale = tonumber(getParamEx(class, sec, "sec_scale").param_value)
    while is_run do
        local price = tonumber(getParamEx(class, sec, "LAST").param_value)
        if not price or price <= 0 then
            coroutine.yield()
        else
            if not base_price then
                base_price = price
                log(string.format("[%s] Базовая цена: %.2f", sec, price))
            end

            while is_run do
                local cur = tonumber(getParamEx(class, sec, "LAST").param_value)
                if cur and cur > 0 then
                    local drop = (cur - base_price) / base_price
                    if drop <= -drop_trigger then
                        log(string.format("[%s] v Падение %.2f%% > Покупка", sec, drop * 100))
                        cur = fit(cur, step, scale)
                        send_order(class, sec, "B", cur)
                        local entry = cur

                        -- Контроль позиции
                        while is_run do
                            local now = tonumber(getParamEx(class, sec, "LAST").param_value)
                            if now then
                                local change = (now - entry) / entry
                                if change >= take_profit then
                                    log(string.format("[%s]  Тейк +%.2f%% > Продажа", sec, change * 100))
                                    now = fit(now, step, scale)
                                    send_order(class, sec, "S", now)
                                    base_price = now
                                    break
                                elseif change <= -stop_loss then
                                    log(string.format("[%s] Стоп %.2f%% > Продажа", sec, change * 100))
                                    now = fit(now, step, scale)
                                    send_order(class, sec, "S", now)
                                    base_price = now
                                    break
                                end
                            end
                            coroutine.yield()
                        end

                        log(string.format("[%s] Позиция закрыта, возвращаемся к ожиданию.", sec))
                        break
                    end
                end
                coroutine.yield()
            end
        end
        coroutine.yield()
    end
    log(string.format("[%s] x Стратегия завершена", sec))
end

------------------------------------------------------------
-- === Менеджер стратегий ===
------------------------------------------------------------
local Manager = {}
Manager.tasks = {}
function Manager:add_strategy(class, sec)
    local co = coroutine.create(function()
        strategy(class, sec)
    end)
    table.insert(self.tasks, {co = co, class = class, sec = sec})
    log(string.format("[%s] v Добавлена стратегия", sec))
end
function Manager:run_all()
    local check_interval = os.time()

    while is_run do
        -- Проверка капитала каждые 5 секунд
        if os.time() - check_interval >= 5 then
            Risk:check()
            check_interval = os.time()
        end

        for _, task in ipairs(self.tasks) do
            local co = task.co
            if coroutine.status(co) == "dead" then
                log(string.format("[%s] Перезапуск стратегии", task.sec))
                task.co = coroutine.create(function()
                    strategy(task.class, task.sec)
                end)
            else
                local ok, err = coroutine.resume(co)
                if not ok then
                    log(string.format("[%s] Ошибка: %s", task.sec, tostring(err)))
                    task.co = coroutine.create(function()
                        strategy(task.class, task.sec)
                    end)
                end
            end
        end
        sleep(300)
    end
    log("x Менеджер остановлен (риск или пользователь).")
end

------------------------------------------------------------
-- === Основной запуск ===
------------------------------------------------------------
function main()
    math.randomseed(os.time())
    log("v Запуск торгового менеджера с реальным риск-контролем...")
    Risk:init()

    for _, inst in ipairs(instruments) do
        Manager:add_strategy(inst.class, inst.sec)
    end

    Manager:run_all()
end

------------------------------------------------------------
-- === Завершение ===
------------------------------------------------------------
function OnStop()
    is_run = false
    log("v Скрипт остановлен пользователем.")
end

function OrderManager:check_timeouts()
    local now = os.time()
    for trans_id, ctx in pairs(self.pool) do
        if ctx.status == "SENT" and now - ctx.timestamp > self.timeout_sec then
            ctx.status = "TIMEOUT"
            log(string.format("[%s] x Таймаут ордера, отправляем отмену", ctx.sec))
            self:cancel(ctx)
        end
    end
end

function OrderManager:cancel(ctx)
    if not ctx.order_num then return end
    local txn = {
        ACCOUNT     = ACCOUNT,
        CLIENT_CODE = CLIENT_CODE,
        CLASSCODE   = ctx.class,
        SECCODE     = ctx.sec,
        ACTION      = "KILL_ORDER",
        ORDER_KEY   = ctx.order_num,
        TRANS_ID    = tostring(math.random(1000000,9999999))
    }
    sendTransaction(txn)
    ctx.status = "CANCELLED"
end

local ctx = {
    sec = "SBER",
    class = "TQBR",
    base_price = nil,
    drop_trigger = 0.002,
    qty = 1
}

local function strategy_tick()
    local price = tonumber(getParamEx(ctx.class, ctx.sec, "LAST").param_value)
    if not price or price <= 0 then return end

    if not ctx.base_price then
        ctx.base_price = price
        return
    end

    local change = (price - ctx.base_price)/ctx.base_price
    if change <= -ctx.drop_trigger then
        OrderManager:send({
            class = ctx.class,
            sec = ctx.sec,
            operation = "B",
            price = price,
            qty = ctx.qty
        })
    elseif change >= ctx.drop_trigger then
        OrderManager:send({
            class = ctx.class,
            sec = ctx.sec,
            operation = "S",
            price = price,
            qty = ctx.qty
        })
    end
end

Tnt={[0]=0}; --таблица активных транзакций  содержит trans_id,jts
Tor={[0]=0}; --таблица активных заявок 1-trans_id 2- номер в таблице QUIK 0-если выставляется , минус на удаление
Tso={[0]=0}; --таблица активных стоп-заявок 1-trans_id 2- номер в таблице QUIK 0-если выставляется , минус на удаление

elseif m==2 then --onOrder
local N=Tor[0]; local flags=t.flags local flag=flags&1; local num=t.order_num; local id=t.trans_id;
for i=1,N do
   local s=Tor[i]; --s,id,js,num
   if s[4]==num or (id~=0 and s[2]==id) then
      if flag==0 then -- заявка не активна удаляем из списка активных если она есть в списке
      if N>1 then Tor[i]=Tor[N] end Tor[N]=nil; Tor[0]=N-1;
      else  --заявка активная записываем ее номер
      s[4]=num --записываем номер новой заявки по транзакции
      if s[3]==0 then s[3]=Nor; Nor=Nor+1 end
      end
   break;
   end  -- заявка в списках
   end
   if flag==1 and id==0 then
   N=N+1; Tor[N]={t.sec_code,0,Nor,num}; Nor=Nor+1 Tor[0]=N;--- активная заявка не найдена заявка выставлена не из скрипта создаем ее
end;   
elseif m==3 then --onStopOrder
local   N=Tso[0]; local flag=t.flags&1;    local num=t.order_num; local id=t.trans_id;
for i=1,N do
   local s=Tso[i]; --s,id,js,num
   if s[2]==id or s[4]==num then
   if flag==0 then -- заяка не активна удаляем из списка активных если она есть в списке
   if N>1 then Tso[i]=Tso[N] end Tso[N]=nil; Tso[0]=N-1;
   else  --заявка активная записываем ее номер
   s[4]=num --записываем номер новой заявки по транзакции
   if s[3]==0 then s[3]=Nso; Nso=Nso+1 end
   end
   break;
   end; -- таблица заявок,стоп-заявок инструмента
end
if flag==1 and id==0 then
N=N+1; Tso[N]={t.sec_code,0,Nso,num}; Nso=Nso+1 Tso[0]=N;--- активная заявка не найдена заявка выставлена не из скрипта создаем ее
end
elseif m==4 then
local x=t.status local msg=t.result_msg;
if x==3 or 2>x or x==15 then return end
   ---удаляем ошибочные транзакции сделок
   message("status="..x..": транзакция "..t_mes[x+1]..">"..msg, 3)
local id=t.trans_id; local s,js;   local N=Tor[0]; --ищем по заявкам
for i=1,N do s=Tor[i]; --s,id,js,num
   if s[2]==id then  js=s[3];
   if js==0 then if N>1 then Tor[i]=Tor[N] end Tor[N]=nil; Tor[0]=N-1; return  --отменяем выставление
   else s[3]=-js; return end -- отменяем удаление
   end
   end
N=Tso[0]; --ищем по стоп-заявкам
for i=1,N do local s=Tso[i]; --s,id,js,num
   if s[2]==id then local js=s[3];
   if js==0 then if N>1 then  Tso[i]=Tso[N]  end Tor[N]=nil; Tor[0]=N-1; return  --отменяем выставление
   else s[3]=-js; return end -- отменяем удаление
   end
end