← К каталогу
Исходный код · ID 4895

Luxy BIG beautiful Dynamic ORB v5 by FXProSystems.com

luxy big beautiful dynamic orb v5.pine
Вы автор или правообладатель?

Сообщите нам, если считаете, что материал размещён без разрешения.

Краткий обзор

О программе

Этот индикатор Pine Script v6 для TradingView строит динамические диапазоны открытия (ORB) с несколькими стадиями: 5, 15, 30 и 60 минут. Он отображает границы диапазона, среднюю линию и заливку, а также метки пробоев и ретестов. Пользователь может включать или отключать отдельные стадии ORB и настраивать их цвета.

Индикатор поддерживает выбор торговой сессии: автоопределение, Нью-Йорк, Лондон, Токио, Сидней, Франкфурт или пользовательский интервал. Можно учитывать предторговые и послеторговые часы. Для пробоев и ретестов задаются буферы, минимальное расстояние и количество баров вне диапазона, а также режим сигналов (только первый или отслеживание циклов).

Дополнительно доступны фильтры по FVG, откату, объёму и тренду, а также проверка старшего таймфрейма. Индикатор рассчитывает уровни целей и стоп-лосса, может отображать их на графике и показывать информационную панель с параметрами позиции и статистикой сессии. Предусмотрены условия для оповещений TradingView о пробоях, ретестах и неудачных пробоях.

Настройки программы

НастройкаОписание
showEdgeLabels Показывать метки стадий ORB у границ диапазона.
labelFormat Формат текста меток (простой или подробный).
labelSize Размер всех меток на графике.
showBG Показывать заливку фона диапазона ORB.
fillTransparency Прозрачность заливки диапазона ORB.
enableORB5Signals Включает стадию ORB 5 минут.
orb5LineColor Цвет линий ORB 5 минут.
enableORB15Signals Включает стадию ORB 15 минут.
orb15LineColor Цвет линий ORB 15 минут.
enableORB30Signals Включает стадию ORB 30 минут.
orb30LineColor Цвет линий ORB 30 минут.
enableORB60Signals Включает стадию ORB 60 минут.
orb60LineColor Цвет линий ORB 60 минут.
showMidLine Показывать среднюю линию диапазона ORB.
sessionMode Режим выбора торговой сессии для расчёта ORB.
customSession Пользовательские часы торговой сессии в формате ЧЧММ-ЧЧММ, используются при режиме сессии «Custom».
enableExtendedHours Учитывать предторговые и послеторговые часы при расчёте ORB.
extendedPreMarket Часы предторговой сессии.
extendedAfterHours Часы послеторговой сессии.
enableBreakout Включает обнаружение пробоев границ ORB.
showBreakLabels Показывать метки пробоев.
enableRetest Показывать метки ретестов после пробоя.
signalMode Режим сигналов: только первый пробой или отслеживание циклов.
maxCycles Максимальное количество циклов пробой-ретест при режиме отслеживания циклов.
breakoutBuffer Дополнительное процентное расстояние за границей ORB, необходимое для подтверждения пробоя.
retestBuffer Допуск в процентах для обнаружения ретеста.
minRetestDistancePct Минимальное расстояние в процентах от ORB для действительного ретеста.
minBarsOutside Минимальное количество баров вне ORB для подтверждения пробоя.
minPullbackPct Минимальный откат в процентах для обнаружения нового пробоя.
enableFVGFilter Включает фильтр по Fair Value Gap для сигналов пробоя.
showFVG Показывать прямоугольники FVG.
maxFVGtoKeep Максимальное количество FVG для отображения.
fvgProximity Максимальное расстояние до FVG для учёта в фильтре.
fvgTransparency Прозрачность отображения FVG.
fvgBullColor Цвет бычьего FVG.
fvgBearColor Цвет медвежьего FVG.
enablePullbackFilter Включает фильтр отката для подтверждения сигналов пробоя.
pullbackPercent Требуемый процент отката для подтверждения сигнала.
pullbackTimeout Максимальное количество баров для ожидания отката.
enableVolumeFilter Включает фильтр объёма для сигналов.
volumeMaLength Период скользящей средней объёма.
volumeMultiplier Минимальный множитель объёма для фильтра.
strongVolumeMultiplier Множитель объёма для определения сильного объёма.
enableTrendFilter Включает фильтр тренда для сигналов.
trendMode Метод определения тренда для фильтра.
customEmaLength Период пользовательской скользящей средней для фильтра тренда.
supertrendPeriod Период SuperTrend для фильтра тренда.
supertrendMult Множитель SuperTrend для фильтра тренда.
enableTargets Включает расчёт и отображение целей и стоп-лосса.
showTP1 Показывать цель TP1 (1R).
showTP1_5 Показывать цель TP1.5 (1.5R).
showTP2 Показывать цель TP2 (2R).
showTP3 Показывать цель TP3 (3R).
stopMode Метод расчёта стоп-лосса.
atrLength Период ATR для расчёта волатильности при определении стоп-лосса.
atrMultiplier Множитель ATR для расчёта расстояния до стоп-лосса.
percentBasedStop Процентный размер стоп-лосса.
stopOrbFraction Доля диапазона ORB для стоп-лосса.
swingBars Количество баров для определения свинга при расчёте стоп-лосса.
showTPSLLines Показывать линии целей и стоп-лосса на графике.
freezeOnEOD Фиксировать линии целей и стоп-лосса в конце дня.
showDashboard Показывать информационную панель.
dashTheme Цветовая тема информационной панели (тёмная или светлая).
dashPos Положение информационной панели на графике.
dashSize Размер текста на информационной панели.
showStage Показывать стадию ORB на панели.
showRange Показывать диапазон ORB на панели.
showStatus Показывать статус ORB на панели.
showVol Показывать объём на панели.
showTrend Показывать тренд на панели.
showRisk Показывать соотношение риск/прибыль на панели.
showVolatilityMeter Показывать индикатор волатильности на панели.
enablePosSizing Включает расчёт размера позиции на основе риска.
riskMode Режим расчёта риска (фиксированный или процент от счёта).
fixedRisk Фиксированная сумма риска в долларах.
riskPct Процент риска от счёта.
maxPositionPct Максимальный процент счёта для размера позиции.
useDynamicRates Использовать динамические курсы обмена валют.
manualRate Ручной курс обмена валюты, если не используются динамические курсы.
enableHTF Включает проверку тренда на старшем таймфрейме.
htfTF Таймфрейм для проверки тренда.
htfMethod Метод определения тренда на старшем таймфрейме.
htfEMA Период скользящей средней на старшем таймфрейме.
htfMinStrength Минимальное расстояние в процентах для подтверждения тренда на старшем таймфрейме.

Поиск по коду файла

indicator("Luxy BIG beautiful Dynamic ORB v5 by FXProSystems.com", shorttitle = "Luxy Big Beautiful ORB", overlay=true, max_labels_count=500, max_lines_count=500, max_boxes_count=300)

type ORBData
    string name          
    int    minutes       
    float  high         
    float  low          
    float  mid          
    float  orbRange     
    bool   isEnabled     
    bool   isBuilding    
    bool   isComplete    
    int    completionBar 
    bool   breakoutUp    
    bool   breakoutDown  
    int    breakoutBar   
    float  breakoutLevel 
    int    cyclesUp      
    int    cyclesDown    
    box    orbBox        
    line   highLine      
    line   lowLine       
    line   midLine       
    label  edgeLabel     
    color  orbColor      
    int    lineWidth     
    string lineStyle     

grp_colors   = "🎨 ORB COLORS ▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬"
grp_session  = "⏰ SESSION SETTINGS ▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬"
grp_breakout = "⚡ BREAKOUT DETECTION ▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬"
grp_targets  = "🎯 TARGETS & RISK ▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬"
grp_FVG      = "↩️ FVG FILTER ▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬"
grp_lines    = "📍 TP/SL LINES ▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬"
grp_pullback = "↩️ PULLBACK FILTER ▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬"
grp_volume   = "📊 VOLUME FILTER ▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬"
grp_trend    = "📈 TREND FILTER ▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬"
grp_dash     = "📊 DASHBOARD ▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬"
grp_htf      = "📈 HIGHER TIMEFRAME ▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬"
grp_alerts   = "🔔 ALERTS ▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬"

LABEL_OFFSET_ATR_MULTIPLIER = 0.8  // 0.8× ATR distance from high/low
LABEL_OFFSET_BARS = 2              // Bars ahead for edge labels (keeps them visible)

MAX_BARS_FAILED_BREAK = 5  // Maximum bars to consider a retest as "failed break" instead of committed breakout
showEdgeLabels = input.bool(true, "Show Edge Labels", inline = "core", group=grp_colors)
labelFormat = input.string("Detailed", "Label Format", options=["Simple", "Detailed"], group=grp_colors, inline="core1")
labelSize = input.string("Small", "All Label Size", inline = "core1", options=["Tiny", "Small", "Normal", "Large", "Huge"], group=grp_colors, tooltip="Display ORB stage labels at the edge of price levels\n\nShows which ORB period is active (5min/15min/30min/60min)\nLabels follow price as chart scrolls\n\nON = Labels visible\nOFF = Clean chart\n\nVisual size for ALL labels (breakout, retest, failed)\n\nTINY: Minimal space, cluttered on small screens\nSMALL: Clean and readable (recommended)\nNORMAL: Good for presentations\nLARGE: High visibility\nHUGE: Maximum visibility\n\nLabel text format for ALL labels (TP/SL and Breakouts)\n\nSIMPLE:\n• Minimal text\n• TP/SL: 'ENTRY', 'TP1', 'SL'\n• Breakout: '🔼 BREAKOUT UP #1'\n• Clean and compact\n• Good for: Small screens, many lines\n\nDETAILED:\n• Full info with context\n• TP/SL: 'ENTRY: $150.50', 'TP1: $152.20 +1.1%'\n• Breakout: 'ORB15 | #1 | Vol: 2.3x'\n• Shows prices, percentages, ORB stage, volume\n• Good for: Analysis, larger screens (recommended) ⭐\n\nAFTER HIT:\n• TP: '✅ TP1: $152.20'\n• SL: '❌ SL: $148.50'")
showBG = input.bool(true, "Show Background", inline="BG", group=grp_colors)
fillTransparency = input.int(95, "  | Transparency", inline="BG", minval=0, maxval=100, step=5, group=grp_colors, tooltip="Background fill transparency for ORB range\n\n0 = Fully opaque (solid color)\n50 = Semi-transparent\n95 = Nearly invisible (recommended)\n100 = Completely invisible")
enableORB5Signals = input.bool(true, "Enable ORB 5", group=grp_colors, inline="5-15", tooltip="Enable/Disable ORB stages\n\nORB 5: First 5 minutes - fastest signals, most noise\nORB 15: First 15 minutes - balanced signals\nORB 30: First 30 minutes - slower, more reliable\nORB 60: First 60 minutes - slowest, most confirmed\n\nDisable stages you don't want to trade")
orb5LineColor = input.color(color.yellow, "", inline = "5-15",  group=grp_colors)
enableORB15Signals = input.bool(true, "Enable ORB15", group=grp_colors, inline="5-15")
orb15LineColor = input.color(color.green, "", inline = "5-15",group=grp_colors) 
enableORB30Signals = input.bool(true, "Enable ORB30", group=grp_colors, inline="30-60")
orb30LineColor = input.color(color.blue, "", inline = "30-60", group=grp_colors)
enableORB60Signals = input.bool(true, "Enable ORB60", group=grp_colors, inline="30-60")
orb60LineColor = input.color(color.purple, "", inline = "30-60", group=grp_colors)
showMidLine = input.bool(true, "Mid-Range Line", group=grp_colors, tooltip="Display a thin line at the midpoint between ORB High and Low\n\nUSEFUL FOR:\n• Visual center reference\n• Mean reversion trading\n• Support/resistance level\n• Range symmetry analysis\n\nThe line uses the same color as the ORB boundaries but thinner\n\nON = Midpoint line visible\nOFF = Only High/Low lines")

sessionMode = input.string("Auto-Detect", "Session Mode", options=["Auto-Detect", "New-York", "London", "Tokyo", "Sydney", "Frankfurt", "Custom"], group=grp_session, tooltip="Define trading session for ORB calculation\n\nIMPORTANT - DST/TIMEZONE FIX:\nIf ORB appears 1 hour off, fix your chart timezone:\nRight-click chart → Settings → Symbol → Timezone\n\nRECOMMENDED TIMEZONE SETTINGS:\n• NYSE/NASDAQ → America/New_York\n• LSE → Europe/London\n• TSE → Asia/Tokyo\n• ASX → Australia/Sydney\n\nAUTO-DETECT: Uses symbol's native hours (recommended)\n  • Stocks: Uses exchange hours automatically\n  • Crypto: 24/7\n\nNEW YORK: 09:30-16:00 (local NY time)\nLONDON: 08:00-16:30 (local London time)\nTOKYO: 09:00-15:00 JST (TSE)\nSYDNEY: 10:00-16:00 AEST (ASX)\nFRANKFURT: 09:00-17:30 CET (XETRA)\nCUSTOM: Define your own session\n\nORB resets at session start")
customSession = input.session("0930-1600", "Custom Session Hours", group=grp_session, tooltip="Custom trading session definition\n\nONLY ACTIVE when Session Mode = Custom\n\nFORMAT: HHMM-HHMM (24-hour)\n\nEXAMPLES:\n• 0930-1600 = NYSE regular hours\n• 0400-2000 = Extended trading\n• 0000-2359 = Full 24 hours\n\nTIMEZONE: Chart timezone")

