無料・高収益 MQL5 EA「TrendFollow_Pyramid」のソースコード・使い方

//+------------------------------------------------------------------+
//| v1.13 ATR期間・エントリーSLバー数・トレーリング参照バー数を外部化 |
//+------------------------------------------------------------------+
#property copyright "TrendFollow_Pyramid"
#property version   "1.13"

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

input string   Group1 = "=== Risk & Money Management ===";
input double   FixedLot          = 0.01;
input int      MaxPositions      = 10;
input double   PyramidScale      = 2.0;

input string   Group2 = "=== Trend Filter ===";
input int      H4_FastMA         = 15;
input int      H4_SlowMA         = 40;
input int      D1_FastMA         = 5;
input int      D1_SlowMA         = 15;

input string   Group3 = "=== Entry & Pyramid Logic ===";
input int      M15_TriggerMA     = 60;
input double   PullbackAtrMult   = 10.0;
input int      SwingSettleBars   = 1;
input double   PyramidAtrMult    = 0.8;
input int      EntrySlBars       = 15;

input string   Group4 = "=== Trade Management ===";
input int      M15_AtrPeriod       = 14;
input int      TrailingLookback    = 14;
input double   TrailingAtrMultMax  = 8.0;
input double   TrailingAtrMultMin  = 2.0;
input double   TrailingAtrMultStep = 1.0;
input int      MaxSpread         = 50;

input string   Group5 = "=== EA System ===";
input int      MagicNumber       = 100013;
input int      Slippage          = 30;

CTrade         trade;
CPositionInfo  posInfo;
CSymbolInfo    symInfo;

int handle_H4_FastMA, handle_H4_SlowMA;
int handle_D1_FastMA, handle_D1_SlowMA;
int handle_M15_TriggerMA;
int handle_M15_ATR;

ENUM_POSITION_TYPE currentTradeDirection = WRONG_VALUE;

ulong failedTickets[];

int OnInit()
  {
   trade.SetExpertMagicNumber(MagicNumber);
   trade.SetDeviationInPoints(Slippage);
   symInfo.Name(_Symbol);
   symInfo.Refresh();

   handle_H4_FastMA     = iMA(_Symbol, PERIOD_H4, H4_FastMA, 0, MODE_SMA, PRICE_CLOSE);
   handle_H4_SlowMA     = iMA(_Symbol, PERIOD_H4, H4_SlowMA, 0, MODE_SMA, PRICE_CLOSE);
   handle_D1_FastMA     = iMA(_Symbol, PERIOD_D1, D1_FastMA, 0, MODE_SMA, PRICE_CLOSE);
   handle_D1_SlowMA     = iMA(_Symbol, PERIOD_D1, D1_SlowMA, 0, MODE_SMA, PRICE_CLOSE);
   handle_M15_TriggerMA = iMA(_Symbol, PERIOD_M15, M15_TriggerMA, 0, MODE_SMA, PRICE_CLOSE);
   handle_M15_ATR       = iATR(_Symbol, PERIOD_M15, M15_AtrPeriod);

   if(handle_H4_FastMA == INVALID_HANDLE || handle_H4_SlowMA == INVALID_HANDLE ||
      handle_D1_FastMA == INVALID_HANDLE || handle_D1_SlowMA == INVALID_HANDLE ||
      handle_M15_TriggerMA == INVALID_HANDLE || handle_M15_ATR == INVALID_HANDLE)
     {
      Print("Failed to load indicators. EA initialization aborted.");
      return(INIT_FAILED);
     }

   ArrayResize(failedTickets, 0);
   RestoreTradeDirection();

   Print("Momentum Pyramid Master EA v1.13 initialized. Symbol=", _Symbol,
         " Magic=", MagicNumber, " FixedLot=", FixedLot, " Direction=", currentTradeDirection);
   return(INIT_SUCCEEDED);
  }

void RestoreTradeDirection()
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      if(posInfo.SelectByIndex(i) && posInfo.Magic() == MagicNumber && posInfo.Symbol() == _Symbol)
        {
         currentTradeDirection = (ENUM_POSITION_TYPE)posInfo.PositionType();
         Print("Trade direction restored: ", currentTradeDirection);
         return;
        }
     }
   currentTradeDirection = WRONG_VALUE;
  }

