Tectonic Structure Engine

Biblioteca MQL4 que traza la estructura del mercado para su EA, indicador o script: swings confirmados con etiquetas HH, HL, LH, LL, EQH y EQL, ruptura de estructura (BOS), cambio de carácter (CHoCH), barridos de liquidez, order blocks y fair value gaps con seguimiento del llenado, y la posición del precio en el rango operativo. Solo lee barras cerradas y nunca repinta. No opera, no dibuja y no envía alertas. Usted recibe el archivo compilado Tectonic_Structure_Engine.ex4; esta página es la referencia completa de la API.

Inicio rápido

1. Copie Tectonic_Structure_Engine.ex4 a MQL4/Libraries (Archivo > Abrir carpeta de datos).
2. Pegue el bloque #import de abajo en su programa.
3. En OnInit: h = TSE_Create("", 0, 3, 1000); opcionalmente TSE_Configure.
4. Llame a TSE_Update(h) en OnTick u OnCalculate. Sin barra nueva devuelve 0 en aproximadamente un microsegundo.
5. Lea TSE_Trend, TSE_GetEvent, TSE_NearestZone y las demás; TSE_Release(h) en OnDeinit.
6. Compruebe: ejecute el ejemplo de abajo en el Probador de estrategias (cualquier símbolo, M15). El diario lista cada evento; la primera actualización lista todo el historial.

Declaración de importación (lista para copiar)

#import "Tectonic_Structure_Engine.ex4"
   int    TSE_Create(string symbol, int timeframe, int strength, int history_bars);
   bool   TSE_Configure(int handle, int break_mode, double min_swing_atr, double equal_tol_atr, double fvg_min_atr, int atr_period);
   void   TSE_Release(int handle);
   int    TSE_Update(int handle);
   int    TSE_Trend(int handle);
   int    TSE_SwingCount(int handle);
   bool   TSE_GetSwing(int handle, int index, int &side, double &price, datetime &time, int &label);
   int    TSE_EventCount(int handle);
   bool   TSE_GetEvent(int handle, int index, int &type, double &level, datetime &swing_time, datetime &break_time);
   bool   TSE_GetLevels(int handle, double &swing_high, double &swing_low, bool &high_broken, bool &low_broken);
   double TSE_RangePosition(int handle, double price);
   int    TSE_ZoneCount(int handle);
   bool   TSE_GetZone(int handle, int index, int &kind, int &dir, double &top, double &bottom, datetime &time, int &state, double &fill);
   int    TSE_NearestZone(int handle, int kind, int dir, double price, double &top, double &bottom);
   int    TSE_GetStats(int handle, int &stats[]);
   int    TSE_LastError();
   string TSE_ErrorText(int code);
   string TSE_LabelText(int label);
   string TSE_EventText(int type);
   string TSE_ZoneText(int kind, int dir);
   string TSE_StateText(int state);
#import 

Códigos

• Etiquetas de swing: 1 HH, 2 LH, 3 EQH (máximos); -1 LL, -2 HL, -3 EQL (mínimos); 0 FIRST (sin swing anterior de ese lado).
• Tipos de evento: 1 BOS UP, -1 BOS DOWN, 2 CHOCH UP, -2 CHOCH DOWN, 3 SWEEP HIGH, -3 SWEEP LOW.
• Tipo de zona (kind): 1 fair value gap, 2 order block. dir: 1 alcista (soporte), -1 bajista (resistencia). Textos: BULL FVG, BEAR FVG, BULL OB, BEAR OB.
• Estado de zona: 0 FRESH (intacta), 1 TESTED (el precio entró), 2 FILLED (FVG atravesado), 3 BROKEN (OB cerrado al otro lado).
• Errores: 0 OK, -1 BAD HANDLE, -2 BAD PARAMETERS, -3 NO HISTORY, -4 NO FREE SLOT, -5 BAD INDEX. Las funciones de texto devuelven UNKNOWN para otros códigos.

Cómo se lee cada barra cerrada