enableExtendedHours = input.bool(false, "Include Extended Hours", group=grp_session, inline="ext1", tooltip="Include pre-market and after-hours trading\n\n🌅 PRE-MARKET: 04:00-09:30 EST\n🌆 REGULAR: 09:30-16:00 EST\n🌃 AFTER-HOURS: 16:00-20:00 EST\n\nWhen ENABLED:\n• ORB tracking works 04:00-20:00\n• Dashboard shows 'OPEN' during extended hours\n• Breakouts detected in extended hours\n\nWhen DISABLED:\n• ORB tracking only 09:30-16:00 (regular)\n• Dashboard shows 'CLOSED' outside regular hours\n\nRECOMMENDED: Enable if you trade extended hours")
extendedPreMarket = input.session("0400-0930", "Pre-Market", group=grp_session, inline="ext2", tooltip="Pre-market trading hours\n\nDEFAULT: 04:00-09:30 (NYSE)\n\nDefine the pre-market session window.\nOnly the START time (04:00) is used for extended hours calculation.")
extendedAfterHours = input.session("1600-2000", "After-Hours", group=grp_session, inline="ext3", tooltip="After-hours trading session\n\nDEFAULT: 16:00-20:00 (NYSE)\n\nDefine the after-hours session window.\nOnly the END time (20:00) is used for extended hours calculation.")

string tradingSession = "0930-1600:23456"  // Default: NYSE hours, Mon-Fri
var int sessionStartHour = na
var int sessionStartMinute = na
var int sessionEndHour = na
var int sessionEndMinute = na

if sessionMode == "Auto-Detect"
    if syminfo.type == "stock" or syminfo.type == "fund" or syminfo.type == "index" or syminfo.type == "dr" or syminfo.type == "etf" or syminfo.type == "futures"
        if enableExtendedHours
            string preMarketStart = str.split(extendedPreMarket, "-").get(0)
            string afterHoursEnd = str.split(extendedAfterHours, "-").get(1)
            tradingSession := preMarketStart + "-" + afterHoursEnd + ":23456"
        else

            tradingSession := ""
    else if syminfo.type == "crypto"

        tradingSession := ""
    else if syminfo.type == "forex"

        tradingSession := ""
    else

        tradingSession := ""

else if sessionMode == "New-York"

    if enableExtendedHours
        string preMarketStart = str.split(extendedPreMarket, "-").get(0)
        string afterHoursEnd = str.split(extendedAfterHours, "-").get(1)
        tradingSession := preMarketStart + "-" + afterHoursEnd + ":23456"
    else
        tradingSession := "0930-1600:23456"

else if sessionMode == "London"

    if enableExtendedHours
        string preMarketStart = str.split(extendedPreMarket, "-").get(0)
        string afterHoursEnd = str.split(extendedAfterHours, "-").get(1)
        tradingSession := preMarketStart + "-" + afterHoursEnd + ":23456"
    else
        tradingSession := "0800-1630:23456"

else if sessionMode == "Tokyo"

    if enableExtendedHours
        string preMarketStart = str.split(extendedPreMarket, "-").get(0)
        string afterHoursEnd = str.split(extendedAfterHours, "-").get(1)
        tradingSession := preMarketStart + "-" + afterHoursEnd + ":23456"
    else
        tradingSession := "0900-1500:23456"

else if sessionMode == "Sydney"

    if enableExtendedHours
        string preMarketStart = str.split(extendedPreMarket, "-").get(0)
        string afterHoursEnd = str.split(extendedAfterHours, "-").get(1)
        tradingSession := preMarketStart + "-" + afterHoursEnd + ":23456"

else if sessionMode == "Frankfurt"

    if enableExtendedHours
        string preMarketStart = str.split(extendedPreMarket, "-").get(0)
        string afterHoursEnd = str.split(extendedAfterHours, "-").get(1)
        tradingSession := preMarketStart + "-" + afterHoursEnd + ":23456"
    else
        tradingSession := "0900-1730:23456"

else if sessionMode == "Custom"
    if str.contains(customSession, ":")
        tradingSession := customSession
    else
        tradingSession := customSession + ":23456"

if tradingSession != ""
    string sessionTimeOnly = str.contains(tradingSession, ":") ? str.split(tradingSession, ":").get(0) : tradingSession
    array<string> sessionParts = str.split(sessionTimeOnly, "-")

    if array.size(sessionParts) == 2
        string startTime = array.get(sessionParts, 0)
        string endTime = array.get(sessionParts, 1)

        if str.length(startTime) == 4
            sessionStartHour := int(str.tonumber(str.substring(startTime, 0, 2)))
            sessionStartMinute := int(str.tonumber(str.substring(startTime, 2, 4)))

        if str.length(endTime) == 4
            sessionEndHour := int(str.tonumber(str.substring(endTime, 0, 2)))
            sessionEndMinute := int(str.tonumber(str.substring(endTime, 2, 4)))

enableBreakout = input.bool(true, "Enable Breakout Detection", inline = "Show", group=grp_breakout)
showBreakLabels = input.bool(true, "Show Breakout Labels", group=grp_breakout, inline = "Show", tooltip="Detect and label breakouts above ORB High or below ORB Low\n\nON: Shows breakout labels when price exits ORB range\nOFF: Only displays ORB levels without signals\n\nBreakouts detected on CLOSE (no repaint)")
enableRetest = input.bool(true, "Show Retest Labels", group=grp_breakout, inline="retest", tooltip="Show labels when price returns to ORB after breakout\n\nRETEST = Price broke out, then came back to test ORB level\n\nUSEFUL FOR:\n• Re-entry opportunities\n• Confirming support/resistance\n• Failed breakout detection\n\nON: Shows retest labels\nOFF: Only shows initial breakout")
signalMode = input.string("Track Cycles", "Signal Mode", options=["First Only", "Track Cycles"], group=grp_breakout, inline="mode", tooltip="How many breakout signals to show per day\n\nFIRST ONLY:\n• Shows only the FIRST breakout in each direction\n• One UP signal, one DOWN signal max per day\n• Clean chart, less noise\n• Good for: Swing traders, position traders\n\nTRACK CYCLES:\n• Tracks Breakout → Retest → Re-breakout cycles\n• Multiple signals as price oscillates\n• Detects momentum returns\n• Good for: Active traders, scalpers\n\nRECOMMENDED: Track Cycles")
maxCycles = input.int(6, "Max Cycles", minval=1, maxval=10, group=grp_breakout, inline="mode", tooltip="Maximum cycles to track when Signal Mode = Track Cycles\n\nCYCLE = Breakout → Retest → Re-breakout sequence\n\n1-2 cycles: Clean chart, fewer signals\n4-6 cycles: Balanced (recommended)\n8-10 cycles: Very active, may clutter chart\n\nIGNORED when Signal Mode = First Only")
breakoutBuffer = input.float(0.2, "Breakout Buffer (%)", minval=0, maxval=5, step=0.1, group=grp_breakout, inline="buffer", tooltip="Extra distance required beyond ORB level for breakout\n\nPREVENTS: False breakouts from tiny penetrations\n\nHOW IT WORKS:\n• UP: Price must close ABOVE (ORB High + buffer%)\n• DOWN: Price must close BELOW (ORB Low - buffer%)\n\nRECOMMENDATIONS:\n• 0.0% = Exact level (sensitive, more signals)\n• 0.1% = Tiny buffer (recommended)\n• 0.3% = Moderate filter\n• 0.5%+ = Conservative (fewer signals)\n\nHigher = fewer but stronger breakouts")
retestBuffer = input.float(0.0, "Retest Buffer (%)", minval=0, maxval=5, step=0.1, group=grp_breakout, inline="buffer", tooltip="Tolerance for retest detection\n\nALLOWS: Price to slightly penetrate ORB during retest\n\nHOW IT WORKS:\n• After UP breakout: Retest if price returns to ORB High ± buffer\n• After DOWN breakout: Retest if price returns to ORB Low ± buffer\n\nRECOMMENDATIONS:\n• 0.0% = Must touch exact level (strict)\n• 0.1-0.2% = Slight tolerance (recommended)\n• 0.3-0.5% = Generous tolerance\n\nHigher = more retests detected")
minRetestDistancePct = input.float(0.5, "Min Distance for Retest (%)", minval=0.5, maxval=10, step=0.5, group=grp_breakout, tooltip="How far price must travel away from ORB before retest is valid\n\nPREVENTS: Labeling tiny bounces as 'retests'\n\nEXAMPLE: ORB High = $10.00, Distance = 2%\n• Price breaks to $10.20 (2% away) ✓ Valid\n• Price returns to $10.00 → RETEST LABEL\n• If only went to $10.05 (0.5% away) ✗ Not valid\n\nRECOMMENDATIONS:\n• 0.5% = Very sensitive (many retests)\n• 2.0% = Balanced (filters noise) ⭐\n• 3.0%+ = Only strong moves\n\nHigher = fewer but more meaningful retests")
minBarsOutside = input.int(2, "Min Bars Outside ORB", minval=1, maxval=10, group=grp_breakout, tooltip="How many bars price must stay outside ORB for 'committed' breakout\n\nPREVENTS: Labeling quick failures as breakouts\n\nEXAMPLE: Min Bars = 2\n• Bar 1: Price breaks above ORB High\n• Bar 2: Still above ORB High ✓\n• Bar 3: Returns inside → Now can show retest\n\nIf returned on Bar 2 → Shows 'FAILED BREAK' instead\n\nRECOMMENDATIONS:\n• 1 bar = Aggressive (more signals, more failures)\n• 2 bars = Balanced (recommended) ⭐\n• 3-4 bars = Conservative (only strong moves)\n\nHigher = fewer but stronger breakouts")
minPullbackPct = input.float(0.3, "Min Pullback for Re-break (%)", minval=0.1, maxval=2, step=0.1, group=grp_breakout, tooltip="How far price must pull back before detecting new breakout\n\nPREVENTS: Too many signals from small wiggles\n\nEXAMPLE: Last breakout at $10.00\n• Price reaches $10.50\n• Must pull back to $10.35 (0.3% = $0.15) before new breakout counted\n\nRECOMMENDED:\n• 0.3% = Balanced (recommended) ⭐\n• 0.5% = Less sensitive\n• 1.0% = Very selective")

enableFVGFilter = input.bool(false, "Enable FVG Filter  | ", group=grp_FVG, inline="fvg1")
showFVG = input.bool(true, "Show FVG Boxes", group=grp_FVG, inline="fvg1", tooltip="Fair Value Gap Filter\n\nRequires breakout through FVG for confirmation\n\nFVG = Price gap from strong momentum\nON: Only signals with FVG\nOFF: All signals")
maxFVGtoKeep = input.int(5, "Max FVG", minval=1, maxval=20, inline="fvg2", group=grp_FVG)
fvgProximity = input.float(2.0, "FVG Proximity", minval=0.5, maxval=5.0, inline="fvg2", step=0.5, group=grp_FVG, tooltip="How close to FVG?\n\n1.0 = Must be IN the FVG\n2.0 = Within 2x FVG size (recommended)\n3.0 = Within 3x FVG size (very permissive)")
fvgTransparency = input.int(90, "Transparency", minval=0, maxval=100, step=5, inline="fvgcolor", group=grp_FVG)
fvgBullColor = input.color(color.green, "Bullish FVG", inline="fvgcolor", group=grp_FVG)
fvgBearColor = input.color(color.orange, "Bearish FVG", inline="fvgcolor", group=grp_FVG)

