订单块（供需区）自动识别

#property copyright "Order Block Indicator"
#property link      ""
#property version   "1.00"
#property indicator_chart_window
#property indicator_plots 0

// ========== 可调参数 ==========
input int    MaxBlocks = 5;              // 最多显示订单块数量（推荐3-5个）
input int    ExtendBars = 50;            // 矩形向右延伸K线数（推荐30-100）
input double BreakoutMultiplier = 1.5;   // 突破强度最小倍数（突破K线长度需≥订单块K线×此倍数，推荐1.5-3.0）
input bool   AlertOnReturn = true;       // 价格回到区域时是否弹窗提醒
input color  BullishColor = clrLimeGreen;// 看涨订单块颜色
input color  BearishColor = clrRed;      // 看跌订单块颜色
input int    Transparency = 85;          // 矩形透明度（0-100，越大越透明）

// ========== 订单块结构 ==========
struct OrderBlock {
   int type;              // 1=看涨，-1=看跌，0=无效
   double priceTop;       // 矩形上边界
   double priceBottom;    // 矩形下边界
   datetime timeStart;    // 起始时间
   int barIndex;          // 订单块K线索引
   bool alerted;          // 是否已提醒
   string objectName;     // 矩形对象名称
};

OrderBlock blocks[];      // 存储所有订单块
int blockCount = 0;       // 当前订单块数量

//+------------------------------------------------------------------+
//| 初始化函数                                                          |
//+------------------------------------------------------------------+
int OnInit() {
   // 设置定时器，每秒检查一次价格回归提醒
   if(AlertOnReturn) {
      EventSetTimer(1);
   }
   
   // 初始化订单块数组
   ArrayResize(blocks, MaxBlocks);
   for(int i = 0; i < MaxBlocks; i++) {
      blocks[i].type = 0;
      blocks[i].alerted = false;
      blocks[i].objectName = "";
   }
   
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| 反初始化函数                                                        |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
   // 删除所有订单块矩形
   for(int i = 0; i < MaxBlocks; i++) {
      if(blocks[i].objectName != "") {
         ObjectDelete(0, blocks[i].objectName);
      }
   }
   
   // 删除定时器
   EventKillTimer();
}

//+------------------------------------------------------------------+
//| 主计算函数                                                          |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[]) {
   
   // 设置数组为时间序列（索引0是最新K线）
   ArraySetAsSeries(time, true);
   ArraySetAsSeries(open, true);
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(close, true);
   
   // 至少需要3根K线才能识别订单块
   if(rates_total < 3) return(0);
   
   // 从最近的K线开始扫描（跳过正在形成的K线0）
   int start = 1;
   if(prev_calculated > 0) {
      start = 1; // 每次只检查最近的几根K线
   }
   
   // 扫描新的订单块（从索引1到10，只识别最近形成的）
   for(int i = start; i < MathMin(10, rates_total - 1); i++) {
      // 检查看涨订单块：i-1是下跌K线，i是强势上涨突破前高
      if(i >= 1 && i < rates_total - 1) {
         double prevOpen = open[i];
         double prevClose = close[i];
         double prevHigh = high[i];
         double prevLow = low[i];
         
         double currOpen = open[i-1];
         double currClose = close[i-1];
         double currHigh = high[i-1];
         double currLow = low[i-1];
         
         // 看涨订单块识别：prev是下跌K线，curr是上涨K线且突破前高
         if(prevClose < prevOpen) { // prev是下跌K线
            double prevBodySize = prevOpen - prevClose;
            double currBodySize = MathAbs(currClose - currOpen);
            
            // 检查curr是否强势突破（上涨且突破前高，且强度足够）
            if(currClose > currOpen && 
               currHigh > prevHigh &&
               prevBodySize > 0 &&
               currBodySize >= prevBodySize * BreakoutMultiplier) {
               
               // 检查是否已存在相同位置的订单块
               bool exists = false;
               for(int j = 0; j < MaxBlocks; j++) {
                  if(blocks[j].type == 1 && 
                     MathAbs(blocks[j].timeStart - time[i]) < PeriodSeconds(PERIOD_CURRENT) * 2) {
                     exists = true;
                     break;
                  }
               }
               
               if(!exists) {
                  // 创建新的看涨订单块（使用prev的实体范围）
                  AddOrderBlock(1, prevOpen, prevClose, time[i], i);
               }
            }
         }
         
         // 看跌订单块识别：prev是上涨K线，curr是下跌K线且跌破前低
         if(prevClose > prevOpen) { // prev是上涨K线
            double prevBodySize = prevClose - prevOpen;
            double currBodySize = MathAbs(currClose - currOpen);
            
            // 检查curr是否强势跌破（下跌且跌破前低，且强度足够）
            if(currClose < currOpen && 
               currLow < prevLow &&
               prevBodySize > 0 &&
               currBodySize >= prevBodySize * BreakoutMultiplier) {
               
               // 检查是否已存在相同位置的订单块
               bool exists = false;
               for(int j = 0; j < MaxBlocks; j++) {
                  if(blocks[j].type == -1 && 
                     MathAbs(blocks[j].timeStart - time[i]) < PeriodSeconds(PERIOD_CURRENT) * 2) {
                     exists = true;
                     break;
                  }
               }
               
               if(!exists) {
                  // 创建新的看跌订单块（使用prev的实体范围）
                  AddOrderBlock(-1, prevClose, prevOpen, time[i], i);
               }
            }
         }
      }
   }
   
   // 更新所有订单块矩形位置和检查是否被突破
   UpdateOrderBlocks(time, close);
   
   return(rates_total);
}

