ICTLibraryExamples/Benchmark/OtherCode/Code4.mq5

<EFBFBD><EFBFBD>//+------------------------------------------------------------------+

//|                                               FVG_Detector.mq5   |

//|                                   Expert Advisor para MT5        |

//|                      Detecci<EFBFBD>n y Visualizaci<EFBFBD>n de Fair Value Gaps|

//+------------------------------------------------------------------+

#property copyright "FVG Visual Detector"

#property link      ""

#property version   "1.00"

#property description "Expert Advisor exclusivo para detectar y dibujar Fair Value Gaps"

#property description "NO ejecuta trades - Solo an<00>lisis visual"

#property strict



//+------------------------------------------------------------------+

//|                                                                  |

//+------------------------------------------------------------------+

#include "..\\Utils\\MetricSaver.mqh"

#include <TSN\\MQLArticles\\Utils\\TFManager.mqh>





/* Codigo hecho por ia Claude Sonnet 4.6

Promt:

Desarrolla un BOT (Expert Advisor) para MetaTrader 5 (MT5) que EXCLUSIVAMENTE detecte y dibuje Fair Value Gaps (FVG) en el gr<EFBFBD>fico.

 <EFBFBD>&<EFBFBD> Este BOT NO debe ejecutar operaciones, NO debe abrir/cerrar trades y NO debe funcionar como indicador. Su <EFBFBD>nica funci<EFBFBD>n es an<EFBFBD>lisis visual mediante dibujo en el gr<EFBFBD>fico

 . Requisitos t<EFBFBD>cnicos obligatorios: Implementado como Expert Advisor (EA) en MQL5. Detecci<EFBFBD>n y dibujo de FVG alcistas y bajistas.

 Funcionamiento r<EFBFBD>pido, eficiente y altamente optimizado. Capaz de trabajar con datos hist<EFBFBD>ricos y en tiempo real.

 Configuraci<EFBFBD>n personalizable desde el panel del BOT: Colores de los FVG. Opacidad / transparencia.

 Grosor y estilo de los rect<EFBFBD>ngulos. Activar o desactivar FVG alcistas o bajistas. Timeframe de an<EFBFBD>lisis. Aspectos visuales:

  Los FVG deben dibujarse como zonas (rect<EFBFBD>ngulos) claras y limpias. Evitar redibujados innecesarios. El BOT debe actualizar los FVG solo cuando sea necesario.

  Buenas pr<EFBFBD>cticas de desarrollo: C<EFBFBD>digo limpio, modular y bien comentado. Uso eficiente de OnInit, OnTick y manejo de objetos gr<EFBFBD>ficos.

   Optimizaci<EFBFBD>n de loops y c<EFBFBD>lculos para m<EFBFBD>nimo consumo de CPU.

  Usa todo tu conocimiento avanzado en MQL5, optimizaci<EFBFBD>n y Smart Money Concepts para crear un BOT profesional, estable y r<EFBFBD>pido,

  enfocado <EFBFBD>nicamente en dibujar Fair Value Gaps.

*/



//+------------------------------------------------------------------+

//| INPUTS - Configuraci<EFBFBD>n Personalizable                            |

//+------------------------------------------------------------------+

//+------------------------------------------------------------------+

//|  CFvgFast.mqh     Fair Value Gap <EFBFBD> Zero-alloc <EFBFBD> Flat arrays      |

//|  Mismo estilo que CFvgBar: Create / Set / SetGraphic / OnNewBar  |

//|  Sin clases internas <EFBFBD> Sin new/delete <EFBFBD> Arrays est<EFBFBD>ticos         |

//+------------------------------------------------------------------+

#property strict



#ifndef FVG_MAX

  #define FVG_MAX  200

#endif



//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

//  Zona FVG   40 bytes, sin strings din<EFBFBD>micos

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

struct FVGZone

{

   double   hi;

   double   lo;

   datetime t;

   bool     active;

   bool     bullish;

};



//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

//  CFvgFast

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

class CFvgFast

{

private:

   //--- arrays planos en el heap del objeto (no BSS, pero un solo alloc en Create)

   FVGZone  m_bull[FVG_MAX];

   FVGZone  m_bear[FVG_MAX];



   int      m_bull_n;

   int      m_bear_n;

   int      m_bull_head;   // circular overwrite

   int      m_bear_head;

   long     m_bull_total;  // total insertados (para saber si circular)

   long     m_bear_total;



   //--- nearest (actualizado 1x barra, le<EFBFBD>do N veces por EA)

   int      m_near_bull;

   int      m_near_bear;



   //--- config

   string   m_symbol;

   ENUM_TIMEFRAMES m_tf;

   string   m_prefix;

   int      m_lookback;

   double   m_min_gap;    // en precio, ya convertido

   bool     m_draw;



   //--- visual

   color    m_col_bull;

   color    m_col_bear;

