forked from chiki2bum2/SniperGold_ML
563 lines
21 KiB
MQL5
563 lines
21 KiB
MQL5
 | //+------------------------------------------------------------------+
| ||
//| AF_Engine2_Setup.mqh |
| |||
//| Project : Algo Forge (refactor total) |
| |||
//| Sumber inspirasi: SniperGold SMC Pro+ (c) Waseem Shahrukh |
| |||
//| https://www.mql5.com/en/code/75466 |
| |||
//+------------------------------------------------------------------+
| |||
//| ENGINE 2 - F3 CANDIDATE SETUP LAYER (P3-S.13) |
| |||
//| |
| |||
//| TUJUAN: materialisasi entitas Candidate Setup (frozen contract |
| |||
//| docs/SNIPERGOLD_CANONICAL_SETUP_CONTRACT_v1.md): satu setup = |
| |||
//| satu identitas = satu lifecycle. LAYER INI TIDAK MENGHITUNG |
| |||
//| primitif sendiri; ia MENGONSUMSI input SEMANTIK per bar: |
| |||
//| F1 events : sweep/CHoCH {onset, dir} (P3-S.11) |
| |||
//| F2 zones : OB/FVG {type, formation, dir, mit, invalidated} |
| |||
//| (P3-S.12) |
| |||
//| H4/M30 : context STATE (as-of closed bar) |
| |||
//| M15 : entry CONDITION (direction-compatible) |
| |||
//| M3 : OPTIONAL micro-confirmation (no veto) |
| |||
//| dan MENGHASILKAN: AFCandidateSetup (setup_id, direction, state, |
| |||
//| referensi sweep/choch/zone, creation, M3, reason). |
| |||
//| |
| |||
//| KANONIK (frozen): |
| |||
//| H4 gate -> M30 gate -> fresh sweep EVENT -> CHoCH EVENT after |
| |||
//| sweep -> unmitigated OB|FVG ZONE -> M15 entry condition -> |
| |||
//| CANDIDATE_SETUP -> [optional M3 confirmation]. |
| |||
//| |
| |||
//| Lifecycle: NONE -> CONTEXT_VALID -> LIQUIDITY_TRIGGERED -> |
| |||
//| STRUCTURE_CONFIRMED -> ZONE_READY -> ENTRY_ARMED -> |
| |||
//| CANDIDATE_SETUP -> [M3_CONFIRMED] -> EXPIRED | INVALIDATED | |
| |||
//| CONSUMED. Tidak ada skip state; tidak ada reaktivasi; maksimum |
| |||
//| satu entry per setup (frozen §H). |
| |||
//| |
| |||
//| IDENTITAS (frozen §E): setup_id monotonic; uniqueness = (dir, |
| |||
//| sweep onset, choch onset, zone formation, creation). Satu rantai|
| |||
//| kausal = satu setup_id (dedup by registry, §G). |
| |||
//| |
| |||
//| SCORE SEPARATION (frozen §I): score TIDAK pernah menciptakan |
| |||
//| setup. Layer ini mengekspos setup_exists/setup_id/state; |
| |||
//| scoring boleh melekat setelahnya. |
| |||
//| |
| |||
//| W_setup / W_m3 = OPEN NUMERIC PARAMETERS; nilai di AF_Defines |
| |||
//| adalah PLACEHOLDER TEST BOUNDARY (bukan hasil optimasi). |
| |||
//| |
| |||
//| BAR SEMANTICS (parity with the F3 spec oracle): decisionBar dan |
| |||
//| event onsets adalah index bar MONOTONIK (bertambah seiring |
| |||
//| waktu, 0 = bar tertua). Konsumen Engine-1 (reversed index, |
| |||
//| 0 = bar tertutup terbaru) harus mengonversi: |
| |||
//| mono = totalClosed - 1 - reversed |
| |||
//| untuk memberi makan layer ini. |
| |||
//+------------------------------------------------------------------+
| |||
#ifndef AF_ENGINE2_SETUP_MQH
| |||
#define AF_ENGINE2_SETUP_MQH
| |||
| |||
#include "AF_Engine2_Agents.mqh"
| |||
| |||
//------------------------------------------------------------------
| |||
// Lifecycle state (frozen §F)
| |||
//------------------------------------------------------------------
| |||
enum AFSetupState
| |||
{
| |||
AF_SETUP_NONE = 0,
| |||
AF_SETUP_CONTEXT_VALID = 1,
| |||
AF_SETUP_LIQUIDITY_TRIGGERED= 2,
| |||
AF_SETUP_STRUCTURE_CONFIRMED= 3,
| |||
AF_SETUP_ZONE_READY = 4,
| |||
AF_SETUP_ENTRY_ARMED = 5,
| |||
AF_SETUP_CANDIDATE = 6, // CANDIDATE_SETUP (terminal formation)
| |||
AF_SETUP_M3_CONFIRMED = 7, // optional micro-confirmed
| |||
AF_SETUP_EXPIRED = 8, // terminal
| |||
AF_SETUP_INVALIDATED = 9, // terminal
| |||
AF_SETUP_CONSUMED = 10 // terminal (one entry emitted)
| |||
};
| |||
| |||
enum AFSetupZoneType
| |||
{
| |||
AF_SETUP_ZONE_NONE = 0,
| |||
AF_SETUP_ZONE_OB = 1,
| |||
AF_SETUP_ZONE_FVG = 2
| |||
};
| |||
| |||
//------------------------------------------------------------------
| |||
// Event input (F1 contract, P3-S.11) — monotonic onset
| |||
//------------------------------------------------------------------
| |||
struct AFSetupEvent
| |||
{
| |||
int onset; // M15 bar index (monotonic) of onset; -1 = none
| |||
int dir; // +1 / -1 / 0
| |||
};
| |||
| |||
//------------------------------------------------------------------
| |||
// Zone input (F2 contract, P3-S.12) — semantic projection of AFZoneState
| |||
//------------------------------------------------------------------
| |||
struct AFSetupZone
| |||
{
| |||
int type; // AF_SETUP_ZONE_OB / AF_SETUP_ZONE_FVG / NONE
| |||
int formation; // formation bar (monotonic); -1 = none
| |||
int dir; // +1 / -1 / 0
| |||
AFZoneMitState mit; // F2 mit_state
| |||
bool invalidated; // F2 terminal flag
| |||
bool IsActive() const
| |||
{
| |||
return (mit==AF_ZONE_UNMITIGATED || mit==AF_ZONE_PARTIALLY_FILLED)
| |||
&& !invalidated;
| |||
}
| |||
};
| |||
| |||
//------------------------------------------------------------------
| |||
// Semantic inputs for ONE decision bar (what the F3 layer consumes)
| |||
//------------------------------------------------------------------
| |||
struct AFSetupInputs
| |||
{
| |||
int h4; // H4 context STATE direction (+1/-1/0)
| |||
int m30; // M30 context STATE direction (+1/-1/0)
| |||
AFSetupEvent sweep; // sweep EVENT (onset + dir)
| |||
AFSetupEvent choch; // CHoCH EVENT (onset + dir)
| |||
AFSetupZone zone; // unmitigated OB|FVG ZONE
| |||
int m15; // M15 entry CONDITION direction (+1/-1/0)
| |||
int m3; // M3 micro-confirmation (+1/-1/0; 0 = absent)
| |||
bool entry; // entry signal bound to the valid setup this bar
| |||
double score; // informational (NEVER creates a setup, §I)
| |||
};
| |||
| |||
//------------------------------------------------------------------
| |||
// Candidate Setup entity (frozen §E)
| |||
//------------------------------------------------------------------
| |||
struct AFCandidateSetup
| |||
{
| |||
int setup_id; // monotonic, assigned at CANDIDATE_SETUP
| |||
int direction; // +1 bullish / -1 bearish
| |||
AFSetupState state; // lifecycle
| |||
// originating liquidity (sweep)
| |||
int sweep_onset;
| |||
int sweep_dir;
| |||
// structure event (choch)
| |||
int choch_onset;
| |||
int choch_dir;
| |||
// zone
| |||
AFSetupZoneType zone_type;
| |||
int zone_formation;
| |||
double zone_top;
| |||
double zone_bot;
| |||
int zone_dir;
| |||
AFZoneMitState zone_mit_at_creation;
| |||
// entry timeframe = M15 (fixed by construction)
| |||
int creation_bar;
| |||
// optional M3 confirmation
| |||
int m3_bar; // -1 = none
| |||
// provenance / lifecycle reason
| |||
string reason;
| |||
// one-entry bookkeeping (frozen §H)
| |||
bool entry_bound;
| |||
};
| |||
| |||
//------------------------------------------------------------------
| |||
// Per-bar outcome (what consumers read)
| |||
//------------------------------------------------------------------
| |||
struct AFSetupOutcome
| |||
{
| |||
int bar;
| |||
bool setup_exists; // CANDIDATE_SETUP / M3_CONFIRMED
| |||
int setup_id;
| |||
AFSetupState state;
| |||
int dir;
| |||
bool blocked; // gate-fail (OD-4)
| |||
string block_reason;
| |||
bool m3_confirmed;
| |||
bool entry_bound;
| |||
double score;
| |||
AFCandidateSetup entity; // full entity (valid when setup_exists)
| |||
};
| |||
| |||
//------------------------------------------------------------------
| |||
// F3 setup engine — STATEFUL runtime (frozen §F/§G/§H).
| |||
// Engine-2 detectors are stateless per-bar (P3-S.7 S-ST), but a
| |||
// Candidate Setup is by definition an ENTITY with identity + lifecycle
| |||
// that persists across bars (contract §A/§E/§F). This engine holds the
| |||
// cross-bar state: the current forming/formed setup, the identity
| |||
// registry (dedup), and the one-entry bookkeeping. It is driven once
| |||
// per CLOSED M15 bar with semantic inputs (consumed, never recomputed).
| |||
// The algorithm is a faithful port of the F3 spec oracle
| |||
// (spec_tests_candidate_setup_runtime.py, canonical_oracle).
| |||
//------------------------------------------------------------------
| |||
class AFSetupEngine
| |||
{
| |||
private:
| |||
AFCandidateSetup m_current; // forming/formed setup (id==0 = none)
| |||
AFCandidateSetup m_registry[]; // identity registry (dedup by chain key)
| |||
int m_nextId;
| |||
int m_entryBindings;
| |||
// windows (AF_Defines placeholders)
| |||
int m_wSweep;
| |||
int m_wChoch;
| |||
int m_wSetup;
| |||
int m_wM3;
| |||
| |||
void ResetEntity(AFCandidateSetup &s) const;
| |||
bool SameChainKey(const AFCandidateSetup &a,const AFCandidateSetup &b) const;
| |||
int RegistryHas(const AFCandidateSetup &s) const; // -1 = none
| |||
bool EventActive(const AFSetupEvent &ev,int r,int w) const;
| |||
void StartChain(const AFSetupInputs &inp); // NONE -> CONTEXT_VALID
| |||
void Advance(int r,const AFSetupInputs &inp); // forming stages
| |||
void PostFormation(int r,const AFSetupInputs &inp); // terminal/M3
| |||
| |||
public:
| |||
AFSetupEngine()
| |||
{
| |||
m_wSweep=40; // W_sweep (frozen §M)
| |||
m_wChoch=40; // W_choch (frozen §M)
| |||
m_wSetup=AF_F3_W_SETUP; // placeholder test boundary
| |||
m_wM3=AF_F3_W_M3; // placeholder test boundary
| |||
Reset();
| |||
}
| |||
void Reset()
| |||
{
| |||
m_nextId=1;
| |||
m_entryBindings=0;
| |||
ResetEntity(m_current);
| |||
ArrayResize(m_registry,0);
| |||
}
| |||
void SetWindows(int wSweep,int wChoch,int wSetup,int wM3)
| |||
{
| |||
m_wSweep=wSweep; m_wChoch=wChoch; m_wSetup=wSetup; m_wM3=wM3;
| |||
}
| |||
| |||
// Advance the runtime by ONE closed M15 decision bar.
| |||
// decisionBar : monotonic M15 bar index (see header bar semantics).
| |||
// inp : semantic inputs (consumed; not computed here).
| |||
// out : per-bar outcome (exposed to consumers/scoring).
| |||
void Step(int decisionBar,const AFSetupInputs &inp,AFSetupOutcome &out);
| |||
| |||
// diagnostics
| |||
int CreatedCount() const { return m_nextId-1; }
| |||
int EntryBindings() const { return m_entryBindings; }
| |||
};
| |||
| |||
//------------------------------------------------------------------
| |||
// Implementasi
| |||
//------------------------------------------------------------------
| |||
void AFSetupEngine::ResetEntity(AFCandidateSetup &s) const
| |||
{
| |||
s.setup_id=0;
| |||
s.direction=0;
| |||
s.state=AF_SETUP_NONE;
| |||
s.sweep_onset=-1; s.sweep_dir=0;
| |||
s.choch_onset=-1; s.choch_dir=0;
| |||
s.zone_type=AF_SETUP_ZONE_NONE; s.zone_formation=-1;
| |||
s.zone_top=0.0; s.zone_bot=0.0; s.zone_dir=0;
| |||
s.zone_mit_at_creation=AF_ZONE_UNMITIGATED;
| |||
s.creation_bar=-1;
| |||
s.m3_bar=-1;
| |||
s.reason="";
| |||
s.entry_bound=false;
| |||
}
| |||
| |||
bool AFSetupEngine::SameChainKey(const AFCandidateSetup &a,
| |||
const AFCandidateSetup &b) const
| |||
{
| |||
return (a.direction==b.direction
| |||
&& a.sweep_onset==b.sweep_onset
| |||
&& a.choch_onset==b.choch_onset
| |||
&& a.zone_formation==b.zone_formation);
| |||
}
| |||
| |||
int AFSetupEngine::RegistryHas(const AFCandidateSetup &s) const
| |||
{
| |||
for(int i=0;i<ArraySize(m_registry);i++)
| |||
if(m_registry[i].setup_id>0 && SameChainKey(m_registry[i],s))
| |||
return i;
| |||
return -1;
| |||
}
| |||
| |||
bool AFSetupEngine::EventActive(const AFSetupEvent &ev,int r,int w) const
| |||
{
| |||
if(ev.onset<0) return false;
| |||
return (ev.onset<=r && (r-ev.onset)<=w);
| |||
}
| |||
| |||
// NONE -> CONTEXT_VALID (H4+M30 direction-compatible, non-zero; OD-1)
| |||
void AFSetupEngine::StartChain(const AFSetupInputs &inp)
| |||
{
| |||
if(inp.h4==0 || inp.m30==0) return;
| |||
if(inp.h4!=inp.m30) return; // H4<->M30 conflict -> BLOCKED
| |||
ResetEntity(m_current);
| |||
m_current.direction=inp.h4;
| |||
m_current.state=AF_SETUP_CONTEXT_VALID;
| |||
m_current.reason="context valid";
| |||
}
| |||
| |||
// forming stage transitions (strict order; no skipping; lapsed stage
| |||
// discards the forming setup, frozen §F)
| |||
void AFSetupEngine::Advance(int r,const AFSetupInputs &inp)
| |||
{
| |||
if(m_current.setup_id>0) return; // already CANDIDATE/terminal
| |||
if(m_current.state==AF_SETUP_NONE) return;
| |||
int D=m_current.direction;
| |||
| |||
// ---- re-validate context gates at every decision bar (OD-1) ----
| |||
if(inp.h4!=D || inp.m30!=D)
| |||
{
| |||
ResetEntity(m_current);
| |||
m_current.reason="context break";
| |||
return;
| |||
}
| |||
| |||
// ---- re-validate ESTABLISHED legs at every decision bar (§F: a
| |||
// lapsed stage before CANDIDATE_SETUP discards the forming
| |||
// setup; e.g. a stale sweep at ZONE_READY -> no setup) ----
| |||
if(m_current.sweep_onset>=0)
| |||
{
| |||
if(inp.sweep.dir!=D || inp.sweep.onset!=m_current.sweep_onset ||
| |||
!EventActive(inp.sweep,r,m_wSweep))
| |||
{
| |||
ResetEntity(m_current);
| |||
m_current.reason="sweep lapsed";
| |||
return;
| |||
}
| |||
}
| |||
if(m_current.choch_onset>=0)
| |||
{
| |||
if(inp.choch.dir!=D || inp.choch.onset!=m_current.choch_onset ||
| |||
!EventActive(inp.choch,r,m_wChoch))
| |||
{
| |||
ResetEntity(m_current);
| |||
m_current.reason="choch lapsed";
| |||
return;
| |||
}
| |||
}
| |||
if(m_current.zone_formation>=0)
| |||
{
| |||
if(inp.zone.dir!=D || inp.zone.formation!=m_current.zone_formation ||
| |||
!inp.zone.IsActive())
| |||
{
| |||
ResetEntity(m_current);
| |||
m_current.reason="zone lapsed";
| |||
return;
| |||
}
| |||
}
| |||
| |||
// ---- CONTEXT_VALID -> LIQUIDITY_TRIGGERED (fresh sweep EVENT) ----
| |||
if(m_current.state==AF_SETUP_CONTEXT_VALID ||
| |||
m_current.state==AF_SETUP_LIQUIDITY_TRIGGERED)
| |||
{
| |||
bool sweepPresent=(inp.sweep.dir!=0 && inp.sweep.onset>=0);
| |||
if(!sweepPresent) { m_current.reason="waiting sweep"; return; }
| |||
if(inp.sweep.dir!=D)
| |||
{ ResetEntity(m_current); m_current.reason="sweep dir mismatch"; return; }
| |||
if(!EventActive(inp.sweep,r,m_wSweep))
| |||
{ ResetEntity(m_current); m_current.reason="stale sweep"; return; }
| |||
m_current.sweep_onset=inp.sweep.onset;
| |||
m_current.sweep_dir=inp.sweep.dir;
| |||
m_current.state=AF_SETUP_LIQUIDITY_TRIGGERED;
| |||
}
| |||
| |||
// ---- LIQUIDITY_TRIGGERED -> STRUCTURE_CONFIRMED (CHoCH after sweep) ----
| |||
if(m_current.state==AF_SETUP_LIQUIDITY_TRIGGERED ||
| |||
m_current.state==AF_SETUP_STRUCTURE_CONFIRMED)
| |||
{
| |||
bool chochPresent=(inp.choch.dir!=0 && inp.choch.onset>=0);
| |||
if(!chochPresent) { m_current.reason="waiting choch"; return; }
| |||
if(inp.choch.dir!=D)
| |||
{ ResetEntity(m_current); m_current.reason="choch dir mismatch"; return; }
| |||
// causal order: CHoCH AFTER sweep (monotonic onset)
| |||
if(inp.choch.onset < m_current.sweep_onset)
| |||
{ ResetEntity(m_current); m_current.reason="choch before sweep"; return; }
| |||
// chain bound: CHoCH within the sweep validity chain
| |||
if((inp.choch.onset-m_current.sweep_onset)>m_wSweep)
| |||
{ ResetEntity(m_current); m_current.reason="choch outside sweep window"; return; }
| |||
// freshness: CHoCH active at the decision bar
| |||
if(!EventActive(inp.choch,r,m_wChoch))
| |||
{ ResetEntity(m_current); m_current.reason="stale choch"; return; }
| |||
m_current.choch_onset=inp.choch.onset;
| |||
m_current.choch_dir=inp.choch.dir;
| |||
m_current.state=AF_SETUP_STRUCTURE_CONFIRMED;
| |||
}
| |||
| |||
// ---- STRUCTURE_CONFIRMED -> ZONE_READY (unmitigated OB|FVG) ----
| |||
if(m_current.state==AF_SETUP_STRUCTURE_CONFIRMED ||
| |||
m_current.state==AF_SETUP_ZONE_READY)
| |||
{
| |||
if(inp.zone.dir==0 || inp.zone.formation<0)
| |||
{ m_current.reason="waiting zone"; return; }
| |||
if(inp.zone.dir!=D)
| |||
{ ResetEntity(m_current); m_current.reason="zone dir mismatch"; return; }
| |||
if(!inp.zone.IsActive())
| |||
{ ResetEntity(m_current); m_current.reason="zone mitigated/invalidated"; return; }
| |||
m_current.zone_type=(AFSetupZoneType)inp.zone.type;
| |||
m_current.zone_formation=inp.zone.formation;
| |||
m_current.zone_top=0.0;
| |||
m_current.zone_bot=0.0;
| |||
m_current.zone_dir=inp.zone.dir;
| |||
m_current.zone_mit_at_creation=inp.zone.mit;
| |||
m_current.state=AF_SETUP_ZONE_READY;
| |||
}
| |||
| |||
// ---- ZONE_READY -> ENTRY_ARMED (M15 entry condition) ----
| |||
if(m_current.state==AF_SETUP_ZONE_READY ||
| |||
m_current.state==AF_SETUP_ENTRY_ARMED)
| |||
{
| |||
if(inp.m15==0) { m_current.reason="waiting m15 entry"; return; }
| |||
if(inp.m15!=D)
| |||
{ ResetEntity(m_current); m_current.reason="M15 conflict -> BLOCKED"; return; }
| |||
m_current.state=AF_SETUP_ENTRY_ARMED;
| |||
}
| |||
| |||
// ---- ENTRY_ARMED -> CANDIDATE_SETUP (chain complete; identity) ----
| |||
if(m_current.state==AF_SETUP_ENTRY_ARMED)
| |||
{
| |||
// dedup by construction (§G): same chain key -> no duplicate setup
| |||
if(RegistryHas(m_current)>=0)
| |||
{
| |||
ResetEntity(m_current);
| |||
m_current.reason="duplicate chain (dedup)";
| |||
return;
| |||
}
| |||
m_current.setup_id=m_nextId;
| |||
m_nextId++;
| |||
m_current.creation_bar=r;
| |||
m_current.state=AF_SETUP_CANDIDATE;
| |||
m_current.reason="candidate setup";
| |||
int n=ArraySize(m_registry);
| |||
ArrayResize(m_registry,n+1);
| |||
m_registry[n]=m_current;
| |||
}
| |||
}
| |||
| |||
// post-formation: optional M3 / expiry / invalidation / consumption
| |||
void AFSetupEngine::PostFormation(int r,const AFSetupInputs &inp)
| |||
{
| |||
if(m_current.setup_id<=0) return;
| |||
int D=m_current.direction;
| |||
int cb=m_current.creation_bar;
| |||
| |||
// one entry per setup (§H) — checked FIRST so consumption wins
| |||
if(inp.entry && !m_current.entry_bound)
| |||
{
| |||
m_current.entry_bound=true;
| |||
m_entryBindings++;
| |||
m_current.state=AF_SETUP_CONSUMED;
| |||
m_current.reason="consumed by entry";
| |||
return;
| |||
}
| |||
// zone mitigated after formation -> INVALIDATED (§F)
| |||
if(inp.zone.dir!=0 && !inp.zone.IsActive())
| |||
{
| |||
m_current.state=AF_SETUP_INVALIDATED;
| |||
m_current.reason="zone mitigated";
| |||
return;
| |||
}
| |||
// contrary CHoCH after formation -> INVALIDATED (§F)
| |||
if(inp.choch.dir==-D)
| |||
{
| |||
m_current.state=AF_SETUP_INVALIDATED;
| |||
m_current.reason="contrary choch";
| |||
return;
| |||
}
| |||
// context break after formation -> INVALIDATED (§F canonical)
| |||
if(inp.h4==-D || inp.m30==-D)
| |||
{
| |||
m_current.state=AF_SETUP_INVALIDATED;
| |||
m_current.reason="context break";
| |||
return;
| |||
}
| |||
// setup validity exceeded -> EXPIRED (§M W_setup)
| |||
if(cb>=0 && (r-cb)>m_wSetup)
| |||
{
| |||
m_current.state=AF_SETUP_EXPIRED;
| |||
m_current.reason="setup expired";
| |||
return;
| |||
}
| |||
// optional M3 confirmation (no veto, OD-4)
| |||
if(m_current.state==AF_SETUP_CANDIDATE)
| |||
{
| |||
if(inp.m3==D && (r-cb)<=m_wM3)
| |||
{
| |||
m_current.state=AF_SETUP_M3_CONFIRMED;
| |||
m_current.m3_bar=r;
| |||
m_current.reason="m3 confirmed";
| |||
}
| |||
else if(inp.m3==-D)
| |||
{
| |||
m_current.reason="m3 contrary (not confirmed)";
| |||
}
| |||
}
| |||
}
| |||
| |||
void AFSetupEngine::Step(int decisionBar,const AFSetupInputs &inp,
| |||
AFSetupOutcome &out)
| |||
{
| |||
out.bar=decisionBar;
| |||
out.score=inp.score;
| |||
out.blocked=false;
| |||
out.block_reason="";
| |||
| |||
// ---- gates (OD-1/OD-4): conflict -> BLOCKED ----
| |||
bool contextConflict=(inp.h4!=0 && inp.m30!=0 && inp.h4!=inp.m30);
| |||
bool chainConflict=false;
| |||
int D=0;
| |||
if(inp.sweep.dir!=0) D=inp.sweep.dir;
| |||
else if(inp.choch.dir!=0) D=inp.choch.dir;
| |||
else if(inp.zone.dir!=0) D=inp.zone.dir;
| |||
if(D!=0 && inp.m15!=0 && inp.m15!=D) chainConflict=true;
| |||
bool blocked=contextConflict || chainConflict;
| |||
if(blocked)
| |||
{
| |||
out.blocked=true;
| |||
out.block_reason=contextConflict? "H4_M30_CONFLICT" : "M15_CONFLICT";
| |||
}
| |||
| |||
// ---- forming / active handling (only when not blocked) ----
| |||
if(!blocked)
| |||
{
| |||
if(m_current.setup_id==0)
| |||
{
| |||
// no active setup: start a new chain if gates permit (OD-1)
| |||
StartChain(inp);
| |||
Advance(decisionBar,inp);
| |||
}
| |||
else if(m_current.state==AF_SETUP_CONSUMED ||
| |||
m_current.state==AF_SETUP_EXPIRED ||
| |||
m_current.state==AF_SETUP_INVALIDATED)
| |||
{
| |||
// terminal slot: free; a NEW chain may start on a later bar
| |||
ResetEntity(m_current);
| |||
StartChain(inp);
| |||
Advance(decisionBar,inp);
| |||
}
| |||
else
| |||
{
| |||
Advance(decisionBar,inp);
| |||
}
| |||
}
| |||
| |||
// ---- post-formation ALWAYS for an active setup (even if this bar
| |||
// is gate-blocked — context break invalidation still applies) ----
| |||
if(m_current.setup_id>0 &&
| |||
(m_current.state==AF_SETUP_CANDIDATE ||
| |||
m_current.state==AF_SETUP_M3_CONFIRMED))
| |||
{
| |||
PostFormation(decisionBar,inp);
| |||
}
| |||
| |||
// ---- expose outcome ----
| |||
out.dir=m_current.direction;
| |||
out.state=m_current.state;
| |||
out.setup_id=m_current.setup_id;
| |||
out.setup_exists=(m_current.setup_id>0 &&
| |||
(m_current.state==AF_SETUP_CANDIDATE ||
| |||
m_current.state==AF_SETUP_M3_CONFIRMED));
| |||
out.m3_confirmed=(m_current.state==AF_SETUP_M3_CONFIRMED);
| |||
out.entry_bound=m_current.entry_bound;
| |||
out.entity=m_current;
| |||
| |||
// ---- terminal -> slot free; a NEW chain may start next bar ----
| |||
if(m_current.setup_id>0 &&
| |||
(m_current.state==AF_SETUP_CONSUMED ||
| |||
m_current.state==AF_SETUP_EXPIRED ||
| |||
m_current.state==AF_SETUP_INVALIDATED))
| |||
{
| |||
ResetEntity(m_current);
| |||
}
| |||
}
| |||
| |||
#endif // AF_ENGINE2_SETUP_MQH
|