forex-scalping.com

Code: Select all

//@version=5
indicator("XAG Scalp Pro Engine", overlay=true, precision=3)

// --- INPUTS ---
// Core Trend Settings
hmaSource   = input.source(close, title="HMA Source")
hmaLength   = input.int(9, title="HMA Period (Fast Trend)", minval=1)

// Volatility & Filter Settings
atrLength   = input.int(14, title="ATR Length for Bands")
atrMult     = input.float(1.5, title="ATR Multiplier (Width)", step=0.1)

// Session Filters (UTC default, adjust to your broker time - e.g., London/NY overlap)
useSession  = input.bool(true, title="Filter by Active Trading Session?")
tradeSession= input.session("0700-1600", title="Active Session (UTC)")

// --- CALCULATIONS ---
// 1. Hull Moving Average for lightning-fast direction without lag
f_hma(src, length) =>
    ta.wma(2 * ta.wma(src, length / 2) - ta.wma(src, length), math.round(math.sqrt(length)))

trendLine = f_hma(hmaSource, hmaLength)

// 2. Trend Direction Determination
isBullish = trendLine > trendLine[1]
isBearish = trendLine < trendLine[1]

// 3. ATR Volatility Bands for Breakout / Pullback detection
atrValue = ta.atr(atrLength)
upperBand = trendLine + (atrValue * atrMult)
lowerBand = trendLine - (atrValue * atrMult)

// 4. Session Time Check
inSession = not useSession or not na(time(timeframe.period, tradeSession + ":234560"))

// --- SIGNAL GENERATION ---
// Scalp triggers: Price piercing the volatility band while HMA changes direction
longSignal  = ta.crossover(close, lowerBand) and isBullish and inSession
shortSignal = ta.crossunder(close, upperBand) and isBearish and inSession

// --- PLOTTING ---
// Plot HMA Trend Line
barColor = isBullish ? color.green : color.red
plot(trendLine, title="Fast HMA", color=barColor, linewidth=2)

// Plot ATR Volatility Channels
uPlot = plot(upperBand, title="Upper Volatility Band", color=color.new(color.blue, 50))
lPlot = plot(lowerBand, title="Lower Volatility Band", color=color.new(color.blue, 50))
fill(uPlot, lPlot, color=color.new(color.blue, 95), title="Channel Background")

// Visual Chart Signals
plotshape(longSignal, title="Scalp Buy", location=location.belowbar, style=shape.triangleup, size=size.small, color=color.green, text="BUY")
plotshape(shortSignal, title="Scalp Sell", location=location.abovebar, style=shape.triangledown, size=size.small, color=color.red, text="SELL")

// --- ALERTS ---
alertcondition(longSignal, title="XAG Scalp BUY Alert", message="XAG/USD Bullish Scalp Setup Triggered!")
alertcondition(shortSignal, title="XAG Scalp SELL Alert", message="XAG/USD Bearish Scalp Setup Triggered!")

Code: Select all

//+------------------------------------------------------------------+
//|                                           XAG_Scalp_Pro.mq4      |
//|                                  Custom Scalping Engine for MT4  |
//+------------------------------------------------------------------+
#property copyright "Custom Scalp Engine"
#property link      ""
#property version   "1.00"
#property strict

#property indicator_chart_window
#property indicator_buffers 5
#property indicator_color1 Lime     // Bullish HMA
#property indicator_color2 Red      // Bearish HMA
#property indicator_color3 DodgerBlue // Upper Band
#property indicator_color4 DodgerBlue // Lower Band
#property indicator_color5 Lime     // Buy Arrow
#property indicator_color6 Red      // Sell Arrow

// --- INPUT PARAMETERS ---
input int    InpHmaPeriod = 9;          // HMA Period (Fast Trend)
input int    InpAtrPeriod = 14;         // ATR Period for Bands
input double InpAtrMult   = 1.5;        // ATR Multiplier (Width)
input bool   InpUseSound  = true;       // Enable Push/Audio Alerts

