// This work is licensed under a Attribution-NonCommercial-ShareAlike 4.

0
International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// © PunkAlgo - formerly know as PunkAlgo

//@version=5
indicator("PunkChainer™ Price Action Concepts [🧊 PunkAlgo 4.0]", shorttitle =
"PunkAlgo - Price Action Concepts [1.0]", overlay = true, max_lines_count = 500,
max_labels_count = 500, max_boxes_count = 500, max_bars_back = 500,
max_polylines_count = 100)

// Liquidity Concepts
lookback = input.int(12,"Pivot Point Length",minval = 2,group = "🧊 Liquidity
Concepts")
liq_valid = input.int(7,"Liquidation Validity",minval = 1,tooltip = "Measure how
many candles should max pass to count as liquidity. Ex: if set to 7, the
liquidation should happen in those 7 bars; otherwise, it is not valid.",inline =
"AA",group = "Inputs")
liq_bool = input.bool(true,"Use Pivot Length",inline = "AA",group = "🧊 Liquidity
Concepts")

switch liq_bool
true => liq_valid := lookback
false => na
=> liq_valid

HH_css = input.color(color.white, "HH & HL", inline = "HHLL2", group = "🧊 Liquidity
Concepts")
LL_css = input.color(color.gray , "LL & LH", inline = "HHLL2", group = "🧊 Liquidity
Concepts")

css_candle = input.string("CHoCH", "Candle Options",options = ["CHoCH","Default"])

// bt_show = input.bool(false,"Show feedbacks result",group = "Settings")

show_liq = input.bool(true,"Hide Liquidity Swipe",group = "Settings")
show_pivot = input.bool(true,"Hide Pivot Point",group = "Settings")
show_wick = input.bool(false,"Hide Liquidation Wicks Point",group = "Settings")

css_bull = input.color(#089981 , "Bull CHoCH", inline = "Color 1", group = "Colors

trend")
css_bear = input.color(color.red, "Bear CHoCH", inline = "Color 1", group = "Colors
trend")

css_up = input.color(color.gray, "Up Candle", inline = "Color 2", group = "Colors

trend")
css_dn = input.color(color.black, "Down Candle", inline = "Color 2", group =
"Colors trend")

major_trans = input.int(15,"Transp Major Liquidation",0,100,inline = "trans1",group

= "Liquidations Color")
minor_trans = input.int(15,"Transp Minor Liquidation",0,100,inline = "trans2",group
= "Liquidations Color")

liq_bear_minor = input.color(color.gray,"Bearish Liquidity Minor Swipe", group =

"Liquidations Color")
liq_bull_minor = input.color(color.gray,"Bullish Liquidity Minor Swipe", group =
"Liquidations Color")

liq_bear_major = input.color(color.purple,"Bearish Liquidity Major Swipe", group =

"Liquidations Color")
liq_bull_major = input.color(color.aqua,"Bullish Liquidity Major Swipe", group =
"Liquidations Color")

liq_wick_lh = input.color(color.orange, "Bearish Liquidation wick", group =

"Liquidations Color")
liq_wick_hl = input.color(color.new(#2157f3,0), "Bearish Liquidation wick", group =
"Liquidations Color")

lbl_size = input.int(1,"Pivot Text size",1,maxval = 5, group = "Text size")

lbl_t = switch lbl_size
1 => size.tiny
2 => size.small
3 => size.normal
4 => size.large
5 => size.huge

txt_size = input.int(1,"Market structure Text size",1,maxval = 5, group = "Text

size")
txt_t = switch txt_size
1 => size.tiny
2 => size.small
3 => size.normal
4 => size.large
5 => size.huge

transline = 0

BOS_bull_css = input.color(color.white, "Bullish BOS", inline = "BOS1", group =

"BOS and CHoCH colors")
BOS_bear_css = input.color(color.gray , "Bullish BOS", inline = "BOS2", group =
"BOS and CHoCH colors")

CHOCH_bull_css = input.color(color.white, "Bullish CHoCH", inline = "BOS1", group =

"BOS and CHoCH colors")
CHOCH_bear_css = input.color(color.gray , "Bearish CHoCH", inline = "BOS2", group =
"BOS and CHoCH colors")

switch show_liq
true => major_trans := 100, minor_trans := 100
false => na

colinv = color.new(color.white,100) // gay

type barLiq
float o = open
float h = high
float l = low
float c = close
float v = volume
 int idx = bar_index
int t = time

// type col
// color gray = color.gray
// color black = color.black
// color green = color.green
// color red = color.red
// color blue = color.blue
// color purpl1e = color.purpl1e
// color ared = #e60000
// color ablue = #3366ff
// color inv = #ffffff00

type zBin
float[] LH
float[] HL
float[] LL
float[] HH

int[] LHindex
int[] HLindex
int[] LLindex
int[] HHindex

float[] LHchoch
float[] HLchoch
float[] LLchoch
float[] HHchoch

int[] LHchochIndex
int[] HLchochIndex
int[] LLchochIndex
int[] HHchochIndex

float[] _popl1H
int[] _popl1Hidx

var bin = zBin.new(

array.new<float>()
, array.new<float>()
, array.new<float>()
, array.new<float>()

, array.new<int>()
, array.new<int>()
, array.new<int>()
, array.new<int>()

, array.new<float>()
, array.new<float>()
, array.new<float>()
, array.new<float>()
 , array.new<int>()
, array.new<int>()
, array.new<int>()
, array.new<int>()

, array.new<float>()
, array.new<int>()

barLiq = barLiq.new()
// col = col.new()
var int itrendLiq = 0

f_drawLine(x1, y1, x2, y2, color, widh, bBar, txt, down, dashed,transline) =>
var line id = na

// id := line.new(na, na, na, na, xloc = xloc.bar_index, style = dashed ?

line.style_dashed : line.style_solid)
line.set_x1(id ,x1)
line.set_y1(id ,y1)
line.set_x2(id ,x2)
line.set_y2(id ,y2)

line.set_color(id, color.new(color,transline))
line.set_width(id, widh)

structure_lbl = label.new(int(math.avg(x1, bBar)), y1, txt

, color = colinv
, textcolor = color
, style = down ? label.style_label_down : label.style_label_up
, size = txt_t)

f_drawBox(left, top, right, bottom, bgcolor, bcolor, trans) =>

var box idLiq = na
idLiq := box.new(left, top, right, bottom)
box.set_bgcolor(idLiq,color.new(bgcolor,trans))
box.set_border_width(idLiq, 1)
box.set_border_color(idLiq, color.new(bcolor,11))

// && => HH LL LH

ph1 = ta.pivothigh(lookback, lookback)

pl1 = ta.pivotlow(lookback, lookback)

iff_1 = pl1 ? -1 : na // Trend direction

hl = ph1 ? 1 : iff_1
iff_2 = pl1 ? pl1 : na // similar to zigzag but may have multipl1e highs/lows
zz = ph1 ? ph1 : iff_2
valuewhen_1 = ta.valuewhen(hl, hl, 1)
valuewhen_2 = ta.valuewhen(zz, zz, 1)
zz := pl1 and hl == -1 and valuewhen_1 == -1 and pl1 > valuewhen_2 ? na : zz
valuewhen_3 = ta.valuewhen(hl, hl, 1)
valuewhen_4 = ta.valuewhen(zz, zz, 1)
zz := ph1 and hl == 1 and valuewhen_3 == 1 and ph1 < valuewhen_4 ? na : zz
valuewhen_5 = ta.valuewhen(hl, hl, 1)
valuewhen_6 = ta.valuewhen(zz, zz, 1)
hl := hl == -1 and valuewhen_5 == 1 and zz > valuewhen_6 ? na : hl
valuewhen_7 = ta.valuewhen(hl, hl, 1)
valuewhen_8 = ta.valuewhen(zz, zz, 1)
hl := hl == 1 and valuewhen_7 == -1 and zz < valuewhen_8 ? na : hl
zz := na(hl) ? na : zz

findprevious() => // finds previous three points (b, c, d, e)

ehl = hl == 1 ? -1 : 1
loc1 = 0.0
loc2 = 0.0
loc3 = 0.0
loc4 = 0.0
xx = 0
for x = 1 to 1000 by 1
if hl[x] == ehl and not na(zz[x])
loc1 := zz[x]
xx := x + 1
break
ehl := hl
for x = xx to 1000 by 1
if hl[x] == ehl and not na(zz[x])
loc2 := zz[x]
xx := x + 1
break
ehl := hl == 1 ? -1 : 1
for x = xx to 1000 by 1
if hl[x] == ehl and not na(zz[x])
loc3 := zz[x]
xx := x + 1
break
ehl := hl
for x = xx to 1000 by 1
if hl[x] == ehl and not na(zz[x])
loc4 := zz[x]
break
[loc1, loc2, loc3, loc4]

isNot() =>
float a = na
float b = na
float c = na
float d = na
float e = na

if not na(hl)
[loc1, loc2, loc3, loc4] = findprevious()
a := zz
b := loc1
c := loc2
d := loc3
e := loc4
e

_hh = zz and a > b and a > c and c > b and c > d

_ll = zz and a < b and a < c and c < b and c < d
 _hl = zz and (a >= c and b > c and b > d and d > c and d > e or a < b and a > c
and b < d)
_lh = zz and (a <= c and b < c and b < d and d < c and d < e or a > b and a < c
and b > d)

[_hh, _ll, _hl, _lh]

[_hh, _ll, _hl, _lh] = isNot()

float res = na
float sup = na
res := _lh ? zz : res[1]
sup := _hl ? zz : sup[1]

int trendLiq = na
iff_3 = close < sup ? -1 : nz(trendLiq[1])
trendLiq := close > res ? 1 : iff_3

res := trendLiq == 1 and _hh or trendLiq == -1 and _lh ? zz : res

sup := trendLiq == 1 and _hl or trendLiq == -1 and _ll ? zz : sup
rechange = res != res[1]
suchange = sup != sup[1]

//table int

var int tot_structure_bull = 0

var int tot_structure_bear = 0

var float tot_bear_liq = 0

var float tot_bull_liq = 0

var float tot_liq_sell = 0

var float tot_liq_buy = 0

// && => Pivot HH and CHoCH

var bxHHchOchPoint = array.new<float>()

color onetap = na
float src_onetap_lh = na
float src_onetap_hl = na

bodyLength = math.abs(close - open)

downWickLength = low - math.min(open, close)
downWickBigger = downWickLength > bodyLength

if _hh
id = show_pivot ? na : label.new(barLiq.idx[lookback], barLiq.h[lookback], text
= "HH", style = label.style_label_down, size = lbl_t, color = colinv, textcolor =
HH_css)
bin.HH.push(barLiq.h[lookback])
bin.HHindex.push(barLiq.idx[lookback])

bxHHchOchPoint.push(barLiq.h[1])

if bin.HH.size() > 0
 if barLiq.idx % (lookback * 2) == 0
bin.HHchoch.push(bin.HH.pop())
bin.HHchochIndex.push(bin.HHindex.pop())

if bin.HH.size() > 0
for j = 0 to bin.HH.size()
if bin.HH.size() <= 0
break
else
var _poph1H = array.new<float>()
var _poph1Hidx = array.new<int>()
var int barLiqsince = ta.barssince(ta.crossunder(barLiq.c,
bin.HH.last()))
if ta.crossover(barLiq.h, bin.HH.last())
bool choch = false

if itrendLiq < 0
choch := true
txt = choch ? "" : ""
_poph1H.push(bin.HH.pop())
_poph1Hidx.push(bin.HHindex.pop())
if math.abs(_poph1Hidx.last() - barLiq.idx) > 500
break
else
col = choch ? CHOCH_bull_css : BOS_bull_css
itrendLiq := 1
tot_structure_bull += 1

f_drawLine(_poph1Hidx.last(), _poph1H.last(), barLiq.idx,

_poph1H.last(), col, 1, barLiq.idx, txt, true, txt == "" ? true : false, transline)

if bin.HHchoch.size() > 0
for j = 0 to bin.HHchoch.size()
if bin.HHchoch.size() <= 0
break
else
var _poph1Hchoch = array.new<float>()
var _poph1HchochIndex = array.new<int>()
if ta.crossover(barLiq.c, bin.HHchoch.last())
bool choch = false

if itrendLiq < 0
choch := true
txt = choch ? "" : ""

_poph1Hchoch.push(bin.HHchoch.pop())
_poph1HchochIndex.push(bin.HHchochIndex.pop())
if math.abs(_poph1HchochIndex.last() - barLiq.idx) > 500
break
else
col = choch ? CHOCH_bull_css : BOS_bull_css
f_drawLine(_poph1HchochIndex.last(), _poph1Hchoch.last(),
barLiq.idx, _poph1Hchoch.last(), col, 1, barLiq.idx, txt, true, txt == "" ? true :
false, transline)
itrendLiq := 1
tot_structure_bull += 1
if bxHHchOchPoint.size() > 0
barLiqsince = ta.barssince(ta.crossover(barLiq.h ,bxHHchOchPoint.last()))
var float lastLvl = na
var int index = na
if ta.crossover(barLiq.h, bxHHchOchPoint.last())
lastLvl := bxHHchOchPoint.last()
index := barLiq.idx[1]

if ta.crossunder(barLiq.h, bxHHchOchPoint.last()) and barLiqsince <= liq_valid

var maxtop = array.new<float>()
for j = 0 to barLiqsince
maxtop.push(barLiq.h[j])

// f_drawBox(index, maxtop.max(), barLiq.idx, lastLvl, liq_bear_major,

liq_bear_major, major_trans)
tot_liq_sell += ta.cum(volume)
lastLvl := na
index := na
maxtop.clear()
else if ta.crossunder(barLiq.h, bxHHchOchPoint.last()) and barLiqsince >
liq_valid
lastLvl := na
index := na

// && => Pivot LL and CHoCH

var bxLLchOch = array.new<float>()

if _ll
id = show_pivot ? na : label.new(barLiq.idx[lookback], barLiq.l[lookback], text
= "LL", style = label.style_label_up, size = lbl_t, color = colinv, textcolor =
LL_css)
bin.LL.push(barLiq.l[lookback])
bin.LLindex.push(barLiq.idx[lookback])

bxLLchOch.push(barLiq.l[1])

if bin.LL.size() > 0
if barLiq.idx % (lookback * 2) == 0
bin.LLchoch.push(bin.LL.pop())
bin.LLchochIndex.push(bin.LLindex.pop())

if bin.LL.size() > 0
for j = 0 to bin.LL.size()
if bin.LL.size() <= 0
break
else
var _popl1L = array.new<float>()
var _popl1Lidx = array.new<int>()
var int barLiqsince = ta.barssince(ta.crossunder(barLiq.c,
bin.LL.last()))
if ta.crossunder(barLiq.l, bin.LL.last())
bool choch = false

if itrendLiq > 0
choch := true
 txt = choch ? "" : ""

_popl1L.push(bin.LL.pop())
_popl1Lidx.push(bin.LLindex.pop())
if math.abs(_popl1Lidx.last() - barLiq.idx) > 500
break
else
col = choch ? CHOCH_bear_css : BOS_bear_css
f_drawLine(_popl1Lidx.last(), _popl1L.last(), barLiq.idx,
_popl1L.last(), col, 1, barLiq.idx, txt, false, txt == "" ? true : false,
transline)
itrendLiq := -1
tot_structure_bear += 1

if bin.LLchoch.size() > 0
for j = 0 to bin.LLchoch.size()
if bin.LLchoch.size() <= 0
break
else
var _popl1Lchoch = array.new<float>()
var _popl1LchochIndex = array.new<int>()
if ta.crossunder(barLiq.c, bin.LLchoch.last())
bool choch = false

if itrendLiq > 0
choch := true
txt = choch ? "" : ""

_popl1Lchoch.push(bin.LLchoch.pop())
_popl1LchochIndex.push(bin.LLchochIndex.pop())
if math.abs(_popl1LchochIndex.last() - barLiq.idx) > 500
break
else
col = choch ? CHOCH_bear_css : BOS_bear_css
f_drawLine(_popl1LchochIndex.last(), _popl1Lchoch.last(),
barLiq.idx, _popl1Lchoch.last(), col, 1, barLiq.idx, txt, false, txt == "" ? true :
false, transline)
itrendLiq := -1
tot_structure_bear += 1

if bxLLchOch.size() > 0
barLiqsince = ta.barssince(ta.crossunder(barLiq.l ,bxLLchOch.last()))
var float lastLvl = na
var int index = na
if ta.crossunder(barLiq.h, bxLLchOch.last())
lastLvl := bxLLchOch.last()
index := barLiq.idx[1]

if ta.crossover(barLiq.h, bxLLchOch.last()) and barLiqsince <= liq_valid

var maxtop = array.new<float>()
for j = 0 to barLiqsince
maxtop.push(barLiq.l[j])

// f_drawBox(index, lastLvl, barLiq.idx[1], maxtop.min(), liq_bull_major,

liq_bull_major, major_trans)
tot_liq_buy += ta.cum(volume)
 lastLvl := na
index := na
maxtop.clear()
else if ta.crossover(barLiq.l, bxLLchOch.last()) and barLiqsince > liq_valid
lastLvl := na
index := na

// && => Pivot HL

var bxHLPoint = array.new<float>()

if _hl
id = show_pivot ? na : label.new(barLiq.idx[lookback], barLiq.l[lookback], text
= "HL", style = label.style_label_up, size = lbl_t, color = colinv, textcolor =
HH_css)
bin.HL.push(barLiq.l[lookback])
bin.HLindex.push(barLiq.idx[lookback])

bxHLPoint.push(barLiq.l[lookback])

if bin.HL.size() > 0
for j = 0 to bin.HL.size()
if bin.HL.size() <= 0
break
else
if bin.HL.size() > 0
var _poph1L = array.new<float>()
var _poph1Lidx = array.new<int>()
var int barLiqsince = ta.barssince(ta.crossunder(barLiq.c,
bin.HL.last()))
if ta.crossunder(barLiq.l, bin.HL.last())
_poph1L.push(bin.HL.pop())
_poph1Lidx.push(bin.HLindex.pop())
if math.abs(_poph1Lidx.last() - barLiq.idx) > 500
break
else
show_pivot ? na : f_drawLine(_poph1Lidx.last(),
_poph1L.last(), barLiq.idx, _poph1L.last(), HH_css, 1, barLiq.idx, "", false,
false, 0)

if barLiq.c > _poph1L.last() and barLiq.o > _poph1L.last() and

math.abs(close - open) <= math.abs(low - (close > open ? open : close))
src_onetap_hl := low

if bxHLPoint.size() > 0
barLiqsince = ta.barssince(ta.crossunder(barLiq.l ,bxHLPoint.last()))
var float lastLvl = na
var int index = na
if ta.crossunder(barLiq.h, bxHLPoint.last())
lastLvl := bxHLPoint.last()
index := barLiq.idx[1]

if ta.crossover(barLiq.h, bxHLPoint.last()) and barLiqsince <= liq_valid

var maxtop = array.new<float>()
 for j = 0 to barLiqsince
maxtop.push(barLiq.l[j])

// f_drawBox(index, lastLvl, barLiq.idx[1], maxtop.min(), liq_bear_minor,

liq_bear_minor, minor_trans)
tot_liq_buy += ta.cum(volume)
lastLvl := na
index := na
maxtop.clear()
else if ta.crossover(barLiq.l, bxHLPoint.last()) and barLiqsince > liq_valid
lastLvl := na
index := na

// && => Pivot LH and Liquidity Swap

var bxLHPoint = array.new<float>()

if _lh
id = show_pivot ? na : label.new(barLiq.idx[lookback], barLiq.h[lookback], text
= "LH", style = label.style_label_down, size = lbl_t, color = colinv, textcolor =
LL_css)
bin.LH.push(barLiq.h[lookback])
bin.LHindex.push(barLiq.idx[lookback])

bxLHPoint.push(barLiq.h[lookback])

if bin.LH.size() > 0
for j = 0 to bin.LH.size()
if bin.LH.size() <= 0
break
else
if ta.crossover(barLiq.h, bin.LH.last())
bin._popl1H.push(bin.LH.pop())
bin._popl1Hidx.push(bin.LHindex.pop())
if math.abs(bin._popl1Hidx.last() - barLiq.idx) > 500
break
else
show_pivot ? na : f_drawLine(bin._popl1Hidx.last(),
bin._popl1H.last(), barLiq.idx, bin._popl1H.last(), LL_css, 1, barLiq.idx, "",
false, false, 0)

if barLiq.c < bin._popl1H.last() and barLiq.o < bin._popl1H.last()

and math.abs(close - open) <= math.abs(high - (close > open ? close : open))
src_onetap_lh := high

if bxLHPoint.size() > 0
barLiqsince = ta.barssince(ta.crossover(barLiq.h ,bxLHPoint.last()))
var float lastLvl = na
var int index = na
if ta.crossover(barLiq.h, bxLHPoint.last())
lastLvl := bxLHPoint.last()
index := barLiq.idx[1]

if ta.crossunder(barLiq.h, bxLHPoint.last()) and barLiqsince <= liq_valid

 var maxtop = array.new<float>()
for j = 0 to barLiqsince
maxtop.push(barLiq.h[j])

// f_drawBox(index, maxtop.max(), barLiq.idx[1], lastLvl, liq_bull_minor,

liq_bull_minor, minor_trans)
tot_liq_sell += ta.cum(volume)
lastLvl := na
index := na
maxtop.clear()
else if ta.crossunder(barLiq.h, bxLHPoint.last()) and barLiqsince > liq_valid
lastLvl := na
index := na

css(x) =>
var color col = na
if x == "CHoCH"
col := itrendLiq == 1 ? css_bull : css_bear
else if x == "Default"
col := barLiq.c > barLiq.o ? css_up : css_dn
col

csss = css(css_candle)
c_src = close > open ? close : open
c_csrc = close > open ? open : close

int b_wick = 0

switch show_wick
false => na
true => b_wick := 100

plotcandle(src_onetap_lh,c_src, c_src ,c_src, color = colinv,wickcolor =

colinv,bordercolor = color.new(liq_wick_lh,b_wick),display = display.pane)
plotcandle(src_onetap_hl,c_src, c_src ,c_src, color = colinv,wickcolor =
colinv,bordercolor = color.new(liq_wick_hl,b_wick),display = display.pane)

// Liquidity ALERTS
alertcondition(src_onetap_lh, title = "Bearish Liquidity Grab", message =
"Bearish Liquidity Grab")
alertcondition(src_onetap_hl, title = "Bullish Liquidity Grab", message =
"Bullish Liquidity Grab")

//-----------------------------------------------------------------------------{
//Boolean set
//-----------------------------------------------------------------------------{
s_BOS = 0
s_CHoCH = 1
i_BOS = 2
i_CHoCH = 3
i_pp_CHoCH = 4
green_candle = 5
red_candle = 6
s_CHoCHP = 7
i_CHoCHP = 8

boolean =
 array.from(
false
, false
, false
, false
, false
, false
, false
, false
, false
)

//-----------------------------------------------------------------------------{
// User inputs
//-----------------------------------------------------------------------------{

show_swing_ms = input.string ("All"

, "Swing " , inline = "1", group = "MARKET
STRUCTURE" , options = ["All", "CHoCH", "CHoCH+", "BOS", "None"])
show_internal_ms = input.string ("All"
, "Internal " , inline = "2", group = "MARKET STRUCTURE"
, options = ["All", "CHoCH", "CHoCH+", "BOS", "None"])
internal_r_lookback = input.int (5
, "" , inline = "2", group = "MARKET STRUCTURE"
, minval = 2)
swing_r_lookback = input.int (50
, "" , inline = "1", group = "MARKET STRUCTURE"
, minval = 2)
ms_mode = input.string ("Manual"
, "Market Structure Mode" , inline = "a", group = "MARKET STRUCTURE"
, tooltip = "[Manual] Use selected lenght\n[Dynamic] Use automatic lenght" ,options
= ["Manual", "Dynamic"])
show_mtf_str = input.bool (true
, "MTF Scanner" , inline = "9", group = "MARKET STRUCTURE"
, tooltip = "Display Multi-Timeframe Market Structure Trend Directions. Green =
Bullish. Red = Bearish")
show_eql = input.bool (false
, "Show EQH/EQL" , inline = "6", group = "MARKET STRUCTURE")
plotcandle_bool = input.bool (false
, "Plotcandle" , inline = "3", group = "MARKET STRUCTURE"
, tooltip = "Displays a cleaner colored candlestick chart in place of the default
candles. (requires hiding the current ticker candles)")
barcolor_bool = input.bool (false
, "Bar Color" , inline = "4", group = "MARKET STRUCTURE"
, tooltip = "Color the candle bodies according to market strucutre trend")

i_ms_up_BOS = input.color (#089981

, "" , inline = "2", group = "MARKET STRUCTURE")
i_ms_dn_BOS = input.color (#f23645
, "" , inline = "2", group = "MARKET STRUCTURE")
s_ms_up_BOS = input.color (#089981
, "" , inline = "1", group = "MARKET STRUCTURE")
s_ms_dn_BOS = input.color (#f23645
, "" , inline = "1", group = "MARKET STRUCTURE")

lvl_daily = input.bool (false

, "Day " , inline = "1", group = "HIGHS & LOWS MTF")
lvl_weekly = input.bool (false
, "Week " , inline = "2", group = "HIGHS & LOWS MTF")
lvl_monthly = input.bool (false
, "Month" , inline = "3", group = "HIGHS & LOWS MTF")
lvl_yearly = input.bool (false
, "Year " , inline = "4", group = "HIGHS & LOWS MTF")
css_d = input.color (color.blue
, "" , inline = "1", group = "HIGHS & LOWS MTF")
css_w = input.color (color.blue
, "" , inline = "2", group = "HIGHS & LOWS MTF")
css_m = input.color (color.blue
, "" , inline = "3", group = "HIGHS & LOWS MTF")
css_y = input.color (color.blue
, "" , inline = "4", group = "HIGHS & LOWS MTF")
s_d = input.string ('⎯⎯⎯'
, '' , inline = '1', group = 'HIGHS & LOWS MTF'
, options = ['⎯⎯⎯', '----', '····'])
s_w = input.string ('⎯⎯⎯'
, '' , inline = '2', group = 'HIGHS & LOWS MTF'
, options = ['⎯⎯⎯', '----', '····'])
s_m = input.string ('⎯⎯⎯'
, '' , inline = '3', group = 'HIGHS & LOWS MTF'
, options = ['⎯⎯⎯', '----', '····'])
s_y = input.string ('⎯⎯⎯'
, '' , inline = '4', group = 'HIGHS & LOWS MTF'
, options = ['⎯⎯⎯', '----', '····'])

ob_show = input.bool (true

, "Show Last " , inline = "1", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Display volumetric order blocks on the chart \n\n[Input] Ammount of
volumetric order blocks to show")
ob_num = input.int (5
, "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Orderblocks number", minval = 1, maxval = 10)
ob_metrics_show = input.bool (true
, "Internal Buy/Sell Activity" , inline = "2", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Display volume metrics that have formed the orderblock")
css_metric_up = input.color (color.new(#089981, 50)
, " " , inline = "2", group = "VOLUMETRIC ORDER BLOCKS")
css_metric_dn = input.color (color.new(#f23645 , 50)
, "" , inline = "2", group = "VOLUMETRIC ORDER BLOCKS")
ob_swings = input.bool (false
, "Swing Order Blocks" , inline = "a", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Display swing volumetric order blocks")
css_swing_up = input.color (color.new(color.gray , 90)
, " " , inline = "a", group = "VOLUMETRIC ORDER BLOCKS")
css_swing_dn = input.color (color.new(color.silver, 90)
, "" , inline = "a", group = "VOLUMETRIC ORDER BLOCKS")
ob_filter = input.string ("None"
, "Filtering " , inline = "d", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Filter out volumetric order blocks by BOS/CHoCH/CHoCH+", options =
["None", "BOS", "CHoCH", "CHoCH+"])
ob_mitigation = input.string ("Absolute"
, "Mitigation " , inline = "4", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Trigger to remove volumetric order blocks", options = ["Absolute",
"Middle"])
ob_pos = input.string ("Precise"
, "Positioning " , inline = "k", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Position of the Order Block\n[Full] Cover the whole candle\n[Middle]
Cover half candle\n[Accurate] Adjust to volatility\n[Precise] Same as Accurate but
more precise", options = ["Full", "Middle", "Accurate", "Precise"])
use_grayscale = input.bool (false
, "Grayscale" , inline = "6", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Use gray as basic order blocks color")
use_show_metric = input.bool (true
, "Show Metrics" , inline = "7", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Show volume associated with the orderblock and his relevance")
use_middle_line = input.bool (true
, "Show Middle-Line" , inline = "8", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Show mid-line order blocks")
use_overlap = input.bool (true
, "Hide Overlap" , inline = "9", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Hide overlapping order blocks")
use_overlap_method = input.string ("Previous"
, "Overlap Method " , inline = "Z", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "[Recent] Preserve the most recent volumetric order blocks\n\
n[Previous] Preserve the previous volumetric order blocks", options = ["Recent",
"Previous"])
ob_bull_css = input.color (color.new(#089981 , 90)
, "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS")
ob_bear_css = input.color (color.new(#f23645 , 90)
, "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS")

show_acc_dist_zone = input.bool (false

, "" , inline = "1", group = "Accumulation And
Distribution")
zone_mode = input.string ("Fast"
, "" , inline = "1", group = "Accumulation And
Distribution" , tooltip = "[Fast] Find small zone pattern formation\n[Slow] Find
bigger zone pattern formation" ,options = ["Slow", "Fast"])
acc_css = input.color (color.new(#089981 , 60)
, "" , inline = "1", group = "Accumulation And
Distribution")
dist_css = input.color (color.new(#f23645 , 60)
, "" , inline = "1", group = "Accumulation And
Distribution")

show_lbl = input.bool (false

, "Show swing point" , inline = "1", group = "High and Low"
, tooltip = "Display swing point")
show_mtb = input.bool (false
, "Show High/Low/Equilibrium" , inline = "2", group = "High and Low"
, tooltip = "Display Strong/Weak High And Low and Equilibrium")
toplvl = input.color (color.red
, "Premium Zone " , inline = "3", group = "High and Low")
midlvl = input.color (color.white
, "Equilibrium Zone" , inline = "4", group = "High and Low")
btmlvl = input.color (#089981
, "Discount Zone " , inline = "5", group = "High and Low")

fvg_enable = input.bool (false

, " " , inline = "1", group = "FAIR VALUE GAP"
, tooltip = "Display fair value gap")
what_fvg = input.string ("FVG"
, "" , inline = "1", group = "FAIR VALUE GAP"
, tooltip = "Display fair value gap", options = ["FVG", "VI", "OG"])
fvg_num = input.int (5
, "Show Last " , inline = "1a", group = "FAIR VALUE GAP"
, tooltip = "Number of fvg to show")
fvg_upcss = input.color (color.new(#089981, 80)
, "" , inline = "1", group = "FAIR VALUE GAP")
fvg_dncss = input.color (color.new(color.red , 80)
, "" , inline = "1", group = "FAIR VALUE GAP")
fvg_extend = input.int (10
, "Extend FVG" , inline = "2", group = "FAIR VALUE GAP"
, tooltip = "Extend the display of the FVG.")
fvg_src = input.string ("Close"
, "Mitigation " , inline = "3", group = "FAIR VALUE GAP"
, tooltip = "[Close] Use the close of the body as trigger\n\n[Wick] Use the extreme
point of the body as trigger", options = ["Close", "Wick"])
fvg_tf = input.timeframe (""
, "Timeframe " , inline = "4", group = "FAIR VALUE GAP"
, tooltip = "Timeframe of the fair value gap")

t = color.t (ob_bull_css)
invcol = color.new (color.white
, 100)
obtxt = input.string("Small" , "Metric Size"
, ["Tiny", "Small", "Normal", "Large", "Huge"], inline = "7", group = "VOLUMETRIC
ORDER BLOCKS" )

method txSz(string s) =>

out = switch s
"Tiny" => size.tiny
"Small" => size.small
"Normal" => size.normal
"Large" => size.large
"Huge" => size.huge
out

type bar
float o = open
float c = close
float h = high
float l = low
float v = volume
int n = bar_index
int t = time

type Zphl
line top
line bottom
label top_label
label bottom_label
bool stopcross
bool sbottomcross
bool itopcross
bool ibottomcross
string txtup
string txtdn
float topy
float bottomy
float topx
float bottomx
float tup
float tdn
 int tupx
int tdnx
float itopy
float itopx
float ibottomy
float ibottomx
float uV
float dV

type FVG
box [] box
line[] ln
bool bull
float top
float btm
int left
int right

type ms
float[] p
int [] n
float[] l

type msDraw
int n
float p
color css
string txt
bool bull

type obC
float[] top
float[] btm
int [] left
float[] avg
float[] dV
float[] cV
int [] wM
int [] blVP
int [] brVP
int [] dir
float[] h
float[] l
int [] n

type obD
box [] ob
box [] eOB
box [] blB
box [] brB
line[] mL

type zone
chart.point points
float p
int c
int t

type hqlzone
 box pbx
box ebx
box lbx
label plb
label elb
label lbl

type ehl
float pt
int t
float pb
int b

type pattern
string found = "None"
bool isfound = false
int period = 0
bool bull = false

type alerts
bool chochswing = false
bool chochplusswing = false
bool swingbos = false
bool chochplus = false
bool choch = false
bool bos = false
bool equal = false
bool ob = false
bool swingob = false
bool zone = false
bool fvg = false
bool obtouch = false

bar b = bar.new()
var pattern p = pattern.new()

alerts blalert = alerts.new()

alerts bralert = alerts.new()

if p.isfound

p.period += 1

if p.period == 50

p.period := 0
p.found := "None"
p.isfound := false
p.bull := na

switch

b.c > b.o => boolean.set(green_candle, true)

b.c < b.o => boolean.set(red_candle , true)

f_zscore(src, lookback) =>

(src - ta.sma(src, lookback)) / ta.stdev(src, lookback)

var int iLen = internal_r_lookback
var int sLen = swing_r_lookback

vv = f_zscore(((close - close[iLen]) / close[iLen]) * 100,iLen)

if ms_mode == "Dynamic"

switch

vv >= 1.5 or vv <= -1.5 => iLen := 10

vv >= 1.6 or vv <= -1.6 => iLen := 9
vv >= 1.7 or vv <= -1.7 => iLen := 8
vv >= 1.8 or vv <= -1.8 => iLen := 7
vv >= 1.9 or vv <= -1.9 => iLen := 6
vv >= 2.0 or vv <= -2.0 => iLen := 5
=> iLen

var msline = array.new<line>(0)

iH = ta.pivothigh(high, iLen, iLen)

sH = ta.pivothigh(high, sLen, sLen)
iL = ta.pivotlow (low , iLen, iLen)
sL = ta.pivotlow (low , sLen, sLen)

hl () => [high, low]

[pdh, pdl] = request.security(syminfo.tickerid , 'D' , hl() , lookahead =

barmerge.lookahead_on)
[pwh, pwl] = request.security(syminfo.tickerid , 'W' , hl() , lookahead =
barmerge.lookahead_on)
[pmh, pml] = request.security(syminfo.tickerid , 'M' , hl() , lookahead =
barmerge.lookahead_on)
[pyh, pyl] = request.security(syminfo.tickerid , '12M', hl() , lookahead =
barmerge.lookahead_on)

lstyle(style) =>

out = switch style

'⎯⎯⎯' => line.style_solid

'----' => line.style_dashed
'····' => line.style_dotted

mtfphl(h, l ,tf ,css, pdhl_style) =>

var line hl = line.new(

na
, na
, na
, na
, xloc = xloc.bar_time
, color = css
, style = lstyle(pdhl_style)
)

var line ll = line.new(

na
, na
 , na
, na
, xloc = xloc.bar_time
, color = css
, style = lstyle(pdhl_style)
)

var label lbl = label.new(

na
, na
, xloc = xloc.bar_time
, text = str.format('P{0}L', tf)
, color = invcol
, textcolor = css
, size = size.small
, style = label.style_label_left
)

var label hlb = label.new(

na
, na
, xloc = xloc.bar_time
, text = str.format('P{0}H', tf)
, color = invcol
, textcolor = css
, size = size.small
, style = label.style_label_left
)

hy = ta.valuewhen(h != h[1] , h , 1)
hx = ta.valuewhen(h == high , time , 1)
ly = ta.valuewhen(l != l[1] , l , 1)
lx = ta.valuewhen(l == low , time , 1)

if barstate.islast

extension = time + (time - time[1]) * 50

line.set_xy1(hl , hx , hy)
line.set_xy2(hl , extension , hy)
label.set_xy(hlb, extension , hy)
line.set_xy1(ll , lx , ly)
line.set_xy2(ll , extension , ly)
label.set_xy(lbl, extension , ly)

if lvl_daily

mtfphl(pdh , pdl , 'D' , css_d, s_d)

if lvl_weekly

mtfphl(pwh , pwl , 'W' , css_w, s_w)

if lvl_monthly

mtfphl(pmh , pml, 'M' , css_m, s_m)

if lvl_yearly
 mtfphl(pyh , pyl , '12M', css_y, s_y)

//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - End
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - Market Structure
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}

method darkcss(color css, float factor, bool bull) =>

blue = color.b(css) * (1 - factor)

red = color.r(css) * (1 - factor)
green = color.g(css) * (1 - factor)

color.rgb(red, green, blue, 0)

method f_line(msDraw d, size, style) =>

var line id = na
var label lbl = na

id := line.new(
d.n
, d.p
, b.n
, d.p
, color = d.css
, width = 1
, style = style
)

if msline.size() >= 250

line.delete(msline.shift())

msline.push(id)
 lbl := label.new(
int(math.avg(d.n, b.n))
, d.p
, d.txt
, color = invcol
, textcolor = d.css
, style = d.bull ? label.style_label_down : label.style_label_up
, size = size
)

structure(bool mtf) =>

msDraw drw = na

bool isdrw = false

bool isdrwS = false

var color css = na

var color icss = na

var int itrend = 0

var int trend = 0

bool bull_ob = false

bool bear_ob = false

bool s_bull_ob = false

bool s_bear_ob = false

n = bar_index

var ms up = ms.new(
array.new<float>()
, array.new< int >()
, array.new<float>()
)

var ms dn = ms.new(
array.new<float>()
, array.new< int >()
, array.new<float>()
)

var ms sup = ms.new(

array.new<float>()
, array.new< int >()
, array.new<float>()
)

var ms sdn = ms.new(

array.new<float>()
, array.new< int >()
, array.new<float>()
)

switch show_swing_ms

"All" => boolean.set(s_BOS , true ), boolean.set(s_CHoCH, true ) ,

boolean.set(s_CHoCHP, true )
 "CHoCH" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, true ) ,
boolean.set(s_CHoCHP, false )
"CHoCH+" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, false) ,
boolean.set(s_CHoCHP, true )
"BOS" => boolean.set(s_BOS , true ), boolean.set(s_CHoCH, false) ,
boolean.set(s_CHoCHP, false )
"None" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, false) ,
boolean.set(s_CHoCHP, false )
=> na

switch show_internal_ms

"All" => boolean.set(i_BOS, true ), boolean.set(i_CHoCH, true ),

boolean.set(i_CHoCHP, true )
"CHoCH" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, true ),
boolean.set(i_CHoCHP, false)
"CHoCH+" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, false ),
boolean.set(i_CHoCHP, true )
"BOS" => boolean.set(i_BOS, true ), boolean.set(i_CHoCH, false ),
boolean.set(i_CHoCHP, false)
"None" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, false ),
boolean.set(i_CHoCHP, false)
=> na

switch
iH =>

up.p.unshift(b.h[iLen])
up.l.unshift(b.h[iLen])
up.n.unshift(n [iLen])

iL =>

dn.p.unshift(b.l[iLen])
dn.l.unshift(b.l[iLen])
dn.n.unshift(n [iLen])

sL =>

sdn.p.unshift(b.l[sLen])
sdn.l.unshift(b.l[sLen])
sdn.n.unshift(n [sLen])

sH =>

sup.p.unshift(b.h[sLen])
sup.l.unshift(b.h[sLen])
sup.n.unshift(n [sLen])

// INTERNAL BULLISH STRUCTURE

if up.p.size() > 0 and dn.l.size() > 1

if ta.crossover(b.c, up.p.first())

bool CHoCH = na
string txt = na

if itrend < 0
 CHoCH := true

switch

not CHoCH =>

txt := "BOS"
css := i_ms_up_BOS

blalert.bos := true

if boolean.get(i_BOS) and mtf == false and na(drw)

isdrw := true
drw := msDraw.new(
up.n.first()
, up.p.first()
, i_ms_up_BOS
, txt
, true
)

CHoCH =>

dn.l.first() > dn.l.get(1) ? blalert.chochplus : blalert.choch

txt := dn.l.first() > dn.l.get(1) ? "CHoCH+" :

"CHoCH"
css := i_ms_up_BOS.darkcss(0.25, true)

if (dn.l.first() > dn.l.get(1) ?

boolean.get(i_CHoCHP) : boolean.get(i_CHoCH)) and mtf == false and na(drw)

isdrw := true
drw := msDraw.new(
up.n.first()
, up.p.first()
, i_ms_up_BOS.darkcss(0.25, true)
, txt
, true
)

if mtf == false

switch

ob_filter == "None" =>

bull_ob := true
ob_filter == "BOS" and txt == "BOS" =>
bull_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" =>
bull_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" =>
bull_ob := true

itrend := 1
up.n.clear()
up.p.clear()
 // INTERNAL BEARISH STRUCTURE
if dn.p.size() > 0 and up.l.size() > 1

if ta.crossunder(b.c, dn.p.first())

bool CHoCH = na
string txt = na

if itrend > 0

CHoCH := true

switch

not CHoCH =>

bralert.bos := true

txt := "BOS"
css := i_ms_dn_BOS

if boolean.get(i_BOS) and mtf == false and na(drw)

isdrw := true
drw := msDraw.new(
dn.n.first()
, dn.p.first()
, i_ms_dn_BOS
, txt
, false
)

CHoCH =>

if up.l.first() < up.l.get(1)

bralert.chochplus := true
else
bralert.choch := true

txt := up.l.first() < up.l.get(1) ? "CHoCH+" :

"CHoCH"
css := i_ms_dn_BOS.darkcss(0.25, false)

if (up.l.first() < up.l.get(1) ?

boolean.get(i_CHoCHP) : boolean.get(i_CHoCH)) and mtf == false and na(drw)

isdrw := true
drw := msDraw.new(
dn.n.first()
, dn.p.first()
, i_ms_dn_BOS.darkcss(0.25, false)
, txt
, false
)

if mtf == false

switch
 ob_filter == "None" =>
bear_ob := true
ob_filter == "BOS" and txt == "BOS" =>
bear_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" =>
bear_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" =>
bear_ob := true

itrend := -1
dn.n.clear()
dn.p.clear()

// SWING BULLISH STRUCTURE

if sup.p.size() > 0 and sdn.l.size() > 1

if ta.crossover(b.c, sup.p.first())

bool CHoCH = na
string txt = na

if trend < 0

CHoCH := true

switch

not CHoCH =>

blalert.swingbos := true

txt := "BOS"
icss := s_ms_up_BOS

if boolean.get(s_BOS) and mtf == false and na(drw)

isdrwS := true
drw := msDraw.new(
sup.n.first()
, sup.p.first()
, s_ms_up_BOS
, txt
, true
)

CHoCH =>

if sdn.l.first() > sdn.l.get(1)

blalert.chochplusswing := true
else
blalert.chochswing := true

txt := sdn.l.first() > sdn.l.get(1) ? "CHoCH+" :

"CHoCH"
icss := s_ms_up_BOS.darkcss(0.25, true)

if (sdn.l.first() > sdn.l.get(1) ?

boolean.get(s_CHoCHP) : boolean.get(s_CHoCH)) and mtf == false and na(drw)
 isdrwS := true
drw := msDraw.new(
sup.n.first()
, sup.p.first()
, s_ms_up_BOS.darkcss(0.25, true)
, txt
, true
)

if mtf == false

switch

ob_filter == "None" =>

s_bull_ob := true
ob_filter == "BOS" and txt == "BOS" =>
s_bull_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" =>
s_bull_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" =>
s_bull_ob := true

trend := 1
sup.n.clear()
sup.p.clear()

// SWING BEARISH STRUCTURE

if sdn.p.size() > 0 and sup.l.size() > 1

if ta.crossunder(b.c, sdn.p.first())

bool CHoCH = na
string txt = na

if trend > 0

CHoCH := true

switch

not CHoCH =>

bralert.swingbos := true

txt := "BOS"
icss := s_ms_dn_BOS

if boolean.get(s_BOS) and mtf == false and na(drw)

isdrwS := true
drw := msDraw.new(
sdn.n.first()
, sdn.p.first()
, s_ms_dn_BOS
, txt
, false
)

CHoCH =>
 if sup.l.first() < sup.l.get(1)
bralert.chochplusswing := true
else
bralert.chochswing := true

txt := sup.l.first() < sup.l.get(1) ? "CHoCH+" :

"CHoCH"
icss := s_ms_dn_BOS.darkcss(0.25, false)

if (sup.l.first() < sup.l.get(1) ?

boolean.get(s_CHoCHP) : boolean.get(s_CHoCH)) and mtf == false and na(drw)

isdrwS := true
drw := msDraw.new(
sdn.n.first()
, sdn.p.first()
, s_ms_dn_BOS.darkcss(0.25, false)
, txt
, false
)

if mtf == false

switch

ob_filter == "None" =>

s_bear_ob := true
ob_filter == "BOS" and txt == "BOS" =>
s_bear_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" =>
s_bear_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" =>
s_bear_ob := true

trend := -1
sdn.n.clear()
sdn.p.clear()

[css, bear_ob, bull_ob, itrend, drw, isdrw, s_bear_ob, s_bull_ob, trend, icss,
isdrwS]

[css, bear_ob, bull_ob, itrend, drw, isdrw, s_bear_ob, s_bull_ob, trend, icss,
isdrwS] = structure(false)

if isdrw
f_line(drw, size.small, line.style_dashed)

if isdrwS
f_line(drw, size.small, line.style_solid)

[_, _, _, itrend15, _, _, _, _, _, _, _] = request.security("", "15" ,

structure(true))
[_, _, _, itrend1H, _, _, _, _, _, _, _] = request.security("", "60" ,
structure(true))
[_, _, _, itrend4H, _, _, _, _, _, _, _] = request.security("", "240" ,
structure(true))
[_, _, _, itrend1D, _, _, _, _, _, _, _] = request.security("", "1440" ,
structure(true))

if show_mtf_str

var tab = table.new(position = position.top_right, columns = 10, rows = 10,

bgcolor = na, frame_color = color.rgb(54, 58, 69, 0), frame_width = 1, border_color
= color.rgb(54, 58, 69, 100), border_width = 1)
table.cell(tab, 0, 1, text = "15" , text_color = color.silver, text_halign =
text.align_center, text_size = size.normal, bgcolor = chart.bg_color, width = 2)
table.cell(tab, 0, 2, text = "1H" , text_color = color.silver, text_halign =
text.align_center, text_size = size.normal, bgcolor = chart.bg_color, width = 2)
table.cell(tab, 0, 3, text = "4H" , text_color = color.silver, text_halign =
text.align_center, text_size = size.normal, bgcolor = chart.bg_color, width = 2)
table.cell(tab, 0, 4, text = "1D" , text_color = color.silver, text_halign =
text.align_center, text_size = size.normal, bgcolor = chart.bg_color, width = 2)

table.cell(tab, 1, 1, text = itrend15 == 1 ? "BULLISH" : itrend15 == -1 ?

"BEARISH" : na , text_halign = text.align_center, text_size = size.normal,
text_color = itrend15 == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend15 == -1 ?
i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color)
table.cell(tab, 1, 2, text = itrend1H == 1 ? "BULLISH" : itrend1H == -1 ?
"BEARISH" : na , text_halign = text.align_center, text_size = size.normal,
text_color = itrend1H == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1H == -1 ?
i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color)
table.cell(tab, 1, 3, text = itrend4H == 1 ? "BULLISH" : itrend4H == -1 ?
"BEARISH" : na , text_halign = text.align_center, text_size = size.normal,
text_color = itrend4H == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend4H == -1 ?
i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color)
table.cell(tab, 1, 4, text = itrend1D == 1 ? "BULLISH" : itrend1D == -1 ?
"BEARISH" : na , text_halign = text.align_center, text_size = size.normal,
text_color = itrend1D == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1D == -1 ?
i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color)

table.cell(tab, 0, 5, text = "Detected Pattern", text_halign =

text.align_center, text_size = size.normal, text_color = color.silver, bgcolor =
chart.bg_color)
table.cell(tab, 0, 6, text = p.found, text_halign = text.align_center,
text_size = size.normal, text_color = na(p.bull) ? color.white : p.bull ?
i_ms_up_BOS.darkcss(-0.25, true) : p.bull == false ? i_ms_dn_BOS.darkcss(0.25,
false) : na, bgcolor = chart.bg_color)

table.merge_cells(tab, 0, 5, 1, 5)
table.merge_cells(tab, 0, 6, 1, 6)

var phl = Zphl.new(

na
, na
, label.new(na , na , color = invcol , textcolor = i_ms_dn_BOS , style =
label.style_label_down , size = size.tiny , text = "")
, label.new(na , na , color = invcol , textcolor = i_ms_up_BOS , style =
label.style_label_up , size = size.tiny , text = "")
, true
, true
, true
, true
, ""
, ""
, 0
 , 0
, 0
, 0
, high
, low
, 0
, 0
, 0
, 0
, 0
, 0
, na
, na
)

zhl(len)=>

upper = ta.highest(len)
lower = ta.lowest(len)

var float out = 0

out := b.h[len] > upper ? 0 : b.l[len] < lower ? 1 : out[1]

top = out == 0 and out[1] != 0 ? b.h[len] : 0

btm = out == 1 and out[1] != 1 ? b.l[len] : 0

[top, btm]

[top , btm ] = zhl(sLen)

[itop, ibtm] = zhl(iLen)

upphl(trend) =>

var label lbl = label.new(

na
, na
, color = invcol
, textcolor = toplvl
, style = label.style_label_down
, size = size.small
)

if top

phl.stopcross := true
phl.txtup := top > phl.topy ? "HH" : "HL"

if show_lbl

topl = label.new(
b.n - swing_r_lookback
, top
, phl.txtup
, color = invcol
, textcolor = toplvl
, style = label.style_label_down
, size = size.small
)
 line.delete(phl.top[1])

phl.top := line.new(
b.n - sLen
, top
, b.n
, top
, color = toplvl)

phl.topy := top
phl.topx := b.n - sLen
phl.tup := top
phl.tupx := b.n - sLen

if itop

phl.itopcross := true
phl.itopy := itop
phl.itopx := b.n - iLen

phl.tup := math.max(high, phl.tup)

phl.tupx := phl.tup == high ? b.n : phl.tupx
phl.uV := phl.tup != phl.tup[1] ? b.v : phl.uV

if barstate.islast

line.set_xy1(
phl.top
, phl.tupx
, phl.tup
)

line.set_xy2(
phl.top
, b.n + 50
, phl.tup
)

label.set_x(
lbl
, b.n + 50
)

label.set_y(
lbl
, phl.tup
)

dist = math.abs(phl.uV / (phl.uV + phl.dV)) * 100

label.set_text (lbl, trend < 0
? "Strong High | " + str.tostring(phl.uV, format.volume) + " (" +
str.tostring(math.round(dist,0)) + "%)"
: "Weak High | " + str.tostring(phl.uV, format.volume) + " (" +
str.tostring(math.round(dist,0)) + "%)")

dnphl(trend) =>

var label lbl = label.new(

na
 , na
, color = invcol
, textcolor = btmlvl
, style = label.style_label_up
, size = size.small
)

if btm

phl.sbottomcross := true
phl.txtdn := btm > phl.bottomy ? "LH" : "LL"

if show_lbl

btml = label.new(
b.n - swing_r_lookback
, btm, phl.txtdn
, color = invcol
, textcolor = btmlvl
, style = label.style_label_up
, size = size.small
)

line.delete(phl.bottom[1])

phl.bottom := line.new(
b.n - sLen
, btm
, b.n
, btm
, color = btmlvl
)

phl.bottomy := btm
phl.bottomx := b.n - sLen
phl.tdn := btm
phl.tdnx := b.n - sLen

if ibtm

phl.ibottomcross := true
phl.ibottomy := ibtm
phl.ibottomx := b.n - iLen

phl.tdn := math.min(low, phl.tdn)

phl.tdnx := phl.tdn == low ? b.n : phl.tdnx
phl.dV := phl.tdn != phl.tdn[1] ? b.v : phl.dV

if barstate.islast

line.set_xy1(
phl.bottom
, phl.tdnx
, phl.tdn
)

line.set_xy2(
phl.bottom
, b.n + 50
 , phl.tdn
)

label.set_x(
lbl
, b.n + 50
)

label.set_y(
lbl
, phl.tdn
)

dist = math.abs(phl.dV / (phl.uV + phl.dV)) * 100

label.set_text (lbl, trend > 0
? "Strong Low | " + str.tostring(phl.dV, format.volume) + " (" +
str.tostring(math.round(dist,0)) + "%)"
: "Weak Low | " + str.tostring(phl.uV, format.volume) + " (" +
str.tostring(math.round(dist,0)) + "%)")

midphl() =>

avg = math.avg(phl.bottom.get_y2(), phl.top.get_y2())

var line l = line.new(

y1 = avg
, y2 = avg
, x1 = b.n - sLen
, x2 = b.n + 50
, color = midlvl
, style = line.style_solid
)

var label lbl = label.new(

x = b.n + 50
, y = avg
, text = "Equilibrium"
, style = label.style_label_left
, color = invcol
, textcolor = midlvl
, size = size.small
)

if barstate.islast

more = (phl.bottom.get_x1() + phl.bottom.get_x2()) > (phl.top.get_x1() +

phl.top.get_x2()) ? phl.top.get_x1() : phl.bottom.get_x1()
line.set_xy1(l , more , avg)
line.set_xy2(l , b.n + 50, avg)
label.set_x (lbl , b.n + 50 )
label.set_y (lbl , avg )
dist = math.abs((l.get_y2() - close) / close) * 100
label.set_text (lbl, "Equilibrium (" + str.tostring(math.round(dist,0)) +
"%)")

hqlzone() =>

if barstate.islast
 var hqlzone dZone = hqlzone.new(
box.new(
na
, na
, na
, na
, bgcolor = color.new(toplvl, 70)
, border_color = na
)
, box.new(
na
, na
, na
, na
, bgcolor = color.new(midlvl, 70)
, border_color = na
)
, box.new(
na
, na
, na
, na
, bgcolor = color.new(btmlvl, 70)
, border_color = na
)

, label.new(na, na, text = "Premium" , color = invcol, textcolor =

toplvl, style = label.style_label_down, size = size.small)
, label.new(na, na, text = "Equilibrium", color = invcol, textcolor =
midlvl, style = label.style_label_left, size = size.small)
, label.new(na, na, text = "Discount" , color = invcol, textcolor =
btmlvl, style = label.style_label_up , size = size.small)
)

dZone.pbx.set_lefttop(int(math.max(phl.topx, phl.bottomx))
, phl.tup)
dZone.pbx.set_rightbottom(b.n + 50 , 0.95 * phl.tup
+ 0.05 * phl.tdn)

dZone.ebx.set_lefttop(int(math.max(phl.topx, phl.bottomx)), 0.525 * phl.tup

+ 0.475 * phl.tdn)
dZone.ebx.set_rightbottom(b.n + 50 , 0.525 * phl.tdn
+ 0.475 * phl.tup)

dZone.lbx.set_lefttop(int(math.max(phl.topx, phl.bottomx)), 0.95 * phl.tdn

+ 0.05 * phl.tup)
dZone.lbx.set_rightbottom(b.n + 50
, phl.tdn)

dZone.plb.set_xy( int(math.avg(math.max(phl.topx, phl.bottomx), int(b.n +

50))) , phl.tup)
dZone.elb.set_xy( int(b.n + 50)
, math.avg(phl.tup, phl.tdn))
dZone.lbl.set_xy( int(math.avg(math.max(phl.topx, phl.bottomx), int(b.n +
50))) , phl.tdn)

if show_mtb
 upphl (trend)
dnphl (trend)
hqlzone()

//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - End
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - Volumetric Order Block
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}

method eB(box[] b, bool ext, color css, bool swing) =>

b.unshift(
box.new(
na
, na
, na
, na
, xloc = xloc.bar_time
, extend = ext ? extend.right : extend.none
, border_color = swing ? color.new(css, 0) :
color.new(color.white,100)
, bgcolor = css
, border_width = 1
)
)

method eL(line[] l, bool ext, bool solid, color css) =>

l.unshift(
line.new(
na
, na
, na
, na
, width = 1
, color = css
, xloc = xloc.bar_time
, extend = ext ? extend.right : extend.none
 , style = solid ? line.style_solid : line.style_dashed
)
)

method drawVOB(bool cdn, bool bull, color css, int loc, bool swing) =>

[cC, oO, hH, lL, vV] = request.security(

syminfo.tickerid
, ""

, [

close
, open
, high
, low
, volume

, lookahead = barmerge.lookahead_off
)
var obC obj = obC.new(
array.new<float>()
, array.new<float>()
, array.new< int >()
, array.new<float>()
, array.new<float>()
, array.new<float>()
, array.new< int >()
, array.new< int >()
, array.new< int >()
, array.new< int >()
, array.new<float>()
, array.new<float>()
, array.new< int >()
)

var obD draw = obD.new(

array.new<box >()
, array.new<box >()
, array.new<box >()
, array.new<box >()
, array.new<line>()
)

if barstate.isfirst

for i = 0 to ob_num - 1

draw.mL .eL(false, false, use_grayscale ? color.new(color.gray, 0) :

color.new(css,0))
draw.ob .eB(false, use_grayscale ? color.new(color.gray, 90) : css,
swing)
draw.blB.eB(false, css_metric_up ,
swing)
draw.brB.eB(false, css_metric_dn ,
swing)
draw.eOB.eB(true , use_grayscale ? color.new(color.gray, 90) : css,
swing)

float pos = ob_pos == "Full"

? (bull ? high : low)
: ob_pos == "Middle"
? ohlc4
: ob_pos == "Accurate"
? hl2
: hl2

if cdn

obj.h.clear()
obj.l.clear()
obj.n.clear()

for i = 1 to math.abs((loc - b.n)) - 1

obj.h.push(hH[i])
obj.l.push(lL[i])
obj.n.push(b.t[i])

// obj.h.reverse()
// obj.l.reverse()

int iU = obj.l.indexof(obj.l.min()) + 1
int iD = obj.h.indexof(obj.h.max()) + 1

obj.dir.unshift(
bull
? (b.c[iU] > b.o[iU] ? 1 : -1)
: (b.c[iD] > b.o[iD] ? 1 : -1)
)

obj.top.unshift(
bull
? pos[iU]
: obj.h.max()
)

obj.btm.unshift(
bull
? obj.l.min()
: pos[iD]
)

obj.left.unshift(
bull
? obj.n.get(obj.l.indexof(obj.l.min()))
: obj.n.get(obj.h.indexof(obj.h.max()))
)

obj.avg.unshift(
math.avg(obj.top.first(), obj.btm.first())
)

obj.cV.unshift(
bull
? b.v[iU]
 : b.v[iD]
)

if ob_pos == "Precise"

switch bull
true =>
if obj.avg.get(0) < (b.c[iU] < b.o[iU] ? b.c[iU] : b.o[iU]) and
obj.top.get(0) > hlcc4[iU]
obj.top.set(0, obj.avg.get(0))
obj.avg.set(0, math.avg(obj.top.first(), obj.btm.first()))
false =>
if obj.avg.get(0) > (b.c[iU] < b.o[iU] ? b.o[iD] : b.c[iD]) and
obj.btm.get(0) < hlcc4[iD]
obj.btm.set(0, obj.avg.get(0))
obj.avg.set(0, math.avg(obj.top.first(), obj.btm.first()))

obj.blVP.unshift ( 0 )
obj.brVP.unshift ( 0 )
obj.wM .unshift ( 1 )

if use_overlap

int rmP = use_overlap_method == "Recent" ? 1 : 0

if obj.avg.size() > 1

if bull

? obj.btm.first() < obj.top.get(1)

: obj.top.first() > obj.btm.get(1)
obj.wM .remove(rmP)
obj.cV .remove(rmP)
obj.dir .remove(rmP)
obj.top .remove(rmP)
obj.avg .remove(rmP)
obj.btm .remove(rmP)
obj.left .remove(rmP)
obj.blVP .remove(rmP)
obj.brVP .remove(rmP)

if barstate.isconfirmed

for x = 0 to ob_num - 1

tg = switch ob_mitigation
"Middle" => obj.avg
"Absolute" => bull ? obj.btm : obj.top

for [idx, pt] in tg

if (bull ? cC < pt : cC > pt)

obj.wM .remove(idx)
obj.cV .remove(idx)
obj.dir .remove(idx)
obj.top .remove(idx)
obj.avg .remove(idx)
obj.btm .remove(idx)
obj.left .remove(idx)
 obj.blVP .remove(idx)
obj.brVP .remove(idx)

if barstate.islast

if obj.avg.size() > 0

// Alert

if bull
? ta.crossunder(low , obj.top.get(0))
: ta.crossover (high, obj.btm.get(0))
switch bull
true => blalert.obtouch := true
false => bralert.obtouch := true

float tV = 0
obj.dV.clear()
seq = math.min(ob_num - 1, obj.avg.size() - 1)

for j = 0 to seq

tV += obj.cV.get(j)

if j == seq

for y = 0 to seq

obj.dV.unshift(
math.floor(
(obj.cV.get(y) / tV) * 100)
)

obj.dV.reverse()

for i = 0 to math.min(ob_num - 1, obj.avg.size() - 1)

dmL = draw.mL .get(i)

dOB = draw.ob .get(i)
dblB = draw.blB.get(i)
dbrB = draw.brB.get(i)
deOB = draw.eOB.get(i)

dOB.set_lefttop (obj.left .get(i) , obj.top.get(i))

deOB.set_lefttop (b.t , obj.top.get(i))
dOB.set_rightbottom (b.t , obj.btm.get(i))
deOB.set_rightbottom(b.t + (b.t - b.t[1]) * 100 , obj.btm.get(i))

if use_middle_line

dmL.set_xy1(obj.left.get(i), obj.avg.get(i))
dmL.set_xy2(b.t , obj.avg.get(i))

if ob_metrics_show

dblB.set_lefttop (obj.left.get(i), obj.top.get(i))

dbrB.set_lefttop (obj.left.get(i), obj.avg.get(i))
dblB.set_rightbottom(obj.left.get(i), obj.avg.get(i))
 dbrB.set_rightbottom(obj.left.get(i), obj.btm.get(i))

rpBL = dblB.get_right()
rpBR = dbrB.get_right()
dbrB.set_right(rpBR + (b.t - b.t[1]) * obj.brVP.get(i))
dblB.set_right(rpBL + (b.t - b.t[1]) * obj.blVP.get(i))

if use_show_metric

txt = switch

obj.cV.get(i) >= 1000000000 =>

str.tostring(math.round(obj.cV.get(i) / 1000000000,3)) + "B"
obj.cV.get(i) >= 1000000 =>
str.tostring(math.round(obj.cV.get(i) / 1000000,3)) + "M"
obj.cV.get(i) >= 1000 =>
str.tostring(math.round(obj.cV.get(i) / 1000,3)) + "K"
obj.cV.get(i) < 1000 =>
str.tostring(math.round(obj.cV.get(i)))

deOB.set_text(
str.tostring(
txt + " (" + str.tostring(obj.dV.get(i)) + "%)")
)

deOB.set_text_size (obtxt.txSz())
deOB.set_text_halign(text.align_left)
deOB.set_text_color (use_grayscale ? color.silver :
color.new(css, 0))

if ob_metrics_show and barstate.isconfirmed

if obj.wM.size() > 0

for i = 0 to obj.avg.size() - 1

switch obj.dir.get(i)

1 =>

switch obj.wM.get(i)

1 => obj.blVP.set(i, obj.blVP.get(i) + 1),

obj.wM.set(i, 2)
2 => obj.blVP.set(i, obj.blVP.get(i) + 1),
obj.wM.set(i, 3)
3 => obj.brVP.set(i, obj.brVP.get(i) + 1),
obj.wM.set(i, 1)
-1 =>

switch obj.wM.get(i)

1 => obj.brVP.set(i, obj.brVP.get(i) + 1),

obj.wM.set(i, 2)
2 => obj.brVP.set(i, obj.brVP.get(i) + 1),
obj.wM.set(i, 3)
3 => obj.blVP.set(i, obj.blVP.get(i) + 1),
obj.wM.set(i, 1)
var hN = array.new<int>(1, b.n)
var lN = array.new<int>(1, b.n)
var hS = array.new<int>(1, b.n)
var lS = array.new<int>(1, b.n)

if iH

hN.pop()
hN.unshift(int(b.n[iLen]))

if iL

lN.pop()
lN.unshift(int(b.n[iLen]))

if sH

hS.pop()
hS.unshift(int(b.n[sLen]))

if sL

lS.pop()
lS.unshift(int(b.n[sLen]))

if ob_show

bull_ob.drawVOB(true , ob_bull_css, hN.first(), false)

bear_ob.drawVOB(false, ob_bear_css, lN.first(), false)

if ob_swings

s_bull_ob.drawVOB(true , css_swing_up, hS.first(), true)

s_bear_ob.drawVOB(false, css_swing_dn, lS.first(), true)

if bull_ob
blalert.ob := true

if bear_ob
bralert.ob := true

if s_bull_ob
blalert.swingob := true

if s_bear_ob
blalert.swingob := true

//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - End
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}

//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - FVG | VI | OG
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}

ghl() => request.security(syminfo.tickerid, fvg_tf, [high[2], low[2], close[1],

open[1]])
tfG() => request.security(syminfo.tickerid, fvg_tf, [open, high, low, close])

cG(bool bull) =>

[h, l, c, o] = ghl()
[go, gh, gl, gc] = tfG()

var FVG draw = FVG.new(

array.new<box>()
, array.new<line>()
)

var FVG[] cords = array.new<FVG>()

float pup = na
float pdn = na
bool cdn = na
int pos = 2
cc = timeframe.change(fvg_tf)

if barstate.isfirst

for i = 0 to fvg_num - 1

draw.box.unshift(box.new (na, na, na, na, border_color =

color.new(color.white, 100), xloc = xloc.bar_time))
draw.ln.unshift (line.new(na, na, na, na, xloc = xloc.bar_time, width =
1, style = line.style_solid))

switch what_fvg

"FVG" =>

pup := bull ? gl : l
pdn := bull ? h : gh
cdn := bull ? gl > h and cc : gh < l and cc
pos := 2

"VI" =>
 pup := bull
? (gc > go
? go
: gc)
: (gc[1] > go[1]
? go[1]
: gc[1])
pdn := bull
? (gc[1] > go[1]
? gc[1]
: go[1])
: (gc > go
? gc
: go)
cdn := bull
? go > gc[1] and gh[1] > gl and gc > gc[1] and go > go[1] and
gh[1] < math.min(gc, go) and cc
: go < gc[1] and gl[1] < gh and gc < gc[1] and go < go[1] and
gl[1] > math.max(gc, go) and cc
pos := 1

"OG" =>

pup := bull ? b.l : gl[1]

pdn := bull ? gh[1] : gh
cdn := bull ? gl > gh[1] and cc : gh < gl[1] and cc
pos := 1

if not na(cdn) and cdn

cords.unshift(
FVG.new(
na
, na
, bull
? true
: false
, pup
, pdn
, b.t - (b.t - b.t[1]) * pos
, b.t + (b.t - b.t[1]) * fvg_extend)
)

if bull
blalert.fvg := true
else
bralert.fvg := true

if barstate.isconfirmed

for [idx, obj] in cords

if obj.bull ? b.c < obj.btm : b.c > obj.top

cords.remove(idx)

if barstate.islast

if cords.size() > 0
 for i = math.min(fvg_num - 1, cords.size() - 1) to 0

gbx = draw.box.get(i)
gln = draw.ln.get(i)
gcd = cords.get(i)

gtop = gcd.top
gbtm = gcd.btm
left = gcd.left
right = gcd.right

gbx.set_lefttop(left, gtop)
gbx.set_rightbottom(right, gbtm)
gbx.set_bgcolor(gcd.bull ? fvg_upcss : fvg_dncss)

gln.set_xy1(left, math.avg(gbx.get_top(), gbx.get_bottom()))

gln.set_xy2(right, math.avg(gbx.get_top(), gbx.get_bottom()))
gln.set_color(gcd.bull ? fvg_upcss : fvg_dncss)

if fvg_enable

cG(true )
cG(false)

//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - END
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - Accumulation And Distribution
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}

drawZone(int len) =>

var zone[] z = array.new<zone>()

if iH

z.unshift(
 zone.new(
chart.point.from_time(
time[len]
, high [len]
)
, high [len]
, 1
, time[len]
)
)
if iL
z.unshift(
zone.new(
chart.point.from_time(
time[len]
, low [len]
)
, low [len]
, -1
, time[len]
)
)
if z.size() > 1
if z.get(0).c == z.get(1).c
z.clear()

switch

zone_mode == "Slow" =>

if z.size() > 5

if z.get(0).c == -1 and z.get(1).c == 1 and z.get(2).c == -1 and

z.get(3).c == 1 and z.get(4).c == -1 and z.get(5).c == 1

if z.get(0).p > z.get(2).p and z.get(2).p > z.get(4).p

if z.get(1).p < z.get(3).p and z.get(3).p < z.get(5).p

blalert.zone := true

box.new(top = z.get(5).p, bottom = z.get(4).p, left =

z.get(5).t, right = z.get(0).t, bgcolor = acc_css, border_color =
color.new(color.white, 100), xloc = xloc.bar_time)
slice = array.new<chart.point>()

for i = 0 to 5

slice.unshift(z.get(i).points)

polyline.new(slice, xloc = xloc.bar_time, line_color =

color.new(acc_css, 0), line_width = 2)
p.found := "Accumulation Zone"
p.bull := true
p.isfound := true
p.period := 0
z.clear()

if z.size() > 5
 if z.get(0).c == 1 and z.get(1).c == -1 and z.get(2).c == 1 and
z.get(3).c == -1 and z.get(4).c == 1 and z.get(5).c == -1

if z.get(0).p < z.get(2).p and z.get(2).p < z.get(4).p

if z.get(1).p > z.get(3).p and z.get(3).p > z.get(5).p

bralert.zone := true

box.new(top = z.get(5).p, bottom = z.get(4).p, left =

z.get(5).t, right = z.get(0).t, bgcolor = dist_css, border_color =
color.new(color.white, 100), xloc = xloc.bar_time)
slice = array.new<chart.point>()

for i = 0 to 5

slice.unshift(z.get(i).points)

polyline.new(slice, xloc = xloc.bar_time, line_color =

color.new(dist_css, 0), line_width = 2)
p.found := "Distribution Zone"
p.bull := false
p.isfound := true
p.period := 0
z.clear()

zone_mode == "Fast" =>

if z.size() > 3

if z.get(0).c == -1 and z.get(1).c == 1 and z.get(2).c == -1 and

z.get(3).c == 1

if z.get(0).p > z.get(2).p

if z.get(1).p < z.get(3).p

blalert.zone := true

box.new(top = z.get(3).p, bottom = z.get(2).p, left =

z.get(3).t, right = z.get(0).t, bgcolor = acc_css, border_color =
color.new(color.white, 100), xloc = xloc.bar_time)
slice = array.new<chart.point>()

for i = 0 to 3

slice.unshift(z.get(i).points)

polyline.new(slice, xloc = xloc.bar_time, line_color =

color.new(acc_css, 0), line_width = 2)
p.found := "Accumulation Zone"
p.bull := true
p.isfound := true
p.period := 0
z.clear()

if z.size() > 3
 if z.get(0).c == 1 and z.get(1).c == -1 and z.get(2).c == 1 and
z.get(3).c == -1

if z.get(0).p < z.get(2).p

if z.get(1).p > z.get(3).p

bralert.zone := true

box.new(top = z.get(2).p, bottom = z.get(3).p, left =

z.get(3).t, right = z.get(0).t, bgcolor = dist_css, border_color =
color.new(color.white, 100), xloc = xloc.bar_time)
slice = array.new<chart.point>()

for i = 0 to 3

slice.unshift(z.get(i).points)

polyline.new(slice, xloc = xloc.bar_time, line_color =

color.new(dist_css, 0), line_width = 2)
p.found := "Distribution Zone"
p.bull := false
p.isfound := true
p.period := 0
z.clear()

if show_acc_dist_zone

drawZone(iLen)

//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - END
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - EQH / EQL
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}

dEHL() =>
 var ehl w = ehl.new(0, 0, 0, 0)
top = ta.pivothigh(high, 1, 1)
btm = ta.pivotlow(low , 1, 1)
atr = ta.atr(200)

switch

top =>

mx = math.max(top, w.pt)
mn = math.min(top, w.pt)

switch

mx < mn + atr * 0.1 =>

var aZ = array.new<line>()
var aL = array.new<label>()

if aZ.size() > 50

aZ.pop().delete()
aL.pop().delete()

aZ.unshift(line.new(w.t, w.pt, b.n - 1, top, color =

i_ms_dn_BOS, style = line.style_dotted))
aL.unshift(label.new(int(math.avg(b.n - 1, w.t)), top, "EQH",
color = invcol, textcolor = i_ms_dn_BOS, style = label.style_label_down, size =
size.tiny))

bralert.equal := true

w.pt := top
w.t := b.n - 1

btm =>

mx = math.max(btm, w.pb)
mn = math.min(btm, w.pb)

switch

mn > mx - atr * 0.1 =>

var aZ = array.new<line>()
var aL = array.new<label>()

if aZ.size() > 50

aZ.pop().delete()
aL.pop().delete()

aZ.unshift(line.new(w.b, w.pb, b.n - 1, btm, color =

i_ms_up_BOS, style = line.style_dotted))
aL.unshift(label.new(int(math.avg(b.n - 1, w.b)), btm, "EQL",
color = invcol, textcolor = i_ms_up_BOS, style = label.style_label_up, size =
size.tiny))
 blalert.equal := true

w.pb := btm
w.b := b.n - 1

if show_eql
dEHL()

//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - End
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - Plotting And Coloring
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}

p_css = css
b_css = css
w_css = css

p_css := plotcandle_bool ? (css) : na

b_css := barcolor_bool ? (css) : na
w_css := plotcandle_bool ? color.rgb(120, 123, 134, 50) : na

plotcandle(open,high,low,close , color = p_css , wickcolor = w_css , bordercolor =

p_css , editable = false)
barcolor(b_css, editable = false)

//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - END
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}

alertcondition(blalert.bos , "Bullish BOS", "Bullish BOS")

alertcondition(blalert.choch , "Bullish CHOCH", "Bullish CHOCH")
alertcondition(blalert.chochplus , "Bullish CHOCH+", "Bullish CHOCH+")
alertcondition(blalert.chochplusswing, "Bullish Swing CHOCH+", "Bullish Swing
CHOCH+")
alertcondition(blalert.chochswing , "Bullish Swing CHOCH", "Bullish CHOCH")
alertcondition(blalert.swingbos , "Bullish Swing BOS", "Bullish Swing BOS")
alertcondition(blalert.equal , "EQL", "EQL")
alertcondition(blalert.fvg , "Bullish FVG", "Bullish FVG")
alertcondition(blalert.ob , "Bullish Order Block", "Bullish Order
Block")
alertcondition(blalert.swingob , "Bullish Swing Order Block", "Bullish Swing
Order Block")
alertcondition(blalert.zone , "Accumulation Zone", "Accumulation Zone")
alertcondition(blalert.obtouch , "Candle Entering in a Bullish Order Block",
"Candle Entering in a Bullish Order Block")

alertcondition(bralert.bos , "Bearish BOS", "Bearish BOS")

alertcondition(bralert.choch , "Bearish CHOCH", "Bearish CHOCH")
alertcondition(bralert.chochplus , "Bearish CHOCH+", "Bearish CHOCH+")
alertcondition(bralert.chochplusswing, "Bearish Swing CHOCH+", "Bearish Swing
CHOCH+")
alertcondition(bralert.chochswing , "Bearish Swing CHOCH", "Bearish CHOCH")
alertcondition(bralert.swingbos , "Bearish Swing BOS", "Bearish Swing BOS")
alertcondition(bralert.equal , "EQH", "EQH")
alertcondition(bralert.fvg , "Bearish FVG", "Bearish FVG")
alertcondition(bralert.ob , "Bearish Order Block", "Bearish Order
Block")
alertcondition(bralert.swingob , "Bearish Swing Order Block", "Bearish Swing
Order Block")
alertcondition(bralert.zone , "Distribution Zone", "Distribution Zone")
alertcondition(bralert.obtouch , "Candle Entering in a Bearish Order Block",
"Candle Entering in a Bearish Order Block")

if barstate.isfirst
var table errorBox = table.new(position.bottom_right, 1, 1, bgcolor =
color.new(#363a45, 100))
table.cell(errorBox, 0, 0, "© Stratify", text_color = color.gray,
text_halign = text.align_center, text_size = size.normal)