MwlRCT WorkSpace: Custom EA and Indicator Development

XAUUSD-M1

BTCUSD - M15

GBPAUD: M30 on M5

//--- NEW: History and Timeframe inputs (modeled on reference indicator)
extern int                          History           = 4444;              // How many bars to draw/calc
extern ENUM_TIMEFRAMES HLTimeFrame = PERIOD_CURRENT;    // Calculation timeframe

 //+------------------------------------------------------------------+
//|                                          A! Volumatic VIDYA.mq4  |
//|                                     Converted from Pine Script   |
//|                          Updated with History & MTF Support      |
//+------------------------------------------------------------------+
#property strict
#property indicator_chart_window
#property indicator_buffers 8
#property indicator_plots   8
//--- Plot VIDYA Up
#property indicator_label1  "VIDYA Up"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrLimeGreen
#property indicator_style1  STYLE_SOLID
#property indicator_width1  5
//--- Plot VIDYA Down
#property indicator_label2  "VIDYA Down"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrCrimson
#property indicator_style2  STYLE_SOLID
#property indicator_width2  5
//--- Plot Extra Line Up
#property indicator_label3  "Extra Up"
#property indicator_type3   DRAW_LINE
#property indicator_color3  clrLimeGreen
#property indicator_style3  STYLE_DOT
#property indicator_width3  1
//--- Plot Extra Line Down
#property indicator_label4  "Extra Down"
#property indicator_type4   DRAW_LINE
#property indicator_color4  clrCrimson
#property indicator_style4  STYLE_DOT
#property indicator_width4  1
//--- Plot Take Profit Up
#property indicator_label5  "TP Up"
#property indicator_type5   DRAW_LINE
#property indicator_color5  clrAqua
#property indicator_style5  STYLE_DASH
#property indicator_width5  1
//--- Plot Take Profit Down
#property indicator_label6  "TP Down"
#property indicator_type6   DRAW_LINE
#property indicator_color6  clrAqua
#property indicator_style6  STYLE_DASH
#property indicator_width6  1
//--- Plot Buy Arrow
#property indicator_label7  "Buy Signal"
#property indicator_type7   DRAW_ARROW
#property indicator_color7  clrLime
#property indicator_width7  10
//--- Plot Sell Arrow
#property indicator_label8  "Sell Signal"
#property indicator_type8   DRAW_ARROW
#property indicator_color8  clrRed
#property indicator_width8  10
//--- Input parameters
//--- NEW: History and Timeframe inputs (modeled on reference indicator)
extern int             History     = 4444;              // How many bars to draw/calc
extern ENUM_TIMEFRAMES HLTimeFrame = PERIOD_CURRENT;    // Calculation timeframe
input int    VidyaLength          = 5;              // VIDYA Length
input int    VidyaMomentum        = 20;             // VIDYA Momentum
input double BandDistance         = 2.0;            // Distance Factor
input double ExtraLineMultiplier  = 3.0;            // Extra Line Multiplier
input double TakeProfitMultiplier = 2.0;            // Take Profit Multiplier
input int    PivotBars            = 3;              // Pivot Bars
input color  UpColor              = clrLimeGreen;   // Uptrend Color
input color  DownColor            = clrCrimson;     // Downtrend Color
input color  TakeProfitColor      = clrGray;        // Take Profit Color
 
