zonestrategy.mqh

#property version   "2.00"

#include <Arrays\ArrayObj.mqh>
#include "TradeManager.mqh"

enum ENUM_APPROACH_CONTEXT
  {
   APPROACH_NEUTRAL,
   APPROACH_BULLISH_AGGRESSIVE,
   APPROACH_BULLISH_CONSERVATIVE,
   APPROACH_BEARISH_AGGRESSIVE,
   APPROACH_BEARISH_CONSERVATIVE
  };

class CZoneStrategy
  {
private:

   double            min_zone_score;
   int               bounce_closes;
   double            risk_reward;
   double            atr_buffer_mult;

   bool              use_htf_filter;
   ENUM_TIMEFRAMES   htf_timeframe;
   int               htf_ma_period;

   bool              use_htf_rsi_filter;
   int               htf_rsi_period;
   double            htf_rsi_overbought;
   double            htf_rsi_oversold;

   int               approach_lookback_bars;      // Number of bars to evaluate before zone touch
   double            approach_velocity_threshold; // ATR multiplier threshold for momentum sprint

   bool              VerifyBullishRejection(const MqlRates &bar, double zone_bottom);
   bool              VerifyBearishRejection(const MqlRates &bar, double zone_top);

   bool              ValidateZoneInteraction(double z_top, double z_bottom, double cached_atr, const MqlRates &current_bar);

   ENUM_APPROACH_CONTEXT EvaluateApproachContext(const MqlRates &rates[], const double cached_atr);

   bool              CheckHTFBias(bool bullish);

   bool              IsPinBarBullish(const MqlRates &b);
   bool              IsPinBarBearish(const MqlRates &b);
   bool              IsBullishEngulfing(const MqlRates &p, const MqlRates &c);
   bool              IsBearishEngulfing(const MqlRates &p, const MqlRates &c);

public:

                     CZoneStrategy(const double min_score,
                 const int confirm_closes,
                 const double rr,
                 const double atr_mult,
                 const bool use_htf,
                 const ENUM_TIMEFRAMES htf_tf,
                 const int htf_ma,
                 const bool use_htf_rsi,
                 const int htf_rsi_len,
                 const double htf_rsi_ob,
                 const double htf_rsi_os,
                 const int approach_bars,
                 const double approach_threshold);

                    ~CZoneStrategy(void);

   bool              EvaluateSingleZoneSignal(CTradeManager *trade_manager,
         const double cached_atr,
         string z_name,
         int z_type,
         double z_top,
         double z_bottom,
         bool z_is_broken,
         bool z_is_pending,
         double z_current_score,
         bool z_buy_triggered,
         bool z_sell_triggered);

  };

CZoneStrategy::CZoneStrategy(const double min_score,
                             const int confirm_closes,
                             const double rr,
                             const double atr_mult,
                             const bool use_htf,
                             const ENUM_TIMEFRAMES htf_tf,
                             const int htf_ma,
                             const bool use_htf_rsi,
                             const int htf_rsi_len,
                             const double htf_rsi_ob,
                             const double htf_rsi_os,
                             const int approach_bars,
                             const double approach_threshold)
   :
   min_zone_score(min_score),
   bounce_closes(confirm_closes),
   risk_reward(rr),
   atr_buffer_mult(atr_mult),

   use_htf_filter(use_htf),
   htf_timeframe(htf_tf),
   htf_ma_period(htf_ma),

   use_htf_rsi_filter(use_htf_rsi),
   htf_rsi_period(htf_rsi_len),
   htf_rsi_overbought(htf_rsi_ob),
   htf_rsi_oversold(htf_rsi_os),

   approach_lookback_bars(approach_bars),
   approach_velocity_threshold(approach_threshold)
  {

  }

CZoneStrategy::~CZoneStrategy(void)
  {

  }