// --- INDICATOR BUFFERS ---
double HmaBufferUp[];
double HmaBufferDn[];
double UpperBandBuffer[];
double LowerBandBuffer[];
double BuySignalBuffer[];
double SellSignalBuffer[];

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
   // Mapping Buffers
   SetIndexBuffer(0, HmaBufferUp); SetIndexStyle(0, DRAW_LINE, STYLE_SOLID, 2);
   SetIndexBuffer(1, HmaBufferDn); SetIndexStyle(1, DRAW_LINE, STYLE_SOLID, 2);
   SetIndexBuffer(2, UpperBandBuffer); SetIndexStyle(2, DRAW_LINE, STYLE_DASH, 1);
   SetIndexBuffer(3, LowerBandBuffer); SetIndexStyle(3, DRAW_LINE, STYLE_DASH, 1);
   SetIndexBuffer(4, BuySignalBuffer); SetIndexStyle(4, DRAW_ARROW, STYLE_SOLID, 2); SetIndexArrow(4, 233);
   SetIndexBuffer(5, SellSignalBuffer); SetIndexStyle(5, DRAW_ARROW, STYLE_SOLID, 2); SetIndexArrow(5, 234);

   IndicatorShortName("XAG Scalp Pro Engine");
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| 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 volume &volume[],
                const spread &spread[])
{
   int limit = rates_total - prev_calculated;
   if (prev_calculated > 0) limit++;
   if (limit > rates_total - InpHmaPeriod * 2) limit = rates_total - InpHmaPeriod * 2;
   if (limit < 0) limit = 0;

   // Calculate Hull Moving Average and ATR Bands loop
   for (int i = limit; i >= 0; i--)
   {
      double hma = CalculateHMA(i, InpHmaPeriod, close);
      double atr = iATR(NULL, 0, InpAtrPeriod, i);
      
      double upper = hma + (atr * InpAtrMult);
      double lower = hma - (atr * InpAtrMult);

      UpperBandBuffer[i] = upper;
      LowerBandBuffer[i] = lower;

      // HMA Direction Check
      double prev_hma = (i + 1 < rates_total) ? CalculateHMA(i + 1, InpHmaPeriod, close) : hma;
      
      if (hma >= prev_hma)
      {
         HmaBufferUp[i] = hma;
         HmaBufferDn[i] = EMPTY_VALUE;
      }
      else
      {
         HmaBufferDn[i] = hma;
         HmaBufferUp[i] = EMPTY_VALUE;
      }

      // Signal Triggers (Check on closed bar [1] to avoid repainting during formation)
      BuySignalBuffer[i]  = EMPTY_VALUE;
      SellSignalBuffer[i] = EMPTY_VALUE;

      if (i == 1)
      {
         bool isBullish = (hma > prev_hma);
         bool isBearish = (hma < prev_hma);
         
         bool longSignal  = (close[1] <= lower && isBullish);
         bool shortSignal = (close[1] >= upper && isBearish);

         if (longSignal)
         {
            BuySignalBuffer[1] = low[1] - (atr * 0.5);
            if (InpUseSound) Alert("XAG/USD Scalp BUY Signal on ", Symbol(), " (M", Period(), ")");
         }
         else if (shortSignal)
         {
            SellSignalBuffer[1] = high[1] + (atr * 0.5);
            if (InpUseSound) Alert("XAG/USD Scalp SELL Signal on ", Symbol(), " (M", Period(), ")");
         }
      }
   }

   return(rates_total);
}

//+------------------------------------------------------------------+
//| Custom Hull Moving Average Calculation Function                   |
//+------------------------------------------------------------------+
double CalculateHMA(int shift, int period, const double &price_array[])
{
   int halfPeriod = (int)MathRound(period / 2);
   int sqrtPeriod = (int)MathRound(MathSqrt(period));
   
   double wma_half = CalculateWMA(shift, halfPeriod, price_array);
   double wma_full = CalculateWMA(shift, period, price_array);
   
   double diff = 2.0 * wma_half - wma_full;
   
   // Create an array slice for the final WMA of the difference
   double temp_array[];
   ArrayResize(temp_array, sqrtPeriod + 5);
   
   for(int i = 0; i <= sqrtPeriod; i++)
   {
      int s = shift + i;
      double wh = CalculateWMA(s, halfPeriod, price_array);
      double wf = CalculateWMA(s, period, price_array);
      temp_array[i] = 2.0 * wh - wf;
   }
   
   double hma = 0;
   double weightSum = 0;
   for(int i = 0; i < sqrtPeriod; i++)
   {
      int weight = sqrtPeriod - i;
      hma += temp_array[i] * weight;
      weightSum += weight;
   }
   
   return (weightSum > 0) ? (hma / weightSum) : diff;
}