//--- Indicator buffers
double VidyaUpBuffer[];
double VidyaDownBuffer[];
double ExtraLineUpBuffer[];
double ExtraLineDownBuffer[];
double TakeProfitUpBuffer[];
double TakeProfitDownBuffer[];
double BuyArrowBuffer[];
double SellArrowBuffer[];
//--- Global variables
double vidyaValue     = 0.0;
double smoothedValue  = 0.0;
bool   isTrendUp      = false;
double upTrendVolume  = 0.0;
double downTrendVolume= 0.0;
int    lastTrendBar   = 0;
//--- NEW: History/Timeframe helpers
int    MAX            = 0;       // Minimum bars needed for VIDYA + ATR
int    g_lastTFShift  = -1;      // Track last processed TF shift for VIDYA state
double g_prevVidya    = 0.0;     // VIDYA state (global for proper MTF handling)
//--- Signal tracking
bool priceTouchedDown = false;
bool priceTouchedUp   = false;
int  touchBarDown     = -1;
int  touchBarUp       = -1;
//--- Arrays for liquidity lines
struct LiquidityLine {
   int    startBar;
   double price;
   bool   isHigh;
   double volumeVal;
   bool   active;
};
LiquidityLine liquidityLines[];
int liquidityCount = 0;
//+------------------------------------------------------------------+
//| Convert timeframe enum to human-readable string                  |
//+------------------------------------------------------------------+
string stringMTF(int perMTF)
{
   if(perMTF == 0)           perMTF = _Period;
   if(perMTF == PERIOD_M1)   return("M1");
   if(perMTF == PERIOD_M5)   return("M5");
   if(perMTF == PERIOD_M15)  return("M15");
   if(perMTF == PERIOD_M30)  return("M30");
   if(perMTF == PERIOD_H1)   return("H1");
   if(perMTF == PERIOD_H4)   return("H4");
   if(perMTF == PERIOD_D1)   return("D1");
   if(perMTF == PERIOD_W1)   return("W1");
   if(perMTF == PERIOD_MN1)  return("MN1");
   return("M" + IntegerToString(perMTF));
}
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
   //--- Validate and normalize HLTimeFrame
   if(HLTimeFrame == PERIOD_CURRENT || HLTimeFrame == 0)
      HLTimeFrame = (ENUM_TIMEFRAMES)_Period;
   else if(HLTimeFrame < _Period)
      HLTimeFrame = (ENUM_TIMEFRAMES)_Period;  // Cannot use lower TF than chart
   
   //--- Compute MAX: bars needed for VIDYA + ATR(200)
   MAX = VidyaMomentum + 200;
   if(History < MAX)
      History = MAX;  // Ensure enough history for stable values
   
   //--- Get TF string for labels
   string tfStr = stringMTF((int)HLTimeFrame);
   
   //--- Indicator buffers mapping with MTF labels
   SetIndexBuffer(0, VidyaUpBuffer);
   SetIndexStyle(0, DRAW_LINE, STYLE_SOLID, 5, UpColor);
   SetIndexLabel(0, "[" + tfStr + "] BUY");
   
   SetIndexBuffer(1, VidyaDownBuffer);
   SetIndexStyle(1, DRAW_LINE, STYLE_SOLID, 5, DownColor);
   SetIndexLabel(1, "[" + tfStr + "] SELL");
   
   SetIndexBuffer(2, ExtraLineUpBuffer);
   SetIndexStyle(2, DRAW_LINE, STYLE_DOT, 1, UpColor);
   SetIndexLabel(2, "[" + tfStr + "] StopLoss Up");
   
   SetIndexBuffer(3, ExtraLineDownBuffer);
   SetIndexStyle(3, DRAW_LINE, STYLE_DOT, 1, DownColor);
   SetIndexLabel(3, "[" + tfStr + "] StopLoss Down");
   
   SetIndexBuffer(4, TakeProfitUpBuffer);
   SetIndexStyle(4, DRAW_LINE, STYLE_DASH, 1, TakeProfitColor);
   SetIndexLabel(4, "[" + tfStr + "] TakeProfit Up");
   
   SetIndexBuffer(5, TakeProfitDownBuffer);
   SetIndexStyle(5, DRAW_LINE, STYLE_DASH, 1, TakeProfitColor);
   SetIndexLabel(5, "[" + tfStr + "] TakeProfit Down");
   
   SetIndexBuffer(6, BuyArrowBuffer);
   SetIndexStyle(6, DRAW_ARROW, STYLE_SOLID, 3, clrLime);
   SetIndexArrow(6, 233);  // Up arrow
   SetIndexLabel(6, "[" + tfStr + "] Buy Signal");
   
   SetIndexBuffer(7, SellArrowBuffer);
   SetIndexStyle(7, DRAW_ARROW, STYLE_SOLID, 3, clrRed);
   SetIndexArrow(7, 234);  // Down arrow
   SetIndexLabel(7, "[" + tfStr + "] Sell Signal");
   
   //--- Set empty values for all buffers
   for(int i = 0; i < 8; i++)
      SetIndexEmptyValue(i, EMPTY_VALUE);
   
   //--- Set draw begin based on History (limits drawing to recent bars)
   int draw_begin = (History > MAX) ? MathMax(0, Bars - History) : MAX;
   for(int i = 0; i < 8; i++)
      SetIndexDrawBegin(i, draw_begin);
   
   //--- Initialize arrays
   ArrayResize(liquidityLines, 500);
   liquidityCount = 0;
   
   //--- Initialize variables
   vidyaValue      = 0.0;
   smoothedValue   = 0.0;
   isTrendUp       = false;
   upTrendVolume   = 0.0;
   downTrendVolume = 0.0;
   lastTrendBar    = 0;
   g_lastTFShift   = -1;
   g_prevVidya     = 0.0;
   
   //--- Set indicator short name with TF and History info
   IndicatorShortName("A! Volumatic VIDYA [" + tfStr + "] Hist=" + IntegerToString(History));
   
   //--- Debug print for verification
   Print("VIDYA Init: HLTimeFrame=", tfStr, " History=", History, " MAX=", MAX, " ChartTF=", stringMTF(_Period));
   
   return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Calculate VIDYA (MTF-aware with proper state tracking)           |
