均线回踩突破信号指标

#property copyright "XAUOF Indicator Workshop"
#property version   "1.00"
#property strict
#property indicator_chart_window
#property indicator_buffers 6
#property indicator_plots   6

//============ 参数区 ============
input int      InpFastMA     = 20;      // 快线周期（默认20）
input int      InpSlowMA     = 60;      // 慢线周期（默认60）
input int      InpMAMethod   = 0;       // 均线类型 0=SMA 1=EMA
input int      InpMACDFast   = 12;      // MACD 快线
input int      InpMACDSlow   = 26;      // MACD 慢线
input int      InpMACDSignal = 9;       // MACD 信号线
input int      InpATRPeriod  = 14;      // ATR 周期
input double   InpATRFactor  = 0.8;     // ATR 过滤系数（越大越严格，建议0.6~1.2）
input int      InpArrowGap   = 5;       // 箭头离K线距离（点）
input color    InpFastColor  = clrDodgerBlue; // 快线颜色
input color    InpSlowColor  = clrOrangeRed;  // 慢线颜色
input color    InpBuyColor   = clrLime;       // 多信号箭头颜色
input color    InpSellColor  = clrRed;        // 空信号箭头颜色

//============ 缓冲区 ============
double FastBuf[];   // 快线数据
double SlowBuf[];   // 慢线数据
double BuyBuf[];    // 多箭头上
double SellBuf[];   // 空箭头下
double BuyLbl[];    // 多信号标签
double SellLbl[];   // 空信号标签

//============ 指标句柄 ============
int hFastMA = INVALID_HANDLE;
int hSlowMA = INVALID_HANDLE;
int hMACD   = INVALID_HANDLE;
int hATR    = INVALID_HANDLE;

