| //+------------------------------------------------------------------+
|
| //| FVG_Detector_EA.mq5 |
|
| //| Fair Value Gap Detection Tool |
|
| //| Professional Smart Money Concepts Expert |
|
| //+------------------------------------------------------------------+
|
| #property copyright "FVG Detector - SMC Analysis Tool"
|
| #property link "https://www.smartmoneyconcepts.com"
|
| #property version "2.01"
|
| #property description "Expert Advisor para detección y visualización de Fair Value Gaps (FVG)"
|
| #property description "⚠️ SOLO ANÁLISIS VISUAL - NO EJECUTA OPERACIONES"
|
| #property strict
|
|
|
| //+------------------------------------------------------------------+
|
| //| |
|
| //+------------------------------------------------------------------+
|
| #include "..\\Utils\\MetricSaver.mqh"
|
|
|
| /* Codigo hecho por ia Claude Opus 4.5
|
| Promt:
|
| Desarrolla un BOT (Expert Advisor) para MetaTrader 5 (MT5) que EXCLUSIVAMENTE detecte y dibuje Fair Value Gaps (FVG) en el gráfico.
|
| ⚠️ Este BOT NO debe ejecutar operaciones, NO debe abrir/cerrar trades y NO debe funcionar como indicador. Su única función es análisis visual mediante dibujo en el gráfico
|
| . Requisitos técnicos obligatorios: Implementado como Expert Advisor (EA) en MQL5. Detección y dibujo de FVG alcistas y bajistas.
|
| Funcionamiento rápido, eficiente y altamente optimizado. Capaz de trabajar con datos históricos y en tiempo real.
|
| Configuración personalizable desde el panel del BOT: Colores de los FVG. Opacidad / transparencia.
|
| Grosor y estilo de los rectángulos. Activar o desactivar FVG alcistas o bajistas. Timeframe de análisis. Aspectos visuales:
|
| Los FVG deben dibujarse como zonas (rectángulos) claras y limpias. Evitar redibujados innecesarios. El BOT debe actualizar los FVG solo cuando sea necesario.
|
| Buenas prácticas de desarrollo: Código limpio, modular y bien comentado. Uso eficiente de OnInit, OnTick y manejo de objetos gráficos.
|
| Optimización de loops y cálculos para mínimo consumo de CPU.
|
| Usa todo tu conocimiento avanzado en MQL5, optimización y Smart Money Concepts para crear un BOT profesional, estable y rápido,
|
| enfocado únicamente en dibujar Fair Value Gaps.
|
| */
|
|
|
| //+------------------------------------------------------------------+
|
| //| ENUMERACIONES PERSONALIZADAS |
|
| //+------------------------------------------------------------------+
|
|
|
| // Estilos de borde para los rectángulos FVG
|
| enum ENUM_FVG_BORDER_STYLE
|
| {
|
| FVG_BORDER_SOLID = STYLE_SOLID, // Línea Sólida
|
| FVG_BORDER_DASH = STYLE_DASH, // Línea Discontinua
|
| FVG_BORDER_DOT = STYLE_DOT, // Línea Punteada
|
| FVG_BORDER_DASHDOT = STYLE_DASHDOT, // Guión-Punto
|
| FVG_BORDER_DASHDOTDOT = STYLE_DASHDOTDOT // Guión-Punto-Punto
|
| };
|
|
|
| // Tipo de extensión del FVG
|
| enum ENUM_FVG_EXTENSION
|
| {
|
| FVG_EXTEND_FIXED = 0, // Extensión Fija (N velas)
|
| FVG_EXTEND_UNTIL_FILL = 1 // Hasta ser llenado
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| PARÁMETROS DE ENTRADA - CONFIGURACIÓN DEL USUARIO |
|
| //+------------------------------------------------------------------+
|
|
|
| // === CONFIGURACIÓN GENERAL ===
|
| input group "══════════ CONFIGURACIÓN GENERAL ══════════"
|
| input ENUM_TIMEFRAMES InpTimeframe = PERIOD_CURRENT; // Timeframe de análisis
|
| input int InpLookbackBars = 500; // Velas a analizar (historial)
|
| input int InpMinFVGSize = 5; // Tamaño mínimo FVG (puntos)
|
| input bool InpShowFilledFVG = false; // Mostrar FVG ya llenados
|
| input ENUM_FVG_EXTENSION InpExtensionType = FVG_EXTEND_UNTIL_FILL; // Tipo de extensión
|
|
|
| // === FVG ALCISTAS (BULLISH) ===
|
| input group "══════════ FVG ALCISTAS (BULLISH) ══════════"
|
| input bool InpShowBullishFVG = true; // Activar FVG Alcistas
|
| input color InpBullishColor = clrDodgerBlue; // Color FVG Alcista
|
| input uchar InpBullishOpacity = 50; // Opacidad (0-255)
|
| input int InpBullishWidth = 1; // Grosor del borde
|
| input ENUM_FVG_BORDER_STYLE InpBullishStyle = FVG_BORDER_SOLID; // Estilo del borde
|
| input bool InpBullishFill = true; // Rellenar rectángulo
|
|
|
| // === FVG BAJISTAS (BEARISH) ===
|
| input group "══════════ FVG BAJISTAS (BEARISH) ══════════"
|
| input bool InpShowBearishFVG = true; // Activar FVG Bajistas
|
| input color InpBearishColor = clrCrimson; // Color FVG Bajista
|
| input uchar InpBearishOpacity = 50; // Opacidad (0-255)
|
| input int InpBearishWidth = 1; // Grosor del borde
|
| input ENUM_FVG_BORDER_STYLE InpBearishStyle = FVG_BORDER_SOLID; // Estilo del borde
|
| input bool InpBearishFill = true; // Rellenar rectángulo
|
|
|
| // === CONFIGURACIÓN AVANZADA ===
|
| input group "══════════ CONFIGURACIÓN AVANZADA ══════════"
|
| input int InpFixedExtension = 50; // Extensión fija (velas)
|
| input bool InpDeleteOnFill = true; // Eliminar FVG al llenarse
|
| input int InpUpdateFrequency = 1; // Frecuencia actualización (ticks)
|
| input string InpObjectPrefix = "FVG_"; // Prefijo objetos gráficos
|
|
|
| //+------------------------------------------------------------------+
|
| //| ESTRUCTURA PARA ALMACENAR INFORMACIÓN DE FVG |
|
| //+------------------------------------------------------------------+
|
| struct FVG_Data
|
| {
|
| datetime timeStart; // Tiempo de inicio (vela del gap)
|
| datetime timeEnd; // Tiempo de fin (extensión)
|
| double priceHigh; // Precio superior del gap
|
| double priceLow; // Precio inferior del gap
|
| bool isBullish; // true = alcista, false = bajista
|
| bool isFilled; // true si el gap ha sido llenado
|
| int barIndex; // Índice de la vela donde se formó
|
| string objectName; // Nombre del objeto gráfico
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| VARIABLES GLOBALES |
|
| //+------------------------------------------------------------------+
|
| FVG_Data g_fvgArray[]; // Array dinámico de FVGs detectados
|
| int g_totalFVG = 0; // Contador total de FVGs
|
| int g_tickCounter = 0; // Contador de ticks para optimización
|
| datetime g_lastBarTime = 0; // Tiempo de la última vela procesada
|
| int g_lastBarsCount = 0; // Último conteo de barras
|
| string g_chartSymbol; // Símbolo del gráfico
|
| ENUM_TIMEFRAMES g_chartTimeframe; // Timeframe activo
|
| double g_pointValue; // Valor del punto
|
| int g_digits; // Dígitos del símbolo
|
|
|
| //+------------------------------------------------------------------+
|
| //| FUNCIÓN DE INICIALIZACIÓN DEL EXPERT ADVISOR |
|
| //+------------------------------------------------------------------+
|
| int OnInit()
|
| {
|
| CMetricsSave::Start(FILE_CODE6);
|
|
|
|
|
| // Validar parámetros de entrada
|
| if(!ValidateInputParameters())
|
| {
|
| Print("❌ Error: Parámetros de entrada inválidos");
|
| return(INIT_PARAMETERS_INCORRECT);
|
| }
|
|
|
| // Inicializar variables globales
|
| g_chartSymbol = _Symbol;
|
| g_chartTimeframe = (InpTimeframe == PERIOD_CURRENT) ? Period() : InpTimeframe;
|
| g_pointValue = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
|
| g_digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
|
| g_lastBarTime = 0;
|
| g_lastBarsCount = 0;
|
| g_tickCounter = 0;
|
|
|
| // Limpiar objetos gráficos anteriores
|
| CleanupGraphicObjects();
|
|
|
| // Inicializar array de FVGs
|
| ArrayResize(g_fvgArray, 0);
|
| g_totalFVG = 0;
|
|
|
| // Detectar FVGs en el historial
|
| DetectHistoricalFVGs();
|
|
|
| // Dibujar FVGs detectados
|
| DrawAllFVGs();
|
|
|
| // Forzar actualización del gráfico
|
| ChartRedraw(0);
|
|
|
| // Mensaje de inicialización exitosa
|
| Print("═══════════════════════════════════════════════════════════");
|
| Print("✅ FVG Detector EA iniciado correctamente");
|
| Print("📊 Símbolo: ", g_chartSymbol, " | Timeframe: ", EnumToString(g_chartTimeframe));
|
| Print("📈 FVGs Alcistas: ", InpShowBullishFVG ? "Activados" : "Desactivados");
|
| Print("📉 FVGs Bajistas: ", InpShowBearishFVG ? "Activados" : "Desactivados");
|
| Print("📋 FVGs detectados: ", g_totalFVG);
|
| Print("═══════════════════════════════════════════════════════════");
|
|
|
| return(INIT_SUCCEEDED);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| FUNCIÓN DE DESINICIALIZACIÓN |
|
| //+------------------------------------------------------------------+
|
| void OnDeinit(const int reason)
|
| {
|
| // Limpiar todos los objetos gráficos creados
|
| CleanupGraphicObjects();
|
|
|
| // Liberar memoria del array
|
| ArrayFree(g_fvgArray);
|
| g_totalFVG = 0;
|
|
|
| // Mensaje de cierre
|
| string reasonText = "";
|
| switch(reason)
|
| {
|
| case REASON_PROGRAM: reasonText = "Programa terminado"; break;
|
| case REASON_REMOVE: reasonText = "EA eliminado del gráfico"; break;
|
| case REASON_RECOMPILE: reasonText = "EA recompilado"; break;
|
| case REASON_CHARTCHANGE: reasonText = "Símbolo o timeframe cambiado"; break;
|
| case REASON_CHARTCLOSE: reasonText = "Gráfico cerrado"; break;
|
| case REASON_PARAMETERS: reasonText = "Parámetros modificados"; break;
|
| case REASON_ACCOUNT: reasonText = "Cuenta cambiada"; break;
|
| case REASON_TEMPLATE: reasonText = "Nueva plantilla aplicada"; break;
|
| default: reasonText = "Razón desconocida"; break;
|
| }
|
|
|
| Print("══════════════════════════════════════════════════════════");
|
| Print("⏹️ FVG Detector EA detenido - ", reasonText);
|
| Print("══════════════════════════════════════════════════════════");
|
| CMetricsSave::Destroy();
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| FUNCIÓN PRINCIPAL OnTick - PROCESAMIENTO EN TIEMPO REAL |
|
| //+------------------------------------------------------------------+
|
| void OnTick()
|
| {
|
| // Control de frecuencia de actualización para optimización
|
| g_tickCounter++;
|
| if(g_tickCounter < InpUpdateFrequency)
|
| return;
|
| g_tickCounter = 0;
|
|
|
| // Obtener tiempo de la vela actual
|
| datetime currentBarTime = iTime(g_chartSymbol, g_chartTimeframe, 0);
|
| int currentBarsCount = iBars(g_chartSymbol, g_chartTimeframe);
|
|
|
| // Verificar si hay una nueva vela
|
| bool isNewBar = (currentBarTime != g_lastBarTime);
|
| bool barsChanged = (currentBarsCount != g_lastBarsCount);
|
|
|
| if(isNewBar || barsChanged)
|
| {
|
| g_lastBarTime = currentBarTime;
|
| g_lastBarsCount = currentBarsCount;
|
|
|
| // Detectar nuevo FVG potencial (solo en la vela más reciente completa)
|
| CheckForNewFVG(1);
|
|
|
| // Actualizar estado de FVGs existentes (verificar si fueron llenados)
|
| UpdateFVGStatus();
|
|
|
| // Redibujar FVGs si es necesario
|
| RedrawModifiedFVGs();
|
| }
|
| else
|
| {
|
| // Solo actualizar extensiones si no hay nueva vela
|
| UpdateFVGExtensions();
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| VALIDACIÓN DE PARÁMETROS DE ENTRADA |
|
| //+------------------------------------------------------------------+
|
| bool ValidateInputParameters()
|
| {
|
| bool isValid = true;
|
|
|
| // Validar lookback
|
| if(InpLookbackBars < 10 || InpLookbackBars > 10000)
|
| {
|
| Print("⚠️ Advertencia: LookbackBars debe estar entre 10 y 10000. Usando 500.");
|
| // Continuar con valor por defecto
|
| }
|
|
|
| // Validar tamaño mínimo
|
| if(InpMinFVGSize < 0)
|
| {
|
| Print("⚠️ Advertencia: MinFVGSize no puede ser negativo.");
|
| }
|
|
|
| // Validar que al menos un tipo de FVG esté activo
|
| if(!InpShowBullishFVG && !InpShowBearishFVG)
|
| {
|
| Print("⚠️ Advertencia: Ambos tipos de FVG están desactivados. El EA no mostrará nada.");
|
| }
|
|
|
| return isValid;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| LIMPIEZA DE OBJETOS GRÁFICOS |
|
| //+------------------------------------------------------------------+
|
| void CleanupGraphicObjects()
|
| {
|
| int totalObjects = ObjectsTotal(0, 0, OBJ_RECTANGLE);
|
|
|
| // Iterar en orden inverso para eliminar objetos con nuestro prefijo
|
| for(int i = totalObjects - 1; i >= 0; i--)
|
| {
|
| string objName = ObjectName(0, i, 0, OBJ_RECTANGLE);
|
| if(StringFind(objName, InpObjectPrefix) == 0)
|
| {
|
| ObjectDelete(0, objName);
|
| }
|
| }
|
|
|
| ChartRedraw(0);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| DETECCIÓN DE FVGs EN DATOS HISTÓRICOS |
|
| //+------------------------------------------------------------------+
|
| void DetectHistoricalFVGs()
|
| {
|
| // Determinar el rango de barras a analizar
|
| int totalBars = iBars(g_chartSymbol, g_chartTimeframe);
|
| int barsToAnalyze = MathMin(InpLookbackBars, totalBars - 3);
|
|
|
| if(barsToAnalyze < 3)
|
| {
|
| Print("⚠️ No hay suficientes datos históricos para análisis");
|
| return;
|
| }
|
|
|
| // Reservar memoria para el array (estimación inicial)
|
| ArrayResize(g_fvgArray, 0, barsToAnalyze / 10);
|
|
|
| // Iterar desde la vela más antigua hacia la más reciente
|
| for(int i = barsToAnalyze; i >= 2; i--)
|
| {
|
| CheckForFVGAtBar(i);
|
| }
|
|
|
| // Ajustar tamaño final del array
|
| ArrayResize(g_fvgArray, g_totalFVG);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| VERIFICAR FVG EN UNA VELA ESPECÍFICA |
|
| //+------------------------------------------------------------------+
|
| void CheckForFVGAtBar(int barIndex)
|
| {
|
| // Obtener datos OHLC de las 3 velas necesarias
|
| // Vela 0 (barIndex+1): Primera vela
|
| // Vela 1 (barIndex): Vela del impulso (donde se forma el gap)
|
| // Vela 2 (barIndex-1): Tercera vela
|
|
|
| double high0 = iHigh(g_chartSymbol, g_chartTimeframe, barIndex + 1);
|
| double low0 = iLow(g_chartSymbol, g_chartTimeframe, barIndex + 1);
|
| double high2 = iHigh(g_chartSymbol, g_chartTimeframe, barIndex - 1);
|
| double low2 = iLow(g_chartSymbol, g_chartTimeframe, barIndex - 1);
|
|
|
| // Verificar datos válidos
|
| if(high0 <= 0 || low0 <= 0 || high2 <= 0 || low2 <= 0)
|
| return;
|
|
|
| // Tiempos de las velas
|
| datetime time1 = iTime(g_chartSymbol, g_chartTimeframe, barIndex);
|
| datetime time2 = iTime(g_chartSymbol, g_chartTimeframe, barIndex - 1);
|
|
|
| // Tamaño mínimo en precio
|
| double minSize = InpMinFVGSize * g_pointValue;
|
|
|
| // === DETECCIÓN FVG ALCISTA (BULLISH) ===
|
| // Se forma cuando: Low de vela 3 > High de vela 1
|
| if(InpShowBullishFVG && low2 > high0)
|
| {
|
| double gapHigh = low2;
|
| double gapLow = high0;
|
| double gapSize = gapHigh - gapLow;
|
|
|
| if(gapSize >= minSize)
|
| {
|
| // Crear nuevo FVG
|
| FVG_Data newFVG;
|
| newFVG.timeStart = time1;
|
| newFVG.timeEnd = time2;
|
| newFVG.priceHigh = gapHigh;
|
| newFVG.priceLow = gapLow;
|
| newFVG.isBullish = true;
|
| newFVG.isFilled = false;
|
| newFVG.barIndex = barIndex;
|
| newFVG.objectName = GenerateFVGObjectName(true, barIndex);
|
|
|
| // Verificar si ya fue llenado en el historial
|
| CheckIfFVGFilledHistorical(newFVG);
|
|
|
| // Solo agregar si no está llenado o si queremos mostrar llenados
|
| if(!newFVG.isFilled || InpShowFilledFVG)
|
| {
|
| AddFVGToArray(newFVG);
|
| }
|
| }
|
| }
|
|
|
| // === DETECCIÓN FVG BAJISTA (BEARISH) ===
|
| // Se forma cuando: High de vela 3 < Low de vela 1
|
| if(InpShowBearishFVG && high2 < low0)
|
| {
|
| double gapHigh = low0;
|
| double gapLow = high2;
|
| double gapSize = gapHigh - gapLow;
|
|
|
| if(gapSize >= minSize)
|
| {
|
| // Crear nuevo FVG
|
| FVG_Data newFVG;
|
| newFVG.timeStart = time1;
|
| newFVG.timeEnd = time2;
|
| newFVG.priceHigh = gapHigh;
|
| newFVG.priceLow = gapLow;
|
| newFVG.isBullish = false;
|
| newFVG.isFilled = false;
|
| newFVG.barIndex = barIndex;
|
| newFVG.objectName = GenerateFVGObjectName(false, barIndex);
|
|
|
| // Verificar si ya fue llenado en el historial
|
| CheckIfFVGFilledHistorical(newFVG);
|
|
|
| // Solo agregar si no está llenado o si queremos mostrar llenados
|
| if(!newFVG.isFilled || InpShowFilledFVG)
|
| {
|
| AddFVGToArray(newFVG);
|
| }
|
| }
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| VERIFICAR SI FVG FUE LLENADO EN HISTORIAL |
|
| //+------------------------------------------------------------------+
|
| void CheckIfFVGFilledHistorical(FVG_Data &fvg)
|
| {
|
| // Obtener el índice de barra actual del FVG
|
| int fvgBarShift = iBarShift(g_chartSymbol, g_chartTimeframe, fvg.timeStart);
|
| if(fvgBarShift < 0) return;
|
|
|
| // Verificar todas las velas posteriores al FVG
|
| for(int i = fvgBarShift - 1; i >= 0; i--)
|
| {
|
| double high = iHigh(g_chartSymbol, g_chartTimeframe, i);
|
| double low = iLow(g_chartSymbol, g_chartTimeframe, i);
|
|
|
| if(fvg.isBullish)
|
| {
|
| // FVG alcista se llena cuando el precio baja hasta el nivel inferior
|
| if(low <= fvg.priceLow)
|
| {
|
| fvg.isFilled = true;
|
| fvg.timeEnd = iTime(g_chartSymbol, g_chartTimeframe, i);
|
| return;
|
| }
|
| }
|
| else
|
| {
|
| // FVG bajista se llena cuando el precio sube hasta el nivel superior
|
| if(high >= fvg.priceHigh)
|
| {
|
| fvg.isFilled = true;
|
| fvg.timeEnd = iTime(g_chartSymbol, g_chartTimeframe, i);
|
| return;
|
| }
|
| }
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| AGREGAR FVG AL ARRAY DINÁMICO |
|
| //+------------------------------------------------------------------+
|
| void AddFVGToArray(FVG_Data &newFVG)
|
| {
|
| int newSize = g_totalFVG + 1;
|
| ArrayResize(g_fvgArray, newSize, 100);
|
| g_fvgArray[g_totalFVG] = newFVG;
|
| g_totalFVG = newSize;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| GENERAR NOMBRE ÚNICO PARA OBJETO FVG |
|
| //+------------------------------------------------------------------+
|
| string GenerateFVGObjectName(bool isBullish, int barIndex)
|
| {
|
| string type = isBullish ? "BULL_" : "BEAR_";
|
| datetime barTime = iTime(g_chartSymbol, g_chartTimeframe, barIndex);
|
| return InpObjectPrefix + type + IntegerToString((long)barTime);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| DIBUJAR TODOS LOS FVGs |
|
| //+------------------------------------------------------------------+
|
| void DrawAllFVGs()
|
| {
|
| for(int i = 0; i < g_totalFVG; i++)
|
| {
|
| DrawSingleFVG(g_fvgArray[i]);
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| DIBUJAR UN FVG INDIVIDUAL |
|
| //+------------------------------------------------------------------+
|
| void DrawSingleFVG(FVG_Data &fvg)
|
| {
|
| // Si está llenado y no queremos mostrar llenados, eliminar objeto existente
|
| if(fvg.isFilled && !InpShowFilledFVG)
|
| {
|
| if(ObjectFind(0, fvg.objectName) >= 0)
|
| {
|
| ObjectDelete(0, fvg.objectName);
|
| }
|
| return;
|
| }
|
|
|
| // Si ya existe el objeto y está llenado, eliminarlo si corresponde
|
| if(fvg.isFilled && InpDeleteOnFill && ObjectFind(0, fvg.objectName) >= 0)
|
| {
|
| ObjectDelete(0, fvg.objectName);
|
| return;
|
| }
|
|
|
| // Calcular tiempo de fin del rectángulo
|
| datetime endTime = CalculateFVGEndTime(fvg);
|
|
|
| // Obtener configuración visual según tipo
|
| color fvgColor;
|
| uchar opacity;
|
| int borderWidth;
|
| ENUM_LINE_STYLE borderStyle;
|
| bool fillRectangle;
|
|
|
| if(fvg.isBullish)
|
| {
|
| fvgColor = InpBullishColor;
|
| opacity = InpBullishOpacity;
|
| borderWidth = InpBullishWidth;
|
| borderStyle = (ENUM_LINE_STYLE)InpBullishStyle;
|
| fillRectangle = InpBullishFill;
|
| }
|
| else
|
| {
|
| fvgColor = InpBearishColor;
|
| opacity = InpBearishOpacity;
|
| borderWidth = InpBearishWidth;
|
| borderStyle = (ENUM_LINE_STYLE)InpBearishStyle;
|
| fillRectangle = InpBearishFill;
|
| }
|
|
|
| // Crear o actualizar el rectángulo
|
| if(ObjectFind(0, fvg.objectName) < 0)
|
| {
|
| // Crear nuevo objeto rectángulo
|
| if(!ObjectCreate(0, fvg.objectName, OBJ_RECTANGLE, 0,
|
| fvg.timeStart, fvg.priceHigh, endTime, fvg.priceLow))
|
| {
|
| Print("❌ Error al crear rectángulo FVG: ", GetLastError());
|
| return;
|
| }
|
| }
|
| else
|
| {
|
| // Actualizar coordenadas del objeto existente
|
| ObjectSetInteger(0, fvg.objectName, OBJPROP_TIME, 0, fvg.timeStart);
|
| ObjectSetDouble(0, fvg.objectName, OBJPROP_PRICE, 0, fvg.priceHigh);
|
| ObjectSetInteger(0, fvg.objectName, OBJPROP_TIME, 1, endTime);
|
| ObjectSetDouble(0, fvg.objectName, OBJPROP_PRICE, 1, fvg.priceLow);
|
| }
|
|
|
| // Configurar propiedades visuales con color ARGB (usando función nativa)
|
| uint colorARGB = ColorToARGB(fvgColor, opacity);
|
|
|
| ObjectSetInteger(0, fvg.objectName, OBJPROP_COLOR, colorARGB);
|
| ObjectSetInteger(0, fvg.objectName, OBJPROP_STYLE, borderStyle);
|
| ObjectSetInteger(0, fvg.objectName, OBJPROP_WIDTH, borderWidth);
|
| ObjectSetInteger(0, fvg.objectName, OBJPROP_FILL, fillRectangle);
|
| ObjectSetInteger(0, fvg.objectName, OBJPROP_BACK, true);
|
| ObjectSetInteger(0, fvg.objectName, OBJPROP_SELECTABLE, false);
|
| ObjectSetInteger(0, fvg.objectName, OBJPROP_HIDDEN, true);
|
|
|
| // Tooltip descriptivo
|
| string tooltip = StringFormat("%s FVG\nAlto: %s\nBajo: %s\nTamaño: %.1f pips%s",
|
| fvg.isBullish ? "📈 Alcista" : "📉 Bajista",
|
| DoubleToString(fvg.priceHigh, g_digits),
|
| DoubleToString(fvg.priceLow, g_digits),
|
| (fvg.priceHigh - fvg.priceLow) / g_pointValue / 10,
|
| fvg.isFilled ? "\n✓ LLENADO" : "");
|
| ObjectSetString(0, fvg.objectName, OBJPROP_TOOLTIP, tooltip);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| CALCULAR TIEMPO DE FIN DEL FVG |
|
| //+------------------------------------------------------------------+
|
| datetime CalculateFVGEndTime(FVG_Data &fvg)
|
| {
|
| if(fvg.isFilled)
|
| {
|
| return fvg.timeEnd;
|
| }
|
|
|
| switch(InpExtensionType)
|
| {
|
| case FVG_EXTEND_FIXED:
|
| {
|
| // Extensión fija: N velas desde el FVG
|
| int barShift = iBarShift(g_chartSymbol, g_chartTimeframe, fvg.timeStart);
|
| if(barShift < 0) barShift = 0;
|
|
|
| int targetBar = MathMax(0, barShift - InpFixedExtension);
|
| return iTime(g_chartSymbol, g_chartTimeframe, targetBar);
|
| }
|
|
|
| case FVG_EXTEND_UNTIL_FILL:
|
| default:
|
| {
|
| // Extender hasta el tiempo actual (última vela)
|
| return iTime(g_chartSymbol, g_chartTimeframe, 0);
|
| }
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| VERIFICAR NUEVO FVG EN TIEMPO REAL |
|
| //+------------------------------------------------------------------+
|
| void CheckForNewFVG(int barIndex)
|
| {
|
| // Verificar que tenemos suficientes datos
|
| if(barIndex < 1) return;
|
|
|
| // Solo verificar si la vela en barIndex está completa
|
| // (barIndex debe ser al menos 1 para que la formación esté completa)
|
| CheckForFVGAtBar(barIndex + 1);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| ACTUALIZAR ESTADO DE FVGs (VERIFICAR SI FUERON LLENADOS) |
|
| //+------------------------------------------------------------------+
|
| void UpdateFVGStatus()
|
| {
|
| for(int i = 0; i < g_totalFVG; i++)
|
| {
|
| if(g_fvgArray[i].isFilled)
|
| continue;
|
|
|
| // Obtener precio actual
|
| double currentHigh = iHigh(g_chartSymbol, g_chartTimeframe, 0);
|
| double currentLow = iLow(g_chartSymbol, g_chartTimeframe, 0);
|
|
|
| if(g_fvgArray[i].isBullish)
|
| {
|
| // FVG alcista se llena si el precio baja hasta el nivel inferior
|
| if(currentLow <= g_fvgArray[i].priceLow)
|
| {
|
| g_fvgArray[i].isFilled = true;
|
| g_fvgArray[i].timeEnd = iTime(g_chartSymbol, g_chartTimeframe, 0);
|
| }
|
| }
|
| else
|
| {
|
| // FVG bajista se llena si el precio sube hasta el nivel superior
|
| if(currentHigh >= g_fvgArray[i].priceHigh)
|
| {
|
| g_fvgArray[i].isFilled = true;
|
| g_fvgArray[i].timeEnd = iTime(g_chartSymbol, g_chartTimeframe, 0);
|
| }
|
| }
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| REDIBUJAR FVGs MODIFICADOS |
|
| //+------------------------------------------------------------------+
|
| void RedrawModifiedFVGs()
|
| {
|
| for(int i = 0; i < g_totalFVG; i++)
|
| {
|
| DrawSingleFVG(g_fvgArray[i]);
|
| }
|
|
|
| ChartRedraw(0);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| ACTUALIZAR EXTENSIONES DE FVGs |
|
| //+------------------------------------------------------------------+
|
| void UpdateFVGExtensions()
|
| {
|
| bool needsRedraw = false;
|
|
|
| for(int i = 0; i < g_totalFVG; i++)
|
| {
|
| if(!g_fvgArray[i].isFilled && InpExtensionType == FVG_EXTEND_UNTIL_FILL)
|
| {
|
| datetime newEndTime = iTime(g_chartSymbol, g_chartTimeframe, 0);
|
|
|
| if(ObjectFind(0, g_fvgArray[i].objectName) >= 0)
|
| {
|
| datetime currentEndTime = (datetime)ObjectGetInteger(0, g_fvgArray[i].objectName, OBJPROP_TIME, 1);
|
|
|
| if(currentEndTime != newEndTime)
|
| {
|
| ObjectSetInteger(0, g_fvgArray[i].objectName, OBJPROP_TIME, 1, newEndTime);
|
| needsRedraw = true;
|
| }
|
| }
|
| }
|
| }
|
|
|
| if(needsRedraw)
|
| {
|
| ChartRedraw(0);
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| FUNCIÓN PARA MANEJAR EVENTOS DEL GRÁFICO |
|
| //+------------------------------------------------------------------+
|
| void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
|
| {
|
| // Manejar cambio de escala o desplazamiento del gráfico
|
| if(id == CHARTEVENT_CHART_CHANGE)
|
| {
|
| // Redibujar FVGs para asegurar visualización correcta
|
| ChartRedraw(0);
|
| }
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| FUNCIÓN PARA OBTENER ESTADÍSTICAS |
|
| //+------------------------------------------------------------------+
|
| string GetFVGStatistics()
|
| {
|
| int bullishCount = 0;
|
| int bearishCount = 0;
|
| int filledCount = 0;
|
| int activeCount = 0;
|
|
|
| for(int i = 0; i < g_totalFVG; i++)
|
| {
|
| if(g_fvgArray[i].isBullish)
|
| bullishCount++;
|
| else
|
| bearishCount++;
|
|
|
| if(g_fvgArray[i].isFilled)
|
| filledCount++;
|
| else
|
| activeCount++;
|
| }
|
|
|
| return StringFormat(
|
| "═══ ESTADÍSTICAS FVG ═══\n"
|
| "Total: %d\n"
|
| "Alcistas: %d\n"
|
| "Bajistas: %d\n"
|
| "Activos: %d\n"
|
| "Llenados: %d",
|
| g_totalFVG, bullishCount, bearishCount, activeCount, filledCount
|
| );
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| FIN DEL EXPERT ADVISOR |
|
| //+------------------------------------------------------------------+ |
