I will code your EAs and Indicators for no charge

Quoting aqzhd

Disliked

Sincerely thank you for your reply and the two sets of indicators you wrote!!! These two sets of indicators encounter the same problem, that is, the indicator's bar chart will not be displayed when the candlestick chart reaches the end. In other words, there is a blank area on the screen, the indicator cannot be displayed, and the indicator data will still appear. (As shown in the figure) The upper and lower indicators on the chart are all single-period indicators, but the writing methods are different. The top indicator can fully display the indicator...

Ignored

Quoting mntiwana

Disliked

{quote} Incluso una pequeña adición a "BestTraderEv": nadie puede ni debe dar sugerencias, consejos ni recomendaciones sobre ninguna configuración de código. Esto significa que es responsable y cuestionable por cualquier pérdida que el usuario pueda sufrir tras sus palabras, ya que la razón o la realidad es que el mercado nunca sigue ningún indicador, sino que todos los indicadores siempre siguen el precio (línea de precio), por lo que los llamados indicadores predictivos siempre son engañosos y simplemente suponen.

Ignored

Quoting BestTraderEv

Disliked

{quote} I have no idea what you're talking about? As far as I'm concerrned the indicators are woking properly and updating on current bar properly, as well. You need to show me the logs, otherwise I don't know what you're talking about. I am not encouteriing any errors at all. If you don't see anything, it most likely means that MT5 hasn't downloaded the data, so you need to switch TFs a few times, maybe? If the instrument doesn't have enough data to calculate all the MAs of the oscillator, then the indicator can't plot any histogram. And this indicator...

Ignored

Quoting BestTraderEv

Disliked

{quote} I got what you were talking about! It's not "scaling" but "zooming". {file} {image}

Ignored

Quoting BestTraderEv

Disliked

{quote} It's not "scaling"!!! You are ZOOMING in and out. And I noticed a funny thing when max zoomed out: there is nothing, but when we move the mouse wheel, the picture comes back. But, also that doesn't always happen! I have no idea if that can be fixed or how to fix that??? It seems to be a flaw of MT5 itself, not the indicator. These two are the final: {file}{file} You have the source codes. Some better coder can make it better, if possible. {image} {image}

Ignored

Quoting aqzhd

Disliked

{quote} Dear Mr. BestTraderEv, good evening! I am very sorry to bother you. The Multi Oscillator (Final Corrected Version) indicator may still have some problems. Through testing, it is found that the indicator does not work properly. The indicator value and the bar chart cannot be displayed normally after a period of time. (As shown in the picture: inside the box) Best regards, good night!{image}

Ignored

Quoting rizco98

Disliked

need help to fix these error tq {file} {image}

Ignored

 //+------------------------------------------------------------------+
