供需区价格行为指标

#property copyright   "XAUOF指标工坊"
#property version     "1.0"
#property strict
#property indicator_chart_window
#property indicator_buffers 4
#property indicator_plots   4

// 供应区线（粉红色）
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrDeepPink
#property indicator_width1  2
#property indicator_label1  "供应区"

// 需求区线（青绿色）
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrMediumTurquoise
#property indicator_width2  2
#property indicator_label2  "需求区"

// 卖出信号箭头（黄色向下）
#property indicator_type3   DRAW_ARROW
#property indicator_color3  clrGold
#property indicator_width3  2
#property indicator_label3  "卖出信号"

// 买入信号箭头（青绿向上）
#property indicator_type4   DRAW_ARROW
#property indicator_color4  clrMediumTurquoise
#property indicator_width4  2
#property indicator_label4  "买入信号"

//--- 输入参数
input int    SwingPeriod    = 5;      // 识别周期：判断局部高低点需要左右各N根K线，推荐5-10
input int    ZoneValidBars  = 50;     // 区域有效期：供需区在图上保持的K线数量，推荐30-100
input int    ZoneWidthPips  = 20;     // 区域宽度：允许的价格偏差（点数），推荐10-30
input int    ArrowGap       = 50;     // 箭头间距：箭头距离K线高低点的点数，推荐30-100

//--- 指标缓冲区
double SupplyBuffer[];      // 供应区（阻力位）
double DemandBuffer[];      // 需求区（支撑位）
double SellArrow[];         // 卖出箭头
double BuyArrow[];          // 买入箭头

//--- 全局变量，记录上一次标记的区域位置和时间
struct ZoneInfo {
   double price;            // 区域价格
   int    startBar;         // 开始K线索引
};

ZoneInfo lastSupplyZones[100];   // 最近的供应区
ZoneInfo lastDemandZones[100];   // 最近的需求区
int supplyCount = 0;
int demandCount = 0;

