Smart Money 供需区 + 买卖信号指标

// 基于 XAUOF 社区作品 #15《一键平仓 / 一键保本工具（二创）》（作者 123456789）二次创作
// 本次改动：
// 1. 新增买入/卖出信号箭头：价格触及需求区且反弹显示买入，触及供给区且回落显示卖出
// 2. 新增止盈止损标注：自动绘制虚线和文字标签显示建议的 SL/TP 位置
// 3. 新增信号确认参数：可设置反弹/回落的最小幅度，避免假信号
// 4. 修复索引方向：移除 ArraySetAsSeries，使用正确的 MT5 正向索引规则
//+------------------------------------------------------------------+
#property copyright "XAUOF 指标工坊 - 基于社区作品 #15 二创"
#property version   "2.01"
#property strict
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_plots   2

//--- 买入信号箭头
#property indicator_type1   DRAW_ARROW
#property indicator_color1  clrLime
#property indicator_width1  3
#property indicator_label1  "买入信号"

//--- 卖出信号箭头
#property indicator_type2   DRAW_ARROW
#property indicator_color2  clrRed
#property indicator_width2  3
#property indicator_label2  "卖出信号"

//+------------------------------------------------------------------+
//| 输入参数                                                           |
//+------------------------------------------------------------------+
input int    InpSwingLength = 5;              // 摆动识别周期（左右各多少根K线）
input int    InpZoneThickness = 30;           // 供需区厚度（单位：点数）
input int    InpZoneExtendBars = 50;          // 区域向右延伸多少根K线
input color  InpDemandColor = clrDodgerBlue;  // 需求区颜色（支撑）
input color  InpSupplyColor = clrTomato;      // 供给区颜色（阻力）
input int    InpZoneTransparency = 85;        // 区域透明度（0-100，越大越透明）
input bool   InpShowLabels = true;            // 是否显示供需区标注
input int    InpMaxZones = 10;                // 最多显示多少个区域（0=不限制）
input bool   InpDeleteOldZones = true;        // 价格触及后是否删除旧区域

//--- 信号相关参数
input int    InpSignalMinPips = 5;            // 信号确认最小点数（反弹/回落幅度）
input bool   InpShowSignals = true;           // 是否显示买卖信号箭头
input int    InpArrowOffset = 10;             // 信号箭头距离K线的点数
input bool   InpShowSLTP = true;              // 是否显示止盈止损线
input double InpRiskRewardRatio = 2.0;        // 止盈止损比例（盈亏比，例如 2.0 表示止盈是止损的2倍）
input color  InpSLColor = clrOrangeRed;       // 止损线颜色
input color  InpTPColor = clrSpringGreen;     // 止盈线颜色

//--- 全局变量
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_"; // 对象名称前缀
string   g_signal_prefix = "SIG_"; // 信号对象前缀

//--- 指标缓冲区
double BuySignalBuffer[];   // 买入信号箭头
double SellSignalBuffer[];  // 卖出信号箭头