enablePullbackFilter = input.bool(false, "Enable Pullback Filter", group=grp_pullback, tooltip="Require pullback confirmation before showing breakout signal\n\nWHY: Filters weak breakouts that reverse immediately\nHOW: Waits for price to pull back slightly, then continue breakout direction\n\nWORKFLOW:\n1. Price breaks above/below ORB\n2. Wait for pullback (small dip/rise)\n3. Price continues in breakout direction\n4. NOW show signal ✅\n\nBENEFITS:\n• Better entry prices\n• Fewer false breakouts\n• Improved risk/reward\n• Confirmation of strength\n\nDRAWBACKS:\n• Misses fast runners\n• Slower signals\n• More conservative\n\nON: Wait for pullback confirmation\nOFF: Immediate signals (current behavior)\n\nRECOMMENDED: Try OFF first, enable if too many false signals")
pullbackPercent = input.float(0.3, "Pullback Required (%)", minval=0.1, maxval=2.0, step=0.1, group=grp_pullback, inline="pb", tooltip="How much pullback required for confirmation\n\nEXAMPLE: ORB High = $100, Pullback = 0.5%\n• Breaks to $100.60 (above ORB)\n• Pulls back to $100.10 (0.5% dip) ✓\n• Continues to $100.70 → SIGNAL!\n\nSMALLER % = More signals, faster\nLARGER % = Fewer signals, stronger\n\nRECOMMENDED:\n• 0.3% = Sensitive (active trading) ⭐\n• 0.5% = Balanced\n• 1.0% = Conservative (swing trading)")
pullbackTimeout = input.int(10, "Timeout (bars)", minval=3, maxval=30, group=grp_pullback, inline="pb", tooltip="Max bars to wait for pullback\n\nIf pullback doesn't happen within this time:\n→ Shows signal anyway (prevents missing strong moves)\n\nEXAMPLE: Timeout = 10 bars\n• Breakout occurs\n• Wait 10 bars for pullback\n• No pullback? → Show signal at bar 10\n• Pullback at bar 5? → Show signal when continues\n\nSHORTER = Less waiting, more immediate signals\nLONGER = More patient, better confirmation\n\nRECOMMENDED:\n• 5 bars = Quick (5min chart = 25 min)\n• 10 bars = Balanced (5min chart = 50 min) ⭐\n• 15 bars = Patient (5min chart = 75 min)")

enableVolumeFilter = input.bool(false, "Enable Volume Filter", group=grp_volume, inline="enable", tooltip="Require volume confirmation for breakout signals\n\nWHY: High volume breakouts are more reliable\nWHAT: Compares current volume to moving average\n\nON: Only shows breakouts with sufficient volume\nOFF: Shows all breakouts regardless of volume\n\nRECOMMENDED: ON for stocks, OFF for crypto")
volumeMaLength = input.int(20, "| MA Length", minval=1, group=grp_volume, inline="enable", tooltip="Volume moving average period for comparison\n\nSHORTER = More sensitive to recent volume spikes\nLONGER = Smoother average, less reactive\n\nRECOMMENDATIONS:\n• 10 periods: Very responsive\n• 20 periods: Balanced (recommended) ⭐\n• 50 periods: Long-term average\n\nCHART TIMEFRAME affects calculation:\n• 5min chart, MA=20 → Last 100 minutes\n• 1hour chart, MA=20 → Last 20 hours")
volumeMultiplier = input.float(1.5, "Min Volume ×", minval=0.5, step=0.1, group=grp_volume, inline="mult", tooltip="Minimum volume multiplier required for breakout\n\nCURRENT VOLUME must be ≥ (Volume MA × Multiplier)\n\nEXAMPLE: Volume MA = 1M shares, Multiplier = 1.5\n• Breakout with 1.6M volume ✓ Valid\n• Breakout with 1.2M volume ✗ Rejected\n\nRECOMMENDATIONS:\n• 1.0× = Any above-average volume\n• 1.5× = Moderate requirement (recommended) ⭐\n• 2.0× = Strong requirement (fewer signals)\n• 2.5×+ = Very selective\n\nHigher = fewer but higher-quality signals")
strongVolumeMultiplier = input.float(2.0, "Strong ×", minval=1.0, step=0.1, group=grp_volume, inline="mult", tooltip="Strong volume override threshold\n\nSPECIAL RULE: If volume exceeds this multiplier:\n→ BYPASSES all other filters (trend, etc.)\n→ Shows breakout immediately\n\nRATIONALE: Massive volume = institutional activity\n\nEXAMPLE: Volume MA = 1M, Strong = 2.0×\n• Breakout with 2.5M volume → Shows even if trend filter says NO\n\nRECOMMENDATIONS:\n• 2.0× = Balanced (recommended) ⭐\n• 2.5× = More selective\n• 3.0× = Only exceptional volume\n\nMUST BE ≥ Min Volume Multiplier")

enableTrendFilter = input.bool(false, "Enable Trend Filter", group=grp_trend, inline = "FILTER", tooltip="Only show breakouts that align with broader trend\n\nWHY: Trend-aligned breakouts have higher success rate\nWHAT: Checks if price is above/below trend indicator\n\nRULES:\n• UP breakout: Only if price ABOVE trend\n• DOWN breakout: Only if price BELOW trend\n\nON: Filters against-trend breakouts\nOFF: Shows all breakouts\n\nRECOMMENDED: ON for conservative trading")
trendMode = input.string("VWAP", "| Trend Mode",inline = "FILTER", options=["VWAP", "EMA", "Custom EMA", "SuperTrend", "VWAP+EMA", "VWAP+SuperTrend"], group=grp_trend, tooltip="Method to determine trend direction\n\nVWAP (Volume-Weighted Average Price):\n• Accounts for volume in price calculation\n• Good for: Intraday trading\n• Above VWAP = Bullish, Below = Bearish\n\nEMA (12-period):\n• Fast exponential moving average\n• Responsive to recent price action\n• Good for: Quick trends\n\nCUSTOM EMA:\n• Your own EMA period\n• Longer = Smoother trend\n• Good for: Swing trading (50-200 period)\n\nSUPERTREND:\n• ATR-based trailing stop\n• Clear trend direction\n• Good for: Strong trends\n\nVWAP+EMA:\n• BOTH must agree\n• More conservative\n• Fewer but higher quality signals\n\nVWAP+SUPERTREND:\n• BOTH must agree\n• Most conservative\n• Best signal quality")

customEmaLength = input.int(50, "Custom EMA Length", minval=1, group=grp_trend, inline="ema", tooltip="EMA period when Trend Mode = Custom EMA\n\nSHORTER = More reactive, more signals\nLONGER = Smoother, fewer signals\n\nRECOMMENDATIONS:\n• 20-30: Intraday trading\n• 50: Swing trading (recommended) ⭐\n• 100-200: Position trading\n\nIGNORED for other trend modes")
supertrendPeriod = input.int(10, "SuperTrend Period", minval=1, group=grp_trend, inline="st", tooltip="ATR period for SuperTrend calculation\n\nSHORTER = More sensitive, tighter stops\nLONGER = Smoother, wider stops\n\nRECOMMENDATIONS:\n• 7: Aggressive\n• 10: Balanced (recommended) ⭐\n• 14: Conservative\n\nONLY USED when Trend Mode includes SuperTrend")
supertrendMult = input.float(3.0, "Mult", minval=0.1, step=0.1, group=grp_trend, inline="st", tooltip="ATR multiplier for SuperTrend bands\n\nLOWER = Tighter bands, more trend changes\nHIGHER = Wider bands, fewer changes\n\nRECOMMENDATIONS:\n• 2.0: Sensitive (more signals)\n• 3.0: Balanced (recommended) ⭐\n• 4.0+: Conservative (fewer signals)\n\nONLY USED when Trend Mode includes SuperTrend")

enableTargets = input.bool(true, "Enable Targets & Stop-Loss", group=grp_targets, tooltip="Calculate and display profit targets (TP) and stop-loss (SL)\n\nWHEN ENABLED:\n• Shows TP/SL lines on chart during breakout\n• Displays values in dashboard\n• Calculates Risk/Reward ratio\n\nWHEN DISABLED:\n• Only shows ORB levels\n• No trade management\n\nRECOMMENDED: ON for active trading")

showTP1 = input.bool(true, "TP1 (1R)", group=grp_targets, inline="show")
showTP1_5 = input.bool(false, "TP1.5 (1.5R)", group=grp_targets, inline="show")
showTP2 = input.bool(true, "TP2 (2R)", group=grp_targets, inline="show")
showTP3 = input.bool(false, "TP3 (3R)", group=grp_targets, inline="show", tooltip="Select which Take Profit levels to display\n\nR = RISK UNITS (1R = distance from entry to stop-loss)\n\nTP1 (1R): Conservative target, 1:1 risk/reward\nTP1.5 (1.5R): Intermediate target\nTP2 (2R): Balanced target, 2:1 risk/reward\nTP3 (3R): Aggressive target, 3:1 risk/reward\n\nRECOMMENDED COMBINATIONS:\n• Scalping: TP1 + TP1.5\n• Day Trading: TP1 + TP2 ⭐\n• Swing Trading: TP1 + TP2 + TP3\n\nLines and labels stop updating when last enabled TP is hit")

stopMode = input.string("ATR", "Stop Method", options=["ATR", "ORB %", "Swing", "Safer", "Scaled ATR", "% Based", "Smart Adaptive"], group=grp_targets, inline="tgt", tooltip="How to calculate Stop Loss placement\n\n🆕 ATR-BASED VOLATILITY SYSTEM:\n\nSMART ADAPTIVE (Recommended) ⭐:\n• Adjusts to ACTUAL volatility (not price)\n• ATR < 1.5% = Tight stop (0.7× ATR)\n• ATR 1.5-3% = Normal stop (1.0× ATR)\n• ATR > 3% = Wide stop (1.5× ATR)\n• Perfect for: ALL assets automatically\n\nSCALED ATR:\n• Dynamic multiplier based on volatility %\n• Very volatile (>5% ATR): 2.5× ATR\n• High volatility (3-5%): 2.0× ATR\n• Normal (1.5-3%): 1.5× ATR\n• Low (<1.5%): 1.2× ATR\n• Good for: Mixed portfolios\n\nATR:\n• Standard ATR with volatility adjustment\n• Multiplier adjusts to market conditions\n• Formula: SL = Entry ± (ATR × Multiplier × VolAdjust)\n• Good for: Traditional traders\n\n% BASED:\n• Fixed percentage from entry\n• You set the % (e.g., 1.0%)\n• Simple and consistent\n• Good for: Beginners\n\n────────────────────────\n\n🔥 NEW VOLATILITY PROTECTION:\n\nALL METHODS NOW USE ATR-BASED MINIMUMS:\n• Crypto: Min 1.0× ATR (wider for volatility)\n• Forex: Min 0.3× ATR (tighter for stability)\n• Stocks: Min 0.5-1.5× ATR (based on volatility)\n\nABSOLUTE MINIMUMS:\n• Crypto: 1.0% of price\n• Forex: 0.2% of price\n• Stocks: 0.3% of price\n\n────────────────────────\n\nORB %:\n• Fixed percentage beyond ORB level\n• Simple and predictable\n• Formula: SL = ORB_Level ± (ORB_Range × %)\n• Good for: ORB-focused trading\n\nSWING:\n• Placed at recent swing high/low\n• Technical support/resistance\n• Respects chart structure\n• May be far from entry\n• Good for: Technical traders\n\nSAFER:\n• Widest stop of all methods\n• Lowest chance of stop-out\n• Largest potential loss\n• Good for: Risk-averse traders")
atrLength = input.int(14, "ATR", minval=5, maxval=50, group=grp_targets, inline="atr2", tooltip="ATR calculation period\n\nATR = Average True Range = How much price moves\n\nSHORTER = More reactive to recent volatility\nLONGER = Smoother, stable average\n\nRECOMMENDATIONS:\n• 7-10: Day trading, responsive\n• 14: Standard, balanced (recommended) ⭐\n• 20-30: Swing trading, smooth\n\nUSED FOR: ATR-based targets and stops")
atrMultiplier = input.float(1.5, "×", minval=0.5, maxval=3, step=0.1, group=grp_targets, inline="atr2", tooltip="ATR multiplier for stop-loss distance\n\nSL = Entry ± (ATR × Multiplier)\n\nLOWER = Tighter stop, less risk, more stop-outs\nHIGHER = Wider stop, more risk, fewer stop-outs\n\nRECOMMENDATIONS:\n• 1.0×: Tight stop (aggressive)\n• 1.5×: Balanced (recommended) ⭐\n• 2.0×: Loose stop (conservative)\n• 2.5×+: Very loose (volatile stocks)\n\nONLY AFFECTS: ATR stop method")
percentBasedStop = input.float(1.0, "% Based Stop", minval=0.1, maxval=5.0, step=0.1, group=grp_targets, inline="pct", tooltip="Stop Loss percentage from entry\n\nONLY USED when Stop Method = % Based\n\nFORMULA:\n• LONG: SL = Entry × (1 - Stop%)\n• SHORT: SL = Entry × (1 + Stop%)\n\nEXAMPLE: Entry = $100, Stop = 1.0%\n• LONG SL: $99.00 (1% below)\n• SHORT SL: $101.00 (1% above)\n\nRECOMMENDATIONS:\n• 0.5%: Tight (day trading, scalping)\n• 1.0%: Balanced (recommended) ⭐\n• 1.5%: Medium (swing trading)\n• 2.0%+: Wide (position trading)\n\nPERFECT FOR:\n• High-price assets (BTC, TSLA)\n• Consistent risk management\n• Easy to understand")
stopOrbFraction = input.float(20, "ORB Stop %", minval=10, maxval=50, step=5, group=grp_targets, inline="stop", tooltip="Stop distance as percentage of ORB range\n\nONLY USED when Stop Method = ORB %\n\nFORMULA:\n• LONG: SL = ORB_Low - (ORB_Range × 20%)\n• SHORT: SL = ORB_High + (ORB_Range × 20%)\n\nEXAMPLE: ORB Range = $1.00, Fraction = 20%\n• SL placed $0.20 beyond ORB boundary\n\nRECOMMENDATIONS:\n• 10-15%: Tight (more stop-outs)\n• 20%: Balanced (recommended) ⭐\n• 30-40%: Loose (fewer stop-outs)\n• 50%: Very loose")
swingBars = input.int(3, "Swing Bars", minval=1, maxval=10, group=grp_targets, inline="stop", tooltip="Lookback period to find swing high/low\n\nONLY USED when Stop Method = Swing\n\nSWING = Local high/low point (reversal point)\n\nSHORTER = Recent swing (closer SL)\nLONGER = Deeper swing (farther SL)\n\nEXAMPLE: Swing Bars = 3\n• Looks back 3 bars\n• Finds lowest low (for LONG) or highest high (for SHORT)\n• Places SL there\n\nRECOMMENDATIONS:\n• 2: Very recent swing (aggressive)\n• 3: Recent swing (recommended) ⭐\n• 5: Moderate swing\n• 7-10: Deep swing (conservative)")
showTPSLLines = input.bool(true, "Show TP/SL Lines on Chart", group=grp_lines, tooltip="Display Entry, TP, and SL as horizontal lines on chart\n\nWHEN BREAKOUT OCCURS:\n• Lines appear instantly\n• Extend forward as chart progresses\n• Update with each new bar\n\nLINES FREEZE (stop updating) when:\n• Last TP is hit ✓\n• Stop Loss is hit ✗\n• End of Day (if enabled)\n\nCOLORS:\n• Entry: Cyan (LONG) / Orange (SHORT)\n• TP: Green when hit, cyan/orange before\n• SL: Red always\n\nON: Shows lines (recommended)\nOFF: Only dashboard display")
freezeOnEOD = input.bool(true, "Freeze Lines at End of Day", group=grp_lines, inline="freeze", tooltip="Stop updating lines when trading session ends\n\nON (Recommended):\n• Lines freeze at session close\n• Keeps intraday setup visible\n• Clean daily reset\n• Good for: ORB strategy (intraday)\n\nOFF:\n• Lines continue extending until hit\n• May cross multiple sessions\n• Good for: Swing trading, 24/7 markets\n\nNOTE: Lines also freeze when SL hit or last TP hit")

