MT4/MT5 智能交易策略: 基于价格间距和补仓机制

extern int magicNumber = 92133; // 魔术码
extern double initialLots = 0.5; // 初始手数
extern int interval = 100; // 间距
extern double replenishmentMultiplier = 0.6; // 补仓倍数
extern int maxReplenishmentCount = 5; // 补仓次数
extern double takeProfitAmount = 80; // 止盈金额

int totalOrders = 0; // 总订单数
int buyOrders = 0; // 多单订单数
int sellOrders = 0; // 空单订单数
double lastBuyOrderPrice = 0; // 最后一个多单的持仓价
double lastSellOrderPrice = 0; // 最后一个空单的持仓价

// 开仓函数
void OpenOrder(double lots, int type) {
   double price = Ask; // 当前最新价
   if (type == OP_BUY) {
      lastBuyOrderPrice = price;
      buyOrders++;
   } else if (type == OP_SELL) {
      lastSellOrderPrice = price;
      sellOrders++;
   }
   totalOrders++;
   
   OrderSend(Symbol(), type, lots, price, 3, 0, 0, 'MagicNumber', magicNumber, 0, Green);
}

// 平仓函数
void CloseOrder(int ticket) {
   OrderClose(ticket, OrderLots(), OrderClosePrice(), 3, Red);
   totalOrders--;
   if (OrderType() == OP_BUY)
      buyOrders--;
   else if (OrderType() == OP_SELL)
      sellOrders--;
}

// 补仓函数
void ReplenishOrder(int type) {
   double lots = OrderLots() * replenishmentMultiplier;
   if (type == OP_BUY && buyOrders < maxReplenishmentCount)
      OpenOrder(lots, OP_BUY);
   else if (type == OP_SELL && sellOrders < maxReplenishmentCount)
      OpenOrder(lots, OP_SELL);
}

// 策略主函数
void OnTick() {
   double price = Ask; // 当前最新价
   int orders = OrdersTotal(); // 当前订单数
   
   // 判断持仓多单没有空单，并且最新价小于目前持仓中第一个多单持仓价100点时（间距），以初始手数0.5手做空，多空共存
   if (buyOrders > 0 && sellOrders == 0 && price < lastBuyOrderPrice - interval) {
      CloseAllOrders();
      OpenOrder(initialLots, OP_SELL);
   }
   
   // 判断持仓多单没有空单，并且最新价大于目前持仓中第一个空单持仓价100点时（间距），则以初始手数0.5手做多，多空共存
   if (buyOrders > 0 && sellOrders == 0 && price > lastSellOrderPrice + interval) {
      CloseAllOrders();
      OpenOrder(initialLots, OP_BUY);
   }
   
   // 检查止盈金额是否达到阈值，如果达到则触发全部平仓
   double totalProfit = 0;
   for (int i = 0; i < orders; i++) {
      if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
         if (OrderMagicNumber() == magicNumber)
            totalProfit += OrderProfit();
      }
   }
   if (totalProfit >= takeProfitAmount)
      CloseAllOrders();
}

// 平掉所有订单
void CloseAllOrders() {
   int orders = OrdersTotal();
   for (int i = orders - 1; i >= 0; i--) {
      if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
         if (OrderMagicNumber() == magicNumber)
            CloseOrder(OrderTicket());
      }
   }
}

// 开仓逻辑函数
void OpenOrdersLogic() {
   double price = Ask; // 当前最新价
   
   // 如果没有持仓
   if (totalOrders == 0) {
      // 加200点挂单一次多单
      OpenOrder(initialLots, OP_BUYSTOP);
      
      // 减200点挂单一次空单
      OpenOrder(initialLots, OP_SELLSTOP);
   }
   // 挂单的多单成交
   else if (buyOrders == 1 && sellOrders == 1) {
      if (OrderSelect(0, SELECT_BY_POS, MODE_TRADES) && OrderMagicNumber() == magicNumber && OrderType() == OP_BUYSTOP) {
         // 删除挂单的空单
         CloseOrder(OrderTicket());
         
         double currentLots = initialLots;
         double currentPrice = lastBuyOrderPrice;
         int replenishmentCount = 0;
         
         // 根据最新价格每间隔100点开仓一次多单
         while (price - currentPrice >= interval && replenishmentCount < maxReplenishmentCount) {
            replenishmentCount++;
            currentLots *= replenishmentMultiplier;
            currentPrice += interval;
            OpenOrder(currentLots, OP_BUY);
         }
      }
   }
   // 挂单的空单成交
   else if (buyOrders == 1 && sellOrders == 1) {
      if (OrderSelect(0, SELECT_BY_POS, MODE_TRADES) && OrderMagicNumber() == magicNumber && OrderType() == OP_SELLSTOP) {
         // 删除挂单的多单
         CloseOrder(OrderTicket());
         
         double currentLots = initialLots;
         double currentPrice = lastSellOrderPrice;
         int replenishmentCount = 0;
         
         // 根据最新价格每间隔100点开仓一次空单
         while (currentPrice - price >= interval && replenishmentCount < maxReplenishmentCount) {
            replenishmentCount++;
            currentLots *= replenishmentMultiplier;
            currentPrice -= interval;
            OpenOrder(currentLots, OP_SELL);
         }
      }
   }
}

// 初始化函数
void OnInit() {
   totalOrders = 0;
   buyOrders = 0;
   sellOrders = 0;
   lastBuyOrderPrice = 0;
   lastSellOrderPrice = 0;
   OpenOrdersLogic();
}

// 入口点函数
void start() {
   OnTick();
}

代码说明:

外部变量: 定义了一些可配置的参数，例如魔术码、初始手数、价格间距、补仓倍数、最大补仓次数和止盈金额。
全局变量: 用于记录交易状态，例如总订单数、多单订单数、空单订单数、最后一个多单的持仓价和最后一个空单的持仓价。
OpenOrder 函数: 用于开仓，根据指定的类型（买入或卖出）和手数下单。
CloseOrder 函数: 用于平仓，根据订单号平掉指定的订单。
ReplenishOrder 函数: 用于补仓，根据指定的类型（买入或卖出）进行补仓操作。
OnTick 函数: 策略主函数，在每个价格变动时被调用，用于判断是否满足开仓、平仓或补仓条件。
CloseAllOrders 函数: 用于平掉所有订单。
OpenOrdersLogic 函数: 用于处理开仓逻辑，根据当前持仓情况进行挂单或直接开仓操作。
OnInit 函数: 初始化函数，在 EA 加载时被调用，用于初始化全局变量。
start 函数: 入口点函数，在 EA 开始运行时被调用，用于调用 OnTick 函数。

策略逻辑:

该策略使用价格间距和补仓机制进行交易。

初始状态: EA启动后，会挂一个买单和一个卖单，价格分别为当前价格加减200点。
开仓: 当挂单成交后，会根据当前价格和设定的间距，以递增的仓位进行开仓操作。
平仓: 当价格朝不利方向移动，达到设定的间距时，会平掉所有持仓并反向开仓。
止盈: 当总盈利达到设定的止盈金额时，会平掉所有持仓。

注意事项:

该策略仅供学习和参考，实际交易中请谨慎使用。
建议在模拟账户上充分测试后，再在真实账户上运行该策略。
交易过程中请注意风险控制，设置合理的止损和止盈。
以上代码仅供参考，实际使用时可能需要根据个人需求进行修改和调整。