| //+------------------------------------------------------------------+
|
| //| GoldTrendSentinel.mqh |
|
| //| Copyright 2026, Allan Niñal |
|
| //| https://www.allanninal.dev/mql5 |
|
| //+------------------------------------------------------------------+
|
| //| Gold Trend Sentinel MT4: a gold H4 trend follower. |
|
| //| On each new H4 bar, from the last closed one: |
|
| //| buy when the close crosses above the UT Bot stop line |
|
| //| (key 1.5, ATR 10) AND the last completed daily close is |
|
| //| above its EMA(200) AND Supertrend(10, 3) on H4 is up; |
|
| //| sell is the mirror. Market order at the bar's open; stop |
|
| //| 3 x ATR(14) from the fill, then a chandelier trail 3 x ATR |
|
| //| behind the best price since entry, tightened once per H4 bar. |
|
| //| No target. An opposite signal reverses; a same-side signal |
|
| //| while in a trade is ignored. ATRs are Wilder's (RMA) seeded |
|
| //| with an SMA, as TradingView computes them. |
|
| //| Candles: the rule was researched on New York-close candles |
|
| //| (server time UTC+2, or UTC+3 while US daylight saving is on). |
|
| //| On a broker with another server clock, H4 and D1 candles are |
|
| //| rebuilt from H1 on that clock, so the signals stay the same. |
|
| //| Lot: always 0.01, or the broker's minimum when that is larger; |
|
| //| no lot inputs. No network calls. |
|
| //| Every order is checked for margin and for surviving its stop |
|
| //| above the broker's stop-out level. Live and demo charts trade |
|
| //| XAUUSD only; the Strategy Tester may test any symbol. |
|
| //+------------------------------------------------------------------+
|
| // SPDX-License-Identifier: MPL-2.0
|
| // This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not
|
| // distributed with this file, You can obtain one at https://mozilla.org/MPL/2.0/
|
| // Origin of the maths: UT Bot idea by Yo_adriiiiaan (from an original idea by HPotter), TradingView "UT Bot Alerts" by
|
| // QuantNomad; Supertrend is the textbook ATR-band indicator.
|
|
|
| //+------------------------------------------------------------------+
|
| //| Inputs |
|
| //+------------------------------------------------------------------+
|
| //--- Inputs-dialog text. MT5 shows each enum choice by the comment on its own line, so every member,
|
| //--- including the last, needs its comment before the closing brace.
|
| enum ENUM_GTS_CORNER
|
| {
|
| GTS_LEFT=0, // Top left
|
| GTS_RIGHT=1 // Top right
|
| };
|
|
|
| enum ENUM_GTS_CLOCK
|
| {
|
| GTS_CLOCK_AUTO=0, // Auto: detect from the live server time
|
| GTS_CLOCK_NY=1, // New York close: UTC+2/+3 with US daylight saving
|
| GTS_CLOCK_EET=2, // UTC+2/+3 with European daylight saving
|
| GTS_CLOCK_FIXED=3 // Fixed offset from UTC (set below), no daylight saving
|
| };
|
|
|
| input int InpMagic = 770100; // Magic number (order ID)
|
| input ENUM_TIMEFRAMES InpTF = PERIOD_H4; // Signal timeframe
|
| input double InpUTKey = 1.5; // UT Bot key value
|
| input int InpUTATR = 10; // UT Bot ATR period
|
| input int InpSTPeriod = 10; // Supertrend ATR period
|
| input double InpSTMult = 3.0; // Supertrend multiplier
|
| input int InpTrendEMA = 200; // Daily trend EMA period
|
| input int InpStopATR = 14; // Stop ATR period
|
| input double InpStopMult = 3.0; // Stop and trail, x ATR
|
| input bool InpTrail = true; // Trail the stop
|
|
|
| input ENUM_GTS_CLOCK InpClock = GTS_CLOCK_AUTO; // Broker server clock
|
| input int InpFixedUTC = 0; // Broker offset from UTC, hours (Fixed offset only)
|
|
|
| input bool InpShowPanel = true; // Show info panel
|
| input bool InpShowLevels = true; // Show the UT Bot line and signals
|
| input bool InpLightTheme = false; // Light colours (for white charts)
|
| input ENUM_GTS_CORNER InpCorner = GTS_LEFT; // Panel position
|
| input int InpOffsetX = 10; // Panel margin from the side, px
|
| input int InpOffsetY = 26; // Panel margin from the top, px
|
| input int InpFontSize = 9; // Panel font size
|
|
|
| input bool InpDebug = false; // Debug log for bug reports (Experts tab)
|
|
|
| //+------------------------------------------------------------------+
|
| //| Constants and state |
|
| //+------------------------------------------------------------------+
|
| #define WIN 1500 // signal-timeframe bars the indicators are rebuilt over
|
| #define D1WIN 1500 // daily bars for the EMA(200)
|
| #define MIN_BARS 300 // signal bars required before trading
|
| #define PREFIX "GTS_" // chart object prefix
|
| #define MARKERS 60 // signal markers kept on the chart
|
| #define GAP_MULT 2.0 // plan for twice the loss at the stop: a gap, or a tester that only
|
| // checks stops at bar opens, can carry the price past it
|
|
|
| datetime g_last_bar = 0; // open time of the last processed signal bar
|
|
|
| //--- symbol properties cached in OnInit
|
| double g_tick=0, g_vol_min=0, g_vol_max=0, g_vol_step=0;
|
|
|
| //--- status
|
| bool g_symbol_ok=true; // XAUUSD on live charts (any symbol in the tester)
|
|
|
| //--- what the last evaluation saw, for the panel and the trail
|
| double g_ut_stop=0; // UT Bot line on the last closed bar
|
| int g_ut_side=0; // +1 close above the line, -1 below
|
| int g_st_dir=0; // Supertrend +1 up / -1 down
|
| int g_d1_dir=0; // daily close vs EMA: +1 above / -1 below
|
| double g_d1_close=0, g_d1_ema=0;
|
| double g_atr_stop=0; // ATR(14) on the last closed bar
|
| double g_pdh=0; // reference price for the Risk row (current bid)
|
| double g_ref_stop=0; // stop distance the next trade would use
|
| datetime g_sig_time=0; // bar of the last buy/sell signal
|
| int g_sig_side=0; // +1 buy, -1 sell
|
| string g_sig_result=""; // "placed" / "reversed" / why it was skipped
|
| bool g_market_open=true;
|
| //--- candle clock
|
| bool g_native=true; // the broker already runs on New York-close time: use its own candles
|
| ENUM_GTS_CLOCK g_clock=GTS_CLOCK_NY; // resolved clock (Auto becomes one of the others)
|
| int g_fixed_off=0; // seconds, for GTS_CLOCK_FIXED
|
|
|
| //--- panel state
|
| bool g_ui=false, g_collapsed=false, g_stats_dirty=true;
|
| int g_rows=0;
|
| string g_cache_txt[];
|
| int g_cache_x[], g_cache_y[], g_cache_w[], g_cache_h[]; // last geometry sent per object
|
| color g_cache_fill[];
|
| int g_cursor=0; // the panel draws in the same order every time: try this slot first
|
| bool g_panel_dirty=true; // something changed since the last ChartRedraw
|
| datetime g_cache_reset=0; // the cache is dropped once a minute, so deleted objects come back
|
| color g_cache_clr[];
|
| string g_cache_name[];
|
| int g_closed=0, g_wins=0;
|
| int g_hist_seen=0; // closed-trade results are read incrementally: history records counted
|
| datetime g_today_start=0;
|
| int g_trd[]; // this EA's open orders, watched until they close (MQL4: no OnTradeTransaction)
|
| double g_trd_sl[]; // their stop at entry (debug TRD lines)
|
| double g_net=0, g_gross_win=0, g_gross_loss=0, g_today=0;
|
| double g_curve=0, g_curve_peak=0, g_max_dd=0; // closed-trade results in sequence, for the worst drawdown
|
| int g_mon_key[]; // yyyymm of the months with closed trades
|
| double g_mon_net[]; // their results
|
| int g_markers=0;
|
| datetime g_last_ui=0;
|
|
|
| //+------------------------------------------------------------------+
|
| //| Palette (same as Vitals) |
|
| //+------------------------------------------------------------------+
|
| color UiBack() { return(InpLightTheme ? C'250,250,251' : C'24,26,30'); } // panel background
|
| color UiText() { return(InpLightTheme ? C'44,48,56' : C'206,212,220'); } // values
|
| color UiLabel() { return(InpLightTheme ? C'124,131,142' : C'122,130,142'); } // field names
|
| color UiHead() { return(InpLightTheme ? C'92,100,112' : C'150,160,175'); } // section titles
|
| color UiDim() { return(InpLightTheme ? C'140,146,157' : C'96,102,112'); } // zero / no data
|
| color UiPos() { return(InpLightTheme ? C'38,118,66' : C'126,192,143'); } // sage, not Lime
|
| color UiNeg() { return(InpLightTheme ? C'176,58,58' : C'226,124,124'); } // coral, not Red
|
| color UiWarn() { return(InpLightTheme ? C'160,112,28' : C'220,178,116'); } // amber
|
| color UiAccent() { return(InpLightTheme ? C'48,92,148' : C'132,164,206'); } // market data
|
| color UiRule() { return(InpLightTheme ? C'220,223,228' : C'48,52,58'); } // group divider
|
|
|
| //+------------------------------------------------------------------+
|
| //| Panel geometry, px at font size 9 |
|
| //+------------------------------------------------------------------+
|
| #define UI_W 306 // panel width (27 characters of value)
|
| #define UI_PAD 10 // inner padding
|
| #define UI_VAL 106 // value column (clears "Profit factor" at font 9)
|
| #define UI_ROW 16 // row height
|
| #define UI_HEAD 24 // title bar height
|
| #define UI_GAP 6 // space above a section title
|
| #define UI_CHAR 7 // Consolas 9 advance width, px
|
|
|
| //+------------------------------------------------------------------+
|
| //| Rounds a price to the symbol tick size |
|
| //+------------------------------------------------------------------+
|
| double FixPrice(const double price)
|
| {
|
| if(g_tick==0)
|
| return(NormalizeDouble(price,_Digits));
|
| return(NormalizeDouble(MathRound(price/g_tick)*g_tick,_Digits));
|
| }
|
|
|
| //--- server time: TimeCurrent() in the tester; live, MQL4 has no TimeTradeServer and TimeCurrent stops between ticks
|
| //--- (all weekend), so GMT + the server's offset, learnt from a fresh tick (a whole half hour, -12 h .. +14 h)
|
| datetime NowSrv(void)
|
| {
|
| static long off=LONG_MIN;
|
| if(IsTesting())
|
| return(TimeCurrent());
|
| long d=(long)TimeCurrent()-(long)TimeGMT();
|
| long r=(long)MathRound(d/1800.0)*1800;
|
| if(MathAbs(d-r)<=120 && r>=-12*3600 && r<=14*3600)
|
| off=r;
|
| return(off==LONG_MIN ? TimeCurrent() : (datetime)((long)TimeGMT()+off));
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| True inside a trading session of the chart symbol, server time |
|
| //+------------------------------------------------------------------+
|
| bool IsMarketOpen(void)
|
| {
|
| datetime now=NowSrv();
|
| MqlDateTime dt;
|
| TimeToStruct(now,dt);
|
| int tod=(int)(now%86400);
|
| datetime from,to;
|
| for(uint s=0; SymbolInfoSessionTrade(_Symbol,(ENUM_DAY_OF_WEEK)dt.day_of_week,s,from,to); s++)
|
| {
|
| int f=(int)(from%86400),t=(int)(to%86400);
|
| if(f<t ? (tod>=f && tod<t) : (tod>=f || tod<t)) // the session end itself is closed (orders rejected)
|
| return(true);
|
| }
|
| return(false);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Selects order `i` of the open pool; true for a market order of |
|
| //| this EA on this symbol |
|
| //+------------------------------------------------------------------+
|
| bool MyOrderAt(const int i)
|
| {
|
| return(OrderSelect(i,SELECT_BY_POS,MODE_TRADES) && OrderType()<=OP_SELL && OrderMagicNumber()==InpMagic &&
|
| OrderSymbol()==_Symbol);
|
| }
|
|
|
| //--- true when ticket `t` is still open (and selects it)
|
| bool OpenTicket(const int t) { return(t>0 && OrderSelect(t,SELECT_BY_TICKET) && OrderCloseTime()==0); }
|
|
|
| double Bid_(void) { return(MarketInfo(_Symbol,MODE_BID)); }
|
| double Ask_(void) { return(MarketInfo(_Symbol,MODE_ASK)); }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Risk shown on the panel: the percent of balance lost at the stop,|
|
| //| and its name. Bands: Safe <= 1, Medium <= 2, High <= 3, Very high|
|
| //| <= 5, Extreme above. |
|
| //+------------------------------------------------------------------+
|
|
|
| string RiskName(const double pct)
|
| {
|
| if(pct<=1.0) return("Safe");
|
| if(pct<=2.0) return("Medium");
|
| if(pct<=3.0) return("High");
|
| if(pct<=5.0) return("Very high");
|
| return("Extreme");
|
| }
|
|
|
| color RiskColor(const double pct)
|
| {
|
| if(pct<=1.0) return(UiPos());
|
| if(pct<=2.0) return(UiAccent());
|
| if(pct<=3.0) return(UiWarn());
|
| return(UiNeg());
|
| }
|
|
|
| //--- the money one tick moves one lot, in the account currency. MT4 gives 0 for gold in the Strategy Tester: then tick
|
| //--- size x contract size, in the profit currency, converted with its cross rate
|
| double TickValue(void)
|
| {
|
| double tv=MarketInfo(_Symbol,MODE_TICKVALUE);
|
| if(tv>0)
|
| return(tv);
|
| double v=MarketInfo(_Symbol,MODE_TICKSIZE)*MarketInfo(_Symbol,MODE_LOTSIZE);
|
| string pc=SymbolInfoString(_Symbol,SYMBOL_CURRENCY_PROFIT),ac=AccountCurrency();
|
| if(v<=0 || pc=="")
|
| return(0);
|
| if(pc==ac)
|
| return(v);
|
| double r=MarketInfo(pc+ac,MODE_BID);
|
| if(r>0)
|
| return(v*r);
|
| r=MarketInfo(ac+pc,MODE_BID);
|
| return(r>0 ? v/r : 0);
|
| }
|
|
|
| //--- money lost at the stop by one lot (MQL4 has no OrderCalcProfit: ticks x tick value)
|
| double LossPerLot(const double price,const double sl)
|
| {
|
| return(g_tick>0 ? MathAbs(price-sl)/g_tick*TickValue() : 0);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| The minimum lot: 0.01, or the broker's minimum on |
|
| //| this symbol when that is larger (0.10 at some brokers). A broker |
|
| //| that allows less than 0.01 still gets 0.01. |
|
| //+------------------------------------------------------------------+
|
| double MinLot(void)
|
| {
|
| double v=MathMax(0.01,g_vol_min);
|
| if(g_vol_step>0) // keep it on the broker's lot step
|
| v=MathCeil(v/g_vol_step-1e-9)*g_vol_step;
|
| return(NormalizeDouble(v,8));
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //+------------------------------------------------------------------+
|
| //| Lot for an order at `price` with stop `sl`: always the broker's |
|
| //| minimum lot (SYMBOL_VOLUME_MIN: 0.01 on most brokers, 0.10 on |
|
| //| some), whatever the balance. |
|
| //+------------------------------------------------------------------+
|
| double TradeVolume(const double price,const double sl,string &why)
|
| {
|
| return(MinLot()); // FREE: 0.01 or the broker minimum, whatever the balance
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| "" when the account can take a new position of `volume` at |
|
| //| `price` with stop `sl`; otherwise the reason. Two conditions: |
|
| //| the margin fits in free margin, and if every open position of |
|
| //| this EA and the new one all reach their stops, equity stays above|
|
| //| the broker's stop-out level for the margin then in use. A broker |
|
| //| would reject the first and force-close the second. |
|
| //+------------------------------------------------------------------+
|
| string Affordable(const bool buy,const double volume,const double price,const double sl)
|
| {
|
| //--- 0 when MT4 cannot price the margin (the tester offline, "margin exchange rate cannot be calculated"): the
|
| //--- broker decides
|
| double margin=volume*MarketInfo(_Symbol,MODE_MARGINREQUIRED);
|
| if(margin>AccountInfoDouble(ACCOUNT_MARGIN_FREE))
|
| return("not enough margin");
|
| double worst=AccountInfoDouble(ACCOUNT_EQUITY)-GAP_MULT*volume*LossPerLot(price,sl);
|
| for(int i=OrdersTotal()-1; i>=0; i--)
|
| {
|
| if(!MyOrderAt(i))
|
| continue;
|
| double psl=OrderStopLoss();
|
| bool pbuy=OrderType()==OP_BUY;
|
| double cur=pbuy ? Bid_() : Ask_();
|
| if(psl>0 && (pbuy ? psl<cur : psl>cur)) // room left between the price now and its stop
|
| worst-=GAP_MULT*OrderLots()*LossPerLot(cur,psl);
|
| }
|
| double so=AccountInfoDouble(ACCOUNT_MARGIN_SO_SO);
|
| double used=AccountInfoDouble(ACCOUNT_MARGIN)+margin;
|
| double floor_=AccountInfoInteger(ACCOUNT_MARGIN_SO_MODE)==ACCOUNT_STOPOUT_MODE_PERCENT ? used*so/100.0 : so;
|
| if(worst<=floor_)
|
| return("balance too small for SL");
|
| return("");
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Chart objects: one cached setter so unchanged text is not resent |
|
| //+------------------------------------------------------------------+
|
| int CacheSlot(const string name)
|
| {
|
| int n=ArraySize(g_cache_name);
|
| if(g_cursor<n && g_cache_name[g_cursor]==name)
|
| return(g_cursor++);
|
| for(int i=0; i<n; i++)
|
| if(g_cache_name[i]==name)
|
| {
|
| g_cursor=i+1;
|
| return(i);
|
| }
|
| ArrayResize(g_cache_name,n+1);
|
| ArrayResize(g_cache_txt,n+1);
|
| ArrayResize(g_cache_clr,n+1);
|
| ArrayResize(g_cache_x,n+1);
|
| ArrayResize(g_cache_y,n+1);
|
| ArrayResize(g_cache_w,n+1);
|
| ArrayResize(g_cache_h,n+1);
|
| ArrayResize(g_cache_fill,n+1);
|
| g_cache_name[n]=name;
|
| g_cache_txt[n]="\x01";
|
| g_cache_clr[n]=clrNONE;
|
| g_cache_fill[n]=clrNONE;
|
| g_cache_x[n]=g_cache_y[n]=g_cache_w[n]=g_cache_h[n]=INT_MIN;
|
| g_cursor=n+1;
|
| return(n);
|
| }
|
|
|
| void CacheClear(void)
|
| {
|
| ArrayResize(g_cache_name,0);
|
| ArrayResize(g_cache_txt,0);
|
| ArrayResize(g_cache_clr,0);
|
| ArrayResize(g_cache_x,0);
|
| ArrayResize(g_cache_y,0);
|
| ArrayResize(g_cache_w,0);
|
| ArrayResize(g_cache_h,0);
|
| ArrayResize(g_cache_fill,0);
|
| g_cursor=0;
|
| g_panel_dirty=true;
|
| }
|
|
|
| //--- sets an integer property only when it differs from what was last sent
|
| void SetInt(const string name,const ENUM_OBJECT_PROPERTY_INTEGER prop,const long v,int &cache)
|
| {
|
| if(cache==(int)v)
|
| return;
|
| ObjectSetInteger(0,name,prop,v);
|
| cache=(int)v;
|
| g_panel_dirty=true;
|
| }
|
|
|
| //--- x distance of a point `x` px from the panel's left edge, for either corner
|
| int PanelX(const int x)
|
| {
|
| return(InpCorner==GTS_LEFT ? InpOffsetX+x : InpOffsetX+UI_W-x);
|
| }
|
|
|
| ENUM_BASE_CORNER PanelCorner(void)
|
| {
|
| return(InpCorner==GTS_LEFT ? CORNER_LEFT_UPPER : CORNER_RIGHT_UPPER);
|
| }
|
|
|
| void Text(const string id,const int x,const int y,const string text,const color clr,
|
| const int size=0,const string font="Consolas")
|
| {
|
| string name=PREFIX+id;
|
| string txt=(text=="") ? " " : text; // an empty label would show the word "Label"
|
| int slot=CacheSlot(name);
|
| if(g_cache_x[slot]==INT_MIN && ObjectFind(0,name)<0) // first time this object is seen
|
| {
|
| ObjectCreate(0,name,OBJ_LABEL,0,0,0);
|
| ObjectSetInteger(0,name,OBJPROP_CORNER,PanelCorner());
|
| ObjectSetInteger(0,name,OBJPROP_ANCHOR,ANCHOR_LEFT_UPPER);
|
| ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);
|
| ObjectSetInteger(0,name,OBJPROP_HIDDEN,true);
|
| ObjectSetInteger(0,name,OBJPROP_BACK,false);
|
| ObjectSetString(0,name,OBJPROP_FONT,font);
|
| ObjectSetInteger(0,name,OBJPROP_FONTSIZE,size>0 ? size : InpFontSize);
|
| }
|
| SetInt(name,OBJPROP_XDISTANCE,PanelX(x),g_cache_x[slot]);
|
| SetInt(name,OBJPROP_YDISTANCE,InpOffsetY+y,g_cache_y[slot]);
|
| if(g_cache_txt[slot]!=txt)
|
| {
|
| ObjectSetString(0,name,OBJPROP_TEXT,txt);
|
| g_cache_txt[slot]=txt;
|
| g_panel_dirty=true;
|
| }
|
| if(g_cache_clr[slot]!=clr)
|
| {
|
| ObjectSetInteger(0,name,OBJPROP_COLOR,clr);
|
| g_cache_clr[slot]=clr;
|
| g_panel_dirty=true;
|
| }
|
| }
|
|
|
| void Box(const string id,const int x,const int y,const int w,const int h,const color fill,const color border)
|
| {
|
| string name=PREFIX+id;
|
| int slot=CacheSlot(name);
|
| if(g_cache_x[slot]==INT_MIN && ObjectFind(0,name)<0)
|
| {
|
| ObjectCreate(0,name,OBJ_RECTANGLE_LABEL,0,0,0);
|
| ObjectSetInteger(0,name,OBJPROP_CORNER,PanelCorner());
|
| ObjectSetInteger(0,name,OBJPROP_BORDER_TYPE,BORDER_FLAT);
|
| ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);
|
| ObjectSetInteger(0,name,OBJPROP_HIDDEN,true);
|
| ObjectSetInteger(0,name,OBJPROP_BACK,false);
|
| }
|
| //--- a rectangle label is anchored at its top-left corner, so on the right corner shift it by its width
|
| SetInt(name,OBJPROP_XDISTANCE,InpCorner==GTS_LEFT ? InpOffsetX+x : InpOffsetX+UI_W-x,g_cache_x[slot]);
|
| SetInt(name,OBJPROP_YDISTANCE,InpOffsetY+y,g_cache_y[slot]);
|
| SetInt(name,OBJPROP_XSIZE,w,g_cache_w[slot]);
|
| SetInt(name,OBJPROP_YSIZE,h,g_cache_h[slot]);
|
| if(g_cache_fill[slot]!=fill)
|
| {
|
| ObjectSetInteger(0,name,OBJPROP_BGCOLOR,fill);
|
| g_cache_fill[slot]=fill;
|
| g_panel_dirty=true;
|
| }
|
| if(g_cache_clr[slot]!=border)
|
| {
|
| ObjectSetInteger(0,name,OBJPROP_COLOR,border);
|
| g_cache_clr[slot]=border;
|
| g_panel_dirty=true;
|
| }
|
| }
|
|
|
| void Button(const string id,const int x,const int y,const string txt)
|
| {
|
| string name=PREFIX+id;
|
| if(ObjectFind(0,name)<0)
|
| {
|
| ObjectCreate(0,name,OBJ_BUTTON,0,0,0);
|
| ObjectSetInteger(0,name,OBJPROP_CORNER,PanelCorner());
|
| ObjectSetInteger(0,name,OBJPROP_XSIZE,18);
|
| ObjectSetInteger(0,name,OBJPROP_YSIZE,16);
|
| ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);
|
| ObjectSetInteger(0,name,OBJPROP_HIDDEN,true);
|
| ObjectSetString(0,name,OBJPROP_FONT,"Consolas");
|
| ObjectSetInteger(0,name,OBJPROP_FONTSIZE,InpFontSize);
|
| }
|
| ObjectSetInteger(0,name,OBJPROP_XDISTANCE,InpCorner==GTS_LEFT ? InpOffsetX+x : InpOffsetX+UI_W-x);
|
| ObjectSetInteger(0,name,OBJPROP_YDISTANCE,InpOffsetY+y);
|
| ObjectSetInteger(0,name,OBJPROP_BGCOLOR,UiBack());
|
| ObjectSetInteger(0,name,OBJPROP_BORDER_COLOR,UiRule());
|
| ObjectSetInteger(0,name,OBJPROP_COLOR,UiHead());
|
| ObjectSetString(0,name,OBJPROP_TEXT,txt);
|
| ObjectSetInteger(0,name,OBJPROP_STATE,false);
|
| }
|
|
|
| //--- one "label value" row; returns the next y
|
| int Row(const string id,const int y,const string label,const string value,const color clr)
|
| {
|
| int fit=(UI_W-UI_VAL-UI_PAD)/UI_CHAR; // characters that fit in the value column
|
| Text(id+"_l",UI_PAD,y,label,UiLabel());
|
| Text(id+"_v",UI_VAL,y,StringLen(value)>fit ? StringSubstr(value,0,fit-1)+"~" : value,clr);
|
| return(y+UI_ROW);
|
| }
|
|
|
| int Section(const string id,const int y,const string title)
|
| {
|
| int top=y+UI_GAP;
|
| Box(id+"_r",UI_PAD,top+UI_ROW-3,UI_W-2*UI_PAD,1,UiRule(),UiRule());
|
| Text(id+"_t",UI_PAD,top,title,UiHead(),InpFontSize-1);
|
| return(top+UI_ROW+2);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Formatting helpers |
|
| //+------------------------------------------------------------------+
|
| string Px(const double v) { return(v>0 ? DoubleToString(v,_Digits) : "-"); } // 2 or 3 digit gold alike
|
| string Money(const double v) { return((v>=0 ? "+" : "-")+DoubleToString(MathAbs(v),2)+" "+AccountInfoString(ACCOUNT_CURRENCY)); }
|
| color Sign(const double v) { return(v>0 ? UiPos() : (v<0 ? UiNeg() : UiDim())); }
|
|
|
| //--- the lot the EA uses: 0.01, or the broker minimum
|
| string LotText(void)
|
| {
|
| return(DoubleToString(MinLot(),2)+" fixed (FREE)");
|
| }
|
|
|
| //--- percent of balance lost at the stop with the lot actually used, at yesterday's high
|
| double g_risk_now=0;
|
| string RiskText(void)
|
| {
|
| g_risk_now=0;
|
| double bal=AccountInfoDouble(ACCOUNT_BALANCE);
|
| if(g_pdh<=0 || g_ref_stop<=0 || bal<=0)
|
| return("-");
|
| string why="";
|
| double sl=g_pdh-g_ref_stop;
|
| double v=TradeVolume(g_pdh,sl,why);
|
| if(v<=0)
|
| return("-");
|
| g_risk_now=100.0*v*LossPerLot(g_pdh,sl)/bal;
|
| return(StringFormat("%.1f%% at stop %s",g_risk_now,RiskName(g_risk_now)));
|
| }
|
|
|
| string Clock(const int secs)
|
| {
|
| int s=MathMax(0,secs);
|
| return(s>=3600 ? StringFormat("%dh %02dm",s/3600,(s%3600)/60) : StringFormat("%02d:%02d",s/60,s%60));
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Closed-trade results of this EA on this symbol, from the account |
|
| //| history (MT4: one record per closed order or closed part). |
|
| //| Read incrementally: only records added since the last update. |
|
| //+------------------------------------------------------------------+
|
| void RecalcStats(void)
|
| {
|
| datetime today=iTime(_Symbol,PERIOD_D1,0);
|
| if(today!=g_today_start) // a new day: today's total starts again
|
| {
|
| g_today_start=today;
|
| g_today=0;
|
| for(int i=0; i<OrdersHistoryTotal(); i++) // today's closed trades so far
|
| if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY) && OrderType()<=OP_SELL && OrderMagicNumber()==InpMagic &&
|
| OrderSymbol()==_Symbol && OrderCloseTime()>=today && i<g_hist_seen)
|
| g_today+=OrderProfit()+OrderSwap()+OrderCommission();
|
| }
|
| int n=OrdersHistoryTotal();
|
| if(n<g_hist_seen) // the history tab's period was shortened: count again
|
| {
|
| g_hist_seen=0;
|
| g_closed=g_wins=0;
|
| g_net=g_gross_win=g_gross_loss=g_today=g_curve=g_curve_peak=g_max_dd=0;
|
| ArrayResize(g_mon_key,0);
|
| ArrayResize(g_mon_net,0);
|
| }
|
| for(int i=g_hist_seen; i<n; i++)
|
| {
|
| if(!OrderSelect(i,SELECT_BY_POS,MODE_HISTORY) || OrderType()>OP_SELL || OrderMagicNumber()!=InpMagic ||
|
| OrderSymbol()!=_Symbol)
|
| continue;
|
| double v=OrderProfit()+OrderSwap()+OrderCommission();
|
| datetime t=OrderCloseTime();
|
| g_net+=v;
|
| if(t>=today)
|
| g_today+=v;
|
| g_closed++;
|
| g_curve+=v;
|
| g_curve_peak=MathMax(g_curve_peak,g_curve);
|
| g_max_dd=MathMax(g_max_dd,g_curve_peak-g_curve);
|
| MqlDateTime mt;
|
| TimeToStruct(t,mt);
|
| int key=mt.year*100+mt.mon,k=ArraySize(g_mon_key)-1;
|
| if(k<0 || g_mon_key[k]!=key)
|
| {
|
| k++;
|
| ArrayResize(g_mon_key,k+1);
|
| ArrayResize(g_mon_net,k+1);
|
| g_mon_key[k]=key;
|
| g_mon_net[k]=0;
|
| }
|
| g_mon_net[k]+=v;
|
| if(v>0)
|
| {
|
| g_wins++;
|
| g_gross_win+=v;
|
| }
|
| else
|
| g_gross_loss-=v;
|
| }
|
| g_hist_seen=n;
|
| g_stats_dirty=false;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Indicators, exactly as the Python research computes them |
|
| //+------------------------------------------------------------------+
|
| //--- Sunday on or after `day` of `month` in year `y`, at `hour` UTC
|
| datetime SundayFrom(const int y,const int month,const int day,const int hour)
|
| {
|
| MqlDateTime t;
|
| ZeroMemory(t);
|
| t.year=y;
|
| t.mon=month;
|
| t.day=day;
|
| datetime d=StructToTime(t);
|
| TimeToStruct(d,t);
|
| return(d+(datetime)(((7-t.day_of_week)%7)*86400+hour*3600));
|
| }
|
|
|
| //--- US daylight saving (second Sunday of March 07:00 UTC to first Sunday of November 06:00 UTC)
|
| bool UsDst(const datetime utc)
|
| {
|
| MqlDateTime t;
|
| TimeToStruct(utc,t);
|
| return(utc>=SundayFrom(t.year,3,8,7) && utc<SundayFrom(t.year,11,1,6));
|
| }
|
|
|
| //--- EU summer time (last Sunday of March to last Sunday of October, 01:00 UTC)
|
| bool EuDst(const datetime utc)
|
| {
|
| MqlDateTime t;
|
| TimeToStruct(utc,t);
|
| return(utc>=SundayFrom(t.year,3,25,1) && utc<SundayFrom(t.year,10,25,1));
|
| }
|
|
|
| int NyOffset(const datetime utc) { return(UsDst(utc) ? 3*3600 : 2*3600); }
|
|
|
| //--- the broker's offset from UTC at server time `srv`
|
| int BrokerOffset(const datetime srv)
|
| {
|
| if(g_clock==GTS_CLOCK_FIXED)
|
| return(g_fixed_off);
|
| if(g_clock==GTS_CLOCK_EET)
|
| return(EuDst(srv-2*3600) ? 3*3600 : 2*3600);
|
| return(NyOffset(srv-2*3600));
|
| }
|
|
|
| //--- seconds to add to server time to get New York-close time
|
| int Shift(const datetime srv)
|
| {
|
| if(g_native)
|
| return(0);
|
| int b=BrokerOffset(srv);
|
| return(NyOffset(srv-b)-b);
|
| }
|
|
|
| //--- open time, on the New York-close clock, of the candle of length `per` that contains server time `srv`
|
| datetime NyBucket(const datetime srv,const int per)
|
| {
|
| long ny=(long)srv+Shift(srv);
|
| return((datetime)(ny-ny%per));
|
| }
|
|
|
| //--- decide the clock once: the inputs, or the live server time against UTC (the tester can't tell, see OnInit)
|
| void ResolveClock(void)
|
| {
|
| g_clock=InpClock;
|
| g_fixed_off=InpFixedUTC*3600;
|
| if(InpClock==GTS_CLOCK_AUTO)
|
| {
|
| g_clock=GTS_CLOCK_NY;
|
| if(!MQLInfoInteger(MQL_TESTER))
|
| {
|
| datetime gmt=TimeGMT();
|
| int off=(int)MathRound((double)(NowSrv()-gmt)/1800.0)*1800;
|
| if(off==NyOffset(gmt))
|
| g_clock=GTS_CLOCK_NY;
|
| else
|
| if(off==(EuDst(gmt) ? 3*3600 : 2*3600))
|
| g_clock=GTS_CLOCK_EET;
|
| else
|
| {
|
| g_clock=GTS_CLOCK_FIXED;
|
| g_fixed_off=off;
|
| }
|
| }
|
| }
|
| g_native=(g_clock==GTS_CLOCK_NY);
|
| }
|
|
|
| string ClockText(void)
|
| {
|
| if(g_native)
|
| return("NY close (broker)");
|
| if(g_clock==GTS_CLOCK_EET)
|
| return("NY close, from EET");
|
| return(StringFormat("NY close, from UTC%+d",g_fixed_off/3600));
|
| }
|
|
|
| //--- closed candles of `tf`, oldest first, on the New York-close clock. With a New York-close broker this is the
|
| //--- broker's own candles; otherwise they are rebuilt from H1 (times in the result are New York-close times)
|
| int GetBars(const ENUM_TIMEFRAMES tf,const int count,MqlRates &out[])
|
| {
|
| int per=PeriodSeconds(tf);
|
| if(g_native || per<3600 || per>86400 || per%3600!=0)
|
| return(CopyRates(_Symbol,tf,1,count,out));
|
| MqlRates h[];
|
| int need=(int)MathMin((double)count*per/3600.0+48.0,60000.0);
|
| int n=CopyRates(_Symbol,PERIOD_H1,1,need,h);
|
| if(n<=0)
|
| return(n);
|
| datetime cur=NyBucket(TimeCurrent(),per); // the candle still forming is left out
|
| ArrayResize(out,0,count+1);
|
| int m=0;
|
| for(int i=0; i<n; i++)
|
| {
|
| datetime k=NyBucket(h[i].time,per);
|
| if(k>=cur)
|
| break;
|
| if(m==0 || k!=out[m-1].time)
|
| {
|
| ArrayResize(out,m+1,count+1);
|
| out[m]=h[i];
|
| out[m].time=k;
|
| m++;
|
| continue;
|
| }
|
| out[m-1].high=MathMax(out[m-1].high,h[i].high);
|
| if(h[i].low<out[m-1].low)
|
| {
|
| out[m-1].low=h[i].low;
|
| out[m-1].spread=h[i].spread; // the spread when the low printed: the ask low for shorts
|
| }
|
| out[m-1].close=h[i].close;
|
| out[m-1].tick_volume+=h[i].tick_volume;
|
| out[m-1].real_volume+=h[i].real_volume;
|
| }
|
| if(m>count) // keep the newest `count` (MQL4 has no ArrayRemove)
|
| {
|
| MqlRates keep[];
|
| ArrayCopy(keep,out,0,m-count,count);
|
| ArrayFree(out);
|
| ArrayCopy(out,keep);
|
| m=count;
|
| }
|
| return(m);
|
| }
|
|
|
| //--- open time of the forming candle (New York-close time when converting), and seconds until it closes
|
| datetime CurBar(void) { return(g_native ? iTime(_Symbol,InpTF,0) : NyBucket(TimeCurrent(),PeriodSeconds(InpTF))); }
|
|
|
| int SecsToNextBar(void)
|
| {
|
| datetime now=TimeCurrent();
|
| return(PeriodSeconds(InpTF)-(int)(now+Shift(now)-CurBar()));
|
| }
|
|
|
| //--- true range; the first bar has no previous close, so it is high - low
|
| void TrueRange(const MqlRates &r[],const int n,double &tr[])
|
| {
|
| ArrayResize(tr,n);
|
| for(int i=0; i<n; i++)
|
| {
|
| double hl=r[i].high-r[i].low;
|
| if(i==0)
|
| {
|
| tr[i]=hl;
|
| continue;
|
| }
|
| double pc=r[i-1].close;
|
| tr[i]=MathMax(hl,MathMax(MathAbs(r[i].high-pc),MathAbs(r[i].low-pc)));
|
| }
|
| }
|
|
|
| //--- Wilder's smoothing (TradingView ta.rma), seeded with the SMA of the first n values; EMPTY_VALUE before
|
| void Rma(const double &x[],const int n,const int period,double &out[])
|
| {
|
| ArrayResize(out,n);
|
| ArrayInitialize(out,EMPTY_VALUE);
|
| if(n<period)
|
| return;
|
| double s=0;
|
| for(int i=0; i<period; i++)
|
| s+=x[i];
|
| out[period-1]=s/period;
|
| for(int i=period; i<n; i++)
|
| out[i]=(out[i-1]*(period-1)+x[i])/period;
|
| }
|
|
|
| //--- UT Bot Alerts trailing line on the close
|
| void UTBot(const MqlRates &r[],const int n,const double &atr[],const double key,double &stop[])
|
| {
|
| ArrayResize(stop,n);
|
| for(int i=0; i<n; i++)
|
| {
|
| double prev=(i>0 ? stop[i-1] : 0.0);
|
| if(atr[i]==EMPTY_VALUE)
|
| {
|
| stop[i]=(i==0 ? EMPTY_VALUE : prev);
|
| continue;
|
| }
|
| if(prev==EMPTY_VALUE)
|
| prev=0.0;
|
| double src=r[i].close,p1=(i>0 ? r[i-1].close : r[i].close),nloss=key*atr[i];
|
| if(src>prev && p1>prev)
|
| stop[i]=MathMax(prev,src-nloss);
|
| else
|
| if(src<prev && p1<prev)
|
| stop[i]=MathMin(prev,src+nloss);
|
| else
|
| stop[i]=(src>prev ? src-nloss : src+nloss);
|
| }
|
| }
|
|
|
| //--- Supertrend direction (+1 up, -1 down; 0 before the ATR exists)
|
| void Supertrend(const MqlRates &r[],const int n,const double &atr[],const double mult,int &dir[])
|
| {
|
| ArrayResize(dir,n);
|
| ArrayInitialize(dir,0);
|
| double up=0,dn=0,st=0;
|
| bool have=false;
|
| for(int i=0; i<n; i++)
|
| {
|
| if(atr[i]==EMPTY_VALUE)
|
| continue;
|
| double src=(r[i].high+r[i].low)/2.0;
|
| double ub=src+mult*atr[i],lb=src-mult*atr[i];
|
| if(have)
|
| {
|
| lb=(lb>dn || r[i-1].close<dn) ? lb : dn;
|
| ub=(ub<up || r[i-1].close>up) ? ub : up;
|
| }
|
| double d;
|
| if(!have)
|
| d=1.0;
|
| else
|
| if(st==up)
|
| d=(r[i].close>ub ? -1.0 : 1.0);
|
| else
|
| d=(r[i].close<lb ? 1.0 : -1.0);
|
| up=ub;
|
| dn=lb;
|
| st=(d<0 ? lb : ub);
|
| have=true;
|
| dir[i]=(d<0 ? 1 : -1); // research: trend = -direction
|
| }
|
| }
|
|
|
| //--- daily trend: last completed D1 close vs its EMA (seeded with the SMA of the first `period` closes)
|
| bool DailyTrend(int &dir,double &close1,double &ema1)
|
| {
|
| double c[];
|
| MqlRates d[];
|
| int n=GetBars(PERIOD_D1,D1WIN,d); // completed days only, oldest first
|
| ArrayResize(c,MathMax(n,0));
|
| for(int i=0; i<n; i++)
|
| c[i]=d[i].close;
|
| if(n<InpTrendEMA) // the EMA exists from the period-th close, as in the research
|
| return(false);
|
| double s=0;
|
| for(int i=0; i<InpTrendEMA; i++)
|
| s+=c[i];
|
| double e=s/InpTrendEMA,k=2.0/(InpTrendEMA+1);
|
| for(int i=InpTrendEMA; i<n; i++)
|
| e+=k*(c[i]-e);
|
| close1=c[n-1];
|
| ema1=e;
|
| dir=(close1>e ? 1 : (close1<e ? -1 : 0));
|
| return(true);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Signal from the last closed signal bar: +1 buy, -1 sell, 0 none |
|
| //+------------------------------------------------------------------+
|
| int Evaluate(void)
|
| {
|
| MqlRates r[];
|
| int n=GetBars(InpTF,WIN,r); // closed bars, oldest first
|
| if(n<MIN_BARS)
|
| return(0);
|
| double tr[],atr_ut[],atr_st[],atr_sl[],ut[];
|
| int st[];
|
| TrueRange(r,n,tr);
|
| Rma(tr,n,InpUTATR,atr_ut);
|
| Rma(tr,n,InpSTPeriod,atr_st);
|
| Rma(tr,n,InpStopATR,atr_sl);
|
| UTBot(r,n,atr_ut,InpUTKey,ut);
|
| Supertrend(r,n,atr_st,InpSTMult,st);
|
| int j=n-1;
|
| if(ut[j]==EMPTY_VALUE || ut[j-1]==EMPTY_VALUE || atr_sl[j]==EMPTY_VALUE)
|
| return(0);
|
| g_ut_stop=ut[j];
|
| g_ut_side=(r[j].close>ut[j] ? 1 : -1);
|
| g_st_dir=st[j];
|
| g_atr_stop=atr_sl[j];
|
| if(!DailyTrend(g_d1_dir,g_d1_close,g_d1_ema))
|
| return(0);
|
| bool ut_buy =r[j].close>ut[j] && r[j-1].close<=ut[j-1];
|
| bool ut_sell=r[j].close<ut[j] && r[j-1].close>=ut[j-1];
|
| if(ut_buy && g_d1_dir>0 && g_st_dir>0)
|
| return(1);
|
| if(ut_sell && g_d1_dir<0 && g_st_dir<0)
|
| return(-1);
|
| return(0);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Positions |
|
| //+------------------------------------------------------------------+
|
| //--- this EA's open order on the symbol (0 = none); it stays selected
|
| int MyTicket(void)
|
| {
|
| for(int i=OrdersTotal()-1; i>=0; i--)
|
| if(MyOrderAt(i))
|
| return(OrderTicket());
|
| return(0);
|
| }
|
|
|
| string TrailKey(const int ticket) { return("GTS_TRAIL_"+IntegerToString(ticket)); }
|
|
|
| //--- watch an order of this EA until it closes: its TRD debug line, alerts, and dropping its trail variable
|
| void TradeWatch(const int t,const double sl)
|
| {
|
| for(int k=0; k<ArraySize(g_trd); k++)
|
| if(g_trd[k]==t)
|
| return;
|
| int k=ArraySize(g_trd);
|
| ArrayResize(g_trd,k+1);
|
| ArrayResize(g_trd_sl,k+1);
|
| g_trd[k]=t;
|
| g_trd_sl[k]=sl;
|
| }
|
|
|
| //--- the watched orders that have closed (by this EA, the stop or the broker): one TRD line each (debug), the
|
| //--- the trail variable dropped. Called at every tick and after every close; the survive
|
| //--- check runs on the next tick (OnTick, once a second while an order is open)
|
| void TradeLine(void)
|
| {
|
| for(int k=ArraySize(g_trd)-1; k>=0; k--)
|
| {
|
| if(!OrderSelect(g_trd[k],SELECT_BY_TICKET) || OrderCloseTime()==0)
|
| continue;
|
| if(InpDebug)
|
| PrintFormat("TRD %s %s %s %s %s %s %s %.2f %.2f",TimeToString(OrderOpenTime(),TIME_DATE|TIME_MINUTES), // MQL4: no %.*f
|
| TimeToString(OrderCloseTime(),TIME_DATE|TIME_MINUTES),OrderType()==OP_BUY ? "BUY" : "SELL",
|
| DoubleToString(OrderLots(),2),DoubleToString(OrderOpenPrice(),_Digits),DoubleToString(OrderClosePrice(),_Digits),
|
| DoubleToString(g_trd_sl[k],_Digits),OrderProfit(),OrderSwap());
|
| GlobalVariableDel(TrailKey(g_trd[k]));
|
| int last=ArraySize(g_trd)-1;
|
| g_trd[k]=g_trd[last];
|
| g_trd_sl[k]=g_trd_sl[last];
|
| ArrayResize(g_trd,last);
|
| ArrayResize(g_trd_sl,last);
|
| g_stats_dirty=true;
|
| }
|
| }
|
|
|
| bool ClosePosition(const int ticket)
|
| {
|
| if(!OpenTicket(ticket))
|
| return(true);
|
| RefreshRates();
|
| bool lng=OrderType()==OP_BUY;
|
| bool ok=OrderClose(ticket,OrderLots(),lng ? Bid_() : Ask_(),50,clrNONE);
|
| if(!ok)
|
| PrintFormat("Gold Trend Sentinel MT4: close of #%d refused, error %d",ticket,GetLastError());
|
| TradeLine();
|
| return(ok);
|
| }
|
|
|
| //--- after any fill: if this EA's position could not reach its stop without the account hitting the broker's
|
| //--- stop-out level (e.g. after a gap), close it at market rather than let the broker force-close it
|
| void SurviveCheck(void)
|
| {
|
| int t=MyTicket();
|
| if(t==0)
|
| return;
|
| double worst=AccountInfoDouble(ACCOUNT_EQUITY);
|
| bool lng=OrderType()==OP_BUY;
|
| double psl=OrderStopLoss(),cur=lng ? Bid_() : Ask_();
|
| if(psl>0 && (lng ? psl<cur : psl>cur))
|
| worst-=GAP_MULT*OrderLots()*LossPerLot(cur,psl);
|
| double so=AccountInfoDouble(ACCOUNT_MARGIN_SO_SO);
|
| double used=AccountInfoDouble(ACCOUNT_MARGIN);
|
| double floor_=AccountInfoInteger(ACCOUNT_MARGIN_SO_MODE)==ACCOUNT_STOPOUT_MODE_PERCENT ? used*so/100.0 : so;
|
| if(worst<=floor_ && ClosePosition(t))
|
| {
|
| g_sig_result="closed: balance too small for SL";
|
| Print("Gold Trend Sentinel MT4: the balance could not carry the position to its stop; closed at market.");
|
| }
|
| }
|
|
|
| //--- market order with the stop attached; "placed" or why not
|
|
|
| string OpenPosition(const bool buy)
|
| {
|
| RefreshRates();
|
| double price=buy ? Ask_() : Bid_();
|
| double dist=InpStopMult*g_atr_stop;
|
| double gap=MarketInfo(_Symbol,MODE_STOPLEVEL)*_Point;
|
| double spread=Ask_()-Bid_();
|
| if(dist<gap+spread+_Point) // never inside the broker's stop level or the spread: a stop
|
| dist=gap+spread+_Point; // on the wrong side of the bid/ask is rejected "Invalid stops"
|
| double sl=FixPrice(buy ? price-dist : price+dist);
|
| string why="";
|
| double volume=TradeVolume(price,sl,why);
|
| if(volume<=0)
|
| return(why);
|
| string why_not=Affordable(buy,volume,price,sl);
|
| if(why_not!="")
|
| return(why_not);
|
| int t=OrderSend(_Symbol,buy ? OP_BUY : OP_SELL,volume,price,50,sl,0,"GTS",InpMagic,0,clrNONE);
|
| if(t<0)
|
| {
|
| int err=GetLastError();
|
| why=err==ERR_NOT_ENOUGH_MONEY ? "not enough margin" : "error "+IntegerToString(err);
|
| PrintFormat("Gold Trend Sentinel MT4: %s %.2f lot not opened: %s",buy ? "buy" : "sell",volume,why);
|
| return("rejected: "+why);
|
| }
|
| GlobalVariableSet(TrailKey(t),dist); // the trail keeps the entry's distance, across restarts
|
| TradeWatch(t,sl);
|
| return("placed");
|
| }
|
|
|
| //--- chandelier trail, once per signal bar: best price since entry (fill and every closed bar's extreme)
|
| void TrailStop(void)
|
| {
|
| if(!InpTrail)
|
| return;
|
| int t=MyTicket();
|
| if(t==0)
|
| return;
|
| double dist=GlobalVariableCheck(TrailKey(t)) ? GlobalVariableGet(TrailKey(t)) : InpStopMult*g_atr_stop;
|
| bool lng=OrderType()==OP_BUY;
|
| double open=OrderOpenPrice(),sl=OrderStopLoss();
|
| //--- from the start of the bar the position opened in: the research counts that bar's extreme too
|
| datetime opened=OrderOpenTime();
|
| int per=PeriodSeconds(InpTF);
|
| datetime since=g_native ? iTime(_Symbol,InpTF,MathMax(iBarShift(_Symbol,InpTF,opened),0)) : NyBucket(opened,per);
|
| datetime cur=CurBar();
|
| if(since>=cur)
|
| return; // opened in the current bar: nothing closed yet
|
| MqlRates r[];
|
| int n=GetBars(InpTF,(int)((cur-since)/per)+2,r);
|
| double best=open;
|
| for(int i=0; i<n; i++)
|
| if(r[i].time>=since)
|
| best=lng ? MathMax(best,r[i].high) : MathMin(best,r[i].low+r[i].spread*_Point);
|
| double ns=FixPrice(lng ? best-dist : best+dist);
|
| if(sl>0 && (lng ? ns<=sl : ns>=sl))
|
| return; // only ever tightens
|
| RefreshRates();
|
| double bid=Bid_(),ask=Ask_();
|
| double gap=MarketInfo(_Symbol,MODE_STOPLEVEL)*_Point;
|
| double freeze=MarketInfo(_Symbol,MODE_FREEZELEVEL)*_Point;
|
| //--- the new stop is already through the price: the tested rule exits at this bar's open
|
| if(lng ? ns>=bid : ns<=ask)
|
| {
|
| if(ClosePosition(t))
|
| PrintFormat("Gold Trend Sentinel MT4: trail stop %s passed the price, position closed",DoubleToString(ns,_Digits));
|
| return;
|
| }
|
| if(lng ? bid-ns<=MathMax(gap,freeze) : ns-ask<=MathMax(gap,freeze))
|
| return; // too close for the broker now; try again next bar
|
| if(OpenTicket(t) && !OrderModify(t,OrderOpenPrice(),ns,OrderTakeProfit(),0,clrNONE))
|
| PrintFormat("Gold Trend Sentinel MT4: trail of #%d to %s refused, error %d",t,DoubleToString(ns,_Digits),GetLastError());
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Chart: the UT Bot line and signal markers |
|
| //+------------------------------------------------------------------+
|
|
|
| void DrawLevels(void)
|
| {
|
| if(!g_ui || !InpShowLevels || g_ut_stop<=0)
|
| return;
|
| string name=PREFIX+"ut";
|
| if(ObjectFind(0,name)<0)
|
| {
|
| ObjectCreate(0,name,OBJ_HLINE,0,0,g_ut_stop);
|
| ObjectSetInteger(0,name,OBJPROP_STYLE,STYLE_DOT);
|
| ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);
|
| ObjectSetInteger(0,name,OBJPROP_HIDDEN,true);
|
| }
|
| ObjectSetDouble(0,name,OBJPROP_PRICE1,g_ut_stop);
|
| ObjectSetInteger(0,name,OBJPROP_COLOR,g_ut_side>0 ? UiPos() : UiNeg());
|
| ObjectSetString(0,name,OBJPROP_TOOLTIP,"UT Bot line "+DoubleToString(g_ut_stop,_Digits));
|
| }
|
|
|
| void Marker(const bool buy,const datetime t)
|
| {
|
| if(!g_ui || !InpShowLevels)
|
| return;
|
| string name=PREFIX+"m"+IntegerToString(g_markers%MARKERS);
|
| g_markers++;
|
| ObjectDelete(0,name);
|
| MqlRates r[];
|
| if(GetBars(InpTF,1,r)<1)
|
| return;
|
| double price=buy ? r[0].low : r[0].high;
|
| ObjectCreate(0,name,buy ? OBJ_ARROW_BUY : OBJ_ARROW_SELL,0,r[0].time-Shift(r[0].time),price);
|
| ObjectSetInteger(0,name,OBJPROP_COLOR,buy ? UiPos() : UiNeg());
|
| ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false);
|
| ObjectSetInteger(0,name,OBJPROP_HIDDEN,true);
|
| ObjectSetString(0,name,OBJPROP_TOOLTIP,(buy ? "buy signal: " : "sell signal: ")+g_sig_result);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Status panel |
|
| //+------------------------------------------------------------------+
|
| string Dir(const int d,const string up,const string dn) { return(d>0 ? up : (d<0 ? dn : "-")); }
|
|
|
| void DrawPanel(void)
|
| {
|
| if(!g_ui)
|
| return;
|
| if(g_stats_dirty)
|
| RecalcStats();
|
| g_cursor=0;
|
| Box("bg",0,0,UI_W,g_collapsed ? UI_HEAD : MathMax(g_rows,UI_HEAD),UiBack(),UiRule());
|
| Text("title",UI_PAD,5,"GOLD TREND SENTINEL",UiText());
|
| string ed="FREE";
|
| Text("ed",UI_W-UI_PAD-18-8-UI_CHAR*4,6,ed,UiAccent(),InpFontSize-1);
|
| Button("btn",UI_W-UI_PAD-18,4,g_collapsed ? "+" : "-");
|
| if(g_collapsed)
|
| return;
|
| int pos=MyTicket();
|
| double bid=Bid_(),ask=Ask_();
|
| g_pdh=bid;
|
| g_ref_stop=InpStopMult*g_atr_stop;
|
| string state;
|
| color sc;
|
| if(!g_symbol_ok)
|
| {
|
| state="XAUUSD only - idle";
|
| sc=UiNeg();
|
| }
|
| else
|
| if(!g_market_open)
|
| {
|
| state="market closed";
|
| sc=UiDim();
|
| }
|
| else
|
| if(pos>0 && OpenTicket(pos))
|
| {
|
| state=OrderType()==OP_BUY ? "in a long trade" : "in a short trade";
|
| sc=UiAccent();
|
| }
|
| else
|
| {
|
| state="watching for a signal";
|
| sc=UiText();
|
| }
|
| int y=UI_HEAD+2;
|
| y=Section("s1",y,"STATUS");
|
| y=Row("state",y,"State",state,sc);
|
| y=Row("lot",y,"Lot",LotText(),UiText());
|
| string rt=RiskText();
|
| y=Row("risk",y,"Risk",rt,rt=="-" ? UiDim() : RiskColor(g_risk_now));
|
| y=Row("spread",y,"Spread",DoubleToString(ask-bid,_Digits),UiAccent());
|
| y=Row("next",y,"Next check",Clock(SecsToNextBar()),UiDim());
|
| y=Row("clock",y,"Candles",ClockText(),g_native ? UiDim() : UiWarn());
|
| y=Section("s2",y,"TREND FILTERS");
|
| y=Row("d1",y,"Daily trend",g_d1_ema>0 ? Dir(g_d1_dir,"UP","DOWN")+StringFormat(" %+.1f%% vs EMA",100*(g_d1_close/g_d1_ema-1)) : "-",
|
| g_d1_dir>0 ? UiPos() : (g_d1_dir<0 ? UiNeg() : UiDim()));
|
| y=Row("st",y,"Supertrend",Dir(g_st_dir,"UP","DOWN"),g_st_dir>0 ? UiPos() : (g_st_dir<0 ? UiNeg() : UiDim()));
|
| y=Row("ut",y,"UT Bot line",g_ut_stop>0 ? Px(g_ut_stop)+(g_ut_side>0 ? " price above" : " price below") : "-",UiAccent());
|
| string allow=(g_d1_dir>0 && g_st_dir>0) ? "buys only" : ((g_d1_dir<0 && g_st_dir<0) ? "sells only" : "none (filters disagree)");
|
| y=Row("allow",y,"Allowed",allow,StringFind(allow,"none")==0 ? UiDim() : UiWarn());
|
| string ls=g_sig_time>0 ? StringFormat("%s %s",g_sig_side>0 ? "BUY" : "SELL",TimeToString(g_sig_time,TIME_DATE|TIME_MINUTES)) : "none yet";
|
| y=Row("last",y,"Last signal",ls,g_sig_time>0 ? (g_sig_side>0 ? UiPos() : UiNeg()) : UiDim());
|
| y=Row("res",y,"",g_sig_result,g_sig_result=="placed" || g_sig_result=="reversed" ? UiPos() : UiDim());
|
| y=Section("s3",y,"POSITION");
|
| string pv="-",slv="-",fl="-",rr="-";
|
| color fc=UiDim();
|
| if(pos>0 && OpenTicket(pos))
|
| {
|
| bool lng=OrderType()==OP_BUY;
|
| double op=OrderOpenPrice(),sl=OrderStopLoss();
|
| double f=OrderProfit()+OrderSwap();
|
| double dist=GlobalVariableCheck(TrailKey(pos)) ? GlobalVariableGet(TrailKey(pos)) : g_ref_stop;
|
| pv=StringFormat("%s %s @ %s",lng ? "LONG" : "SHORT",DoubleToString(OrderLots(),2),Px(op));
|
| slv=Px(sl)+(sl>0 && (lng ? sl>op : sl<op) ? " locked in" : "");
|
| fl=Money(f);
|
| fc=Sign(f);
|
| if(dist>0)
|
| rr=StringFormat("%+.2fR",(lng ? bid-op : op-ask)/dist);
|
| }
|
| y=Row("pos",y,"Position",pv,pos>0 ? UiText() : UiDim());
|
| y=Row("sl",y,"Trail stop",slv,pos>0 ? UiText() : UiDim());
|
| y=Row("float",y,"Floating",fl,fc);
|
| y=Row("rnow",y,"Now",rr,pos>0 ? UiText() : UiDim());
|
| y=Section("s4",y,"RESULTS (this EA, this symbol)");
|
| string tr=g_closed>0 ? StringFormat("%d (%dW / %dL, %.0f%%)",g_closed,g_wins,g_closed-g_wins,100.0*g_wins/g_closed) : "none yet";
|
| y=Row("trades",y,"Trades",tr,g_closed>0 ? UiText() : UiDim());
|
| y=Row("net",y,"Net",Money(g_net),Sign(g_net));
|
| string pf=g_gross_loss>0 ? DoubleToString(g_gross_win/g_gross_loss,2) : (g_gross_win>0 ? "inf" : "-");
|
| y=Row("pf",y,"Profit factor",pf,g_closed>0 ? UiText() : UiDim());
|
| y=Row("today",y,"Today",Money(g_today),Sign(g_today));
|
| g_rows=y+UI_PAD-4;
|
| Box("bg",0,0,UI_W,g_rows,UiBack(),UiRule());
|
| if(g_panel_dirty)
|
| {
|
| ChartRedraw();
|
| g_panel_dirty=false;
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Expert events |
|
| //+------------------------------------------------------------------+
|
| //--- XAUUSD, with any broker prefix or suffix (XAUUSDm, XAUUSD.pro, pXAUUSD...)
|
| bool GoldSymbol(void)
|
| {
|
| string s=_Symbol;
|
| StringToUpper(s);
|
| return(StringFind(s,"XAUUSD")>=0);
|
| }
|
|
|
| int OnInit(void)
|
| {
|
| g_tick=MarketInfo(_Symbol,MODE_TICKSIZE);
|
| g_vol_min=MarketInfo(_Symbol,MODE_MINLOT);
|
| g_vol_max=MarketInfo(_Symbol,MODE_MAXLOT);
|
| g_vol_step=MarketInfo(_Symbol,MODE_LOTSTEP);
|
| g_last_bar=0;
|
| //--- live and demo charts: XAUUSD only. The Strategy Tester may test any symbol (the Market's automatic
|
| //--- validation runs EURUSD and GBPUSD on a small account, where gold's minimum lot cannot be carried safely)
|
| g_symbol_ok=GoldSymbol() || MQLInfoInteger(MQL_TESTER);
|
| if(!GoldSymbol())
|
| {
|
| string msg=MQLInfoInteger(MQL_TESTER) ?
|
| StringFormat("Gold Trend Sentinel MT4: testing %s in the Strategy Tester; on live charts it trades XAUUSD only.",_Symbol) :
|
| StringFormat("Gold Trend Sentinel MT4 works on XAUUSD charts only; it will not trade on %s.",_Symbol);
|
| Print(msg);
|
| if(!MQLInfoInteger(MQL_TESTER))
|
| Alert(msg);
|
| }
|
| ResolveClock();
|
| if(InpDebug) // one line with everything a bug report needs (no account number)
|
| PrintFormat("DBG start: Gold Trend Sentinel %s %s, %s, signals %s, server %s, %s account, digits %d, tick %s, "
|
| "lot min/step/max %s/%s/%s, stops %d, freeze %d, clock %s, terminal build %d",GTS_VERSION,
|
| "Free",_Symbol,StringSubstr(EnumToString(InpTF),7),AccountInfoString(ACCOUNT_SERVER),
|
| "MT4",_Digits,DoubleToString(g_tick,_Digits),
|
| DoubleToString(g_vol_min,2),DoubleToString(g_vol_step,2),
|
| DoubleToString(g_vol_max,2),(int)MarketInfo(_Symbol,MODE_STOPLEVEL),
|
| (int)MarketInfo(_Symbol,MODE_FREEZELEVEL),ClockText(),(int)TerminalInfoInteger(TERMINAL_BUILD));
|
| bool tester=(bool)MQLInfoInteger(MQL_TESTER);
|
| if(tester && InpClock==GTS_CLOCK_AUTO)
|
| Print("Gold Trend Sentinel MT4: the Strategy Tester can't detect the broker's clock; New York close is assumed. ",
|
| "Set 'Broker server clock' for a broker on another clock.");
|
| PrintFormat("Gold Trend Sentinel MT4: candles on the New York-close clock (%s)",ClockText());
|
| g_ui=InpShowPanel && !MQLInfoInteger(MQL_OPTIMIZATION) && (!tester || MQLInfoInteger(MQL_VISUAL_MODE));
|
| //--- drop trail variables of positions that no longer exist (closed while the EA was off)
|
| for(int i=GlobalVariablesTotal()-1; i>=0; i--)
|
| {
|
| string gv=GlobalVariableName(i);
|
| if(StringFind(gv,"GTS_TRAIL_")!=0)
|
| continue;
|
| if(!OpenTicket((int)StringToInteger(StringSubstr(gv,10))))
|
| GlobalVariableDel(gv);
|
| }
|
| //--- orders already open (a restart): watch them until they close
|
| ArrayResize(g_trd,0);
|
| ArrayResize(g_trd_sl,0);
|
| for(int i=OrdersTotal()-1; i>=0; i--)
|
| if(MyOrderAt(i))
|
| TradeWatch(OrderTicket(),OrderStopLoss());
|
| g_hist_seen=0;
|
| if(!tester)
|
| EventSetTimer(1);
|
| if(g_ui)
|
| {
|
| CacheClear();
|
| g_stats_dirty=true;
|
| DrawPanel();
|
| }
|
| return(INIT_SUCCEEDED);
|
| }
|
|
|
| void OnDeinit(const int reason)
|
| {
|
| EventKillTimer();
|
| ObjectsDeleteAll(0,PREFIX);
|
| CacheClear();
|
| ChartRedraw();
|
| }
|
|
|
| void OnTick(void)
|
| {
|
| TradeLine(); // orders closed since the last tick (stop hits)
|
| if(OrdersHistoryTotal()!=g_hist_seen)
|
| g_stats_dirty=true;
|
| if(!g_symbol_ok) // not an XAUUSD chart: never trade
|
| return;
|
| datetime bar=CurBar();
|
| static datetime guarded=0; // an open trade must stay survivable to its stop; swaps or
|
| if(OrdersTotal()>0 && TimeCurrent()!=guarded) // another position can drain the account: once a second
|
| {
|
| guarded=TimeCurrent();
|
| SurviveCheck();
|
| }
|
| if(bar==g_last_bar || (g_last_bar==0 && Bars(_Symbol,InpTF)<MIN_BARS))
|
| {
|
| if(g_ui && MQLInfoInteger(MQL_TESTER) && TimeCurrent()!=g_last_ui)
|
| {
|
| g_last_ui=TimeCurrent();
|
| DrawPanel();
|
| }
|
| return;
|
| }
|
| g_last_bar=bar;
|
| g_market_open=IsMarketOpen();
|
| if(!g_market_open)
|
| {
|
| g_last_bar=0; // try again on the first tick of the session
|
| DrawPanel();
|
| return;
|
| }
|
| int sig=Evaluate();
|
| if(InpDebug)
|
| PrintFormat("DBG %s: ut %s side %d, supertrend %d, daily %d (close %s ema %s), atr %s, signal %d",
|
| TimeToString(bar),DoubleToString(g_ut_stop,_Digits),g_ut_side,g_st_dir,g_d1_dir,
|
| DoubleToString(g_d1_close,_Digits),DoubleToString(g_d1_ema,_Digits),DoubleToString(g_atr_stop,_Digits),sig);
|
| //--- the tested order of events: exits decided at the close (reversal), then entries, then the trail
|
| int t=MyTicket();
|
| int pos=0;
|
| if(t>0)
|
| pos=OrderType()==OP_BUY ? 1 : -1;
|
| if(sig!=0)
|
| {
|
| g_sig_time=g_native ? iTime(_Symbol,InpTF,1) : bar-PeriodSeconds(InpTF)-Shift(TimeCurrent()); // server time
|
| g_sig_side=sig;
|
| if(pos==sig)
|
| {
|
| g_sig_result="already in this direction";
|
| TrailStop(); // the research tightens the trail on this bar too
|
| }
|
| else
|
| {
|
| bool reversed=false;
|
| if(pos==-sig)
|
| reversed=ClosePosition(t);
|
| if(pos==0 || reversed)
|
| {
|
| g_sig_result=OpenPosition(sig>0);
|
| if(reversed && g_sig_result=="placed")
|
| g_sig_result="reversed";
|
| }
|
| else
|
| g_sig_result="could not close the old trade";
|
| }
|
| Marker(sig>0,g_sig_time);
|
| if(InpDebug)
|
| PrintFormat("DBG %s: signal %s -> %s",TimeToString(bar),sig>0 ? "BUY" : "SELL",g_sig_result);
|
| }
|
| else
|
| TrailStop();
|
| DrawLevels();
|
| DrawPanel();
|
| }
|
|
|
| void OnTimer(void)
|
| {
|
| if(g_ui && TimeLocal()-g_cache_reset>=60)
|
| {
|
| g_cache_reset=TimeLocal();
|
| CacheClear();
|
| }
|
| DrawPanel();
|
| }
|
|
|
| void OnChartEvent(const int id,const long &lparam,const double &dparam,const string &sparam)
|
| {
|
| if(id==CHARTEVENT_OBJECT_CLICK && sparam==PREFIX+"btn")
|
| {
|
| g_collapsed=!g_collapsed;
|
| ObjectsDeleteAll(0,PREFIX+"s");
|
| for(int i=ObjectsTotal(0,0,OBJ_LABEL)-1; i>=0; i--)
|
| {
|
| string n=ObjectName(0,i,0,OBJ_LABEL);
|
| if(StringFind(n,PREFIX)==0 && n!=PREFIX+"title" && n!=PREFIX+"ed")
|
| ObjectDelete(0,n);
|
| }
|
| CacheClear();
|
| DrawPanel();
|
| ChartRedraw();
|
| }
|
| }
|
| //+------------------------------------------------------------------+
|
