HT 指标 EA - 增强型趋势跟踪

#property copyright "厕所2号"
#property version   "3.00"

#include <Trade\Trade.mqh>

//========== 指标设置 ==========
input string    Section1 = "========== 指标设置 ==========";
input string    IndicatorName = "HT";
input int       InpAmplitude = 2;
input int       InpAtrPeriod = 100;
input ENUM_TIMEFRAMES SignalTimeframe = PERIOD_M15;

//========== 交易设置 ==========
input string    Section2 = "========== 交易设置 ==========";
input double    InitialLot = 0.01;
input double    MaxLot = 0.3;

//========== 摆动止损设置 ==========
input string    Section3 = "========== 摆动止损设置 ==========";
input int       SwingLookback = 10;
input int       StopBuffer = 100;

//========== 分阶段止损设置（新增）==========
input string    Section4 = "========== 分阶段止损设置 ==========";
input bool      EnablePhaseTrailing = true;          // 启用分阶段跟踪止损
input int       Phase1ProfitTrigger = 300;           // 第一阶段：盈利达此值（点）后进入第二阶段
input int       Phase2ProfitTrigger = 800;           // 第二阶段：盈利达此值（点）后进入第三阶段
input int       Phase1SLBuffer = 200;                // 第一阶段平仓：设置保本止损，缓冲此距离
input int       Phase2ATRMultiplier = 2;             // 第二阶段跟踪：用 2 倍 ATR 作为止损距离
input int       Phase3ATRMultiplier = 1;             // 第三阶段跟踪：用 1 倍 ATR 作为止损距离（更激进）
input int       MinATRDistance = 100;                // ATR 跟踪的最小距离（点）
input bool      CloseOnReverseSignal = true;         // 反向信号时立即平仓

//========== 风控设置 ==========
input string    Section5 = "========== 风控设置 ==========";
input int       MagicNumber = 888888;
input string    TradeComment = "HT_EA_V3";

//========== 全局变量 ==========
CTrade trade;
int indicatorHandle = INVALID_HANDLE;
int atrHandle = INVALID_HANDLE;
double upArrow[], downArrow[];
double currentLotBuy = 0.01;
double currentLotSell = 0.01;
datetime lastBarTime = 0;

// 持仓阶段跟踪
struct PositionPhase {
   int phase;              // 1=初期摆动, 2=中期保本, 3=深度跟踪
   double entryPrice;
   double highestPrice;    // 做多最高点
   double lowestPrice;     // 做空最低点
   int profitAtPhase2;     // 进入第二阶段的盈利
};

PositionPhase positionPhaseInfo;

//+------------------------------------------------------------------+
//| EA 初始化
//+------------------------------------------------------------------+
int OnInit()
{
   if(SwingLookback < 1)
   {
      Print("❌ 摆动回溯K线数必须大于0");
      return INIT_PARAMETERS_INCORRECT;
   }
   
   trade.SetExpertMagicNumber(MagicNumber);
   trade.SetDeviationInPoints(50);
   trade.SetTypeFilling(ORDER_FILLING_FOK);
   trade.SetAsyncMode(false);
   
   // 加载 HT 指标
   indicatorHandle = iCustom(_Symbol, SignalTimeframe, IndicatorName, 
                             InpAmplitude, InpAtrPeriod, 
                             true, true, false, false, false, false);
   
   if(indicatorHandle == INVALID_HANDLE)
   {
      Print("❌ 无法加载指标: ", IndicatorName);
      return INIT_FAILED;
   }
   
   // 加载 ATR 指标
   atrHandle = iATR(_Symbol, SignalTimeframe, InpAtrPeriod);
   if(atrHandle == INVALID_HANDLE)
   {
      Print("❌ 无法加载 ATR 指标");
      return INIT_FAILED;
   }
   
   currentLotBuy = InitialLot;
   currentLotSell = InitialLot;
   
   Print("✅ EA 初始化成功 (v3.0)");
   Print("   分阶段止损: ", EnablePhaseTrailing ? "启用" : "禁用");
   Print("   第一阶段触发: ", Phase1ProfitTrigger, " 点");
   Print("   第二阶段触发: ", Phase2ProfitTrigger, " 点");
   Print("   反向信号平仓: ", CloseOnReverseSignal ? "是" : "否");
   
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| EA 反初始化
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   if(indicatorHandle != INVALID_HANDLE)
      IndicatorRelease(indicatorHandle);
   if(atrHandle != INVALID_HANDLE)
      IndicatorRelease(atrHandle);
   
   Print("EA 已停止");
}

