一键平仓 / 一键保本工具（二创）

// 基于 Smart Money Concept 理念的供需区域自动识别指标

// 功能：识别摆动高低点，绘制供需区矩形，标注 BOS/CHoCH

//+------------------------------------------------------------------+

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

//+------------------------------------------------------------------+

//| 输入参数                                                           |

//+------------------------------------------------------------------+

input int    InpSwingLength = 5;              // 摆动识别周期（左右各多少根K线）

input int    InpZoneThickness = 3;            // 供需区厚度（单位：点数）

input int    InpZoneExtendBars = 50;          // 区域向右延伸多少根K线

input color  InpDemandColor = clrDodgerBlue;  // 需求区颜色（支撑）

input color  InpSupplyColor = clrTomato;      // 供给区颜色（阻力）

input int    InpZoneTransparency = 85;        // 区域透明度（0-100，越大越透明）

input bool   InpShowLabels = true;            // 是否显示 BOS/CHoCH 标注

input int    InpMaxZones = 10;                // 最多显示多少个区域（0=不限制）

input bool   InpDeleteOldZones = true;        // 价格触及后是否删除旧区域


//--- 全局变量

struct ZoneInfo
{
   string   name;          // 对象名称

   double   price_top;     // 区域上边界

   double   price_bottom;  // 区域下边界

   datetime time_start;    // 开始时间

   bool     is_demand;     // true=需求区，false=供给区

   bool     touched;       // 是否已被触及

};

ZoneInfo g_zones[];        // 存储所有区域

int      g_zone_count = 0; // 当前区域数量

string   g_prefix = "SMZ_"; // 对象名称前缀


//+------------------------------------------------------------------+

//| 初始化函数                                                         |

//+------------------------------------------------------------------+

int OnInit()
{
   //--- 检查参数

   if(InpSwingLength < 1)
   {
      Print("错误：摆动周期必须 >= 1");
      return INIT_PARAMETERS_INCORRECT;
   }
   
   //--- 清理旧对象

   DeleteAllObjects();
   
   //--- 初始化数组

   ArrayResize(g_zones, 0);
   g_zone_count = 0;
   
   Print("Smart Money 供需区指标已加载");
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+

//| 反初始化函数                                                       |

//+------------------------------------------------------------------+

void OnDeinit(const int reason)
{
   //--- 清理所有绘制的对象

   DeleteAllObjects();
}

//+------------------------------------------------------------------+

//| 主计算函数                                                         |

//+------------------------------------------------------------------+

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 为最新）

   ArraySetAsSeries(time, true);
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   ArraySetAsSeries(close, true);
   
   //--- 需要至少有足够的K线

   if(rates_total < InpSwingLength * 2 + 10)
      return 0;
   
   //--- 计算开始位置

   int start = InpSwingLength + 1;
   int limit = rates_total - prev_calculated;
   
   // 首次运行或数据较多时，只扫描最近的K线

   if(limit > 100 || prev_calculated == 0)
      limit = 100;
   
   //--- 遍历K线，寻找摆动高低点

   for(int i = start; i < start + limit && i < rates_total - InpSwingLength - 1; i++)
   {
      //--- 检查是否是摆动高点（局部最高）

      bool is_swing_high = true;
      for(int j = 1; j <= InpSwingLength; j++)
      {
         if(i - j < 0 || i + j >= rates_total)
         {
            is_swing_high = false;
            break;
         }
         if(high[i] <= high[i - j] || high[i] <= high[i + j])
         {
            is_swing_high = false;
            break;
         }
      }
      
      //--- 如果是摆动高点，创建供给区

      if(is_swing_high)
      {
         double zone_top = high[i];
         double zone_bottom = zone_top - InpZoneThickness * _Point;
         
         // 检查是否已存在相似区域（避免重复）

         if(!ZoneExists(zone_top, zone_bottom, time[i]))
         {
            CreateZone(time[i], zone_top, zone_bottom, false); // false = 供给区

         }
      }
      
      //--- 检查是否是摆动低点（局部最低）

      bool is_swing_low = true;
      for(int j = 1; j <= InpSwingLength; j++)
      {
         if(i - j < 0 || i + j >= rates_total)
         {
            is_swing_low = false;
            break;
         }
         if(low[i] >= low[i - j] || low[i] >= low[i + j])
         {
            is_swing_low = false;
            break;
         }
      }
      
      //--- 如果是摆动低点，创建需求区

      if(is_swing_low)
      {
         double zone_bottom = low[i];
         double zone_top = zone_bottom + InpZoneThickness * _Point;
         
         if(!ZoneExists(zone_top, zone_bottom, time[i]))
         {
            CreateZone(time[i], zone_top, zone_bottom, true); // true = 需求区

         }
      }
   }
   
   //--- 检查价格是否触及区域（可选：触及后删除）

   if(InpDeleteOldZones)
   {
      CheckZonesTouched(close[0]);
   }
   
   return rates_total;
}

