HedgeCycleEA v7

#property version   "7.00"
#property strict

#include <Trade\Trade.mqh>
#include <Trade\PositionInfo.mqh>

input group "=== Trade ==="
input double   LotSize            = 0.11;
input int      Slippage           = 50;
input double   MaxSpreadPoints    = 30.0;
input int      MagicBase          = 90000;

input group "=== 40-Pip Rule ==="
input double   WaitPips           = 40.0;

input group "=== Profit Targets ==="
input double   FirstTargetUSD     = 15.0;
input double   RecoveryExtraUSD   = 15.0;

input group "=== Hard Limits ==="
input int      MaxCycles          = 4;
input double   EmergencyLossPips  = 200.0;

input group "=== Round Loss Cap ==="
input bool     UseRoundCap        = true;
input double   MaxRoundLossUSD    = 45.0;

input group "=== Float Profit Lock ==="
input bool     UseFloatLock       = true;
input double   FloatLockMinUSD    = 5.0;
input double   FloatLockDropUSD   = 3.0;

input group "=== Account Protection ==="
input bool     UseHWM             = true;
input double   MaxDDFromPeakPct   = 10.0;
input bool     UseDailyLimit      = true;
input double   DailyLossLimitUSD  = 30.0;

input group "=== Pause Float Monitor ==="
input bool     MonitorDuringPause   = true;

input double   PauseFloatTargetUSD  = 10.0;

input group "=== Panel ==="
input bool     ShowPanel          = true;
input int      PanelX             = 10;
input int      PanelY             = 30;

enum EState
{
   S_IDLE    = 0,
   S_WAITING = 1,
   S_MONITOR = 2,
   S_CLOSING = 3,
};

struct SCycle
{
   int    magicBuy;
   int    magicSell;
   int    winnerMagic;
   double lossLocked;
   bool   decided;
};

CTrade        g_trade;
CPositionInfo g_pos;

EState  g_state         = S_IDLE;
double  g_startPrice    = 0.0;
double  g_highPrice     = 0.0;
double  g_lowPrice      = 0.0;
double  g_totalLocked   = 0.0;
int     g_cycleCount    = 0;
double  g_roundStartBal = 0.0;
int     g_rounds        = 0;
double  g_totalProfit   = 0.0;
bool    g_firstRun      = true;

SCycle  g_cycles[];

double   g_initialBalance  = 0.0;
double   g_floatPeak       = 0.0;
double   g_highWaterMark   = 0.0;
double   g_dayStartBalance = 0.0;
datetime g_lastDayReset    = 0;
bool     g_paused          = false;
string   g_pauseReason     = "";

string  g_status        = "Starting...";
#define PN "HC7_"
#define PANEL_ROWS 20

int OnInit()
{
      // код доступен только после оплаты
   }

void OnDeinit(const int reason)
{
   for(int i = ObjectsTotal(0,0,-1)-1; i >= 0; i--)
   {
      string name = ObjectName(0,i,0,-1);
      if(StringFind(name,PN) == 0) ObjectDelete(0,name);
   }
}

void OnTick()
{
      // код доступен только после оплаты
   }

void HandleIdle()
{
   if(HasAnyPosition()) { CloseAllOurs(); return; }

   ArrayResize(g_cycles, 0);
   g_totalLocked   = 0.0;
   g_cycleCount    = 0;
   g_roundStartBal = AccountInfoDouble(ACCOUNT_BALANCE);
   g_floatPeak     = 0.0;

   if(!OpenNewCycle()) return;

   g_startPrice = MidPrice();
   g_highPrice  = g_startPrice;
   g_lowPrice   = g_startPrice;
   g_state      = S_WAITING;
   g_rounds++;

   g_status = StringFormat("Round #%d opened | Entry=%.5f | Waiting %.0f pips...",
                            g_rounds, g_startPrice, WaitPips);
   Print("v7: Round #", g_rounds, " opened. Entry=", g_startPrice);
}