void OnDeinit(const int reason)
  {
   IndicatorRelease(handle_H4_FastMA);
   IndicatorRelease(handle_H4_SlowMA);
   IndicatorRelease(handle_D1_FastMA);
   IndicatorRelease(handle_D1_SlowMA);
   IndicatorRelease(handle_M15_TriggerMA);
   IndicatorRelease(handle_M15_ATR);
  }

bool IsNewBar()
  {
   static datetime last_time = 0;
   static bool     initialized = false;
   datetime current_time = iTime(_Symbol, PERIOD_M15, 0);

   if(!initialized)
     {
      last_time   = current_time;
      initialized = true;
      return false;
     }

   if(current_time != last_time)
     {
      last_time = current_time;
      return true;
     }
   return false;
  }

double GetDynamicTrailingMult(int posCount)
  {
   double mult = TrailingAtrMultMax - (posCount - 1) * TrailingAtrMultStep;
   if(mult < TrailingAtrMultMin) mult = TrailingAtrMultMin;
   return mult;
  }

void AddFailedTicket(ulong ticket)
  {
   int sz = ArraySize(failedTickets);
   for(int i = 0; i < sz; i++)
      if(failedTickets[i] == ticket) return;
   ArrayResize(failedTickets, sz + 1);
   failedTickets[sz] = ticket;
  }

void RemoveFailedTicket(ulong ticket)
  {
   int sz = ArraySize(failedTickets);
   for(int i = 0; i < sz; i++)
     {
      if(failedTickets[i] == ticket)
        {
         for(int j = i; j < sz - 1; j++)
            failedTickets[j] = failedTickets[j + 1];
         ArrayResize(failedTickets, sz - 1);
         return;
        }
     }
  }

void RetryFailedSLModify()
  {
   if(ArraySize(failedTickets) == 0) return;

   double target_sl = GetSecureSyncSL();
   if(target_sl == 0) return;

   for(int i = ArraySize(failedTickets) - 1; i >= 0; i--)
     {
      ulong ticket = failedTickets[i];
      if(!posInfo.SelectByTicket(ticket))
        {
         RemoveFailedTicket(ticket);
         continue;
        }
      if(posInfo.Magic() != MagicNumber || posInfo.Symbol() != _Symbol)
        {
         RemoveFailedTicket(ticket);
         continue;
        }
      if(posInfo.StopLoss() == target_sl)
        {
         RemoveFailedTicket(ticket);
         continue;
        }
      if(trade.PositionModify(ticket, target_sl, 0))
         RemoveFailedTicket(ticket);
      else
         Print("Retry SL modify failed. Ticket=", ticket, " Error=", trade.ResultRetcode());
     }
  }

void VerifyAndQueueNewPosition(double expected_sl)
  {
   ulong ticket = trade.ResultDeal();
   if(ticket == 0) ticket = trade.ResultOrder();
   if(ticket == 0)
     {
      Print("VerifyNewPosition: could not retrieve ticket from result.");
      return;
     }

   ulong maxTicket = 0;
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      if(posInfo.SelectByIndex(i) && posInfo.Magic() == MagicNumber && posInfo.Symbol() == _Symbol)
         if(posInfo.Ticket() > maxTicket) maxTicket = posInfo.Ticket();
     }

   if(maxTicket == 0)
     {
      Print("VerifyNewPosition: no position found after order. Order may be pending.");
      return;
     }

   if(!posInfo.SelectByTicket(maxTicket))
     {
      Print("VerifyNewPosition: SelectByTicket failed. Ticket=", maxTicket);
      return;
     }

   if(posInfo.StopLoss() != expected_sl)
     {
      Print("VerifyNewPosition: SL mismatch. Ticket=", maxTicket,
            " Expected=", expected_sl, " Actual=", posInfo.StopLoss(), " Queuing retry.");
      AddFailedTicket(maxTicket);
     }
  }

