| //+------------------------------------------------------------------+
|
| //| Gold Session Liquidity Free MT5 |
|
| //| Free educational build 1.10 - FXLINER - 2026 |
|
| //| OHLC-based liquidity proxy; does NOT inspect real resting orders. |
|
| //| Contains techniques developed in Smart Liquidity Hunter v1.11, |
|
| //| (c) Smart Liquidity Hunter contributors, used under the MIT |
|
| //| License (see THIRD_PARTY_NOTICES.txt). |
|
| //| Signal confirmation uses closed bars; never the forming bar. |
|
| //+------------------------------------------------------------------+
|
| #property strict
|
| #property copyright "FXLINER; Smart Liquidity Hunter contributors (MIT portions)"
|
| #property link "https://forexreview.top/"
|
| #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
|
|
|
| // Buffer index map for EA iCustom / CopyBuffer:
|
| // 0 BUY arrow; 1 SELL arrow; 2 completed Asia high; 3 Asia low;
|
| // 4 BUY SL; 5 SELL SL; 6 BUY TP1; 7 SELL TP1;
|
| // 8 BUY TP2; 9 SELL TP2; 10 BUY TP3; 11 SELL TP3;
|
| // 12 signal quality 0..100 (EMPTY_VALUE without signal).
|
| // 13 sweep low; 14 sweep high; 15 swing structure break up; 16 break down.
|
| // Experimental signal buffers 0/1 and trade plan buffers 4..12 remain
|
| // EMPTY_VALUE unless user explicitly opts into ShowExperimentalSignals.
|
|
|
| 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="";
|
|
|
| //+------------------------------------------------------------------+
|
| //| Pure clock functions: timestamps are interpreted as UTC. |
|
| //+------------------------------------------------------------------+
|
| 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)
|
| {
|
| // Determine the offset from candidate UTC values, not from server time.
|
| // Forex normally closes during the EU Sunday DST transition, when the
|
| // repeated local server hour is otherwise inherently ambiguous.
|
| 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);
|
| }
|
| // Session bitmask 1=Asia 2=London 4=New York.
|
| 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");
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Reference price data helpers. All indices are series (0=live). |
|
| //+------------------------------------------------------------------+
|
| 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);
|
| }
|
| // Only use bars OLDER than index i. No future session high/low.
|
| 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);
|
| }
|
| // Count matching older pivot near same level, for quality scoring.
|
| 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;
|
| };
|
|
|
| // Strictly closed-bar sweep on index k; structure level comes BEFORE k.
|
| 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;
|
| // Sweep candle itself must NOT have already broken MSS structure.
|
| if(bullish && c[k]>=structure) return(false);
|
| if(!bullish && c[k]<=structure) return(false);
|
| return(true);
|
| }
|
|
|
| // An MSS must be the FIRST post-sweep CLOSED candle breaking structure.
|
| // If stop sweeps further while waiting, invalidate that candidate.
|
| 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]);
|
| // A deeper re-sweep after the candidate invalidates it, INCLUDING
|
| // the confirmation candle: never shift a stop to salvage a signal.
|
| 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);
|
| }
|
|
|
| // Indicators refer only to fully CLOSED higher-timeframe bars.
|
| // EMA buffer index: iBarShift(current bar OPEN) + 1, conservatively
|
| // excluding the containing higher-timeframe candle even at boundary.
|
| 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(CompletedAsianRange(i,bars,time,h,l,ah,al))
|
| {AsiaHighLine[i]=ah;AsiaLowLine[i]=al;}
|
| }
|
| // All overlay pivots and sweeps are computed using CLOSED bars only.
|
| // A liquidity sweep is an OHLC inference, NOT actual broker order-book liquidity.
|
| if(ShowLiquiditySweeps)
|
| {
|
| SweepSetup sweepLow,sweepHigh;
|
| const double mtr=MeanTrueRangeBefore(i,bars,h,l,c);
|
| if(mtr>0.0)
|
| {
|
| if(DetectSweep(true,i,bars,time,o,h,l,c,sweepLow))
|
| LowSweepMark[i]=l[i]-0.12*mtr;
|
| if(DetectSweep(false,i,bars,time,o,h,l,c,sweepHigh))
|
| HighSweepMark[i]=h[i]+0.12*mtr;
|
| }
|
| }
|
| if(ShowStructureBreaks)
|
| {
|
| const int highPivot=FindFreshPivot(true,i,bars,h,l);
|
| const int lowPivot =FindFreshPivot(false,i,bars,h,l);
|
| const double mtr=MeanTrueRangeBefore(i,bars,h,l,c);
|
| if(mtr>0.0)
|
| {
|
| if(highPivot>=0 && c[i]>h[highPivot]+2*_Point &&
|
| c[i+1]<=h[highPivot]+2*_Point)
|
| BreakUpMark[i]=l[i]-0.32*mtr;
|
| if(lowPivot>=0 && c[i]<l[lowPivot]-2*_Point &&
|
| c[i+1]>=l[lowPivot]-2*_Point)
|
| BreakDownMark[i]=h[i]+0.32*mtr;
|
| }
|
| }
|
| if(!ShowExperimentalSignals) return; // No BUY/SELL arrow or trade plan by default.
|
| TradeSignal buy,sell;
|
| const bool longFound=FindTrade(true,i,bars,time,o,h,l,c,spread,buy);
|
| const bool shortFound=FindTrade(false,i,bars,time,o,h,l,c,spread,sell);
|
| if(longFound && shortFound) return; // same-bar conflicting MSS: WAIT
|
| if(longFound)
|
| {
|
| const double mtr=MeanTrueRangeBefore(i,bars,h,l,c);
|
| BuyArrow[i]=l[i]-0.18*mtr;
|
| BuySL[i]=buy.stop;
|
| BuyTP1[i]=buy.tp1;BuyTP2[i]=buy.tp2;BuyTP3[i]=buy.tp3;
|
| Quality[i]=buy.score;
|
| }
|
| if(shortFound)
|
| {
|
| const double mtr=MeanTrueRangeBefore(i,bars,h,l,c);
|
| SellArrow[i]=h[i]+0.18*mtr;
|
| SellSL[i]=sell.stop;
|
| SellTP1[i]=sell.tp1;SellTP2[i]=sell.tp2;SellTP3[i]=sell.tp3;
|
| Quality[i]=sell.score;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| UI and chart objects - named per instance and deleted on remove. |
|
| //+------------------------------------------------------------------+
|
| void SetPanelLabel(const string key,const string value,const int row,
|
| const int fontSize,const color ink)
|
| {
|
| const string name=g_prefix+key;
|
| if(ObjectFind(0,name)<0)
|
| if(!ObjectCreate(0,name,OBJ_LABEL,0,0,0)) return;
|
| ObjectSetInteger(0,name,OBJPROP_CORNER,CORNER_LEFT_UPPER);
|
| ObjectSetInteger(0,name,OBJPROP_ANCHOR,ANCHOR_LEFT_UPPER);
|
| ObjectSetInteger(0,name,OBJPROP_XDISTANCE,DashboardX+14);
|
| ObjectSetInteger(0,name,OBJPROP_YDISTANCE,DashboardY+14+row*23);
|
| ObjectSetInteger(0,name,OBJPROP_FONTSIZE,fontSize);
|
| ObjectSetInteger(0,name,OBJPROP_COLOR,ink);
|
| ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);
|
| ObjectSetInteger(0,name,OBJPROP_HIDDEN,true);
|
| ObjectSetInteger(0,name,OBJPROP_ZORDER,200);
|
| ObjectSetString(0,name,OBJPROP_FONT,"Consolas");
|
| ObjectSetString(0,name,OBJPROP_TEXT,value);
|
| }
|
| void SetupPanel()
|
| {
|
| if(!ShowDashboard) return;
|
| const string name=g_prefix+"PANEL_BG";
|
| if(ObjectFind(0,name)<0)
|
| if(!ObjectCreate(0,name,OBJ_RECTANGLE_LABEL,0,0,0)) return;
|
| ObjectSetInteger(0,name,OBJPROP_CORNER,CORNER_LEFT_UPPER);
|
| ObjectSetInteger(0,name,OBJPROP_XDISTANCE,DashboardX);
|
| ObjectSetInteger(0,name,OBJPROP_YDISTANCE,DashboardY);
|
| ObjectSetInteger(0,name,OBJPROP_XSIZE,520);
|
| ObjectSetInteger(0,name,OBJPROP_YSIZE,284);
|
| ObjectSetInteger(0,name,OBJPROP_BGCOLOR,DashboardBackground);
|
| ObjectSetInteger(0,name,OBJPROP_COLOR,C'55,76,99');
|
| ObjectSetInteger(0,name,OBJPROP_BORDER_TYPE,BORDER_FLAT);
|
| ObjectSetInteger(0,name,OBJPROP_BACK,false);
|
| ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);
|
| ObjectSetInteger(0,name,OBJPROP_HIDDEN,true);
|
| ObjectSetInteger(0,name,OBJPROP_ZORDER,100);
|
| }
|
| int RecentSignalIndex(const int bars)
|
| {
|
| const int max=(int)MathMin(bars-1,MaxBarsToScan);
|
| for(int i=1;i<=max;i++)
|
| if(BuyArrow[i]!=EMPTY_VALUE || SellArrow[i]!=EMPTY_VALUE) return(i);
|
| return(-1);
|
| }
|
| string RiskMoneyLabel()
|
| {
|
| if(!ShowManualRiskPlanner) return("RISK PLANNER: DISABLED");
|
| const double equity=AccountInfoDouble(ACCOUNT_EQUITY);
|
| if(equity<=0.0) return("RISK PLANNER: equity unavailable (connect demo account)");
|
| return("BUDGET "+DoubleToString(RiskBudgetPercent,2)+"% of equity = "+
|
| DoubleToString(equity*RiskBudgetPercent/100.0,2)+" "+
|
| AccountInfoString(ACCOUNT_CURRENCY));
|
| }
|
| string SuggestedManualLots()
|
| {
|
| if(!ShowManualRiskPlanner) return("LOT: manual planner disabled");
|
| if(ManualEntryPrice<=0.0 || ManualStopPrice<=0.0 ||
|
| MathAbs(ManualEntryPrice-ManualStopPrice)<_Point)
|
| return("LOT: set ManualEntryPrice + ManualStopPrice in inputs");
|
| const double equity=AccountInfoDouble(ACCOUNT_EQUITY);
|
| if(equity<=0.0) return("LOT: no account equity");
|
| const bool buy=(ManualEntryPrice>ManualStopPrice);
|
| const double minimum=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN);
|
| const double maximum=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX);
|
| const double step=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);
|
| if(minimum<=0.0 || maximum<minimum || step<=0.0)
|
| return("LOT: broker lot specification unavailable");
|
| double loss=0.0;
|
| if(!OrderCalcProfit(buy?ORDER_TYPE_BUY:ORDER_TYPE_SELL,
|
| _Symbol,minimum,ManualEntryPrice,ManualStopPrice,loss) ||
|
| loss>=0.0)
|
| return("LOT: check symbol or entry/stop levels");
|
| const double riskPerLot=(-loss/minimum)+CommissionPerLotRoundTrip;
|
| const double budget=equity*RiskBudgetPercent/100.0;
|
| if(riskPerLot<=0.0) return("LOT: risk calculation unavailable");
|
| const double rawLots=MathMin(maximum,budget/riskPerLot);
|
| const double lots=NormalizeDouble(MathFloor(rawLots/step+1e-9)*step,8);
|
| if(lots<minimum-1e-9)
|
| return("LOT: min broker lot exceeds your chosen risk budget");
|
| const double expectedNominal=lots*riskPerLot;
|
| const double targetDistance=buy?ManualTargetPrice-ManualEntryPrice:
|
| ManualEntryPrice-ManualTargetPrice;
|
| const string rr=(ManualTargetPrice>0.0 && targetDistance>0.0)?
|
| " | price R:R "+DoubleToString(targetDistance/
|
| MathAbs(ManualEntryPrice-ManualStopPrice),2):"";
|
| return("LOT "+DoubleToString(lots,2)+" "+(buy?"BUY":"SELL")+
|
| " | nominal SL "+DoubleToString(expectedNominal,2)+
|
| " "+AccountInfoString(ACCOUNT_CURRENCY)+rr);
|
| }
|
|
|
| int RecentOverlay(const int bars,int &kind)
|
| {
|
| kind=0;
|
| const int limit=(int)MathMin(bars-1,96); // no stale historical setups
|
| for(int i=1;i<=limit;i++)
|
| {
|
| if(LowSweepMark[i]!=EMPTY_VALUE) {kind=1;return(i);}
|
| if(HighSweepMark[i]!=EMPTY_VALUE) {kind=2;return(i);}
|
| }
|
| return(-1);
|
| }
|
| int RecentStructure(const int bars,int &kind)
|
| {
|
| kind=0;
|
| const int limit=(int)MathMin(bars-1,96);
|
| for(int i=1;i<=limit;i++)
|
| {
|
| if(BreakUpMark[i]!=EMPTY_VALUE) {kind=1;return(i);}
|
| if(BreakDownMark[i]!=EMPTY_VALUE) {kind=2;return(i);}
|
| }
|
| return(-1);
|
| }
|
| void UpdatePanel(const int bars,const datetime &time[],const double &c[],
|
| const double &h[],const double &l[],const int &spread[])
|
| {
|
| if(!ShowDashboard) return;
|
| SetupPanel();
|
| const datetime utc=BrokerToUTC(time[0]);
|
| const string tf=EnumToString((ENUM_TIMEFRAMES)_Period);
|
| const int trend=TrendDirection(time[1]);
|
| const string trendName=trend>0?"UP":(trend<0?"DOWN":"NEUTRAL / LOADING");
|
| const bool active=IsTradingSession(utc);
|
| SetPanelLabel("TITLE","GOLD SESSION LIQUIDITY FREE | MT5 v1.10",0,11,clrDeepSkyBlue);
|
| SetPanelLabel("SYMBOL",_Symbol+" | "+tf+" | "+SessionName(utc),1,9,DashboardForeground);
|
| SetPanelLabel("CLOCK","UTC "+TimeToString(utc,TIME_DATE|TIME_MINUTES)+
|
| " | Session "+(active?"ACTIVE":"WAIT"),2,9,
|
| active?clrLimeGreen:clrSilver);
|
| const long liveSpread=SymbolInfoInteger(_Symbol,SYMBOL_SPREAD);
|
| const double mtr=MeanTrueRangeBefore(1,bars,h,l,c);
|
| const string costContext=(mtr>0.0 && liveSpread>0)?
|
| " | spread/ATR "+DoubleToString(100.0*liveSpread*_Point/mtr,1)+"%":"";
|
| SetPanelLabel("TREND",EnumToString(TrendTimeframe)+" EMA "+IntegerToString(TrendFastEMA)+"/"+
|
| IntegerToString(TrendSlowEMA)+" "+trendName+
|
| " | spread "+IntegerToString((int)liveSpread)+" pt"+costContext,
|
| 3,9,DashboardForeground);
|
| if(AsiaHighLine[0]!=EMPTY_VALUE && AsiaLowLine[0]!=EMPTY_VALUE)
|
| SetPanelLabel("ASIA","ASIA completed H "+DoubleToString(AsiaHighLine[0],_Digits)+
|
| " | L "+DoubleToString(AsiaLowLine[0],_Digits),4,9,DashboardForeground);
|
| else
|
| SetPanelLabel("ASIA","ASIA range: not yet completed / data unavailable",4,9,clrSilver);
|
| int kind=0;
|
| const int sw=RecentOverlay(bars,kind);
|
| if(sw>=1)
|
| SetPanelLabel("SWEEP",(kind==1?"SWEEP LOW reclaimed":"SWEEP HIGH rejected")+
|
| " | "+TimeToString(time[sw],TIME_DATE|TIME_MINUTES),5,9,
|
| kind==1?clrLimeGreen:clrTomato);
|
| else
|
| SetPanelLabel("SWEEP","SWEEPS: no recent closed-bar event",5,9,clrSilver);
|
| int skind=0;
|
| const int br=RecentStructure(bars,skind);
|
| if(br>=1)
|
| SetPanelLabel("STRUCTURE",(skind==1?"SWING BREAK UP":"SWING BREAK DOWN")+
|
| " | "+TimeToString(time[br],TIME_DATE|TIME_MINUTES),6,9,
|
| skind==1?clrDeepSkyBlue:clrOrange);
|
| else
|
| SetPanelLabel("STRUCTURE","STRUCTURE: no recent closed-bar break",6,9,clrSilver);
|
| if(!ShowExperimentalSignals)
|
| SetPanelLabel("SIGNAL","EXPERIMENTAL BUY/SELL: OFF (research not validated)",7,9,clrSilver);
|
| else
|
| {
|
| const int latest=RecentSignalIndex(bars);
|
| if(latest<1 || latest>MaximumDisplayPlanAgeBars)
|
| SetPanelLabel("SIGNAL","EXPERIMENTAL BUY/SELL: no recent setup",7,9,clrSilver);
|
| else
|
| {
|
| const bool bull=(BuyArrow[latest]!=EMPTY_VALUE);
|
| SetPanelLabel("SIGNAL",string("RESEARCH ONLY: ")+(bull?"BUY":"SELL")+
|
| " | heuristic score "+IntegerToString((int)Quality[latest])+"/100",
|
| 7,9,bull?clrLimeGreen:clrTomato);
|
| }
|
| }
|
| SetPanelLabel("RISK",RiskMoneyLabel(),8,9,DashboardForeground);
|
| SetPanelLabel("LOT",SuggestedManualLots(),9,9,DashboardForeground);
|
| SetPanelLabel("NOTICE","OHLC sweep proxy | SL not guaranteed | no proven trading edge",
|
| 10,8,clrSilver);
|
| }void TradeSegment(const string suffix,const datetime from,const datetime to,
|
| const double price,const color ink,const ENUM_LINE_STYLE style)
|
| {
|
| const string name=g_prefix+"PLAN_"+suffix;
|
| if(ObjectFind(0,name)<0)
|
| {
|
| if(!ObjectCreate(0,name,OBJ_TREND,0,from,price,to,price)) return;
|
| }
|
| else
|
| {
|
| ObjectMove(0,name,0,from,price);
|
| ObjectMove(0,name,1,to,price);
|
| }
|
| ObjectSetInteger(0,name,OBJPROP_RAY_RIGHT,false);
|
| ObjectSetInteger(0,name,OBJPROP_STYLE,style);
|
| ObjectSetInteger(0,name,OBJPROP_COLOR,ink);
|
| ObjectSetInteger(0,name,OBJPROP_WIDTH,1);
|
| ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);
|
| ObjectSetInteger(0,name,OBJPROP_HIDDEN,true);
|
| }
|
| void DeleteTradeLines()
|
| {
|
| ObjectDelete(0,g_prefix+"PLAN_ENTRY");
|
| ObjectDelete(0,g_prefix+"PLAN_SL");
|
| ObjectDelete(0,g_prefix+"PLAN_TP1");
|
| ObjectDelete(0,g_prefix+"PLAN_TP2");
|
| ObjectDelete(0,g_prefix+"PLAN_TP3");
|
| }
|
| void UpdateTradeLines(const int bars,const datetime &time[],const double &c[])
|
| {
|
| if(!ShowCurrentTradePlan) {DeleteTradeLines();return;}
|
| const int latest=RecentSignalIndex(bars);
|
| if(latest<0 || latest>MaximumDisplayPlanAgeBars) {DeleteTradeLines();return;}
|
| const bool longTrade=BuyArrow[latest]!=EMPTY_VALUE;
|
| const double sl=longTrade?BuySL[latest]:SellSL[latest];
|
| if(sl==EMPTY_VALUE) {DeleteTradeLines();return;}
|
| const int ps=PeriodSeconds((ENUM_TIMEFRAMES)_Period);
|
| const datetime from=time[latest];
|
| const datetime to=(datetime)(time[0]+12*ps);
|
| const color signalColor=longTrade?clrLimeGreen:clrTomato;
|
| TradeSegment("ENTRY",from,to,c[latest],signalColor,STYLE_SOLID);
|
| TradeSegment("SL",from,to,sl,clrTomato,STYLE_DASH);
|
| TradeSegment("TP1",from,to,longTrade?BuyTP1[latest]:SellTP1[latest],clrDeepSkyBlue,STYLE_DOT);
|
| TradeSegment("TP2",from,to,longTrade?BuyTP2[latest]:SellTP2[latest],clrDeepSkyBlue,STYLE_DOT);
|
| TradeSegment("TP3",from,to,longTrade?BuyTP3[latest]:SellTP3[latest],clrDeepSkyBlue,STYLE_DOT);
|
| }
|
| void AlertOnFreshClosedBar(const datetime &time[])
|
| {
|
| if(!ShowExperimentalSignals) return;
|
| if(!PopupAlerts && !PushAlerts && !SoundAlerts) return;
|
| if(time[1]==g_lastAlert) return;
|
| const bool buy=BuyArrow[1]!=EMPTY_VALUE;
|
| const bool sell=SellArrow[1]!=EMPTY_VALUE;
|
| if(!buy && !sell) return;
|
| g_lastAlert=time[1];
|
| const string msg="Gold Session Liquidity FREE (experimental) | "+_Symbol+" "+
|
| EnumToString((ENUM_TIMEFRAMES)_Period)+" | "+(buy?"BUY":"SELL")+
|
| " confirmed MSS | quality "+IntegerToString((int)Quality[1])+
|
| "/100 | "+TimeToString(time[1],TIME_DATE|TIME_MINUTES);
|
| if(PopupAlerts) Alert(msg);
|
| if(SoundAlerts) PlaySound("alert.wav");
|
| if(PushAlerts && !SendNotification(msg))
|
| Print("GSLP: push notification failed, error=",GetLastError());
|
| }
|
| int NewlyClosed(const int bars,const datetime &time[])
|
| {
|
| const int cap=(int)MathMin(MaxBarsToScan,bars-1);
|
| for(int i=1;i<=cap;i++) if(time[i]==g_lastOpening) return(i);
|
| return(-1);
|
| }
|
| bool ValidInputs()
|
| {
|
| return(BrokerWinterUTCOffsetHours>=-12 && BrokerWinterUTCOffsetHours<=14 &&
|
| AsianStartUTCHour>=0 && AsianStartUTCHour<24 &&
|
| AsianEndUTCHour>AsianStartUTCHour && AsianEndUTCHour<=24 &&
|
| (TradeLondon || TradeNewYork || TradeAsia) &&
|
| SwingStrength>=1 && SwingStrength<=15 &&
|
| MaxSwingAge>=SwingStrength+2 && MaxSwingAge<=500 &&
|
| StructureLookback>=3 && StructureLookback<=150 &&
|
| MSSConfirmBars>=1 && MSSConfirmBars<=20 &&
|
| MeanTrueRangePeriod>=3 && MeanTrueRangePeriod<=200 &&
|
| MinSweepPoints>=0 && MinSweepToATR>=0.0 &&
|
| MinRejectionWickPct>=0.0 && MinRejectionWickPct<=100.0 &&
|
| MinCloseLocationPct>=0.0 && MinCloseLocationPct<=100.0 &&
|
| EqualLevelATR>=0 && EqualLevelATR<=5.0 &&
|
| MinBarRangeToATR>=0.0 && MaxBarRangeToATR>MinBarRangeToATR &&
|
| MaxSpreadToATR>=0.0 && MinRecordedSpreadPoints>=0 &&
|
| EfficiencyLookback>=3 && EfficiencyLookback<=200 &&
|
| MinEfficiencyRatio>=0.0 && MinEfficiencyRatio<=1.0 &&
|
| TrendFastEMA>=2 && TrendSlowEMA>TrendFastEMA &&
|
| PeriodSeconds(TrendTimeframe)>0 &&
|
| MinimumSignalScore>=0 && MinimumSignalScore<=100 &&
|
| StopBufferATR>=0.0 && MaxStopDistanceATR>0.25 &&
|
| Target1R>0.0 && Target2R>Target1R && Target3R>Target2R &&
|
| MaxBarsToScan>=100 && MaxBarsToScan<=10000 &&
|
| MaximumDisplayPlanAgeBars>=1 && MaximumDisplayPlanAgeBars<=500 &&
|
| DashboardX>=0 && DashboardY>=0 &&
|
| StringLen(InstanceID)>=1 && StringLen(InstanceID)<=30 &&
|
| RiskBudgetPercent>0.0 && RiskBudgetPercent<=5.0 &&
|
| CommissionPerLotRoundTrip>=0.0 &&
|
| ManualEntryPrice>=0.0 && ManualStopPrice>=0.0 &&
|
| ManualTargetPrice>=0.0);
|
| }
|
| int OnInit()
|
| {
|
| if(!ValidInputs())
|
| {Print("GSLF: invalid inputs. Please review parameter ranges.");return(INIT_PARAMETERS_INCORRECT);}
|
| if(!SetIndexBuffer(0,BuyArrow,INDICATOR_DATA) ||
|
| !SetIndexBuffer(1,SellArrow,INDICATOR_DATA) ||
|
| !SetIndexBuffer(2,AsiaHighLine,INDICATOR_DATA) ||
|
| !SetIndexBuffer(3,AsiaLowLine,INDICATOR_DATA) ||
|
| !SetIndexBuffer(4,BuySL,INDICATOR_DATA) ||
|
| !SetIndexBuffer(5,SellSL,INDICATOR_DATA) ||
|
| !SetIndexBuffer(6,BuyTP1,INDICATOR_DATA) ||
|
| !SetIndexBuffer(7,SellTP1,INDICATOR_DATA) ||
|
| !SetIndexBuffer(8,BuyTP2,INDICATOR_DATA) ||
|
| !SetIndexBuffer(9,SellTP2,INDICATOR_DATA) ||
|
| !SetIndexBuffer(10,BuyTP3,INDICATOR_DATA) ||
|
| !SetIndexBuffer(11,SellTP3,INDICATOR_DATA) ||
|
| !SetIndexBuffer(12,Quality,INDICATOR_DATA) ||
|
| !SetIndexBuffer(13,LowSweepMark,INDICATOR_DATA) ||
|
| !SetIndexBuffer(14,HighSweepMark,INDICATOR_DATA) ||
|
| !SetIndexBuffer(15,BreakUpMark,INDICATOR_DATA) ||
|
| !SetIndexBuffer(16,BreakDownMark,INDICATOR_DATA))
|
| {Print("GSLP: SetIndexBuffer failed");return(INIT_FAILED);}
|
| ArraySetAsSeries(BuyArrow,true);ArraySetAsSeries(SellArrow,true);
|
| ArraySetAsSeries(AsiaHighLine,true);ArraySetAsSeries(AsiaLowLine,true);
|
| ArraySetAsSeries(BuySL,true);ArraySetAsSeries(SellSL,true);
|
| ArraySetAsSeries(BuyTP1,true);ArraySetAsSeries(SellTP1,true);
|
| ArraySetAsSeries(BuyTP2,true);ArraySetAsSeries(SellTP2,true);
|
| ArraySetAsSeries(BuyTP3,true);ArraySetAsSeries(SellTP3,true);
|
| ArraySetAsSeries(Quality,true);
|
| ArraySetAsSeries(LowSweepMark,true);ArraySetAsSeries(HighSweepMark,true);
|
| ArraySetAsSeries(BreakUpMark,true);ArraySetAsSeries(BreakDownMark,true);
|
| for(int j=0;j<17;j++)
|
| {
|
| PlotIndexSetDouble(j,PLOT_EMPTY_VALUE,EMPTY_VALUE);
|
| if(j>=4 && j<=12) PlotIndexSetInteger(j,PLOT_DRAW_TYPE,DRAW_NONE);
|
| }
|
| PlotIndexSetInteger(0,PLOT_ARROW,233);
|
| PlotIndexSetInteger(1,PLOT_ARROW,234);
|
| PlotIndexSetInteger(13,PLOT_ARROW,159); // swept low marker
|
| PlotIndexSetInteger(14,PLOT_ARROW,159); // swept high marker
|
| PlotIndexSetInteger(15,PLOT_ARROW,233); // structure break up
|
| PlotIndexSetInteger(16,PLOT_ARROW,234); // structure break down
|
| if(!ShowExperimentalSignals)
|
| {
|
| PlotIndexSetInteger(0,PLOT_DRAW_TYPE,DRAW_NONE);
|
| PlotIndexSetInteger(1,PLOT_DRAW_TYPE,DRAW_NONE);
|
| }
|
| if(!ShowLiquiditySweeps)
|
| {
|
| PlotIndexSetInteger(13,PLOT_DRAW_TYPE,DRAW_NONE);
|
| PlotIndexSetInteger(14,PLOT_DRAW_TYPE,DRAW_NONE);
|
| }
|
| if(!ShowStructureBreaks)
|
| {
|
| PlotIndexSetInteger(15,PLOT_DRAW_TYPE,DRAW_NONE);
|
| PlotIndexSetInteger(16,PLOT_DRAW_TYPE,DRAW_NONE);
|
| }
|
| if(!ShowAsianRange)
|
| {
|
| PlotIndexSetInteger(2,PLOT_DRAW_TYPE,DRAW_NONE);
|
| PlotIndexSetInteger(3,PLOT_DRAW_TYPE,DRAW_NONE);
|
| }
|
| PlotIndexSetString(4,PLOT_LABEL,"Buy SL");
|
| PlotIndexSetString(5,PLOT_LABEL,"Sell SL");
|
| PlotIndexSetString(6,PLOT_LABEL,"Buy TP1");
|
| PlotIndexSetString(7,PLOT_LABEL,"Sell TP1");
|
| PlotIndexSetString(8,PLOT_LABEL,"Buy TP2");
|
| PlotIndexSetString(9,PLOT_LABEL,"Sell TP2");
|
| PlotIndexSetString(10,PLOT_LABEL,"Buy TP3");
|
| PlotIndexSetString(11,PLOT_LABEL,"Sell TP3");
|
| PlotIndexSetString(12,PLOT_LABEL,"Signal Quality 0..100");
|
| IndicatorSetString(INDICATOR_SHORTNAME,"Gold Session Liquidity Free MT5 [v1.10]");
|
| IndicatorSetInteger(INDICATOR_DIGITS,_Digits);
|
| g_fastHandle=iMA(_Symbol,TrendTimeframe,TrendFastEMA,0,MODE_EMA,PRICE_CLOSE);
|
| g_slowHandle=iMA(_Symbol,TrendTimeframe,TrendSlowEMA,0,MODE_EMA,PRICE_CLOSE);
|
| if(g_fastHandle==INVALID_HANDLE || g_slowHandle==INVALID_HANDLE)
|
| {Print("GSLP: EMA handle failed");return(INIT_FAILED);}
|
| g_lastOpening=0;g_lastAlert=0;
|
| g_prefix="GSLF_"+InstanceID+"_";
|
| ObjectsDeleteAll(0,g_prefix);
|
| return(INIT_SUCCEEDED);
|
| }
|
| void OnDeinit(const int reason)
|
| {
|
| ObjectsDeleteAll(0,g_prefix);
|
| if(g_fastHandle!=INVALID_HANDLE) IndicatorRelease(g_fastHandle);
|
| if(g_slowHandle!=INVALID_HANDLE) IndicatorRelease(g_slowHandle);
|
| }
|
| int OnCalculate(const int rates_total,const int prev_calculated,
|
| const datetime &time[],const double &open[],
|
| const double &high[],const double &low[],
|
| const double &close[],const long &tick_volume[],
|
| const long &volume[],const int &spread[])
|
| {
|
| ArraySetAsSeries(time,true);ArraySetAsSeries(open,true);
|
| ArraySetAsSeries(high,true);ArraySetAsSeries(low,true);
|
| ArraySetAsSeries(close,true);ArraySetAsSeries(spread,true);
|
| const int minimum=(int)MathMax(120,
|
| MathMax(MaxSwingAge+SwingStrength+5,
|
| MathMax(MeanTrueRangePeriod+MSSConfirmBars+3,StructureLookback+MSSConfirmBars+3)));
|
| if(rates_total<minimum)
|
| {
|
| ClearEverything();
|
| g_lastOpening=0;
|
| return(0);
|
| }
|
| bool full=(prev_calculated<=0 || prev_calculated>rates_total || g_lastOpening==0);
|
| const bool newbar=(time[0]!=g_lastOpening);
|
| if(!full && !newbar && rates_total!=prev_calculated) full=true;
|
| if(!full && !newbar) return(rates_total);
|
| int added=0;
|
| if(!full)
|
| {
|
| added=NewlyClosed(rates_total,time);
|
| if(added<1) full=true;
|
| }
|
| if(!PrepareTrend(rates_total,time))
|
| return(0); // Wait for H1/H4 history, not a provisional score.
|
| if(full) ClearEverything();
|
| const int maximum=(int)MathMin(MaxBarsToScan,rates_total-2*SwingStrength-2);
|
| const int start=full?maximum:(int)MathMin(added,maximum);
|
| for(int i=start;i>=1;i--)
|
| {
|
| if(IsStopped()) return(0);
|
| CalculateClosedBar(i,rates_total,time,open,high,low,close,spread);
|
| }
|
| if(!full)
|
| {
|
| const int oldEnd=(int)MathMin(rates_total-1,maximum+added);
|
| for(int i=maximum+1;i<=oldEnd;i++) ClearBar(i);
|
| }
|
| ClearBar(0); // Zero current-candle arrows, stops, targets, and score.
|
| if(ShowAsianRange)
|
| {
|
| double ah,al;
|
| if(CompletedAsianRange(0,rates_total,time,high,low,ah,al))
|
| {AsiaHighLine[0]=ah;AsiaLowLine[0]=al;}
|
| }
|
| UpdatePanel(rates_total,time,close,high,low,spread);
|
| UpdateTradeLines(rates_total,time,close);
|
| // No startup alerts, reattach alerts, or multi-candle catch-up spam.
|
| if(!full && newbar && added==1) AlertOnFreshClosedBar(time);
|
| g_lastOpening=time[0];
|
| return(rates_total);
|
| }
|
| //+------------------------------------------------------------------+
|