趋势启动前 OB/FVG 回踩反转策略

#property copyright "XAUOF Strategy Workshop"
#property version   "1.10"
#property strict

#include <Trade\Trade.mqh>

//--- 输入参数
input group "===== 区域识别参数 ====="
input int    MaxOB_Display      = 2;       // 最多显示几个看涨订单块（建议1-3）
input int    MaxOB_DisplayBear  = 2;       // 最多显示几个看跌订单块（建议1-3）
input int    MaxFVG_Display     = 2;       // 最多显示几个看涨FVG（建议1-3）
input int    MaxFVG_DisplayBear = 2;       // 最多显示几个看跌FVG（建议1-3）
input int    TrendStrength      = 3;       // 趋势强度确认K线数（突破后连续N根同向）
input double ZoneOverlapPct     = 50.0;    // 区域重叠判定百分比（超过此值合并）

input group "===== 显示设置 ====="
input color  BullOB_Color       = clrDodgerBlue;     // 看涨订单块颜色
input color  BearOB_Color       = clrCrimson;        // 看跌订单块颜色
input color  BullFVG_Color      = clrMediumSeaGreen; // 看涨FVG颜色
input color  BearFVG_Color      = clrOrangeRed;      // 看跌FVG颜色
input int    RectTransparency   = 70;      // 矩形透明度0-100（越大越透明）
input bool   EnableAlert        = true;    // 价格回踩时是否弹窗提醒

input group "===== 结构反转确认 ====="
input int    SwingBars          = 5;       // 判断高低点突破的回溯周期
input bool   RequireClose       = true;    // 是否要求收盘价确认突破

input group "===== 交易参数 ====="
input double LotSize            = 0.1;     // 每单手数
input int    StopLossPips       = 200;     // 止损点数（相对入场价）
input int    TakeProfitPips     = 400;     // 止盈点数（相对入场价）
input int    MagicNumber        = 202501;  // EA魔术号（用于识别自己的订单）
input string TradeComment       = "OB_FVG_Strategy"; // 订单备注

input group "===== 风控参数 ====="
input int    MaxOpenOrders      = 2;       // 同时最多持仓订单数
input bool   OnlyOneTrade       = false;   // 每个区域只交易一次
input int    MinBarsSinceEntry  = 3;       // 两次开仓最少间隔K线数

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

struct Zone {
   datetime time_start;      // 区域起始时间
   double   price_top;       // 区域上边界
   double   price_bottom;    // 区域下边界
   string   obj_name;        // 图形对象名称
   bool     touched;         // 价格是否已触及
   bool     alerted;         // 是否已提醒
   bool     traded;          // 是否已交易
   bool     valid;           // 区域是否有效
};

Zone bullOB[];
Zone bearOB[];
Zone bullFVG[];
Zone bearFVG[];

datetime last_entry_time = 0;  // 上次开仓时间

//--- 初始化
int OnInit() {
   trade.SetExpertMagicNumber(MagicNumber);
   trade.SetDeviationInPoints(10);
   
   ArrayResize(bullOB, MaxOB_Display);
   ArrayResize(bearOB, MaxOB_DisplayBear);
   ArrayResize(bullFVG, MaxFVG_Display);
   ArrayResize(bearFVG, MaxFVG_DisplayBear);
   
   for(int i = 0; i < MaxOB_Display; i++) {
      bullOB[i].time_start = 0;
      bullOB[i].obj_name = "";
      bullOB[i].touched = false;
      bullOB[i].alerted = false;
      bullOB[i].traded = false;
      bullOB[i].valid = true;
   }
   for(int i = 0; i < MaxOB_DisplayBear; i++) {
      bearOB[i].time_start = 0;
      bearOB[i].obj_name = "";
      bearOB[i].touched = false;
      bearOB[i].alerted = false;
      bearOB[i].traded = false;
      bearOB[i].valid = true;
   }
   for(int i = 0; i < MaxFVG_Display; i++) {
      bullFVG[i].time_start = 0;
      bullFVG[i].obj_name = "";
      bullFVG[i].touched = false;
      bullFVG[i].alerted = false;
      bullFVG[i].traded = false;
      bullFVG[i].valid = true;
   }
   for(int i = 0; i < MaxFVG_DisplayBear; i++) {
      bearFVG[i].time_start = 0;
      bearFVG[i].obj_name = "";
      bearFVG[i].touched = false;
      bearFVG[i].alerted = false;
      bearFVG[i].traded = false;
      bearFVG[i].valid = true;
   }
   
   Print("OB/FVG 趋势启动策略已启动 | MagicNumber: ", MagicNumber);
   return INIT_SUCCEEDED;
}

