多空双开总利润追踪止盈EA

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

#include <Trade\Trade.mqh>

// ========== 基础开仓参数 ==========
input group "=== 基础开仓设置 ==="
input double InitialLot = 0.01;           // 初始手数
input int MagicNumber = 20241201;         // 魔术号(区分不同EA)
input int Slippage = 30;                  // 滑点(点数)

// ========== 多空开仓控制 ==========
input group "=== 多空开仓控制 ==="
input bool AllowBuy = true;               // 允许开多单
input bool AllowSell = true;              // 允许开空单
input bool AllowHedge = true;             // 允许多空双开(对冲)

// ========== 顺势加仓参数 ==========
input group "=== 顺势加仓设置 ==="
input bool EnableTrendAdd = true;         // 启用顺势加仓
input double TrendAddDistance = 300;      // 顺势加仓间距(点数)
input double TrendAddMultiplier = 1.5;    // 顺势加仓倍数
input int MaxTrendAddCount = 3;           // 顺势最多加仓次数

// ========== 逆势加仓参数 ==========
input group "=== 逆势加仓设置 ==="
input bool EnableCounterAdd = true;       // 启用逆势加仓
input double CounterAddDistance = 500;    // 逆势加仓间距(点数)
input double CounterAddMultiplier = 2.0;  // 逆势加仓倍数
input int MaxCounterAddCount = 2;         // 逆势最多加仓次数

// ========== ADX趋势过滤 ==========
input group "=== ADX趋势过滤 ==="
input bool UseAdxFilter = true;           // 启用ADX过滤
input int AdxPeriod = 14;                 // ADX周期
input double AdxTrendLevel = 25.0;        // ADX趋势强度阈值(>此值才开仓)
input double AdxWeakLevel = 20.0;         // ADX弱势阈值(<此值停止加仓)

// ========== 总利润追踪止盈止损 ==========
input group "=== 总利润追踪设置 ==="
input bool EnableTotalTrailing = true;    // 启用总利润追踪
input double TotalProfitTarget = 100.0;   // 开始追踪的总盈利目标(美元)
input double TotalTrailingStop = 50.0;    // 追踪止损回撤(美元,从最高盈利回撤此值全平)
input double TotalStopLoss = 200.0;       // 总止损(美元,浮亏超过此值全平)

// ========== 面板显示 ==========
input group "=== 面板显示设置 ==="
input bool ShowPanel = true;              // 显示信息面板
input int PanelX = 20;                    // 面板X坐标
input int PanelY = 30;                    // 面板Y坐标
input color PanelColor = clrWhite;        // 面板文字颜色

// ========== 全局变量 ==========
CTrade trade;
int adxHandle = INVALID_HANDLE;
double adxBuffer[];

// 追踪状态
double maxProfit = 0;          // 历史最高总盈利
bool isTrailing = false;       // 是否正在追踪

struct PositionInfo {
   ulong ticket;
   int type;        // 0=buy, 1=sell
   double openPrice;
   double lots;
   int addCount;    // 加仓次数
};

PositionInfo buyPositions[];
PositionInfo sellPositions[];

//+------------------------------------------------------------------+
//| 初始化                                                              |
//+------------------------------------------------------------------+
int OnInit()
{
   trade.SetExpertMagicNumber(MagicNumber);
   trade.SetDeviationInPoints(Slippage);
   trade.SetTypeFilling(ORDER_FILLING_IOC);
   
   // 创建ADX句柄
   if(UseAdxFilter) {
      adxHandle = iADX(_Symbol, PERIOD_CURRENT, AdxPeriod);
      if(adxHandle == INVALID_HANDLE) {
         Print("ADX指标创建失败!");
         return INIT_FAILED;
      }
      ArraySetAsSeries(adxBuffer, true);
   }
   
   // 创建面板
   if(ShowPanel) CreatePanel();
   
   // 重置追踪状态
   maxProfit = 0;
   isTrailing = false;
   
   Print("多空双开总利润追踪EA启动成功");
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| 清理                                                              |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   if(adxHandle != INVALID_HANDLE) IndicatorRelease(adxHandle);
   if(ShowPanel) DeletePanel();
}

