黄金追涨杀跌高级策略EA

#property copyright "XAUUSD Advanced System"
#property version   "2.10"
#property strict
#property description "基于图表分析优化：均线排列确认+趋势强度评估+动态止盈"

// ============ 输入参数 ============
input double   InitialLots      = 0.01;         // 初始手数
input int      MaxOpenTrades    = 12;           // 最多持仓单数
input double   LotMultiplier    = 1.5;          // 手数倍增系数
input bool     UseTimeFilter    = true;         // 交易时间过滤
input int      StartHour        = 8;            // 开始小时
input int      EndHour          = 22;           // 结束小时

// ========== 趋势确认参数（关键改进）==========
input int      MA5Period        = 5;            // MA5周期
input int      MA15Period       = 15;           // MA15周期
input int      MA30Period       = 30;           // MA30周期
input double   MinTrendSpread   = 15.0;         // 最小趋势强度 点数（推荐 10-20）
input double   StrongTrendSpread = 30.0;        // 强趋势强度 点数（推荐 25-40）

// ========== 加仓参数 ==========
input int      AddPositionPoints = 60;          // 每涨/跌多少点加仓（推荐 40-80）
input int      MinAddInterval   = 2;            // 最小加仓间隔（分钟）
input bool     AggressiveMode   = true;         // 激进模式

// ========== 止损止盈参数 ==========
input int      StopLossPoints   = 120;          // 固定止损点数（根据波动率调整）
input int      DynamicTPPoints  = 250;          // 动态止盈点数（会根据持仓调整）
input int      BreakEvenPoints  = 70;           // 达到此点移动止损到成本
input int      TrailingDistance = 35;           // 追踪止盈距离
input int      TrailingStep     = 8;            // 追踪止盈步进

// ========== 动态止盈参数 ==========
input bool     UseDynamicTP     = true;         // 启用动态止盈
input double   ProfitTarget1    = 3.0;          // 第一目标 % - 快速获利
input double   ProfitTarget2    = 8.0;          // 第二目标 % - 中期获利
input double   ProfitTarget3    = 15.0;         // 第三目标 % - 大额获利
input double   PartialClosePercent = 40.0;      // 部分平仓比例

// ========== 风控参数 ==========
input double   MaxMarginPercent = 65.0;         // 最大保证金率
input double   MaxDrawdownPercent = 10.0;       // 最大回撤
input int      MaxConsecutiveLosses = 3;        // 最大连续亏损笔数
input bool     ShowPanel        = true;         // 显示面板
input int      MagicNumber      = 20240301;     // EA魔术号

// ============ 全局变量 ============
datetime       lastBuyOrderTime = 0;
datetime       lastSellOrderTime = 0;
double         lastBuyPrice = 0;
double         lastSellPrice = 0;
double         highestEquity = 0;
double         initialBalance = 0;
bool           profitLocked1 = false;
bool           profitLocked2 = false;
int            consecutiveLosses = 0;

// 面板相关
string         PANEL_PREFIX = "XAUUSD_Panel_";
int            currentPanelX = 10;
int            currentPanelY = 10;
int            PANEL_WIDTH = 340;
int            PANEL_HEIGHT = 380;

// ============ OnInit ============
int OnInit()
{
    initialBalance = AccountBalance();
    highestEquity = initialBalance;
    
    if(ShowPanel) {
        CreatePanel();
    }
    
    Print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Print("高级追涨杀跌EA已启动 - 基于图表优化");
    Print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Print("最小趋势强度: ", MinTrendSpread, " 点（图表中三线分离程度）");
    Print("强趋势强度: ", StrongTrendSpread, " 点");
    Print("初始手数: ", InitialLots, " | 手数倍增: ", LotMultiplier);
    Print("最多持仓: ", MaxOpenTrades, " 单");
    Print("盈利目标: ", ProfitTarget1, "% / ", ProfitTarget2, "% / ", ProfitTarget3, "%");
    Print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    
    return(INIT_SUCCEEDED);
}

