黄金多周期趋势突破交易指标

#property copyright "XAUOF 指标工坊"
#property version   "1.00"
#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    M5_EMA_Period     = 200;  // M5 图表趋势过滤 EMA 周期
input int    M1_Fast_EMA       = 7;    // M1 图表快速 EMA 周期（突破通道）
input int    M1_Slow_EMA       = 63;   // M1 图表慢速 EMA 周期（趋势过滤）
input int    MACD_Fast         = 12;   // MACD 快线周期
input int    MACD_Slow         = 26;   // MACD 慢线周期
input int    MACD_Signal       = 9;    // MACD 信号线周期
input int    Arrow_Gap         = 20;   // 箭头与 K 线的间距（点数）

//--- 指标缓冲区
double UpArrow[];    // 做多箭头
double DnArrow[];    // 做空箭头

//--- 指标句柄（全局变量）
int handle_M5_EMA_High;   // M5 图表基于 High 的 200 EMA
int handle_M5_EMA_Low;    // M5 图表基于 Low 的 200 EMA
int handle_M1_EMA_Fast_High;  // M1 图表快速 EMA 基于 High
int handle_M1_EMA_Fast_Low;   // M1 图表快速 EMA 基于 Low
int handle_M1_EMA_Slow;       // M1 图表慢速 EMA 基于 Close
int handle_MACD;              // MACD 指标句柄

//--- 辅助数组（用于存储指标值）
double m5_ema_high[];
double m5_ema_low[];
double m1_ema_fast_high[];
double m1_ema_fast_low[];
double m1_ema_slow[];
double macd_main[];
double macd_signal[];