showDashboard = input.bool(true, "Show Info Panel", group=grp_dash, inline="theme")
dashTheme = input.string("Dark", "| Theme", options=["Dark", "Light"], group=grp_dash, inline="theme", tooltip="Dashboard color scheme\n\nDARK (Recommended):\n• Light text on dark background\n• Matches dark chart themes\n• Less eye strain\n• Professional look\n\nLIGHT:\n• Dark text on light background\n• Matches light chart themes\n• Good for presentations\n• High contrast")
dashPos = input.string("Bottom Left", "Position", options=["Top Left", "Top Right", "Bottom Left", "Bottom Right", "Middle Right"], group=grp_dash, inline="pos", tooltip="Dashboard placement on chart\n\nTOP LEFT: Good for price action top-right\nTOP RIGHT: Good for price action top-left\nBOTTOM LEFT: Classic placement (recommended) ⭐\nBOTTOM RIGHT: Avoid volume bars\nMIDDLE RIGHT: Floating position\n\nChoose based on where price usually is")
dashSize = input.string("Auto", "Text Size", options=["Auto", "Small", "Normal", "Large"], group=grp_dash, inline="pos", tooltip="Text size inside dashboard\n\nAUTO: Adapts to chart zoom (recommended) ⭐\nSMALL: Compact, more screen space\nNORMAL: Readable\nLARGE: Presentations, poor eyesight")
showStage = input.bool(true, "Show Stage", group=grp_dash, inline="rows1", tooltip="Display current ORB stage\n\nSHOWS: Which timeframe is active\n• ORB 5 (5 minutes)\n• ORB 15 (15 minutes)\n• ORB 30 (30 minutes)\n• ORB 60 (60 minutes)\n\nUseful for knowing which ORB you're trading")
showRange = input.bool(true, "Show Range", group=grp_dash, inline="rows1", tooltip="Display ORB range size\n\nSHOWS:\n• High-Low difference (dollars)\n• Range as percentage\n\nEXAMPLE: '$0.50 (2.5%)'\n\nUseful for assessing if range is significant")
showStatus = input.bool(true, "Show Status", group=grp_dash, inline="rows1", tooltip="Display breakout status\n\nSTATES:\nINSIDE RANGE: Price within ORB\n• 💰 BREAK UP: Above ORB High\n▼ BREAK DOWN: Below ORB Low\n• 👁 RETEST: Returned to ORB after breakout\n\nQuick visual confirmation of position")
showVol = input.bool(true, "Show Volume", group=grp_dash, inline="rows2", tooltip="Display volume status\n\nONLY SHOWN when Volume Filter enabled\n\nSHOWS:\n• Current volume vs average\n• Multiplier (e.g., '1.8x')\n• ✓ if above threshold\n• ✗ if below threshold\n\nUseful for confirming breakout strength")
showTrend = input.bool(true, "Show Trend", group=grp_dash, inline="rows2", tooltip="Display trend direction\n\nONLY SHOWN when Trend Filter enabled\n\nSHOWS:\n• Trend direction (UP/DOWN/NEUTRAL)\n• Method used (VWAP/EMA/etc.)\n• ✓ Aligned / ✗ Against trend\n\nUseful for context")
showRisk = input.bool(true, "Show Risk/Reward", group=grp_dash, inline="rows2", tooltip="Display Risk/Reward ratio\n\nSHOWS: Ratio of potential profit to risk\n\nFORMAT: '1:2.5' means:\n• Risk: $100\n• Reward: $250\n\nINDICATORS:\n• ✅ Ratio ≥ 2.0 (good)\n• ⚠️ Ratio 1.5-2.0 (acceptable)\n• ❌ Ratio < 1.5 (poor)\n\nBased on highest enabled TP")
showVolatilityMeter = input.bool(true, "Show Volatility Meter", group=grp_dash, inline="rows3", tooltip="Display current market volatility level\n\nMEASURES: ATR as percentage of price\n\nLEVELS:\n🔥🔥🔥 EXTREME (>3%): Very volatile, wider stops needed\n🔥🔥 HIGH (2-3%): Active movement, standard stops\n🔥 MEDIUM (1-2%): Normal trading range\n⚪ LOW (<1%): Quiet market, tight stops possible\n\nUSE FOR:\n• Adjusting position size\n• Setting appropriate stops\n• Understanding market conditions\n\nHigh volatility = Bigger potential moves but more risk")

enablePosSizing = input.bool(true, "Calculate Position Size", group=grp_dash, tooltip="Calculate shares to buy based on risk management\n\nCALCULATES:\n• Max shares to buy\n• Position dollar value\n• Risk amount\n• TP profit projections\n• TP allocation splits\n\nWHY:\n• Consistent risk per trade\n• Proper position sizing\n• Prevents over-leveraging\n\nSHOWS: Extra section in dashboard\n\nON: Shows position sizing\nOFF: Only price levels")
riskMode = input.string("$ Amount", "Risk", options=["$ Amount", "% of Account"], group=grp_dash, inline="risk", tooltip="How to define your risk per trade\n\n$ AMOUNT:\n• Risk fixed dollar amount\n• Simple and direct\n• Example: '$150 per trade'\n• Good for: Consistent trading\n\n% OF ACCOUNT:\n• Risk percentage of total account\n• Scales with account size\n• Example: '1% of $25,000 = $250'\n• Good for: Account growth\n\nRECOMMENDED: % of Account")
fixedRisk = input.float(150, "$", minval=10, maxval=10000, group=grp_dash, inline="risk", tooltip="Fixed dollar amount to risk per trade\n\nONLY USED when Risk Mode = $ Amount\n\nEXAMPLE: Fixed Risk = $150\n• Entry: $10.00\n• Stop: $9.50 (50¢ risk per share)\n• Position: 300 shares ($150 ÷ $0.50)\n• Total position value: $3,000\n\nRECOMMENDATIONS:\n• $50-100: Small accounts\n• $150-300: Medium accounts ⭐\n• $500+: Large accounts")
accountSize = input.float(25000, "Account $", minval=1000, group=grp_dash, inline="acct", tooltip="Total trading account size\n\nUSED FOR: Calculating risk percentage\n\nEXAMPLE: Account = $25,000, Risk = 1%\n• Risk per trade = $250\n\nUPDATE THIS:\n• When account grows/shrinks significantly\n• For accurate position sizing\n• Monthly review recommended")
riskPct = input.float(0.5, "Risk %", minval=0.1, maxval=5, step=0.1, group=grp_dash, inline="acct", tooltip="Percentage of account to risk per trade\n\nONLY USED when Risk Mode = % of Account\n\nRISK LEVELS:\n• 0.25-0.5%: Very conservative, slow growth\n• 0.5-1%: Balanced (recommended) ⭐\n• 1-2%: Aggressive, faster growth\n• 2-3%: Very aggressive, high risk\n• 3%+: Extreme risk, not recommended\n\nEXAMPLE: Account = $25,000, Risk = 1%\n• Risk per trade = $250\n• Entry: $10, Stop: $9.50 (50¢ risk)\n• Position: 500 shares\n\nRECOMMENDED: 0.5-1% for most traders")
maxPositionPct = input.float(25.0, "Max Position %", minval=5, maxval=100, step=5, group=grp_dash, inline="poslimit", tooltip="Maximum position size as % of account\n\nPREVENTS OVER-LEVERAGE when stop is very tight\n\nEXAMPLE: Account = $10,000, Max = 25%\n• Maximum position value = $2,500\n• If stock = $100, max 25 shares\n• Even if risk calculation allows more\n\nRECOMMENDED LEVELS:\n• 10-15%: Very conservative\n• 20-25%: Balanced ⭐\n• 30-50%: Aggressive\n• 50%+: Very aggressive\n\nThis protects against:\n• Tight stops causing huge positions\n• Slippage on large positions\n• Liquidity issues")

accountCurrency = input.string("USD", "Account Currency", options=["USD", "EUR", "GBP", "JPY", "INR", "CAD", "AUD", "CHF"], group=grp_dash, inline="currency", tooltip="Currency of your trading account\n\nUSD: U.S. Dollar\nEUR: Euro\nGBP: British Pound\nJPY: Japanese Yen\nINR: Indian Rupee\nCAD: Canadian Dollar\nAUD: Australian Dollar\nCHF: Swiss Franc\n\nIMPORTANT: Affects position sizing calculations\nAll risk and position values are shown in this currency")
useDynamicRates = input.bool(true, "Live Exchange Rates", group=grp_dash, inline="exchange", tooltip="Fetch live exchange rates from market data\n\nON: Uses real-time rates from TradingView (recommended)\nOFF: Use manual rate input\n\nNOTE: Live rates may not be available for all pairs")
manualRate = input.float(1.0, "/ Or set manual Rate: $1=", minval=0.001, maxval=10000, step=0.1, group=grp_dash, inline="exchange", tooltip="Fallback exchange rate when live rates unavailable\n\nFrom USD to your account currency\n\nEXAMPLES:\n• USD to INR = 83.0\n• USD to EUR = 0.92\n• USD to JPY = 150.0")

symbolCurrency = syminfo.currency

float liveRate = na
string currencyPair = ""

if useDynamicRates and accountCurrency != "USD"
    currencyPair := accountCurrency == "EUR" ? "EURUSD" :
                   accountCurrency == "GBP" ? "GBPUSD" :
                   accountCurrency == "JPY" ? "USDJPY" :
                   accountCurrency == "INR" ? "USDINR" :
                   accountCurrency == "CAD" ? "USDCAD" :
                   accountCurrency == "AUD" ? "AUDUSD" :
                   accountCurrency == "CHF" ? "USDCHF" : ""

    if currencyPair != ""
        liveRate := request.security(currencyPair, "D", close, lookahead=barmerge.lookahead_off)

float defaultRate = accountCurrency == "EUR" ? 0.92 :
                   accountCurrency == "GBP" ? 0.79 :
                   accountCurrency == "JPY" ? 150.0 :
                   accountCurrency == "INR" ? 83.0 :
                   accountCurrency == "CAD" ? 1.38 :
                   accountCurrency == "AUD" ? 1.55 :
                   accountCurrency == "CHF" ? 0.90 : 1.0
exchangeRate = accountCurrency == "USD" ? 1.0 :
               not useDynamicRates ? manualRate :
               na(liveRate) ? defaultRate :

               (accountCurrency == "EUR" or accountCurrency == "GBP" or accountCurrency == "AUD") ? 1/liveRate : 
               liveRate  // Direct rate for pairs where USD is base currency (JPY, INR, CAD, CHF)