//+------------------------------------------------------------------+
//| 初始化函数                                                         |
//+------------------------------------------------------------------+
int OnInit()
{
   // 绑定缓冲区
   SetIndexBuffer(0, SupplyBuffer, INDICATOR_DATA);
   SetIndexBuffer(1, DemandBuffer, INDICATOR_DATA);
   SetIndexBuffer(2, SellArrow, INDICATOR_DATA);
   SetIndexBuffer(3, BuyArrow, INDICATOR_DATA);
   
   // 设置箭头样式
   PlotIndexSetInteger(2, PLOT_ARROW, 233);  // 向下箭头
   PlotIndexSetInteger(3, PLOT_ARROW, 234);  // 向上箭头
   
   // 设置空值
   PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetDouble(1, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetDouble(2, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetDouble(3, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   
   // 设置指标名称
   IndicatorSetString(INDICATOR_SHORTNAME, "供需区指标");
   
   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 < SwingPeriod * 2 + 1)
      return 0;
   
   // 确定计算起点
   int start = (prev_calculated > SwingPeriod) ? prev_calculated - 1 : SwingPeriod;
   
   // 首次运行，初始化所有缓冲区
   if(prev_calculated == 0)
   {
      ArrayInitialize(SupplyBuffer, EMPTY_VALUE);
      ArrayInitialize(DemandBuffer, EMPTY_VALUE);
      ArrayInitialize(SellArrow, EMPTY_VALUE);
      ArrayInitialize(BuyArrow, EMPTY_VALUE);
      supplyCount = 0;
      demandCount = 0;
   }
   
   // 主循环：从start开始逐根K线计算
   for(int i = start; i < rates_total && !IsStopped(); i++)
   {
      // 初始化当前K线的缓冲区
      SupplyBuffer[i] = EMPTY_VALUE;
      DemandBuffer[i] = EMPTY_VALUE;
      SellArrow[i] = EMPTY_VALUE;
      BuyArrow[i] = EMPTY_VALUE;
      
      // 边界检查：确保可以访问前后SwingPeriod根K线
      if(i < SwingPeriod || i >= rates_total - 1)
         continue;
      
      // 1. 识别局部高点（Swing High）：当前K线的最高价比前后SwingPeriod根都高
      bool isSwingHigh = true;
      for(int j = 1; j <= SwingPeriod; j++)
      {
         if(i - j < 0 || i + j >= rates_total)
         {
            isSwingHigh = false;
            break;
         }
         if(high[i] <= high[i - j] || high[i] <= high[i + j])
         {
            isSwingHigh = false;
            break;
         }
      }
      
      // 如果是局部高点，记录供应区
      if(isSwingHigh)
      {
         double supplyPrice = high[i];
         
         // 在该价格附近画供应区线（持续ZoneValidBars根K线）
         int endBar = MathMin(i + ZoneValidBars, rates_total - 1);
         for(int k = i; k < endBar; k++)
         {
            SupplyBuffer[k] = supplyPrice;
         }
         
         // 记录到供应区数组（用于后续信号判断）
         if(supplyCount < 100)
         {
            lastSupplyZones[supplyCount].price = supplyPrice;
            lastSupplyZones[supplyCount].startBar = i;
            supplyCount++;
         }
      }
      
      // 2. 识别局部低点（Swing Low）：当前K线的最低价比前后SwingPeriod根都低
      bool isSwingLow = true;
      for(int j = 1; j <= SwingPeriod; j++)
      {
         if(i - j < 0 || i + j >= rates_total)
         {
            isSwingLow = false;
            break;
         }
         if(low[i] >= low[i - j] || low[i] >= low[i + j])
         {
            isSwingLow = false;
            break;
         }
      }
      
      // 如果是局部低点，记录需求区
      if(isSwingLow)
      {
         double demandPrice = low[i];
         
         // 在该价格附近画需求区线（持续ZoneValidBars根K线）
         int endBar = MathMin(i + ZoneValidBars, rates_total - 1);
         for(int k = i; k < endBar; k++)
         {
            DemandBuffer[k] = demandPrice;
         }
         
         // 记录到需求区数组
         if(demandCount < 100)
         {
            lastDemandZones[demandCount].price = demandPrice;
            lastDemandZones[demandCount].startBar = i;
            demandCount++;
         }
      }
      
      // 3. 判断是否产生交易信号
      // 卖出信号：价格触及供应区后向下反转
      for(int s = 0; s < supplyCount; s++)
      {
         double zonePrice = lastSupplyZones[s].price;
         int zoneStart = lastSupplyZones[s].startBar;
         
         // 只检查有效期内的区域
         if(i > zoneStart && i <= zoneStart + ZoneValidBars)
         {
            double zonePips = ZoneWidthPips * _Point;
            
            // 当前K线触及供应区（最高价接近或超过区域价格）
            if(high[i] >= zonePrice - zonePips && high[i] <= zonePrice + zonePips)
            {
               // 并且收盘价回落（表示反转）
               if(i >= 1 && close[i] < close[i - 1] && close[i] < open[i])
               {
                  SellArrow[i] = high[i] + ArrowGap * _Point;
                  break;  // 只画一个箭头
               }
            }
         }
      }
      
      // 买入信号：价格触及需求区后向上反转
      for(int d = 0; d < demandCount; d++)
      {
         double zonePrice = lastDemandZones[d].price;
         int zoneStart = lastDemandZones[d].startBar;
         
         // 只检查有效期内的区域
         if(i > zoneStart && i <= zoneStart + ZoneValidBars)
         {
            double zonePips = ZoneWidthPips * _Point;
            
            // 当前K线触及需求区（最低价接近或低于区域价格）
            if(low[i] <= zonePrice + zonePips && low[i] >= zonePrice - zonePips)
            {
               // 并且收盘价反弹（表示反转）
               if(i >= 1 && close[i] > close[i - 1] && close[i] > open[i])
               {
                  BuyArrow[i] = low[i] - ArrowGap * _Point;
                  break;  // 只画一个箭头
               }
            }
         }
      }
   }
   
   return rates_total;
}