Adaptive Support Resistance

indicator("Adaptive Support Resistance", "ASR", overlay = true, max_boxes_count = 300, max_lines_count = 300, max_labels_count = 300, max_bars_back = 500)

gDet = "=====  ADAPTIVE DETECTION  ====="
minSwing = input.int(3,  "Minimum Swing Bars", minval = 2, maxval = 20, group = gDet, tooltip = "Used when volatility is high. Turns resolve fast, so fewer bars of confirmation are needed.")
maxSwing = input.int(10, "Maximum Swing Bars", minval = 3, maxval = 30, group = gDet, tooltip = "Used when volatility is low. Drift produces false turns, so more bars of confirmation are needed.")
volFast  = input.int(10, "Volatility Fast ATR", minval = 2, maxval = 100, group = gDet)
volSlow  = input.int(50, "Volatility Slow ATR", minval = 5, maxval = 300, group = gDet)
atrLen   = input.int(14, "Scoring ATR Length",  minval = 2, maxval = 200, group = gDet)

gPow = "=====  LEVEL POWER MODEL  ====="
minPower   = input.float(4.0,  "Minimum Power To Display", minval = 0, maxval = 10, step = 0.5, group = gPow, tooltip = "Levels below this are tracked internally but not drawn. Raise it to keep only the strongest structure.")
wImpulse   = input.float(0.45, "Weight - Displacement Impulse", minval = 0, maxval = 1, step = 0.05, group = gPow)
wPartic    = input.float(0.30, "Weight - Participation",        minval = 0, maxval = 1, step = 0.05, group = gPow)
wReject    = input.float(0.25, "Weight - Rejection Quality",    minval = 0, maxval = 1, step = 0.05, group = gPow)
impNorm    = input.float(3.0,  "Impulse Saturation (x ATR)",       minval = 0.5, maxval = 15, step = 0.5, group = gPow)
partNorm   = input.float(2.5,  "Participation Saturation (x Avg)", minval = 1,   maxval = 10, step = 0.5, group = gPow)
recentBars = input.int(50,     "Full Weight Window (bars)", minval = 5, maxval = 500, group = gPow)
decayFloor = input.float(0.50, "Recency Decay Floor", minval = 0.1, maxval = 1, step = 0.05, group = gPow)
decaySpan  = input.int(200,    "Decay Span (bars)", minval = 20, maxval = 2000, group = gPow)
touchBonus = input.float(0.10, "Bonus Per Confirming Touch", minval = 0, maxval = 0.5, step = 0.01, group = gPow)
maxTouchB  = input.float(0.50, "Maximum Touch Bonus", minval = 0, maxval = 2, step = 0.05, group = gPow)
conflBonus = input.float(0.25, "Higher-Timeframe Confluence Bonus", minval = 0, maxval = 1, step = 0.05, group = gPow)

gLvl = "=====  LEVEL MANAGEMENT  ====="
mergeATR   = input.float(0.50, "Merge Distance (x ATR)", minval = 0.05, maxval = 3, step = 0.05, group = gLvl, tooltip = "New swings within this distance of an existing level merge into it as a confirming touch.")
maxPerSide = input.int(10, "Max Levels Per Side", minval = 1, maxval = 40, group = gLvl)
breakBuf   = input.float(0.25, "Break Buffer (x ATR)", minval = 0.0, maxval = 3, step = 0.05, group = gLvl, tooltip = "How far beyond a level price must close before that level counts as resolved.")
flipOn     = input.bool(true, "Enable Role Reversal", group = gLvl, tooltip = "ON  : a broken resistance becomes support and a broken support becomes resistance, drawn in the flip colour.\nOFF : broken levels are retired from the chart.")
maxFlips   = input.int(2, "Max Flips Per Level", minval = 1, maxval = 6, group = gLvl, tooltip = "After this many role reversals the level is retired.")

gZone = "=====  ZONES  ====="
zoneOn    = input.bool(true, "Draw Levels As Zones", group = gZone)
zoneATR   = input.float(0.30, "Zone Half-Height (x ATR)", minval = 0.05, maxval = 2, step = 0.05, group = gZone, tooltip = "The zone scales with volatility, so it stays proportionate on every instrument and timeframe.")
zoneCentre= input.bool(true, "Show Zone Centre Line", group = gZone)
zoneExt   = input.int(20, "Zone Extension (bars)", minval = 0, maxval = 200, group = gZone)

