SMC 机构级交易指标

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

//--- 输入参数
input group "=== 核心设置 ==="
input int    SwingStrength = 7;           // 结构强度（左右确认 K 线数）
input double MinOBBodyPips = 10;          // 订单块最小实体（点数）
input double MinFVGSizePips = 8;          // FVG 最小尺寸（点数）
input bool   AutoRemoveInvalidOB = true;  // 自动移除失效订单块
input int    MaxActiveOB = 8;             // 最多显示订单块数量
input int    MaxActiveFVG = 6;            // 最多显示 FVG 数量

input group "=== 显示选项 ==="
input bool   ShowSwingPoints = false;     // 显示结构高低点（默认关闭）
input bool   ShowOrderBlocks = true;      // 显示订单块
input bool   ShowFVG = true;              // 显示公允价值缺口
input bool   ShowOBLabels = true;         // 显示订单块标签
input int    OBExtendBars = 100;          // 订单块延伸长度

input group "=== 专业配色 ==="
input color  BullOBColor = C'30,144,255'; // 看涨订单块（深蓝）
input color  BearOBColor = C'220,20,60';  // 看跌订单块（深红）
input color  BullFVGColor = C'64,224,208';// 看涨 FVG（青绿）
input color  BearFVGColor = C'255,182,193';// 看跌 FVG（浅粉）
input int    OBTransparency = 85;         // 订单块透明度（0-100）
input int    FVGTransparency = 90;        // FVG 透明度（0-100）

//--- 订单块结构
struct OrderBlock
{
   datetime time;
   double   top;
   double   bottom;
   bool     isBullish;
   string   objName;
   bool     isValid;
   double   strength;  // 强度评分
};

OrderBlock activeOBs[];
int obCount = 0;

//--- FVG 结构
struct FairValueGap
{
   datetime time;
   double   top;
   double   bottom;
   bool     isBullish;
   string   objName;
   bool     isValid;
};

FairValueGap activeFVGs[];
int fvgCount = 0;

//+------------------------------------------------------------------+
//| 初始化函数                                                        |
//+------------------------------------------------------------------+
int OnInit()
{
   ArrayResize(activeOBs, 0);
   ArrayResize(activeFVGs, 0);
   obCount = 0;
   fvgCount = 0;
   
   // 清理旧对象
   ObjectsDeleteAll(0, "SMC_");
   
   // 扫描历史
   ScanHistoricalData();
   
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| 计算函数                                                          |
//+------------------------------------------------------------------+
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 < SwingStrength * 2 + 10) return 0;
   
   static datetime lastProcessed = 0;
   datetime currentBar = time[rates_total - 1];
   if(currentBar == lastProcessed) return rates_total;
   lastProcessed = currentBar;
   
   // 检查确认 K 线位置
   int checkBar = rates_total - SwingStrength - 2;
   if(checkBar < SwingStrength + 3) return rates_total;
   
   // 1. 验证现有订单块是否仍然有效
   if(AutoRemoveInvalidOB)
   {
      ValidateOrderBlocks(close[rates_total - 1]);
   }
   
   // 2. 检测新订单块
   if(ShowOrderBlocks)
   {
      DetectNewOrderBlock(checkBar, time, open, high, low, close);
   }
   
   // 3. 检测新 FVG
   if(ShowFVG)
   {
      DetectNewFVG(checkBar, time, high, low);
   }
   
   // 4. 检测结构点（可选）
   if(ShowSwingPoints)
   {
      DetectSwingPoints(checkBar, rates_total, time, high, low);
   }
   
   return rates_total;
}

//+------------------------------------------------------------------+
//| 扫描历史数据                                                      |
//+------------------------------------------------------------------+
void ScanHistoricalData()
{
   int lookback = 500;
   MqlRates rates[];
   ArraySetAsSeries(rates, true);
   
   int copied = CopyRates(_Symbol, PERIOD_CURRENT, 0, lookback, rates);
   if(copied <= SwingStrength + 10)
   {
      Print("数据不足，无法扫描历史");
      return;
   }
   
   // 从老到新扫描（倒序索引）
   for(int i = copied - SwingStrength - 3; i >= SwingStrength + 2; i--)
   {
      // 检测订单块
      if(ShowOrderBlocks)
      {
         CheckOBInHistory(i, rates);
      }
      
      // 检测 FVG
      if(ShowFVG)
      {
         CheckFVGInHistory(i, rates);
      }
   }
   
   // 只保留最强的几个
   FilterTopOrderBlocks();
   FilterTopFVGs();
   
   Print(StringFormat("已加载 %d 个订单块，%d 个 FVG", obCount, fvgCount));
}

