forex-scalping.com

Code: Select all

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

namespace cAlgo.Indicators
{
    [Indicator(IsOverlay = true, TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class M1LiquidityReclaim : Indicator
    {
        [Parameter("Swing Left (Bars)", DefaultValue = 15, Group = "Market Structure")]
        public int LeftBars { get; set; }

        [Parameter("Swing Right (Bars)", DefaultValue = 5, Group = "Market Structure")]
        public int RightBars { get; set; }

        [Parameter("Min Reclaim % of Candle Range", DefaultValue = 0.35, Step = 0.05, Group = "Reclaim Mechanics")]
        public double ReclaimPct { get; set; }

        [Parameter("Require Next Candle Confirmation", DefaultValue = true, Group = "Reclaim Mechanics")]
        public bool RequireConf { get; set; }

        [Parameter("Filter by Session", DefaultValue = true, Group = "Session")]
        public bool UseSession { get; set; }

        [Parameter("Session Start (HH:mm)", DefaultValue = "08:00", Group = "Session")]
        public string SessionStart { get; set; }

        [Parameter("Session End (HH:mm)", DefaultValue = "16:00", Group = "Session")]
        public string SessionEnd { get; set; }

        // Outputs exposed for cBot algorithmic integration
        [Output("Bullish Reclaim", LineColor = "DodgerBlue", PlotType = PlotType.Points, Thickness = 3)]
        public IndicatorDataSeries BullBuffer { get; set; }

        [Output("Bearish Reclaim", LineColor = "Red", PlotType = PlotType.Points, Thickness = 3)]
        public IndicatorDataSeries BearBuffer { get; set; }

        private TimeSpan _start;
        private TimeSpan _end;

        protected override void Initialize()
        {
            TimeSpan.TryParse(SessionStart, out _start);
            TimeSpan.TryParse(SessionEnd, out _end);
        }

        public override void Calculate(int index)
        {
            // Initialize empty buffers to prevent false signals in cBots
            BullBuffer[index] = double.NaN;
            BearBuffer[index] = double.NaN;

            string lineNameL = "L_Purge_Line_" + index;
            string iconNameL = "L_Purge_Icon_" + index;
            string lineNameH = "H_Purge_Line_" + index;
            string iconNameH = "H_Purge_Icon_" + index;

            // Wait for enough history to form the left/right pivots + the 2-candle setup
            if (index < LeftBars + RightBars + 2)
                return;

            if (!InSession(Bars.OpenTimes[index]))
            {
                RemoveObjectIfExists(lineNameL); RemoveObjectIfExists(iconNameL);
                RemoveObjectIfExists(lineNameH); RemoveObjectIfExists(iconNameH);
                return;
            }

            int sweepIdx = index - 1;
            double c1_high = Bars.HighPrices[sweepIdx];
            double c1_low = Bars.LowPrices[sweepIdx];
            double c1_close = Bars.ClosePrices[sweepIdx];
            
            double c1_range = c1_high - c1_low;
            if (c1_range == 0) c1_range = Symbol.PipSize;

            double lastPL = GetLastPivotLow(sweepIdx);
            double lastPH = GetLastPivotHigh(sweepIdx);

            bool isBullSetup = false;
            bool isBearSetup = false;

            // 1. Evaluate Bullish Purge
            if (!double.IsNaN(lastPL) && c1_low < lastPL && c1_close > lastPL)
            {
                double bullCloseDist = c1_close - lastPL;
                bool validBullClose = bullCloseDist >= (c1_range * ReclaimPct);
                
                // Confirming candle (live forming) must hold level and close favorably
                bool bullConf = Bars.ClosePrices[index] > lastPL && Bars.ClosePrices[index] >= c1_close;

                if (validBullClose && (!RequireConf || bullConf))
                {
                    isBullSetup = true;
                    BullBuffer[index] = Bars.LowPrices[index] - (Symbol.PipSize * 5);
                    
                    var line = Chart.DrawTrendLine(lineNameL, Bars.OpenTimes[sweepIdx], lastPL, Bars.OpenTimes[index], lastPL, Color.DodgerBlue);
                    line.LineStyle = LineStyle.Lines;
                    
                    Chart.DrawIcon(iconNameL, ChartIconType.UpArrow, Bars.OpenTimes[index], Bars.LowPrices[index] - (Symbol.PipSize * 15), Color.DodgerBlue);
                }
            }

            // 2. Evaluate Bearish Purge
            if (!double.IsNaN(lastPH) && c1_high > lastPH && c1_close < lastPH)
            {
                double bearCloseDist = lastPH - c1_close;
                bool validBearClose = bearCloseDist >= (c1_range * ReclaimPct);
                bool bearConf = Bars.ClosePrices[index] < lastPH && Bars.ClosePrices[index] <= c1_close;

                if (validBearClose && (!RequireConf || bearConf))
                {
                    isBearSetup = true;
                    BearBuffer[index] = Bars.HighPrices[index] + (Symbol.PipSize * 5);

                    var line = Chart.DrawTrendLine(lineNameH, Bars.OpenTimes[sweepIdx], lastPH, Bars.OpenTimes[index], lastPH, Color.Red);
                    line.LineStyle = LineStyle.Lines;

                    Chart.DrawIcon(iconNameH, ChartIconType.DownArrow, Bars.OpenTimes[index], Bars.HighPrices[index] + (Symbol.PipSize * 15), Color.Red);
                }
            }

            // Intra-bar cleanup: if price fluctuates and invalidates the confirmation, remove the visual objects
            if (!isBullSetup) 
            {
                RemoveObjectIfExists(lineNameL);
                RemoveObjectIfExists(iconNameL);
            }
            if (!isBearSetup) 
            {
                RemoveObjectIfExists(lineNameH);
                RemoveObjectIfExists(iconNameH);
            }
        }

        private void RemoveObjectIfExists(string name)
        {
            var obj = Chart.FindObject(name);
            if (obj != null)
                Chart.RemoveObject(name);
        }

        private bool InSession(DateTime time)
        {
            if (!UseSession) return true;
            
            TimeSpan current = time.TimeOfDay;
            if (_start < _end)
                return current >= _start && current <= _end;
            else // Handles crossover periods (e.g., 22:00 to 02:00)
                return current >= _start || current <= _end;
        }

        // Dynamically search backward for the most recent valid Pivot Low
        private double GetLastPivotLow(int sweepIdx)
        {
            for (int p = sweepIdx - RightBars - 1; p >= LeftBars; p--)
            {
                bool isPivot = true;
                
                for (int k = 1; k <= LeftBars; k++)
                    if (Bars.LowPrices[p - k] <= Bars.LowPrices[p]) { isPivot = false; break; }
                
                if (!isPivot) continue;

                for (int k = 1; k <= RightBars; k++)
                    if (Bars.LowPrices[p + k] <= Bars.LowPrices[p]) { isPivot = false; break; }
                
                if (isPivot) return Bars.LowPrices[p];
            }
            return double.NaN;
        }

        // Dynamically search backward for the most recent valid Pivot High
        private double GetLastPivotHigh(int sweepIdx)
        {
            for (int p = sweepIdx - RightBars - 1; p >= LeftBars; p--)
            {
                bool isPivot = true;
                
                for (int k = 1; k <= LeftBars; k++)
                    if (Bars.HighPrices[p - k] >= Bars.HighPrices[p]) { isPivot = false; break; }
                
                if (!isPivot) continue;

                for (int k = 1; k <= RightBars; k++)
                    if (Bars.HighPrices[p + k] >= Bars.HighPrices[p]) { isPivot = false; break; }
                
                if (isPivot) return Bars.HighPrices[p];
            }
            return double.NaN;
        }
    }
}