VPM (Все сообщения пользователя)

function Trading:allocate_money_for_trading()
    local total_active_capital = self:get_active_capital()  -- Общее количество активных средств
    local total_tickers = self:get_number_of_tickers()      -- Количество активных тикеров
    
    local capital_per_ticker = total_active_capital / total_tickers
    
    -- Для каждого тикера выделяем средства
    for i = 1, total_tickers do
        self:allocate_ticker_capital(i, capital_per_ticker)
    end
end

function Trading:allocate_ticker_capital(ticker_id, amount)
    -- Логика выделения средств для конкретного тикера
    log_info(string.format("Для тикера %d выделено %.2f средств на торговлю.", ticker_id, amount))
    -- Дополнительная логика управления средствами для конкретного тикера...
end

function Trading:allocate_money_based_on_risk()
    local total_active_capital = self:get_active_capital()
    local ticker_risks = self:get_ticker_risks()  -- Структура риска для каждого тикера
    
    -- Распределяем капитал пропорционально рискам
    for i, risk in ipairs(ticker_risks) do
        local capital_for_ticker = self:calculate_risk_adjusted_capital(total_active_capital, risk)
        self:allocate_ticker_capital(i, capital_for_ticker)
    end
end

function Trading:calculate_risk_adjusted_capital(total_capital, risk)
    -- Логика расчета капитала с учетом рисков
    return total_capital * (1 - risk)
end

function Trading:reallocate_capital_based_on_market_conditions()
    local total_active_capital = self:get_active_capital()
    local market_conditions = self:get_market_conditions() -- Получаем текущие рыночные условия
    
    for i, condition in ipairs(market_conditions) do
        if condition == "high_volatility" then
            self:reduce_capital_for_ticker(i)
        elseif condition == "stable_market" then
            self:increase_capital_for_ticker(i)
        end
    end
end

function Trading:reduce_capital_for_ticker(ticker_id)
    -- Логика уменьшения капитала для данного тикера
    log_info(string.format("Уменьшаем капитал для тикера %d из-за высокой волатильности.", ticker_id))
end

function Trading:increase_capital_for_ticker(ticker_id)
    -- Логика увеличения капитала для данного тикера
    log_info(string.format("Увеличиваем капитал для тикера %d из-за стабильного рынка.", ticker_id))
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

OrderManager = {
    pool = {},       -- все активные ордера по TRANS_ID
    timeout_sec = 10 -- время ожидания исполнения
}

-- контекст ордера
local order_ctx = {
    trans_id   = "12345", -- уникальный локальный ID
    class      = "TQBR",
    sec        = "SBER",
    operation  = "B",     -- B / S
    price      = 123.45,
    qty        = 1,
    status     = "NEW",   -- NEW / SENT / PARTIALLY_FILLED / FILLED / CANCELLED / REJECTED / TIMEOUT
    order_num  = nil,     -- номер заявки на сервере QUIK
    trades     = {},      -- массив исполненных частей
    timestamp  = os.time()
}

function OrderManager:send(order)
    local trans_id = tostring(math.random(1000000,9999999))
    order.trans_id = trans_id
    order.status = "NEW"
    order.timestamp = os.time()
    self.pool[trans_id] = order

    local txn = {
        ACCOUNT     = ACCOUNT,
        CLIENT_CODE = CLIENT_CODE,
        CLASSCODE   = order.class,
        SECCODE     = order.sec,
        ACTION      = "NEW_ORDER",
        OPERATION   = order.operation,
        PRICE       = tostring(order.price),
        QUANTITY    = tostring(order.qty),
        TYPE        = "L",
        TRANS_ID    = trans_id
    }

    local result = sendTransaction(txn)
    if result ~= "" then
        log(string.format("[%s] x Ошибка отправки: %s", order.sec, result))
        order.status = "REJECTED"
        return false
    else
        order.status = "SENT"
        log(string.format("[%s] v Ордер отправлен (TRANS_ID=%s)", order.sec, trans_id))
        return true
    end
end

function OnTransReply(tr)
    local ctx = OrderManager.pool[tr.trans_id]
    if not ctx then return end

    if tr.status == 3 then
        ctx.order_num = tr.order_num
        log(string.format("[%s] v Ордер принят биржей (order_num=%s)", ctx.sec, ctx.order_num))
    elseif tr.status >= 4 then
        ctx.status = "REJECTED"
        log(string.format("[%s] x Ордер отклонен: %s", ctx.sec, tr.result_msg))
        OrderManager.pool[tr.trans_id] = nil
    end
end

function OnOrder(ord)
    for _, ctx in pairs(OrderManager.pool) do
        if ctx.order_num and ctx.order_num == ord.order_num then
            ctx.balance = ord.balance
            if ctx.balance == 0 then
                ctx.status = "FILLED"
                log(string.format("[%s] v Ордер полностью исполнен", ctx.sec))
            elseif ord.balance < ctx.qty then
                ctx.status = "PARTIALLY_FILLED"
                log(string.format("[%s] v Частичное исполнение: %d/%d", ctx.sec, ctx.qty-ord.balance, ctx.qty))
            end
        end
    end
end

function OnTrade(trade)
    for _, ctx in pairs(OrderManager.pool) do
        if ctx.order_num and ctx.order_num == trade.order_num then
            table.insert(ctx.trades, {
                trade_num = trade.trade_num,
                qty       = trade.qty,
                price     = trade.price,
                dir       = trade.flags % 2 == 0 and "B" or "S"
            })
        end
    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 main()
    threads[1] = coroutine.create(function() worker("A", 2) end)
    threads[2] = coroutine.create(function() worker("B", 5) end)

    while is_run do
        for _, co in ipairs(threads) do
            if coroutine.status(co) ~= "dead" then
                coroutine.resume(co)
            end
        end
        sleep(200)
    end