//============ 初始化 ============
int OnInit()
{
   SetIndexBuffer(0, FastBuf, INDICATOR_DATA);
   SetIndexBuffer(1, SlowBuf, INDICATOR_DATA);
   SetIndexBuffer(2, BuyBuf,  INDICATOR_DATA);
   SetIndexBuffer(3, SellBuf, INDICATOR_DATA);
   SetIndexBuffer(4, BuyLbl,  INDICATOR_DATA);
   SetIndexBuffer(5, SellLbl, INDICATOR_DATA);

   // 快线
   PlotIndexSetInteger(0, PLOT_LINE_COLOR, InpFastColor);
   PlotIndexSetInteger(0, PLOT_LINE_WIDTH, 2);
   PlotIndexSetString(0, PLOT_LABEL, "MA快线");

   // 慢线
   PlotIndexSetInteger(1, PLOT_LINE_COLOR, InpSlowColor);
   PlotIndexSetInteger(1, PLOT_LINE_WIDTH, 2);
   PlotIndexSetString(1, PLOT_LABEL, "MA慢线");

   // 多箭头（上箭头 233）
   PlotIndexSetInteger(2, PLOT_ARROW, 233);
   PlotIndexSetInteger(2, PLOT_ARROW_SHIFT, 10);
   PlotIndexSetInteger(2, PLOT_LINE_COLOR, InpBuyColor);
   PlotIndexSetInteger(2, PLOT_LINE_WIDTH, 3);
   PlotIndexSetString(2, PLOT_LABEL, "买入信号");
   PlotIndexSetDouble(2, PLOT_EMPTY_VALUE, EMPTY_VALUE);

   // 空箭头（下箭头 234）
   PlotIndexSetInteger(3, PLOT_ARROW, 234);
   PlotIndexSetInteger(3, PLOT_ARROW_SHIFT, -10);
   PlotIndexSetInteger(3, PLOT_LINE_COLOR, InpSellColor);
   PlotIndexSetInteger(3, PLOT_LINE_WIDTH, 3);
   PlotIndexSetString(3, PLOT_LABEL, "卖出信号");
   PlotIndexSetDouble(3, PLOT_EMPTY_VALUE, EMPTY_VALUE);

   // 文字标签（多）
   PlotIndexSetInteger(4, PLOT_ARROW, 167);
   PlotIndexSetInteger(4, PLOT_ARROW_SHIFT, 20);
   PlotIndexSetInteger(4, PLOT_LINE_COLOR, InpBuyColor);
   PlotIndexSetInteger(4, PLOT_LINE_WIDTH, 1);
   PlotIndexSetString(4, PLOT_LABEL, "多标签");
   PlotIndexSetDouble(4, PLOT_EMPTY_VALUE, EMPTY_VALUE);

   // 文字标签（空）
   PlotIndexSetInteger(5, PLOT_ARROW, 167);
   PlotIndexSetInteger(5, PLOT_ARROW_SHIFT, -20);
   PlotIndexSetInteger(5, PLOT_LINE_COLOR, InpSellColor);
   PlotIndexSetInteger(5, PLOT_LINE_WIDTH, 1);
   PlotIndexSetString(5, PLOT_LABEL, "空标签");
   PlotIndexSetDouble(5, PLOT_EMPTY_VALUE, EMPTY_VALUE);

   // 创建句柄
   ENUM_MA_METHOD maMethod = (InpMAMethod == 1) ? MODE_EMA : MODE_SMA;

   hFastMA = iMA(_Symbol, PERIOD_CURRENT, InpFastMA, 0, maMethod, PRICE_CLOSE);
   if(hFastMA == INVALID_HANDLE) { Print("快线句柄创建失败"); return INIT_FAILED; }

   hSlowMA = iMA(_Symbol, PERIOD_CURRENT, InpSlowMA, 0, maMethod, PRICE_CLOSE);
   if(hSlowMA == INVALID_HANDLE) { Print("慢线句柄创建失败"); return INIT_FAILED; }

   hMACD = iMACD(_Symbol, PERIOD_CURRENT, InpMACDFast, InpMACDSlow, InpMACDSignal, PRICE_CLOSE);
   if(hMACD == INVALID_HANDLE) { Print("MACD句柄创建失败"); return INIT_FAILED; }

   hATR = iATR(_Symbol, PERIOD_CURRENT, InpATRPeriod);
   if(hATR == INVALID_HANDLE) { Print("ATR句柄创建失败"); return INIT_FAILED; }

   IndicatorSetString(INDICATOR_SHORTNAME, "MA回踩信号系统");
   IndicatorSetInteger(INDICATOR_DIGITS, _Digits);

   return INIT_SUCCEEDED;
}

//============ 反初始化 ============
void OnDeinit(const int reason)
{
   if(hFastMA != INVALID_HANDLE) IndicatorRelease(hFastMA);
   if(hSlowMA != INVALID_HANDLE) IndicatorRelease(hSlowMA);
   if(hMACD   != INVALID_HANDLE) IndicatorRelease(hMACD);
   if(hATR    != INVALID_HANDLE) IndicatorRelease(hATR);
}

