Forex Tramp EA 4.0
MQL4策略实现

//+------------------------------------------------------------------+
//| Forex Tramp EA 4.0 Implementation                               |
//| Based on Strategy Documentation                                 |
//+------------------------------------------------------------------+

//--- 输入参数
input string SETname = "Default";            // 设置名称
input bool Flag_Stop = false;                // 停止开关
input int Magic = 123456;                    // 魔术号码
input double Filter = 20.0;                  // 数字滤波器步长
input double SL_fact = 2.0;                  // 止损因子
input double LotSize = 0.01;                 // 基础手数大小
input bool AutoMM = true;                    // 自动资金管理
input double AutoMM_Equity = 10000.0;        // AutoMM参考净值
input int Indent = 10;                       // 挂单缩进(点)
input double TakeProfit_Martin = 1.5;        // 马丁止盈乘数
input bool Verbose = true;                   // 详细日志

//--- 全局变量
double digiFilterUpper, digiFilterLower;
double currentLotSize;
int totalOpenOrders;
int martingaleStep;
double lastClosedOrderProfit;
int ticketArray[];
datetime lastTickTime;
string orderComment;

//+------------------------------------------------------------------+
//| EA初始化函数                                                     |
//+------------------------------------------------------------------+
int OnInit()
{
   // 初始化全局变量
   currentLotSize = LotSize;
   totalOpenOrders = 0;
   martingaleStep = 0;
   lastClosedOrderProfit = 0.0;
   orderComment = "ForexTramp4.0-" + SETname;
   
   // 验证输入参数
   if(Filter <= 0 || SL_fact <= 0 || LotSize <= 0 || AutoMM_Equity <= 0)
   {
      Print("错误：无效的输入参数值");
      return INIT_FAILED;
   }
   
   // 检查账户兼容性
   if(!CheckAccountCompatibility())
   {
      Print("错误：账户不兼容");
      return INIT_FAILED;
   }
   
   if(Verbose) Print("EA初始化成功，设置：", SETname);
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| 主tick处理函数                                                   |
//+------------------------------------------------------------------+
void OnTick()
{
   // 避免重复处理同一tick
   if(lastTickTime == TimeCurrent()) return;
   lastTickTime = TimeCurrent();
   
   // 检查交易条件
   if(!CheckTradingConditions()) return;
   
   // 使用数字滤波器计算当前交易范围
   CalculateTradingRange();
   
   // 检查现有订单并更新计数
   CheckForOpen();
   
   // 如果未达到最大订单数，生成信号
   if(totalOpenOrders < MaxOrders)
   {
      int signal = GenerateSignal();
      if(signal != NO_SIGNAL)
      {
         ExecuteTrade(signal);
      }
   }
   
   // 管理现有订单（止盈、止损、跟踪等）
   ManageOpenOrders();
}

//+------------------------------------------------------------------+
//| 使用数字滤波器计算交易范围                                        |
//+------------------------------------------------------------------+
void CalculateTradingRange()
{
   // 这里实现专有的数字滤波器逻辑
   // 基于当前价格和Filter参数计算上下边界
   double currentPrice = (Ask + Bid) / 2.0;
   digiFilterUpper = currentPrice + Filter * _Point;
   digiFilterLower = currentPrice - Filter * _Point;
   
   if(Verbose) Print("范围计算：Upper=", digiFilterUpper, " Lower=", digiFilterLower);
}

//+------------------------------------------------------------------+
//| 生成入场信号                                                     |
//+------------------------------------------------------------------+
int GenerateSignal()
{
   // 突破上边界 = 买入信号
   if(Ask > digiFilterUpper)
   {
      if(Verbose) Print("生成买入信号：价格突破上边界");
      return BUY_SIGNAL;
   }
   
   // 突破下边界 = 卖出信号
   if(Bid < digiFilterLower)
   {
      if(Verbose) Print("生成卖出信号：价格突破下边界");
      return SELL_SIGNAL;
   }
   
   return NO_SIGNAL;
}

//+------------------------------------------------------------------+
//| 执行交易                                                         |
//+------------------------------------------------------------------+
void ExecuteTrade(int signal)
{
   // 计算当前手数（考虑AutoMM和马丁格尔）
   double lots = CalculateLots();
   
   // 根据信号类型确定订单参数
   int orderType;
   double orderPrice, slPrice, tpPrice;
   
   if(signal == BUY_SIGNAL)
   {
      orderType = OP_BUYLIMIT;
      orderPrice = digiFilterUpper + Indent * _Point;
      slPrice = orderPrice - (Filter * SL_fact) * _Point;
      tpPrice = orderPrice + (Filter * TakeProfit_Martin) * _Point;
   }
   else // SELL_SIGNAL
   {
      orderType = OP_SELLLIMIT;
      orderPrice = digiFilterLower - Indent * _Point;
      slPrice = orderPrice + (Filter * SL_fact) * _Point;
      tpPrice = orderPrice - (Filter * TakeProfit_Martin) * _Point;
   }
   
   // 发送订单
   int ticket = OrderSend(Symbol(), orderType, lots, orderPrice, 3, slPrice, tpPrice, orderComment, Magic);
   
   if(ticket > 0)
   {
      if(Verbose) Print("订单发送成功，Ticket:", ticket);
      // 将ticket添加到管理数组
      AddTicketToArray(ticket);
   }
   else
   {
      Print("订单发送失败，错误:", GetLastError());
   }
}

//+------------------------------------------------------------------+
//| 使用AutoMM和马丁格尔计算手数                                     |
//+------------------------------------------------------------------+
double CalculateLots()
{
   double lots = LotSize;
   
   // 应用AutoMM
   if(AutoMM)
   {
      double equityRatio = AccountBalance() / AutoMM_Equity;
      lots *= equityRatio;
   }
   
   // 应用马丁格尔（如果上笔交易亏损）
   if(martingaleStep > 0)
   {
      lots *= MathPow(MartingaleFactor, martingaleStep);
   }
   
   // 确保不低于最小手数且不超过最大手数
   lots = MathMax(lots, MarketInfo(Symbol(), MODE_MINLOT));
   lots = MathMin(lots, MarketInfo(Symbol(), MODE_MAXLOT));
   
   return NormalizeDouble(lots, 2);
}

//+------------------------------------------------------------------+
//| 检查已有订单并更新计数                                            |
//+------------------------------------------------------------------+
void CheckForOpen()
{
   int count = 0;
   for(int i = OrdersTotal() - 1; i >= 0; i--)
   {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
      {
         if(OrderSymbol() == Symbol() && OrderMagicNumber() == Magic)
         {
            count++;
            
            // 检查是否有需要删除的过时挂单
            if((OrderType() == OP_BUYLIMIT || OrderType() == OP_SELLLIMIT) && 
               TimeCurrent() - OrderOpenTime() > PendingOrderExpiry)
            {
               OrderDelete(OrderTicket());
            }
         }
      }
   }
   
   totalOpenOrders = count;
   if(Verbose) Print("当前订单数：", totalOpenOrders);
}

//+------------------------------------------------------------------+
//| 管理开仓订单（止盈、止损、跟踪）                                 |
//+------------------------------------------------------------------+
void ManageOpenOrders()
{
   for(int i = 0; i < ArraySize(ticketArray); i++)
   {
      if(OrderSelect(ticketArray[i], SELECT_BY_TICKET))
      {
         // 检查是否需要平仓
         if(OrderType() == OP_BUY || OrderType() == OP_SELL)
         {
            CheckForClose(ticketArray[i]);
            
            // 实现跟踪止损逻辑（如果适用）
            if(HasTrailingStop)
            {
               TrailingStop(ticketArray[i]);
            }
         }
      }
   }
}

//+------------------------------------------------------------------+
//| 检查订单是否需要平仓                                             |
//+------------------------------------------------------------------+
void CheckForClose(int ticket)
{
   if(OrderSelect(ticket, SELECT_BY_TICKET))
   {
      bool shouldClose = false;
      
      // 检查是否达到止盈或止损
      if((OrderType() == OP_BUY && Bid >= OrderTakeProfit()) ||
         (OrderType() == OP_BUY && Bid <= OrderStopLoss()) ||
         (OrderType() == OP_SELL && Ask <= OrderTakeProfit()) ||
         (OrderType() == OP_SELL && Ask >= OrderStopLoss()))
      {
         shouldClose = true;
      }
      
      // 执行平仓
      if(shouldClose)
      {
         double profit = OrderProfit();
         OrderClose(ticket, OrderLots(), 
                   (OrderType() == OP_BUY) ? Bid : Ask, 3);
                   
         // 更新马丁格尔步数
         if(profit < 0) // 亏损交易
         {
            martingaleStep++;
         }
         else // 盈利交易，重置序列
         {
            martingaleStep = 0;
         }
         
         lastClosedOrderProfit = profit;
      }
   }
}

//+------------------------------------------------------------------+
//| EA反初始化函数                                                   |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   // 清理：删除图形对象、释放资源等
   if(Verbose) Print("EA已从图表移除，原因：", reason);
}

//+------------------------------------------------------------------+