多周期布林共振专业版EA

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

#include <Trade\Trade.mqh>

//+------------------------------------------------------------------+
//| 输入参数                                                           |
//+------------------------------------------------------------------+
input group "== 布林带参数 =="
input int    Inp_BOLL_Period      = 20;       // 布林周期（所有时间周期统一）
input double Inp_BOLL_Deviation   = 2.0;      // 布林带标准差倍数

input group "== 趋势过滤参数 =="
input double Inp_MinDistanceFromMiddle = 30;  // D/4H距中轨最小点数（过滤震荡）
input int    Inp_SlopeMinBars     = 3;        // 中轨斜率判断K线数
input double Inp_BreakoutMinPoints = 20;      // 1H突破中轨最小点数

input group "== 回调确认参数 =="
input int    Inp_PullbackMinBars  = 2;        // 1H回调最少K线数
input int    Inp_ConfirmBars      = 2;        // 15分钟确认K线数
input double Inp_MaxWickRatio     = 0.4;      // 确认K线最大影线比例(0.4=40%)

input group "== ATR动态止损 =="
input int    Inp_ATR_Period       = 14;       // ATR周期
input double Inp_ATR_Multiplier   = 1.0;      // ATR倍数（止损 = 布林+ATR*倍数）
input int    Inp_MinStopLoss      = 100;      // 最小止损点数
input int    Inp_MaxStopLoss      = 400;      // 最大止损点数

input group "== 移动止损参数 =="
input bool   Inp_UseTrailingStop  = true;     // 启用移动止损
input double Inp_BreakEvenRatio   = 1.0;      // 保本触发倍数（1倍SL距离）
input double Inp_LockProfitRatio  = 2.0;      // 锁定利润倍数（2倍SL距离）
input double Inp_TrailingStep     = 1.0;      // 追踪止损步进倍数

input group "== 交易管理 =="
input double Inp_RiskPercent      = 2.0;      // 单笔风险百分比
input double Inp_RiskRewardRatio  = 3.0;      // 初始止盈止损比
input int    Inp_MagicNumber      = 999999;   // EA魔术号
input string Inp_Comment          = "BOLL_PRO"; // 订单备注

input group "== 时间过滤 =="
input bool   Inp_UseTimeFilter    = true;     // 启用时间过滤
input int    Inp_StartHour        = 14;       // 开始交易时间（小时，服务器时间）
input int    Inp_EndHour          = 23;       // 结束交易时间（小时，服务器时间）

//+------------------------------------------------------------------+
//| 全局变量                                                           |
//+------------------------------------------------------------------+
CTrade trade;

// 指标句柄
int handle_BOLL_D;
int handle_BOLL_4H;
int handle_BOLL_1H;
int handle_BOLL_15M;
int handle_ATR_4H;

// 缓冲区数组
double boll_D_upper[], boll_D_middle[], boll_D_lower[];
double boll_4H_upper[], boll_4H_middle[], boll_4H_lower[];
double boll_1H_upper[], boll_1H_middle[], boll_1H_lower[];
double boll_15M_upper[], boll_15M_middle[], boll_15M_lower[];
double atr_4H[];

double close_D[], close_4H[], close_1H[], close_15M[];
double high_1H[], low_1H[], high_15M[], low_15M[];
double open_15M[];

// 持仓跟踪
double positionOpenPrice = 0;      // 持仓开仓价
double positionInitialSL = 0;      // 持仓初始止损价
double positionSLDistance = 0;     // 止损距离（点数）
int    positionType = -1;          // 持仓类型：0=BUY, 1=SELL, -1=无持仓

datetime lastBarTime = 0;

