A.R.E.S. — Adaptive Reversal Engine System

indicator("A.R.E.S. — Adaptive Reversal Engine System", shorttitle="A.R.E.S.", overlay=true, max_lines_count=500, max_labels_count=300, max_boxes_count=50)

type LiqLevel
    float px
    int   bi
    int   st
    int   sd
    float imp
    line  ln

G_SIG  = "01 — Signal Engine"
G_SENS = "02 — Reversal Sensitivity"
G_LIQ  = "03 — Liquidity"
G_MOM  = "04 — Momentum"
G_DIV  = "05 — Divergence"
G_VOL  = "06 — Volume"
G_REG  = "07 — Market Regime"
G_HTF  = "08 — Higher Timeframe"
G_CONF = "09 — Confirmation"
G_VIS  = "10 — Visuals"
G_DASH = "11 — Dashboard"
G_ADV  = "13 — Advanced"

preset      = input.string("Balanced", "Preset", options=["Aggressive", "Balanced", "Conservative", "Custom"], group=G_SIG, tooltip="Aggressive: more signals, lower confluence. Balanced: default. Conservative: fewer signals, higher confluence. Custom: uses the group 02 values.")
showSignals = input.bool(true, "Show BUY / SELL Signals", group=G_SIG)
compactMode = input.bool(false, "Compact Markers (B / S)", group=G_SIG)
showScore   = input.bool(false, "Show Score On Signal", group=G_SIG)

customSetup = input.float(75.0, "Custom: Setup Threshold", minval=50.0, maxval=95.0, step=1.0, group=G_SENS, tooltip="Score needed for a BUY / SELL (Custom preset only).")
customTrig  = input.float(45.0, "Custom: Min Trigger Score", minval=0.0, maxval=100.0, step=1.0, group=G_SENS)
customCool  = input.int(6, "Custom: Cooldown Bars", minval=0, group=G_SENS)
watchMin    = input.float(65.0, "Quality: Watch From", minval=0.0, maxval=100.0, group=G_SENS)
validMin    = input.float(72.0, "Quality: Valid From", minval=0.0, maxval=100.0, group=G_SENS)
strongMin   = input.float(80.0, "Quality: Strong From", minval=0.0, maxval=100.0, group=G_SENS)
extremeMin  = input.float(90.0, "Quality: Extreme From", minval=0.0, maxval=100.0, group=G_SENS)
armBand     = input.float(10.0, "Arm Band Below Setup", minval=0.0, maxval=30.0, step=1.0, group=G_SENS, tooltip="A setup becomes ARMED when the score enters this band below the signal threshold.")
maxSetupAge = input.int(12, "Max Setup Age (bars)", minval=2, group=G_SENS)
setupDecay  = input.float(1.5, "Setup Decay (pts per bar)", minval=0.0, maxval=5.0, step=0.1, group=G_SENS)
scoreCurve  = input.float(1.8, "Score Sharpness", minval=1.0, maxval=3.0, step=0.1, group=G_SENS, tooltip="Calibration curve applied to the weighted confluence average. Higher values require more simultaneous evidence.")
wStretch    = input.float(15.0, "Weight: Stretch", minval=0.0, group=G_SENS)
wLiq        = input.float(20.0, "Weight: Liquidity", minval=0.0, group=G_SENS)
wRej        = input.float(15.0, "Weight: Rejection", minval=0.0, group=G_SENS)
wExh        = input.float(15.0, "Weight: Exhaustion", minval=0.0, group=G_SENS)
wStr        = input.float(10.0, "Weight: Structure", minval=0.0, group=G_SENS)
wVol        = input.float(7.5, "Weight: Volume", minval=0.0, group=G_SENS, tooltip="Redistributed automatically when volume data is missing.")
wHtf        = input.float(7.5, "Weight: HTF Context", minval=0.0, group=G_SENS, tooltip="Redistributed automatically when HTF context is disabled.")

