MQL4: Алгоритм Частичного Закрытия Сетки для Снижения Просадки (Partial Grid Close)

#property copyright "FinFluct"
#property link      "https://finfluct.com"
#property version   "1.00"
#property strict

//--- Input parameters
extern int      MagicNumber         = 12345;    // Magic number for EA's orders
extern double   MinLossToClose      = 100.0;    // Minimum total loss (in account currency) for a grid to trigger partial close
extern double   ClosePercentage     = 0.25;     // Percentage of volume to close from each selected order (e.g., 0.25 for 25%)
extern int      MaxOrdersToClose    = 3;        // Maximum number of orders to partially close per processing cycle
extern bool     CloseOnlyOldest     = true;     // If true, closes oldest losing orders first; otherwise, closes most losing orders first
extern int      Slippage            = 3;        // Maximum allowed slippage in points
extern string   CommentPrefix       = "PartialClose"; // Prefix for order comments

//--- Structure to hold order information for sorting
struct OrderInfo {
    int      ticket;
    int      type;
    double   volume;
    double   profit;
    datetime openTime;
};

//--- Global variable to prevent multiple executions on the same tick
datetime lastTickTime = 0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit() {
    Print("Partial Grid Close EA initialized. Magic: ", MagicNumber);
    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
    Print("Partial Grid Close EA deinitialized.");
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick() {
    // Prevent multiple executions on the same tick
    if (lastTickTime == TimeCurrent()) return;
    lastTickTime = TimeCurrent();

    //--- Collect all relevant orders
    OrderInfo buyOrders[];
    OrderInfo sellOrders[];
    int buyCount = 0;
    int sellCount = 0;

    for (int i = OrdersTotal() - 1; i >= 0; i--) {
        if (!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;

        // Filter by current symbol and magic number
        if (OrderSymbol() != Symbol() || OrderMagicNumber() != MagicNumber) continue;

        // Only consider BUY and SELL orders
        if (OrderType() != OP_BUY && OrderType() != OP_SELL) continue;

        OrderInfo currentOrder;
        currentOrder.ticket = OrderTicket();
        currentOrder.type = OrderType();
        currentOrder.volume = OrderLots();
        currentOrder.profit = OrderProfit();
        currentOrder.openTime = OrderOpenTime();

        if (currentOrder.type == OP_BUY) {
            ArrayResize(buyOrders, buyCount + 1);
            buyOrders[buyCount] = currentOrder;
            buyCount++;
        } else if (currentOrder.type == OP_SELL) {
            ArrayResize(sellOrders, sellCount + 1);
            sellOrders[sellCount] = currentOrder;
            sellCount++;
        }
    }

    //--- Process BUY orders grid
    ProcessGrid(buyOrders, buyCount, OP_BUY);

    //--- Process SELL orders grid
    ProcessGrid(sellOrders, sellCount, OP_SELL);
}

//+------------------------------------------------------------------+
//| Helper function to process a grid of orders (either BUY or SELL) |
//+------------------------------------------------------------------+
void ProcessGrid(OrderInfo& orders[], int count, int orderType) {
    if (count == 0) return;

    //--- Calculate total profit/loss for this grid
    double totalGridProfit = 0;
    for (int i = 0; i < count; i++) {
        totalGridProfit += orders[i].profit;
    }

    //--- Check if the grid is in significant loss
    if (totalGridProfit < -MinLossToClose) {
        Print("Grid (", (orderType == OP_BUY ? "BUY" : "SELL"), ") total loss: ", DoubleToString(totalGridProfit, 2), " exceeds threshold: ", DoubleToString(MinLossToClose, 2));

        //--- Sort orders based on configuration
        if (CloseOnlyOldest) {
            // Sort by open time ascending (oldest first) using bubble sort
            for (int i = 0; i < count - 1; i++) {
                for (int j = i + 1; j < count; j++) {
                    if (orders[i].openTime > orders[j].openTime) {
                        OrderInfo temp = orders[i];
                        orders[i] = orders[j];
                        orders[j] = temp;
                    }
                }
            }
        } else {
            // Sort by profit ascending (most losing first) using bubble sort
            for (int i = 0; i < count - 1; i++) {
                for (int j = i + 1; j < count; j++) {
                    if (orders[i].profit > orders[j].profit) { // Swap if i is less losing than j
                        OrderInfo temp = orders[i];
                        orders[i] = orders[j];
                        orders[j] = temp;
                    }
                }
            }
        }

        int closedCount = 0;
        for (int i = 0; i < count && closedCount < MaxOrdersToClose; i++) {
            // Only consider closing losing orders
            if (orders[i].profit < 0) {
                double volumeToClose = orders[i].volume * ClosePercentage;

                // Ensure volume is within allowed limits
                double minLot = MarketInfo(Symbol(), MODE_MINLOT);
                double lotStep = MarketInfo(Symbol(), MODE_LOTSTEP);

                // Round volume to lot step
                volumeToClose = NormalizeDouble(volumeToClose / lotStep, 0) * lotStep;

                if (volumeToClose < minLot) {
                    Print("Calculated volume ", DoubleToString(volumeToClose, 2), " for order ", orders[i].ticket, " is less than min lot (", DoubleToString(minLot, 2), "). Skipping partial close.");
                    continue;
                }
                if (volumeToClose > orders[i].volume) { // Don't close more than available
                    volumeToClose = orders[i].volume;
                }

                // Select the order again to ensure it's still open and get fresh data
                if (OrderSelect(orders[i].ticket, SELECT_BY_TICKET)) {
                    double currentPrice;
                    if (orderType == OP_BUY) currentPrice = MarketInfo(Symbol(), MODE_BID);
                    else currentPrice = MarketInfo(Symbol(), MODE_ASK);

                    if (OrderClose(orders[i].ticket, volumeToClose, currentPrice, Slippage, CommentPrefix)) {
                        Print("Partially closed order #", orders[i].ticket, " (", (orderType == OP_BUY ? "BUY" : "SELL"), ") volume: ", DoubleToString(volumeToClose, 2), " at price: ", DoubleToString(currentPrice, Digits), ". Remaining volume: ", DoubleToString(OrderLots() - volumeToClose, 2));
                        closedCount++;
                        Sleep(100); // Small delay to avoid flooding the server
                    } else {
                        Print("Failed to partially close order #", orders[i].ticket, ". Error: ", GetLastError(), " (", ErrorDescription(GetLastError()), ")");
                    }
                } else {
                    Print("Failed to select order #", orders[i].ticket, " for partial close. It might have been closed already or ticket is invalid. Error: ", GetLastError(), " (", ErrorDescription(GetLastError()), ")");
                }
            }
        }
    }
}