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

Strong Magnet Zones

indicator strong magnet zones for tradingview.pine

Похожие материалы по тегам

indicator crt with smc levels for tradingview.pineTradingView · 1 общих теговgold_session_liquidity_free_mt5 (1).mq5MQL5 / MetaTrader 5 · 1 общих теговconfluenceforge_pro.mq5TradingView · 1 общих теговidentical candles.mq5MQL5 / MetaTrader 5 · 1 общих теговbattleplan_ciclo_3_tempi.mq4MQL4 / MetaTrader 4 · 1 общих теговvolatility_gold_master.mq5MQL5 / MetaTrader 5 · 1 общих тегов
Вы автор или правообладатель?

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

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

О программе

«Strong Magnet Zones» — индикатор для TradingView, который строит зоны спроса и предложения (магнитные зоны) на основе свинговых структур цены. Зоны формируются на выбранном таймфрейме и отображаются на графике в виде залитых прямоугольников с оценкой актуальности (тепло), которое постепенно затухает со временем. Индикатор отслеживает, как цена тестирует эти зоны, и фиксирует результаты — отработка, разворот или продолжение движения.

Встроена система теплового scoring: каждая зона получает числовую оценку, зависящую от актуальности, количества наложений, объёма при формировании и близости к ровным числам. Горячие зоны выделяются специальной подсветкой и свечами. На графике отображаются магниты — самые горячие зоны выше и ниже текущей цены, а также метки проскальзывания с информацией о результатах.

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

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

НастройкаОписание
lockTf Таймфрейм, на котором строятся зоны. Все графики на или ниже этого таймфрейма видят одни и те же зоны
pivLen Длина свинга — количество баров по каждой стороне для определения свинг-хая/лоу
mergeTol Допуск слияния новых зон с существующими (в кратных ATR)
useVol Учитывать объём при формировании свинга для веса зоны
useRound Усиливать зоны, расположенные на ровных числах
roundStp Шаг ровного числа для усиления зон (0 = автоматический)
heightMode Метод расчёта высоты зоны: ATR Based или Fixed Percentage
heightATR Высота зоны в кратных значениях ATR (при режиме ATR Based)
heightPct Высота зоны в процентах от цены (при режиме Fixed Percentage)
atrLen Длина ATR для таймфрейма построения зон
minBase Минимальное количество свечей в базе спроса/предложения
maxBase Максимальное количество свечей в базе спроса/предложения
baseThresh Максимальное соотношение тела свечи к диапазону для базы спроса/предложения
legOutThresh Минимальное соотношение тела к диапазону для выхода из базы
legOutMult Множитель диапазона выхода относительно среднего диапазона базы
depCandles Количество свечей устойчивого удаления для подтверждения базы
halfLife Период полураспада тепла в барах таймфрейма построения
touchAdd Количество тепла, добавляемое при касании зоны без проскальзывания
maxLv Максимальное количество активных зон одновременно
maxDist Максимальная дистанция от цены для отображения зон (в кратных ATR)
minShow Минимальная оценка зоны для отображения на графике (0–10)
hotPct Порог тепла для признания зоны горячей (от 0 до 100)
workRR Множитель высоты зоны: цена должна пройти это расстояние после теста для признания отработкой
revBars Окно в барах для определения разворота после проскальзывания зоны
revAtr Множитель ATR для подтверждения разворота после проскальзывания зоны
keepRes Количество решённых зон, сохраняемых на графике
showSig Отображать торговые сигналы и тикеты
sigMode Режим фильтра тренма для сигналов: Trend aligned, Trend or turning или Any
lagLen Период фильтра Лагерра для определения тренма
sigWin Окно в барах после проскальзывания для восстановления зоны и генерации сигнала
minScore Минимальная оценка сигнала для его срабатывания (0–10)
coolBars Пауза в барах после закрытия тикета перед открытием нового сигнала
showTk Отрисовывать R-тикеты с уровнями входа, стоп-лосса и тейк-профита
slPad Отступ стоп-лосса за экстремум проскальзывания (в кратных ATR)
maxRisk Максимальный риск в кратных ATR
minRisk Минимальный риск в кратных ATR
defRR Целевое расстояние по R по умолчанию, если не подходит магнит
maxRR Максимальное расстояние цели по R
maxHold Таймаут тикета в барах — после истечения тикет закрывается
keepTk Количество тикетов, сохраняемых на графике
showZ Отображать магнитные зоны на графике
maxSide Максимальное количество живых зон, отображаемых на каждую сторону
showLbl Отображать подписи внутри активных зон
lblMax Максимальное количество подписей внутри лучших активных зон
lblMin Минимальная оценка зоны для отображения подписи (0–10)
lblRes Отображать краткие подписи на решённых зонах
lblSize Размер подписей внутри зон
showEdge Отображать линии ближнего (сплошная) и дальнего (пунктирная) краёв зон
showSwept Отображать решённые зоны (затенённые)
resBars Максимальная длина полосы решённых зон в барах
showProf Отображать тепловой профиль справа от графика
profBins Количество строк (корзин) в тепловом профиле справа
profWidth Ширина теплового профиля в барах
extRight Количество баров для продления зон вправо от последней свечи
showMag Отображать магниты — самые горячие зоны выше и ниже цены
showSwpL Отображать метки проскальзывания ⚡ (сплошная = разворот, затухшая = продолжение)
hotCandle Подсвечивать свечи внутри горячих зон
cBull Цвет бычьих магнитных зон
cBear Цвет медвежьих магнитных зон
cSwept Цвет решённых (проскользнувших) зон
fillTransp Прозрачность заливки зон
showBord Отображать границы зон
bordTransp Прозрачность границ зон
cTp Цвет тейк-профита на тикете
cSl Цвет стоп-лосса на тикете

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