//+------------------------------------------------------------------+
//| 主循环                                                              |
//+------------------------------------------------------------------+
void OnTick()
{
   // 更新持仓信息
   UpdatePositions();
   
   // 检查总盈亏追踪止盈止损（优先级最高）
   if(EnableTotalTrailing) {
      CheckTotalProfitTrailing();
   }
   
   // 检查ADX条件
   bool adxOk = CheckAdx();
   
   // 多单逻辑
   if(AllowBuy) {
      if(ArraySize(buyPositions) == 0 && adxOk) {
         // 首次开多单
         OpenPosition(ORDER_TYPE_BUY, InitialLot);
      } else if(ArraySize(buyPositions) > 0) {
         // 多单加仓逻辑
         CheckAddPosition(ORDER_TYPE_BUY);
      }
   }
   
   // 空单逻辑
   if(AllowSell) {
      if(ArraySize(sellPositions) == 0 && adxOk) {
         // 首次开空单
         OpenPosition(ORDER_TYPE_SELL, InitialLot);
      } else if(ArraySize(sellPositions) > 0) {
         // 空单加仓逻辑
         CheckAddPosition(ORDER_TYPE_SELL);
      }
   }
   
   // 更新面板
   if(ShowPanel) UpdatePanel();
}

//+------------------------------------------------------------------+
//| 检查总利润追踪止盈止损                                                |
//+------------------------------------------------------------------+
void CheckTotalProfitTrailing()
{
   double totalProfit = GetTotalProfit();
   
   // 总止损：浮亏超过阈值，立即全平
   if(totalProfit < 0 && MathAbs(totalProfit) >= TotalStopLoss) {
      Print("触发总止损! 总浮亏: ", DoubleToString(totalProfit, 2), " 美元，全平所有持仓");
      CloseAllPositions();
      ResetTrailingState();
      return;
   }
   
   // 更新最高盈利
   if(totalProfit > maxProfit) {
      maxProfit = totalProfit;
   }
   
   // 启动追踪：总盈利达到目标
   if(!isTrailing && totalProfit >= TotalProfitTarget) {
      isTrailing = true;
      maxProfit = totalProfit;
      Print("启动总利润追踪! 当前盈利: ", DoubleToString(totalProfit, 2), " 美元");
   }
   
   // 追踪止盈：盈利回撤超过阈值
   if(isTrailing) {
      double drawdown = maxProfit - totalProfit;
      if(drawdown >= TotalTrailingStop) {
         Print("触发追踪止盈! 最高盈利: ", DoubleToString(maxProfit, 2), 
               " 当前盈利: ", DoubleToString(totalProfit, 2), 
               " 回撤: ", DoubleToString(drawdown, 2), " 美元，全平所有持仓");
         CloseAllPositions();
         ResetTrailingState();
      }
   }
}

//+------------------------------------------------------------------+
//| 获取所有持仓总盈亏                                                   |
//+------------------------------------------------------------------+
double GetTotalProfit()
{
   double total = 0;
   for(int i = 0; i < PositionsTotal(); i++) {
      if(PositionGetTicket(i) <= 0) continue;
      if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
      if(PositionGetInteger(POSITION_MAGIC) != MagicNumber) continue;
      
      total += PositionGetDouble(POSITION_PROFIT) + PositionGetDouble(POSITION_SWAP);
   }
   return total;
}

//+------------------------------------------------------------------+
//| 平掉所有持仓                                                        |
//+------------------------------------------------------------------+
void CloseAllPositions()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--) {
      ulong ticket = PositionGetTicket(i);
      if(ticket <= 0) continue;
      if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
      if(PositionGetInteger(POSITION_MAGIC) != MagicNumber) continue;
      
      if(!trade.PositionClose(ticket)) {
         Print("平仓失败 票号: ", ticket, " 错误: ", trade.ResultRetcodeDescription());
      } else {
         Print("平仓成功 票号: ", ticket);
      }
   }
}

//+------------------------------------------------------------------+
//| 重置追踪状态                                                        |
//+------------------------------------------------------------------+
void ResetTrailingState()
{
   maxProfit = 0;
   isTrailing = false;
}

//+------------------------------------------------------------------+
//| 检查ADX条件                                                         |
//+------------------------------------------------------------------+
bool CheckAdx()
{
   if(!UseAdxFilter) return true;
   
   if(BarsCalculated(adxHandle) < 2) return false;
   
   if(CopyBuffer(adxHandle, 0, 0, 2, adxBuffer) < 2) return false;
   
   double adxNow = adxBuffer[0];
   
   // ADX大于趋势阈值才允许开仓
   return (adxNow > AdxTrendLevel);
}

