alexnik90/Ind_Aleks_ICT_Entry_V2_TS_Indie
1
0
포크 0
코드 이슈 풀 리퀘스트 Projects 릴리즈 Packages 위키 활동 Actions
Ind_Aleks_ICT_Entry_V2_TS_I.../ARCHITECTURE_FVG.md

705 lines
36 KiB
Markdown
Raw 고유링크 Normal View 히스토리

new files added
2026-02-10 21:54:56 +03:00
# Архитектура: 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)
Reference in a new issue Copy permalink