三均线马丁EA（逻辑完全修正版）

#property copyright "XAUOF指标工坊"
#property version   "9.00"
#property strict

#include <Trade\Trade.mqh>

//--- 输入参数

input int    MA10_Period = 10;
input int    MA15_Period = 15;
input int    MA20_Period = 20;
input double BaseLots = 0.01;
input double MaxLots = 1.0;
input int    StopLoss = 400;
input int    MADistanceMin = 400;
input int    TrailingTrigger = 500;
input int    TrailingStop = 200;
input int    CooldownSeconds = 5;
input int    MinHoldSeconds = 30;
input int    MartinMaxLoss = 4;
input int    MagicBase = 20250101;

enum POSITION_STATE
{
   STATE_NO_POS = 0,
   STATE_BUY_OPEN = 1,
   STATE_SELL_OPEN = 2,
   STATE_CLOSE_COOLDOWN = 3,
   STATE_MARTIN_FOLLOW_PENDING = 4
};

struct TimeframeData
{
   ENUM_TIMEFRAMES period;
   int magic;
   int handleMA10, handleMA15, handleMA20;
   double bufMA10[3], bufMA15[3], bufMA20[3];
   
   double currentLots;
   double entryPrice;
   datetime entryTime;
   datetime lastCloseTime;
   datetime lastSignalBarTime;
   double lastStopLoss;
   bool hasModifiedSL;
   POSITION_STATE state;
   int positionType;
   double floatingProfit;
   double floatingProfitUSD;
   
   int martinFixedStopLossCount;
   double martinAccumulatedLossUSD;
   bool usedTrailingStopThisRound;
   
   int followDirection;
};

CTrade trade;
TimeframeData tfData[3];
string panelName = "MartinPanel";

//+------------------------------------------------------------------+