pivLeft   = input.int(5, "Swing Left Bars", minval=2, group=G_LIQ)
pivRight  = input.int(3, "Swing Right Bars", minval=1, group=G_LIQ, tooltip="Bars that must close before a swing is confirmed. Only confirmed swings are used.")
rollLen   = input.int(40, "Rolling Liquidity Lookback", minval=5, group=G_LIQ)
eqTol     = input.float(0.25, "Equal Level Tolerance (ATR)", minval=0.05, maxval=1.0, step=0.05, group=G_LIQ)
sweepMem  = input.int(6, "Sweep Memory (bars)", minval=1, group=G_LIQ)
maxLiqLns = input.int(8, "Max Active Liquidity Lines", minval=2, maxval=30, group=G_LIQ, tooltip="Lowest-importance levels are removed first.")
liqMaxAge = input.int(300, "Max Liquidity Line Age (bars)", minval=20, group=G_LIQ)

momLen    = input.int(14, "RSI Length", minval=2, group=G_MOM)
velSmooth = input.int(3, "Velocity Smoothing", minval=1, group=G_MOM)
exhLook   = input.int(6, "Exhaustion Lookback", minval=2, group=G_MOM)

useDiv    = input.bool(true, "Use Divergence", group=G_DIV)
divW      = input.float(10.0, "Divergence Weight", minval=0.0, group=G_DIV)
divLeft   = input.int(3, "Divergence Pivot Left", minval=1, group=G_DIV)
divRight  = input.int(3, "Divergence Pivot Right", minval=1, group=G_DIV, tooltip="Confirmation delay. The divergence is marked on the bar where the second pivot becomes confirmed.")
divMaxGap = input.int(60, "Max Bars Between Pivots", minval=5, group=G_DIV)

useVol    = input.bool(true, "Use Volume Engine", group=G_VOL)
volLen    = input.int(20, "Volume Baseline Length", minval=5, group=G_VOL)

useAdapt  = input.bool(true, "Auto Adaptive Weights", group=G_REG, tooltip="Re-weights the engines according to the detected market regime.")
adxLen    = input.int(14, "Trend Strength Length", minval=5, group=G_REG)
erLen     = input.int(10, "Efficiency Ratio Length", minval=3, group=G_REG)
atrPctLen = input.int(100, "ATR Percentile Lookback", minval=20, group=G_REG)

useHtf    = input.bool(false, "Enable HTF Context", group=G_HTF, tooltip="HTF is a context filter only. It never produces BUY or SELL by itself.")
htfInput  = input.timeframe("240", "HTF Timeframe", group=G_HTF)

confWin   = input.int(3, "Trigger Window (bars)", minval=1, maxval=10, group=G_CONF)
adaptConf = input.bool(true, "Adaptive Confirmation", group=G_CONF, tooltip="Range: faster confirmation. Trend: stricter confirmation.")
structMin = input.float(35.0, "Min Structure Score", minval=0.0, maxval=100.0, group=G_CONF)
minSame   = input.int(8, "Min Bars Between Same Signals", minval=0, group=G_CONF)

visMode   = input.string("Balanced", "Visual Mode", options=["Minimal", "Balanced", "Advanced"], group=G_VIS, tooltip="Minimal: signals and dashboard only. Balanced: default. Advanced: adds the optional sequence markers.")
showLiq   = input.bool(true, "Liquidity Lines", group=G_VIS)
showStr   = input.bool(true, "Structure Lines", group=G_VIS)
showZone  = input.bool(true, "Reversal Zones", group=G_VIS)
showDivL  = input.bool(true, "Divergence Lines", group=G_VIS)
showSeq   = input.bool(false, "Advanced Sequence", group=G_VIS, tooltip="Writes a small stage-status label when a setup arms.")
showEq    = input.bool(false, "Equilibrium Line", group=G_VIS)
showInval = input.bool(false, "Show Invalidation Level", group=G_VIS)
invalLen  = input.int(20, "Invalidation / Projection Length (bars)", minval=5, group=G_VIS)
atrBuf    = input.float(0.4, "Marker ATR Buffer", minval=0.0, maxval=3.0, step=0.1, group=G_VIS)
smartBars = input.bool(true, "Enable Smart Bar Colors", group=G_VIS)
showProj  = input.bool(false, "Show Mean Projection (not a target)", group=G_VIS)