//|                                               SNR Dynamic V3.mq4 |
//|                                     Copyright 2025, Nazrul Islam |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Converted from TradingView Pine - Enhanced Version"
#property link      "https://www.tradingview.com/"
#property version   "4.00"
#property strict
#property indicator_chart_window
#property indicator_buffers 2
// Define indicator buffers
double PivotHighBuffer[];
double PivotLowBuffer[];
// Input parameters - General Settings
extern int PivotPeriod = 10;              // Pivot Period
extern string SourceType = "High/Low";     // Source (High/Low or Close/Open)
extern int MaxPivotPoints = 20;           // Maximum Number of Pivot Points
extern int ChannelWidth = 10;             // Maximum Channel Width %
extern int MaxSRLevels = 5;               // Maximum Number of S/R Levels
extern int MinStrength = 2;               // Minimum Strength for S/R Levels
// Input parameters - Visual Settings
extern int LabelLocation = 20;            // Label Location (bars from right)
extern string LineStyle = "Dashed";       // Line Style (Solid, Dashed, Dotted)
extern int LineWidth = 2;                 // Line Width
extern color ResistanceColor = clrRed;    // Resistance Color
extern color SupportColor = clrLime;      // Support Color
extern color ResistanceLabelColor = clrWhite;  // Resistance Label Text Color
extern color SupportLabelColor = clrBlack;     // Support Label Text Color
extern bool ShowPivotPoints = false;      // Show Pivot Points
extern bool ShowSRZones = false;          // Show S/R as Zones (not just lines)
extern color ResistanceZoneColor = clrLightPink; // Resistance Zone Color (Fixed)
extern color SupportZoneColor = clrLightGreen;    // Support Zone Color (Fixed)
extern int ZoneTransparency = 230;        // Zone Transparency (0-255, higher = more transparent)
// Input parameters - Multi-timeframe Settings
extern bool UseMultiTimeframe = false;    // Use Multiple Timeframes
extern int MTFHTF = PERIOD_D1;            // Higher Timeframe
extern color HTFResistanceColor = clrOrange; // HTF Resistance Color
extern color HTFSupportColor = clrAqua;   // HTF Support Color
// Input parameters - Alert Settings
extern bool EnableAlerts = false;         // Enable Alerts
extern bool EnableEmailAlerts = false;    // Send Email Alerts
extern bool EnablePushAlerts = false;     // Send Push Notifications
extern bool AlertOnCrossover = true;      // Alert on S/R Crossover
extern bool AlertOnApproach = false;      // Alert when Price Approaches S/R
extern int ApproachDistance = 10;         // Distance to S/R for Approach Alert (in points)
// Input parameters - Advanced Settings
extern bool PersistentLevels = true;      // Keep S/R Levels on Chart Scroll
extern int MinimumBarsConfirmation = 1;   // Minimum Bars to Confirm Pivot (Anti-Repaint)
extern int HistoryLength = 500;           // Number of Bars to Analyze
extern bool ShowHistoricalBreakouts = false; // Mark Historical Breakouts
extern int BreakoutConfirmBars = 3;       // Bars to Confirm Breakout
extern bool UseTrendFilter = false;       // Apply Trend Filter
extern int TrendPeriod = 50;              // Trend Detection Period
// Circular buffer for storing pivots
struct PivotPoint {
   datetime time;
   double price;
   bool isHigh;
   int strength;
   bool confirmed;
};
// S/R Level structure
struct SRLevel {
   double upperBound;
   double lowerBound;
   double midPoint;
   int strength;
   bool isResistance;
   datetime firstTouch;
   datetime lastTouch;
   int touchCount;
   int breakoutCount;
   bool fromHigherTF;
};
// Arrays to store pivot values and S/R levels
PivotPoint pivots[];
SRLevel srLevels[];
SRLevel htfSRLevels[];
// Object name arrays for lines, zones, and labels
string srLines[];
string srZones[];
string srLabels[];
string pivotMarkers[];
string breakoutMarkers[];
// Global variables
double channelWidthValue;
int lastCalculatedBar = 0;
bool levelsCached = false;
datetime lastAlert = 0;
int trend = 0; // 1 = up, -1 = down, 0 = neutral
// For performance optimization
int updateCounter = 0;
int updateFrequency = 10; // Update SR levels every 10 ticks
// Helper function for transparency
color ColorChangeAlpha(color clr, int alpha) {
   int r = (clr & 0xFF0000) >> 16;
   int g = (clr & 0x00FF00) >> 8;
   int b = (clr & 0x0000FF);
   // Note: MQL4 doesn't directly support alpha in C'...' string format this way.
   // Standard ARGB format is 0xAARRGGBB or use SetInteger(handle, OBJPROP_BGCOLOR, ...) if background drawing.
   // For transparency on OBJ_RECTANGLE, setting OBJPROP_BACK to true and using a standard color often works well.
   // Let's assume the original intent was just to use the base color. The alpha parameter isn't standard here.
   // Returning the original color for safety. Proper transparency needs OBJPROP_BACK=true.
   return(clr);
}
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
   // Validate inputs
   if(PivotPeriod < 2) {
      Alert("Pivot Period must be at least 2");
      return(INIT_PARAMETERS_INCORRECT);
   }
   
   if(MaxPivotPoints < 5) {
      Alert("Maximum Pivot Points should be at least 5");
      return(INIT_PARAMETERS_INCORRECT);
   }
   
   if(ChannelWidth <= 0 || ChannelWidth > 50) {
      Alert("Channel Width should be between 1 and 50");
      return(INIT_PARAMETERS_INCORRECT);
   }
   // Initialize buffers
   SetIndexBuffer(0, PivotHighBuffer);
   SetIndexBuffer(1, PivotLowBuffer);
   
   SetIndexStyle(0, DRAW_ARROW, EMPTY, 1, clrRed);
   SetIndexArrow(0, 119); // Up arrow
   SetIndexStyle(1, DRAW_ARROW, EMPTY, 1, clrLime);
   SetIndexArrow(1, 119); // Down arrow
   
   SetIndexEmptyValue(0, 0.0);
   SetIndexEmptyValue(1, 0.0);
   
   SetIndexLabel(0, "Pivot High");
   SetIndexLabel(1, "Pivot Low");
   
   // Initialize arrays with dynamic size
   ArrayResize(pivots, MaxPivotPoints);
   ArrayResize(srLevels, MaxSRLevels);
   ArrayResize(htfSRLevels, MaxSRLevels);
   
   // Initialize object name arrays
   ArrayResize(srLines, MaxSRLevels * 2); // Double for HTF
   ArrayResize(srZones, MaxSRLevels * 2);
   ArrayResize(srLabels, MaxSRLevels * 2);
   ArrayResize(pivotMarkers, MaxPivotPoints);
   ArrayResize(breakoutMarkers, MaxSRLevels * 10); // Multiple breakouts per level
   
   // Clear all arrays
   ClearArrays();
   
   // Set indicator name
   IndicatorShortName("SR Dynamic v3");
   
   return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   // Delete all graphical objects
   DeleteAllObjects();
}
//+------------------------------------------------------------------+
//| 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[])
{
   // Skip calculation if not enough bars
   if(rates_total <= PivotPeriod * 2 + MinimumBarsConfirmation)
      return(rates_total);
      
   // Performance optimization - only update SR levels periodically
   updateCounter++;
   bool updateSRLevels = (updateCounter >= updateFrequency);
   if(updateSRLevels) updateCounter = 0;
   
   // Calculate the maximum S/R channel zone width
   int barsToAnalyze = MathMin(HistoryLength, rates_total);
   double highestHigh = High[iHighest(NULL, 0, MODE_HIGH, barsToAnalyze, 0)];
   double lowestLow = Low[iLowest(NULL, 0, MODE_LOW, barsToAnalyze, 0)];
   channelWidthValue = (highestHigh - lowestLow) * ChannelWidth / 100.0;
   
   // Calculate trend if filter is enabled
   if(UseTrendFilter) {
      CalculateTrend(close, TrendPeriod);
   }
   
   // Calculate HTF S/R levels if enabled
   if(UseMultiTimeframe && updateSRLevels) {
      CalculateHTFLevels(time);
   }
   
   // Define calculation range
   int startPos = PivotPeriod * 2 + MinimumBarsConfirmation;
   int endPos = rates_total - 1 - MinimumBarsConfirmation;
   int limit;
   
   // Determine which bars to calculate
   if(prev_calculated > startPos) {
      limit = rates_total - prev_calculated + 5; // Recalculate a few extra bars
   } else {
      limit = barsToAnalyze;
      DeleteAllObjects(); // Clear all objects for full recalculation
   }
   
   limit = MathMin(limit, barsToAnalyze);
   
   // Reset buffers
   for(int i = 0; i < rates_total; i++) {
      PivotHighBuffer[i] = 0;
      PivotLowBuffer[i] = 0;
   }
   
   // Detect pivot points
   for(int i = startPos; i < endPos; i++) {
      // Check if pivot high
      bool isPivotHigh = IsPivotHigh(i, PivotPeriod, SourceType, high, low, open, close);
      if(isPivotHigh && IsConfirmedPivot(i, true, MinimumBarsConfirmation)) {
         PivotHighBuffer[i] = high[i];
         
         if(ShowPivotPoints) {
            CreatePivotMarker(time[i], high[i], true);
         }
         
         // Add to pivots array if updating
         if(updateSRLevels) {
            AddPivotPoint(time[i], GetPivotHigh(i, PivotPeriod, SourceType, high, low, open, close), true);
         }
      }
      
      // Check if pivot low
      bool isPivotLow = IsPivotLow(i, PivotPeriod, SourceType, high, low, open, close);
      if(isPivotLow && IsConfirmedPivot(i, false, MinimumBarsConfirmation)) {
         PivotLowBuffer[i] = low[i];
         
         if(ShowPivotPoints) {
            CreatePivotMarker(time[i], low[i], false);
         }
         
         // Add to pivots array if updating
         if(updateSRLevels) {
            AddPivotPoint(time[i], GetPivotLow(i, PivotPeriod, SourceType, high, low, open, close), false);
         }
      }
   }
   
   // Update S/R levels if needed
   if(updateSRLevels) {
      CalculateSRLevels();
      DrawSRLevels(time);
   }
   
   // Check for alerts
   if(EnableAlerts) {
      CheckAlerts(time[0], close[0], high[0], low[0]);
   }
   
   // Check for historical breakouts if enabled
   if(ShowHistoricalBreakouts && updateSRLevels) {
      MarkHistoricalBreakouts(time, close, BreakoutConfirmBars);
   }
   
   lastCalculatedBar = rates_total;
   return(rates_total);
}
//+------------------------------------------------------------------+
//| Check if there is a confirmed pivot high at the specified bar    |
//+------------------------------------------------------------------+
bool IsConfirmedPivot(int bar, bool isHigh, int confirmBars)
{
   // Need enough bars after pivot for confirmation
   if(bar < confirmBars) return false;
   
   // Basic confirmation (exists) - could add price action checks here
   return true;
}
//+------------------------------------------------------------------+
//| Check if there is a pivot high at the specified bar              |
//+------------------------------------------------------------------+
bool IsPivotHigh(int bar, int period, string sourceType, const double &high[], const double &low[], const double &open[], const double &close[])
{
   if(bar + period >= Bars || bar - period < 0)
      return false;
   double src;
   if(sourceType == "High/Low")
      src = high[bar];
   else
      src = MathMax(close[bar], open[bar]);
   for(int i = 1; i <= period; i++) {
      double leftSrc, rightSrc;
      if(sourceType == "High/Low") {
         leftSrc = high[bar + i];
         rightSrc = high[bar - i];
      }
      else {
         leftSrc = MathMax(close[bar + i], open[bar + i]);
         rightSrc = MathMax(close[bar - i], open[bar - i]);
      }
      if(src <= leftSrc || src <= rightSrc)
         return false;
   }
   return true;
}
//+------------------------------------------------------------------+
//| Check if there is a pivot low at the specified bar               |
//+------------------------------------------------------------------+
bool IsPivotLow(int bar, int period, string sourceType, const double &high[], const double &low[], const double &open[], const double &close[])
{
   if(bar + period >= Bars || bar - period < 0)
      return false;
   double src;
   if(sourceType == "High/Low")
      src = low[bar];
   else
      src = MathMin(close[bar], open[bar]);
   for(int i = 1; i <= period; i++) {
      double leftSrc, rightSrc;
      if(sourceType == "High/Low") {
         leftSrc = low[bar + i];
         rightSrc = low[bar - i];
      }
      else {
         leftSrc = MathMin(close[bar + i], open[bar + i]);
         rightSrc = MathMin(close[bar - i], open[bar - i]);
      }
      if(src >= leftSrc || src >= rightSrc)
         return false;
   }
   return true;
}
//+------------------------------------------------------------------+
//| Get pivot high value at the specified bar                        |
//+------------------------------------------------------------------+
double GetPivotHigh(int bar, int period, string sourceType, const double &high[], const double &low[], const double &open[], const double &close[])
{
   if(sourceType == "High/Low")
      return high[bar];
   else
      return MathMax(close[bar], open[bar]);
}
//+------------------------------------------------------------------+
//| Get pivot low value at the specified bar                         |
//+------------------------------------------------------------------+
double GetPivotLow(int bar, int period, string sourceType, const double &high[], const double &low[], const double &open[], const double &close[])
{
   if(sourceType == "High/Low")
      return low[bar];
   else
      return MathMin(close[bar], open[bar]);
}
//+------------------------------------------------------------------+
//| Add a pivot point to the circular buffer                         |
//+------------------------------------------------------------------+
void AddPivotPoint(datetime time, double price, bool isHigh)
{
   // Shift all elements down by one
   for(int i = ArraySize(pivots) - 1; i > 0; i--) {
      pivots[i] = pivots[i-1];
   }
   
   // Add new pivot at the beginning
   pivots[0].time = time;
   pivots[0].price = price;
   pivots[0].isHigh = isHigh;
   pivots[0].strength = 1;
   pivots[0].confirmed = true;
}
//+------------------------------------------------------------------+
//| Calculate S/R levels based on pivot points                       |
//+------------------------------------------------------------------+
void CalculateSRLevels()
{
   // Clear existing levels
   ArrayResize(srLevels, 0);
   
   // Group pivot points into zones
   for(int i = 0; i < ArraySize(pivots); i++) {
      if(pivots[i].time == 0) continue; // Skip empty slots
      
      double price = pivots[i].price;
      bool isHigh = pivots[i].isHigh;
      
      // Check if price fits within any existing level
      bool foundZone = false;
      for(int j = 0; j < ArraySize(srLevels); j++) {
         if(price >= srLevels[j].lowerBound && price <= srLevels[j].upperBound) {
            // Update existing zone
            srLevels[j].strength++;
            srLevels[j].touchCount++;
            srLevels[j].lastTouch = pivots[i].time;
            // Don't reset isResistance here, keep the original type
            foundZone = true;
            break;
         }
      }
      
      // If no existing zone, create new one
      if(!foundZone) {
         // Apply trend filter if enabled
         if(UseTrendFilter) {
            // Skip resistance in uptrend or support in downtrend if not strong enough
            if((isHigh && trend > 0) || (!isHigh && trend < 0)) {
               if(MinStrength > 1) continue; // Require stronger confirmation in trend direction
            }
         }
         
         // Create new zone
         int size = ArraySize(srLevels);
         ArrayResize(srLevels, size + 1);
         
         srLevels[size].upperBound = price + channelWidthValue/2;
         srLevels[size].lowerBound = price - channelWidthValue/2;
         srLevels[size].midPoint = price;
         srLevels[size].strength = 1;
         srLevels[size].isResistance = isHigh;
         srLevels[size].firstTouch = pivots[i].time;
         srLevels[size].lastTouch = pivots[i].time;
         srLevels[size].touchCount = 1;
         srLevels[size].breakoutCount = 0;
         srLevels[size].fromHigherTF = false;
         
         // Look for other pivots in this zone to increase strength
         for(int k = i + 1; k < ArraySize(pivots); k++) {
            if(pivots[k].time == 0) continue;
            
            double otherPrice = pivots[k].price;
            if(otherPrice >= srLevels[size].lowerBound && otherPrice <= srLevels[size].upperBound) {
               srLevels[size].strength++;
               srLevels[size].touchCount++;
               if(pivots[k].time < srLevels[size].firstTouch) {
                  srLevels[size].firstTouch = pivots[k].time;
               }
               // Adjust midpoint slightly? Or just increase strength? Stick to strength for now.
            }
         }
      }
   }
   
   // Sort levels by strength (bubble sort)
   if(ArraySize(srLevels) > 1) {
       for(int i = 0; i < ArraySize(srLevels); i++) {
          for(int j = 0; j < ArraySize(srLevels) - i - 1; j++) {
             if(srLevels[j].strength < srLevels[j+1].strength) {
                // Swap
                SRLevel temp = srLevels[j];
                srLevels[j] = srLevels[j+1];
                srLevels[j+1] = temp;
             }
          }
       }
   }
   
   // Limit to MaxSRLevels and ensure MinStrength
   int validLevels = 0;
   for(int i = 0; i < ArraySize(srLevels); i++) {
      if(srLevels[i].strength >= MinStrength) {
         validLevels++;
      }
   }
   
   validLevels = MathMin(validLevels, MaxSRLevels);
   
   // Create a new array with only the valid levels to avoid resizing issues during filtering
   SRLevel filteredLevels[];
   ArrayResize(filteredLevels, validLevels);
   int currentFilteredIndex = 0;
   for(int i = 0; i < ArraySize(srLevels) && currentFilteredIndex < validLevels; i++) {
       if(srLevels[i].strength >= MinStrength) {
           filteredLevels[currentFilteredIndex] = srLevels[i];
           currentFilteredIndex++;
       }
   }
   
   // Replace the old srLevels array with the filtered one
   ArrayResize(srLevels, validLevels);
   for(int i = 0; i < validLevels; i++) {
       srLevels[i] = filteredLevels[i];
   }

   // Merge levels that are too close to each other
   for(int i = 0; i < ArraySize(srLevels); i++) {
      for(int j = i + 1; j < ArraySize(srLevels); j++) {
         if(MathAbs(srLevels[i].midPoint - srLevels[j].midPoint) < channelWidthValue) {
            // Merge j into i
            // Weighted average midpoint
            double totalStrength = srLevels[i].strength + srLevels[j].strength;
            if(totalStrength > 0) { // Avoid division by zero
                srLevels[i].midPoint = (srLevels[i].midPoint * srLevels[i].strength +
                                        srLevels[j].midPoint * srLevels[j].strength) / totalStrength;
            } // else keep midpoint i? Or average? Let's keep the weighted avg approach.
            srLevels[i].strength += srLevels[j].strength;
            srLevels[i].touchCount += srLevels[j].touchCount;
            srLevels[i].upperBound = srLevels[i].midPoint + channelWidthValue/2;
            srLevels[i].lowerBound = srLevels[i].midPoint - channelWidthValue/2;
            
            if(srLevels[j].firstTouch < srLevels[i].firstTouch)
               srLevels[i].firstTouch = srLevels[j].firstTouch;
               
            if(srLevels[j].lastTouch > srLevels[i].lastTouch)
               srLevels[i].lastTouch = srLevels[j].lastTouch;
            // Keep the type (Resistance/Support) of the stronger level? Or the first one?
            // Let's keep the type of 'i' since 'j' is merged into 'i'.
            // Remove level j
            for(int k = j; k < ArraySize(srLevels) - 1; k++) {
               srLevels[k] = srLevels[k+1];
            }
            
            ArrayResize(srLevels, ArraySize(srLevels) - 1);
            j--; // Check the new j again
         }
      }
   }
   
   // Resort by strength if needed after merging
   if(ArraySize(srLevels) > 1) {
      for(int i = 0; i < ArraySize(srLevels); i++) {
         for(int j = 0; j < ArraySize(srLevels) - i - 1; j++) {
            if(srLevels[j].strength < srLevels[j+1].strength) {
               // Swap
               SRLevel temp = srLevels[j];
               srLevels[j] = srLevels[j+1];
               srLevels[j+1] = temp;
            }
         }
      }
   }
   
   // Ensure we don't exceed MaxSRLevels after merging/resorting
   if(ArraySize(srLevels) > MaxSRLevels) {
        ArrayResize(srLevels, MaxSRLevels);
   }
}
//+------------------------------------------------------------------+
//| Calculate S/R levels from higher timeframe                       |
//+------------------------------------------------------------------+
void CalculateHTFLevels(const datetime &time[])
{
   if(!UseMultiTimeframe) return;
   
   // Clear existing HTF levels
   ArrayResize(htfSRLevels, 0);
   
   // Get data from higher timeframe
   int htfBarsToRequest = HistoryLength; // Use HistoryLength for consistency? Or MaxPivotPoints * X?
   int htfBarsAvailable = iBars(NULL, MTFHTF);
   if(htfBarsAvailable <= 0) return; // No HTF data
   
   int htfBars = MathMin(htfBarsToRequest, htfBarsAvailable);
   if (htfBars < PivotPeriod * 2) return; // Not enough HTF bars for pivot calculation
   
   double htfHigh[], htfLow[], htfOpen[], htfClose[];
   datetime htfTime[];
   
   ArrayResize(htfHigh, htfBars);
   ArrayResize(htfLow, htfBars);
   ArrayResize(htfOpen, htfBars);
   ArrayResize(htfClose, htfBars);
   ArrayResize(htfTime, htfBars);
   
   // Copy HTF data
   if(CopyHigh(NULL, MTFHTF, 0, htfBars, htfHigh) != htfBars) return;
   if(CopyLow(NULL, MTFHTF, 0, htfBars, htfLow) != htfBars) return;
   if(CopyOpen(NULL, MTFHTF, 0, htfBars, htfOpen) != htfBars) return;
   if(CopyClose(NULL, MTFHTF, 0, htfBars, htfClose) != htfBars) return;
   if(CopyTime(NULL, MTFHTF, 0, htfBars, htfTime) != htfBars) return;
   
   // Data is copied from present to past, reverse for calculation
   ArraySetAsSeries(htfHigh, true);
   ArraySetAsSeries(htfLow, true);
   ArraySetAsSeries(htfOpen, true);
   ArraySetAsSeries(htfClose, true);
   ArraySetAsSeries(htfTime, true);
   
   // Temporary pivot storage
   PivotPoint htfPivots[];
   ArrayResize(htfPivots, MaxPivotPoints); // Limit potential pivots
   int pivotCount = 0;
   
   // Find HTF pivot points
   int htfPivotPeriod = PivotPeriod / 2; // Adjust period for higher timeframe? Maybe keep same or make input?
   htfPivotPeriod = MathMax(htfPivotPeriod, 2);
   
   for(int i = htfPivotPeriod; i < htfBars - htfPivotPeriod; i++) {
      // Check for pivot high
      bool isPivotHigh = IsPivotHighArray(i, htfPivotPeriod, SourceType, htfHigh, htfLow, htfOpen, htfClose);
      if(isPivotHigh) {
         if(pivotCount < MaxPivotPoints) {
             htfPivots[pivotCount].time = htfTime[i];
             htfPivots[pivotCount].price = GetPivotHighArray(i, htfPivotPeriod, SourceType, htfHigh, htfLow, htfOpen, htfClose);
             htfPivots[pivotCount].isHigh = true;
             htfPivots[pivotCount].strength = 1;
             pivotCount++;
         } else break; // Reached max pivots
      }
      
      // Check for pivot low
      bool isPivotLow = IsPivotLowArray(i, htfPivotPeriod, SourceType, htfHigh, htfLow, htfOpen, htfClose);
      if(isPivotLow) {
          if(pivotCount < MaxPivotPoints) {
              htfPivots[pivotCount].time = htfTime[i];
              htfPivots[pivotCount].price = GetPivotLowArray(i, htfPivotPeriod, SourceType, htfHigh, htfLow, htfOpen, htfClose);
              htfPivots[pivotCount].isHigh = false;
              htfPivots[pivotCount].strength = 1;
              pivotCount++;
          } else break; // Reached max pivots
      }
   }
   
   // Resize array to actual pivot count
   ArrayResize(htfPivots, pivotCount);
   if(pivotCount == 0) return; // No HTF pivots found
   
   // Calculate HTF S/R levels similar to the main function
   double htfHighest = htfHigh[ArrayMaximum(htfHigh, 0, htfBars)];
   double htfLowest = htfLow[ArrayMinimum(htfLow, 0, htfBars)];
   double htfRange = htfHighest - htfLowest;
   double htfChannelWidth = htfRange * ChannelWidth / 100.0;
   
   // Group HTF pivot points into zones
   for(int i = 0; i < ArraySize(htfPivots); i++) {
      double price = htfPivots[i].price;
      bool isHigh = htfPivots[i].isHigh;
      
      // Check if price fits within any existing level
      bool foundZone = false;
      for(int j = 0; j < ArraySize(htfSRLevels); j++) {
         if(price >= htfSRLevels[j].lowerBound && price <= htfSRLevels[j].upperBound) {
            // Update existing zone
            htfSRLevels[j].strength++;
            // Update touch count, times etc.? Keep simple for HTF?
            foundZone = true;
            break;
         }
      }
      
      // If no existing zone, create new one
      if(!foundZone) {
         int size = ArraySize(htfSRLevels);
         ArrayResize(htfSRLevels, size + 1);
         
         htfSRLevels[size].upperBound = price + htfChannelWidth/2;
         htfSRLevels[size].lowerBound = price - htfChannelWidth/2;
         htfSRLevels[size].midPoint = price;
         htfSRLevels[size].strength = 1;
         htfSRLevels[size].isResistance = isHigh;
         htfSRLevels[size].firstTouch = htfPivots[i].time; // Use pivot time
         htfSRLevels[size].lastTouch = htfPivots[i].time;
         htfSRLevels[size].touchCount = 1;
         htfSRLevels[size].breakoutCount = 0;
         htfSRLevels[size].fromHigherTF = true;
         
         // Look for other pivots in this zone to increase strength
         for(int k = i + 1; k < ArraySize(htfPivots); k++) {
            double otherPrice = htfPivots[k].price;
            if(otherPrice >= htfSRLevels[size].lowerBound && otherPrice <= htfSRLevels[size].upperBound) {
               htfSRLevels[size].strength++;
               htfSRLevels[size].touchCount++;
               // Update times?
            }
         }
      }
   }
   
   // Filter and sort HTF levels
   if(ArraySize(htfSRLevels) > 0) {
      // Sort by strength
      for(int i = 0; i < ArraySize(htfSRLevels); i++) {
         for(int j = 0; j < ArraySize(htfSRLevels) - i - 1; j++) {
            if(htfSRLevels[j].strength < htfSRLevels[j+1].strength) {
               // Swap
               SRLevel temp = htfSRLevels[j];
               htfSRLevels[j] = htfSRLevels[j+1];
               htfSRLevels[j+1] = temp;
            }
         }
      }
      
      // Limit to MaxSRLevels/2 for HTF
      int htfMaxLevels = (int)MathMax(1, MathFloor(MaxSRLevels / 2.0)); // Explicit cast added, use 2.0 for double division
      htfMaxLevels = MathMin(htfMaxLevels, ArraySize(htfSRLevels));
      ArrayResize(htfSRLevels, htfMaxLevels);
   }
}
//+------------------------------------------------------------------+
//| Check for pivot high in array data                               |
//+------------------------------------------------------------------+
bool IsPivotHighArray(int bar, int period, string sourceType, const double &high[], const double &low[], const double &open[], const double &close[])
{
   int arraySize = ArraySize(high);
   if(bar < period || bar >= arraySize - period)
      return false;
   double src;
   if(sourceType == "High/Low")
      src = high[bar];
   else
      src = MathMax(close[bar], open[bar]);
   for(int i = 1; i <= period; i++) {
      double leftSrc, rightSrc;
      if(sourceType == "High/Low") {
         leftSrc = high[bar + i]; // Accessing future bars (lower index because series)
         rightSrc = high[bar - i]; // Accessing past bars (higher index because series)
      }
      else {
         leftSrc = MathMax(close[bar + i], open[bar + i]);
         rightSrc = MathMax(close[bar - i], open[bar - i]);
      }
      if(src <= leftSrc || src <= rightSrc)
         return false;
   }
   return true;
}
//+------------------------------------------------------------------+
//| Check for pivot low in array data                                |
//+------------------------------------------------------------------+
bool IsPivotLowArray(int bar, int period, string sourceType, const double &high[], const double &low[], const double &open[], const double &close[])
{
   int arraySize = ArraySize(low);
   if(bar < period || bar >= arraySize - period)
      return false;
   double src;
   if(sourceType == "High/Low")
      src = low[bar];
   else
      src = MathMin(close[bar], open[bar]);
   for(int i = 1; i <= period; i++) {
      double leftSrc, rightSrc;
      if(sourceType == "High/Low") {
         leftSrc = low[bar + i]; // Accessing future bars (lower index because series)
         rightSrc = low[bar - i]; // Accessing past bars (higher index because series)
      }
      else {
         leftSrc = MathMin(close[bar + i], open[bar + i]);
         rightSrc = MathMin(close[bar - i], open[bar - i]);
      }
      if(src >= leftSrc || src >= rightSrc)
         return false;
   }
   return true;
}
//+------------------------------------------------------------------+
//| Get pivot high value from array data                             |
//+------------------------------------------------------------------+
double GetPivotHighArray(int bar, int period, string sourceType, const double &high[], const double &low[], const double &open[], const double &close[])
{
   // Assumes IsPivotHighArray was true for this bar
   if(sourceType == "High/Low")
      return high[bar];
   else
      return MathMax(close[bar], open[bar]);
}
//+------------------------------------------------------------------+
//| Get pivot low value from array data                              |
//+------------------------------------------------------------------+
double GetPivotLowArray(int bar, int period, string sourceType, const double &high[], const double &low[], const double &open[], const double &close[])
{
    // Assumes IsPivotLowArray was true for this bar
   if(sourceType == "High/Low")
      return low[bar];
   else
      return MathMin(close[bar], open[bar]);
}

