精控呗441极端信号EA

#property copyright "XAUOF指标工坊"
#property version   "1.00"

#include <Trade\Trade.mqh>

//--- 输入参数
input group "========== 信号参数 =========="
input int    InpMagicNumber = 260813;              // 魔术号码
input bool   InpUseDoubleCandle = true;            // 启用双K线确认模式
input int    InpMinCandlePoints = 225;             // 做多最小K线幅度(点)
input int    InpMultiMinHighReq = 225;             // 做多最小涨幅要求(点)
input int    InpMultiMinLowReq = 225;              // 做多最小跌幅要求(点)
input bool   InpUseATRFilter = true;               // 启用ATR过滤器
input int    InpATRPeriod = 12;                    // ATR计算周期
input double InpMinATRPoints = 330.0;              // 最小ATR点数(只交易大于此值)
input bool   InpAutoAdjustTime = true;             // 启用自动周期适应
input int    InpTradeStartHour = 0;                // 开始交易的时间(服务器时间)，0=全天交易
input int    InpTradeEndHour = 0;                  // 结束交易的时间(服务器时间)，0=全天交易

input group "========== 止损止盈 =========="
input double InpFixedStopLoss = 0.0;               // 固定止损(0=自动计算)
input double InpRiskPercent = 1.0;                 // 风险百分比(0.1-20.0)
input double InpNormalStopPoints = 750;            // 普通止损(点)
input double InpNormalTakeProfitPoints = 5650;     // 普通止盈(点)
input bool   InpUseTimeBasedParams = false;        // 启用时段特定参数
input double InpPeakStopLoss = 850;                // 高峰柔时段止损(08:00-16:00)
input double InpPeakTakeProfit = 4250;             // 高峰柔时段止盈
input bool   InpUseMovingStop = true;              // 启用移动止损
input int    InpMovingStopActivate = 1350;         // 移动止盈盘启动点数(0=禁用，浮盈达此点数后启动)
input int    InpMovingStopDistance = 200;          // 移动止盈回撤点数(0=禁用，从最高/最低回撤此点数平仓)
input bool   InpUseTrailStop = true;               // 启用动态追踪止损
input int    InpTrailActivateProfit = 1600;        // 动态追踪启动盈利(点) - 盈利达到此点数后启动动态...
input int    InpTrailStopDistance = 300;           // 动态追踪距离(点) - 止损距离当前价格的点数

input group "========== 日盈亏控制 =========="
input double InpDailyProfitLimit = 12.0;           // 日盈利限制(%)
input double InpDailyLossLimit = 8.0;              // 日亏损限制(%)
input double InpDailyProfitAmount = 0.0;           // 日盈利金额限制($) (0=禁用)
input double InpDailyLossAmount = 0.0;             // 日亏损金额限制($) (0=禁用)
input int    InpMaxDailyTrades = 20;               // 最大日交易数
input bool   InpUseLossContinuousControl = true;   // 启用连续亏损控制

