forex-scalping.com

Code: Select all

//@version=5
indicator("Institutional MTF ER Regime Filter", shorttitle="Inst. ER Regime", overlay=false)

// =========================================================================
// INPUTS & ARCHITECTURE
// =========================================================================
grp_er = "Efficiency Ratio Engine"
i_len      = input.int(14, "ER Lookback", minval=1, group=grp_er)
i_smooth   = input.int(3, "Signal Smoothing (EMA)", minval=1, group=grp_er, tooltip="Applies an EMA to the ER to prevent threshold flickering.")

grp_mtf = "Multi-Timeframe & Execution"
i_htf      = input.timeframe("15", "HTF Vector", group=grp_mtf)
i_strict   = input.bool(true, "Strict Non-Repainting", group=grp_mtf, tooltip="Locks evaluation to the last fully closed HTF bar.")

grp_regime = "Regime Thresholds"
i_th_chop  = input.float(0.25, "Chop Ceiling (Max)", step=0.05, group=grp_regime)
i_th_trend = input.float(0.40, "Trend Floor (Min)", step=0.05, group=grp_regime)

grp_ui = "UI & Automation"
i_show_hud = input.bool(true, "Show Dashboard HUD", group=grp_ui)

// =========================================================================
// CORE ENGINE: TUPLE-BASED CALCULATION
// =========================================================================
// Calculating ER, Smoothed ER, and Direction simultaneously
f_regime_engine(len, smooth) =>
    change = close - close[len]
    vol    = math.sum(math.abs(close - close[1]), len)
    
    // Raw Efficiency
    raw_er = vol == 0 ? 0 : math.abs(change) / vol
    
    // Smoothed Signal (Prevents micro-whipsaws around the threshold)
    sig_er = ta.ema(raw_er, smooth)
    
    // Vector (1 = Bullish flow, -1 = Bearish flow)
    dir    = change > 0 ? 1 : change < 0 ? -1 : 0
    
    [raw_er, sig_er, dir]

// Single request.security call returning a Tuple (Highly optimized for Pine VM)
[htf_raw, htf_sig, htf_dir] = request.security(
     syminfo.tickerid, 
     i_htf, 
     i_strict ? f_regime_engine(i_len, i_smooth)[1] : f_regime_engine(i_len, i_smooth), 
     lookahead = i_strict ? barmerge.lookahead_on : barmerge.lookahead_off
 )

// =========================================================================
// STATE MACHINE & ROUTING
// =========================================================================
// Define the 3 operational states
bool is_chop  = htf_sig < i_th_chop
bool is_trend = htf_sig >= i_th_trend
bool is_trans = not is_chop and not is_trend