//+------------------------------------------------------------------+
//| EA初始化                                                           |
//+------------------------------------------------------------------+
int OnInit()
{
   // 创建布林带指标句柄
   handle_BOLL_D = iBands(_Symbol, PERIOD_D1, Inp_BOLL_Period, 0, Inp_BOLL_Deviation, PRICE_CLOSE);
   handle_BOLL_4H = iBands(_Symbol, PERIOD_H4, Inp_BOLL_Period, 0, Inp_BOLL_Deviation, PRICE_CLOSE);
   handle_BOLL_1H = iBands(_Symbol, PERIOD_H1, Inp_BOLL_Period, 0, Inp_BOLL_Deviation, PRICE_CLOSE);
   handle_BOLL_15M = iBands(_Symbol, PERIOD_M15, Inp_BOLL_Period, 0, Inp_BOLL_Deviation, PRICE_CLOSE);
   handle_ATR_4H = iATR(_Symbol, PERIOD_H4, Inp_ATR_Period);
   
   if(handle_BOLL_D == INVALID_HANDLE || handle_BOLL_4H == INVALID_HANDLE || 
      handle_BOLL_1H == INVALID_HANDLE || handle_BOLL_15M == INVALID_HANDLE ||
      handle_ATR_4H == INVALID_HANDLE)
   {
      Print("指标创建失败！请检查参数。");
      return INIT_FAILED;
   }
   
   trade.SetExpertMagicNumber(Inp_MagicNumber);
   trade.SetDeviationInPoints(50);
   trade.SetTypeFilling(ORDER_FILLING_IOC);
   
   Print("多周期布林共振专业版EA初始化成功");
   Print("风险设置：单笔", Inp_RiskPercent, "% | 止盈比例 1:", Inp_RiskRewardRatio);
   Print("时间过滤：", Inp_UseTimeFilter ? "启用" : "关闭", " | 交易时段：", Inp_StartHour, ":00 - ", Inp_EndHour, ":00");
   
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| EA清理                                                             |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   IndicatorRelease(handle_BOLL_D);
   IndicatorRelease(handle_BOLL_4H);
   IndicatorRelease(handle_BOLL_1H);
   IndicatorRelease(handle_BOLL_15M);
   IndicatorRelease(handle_ATR_4H);
}

//+------------------------------------------------------------------+
//| EA主循环                                                           |
//+------------------------------------------------------------------+
void OnTick()
{
   // 检查是否有持仓，有则管理持仓（移动止损）
   if(PositionSelect(_Symbol))
   {
      ManagePosition();
      return;  // 有持仓时不再寻找新信号
   }
   else
   {
      // 无持仓时重置跟踪变量
      positionType = -1;
      positionOpenPrice = 0;
      positionInitialSL = 0;
      positionSLDistance = 0;
   }
   
   // 等待新15分钟K线
   datetime currentBarTime = iTime(_Symbol, PERIOD_M15, 0);
   if(currentBarTime == lastBarTime) return;
   lastBarTime = currentBarTime;
   
   // 时间过滤
   if(Inp_UseTimeFilter && !IsWithinTradingHours()) return;
   
   // 更新指标数据
   if(!UpdateIndicatorData()) return;
   
   // ========== 核心策略逻辑 ==========
   
   // 1. 检查D和4H趋势共振（同向且距中轨足够远）
   int resonance = CheckTrendResonance();
   if(resonance == 0) return;  // 0=无共振，1=多头共振，-1=空头共振
   
   // 2. 检查4H布林中轨斜率（确认趋势方向）
   bool slope_bullish = CheckBollSlope(boll_4H_middle, true);
   bool slope_bearish = CheckBollSlope(boll_4H_middle, false);
   
   if(resonance > 0 && !slope_bullish) return;   // 多头共振但中轨不向上
   if(resonance < 0 && !slope_bearish) return;   // 空头共振但中轨不向下
   
   // 3. 检查1H是否有深度回调（触及布林上轨/下轨）
   int pullback = Check1HPullback(resonance);
   if(pullback == 0) return;  // 0=无回调，1=多头回调结束，-1=空头回调结束
   
   // 4. 检查1H是否突破中轨（回调结束，顺应大趋势）
   bool breakout_bullish = Check1HBreakout(true);
   bool breakout_bearish = Check1HBreakout(false);
   
   // 5. 检查15分钟确认K线（无长影线，方向一致）
   bool confirm_bullish = CheckConfirmCandles(true);
   bool confirm_bearish = CheckConfirmCandles(false);
   
   // ========== 开仓信号 ==========
   
   // 做多：多头共振 + 中轨向上 + 1H回调结束 + 突破向上 + 15分钟确认
   if(resonance > 0 && slope_bullish && pullback > 0 && breakout_bullish && confirm_bullish)
   {
      Print("【做多信号】D/4H共振上涨，1H回调结束突破中轨，15M确认");
      OpenPosition(ORDER_TYPE_BUY);
   }
   // 做空：空头共振 + 中轨向下 + 1H反弹结束 + 突破向下 + 15分钟确认
   else if(resonance < 0 && slope_bearish && pullback < 0 && breakout_bearish && confirm_bearish)
   {
      Print("【做空信号】D/4H共振下跌，1H反弹结束突破中轨，15M确认");
      OpenPosition(ORDER_TYPE_SELL);
   }
}

