← К каталогу
Исходный код · ID 4979

Gold Session Liquidity Free MT5

gold_session_liquidity_free_mt5 (1).mq5

Похожие материалы по тегам

indicator crt with smc levels for tradingview.pineTradingView · 1 общих теговconfluenceforge_pro.mq5TradingView · 1 общих теговidentical candles.mq5MQL5 / MetaTrader 5 · 1 общих теговbattleplan_ciclo_3_tempi.mq4MQL4 / MetaTrader 4 · 1 общих теговvolatility_gold_master.mq5MQL5 / MetaTrader 5 · 1 общих теговfx sniper ergodic cci trigger alert fast mtf arrows_v1 nmc.mq5MQL5 / MetaTrader 5 · 1 общих тегов
Вы автор или правообладатель?

Сообщите нам, если считаете, что материал размещён без разрешения.

Краткий обзор

О программе

Gold Session Liquidity Free MT5 — бесплатный аналитический индикатор для XAUUSD в MetaTrader 5, отслеживающий торговые сессии (Азия, Лондон, Нью-Йорк), выявляющий закрытые свечные ликвидностные заборы и пробои свинг-структуры, а также включающий ручной калькулятор рисков. Все расчёты основаны исключительно на данных OHLC; индикатор не анализирует реальный стакан ордеров. Подтверждение сигналов производится только по закрытым барам, формирующийся бар не используется.

Индикатор отображает на графике 17 буферов: стрелки подтверждённых BUY/SELL, линии завершённого азиатского диапазона, маркеры ликвидностных заборов и пробоев, а также оценку качества сигнала 0–100. Встроенная панель показывает текущее состояние сессии, направление тренда (EMA быстрая/медленная), последние заборы и пробои, бюджет риска и рекомендуемый лот для ручного планирования.

Торговые сигналы (BUY/SELL) и отображение плана сделки отключены по умолчанию и требуют явной активации в настройках. Индикатор работает на указанном таймфрейме с использованием истории более высокого таймфрейма для определения тренда. Все входные параметры имеют проверку допустимых диапазонов при инициализации.

Настройки программы