//--- 清理
void OnDeinit(const int reason) {
   for(int i = 0; i < MaxOB_Display; i++) {
      if(bullOB[i].obj_name != "") ObjectDelete(0, bullOB[i].obj_name);
   }
   for(int i = 0; i < MaxOB_DisplayBear; i++) {
      if(bearOB[i].obj_name != "") ObjectDelete(0, bearOB[i].obj_name);
   }
   for(int i = 0; i < MaxFVG_Display; i++) {
      if(bullFVG[i].obj_name != "") ObjectDelete(0, bullFVG[i].obj_name);
   }
   for(int i = 0; i < MaxFVG_DisplayBear; i++) {
      if(bearFVG[i].obj_name != "") ObjectDelete(0, bearFVG[i].obj_name);
   }
   Print("OB/FVG 策略已停止");
}

//--- 主循环
void OnTick() {
   static datetime last_bar_time = 0;
   datetime current_bar_time = iTime(_Symbol, PERIOD_CURRENT, 0);
   
   // 只在新K线时扫描区域
   if(current_bar_time != last_bar_time) {
      last_bar_time = current_bar_time;
      
      // 删除已失效的区域
      CleanInvalidZones();
      
      // 扫描新的OB和FVG
      ScanOrderBlocks();
      ScanFVG();
   }
   
   // 每次Tick检查信号
   CheckTradeSignals();
}

//--- 扫描看涨/看跌订单块（只标记趋势启动前的最后一个）
void ScanOrderBlocks() {
   MqlRates rates[];
   ArraySetAsSeries(rates, true);
   int copied = CopyRates(_Symbol, PERIOD_CURRENT, 0, 200, rates);
   if(copied < 50) return;
   
   // 看涨OB：向下趋势后第一次强势向上突破前的最后一根阴线
   for(int i = 10; i < copied - 5; i++) {
      // 当前是阴线
      if(rates[i].close >= rates[i].open) continue;
      
      // 检查前面是否有下跌趋势（连续N根收低）
      bool downtrend = true;
      for(int j = i - TrendStrength; j < i; j++) {
         if(j < 0) continue;
         if(rates[j].close >= rates[j+1].close) {
            downtrend = false;
            break;
         }
      }
      if(!downtrend) continue;
      
      // 下一根强势上涨突破当前高点且连续N根收高
      if(rates[i-1].close <= rates[i].high) continue;
      if(rates[i-1].close <= rates[i-1].open) continue;
      
      bool strong_up = true;
      for(int j = i - 1; j > i - 1 - TrendStrength && j >= 0; j--) {
         if(rates[j].close < rates[j].open || (j < copied - 1 && rates[j].close <= rates[j+1].close)) {
            strong_up = false;
            break;
         }
      }
      if(!strong_up) continue;
      
      // 检查是否与现有区域重叠过多
      bool overlap = false;
      for(int k = 0; k < MaxOB_Display; k++) {
         if(bullOB[k].time_start == 0 || !bullOB[k].valid) continue;
         if(IsOverlapping(rates[i].high, rates[i].low, bullOB[k].price_top, bullOB[k].price_bottom)) {
            overlap = true;
            // 保留新的，删除旧的
            if(bullOB[k].obj_name != "") ObjectDelete(0, bullOB[k].obj_name);
            bullOB[k].valid = false;
            break;
         }
      }
      
      // 添加新区域
      if(bullOB[MaxOB_Display - 1].obj_name != "") {
         ObjectDelete(0, bullOB[MaxOB_Display - 1].obj_name);
      }
      for(int j = MaxOB_Display - 1; j > 0; j--) {
         bullOB[j] = bullOB[j - 1];
      }
      bullOB[0].time_start = rates[i].time;
      bullOB[0].price_top = rates[i].high;
      bullOB[0].price_bottom = rates[i].low;
      bullOB[0].touched = false;
      bullOB[0].alerted = false;
      bullOB[0].traded = false;
      bullOB[0].valid = true;
      bullOB[0].obj_name = "BullOB_" + IntegerToString(rates[i].time);
      
      DrawZoneRect(bullOB[0].obj_name, rates[i].time, bullOB[0].price_top, bullOB[0].price_bottom, BullOB_Color);
      break; // 只找最近一个
   }
   
   // 看跌OB：向上趋势后第一次强势向下突破前的最后一根阳线
   for(int i = 10; i < copied - 5; i++) {
      if(rates[i].close <= rates[i].open) continue;
      
      bool uptrend = true;
      for(int j = i - TrendStrength; j < i; j++) {
         if(j < 0) continue;
         if(rates[j].close <= rates[j+1].close) {
            uptrend = false;
            break;
         }
      }
      if(!uptrend) continue;
      
      if(rates[i-1].close >= rates[i].low) continue;
      if(rates[i-1].close >= rates[i-1].open) continue;
      
      bool strong_down = true;
      for(int j = i - 1; j > i - 1 - TrendStrength && j >= 0; j--) {
         if(rates[j].close > rates[j].open || (j < copied - 1 && rates[j].close >= rates[j+1].close)) {
            strong_down = false;
            break;
         }
      }
      if(!strong_down) continue;
      
      bool overlap = false;
      for(int k = 0; k < MaxOB_DisplayBear; k++) {
         if(bearOB[k].time_start == 0 || !bearOB[k].valid) continue;
         if(IsOverlapping(rates[i].high, rates[i].low, bearOB[k].price_top, bearOB[k].price_bottom)) {
            overlap = true;
            if(bearOB[k].obj_name != "") ObjectDelete(0, bearOB[k].obj_name);
            bearOB[k].valid = false;
            break;
         }
      }
      
      if(bearOB[MaxOB_DisplayBear - 1].obj_name != "") {
         ObjectDelete(0, bearOB[MaxOB_DisplayBear - 1].obj_name);
      }
      for(int j = MaxOB_DisplayBear - 1; j > 0; j--) {
         bearOB[j] = bearOB[j - 1];
      }
      bearOB[0].time_start = rates[i].time;
      bearOB[0].price_top = rates[i].high;
      bearOB[0].price_bottom = rates[i].low;
      bearOB[0].touched = false;
      bearOB[0].alerted = false;
      bearOB[0].traded = false;
      bearOB[0].valid = true;
      bearOB[0].obj_name = "BearOB_" + IntegerToString(rates[i].time);
      
      DrawZoneRect(bearOB[0].obj_name, rates[i].time, bearOB[0].price_top, bearOB[0].price_bottom, BearOB_Color);
      break;
   }
}

