mnbvc188199/Warrior_EA
Watch
1
0
Fork
You've already forked Warrior_EA
 1
forked from animatedread/Warrior_EA
Code Pull requests Activity
Warrior_EA/Warrior_EA.mq5
AnimateDread 788115970c fix(vote): unranked members voted with the stock 25/50/75/100 ladder 
Two defects behind "arrows drawn while members are still mid-era".

1. THE DRAW. The filtered overlay armed on the FIRST member to finish
   pass 3 and leaned on a 60 s rate limit to "collapse the burst",
   assuming members finish seconds apart. They do not - on USDJPY one
   member was at sample 10496 of pass 2 while another was at 2304,
   minutes apart. A member with no era-end snapshot returns false from
   SnapshotVoteAt, and the sweep's `if(!hasData) continue;` skips it
   BEFORE `den += ModuleWeight()`, so the one finished model's tier
   weight became the entire vote and was drawn as a consensus arrow.

   An abstention is a member that looked at the bar and said nothing; a
   missing snapshot is a member that has not looked. The first must
   dilute the vote, the second must suppress the draw. The arm is now a
   readiness MASK - one bit per m_ensembleIndex, set at that member's
   pass-3 completion, cleared when a sweep arms - and a sweep waits for
   every enrolled member. Bounded at 10 minutes so a member that stops
   cannot freeze the chart, and the partial draw PRINTS which members
   were missing: the be39674 lesson is that a hold must never silence
   the thing that reports it.

2. THE VOTE ITSELF, which is the worse half and is not display-only.
   Tier weights are not persisted in the .nnw - they exist only as the
   output of a completed pass 3 - so before a member's first
   RankTiersFromOos() it holds the constructor's stock 25/50/75/100.
   Since 4858507 the vote currency is a WIN RATE, so an unranked tier-3
   call enters the capability-weighted mean claiming a 100% win rate
   beside ranked members contributing ~25. Not a strong opinion: the
   wrong unit. One unranked member drags the ensemble over any
   threshold, on every fresh deploy and every resume. USDJPY has a
   measured ceiling of ~19 and was firing anyway.

   LiveVoteContribution() now abstains until self-ranked, which drops
   the member from the sum AND the divisor. One function, so live and
   the gate move together (2c443ba).

Era 0 will therefore report 0 coverage until each member completes one
era. The ensemble line says so explicitly rather than leaving it to look
like the USDJPY unreachable-threshold case - the two are identical in
the coverage number and completely different problems.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-23 08:55:04 -04:00

1905 lines
98 KiB
MQL5
Raw Permalink Blame History