//+------------------------------------------------------------------+
//| 更新所有指标数据                                                    |
//+------------------------------------------------------------------+
bool UpdateIndicatorData()
{
   if(BarsCalculated(handle_BOLL_D) < Inp_SlopeMinBars + 1) return false;
   if(BarsCalculated(handle_BOLL_4H) < Inp_SlopeMinBars + 1) return false;
   if(BarsCalculated(handle_BOLL_1H) < Inp_PullbackMinBars + 2) return false;
   if(BarsCalculated(handle_BOLL_15M) < Inp_ConfirmBars + 1) return false;
   if(BarsCalculated(handle_ATR_4H) < 2) return false;
   
   int bars_needed = MathMax(Inp_SlopeMinBars, Inp_PullbackMinBars) + 3;
   
   // 日线
   if(CopyBuffer(handle_BOLL_D, 1, 0, bars_needed, boll_D_middle) <= 0) return false;
   if(CopyClose(_Symbol, PERIOD_D1, 0, bars_needed, close_D) <= 0) return false;
   
   // 4小时
   if(CopyBuffer(handle_BOLL_4H, 0, 0, bars_needed, boll_4H_upper) <= 0) return false;
   if(CopyBuffer(handle_BOLL_4H, 1, 0, bars_needed, boll_4H_middle) <= 0) return false;
   if(CopyBuffer(handle_BOLL_4H, 2, 0, bars_needed, boll_4H_lower) <= 0) return false;
   if(CopyClose(_Symbol, PERIOD_H4, 0, bars_needed, close_4H) <= 0) return false;
   if(CopyBuffer(handle_ATR_4H, 0, 0, 3, atr_4H) <= 0) return false;
   
   // 1小时
   if(CopyBuffer(handle_BOLL_1H, 0, 0, bars_needed, boll_1H_upper) <= 0) return false;
   if(CopyBuffer(handle_BOLL_1H, 1, 0, bars_needed, boll_1H_middle) <= 0) return false;
   if(CopyBuffer(handle_BOLL_1H, 2, 0, bars_needed, boll_1H_lower) <= 0) return false;
   if(CopyClose(_Symbol, PERIOD_H1, 0, bars_needed, close_1H) <= 0) return false;
   if(CopyHigh(_Symbol, PERIOD_H1, 0, bars_needed, high_1H) <= 0) return false;
   if(CopyLow(_Symbol, PERIOD_H1, 0, bars_needed, low_1H) <= 0) return false;
   
   // 15分钟
   int bars_15M = Inp_ConfirmBars + 2;
   if(CopyBuffer(handle_BOLL_15M, 1, 0, bars_15M, boll_15M_middle) <= 0) return false;
   if(CopyClose(_Symbol, PERIOD_M15, 0, bars_15M, close_15M) <= 0) return false;
   if(CopyHigh(_Symbol, PERIOD_M15, 0, bars_15M, high_15M) <= 0) return false;
   if(CopyLow(_Symbol, PERIOD_M15, 0, bars_15M, low_15M) <= 0) return false;
   if(CopyOpen(_Symbol, PERIOD_M15, 0, bars_15M, open_15M) <= 0) return false;
   
   return true;
}

//+------------------------------------------------------------------+
//| 检查D和4H趋势共振（价格距中轨足够远，同向）                          |
//| 返回：1=多头共振，-1=空头共振，0=无共振                              |
//+------------------------------------------------------------------+
int CheckTrendResonance()
{
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   double min_distance = Inp_MinDistanceFromMiddle * point;
   
   // 检查日线：收盘价距中轨距离
   double d_distance = close_D[1] - boll_D_middle[1];
   if(MathAbs(d_distance) < min_distance) return 0;  // 日线在中轨附近震荡
   
   // 检查4小时：收盘价距中轨距离
   double h4_distance = close_4H[1] - boll_4H_middle[1];
   if(MathAbs(h4_distance) < min_distance) return 0;  // 4H在中轨附近震荡
   
   // 判断方向是否一致
   if(d_distance > 0 && h4_distance > 0)  // 都在中轨上方
      return 1;  // 多头共振
   else if(d_distance < 0 && h4_distance < 0)  // 都在中轨下方
      return -1;  // 空头共振
   
   return 0;  // 方向不一致
}