//+------------------------------------------------------------------+

//| 创建供需区矩形                                                     |

//+------------------------------------------------------------------+

void CreateZone(datetime start_time, double price_top, double price_bottom, bool is_demand)
{
   //--- 检查最大区域数量限制

   if(InpMaxZones > 0 && g_zone_count >= InpMaxZones)
   {
      // 删除最老的区域

      DeleteOldestZone();
   }
   
   //--- 生成唯一对象名

   string obj_name = g_prefix + (is_demand ? "D_" : "S_") + TimeToString(start_time, TIME_DATE | TIME_SECONDS);
   
   //--- 计算结束时间（向右延伸）

   datetime end_time = start_time + InpZoneExtendBars * PeriodSeconds();
   
   //--- 创建矩形对象

   if(ObjectCreate(0, obj_name, OBJ_RECTANGLE, 0, start_time, price_top, end_time, price_bottom))
   {
      color zone_color = is_demand ? InpDemandColor : InpSupplyColor;
      
      ObjectSetInteger(0, obj_name, OBJPROP_COLOR, zone_color);
      ObjectSetInteger(0, obj_name, OBJPROP_STYLE, STYLE_SOLID);
      ObjectSetInteger(0, obj_name, OBJPROP_WIDTH, 1);
      ObjectSetInteger(0, obj_name, OBJPROP_FILL, true);
      ObjectSetInteger(0, obj_name, OBJPROP_BACK, true);
      ObjectSetInteger(0, obj_name, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(0, obj_name, OBJPROP_HIDDEN, true);
      
      // 设置透明度（0-255，255为完全不透明）

      int alpha = (int)MathRound(255 * (100 - InpZoneTransparency) / 100.0);
      if(alpha < 0) alpha = 0;
      if(alpha > 255) alpha = 255;
      long color_with_alpha = (long)zone_color | ((long)alpha << 24);
      ObjectSetInteger(0, obj_name, OBJPROP_BGCOLOR, color_with_alpha);
      
      //--- 保存到数组

      int idx = g_zone_count;
      ArrayResize(g_zones, g_zone_count + 1);
      g_zones[idx].name = obj_name;
      g_zones[idx].price_top = price_top;
      g_zones[idx].price_bottom = price_bottom;
      g_zones[idx].time_start = start_time;
      g_zones[idx].is_demand = is_demand;
      g_zones[idx].touched = false;
      g_zone_count++;
      
      //--- 可选：添加文字标注

      if(InpShowLabels)
      {
         string label_name = obj_name + "_LBL";
         double label_price = is_demand ? price_bottom : price_top;
         string label_text = is_demand ? "Demand" : "Supply";
         
         if(ObjectCreate(0, label_name, OBJ_TEXT, 0, start_time, label_price))
         {
            ObjectSetString(0, label_name, OBJPROP_TEXT, label_text);
            ObjectSetInteger(0, label_name, OBJPROP_COLOR, zone_color);
            ObjectSetInteger(0, label_name, OBJPROP_FONTSIZE, 8);
            ObjectSetInteger(0, label_name, OBJPROP_ANCHOR, is_demand ? ANCHOR_LEFT_LOWER : ANCHOR_LEFT_UPPER);
            ObjectSetInteger(0, label_name, OBJPROP_SELECTABLE, false);
            ObjectSetInteger(0, label_name, OBJPROP_HIDDEN, true);
            ObjectSetInteger(0, label_name, OBJPROP_BACK, false);
         }
      }
   }
}

//+------------------------------------------------------------------+

//| 检查区域是否已存在（避免重复）                                      |

//+------------------------------------------------------------------+

bool ZoneExists(double price_top, double price_bottom, datetime check_time)
{
   double tolerance = 5 * _Point; // 容差范围

   
   for(int i = 0; i < g_zone_count; i++)
   {
      if(MathAbs(g_zones[i].price_top - price_top) < tolerance &&
         MathAbs(g_zones[i].price_bottom - price_bottom) < tolerance)
      {
         return true;
      }
   }
   return false;
}

//+------------------------------------------------------------------+

//| 检查价格是否触及区域                                               |

//+------------------------------------------------------------------+

void CheckZonesTouched(double current_price)
{
   for(int i = g_zone_count - 1; i >= 0; i--)
   {
      if(g_zones[i].touched)
         continue;
      
      // 判断价格是否进入区域

      if(current_price >= g_zones[i].price_bottom && current_price <= g_zones[i].price_top)
      {
         g_zones[i].touched = true;
         
         // 删除该区域对象

         ObjectDelete(0, g_zones[i].name);
         ObjectDelete(0, g_zones[i].name + "_LBL");
         
         // 从数组中移除

         for(int j = i; j < g_zone_count - 1; j++)
         {
            g_zones[j] = g_zones[j + 1];
         }
         ArrayResize(g_zones, g_zone_count - 1);
         g_zone_count--;
      }
   }
}

//+------------------------------------------------------------------+

//| 删除最老的区域                                                     |

//+------------------------------------------------------------------+

void DeleteOldestZone()
{
   if(g_zone_count == 0)
      return;
   
   // 找到时间最早的区域

   int oldest_idx = 0;
   datetime oldest_time = g_zones[0].time_start;
   
   for(int i = 1; i < g_zone_count; i++)
   {
      if(g_zones[i].time_start < oldest_time)
      {
         oldest_time = g_zones[i].time_start;
         oldest_idx = i;
      }
   }
   
   // 删除对象

   ObjectDelete(0, g_zones[oldest_idx].name);
   ObjectDelete(0, g_zones[oldest_idx].name + "_LBL");
   
   // 从数组中移除

   for(int i = oldest_idx; i < g_zone_count - 1; i++)
   {
      g_zones[i] = g_zones[i + 1];
   }
   ArrayResize(g_zones, g_zone_count - 1);
   g_zone_count--;
}

//+------------------------------------------------------------------+

//| 清理所有对象                                                       |

//+------------------------------------------------------------------+

void DeleteAllObjects()
{
   int total = ObjectsTotal(0, 0, OBJ_RECTANGLE);
   for(int i = total - 1; i >= 0; i--)
   {
      string name = ObjectName(0, i, 0, OBJ_RECTANGLE);
      if(StringFind(name, g_prefix) == 0)
      {
         ObjectDelete(0, name);
         ObjectDelete(0, name + "_LBL");
      }
   }
   
   total = ObjectsTotal(0, 0, OBJ_TEXT);
   for(int i = total - 1; i >= 0; i--)
   {
      string name = ObjectName(0, i, 0, OBJ_TEXT);
      if(StringFind(name, g_prefix) == 0)
         ObjectDelete(0, name);
   }
}
//+------------------------------------------------------------------+