Bloques de órdenes invalidados: Reutilización como bloques de mitigación (SMC)
Índice:
- Introducción
- Comprender el bloque de mitigación
- Primeros pasos
- Resultados de la prueba retrospectiva
- Conclusión
Introducción
En la operativa basada en los conceptos de dinero inteligente (SMC), los bloques de órdenes representan zonas clave en las que los operadores institucionales acumulan o distribuyen posiciones antes de impulsar el precio en una dirección concreta. Sin embargo, no todos los bloques de órdenes siguen siendo válidos: algunos quedan invalidados por una ruptura a medida que cambian las condiciones del mercado. Cuando un bloque de órdenes no logra contener el precio, no pierde necesariamente su importancia; en cambio, se transforma en un posible bloque de mitigación. Este concepto se centra en cómo el precio suele retroceder hasta estas zonas invalidadas para «mitigar» las órdenes remanentes antes de continuar en la dirección de la nueva tendencia, lo que ofrece a los operadores una visión más profunda de las intenciones de los inversores institucionales y del comportamiento de la estructura del mercado.
La idea de reutilizar los bloques de órdenes invalidados como bloques de mitigación permite a los operadores identificar en qué puntos el dinero inteligente podría volver a intervenir en el mercado tras cambiar su sesgo direccional. Al analizar cómo interactúa el precio con estas zonas, los operadores pueden anticipar entradas de alta probabilidad alineadas con el nuevo flujo direccional. Comprender esta transformación de bloque de órdenes en bloque de mitigación mejora la precisión al elegir el momento de entrada y gestionar el riesgo.
Comprender el bloque de mitigación:

Normalmente, cuando el precio sube, suele dejar tras de sí una especie de bloque de órdenes alcista cerca del mínimo relativo, o justo en él, que representa el último punto en el que los compradores intervinieron antes de impulsar el precio al alza. A medida que continúa la subida, el precio suele acercarse a un nivel que se percibe como resistencia, que podría ser un máximo anterior, un bloque de órdenes previo o una estructura de tipo breaker. En este nivel, buscamos señales claras de que hay vendedores dispuestos a actuar, como mechas de rechazo o velas bajistas que indiquen un cambio en el flujo de órdenes. Si el precio comienza a reajustarse a la baja y posteriormente vuelve a subir hasta esa misma zona de resistencia, el siguiente paso es observar si el mercado muestra disposición a romper a la baja desde ese nivel, lo que indicaría que la presión vendedora está surtiendo efecto y que podría producirse un movimiento bajista.

Cuando el mercado empieza a bajar, suele formar un patrón en forma de «M», que representa una oscilación fallida e indica el agotamiento del impulso alcista cerca de un nivel de resistencia. Normalmente, el segundo pico de la «M» no logra alcanzar un nuevo máximo, lo que indica que los compradores están perdiendo fuerza mientras que los vendedores comienzan a intervenir. Este comportamiento del precio queda confirmado posteriormente por una ruptura de la estructura del mercado, a menudo denominada «cambio de estructura del mercado», cuando el precio cae por debajo de un mínimo clave. Este cambio confirma que el dinero inteligente o las instituciones se están posicionando efectivamente para hacer bajar los precios, lo que provoca la transición del mercado de un entorno alcista a uno bajista.