indicator("Strong Magnet Zones", "Strong Magnet Zones", overlay=true, max_boxes_count=500, max_lines_count=500, max_labels_count=500, max_bars_back=5000)

grpB = "1 · Build"
lockTf   = input.timeframe("30", "Build zones on timeframe", group=grpB, tooltip="Stop pools AND supply/demand bases are built from this timeframe, so every chart at or below it (1m, 5m, 15m, 30m) shows the same zones. Charts above it use their own timeframe. Leave empty to always use the chart timeframe.")
pivLen   = input.int(5, "Swing length", minval=2, maxval=30, group=grpB, tooltip="A swing high/low needs this many bars on each side. Stops sit just beyond these swings.")
mergeTol = input.float(0.30, "Merge tolerance (× ATR)", minval=0.05, step=0.05, group=grpB, tooltip="A new pool or base that comes within this distance of a same-side zone merges into it (equal highs/lows stack heat; a pool inside a base becomes a confluence zone).")
useVol   = input.bool(true, "Weight by volume at the swing", group=grpB)
useRound = input.bool(true, "Boost zones holding a round number", group=grpB)
roundStp = input.float(0.0, "Round number step (0 = auto)", minval=0.0, group=grpB)

grpZ = "2 · Zone height (universal)"
heightMode = input.string("ATR Based", "Height method", options=["ATR Based", "Fixed Percentage"], group=grpZ, tooltip="Every zone — stop pool, base or merged — gets the SAME thickness, centered on its level (swing price, or base midpoint).")
heightATR  = input.float(0.6, "Zone height (ATR mult)", minval=0.05, maxval=10.0, step=0.05, group=grpZ)
heightPct  = input.float(0.30, "Zone height (% of price)", minval=0.01, maxval=5.0, step=0.05, group=grpZ)
atrLen     = input.int(200, "ATR length (build TF)", minval=1, maxval=500, group=grpZ)

