魔术码92133: 自动交易策略 - MT4 EA

本EA交易策略使用魔术码'92133'，自动执行交易，包括开仓、补仓和止盈止损等功能。策略支持自定义参数设置，适用于MetaTrader 4平台。

策略逻辑:

1. 检查持仓:
   • 若没有持仓，则根据最新价格加'100'点挂单一次多单，根据最新价格减'100'点挂单一次空单，挂单手数为初始手数。
2. 补仓:
   • 若挂单的多单成交，则删除挂单的空单，并且在持仓价的基础上每上涨'100'点，补仓一次，补仓手数依次为'0.3', '0.18', '0.1', '0.06', '0.03'，多单最多补仓'5'次。
   • 若挂单的空单成交，则删除挂单的多单，并且在持仓价的基础上每下跌'100'点，补仓一次，补仓手数依次为'0.3', '0.18', '0.1', '0.06', '0.03'，空单最多补仓'5'次。
3. 止损止盈:
   • 若持仓多单，最新价小于第一单多单'100'点时，以初始手数'0.5'手做空；
   • 若持仓空单，最新价大于第一单空单'100'点时，以初始手数'0.5'手做多。
4. 盈利目标:
   • 若总盈利达到'40'美金，触发全部平仓。

参数设置:

• 魔术码: '92133'
• 初始手数: '0.5'
• 间距: '100'
• 补仓倍数: '0.6'
• 补仓次数: '5'
• 盈利目标: '40' 美金

代码示例:

extern int MagicNumber = 92133; // 魔术码
extern double InitialLotSize = 0.5; // 初始手数
extern int Gap = 100; // 间距
extern double AddLotMultiplier = 0.6; // 补仓倍数
extern int MaxAddLotCount = 5; // 补仓次数
extern double ProfitTarget = 40; // 盈利目标（美金）

void OnTick()
{
    double latestPrice = MarketInfo(Symbol(), MODE_BID); // 获取最新价格
    int totalOrders = OrdersTotal(); // 获取订单总数

    // 检查当前魔术码下是否持仓
    bool hasPosition = false;
    for (int i = 0; i < totalOrders; i++)
    {
        if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES) && OrderMagicNumber() == MagicNumber)
        {
            hasPosition = true;
            break;
        }
    }

    // 如果没有持仓
    if (!hasPosition)
    {
        double entryPrice = latestPrice;
        double lotSize = InitialLotSize;

        // 根据最新价格加100点挂单一次多单
        double buyStopPrice = entryPrice + Gap;
        int buyStopOrderTicket = OrderSend(Symbol(), OP_BUYSTOP, lotSize, buyStopPrice, 0, 0, 0, "Buy Stop", MagicNumber, 0, Blue);

        // 根据最新价格减100点挂单一次空单
        double sellStopPrice = entryPrice - Gap;
        int sellStopOrderTicket = OrderSend(Symbol(), OP_SELLSTOP, lotSize, sellStopPrice, 0, 0, 0, "Sell Stop", MagicNumber, 0, Red);
        
        // 设置挂单的止损和止盈
        if (buyStopOrderTicket > 0)
        {
            OrderSelect(buyStopOrderTicket, SELECT_BY_TICKET);
            OrderModify(OrderTicket(), OrderOpenPrice(), NormalizeDouble(entryPrice - Gap * 2, Digits), OrderTakeProfit(), 0, Green);
        }
        if (sellStopOrderTicket > 0)
        {
            OrderSelect(sellStopOrderTicket, SELECT_BY_TICKET);
            OrderModify(OrderTicket(), OrderOpenPrice(), NormalizeDouble(entryPrice + Gap * 2, Digits), OrderTakeProfit(), 0, Green);
        }
    }
    else // 如果持仓
    {
        double firstOrderProfitTarget = 0;
        
        for (int j = 0; j < totalOrders; j++)
        {
            if (OrderSelect(j, SELECT_BY_POS, MODE_TRADES) && OrderMagicNumber() == MagicNumber)
            {
                double orderProfit = OrderProfit();
                
                // 判断当前魔术码下的所有持仓订单
                if (orderProfit >= ProfitTarget)
                {
                    OrderClose(OrderTicket(), OrderLots(), Bid, Slippage, Red);
                }
                else
                {
                    if (j == 0) // 第一单
                    {
                        firstOrderProfitTarget = orderProfit;
                        
                        // 如果持仓多单，最新价小于第一单多单100点时，以初始手数0.5手做空
                        if (OrderType() == OP_BUY && latestPrice < OrderOpenPrice() - Gap)
                        {
                            OrderClose(OrderTicket(), OrderLots(), Bid, Slippage, Red);
                            OrderSend(Symbol(), OP_SELL, InitialLotSize, 0, 0, 0, 0, "Initial Short", MagicNumber, 0, Red);
                        }
                        
                        // 如果持仓空单，最新价大于第一单空单100点时，以初始手数0.5手做多
                        if (OrderType() == OP_SELL && latestPrice > OrderOpenPrice() + Gap)
                        {
                            OrderClose(OrderTicket(), OrderLots(), Ask, Slippage, Red);
                            OrderSend(Symbol(), OP_BUY, InitialLotSize, 0, 0, 0, 0, "Initial Long", MagicNumber, 0, Blue);
                        }
                    }
                    else // 非第一单
                    {
                        int addLotCount = MathFloor(orderProfit / Gap); // 补仓次数计数

                        if (OrderType() == OP_BUY) // 多单
                        {
                            for (int k = 1; k <= addLotCount && k <= MaxAddLotCount; k++)
                            {
                                double addLotSize = InitialLotSize * MathPow(AddLotMultiplier, k);
                                double addLotEntryPrice = firstOrderProfitTarget + Gap * k;
                                OrderSend(Symbol(), OP_BUY, addLotSize, addLotEntryPrice, 0, 0, 0, "Buy Add", MagicNumber, 0, Blue);
                            }
                        }
                        else if (OrderType() == OP_SELL) // 空单
                        {
                            for (int k = 1; k <= addLotCount && k <= MaxAddLotCount; k++)
                            {
                                double addLotSize = InitialLotSize * MathPow(AddLotMultiplier, k);
                                double addLotEntryPrice = firstOrderProfitTarget - Gap * k;
                                OrderSend(Symbol(), OP_SELL, addLotSize, addLotEntryPrice, 0, 0, 0, "Sell Add", MagicNumber, 0, Red);
                            }
                        }
                    }
                }
            }
        }
    }
}

注意:

• 以上代码只是一个基础框架，实际使用时需要根据具体需求进行调整和完善。
• 在使用代码之前，请确保已经理解和测试了其中的每个功能，并根据实际情况进行修改和优化。
• 交易策略的风险很大，请谨慎使用，并自行承担所有风险。