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

Anchored VWAP Pullback & Target Zones

indicator anchored vwap pullback & target zones for tradingview.pine
Вы автор или правообладатель?

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

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

О программе

Данный индикатор TradingView рассчитывает Anchored VWAP (объёмно-взвешенную среднюю цену) от структурных свинг-точек и выявляет паттерны отката с возвратом к якорной цене на графике. Он отображает зоны значения, линии якорей и графические метки сигналов прямо на ценовом графике.

Индикатор одновременно запускает 7 параллельных профилей фильтрации с различными параметрами и автоматически выбирает профиль с наилучшей историей результатов (режим Auto-Optimize). Каждый профиль оценивает откаты по эффективности тренда, качеству сделки и относительной активности объёма.

Для каждого подтверждённого сигнала формируется торговый план с уровнями входа, Stop Loss и тремя целями (TP1–TP3). Визуально планы отображаются в виде коробок, линий и подписей на графике. Также доступна сводная панель с текущими значениями VWAP, эффективности и статистикой.

Индикатор поддерживает условия оповещений для входов, достижения целей и срабатывания Stop Loss. Все расчёты выполняются средствами Pine Script на закрытых барах без перерисовки.

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

НастройкаОписание
swingLen Количество баров для определения структурных свинг-высоких и свинг-низких, служащих якорями для расчёта Anchored VWAP.
maxPbPerAnchor Максимальное количество подтверждённых планов отката от одной структурной якорной точки до появления нового якоря.
minImpulseAtr Минимальное расширение цены от якорной точки (в единицах ATR(14)), необходимое для активации обнаружения откатов.
filterPreset Режим фильтрации откатов: автоматический выбор лучшего профиля или один из шести предустановленных режимов с заданными параметрами.
customMinEr Минимальная эффективность тренда по Кофману (%), при которой подтверждается trending-режим и блокируется боковик (активно только в режиме Custom).
customBandSig Ширина зоны отката Anchored VWAP в объёмно-взвешенных стандартных отклонениях (активно только в режиме Custom).
targetMode Режим проекции целей: гибридный (лестница R + магнит импульсных экстремумов) или фиксированная лестница R (1R/2R/3R).
slBufferAtr Буферное расстояние (в ATR(14)) за пределами уровня отката для установки Stop Loss.
useBeRatchet При достижении TP1 перемещает активный Stop Loss на уровень входа (безубыточность) для оставшихся целей.
showPastPlans Отображает до 5 последних торговых планов на графике (по умолчанию показывается только текущий).
showSkipped Показывает маркеры отфильтрованных откатов, заблокированных фильтром качества/эффективности.
showDash Отображает информационную панель с текущим Anchored VWAP, эффективностью, профилем и статистикой в правом верхнем углу.
dashSizeInput Размер шрифта и масштаб элементов информационной панели.
bullCol Цветовое оформление бычьих зон, меток BUY и целей по фиксации прибыли.
bearCol Цветовое оформление медвежьих зон, меток SELL и уровней Stop Loss.

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

indicator(
     title            = "Anchored VWAP Pullback & Target Zones",
     shorttitle       = "AVPT",
     overlay          = true,
     max_lines_count  = 500,
     max_labels_count = 500,
     max_boxes_count  = 300
)

max_bars_back(time, 64)
max_bars_back(close, 64)
max_bars_back(high, 64)
max_bars_back(low, 64)
max_bars_back(volume, 64)

enum FilterMode
    AUTO_OPTIMIZE = "Auto-Optimize (Best Chart Win Rate)"
    BALANCED      = "Balanced (1.0σ Band · 26% Eff)"
    CONSERVATIVE  = "Conservative (0.8σ Band · 35% Eff)"
    AGGRESSIVE    = "Aggressive (1.25σ Band · 18% Eff)"
    SHALLOW       = "Shallow Pullback (0.65σ · 30% Eff)"
    DEEP_VALUE    = "Deep Value Reclaim (1.45σ · 22% Eff)"
    VOL_CLIMAX    = "Volume Climax Reclaim (1.0σ · 1.25x Vol)"
    CUSTOM        = "Custom Thresholds"