bool CZoneStrategy::CheckHTFBias(bool bullish)
  {

   if(!use_htf_filter)
      return true;

   int ma_handle=iMA(_Symbol,
                     htf_timeframe,
                     htf_ma_period,
                     0,
                     MODE_EMA,
                     PRICE_CLOSE);

   if(ma_handle==INVALID_HANDLE)
     {
      PrintFormat("[HTF WARNING] Failed to obtain EMA handle for %s. Bypassing filter.", EnumToString(htf_timeframe));
      return true;
     }

   double ma_buffer[];
   ArraySetAsSeries(ma_buffer,true);

   if(CopyBuffer(ma_handle,0,0,2,ma_buffer)<2)
     {
      IndicatorRelease(ma_handle);
      return true;
     }

   double htf_price=iClose(_Symbol,htf_timeframe,0);
   IndicatorRelease(ma_handle);

   bool trend_aligned = bullish ? (htf_price > ma_buffer[0]) : (htf_price < ma_buffer[0]);
   if(!trend_aligned)
      return false;

   if(use_htf_rsi_filter)
     {
      int rsi_handle = iRSI(_Symbol, htf_timeframe, htf_rsi_period, PRICE_CLOSE);
      if(rsi_handle != INVALID_HANDLE)
        {
         double rsi_buffer[];
         ArraySetAsSeries(rsi_buffer, true);

         if(CopyBuffer(rsi_handle, 0, 0, 1, rsi_buffer) > 0)
           {
            double current_rsi = rsi_buffer[0];
            IndicatorRelease(rsi_handle);

            if(bullish && current_rsi >= htf_rsi_overbought)
              {
               PrintFormat("[RSI EXHAUSTION] Blocked BUY. HTF RSI Overbought (%.2f >= %.2f)", current_rsi, htf_rsi_overbought);
               return false;
              }

            if(!bullish && current_rsi <= htf_rsi_oversold)
              {
               PrintFormat("[RSI EXHAUSTION] Blocked SELL. HTF RSI Oversold (%.2f <= %.2f)", current_rsi, htf_rsi_oversold);
               return false;
              }
           }
         else
           {
            IndicatorRelease(rsi_handle);
           }
        }
     }

   return true;
  }

bool CZoneStrategy::IsPinBarBullish(const MqlRates &b)
  {
   double range = b.high - b.low;
   if(range <= 0)
      return false;

   double body = MathAbs(b.open - b.close);
   double lower_tail = MathMin(b.open, b.close) - b.low;
   double upper_tail = b.high - MathMax(b.open, b.close);

   bool rejectionOK = (lower_tail >= body * 2.0); // Strict PinBarRatio of 2.0
   bool cleanTop    = (upper_tail <= range * 0.15);
   bool compactBody = (body <= range * 0.30);

   return (rejectionOK && cleanTop && compactBody);
  }

bool CZoneStrategy::IsPinBarBearish(const MqlRates &b)
  {
   double range = b.high - b.low;
   if(range <= 0)
      return false;

   double body = MathAbs(b.open - b.close);
   double upper_tail = b.high - MathMax(b.open, b.close);
   double lower_tail = MathMin(b.open, b.close) - b.low;

   bool rejectionOK = (upper_tail >= body * 2.0); // Strict PinBarRatio of 2.0
   bool cleanBottom = (lower_tail <= range * 0.15);
   bool compactBody = (body <= range * 0.30);

   return (rejectionOK && cleanBottom && compactBody);
  }

bool CZoneStrategy::IsBullishEngulfing(const MqlRates &p, const MqlRates &c)
  {
   double pRange = p.high - p.low;
   double cRange = c.high - c.low;
   if(pRange <= 0 || cRange <= 0)
      return false;

   double pBody = MathAbs(p.close - p.open);
   double cBody = MathAbs(c.close - c.open);

   if(pBody / pRange < 0.30)
      return false;
   if(cBody / cRange < 0.55)
      return false;

   if(!(p.close < p.open && c.close > c.open))
      return false;

   if(!(c.open <= p.close && c.close >= p.open))
      return false;

   if(cBody < pBody * 1.2)
      return false;

   return true;
  }

bool CZoneStrategy::IsBearishEngulfing(const MqlRates &p, const MqlRates &c)
  {
   double pRange = p.high - p.low;
   double cRange = c.high - c.low;
   if(pRange <= 0 || cRange <= 0)
      return false;

   double pBody = Math

Показано первые 50% кода (символов: 10501)