MT5订单流分析指标（简化版）

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

// 第一个图：支撑区域（蓝色填充）
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrDodgerBlue
#property indicator_width1  1
#property indicator_label1  "支撑区"

// 第二个图：阻力区域（橙色填充）
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrOrange
#property indicator_width2  1
#property indicator_label2  "阻力区"

// 第三个图：强买入信号（绿色上箭头）
#property indicator_type3   DRAW_ARROW
#property indicator_color3  clrLime
#property indicator_width3  3
#property indicator_label3  "强买压"

// 第四个图：强卖出信号（红色下箭头）
#property indicator_type4   DRAW_ARROW
#property indicator_color4  clrRed
#property indicator_width4  3
#property indicator_label4  "强卖压"

//--- 输入参数
input int    InpLookbackBars   = 200;         // 回溯K线数量（计算成交分布范围）
input int    InpPriceLevels    = 100;         // 价格分档数量（越多越细腻）
input double InpDeltaThreshold = 1.5;         // Delta信号阈值（买卖差倍数）
input bool   InpShowVolumeText = false;       // 显示成交量数字（消耗性能）
input color  InpSupportColor   = clrDodgerBlue;   // 支撑区颜色
input color  InpResistColor    = clrOrange;       // 阻力区颜色

//--- 指标缓冲区
double SupportBuf[];     // 支撑区上边界
double ResistBuf[];      // 阻力区下边界
double BuySignalBuf[];   // 买入信号
double SellSignalBuf[];  // 卖出信号
double BullVolBuf[];     // 多头成交量（辅助计算）
double BearVolBuf[];     // 空头成交量（辅助计算）
double DeltaBuf[];       // Delta值（辅助）
double TotalVolBuf[];    // 总成交量（辅助）

//--- 全局变量
struct PriceLevel {
   double price;
   long   bull_vol;   // 涨K线在此价位的成交量
   long   bear_vol;   // 跌K线在此价位的成交量
   long   total_vol;
};
PriceLevel levels[];

string object_prefix = "OrderFlow_";
int chart_window = 0;