НастройкаОписание
BrokerClock Режим интерпретации временной метки брокера: фиксированный смещение UTC или летнее/зимнее время ЕС.
BrokerWinterUTCOffsetHours Смещение серверного времени от UTC зимой (типично UTC+2 зимой, UTC+3 летом).
AsianStartUTCHour Час начала азиатской сессии в UTC.
AsianEndUTCHour Час окончания азиатской сессии в UTC (диапазон [00:00, 06:00)).
TradeLondon Учитывать лондонскую сессию при определении активной торговой сессии.
TradeNewYork Учитывать нью-йоркскую сессию при определении активной торговой сессии.
TradeAsia Учитывать азиатскую сессию при определении активной торговой сессии.
UseAsianLiquidity Использовать завершённый азиатский диапазон как уровень ликвидности при обнаружении забора.
ShowAsianRange Отображать линии завершённого азиатского диапазона (High/Low) на графике.
SwingStrength Количество баров по обе стороны от пивота для подтверждения свинг-вершины/дна.
MaxSwingAge Максимальный возраст свинга в барами при поиске опорного уровня.
RequireFreshLevel Требовать, чтобы опорный свинг-уровень не был пробит в промежуточных барах.
MinSweepPoints Минимальное расстояние забора уровня в пунктах (минимум от ATR и этого значения).
MinSweepToATR Минимальное расстояние забора в кратностях ATR.
MinRejectionWickPct Минимальный процент фитильной части свечи от диапазона для распознавания реjection (отклонения).
MinCloseLocationPct Минимальное расположение закрытия внутри свечи в процентах от диапазона (для распознавания реjection).
StructureLookback Количество баров после забора для определения уровня структуры (уровень должен быть до забора, без опережения).
MSSConfirmBars Количество закрытых баров после забора, в течение которых должен подтвердиться пробой структуры.
EqualLevelATR Множитель ATR для определения равных уровней при оценке качества забора.
MeanTrueRangePeriod Период расчёта среднего истинного диапазона (ATR-эквивалент).
MinBarRangeToATR Минимальное соотношение диапазона бара к ATR для прохождения фильтра волатильности.
MaxBarRangeToATR Максимальное допустимое соотношение диапазона бара к ATR для фильтра волатильности.
MaxSpreadToATR Максимальное соотножение спреда к ATR; 0 отключает проверку спреда (доступно при наличии истории спреда).
MinRecordedSpreadPoints Минимальное значение зафиксированного спреда в пунктах; 0 отключает минимальную проверку.
RequireRecordedSpread Требовать наличие зафиксированной истории спреда для прохождения проверки.
FilterChoppyMarkets Включить фильтрацию бокового рынка по коэффициенту эффективности.
EfficiencyLookback Количество баров для расчёта коэффициента эффективности движения цены.
MinEfficiencyRatio Минимальный коэффициент эффективности для прохождения фильтра бокового рынка.
TrendTimeframe Таймфрейм для расчёта тренда (EMA быстрая/медленная).
TrendFastEMA Период быстрой EMA для определения направления тренда.
TrendSlowEMA Период медленной EMA для определения направления тренда.
RequireTrendAlignment Требовать совпадения направления тренда с направлением сигнала (фильтр тренда).
MinimumSignalScore Минимальная оценка качества сигнала (0–100) для отображения торгового сигнала.
StopBufferATR Буфер стоп-лосса в кратностях ATR за экстремумом забора.
MaxStopDistanceATR Максимальное расстояние стоп-лосса в кратностях ATR от экстремума забора.
Target1R Первое целевое соотношение риск/прибыль (в кратностях R).
Target2R Второе целевое соотношение риск/прибыль (в кратностях R).
Target3R Третье целевое соотношение риск/прибыль (в кратностях R).
MaxBarsToScan Максимальное количество баров для сканирования при расчёте.
ShowDashboard Отображать информационную панель на графике.
ShowCurrentTradePlan Отображать линии плана текущей сделки (вход, стоп, тейки) на графике. Исследовательский оверлей, отключён по умолчанию.
MaximumDisplayPlanAgeBars Максимальное количество баров, в пределах которого отображается план сделки на графике.
InstanceID Идентификатор экземпляра индикатора для различения нескольких копий на одном графике.
DashboardX Горизонтальное положение панели от левого верхнего угла графика (в пикселях).
DashboardY Вертикальное положение панели от левого верхнего угла графика (в пикселях).
DashboardBackground Цвет фона информационной панели на графике.
DashboardForeground Цвет текста информационной панели на графике.
ShowLiquiditySweeps Отображать маркеры ликвидностных заборов (Low/High sweep) на графике.
ShowStructureBreaks Отображать маркеры пробоев свинг-структуры (Break Up/Break Down) на графике.
ShowExperimentalSignals Включить отображение экспериментальных сигналов BUY/SELL и плана сделки. Не валидированы, отключены по умолчанию.
ShowManualRiskPlanner Включить ручной калькулятор рисков с расчётом лота в панели.
RiskBudgetPercent Процент от баланса счёта, выделяемый под риск для ручного калькулятора.
ManualEntryPrice Уровень входа для ручного калькулятора рисков (0.0 — отключено).
ManualStopPrice Уровень стоп-лосса для ручного калькулятора рисков (0.0 — отключено).
ManualTargetPrice Уровень тейк-профита для иллюстрации соотношения риск/прибыль (0.0 — без расчёта R:R).
CommissionPerLotRoundTrip Оценка комиссии за полный оборот лота в валюте счёта.
PopupAlerts Включить всплывающие уведомления-алерты на графике.
PushAlerts Включить push-уведомления на мобильное устройство.
SoundAlerts Включить звуковые уведомления при появлении нового сигнала.

Поиск по коду файла

#property strict

#property version   "1.100"
#property description "FREE XAUUSD analysis: sessions, closed-bar liquidity sweeps, swing breaks and risk planner. Experimental trading signals off by default."
#property indicator_chart_window
#property indicator_buffers 17
#property indicator_plots 17
#property indicator_label1  "Confirmed BUY"
#property indicator_type1   DRAW_ARROW
#property indicator_color1  clrLimeGreen
#property indicator_width1  2
#property indicator_label2  "Confirmed SELL"
#property indicator_type2   DRAW_ARROW
#property indicator_color2  clrTomato
#property indicator_width2  2
#property indicator_label3  "Completed Asian High"
#property indicator_type3   DRAW_LINE
#property indicator_color3  clrDarkOrange
#property indicator_style3  STYLE_DOT
#property indicator_label4  "Completed Asian Low"
#property indicator_type4   DRAW_LINE
#property indicator_color4  clrDeepSkyBlue
#property indicator_style4  STYLE_DOT