int OnInit()
{
   ENUM_TIMEFRAMES periods[3] = {PERIOD_M5, PERIOD_M15, PERIOD_M30};
   
   for(int i = 0; i < 3; i++)
   {
      tfData[i].period = periods[i];
      tfData[i].magic = MagicBase + PeriodSeconds(periods[i]) / 60;
      tfData[i].currentLots = BaseLots;
      tfData[i].entryPrice = 0;
      tfData[i].entryTime = 0;
      tfData[i].lastCloseTime = 0;
      tfData[i].lastSignalBarTime = 0;
      tfData[i].lastStopLoss = 0;
      tfData[i].hasModifiedSL = false;
      tfData[i].state = STATE_NO_POS;
      tfData[i].positionType = -1;
      tfData[i].floatingProfit = 0;
      tfData[i].floatingProfitUSD = 0;
      
      tfData[i].martinFixedStopLossCount = 0;
      tfData[i].martinAccumulatedLossUSD = 0;
      tfData[i].usedTrailingStopThisRound = false;
      tfData[i].followDirection = -1;
      
      tfData[i].handleMA10 = iMA(_Symbol, periods[i], MA10_Period, 0, MODE_EMA, PRICE_CLOSE);
      tfData[i].handleMA15 = iMA(_Symbol, periods[i], MA15_Period, 0, MODE_EMA, PRICE_CLOSE);
      tfData[i].handleMA20 = iMA(_Symbol, periods[i], MA20_Period, 0, MODE_EMA, PRICE_CLOSE);
      
      if(tfData[i].handleMA10 == INVALID_HANDLE || 
         tfData[i].handleMA15 == INVALID_HANDLE || 
         tfData[i].handleMA20 == INVALID_HANDLE)
         return INIT_FAILED;
   }
   
   CreatePanel();
   EventSetTimer(1);
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+

void OnDeinit(const int reason)
{
   for(int i = 0; i < 3; i++)
   {
      IndicatorRelease(tfData[i].handleMA10);
      IndicatorRelease(tfData[i].handleMA15);
      IndicatorRelease(tfData[i].handleMA20);
   }
   ObjectDelete(0, panelName);
   EventKillTimer();
}

//+------------------------------------------------------------------+

void OnTick()
{
   for(int i = 0; i < 3; i++)
   {
      ProcessTimeframe(i);
   }
}

//+------------------------------------------------------------------+

void OnTimer()
{
   UpdatePanel();
}

//+------------------------------------------------------------------+

void ProcessTimeframe(int idx)
{
   if(BarsCalculated(tfData[idx].handleMA10) < 3 || 
      BarsCalculated(tfData[idx].handleMA15) < 3 || 
      BarsCalculated(tfData[idx].handleMA20) < 3)
      return;
   
   if(CopyBuffer(tfData[idx].handleMA10, 0, 0, 3, tfData[idx].bufMA10) < 3) return;
   if(CopyBuffer(tfData[idx].handleMA15, 0, 0, 3, tfData[idx].bufMA15) < 3) return;
   if(CopyBuffer(tfData[idx].handleMA20, 0, 0, 3, tfData[idx].bufMA20) < 3) return;
   
   ArraySetAsSeries(tfData[idx].bufMA10, true);
   ArraySetAsSeries(tfData[idx].bufMA15, true);
   ArraySetAsSeries(tfData[idx].bufMA20, true);
   
   datetime time[];
   double close[];
   ArraySetAsSeries(time, true);
   ArraySetAsSeries(close, true);
   
   if(CopyTime(_Symbol, tfData[idx].period, 0, 3, time) < 3) return;
   if(CopyClose(_Symbol, tfData[idx].period, 0, 3, close) < 3) return;
   
   int actualPosType = GetPositionType(tfData[idx].magic);
   
   // 【漏洞修正】检测持仓被平仓

   if(tfData[idx].positionType != -1 && actualPosType == -1)
   {
      OnPositionClosed(idx);
      // 平仓后立即检查是否需要追单

      if(tfData[idx].state == STATE_MARTIN_FOLLOW_PENDING)
      {
         if(tfData[idx].followDirection == 0)
         {
            OpenFollowBuy(idx);
         }
         else if(tfData[idx].followDirection == 1)
         {
            OpenFollowSell(idx);
         }
         tfData[idx].state = STATE_NO_POS;
         tfData[idx].followDirection = -1;
      }
      return;
   }
   
   tfData[idx].positionType = actualPosType;
   
   // 普通冷却

   if(tfData[idx].state == STATE_CLOSE_COOLDOWN)
   {
      if(TimeCurrent() - tfData[idx].lastCloseTime >= CooldownSeconds)
      {
         tfData[idx].state = STATE_NO_POS;
         tfData[idx].lastSignalBarTime = 0;
      }
      else
      {
         return;
      }
   }
   
   // 管理持仓

   if(actualPosType == POSITION_TYPE_BUY)
   {
      ManageBuyPosition(idx, close[1]);
   }
   else if(actualPosType == POSITION_TYPE_SELL)
   {
      ManageSellPosition(idx, close[1]);
   }
   
   // 无持仓时检查开仓信号

   if(actualPosType == -1 && tfData[idx].state == STATE_NO_POS)
   {
      if(time[1] == tfData[idx].lastSignalBarTime)
         return;
      
      if(IsBullishCrossover(idx, close[1]))
      {
         OpenBuy(idx);
         tfData[idx].lastSignalBarTime = time[1];
         return;
      }
      
      if(IsBearishCrossover(idx, close[1]))
      {
         OpenSell(idx);
         tfData[idx].lastSignalBarTime = time[1];
         return;
      }
   }
}

//+------------------------------------------------------------------+

bool IsBullishCrossover(int idx, double lastClosePrice)
{
   if(!(tfData[idx].bufMA10[1] > tfData[idx].bufMA20[1] && 
        tfData[idx].bufMA10[2] <= tfData[idx].bufMA20[2]))
      return false;
   
   double maDistance = MathAbs(tfData[idx].bufMA20[1] - tfData[idx].bufMA10[1]) / _Point;
   if(maDistance < MADistanceMin)
      return false;
   
   if(lastClosePrice <= tfData[idx].bufMA10[1])
      return false;
   
   return true;
}

//+------------------------------------------------------------------+

bool IsBearishCrossover(int idx, double lastClosePrice)
{
   if(!(tfData[idx].bufMA10[1] < tfData[idx].bufMA20[1] && 
        tfData[idx].bufMA10[2] >= tfData[idx].bufMA20[2]))
      return false;
   
   double maDistance = MathAbs(tfData[idx].bufMA10[1] - tfData[idx].bufMA20[1]) / _Point;
   if(maDistance < MADistanceMin)
      return false;
   
   if(lastClosePrice >= tfData[idx].bufMA10[1])
      return false;
   
   return true;
}

//+------------------------------------------------------------------+

void OpenBuy(int idx)
{
   trade.SetExpertMagicNumber(tfData[idx].magic);
   
   double price = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double sl = price - StopLoss * _Point;
   
   double lots = tfData[idx].currentLots;
   if(lots > MaxLots) lots = MaxLots;
   
   if(trade.Buy(lots, _Symbol, price, sl, 0))
   {
      tfData[idx].entryPrice = price;
      tfData[idx].entryTime = TimeCurrent();
      tfData[idx].lastStopLoss = sl;
      tfData[idx].hasModifiedSL = false;
      tfData[idx].state = STATE_BUY_OPEN;
      tfData[idx].positionType = POSITION_TYPE_BUY;
      tfData[idx].usedTrailingStopThisRound = false;
      
      Print(EnumToString(tfData[idx].period), 
            " 【开多】手数=", DoubleToString(lots, 2),
            " 固定止损次数=", tfData[idx].martinFixedStopLossCount,
            " 累计亏损=$", DoubleToString(tfData[idx].martinAccumulatedLossUSD, 2));
   }
}

//+------------------------------------------------------------------+

void OpenSell(int idx)
{
   trade.SetExpertMagicNumber(tfData[idx].magic);
   
   double price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double sl = price + StopLoss * _Point;
   
   double lots = tfData[idx].currentLots;
   if(lots > MaxLots) lots = MaxLots;
   
   if(trade.Sell(lots, _Symbol, price, sl, 0))
   {
      tfData[idx].entryPrice = price;
      tfData[idx].entryTime = TimeCurrent();
      tfData[idx].lastStopLoss = sl;
      tfData[idx].hasModifiedSL = false;
      tfData[idx].state = STATE_SELL_OPEN;
      tfData[idx].positionType = POSITION_TYPE_SELL;
      tfData[idx].usedTrailingStopThisRound = false;
      
      Print(EnumToString(tfData[idx].period), 
            " 【开空】手数=", DoubleToString(lots, 2),
            " 固定止损次数=", tfData[idx].martinFixedStopLossCount,
            " 累计亏损=$", DoubleToString(tfData[idx].martinAccumulatedLossUSD, 2));
   }
}

//+------------------------------------------------------------------+

void OpenFollowBuy(int idx)
{
   trade.SetExpertMagicNumber(tfData[idx].magic);
   
   double price = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double sl = price - StopLoss * _Point;
   
   if(trade.Buy(BaseLots, _Symbol, price, sl, 0))
   {
      tfData[idx].entryPrice = price;
      tfData[idx].entryTime = TimeCurrent();
      tfData[idx].lastStopLoss = sl;
      tfData[idx].hasModifiedSL = false;
      tfData[idx].state = STATE_BUY_OPEN;
      tfData[idx].positionType = POSITION_TYPE_BUY;
      tfData[idx].usedTrailingStopThisRound = false;
      
      Print(EnumToString(tfData[idx].period), 
            " 【马丁止盈后追单-多】0.01手 马丁已重置");
   }
}

//+------------------------------------------------------------------+

void OpenFollowSell(int idx)
{
   trade.SetExpertMagicNumber(tfData[idx].magic);
   
   double price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double sl = price + StopLoss * _Point;
   
   if(trade.Sell(BaseLots, _Symbol, price, sl, 0))
   {
      tfData[idx].entryPrice = price;
      tfData[idx].entryTime = TimeCurrent();
      tfData[idx].lastStopLoss = sl;
      tfData[idx].hasModifiedSL = false;
      tfData[idx].state = STATE_SELL_OPEN;
      tfData[idx].positionType = POSITION_TYPE_SELL;
      tfData[idx].usedTrailingStopThisRound = false;
      
      Print(EnumToString(tfData[idx].period), 
            " 【马丁止盈后追单-空】0.01手 马丁已重置");
   }
}

//+------------------------------------------------------------------+

void ManageBuyPosition(int idx, double lastClosePrice)
{
   if(!PositionSelect(_Symbol)) return;
   if(PositionGetInteger(POSITION_MAGIC) != tfData[idx].magic) return;
   
   trade.SetExpertMagicNumber(tfData[idx].magic);
   
   double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
   double currentSL = PositionGetDouble(POSITION_SL);
   double currentPrice = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double profitUSD = PositionGetDouble(POSITION_PROFIT);
   double profitPoints = (currentPrice - openPrice) / _Point;
   
   tfData[idx].floatingProfitUSD = profitUSD;
   tfData[idx].floatingProfit = profitPoints;
   tfData[idx].lastStopLoss = currentSL;
   
   // ===== 【优先级1】马丁止盈 =====

   if(tfData[idx].martinFixedStopLossCount >= MartinMaxLoss)
   {
      if(profitUSD >= tfData[idx].martinAccumulatedLossUSD)
      {
         if(trade.PositionClose(_Symbol))
         {
            Print(EnumToString(tfData[idx].period), 
                  " 【马丁止盈】浮盈=$", DoubleToString(profitUSD, 2),
                  " >= 累计亏损=$", DoubleToString(tfData[idx].martinAccumulatedLossUSD, 2),
                  " 平仓重置");
            
            // 重置马丁

            tfData[idx].martinFixedStopLossCount = 0;
            tfData[idx].martinAccumulatedLossUSD = 0;
            tfData[idx].currentLots = BaseLots;
            tfData[idx].state = STATE_MARTIN_FOLLOW_PENDING;
            tfData[idx].followDirection = 0;
            tfData[idx].lastCloseTime = TimeCurrent();
         }
         return;
      }
   }
   
   // ===== 【优先级2】MA15止盈 =====

   int holdSeconds = (int)(TimeCurrent() - tfData[idx].entryTime);
   if(holdSeconds >= MinHoldSeconds && lastClosePrice <= tfData[idx].bufMA15[1])
   {
      // 【漏洞修正】平仓前检查

      if(trade.PositionClose(_Symbol))
      {
         Print(EnumToString(tfData[idx].period), 
               " 【MA15止盈】平仓");
         
         tfData[idx].martinFixedStopLossCount = 0;
         tfData[idx].martinAccumulatedLossUSD = 0;
         tfData[idx].currentLots = BaseLots;
         tfData[idx].state = STATE_CLOSE_COOLDOWN;
         tfData[idx].lastCloseTime = TimeCurrent();
      }
      return;
   }
   
   // ===== 【优先级3】移动止损 =====

   if(!tfData[idx].hasModifiedSL && profitPoints >= TrailingTrigger)
   {
      double newSL = openPrice + TrailingStop * _Point;
      if(newSL > currentSL)
      {
         // 【漏洞修正】先标记，再尝试修改

         tfData[idx].hasModifiedSL = true;
         tfData[idx].usedTrailingStopThisRound = true;
         
         if(!trade.PositionModify(_Symbol, newSL, 0))
         {
            Print(EnumToString(tfData[idx].period), " 移动止损修改失败");
         }
         else
         {
            Print(EnumToString(tfData[idx].period), 
                  " 【移动止损】浮盈=", (int)profitPoints, "点");
         }
      }
   }
}

//+------------------------------------------------------------------+

void ManageSellPosition(int idx, double lastClosePrice)
{
   if(!PositionSelect(_Symbol)) return;
   if(PositionGetInteger(POSITION_MAGIC) != tfData[idx].magic) return;
   
   trade.SetExpertMagicNumber(tfData[idx].magic);
   
   double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
   double currentSL = PositionGetDouble(POSITION_SL);
   double currentPrice = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double profitUSD = PositionGetDouble(POSITION_PROFIT);
   double profitPoints = (openPrice - currentPrice) / _Point;
   
   tfData[idx].floatingProfitUSD = profitUSD;
   tfData[idx].floatingProfit = profitPoints;
   tfData[idx].lastStopLoss = currentSL;
   
   if(tfData[idx].martinFixedStopLossCount >= MartinMaxLoss)
   {
      if(profitUSD >= tfData[idx].martinAccumulatedLossUSD)
      {
         if(trade.PositionClose(_Symbol))
         {
            Print(EnumToString(tfData[idx].period), 
                  " 【马丁止盈】浮盈=$", DoubleToString(profitUSD, 2),
                  " >= 累计亏损=$", DoubleToString(tfData[idx].martinAccumulatedLossUSD, 2),
                  " 平仓重置");
            
            tfData[idx].martinFixedStopLossCount = 0;
            tfData[idx].martinAccumulatedLossUSD = 0;
            tfData[idx].currentLots = BaseLots;
            tfData[idx].state = STATE_MARTIN_FOLLOW_PENDING;
            tfData[idx].followDirection = 1;
            tfData[idx].lastCloseTime = TimeCurrent();
         }
         return;
      }
   }
   
   int holdSeconds = (int)(TimeCurrent() - tfData[idx].entryTime);
   if(holdSeconds >= MinHoldSeconds && lastClosePrice >= tfData[idx].bufMA15[1])
   {
      if(trade.PositionClose(_Symbol))
      {
         Print(EnumToString(tfData[idx].period), 
               " 【MA15止盈】平仓");
         
         tfData[idx].martinFixedStopLossCount = 0;
         tfData[idx].martinAccumulatedLossUSD = 0;
         tfData[idx].currentLots = BaseLots;
         tfData[idx].state = STATE_CLOSE_COOLDOWN;
         tfData[idx].lastCloseTime = TimeCurrent();
      }
      return;
   }
   
   if(!tfData[idx].hasModifiedSL && profitPoints >= TrailingTrigger)
   {
      double newSL = openPrice - TrailingStop * _Point;
      if(newSL < currentSL || currentSL == 0)
      {
         tfData[idx].hasModifiedSL = true;
         tfData[idx].usedTrailingStopThisRound = true;
         
         if(!trade.PositionModify(_Symbol, newSL, 0))
         {
            Print(EnumToString(tfData[idx].period), " 移动止损修改失败");
         }
         else
         {
            Print(EnumToString(tfData[idx].period), 
                  " 【移动止损】浮盈=", (int)profitPoints, "点");
         }
      }
   }
}

//+------------------------------------------------------------------+

void OnPositionClosed(int idx)
{
   Print(EnumToString(tfData[idx].period), " 【平仓事件检测】");
   
   double closeProfitUSD = 0;
   if(HistorySelect(tfData[idx].entryTime - 10, TimeCurrent()))
   {
      int dealsTotal = HistoryDealsTotal();
      for(int i = dealsTotal - 1; i >= 0; i--)
      {
         ulong ticket = HistoryDealGetTicket(i);
         if(ticket > 0)
         {
            string dealSymbol = HistoryDealGetString(ticket, DEAL_SYMBOL);
            int dealMagic = (int)HistoryDealGetInteger(ticket, DEAL_MAGIC);
            int dealEntry = (int)HistoryDealGetInteger(ticket, DEAL_ENTRY);
            
            if(dealSymbol == _Symbol && dealMagic == tfData[idx].magic && dealEntry == DEAL_ENTRY_OUT)
            {
               closeProfitUSD = HistoryDealGetDouble(ticket, DEAL_PROFIT);
               break;
            }
         }
      }
   }
   
   // 【核心逻辑】分情况处理

   if(tfData[idx].usedTrailingStopThisRound)
   {
      // ===== 移动止损触发 =====

      // 手数继续累加，马丁统计保留

      tfData[idx].currentLots = MathMin(tfData[idx].currentLots + BaseLots, MaxLots);
      
      Print(EnumToString(tfData[idx].period), 
            " 【移动止损平仓】盈利=$", DoubleToString(closeProfitUSD, 2),
            " | 下次手数=", DoubleToString(tfData[idx].currentLots, 2),
            " | 固定止损次数=", tfData[idx].martinFixedStopLossCount,
            " | 累计亏损=$", DoubleToString(tfData[idx].martinAccumulatedLossUSD, 2));
      
      // 进入冷却

      if(tfData[idx].state != STATE_MARTIN_FOLLOW_PENDING)
      {
         tfData[idx].state = STATE_CLOSE_COOLDOWN;
         tfData[idx].lastCloseTime = TimeCurrent();
      }
   }
   else if(closeProfitUSD < -0.01)
   {
      // ===== 固定止损触发 =====

      tfData[idx].martinFixedStopLossCount++;
      tfData[idx].martinAccumulatedLossUSD += (-closeProfitUSD);
      tfData[idx].currentLots = MathMin(tfData[idx].currentLots + BaseLots, MaxLots);
      
      Print(EnumToString(tfData[idx].period), 
            " 【固定止损平仓】亏损=$", DoubleToString(-closeProfitUSD, 2),
            " | 下次手数=", DoubleToString(tfData[idx].currentLots, 2),
            " | 固定止损次数=", tfData[idx].martinFixedStopLossCount,
            " | 累计亏损=$", DoubleToString(tfData[idx].martinAccumulatedLossUSD, 2));
      
      if(tfData[idx].state != STATE_MARTIN_FOLLOW_PENDING)
      {
         tfData[idx].state = STATE_CLOSE_COOLDOWN;
         tfData[idx].lastCloseTime = TimeCurrent();
      }
   }
   else
   {
      // ===== 其他盈利平仓（MA15或马丁止盈已在Manage里处理，这里不会到） =====

      Print(EnumToString(tfData[idx].period), 
            " 【其他平仓】盈利=$", DoubleToString(closeProfitUSD, 2));
   }
   
   tfData[idx].positionType = -1;
   tfData[idx].entryPrice = 0;
   tfData[idx].entryTime = 0;
   tfData[idx].lastStopLoss = 0;
   tfData[idx].hasModifiedSL = false;
   tfData[idx].usedTrailingStopThisRound = false;
}

//+------------------------------------------------------------------+

int GetPositionType(int magic)
{
   for(int i = 0; i < PositionsTotal(); i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket))
      {
         if(PositionGetString(POSITION_SYMBOL) == _Symbol && 
            PositionGetInteger(POSITION_MAGIC) == magic)
         {
            return (int)PositionGetInteger(POSITION_TYPE);
         }
      }
   }
   return -1;
}