//+------------------------------------------------------------------+
int OnInit()
{
   if(InpLookbackBars < 50 || InpPriceLevels < 20) {
      Print("参数错误：回溯K线≥50，价格分档≥20");
      return INIT_PARAMETERS_INCORRECT;
   }
   
   // 绑定缓冲区
   SetIndexBuffer(0, SupportBuf, INDICATOR_DATA);
   SetIndexBuffer(1, ResistBuf, INDICATOR_DATA);
   SetIndexBuffer(2, BuySignalBuf, INDICATOR_DATA);
   SetIndexBuffer(3, SellSignalBuf, INDICATOR_DATA);
   SetIndexBuffer(4, BullVolBuf, INDICATOR_CALCULATIONS);
   SetIndexBuffer(5, BearVolBuf, INDICATOR_CALCULATIONS);
   SetIndexBuffer(6, DeltaBuf, INDICATOR_CALCULATIONS);
   SetIndexBuffer(7, TotalVolBuf, INDICATOR_CALCULATIONS);
   
   // 设置箭头样式
   PlotIndexSetInteger(2, PLOT_ARROW, 233);  // 上箭头
   PlotIndexSetInteger(3, PLOT_ARROW, 234);  // 下箭头
   PlotIndexSetDouble(2, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetDouble(3, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   
   ArrayResize(levels, InpPriceLevels);
   
   IndicatorSetString(INDICATOR_SHORTNAME, "订单流分析");
   IndicatorSetInteger(INDICATOR_DIGITS, _Digits);
   
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   // 清理图表对象
   ObjectsDeleteAll(0, object_prefix);
   ChartRedraw();
}

//+------------------------------------------------------------------+
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 < InpLookbackBars) return 0;
   
   // 初始化缓冲区
   int start = (prev_calculated > 0) ? prev_calculated - 1 : InpLookbackBars;
   if(prev_calculated == 0) {
      ArrayInitialize(SupportBuf, 0);
      ArrayInitialize(ResistBuf, 0);
      ArrayInitialize(BuySignalBuf, EMPTY_VALUE);
      ArrayInitialize(SellSignalBuf, EMPTY_VALUE);
      ArrayInitialize(BullVolBuf, 0);
      ArrayInitialize(BearVolBuf, 0);
      ArrayInitialize(DeltaBuf, 0);
   }
   
   // ========== 第一步：计算价格档位成交分布 ==========
   int calc_start = rates_total - InpLookbackBars;
   if(calc_start < 0) calc_start = 0;
   
   // 找出价格范围
   double price_min = low[calc_start];
   double price_max = high[calc_start];
   for(int i = calc_start; i < rates_total; i++) {
      if(low[i] < price_min) price_min = low[i];
      if(high[i] > price_max) price_max = high[i];
   }
   
   if(price_max <= price_min) return rates_total;
   
   double price_step = (price_max - price_min) / InpPriceLevels;
   if(price_step < _Point * 10) price_step = _Point * 10;
   
   // 初始化价格档位
   for(int lv = 0; lv < InpPriceLevels; lv++) {
      levels[lv].price = price_min + lv * price_step + price_step / 2;
      levels[lv].bull_vol = 0;
      levels[lv].bear_vol = 0;
      levels[lv].total_vol = 0;
   }
   
   // 遍历K线，统计成交分布
   for(int i = calc_start; i < rates_total; i++) {
      bool is_bull = (close[i] >= open[i]);
      long vol = (volume[i] > 0) ? volume[i] : tick_volume[i];
      
      double k_low = low[i];
      double k_high = high[i];
      
      // 找出K线覆盖的价格档位
      int lv_start = (int)((k_low - price_min) / price_step);
      int lv_end   = (int)((k_high - price_min) / price_step);
      
      if(lv_start < 0) lv_start = 0;
      if(lv_end >= InpPriceLevels) lv_end = InpPriceLevels - 1;
      
      int lv_count = lv_end - lv_start + 1;
      if(lv_count < 1) lv_count = 1;
      
      long vol_per_level = vol / lv_count;
      
      for(int lv = lv_start; lv <= lv_end; lv++) {
         levels[lv].total_vol += vol_per_level;
         if(is_bull)
            levels[lv].bull_vol += vol_per_level;
         else
            levels[lv].bear_vol += vol_per_level;
      }
   }
   
   // ========== 第二步：找出关键支撑阻力区 ==========
   // 找出成交量最大的3个区域
   long max_vol = 0;
   for(int lv = 0; lv < InpPriceLevels; lv++) {
      if(levels[lv].total_vol > max_vol) 
         max_vol = levels[lv].total_vol;
   }
   
   double vol_threshold = max_vol * 0.7;  // 70%以上算高成交区
   
   // 标记支撑和阻力
   for(int i = start; i < rates_total; i++) {
      double current_price = close[i];
      
      // 找出当前价格附近的高成交区
      bool has_support = false;
      bool has_resist = false;
      
      for(int lv = 0; lv < InpPriceLevels; lv++) {
         if(levels[lv].total_vol < vol_threshold) continue;
         
         double level_price = levels[lv].price;
         
         // 价格在高成交区下方 → 阻力
         if(level_price > current_price && level_price - current_price < 100 * _Point) {
            has_resist = true;
            ResistBuf[i] = level_price;
         }
         
         // 价格在高成交区上方 → 支撑
         if(level_price < current_price && current_price - level_price < 100 * _Point) {
            has_support = true;
            SupportBuf[i] = level_price;
         }
      }
      
      if(!has_support) SupportBuf[i] = 0;
      if(!has_resist) ResistBuf[i] = 0;
   }
   
   // ========== 第三步：计算Delta信号 ==========
   for(int i = start; i < rates_total && !IsStopped(); i++) {
      if(i < 1) continue;
      
      BuySignalBuf[i] = EMPTY_VALUE;
      SellSignalBuf[i] = EMPTY_VALUE;
      
      bool is_bull = (close[i] >= open[i]);
      long vol = (volume[i] > 0) ? volume[i] : tick_volume[i];
      
      if(is_bull) {
         BullVolBuf[i] = (double)vol;
         BearVolBuf[i] = 0;
      } else {
         BullVolBuf[i] = 0;
         BearVolBuf[i] = (double)vol;
      }
      
      // 计算最近3根K线的Delta
      double bull_sum = BullVolBuf[i] + BullVolBuf[i-1];
      double bear_sum = BearVolBuf[i] + BearVolBuf[i-1];
      if(i >= 2) {
         bull_sum += BullVolBuf[i-2];
         bear_sum += BearVolBuf[i-2];
      }
      
      DeltaBuf[i] = bull_sum - bear_sum;
      
      // 强买压信号：多头成交量是空头的N倍
      if(bear_sum > 0 && bull_sum / bear_sum > InpDeltaThreshold) {
         BuySignalBuf[i] = low[i] - 20 * _Point;
      }
      
      // 强卖压信号：空头成交量是多头的N倍
      if(bull_sum > 0 && bear_sum / bull_sum > InpDeltaThreshold) {
         SellSignalBuf[i] = high[i] + 20 * _Point;
      }
   }
   
   // ========== 第四步：绘制右侧成交分布柱状图（仅最新一次） ==========
   if(rates_total - prev_calculated > 0 || prev_calculated == 0) {
      DrawVolumProfile(levels, InpPriceLevels, price_min, price_max);
   }
   
   return rates_total;
}