//+------------------------------------------------------------------+
//| 检查加仓条件是否满足                                                  |
//+------------------------------------------------------------------+
void CheckAddPosition(ENUM_ORDER_TYPE type)
{
   double currentPrice = (type == ORDER_TYPE_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) : SymbolInfoDouble(_Symbol, SYMBOL_BID);
   
   PositionInfo positions[];
   if(type == ORDER_TYPE_BUY) {
      ArrayCopy(positions, buyPositions);
   } else {
      ArrayCopy(positions, sellPositions);
   }
   
   if(ArraySize(positions) == 0) return;
   
   // 找最后一单
   PositionInfo lastPos = positions[ArraySize(positions) - 1];
   double priceDiff = MathAbs(currentPrice - lastPos.openPrice) / _Point;
   
   // 判断是顺势还是逆势
   bool isTrend = false;
   if(type == ORDER_TYPE_BUY) {
      isTrend = (currentPrice > lastPos.openPrice); // 多单价格上涨=顺势
   } else {
      isTrend = (currentPrice < lastPos.openPrice); // 空单价格下跌=顺势
   }
   
   // 顺势加仓
   if(isTrend && EnableTrendAdd) {
      if(lastPos.addCount < MaxTrendAddCount && priceDiff >= TrendAddDistance) {
         // 检查ADX是否太弱
         if(UseAdxFilter && !CheckAdxForAdd()) return;
         
         double newLot = NormalizeDouble(lastPos.lots * TrendAddMultiplier, 2);
         OpenPosition(type, newLot);
      }
   }
   
   // 逆势加仓
   if(!isTrend && EnableCounterAdd) {
      if(lastPos.addCount < MaxCounterAddCount && priceDiff >= CounterAddDistance) {
         double newLot = NormalizeDouble(lastPos.lots * CounterAddMultiplier, 2);
         OpenPosition(type, newLot);
      }
   }
}

//+------------------------------------------------------------------+
//| 检查ADX是否适合加仓                                                  |
//+------------------------------------------------------------------+
bool CheckAdxForAdd()
{
   if(!UseAdxFilter) return true;
   if(CopyBuffer(adxHandle, 0, 0, 1, adxBuffer) < 1) return false;
   return (adxBuffer[0] > AdxWeakLevel);
}

//+------------------------------------------------------------------+
//| 开仓                                                              |
//+------------------------------------------------------------------+
void OpenPosition(ENUM_ORDER_TYPE type, double lots)
{
   // 检查是否允许对冲
   if(!AllowHedge) {
      if(type == ORDER_TYPE_BUY && ArraySize(sellPositions) > 0) return;
      if(type == ORDER_TYPE_SELL && ArraySize(buyPositions) > 0) return;
   }
   
   double price = (type == ORDER_TYPE_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) : SymbolInfoDouble(_Symbol, SYMBOL_BID);
   
   if(trade.PositionOpen(_Symbol, type, lots, price, 0, 0, "")) {
      Print("开仓成功: ", (type == ORDER_TYPE_BUY ? "买入" : "卖出"), " 手数:", lots);
   } else {
      Print("开仓失败: ", trade.ResultRetcodeDescription());
   }
}

//+------------------------------------------------------------------+
//| 更新持仓数组                                                        |
//+------------------------------------------------------------------+
void UpdatePositions()
{
   ArrayResize(buyPositions, 0);
   ArrayResize(sellPositions, 0);
   
   for(int i = 0; i < PositionsTotal(); i++) {
      ulong ticket = PositionGetTicket(i);
      if(ticket <= 0) continue;
      if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
      if(PositionGetInteger(POSITION_MAGIC) != MagicNumber) continue;
      
      PositionInfo info;
      info.ticket = ticket;
      info.type = (int)PositionGetInteger(POSITION_TYPE);
      info.openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
      info.lots = PositionGetDouble(POSITION_VOLUME);
      
      if(info.type == POSITION_TYPE_BUY) {
         info.addCount = ArraySize(buyPositions);
         int size = ArraySize(buyPositions);
         ArrayResize(buyPositions, size + 1);
         buyPositions[size] = info;
      } else {
         info.addCount = ArraySize(sellPositions);
         int size = ArraySize(sellPositions);
         ArrayResize(sellPositions, size + 1);
         sellPositions[size] = info;
      }
   }
}