end

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

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 — она живёт, имеет собственный контекст и исполняется пошагово.

--- Рабочий пример фонового скрипта QUIK с корутиной
local is_run = true  -- глобальный флаг для остановки фоновой задачи

function main()
    message("Скрипт запущен. Идёт фоновое измерение производительности...")

    -- создаём корутину (фоновую задачу)
    local co = coroutine.create(worker)

    -- основной цикл QUIK
    while is_run do
        local ok, err = coroutine.resume(co)
        if not ok then
            message("Ошибка в корутине: " .. tostring(err))
            break
        end
        sleep(1000) -- основной поток спит 1 сек между циклами
    end

    message("Скрипт остановлен.")
end

-- фоновая функция
function worker()
    local N = 100000
    local c, f = 0, 0

    local function foo()
        f = f + 1
    end

    local co_task = coroutine.create(function()
        while true do
            c = c + 1
            coroutine.yield()
        end
    end)

    while is_run do
        local TT1 = os.clock()
        for i = 1, N do
            local ok, err = coroutine.resume(co_task)
            if not ok then
                message("Ошибка в co_task: " .. tostring(err))
                break
            end
        end
        TT1 = (os.clock() - TT1) * 1000

        local TT2 = os.clock()
        for i = 1, N do
            foo()
        end
        TT2 = (os.clock() - TT2) * 1000

        local out = string.format(
            "Фон: N=%d, coroutine=%.3f мс (c=%d), func=%.3f мс (f=%d), T1/T2=%.2f",
            N, TT1, c, TT2, f, TT1 / TT2
        )
        message(out)

        sleep(3000) -- измерение каждые 3 секунды
    end
end

function OnStop()
    is_run = false
    message("Останавливаем фоновую задачу...")
end

Вывод:
   TYPE   DATE   TIME   MESSAGE
1   1   29.10.2025   10:31:19   Скрипт запущен. Идёт фоновое измерение производительности...
2   1   29.10.2025   10:31:20   Фон: N=100000, coroutine=584.000 мс (c=100000), func=6.000 мс (f=100000), T1/T2=97.33
3   1   29.10.2025   10:31:23   Фон: N=100000, coroutine=604.000 мс (c=200000), func=7.000 мс (f=200000), T1/T2=86.29
4   1   29.10.2025   10:31:27   Фон: N=100000, coroutine=586.000 мс (c=300000), func=7.000 мс (f=300000), T1/T2=83.71
5   1   29.10.2025   10:31:30   Фон: N=100000, coroutine=553.000 мс (c=400000), func=7.000 мс (f=400000), T1/T2=79.00
6   1   29.10.2025   10:31:34   Фон: N=100000, coroutine=614.000 мс (c=500000), func=7.000 мс (f=500000), T1/T2=87.71
7   1   29.10.2025   10:31:38   Фон: N=100000, coroutine=550.000 мс (c=600000), func=7.000 мс (f=600000), T1/T2=78.57
8   1   29.10.2025   10:31:41   Фон: N=100000, coroutine=555.000 мс (c=700000), func=7.000 мс (f=700000), T1/T2=79.29
9   1   29.10.2025   10:31:45   Фон: N=100000, coroutine=544.000 мс (c=800000), func=6.000 мс (f=800000), T1/T2=90.67
10   1   29.10.2025   10:31:45   Останавливаем фоновую задачу...
11   1   29.10.2025   10:31:49   Скрипт остановлен.

--[[Помним!
Время работы корутин в QUIK может зависеть от множества факторов: 
* нагрузки платформы, 
* количества исполняющихся скриптов, 
* задержек в сети
 и так далее.
--]]

-- Переписанный пример с использованием корутин и пустой функции в QUIK в формате кода Lua:

--local message = message or print;
local run = true

function main()

   local N = 100000
   local c,f = 0,0
   -- создаем корутину, которая будет выполнять асинхронную задачу
   local co = coroutine.create(function()
      local yield = coroutine.yield
      while true do
         -- можно выполнять любую логику
       c = c + 1
         yield()  -- здесь задача будет приостанавливаться
      end
   end)

   -- простая функция, которая ничего не делает
   local function foo1() 
        f = f + 1
        return f
   end

   local out = 'Результат теста: количество вызовов = ' .. N .. ', время вызова сопрограммы '
   while true do
        
      -- замер времени для корутины
        local TT1 = os.clock()
        for i = 1, N do
            local ok, err = coroutine.resume(co)  -- возобновляем выполнение корутины
            if not ok then
                message("Ошибка при выполнении корутины: " .. err)
                break
            end
        end
        TT1 = (os.clock() - TT1) * 1000
      message("TT1: " .. TT1 .."; c = " .. c)

        -- замер времени для обычной функции
        local TT2 = os.clock()
        for i = 1, N do
            foo1()
        end
      TT2 = (os.clock() - TT2) * 1000
      message("TT2: " .. TT2 .."; f = " .. f)

        -- вывод результата
        out = out .. string.format("%.3f мс, функции %.3f мс, T1/T2 = %.2f", TT1, TT2, TT1 / TT2)
        message(out)
         return
   end
   run = false

end

Результаты у одного брокера:
   TYPE   DATE   TIME   MESSAGE
1   1   29.10.2025   9:47:15   TT1: 555.00000000029; c = 100000
2   1   29.10.2025   9:47:15   TT2: 7.9999999998108; f = 100000
3   1   29.10.2025   9:47:15   Результат теста: количество вызовов = 100000, время вызова сопрограммы 555.000 мс, функции 8.000 мс, T1/T2 = 69.38