//+------------------------------------------------------------------+
double CalculateVIDYA(int tfShift, double src)
{
   int bars_tf = iBars(NULL, HLTimeFrame);
   if(bars_tf <= VidyaMomentum + 1)
      return(src);
   
   double momentum = 0.0;
   double sumPos   = 0.0;
   double sumNeg   = 0.0;
   
   //--- Calculate momentum sums using HLTimeFrame close prices
   for(int j = 0; j < VidyaMomentum; j++)
   {
      int idx1 = tfShift + j;
      int idx2 = idx1 + 1;
      if(idx2 >= bars_tf) break;
      
      double c1 = iClose(NULL, HLTimeFrame, idx1);
      double c2 = iClose(NULL, HLTimeFrame, idx2);
      momentum = c1 - c2;
      
      if(momentum >= 0.0)
         sumPos += momentum;
      else
         sumNeg -= momentum;  // Sum of absolute negatives
   }
   
   //--- Calculate CMO (Chande Momentum Oscillator)
   double absCMO = 0.0;
   if(sumPos + sumNeg != 0.0)
      absCMO = MathAbs(100.0 * (sumPos - sumNeg) / (sumPos + sumNeg));
   
   //--- Calculate alpha
   double alpha = 2.0 / (VidyaLength + 1);
   
   //--- Handle VIDYA state: only update when TF shift changes
   //    This prevents contamination when multiple chart bars map to same TF bar
   if(tfShift != g_lastTFShift)
   {
      // New TF bar - update VIDYA
      if(tfShift >= bars_tf - 1 || g_lastTFShift == -1)
      {
         // At oldest bar or first calculation - initialize
         g_prevVidya = src;
      }
      
      double currentVidya = alpha * absCMO / 100.0 * src 
                          + (1.0 - alpha * absCMO / 100.0) * g_prevVidya;
      g_prevVidya = currentVidya;
      g_lastTFShift = tfShift;
      
      //--- Apply SMA smoothing (kept for compatibility with original)
      double smaSum   = 0.0;
      int    smaCount = 0;
      for(int j = 0; j < 15 && (tfShift + j) < bars_tf; j++)
      {
         smaSum += currentVidya;
         smaCount++;
      }
      
      return (smaCount > 0) ? smaSum / smaCount : currentVidya;
   }
   else
   {
      // Same TF bar as before - return cached value
      return g_prevVidya;
   }
}
//+------------------------------------------------------------------+
//| Calculate ATR (MTF-aware)                                        |
//+------------------------------------------------------------------+
double CalculateATR(int tfShift, int period)
{
   int bars_tf = iBars(NULL, HLTimeFrame);
   if(bars_tf <= period + 1)
      return(0.0);
   
   double atr   = 0.0;
   int    count = 0;
   
   for(int j = 0; j < period; j++)
   {
      int idx  = tfShift + j;
      int idx1 = idx + 1;
      if(idx1 >= bars_tf) break;
      
      double h = iHigh(NULL, HLTimeFrame, idx);
      double l = iLow(NULL, HLTimeFrame, idx);
      double c = iClose(NULL, HLTimeFrame, idx1);
      
      double tr = MathMax(h - l, MathMax(MathAbs(h - c), MathAbs(l - c)));
      atr += tr;
      count++;
   }
   
   return (count > 0) ? atr / count : 0.0;
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
{
   int limit;
   
   //--- Initial setup or full recalculation
   if(prev_calculated == 0)
   {
      limit = rates_total - 1;
      vidyaValue      = 0.0;
      isTrendUp       = false;
      upTrendVolume   = 0.0;
      downTrendVolume = 0.0;
      g_lastTFShift   = -1;   // Reset VIDYA state tracking
      g_prevVidya     = 0.0;
      
      //--- Initialize buffers with EMPTY_VALUE
      ArrayInitialize(VidyaUpBuffer, EMPTY_VALUE);
      ArrayInitialize(VidyaDownBuffer, EMPTY_VALUE);
      ArrayInitialize(ExtraLineUpBuffer, EMPTY_VALUE);
      ArrayInitialize(ExtraLineDownBuffer, EMPTY_VALUE);
      ArrayInitialize(TakeProfitUpBuffer, EMPTY_VALUE);
      ArrayInitialize(TakeProfitDownBuffer, EMPTY_VALUE);
      ArrayInitialize(BuyArrowBuffer, EMPTY_VALUE);
      ArrayInitialize(SellArrowBuffer, EMPTY_VALUE);
      
      //--- Reset signal tracking
      priceTouchedDown = false;
      priceTouchedUp   = false;
      touchBarDown     = -1;
      touchBarUp       = -1;
   }
   else
   {
      // Only recalc new bars + safety margin
      limit = rates_total - prev_calculated + 1;
   }
   
   //--- Apply History / MAX restriction (like reference indicator)
   int max_needed_bars = History + MAX * 2;
   if(limit > max_needed_bars)
      limit = max_needed_bars;
   
   // Safety bounds check
   if(limit > rates_total - 2)
      limit = rates_total - 2;
   if(limit < 0) 
      limit = 0;
   
   //--- Check if HLTimeFrame data is available
   int bars_tf = iBars(NULL, HLTimeFrame);
   if(bars_tf <= MAX)
   {
      Print("VIDYA: Insufficient bars on ", stringMTF((int)HLTimeFrame), 
            " timeframe. Need ", MAX, ", have ", bars_tf);
      return(prev_calculated);
   }
   
   //--- Main calculation loop (from oldest to newest within limit)
   for(int i = limit; i >= 0; i--)
   {
      //--- Map chart bar time to HLTimeFrame bar
      int tfShift = iBarShift(NULL, HLTimeFrame, time[i], false);
      
      if(tfShift < 0 || tfShift >= bars_tf - MAX)
      {
         // No valid TF bar or insufficient history - clear buffers
         VidyaUpBuffer[i]        = EMPTY_VALUE;
         VidyaDownBuffer[i]      = EMPTY_VALUE;
         ExtraLineUpBuffer[i]    = EMPTY_VALUE;
         ExtraLineDownBuffer[i]  = EMPTY_VALUE;
         TakeProfitUpBuffer[i]   = EMPTY_VALUE;
         TakeProfitDownBuffer[i] = EMPTY_VALUE;
         continue;
      }
      
      //--- Get source price from HLTimeFrame
      double src = iClose(NULL, HLTimeFrame, tfShift);
      
      //--- Calculate VIDYA on HLTimeFrame
      double vidya = CalculateVIDYA(tfShift, src);
      
      //--- Calculate ATR on HLTimeFrame
      double atr = CalculateATR(tfShift, 200);
      
      if(atr == 0.0)
      {
         // ATR not available yet - clear buffers
         VidyaUpBuffer[i]        = EMPTY_VALUE;
         VidyaDownBuffer[i]      = EMPTY_VALUE;
         ExtraLineUpBuffer[i]    = EMPTY_VALUE;
         ExtraLineDownBuffer[i]  = EMPTY_VALUE;
         TakeProfitUpBuffer[i]   = EMPTY_VALUE;
         TakeProfitDownBuffer[i] = EMPTY_VALUE;
         continue;
      }
      
      //--- Calculate bands
      double upperBand = vidya + atr * BandDistance;
      double lowerBand = vidya - atr * BandDistance;
      
      //--- Calculate extra line bands (stop loss levels)
      double extraUpperBand = vidya + atr * ExtraLineMultiplier;
      double extraLowerBand = vidya - atr * ExtraLineMultiplier;
      
      //--- Calculate take profit bands
      double tpUpperBand = vidya + atr * TakeProfitMultiplier;
      double tpLowerBand = vidya - atr * TakeProfitMultiplier;
      
      //--- Detect trend using HLTimeFrame data (aligned with VIDYA/ATR)
      bool prevTrendUp = isTrendUp;
      
      // Get current and previous close from HLTimeFrame for trend detection
      double tfClose     = iClose(NULL, HLTimeFrame, tfShift);
      double tfClosePrev = (tfShift + 1 < bars_tf) ? iClose(NULL, HLTimeFrame, tfShift + 1) : tfClose;
      
      if(tfShift < bars_tf - 1)
      {
         if(tfClose > upperBand && tfClosePrev <= upperBand)
            isTrendUp = true;
         if(tfClose < lowerBand && tfClosePrev >= lowerBand)
            isTrendUp = false;
      }
      
      //--- Set smoothed value based on trend
      if(isTrendUp)
         smoothedValue = lowerBand;
      else
         smoothedValue = upperBand;
      
      //--- Set extra line value (same side as main line - stop loss)
      double extraLineValue;
      if(isTrendUp)
         extraLineValue = extraLowerBand;
      else
         extraLineValue = extraUpperBand;
      
      //--- Set take profit value (opposite side of main line)
      double tpValue;
      if(isTrendUp)
         tpValue = tpUpperBand;   // TP above for uptrend
      else
         tpValue = tpLowerBand;   // TP below for downtrend
      
      //--- Trend change detection
      bool trendChanged = false;
      if(prevTrendUp != isTrendUp)
      {
         lastTrendBar = i;
         trendChanged = true;
      }
      
      //--- Assign to appropriate buffer based on trend
      if(isTrendUp)
      {
         VidyaUpBuffer[i]        = smoothedValue;
         VidyaDownBuffer[i]      = EMPTY_VALUE;
         ExtraLineUpBuffer[i]    = extraLineValue;
         ExtraLineDownBuffer[i]  = EMPTY_VALUE;
         TakeProfitUpBuffer[i]   = tpValue;
         TakeProfitDownBuffer[i] = EMPTY_VALUE;
         
         // Connect to previous downtrend line at transition point
         if(trendChanged && i < rates_total - 1)
         {
            VidyaDownBuffer[i]      = smoothedValue;
            ExtraLineDownBuffer[i]  = extraLineValue;
            TakeProfitDownBuffer[i] = tpValue;
         }
      }
      else
      {
         VidyaUpBuffer[i]        = EMPTY_VALUE;
         VidyaDownBuffer[i]      = smoothedValue;
         ExtraLineUpBuffer[i]    = EMPTY_VALUE;
         ExtraLineDownBuffer[i]  = extraLineValue;
         TakeProfitUpBuffer[i]   = EMPTY_VALUE;
         TakeProfitDownBuffer[i] = tpValue;
         
         // Connect to previous uptrend line at transition point
         if(trendChanged && i < rates_total - 1)
         {
            VidyaUpBuffer[i]       = smoothedValue;
            ExtraLineUpBuffer[i]   = extraLineValue;
            TakeProfitUpBuffer[i]  = tpValue;
         }
      }
   }
   
   //--- Calculate volume for current trend (from lastTrendBar to current bar)
   //    Note: Volume stays on chart timeframe for practical relevance
   upTrendVolume   = 0.0;
   downTrendVolume = 0.0;
   
   int volLimit = MathMin(lastTrendBar, rates_total - 1);
   for(int i = volLimit; i >= 0; i--)
   {
      if(close[i] > open[i])
         upTrendVolume += (double)volume[i];
      else if(close[i] < open[i])
         downTrendVolume += (double)volume[i];
   }
   
   //--- Detect signals on confirmed bars (not current bar)
   //    Note: Signal detection uses chart TF price action touching HLTimeFrame levels
   int signalLimit = MathMin(limit, rates_total - 3);
   for(int i = signalLimit; i >= 1; i--)
   {
      BuyArrowBuffer[i]  = EMPTY_VALUE;
      SellArrowBuffer[i] = EMPTY_VALUE;
      
      //--- Get VIDYA line values at this bar
      double vidyaLineDown = (VidyaDownBuffer[i] != EMPTY_VALUE) ? VidyaDownBuffer[i] : VidyaUpBuffer[i];
      double vidyaLineUp   = (VidyaUpBuffer[i] != EMPTY_VALUE)   ? VidyaUpBuffer[i]   : VidyaDownBuffer[i];
      
      if(vidyaLineDown == EMPTY_VALUE || vidyaLineUp == EMPTY_VALUE) continue;
      
      //--- Check for BUY signal (price touches support line, then bullish close)
      bool bar1TouchedDown = (low[i+1] <= vidyaLineDown * 1.0001);
      bool bar0Bullish     = (close[i] > open[i]);
      
      if(bar1TouchedDown && bar0Bullish && isTrendUp)
      {
         BuyArrowBuffer[i] = low[i] - (high[i] - low[i]) * 0.5;
      }
      
      //--- Check for SELL signal (price touches resistance line, then bearish close)
      bool bar1TouchedUp = (high[i+1] >= vidyaLineUp * 0.9999);
      bool bar0Bearish   = (close[i] < open[i]);
      
      if(bar1TouchedUp && bar0Bearish && !isTrendUp)
      {
         SellArrowBuffer[i] = high[i] + (high[i] - low[i]) * 0.5;
      }
   }
   
   //--- Display information on chart
   DisplayInfo();
   
   return(rates_total);
}
//+------------------------------------------------------------------+
//| Display volume and indicator information                         |
//+------------------------------------------------------------------+
void DisplayInfo()
{
   //--- Create background box
   string bgName = "VIDYA_Background";
   ObjectDelete(0, bgName);
   
   int corner = CORNER_LEFT_UPPER;
   int x_pos  = 10;
   int y_pos  = 20;
   int width  = 280;
   int height = 130;
   
   ObjectCreate(0, bgName, OBJ_RECTANGLE_LABEL, 0, 0, 0);
   ObjectSetInteger(0, bgName, OBJPROP_CORNER, corner);
   ObjectSetInteger(0, bgName, OBJPROP_XDISTANCE, x_pos);
   ObjectSetInteger(0, bgName, OBJPROP_YDISTANCE, y_pos);
   ObjectSetInteger(0, bgName, OBJPROP_XSIZE, width);
   ObjectSetInteger(0, bgName, OBJPROP_YSIZE, height);
   ObjectSetInteger(0, bgName, OBJPROP_BGCOLOR, clrBlack);
   ObjectSetInteger(0, bgName, OBJPROP_BORDER_TYPE, BORDER_FLAT);
   ObjectSetInteger(0, bgName, OBJPROP_COLOR, clrWhite);
   ObjectSetInteger(0, bgName, OBJPROP_WIDTH, 1);
   ObjectSetInteger(0, bgName, OBJPROP_BACK, true);
   ObjectSetInteger(0, bgName, OBJPROP_SELECTABLE, false);
   
   //--- Calculate total volume
   double totalVolume = upTrendVolume + downTrendVolume;
   
   //--- Calculate percentages
   double buyPercent  = 0.0;
   double sellPercent = 0.0;
   
   if(totalVolume > 0)
   {
      buyPercent  = (upTrendVolume / totalVolume) * 100.0;
      sellPercent = (downTrendVolume / totalVolume) * 100.0;
   }
   
   //--- Calculate delta volume
   double deltaVolume  = upTrendVolume - downTrendVolume;
   double deltaPercent = 0.0;
   
   if(totalVolume > 0)
      deltaPercent = (deltaVolume / totalVolume) * 100.0;
   
   //--- Determine strength indicator
   string strength      = "";
   color  strengthColor = clrWhite;
   if(MathAbs(deltaPercent) >= 60)
   {
      strength      = "[STRONG]";
      strengthColor = deltaPercent > 0 ? UpColor : DownColor;
   }
   else if(MathAbs(deltaPercent) >= 40)
   {
      strength      = "[MODERATE]";
      strengthColor = clrYellow;
   }
   else
   {
      strength      = "[WEAK]";
      strengthColor = clrGray;
   }
   
   //--- Format volume strings
   string buyVol   = DoubleToString(upTrendVolume, 0);
   string sellVol  = DoubleToString(downTrendVolume, 0);
   string totalVol = DoubleToString(totalVolume, 0);
   
   //--- Get TF string for display
   string tfStr = stringMTF((int)HLTimeFrame);
   
   //--- Create text labels
   CreateLabel("VIDYA_Title", "VOLUME ANALYSIS [" + tfStr + "]", x_pos + 10, y_pos + 5, 10, clrWhite, corner, true);
   
   CreateLabel("VIDYA_History", "History: " + IntegerToString(History) + " bars", 
               x_pos + 10, y_pos + 25, 8, clrSilver, corner, false);
   
   CreateLabel("VIDYA_Buy", "Buy:  " + buyVol + " (" + DoubleToString(buyPercent, 1) + "%)", 
               x_pos + 10, y_pos + 45, 9, UpColor, corner, false);
   
   CreateLabel("VIDYA_Sell", "Sell: " + sellVol + " (" + DoubleToString(sellPercent, 1) + "%)", 
               x_pos + 10, y_pos + 65, 9, DownColor, corner, false);
   
   CreateLabel("VIDYA_Total", "Total: " + totalVol, 
               x_pos + 10, y_pos + 85, 9, clrWhite, corner, false);
   
   CreateLabel("VIDYA_Delta", "Delta: " + DoubleToString(deltaPercent, 1) + "% " + strength, 
               x_pos + 10, y_pos + 105, 9, strengthColor, corner, true);
   
   //--- Create trend symbol
   string symbolName = "VIDYA_Symbol";
   ObjectDelete(0, symbolName);
   ObjectCreate(0, symbolName, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, symbolName, OBJPROP_CORNER, corner);
   ObjectSetInteger(0, symbolName, OBJPROP_XDISTANCE, x_pos + width - 30);
   ObjectSetInteger(0, symbolName, OBJPROP_YDISTANCE, y_pos + 5);
   ObjectSetString(0, symbolName, OBJPROP_TEXT, isTrendUp ? "▲" : "▼");
   ObjectSetInteger(0, symbolName, OBJPROP_COLOR, isTrendUp ? UpColor : DownColor);
   ObjectSetInteger(0, symbolName, OBJPROP_FONTSIZE, 16);
   ObjectSetInteger(0, symbolName, OBJPROP_SELECTABLE, false);
   
   ChartRedraw();
}
//+------------------------------------------------------------------+
//| Create Label Helper Function                                     |
//+------------------------------------------------------------------+
void CreateLabel(string name, string text, int x, int y, int fontsize, color clr, int corner, bool bold = false)
{
   ObjectDelete(0, name);
   ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, name, OBJPROP_CORNER, corner);
   ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x);
   ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y);
   ObjectSetString(0, name, OBJPROP_TEXT, text);
   ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
   ObjectSetInteger(0, name, OBJPROP_FONTSIZE, fontsize);
   if(bold)
      ObjectSetString(0, name, OBJPROP_FONT, "Arial Bold");
   ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false);
}
//+------------------------------------------------------------------+
//| Deinitialize function                                            |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   //--- Delete all objects created by indicator
   ObjectDelete(0, "VIDYA_Background");
   ObjectDelete(0, "VIDYA_Title");
   ObjectDelete(0, "VIDYA_History");
   ObjectDelete(0, "VIDYA_Buy");
   ObjectDelete(0, "VIDYA_Sell");
   ObjectDelete(0, "VIDYA_Total");
   ObjectDelete(0, "VIDYA_Delta");
   ObjectDelete(0, "VIDYA_Symbol");
   
   //--- Delete all liquidity lines
   for(int i = ObjectsTotal() - 1; i >= 0; i--)
   {
      string name = ObjectName(i);
      if(StringFind(name, "VIDYA_Line_") >= 0)
         ObjectDelete(0, name);
   }
   
   ChartRedraw();
}
//+------------------------------------------------------------------+