enableHTF = input.bool(true, "Check Daily Trend", group=grp_htf, tooltip="Check higher timeframe trend before taking breakouts\n\nWHY: Breakouts WITH higher timeframe trend have higher success rate\n\nWHAT IT DOES:\n• Checks daily/4H/weekly trend\n• Shows warning if breakout against trend\n• Displays HTF bias in dashboard\n\nDOES NOT BLOCK signals - only warns you\n\nON: Shows HTF context (recommended for swing traders)\nOFF: Focuses only on intraday ORB")
htfTF = input.string("D", "Timeframe", options=["15", "30", "60", "120", "240", "D", "W", "M"], group=grp_htf, inline="htf", tooltip="Higher timeframe to analyze for trend\n\nRECOMMENDED OPTIONS:\n• 15/30/60 min: For 1-5 min charts\n• 240 (4H): For 15-60 min charts\n• D (Daily): For intraday trading ⭐\n• W (Weekly): For swing trading\n• M (Monthly): For position trading\n\nRULE: HTF should be 4-10× your chart timeframe\n\nEXAMPLES:\n• 5min chart → Use 30/60/D\n• 15min chart → Use 60/240/D\n• 1H chart → Use 240/D/W")
htfMethod = input.string("Price vs MA", "Method", options=["Price vs MA", "Candle Direction"], group=grp_htf, inline="htf", tooltip="How to determine HTF trend\n\nPRICE VS MA (Recommended):\n• Compares HTF close to moving average\n• Above MA = Bullish\n• Below MA = Bearish\n• Smooth and reliable\n• Less prone to whipsaws\n\nCANDLE DIRECTION:\n• Based on HTF candle color\n• Green candle = Bullish\n• Red candle = Bearish\n• More reactive\n• Can change quickly\n\nRECOMMENDED: Price vs MA for stability")
htfEMA = input.int(20, "MA", minval=5, maxval=200, group=grp_htf, inline="htf2", tooltip="")
htfMinStrength = input.float(2.0, "Min Distance %", minval=0.0, maxval=10.0, step=0.5, group=grp_htf, inline="htf2", tooltip="Moving average period for HTF trend\n\nONLY USED when Method = Price vs MA\n\nSHORTER = More reactive, frequent changes\nLONGER = Smoother, stable trend\n\nRECOMMENDATIONS:\n• 10-20: Responsive (short-term trend)\n• 20-50: Balanced (recommended) ⭐\n• 50-100: Smooth (intermediate trend)\n• 100-200: Very smooth (long-term trend)\n\nCOMMON CHOICES:\n• Daily TF + 20 EMA: Classic\n• Daily TF + 50 EMA: Swing trading\n• Weekly TF + 20 EMA: Position trading\n\nMinimum distance from MA to consider trend valid\n\nPrice must be at least X% away from MA\n\nLOWER = Accept weak trends\nHIGHER = Only strong trends\n\nRECOMMENDATIONS:\n• 0-1%: Very permissive\n• 1-2%: Balanced ⭐\n• 2-3%: Conservative\n• 3%+: Very selective\n\nHELPS AVOID:\n• Choppy/sideways markets\n• Weak trend signals\n• False breakouts")

bool enableAlerts = true
bool alertBreakouts = true
bool alertRetests = true
bool alertFailedBreaks = true
bool alertStageComplete = true

if breakoutBuffer < 0 or breakoutBuffer > 5
    runtime.error("❌ Breakout Buffer must be between 0-5%. Current value: " + str.tostring(breakoutBuffer))
if minRetestDistancePct < 0.5
    runtime.error("❌ Min Retest Distance too low. Must be >= 0.5% to prevent false signals. Current: " + str.tostring(minRetestDistancePct))
if minBarsOutside < 1
    runtime.error("❌ Min Bars Outside must be >= 1. Current: " + str.tostring(minBarsOutside))
if maxCycles < 1 or maxCycles > 10
    runtime.error("❌ Max Cycles must be between 1-10. Current: " + str.tostring(maxCycles))
if enableVolumeFilter
    if volumeMultiplier < 0.5
        runtime.error("❌ Volume Multiplier too low. Must be >= 0.5x. Current: " + str.tostring(volumeMultiplier))
    if strongVolumeMultiplier < volumeMultiplier
        runtime.error("❌ Strong Volume Multiplier must be >= Min Volume Multiplier. Strong: " + str.tostring(strongVolumeMultiplier) + ", Min: " + str.tostring(volumeMultiplier))
    if volumeMaLength < 1
        runtime.error("❌ Volume MA Length must be >= 1. Current: " + str.tostring(volumeMaLength))
if enableTargets
    if atrLength < 5 or atrLength > 50
        runtime.error("❌ ATR Length must be between 5-50. Current: " + str.tostring(atrLength))    
    if atrMultiplier < 0.5 or atrMultiplier > 5
        runtime.error("❌ ATR Multiplier must be between 0.5-5. Current: " + str.tostring(atrMultiplier))    
    if stopOrbFraction < 10 or stopOrbFraction > 100
        runtime.error("❌ ORB Stop % must be between 10-100%. Current: " + str.tostring(stopOrbFraction))    
    if swingBars < 1 or swingBars > 20
        runtime.error("❌ Swing Bars must be between 1-20. Current: " + str.tostring(swingBars))
if enablePosSizing
    if riskMode == "$ Amount" and fixedRisk < 10
        runtime.error("❌ Fixed Risk too low. Must be >= $10. Current: $" + str.tostring(fixedRisk))   
    if riskMode == "% of Account"
        if riskPct < 0.1 or riskPct > 10
            runtime.error("❌ Risk % must be between 0.1-10%. Current: " + str.tostring(riskPct) + "%")      
        if accountSize < 100
            runtime.error("❌ Account Size too low. Must be >= $100. Current: $" + str.tostring(accountSize))
if fillTransparency < 0 or fillTransparency > 100
    runtime.error("❌ Fill Transparency must be between 0-100%. Current: " + str.tostring(fillTransparency))
if enableHTF
    if htfEMA < 5 or htfEMA > 200
        runtime.error("❌ HTF EMA period must be between 5-200. Current: " + str.tostring(htfEMA))
if enableTrendFilter
    if customEmaLength < 1 or customEmaLength > 500
        runtime.error("❌ Custom EMA Length must be between 1-500. Current: " + str.tostring(customEmaLength))

    if supertrendPeriod < 1 or supertrendPeriod > 50
        runtime.error("❌ SuperTrend Period must be between 1-50. Current: " + str.tostring(supertrendPeriod))

    if supertrendMult < 0.1 or supertrendMult > 10
        runtime.error("❌ SuperTrend Multiplier must be between 0.1-10. Current: " + str.tostring(supertrendMult))

bool useNativeSession = tradingSession == ""

bool is24_7Market = syminfo.type == "crypto" and (useNativeSession or tradingSession == "0000-2359:1234567")

inSession = false
if useNativeSession

    inSession := not na(time(timeframe.period))
else

    if syminfo.type == "stock" or syminfo.type == "fund" or syminfo.type == "index" or syminfo.type == "dr" or syminfo.type == "etf" or syminfo.type == "futures"
        inSession := not na(time(timeframe.period, tradingSession))
    else if syminfo.type == "crypto"
        if is24_7Market
            inSession := true  // 24/7 trading - always in session
        else
            inSession := not na(time(timeframe.period, tradingSession))  // Respect custom session hours
    else if syminfo.type == "forex"
        inSession := not na(time(timeframe.period, tradingSession))
    else
        inSession := not na(time(timeframe.period, tradingSession))

var label labH = na
var label labL = na
var color cachedLineColor = na
var float lastLabelH = na
var float lastLabelL = na
var string cachedStageName = na
var bool hadSessionToday = false
var bool hadBreakUp = false
var bool hadBreakDown = false
var int breakUpBar = na
var int breakDownBar = na
var bool shownBreakUpLabel = false
var bool shownBreakDownLabel = false
var bool everHadBreakUp = false
var bool everHadBreakDown = false
var float breakoutEntryPrice = na

var int cyclesUp = 0
var int cyclesDown = 0

var int retestCyclesUp = 0 
var int retestCyclesDown = 0

var int sessionBreakoutsUp = 0
var int sessionBreakoutsDown = 0
var int sessionRetestsUp = 0
var int sessionRetestsDown = 0 

var string alertMsgRetestUp = ""
var string alertMsgRetestDown = ""
var string alertMsgFailedUp = ""
var string alertMsgFailedDown = ""
var string alertMsgStageComplete = ""

bool alertBreakUpTriggered = false
bool alertBreakDownTriggered = false
bool alertRetestUpTriggered = false
bool alertRetestDownTriggered = false
bool alertFailedUpTriggered = false
bool alertFailedDownTriggered = false
bool alertStageCompleteTriggered = false

var int barsOutsideAfterBreakUp = 0
var int barsOutsideAfterBreakDown = 0

var label lastBreakUpLabel = na
var label lastBreakDownLabel = na
var int lastLabelStage = na

var int breakUpBarIndex = 0
var int breakDownBarIndex = 0

var bool pendingLongEntry = false
var bool pendingShortEntry = false
var int pendingLongBar = na
var int pendingShortBar = na

var array<label> breakoutLabels = array.new<label>()
MAX_LABELS_TO_KEEP = 10
var array<line> tpslLines = array.new<line>()
var array<box> orbBoxes = array.new<box>()
MAX_LINES_TO_KEEP = 20
MAX_BOXES_TO_KEEP = 10

var int lastDashUpdateBar = -1

var float cachedATR = na
var int cachedATRBar = -1
var float cachedVolumeMA = na
var int cachedVolumeMABar = -1

var float cachedEntry = na
var float cachedSL = na
var float cachedTP1 = na
var float cachedTP1_5 = na
var float cachedTP2 = na
var float cachedTP3 = na
var float cachedShares = na
var float cachedPosValue = na
var float cachedMaxLoss = na
var float cachedRiskAmount = na

var array<box> fvgBoxes = array.new<box>()
var array<float> fvgTops = array.new<float>()
var array<float> fvgBottoms = array.new<float>()
var array<bool> fvgIsBullish = array.new<bool>()
var array<bool> fvgIsActive = array.new<bool>()
var array<int> fvgStartBar = array.new<int>()

var bool hadRetestUp = false
var bool hadRetestDown = false
var int retestUpBar = na
var int retestDownBar = na
var bool wentFarEnoughUp = false
var bool wentFarEnoughDown = false
var int sessionStartBar = na
var float sessionStartTime = na

var float trendVWAP = na
var float trendEMA12 = na
var float trendEMACustom = na
var float trendSTUp = na
var float trendSTDown = na
var int trendSTDirection = 0
var float volumeMA = na

var bool htfBullish = false
var bool htfBearish = false
var string htfBiasText = ""

var float actH = na
var float actL = na
var float actM = na

var float tradeOrbHigh = na
var float tradeOrbLow = na

var bool haveRange = false
var bool haveDisplayRange = false

var int stage = 0
var float displayH = na
var float displayL = na

var line orbEntryLine = na
var label orbEntryLabel = na
var float orbEntryPrice = na
var int orbEntryBar = na
var color orbLineColor = na
var line orbSLLine = na
var label orbSLLabel = na
var float orbSLPrice = na
var line orbTP1Line = na
var label orbTP1Label = na
var float orbTP1Price = na
var line orbTP1_5Line = na
var label orbTP1_5Label = na
var float orbTP1_5Price = na
var line orbTP2Line = na
var label orbTP2Label = na
var float orbTP2Price = na
var line orbTP3Line = na
var label orbTP3Label = na
var float orbTP3Price = na
var bool orbLinesFrozen = false
var int orbTradeDirection = 0

var bool orbTP1Hit = false
var bool orbTP1_5Hit = false
var bool orbTP2Hit = false
var bool orbTP3Hit = false
var bool orbSLHit = false

var int session_wins = 0
var int session_losses = 0
var float session_total_rr = 0.0
var int session_trades = 0
var float session_best_r = 0.0
var float session_worst_r = 0.0
var bool trade_closed = false
var string last_trade_result = ""

var float current_trade_r = 0.0
var bool tp1_counted = false
var bool tp1_5_counted = false
var bool tp2_counted = false
var bool tp3_counted = false

var float maxShares = na
var float positionValue = na
var float maxLoss = na

var int prevOrbEntryBar = na

var table dashTable = na

var int prevCyclesUp = 0
var int prevCyclesDown = 0