//--- 扫描FVG（只标记趋势启动前的最后一个）
void ScanFVG() {
   MqlRates rates[];
   ArraySetAsSeries(rates, true);
   int copied = CopyRates(_Symbol, PERIOD_CURRENT, 0, 200, rates);
   if(copied < 50) return;
   
   // 看涨FVG：第一根的高 < 第三根的低，且处于趋势启动阶段
   for(int i = 10; i < copied - 5; i++) {
      if(i < 2) continue;
      if(rates[i+2].high >= rates[i].low) continue;
      
      // 检查前面是下跌趋势
      bool downtrend = true;
      for(int j = i + 2; j < i + 2 + TrendStrength && j < copied; j++) {
         if(rates[j].close <= rates[j+1].close) {
            downtrend = false;
            break;
         }
      }
      if(!downtrend) continue;
      
      // 检查后面是上涨趋势
      bool uptrend = true;
      for(int j = i - 1; j > i - 1 - TrendStrength && j >= 0; j--) {
         if(rates[j].close < rates[j].open) {
            uptrend = false;
            break;
         }
      }
      if(!uptrend) continue;
      
      double gap_top = rates[i].low;
      double gap_bottom = rates[i+2].high;
      
      bool overlap = false;
      for(int k = 0; k < MaxFVG_Display; k++) {
         if(bullFVG[k].time_start == 0 || !bullFVG[k].valid) continue;
         if(IsOverlapping(gap_top, gap_bottom, bullFVG[k].price_top, bullFVG[k].price_bottom)) {
            overlap = true;
            if(bullFVG[k].obj_name != "") ObjectDelete(0, bullFVG[k].obj_name);
            bullFVG[k].valid = false;
            break;
         }
      }
      
      if(bullFVG[MaxFVG_Display - 1].obj_name != "") {
         ObjectDelete(0, bullFVG[MaxFVG_Display - 1].obj_name);
      }
      for(int j = MaxFVG_Display - 1; j > 0; j--) {
         bullFVG[j] = bullFVG[j - 1];
      }
      bullFVG[0].time_start = rates[i+1].time;
      bullFVG[0].price_top = gap_top;
      bullFVG[0].price_bottom = gap_bottom;
      bullFVG[0].touched = false;
      bullFVG[0].alerted = false;
      bullFVG[0].traded = false;
      bullFVG[0].valid = true;
      bullFVG[0].obj_name = "BullFVG_" + IntegerToString(rates[i+1].time);
      
      DrawZoneRect(bullFVG[0].obj_name, rates[i+1].time, bullFVG[0].price_top, bullFVG[0].price_bottom, BullFVG_Color);
      break;
   }
   
   // 看跌FVG：第一根的低 > 第三根的高，且处于趋势启动阶段
   for(int i = 10; i < copied - 5; i++) {
      if(i < 2) continue;
      if(rates[i+2].low <= rates[i].high) continue;
      
      bool uptrend = true;
      for(int j = i + 2; j < i + 2 + TrendStrength && j < copied; j++) {
         if(rates[j].close >= rates[j+1].close) {
            uptrend = false;
            break;
         }
      }
      if(!uptrend) continue;
      
      bool downtrend = true;
      for(int j = i - 1; j > i - 1 - TrendStrength && j >= 0; j--) {
         if(rates[j].close > rates[j].open) {
            downtrend = false;
            break;
         }
      }
      if(!downtrend) continue;
      
      double gap_top = rates[i+2].low;
      double gap_bottom = rates[i].high;
      
      bool overlap = false;
      for(int k = 0; k < MaxFVG_DisplayBear; k++) {
         if(bearFVG[k].time_start == 0 || !bearFVG[k].valid) continue;
         if(IsOverlapping(gap_top, gap_bottom, bearFVG[k].price_top, bearFVG[k].price_bottom)) {
            overlap = true;
            if(bearFVG[k].obj_name != "") ObjectDelete(0, bearFVG[k].obj_name);
            bearFVG[k].valid = false;
            break;
         }
      }
      
      if(bearFVG[MaxFVG_DisplayBear - 1].obj_name != "") {
         ObjectDelete(0, bearFVG[MaxFVG_DisplayBear - 1].obj_name);
      }
      for(int j = MaxFVG_DisplayBear - 1; j > 0; j--) {
         bearFVG[j] = bearFVG[j - 1];
      }
      bearFVG[0].time_start = rates[i+1].time;
      bearFVG[0].price_top = gap_top;
      bearFVG[0].price_bottom = gap_bottom;
      bearFVG[0].touched = false;
      bearFVG[0].alerted = false;
      bearFVG[0].traded = false;
      bearFVG[0].valid = true;
      bearFVG[0].obj_name = "BearFVG_" + IntegerToString(rates[i+1].time);
      
      DrawZoneRect(bearFVG[0].obj_name, rates[i+1].time, bearFVG[0].price_top, bearFVG[0].price_bottom, BearFVG_Color);
      break;
   }
}

