-2 RSI_88_5

#property copyright "XAUUSD Indicator Workshop"
#property version   "1.0"
#property strict
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_plots   4

// ============ 输入参数 ============

input int FastMA_Period = 20;                      // 快速MA周期（贴近价格）

input int SlowMA_Period = 50;                      // 慢速MA周期（平滑趋势线）

input ENUM_MA_METHOD MA_Method = MODE_EMA;         // MA类型：MODE_SMA, MODE_EMA, MODE_SMMA, MODE_LWMA

input int Channel_Period = 20;                     // 通道周期（计算标准差）

input double Channel_StdDev = 2.0;                 // 通道宽度（标准差倍数，默认2.0）

input int RSI_Period = 14;                         // RSI周期

input double RSI_Overbought = 70;                  // RSI超买阈值（标注点位）

input double RSI_Oversold = 30;                    // RSI超卖阈值（标注点位）

input bool Show_RSI_Labels = true;                 // 是否显示RSI数值标签

input color Channel_Fill_Color = clrLightBlue;     // 通道填充颜色

input int Channel_Transparency = 85;               // 通道透明度（0-100，越大越透明）


// ============ 指标缓冲区 ============

double FastMA_Buffer[];         // 快速MA（青色）

double SlowMA_Buffer[];         // 慢速MA（浅蓝）

double UpperChannel_Buffer[];   // 上通道线

double LowerChannel_Buffer[];   // 下通道线

double RSI_Buffer[];            // RSI值（不显示，用于计算）


// ============ 全局句柄 ============

int FastMA_Handle = INVALID_HANDLE;
int SlowMA_Handle = INVALID_HANDLE;
int RSI_Handle = INVALID_HANDLE;

// ============ OnInit 初始化 ============

int OnInit()
{
    // 创建快速MA句柄

    FastMA_Handle = iMA(_Symbol, PERIOD_CURRENT, FastMA_Period, 0, MA_Method, PRICE_CLOSE);
    if (FastMA_Handle == INVALID_HANDLE) {
        Alert("快速MA创建失败");
        return INIT_FAILED;
    }
    
    // 创建慢速MA句柄

    SlowMA_Handle = iMA(_Symbol, PERIOD_CURRENT, SlowMA_Period, 0, MA_Method, PRICE_CLOSE);
    if (SlowMA_Handle == INVALID_HANDLE) {
        Alert("慢速MA创建失败");
        return INIT_FAILED;
    }
    
    // 创建RSI句柄

    RSI_Handle = iRSI(_Symbol, PERIOD_CURRENT, RSI_Period, PRICE_CLOSE);
    if (RSI_Handle == INVALID_HANDLE) {
        Alert("RSI创建失败");
        return INIT_FAILED;
    }
    
    // 设置缓冲区数组为时间序列（0=最新）

    ArraySetAsSeries(FastMA_Buffer, true);
    ArraySetAsSeries(SlowMA_Buffer, true);
    ArraySetAsSeries(UpperChannel_Buffer, true);
    ArraySetAsSeries(LowerChannel_Buffer, true);
    ArraySetAsSeries(RSI_Buffer, true);
    
    // 绑定缓冲区

    SetIndexBuffer(0, FastMA_Buffer, INDICATOR_DATA);
    SetIndexBuffer(1, SlowMA_Buffer, INDICATOR_DATA);
    SetIndexBuffer(2, UpperChannel_Buffer, INDICATOR_DATA);
    SetIndexBuffer(3, LowerChannel_Buffer, INDICATOR_DATA);
    SetIndexBuffer(4, RSI_Buffer, INDICATOR_CALCULATIONS);
    
    // 快速MA - 青色粗线

    PlotIndexSetString(0, PLOT_LABEL, "FastMA");
    PlotIndexSetInteger(0, PLOT_DRAW_TYPE, DRAW_LINE);
    PlotIndexSetInteger(0, PLOT_LINE_COLOR, clrCyan);
    PlotIndexSetInteger(0, PLOT_LINE_WIDTH, 2);
    PlotIndexSetInteger(0, PLOT_LINE_STYLE, STYLE_SOLID);
    
    // 慢速MA - 浅蓝色粗线

    PlotIndexSetString(1, PLOT_LABEL, "SlowMA");
    PlotIndexSetInteger(1, PLOT_DRAW_TYPE, DRAW_LINE);
    PlotIndexSetInteger(1, PLOT_LINE_COLOR, clrLightBlue);
    PlotIndexSetInteger(1, PLOT_LINE_WIDTH, 2);
    PlotIndexSetInteger(1, PLOT_LINE_STYLE, STYLE_SOLID);
    
    // 上通道线 - 浅蓝色虚线

    PlotIndexSetString(2, PLOT_LABEL, "Upper Channel");
    PlotIndexSetInteger(2, PLOT_DRAW_TYPE, DRAW_LINE);
    PlotIndexSetInteger(2, PLOT_LINE_COLOR, clrLightBlue);
    PlotIndexSetInteger(2, PLOT_LINE_WIDTH, 1);
    PlotIndexSetInteger(2, PLOT_LINE_STYLE, STYLE_DOT);
    
    // 下通道线 - 浅蓝色虚线

    PlotIndexSetString(3, PLOT_LABEL, "Lower Channel");
    PlotIndexSetInteger(3, PLOT_DRAW_TYPE, DRAW_LINE);
    PlotIndexSetInteger(3, PLOT_LINE_COLOR, clrLightBlue);
    PlotIndexSetInteger(3, PLOT_LINE_WIDTH, 1);
    PlotIndexSetInteger(3, PLOT_LINE_STYLE, STYLE_DOT);
    
    IndicatorSetString(INDICATOR_SHORTNAME, "Trend_Channel_RSI");
    IndicatorSetInteger(INDICATOR_DIGITS, _Digits);
    
    return INIT_SUCCEEDED;
}