grpS = "3 · Supply / demand bases"
minBase      = input.int(1, "Min base candles", minval=1, group=grpS)
maxBase      = input.int(5, "Max base candles", minval=1, maxval=20, group=grpS)
baseThresh   = input.float(0.65, "Max base body/range ratio", minval=0.1, maxval=0.95, step=0.05, group=grpS)
legOutThresh = input.float(0.55, "Min leg-out body/range ratio", minval=0.3, maxval=0.95, step=0.05, group=grpS)
legOutMult   = input.float(1.4, "Leg-out range vs base average (×)", minval=1.0, step=0.1, group=grpS)
depCandles   = input.int(1, "Sustained departure candles", minval=1, maxval=5, group=grpS)

grpH = "4 · Heat & lifecycle"
halfLife = input.int(150, "Heat half-life (bars of build TF)", minval=10, maxval=2000, group=grpH)
touchAdd = input.float(0.3, "Heat added per touch without sweep", minval=0.0, step=0.1, group=grpH)
maxLv    = input.int(60, "Max active zones", minval=10, maxval=200, group=grpH)
maxDist  = input.float(16.0, "Show zones within (× ATR of price)", minval=2.0, step=0.5, group=grpH)
minShow  = input.float(4.0, "Hide zones scoring below (0–10)", minval=0.0, maxval=10.0, step=0.5, group=grpH)
hotPct   = input.int(60, "Hot zone = heat ≥", minval=10, maxval=100, group=grpH)
workRR   = input.float(1.0, "WORKED = price travels (× zone height) after a test", minval=0.5, maxval=5.0, step=0.5, group=grpH)
revBars  = input.int(10, "Sweep → reversal window (bars)", minval=2, maxval=100, group=grpH)
revAtr   = input.float(0.5, "Reversal = close back beyond zone by (× ATR)", minval=0.1, step=0.1, group=grpH)
keepRes  = input.int(30, "Resolved zones kept on chart", minval=0, maxval=150, group=grpH)

grpG = "5 · Signals & tickets"
showSig  = input.bool(true, "Signals", group=grpG)
sigMode  = input.string("Trend or turning", "Trend gate (Laguerre, not drawn)", options=["Trend aligned", "Trend or turning", "Any"], group=grpG, tooltip="An invisible Ehlers Laguerre fast/slow filter gates signals. Trend aligned: BUY only when fast > slow AND rising. Trend or turning: either. Any: no gate. Nothing is plotted.")
lagLen   = input.int(20, "Laguerre period", minval=5, group=grpG)
sigWin   = input.int(8, "Reclaim within (bars after a sweep)", minval=1, maxval=50, group=grpG)
minScore = input.float(6.0, "Min signal score (0–10)", minval=0.0, maxval=10.0, step=0.5, group=grpG)
coolBars = input.int(10, "Cooldown after a ticket closes (bars)", minval=0, maxval=200, group=grpG)
showTk   = input.bool(true, "Draw R-tickets (entry / SL / TP)", group=grpG)
slPad    = input.float(0.15, "SL pad beyond the sweep extreme (× ATR)", minval=0.0, step=0.05, group=grpG)
maxRisk  = input.float(2.0, "Max risk (× ATR)", minval=0.3, step=0.1, group=grpG)
minRisk  = input.float(0.4, "Min risk (× ATR)", minval=0.1, step=0.1, group=grpG)
defRR    = input.float(2.0, "Default target (R) when no magnet fits", minval=0.5, step=0.5, group=grpG)
maxRR    = input.float(5.0, "Max target distance (R)", minval=1.0, step=0.5, group=grpG)
maxHold  = input.int(60, "Ticket timeout (bars)", minval=5, maxval=500, group=grpG)
keepTk   = input.int(12, "Tickets kept on chart", minval=1, maxval=60, group=grpG)

