forex-scalping.com

Code: Select all

//+------------------------------------------------------------------+
//|                                     AUDUSD_Overlap_Initiative.mq4 |
//|             Tape Read Monitor: Initiative Shift & Failed Pushbacks|
//+------------------------------------------------------------------+
#property strict

//--- Inputs
input string   Tape_Settings       = "--- Tape Read Checklist ---";
input int      OverlapStartHour    = 13; // Server hour overlap starts (e.g., 13:00)
input int      OverlapEndHour      = 17; // Server hour overlap ends (e.g., 17:00)
input int      MaxSpreadPoints     = 12; // Maximum acceptable spread in points (tax filter)

input string   Asia_Settings       = "--- Asia Inventory ---";
input int      AsiaStartHour       = 0;  // Server hour Asia starts
input int      AsiaEndHour         = 8;  // Server hour Asia ends

input string   Momentum_Settings   = "--- Initiative Shift ---";
input int      PaceCandles         = 3;  // Number of consecutive candles to confirm pace
input double   RejectionThreshold  = 0.25; // Close must be in top/bottom 25% to prove failed pushback

//--- Global Variables
double AsiaHigh = 0.0;
double AsiaLow = 0.0;
datetime LastAlertTime = 0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    Print("AUDUSD Overlap Monitor Initialized. Waiting for Overlap...");
    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
    // 1. Check if we are in the London-NY Overlap
    int currentHour = TimeHour(TimeCurrent());
    if(currentHour < OverlapStartHour || currentHour >= OverlapEndHour) return;

    // 2. Check Spread (Is it a tradeable market or a tax?)
    double currentSpread = MarketInfo(Symbol(), MODE_SPREAD);
    if(currentSpread > MaxSpreadPoints) return; // Spread is too wide, ignore

    // Calculate Asia Inventory if not done for the day
    CalculateAsiaRange();

    // 3. Look for Initiative Shift (Pace + Failed Pushbacks)
    int shiftDirection = CheckInitiativeShift();

    // 4. Alert if conditions are met (Limit to 1 alert per candle)
    if(shiftDirection != 0 && Time[0] != LastAlertTime)
    {
        // 5. Check if we have reclaimed and held outside Asia
        bool clearedAsia = false;
        if(shiftDirection == 1 && Close[1] > AsiaHigh) clearedAsia = true;
        if(shiftDirection == -1 && Close[1] < AsiaLow) clearedAsia = true;

        if(clearedAsia)
        {
            string dir = (shiftDirection == 1) ? "BULLISH" : "BEARISH";
            Alert("AUDUSD ", dir, " Initiative Shift! Spread: ", currentSpread, 
                  " | Asia Cleared. CHECK CORRELATED RISK ASSETS!");
            LastAlertTime = Time[0];
        }
    }
}

//+------------------------------------------------------------------+
//| Calculates the High and Low of the Asian Session                 |
//+------------------------------------------------------------------+
void CalculateAsiaRange()
{
    // Find the bar shift for the start and end of Asia today
    int shiftStart = iBarShift(Symbol(), PERIOD_H1, iTime(Symbol(), PERIOD_D1, 0) + AsiaStartHour * 3600);
    int shiftEnd   = iBarShift(Symbol(), PERIOD_H1, iTime(Symbol(), PERIOD_D1, 0) + AsiaEndHour * 3600);
    
    // Safety check
    if(shiftStart == -1 || shiftEnd == -1) return;

    int highestBar = iHighest(Symbol(), PERIOD_H1, MODE_HIGH, shiftStart - shiftEnd + 1, shiftEnd);
    int lowestBar  = iLowest(Symbol(), PERIOD_H1, MODE_LOW, shiftStart - shiftEnd + 1, shiftEnd);

    AsiaHigh = iHigh(Symbol(), PERIOD_H1, highestBar);
    AsiaLow  = iLow(Symbol(), PERIOD_H1, lowestBar);
}