//+------------------------------------------------------------------+
//| 历史订单块检测                                                    |
//+------------------------------------------------------------------+
void CheckOBInHistory(int idx, const MqlRates &rates[])
{
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   double minBody = MinOBBodyPips * point;
   
   // 看涨订单块：idx 大阳线吞没 idx+1 阴线
   bool isBullOB = false;
   double body1 = MathAbs(rates[idx + 1].close - rates[idx + 1].open);
   double body2 = rates[idx].close - rates[idx].open;
   
   if(rates[idx + 1].close < rates[idx + 1].open &&  // idx+1 是阴线
      rates[idx].close > rates[idx].open &&           // idx 是阳线
      body2 > minBody &&                              // 阳线实体够大
      rates[idx].close > rates[idx + 1].high)         // 吞没前高
   {
      isBullOB = true;
   }
   
   // 看跌订单块：idx 大阴线吞没 idx+1 阳线
   bool isBearOB = false;
   double body3 = rates[idx].open - rates[idx].close;
   
   if(rates[idx + 1].close > rates[idx + 1].open &&  // idx+1 是阳线
      rates[idx].close < rates[idx].open &&           // idx 是阴线
      body3 > minBody &&                              // 阴线实体够大
      rates[idx].close < rates[idx + 1].low)          // 吞没前低
   {
      isBearOB = true;
   }
   
   // 创建订单块
   if(isBullOB || isBearOB)
   {
      OrderBlock ob;
      ob.time = rates[idx + 1].time;
      ob.top = rates[idx + 1].high;
      ob.bottom = rates[idx + 1].low;
      ob.isBullish = isBullOB;
      ob.isValid = true;
      ob.strength = isBullOB ? body2 / point : body3 / point;
      ob.objName = "SMC_OB_" + TimeToString(ob.time, TIME_DATE|TIME_MINUTES);
      
      // 检查是否已存在
      bool exists = false;
      for(int j = 0; j < obCount; j++)
      {
         if(activeOBs[j].objName == ob.objName)
         {
            exists = true;
            break;
         }
      }
      
      if(!exists && obCount < 100)
      {
         ArrayResize(activeOBs, obCount + 1);
         activeOBs[obCount] = ob;
         obCount++;
      }
   }
}

//+------------------------------------------------------------------+
//| 历史 FVG 检测                                                     |
//+------------------------------------------------------------------+
void CheckFVGInHistory(int idx, const MqlRates &rates[])
{
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   double minSize = MinFVGSizePips * point;
   
   // 看涨 FVG：idx+2.high < idx.low
   if(rates[idx + 2].high < rates[idx].low)
   {
      double gapSize = rates[idx].low - rates[idx + 2].high;
      if(gapSize >= minSize)
      {
         FairValueGap fvg;
         fvg.time = rates[idx + 1].time;
         fvg.top = rates[idx].low;
         fvg.bottom = rates[idx + 2].high;
         fvg.isBullish = true;
         fvg.isValid = true;
         fvg.objName = "SMC_FVG_" + TimeToString(rates[idx].time, TIME_DATE|TIME_MINUTES);
         
         bool exists = false;
         for(int j = 0; j < fvgCount; j++)
         {
            if(activeFVGs[j].objName == fvg.objName)
            {
               exists = true;
               break;
            }
         }
         
         if(!exists && fvgCount < 100)
         {
            ArrayResize(activeFVGs, fvgCount + 1);
            activeFVGs[fvgCount] = fvg;
            fvgCount++;
         }
      }
   }
   
   // 看跌 FVG：idx+2.low > idx.high
   if(rates[idx + 2].low > rates[idx].high)
   {
      double gapSize = rates[idx + 2].low - rates[idx].high;
      if(gapSize >= minSize)
      {
         FairValueGap fvg;
         fvg.time = rates[idx + 1].time;
         fvg.top = rates[idx + 2].low;
         fvg.bottom = rates[idx].high;
         fvg.isBullish = false;
         fvg.isValid = true;
         fvg.objName = "SMC_FVG_" + TimeToString(rates[idx].time, TIME_DATE|TIME_MINUTES);
         
         bool exists = false;
         for(int j = 0; j < fvgCount; j++)
         {
            if(activeFVGs[j].objName == fvg.objName)
            {
               exists = true;
               break;
            }
         }
         
         if(!exists && fvgCount < 100)
         {
            ArrayResize(activeFVGs, fvgCount + 1);
            activeFVGs[fvgCount] = fvg;
            fvgCount++;
         }
      }
   }
}