void OnTick()
  {
   symInfo.RefreshRates();

   RetryFailedSLModify();

   int posCount = CountPositions();
   if(posCount == 0) currentTradeDirection = WRONG_VALUE;

   if(posCount > 0)
      ProcessTrailingStop(posCount);

   if(IsNewBar())
     {
      if(symInfo.Spread() > MaxSpread)
        {
         Print("Spread too wide: ", symInfo.Spread(), " > ", MaxSpread, ". Skipping bar.");
         return;
        }

      if(posCount == 0)
        {
         int signal = CheckEntrySignal();
         if(signal == 1)
           {
            double sl = GetRecentLowest(EntrySlBars);
            sl = CheckStopLevel(symInfo.Ask(), sl, true);
            double lot = NormalizeLotSize(FixedLot);
            if(trade.Buy(lot, _Symbol, symInfo.Ask(), sl, 0, "Initial Long"))
              {
               if(ConfirmPositionExists(POSITION_TYPE_BUY))
                 {
                  currentTradeDirection = POSITION_TYPE_BUY;
                  VerifyAndQueueNewPosition(sl);
                 }
               else
                  Print("Initial Buy: order accepted but position not found.");
              }
            else
               Print("Initial Buy failed. Error: ", trade.ResultRetcode());
           }
         else if(signal == -1)
           {
            double sl = GetRecentHighest(EntrySlBars);
            sl = CheckStopLevel(symInfo.Bid(), sl, false);
            double lot = NormalizeLotSize(FixedLot);
            if(trade.Sell(lot, _Symbol, symInfo.Bid(), sl, 0, "Initial Short"))
              {
               if(ConfirmPositionExists(POSITION_TYPE_SELL))
                 {
                  currentTradeDirection = POSITION_TYPE_SELL;
                  VerifyAndQueueNewPosition(sl);
                 }
               else
                  Print("Initial Sell: order accepted but position not found.");
              }
            else
               Print("Initial Sell failed. Error: ", trade.ResultRetcode());
           }
        }
      else if(posCount > 0 && posCount < MaxPositions)
        {
         if(CheckPyramidSignal(currentTradeDirection))
           {
            double current_sl = GetSecureSyncSL();
            if(current_sl == 0)
              {
               Print("Pyramid skipped: no valid SL found across existing positions.");
               return;
              }

            double nextLot = NormalizeLotSize(FixedLot * PyramidScale);
            if(currentTradeDirection == POSITION_TYPE_BUY)
              {
               current_sl = CheckStopLevel(symInfo.Ask(), current_sl, true);
               if(trade.Buy(nextLot, _Symbol, symInfo.Ask(), current_sl, 0, "Pyramid Long"))
                  VerifyAndQueueNewPosition(current_sl);
               else
                  Print("Pyramid Buy failed. Error: ", trade.ResultRetcode());
              }
            else if(currentTradeDirection == POSITION_TYPE_SELL)
              {
               current_sl = CheckStopLevel(symInfo.Bid(), current_sl, false);
               if(trade.Sell(nextLot, _Symbol, symInfo.Bid(), current_sl, 0, "Pyramid Short"))
                  VerifyAndQueueNewPosition(current_sl);
               else
                  Print("Pyramid Sell failed. Error: ", trade.ResultRetcode());
              }
           }
        }
     }
  }

bool ConfirmPositionExists(ENUM_POSITION_TYPE dir)
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      if(posInfo.SelectByIndex(i) && posInfo.Magic() == MagicNumber && posInfo.Symbol() == _Symbol)
         if((ENUM_POSITION_TYPE)posInfo.PositionType() == dir)
            return true;
     }
   return false;
  }

bool IsSwingSettled(bool is_buy)
  {
   if(is_buy)
     {
      int lowestIdx = iLowest(_Symbol, PERIOD_M15, MODE_LOW, 15, 1);
      if(lowestIdx >= 1 && lowestIdx <= SwingSettleBars) return false;
     }
   else
     {
      int highestIdx = iHighest(_Symbol, PERIOD_M15, MODE_HIGH, 15, 1);
      if(highestIdx >= 1 && highestIdx <= SwingSettleBars) return false;
     }
   return true;
  }