//+------------------------------------------------------------------+
//| 检查布林中轨斜率（确认趋势方向）                                     |
//| is_bullish: true=检查向上，false=检查向下                           |
//+------------------------------------------------------------------+
bool CheckBollSlope(const double &middle_arr[], bool is_bullish)
{
   // 计算最近N根K线的中轨斜率
   int count_up = 0, count_down = 0;
   
   for(int i = 1; i < Inp_SlopeMinBars; i++)
   {
      if(middle_arr[i] > middle_arr[i+1]) count_up++;
      else if(middle_arr[i] < middle_arr[i+1]) count_down++;
   }
   
   if(is_bullish)
      return (count_up > count_down);  // 中轨向上倾斜
   else
      return (count_down > count_up);  // 中轨向下倾斜
}

//+------------------------------------------------------------------+
//| 检查1H深度回调（触及布林上轨/下轨，持续至少N根K线）                   |
//| resonance: 1=检查多头回调，-1=检查空头回调                           |
//| 返回：1=多头回调结束，-1=空头回调结束，0=无有效回调                   |
//+------------------------------------------------------------------+
int Check1HPullback(int resonance)
{
   if(resonance == 1)  // 多头趋势，检查是否有回调
   {
      // 检查最近N根K线是否有触及下轨（回调）
      int pullback_count = 0;
      for(int i = 1; i <= Inp_PullbackMinBars + 1; i++)
      {
         if(low_1H[i] <= boll_1H_lower[i] + 10 * SymbolInfoDouble(_Symbol, SYMBOL_POINT))
            pullback_count++;
      }
      
      if(pullback_count >= Inp_PullbackMinBars)
         return 1;  // 有深度回调
   }
   else if(resonance == -1)  // 空头趋势，检查是否有反弹
   {
      // 检查最近N根K线是否有触及上轨（反弹）
      int pullback_count = 0;
      for(int i = 1; i <= Inp_PullbackMinBars + 1; i++)
      {
         if(high_1H[i] >= boll_1H_upper[i] - 10 * SymbolInfoDouble(_Symbol, SYMBOL_POINT))
            pullback_count++;
      }
      
      if(pullback_count >= Inp_PullbackMinBars)
         return -1;  // 有深度反弹
   }
   
   return 0;
}

//+------------------------------------------------------------------+
//| 检查1H是否突破布林中轨（回调结束信号）                               |
//| is_bullish: true=向上突破，false=向下突破                           |
//+------------------------------------------------------------------+
bool Check1HBreakout(bool is_bullish)
{
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   double min_breakout = Inp_BreakoutMinPoints * point;
   
   if(is_bullish)
   {
      // 前一根在中轨下方，当前根突破到上方，且距离足够
      bool prev_below = (close_1H[2] < boll_1H_middle[2]);
      bool curr_above = (close_1H[1] > boll_1H_middle[1] + min_breakout);
      return (prev_below && curr_above);
   }
   else
   {
      // 前一根在中轨上方，当前根突破到下方，且距离足够
      bool prev_above = (close_1H[2] > boll_1H_middle[2]);
      bool curr_below = (close_1H[1] < boll_1H_middle[1] - min_breakout);
      return (prev_above && curr_below);
   }
}

//+------------------------------------------------------------------+
//| 检查15分钟确认K线（无长影线，方向一致）                              |
//| is_bullish: true=多头确认，false=空头确认                           |
//+------------------------------------------------------------------+
bool CheckConfirmCandles(bool is_bullish)
{
   int valid_count = 0;
   
   for(int i = 1; i <= Inp_ConfirmBars; i++)
   {
      double body = MathAbs(close_15M[i] - open_15M[i]);
      double range = high_15M[i] - low_15M[i];
      
      if(range <= 0) continue;  // 防止除零
      
      if(is_bullish)
      {
         // 多头K线：收盘>开盘，收盘>中轨，上影线不超过X%
         double upper_wick = high_15M[i] - MathMax(open_15M[i], close_15M[i]);
         double wick_ratio = (range > 0) ? upper_wick / range : 0;
         
         if(close_15M[i] > open_15M[i] && 
            close_15M[i] > boll_15M_middle[i] && 
            wick_ratio < Inp_MaxWickRatio)
         {
            valid_count++;
         }
      }
      else
      {
         // 空头K线：收盘<开盘，收盘<中轨，下影线不超过X%
         double lower_wick = MathMin(open_15M[i], close_15M[i]) - low_15M[i];
         double wick_ratio = (range > 0) ? lower_wick / range : 0;
         
         if(close_15M[i] < open_15M[i] && 
            close_15M[i] < boll_15M_middle[i] && 
            wick_ratio < Inp_MaxWickRatio)
         {
            valid_count++;
         }
      }
   }
   
   return (valid_count >= Inp_ConfirmBars);  // 要求所有确认K线都符合
}