dashMode  = input.string("Minimal", "Dashboard Mode", options=["Off", "Minimal", "Detailed"], group=G_DASH)

debugOn   = input.bool(false, "Developer / Debug Mode", group=G_ADV, tooltip="Exposes engine values in the Data Window.")

bullC  = color.rgb(34, 211, 166)     // emerald-aqua
bearC  = color.rgb(255, 99, 120)     // coral-red
neuC   = color.rgb(148, 163, 184)    // slate
txtC   = color.rgb(226, 232, 240)    // near-white text
panelC = color.rgb(15, 23, 42)       // deep slate panel

f_clamp01(float x) => math.max(0.0, math.min(1.0, nz(x)))
f_clampS(float x, float lo, float hi) => math.max(lo, math.min(hi, nz(x)))
f_safeDiv(float a, float b) => nz(b) == 0.0 ? 0.0 : nz(a) / b
f_b(bool c) => c ? 1.0 : 0.0
f_i(float x) => str.tostring(math.round(x))

f_row(table t, int r, string k, string v, color bgc, color tc) =>
    table.cell(t, 0, r, k, text_color=tc, bgcolor=bgc, text_size=size.small, text_halign=text.align_left)
    table.cell(t, 1, r, v, text_color=tc, bgcolor=bgc, text_size=size.small, text_halign=text.align_right)
    r

f_trimLines(array<line> arr, int maxN) =>
    while array.size(arr) > maxN
        line.delete(array.shift(arr))
    array.size(arr)

f_trimLabels(array<label> arr, int maxN) =>
    while array.size(arr) > maxN
        label.delete(array.shift(arr))
    array.size(arr)

f_findLiq(array<LiqLevel> arr, int sdv, float px, float tol) =>
    int found = -1
    if array.size(arr) > 0
        for i = 0 to array.size(arr) - 1
            LiqLevel lv = array.get(arr, i)
            if found == -1 and lv.sd == sdv and lv.st == 0 and math.abs(lv.px - px) <= tol
                found := i
    found

f_pruneLiq(array<LiqLevel> arr, int maxN, int maxAge) =>
    int i = 0
    while i < array.size(arr)
        LiqLevel lv = array.get(arr, i)
        if bar_index - lv.bi > maxAge
            line.delete(lv.ln)
            array.remove(arr, i)
        else
            i += 1
    while array.size(arr) > maxN
        int worst = 0
        float worstImp = 1.0e9
        for j = 0 to array.size(arr) - 1
            LiqLevel c = array.get(arr, j)
            if c.imp < worstImp
                worstImp := c.imp
                worst := j
        LiqLevel old = array.remove(arr, worst)
        line.delete(old.ln)
    array.size(arr)

var float lastSwH    = na
var float lastSwL    = na
var float intSwH     = na
var float intSwL     = na
var int   intSwHBar  = na
var int   intSwLBar  = na
var int   eqlSBar    = na
var int   eqlBBar    = na

var int   swpBBar    = na
var float swpBLvl    = na
var float swpBLow    = na
var float swpBQ      = 0.0
var int   swpSBar    = na
var float swpSLvl    = na
var float swpSHigh   = na
var float swpSQ      = 0.0

var int   strBBar    = na
var float strBLvl    = na
var int   strBFrom   = na
var int   strSBar    = na
var float strSLvl    = na
var int   strSFrom   = na

var float pLowPx     = na
var float pLowOsc    = na
var int   pLowBar    = na
var float pHighPx    = na
var float pHighOsc   = na
var int   pHighBar   = na
var int   divBBar    = na
var float divBSc     = 0.0
var int   divBFrom   = na
var float divBFromPx = na
var int   divBTo     = na
var float divBToPx   = na
var int   divSBar    = na
var float divSSc     = 0.0
var int   divSFrom   = na
var float divSFromPx = na
var int   divSTo     = na
var float divSToPx   = na

var int   trgBLast   = na
var float trgBPk     = 0.0
var int   trgSLast   = na
var float trgSPk     = 0.0

