# Архитектура: FVG и iFVG **Источник:** TradingView Pine Script v6 - ICT Entry V2 [TS_Indie] **Дата создания:** 2026-02-03 --- ## 1. КОНЦЕПЦИЯ FVG (Fair Value Gap) **FVG** - это ценовой разрыв между тремя последовательными барами, где средний бар не перекрывается с соседними. ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ DEMAND FVG (бычий) │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ Бар [2] Бар [1] Бар [0] │ │ │ │ │ │ │ │ ┌───────────────────┐│ │ │ │ │ high[0] ││ │ │ │ │ │ ││ │ │ │ │ │ │┼──────── FVG TOP = low[0] │ │ ──────┼────┼────────┼──────────┼│ (нижняя граница текущего бара) │ │ │ │ │ GAP ││ │ │ ──────┼────┼────────┼──────────┼│ │ │ │ │ │ │┼──────── FVG BOTTOM = high[2] │ │ high[2]────┼────────┼──────────┼│ (верхняя граница бара 2) │ │ │ │ │ ││ │ │ │ │ │ ││ │ │ │ └───────────────────┘│ │ │ │ │ УСЛОВИЕ: low[0] > high[2] (текущий лоу выше хая 2 бара назад) │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ┌─────────────────────────────────────────────────────────────────────────────┐ │ SUPPLY FVG (медвежий) │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ Бар [2] Бар [1] Бар [0] │ │ │ │ │ │ │ │ ┌───────────────────┐│ │ │ low[2]────┼────────┼──────────┼┼──────── FVG TOP = low[2] │ │ │ │ │ ││ (нижняя граница бара 2) │ │ ──────┼────┼────────┼──────────┼│ │ │ │ │ │ GAP ││ │ │ ──────┼────┼────────┼──────────┼│ │ │ │ │ │ │┼──────── FVG BOTTOM = high[0] │ │ │ │ high[0] ││ (верхняя граница текущего бара) │ │ │ │ │ ││ │ │ │ │ │ ││ │ │ │ └───────────────────┘│ │ │ │ │ УСЛОВИЕ: high[0] < low[2] (текущий хай ниже лоу 2 бара назад) │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## 2. СТРУКТУРЫ ДАННЫХ FVG ### 2.1 Массивы FVG (обычные) | Массив | Тип | Описание | |--------|-----|----------| | `dfvg_top[]` | float | Верхняя граница Demand FVG (= low[0]) | | `dfvg_bot[]` | float | Нижняя граница Demand FVG (= high[2]) | | `dfvg_bar[]` | int (time) | Время создания FVG | | `dfvg_col[]` | color | Текущий цвет (меняется при частичной митигации) | | `sfvg_top[]` | float | Верхняя граница Supply FVG (= low[2]) | | `sfvg_bot[]` | float | Нижняя граница Supply FVG (= high[0]) | | `sfvg_bar[]` | int (time) | Время создания | | `sfvg_col[]` | color | Текущий цвет | ### 2.2 Pre-Inversion FVG (промежуточные - кандидаты на iFVG) | Массив | Тип | Описание | |--------|-----|----------| | `dfvg_R_top[]` | float | Копия dfvg_top (для отслеживания инверсии) | | `dfvg_R_bot[]` | float | Копия dfvg_bot | | `dfvg_bar_R[]` | int | Время | | `sfvg_R_top[]` | float | Копия sfvg_top | | `sfvg_R_bot[]` | float | Копия sfvg_bot | | `sfvg_bar_R[]` | int | Время | ### 2.3 iFVG (Inversion FVG - ОСНОВНЫЕ для входа!) | Массив | Тип | Описание | |--------|-----|----------| | `dfvg_R2_top[]` | float | Верхняя граница Demand iFVG | | `dfvg_R2_bot[]` | float | Нижняя граница Demand iFVG | | `dfvg_bar_R2[]` | int | Время создания | | `d_i_fvg_col[]` | color | Цвет | | `sfvg_R2_top[]` | float | Верхняя граница Supply iFVG | | `sfvg_R2_bot[]` | float | Нижняя граница Supply iFVG | | `sfvg_bar_R2[]` | int | Время создания | | `s_i_fvg_col[]` | color | Цвет | --- ## 3. ЖИЗНЕННЫЙ ЦИКЛ FVG ### 3.1 Создание FVG (tz.md строки 272-298) **Demand FVG:** ```pine // Условие: low > high[2] (неявное, через проверку массива) value_unshift(dfvg_top, low, dfvg_bot, high[2], dfvg_bar, time[2]) add_int_unshift(dfvg_col, Col_fvg_d) value_unshift(dfvg_R_top, low, dfvg_R_bot, high[2], dfvg_bar_R, time[2]) // Копия для iFVG ``` **Supply FVG:** ```pine value_unshift(sfvg_top, low[2], sfvg_bot, high, sfvg_bar, time[2]) add_int_unshift(sfvg_col, Col_fvg_s) value_unshift(sfvg_R_top, low[2], sfvg_R_bot, high, sfvg_bar_R, time[2]) // Копия для iFVG ``` ### 3.2 Митигация FVG (удаление при пробое) **Demand FVG митигируется когда:** `low <= dfvg_bot[0]` ```pine if low <= array.get(dfvg_bot, 0): for i = 0 to qty_fvg-1: // Создать фиксированный box (история) add_array_unshift(d_fvg_mit, box.new(...)) // Удалить из активных value_remove(dfvg_top, dfvg_bot, dfvg_bar, 0) array.remove(dfvg_col, 0) Delete_Box_Push(d_fvg_zone, 0) if low > array.get(dfvg_bot, 0) or na(...): break ``` **Supply FVG митигируется когда:** `high >= sfvg_top[0]` ### 3.3 Частичная митигация (изменение цвета) ```pine // Demand FVG частично затронут: if low <= array.get(dfvg_top, 0): // Цена коснулась TOP for i = 0 to qty_fvg-1: if low <= array.get(dfvg_top, i): array.set(dfvg_col, i, Col_fvg_mit) // Меняем цвет на "mitigated" ``` --- ## 4. КОНЦЕПЦИЯ iFVG (Inversion FVG) **iFVG** - это FVG, который был ПРОБИТ ЗАКРЫТИЕМ и "перевернулся": - Supply FVG → Demand iFVG (когда close > sfvg_top) - Demand FVG → Supply iFVG (когда close < dfvg_bot) ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ ИНВЕРСИЯ: Supply FVG → Demand iFVG │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ ДО инверсии: ПОСЛЕ инверсии: │ │ │ │ ┌─────────────┐ sfvg_top ┌─────────────┐ dfvg_R2_top │ │ │ │ │ │ │ │ │ SUPPLY FVG │ ─────────────► │ DEMAND iFVG │ │ │ │ (медвежий) │ │ (бычий) │ │ │ │ │ │ │ │ │ └─────────────┘ sfvg_bot └─────────────┘ dfvg_R2_bot │ │ │ │ Условие инверсии: close > sfvg_R_top[0] │ │ (закрытие ВЫШЕ верхней границы Supply FVG) │ │ │ │ ВАЖНО: только close! Тень (wick) НЕ считается! │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## 5. ЛОГИКА СОЗДАНИЯ iFVG (tz.md строки 357-391) ### 5.1 Demand iFVG (из Supply FVG) ```pine // Условие: close ПРОБИВАЕТ Supply FVG вверх if close > array.get(sfvg_R_top, 0) and barstate.isconfirmed: for i = 0 to qty_fvg-1: if close > array.get(sfvg_R_top, 0): // Копируем Supply FVG в Demand iFVG value_unshift(dfvg_R2_top, array.get(sfvg_R_top, 0), dfvg_R2_bot, array.get(sfvg_R_bot, 0), dfvg_bar_R2, array.get(sfvg_bar_R, 0)) add_int_unshift(d_i_fvg_col, Col_ifvg_d) // Удаляем из Pre-Inversion value_remove(sfvg_R_top, sfvg_R_bot, sfvg_bar_R, 0) if close <= array.get(sfvg_R_top, 0) or na(...): break ``` ### 5.2 Supply iFVG (из Demand FVG) ```pine // Условие: close ПРОБИВАЕТ Demand FVG вниз if close < array.get(dfvg_R_bot, 0) and barstate.isconfirmed: for i = 0 to qty_fvg-1: if close < array.get(dfvg_R_bot, 0): // Копируем Demand FVG в Supply iFVG value_unshift(sfvg_R2_top, array.get(dfvg_R_top, 0), sfvg_R2_bot, array.get(dfvg_R_bot, 0), sfvg_bar_R2, array.get(dfvg_bar_R, 0)) add_int_unshift(s_i_fvg_col, Col_ifvg_s) // Удаляем из Pre-Inversion value_remove(dfvg_R_top, dfvg_R_bot, dfvg_bar_R, 0) ``` --- ## 6. МИТИГАЦИЯ iFVG **Demand iFVG митигируется когда:** `low <= dfvg_R2_bot[0]` **Supply iFVG митигируется когда:** `high >= sfvg_R2_top[0]` --- ## 7. ПОТОК ДАННЫХ FVG → iFVG ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ ПОТОК ДАННЫХ FVG → iFVG │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ ┌──────────────────┐ │ │ │ Создание FVG │ low > high[2] (Demand) или high < low[2] (Supply) │ │ └────────┬─────────┘ │ │ │ │ │ ▼ │ │ ┌──────────────────┐ ┌──────────────────┐ │ │ │ dfvg/sfvg │ ────► │ dfvg_R/sfvg_R │ (копия для отслеживания) │ │ │ (активные FVG) │ │ (Pre-Inversion) │ │ │ └────────┬─────────┘ └────────┬─────────┘ │ │ │ │ │ │ │ │ close пробивает FVG │ │ │ ▼ │ │ │ ┌──────────────────┐ │ │ │ │ dfvg_R2/sfvg_R2 │ (iFVG - для Entry!) │ │ │ │ (Inversion) │ │ │ │ └────────┬─────────┘ │ │ │ │ │ │ ▼ ▼ │ │ ┌──────────────────┐ ┌──────────────────┐ │ │ │ Митигация │ │ Митигация │ │ │ │ low <= dfvg_bot │ │ low <= dfvg_R2_bot│ │ │ │ high >= sfvg_top │ │ high >= sfvg_R2_top │ │ └──────────────────┘ └──────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## 8. ИСПОЛЬЗОВАНИЕ iFVG В ENTRY CONDITIONS (tz.md строки 935-991) ### 8.1 Buy Signal (con_buy + Check_gap_buy) ```pine // Условие: iFVG существует И swept Demand уровень НИЖЕ iFVG if not na(array.get(dfvg_R2_bot, 0)) and value_dem_lid < array.get(dfvg_R2_bot, 0) and up_trend: // 1. Расчёт GAP между iFVG и FVG FVG_gap_buy := math.abs(array.get(dfvg_R2_top, 0) - array.get(dfvg_bot, 0)) // iFVG TOP FVG BOTTOM // 2. Проверка GAP в допустимых пределах Con_gap_buy = FVG_gap_buy >= atr_check_FVG_min and FVG_gap_buy <= atr_check_FVG_max // 3. Если con_buy активен И GAP валиден: if con_buy[1] and Con_gap_buy: // 4. Premium/Discount фильтр EQ_entry_buy = Follow_trend and EQ_con ? (array.get(dfvg_R2_bot, 0) <= Discount and array.get(dfvg_R2_bot, 0) >= Discount2) : true // 5. Фильтр размера FVG Size_FVG_dem = math.abs(array.get(dfvg_top, 0) - array.get(dfvg_bot, 0)) size_FVG_con_dem = not Filter_size_FVG or (Filter_size_FVG and Size_FVG_dem >= Check_min_FVG and Size_FVG_dem <= Check_max_FVG) // 6. Фильтр размера iFVG Size_iFVG_dem = math.abs(array.get(dfvg_R2_top, 0) - array.get(dfvg_R2_bot, 0)) size_iFVG_con_dem = not Filter_size_iFVG or (Filter_size_iFVG and Size_iFVG_dem >= Check_min_iFVG and Size_iFVG_dem <= Check_max_iFVG) // 7. Фильтр взаимного расположения FVG и iFVG con_mix_dem = Con_FVG_mix ? true : (not iFVG_be_FVG ? array.get(dfvg_bot, 0) >= array.get(dfvg_R2_top, 0) : // FVG выше iFVG array.get(dfvg_bot, 0) < array.get(dfvg_R2_top, 0)) // FVG ниже iFVG // 8. Финальная проверка if EQ_entry_buy and size_FVG_con_dem and size_iFVG_con_dem and con_mix_dem: Check_gap_buy := true ``` ### 8.2 Sell Signal (аналогично) ```pine if not na(array.get(sfvg_R2_top, 0)) and value_sup_lid > array.get(sfvg_R2_top, 0) and down_trend: FVG_gap_sell := math.abs(array.get(sfvg_R2_bot, 0) - array.get(sfvg_top, 0)) // ... аналогичные проверки ... if all_conditions: Check_gap_sell := true ``` --- ## 9. РАСЧЁТ ENTRY И STOP LOSS (tz.md строки 1054, 1071) **Для Buy:** ```pine sl_cal_long = array.get(dfvg_R2_bot, 0) // SL = нижняя граница iFVG entry_b = array.get(dfvg_R2_top, 0) // Entry = верхняя граница iFVG ``` **Для Sell:** ```pine sl_cal_short = array.get(sfvg_R2_top, 0) // SL = верхняя граница iFVG entry_s = array.get(sfvg_R2_bot, 0) // Entry = нижняя граница iFVG ``` --- ## 10. ДИАГРАММА РАСПОЛОЖЕНИЯ FVG И iFVG ДЛЯ BUY ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ BUY SETUP: FVG + iFVG │ ├─────────────────────────────────────────────────────────────────────────────┤ │ │ │ Вариант 1: FVG ВЫШЕ iFVG (iFVG_be_FVG = false) │ │ ───────────────────────────────────────────── │ │ │ │ ┌─────────────┐ ← dfvg_top (FVG верх) │ │ │ │ │ │ │ DEMAND FVG │ │ │ │ │ │ │ └─────────────┘ ← dfvg_bot (FVG низ) │ │ ↑ │ │ │ GAP (FVG_gap_buy) │ │ │ Должен быть >= atr_check_FVG_min И <= atr_check_FVG_max │ │ ↓ │ │ ┌─────────────┐ ← dfvg_R2_top (iFVG верх) ═══ ENTRY │ │ │ │ │ │ │ DEMAND iFVG │ │ │ │ │ │ │ └─────────────┘ ← dfvg_R2_bot (iFVG низ) ═══ STOP LOSS │ │ │ │ │ │ Вариант 2: FVG НИЖЕ iFVG (iFVG_be_FVG = true) │ │ ───────────────────────────────────────────── │ │ │ │ ┌─────────────┐ ← dfvg_R2_top (iFVG верх) ═══ ENTRY │ │ │ │ │ │ │ DEMAND iFVG │ │ │ │ │ │ │ └─────────────┘ ← dfvg_R2_bot (iFVG низ) ═══ STOP LOSS │ │ ↑ │ │ │ GAP │ │ ↓ │ │ ┌─────────────┐ ← dfvg_top (FVG верх) │ │ │ │ │ │ │ DEMAND FVG │ │ │ │ │ │ │ └─────────────┘ ← dfvg_bot (FVG низ) │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## 11. ПАРАМЕТРЫ КОНФИГУРАЦИИ FVG/iFVG | Параметр | По умолчанию | Описание | |----------|--------------|----------| | `fibo_entry` | 0 | Entry Zone внутри iFVG (0-100%) | | `iFVG_be_FVG` | false | Режим: iFVG перекрывает FVG | | `Con_FVG_mix` | false | Смешанный режим (оба варианта) | | `FVG_min_ATR` | 0.01 | Минимальный GAP (x ATR) | | `FVG_max_ATR` | 0.2 | Максимальный GAP (x ATR) | | `Filter_size_FVG` | false | Фильтр размера FVG | | `FVG_min` | 0.1 | Минимальный размер FVG (x ATR) | | `FVG_max` | 0.5 | Максимальный размер FVG (x ATR) | | `Filter_size_iFVG` | false | Фильтр размера iFVG | | `iFVG_min` | 0.1 | Минимальный размер iFVG (x ATR) | | `iFVG_max` | 0.5 | Максимальный размер iFVG (x ATR) | --- ## 12. СВЯЗЬ С ДРУГИМИ МОДУЛЯМИ ``` ┌─────────────────────────────────────────────────────────────────────────────┐ │ │ │ ARCHITECTURE_SWINGS_BOS_MSS.md │ │ ───────────────────────────── │ │ In_Dir_Big (тренд) ──────────────► up_trend / down_trend │ │ Premium/Discount ────────────────► EQ_entry_buy / EQ_entry_sell │ │ │ │ ARCHITECTURE_LIQUIDITY.md │ │ ───────────────────────── │ │ value_dem_lid ───────────────────► Проверка: value_dem_lid < dfvg_R2_bot │ │ value_sup_lid ───────────────────► Проверка: value_sup_lid > sfvg_R2_top │ │ con_buy / con_sell ──────────────► Условие активации Check_gap │ │ │ │ │ │ │ ▼ │ │ │ │ ARCHITECTURE_FVG.md (этот файл) │ │ ─────────────────────────────── │ │ dfvg_R2_top/bot ─────────────────► Entry / Stop Loss (Buy) │ │ sfvg_R2_top/bot ─────────────────► Entry / Stop Loss (Sell) │ │ Check_gap_buy / Check_gap_sell ──► buy_signal / sell_signal │ │ │ │ │ │ │ ▼ │ │ │ │ ARCHITECTURE_ENTRY.md │ │ ───────────────────── │ │ buy_signal / sell_signal │ │ Entry/SL/TP расчёт │ │ │ └─────────────────────────────────────────────────────────────────────────────┘ ``` --- ## 13. ПСЕВДОКОД ДЛЯ MQL5 ```cpp // ============ СТРУКТУРЫ ДАННЫХ FVG ============ // FVG массивы CArrayDouble m_dfvg_top, m_dfvg_bot; // Demand FVG CArrayDouble m_sfvg_top, m_sfvg_bot; // Supply FVG CArrayLong m_dfvg_bar, m_sfvg_bar; // Время // Pre-Inversion FVG CArrayDouble m_dfvg_R_top, m_dfvg_R_bot; CArrayDouble m_sfvg_R_top, m_sfvg_R_bot; CArrayLong m_dfvg_bar_R, m_sfvg_bar_R; // iFVG (Inversion) CArrayDouble m_dfvg_R2_top, m_dfvg_R2_bot; // Demand iFVG CArrayDouble m_sfvg_R2_top, m_sfvg_R2_bot; // Supply iFVG CArrayLong m_dfvg_bar_R2, m_sfvg_bar_R2; // ============ СОЗДАНИЕ FVG ============ void CheckAddFVG(int i, double low_cur, double high_cur, double low_2, double high_2, datetime time_2) { // Demand FVG: low[0] > high[2] if(low_cur > high_2) { UnshiftArray(m_dfvg_top, low_cur); UnshiftArray(m_dfvg_bot, high_2); UnshiftArray(m_dfvg_bar, time_2); // Копия для Pre-Inversion UnshiftArray(m_dfvg_R_top, low_cur); UnshiftArray(m_dfvg_R_bot, high_2); UnshiftArray(m_dfvg_bar_R, time_2); } // Supply FVG: high[0] < low[2] if(high_cur < low_2) { UnshiftArray(m_sfvg_top, low_2); UnshiftArray(m_sfvg_bot, high_cur); UnshiftArray(m_sfvg_bar, time_2); UnshiftArray(m_sfvg_R_top, low_2); UnshiftArray(m_sfvg_R_bot, high_cur); UnshiftArray(m_sfvg_bar_R, time_2); } } // ============ МИТИГАЦИЯ FVG ============ void CheckFVGMitigation(double low, double high) { // Demand FVG митигация while(m_dfvg_bot.Total() > 0 && low <= m_dfvg_bot[0]) { // Создать фиксированный box (история) CreateMitigatedFVGBox(m_dfvg_bar[0], m_dfvg_top[0], m_dfvg_bot[0], true); // Удалить m_dfvg_top.Delete(0); m_dfvg_bot.Delete(0); m_dfvg_bar.Delete(0); } // Supply FVG митигация while(m_sfvg_top.Total() > 0 && high >= m_sfvg_top[0]) { CreateMitigatedFVGBox(m_sfvg_bar[0], m_sfvg_top[0], m_sfvg_bot[0], false); m_sfvg_top.Delete(0); m_sfvg_bot.Delete(0); m_sfvg_bar.Delete(0); } } // ============ СОЗДАНИЕ iFVG ============ void CheckCreateIFVG(double close, bool is_confirmed) { if(!is_confirmed) return; // Demand iFVG (из Supply FVG): close > sfvg_R_top while(m_sfvg_R_top.Total() > 0 && close > m_sfvg_R_top[0]) { // Копируем Supply → Demand iFVG UnshiftArray(m_dfvg_R2_top, m_sfvg_R_top[0]); UnshiftArray(m_dfvg_R2_bot, m_sfvg_R_bot[0]); UnshiftArray(m_dfvg_bar_R2, m_sfvg_bar_R[0]); // Удаляем из Pre-Inversion m_sfvg_R_top.Delete(0); m_sfvg_R_bot.Delete(0); m_sfvg_bar_R.Delete(0); } // Supply iFVG (из Demand FVG): close < dfvg_R_bot while(m_dfvg_R_bot.Total() > 0 && close < m_dfvg_R_bot[0]) { UnshiftArray(m_sfvg_R2_top, m_dfvg_R_top[0]); UnshiftArray(m_sfvg_R2_bot, m_dfvg_R_bot[0]); UnshiftArray(m_sfvg_bar_R2, m_dfvg_bar_R[0]); m_dfvg_R_top.Delete(0); m_dfvg_R_bot.Delete(0); m_dfvg_bar_R.Delete(0); } } // ============ МИТИГАЦИЯ iFVG ============ void CheckIFVGMitigation(double low, double high) { // Demand iFVG митигация while(m_dfvg_R2_bot.Total() > 0 && low <= m_dfvg_R2_bot[0]) { CreateMitigatedIFVGBox(m_dfvg_bar_R2[0], m_dfvg_R2_top[0], m_dfvg_R2_bot[0], true); m_dfvg_R2_top.Delete(0); m_dfvg_R2_bot.Delete(0); m_dfvg_bar_R2.Delete(0); } // Supply iFVG митигация while(m_sfvg_R2_top.Total() > 0 && high >= m_sfvg_R2_top[0]) { CreateMitigatedIFVGBox(m_sfvg_bar_R2[0], m_sfvg_R2_top[0], m_sfvg_R2_bot[0], false); m_sfvg_R2_top.Delete(0); m_sfvg_R2_bot.Delete(0); m_sfvg_bar_R2.Delete(0); } } // ============ CHECK GAP BUY ============ bool CheckGapBuy(double value_dem_lid, double atr_sl) { if(m_dfvg_R2_bot.Total() == 0) return false; if(m_dfvg_bot.Total() == 0) return false; if(value_dem_lid >= m_dfvg_R2_bot[0]) return false; if(!m_up_trend) return false; // GAP между iFVG top и FVG bottom double gap = MathAbs(m_dfvg_R2_top[0] - m_dfvg_bot[0]); double gap_min = atr_sl * inp_fvg_min_atr; double gap_max = atr_sl * inp_fvg_max_atr; if(gap < gap_min || gap > gap_max) return false; // Premium/Discount filter if(inp_follow_trend && inp_eq_con) { if(m_dfvg_R2_bot[0] > m_discount || m_dfvg_R2_bot[0] < m_discount2) return false; } // Size FVG filter if(inp_filter_size_fvg) { double size_fvg = MathAbs(m_dfvg_top[0] - m_dfvg_bot[0]); double check_min = inp_fvg_min * atr_sl; double check_max = inp_fvg_max * atr_sl; if(size_fvg < check_min || size_fvg > check_max) return false; } // Size iFVG filter if(inp_filter_size_ifvg) { double size_ifvg = MathAbs(m_dfvg_R2_top[0] - m_dfvg_R2_bot[0]); double check_min = inp_ifvg_min * atr_sl; double check_max = inp_ifvg_max * atr_sl; if(size_ifvg < check_min || size_ifvg > check_max) return false; } // Mix condition if(!inp_con_fvg_mix) { if(!inp_ifvg_be_fvg) { // FVG должен быть выше iFVG if(m_dfvg_bot[0] < m_dfvg_R2_top[0]) return false; } else { // FVG должен быть ниже iFVG if(m_dfvg_bot[0] >= m_dfvg_R2_top[0]) return false; } } return true; } // ============ CHECK GAP SELL ============ bool CheckGapSell(double value_sup_lid, double atr_sl) { if(m_sfvg_R2_top.Total() == 0) return false; if(m_sfvg_top.Total() == 0) return false; if(value_sup_lid <= m_sfvg_R2_top[0]) return false; if(!m_down_trend) return false; // GAP между iFVG bottom и FVG top double gap = MathAbs(m_sfvg_R2_bot[0] - m_sfvg_top[0]); double gap_min = atr_sl * inp_fvg_min_atr; double gap_max = atr_sl * inp_fvg_max_atr; if(gap < gap_min || gap > gap_max) return false; // Premium/Discount filter if(inp_follow_trend && inp_eq_con) { if(m_sfvg_R2_top[0] < m_premium || m_sfvg_R2_top[0] > m_premium2) return false; } // Size filters (аналогично) // Mix condition (аналогично) return true; } // ============ ENTRY/SL РАСЧЁТ ============ void CalculateEntryLong(double &entry, double &sl) { // Entry = верхняя граница iFVG entry = m_dfvg_R2_top[0]; // SL = нижняя граница iFVG sl = m_dfvg_R2_bot[0]; // Корректировка Entry по fibo_entry if(inp_fibo_entry > 0) { double size = entry - sl; entry = sl + size * (inp_fibo_entry / 100.0); } } void CalculateEntryShort(double &entry, double &sl) { // Entry = нижняя граница iFVG entry = m_sfvg_R2_bot[0]; // SL = верхняя граница iFVG sl = m_sfvg_R2_top[0]; // Корректировка Entry по fibo_entry if(inp_fibo_entry > 0) { double size = sl - entry; entry = sl - size * (inp_fibo_entry / 100.0); } } ``` --- ## СЛЕДУЮЩИЕ ШАГИ РЕАЛИЗАЦИИ 1. **Модуль FVG Detection** - определение Demand/Supply FVG 2. **Модуль Pre-Inversion** - отслеживание FVG для инверсии 3. **Модуль iFVG** - создание и митигация iFVG 4. **Модуль Check Gap** - проверка условий для Entry 5. **Интеграция** - связь с Liquidity (value_dem_lid, con_buy) и Entry (buy_signal)