#property indicator_label14 "Liquidity sweep LOW (reclaimed)"
#property indicator_type14 DRAW_ARROW
#property indicator_color14 clrLimeGreen
#property indicator_width14 1
#property indicator_label15 "Liquidity sweep HIGH (rejected)"
#property indicator_type15 DRAW_ARROW
#property indicator_color15 clrTomato
#property indicator_width15 1
#property indicator_label16 "Confirmed swing break UP"
#property indicator_type16 DRAW_ARROW
#property indicator_color16 clrDeepSkyBlue
#property indicator_width16 1
#property indicator_label17 "Confirmed swing break DOWN"
#property indicator_type17 DRAW_ARROW
#property indicator_color17 clrOrange

enum ENUM_GSLP_BROKER_TIME
  {
   BROKER_FIXED_UTC = 0,         // Fixed server offset all year
   BROKER_EU_DST = 1             // Winter UTC+N; summer UTC+N+1
  };

input group "01 | Session clock (historical broker timestamps)"
input ENUM_GSLP_BROKER_TIME BrokerClock = BROKER_EU_DST;
input int    BrokerWinterUTCOffsetHours = 2; // Typical UTC+2 winter, +3 summer
input int    AsianStartUTCHour          = 0;
input int    AsianEndUTCHour            = 6; // Completed Asia range, [00:00,06:00)
input bool   TradeLondon                = true;
input bool   TradeNewYork               = true;
input bool   TradeAsia                  = false;
input bool   UseAsianLiquidity          = true;
input bool   ShowAsianRange             = true;

input group "02 | Liquidity and MSS confirmation"
input int    SwingStrength              = 3;
input int    MaxSwingAge                = 90;
input bool   RequireFreshLevel          = true;
input int    MinSweepPoints             = 10;
input double MinSweepToATR              = 0.10;
input double MinRejectionWickPct         = 20.0;
input double MinCloseLocationPct        = 55.0;
input int    StructureLookback          = 12; // Before sweep; no lookahead
input int    MSSConfirmBars             = 6;  // Strictly AFTER sweep bar
input double EqualLevelATR             = 0.12;

input group "03 | Market filters and setup score"
input int    MeanTrueRangePeriod        = 14;
input double MinBarRangeToATR           = 0.30;
input double MaxBarRangeToATR           = 3.50;
input double MaxSpreadToATR             = 0.15; // 0 disables, only if spread history known
input int    MinRecordedSpreadPoints    = 0;    // 0 disables minimum
input bool   RequireRecordedSpread      = false;
input bool   FilterChoppyMarkets        = true;
input int    EfficiencyLookback         = 12;
input double MinEfficiencyRatio         = 0.15;
input ENUM_TIMEFRAMES TrendTimeframe    = PERIOD_H1;
input int    TrendFastEMA               = 20;
input int    TrendSlowEMA               = 50;
input bool   RequireTrendAlignment      = false; // Context is scored regardless
input int    MinimumSignalScore         = 65;

input group "04 | Trade plan and presentation"
input double StopBufferATR              = 0.15;
input double MaxStopDistanceATR         = 3.50;
input double Target1R                   = 1.0;
input double Target2R                   = 2.0;
input double Target3R                   = 3.0;
input int    MaxBarsToScan              = 900;
input bool   ShowDashboard              = true;
input bool   ShowCurrentTradePlan       = false; // Research-only overlay, off by default
input int    MaximumDisplayPlanAgeBars  = 24; // Hide outdated chart trade lines
input string InstanceID                 = "GSLF"; // Different ID if multiple copies on chart
input int    DashboardX                 = 16;
input int    DashboardY                 = 26;
input color  DashboardBackground        = C'19,28,42';
input color  DashboardForeground        = clrWhiteSmoke;
input group "05 | Free analysis overlays (non-trading)"
input bool   ShowLiquiditySweeps        = true;
input bool   ShowStructureBreaks        = true;
input bool   ShowExperimentalSignals    = false; // UNVALIDATED research only
input group "06 | Manual broker-aware risk calculator"
input bool   ShowManualRiskPlanner      = true;
input double RiskBudgetPercent          = 0.50; // % of account equity
input double ManualEntryPrice           = 0.0;  // Set both entry and stop manually
input double ManualStopPrice            = 0.0;
input double ManualTargetPrice          = 0.0;  // Optional R:R illustration
input double CommissionPerLotRoundTrip  = 7.0;  // Estimated account currency/lot
input bool   PopupAlerts                = false;
input bool   PushAlerts                 = false;
input bool   SoundAlerts                = false;