1. Zonas: un mínimo dentro de una zona alcista (un máximo dentro de una bajista) marca TESTED y eleva fill, la penetración más profunda en % de la altura de la zona. Un FVG pasa a FILLED cuando el precio alcanza su borde lejano; un OB pasa a BROKEN con un cierre más allá de su borde lejano (fill puede llegar al 100% mientras el OB sigue activo).
2. Swings: la barra situada strength barras atrás es un swing alto si su máximo supera las strength barras anteriores y no es inferior a las strength barras posteriores (mínimos a la inversa). Un swing se informa strength barras tarde y nunca se mueve. Con min_swing_atr mayor que 0, el máximo menos el mínimo más bajo de las 2 x strength + 1 barras debe ser al menos min_swing_atr x ATR. Etiqueta frente al swing anterior del mismo lado: dentro de equal_tol_atr x ATR es EQH o EQL; si no, HH o LH, LL o HL. El swing alto y el swing bajo más recientes son los niveles de ruptura.
3. Rupturas: break_mode 0 exige un cierre más allá del nivel, 1 una mecha. Romper el swing alto da CHOCH UP si la tendencia era -1 y BOS UP en otro caso; la tendencia pasa a 1 y el nivel queda usado. Mínimos a la inversa. En modo cierre, una mecha más allá con cierre de vuelta dentro es un SWEEP, una vez por nivel.
4. Order block: en cada BOS o CHoCH, la última vela opuesta (bajista para una ruptura al alza) en el extremo del tramo entre swing y ruptura o hasta 10 barras antes; la zona es su rango máximo-mínimo.
5. Fair value gap: mínimo de la tercera vela por encima del máximo de la primera (alcista), o máximo de la tercera por debajo del mínimo de la primera (bajista), con una altura de al menos fvg_min_atr x ATR.

El ATR es la media simple del rango verdadero sobre atr_period barras.

Referencia de la API

TSE_Create

symbol: "" o NULL = símbolo del gráfico; debe existir. timeframe: 0 = periodo del gráfico, si no de PERIOD_M1 a PERIOD_MN1. strength: 1-50. history_bars: 100-20000, se construyen en la primera actualización. Devuelve un handle 0-31, o -1 con BAD PARAMETERS o NO FREE SLOT. Valores por defecto: break_mode 0, min_swing_atr 0, equal_tol_atr 0.10, fvg_min_atr 0.25, atr_period 14.

TSE_Configure

break_mode 0-1, min_swing_atr 0-10 (0 = desactivado), equal_tol_atr 0-5, fvg_min_atr 0-10, atr_period 1-500. Vacía el handle; el siguiente TSE_Update lo reconstruye. Cualquier valor fuera de rango: false, BAD PARAMETERS, nada cambia.

TSE_Release

Libera el handle para reutilizarlo. Llámela en OnDeinit.

TSE_Update

Lee las barras cerradas aún no vistas; la primera llamada construye history_bars. Devuelve el número de eventos nuevos (índices 0 a n-1 de TSE_GetEvent), 0 sin barra nueva, o -1: BAD HANDLE, o NO HISTORY mientras haya menos de 2 x strength + 4 barras cargadas (vuelva a llamar en el siguiente tick). Si desaparece la última barra leída (historial recargado), el handle se reconstruye solo.

int n = TSE_Update(h);
if(n > 0) Print(n, " new events"); 

TSE_Trend

1 tras una ruptura al alza, -1 tras una ruptura a la baja, 0 antes de la primera ruptura o con un handle inválido.

TSE_SwingCount y TSE_GetSwing

Swings guardados, el más reciente en el índice 0: side (1 máximo, -1 mínimo), price, hora de la barra del swing, label. El recuento es -1 con un handle inválido; fuera de 0 a recuento-1, TSE_GetSwing devuelve false con BAD INDEX.

TSE_EventCount y TSE_GetEvent

Eventos guardados, el más reciente en el índice 0: type, level (el precio del swing), swing_time, break_time (la barra que lo rompió o barrió).

TSE_GetLevels

El swing alto y el swing bajo más recientes (0.0 si aún no hay) y si cada uno ya está roto. Un nivel intacto es el próximo disparador de BOS o CHoCH.

TSE_RangePosition

Dónde está el precio entre esos dos niveles: 0 = swing bajo, 50 = equilibrio, 100 = swing alto, por debajo de 0 o por encima de 100 fuera del rango. price 0 = Bid del símbolo del handle. EMPTY_VALUE si falta un nivel o el alto no está por encima del bajo. La demo muestra DISCOUNT por debajo de 45 y PREMIUM por encima de 55.

TSE_ZoneCount y TSE_GetZone

Zonas guardadas de todos los estados, la más reciente en el índice 0: kind, dir, top, bottom, time (FVG: vela central; OB: la propia vela), state, fill 0-100.