+------------------------------------------------------------------+

 /*====================================================================
  CHANGELOG: Decycler Oscillator
  Version:   2.0.0
  Updated:   2025-12-08
  Author:    mladen (original), MwlRCT (modified)
  Platform:  MT4
======================================================================
  [2.0.0] - 2025-12-08
  + Added: Alert system with 4 notification types (Popup, Sound, Email, Push)
  + Added: SoundFile parameter (default: "alert2.wav")
  + Added: ALERTBAR parameter for signal bar selection
  + Added: AlertsMessage, AlertsSound, AlertsEmail, AlertsMobile toggles
  + Added: BUY arrow buffer (index 4) on bullish trend change
  + Added: SELL arrow buffer (index 5) on bearish trend change
  + Added: Global alert counters (altUP, altDN) for single-fire logic
  + Added: TimeBar tracker to prevent duplicate alerts per bar
  + Added: MAX_BARS constant (1440) for calculation limit
  * Changed: Indicator buffers from 4 to 6
  * Changed: Default Price from pr_close to pr_haaverage
  * Changed: Indicator colors scheme (Aqua/Yellow/Lime/Red)
  * Changed: cos()/sin() to MathCos()/MathSin() for strict mode
  
  [1.0.0] - Original
  + Initial release by mladen, forex-tsd
======================================================================*/