gMtf = "=====  HIGHER-TIMEFRAME CONFLUENCE  ====="
mtfOn    = input.bool(true, "Enable Higher-Timeframe Levels", group = gMtf)
mtfTf    = input.timeframe("60", "Higher Timeframe", group = gMtf)
mtfLeft  = input.int(6, "HTF Pivot Left",  minval = 2, maxval = 30, group = gMtf, inline = "m")
mtfRight = input.int(6, "HTF Pivot Right", minval = 2, maxval = 30, group = gMtf, inline = "m")
mtfMax   = input.int(6, "Max HTF Levels Per Side", minval = 1, maxval = 20, group = gMtf)
conflATR = input.float(0.60, "Confluence Distance (x ATR)", minval = 0.05, maxval = 3, step = 0.05, group = gMtf)
mtfDraw  = input.bool(true, "Draw HTF Levels On Chart", group = gMtf)

gRnd = "=====  PSYCHOLOGICAL ROUND NUMBERS  ====="
roundOn   = input.bool(true, "Show Round Number Levels", group = gRnd)
roundAuto = input.bool(true, "Automatic Step", group = gRnd, tooltip = "Derives a sensible increment from the instrument's price magnitude and its ATR. Turn off to set the step manually.")
roundStepM= input.float(10.0, "Manual Step", minval = 0.00001, group = gRnd)
roundMult = input.float(8.0, "Auto Step Target (x ATR)", minval = 1, maxval = 60, step = 0.5, group = gRnd)
roundSpan = input.float(6.0, "Show Within (x ATR)", minval = 1, maxval = 40, step = 0.5, group = gRnd)

gStat = "=====  HOLD-RATE STATISTICS  ====="
statsOn   = input.bool(true, "Track Hold Rate By Power Tier", group = gStat, tooltip = "Records what actually happened each time price entered a level's zone on the loaded history. Observed record, not a projection.")
holdATR   = input.float(1.0, "Hold Confirmed At (x ATR)", minval = 0.2, maxval = 6, step = 0.1, group = gStat, tooltip = "How far price must travel back away from a zone before the test counts as held.")

gProx = "=====  PROXIMITY CLASSIFICATION  ====="
immATR = input.float(0.75, "Immediate Within (x ATR)",   minval = 0.1, maxval = 5,  step = 0.05, group = gProx)
stATR  = input.float(2.50, "Short-Term Within (x ATR)",  minval = 0.5, maxval = 15, step = 0.25, group = gProx)
mtATR  = input.float(6.00, "Medium-Term Within (x ATR)", minval = 1.0, maxval = 40, step = 0.5,  group = gProx)

gPres = "=====  PRESSURE METER  ====="
presSmooth = input.bool(true, "Smooth Pressure", group = gPres, tooltip = "ON averages the closing-position reading over several bars. A single candle is a thin sample, so smoothing is recommended.")
presLen    = input.int(5, "Smoothing Length", minval = 1, maxval = 50, group = gPres)

gAlr = "=====  ALERTS  ====="
alertPower = input.float(7.0, "Approach Alert Minimum Power", minval = 0, maxval = 10, step = 0.5, group = gAlr)
approachATR= input.float(0.50, "Approach Distance (x ATR)", minval = 0.05, maxval = 5, step = 0.05, group = gAlr)

gAct = "=====  ACTIVITY SOURCE  ====="
actMode = input.string("Auto", "Participation Source", options = ["Auto", "Chart Volume Only", "External Symbol", "Synthetic Estimate"], group = gAct)
extSym  = input.symbol("", "External Volume Symbol", group = gAct)

gVis = "=====  VISUALS  ====="
showLabels = input.bool(true, "Show Level Labels", group = gVis)
showPct    = input.bool(true, "Show Percent Distance", group = gVis)
showPowTxt = input.bool(true, "Show Power Rating", group = gVis)
lblSize    = input.string("Tiny", "Label Size", options = ["Tiny", "Small", "Normal"], group = gVis)
showTable  = input.bool(true, "Show Summary Table", group = gVis)
tablePos   = input.string("Top Right", "Table Position", options = ["Top Right", "Middle Right", "Bottom Right", "Top Left", "Bottom Left"], group = gVis)