//+------------------------------------------------------------------+

void CreatePanel()
{
   ObjectCreate(0, panelName, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, panelName, OBJPROP_CORNER, CORNER_LEFT_UPPER);
   ObjectSetInteger(0, panelName, OBJPROP_XDISTANCE, 10);
   ObjectSetInteger(0, panelName, OBJPROP_YDISTANCE, 20);
   ObjectSetInteger(0, panelName, OBJPROP_COLOR, clrWhite);
   ObjectSetInteger(0, panelName, OBJPROP_FONTSIZE, 9);
   ObjectSetString(0, panelName, OBJPROP_FONT, "Courier New");
}

//+------------------------------------------------------------------+

void UpdatePanel()
{
   string text = "=== MA Martin EA ===\n";
   for(int i = 0; i < 3; i++)
   {
      text += EnumToString(tfData[i].period) + ": ";
      if(tfData[i].positionType == POSITION_TYPE_BUY)
         text += "BUY ";
      else if(tfData[i].positionType == POSITION_TYPE_SELL)
         text += "SELL ";
      else
         text += "- ";
      
      text += " 浮盈=$" + DoubleToString(tfData[i].floatingProfitUSD, 2);
      text += " 止损次数=" + IntegerToString(tfData[i].martinFixedStopLossCount);
      text += " 累计亏=$" + DoubleToString(tfData[i].martinAccumulatedLossUSD, 2);
      text += "\n";
   }
   
   ObjectSetString(0, panelName, OBJPROP_TEXT, text);
}