var ORBData orb5Obj = ORBData.new(name = "ORB5",minutes = 5,high = na, low = na, mid = na, orbRange = na,isEnabled = false, isBuilding = false, isComplete = false,completionBar = 0,breakoutUp = false, breakoutDown = false,breakoutBar = 0, breakoutLevel = na,cyclesUp = 0, cyclesDown = 0,orbBox = na, highLine = na, lowLine = na, midLine = na, edgeLabel = na,orbColor = color.blue,lineWidth = 1,lineStyle = line.style_solid)
var ORBData orb15Obj = ORBData.new(name = "ORB15",minutes = 15,high = na, low = na, mid = na, orbRange = na,isEnabled = false, isBuilding = false, isComplete = false,completionBar = 0,breakoutUp = false, breakoutDown = false,breakoutBar = 0, breakoutLevel = na,cyclesUp = 0, cyclesDown = 0,orbBox = na, highLine = na, lowLine = na, midLine = na, edgeLabel = na,orbColor = color.green, lineWidth = 1,lineStyle = line.style_solid)
var ORBData orb30Obj = ORBData.new(name = "ORB30",minutes = 30,high = na, low = na, mid = na, orbRange = na,isEnabled = false,  isBuilding = false, isComplete = false,completionBar = 0,breakoutUp = false, breakoutDown = false,breakoutBar = 0, breakoutLevel = na,cyclesUp = 0, cyclesDown = 0,orbBox = na, highLine = na, lowLine = na, midLine = na, edgeLabel = na,orbColor = color.orange,  lineWidth = 1,lineStyle = line.style_solid)
var ORBData orb60Obj = ORBData.new(name = "ORB60",minutes = 60,high = na, low = na, mid = na, orbRange = na,isEnabled = false, isBuilding = false, isComplete = false,completionBar = 0,breakoutUp = false, breakoutDown = false,breakoutBar = 0, breakoutLevel = na,cyclesUp = 0, cyclesDown = 0,orbBox = na, highLine = na, lowLine = na, midLine = na, edgeLabel = na,orbColor = color.red, lineWidth = 1,lineStyle = line.style_solid)

var ORBData activeORB = na
var array<ORBData> allORBs = array.from(orb5Obj, orb15Obj, orb30Obj, orb60Obj)
var array<ORBData> cachedPrevORBs = array.new<ORBData>(4, na)
var array<ORBData> cachedNextORBs = array.new<ORBData>(4, na)
var bool orbNavigationCached = false

if barstate.isfirst
    orb5Obj.isEnabled := enableORB5Signals
    orb15Obj.isEnabled := enableORB15Signals
    orb30Obj.isEnabled := enableORB30Signals
    orb60Obj.isEnabled := enableORB60Signals

    orb5Obj.orbColor := orb5LineColor
    orb15Obj.orbColor := orb15LineColor
    orb30Obj.orbColor := orb30LineColor
    orb60Obj.orbColor := orb60LineColor

sendAlert(string message) =>
    if enableAlerts
        alert(message, alert.freq_once_per_bar_close)

hasVolumeConfirmation(volMA, mult, strongMult) =>
    if na(volMA) or volMA == 0
        true
    else
        currentVol = volume
        isStrongVolume = strongMult > 0 and currentVol >= volMA * strongMult
        isNormalVolume = currentVol >= volMA * mult
        isStrongVolume or isNormalVolume

calculateTargets(entry, sl, isBullish) =>
    float risk = math.abs(entry - sl)
    float orbWidth = actH - actL  // Current ORB width

    float riskAdjustment = entry < 1000 ? 1.0 : entry < 5000 ? 0.8 :  0.6

    float tp1_orb = isBullish ? entry + (orbWidth * 1.0) : entry - (orbWidth * 1.0)
    float tp1_5_orb = isBullish ? entry + (orbWidth * 1.5) : entry - (orbWidth * 1.5)
    float tp2_orb = isBullish ? entry + (orbWidth * 2.0) : entry - (orbWidth * 2.0)
    float tp3_orb = isBullish ? entry + (orbWidth * 3.0) : entry - (orbWidth * 3.0)

    float tp1_risk = isBullish ? entry + (risk * 1.0 * riskAdjustment) : entry - (risk * 1.0 * riskAdjustment)
    float tp1_5_risk = isBullish ? entry + (risk * 1.5 * riskAdjustment) : entry - (risk * 1.5 * riskAdjustment)
    float tp2_risk = isBullish ? entry + (risk * 2.0 * riskAdjustment) : entry - (risk * 2.0 * riskAdjustment)
    float tp3_risk = isBullish ? entry + (risk * 3.0 * riskAdjustment) : entry - (risk * 3.0 * riskAdjustment)

    float tp1 = isBullish ? math.min(tp1_orb, tp1_risk) : math.max(tp1_orb, tp1_risk)
    float tp1_5 = isBullish ? math.min(tp1_5_orb, tp1_5_risk) : math.max(tp1_5_orb, tp1_5_risk)
    float tp2 = isBullish ? math.min(tp2_orb, tp2_risk) : math.max(tp2_orb, tp2_risk)
    float tp3 = isBullish ? math.min(tp3_orb, tp3_risk) : math.max(tp3_orb, tp3_risk)

    [tp1, tp1_5, tp2, tp3]

calculateStopLoss(entry, orbHigh, orbLow, orbRange, atr, mode, isBullish) =>
    float sl = na
    float orbFraction = stopOrbFraction / 100

    float validATR = na(atr) or atr == 0 ? orbRange * 0.5 : atr

    float atrPercent = (validATR / entry) * 100

    float minStopMultiplier = syminfo.type == "crypto" ? 1.0 :      // Crypto needs wider stops
                              syminfo.type == "forex" ? 0.3 :       // Forex needs tighter stops
                              atrPercent > 5 ? 1.5 :                // Very volatile (>5% ATR)
                              atrPercent > 3 ? 1.0 :                // High volatility (3-5% ATR)  
                              atrPercent > 1.5 ? 0.7 :              // Normal volatility (1.5-3% ATR)
                              0.5                                   // Low volatility (<1.5% ATR)

    float minStopDistance = validATR * minStopMultiplier

    float absoluteMin = syminfo.type == "crypto" ? entry * 0.01 :   // 1% min for crypto
                       syminfo.type == "forex" ? entry * 0.002 :    // 0.2% min for forex
                       entry * 0.003                                // 0.3% min for stocks

    minStopDistance := math.max(minStopDistance, absoluteMin)

    if isBullish
        if mode == "ATR"
            float priceAdjust = entry < 1000 ? 1.0 :   // Standard for normal prices
                               entry < 5000 ? 0.7 :    // Reduce for high price
                               0.5                     // Further reduce for very high price
            sl := entry - (validATR * atrMultiplier * priceAdjust)
        else if mode == "ORB %"
            sl := orbLow - (orbRange * orbFraction)
        else if mode == "Swing"
            sl := ta.lowest(low, swingBars)
        else if mode == "Safer"
            float atrSL = entry - (validATR * atrMultiplier * 2)  // Wider for safer
            float swingSL = ta.lowest(low, swingBars)
            float orbSL = orbLow - (orbRange * orbFraction * 1.5)  // 150% of normal ORB fraction
            sl := math.min(swingSL, math.min(atrSL, orbSL))  // Most conservative
        else if mode == "% Based"
            sl := entry * (1 - percentBasedStop / 100)  // Simple % from entry
        else if mode == "Smart Adaptive"
            float smartMultiplier = atrPercent > 3 ? 1.5 : atrPercent > 1.5 ? 1.0 : 0.7
            float atrStop = entry - (validATR * smartMultiplier)
            float orbStop = orbLow - (orbRange * 0.3)  // 30% of ORB range

            sl := math.min(atrStop, orbStop)  // More conservative (farther from entry)
        else if mode == "Scaled ATR"
            float scaledMult = atrPercent > 5 ? 2.5 :     // Very volatile - wider stop
                              atrPercent > 3 ? 2.0 :      // High volatility
                              atrPercent > 1.5 ? 1.5 :    // Normal volatility
                              1.2                         // Low volatility - tighter stop
            sl := entry - (validATR * scaledMult)
    else
        if mode == "ATR"
            float volAdjust = atrPercent > 3 ? 1.2 : atrPercent > 1.5 ? 1.0 : 0.8
            sl := entry + (validATR * atrMultiplier * volAdjust)
        else if mode == "ORB %"
            sl := orbHigh + (orbRange * orbFraction)
        else if mode == "Swing"
            sl := ta.highest(high, swingBars)
        else if mode == "Safer"
            float atrSL = entry + (validATR * atrMultiplier * 2)
            float swingSL = ta.highest(high, swingBars)
            float orbSL = orbHigh + (orbRange * orbFraction * 1.5)
            sl := math.max(swingSL, math.max(atrSL, orbSL))
        else if mode == "% Based"
            sl := entry * (1 + percentBasedStop / 100)
        else if mode == "Smart Adaptive"

            float smartMultiplier = atrPercent > 3 ? 1.5 : atrPercent > 1.5 ? 1.0 : 0.7
            float atrStop = entry + (validATR * smartMultiplier)
            float orbStop = orbHigh + (orbRange * 0.3)
            sl := math.max(atrStop, orbStop)  // More conservative
        else if mode == "Scaled ATR"

            float scaledMult = atrPercent > 5 ? 2.5 :
                              atrPercent > 3 ? 2.0 :
                              atrPercent > 1.5 ? 1.5 :
                              1.2
            sl := entry + (validATR * scaledMult)

    sl := isBullish ? math.min(sl, entry - minStopDistance) : math.max(sl, entry + minStopDistance)

    sl

calculatePositionSize(entry, sl) =>
    float riskAmount = 0.0

    if riskMode == "% of Account"
        riskAmount := accountSize * (riskPct / 100)
    else
        riskAmount := fixedRisk

    if symbolCurrency != accountCurrency
        riskAmount := riskAmount * exchangeRate

    float riskPerShare = math.abs(entry - sl) 
    float sharesFromRisk = riskPerShare > 0 ? math.floor(riskAmount / riskPerShare) : 0
    float maxPositionValue = accountSize * (maxPositionPct / 100)

    if symbolCurrency != accountCurrency
        maxPositionValue := maxPositionValue * exchangeRate

    float maxSharesFromLimit = entry > 0 ? math.floor(maxPositionValue / entry) : 0
    float shares = math.min(sharesFromRisk, maxSharesFromLimit)
    float posValue = shares * entry
    shares := math.floor(shares)
    float maxLossCalc = shares * riskPerShare

    [shares, posValue, maxLossCalc, riskAmount]

calculateTPSplits(show1, show1_5, show2, show3) =>
    int activeCount = 0
    if show1
        activeCount += 1
    if show1_5
        activeCount += 1
    if show2
        activeCount += 1
    if show3
        activeCount += 1

    float split1 = 0.0
    float split1_5 = 0.0
    float split2 = 0.0
    float split3 = 0.0

    if activeCount == 1
        if show1
            split1 := 1.0
        else if show1_5
            split1_5 := 1.0
        else if show2
            split2 := 1.0
        else if show3
            split3 := 1.0
    else if activeCount == 2
        float half = 0.5
        if show1
            split1 := half
            if show1_5
                split1_5 := half
            else if show2
                split2 := half
            else if show3
                split3 := half
        else if show1_5
            split1_5 := half
            if show2
                split2 := half
            else if show3
                split3 := half
        else if show2
            split2 := half
            if show3
                split3 := half
        else if show3
            split3 := half
    else if activeCount >= 3
        float remaining = 0.5
        float remainder = remaining / (activeCount - 1)

        bool firstAssigned = false
        if show1
            split1 := firstAssigned ? remainder : 0.5
            firstAssigned := true
        if show1_5
            split1_5 := firstAssigned ? remainder : 0.5
            firstAssigned := true
        if show2
            split2 := firstAssigned ? remainder : 0.5
            firstAssigned := true
        if show3
            split3 := firstAssigned ? remainder : 0.5
            firstAssigned := true

    [split1, split1_5, split2, split3]

checkHTFBias() =>
    bool bullish = false
    bool bearish = false
    string biasText = ""
    float strength = 0.0

    if enableHTF
        [htfClose, htfOpen, htfMA] = request.security(syminfo.tickerid, htfTF, [close, open, ta.ema(close, htfEMA)], barmerge.gaps_off, barmerge.lookahead_off)

        if htfMethod == "Price vs MA"
            float distancePct = htfMA > 0 ? ((htfClose - htfMA) / htfMA) * 100 : 0
            strength := math.abs(distancePct)

            bool strongEnough = enableHTF ? strength >= htfMinStrength : false

            bullish := htfClose > htfMA and strongEnough
            bearish := htfClose < htfMA and strongEnough

        else if htfMethod == "Candle Direction"
            float bodySize = math.abs(htfClose - htfOpen)
            float candleRange = htfClose > 0 ? (bodySize / htfClose) * 100 : 0
            strength := candleRange

            bullish := htfClose > htfOpen
            bearish := htfClose < htfOpen

        if bullish
            biasText := strength > htfMinStrength * 2 ? "✅✅ Strong Aligned" : "✅ Aligned"
        else if bearish
            biasText := strength > htfMinStrength * 2 ? "⚠️ Strong Counter ⚠️" : "⚠️ Counter-Trend"
        else
            biasText := "➖ Neutral/Weak"

    [bullish, bearish, biasText, strength]