//+------------------------------------------------------------------+
//| 只保留最强的订单块                                                |
//+------------------------------------------------------------------+
void FilterTopOrderBlocks()
{
   if(obCount <= MaxActiveOB) 
   {
      DrawAllOrderBlocks();
      return;
   }
   
   // 按强度排序（冒泡排序）
   for(int i = 0; i < obCount - 1; i++)
   {
      for(int j = 0; j < obCount - i - 1; j++)
      {
         if(activeOBs[j].strength < activeOBs[j + 1].strength)
         {
            OrderBlock temp = activeOBs[j];
            activeOBs[j] = activeOBs[j + 1];
            activeOBs[j + 1] = temp;
         }
      }
   }
   
   // 只保留前 MaxActiveOB 个
   ArrayResize(activeOBs, MaxActiveOB);
   obCount = MaxActiveOB;
   
   DrawAllOrderBlocks();
}

//+------------------------------------------------------------------+
//| 只保留最近的 FVG                                                  |
//+------------------------------------------------------------------+
void FilterTopFVGs()
{
   if(fvgCount <= MaxActiveFVG)
   {
      DrawAllFVGs();
      return;
   }
   
   // 只保留最新的
   ArrayResize(activeFVGs, MaxActiveFVG);
   fvgCount = MaxActiveFVG;
   
   DrawAllFVGs();
}

//+------------------------------------------------------------------+
//| 绘制所有订单块                                                    |
//+------------------------------------------------------------------+
void DrawAllOrderBlocks()
{
   for(int i = 0; i < obCount; i++)
   {
      if(!activeOBs[i].isValid) continue;
      
      datetime t2 = activeOBs[i].time + PeriodSeconds(PERIOD_CURRENT) * OBExtendBars;
      
      if(ObjectFind(0, activeOBs[i].objName) < 0)
      {
         ObjectCreate(0, activeOBs[i].objName, OBJ_RECTANGLE, 0, 
                     activeOBs[i].time, activeOBs[i].top, 
                     t2, activeOBs[i].bottom);
         
         color clr = activeOBs[i].isBullish ? BullOBColor : BearOBColor;
         ObjectSetInteger(0, activeOBs[i].objName, OBJPROP_COLOR, clr);
         ObjectSetInteger(0, activeOBs[i].objName, OBJPROP_FILL, true);
         ObjectSetInteger(0, activeOBs[i].objName, OBJPROP_BACK, true);
         ObjectSetInteger(0, activeOBs[i].objName, OBJPROP_WIDTH, 2);
         ObjectSetInteger(0, activeOBs[i].objName, OBJPROP_STYLE, STYLE_SOLID);
         
         // 设置透明度
         long rgb = ObjectGetInteger(0, activeOBs[i].objName, OBJPROP_COLOR);
         long alpha = (100 - OBTransparency) * 255 / 100;
         ObjectSetInteger(0, activeOBs[i].objName, OBJPROP_COLOR, (alpha << 24) | rgb);
         
         // 添加标签
         if(ShowOBLabels)
         {
            string label = activeOBs[i].objName + "_L";
            double labelPrice = activeOBs[i].isBullish ? activeOBs[i].bottom : activeOBs[i].top;
            ObjectCreate(0, label, OBJ_TEXT, 0, activeOBs[i].time, labelPrice);
            ObjectSetString(0, label, OBJPROP_TEXT, activeOBs[i].isBullish ? "OB↑" : "OB↓");
            ObjectSetInteger(0, label, OBJPROP_COLOR, clr);
            ObjectSetInteger(0, label, OBJPROP_FONTSIZE, 8);
            ObjectSetInteger(0, label, OBJPROP_ANCHOR, activeOBs[i].isBullish ? ANCHOR_TOP : ANCHOR_BOTTOM);
         }
      }
   }
}