// ============ OnDeinit ============
void OnDeinit(const int reason)
{
    // 清理面板对象
    ObjectsDeleteAll(0, PANEL_PREFIX);
}

// ============ OnTick ============
void OnTick()
{
    // ========== 风控检查 ==========
    double currentEquity = AccountEquity();
    if(currentEquity > highestEquity) {
        highestEquity = currentEquity;
    }
    
    CheckDrawdownProtection();
    
    if(UseDynamicTP) {
        ManageDynamicTakeProfit();
    }
    
    ManageTrailingStop();
    
    // ========== 时间过滤 ==========
    if(UseTimeFilter) {
        int currentHour = Hour();
        if(currentHour < StartHour || currentHour >= EndHour) {
            if(ShowPanel) UpdatePanel();
            return;
        }
    }
    
    // ========== 保证金检查 ==========
    if(GetMarginPercent() > MaxMarginPercent) {
        if(ShowPanel) UpdatePanel();
        return;
    }
    
    // ========== 连续亏损检查 ==========
    if(consecutiveLosses >= MaxConsecutiveLosses) {
        if(ShowPanel) UpdatePanel();
        return;
    }
    
    // ========== 获取关键数据 ==========
    double currentPrice = Close[0];
    double ask = Ask;
    double bid = Bid;
    double point = Point;
    
    // 获取均线值
    double ma5_cur = iMA(NULL, 0, MA5Period, 0, MODE_EMA, PRICE_CLOSE, 0);
    double ma15_cur = iMA(NULL, 0, MA15Period, 0, MODE_EMA, PRICE_CLOSE, 0);
    double ma30_cur = iMA(NULL, 0, MA30Period, 0, MODE_EMA, PRICE_CLOSE, 0);
    double sar_cur = iSAR(NULL, 0, 0.02, 0.2, 0);
    
    // ========== 趋势分析（关键改进）==========
    double upSpread = 0;
    double downSpread = 0;
    
    // 多头排列强度
    if(ma5_cur > ma15_cur && ma15_cur > ma30_cur) {
        upSpread = (ma5_cur - ma30_cur) / point;  // 转换为点数
    }
    
    // 空头排列强度
    if(ma5_cur < ma15_cur && ma15_cur < ma30_cur) {
        downSpread = (ma30_cur - ma5_cur) / point;  // 转换为点数
    }
    
    // 判断趋势确认
    bool upTrendConfirmed = (upSpread >= MinTrendSpread && sar_cur < currentPrice);
    bool downTrendConfirmed = (downSpread >= MinTrendSpread && sar_cur > currentPrice);
    bool strongUpTrend = (upSpread >= StrongTrendSpread);
    bool strongDownTrend = (downSpread >= StrongTrendSpread);
    
    int buyCount = CountOpenTradesByType(OP_BUY);
    int sellCount = CountOpenTradesByType(OP_SELL);
    int totalCount = buyCount + sellCount;
    
    datetime currentTime = TimeCurrent();
    int timeSinceBuy = (int)((currentTime - lastBuyOrderTime) / 60);
    int timeSinceSell = (int)((currentTime - lastSellOrderTime) / 60);
    
    // ========== 追涨逻辑 ==========
    if(upTrendConfirmed && buyCount < MaxOpenTrades) {
        bool shouldBuy = false;
        
        // 首单：强势上涨 + 趋势确认
        if(buyCount == 0 && strongUpTrend) {
            shouldBuy = true;
            Print("✓✓ 首单追涨触发: 强上涨 ", DoubleToStr(upSpread, 1), " 点");
        }
        // 加仓：价格继续上涨 + 时间间隔满足
        else if(buyCount > 0 && lastBuyPrice > 0) {
            double priceRise = ask - lastBuyPrice;
            double risePoints = priceRise / point;
            bool timeOK = (timeSinceBuy >= MinAddInterval);
            
            if(AggressiveMode && timeOK && risePoints >= AddPositionPoints * 0.7) {
                shouldBuy = true;
                Print("✓ 追涨加仓 #", buyCount + 1, ": 已涨 ", DoubleToStr(risePoints, 1), " 点 (趋势强度 ", DoubleToStr(upSpread, 1), ")");
            } else if(!AggressiveMode && timeOK && risePoints >= AddPositionPoints && strongUpTrend) {
                shouldBuy = true;
                Print("✓ 追涨加仓 #", buyCount + 1, ": 已涨 ", DoubleToStr(risePoints, 1), " 点");
            }
        }
        
        if(shouldBuy) {
            ExecuteBuy(buyCount);
            lastBuyOrderTime = currentTime;
            lastBuyPrice = ask;
            
            // 如果有卖单且趋势强烈反转，平掉卖单
            if(sellCount > 0 && strongUpTrend) {
                Print("⚠ 趋势反转，平掉所有卖单");
                CloseAllByType(OP_SELL);
            }
        }
    }
    
    // ========== 杀跌逻辑 ==========
    if(downTrendConfirmed && sellCount < MaxOpenTrades) {
        bool shouldSell = false;
        
        // 首单：强势下跌 + 趋势确认
        if(sellCount == 0 && strongDownTrend) {
            shouldSell = true;
            Print("✓✓ 首单杀跌触发: 强下跌 ", DoubleToStr(downSpread, 1), " 点");
        }
        // 加仓：价格继续下跌
        else if(sellCount > 0 && lastSellPrice > 0) {
            double priceFall = lastSellPrice - bid;
            double fallPoints = priceFall / point;
            bool timeOK = (timeSinceSell >= MinAddInterval);
            
            if(AggressiveMode && timeOK && fallPoints >= AddPositionPoints * 0.7) {
                shouldSell = true;
                Print("✓ 杀跌加仓 #", sellCount + 1, ": 已跌 ", DoubleToStr(fallPoints, 1), " 点 (趋势强度 ", DoubleToStr(downSpread, 1), ")");
            } else if(!AggressiveMode && timeOK && fallPoints >= AddPositionPoints && strongDownTrend) {
                shouldSell = true;
                Print("✓ 杀跌加仓 #", sellCount + 1, ": 已跌 ", DoubleToStr(fallPoints, 1), " 点");
            }
        }
        
        if(shouldSell) {
            ExecuteSell(sellCount);
            lastSellOrderTime = currentTime;
            lastSellPrice = bid;
            
            // 如果有买单且趋势强烈反转，平掉买单
            if(buyCount > 0 && strongDownTrend) {
                Print("⚠ 趋势反转，平掉所有买单");
                CloseAllByType(OP_BUY);
            }
        }
    }
    
    // ========== 更新面板 ==========
    if(ShowPanel) {
        UpdatePanel();
    }
}