grpV = "6 · Visuals"
showZ     = input.bool(true, "Magnet zones", group=grpV)
maxSide   = input.int(5, "Max live zones shown per side", minval=1, maxval=30, group=grpV, tooltip="Only the best-scoring live zones in view are drawn, per side. Keeps the chart readable.")
showLbl   = input.bool(true, "Labels inside zones", group=grpV)
lblMax    = input.int(4, "Max labels (best live zones)", minval=1, maxval=20, group=grpV)
lblMin    = input.float(5.0, "Label zones scoring ≥", minval=0.0, maxval=10.0, step=0.5, group=grpV)
lblRes    = input.bool(true, "Brief labels on resolved zones", group=grpV, tooltip="Resolved zones are greyed out and carry a short label: score · outcome (WORKED ✔ / ⚡ REVERSED ✔ / ⚡ CONTINUED ✘).")
lblSize   = input.string("Normal", "Label size", options=["Tiny", "Small", "Normal", "Large"], group=grpV)
showEdge  = input.bool(false, "Proximal (solid) / distal (dashed) edge lines", group=grpV)
showSwept = input.bool(true, "Show resolved zones (greyed out)", group=grpV)
resBars   = input.int(400, "Resolved band max length (bars)", minval=20, maxval=3000, group=grpV)
showProf  = input.bool(true, "Heat profile on the right", group=grpV)
profBins  = input.int(40, "Profile rows", minval=10, maxval=80, group=grpV)
profWidth = input.int(12, "Profile width (bars)", minval=5, maxval=100, group=grpV)
extRight  = input.int(3, "Extend zones right (bars)", minval=0, maxval=50, group=grpV)
showMag   = input.bool(true, "Magnets (hottest zone above / below)", group=grpV)
showSwpL  = input.bool(true, "Sweep marks ⚡ (solid = reversed · faded = continued)", group=grpV)
hotCandle = input.bool(true, "Glow candles inside hot zones", group=grpV)

