智能订单块自动识别指标

#property copyright "XAUOF 指标工坊"
#property version   "1.00"
#property strict
#property indicator_chart_window
#property indicator_buffers 0
#property indicator_plots   0

// ==================== 输入参数 ====================
input int    InpLookback       = 300;             // 回溯K线数：扫描最近多少根K线寻找订单块，推荐 200-500
input int    InpMaxBlocks      = 5;               // 最大显示数量：图上最多同时保留几个订单块，推荐 3-10
input color  InpBullColor      = clrDodgerBlue;   // 看涨订单块颜色：推荐 DodgerBlue 或 LimeGreen
input color  InpBearColor      = clrCrimson;      // 看跌订单块颜色：推荐 Crimson 或 OrangeRed
input int    InpRectAlpha      = 40;              // 矩形透明度：0完全透明~255完全不透明，推荐 30-60
input bool   InpEnableAlert    = true;            // 是否开启弹窗提醒：价格回到订单块区域时弹窗
input int    InpAlertCooldown  = 10;              // 提醒冷却时间(分钟)：同一订单块多久内不重复弹窗，推荐 5-15

// ==================== 全局变量 ====================
struct OrderBlock
{
   string   name;          // 图表对象名称
   bool     isBullish;     // true=看涨, false=看跌
   double   topPrice;      // 区域上沿价格
   double   bottomPrice;   // 区域下沿价格
   datetime startTime;     // 订单块起始时间
   bool     alerted;       // 本轮是否已提醒过
};

OrderBlock g_blocks[];     // 存储当前所有订单块的数组
string     g_prefix = "OB_XAUOF_"; // 对象名称前缀，防止与其他指标冲突

//+------------------------------------------------------------------+
//| 初始化函数                                                        |
//+------------------------------------------------------------------+
int OnInit()
{
   // 清除可能残留的旧对象
   ObjectsDeleteAll(0, g_prefix);
   ArrayFree(g_blocks);
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| 反初始化函数：卸载指标时清理图表上的矩形                           |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   ObjectsDeleteAll(0, g_prefix);
}

//+------------------------------------------------------------------+
//| 主计算函数（MQL5 指标必须实现）                                    |
//+------------------------------------------------------------------+
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[])
{
   if(rates_total < 5) return 0;

   // 只在每根新K线开盘时重新扫描一次，避免逐笔跳动导致频繁重绘和卡顿
   static datetime s_lastBarTime = 0;
   if(time[rates_total - 1] == s_lastBarTime)
   {
      // 非新K线时，仅检查价格是否进入已有订单块以触发提醒
      CheckAlerts(close[rates_total - 1], time[rates_total - 1]);
      return rates_total;
   }
   s_lastBarTime = time[rates_total - 1];

   // 第一步：删除旧的订单块对象和数组
   ObjectsDeleteAll(0, g_prefix);
   ArrayFree(g_blocks);

   // 第二步：扫描并识别新的订单块
   ScanOrderBlocks(rates_total, time, open, high, low, close);

   // 第三步：将识别到的订单块画到图表上
   DrawOrderBlocks();

   // 第四步：检查当前价格是否在某个订单块内，触发提醒
   CheckAlerts(close[rates_total - 1], time[rates_total - 1]);

   return rates_total;
}

//+------------------------------------------------------------------+
//| 核心逻辑：扫描历史K线，寻找看涨和看跌订单块                        |
//+------------------------------------------------------------------+
void ScanOrderBlocks(int rates_total,
                     const datetime &time[],
                     const double &open[],
                     const double &high[],
                     const double &low[],
                     const double &close[])
{
   // 确定扫描起点，防止数组越界
   int startIdx = rates_total - InpLookback;
   if(startIdx < 2) startIdx = 2;
   
   // 终点留一根K线余量，因为需要看后面的K线是否突破了它
   int endIdx = rates_total - 2;

   for(int i = startIdx; i <= endIdx; i++)
   {
      // 限制最大数量，达到上限就不再找了
      if(ArraySize(g_blocks) >= InpMaxBlocks) break;

      // --------------------------------------------------
      // 1. 寻找看涨订单块 (Bullish Order Block)
      // 条件：当前K线是阴线（收盘<开盘），且后面某根K线的收盘价突破了这根阴线的最高价
      // --------------------------------------------------
      if(close[i] < open[i]) 
      {
         bool broken = false;
         // 向后最多找 50 根 K 线看有没有突破
         int searchLimit = i + 50;
         if(searchLimit > rates_total - 1) searchLimit = rates_total - 1;
         
         for(int j = i + 1; j <= searchLimit; j++)
         {
            if(close[j] > high[i]) // 阳线实体突破阴线最高点，确认订单块有效
            {
               broken = true;
               break;
            }
         }
         
         if(broken)
         {
            AddBlock(true, high[i], low[i], time[i]);
         }
      }

      // --------------------------------------------------
      // 2. 寻找看跌订单块 (Bearish Order Block)
      // 条件：当前K线是阳线（收盘>开盘），且后面某根K线的收盘价跌破了这根阳线的最低价
      // --------------------------------------------------
      if(close[i] > open[i])
      {
         bool broken = false;
         int searchLimit = i + 50;
         if(searchLimit > rates_total - 1) searchLimit = rates_total - 1;
         
         for(int j = i + 1; j <= searchLimit; j++)
         {
            if(close[j] < low[i]) // 阴线实体跌破阳线最低点，确认订单块有效
            {
               broken = true;
               break;
            }
         }
         
         if(broken)
         {
            AddBlock(false, high[i], low[i], time[i]);
         }
      }
   }
}