//+------------------------------------------------------------------+
//| Weighted Moving Average (WMA) Helper                             |
//+------------------------------------------------------------------+
double CalculateWMA(int shift, int period, const double &price_array[])
{
   double sum = 0;
   double weightSum = 0;
   for(int i = 0; i < period; i++)
   {
      int weight = period - i;
      sum += price_array[shift + i] * weight;
      weightSum += weight;
   }
   return (weightSum > 0) ? (sum / weightSum) : price_array[shift];
}
//+------------------------------------------------------------------+

Code: Select all

//+------------------------------------------------------------------+
//|                                           XAG_Scalp_Pro_MT5.mq5  |
//|                                  Custom Scalping Engine for MT5  |
//+------------------------------------------------------------------+
#property copyright "Custom Scalp Engine"
#property link      ""
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 6
#property indicator_plots   6

// --- PLOT STYLES ---
// Plot 0: Bullish HMA
#property indicator_label1  "HMA Up"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrLime
#property indicator_style1  STYLE_SOLID
#property indicator_width1  2

// Plot 1: Bearish HMA
#property indicator_label2  "HMA Down"
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrRed
#property indicator_style2  STYLE_SOLID
#property indicator_width2  2

// Plot 2: Upper Band
#property indicator_label3  "Upper Band"
#property indicator_type3   DRAW_LINE
#property indicator_color3  clrDodgerBlue
#property indicator_style3  STYLE_DASH
#property indicator_width3  1

// Plot 3: Lower Band
#property indicator_label4  "Lower Band"
#property indicator_type4   DRAW_LINE
#property indicator_color4  clrDodgerBlue
#property indicator_style4  STYLE_DASH
#property indicator_width4  1

// Plot 4: Buy Signal Arrow
#property indicator_label5  "Buy Signal"
#property indicator_type5   DRAW_ARROW
#property indicator_color5  clrLime
#property indicator_width5  3

// Plot 5: Sell Signal Arrow
#property indicator_label6  "Sell Signal"
#property indicator_type6   DRAW_ARROW
#property indicator_color6  clrRed
#property indicator_width6  3

// --- INPUT PARAMETERS ---
input group "--- Core Trend Settings ---"
input int    InpHmaPeriod = 9;          // HMA Period (Fast Trend)

input group "--- Volatility Settings ---"
input int    InpAtrPeriod = 14;         // ATR Period for Bands
input double InpAtrMult   = 1.5;        // ATR Multiplier (Width)

input group "--- Alert Settings ---"
input bool   InpUseSound  = true;       // Enable Push/Audio Alerts

// --- INDICATOR BUFFERS ---
double HmaUpBuffer[];
double HmaDnBuffer[];
double UpperBandBuffer[];
double LowerBandBuffer[];
double BuySignalBuffer[];
double SellSignalBuffer[];

// --- HANDLES ---
int atrHandle;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
   // Map Buffers to Plots
   SetIndexBuffer(0, HmaUpBuffer, INDICATOR_DATA);
   SetIndexBuffer(1, HmaDnBuffer, INDICATOR_DATA);
   SetIndexBuffer(2, UpperBandBuffer, INDICATOR_DATA);
   SetIndexBuffer(3, LowerBandBuffer, INDICATOR_DATA);
   SetIndexBuffer(4, BuySignalBuffer, INDICATOR_DATA);
   SetIndexBuffer(5, SellSignalBuffer, INDICATOR_DATA);

   // Set Arrow Codes (Wingdings 233 = Up Arrow, 234 = Down Arrow)
   PlotIndexSetInteger(4, PLOT_ARROW, 233);
   PlotIndexSetInteger(5, PLOT_ARROW, 234);

   // Initialize ATR handle
   atrHandle = iATR(_Symbol, _Period, InpAtrPeriod);
   if(atrHandle == INVALID_HANDLE)
   {
      Print("Failed to create ATR handle.");
      return(INIT_FAILED);
   }

   IndicatorSetString(INDICATOR_SHORTNAME, "XAG Scalp Pro Engine (MT5)");
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   IndicatorRelease(atrHandle);
}