//+------------------------------------------------------------------+
//| 添加新订单块                                                        |
//+------------------------------------------------------------------+
void AddOrderBlock(int type, double top, double bottom, datetime startTime, int barIdx) {
   // 确保top > bottom
   if(top < bottom) {
      double temp = top;
      top = bottom;
      bottom = temp;
   }
   
   // 查找空位或替换最老的订单块
   int idx = -1;
   for(int i = 0; i < MaxBlocks; i++) {
      if(blocks[i].type == 0) {
         idx = i;
         break;
      }
   }
   
   // 如果没有空位，删除最老的
   if(idx == -1) {
      idx = MaxBlocks - 1;
      if(blocks[idx].objectName != "") {
         ObjectDelete(0, blocks[idx].objectName);
      }
      
      // 向后移动数组
      for(int i = MaxBlocks - 1; i > 0; i--) {
         blocks[i] = blocks[i-1];
      }
      idx = 0;
   }
   
   // 创建新订单块
   blocks[idx].type = type;
   blocks[idx].priceTop = top;
   blocks[idx].priceBottom = bottom;
   blocks[idx].timeStart = startTime;
   blocks[idx].barIndex = barIdx;
   blocks[idx].alerted = false;
   blocks[idx].objectName = "OB_" + IntegerToString(type) + "_" + TimeToString(startTime, TIME_DATE|TIME_SECONDS);
   
   // 创建矩形对象
   CreateRectangle(blocks[idx]);
}

//+------------------------------------------------------------------+
//| 创建矩形对象                                                        |
//+------------------------------------------------------------------+
void CreateRectangle(OrderBlock &block) {
   datetime endTime = block.timeStart + PeriodSeconds(PERIOD_CURRENT) * ExtendBars;
   
   color rectColor = (block.type == 1) ? BullishColor : BearishColor;
   
   // 创建矩形
   ObjectCreate(0, block.objectName, OBJ_RECTANGLE, 0, block.timeStart, block.priceTop, endTime, block.priceBottom);
   ObjectSetInteger(0, block.objectName, OBJPROP_COLOR, rectColor);
   ObjectSetInteger(0, block.objectName, OBJPROP_STYLE, STYLE_SOLID);
   ObjectSetInteger(0, block.objectName, OBJPROP_WIDTH, 1);
   ObjectSetInteger(0, block.objectName, OBJPROP_FILL, true);
   ObjectSetInteger(0, block.objectName, OBJPROP_BACK, true);
   
   // 设置透明度（0-255，255是完全透明）
   int alpha = (int)((Transparency / 100.0) * 255);
   ObjectSetInteger(0, block.objectName, OBJPROP_BGCOLOR, ColorWithAlpha(rectColor, alpha));
   
   // 设置描述
   string desc = (block.type == 1) ? "看涨订单块" : "看跌订单块";
   ObjectSetString(0, block.objectName, OBJPROP_TOOLTIP, desc);
}