En este escenario, nos centramos en el rango comprendido entre el mínimo a corto plazo y el máximo a corto plazo, identificando las zonas en las que se produjo anteriormente actividad compradora. El repunte a corto plazo del precio llama la atención sobre un punto de referencia institucional concreto, conocido como «bloque de mitigación». Es aquí donde el precio retrocede hasta entrar en un bloque de mitigación bajista o se mueve dentro de él, lo que brinda al dinero inteligente la oportunidad de volver a entrar en el mercado en consonancia con el sesgo bajista predominante. Esta zona cobra importancia porque el bloque de órdenes alcista original no logró mantenerse: no se respetó debido a una fuerte presión vendedora, lo que indica que el flujo de órdenes institucional ha pasado de la acumulación a la distribución y que es probable que el precio siga bajando tras mitigar ese bloque.
Primeros pasos
//+------------------------------------------------------------------+ //| OB_&_MitigationOB.mq5 | //| Copyright 2024, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2024, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #include <Trade/Trade.mqh> #include <Arrays\ArrayObj.mqh> CTrade trade; CArrayObj obList; #define BullOB clrLime #define BearOB clrRed #define ViolatedBullOB clrBlue #define ViolatedBearOB clrMagenta //+------------------------------------------------------------------+ //| Input parameters | //+------------------------------------------------------------------+ input double Lots = 0.11; input int takeProfit = 3000; input double stopLoss = 2000; input int Time1Hstrt = 1; input int Time1Hend = 10;
Comenzamos definiendo los fundamentos y la estructura del asesor experto (EA), diseñado para identificar y gestionar los bloques de órdenes y sus correspondientes bloques de mitigación dentro del marco de los conceptos de dinero inteligente. A continuación, se incluyen dos bibliotecas importantes: Trade/Trade.mqh, para gestionar operaciones de trading como la ejecución de órdenes, y Arrays/ArrayObj.mqh, para gestionar colecciones dinámicas de objetos, que en este caso se utilizarán para almacenar de forma eficiente los datos de los bloques de órdenes. La declaración de CTrade trade inicializa el gestor de operaciones, mientras que CArrayObj obList crea un contenedor para almacenar todos los bloques de órdenes detectados durante la ejecución.
A continuación, definimos constantes de color para mayor claridad visual en el gráfico: verde (clrLime) para los bloques de órdenes alcistas, rojo (clrRed) para los bajistas y colores diferenciados, como el azul y el magenta, para representar los bloques de órdenes que han sufrido una ruptura o se han mitigado. Estas señales visuales son fundamentales para distinguir las zonas válidas de las invalidadas. Los parámetros de entrada que se indican a continuación permiten a los operadores personalizar el comportamiento del EA: el dimensionamiento de posiciones (Lots), los niveles de toma de beneficios (takeProfit) y de limitación de pérdidas (stopLoss) y los filtros temporales (Time1Hstrt y Time1Hend) para limitar la ejecución de las operaciones a sesiones de mercado específicas. Esta configuración inicial sienta las bases visuales, lógicas y operativas sobre las que el resto del EA detectará, clasificará y reutilizará los bloques de órdenes como zonas de mitigación.
//+------------------------------------------------------------------+ //| OrderBlock Class | //+------------------------------------------------------------------+ class COrderBlock : public CObject { public: int direction; datetime time; double high; double low; bool violated; datetime violatedTime; bool traded; bool inTrade; string identifier; string tradeComment; COrderBlock() { traded = false; violated = false; inTrade = false; tradeComment = ""; } void UpdateIdentifier() { identifier = IntegerToString(time) + IntegerToString(direction) + IntegerToString(violated); } void draw(datetime tmS, datetime tmE, color clr) { UpdateIdentifier(); string objOB = "OB_REC_" + identifier; if(ObjectFind(0, objOB) == -1) { ObjectCreate(0, objOB, OBJ_RECTANGLE, 0, time, low, tmS, high); ObjectSetInteger(0, objOB, OBJPROP_FILL, true); ObjectSetInteger(0, objOB, OBJPROP_COLOR, clr); ObjectSetInteger(0, objOB, OBJPROP_BACK, true); } string objtrade = "OB_TRADE_" + identifier; if(ObjectFind(0, objtrade) == -1) { ObjectCreate(0, objtrade, OBJ_RECTANGLE, 0, tmS, high, tmE, low); ObjectSetInteger(0, objtrade, OBJPROP_FILL, true); ObjectSetInteger(0, objtrade, OBJPROP_COLOR, clr); ObjectSetInteger(0, objtrade, OBJPROP_BACK, true); } } void RemoveObjects() { UpdateIdentifier(); string objOB = "OB_REC_" + identifier; string objtrade = "OB_TRADE_" + identifier; if(ObjectFind(0, objOB) >= 0) ObjectDelete(0, objOB); if(ObjectFind(0, objtrade) >= 0) ObjectDelete(0, objtrade); } }; //+------------------------------------------------------------------+ //| Global variables | //+------------------------------------------------------------------+ COrderBlock *activeMitigationOB = NULL; int activeMitigationDirection = 0;
A continuación, definimos la clase COrderBlock, que actúa como estructura de datos principal para representar y gestionar los bloques de órdenes dentro del EA. Esta clase hereda de CObject, lo que permite almacenar y manipular instancias en arrays dinámicos de punteros a objetos (CArrayObj). Cada bloque de órdenes almacena atributos fundamentales, como su dirección (alcista o bajista), la hora, los niveles de precio máximo y mínimo, y estados como «violated», «traded» e «inTrade». Los identificadores adicionales, como «identifier» y «tradeComment», permiten hacer referencia de forma unívoca a cada bloque de órdenes del gráfico y realizar un seguimiento de la lógica de negociación asociada. El constructor inicializa los estados por defecto para garantizar que los bloques de órdenes recién detectados comiencen sin operaciones realizadas sobre ellos y sin haber sufrido rupturas, estableciendo así un estado inicial limpio antes de cualquier interacción con el gráfico o con las operaciones.
La clase también incluye varios métodos potentes que se encargan tanto de la visualización como de la gestión del ciclo de vida. El método UpdateIdentifier() genera una cadena única basada en la marca temporal, la dirección y el estado de invalidación, lo cual es esencial para diferenciar entre varios bloques de órdenes. La función draw() se encarga de trazar las zonas de los bloques de órdenes y sus regiones de negociación asociadas en forma de rectángulos de colores en el gráfico, asegurándose de que cada bloque sea visualmente diferenciable y no se solape con los demás. Por su parte, la función RemoveObjects() elimina estos objetos gráficos cuando ya no son válidos, lo que permite mantener la claridad y el rendimiento del gráfico. Por último, se declaran dos variables globales —activeMitigationOB y activeMitigationDirection— para realizar un seguimiento del bloque de mitigación actualmente activo y su sesgo direccional, lo que establece un vínculo entre la detección de bloques de órdenes, su ruptura y la lógica de negociación que se aplica más adelante en el EA.
//+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { trade.SetExpertMagicNumber(76543); return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { for(int i = obList.Total()-1; i >= 0; i--) { COrderBlock* ob = obList.At(i); ob.RemoveObjects(); delete ob; } obList.Clear(); }
En esta sección se definen los procesos de inicialización y desinicialización del asesor experto para garantizar una gestión adecuada de los recursos de negociación y gráficos. La función OnInit() asigna un número mágico único para distinguir las operaciones realizadas por el sistema, lo que permite un seguimiento y una gestión precisos de las posiciones abiertas. Por su parte, la función OnDeinit() garantiza una finalización correcta al eliminar todos los objetos gráficos de los bloques de órdenes del gráfico y liberar la memoria asignada a cada instancia de bloque de órdenes. Esta estructura evita las fugas de memoria y la acumulación de objetos gráficos, lo que permite mantener un entorno de negociación estable y eficiente durante los reinicios o apagados del asesor experto.
//+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { if(isNewBar()) { CheckForClosedTradesAndCleanup(); CheckForViolations(); getOrderB(); CheckForTradeEntries(); } } //+------------------------------------------------------------------+ //| Helpers to find bars and swings safely | //+------------------------------------------------------------------+ int BarIndexFromTimeSafely(datetime t) { int idx = iBarShift(_Symbol, _Period, t, true); if(idx < 0) idx = Bars(_Symbol, _Period) - 1; return(idx); } int FindHighestAfter(datetime t, int lookbackBars) { int obIdx = BarIndexFromTimeSafely(t); int start = MathMax(1, obIdx - lookbackBars); int count = obIdx - start; if(count <= 0) return(-1); int idx = iHighest(_Symbol, _Period, MODE_HIGH, count, start); return(idx); } int FindLowestAfter(datetime t, int lookbackBars) { int obIdx = BarIndexFromTimeSafely(t); int start = obIdx + 1; int maxPossible = Bars(_Symbol, _Period) - start; int count = MathMin(lookbackBars, maxPossible); if(count <= 0) return(-1); int idx = iLowest(_Symbol, _Period, MODE_LOW, count, start); return(idx); }
La función OnTick() constituye el bucle de ejecución principal del asesor experto y se encarga de la toma de decisiones en tiempo real en cada tick del mercado. Ejecuta su lógica al comenzar una nueva barra mediante la condición isNewBar(), con el fin de evitar operaciones redundantes dentro de la misma vela. En cada nueva barra, realiza tareas esenciales como limpiar las operaciones cerradas, comprobar si se han producido rupturas de bloques de órdenes, identificar nuevos bloques de órdenes potenciales y buscar oportunidades válidas para entrar en el mercado. Este enfoque estructurado garantiza un uso eficiente de los recursos y mantiene la coherencia lógica de la estrategia sin sobrecargar el sistema.
Como apoyo a estas operaciones principales, las funciones auxiliares —BarIndexFromTimeSafely(), FindHighestAfter() y FindLowestAfter()— están diseñadas para gestionar de forma fiable la recuperación de datos y el análisis de oscilaciones. La función BarIndexFromTimeSafely() garantiza que el programa pueda determinar de forma segura el índice de barra correcto a partir de un momento dado, incluso en condiciones de mercado irregulares o en caso de que falten datos. Las funciones FindHighestAfter() y FindLowestAfter() identifican los máximos y mínimos relativos clave dentro de un periodo retrospectivo definido, lo cual resulta fundamental para detectar la estructura del mercado y validar el comportamiento de los bloques de órdenes. En conjunto, estas funciones constituyen la base para un análisis preciso y adaptativo de los bloques de órdenes.
//+------------------------------------------------------------------+ //| Check for violations of existing orderblocks | //+------------------------------------------------------------------+ void CheckForViolations() { double currentBid = SymbolInfoDouble(_Symbol, SYMBOL_BID); double currentAsk = SymbolInfoDouble(_Symbol, SYMBOL_ASK); for(int i = 0; i < obList.Total(); i++) { COrderBlock* ob = obList.At(i); if(ob.violated || ob.traded) continue; if(ob.direction == 1 && currentBid < ob.low) { if(activeMitigationOB != NULL) { activeMitigationOB = NULL; activeMitigationDirection = 0; } ob.violated = true; ob.violatedTime = iTime(_Symbol, PERIOD_CURRENT, 0); ob.traded = false; ob.UpdateIdentifier(); activeMitigationOB = ob; activeMitigationDirection = -1; Print("Bullish OB violated and becomes BEARISH mitigation: ", TimeToString(ob.time)); } else if(ob.direction == -1 && currentAsk > ob.high) { if(activeMitigationOB != NULL) { activeMitigationOB = NULL; activeMitigationDirection = 0; } ob.violated = true; ob.violatedTime = iTime(_Symbol, PERIOD_CURRENT, 0); ob.traded = false; ob.UpdateIdentifier(); activeMitigationOB = ob; activeMitigationDirection = 1; Print("Bearish OB violated and becomes BULLISH mitigation: ", TimeToString(ob.time)); } } }
La función CheckForViolations() se encarga de supervisar continuamente todos los bloques de órdenes existentes para determinar si alguno de ellos ha sufrido una ruptura debido a la acción actual del precio de mercado. Recupera los precios bid y ask actuales y, a continuación, recorre todos los bloques de órdenes almacenados, omitiendo aquellos que ya están marcados como utilizados para operar o invalidados.
En el caso de los bloques de órdenes alcistas, se produce una ruptura cuando el precio bid cae por debajo del mínimo del bloque, mientras que, en el caso de los bloques de órdenes bajistas, se produce una ruptura cuando el precio ask sube por encima del máximo del bloque. Una vez detectada una ruptura, el sistema actualiza el estado del bloque de órdenes, registra la hora de la ruptura y restablece las referencias a los bloques de mitigación activos antes de reasignar el bloque de órdenes invalidado como nuevo bloque de mitigación activo con un sesgo direccional opuesto.
Esta transición dinámica de un estado del mercado a otro permite al EA adaptarse a los cambios en el comportamiento de los precios y tratar las zonas que antes eran fuertes como nuevas áreas de mitigación, lo que perfecciona de forma eficaz la capacidad de respuesta de la estrategia ante los cambios en el flujo de órdenes.
//+------------------------------------------------------------------+ //| Check for trade entries in orderblocks | //+------------------------------------------------------------------+ void CheckForTradeEntries() { double currentBid = SymbolInfoDouble(_Symbol, SYMBOL_BID); double currentAsk = SymbolInfoDouble(_Symbol, SYMBOL_ASK); for(int i = 0; i < obList.Total(); i++) { COrderBlock* ob = obList.At(i); if(ob.traded) continue; bool priceInZone = false; bool isBullishTrade = false; bool isMitigation = ob.violated; if(!ob.violated) { if(ob.direction == 1 && currentAsk < ob.high && currentAsk > ob.low) { priceInZone = true; isBullishTrade = true; } else if(ob.direction == -1 && currentBid > ob.low && currentBid < ob.high) { priceInZone = true; isBullishTrade = false; } } else { if(ob.direction == 1 && currentBid > ob.low && currentBid < ob.high) { priceInZone = true; isBullishTrade = false; } else if(ob.direction == -1 && currentAsk < ob.high && currentAsk > ob.low) { priceInZone = true; isBullishTrade = true; } } if(priceInZone) { if(isMitigation) { if(activeMitigationOB == NULL || activeMitigationOB != ob) { continue; } } if(isBullishTrade) { ExecuteBuyTrade(ob); } else { ExecuteSellTrade(ob); } ob.traded = true; break; } } }
La función CheckForTradeEntries() gestiona la lógica principal que determina cuándo y dónde debe ejecutar operaciones el asesor experto en función de la interacción del precio con los bloques de órdenes activos o los bloques de mitigación. Comienza obteniendo el precio bid y el precio ask actuales y recorriendo cada bloque de órdenes almacenado, omitiendo aquellos que ya se han utilizado para operar. A continuación, la lógica comprueba si el precio actual se encuentra dentro de la zona de un bloque de órdenes válido e identifica la dirección de la operación en función de la naturaleza del bloque: alcista o bajista. En el caso de los bloques de órdenes que no han sufrido una ruptura, las operaciones alcistas se activan cuando el precio ask desciende hasta entrar en la zona alcista, mientras que las operaciones bajistas se producen cuando el precio bid sube hasta entrar en la zona bajista.
Cuando se trata de bloques de órdenes invalidados (que ahora actúan como bloques de mitigación), la lógica de negociación se invierte para reflejar la reacción opuesta en la estructura del mercado. El sistema garantiza que solo el bloque de mitigación actualmente activo pueda activar operaciones, evitando reentradas innecesarias o conflictos. Una vez que se cumplen las condiciones, ejecuta una operación de compra o venta utilizando los parámetros correspondientes del bloque de órdenes y marca el bloque como «utilizado para operar» para evitar posiciones duplicadas. Esta lógica de dos niveles —que gestiona tanto los bloques de órdenes válidos como los bloques de mitigación— proporciona una estructura dinámica y adaptable para la negociación basada en el dinero inteligente, lo que permite al algoritmo responder de forma inteligente a medida que evolucionan las condiciones del mercado.
//+------------------------------------------------------------------+ //| Execute a buy trade | //+------------------------------------------------------------------+ void ExecuteBuyTrade(COrderBlock* ob) { double entry = SymbolInfoDouble(_Symbol, SYMBOL_ASK); int swingHighIdx = FindHighestAfter(ob.time, 20); double tp = (swingHighIdx>0) ? getHigh(swingHighIdx) : entry + takeProfit * _Point; double sl = NormalizeDouble(ob.low - stopLoss * _Point, _Digits); string comment = "Bull_OB_" + ob.identifier; ob.tradeComment = comment; if(trade.Buy(Lots, _Symbol, entry, sl, tp, comment)) { color obColor = ob.violated ? ViolatedBullOB : BullOB; ob.draw(ob.time, iTime(_Symbol, PERIOD_CURRENT, 0), obColor); ob.inTrade = true; Print("Buy trade executed. Type: ", ob.violated ? "Mitigation" : "Regular", " OB Time: ", TimeToString(ob.time), " Entry: ", entry, " SL: ", sl, " TP: ", tp); } } //+------------------------------------------------------------------+ //| Execute a sell trade | //+------------------------------------------------------------------+ void ExecuteSellTrade(COrderBlock* ob) { double entry = SymbolInfoDouble(_Symbol, SYMBOL_BID); int swingLowIdx = FindLowestAfter(ob.time, 20); double tp = (swingLowIdx>0) ? getLow(swingLowIdx) : entry - takeProfit * _Point; double sl = NormalizeDouble(ob.high + stopLoss * _Point, _Digits); string comment = "Bear_OB_" + ob.identifier; ob.tradeComment = comment; if(trade.Sell(Lots, _Symbol, entry, sl, tp, comment)) { color obColor = ob.violated ? ViolatedBearOB : BearOB; ob.draw(ob.time, iTime(_Symbol, PERIOD_CURRENT, 0), obColor); ob.inTrade = true; Print("Sell trade executed. Type: ", ob.violated ? "Mitigation" : "Regular", " OB Time: ", TimeToString(ob.time), " Entry: ", entry, " SL: ", sl, " TP: ", tp); } }
Las funciones ExecuteBuyTrade() y ExecuteSellTrade() se encargan de la ejecución precisa de las operaciones una vez que un bloque de órdenes o un bloque de mitigación cumple las condiciones de entrada. En un escenario de compra, el sistema utiliza el precio ask actual como nivel de entrada y calcula el objetivo de take profit basándose en el siguiente máximo relativo detectado. Si no se encuentra ningún máximo relativo válido, se utiliza por defecto una distancia fija en pips definida por el parámetro de entrada takeProfit. El stop loss se sitúa justo por debajo del mínimo del bloque de órdenes, lo que garantiza una configuración con el riesgo controlado. A continuación, la función asigna a la operación un comentario descriptivo para facilitar su seguimiento y actualiza visualmente el gráfico con el color correspondiente: verde para un bloque alcista válido o azul para un bloque de mitigación. Esta estructura permite diferenciar claramente entre las operaciones habituales y las basadas en bloques de mitigación, tanto en la lógica como en la visualización del gráfico.
La lógica de la operación de venta sigue un proceso simétrico: utiliza el precio bid actual como nivel de entrada y determina el take profit a partir del mínimo relativo más cercano o de un valor fijo alternativo. El stop loss se sitúa justo por encima del máximo del bloque de órdenes, manteniendo la simetría de la relación riesgo-beneficio con respecto a las configuraciones de compra. Se genera un comentario claro para identificar la operación y se aplica en el gráfico el color correspondiente al bloque bajista válido o al bloque bajista convertido en bloque de mitigación (rojo o magenta, respectivamente) para resaltar las zonas de negociación activas. Ambas funciones concluyen estableciendo el indicador «inTrade» en «true», lo que garantiza que cada bloque de órdenes active únicamente una posición. Este diseño modular separa de forma eficaz la lógica de ejecución de las operaciones de compra y venta, lo que permite una operativa estructurada, con seguimiento visual y basada en reglas, en consonancia con los conceptos de dinero inteligente.
//+------------------------------------------------------------------+ //| Detect new orderblocks | //+------------------------------------------------------------------+ void getOrderB() { MqlDateTime structTime; TimeCurrent(structTime); static int prevDay = 0; if(structTime.hour >= Time1Hstrt && structTime.hour < Time1Hend) { if(prevDay != structTime.day) { prevDay = structTime.day; for(int i = 3; i < 100; i++) { if(i + 3 >= Bars(_Symbol, _Period)) continue; if(getOpen(i+2) > getClose(i+2) && getClose(i+1) > getOpen(i+1) && getClose(i) > getOpen(i)) { COrderBlock* ob = new COrderBlock(); ob.direction = 1; ob.time = getTime(i+2); ob.high = getHigh(i+2); ob.low = getLow(i+2); ob.violated = false; ob.traded = false; ob.UpdateIdentifier(); obList.Add(ob); Print("Bullish Order Block detected at: ", TimeToString(ob.time)); } else if(getOpen(i+2) < getClose(i+2) && getClose(i+1) < getOpen(i+1) && getClose(i) < getOpen(i)) { COrderBlock* ob = new COrderBlock(); ob.direction = -1; ob.time = getTime(i+2); ob.high = getHigh(i+2); ob.low = getLow(i+2); ob.violated = false; ob.traded = false; ob.UpdateIdentifier(); obList.Add(ob); Print("Bearish Order Block detected at: ", TimeToString(ob.time)); } } } } } //+------------------------------------------------------------------+ //| Check for closed trades and cleanup objects after closure | //+------------------------------------------------------------------+ void CheckForClosedTradesAndCleanup() { for(int i = obList.Total()-1; i >= 0; i--) { COrderBlock* ob = obList.At(i); if(ob.inTrade) { if(!PositionWithCommentExists(ob.tradeComment)) { Print("Trade closed for OB: ", ob.identifier, " -> cleaning up drawings"); ob.RemoveObjects(); ob.inTrade = false; ob.traded = false; ob.tradeComment = ""; if(activeMitigationOB == ob) { activeMitigationOB = NULL; activeMitigationDirection = 0; Print("Active mitigation OB cleared after trade closure"); } obList.Delete(i); delete ob; } } } }
La función getOrderB() se encarga de detectar nuevos bloques de órdenes basándose en una lógica sencilla de patrones de tres velas. Solo realiza el análisis dentro de un intervalo de tiempo específico definido por los parámetros de entrada Time1Hstrt y Time1Hend, lo que garantiza que la detección se produzca dentro del horario de negociación establecido por el usuario. La función comprueba en primer lugar si se dan las condiciones de un bloque de órdenes alcista —en el que una vela bajista va seguida de dos velas alcistas consecutivas—, lo que indica una posible acumulación y un cambio en el sentimiento del mercado. Cuando se identifica este patrón, se crea un nuevo objeto COrderBlock, se inicializan sus atributos (como la dirección, la hora, el máximo y el mínimo) y se añade a la lista global.
Del mismo modo, se detecta un bloque de órdenes bajista cuando a una vela alcista le siguen dos velas bajistas consecutivas, lo que indica una posible distribución y futuras caídas del precio. Esta detección modular y sujeta a restricciones horarias garantiza que solo se registren los bloques significativos de cada día, lo que reduce el exceso de información y permite centrarse en las zonas que ofrecen oportunidades operativas.
La función CheckForClosedTradesAndCleanup() complementa el proceso de detección al garantizar la limpieza de los gráficos y la integridad del sistema. Una vez cerrada una operación asociada a un bloque de órdenes, la función verifica su estado comprobando si existe una posición con el comentario de la operación correspondiente al bloque. Si la operación ya no existe, todos los elementos visuales relacionados (rectángulos y marcas de resaltado) se eliminan del gráfico para evitar confusiones con las configuraciones activas. Además, restablece el estado interno del bloque de órdenes, borra la referencia de mitigación, si procede, y elimina el objeto del bloque de órdenes de la lista global para liberar memoria. Este ciclo de limpieza mantiene el sistema dinámico y eficiente, garantizando que solo se sigan supervisando los bloques de órdenes relevantes y activos, mientras que los obsoletos se eliminan de forma segura tanto de la memoria como del entorno gráfico.
//+------------------------------------------------------------------+ //| Check if position with specific comment exists | //+------------------------------------------------------------------+ bool PositionWithCommentExists(string comment) { if(StringLen(comment) == 0) return(false); for(int i = PositionsTotal()-1; i >= 0; i--) { ulong ticket = PositionGetTicket(i); if(ticket > 0 && PositionSelectByTicket(ticket)) { string c = PositionGetString(POSITION_COMMENT); if(c == comment) return(true); } } return(false); } //+------------------------------------------------------------------+ //| Helper functions | //+------------------------------------------------------------------+ bool isNewBar() { static datetime lastBar; datetime currentBar = iTime(_Symbol, _Period, 0); if(lastBar != currentBar) { lastBar = currentBar; return true; } return false; } double getHigh(int index) { return iHigh(_Symbol, _Period, index); } double getLow(int index) { return iLow(_Symbol, _Period, index); } double getOpen(int index) { return iOpen(_Symbol, _Period, index); } double getClose(int index) { return iClose(_Symbol, _Period, index); } datetime getTime(int index) { return iTime(_Symbol, _Period, index); }
La función PositionWithCommentExists() desempeña un papel fundamental a la hora de mantener la integridad del estado de las operaciones, ya que comprueba si sigue existiendo una posición con un comentario identificativo específico. Dado que cada operación correspondiente a un bloque de órdenes lleva un comentario identificativo único, esta función recorre todas las posiciones abiertas, recupera sus comentarios y los compara con el que se ha proporcionado como entrada. Si se encuentra una coincidencia, devuelve «true», lo que indica que la operación sigue activa; en caso contrario, devuelve «false». Este proceso de verificación es esencial para funciones como la limpieza de operaciones y la lógica de mitigación, ya que garantiza que acciones como la eliminación de objetos o el restablecimiento de estados solo se produzcan una vez que la operación asociada se haya cerrado definitivamente. Al utilizar este método, el EA evita el doble procesamiento y mantiene un reflejo preciso de las operaciones en curso frente a las ya completadas.
Las funciones auxiliares que se indican a continuación sirven como herramientas de apoyo para la recuperación de datos y la gestión de barras. La función isNewBar() identifica cuándo se ha formado una nueva barra, lo que permite que operaciones clave, como la detección de bloques de órdenes o las comprobaciones de ruptura, se ejecuten solo una vez por barra, evitando así un procesamiento redundante en cada tick. Por su parte, las demás funciones auxiliares —getHigh(), getLow(), getOpen(), getClose() y getTime()— son funciones auxiliares que simplifican el acceso a los datos de las velas del gráfico. Esto mejora la legibilidad del código y garantiza la coherencia en el tratamiento de los datos en todo el asesor experto. En conjunto, estas herramientas, pequeñas pero esenciales, constituyen la base que permite que rutinas más complejas, como la identificación de bloques de órdenes y la ejecución de operaciones, funcionen de forma fluida y eficiente.
Resultados de la prueba retrospectiva
La prueba retrospectiva se realizó en el marco temporal de 1H durante un periodo de prueba de aproximadamente dos meses (del 2 de junio de 2025 al 29 de julio de 2025), con los ajustes predeterminados. 