//+------------------------------------------------------------------+
//| 自定义指标初始化函数                                              |
//+------------------------------------------------------------------+
int OnInit()
{
   //--- 绑定指标缓冲区
   SetIndexBuffer(0, UpArrow, INDICATOR_DATA);
   SetIndexBuffer(1, DnArrow, INDICATOR_DATA);
   
   //--- 设置箭头样式
   PlotIndexSetInteger(0, PLOT_ARROW, 233);  // 上箭头
   PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(1, PLOT_ARROW, 234);  // 下箭头
   PlotIndexSetDouble(1, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   
   //--- 创建 M5 图表的 EMA 句柄（基于 High 和 Low）
   handle_M5_EMA_High = iMA(_Symbol, PERIOD_M5, M5_EMA_Period, 0, MODE_EMA, PRICE_HIGH);
   if(handle_M5_EMA_High == INVALID_HANDLE)
   {
      Print("创建 M5 EMA(High) 句柄失败");
      return INIT_FAILED;
   }
   
   handle_M5_EMA_Low = iMA(_Symbol, PERIOD_M5, M5_EMA_Period, 0, MODE_EMA, PRICE_LOW);
   if(handle_M5_EMA_Low == INVALID_HANDLE)
   {
      Print("创建 M5 EMA(Low) 句柄失败");
      return INIT_FAILED;
   }
   
   //--- 创建 M1 图表的 EMA 句柄
   handle_M1_EMA_Fast_High = iMA(_Symbol, PERIOD_M1, M1_Fast_EMA, 0, MODE_EMA, PRICE_HIGH);
   if(handle_M1_EMA_Fast_High == INVALID_HANDLE)
   {
      Print("创建 M1 快速 EMA(High) 句柄失败");
      return INIT_FAILED;
   }
   
   handle_M1_EMA_Fast_Low = iMA(_Symbol, PERIOD_M1, M1_Fast_EMA, 0, MODE_EMA, PRICE_LOW);
   if(handle_M1_EMA_Fast_Low == INVALID_HANDLE)
   {
      Print("创建 M1 快速 EMA(Low) 句柄失败");
      return INIT_FAILED;
   }
   
   handle_M1_EMA_Slow = iMA(_Symbol, PERIOD_M1, M1_Slow_EMA, 0, MODE_EMA, PRICE_CLOSE);
   if(handle_M1_EMA_Slow == INVALID_HANDLE)
   {
      Print("创建 M1 慢速 EMA 句柄失败");
      return INIT_FAILED;
   }
   
   //--- 创建 MACD 句柄
   handle_MACD = iMACD(_Symbol, PERIOD_M1, MACD_Fast, MACD_Slow, MACD_Signal, PRICE_CLOSE);
   if(handle_MACD == INVALID_HANDLE)
   {
      Print("创建 MACD 句柄失败");
      return INIT_FAILED;
   }
   
   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 < M5_EMA_Period + M1_Slow_EMA)
      return 0;
   
   //--- 检查指标是否计算完成
   if(BarsCalculated(handle_M5_EMA_High) < rates_total) return 0;
   if(BarsCalculated(handle_M5_EMA_Low) < rates_total) return 0;
   if(BarsCalculated(handle_M1_EMA_Fast_High) < rates_total) return 0;
   if(BarsCalculated(handle_M1_EMA_Fast_Low) < rates_total) return 0;
   if(BarsCalculated(handle_M1_EMA_Slow) < rates_total) return 0;
   if(BarsCalculated(handle_MACD) < rates_total) return 0;
   
   //--- 调整数组大小
   ArrayResize(m5_ema_high, rates_total);
   ArrayResize(m5_ema_low, rates_total);
   ArrayResize(m1_ema_fast_high, rates_total);
   ArrayResize(m1_ema_fast_low, rates_total);
   ArrayResize(m1_ema_slow, rates_total);
   ArrayResize(macd_main, rates_total);
   ArrayResize(macd_signal, rates_total);
   
   //--- 拷贝指标数据
   if(CopyBuffer(handle_M5_EMA_High, 0, 0, rates_total, m5_ema_high) < rates_total) return 0;
   if(CopyBuffer(handle_M5_EMA_Low, 0, 0, rates_total, m5_ema_low) < rates_total) return 0;
   if(CopyBuffer(handle_M1_EMA_Fast_High, 0, 0, rates_total, m1_ema_fast_high) < rates_total) return 0;
   if(CopyBuffer(handle_M1_EMA_Fast_Low, 0, 0, rates_total, m1_ema_fast_low) < rates_total) return 0;
   if(CopyBuffer(handle_M1_EMA_Slow, 0, 0, rates_total, m1_ema_slow) < rates_total) return 0;
   if(CopyBuffer(handle_MACD, 0, 0, rates_total, macd_main) < rates_total) return 0;
   if(CopyBuffer(handle_MACD, 1, 0, rates_total, macd_signal) < rates_total) return 0;
   
   //--- 确定起始位置
   int start = (prev_calculated > 0) ? prev_calculated - 1 : M5_EMA_Period + M1_Slow_EMA;
   
   //--- 首次计算时初始化箭头缓冲区
   if(prev_calculated == 0)
   {
      ArrayInitialize(UpArrow, EMPTY_VALUE);
      ArrayInitialize(DnArrow, EMPTY_VALUE);
   }
   
   //--- 主循环：逐根 K 线计算信号
   for(int i = start; i < rates_total && !IsStopped(); i++)
   {
      //--- 默认无信号
      UpArrow[i] = EMPTY_VALUE;
      DnArrow[i] = EMPTY_VALUE;
      
      //--- 需要前一根 K 线数据，索引 0 位置无法判断
      if(i < 1) continue;
      
      //--- 获取当前 M1 K 线对应的 M5 K 线时间
      datetime m1_time = time[i];
      int m5_bar = iBarShift(_Symbol, PERIOD_M5, m1_time);
      if(m5_bar < 0) continue;  // M5 数据不足
      
      //--- 读取 M5 趋势通道值（当前 M1 K 线对应的 M5 K 线）
      double m5_high_ema = m5_ema_high[i];
      double m5_low_ema = m5_ema_low[i];
      
      //--- 判断 M5 大趋势方向
      bool m5_uptrend = (close[i] > m5_high_ema);   // 收盘价在 M5 上轨上方，多头趋势
      bool m5_downtrend = (close[i] < m5_low_ema);  // 收盘价在 M5 下轨下方，空头趋势
      
      //--- 读取 M1 快速 EMA 通道和慢速 EMA
      double m1_fast_high = m1_ema_fast_high[i];
      double m1_fast_low = m1_ema_fast_low[i];
      double m1_slow = m1_ema_slow[i];
      
      //--- 读取 MACD 数值
      double macd_curr = macd_main[i];
      double macd_prev = macd_main[i-1];
      double signal_curr = macd_signal[i];
      double signal_prev = macd_signal[i-1];
      
      //--- 做多信号条件：
      // 1. M5 大趋势为多头（收盘价 > M5 上轨）
      // 2. M1 收盘价突破 M1 快速 EMA 上轨（前一根在下方或等于，当前在上方）
      // 3. M1 收盘价在慢速 EMA 上方（趋势过滤）
      // 4. MACD 主线在零轴上方
      // 5. MACD 金叉（主线从下方穿越信号线）
      bool long_signal = false;
      if(m5_uptrend)
      {
         bool breakout_up = (close[i-1] <= m1_fast_high && close[i] > m1_fast_high);
         bool above_slow = (close[i] > m1_slow);
         bool macd_above_zero = (macd_curr > 0);
         bool macd_golden_cross = (macd_prev <= signal_prev && macd_curr > signal_curr);
         
         if(breakout_up && above_slow && macd_above_zero && macd_golden_cross)
         {
            long_signal = true;
         }
      }
      
      //--- 做空信号条件：
      // 1. M5 大趋势为空头（收盘价 < M5 下轨）
      // 2. M1 收盘价突破 M1 快速 EMA 下轨（前一根在上方或等于，当前在下方）
      // 3. M1 收盘价在慢速 EMA 下方（趋势过滤）
      // 4. MACD 主线在零轴下方
      // 5. MACD 死叉（主线从上方穿越信号线）
      bool short_signal = false;
      if(m5_downtrend)
      {
         bool breakout_down = (close[i-1] >= m1_fast_low && close[i] < m1_fast_low);
         bool below_slow = (close[i] < m1_slow);
         bool macd_below_zero = (macd_curr < 0);
         bool macd_death_cross = (macd_prev >= signal_prev && macd_curr < signal_curr);
         
         if(breakout_down && below_slow && macd_below_zero && macd_death_cross)
         {
            short_signal = true;
         }
      }
      
      //--- 画箭头
      if(long_signal)
      {
         UpArrow[i] = low[i] - Arrow_Gap * _Point;
      }
      
      if(short_signal)
      {
         DnArrow[i] = high[i] + Arrow_Gap * _Point;
      }
   }
   
   return rates_total;
}

//+------------------------------------------------------------------+
//| 指标析构函数                                                      |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   //--- 释放指标句柄
   if(handle_M5_EMA_High != INVALID_HANDLE)
      IndicatorRelease(handle_M5_EMA_High);
   if(handle_M5_EMA_Low != INVALID_HANDLE)
      IndicatorRelease(handle_M5_EMA_Low);
   if(handle_M1_EMA_Fast_High != INVALID_HANDLE)
      IndicatorRelease(handle_M1_EMA_Fast_High);
   if(handle_M1_EMA_Fast_Low != INVALID_HANDLE)
      IndicatorRelease(handle_M1_EMA_Fast_Low);
   if(handle_M1_EMA_Slow != INVALID_HANDLE)
      IndicatorRelease(handle_M1_EMA_Slow);
   if(handle_MACD != INVALID_HANDLE)
      IndicatorRelease(handle_MACD);
}