//+------------------------------------------------------------------+
//| 绘制所有 FVG                                                      |
//+------------------------------------------------------------------+
void DrawAllFVGs()
{
   for(int i = 0; i < fvgCount; i++)
   {
      if(!activeFVGs[i].isValid) continue;
      
      datetime t2 = activeFVGs[i].time + PeriodSeconds(PERIOD_CURRENT) * (OBExtendBars / 2);
      
      if(ObjectFind(0, activeFVGs[i].objName) < 0)
      {
         ObjectCreate(0, activeFVGs[i].objName, OBJ_RECTANGLE, 0,
                     activeFVGs[i].time, activeFVGs[i].top,
                     t2, activeFVGs[i].bottom);
         
         color clr = activeFVGs[i].isBullish ? BullFVGColor : BearFVGColor;
         ObjectSetInteger(0, activeFVGs[i].objName, OBJPROP_COLOR, clr);
         ObjectSetInteger(0, activeFVGs[i].objName, OBJPROP_FILL, true);
         ObjectSetInteger(0, activeFVGs[i].objName, OBJPROP_BACK, true);
         ObjectSetInteger(0, activeFVGs[i].objName, OBJPROP_WIDTH, 1);
         ObjectSetInteger(0, activeFVGs[i].objName, OBJPROP_STYLE, STYLE_DOT);
         
         // 透明度
         long rgb = ObjectGetInteger(0, activeFVGs[i].objName, OBJPROP_COLOR);
         long alpha = (100 - FVGTransparency) * 255 / 100;
         ObjectSetInteger(0, activeFVGs[i].objName, OBJPROP_COLOR, (alpha << 24) | rgb);
      }
   }
}

//+------------------------------------------------------------------+
//| 验证订单块是否仍然有效                                            |
//+------------------------------------------------------------------+
void ValidateOrderBlocks(double currentPrice)
{
   for(int i = 0; i < obCount; i++)
   {
      if(!activeOBs[i].isValid) continue;
      
      // 看涨订单块被完全跌破 = 失效
      if(activeOBs[i].isBullish && currentPrice < activeOBs[i].bottom)
      {
         activeOBs[i].isValid = false;
         ObjectDelete(0, activeOBs[i].objName);
         ObjectDelete(0, activeOBs[i].objName + "_L");
      }
      
      // 看跌订单块被完全突破 = 失效
      if(!activeOBs[i].isBullish && currentPrice > activeOBs[i].top)
      {
         activeOBs[i].isValid = false;
         ObjectDelete(0, activeOBs[i].objName);
         ObjectDelete(0, activeOBs[i].objName + "_L");
      }
   }
}

//+------------------------------------------------------------------+
//| 实时检测新订单块                                                  |
//+------------------------------------------------------------------+
void DetectNewOrderBlock(int bar, const datetime &time[], const double &open[],
                        const double &high[], const double &low[], const double &close[])
{
   if(bar < 2) return;
   
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   double minBody = MinOBBodyPips * point;
   
   double body = MathAbs(close[bar] - open[bar]);
   if(body < minBody) return;
   
   // 看涨 OB
   if(close[bar] > open[bar] && 
      close[bar] > high[bar - 1] &&
      close[bar - 1] < open[bar - 1])
   {
      AddOrderBlock(time[bar - 1], high[bar - 1], low[bar - 1], true, body / point);
   }
   
   // 看跌 OB
   if(close[bar] < open[bar] && 
      close[bar] < low[bar - 1] &&
      close[bar - 1] > open[bar - 1])
   {
      AddOrderBlock(time[bar - 1], high[bar - 1], low[bar - 1], false, body / point);
   }
}