//--- 检查交易信号
void CheckTradeSignals() {
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   
   MqlRates rates[];
   ArraySetAsSeries(rates, true);
   int copied = CopyRates(_Symbol, PERIOD_CURRENT, 0, SwingBars + 5, rates);
   if(copied < SwingBars + 2) return;
   
   // 检查持仓数量
   int open_positions = 0;
   for(int i = PositionsTotal() - 1; i >= 0; i--) {
      ulong ticket = PositionGetTicket(i);
      if(PositionGetString(POSITION_SYMBOL) == _Symbol && PositionGetInteger(POSITION_MAGIC) == MagicNumber) {
         open_positions++;
      }
   }
   if(open_positions >= MaxOpenOrders) return;
   
   // 检查距离上次开仓时间
   if(TimeCurrent() - last_entry_time < PeriodSeconds(PERIOD_CURRENT) * MinBarsSinceEntry) return;
   
   // 检查看涨OB
   for(int i = 0; i < MaxOB_Display; i++) {
      if(bullOB[i].time_start == 0 || !bullOB[i].valid) continue;
      if(OnlyOneTrade && bullOB[i].traded) continue;
      
      // 价格触及区域
      if(bid <= bullOB[i].price_top && bid >= bullOB[i].price_bottom) {
         if(!bullOB[i].touched) {
            bullOB[i].touched = true;
            if(EnableAlert && !bullOB[i].alerted) {
               Alert("价格回踩到看涨OB: ", _Symbol, " @ ", DoubleToString(bid, _Digits));
               bullOB[i].alerted = true;
            }
         }
      }
      
      // 已触及且出现结构反转
      if(bullOB[i].touched && !bullOB[i].traded) {
         if(IsSwingReversalUp(rates)) {
            double sl = ask - StopLossPips * _Point;
            double tp = ask + TakeProfitPips * _Point;
            if(trade.Buy(LotSize, _Symbol, ask, sl, tp, TradeComment)) {
               bullOB[i].traded = true;
               last_entry_time = TimeCurrent();
               Print("看涨OB开仓成功 | 价格: ", ask, " | SL: ", sl, " | TP: ", tp);
            }
         }
      }
   }
   
   // 检查看跌OB
   for(int i = 0; i < MaxOB_DisplayBear; i++) {
      if(bearOB[i].time_start == 0 || !bearOB[i].valid) continue;
      if(OnlyOneTrade && bearOB[i].traded) continue;
      
      if(ask >= bearOB[i].price_bottom && ask <= bearOB[i].price_top) {
         if(!bearOB[i].touched) {
            bearOB[i].touched = true;
            if(EnableAlert && !bearOB[i].alerted) {
               Alert("价格回弹到看跌OB: ", _Symbol, " @ ", DoubleToString(ask, _Digits));
               bearOB[i].alerted = true;
            }
         }
      }
      
      if(bearOB[i].touched && !bearOB[i].traded) {
         if(IsSwingReversalDown(rates)) {
            double sl = bid + StopLossPips * _Point;
            double tp = bid - TakeProfitPips * _Point;
            if(trade.Sell(LotSize, _Symbol, bid, sl, tp, TradeComment)) {
               bearOB[i].traded = true;
               last_entry_time = TimeCurrent();
               Print("看跌OB开仓成功 | 价格: ", bid, " | SL: ", sl, " | TP: ", tp);
            }
         }
      }
   }
   
   // 检查看涨FVG
   for(int i = 0; i < MaxFVG_Display; i++) {
      if(bullFVG[i].time_start == 0 || !bullFVG[i].valid) continue;
      if(OnlyOneTrade && bullFVG[i].traded) continue;
      
      if(bid <= bullFVG[i].price_top && bid >= bullFVG[i].price_bottom) {
         if(!bullFVG[i].touched) {
            bullFVG[i].touched = true;
            if(EnableAlert && !bullFVG[i].alerted) {
               Alert("价格回踩到看涨FVG: ", _Symbol, " @ ", DoubleToString(bid, _Digits));
               bullFVG[i].alerted = true;
            }
         }
      }
      
      if(bullFVG[i].touched && !bullFVG[i].traded) {
         if(IsSwingReversalUp(rates)) {
            double sl = ask - StopLossPips * _Point;
            double tp = ask + TakeProfitPips * _Point;
            if(trade.Buy(LotSize, _Symbol, ask, sl, tp, TradeComment)) {
               bullFVG[i].traded = true;
               last_entry_time = TimeCurrent();
               Print("看涨FVG开仓成功 | 价格: ", ask, " | SL: ", sl, " | TP: ", tp);
            }
         }
      }
   }
   
   // 检查看跌FVG
   for(int i = 0; i < MaxFVG_DisplayBear; i++) {
      if(bearFVG[i].time_start == 0 || !bearFVG[i].valid) continue;
      if(OnlyOneTrade && bearFVG[i].traded) continue;
      
      if(ask >= bearFVG[i].price_bottom && ask <= bearFVG[i].price_top) {
         if(!bearFVG[i].touched) {
            bearFVG[i].touched = true;
            if(EnableAlert && !bearFVG[i].alerted) {
               Alert("价格回弹到看跌FVG: ", _Symbol, " @ ", DoubleToString(ask, _Digits));
               bearFVG[i].alerted = true;
            }
         }
      }
      
      if(bearFVG[i].touched && !bearFVG[i].traded) {
         if(IsSwingReversalDown(rates)) {
            double sl = bid + StopLossPips * _Point;
            double tp = bid - TakeProfitPips * _Point;
            if(trade.Sell(LotSize, _Symbol, bid, sl, tp, TradeComment)) {
               bearFVG[i].traded = true;
               last_entry_time = TimeCurrent();
               Print("看跌FVG开仓成功 | 价格: ", bid, " | SL: ", sl, " | TP: ", tp);
            }
         }
      }
   }
}