double BuyArrow[],SellArrow[],AsiaHighLine[],AsiaLowLine[];
double BuySL[],SellSL[],BuyTP1[],SellTP1[],BuyTP2[],SellTP2[],BuyTP3[],SellTP3[],Quality[];
double LowSweepMark[],HighSweepMark[],BreakUpMark[],BreakDownMark[];
datetime g_lastOpening=0,g_lastAlert=0;
int g_fastHandle=INVALID_HANDLE,g_slowHandle=INVALID_HANDLE;
double g_fastEMA[],g_slowEMA[];
bool g_trendReady=false;
string g_prefix="";

datetime UTCStamp(const int y,const int m,const int d,const int hh=0)
  {
   MqlDateTime x;
   ZeroMemory(x);
   x.year=y; x.mon=m; x.day=d; x.hour=hh;
   return(StructToTime(x));
  }
int WeekdayOf(const int y,const int m,const int d)
  {
   MqlDateTime x; TimeToStruct(UTCStamp(y,m,d),x); return(x.day_of_week);
  }
int LastSundayOf31(const int y,const int m)
  {return(31-WeekdayOf(y,m,31));}
int FirstSunday(const int y,const int m)
  {return(1+(7-WeekdayOf(y,m,1))%7);}
bool EuropeDST(const datetime utc)
  {
   MqlDateTime x; TimeToStruct(utc,x);
   const datetime begin=UTCStamp(x.year,3,LastSundayOf31(x.year,3),1);
   const datetime end=UTCStamp(x.year,10,LastSundayOf31(x.year,10),1);
   return(utc>=begin && utc<end);
  }
bool UnitedStatesDST(const datetime utc)
  {
   MqlDateTime x; TimeToStruct(utc,x);
   const datetime begin=UTCStamp(x.year,3,FirstSunday(x.year,3)+7,7);
   const datetime end=UTCStamp(x.year,11,FirstSunday(x.year,11),6);
   return(utc>=begin && utc<end);
  }
datetime BrokerToUTC(const datetime server)
  {

   const datetime winterUTC=server-BrokerWinterUTCOffsetHours*3600;
   if(BrokerClock==BROKER_FIXED_UTC) return(winterUTC);
   const datetime summerUTC=winterUTC-3600;
   if(EuropeDST(summerUTC)) return(summerUTC);
   return(winterUTC);
  }
int UTCDayKey(const datetime utc)
  {
   MqlDateTime x; TimeToStruct(utc,x);
   return(x.year*1000+x.day_of_year);
  }
int UTCHour(const datetime utc)
  {
   MqlDateTime x; TimeToStruct(utc,x); return(x.hour);
  }

int SessionMask(const datetime utc)
  {
   MqlDateTime x;TimeToStruct(utc,x);
   if(x.day_of_week==0 || x.day_of_week==6) return(0);
   const int minOfDay=x.hour*60+x.min;
   const int londonOpen=(EuropeDST(utc)?7:8)*60;
   const int newYorkOpen=(UnitedStatesDST(utc)?12:13)*60;
   int mask=0;
   if(minOfDay>=AsianStartUTCHour*60 && minOfDay<AsianEndUTCHour*60) mask|=1;
   if(minOfDay>=londonOpen && minOfDay<londonOpen+8*60) mask|=2;
   if(minOfDay>=newYorkOpen && minOfDay<newYorkOpen+9*60) mask|=4;
   return(mask);
  }
bool IsTradingSession(const datetime utc)
  {
   int mask=SessionMask(utc);
   return((TradeAsia && (mask&1)!=0) || (TradeLondon && (mask&2)!=0) ||
          (TradeNewYork && (mask&4)!=0));
  }
