MT4 自动交易策略：多空共存、止盈止损策略

本策略使用多空共存的方式，结合止盈止损机制，根据价格变动进行自动交易。

策略流程：

检查当前魔术码 (92133) 下是否存在持仓。
如果没有持仓，则根据最新价格加 200 点挂单一次多单，并根据最新价格减 200 点挂单一次空单。挂单手数为初始手数，即 0.5 手。
如果挂单的多单成交，则删除挂单的空单，并且在持仓价的基础上，每上涨 100 点，补仓一次。补仓手数为上一个多单手数的 0.6 倍，且多单最多补仓 5 次。
如果挂单的空单成交，则删除挂单的多单，并且在持仓价的基础上，每下跌 100 点，补仓一次。补仓手数为上一个空单手数的 0.6 倍，且空单最多补仓 5 次。
如果已经持仓多单，并且最新价小于第一单多单 100 点时（间距），则以初始手数 0.5 手做空，多空共存。
如果已经持仓空单，并且最新价大于第一单空单 100 点时（间距），则以初始手数 0.5 手做多，多空共存。
最后，判断当前魔术码下所有订单的总盈利是否达到 40 美金（止盈金额），如果达到则触发全部平仓。

可自定义参数：

magicNumber: 魔术码，用于识别您的交易订单
initialLots: 初始手数
gapPoints: 间距，用于判断是否进行补仓
addPositionMultiplier: 补仓倍数，每次补仓的手数为上一次手数的倍数
maxAddPositions: 最大补仓次数
takeProfitAmount: 止盈金额，当总盈利达到此金额时，会触发全部平仓

适用于 MetaTrader 4 (MT4) 平台的函数和变量

下面是一个用 MQ4 语言编写的示例代码，根据您的设定执行所述逻辑：

extern int magicNumber = 92133;
extern double initialLots = 0.5;
extern int gapPoints = 100;
extern double addPositionMultiplier = 0.6;
extern int maxAddPositions = 5;
extern double takeProfitAmount = 40.0;

int totalPositions = 0;

void OnTick()
{
    // 检查是否存在持仓
    bool hasOpenPositions = CheckOpenPositions();

    if (!hasOpenPositions)
    {
        // 获取最新价格
        double currentPrice = MarketInfo(Symbol(), MODE_BID);

        // 挂单挂多单和空单
        double buyStopPrice = currentPrice + 200 * Point;
        double sellStopPrice = currentPrice - 200 * Point;

        bool buyOrderPlaced = OrderSend(Symbol(), OP_BUYSTOP, initialLots, buyStopPrice, 0, 0, 0, 'Buy Stop', magicNumber, 0, Green);
        bool sellOrderPlaced = OrderSend(Symbol(), OP_SELLSTOP, initialLots, sellStopPrice, 0, 0, 0, 'Sell Stop', magicNumber, 0, Red);

        if (buyOrderPlaced && sellOrderPlaced)
        {
            totalPositions = 2;
        }
        else
        {
            Print('Failed to place buy and sell stop orders');
            return;
        }
    }
    
    // 获取当前持仓数量
    totalPositions = TotalPositions(magicNumber);

    // 检查挂单是否成交
    bool buyOrderFilled = CheckOrderFilled(OP_BUYSTOP, magicNumber);
    bool sellOrderFilled = CheckOrderFilled(OP_SELLSTOP, magicNumber);

    if (buyOrderFilled)
    {
        // 删除挂单的空单
        DeletePendingOrders(OP_SELLSTOP, magicNumber);

        // 获取持仓价格
        double openPrice = GetOpenPrice(magicNumber);

        int addPositionCount = 0;
        double positionLots = initialLots;

        while (addPositionCount < maxAddPositions)
        {
            // 每上涨 100 点补仓一次
            if (Bid >= openPrice + (addPositionCount + 1) * gapPoints * Point)
            {
                positionLots *= addPositionMultiplier;

                // 在这里执行补仓操作
                // ...
                
                addPositionCount++;
                totalPositions++;
            }
            else
            {
                break;
            }
        }
    }
    else if (sellOrderFilled)
    {
        // 删除挂单的多单
        DeletePendingOrders(OP_BUYSTOP, magicNumber);

        // 获取持仓价格
        double openPrice = GetOpenPrice(magicNumber);

        int addPositionCount = 0;
        double positionLots = initialLots;

        while (addPositionCount < maxAddPositions)
        {
            // 每下跌 100 点补仓一次
            if (Bid <= openPrice - (addPositionCount + 1) * gapPoints * Point)
            {
                positionLots *= addPositionMultiplier;

                // 在这里执行补仓操作
                // ...

                addPositionCount++;
                totalPositions++;
            }
            else
            {
                break;
            }
        }
    }

    // 判断总盈利是否达到止盈金额
    if (totalPositions > 0 && CalculateTotalProfit() >= takeProfitAmount)
    {
        // 触发全部平仓
        CloseAllPositions();
    }
}

bool CheckOpenPositions()
{
    for (int i = 0; i < OrdersTotal(); i++)
    {
        if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
            if (OrderMagicNumber() == magicNumber)
            {
                return true;
            }
        }
    }

    return false;
}

bool CheckOrderFilled(int orderType, int magic)
{
    for (int i = 0; i < OrdersTotal(); i++)
    {
        if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
            if (OrderMagicNumber() == magic && OrderType() == orderType && OrderSymbol() == Symbol() && OrderCloseTime() == 0)
            {
                return true;
            }
        }
    }

    return false;
}

void DeletePendingOrders(int orderType, int magic)
{
    for (int i = OrdersTotal() - 1; i >= 0; i--)
    {
        if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
            if (OrderMagicNumber() == magic && OrderType() == orderType && OrderSymbol() == Symbol())
            {
                OrderDelete(OrderTicket());
            }
        }
    }
}

double GetOpenPrice(int magic)
{
    for (int i = 0; i < OrdersTotal(); i++)
    {
        if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
            if (OrderMagicNumber() == magic && OrderCloseTime() == 0)
            {
                return OrderOpenPrice();
            }
        }
    }

    return 0.0;
}

int TotalPositions(int magic)
{
    int count = 0;

    for (int i = 0; i < OrdersTotal(); i++)
    {
        if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
            if (OrderMagicNumber() == magic && OrderCloseTime() == 0)
            {
                count++;
            }
        }
    }

    return count;
}

double CalculateTotalProfit()
{
    double totalProfit = 0.0;

    for (int i = 0; i < OrdersTotal(); i++)
    {
        if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
            totalProfit += OrderProfit();
        }
    }

    return totalProfit;
}

void CloseAllPositions()
{
    for (int i = OrdersTotal() - 1; i >= 0; i--)
    {
        if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
            OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), 0, Red);
        }
    }
}

注意：

上述代码只是一个示例，您需要根据自己的需求进行修改和完善。
在实际使用中，您可能需要添加适当的错误处理和其他必要的功能。
代码的执行也依赖于您的交易策略和所使用的指标。
建议在模拟账户中测试策略，并根据实际情况调整参数。
交易具有风险，请谨慎操作。