//--- 全局变量
CTrade trade;
int atrHandle = INVALID_HANDLE;
double atrBuffer[];
datetime lastBarTime = 0;
int dailyTradeCount = 0;
double dailyProfit = 0.0;
double dailyLoss = 0.0;
datetime lastResetDate = 0;
double consecutiveLoss = 0.0;
bool buyAllowed = true;
bool sellAllowed = true;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   // 设置魔术号
   trade.SetExpertMagicNumber(InpMagicNumber);
   trade.SetDeviationInPoints(10);
   trade.SetTypeFilling(ORDER_FILLING_FOK);
   if(trade.ResultRetcode() == TRADE_RETCODE_INVALID_FILL)
      trade.SetTypeFilling(ORDER_FILLING_IOC);
   
   // 创建ATR指标句柄
   if(InpUseATRFilter)
   {
      atrHandle = iATR(_Symbol, PERIOD_CURRENT, InpATRPeriod);
      if(atrHandle == INVALID_HANDLE)
      {
         Print("[初始化] ATR指标创建失败");
         return INIT_FAILED;
      }
   }
   
   ArraySetAsSeries(atrBuffer, true);
   
   Print("========== EA初始化成功 ==========");
   Print("[参数] 魔术号: ", InpMagicNumber);
   Print("[参数] 双K线确认: ", InpUseDoubleCandle ? "启用" : "禁用");
   Print("[参数] 最小K线幅度: ", InpMinCandlePoints, " 点");
   Print("[参数] ATR过滤: ", InpUseATRFilter ? "启用" : "禁用", ", 最小ATR: ", InpMinATRPoints, " 点");
   Print("[参数] 风险百分比: ", InpRiskPercent, "%");
   Print("[参数] 普通止损/止盈: ", InpNormalStopPoints, "/", InpNormalTakeProfitPoints, " 点");
   Print("[参数] 移动止损: ", InpUseMovingStop ? "启用" : "禁用", ", 启动点数: ", InpMovingStopActivate);
   Print("[参数] 动态追踪: ", InpUseTrailStop ? "启用" : "禁用", ", 启动盈利: ", InpTrailActivateProfit);
   Print("[参数] 日盈亏限制: +", InpDailyProfitLimit, "% / -", InpDailyLossLimit, "%");
   Print("[参数] 最大日交易数: ", InpMaxDailyTrades);
   Print("=================================");
   
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   if(atrHandle != INVALID_HANDLE)
      IndicatorRelease(atrHandle);
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   // 检查是否是新K线
   datetime currentBarTime = iTime(_Symbol, PERIOD_CURRENT, 0);
   if(currentBarTime == lastBarTime)
      return;
   lastBarTime = currentBarTime;
   
   // 重置日统计
   ResetDailyStats();
   
   // 检查交易权限
   if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
   {
      Print("[跳过] 终端不允许交易");
      return;
   }
   
   if(!MQLInfoInteger(MQL_TRADE_ALLOWED))
   {
      Print("[跳过] EA不允许交易");
      return;
   }
   
   // 检查日盈亏限制
   if(!CheckDailyLimits())
      return;
   
   // 检查交易时间
   if(!CheckTradingTime())
      return;
   
   // 更新移动止损和动态追踪
   ManageOpenPositions();
   
   // 检查是否达到最大日交易数
   if(dailyTradeCount >= InpMaxDailyTrades)
   {
      Print("[风控] 今日交易数已达上限 ", InpMaxDailyTrades);
      return;
   }
   
   // 检查开仓信号
   int signal = CheckSignal();
   
   if(signal == 1 && buyAllowed)
   {
      if(!HasPosition(POSITION_TYPE_BUY))
         OpenPosition(ORDER_TYPE_BUY);
   }
   else if(signal == -1 && sellAllowed)
   {
      if(!HasPosition(POSITION_TYPE_SELL))
         OpenPosition(ORDER_TYPE_SELL);
   }
}

//+------------------------------------------------------------------+
//| 检查交易信号                                                      |
//+------------------------------------------------------------------+
int CheckSignal()
{
   // 获取最近3根K线数据
   double close[], open[], high[], low[];
   ArraySetAsSeries(close, true);
   ArraySetAsSeries(open, true);
   ArraySetAsSeries(high, true);
   ArraySetAsSeries(low, true);
   
   if(CopyClose(_Symbol, PERIOD_CURRENT, 0, 3, close) < 3) return 0;
   if(CopyOpen(_Symbol, PERIOD_CURRENT, 0, 3, open) < 3) return 0;
   if(CopyHigh(_Symbol, PERIOD_CURRENT, 0, 3, high) < 3) return 0;
   if(CopyLow(_Symbol, PERIOD_CURRENT, 0, 3, low) < 3) return 0;
   
   // 获取ATR值
   double atrValue = 0;
   if(InpUseATRFilter)
   {
      if(BarsCalculated(atrHandle) < 2)
         return 0;
      
      if(CopyBuffer(atrHandle, 0, 0, 2, atrBuffer) < 2)
         return 0;
      
      atrValue = atrBuffer[0] / _Point;
      
      // ATR过滤
      if(atrValue < InpMinATRPoints)
      {
         return 0;
      }
   }
   
   // 计算第1根K线的涨跌幅（索引1是前一根已完成的K线）
   double candle1Range = MathAbs(close[1] - open[1]) / _Point;
   bool candle1Bullish = close[1] > open[1];
   bool candle1Bearish = close[1] < open[1];
   
   // 第1根K线必须满足最小幅度要求
   if(candle1Range < InpMinCandlePoints)
      return 0;
   
   // 双K线确认模式
   if(InpUseDoubleCandle)
   {
      // 做多信号：第1根看涨K线（收>开）且涨幅≥225点，第2根（当前K线）收盘突破第1根最高点
      if(candle1Bullish && candle1Range >= InpMultiMinHighReq)
      {
         if(close[0] > high[1])
         {
            Print("[信号] 做多信号触发 - 双K线突破，第1根涨幅:", (int)candle1Range, "点，第2根突破前高，ATR:", (int)atrValue, "点");
            return 1;
         }
      }
      
      // 做空信号：第1根看跌K线（收<开）且跌幅≥225点，第2根（当前K线）收盘突破第1根最低点
      if(candle1Bearish && candle1Range >= InpMultiMinLowReq)
      {
         if(close[0] < low[1])
         {
            Print("[信号] 做空信号触发 - 双K线突破，第1根跌幅:", (int)candle1Range, "点，第2根突破前低，ATR:", (int)atrValue, "点");
            return -1;
         }
      }
   }
   else
   {
      // 单K线模式（不需要第二根确认）
      if(candle1Bullish && candle1Range >= InpMultiMinHighReq)
      {
         Print("[信号] 做多信号触发 - 单K线模式，涨幅:", (int)candle1Range, "点，ATR:", (int)atrValue, "点");
         return 1;
      }
      
      if(candle1Bearish && candle1Range >= InpMultiMinLowReq)
      {
         Print("[信号] 做空信号触发 - 单K线模式，跌幅:", (int)candle1Range, "点，ATR:", (int)atrValue, "点");
         return -1;
      }
   }
   
   return 0;
}