//+------------------------------------------------------------------+
//| Checks for persistent pace and failed pushbacks                  |
//| Returns: 1 (Bullish), -1 (Bearish), 0 (None/Unclear)             |
//+------------------------------------------------------------------+
int CheckInitiativeShift()
{
    int bullCount = 0;
    int bearCount = 0;

    // Analyze the last N closed candles for pace and pushback absorption
    for(int i = 1; i <= PaceCandles; i++)
    {
        double open  = Open[i];
        double close = Close[i];
        double high  = High[i];
        double low   = Low[i];
        double range = high - low;
        
        if(range == 0) continue;

        // Bullish Pace: Closing higher, and closing near the high (bears tried to push down, failed)
        if(close > open)
        {
            double rejectionZone = high - (range * RejectionThreshold);
            if(close >= rejectionZone) bullCount++;
        }
        
        // Bearish Pace: Closing lower, and closing near the low (bulls tried to push up, failed)
        if(close < open)
        {
            double rejectionZone = low + (range * RejectionThreshold);
            if(close <= rejectionZone) bearCount++;
        }
    }

    if(bullCount == PaceCandles) return 1;  // Persistent bullish pace
    if(bearCount == PaceCandles) return -1; // Persistent bearish pace

    return 0; // Unclear initiative, wait.
}
//+------------------------------------------------------------------+

Code: Select all

//+------------------------------------------------------------------+
//|                                     AUDUSD_Overlap_Initiative.mq5 |
//|             Tape Read Monitor: Initiative Shift & Failed Pushbacks|
//+------------------------------------------------------------------+
#property strict

//--- Inputs
input string   Tape_Settings       = "--- Tape Read Checklist ---";
input int      OverlapStartHour    = 13; // Server hour overlap starts (e.g., 13:00)
input int      OverlapEndHour      = 17; // Server hour overlap ends (e.g., 17:00)
input int      MaxSpreadPoints     = 12; // Maximum acceptable spread in points (tax filter)

input string   Asia_Settings       = "--- Asia Inventory ---";
input int      AsiaStartHour       = 0;  // Server hour Asia starts
input int      AsiaEndHour         = 8;  // Server hour Asia ends

input string   Momentum_Settings   = "--- Initiative Shift ---";
input int      PaceCandles         = 3;  // Number of consecutive candles to confirm pace
input double   RejectionThreshold  = 0.25; // Close must be in top/bottom 25% to prove failed pushback

//--- Global Variables
double   AsiaHigh = 0.0;
double   AsiaLow = 0.0;
datetime LastAlertTime = 0;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    Print("MQL5 AUDUSD Overlap Monitor Initialized. Waiting for Overlap...");
    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
    // 1. Check if we are in the London-NY Overlap
    MqlDateTime dt;
    TimeCurrent(dt);
    if(dt.hour < OverlapStartHour || dt.hour >= OverlapEndHour) return;

    // 2. Check Spread (Is it a tradeable market or a tax?)
    long currentSpread = SymbolInfoInteger(_Symbol, SYMBOL_SPREAD);
    if(currentSpread > MaxSpreadPoints) return; // Spread is too wide, ignore

    // Calculate Asia Inventory for today
    CalculateAsiaRange();

    // 3. Look for Initiative Shift (Pace + Failed Pushbacks)
    int shiftDirection = CheckInitiativeShift();

    // 4. Alert if conditions are met (Limit to 1 alert per candle)
    datetime currentTimeArray[];
    if(CopyTime(_Symbol, PERIOD_CURRENT, 0, 1, currentTimeArray) <= 0) return;
    datetime currentCandleTime = currentTimeArray[0];

    if(shiftDirection != 0 && currentCandleTime != LastAlertTime)
    {
        // 5. Check if we have reclaimed and held outside Asia
        double close1Array[];
        if(CopyClose(_Symbol, PERIOD_CURRENT, 1, 1, close1Array) <= 0) return;
        double lastClose = close1Array[0];

        bool clearedAsia = false;
        if(shiftDirection == 1 && lastClose > AsiaHigh) clearedAsia = true;
        if(shiftDirection == -1 && lastClose < AsiaLow) clearedAsia = true;

        if(clearedAsia)
        {
            string dir = (shiftDirection == 1) ? "BULLISH" : "BEARISH";
            Alert("AUDUSD ", dir, " Initiative Shift! Spread: ", currentSpread, 
                  " pts | Asia Cleared. CHECK CORRELATED RISK ASSETS!");
            LastAlertTime = currentCandleTime; // Prevent spam on the same candle
        }
    }
}