//+------------------------------------------------------------------+
//| 辅助函数：将一个识别出的订单块加入数组（带去重判断）                 |
//+------------------------------------------------------------------+
void AddBlock(bool isBullish, double top, double bottom, datetime tStart)
{
   // 防止除数为0及无效价格
   if(top <= 0 || bottom <= 0 || top < bottom) return;

   // 简单去重：如果价格区间和时间与已有的高度重合，就不重复添加
   for(int k = 0; k < ArraySize(g_blocks); k++)
   {
      if(MathAbs(g_blocks[k].topPrice - top) < 10 * _Point && 
         g_blocks[k].startTime == tStart)
      {
         return; 
      }
   }

   int size = ArraySize(g_blocks);
   ArrayResize(g_blocks, size + 1);
   
   g_blocks[size].isBullish    = isBullish;
   g_blocks[size].topPrice     = top;
   g_blocks[size].bottomPrice  = bottom;
   g_blocks[size].startTime    = tStart;
   g_blocks[size].alerted      = false;
   g_blocks[size].name         = g_prefix + IntegerToString(tStart) + "_" + IntegerToString(size);
}

//+------------------------------------------------------------------+
//| 绘图函数：把数组里的订单块画成半透明矩形                            |
//+------------------------------------------------------------------+
void DrawOrderBlocks()
{
   for(int i = 0; i < ArraySize(g_blocks); i++)
   {
      string name   = g_blocks[i].name;
      color  rColor = g_blocks[i].isBullish ? InpBullColor : InpBearColor;
      
      // 矩形起点为订单块形成的K线时间，终点延伸到图表最右侧
      datetime t1 = g_blocks[i].startTime;
      datetime t2 = TimeCurrent() + PeriodSeconds() * 20; 

      // 创建矩形对象
      ObjectCreate(0, name, OBJ_RECTANGLE, 0, t1, g_blocks[i].topPrice, t2, g_blocks[i].bottomPrice);
      
      // 设置边框颜色和填充颜色一致
      ObjectSetInteger(0, name, OBJPROP_COLOR, rColor);
      ObjectSetInteger(0, name, OBJPROP_FILL, true);           // 开启填充
      ObjectSetInteger(0, name, OBJPROP_BACK, true);           // 放在K线背景层，不遮挡K线
      
      // 设置透明度 (0-255)
      int alpha = InpRectAlpha;
      if(alpha < 0) alpha = 0;
      if(alpha > 255) alpha = 255;
      ObjectSetInteger(0, name, OBJPROP_BGCOLOR, ColorToARGB(rColor, alpha));
      
      // 边框设为虚线更美观
      ObjectSetInteger(0, name, OBJPROP_STYLE, STYLE_DASH);
      ObjectSetInteger(0, name, OBJPROP_WIDTH, 1);
      
      // 设置鼠标悬停时的提示文字
      string tip = (g_blocks[i].isBullish ? "【看涨订单块】" : "【看跌订单块】") + 
                   "\n上沿: " + DoubleToString(g_blocks[i].topPrice, _Digits) +
                   "\n下沿: " + DoubleToString(g_blocks[i].bottomPrice, _Digits);
      ObjectSetString(0, name, OBJPROP_TOOLTIP, tip);
   }
}

//+------------------------------------------------------------------+
//| 提醒函数：判断当前价格是否进入了某个订单块区域                      |
//+------------------------------------------------------------------+
void CheckAlerts(double currentPrice, datetime currentTime)
{
   if(!InpEnableAlert) return;

   for(int i = 0; i < ArraySize(g_blocks); i++)
   {
      double top = g_blocks[i].topPrice;
      double bot = g_blocks[i].bottomPrice;

      // 判断当前价格是否在订单块的上下沿之间
      if(currentPrice >= bot && currentPrice <= top)
      {
         if(!g_blocks[i].alerted)
         {
            string typeStr = g_blocks[i].isBullish ? "看涨(做多)" : "看跌(做空)";
            string msg = StringFormat("XAUOF订单块提醒: %s 价格已进入 %s 订单块区域! [%.2f - %.2f]", 
                                      _Symbol, typeStr, bot, top);
            
            Alert(msg);        // 弹窗提醒
            PlaySound("alert.wav"); // 播放声音
            
            g_blocks[i].alerted = true; // 标记为已提醒，防止疯狂弹窗
         }
      }
      else
      {
         // 价格离开订单块区域后，重置提醒状态，下次再进来还能提醒
         if(g_blocks[i].alerted)
         {
            // 可选：加入冷却时间判断，这里简化处理，离开即重置
            g_blocks[i].alerted = false;
         }
      }
   }
}
//+------------------------------------------------------------------+