//+------------------------------------------------------------------+
//| 时间过滤：是否在交易时段内                                          |
//+------------------------------------------------------------------+
bool IsWithinTradingHours()
{
   MqlDateTime dt;
   TimeCurrent(dt);
   
   int current_hour = dt.hour;
   
   if(Inp_StartHour <= Inp_EndHour)
   {
      return (current_hour >= Inp_StartHour && current_hour < Inp_EndHour);
   }
   else  // 跨天情况（如22:00-06:00）
   {
      return (current_hour >= Inp_StartHour || current_hour < Inp_EndHour);
   }
}

//+------------------------------------------------------------------+
//| 开仓                                                               |
//+------------------------------------------------------------------+
void OpenPosition(ENUM_ORDER_TYPE order_type)
{
   double price = (order_type == ORDER_TYPE_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) : SymbolInfoDouble(_Symbol, SYMBOL_BID);
   
   // 计算动态止损
   double sl = 0, tp = 0;
   CalculateDynamicStopLoss(order_type, price, sl, tp);
   
   // 根据止损距离计算手数（固定风险百分比）
   double sl_points = MathAbs(price - sl) / SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   double lots = CalculateLotSize(sl_points);
   
   // 规范化手数
   double min_lot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double max_lot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   double lot_step = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   lots = MathFloor(lots / lot_step) * lot_step;
   lots = MathMax(min_lot, MathMin(max_lot, lots));
   
   // 发送订单
   bool result = false;
   if(order_type == ORDER_TYPE_BUY)
      result = trade.Buy(lots, _Symbol, price, sl, tp, Inp_Comment);
   else
      result = trade.Sell(lots, _Symbol, price, sl, tp, Inp_Comment);
   
   if(result)
   {
      Print("订单成功：", (order_type == ORDER_TYPE_BUY ? "做多" : "做空"), 
            " | 手数=", lots, " | 价格=", price, " | SL=", sl, " | TP=", tp, " | SL距离=", (int)sl_points, "点");
      
      // 记录持仓信息（用于移动止损）
      positionType = (int)order_type;
      positionOpenPrice = price;
      positionInitialSL = sl;
      positionSLDistance = sl_points;
   }
   else
   {
      Print("订单失败：", trade.ResultRetcodeDescription());
   }
}

//+------------------------------------------------------------------+
//| 计算动态止损和止盈（布林带 + ATR）                                   |
//+------------------------------------------------------------------+
void CalculateDynamicStopLoss(ENUM_ORDER_TYPE order_type, double entry_price, double &sl, double &tp)
{
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   
   double sl_distance = 0;
   
   // 基础止损：4H布林带宽度 + ATR
   if(order_type == ORDER_TYPE_BUY)
   {
      double boll_sl = boll_4H_lower[1];  // 4H下轨
      sl_distance = entry_price - boll_sl + atr_4H[1] * Inp_ATR_Multiplier;
   }
   else
   {
      double boll_sl = boll_4H_upper[1];  // 4H上轨
      sl_distance = boll_sl - entry_price + atr_4H[1] * Inp_ATR_Multiplier;
   }
   
   // 限制止损范围
   double min_sl = Inp_MinStopLoss * point;
   double max_sl = Inp_MaxStopLoss * point;
   sl_distance = MathMax(min_sl, MathMin(max_sl, sl_distance));
   
   // 计算止盈（风险回报比）
   double tp_distance = sl_distance * Inp_RiskRewardRatio;
   
   if(order_type == ORDER_TYPE_BUY)
   {
      sl = NormalizeDouble(entry_price - sl_distance, digits);
      tp = NormalizeDouble(entry_price + tp_distance, digits);
   }
   else
   {
      sl = NormalizeDouble(entry_price + sl_distance, digits);
      tp = NormalizeDouble(entry_price - tp_distance, digits);
   }
}