//+------------------------------------------------------------------+
//| 每个 Tick 执行
//+------------------------------------------------------------------+
void OnTick()
{
   datetime currentBarTime = iTime(_Symbol, SignalTimeframe, 0);
   bool isNewBar = (currentBarTime != lastBarTime);
   
   if(isNewBar)
   {
      lastBarTime = currentBarTime;
      CheckSignalsAndTrade();
   }
   
   // 每个 Tick 检查分阶段止损和跟踪
   if(EnablePhaseTrailing)
      CheckPhaseTrailing();
}

//+------------------------------------------------------------------+
//| 检查信号并开单
//+------------------------------------------------------------------+
void CheckSignalsAndTrade()
{
   int calculated = BarsCalculated(indicatorHandle);
   if(calculated < 2)
      return;
   
   if(CopyBuffer(indicatorHandle, 6, 0, 3, upArrow) < 3)
      return;
   if(CopyBuffer(indicatorHandle, 7, 0, 3, downArrow) < 3)
      return;
   
   int signalBar = 1;
   
   //====== 做多信号 ======
   if(upArrow[signalBar] != EMPTY_VALUE && upArrow[signalBar] > 0)
   {
      if(HasPosition(POSITION_TYPE_BUY))
         return;
      
      double swingLow = GetSwingLow(SwingLookback);
      if(swingLow <= 0)
         return;
      
      double price = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      double sl = swingLow - StopBuffer * _Point;
      
      if(sl >= price)
         sl = price - StopBuffer * _Point;
      
      double lotToUse = NormalizeLot(currentLotBuy);
      
      if(trade.Buy(lotToUse, _Symbol, price, sl, 0, TradeComment))
      {
         Print("🔵 做多开单: ", price, " | 止损: ", sl);
         
         // 初始化持仓阶段信息
         positionPhaseInfo.phase = 1;
         positionPhaseInfo.entryPrice = price;
         positionPhaseInfo.highestPrice = price;
         positionPhaseInfo.profitAtPhase2 = 0;
         
         currentLotBuy = InitialLot;
      }
   }
   
   //====== 做空信号 ======
   if(downArrow[signalBar] != EMPTY_VALUE && downArrow[signalBar] > 0)
   {
      if(HasPosition(POSITION_TYPE_SELL))
         return;
      
      double swingHigh = GetSwingHigh(SwingLookback);
      if(swingHigh <= 0)
         return;
      
      double price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      double sl = swingHigh + StopBuffer * _Point;
      
      if(sl <= price)
         sl = price + StopBuffer * _Point;
      
      double lotToUse = NormalizeLot(currentLotSell);
      
      if(trade.Sell(lotToUse, _Symbol, price, sl, 0, TradeComment))
      {
         Print("🔴 做空开单: ", price, " | 止损: ", sl);
         
         positionPhaseInfo.phase = 1;
         positionPhaseInfo.entryPrice = price;
         positionPhaseInfo.lowestPrice = price;
         positionPhaseInfo.profitAtPhase2 = 0;
         
         currentLotSell = InitialLot;
      }
   }
   
   //====== 反向信号平仓 ======
   if(CloseOnReverseSignal)
   {
      if(upArrow[signalBar] != EMPTY_VALUE && upArrow[signalBar] > 0 && HasPosition(POSITION_TYPE_SELL))
      {
         CloseAllPositionByType(POSITION_TYPE_SELL);
         Print("⚠️ 反向做多信号，平仓所有做空");
      }
      
      if(downArrow[signalBar] != EMPTY_VALUE && downArrow[signalBar] > 0 && HasPosition(POSITION_TYPE_BUY))
      {
         CloseAllPositionByType(POSITION_TYPE_BUY);
         Print("⚠️ 反向做空信号，平仓所有做多");
      }
   }
}

