forex-scalping.com

Code: Select all

//@version=5
indicator("News Blackout Zone & Volatility Filter", overlay=true)

// --- Inputs ---
newsSession = input.session("0825-0845", title="High-Impact News Window", tooltip="Time window to sit out (e.g., 08:25-08:45 for 8:30 AM EST news)")
tz = input.string("America/New_York", title="Timezone", tooltip="Align this with the economic calendar")
volMultiplier = input.float(3.0, title="Abnormal Volatility Multiplier (ATR)", step=0.5)

// --- Logic ---
// 1. Determine if the current bar is inside the news blackout window
inNewsWindow = time(timeframe.period, newsSession, tz)

// Highlight the blackout zone on the chart to visually enforce the "sit out" rule
bgcolor(inNewsWindow ? color.new(color.red, 85) : na, title="News Blackout Background")

// 2. Measure abnormal candle sizes relative to recent history (simulating the 'chaos')
atr = ta.atr(14)
abnormalVolatility = (high - low) > (atr * volMultiplier)

// Flag massive spread/slippage spikes that occur during the news window
plotshape(abnormalVolatility and inNewsWindow, style=shape.xcross, color=color.red, location=location.abovebar, size=size.small, title="News Volatility Spike")

// --- Strategy Integration Example ---
// If you are writing a strategy script, you would use the inNewsWindow variable like this:
//
// validEntryCondition = ta.crossover(ta.sma(close, 10), ta.sma(close, 20))
// 
// // Only enter if we are NOT in the news window
// if (validEntryCondition and not inNewsWindow)
//     strategy.entry("Long", strategy.long)
//
// // Force close open positions 5 minutes before the news hits to avoid slippage
// if (inNewsWindow)
//     strategy.close_all(comment="Flattening for News Liquidity Drain")

Code: Select all

// --- Inputs ---
input int    NewsStartHour   = 8;  // Broker server hour (e.g., Market Watch time)
input int    NewsStartMinute = 25;
input int    NewsEndHour     = 8;
input int    NewsEndMinute   = 45;
input double VolMultiplier   = 3.0;
input int    AtrPeriod       = 14;

// --- Logic ---
bool IsInNewsWindow()
{
    MqlDateTime tm;
    TimeToStruct(TimeCurrent(), tm);
    
    int currentMins = tm.hour * 60 + tm.min;
    int startMins = NewsStartHour * 60 + NewsStartMinute;
    int endMins = NewsEndHour * 60 + NewsEndMinute;
    
    if (startMins <= endMins)
        return (currentMins >= startMins && currentMins <= endMins);
    else // Handles windows that cross midnight
        return (currentMins >= startMins || currentMins <= endMins);
}

bool IsAbnormalVolatility()
{
    // Uses the previous closed candle (index 1) to check for spread/liquidity chaos
    double atr = iATR(Symbol(), PERIOD_CURRENT, AtrPeriod, 1);
    double candleSize = High[1] - Low[1];
    
    return (candleSize > (atr * VolMultiplier));
}

// --- Strategy Integration ---
void OnTick()
{
    if (IsInNewsWindow())
    {
        // 1. Execute logic to flatten open exposure here
        // 2. Reject all new entry signals
        return; 
    }
    
    if (IsAbnormalVolatility())
    {
        // Market is still experiencing spread spikes; block entries
        return;
    }
    
    // Normal trading logic proceeds...
}

Code: Select all

// --- Inputs ---
input int    NewsStartHour   = 8;  
input int    NewsStartMinute = 25;
input int    NewsEndHour     = 8;
input int    NewsEndMinute   = 45;
input double VolMultiplier   = 3.0;
input int    AtrPeriod       = 14;

int atrHandle = INVALID_HANDLE;

// --- Initialization ---
int OnInit()
{
    atrHandle = iATR(_Symbol, PERIOD_CURRENT, AtrPeriod);
    if(atrHandle == INVALID_HANDLE) 
    {
        Print("Failed to create ATR handle");
        return(INIT_FAILED);
    }
    return(INIT_SUCCEEDED);
}

