update

Strategy/EntryLogic_nnfx.mqh

@@ -0,0 +1,111 @@
+
+class EntryState {
+public:
+  int last_trigger_bar_long;
+  int last_trigger_bar_short;
+  int last_bl_cross_long;
+  int last_bl_cross_short;
+  int last_entry_long;
+  int last_entry_short;
+
+  // Constructor
+  EntryState() {
+    reset();
+  }
+
+  void reset() {
+    last_trigger_bar_long  = -1000;
+    last_trigger_bar_short = -1000;
+    last_bl_cross_long     = -1000;
+    last_bl_cross_short    = -1000;
+    last_entry_long        = -1000;
+    last_entry_short       = -1000;
+  }
+
+  void update_trigger(bool trig_long, bool trig_short, int curr_bar) {
+    if (trig_long)  last_trigger_bar_long = curr_bar;
+    if (trig_short) last_trigger_bar_short = curr_bar;
+  }
+
+  void update_baseline_cross(int curr_bar, double price, double baseline, double prev_price, double prev_baseline) {
+    if (prev_price < prev_baseline && price > baseline)
+      last_bl_cross_long = curr_bar;
+    if (prev_price > prev_baseline && price < baseline)
+      last_bl_cross_short = curr_bar;
+  }
+
+  void update_entry(bool is_long, int curr_bar) {
+    if (is_long)
+      last_entry_long = curr_bar;
+    else
+      last_entry_short = curr_bar;
+  }
+
+  int get_last_trigger(bool is_long) {
+    return is_long ? last_trigger_bar_long : last_trigger_bar_short;
+  }
+
+  int get_last_cross(bool is_long) {
+    return is_long ? last_bl_cross_long : last_bl_cross_short;
+  }
+
+  int get_last_entry(bool is_long) {
+    return is_long ? last_entry_long : last_entry_short;
+  }
+};
+
+// Snapshot of conditions for a potential entry signal
+struct EntryContext {
+  bool trigger;
+  bool confirm;
+  bool volume;
+  bool recent;
+  bool base_ok;
+  bool near;
+  bool far;
+  int last_entry;
+  int last_cross;
+};
+
+// Utility: check if signal occurred recently
+bool is_recent(int signal_bar, int curr_bar, int lookback) {
+  return (curr_bar - signal_bar) < lookback;
+}
+
+// Utility: build current entry condition context
+EntryContext build_entry_context(bool is_long, double price, double baseline, double atr,
+                                 int last_cross, int last_entry,
+                                 bool trigger, bool confirm, bool volume, bool recent) {
+  EntryContext ctx;
+  ctx.trigger = trigger;
+  ctx.confirm = confirm;
+  ctx.volume = volume;
+  ctx.recent = recent;
+  ctx.base_ok = is_long ? (price > baseline) : (price < baseline);
+  ctx.near = MathAbs(price - baseline) <= atr;
+  ctx.far = MathAbs(price - baseline) > atr;
+  ctx.last_entry = last_entry;
+  ctx.last_cross = last_cross;
+  return ctx;
+}
+
+// Class wrapper for entry logic
+class EntryLogic {
+public:
+  bool is_standard_entry(const EntryContext &ctx) {
+    return ctx.trigger && ctx.confirm && ctx.volume && ctx.recent && ctx.base_ok && ctx.near;
+  }
+
+  bool is_pullback_entry(const EntryContext &ctx, int curr_bar) {
+    return (curr_bar - ctx.last_cross <= 2) && ctx.confirm && ctx.volume && ctx.base_ok && ctx.far;
+  }
+
+  bool is_baseline_cross_entry(const EntryContext &ctx, double prev_price, double prev_baseline,double price, double baseline, bool is_long){
+    bool crossed = is_long ? (prev_price < prev_baseline && price > baseline): (prev_price > prev_baseline && price < baseline);
+    return crossed && ctx.confirm && ctx.volume && ctx.near;
+  }
+
+  bool is_continuation_entry(const EntryContext &ctx, int curr_bar, int look_back) {
+    return (curr_bar - ctx.last_entry <= look_back) && ctx.last_entry > ctx.last_cross && ctx.trigger && ctx.confirm && ctx.base_ok;
+  }
+};