//+------------------------------------------------------------------+
//| 检查分阶段止损和跟踪（核心优化逻辑）
//+------------------------------------------------------------------+
void CheckPhaseTrailing()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket <= 0) continue;
      
      if(PositionGetInteger(POSITION_MAGIC) != MagicNumber) continue;
      if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
      
      double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
      double currentSL = PositionGetDouble(POSITION_SL);
      double currentTP = PositionGetDouble(POSITION_TP);
      ENUM_POSITION_TYPE posType = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
      
      double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      double currentPrice = (posType == POSITION_TYPE_BUY) ? bid : ask;
      
      if(posType == POSITION_TYPE_BUY)
         ProcessBuyPhaseTrailing(ticket, openPrice, currentSL, currentTP, currentPrice, bid);
      else
         ProcessSellPhaseTrailing(ticket, openPrice, currentSL, currentTP, currentPrice, ask);
   }
}

//+------------------------------------------------------------------+
//| 处理做多的分阶段止损
//+------------------------------------------------------------------+
void ProcessBuyPhaseTrailing(ulong ticket, double openPrice, double currentSL, 
                             double currentTP, double currentPrice, double bid)
{
   double profitPoints = (currentPrice - openPrice) / _Point;
   
   // 更新最高价
   if(currentPrice > positionPhaseInfo.highestPrice)
      positionPhaseInfo.highestPrice = currentPrice;
   
   double newSL = currentSL;
   
   //===== 第一阶段：只用摆动止损 =====
   if(positionPhaseInfo.phase == 1 && profitPoints >= Phase1ProfitTrigger)
   {
      positionPhaseInfo.phase = 2;
      positionPhaseInfo.profitAtPhase2 = (int)profitPoints;
      
      // 激活保本：移至入场价 + Phase1SLBuffer
      newSL = openPrice + Phase1SLBuffer * _Point;
      
      Print("📈 [做多] 进入第二阶段 | 票号: ", ticket);
      Print("   触发条件: 盈利 ", (int)profitPoints, " 点 >= ", Phase1ProfitTrigger, " 点");
      Print("   新止损: ", newSL, " (保本缓冲 ", Phase1SLBuffer, " 点)");
   }
   
   //===== 第二阶段：ATR 2x 跟踪 =====
   if(positionPhaseInfo.phase == 2)
   {
      if(profitPoints >= Phase2ProfitTrigger)
      {
         positionPhaseInfo.phase = 3;
         Print("📈 [做多] 进入第三阶段 | 票号: ", ticket);
         Print("   触发条件: 盈利 ", (int)profitPoints, " 点 >= ", Phase2ProfitTrigger, " 点");
      }
      else
      {
         // 用 2 倍 ATR 作为动态止损
         double atrValue = GetATRValue();
         double atrDistance = MathMax(atrValue * Phase2ATRMultiplier / _Point, MinATRDistance);
         newSL = positionPhaseInfo.highestPrice - atrDistance * _Point;
         
         // 只在新止损高于当前止损时修改
         if(newSL > currentSL + _Point)
         {
            if(trade.PositionModify(ticket, newSL, currentTP))
            {
               Print("📊 [做多] 第二阶段止损更新 | 票号: ", ticket);
               Print("   ATR: ", DoubleToString(atrValue, 2), " | 2x距离: ", 
                     DoubleToString(atrDistance, 0), " 点 | 新止损: ", newSL);
            }
         }
      }
   }
   
   //===== 第三阶段：ATR 1x 激进跟踪 =====
   if(positionPhaseInfo.phase == 3)
   {
      double atrValue = GetATRValue();
      double atrDistance = MathMax(atrValue * Phase3ATRMultiplier / _Point, MinATRDistance);
      newSL = positionPhaseInfo.highestPrice - atrDistance * _Point;
      
      if(newSL > currentSL + _Point)
      {
         if(trade.PositionModify(ticket, newSL, currentTP))
         {
            Print("📊 [做多] 第三阶段止损更新 | 票号: ", ticket);
            Print("   ATR: ", DoubleToString(atrValue, 2), " | 1x距离: ", 
                  DoubleToString(atrDistance, 0), " 点 | 新止损: ", newSL);
         }
      }
   }
}