```### :warning: Critical EA Integration Update
**Indicator Buffers Increased: 4 → 6**
We have expanded the buffer count to create dedicated "Plug-and-Play" signal channels for Expert Advisors. You no longer need to calculate crossovers manually.
**How to use in your EA:**
- **Buffer 4**: BUY Signal (Bullish Arrow)
- **Buffer 5**: SELL Signal (Bearish Arrow)
**Code Example:**
```cpp
// Check for BUY signal on previous bar (shift 1)
double buySignal = iCustom(NULL, 0, "Decycler", ..., 4, 1);
// Check for SELL signal on previous bar (shift 1)
double sellSignal = iCustom(NULL, 0, "Decycler", ..., 5, 1);
if(buySignal > 0) {
   // Open Buy Order
}
if(sellSignal > 0) {
   // Open Sell Order
}

https://www.tradingview.com/script/F2vJnCdI-Ghost-Tangent-Crossings-ChartPrime/

/*====================================================================
  CHANGELOG: Ghost_Tangent_Crossings
  Version:   1.01
  Updated:   2025-06-08
  Author:    Mario Jemic
  Optimizer: MwlRCT
  Platform:  MT4
======================================================================
  [1.01] - 2025-06-08 (Performance Optimization by MwlRCT)
  
  CRITICAL FIXES:
  + Added: Early exit guard if(rates_total < 50)
  + Added: MAX_BREAK_ITERATIONS (1440) to prevent infinite loop freeze
  - Removed: ClearByPrefix() from OnCalculate main body
  - Removed: ResetObjectState() from OnCalculate main body
  
  MEMORY OPTIMIZATION:
  + Added: Pre-allocated s_ghostMax[2000] / s_ghostMin[512] static arrays
  + Added: Static buffers for chronoTime/hiChron/loChron/etc.
  * Changed: ArrayResize with reserve capacity in PushName()
  - Removed: ArrayResize inside ghost processing loops
  
  INCREMENTAL PROCESSING:
  + Added: Static datetime g_lastBarTime for new bar detection
  + Added: Static persistent state (g_ph, g_pl, g_polarityState, etc.)
  + Added: Smart limit using prev_calculated for incremental calc
  + Added: MAX_BARS_PROCESS (1440) cap per tick
  
  OBJECT MANAGEMENT:
  + Added: Object existence check via ObjectFind before creation
  + Added: Object pooling - ObjectMove instead of delete/create cycle
  + Added: TrimObjectArrays() for batch cleanup
  + Added: ChartRedraw() throttling via tick counter modulo
  * Changed: RemoveFirstDirect() - direct deletion without iteration
  * Changed: ClearNamesDirect() - direct pattern-based deletion
  * Changed: Object cleanup moved to OnDeinit only
  
  [1.00] - 2025
  + Initial release by Mario Jemic
  + Repository: https://fxcodebase.com/code/viewtopic.php?f=38&p=161191
======================================================================*/

