WAE 1H Zones + WAE 5m Signals + SMC HTF v2

indicator("WAE 1H Zones + WAE 5m Signals + SMC HTF v2", overlay=true, max_labels_count=500, max_lines_count=500, max_boxes_count=200)

htf      = input.timeframe("60", "Zone Frame (60 = Hour)")
zoneMode = input.string("Direct (like the Hour chart)", "Zone Method",
     options=["Direct (like the Hour chart)", "Closed Hour (fixed)"])
etf      = input.timeframe("5", "Entry Frame (5 = Five minutes)")

sensitivity   = input.int(150,   "Sensitivity")
fastLength    = input.int(20,    "FastEMA Length")
slowLength    = input.int(40,    "SlowEMA Length")
channelLength = input.int(20,    "BB Channel Length")
mult          = input.float(2.0, "BB Stdev Multiplier")

greenColor = input.color(color.new(color.green, 75), "Green zone color")
redColor   = input.color(color.new(color.red,   75), "Red zone color")

grpS      = "SMC - Market Structure"
biasTF    = input.timeframe("240", "Overall Trend Frame (Bias)", group=grpS)
biasLen   = input.int(5, "Swing Length - Trend Frame", minval=2, group=grpS)
trigTF    = input.timeframe("60",  "Events Frame (BOS / CHoCH / Sweep / Zones)", group=grpS)
trigLen   = input.int(5, "Swing Length - Events Frame", minval=2, group=grpS)
showStruct = input.bool(true,  "Draw BOS / CHoCH (lines + labels) and Sweep", group=grpS)
showLvls   = input.bool(true,  "Show last high/low on Events Frame", group=grpS)
showDash   = input.bool(true,  "Show Info Panel", group=grpS)

grpT      = "SMC - Trade Conditions"
useBias    = input.bool(true,  "Trade only in the direction of the larger frame (Bias)", group=grpT)
reqTrigger = input.bool(true,  "Require liquidity/structure event before entry (WAE trades)", group=grpT)
useSweep   = input.bool(true,  "Treat liquidity sweep (Sweep) as a trigger", group=grpT)
useChoch   = input.bool(true,  "Treat CHoCH/MSS as a trigger", group=grpT)
useBos     = input.bool(true,  "Treat BOS as a trigger (trend continuation)", group=grpT)
armBars    = input.int(60, "Trigger validity period (number of chart candles)", minval=1, group=grpT)

grpZ      = "SMC - OB / Breaker / FVG Zones"
showOB     = input.bool(true, "Order Block", group=grpZ)
showBB     = input.bool(true, "Breaker Block (OB failed and reversed)", group=grpZ)
showFVG    = input.bool(true, "FVG", group=grpZ)
fvgMin     = input.float(0.1, "Minimum FVG size (x ATR)", minval=0.0, step=0.05, group=grpZ)
obBack     = input.int(40, "Maximum OB search depth (frame candles)", minval=5, group=grpZ)
maxZones   = input.int(30, "Maximum number of zones on the chart", minval=5, maxval=80, group=grpZ)
zoneReqWae = input.bool(false, "Zone signal requires WAE zone confirmation", group=grpZ)

grpF      = "RSI / Elliott Filters"
rsiMode = input.string("Prevent opposite saturation", "RSI Mode",
     options=["Disabled", "Prevent opposite saturation", "Require saturation in favor of the trade"], group=grpF)
rsiTF   = input.timeframe("", "RSI Frame (empty = chart frame)", group=grpF)
rsiLen  = input.int(14, "RSI Length", minval=2, group=grpF)
rsiOB   = input.int(70, "RSI Buy Saturation", group=grpF)
rsiOS   = input.int(30, "RSI Sell Saturation", group=grpF)
ewMode  = input.string("Prevent reversal", "Elliott Mode",
     options=["Disabled", "Prevent reversal", "Requires confirmation"], group=grpF)
ewTF    = input.timeframe("60", "Elliott Frame", group=grpF)
ewLen   = input.int(5, "Swing Length - Elliott", minval=2, group=grpF)

waeState(int off) =>
    deadZone  = nz(ta.rma(ta.tr(true), 100)) * 3.7
    macdNow   = ta.ema(close, fastLength) - ta.ema(close, slowLength)
    t1        = (macdNow - macdNow[1]) * sensitivity
    e1        = 2 * mult * ta.stdev(close, channelLength)
    trendUp   = t1 >= 0 ? t1 : 0
    trendDown = t1 < 0 ? -t1 : 0
    s = trendUp > e1 and trendUp > deadZone ? 1 : trendDown > e1 and trendDown > deadZone ? -1 : 0
    s[off]