//+------------------------------------------------------------------+
//| 创建面板                                                           |
//+------------------------------------------------------------------+
void CreatePanel()
{
   ObjectCreate(0, "PanelBG", OBJ_RECTANGLE_LABEL, 0, 0, 0);
   ObjectSetInteger(0, "PanelBG", OBJPROP_XDISTANCE, PanelX);
   ObjectSetInteger(0, "PanelBG", OBJPROP_YDISTANCE, PanelY);
   ObjectSetInteger(0, "PanelBG", OBJPROP_XSIZE, 320);
   ObjectSetInteger(0, "PanelBG", OBJPROP_YSIZE, 220);
   ObjectSetInteger(0, "PanelBG", OBJPROP_BGCOLOR, clrBlack);
   ObjectSetInteger(0, "PanelBG", OBJPROP_BORDER_TYPE, BORDER_FLAT);
   ObjectSetInteger(0, "PanelBG", OBJPROP_CORNER, CORNER_LEFT_UPPER);
   ObjectSetInteger(0, "PanelBG", OBJPROP_COLOR, clrWhite);
   ObjectSetInteger(0, "PanelBG", OBJPROP_BACK, false);
   
   for(int i = 0; i < 10; i++) {
      string name = "PanelText" + IntegerToString(i);
      ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0);
      ObjectSetInteger(0, name, OBJPROP_XDISTANCE, PanelX + 10);
      ObjectSetInteger(0, name, OBJPROP_YDISTANCE, PanelY + 10 + i * 20);
      ObjectSetInteger(0, name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
      ObjectSetInteger(0, name, OBJPROP_COLOR, PanelColor);
      ObjectSetInteger(0, name, OBJPROP_FONTSIZE, 9);
      ObjectSetString(0, name, OBJPROP_FONT, "Arial");
   }
}

//+------------------------------------------------------------------+
//| 更新面板                                                           |
//+------------------------------------------------------------------+
void UpdatePanel()
{
   double totalProfit = 0;
   double buyProfit = 0, sellProfit = 0;
   int buyCount = 0, sellCount = 0;
   
   for(int i = 0; i < PositionsTotal(); i++) {
      if(PositionGetTicket(i) <= 0) continue;
      if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
      if(PositionGetInteger(POSITION_MAGIC) != MagicNumber) continue;
      
      double profit = PositionGetDouble(POSITION_PROFIT) + PositionGetDouble(POSITION_SWAP);
      totalProfit += profit;
      
      if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) {
         buyProfit += profit;
         buyCount++;
      } else {
         sellProfit += profit;
         sellCount++;
      }
   }
   
   double adxValue = 0;
   if(UseAdxFilter && CopyBuffer(adxHandle, 0, 0, 1, adxBuffer) > 0) {
      adxValue = adxBuffer[0];
   }
   
   // 追踪状态显示
   string trailingStatus = "未启动";
   double distanceToStop = 0;
   if(isTrailing) {
      trailingStatus = "追踪中";
      distanceToStop = maxProfit - totalProfit;
   }
   
   ObjectSetString(0, "PanelText0", OBJPROP_TEXT, "=== 总利润追踪EA ===");
   ObjectSetString(0, "PanelText1", OBJPROP_TEXT, "总盈亏: " + DoubleToString(totalProfit, 2) + " " + AccountInfoString(ACCOUNT_CURRENCY));
   ObjectSetString(0, "PanelText2", OBJPROP_TEXT, "多单: " + IntegerToString(buyCount) + "单 盈亏:" + DoubleToString(buyProfit, 2));
   ObjectSetString(0, "PanelText3", OBJPROP_TEXT, "空单: " + IntegerToString(sellCount) + "单 盈亏:" + DoubleToString(sellProfit, 2));
   ObjectSetString(0, "PanelText4", OBJPROP_TEXT, "ADX: " + DoubleToString(adxValue, 1));
   ObjectSetString(0, "PanelText5", OBJPROP_TEXT, "---");
   ObjectSetString(0, "PanelText6", OBJPROP_TEXT, "追踪状态: " + trailingStatus);
   ObjectSetString(0, "PanelText7", OBJPROP_TEXT, "最高盈利: " + DoubleToString(maxProfit, 2));
   ObjectSetString(0, "PanelText8", OBJPROP_TEXT, "距离止盈: " + DoubleToString(distanceToStop, 2));
   ObjectSetString(0, "PanelText9", OBJPROP_TEXT, "距离止损: " + DoubleToString(TotalStopLoss - MathAbs(totalProfit), 2));
}

//+------------------------------------------------------------------+
//| 删除面板                                                           |
//+------------------------------------------------------------------+
void DeletePanel()
{
   ObjectDelete(0, "PanelBG");
   for(int i = 0; i < 10; i++) {
      ObjectDelete(0, "PanelText" + IntegerToString(i));
   }
}