// ============ 回撤保护 ============
void CheckDrawdownProtection()
{
    double currentEquity = AccountEquity();
    double drawdown = 0;
    
    if(highestEquity > initialBalance) {
        drawdown = ((highestEquity - currentEquity) / highestEquity) * 100;
    }
    
    if(drawdown >= MaxDrawdownPercent) {
        int posCount = CountAllOpenTrades();
        if(posCount > 0) {
            Print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            Print("✗ 回撤保护: 从最高点回撤 ", DoubleToStr(drawdown, 2), "%");
            CloseAllPositions();
            Print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            
            initialBalance = currentEquity;
            highestEquity = currentEquity;
            profitLocked1 = false;
            profitLocked2 = false;
            consecutiveLosses++;
        }
    }
}

// ============ 动态止盈管理 ============
void ManageDynamicTakeProfit()
{
    double profitPercent = GetProfitPercent();
    int totalPositions = CountAllOpenTrades();
    
    if(totalPositions == 0) return;
    
    // 第一阶段：达到第一目标，部分平仓
    if(!profitLocked1 && profitPercent >= ProfitTarget1) {
        int closeCount = (int)(totalPositions * PartialClosePercent / 100.0);
        if(closeCount > 0) {
            Print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            Print("✓ 第一目标 ", DoubleToStr(profitPercent, 2), "% 达成，部分平仓 ", closeCount, " 单");
            PartialClosePositions(closeCount);
            profitLocked1 = true;
            Print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
        }
    }
    
    // 第二阶段：达到第二目标，再次部分平仓
    if(!profitLocked2 && profitPercent >= ProfitTarget2) {
        int remaining = CountAllOpenTrades();
        int closeCount = (int)(remaining * PartialClosePercent / 100.0);
        if(closeCount > 0) {
            Print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            Print("✓ 第二目标 ", DoubleToStr(profitPercent, 2), "% 达成，再次平仓 ", closeCount, " 单");
            PartialClosePositions(closeCount);
            profitLocked2 = true;
            Print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
        }
    }
    
    // 第三阶段：达到第三目标，全部平仓
    if(profitPercent >= ProfitTarget3) {
        int remaining = CountAllOpenTrades();
        if(remaining > 0) {
            Print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            Print("✓✓✓ 第三目标 ", DoubleToStr(profitPercent, 2), "% 达成，全部平仓！");
            CloseAllPositions();
            Print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            
            initialBalance = AccountBalance();
            highestEquity = initialBalance;
            profitLocked1 = false;
            profitLocked2 = false;
            consecutiveLosses = 0;
        }
    }
}