var int   stateL     = 0      // 0 NEUTRAL · 1 ARMED · 3 COOLDOWN
var int   stateS     = 0
var int   armL       = na
var int   armS       = na
var float peakL      = 0.0
var float peakS      = 0.0
var int   coolL      = 0
var int   coolS      = 0
var int   lastBuy    = na
var int   lastSell   = na
var float sigScore   = 0.0
var bool  buySig     = false
var bool  sellSig    = false

var array<LiqLevel> liqArr = array.new<LiqLevel>()
var array<line>     strLn  = array.new<line>()
var array<line>     divLn  = array.new<line>()
var array<line>     auxLn  = array.new<line>()
var array<label>    lblArr = array.new<label>()
var box   zoneB      = na
var box   zoneS      = na
var table dash       = table.new(position.top_right, 2, 12, bgcolor=color.new(panelC, 10), frame_color=color.new(neuC, 60), frame_width=1, border_color=color.new(neuC, 80), border_width=1)

atr     = ta.atr(14)
atrS    = math.max(atr, syminfo.mintick)
ema34   = ta.ema(close, 34)
sd50    = math.max(ta.stdev(close, 50), syminfo.mintick)
zSc     = (close - ema34) / sd50
atrDev  = (close - ema34) / atrS
rng     = math.max(high - low, syminfo.mintick)
bodyHi  = math.max(open, close)
bodyLo  = math.min(open, close)
lowWkR  = (bodyLo - low) / rng
upWkR   = (high - bodyHi) / rng
clvBull = ((close - low) - (high - close)) / rng    // close location value, [-1, 1]
clvB    = (clvBull + 1.0) / 2.0                     // 1 = closed at the high
clvS    = 1.0 - clvB
bodyATR = (close - open) / atrS                     // signed displacement in ATR

isAgg      = preset == "Aggressive"
isCons     = preset == "Conservative"
isCust     = preset == "Custom"
setupThr   = isCust ? customSetup : isAgg ? 70.0 : isCons ? 80.0 : 75.0
trigBase   = isCust ? customTrig : isAgg ? 35.0 : isCons ? 55.0 : 45.0
cdBase     = isCust ? customCool : isAgg ? 3 : isCons ? 12 : 6
cdN        = cdBase > minSame ? cdBase : minSame
coreReq    = isAgg ? 0.25 : isCons ? 0.50 : 0.35
structNeed = isCons ? 50.0 : isAgg ? 25.0 : structMin
winPreset  = isAgg ? 4 : isCons ? 2 : confWin
armedThr   = setupThr - armBand

swH     = ta.pivothigh(high, pivLeft, pivRight)
swL     = ta.pivotlow(low, pivLeft, pivRight)
swBar   = bar_index - pivRight
rollHi  = ta.highest(high, rollLen)[1]
rollLo  = ta.lowest(low, rollLen)[1]
refLo   = na(lastSwL[1]) ? rollLo : lastSwL[1]
refHi   = na(lastSwH[1]) ? rollHi : lastSwH[1]

bullSwp = not na(refLo) and low < refLo and close > refLo
bearSwp = not na(refHi) and high > refHi and close < refHi
penL    = f_clamp01((refLo - low) / (atrS * 0.5))
recL    = f_clamp01((close - refLo) / (atrS * 0.4))
sweepQB = 0.45 * penL + 0.35 * recL + 0.20 * (0.5 * clvB + 0.5 * lowWkR)
penH    = f_clamp01((high - refHi) / (atrS * 0.5))
recH    = f_clamp01((refHi - close) / (atrS * 0.4))
sweepQS = 0.45 * penH + 0.35 * recH + 0.20 * (0.5 * clvS + 0.5 * upWkR)