//+------------------------------------------------------------------+
//| Warrior_EA |
//| AnimateDread |
//| |
//+------------------------------------------------------------------+
//--- MQL5 Market rule IV: "Products must not contain calls to any DLL". Leave commented out for the
//--- private/prop-firm deployment build, which keeps the DirectML/ CPU-DLL fallback tier for hosts
//--- without OpenCL.
//#define WARRIOR_MARKET_BUILD
//--- MARKET build only: embed every custom indicator this EA calls via CiCustom so one self-
//--- contained .ex5 ships to the Market. The private build uses bare names (no resources), so it
//--- builds from anywhere.
#ifdef WARRIOR_MARKET_BUILD
#resource "\\Indicators\\ADCumulativeDelta.ex5"
#resource "\\Indicators\\ADShorteningOfThrust.ex5"
#resource "\\Indicators\\ADWyckoffEventStream.ex5"
#resource "\\Indicators\\ADWyckoffFailedStructure.ex5"
#resource "\\Indicators\\ADWyckoffSignificantBarInversion.ex5"
//--- ADZigZag and ADMovingAverage are no longer bundled: the ZigZag now loads MetaTrader's own
//--- Examples\ZigZag (our copy was a byte-identical rename) and the MA runs the built-in iMA.
#endif
//--- Inputs FIRST so the EA's own grouped inputs lead the Inputs tab. Safe because Inputs.mqh
//--- depends only on Enumerations\InputEnums.mqh (which carries a guarded ENUM_OPTIMIZATION copy) -
//--- no AI header needed.
#include "Variables\Inputs.mqh"
//--- chart-level tuned indicator periods: read at OnInit before the DB fingerprint and the classic
//--- signal configuration, written by a gated auto-tune install - see the file's header contract
#include "Variables\TunedPeriods.mqh"
//--- database classes
#include "Database\DatabaseManager.mqh"
#include "Database\TradeJournalManager.mqh"
//--- available custom classes
#include "Expert\ExpertCustom.mqh"
#include "Expert\AIBase\MetaCorpus.mqh"
#include "System\Random.mqh"
#include "System\PrintVerbose.mqh"
#include "System\StatusLabel.mqh"
#include "System\AltDataFetch.mqh"
//--- available signals
#include "Signals\Signals.mqh"
//--- available trailing
#include "Trailing\Trailing.mqh"
//--- available money management
#include "Money\Money.mqh"
//--- Variables
#include "Variables\Variables.mqh"
//--- Control panel GUI (standard MQL5 Controls library)
#include "Panel\ControlPanel.mqh"
//--- One-time "which instrument is this?" dialog for symbols the alt-data catalog does not know
#include "Panel\AltDataMapDialog.mqh"
//+------------------------------------------------------------------+
//| The CustomIndicators\*.mq5 files (ADCumulativeDelta, |
//| ADShorteningOfThrust, ADWyckoffEventStream, |
//| ADWyckoffFailedStructure, ADWyckoffSignificantBarInversion) are |
//| loaded via CiCustom/IND_CUSTOM (see ExpertSignalAIBase.mqh). |
//+------------------------------------------------------------------+
//
CExpertCustom Expert;
CDatabaseManager dbm();
CTradeJournalManager journal;
//+------------------------------------------------------------------+
//| Pointers to whichever AI signal instances this run actually |
//| created (any enabled Use_* subset, plus the meta head), so the |
//| panel can drive training/weight actions on exactly the signal(s) |
//| in play this run and never touch another config's files. |
//+------------------------------------------------------------------+
//--- Must be >= the number of AI signal instances one run can create at once. At 3 the CONVLSTM
//--- member was once silently dropped on the floor (609be10); the array holds borrowed pointers, so
//--- headroom is free - but a cap that silently discards a model is a trapdoor, hence the loud
//--- refusal below.
#define MAX_AI_SIGNALS 5
//--- Printed at OnInit so tester logs prove which binary is actually running.
#define WARRIOR_BUILD_TAG "meta-gate-v1"
CExpertSignalAIBase *g_aiSignals[MAX_AI_SIGNALS];
int g_aiSignalCount = 0;
void RegisterAISignal(CExpertSignalAIBase *sig)
{
if(sig == NULL)
return;
//--- LOUD on overflow. A cap that silently discards a model is not a guard, it is a trapdoor.
if(g_aiSignalCount >= MAX_AI_SIGNALS)
{
Print(__FUNCTION__ + ": CANNOT REGISTER a further AI signal - MAX_AI_SIGNALS is " +
IntegerToString(MAX_AI_SIGNALS) + " and this run already created that many. The extra "
"model would still train and still vote, but the control panel could not reach it and its "
"weights would never be autosaved or flushed on shutdown. Raise MAX_AI_SIGNALS to at least "
"the number of instances the enabled Use_* inputs create and recompile.");
return;
}
g_aiSignals[g_aiSignalCount++] = sig;
}
//+------------------------------------------------------------------+
//| Control panel: a CAppDialog-based GUI (see Panel\ControlPanel.mqh) |
//| with show/hide signals, start/pause/stop training, and save/load/ |
//| delete-reset weights buttons for the currently-active AI |
//| signal(s) only. The dialog's own caption bar provides the show/ |
//| hide (minimize) control - no separate toggle button needed. |
//+------------------------------------------------------------------+
//--- default spawn position: top-right corner, clear of the status label text block (top-left) so the
//--- two don't overlap on first run - the panel is fully draggable afterwards via its caption bar,
//--- so this is only a starting point, not a constraint.
#define CP_Y0 10
#define CP_RIGHT_MARGIN 80
CControlPanel ExtPanel;
//--- Alt-data maintenance + the one-time symbol-mapping dialog. Declared HERE rather than beside
//--- OnTimer because OnDeinit (further up the file) tears the dialog down, and MQL5 resolves global
//--- variables in declaration order.
#define ALTDATA_CHECK_SECONDS 1800
datetime g_lastAltDataRun = 0;
CAltDataFetch g_altDataFetch;
CAltDataMapDialog g_altMapDialog;
bool g_altMapDialogOpen = false;
bool g_altMapAsked = false; // one prompt per attach, even if the user closes it unanswered
bool g_signalsVisible = true;
#define SIGNAL_VISIBILITY_STATE_SUFFIX ".sigvis"
string SignalsVisibilityStateFile(void)
{
return eaName + "_" + Symbol() + "_" + IntegerToString(Period()) + SIGNAL_VISIBILITY_STATE_SUFFIX;
}
bool LoadSignalsVisibilityState(void)
{
if(MQLInfoInteger(MQL_TESTER) || MQLInfoInteger(MQL_OPTIMIZATION) || MQLInfoInteger(MQL_FORWARD))
return false;
string stateFile = SignalsVisibilityStateFile();
if(!FileIsExist(stateFile, FILE_COMMON))
return false;
int handle = FileOpen(stateFile, FILE_COMMON | FILE_BIN | FILE_READ | FILE_SHARE_READ | FILE_SHARE_WRITE);
if(handle == INVALID_HANDLE)
return false;
int storedVisible = FileReadInteger(handle);
FileClose(handle);
g_signalsVisible = (storedVisible != 0);
return true;
}
bool SaveSignalsVisibilityState(void)
{
if(MQLInfoInteger(MQL_TESTER) || MQLInfoInteger(MQL_OPTIMIZATION) || MQLInfoInteger(MQL_FORWARD))
return true;
string stateFile = SignalsVisibilityStateFile();
int handle = FileOpen(stateFile, FILE_COMMON | FILE_BIN | FILE_WRITE | FILE_SHARE_READ | FILE_SHARE_WRITE);
if(handle == INVALID_HANDLE)
{
Print(__FUNCTION__ + ": failed to open " + stateFile + " for write, error " + IntegerToString(GetLastError()));
return false;
}
FileWriteInteger(handle, g_signalsVisible ? 1 : 0, INT_VALUE);
FileClose(handle);
return true;
}
//--- true while Show Signals has queued a rescan on one or more g_aiSignals and is waiting for all of
//--- them to finish (see ToggleSignalsVisibility/FinalizeSignalsRescanIfDone) - each signal's own rescan
//--- is now chunked across PollTraining's timer slices (CExpertSignalAIBase::AdvanceChartSignalRescan)
//--- instead of blocking the button click, so visibility can only be (re)applied and the "shown" Alert
//--- fired once every instance's RescanPending() has cleared.
bool g_signalsRescanPending = false;
//--- tracks the last known AlgoTrading permission state (terminal "Algo Trading" toggle AND this
//--- EA's own "Allow Algo Trading" property) so a change is logged exactly once, not spammed every tick
bool g_lastAlgoTradingAllowed = true;
//--- OnDeinit() is not guaranteed to run on a terminal crash/power loss/forced kill, so weights
//--- would otherwise only be as fresh as the last fully-completed training era.
datetime g_lastAutosaveBarTime = 0;
//--- last observed AllTrainingDeployed() value, so OnTimer() can spot training deploying itself (plateau
//--- ladder / era cap) and resync the panel's button labels exactly once on the transition
bool g_lastDeployedState = false;
//--- summarizes state across all currently-active AI signals for button labels;
//--- "paused"/"stopped" only report true if EVERY active signal agrees, so a mixed state
//--- (e.g. several NNs enabled with one paused and one running) still shows an actionable label
//--- Counted over the SIGNAL TREE, not over g_aiSignals[]: the tree is the population a panel command
//--- actually reaches, so a label can no longer describe a different set of models than the button acts
//--- on. SIGTRAIT_TRAINABLE is the denominator - "all paused" means nothing without it.
int TrainableSignalCount(void) { return Expert.CountSignalTrait(SIGTRAIT_TRAINABLE); }
bool AllTrainingPaused(void)
{
int n = TrainableSignalCount();
return n > 0 && Expert.CountSignalTrait(SIGTRAIT_TRAINING_PAUSED) == n;
}
bool AllTrainingStopped(void)
{
int n = TrainableSignalCount();
return n > 0 && Expert.CountSignalTrait(SIGTRAIT_TRAINING_STOPPED) == n;
}
//--- "deployed" = every active signal has finalised a model and is running live inference rather
//--- than training.
bool AllTrainingDeployed(void)
{
int n = TrainableSignalCount();
return n > 0 && Expert.CountSignalTrait(SIGTRAIT_TRAINING_COMPLETE) == n;
}
//--- true only while at least one signal is still trainable AND has never checkpointed an era that
//--- cleared the per-class recall floor - i.e. deploying right now would ship a model that ignores Buy
//--- or Sell. Same bar the plateau ladder's automatic deploy refuses to cross on its own.
bool AnyDeployWouldSkipRecallFloor(void)
{
return Expert.CountSignalTrait(SIGTRAIT_DEPLOY_SKIPS_RECALL) > 0;
}
void ApplySignalsVisibility(void)
{
//--- TYPED-BLIND, PREFIX-SCOPED. A mark is a line AND an arrow (see WarriorPlotSignalLevel), so
//--- a type-filtered sweep would toggle half of each one and leave the chart showing arrows for
//--- signals whose levels are hidden.
for(int i = ObjectsTotal(0, -1, -1) - 1; i >= 0; i--)
{
string name = ObjectName(0, i, -1, -1);
if(StringFind(name, SIG_ARROW_PREFIX) != 0)
continue;
ObjectSetInteger(0, name, OBJPROP_TIMEFRAMES, g_signalsVisible ? OBJ_ALL_PERIODS : OBJ_NO_PERIODS);
}
ChartRedraw(0);
}
void ToggleSignalsVisibility(void)
{
g_signalsVisible = !g_signalsVisible;
//--- Hide->Show is also the operator's manual "these arrows look stale" refresh: rescan each
//--- deployed model against recent history BEFORE re-showing, so Show Signals reveals a fresh
//--- set instead of just re-exposing whatever old render the .arrows sidecar happened to hold
//--- (see CExpertSignalAIBase::StartChartSignalRescan/AdvanceChartSignalRescan).
if(g_signalsVisible)
{
bool anyQueued = (Expert.DispatchSignalCommand(SIGCMD_RESCAN_SIGNALS) > 0);
g_signalsRescanPending = anyQueued;
if(anyQueued)
{
//--- Immediate feedback that the click registered - the real "Hide Signals" label only lands
//--- once FinalizeSignalsRescanIfDone() runs RefreshControlPanelLabels() below.
ExtPanel.SetSignalsText("Scanning...");
return; // ApplySignalsVisibility()/labels/Alert deferred to FinalizeSignalsRescanIfDone()
}
}
ApplySignalsVisibility();
SaveSignalsVisibilityState();
}
//--- Called every OnTimer tick while g_signalsRescanPending: applies visibility and fires the "shown"
//--- Alert only once every queued rescan (see ToggleSignalsVisibility) has finished, since the arrows
//--- being toggled visible don't exist yet until each instance's AdvanceChartSignalRescan completes.
void FinalizeSignalsRescanIfDone(void)
{
if(!g_signalsRescanPending)
return;
if(Expert.CountSignalTrait(SIGTRAIT_RESCAN_PENDING) > 0)
return; // at least one instance still scanning - check again next tick
g_signalsRescanPending = false;
ApplySignalsVisibility();
RefreshControlPanelLabels();
Alert("Warrior EA: signal arrows shown");
}
//--- keeps every button's label in sync with live training/signal-visibility state; safe/cheap to
//--- call after every panel action
void RefreshControlPanelLabels(void)
{
ExtPanel.SetSignalsText(g_signalsVisible ? "Hide Signals" : "Show Signals");
bool noAI = (TrainableSignalCount() == 0);
//--- The four training buttons describe ONE state machine, so their labels are derived together
//--- rather than independently - otherwise the panel offers actions that silently do nothing.
bool deployed = !noAI && AllTrainingDeployed();
ExtPanel.SetPauseText(noAI ? "Pause Training (n/a)"
: deployed ? "Pause Training (deployed)"
: (AllTrainingPaused() ? "Resume Training" : "Pause Training"));
ExtPanel.SetStopText(noAI ? "Stop Training (n/a)"
: deployed ? "Stop Training (deployed)"
: (AllTrainingStopped() ? "Start Training" : "Stop Training"));
ExtPanel.SetDeployText(noAI ? "Deploy Model (n/a)" : (deployed ? "Retrain Model" : "Deploy Model"));
ChartRedraw(0);
}
//--- CAppDialog is user-draggable; a drag near an edge followed by shrinking the chart (or dragging
//--- past the visible area) can leave it partially or fully off-screen with no way to grab it back.
//--- Clamps it back inside the current chart bounds whenever the chart is resized/scrolled.
void ClampControlPanelToChart(void)
{
long chartWidth = ChartGetInteger(0, CHART_WIDTH_IN_PIXELS);
long chartHeight = ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS);
if(chartWidth <= 0 || chartHeight <= 0)
return;
int x = ExtPanel.Left();
int y = ExtPanel.Top();
int w = ExtPanel.Width();
int h = ExtPanel.Height();
int maxX = (int)chartWidth - w;
int maxY = (int)chartHeight - h;
int clampedX = (maxX < 0) ? 0 : MathMin(MathMax(x, 0), maxX);
int clampedY = (maxY < 0) ? 0 : MathMin(MathMax(y, 0), maxY);
if(clampedX != x || clampedY != y)
ExtPanel.Move(clampedX, clampedY);
}
//--- creates the control panel dialog once, from OnInit() - the standard CAppDialog usage pattern
//--- (create in OnInit, destroy in OnDeinit; see Controls\Dialog.mqh).
bool CreateControlPanel(void)
{
ResetLastError();
long chartWidth = ChartGetInteger(0, CHART_WIDTH_IN_PIXELS);
int panelX1 = (chartWidth > CP_PANEL_W + CP_RIGHT_MARGIN + 20) ? (int)(chartWidth - CP_PANEL_W - CP_RIGHT_MARGIN) : 10;
//--- Same orphan sweep the signal arrows get, for the same reason: CAppDialog namespaces every
//--- control it creates under the dialog name, those objects live in the CHART PROFILE, and
//--- Destroy() is the only thing that removes them.
ObjectsDeleteAll(0, WARRIOR_PANEL_PREFIX);
if(!ExtPanel.Create(0, WARRIOR_PANEL_PREFIX, 0, panelX1, CP_Y0, panelX1 + CP_PANEL_W, CP_Y0 + CP_PANEL_H))
{
Print(__FUNCTION__ + ": failed to create control panel, error " + IntegerToString(GetLastError()));
return false;
}
if(!ExtPanel.Run())
{
Print(__FUNCTION__ + ": failed to run control panel, error " + IntegerToString(GetLastError()));
return false;
}
ExtPanel.ForceMaximize();
ClampControlPanelToChart();
//--- seed the transition watcher (see OnTimer) so a model that is ALREADY deployed at attach time
//--- doesn't register as a fresh transition on the first timer tick
g_lastDeployedState = AllTrainingDeployed();
RefreshControlPanelLabels();
return true;
}
//--- Blocking on purpose, unlike the Alert() calls below: this only ever runs in direct response to the
//--- trader clicking a destructive (red) panel button, so pausing for their yes/no is expected UX, not
//--- an unwanted stall of live trade management - MessageBox() briefly blocks the chart's UI thread,
//--- which is exactly what a "are you sure?" gate needs.
bool ConfirmDestructiveAction(string message)
{
return MessageBox(message + "\n\nThis action cannot be undone.", "Warrior EA - Confirm",
MB_YESNO | MB_ICONWARNING | MB_DEFBUTTON2) == IDYES;
}
//--- performs whatever button action ExtPanel recorded (see ConsumeAction() in ControlPanel.mqh);
//--- a no-op when nothing was clicked since the last call
void HandleControlPanelAction(ENUM_CP_ACTION action)
{
switch(action)
{
case CP_ACTION_TOGGLE_SIGNALS:
ToggleSignalsVisibility();
//--- If a rescan got queued (Show Signals with a deployed model to re-infer from), the
//--- label refresh + Alert are deferred to FinalizeSignalsRescanIfDone() - firing "shown"
//--- here would lie about arrows that don't exist on the chart yet.
if(!g_signalsRescanPending)
{
RefreshControlPanelLabels();
Alert("Warrior EA: signal arrows " + (g_signalsVisible ? "shown" : "hidden"));
}
break;
case CP_ACTION_TOGGLE_PAUSE:
{
//--- A deployed model has no training run to pause - say so instead of silently doing nothing.
if(AllTrainingDeployed())
{
Alert("Warrior EA: the model is deployed - there is no training run to pause.\nUse \"Retrain Model\" first if you want to train it further.");
break;
}
//--- Direction resolved ONCE here, then handed to every signal as a plain command. A toggle
//--- each model re-derived from its own state is how a mixed set ends up half paused.
bool pause = !AllTrainingPaused();
int touched = Expert.DispatchSignalCommand(pause ? SIGCMD_PAUSE_TRAINING : SIGCMD_RESUME_TRAINING);
RefreshControlPanelLabels();
Alert("Warrior EA: training " + (pause ? "paused" : "resumed") +
" (" + IntegerToString(touched) + " model(s))");
break;
}
case CP_ACTION_TOGGLE_STOP:
{
//--- Same as Pause: Stop/Start operate on a training run, and a deployed model isn't one.
//--- Routing this to RetrainDeployed() instead would silently do the Deploy button's job.
if(AllTrainingDeployed())
{
Alert("Warrior EA: the model is deployed and already running live inference, not training.\nUse \"Retrain Model\" to put it back into training.");
break;
}
bool doStop = !AllTrainingStopped();
int touched = Expert.DispatchSignalCommand(doStop ? SIGCMD_STOP_TRAINING : SIGCMD_START_TRAINING);
RefreshControlPanelLabels();
Alert("Warrior EA: training " + (doStop ? "stopped" : "restarted") +
" (" + IntegerToString(touched) + " model(s))");
break;
}
case CP_ACTION_TOGGLE_DEPLOY:
{
if(TrainableSignalCount() == 0)
{
Alert("Warrior EA: no AI signal is active - nothing to deploy (set the AI algorithm input to something other than Disabled).");
break;
}
//--- RETRAIN direction: put the finalised model back into training, continuing from its own
//--- weights. Reversible, non-destructive (the weights on disk stay), so no confirmation.
if(AllTrainingDeployed())
{
Expert.DispatchSignalCommand(SIGCMD_RETRAIN_DEPLOYED);
RefreshControlPanelLabels();
Alert("Warrior EA: retraining the deployed model - it continues from its current weights.\nUse \"Delete & Reset Weights\" instead to start from scratch.");
break;
}
//--- DEPLOY direction. The plateau ladder refuses to auto-deploy a model that never cleared the
//--- per-class recall floor (it would be one that ignores Buy or Sell); a manual deploy is the
//--- operator's call, but they should make it knowingly - so this is the one case that asks.
if(AnyDeployWouldSkipRecallFloor() &&
!ConfirmDestructiveAction("No training era has cleared the per-class recall floor yet, so this model may "
"be ignoring Buy or Sell entirely.\n\nDeploy it anyway as the final model?"))
{
Alert("Warrior EA: deploy cancelled - training continues");
break;
}
int deployed = Expert.DispatchSignalCommand(SIGCMD_DEPLOY);
RefreshControlPanelLabels();
if(deployed == 0)
Alert("Warrior EA: could not deploy - the AI signal is not initialised yet.");
else
Alert("Warrior EA: model deployed (" + IntegerToString(deployed) + " signal(s)).\nTraining stopped; it now runs live inference. Click \"Retrain Model\" to train it further.");
break;
}
case CP_ACTION_SAVE:
{
int saved = Expert.DispatchSignalCommand(SIGCMD_SAVE_WEIGHTS);
Alert("Warrior EA: weights saved (" + IntegerToString(saved) + " of " +
IntegerToString(TrainableSignalCount()) + " model(s))");
break;
}
case CP_ACTION_LOAD:
Expert.DispatchSignalCommand(SIGCMD_LOAD_WEIGHTS);
//--- A reload carries the saved file's own "deployed" flag, so it can flip the whole training
//--- state machine (loading a finalised model makes Deploy read "Retrain Model", and Pause/Stop
//--- read "(deployed)"). Resync the labels or the panel would keep offering stale actions.
RefreshControlPanelLabels();
Alert("Warrior EA: weights reloaded from disk");
break;
case CP_ACTION_RESET:
{
//--- CENSUS BEFORE THE ACTION, walked over the SAME tree the reset itself walks - so the
//--- count and the identity lines describe exactly the models about to be wiped and cannot
//--- drift from them.
int trainable = TrainableSignalCount();
PrintFormat("%s: RESET requested - %d AI signal(s) reachable on this chart:",
__FUNCTION__, trainable);
Expert.DispatchSignalCommand(SIGCMD_REPORT_IDENTITY);
if(!ConfirmDestructiveAction("Delete the saved AI weights of all " +
IntegerToString(trainable) +
" AI model(s) on this chart and restart training from era 0?"))
{
Alert("Warrior EA: weights reset cancelled");
break;
}
//--- ResetWeights() returns whether the fresh topology was REBUILT, and that return has
//--- been discarded since it was written. Count it, and say so when they disagree.
int resetOk = Expert.DispatchSignalCommand(SIGCMD_RESET_WEIGHTS);
RefreshControlPanelLabels();
PrintFormat("%s: RESET complete - %d of %d AI signal(s) rebuilt a fresh topology.",
__FUNCTION__, resetOk, trainable);
if(trainable == 0)
Alert("Warrior EA: nothing to reset - no AI signal is registered on this chart.");
else
if(resetOk == trainable)
Alert("Warrior EA: weights reset for " + IntegerToString(resetOk) +
" model(s) - training restarts from era 0");
else
Alert("Warrior EA: weights reset INCOMPLETE - " + IntegerToString(resetOk) + " of " +
IntegerToString(trainable) + " model(s) rebuilt.\nThe rest had their files "
"deleted but could not rebuild a topology - see the Experts log.");
break;
}
case CP_ACTION_REPORT:
{
if(!UseDatabaseRanking)
{
Print(__FUNCTION__ + ": trade journal report requires \"Weight filters by DB win-rate\" (UseDatabaseRanking) to be enabled");
Alert("Warrior EA: trade journal report requires \"Weight filters by DB win-rate\" to be enabled");
break;
}
string reportPath, reportError;
if(journal.GenerateReport(reportPath, reportError))
{
Print(__FUNCTION__ + ": trade journal report ready - " + reportPath);
Alert("Warrior EA: trade journal report exported - see the Experts log for the file path");
}
else
{
Print(__FUNCTION__ + ": could not generate trade journal report - " + reportError);
Alert("Warrior EA: could not export trade journal report - " + reportError);
}
break;
}
//--- separate from CP_ACTION_RESET on purpose: resetting AI weights (a routine, frequent action
//--- while tuning) must never cost the trader their accumulated pattern-confidence/trade-journal
//--- history, and vice versa - these are two independent "start fresh" decisions now.
case CP_ACTION_RESET_DB:
if(UseDatabaseRanking)
{
if(!ConfirmDestructiveAction("Delete the trade-journal and pattern-confidence database?"))
{
Alert("Warrior EA: database reset cancelled");
break;
}
//--- ResetDatabase() returns false when the file could not be deleted or the connection
//--- could not be reopened, and that return was discarded too - the Alert said
//--- "database reset" either way.
bool dbReset = dbm.ResetDatabase();
PrintFormat("%s: DATABASE RESET %s - one shared trade-journal/pattern-confidence DB serves all"
" %d AI signal(s) on this chart; per-model weights are NOT affected (use Delete &&"
" Reset Weights for those).", __FUNCTION__,
(dbReset ? "succeeded" : "FAILED"), TrainableSignalCount());
Alert(dbReset
? "Warrior EA: database reset"
: "Warrior EA: database reset FAILED - see the Experts log");
}
else
{
Print(__FUNCTION__ + ": database reset requires \"Weight filters by DB win-rate\" (UseDatabaseRanking) to be enabled");
Alert("Warrior EA: database reset requires \"Weight filters by DB win-rate\" to be enabled");
}
break;
default:
break;
}
}
// Helper function to pause execution for a random duration between 1 to 3 seconds
void RandomSleep()
{
Sleep(WarriorRandInt(2000) + 1000); // Sleeps between 1000ms (1s) and 3000ms (3s)
}
//+------------------------------------------------------------------+
//| The DB fingerprint's first slot - was (int)AIType until the |
//| preset selector was replaced by the per-NN toggles (2026-08-19). |
//+------------------------------------------------------------------+
int DbLegacyAiSlot()
{
int bits = (Use_MLP ? 1 : 0) | (Use_CONV ? 2 : 0) | (Use_LSTM ? 4 : 0) | (Use_CONVLSTM ? 8 : 0);
if(bits == 15)
return 6; // all four = the old AI_HYBRID ensemble preset
if(bits == 0)
return Use_MetaLabeling ? 5 : 0; // legacy AI_META / AI_NONE
if(bits == 1)
return 1; // AI_MLP
if(bits == 2)
return 2; // AI_CONV
if(bits == 4)
return 3; // AI_LSTM
if(bits == 8)
return 4; // AI_CONVLSTM
return 100 + bits; // new subset - outside the legacy value space by construction
}
//+------------------------------------------------------------------+
//| Config fingerprint appended to the pattern-confidence/trade- |
//| journal database's filename, so a topology or feature-set change |
//| that would produce a differently-shaped/behaving model gets its |
//| own database instead of silently reusing pattern-weight/journal |
//| history that no longer matches what's actually trading now. |
//+------------------------------------------------------------------+
string ComputeDbConfigFingerprint()
{
//--- InitialNeurons is gone from this key: the first-layer width is now DERIVED from the input
//--- width and the study period (CExpertSignalAIBase::ComputeFirstLayerWidth), not chosen, and
//--- every determinant of it that IS a user choice is already hashed here.
string fp = StringFormat("SEM%d|", SIGNAL_DB_SEMANTICS_VERSION)
+ StringFormat("%d|%d|%d|%d|%d|%d|%d|%d|%d|%d|%d|%d|%d|%d|%d|%d|%d",
DbLegacyAiSlot(), (int)OutputNeuronsCount, (int)TrainingOptimizer,
//--- LEGACY SLOT (was ind_Periods, derived since 2026-08-11). The literal
//--- is the shipped default so every existing database keeps its key.
20,
EnableVolume, EnableTime, EnableATR,
//--- TUNED values, not the seed constants (2026-08-16): the classic votes
//--- run at the adopted periods, so the DB key must describe THOSE - a
//--- tuning install re-keys the database, which is the semantics rule
//--- (new periods = new pattern definitions = fresh win-rate history).
EnableMA, g_TunedMaPeriod, g_TunedMaType, EnableRSI, g_TunedRsiPeriod,
EnableSwingContext, EnableNews,
EnableADCumulativeDelta, EnableADShorteningOfThrust, EnableADWyckoffEventStream)
+ StringFormat("|%d|%d|%d|%d", EnableADWyckoffFailedStructure, EnableADWyckoffSignificantBarInversion,
EnableMAFeature, EnableRSIFeature);
//--- MACD/Ichimoku, appended ONLY WHEN ENABLED - same rule, and same reason, as the matching block
//--- in CExpertSignalAIBase::BuildConfigFingerprint(): appending unconditionally would re-key every
//--- existing database the moment this shipped, orphaning the accumulated per-pattern win-rate
//--- history of configs that use neither.
if(EnableMACD || EnableMACDFeature)
fp += StringFormat("|MACD:%d:%d:%d:%d:%d", EnableMACD, EnableMACDFeature,
g_TunedMacdFast, g_TunedMacdSlow, g_TunedMacdSignal);
if(EnableIchimoku || EnableIchimokuFeature)
fp += StringFormat("|ICHI:%d:%d:%d:%d:%d", EnableIchimoku, EnableIchimokuFeature,
g_TunedIchiTenkan, g_TunedIchiKijun, g_TunedIchiSenkou);
//--- Alt-data block, conditional like MACD/ICHI: enabling it changes what the model trades on, so it
//--- keys the database; only the FLAG goes in, never the per-symbol feature list - that is a measured
//--- property served by the AltData file and pinned per-model in the .cfg, and a measured quantity
//--- must not key a filename (same rule as the cross-asset pair set).
if(EnableAltData)
fp += "|ALT:1";
//--- Cross-asset, conditional for the same reason. Only the flag goes in, never the discovered
//--- reference set - see the matching comment in BuildConfigFingerprint() for why a measured
//--- quantity must not key a filename.
if(EnableCrossAsset)
fp += StringFormat("|XA:%d", EnableCrossAsset);
if(EnableSpreadFeature)
fp += StringFormat("|SPR:%d", EnableSpreadFeature);
uint fpHash = 2166136261;
int fpLen = StringLen(fp);
for(int fpi = 0; fpi < fpLen; fpi++)
{
fpHash ^= (uint)StringGetCharacter(fp, fpi);
fpHash *= 16777619;
}
return StringFormat("%08x", fpHash);
}
//+------------------------------------------------------------------+
//| Verifies SL_Mode / TP_Mode actually hold members of their enums. |
//| See the call site in OnInit() for why this is a hard gate and |
//| not a clamp. Returns false (and explains itself) on any stale |
//| value. |
//+------------------------------------------------------------------+
bool ValidateBarrierInputs()
{
int sl = (int)SL_Mode;
bool slOk = (sl == SL_INTELLIGENT || sl == SL_ATR_x1 || sl == SL_ATR_x2 || sl == SL_ATR_x3);
int tp = (int)TP_Mode;
bool tpOk = (tp == TP_INTELLIGENT || tp == TP_ATR_x1 || tp == TP_ATR_x2 || tp == TP_ATR_x3 ||
tp == TP_ATR_x4 || tp == TP_ATR_x6 || tp == TP_ATR_x8 || tp == TP_ATR_x10);
if(slOk && tpOk)
return true;
string bad = (!slOk ? "Stop-loss mode (" + IntegerToString(sl) + ")" : "") +
(!slOk && !tpOk ? " and " : "") +
(!tpOk ? "Take-profit mode (" + IntegerToString(tp) + ")" : "");
Print("Warrior EA: REFUSING TO START - " + bad + " is not one of the available options.");
Print("Warrior EA: this happens when a chart's saved settings were written by an older version of the "
"EA that offered an option which no longer exists. MetaTrader keeps the old value silently.");
Print("Warrior EA: FIX - open the EA's Inputs tab, re-pick Stop-loss mode and Take-profit mode from "
"the dropdowns (the shipped pair is 'ATR * 1 from entry (classic)' and 'ATR * 3 from entry "
"(classic)'), then press OK.");
Print("Warrior EA: these two inputs define the neural network's TRAINING TARGET, not just order "
"placement - running with a wrong value would train the model on a strategy you did not choose, "
"so the EA stops here instead of guessing.");
Alert("Warrior EA: " + bad + " is invalid - re-pick Stop-loss / Take-profit mode in the Inputs tab. See the Experts log.");
return false;
}
//+------------------------------------------------------------------+
//| Risk-limit inputs are now free-entry doubles rather than a preset |
//| dropdown, which is what makes them expressive enough for a real |
//| funded-account agreement - and also what makes a typo possible. |
//| These limits gate every trade the EA will ever place, so a wrong |
//| value here is not a suboptimal setting, it is an unprotected |
//| account. Same reasoning as ValidateBarrierInputs() above: refuse to |
//| start rather than substitute something plausible. |
//+------------------------------------------------------------------+
bool ValidateRiskInputs()
{
if(!EnableRiskGuard)
return true;
string bad = "";
if(MaxDailyLossPct < 0.0 || MaxDailyLossPct >= 100.0)
bad += "Daily loss limit (" + DoubleToString(MaxDailyLossPct, 2) + "%) must be >= 0 and < 100. ";
if(MaxDrawdownPct < 0.0 || MaxDrawdownPct >= 100.0)
bad += "Max total drawdown (" + DoubleToString(MaxDrawdownPct, 2) + "%) must be >= 0 and < 100. ";
if(RiskPerTradeOfBudget <= 0.0 || RiskPerTradeOfBudget > 100.0)
bad += "Max % of remaining budget per trade (" + DoubleToString(RiskPerTradeOfBudget, 2) +
") must be > 0 and <= 100. ";
if(RiskDayResetHour < 0 || RiskDayResetHour > 23)
bad += "Risk day reset hour (" + IntegerToString(RiskDayResetHour) + ") must be 0-23. ";
if(bad != "")
{
Print("Warrior EA: REFUSING TO START - " + bad);
Print("Warrior EA: fix the Risk Guard section of the Inputs tab. Enter the limits from your account "
"agreement as plain percentages (e.g. 4 and 8), or 0 to disable a rule.");
Alert("Warrior EA: Risk Guard inputs are invalid - see the Experts log.");
return false;
}
//--- Not fatal, but always wrong in practice: a daily allowance at or above the total allowance means
//--- the daily rule can never trip first, so the first thing it ever protects is nothing.
if(MaxDailyLossPct > 0.0 && MaxDrawdownPct > 0.0 && MaxDailyLossPct >= MaxDrawdownPct)
Print("Warrior EA: WARNING - daily loss limit (", DoubleToString(MaxDailyLossPct, 2),
"%) is not tighter than the max drawdown limit (", DoubleToString(MaxDrawdownPct, 2),
"%). One full daily loss would end the account, so the daily rule protects nothing.");
if(!RiskGuardFlatten)
Print("Warrior EA: NOTE - 'Close own positions on breach' is OFF. The risk limits will decline new "
"entries and shrink position sizing, but an ALREADY-OPEN position can still run through the "
"limit - which is how a hard daily loss rule is usually breached. Turn it on for a funded "
"account where a breach ends the account.");
return true;
}
//+------------------------------------------------------------------+
//| Apply the configuration shared by every AI architecture. |
//+------------------------------------------------------------------+
void ConfigureAISignal(CExpertSignalAIBase *aiSignal)
{
if(CheckPointer(aiSignal) == POINTER_INVALID)
return;
aiSignal.OutputNeuronsCount(OutputNeuronsCount);
//--- HistoryBars is no longer seeded here: the window is DERIVED at InitNeuralNetwork (fresh
//--- model) or ADOPTED from the .cfg (existing model) - see DeriveHistoryBars.
aiSignal.MinDirectionalRecall(MinRecall);
aiSignal.LogitAdjustTau(LogitAdjustTau / 100.0);
aiSignal.SignalClusterWindow(SignalClusterWindow);
aiSignal.FreezePriorCalibration(FreezePriorCalibration);
aiSignal.SwingConfirmationBars(SwingConfirmationBars);
//--- SL/TP reach the AI signals because they now define the TRAINING TARGET, not just the order.
//--- InitializeSignal() sets them on the master signal only; the AI filters are separate objects.
aiSignal.SLMode((int)SL_Mode);
aiSignal.TPMode((int)TP_Mode);
//--- The training target is no longer selectable - direction models are unconditionally triple-
//--- barrier (see the withdrawn TrainingTarget input in Variables\Inputs.mqh for why, and for the
//--- three lines that bring the fractal option back).
if(!aiSignal.IsMetaTarget()
&& (EnablePAI ? 1 : 0) + (EnableCONV ? 1 : 0) + (EnableLSTM ? 1 : 0) + (EnableHYBRID ? 1 : 0) >= 2)
//--- second argument mirrors the open threshold into the combined-vote OOS scorer so the
//--- ensemble panel's "Ensemble vote" line fires on the same criterion the live trade does
aiSignal.EnsembleMember(true, (double)Signal_ThresholdOpen);
//--- THE EXIT POLICY, pushed into the AI signal so the GATE simulates what the live order path
//--- does.
aiSignal.ExitPolicy(0.0, true);
aiSignal.EnableOnlineLearning(EnableOnlineLearning);
aiSignal.MaxErasPerRun(MaxErasPerRun);
aiSignal.OOSSplit(OOSSplit);
if(!UseDatabaseRanking)
aiSignal.Weight(1);
aiSignal.UseVolumes(EnableVolume);
aiSignal.UseTime(EnableTime);
aiSignal.UseATR(EnableATR);
aiSignal.UseMA(EnableMAFeature);
aiSignal.UseRSI(EnableRSIFeature);
aiSignal.UseMACD(EnableMACDFeature);
aiSignal.UseIchimoku(EnableIchimokuFeature);
aiSignal.UseSwingContext(EnableSwingContext);
aiSignal.UseNews(EnableNews);
aiSignal.NewsFeatureWindowMinutes(NewsFeatureWindowMinutes);
aiSignal.UseCrossAsset(EnableCrossAsset);
aiSignal.UseSpreadFeature(EnableSpreadFeature);
aiSignal.UseAltData(EnableAltData);
aiSignal.UseADCumulativeDelta(EnableADCumulativeDelta);
aiSignal.UseADShorteningOfThrust(EnableADShorteningOfThrust);
aiSignal.UseADWyckoffEventStream(EnableADWyckoffEventStream);
aiSignal.UseADWyckoffFailedStructure(EnableADWyckoffFailedStructure);
aiSignal.UseADWyckoffSignificantBarInversion(EnableADWyckoffSignificantBarInversion);
aiSignal.AutoTuneIndicators(AutoTuneIndicators);
}
//+------------------------------------------------------------------+
// Helper function to retry signal creation with error handling
template <typename TSignal>
TSignal* CreateSignalWithRetry(int maxRetries, bool enableFlag)
{
if(!enableFlag)
return NULL;
TSignal* signal = NULL;
for(int tries = 0; tries < maxRetries; ++tries)
{
signal = new TSignal;
if(signal == NULL)
{
Print("Initialization of signal failed, retrying...");
RandomSleep();
}
else
break;
}
if(signal == NULL)
{
Print("Failed to create and initialize signal after retries");
}
return signal;
}
//+------------------------------------------------------------------+
//| ONE RETRY-AND-REPORT for the init steps that can lose a race |
//| with the terminal (indicator handles, timer registration, the |
//| trade objects' own setup). |
//+------------------------------------------------------------------+
typedef bool (*TInitStep)(void);
bool RetryInitStep(TInitStep step, const string what, const int maxRetries, const string caller)
{
for(int tries = 0; tries < maxRetries; ++tries)
{
if(step())
return true;
//--- A permanent refusal gives the same answer five times, and the retries push the one line
//--- that explains it off the top of the operator's log. Stop and repeat the reason instead.
if(g_initFatalReason != "")
{
Print(caller + ": Failed to " + what + " - " + g_initFatalReason +
". Retrying cannot change this; see the REFUSED line above.");
return false;
}
Print(caller + ": Failed to " + what + ", retrying...");
RandomSleep();
}
Print(caller + ": Failed to " + what + " after retries");
return false;
}
//--- The four steps above, each as the no-argument call RetryInitStep takes. Thin by necessity:
//--- MQL5 function pointers cannot bind a method call or an argument, and these are two of each.
bool StepInitTrailing(void) { return InitializeTrailing(); }
bool StepInitMoneyManagement(void) { return InitializeMoneyManagement(); }
bool StepValidateSettings(void) { return Expert.ValidationSettings(); }
bool StepInitIndicators(void) { return Expert.InitIndicators(); }
//--- 500ms: Train() does at most TRAIN_TIME_BUDGET_MS (120ms solo, 30ms per ensemble member) of
//--- work per call, then yields back here. EventSetMillisecondTimer is needed for sub-second
//--- resolution; EventSetTimer takes whole seconds only.
#define WARRIOR_TIMER_INTERVAL_MS 500
bool StepSetTimer(void) { return EventSetMillisecondTimer(WARRIOR_TIMER_INTERVAL_MS); }
//+------------------------------------------------------------------+
//| IMPORTANT: no failure branch below (nor in any helper it calls - |
//| AddFilterToSignal(), InitializeSignal(), InitializeTrailing(), |
//| InitializeMoneyManagement()) may call Expert.Deinit() before |
//| returning INIT_FAILED/false. |
//+------------------------------------------------------------------+
int OnInit()
{
//--- FIRST: adopt the chart's tuned indicator periods (if a gated auto-tune install ever wrote them).
//--- Must precede ComputeDbConfigFingerprint() and the classic-signal configuration below, both of
//--- which consume the g_Tuned* values - see Variables\TunedPeriods.mqh for the whole contract.
LoadTunedPeriods();
//--- clears out whatever status label text was left over from before this OnInit() ran (stale text
//--- from a prior "warm" re-init - e.g. an input-parameter change, which reuses this same running
//--- instance rather than a fresh one - would otherwise sit unchanged and look like nothing is
//--- happening) so it's obvious the moment training/signal init actually resumes producing new status text
//--- START FROM A GUARANTEED-CLEAN CHART. Before anything is drawn, sweep every object namespace this
//--- EA owns (WarriorChartPrefixes). Chart objects live in the chart PROFILE, not in the EA, so they
//--- outlive the process: a deinit that ran out of MetaTrader's ~4,500 ms budget, a crash, a terminal
//--- kill, or an .ex5 replaced while attached all leave objects behind that no later deinit will ever
//--- own. Deleting the EA's files does not remove them either, which is why they read as corruption.
//--- Arrows are INCLUDED in this sweep: LoadChartSignals restores them from their sidecar moments later
//--- and already opens with its own arrow sweep, so purging here costs nothing and removes any orphan
//--- that the sidecar does not account for - the ones that would otherwise be adopted by the next model
//--- to attach, because SaveChartSignals rebuilds that sidecar by SCANNING the chart.
//--- Runs BEFORE SetStatusLabel below, or it would delete the label it just created.
int initLeftover = 0;
int initPurged = WarriorPurgeChartObjects(0, false, initLeftover);
if(initPurged > 0)
PrintFormat("%s: chart purge on init - removed %d leftover EA object(s)%s. Chart objects survive a"
" starved deinit, a crash and an .ex5 swap, so a clean start is asserted here rather"
" than assumed from the last shutdown.", __FUNCTION__, initPurged,
(initLeftover > 0
? StringFormat(" (%d of them needed a by-name delete after the bulk call)", initLeftover)
: ""));
//--- AND SAY WHAT SURVIVED IT. Names, not just a count - a count cannot be acted on. Reporting is
//--- the whole intervention. "Removed N, zero by-name leftovers" only ever meant "nothing matching
//--- OUR PREFIXES remains" - it was never a statement about the chart, and on 2026-08-17 22:00 all
//--- three charts printed exactly that and still came up with duplicated panels.
{
string resPrefixes[];
int np = WarriorChartPrefixes(resPrefixes);
int resTotal = ObjectsTotal(0, -1, -1);
string residue = "";
int unmatched = 0;
for(int i = 0; i < resTotal; i++)
{
string nm = ObjectName(0, i, -1, -1);
bool ours = false;
for(int q = 0; q < np; q++)
if(StringFind(nm, resPrefixes[q]) == 0)
{
ours = true;
break;
}
if(ours)
continue;
unmatched++;
if(unmatched <= 12)
residue += (residue == "" ? "" : ", ") + nm;
}
if(unmatched > 0)
PrintFormat("%s: chart residue after the init purge - %d object(s) this EA did not create and did"
" not touch: %s%s. If a Warrior panel or status line is VISIBLE on the chart and is"
" not in this list and was not removed above, the prefix list has drifted again"
" (see WarriorChartPrefixes).", __FUNCTION__, unmatched, residue,
(unmatched > 12 ? StringFormat(" ... and %d more", unmatched - 12) : ""));
}
SetStatusLabel("Warrior EA: initializing...");
//--- WHICH BINARY IS ACTUALLY RUNNING. Read it FIRST when a fix appears not to have taken.
PrintFormat("%s: build tag %s | COMPILED %s", __FUNCTION__, WARRIOR_BUILD_TAG,
TimeToString(__DATETIME__, TIME_DATE | TIME_MINUTES));
PrintFormat("%s: trade settings snapshot - NNs=%s Entry_Multiplier=%d SL_Mode=%d TP_Mode=%d TrailingStrategy=%d MM_STRATEGY=%d",
__FUNCTION__, EnabledNNSummary(), (int)Entry_Multiplier, (int)SL_Mode, (int)TP_Mode,
(int)TrailingStrategy, (int)MM_STRATEGY);
//--- HARD GATE on the two inputs that define the training target. This is not hypothetical. Hours
//--- of training measuring a strategy nobody chose, with nothing in the log saying so.
if(!ValidateBarrierInputs())
return INIT_FAILED;
if(!ValidateRiskInputs())
return INIT_FAILED;
//--- Configure the account loss budget BEFORE anything can size or place a trade. Everything
//--- downstream (the money manager's clamp, the risk-guard veto) reads this one object, so it must be
//--- live from the first tick rather than from whenever the signal pipeline happens to initialise.
g_riskBudget.Configure(EnableRiskGuard, MaxDailyLossPct, MaxDrawdownPct, MaxDrawdownIsTrailing,
RiskDayResetHour, RiskPerTradeOfBudget, RiskGuardFlatten,
(long)Expert_MagicNumber, Symbol());
g_riskBudget.ConfigureExpectancy(ExpectancyMinTrades, ExpectancySigma);
g_riskBudget.Update();
if(EnableRiskGuard)
Print("Warrior EA: ", g_riskBudget.StatusLine());
//--- Stated at init so the sample carried over from previous sessions is visible before any trade is
//--- placed, rather than only appearing in the line that halts trading.
if(ExpectancyMinTrades > 0 && g_riskBudget.ExpectancyTrades() > 0)
PrintFormat("Warrior EA: realised expectancy %.3f R over %d closed trades (halts below %.1f standard "
"errors under zero, after %d trades). Expected value per trade with no directional edge "
"is minus the cost, so a persistently negative figure here is the strategy, not variance.",
g_riskBudget.ExpectancyR(), g_riskBudget.ExpectancyTrades(), ExpectancySigma,
ExpectancyMinTrades);
LoadSignalsVisibilityState();
int maxRetryOnError = 5;
string functionName = __FUNCTION__;
// Initialize random seed based on the number of milliseconds since the system started
//--- One process-wide seeding at startup; every fresh topology re-seeds with its own model id
//--- on top of this (System\Random.mqh).
WarriorRandSeed("OnInit");
// Initialize expert
bool expertInitialized = false;
for(int tries = 0; !expertInitialized && tries < 5; ++tries)
{
if(!Expert.Init(Symbol(), Period(), Expert_EveryTick, Expert_MagicNumber))
{
Print(functionName + ": Failed initializing expert, retrying...");
RandomSleep();
}
else
{
expertInitialized = true;
break;
}
}
if(!expertInitialized)
{
Print(functionName + ": Failed to initialize expert after retries");
return INIT_FAILED;
}
Expert.OnChartEventProcess(true);
//--- Alt-data MUST be on disk BEFORE any model is built below, not after: InitNeuralNetwork's
//--- fingerprint/input-width pinning happens once, at construction, and never re-widens for data
//--- that lands later (see AltDataReload's declaration comment for the OLD failure - a fresh
//--- attach with an empty AltData folder built every model at 0 features while the OnTimer-driven
//--- download finished moments afterward, and every model then trained on price alone for the rest
//--- of the run). Blocking here instead of leaving it to the timer means the one-off backfill
//--- WebRequest(s) (seconds, per CAltDataFetch::Update's comment) delay this OnInit instead of
//--- racing it - a slower attach is the correct trade against a silently undersized model.
//--- Skipped for an unmapped symbol (Update() no-ops via FindSpec) and in the tester/optimizer,
//--- where WebRequest is unavailable by platform rule - same guard OnTimer's upkeep tick uses.
if(EnableAltData && !MQLInfoInteger(MQL_TESTER) && !MQLInfoInteger(MQL_OPTIMIZATION))
{
g_lastAltDataRun = TimeCurrent();
g_altDataFetch.Update(_Symbol);
}
//--- Same fix, same reason, for the cross-asset reference pairs (System\CrossAsset.mqh): a fresh
//--- model's first successful Build() pins whichever reference pairs happened to be synchronised at
//--- that instant, for the model's life (see WarmBlocking's declaration comment) - so a pair still
//--- mid-sync at attach time would be silently and permanently excluded, exactly the alt-data failure
//--- above. Skipped in the tester/optimizer, where the agent loads auxiliary symbols from the
//--- terminal rather than syncing them, so waiting here would only burn the timeout for nothing.
if(EnableCrossAsset && !MQLInfoInteger(MQL_TESTER) && !MQLInfoInteger(MQL_OPTIMIZATION))
{
CCrossAssetPanel crossAssetWarmer;
//--- A TIMEOUT HERE MUST BE AUDIBLE. Say so in the journal, because from that point on
//--- nothing else in the run ever mentions the missing pair again.
if(!crossAssetWarmer.WarmBlocking((ENUM_TIMEFRAMES)Period(), 4000))
Print("Cross-asset warm-up did not finish syncing every reference pair within 4s - the model"
" built below will PIN whichever pairs are ready at that moment and never add the rest."
" If the feature count looks short, detach and re-attach once the terminal has finished"
" downloading the reference symbols' history.");
}
// Creating signal
PrintVerbose("Initializing Signal...");
CExpertSignalCustom* signal = NULL;
for(int tries = 0; signal == NULL && tries < 5; ++tries)
{
signal = new CExpertSignalCustom;
if(signal == NULL)
{
Print(functionName + ": Failed to initialize Signal, retrying...");
RandomSleep();
}
else
{
break;
}
}
if(signal == NULL)
{
Print(functionName + ": Failed to initialize Signal after retries");
return INIT_FAILED;
}
InitializeSignal(signal);
// Initializing Database
if(UseDatabaseRanking)
{
bool dbInitialized = false;
string databaseFolderStructure[] = {eaName, "Databases", "Signals"};
//--- fingerprinted so a topology/feature-set change that would produce a differently-shaped or
//--- differently-behaving model gets its own database, instead of silently mixing pattern-weight/
//--- trade-journal history from an incompatible prior config into the one now trading.
const string dbName = Symbol() + "_" + IntegerToString(Period()) + "_" + ComputeDbConfigFingerprint() + ".db";
//--- 3.0: the pattern tables gained the netVote column and journaling went per-side (see
//--- CExpertSignalCustom::Direction()). 4.0 (2026-08-19): DB timestamps switched from GMT to
//--- BROKER time (user decision: one clock everywhere).
const string dbVersion = "4.0";
PrintVerbose("Initializing Database...");
for(int tries = 0; !dbInitialized && tries < 5; ++tries)
{
if(!dbm.Init(dbVersion, databaseFolderStructure, dbName))
{
Print(functionName + ": Failed to initialize Database, retrying...");
RandomSleep();
}
else
{
dbInitialized = true;
break;
}
}
if(!dbInitialized)
{
Print(functionName + ": Failed to initialize Database after retries");
return INIT_FAILED;
}
//--- Trade journal shares UseDatabaseRanking's DB connection/lifecycle rather than adding a
//--- second always-on toggle - see Database\TradeJournalManager.mqh's class comment.
if(!journal.Init(GetPointer(dbm), Expert_MagicNumber))
{
Print(functionName + ": Failed to initialize trade journal table");
return INIT_FAILED;
}
//--- Meta_Labeling_Design.md S1: the pattern DB doubles as the meta-label training corpus.
//--- The stale-DB check is ALWAYS on in the tester (a forgotten wipe silently voids a whole
//--- corpus run); the full report - volume per family, closed fraction, and the measured
//--- GMT->server bar-time offset S2's label plumbing pins to - stays under VerboseMode.
MetaCorpusStaleCheck();
if(VerboseMode)
MetaCorpusReport();
}
else
//--- No DB, but the close-detection path still runs: it feeds the expectancy stop
//--- (g_riskBudget.RecordTradeResult). Until 2026-08-11 that feed existed only under
//--- UseDatabaseRanking (ships false), so the expectancy halt could never arm on a default
//--- install - see InitTrackingOnly's comment in Database\TradeJournalManager.mqh.
journal.InitTrackingOnly(Expert_MagicNumber);
//+------------------------------------------------------------------+
//| The per-NN inputs (Use_MLP/Use_CONV/Use_LSTM/Use_CONVLSTM) pick |
//| which direction architectures this run trades/trains - any |
//| subset, each an independent model - plus the optional meta head |
//| (Use_MetaLabeling). |
//+------------------------------------------------------------------+
//--- Re-derived from the per-NN inputs (they are also initialized at file scope in
//--- Variables\Variables.mqh; this re-assignment is the init-order-safe truth).
EnablePAI = Use_MLP;
EnableCONV = Use_CONV;
EnableLSTM = Use_LSTM;
EnableHYBRID = Use_CONVLSTM;
EnableMETA = Use_MetaLabeling;
// Creating instances of signals
CSignalPAI *PAI = CreateSignalWithRetry<CSignalPAI>(maxRetryOnError, EnablePAI);
CSignalCONV *CONV = CreateSignalWithRetry<CSignalCONV>(maxRetryOnError, EnableCONV);
CSignalLSTM *LSTM = CreateSignalWithRetry<CSignalLSTM>(maxRetryOnError, EnableLSTM);
CSignalHYBRID *HYBRID = CreateSignalWithRetry<CSignalHYBRID>(maxRetryOnError, EnableHYBRID);
CSignalMETA *META = CreateSignalWithRetry<CSignalMETA>(maxRetryOnError, EnableMETA);
//--- register whichever AI signal instances this run created, so the control panel can drive
//--- training/weight actions on exactly this run's current config (never another config's files)
g_aiSignalCount = 0;
//--- The meta gate pointer must not survive a re-init: an input change re-enters OnInit in the
//--- same program instance, and the old object is freed by the filter-array teardown.
g_warriorMetaGate = NULL;
if(EnablePAI && PAI != NULL)
RegisterAISignal(PAI);
if(EnableCONV && CONV != NULL)
RegisterAISignal(CONV);
if(EnableLSTM && LSTM != NULL)
RegisterAISignal(LSTM);
if(EnableHYBRID && HYBRID != NULL)
RegisterAISignal(HYBRID);
if(EnableMETA && META != NULL)
{
RegisterAISignal(META);
//--- Arm the vote-pipeline meta gate (CSignalMETA::LiveMetaGate): CheckOpenPosition consults
//--- this pointer on every vote-cleared entry, and the ensemble era verdict replays the same
//--- veto over its OOS fired bars so certified == traded.
g_warriorMetaGate = META;
}
CSignalMA *MA = CreateSignalWithRetry<CSignalMA>(maxRetryOnError, EnableMA);
CSignalRSI *RSI = CreateSignalWithRetry<CSignalRSI>(maxRetryOnError, EnableRSI);
CSignalMACD *MACD = CreateSignalWithRetry<CSignalMACD>(maxRetryOnError, EnableMACD);
CSignalIchimoku *Ichimoku = CreateSignalWithRetry<CSignalIchimoku>(maxRetryOnError, EnableIchimoku);
CSignalNewsFilter *newsFilter = CreateSignalWithRetry<CSignalNewsFilter>(maxRetryOnError, EnableNewsFilter);
CSignalSessionFilter *sessionFilter = CreateSignalWithRetry<CSignalSessionFilter>(maxRetryOnError, EnableSessionFilter);
//--- CSignalITF and CSignalMarketDepth were removed 2026-08-01 - see the removal notes in
//--- Variables\Inputs.mqh (bitmask-configured time filter, and an untestable DOM module).
CSignalRiskGuard *riskGuard = CreateSignalWithRetry<CSignalRiskGuard>(maxRetryOnError, EnableRiskGuard);
if((EnableMA && MA == NULL) || (EnableRSI && RSI == NULL) || (EnableMACD && MACD == NULL) || (EnableIchimoku && Ichimoku == NULL) || (EnablePAI && PAI == NULL) || (EnableCONV && CONV == NULL) || (EnableLSTM && LSTM == NULL) || (EnableHYBRID && HYBRID == NULL) || (EnableMETA && META == NULL) || (EnableNewsFilter && newsFilter == NULL) || (EnableSessionFilter && sessionFilter == NULL) || (EnableRiskGuard && riskGuard == NULL))
{
Print("Critical signal initialization failed, cannot proceed");
return INIT_FAILED;
}
// Set filter parameters
//--- CSignalRiskGuard takes no parameters any more: the thresholds, the anchors and the state file
//--- all moved to g_riskBudget (configured in OnInit, evaluated per tick).
if(EnableSessionFilter)
{
sessionFilter.TradeLondonSession(SF_trade_LondonSession);
sessionFilter.TradeNewYorkSession(SF_trade_NewYorkSession);
sessionFilter.TradeTokyoSession(SF_trade_TokyoSession);
}
//--- Classic votes run at the chart's TUNED periods (g_Tuned*, loaded first thing in OnInit) -
//--- the same values the AI features seed from and the DB key hashes, so all three consumers
//--- always describe the same indicators. See Variables\TunedPeriods.mqh.
//--- Classic_Shift is set on these four and nowhere else - see that input's comment for why the AI
//--- signals keep the stock rule.
if(EnableMA)
{
MA.PeriodMA(g_TunedMaPeriod);
MA.Method(g_TunedMaType);
MA.Shift(Classic_Shift);
if(!UseDatabaseRanking)
MA.Weight(1);
}
if(EnableRSI)
{
RSI.PeriodRSI(g_TunedRsiPeriod);
RSI.Shift(Classic_Shift);
if(!UseDatabaseRanking)
RSI.Weight(1);
}
if(EnableMACD)
{
MACD.PeriodFast(g_TunedMacdFast);
MACD.PeriodSlow(g_TunedMacdSlow);
MACD.PeriodSignal(g_TunedMacdSignal);
MACD.Shift(Classic_Shift);
if(!UseDatabaseRanking)
MACD.Weight(1);
}
if(EnableIchimoku)
{
Ichimoku.PeriodTenkan(g_TunedIchiTenkan);
Ichimoku.PeriodKijun(g_TunedIchiKijun);
Ichimoku.PeriodSenkou(g_TunedIchiSenkou);
Ichimoku.Shift(Classic_Shift);
if(!UseDatabaseRanking)
Ichimoku.Weight(1);
}
if(EnableNewsFilter)
{
newsFilter.SetMinImpact(NF_MinImpact);
newsFilter.SetLookbackMinutes(NF_LookMinutes);
}
if(EnablePAI)
ConfigureAISignal(PAI);
if(EnableCONV)
ConfigureAISignal(CONV);
if(EnableLSTM)
ConfigureAISignal(LSTM);
if(EnableHYBRID)
ConfigureAISignal(HYBRID);
if(EnableMETA)
{
ConfigureAISignal(META);
//--- AFTER the shared config (which stamps the 1/3-output const input): the meta head is a
//--- 2-output binary softmax - "did this candidate's trade win" - and both the topology and the
//--- weights-filename fingerprint key off this value. See Meta_Labeling_Design.md S2.
META.OutputNeuronsCount(2);
//--- candidate sources for the on-chart ladder sweep (BuildCorpusBySweep): the meta corpus is
//--- generated by evaluating these real filters over this chart's own history, so a META
//--- chart is fully self-contained - no tester corpus run.
if(EnableMA)
META.AddCandidateSource(MA, 0);
if(EnableRSI)
META.AddCandidateSource(RSI, 1);
if(EnableMACD)
META.AddCandidateSource(MACD, 2);
if(EnableIchimoku)
META.AddCandidateSource(Ichimoku, 3);
}
// Add filters
PrintVerbose("Initializing Signal filters...");
//--- added exactly once, before the DB retry loop below - these calls don't depend on DB success at
//--- all (every pointer here was already validated non-NULL above), but living inside the loop body
//--- meant a DB open/transaction failure that triggered a retry would re-run AddFilterToSignal() and
//--- register the same filter pointer a second time in signal's CArrayObj; since that array frees its
//--- elements on destruction, a duplicate entry means the same pointer gets deleted twice on shutdown
//--- (heap corruption), which could easily explain instability across a later remove/re-add cycle.
bool filtersAdded = true;
filtersAdded &= (EnableMA ? AddFilterToSignal(signal, MA) : true);
filtersAdded &= (EnableRSI ? AddFilterToSignal(signal, RSI) : true);
filtersAdded &= (EnableMACD ? AddFilterToSignal(signal, MACD) : true);
filtersAdded &= (EnableIchimoku ? AddFilterToSignal(signal, Ichimoku) : true);
filtersAdded &= (EnableSessionFilter ? AddFilterToSignal(signal, sessionFilter) : true);
filtersAdded &= (EnableNewsFilter ? AddFilterToSignal(signal, newsFilter) : true);
filtersAdded &= (EnableRiskGuard ? AddFilterToSignal(signal, riskGuard) : true);
filtersAdded &= (EnablePAI ? AddFilterToSignal(signal, PAI) : true);
filtersAdded &= (EnableCONV ? AddFilterToSignal(signal, CONV) : true);
filtersAdded &= (EnableLSTM ? AddFilterToSignal(signal, LSTM) : true);
filtersAdded &= (EnableHYBRID ? AddFilterToSignal(signal, HYBRID) : true);
//--- META registers like any AI filter so it gets InitIndicators + training scheduling; its votes
//--- are structurally 0 in S2 (dPrevSignal never leaves the sentinel - see SignalMETA.mqh header).
filtersAdded &= (EnableMETA ? AddFilterToSignal(signal, META) : true);
if(!filtersAdded)
{
Print(functionName + ": Error loading filters");
return INIT_FAILED;
}
bool filterSuccess = false;
for(int tries = 0; tries < maxRetryOnError; ++tries)
{
if(UseDatabaseRanking && !dbm.OpenDatabase())
{
Print(functionName + ": Error opening database, retrying...");
RandomSleep();
continue;
}
if(UseDatabaseRanking && !dbm.BeginTransaction())
{
Print(functionName + ": Error starting transaction, retrying...");
dbm.CloseDatabase(); // Ensure the database is closed before retry
RandomSleep();
continue;
}
if(UseDatabaseRanking && (!dbm.CommitTransaction() || !dbm.CloseDatabase()))
{
Print(functionName + ": Error committing transaction or closing database, retrying...");
RandomSleep();
continue;
}
filterSuccess = true;
break; // Success if all operations complete without error
}
if(!filterSuccess)
{
Print(functionName + ": Failed after all retries");
return INIT_FAILED; // Return failure if retries are exhausted
}
// Trailing logic
PrintVerbose("Initializing Trailing...");
if(!RetryInitStep(StepInitTrailing, "initialize Trailing", maxRetryOnError, functionName))
return INIT_FAILED;
// Creation of money object
if(!RetryInitStep(StepInitMoneyManagement, "initialize Money Management", maxRetryOnError, functionName))
return INIT_FAILED;
// Check all trading objects parameters
PrintVerbose("Validating settings...");
if(!RetryInitStep(StepValidateSettings, "validate settings", maxRetryOnError, functionName))
return INIT_FAILED;
// Tuning of all necessary indicators
PrintVerbose("Initializing Indicators...");
if(!RetryInitStep(StepInitIndicators, "initialize Indicators", maxRetryOnError, functionName))
return INIT_FAILED;
//--- setting timer: always on (short interval) so control-panel upkeep and other periodic checks
//--- run on a fixed schedule regardless of tick activity - a quiet/after-hours symbol can go long
//--- stretches without a single OnTick() call, and self-healing logic that only lives in OnTick()
//--- would never run during that stretch.
if(UseDatabaseRanking)
Expert.OnTimerProcess(true);
//--- Interval and the reasoning behind it: WARRIOR_TIMER_INTERVAL_MS, beside StepSetTimer().
if(!RetryInitStep(StepSetTimer, "set the timer", maxRetryOnError, functionName))
return INIT_FAILED;
// Initialization successful
PrintVerbose("Initialization successful");
if(!CreateControlPanel())
Print(functionName + ": WARNING - control panel failed to initialize; trading/training continue normally, "
"but no GUI panel will be available for this run");
//--- one-time cleanup: an earlier build used Comment() plus a separate background rectangle object
//--- that turned out to render ON TOP of the text (Comment() has no built-in background/styling
//--- parameters at all) - delete any leftover from a prior run now that status text is a single
//--- self-contained OBJ_LABEL (see SetStatusLabel()) with its own BGCOLOR fill instead
if(ObjectFind(0, "WarriorCommentBG") >= 0)
ObjectDelete(0, "WarriorCommentBG");
//--- required for CAppDialog's caption-bar drag to work at all - without it, the chart never delivers
//--- CHARTEVENT_MOUSE_MOVE and the panel silently ignores drag attempts
ChartSetInteger(0, CHART_EVENT_MOUSE_MOVE, true);
g_lastAlgoTradingAllowed = (bool)TerminalInfoInteger(TERMINAL_TRADE_ALLOWED) && (bool)MQLInfoInteger(MQL_TRADE_ALLOWED);
if(!g_lastAlgoTradingAllowed)
Print(functionName + ": WARNING - AlgoTrading is currently disabled (terminal or EA); signals will still train but no orders will be sent until it is re-enabled");
return INIT_SUCCEEDED;
}
// Called before optimization/backtesting in the strategy tester
int OnTesterInit()
{
IsBacktesting = true;
return(INIT_SUCCEEDED);
}
// Called after EA optimization in the strategy tester
void OnTesterDeinit()
{
//--- OnTesterInit/OnTesterDeinit fire once per tester session, even for a single (non-
//--- optimization) backtest - and by the time this runs, that pass's own OnDeinit() has ALREADY
//--- executed (the terminal calls it automatically at the end of every pass), including its own
//--- dbm.Deinit().
IsBacktesting = false;
}
//+------------------------------------------------------------------+
//| Tester function for smooth linear equity optimization |
//| Output Range: 0.0 (Worst/Failed) to 100.0 (Perfect Linear Curve) |
//+------------------------------------------------------------------+
double OnTester()
{
// 1. Enforce minimum performance thresholds
double totalTrades = TesterStatistics(STAT_TRADES);
if(totalTrades < 30) return(0.0);
double netProfit = TesterStatistics(STAT_PROFIT);
if(netProfit <= 0) return(0.0);
double maxDrawdownPct = TesterStatistics(STAT_EQUITY_DDREL_PERCENT);
if(maxDrawdownPct > 15.0) return(0.0);
// 2. Extract key performance components for linearity proxy
double profitFactor = TesterStatistics(STAT_PROFIT_FACTOR);
double recoveryFactor = TesterStatistics(STAT_RECOVERY_FACTOR);
double sharpeRatio = TesterStatistics(STAT_SHARPE_RATIO);
if(profitFactor <= 0 || recoveryFactor <= 0) return(0.0);
if(sharpeRatio < 0) sharpeRatio = 0.01;
// 3. Trade density multiplier
double tradeDensity = 1.0 - MathExp(-0.01 * (double)totalTrades);
// 4. Mathematical combination proxy targeting visual linearity
double rawScore = profitFactor * recoveryFactor * sharpeRatio;
// FIX: Convert percent to decimal (divide by 100) before penalization
double drawdownDecimal = maxDrawdownPct / 100.0;
rawScore /= (1.0 + (drawdownDecimal * 0.5));
// Apply trade density
rawScore *= tradeDensity;
// 5. Normalize the score to a 0.0 - 100.0 scale
double finalScore = 100.0 * (1.0 - MathExp(-0.12 * rawScore));
if(finalScore > 100.0) finalScore = 100.0;
if(finalScore < 0.0) finalScore = 0.0;
return(finalScore);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Maps a terminal deinit reason code to a short label for logging, |
//| so operators can tell a routine recompile/parameter change apart |
//| from a terminal shutdown or the EA actually being removed. |
//+------------------------------------------------------------------+
string DeinitReasonToString(const int reason)
{
switch(reason)
{
case REASON_PROGRAM: return "EA stopped by ExpertRemove()/self";
case REASON_REMOVE: return "EA removed from chart";
case REASON_RECOMPILE: return "EA recompiled";
case REASON_CHARTCHANGE: return "chart symbol/period changed";
case REASON_CHARTCLOSE: return "chart closed";
case REASON_PARAMETERS: return "input parameters changed";
case REASON_ACCOUNT: return "account changed";
case REASON_TEMPLATE: return "template applied";
case REASON_INITFAILED: return "OnInit() failed";
case REASON_CLOSE: return "terminal closed";
default: return "unknown (" + IntegerToString(reason) + ")";
}
}
void OnDeinit(const int reason)
{
static bool s_deinitInProgress = false;
if(s_deinitInProgress)
return;
s_deinitInProgress = true;
// Stop timer callbacks first so no more periodic work is queued while teardown runs.
EventKillTimer();
string reasonStr = DeinitReasonToString(reason);
Print(__FUNCTION__ + ": shutting down - reason: " + reasonStr);
bool isTesterRun = (MQLInfoInteger(MQL_TESTER) || MQLInfoInteger(MQL_OPTIMIZATION) || MQLInfoInteger(MQL_FORWARD));
if(!isTesterRun)
SaveSignalsVisibilityState();
//--- Clear the VISIBLE EA objects FIRST and fast - status label, then control panel, then arrows -
//--- BEFORE the slow/fragile weight save below. Only then the heavy persistence runs, best-effort,
//--- last.
ClearStatusLabel();
//--- EARLY VISIBLE-UI SWEEP, 2026-08-16.
int earlySweepLeft = 0;
WarriorPurgeChartObjects(0, true, earlySweepLeft);
//--- ORDER, 2026-08-09: the arrow purge now runs BEFORE ExtPanel.Destroy(), not after. That 4.8 s
//--- is MetaTrader's OnDeinit budget expiring, not a fault: nothing threw, the process simply ran
//--- out of time in a step ahead of the cleanup.
ulong deinitT0 = GetMicrosecondCount();
for(int i = 0; i < g_aiSignalCount; i++)
g_aiSignals[i].MarkShutdown();
for(int i = 0; i < g_aiSignalCount; i++)
//--- Persist the drawn arrows to their sidecar and take them off the chart, on EVERY deinit
//--- reason. They come back on the next attach, from disk, if a model for that config exists -
//--- see PersistAndClearChartSignals().
g_aiSignals[i].ShutdownChartCleanup();
ulong deinitTArrows = GetMicrosecondCount();
//--- Destroy the control panel's own UI so CAppDialog removes its own objects cleanly (see
//--- Controls\Dialog.mqh). After the arrow purge now - see the ordering note above.
if(!isTesterRun)
{
ExtPanel.Destroy(reason);
if(g_altMapDialogOpen)
{
g_altMapDialog.Destroy(reason);
g_altMapDialogOpen = false;
}
}
//--- FINAL SWEEP, after every owner-driven teardown has had its turn. Cheap and bounded: three
//--- prefix deletes plus one object-list scan, which is the shape of work this ordering rule
//--- permits at this point. It closes the ordinary case; OnInit closes the case where MetaTrader
//--- never let us finish.
int deinitLeftover = 0;
int deinitPurged = WarriorPurgeChartObjects(0, true, deinitLeftover);
if(deinitPurged > 0)
PrintFormat("%s: final sweep removed %d EA object(s) that survived their own teardown%s.",
__FUNCTION__, deinitPurged,
(deinitLeftover > 0
? StringFormat(" (%d needed a by-name delete)", deinitLeftover) : ""));
ChartRedraw(0);
ulong deinitTPanel = GetMicrosecondCount();
Print(__FUNCTION__ + ": cleanup timings - arrows " + DoubleToString((deinitTArrows - deinitT0) / 1000.0, 0) +
" ms, panel " + DoubleToString((deinitTPanel - deinitTArrows) / 1000.0, 0) +
" ms. MetaTrader force-terminates OnDeinit at roughly 4,500 ms TOTAL; if this line is missing "
"entirely, the budget expired before it and the step that overran is the one after the last "
"message that DID print.");
//--- The MarkShutdown()/ShutdownChartCleanup() pair that used to sit here has moved ABOVE the panel
//--- teardown - see the ordering note there. The original order put that heavy save ahead of the
//--- cheap visible cleanup.
bool flushedAny = false;
for(int i = 0; i < g_aiSignalCount; i++)
{
if(g_aiSignals[i].TrainingComplete())
g_aiSignals[i].StopTraining();
else
flushedAny = (g_aiSignals[i].FlushTrainRun() || flushedAny);
}
if(flushedAny)
Print(__FUNCTION__ + ": discarded the in-flight era on at least one model rather than finalising it -"
" training resumes from the last completed era, which is already on disk. This is what keeps"
" the chart cleanup inside MetaTrader's deinit budget.");
//--- Persist every active AI signal's current in-memory weights/state, so a terminal restart,
//--- recompile, chart re-add or template swap resumes from here rather than from the last fully-
//--- completed training era only.
if(!isTesterRun)
{
for(int i = 0; i < g_aiSignalCount; i++)
{
if(!g_aiSignals[i].TrainingComplete())
continue;
if(!g_aiSignals[i].PersistWeightsOnShutdown())
Print(__FUNCTION__ + ": WARNING - failed to persist weights for signal index " + IntegerToString(i) + " on shutdown (reason: " + reasonStr + ")");
}
}
g_aiSignalCount = 0;
dbm.Deinit();
Expert.Deinit();
//--- belt-and-suspenders: the status label was already cleared first, but re-clear in case a later path
//--- (e.g. Expert.Deinit's destructors) drew anything, so nothing is left on the chart after removal.
ClearStatusLabel();
s_deinitInProgress = false;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
//--- Expert.OnTimer() does the (comparatively expensive) DB-ranking work, originally paced by its
//--- own 1-hour EventSetTimer() interval; now that the timer fires every 500ms (see OnInit for why
//--- that interval), pace that work manually instead so it still only actually runs about once an hour.
#define DB_RANKING_INTERVAL_SECONDS 3600
datetime g_lastDbRankingRun = 0;
//--- Alt-data maintenance (see System\AltDataFetch.mqh): the EA downloads its own missing history
//--- at attach time and keeps appending forward while deployed, so online learning never depends on
//--- an external process.
//+------------------------------------------------------------------+
//| Unknown chart symbol -> ask which instrument it is, once. |
//| Non-blocking: the EA keeps initialising, training and trading |
//| while the dialog sits on the chart. An unmapped symbol just |
//| contributes 0 alt-data features. |
//+------------------------------------------------------------------+
void MaybeAskAltDataMapping(void)
{
if(!EnableAltData || g_altMapAsked || g_altMapDialogOpen)
return;
if(!g_altDataFetch.NeedsMapping(_Symbol))
return; // catalogued, or the user already recorded a choice
g_altMapAsked = true; // one prompt per attach, even if it is closed unanswered
int n = g_altDataFetch.CatalogCount();
string labels[], canon[];
ArrayResize(labels, n);
ArrayResize(canon, n);
for(int i = 0; i < n; i++)
{
labels[i] = g_altDataFetch.CatalogLabel(i);
canon[i] = g_altDataFetch.CatalogName(i);
}
PrintFormat("AltDataFetch: '%s' is not in the alt-data catalog - asking which instrument it maps "
"to. The EA runs normally either way; the answer is saved in symbol_map.cfg.", _Symbol);
if(g_altMapDialog.Show(_Symbol, labels, canon))
g_altMapDialogOpen = true;
else
Print("AltDataFetch: the mapping dialog could not be opened - map it by hand instead: add a "
"line like '" + _Symbol + "=SP500' to Common\\Files\\Warrior_EA\\AltData\\symbol_map.cfg "
"(or '" + _Symbol + "=NONE' to decline).");
}
//+------------------------------------------------------------------+
//| Apply the dialog's answer once the user has clicked. Called from |
//| OnChartEvent, after the dialog has seen the same event. Drive |
//| the FILTERED view's historical reconstruction. |
//+------------------------------------------------------------------+
#define OVERLAY_BARS_PER_SLICE 150
//--- Minimum wall-clock between overlay re-arms. Five minutes keeps the reconstruction current on
//--- any human timescale while cutting the churn ~15x.
#define OVERLAY_REARM_MIN_MS 60000
uint g_lastOverlayArmTick = 0;
//--- Longest a sweep waits for a member that has stopped producing snapshots. Past this it draws
//--- with whoever is ready AND SAYS SO - a stale chart that never redraws is worse than a partial
//--- one that reports itself.
#define OVERLAY_PARTIAL_ARM_MS 600000
//+------------------------------------------------------------------+
//| Which ensemble members must have a snapshot before a sweep runs. |
//| |
//| The array index is the member's m_ensembleIndex, so the slot IS |
//| the bit. Zero means no ensemble is registered (a single-model |
//| configuration), and the gate is then a no-op rather than a lock. |
//+------------------------------------------------------------------+
uint EnrolledOverlayMask(void)
{
uint mask = 0;
int n = MathMin(ArraySize(g_warriorEnsemble), ENS_MAX_MEMBERS);
for(int i = 0; i < n; i++)
if(CheckPointer(g_warriorEnsemble[i]) != POINTER_INVALID)
mask |= (((uint)1) << i);
return mask;
}
void AdvanceFilteredSignalOverlay(void)
{
if(DrawUnfilteredSignals)
return; // raw view owns the chart; nothing to reconstruct
//--- ARM ON THE MEMBERS' OWN SIGNAL, not on an era-counter diff. g_warriorOverlayArmRequest is
//--- set by RankTiersFromOos() at pass-3 completion - the moment a member's era-end snapshot
//--- became fresher - which is the only event a redraw can act on.
bool wantArm = g_warriorOverlayArmRequest || (g_aiSignalCount == 0 && g_lastOverlayArmTick == 0);
//--- EVERY ENROLLED MEMBER FIRST. A member still mid-era has no snapshot, the sweep skips it
//--- before the divisor, and the remaining member's own tier weight becomes the whole vote - a
//--- consensus arrow drawn from one model. See g_warriorOverlayReadyMask.
uint enrolled = EnrolledOverlayMask();
bool everyoneReady = (enrolled == 0) || ((g_warriorOverlayReadyMask & enrolled) == enrolled);
if(wantArm && !everyoneReady)
{
if(g_warriorOverlayArmSince == 0)
g_warriorOverlayArmSince = GetTickCount();
//--- Bounded, so a member that stopped cannot freeze the chart. Drawing partial is allowed;
//--- drawing partial SILENTLY is not.
if(GetTickCount() - g_warriorOverlayArmSince >= OVERLAY_PARTIAL_ARM_MS)
{
PrintFormat("Warrior: filtered overlay drawing with a PARTIAL ensemble after %d s - members"
" ready 0x%X of 0x%X enrolled. The missing members have produced no era-end"
" snapshot, so they abstain from every bar in this sweep and the vote is"
" diluted toward the members that did finish. Expect fewer arrows than the live"
" vote would cast, not different ones.",
OVERLAY_PARTIAL_ARM_MS / 1000, g_warriorOverlayReadyMask, enrolled);
everyoneReady = true;
}
}
//--- Re-arm only between sweeps (mid-flight restart would strand the tail undrawn), and at most
//--- once a minute once everyone is in.
if(wantArm && everyoneReady && !Expert.FilteredOverlayPending()
&& (g_lastOverlayArmTick == 0 || GetTickCount() - g_lastOverlayArmTick >= OVERLAY_REARM_MIN_MS))
{
g_warriorOverlayArmRequest = false;
g_warriorOverlayReadyMask = 0;
g_warriorOverlayArmSince = 0;
g_lastOverlayArmTick = GetTickCount();
Expert.ArmFilteredOverlay();
}
Expert.AdvanceFilteredOverlay(OVERLAY_BARS_PER_SLICE);
}
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
void PollAltDataMapDialog(void)
{
if(!g_altMapDialogOpen || !g_altMapDialog.Done())
return;
string choice = g_altMapDialog.Result();
g_altDataFetch.SaveUserMapping(_Symbol, choice);
g_altMapDialog.Destroy(REASON_REMOVE);
g_altMapDialogOpen = false;
if(choice == "NONE")
{
Print("AltDataFetch: recorded 'no alternative data' for " + _Symbol + " - it will not ask "
"again. Remove that line from symbol_map.cfg to be asked at the next attach.");
return;
}
//--- Download now rather than waiting up to 30 minutes for the next upkeep tick.
g_lastAltDataRun = TimeCurrent();
if(g_altDataFetch.Update(_Symbol))
for(int i = 0; i < g_aiSignalCount; i++)
g_aiSignals[i].AltDataReload();
Print("AltDataFetch: alt data for " + _Symbol + " is being maintained now. A model that was "
"already created without these features keeps its pinned input width - re-attach the EA "
"to build models that actually train on them.");
}
void OnTimer()
{
//--- STOP FIRST. Nothing below this line matters to a program that is being unloaded: the training
//--- poll, the alt-data upkeep (blocking WebRequests) and the DB ranking pass are all work whose
//--- results are about to be discarded.
if(IsStopped())
return;
//--- Also here, not only in OnTick(): this chart's own symbol can go minutes without a quote while
//--- an open position on ANOTHER symbol moves account equity through the limit. Equity is
//--- account-wide, so the budget must be re-checked on the clock, not only on this symbol's ticks.
g_riskBudget.Update();
//--- keeps training progressing on wall-clock time even with no ticks at all (market closed) -
//--- OnTickHandler's own scheduling only ever runs when a tick actually arrives
for(int i = 0; i < g_aiSignalCount; i++)
g_aiSignals[i].PollTraining();
//--- FILTERED VIEW: keep the reconstructed history in step with the models. One slice per timer
//--- tick, same cadence and same reasoning as the chunked signal rescan above it.
AdvanceFilteredSignalOverlay();
//--- Keep the vote readout tracking the models at timer cadence - Direction() only runs on
//--- new-bar ticks (stock CExpert::Refresh gates it), which on H4 is once every four hours.
Expert.RefreshVoteReadout();
//--- Finish the Show Signals sequence once every instance queued by ToggleSignalsVisibility has
//--- drained its chunked rescan (each is advanced one slice per PollTraining call above).
FinalizeSignalsRescanIfDone();
//--- Training can finish and deploy ITSELF (the plateau ladder finalising the best checkpoint,
//--- or the era-cap deploy) with no button ever pressed, and RefreshControlPanelLabels()
//--- otherwise only runs in response to a click - which would leave the panel offering "Deploy
//--- Model" on an already-deployed model until the user happened to click something.
bool deployedNow = AllTrainingDeployed();
if(deployedNow != g_lastDeployedState)
{
g_lastDeployedState = deployedNow;
RefreshControlPanelLabels();
}
//--- Alt-data upkeep, before the UseDatabaseRanking early-return so it runs regardless of
//--- that input. First pass backfills any missing history (one blocking WebRequest per stale
//--- source, seconds); steady state is two date compares every 30 minutes.
if(!MQLInfoInteger(MQL_TESTER) && !MQLInfoInteger(MQL_OPTIMIZATION))
{
MaybeAskAltDataMapping();
datetime altNow = TimeCurrent();
if(g_lastAltDataRun == 0 || altNow - g_lastAltDataRun >= ALTDATA_CHECK_SECONDS)
{
g_lastAltDataRun = altNow;
if(g_altDataFetch.Update(_Symbol))
for(int i = 0; i < g_aiSignalCount; i++)
g_aiSignals[i].AltDataReload();
}
}
if(!UseDatabaseRanking)
return;
datetime now = TimeCurrent();
//--- One-shot bypass of the hourly throttle below (see g_forcePatternWeightsRefresh's declaration
//--- comment): a model that just finished its backfill has real DB history sitting unranked, and
//--- waiting up to an hour for it to reach UpdateSignalsWeights() is exactly the "not ready to trade
//--- the instant training finishes" gap this whole feature exists to close.
bool forceNow = g_forcePatternWeightsRefresh;
if(forceNow)
g_forcePatternWeightsRefresh = false;
if(!forceNow && g_lastDbRankingRun != 0 && now - g_lastDbRankingRun < DB_RANKING_INTERVAL_SECONDS)
return;
g_lastDbRankingRun = now;
Expert.OnTimer();
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void CheckAlgoTradingState(void)
{
bool allowed = (bool)TerminalInfoInteger(TERMINAL_TRADE_ALLOWED) && (bool)MQLInfoInteger(MQL_TRADE_ALLOWED);
if(allowed != g_lastAlgoTradingAllowed)
{
if(allowed)
Print(__FUNCTION__ + ": AlgoTrading re-enabled - order placement resumed (training/signals were unaffected while disabled)");
else
Print(__FUNCTION__ + ": AlgoTrading disabled (terminal toggle off, or EA's own permission revoked) - no new orders will be sent until re-enabled; training/signal generation continues unaffected");
g_lastAlgoTradingAllowed = allowed;
}
}
void AutosaveWeightsIfDue(void)
{
//--- NEVER autosave inside the Strategy Tester / optimizer. The whole reason this exists is that
//--- a live terminal can be killed without OnDeinit running - a tester run has no such exposure.
//--- A tester run is inference-only anyway (see m_inferenceOnly) - the weights never change, so
//--- there is literally nothing to persist.
if(MQLInfoInteger(MQL_TESTER) || MQLInfoInteger(MQL_OPTIMIZATION) || MQLInfoInteger(MQL_FORWARD))
return;
datetime lastBarDate = (datetime)SeriesInfoInteger(_Symbol, _Period, SERIES_LASTBAR_DATE);
//--- <=0 is a transient history-sync hiccup, not "no new bar" - skip this tick and try again on the
//--- next one rather than risk locking onto a bad watermark (same guard philosophy as
//--- ScheduleTrainingIfNeeded's own lastBarDate read).
if(lastBarDate <= 0 || lastBarDate == g_lastAutosaveBarTime)
return;
g_lastAutosaveBarTime = lastBarDate;
for(int i = 0; i < g_aiSignalCount; i++)
g_aiSignals[i].SaveWeightsNow();
}
void OnTick()
{
#ifdef WARRIOR_EXPORT_FEATURES
//--- RESEARCH BUILD: writes the feature matrix at init and does NOTHING else, ever. Returning here
//--- means Expert.OnTick() (the entire trading path) is never reached, independently of the
//--- AlgoTrading toggle, the signal state or the inputs.
return;
#endif
//--- STOP FIRST - same reasoning as OnTimer's guard. Deliberately AHEAD of the risk-budget update
//--- too: a program that is unloading places no orders, so there is nothing left for the budget to
//--- protect.
if(IsStopped())
return;
CheckAlgoTradingState();
//--- FIRST, and before Expert.OnTick() can open anything.
g_riskBudget.Update();
AutosaveWeightsIfDue();
Expert.OnTick();
//--- Unconditional since 2026-08-11: Update() feeds the expectancy stop from every closed trade
//--- and only touches the journal DB when one was initialized (UseDatabaseRanking).
journal.Update();
//--- new arrows are always created visible; if signals are currently hidden, re-hide
//--- any that were drawn this tick (cheap - only runs while the toggle is in the "hidden" state)
if(!g_signalsVisible)
ApplySignalsVisibility();
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
const long &lparam,
const double &dparam,
const string &sparam)
{
//--- STOP FIRST, and this handler matters more than the other two: training is driven by a CUSTOM
//--- CHART EVENT (see CExpertSignalAIBase::OnChartEventHandler -> TuneIndicatorsAndTrain), so an
//--- event already queued when the stop request lands would start a full era-0 warm-up - the MI
//--- suite, the geometry scan, a relabel - inside the teardown window.
if(IsStopped())
return;
//--- canonical CAppDialog usage (Controls\Dialog.mqh): forward every event to the dialog first, since
//--- that's what drives its own click/drag hit-testing (via CHARTEVENT_MOUSE_MOVE) as well as our
//--- buttons' EVENT_MAP handlers (see ControlPanel.mqh) - then pick up whatever button action, if any,
//--- that just recorded.
ExtPanel.ChartEvent(id, lparam, dparam, sparam);
HandleControlPanelAction(ExtPanel.ConsumeAction());
//--- The alt-data mapping dialog, when open, drives its own hit-testing the same way.
if(g_altMapDialogOpen)
{
g_altMapDialog.ChartEvent(id, lparam, dparam, sparam);
PollAltDataMapDialog();
}
Expert.OnChartEvent(id, lparam, dparam, sparam);
//--- CHARTEVENT_CHART_CHANGE covers resize, scroll and DPI/zoom changes - anything that can
//--- move the visible area out from under a dialog left near an edge from a previous drag.
if(id == CHARTEVENT_CHART_CHANGE)
ClampControlPanelToChart();
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool AddFilterToSignal(CExpertSignalCustom * signal, CExpertSignalCustom * filter)
{
if(filter == NULL)
{
Print(__FUNCTION__ + "Error creating filters");
return false;
}
return signal.AddFilter(filter);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool InitializeSignal(CExpertSignalCustom * signal_obj)
{
if(signal_obj == NULL)
{
Print(__FUNCTION__ + ": error creating signal");
return false;
}
Expert.InitSignal(signal_obj);
signal_obj.Entry_Multiplier(Entry_Multiplier);
signal_obj.Expiration(Signal_Expiration);
//--- ATR unit lookback, pinned - decoupled from the derived input window, see Inputs.mqh.
signal_obj.Periods(ATR_FEATURE_PERIOD);
signal_obj.SLMode((int)SL_Mode);
signal_obj.TPMode((int)TP_Mode);
signal_obj.ConfidenceSource((int)Confidence_Source);
//--- Gates AddFilter()'s DB pattern-table creation and Direction()'s per-tick DB signal buffering
//--- (ExpertSignalCustom.mqh:286/555) - without this, UseDatabaseRanking only skipped the Weight(1)
//--- default below and never actually populated the win-rate tables UpdateSignalsWeights() reads from.
signal_obj.UseDatabase(UseDatabaseRanking);
//--- Pattern-table row cap; raised via the input for meta-label corpus builds (design doc S1).
signal_obj.MaxTableRows(DB_MaxRowsPerTable);
//--- Same two inputs feed BOTH engines, and now on ONE scale each. Close drives the rule-based
//--- exit, and
//--- ONLY that: an AI-certified position holds to its barrier. See Signal_ThresholdOpen's
//--- declaration comment (Variables\Inputs.mqh) for the shared 0-100 conviction scale, and for
//--- why open and close must stay independent of each other.
signal_obj.ThresholdOpen((int)Signal_ThresholdOpen);
signal_obj.ThresholdClose((int)Signal_ThresholdClose);
//--- The hold-to-barrier exit policy went with the fractal target (withdrawn - see Inputs.mqh).
//--- Barrier-target models keep the vote exits and always did: their label IS the vote's own
//--- horizon.
//--- HYBRID is now one fused signal, so no separate AI quorum is needed here.
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
// Initialize Trailing
bool InitializeTrailing()
{
if(TrailingStrategy == TRAILING_STRATEGY_NONE)
{
// No trailing strategy selected
return true;
}
else
if(TrailingStrategy == TRAILING_STRATEGY_ATR_x1 ||
TrailingStrategy == TRAILING_STRATEGY_ATR_x2 ||
TrailingStrategy == TRAILING_STRATEGY_ATR_x3)
{
// ATR Trailing Strategy
double multiplier = 0;
if(TrailingStrategy == TRAILING_STRATEGY_ATR_x1)
multiplier = 1;
else
if(TrailingStrategy == TRAILING_STRATEGY_ATR_x2)
multiplier = 2;
else
if(TrailingStrategy == TRAILING_STRATEGY_ATR_x3)
multiplier = 3;
CTrailingATR *trailing = new CTrailingATR;
if(trailing == NULL)
{
Print(__FUNCTION__ + ": error creating trailing");
return false;
}
// Set ATR Multiplier
trailing.Multiplier(multiplier);
if(!Expert.InitTrailing(trailing))
{
Print(__FUNCTION__ + ": error initializing trailing");
return false;
}
}
else
if(TrailingStrategy == TRAILING_STRATEGY_INTELLIGENT)
{
// Confidence-adaptive ATR trailing (see Trailing\TrailingIntelligent.mqh) - the ATR
// multiple is set per-check from live AI confidence, so no fixed Multiplier() here.
CTrailingIntelligent *trailing = new CTrailingIntelligent;
if(trailing == NULL)
{
Print(__FUNCTION__ + ": error creating intelligent trailing");
return false;
}
if(!Expert.InitTrailing(trailing))
{
Print(__FUNCTION__ + ": error initializing intelligent trailing");
return false;
}
}
// Add more trailing strategies if needed
return true;
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
bool InitializeMoneyManagement()
{
string functionName = __FUNCTION__;
if(MM_STRATEGY == FIXED_RISK)
{
CMoneyFixedRisk *money = new CMoneyFixedRisk;
if(money == NULL)
{
Print(functionName + ": error creating money");
return false;
}
if(!Expert.InitMoney(money))
{
Print(functionName + ": error initializing money");
return false;
}
money.Percent(Money_Risk_Percent);
}
else
if(MM_STRATEGY == FIXED_LOT)
{
CMoneyFixedLot *money = new CMoneyFixedLot;
if(money == NULL)
{
Print(functionName + ": error creating money");
return false;
}
if(!Expert.InitMoney(money))
{
Print(functionName + ": error initializing money");
return false;
}
money.Lots(Money_FixLot_Lots);
}
else
if(MM_STRATEGY == INTELLIGENT)
{
CMoneyIntelligent *money = new CMoneyIntelligent;
if(money == NULL)
{
Print(functionName + ": error creating money");
return false;
}
if(!Expert.InitMoney(money))
{
Print(functionName + ": error initializing money");
return false;
}
money.Percent(Money_Risk_Percent);
//--- Intelligent MM is AI-driven by definition now (the old Use_AI_Lot_Sizing toggle was
//--- removed as redundant) - always scale risk% by confidence via the Kelly path.
money.UseAIConfidenceLotSizing(true);
money.ConfidenceSource((int)Confidence_Source);
}
// Add more money management strategies if needed
return true;
}
//+------------------------------------------------------------------+
View git blame Copy permalink