liveState = request.security(syminfo.tickerid, htf, waeState(0), lookahead=barmerge.lookahead_on)
confState = request.security(syminfo.tickerid, htf, waeState(1), lookahead=barmerge.lookahead_on)
state     = zoneMode == "Direct (like the Hour chart)" ? liveState : confState

isGreen = state == 1
isRed   = state == -1

bgcolor(isGreen ? greenColor : isRed ? redColor : na)

chartSec = timeframe.in_seconds()
etfSec   = timeframe.in_seconds(etf)

chartState = waeState(0)

etfClosed  = request.security(syminfo.tickerid, etf, waeState(1), lookahead=barmerge.lookahead_on)

entryState = chartSec == etfSec ? chartState : etfClosed

sigTF = chartSec <= etfSec and chartSec < timeframe.in_seconds(htf)

callCond = isGreen and entryState == 1
putCond  = isRed   and entryState == -1

callSig = sigTF and callCond and not callCond[1] and barstate.isconfirmed
putSig  = sigTF and putCond  and not putCond[1]  and barstate.isconfirmed

plotshape(callSig, "CALL", shape.labelup,   location.belowbar, color.green, text="CALL", textcolor=color.white, size=size.small)
plotshape(putSig,  "PUT",  shape.labeldown, location.abovebar, color.red,   text="PUT",  textcolor=color.white, size=size.small)

alertcondition(callSig, "CALL", "WAE: CALL Signal")
alertcondition(putSig,  "PUT",  "WAE: PUT Signal")

biasFn(int len, int off) =>
    ph = ta.pivothigh(high, len, len)
    pl = ta.pivotlow(low,  len, len)
    var float lastH   = na
    var float lastL   = na
    var int   trend   = 0
    var bool  hBroken = false
    var bool  lBroken = false
    if not na(ph)
        lastH   := ph
        hBroken := false
    if not na(pl)
        lastL   := pl
        lBroken := false
    if not na(lastH) and not hBroken and close > lastH
        trend   := 1
        hBroken := true
    if not na(lastL) and not lBroken and close < lastL
        trend   := -1
        lBroken := true
    trend[off]

structFn(int len, int off, float fvgMinMult, int obMaxBack) =>
    ph   = ta.pivothigh(high, len, len)
    pl   = ta.pivotlow(low,  len, len)
    atrv = ta.atr(14)
    var float lastH   = na
    var float lastL   = na
    var int   lastHT  = na
    var int   lastLT  = na
    var int   lastHBI = na
    var int   lastLBI = na
    var int   trend   = 0
    var bool  hBroken = false
    var bool  lBroken = false
    var float obBuHi = na
    var float obBuLo = na
    var int   obBuT  = na
    var int   obBuN  = 0
    var float obBeHi = na
    var float obBeLo = na
    var int   obBeT  = na
    var int   obBeN  = 0
    var float fvBuHi = na
    var float fvBuLo = na
    var int   fvBuT  = na
    var int   fvBuN  = 0
    var float fvBeHi = na
    var float fvBeLo = na
    var int   fvBeT  = na
    var int   fvBeN  = 0

    if not na(ph)
        lastH   := ph
        lastHT  := time[len]
        lastHBI := bar_index - len
        hBroken := false
    if not na(pl)
        lastL   := pl
        lastLT  := time[len]
        lastLBI := bar_index - len
        lBroken := false

    bool bosUp = false
    bool bosDn = false
    bool chUp  = false
    bool chDn  = false

    bool sweepH = not na(lastH) and not hBroken and high > lastH and close <= lastH
    bool sweepL = not na(lastL) and not lBroken and low  < lastL and close >= lastL

    if not na(lastH) and not hBroken and close > lastH
        if trend == -1
            chUp := true
        else
            bosUp := true
        trend   := 1
        hBroken := true
        int lb  = na(lastLBI) ? obMaxBack : math.max(1, math.min(bar_index - lastLBI, obMaxBack))
        int idx = 0
        float mn = low
        for i = 1 to lb
            if low[i] < mn
                mn  := low[i]
                idx := i
        obBuHi := high[idx]
        obBuLo := low[idx]
        obBuT  := time[idx]
        obBuN  += 1

    if not na(lastL) and not lBroken and close < lastL
        if trend == 1
            chDn := true
        else
            bosDn := true
        trend   := -1
        lBroken := true
        int lb2  = na(lastHBI) ? obMaxBack : math.max(1, math.min(bar_index - lastHBI, obMaxBack))
        int idx2 = 0
        float mx = high
        for j = 1 to lb2
            if high[j] > mx
                mx   := high[j]
                idx2 := j
        obBeHi := high[idx2]
        obBeLo := low[idx2]
        obBeT  := time[idx2]
        obBeN  += 1

    if low > high[2] and (low - high[2]) > atrv * fvgMinMult
        fvBuHi := low
        fvBuLo := high[2]
        fvBuT  := time[2]
        fvBuN  += 1
    if high < low[2] and (low[2] - high) > atrv * fvgMinMult
        fvBeHi := low[2]
        fvBeLo := high
        fvBeT  := time[2]
        fvBeN  += 1

    [trend[off], bosUp[off], bosDn[off], chUp[off], chDn[off], sweepH[off], sweepL[off], lastH[off], lastL[off], lastHT[off], lastLT[off], obBuHi[off], obBuLo[off], obBuT[off], obBuN[off], obBeHi[off], obBeLo[off], obBeT[off], obBeN[off], fvBuHi[off], fvBuLo[off], fvBuT[off], fvBuN[off], fvBeHi[off], fvBeLo[off], fvBeT[off], fvBeN[off]]

