1054 行
45 KiB
MQL5
//+------------------------------------------------------------------+
| |||
//| 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);
| |||
}
| |||
//+------------------------------------------------------------------+
|