//+------------------------------------------------------------------+
//| 处理做空的分阶段止损
//+------------------------------------------------------------------+
void ProcessSellPhaseTrailing(ulong ticket, double openPrice, double currentSL, 
                              double currentTP, double currentPrice, double ask)
{
   double profitPoints = (openPrice - currentPrice) / _Point;
   
   // 更新最低价
   if(currentPrice < positionPhaseInfo.lowestPrice)
      positionPhaseInfo.lowestPrice = currentPrice;
   
   double newSL = currentSL;
   
   //===== 第一阶段：只用摆动止损 =====
   if(positionPhaseInfo.phase == 1 && profitPoints >= Phase1ProfitTrigger)
   {
      positionPhaseInfo.phase = 2;
      positionPhaseInfo.profitAtPhase2 = (int)profitPoints;
      
      // 激活保本：移至入场价 - Phase1SLBuffer
      newSL = openPrice - Phase1SLBuffer * _Point;
      
      Print("📈 [做空] 进入第二阶段 | 票号: ", ticket);
      Print("   触发条件: 盈利 ", (int)profitPoints, " 点 >= ", Phase1ProfitTrigger, " 点");
      Print("   新止损: ", newSL, " (保本缓冲 ", Phase1SLBuffer, " 点)");
   }
   
   //===== 第二阶段：ATR 2x 跟踪 =====
   if(positionPhaseInfo.phase == 2)
   {
      if(profitPoints >= Phase2ProfitTrigger)
      {
         positionPhaseInfo.phase = 3;
         Print("📈 [做空] 进入第三阶段 | 票号: ", ticket);
         Print("   触发条件: 盈利 ", (int)profitPoints, " 点 >= ", Phase2ProfitTrigger, " 点");
      }
      else
      {
         // 用 2 倍 ATR 作为动态止损
         double atrValue = GetATRValue();
         double atrDistance = MathMax(atrValue * Phase2ATRMultiplier / _Point, MinATRDistance);
         newSL = positionPhaseInfo.lowestPrice + atrDistance * _Point;
         
         // 只在新止损低于当前止损时修改
         if(newSL < currentSL - _Point)
         {
            if(trade.PositionModify(ticket, newSL, currentTP))
            {
               Print("📊 [做空] 第二阶段止损更新 | 票号: ", ticket);
               Print("   ATR: ", DoubleToString(atrValue, 2), " | 2x距离: ", 
                     DoubleToString(atrDistance, 0), " 点 | 新止损: ", newSL);
            }
         }
      }
   }
   
   //===== 第三阶段：ATR 1x 激进跟踪 =====
   if(positionPhaseInfo.phase == 3)
   {
      double atrValue = GetATRValue();
      double atrDistance = MathMax(atrValue * Phase3ATRMultiplier / _Point, MinATRDistance);
      newSL = positionPhaseInfo.lowestPrice + atrDistance * _Point;
      
      if(newSL < currentSL - _Point)
      {
         if(trade.PositionModify(ticket, newSL, currentTP))
         {
            Print("📊 [做空] 第三阶段止损更新 | 票号: ", ticket);
            Print("   ATR: ", DoubleToString(atrValue, 2), " | 1x距离: ", 
                  DoubleToString(atrDistance, 0), " 点 | 新止损: ", newSL);
         }
      }
   }
}

//+------------------------------------------------------------------+
//| 获取 ATR 值
//+------------------------------------------------------------------+
double GetATRValue()
{
   double atrBuffer[];
   if(BarsCalculated(atrHandle) < 1)
      return 100 * _Point;  // 默认返回 100 点
   
   if(CopyBuffer(atrHandle, 0, 0, 1, atrBuffer) <= 0)
      return 100 * _Point;
   
   return atrBuffer[0];
}

//+------------------------------------------------------------------+
//| 获取摆动低点
//+------------------------------------------------------------------+
double GetSwingLow(int lookback)
{
   double lowArray[];
   ArraySetAsSeries(lowArray, true);
   
   if(CopyLow(_Symbol, SignalTimeframe, 0, lookback + 1, lowArray) <= 0)
      return 0;
   
   double swingLow = lowArray[1];
   for(int i = 1; i <= lookback && i < ArraySize(lowArray); i++)
   {
      if(lowArray[i] < swingLow)
         swingLow = lowArray[i];
   }
   
   return swingLow;
}