string SessionName(const datetime utc)
  {
   const int mask=SessionMask(utc);
   if((mask&2)!=0 && (mask&4)!=0) return("LONDON + NEW YORK");
   if((mask&4)!=0) return("NEW YORK");
   if((mask&2)!=0) return("LONDON");
   if((mask&1)!=0) return("ASIA");
   return("OUTSIDE SESSIONS");
  }

bool PivotHigh(const int j,const int bars,const double &h[])
  {
   if(j-SwingStrength<1 || j+SwingStrength>=bars) return(false);
   for(int n=1;n<=SwingStrength;n++)
      if(h[j]<=h[j-n] || h[j]<h[j+n]) return(false);
   return(true);
  }
bool PivotLow(const int j,const int bars,const double &l[])
  {
   if(j-SwingStrength<1 || j+SwingStrength>=bars) return(false);
   for(int n=1;n<=SwingStrength;n++)
      if(l[j]>=l[j-n] || l[j]>l[j+n]) return(false);
   return(true);
  }
int FindFreshPivot(const bool highs,const int i,const int bars,
                   const double &h[],const double &l[])
  {
   const int first=i+SwingStrength+1;
   const int last=(int)MathMin(i+MaxSwingAge,bars-SwingStrength-1);
   if(first>last) return(-1);
   double priorHi=-DBL_MAX,priorLo=DBL_MAX;
   if(RequireFreshLevel)
      for(int k=i+1;k<first;k++)
        {priorHi=MathMax(priorHi,h[k]);priorLo=MathMin(priorLo,l[k]);}
   for(int j=first;j<=last;j++)
     {
      const bool isPivot=highs?PivotHigh(j,bars,h):PivotLow(j,bars,l);
      if(isPivot && (!RequireFreshLevel ||
         (highs?priorHi<=h[j]+0.01*_Point:priorLo>=l[j]-0.01*_Point)))
         return(j);
      if(RequireFreshLevel)
        {priorHi=MathMax(priorHi,h[j]);priorLo=MathMin(priorLo,l[j]);}
     }
   return(-1);
  }
double MeanTrueRangeBefore(const int i,const int bars,const double &h[],
                           const double &l[],const double &c[])
  {
   if(i+MeanTrueRangePeriod+1>=bars) return(-1.0);
   double total=0.0;
   for(int k=i+1;k<=i+MeanTrueRangePeriod;k++)
     {
      double a=h[k]-l[k],b=MathAbs(h[k]-c[k+1]),d=MathAbs(l[k]-c[k+1]);
      total+=MathMax(a,MathMax(b,d));
     }
   return(total/MeanTrueRangePeriod);
  }
double EfficiencyBefore(const int i,const int bars,const double &c[])
  {
   if(i+EfficiencyLookback+1>=bars) return(-1.0);
   double traveled=0.0;
   for(int k=i+1;k<=i+EfficiencyLookback;k++) traveled+=MathAbs(c[k]-c[k+1]);
   if(traveled<_Point*0.01) return(0.0);
   return(MathAbs(c[i+1]-c[i+EfficiencyLookback+1])/traveled);
  }
bool Rejects(const bool bullish,const int i,const double &o[],
             const double &h[],const double &l[],const double &c[])
  {
   const double range=h[i]-l[i]; if(range<=0.0) return(false);
   const double wick=bullish?MathMin(o[i],c[i])-l[i]:h[i]-MathMax(o[i],c[i]);
   const double location=bullish?(c[i]-l[i])/range:(h[i]-c[i])/range;
   return(wick/range*100.0+1e-9>=MinRejectionWickPct &&
          location*100.0+1e-9>=MinCloseLocationPct);
  }

bool CompletedAsianRange(const int i,const int bars,const datetime &time[],
                         const double &h[],const double &l[],
                         double &hi,double &lo)
  {
   const datetime utc=BrokerToUTC(time[i]);
   if(UTCHour(utc)<AsianEndUTCHour) return(false);
   const int day=UTCDayKey(utc);
   hi=-DBL_MAX;lo=DBL_MAX;
   int count=0;
   for(int k=i+1;k<bars;k++)
     {
      const datetime older=BrokerToUTC(time[k]);
      if(UTCDayKey(older)!=day) break;
      const int hh=UTCHour(older);
      if(hh>=AsianStartUTCHour && hh<AsianEndUTCHour)
        {hi=MathMax(hi,h[k]);lo=MathMin(lo,l[k]);count++;}
     }
   return(count>=2 && hi>lo);
  }