//+------------------------------------------------------------------+
//| 开仓                                                              |
//+------------------------------------------------------------------+
void OpenPosition(ENUM_ORDER_TYPE orderType)
{
   double price = (orderType == ORDER_TYPE_BUY) ? 
                  SymbolInfoDouble(_Symbol, SYMBOL_ASK) : 
                  SymbolInfoDouble(_Symbol, SYMBOL_BID);
   
   // 计算止损止盈
   double sl = 0, tp = 0;
   CalculateStopLossTakeProfit(orderType, price, sl, tp);
   
   // 计算手数
   double lotSize = CalculateLotSize(sl, price);
   
   // 检查手数范围
   double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   
   lotSize = MathFloor(lotSize / lotStep) * lotStep;
   lotSize = MathMax(minLot, MathMin(maxLot, lotSize));
   
   // 执行开仓
   bool result = false;
   if(orderType == ORDER_TYPE_BUY)
      result = trade.Buy(lotSize, _Symbol, 0, sl, tp, "精控呗441");
   else
      result = trade.Sell(lotSize, _Symbol, 0, sl, tp, "精控呗441");
   
   if(result)
   {
      dailyTradeCount++;
      Print("[开仓] ", (orderType == ORDER_TYPE_BUY ? "做多" : "做空"), 
            " ", lotSize, " 手，价格:", price, "，止损:", sl, "，止盈:", tp);
   }
   else
   {
      Print("[开仓失败] 错误代码:", trade.ResultRetcode(), "，描述:", trade.ResultRetcodeDescription());
   }
}

//+------------------------------------------------------------------+
//| 计算止损止盈                                                      |
//+------------------------------------------------------------------+
void CalculateStopLossTakeProfit(ENUM_ORDER_TYPE orderType, double price, double &sl, double &tp)
{
   double stopLossPoints = InpNormalStopPoints;
   double takeProfitPoints = InpNormalTakeProfitPoints;
   
   // 如果启用时段特定参数
   if(InpUseTimeBasedParams)
   {
      MqlDateTime dt;
      TimeToStruct(TimeCurrent(), dt);
      if(dt.hour >= 8 && dt.hour < 16)
      {
         stopLossPoints = InpPeakStopLoss;
         takeProfitPoints = InpPeakTakeProfit;
      }
   }
   
   // 检查最小止损距离
   int stopsLevel = (int)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_STOPS_LEVEL);
   if(stopsLevel > 0)
   {
      stopLossPoints = MathMax(stopLossPoints, stopsLevel + 10);
      takeProfitPoints = MathMax(takeProfitPoints, stopsLevel + 10);
   }
   
   double point = _Point;
   
   if(orderType == ORDER_TYPE_BUY)
   {
      sl = price - stopLossPoints * point;
      tp = price + takeProfitPoints * point;
   }
   else
   {
      sl = price + stopLossPoints * point;
      tp = price - takeProfitPoints * point;
   }
   
   // 规范化价格
   int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   sl = NormalizeDouble(sl, digits);
   tp = NormalizeDouble(tp, digits);
}