//+------------------------------------------------------------------+
//| 获取摆动高点
//+------------------------------------------------------------------+
double GetSwingHigh(int lookback)
{
   double highArray[];
   ArraySetAsSeries(highArray, true);
   
   if(CopyHigh(_Symbol, SignalTimeframe, 0, lookback + 1, highArray) <= 0)
      return 0;
   
   double swingHigh = highArray[1];
   for(int i = 1; i <= lookback && i < ArraySize(highArray); i++)
   {
      if(highArray[i] > swingHigh)
         swingHigh = highArray[i];
   }
   
   return swingHigh;
}

//+------------------------------------------------------------------+
//| 检查是否有指定方向持仓
//+------------------------------------------------------------------+
bool HasPosition(ENUM_POSITION_TYPE type)
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket <= 0) continue;
      
      if(PositionGetInteger(POSITION_MAGIC) != MagicNumber) continue;
      if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
      
      if((ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == type)
         return true;
   }
   return false;
}

//+------------------------------------------------------------------+
//| 平仓指定方向所有持仓
//+------------------------------------------------------------------+
void CloseAllPositionByType(ENUM_POSITION_TYPE type)
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket <= 0) continue;
      
      if(PositionGetInteger(POSITION_MAGIC) != MagicNumber) continue;
      if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
      
      if((ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == type)
         trade.PositionClose(ticket);
   }
}

//+------------------------------------------------------------------+
//| 交易事件回调（检测亏损后翻倍）
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction& trans,
                        const MqlTradeRequest& request,
                        const MqlTradeResult& result)
{
   if(trans.type != TRADE_TRANSACTION_DEAL_ADD)
      return;
   
   if(!HistoryDealSelect(trans.deal))
      return;
   
   if(HistoryDealGetInteger(trans.deal, DEAL_MAGIC) != MagicNumber)
      return;
   if(HistoryDealGetString(trans.deal, DEAL_SYMBOL) != _Symbol)
      return;
   
   ENUM_DEAL_ENTRY entry = (ENUM_DEAL_ENTRY)HistoryDealGetInteger(trans.deal, DEAL_ENTRY);
   if(entry != DEAL_ENTRY_OUT)
      return;
   
   double profit = HistoryDealGetDouble(trans.deal, DEAL_PROFIT);
   double swap = HistoryDealGetDouble(trans.deal, DEAL_SWAP);
   double commission = HistoryDealGetDouble(trans.deal, DEAL_COMMISSION);
   double totalProfit = profit + swap + commission;
   
   ENUM_DEAL_TYPE dealType = (ENUM_DEAL_TYPE)HistoryDealGetInteger(trans.deal, DEAL_TYPE);
   
   if(totalProfit < 0)
   {
      if(dealType == DEAL_TYPE_BUY)
      {
         currentLotBuy = currentLotBuy * 2;
         if(currentLotBuy > MaxLot)
            currentLotBuy = MaxLot;
         Print("📉 做多止损 | 亏损: ", DoubleToString(totalProfit, 2), 
               " | 下次手数: ", currentLotBuy);
      }
      else if(dealType == DEAL_TYPE_SELL)
      {
         currentLotSell = currentLotSell * 2;
         if(currentLotSell > MaxLot)
            currentLotSell = MaxLot;
         Print("📉 做空止损 | 亏损: ", DoubleToString(totalProfit, 2), 
               " | 下次手数: ", currentLotSell);
      }
   }
   else if(totalProfit > 0)
   {
      if(dealType == DEAL_TYPE_BUY)
      {
         currentLotBuy = InitialLot;
         Print("📈 做多盈利 | 盈利: ", DoubleToString(totalProfit, 2), 
               " | 手数重置: ", currentLotBuy);
      }
      else if(dealType == DEAL_TYPE_SELL)
      {
         currentLotSell = InitialLot;
         Print("📈 做空盈利 | 盈利: ", DoubleToString(totalProfit, 2), 
               " | 手数重置: ", currentLotSell);
      }
   }
}

//+------------------------------------------------------------------+
//| 规范化手数
//+------------------------------------------------------------------+
double NormalizeLot(double lot)
{
   double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   double stepLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   
   if(lot < minLot)
      lot = minLot;
   if(lot > maxLot)
      lot = maxLot;
   
   lot = MathFloor(lot / stepLot) * stepLot;
   
   return lot;
}