//+------------------------------------------------------------------+
//| Calculates the High and Low of today's Asian Session             |
//+------------------------------------------------------------------+
void CalculateAsiaRange()
{
    // Set up start and end times for today's Asia session
    MqlDateTime startDt, endDt;
    TimeCurrent(startDt);
    
    startDt.hour = AsiaStartHour; 
    startDt.min = 0; 
    startDt.sec = 0;
    
    endDt = startDt;
    endDt.hour = AsiaEndHour;
    
    datetime startTime = StructToTime(startDt);
    datetime endTime = StructToTime(endDt);
    
    // Copy the high and low data from the H1 timeframe during Asian hours
    double highArr[], lowArr[];
    int copiedH = CopyHigh(_Symbol, PERIOD_H1, startTime, endTime, highArr);
    int copiedL = CopyLow(_Symbol, PERIOD_H1, startTime, endTime, lowArr);
    
    // Find the max and min values within those copied arrays
    if(copiedH > 0 && copiedL > 0)
    {
        AsiaHigh = highArr[ArrayMaximum(highArr)];
        AsiaLow  = lowArr[ArrayMinimum(lowArr)];
    }
}

//+------------------------------------------------------------------+
//| Checks for persistent pace and failed pushbacks                  |
//| Returns: 1 (Bullish), -1 (Bearish), 0 (None/Unclear)             |
//+------------------------------------------------------------------+
int CheckInitiativeShift()
{
    // Fetch the last N closed candles
    MqlRates rates[];
    ArraySetAsSeries(rates, true); // Index 0 becomes the most recently closed candle
    
    if(CopyRates(_Symbol, PERIOD_CURRENT, 1, PaceCandles, rates) < PaceCandles) 
        return 0; // Not enough data
        
    int bullCount = 0;
    int bearCount = 0;

    // Analyze the copied candles for pace and pushback absorption
    for(int i = 0; i < PaceCandles; i++)
    {
        double open  = rates[i].open;
        double close = rates[i].close;
        double high  = rates[i].high;
        double low   = rates[i].low;
        double range = high - low;
        
        if(range == 0) continue; // Prevent division by zero

        // Bullish Pace: Closing higher, and closing near the high
        if(close > open)
        {
            double rejectionZone = high - (range * RejectionThreshold);
            if(close >= rejectionZone) bullCount++;
        }
        
        // Bearish Pace: Closing lower, and closing near the low
        if(close < open)
        {
            double rejectionZone = low + (range * RejectionThreshold);
            if(close <= rejectionZone) bearCount++;
        }
    }

    if(bullCount == PaceCandles) return 1;  // Persistent bullish pace
    if(bearCount == PaceCandles) return -1; // Persistent bearish pace

    return 0; // Unclear initiative, wait.
}
//+------------------------------------------------------------------+

Code: Select all

//@version=5
indicator("AUDUSD Overlap Initiative Monitor", overlay=true, max_labels_count=50)

// --- Inputs ---
grpTime = "--- Time Settings ---"
asiaSession = input.session("0000-0800", "Asia Session", group=grpTime)
overlapSession = input.session("1300-1700", "London-NY Overlap Session", group=grpTime)
sessionZone = input.string("UTC", "Timezone", group=grpTime, tooltip="Ensure this matches your broker/chart timezone. Forex is typically best tracked in UTC.")

grpTape = "--- Tape Read / Initiative Shift ---"
paceCandles = input.int(3, "Pace Candles (N)", minval=1, group=grpTape)
rejThreshold = input.float(0.25, "Rejection Threshold (0.0 to 1.0)", step=0.05, group=grpTape, tooltip="0.25 means price must close in the top/bottom 25% of the candle's range to prove failed pushback.")

// --- Session & Asia Inventory Logic ---
inAsia = not na(time(timeframe.period, asiaSession, sessionZone))
inOverlap = not na(time(timeframe.period, overlapSession, sessionZone))

