| //+------------------------------------------------------------------+
|
| //| PrgRules.mqh |
|
| //| Copyright 2026, Allan Niñal |
|
| //| https://www.allanninal.dev/mql5 |
|
| //+------------------------------------------------------------------+
|
| //| Rule engine of Prop Rules Monitor. It only measures: day start, |
|
| //| daily and overall loss floors, trading days. It never trades. |
|
| //| |
|
| //| Daily floor = day-start reference - daily limit |
|
| //| reference: balance, equity or the higher of the two at the |
|
| //| reset instant (a time of day in a chosen time zone); |
|
| //| limit: % of the initial balance or of that reference. |
|
| //| Overall floor = initial - max% (static), or the peak (equity, |
|
| //| balance, or end-of-day balance) - max% of the initial, which |
|
| //| can stop rising once it reaches the initial balance. |
|
| //| Breach = equity at or below a floor (open trades count). |
|
| //| Times: deals and resets are compared in broker server time; the |
|
| //| reset zone is converted with built-in EU/US daylight-saving |
|
| //| rules. Nothing here uses the network. |
|
| //| MT4 edition: the same measurements. MT4 keeps orders, not deals: |
|
| //| the history scan reads balance operations and closed orders (P&L |
|
| //| at the close, commission included; a day is a trading day when a |
|
| //| trade was opened in it) and is rebuilt when the orders change; |
|
| //| the server clock is GMT + an offset learnt from a fresh tick. |
|
| //+------------------------------------------------------------------+
|
| // SPDX-License-Identifier: LicenseRef-PolyForm-Noncommercial-1.0.0 (see LICENSE)
|
| #ifndef PRG_RULES_MQH
|
| #define PRG_RULES_MQH
|
|
|
| //--- MT5 shows each enum choice by the comment on its own line, so every member needs one
|
| enum ENUM_PRG_REF
|
| {
|
| PRG_REF_BALANCE=0, // Balance at the reset
|
| PRG_REF_EQUITY=1, // Equity at the reset
|
| PRG_REF_HIGHER=2 // Higher of balance and equity at the reset
|
| };
|
| enum ENUM_PRG_OF
|
| {
|
| PRG_OF_INITIAL=0, // % of the initial balance (account size)
|
| PRG_OF_DAYSTART=1 // % of the day-start reference
|
| };
|
| enum ENUM_PRG_ZONE
|
| {
|
| PRG_ZONE_BROKER=0, // Broker server time
|
| PRG_ZONE_PRAGUE=1, // Central Europe (Prague, CET/CEST)
|
| PRG_ZONE_UTC=2, // UTC
|
| PRG_ZONE_NEWYORK=3, // New York (EST/EDT)
|
| PRG_ZONE_LONDON=4, // London (GMT/BST)
|
| PRG_ZONE_UTC3=5 // UTC+3 all year
|
| };
|
| enum ENUM_PRG_MAX
|
| {
|
| PRG_MAX_STATIC=0, // Static: initial balance - max %
|
| PRG_MAX_TRAIL_EQ=1, // Trailing from the highest equity
|
| PRG_MAX_TRAIL_BAL=2, // Trailing from the highest closed balance
|
| PRG_MAX_EOD=3, // Trailing from the highest end-of-day balance
|
| PRG_MAX_SMART=4 // Two-stage: max % until a gain, then a smaller fixed %
|
| };
|
| enum ENUM_PRG_CLOCK
|
| {
|
| PRG_CLOCK_AUTO=0, // Auto: detect from the live server time
|
| PRG_CLOCK_NY=1, // New York close: UTC+2/+3 with US daylight saving
|
| PRG_CLOCK_EET=2, // UTC+2/+3 with European daylight saving
|
| PRG_CLOCK_FIXED=3 // Fixed offset from UTC, no daylight saving
|
| };
|
|
|
| //--- one set of rules (the user's own)
|
| struct PrgRules
|
| {
|
| string name;
|
| double daily_pct; // 0 = no daily limit
|
| ENUM_PRG_REF daily_ref;
|
| ENUM_PRG_OF daily_of;
|
| ENUM_PRG_ZONE reset_zone;
|
| int reset_hour; // hour of the reset in that zone (0-23)
|
| double max_pct; // 0 = no overall limit
|
| ENUM_PRG_MAX max_mode;
|
| bool max_stop_at_initial; // a trailing floor stops rising at the initial balance
|
| double smart_gain_pct; // PRG_MAX_SMART: closed-balance gain that switches the floor ...
|
| double smart_after_pct; // ... to account size - this %
|
| double target_pct; // profit target, 0 = none
|
| int min_days; // minimum trading days, 0 = none
|
| };
|
|
|
| //--- what the engine measured, for the panel
|
| struct PrgState
|
| {
|
| double initial; // account size the % limits use
|
| bool initial_auto; // taken from the first deposit
|
| datetime day_start; // current reset instant, server time
|
| datetime next_reset;
|
| double ref_balance; // balance at the reset
|
| double ref_equity; // equity at the reset (= balance when not measured)
|
| bool ref_measured; // true when the program was running at the reset
|
| double daily_floor; // equity at or below this breaks the daily limit (-DBL_MAX = off)
|
| double daily_limit; // money
|
| double max_floor; // (-DBL_MAX = off)
|
| double peak_equity;
|
| double peak_balance;
|
| double peak_eod;
|
| double balance,equity;
|
| double today_closed; // closed P&L since the reset
|
| int trading_days; // days with at least one new trade
|
| double daily_used_pct; // 0..100+ of the daily limit
|
| double max_used_pct;
|
| };
|
|
|
| PrgRules g_rules;
|
| PrgState g_st;
|
|
|
| //--- clock of the broker server, resolved once
|
| ENUM_PRG_CLOCK g_prg_clock=PRG_CLOCK_NY;
|
| int g_prg_fixed=0; // seconds, PRG_CLOCK_FIXED
|
|
|
| //+------------------------------------------------------------------+
|
| //| Time zones |
|
| //+------------------------------------------------------------------+
|
| //--- Sunday on or after `day` of `month` in year `y`, at `hour` UTC
|
| datetime PrgSundayFrom(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 PrgUsDst(const datetime utc)
|
| {
|
| MqlDateTime t;
|
| TimeToStruct(utc,t);
|
| return(utc>=PrgSundayFrom(t.year,3,8,7) && utc<PrgSundayFrom(t.year,11,1,6));
|
| }
|
|
|
| //--- EU summer time: last Sunday of March to last Sunday of October, 01:00 UTC
|
| bool PrgEuDst(const datetime utc)
|
| {
|
| MqlDateTime t;
|
| TimeToStruct(utc,t);
|
| return(utc>=PrgSundayFrom(t.year,3,25,1) && utc<PrgSundayFrom(t.year,10,25,1));
|
| }
|
|
|
| //--- offset of a named zone from UTC at UTC time `utc`, seconds
|
| int PrgZoneOffset(const ENUM_PRG_ZONE zone,const datetime utc)
|
| {
|
| switch(zone)
|
| {
|
| case PRG_ZONE_PRAGUE: return(PrgEuDst(utc) ? 2*3600 : 3600);
|
| case PRG_ZONE_LONDON: return(PrgEuDst(utc) ? 3600 : 0);
|
| case PRG_ZONE_NEWYORK: return(PrgUsDst(utc) ? -4*3600 : -5*3600);
|
| case PRG_ZONE_UTC3: return(3*3600);
|
| default: return(0);
|
| }
|
| }
|
|
|
| //--- the broker's offset from UTC at server time `srv`
|
| int PrgBrokerOffset(const datetime srv)
|
| {
|
| if(g_prg_clock==PRG_CLOCK_FIXED)
|
| return(g_prg_fixed);
|
| if(g_prg_clock==PRG_CLOCK_EET)
|
| return(PrgEuDst(srv-2*3600) ? 3*3600 : 2*3600);
|
| return(PrgUsDst(srv-2*3600) ? 3*3600 : 2*3600);
|
| }
|
|
|
| //--- decide the server clock: the input, or the live server time against UTC (the tester can't tell)
|
| void PrgResolveClock(const ENUM_PRG_CLOCK input_clock,const int fixed_hours)
|
| {
|
| g_prg_clock=input_clock;
|
| g_prg_fixed=fixed_hours*3600;
|
| if(input_clock!=PRG_CLOCK_AUTO)
|
| return;
|
| g_prg_clock=PRG_CLOCK_NY;
|
| if(IsTesting())
|
| return;
|
| datetime gmt=TimeGMT();
|
| long off=(long)TimeCurrent()-(long)gmt; // the last tick's server time (MQL4 has no TimeTradeServer)
|
| off=(long)MathRound(off/1800.0)*1800;
|
| if(MathAbs(off)>14*3600) // a frozen weekend server time: keep New York close
|
| return;
|
| int ny=PrgUsDst(gmt) ? 3*3600 : 2*3600;
|
| int eu=PrgEuDst(gmt) ? 3*3600 : 2*3600;
|
| if(off==ny)
|
| return;
|
| if(off==eu)
|
| {
|
| g_prg_clock=PRG_CLOCK_EET;
|
| return;
|
| }
|
| g_prg_clock=PRG_CLOCK_FIXED;
|
| g_prg_fixed=(int)off;
|
| }
|
|
|
| string PrgClockName(void)
|
| {
|
| switch(g_prg_clock)
|
| {
|
| case PRG_CLOCK_EET: return("UTC+2/+3 EU");
|
| case PRG_CLOCK_FIXED: return(StringFormat("UTC%+.1f",g_prg_fixed/3600.0));
|
| default: return("NY close");
|
| }
|
| }
|
|
|
| //--- floor `t` to the last instant whose time of day is `hour`:00 (all in one clock)
|
| datetime PrgFloorToHour(const datetime t,const int hour)
|
| {
|
| long k=(long)t-hour*3600;
|
| long m=k%86400;
|
| if(m<0)
|
| m+=86400;
|
| return((datetime)((long)t-m));
|
| }
|
|
|
| //--- the reset instant (server time) of the trading day that contains server time `srv`
|
| datetime PrgDayStart(const datetime srv)
|
| {
|
| if(g_rules.reset_zone==PRG_ZONE_BROKER)
|
| return(PrgFloorToHour(srv,g_rules.reset_hour));
|
| datetime utc=srv-PrgBrokerOffset(srv);
|
| datetime loc=utc+PrgZoneOffset(g_rules.reset_zone,utc);
|
| datetime rl=PrgFloorToHour(loc,g_rules.reset_hour); // reset, zone local time
|
| datetime ru=rl-PrgZoneOffset(g_rules.reset_zone,rl-PrgZoneOffset(g_rules.reset_zone,utc));
|
| return(ru+PrgBrokerOffset(ru+2*3600));
|
| }
|
|
|
| string PrgZoneName(const ENUM_PRG_ZONE z)
|
| {
|
| switch(z)
|
| {
|
| case PRG_ZONE_PRAGUE: return("Prague");
|
| case PRG_ZONE_UTC: return("UTC");
|
| case PRG_ZONE_NEWYORK: return("New York");
|
| case PRG_ZONE_LONDON: return("London");
|
| case PRG_ZONE_UTC3: return("UTC+3");
|
| default: return("server");
|
| }
|
| }
|
|
|
| //--- current 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 PrgNow(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));
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Persistence: terminal global variables keyed by the login, so a |
|
| //| restart, re-attach or timeframe change keeps peaks and the day |
|
| //| start: PRG.<login>.MON.<field>. |
|
| //+------------------------------------------------------------------+
|
| string g_prg_ns=""; // "MON." (set before PrgInit)
|
|
|
| string PrgKey(const string field)
|
| {
|
| return("PRG."+IntegerToString(AccountInfoInteger(ACCOUNT_LOGIN))+"."+g_prg_ns+field);
|
| }
|
|
|
| double PrgGet(const string field,const double def)
|
| {
|
| string k=PrgKey(field);
|
| return(GlobalVariableCheck(k) ? GlobalVariableGet(k) : def);
|
| }
|
|
|
| void PrgSet(const string field,const double v)
|
| {
|
| if(IsTesting() && IsOptimization())
|
| return;
|
| GlobalVariableSet(PrgKey(field),v);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| History scan: initial deposit, closed P&L per trading day, peak |
|
| //| balance, peak end-of-day balance, trading days. Called at start |
|
| //| and after every new deal; prop accounts have short histories. |
|
| //+------------------------------------------------------------------+
|
| double g_day_pnl[]; // closed P&L per trading day ...
|
| datetime g_day_key[]; // ... keyed by its reset instant
|
| bool g_day_traded[]; // a new position was opened that day
|
| double g_initial_input=0; // 0 = first deposit
|
|
|
| int PrgDaySlot(const datetime key)
|
| {
|
| int n=ArraySize(g_day_key);
|
| if(n>0 && g_day_key[n-1]==key)
|
| return(n-1);
|
| for(int i=n-1; i>=0; i--)
|
| if(g_day_key[i]==key)
|
| return(i);
|
| ArrayResize(g_day_key,n+1,64);
|
| ArrayResize(g_day_pnl,n+1,64);
|
| ArrayResize(g_day_traded,n+1,64);
|
| g_day_key[n]=key;
|
| g_day_pnl[n]=0;
|
| g_day_traded[n]=false;
|
| return(n);
|
| }
|
|
|
| //--- running totals of the scan, so each call reads only the deals added since the last one
|
| double g_scan_run=0,g_scan_peak=0,g_scan_eod=0,g_scan_day_end=0,g_scan_first=0;
|
| datetime g_scan_day=0,g_scan_time=0;
|
| double g_scan_base=0; // MT4: added to the running sums when no deposit is in the history
|
|
|
| void PrgScanReset(void)
|
| {
|
| ArrayResize(g_day_key,0);
|
| ArrayResize(g_day_pnl,0);
|
| ArrayResize(g_day_traded,0);
|
| g_scan_run=g_scan_peak=g_scan_eod=g_scan_day_end=g_scan_first=0;
|
| g_scan_day=g_scan_time=0;
|
| g_scan_base=0;
|
| }
|
|
|
| //--- the account's history as events in time order (MT4 keeps orders): a balance operation (kind 0), a closed trade's
|
| //--- P&L at its close (kind 1, profit + swap + commission), and the opening of a trade (kind 2, value 0), history and
|
| //--- open orders; in one second, balance first, then closes, then opens, then reading order
|
| int PrgEvents(datetime &t[],int &kind[],double &v[])
|
| {
|
| int nh=OrdersHistoryTotal(),no=OrdersTotal(),n=0;
|
| ArrayResize(t,2*(nh+no)); ArrayResize(kind,2*(nh+no)); ArrayResize(v,2*(nh+no));
|
| for(int pass=0; pass<2; pass++)
|
| for(int i=0; i<(pass==0 ? nh : no); i++)
|
| {
|
| if(!OrderSelect(i,SELECT_BY_POS,pass==0 ? MODE_HISTORY : MODE_TRADES))
|
| continue;
|
| int ty=OrderType();
|
| if(pass==0 && ty==6) // balance operation (deposit, withdrawal); 7 = credit: not balance
|
| { t[n]=OrderCloseTime()>0 ? OrderCloseTime() : OrderOpenTime(); kind[n]=0; v[n]=OrderProfit(); n++; continue; }
|
| if(ty>OP_SELL)
|
| continue;
|
| if(StringFind(OrderComment(),"from #")!=0) // the rest of a partly closed order is not a new trade
|
| { t[n]=OrderOpenTime(); kind[n]=2; v[n]=0; n++; }
|
| if(pass==0)
|
| { t[n]=OrderCloseTime(); kind[n]=1; v[n]=OrderProfit()+OrderSwap()+OrderCommission(); n++; }
|
| }
|
| double key[][2];
|
| ArrayResize(key,n);
|
| for(int i=0; i<n; i++)
|
| { key[i][0]=((double)t[i]*4.0+kind[i])*1048576.0+i; key[i][1]=i; }
|
| if(n>1)
|
| ArraySort(key);
|
| datetime t2[];
|
| int k2[];
|
| double v2[];
|
| ArrayResize(t2,n); ArrayResize(k2,n); ArrayResize(v2,n);
|
| for(int i=0; i<n; i++)
|
| { int j=(int)key[i][1]; t2[i]=t[j]; k2[i]=kind[j]; v2[i]=v[j]; }
|
| ArrayCopy(t,t2); ArrayCopy(kind,k2); ArrayCopy(v,v2);
|
| ArrayResize(t,n); ArrayResize(kind,n); ArrayResize(v,n);
|
| return(n);
|
| }
|
|
|
| void PrgScanHistory(void)
|
| {
|
| datetime now=PrgNow();
|
| PrgScanReset(); // MT4: no deal list to continue from - read it all again
|
| datetime et[];
|
| int ek[];
|
| double ev[];
|
| int n=PrgEvents(et,ek,ev);
|
| for(int i=0; i<n; i++)
|
| {
|
| datetime t=et[i];
|
| double v=ev[i];
|
| g_scan_time=MathMax(g_scan_time,t);
|
| datetime key=PrgDayStart(t);
|
| if(ek[i]==2) // an opening: a trading day, no money moved
|
| {
|
| g_day_traded[PrgDaySlot(key)]=true;
|
| continue;
|
| }
|
| if(g_scan_day!=0 && key!=g_scan_day) // a day ended: its closing balance
|
| g_scan_eod=MathMax(g_scan_eod,g_scan_day_end);
|
| g_scan_day=key;
|
| g_scan_run+=v;
|
| g_scan_day_end=g_scan_run;
|
| if(ek[i]==0)
|
| {
|
| if(g_scan_first==0 && v>0)
|
| g_scan_first=v;
|
| g_scan_peak=MathMax(g_scan_peak,g_scan_run);
|
| g_scan_eod=MathMax(g_scan_eod,g_scan_run);
|
| continue;
|
| }
|
| int sl=PrgDaySlot(key);
|
| g_day_pnl[sl]+=v;
|
| g_scan_peak=MathMax(g_scan_peak,g_scan_run);
|
| }
|
| //--- no deposit in the history (the Account History tab starts later, or the tester): the running sums are relative;
|
| //--- anchor them to the balance now, so balance peaks and end-of-day balances are real balances
|
| if(g_scan_first==0 && n>0)
|
| {
|
| double base=AccountInfoDouble(ACCOUNT_BALANCE)-g_scan_run;
|
| g_scan_run+=base; g_scan_peak+=base; g_scan_eod+=base; g_scan_day_end+=base;
|
| g_scan_base=base;
|
| }
|
| double bal=AccountInfoDouble(ACCOUNT_BALANCE);
|
| double first_dep=g_scan_first>0 ? g_scan_first : bal-(g_scan_run-g_scan_base); // tester or no deposit in history
|
| g_st.initial_auto=(g_initial_input<=0);
|
| g_st.initial=g_initial_input>0 ? g_initial_input : (first_dep>0 ? first_dep : bal);
|
| g_st.peak_balance=MathMax(MathMax(g_scan_peak,g_st.initial),bal);
|
| //--- end-of-day peak: days that closed before today's reset, plus the stored live value
|
| datetime today=PrgDayStart(now);
|
| double peak_eod=g_scan_eod;
|
| if(g_scan_day!=0 && g_scan_day<today)
|
| peak_eod=MathMax(peak_eod,g_scan_day_end);
|
| g_st.peak_eod=MathMax(MathMax(peak_eod,g_st.initial),MathMax(g_st.peak_eod,PrgGet("peak_eod",0)));
|
| PrgTotals(today);
|
| }
|
|
|
| //--- trading-day totals from the per-day table
|
| void PrgTotals(const datetime today)
|
| {
|
| g_st.trading_days=0;
|
| g_st.today_closed=0;
|
| for(int i=0; i<ArraySize(g_day_key); i++)
|
| {
|
| if(g_day_traded[i])
|
| g_st.trading_days++;
|
| if(g_day_key[i]==today)
|
| g_st.today_closed=g_day_pnl[i];
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Day start: measured when the program runs through the reset, |
|
| //| otherwise rebuilt as the balance minus every deal since then. |
|
| //| Equity at a reset the program missed cannot be known: it then |
|
| //| equals the rebuilt balance and the panel says "rebuilt". |
|
| //+------------------------------------------------------------------+
|
| //--- money moved in the history at or after a time (closed P&L and balance operations)
|
| double PrgMovedSince(const datetime start)
|
| {
|
| double since=0;
|
| datetime et[];
|
| int ek[];
|
| double ev[];
|
| int n=PrgEvents(et,ek,ev);
|
| for(int i=0; i<n; i++)
|
| if(et[i]>=start)
|
| since+=ev[i];
|
| return(since);
|
| }
|
|
|
| void PrgRebuildDayStart(const datetime start)
|
| {
|
| g_st.ref_balance=AccountInfoDouble(ACCOUNT_BALANCE)-PrgMovedSince(start);
|
| g_st.ref_equity=g_st.ref_balance;
|
| g_st.ref_measured=false;
|
| }
|
|
|
| //--- start (or restart) the engine
|
| void PrgInit(void)
|
| {
|
| ZeroMemory(g_st);
|
| g_st.day_start=0;
|
| PrgScanReset();
|
| PrgScanHistory();
|
| g_st.peak_equity=MathMax(PrgGet("peak_eq",0),MathMax(g_st.peak_balance,AccountInfoDouble(ACCOUNT_EQUITY)));
|
| datetime now=PrgNow();
|
| datetime start=PrgDayStart(now);
|
| //--- a day start stored by a program that was running at the reset is kept
|
| if((datetime)PrgGet("day",0)==start)
|
| {
|
| g_st.ref_balance=PrgGet("day_bal",0);
|
| g_st.ref_equity=PrgGet("day_eq",0);
|
| g_st.ref_measured=PrgGet("day_meas",0)>0;
|
| }
|
| else
|
| {
|
| PrgRebuildDayStart(start);
|
| PrgSet("day",(double)start);
|
| PrgSet("day_bal",g_st.ref_balance);
|
| PrgSet("day_eq",g_st.ref_equity);
|
| PrgSet("day_meas",0);
|
| }
|
| g_st.day_start=start;
|
| g_st.next_reset=PrgDayStart(start+26*3600);
|
| if(g_st.next_reset<=start)
|
| g_st.next_reset=start+86400;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Per tick / timer update. Returns true when a new day started. |
|
| //+------------------------------------------------------------------+
|
| bool PrgUpdate(void)
|
| {
|
| bool new_day=false;
|
| datetime now=PrgNow();
|
| g_st.balance=AccountInfoDouble(ACCOUNT_BALANCE);
|
| g_st.equity=AccountInfoDouble(ACCOUNT_EQUITY);
|
| if(now>=g_st.next_reset)
|
| {
|
| //--- running through the reset: today's reference is measured, yesterday's close is an end-of-day value;
|
| //--- the first tick of the day can come late (a gap) with stops already filled after the reset: those belong
|
| //--- to the new day, so they are taken out of both
|
| g_st.day_start=PrgDayStart(now);
|
| g_st.next_reset=PrgDayStart(g_st.day_start+26*3600);
|
| if(g_st.next_reset<=g_st.day_start)
|
| g_st.next_reset=g_st.day_start+86400;
|
| double since=PrgMovedSince(g_st.day_start);
|
| g_st.peak_eod=MathMax(g_st.peak_eod,g_st.balance-since);
|
| PrgSet("peak_eod",g_st.peak_eod);
|
| g_st.ref_balance=g_st.balance-since;
|
| g_st.ref_equity=g_st.equity-since;
|
| g_st.ref_measured=true;
|
| g_st.today_closed=0;
|
| PrgSet("day",(double)g_st.day_start);
|
| PrgSet("day_bal",g_st.ref_balance);
|
| PrgSet("day_eq",g_st.ref_equity);
|
| PrgSet("day_meas",1);
|
| PrgTotals(g_st.day_start);
|
| new_day=true;
|
| }
|
| if(g_st.equity>g_st.peak_equity)
|
| {
|
| g_st.peak_equity=g_st.equity;
|
| PrgSet("peak_eq",g_st.peak_equity);
|
| }
|
| g_st.peak_balance=MathMax(g_st.peak_balance,g_st.balance);
|
| //--- daily floor
|
| g_st.daily_floor=-DBL_MAX;
|
| g_st.daily_limit=0;
|
| if(g_rules.daily_pct>0)
|
| {
|
| double ref=g_st.ref_balance;
|
| if(g_rules.daily_ref==PRG_REF_EQUITY)
|
| ref=g_st.ref_equity;
|
| else
|
| if(g_rules.daily_ref==PRG_REF_HIGHER)
|
| ref=MathMax(g_st.ref_balance,g_st.ref_equity);
|
| g_st.daily_limit=g_rules.daily_pct/100.0*(g_rules.daily_of==PRG_OF_INITIAL ? g_st.initial : ref);
|
| g_st.daily_floor=ref-g_st.daily_limit;
|
| g_st.daily_used_pct=g_st.daily_limit>0 ? 100.0*(ref-g_st.equity)/g_st.daily_limit : 0;
|
| }
|
| //--- overall floor
|
| g_st.max_floor=-DBL_MAX;
|
| if(g_rules.max_pct>0)
|
| {
|
| double amount=g_rules.max_pct/100.0*g_st.initial;
|
| double peak=g_st.initial;
|
| switch(g_rules.max_mode)
|
| {
|
| case PRG_MAX_TRAIL_EQ: peak=g_st.peak_equity; break;
|
| case PRG_MAX_TRAIL_BAL: peak=g_st.peak_balance; break;
|
| case PRG_MAX_EOD: peak=g_st.peak_eod; break;
|
| default: break;
|
| }
|
| g_st.max_floor=peak-amount;
|
| if(g_rules.max_mode==PRG_MAX_SMART && g_rules.smart_gain_pct>0 &&
|
| g_st.peak_balance>=g_st.initial*(1.0+g_rules.smart_gain_pct/100.0))
|
| {
|
| amount=g_rules.smart_after_pct/100.0*g_st.initial;
|
| g_st.max_floor=g_st.initial-amount;
|
| }
|
| if(g_rules.max_mode!=PRG_MAX_STATIC && g_rules.max_mode!=PRG_MAX_SMART && g_rules.max_stop_at_initial)
|
| g_st.max_floor=MathMin(g_st.max_floor,g_st.initial);
|
| //--- share of the loss budget used: 0 with the full amount of room, 100 at the floor
|
| g_st.max_used_pct=amount>0 ? 100.0*(amount-(g_st.equity-g_st.max_floor))/amount : 0;
|
| }
|
| return(new_day);
|
| }
|
|
|
| //--- equity at or below the daily floor
|
| bool PrgDailyBreached(void) { return(g_st.daily_floor>-DBL_MAX && g_st.equity<=g_st.daily_floor); }
|
| bool PrgMaxBreached(void) { return(g_st.max_floor>-DBL_MAX && g_st.equity<=g_st.max_floor); }
|
|
|
| //--- money left before a floor (DBL_MAX when the rule is off)
|
| double PrgDailyRoom(void) { return(g_st.daily_floor>-DBL_MAX ? g_st.equity-g_st.daily_floor : DBL_MAX); }
|
| double PrgMaxRoom(void) { return(g_st.max_floor>-DBL_MAX ? g_st.equity-g_st.max_floor : DBL_MAX); }
|
|
|
| //--- the smaller of the two rooms
|
| double PrgRoom(void) { return(MathMin(PrgDailyRoom(),PrgMaxRoom())); }
|
|
|
| #endif
|
| //+------------------------------------------------------------------+
|
