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

ZoneLens

indicator zonelens - order blocks, fair value gaps and market structure for tradingview.pine
Вы автор или правообладатель?

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

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

О программе

ZoneLens — индикатор для TradingView (Pine Script v6), отображающий на графике зоны заказов (Order Blocks) и справедливые пробелы (Fair Value Gaps) в обоих направлениях, а также структурные уровни рынка BOS и ChoCH. Индикатор включает визуализацию трендового канала на основе классического канала Келтнера, экспоненциальные скользящие средние EMA Fast/Slow, зоны повторных тестов и уровни свингов.

Пользователь может настраивать отображение каждого элемента через логические переключатели, выбирать цвета, глубину поиска зон и количество отображаемых зон на сторону. Доступен режим отображения только в видимом диапазоне графика и режим агрессивной/подтверждённой индикации зон.

Индикатор поддерживает оповещения TradingView для касаний зон, структурных уровней и заполнения пробелов. Также предоставляет экспортные значения для использования в других скриптах через Data Window.

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

НастройкаОписание
zShowObBull Отображать бычьи зоны заказов (OB+) на графике.
zShowObBear Отображать медвежьи зоны заказов (OB−) на графике.
zShowFvgBull Отображать бычьи справедливые пробелы (FVG+) на графике.
zShowFvgBear Отображать медвежьи справедливые пробелы (FVG−) на графике.
zShowBos Отображать структурные уровни BOS (Break of Structure) на графике.
zShowChoch Отображать структурные уровни ChoCH (Change of Character) на графике.
zShowEmaFast Отображать быструю EMA на графике.
zShowEmaSlow Отображать медленную EMA на графике.
zShowBg Отображать фоновый цвет по тренду канала Келтнера.
zShowBarCol Окрашивать бары по тренду канала Келтнера.
zShowKc Отображать трендовый канал (середина и полосы) на основе канала Келтнера.
zKcLength Длина SMA типичной цены и ATR для расчёта канала Келтнера.
zKcMult Множитель ATR для определения расстояния полос канала. Большее значение — меньше изменений тренда.
zUpColor Цвет баров и канала при восходящем тренде.
zDownColor Цвет баров и канала при нисходящем тренде.
zBgTransp Прозрачность фонового цвета трендового канала (0–100).
swingL Количество баров слева для определения свинга прорыва.
swingR Количество баров справа для определения свинга прорыва. Меньшие значения обнаруживают новые структурные уровни быстрее.
swingMaxAgeBars Максимальный возраст свинга в барах. 0 отключает истечение старых свингов.
breakoutSource Источник прорыва: Close — для прорыва требуется закрытие свечи за уровнем, Wick — достаточно пересечения фитилем.
chochScalpPreset Предустановка ChoCH Scalp Fast: breakoutSource=Wick, chochSignalMode=Ping (Fast). При активной предустановке Fast+Safer приоритет у Fast+Safer.
chochScalpSaferPreset Предустановка ChoCH Fast+Safer: breakoutSource=Wick, chochSignalMode=Ping+Verify. Safer за счёт дополнительной проверки.
chochSignalMode Ручной выбор режима сигнала ChoCH: Ping (Fast), Verify (Safer) или Ping+Verify. Применяется, когда ни одна предустановка не активна.
emaFastLen Период быстрой экспоненциальной скользящей средней.
emaSlowLen Период медленной экспоненциальной скользящей средней.
zSignalMode Режим сигнала зон: Confirmed only — зоны ломаются и заполняются по закрытию баров; Aggressive live — по максимумам/минимумам, также внутри формирующегося бара.
zRenderVisibleOnly Отображать зоны только в видимом диапазоне графика.
zBullObCss Цвет заливки бычьих зон заказов (OB+).
zBullObCssLine Цвет линий бычьих зон заказов (OB+).
zBearObCss Цвет заливки медвежьих зон заказов (OB−).
zBearObCssLine Цвет линий медвежьих зон заказов (OB−).
zObShowLast Количество отображаемых зон заказов на сторону.
zObEdges Края зоны: Wick — от фитиля до фитиля, Body — от открытия до закрытия.
zObDepth Глубина поиска в барах от прорыва для поиска последней противоположной свечи.
zObFilterMinMult Минимальный размер зоны заказов в кратных ATR(50).
zObFilterMaxMult Максимальный размер зоны заказов в кратных ATR(50).
zObExtendUntilBroken Продлевать зоны заказов вправо до их прорыва.
zObKeepBroken Отображать прорванные зоны заказов.
zObKeepBrokenMax Максимальное количество хранимых прорванных зон заказов на сторону.
zObCssBroken Цвет заливки прорванных зон заказов.
zObMidline Отображать среднюю линию (50%) внутри зон заказов.
zObFlip Инверсия зоны после прорыва с пробелом (FVG): зона становится зоной противоположного направления в том же ценовом диапазоне.
zObHideTouched Скрывать зоны после первого касания ценой.
zObAlertDist Расстояние оповещения касания зон в кратных ATR(50). 0 — касание на уровне зоны, 0.25 — за четверть ATR до зоны.
zObHtf Таймфрейм для отображения зон заказов со старшего таймфрейма. Пустое значение — отключено.
zBullFvgCss Цвет заливки бычьих справедливых пробелов (FVG+).
zBullFvgLineCss Цвет линий бычьих справедливых пробелов (FVG+).
zBearFvgCss Цвет заливки медвежьих справедливых пробелов (FVG−).
zBearFvgLineCss Цвет линий медвежьих справедливых пробелов (FVG−).
zFvgShowLast Количество отображаемых справедливых пробелов на сторону.
zFvgExtendUntilFilled Продлевать справедливые пробелы вправо до их заполнения.
zFvgKeepFilled Отображать заполненные справедливые пробелы.
zFvgKeepFilledMax Максимальное количество хранимых заполненных пробелов на сторону.
zFvgCssFilled Цвет заливки заполненных справедливых пробелов.
zFilterInsignificantFvgs Фильтрует незначительные пробелы по минимальному размеру, заданному в настройках ATR.
zMinFvgSizeAtrLen Период ATR для определения минимального размера справедливого пробела.
zMinFvgSizeAtrMult Множитель ATR для минимального размера справедливого пробела.
zFvgFillTargetPct Процент пробела, при котором он считается заполненным (0–100).
zRtShow Отображать зоны повторных тестов (сопротивление / поддержка). Только отображение, не тестируется как правило.
zRtMin Минимальное количество тестов для отображения зоны повторных тестов.
zRtTol Допуск в кратных ATR(50) для допустимого расстояния между тестами одного уровня.
zRtAway Разделение тестов в кратных ATR(50). Новый тест считается только после закрытия на таком расстоянии от уровня.
zRtLook Глубина просмотра в барах для поиска зон повторных тестов.
zRtResCol Цвет зоны сопротивления (повторные тесты сверху).
zRtSupCol Цвет зоны поддержки (повторные тесты снизу).
zSwShow Отображать текущие уровни свинга высокого и низкого как линии на графике.

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