//+------------------------------------------------------------------+
//| 计算手数（基于风险百分比）                                         |
//+------------------------------------------------------------------+
double CalculateLotSize(double sl, double entryPrice)
{
   if(InpRiskPercent <= 0 || sl == 0)
      return SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   
   double balance = AccountInfoDouble(ACCOUNT_BALANCE);
   double riskAmount = balance * InpRiskPercent / 100.0;
   
   double slDistance = MathAbs(entryPrice - sl);
   double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   
   if(tickSize == 0 || slDistance == 0)
      return SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   
   double lotSize = riskAmount / (slDistance / tickSize * tickValue);
   
   return lotSize;
}

//+------------------------------------------------------------------+
//| 管理已开仓位（移动止损和动态追踪）                                 |
//+------------------------------------------------------------------+
void ManageOpenPositions()
{
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket == 0) continue;
      
      if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
      if(PositionGetInteger(POSITION_MAGIC) != InpMagicNumber) continue;
      
      ENUM_POSITION_TYPE posType = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
      double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
      double currentSL = PositionGetDouble(POSITION_SL);
      double currentTP = PositionGetDouble(POSITION_TP);
      double profit = PositionGetDouble(POSITION_PROFIT);
      
      double currentPrice = (posType == POSITION_TYPE_BUY) ? 
                           SymbolInfoDouble(_Symbol, SYMBOL_BID) : 
                           SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      
      double profitPoints = 0;
      if(posType == POSITION_TYPE_BUY)
         profitPoints = (currentPrice - openPrice) / _Point;
      else
         profitPoints = (openPrice - currentPrice) / _Point;
      
      bool needModify = false;
      double newSL = currentSL;
      double newTP = currentTP;
      
      // 移动止盈（回撤平仓）
      if(InpUseMovingStop && InpMovingStopActivate > 0 && InpMovingStopDistance > 0)
      {
         if(profitPoints >= InpMovingStopActivate)
         {
            // 计算从最高/最低价回撤的距离
            if(posType == POSITION_TYPE_BUY)
            {
               double newStopPrice = currentPrice - InpMovingStopDistance * _Point;
               if(newStopPrice > currentSL)
               {
                  newSL = NormalizeDouble(newStopPrice, _Digits);
                  needModify = true;
               }
            }
            else
            {
               double newStopPrice = currentPrice + InpMovingStopDistance * _Point;
               if(currentSL == 0 || newStopPrice < currentSL)
               {
                  newSL = NormalizeDouble(newStopPrice, _Digits);
                  needModify = true;
               }
            }
         }
      }
      
      // 动态追踪止损
      if(InpUseTrailStop && InpTrailActivateProfit > 0 && InpTrailStopDistance > 0)
      {
         if(profitPoints >= InpTrailActivateProfit)
         {
            if(posType == POSITION_TYPE_BUY)
            {
               double trailStop = currentPrice - InpTrailStopDistance * _Point;
               if(trailStop > currentSL)
               {
                  newSL = NormalizeDouble(trailStop, _Digits);
                  needModify = true;
               }
            }
            else
            {
               double trailStop = currentPrice + InpTrailStopDistance * _Point;
               if(currentSL == 0 || trailStop < currentSL)
               {
                  newSL = NormalizeDouble(trailStop, _Digits);
                  needModify = true;
               }
            }
         }
      }
      
      // 执行修改
      if(needModify)
      {
         if(trade.PositionModify(ticket, newSL, currentTP))
         {
            Print("[止损调整] 订单:", ticket, "，新止损:", newSL, "，当前盈利:", (int)profitPoints, "点");
         }
      }
   }
}

//+------------------------------------------------------------------+
//| 检查是否有指定类型的持仓                                          |
//+------------------------------------------------------------------+
bool HasPosition(ENUM_POSITION_TYPE posType)
{
   for(int i = 0; i < PositionsTotal(); i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket == 0) continue;
      
      if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
      if(PositionGetInteger(POSITION_MAGIC) != InpMagicNumber) continue;
      if((ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == posType)
         return true;
   }
   return false;
}