bool HasEqualPartner(const bool highs,const int pivot,const int bars,
                     const double &h[],const double &l[],
                     const double tolerance)
  {
   if(pivot<0 || tolerance<=0.0) return(false);
   const int last=(int)MathMin(bars-SwingStrength-1,pivot+MaxSwingAge);
   for(int j=pivot+SwingStrength+1;j<=last;j++)
     {
      if(highs && PivotHigh(j,bars,h) && MathAbs(h[j]-h[pivot])<=tolerance) return(true);
      if(!highs && PivotLow(j,bars,l) && MathAbs(l[j]-l[pivot])<=tolerance) return(true);
     }
   return(false);
  }

struct SweepSetup
  {
   bool bullish;
   bool asianLevel;
   bool equalLevel;
   int  bar;
   double level;
   double extreme;
   double structure;
   double mtr;
  };

bool DetectSweep(const bool bullish,const int k,const int bars,
                 const datetime &time[],const double &o[],
                 const double &h[],const double &l[],const double &c[],
                 SweepSetup &s)
  {
   const datetime utc=BrokerToUTC(time[k]);
   if(!IsTradingSession(utc)) return(false);
   if(k+StructureLookback+1>=bars) return(false);
   const double mtr=MeanTrueRangeBefore(k,bars,h,l,c);
   if(mtr<=0.0 || !Rejects(bullish,k,o,h,l,c)) return(false);
   const double penetration=MathMax(MinSweepPoints*_Point,MinSweepToATR*mtr);
   const int pv=FindFreshPivot(!bullish,k,bars,h,l);
   double swing=-1.0;
   if(pv>=0) swing=(bullish?l[pv]:h[pv]);
   double asiaHi=0.0,asiaLo=0.0;
   const bool hasAsia=UseAsianLiquidity && CompletedAsianRange(k,bars,time,h,l,asiaHi,asiaLo);
   const double asian=hasAsia?(bullish?asiaLo:asiaHi):0.0;
   const bool swingPass=(pv>=0 &&
       (bullish?(l[k]<swing-penetration && c[k]>swing):
                (h[k]>swing+penetration && c[k]<swing)));
   const bool asiaPass=(hasAsia &&
       (bullish?(l[k]<asian-penetration && c[k]>asian):
                (h[k]>asian+penetration && c[k]<asian)));
   if(!swingPass && !asiaPass) return(false);
   s.bullish=bullish;
   s.bar=k;
   s.asianLevel=asiaPass;
   s.level=asiaPass?asian:swing;
   s.equalLevel=(!asiaPass && HasEqualPartner(!bullish,pv,bars,h,l,mtr*EqualLevelATR));
   s.extreme=bullish?l[k]:h[k];
   s.mtr=mtr;
   double structure=bullish?-DBL_MAX:DBL_MAX;
   for(int j=k+1;j<=k+StructureLookback;j++)
      structure=bullish?MathMax(structure,h[j]):MathMin(structure,l[j]);
   s.structure=structure;

   if(bullish && c[k]>=structure) return(false);
   if(!bullish && c[k]<=structure) return(false);
   return(true);
  }

bool ConfirmMSS(const bool bullish,const int i,const SweepSetup &s,
                const double &h[],const double &l[],const double &c[],
                double &extreme)
  {
   if(bullish ? c[i]<=s.structure : c[i]>=s.structure) return(false);
   extreme=s.extreme;
   for(int j=s.bar-1;j>=i;j--)
     {
      if(j>i && (bullish?c[j]>s.structure:c[j]<s.structure)) return(false);
      extreme=bullish?MathMin(extreme,l[j]):MathMax(extreme,h[j]);

      if(bullish && l[j]<s.extreme-0.10*s.mtr) return(false);
      if(!bullish && h[j]>s.extreme+0.10*s.mtr) return(false);
     }
   return(true);
  }

