MACD背离动能衰减交易系统

#property copyright "XAUOF指标工坊"
#property version   "1.00"
#property strict
#property indicator_chart_window
#property indicator_buffers 6
#property indicator_plots   6

// 做多信号（蓝色上箭头）
#property indicator_type1   DRAW_ARROW
#property indicator_color1  clrBlue
#property indicator_width1  3
#property indicator_label1  "做多信号"

// 做空信号（红色下箭头）
#property indicator_type2   DRAW_ARROW
#property indicator_color2  clrRed
#property indicator_width2  3
#property indicator_label2  "做空信号"

// 多单止盈（绿色圆点）
#property indicator_type3   DRAW_ARROW
#property indicator_color3  clrLime
#property indicator_width3  2
#property indicator_label3  "多单止盈"

// 多单止损（橙色圆点）
#property indicator_type4   DRAW_ARROW
#property indicator_color4  clrOrange
#property indicator_width4  2
#property indicator_label4  "多单止损"

// 空单止盈（绿色圆点）
#property indicator_type5   DRAW_ARROW
#property indicator_color5  clrLime
#property indicator_width5  2
#property indicator_label5  "空单止盈"

// 空单止损（橙色圆点）
#property indicator_type6   DRAW_ARROW
#property indicator_color6  clrOrange
#property indicator_width6  2
#property indicator_label6  "空单止损"

//--- 输入参数
input int    MACD_Fast       = 12;       // MACD快线周期
input int    MACD_Slow       = 26;       // MACD慢线周期
input int    MACD_Signal     = 9;        // MACD信号线周期
input int    Lookback        = 20;       // 背离回溯K线数（寻找前期高低点）
input int    MomentumBars    = 3;        // 动能衰减判断K线数（柱状图连续缩小）
input double RiskReward      = 2.0;      // 盈亏比（止盈是止损的倍数）
input int    ArrowDistance   = 50;       // 箭头与K线的距离（点数）
input bool   OnlyDivergence  = false;    // 是否必须有背离（false=动能衰减也可触发）

//--- 指标缓冲区
double BuySignal[];     // 做多箭头
double SellSignal[];    // 做空箭头
double BuyTP[];         // 多单止盈
double BuySL[];         // 多单止损
double SellTP[];        // 空单止盈
double SellSL[];        // 空单止损

//--- 全局变量
int macdHandle;         // MACD指标句柄
double macdMain[];      // MACD主线
double macdSignal[];    // MACD信号线
double macdHist[];      // MACD柱状图

