双均线马丁趋势跟踪EA

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

#include <Trade\Trade.mqh>

// ========== 输入参数 ==========
input int    MA_Fast_Period = 10;        // 快线周期（推荐10）
input int    MA_Slow_Period = 20;        // 慢线周期（推荐20）
input double Initial_Lot = 0.01;         // 初始手数（马丁起始手数）
input double Lot_Step = 0.01;            // 马丁加仓步长
input int    Magic_Number = 20250115;    // EA魔术号
input int    Slippage = 30;              // 允许滑点（点）
input string Comment_Text = "MA马丁EA";   // 订单注释

// ========== 全局变量 ==========
CTrade trade;
int handleMA10, handleMA20;
double bufMA10[], bufMA20[];

// 状态机：0=空闲 1=持多 2=持空 3=等待突破G1做多 4=等待突破D1做空
int currentState = 0;
double G1 = 0; // 上次多单止损K线的最高点
double D1 = 0; // 上次空单止损K线的最低点

// 马丁策略变量
double currentLotSize = 0.01; // 当前开仓手数，动态调整

//+------------------------------------------------------------------+
int OnInit()
{
   trade.SetExpertMagicNumber(Magic_Number);
   trade.SetDeviationInPoints(Slippage);
   
   // 创建MA指标句柄
   handleMA10 = iMA(_Symbol, PERIOD_CURRENT, MA_Fast_Period, 0, MODE_EMA, PRICE_CLOSE);
   handleMA20 = iMA(_Symbol, PERIOD_CURRENT, MA_Slow_Period, 0, MODE_EMA, PRICE_CLOSE);
   
   if(handleMA10 == INVALID_HANDLE || handleMA20 == INVALID_HANDLE)
   {
      Print("创建MA指标失败");
      return INIT_FAILED;
   }
   
   ArraySetAsSeries(bufMA10, true);
   ArraySetAsSeries(bufMA20, true);
   
   currentLotSize = Initial_Lot; // 初始化马丁手数
   
   Print("EA初始化成功，魔术号：", Magic_Number, " 初始手数：", currentLotSize);
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   IndicatorRelease(handleMA10);
   IndicatorRelease(handleMA20);
}