//+------------------------------------------------------------------+
//| 颜色透明度处理                                                      |
//+------------------------------------------------------------------+
color ColorWithAlpha(color baseColor, int alpha) {
   // MQL5的颜色格式：0xAARRGGBB
   int r = (baseColor & 0xFF);
   int g = ((baseColor >> 8) & 0xFF);
   int b = ((baseColor >> 16) & 0xFF);
   
   return (color)((alpha << 24) | (b << 16) | (g << 8) | r);
}

//+------------------------------------------------------------------+
//| 更新订单块并检查是否被突破                                            |
//+------------------------------------------------------------------+
void UpdateOrderBlocks(const datetime &time[], const double &close[]) {
   double currentPrice = close[0];
   
   for(int i = 0; i < MaxBlocks; i++) {
      if(blocks[i].type == 0) continue;
      
      // 更新矩形右边界时间
      datetime endTime = TimeCurrent() + PeriodSeconds(PERIOD_CURRENT) * ExtendBars;
      ObjectSetInteger(0, blocks[i].objectName, OBJPROP_TIME, 1, endTime);
      
      // 检查是否被完全突破
      bool breached = false;
      if(blocks[i].type == 1) {
         // 看涨订单块被向下突破
         if(currentPrice < blocks[i].priceBottom) {
            breached = true;
         }
      } else if(blocks[i].type == -1) {
         // 看跌订单块被向上突破
         if(currentPrice > blocks[i].priceTop) {
            breached = true;
         }
      }
      
      // 如果被突破，删除订单块
      if(breached) {
         ObjectDelete(0, blocks[i].objectName);
         blocks[i].type = 0;
         blocks[i].objectName = "";
      }
   }
}

//+------------------------------------------------------------------+
//| 定时器函数：检查价格是否回到订单块区域                                 |
//+------------------------------------------------------------------+
void OnTimer() {
   if(!AlertOnReturn) return;
   
   double currentPrice = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   
   for(int i = 0; i < MaxBlocks; i++) {
      if(blocks[i].type == 0) continue;
      
      // 检查价格是否在订单块范围内
      bool inZone = (currentPrice >= blocks[i].priceBottom && currentPrice <= blocks[i].priceTop);
      
      // 如果价格回到区域且未提醒过
      if(inZone && !blocks[i].alerted) {
         string alertMsg = "";
         if(blocks[i].type == 1) {
            alertMsg = "价格回到看涨订单块区域！\n价格: " + DoubleToString(currentPrice, _Digits) +
                      "\n区域: " + DoubleToString(blocks[i].priceBottom, _Digits) + " - " + DoubleToString(blocks[i].priceTop, _Digits);
         } else {
            alertMsg = "价格回到看跌订单块区域！\n价格: " + DoubleToString(currentPrice, _Digits) +
                      "\n区域: " + DoubleToString(blocks[i].priceBottom, _Digits) + " - " + DoubleToString(blocks[i].priceTop, _Digits);
         }
         
         Alert(alertMsg);
         blocks[i].alerted = true;
      }
      
      // 如果价格离开区域，重置提醒标志
      if(!inZone) {
         blocks[i].alerted = false;
      }
   }
}
//+------------------------------------------------------------------+