// ============ 部分平仓 ============
void PartialClosePositions(int count)
{
    int closed = 0;
    
    for(int i = OrdersTotal() - 1; i >= 0 && closed < count; i--) {
        if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
        if(OrderSymbol() != Symbol()) continue;
        if(OrderMagicNumber() != MagicNumber) continue;
        
        if(OrderType() == OP_BUY || OrderType() == OP_SELL) {
            if(OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), 10, clrNONE)) {
                closed++;
            }
        }
    }
    
    Print("  实际平仓 ", closed, " 单");
}

// ============ 管理追踪止损 ============
void ManageTrailingStop()
{
    double point = Point;
    
    for(int i = OrdersTotal() - 1; i >= 0; i--) {
        if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
        if(OrderSymbol() != Symbol()) continue;
        if(OrderMagicNumber() != MagicNumber) continue;
        if(OrderType() != OP_BUY && OrderType() != OP_SELL) continue;
        
        double openPrice = OrderOpenPrice();
        double currentSL = OrderStopLoss();
        double currentTP = OrderTakeProfit();
        
        if(OrderType() == OP_BUY) {
            double profit = Bid - openPrice;
            double profitPoints = profit / point;
            
            if(profitPoints >= BreakEvenPoints) {
                double newSL = Bid - TrailingDistance * point;
                
                if(newSL > currentSL + TrailingStep * point && newSL < Bid) {
                    if(OrderModify(OrderTicket(), openPrice, newSL, currentTP, 0, clrNONE)) {
                        Print("✓ 买单 #", OrderTicket(), " 追踪止损: ", DoubleToStr(currentSL, Digits), " → ", DoubleToStr(newSL, Digits));
                    }
                }
            }
        }
        else if(OrderType() == OP_SELL) {
            double profit = openPrice - Ask;
            double profitPoints = profit / point;
            
            if(profitPoints >= BreakEvenPoints) {
                double newSL = Ask + TrailingDistance * point;
                
                if(newSL < currentSL - TrailingStep * point && newSL > Ask) {
                    if(OrderModify(OrderTicket(), openPrice, newSL, currentTP, 0, clrNONE)) {
                        Print("✓ 卖单 #", OrderTicket(), " 追踪止损: ", DoubleToStr(currentSL, Digits), " → ", DoubleToStr(newSL, Digits));
                    }
                }
            }
        }
    }
}