//+------------------------------------------------------------------+
void DrawVolumProfile(PriceLevel &lvs[], int count, double pmin, double pmax)
{
   // 清理旧对象
   ObjectsDeleteAll(0, object_prefix);
   
   if(!InpShowVolumeText) return;  // 用户关闭了绘图功能
   
   // 找出最大成交量（用于归一化）
   long max_vol = 0;
   for(int i = 0; i < count; i++) {
      if(lvs[i].total_vol > max_vol) max_vol = lvs[i].total_vol;
   }
   
   if(max_vol == 0) return;
   
   // 获取图表尺寸
   int chart_width = (int)ChartGetInteger(0, CHART_WIDTH_IN_PIXELS);
   int chart_height = (int)ChartGetInteger(0, CHART_HEIGHT_IN_PIXELS);
   
   double price_range = pmax - pmin;
   int bar_width = 100;  // 右侧柱状图宽度（像素）
   
   // 从右往左画柱状图
   for(int i = 0; i < count; i++) {
      if(lvs[i].total_vol == 0) continue;
      
      double ratio = (double)lvs[i].total_vol / max_vol;
      int width = (int)(ratio * bar_width);
      if(width < 2) width = 2;
      
      // 计算纵向位置（价格 → 像素）
      double price_ratio = (lvs[i].price - pmin) / price_range;
      int y_pos = chart_height - (int)(price_ratio * chart_height);
      
      // 画矩形
      string obj_name = object_prefix + "bar_" + IntegerToString(i);
      ObjectCreate(0, obj_name, OBJ_RECTANGLE_LABEL, 0, 0, 0);
      ObjectSetInteger(0, obj_name, OBJPROP_XDISTANCE, chart_width - width - 10);
      ObjectSetInteger(0, obj_name, OBJPROP_YDISTANCE, y_pos);
      ObjectSetInteger(0, obj_name, OBJPROP_XSIZE, width);
      ObjectSetInteger(0, obj_name, OBJPROP_YSIZE, 3);
      
      // 颜色：多头多用蓝色，空头多用橙色
      color bar_color = (lvs[i].bull_vol > lvs[i].bear_vol) ? clrDodgerBlue : clrOrange;
      ObjectSetInteger(0, obj_name, OBJPROP_BGCOLOR, bar_color);
      ObjectSetInteger(0, obj_name, OBJPROP_BACK, false);
   }
   
   ChartRedraw();
}
//+------------------------------------------------------------------+