Conclusión
En resumen, este asesor experto (EA) integra conceptos de dinero inteligente (SMC), como los bloques de órdenes y los bloques de mitigación, en un sistema de negociación estructurado y basado en reglas. Comienza identificando bloques de órdenes alcistas y bajistas válidos a partir de la estructura de precios y las formaciones de velas; a continuación, supervisa si se producen rupturas para transformar los bloques de órdenes invalidados en zonas de mitigación. A través de sus mecanismos de detección, validación y ejecución, el EA gestiona las operaciones de forma dinámica, abriendo posiciones de compra o venta cuando el precio vuelve a situarse en niveles clave. Además, se encarga de todas las representaciones visuales de los bloques de órdenes, dibujando y eliminando rectángulos a medida que se abren y se cierran las operaciones, lo que garantiza que el gráfico refleje siempre las zonas institucionales más relevantes.
En conclusión, este sistema constituye un enfoque metódico para interpretar la estructura del mercado y el comportamiento institucional de los precios en MQL5. Al automatizar el reconocimiento de los bloques de órdenes, su transformación en zonas de mitigación y la posterior gestión de las operaciones, el EA capta la esencia de cómo el dinero inteligente reutiliza las zonas invalidadas para obtener liquidez y generar configuraciones operativas de continuación de tendencia. La inclusión de rutinas de limpieza, funciones auxiliares y condiciones de validación estrictas mejora su fiabilidad y realismo. En general, este proyecto aúna la ejecución técnica con la negociación basada en los conceptos de estructura del mercado, proporcionando un marco completo y autónomo que refleja la forma en que los operadores profesionales interpretan la dinámica del flujo de órdenes y actúan en consecuencia.
Traducción del inglés realizada por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/en/articles/19619
Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.
Este artículo ha sido escrito por un usuario del sitio web y refleja su punto de vista personal. MetaQuotes Ltd. no se responsabiliza de la exactitud de la información ofrecida, ni de las posibles consecuencias del uso de las soluciones, estrategias o recomendaciones descritas.