//+------------------------------------------------------------------+
//| 初始化函数                                                          |
//+------------------------------------------------------------------+
int OnInit()
{
   // 创建MACD指标句柄
   macdHandle = iMACD(_Symbol, PERIOD_CURRENT, MACD_Fast, MACD_Slow, MACD_Signal, PRICE_CLOSE);
   if(macdHandle == INVALID_HANDLE)
   {
      Print("创建MACD指标失败");
      return INIT_FAILED;
   }
   
   // 绑定指标缓冲区
   SetIndexBuffer(0, BuySignal, INDICATOR_DATA);
   SetIndexBuffer(1, SellSignal, INDICATOR_DATA);
   SetIndexBuffer(2, BuyTP, INDICATOR_DATA);
   SetIndexBuffer(3, BuySL, INDICATOR_DATA);
   SetIndexBuffer(4, SellTP, INDICATOR_DATA);
   SetIndexBuffer(5, SellSL, INDICATOR_DATA);
   
   // 设置箭头样式
   PlotIndexSetInteger(0, PLOT_ARROW, 233);  // 上箭头
   PlotIndexSetInteger(1, PLOT_ARROW, 234);  // 下箭头
   PlotIndexSetInteger(2, PLOT_ARROW, 159);  // 圆点
   PlotIndexSetInteger(3, PLOT_ARROW, 159);  // 圆点
   PlotIndexSetInteger(4, PLOT_ARROW, 159);  // 圆点
   PlotIndexSetInteger(5, PLOT_ARROW, 159);  // 圆点
   
   // 设置空值
   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);
   PlotIndexSetDouble(4, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetDouble(5, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   
   // 设置数组为动态
   ArraySetAsSeries(macdMain, false);
   ArraySetAsSeries(macdSignal, false);
   ArraySetAsSeries(macdHist, false);
   
   IndicatorSetString(INDICATOR_SHORTNAME, "MACD背离动能");
   
   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[])
{
   // 检查MACD数据是否准备好
   if(BarsCalculated(macdHandle) < rates_total)
      return 0;
   
   // 调整数组大小
   ArrayResize(macdMain, rates_total);
   ArrayResize(macdSignal, rates_total);
   ArrayResize(macdHist, rates_total);
   
   // 拷贝MACD数据
   if(CopyBuffer(macdHandle, 0, 0, rates_total, macdMain) < rates_total)
      return 0;
   if(CopyBuffer(macdHandle, 1, 0, rates_total, macdSignal) < rates_total)
      return 0;
   
   // 计算柱状图
   for(int i = 0; i < rates_total; i++)
      macdHist[i] = macdMain[i] - macdSignal[i];
   
   // 确定开始位置
   int start = (prev_calculated > 0) ? prev_calculated - 1 : Lookback + MomentumBars;
   
   // 初始化缓冲区
   if(prev_calculated == 0)
   {
      ArrayInitialize(BuySignal, EMPTY_VALUE);
      ArrayInitialize(SellSignal, EMPTY_VALUE);
      ArrayInitialize(BuyTP, EMPTY_VALUE);
      ArrayInitialize(BuySL, EMPTY_VALUE);
      ArrayInitialize(SellTP, EMPTY_VALUE);
      ArrayInitialize(SellSL, EMPTY_VALUE);
   }
   
   // 主循环
   for(int i = start; i < rates_total && !IsStopped(); i++)
   {
      // 默认清空信号
      BuySignal[i] = EMPTY_VALUE;
      SellSignal[i] = EMPTY_VALUE;
      BuyTP[i] = EMPTY_VALUE;
      BuySL[i] = EMPTY_VALUE;
      SellTP[i] = EMPTY_VALUE;
      SellSL[i] = EMPTY_VALUE;
      
      // 需要足够历史数据
      if(i < Lookback + MomentumBars)
         continue;
      
      // 检查动能衰减（柱状图绝对值连续缩小）
      bool momentumDecay = true;
      for(int j = 1; j < MomentumBars && i - j >= 0; j++)
      {
         if(MathAbs(macdHist[i - j + 1]) <= MathAbs(macdHist[i - j]))
         {
            momentumDecay = false;
            break;
         }
      }
      
      if(!momentumDecay && !OnlyDivergence)
         continue;
      
      // 检查看涨背离（价格新低，MACD柱状图不创新低）
      bool bullishDiv = false;
      if(macdHist[i] < 0)  // 当前在零轴下方
      {
         // 寻找回溯期内的价格最低点和MACD柱最低点
         int priceLowBar = i;
         int macdLowBar = i;
         double priceLowest = low[i];
         double macdLowest = macdHist[i];
         
         for(int j = 1; j <= Lookback && i - j >= 0; j++)
         {
            if(low[i - j] < priceLowest)
            {
               priceLowest = low[i - j];
               priceLowBar = i - j;
            }
            if(macdHist[i - j] < macdLowest)
            {
               macdLowest = macdHist[i - j];
               macdLowBar = i - j;
            }
         }
         
         // 背离条件：价格创新低，但MACD柱未创新低（或当前更高）
         if(low[i] <= priceLowest && macdHist[i] > macdLowest)
            bullishDiv = true;
      }
      
      // 检查看跌背离（价格新高，MACD柱状图不创新高）
      bool bearishDiv = false;
      if(macdHist[i] > 0)  // 当前在零轴上方
      {
         // 寻找回溯期内的价格最高点和MACD柱最高点
         int priceHighBar = i;
         int macdHighBar = i;
         double priceHighest = high[i];
         double macdHighest = macdHist[i];
         
         for(int j = 1; j <= Lookback && i - j >= 0; j++)
         {
            if(high[i - j] > priceHighest)
            {
               priceHighest = high[i - j];
               priceHighBar = i - j;
            }
            if(macdHist[i - j] > macdHighest)
            {
               macdHighest = macdHist[i - j];
               macdHighBar = i - j;
            }
         }
         
         // 背离条件：价格创新高，但MACD柱未创新高（或当前更低）
         if(high[i] >= priceHighest && macdHist[i] < macdHighest)
            bearishDiv = true;
      }
      
      double arrowGap = ArrowDistance * _Point;
      
      // 做多信号：看涨背离 + 动能衰减
      if((bullishDiv || !OnlyDivergence) && momentumDecay && macdHist[i] < 0)
      {
         BuySignal[i] = low[i] - arrowGap;
         
         // 计算止损止盈
         double entryPrice = close[i];
         double stopLoss = low[i] - 5 * _Point;  // 止损设在近期低点下方
         for(int j = 1; j <= 5 && i - j >= 0; j++)
         {
            if(low[i - j] < stopLoss)
               stopLoss = low[i - j] - 5 * _Point;
         }
         
         double riskPips = entryPrice - stopLoss;
         if(riskPips > 0)
         {
            double takeProfit = entryPrice + riskPips * RiskReward;
            BuySL[i] = stopLoss;
            BuyTP[i] = takeProfit;
         }
      }
      
      // 做空信号：看跌背离 + 动能衰减
      if((bearishDiv || !OnlyDivergence) && momentumDecay && macdHist[i] > 0)
      {
         SellSignal[i] = high[i] + arrowGap;
         
         // 计算止损止盈
         double entryPrice = close[i];
         double stopLoss = high[i] + 5 * _Point;  // 止损设在近期高点上方
         for(int j = 1; j <= 5 && i - j >= 0; j++)
         {
            if(high[i - j] > stopLoss)
               stopLoss = high[i - j] + 5 * _Point;
         }
         
         double riskPips = stopLoss - entryPrice;
         if(riskPips > 0)
         {
            double takeProfit = entryPrice - riskPips * RiskReward;
            SellSL[i] = stopLoss;
            SellTP[i] = takeProfit;
         }
      }
   }
   
   return rates_total;
}

//+------------------------------------------------------------------+
//| 清理函数                                                            |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   if(macdHandle != INVALID_HANDLE)
      IndicatorRelease(macdHandle);
}