int CheckEntrySignal()
  {
   double h4_fast[1], h4_slow[1], d1_fast[1], d1_slow[1];
   double m15_ma[2], atr[1], close[2];

   if(CopyBuffer(handle_H4_FastMA, 0, 1, 1, h4_fast) < 1)     return 0;
   if(CopyBuffer(handle_H4_SlowMA, 0, 1, 1, h4_slow) < 1)     return 0;
   if(CopyBuffer(handle_D1_FastMA, 0, 1, 1, d1_fast) < 1)     return 0;
   if(CopyBuffer(handle_D1_SlowMA, 0, 1, 1, d1_slow) < 1)     return 0;
   if(CopyBuffer(handle_M15_TriggerMA, 0, 1, 2, m15_ma) < 2)  return 0;
   if(CopyBuffer(handle_M15_ATR, 0, 1, 1, atr) < 1)           return 0;
   if(CopyClose(_Symbol, PERIOD_M15, 1, 2, close) < 2)         return 0;

   bool isUpTrendD1   = (d1_fast[0] > d1_slow[0]);
   bool isDownTrendD1 = (d1_fast[0] < d1_slow[0]);
   bool isUpTrendH4   = (h4_fast[0] > h4_slow[0]);
   bool isDownTrendH4 = (h4_fast[0] < h4_slow[0]);

   double distToH4   = MathAbs(close[0] - h4_fast[0]);
   bool isPulledBack = (distToH4 <= (atr[0] * PullbackAtrMult));

   if(isUpTrendD1 && isUpTrendH4 && isPulledBack)
      if(close[1] < m15_ma[1] && close[0] > m15_ma[0])
         if(IsSwingSettled(true)) return 1;

   if(isDownTrendD1 && isDownTrendH4 && isPulledBack)
      if(close[1] > m15_ma[1] && close[0] < m15_ma[0])
         if(IsSwingSettled(false)) return -1;

   return 0;
  }

bool CheckPyramidSignal(ENUM_POSITION_TYPE dir)
  {
   double atr[1];
   if(CopyBuffer(handle_M15_ATR, 0, 1, 1, atr) < 1) return false;

   double lastOpenPrice = GetLastPositionOpenPrice();
   if(dir == POSITION_TYPE_BUY  && (symInfo.Bid() - lastOpenPrice) < atr[0] * PyramidAtrMult) return false;
   if(dir == POSITION_TYPE_SELL && (lastOpenPrice - symInfo.Ask()) < atr[0] * PyramidAtrMult)  return false;

   return true;
  }

void ProcessTrailingStop(int posCount)
  {
   double atr[1];
   if(CopyBuffer(handle_M15_ATR, 0, 1, 1, atr) < 1) return;

   double dynamicMult = GetDynamicTrailingMult(posCount);

   double current_sl = GetSecureSyncSL();
   if(current_sl != 0)
      FillMissingStopLoss(current_sl);

   current_sl = GetSecureSyncSL();

   double new_sl = 0;

   if(currentTradeDirection == POSITION_TYPE_BUY)
     {
      double highest = iHigh(_Symbol, PERIOD_M15, iHighest(_Symbol, PERIOD_M15, MODE_HIGH, TrailingLookback, 1));
      new_sl = NormalizeDouble(highest - (atr[0] * dynamicMult), symInfo.Digits());
      new_sl = CheckStopLevel(symInfo.Bid(), new_sl, true);
      if(current_sl == 0 || new_sl > current_sl)
         ModifyAllPositionsSL(new_sl);
     }
   else if(currentTradeDirection == POSITION_TYPE_SELL)
     {
      double lowest = iLow(_Symbol, PERIOD_M15, iLowest(_Symbol, PERIOD_M15, MODE_LOW, TrailingLookback, 1));
      new_sl = NormalizeDouble(lowest + (atr[0] * dynamicMult), symInfo.Digits());
      new_sl = CheckStopLevel(symInfo.Ask(), new_sl, false);
      if(current_sl == 0 || new_sl < current_sl)
         ModifyAllPositionsSL(new_sl);
     }
  }