//+------------------------------------------------------------------+
//| 检查交易时间                                                      |
//+------------------------------------------------------------------+
bool CheckTradingTime()
{
   if(InpTradeStartHour == 0 && InpTradeEndHour == 0)
      return true;
   
   MqlDateTime dt;
   TimeToStruct(TimeCurrent(), dt);
   
   // 周末不交易
   if(dt.day_of_week == 0 || dt.day_of_week == 6)
      return false;
   
   int currentHour = dt.hour;
   
   if(InpTradeStartHour < InpTradeEndHour)
   {
      if(currentHour < InpTradeStartHour || currentHour >= InpTradeEndHour)
         return false;
   }
   else if(InpTradeStartHour > InpTradeEndHour)
   {
      if(currentHour < InpTradeStartHour && currentHour >= InpTradeEndHour)
         return false;
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| 重置日统计                                                        |
//+------------------------------------------------------------------+
void ResetDailyStats()
{
   MqlDateTime dt;
   TimeToStruct(TimeCurrent(), dt);
   datetime currentDate = StringToTime(StringFormat("%04d.%02d.%02d", dt.year, dt.mon, dt.day));
   
   if(currentDate != lastResetDate)
   {
      dailyTradeCount = 0;
      dailyProfit = 0.0;
      dailyLoss = 0.0;
      buyAllowed = true;
      sellAllowed = true;
      consecutiveLoss = 0.0;
      lastResetDate = currentDate;
      
      Print("[日统计] 新交易日开始: ", TimeToString(currentDate, TIME_DATE));
   }
}

//+------------------------------------------------------------------+
//| 检查日盈亏限制                                                    |
//+------------------------------------------------------------------+
bool CheckDailyLimits()
{
   // 计算今日盈亏
   CalculateDailyProfitLoss();
   
   double balance = AccountInfoDouble(ACCOUNT_BALANCE);
   
   // 检查日盈利限制（百分比）
   if(InpDailyProfitLimit > 0)
   {
      double profitPercent = (dailyProfit / balance) * 100.0;
      if(profitPercent >= InpDailyProfitLimit)
      {
         Print("[风控] 今日盈利已达 ", DoubleToString(profitPercent, 2), "%，停止开仓");
         return false;
      }
   }
   
   // 检查日盈利限制（金额）
   if(InpDailyProfitAmount > 0 && dailyProfit >= InpDailyProfitAmount)
   {
      Print("[风控] 今日盈利已达 $", DoubleToString(dailyProfit, 2), "，停止开仓");
      return false;
   }
   
   // 检查日亏损限制（百分比）
   if(InpDailyLossLimit > 0)
   {
      double lossPercent = (dailyLoss / balance) * 100.0;
      if(lossPercent >= InpDailyLossLimit)
      {
         Print("[风控] 今日亏损已达 ", DoubleToString(lossPercent, 2), "%，停止开仓");
         return false;
      }
   }
   
   // 检查日亏损限制（金额）
   if(InpDailyLossAmount > 0 && dailyLoss >= InpDailyLossAmount)
   {
      Print("[风控] 今日亏损已达 $", DoubleToString(dailyLoss, 2), "，停止开仓");
      return false;
   }
   
   // 检查连续亏损控制
   if(InpUseLossContinuousControl && consecutiveLoss >= 200)
   {
      Print("[风控] 连续亏损已达 ", (int)consecutiveLoss, " 点，暂停开仓");
      return false;
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| 计算今日盈亏                                                      |
//+------------------------------------------------------------------+
void CalculateDailyProfitLoss()
{
   dailyProfit = 0.0;
   dailyLoss = 0.0;
   
   MqlDateTime dt;
   TimeToStruct(TimeCurrent(), dt);
   datetime todayStart = StringToTime(StringFormat("%04d.%02d.%02d 00:00", dt.year, dt.mon, dt.day));
   
   // 统计当前持仓的盈亏
   for(int i = 0; i < PositionsTotal(); i++)
   {
      ulong ticket = PositionGetTicket(i);
      if(ticket == 0) continue;
      
      if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
      if(PositionGetInteger(POSITION_MAGIC) != InpMagicNumber) continue;
      
      double profit = PositionGetDouble(POSITION_PROFIT);
      if(profit > 0)
         dailyProfit += profit;
      else
         dailyLoss += MathAbs(profit);
   }
   
   // 统计今日已平仓订单
   HistorySelect(todayStart, TimeCurrent());
   for(int i = 0; i < HistoryDealsTotal(); i++)
   {
      ulong ticket = HistoryDealGetTicket(i);
      if(ticket == 0) continue;
      
      if(HistoryDealGetString(ticket, DEAL_SYMBOL) != _Symbol) continue;
      if(HistoryDealGetInteger(ticket, DEAL_MAGIC) != InpMagicNumber) continue;
      if(HistoryDealGetInteger(ticket, DEAL_ENTRY) != DEAL_ENTRY_OUT) continue;
      
      double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);
      if(profit > 0)
      {
         dailyProfit += profit;
         consecutiveLoss = 0.0; // 重置连续亏损
      }
      else
      {
         dailyLoss += MathAbs(profit);
         consecutiveLoss += MathAbs(profit / _Point); // 累加连续亏损点数
      }
   }
}