//+------------------------------------------------------------------+
//| 初始化函数                                                         |
//+------------------------------------------------------------------+
int OnInit()
{
   //--- 检查参数
   if(InpSwingLength < 1)
   {
      Print("错误：摆动周期必须 >= 1");
      return INIT_PARAMETERS_INCORRECT;
   }
   
   if(InpRiskRewardRatio <= 0)
   {
      Print("错误：盈亏比必须大于 0");
      return INIT_PARAMETERS_INCORRECT;
   }
   
   //--- 绑定指标缓冲区
   SetIndexBuffer(0, BuySignalBuffer, INDICATOR_DATA);
   SetIndexBuffer(1, SellSignalBuffer, INDICATOR_DATA);
   
   //--- 设置箭头样式
   PlotIndexSetInteger(0, PLOT_ARROW, 233);  // 上箭头
   PlotIndexSetInteger(1, PLOT_ARROW, 234);  // 下箭头
   
   //--- 设置空值为 EMPTY_VALUE（必须，否则 0 会被当作有效价格画出来）
   PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetDouble(1, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   
   //--- 初始化缓冲区为空值
   ArrayInitialize(BuySignalBuffer, EMPTY_VALUE);
   ArrayInitialize(SellSignalBuffer, EMPTY_VALUE);
   
   //--- 清理旧对象
   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[])
{
   //--- 需要至少有足够的K线
   if(rates_total < InpSwingLength * 2 + 10)
      return 0;
   
   //--- 首次运行时初始化缓冲区和扫描历史供需区
   if(prev_calculated == 0)
   {
      ArrayInitialize(BuySignalBuffer, EMPTY_VALUE);
      ArrayInitialize(SellSignalBuffer, EMPTY_VALUE);
      
      //--- 扫描历史K线识别供需区（从老到新，注意循环上界要留出 InpSwingLength 避免越界）
      for(int i = InpSwingLength + 1; i < rates_total - InpSwingLength - 1; i++)
      {
         //--- 检查摆动高点（供给区）
         bool is_swing_high = true;
         for(int j = 1; j <= InpSwingLength; j++)
         {
            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);
            }
         }
         
         //--- 检查摆动低点（需求区）
         bool is_swing_low = true;
         for(int j = 1; j <= InpSwingLength; j++)
         {
            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);
            }
         }
      }
   }
   
   //--- 计算信号扫描起点（标准骨架：从 prev_calculated-1 开始，首次运行从 1 开始）
   int start = (prev_calculated > 1) ? prev_calculated - 1 : 1;
   
   //--- 逐根K线检测信号
   for(int i = start; i < rates_total && !IsStopped(); i++)
   {
      //--- 默认无信号（每根K线先初始化为 EMPTY_VALUE）
      BuySignalBuffer[i] = EMPTY_VALUE;
      SellSignalBuffer[i] = EMPTY_VALUE;
      
      //--- 至少需要前一根K线来判断反弹/回落（i < 1 时跳过）
      if(i < 1) continue;
      
      //--- 检查是否有买入信号（价格回踩需求区且反弹）
      if(InpShowSignals)
      {
         ZoneInfo nearest_demand;
         if(FindNearestZone(close[i], true, nearest_demand))
         {
            //--- 判断当前K线是否在需求区内或刚离开
            bool in_zone = (low[i] <= nearest_demand.price_top && low[i] >= nearest_demand.price_bottom);
            bool just_left = (low[i-1] <= nearest_demand.price_top && close[i] > nearest_demand.price_top);
            
            if(in_zone || just_left)
            {
               //--- 检查是否是反弹K线（阳线且幅度足够）
               bool is_bullish = close[i] > open[i];
               double bounce_pips = (close[i] - low[i]) / _Point;
               
               if(is_bullish && bounce_pips >= InpSignalMinPips)
               {
                  //--- 只在这根K线显示买入箭头
                  BuySignalBuffer[i] = low[i] - InpArrowOffset * _Point;
                  
                  //--- 绘制止盈止损线
                  if(InpShowSLTP)
                  {
                     double sl_price = nearest_demand.price_bottom - 2 * _Point; // 止损设在需求区下方
                     double sl_pips = (close[i] - sl_price) / _Point;
                     double tp_price = close[i] + sl_pips * InpRiskRewardRatio * _Point; // 按盈亏比计算止盈
                     
                     DrawSLTPLines(time[i], close[i], sl_price, tp_price, true);
                  }
               }
            }
         }
         
         //--- 检查是否有卖出信号（价格触及供给区且回落）
         ZoneInfo nearest_supply;
         if(FindNearestZone(close[i], false, nearest_supply))
         {
            bool in_zone = (high[i] >= nearest_supply.price_bottom && high[i] <= nearest_supply.price_top);
            bool just_left = (high[i-1] >= nearest_supply.price_bottom && close[i] < nearest_supply.price_bottom);
            
            if(in_zone || just_left)
            {
               //--- 检查是否是回落K线（阴线且幅度足够）
               bool is_bearish = close[i] < open[i];
               double drop_pips = (high[i] - close[i]) / _Point;
               
               if(is_bearish && drop_pips >= InpSignalMinPips)
               {
                  //--- 只在这根K线显示卖出箭头
                  SellSignalBuffer[i] = high[i] + InpArrowOffset * _Point;
                  
                  //--- 绘制止盈止损线
                  if(InpShowSLTP)
                  {
                     double sl_price = nearest_supply.price_top + 2 * _Point;
                     double sl_pips = (sl_price - close[i]) / _Point;
                     double tp_price = close[i] - sl_pips * InpRiskRewardRatio * _Point;
                     
                     DrawSLTPLines(time[i], close[i], sl_price, tp_price, false);
                  }
               }
            }
         }
      }
   }
   
   //--- 检查价格是否触及区域（可选：触及后删除）
   if(InpDeleteOldZones && rates_total > 0)
   {
      CheckZonesTouched(close[rates_total - 1]);
   }
   
   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);
      
      //--- 设置透明度
      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 FindNearestZone(double current_price, bool is_demand, ZoneInfo &zone_out)
{
   double nearest_distance = DBL_MAX;
   bool found = false;
   
   for(int i = 0; i < g_zone_count; i++)
   {
      //--- 只查找对应类型的区域
      if(g_zones[i].is_demand != is_demand)
         continue;
      
      //--- 跳过已触及的区域
      if(g_zones[i].touched && InpDeleteOldZones)
         continue;
      
      //--- 计算距离
      double distance;
      if(is_demand)
      {
         //--- 需求区：计算价格到区域上边界的距离（价格应该在上方）
         distance = current_price - g_zones[i].price_top;
      }
      else
      {
         //--- 供给区：计算区域下边界到价格的距离（价格应该在下方）
         distance = g_zones[i].price_bottom - current_price;
      }
      
      //--- 只考虑合理方向的区域，并找最近的（允许价格稍微进入区域内）
      if(distance > -InpZoneThickness * _Point && distance < nearest_distance)
      {
         nearest_distance = distance;
         zone_out = g_zones[i];
         found = true;
      }
   }
   
   return found;
}