indicator("ZoneLens", overlay=true, max_bars_back=500, max_labels_count=500, max_lines_count=500, max_boxes_count=500)

var string zgShow = "Display"
zShowObBull  = input.bool(true, "OB+ (bullish order blocks)", group=zgShow)
zShowObBear  = input.bool(true, "OB− (bearish order blocks)", group=zgShow)
zShowFvgBull = input.bool(true, "FVG+ (bullish fair value gaps)", group=zgShow)
zShowFvgBear = input.bool(true, "FVG− (bearish fair value gaps)", group=zgShow)
zShowBos     = input.bool(true, "BOS", group=zgShow)
zShowChoch   = input.bool(true, "ChoCH", group=zgShow)
zShowEmaFast = input.bool(true, "EMA Fast", group=zgShow)
zShowEmaSlow = input.bool(true, "EMA Slow", group=zgShow)
zShowBg      = input.bool(true, "Background by trend", group=zgShow)
zShowBarCol  = input.bool(true, "Color bars by trend", group=zgShow)
zShowKc      = input.bool(true, "Trend channel (midline and bands)", group=zgShow)

var string zgKc = "Trend channel (Keltner)"
zKcLength = input.int(20, "Length", minval=2, group=zgKc, tooltip="Length of the SMA of the typical price and of the ATR.")
zKcMult   = input.float(2.0, "ATR factor", minval=0.1, step=0.1, group=zgKc, tooltip="Band distance in ATR. Larger = fewer trend changes.")
zUpColor   = input.color(#169c86, "Up color", group=zgKc)
zDownColor = input.color(#e0532c, "Down color", group=zgKc)
zBgTransp  = input.int(96, "Background transparency", minval=0, maxval=100, group=zgKc)

var string zgStruct = "Market structure (BOS / ChoCH)"
var string zgEma = "EMA"
swingL = input.int(5, "Breakout swing left (L)", minval=1, maxval=20, group=zgStruct)
swingR = input.int(3, "Breakout swing right (R)", minval=1, maxval=20, tooltip="Lower 'R' values detect new structure levels faster.", group=zgStruct)
swingMaxAgeBars = input.int(0, "Breakout swing max age (bars)", minval=0, maxval=2000, tooltip="0 disables expiry of old swings", group=zgStruct)
breakoutSource = input.string("Close", "Breakout Source", options=["Close", "Wick"], tooltip="Determines if a breakout requires a candle Close or just a Wick cross.", group=zgStruct)
chochScalpPreset = input.bool(false, "ChoCH Scalp Fast preset", tooltip="Preset values: breakoutSource=Wick, chochSignalMode=Ping (Fast), swingREff=max(swingR,1). Note: if Fast+Safer is also enabled, Fast+Safer takes precedence.", group=zgStruct)
chochScalpSaferPreset = input.bool(false, "ChoCH Fast+Safer preset", tooltip="Preset values: breakoutSource=Wick, chochSignalMode=Ping+Verify, swingREff=max(swingR,1). Safer than Fast due to additional verify confirmation.", group=zgStruct)
chochSignalMode  = input.string("Ping+Verify", "ChoCH signal mode", options=["Ping (Fast)", "Verify (Safer)", "Ping+Verify"], tooltip="Manual mode selector when no ChoCH preset is active. Preset override: Fast => Ping (Fast), Fast+Safer => Ping+Verify.", group=zgStruct)
emaFastLen = input.int(21, "EMA fast", minval=1, group=zgEma)
emaSlowLen = input.int(55, "EMA slow", minval=1, group=zgEma)
bool chochFastPresetEff = chochScalpPreset and not chochScalpSaferPreset
bool chochSaferPresetEff = chochScalpSaferPreset
int swingREff = (chochFastPresetEff or chochSaferPresetEff) ? math.max(1, swingR) : swingR
string breakoutSourceEff = (chochFastPresetEff or chochSaferPresetEff) ? "Wick" : breakoutSource
string chochSignalModeEff = chochFastPresetEff ? "Ping (Fast)" : chochSaferPresetEff ? "Ping+Verify" : chochSignalMode
emaF = ta.ema(close, emaFastLen)
emaS = ta.ema(close, emaSlowLen)

var float lastSwingHigh = na
var float lastSwingLow  = na
var int lastSwingHighBar = na
var int lastSwingLowBar  = na
ph = ta.pivothigh(high, swingL, swingREff)
pl = ta.pivotlow(low,  swingL, swingREff)
prevSwingHigh = lastSwingHigh
prevSwingLow = lastSwingLow
if not na(ph)
    lastSwingHigh := ph
    lastSwingHighBar := bar_index
if not na(pl)
    lastSwingLow := pl
    lastSwingLowBar := bar_index
if swingMaxAgeBars > 0
    if not na(lastSwingHighBar) and (bar_index - lastSwingHighBar > swingMaxAgeBars)
        lastSwingHigh := na
        lastSwingHighBar := na
    if not na(lastSwingLowBar) and (bar_index - lastSwingLowBar > swingMaxAgeBars)
        lastSwingLow := na
        lastSwingLowBar := na

bool breakHigh = false
bool breakLow  = false

bool _xoWick = ta.crossover(high, lastSwingHigh)
bool _xuWick = ta.crossunder(low, lastSwingLow)

if breakoutSourceEff == "Close"
    breakHigh := (not na(lastSwingHigh)) and (not na(prevSwingHigh)) and close > lastSwingHigh and close[1] <= lastSwingHigh[1]
    breakLow  := (not na(lastSwingLow)) and (not na(prevSwingLow)) and close < lastSwingLow  and close[1] >= lastSwingLow[1]
else // Wick
    if not na(lastSwingHigh)
        breakHigh := _xoWick
    if not na(lastSwingLow)
        breakLow  := _xuWick

breakoutLong  = not na(lastSwingHigh) and breakHigh
breakoutShort = not na(lastSwingLow)  and breakLow

var int structState = 0 // 0=Neutral, 1=Bullish, -1=Bearish
bool isChoCH_Long = false
bool isBOS_Long   = false
bool isChoCH_Short = false
bool isBOS_Short   = false
bool chochPingLong = false
bool chochPingShort = false
bool chochVerifyLong = false
bool chochVerifyShort = false

if breakoutLong
    chochPingLong := structState == -1
    if not chochPingLong
        isBOS_Long := true
    structState := 1

if breakoutShort
    chochPingShort := structState == 1
    if not chochPingShort
        isBOS_Short := true
    structState := -1

var float chochPingHighLevel = na
var float chochPingLowLevel = na
if chochPingLong
    chochPingHighLevel := lastSwingHigh
if chochPingShort
    chochPingLowLevel := lastSwingLow

chochVerifyLong := chochPingLong[1] and (not na(chochPingHighLevel[1]) and close > chochPingHighLevel[1])
chochVerifyShort := chochPingShort[1] and (not na(chochPingLowLevel[1]) and close < chochPingLowLevel[1])
isChoCH_Long := chochSignalModeEff == "Ping (Fast)" ? chochPingLong : chochSignalModeEff == "Verify (Safer)" ? chochVerifyLong : (chochPingLong or chochVerifyLong)
isChoCH_Short := chochSignalModeEff == "Ping (Fast)" ? chochPingShort : chochSignalModeEff == "Verify (Safer)" ? chochVerifyShort : (chochPingShort or chochVerifyShort)

labelChoCH_L = isChoCH_Long
labelChoCH_S = isChoCH_Short
labelBOS_L = isBOS_Long
labelBOS_S = isBOS_Short

const int Z_ATR_LEN_MAIN = 50
const int Z_DEFAULT_OB_SHOW_LAST = 2
const int Z_DEFAULT_FVG_SHOW_LAST = 2
const int Z_DEFAULT_KEEP_HISTORY = 1
const float Z_DEFAULT_OB_FILTER_MIN_MULT = 0.2
const float Z_DEFAULT_OB_FILTER_MAX_MULT = 3.0
const float Z_DEFAULT_FVG_MIN_SIZE_MULT = 0.5
const float Z_DEFAULT_FVG_FILL_TARGET_PCT = 60.0

enum ZSignalMode
    CONFIRMED_ONLY = 'Confirmed only'
    AGGRESSIVE_LIVE = 'Aggressive live'

var string zgCalc = "OB / FVG – calculation"
var ZSignalMode zSignalMode = input.enum(ZSignalMode.CONFIRMED_ONLY, "Signal Mode", group=zgCalc, tooltip="Confirmed only: zones break and gaps fill on bar closes. Aggressive live: on highs/lows, also within the forming bar.")
var bool zRenderVisibleOnly = input.bool(true, "Render visible range only", group=zgCalc)

var string zgOb = "Order blocks"
var zBullObCss = input.color(color.new(#169c86, 74), "OB+", group=zgOb, inline="obbull")
var zBullObCssLine = input.color(color.new(#169c86, 5), "", group=zgOb, inline="obbull")
var zBearObCss = input.color(color.new(#e0532c, 74), "OB−", group=zgOb, inline="obbear")
var zBearObCssLine = input.color(color.new(#e0532c, 5), "", group=zgOb, inline="obbear")
var zObShowLast = input.int(Z_DEFAULT_OB_SHOW_LAST, "Zones shown per side", minval=1, group=zgOb)
var string zObEdges = input.string("Wick", "Zone edges", options=["Wick", "Body"], group=zgOb, tooltip="Wick: high to low of the order block candle. Body: open to close.")
var int zObDepth = input.int(10, "Search depth (bars)", minval=1, maxval=50, group=zgOb, tooltip="How far back from the break the last opposite candle is searched.")
var zObFilterMinMult = input.float(Z_DEFAULT_OB_FILTER_MIN_MULT, "Min size × ATR(50)", minval=0, step=0.1, group=zgOb, inline="obf")
var zObFilterMaxMult = input.float(Z_DEFAULT_OB_FILTER_MAX_MULT, "max", minval=0.1, step=0.1, group=zgOb, inline="obf")
var zObExtendUntilBroken = input.bool(true, "Extend right until broken", group=zgOb)
var zObKeepBroken = input.bool(true, "Show broken zones", group=zgOb, inline="obkb")
var zObKeepBrokenMax = input.int(Z_DEFAULT_KEEP_HISTORY, "", minval=0, group=zgOb, inline="obkb")
var zObCssBroken = input.color(color.new(#787b86, 88), "", group=zgOb, inline="obkb")
var zObLineCssBroken = color.new(zObCssBroken, 50)
var bool zObMidline = input.bool(true, "Midline (50 %)", group=zgOb)
var bool zObFlip = input.bool(true, "Flip after a gap (FVG)", group=zgOb, tooltip="A zone that price breaks with a fair value gap (same minimum size as the FVG settings) becomes a zone of the opposite direction at the same price range, starting at the break.")
var bool zObHideTouched = input.bool(true, "Hide after first touch", group=zgOb, tooltip="A zone is no longer drawn once price has reached it (the edge seen from the side it was created on).")
var float zObAlertDist = input.float(0.0, "Touch alert distance × ATR(50)", minval=0, step=0.05, group=zgOb, tooltip="All \"touched\" alerts (order blocks, gaps, higher-timeframe zones) fire on the first bar that comes this close to a zone (0 = reaches it). 0.25 = already a quarter ATR before the zone.")
var string zObHtf = input.timeframe("", "Zones from higher timeframe", group=zgOb, tooltip="Empty = off. Shows the two newest active order blocks per side of this timeframe, computed on its bars with the same rules, values of its last completed bar (no repainting).")

var string zgFvg = "Fair value gaps"
var zBullFvgCss = input.color(color.new(#3d8bfd, 82), "FVG+", group=zgFvg, inline="fvgbull")
var zBullFvgLineCss = input.color(color.new(#3d8bfd, 5), "", group=zgFvg, inline="fvgbull")
var zBearFvgCss = input.color(color.new(#c8861e, 82), "FVG−", group=zgFvg, inline="fvgbear")
var zBearFvgLineCss = input.color(color.new(#c8861e, 5), "", group=zgFvg, inline="fvgbear")
var zFvgShowLast = input.int(Z_DEFAULT_FVG_SHOW_LAST, "Gaps shown per side", minval=1, group=zgFvg)
var zFvgExtendUntilFilled = input.bool(true, "Extend right until filled", group=zgFvg)
var zFvgKeepFilled = input.bool(true, "Show filled gaps", group=zgFvg, inline="fvgkf")
var zFvgKeepFilledMax = input.int(Z_DEFAULT_KEEP_HISTORY, "", minval=1, group=zgFvg, inline="fvgkf")
var zFvgCssFilled = input.color(color.new(#787b86, 85), "", group=zgFvg, inline="fvgkf")
var zFvgLineCssFilled = color.new(zFvgCssFilled, 50)
var zFilterInsignificantFvgs = input.bool(true, "Min gap size", group=zgFvg, inline="fvgmin")
var zMinFvgSizeAtrLen = input.int(Z_ATR_LEN_MAIN, "ATR length", minval=1, group=zgFvg, inline="fvgmin")
var zMinFvgSizeAtrMult = input.float(Z_DEFAULT_FVG_MIN_SIZE_MULT, "× ATR", minval=0, step=0.1, group=zgFvg, inline="fvgmin")
var float zFvgFillTargetPct = input.float(Z_DEFAULT_FVG_FILL_TARGET_PCT, "Filled at % of the gap", minval=0, maxval=100, step=5, group=zgFvg)

bool zBreakOnClose = zSignalMode == ZSignalMode.CONFIRMED_ONLY
int zVisibleLeftTime = zRenderVisibleOnly ? chart.left_visible_bar_time : na
int zVisibleRightTime = zRenderVisibleOnly ? chart.right_visible_bar_time : na

znStableAtr(simple int n) =>
    float znAtrFull = ta.atr(n)
    float znTrSum = ta.cum(ta.tr(true))
    bar_index < n ? znTrSum / (bar_index + 1) : znAtrFull

float znAtr50 = znStableAtr(Z_ATR_LEN_MAIN)
float znAtrFvg = znStableAtr(zMinFvgSizeAtrLen)
float znFvgThreshold = zFilterInsignificantFvgs ? znAtrFvg * zMinFvgSizeAtrMult : 0.0
float znFillRatio = math.max(0.0, math.min(1.0, zFvgFillTargetPct / 100))
bool znBreakAllowed = zBreakOnClose ? barstate.isconfirmed : true

type ZnOb
    int dir
    int t1          // open time of the order block candle (flipped zones: open time of the flip bar)
    int tBreak      // close time of the bar that created the zone
    float top
    float bottom
    bool broken = false
    int brokenTime = na
    bool flipped = false   // created by a break with a gap (opposite direction of the broken zone)
    bool touched = false   // price reached the zone after it was created
    bool alerted = false   // touch alert already raised for this zone

type ZnObBook
    array<ZnOb> bull
    array<ZnOb> bear
    array<ZnOb> bullBroken
    array<ZnOb> bearBroken

const int ZN_OB_MEMORY = 100

znObBookNew() =>
    ZnObBook.new(array.new<ZnOb>(), array.new<ZnOb>(), array.new<ZnOb>(), array.new<ZnOb>())

znOppositeCandle(int dir, int depth) =>
    int found = na
    for k = 1 to depth
        if dir == 1 ? close[k] < open[k] : close[k] > open[k]
            found := k
            break
    found

znObTouches(array<ZnOb> act, int dir, float alertDist) =>
    bool alert = false
    bool alertFlipped = false
    for o in act
        if not o.alerted and (dir == 1 ? low <= o.top + alertDist : high >= o.bottom - alertDist)
            o.alerted := true
            alert := true
            if o.flipped
                alertFlipped := true
        if not o.touched and (dir == 1 ? low <= o.top : high >= o.bottom)
            o.touched := true
    [alert, alertFlipped]

znObBreaks(array<ZnOb> act, array<ZnOb> done, int dir, float fvgThr, bool closeRule, int keepBroken) =>
    float src = closeRule ? close : dir == 1 ? low : high
    bool gapWithBreak = dir == 1 ? low[2] - high > fvgThr : low - high[2] > fvgThr
    array<ZnOb> flips = array.new<ZnOb>()
    int n = array.size(act)
    if n > 0
        for i = n - 1 to 0
            ZnOb o = array.get(act, i)
            if dir == 1 ? src < o.bottom : src > o.top
                o.broken := true
                o.brokenTime := time_close
                array.remove(act, i)
                array.push(done, o)
                if zObFlip and barstate.isconfirmed and gapWithBreak
                    array.unshift(flips, ZnOb.new(-dir, time, time_close, o.top, o.bottom, flipped = true))
    while array.size(done) > keepBroken
        array.shift(done)
    flips

znObOverlapsAny(array<ZnOb> act, float top, float bottom) =>
    bool hit = false
    for z in act
        if z.bottom < top and z.top > bottom
            hit := true
            break
    hit

znObAddFlips(array<ZnOb> act, array<ZnOb> flips) =>
    for f in flips
        if not znObOverlapsAny(act, f.top, f.bottom)
            array.push(act, f)
            if array.size(act) > ZN_OB_MEMORY
                array.shift(act)

znObAdd(array<ZnOb> act, int dir, float atr) =>
    int k = znOppositeCandle(dir, zObDepth)
    if not na(k)
        float top = zObEdges == "Wick" ? high[k] : math.max(open[k], close[k])
        float bottom = zObEdges == "Wick" ? low[k] : math.min(open[k], close[k])
        float size = top - bottom
        bool sameCandle = array.size(act) > 0 and array.get(act, array.size(act) - 1).t1 == time[k]
        if not sameCandle and size >= zObFilterMinMult * atr and size <= zObFilterMaxMult * atr
            array.push(act, ZnOb.new(dir, time[k], time_close, top, bottom))
            if array.size(act) > ZN_OB_MEMORY
                array.shift(act)

znObStep(ZnObBook b, bool brkLong, bool brkShort, float atr, float fvgThr, float alertDist, bool allowed, bool closeRule, int keepBroken) =>
    bool bullAlert = false
    bool bearAlert = false
    bool bullFlipAlert = false
    bool bearFlipAlert = false
    if allowed
        [ba, bf] = znObTouches(b.bull, 1, alertDist)
        [sa, sf] = znObTouches(b.bear, -1, alertDist)
        bullAlert := ba
        bullFlipAlert := bf
        bearAlert := sa
        bearFlipAlert := sf
        array<ZnOb> toBear = znObBreaks(b.bull, b.bullBroken, 1, fvgThr, closeRule, keepBroken)
        array<ZnOb> toBull = znObBreaks(b.bear, b.bearBroken, -1, fvgThr, closeRule, keepBroken)
        znObAddFlips(b.bear, toBear)
        znObAddFlips(b.bull, toBull)
    if barstate.isconfirmed and brkLong
        znObAdd(b.bull, 1, atr)
    if barstate.isconfirmed and brkShort
        znObAdd(b.bear, -1, atr)
    [bullAlert, bearAlert, bullFlipAlert, bearFlipAlert]

var ZnObBook znBook = znObBookNew()
[znBullTouchAlert, znBearTouchAlert, znBullFlipTouchAlert, znBearFlipTouchAlert] = znObStep(znBook, breakoutLong, breakoutShort, znAtr50,
     znFvgThreshold, zObAlertDist * znAtr50, znBreakAllowed, zBreakOnClose, zObKeepBrokenMax)

znObPick(array<ZnOb> act, int nth, bool skipTouched) =>
    ZnOb found = na
    int seen = 0
    int n = array.size(act)
    if n > 0
        for i = n - 1 to 0
            ZnOb o = array.get(act, i)
            if not (skipTouched and o.touched)
                if seen == nth
                    found := o
                    break
                seen += 1
    found

znObVals(ZnOb o) =>
    float t = na
    float top = na
    float bottom = na
    float flipped = na
    if not na(o)
        t := o.t1
        top := o.top
        bottom := o.bottom
        flipped := o.flipped ? 1 : 0
    [t, top, bottom, flipped]

znHtfZones() =>
    var float hi = na
    var float lo = na
    var int hiBar = na
    var int loBar = na
    float sph = ta.pivothigh(high, swingL, swingREff)
    float spl = ta.pivotlow(low, swingL, swingREff)
    float prevHi = hi
    float prevLo = lo
    if not na(sph)
        hi := sph
        hiBar := bar_index
    if not na(spl)
        lo := spl
        loBar := bar_index
    if swingMaxAgeBars > 0
        if not na(hiBar) and bar_index - hiBar > swingMaxAgeBars
            hi := na
            hiBar := na
        if not na(loBar) and bar_index - loBar > swingMaxAgeBars
            lo := na
            loBar := na
    bool xoWick = ta.crossover(high, hi)
    bool xuWick = ta.crossunder(low, lo)
    bool brkL = breakoutSourceEff == "Close" ? (not na(hi) and not na(prevHi) and close > hi and close[1] <= hi[1]) : (not na(hi) and xoWick)
    bool brkS = breakoutSourceEff == "Close" ? (not na(lo) and not na(prevLo) and close < lo and close[1] >= lo[1]) : (not na(lo) and xuWick)
    float atr = znStableAtr(Z_ATR_LEN_MAIN)
    float fvgThr = zFilterInsignificantFvgs ? znStableAtr(zMinFvgSizeAtrLen) * zMinFvgSizeAtrMult : 0.0
    var ZnObBook bk = znObBookNew()
    znObStep(bk, brkL, brkS, atr, fvgThr, 0.0, zBreakOnClose ? barstate.isconfirmed : true, zBreakOnClose, 0)
    ZnOb b1 = znObPick(bk.bull, 0, zObHideTouched)
    ZnOb b2 = znObPick(bk.bull, 1, zObHideTouched)
    ZnOb s1 = znObPick(bk.bear, 0, zObHideTouched)
    ZnOb s2 = znObPick(bk.bear, 1, zObHideTouched)
    [b1t, b1u, b1d, b1f] = znObVals(b1)
    [b2t, b2u, b2d, b2f] = znObVals(b2)
    [s1t, s1u, s1d, s1f] = znObVals(s1)
    [s2t, s2u, s2d, s2f] = znObVals(s2)

    [b1t[1], b1u[1], b1d[1], b1f[1], b2t[1], b2u[1], b2d[1], b2f[1], s1t[1], s1u[1], s1d[1], s1f[1], s2t[1], s2u[1], s2d[1], s2f[1]]

bool znHtfOn = zObHtf != "" and timeframe.in_seconds(zObHtf) > timeframe.in_seconds(timeframe.period)
var array<float> znHtf = array.new<float>(16, na)
if znHtfOn
    [h1t, h1u, h1d, h1f, h2t, h2u, h2d, h2f, l1t, l1u, l1d, l1f, l2t, l2u, l2d, l2f] =
         request.security(syminfo.tickerid, zObHtf, znHtfZones(), lookahead = barmerge.lookahead_on)
    znHtf := array.from(h1t, h1u, h1d, h1f, h2t, h2u, h2d, h2f, l1t, l1u, l1d, l1f, l2t, l2u, l2d, l2f)

var array<string> znHtfAlerted = array.new<string>()
znHtfTouch(int i, int dir, float alertDist) =>
    bool hit = false
    float t = array.get(znHtf, i)
    if not na(t)
        float top = array.get(znHtf, i + 1)
        float bottom = array.get(znHtf, i + 2)
        string key = str.tostring(dir) + "*" + str.tostring(t) + "*" + str.tostring(top) + "*" + str.tostring(bottom)
        if not array.includes(znHtfAlerted, key) and (dir == 1 ? low <= top + alertDist : high >= bottom - alertDist)
            array.push(znHtfAlerted, key)
            if array.size(znHtfAlerted) > 50
                array.shift(znHtfAlerted)
            hit := true
    hit

bool znHtfBullTouchAlert = false
bool znHtfBearTouchAlert = false
if znHtfOn and znBreakAllowed
    float d = zObAlertDist * znAtr50
    bool b1 = znHtfTouch(0, 1, d)
    bool b2 = znHtfTouch(4, 1, d)
    bool s1 = znHtfTouch(8, -1, d)
    bool s2 = znHtfTouch(12, -1, d)
    znHtfBullTouchAlert := b1 or b2
    znHtfBearTouchAlert := s1 or s2

type ZnGap
    int dir
    int t1
    int i1
    int t2
    int i2
    float gTop
    float gBot
    float thr
    float target
    float level
    float share
    float vol
    bool filled = false
    int fillTime = na
    bool alerted = false   // touch alert already raised for this gap

var array<ZnGap> znBullGaps = array.new<ZnGap>()
var array<ZnGap> znBearGaps = array.new<ZnGap>()
var array<ZnGap> znBullFilled = array.new<ZnGap>()
var array<ZnGap> znBearFilled = array.new<ZnGap>()
var table wm = table.new(position.bottom_right, 1, 1)
if barstate.isfirst
    table.cell(wm, 0, 0, "Telegram

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