getBodyHigh() => math.max(open, close)
getBodyLow() => math.min(open, close)
bodyClosedAbove(level) => getBodyLow() > level
bodyClosedBelow(level) => getBodyHigh() < level

float currentTF_minutes = timeframe.in_seconds() / 60
needsConfirmation = currentTF_minutes <= 5

getBuffer(level, pct) =>
    level * (pct / 100)
priceRetestFromAbove(level, buffer) =>
    getBodyLow() < level + buffer
priceRetestFromBelow(level, buffer) =>
    getBodyHigh() > level - buffer
getLabelSize(sizeStr) =>
    sizeStr == "Tiny" ? size.tiny : sizeStr == "Small" ? size.small : sizeStr == "Normal" ? size.normal : sizeStr == "Large" ? size.large : size.huge
calcSuperTrend(atrPeriod, multiplier) =>
    atr = ta.atr(atrPeriod)
    hl2Val = hl2

    basicUpperBand = hl2Val + multiplier * atr
    basicLowerBand = hl2Val - multiplier * atr

    var float finalUpperBand = na
    var float finalLowerBand = na
    var int trendDir = 1

    finalUpperBand := na(finalUpperBand[1]) or basicUpperBand < finalUpperBand[1] or close[1] > finalUpperBand[1] ? basicUpperBand : finalUpperBand[1]
    finalLowerBand := na(finalLowerBand[1]) or basicLowerBand > finalLowerBand[1] or close[1] < finalLowerBand[1] ? basicLowerBand : finalLowerBand[1]

    trendDir := na(trendDir[1]) ? 1 : close > finalUpperBand[1] ? 1 : close < finalLowerBand[1] ? -1 : trendDir[1]

    [finalLowerBand, finalUpperBand, trendDir]

isTrendUp(mode, closePrice, vwapVal, ema12Val, emaCustomVal, stDir) =>
    switch mode
        "VWAP" => closePrice > vwapVal
        "EMA" => closePrice > ema12Val
        "Custom EMA" => closePrice > emaCustomVal
        "SuperTrend" => stDir == 1
        "VWAP+EMA" => closePrice > vwapVal and closePrice > ema12Val
        "VWAP+SuperTrend" => closePrice > vwapVal and stDir == 1
        => true

isTrendDown(mode, closePrice, vwapVal, ema12Val, emaCustomVal, stDir) =>
    switch mode
        "VWAP" => closePrice < vwapVal
        "EMA" => closePrice < ema12Val
        "Custom EMA" => closePrice < emaCustomVal
        "SuperTrend" => stDir == -1
        "VWAP+EMA" => closePrice < vwapVal and closePrice < ema12Val
        "VWAP+SuperTrend" => closePrice < vwapVal and stDir == -1
        => true

isTradingDay() =>
    bool isTrading = true

    if syminfo.type == "stock" or syminfo.type == "fund" or syminfo.type == "index" or syminfo.type == "dr" or syminfo.type == "etf" or syminfo.type == "futures"
        int currentDayOfWeek = dayofweek(timenow)

        isTrading := currentDayOfWeek >= 2 and currentDayOfWeek <= 6
    else if syminfo.type == "crypto"
        isTrading := true  // 24/7
    else if syminfo.type == "forex"
        int currentDayOfWeek = dayofweek(timenow)

        isTrading := currentDayOfWeek >= 1 and currentDayOfWeek <= 6
    else
        isTrading := true

    isTrading

isReplayMode() =>
    bool isReplay = false

    if barstate.islast
        int timeDiffMinutes = int((timenow - time_close) / 60000)

        int currentDayOfWeek = dayofweek(timenow)
        int barDayOfWeek = dayofweek(time_close)

        bool isWeekendNow = currentDayOfWeek == 7 or currentDayOfWeek == 1  // Saturday or Sunday
        bool barWasFriday = barDayOfWeek == 6  // Last bar was Friday

        if isWeekendNow and barWasFriday
            isReplay := false  // LIVE on weekend - don't show dashboard

        else if currentDayOfWeek == 2 and barDayOfWeek == 6
            isReplay := false  // LIVE on Monday pre-market

        else
            isReplay := timeDiffMinutes > 1440

    isReplay

isWithinSessionHours() =>
    bool withinHours = false

    if useNativeSession
        withinHours := inSession
    else
        bool useReplayTime = isReplayMode()
        int timeToCheck = useReplayTime ? time : timenow

        int currentDayOfWeek = dayofweek(timeToCheck)
        bool isTradingDay = syminfo.type == "stock" ? (currentDayOfWeek >= 2 and currentDayOfWeek <= 6) : true

        if not isTradingDay and syminfo.type == "stock"
            withinHours := false
        else if not na(sessionStartHour) and not na(sessionEndHour)

            int currentHour = hour(timeToCheck)
            int currentMinute = minute(timeToCheck)

            int currentMinutesFromMidnight = currentHour * 60 + currentMinute
            int sessionStartMinutes = sessionStartHour * 60 + sessionStartMinute
            int sessionEndMinutes = sessionEndHour * 60 + sessionEndMinute

            withinHours := currentMinutesFromMidnight >= sessionStartMinutes and currentMinutesFromMidnight <= sessionEndMinutes

    withinHours

getPreviousEnabledORB(ORBData currentOrb) =>
    ORBData prevOrb = na
    for orb in allORBs
        if orb.isEnabled and orb.minutes < currentOrb.minutes
            if na(prevOrb) or orb.minutes > prevOrb.minutes
                prevOrb := orb
    prevOrb

getNextEnabledORB(ORBData currentOrb) =>
    ORBData nextOrb = na
    for orb in allORBs
        if orb.isEnabled and orb.minutes > currentOrb.minutes
            if na(nextOrb) or orb.minutes < nextOrb.minutes
                nextOrb := orb
    nextOrb

cleanupLine(lineObject) =>
    if not na(lineObject)
        array.push(tpslLines, lineObject)
        if array.size(tpslLines) > MAX_LINES_TO_KEEP
            oldLine = array.shift(tpslLines)
            if not na(oldLine)
                line.delete(oldLine)

cleanupLabel(labelObject) =>
    if not na(labelObject)
        array.push(breakoutLabels, labelObject)
        if array.size(breakoutLabels) > MAX_LABELS_TO_KEEP
            oldLabel = array.shift(breakoutLabels)
            if not na(oldLabel)
                label.delete(oldLabel)

cleanupBox(boxObject) =>
    if not na(boxObject)
        array.push(orbBoxes, boxObject)
        if array.size(orbBoxes) > MAX_BOXES_TO_KEEP
            oldBox = array.shift(orbBoxes)
            if not na(oldBox)
                box.delete(oldBox)

detectBullishFVG() =>
    bool hasFVG = false
    float fvgTop = na
    float fvgBottom = na

    if bar_index >= 2
        if high[2] < low[0]
            hasFVG := true
            fvgTop := low[0]
            fvgBottom := high[2]

    [hasFVG, fvgTop, fvgBottom]

detectBearishFVG() =>
    bool hasFVG = false
    float fvgTop = na
    float fvgBottom = na

    if bar_index >= 2
        if low[2] > high[0]
            hasFVG := true
            fvgTop := low[2]
            fvgBottom := high[0]

    [hasFVG, fvgTop, fvgBottom]

hasValidFVGNearLevel(level, isBullish) =>
    bool foundFVG = false

    if array.size(fvgTops) > 0
        for i = 0 to array.size(fvgTops) - 1
            if array.get(fvgIsBullish, i) == isBullish
                fvgTop = array.get(fvgTops, i)
                fvgBottom = array.get(fvgBottoms, i)
                fvgSize = fvgTop - fvgBottom

                expandedTop = fvgTop + (fvgSize * fvgProximity)
                expandedBottom = fvgBottom - (fvgSize * fvgProximity)

                if level >= expandedBottom and level <= expandedTop
                    foundFVG := true
                    break

    foundFVG

cleanupOldFVG() =>
    while array.size(fvgBoxes) > maxFVGtoKeep
        oldBox = array.shift(fvgBoxes)
        array.shift(fvgTops)
        array.shift(fvgBottoms)
        array.shift(fvgIsBullish)
        array.shift(fvgIsActive)
        array.shift(fvgStartBar)
        if not na(oldBox)
            box.delete(oldBox)

isWithinDisplayHours() =>
    bool withinDisplay = false

    bool useReplayTime = isReplayMode()
    int timeToCheck = useReplayTime ? time : timenow

    if syminfo.type == "stock" or syminfo.type == "fund" or syminfo.type == "index" or syminfo.type == "dr" or syminfo.type == "etf" or syminfo.type == "futures"
        int currentDayOfWeek = dayofweek(timeToCheck)
        bool isTradingDay = currentDayOfWeek >= 2 and currentDayOfWeek <= 6

        if not isTradingDay
            withinDisplay := false
        else
            int currentHour = hour(timeToCheck)
            int currentMinute = minute(timeToCheck)
            int currentMinutesFromMidnight = currentHour * 60 + currentMinute

            int displayStartMinutes = 4 * 60  // 240 minutes = 04:00
            int displayEndMinutes = 20 * 60   // 1200 minutes = 20:00

            withinDisplay := currentMinutesFromMidnight >= displayStartMinutes and currentMinutesFromMidnight < displayEndMinutes
    else if syminfo.type == "crypto"
        withinDisplay := true  // 24/7 display
    else if syminfo.type == "forex"
        withinDisplay := true  // Display when forex session active
    else
        withinDisplay := true  // Default: always display

    withinDisplay

isInRegularHours() =>
    bool inRegular = false

    bool useReplayTime = isReplayMode()
    int timeToCheck = useReplayTime ? time : timenow

    if syminfo.type == "stock" or syminfo.type == "fund" or syminfo.type == "index" or syminfo.type == "dr" or syminfo.type == "etf" or syminfo.type == "futures"
        int currentDayOfWeek = dayofweek(timeToCheck)
        bool isTradingDay = currentDayOfWeek >= 2 and currentDayOfWeek <= 6

        if not isTradingDay
            inRegular := false
        else
            int currentHour = hour(timeToCheck)
            int currentMinute = minute(timeToCheck)
            int currentMinutesFromMidnight = currentHour * 60 + currentMinute

            int regularStartMinutes = 9 * 60 + 30  // Default: 09:30
            int regularEndMinutes = 16 * 60        // Default: 16:00

            if not useNativeSession and not na(sessionStartHour) and not na(sessionEndHour)
                if enableExtendedHours
                    regularStartMinutes := 9 * 60 + 30
                    regularEndMinutes := 16 * 60
                else
                    regularStartMinutes := sessionStartHour * 60 + sessionStartMinute
                    regularEndMinutes := sessionEndHour * 60 + sessionEndMinute

            inRegular := currentMinutesFromMidnight >= regularStartMinutes and currentMinutesFromMidnight <= regularEndMinutes
    else if syminfo.type == "crypto"
        inRegular := true  // Crypto is always "regular" (24/7)
    else
        inRegular := true

    inRegular

isNewSession = false
isNewDay = false

if is24_7Market
    currentDay = dayofmonth(time)
    prevDay = dayofmonth(time[1])
    isNewDay := currentDay != prevDay
    isNewSession := false
else
    isNewSession := inSession and not inSession[1]
    isNewDay := ta.change(dayofweek) != 0

shouldReset = isNewSession or isNewDay

