| //+------------------------------------------------------------------+
|
| //| SMCZones.mq4 |
|
| //| Copyright 2026, Allan Niñal |
|
| //| https://www.allanninal.dev/mql5 |
|
| //+------------------------------------------------------------------+
|
| //| Smart-money concepts zones: order blocks, fair value gaps, |
|
| //| BOS / CHoCH, optional liquidity sweeps and session filter, and |
|
| //| optional zones from a higher timeframe. |
|
| //| Every zone is decided from closed bars only: its creation and |
|
| //| its mitigation never change afterwards, so nothing appears or |
|
| //| disappears after the bar closed. Rules: |
|
| //| swing N bars each side, known N bars later |
|
| //| BOS/CHoCH a close beyond the last unbroken swing; CHoCH when |
|
| //| it reverses the previous break |
|
| //| order blk the last candle against the move at the start of the |
|
| //| leg that broke the swing |
|
| //| FVG a three-candle gap of at least k x ATR |
|
| //| mitigated chosen rule: touch, midpoint, far-edge wick, or a |
|
| //| close beyond the far edge |
|
| //| An indicator, not a trading system: it draws and alerts only. |
|
| //| MT4 edition: the same engine (SmcEngine.mqh, an exact copy of |
|
| //| the MT5 one), the same inputs and the same 16 iCustom buffers. |
|
| //+------------------------------------------------------------------+
|
| // SPDX-License-Identifier: LicenseRef-PolyForm-Noncommercial-1.0.0 (see LICENSE)
|
| #property copyright "Copyright 2026, Allan Niñal <https://www.allanninal.dev/mql5>"
|
| #property link "https://www.allanninal.dev/mql5"
|
| #property version "1.1"
|
| #property description "Smart-money zones: order blocks, fair value gaps, BOS/CHoCH, optional sweeps, session filter and higher-timeframe zones."
|
| #property description "Non-repainting: zones are decided from closed bars and never change afterwards. Alerts for new, touched and mitigated zones."
|
| #property indicator_chart_window
|
| #property indicator_buffers 16
|
|
|
| #include "SmcEngine.mqh"
|
| #include "ObjSync.mqh"
|
| #include <ChartKit/CkDebug.mqh>
|
|
|
| enum ENUM_SMCZ_MIT
|
| {
|
| SMCZ_MIT_TOUCH=0, // Touch: a wick reaches the near edge
|
| SMCZ_MIT_MID=1, // Midpoint: a wick reaches the middle
|
| SMCZ_MIT_WICK=2, // Far edge, wick: a wick reaches the far edge
|
| SMCZ_MIT_CLOSE=3 // Far edge, close: a bar closes beyond the far edge
|
| };
|
|
|
| input int InpSwing = 3; // Swing strength, bars on each side
|
| input int InpATR = 14; // ATR period
|
| input bool InpShowOB = true; // Draw order blocks
|
| input ENUM_SMCZ_MIT InpOBMit = SMCZ_MIT_CLOSE; // Order block is mitigated when
|
| input bool InpShowFVG = true; // Draw fair value gaps
|
| input double InpFVGMin = 0.20; // Minimum gap, x ATR
|
| input ENUM_SMCZ_MIT InpFVGMit = SMCZ_MIT_WICK; // Gap is mitigated when
|
| input bool InpShowSweeps = false; // Mark liquidity sweeps
|
| input int InpSweepLook = 60; // Swing looked back, bars
|
| input double InpSweepMin = 0.10; // Wick beyond the swing, min x ATR
|
| input bool InpUseSession = false; // Only create zones and sweeps in the session
|
| input int InpSessStart = 7; // Session start, server hour
|
| input int InpSessEnd = 17; // Session end, server hour (exclusive)
|
| input ENUM_TIMEFRAMES InpHTF = PERIOD_CURRENT; // Also draw zones of this timeframe (current = off)
|
| input bool InpShowStruct = true; // Draw BOS / CHoCH lines
|
| input bool InpShowMitigated = false; // Keep mitigated zones, up to their mitigation bar
|
| input int InpDrawBars = 1000; // Draw zones created within this many bars
|
| input int InpMaxZones = 80; // Draw at most this many zones (newest first)
|
| input int InpExtendBars = 12; // Extend live zones this many bars past the last bar
|
| input bool InpFill = true; // Fill the zones
|
| input color InpClrOBBull = 6057759; // Bullish order block
|
| input color InpClrOBBear = 3421312; // Bearish order block
|
| input color InpClrFVGBull = 9198638; // Bullish gap
|
| input color InpClrFVGBear = 2516108; // Bearish gap
|
| input color InpClrHTF = 7888992; // Higher-timeframe zones (outline colour)
|
|
|
| #include "SignalAlerts.mqh"
|
|
|
| input bool InpAlNew = true; // Alert: new order block or gap
|
| input bool InpAlTouch = true; // Alert: price touches a live zone
|
| input bool InpAlMit = false; // Alert: a zone is mitigated
|
| input bool InpAlStruct = true; // Alert: BOS / CHoCH
|
| input bool InpAlSweep = false; // Alert: liquidity sweep
|
| input bool InpDebug = false; // Debug log for bug reports (Experts tab)
|
|
|
| const string PRODUCT="SMC Zones";
|
| const string PFX="SMCZ_";
|
|
|
| //--- the 16 buffers, series-indexed (0 = live bar) as every MT4 buffer; the engine counts bars from the oldest
|
| double b0[],b1[],b2[],b3[],b4[],b5[],b6[],b7[],b8[],b9[],b10[],b11[],b12[],b13[],b14[],b15[];
|
| CSmcEngine g_eng,g_htf;
|
| double g_out[];
|
| datetime g_htf_last=0;
|
| datetime g_ht[]; // bar times of the higher-timeframe series the engine ran on
|
| int g_hn=0;
|
| int g_obj_fail=0; // objects the chart refused in the last pass
|
| int g_dbg_fail=0;
|
| int g_draw_stamp=-1;
|
| bool g_no_draw=false; // set in OnInit: tester without visual mode
|
|
|
| //--- buffer k at series index s
|
| void SetB(const int k,const int s,const double v)
|
| {
|
| switch(k)
|
| {
|
| case 0: b0[s]=v; break;
|
| case 1: b1[s]=v; break;
|
| case 2: b2[s]=v; break;
|
| case 3: b3[s]=v; break;
|
| case 4: b4[s]=v; break;
|
| case 5: b5[s]=v; break;
|
| case 6: b6[s]=v; break;
|
| case 7: b7[s]=v; break;
|
| case 8: b8[s]=v; break;
|
| case 9: b9[s]=v; break;
|
| case 10: b10[s]=v; break;
|
| case 11: b11[s]=v; break;
|
| case 12: b12[s]=v; break;
|
| case 13: b13[s]=v; break;
|
| case 14: b14[s]=v; break;
|
| case 15: b15[s]=v; break;
|
| }
|
| }
|
|
|
| void Configure(CSmcEngine &e)
|
| {
|
| e.swing=InpSwing;
|
| e.atr_period=InpATR;
|
| e.fvg_min=InpFVGMin;
|
| e.ob_mit=(int)InpOBMit;
|
| e.fvg_mit=(int)InpFVGMit;
|
| e.sweep_look=InpSweepLook;
|
| e.sweep_min=InpSweepMin;
|
| e.use_session=InpUseSession;
|
| e.s_start=InpSessStart;
|
| e.s_end=InpSessEnd;
|
| }
|
|
|
| int OnInit()
|
| {
|
| CkDebugStart(PRODUCT,"1.1",InpDebug,StringFormat("swing %d, ATR %d, OB %d mit %d, FVG %d min %.2f mit %d, sweeps %d (%d bars, %.2f), session %d (%d-%d), HTF %s, struct %d, mitigated %d, draw %d bars, max %d zones, extend %d",
|
| InpSwing,InpATR,InpShowOB,(int)InpOBMit,InpShowFVG,InpFVGMin,(int)InpFVGMit,InpShowSweeps,InpSweepLook,InpSweepMin,
|
| InpUseSession,InpSessStart,InpSessEnd,TfName(InpHTF),InpShowStruct,InpShowMitigated,InpDrawBars,InpMaxZones,InpExtendBars));
|
| if(InpSwing<1 || InpSwing>50 || InpATR<1 || InpATR>1000 || InpFVGMin<0 || InpFVGMin>100 || InpSweepLook<1 || InpSweepLook>10000 ||
|
| InpSweepMin<0 || InpSweepMin>100 || InpDrawBars<1 || InpMaxZones<0 || InpMaxZones>1000 || InpExtendBars<0 || InpExtendBars>1000 ||
|
| InpSessStart<0 || InpSessStart>23 || InpSessEnd<0 || InpSessEnd>24)
|
| {
|
| Print("SMC Zones: check the inputs (swing 1-50, ATR period 1-1000, sweep look-back 1-10000, zones 0-1000, extension 0-1000 bars, hours 0-23)");
|
| CkDbg("init refused: inputs out of range");
|
| return(INIT_PARAMETERS_INCORRECT);
|
| }
|
| string names[B_COUNT]={"OB bull top","OB bull bottom","OB bear top","OB bear bottom","FVG bull top","FVG bull bottom",
|
| "FVG bear top","FVG bear bottom","Structure (1 BOS, 2 CHoCH, sign = direction)","Broken level",
|
| "Sweep of a low","Sweep of a high","Zones mitigated","Zones touched","Live bullish zones","Live bearish zones"};
|
| ArrayResize(g_out,B_COUNT);
|
| SetIndexBuffer(0,b0); SetIndexBuffer(1,b1); SetIndexBuffer(2,b2); SetIndexBuffer(3,b3);
|
| SetIndexBuffer(4,b4); SetIndexBuffer(5,b5); SetIndexBuffer(6,b6); SetIndexBuffer(7,b7);
|
| SetIndexBuffer(8,b8); SetIndexBuffer(9,b9); SetIndexBuffer(10,b10); SetIndexBuffer(11,b11);
|
| SetIndexBuffer(12,b12); SetIndexBuffer(13,b13); SetIndexBuffer(14,b14); SetIndexBuffer(15,b15);
|
| for(int k=0; k<B_COUNT; k++)
|
| {
|
| SetIndexStyle(k,DRAW_NONE);
|
| SetIndexEmptyValue(k,EMPTY_VALUE);
|
| SetIndexLabel(k,names[k]);
|
| }
|
| Configure(g_eng);
|
| Configure(g_htf);
|
| g_eng.Reset();
|
| g_htf.Reset();
|
| g_htf_last=0;
|
| g_draw_stamp=-1;
|
| g_hn=0;
|
| ArrayResize(g_ht,0);
|
| g_obj_fail=0;
|
| g_dbg_fail=0;
|
| g_no_draw=(IsTesting() && !IsVisualMode());
|
| IndicatorShortName("SMC Zones");
|
| IndicatorDigits(_Digits);
|
| return(INIT_SUCCEEDED);
|
| }
|
|
|
| void OnDeinit(const int reason)
|
| {
|
| ObjectsDeleteAll(0,PFX);
|
| ChartRedraw();
|
| }
|
|
|
| //--- one rectangle (created once, changed only when it differs)
|
| void Rect(const string name,const datetime t1,const double top,const datetime t2,const double bot,const color clr,
|
| const bool fill,const string tip)
|
| {
|
| if(!OsPlace(name,OBJ_RECTANGLE,2,t1,top,t2,bot))
|
| {
|
| g_obj_fail++;
|
| return;
|
| }
|
| OsInt(name,OBJPROP_COLOR,clr);
|
| OsInt(name,OBJPROP_FILL,fill);
|
| OsInt(name,OBJPROP_BACK,fill);
|
| OsInt(name,OBJPROP_WIDTH,1);
|
| OsStr(name,OBJPROP_TOOLTIP,tip);
|
| }
|
|
|
| void Seg(const string name,const datetime t1,const double p1,const datetime t2,const double p2,const color clr,
|
| const ENUM_LINE_STYLE style,const string tip)
|
| {
|
| if(!OsPlace(name,OBJ_TREND,2,t1,p1,t2,p2))
|
| {
|
| g_obj_fail++;
|
| return;
|
| }
|
| OsInt(name,OBJPROP_COLOR,clr);
|
| OsInt(name,OBJPROP_STYLE,style);
|
| OsInt(name,OBJPROP_RAY_RIGHT,false);
|
| OsInt(name,OBJPROP_BACK,true);
|
| OsStr(name,OBJPROP_TOOLTIP,tip);
|
| }
|
|
|
| void Label(const string name,const datetime t,const double p,const string text,const color clr,const ENUM_ANCHOR_POINT anchor)
|
| {
|
| if(!OsPlace(name,OBJ_TEXT,1,t,p,0,0))
|
| {
|
| g_obj_fail++;
|
| return;
|
| }
|
| OsStr(name,OBJPROP_TEXT,text);
|
| OsInt(name,OBJPROP_COLOR,clr);
|
| OsInt(name,OBJPROP_FONTSIZE,8);
|
| OsInt(name,OBJPROP_ANCHOR,anchor);
|
| }
|
|
|
| //--- draw the zones of one engine; `t` are the bar times of the series the engine ran on, `last_t` is the time of the
|
| //--- last bar of the chart, `ex` the extension in seconds
|
| int DrawEngine(CSmcEngine &e,const datetime &t[],const int bars,const string tag,const bool htf,
|
| const datetime from_t,const datetime right_t,int budget)
|
| {
|
| int drawn=0;
|
| for(int z=e.nz-1; z>=0 && drawn<budget; z--)
|
| {
|
| bool live=(e.zones[z].end<0);
|
| if(!live && !InpShowMitigated)
|
| continue;
|
| if(t[e.zones[z].born]<from_t)
|
| break; // zones are stored in birth order: all older ones are out too
|
| if(e.zones[z].kind==ZK_OB ? !InpShowOB : !InpShowFVG)
|
| continue;
|
| bool bull=(e.zones[z].dir>0);
|
| color clr=htf ? InpClrHTF : (e.zones[z].kind==ZK_OB ? (bull ? InpClrOBBull : InpClrOBBear) : (bull ? InpClrFVGBull : InpClrFVGBear));
|
| datetime t2=live ? right_t : t[e.zones[z].end];
|
| string tip=StringFormat("%s%s %s %s, %s - %s%s",htf ? TfName(InpHTF)+" " : "",bull ? "Bullish" : "Bearish",
|
| e.zones[z].kind==ZK_OB ? "order block" : "fair value gap",
|
| TimeToString(t[e.zones[z].born]),DoubleToString(e.zones[z].bot,_Digits),
|
| DoubleToString(e.zones[z].top,_Digits),live ? "" : " (mitigated)");
|
| string nm=StringFormat("%s%s%d",PFX,tag,z);
|
| Rect(nm,t[e.zones[z].t0],e.zones[z].top,t2,e.zones[z].bot,clr,htf ? false : (InpFill && live),tip);
|
| drawn++;
|
| }
|
| return(drawn);
|
| }
|
|
|
| void Redraw(const datetime &time[],const int n,const datetime &htime[],const int hn)
|
| {
|
| OsBegin();
|
| g_obj_fail=0;
|
| int from_bar=MathMax(0,n-1-InpDrawBars);
|
| datetime from_t=time[from_bar];
|
| datetime right_t=time[n-1]+(datetime)((long)InpExtendBars*PeriodSeconds(PERIOD_CURRENT));
|
| int used=0;
|
| if(InpHTF!=PERIOD_CURRENT && PeriodSeconds(InpHTF)>PeriodSeconds(PERIOD_CURRENT))
|
| used+=DrawEngine(g_htf,htime,hn,"H",true,from_t,right_t,InpMaxZones);
|
| used+=DrawEngine(g_eng,time,n,"Z",false,from_t,right_t,MathMax(0,InpMaxZones-used));
|
| if(InpShowStruct || InpShowSweeps)
|
| {
|
| int shown=0;
|
| if(InpShowStruct)
|
| for(int b=g_eng.nb-1; b>=0 && shown<InpMaxZones; b--)
|
| {
|
| if(g_eng.breaks[b].at<from_bar)
|
| break;
|
| bool up=(g_eng.breaks[b].dir>0);
|
| color clr=up ? InpClrOBBull : InpClrOBBear;
|
| string tx=g_eng.breaks[b].choch ? "CHoCH" : "BOS";
|
| Seg(StringFormat("%sS%d",PFX,b),time[g_eng.breaks[b].frm],g_eng.breaks[b].level,time[g_eng.breaks[b].at],
|
| g_eng.breaks[b].level,clr,STYLE_DOT,tx);
|
| Label(StringFormat("%sT%d",PFX,b),time[(g_eng.breaks[b].frm+g_eng.breaks[b].at)/2],g_eng.breaks[b].level,tx,clr,
|
| up ? ANCHOR_LOWER : ANCHOR_UPPER);
|
| shown++;
|
| }
|
| shown=0;
|
| if(InpShowSweeps)
|
| for(int s=g_eng.ns-1; s>=0 && shown<InpMaxZones; s--)
|
| {
|
| if(g_eng.sweeps[s].at<from_bar)
|
| break;
|
| bool up=(g_eng.sweeps[s].dir>0);
|
| Seg(StringFormat("%sW%d",PFX,s),time[g_eng.sweeps[s].frm],g_eng.sweeps[s].level,time[g_eng.sweeps[s].at],
|
| g_eng.sweeps[s].level,clrSilver,STYLE_DASH,"Liquidity sweep");
|
| Label(StringFormat("%sX%d",PFX,s),time[g_eng.sweeps[s].at],g_eng.sweeps[s].level,"sweep",clrSilver,
|
| up ? ANCHOR_UPPER : ANCHOR_LOWER);
|
| shown++;
|
| }
|
| }
|
| OsEnd(PFX);
|
| if(g_obj_fail!=g_dbg_fail)
|
| {
|
| g_dbg_fail=g_obj_fail;
|
| CkDbg(StringFormat("the chart refused %d object(s), error %d",g_obj_fail,GetLastError()));
|
| }
|
| ChartRedraw();
|
| }
|
|
|
| //--- the alert text for the events of the closed bar `i`
|
| string Events(const double &o[])
|
| {
|
| string s="";
|
| if(InpAlNew)
|
| {
|
| if(o[B_OB_BULL_TOP]!=EMPTY_VALUE && InpShowOB)
|
| s+="new bullish order block "+DoubleToString(o[B_OB_BULL_BOT],_Digits)+"-"+DoubleToString(o[B_OB_BULL_TOP],_Digits)+"; ";
|
| if(o[B_OB_BEAR_TOP]!=EMPTY_VALUE && InpShowOB)
|
| s+="new bearish order block "+DoubleToString(o[B_OB_BEAR_BOT],_Digits)+"-"+DoubleToString(o[B_OB_BEAR_TOP],_Digits)+"; ";
|
| if(o[B_FVG_BULL_TOP]!=EMPTY_VALUE && InpShowFVG)
|
| s+="new bullish gap "+DoubleToString(o[B_FVG_BULL_BOT],_Digits)+"-"+DoubleToString(o[B_FVG_BULL_TOP],_Digits)+"; ";
|
| if(o[B_FVG_BEAR_TOP]!=EMPTY_VALUE && InpShowFVG)
|
| s+="new bearish gap "+DoubleToString(o[B_FVG_BEAR_BOT],_Digits)+"-"+DoubleToString(o[B_FVG_BEAR_TOP],_Digits)+"; ";
|
| }
|
| if(InpAlStruct && o[B_STRUCT]!=EMPTY_VALUE)
|
| s+=StringFormat("%s %s at %s; ",MathAbs(o[B_STRUCT])>1 ? "CHoCH" : "BOS",o[B_STRUCT]>0 ? "up" : "down",
|
| DoubleToString(o[B_LEVEL],_Digits));
|
| if(InpAlSweep && InpShowSweeps)
|
| {
|
| if(o[B_SWEEP_BULL]!=EMPTY_VALUE)
|
| s+="low swept at "+DoubleToString(o[B_SWEEP_BULL],_Digits)+"; ";
|
| if(o[B_SWEEP_BEAR]!=EMPTY_VALUE)
|
| s+="high swept at "+DoubleToString(o[B_SWEEP_BEAR],_Digits)+"; ";
|
| }
|
| if(InpAlTouch && o[B_TOUCHED]!=EMPTY_VALUE && o[B_TOUCHED]>0)
|
| s+=StringFormat("%d zone(s) touched; ",(int)o[B_TOUCHED]);
|
| if(InpAlMit && o[B_MITIGATED]!=EMPTY_VALUE && o[B_MITIGATED]>0)
|
| s+=StringFormat("%d zone(s) mitigated; ",(int)o[B_MITIGATED]);
|
| return(s);
|
| }
|
|
|
| //--- the higher-timeframe engine: completed HTF bars only, rebuilt (and the series copied) only when a new HTF bar has
|
| //--- closed; between those moments the copy in g_ht is used as it is
|
| int UpdateHTF(bool &changed)
|
| {
|
| changed=false;
|
| if(InpHTF==PERIOD_CURRENT || PeriodSeconds(InpHTF)<=PeriodSeconds(PERIOD_CURRENT))
|
| return(0);
|
| datetime cur=iTime(_Symbol,InpHTF,0);
|
| if(cur==0)
|
| return(0);
|
| if(g_htf_last==cur && g_htf.done>=0)
|
| return(g_hn);
|
| int want=MathMin(Bars(_Symbol,InpHTF),3000);
|
| double ho[],hh[],hl[],hc[];
|
| if(want<3 || CopyTime(_Symbol,InpHTF,0,want,g_ht)!=want || CopyOpen(_Symbol,InpHTF,0,want,ho)!=want ||
|
| CopyHigh(_Symbol,InpHTF,0,want,hh)!=want || CopyLow(_Symbol,InpHTF,0,want,hl)!=want ||
|
| CopyClose(_Symbol,InpHTF,0,want,hc)!=want)
|
| {
|
| CkDbg(StringFormat("higher-timeframe %s history not ready (%d bars wanted), error %d",TfName(InpHTF),want,GetLastError()));
|
| g_hn=0;
|
| return(0);
|
| }
|
| g_htf.Reset();
|
| double ob[];
|
| ArrayResize(ob,B_COUNT);
|
| for(int i=0; i<=want-2; i++)
|
| g_htf.Step(i,g_ht,ho,hh,hl,hc,ob);
|
| g_htf_last=cur;
|
| g_hn=want;
|
| changed=true;
|
| CkDbg(StringFormat("higher-timeframe %s engine rebuilt on %d bars, %d zones",TfName(InpHTF),want,g_htf.nz));
|
| return(want);
|
| }
|
|
|
| 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[])
|
| {
|
| if(rates_total<3)
|
| return(0);
|
| //--- the engine and the drawing count bars from the oldest, as MT5 does
|
| ArraySetAsSeries(time,false);
|
| ArraySetAsSeries(open,false);
|
| ArraySetAsSeries(high,false);
|
| ArraySetAsSeries(low,false);
|
| ArraySetAsSeries(close,false);
|
| if(prev_calculated==0 || g_eng.done>rates_total-2)
|
| g_eng.Reset();
|
| bool moved=false;
|
| for(int i=g_eng.done+1; i<=rates_total-2; i++)
|
| {
|
| g_eng.Step(i,time,open,high,low,close,g_out);
|
| for(int k=0; k<B_COUNT; k++)
|
| SetB(k,rates_total-1-i,g_out[k]);
|
| moved=true;
|
| if(i==rates_total-2 && prev_calculated>0)
|
| {
|
| string ev=Events(g_out);
|
| if(ev!="")
|
| {
|
| CkDbg("alert for the closed bar "+TimeToString(time[i])+": "+ev);
|
| SignalAlert(PRODUCT,ev,time[i],true);
|
| }
|
| }
|
| }
|
| for(int k=0; k<B_COUNT; k++)
|
| SetB(k,0,EMPTY_VALUE);
|
| if(g_no_draw) // non-visual Strategy Tester: no chart, so no objects (the
|
| return(rates_total); // buffers above, read by iCustom and alerts, are unchanged)
|
| bool hchanged=false;
|
| int hn=UpdateHTF(hchanged);
|
| if(moved || hchanged || g_draw_stamp!=rates_total)
|
| {
|
| Redraw(time,rates_total,g_ht,hn);
|
| g_draw_stamp=rates_total;
|
| }
|
| return(rates_total);
|
| }
|
| //+------------------------------------------------------------------+
|