//+------------------------------------------------------------------+
//| Draw S/R levels on chart                                         |
//+------------------------------------------------------------------+
void DrawSRLevels(const datetime &time[])
{
   // Delete existing objects managed by this function
   DeleteSRObjects();
   
   // Calculate rightmost position for labels
   int labelPos = MathMin(LabelLocation, Bars - 2); // Avoid very last bar
   if(labelPos < 0) labelPos = 0; // Handle small number of bars
   datetime labelTime = time[labelPos];
   datetime startTime = time[MathMin(HistoryLength-1, Bars-1)]; // Start lines from HistoryLength bars ago or beginning
   datetime endTime = time[0]; // Extend to current bar
   
   // Set line style
   int lineStyleType = STYLE_SOLID;
   if(LineStyle == "Dashed") lineStyleType = STYLE_DASH;
   if(LineStyle == "Dotted") lineStyleType = STYLE_DOT;
   
   // Draw normal S/R levels
   for(int i = 0; i < ArraySize(srLevels); i++) {
      string levelDesc = StringFormat("S/R Level %d (Strength: %d)", i+1, srLevels[i].strength);
      color lineColor = srLevels[i].isResistance ? ResistanceColor : SupportColor;
      color labelColor = srLevels[i].isResistance ? ResistanceLabelColor : SupportLabelColor;
      
      // Create line object
      string lineName = "SRLine_" + IntegerToString(i);
      srLines[i] = lineName; // Store name for later deletion
      
      datetime lineStartTime = MathMax(startTime, srLevels[i].firstTouch); // Don't draw before first touch or history limit
      
      ObjectCreate(lineName, OBJ_TREND, 0, lineStartTime, srLevels[i].midPoint,
                   endTime, srLevels[i].midPoint);
      ObjectSetInteger(0, lineName, OBJPROP_COLOR, lineColor);
      ObjectSetInteger(0, lineName, OBJPROP_STYLE, lineStyleType);
      ObjectSetInteger(0, lineName, OBJPROP_WIDTH, LineWidth);
      ObjectSetInteger(0, lineName, OBJPROP_RAY_RIGHT, PersistentLevels); // Use RAY_RIGHT instead of RAY
      ObjectSetString(0, lineName, OBJPROP_TEXT, levelDesc);
      ObjectSetInteger(0, lineName, OBJPROP_BACK, false); // Draw line on top
      
      // Create label
      string labelName = "SRLabel_" + IntegerToString(i);
      srLabels[i] = labelName; // Store name
      
      ObjectCreate(labelName, OBJ_TEXT, 0, labelTime, srLevels[i].midPoint);
      ObjectSetInteger(0, labelName, OBJPROP_COLOR, labelColor);
      ObjectSetString(0, labelName, OBJPROP_TEXT, StringFormat("%.*f (S:%d)", Digits, srLevels[i].midPoint, srLevels[i].strength));
      ObjectSetInteger(0, labelName, OBJPROP_FONTSIZE, 8);
      ObjectSetInteger(0, labelName, OBJPROP_ANCHOR, ANCHOR_RIGHT); // Anchor to the right of time coordinate
      ObjectSetInteger(0, labelName, OBJPROP_BACK, true); // Background label
      
      // Create zone if enabled
      if(ShowSRZones) {
         string zoneName = "SRZone_" + IntegerToString(i);
         srZones[i] = zoneName; // Store name
         
         color zoneColor = srLevels[i].isResistance ? ResistanceZoneColor : SupportZoneColor;
         // Transparency is handled by OBJPROP_BACK = true and the color itself
         
         ObjectCreate(zoneName, OBJ_RECTANGLE, 0, lineStartTime, srLevels[i].upperBound,
                      endTime, srLevels[i].lowerBound);
         ObjectSetInteger(0, zoneName, OBJPROP_COLOR, zoneColor);
         ObjectSetInteger(0, zoneName, OBJPROP_BACK, true); // Draw zone behind candles
         ObjectSetInteger(0, zoneName, OBJPROP_RAY_RIGHT, PersistentLevels); // Extend zone
         ObjectSetInteger(0, zoneName, OBJPROP_STYLE, STYLE_SOLID); // Make sure zone is filled
         ObjectSetString(0, zoneName, OBJPROP_TEXT, levelDesc + " Zone");
      }
   }
   
   // Draw HTF S/R levels
   if(UseMultiTimeframe) {
      for(int i = 0; i < ArraySize(htfSRLevels); i++) {
         int idx = ArraySize(srLevels) + i; // Index in the object name arrays
         if(idx >= ArraySize(srLines)) continue; // Safety check for array bounds
         string levelDesc = StringFormat("HTF Level %d (Strength: %d)", i+1, htfSRLevels[i].strength);
         color lineColor = htfSRLevels[i].isResistance ? HTFResistanceColor : HTFSupportColor;
         color labelColor = htfSRLevels[i].isResistance ? HTFResistanceColor : HTFSupportColor; // Label same color as line?
         
         // Create line object
         string lineName = "HTFLine_" + IntegerToString(i);
         srLines[idx] = lineName; // Store name
         
         datetime lineStartTime = MathMax(startTime, htfSRLevels[i].firstTouch);
         ObjectCreate(lineName, OBJ_TREND, 0, lineStartTime, htfSRLevels[i].midPoint,
                      endTime, htfSRLevels[i].midPoint);
         ObjectSetInteger(0, lineName, OBJPROP_COLOR, lineColor);
         ObjectSetInteger(0, lineName, OBJPROP_STYLE, lineStyleType);
         ObjectSetInteger(0, lineName, OBJPROP_WIDTH, LineWidth);
         ObjectSetInteger(0, lineName, OBJPROP_RAY_RIGHT, PersistentLevels);
         ObjectSetString(0, lineName, OBJPROP_TEXT, levelDesc);
         ObjectSetInteger(0, lineName, OBJPROP_BACK, false);
         
         // Create label
         string labelName = "HTFLabel_" + IntegerToString(i);
         srLabels[idx] = labelName; // Store name
         
         ObjectCreate(labelName, OBJ_TEXT, 0, labelTime, htfSRLevels[i].midPoint);
         ObjectSetInteger(0, labelName, OBJPROP_COLOR, labelColor);
         ObjectSetString(0, labelName, OBJPROP_TEXT, StringFormat("HTF: %.*f (S:%d)", Digits, htfSRLevels[i].midPoint, htfSRLevels[i].strength));
         ObjectSetInteger(0, labelName, OBJPROP_FONTSIZE, 8);
         ObjectSetInteger(0, labelName, OBJPROP_ANCHOR, ANCHOR_RIGHT);
         ObjectSetInteger(0, labelName, OBJPROP_BACK, true);
         
         // Create zone if enabled
         if(ShowSRZones) {
            string zoneName = "HTFZone_" + IntegerToString(i);
            srZones[idx] = zoneName; // Store name
            
            color zoneColor = htfSRLevels[i].isResistance ? ResistanceZoneColor : SupportZoneColor; // Use same zone colors? Or HTF specific? Using same for now.
            
            ObjectCreate(zoneName, OBJ_RECTANGLE, 0, lineStartTime, htfSRLevels[i].upperBound,
                         endTime, htfSRLevels[i].lowerBound);
            ObjectSetInteger(0, zoneName, OBJPROP_COLOR, zoneColor);
            ObjectSetInteger(0, zoneName, OBJPROP_BACK, true);
            ObjectSetInteger(0, zoneName, OBJPROP_RAY_RIGHT, PersistentLevels);
            ObjectSetInteger(0, zoneName, OBJPROP_STYLE, STYLE_SOLID);
            ObjectSetString(0, zoneName, OBJPROP_TEXT, levelDesc + " Zone");
         }
      }
   }
   ChartRedraw(); // Force redraw after updating objects
}
//+------------------------------------------------------------------+
//| Calculate market trend                                           |
//+------------------------------------------------------------------+
void CalculateTrend(const double &close[], int period)
{
   if(period <= 0 || !UseTrendFilter) {
       trend = 0; // Neutral if disabled or invalid period
       return;
   }
   
   int bars = ArraySize(close);
   if(bars < period + 1) { // Need at least period+1 bars for two MA values
       trend = 0;
       return;
   }
   
   // Use simple moving average for trend
   double ma = iMAOnArray(close, 0, period, 0, MODE_SMA, 0);
   double prevMa = iMAOnArray(close, 0, period, 0, MODE_SMA, 1);
   
   // Determine trend
   if(ma > prevMa) {
      trend = 1; // Uptrend
   } else if(ma < prevMa) {
      trend = -1; // Downtrend
   } else {
      trend = 0; // Neutral
   }
}
//+------------------------------------------------------------------+
//| Create a pivot point marker                                      |
//+------------------------------------------------------------------+
void CreatePivotMarker(datetime time, double price, bool isHigh)
{
   string markerName = "Pivot_" + TimeToString(time, TIME_DATE|TIME_MINUTES) + "_" + (isHigh ? "H" : "L");
   
   // Check if marker already exists (basic check, doesn't manage array properly)
   if(ObjectFind(0, markerName) >= 0) return; 
   
   // Add name to array (potential issue: array might fill up if not cleared properly)
   bool added = false;
   for(int i = 0; i < ArraySize(pivotMarkers); i++) {
      if(pivotMarkers[i] == "") {
         pivotMarkers[i] = markerName;
         added = true;
         break;
      }
   }
   // If array is full, we might overwrite old names or fail to add new ones.
   // Consider a more robust circular buffer or resizing if needed.
   ObjectCreate(0, markerName, OBJ_ARROW, 0, time, price);
   ObjectSetInteger(0, markerName, OBJPROP_ARROWCODE, isHigh ? SYMBOL_ARROWUP : SYMBOL_ARROWDOWN);
   ObjectSetInteger(0, markerName, OBJPROP_COLOR, isHigh ? ResistanceColor : SupportColor);
   ObjectSetInteger(0, markerName, OBJPROP_WIDTH, 1);
   ObjectSetInteger(0, markerName, OBJPROP_BACK, false);
   // Anchor arrows slightly above/below the price
   if (isHigh) ObjectSetDouble(0, markerName, OBJPROP_PRICE, 0, price + 10 * _Point);
   else ObjectSetDouble(0, markerName, OBJPROP_PRICE, 0, price - 10 * _Point);
}
//+------------------------------------------------------------------+
//| Mark historical breakouts                                        |
//+------------------------------------------------------------------+
void MarkHistoricalBreakouts(const datetime &time[], const double &close[], int confirmBars)
{
   if(!ShowHistoricalBreakouts) return;
   
   // Delete existing breakout markers
   for(int i = 0; i < ArraySize(breakoutMarkers); i++) {
      if(breakoutMarkers[i] != "" && ObjectFind(0, breakoutMarkers[i]) >= 0) {
         ObjectDelete(0, breakoutMarkers[i]);
      }
      breakoutMarkers[i] = ""; // Clear array slot
   }
   
   int breakoutMarkerIndex = 0; // Index for the breakoutMarkers array
   int barsToCheck = MathMin(HistoryLength, ArraySize(close));
   // Check for breakouts across all S/R levels
   for(int i = 0; i < ArraySize(srLevels); i++) {
      double level = srLevels[i].midPoint;
      bool isResistance = srLevels[i].isResistance;
      
      for(int bar = barsToCheck - confirmBars - 2; bar >= confirmBars ; bar--) { // Iterate backwards from near present
         if (breakoutMarkerIndex >= ArraySize(breakoutMarkers)) break; // Stop if array is full
         bool breakout = false;
         bool confirmed = false;
         
         if(isResistance) {
            // Check for resistance breakout (close above resistance)
            // Potential breakout on 'bar' if close[bar] > level and close[bar+1] <= level
            if(close[bar] > level && close[bar+1] <= level) {
               // Confirm breakout with subsequent bars (meaning bars before 'bar' index)
               confirmed = true;
               for(int j = 1; j <= confirmBars; j++) {
                  if(close[bar-j] <= level) {
                     confirmed = false;
                     break;
                  }
               }
               if(confirmed) breakout = true;
            }
         } else {
            // Check for support breakout (close below support)
            // Potential breakout on 'bar' if close[bar] < level and close[bar+1] >= level
            if(close[bar] < level && close[bar+1] >= level) {
               // Confirm breakout with subsequent bars (meaning bars before 'bar' index)
               confirmed = true;
               for(int j = 1; j <= confirmBars; j++) {
                  if(close[bar-j] >= level) {
                     confirmed = false;
                     break;
                  }
               }
               if(confirmed) breakout = true;
            }
         }
         
         if(breakout) {
            // Create breakout marker
            string markerName = "Breakout_" + IntegerToString(i) + "_" + IntegerToString(bar);
            breakoutMarkers[breakoutMarkerIndex] = markerName; // Store name
            
            ObjectCreate(0, markerName, OBJ_ARROW, 0, time[bar], close[bar]);
            ObjectSetInteger(0, markerName, OBJPROP_ARROWCODE, isResistance ? SYMBOL_CHECKSIGN : SYMBOL_STOPSIGN); // Check for break up, Stop for break down
            ObjectSetInteger(0, markerName, OBJPROP_COLOR, isResistance ? clrLime : clrRed);
            ObjectSetInteger(0, markerName, OBJPROP_WIDTH, 2);
            ObjectSetInteger(0, markerName, OBJPROP_BACK, false);
             // Position marker slightly
             if(isResistance) ObjectSetDouble(0, markerName, OBJPROP_PRICE, 0, close[bar] + 15 * _Point);
             else ObjectSetDouble(0, markerName, OBJPROP_PRICE, 0, close[bar] - 15 * _Point);
            breakoutMarkerIndex++; // Move to next slot in array
            
            // Skip ahead to avoid multiple markers for the same event
            bar -= confirmBars;
         }
      }
      if (breakoutMarkerIndex >= ArraySize(breakoutMarkers)) break; // Stop outer loop if array is full
   }
   
   // Do the same for HTF levels if enabled
   if(UseMultiTimeframe) {
      for(int i = 0; i < ArraySize(htfSRLevels); i++) {
         if (breakoutMarkerIndex >= ArraySize(breakoutMarkers)) break; // Stop if array is full
         double level = htfSRLevels[i].midPoint;
         bool isResistance = htfSRLevels[i].isResistance;
         
         for(int bar = barsToCheck - confirmBars - 2; bar >= confirmBars ; bar--) {
             if (breakoutMarkerIndex >= ArraySize(breakoutMarkers)) break; // Stop if array is full
             bool breakout = false;
             bool confirmed = false;
            
            if(isResistance) {
               if(close[bar] > level && close[bar+1] <= level) {
                  confirmed = true;
                  for(int j = 1; j <= confirmBars; j++) {
                     if(close[bar-j] <= level) { confirmed = false; break; }
                  }
                  if(confirmed) breakout = true;
               }
            } else {
               if(close[bar] < level && close[bar+1] >= level) {
                  confirmed = true;
                  for(int j = 1; j <= confirmBars; j++) {
                     if(close[bar-j] >= level) { confirmed = false; break; }
                  }
                  if(confirmed) breakout = true;
               }
            }
            
            if(breakout) {
               // Create breakout marker
               string markerName = "HTFBreakout_" + IntegerToString(i) + "_" + IntegerToString(bar);
               breakoutMarkers[breakoutMarkerIndex] = markerName; // Store name
               ObjectCreate(0, markerName, OBJ_ARROW, 0, time[bar], close[bar]);
               ObjectSetInteger(0, markerName, OBJPROP_ARROWCODE, isResistance ? SYMBOL_CHECKSIGN : SYMBOL_STOPSIGN);
               ObjectSetInteger(0, markerName, OBJPROP_COLOR, isResistance ? HTFSupportColor : HTFResistanceColor); // Use opposite HTF colors for visibility?
               ObjectSetInteger(0, markerName, OBJPROP_WIDTH, 2);
               ObjectSetInteger(0, markerName, OBJPROP_BACK, false);
               // Position marker slightly
               if(isResistance) ObjectSetDouble(0, markerName, OBJPROP_PRICE, 0, close[bar] + 15 * _Point);
               else ObjectSetDouble(0, markerName, OBJPROP_PRICE, 0, close[bar] - 15 * _Point);
               breakoutMarkerIndex++; // Move to next slot in array
               
               // Skip ahead
               bar -= confirmBars;
            }
         }
         if (breakoutMarkerIndex >= ArraySize(breakoutMarkers)) break; // Stop outer loop if array is full
      }
   }
}
//+------------------------------------------------------------------+
//| Check for alert conditions                                       |
//+------------------------------------------------------------------+
void CheckAlerts(datetime currentTime, double currentPrice, double currentHigh, double currentLow)
{
   if(!EnableAlerts || IsTesting() || IsOptimization()) return;
   
   // Check if at least 60 seconds have passed since last alert to prevent spam
   if(TimeCurrent() - lastAlert < 60) return; // Use TimeCurrent() for real-time check
   
   bool alertTriggered = false; // Flag to ensure only one alert per check interval
   // Check for price crossover or approaching S/R levels
   for(int i = 0; i < ArraySize(srLevels); i++) {
      if(alertTriggered) break; // Exit loop if an alert was already sent
      
      double level = srLevels[i].midPoint;
      double levelUpper = srLevels[i].upperBound;
      double levelLower = srLevels[i].lowerBound;
      bool isResistance = srLevels[i].isResistance;
      string levelType = isResistance ? "Resistance" : "Support";
      string symbol = Symbol();
      
      // Check crossover (using bar 1 close vs bar 0 close/currentPrice)
      if(AlertOnCrossover) {
         double prevClose = iClose(symbol, Period(), 1);
         
         if(isResistance) {
            // Cross Above Resistance Level (midpoint)
            if(currentPrice > level && prevClose <= level) {
               string alertMsg = StringFormat("%s crossed above %s level %. *f", symbol, levelType, Digits, level);
               SendAlert(alertMsg);
               lastAlert = TimeCurrent();
               alertTriggered = true;
               break;
            }
         } else {
            // Cross Below Support Level (midpoint)
            if(currentPrice < level && prevClose >= level) {
               string alertMsg = StringFormat("%s crossed below %s level %. *f", symbol, levelType, Digits, level);
               SendAlert(alertMsg);
               lastAlert = TimeCurrent();
               alertTriggered = true;
               break;
            }
         }
      }
      
      // Check approach (current high/low within distance of level bounds)
      if(AlertOnApproach && !alertTriggered) {
         double approachDistPts = ApproachDistance * _Point;
         
         if(isResistance) {
             // Price high approaches lower bound of resistance zone
            if(currentHigh >= levelLower - approachDistPts && currentHigh < levelLower) {
                // Optional: Check if previous bar was further away
                double prevHigh = iHigh(symbol, Period(), 1);
                if(prevHigh < levelLower - approachDistPts) {
                    string alertMsg = StringFormat("%s approaching %s zone near %. *f", symbol, levelType, Digits, levelLower);
                    SendAlert(alertMsg);
                    lastAlert = TimeCurrent();
                    alertTriggered = true;
                    break;
                }
            }
         } else {
             // Price low approaches upper bound of support zone
            if(currentLow <= levelUpper + approachDistPts && currentLow > levelUpper) {
                // Optional: Check if previous bar was further away
                double prevLow = iLow(symbol, Period(), 1);
                if(prevLow > levelUpper + approachDistPts) {
                    string alertMsg = StringFormat("%s approaching %s zone near %. *f", symbol, levelType, Digits, levelUpper);
                    SendAlert(alertMsg);
                    lastAlert = TimeCurrent();
                    alertTriggered = true;
                    break;
                }
            }
         }
      }
   }
   
   // Also check HTF levels if enabled and no alert triggered yet
   if(UseMultiTimeframe && !alertTriggered) {
      for(int i = 0; i < ArraySize(htfSRLevels); i++) {
         if(alertTriggered) break;
         
         double level = htfSRLevels[i].midPoint;
         double levelUpper = htfSRLevels[i].upperBound;
         double levelLower = htfSRLevels[i].lowerBound;
         bool isResistance = htfSRLevels[i].isResistance;
         string levelType = isResistance ? "HTF Resistance" : "HTF Support";
         string symbol = Symbol();
         
         // Check crossover HTF
         if(AlertOnCrossover) {
            double prevClose = iClose(symbol, Period(), 1);
            if(isResistance) {
               if(currentPrice > level && prevClose <= level) {
                  string alertMsg = StringFormat("%s crossed above %s level %. *f", symbol, levelType, Digits, level);
                  SendAlert(alertMsg);
                  lastAlert = TimeCurrent();
                  alertTriggered = true;
                  break;
               }
            } else {
               if(currentPrice < level && prevClose >= level) {
                  string alertMsg = StringFormat("%s crossed below %s level %. *f", symbol, levelType, Digits, level);
                  SendAlert(alertMsg);
                  lastAlert = TimeCurrent();
                  alertTriggered = true;
                  break;
               }
            }
         }
         
         // Check approach HTF
         if(AlertOnApproach && !alertTriggered) {
            double approachDistPts = ApproachDistance * _Point;
            if(isResistance) {
               if(currentHigh >= levelLower - approachDistPts && currentHigh < levelLower) {
                  double prevHigh = iHigh(symbol, Period(), 1);
                  if(prevHigh < levelLower - approachDistPts) {
                     string alertMsg = StringFormat("%s approaching %s zone near %. *f", symbol, levelType, Digits, levelLower);
                     SendAlert(alertMsg);
                     lastAlert = TimeCurrent();
                     alertTriggered = true;
                     break;
                  }
               }
            } else {
               if(currentLow <= levelUpper + approachDistPts && currentLow > levelUpper) {
                  double prevLow = iLow(symbol, Period(), 1);
                  if(prevLow > levelUpper + approachDistPts) {
                     string alertMsg = StringFormat("%s approaching %s zone near %. *f", symbol, levelType, Digits, levelUpper);
                     SendAlert(alertMsg);
                     lastAlert = TimeCurrent();
                     alertTriggered = true;
                     break;
                  }
               }
            }
         }
      }
   }
}
//+------------------------------------------------------------------+
//| Send Alert Helper Function                                       |
//+------------------------------------------------------------------+
void SendAlert(string message)
{
    if (!IsTesting()) { // Don't send alerts during backtesting
        Alert(message); // Popup alert
        
        if(EnableEmailAlerts && !IsOptimization()) {
            SendMail("SNR Dynamic Alert: " + Symbol(), message);
        }
        if(EnablePushAlerts && !IsOptimization()) {
            SendNotification(message);
        }
    }
}