if shouldReset

    hadSessionToday := false

    orbNavigationCached := false
    if shouldReset
        hadSessionToday := false
        orbNavigationCached := false
        wentFarEnoughUp := false
        wentFarEnoughDown := false

    for i = 0 to array.size(allORBs) - 1
        orbObj = array.get(allORBs, i)
        if orbObj.minutes == 5
            orbObj.high := high
            orbObj.low := low
            orbObj.mid := hl2
            orbObj.orbRange := 0
        else
            orbObj.high := na
            orbObj.low := na
            orbObj.mid := na
            orbObj.orbRange := 0
        orbObj.isBuilding := true
        orbObj.isComplete := false
        orbObj.completionBar := 0
        orbObj.breakoutUp := false
        orbObj.breakoutDown := false
        orbObj.breakoutBar := 0
        orbObj.breakoutLevel := na
        orbObj.cyclesUp := 0
        orbObj.cyclesDown := 0

        if not na(orbObj.orbBox)
            box.delete(orbObj.orbBox)
        if not na(orbObj.highLine)
            line.delete(orbObj.highLine)
        if not na(orbObj.lowLine)
            line.delete(orbObj.lowLine)
        if not na(orbObj.midLine)
            line.delete(orbObj.midLine)
        if not na(orbObj.edgeLabel)
            label.delete(orbObj.edgeLabel)

        orbObj.orbBox := na
        orbObj.highLine := na
        orbObj.lowLine := na
        orbObj.midLine := na
        orbObj.edgeLabel := na

    activeORB := na
    actH := na
    actL := na
    actM := na

    tradeOrbHigh := na
    tradeOrbLow := na

    tradeOrbHigh := na
    tradeOrbLow := na
    haveRange := false
    haveDisplayRange := false
    stage := 0
    displayH := na
    displayL := na
    breakUpBarIndex := 0
    breakDownBarIndex := 0

    cyclesUp := 0
    cyclesDown := 0
    retestCyclesUp := 0
    retestCyclesDown := 0
    barsOutsideAfterBreakUp := 0
    barsOutsideAfterBreakDown := 0
    wentFarEnoughUp := false
    wentFarEnoughDown := false

    sessionBreakoutsUp := 0
    sessionBreakoutsDown := 0
    sessionRetestsUp := 0
    sessionRetestsDown := 0

    session_wins := 0
    session_losses := 0
    session_total_rr := 0.0
    session_trades := 0
    session_best_r := 0.0
    session_worst_r := 0.0
    trade_closed := false
    last_trade_result := ""

    current_trade_r := 0.0
    tp1_counted := false
    tp1_5_counted := false
    tp2_counted := false
    tp3_counted := false

    prevOrbEntryBar := na

    sessionStartBar := na
    sessionStartTime := na

    cachedLineColor := na
    cachedStageName := na

    lastLabelH := na
    lastLabelL := na
    lastLabelStage := na

    if not na(labH)
        label.delete(labH)
        labH := na
    if not na(labL)
        label.delete(labL)
        labL := na

    hadBreakUp := false
    hadBreakDown := false
    breakUpBar := na
    breakDownBar := na
    shownBreakUpLabel := false
    shownBreakDownLabel := false        
    everHadBreakUp := false
    everHadBreakDown := false
    breakoutEntryPrice := na
    hadRetestUp := false
    hadRetestDown := false
    retestUpBar := na
    retestDownBar := na
    lastLabelStage := na

    pendingLongEntry := false
    pendingShortEntry := false
    pendingLongBar := na
    pendingShortBar := na

    if not na(orbEntryLine)
        line.delete(orbEntryLine)
        orbEntryLine := na
    if not na(orbEntryLabel)
        label.delete(orbEntryLabel)
        orbEntryLabel := na
    if not na(orbSLLine)
        line.delete(orbSLLine)
        orbSLLine := na
    if not na(orbSLLabel)
        label.delete(orbSLLabel)
        orbSLLabel := na
    if not na(orbTP1Line)
        line.delete(orbTP1Line)
        orbTP1Line := na
    if not na(orbTP1Label)
        label.delete(orbTP1Label)
        orbTP1Label := na
    if not na(orbTP1_5Line)
        line.delete(orbTP1_5Line)
        orbTP1_5Line := na
    if not na(orbTP1_5Label)
        label.delete(orbTP1_5Label)
        orbTP1_5Label := na
    if not na(orbTP2Line)
        line.delete(orbTP2Line)
        orbTP2Line := na
    if not na(orbTP2Label)
        label.delete(orbTP2Label)
        orbTP2Label := na
    if not na(orbTP3Line)
        line.delete(orbTP3Line)
        orbTP3Line := na
    if not na(orbTP3Label)
        label.delete(orbTP3Label)
        orbTP3Label := na

    orbEntryPrice := na
    orbEntryBar := na
    orbLineColor := na
    orbSLPrice := na
    orbTP1Price := na
    orbTP1_5Price := na
    orbTP2Price := na
    orbTP3Price := na
    orbLinesFrozen := false
    orbTP1Hit := false
    orbTP1_5Hit := false
    orbTP2Hit := false
    orbTP3Hit := false
    orbSLHit := false
    orbTradeDirection := 0

    current_trade_r := 0.0
    tp1_counted := false
    tp1_5_counted := false
    tp2_counted := false
    tp3_counted := false

    maxShares := na
    positionValue := na
    maxLoss := na

    lastDashUpdateBar := bar_index - 100

var float sessionFirstBarTime = na

if inSession and na(sessionStartTime)
    sessionStartBar := bar_index
    sessionStartTime := time
    sessionFirstBarTime := time
    hadSessionToday := true// Track session start time and bar when new session is detected
if isNewSession
    sessionStartBar := bar_index
    sessionStartTime := time
    sessionFirstBarTime := time  // Reset first bar time for new session
    hadSessionToday := true  // Mark that session started today

float minsFromOpen = -1.0

if not na(sessionFirstBarTime) and inSession
    minsFromOpen := (time - sessionFirstBarTime) / 60000   
    if minsFromOpen > 480
        minsFromOpen := 480  
    if minsFromOpen < 0
        minsFromOpen := 0

if barstate.isconfirmed or barstate.islast
    bool needATR = everHadBreakUp or everHadBreakDown or showDashboard or not na(activeORB)
    if needATR and bar_index != cachedATRBar
        cachedATR := ta.atr(atrLength)
        cachedATRBar := bar_index

    if bar_index != cachedVolumeMABar
        cachedVolumeMA := ta.sma(volume, volumeMaLength)
        cachedVolumeMABar := bar_index

currentTF_seconds = timeframe.in_seconds()
isHTF = currentTF_seconds >= 86400

if not isHTF and minsFromOpen >= 0 and (barstate.isconfirmed or barstate.islast) and inSession
    for i = 0 to array.size(allORBs) - 1
        orbObj = array.get(allORBs, i)

        if orbObj.isEnabled and orbObj.isBuilding
            if minsFromOpen > orbObj.minutes
                orbObj.isBuilding := false
                orbObj.isComplete := true
                orbObj.completionBar := bar_index

                if na(activeORB) or orbObj.minutes > activeORB.minutes
                    activeORB := orbObj
                    actH := orbObj.high
                    actL := orbObj.low
                    actM := orbObj.mid
                    haveRange := true
                    haveDisplayRange := true
                    stage := orbObj.minutes
                    displayH := orbObj.high
                    displayL := orbObj.low
                    cachedStageName := orbObj.name
                    cachedLineColor := orbObj.orbColor

            else

                if na(orbObj.high)
                    prevOrb = getPreviousEnabledORB(orbObj)
                    if not na(prevOrb) and prevOrb.isComplete
                        orbObj.high := prevOrb.high
                        orbObj.low := prevOrb.low
                        orbObj.mid := prevOrb.mid
                        orbObj.orbRange := prevOrb.orbRange

                if minsFromOpen < orbObj.minutes
                    orbObj.high := math.max(nz(orbObj.high, high), high)
                    orbObj.low := math.min(nz(orbObj.low, low), low)
                    orbObj.mid := (orbObj.high + orbObj.low) / 2
                    orbObj.orbRange := orbObj.high - orbObj.low

                    if minsFromOpen >= orbObj.minutes - 1 and not orbObj.isComplete
                        orbObj.isBuilding := false
                        orbObj.isComplete := true
                        orbObj.completionBar := bar_index

                        activeORB := orbObj

                        actH := orbObj.high
                        actL := orbObj.low
                        actM := orbObj.mid
                        haveRange := true
                        haveDisplayRange := true

                        stage := orbObj.minutes
                        displayH := orbObj.high
                        displayL := orbObj.low
                        cachedStageName := orbObj.name
                        cachedLineColor := orbObj.orbColor

if not orbNavigationCached and not isHTF
    for i = 0 to array.size(allORBs) - 1
        orbObj = array.get(allORBs, i)

        ORBData prevOrb = na
        for j = 0 to array.size(allORBs) - 1
            checkOrb = array.get(allORBs, j)
            if checkOrb.isEnabled and checkOrb.minutes < orbObj.minutes
                if na(prevOrb) or checkOrb.minutes > prevOrb.minutes
                    prevOrb := checkOrb
        array.set(cachedPrevORBs, i, prevOrb)

        ORBData nextOrb = na
        for j = 0 to array.size(allORBs) - 1
            checkOrb = array.get(allORBs, j)
            if checkOrb.isEnabled and checkOrb.minutes > orbObj.minutes
                if na(nextOrb) or checkOrb.minutes < nextOrb.minutes
                    nextOrb := checkOrb
        array.set(cachedNextORBs, i, nextOrb)

    orbNavigationCached := true

for i = 0 to array.size(allORBs) - 1
    orbObj = array.get(allORBs, i)
    if orbObj.isEnabled and orbObj.isComplete and orbObj.completionBar == bar_index
        rangeSize = orbObj.high - orbObj.low
        rangePct = (rangeSize / orbObj.low) * 100
        alertMsgStageComplete := "✅ " + orbObj.name + " COMPLETE - " + syminfo.ticker + " | Range: $" + str.tostring(orbObj.high, "#.##") + " - $" + str.tostring(orbObj.low, "#.##") + " (" + str.tostring(rangePct, "#.#") + "%)"
        sendAlert(alertMsgStageComplete)
        alertStageCompleteTriggered := true

if enableTrendFilter
    if str.contains(trendMode, "VWAP")
        trendVWAP := ta.vwap(close)

    if trendMode == "EMA" or trendMode == "VWAP+EMA"
        trendEMA12 := ta.ema(close, 12)

    if trendMode == "Custom EMA"
        trendEMACustom := ta.ema(close, customEmaLength)

    if str.contains(trendMode, "SuperTrend")
        if barstate.isnew or na(trendSTUp)
            [stLower, stUpper, stDir] = calcSuperTrend(supertrendPeriod, supertrendMult)
            trendSTUp := stLower
            trendSTDown := stUpper
            trendSTDirection := stDir

canDetectBreakout = not isHTF and enableBreakout and not na(activeORB) and barstate.isconfirmed
volumeMA := cachedVolumeMA

if pendingLongEntry and bar_index > pendingLongBar
    if enableTargets

        float activeHigh = not na(activeORB) ? activeORB.high : na
        float activeLow = not na(activeORB) ? activeORB.low : na

        if not na(activeHigh) and not na(activeLow)

            if not na(orbEntryLine)
                line.delete(orbEntryLine)
                orbEntryLine := na
            if not na(orbEntryLabel)
                label.delete(orbEntryLabel)
                orbEntryLabel := na
            if not na(orbSLLine)
                line.delete(orbSLLine)
                orbSLLine := na
            if not na(orbSLLabel)
                label.delete(orbSLLabel)
                orbSLLabel := na
            if not na(orbTP1Line)
                line.delete(orbTP1Line)
                orbTP1Line := na
            if not na(orbTP1Label)
                label.delete(orbTP1Label)
                orbTP1Label := na
            if not na(orbTP1_5Line)
                line.delete(orbTP1_5Line)
                orbTP1_5Line := na
            if not na(orbTP1_5Label)
                label.delete(orbTP1_5Label)
                orbTP1_5Label := na
            if not na(orbTP2Line)
                line.delete(orbTP2Line)
                orbTP2Line := na
            if not na(orbTP2Label)
                label.delete(orbTP2Label)
                orbTP2Label := na
            if not na(orbTP3Line)
                line.delete(orbTP3Line)
                orbTP3Line := na
            if not na(orbTP3Label)
                label.delete(orbTP3Label)
                orbTP3Label := na

            float entry = open
            float atr = cachedATR
            float sl = calculateStopLoss(entry, activeHigh, activeLow, activeHigh - activeLow, atr, stopMode, true)
            [tp1, tp1_5, tp2, tp3] = calculateTargets(entry, sl, true)

            [shares, posValue, maxLossCalc, riskAmount] = calculatePositionSize(entry, sl)

            orbEntryPrice := entry
            breakoutEntryPrice := entry  // Sync with global entry price
            orbEntryBar := bar_index
            orbLineColor := color.new(color.aqua, 0)
            orbSLPrice := sl
            orbTP1Price := tp1
            orbTP1_5Price := tp1_5
            orbTP2Price := tp2
            orbTP3Price := tp3
            orbLinesFrozen := false
            orbTP1Hit := false
            orbTP1_5Hit := false
            orbTP2Hit := false
            orbTP3Hit := false
            orbSLHit := false
            orbTradeDirection := 1

            maxShares := shares
            positionValue := posValue
            maxLoss := maxLossCalc

            orbEntryLine := line.new(orbEntryBar, orbEntryPrice, bar_index, orbEntryPrice, xloc=xloc.bar_index, extend=extend.none, color=orbLineColor, width=1, style=line.style_solid)
            cleanupLine(orbEntryLine)
            string entryText = labelFormat == "Simple" ? "ENTRY" : str.format("ENTRY: ${0}", str.tostring(orbEntryPrice, "#.##"))
            orbEntryLabel := label.new(orbEntryBar, orbEntryPrice, entryText, xloc=xloc.bar_index, style=label.style_label_left, textcolor=color.white, color=orbLineColor, size=getLabelSize(labelSize))

            if showTPSLLines
                orbSLLine := line.new(orbEntryBar, orbSLPrice, bar_index, orbSLPrice, xloc=xloc.bar_index, extend=extend.none, color=color.new(color.red, 0), width=1, style=line.style_solid)
                cleanupLine(orbSLLine)
                string slText = labelFormat == "Simple" ? "SL" : str.format("SL: ${0}", str.tostring(orbSLP

Показано первые 50% кода (символов: 129752)