void HandleWaiting()
{
   double mid = MidPrice();
   if(mid > g_highPrice) g_highPrice = mid;
   if(mid < g_lowPrice)  g_lowPrice  = mid;

   double pip       = GetPipSize();
   double rangeUp   = (g_highPrice - g_startPrice) / pip;
   double rangeDn   = (g_startPrice - g_lowPrice)  / pip;
   double pipsMoved = MathMax(rangeUp, rangeDn);

   if(pipsMoved < WaitPips)
   {
      double buyPnl  = SidePnl(g_cycles[0].magicBuy);
      double sellPnl = SidePnl(g_cycles[0].magicSell);
      g_status = StringFormat("WAITING %.1f/%.0f pips | BUY=%+.2f SELL=%+.2f Net=%+.2f",
                               pipsMoved, WaitPips, buyPnl, sellPnl, buyPnl + sellPnl);
      return;
   }

   double buyPnl  = SidePnl(g_cycles[0].magicBuy);
   double sellPnl = SidePnl(g_cycles[0].magicSell);
   double netPnl  = buyPnl + sellPnl;

   Print("v7: 40 pips (", DoubleToString(pipsMoved,1), "). BUY=", buyPnl,
         " SELL=", sellPnl, " Net=", netPnl);

   if(netPnl >= FirstTargetUSD)
   {
      g_status = StringFormat("40-pip TARGET HIT! Net=%.2f >= $%.0f. Closing.", netPnl, FirstTargetUSD);
      Print("v7: First target hit. Closing all.");
      g_state = S_CLOSING;
      return;
   }

   if(g_cycleCount >= MaxCycles)
   {
      g_status = StringFormat("MAX %d CYCLES at first decision. Closing all.", MaxCycles);
      Print("v7: Max cycles at first decision. Closing.");
      g_state = S_CLOSING;
      return;
   }

   int    winnerMagic, loserMagic;
   double winnerPnl,   loserPnl;

   if(buyPnl >= sellPnl)
   {
      winnerMagic = g_cycles[0].magicBuy;  winnerPnl = buyPnl;
      loserMagic  = g_cycles[0].magicSell; loserPnl  = sellPnl;
   }
   else
   {
      winnerMagic = g_cycles[0].magicSell; winnerPnl = sellPnl;
      loserMagic  = g_cycles[0].magicBuy;  loserPnl  = buyPnl;
   }

   double lossAmt = MathAbs(loserPnl);
   g_totalLocked += lossAmt;

   g_cycles[0].winnerMagic = winnerMagic;
   g_cycles[0].decided     = true;

   Print("v7: Closing loser ", MagicLabel(loserMagic), " P&L=", loserPnl,
         " | Keeping ", MagicLabel(winnerMagic), " | TotalLocked=", g_totalLocked);

   CloseByMagic(loserMagic);

   if(!OpenNewCycle())
   {
      g_status = "New cycle open FAILED. Closing all.";
      g_state  = S_CLOSING;
      return;
   }

   g_state  = S_MONITOR;
   g_status = StringFormat("Loser closed (-%.2f). Winner kept (+%.2f). Cycle %d/%d.",
                            lossAmt, winnerPnl, g_cycleCount, MaxCycles);
}

void HandleMonitor()
{
   double totalPnl = TotalAllFloatingPnl();
   double target   = g_totalLocked + RecoveryExtraUSD;

   if(UseFloatLock)
   {
      if(totalPnl > g_floatPeak) g_floatPeak = totalPnl;

      if(g_floatPeak >= FloatLockMinUSD &&
         totalPnl    <= g_floatPeak - FloatLockDropUSD)
      {
         g_status = StringFormat(
            "FLOAT LOCK: peak=%.2f now=%.2f dropped %.2f. Closing to protect.",
            g_floatPeak, totalPnl, g_floatPeak - totalPnl);
         Print("v7: ", g_status);
         g_state = S_CLOSING;
         return;
      }
   }

   if(totalPnl >= target)
   {
      Print("v7: MONITOR target hit! TotalPnl=", totalPnl, " Target=", target);
      g_status = StringFormat("RECOVERY HIT! P&L=%.2f >= %.2f. Closing ALL!", totalPnl, target);
      g_state  = S_CLOSING;
      return;
   }

   double worstPnl   = -RecoveryExtraUSD;
   int    worstMagic = 0;

   for(int i = PositionsTotal()-1; i >= 0; i--)
   {
      if(!g_pos.SelectByIndex(i))              continue;
      if(g_pos.Symbol() != _Symbol)             continue;
      if(!IsOurMagic((int)g_pos.Magic()))       continue;

      double p = g_pos.Profit() + g_pos.Swap();
      if(p < worstPnl)
      {
         worstPnl   = p;
         worstMagic = (int)g_pos.Magic();
      }
   }

   if(worstMagic != 0 && totalPnl < 0.0)
   {
      if(g_cycleCount < MaxCycles)
      {
         double lossAmt = MathAbs(worstPnl);
         g_totalLocked += lossAmt;

         Print("v7: Monitor re-eval. Closing worst leg ", MagicLabel(worstMagic),
               " P&L=", worstPnl,
               " | NewLocked=", g_totalLocked,
               " | NewTarget=", g_totalLocked + RecoveryExtraUSD);

         CloseByMagic(worstMagic);

         if(!OpenNewCycle())
         {
            g_status = "Monitor recovery open FAILED. Closing all.";
            g_state  = S_CLOSING;
            return;
         }

         g_status = StringFormat("Monitor: closed worst (%.2f). New pair open. Cycle %d/%d. Target=%.2f",
                                  worstPnl, g_cycleCount, MaxCycles,
                                  g_totalLocked + RecoveryExtraUSD);
         return;
      }
      else
      {
         g_status = StringFormat("MAX %d CYCLES in monitor. Closing all.", MaxCycles);
         Print("v7: Max cycles in monitor. Closing.");
         g_state = S_CLOSING;
         return;
      }
   }

   string allStr = "";
   for(int i = 0; i < ArraySize(g_cycles); i++)
   {
      if(g_cycles[i].decided)
      {
         if(SideHasPos(g_cycles[i].winnerMagic))
            allStr += StringFormat("C%dW=%+.1f ", i+1, SidePnl(g_cycles[i].winnerMagic));
      }
      else
      {
         if(SideHasPos(g_cycles[i].magicBuy))
            allStr += StringFormat("C%dB=%+.1f ", i+1, SidePnl(g_cycles[i].magicBuy));
         if(SideHasPo

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