//+------------------------------------------------------------------+
//| Delete all indicator objects                                     |
//+------------------------------------------------------------------+
void DeleteAllObjects()
{
   // Use ObjectsDeleteAll to clear objects created by this indicator
   // Prefix object names consistently to target deletion more safely.
   // Example prefix: "SNR_" + IndicatorShortName() + "_"
   string prefix = "SR"; // Using simple prefix based on object names used
   ObjectsDeleteAll(0, prefix, -1); // Delete lines, labels, zones
   prefix = "HTF";
   ObjectsDeleteAll(0, prefix, -1); // Delete HTF objects
   prefix = "Pivot_";
   ObjectsDeleteAll(0, prefix, -1); // Delete pivot markers
   prefix = "Breakout_";
   ObjectsDeleteAll(0, prefix, -1); // Delete breakout markers
   prefix = "HTFBreakout_";
   ObjectsDeleteAll(0, prefix, -1); // Delete HTF breakout markers
   // Clear the stored object names in arrays as well
   ClearObjectArrays();
   ChartRedraw();
}
//+------------------------------------------------------------------+
//| Delete S/R objects only                                          |
//+------------------------------------------------------------------+
void DeleteSRObjects()
{
    string prefix = "SRLine_"; ObjectsDeleteAll(0, prefix);
    prefix = "SRLabel_"; ObjectsDeleteAll(0, prefix);
    prefix = "SRZone_"; ObjectsDeleteAll(0, prefix);
    prefix = "HTFLine_"; ObjectsDeleteAll(0, prefix);
    prefix = "HTFLabel_"; ObjectsDeleteAll(0, prefix);
    prefix = "HTFZone_"; ObjectsDeleteAll(0, prefix);
    // Clear corresponding array slots - important!
    for(int i=0; i<ArraySize(srLines); i++) srLines[i] = "";
    for(int i=0; i<ArraySize(srLabels); i++) srLabels[i] = "";
    for(int i=0; i<ArraySize(srZones); i++) srZones[i] = "";
    // Don't redraw here, let the calling function do it once after all drawing/deleting.
}
//+------------------------------------------------------------------+
//| Clear all arrays (Data and Object Names)                         |
//+------------------------------------------------------------------+
void ClearArrays()
{
   // Clear pivot data array
   ArrayResize(pivots, MaxPivotPoints); // Keep size for reuse
   for(int i = 0; i < ArraySize(pivots); i++) {
      pivots[i].time = 0;
      pivots[i].price = 0;
      pivots[i].isHigh = false;
      pivots[i].strength = 0;
      pivots[i].confirmed = false;
   }
   
   // Clear S/R level data arrays
   ArrayResize(srLevels, 0);
   ArrayResize(htfSRLevels, 0);
   
   // Clear object name arrays
   ClearObjectArrays();
}
//+------------------------------------------------------------------+
//| Clear object name arrays only                                    |
//+------------------------------------------------------------------+
void ClearObjectArrays()
{
   // Clear object name arrays
   for(int i = 0; i < ArraySize(srLines); i++) srLines[i] = "";
   for(int i = 0; i < ArraySize(srZones); i++) srZones[i] = "";
   for(int i = 0; i < ArraySize(srLabels); i++) srLabels[i] = "";
   for(int i = 0; i < ArraySize(pivotMarkers); i++) pivotMarkers[i] = "";
   for(int i = 0; i < ArraySize(breakoutMarkers); i++) breakoutMarkers[i] = "";
}
//+------------------------------------------------------------------+

Quoting BestTraderEv

Disliked

{quote} {file} Checked, updates. PS. I deleted all previous posts with this indicator, so as not to confuse! This one seems to work the best.

Ignored

Quoting BestTraderEv

Disliked

{quote} {file} Checked, updates. PS. I deleted all previous posts with this indicator, so as not to confuse! This one seems to work the best.

Ignored

Quoting aqzhd

Disliked

{quote} Dear Mr. BestTraderEv, good evening! I am very sorry to bother you. The Multi Oscillator (Final Corrected Version) indicator may still have some problems. Through testing, it is found that the indicator does not work properly. The indicator value and the bar chart cannot be displayed normally after a period of time. (As shown in the picture: inside the box) Best regards, good night!{image}

Ignored

Quoting BestTraderEv

Disliked

{quote} https://www.forexfactory.com/thread/...0#post15211860

Ignored

Quoting BestTraderEv

Disliked

{quote} I am tired of this. This is the last job for you, at least for a longer while. {file} {image}

Ignored

Quoting hharrington

Disliked

does anyone have an indicator for metatrader 5 that will display the bid price on the chart so i can make the numbers larger

Ignored