// --- Logic ---
bool IsInNewsWindow()
{
    MqlDateTime tm;
    TimeToStruct(TimeCurrent(), tm);
    
    int currentMins = tm.hour * 60 + tm.min;
    int startMins = NewsStartHour * 60 + NewsStartMinute;
    int endMins = NewsEndHour * 60 + NewsEndMinute;
    
    if (startMins <= endMins)
        return (currentMins >= startMins && currentMins <= endMins);
    else 
        return (currentMins >= startMins || currentMins <= endMins);
}

bool IsAbnormalVolatility()
{
    double atrArray[];
    MqlRates rates[];
    
    ArraySetAsSeries(atrArray, true);
    ArraySetAsSeries(rates, true);
    
    // Retrieve ATR and price data for the last closed candle (index 1)
    if(CopyBuffer(atrHandle, 0, 1, 1, atrArray) <= 0) return false;
    if(CopyRates(_Symbol, PERIOD_CURRENT, 1, 1, rates) <= 0) return false;
    
    double atr = atrArray[0];
    double candleSize = rates[0].high - rates[0].low;
    
    return (candleSize > (atr * VolMultiplier));
}

// --- Strategy Integration ---
void OnTick()
{
    if (IsInNewsWindow())
    {
        // 1. Execute logic to flatten open exposure here
        // 2. Reject all new entry signals
        return; 
    }
    
    if (IsAbnormalVolatility())
    {
        // Market is still experiencing spread spikes; block entries
        return;
    }
    
    // Normal trading logic proceeds...
}

Code: Select all

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

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class NewsVolatilityFilter : Robot
    {
        // --- Inputs / Parameters ---
        [Parameter("News Start Hour", DefaultValue = 8, Group = "News Window")]
        public int NewsStartHour { get; set; }

        [Parameter("News Start Min", DefaultValue = 25, Group = "News Window")]
        public int NewsStartMinute { get; set; }

        [Parameter("News End Hour", DefaultValue = 8, Group = "News Window")]
        public int NewsEndHour { get; set; }

        [Parameter("News End Min", DefaultValue = 45, Group = "News Window")]
        public int NewsEndMinute { get; set; }

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

        [Parameter("ATR Multiplier", DefaultValue = 3.0, Group = "Volatility Filter")]
        public double VolMultiplier { get; set; }

        private AverageTrueRange _atr;

        protected override void OnStart()
        {
            // Initialize ATR using Wilder's smoothing for accuracy in volatility measurement
            _atr = Indicators.AverageTrueRange(AtrPeriod, MovingAverageType.WilderSmoothing);
        }

        protected override void OnTick()
        {
            if (IsInNewsWindow())
            {
                // 1. Flatten exposure before the liquidity drain (optional usage below)
                // FlattenPositions();
                
                // 2. Reject all new entry signals
                return; 
            }
            
            if (IsAbnormalVolatility())
            {
                // Market is still experiencing spread spikes; block entries
                return;
            }
            
            // Normal trading logic proceeds...
        }

        private bool IsInNewsWindow()
        {
            // Use Server.Time to align perfectly with the broker's clock (Market Watch)
            int currentMins = Server.Time.Hour * 60 + Server.Time.Minute;
            int startMins = NewsStartHour * 60 + NewsStartMinute;
            int endMins = NewsEndHour * 60 + NewsEndMinute;
            
            if (startMins <= endMins)
                return (currentMins >= startMins && currentMins <= endMins);
            else // Handles blackout windows that cross midnight
                return (currentMins >= startMins || currentMins <= endMins);
        }

        private bool IsAbnormalVolatility()
        {
            // Ensure there is enough historical data loaded
            if (Bars.Count < 2) return false;

            // Measure the previous closed candle to avoid false positives from mid-candle tick spikes
            double candleSize = Bars.HighPrices.Last(1) - Bars.LowPrices.Last(1);
            double atr = _atr.Result.Last(1);
            
            return (candleSize > (atr * VolMultiplier));
        }

        // Example utility to clear market exposure
        private void FlattenPositions()
        {
            foreach (var position in Positions)
            {
                if (position.SymbolName == SymbolName)
                {
                    ClosePosition(position);
                }
            }
        }
    }
}