//--- 判断向上结构反转：当前K线突破近期SwingBars内的最高点
bool IsSwingReversalUp(const MqlRates &rates[]) {
   double recent_high = rates[1].high;
   for(int i = 1; i <= SwingBars && i < ArraySize(rates); i++) {
      if(rates[i].high > recent_high) recent_high = rates[i].high;
   }
   
   if(RequireClose) {
      return (rates[0].close > recent_high);
   } else {
      return (rates[0].high > recent_high);
   }
}

//--- 判断向下结构反转：当前K线突破近期SwingBars内的最低点
bool IsSwingReversalDown(const MqlRates &rates[]) {
   double recent_low = rates[1].low;
   for(int i = 1; i <= SwingBars && i < ArraySize(rates); i++) {
      if(rates[i].low < recent_low) recent_low = rates[i].low;
   }
   
   if(RequireClose) {
      return (rates[0].close < recent_low);
   } else {
      return (rates[0].low < recent_low);
   }
}

//--- 判断两个区域是否重叠超过阈值
bool IsOverlapping(double top1, double bottom1, double top2, double bottom2) {
   double overlap_top = MathMin(top1, top2);
   double overlap_bottom = MathMax(bottom1, bottom2);
   
   if(overlap_top <= overlap_bottom) return false;
   
   double overlap_size = overlap_top - overlap_bottom;
   double zone1_size = top1 - bottom1;
   double zone2_size = top2 - bottom2;
   
   if(zone1_size <= 0 || zone2_size <= 0) return false;
   
   double overlap_pct1 = (overlap_size / zone1_size) * 100.0;
   double overlap_pct2 = (overlap_size / zone2_size) * 100.0;
   
   return (overlap_pct1 >= ZoneOverlapPct || overlap_pct2 >= ZoneOverlapPct);
}