//+------------------------------------------------------------------+
//| 绘制止盈止损线                                                     |
//+------------------------------------------------------------------+
void DrawSLTPLines(datetime signal_time, double entry_price, double sl_price, double tp_price, bool is_buy)
{
   string base_name = g_signal_prefix + TimeToString(signal_time, TIME_DATE | TIME_SECONDS);
   
   //--- 止损线
   string sl_name = base_name + "_SL";
   if(ObjectCreate(0, sl_name, OBJ_TREND, 0, signal_time, sl_price, signal_time + 30 * PeriodSeconds(), sl_price))
   {
      ObjectSetInteger(0, sl_name, OBJPROP_COLOR, InpSLColor);
      ObjectSetInteger(0, sl_name, OBJPROP_STYLE, STYLE_DASH);
      ObjectSetInteger(0, sl_name, OBJPROP_WIDTH, 1);
      ObjectSetInteger(0, sl_name, OBJPROP_RAY_RIGHT, true);
      ObjectSetInteger(0, sl_name, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(0, sl_name, OBJPROP_HIDDEN, true);
      ObjectSetInteger(0, sl_name, OBJPROP_BACK, true);
   }
   
   //--- 止盈线
   string tp_name = base_name + "_TP";
   if(ObjectCreate(0, tp_name, OBJ_TREND, 0, signal_time, tp_price, signal_time + 30 * PeriodSeconds(), tp_price))
   {
      ObjectSetInteger(0, tp_name, OBJPROP_COLOR, InpTPColor);
      ObjectSetInteger(0, tp_name, OBJPROP_STYLE, STYLE_DASH);
      ObjectSetInteger(0, tp_name, OBJPROP_WIDTH, 1);
      ObjectSetInteger(0, tp_name, OBJPROP_RAY_RIGHT, true);
      ObjectSetInteger(0, tp_name, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(0, tp_name, OBJPROP_HIDDEN, true);
      ObjectSetInteger(0, tp_name, OBJPROP_BACK, true);
   }
   
   //--- 添加文字标签
   double sl_pips = MathAbs(entry_price - sl_price) / _Point;
   double tp_pips = MathAbs(tp_price - entry_price) / _Point;
   
   string sl_label_name = base_name + "_SL_TXT";
   if(ObjectCreate(0, sl_label_name, OBJ_TEXT, 0, signal_time, sl_price))
   {
      ObjectSetString(0, sl_label_name, OBJPROP_TEXT, StringFormat("SL %.0f点", sl_pips));
      ObjectSetInteger(0, sl_label_name, OBJPROP_COLOR, InpSLColor);
      ObjectSetInteger(0, sl_label_name, OBJPROP_FONTSIZE, 8);
      ObjectSetInteger(0, sl_label_name, OBJPROP_ANCHOR, is_buy ? ANCHOR_LEFT_LOWER : ANCHOR_LEFT_UPPER);
      ObjectSetInteger(0, sl_label_name, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(0, sl_label_name, OBJPROP_HIDDEN, true);
   }
   
   string tp_label_name = base_name + "_TP_TXT";
   if(ObjectCreate(0, tp_label_name, OBJ_TEXT, 0, signal_time, tp_price))
   {
      ObjectSetString(0, tp_label_name, OBJPROP_TEXT, StringFormat("TP %.0f点", tp_pips));
      ObjectSetInteger(0, tp_label_name, OBJPROP_COLOR, InpTPColor);
      ObjectSetInteger(0, tp_label_name, OBJPROP_FONTSIZE, 8);
      ObjectSetInteger(0, tp_label_name, OBJPROP_ANCHOR, is_buy ? ANCHOR_LEFT_UPPER : ANCHOR_LEFT_LOWER);
      ObjectSetInteger(0, tp_label_name, OBJPROP_SELECTABLE, false);
      ObjectSetInteger(0, tp_label_name, OBJPROP_HIDDEN, true);
   }
}

//+------------------------------------------------------------------+
//| 检查区域是否已存在                                                 |
//+------------------------------------------------------------------+
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 || StringFind(name, g_signal_prefix) == 0)
         ObjectDelete(0, name);
   }
   
   //--- 删除止盈止损线
   total = ObjectsTotal(0, 0, OBJ_TREND);
   for(int i = total - 1; i >= 0; i--)
   {
      string name = ObjectName(0, i, 0, OBJ_TREND);
      if(StringFind(name, g_signal_prefix) == 0)
         ObjectDelete(0, name);
   }
}
//+------------------------------------------------------------------+