// ============ 执行买入（递增手数）============
void ExecuteBuy(int currentBuyCount)
{
    double ask = Ask;
    if(ask <= 0 || currentBuyCount >= MaxOpenTrades) return;
    
    // 计算递增手数
    double lots = InitialLots * MathPow(LotMultiplier, currentBuyCount);
    lots = NormalizeDouble(lots, 2);
    
    // 限制最大手数
    double maxLot = MarketInfo(Symbol(), MODE_MAXLOT);
    if(lots > maxLot) lots = maxLot;
    
    double point = Point;
    double stopLoss = ask - StopLossPoints * point;
    double takeProfit = ask + DynamicTPPoints * point;
    
    // 检查保证金
    double freeMargin = AccountFreeMargin();
    if(freeMargin < lots * 100) {
        Print("⚠ 买单 #", currentBuyCount + 1, " 保证金不足（需要手数: ", DoubleToStr(lots, 2), "）");
        return;
    }
    
    int ticket = OrderSend(Symbol(), OP_BUY, lots, ask, 10, stopLoss, takeProfit, 
                          "BUY #" + IntegerToString(currentBuyCount + 1) + " " + DoubleToStr(lots, 2), 
                          MagicNumber, 0, clrGreen);
    
    if(ticket > 0) {
        Print("✓ 买单 #", currentBuyCount + 1, " 已开: Ticket=", ticket, ", 手数=", DoubleToStr(lots, 2), ", 价格=", DoubleToStr(ask, Digits));
    } else {
        Print("✗ 买单 #", currentBuyCount + 1, " 失败: Error ", GetLastError());
    }
}

// ============ 执行卖出（递增手数）============
void ExecuteSell(int currentSellCount)
{
    double bid = Bid;
    if(bid <= 0 || currentSellCount >= MaxOpenTrades) return;
    
    // 计算递增手数
    double lots = InitialLots * MathPow(LotMultiplier, currentSellCount);
    lots = NormalizeDouble(lots, 2);
    
    // 限制最大手数
    double maxLot = MarketInfo(Symbol(), MODE_MAXLOT);
    if(lots > maxLot) lots = maxLot;
    
    double point = Point;
    double stopLoss = bid + StopLossPoints * point;
    double takeProfit = bid - DynamicTPPoints * point;
    
    // 检查保证金
    double freeMargin = AccountFreeMargin();
    if(freeMargin < lots * 100) {
        Print("⚠ 卖单 #", currentSellCount + 1, " 保证金不足（需要手数: ", DoubleToStr(lots, 2), "）");
        return;
    }
    
    int ticket = OrderSend(Symbol(), OP_SELL, lots, bid, 10, stopLoss, takeProfit, 
                          "SELL #" + IntegerToString(currentSellCount + 1) + " " + DoubleToStr(lots, 2), 
                          MagicNumber, 0, clrRed);
    
    if(ticket > 0) {
        Print("✓ 卖单 #", currentSellCount + 1, " 已开: Ticket=", ticket, ", 手数=", DoubleToStr(lots, 2), ", 价格=", DoubleToStr(bid, Digits));
    } else {
        Print("✗ 卖单 #", currentSellCount + 1, " 失败: Error ", GetLastError());
    }
}

// ============ 获取保证金率 ============
double GetMarginPercent()
{
    double balance = AccountBalance();
    double margin = AccountMargin();
    
    if(balance <= 0) return 0;
    
    return (margin / balance) * 100;
}

// ============ 获取盈亏百分比 ============
double GetProfitPercent()
{
    double equity = AccountEquity();
    
    if(initialBalance <= 0) return 0;
    
    return ((equity - initialBalance) / initialBalance) * 100;
}

// ============ 计数所有持仓 ============
int CountAllOpenTrades()
{
    int count = 0;
    
    for(int i = 0; i < OrdersTotal(); i++) {
        if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
        if(OrderSymbol() != Symbol()) continue;
        if(OrderMagicNumber() != MagicNumber) continue;
        if(OrderType() == OP_BUY || OrderType() == OP_SELL) {
            count++;
        }
    }
    
    return count;
}