var float asiaHigh = na
var float asiaLow = na

// Track highest high and lowest low during Asia
if inAsia and not inAsia[1]
    asiaHigh := high
    asiaLow := low
else if inAsia
    asiaHigh := math.max(asiaHigh, high)
    asiaLow := math.min(asiaLow, low)

// Visuals: Draw Asia Range and highlight the Overlap session
plot(not inAsia ? asiaHigh : na, title="Asia High", color=color.new(color.red, 40), style=plot.style_linebr, linewidth=2)
plot(not inAsia ? asiaLow : na, title="Asia Low", color=color.new(color.green, 40), style=plot.style_linebr, linewidth=2)
bgcolor(inOverlap ? color.new(color.blue, 90) : na, title="Overlap Window Background")

// --- Initiative Shift Logic ---
isBullishPace = true
isBearishPace = true

// Loop through the last N closed candles to check for persistent pace & absorption
for i = 1 to paceCandles
    rng = high[i] - low[i]
    
    // Bullish check: closed up AND closed in the top X% (bears failed to push down)
    rejZoneBull = high[i] - (rng * rejThreshold)
    if not (close[i] > open[i] and close[i] >= rejZoneBull and rng > 0)
        isBullishPace := false
        
    // Bearish check: closed down AND closed in the bottom X% (bulls failed to push up)
    rejZoneBear = low[i] + (rng * rejThreshold)
    if not (close[i] < open[i] and close[i] <= rejZoneBear and rng > 0)
        isBearishPace := false

// --- Trigger Conditions ---
// Did the last closed candle actually clear the Asia boundary?
clearedAsiaBull = close[1] > asiaHigh
clearedAsiaBear = close[1] < asiaLow

bullishShift = inOverlap and isBullishPace and clearedAsiaBull
bearishShift = inOverlap and isBearishPace and clearedAsiaBear

// Ensure we only trigger once per shift sequence
bullTrigger = bullishShift and not bullishShift[1]
bearTrigger = bearishShift and not bearishShift[1]

// --- Alerts & Chart Markers ---
plotshape(bullTrigger, title="Bullish Initiative", style=shape.triangleup, location=location.belowbar, color=color.green, size=size.normal)
plotshape(bearTrigger, title="Bearish Initiative", style=shape.triangledown, location=location.abovebar, color=color.red, size=size.normal)

if bullTrigger
    alert("AUDUSD BULLISH Initiative Shift! Asia Cleared. CHECK CORRELATED RISK ASSETS!", alert.freq_once_per_bar_close)
    
if bearTrigger
    alert("AUDUSD BEARISH Initiative Shift! Asia Cleared. CHECK CORRELATED RISK ASSETS!", alert.freq_once_per_bar_close)

