forked from animatedread/Warrior_EA
75d7362161
Warrior's defaults are now the validated book: DIP_ZSCORE alone, long only, H4, risk 0.25%, one chart per index with a shared Magic. - System/BarCache.mqh: whole-history closed bars, Wilder ATR, GK sigma and the expanding vol percentile (no 1024-bar stdlib ceiling) - System/AccountGuard.mqh: open-risk cap, kill switch, cross-chart lock and Friday flat, shared through terminal globals by Magic - CWarriorExpert: guard on every tick; a transient open failure retries the bar - CWarriorSignal::SetupStop: the dip owns its 3 x Wilder ATR stop from the bid - SignalDipBuy: no entry vote while holding (a still-dipping time exit never closed, and Processing re-entered on the exit bar); no entry on a stop bar - WarriorMoney sizes on equity; WARRIOR_RISK allows fractional risk - TradeLog + research/compare_ea.py: trade-for-trade check vs WarriorDipZ - SP500/US30/DAX40 identical to the cent, NAS100 96.9% (stale-quote timer fills) - research/nn_cross_index.py: pre-registered cross-index NN meta-label - FAIL (AUC 0.564, CI [0.498, 0.630]); DipMetaCut stays off Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
239 lines
12 KiB
MQL5
239 lines
12 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| AccountGuard.mqh |
|
|
//| AnimateDread |
|
|
//| |
|
|
//| THE ACCOUNT, NOT THE CHART. One Warrior instance trades one |
|
|
//| symbol, but the prop account is judged on ALL of them together - |
|
|
//| and equity indices fall together. Four charts at 0.25% each are |
|
|
//| one 1% bet on a selloff. So every instance that shares a Magic |
|
|
//| number shares three things, through terminal global variables: |
|
|
//| |
|
|
//| OPEN-RISK CAP the money at risk to the stops of every position |
|
|
//| carrying this magic, on any symbol, as % of |
|
|
//| equity. An entry that would take it past the cap |
|
|
//| is DROPPED, not queued - by the time room frees |
|
|
//| up the dip it measured is gone. Measured: a |
|
|
//| 7-index basket at 0.25% each crossed 4.5% equity |
|
|
//| DD within five months of 2022 without it. |
|
|
//| LOCK "check the cap, then open" is serialised, so two |
|
|
//| charts rolling to the same H4 bar cannot both |
|
|
//| read the cap before either has opened. |
|
|
//| KILL SWITCH equity drawdown from its peak. One trip halts |
|
|
//| and flattens every instance, and the state |
|
|
//| survives a restart: a VPS reboot must not reset |
|
|
//| the drawdown clock to "at the peak". |
|
|
//| Delete <prefix>_halt_<magic> by hand to re-arm. |
|
|
//| |
|
|
//| And one thing per symbol: |
|
|
//| FRIDAY FLAT from N minutes before THIS symbol's own Friday |
|
|
//| session close (the broker's session table, so it |
|
|
//| is right on every symbol and both sides of DST) |
|
|
//| until the week reopens. Swap was 23% of gross |
|
|
//| profit without it; with it, ret/DD 2.55 -> 4.11. |
|
|
//| The original Warrior design (CH_MARKET_CLOSE). |
|
|
//| |
|
|
//| Same magic on every chart of one strategy - that IS the grouping. |
|
|
//| Never reuse it for another EA on the account: its positions would |
|
|
//| count against the cap and its losses toward the kill switch. |
|
|
//+------------------------------------------------------------------+
|
|
#ifndef WARRIOR_ACCOUNTGUARD_MQH
|
|
#define WARRIOR_ACCOUNTGUARD_MQH
|
|
|
|
class CAccountGuard
|
|
{
|
|
protected:
|
|
string m_symbol;
|
|
long m_magic;
|
|
double m_riskPct; // what one new entry adds to open risk
|
|
double m_capPct; // 0 = no cap
|
|
double m_killPct; // 0 = no kill switch
|
|
int m_fridayMin; // -1 = no Friday flat
|
|
double m_peak;
|
|
bool m_halted;
|
|
int m_capDropped; // entries dropped at the cap, reported at deinit
|
|
int m_lockBusy; // opens deferred because another chart held the lock
|
|
|
|
string Gv(const string what) const
|
|
{ return "Warrior_" + what + "_" + IntegerToString(m_magic); }
|
|
|
|
public:
|
|
CAccountGuard(void) : m_symbol(""), m_magic(0), m_riskPct(0.0), m_capPct(0.0),
|
|
m_killPct(0.0), m_fridayMin(-1), m_peak(0.0),
|
|
m_halted(false), m_capDropped(0), m_lockBusy(0) {}
|
|
~CAccountGuard(void) {}
|
|
|
|
void Init(const string symbol, const long magic, const double riskPct,
|
|
const double capPct, const double killPct, const int fridayMin);
|
|
//--- Once per tick: track the peak, trip or honour the kill switch.
|
|
void Update(void);
|
|
bool Halted(void) const { return m_halted; }
|
|
//--- Nothing of this symbol may be held right now (halted, or inside the Friday window).
|
|
bool MustBeFlat(void) const { return m_halted || FridayBlock(); }
|
|
//--- Would one more entry of m_riskPct stay inside the cap?
|
|
bool RoomForOne(void);
|
|
bool LockTake(void);
|
|
void LockDrop(void);
|
|
void NoteLockBusy(void) { m_lockBusy++; }
|
|
bool FridayBlock(void) const;
|
|
double OpenRiskPct(void) const;
|
|
void Report(void) const;
|
|
static int MarketCloseSeconds(const string symbol, const int dayOfWeek);
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
void CAccountGuard::Init(const string symbol, const long magic, const double riskPct,
|
|
const double capPct, const double killPct, const int fridayMin)
|
|
{
|
|
m_symbol = symbol; m_magic = magic; m_riskPct = riskPct;
|
|
m_capPct = capPct; m_killPct = killPct; m_fridayMin = fridayMin;
|
|
m_peak = AccountInfoDouble(ACCOUNT_EQUITY);
|
|
if(GlobalVariableCheck(Gv("peak")))
|
|
m_peak = MathMax(m_peak, GlobalVariableGet(Gv("peak")));
|
|
GlobalVariableSet(Gv("peak"), m_peak);
|
|
m_halted = (m_killPct > 0.0 && GlobalVariableCheck(Gv("halt")) && GlobalVariableGet(Gv("halt")) > 0.0);
|
|
if(m_halted)
|
|
PrintFormat("CAccountGuard: HALTED by an earlier kill-switch trip - delete global variable %s"
|
|
" to re-arm.", Gv("halt"));
|
|
const int fc = MarketCloseSeconds(m_symbol, 5);
|
|
if(m_fridayMin >= 0 && fc > 0)
|
|
{
|
|
const int ff = fc - m_fridayMin * 60;
|
|
PrintFormat("CAccountGuard: %s Friday session closes %02d:%02d server; flat from %02d:%02d"
|
|
" (%d min before).", m_symbol, fc / 3600, (fc % 3600) / 60, ff / 3600,
|
|
(ff % 3600) / 60, m_fridayMin);
|
|
}
|
|
PrintFormat("CAccountGuard: magic %I64d - open-risk cap %s across every chart with this magic,"
|
|
" kill switch %s, Friday flat %s.", m_magic,
|
|
(m_capPct > 0.0 ? DoubleToString(m_capPct, 2) + "%" : "off"),
|
|
(m_killPct > 0.0 ? DoubleToString(m_killPct, 1) + "% equity DD from peak" : "off"),
|
|
(m_fridayMin >= 0 ? "on" : "off"));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
void CAccountGuard::Update(void)
|
|
{
|
|
const double eq = AccountInfoDouble(ACCOUNT_EQUITY);
|
|
if(eq > m_peak)
|
|
{
|
|
m_peak = eq;
|
|
GlobalVariableSet(Gv("peak"), m_peak);
|
|
}
|
|
if(m_killPct <= 0.0)
|
|
return;
|
|
if(!m_halted && m_peak > 0.0 && (m_peak - eq) / m_peak * 100.0 >= m_killPct)
|
|
{
|
|
m_halted = true;
|
|
GlobalVariableSet(Gv("halt"), 1.0);
|
|
PrintFormat("CAccountGuard: KILL SWITCH - equity %.2f is %.2f%% below peak %.2f; flattening"
|
|
" and halting every chart with magic %I64d.",
|
|
eq, (m_peak - eq) / m_peak * 100.0, m_peak, m_magic);
|
|
}
|
|
//--- Another instance may have tripped it: honour that here too.
|
|
if(!m_halted && GlobalVariableCheck(Gv("halt")) && GlobalVariableGet(Gv("halt")) > 0.0)
|
|
{
|
|
m_halted = true;
|
|
PrintFormat("CAccountGuard: halted by another chart's kill switch (magic %I64d).", m_magic);
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Money at risk to the stops across ALL positions with this magic, |
|
|
//| any symbol, as % of equity. A position without a stop has |
|
|
//| unbounded risk and fills the whole cap. |
|
|
//+------------------------------------------------------------------+
|
|
double CAccountGuard::OpenRiskPct(void) const
|
|
{
|
|
const double eq = AccountInfoDouble(ACCOUNT_EQUITY);
|
|
if(eq <= 0.0)
|
|
return 100.0;
|
|
double money = 0.0;
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--)
|
|
{
|
|
const ulong tk = PositionGetTicket(i);
|
|
if(tk == 0 || PositionGetInteger(POSITION_MAGIC) != m_magic)
|
|
continue;
|
|
const string sym = PositionGetString(POSITION_SYMBOL);
|
|
const double op = PositionGetDouble(POSITION_PRICE_OPEN);
|
|
const double sl = PositionGetDouble(POSITION_SL);
|
|
const double vol = PositionGetDouble(POSITION_VOLUME);
|
|
const double tv = SymbolInfoDouble(sym, SYMBOL_TRADE_TICK_VALUE);
|
|
const double ts = SymbolInfoDouble(sym, SYMBOL_TRADE_TICK_SIZE);
|
|
if(sl <= 0.0 || ts <= 0.0)
|
|
return 100.0;
|
|
const bool isLong = (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY);
|
|
const double dist = isLong ? op - sl : sl - op;
|
|
if(dist > 0.0)
|
|
money += dist * vol * tv / ts;
|
|
}
|
|
return money / eq * 100.0;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
bool CAccountGuard::RoomForOne(void)
|
|
{
|
|
if(m_capPct <= 0.0)
|
|
return true;
|
|
if(OpenRiskPct() + m_riskPct <= m_capPct + 1e-9)
|
|
return true;
|
|
m_capDropped++;
|
|
return false;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Terminal-global lock around "check the cap, then open". A stale |
|
|
//| lock (a crashed holder) expires after 30 s. The tester runs one |
|
|
//| instance per agent, so there is nothing to serialise there. |
|
|
//+------------------------------------------------------------------+
|
|
bool CAccountGuard::LockTake(void)
|
|
{
|
|
if(MQLInfoInteger(MQL_TESTER))
|
|
return true;
|
|
const string gv = Gv("lock");
|
|
const double now = (double)TimeCurrent();
|
|
if(!GlobalVariableCheck(gv))
|
|
GlobalVariableSet(gv, 0.0);
|
|
const double v = GlobalVariableGet(gv);
|
|
if(v != 0.0 && now - v < 30.0)
|
|
return false;
|
|
return GlobalVariableSetOnCondition(gv, now, v);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
void CAccountGuard::LockDrop(void)
|
|
{
|
|
if(!MQLInfoInteger(MQL_TESTER))
|
|
GlobalVariableSet(Gv("lock"), 0.0);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| The LAST trade-session close of a weekday, in seconds from that |
|
|
//| day's midnight (86400 = trades to midnight), -1 = no session. |
|
|
//+------------------------------------------------------------------+
|
|
int CAccountGuard::MarketCloseSeconds(const string symbol, const int dayOfWeek)
|
|
{
|
|
datetime from = 0, to = 0;
|
|
int lastTo = -1;
|
|
for(uint k = 0; SymbolInfoSessionTrade(symbol, (ENUM_DAY_OF_WEEK)dayOfWeek, k, from, to); k++)
|
|
lastTo = (int)to;
|
|
return lastTo;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| From (Friday close - N minutes) until the week reopens. |
|
|
//+------------------------------------------------------------------+
|
|
bool CAccountGuard::FridayBlock(void) const
|
|
{
|
|
if(m_fridayMin < 0)
|
|
return false;
|
|
MqlDateTime d;
|
|
TimeToStruct(TimeCurrent(), d);
|
|
if(d.day_of_week == 6 || d.day_of_week == 0)
|
|
return true;
|
|
if(d.day_of_week != 5)
|
|
return false;
|
|
const int close = MarketCloseSeconds(m_symbol, 5);
|
|
if(close <= 0)
|
|
return true; // no Friday session: nothing may be held into it
|
|
const int now = d.hour * 3600 + d.min * 60 + d.sec;
|
|
return now >= close - m_fridayMin * 60;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
void CAccountGuard::Report(void) const
|
|
{
|
|
PrintFormat("CAccountGuard: %d entr%s dropped at the open-risk cap, %d open(s) deferred for the"
|
|
" cross-chart lock; kill switch %s.", m_capDropped, (m_capDropped == 1 ? "y" : "ies"),
|
|
m_lockBusy, (m_halted ? "TRIPPED" : "not tripped"));
|
|
}
|
|
#endif // WARRIOR_ACCOUNTGUARD_MQH
|