// ============ 计数指定方向持仓 ============
int CountOpenTradesByType(int orderType)
{
    int count = 0;
    
    for(int i = 0; i < OrdersTotal(); i++) {
        if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
        if(OrderSymbol() != Symbol()) continue;
        if(OrderMagicNumber() != MagicNumber) continue;
        if(OrderType() == orderType) {
            count++;
        }
    }
    
    return count;
}

// ============ 平仓所有持仓 ============
void CloseAllPositions()
{
    int closed = 0;
    
    for(int i = OrdersTotal() - 1; i >= 0; i--) {
        if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
        if(OrderSymbol() != Symbol()) continue;
        if(OrderMagicNumber() != MagicNumber) continue;
        
        if(OrderType() == OP_BUY || OrderType() == OP_SELL) {
            if(OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), 10, clrNONE)) {
                closed++;
            }
        }
    }
    
    Print("✓ 已平仓 ", closed, " 单");
}

// ============ 平仓指定类型持仓 ============
void CloseAllByType(int orderType)
{
    int closed = 0;
    
    for(int i = OrdersTotal() - 1; i >= 0; i--) {
        if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
        if(OrderSymbol() != Symbol()) continue;
        if(OrderMagicNumber() != MagicNumber) continue;
        
        if(OrderType() == orderType) {
            if(OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), 10, clrNONE)) {
                closed++;
            }
        }
    }
    
    string typeStr = (orderType == OP_BUY) ? "买单" : "卖单";
    Print("✓ 已平仓所有", typeStr, " ", closed, " 单");
}

// ============ 创建资金面板 ============
void CreatePanel()
{
    // 清除旧的面板对象
    ObjectsDeleteAll(0, PANEL_PREFIX);
    
    // 创建背景矩形
    string bgName = PANEL_PREFIX + "Background";
    ObjectCreate(bgName, OBJ_RECTANGLE_LABEL, 0, 0, 0);
    ObjectSet(bgName, OBJPROP_XDISTANCE, currentPanelX);
    ObjectSet(bgName, OBJPROP_YDISTANCE, currentPanelY);
    ObjectSet(bgName, OBJPROP_XSIZE, PANEL_WIDTH);
    ObjectSet(bgName, OBJPROP_YSIZE, PANEL_HEIGHT);
    ObjectSet(bgName, OBJPROP_BGCOLOR, C'40,40,40');
    ObjectSet(bgName, OBJPROP_BORDER_TYPE, BORDER_FLAT);
    ObjectSet(bgName, OBJPROP_CORNER, CORNER_LEFT_UPPER);
    ObjectSet(bgName, OBJPROP_SELECTABLE, false);
    
    // 标题
    CreatePanelLabel(PANEL_PREFIX + "Title", "━━━ 智能风控面板 ━━━", 10, 10, clrYellow, 10);
    
    // 各项数据标签
    CreatePanelLabel(PANEL_PREFIX + "Balance", "账户余额: ", 15, 40, clrWhite, 9);
    CreatePanelLabel(PANEL_PREFIX + "BalanceVal", "0.00", 180, 40, clrLime, 9);
    
    CreatePanelLabel(PANEL_PREFIX + "Equity", "账户净值: ", 15, 60, clrWhite, 9);
    CreatePanelLabel(PANEL_PREFIX + "EquityVal", "0.00", 180, 60, clrLime, 9);
    
    CreatePanelLabel(PANEL_PREFIX + "Margin", "保证金率: ", 15, 80, clrWhite, 9);
    CreatePanelLabel(PANEL_PREFIX + "MarginVal", "0.00%", 180, 80, clrOrange, 9);
    
    CreatePanelLabel(PANEL_PREFIX + "Profit", "盈亏比例: ", 15, 100, clrWhite, 9);
    CreatePanelLabel(PANEL_PREFIX + "ProfitVal", "0.00%", 180, 100, clrAqua, 9);
    
    CreatePanelLabel(PANEL_PREFIX + "FloatingProfit", "浮动盈亏: ", 15, 120, clrWhite, 9);
    CreatePanelLabel(PANEL_PREFIX + "FloatingProfitVal", "0.00", 180, 120, clrAqua, 9);
    
    CreatePanelLabel(PANEL_PREFIX + "Drawdown", "当前回撤: ", 15, 140, clrWhite, 9);
    CreatePanelLabel(PANEL_PREFIX + "DrawdownVal", "0.00%", 180, 140, clrRed, 9);
    
    CreatePanelLabel(PANEL_PREFIX + "BuyCount", "买单数量: ", 15, 160, clrWhite, 9);
    CreatePanelLabel(PANEL_PREFIX + "BuyCountVal", "0", 180, 160, clrLime, 9);
    
    CreatePanelLabel(PANEL_PREFIX + "SellCount", "卖单数量: ", 15, 180, clrWhite, 9);
    CreatePanelLabel(PANEL_PREFIX + "SellCountVal", "0", 180, 180, clrRed, 9);
    
    CreatePanelLabel(PANEL_PREFIX + "TotalCount", "总持仓数: ", 15, 200, clrWhite, 9);
    CreatePanelLabel(PANEL_PREFIX + "TotalCountVal", "0", 180, 200, clrYellow, 9);
    
    CreatePanelLabel(PANEL_PREFIX + "Trend", "趋势强度: ", 15, 220, clrWhite, 9);
    CreatePanelLabel(PANEL_PREFIX + "TrendVal", "中性", 180, 220, clrGray, 9);
    
    CreatePanelLabel(PANEL_PREFIX + "NextTarget", "下一目标: ", 15, 240, clrWhite, 9);
    CreatePanelLabel(PANEL_PREFIX + "NextTargetVal", "--", 180, 240, clrGold, 9);
    
    CreatePanelLabel(PANEL_PREFIX + "Status", "状态: 运行中", 15, 270, clrLime, 10);
    CreatePanelLabel(PANEL_PREFIX + "Time", TimeToStr(TimeCurrent(), TIME_DATE|TIME_SECONDS), 15, 290, clrSilver, 8);
    
    CreatePanelLabel(PANEL_PREFIX + "Version", "v2.10 图表优化版", 15, 310, clrGray, 7);
    
    // 分隔线
    CreatePanelLabel(PANEL_PREFIX + "Divider", "━━━━━━━━━━━━━━━━━━━━━", 15, 330, clrDimGray, 8);
    
    CreatePanelLabel(PANEL_PREFIX + "Tip", "基于均线排列强度确认趋势", 15, 350, clrGray, 8);
    
    ChartRedraw();
}

