2497 lines
92 KiB
MQL5
2497 lines
92 KiB
MQL5
|
//+------------------------------------------------------------------+
|
||
|
|
//| QuarterTheory_VIZION_FINAL_v5.8.mq5 |
|
||
|
|
//| PRAISE SYSTEM: 8 Trend Signals for Aggressive Continuation |
|
||
|
|
//| WARN vs PRAISE: Dynamic position sizing and setup priority |
|
||
|
|
//| War Survivor: 2.5x size + 25% MFIB partials | All 18 Active |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
#property copyright "QuarterTheory x VIZION"
|
||
|
|
#property version "5.80"
|
||
|
|
#property strict
|
||
|
|
|
||
|
|
#include <Trade/Trade.mqh>
|
||
|
|
CTrade Trade;
|
||
|
|
|
||
|
|
//================ INPUT PARAMETERS ==================//
|
||
|
|
input group "=== CORE SETTINGS ==="
|
||
|
|
input int MagicNumber = 456789;
|
||
|
|
input double Risk_Per_Trade = 1.2;
|
||
|
|
input int Max_Trades_Per_Setup = 10;
|
||
|
|
input int Max_Total_Trades = 100;
|
||
|
|
input int Min_Runners_To_Keep = 4;
|
||
|
|
|
||
|
|
input group "=== MARKET MODE SYSTEM ==="
|
||
|
|
input bool Use_Market_Mode_Filter = true;
|
||
|
|
input int Mode_Confirmation_Bars = 2;
|
||
|
|
input double Chop_ATR_Threshold = 0.5;
|
||
|
|
input double Range_Price_Threshold = 0.3;
|
||
|
|
|
||
|
|
input group "=== REVERSAL CONFIRMATION ==="
|
||
|
|
input bool Only_Close_On_Full_Reversal = true;
|
||
|
|
input int Reversal_Confirmation_Bars = 3;
|
||
|
|
|
||
|
|
input group "=== MA SYSTEM ==="
|
||
|
|
input int MA_1 = 7;
|
||
|
|
input int MA_2 = 14;
|
||
|
|
input int MA_3 = 21;
|
||
|
|
input int MA_4 = 50;
|
||
|
|
input int MA_5 = 140;
|
||
|
|
input int MA_6 = 230;
|
||
|
|
input int MA_7 = 500;
|
||
|
|
input int MA_8 = 1000;
|
||
|
|
input int MA_9 = 1100;
|
||
|
|
input int MA_10 = 1300;
|
||
|
|
input int MA_Touch_Buffer = 100;
|
||
|
|
|
||
|
|
input group "=== STOCHASTIC ==="
|
||
|
|
input int Stoch_K_Period = 5;
|
||
|
|
input int Stoch_D_Period = 3;
|
||
|
|
input int Stoch_Slowing = 3;
|
||
|
|
input double Stoch_Extreme_High = 85.0; // Extreme overbought
|
||
|
|
input double Stoch_Extreme_Low = 15.0; // Extreme oversold
|
||
|
|
input double Stoch_High = 70.0;
|
||
|
|
input double Stoch_Low = 30.0;
|
||
|
|
|
||
|
|
// STOCHASTIC KEY LEVELS for Pullback Detection
|
||
|
|
// OS (Oversold) Levels: <20, 20, 35, 50
|
||
|
|
// OB (Overbought) Levels: 50, 65, 80, >80
|
||
|
|
// K x D (or D x K) at ANY of these levels = pullback signal
|
||
|
|
double Stoch_Levels[7] = {20.0, 35.0, 50.0, 65.0, 80.0}; // Key pivot levels
|
||
|
|
|
||
|
|
input group "=== MOVING FIBONACCI (ATH/ATL) ==="
|
||
|
|
input int MFIB_Lookback = 500; // Moving fib from ATH/ATL over this period
|
||
|
|
input bool Use_MFIB_382_Bias = true; // Price > .382 = bull bias, < .382 = bear bias
|
||
|
|
|
||
|
|
input group "=== FIBONACCI ==="
|
||
|
|
input int Lookback_Bars = 200;
|
||
|
|
input bool Show_Levels = true;
|
||
|
|
|
||
|
|
input group "=== CONTINUATION TRADE SETTINGS ==="
|
||
|
|
input int Continuation_SL_Points = 150;
|
||
|
|
input int Continuation_BreakEven_Points = 300;
|
||
|
|
input int Continuation_Trail_Points = 300;
|
||
|
|
input int Continuation_TP_Points = 4000;
|
||
|
|
input int Continuation_Partial_TP = 900;
|
||
|
|
input double Continuation_Partial_Percent = 33.0;
|
||
|
|
|
||
|
|
input group "=== COUNTER-TREND TRADE SETTINGS (Pullback/Retracement/Range/Chop) ==="
|
||
|
|
input int Counter_SL_Points = 50; // Tight SL
|
||
|
|
input int Counter_BreakEven_Points = 25; // Fast BE
|
||
|
|
input int Counter_Trail_Points = 150; // Trail by 150
|
||
|
|
input int Counter_TP_Points = 3000; // Open TP for trend expansion
|
||
|
|
input int Counter_Partial_TP = 100; // First partial
|
||
|
|
input double Counter_Partial_Percent = 50.0; // Close 50% early
|
||
|
|
|
||
|
|
input group "=== WAR SURVIVOR: AGGRESSIVE MFIB PARTIAL SYSTEM ==="
|
||
|
|
input bool Use_MFIB_Partials = true; // Take 25% at each MFIB reject
|
||
|
|
input double MFIB_Partial_Percent = 25.0; // 25% per MFIB level
|
||
|
|
input int MFIB_Partial_Min_Profit = 30; // Min profit to take MFIB partial (points)
|
||
|
|
input double War_Survivor_Lot_Multiplier = 2.5; // Multiply lot size for more survivors
|
||
|
|
|
||
|
|
input group "=== PRAISE SYSTEM: Aggressive Trend Following ==="
|
||
|
|
input bool Use_Praise_System = true; // Enable PRAISE signals
|
||
|
|
input double Praise_Size_Multiplier_Strong = 1.5; // 3 praise signals
|
||
|
|
input double Praise_Size_Multiplier_Supreme = 2.0; // 4+ praise signals
|
||
|
|
input int Praise_Tight_Trail = 100; // Tighter trail for supreme praise
|
||
|
|
input bool Pause_Counter_On_Praise = true; // Disable counter when P >= 3
|
||
|
|
input bool Reduce_Continuation_On_Warn = true; // 50% size continuation when W >= 3
|
||
|
|
input bool Max_Aggression_Mode = true; // Take EVERY valid setup (no hesitation)
|
||
|
|
|
||
|
|
input group "=== BAND SNAP DETECTION ==="
|
||
|
|
input double Band_Snap_ATR_Multiplier = 2.0;
|
||
|
|
|
||
|
|
input group "=== RE-ENTRY SETTINGS ==="
|
||
|
|
input bool Allow_Re_Entry = true;
|
||
|
|
input int Re_Entry_Cooldown_Bars = 5;
|
||
|
|
|
||
|
|
//================ ENUMS ==================//
|
||
|
|
enum MODE_FAMILY
|
||
|
|
{
|
||
|
|
FAMILY_TRENDING = 0,
|
||
|
|
FAMILY_RANGING = 1,
|
||
|
|
FAMILY_CHOP = 2,
|
||
|
|
FAMILY_TRANSITIONAL = 3
|
||
|
|
};
|
||
|
|
|
||
|
|
enum TREND_BIAS
|
||
|
|
{
|
||
|
|
BIAS_NEUTRAL = 0,
|
||
|
|
BIAS_BULL = 1,
|
||
|
|
BIAS_BEAR = -1
|
||
|
|
};
|
||
|
|
|
||
|
|
enum TREND_STRENGTH
|
||
|
|
{
|
||
|
|
STRENGTH_WEAK = 0,
|
||
|
|
STRENGTH_CONFIRMED = 1,
|
||
|
|
STRENGTH_STRONG = 2
|
||
|
|
};
|
||
|
|
|
||
|
|
enum PRICE_STATE
|
||
|
|
{
|
||
|
|
STATE_CONTINUATION = 0,
|
||
|
|
STATE_PULLBACK = 1,
|
||
|
|
STATE_DEEP_RETRACEMENT = 2,
|
||
|
|
STATE_REVERSAL_ATTEMPT = 3,
|
||
|
|
STATE_REVERSAL_CONFIRMED = 4,
|
||
|
|
|
||
|
|
STATE_RANGE_MID_DRIFT = 10,
|
||
|
|
STATE_RANGE_EDGE_TEST = 11,
|
||
|
|
STATE_RANGE_REJECTION = 12,
|
||
|
|
STATE_RANGE_BREAK_ATTEMPT = 13,
|
||
|
|
STATE_RANGE_BREAK_CONFIRMED = 14,
|
||
|
|
|
||
|
|
STATE_CHOP_NOISE = 20,
|
||
|
|
STATE_CHOP_VOL_SPIKE = 21,
|
||
|
|
STATE_CHOP_SQUEEZE = 22,
|
||
|
|
STATE_CHOP_FAKEOUT_LOOP = 23,
|
||
|
|
|
||
|
|
STATE_UNKNOWN = 99
|
||
|
|
};
|
||
|
|
|
||
|
|
enum SETUP_TYPE
|
||
|
|
{
|
||
|
|
SETUP_MA14_CROSS = 1,
|
||
|
|
SETUP_MA50_BOUNCE = 2,
|
||
|
|
SETUP_MA140_BOUNCE = 3,
|
||
|
|
SETUP_MA230_BOUNCE = 4,
|
||
|
|
SETUP_MA500_TOUCH = 5,
|
||
|
|
SETUP_FIB_BREAK = 6,
|
||
|
|
SETUP_FIB_RECLAIM = 7,
|
||
|
|
SETUP_FIB_REJECT = 8,
|
||
|
|
SETUP_MAGNET_WALK = 9,
|
||
|
|
SETUP_STAIRCASE_ADV = 10,
|
||
|
|
SETUP_CTRL_PULLBACK = 11,
|
||
|
|
SETUP_TF_RESET = 12,
|
||
|
|
SETUP_MFIB_LADDER = 13,
|
||
|
|
SETUP_MFIB_PRESS = 14,
|
||
|
|
SETUP_MEAN_REV = 15,
|
||
|
|
SETUP_RANGE_ENGINE = 16,
|
||
|
|
SETUP_PULLBACK_COUNTER = 17,
|
||
|
|
SETUP_RETRACEMENT_COUNTER = 18
|
||
|
|
};
|
||
|
|
|
||
|
|
enum TRADE_CATEGORY
|
||
|
|
{
|
||
|
|
CATEGORY_CONTINUATION = 0,
|
||
|
|
CATEGORY_COUNTER_TREND = 1
|
||
|
|
};
|
||
|
|
|
||
|
|
//================ GLOBALS ==================//
|
||
|
|
int Stoch_Handle, ATR_Handle, ADX_Handle;
|
||
|
|
|
||
|
|
double Stoch_K_Current = 0, Stoch_K_Previous = 0, Stoch_K_Prev2 = 0;
|
||
|
|
double Stoch_D_Current = 0;
|
||
|
|
|
||
|
|
double Current_ATR = 0;
|
||
|
|
double Current_ADX = 0;
|
||
|
|
|
||
|
|
double PriceLevels[7];
|
||
|
|
|
||
|
|
int MA_Handles[10];
|
||
|
|
double MA_Current[10];
|
||
|
|
double MA_Previous[10];
|
||
|
|
double MA_Prev2[10];
|
||
|
|
|
||
|
|
// Moving MFIB from ATH to ATL
|
||
|
|
double MFIB_High, MFIB_Low;
|
||
|
|
double MFIB_Level_236, MFIB_Level_382, MFIB_Level_050;
|
||
|
|
double MFIB_Level_618, MFIB_Level_786;
|
||
|
|
|
||
|
|
// MFIB .382 Bias
|
||
|
|
TREND_BIAS MFIB_Bias = BIAS_NEUTRAL;
|
||
|
|
|
||
|
|
MODE_FAMILY Current_Family = FAMILY_TRANSITIONAL;
|
||
|
|
TREND_BIAS Current_Bias = BIAS_NEUTRAL;
|
||
|
|
TREND_STRENGTH Current_Strength = STRENGTH_WEAK;
|
||
|
|
PRICE_STATE Current_State = STATE_UNKNOWN;
|
||
|
|
|
||
|
|
MODE_FAMILY Prev_Family = FAMILY_TRANSITIONAL;
|
||
|
|
TREND_BIAS Prev_Bias = BIAS_NEUTRAL;
|
||
|
|
TREND_STRENGTH Prev_Strength = STRENGTH_WEAK;
|
||
|
|
|
||
|
|
int Mode_Confirmation_Count = 0;
|
||
|
|
int Reversal_Confirm_Counter = 0;
|
||
|
|
|
||
|
|
bool MA7_Cross_14_Warning = false;
|
||
|
|
bool MA7_Cross_21_Warning = false;
|
||
|
|
bool MA50_Break_Warning = false;
|
||
|
|
|
||
|
|
bool Fib_Reject_Warning = false;
|
||
|
|
bool MFIB_Reject_Warning = false;
|
||
|
|
|
||
|
|
bool Fib_Reclaim_Warning = false; // NEW: Fib reclaim signal
|
||
|
|
bool MFIB_Reclaim_Warning = false; // NEW: MFIB reclaim signal
|
||
|
|
bool Fib_Break_Warning = false; // NEW: Fib break signal
|
||
|
|
bool MFIB_Break_Warning = false; // NEW: MFIB break signal
|
||
|
|
|
||
|
|
bool MA_Reject_Warning = false;
|
||
|
|
bool MA_Reclaim_Warning = false; // NEW: MA reclaim signal
|
||
|
|
bool MA_Break_Warning = false; // NEW: MA break signal
|
||
|
|
|
||
|
|
bool Stoch_Extreme_Warning = false;
|
||
|
|
bool Stoch_Reject_Warning = false;
|
||
|
|
bool Stoch_Level_Cross = false; // NEW: K x D at key level
|
||
|
|
|
||
|
|
// Strong MA warnings (140, 230, 500, 50)
|
||
|
|
bool MA50_Warning = false;
|
||
|
|
bool MA140_Warning = false;
|
||
|
|
bool MA230_Warning = false;
|
||
|
|
bool MA500_Warning = false;
|
||
|
|
|
||
|
|
bool Pullback_Warning = false;
|
||
|
|
bool Retracement_Warning = false;
|
||
|
|
bool Band_Snap_Warning = false;
|
||
|
|
|
||
|
|
bool Is_Pullback_State = false;
|
||
|
|
bool Is_Retracement_State = false;
|
||
|
|
|
||
|
|
// NEW: Re-entry combo flags
|
||
|
|
bool MA14_Magnet_Active = false; // Price hugging MA14
|
||
|
|
bool Fib_Break_Confirmed = false; // Clean fib break
|
||
|
|
bool MFIB_Break_Confirmed = false; // Clean MFIB break
|
||
|
|
bool Strong_MA_Bounce = false; // Bounce off 140/230/500
|
||
|
|
bool Trend_Resumption = false; // Post-pullback trend resume
|
||
|
|
|
||
|
|
// PRAISE SYSTEM: 8 Trend Strength Signals (NO stochastic)
|
||
|
|
bool Praise_Triple_Magnet = false; // 7x14x21 all tight
|
||
|
|
bool Praise_Power_Couple = false; // 14x21 very close
|
||
|
|
bool Praise_MFIB_Staircase = false; // Sequential MFIB advance
|
||
|
|
bool Praise_MFIB_Express = false; // Skips MFIB level
|
||
|
|
bool Praise_MFIB_Breakout = false; // MFIB break + hold
|
||
|
|
bool Praise_MA_Stack = false; // Perfect MA stack
|
||
|
|
bool Praise_Clean_Reclaim = false; // MFIB+MA+Fib reclaim together
|
||
|
|
bool Praise_Multi_Breakout = false; // Everything breaking at once
|
||
|
|
int Praise_Count = 0; // Total praise signals
|
||
|
|
|
||
|
|
int Warning_Confluence_Count = 0;
|
||
|
|
bool Warning_Confluence_3Plus = false;
|
||
|
|
|
||
|
|
struct PositionRec
|
||
|
|
{
|
||
|
|
ulong ticket;
|
||
|
|
double entry;
|
||
|
|
double original_lot;
|
||
|
|
bool is_buy;
|
||
|
|
bool partial_tp_hit;
|
||
|
|
bool be_set;
|
||
|
|
bool trailing_active;
|
||
|
|
bool is_runner;
|
||
|
|
SETUP_TYPE setup_type;
|
||
|
|
TRADE_CATEGORY category;
|
||
|
|
string setup_name;
|
||
|
|
MODE_FAMILY entry_family;
|
||
|
|
TREND_BIAS entry_bias;
|
||
|
|
TREND_STRENGTH entry_strength;
|
||
|
|
double distance_from_current;
|
||
|
|
datetime last_close_time;
|
||
|
|
bool closed_at_sl; // NEW: Track if closed at SL
|
||
|
|
bool closed_at_be; // NEW: Track if closed at BE
|
||
|
|
double close_price; // NEW: Track close price for re-entry reference
|
||
|
|
|
||
|
|
// WAR SURVIVOR: MFIB partial tracking
|
||
|
|
int mfib_partials_taken; // Count of MFIB partials taken (0-4 possible)
|
||
|
|
double last_mfib_partial_price; // Last price where MFIB partial was taken
|
||
|
|
};
|
||
|
|
PositionRec OpenPositions[];
|
||
|
|
|
||
|
|
// NEW: Track recently closed positions for re-entry opportunities
|
||
|
|
struct ClosedPositionRec
|
||
|
|
{
|
||
|
|
SETUP_TYPE setup_type;
|
||
|
|
TRADE_CATEGORY category;
|
||
|
|
bool was_buy;
|
||
|
|
double close_price;
|
||
|
|
datetime close_time;
|
||
|
|
bool closed_at_sl;
|
||
|
|
bool closed_at_be;
|
||
|
|
};
|
||
|
|
ClosedPositionRec RecentClosures[10]; // Track last 10 closures
|
||
|
|
int ClosureIndex = 0;
|
||
|
|
|
||
|
|
int TodayTrades = 0;
|
||
|
|
int BuyTrades = 0;
|
||
|
|
int SellTrades = 0;
|
||
|
|
int ClosedByReversal = 0;
|
||
|
|
|
||
|
|
int SetupCount[19];
|
||
|
|
datetime LastEntryTime[19];
|
||
|
|
|
||
|
|
//================ HELPERS ==================//
|
||
|
|
double MidPrice()
|
||
|
|
{
|
||
|
|
double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
|
||
|
|
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
|
||
|
|
return (bid + ask) / 2.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool NearLevel(const double price, const double level, const double tolPoints)
|
||
|
|
{
|
||
|
|
return (MathAbs(price - level) <= tolPoints * _Point);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool StochCrossUp()
|
||
|
|
{
|
||
|
|
return (Stoch_K_Previous < Stoch_D_Current && Stoch_K_Current >= Stoch_D_Current);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool StochCrossDown()
|
||
|
|
{
|
||
|
|
return (Stoch_K_Previous > Stoch_D_Current && Stoch_K_Current <= Stoch_D_Current);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool IsBullBias() { return (Current_Bias == BIAS_BULL); }
|
||
|
|
bool IsBearBias() { return (Current_Bias == BIAS_BEAR); }
|
||
|
|
|
||
|
|
bool Bull_MA50_Reclaimed()
|
||
|
|
{
|
||
|
|
bool reclaimed = (MA_Previous[0] <= MA_Previous[3]) && (MA_Current[0] > MA_Current[3]);
|
||
|
|
double low0 = iLow(_Symbol, PERIOD_CURRENT, 0);
|
||
|
|
double close0 = iClose(_Symbol, PERIOD_CURRENT, 0);
|
||
|
|
bool rejected = (low0 <= MA_Current[3] && close0 > MA_Current[3] && (StochCrossUp() || Stoch_K_Current > 50));
|
||
|
|
return (reclaimed || rejected);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool Bear_MA50_Reclaimed()
|
||
|
|
{
|
||
|
|
bool reclaimed = (MA_Previous[0] >= MA_Previous[3]) && (MA_Current[0] < MA_Current[3]);
|
||
|
|
double high0 = iHigh(_Symbol, PERIOD_CURRENT, 0);
|
||
|
|
double close0 = iClose(_Symbol, PERIOD_CURRENT, 0);
|
||
|
|
bool rejected = (high0 >= MA_Current[3] && close0 < MA_Current[3] && (StochCrossDown() || Stoch_K_Current < 50));
|
||
|
|
return (reclaimed || rejected);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Track position closure for re-entry opportunities
|
||
|
|
void RecordClosure(SETUP_TYPE setup, TRADE_CATEGORY cat, bool was_buy, double close_price, bool at_sl, bool at_be)
|
||
|
|
{
|
||
|
|
RecentClosures[ClosureIndex].setup_type = setup;
|
||
|
|
RecentClosures[ClosureIndex].category = cat;
|
||
|
|
RecentClosures[ClosureIndex].was_buy = was_buy;
|
||
|
|
RecentClosures[ClosureIndex].close_price = close_price;
|
||
|
|
RecentClosures[ClosureIndex].close_time = TimeCurrent();
|
||
|
|
RecentClosures[ClosureIndex].closed_at_sl = at_sl;
|
||
|
|
RecentClosures[ClosureIndex].closed_at_be = at_be;
|
||
|
|
|
||
|
|
ClosureIndex = (ClosureIndex + 1) % 10; // Circular buffer
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check if recently closed at SL or BE (within last 10 bars)
|
||
|
|
bool RecentlyStopped(SETUP_TYPE setup)
|
||
|
|
{
|
||
|
|
datetime now = TimeCurrent();
|
||
|
|
datetime cutoff = now - 10 * PeriodSeconds(PERIOD_CURRENT);
|
||
|
|
|
||
|
|
for(int i=0; i<10; i++)
|
||
|
|
{
|
||
|
|
if(RecentClosures[i].setup_type == setup &&
|
||
|
|
RecentClosures[i].close_time > cutoff &&
|
||
|
|
(RecentClosures[i].closed_at_sl || RecentClosures[i].closed_at_be))
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
// COMPREHENSIVE RE-ENTRY SYSTEM
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CanReEnter(SETUP_TYPE setup)
|
||
|
|
{
|
||
|
|
if(!Allow_Re_Entry) return true;
|
||
|
|
|
||
|
|
datetime now = TimeCurrent();
|
||
|
|
datetime cooldown_end = LastEntryTime[setup] + Re_Entry_Cooldown_Bars * PeriodSeconds(PERIOD_CURRENT);
|
||
|
|
bool cooldown_passed = (now >= cooldown_end);
|
||
|
|
|
||
|
|
// Check if recently stopped out
|
||
|
|
bool recently_stopped = RecentlyStopped(setup);
|
||
|
|
|
||
|
|
//================================================================
|
||
|
|
// RE-ENTRY COMBO TRIGGERS (Override cooldown)
|
||
|
|
//================================================================
|
||
|
|
|
||
|
|
// COMBO 1: 3+ Rejection/Reclaim at Strong MAs (140, 230, 500+)
|
||
|
|
int reject_reclaim_count = 0;
|
||
|
|
if(Fib_Reject_Warning) reject_reclaim_count++;
|
||
|
|
if(MFIB_Reject_Warning) reject_reclaim_count++;
|
||
|
|
if(MA_Reject_Warning) reject_reclaim_count++;
|
||
|
|
if(Fib_Reclaim_Warning) reject_reclaim_count++;
|
||
|
|
if(MFIB_Reclaim_Warning) reject_reclaim_count++;
|
||
|
|
if(MA_Reclaim_Warning) reject_reclaim_count++;
|
||
|
|
|
||
|
|
bool at_strong_ma = (MA140_Warning || MA230_Warning || MA500_Warning);
|
||
|
|
bool combo1_strong_ma_confluence = (reject_reclaim_count >= 3 && at_strong_ma);
|
||
|
|
|
||
|
|
// COMBO 2: MA14 Magnet + Fib/MFIB Break (Trending)
|
||
|
|
bool combo2_ma14_magnet_break = (MA14_Magnet_Active && (Fib_Break_Confirmed || MFIB_Break_Confirmed));
|
||
|
|
|
||
|
|
// COMBO 3: Strong MA Bounce + Stoch Confirmation (Post-SL/BE)
|
||
|
|
bool combo3_strong_bounce = (Strong_MA_Bounce && recently_stopped &&
|
||
|
|
(Stoch_Level_Cross || StochCrossUp() || StochCrossDown()));
|
||
|
|
|
||
|
|
// COMBO 4: Trend Resumption after Pullback (MA50 reclaim + 2+ signals)
|
||
|
|
bool combo4_trend_resume = (Trend_Resumption && Warning_Confluence_Count >= 2);
|
||
|
|
|
||
|
|
// COMBO 5: Fib/MFIB Reclaim + MA Alignment (Post-BE)
|
||
|
|
bool mas_aligned_bull = (MA_Current[0] > MA_Current[1]) && (MA_Current[1] > MA_Current[2]);
|
||
|
|
bool mas_aligned_bear = (MA_Current[0] < MA_Current[1]) && (MA_Current[1] < MA_Current[2]);
|
||
|
|
bool combo5_level_reclaim = ((Fib_Reclaim_Warning || MFIB_Reclaim_Warning) &&
|
||
|
|
recently_stopped && (mas_aligned_bull || mas_aligned_bear));
|
||
|
|
|
||
|
|
// COMBO 6: Band Snap Recovery + Strong MA (Overextension correction)
|
||
|
|
bool combo6_snap_recovery = (Band_Snap_Warning && at_strong_ma && recently_stopped);
|
||
|
|
|
||
|
|
// COMBO 7: Multiple Level Confluence (Fib + MFIB + MA all align)
|
||
|
|
bool fib_and_mfib = (Fib_Reject_Warning || Fib_Reclaim_Warning) &&
|
||
|
|
(MFIB_Reject_Warning || MFIB_Reclaim_Warning);
|
||
|
|
bool combo7_triple_level = (fib_and_mfib && (MA_Reject_Warning || MA_Reclaim_Warning));
|
||
|
|
|
||
|
|
// COMBO 8: Stoch Extreme + Fib/MFIB Level + Post-SL
|
||
|
|
bool combo8_extreme_level = (Stoch_Extreme_Warning && recently_stopped &&
|
||
|
|
(Fib_Reject_Warning || MFIB_Reject_Warning));
|
||
|
|
|
||
|
|
// COMBO 9: MA Cross + Level Break + Continuation State
|
||
|
|
bool combo9_cross_break = (MA7_Cross_14_Warning && (Fib_Break_Confirmed || MFIB_Break_Confirmed) &&
|
||
|
|
Current_State == STATE_CONTINUATION);
|
||
|
|
|
||
|
|
// COMBO 10: 4+ Warning Confluence (Extreme conviction)
|
||
|
|
bool combo10_mega_confluence = (Warning_Confluence_Count >= 4);
|
||
|
|
|
||
|
|
//================================================================
|
||
|
|
// DECISION LOGIC
|
||
|
|
//================================================================
|
||
|
|
|
||
|
|
// If ANY combo triggers, allow immediate re-entry
|
||
|
|
bool combo_triggered =
|
||
|
|
combo1_strong_ma_confluence ||
|
||
|
|
combo2_ma14_magnet_break ||
|
||
|
|
combo3_strong_bounce ||
|
||
|
|
combo4_trend_resume ||
|
||
|
|
combo5_level_reclaim ||
|
||
|
|
combo6_snap_recovery ||
|
||
|
|
combo7_triple_level ||
|
||
|
|
combo8_extreme_level ||
|
||
|
|
combo9_cross_break ||
|
||
|
|
combo10_mega_confluence;
|
||
|
|
|
||
|
|
// Log re-entry combo if triggered
|
||
|
|
if(combo_triggered && !cooldown_passed)
|
||
|
|
{
|
||
|
|
string combo_name = "";
|
||
|
|
if(combo1_strong_ma_confluence) combo_name = "3+Reject/Reclaim@StrongMA";
|
||
|
|
else if(combo2_ma14_magnet_break) combo_name = "MA14Magnet+FibBreak";
|
||
|
|
else if(combo3_strong_bounce) combo_name = "StrongMA_Bounce+Stoch";
|
||
|
|
else if(combo4_trend_resume) combo_name = "TrendResumption";
|
||
|
|
else if(combo5_level_reclaim) combo_name = "Level_Reclaim+MA_Align";
|
||
|
|
else if(combo6_snap_recovery) combo_name = "BandSnap_Recovery";
|
||
|
|
else if(combo7_triple_level) combo_name = "Triple_Level_Confluence";
|
||
|
|
else if(combo8_extreme_level) combo_name = "Stoch_Extreme+Level";
|
||
|
|
else if(combo9_cross_break) combo_name = "MA_Cross+Level_Break";
|
||
|
|
else if(combo10_mega_confluence) combo_name = "4+_Confluence";
|
||
|
|
|
||
|
|
Print("🔁 RE-ENTRY COMBO TRIGGERED: ", combo_name);
|
||
|
|
}
|
||
|
|
|
||
|
|
return (cooldown_passed || combo_triggered);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
int OnInit()
|
||
|
|
{
|
||
|
|
Print("========================================");
|
||
|
|
Print("QuarterTheory_VIZION_FINAL v5.7");
|
||
|
|
Print("⚔️ WAR SURVIVOR SYSTEM:");
|
||
|
|
Print(" - Aggressive MFIB Partials: 25% at each reject");
|
||
|
|
Print(" - Larger Initial Size: ", DoubleToString(War_Survivor_Lot_Multiplier, 1), "x multiplier");
|
||
|
|
Print(" - Max 4 MFIB partials per trade");
|
||
|
|
Print(" - Survive frequent trailing stops");
|
||
|
|
Print("SMART RE-ENTRY:");
|
||
|
|
Print(" - 10 combo triggers for post-SL/BE re-entry");
|
||
|
|
Print(" - 3+ Reject/Reclaim at MA140/230/500");
|
||
|
|
Print("ALL 18 SETUPS ACTIVE:");
|
||
|
|
Print(" - 14 Continuation (150 SL, 4000 TP)");
|
||
|
|
Print(" - 4 Counter-Trend (50 SL, 3000 TP)");
|
||
|
|
Print("TRAILING SL:");
|
||
|
|
Print(" - Counter: 150pts behind price");
|
||
|
|
Print(" - Continuation: 300pts behind price");
|
||
|
|
Print("========================================");
|
||
|
|
|
||
|
|
Trade.SetExpertMagicNumber(MagicNumber);
|
||
|
|
Trade.SetDeviationInPoints(50);
|
||
|
|
Trade.SetTypeFilling(ORDER_FILLING_FOK);
|
||
|
|
|
||
|
|
Stoch_Handle = iStochastic(_Symbol, PERIOD_CURRENT, Stoch_K_Period, Stoch_D_Period,
|
||
|
|
Stoch_Slowing, MODE_SMA, STO_LOWHIGH);
|
||
|
|
ATR_Handle = iATR(_Symbol, PERIOD_CURRENT, 14);
|
||
|
|
ADX_Handle = iADX(_Symbol, PERIOD_CURRENT, 14);
|
||
|
|
|
||
|
|
int periods[10] = {MA_1, MA_2, MA_3, MA_4, MA_5, MA_6, MA_7, MA_8, MA_9, MA_10};
|
||
|
|
for(int i=0; i<10; i++)
|
||
|
|
MA_Handles[i] = iMA(_Symbol, PERIOD_CURRENT, periods[i], 0, MODE_EMA, PRICE_CLOSE);
|
||
|
|
|
||
|
|
ArrayInitialize(SetupCount, 0);
|
||
|
|
ArrayInitialize(LastEntryTime, 0);
|
||
|
|
|
||
|
|
CalculateLevels();
|
||
|
|
if(Show_Levels) DrawLevels();
|
||
|
|
|
||
|
|
return INIT_SUCCEEDED;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void OnDeinit(const int reason)
|
||
|
|
{
|
||
|
|
for(int i=0; i<10; i++)
|
||
|
|
if(MA_Handles[i] != INVALID_HANDLE)
|
||
|
|
IndicatorRelease(MA_Handles[i]);
|
||
|
|
|
||
|
|
if(Stoch_Handle != INVALID_HANDLE) IndicatorRelease(Stoch_Handle);
|
||
|
|
if(ATR_Handle != INVALID_HANDLE) IndicatorRelease(ATR_Handle);
|
||
|
|
if(ADX_Handle != INVALID_HANDLE) IndicatorRelease(ADX_Handle);
|
||
|
|
|
||
|
|
ObjectsDeleteAll(0, "Level_");
|
||
|
|
ObjectsDeleteAll(0, "MFIB_");
|
||
|
|
ObjectsDeleteAll(0, "ModeLabel");
|
||
|
|
ObjectsDeleteAll(0, "StateLabel");
|
||
|
|
ObjectsDeleteAll(0, "WarningLabel");
|
||
|
|
ObjectsDeleteAll(0, "MFIBLabel");
|
||
|
|
|
||
|
|
Print("Final: B:", BuyTrades, " | S:", SellTrades, " | Reversed:", ClosedByReversal);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CalculateLevels()
|
||
|
|
{
|
||
|
|
// Static Fibonacci levels for reference
|
||
|
|
double high = iHigh(_Symbol, PERIOD_CURRENT, 0);
|
||
|
|
double low = iLow(_Symbol, PERIOD_CURRENT, 0);
|
||
|
|
|
||
|
|
for(int i=1; i<=Lookback_Bars; i++)
|
||
|
|
{
|
||
|
|
double h = iHigh(_Symbol, PERIOD_CURRENT, i);
|
||
|
|
double l = iLow(_Symbol, PERIOD_CURRENT, i);
|
||
|
|
if(h > high) high = h;
|
||
|
|
if(l < low) low = l;
|
||
|
|
}
|
||
|
|
|
||
|
|
double range = high - low;
|
||
|
|
PriceLevels[0] = low;
|
||
|
|
PriceLevels[1] = low + range * 0.236;
|
||
|
|
PriceLevels[2] = low + range * 0.382;
|
||
|
|
PriceLevels[3] = low + range * 0.5;
|
||
|
|
PriceLevels[4] = low + range * 0.618;
|
||
|
|
PriceLevels[5] = low + range * 0.786;
|
||
|
|
PriceLevels[6] = high;
|
||
|
|
|
||
|
|
// MOVING FIBONACCI - From ATH to ATL (stacked from top)
|
||
|
|
double ath = iHigh(_Symbol, PERIOD_CURRENT, 0);
|
||
|
|
double atl = iLow(_Symbol, PERIOD_CURRENT, 0);
|
||
|
|
|
||
|
|
for(int i=1; i<=MFIB_Lookback; i++)
|
||
|
|
{
|
||
|
|
double h = iHigh(_Symbol, PERIOD_CURRENT, i);
|
||
|
|
double l = iLow(_Symbol, PERIOD_CURRENT, i);
|
||
|
|
if(h > ath) ath = h;
|
||
|
|
if(l < atl) atl = l;
|
||
|
|
}
|
||
|
|
|
||
|
|
MFIB_High = ath;
|
||
|
|
MFIB_Low = atl;
|
||
|
|
double mfib_range = ath - atl;
|
||
|
|
|
||
|
|
// Levels stacked from ATH down to ATL
|
||
|
|
MFIB_Level_236 = ath - (mfib_range * 0.236); // 23.6% down from ATH
|
||
|
|
MFIB_Level_382 = ath - (mfib_range * 0.382); // 38.2% down from ATH *** KEY BIAS LEVEL ***
|
||
|
|
MFIB_Level_050 = ath - (mfib_range * 0.500); // 50% down from ATH
|
||
|
|
MFIB_Level_618 = ath - (mfib_range * 0.618); // 61.8% down from ATH *** KEY LEVEL ***
|
||
|
|
MFIB_Level_786 = ath - (mfib_range * 0.786); // 78.6% down from ATH
|
||
|
|
|
||
|
|
// MFIB .382 Bias Logic
|
||
|
|
if(Use_MFIB_382_Bias)
|
||
|
|
{
|
||
|
|
double current = MidPrice();
|
||
|
|
|
||
|
|
if(current > MFIB_Level_382)
|
||
|
|
MFIB_Bias = BIAS_BULL; // Above .382 = bullish bias
|
||
|
|
else if(current < MFIB_Level_382)
|
||
|
|
MFIB_Bias = BIAS_BEAR; // Below .382 = bearish bias
|
||
|
|
else
|
||
|
|
MFIB_Bias = BIAS_NEUTRAL;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
MFIB_Bias = BIAS_NEUTRAL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void DrawLevels()
|
||
|
|
{
|
||
|
|
ObjectsDeleteAll(0, "Level_");
|
||
|
|
ObjectsDeleteAll(0, "MFIB_");
|
||
|
|
|
||
|
|
color level_colors[7] = {clrRed, clrOrange, clrYellow, clrLime, clrCyan, clrBlue, clrMagenta};
|
||
|
|
|
||
|
|
// Draw static fib levels
|
||
|
|
for(int i=0; i<7; i++)
|
||
|
|
{
|
||
|
|
string name = "Level_" + IntegerToString(i);
|
||
|
|
ObjectCreate(0, name, OBJ_HLINE, 0, 0, PriceLevels[i]);
|
||
|
|
ObjectSetInteger(0, name, OBJPROP_COLOR, level_colors[i]);
|
||
|
|
ObjectSetInteger(0, name, OBJPROP_STYLE, STYLE_DOT);
|
||
|
|
ObjectSetInteger(0, name, OBJPROP_WIDTH, 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Draw MFIB levels (more prominent)
|
||
|
|
string mfib_name = "MFIB_382";
|
||
|
|
ObjectCreate(0, mfib_name, OBJ_HLINE, 0, 0, MFIB_Level_382);
|
||
|
|
ObjectSetInteger(0, mfib_name, OBJPROP_COLOR, clrYellow);
|
||
|
|
ObjectSetInteger(0, mfib_name, OBJPROP_STYLE, STYLE_SOLID);
|
||
|
|
ObjectSetInteger(0, mfib_name, OBJPROP_WIDTH, 2);
|
||
|
|
|
||
|
|
mfib_name = "MFIB_618";
|
||
|
|
ObjectCreate(0, mfib_name, OBJ_HLINE, 0, 0, MFIB_Level_618);
|
||
|
|
ObjectSetInteger(0, mfib_name, OBJPROP_COLOR, clrCyan);
|
||
|
|
ObjectSetInteger(0, mfib_name, OBJPROP_STYLE, STYLE_SOLID);
|
||
|
|
ObjectSetInteger(0, mfib_name, OBJPROP_WIDTH, 2);
|
||
|
|
|
||
|
|
mfib_name = "MFIB_050";
|
||
|
|
ObjectCreate(0, mfib_name, OBJ_HLINE, 0, 0, MFIB_Level_050);
|
||
|
|
ObjectSetInteger(0, mfib_name, OBJPROP_COLOR, clrWhite);
|
||
|
|
ObjectSetInteger(0, mfib_name, OBJPROP_STYLE, STYLE_SOLID);
|
||
|
|
ObjectSetInteger(0, mfib_name, OBJPROP_WIDTH, 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void UpdateIndicators()
|
||
|
|
{
|
||
|
|
for(int i=0; i<10; i++)
|
||
|
|
{
|
||
|
|
double curr[1], prev[1], prev2[1];
|
||
|
|
if(CopyBuffer(MA_Handles[i], 0, 0, 1, curr) > 0) MA_Current[i] = curr[0];
|
||
|
|
if(CopyBuffer(MA_Handles[i], 0, 1, 1, prev) > 0) MA_Previous[i] = prev[0];
|
||
|
|
if(CopyBuffer(MA_Handles[i], 0, 2, 1, prev2) > 0) MA_Prev2[i] = prev2[0];
|
||
|
|
}
|
||
|
|
|
||
|
|
double k_curr[1], k_prev[1], k_prev2[1], d_curr[1];
|
||
|
|
if(CopyBuffer(Stoch_Handle, MAIN_LINE, 0, 1, k_curr) > 0) Stoch_K_Current = k_curr[0];
|
||
|
|
if(CopyBuffer(Stoch_Handle, MAIN_LINE, 1, 1, k_prev) > 0) Stoch_K_Previous = k_prev[0];
|
||
|
|
if(CopyBuffer(Stoch_Handle, MAIN_LINE, 2, 1, k_prev2) > 0) Stoch_K_Prev2 = k_prev2[0];
|
||
|
|
if(CopyBuffer(Stoch_Handle, SIGNAL_LINE, 0, 1, d_curr) > 0) Stoch_D_Current = d_curr[0];
|
||
|
|
|
||
|
|
double atr[1], adx[1];
|
||
|
|
if(CopyBuffer(ATR_Handle, 0, 0, 1, atr) > 0) Current_ATR = atr[0];
|
||
|
|
if(CopyBuffer(ADX_Handle, 0, 0, 1, adx) > 0) Current_ADX = adx[0];
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void DetectWarnings()
|
||
|
|
{
|
||
|
|
double current = MidPrice();
|
||
|
|
double bufferPts = (double)MA_Touch_Buffer;
|
||
|
|
double prev = iClose(_Symbol, PERIOD_CURRENT, 1);
|
||
|
|
|
||
|
|
// MFIB levels array for use throughout function
|
||
|
|
double mfib_levels[5] = {MFIB_Level_236, MFIB_Level_382, MFIB_Level_050, MFIB_Level_618, MFIB_Level_786};
|
||
|
|
|
||
|
|
// Reset all warnings
|
||
|
|
MA7_Cross_14_Warning = false;
|
||
|
|
MA7_Cross_21_Warning = false;
|
||
|
|
MA50_Break_Warning = false;
|
||
|
|
|
||
|
|
Fib_Reject_Warning = false;
|
||
|
|
MFIB_Reject_Warning = false;
|
||
|
|
Fib_Reclaim_Warning = false;
|
||
|
|
MFIB_Reclaim_Warning = false;
|
||
|
|
Fib_Break_Warning = false;
|
||
|
|
MFIB_Break_Warning = false;
|
||
|
|
|
||
|
|
MA_Reject_Warning = false;
|
||
|
|
MA_Reclaim_Warning = false;
|
||
|
|
MA_Break_Warning = false;
|
||
|
|
|
||
|
|
Stoch_Extreme_Warning = false;
|
||
|
|
Stoch_Reject_Warning = false;
|
||
|
|
Stoch_Level_Cross = false;
|
||
|
|
|
||
|
|
MA50_Warning = false;
|
||
|
|
MA140_Warning = false;
|
||
|
|
MA230_Warning = false;
|
||
|
|
MA500_Warning = false;
|
||
|
|
|
||
|
|
Pullback_Warning = false;
|
||
|
|
Retracement_Warning = false;
|
||
|
|
Band_Snap_Warning = false;
|
||
|
|
|
||
|
|
//================================================================
|
||
|
|
// 1) STOCHASTIC ANALYSIS
|
||
|
|
//================================================================
|
||
|
|
|
||
|
|
// A) Extreme levels
|
||
|
|
if(Stoch_K_Current <= Stoch_Extreme_Low || Stoch_K_Current >= Stoch_Extreme_High)
|
||
|
|
Stoch_Extreme_Warning = true;
|
||
|
|
|
||
|
|
// B) Cross at key levels (20, 35, 50, 65, 80)
|
||
|
|
bool k_crossed_d = false;
|
||
|
|
bool near_key_level = false;
|
||
|
|
|
||
|
|
// Check if K crossed D (either direction)
|
||
|
|
if((Stoch_K_Previous < Stoch_D_Current && Stoch_K_Current >= Stoch_D_Current) ||
|
||
|
|
(Stoch_K_Previous > Stoch_D_Current && Stoch_K_Current <= Stoch_D_Current))
|
||
|
|
{
|
||
|
|
k_crossed_d = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check if current stoch is near any key level
|
||
|
|
for(int i=0; i<5; i++)
|
||
|
|
{
|
||
|
|
if(MathAbs(Stoch_K_Current - Stoch_Levels[i]) <= 5.0)
|
||
|
|
{
|
||
|
|
near_key_level = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(k_crossed_d && near_key_level)
|
||
|
|
Stoch_Level_Cross = true;
|
||
|
|
|
||
|
|
// C) Reject patterns (cross at meaningful bands)
|
||
|
|
bool stoch_reject_down = (StochCrossDown() && Stoch_K_Current > 50);
|
||
|
|
bool stoch_reject_up = (StochCrossUp() && Stoch_K_Current < 50);
|
||
|
|
if(stoch_reject_down || stoch_reject_up || Stoch_Level_Cross)
|
||
|
|
Stoch_Reject_Warning = true;
|
||
|
|
|
||
|
|
//================================================================
|
||
|
|
// 2) MA CROSS ANALYSIS
|
||
|
|
//================================================================
|
||
|
|
|
||
|
|
// MA7 x MA14 cross (pullback signal)
|
||
|
|
bool ma7_crossed_14_down = (MA_Previous[0] > MA_Previous[1]) && (MA_Current[0] <= MA_Current[1]);
|
||
|
|
bool ma7_crossed_14_up = (MA_Previous[0] < MA_Previous[1]) && (MA_Current[0] >= MA_Current[1]);
|
||
|
|
if(ma7_crossed_14_down || ma7_crossed_14_up)
|
||
|
|
{
|
||
|
|
MA7_Cross_14_Warning = true;
|
||
|
|
Pullback_Warning = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// MA7 x MA21 cross (retracement signal)
|
||
|
|
bool ma7_crossed_21_down = (MA_Previous[0] > MA_Previous[2]) && (MA_Current[0] <= MA_Current[2]);
|
||
|
|
bool ma7_crossed_21_up = (MA_Previous[0] < MA_Previous[2]) && (MA_Current[0] >= MA_Current[2]);
|
||
|
|
if(ma7_crossed_21_down || ma7_crossed_21_up)
|
||
|
|
{
|
||
|
|
MA7_Cross_21_Warning = true;
|
||
|
|
Retracement_Warning = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// MA50 break (reversal warning)
|
||
|
|
bool ma7_broke_50_down = (MA_Previous[0] > MA_Previous[3]) && (MA_Current[0] <= MA_Current[3]);
|
||
|
|
bool ma7_broke_50_up = (MA_Previous[0] < MA_Previous[3]) && (MA_Current[0] >= MA_Current[3]);
|
||
|
|
if(ma7_broke_50_down || ma7_broke_50_up)
|
||
|
|
MA50_Break_Warning = true;
|
||
|
|
|
||
|
|
//================================================================
|
||
|
|
// 3) BAND SNAP
|
||
|
|
//================================================================
|
||
|
|
if(Current_ATR > 0.0)
|
||
|
|
{
|
||
|
|
double distance = MathAbs(current - MA_Current[0]);
|
||
|
|
double band_threshold = Current_ATR * Band_Snap_ATR_Multiplier;
|
||
|
|
if(distance >= band_threshold)
|
||
|
|
Band_Snap_Warning = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//================================================================
|
||
|
|
// 5) FIBONACCI LEVEL ANALYSIS (Reject, Reclaim, Break)
|
||
|
|
//================================================================
|
||
|
|
|
||
|
|
bool at_fib = false;
|
||
|
|
int fib_level_idx = -1;
|
||
|
|
|
||
|
|
for(int i=1; i<6; i++)
|
||
|
|
{
|
||
|
|
if(NearLevel(current, PriceLevels[i], bufferPts))
|
||
|
|
{
|
||
|
|
at_fib = true;
|
||
|
|
fib_level_idx = i;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(at_fib)
|
||
|
|
{
|
||
|
|
double fib_level = PriceLevels[fib_level_idx];
|
||
|
|
|
||
|
|
// REJECT: Price hits level + stoch reject/extreme
|
||
|
|
if(Stoch_Extreme_Warning || Stoch_Reject_Warning || Stoch_Level_Cross)
|
||
|
|
Fib_Reject_Warning = true;
|
||
|
|
|
||
|
|
// RECLAIM: Price crosses back above/below level
|
||
|
|
if((prev < fib_level && current > fib_level) || (prev > fib_level && current < fib_level))
|
||
|
|
Fib_Reclaim_Warning = true;
|
||
|
|
|
||
|
|
// BREAK: Price decisively breaks through
|
||
|
|
if(MathAbs(current - fib_level) > bufferPts * 1.5)
|
||
|
|
Fib_Break_Warning = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//================================================================
|
||
|
|
// 6) MFIB LEVEL ANALYSIS (Reject, Reclaim, Break)
|
||
|
|
//================================================================
|
||
|
|
|
||
|
|
bool at_mfib = false;
|
||
|
|
double mfib_level = 0;
|
||
|
|
|
||
|
|
for(int i=0; i<5; i++)
|
||
|
|
{
|
||
|
|
if(NearLevel(current, mfib_levels[i], bufferPts))
|
||
|
|
{
|
||
|
|
at_mfib = true;
|
||
|
|
mfib_level = mfib_levels[i];
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(at_mfib)
|
||
|
|
{
|
||
|
|
// REJECT: Price hits MFIB + stoch signal
|
||
|
|
if(Stoch_Extreme_Warning || Stoch_Reject_Warning || Stoch_Level_Cross)
|
||
|
|
MFIB_Reject_Warning = true;
|
||
|
|
|
||
|
|
// RECLAIM: Price crosses MFIB level
|
||
|
|
if((prev < mfib_level && current > mfib_level) || (prev > mfib_level && current < mfib_level))
|
||
|
|
MFIB_Reclaim_Warning = true;
|
||
|
|
|
||
|
|
// BREAK: Price breaks through MFIB decisively
|
||
|
|
if(MathAbs(current - mfib_level) > bufferPts * 1.5)
|
||
|
|
MFIB_Break_Warning = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//================================================================
|
||
|
|
// 7) STRONG MA ANALYSIS (50, 140, 230, 500)
|
||
|
|
//================================================================
|
||
|
|
|
||
|
|
// Check proximity to each strong MA
|
||
|
|
bool at_ma50 = NearLevel(current, MA_Current[3], bufferPts);
|
||
|
|
bool at_ma140 = NearLevel(current, MA_Current[4], bufferPts);
|
||
|
|
bool at_ma230 = NearLevel(current, MA_Current[5], bufferPts);
|
||
|
|
bool at_ma500 = NearLevel(current, MA_Current[6], bufferPts);
|
||
|
|
|
||
|
|
if(at_ma50) MA50_Warning = true;
|
||
|
|
if(at_ma140) MA140_Warning = true;
|
||
|
|
if(at_ma230) MA230_Warning = true;
|
||
|
|
if(at_ma500) MA500_Warning = true;
|
||
|
|
|
||
|
|
// MA REJECT: At strong MA + stoch signal
|
||
|
|
if((at_ma50 || at_ma140 || at_ma230 || at_ma500) &&
|
||
|
|
(Stoch_Extreme_Warning || Stoch_Reject_Warning || Stoch_Level_Cross))
|
||
|
|
{
|
||
|
|
MA_Reject_Warning = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// MA RECLAIM: Price reclaims strong MA
|
||
|
|
|
||
|
|
if(at_ma50 && ((prev < MA_Current[3] && current > MA_Current[3]) ||
|
||
|
|
(prev > MA_Current[3] && current < MA_Current[3])))
|
||
|
|
MA_Reclaim_Warning = true;
|
||
|
|
|
||
|
|
if(at_ma140 && ((prev < MA_Current[4] && current > MA_Current[4]) ||
|
||
|
|
(prev > MA_Current[4] && current < MA_Current[4])))
|
||
|
|
MA_Reclaim_Warning = true;
|
||
|
|
|
||
|
|
// MA BREAK: Price breaks away from MA
|
||
|
|
if((at_ma50 || at_ma140 || at_ma230) && MathAbs(current - MA_Current[3]) > bufferPts * 2)
|
||
|
|
MA_Break_Warning = true;
|
||
|
|
|
||
|
|
//================================================================
|
||
|
|
// 8) PULLBACK CONFLUENCE
|
||
|
|
// Mix and match: (MA, Fib, MFIB, Stoch) x (Reject, Reclaim, Break)
|
||
|
|
//================================================================
|
||
|
|
|
||
|
|
// Any 2+ of these combinations = pullback signal
|
||
|
|
int pullback_signals = 0;
|
||
|
|
|
||
|
|
if(MA7_Cross_14_Warning) pullback_signals++;
|
||
|
|
if(Fib_Reject_Warning) pullback_signals++;
|
||
|
|
if(MFIB_Reject_Warning) pullback_signals++;
|
||
|
|
if(MA_Reject_Warning) pullback_signals++;
|
||
|
|
if(Stoch_Level_Cross) pullback_signals++;
|
||
|
|
if(Band_Snap_Warning) pullback_signals++;
|
||
|
|
if(Fib_Reclaim_Warning) pullback_signals++;
|
||
|
|
if(MFIB_Reclaim_Warning) pullback_signals++;
|
||
|
|
if(MA_Reclaim_Warning) pullback_signals++;
|
||
|
|
|
||
|
|
if(pullback_signals >= 2)
|
||
|
|
Pullback_Warning = true;
|
||
|
|
|
||
|
|
//================================================================
|
||
|
|
// 9) WARNING CONFLUENCE COUNT
|
||
|
|
//================================================================
|
||
|
|
Warning_Confluence_Count = 0;
|
||
|
|
|
||
|
|
if(Stoch_Extreme_Warning) Warning_Confluence_Count++;
|
||
|
|
if(Stoch_Reject_Warning) Warning_Confluence_Count++;
|
||
|
|
if(Stoch_Level_Cross) Warning_Confluence_Count++;
|
||
|
|
|
||
|
|
if(MA7_Cross_14_Warning) Warning_Confluence_Count++;
|
||
|
|
if(MA7_Cross_21_Warning) Warning_Confluence_Count++;
|
||
|
|
if(MA50_Break_Warning) Warning_Confluence_Count++;
|
||
|
|
|
||
|
|
if(Fib_Reject_Warning) Warning_Confluence_Count++;
|
||
|
|
if(MFIB_Reject_Warning) Warning_Confluence_Count++;
|
||
|
|
if(MA_Reject_Warning) Warning_Confluence_Count++;
|
||
|
|
|
||
|
|
if(Fib_Reclaim_Warning) Warning_Confluence_Count++;
|
||
|
|
if(MFIB_Reclaim_Warning) Warning_Confluence_Count++;
|
||
|
|
if(MA_Reclaim_Warning) Warning_Confluence_Count++;
|
||
|
|
|
||
|
|
if(Band_Snap_Warning) Warning_Confluence_Count++;
|
||
|
|
|
||
|
|
if(MA50_Warning) Warning_Confluence_Count++;
|
||
|
|
if(MA140_Warning) Warning_Confluence_Count++;
|
||
|
|
if(MA230_Warning) Warning_Confluence_Count++;
|
||
|
|
if(MA500_Warning) Warning_Confluence_Count++;
|
||
|
|
|
||
|
|
Warning_Confluence_3Plus = (Warning_Confluence_Count >= 3);
|
||
|
|
|
||
|
|
//================================================================
|
||
|
|
// 10) RE-ENTRY COMBO FLAGS
|
||
|
|
//================================================================
|
||
|
|
|
||
|
|
// Strong MA flag for use in re-entry detection
|
||
|
|
bool at_strong_ma = (MA140_Warning || MA230_Warning || MA500_Warning);
|
||
|
|
|
||
|
|
// MA14 Magnet: Price hugging MA14 (within 0.7 ATR)
|
||
|
|
MA14_Magnet_Active = false;
|
||
|
|
if(Current_ATR > 0.0)
|
||
|
|
{
|
||
|
|
double distance_to_ma14 = MathAbs(current - MA_Current[1]);
|
||
|
|
if((distance_to_ma14 / Current_ATR) < 0.7)
|
||
|
|
MA14_Magnet_Active = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Fib Break Confirmed: Price cleanly broke through fib level
|
||
|
|
Fib_Break_Confirmed = false;
|
||
|
|
for(int i=1; i<6; i++)
|
||
|
|
{
|
||
|
|
if(MathAbs(prev - PriceLevels[i]) < bufferPts * 0.5 && // Was near level
|
||
|
|
MathAbs(current - PriceLevels[i]) > bufferPts * 2.0) // Now far from level
|
||
|
|
{
|
||
|
|
Fib_Break_Confirmed = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// MFIB Break Confirmed: Price cleanly broke through MFIB level
|
||
|
|
MFIB_Break_Confirmed = false;
|
||
|
|
for(int i=0; i<5; i++)
|
||
|
|
{
|
||
|
|
if(MathAbs(prev - mfib_levels[i]) < bufferPts * 0.5 &&
|
||
|
|
MathAbs(current - mfib_levels[i]) > bufferPts * 2.0)
|
||
|
|
{
|
||
|
|
MFIB_Break_Confirmed = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Strong MA Bounce: Price touched strong MA and bounced with stoch confirmation
|
||
|
|
Strong_MA_Bounce = false;
|
||
|
|
if(at_strong_ma)
|
||
|
|
{
|
||
|
|
// Check if price was on opposite side of MA and now back
|
||
|
|
bool ma140_bounce = false, ma230_bounce = false, ma500_bounce = false;
|
||
|
|
|
||
|
|
if(MA140_Warning)
|
||
|
|
{
|
||
|
|
if((prev < MA_Current[4] && current > MA_Current[4]) ||
|
||
|
|
(prev > MA_Current[4] && current < MA_Current[4]))
|
||
|
|
ma140_bounce = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(MA230_Warning)
|
||
|
|
{
|
||
|
|
if((prev < MA_Current[5] && current > MA_Current[5]) ||
|
||
|
|
(prev > MA_Current[5] && current < MA_Current[5]))
|
||
|
|
ma230_bounce = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(MA500_Warning)
|
||
|
|
{
|
||
|
|
if((prev < MA_Current[6] && current > MA_Current[6]) ||
|
||
|
|
(prev > MA_Current[6] && current < MA_Current[6]))
|
||
|
|
ma500_bounce = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if((ma140_bounce || ma230_bounce || ma500_bounce) &&
|
||
|
|
(Stoch_Level_Cross || Stoch_Reject_Warning))
|
||
|
|
Strong_MA_Bounce = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Trend Resumption: MA50 reclaimed after pullback
|
||
|
|
Trend_Resumption = false;
|
||
|
|
if(IsBullBias() && Bull_MA50_Reclaimed()) Trend_Resumption = true;
|
||
|
|
if(IsBearBias() && Bear_MA50_Reclaimed()) Trend_Resumption = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
// PRAISE SYSTEM: Detect 8 Aggressive Trend Signals
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void DetectPraiseSignals()
|
||
|
|
{
|
||
|
|
if(!Use_Praise_System)
|
||
|
|
{
|
||
|
|
Praise_Count = 0;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
double current = MidPrice();
|
||
|
|
double bufferPts = (double)MA_Touch_Buffer;
|
||
|
|
|
||
|
|
// Reset all praise flags
|
||
|
|
Praise_Triple_Magnet = false;
|
||
|
|
Praise_Power_Couple = false;
|
||
|
|
Praise_MFIB_Staircase = false;
|
||
|
|
Praise_MFIB_Express = false;
|
||
|
|
Praise_MFIB_Breakout = false;
|
||
|
|
Praise_MA_Stack = false;
|
||
|
|
Praise_Clean_Reclaim = false;
|
||
|
|
Praise_Multi_Breakout = false;
|
||
|
|
|
||
|
|
//================================================================
|
||
|
|
// CATEGORY 1: MA MAGNET PERFECTION
|
||
|
|
//================================================================
|
||
|
|
|
||
|
|
// PRAISE 1: 7x14x21 Triple Magnet Hold
|
||
|
|
if(Current_ATR > 0.0)
|
||
|
|
{
|
||
|
|
double dist7 = MathAbs(current - MA_Current[0]) / Current_ATR;
|
||
|
|
double dist14 = MathAbs(current - MA_Current[1]) / Current_ATR;
|
||
|
|
double dist21 = MathAbs(current - MA_Current[2]) / Current_ATR;
|
||
|
|
|
||
|
|
bool all_close = (dist7 < 0.5) && (dist14 < 0.7) && (dist21 < 0.9);
|
||
|
|
bool mas_trending = (MA_Current[0] > MA_Previous[0] && MA_Current[1] > MA_Previous[1] && MA_Current[2] > MA_Previous[2]) ||
|
||
|
|
(MA_Current[0] < MA_Previous[0] && MA_Current[1] < MA_Previous[1] && MA_Current[2] < MA_Previous[2]);
|
||
|
|
|
||
|
|
if(all_close && mas_trending && !Band_Snap_Warning)
|
||
|
|
Praise_Triple_Magnet = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// PRAISE 2: 14x21 Power Couple
|
||
|
|
if(Current_ATR > 0.0)
|
||
|
|
{
|
||
|
|
double dist_14_21 = MathAbs(MA_Current[1] - MA_Current[2]) / Current_ATR;
|
||
|
|
bool couple_close = (dist_14_21 < 0.3);
|
||
|
|
bool same_direction = (MA_Current[1] > MA_Previous[1] && MA_Current[2] > MA_Previous[2]) ||
|
||
|
|
(MA_Current[1] < MA_Previous[1] && MA_Current[2] < MA_Previous[2]);
|
||
|
|
bool ma7_correct_side = (IsBullBias() && MA_Current[0] > MA_Current[1]) ||
|
||
|
|
(IsBearBias() && MA_Current[0] < MA_Current[1]);
|
||
|
|
bool price_hugging = MathAbs(current - MA_Current[1]) / Current_ATR < 0.8 ||
|
||
|
|
MathAbs(current - MA_Current[2]) / Current_ATR < 0.8;
|
||
|
|
|
||
|
|
if(couple_close && same_direction && ma7_correct_side && price_hugging)
|
||
|
|
Praise_Power_Couple = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//================================================================
|
||
|
|
// CATEGORY 2: MFIB MOMENTUM
|
||
|
|
//================================================================
|
||
|
|
|
||
|
|
// PRAISE 3: MFIB Staircase Advance
|
||
|
|
// Track if price is advancing through MFIB levels sequentially
|
||
|
|
static double last_mfib_level = 0;
|
||
|
|
static int mfib_advances = 0;
|
||
|
|
|
||
|
|
double mfib_levels[5] = {MFIB_Level_786, MFIB_Level_618, MFIB_Level_050, MFIB_Level_382, MFIB_Level_236};
|
||
|
|
|
||
|
|
for(int i=0; i<5; i++)
|
||
|
|
{
|
||
|
|
if(MathAbs(current - mfib_levels[i]) / _Point < 30) // Just crossed this level
|
||
|
|
{
|
||
|
|
if(IsBullBias())
|
||
|
|
{
|
||
|
|
if(i > 0 && last_mfib_level == mfib_levels[i-1]) // Sequential advance
|
||
|
|
mfib_advances++;
|
||
|
|
}
|
||
|
|
else if(IsBearBias())
|
||
|
|
{
|
||
|
|
if(i < 4 && last_mfib_level == mfib_levels[i+1]) // Sequential decline
|
||
|
|
mfib_advances++;
|
||
|
|
}
|
||
|
|
|
||
|
|
last_mfib_level = mfib_levels[i];
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(mfib_advances >= 2 && !MFIB_Reject_Warning)
|
||
|
|
Praise_MFIB_Staircase = true;
|
||
|
|
|
||
|
|
// Reset counter if no advance for 10 bars
|
||
|
|
static datetime last_advance_time = 0;
|
||
|
|
if(TimeCurrent() - last_advance_time > 10 * PeriodSeconds())
|
||
|
|
{
|
||
|
|
mfib_advances = 0;
|
||
|
|
last_mfib_level = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
// PRAISE 4: MFIB Express (skips a level)
|
||
|
|
static double prev_mfib_zone = 0;
|
||
|
|
double curr_mfib_zone = 0;
|
||
|
|
|
||
|
|
// Determine which MFIB zone we're in
|
||
|
|
for(int i=0; i<5; i++)
|
||
|
|
{
|
||
|
|
if(MathAbs(current - mfib_levels[i]) / _Point < 50)
|
||
|
|
{
|
||
|
|
curr_mfib_zone = i;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(curr_mfib_zone > 0 && prev_mfib_zone > 0)
|
||
|
|
{
|
||
|
|
double zone_diff = MathAbs(curr_mfib_zone - prev_mfib_zone);
|
||
|
|
if(zone_diff >= 2 && Current_ADX > 25) // Skipped at least one level
|
||
|
|
Praise_MFIB_Express = true;
|
||
|
|
}
|
||
|
|
prev_mfib_zone = curr_mfib_zone;
|
||
|
|
|
||
|
|
// PRAISE 5: MFIB Breakout Hold
|
||
|
|
static int mfib_breakout_hold_bars = 0;
|
||
|
|
|
||
|
|
if(MFIB_Break_Confirmed)
|
||
|
|
mfib_breakout_hold_bars++;
|
||
|
|
else
|
||
|
|
mfib_breakout_hold_bars = 0;
|
||
|
|
|
||
|
|
if(mfib_breakout_hold_bars >= 3 && !MFIB_Reject_Warning)
|
||
|
|
{
|
||
|
|
bool ma7_correct = (IsBullBias() && MA_Current[0] > last_mfib_level) ||
|
||
|
|
(IsBearBias() && MA_Current[0] < last_mfib_level);
|
||
|
|
if(ma7_correct)
|
||
|
|
Praise_MFIB_Breakout = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//================================================================
|
||
|
|
// CATEGORY 3: STRUCTURE PERFECTION
|
||
|
|
//================================================================
|
||
|
|
|
||
|
|
// PRAISE 6: MA Stack Perfection
|
||
|
|
bool stack_bull = (MA_Current[0] > MA_Current[1]) && (MA_Current[1] > MA_Current[2]) &&
|
||
|
|
(MA_Current[2] > MA_Current[3]) && (MA_Current[3] > MA_Current[4]);
|
||
|
|
bool stack_bear = (MA_Current[0] < MA_Current[1]) && (MA_Current[1] < MA_Current[2]) &&
|
||
|
|
(MA_Current[2] < MA_Current[3]) && (MA_Current[3] < MA_Current[4]);
|
||
|
|
|
||
|
|
// Check proper spacing (not bunched)
|
||
|
|
bool properly_spaced = true;
|
||
|
|
if(Current_ATR > 0.0)
|
||
|
|
{
|
||
|
|
for(int i=0; i<4; i++)
|
||
|
|
{
|
||
|
|
double spacing = MathAbs(MA_Current[i] - MA_Current[i+1]) / Current_ATR;
|
||
|
|
if(spacing < 0.1) // Too close = bunched
|
||
|
|
{
|
||
|
|
properly_spaced = false;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// All MAs trending (not flat)
|
||
|
|
bool all_trending = true;
|
||
|
|
for(int i=0; i<5; i++)
|
||
|
|
{
|
||
|
|
if(MathAbs(MA_Current[i] - MA_Previous[i]) / _Point < 5) // Flat
|
||
|
|
{
|
||
|
|
all_trending = false;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if((stack_bull || stack_bear) && properly_spaced && all_trending)
|
||
|
|
Praise_MA_Stack = true;
|
||
|
|
|
||
|
|
// PRAISE 7: Clean Reclaim Sequence
|
||
|
|
// MFIB + MA + Fib all reclaimed in same zone
|
||
|
|
bool triple_reclaim = false;
|
||
|
|
|
||
|
|
if(MFIB_Reclaim_Warning && MA_Reclaim_Warning && Fib_Reclaim_Warning)
|
||
|
|
{
|
||
|
|
// Check if all within 100 points
|
||
|
|
double mfib_price = 0, ma_price = 0, fib_price = 0;
|
||
|
|
|
||
|
|
// Find which MFIB was reclaimed
|
||
|
|
for(int i=0; i<5; i++)
|
||
|
|
{
|
||
|
|
if(MathAbs(current - mfib_levels[i]) / _Point < 100)
|
||
|
|
{
|
||
|
|
mfib_price = mfib_levels[i];
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Find which MA was reclaimed (50, 140, 230)
|
||
|
|
if(MA50_Warning) ma_price = MA_Current[3];
|
||
|
|
else if(MA140_Warning) ma_price = MA_Current[4];
|
||
|
|
else if(MA230_Warning) ma_price = MA_Current[5];
|
||
|
|
|
||
|
|
// Find which Fib was reclaimed
|
||
|
|
for(int i=1; i<6; i++)
|
||
|
|
{
|
||
|
|
if(MathAbs(current - PriceLevels[i]) / _Point < 100)
|
||
|
|
{
|
||
|
|
fib_price = PriceLevels[i];
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(mfib_price > 0 && ma_price > 0 && fib_price > 0)
|
||
|
|
{
|
||
|
|
if(MathAbs(mfib_price - ma_price) / _Point < 100 &&
|
||
|
|
MathAbs(mfib_price - fib_price) / _Point < 100)
|
||
|
|
triple_reclaim = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(triple_reclaim)
|
||
|
|
Praise_Clean_Reclaim = true;
|
||
|
|
|
||
|
|
//================================================================
|
||
|
|
// CATEGORY 4: BREAKOUT CONFIRMATION
|
||
|
|
//================================================================
|
||
|
|
|
||
|
|
// PRAISE 8: Multi-Level Breakout
|
||
|
|
static int breakout_time_window = 0;
|
||
|
|
static bool mfib_broke = false, fib_broke = false, ma_broke = false;
|
||
|
|
|
||
|
|
// Track breakouts
|
||
|
|
if(MFIB_Break_Confirmed) mfib_broke = true;
|
||
|
|
if(Fib_Break_Warning) fib_broke = true;
|
||
|
|
if(MA_Break_Warning) ma_broke = true;
|
||
|
|
|
||
|
|
if(mfib_broke || fib_broke || ma_broke)
|
||
|
|
breakout_time_window++;
|
||
|
|
|
||
|
|
// If all 3 broke within 5 bars = multi-breakout
|
||
|
|
if(breakout_time_window > 0 && breakout_time_window <= 5)
|
||
|
|
{
|
||
|
|
if(mfib_broke && fib_broke && ma_broke)
|
||
|
|
Praise_Multi_Breakout = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Reset window after 5 bars
|
||
|
|
if(breakout_time_window > 5)
|
||
|
|
{
|
||
|
|
breakout_time_window = 0;
|
||
|
|
mfib_broke = false;
|
||
|
|
fib_broke = false;
|
||
|
|
ma_broke = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//================================================================
|
||
|
|
// COUNT TOTAL PRAISE
|
||
|
|
//================================================================
|
||
|
|
Praise_Count = 0;
|
||
|
|
if(Praise_Triple_Magnet) Praise_Count++;
|
||
|
|
if(Praise_Power_Couple) Praise_Count++;
|
||
|
|
if(Praise_MFIB_Staircase) Praise_Count++;
|
||
|
|
if(Praise_MFIB_Express) Praise_Count++;
|
||
|
|
if(Praise_MFIB_Breakout) Praise_Count++;
|
||
|
|
if(Praise_MA_Stack) Praise_Count++;
|
||
|
|
if(Praise_Clean_Reclaim) Praise_Count++;
|
||
|
|
if(Praise_Multi_Breakout) Praise_Count++;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void DetectFamilyBiasStrength(MODE_FAMILY &family, TREND_BIAS &bias, TREND_STRENGTH &strength)
|
||
|
|
{
|
||
|
|
double current = MidPrice();
|
||
|
|
|
||
|
|
bool mas_aligned_bull = (MA_Current[0] > MA_Current[1]) && (MA_Current[1] > MA_Current[2]) && (MA_Current[2] > MA_Current[3]);
|
||
|
|
bool mas_aligned_bear = (MA_Current[0] < MA_Current[1]) && (MA_Current[1] < MA_Current[2]) && (MA_Current[2] < MA_Current[3]);
|
||
|
|
|
||
|
|
double recent_high = iHigh(_Symbol, PERIOD_CURRENT, 0);
|
||
|
|
double recent_low = iLow(_Symbol, PERIOD_CURRENT, 0);
|
||
|
|
for(int i=1; i<20; i++)
|
||
|
|
{
|
||
|
|
recent_high = MathMax(recent_high, iHigh(_Symbol, PERIOD_CURRENT, i));
|
||
|
|
recent_low = MathMin(recent_low, iLow(_Symbol, PERIOD_CURRENT, i));
|
||
|
|
}
|
||
|
|
double range_size = (recent_high - recent_low) / current;
|
||
|
|
bool is_ranging = (range_size < Range_Price_Threshold);
|
||
|
|
|
||
|
|
bool ma_clustered = false;
|
||
|
|
if(Current_ATR > 0.0)
|
||
|
|
ma_clustered = ((MathAbs(MA_Current[0] - MA_Current[3]) / Current_ATR) < Chop_ATR_Threshold);
|
||
|
|
bool is_choppy = (ma_clustered || Current_ADX < 15);
|
||
|
|
|
||
|
|
// Bias detection WITH MFIB .382 confirmation
|
||
|
|
if(mas_aligned_bull && (MFIB_Bias == BIAS_BULL || !Use_MFIB_382_Bias))
|
||
|
|
bias = BIAS_BULL;
|
||
|
|
else if(mas_aligned_bear && (MFIB_Bias == BIAS_BEAR || !Use_MFIB_382_Bias))
|
||
|
|
bias = BIAS_BEAR;
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// Use MFIB bias as tiebreaker when MAs not fully aligned
|
||
|
|
if(MFIB_Bias == BIAS_BULL && MA_Current[0] > MA_Current[3])
|
||
|
|
bias = BIAS_BULL;
|
||
|
|
else if(MFIB_Bias == BIAS_BEAR && MA_Current[0] < MA_Current[3])
|
||
|
|
bias = BIAS_BEAR;
|
||
|
|
else if(MA_Current[0] > MA_Current[3])
|
||
|
|
bias = BIAS_BULL;
|
||
|
|
else if(MA_Current[0] < MA_Current[3])
|
||
|
|
bias = BIAS_BEAR;
|
||
|
|
else
|
||
|
|
bias = BIAS_NEUTRAL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(is_choppy && !(mas_aligned_bull || mas_aligned_bear))
|
||
|
|
family = FAMILY_CHOP;
|
||
|
|
else if(is_ranging && !(mas_aligned_bull || mas_aligned_bear))
|
||
|
|
family = FAMILY_RANGING;
|
||
|
|
else if(bias != BIAS_NEUTRAL)
|
||
|
|
family = FAMILY_TRENDING;
|
||
|
|
else
|
||
|
|
family = FAMILY_TRANSITIONAL;
|
||
|
|
|
||
|
|
if(Current_ADX > 25 && (mas_aligned_bull || mas_aligned_bear))
|
||
|
|
strength = STRENGTH_STRONG;
|
||
|
|
else if(Current_ADX > 18 && (mas_aligned_bull || mas_aligned_bear))
|
||
|
|
strength = STRENGTH_CONFIRMED;
|
||
|
|
else
|
||
|
|
strength = STRENGTH_WEAK;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
PRICE_STATE DetermineStateFromContext()
|
||
|
|
{
|
||
|
|
if(Current_Family == FAMILY_RANGING)
|
||
|
|
{
|
||
|
|
double current = MidPrice();
|
||
|
|
double bufferPts = (double)MA_Touch_Buffer;
|
||
|
|
|
||
|
|
bool near_low = NearLevel(current, PriceLevels[1], bufferPts) || NearLevel(current, PriceLevels[0], bufferPts);
|
||
|
|
bool near_high = NearLevel(current, PriceLevels[5], bufferPts) || NearLevel(current, PriceLevels[6], bufferPts);
|
||
|
|
|
||
|
|
if(near_low || near_high) return STATE_RANGE_EDGE_TEST;
|
||
|
|
if(Stoch_Reject_Warning || Stoch_Extreme_Warning || Fib_Reject_Warning || MFIB_Reject_Warning) return STATE_RANGE_REJECTION;
|
||
|
|
|
||
|
|
double close0 = iClose(_Symbol, PERIOD_CURRENT, 0);
|
||
|
|
if(close0 > PriceLevels[6] || close0 < PriceLevels[0]) return STATE_RANGE_BREAK_CONFIRMED;
|
||
|
|
if(NearLevel(current, PriceLevels[6], bufferPts) || NearLevel(current, PriceLevels[0], bufferPts)) return STATE_RANGE_BREAK_ATTEMPT;
|
||
|
|
|
||
|
|
return STATE_RANGE_MID_DRIFT;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(Current_Family == FAMILY_CHOP)
|
||
|
|
{
|
||
|
|
if(Current_ADX < 12 && !Stoch_Reject_Warning) return STATE_CHOP_NOISE;
|
||
|
|
|
||
|
|
if(Current_ATR > 0)
|
||
|
|
{
|
||
|
|
double body = MathAbs(iClose(_Symbol, PERIOD_CURRENT, 0) - iOpen(_Symbol, PERIOD_CURRENT, 0));
|
||
|
|
if((body / Current_ATR) > 1.2) return STATE_CHOP_VOL_SPIKE;
|
||
|
|
|
||
|
|
double cluster = MathAbs(MA_Current[0] - MA_Current[3]) / Current_ATR;
|
||
|
|
if(Current_ADX < 15 && cluster < 0.25) return STATE_CHOP_SQUEEZE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(Stoch_Reject_Warning) return STATE_CHOP_FAKEOUT_LOOP;
|
||
|
|
return STATE_CHOP_NOISE;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ma7_above_14 = (MA_Current[0] > MA_Current[1]);
|
||
|
|
bool ma7_above_21 = (MA_Current[0] > MA_Current[2]);
|
||
|
|
bool ma7_above_50 = (MA_Current[0] > MA_Current[3]);
|
||
|
|
bool ma14_above_50 = (MA_Current[1] > MA_Current[3]);
|
||
|
|
bool ma21_above_50 = (MA_Current[2] > MA_Current[3]);
|
||
|
|
|
||
|
|
bool ma7_below_14 = (MA_Current[0] < MA_Current[1]);
|
||
|
|
bool ma7_below_21 = (MA_Current[0] < MA_Current[2]);
|
||
|
|
bool ma7_below_50 = (MA_Current[0] < MA_Current[3]);
|
||
|
|
bool ma14_below_50 = (MA_Current[1] < MA_Current[3]);
|
||
|
|
bool ma21_below_50 = (MA_Current[2] < MA_Current[3]);
|
||
|
|
|
||
|
|
bool structure_intact_bull = (ma14_above_50 && ma21_above_50);
|
||
|
|
bool structure_intact_bear = (ma14_below_50 && ma21_below_50);
|
||
|
|
|
||
|
|
bool pullbackSignal =
|
||
|
|
(Pullback_Warning || MFIB_Reject_Warning || Fib_Reject_Warning ||
|
||
|
|
Stoch_Reject_Warning || Band_Snap_Warning || Stoch_Level_Cross ||
|
||
|
|
MFIB_Reclaim_Warning || Fib_Reclaim_Warning || MA_Reclaim_Warning);
|
||
|
|
|
||
|
|
bool retraceSignal = (MA7_Cross_21_Warning || Retracement_Warning ||
|
||
|
|
MA140_Warning || MA230_Warning || MA500_Warning);
|
||
|
|
|
||
|
|
// Strong MA warnings indicate deeper pullback (potential retracement/reversal)
|
||
|
|
bool strongMA_pressure = (MA140_Warning || MA230_Warning || MA500_Warning || MA50_Warning);
|
||
|
|
|
||
|
|
bool confluenceAligned = false;
|
||
|
|
if(IsBullBias() && structure_intact_bull) confluenceAligned = Warning_Confluence_3Plus;
|
||
|
|
if(IsBearBias() && structure_intact_bear) confluenceAligned = Warning_Confluence_3Plus;
|
||
|
|
|
||
|
|
if(IsBullBias())
|
||
|
|
{
|
||
|
|
if(ma7_below_50 && !ma14_above_50 && !ma21_above_50) return STATE_REVERSAL_CONFIRMED;
|
||
|
|
|
||
|
|
if(MA50_Break_Warning && (retraceSignal || strongMA_pressure || Stoch_Extreme_Warning || Stoch_Reject_Warning || Warning_Confluence_3Plus))
|
||
|
|
return STATE_REVERSAL_ATTEMPT;
|
||
|
|
|
||
|
|
// DEEP RETRACEMENT: MA7x21 cross OR testing strong MAs (140/230/500)
|
||
|
|
if(MA7_Cross_21_Warning || strongMA_pressure || (!ma7_above_21 && (pullbackSignal || retraceSignal || confluenceAligned)))
|
||
|
|
return STATE_DEEP_RETRACEMENT;
|
||
|
|
|
||
|
|
// PULLBACK: MA7x14 cross OR 2+ pullback signals with structure intact
|
||
|
|
if(MA7_Cross_14_Warning || (structure_intact_bull && (pullbackSignal || confluenceAligned)))
|
||
|
|
return STATE_PULLBACK;
|
||
|
|
|
||
|
|
return STATE_CONTINUATION;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(IsBearBias())
|
||
|
|
{
|
||
|
|
if(ma7_above_50 && !ma14_below_50 && !ma21_below_50) return STATE_REVERSAL_CONFIRMED;
|
||
|
|
|
||
|
|
if(MA50_Break_Warning && (retraceSignal || strongMA_pressure || Stoch_Extreme_Warning || Stoch_Reject_Warning || Warning_Confluence_3Plus))
|
||
|
|
return STATE_REVERSAL_ATTEMPT;
|
||
|
|
|
||
|
|
// DEEP RETRACEMENT: MA7x21 cross OR testing strong MAs (140/230/500)
|
||
|
|
if(MA7_Cross_21_Warning || strongMA_pressure || (!ma7_below_21 && (pullbackSignal || retraceSignal || confluenceAligned)))
|
||
|
|
return STATE_DEEP_RETRACEMENT;
|
||
|
|
|
||
|
|
// PULLBACK: MA7x14 cross OR 2+ pullback signals with structure intact
|
||
|
|
if(MA7_Cross_14_Warning || (structure_intact_bear && (pullbackSignal || confluenceAligned)))
|
||
|
|
return STATE_PULLBACK;
|
||
|
|
|
||
|
|
return STATE_CONTINUATION;
|
||
|
|
}
|
||
|
|
|
||
|
|
return STATE_UNKNOWN;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
string FamilyToText(MODE_FAMILY f)
|
||
|
|
{
|
||
|
|
switch(f)
|
||
|
|
{
|
||
|
|
case FAMILY_TRENDING: return "Trending";
|
||
|
|
case FAMILY_RANGING: return "Ranging";
|
||
|
|
case FAMILY_CHOP: return "Chop";
|
||
|
|
case FAMILY_TRANSITIONAL: return "Transitional";
|
||
|
|
}
|
||
|
|
return "Unknown";
|
||
|
|
}
|
||
|
|
|
||
|
|
string BiasToText(TREND_BIAS b)
|
||
|
|
{
|
||
|
|
if(b == BIAS_BULL) return "Bull";
|
||
|
|
if(b == BIAS_BEAR) return "Bear";
|
||
|
|
return "Neutral";
|
||
|
|
}
|
||
|
|
|
||
|
|
string StrengthToText(TREND_STRENGTH s)
|
||
|
|
{
|
||
|
|
switch(s)
|
||
|
|
{
|
||
|
|
case STRENGTH_WEAK: return "Weak";
|
||
|
|
case STRENGTH_CONFIRMED: return "Confirmed";
|
||
|
|
case STRENGTH_STRONG: return "Strong";
|
||
|
|
}
|
||
|
|
return "Weak";
|
||
|
|
}
|
||
|
|
|
||
|
|
string StateToText(PRICE_STATE s)
|
||
|
|
{
|
||
|
|
switch(s)
|
||
|
|
{
|
||
|
|
case STATE_CONTINUATION: return "Continuation";
|
||
|
|
case STATE_PULLBACK: return "Pullback";
|
||
|
|
case STATE_DEEP_RETRACEMENT: return "Deep Retracement";
|
||
|
|
case STATE_REVERSAL_ATTEMPT: return "Reversal Attempt";
|
||
|
|
case STATE_REVERSAL_CONFIRMED: return "Reversal Confirmed";
|
||
|
|
|
||
|
|
case STATE_RANGE_MID_DRIFT: return "Range: Mid Drift";
|
||
|
|
case STATE_RANGE_EDGE_TEST: return "Range: Edge Test";
|
||
|
|
case STATE_RANGE_REJECTION: return "Range: Rejection";
|
||
|
|
case STATE_RANGE_BREAK_ATTEMPT: return "Range: Break Attempt";
|
||
|
|
case STATE_RANGE_BREAK_CONFIRMED: return "Range: Break Confirmed";
|
||
|
|
|
||
|
|
case STATE_CHOP_NOISE: return "Chop: Noise";
|
||
|
|
case STATE_CHOP_VOL_SPIKE: return "Chop: Vol Spike";
|
||
|
|
case STATE_CHOP_SQUEEZE: return "Chop: Squeeze";
|
||
|
|
case STATE_CHOP_FAKEOUT_LOOP: return "Chop: Fakeout Loop";
|
||
|
|
|
||
|
|
default: return "Unknown";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void UpdateLabels()
|
||
|
|
{
|
||
|
|
ObjectDelete(0, "ModeLabel");
|
||
|
|
ObjectCreate(0, "ModeLabel", OBJ_LABEL, 0, 0, 0);
|
||
|
|
ObjectSetInteger(0, "ModeLabel", OBJPROP_CORNER, CORNER_LEFT_UPPER);
|
||
|
|
ObjectSetInteger(0, "ModeLabel", OBJPROP_XDISTANCE, 10);
|
||
|
|
ObjectSetInteger(0, "ModeLabel", OBJPROP_YDISTANCE, 20);
|
||
|
|
|
||
|
|
string mode_text = "MODE: " + FamilyToText(Current_Family);
|
||
|
|
if(Current_Family == FAMILY_TRENDING)
|
||
|
|
mode_text += " | " + StrengthToText(Current_Strength) + " " + BiasToText(Current_Bias);
|
||
|
|
|
||
|
|
color mode_color = clrYellow;
|
||
|
|
if(Current_Family == FAMILY_TRENDING)
|
||
|
|
{
|
||
|
|
if(Current_Bias == BIAS_BULL) mode_color = (Current_Strength == STRENGTH_STRONG ? clrLime : (Current_Strength == STRENGTH_CONFIRMED ? clrGreenYellow : clrGreen));
|
||
|
|
if(Current_Bias == BIAS_BEAR) mode_color = (Current_Strength == STRENGTH_STRONG ? clrRed : (Current_Strength == STRENGTH_CONFIRMED ? clrOrangeRed : clrOrange));
|
||
|
|
}
|
||
|
|
else if(Current_Family == FAMILY_RANGING) mode_color = clrAqua;
|
||
|
|
else if(Current_Family == FAMILY_CHOP) mode_color = clrViolet;
|
||
|
|
|
||
|
|
ObjectSetString(0, "ModeLabel", OBJPROP_TEXT, mode_text);
|
||
|
|
ObjectSetInteger(0, "ModeLabel", OBJPROP_COLOR, mode_color);
|
||
|
|
ObjectSetInteger(0, "ModeLabel", OBJPROP_FONTSIZE, 12);
|
||
|
|
|
||
|
|
// MFIB BIAS LABEL
|
||
|
|
ObjectDelete(0, "MFIBLabel");
|
||
|
|
if(Use_MFIB_382_Bias)
|
||
|
|
{
|
||
|
|
ObjectCreate(0, "MFIBLabel", OBJ_LABEL, 0, 0, 0);
|
||
|
|
ObjectSetInteger(0, "MFIBLabel", OBJPROP_CORNER, CORNER_LEFT_UPPER);
|
||
|
|
ObjectSetInteger(0, "MFIBLabel", OBJPROP_XDISTANCE, 10);
|
||
|
|
ObjectSetInteger(0, "MFIBLabel", OBJPROP_YDISTANCE, 40);
|
||
|
|
|
||
|
|
string mfib_text = "MFIB .382 BIAS: " + BiasToText(MFIB_Bias);
|
||
|
|
color mfib_color = (MFIB_Bias == BIAS_BULL ? clrLime : (MFIB_Bias == BIAS_BEAR ? clrRed : clrGray));
|
||
|
|
|
||
|
|
ObjectSetString(0, "MFIBLabel", OBJPROP_TEXT, mfib_text);
|
||
|
|
ObjectSetInteger(0, "MFIBLabel", OBJPROP_COLOR, mfib_color);
|
||
|
|
ObjectSetInteger(0, "MFIBLabel", OBJPROP_FONTSIZE, 11);
|
||
|
|
}
|
||
|
|
|
||
|
|
ObjectDelete(0, "StateLabel");
|
||
|
|
ObjectCreate(0, "StateLabel", OBJ_LABEL, 0, 0, 0);
|
||
|
|
ObjectSetInteger(0, "StateLabel", OBJPROP_CORNER, CORNER_LEFT_UPPER);
|
||
|
|
ObjectSetInteger(0, "StateLabel", OBJPROP_XDISTANCE, 10);
|
||
|
|
ObjectSetInteger(0, "StateLabel", OBJPROP_YDISTANCE, Use_MFIB_382_Bias ? 60 : 40);
|
||
|
|
|
||
|
|
string state_text = "STATE: " + StateToText(Current_State);
|
||
|
|
|
||
|
|
if(Current_Family == FAMILY_TRENDING && (Current_State == STATE_PULLBACK || Current_State == STATE_DEEP_RETRACEMENT))
|
||
|
|
{
|
||
|
|
if(IsBullBias() && !Bull_MA50_Reclaimed())
|
||
|
|
state_text += " | ACTION: COUNTER-SELLS (50 SL)";
|
||
|
|
else if(IsBearBias() && !Bear_MA50_Reclaimed())
|
||
|
|
state_text += " | ACTION: COUNTER-BUYS (50 SL)";
|
||
|
|
else
|
||
|
|
state_text += " | ACTION: TREND-OK (150 SL)";
|
||
|
|
}
|
||
|
|
|
||
|
|
color state_color = clrWhite;
|
||
|
|
if(Current_State == STATE_CONTINUATION) state_color = clrLime;
|
||
|
|
else if(Current_State == STATE_PULLBACK) state_color = clrYellow;
|
||
|
|
else if(Current_State == STATE_DEEP_RETRACEMENT) state_color = clrOrange;
|
||
|
|
else if(Current_State == STATE_REVERSAL_ATTEMPT) state_color = clrOrangeRed;
|
||
|
|
else if(Current_State == STATE_REVERSAL_CONFIRMED) state_color = clrRed;
|
||
|
|
else if(Current_Family == FAMILY_RANGING) state_color = clrAqua;
|
||
|
|
else if(Current_Family == FAMILY_CHOP) state_color = clrViolet;
|
||
|
|
|
||
|
|
ObjectSetString(0, "StateLabel", OBJPROP_TEXT, state_text);
|
||
|
|
ObjectSetInteger(0, "StateLabel", OBJPROP_COLOR, state_color);
|
||
|
|
ObjectSetInteger(0, "StateLabel", OBJPROP_FONTSIZE, 11);
|
||
|
|
|
||
|
|
bool anyWarn =
|
||
|
|
(Stoch_Extreme_Warning || Stoch_Reject_Warning || Stoch_Level_Cross ||
|
||
|
|
MA7_Cross_14_Warning || MA7_Cross_21_Warning ||
|
||
|
|
MA50_Break_Warning || MA50_Warning || MA140_Warning || MA230_Warning || MA500_Warning ||
|
||
|
|
Fib_Reject_Warning || MFIB_Reject_Warning ||
|
||
|
|
Fib_Reclaim_Warning || MFIB_Reclaim_Warning || MA_Reclaim_Warning ||
|
||
|
|
MA_Reject_Warning || Band_Snap_Warning || Warning_Confluence_3Plus);
|
||
|
|
|
||
|
|
if(anyWarn)
|
||
|
|
{
|
||
|
|
ObjectDelete(0, "WarningLabel");
|
||
|
|
ObjectCreate(0, "WarningLabel", OBJ_LABEL, 0, 0, 0);
|
||
|
|
ObjectSetInteger(0, "WarningLabel", OBJPROP_CORNER, CORNER_LEFT_UPPER);
|
||
|
|
ObjectSetInteger(0, "WarningLabel", OBJPROP_XDISTANCE, 10);
|
||
|
|
ObjectSetInteger(0, "WarningLabel", OBJPROP_YDISTANCE, Use_MFIB_382_Bias ? 80 : 60);
|
||
|
|
|
||
|
|
string warn_text = "WARN: ";
|
||
|
|
if(Stoch_Extreme_Warning) warn_text += "STOCH-EXT | ";
|
||
|
|
if(Stoch_Reject_Warning) warn_text += "STOCH-REJ | ";
|
||
|
|
if(Stoch_Level_Cross) warn_text += "STOCH-LVL | ";
|
||
|
|
if(MA7_Cross_14_Warning) warn_text += "MA7x14-PB | ";
|
||
|
|
if(MA7_Cross_21_Warning) warn_text += "MA7x21-RET | ";
|
||
|
|
if(MA50_Break_Warning) warn_text += "MA50-BRK | ";
|
||
|
|
if(MA50_Warning) warn_text += "MA50 | ";
|
||
|
|
if(MA140_Warning) warn_text += "MA140 | ";
|
||
|
|
if(MA230_Warning) warn_text += "MA230 | ";
|
||
|
|
if(MA500_Warning) warn_text += "MA500 | ";
|
||
|
|
if(Fib_Reject_Warning) warn_text += "FIB-REJ | ";
|
||
|
|
if(MFIB_Reject_Warning) warn_text += "MFIB-REJ | ";
|
||
|
|
if(Fib_Reclaim_Warning) warn_text += "FIB-RCL | ";
|
||
|
|
if(MFIB_Reclaim_Warning) warn_text += "MFIB-RCL | ";
|
||
|
|
if(MA_Reclaim_Warning) warn_text += "MA-RCL | ";
|
||
|
|
if(MA_Reject_Warning) warn_text += "MA-REJ | ";
|
||
|
|
if(Band_Snap_Warning) warn_text += "BAND-SNAP | ";
|
||
|
|
if(Warning_Confluence_3Plus) warn_text += "3+CONF | ";
|
||
|
|
|
||
|
|
warn_text += "W=" + IntegerToString(Warning_Confluence_Count);
|
||
|
|
|
||
|
|
ObjectSetString(0, "WarningLabel", OBJPROP_TEXT, warn_text);
|
||
|
|
ObjectSetInteger(0, "WarningLabel", OBJPROP_COLOR, clrRed);
|
||
|
|
ObjectSetInteger(0, "WarningLabel", OBJPROP_FONTSIZE, 10);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ObjectDelete(0, "WarningLabel");
|
||
|
|
}
|
||
|
|
|
||
|
|
//===================================================================
|
||
|
|
// PRAISE LABEL DISPLAY
|
||
|
|
//===================================================================
|
||
|
|
bool anyPraise = (Praise_Triple_Magnet || Praise_Power_Couple || Praise_MFIB_Staircase ||
|
||
|
|
Praise_MFIB_Express || Praise_MFIB_Breakout || Praise_MA_Stack ||
|
||
|
|
Praise_Clean_Reclaim || Praise_Multi_Breakout);
|
||
|
|
|
||
|
|
if(anyPraise && Use_Praise_System)
|
||
|
|
{
|
||
|
|
ObjectDelete(0, "PraiseLabel");
|
||
|
|
ObjectCreate(0, "PraiseLabel", OBJ_LABEL, 0, 0, 0);
|
||
|
|
ObjectSetInteger(0, "PraiseLabel", OBJPROP_CORNER, CORNER_LEFT_UPPER);
|
||
|
|
ObjectSetInteger(0, "PraiseLabel", OBJPROP_XDISTANCE, 10);
|
||
|
|
ObjectSetInteger(0, "PraiseLabel", OBJPROP_YDISTANCE, Use_MFIB_382_Bias ? 100 : 80);
|
||
|
|
|
||
|
|
string praise_text = "PRAISE: ";
|
||
|
|
if(Praise_Triple_Magnet) praise_text += "7x14x21-MAG | ";
|
||
|
|
if(Praise_Power_Couple) praise_text += "14x21-PWR | ";
|
||
|
|
if(Praise_MFIB_Staircase) praise_text += "MFIB-STAIR | ";
|
||
|
|
if(Praise_MFIB_Express) praise_text += "MFIB-EXP | ";
|
||
|
|
if(Praise_MFIB_Breakout) praise_text += "MFIB-BRK | ";
|
||
|
|
if(Praise_MA_Stack) praise_text += "MA-STACK | ";
|
||
|
|
if(Praise_Clean_Reclaim) praise_text += "3xRCL | ";
|
||
|
|
if(Praise_Multi_Breakout) praise_text += "MULTI-BRK | ";
|
||
|
|
|
||
|
|
praise_text += "P=" + IntegerToString(Praise_Count);
|
||
|
|
|
||
|
|
// Add star indicators for strength
|
||
|
|
if(Praise_Count >= 4) praise_text += " ⭐⭐⭐⭐";
|
||
|
|
else if(Praise_Count == 3) praise_text += " ⭐⭐⭐";
|
||
|
|
|
||
|
|
color praise_color = clrGold;
|
||
|
|
if(Praise_Count >= 4) praise_color = clrYellow; // Supreme praise - bright
|
||
|
|
|
||
|
|
ObjectSetString(0, "PraiseLabel", OBJPROP_TEXT, praise_text);
|
||
|
|
ObjectSetInteger(0, "PraiseLabel", OBJPROP_COLOR, praise_color);
|
||
|
|
ObjectSetInteger(0, "PraiseLabel", OBJPROP_FONTSIZE, 10);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ObjectDelete(0, "PraiseLabel");
|
||
|
|
}
|
||
|
|
|
||
|
|
//===================================================================
|
||
|
|
// SIGNAL MODE LABEL (P vs W Summary)
|
||
|
|
//===================================================================
|
||
|
|
ObjectDelete(0, "SignalLabel");
|
||
|
|
ObjectCreate(0, "SignalLabel", OBJ_LABEL, 0, 0, 0);
|
||
|
|
ObjectSetInteger(0, "SignalLabel", OBJPROP_CORNER, CORNER_LEFT_UPPER);
|
||
|
|
ObjectSetInteger(0, "SignalLabel", OBJPROP_XDISTANCE, 10);
|
||
|
|
int signal_y = Use_MFIB_382_Bias ? 120 : 100;
|
||
|
|
if(!anyPraise) signal_y -= 20; // Move up if no praise label
|
||
|
|
ObjectSetInteger(0, "SignalLabel", OBJPROP_YDISTANCE, signal_y);
|
||
|
|
|
||
|
|
string signal_text = "SIGNAL: ";
|
||
|
|
color signal_color = clrWhite;
|
||
|
|
|
||
|
|
if(Praise_Count >= 4 && Warning_Confluence_Count <= 1)
|
||
|
|
{
|
||
|
|
signal_text += "SUPREME TREND (P>>W) - MAX AGGRESSION";
|
||
|
|
signal_color = clrLime;
|
||
|
|
}
|
||
|
|
else if(Praise_Count >= 3 && Warning_Confluence_Count <= 2)
|
||
|
|
{
|
||
|
|
signal_text += "STRONG TREND (P>W) - AGGRESSIVE";
|
||
|
|
signal_color = clrGreenYellow;
|
||
|
|
}
|
||
|
|
else if(Praise_Count >= 2 && Praise_Count > Warning_Confluence_Count)
|
||
|
|
{
|
||
|
|
signal_text += "TREND MODE (P>W) - CONTINUATION BIAS";
|
||
|
|
signal_color = clrYellow;
|
||
|
|
}
|
||
|
|
else if(Warning_Confluence_Count >= 3 && Praise_Count <= 1)
|
||
|
|
{
|
||
|
|
signal_text += "REVERSAL RISK (W>>P) - COUNTER BIAS";
|
||
|
|
signal_color = clrOrangeRed;
|
||
|
|
}
|
||
|
|
else if(Warning_Confluence_Count > Praise_Count)
|
||
|
|
{
|
||
|
|
signal_text += "CAUTION (W>P) - DEFENSIVE MODE";
|
||
|
|
signal_color = clrOrange;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
signal_text += "NEUTRAL (P≈W) - STANDARD MODE";
|
||
|
|
signal_color = clrGray;
|
||
|
|
}
|
||
|
|
|
||
|
|
ObjectSetString(0, "SignalLabel", OBJPROP_TEXT, signal_text);
|
||
|
|
ObjectSetInteger(0, "SignalLabel", OBJPROP_COLOR, signal_color);
|
||
|
|
ObjectSetInteger(0, "SignalLabel", OBJPROP_FONTSIZE, 10);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void UpdateModeAndState()
|
||
|
|
{
|
||
|
|
MODE_FAMILY detected_family;
|
||
|
|
TREND_BIAS detected_bias;
|
||
|
|
TREND_STRENGTH detected_strength;
|
||
|
|
|
||
|
|
DetectFamilyBiasStrength(detected_family, detected_bias, detected_strength);
|
||
|
|
|
||
|
|
Current_Family = detected_family;
|
||
|
|
Current_Bias = detected_bias;
|
||
|
|
Current_Strength = detected_strength;
|
||
|
|
|
||
|
|
PRICE_STATE detected_state = DetermineStateFromContext();
|
||
|
|
|
||
|
|
bool changed =
|
||
|
|
(detected_family != Prev_Family) ||
|
||
|
|
(detected_bias != Prev_Bias) ||
|
||
|
|
(detected_strength != Prev_Strength);
|
||
|
|
|
||
|
|
if(changed)
|
||
|
|
{
|
||
|
|
int required = Mode_Confirmation_Bars;
|
||
|
|
if(detected_state == STATE_REVERSAL_CONFIRMED) required = 1;
|
||
|
|
|
||
|
|
if(detected_family == Prev_Family && detected_bias == Prev_Bias && detected_strength == Prev_Strength)
|
||
|
|
{
|
||
|
|
Mode_Confirmation_Count++;
|
||
|
|
if(Mode_Confirmation_Count >= required)
|
||
|
|
{
|
||
|
|
Prev_Family = detected_family;
|
||
|
|
Prev_Bias = detected_bias;
|
||
|
|
Prev_Strength = detected_strength;
|
||
|
|
|
||
|
|
Current_Family = detected_family;
|
||
|
|
Current_Bias = detected_bias;
|
||
|
|
Current_Strength = detected_strength;
|
||
|
|
Current_State = detected_state;
|
||
|
|
|
||
|
|
Mode_Confirmation_Count = 0;
|
||
|
|
Reversal_Confirm_Counter = 0;
|
||
|
|
|
||
|
|
if(Current_State == STATE_REVERSAL_CONFIRMED)
|
||
|
|
CloseOnFullReversal();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Prev_Family = detected_family;
|
||
|
|
Prev_Bias = detected_bias;
|
||
|
|
Prev_Strength = detected_strength;
|
||
|
|
Mode_Confirmation_Count = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Mode_Confirmation_Count = 0;
|
||
|
|
Current_State = detected_state;
|
||
|
|
}
|
||
|
|
|
||
|
|
Is_Pullback_State = (Current_State == STATE_PULLBACK);
|
||
|
|
Is_Retracement_State = (Current_State == STATE_DEEP_RETRACEMENT);
|
||
|
|
|
||
|
|
UpdateLabels();
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void MarkRunners()
|
||
|
|
{
|
||
|
|
double current = MidPrice();
|
||
|
|
|
||
|
|
for(int i=0; i<ArraySize(OpenPositions); i++)
|
||
|
|
{
|
||
|
|
if(PositionSelectByTicket(OpenPositions[i].ticket))
|
||
|
|
{
|
||
|
|
double entry = OpenPositions[i].entry;
|
||
|
|
OpenPositions[i].distance_from_current = MathAbs(current - entry) / _Point;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for(int i=0; i<ArraySize(OpenPositions)-1; i++)
|
||
|
|
{
|
||
|
|
for(int j=i+1; j<ArraySize(OpenPositions); j++)
|
||
|
|
{
|
||
|
|
if(OpenPositions[j].distance_from_current > OpenPositions[i].distance_from_current)
|
||
|
|
{
|
||
|
|
PositionRec tmp = OpenPositions[i];
|
||
|
|
OpenPositions[i] = OpenPositions[j];
|
||
|
|
OpenPositions[j] = tmp;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for(int i=0; i<ArraySize(OpenPositions); i++)
|
||
|
|
OpenPositions[i].is_runner = (i < Min_Runners_To_Keep);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CloseOnFullReversal()
|
||
|
|
{
|
||
|
|
if(!Only_Close_On_Full_Reversal) return;
|
||
|
|
|
||
|
|
MarkRunners();
|
||
|
|
Print("🔄 REVERSAL CONFIRMED - Closing opposing positions (protecting runners)");
|
||
|
|
|
||
|
|
for(int i=PositionsTotal()-1; i>=0; i--)
|
||
|
|
{
|
||
|
|
if(PositionGetTicket(i) == 0) continue;
|
||
|
|
if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
|
||
|
|
if(PositionGetInteger(POSITION_MAGIC) != MagicNumber) continue;
|
||
|
|
|
||
|
|
ulong ticket = PositionGetTicket(i);
|
||
|
|
bool is_buy = (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY);
|
||
|
|
|
||
|
|
int idx = -1;
|
||
|
|
for(int j=0; j<ArraySize(OpenPositions); j++)
|
||
|
|
{
|
||
|
|
if(OpenPositions[j].ticket == ticket) { idx = j; break; }
|
||
|
|
}
|
||
|
|
|
||
|
|
if(idx >= 0 && OpenPositions[idx].is_runner)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
bool should_close = false;
|
||
|
|
if(is_buy && IsBearBias()) should_close = true;
|
||
|
|
if(!is_buy && IsBullBias()) should_close = true;
|
||
|
|
|
||
|
|
if(should_close)
|
||
|
|
{
|
||
|
|
if(Trade.PositionClose(ticket))
|
||
|
|
ClosedByReversal++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool IsDirectionAllowed(bool is_buy)
|
||
|
|
{
|
||
|
|
if(!Use_Market_Mode_Filter) return true;
|
||
|
|
|
||
|
|
if(Current_Family == FAMILY_TRENDING)
|
||
|
|
{
|
||
|
|
if(Current_State == STATE_REVERSAL_CONFIRMED)
|
||
|
|
{
|
||
|
|
if(IsBullBias() && !is_buy) return false;
|
||
|
|
if(IsBearBias() && is_buy) return false;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(Current_State == STATE_PULLBACK || Current_State == STATE_DEEP_RETRACEMENT)
|
||
|
|
{
|
||
|
|
if(IsBullBias())
|
||
|
|
{
|
||
|
|
if(!Bull_MA50_Reclaimed())
|
||
|
|
return (!is_buy); // SELLS ONLY
|
||
|
|
return is_buy;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(IsBearBias())
|
||
|
|
{
|
||
|
|
if(!Bear_MA50_Reclaimed())
|
||
|
|
return (is_buy); // BUYS ONLY
|
||
|
|
return (!is_buy);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(Current_State == STATE_CONTINUATION)
|
||
|
|
{
|
||
|
|
if(IsBullBias() && !is_buy) return false;
|
||
|
|
if(IsBearBias() && is_buy) return false;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
int CountSetupTrades(SETUP_TYPE setup)
|
||
|
|
{
|
||
|
|
int count = 0;
|
||
|
|
for(int i=0; i<PositionsTotal(); i++)
|
||
|
|
{
|
||
|
|
if(PositionGetTicket(i) == 0) continue;
|
||
|
|
if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
|
||
|
|
if(PositionGetInteger(POSITION_MAGIC) != MagicNumber) continue;
|
||
|
|
|
||
|
|
ulong t = PositionGetTicket(i);
|
||
|
|
|
||
|
|
for(int j=0; j<ArraySize(OpenPositions); j++)
|
||
|
|
{
|
||
|
|
if(OpenPositions[j].ticket == t)
|
||
|
|
{
|
||
|
|
if(OpenPositions[j].setup_type == setup)
|
||
|
|
count++;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return count;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double GetLotSize(TRADE_CATEGORY category)
|
||
|
|
{
|
||
|
|
double risk = AccountInfoDouble(ACCOUNT_BALANCE) * Risk_Per_Trade / 100.0;
|
||
|
|
double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
|
||
|
|
double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
|
||
|
|
|
||
|
|
double sl_points = (category == CATEGORY_COUNTER_TREND) ? Counter_SL_Points : Continuation_SL_Points;
|
||
|
|
|
||
|
|
double lot = risk / ((sl_points * _Point / tickSize) * tickValue);
|
||
|
|
|
||
|
|
// WAR SURVIVOR: Apply multiplier for larger initial positions
|
||
|
|
if(Use_MFIB_Partials)
|
||
|
|
lot = lot * War_Survivor_Lot_Multiplier;
|
||
|
|
|
||
|
|
// PRAISE SYSTEM: Dynamic sizing based on PRAISE vs WARN
|
||
|
|
if(Use_Praise_System)
|
||
|
|
{
|
||
|
|
if(category == CATEGORY_CONTINUATION)
|
||
|
|
{
|
||
|
|
// CONTINUATION TRADES: Boost on PRAISE, reduce on WARN
|
||
|
|
if(Praise_Count >= 4)
|
||
|
|
lot = lot * Praise_Size_Multiplier_Supreme; // Supreme praise = 2x
|
||
|
|
else if(Praise_Count == 3)
|
||
|
|
lot = lot * Praise_Size_Multiplier_Strong; // Strong praise = 1.5x
|
||
|
|
|
||
|
|
// Reduce size if high warnings
|
||
|
|
if(Reduce_Continuation_On_Warn && Warning_Confluence_Count >= 3)
|
||
|
|
lot = lot * 0.5; // Cut continuation size in half when warned
|
||
|
|
}
|
||
|
|
else if(category == CATEGORY_COUNTER_TREND)
|
||
|
|
{
|
||
|
|
// COUNTER-TREND TRADES: Boost on WARN, reduce on PRAISE
|
||
|
|
if(Warning_Confluence_Count >= 3)
|
||
|
|
lot = lot * 1.0; // Full size counter when warned
|
||
|
|
|
||
|
|
// Reduce counter size if high praise (strong trend)
|
||
|
|
if(Pause_Counter_On_Praise && Praise_Count >= 3)
|
||
|
|
lot = lot * 0.25; // Minimal counter when praised (trend strong)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
|
||
|
|
double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
|
||
|
|
double step = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
|
||
|
|
|
||
|
|
lot = MathMax(lot, minLot);
|
||
|
|
lot = MathMin(lot, maxLot);
|
||
|
|
lot = NormalizeDouble(lot / step, 0) * step;
|
||
|
|
|
||
|
|
return lot;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void OpenTrade(bool buy, double price, string setup_name, SETUP_TYPE setup_type, TRADE_CATEGORY category)
|
||
|
|
{
|
||
|
|
if(!IsDirectionAllowed(buy)) return;
|
||
|
|
if(!CanReEnter(setup_type)) return;
|
||
|
|
|
||
|
|
if(CountSetupTrades(setup_type) >= Max_Trades_Per_Setup) return;
|
||
|
|
if(PositionsTotal() >= Max_Total_Trades) return;
|
||
|
|
|
||
|
|
datetime now = TimeCurrent();
|
||
|
|
if(now - LastEntryTime[setup_type] < 1) return;
|
||
|
|
|
||
|
|
double lot = GetLotSize(category);
|
||
|
|
if(lot < SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN)) return;
|
||
|
|
|
||
|
|
double sl, tp;
|
||
|
|
|
||
|
|
if(category == CATEGORY_COUNTER_TREND)
|
||
|
|
{
|
||
|
|
sl = buy ? price - Counter_SL_Points * _Point : price + Counter_SL_Points * _Point;
|
||
|
|
tp = buy ? price + Counter_TP_Points * _Point : price - Counter_TP_Points * _Point;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
sl = buy ? price - Continuation_SL_Points * _Point : price + Continuation_SL_Points * _Point;
|
||
|
|
tp = buy ? price + Continuation_TP_Points * _Point : price - Continuation_TP_Points * _Point;
|
||
|
|
}
|
||
|
|
|
||
|
|
string cat_text = (category == CATEGORY_COUNTER_TREND) ? "CTR" : "CONT";
|
||
|
|
string bias_text = BiasToText(MFIB_Bias);
|
||
|
|
string comment = setup_name + "|" + cat_text + "|" + FamilyToText(Current_Family) + "|" + bias_text;
|
||
|
|
|
||
|
|
bool result = false;
|
||
|
|
if(buy) result = Trade.Buy(lot, _Symbol, 0, sl, tp, comment);
|
||
|
|
else result = Trade.Sell(lot, _Symbol, 0, sl, tp, comment);
|
||
|
|
|
||
|
|
if(result)
|
||
|
|
{
|
||
|
|
LastEntryTime[setup_type] = now;
|
||
|
|
TodayTrades++;
|
||
|
|
if(buy) BuyTrades++; else SellTrades++;
|
||
|
|
SetupCount[setup_type]++;
|
||
|
|
|
||
|
|
ulong ticket = Trade.ResultOrder();
|
||
|
|
|
||
|
|
int size = ArraySize(OpenPositions);
|
||
|
|
ArrayResize(OpenPositions, size+1);
|
||
|
|
|
||
|
|
OpenPositions[size].ticket = ticket;
|
||
|
|
OpenPositions[size].entry = price;
|
||
|
|
OpenPositions[size].original_lot = lot;
|
||
|
|
OpenPositions[size].is_buy = buy;
|
||
|
|
OpenPositions[size].partial_tp_hit = false;
|
||
|
|
OpenPositions[size].be_set = false;
|
||
|
|
OpenPositions[size].trailing_active = false;
|
||
|
|
OpenPositions[size].is_runner = false;
|
||
|
|
OpenPositions[size].setup_type = setup_type;
|
||
|
|
OpenPositions[size].category = category;
|
||
|
|
OpenPositions[size].setup_name = setup_name;
|
||
|
|
OpenPositions[size].entry_family = Current_Family;
|
||
|
|
OpenPositions[size].entry_bias = Current_Bias;
|
||
|
|
OpenPositions[size].entry_strength = Current_Strength;
|
||
|
|
OpenPositions[size].distance_from_current = 0;
|
||
|
|
OpenPositions[size].last_close_time = 0;
|
||
|
|
OpenPositions[size].closed_at_sl = false; // NEW
|
||
|
|
OpenPositions[size].closed_at_be = false; // NEW
|
||
|
|
OpenPositions[size].close_price = 0; // NEW
|
||
|
|
OpenPositions[size].mfib_partials_taken = 0; // WAR SURVIVOR
|
||
|
|
OpenPositions[size].last_mfib_partial_price = 0; // WAR SURVIVOR
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void ManagePositions()
|
||
|
|
{
|
||
|
|
for(int i=PositionsTotal()-1; i>=0; i--)
|
||
|
|
{
|
||
|
|
ulong ticket = PositionGetTicket(i);
|
||
|
|
if(ticket == 0) continue;
|
||
|
|
if(PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
|
||
|
|
if(PositionGetInteger(POSITION_MAGIC) != MagicNumber) continue;
|
||
|
|
|
||
|
|
int idx = -1;
|
||
|
|
for(int j=0; j<ArraySize(OpenPositions); j++)
|
||
|
|
{
|
||
|
|
if(OpenPositions[j].ticket == ticket) { idx = j; break; }
|
||
|
|
}
|
||
|
|
if(idx == -1) continue;
|
||
|
|
|
||
|
|
double entry = PositionGetDouble(POSITION_PRICE_OPEN);
|
||
|
|
double current_sl = PositionGetDouble(POSITION_SL);
|
||
|
|
double current_tp = PositionGetDouble(POSITION_TP);
|
||
|
|
bool is_buy = OpenPositions[idx].is_buy;
|
||
|
|
TRADE_CATEGORY cat = OpenPositions[idx].category;
|
||
|
|
|
||
|
|
double current = is_buy ? SymbolInfoDouble(_Symbol, SYMBOL_BID) : SymbolInfoDouble(_Symbol, SYMBOL_ASK);
|
||
|
|
double profit_points = is_buy ? (current - entry) / _Point : (entry - current) / _Point;
|
||
|
|
|
||
|
|
int partial_tp_pts = (cat == CATEGORY_COUNTER_TREND) ? Counter_Partial_TP : Continuation_Partial_TP;
|
||
|
|
double partial_pct = (cat == CATEGORY_COUNTER_TREND) ? Counter_Partial_Percent : Continuation_Partial_Percent;
|
||
|
|
int be_pts = (cat == CATEGORY_COUNTER_TREND) ? Counter_BreakEven_Points : Continuation_BreakEven_Points;
|
||
|
|
int trail_pts = (cat == CATEGORY_COUNTER_TREND) ? Counter_Trail_Points : Continuation_Trail_Points;
|
||
|
|
|
||
|
|
// PRAISE SYSTEM: Tighter trail during supreme praise
|
||
|
|
if(Use_Praise_System && cat == CATEGORY_CONTINUATION && Praise_Count >= 4)
|
||
|
|
trail_pts = Praise_Tight_Trail; // 100pts trail in supreme trend
|
||
|
|
|
||
|
|
if(!OpenPositions[idx].partial_tp_hit && profit_points >= partial_tp_pts)
|
||
|
|
{
|
||
|
|
double current_lot = PositionGetDouble(POSITION_VOLUME);
|
||
|
|
double close_size = NormalizeDouble(OpenPositions[idx].original_lot * partial_pct / 100.0, 2);
|
||
|
|
|
||
|
|
if(close_size > 0 && close_size <= current_lot)
|
||
|
|
{
|
||
|
|
if(Trade.PositionClosePartial(ticket, close_size))
|
||
|
|
OpenPositions[idx].partial_tp_hit = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//===================================================================
|
||
|
|
// WAR SURVIVOR: AGGRESSIVE MFIB PARTIAL SYSTEM
|
||
|
|
// Take 25% at each MFIB rejection to lock in gains frequently
|
||
|
|
//===================================================================
|
||
|
|
if(Use_MFIB_Partials && profit_points >= MFIB_Partial_Min_Profit && OpenPositions[idx].mfib_partials_taken < 4)
|
||
|
|
{
|
||
|
|
bool mfib_reject_happened = false;
|
||
|
|
double mfib_reject_price = 0;
|
||
|
|
|
||
|
|
// Check if we're at a MFIB level with rejection
|
||
|
|
double mfib_levels[5] = {MFIB_Level_236, MFIB_Level_382, MFIB_Level_050, MFIB_Level_618, MFIB_Level_786};
|
||
|
|
|
||
|
|
for(int m=0; m<5; m++)
|
||
|
|
{
|
||
|
|
double dist_to_level = MathAbs(current - mfib_levels[m]) / _Point;
|
||
|
|
|
||
|
|
// At MFIB level (within 50 points)
|
||
|
|
if(dist_to_level <= 50)
|
||
|
|
{
|
||
|
|
// Check for rejection signs
|
||
|
|
bool has_reject_signal = (MFIB_Reject_Warning || Stoch_Reject_Warning ||
|
||
|
|
Stoch_Extreme_Warning || Warning_Confluence_3Plus);
|
||
|
|
|
||
|
|
// Check if different from last partial
|
||
|
|
bool new_level = (OpenPositions[idx].last_mfib_partial_price == 0) ||
|
||
|
|
(MathAbs(current - OpenPositions[idx].last_mfib_partial_price) / _Point > 100);
|
||
|
|
|
||
|
|
if(has_reject_signal && new_level)
|
||
|
|
{
|
||
|
|
mfib_reject_happened = true;
|
||
|
|
mfib_reject_price = mfib_levels[m];
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Execute MFIB partial
|
||
|
|
if(mfib_reject_happened)
|
||
|
|
{
|
||
|
|
double current_lot = PositionGetDouble(POSITION_VOLUME);
|
||
|
|
double close_size = NormalizeDouble(OpenPositions[idx].original_lot * MFIB_Partial_Percent / 100.0, 2);
|
||
|
|
|
||
|
|
// Ensure we don't close more than available
|
||
|
|
if(close_size > current_lot)
|
||
|
|
close_size = current_lot * 0.25; // Take 25% of what's left
|
||
|
|
|
||
|
|
if(close_size > 0 && close_size >= SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN))
|
||
|
|
{
|
||
|
|
if(Trade.PositionClosePartial(ticket, close_size))
|
||
|
|
{
|
||
|
|
OpenPositions[idx].mfib_partials_taken++;
|
||
|
|
OpenPositions[idx].last_mfib_partial_price = mfib_reject_price;
|
||
|
|
|
||
|
|
Print("💰 WAR SURVIVOR MFIB PARTIAL #", OpenPositions[idx].mfib_partials_taken,
|
||
|
|
" | Closed ", close_size, " lots at MFIB ", DoubleToString(mfib_reject_price, 2),
|
||
|
|
" | +", DoubleToString(profit_points, 1), " pts");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(!OpenPositions[idx].be_set && profit_points >= be_pts)
|
||
|
|
{
|
||
|
|
if((is_buy && current_sl < entry) || (!is_buy && current_sl > entry))
|
||
|
|
{
|
||
|
|
if(Trade.PositionModify(ticket, entry, current_tp))
|
||
|
|
OpenPositions[idx].be_set = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if(profit_points >= be_pts + 50)
|
||
|
|
{
|
||
|
|
OpenPositions[idx].trailing_active = true;
|
||
|
|
|
||
|
|
double newSL = 0;
|
||
|
|
bool should_modify = false;
|
||
|
|
|
||
|
|
if(is_buy)
|
||
|
|
{
|
||
|
|
newSL = current - trail_pts * _Point;
|
||
|
|
if(newSL > current_sl + 30 * _Point) should_modify = true;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
newSL = current + trail_pts * _Point;
|
||
|
|
if(newSL < current_sl - 30 * _Point) should_modify = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(should_modify) Trade.PositionModify(ticket, newSL, current_tp);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Update close price for tracking
|
||
|
|
OpenPositions[idx].close_price = current;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check for recently closed positions (for re-entry tracking)
|
||
|
|
for(int i=ArraySize(OpenPositions)-1; i>=0; i--)
|
||
|
|
{
|
||
|
|
ulong ticket = OpenPositions[i].ticket;
|
||
|
|
|
||
|
|
// Check if position still exists
|
||
|
|
if(!PositionSelectByTicket(ticket))
|
||
|
|
{
|
||
|
|
// Position was closed - determine if at SL or BE
|
||
|
|
double entry = OpenPositions[i].entry;
|
||
|
|
double close_price = OpenPositions[i].close_price;
|
||
|
|
bool is_buy = OpenPositions[i].is_buy;
|
||
|
|
|
||
|
|
// Check if closed at BE (close price near entry)
|
||
|
|
bool at_be = (MathAbs(close_price - entry) / _Point < 10);
|
||
|
|
|
||
|
|
// Check if closed at SL (assuming loss)
|
||
|
|
bool at_sl = false;
|
||
|
|
if(is_buy && close_price < entry) at_sl = true;
|
||
|
|
if(!is_buy && close_price > entry) at_sl = true;
|
||
|
|
|
||
|
|
if(at_be) at_sl = false; // BE takes precedence
|
||
|
|
|
||
|
|
// Record closure for re-entry system
|
||
|
|
RecordClosure(OpenPositions[i].setup_type, OpenPositions[i].category,
|
||
|
|
OpenPositions[i].is_buy, close_price, at_sl, at_be);
|
||
|
|
|
||
|
|
// Remove from array
|
||
|
|
for(int j=i; j<ArraySize(OpenPositions)-1; j++)
|
||
|
|
OpenPositions[j] = OpenPositions[j+1];
|
||
|
|
ArrayResize(OpenPositions, ArraySize(OpenPositions)-1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void OnTick()
|
||
|
|
{
|
||
|
|
UpdateIndicators();
|
||
|
|
DetectWarnings();
|
||
|
|
DetectPraiseSignals(); // NEW: Detect PRAISE signals
|
||
|
|
|
||
|
|
static int tick_count = 0;
|
||
|
|
tick_count++;
|
||
|
|
if(tick_count >= 100)
|
||
|
|
{
|
||
|
|
CalculateLevels();
|
||
|
|
if(Show_Levels) DrawLevels();
|
||
|
|
tick_count = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
UpdateModeAndState();
|
||
|
|
ManagePositions();
|
||
|
|
|
||
|
|
double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
|
||
|
|
double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
|
||
|
|
double current = (bid + ask) / 2.0;
|
||
|
|
double previous = iClose(_Symbol, PERIOD_CURRENT, 1);
|
||
|
|
double buffer = MA_Touch_Buffer * _Point;
|
||
|
|
|
||
|
|
//=================================================================
|
||
|
|
// PULLBACK COUNTER-TREND SETUPS (50 SL) - TEMPORARILY DISABLED
|
||
|
|
// Waiting for confirmation of warning/praise signal definitions
|
||
|
|
//=================================================================
|
||
|
|
/*
|
||
|
|
if(Current_Family == FAMILY_TRENDING && Is_Pullback_State && Warning_Confluence_Count >= 3)
|
||
|
|
{
|
||
|
|
bool bull = IsBullBias();
|
||
|
|
bool bear = IsBearBias();
|
||
|
|
bool ma50_not_reclaimed = (bull && !Bull_MA50_Reclaimed()) || (bear && !Bear_MA50_Reclaimed());
|
||
|
|
|
||
|
|
if(ma50_not_reclaimed)
|
||
|
|
{
|
||
|
|
int pb_signals = 0;
|
||
|
|
if(MA7_Cross_14_Warning) pb_signals++;
|
||
|
|
if(MFIB_Reject_Warning) pb_signals++;
|
||
|
|
if(Band_Snap_Warning) pb_signals++;
|
||
|
|
if(Stoch_Reject_Warning || Stoch_Extreme_Warning) pb_signals++;
|
||
|
|
|
||
|
|
if(pb_signals >= 2)
|
||
|
|
{
|
||
|
|
if(bull) OpenTrade(false, bid, "PB-COUNTER-SELL", SETUP_PULLBACK_COUNTER, CATEGORY_COUNTER_TREND);
|
||
|
|
if(bear) OpenTrade(true, ask, "PB-COUNTER-BUY", SETUP_PULLBACK_COUNTER, CATEGORY_COUNTER_TREND);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
|
||
|
|
//=================================================================
|
||
|
|
// RETRACEMENT COUNTER-TREND SETUPS (50 SL) - TEMPORARILY DISABLED
|
||
|
|
// Waiting for confirmation of warning/praise signal definitions
|
||
|
|
//=================================================================
|
||
|
|
/*
|
||
|
|
if(Current_Family == FAMILY_TRENDING && Is_Retracement_State && Warning_Confluence_Count >= 3)
|
||
|
|
{
|
||
|
|
bool bull = IsBullBias();
|
||
|
|
bool bear = IsBearBias();
|
||
|
|
bool ma50_not_reclaimed = (bull && !Bull_MA50_Reclaimed()) || (bear && !Bear_MA50_Reclaimed());
|
||
|
|
|
||
|
|
if(ma50_not_reclaimed)
|
||
|
|
{
|
||
|
|
int ret_signals = 0;
|
||
|
|
if(MA7_Cross_21_Warning) ret_signals++;
|
||
|
|
if(MFIB_Reject_Warning) ret_signals++;
|
||
|
|
if(Band_Snap_Warning) ret_signals++;
|
||
|
|
if(Stoch_Reject_Warning || Stoch_Extreme_Warning) ret_signals++;
|
||
|
|
|
||
|
|
if(ret_signals >= 2)
|
||
|
|
{
|
||
|
|
if(bull) OpenTrade(false, bid, "RET-COUNTER-SELL", SETUP_RETRACEMENT_COUNTER, CATEGORY_COUNTER_TREND);
|
||
|
|
if(bear) OpenTrade(true, ask, "RET-COUNTER-BUY", SETUP_RETRACEMENT_COUNTER, CATEGORY_COUNTER_TREND);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
*/
|
||
|
|
|
||
|
|
//=================================================================
|
||
|
|
// CONTINUATION SETUPS (150 SL) - ALL 16 ORIGINAL SETUPS
|
||
|
|
//=================================================================
|
||
|
|
if(Current_Family == FAMILY_TRENDING && Current_State == STATE_CONTINUATION)
|
||
|
|
{
|
||
|
|
// 1. MA14 CROSS
|
||
|
|
int ma14_crosses = 0;
|
||
|
|
for(int i=0; i<10; i++) if(i != 1 && MA_Current[1] > MA_Current[i]) ma14_crosses++;
|
||
|
|
if(ma14_crosses >= 2) OpenTrade(true, ask, "MA14-CROSS↑", SETUP_MA14_CROSS, CATEGORY_CONTINUATION);
|
||
|
|
|
||
|
|
ma14_crosses = 0;
|
||
|
|
for(int i=0; i<10; i++) if(i != 1 && MA_Current[1] < MA_Current[i]) ma14_crosses++;
|
||
|
|
if(ma14_crosses >= 2) OpenTrade(false, bid, "MA14-CROSS↓", SETUP_MA14_CROSS, CATEGORY_CONTINUATION);
|
||
|
|
|
||
|
|
// 2. MA50 BOUNCE
|
||
|
|
if(MathAbs(current - MA_Current[3]) <= buffer)
|
||
|
|
{
|
||
|
|
OpenTrade(true, ask, "MA50-BOUNCE↑", SETUP_MA50_BOUNCE, CATEGORY_CONTINUATION);
|
||
|
|
OpenTrade(false, bid, "MA50-BOUNCE↓", SETUP_MA50_BOUNCE, CATEGORY_CONTINUATION);
|
||
|
|
}
|
||
|
|
|
||
|
|
// 3. MA140 BOUNCE
|
||
|
|
if(MathAbs(current - MA_Current[4]) <= buffer)
|
||
|
|
{
|
||
|
|
OpenTrade(true, ask, "MA140-BOUNCE↑", SETUP_MA140_BOUNCE, CATEGORY_CONTINUATION);
|
||
|
|
OpenTrade(false, bid, "MA140-BOUNCE↓", SETUP_MA140_BOUNCE, CATEGORY_CONTINUATION);
|
||
|
|
}
|
||
|
|
|
||
|
|
// 4. MA230 BOUNCE
|
||
|
|
if(MathAbs(current - MA_Current[5]) <= buffer)
|
||
|
|
{
|
||
|
|
OpenTrade(true, ask, "MA230-BOUNCE↑", SETUP_MA230_BOUNCE, CATEGORY_CONTINUATION);
|
||
|
|
OpenTrade(false, bid, "MA230-BOUNCE↓", SETUP_MA230_BOUNCE, CATEGORY_CONTINUATION);
|
||
|
|
}
|
||
|
|
|
||
|
|
// 5. MA500 TOUCH
|
||
|
|
if(MathAbs(current - MA_Current[6]) <= buffer)
|
||
|
|
{
|
||
|
|
OpenTrade(true, ask, "MA500-TOUCH↑", SETUP_MA500_TOUCH, CATEGORY_CONTINUATION);
|
||
|
|
OpenTrade(false, bid, "MA500-TOUCH↓", SETUP_MA500_TOUCH, CATEGORY_CONTINUATION);
|
||
|
|
}
|
||
|
|
|
||
|
|
// 6. FIB BREAKS
|
||
|
|
for(int i=1; i<6; i++)
|
||
|
|
{
|
||
|
|
if(MathAbs(current - PriceLevels[i]) <= buffer)
|
||
|
|
{
|
||
|
|
if(previous < PriceLevels[i])
|
||
|
|
OpenTrade(true, ask, "FIB-BREAK↑", SETUP_FIB_BREAK, CATEGORY_CONTINUATION);
|
||
|
|
if(previous > PriceLevels[i])
|
||
|
|
OpenTrade(false, bid, "FIB-BREAK↓", SETUP_FIB_BREAK, CATEGORY_CONTINUATION);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// 7. FIB RECLAIM
|
||
|
|
for(int i=1; i<6; i++)
|
||
|
|
{
|
||
|
|
if(NearLevel(current, PriceLevels[i], buffer))
|
||
|
|
{
|
||
|
|
if(MA_Previous[0] < PriceLevels[i] && MA_Current[0] > PriceLevels[i])
|
||
|
|
OpenTrade(true, ask, "FIB-RECLAIM↑", SETUP_FIB_RECLAIM, CATEGORY_CONTINUATION);
|
||
|
|
if(MA_Previous[0] > PriceLevels[i] && MA_Current[0] < PriceLevels[i])
|
||
|
|
OpenTrade(false, bid, "FIB-RECLAIM↓", SETUP_FIB_RECLAIM, CATEGORY_CONTINUATION);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// 8. MAGNET WALK
|
||
|
|
bool hugging = (Current_ATR > 0.0) ? (MathAbs(current - MA_Current[2]) / Current_ATR < 0.7) : false;
|
||
|
|
if(hugging && MA_Current[0] > MA_Current[3])
|
||
|
|
OpenTrade(true, ask, "MAGNET-WALK↑", SETUP_MAGNET_WALK, CATEGORY_CONTINUATION);
|
||
|
|
if(hugging && MA_Current[0] < MA_Current[3])
|
||
|
|
OpenTrade(false, bid, "MAGNET-WALK↓", SETUP_MAGNET_WALK, CATEGORY_CONTINUATION);
|
||
|
|
|
||
|
|
// 9. MFIB LADDER (near MFIB levels)
|
||
|
|
if(NearLevel(current, MFIB_Level_618, buffer) || NearLevel(current, MFIB_Level_382, buffer))
|
||
|
|
{
|
||
|
|
if(IsBullBias()) OpenTrade(true, ask, "MFIB-LADDER↑", SETUP_MFIB_LADDER, CATEGORY_CONTINUATION);
|
||
|
|
if(IsBearBias()) OpenTrade(false, bid, "MFIB-LADDER↓", SETUP_MFIB_LADDER, CATEGORY_CONTINUATION);
|
||
|
|
}
|
||
|
|
|
||
|
|
// 10. STAIRCASE ADVANCE - MA stack with momentum
|
||
|
|
bool mas_stacked_bull = (MA_Current[0] > MA_Current[1]) && (MA_Current[1] > MA_Current[2]) &&
|
||
|
|
(MA_Current[2] > MA_Current[3]) && (MA_Current[3] > MA_Current[4]);
|
||
|
|
bool mas_stacked_bear = (MA_Current[0] < MA_Current[1]) && (MA_Current[1] < MA_Current[2]) &&
|
||
|
|
(MA_Current[2] < MA_Current[3]) && (MA_Current[3] < MA_Current[4]);
|
||
|
|
|
||
|
|
if(mas_stacked_bull && Current_ADX > 25 && !Band_Snap_Warning)
|
||
|
|
OpenTrade(true, ask, "STAIRCASE↑", SETUP_STAIRCASE_ADV, CATEGORY_CONTINUATION);
|
||
|
|
if(mas_stacked_bear && Current_ADX > 25 && !Band_Snap_Warning)
|
||
|
|
OpenTrade(false, bid, "STAIRCASE↓", SETUP_STAIRCASE_ADV, CATEGORY_CONTINUATION);
|
||
|
|
|
||
|
|
// 11. CONTROLLED PULLBACK - Minor pullback in strong trend
|
||
|
|
bool minor_pb_bull = (MA_Current[0] < MA_Current[1]) && (MA_Current[0] > MA_Current[3]) &&
|
||
|
|
(Stoch_K_Current < 50) && (Stoch_K_Current > Stoch_Low);
|
||
|
|
bool minor_pb_bear = (MA_Current[0] > MA_Current[1]) && (MA_Current[0] < MA_Current[3]) &&
|
||
|
|
(Stoch_K_Current > 50) && (Stoch_K_Current < Stoch_High);
|
||
|
|
|
||
|
|
if(minor_pb_bull && IsBullBias())
|
||
|
|
OpenTrade(true, ask, "CTRL-PB↑", SETUP_CTRL_PULLBACK, CATEGORY_CONTINUATION);
|
||
|
|
if(minor_pb_bear && IsBearBias())
|
||
|
|
OpenTrade(false, bid, "CTRL-PB↓", SETUP_CTRL_PULLBACK, CATEGORY_CONTINUATION);
|
||
|
|
|
||
|
|
// 12. TIMEFRAME RESET - Price resets to key level then resumes
|
||
|
|
bool tf_reset_bull = (MA_Previous[0] < MA_Current[3]) && (MA_Current[0] >= MA_Current[3]) &&
|
||
|
|
(Stoch_K_Current > Stoch_K_Previous);
|
||
|
|
bool tf_reset_bear = (MA_Previous[0] > MA_Current[3]) && (MA_Current[0] <= MA_Current[3]) &&
|
||
|
|
(Stoch_K_Current < Stoch_K_Previous);
|
||
|
|
|
||
|
|
if(tf_reset_bull && IsBullBias())
|
||
|
|
OpenTrade(true, ask, "TF-RESET↑", SETUP_TF_RESET, CATEGORY_CONTINUATION);
|
||
|
|
if(tf_reset_bear && IsBearBias())
|
||
|
|
OpenTrade(false, bid, "TF-RESET↓", SETUP_TF_RESET, CATEGORY_CONTINUATION);
|
||
|
|
|
||
|
|
// 14. MFIB PRESS - Sustained pressure at MFIB levels
|
||
|
|
bool mfib_press_bull = (NearLevel(current, MFIB_Level_618, buffer) || NearLevel(current, MFIB_Level_786, buffer)) &&
|
||
|
|
(MA_Current[0] > MA_Current[1]) && (Stoch_K_Current > 50);
|
||
|
|
bool mfib_press_bear = (NearLevel(current, MFIB_Level_236, buffer) || NearLevel(current, MFIB_Level_382, buffer)) &&
|
||
|
|
(MA_Current[0] < MA_Current[1]) && (Stoch_K_Current < 50);
|
||
|
|
|
||
|
|
if(mfib_press_bull && IsBullBias())
|
||
|
|
OpenTrade(true, ask, "MFIB-PRESS↑", SETUP_MFIB_PRESS, CATEGORY_CONTINUATION);
|
||
|
|
if(mfib_press_bear && IsBearBias())
|
||
|
|
OpenTrade(false, bid, "MFIB-PRESS↓", SETUP_MFIB_PRESS, CATEGORY_CONTINUATION);
|
||
|
|
}
|
||
|
|
|
||
|
|
//=================================================================
|
||
|
|
// RANGE SETUPS (50 SL) - Counter-trend parameters
|
||
|
|
//=================================================================
|
||
|
|
if(Current_Family == FAMILY_RANGING)
|
||
|
|
{
|
||
|
|
// Range edge entries
|
||
|
|
if(MathAbs(current - PriceLevels[1]) < buffer && Stoch_K_Current < 35)
|
||
|
|
OpenTrade(true, ask, "RANGE-BUY", SETUP_RANGE_ENGINE, CATEGORY_COUNTER_TREND);
|
||
|
|
if(MathAbs(current - PriceLevels[5]) < buffer && Stoch_K_Current > 65)
|
||
|
|
OpenTrade(false, bid, "RANGE-SELL", SETUP_RANGE_ENGINE, CATEGORY_COUNTER_TREND);
|
||
|
|
|
||
|
|
// MFIB reject in range
|
||
|
|
if(MFIB_Reject_Warning && (Stoch_Reject_Warning || Stoch_Extreme_Warning || Warning_Confluence_3Plus))
|
||
|
|
{
|
||
|
|
if(current <= MFIB_Level_050) OpenTrade(true, ask, "RANGE-MFIB-BUY", SETUP_RANGE_ENGINE, CATEGORY_COUNTER_TREND);
|
||
|
|
if(current >= MFIB_Level_050) OpenTrade(false, bid, "RANGE-MFIB-SELL", SETUP_RANGE_ENGINE, CATEGORY_COUNTER_TREND);
|
||
|
|
}
|
||
|
|
|
||
|
|
// 8. FIB REJECT in range (using SETUP_FIB_REJECT)
|
||
|
|
if(Fib_Reject_Warning)
|
||
|
|
{
|
||
|
|
if(current <= PriceLevels[3]) OpenTrade(true, ask, "RANGE-FIB-BUY", SETUP_FIB_REJECT, CATEGORY_COUNTER_TREND);
|
||
|
|
if(current >= PriceLevels[3]) OpenTrade(false, bid, "RANGE-FIB-SELL", SETUP_FIB_REJECT, CATEGORY_COUNTER_TREND);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//=================================================================
|
||
|
|
// CHOP SETUPS (50 SL) - Counter-trend parameters
|
||
|
|
//=================================================================
|
||
|
|
if(Current_Family == FAMILY_CHOP)
|
||
|
|
{
|
||
|
|
if(Stoch_Extreme_Warning || Stoch_Reject_Warning || Fib_Reject_Warning || MFIB_Reject_Warning || Warning_Confluence_3Plus)
|
||
|
|
{
|
||
|
|
if(Stoch_K_Current <= Stoch_Low) OpenTrade(true, ask, "CHOP-REV-BUY", SETUP_MEAN_REV, CATEGORY_COUNTER_TREND);
|
||
|
|
if(Stoch_K_Current >= Stoch_High) OpenTrade(false, bid, "CHOP-REV-SELL", SETUP_MEAN_REV, CATEGORY_COUNTER_TREND);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Band snap in chop
|
||
|
|
if(Band_Snap_Warning)
|
||
|
|
{
|
||
|
|
if(current < MA_Current[0]) OpenTrade(true, ask, "CHOP-SNAP-BUY", SETUP_MEAN_REV, CATEGORY_COUNTER_TREND);
|
||
|
|
if(current > MA_Current[0]) OpenTrade(false, bid, "CHOP-SNAP-SELL", SETUP_MEAN_REV, CATEGORY_COUNTER_TREND);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//+------------------------------------------------------------------+
|