enum TargetMode
    HYBRID      = "R Ladder + Impulse High/Low Magnet"
    R_MULTIPLES = "Fixed R Ladder (1R / 2R / 3R)"

enum DashSize
    TINY   = "Tiny"
    SMALL  = "Small"
    NORMAL = "Normal"
    LARGE  = "Large"

string GRP_ANC  = "1. Structural Anchor & AVWAP Value Band"
string GRP_FILT = "2. Pullback Chop Filter & Auto-Optimizer"
string GRP_PLAN = "3. Entry, Stop Loss & TP1–TP3 Targets"
string GRP_VIS  = "4. Visuals & Dashboard"

int        swingLen       = input.int(10, "Structural Anchor Swing Lookback", minval = 3, maxval = 40, group = GRP_ANC, tooltip = "Confirmed left/right bars used to detect structural swing highs and lows that anchor the impulse VWAP. Confirmed pivots reconstruct exact AVWAP from the true swing bar without repainting.")
int        maxPbPerAnchor = input.int(2, "Max Pullbacks Per Trend Anchor", minval = 1, maxval = 4, group = GRP_ANC, tooltip = "Maximum number of confirmed pullback trade plans allowed from a single structural anchor before requiring a fresh swing anchor.")
float      minImpulseAtr  = input.float(1.40, "Min Impulse Expansion (ATR)", minval = 0.60, maxval = 3.50, step = 0.10, group = GRP_ANC, tooltip = "Minimum directional expansion away from the swing anchor (in ATR(14) units) required before the Anchored VWAP arms pullback detection.")

FilterMode filterPreset   = input.enum(FilterMode.AUTO_OPTIMIZE, "Pullback Filter Mode", group = GRP_FILT, tooltip = "Auto-Optimize runs all 6 built-in strategy profiles in parallel across the current asset and timeframe, then selects and renders the exact profile with the highest closed-bar TP1+ Win Rate.")
float      customMinEr    = input.float(26.0, "Custom Min Trend Efficiency (%)", minval = 10.0, maxval = 70.0, step = 2.0, group = GRP_FILT, active = filterPreset == FilterMode.CUSTOM, tooltip = "Minimum Kaufman Trend Efficiency (0–100%) required to confirm a trending regime and block sideways chop when Mode is set to Custom Thresholds.")
float      customBandSig  = input.float(1.00, "Custom Value Band Width (Sigma)", minval = 0.40, maxval = 2.20, step = 0.05, group = GRP_FILT, active = filterPreset == FilterMode.CUSTOM, tooltip = "Width of the Anchored VWAP pullback value zone in volume/activity-weighted standard deviations when Mode is set to Custom Thresholds.")

TargetMode targetMode     = input.enum(TargetMode.HYBRID, "Target Projection Mode", group = GRP_PLAN, tooltip = "Fixed R Ladder projects TP1/TP2/TP3 at 1.0R, 2.0R, and 3.0R. R Ladder + Impulse High/Low Magnet snaps TP2 or TP3 to the prior impulse extreme when it offers a clean structural liquidity target.")
float      slBufferAtr    = input.float(0.20, "Stop Loss Buffer Beyond Pullback (ATR)", minval = 0.05, maxval = 1.00, step = 0.05, group = GRP_PLAN, tooltip = "Base ATR(14) breathing room placed beyond the pullback low/high or AVWAP defense band for the Stop Loss level.")
bool       useBeRatchet   = input.bool(true, "Move Stop to Breakeven After TP1", group = GRP_PLAN, tooltip = "When enabled, once TP1 is reached on a confirmed bar, the active Stop Loss ratchets to the Entry price (Breakeven) for remaining targets.")