Quoting MwlRCT

Disliked

{image} From this post: https://www.forexfactory.com/thread/...7#post15497537 --- {image} --- ChangeLog. /*==================================================================== CHANGELOG: Decycler Oscillator Version: 2.0.0 Updated: 2025-12-08 Author: mladen (original), MwlRCT (modified) Platform: MT4 ====================================================================== [2.0.0] - 2025-12-08 + Added: Alert system with 4 notification types (Popup, Sound, Email, Push) + Added: SoundFile parameter (default: "alert2.wav") + Added:...

Ignored

US100- M1
BUY

Am About to Merge the logic of this two Indicator, to have single Dot/Arrow on Chart
 
when signal from both match/align

Quoting MwlRCT

Disliked

{image} From this post: https://www.forexfactory.com/thread/...7#post15497537 --- {image} --- ChangeLog. /*==================================================================== CHANGELOG: Decycler Oscillator Version: 2.0.0 Updated: 2025-12-08 Author: mladen (original), MwlRCT (modified) Platform: MT4 ====================================================================== [2.0.0] - 2025-12-08 + Added: Alert system with 4 notification types (Popup, Sound, Email, Push) + Added: SoundFile parameter (default: "alert2.wav") + Added:...

Ignored

Quoting FXreversal

Disliked