//--- 删除已失效的区域（价格完全穿透）
void CleanInvalidZones() {
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   
   for(int i = 0; i < MaxOB_Display; i++) {
      if(bullOB[i].time_start == 0 || !bullOB[i].valid) continue;
      if(bid > bullOB[i].price_top + 50 * _Point) {
         if(bullOB[i].obj_name != "") ObjectDelete(0, bullOB[i].obj_name);
         bullOB[i].valid = false;
      }
   }
   
   for(int i = 0; i < MaxOB_DisplayBear; i++) {
      if(bearOB[i].time_start == 0 || !bearOB[i].valid) continue;
      if(bid < bearOB[i].price_bottom - 50 * _Point) {
         if(bearOB[i].obj_name != "") ObjectDelete(0, bearOB[i].obj_name);
         bearOB[i].valid = false;
      }
   }
   
   for(int i = 0; i < MaxFVG_Display; i++) {
      if(bullFVG[i].time_start == 0 || !bullFVG[i].valid) continue;
      if(bid > bullFVG[i].price_top + 50 * _Point) {
         if(bullFVG[i].obj_name != "") ObjectDelete(0, bullFVG[i].obj_name);
         bullFVG[i].valid = false;
      }
   }
   
   for(int i = 0; i < MaxFVG_DisplayBear; i++) {
      if(bearFVG[i].time_start == 0 || !bearFVG[i].valid) continue;
      if(bid < bearFVG[i].price_bottom - 50 * _Point) {
         if(bearFVG[i].obj_name != "") ObjectDelete(0, bearFVG[i].obj_name);
         bearFVG[i].valid = false;
      }
   }
}

//--- 画半透明矩形
void DrawZoneRect(string name, datetime start_time, double top, double bottom, color clr) {
   if(ObjectFind(0, name) >= 0) ObjectDelete(0, name);
   
   datetime end_time = TimeCurrent() + PeriodSeconds(PERIOD_CURRENT) * 1000;
   ObjectCreate(0, name, OBJ_RECTANGLE, 0, start_time, top, end_time, bottom);
   ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
   ObjectSetInteger(0, name, OBJPROP_FILL, true);
   ObjectSetInteger(0, name, OBJPROP_BACK, true);
   ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
   ObjectSetInteger(0, name, OBJPROP_HIDDEN, true);
   ObjectSetInteger(0, name, OBJPROP_WIDTH, 1);
   
   // 设置透明度
   int transparency = (int)MathRound((RectTransparency / 100.0) * 255);
   if(transparency < 0) transparency = 0;
   if(transparency > 255) transparency = 255;
   long alpha = 255 - transparency;
   ObjectSetInteger(0, name, OBJPROP_BGCOLOR, (alpha << 24) | (clr & 0xFFFFFF));
}