bullImp6(float p0, float p1, float p2, float p3, float p4, float p5) =>
    p1 > p0 and p2 > p0 and p2 < p1 and p3 > p1 and p3 > p2 and p4 > p1 and p4 < p3 and p5 > p3 and p5 > p4 and (p3 - p2) >= math.min(p1 - p0, p5 - p4)

bullImp5(float p0, float p1, float p2, float p3, float p4) =>
    p1 > p0 and p2 > p0 and p2 < p1 and p3 > p1 and p3 > p2 and p4 > p1 and p4 < p3 and (p3 - p2) >= (p1 - p0)

bullImp4(float p0, float p1, float p2, float p3) =>
    p1 > p0 and p2 > p0 and p2 < p1 and p3 > p1 and (p3 - p2) >= (p1 - p0)

ewFn(int len, int off) =>
    ph = ta.pivothigh(high, len, len)
    pl = ta.pivotlow(low,  len, len)
    var array<float> pp = array.new_float()
    var array<int>   pt = array.new_int()
    var int ewDir  = 0
    var int ewCode = 0
    int   typ = 0
    float prc = na
    if not na(ph) and na(pl)
        typ := 1
        prc := ph
    else if not na(pl) and na(ph)
        typ := -1
        prc := pl
    if typ != 0
        int n0 = array.size(pt)
        bool sameType = false
        if n0 > 0
            sameType := array.get(pt, n0 - 1) == typ
        if sameType
            float lastP = array.get(pp, n0 - 1)
            if (typ == 1 and prc > lastP) or (typ == -1 and prc < lastP)
                array.set(pp, n0 - 1, prc)
        else
            array.push(pp, prc)
            array.push(pt, typ)
            if array.size(pp) > 8
                array.shift(pp)
                array.shift(pt)
        int n = array.size(pp)
        float w5 = na
        float w4 = na
        float w3 = na
        float w2 = na
        float w1 = na
        float w0 = na
        int typ6 = 0
        int typ5 = 0
        int typ4 = 0
        if n >= 1
            w5 := array.get(pp, n - 1)
        if n >= 2
            w4 := array.get(pp, n - 2)
        if n >= 3
            w3 := array.get(pp, n - 3)
        if n >= 4
            w2   := array.get(pp, n - 4)
            typ4 := array.get(pt, n - 4)
        if n >= 5
            w1   := array.get(pp, n - 5)
            typ5 := array.get(pt, n - 5)
        if n >= 6
            w0   := array.get(pp, n - 6)
            typ6 := array.get(pt, n - 6)
        int code = 0
        if typ6 == -1 and bullImp6(w0, w1, w2, w3, w4, w5)
            code := 6
        else if typ6 == 1 and bullImp6(-w0, -w1, -w2, -w3, -w4, -w5)
            code := -6
        if code == 0
            if typ5 == -1 and bullImp5(w1, w2, w3, w4, w5)
                code := 5
            else if typ5 == 1 and bullImp5(-w1, -w2, -w3, -w4, -w5)
                code := -5
        if code == 0
            if typ4 == -1 and bullImp4(w2, w3, w4, w5)
                code := 4
            else if typ4 == 1 and bullImp4(-w2, -w3, -w4, -w5)
                code := -4
        ewCo

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