Hello, I saw an indicator on Forex Factory and I really like this version – even though there are newer updates, this one's my favorite. The problem is, check the image I uploaded: only the red bars go past level 11 and trigger buy signals. The aqua bars never cross level 11, so no sell signals at all. This indicator only gives signals when it breaks level 11 on the line, but right now it's just all red bars and buys only. I don't know what's wrong with the code. Can you help fix it? I love the current settings. Hope you can assist. Thanks! {image}...

Ignored

Quoting FXreversal

Disliked

Hello, I saw an indicator on Forex Factory and I really like this version – even though there are newer updates, this one's my favorite. The problem is, check the image I uploaded: only the red bars go past level 11 and trigger buy signals. The aqua bars never cross level 11, so no sell signals at all. This indicator only gives signals when it breaks level 11 on the line, but right now it's just all red bars and buys only. I don't know what's wrong with the code. Can you help fix it? I love the current settings. Hope you can assist. Thanks! {image}...

Ignored

======================================================================
  TECHNICAL SUMMARY:
  ------------------
  File:      start() function, inner for-loop
  Location:  if(hnw > hpres) block (~line 206)
  Before:    sbl = sbl + ii*cle;
  After:     sbl = sbl + (100.0 - ii)*cle;
  
  Root Cause: Raw RSI is ~25-30 in downtrends vs ~70-75 in uptrends
  Solution:   Inverse RSI (100-RSI) normalizes bearish weighting
