# Архитектура: Система Ликвидности **Источник:** TradingView Pine Script v6 - ICT Entry V2 [TS_Indie] **Дата создания:** 2026-02-03 --- ## 1. ОБЗОР СИСТЕМЫ ЛИКВИДНОСТИ Система ликвидности определяет уровни, где скапливаются стоп-лоссы. Пробой (sweep) этих уровней активирует торговые условия. **Источник данных:** Liquidity Swings (Len=5, красные точки) ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ ПОТОК ДАННЫХ ЛИКВИДНОСТИ │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ Liquidity Swings (Len=5) │ │ │ │ │ │ Ch_swh=true AND sw_high >= ph │ │ │ Ch_swl=true AND sw_low <= pl │ │ ▼ │ │ ┌─────────────────────┐ ┌─────────────────────┐ │ │ │ lid_sup[] (Supply) │ │ lid_dem[] (Demand) │ │ │ │ lid_bar_sup[] │ │ lid_bar_dem[] │ │ │ │ (Swing Highs) │ │ (Swing Lows) │ │ │ └──────────┬──────────┘ └──────────┬──────────┘ │ │ │ │ │ │ │ high >= lid_sup[0] │ low <= lid_dem[0] │ │ ▼ ▼ │ │ ┌─────────────────────┐ ┌─────────────────────┐ │ │ │ SWEEP SUPPLY │ │ SWEEP DEMAND │ │ │ │ break_sup=true │ │ break_dem=true │ │ │ │ value_sup_lid=... │ │ value_dem_lid=... │ │ │ └──────────┬──────────┘ └──────────┬──────────┘ │ │ │ │ │ │ │ close < value_sup_lid │ close > value_dem_lid │ │ │ open < value_sup_lid │ open > value_dem_lid │ │ ▼ ▼ │ │ ┌─────────────────────┐ ┌─────────────────────┐ │ │ │ con_sell=true │ │ con_buy=true │ │ │ └──────────┬──────────┘ └──────────┬──────────┘ │ │ │ │ │ │ │ + FVG/iFVG условия │ + FVG/iFVG условия │ │ ▼ ▼ │ │ ┌─────────────────────┐ ┌─────────────────────┐ │ │ │ sell_signal=true │ │ buy_signal=true │ │ │ └─────────────────────┘ └─────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## 2. СТРУКТУРЫ ДАННЫХ ### 2.1 Массивы уровней ликвидности | Массив | Тип | Размер | Описание | |--------|-----|--------|----------| | `lid_sup[]` | float | ar_q (9000) | Уровни Supply (Swing Highs) | | `lid_dem[]` | float | ar_q (9000) | Уровни Demand (Swing Lows) | | `lid_bar_sup[]` | int (time) | ar_q | Время уровней Supply | | `lid_bar_dem[]` | int (time) | ar_q | Время уровней Demand | ### 2.2 Массивы линий отображения | Массив | Тип | Размер | Описание | |--------|-----|--------|----------| | `line_lid_s` | line | Lid_show | Активные линии Supply | | `line_lid_d` | line | Lid_show | Активные линии Demand | | `label_lid_s` | label | Lid_show | Метки Supply | | `label_lid_d` | label | Lid_show | Метки Demand | | `mit_lid_s` | line | Lid_ss | Фиксированные линии Supply (история) | | `mit_lid_d` | line | Lid_ss | Фиксированные линии Demand (история) | | `mit_lid_lbl_s` | label | Lid_ss | Метки истории Supply | | `mit_lid_lbl_d` | label | Lid_ss | Метки истории Demand | ### 2.3 Переменные состояния | Переменная | Тип | Описание | |------------|-----|----------| | `break_dem` | bool | Sweep Demand произошёл на этом баре | | `break_sup` | bool | Sweep Supply произошёл на этом баре | | `con_buy` | bool (var) | Условие Buy активно | | `con_sell` | bool (var) | Условие Sell активно | | `value_dem_lid` | float (var) | Значение последнего swept Demand уровня | | `value_sup_lid` | float (var) | Значение последнего swept Supply уровня | | `pre_bar_Dlid_left` | int (var) | Левая временная координата swept Demand | | `pre_bar_Dlid_right` | int (var) | Правая временная координата swept Demand | | `pre_bar_Slid_left` | int (var) | Левая временная координата swept Supply | | `pre_bar_Slid_right` | int (var) | Правая временная координата swept Supply | --- ## 3. ДОБАВЛЕНИЕ УРОВНЕЙ ЛИКВИДНОСТИ **Условия добавления (из tz.md, строки 601-604):** ```pine // Supply уровень (Swing High → lid_sup) if Ch_swh and sw_high >= ph: unshift_remove(lid_sup, sw_high) unshift_remove(lid_bar_sup, time[bar_index - Bar_sw_high]) // Demand уровень (Swing Low → lid_dem) if Ch_swl and sw_low <= pl: unshift_remove(lid_dem, sw_low) unshift_remove(lid_bar_dem, time[bar_index - Bar_sw_low]) ``` **Логика:** - `Ch_swh` = новый Swing High подтверждён (из Liquidity Swings) - `Ch_swl` = новый Swing Low подтверждён - `sw_high >= ph` = swing high на уровне или выше недавнего максимума - `sw_low <= pl` = swing low на уровне или ниже недавнего минимума - `ph` = `ta.highest(Len)` - максимум за последние Len баров - `pl` = `ta.lowest(Len)` - минимум за последние Len баров **Функция unshift_remove:** ```pine unshift_remove(array, new_value) => array.unshift(array, new_value) // Добавить в начало array.remove(array, array.size(array)-1) // Удалить последний ``` --- ## 4. SWEEP ЛОГИКА (ПРОБОЙ ЛИКВИДНОСТИ) ### 4.1 Sweep Demand (tz.md, строки 608-620) ``` УСЛОВИЕ: low <= array.get(lid_dem, 0) (лоу текущего бара касается/пробивает ближайший Demand уровень) АЛГОРИТМ: for i = 0 to ar_q-1: 1. Сохранить значения swept уровня: value_dem_lid := array.get(lid_dem, 0) pre_bar_Dlid_left := array.get(lid_bar_dem, 0) pre_bar_Dlid_right := time 2. Если show_lid включён: - Создать фиксированную линию (история) - Создать метку с текстом txt_lid 3. Удалить уровень из активных массивов: value_delet_Push1(lid_dem, 0) value_delet_Push1(lid_bar_dem, 0) Delete_line_lbl_Push(line_lid_d, label_lid_d, 0) 4. Проверка выхода из цикла: if low > array.get(lid_dem, 0) or na(array.get(lid_dem, 0)): break break_dem := true ``` ### 4.2 Sweep Supply (tz.md, строки 622-634) ``` УСЛОВИЕ: high >= array.get(lid_sup, 0) (хай текущего бара касается/пробивает ближайший Supply уровень) АЛГОРИТМ: for i = 0 to ar_q-1: 1. Сохранить значения swept уровня: value_sup_lid := array.get(lid_sup, 0) pre_bar_Slid_left := array.get(lid_bar_sup, 0) pre_bar_Slid_right := time 2. Если show_lid включён: - Создать фиксированную линию (история) - Создать метку 3. Удалить уровень из активных массивов 4. Проверка выхода из цикла: if high < array.get(lid_sup, 0) or na(array.get(lid_sup, 0)): break break_sup := true ``` **ВАЖНО:** Sweep может пробить НЕСКОЛЬКО уровней за один бар! Цикл продолжается пока текущий лоу/хай пробивает уровни. --- ## 5. АКТИВАЦИЯ ТОРГОВЫХ УСЛОВИЙ ### 5.1 con_buy (tz.md, строки 921-933) ``` АКТИВАЦИЯ: if break_dem AND // Sweep Demand произошёл close > value_dem_lid AND // Закрытие выше swept уровня open > value_dem_lid AND // Открытие выше swept уровня barstate.isconfirmed AND // Бар подтверждён strategy.position_size == 0: // Нет открытой позиции if B_long: // Buy разрешён con_buy := true // Сохранить данные для отрисовки pre_dem_lid := value_dem_lid pre2_bar_Dlid_left := pre_bar_Dlid_left pre2_bar_Dlid_right := pre_bar_Dlid_right con_sell := false // Отменить противоположное условие ДЕАКТИВАЦИЯ: if B_long AND barstate.isconfirmed AND (close < value_dem_lid OR // Цена вернулась под swept уровень (NOT con_time AND con_time[1])): // ИЛИ вышли из торговой сессии con_buy := false ``` ### 5.2 con_sell (tz.md, строки 965-977) ``` АКТИВАЦИЯ: if break_sup AND // Sweep Supply произошёл close < value_sup_lid AND // Закрытие ниже swept уровня open < value_sup_lid AND // Открытие ниже swept уровня barstate.isconfirmed AND strategy.position_size == 0: if S_short: // Sell разрешён con_sell := true pre_sup_lid := value_sup_lid pre2_bar_Slid_left := pre_bar_Slid_left pre2_bar_Slid_right := pre_bar_Slid_right con_buy := false // Отменить противоположное условие ДЕАКТИВАЦИЯ: if S_short AND barstate.isconfirmed AND (close > value_sup_lid OR // Цена вернулась над swept уровень (NOT con_time AND con_time[1])): con_sell := false ``` --- ## 6. ДИАГРАММА СОСТОЯНИЙ con_buy/con_sell ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ ЖИЗНЕННЫЙ ЦИКЛ con_buy │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ ┌────────────────────┐ │ │ │ con_buy = false │ ◀─────────────────────────────────────────────┐ │ │ └──────────┬─────────┘ │ │ │ │ │ │ │ │ break_dem = true │ │ │ │ close > value_dem_lid │ │ │ │ open > value_dem_lid │ │ │ │ position_size == 0 │ │ │ ▼ │ │ │ ┌────────────────────┐ │ │ │ │ con_buy = true │ │ │ │ │ (ожидание iFVG) │──────────────────────────────────────────────┼────│ │ └──────────┬─────────┘ │ │ │ │ │ │ │ ┌─────┴───────────────────────────────────────┐ │ │ │ │ │ │ │ │ ▼ ▼ │ │ │ close < value_dem_lid iFVG условия выполнены │ │ │ ИЛИ вышли из сессии Check_gap_buy = true │ │ │ │ │ │ │ │ │ ▼ │ │ │ │ ┌────────────────────┐ │ │ │ │ │ buy_signal = true │ │ │ │ │ │ con_buy := false │─────┘ │ │ │ └────────────────────┘ │ │ │ │ │ └───────────────────────────────────────────────────────────────────┘ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## 7. ОТРИСОВКА ЛИНИЙ ЛИКВИДНОСТИ ### 7.1 Активные линии (tz.md, строки 636-655) ```pine if show_lid and Turn_off: // Demand линии if not na(array.get(lid_dem, 0)): for i = 0 to Lid_show-1: line.delete(array.get(line_lid_d, i)) label.delete(array.get(label_lid_d, i)) if na(array.get(lid_dem, i)): break x_value = array.get(lid_bar_dem, i) y_value = array.get(lid_dem, i) // Активная линия: от свинга до правого края array.set(line_lid_d, i, line.new( x_value, y_value, time_set, y_value, // time_set = будущее время xloc = xloc.bar_time, color = Lid_color, style = get_line_style(Lid_style))) // Метка справа array.set(label_lid_d, i, label.new( time_lbl, y_value, xloc = xloc.bar_time, text = txt_lid, // "Liq" и т.д. color = TRANSP, textcolor = Lid_txt_color, style = label.style_label_center)) // Supply линии - аналогично ``` ### 7.2 Фиксированные линии (при sweep) ```pine // При sweep Demand (строки 612-615): if show_lid and Turn_off: x_value = array.get(lid_bar_dem, 0) y_value = array.get(lid_dem, 0) bar_lbl = (x_value + time) / 2 // Середина линии // Фиксированная линия (от свинга до момента sweep) Line_mit_unshift(mit_lid_d, line.new( x_value, y_value, time, y_value, // time = текущее время (момент sweep) xloc = xloc.bar_time, color = Lid_color, style = get_line_style(Lid_style))) // Метка в центре линии label_mit_unshift(mit_lid_lbl_d, label.new( bar_lbl, y_value, xloc = xloc.bar_time, text = txt_lid, color = TRANSP, textcolor = Lid_txt_color, style = label.style_label_center)) ``` --- ## 8. ЖИЗНЕННЫЙ ЦИКЛ ЛИНИИ ЛИКВИДНОСТИ ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ ЖИЗНЕННЫЙ ЦИКЛ ЛИНИИ ЛИКВИДНОСТИ │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ 1. СОЗДАНИЕ УРОВНЯ │ │ ──────────────── │ │ Когда: Ch_swh=true AND sw_high >= ph (или Ch_swl для Demand) │ │ Что: unshift_remove(lid_sup, sw_high) │ │ unshift_remove(lid_bar_sup, time) │ │ Результат: Уровень добавлен в массив │ │ │ │ 2. ОТРИСОВКА АКТИВНОЙ ЛИНИИ (каждый бар) │ │ ──────────────────────────────────────── │ │ Условие: show_lid = true │ │ Что: На каждом баре: │ │ - line.delete(старая) + label.delete(старая) │ │ - line.new(time_свинга → time_set) │ │ - label.new(справа) │ │ Результат: Линия продлевается вправо │ │ │ │ 3. SWEEP (пробой) │ │ ────────────── │ │ Условие: low <= lid_dem[0] (или high >= lid_sup[0]) │ │ Что происходит: │ │ a) Сохраняем value_dem_lid, pre_bar_Dlid_left/right │ │ b) Создаём ФИКСИРОВАННУЮ линию (mit_lid_d[]) │ │ - Левый край: время свинга │ │ - Правый край: текущее время (НЕ продлевается!) │ │ c) Удаляем из lid_dem[], lid_bar_dem[] │ │ d) Удаляем активную линию/метку │ │ e) break_dem := true │ │ f) Проверяем следующий уровень (может пробить несколько!) │ │ │ │ 4. ИСТОРИЯ │ │ ───────── │ │ Фиксированные линии хранятся в mit_lid_d[] (размер Lid_ss) │ │ При добавлении новой - самая старая удаляется │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## 9. ПАРАМЕТРЫ КОНФИГУРАЦИИ | Параметр | По умолчанию | Описание | |----------|--------------|----------| | `Len` | 5 | Сила Liquidity Pivot (для определения уровней) | | `Lid_show` | (настр.) | Количество отображаемых активных линий | | `Lid_ss` | (настр.) | Количество линий истории | | `show_lid` | true | Показывать линии ликвидности | | `Lid_color` | (настр.) | Цвет линий ликвидности | | `Lid_style` | (настр.) | Стиль линий | | `txt_lid` | "Liq" | Текст меток | | `Lid_txt_color` | (настр.) | Цвет текста меток | --- ## 10. СВЯЗЬ С ДРУГИМИ МОДУЛЯМИ ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ ARCHITECTURE_SWINGS_BOS_MSS.md ARCHITECTURE_LIQUIDITY.md │ │ ───────────────────────────── ───────────────────────── │ │ │ │ Liquidity Swings (Len=5) ────────► lid_sup[], lid_dem[] │ │ Ch_swh, Ch_swl, sw_high, sw_low │ │ │ │ │ │ Structure Swings (Len_in=10) │ │ │ In_Dir_Big (тренд) ───────────────► up_trend, down_trend │ │ (фильтрация con_buy/sell) │ │ │ │ │ Premium/Discount ─────────────────► EQ_entry_buy/sell │ │ (фильтрация Entry) │ │ │ │ │ ▼ │ │ ARCHITECTURE_FVG.md │ │ ───────────────────── │ │ dfvg[], sfvg[] (FVG) │ │ dfvg_R2[], sfvg_R2[] (iFVG) │ │ │ │ │ ▼ │ │ ARCHITECTURE_ENTRY.md │ │ ────────────────────── │ │ buy_signal, sell_signal │ │ Entry/SL/TP расчёт │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## 11. ПСЕВДОКОД ДЛЯ MQL5 ```cpp // ============ СТРУКТУРЫ ДАННЫХ ============ // Массивы уровней (используем CArrayDouble и CArrayLong) CArrayDouble m_lid_sup; // Supply levels CArrayDouble m_lid_dem; // Demand levels CArrayLong m_lid_bar_sup; // Supply times CArrayLong m_lid_bar_dem; // Demand times // Переменные состояния bool m_break_dem = false; bool m_break_sup = false; bool m_con_buy = false; bool m_con_sell = false; double m_value_dem_lid = 0; double m_value_sup_lid = 0; datetime m_pre_bar_Dlid_left = 0; datetime m_pre_bar_Dlid_right = 0; datetime m_pre_bar_Slid_left = 0; datetime m_pre_bar_Slid_right = 0; // ============ ДОБАВЛЕНИЕ УРОВНЕЙ ============ void AddLiquidityLevels(bool ch_swh, bool ch_swl, double sw_high, double sw_low, datetime bar_sw_high, datetime bar_sw_low, double ph, double pl) { // Supply level (from Swing High) if(ch_swh && sw_high >= ph) { m_lid_sup.InsertSort(sw_high); // Или unshift логика m_lid_bar_sup.InsertSort(bar_sw_high); // Удалить последний если размер > ar_q } // Demand level (from Swing Low) if(ch_swl && sw_low <= pl) { m_lid_dem.InsertSort(sw_low); m_lid_bar_dem.InsertSort(bar_sw_low); } } // ============ SWEEP ЛОГИКА ============ void CheckSweep(double low, double high, datetime time) { m_break_dem = false; m_break_sup = false; // Sweep Demand if(m_lid_dem.Total() > 0 && low <= m_lid_dem[0]) { while(m_lid_dem.Total() > 0 && low <= m_lid_dem[0]) { m_value_dem_lid = m_lid_dem[0]; m_pre_bar_Dlid_left = m_lid_bar_dem[0]; m_pre_bar_Dlid_right = time; // Создать фиксированную линию CreateFixedLiquidityLine(m_pre_bar_Dlid_left, m_value_dem_lid, time, m_value_dem_lid, true); // Удалить из массивов m_lid_dem.Delete(0); m_lid_bar_dem.Delete(0); // Удалить активную линию DeleteActiveLiquidityLine(0, true); } m_break_dem = true; } // Sweep Supply (аналогично) if(m_lid_sup.Total() > 0 && high >= m_lid_sup[0]) { while(m_lid_sup.Total() > 0 && high >= m_lid_sup[0]) { m_value_sup_lid = m_lid_sup[0]; m_pre_bar_Slid_left = m_lid_bar_sup[0]; m_pre_bar_Slid_right = time; CreateFixedLiquidityLine(...); m_lid_sup.Delete(0); m_lid_bar_sup.Delete(0); DeleteActiveLiquidityLine(0, false); } m_break_sup = true; } } // ============ АКТИВАЦИЯ УСЛОВИЙ ============ void CheckConditions(double close, double open, bool is_confirmed, double position_size, bool b_long, bool s_short, bool con_time) { // con_buy активация if(m_break_dem && close > m_value_dem_lid && open > m_value_dem_lid && is_confirmed && position_size == 0) { if(b_long) { m_con_buy = true; // Сохранить pre_dem_lid, pre2_bar_Dlid_left/right } m_con_sell = false; } // con_buy деактивация if(b_long && is_confirmed && (close < m_value_dem_lid || !con_time)) { m_con_buy = false; } // con_sell (аналогично) if(m_break_sup && close < m_value_sup_lid && open < m_value_sup_lid && is_confirmed && position_size == 0) { if(s_short) { m_con_sell = true; } m_con_buy = false; } if(s_short && is_confirmed && (close > m_value_sup_lid || !con_time)) { m_con_sell = false; } } // ============ ОТРИСОВКА ============ void DrawActiveLiquidityLines(datetime time_set) { if(!inp_show_lid) return; // Demand линии for(int i = 0; i < m_lid_dem.Total() && i < inp_lid_show; i++) { double level = m_lid_dem[i]; datetime time_start = m_lid_bar_dem[i]; // Обновить или создать линию UpdateLiquidityLine(i, true, time_start, level, time_set, level); } // Supply линии for(int i = 0; i < m_lid_sup.Total() && i < inp_lid_show; i++) { double level = m_lid_sup[i]; datetime time_start = m_lid_bar_sup[i]; UpdateLiquidityLine(i, false, time_start, level, time_set, level); } } ``` --- ## СЛЕДУЮЩИЕ ШАГИ РЕАЛИЗАЦИИ 1. **Модуль Liquidity Levels** - массивы lid_sup/lid_dem, добавление уровней 2. **Модуль Sweep** - логика пробоя, break_dem/break_sup 3. **Модуль Conditions** - con_buy/con_sell, активация/деактивация 4. **Модуль Drawing** - активные и фиксированные линии 5. **Интеграция** - связь с Swings (входные данные) и FVG (выходные сигналы)