gSty = "=====  STYLE  ====="
colRes   = input.color(#f6465d, "Resistance", group = gSty, inline = "a")
colSup   = input.color(#26e2a8, "Support",    group = gSty, inline = "a")
colFlipR = input.color(#ff9800, "Flipped To Resistance", group = gSty, inline = "b")
colFlipS = input.color(#00bcd4, "Flipped To Support",    group = gSty, inline = "b")
colMtf   = input.color(#b388ff, "HTF Level",     group = gSty, inline = "c")
colRound = input.color(#9e9e9e, "Round Number",  group = gSty, inline = "c")
colTxt   = input.color(color.white, "Label Text", group = gSty)
colTblBg = input.color(#0b1020, "Table Background", group = gSty, inline = "d")
colTblTx = input.color(#d1d4dc, "Table Text",       group = gSty, inline = "d")
colAcc   = input.color(#f0b90b, "Accent", group = gSty)

string szL = lblSize == "Small" ? size.small : lblSize == "Normal" ? size.normal : size.tiny

float  rawVol  = nz(volume)
bool   hasReal = ta.cum(rawVol) > 0 and not na(volume)
string reqSym  = extSym == "" ? syminfo.tickerid : extSym
float  extRaw  = request.security(reqSym, timeframe.period, volume, ignore_invalid_symbol = true)
float  extVol  = nz(extRaw)
bool   hasExt  = extSym != "" and ta.cum(extVol) > 0

float trueR   = ta.tr(true)
float baseATR = ta.atr(20)
float bodyEff = trueR > 0 ? math.abs(close - open) / trueR : 0.0
float synth   = baseATR > 0 ? math.max(0.0, (trueR / baseATR) * (0.55 + 0.45 * bodyEff) * 1000.0) : 0.0

string actName = "Synthetic"
float  actVol  = synth
if actMode == "Chart Volume Only"
    actVol  := rawVol
    actName := hasReal ? "Real" : "None"
else if actMode == "External Symbol"
    actVol  := extVol
    actName := hasExt ? "External" : "None"
else if actMode == "Synthetic Estimate"
    actVol  := synth
    actName := "Synthetic"
else
    if hasReal
        actVol  := rawVol
        actName := "Real"
    else if hasExt
        actVol  := extVol
        actName := "External"
    else
        actVol  := synth
        actName := "Synthetic"

float actAvg = ta.sma(actVol, 20)

float atrS     = ta.atr(atrLen)
float aFast    = ta.atr(volFast)
float aSlow    = ta.atr(volSlow)
float volRatio = aSlow > 0 ? aFast / aSlow : 1.0
float volRank  = nz(ta.percentrank(volRatio, 100), 50.0)
int   hiSw     = math.max(minSwing, maxSwing)
int   swingLen = math.max(minSwing, math.min(hiSw, int(math.round(hiSw - (hiSw - minSwing) * volRank / 100.0))))

isPivot(int len, bool isRes) =>
    float c  = isRes ? high[len] : low[len]
    bool  ok = not na(c)
    if ok
        for i = 1 to hiSw
            if i <= len
                float lft = isRes ? high[len + i] : low[len + i]
                float rgt = isRes ? high[len - i] : low[len - i]
                if na(lft) or na(rgt)
                    ok := false
                else if isRes
                    if lft > c or rgt >= c
                        ok := false
                else
                    if lft < c or rgt <= c
                        ok := false
    ok

basePower(int len, bool isRes) =>
    float a  = nz(atrS[len])
    float px = isRes ? high[len] : low[len]

    float extL = na
    float extR = na
    for i = 1 to hiSw
        if i <= len
            float vL = isRes ? low[len + i] : high[len + i]
            float vR = isRes ? low[len - i] : high[len - i]
            extL := na(extL) ? vL : (isRes ? math.min(extL, vL) : math.max(extL, vL))
            extR := na(extR) ? vR : (isRes ? math.min(extR, vR) : math.max(extR, vR))
    float approach = isRes ? px - nz(extL, px) : nz(extL, px) - px
    float depart   = isRes ? px - nz(extR, px) : nz(extR, px) - px
    float impulse  = a > 0 ? math.max(math.max(approach, depart), 0.0) / a : 0.0
    float compA    = math.min(impulse / math.max(impNorm, 0.1), 1.0)

    float av    = nz(actAvg[len])
    float ratio = av > 0 ? nz(actVol[len]) / av : 1.0
    float compB = math.min(ratio / math.max(partNorm, 0.1), 1.0)

    float rng  = nz(high[len]) - nz(low[len])
    float bodH = math.max(nz(open[len]), nz(close[len]))
    float bodL = math.min(nz(open[len]), nz(close[len]))
    float wick = isRes ? nz(high[len]) - bodH : bodL - nz(low[len])
    float compC = rng > 0 ? math.min(math.max(wick, 0.0) / rng * 2.0, 1.0) : 0.0

    float wSum  = math.max(wImpulse + wPartic + wReject, 0.0001)
    float blend = (compA * wImpulse + compB * wPartic + compC * wReject) / wSum
    math.max(0.0, math.min(10.0, blend * 10.0))

recency(int age) =>
    float r = 1.0
    if age > recentBars
        float over = age - recentBars
        r := math.max(decayFloor, 1.0 - (1.0 - decayFloor) * math.min(over / math.max(decaySpan, 1), 1.0))
    r

powerTier(float p) =>
    p >= 8.0 ? "Extreme" : p >= 6.0 ? "Very Strong" : p >= 4.0 ? "Strong" : p >= 2.0 ? "Moderate" : "Weak"

powerBar(float p) =>
    int n = math.max(1, math.min(5, int(math.round(p / 2.0))))
    string s = ""
    for i = 1 to 5
        s := s + (i <= n ? "|" : ".")
    s

proximity(float d, float a) =>
    float m = a > 0 ? d / a : 0.0
    m <= immATR ? "Immediate" : m <= stATR ? "Short-Term" : m <= mtATR ? "Medium-Term" : "Long-Term"

tierBucket(float p) =>
    p >= 7.0 ? 0 : p >= 4.0 ? 1 : 2
var table wm = table.new(position.bottom_right, 1, 1)
if barstate.isfirst
    table.cell(wm, 0, 0, "Telegram @SimpleForexTools", text_color = color.new(color.gray, 70), text_size = size.large)

[htfPH, htfPL] = request.security(syminfo.tickerid, mtfTf, [ta.pivothigh(mtfLeft, mtfRight), ta.pivotlow(mtfLeft, mtfRight)], lookahead = barmerge.lookahead_off)

var array<float> mtfRes = array.new<float>()
var array<float> mtfSup = array.new<float>()

if mtfOn and barstate.isconfirmed
    if not na(htfPH) and (mtfRes.size() == 0 or mtfRes.get(mtfRes.size() - 1) != htfPH)
        mtfRes.push(htfPH)
        while mtfRes.size() > mtfMax
            mtfRes.shift()
    if not na(htfPL) and (mtfSup.size() == 0 or mtfSup.get(mtfSup.size() - 1) != htfPL)
        mtfSup.push(htfPL)
        while mtfSup.size() > mtfMax
            mtfSup.shift()

nearHtf(float px, float tol) =>
    bool found = false
    if mtfRes.size() > 0
        for v in mtfRes
            if math.abs(v - px) <= tol
                found := true
    if mtfSup.size() > 0
        for v in mtfSup
            if math.abs(v - px) <= tol
                found := true
    found

type Level
    float price
    bool  isRes
    int   born
    float raw
    int   touches
    int   flips
    bool  confl
    int   state
    int   testTier
    box   zn
    line  ln
    label lb

var array<Level> levels = array.new<Level>()

var array<int> statHold  = array.from(0, 0, 0)
var array<int> statBreak = array.from(0, 0, 0)

bool newRes  = false
bool newSup  = false
bool broke   = false
bool flipped = false

method scrub(Level v) =>
    box.delete(v.zn)
    line.delete(v.ln)
    label.delete(v.lb)

method livePower(Level v) =>
    float bonus = math.min(v.touches * touchBonus, maxTouchB) + (v.confl ? conflBonus : 0.0)
    math.min(10.0, v.raw * recency(bar_index - v.born) * (1.0 + bonus))

if barstate.isconfirmed and bar_index > hiSw * 2 + volSlow and not na(atrS) and atrS > 0
    float mergeD = atrS * mergeATR
    float zoneH  = atrS * zoneATR
    float brkD   = atrS * breakBuf

    for pass = * to *
        bool isRes = pass == 0
        if isPivot(swingLen, isRes)
            float px  = isRes ? high[swingLen] : low[swingLen]
            float raw = basePower(swingLen, isRes)
            int   bx  = bar_index - swingLen

            int hit = -1
            if levels.size() > 0
                for k = 0 to levels.size() - 1
                    Level v = levels.get(k)
                    if v.isRes == isRes and math.abs(v.price - px) <= mergeD
                        hit := k
            if hit >= 0

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