bool PrepareTrend(const int bars,const datetime &time[])
  {
   g_trendReady=false;
   if(g_fastHandle==INVALID_HANDLE || g_slowHandle==INVALID_HANDLE) return(false);
   const int oldest=(int)MathMin(MaxBarsToScan+MSSConfirmBars+2,bars-1);
   const int sh=iBarShift(_Symbol,TrendTimeframe,time[oldest],false);
   if(sh<0) return(false);
   const int need=sh+3;
   if(CopyBuffer(g_fastHandle,0,0,need,g_fastEMA)<need ||
      CopyBuffer(g_slowHandle,0,0,need,g_slowEMA)<need) return(false);
   ArraySetAsSeries(g_fastEMA,true);
   ArraySetAsSeries(g_slowEMA,true);
   g_trendReady=true;
   return(true);
  }
int TrendDirection(const datetime when)
  {
   if(!g_trendReady) return(0);
   const int shift=iBarShift(_Symbol,TrendTimeframe,when,false)+1;
   if(shift<1 || shift>=ArraySize(g_fastEMA) || shift>=ArraySize(g_slowEMA)) return(0);
   if(g_fastEMA[shift]>g_slowEMA[shift]) return(1);
   if(g_fastEMA[shift]<g_slowEMA[shift]) return(-1);
   return(0);
  }

bool PassSignalFilters(const int i,const int bars,const int &spread[],
                       const double &h[],const double &l[],const double &c[],
                       double &mtr,double &efficiency,string &reason)
  {
   reason="OK";
   mtr=MeanTrueRangeBefore(i,bars,h,l,c);
   if(mtr<=0.0) {reason="MTR HISTORY";return(false);}
   const double range=(h[i]-l[i])/mtr;
   if(range<MinBarRangeToATR || range>MaxBarRangeToATR)
     {reason="VOLATILITY";return(false);}
   if(spread[i]>0 && MaxSpreadToATR>0.0 && spread[i]*_Point>MaxSpreadToATR*mtr)
     {reason="SPREAD";return(false);}
   if(RequireRecordedSpread && spread[i]<=0)
     {reason="SPREAD UNKNOWN";return(false);}
   if(spread[i]>0 && spread[i]<MinRecordedSpreadPoints)
     {reason="SPREAD INVALID";return(false);}
   efficiency=EfficiencyBefore(i,bars,c);
   if(efficiency<0.0) {reason="EFFICIENCY HISTORY";return(false);}
   if(FilterChoppyMarkets && efficiency<MinEfficiencyRatio)
     {reason="CHOPPY";return(false);}
   return(true);
  }
int SignalScore(const int i,const bool bullish,const SweepSetup &s,
                const datetime &time[],const double &o[],const double &h[],const double &l[],
                const double &c[],const int trendDir)
  {
   int score=40;  // confirmed sweep (20) + first confirmed MSS (20)
   const double full=MathMax(h[s.bar]-l[s.bar],_Point);
   const double wick=bullish?MathMin(o[s.bar],c[s.bar])-l[s.bar]:
                           h[s.bar]-MathMax(o[s.bar],c[s.bar]);
   if(wick/full>=0.35) score+=10;
   else if(wick/full>=0.22) score+=6;
   if(s.asianLevel) score+=10;
   else if(s.equalLevel) score+=8;
   else score+=5;
   const int mask=SessionMask(BrokerToUTC(time[i]));
   if((mask&2)!=0 && (mask&4)!=0) score+=15;
   else if((mask&6)!=0) score+=12;
   else score+=5;
   if(trendDir==(bullish?1:-1)) score+=15;
   else if(trendDir==0) score+=5;
   const double barRange=MathMax(h[i]-l[i],_Point);
   const double closeLocation=bullish?(c[i]-l[i])/barRange:(h[i]-c[i])/barRange;
   if(closeLocation>=0.75) score+=10;
   else if(closeLocation>=0.60) score+=5;
   if(s.bar-i<=3) score+=5;
   return((int)MathMin(100,score));
  }

struct TradeSignal
  {
   bool bullish;
   int score;
   int sweepBar;
   bool fromAsia;
   double level;
   double structure;
   double entry;
   double stop;
   double tp1;
   double tp2;
   double tp3;
  };