//+------------------------------------------------------------------+
//| 添加订单块                                                        |
//+------------------------------------------------------------------+
void AddOrderBlock(datetime t, double top, double bottom, bool bull, double strength)
{
   if(obCount >= MaxActiveOB) return;
   
   OrderBlock ob;
   ob.time = t;
   ob.top = top;
   ob.bottom = bottom;
   ob.isBullish = bull;
   ob.isValid = true;
   ob.strength = strength;
   ob.objName = "SMC_OB_" + TimeToString(t, TIME_DATE|TIME_MINUTES);
   
   // 检查重复
   for(int i = 0; i < obCount; i++)
   {
      if(activeOBs[i].objName == ob.objName) return;
   }
   
   ArrayResize(activeOBs, obCount + 1);
   activeOBs[obCount] = ob;
   obCount++;
   
   DrawAllOrderBlocks();
}

//+------------------------------------------------------------------+
//| 实时检测 FVG                                                      |
//+------------------------------------------------------------------+
void DetectNewFVG(int bar, const datetime &time[], const double &high[], const double &low[])
{
   if(bar < 2) return;
   
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   double minSize = MinFVGSizePips * point;
   
   // 看涨 FVG
   if(high[bar - 2] < low[bar])
   {
      double gap = low[bar] - high[bar - 2];
      if(gap >= minSize)
      {
         AddFVG(time[bar - 1], low[bar], high[bar - 2], true);
      }
   }
   
   // 看跌 FVG
   if(low[bar - 2] > high[bar])
   {
      double gap = low[bar - 2] - high[bar];
      if(gap >= minSize)
      {
         AddFVG(time[bar - 1], low[bar - 2], high[bar], false);
      }
   }
}

//+------------------------------------------------------------------+
//| 添加 FVG                                                          |
//+------------------------------------------------------------------+
void AddFVG(datetime t, double top, double bottom, bool bull)
{
   if(fvgCount >= MaxActiveFVG) return;
   
   FairValueGap fvg;
   fvg.time = t;
   fvg.top = top;
   fvg.bottom = bottom;
   fvg.isBullish = bull;
   fvg.isValid = true;
   fvg.objName = "SMC_FVG_" + TimeToString(t, TIME_DATE|TIME_MINUTES);
   
   for(int i = 0; i < fvgCount; i++)
   {
      if(activeFVGs[i].objName == fvg.objName) return;
   }
   
   ArrayResize(activeFVGs, fvgCount + 1);
   activeFVGs[fvgCount] = fvg;
   fvgCount++;
   
   DrawAllFVGs();
}

//+------------------------------------------------------------------+
//| 检测结构点                                                        |
//+------------------------------------------------------------------+
void DetectSwingPoints(int bar, int total, const datetime &time[],
                       const double &high[], const double &low[])
{
   if(bar < SwingStrength || bar + SwingStrength >= total) return;
   
   bool isHigh = true;
   for(int i = 1; i <= SwingStrength; i++)
   {
      if(high[bar - i] > high[bar] || high[bar + i] >= high[bar])
      {
         isHigh = false;
         break;
      }
   }
   
   bool isLow = true;
   for(int i = 1; i <= SwingStrength; i++)
   {
      if(low[bar - i] < low[bar] || low[bar + i] <= low[bar])
      {
         isLow = false;
         break;
      }
   }
   
   if(isHigh)
   {
      string name = "SMC_SwH_" + TimeToString(time[bar], TIME_DATE|TIME_MINUTES);
      if(ObjectFind(0, name) < 0)
      {
         ObjectCreate(0, name, OBJ_ARROW_DOWN, 0, time[bar], high[bar]);
         ObjectSetInteger(0, name, OBJPROP_COLOR, clrDarkRed);
         ObjectSetInteger(0, name, OBJPROP_WIDTH, 1);
      }
   }
   
   if(isLow)
   {
      string name = "SMC_SwL_" + TimeToString(time[bar], TIME_DATE|TIME_MINUTES);
      if(ObjectFind(0, name) < 0)
      {
         ObjectCreate(0, name, OBJ_ARROW_UP, 0, time[bar], low[bar]);
         ObjectSetInteger(0, name, OBJPROP_COLOR, clrDarkGreen);
         ObjectSetInteger(0, name, OBJPROP_WIDTH, 1);
      }
   }
}

//+------------------------------------------------------------------+
//| 清理函数                                                          |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   ObjectsDeleteAll(0, "SMC_");
   Comment("");
}