   ENUM_LINE_STYLE m_style;

   bool     m_fill;

   int      m_border_w;

   bool     m_extend;

   int      m_extend_bars;



   //%%%%%%%% helpers privados %%%%%%%%



   string _Name(bool bull, int idx)

   {

      return m_prefix + (bull ? "B" : "S") + IntegerToString(idx);

   }



   void _DrawZone(int idx, bool bull)

   {

      if(!m_draw) return;

      FVGZone z = bull ? m_bull[idx] : m_bear[idx];

      if(!z.active) return;



      string   nm  = _Name(bull, idx);

      color    c   = bull ? m_col_bull : m_col_bear;

      datetime t1  = z.t;

      datetime t2  = m_extend

                     ? z.t + (datetime)PeriodSeconds(m_tf) * m_extend_bars

                     : 0;



      if(ObjectFind(0, nm) < 0)

         ObjectCreate(0, nm, OBJ_RECTANGLE, 0, t1, z.hi, t2, z.lo);

      else

      {

         ObjectSetInteger(0, nm, OBJPROP_TIME,  0, t1);

         ObjectSetInteger(0, nm, OBJPROP_TIME,  1, t2);

         ObjectSetDouble (0, nm, OBJPROP_PRICE, 0, z.hi);

         ObjectSetDouble (0, nm, OBJPROP_PRICE, 1, z.lo);

      }

      ObjectSetInteger(0, nm, OBJPROP_COLOR,      c);

      ObjectSetInteger(0, nm, OBJPROP_STYLE,      m_style);

      ObjectSetInteger(0, nm, OBJPROP_WIDTH,      m_border_w);

      ObjectSetInteger(0, nm, OBJPROP_FILL,       m_fill);

      ObjectSetInteger(0, nm, OBJPROP_BACK,       true);

      ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false);

      ObjectSetInteger(0, nm, OBJPROP_HIDDEN,     true);

   }



   void _DeleteZone(int idx, bool bull)

   {

      if(!m_draw) return;

      ObjectDelete(0, _Name(bull, idx));

   }



   void _Insert(const FVGZone &z)

   {

      if(z.bullish)

      {

         int i = m_bull_head;

         if(m_bull_total >= FVG_MAX) _DeleteZone(i, true);

         m_bull[i] = z;

         _DrawZone(i, true);

         m_bull_head = (m_bull_head + 1) % FVG_MAX;

         if(m_bull_n < FVG_MAX) m_bull_n++;

         m_bull_total++;

      }

      else

      {

         int i = m_bear_head;

         if(m_bear_total >= FVG_MAX) _DeleteZone(i, false);

         m_bear[i] = z;

         _DrawZone(i, false);

         m_bear_head = (m_bear_head + 1) % FVG_MAX;

         if(m_bear_n < FVG_MAX) m_bear_n++;

         m_bear_total++;

      }

   }



   //--- Detecci<EFBFBD>n O(1): lee 3 velas, eval<EFBFBD>a gap

   void _Detect(int shift)

   {

      double hi[3], lo[3];

      datetime t[1];

      if(CopyHigh(m_symbol, m_tf, shift,   3, hi) < 3) return;

      if(CopyLow (m_symbol, m_tf, shift,   3, lo) < 3) return;

      if(CopyTime(m_symbol, m_tf, shift+1, 1, t)  < 1) return;



      //--- Bull FVG: low[0] > high[2]

      if(lo[0] > hi[2] && (lo[0] - hi[2]) >= m_min_gap)

      {

         FVGZone z;

         z.hi = lo[0]; z.lo = hi[2]; z.t = t[0];

         z.active = true; z.bullish = true;

         _Insert(z);

      }

      //--- Bear FVG: high[0] < low[2]

      if(hi[0] < lo[2] && (lo[2] - hi[0]) >= m_min_gap)

      {

         FVGZone z;

         z.hi = lo[2]; z.lo = hi[0]; z.t = t[0];

         z.active = true; z.bullish = false;

         _Insert(z);

      }

   }



   //--- Mitigaci<EFBFBD>n O(n), solo comparaciones de double

   void _Mitigate(double price)

   {

      int n = (int)MathMin(m_bull_n, FVG_MAX);

      for(int i = 0; i < n; i++)

      {

         if(!m_bull[i].active) continue;

        if(price <= m_bull[i].hi && price >= m_bull[i].lo)

         {

            m_bull[i].active = false;

            _DeleteZone(i, true);

         }

      }

      n = (int)MathMin(m_bear_n, FVG_MAX);

      for(int i = 0; i < n; i++)

      {

         if(!m_bear[i].active) continue;

         if(price >= m_bear[i].lo && price <= m_bear[i].hi)

         {

            m_bear[i].active = false;

            _DeleteZone(i, false);

         }

      }

   }



   //--- Nearest O(n), 1x barra

   void _UpdateNearest(double price)

   {