======================================================================

Quoting MwlRCT

Disliked

{quote} ====================================================================== TECHNICAL SUMMARY: ------------------ File: start() function, inner for-loop Location: if(hnw > hpres) block (~line 206) Before: sbl = sbl + ii*cle; After: sbl = sbl + (100.0 - ii)*cle; Root Cause: Raw RSI is ~25-30 in downtrends vs ~70-75 in uptrends Solution: Inverse RSI (100-RSI) normalizes bearish weighting ====================================================================== Download:{file} Image: {image}

Ignored

Quoting kingrein

Disliked

Hi @MwlRCT, could you please add an alert to this indicator whenever the yellow line goes above or below the zero line level? Thanks a lot! {image} {file}

Ignored

//--- Arrow Settings
extern int    ARROWBAR      = 0;        // Bar index for arrow placement (0=current bar)
extern color  ArrowUP       = clrAqua;  // Bullish arrow color
extern color  ArrowDN       = clrYellow;// Bearish arrow color
extern int    ArrCodUP      = 158;      // Wingding code for bullish arrow
extern int    ArrCodDN      = 158;      // Wingding code for bearish arrow
extern int    ArrSize       = 3;        // Arrow size
//--- Alert Settings
extern int    SIGNALBAR     = 0;        // Bar index for alert trigger (1=closed bar)
extern bool   AlertsMessage = false;    // Enable popup alert
extern bool   AlertsSound   = true;     // Enable sound alert
extern bool   AlertsEmail   = false;    // Enable email alert
extern bool   AlertsMobile  = false;    // Enable push notification
extern string SoundFile     = "alert2.wav"; // Sound file name

Quoting MwlRCT

Disliked

{quote}{image} //--- Arrow Settings extern int ARROWBAR = 0; // Bar index for arrow placement (0=current bar) extern color ArrowUP = clrAqua; // Bullish arrow color extern color ArrowDN = clrYellow;// Bearish arrow color extern int ArrCodUP = 158; // Wingding code for bullish arrow extern int ArrCodDN = 158; // Wingding code for bearish arrow extern int ArrSize = 3; // Arrow size //--- Alert Settings extern int SIGNALBAR = 0; // Bar index for alert trigger (1=closed bar) extern bool AlertsMessage = false; // Enable popup alert extern bool AlertsSound...

Ignored

Quoting MwlRCT

Disliked

{quote}{image} //--- Arrow Settings extern int ARROWBAR = 0; // Bar index for arrow placement (0=current bar) extern color ArrowUP = clrAqua; // Bullish arrow color extern color ArrowDN = clrYellow;// Bearish arrow color extern int ArrCodUP = 158; // Wingding code for bullish arrow extern int ArrCodDN = 158; // Wingding code for bearish arrow extern int ArrSize = 3; // Arrow size //--- Alert Settings extern int SIGNALBAR = 0; // Bar index for alert trigger (1=closed bar) extern bool AlertsMessage = false; // Enable popup alert extern bool AlertsSound...

Ignored

Quoting kingrein

Disliked

{quote} thanks again for adding the alerts to my indicator—it seems good to me! Could you please turn it into a simple EA? Buy when above zero line, sell when below, with SL pips as input and lot size (I'll set it). Thank you!

Ignored