//+------------------------------------------------------------------+
void OnTick()
{
   // 等待指标计算完成
   if(BarsCalculated(handleMA10) < MA_Slow_Period || BarsCalculated(handleMA20) < MA_Slow_Period)
      return;
   
   // 复制MA数值（索引0=当前K线，1=前一根...）
   if(CopyBuffer(handleMA10, 0, 0, 5, bufMA10) < 5) return;
   if(CopyBuffer(handleMA20, 0, 0, 5, bufMA20) < 5) return;
   
   // 获取当前K线和前3根K线的OHLC
   MqlRates rates[];
   ArraySetAsSeries(rates, true);
   if(CopyRates(_Symbol, PERIOD_CURRENT, 0, 5, rates) < 5) return;
   
   // 计算实体中点价格（最近3根K线，索引1/2/3，不含当前未完成K线0）
   double mid1 = (rates[1].open + rates[1].close) / 2.0;
   double mid2 = (rates[2].open + rates[2].close) / 2.0;
   double mid3 = (rates[3].open + rates[3].close) / 2.0;
   
   // 当前价格和MA值
   double price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double ma10_current = bufMA10[1]; // 用完成K线的MA值
   double ma20_current = bufMA20[1];
   
   // 检查当前持仓
   bool hasPosition = false;
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket))
      {
         if(PositionGetString(POSITION_SYMBOL) == _Symbol && PositionGetInteger(POSITION_MAGIC) == Magic_Number)
         {
            hasPosition = true;
            break;
         }
      }
   }
   
   // ========== 持仓管理：检查止损条件 ==========
   if(currentState == 1) // 持多仓
   {
      // 止损条件：价格回落到MA10与MA20之间 OR 价格同时低于两均线
      bool stopLong = false;
      if(price < ma10_current && price > ma20_current) stopLong = true; // 在两线之间
      if(price < ma10_current && price < ma20_current) stopLong = true; // 同时低于
      
      if(stopLong)
      {
         // 平仓前计算盈亏，决定下次手数
         double totalProfit = GetTotalProfit();
         CloseAllPositions();
         
         // 马丁策略：亏损加仓，盈利重置
         if(totalProfit < 0)
         {
            currentLotSize += Lot_Step;
            Print("多单止损亏损，下次手数增加至：", currentLotSize);
         }
         else
         {
            currentLotSize = Initial_Lot;
            Print("多单止损盈利，手数重置为：", currentLotSize);
         }
         
         G1 = rates[0].high; // 记录当前止损K线的最高点
         currentState = 3;   // 进入等待突破G1状态
         Print("多单止损，记录止损K线最高点G1=", G1, " 盈亏=", totalProfit);
      }
   }
   else if(currentState == 2) // 持空仓
   {
      // 止损条件：价格上升到MA10与MA20之间 OR 价格同时高于两均线
      bool stopShort = false;
      if(price > ma10_current && price < ma20_current) stopShort = true; // 在两线之间
      if(price > ma10_current && price > ma20_current) stopShort = true; // 同时高于
      
      if(stopShort)
      {
         // 平仓前计算盈亏，决定下次手数
         double totalProfit = GetTotalProfit();
         CloseAllPositions();
         
         // 马丁策略：亏损加仓，盈利重置
         if(totalProfit < 0)
         {
            currentLotSize += Lot_Step;
            Print("空单止损亏损，下次手数增加至：", currentLotSize);
         }
         else
         {
            currentLotSize = Initial_Lot;
            Print("空单止损盈利，手数重置为：", currentLotSize);
         }
         
         D1 = rates[0].low; // 记录当前止损K线的最低点
         currentState = 4;  // 进入等待突破D1状态
         Print("空单止损，记录止损K线最低点D1=", D1, " 盈亏=", totalProfit);
      }
   }
   
   // 如果已有持仓，不再检查开仓信号
   if(hasPosition) return;
   
   // ========== 开仓信号判断 ==========
   
   // 【做多信号】
   if(currentState == 0 || currentState == 3)
   {
      // 前提：MA10 > MA20
      if(bufMA10[1] > bufMA20[1])
      {
         // 连续3根K线实体中点都在MA10之上
         bool signal = (mid1 > bufMA10[1] && mid2 > bufMA10[2] && mid3 > bufMA10[3]);
         
         // 如果是状态3（等待突破G1），需要额外判断价格>G1
         if(currentState == 3)
         {
            if(signal && price > G1)
            {
               OpenBuy();
               currentState = 1;
               Print("突破G1再入场做多，价格=", price, " G1=", G1, " 手数=", currentLotSize);
            }
         }
         else if(currentState == 0) // 初始状态
         {
            if(signal)
            {
               OpenBuy();
               currentState = 1;
               Print("首次开多，MA10=", ma10_current, " MA20=", ma20_current, " 手数=", currentLotSize);
            }
         }
      }
      else
      {
         // MA10已经<MA20，取消等待突破G1状态，重置手数
         if(currentState == 3) 
         {
            currentState = 0;
            currentLotSize = Initial_Lot; // 趋势反转，重置马丁
            Print("趋势反转，马丁手数重置");
         }
      }
   }
   
   // 【做空信号】
   if(currentState == 0 || currentState == 4)
   {
      // 前提：MA10 < MA20
      if(bufMA10[1] < bufMA20[1])
      {
         // 连续3根K线实体中点都在MA10之下
         bool signal = (mid1 < bufMA10[1] && mid2 < bufMA10[2] && mid3 < bufMA10[3]);
         
         // 如果是状态4（等待突破D1），需要额外判断价格<D1
         if(currentState == 4)
         {
            if(signal && price < D1)
            {
               OpenSell();
               currentState = 2;
               Print("跌破D1再入场做空，价格=", price, " D1=", D1, " 手数=", currentLotSize);
            }
         }
         else if(currentState == 0) // 初始状态
         {
            if(signal)
            {
               OpenSell();
               currentState = 2;
               Print("首次开空，MA10=", ma10_current, " MA20=", ma20_current, " 手数=", currentLotSize);
            }
         }
      }
      else
      {
         // MA10已经>MA20，取消等待突破D1状态，重置手数
         if(currentState == 4) 
         {
            currentState = 0;
            currentLotSize = Initial_Lot; // 趋势反转，重置马丁
            Print("趋势反转，马丁手数重置");
         }
      }
   }
}

//+------------------------------------------------------------------+
// 计算当前所有持仓的总盈亏
double GetTotalProfit()
{
   double totalProfit = 0.0;
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket))
      {
         if(PositionGetString(POSITION_SYMBOL) == _Symbol && PositionGetInteger(POSITION_MAGIC) == Magic_Number)
         {
            totalProfit += PositionGetDouble(POSITION_PROFIT);
         }
      }
   }
   return totalProfit;
}

//+------------------------------------------------------------------+
void OpenBuy()
{
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   if(trade.Buy(currentLotSize, _Symbol, ask, 0, 0, Comment_Text))
   {
      Print("开多成功，手数=", currentLotSize, " 价格=", ask);
   }
   else
   {
      Print("开多失败，错误码=", GetLastError());
   }
}

//+------------------------------------------------------------------+
void OpenSell()
{
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   if(trade.Sell(currentLotSize, _Symbol, bid, 0, 0, Comment_Text))
   {
      Print("开空成功，手数=", currentLotSize, " 价格=", bid);
   }
   else
   {
      Print("开空失败，错误码=", GetLastError());
   }
}

//+------------------------------------------------------------------+
void CloseAllPositions()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket))
      {
         if(PositionGetString(POSITION_SYMBOL) == _Symbol && PositionGetInteger(POSITION_MAGIC) == Magic_Number)
         {
            trade.PositionClose(ticket);
            Print("平仓订单：", ticket);
         }
      }
   }
}