bool FindTrade(const bool bullish,const int i,const int bars,
               const datetime &time[],const double &o[],
               const double &h[],const double &l[],const double &c[],
               const int &spread[],TradeSignal &result)
  {
   if(!IsTradingSession(BrokerToUTC(time[i]))) return(false);
   double mtr,efficiency; string reject;
   if(!PassSignalFilters(i,bars,spread,h,l,c,mtr,efficiency,reject)) return(false);
   const int trend=TrendDirection(time[i]);
   if(RequireTrendAlignment && trend!=(bullish?1:-1)) return(false);
   for(int k=i+1;k<=i+MSSConfirmBars && k<bars;k++)
     {
      SweepSetup s;
      if(!DetectSweep(bullish,k,bars,time,o,h,l,c,s)) continue;
      double extreme;
      if(!ConfirmMSS(bullish,i,s,h,l,c,extreme)) continue;
      const double stop=bullish?(extreme-StopBufferATR*mtr):(extreme+StopBufferATR*mtr);
      const double risk=bullish?c[i]-stop:stop-c[i];
      if(risk<0.25*mtr || risk>MaxStopDistanceATR*mtr) continue;
      const int score=SignalScore(i,bullish,s,time,o,h,l,c,trend);
      if(score<MinimumSignalScore) continue;
      result.bullish=bullish;
      result.score=score;
      result.sweepBar=k;
      result.fromAsia=s.asianLevel;
      result.level=s.level;
      result.structure=s.structure;
      result.entry=c[i];
      result.stop=NormalizeDouble(stop,_Digits);
      const double direction=bullish?1.0:-1.0;
      result.tp1=NormalizeDouble(c[i]+direction*Target1R*risk,_Digits);
      result.tp2=NormalizeDouble(c[i]+direction*Target2R*risk,_Digits);
      result.tp3=NormalizeDouble(c[i]+direction*Target3R*risk,_Digits);
      return(true); // most recent qualifying sweep; avoids multiple signals
     }
   return(false);
  }

void ClearBar(const int i)
  {
   BuyArrow[i]=EMPTY_VALUE;SellArrow[i]=EMPTY_VALUE;
   AsiaHighLine[i]=EMPTY_VALUE;AsiaLowLine[i]=EMPTY_VALUE;
   BuySL[i]=EMPTY_VALUE;SellSL[i]=EMPTY_VALUE;
   BuyTP1[i]=EMPTY_VALUE;SellTP1[i]=EMPTY_VALUE;
   BuyTP2[i]=EMPTY_VALUE;SellTP2[i]=EMPTY_VALUE;
   BuyTP3[i]=EMPTY_VALUE;SellTP3[i]=EMPTY_VALUE;
   Quality[i]=EMPTY_VALUE;
   LowSweepMark[i]=EMPTY_VALUE;HighSweepMark[i]=EMPTY_VALUE;
   BreakUpMark[i]=EMPTY_VALUE;BreakDownMark[i]=EMPTY_VALUE;
  }
void ClearEverything()
  {
   ArrayInitialize(BuyArrow,EMPTY_VALUE);
   ArrayInitialize(SellArrow,EMPTY_VALUE);
   ArrayInitialize(AsiaHighLine,EMPTY_VALUE);
   ArrayInitialize(AsiaLowLine,EMPTY_VALUE);
   ArrayInitialize(BuySL,EMPTY_VALUE);
   ArrayInitialize(SellSL,EMPTY_VALUE);
   ArrayInitialize(BuyTP1,EMPTY_VALUE);
   ArrayInitialize(SellTP1,EMPTY_VALUE);
   ArrayInitialize(BuyTP2,EMPTY_VALUE);
   ArrayInitialize(SellTP2,EMPTY_VALUE);
   ArrayInitialize(BuyTP3,EMPTY_VALUE);
   ArrayInitialize(SellTP3,EMPTY_VALUE);
   ArrayInitialize(Quality,EMPTY_VALUE);
   ArrayInitialize(LowSweepMark,EMPTY_VALUE);
   ArrayInitialize(HighSweepMark,EMPTY_VALUE);
   ArrayInitialize(BreakUpMark,EMPTY_VALUE);
   ArrayInitialize(BreakDownMark,EMPTY_VALUE);
  }
void CalculateClosedBar(const int i,const int bars,
                        const datetime &time[],const double &o[],
                        const double &h[],const double &l[],const double &c[],
                        const int &spread[])
  {
   ClearBar(i);
   if(ShowAsianRange)
     {
      double ah,al;
      if(CompletedAsianRan

Показано первые 50% кода (символов: 34784)