grpK = "7 · Style"
cBull     = input.color(#21c997, "Magnet Zone Bulls tone", group=grpK)
cBear     = input.color(#cc24e2, "Magnet Zone Bears tone", group=grpK)
cSwept    = input.color(#B2B5BE, "Swept / resolved zone", group=grpK)
fillTransp= input.int(84, "Zone transparency", minval=50, maxval=96, group=grpK)
showBord  = input.bool(true, "Show zone borders", group=grpK)
bordTransp= input.int(35, "Border transparency", minval=0, maxval=100, group=grpK)
cTp     = input.color(#4caf50, "Ticket TP", group=grpK)
cSl     = input.color(#e53935, "Ticket SL", group=grpK)

type MZ
    float lvl
    float top
    float bot
    int   side
    float w
    int   born
    int   bornT
    int   stacks = 0
    bool  sd = false
    float imp = 0.0
    float bod = 0.0
    float vf = 1.0
    bool  rnd = false
    int   tests = 0
    bool  inLast = false
    int   addB = na
    int   state = 0
    int   revRes = 0
    int   endBar = na
    float score = 0.0
    float hpEnd = 0.0
    box   bx = na
    line  pLn = na
    line  dLn = na
    label tag = na

type Tk
    int   dir
    float entry
    float sl
    float tp
    int   born
    float r
    line  eLn
    line  sLn
    line  tLn
    box   rBox
    box   pBox
    label sig
    label out = na
    int   state = 0

int    chSec  = timeframe.in_seconds()
int    lkSec  = lockTf == "" ? chSec : timeframe.in_seconds(lockTf)
string effTf  = lkSec > chSec ? lockTf : timeframe.period
int    effSec = math.max(lkSec, chSec)
float  tfMult = float(effSec) / chSec

f_sdDetect() =>
    int   dirO = 0
    float zTop = na
    float zBot = na
    float imp  = 0.0
    float bod  = 0.0
    float vf   = 1.0
    int   st   = na
    float va   = ta.sma(nz(volume), 50)
    int   lo   = depCandles
    if bar_index >= maxBase + lo + 5
        float rngL = high[lo] - low[lo]
        float bdyL = math.abs(close[lo] - open[lo])
        if rngL > 0 and bdyL / rngL >= legOutThresh
            bool bull = close[lo] > open[lo]
            int  bc = 0
            int  sb = lo + 1
            for i = 0 to maxBase - 1
                float r = high[sb + i] - low[sb + i]
                float b = math.abs(close[sb + i] - open[sb + i])
                if r > 0 and b / r <= baseThresh
                    bc += 1
                else
                    break
            bool inside = high[sb] <= high[sb + 1] and low[sb] >= low[sb + 1]
            if bc >= minBase and not inside
                float bh = high[sb]
                float bl = low[sb]
                float sum = 0.0
                for b2 = 0 to bc - 1
                    bh := math.max(bh, high[sb + b2])
                    bl := math.min(bl, low[sb + b2])
                    sum += high[sb + b2] - low[sb + b2]
                float avg = sum / bc
                float zh = bh - bl
                if zh > 0 and zh < rngL and rngL >= avg * legOutMult
                    bool ok = true
                    for dep = 1 to depCandles
                        int d = lo - dep
                        if d >= 0
                            if bull ? (close[d] <= bh or low[d] <= bh) : (close[d] >= bl or high[d] >= bl)
                                ok := false
                    if ok and (bull ? close[lo] > bh : close[lo] < bl)
                        dirO := bull ? 1 : -1
                        zTop := bh
                        zBot := bl
                        imp  := rngL / avg
                        bod  := bdyL / rngL
                        vf   := va[lo] > 0 ? math.min(math.max(nz(volume[lo]) / va[lo], 0.5), 3.0) : 1.0
                        st   := time[sb + bc - 1]
    [dirO, zTop, zBot, imp, bod, vf, st]

f_src() =>
    float a   = ta.atr(14)
    float a2  = ta.atr(atrLen)
    float va  = ta.sma(nz(volume), 50)
    float vfx = va[pivLen] > 0 ? math.min(math.max(nz(volume[pivLen]) / va[pivLen], 0.5), 3.0) : 1.0
    float p1  = ta.pivothigh(high, pivLen, pivLen)
    float p2  = ta.pivotlow(low, pivLen, pivLen)
    int   tp  = time[pivLen]
    [sdD, sdT, sdB, sdI, sdBo, sdV, sdS] = f_sdDetect()
    [p1[1], p2[1], tp[1], a[1], a2[1], vfx[1], high[1], low[1], sdD[1], sdT[1], sdB[1], sdI[1], sdBo[1], sdV[1], sdS[1]]
[ph, pl, pivT, atrL, atrNL, vfL, hiL, loL, sdDir, sdTop, sdBot, sdImp, sdBod, sdVf, sdStartT] = request.security(syminfo.tickerid, effTf, f_src(), lookahead=barmerge.lookahead_on)
bool  tfCh   = timeframe.change(effTf)
bool  newL   = effTf == timeframe.period ? true : tfCh
float atr    = atrL
float atrN   = math.max(nz(atrNL, atr), syminfo.mintick)
float zoneH  = heightMode == "ATR Based" ? atrN * heightATR : close * (heightPct / 100.0)
bool  conf   = barstate.isconfirmed
bool  hasVol = ta.cum(nz(volume)) > 0

f_idxAt(int t) =>
    int k = 0
    while k < 4900 and bar_index - k > 0 and time[k] > t
        k += 1
    bar_index - k

var array<MZ> act = array.new<MZ>()
var array<MZ> res = array.new<MZ>()

f_step() =>
    float s = roundStp
    if s <= 0
        s := math.pow(10, math.floor(math.log10(math.max(close, 1e-10))) - 2) * 2.5
    s
f_heat(MZ z) =>
    float age = (time - z.bornT) / (effSec * 1000.0)
    z.w * math.pow(0.5, age / halfLife)
f_clamp(float v, float lo, float hi) =>
    math.max(lo, math.min(hi, v))
f_prox(MZ z) =>
    z.side == 1 ? z.top : z.bot
f_dist(MZ z) =>
    z.side == 1 ? z.bot : z.top
f_hasRound(float top, float bot) =>
    float st = f_step()
    float r = math.round((top + bot) / 2 / st) * st
    r >= bot and r <= top
f_setBounds(MZ z) =>
    z.top := z.lvl + zoneH / 2
    z.bot := z.lvl - zoneH / 2
f_stars(float sc) =>
    sc >= 8 ? "★★★★" : sc >= 6.5 ? "★★★" : sc >= 5 ? "★★" : sc >= 3 ? "★" : "·"
f_tier(float sc) =>
    sc >= 8 ? "ELITE" : sc >= 6.5 ? "STRONG" : sc >= 5 ? "MODERATE" : sc >= 3 ? "WEAK" : "FORMING"

f_score(MZ z, float mx) =>
    float hp = mx > 0 ? math.sqrt(math.max(f_heat(z), 0) / mx) : 0.0
    float pts = 4.0 * hp
    pts += math.min(1.5, z.stacks * 0.5)
    if z.sd
        pts += f_clamp((z.imp - 1.0) * 1.5, 0.0, 2.0) + f_clamp((z.bod - 0.5) * 3.0, 0.0, 1.0)
    pts += f_clamp((z.vf - 1.0), 0.0, 1.0)
    pts += z.sd and z.stacks > 0 ? 1.5 : 0.0
    pts += z.rnd ? 0.5 : 0.0
    pts += z.state == 0 and z.tests == 0 ? 0.5 : 0.0
    f_clamp(pts, 0.0, 10.0)

f_add(float lvl, int side, float wNew, int bornBar, int bornT, bool isSD, float imp, float bod, float vf) =>
    float tol = math.max(mergeTol * atr, zoneH / 2)
    int hit = -1
    float best = tol
    if act.size() > 0
        for i = 0 to act.size() - 1
            MZ z = act.get(i)
            float d = math.abs(z.lvl - lvl)
            if z.side == side and d <= best
                best := d
                hit := i
    if hit >= 0
        MZ z = act.get(hit)
        float cur = f_heat(z)
        float tw = cur + wNew
        z.lvl := (z.lvl * cur + lvl * wNew) / tw
        f_setBounds(z)
        z.w := tw + (isSD ? 0.0 : wNew * 0.5)
        z.born := math.min(z.born, bornBar)
        z.bornT := math.max(z.bornT, bornT)
        z.addB := bar_index
        if isSD
            z.sd := true
            z.imp := math.max(z.imp, imp)
            z.bod := math.max(z.bod, bod)
            z.vf := math.max(z.vf, vf)
        else
            z.stacks += 1
            z.vf := math.max(z.vf, vf)
        z.rnd := useRound and f_hasRound(z.top, z.bot)
    else
        MZ nz1 = MZ.new(lvl, lvl + zoneH / 2, lvl - zoneH / 2, side, wNew, bornBar, bornT)
        nz1.rnd := useRound and f_hasRound(nz1.top, nz1.bot)
        if nz1.rnd
            nz1.w := nz1.w * 1.3
        if isSD
            nz1.sd := true
            nz1.imp := imp
            nz1.bod := bod
            nz1.vf := vf
        else
            nz1.stacks := 1
            nz1.vf := vf
        nz1.addB := bar_index
        act.push(nz1)
    hit

if conf and newL and not na(atr) and atr > 0 and zoneH > 0
    if not na(pivT)
        float vf = useVol and hasVol ? nz(vfL, 1.0) : 1.0
        int bi = na(ph) and na(pl) ? na : f_idxAt(pivT)
        if not na(ph)
            f_add(ph, -1, vf, bi, pivT, false, 0.0, 0.0, vf)
        if not na(pl)
            f_add(pl, 1, vf, bi, pivT, false, 0.0, 0.0, vf)
    if nz(sdDir) != 0 and not na(sdTop) and not na(sdBot) and not na(sdStartT)
        float wSD = 1.0 + f_clamp((sdImp - 1.0) * 0.5, 0.0, 1.0)
        f_add((sdTop + sdBot) / 2, sdDir, wSD, f_idxAt(sdStartT), sdStartT, true, sdImp, sdBod, useVol and hasVol ? sdVf : 1.0)

float maxH = 0.0
if act.size() > 0
    for i = 0 to act.size() - 1
        maxH := math.max(maxH, f_heat(act.get(i)))

var array<label> swLbls = array.new<label>()
var int nRev   = 0
var int nRevOk = 0
bool  sweepBull = false
bool  sweepBear = false
bool  workEv    = false
bool  testEv    = false
float swBullHp  = 0.0
float swBearHp  = 0.0
float swBullP   = na
float swBearP   = na
float swBullSc  = 0.0
float swBearSc  = 0.0
string hotMsg = ""

f_zName(MZ z) =>
    z.side == 1 ? "MAGNET ZONE BULLS" : "MAGNET ZONE BEARS"
f_zCol(MZ z) =>
    z.side == 1 ? cBull : cBear
f_zSize() =>
    lblSize == "Tiny" ? size.tiny : lblSize == "Normal" ? size.normal : lblSize == "Large" ? size.large : size.small

f_zText(MZ z, float hp) =>
    float hpx = z.state == 0 ? hp : z.hpEnd
    string t = f_stars(z.score) + " " + str.tostring(z.score, "0.0") + "/10 " + f_tier(z.score) + " · heat " + str.tostring(hpx, "0")
    if z.stacks > 1
        t += " · ×" + str.tostring(z.stacks)
    if z.sd
        t += " · S/D " + str.tostring(z.imp, "0.0") + "×"
    if z.sd and z.stacks > 0
        t += " · CONF"
    if z.vf > 1.05
        t += " · vol " + str.tostring(z.vf, "0.0") + "×"
    if z.rnd
        t += " · ◎"
    t += z.state == 1 ? " · WORKED ✔" : z.state == 2 ? (z.revRes == 1 ? " · SWEPT → REVERSED ✔" : z.revRes == -1 ? " · SWEPT → CONTINUED ✘" : " · SWEPT") : z.tests == 0 ? " · FRESH" : " · R:" + str.tostring(z.tests)
    t

f_zBrief(MZ z) =>
    str.tostring(z.score, "0.0") + (z.state == 1 ? " · WORKED ✔" : z.revRes == 1 ? " · ⚡ REVERSED ✔" : z.revRes == -1 ? " · ⚡ CONTINUED ✘" : " · ⚡ SWEPT")

f_zDel(MZ z) =>
    if not na(z.bx)
        z.bx.delete()
    if not na(z.pLn)
        z.pLn.delete()
    if not na(z.dLn)
        z.dLn.delete()
    if not na(z.tag)
        z.tag.delete()
    true

f_zFreeze(MZ z, color c, int alpha) =>
    int xl = math.max(z.born, bar_index - resBars)
    if na(z.bx)
        z.bx := box.new(xl, z.top, bar_index, z.bot, border_color=color(na), bgcolor=color.new(c, alpha))
    else
        z.bx.set_lefttop(xl, z.top)
        z.bx.set_rightbottom(bar_index, z.bot)
        z.bx.set_bgcolor(color.new(c, alpha))
        z.bx.set_border_color(color(na))
    if not na(z.pLn)
        z.pLn.delete()
        z.pLn := na
    if not na(z.dLn)
        z.dLn.delete()
        z.dLn := na
    if lblRes and showLbl
        if na(z.tag)
            z.tag := label.new(bar_index, (z.top + z.bot) / 2, f_zBrief(z), style=label.style_label_right, color=color.new(c, 100), textcolor=color.new(cSwept, 20), size=size.tiny)
        else
            z.tag.set_x(bar_index)
            z.tag.set_text(f_zBrief(z))
            z.tag.set_textcolor(color.new(cSwept, 20))
            z.tag.set_size(size.tiny)
    else if not na(z.tag)
        label old = z.tag
        z.tag := na
        old.delete()
    true

if conf and act.size() > 0 and not na(atr)
    for i = act.size() - 1 to 0
        MZ z = act.get(i)
        if zoneH > 0
            f_setBounds(z)
        if z.born < bar_index
            float hp = maxH > 0 ? 100 * math.sqrt(f_heat(z) / maxH) : 0
            bool swept  = z.side == 1 ? low < z.bot - 0.05 * atr : high > z.top + 0.05 * atr
            bool inZone = high >= z.bot and low <= z.top
            bool touchH = newL and not na(hiL) and z.addB != bar_index and (z.side == 1 ? loL <= z.top : hiL >= z.bot)
            bool worked = z.tests > 0 and (z.side == 1 ? high >= z.top + (z.top - z.bot) * workRR : low <= z.bot - (z.top - z.bot) * workRR)
            if swept
                z.state := 2
                z.endBar := bar_index
                z.hpEnd := hp
                z.score := f_score(z, maxH)
                if hp >= hotPct
                    hotMsg += (z.side == 1 ? "BULLS " : "BEARS ") + str.tostring(f_prox(z), format.mintick) + " (heat " + str.tostring(hp, "0") + ")  "
                if z.side == 1
                    sweepBull := true
                    if hp > swBullHp
                        swBullHp := hp
                        swBullP := z.top
                        swBullSc := z.score
                else
                    sweepBear := true
                    if hp > swBearHp
                        swBearHp := hp
                        swBearP := z.bot
                        swBearSc := z.score
                if showSwpL and hp >= hotPct
                    bool up = z.side == -1
                    label sl = label.new(bar_index, up ? high : low, "⚡", yloc=up ? yloc.abovebar : yloc.belowbar, style=label.style_none, textcolor=up ? cBear : cBull, size=size.normal, tooltip=f_zName(z) + " swept · " + str.tostring(f_prox(z), format.mintick) + " · heat " + str.tostring(hp, "0") + " · outcome pending")
                    swLbls.push(sl)
                    while swLbls.size() > 24
                        swLbls.shift().delete()
                f_zFreeze(z, cSwept, 84)
                act.remove(i)
                res.push(z)
            else if worked
                z.state := 1
                z.endBar := bar_index
                z.hpEnd := hp
                z.score := f_score(z, maxH)
                workEv := true
                f_zFreeze(z, cSwept, 80)
                act.remove(i)
                res.push(z)
            else
                if inZone and not z.inLast
                    z.tests += 1
                    testEv := true
                if touchH
                    z.w := f_heat(z) + touchAdd
                    z.bornT := time
                z.inLast := inZone
    while act.size() > maxLv
        int ci = 0
        float ch = 1e30
        for j = 0 to act.size() - 1
            float h = f_heat(act.get(j))
            if h < ch
                ch := h
                ci := j
        MZ d = act.remove(ci)
        f_zDel(d)

if conf and res.size() > 0 and not na(atr)
    for i = 0 to res.size() - 1
        MZ z = res.get(i)
        if z.state == 2 and z.revRes == 0
            bool ok  = bar_index > z.endBar and (z.side == 1 ? close >= z.top + revAtr * atr : close <= z.bot - revAtr * atr)
            bool out = bar_index - z.endBar >= revBars * tfMult
            if ok or out
                z.revRes := ok ? 1 : -1
                nRev += 1
                nRevOk += ok ? 1 : 0
                if not na(z.tag)
                    z.tag.set_text(f_zBrief(z))
                if swLbls.size() > 0
                    for k = swLbls.size() - 1 to 0
                 

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