//+------------------------------------------------------------------+
//| 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[])
{
   if(rates_total < InpHmaPeriod * 2 || rates_total < InpAtrPeriod) return(0);

   // Copy ATR values safely to array
   double atrValues[];
   ArraySetAsSeries(atrValues, true);
   if(CopyBuffer(atrHandle, 0, 0, rates_total, atrValues) <= 0) return(0);

   int limit = (prev_calculated > 0) ? rates_total - prev_calculated + 1 : rates_total - InpHmaPeriod * 2;
   if(limit > rates_total - 1) limit = rates_total - 1;

   // Main calculation loop
   for(int i = limit; i >= 0; i--)
   {
      // Calculate current and previous HMA
      double hma     = CalculateHMA(i, InpHmaPeriod, close);
      double prev_hma = (i + 1 < rates_total) ? CalculateHMA(i + 1, InpHmaPeriod, close) : hma;
      double atr     = atrValues[i];

      double upper = hma + (atr * InpAtrMult);
      double lower = hma - (atr * InpAtrMult);

      UpperBandBuffer[i] = upper;
      LowerBandBuffer[i] = lower;

      // Color mapping for HMA line
      if(hma >= prev_hma)
      {
         HmaUpBuffer[i] = hma;
         HmaDnBuffer[i] = EMPTY_VALUE;
      }
      else
      {
         HmaDnBuffer[i] = hma;
         HmaUpBuffer[i] = EMPTY_VALUE;
      }

      // Reset signal buffers
      BuySignalBuffer[i]  = EMPTY_VALUE;
      SellSignalBuffer[i] = EMPTY_VALUE;

      // Evaluate signals strictly on bar [1] to avoid repainting during real-time formation
      if(i == 1)
      {
         bool isBullish = (hma > prev_hma);
         bool isBearish = (hma < prev_hma);
         
         bool longSignal  = (close[1] <= lower && isBullish);
         bool shortSignal = (close[1] >= upper && isBearish);

         if(longSignal)
         {
            BuySignalBuffer[1] = low[1] - (atr * 0.5);
            if(InpUseSound) PlaySound("alert.wav");
         }
         else if(shortSignal)
         {
            SellSignalBuffer[1] = high[1] + (atr * 0.5);
            if(InpUseSound) PlaySound("alert.wav");
         }
      }
   }

   return(rates_total);
}

//+------------------------------------------------------------------+
//| Custom Hull Moving Average Calculation Function                  |
//+------------------------------------------------------------------+
double CalculateHMA(int shift, int period, const double &price_array[])
{
   int halfPeriod = (int)MathRound(period / 2);
   int sqrtPeriod = (int)MathRound(MathSqrt(period));
   
   double wma_half = CalculateWMA(shift, halfPeriod, price_array);
   double wma_full = CalculateWMA(shift, period, price_array);
   
   double diff = 2.0 * wma_half - wma_full;
   
   double temp_array[];
   ArrayResize(temp_array, sqrtPeriod + 5);
   
   for(int i = 0; i <= sqrtPeriod; i++)
   {
      int s = shift + i;
      double wh = CalculateWMA(s, halfPeriod, price_array);
      double wf = CalculateWMA(s, period, price_array);
      temp_array[i] = 2.0 * wh - wf;
   }
   
   double hma = 0;
   double weightSum = 0;
   for(int i = 0; i < sqrtPeriod; i++)
   {
      int weight = sqrtPeriod - i;
      hma += temp_array[i] * weight;
      weightSum += weight;
   }
   
   return (weightSum > 0) ? (hma / weightSum) : diff;
}