void FillMissingStopLoss(double sl_price)
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      if(posInfo.SelectByIndex(i) && posInfo.Magic() == MagicNumber && posInfo.Symbol() == _Symbol)
        {
         if(posInfo.StopLoss() == 0)
           {
            Print("SL missing. Ticket=", posInfo.Ticket(), " Filling SL=", sl_price);
            if(!trade.PositionModify(posInfo.Ticket(), sl_price, 0))
              {
               Print("FillMissingSL failed. Ticket=", posInfo.Ticket(), " Error=", trade.ResultRetcode());
               AddFailedTicket(posInfo.Ticket());
              }
            else
               RemoveFailedTicket(posInfo.Ticket());
           }
        }
     }
  }

void ModifyAllPositionsSL(double sl_price)
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      if(posInfo.SelectByIndex(i) && posInfo.Magic() == MagicNumber && posInfo.Symbol() == _Symbol)
        {
         if(posInfo.StopLoss() != sl_price)
           {
            if(!trade.PositionModify(posInfo.Ticket(), sl_price, 0))
              {
               Print("SL Modify failed. Ticket=", posInfo.Ticket(), " Error=", trade.ResultRetcode());
               AddFailedTicket(posInfo.Ticket());
              }
            else
               RemoveFailedTicket(posInfo.Ticket());
           }
        }
     }
  }

double CheckStopLevel(double base_price, double sl_price, bool is_buy)
  {
   double stopLevel = SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL) * symInfo.Point();
   if(stopLevel == 0) return sl_price;

   if(is_buy)
     {
      if(base_price - sl_price < stopLevel)
         return NormalizeDouble(base_price - stopLevel, symInfo.Digits());
     }
   else
     {
      if(sl_price - base_price < stopLevel)
         return NormalizeDouble(base_price + stopLevel, symInfo.Digits());
     }
   return sl_price;
  }

double NormalizeLotSize(double lot)
  {
   double minLot  = symInfo.LotsMin();
   double maxLot  = symInfo.LotsMax();
   double stepLot = symInfo.LotsStep();
   if(stepLot <= 0) return lot;
   lot = MathFloor(lot / stepLot) * stepLot;
   if(lot < minLot) lot = minLot;
   if(lot > maxLot) lot = maxLot;
   return lot;
  }

double GetRecentLowest(int period)  { return iLow(_Symbol,  PERIOD_M15, iLowest(_Symbol,  PERIOD_M15, MODE_LOW,  period, 1)); }
double GetRecentHighest(int period) { return iHigh(_Symbol, PERIOD_M15, iHighest(_Symbol, PERIOD_M15, MODE_HIGH, period, 1)); }

int CountPositions()
  {
   int count = 0;
   for(int i = PositionsTotal() - 1; i >= 0; i--)
      if(posInfo.SelectByIndex(i) && posInfo.Magic() == MagicNumber && posInfo.Symbol() == _Symbol)
         count++;
   return count;
  }

double GetLastPositionOpenPrice()
  {
   double price = 0;
   ulong maxTicket = 0;
   for(int i = PositionsTotal() - 1; i >= 0; i--)
      if(posInfo.SelectByIndex(i) && posInfo.Magic() == MagicNumber && posInfo.Symbol() == _Symbol)
         if(posInfo.Ticket() > maxTicket) { maxTicket = posInfo.Ticket(); price = posInfo.PriceOpen(); }
   return price;
  }

double GetSecureSyncSL()
  {
   double sl = 0;
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      if(posInfo.SelectByIndex(i) && posInfo.Magic() == MagicNumber && posInfo.Symbol() == _Symbol)
        {
         double posSL = posInfo.StopLoss();
         if(posSL == 0) continue;

         if(currentTradeDirection == POSITION_TYPE_BUY)
           {
            if(sl == 0 || posSL > sl) sl = posSL;
           }
         else if(currentTradeDirection == POSITION_TYPE_SELL)
           {
            if(sl == 0 || posSL < sl) sl = posSL;
           }
        }
     }
   return sl;
  }