rsiV  = ta.rsi(close, momLen)
retN  = (close - close[1]) / atrS
vel   = ta.ema(retN, velSmooth)
dVel  = vel - vel[1]
dAcc  = dVel - dVel[1]
pushD = math.max(0.0, -vel)
pushU = math.max(0.0, vel)
peakD = ta.highest(pushD, exhLook)
peakU = ta.highest(pushU, exhLook)
rsiSl = rsiV - rsiV[3]
decB  = peakD > 0.0 ? f_clamp01((peakD - pushD) / peakD) : 0.0
decS  = peakU > 0.0 ? f_clamp01((peakU - pushU) / peakU) : 0.0
exhB  = 0.45 * decB + 0.25 * f_clamp01(dVel / 0.2) + 0.20 * f_clamp01(dAcc / 0.15) + 0.10 * f_clamp01(rsiSl / 8.0)
exhS  = 0.45 * decS + 0.25 * f_clamp01(-dVel / 0.2) + 0.20 * f_clamp01(-dAcc / 0.15) + 0.10 * f_clamp01(-rsiSl / 8.0)

iH    = ta.pivothigh(high, 2, 2)
iL    = ta.pivotlow(low, 2, 2)
oscD  = 0.5 * ((rsiV - 50.0) / 50.0) + 0.5 * math.max(-1.0, math.min(1.0, nz(vel)))
pvL   = ta.pivotlow(low, divLeft, divRight)
pvH   = ta.pivothigh(high, divLeft, divRight)
oscPL = oscD[divRight]
oscPH = oscD[divRight]

stretchB = 0.6 * f_clamp01(-zSc / 2.5) + 0.4 * f_clamp01(-atrDev / 3.0)
stretchS = 0.6 * f_clamp01(zSc / 2.5) + 0.4 * f_clamp01(atrDev / 3.0)

rejBr = f_clamp01(0.5 * f_clamp01(lowWkR / 0.6) + 0.3 * clvB + 0.2 * f_clamp01((bodyLo - low) / atrS / 0.8))
rejSr = f_clamp01(0.5 * f_clamp01(upWkR / 0.6) + 0.3 * clvS + 0.2 * f_clamp01((high - bodyHi) / atrS / 0.8))

if barstate.isconfirmed

    if not na(swL) and not na(lastSwL) and math.abs(swL - lastSwL) <= eqTol * atrS
        eqlBBar := bar_index
    if not na(swH) and not na(lastSwH) and math.abs(swH - lastSwH) <= eqTol * atrS
        eqlSBar := bar_index

    if bullSwp
        swpBBar := bar_index
        swpBLvl := refLo
        swpBLow := low
        swpBQ   := sweepQB
    if bearSwp
        swpSBar  := bar_index
        swpSLvl  := refHi
        swpSHigh := high
        swpSQ    := sweepQS

    if not na(swL)
        lastSwL := swL
    if not na(swH)
        lastSwH := swH

    if not na(intSwH) and close > intSwH and close[1] <= intSwH
        strBBar  := bar_index
        strBLvl  := intSwH
        strBFrom := intSwHBar
    if not na(intSwL) and close < intSwL and close[1] >= intSwL
        strSBar  := bar_index
        strSLvl  := intSwL
        strSFrom := intSwLBar
    if not na(iH)
        intSwH    := iH
        intSwHBar := bar_index - 2
    if not na(iL)
        intSwL    := iL
        intSwLBar := bar_index - 2

    if not na(pvL)
        pbL = bar_index - divRight
        if not na(pLowPx) and pbL - pLowBar <= divMaxGap and pvL < pLowPx and oscPL > pLowOsc
            divBSc   := f_clamp01((oscPL - pLowOsc) / 0.5)
            divBBar  := bar_index
            divBFrom := pLowBar
            divBFromPx := pLowPx
            divBTo   := pbL
            divBToPx := pvL
        pLowPx  := pvL
        pLowOsc := oscPL
        pLowBar := pbL

    if not na(pvH)
        pbH = bar_index - divRight
        if not na(pHighPx) and pbH - pHighBar <= divMaxGap and pvH > pHighPx and oscPH < pHighOsc
            divSSc     := f_clamp01((pHighOsc - oscPH) / 0.5)
            divSBar    := bar_index
            divSFrom   := pHighBar
            divSFromPx := pHighPx
            divSTo     := pbH
            divSToPx   := pvH
        pHighPx  := pvH
        pHighOsc := oscPH
        pHighBar := pbH