// ============ 计算标准差 ============

double CalculateStdDev(const double &values[], int size)
{
    if (size <= 1) return 0;
    
    double sum = 0;
    for (int i = 0; i < size; i++) {
        sum += values[i];
    }
    double average = sum / size;
    
    double variance = 0;
    for (int i = 0; i < size; i++) {
        double diff = values[i] - average;
        variance += diff * diff;
    }
    variance /= size;
    
    return MathSqrt(variance);
}

// ============ OnCalculate 主计算 ============

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 < MathMax(FastMA_Period, SlowMA_Period) + Channel_Period) {
        return 0; // 数据不足

    }
    
    // 设置价格数组为时间序列

    ArraySetAsSeries(close, true);
    ArraySetAsSeries(time, true);
    
    int limit = rates_total - prev_calculated;
    if (limit == 0) limit = 1; // 只计算最新K线

    if (prev_calculated == 0) limit = rates_total - 1; // 首次计算全部

    
    // 复制快速MA

    if (CopyBuffer(FastMA_Handle, 0, 0, rates_total, FastMA_Buffer) <= 0) {
        return 0;
    }
    ArraySetAsSeries(FastMA_Buffer, true);
    
    // 复制慢速MA

    if (CopyBuffer(SlowMA_Handle, 0, 0, rates_total, SlowMA_Buffer) <= 0) {
        return 0;
    }
    ArraySetAsSeries(SlowMA_Buffer, true);
    
    // 复制RSI

    if (CopyBuffer(RSI_Handle, 0, 0, rates_total, RSI_Buffer) <= 0) {
        return 0;
    }
    ArraySetAsSeries(RSI_Buffer, true);
    
    // 计算通道（基于收盘价的标准差）

    double priceArray[];
    ArrayResize(priceArray, Channel_Period);
    
    for (int i = limit; i >= 0; i--) {
        if (i + Channel_Period > rates_total) continue;
        
        // 提取最近 Channel_Period 个收盘价

        for (int j = 0; j < Channel_Period; j++) {
            priceArray[j] = close[i + j];
        }
        
        // 计算标准差

        double stdDev = CalculateStdDev(priceArray, Channel_Period);
        
        // 计算通道上下轨（以快速MA为中线）

        UpperChannel_Buffer[i] = FastMA_Buffer[i] + stdDev * Channel_StdDev;
        LowerChannel_Buffer[i] = FastMA_Buffer[i] - stdDev * Channel_StdDev;
    }
    
    // ========== 在超买超卖点位标注RSI值 ==========

    if (Show_RSI_Labels && prev_calculated != rates_total) {
        for (int i = 0; i < MathMin(10, rates_total); i++) { // 只检查最近10根K线

            if (RSI_Buffer[i] >= RSI_Overbought || RSI_Buffer[i] <= RSI_Oversold) {
                string objName = "RSI_Label_" + TimeToString(time[i]);
                
                // 删除旧对象

                if (ObjectFind(0, objName) >= 0) {
                    ObjectDelete(0, objName);
                }
                
                // 创建文本标签

                if (ObjectCreate(0, objName, OBJ_TEXT, 0, time[i], high[i] + 10 * _Point)) {
                    ObjectSetString(0, objName, OBJPROP_TEXT, "RSI_" + DoubleToString(RSI_Buffer[i], 1));
                    ObjectSetInteger(0, objName, OBJPROP_COLOR, (RSI_Buffer[i] >= RSI_Overbought) ? clrRed : clrLime);
                    ObjectSetInteger(0, objName, OBJPROP_FONTSIZE, 8);
                    ObjectSetInteger(0, objName, OBJPROP_ANCHOR, ANCHOR_LOWER);
                }
            }
        }
    }
    
    return rates_total;
}

// ============ OnDeinit 清理 ============

void OnDeinit(const int reason)
{
    // 释放指标句柄

    if (FastMA_Handle != INVALID_HANDLE) IndicatorRelease(FastMA_Handle);
    if (SlowMA_Handle != INVALID_HANDLE) IndicatorRelease(SlowMA_Handle);
    if (RSI_Handle != INVALID_HANDLE) IndicatorRelease(RSI_Handle);
    
    // 删除所有RSI标签

    ObjectsDeleteAll(0, "RSI_Label_", 0, OBJ_TEXT);
}