//============ 主计算 ============
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[])
{
   int minBars = MathMax(InpSlowMA, MathMax(InpMACDSlow + InpMACDSignal, InpATRPeriod)) + 5;
   if(rates_total < minBars) return 0;

   // 句柄准备好
   if(BarsCalculated(hFastMA) < rates_total) return 0;
   if(BarsCalculated(hSlowMA) < rates_total) return 0;
   if(BarsCalculated(hMACD)   < rates_total) return 0;
   if(BarsCalculated(hATR)    < rates_total) return 0;

   // 拷贝数据到缓冲区
   if(CopyBuffer(hFastMA, 0, 0, rates_total, FastBuf) < rates_total) return 0;
   if(CopyBuffer(hSlowMA, 0, 0, rates_total, SlowBuf) < rates_total) return 0;

   // MACD 主线和信号线
   double macdMain[], macdSig[];
   ArrayResize(macdMain, rates_total);
   ArrayResize(macdSig,  rates_total);
   if(CopyBuffer(hMACD, 0, 0, rates_total, macdMain) < rates_total) return 0;
   if(CopyBuffer(hMACD, 1, 0, rates_total, macdSig)  < rates_total) return 0;

   // ATR
   double atrBuf[];
   ArrayResize(atrBuf, rates_total);
   if(CopyBuffer(hATR, 0, 0, rates_total, atrBuf) < rates_total) return 0;

   // 起点
   int start = (prev_calculated > 0) ? prev_calculated - 1 : minBars;
   if(start < 1) start = 1;

   if(prev_calculated == 0)
   {
      ArrayInitialize(BuyBuf,  EMPTY_VALUE);
      ArrayInitialize(SellBuf, EMPTY_VALUE);
      ArrayInitialize(BuyLbl,  EMPTY_VALUE);
      ArrayInitialize(SellLbl, EMPTY_VALUE);
   }

   for(int i = start; i < rates_total && !IsStopped(); i++)
   {
      // 默认空值
      BuyBuf[i]  = EMPTY_VALUE;
      SellBuf[i] = EMPTY_VALUE;
      BuyLbl[i]  = EMPTY_VALUE;
      SellLbl[i] = EMPTY_VALUE;

      if(i < 3) continue;

      double fast   = FastBuf[i];
      double slow   = SlowBuf[i];
      double fast1  = FastBuf[i-1];
      double slow1  = SlowBuf[i-1];
      double atr    = atrBuf[i];
      double macd   = macdMain[i];
      double macdS  = macdSig[i];
      double macd1  = macdMain[i-1];
      double macdS1 = macdSig[i-1];

      // 数据合法性
      if(fast == EMPTY_VALUE || slow == EMPTY_VALUE) continue;
      if(atr <= 0) continue;

      // 波动过滤：K线实体小于 ATR 系数认为在震荡，信号不明确，跳过
      double body = MathAbs(close[i] - open[i]);
      if(body < atr * InpATRFactor * 0.3) continue;

      // 趋势定义
      bool upTrend   = (fast > slow) && (slow > SlowBuf[i-2]) && (close[i] > slow);
      bool downTrend = (fast < slow) && (slow < SlowBuf[i-2]) && (close[i] < slow);

      if(upTrend)
      {
         // 前一根 K 最低点触碰或接近快线，且前一根已收回快线上方 → 视为回踩完成
         bool touchedFast = (low[i-1] <= fast1 * 1.0005) && (low[i-1] >= slow1 * 0.9995);
         bool pulledBack  = (close[i-1] > fast1);

         // MACD 金叉或柱状体由负转正
         bool macdBull = (macd1 <= macdS1 && macd > macdS) || (macd > 0 && macd1 <= 0);

         // 当前为阳线，收在快线上
         bool candleUp = (close[i] > open[i]) && (close[i] > fast);

         // 要远离均线，突破幅度要够
         bool strongBreak = (close[i] - fast) > atr * 0.2;

         if(touchedFast && pulledBack && macdBull && candleUp && strongBreak)
         {
            BuyBuf[i] = low[i] - InpArrowGap * _Point;
            BuyLbl[i] = low[i] - (InpArrowGap + 15) * _Point;
         }
      }
      else if(downTrend)
      {
         // 前一根 K 最高点触碰或接近快线，且前一根已收回快线下方 → 视为回踩完成
         bool touchedFast = (high[i-1] >= fast1 * 0.9995) && (high[i-1] <= slow1 * 1.0005);
         bool pulledBack  = (close[i-1] < fast1);

         // MACD 死叉或柱状体由正转负
         bool macdBear = (macd1 >= macdS1 && macd < macdS) || (macd < 0 && macd1 >= 0);

         // 当前为阴线，收在快线下方
         bool candleDown = (close[i] < open[i]) && (close[i] < fast);

         // 突破幅度
         bool strongBreak = (fast - close[i]) > atr * 0.2;

         if(touchedFast && pulledBack && macdBear && candleDown && strongBreak)
         {
            SellBuf[i] = high[i] + InpArrowGap * _Point;
            SellLbl[i] = high[i] + (InpArrowGap + 15) * _Point;
         }
      }
   }

   return rates_total;
}