Code: Select all

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

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class AUDUSDOverlapMonitor : Robot
    {
        [Parameter("Overlap Start Hour", DefaultValue = 13, Group = "Tape Read Checklist")]
        public int OverlapStartHour { get; set; }

        [Parameter("Overlap End Hour", DefaultValue = 17, Group = "Tape Read Checklist")]
        public int OverlapEndHour { get; set; }

        [Parameter("Max Spread (Pips)", DefaultValue = 1.2, Group = "Tape Read Checklist")]
        public double MaxSpreadPips { get; set; }

        [Parameter("Asia Start Hour", DefaultValue = 0, Group = "Asia Inventory")]
        public int AsiaStartHour { get; set; }

        [Parameter("Asia End Hour", DefaultValue = 8, Group = "Asia Inventory")]
        public int AsiaEndHour { get; set; }

        [Parameter("Pace Candles", DefaultValue = 3, Group = "Initiative Shift")]
        public int PaceCandles { get; set; }

        [Parameter("Rejection Threshold", DefaultValue = 0.25, Group = "Initiative Shift")]
        public double RejectionThreshold { get; set; }

        private double _asiaHigh = 0.0;
        private double _asiaLow = 0.0;
        private DateTime _lastAlertTime;

        protected override void OnStart()
        {
            Print("cTrader AUDUSD Overlap Monitor Initialized. Waiting for Overlap...");
        }

        protected override void OnTick()
        {
            // 1. Check if we are in the London-NY Overlap
            if (Server.Time.Hour < OverlapStartHour || Server.Time.Hour >= OverlapEndHour)
                return;

            // 2. Check Spread (Is it a tradeable market or a tax?)
            double currentSpreadPips = Symbol.Spread / Symbol.PipSize;
            if (currentSpreadPips > MaxSpreadPips)
                return; // Spread is too wide, ignore

            // Calculate Asia Inventory for today
            CalculateAsiaRange();

            // 3. Look for Initiative Shift (Pace + Failed Pushbacks)
            int shiftDirection = CheckInitiativeShift();

            // 4. Alert if conditions are met (Limit to 1 alert per candle)
            DateTime currentCandleTime = Bars.OpenTimes.Last(0);
            if (shiftDirection != 0 && currentCandleTime != _lastAlertTime)
            {
                // 5. Check if we have reclaimed and held outside Asia
                double lastClose = Bars.ClosePrices.Last(1);
                bool clearedAsia = false;

                if (shiftDirection == 1 && lastClose > _asiaHigh) clearedAsia = true;
                if (shiftDirection == -1 && lastClose < _asiaLow) clearedAsia = true;

                if (clearedAsia)
                {
                    string dir = shiftDirection == 1 ? "BULLISH" : "BEARISH";
                    string msg = $"AUDUSD {dir} Initiative Shift! Spread: {Math.Round(currentSpreadPips, 1)} pips | Asia Cleared.";
                    
                    // Alert actions
                    Print(msg + " CHECK CORRELATED RISK ASSETS!");
                    Notifications.PlaySound(SoundType.Ring);
                    
                    // Draw visual marker on chart
                    Color textColor = shiftDirection == 1 ? Color.LimeGreen : Color.Red;
                    Chart.DrawText($"Shift_{currentCandleTime}", msg, Bars.OpenTimes.Last(1), Bars.HighPrices.Last(1), textColor);

                    _lastAlertTime = currentCandleTime; // Prevent spam on the same candle
                }
            }
        }

        private void CalculateAsiaRange()
        {
            _asiaHigh = double.MinValue;
            _asiaLow = double.MaxValue;
            DateTime today = Server.Time.Date;

            // Look back through the closed bars to find today's Asian session highs/lows
            for (int i = 1; i < Bars.Count; i++)
            {
                DateTime barTime = Bars.OpenTimes.Last(i);

                if (barTime.Date < today) 
                    break; // Stop looking once we hit yesterday's bars

                if (barTime.Hour >= AsiaStartHour && barTime.Hour < AsiaEndHour)
                {
                    _asiaHigh = Math.Max(_asiaHigh, Bars.HighPrices.Last(i));
                    _asiaLow = Math.Min(_asiaLow, Bars.LowPrices.Last(i));
                }
            }
        }

        private int CheckInitiativeShift()
        {
            if (Bars.Count < PaceCandles + 1) return 0;

            int bullCount = 0;
            int bearCount = 0;

            // Analyze the closed candles for pace and pushback absorption
            for (int i = 1; i <= PaceCandles; i++)
            {
                double open = Bars.OpenPrices.Last(i);
                double close = Bars.ClosePrices.Last(i);
                double high = Bars.HighPrices.Last(i);
                double low = Bars.LowPrices.Last(i);
                double range = high - low;

                if (range == 0) continue;

                // Bullish Pace: Closing higher, and closing near the high
                if (close > open)
                {
                    double rejectionZone = high - (range * RejectionThreshold);
                    if (close >= rejectionZone) bullCount++;
                }

                // Bearish Pace: Closing lower, and closing near the low
                if (close < open)
                {
                    double rejectionZone = low + (range * RejectionThreshold);
                    if (close <= rejectionZone) bearCount++;
                }
            }

            if (bullCount == PaceCandles) return 1;  // Persistent bullish pace
            if (bearCount == PaceCandles) return -1; // Persistent bearish pace

            return 0; // Unclear initiative, wait.
        }
    }
}