// Color routing based on Vector + State
color c_bull_strong = color.new(#00E676, 10)
color c_bear_strong = color.new(#FF5252, 10)
color c_trans       = color.new(#FFB74D, 30) // Orange for transition/caution
color c_chop        = color.new(#787B86, 60)

color state_color = is_chop ? c_chop : is_trans ? c_trans : (htf_dir == 1 ? c_bull_strong : c_bear_strong)

// =========================================================================
// VISUALIZATION
// =========================================================================
// Histogram mapping the smoothed ER
plot(htf_sig, "Regime Signal", color=state_color, style=plot.style_columns, linewidth=2)
plot(htf_raw, "Raw ER (Ghost)", color=color.new(state_color, 80), style=plot.style_line) // Faint underlying raw data

// Threshold barriers
hline(i_th_trend, "Trend Floor", color=color.new(#00E676, 50), linestyle=hline.style_dashed)
hline(i_th_chop, "Chop Ceiling", color=color.new(#FF5252, 50), linestyle=hline.style_dotted)

// Main chart background integration
bgcolor(is_trend ? color.new(state_color, 90) : na, title="Trend Lock Highlight")

// =========================================================================
// HEADS UP DISPLAY (HUD)
// =========================================================================
var table hud = table.new(position.top_right, 2, 2, bgcolor=color.new(#131722, 20), border_width=1, border_color=color.new(#363A45, 50))

if i_show_hud and barstate.islast
    string regime_str = is_chop ? "STAND ASIDE (CHOP)" : is_trans ? "CAUTION (BUILDING)" : "ACTIVE (EFFICIENT)"
    string dir_str    = htf_dir == 1 ? "BULLISH" : htf_dir == -1 ? "BEARISH" : "FLAT"
    
    table.cell(hud, 0, 0, "HTF REGIME", text_color=color.gray, text_size=size.small, text_halign=text.align_left)
    table.cell(hud, 1, 0, regime_str, text_color=state_color, text_size=size.small, text_halign=text.align_right)
    
    table.cell(hud, 0, 1, "ORDER FLOW", text_color=color.gray, text_size=size.small, text_halign=text.align_left)
    table.cell(hud, 1, 1, is_chop ? "N/A" : dir_str, text_color=is_chop ? color.gray : state_color, text_size=size.small, text_halign=text.align_right)

// =========================================================================
// ALERTS (Webhook / Automated Execution Ready)
// =========================================================================
alertcondition(is_trend and not is_trend[1], title="Regime: Trend Started", message='{"Regime": "Trend", "Action": "Unlock Pullbacks"}')
alertcondition(is_chop and not is_chop[1], title="Regime: Chop Started", message='{"Regime": "Chop", "Action": "Lockdown"}')

Code: Select all

//+------------------------------------------------------------------+
//|                                       Inst_MTF_ER_Regime.mq5     |
//|                                     Strict Non-Repainting Filter |
//+------------------------------------------------------------------+
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_plots   1

// Histogram Plot
#property indicator_label1  "ER Regime"
#property indicator_type1   DRAW_COLOR_HISTOGRAM
#property indicator_color1  clrMediumSeaGreen, clrCrimson, clrGoldenrod, clrDimGray
#property indicator_style1  STYLE_SOLID
#property indicator_width1  2

//--- Inputs
input ENUM_TIMEFRAMES InpHTF         = PERIOD_M15; // HTF Vector
input int             InpLookback    = 14;         // ER Lookback
input double          InpTrendThresh = 0.40;       // Trend Floor (Min)
input double          InpChopThresh  = 0.25;       // Chop Ceiling (Max)
input bool            InpStrict      = true;       // Strict Non-Repainting (Closed Bar Only)

//--- Buffers
double ExtERBuffer[];
double ExtColorBuffer[];

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
    SetIndexBuffer(0, ExtERBuffer, INDICATOR_DATA);
    SetIndexBuffer(1, ExtColorBuffer, INDICATOR_COLOR_INDEX);
    
    IndicatorSetDouble(INDICATOR_MINIMUM, 0.0);
    IndicatorSetDouble(INDICATOR_MAXIMUM, 1.0);
    
    // Set Threshold Levels
    IndicatorSetInteger(INDICATOR_LEVELS, 2);
    IndicatorSetDouble(INDICATOR_LEVELVALUE, 0, InpTrendThresh);
    IndicatorSetDouble(INDICATOR_LEVELVALUE, 1, InpChopThresh);
    
    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 long &volume[],
                const int &spread[])
{
    int limit = prev_calculated == 0 ? 0 : prev_calculated - 1;

    for(int i = limit; i < rates_total; i++)
    {
        // 1. Find the corresponding HTF bar index for the current LTF time
        int htf_shift = iBarShift(_Symbol, InpHTF, time[i], false);
        if(htf_shift < 0) continue;
        
        // 2. Apply Strict Non-Repainting (Shift by 1 to use closed HTF bar)
        int calc_shift = InpStrict ? htf_shift + 1 : htf_shift;
        
        // 3. Fetch HTF Closes
        double htf_closes[];
        ArraySetAsSeries(htf_closes, true);
        if(CopyClose(_Symbol, InpHTF, calc_shift, InpLookback + 1, htf_closes) <= 0) continue;
        
        // 4. Calculate ER Core Engine
        double net_change = htf_closes[0] - htf_closes[InpLookback];
        double abs_change = MathAbs(net_change);
        double volatility = 0.0;
        
        for(int j = 0; j < InpLookback; j++) {
            volatility += MathAbs(htf_closes[j] - htf_closes[j+1]);
        }
        
        double raw_er = (volatility == 0) ? 0.0 : abs_change / volatility;
        int direction = (net_change > 0) ? 1 : (net_change < 0) ? -1 : 0;
        
        // 5. Assign to Buffers
        ExtERBuffer[i] = raw_er;
        
        // 6. State Machine & Color Routing
        if(raw_er < InpChopThresh) {
            ExtColorBuffer[i] = 3; // Chop (Gray)
        } 
        else if(raw_er >= InpTrendThresh) {
            ExtColorBuffer[i] = (direction == 1) ? 0 : 1; // Trend (Green/Red)
        } 
        else {
            ExtColorBuffer[i] = 2; // Transition (Orange)
        }
    }
    
    return(rates_total);
}

Code: Select all

//+------------------------------------------------------------------+
//|                                       Inst_MTF_ER_Regime.mq4     |
//|                                     Strict Non-Repainting Filter |
//+------------------------------------------------------------------+
#property indicator_separate_window
#property indicator_buffers 4
#property indicator_color1  clrMediumSeaGreen // Bull Trend
#property indicator_color2  clrCrimson        // Bear Trend
#property indicator_color3  clrGoldenrod      // Transition
#property indicator_color4  clrDimGray        // Chop
#property indicator_minimum 0.0
#property indicator_maximum 1.0
#property indicator_level1  0.40
#property indicator_level2  0.25

//--- Inputs
extern int    InpHTF         = 15;   // HTF Vector (in minutes, e.g., 15 for M15)
extern int    InpLookback    = 14;   // ER Lookback
extern double InpTrendThresh = 0.40; // Trend Floor
extern double InpChopThresh  = 0.25; // Chop Ceiling
extern bool   InpStrict      = true; // Strict Non-Repainting

//--- Buffers
double BufBull[];
double BufBear[];
double BufTrans[];
double BufChop[];

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
    SetIndexStyle(0, DRAW_HISTOGRAM, STYLE_SOLID, 2); SetIndexBuffer(0, BufBull);
    SetIndexStyle(1, DRAW_HISTOGRAM, STYLE_SOLID, 2); SetIndexBuffer(1, BufBear);
    SetIndexStyle(2, DRAW_HISTOGRAM, STYLE_SOLID, 2); SetIndexBuffer(2, BufTrans);
    SetIndexStyle(3, DRAW_HISTOGRAM, STYLE_SOLID, 2); SetIndexBuffer(3, BufChop);
    
    IndicatorShortName("MTF ER Regime");
    return(0);
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
{
    int limit = Bars - IndicatorCounted() - 1;
    if(limit < 0) limit = 0;

    for(int i = limit; i >= 0; i--)
    {
        // 1. Time Synchronization
        int htf_shift = iBarShift(NULL, InpHTF, Time[i], false);
        if(htf_shift < 0) continue;
        
        // 2. Strict Non-Repainting
        int calc_shift = InpStrict ? htf_shift + 1 : htf_shift;
        
        // 3. Calculate Volatility & Change via native iClose
        double current_close = iClose(NULL, InpHTF, calc_shift);
        double old_close     = iClose(NULL, InpHTF, calc_shift + InpLookback);
        
        double net_change = current_close - old_close;
        double abs_change = MathAbs(net_change);
        double volatility = 0.0;
        
        for(int j = 0; j < InpLookback; j++) {
            volatility += MathAbs(iClose(NULL, InpHTF, calc_shift + j) - iClose(NULL, InpHTF, calc_shift + j + 1));
        }
        
        // 4. Calculate ER
        double raw_er = (volatility == 0) ? 0.0 : abs_change / volatility;
        int direction = (net_change > 0) ? 1 : (net_change < 0) ? -1 : 0;
        
        // 5. Reset all buffers for this bar
        BufBull[i] = EMPTY_VALUE;
        BufBear[i] = EMPTY_VALUE;
        BufTrans[i] = EMPTY_VALUE;
        BufChop[i] = EMPTY_VALUE;
        
        // 6. Color Routing via Buffer Selection
        if(raw_er < InpChopThresh) {
            BufChop[i] = raw_er;
        } 
        else if(raw_er >= InpTrendThresh) {
            if(direction == 1) BufBull[i] = raw_er;
            else               BufBear[i] = raw_er;
        } 
        else {
            BufTrans[i] = raw_er;
        }
    }
    
    return(0);
}

Code: Select all

//+------------------------------------------------------------------+
//| 1. Define Regime States                                          |
//+------------------------------------------------------------------+
enum ENUM_REGIME_STATE 
{
    REGIME_CHOP       = 0,
    REGIME_TRANSITION = 1,
    REGIME_BULL_TREND = 2,
    REGIME_BEAR_TREND = 3,
    REGIME_ERROR      = -1
};

//+------------------------------------------------------------------+
//| 2. Native ER Calculation Function                                |
//+------------------------------------------------------------------+
ENUM_REGIME_STATE GetNativeMTFRegime(string symbol, ENUM_TIMEFRAMES htf, int lookback, double chop_th, double trend_th, bool strict_closed)
{
    // If strict_closed is true, we start at index 1 (ignoring the active repainting bar)
    int start_idx = strict_closed ? 1 : 0;
    
    double closes[];
    ArraySetAsSeries(closes, true);
    
    // Fetch lookback + 1 to get the start and end prices for the net change
    if(CopyClose(symbol, htf, start_idx, lookback + 1, closes) <= 0) 
    {
        Print("Failed to fetch HTF data. Error: ", GetLastError());
        return REGIME_ERROR; // Fail-safe state
    }
    
    double net_change = closes[0] - closes[lookback];
    double abs_change = MathAbs(net_change);
    double volatility = 0.0;
    
    // Accumulate the bar-to-bar volatility
    for(int i = 0; i < lookback; i++) 
    {
        volatility += MathAbs(closes[i] - closes[i+1]);
    }
    
    // Guard against division by zero in flat markets
    double er = (volatility == 0.0) ? 0.0 : (abs_change / volatility);
    
    // State Routing
    if(er < chop_th) return REGIME_CHOP;
    if(er >= trend_th) return (net_change > 0) ? REGIME_BULL_TREND : REGIME_BEAR_TREND;
    
    return REGIME_TRANSITION;
}

//+------------------------------------------------------------------+
//| 3. The OnTick() Execution Loop with State Caching                |
//+------------------------------------------------------------------+
// Global or static variables to cache the regime state
datetime          Global_LastHTFTime = 0;
ENUM_REGIME_STATE Global_CurrentRegime = REGIME_CHOP;

void OnTick()
{
    // 1. Check if a new HTF bar has opened
    datetime current_htf_time = iTime(_Symbol, PERIOD_M15, 0);
    
    // 2. Only recalculate the ER once every 15 minutes
    if(current_htf_time != Global_LastHTFTime)
    {
        Global_CurrentRegime = GetNativeMTFRegime(_Symbol, PERIOD_M15, 14, 0.25, 0.40, true);
        
        // Update the cache time if successful
        if(Global_CurrentRegime != REGIME_ERROR) 
        {
            Global_LastHTFTime = current_htf_time;
        }
    }

    // 3. Playbook Execution Logic
    if(Global_CurrentRegime == REGIME_CHOP || Global_CurrentRegime == REGIME_ERROR) 
    {
        // Lockdown: Do not evaluate pullback continuations
        // Optional: Manage trailing stops or execute mean-reversion only
        return; 
    }

    if(Global_CurrentRegime == REGIME_BULL_TREND) 
    {
        // 4a. Run your M1 price action / long pullback entry logic here
        // if(IsBullishPullbackOver()) OrderSend(...);
    }
    else if(Global_CurrentRegime == REGIME_BEAR_TREND) 
    {
        // 4b. Run your M1 price action / short pullback entry logic here
        // if(IsBearishPullbackOver()) OrderSend(...);
    }
    else if(Global_CurrentRegime == REGIME_TRANSITION) 
    {
        // Caution zone: You might allow trades but cut position sizing in half
    }
}

Code: Select all

// MQL4 adaptation for the data fetch
double current_close = iClose(symbol, htf, start_idx);
double old_close     = iClose(symbol, htf, start_idx + lookback);

double net_change = current_close - old_close;
double abs_change = MathAbs(net_change);
double volatility = 0.0;

for(int i = 0; i < lookback; i++) 
{
    volatility += MathAbs(iClose(symbol, htf, start_idx + i) - iClose(symbol, htf, start_idx + i + 1));
}