// ============ 创建面板标签 ============
void CreatePanelLabel(string name, string text, int x, int y, color clr, int fontSize)
{
    ObjectCreate(name, OBJ_LABEL, 0, 0, 0);
    ObjectSetText(name, text, fontSize, "Arial", clr);
    ObjectSet(name, OBJPROP_XDISTANCE, currentPanelX + x);
    ObjectSet(name, OBJPROP_YDISTANCE, currentPanelY + y);
    ObjectSet(name, OBJPROP_CORNER, CORNER_LEFT_UPPER);
    ObjectSet(name, OBJPROP_SELECTABLE, false);
}

// ============ 更新面板数据 ============
void UpdatePanel()
{
    if(!ShowPanel) return;
    
    double balance = AccountBalance();
    double equity = AccountEquity();
    double marginPercent = GetMarginPercent();
    double profitPercent = GetProfitPercent();
    double floatingProfit = equity - balance;
    
    // 计算回撤
    double drawdown = 0;
    if(highestEquity > initialBalance) {
        drawdown = ((highestEquity - equity) / highestEquity) * 100;
    }
    
    int buyCount = CountOpenTradesByType(OP_BUY);
    int sellCount = CountOpenTradesByType(OP_SELL);
    int totalCount = buyCount + sellCount;
    
    // 计算趋势强度
    double ma5 = iMA(NULL, 0, MA5Period, 0, MODE_EMA, PRICE_CLOSE, 0);
    double ma15 = iMA(NULL, 0, MA15Period, 0, MODE_EMA, PRICE_CLOSE, 0);
    double ma30 = iMA(NULL, 0, MA30Period, 0, MODE_EMA, PRICE_CLOSE, 0);
    
    double upSpread = 0;
    double downSpread = 0;
    string trendText = "中性";
    color trendColor = clrGray;
    
    if(ma5 > ma15 && ma15 > ma30) {
        upSpread = (ma5 - ma30) / Point;
        trendText = "上涨 " + DoubleToStr(upSpread, 0) + " 点";
        trendColor = clrLime;
    } else if(ma5 < ma15 && ma15 < ma30) {
        downSpread = (ma30 - ma5) / Point;
        trendText = "下跌 " + DoubleToStr(downSpread, 0) + " 点";
        trendColor = clrRed;
    }
    
    // 计算下一个盈利目标
    string nextTarget = "--";
    if(!profitLocked1) {
        nextTarget = "目标1: " + DoubleToStr(ProfitTarget1, 1) + "%";
    } else if(!profitLocked2) {
        nextTarget = "目标2: " + DoubleToStr(ProfitTarget2, 1) + "%";
    } else {
        nextTarget = "目标3: " + DoubleToStr(ProfitTarget3, 1) + "%";
    }
    
    // 更新显示
    ObjectSetText(PANEL_PREFIX + "BalanceVal", DoubleToStr(balance, 2), 9, "Arial", clrLime);
    ObjectSetText(PANEL_PREFIX + "EquityVal", DoubleToStr(equity, 2), 9, "Arial", equity >= balance ? clrLime : clrRed);
    ObjectSetText(PANEL_PREFIX + "MarginVal", DoubleToStr(marginPercent, 2) + "%", 9, "Arial", 
                  marginPercent > 50 ? clrRed : clrOrange);
    ObjectSetText(PANEL_PREFIX + "ProfitVal", DoubleToStr(profitPercent, 2) + "%", 9, "Arial", 
                  profitPercent >= 0 ? clrLime : clrRed);
    ObjectSetText(PANEL_PREFIX + "FloatingProfitVal", DoubleToStr(floatingProfit, 2), 9, "Arial", 
                  floatingProfit >= 0 ? clrLime : clrRed);
    ObjectSetText(PANEL_PREFIX + "DrawdownVal", DoubleToStr(drawdown, 2) + "%", 9, "Arial", 
                  drawdown > 5 ? clrRed : clrOrange);
    ObjectSetText(PANEL_PREFIX + "BuyCountVal", IntegerToString(buyCount), 9, "Arial", clrLime);
    ObjectSetText(PANEL_PREFIX + "SellCountVal", IntegerToString(sellCount), 9, "Arial", clrRed);
    ObjectSetText(PANEL_PREFIX + "TotalCountVal", IntegerToString(totalCount), 9, "Arial", clrYellow);
    ObjectSetText(PANEL_PREFIX + "TrendVal", trendText, 9, "Arial", trendColor);
    ObjectSetText(PANEL_PREFIX + "NextTargetVal", nextTarget, 9, "Arial", clrGold);
    ObjectSetText(PANEL_PREFIX + "Time", TimeToStr(TimeCurrent(), TIME_DATE|TIME_SECONDS), 8, "Arial", clrSilver);
    
    // 更新状态
    string status = "运行中";
    color statusColor = clrLime;
    
    if(consecutiveLosses >= MaxConsecutiveLosses) {
        status = "暂停: 连续止损";
        statusColor = clrRed;
    } else if(marginPercent > MaxMarginPercent) {
        status = "保证金超限";
        statusColor = clrOrange;
    } else if(drawdown >= MaxDrawdownPercent * 0.8) {
        status = "警告: 回撤接近上限";
        statusColor = clrYellow;
    }
    
    ObjectSetText(PANEL_PREFIX + "Status", "状态: " + status, 10, "Arial", statusColor);
    
    ChartRedraw();
}