bsAge   = na(swpBBar) ? 999 : bar_index - swpBBar
ssAge   = na(swpSBar) ? 999 : bar_index - swpSBar
bsAct   = bsAge <= sweepMem
ssAct   = ssAge <= sweepMem
eqlBRec = not na(eqlBBar) and bar_index - eqlBBar <= 5
eqlSRec = not na(eqlSBar) and bar_index - eqlSBar <= 5

liqB = bsAct ? f_clamp01(swpBQ * (1.0 - bsAge / (sweepMem + 1.0)) + (eqlBRec ? 0.10 : 0.0)) : 0.0
liqS = ssAct ? f_clamp01(swpSQ * (1.0 - ssAge / (sweepMem + 1.0)) + (eqlSRec ? 0.10 : 0.0)) : 0.0

rejB = rejBr * (bsAct ? 1.0 : 0.75)
rejS = rejSr * (ssAct ? 1.0 : 0.75)

strBAge = na(strBBar) ? 999 : bar_index - strBBar
strSAge = na(strSBar) ? 999 : bar_index - strSBar
strBOk  = not na(strBLvl) and close > strBLvl
strSOk  = not na(strSLvl) and close < strSLvl
structB = f_clamp01(f_clamp01(1.0 - strBAge / 8.0) * (bsAct ? 1.0 : 0.7) + (strBOk ? 0.2 : 0.0))
structS = f_clamp01(f_clamp01(1.0 - strSAge / 8.0) * (ssAct ? 1.0 : 0.7) + (strSOk ? 0.2 : 0.0))

divBNow = na(divBBar) ? 0.0 : divBSc * f_clamp01(1.0 - (bar_index - divBBar) / 30.0)
divSNow = na(divSBar) ? 0.0 : divSSc * f_clamp01(1.0 - (bar_index - divSBar) / 30.0)
divB    = useDiv ? divBNow : 0.0
divS    = useDiv ? divSNow : 0.0

trigB = 100.0 * (0.20 * f_b(close > high[1]) + 0.20 * f_b(dVel > 0.0) + 0.20 * f_clamp01(bodyATR / 0.6) + 0.20 * f_b(strBAge <= 3) + 0.20 * f_b(bsAct and close > swpBLvl))
trigS = 100.0 * (0.20 * f_b(close < low[1]) + 0.20 * f_b(dVel < 0.0) + 0.20 * f_clamp01(-bodyATR / 0.6) + 0.20 * f_b(strSAge <= 3) + 0.20 * f_b(ssAct and close < swpSLvl))

volAvg = ta.sma(volume, volLen)
volSd  = ta.stdev(volume, volLen)
volOk  = useVol and volAvg > 0.0
volZ   = f_safeDiv(volume - volAvg, volSd)
volAbn = f_clamp01(volZ / 3.0)
volB   = volOk ? volAbn * f_clamp01(0.5 * rejB + 0.5 * clvB) * (zSc < 0.0 ? 1.0 : 0.5) : 0.0
volS   = volOk ? volAbn * f_clamp01(0.5 * rejS + 0.5 * clvS) * (zSc > 0.0 ? 1.0 : 0.5) : 0.0

htfSel   = useHtf ? htfInput : timeframe.period
emaH     = ta.ema(close, 50)
slopeH0  = (emaH - emaH[3]) / atrS
eqH0     = (close - emaH) / atrS
momH0    = (close - close[5]) / atrS
[slopeH, eqH, momH] = request.security(syminfo.tickerid, htfSel, [slopeH0[1], eqH0[1], momH0[1]], lookahead=barmerge.lookahead_on)
hTrend   = f_clampS(slopeH / 0.5, -1.0, 1.0)
hEqN     = f_clampS(eqH / 2.0, -1.0, 1.0)
hMomN    = f_clampS(momH / 2.0, -1.0, 1.0)

hBullCtx = f_clamp01(0.5 - 0.25 * hEqN + 0.15 * hTrend + 0.10 * hMomN)
hBearCtx = f_clamp01(0.5 + 0.25 * hEqN - 0.15 * hTrend - 0.10 * hMomN)

[diP, diM, adxV] = ta.dmi(adxLen, adxLen)
trendStr = f_clamp01(nz(adxV) / 40.0)
ema50    = ta.ema(clo

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