TSE_NearestZone

Zona FRESH o TESTED más cercana al precio (0 = Bid); distancia 0 dentro de una zona, los empates van a la zona más reciente. kind: 0 cualquiera, 1 FVG, 2 OB. dir: 0 cualquiera, 1, -1. Devuelve su índice para TSE_GetZone y rellena top y bottom; -1 si no hay ninguna (error OK) o BAD PARAMETERS.

double top, bottom;
int z = TSE_NearestZone(h, 2, 1, 0, top, bottom);   // nearest bullish order block 

TSE_GetStats

Pase un array int dinámico; se redimensiona a 12 y se devuelve 12: 0 barras leídas, 1 swings altos, 2 swings bajos, 3 BOS UP, 4 BOS DOWN, 5 CHOCH UP, 6 CHOCH DOWN, 7 SWEEP HIGH, 8 SWEEP LOW, 9 FVG, 10 OB, 11 zonas activas ahora. Recuentos desde la última construcción.

TSE_LastError y las funciones de texto

TSE_LastError: código de la última llamada. TSE_ErrorText, TSE_LabelText, TSE_EventText, TSE_ZoneText(kind, dir) y TSE_StateText devuelven las cadenas listadas en Códigos.

Ejemplo de integración funcional

#import "Tectonic_Structure_Engine.ex4"
   int    TSE_Create(string symbol, int timeframe, int strength, int history_bars);
   void   TSE_Release(int handle);
   int    TSE_Update(int handle);
   int    TSE_Trend(int handle);
   bool   TSE_GetEvent(int handle, int index, int &type, double &level, datetime &swing_time, datetime &break_time);
   int    TSE_NearestZone(int handle, int kind, int dir, double price, double &top, double &bottom);
   string TSE_EventText(int type);
#import

int h = -1, htf = -1;

int OnInit()
{
   h   = TSE_Create("", 0, 3, 1000);           // chart timeframe
   htf = TSE_Create("", PERIOD_H4, 3, 1000);   // higher-timeframe bias
   return (h >= 0 && htf >= 0) ? INIT_SUCCEEDED : INIT_FAILED;
}

void OnDeinit(const int reason) { TSE_Release(h); TSE_Release(htf); }

void OnTick()
{
   TSE_Update(htf);
   int n = TSE_Update(h);
   for(int i = n - 1; i >= 0; i--)
   {
      int type; double level; datetime st, bt;
      if(TSE_GetEvent(h, i, type, level, st, bt))
         Print(TSE_EventText(type), " at ", level, ", H4 trend ", TSE_Trend(htf));
   }
   double top, bottom;
   if(n > 0 && TSE_NearestZone(h, 2, 1, 0, top, bottom) >= 0)
      Print("nearest bullish OB ", bottom, " - ", top);
} 

Configuraciones típicas

• Estructura interna y externa: dos handles en un gráfico, strength 2 y 8.
• Sesgo multitemporal: handle del gráfico para entradas, handle H4 o D1 como filtro TSE_Trend.
• Rupturas por mecha: TSE_Configure(h, 1, 0, 0.10, 0.25, 14); en este modo no hay barridos.
• Menos zonas y swings, más grandes: fvg_min_atr 0.5-1.0, min_swing_atr 1.0.

Arquitectura y notas

• Un motor por handle, hasta 32 handles por programa; cada programa que importa tiene los suyos. Los datos viven en memoria y se reconstruyen desde el historial tras un reinicio.
• Solo barras cerradas, cada una leída una vez, de la más antigua a la más nueva: nada repinta y la barra 0 nunca se usa.
• Construir 20 000 barras tomó unos 80 ms en el Probador de estrategias de MT4.
• Otros símbolos o marcos temporales se leen con iHigh, iLow, iOpen, iClose e iTime; NO HISTORY es normal mientras el terminal los descarga. En el Probador de estrategias use el símbolo probado (cualquier marco temporal).
• Por handle: hasta 2000 swings, 2000 eventos y 500 zonas; al llenarse se descarta el 10% más antiguo.
• MetaTrader 4 build 600 o posterior. Seguro en el Probador de estrategias y en la optimización. Sin DLL, archivos, variables globales, objetos gráficos, temporizadores, alertas ni operaciones.

Aviso de riesgo

La biblioteca describe la estructura del precio. No predice precios ni garantiza beneficios. Pruebe cualquier estrategia basada en ella primero en una cuenta demo.