//+------------------------------------------------------------------+
//| Weighted Moving Average (WMA) Helper                             |
//+------------------------------------------------------------------+
double CalculateWMA(int shift, int period, const double &price_array[])
{
   double sum = 0;
   double weightSum = 0;
   for(int i = 0; i < period; i++)
   {
      int weight = period - i;
      sum += price_array[shift + i] * weight;
      weightSum += weight;
   }
   return (weightSum > 0) ? (sum / weightSum) : price_array[shift];
}

Code: Select all

using System;
using cAlgo.API;
using cAlgo.API.Internals;
using cAlgo.API.Indicators;

namespace cAlgo
{
    [Indicator(IsOverlay = true, TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class XagsScalpPro : Indicator
    {
        [Parameter("HMA Period", DefaultValue = 9, MinValue = 1)]
        public int HmaPeriod { get; set; }

        [Parameter("ATR Period", DefaultValue = 14, MinValue = 1)]
        public int AtrPeriod { get; set; }

        [Parameter("ATR Multiplier", DefaultValue = 1.5, MinValue = 0.1, Step = 0.1)]
        public double AtrMult { get; set; }

        [Parameter("Enable Alerts", DefaultValue = true)]
        public bool EnableAlerts { get; set; }

        [Output("HMA Up", LineColor = "Lime", PlotType = PlotType.Line, Thickness = 2)]
        public IndicatorDataSeries HmaUp { get; set; }

        [Output("HMA Down", LineColor = "Red", PlotType = PlotType.Line, Thickness = 2)]
        public IndicatorDataSeries HmaDn { get; set; }

        [Output("Upper Band", LineColor = "DodgerBlue", PlotType = PlotType.Line, LineStyle = LineStyle.Dash, Thickness = 1)]
        public IndicatorDataSeries UpperBand { get; set; }

        [Output("Lower Band", LineColor = "DodgerBlue", PlotType = PlotType.Line, LineStyle = LineStyle.Dash, Thickness = 1)]
        public IndicatorDataSeries LowerBand { get; set; }

        [Output("Buy Signal", PlotType = PlotType.Points, Color = "Lime", Thickness = 3)]
        public IndicatorDataSeries BuySignal { get; set; }

        [Output("Sell Signal", PlotType = PlotType.Points, Color = "Red", Thickness = 3)]
        public IndicatorDataSeries SellSignal { get; set; }

        private HullMovingAverage _hma;
        private AverageTrueRange _atr;

        protected override void Initialize()
        {
            _hma = Indicators.GetIndicator<HullMovingAverage>(MarketSeries.Close, HmaPeriod);
            _atr = Indicators.GetIndicator<AverageTrueRange>(AtrPeriod, MovingAverageType.Simple);
        }

        public override void Calculate(int index)
        {
            double hmaValue = _hma.Result[index];
            double prevHma = index > 0 ? _hma.Result[index - 1] : hmaValue;
            double atrValue = _atr.Result[index];

            UpperBand[index] = hmaValue + (atrValue * AtrMult);
            LowerBand[index] = hmaValue - (atrValue * AtrMult);

            // Color Coding HMA
            if (hmaValue >= prevHma)
            {
                HmaUp[index] = hmaValue;
                HmaDn[index] = double.NaN;
            }
            else
            {
                HmaDn[index] = hmaValue;
                HmaUp[index] = double.NaN;
            }

            // Zero-repainting signal execution evaluated strictly on the closed bar [index - 1]
            if (index == MarketSeries.Close.Count - 2)
            {
                bool isBullish = hmaValue > prevHma;
                bool isBearish = hmaValue < prevHma;

                bool longSignal = MarketSeries.Close[index] <= LowerBand[index] && isBullish;
                bool shortSignal = MarketSeries.Close[index] >= UpperBand[index] && isBearish;

                if (longSignal)
                {
                    BuySignal[index] = MarketSeries.Low[index] - (atrValue * 0.5);
                    if (EnableAlerts)
                    {
                        Notifications.PlaySound("alert.wav");
                    }
                }
                else if (shortSignal)
                {
                    SellSignal[index] = MarketSeries.High[index] + (atrValue * 0.5);
                    if (EnableAlerts)
                    {
                        Notifications.PlaySound("alert.wav");
                    }
                }
            }
        }
    }
}