bool       showPastPlans  = input.bool(false, "Keep Historical Trade Plans (Last 5)", group = GRP_VIS, tooltip = "Off by default so only the current/latest trade plan ladder stays on price. Enable to keep the last 5 trade plans of the active profile visible on the chart.")
bool       showSkipped    = input.bool(false, "Show Filtered (SKIP) Pullbacks", group = GRP_VIS, tooltip = "Displays small muted markers when an AVWAP pullback reclaim occurs but is blocked by the active profile's chop/efficiency filter.")
bool       showDash       = input.bool(true, "Show Summary Dashboard", group = GRP_VIS, tooltip = "Displays the live Anchored VWAP, Trend Efficiency, Auto-Optimizer Winner, Trade Plan, and Win/Loss performance table in the top-right corner.")
DashSize   dashSizeInput  = input.enum(DashSize.SMALL, "Table Size", group = GRP_VIS, active = showDash, tooltip = "Scales text size inside the summary dashboard.")
color      bullCol        = input.color(#00E6A8, "Bullish Trend & Reward Color", group = GRP_VIS, tooltip = "Accent color for Bullish Anchored VWAP bands, BUY callouts, and Take-Profit zones.")
color      bearCol        = input.color(#FF3B69, "Bearish Trend & Risk Color", group = GRP_VIS, tooltip = "Accent color for Bearish Anchored VWAP bands, SELL callouts, and Stop-Loss zones.")

type SavedPlan
    int   profId
    int   dir
    int   entryBar
    float entry
    float initSl
    float activeSl
    float risk
    float tp1
    float tp2
    float tp3
    float tp1R
    float tp2R
    float tp3R
    bool  tpIsMag
    float qualPct
    bool  tp1Hit
    bool  tp2Hit
    bool  tp3Hit
    bool  slHit
    bool  beHit
    int   status      // 0 = ACTIVE, 1 = TP3 FULL WIN, 2 = PARTIAL WIN (TP1+), -1 = LOSS (SL), 3 = EXPIRED/FLIP
    int   endTime
    int   pbLeftTime
    float pbTop
    float pbBot
    int   entryTime
    float signalY     // Stored price anchor; avoids abovebar/belowbar history lookups

type ProfileEngine
    int    id
    string nameTag
    float  bandSigma
    float  outerSigma
    float  minErPct
    float  minQual
    float  slScale
    float  minRiskAtr
    float  minRelAct
    int    totalTrades
    int    winTrades
    int    lossTrades
    int    tp1Count
    int    tp2Count
    int    tp3Count
    float  cumNetR
    int    lastSigDir
    float  lastSigQual
    string lastSigText
    int    activePlanIdx // Index in global allPlans array (-1 if none)

    bool   bullInZone
    float  bullPbLow
    int    bullPbTime
    int    bullPbUsed
    bool   bearInZone
    float  bearPbHigh
    int    bearPbTime
    int    bearPbUsed

    bool   barBullTake
    bool   barBearTake
    bool   barBullSkip
    bool   barBearSkip
    bool   barTp1Evt
    bool   barTp2Evt
    bool   barTp3Evt
    bool   barSlEvt

f_clamp(float val, float lo, float hi) =>
    math.min(math.max(val, lo), hi)

float rawAtr      = ta.atr(14)
float safeAtr     = nz(rawAtr, math.max(high - low, syminfo.mintick * 10.0))
float barSpan     = math.max(high - low, syminfo.mintick)

float volSma      = ta.sma(volume, 20)
bool  hasRealVol  = not na(volume) and volume > 0 and not na(volSma) and volSma > 0
float relActivity = hasRealVol ? (volume / volSma) : (barSpan / math.max(safeAtr, syminfo.mintick))
float actNorm     = f_clamp(relActivity / 2.0, 0.0, 1.0)
float barWeight   = hasRealVol ? math.max(nz(volume), 1e-6) : math.max(relActivity, 0.1)

int   erLen       = 10
float netMove     = math.abs(close - nz(close[erLen], close))
float pathMove    = nz(ta.sma(math.abs(close - nz(close[1], close)), erLen), 0.0) * float(erLen)
float erPct       = pathMove > 0 ? f_clamp((netMove / pathMove) * 100.0, 0.0, 100.0) : 0.0
float erNorm      = f_clamp(erPct / 55.0, 0.0, 1.0)

float bullCloseShare = f_clamp((close - low) / barSpan, 0.0, 1.0)
float bearCloseShare = f_clamp((high - close) / barSpan, 0.0, 1.0)
float bullBodyBonus  = close > open ? 1.0 : 0.55
float bearBodyBonus  = close < open ? 1.0 : 0.55

float bullQualScore  = math.round(f_clamp((0.40 * bullCloseShare + 0.35 * erNorm + 0.25 * actNorm) * 100.0 * (close > open ? 1.0 : 0.85), 0.0, 100.0), 1)
float bearQualScore  = math.round(f_clamp((0.40 * bearCloseShare + 0.35 * erNorm + 0.25 * actNorm) * 100.0 * (close < open ? 1.0 : 0.85), 0.0, 100.0), 1)

var array<ProfileEngine> engines    = array.new<ProfileEngine>()
var array<SavedPlan>     allPlans   = array.new<SavedPlan>()
var array<box>           drawnBoxes = array.new<box>()
var array<line>          drawnLines = array.new<line>()
var array<label>         drawnLbls  = array.new<label>()

var bool  bullAnchorActive = false
var int   bullAnchorTime   = 0
var int   bullAnchorBar    = 0
var float bullAnchorPrice  = na
var float bullSumWP        = 0.0
var float bullSumWP2       = 0.0
var float bullSumW         = 0.0
var float bullAvwap        = na
var float bullStd          = 0.0
var float bullImpHigh      = na
var int   bullImpHighTime  = 0
var bool  bullImpArmed     = false

var bool  bearAnchorActive = false
var int   bearAnchorTime   = 0
var int   bearAnchorBar    = 0
var float bearAnchorPrice  = na
var float bearSumWP        = 0.0
var float bearSumWP2       = 0.0
var float bearSumW         = 0.0
var float bearAvwap        = na
var float bearStd          = 0.0
var float bearImpLow       = na
var int   bearImpLowTime   = 0
var bool  bearImpArmed     = false

var int   activeTrendBias  = 0

if barstate.isfirst

    array.push(engines, ProfileEngine.new(0, "Balanced (1.0σ · 26% Eff)",       1.00, 2.00, 26.0, 52.0, 1.00, 0.35, 0.00, 0, 0, 0, 0, 0, 0, 0.0, 0, 0.0, "NONE", -1, false, na, 0, 0, false, na, 0, 0, false, false, false, false, false, false, false, false))
    array.push(engines, ProfileEngine.new(1, "Conservative (0.8σ · 35% Eff)",   0.80, 1.75, 35.0, 60.0, 1.15, 0.35, 0.00, 0, 0, 0, 0, 0, 0, 0.0, 0, 0.0, "NONE", -1, false, na, 0, 0, false, na, 0, 0, false, false, false, false, false, false, false, false))
    array.push(engines, ProfileEngine.new(2, "Aggressive (1.25σ · 18% Eff)",    1.25, 2.30, 18.0, 44.0, 0.85, 0.30, 0.00, 0, 0, 0, 0, 0, 0, 0.0, 0, 0.0, "NONE", -1, false, na, 0, 0, false, na, 0, 0, false, false, false, false, false, false, false, false))
    array.push(engines, ProfileEngine.new(3, "Shallow Pullback (0.65σ · 30%)",  0.65, 1.60, 30.0, 55.0, 0.90, 0.30, 0.00, 0, 0, 0, 0, 0, 0, 0.0, 0, 0.0, "NONE", -1, false, na, 0, 0, false, na, 0, 0, false, false, false, false, false, false, false, false))
    array.push(engines, ProfileEngine.new(4, "Deep Value Reclaim (1.45σ)",      1.45, 2.50, 22.0, 48.0, 1.25, 0.40, 0.00, 0, 0, 0, 0, 0, 0, 0.0, 0, 0.0, "NONE", -1, false, na, 0, 0, false, na, 0, 0, false, false, false, false, false, false, false, false))
    array.push(engines, ProfileEngine.new(5, "Volume Climax (1.0σ + 1.25x Vol)",1.00, 2.00, 24.0, 58.0, 0.95, 0.32, 1.25, 0, 0, 0, 0, 0, 0, 0.0, 0, 0.0, "NONE", -1, false, na, 0, 0, false, na, 0, 0, false, false, false, false, false, false, false, false))
    array.push(engines, ProfileEngine.new(6, "Custom Thresholds",               customBandSig, customBandSig + 1.0, customMinEr, 50.0, 1.00, 0.35, 0.00, 0, 0, 0, 0, 0, 0, 0.0, 0, 0.0, "NONE", -1, false, na, 0, 0, false, na, 0, 0, false, false, false, false, false, false, false, false))

if array.size(engines) == 7
    ProfileEngine custEng = array.get(engines, 6)
    custEng.bandSigma  := customBandSig
    custEng.outerSigma := customBandSig + 1.0
    custEng.minErPct   := customMinEr

float ph           = ta.pivothigh(high, swingLen, swingLen)
float pl           = ta.pivotlow(low, swingLen, swingLen)
int   pivotTime    = nz(time[swingLen], time)
int   pbWindowTime = nz(time[12], time)
float prevHigh     = nz(high[1], high)
float prevLow      = nz(low[1], low)

float fiveBarMoveAtr = (close - nz(close[5], close)) / math.max(safeAtr, syminfo.mintick)
bool  bearCrashGuard = fiveBarMoveAtr < -3.6 and close < open
bool  bullCrashGuard = fiveBarMoveAtr >  3.6 and close > open

if barstate.isconfirmed and array.size(engines) == 7

    for eIdx = 0 to 6
        ProfileEngine eng = array.get(engines, eIdx)
        eng.barBullTake := false
        eng.barBearTake := false
        eng.barBullSkip := false
        eng.barBearSkip := false
        eng.barTp1Evt   := false
        eng.barTp2Evt   := false
        eng.barTp3Evt   := false
        eng.barSlEvt    := false

        if eng.activePlanIdx >= 0 and eng.activePlanIdx < array.size(allPlans)
            SavedPlan cp = array.get(allPlans, eng.activePlanIdx)
            if cp.status == 0 and bar_index > cp.entryBar
                if cp.dir == 1
                    if low <= cp.activeSl
                        if cp.tp1Hit
                            cp.beHit        := true
                            cp.status       := 2
                            cp.endTime      := time
                            eng.totalTrades += 1
                            eng.winTrades   += 1
                            float bankedR    = cp.tp2Hit ? ((cp.tp1R + cp.tp2R) * 0.5) : (cp.tp1R * 0.5)
                            eng.cumNetR     += bankedR
                        else
                            cp.slHit        := true
                            cp.status       := -1
                            cp.endTime      := time
                            eng.totalTrades += 1
                            eng.lossTrades  += 1
                            eng.cumNetR     -= 1.0
                            eng.barSlEvt    := true
                    else
                        if not cp.tp1Hit and high >= cp.tp1
                            cp.tp1Hit     := true
                            eng.tp1Count  += 1
                            eng.barTp1Evt := true
                            if useBeRatchet
                                cp.activeSl := cp.entry
                        if not cp.tp2Hit and high >= cp.tp2
                            cp.tp2Hit     := true
                            eng.tp2Count  += 1
                            eng.barTp2Evt := true
                        if not cp.tp3Hit and high >= cp.tp3
                            cp.tp3Hit       := true
                            eng.tp3Count    += 1
                            eng.barTp3Evt   := true
                            cp.status       := 1
                            cp.endTime      := time
                            eng.totalTrades += 1
                            eng.winTrades   += 1
                            eng.cumNetR     += cp.tp3R
                        else if (bar_index - cp.entryBar) >= 60
                            cp.status       := cp.tp1Hit ? 2 : 3
                            cp.endTime      := time
                            eng.totalTrades += 1
                            if cp.tp1Hit
                                eng.winTrades += 1
                                eng.cumNetR   += cp.tp1R
                            else
                                float expR = (close - cp.entry) / math.max(cp.risk, syminfo.mintick)
                                if expR >= 0.0
                                    eng.winTrades  += 1
                                else
                                    eng.lossTrades += 1
                                eng.cumNetR += expR
                else if cp.dir == -1
                    if high >= cp.activeSl
                        if cp.tp1Hit
                            cp.beHit        := true
                            cp.status       := 2
                            cp.endTime      := time
                            eng.totalTrades += 1
                            eng.winTrades   += 1
                            float bankedR    = cp.tp2Hit ? ((cp.tp1R + cp.tp2R) * 0.5) : (cp.tp1R * 0.5)
                            eng.cumNetR     += bankedR
                        else
                            cp.slHit        := true
                            cp.status       := -1
                            cp.endTime      := time
                            eng.totalTrades += 1
                            eng.lossTrades  += 1
                            eng.cumNetR     -= 1.0
                            eng.barSlEvt    := true
                    else
                        if not cp.tp1Hit and low <= cp.tp1
                            cp.tp1Hit     := true
                            eng.tp1Count  += 1
                            eng.barTp1Evt := true
                            if useBeRatchet
                                cp.activeSl := cp.entry
                        if not cp.tp2Hit and low <= cp.tp2
                            cp.tp2Hit     := true
                            eng.tp2Count  += 1
                            eng.barTp2Evt := true
                        if not cp.tp3Hit and low <= cp.tp3
                            cp.tp3Hit       := true
                            eng.tp3Count    += 1
                            eng.barTp3Evt   := true
                            cp.status       := 1
                            cp.endTime      := time
                            eng.totalTrades += 1
                            eng.winTrades   += 1
                            eng.cumNetR     += cp.tp3R
                        else if (bar_index - cp.entryBar) >= 60
                            cp.status       := cp.tp1Hit ? 2 : 3
                            cp.endTime      := time
                            eng.totalTrades += 1
                            if cp.tp1Hit
                                eng.winTrades += 1
                                eng.cumNetR   += cp.tp1R
                            else
                                float expR = (cp.entry - close) / math.max(cp.risk, syminfo.mintick)
                                if expR >= 0.0
                                    eng.winTrades  += 1
                                else
                                    eng.lossTrades += 1
                                eng.cumNetR += expR

    if bullAnchorActive
        bullSumWP  += barWeight * hlc3
        bullSumWP2 += barWeight * hlc3 * hlc3
        bullSumW   += barWeight
        bullAvwap  := bullSumWP / math.max(bullSumW, 1e-9)
        float bVar  = math.max(0.0, (bullSumWP2 / math.max(bullSumW, 1e-9)) - (bullAvwap * bullAvwap))
        bullStd    := math.max(math.sqrt(bVar), safeAtr * 0.25)
        if na(bullImpHigh) or high >= bullImpHigh
            bullImpHigh     := high
            bullImpHighTime := time
        if not bullImpArmed and (bullImpHigh - bullAnchorPrice) >= minImpulseAtr * safeAtr
            bullImpArmed := true
        if close < bullAnchorPrice or close < (bullAvwap - 2.60 * bullStd)
            bullAnchorActive := false
            bullImpArmed     := false
            for eIdx = 0 to 6
                ProfileEngine eng = array.get(engines, eIdx)
                eng.bullInZone := false

    if bearAnchorActive
        bearSumWP  += barWeight * hlc3
        bearSumWP2 += barWeight * hlc3 * hlc3
        bearSumW   += barWeight
        bearAvwap  := bearSumWP / math.max(bearSumW, 1e-9)
        float sVar  = math.max(0.0, (bearSumWP2 / math.max(bearSumW, 1e-9)) - (bearAvwap * bearAvwap))
        bearStd    := math.max(math.sqrt(sVar), safeAtr * 0.25)
        if na(bearImpLow) or low <= bearImpLow
            bearImpLow     := low
            bearImpLowTime := time
        if not bearImpArmed and (bearAnchorPrice - bearImpLow) >= minImpulseAtr * safeAtr
            bearImpArmed := true
        if close > bearAnchorPrice or close > (bearAvwap + 2.60 * bearStd)
            bearAnchorActive := false
            bearImpArmed     := false
            for eIdx = 0 to 6
                ProfileEngine eng = array.get(engines, eIdx)
                eng.bearInZone := false

    int pBar = bar_index - swingLen
    ProfileEngine balRef = array.get(engines, 0)

    if not na(pl) and pBar >= 0
        bool replaceBull = not bullAnchorActive or pl < bullAnchorPrice or balRef.bullPbUsed >= maxPbPerAnchor or (bullImpArmed and pl > bullAnchorPrice and (high - pl) >= minImpulseAtr * safeAtr)
        if replaceBull and close > pl
            float sWP  = 0.0
            float sWP2 = 0.0
            float sW   = 0.0
            float mxHi = high
            int   mxTm = time
            for i = 0 to swingLen
                int   k     = swingLen - i
                float spanK = math.max(nz(high[k], high) - nz(low[k], low), syminfo.mintick)
                float wk    = hasRealVol ? math.max(nz(volume[k]), 1e-6) : math.max(spanK / math.max(safeAtr, syminfo.mintick), 0.1)
                float pk    = (nz(high[k], high) + nz(low[k], low) + nz(close[k], close)) / 3.0
                sWP  += wk * pk
                sWP2 += wk * pk * pk
                sW   += wk
                if nz(high[k], high) >= mxHi
                    mxHi := nz(high[k], high)
                    mxTm := nz(time[k], time)
            bullAnchorActive := true
            bullAnchorTime   := pivotTime
            bullAnchorBar    := pBar
            bullAnchorPrice  := pl
            bullSumWP        := sWP
            bullSumWP2       := sWP2
            bullSumW         := sW
            bullAvwap        := sWP / math.max(sW, 1e-9)
            float vB          = math.max(0.0, (sWP2 / math.max(sW, 1e-9)) - (bullAvwap * bullAvwap))
            bullStd          := math.max(math.sqrt(vB), safeAtr * 0.25)
            bullImpHigh      := mxHi
            bullImpHighTime  := mxTm
            bullImpArmed     := (mxHi - pl) >= minImpulseAtr * safeAtr
            for eIdx = 0 to 6
                ProfileEngine eng = array.get(engines, eIdx)
                eng.bullInZone := false
                eng.bullPbLow  := na
                eng.bullPbTime := pivotTime
                eng.bullPbUsed := 0

    if not na(ph) and pBar >= 0
        bool replaceBear = not bearAnchorActive or ph > bearAnchorPrice or balRef.bearPbUsed >= maxPbPerAnchor or (bearImpArmed and ph < bearAnchorPrice and (ph - low) >= minImpulseAtr * safeAtr)
        if replaceBear and close < ph
            float sWP  = 0.0
            float sWP2 = 0.0
            float sW   = 0.0
            float mnLo = low
            int   mnTm = time
            for i = 0 to swingLen
                int   k     = swingLen - i
                float spanK = math.max(nz(high[k], high) - nz(low[k], low), syminfo.mintick)
                float wk    = hasRealVol ? math.max(nz(volume[k]), 1e-6) : math.max(spanK / math.max(safeAtr, syminfo.mintick), 0.1)
                float pk    = (nz(high[k], high) + nz(low[k], low) + nz(close[k], close)) / 3.0
                sWP  += wk * pk
                sWP2 += wk * pk * pk
                sW   += wk
                if nz(low[k], low) <= mnLo
                    mnLo := nz(low[k], low)
                    mnTm := nz(time[k], time)
            bearAnchorActive := true
            bearAnchorTime   := pivotTime
            bearAnchorBar    := pBar
            bearAnchorPrice  := ph
            bearSumWP        := sWP
            bearSumWP2       := sWP2
            bearSumW         := sW
            bearAvwap        := sWP / math.max(sW, 1e-9)
            float vS          = math.max(0.0, (sWP2 / math.max(sW, 1e-9)) - (bearAvwap * bearAvwap))
            bearStd          := math.max(math.sqrt(vS), safeAtr * 0.25)
            bearImpLow       := mnLo
            bearImpLowTime   := mnTm
            bearImpArmed     := (ph - mnLo) >= minImpulseAtr * safeAtr
            for eIdx = 0 to 6
                ProfileEngine eng = array.get(engines, eIdx)
                eng.bearInZone := false
                eng.bearPbHigh := na
                eng.bearPbTime := pivotTime
                eng.bearPbUsed := 0

    if bullAnchorActive and bullImpArmed and not (bearAnchorActive and bearImpArmed)
        activeTrendBias := 1
    else if bearAnchorActive and bearImpArmed and not (bullAnchorActive and bullImpArmed)
        activeTrendBias := -1
    else if bullAnchorActive and bullImpArmed and bearAnchorActive and bearImpArmed
        activeTrendBias := bullAnchorBar >= bearAnchorBar ? 1 : -1
    else if bullAnchorActive
        activeTrendBias := 1
    else if bearAnchorActive
        activeTrendBias := -1
    else
        activeTrendBias := 0

    for eIdx = 0 to 6
        ProfileEngine eng = array.get(engines, eIdx)
        int openDir = -99
        if eng.activePlanIdx >= 0 and eng.activePlanIdx < array.size(allPlans)
            SavedPlan curP = array.get(allPlans, eng.activePlanIdx)
            if curP.status == 0
                openDir := curP.dir

        if bullAnchorActive and bullImpArmed and eng.bullPbUsed < maxPbPerAnchor and not na(bullAvwap)
            float bullUpperBand = bullAvwap + eng.bandSigma * bullStd
            float bullLowerDef  = bullAvwap - eng.outerSigma * bullStd
            if low <= bullUpperBand and close >= bullLowerDef and close > bullAnchorPrice and high < bullImpHigh
                if not eng.bullInZone
                    eng.bullInZone := true
                    eng.bullPbLow  := low
                    eng.bullPbTime := time
                else if low < nz(eng.bullPbLow, low)
                    eng.bullPbLow  := low
            else if close < bullLowerDef
                eng.bullInZone := false

            bool reclaimLong = eng.bullInZone and close > bullAvwap and close > open and close >= (prevHigh - 0.20 * safeAtr)
            if reclaimLong and openDir != 1
                float impLeg   = math.max(bullImpHigh - bullAnchorPrice, safeAtr * 0.5)
                float pbDepth  = (bullImpHigh - nz(eng.bullPbLow, low)) / impLeg
                bool  passEr   = erPct >= eng.minErPct
                bool  passQual = bullQualScore >= eng.minQual
                bool  passAct  = relActivity >= eng.minRelAct
                bool  passDep  = pbDepth >= 0.12 and pbDepth <= 0.85

                if passEr and passQual and passAct and passDep and not bearCrashGuard
                    eng.barBullTake := true
                    eng.lastSigDir  := 1
                    eng.lastSigQual := bullQualScore
                    eng.lastSigText := "BUY (AVWAP · " + str.tostring(bullQualScore, "#") + "%)"
                else
                    eng.barBullSkip := true
                    eng.bullInZone  := false
                    eng.lastSigText := "SKIP (CHOP · " + str.tostring(erPct, "#") + "%)"

        if bearAnchorActive and bearImpArmed and eng.bearPbUsed < maxPbPerAnchor and not na(bearAvwap) and not eng.barBullTake
            float bearLowerBand = bearAvwap - eng.bandSigma * bearStd
            float bearUpperDef  = bearAvwap + eng.outerSigma * bearStd
            if high >= bearLowerBand and close <= bearUpperDef and close < bearAnchorPrice and low > bearImpLow
                if not eng.bearInZone
                    eng.bearInZone := true
                    eng.bearPbHigh := high
                    eng.bearPbTime := time
                else if high > nz(eng.bearPbHigh, high)
                    eng.bearPbHigh := high
            else if close > bearUpperDef
                eng.bearInZone := false

            bool reclaimShort = eng.bearInZone and close < bearAvwap and close < open and close <= (prevLow + 0.20 * safeAtr)
            if reclaimShort and o

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