//+------------------------------------------------------------------+
//| 根据风险百分比和止损距离计算手数                                     |
//+------------------------------------------------------------------+
double CalculateLotSize(double sl_points)
{
   if(sl_points <= 0) return 0.01;
   
   double account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
   double risk_amount = account_balance * Inp_RiskPercent / 100.0;
   
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   double tick_value = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   
   if(tick_value <= 0) return 0.01;
   
   double lots = risk_amount / (sl_points * tick_value);
   
   return lots;
}

//+------------------------------------------------------------------+
//| 持仓管理（移动止损）                                                |
//+------------------------------------------------------------------+
void ManagePosition()
{
   if(!Inp_UseTrailingStop) return;
   if(positionType == -1) return;  // 无持仓记录
   
   // 获取当前持仓信息
   if(!PositionSelect(_Symbol)) return;
   
   double current_price = (positionType == 0) ? SymbolInfoDouble(_Symbol, SYMBOL_BID) : SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   double current_sl = PositionGetDouble(POSITION_SL);
   double current_tp = PositionGetDouble(POSITION_TP);
   
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   
   // 计算当前浮盈（以止损距离的倍数表示）
   double profit_distance = 0;
   if(positionType == 0)  // 做多
      profit_distance = (current_price - positionOpenPrice) / point;
   else  // 做空
      profit_distance = (positionOpenPrice - current_price) / point;
   
   if(positionSLDistance <= 0) return;
   
   double profit_ratio = profit_distance / positionSLDistance;  // 浮盈倍数
   
   double new_sl = current_sl;
   bool need_modify = false;
   
   // 阶段1：浮盈达到1倍止损距离，移动止损到保本
   if(profit_ratio >= Inp_BreakEvenRatio && current_sl != positionOpenPrice)
   {
      new_sl = positionOpenPrice;
      need_modify = true;
      Print("移动止损到保本：浮盈=", (int)profit_distance, "点 (", DoubleToString(profit_ratio, 2), "倍SL)");
   }
   // 阶段2：浮盈达到2倍止损距离，移动止损到+1倍止损
   else if(profit_ratio >= Inp_LockProfitRatio)
   {
      double lock_sl = 0;
      if(positionType == 0)  // 做多
         lock_sl = positionOpenPrice + positionSLDistance * point;
      else  // 做空
         lock_sl = positionOpenPrice - positionSLDistance * point;
      
      if(positionType == 0 && lock_sl > current_sl)
      {
         new_sl = lock_sl;
         need_modify = true;
         Print("锁定利润：移动止损到+1倍SL，浮盈=", (int)profit_distance, "点");
      }
      else if(positionType == 1 && lock_sl < current_sl)
      {
         new_sl = lock_sl;
         need_modify = true;
         Print("锁定利润：移动止损到+1倍SL，浮盈=", (int)profit_distance, "点");
      }
      
      // 阶段3：追踪止损（每涨/跌1倍SL，止损也跟进1倍SL）
      if(profit_ratio > Inp_LockProfitRatio + Inp_TrailingStep)
      {
         int trailing_steps = (int)((profit_ratio - Inp_LockProfitRatio) / Inp_TrailingStep);
         double trailing_sl = 0;
         
         if(positionType == 0)  // 做多
            trailing_sl = positionOpenPrice + (1 + trailing_steps * Inp_TrailingStep) * positionSLDistance * point;
         else  // 做空
            trailing_sl = positionOpenPrice - (1 + trailing_steps * Inp_TrailingStep) * positionSLDistance * point;
         
         if(positionType == 0 && trailing_sl > current_sl)
         {
            new_sl = trailing_sl;
            need_modify = true;
            Print("追踪止损：移动到+", DoubleToString(1 + trailing_steps * Inp_TrailingStep, 1), "倍SL");
         }
         else if(positionType == 1 && trailing_sl < current_sl)
         {
            new_sl = trailing_sl;
            need_modify = true;
            Print("追踪止损：移动到+", DoubleToString(1 + trailing_steps * Inp_TrailingStep, 1), "倍SL");
         }
      }
   }
   
   // 执行止损修改
   if(need_modify)
   {
      new_sl = NormalizeDouble(new_sl, digits);
      if(trade.PositionModify(_Symbol, new_sl, current_tp))
         Print("止损已更新：", new_sl);
      else
         Print("止损修改失败：", trade.ResultRetcodeDescription());
   }
}
//+------------------------------------------------------------------+