Price Action Concepts Indicator

// 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/
//@version=5
indicator("[v1.4.5] Price Action Toolkit", "[v1.4.5] Price Action Toolkit "
, overlay = true
, max_labels_count = 500
, max_lines_count = 500
, max_boxes_count = 500
, max_bars_back = 500)
//-----------------------------------------------------------------------------{
//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 (3
, "" , 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
s_ms_up_BOS = input.color (#089981
s_ms_dn_BOS = input.color (#f23645
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
css_m = input.color (color.blue
css_y = input.color (color.blue
s_d = input.string ('⎯⎯⎯'
, '' , inline = '1', group = 'HIGHS & LOWS MTF'
, options = ['⎯⎯⎯', '----', '····'])
s_w = input.string ('⎯⎯⎯'
, options = ['⎯⎯⎯', '----', '····'])
s_m = input.string ('⎯⎯⎯'
, options = ['⎯⎯⎯', '----', '····'])
s_y = input.string ('⎯⎯⎯'
, 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, 40)
, " " , inline = "2", group = "VOLUMETRIC ORDER BLOCKS")
css_metric_dn = input.color (color.new(#f23645 , 40)
, "" , inline = "2", 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
("Full" , "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")
obtxt = input.string("Normal" , "Metric Size"
, ["Tiny", "Small", "Normal", "Large", "Huge"], inline = "8", group = "VOLUMETRIC
ORDER BLOCKS" )
use_middle_line = input.bool (true
, "Show Middle-Line" , inline = "9", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Show mid-line order blocks")
use_overlap = input.bool (true
, "Hide Overlap" , inline = "10", 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 , 80)
ob_bear_css = input.color (color.new(#f23645 , 80)
show_acc_dist_zone = input.bool (false

, "" , inline = "1", group = "Accumulation And
Distribution")
zone_mode = input.string ("Fast"
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)
Distribution")
dist_css = input.color (color.new(#f23645 , 60)
Distribution")
show_lbl = input.bool (true

, "Show swing point" , inline = "1", group = "High and Low"
, tooltip = "Display swing point")
show_mtb = input.bool (true
, "Show High/Low/Equilibrium" , inline = "2", group = "High and Low"
, tooltip = "Display Strong/Weak High And Low and Equilibrium")
toplvl = input.color (color.rgb(255, 0, 0)
, "Premium Zone " , inline = "3", group = "High and Low")
midlvl = input.color
(color.gray , "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")
rsi_enable = input.bool (true
, "Enable RSI" , group = "RSI"
, tooltip = "Plot overbought and oversold price to bars")
rsi_src = close
rsi_overbought_src = close
rsi_oversold_src = close
rsi_length = input.int (14, minval=1
, title="Length" , group = "RSI")
rsi_overbought_length = input.int (70, minval=1
, title="Overbought " , inline="overbought"
, group = "RSI")
rsi_oversold_length = input.int (30, minval=1
, title="Oversold " , inline = "oversold"
, group = "RSI")
rsi_overbought_color = input.color (color.green
, "", inline = "overbought" , group = "RSI")
rsi_oversold_color = input.color (color.red
, "", inline = "oversold" , group = "RSI")
t = color.t (ob_bull_css)
invcol = color.new (color.white
, 100)
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 =
[pmh, pml] = request.security(syminfo.tickerid , 'M' , hl() , lookahead =
[pyh, pyl] = request.security(syminfo.tickerid , '12M', hl() , lookahead =
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
, color = css
, style = lstyle(pdhl_style)
)
var label lbl = label.new(

na
, na
, 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
, text = str.format('P{0}H', tf)
, color = invcol
, textcolor = css
, size = size.small
)
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
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - RSI
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
up = ta.rma(math.max(ta.change(rsi_src), 0), rsi_length)

down = ta.rma(-math.min(ta.change(rsi_src), 0), rsi_length)
rsi = down == 0 ? 100 : up == 0 ? 0 : 100 - (100 / (1 + up / down))
isoverbought() => rsi > rsi_overbought_length

isoversold() => rsi < rsi_oversold_length
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - 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>()
)
var ms sup = ms.new(

array.new<float>()
)
var ms sdn = ms.new(

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) ,
"None" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, 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 ),
"None" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, 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

bear_ob := true
bear_ob := true
bear_ob := true
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

s_bull_ob := true
s_bull_ob := true
s_bull_ob := true
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

s_bear_ob := true
s_bear_ob := true
s_bear_ob := true
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)
[_, _, _, itrend5, _, _, _, _, _, _, _] = request.security("", "5" ,

structure(true))
structure(true))
structure(true))
[_, _, _, itrend1H, _, _, _, _, _, _, _] = request.security("", "60" ,
structure(true))
[_, _, _, itrend4H, _, _, _, _, _, _, _] = request.security("", "240" ,
structure(true))
[_, _, _, itrend1D, _, _, _, _, _, _, _] = request.security("", "1440" ,
structure(true))
[_, _, _, itrend1W, _, _, _, _, _, _, _] = request.security("", "1W" ,
structure(true))
[_, _, _, itrend1M, _, _, _, _, _, _, _] = request.security("", "1M" ,
structure(true))
rsi_value = ta.rsi(close, rsi_length)

rsi_value_str = str.format("{0,number,#.##}", rsi_value)
if show_mtf_str
var tab = table.new(position = position.top_right, columns = 20, rows = 20,
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 = "5m" , text_color = color.silver, text_halign =
text.align_center, text_size = size.normal, bgcolor = chart.bg_color,
text_font_family = font.family_monospace, width = 4)
table.cell(tab, 0, 4, text = "1H" , text_color = color.silver, text_halign =
table.cell(tab, 0, 5, text = "4H" , text_color = color.silver, text_halign =
table.cell(tab, 0, 6, text = "1D" , text_color = color.silver, text_halign =
table.cell(tab, 0, 7, text = "1W" , text_color = color.silver, text_halign =
table.cell(tab, 0, 8, text = "1M" , text_color = color.silver, text_halign =
table.cell(tab, 0, 9, text = "RSI" , text_color = color.yellow, text_halign =
table.cell(tab, 1, 1, text = itrend5 == 1 ? "BULLISH" : itrend5 == -1 ?

"BEARISH" : na , text_halign = text.align_center, text_size = size.normal,
text_color = itrend5 == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend5 == -1 ?
i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color,
text_font_family = font.family_monospace)
table.cell(tab, 1, 4, text = itrend1H == 1 ? "BULLISH" : itrend1H == -1 ?
text_color = itrend1H == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1H == -1 ?
table.cell(tab, 1, 5, text = itrend4H == 1 ? "BULLISH" : itrend4H == -1 ?
text_color = itrend4H == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend4H == -1 ?
table.cell(tab, 1, 6, text = itrend1D == 1 ? "BULLISH" : itrend1D == -1 ?
text_color = itrend1D == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1D == -1 ?
table.cell(tab, 1, 7, text = itrend1W == 1 ? "BULLISH" : itrend1W == -1 ?
text_color = itrend1W == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1W == -1 ?
table.cell(tab, 1, 8, text = itrend1M == 1 ? "BULLISH" : itrend1M == -1 ?
text_color = itrend1M == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1M == -1 ?
table.cell(tab, 1, 9, text = rsi_enable ? rsi_value_str : "DISABLED" ,
text_halign = text.align_center, text_size = size.normal, text_color =
isoverbought() ? i_ms_up_BOS.darkcss(-0.25, true) : isoversold() ?
i_ms_dn_BOS.darkcss(0.25, false) : color.yellow, bgcolor = chart.bg_color,
table.cell(tab, 0, 11, text = "Detected Pattern", text_halign =

text.align_center, text_size = size.normal, text_color = color.silver, bgcolor =
chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 0, 12, 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, text_font_family = font.family_monospace)
table.merge_cells(tab, 0, 11, 1, 11)

table.merge_cells(tab, 0, 12, 1, 12)
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) =>

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) =>

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
)

x = b.n + 50
, y = avg
, text = "Equilibrium"
, 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
, 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
, 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>()
)
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)
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)

obj.wM.set(i, 2)
obj.wM.set(i, 3)
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 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
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - IDM
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//---------------------------------------------------------------------------------
------------------------------------}
//Settings
//---------------------------------------------------------------------------------
------------------------------------{
len = input(50, 'CHoCH Detection Period')
shortLen = input(3, 'IDM Detection Period')
//Styling
bullCss = input(#089981, 'Bullish Elements', group = 'Style')
bearCss = input(#ff5252, 'Bearish Elements', group = 'Style')
showChoch = input(false, "Show CHoCH", group = 'Style')

showBos = input(false, "Show BOS", group = 'Style')
showIdm = input(true, "Show Inducements", inline = 'idm', group = 'Style')

idmCss = input(color.white, "", inline = 'idm', group = 'Style')
showSweeps = input(true, "Show Sweeps", inline = 'sweeps', group = 'Style')

sweepsCss = input(color.white, "", inline = 'sweeps', group = 'Style')
//---------------------------------------------------------------------------------
------------------------------------}
//Functions
//---------------------------------------------------------------------------------
------------------------------------{
//Swings detection/measurements
n = bar_index
swings(len)=>
var os = 0
var int mytopx = na
var int mybtmx = na
upper = ta.highest(len)
lower = ta.lowest(len)
os := high[len] > upper ? 0 : low[len] < lower ? 1 : os[1]
mytop = os == 0 and os[1] != 0 ? high[len] : na

mytopx := os == 0 and os[1] != 0 ? n[len] : mytopx
mybtm = os == 1 and os[1] != 1 ? low[len] : na

mybtmx := os == 1 and os[1] != 1 ? n[len] : mybtmx
[mytop, mytopx, mybtm, mybtmx]
//---------------------------------------------------------------------------------
------------------------------------}
//Swings
//---------------------------------------------------------------------------------
------------------------------------{
[mytop, mytopx, mybtm, mybtmx] = swings(len)
[smytop, smytopx, smybtm, smybtmx] = swings(shortLen)
var os = 0
var mytop_crossed = false
var mybtm_crossed = false
var float max = na

var float min = na
var int max_x1 = na

var int min_x1 = na
var float mytopy = na

var float mybtmy = na
var smytop_crossed = false
var smybtm_crossed = false
//---------------------------------------------------------------------------------
------------------------------------}
//CHoCH Detection
//---------------------------------------------------------------------------------
------------------------------------{
if mytop
mytopy := mytop
mytop_crossed := false
if mybtm
mybtmy := mybtm
mybtm_crossed := false
//Test for CHoCH

if close > mytopy and not mytop_crossed
os := 1
mytop_crossed := true
if close < mybtmy and not mybtm_crossed
os := 0
mybtm_crossed := true
//Display CHoCH
if os != os[1]
max := high
min := low
max_x1 := n
min_x1 := n
smytop_crossed := false
smybtm_crossed := false
if os == 1 and showChoch
line.new(mytopx, mytopy, n, mytopy, color = bullCss, style =
line.style_dashed)
label.new(int(math.avg(n, mytopx)), mytopy, 'CHoCH', color = color(na),
style = label.style_label_down, textcolor = bullCss, size = size.tiny)
else if showChoch
line.new(mybtmx, mybtmy, n, mybtmy, color = bearCss, style =
line.style_dashed)
label.new(int(math.avg(n, mybtmx)), mybtmy, 'CHoCH', color = color(na),
style = label.style_label_up, textcolor = bearCss, size = size.tiny)
smytopy = fixnan(smytop)
smybtmy = fixnan(smybtm)
//---------------------------------------------------------------------------------
------------------------------------}
//Bullish BOS
//---------------------------------------------------------------------------------
------------------------------------{
//IDM
if low < smybtmy and not smybtm_crossed and os == 1 and smybtmy != mybtmy
if showIdm
line.new(smybtmx, smybtmy, n, smybtmy, color = color.white, style =
line.style_dotted)
label.new(int(math.avg(n, smybtmx)), smybtmy, 'IDM', color = color(na),
style = label.style_label_up, textcolor = color.white, size = size.tiny)
smybtm_crossed := true
//BOS
if close > max and smybtm_crossed and os == 1
if showBos
line.new(max_x1, max, n, max, color = bullCss)
label.new(int(math.avg(n, max_x1)), max, 'BOS', color = color(na), style =
label.style_label_down, textcolor = bullCss, size = size.tiny)
smybtm_crossed := false
//---------------------------------------------------------------------------------
------------------------------------}
//Bearish BOS
//---------------------------------------------------------------------------------
------------------------------------{
//IDM
if high > smytopy and not smytop_crossed and os == 0 and smytopy != mytopy
if showIdm
line.new(smytopx, smytopy, n, smytopy, color = color.white, style =
line.style_dotted)
label.new(int(math.avg(n, smytopx)), smytopy, 'IDM', color = color(na),
style = label.style_label_down, textcolor = color.white, size = size.tiny)
smytop_crossed := true
//BOS
if close < min and smytop_crossed and os == 0
if showBos
line.new(min_x1, min, n, min, color = bearCss)
label.new(int(math.avg(n, min_x1)), min, 'BOS', color = color(na), style =
label.style_label_up, textcolor = bearCss, size = size.tiny)
smytop_crossed := false
//---------------------------------------------------------------------------------
------------------------------------}
//Sweeps
//---------------------------------------------------------------------------------
------------------------------------{
if high > max and close < max and os == 1 and n - max_x1 > 1 and showSweeps
line.new(max_x1, max, n, max, color = color.white, style = line.style_dotted)
label.new(int(math.avg(n, max_x1)), max, 'x', color = color(na), style =
label.style_label_down, textcolor = color.white)
if low < min and close > min and os == 0 and n - min_x1 > 1 and showSweeps
line.new(min_x1, min, n, min, color = color.white, style = line.style_dotted)
label.new(int(math.avg(n, min_x1)), min, 'x', color = color(na), style =
label.style_label_up, textcolor = color.white)
//Trailing max/min
max := math.max(high, max)
min := math.min(low, min)
if max > max[1]

max_x1 := n
if min < min[1]
min_x1 := n
//---------------------------------------------------------------------------------
------------------------------------}
//Extensions
//---------------------------------------------------------------------------------
------------------------------------{
var ext_choch = line.new(na,na,na,na, style = line.style_dashed)
var ext_bos = line.new(na,na,na,na)
var ext_idm = line.new(na,na,na,na, style = line.style_dotted, color = idmCss)
var ext_choch_lbl = label.new(na,na, 'CHoCH', color = color(na), size = size.tiny)

var ext_bos_lbl = label.new(na,na, 'BOS' , color = color(na), size = size.tiny)
var ext_idm_lbl = label.new(na,na, 'IDM' , color = color(na), size = size.tiny,
textcolor = idmCss)
if barstate.islast
if os == 1
ext_choch.set_xy1(mybtmx, mybtmy), ext_choch.set_xy2(n, mybtmy),
ext_choch.set_color(bearCss)
ext_choch_lbl.set_xy(n, mybtmy),
ext_choch_lbl.set_style(label.style_label_up), ext_choch_lbl.set_textcolor(bearCss)
ext_bos.set_xy1(max_x1, max), ext_bos.set_xy2(n, max),

ext_bos.set_color(bullCss)
ext_bos_lbl.set_xy(n, max), ext_bos_lbl.set_style(label.style_label_down),
ext_bos_lbl.set_textcolor(bullCss)
if not smybtm_crossed
ext_idm.set_xy1(smybtmx, smybtmy), ext_idm.set_xy2(n+15, smybtmy)
ext_idm_lbl.set_xy(n+15, smybtmy),
ext_idm_lbl.set_style(label.style_label_up)
ext_idm.set_color(idmCss), ext_idm_lbl.set_textcolor(idmCss)
else
ext_idm.set_color(na)
ext_idm_lbl.set_textcolor(na)
else
ext_choch.set_xy1(mytopx, mytopy), ext_choch.set_xy2(n, mytopy),
ext_choch.set_color(bullCss)
ext_choch_lbl.set_xy(n, mytopy),
ext_choch_lbl.set_style(label.style_label_down),
ext_choch_lbl.set_textcolor(bullCss)
ext_bos.set_xy1(min_x1, min), ext_bos.set_xy2(n, min),
ext_bos.set_color(bearCss)
ext_bos_lbl.set_xy(n, min), ext_bos_lbl.set_style(label.style_label_up),
ext_bos_lbl.set_textcolor(bearCss)
if not smytop_crossed
ext_idm.set_xy1(smytopx, smytopy), ext_idm.set_xy2(n+15, smytopy)
ext_idm_lbl.set_xy(n+15, smytopy),
ext_idm_lbl.set_style(label.style_label_down)
ext_idm.set_color(idmCss), ext_idm_lbl.set_textcolor(idmCss)
else
ext_idm.set_color(na)
ext_idm_lbl.set_textcolor(na)
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - 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

z.get(5).t, right = z.get(0).t, bgcolor = dist_css, border_color =
for i = 0 to 5

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

z.get(3).t, right = z.get(0).t, bgcolor = acc_css, border_color =
for i = 0 to 3

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

z.get(3).t, right = z.get(0).t, bgcolor = dist_css, border_color =
for i = 0 to 3

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")
//Trendlines
bool ChartTime = time > chart.left_visible_bar_time and time <

chart.right_visible_bar_time
string CORE = "Trendlines Settings"

var bool TradeisON = false
var bool LongTrade = false
var bool ShortTrade = false
var float TP = 0.0
var float SL = 0.0
int BarTIME = time - time[1]
var line tpLine = na
var label LAB = na
var int UpdatedX = 0
var float UpdatedY = 0.0
var float UpdatedSLP = 0.0
var int UpdatedXLow = 0
var float UpdatedYLow = 0.0
var float UpdatedSLPLow = 0.0
bool Trendlines = input.bool(false, " Show Trendlines", group=CORE, inline="001")

bool ShowTargets = input.bool(false,"Show Targets",group = CORE,inline = "001")
color LineCol1 = color.rgb(109, 111, 111, 100)
int Period = input.int(10, title=' Period ➞',

group = CORE,
inline = "003")
bool Trendtype = input.string(title = " Type ➞",

defval='Wicks',
options=['Wicks', 'Body'],
group = CORE,
inline = "003")
== 'Wicks'
string Extensions = input.string(title=' Extend ➞',

defval=' 25',
options=[' 25', ' 50', ' 75'],
group = CORE,
inline = "003")
ExtenSwitcher(ex) =>
switch ex
' 25' => 1 ,
' 50' => 2 ,
=> 3
WidthSwitcher(ex) =>
switch ex
'1' => 1 ,
'2' => 2 ,
=> 3
StyleSwitcher(style) =>
switch style
'Dashed' => line.style_dashed ,
'Dotted' => line.style_dotted ,
=> line.style_solid
method volAdj(int len)=>

math.min(ta.atr(len) * 0.3, close * (0.3/100)) [20] /2
Zband = volAdj(30)
method Trendlines(float src, int timeIndex,bool dir) =>

var int Start = 1 , var int End = 0 , var int TIME = 1
var float YEnd = 0, var float YStart = 0 , var float Slope = 0
var line Line1 = na
var line Line2 = na
var line Line3 = na
SCR = fixnan(src)
if ta.change(SCR) != 0
TIME := time[timeIndex]
YStart := SCR[1]
Start := TIME[1]
Slope := (SCR - YStart) / (TIME - Start)
Slope
EXTime = ExtenSwitcher(Extensions) * BarTIME * 25

End := TIME + EXTime
YEnd := SCR + EXTime * Slope
if ta.change(SCR) != 0 and not TradeisON[1]

LineCond = Slope * time < 0 ? dir ? na : color.rgb(9, 255, 0, 53) : dir ?
color.rgb(255, 0, 0, 54) : na
if not na(LineCond) and Trendlines
Line1 := line.new(Start,
YStart,
End,
YEnd,
xloc.bar_time,
extend.none,
color=color.new(color.white,100)
)
Line2:=line.new(Start,
YStart - (Zband * 2),
End,
YEnd - (Zband * 2),
xloc.bar_time,
extend.none,
color=color.new(color.black,100)
)
Line3:=line.new(Start,
YStart - (Zband * 1),
End,
YEnd - (Zband * 1),
xloc.bar_time,
extend.none,
color=color.new(color.black,100)
)
linefill.new(Line3,Line2,color= LineCol1)
linefill.new(Line3,Line1,color= LineCond)
[Start, YStart, Slope]
PH = ta.pivothigh(Trendtype ? high : close > open ? close : open, Period, Period /

2)
PL = ta.pivotlow(Trendtype ? low : close > open ? open : close, Period, Period / 2)
method GetlinePrice(int TIME, float Price, float SLOP, int LookB) =>
var float Current = 0.0
EsTime = time - TIME
Current := Price + (EsTime - LookB * BarTIME) * SLOP
Current
method CheckCross(float Price, int StartTime, float StartPrice, float SLP) =>
var float Current = 0.0
var float Previous = 0.0
if StartPrice[Period] != StartPrice
Current := GetlinePrice(StartTime, StartPrice, SLP, 0)
Previous := GetlinePrice(StartTime, StartPrice, SLP, 1)
Crossover = Price[1] < Previous and Price > Current ? 1 : Price[1] >
Previous - (Zband*0.1) and Price < Current - (Zband*0.1) ? -1 : 0
Crossover
[Xx, XZ, SLPXZ] = Trendlines(PH, Period / 2,false)

[XxL, XZL, SLPXZL] = Trendlines(PL, Period / 2, true)
if ta.change(fixnan(PH)) != 0
UpdatedX := Xx
UpdatedY := XZ
UpdatedSLP := SLPXZ
UpdatedSLP
if ta.change(fixnan(PL)) != 0
UpdatedXLow := XxL
UpdatedYLow := XZL
UpdatedSLPLow := SLPXZL
UpdatedSLPLow
Long = not (UpdatedSLP * time > 0)

and CheckCross(close, UpdatedX, UpdatedY, UpdatedSLP)== 1
and not TradeisON
Short = not (UpdatedSLPLow * time < 0)
and CheckCross(close, UpdatedXLow, UpdatedYLow, UpdatedSLPLow)==-1
and not TradeisON
TradeFire = Long or Short
if Long and not TradeisON

LongTrade:= true
ShortTrade:= false
if Short and not TradeisON

LongTrade:= false
ShortTrade:= true
if true
if TradeFire and not TradeisON
TP := switch
Long => high + (Zband *20)
Short => low - (Zband *20)
SL := switch
Long => low - (Zband *20)
Short => high + (Zband *20)
TradeisON:= true
if ShowTargets and Trendlines
line.new(bar_index,
Long ? high : low,
bar_index,
TP,
width=2,
color = color.rgb(154, 103, 20),
style= line.style_dashed)
tpLine:= line.new(bar_index,
TP,
bar_index+2,
TP,
style= line.style_dashed,
color = color.rgb(154, 103, 20)
)
LAB:=label.new(bar_index,
TP,
"Target",
color = color.rgb(154, 103, 20),
style= label.style_label_left,
size=size.small,
textcolor = color.white
)
if TradeisON
line.set_x2(tpLine,bar_index)
label.set_x(LAB,bar_index+1)
if LongTrade and TradeisON

if high >= TP
label.set_color(LAB,color.rgb(6, 128, 10, 37))
TradeisON:=false
if close <= SL
label.set_color(LAB,color.new(color.rgb(246, 7, 7),70))
TradeisON:=false
else if ShortTrade and TradeisON

if low <= TP
label.set_color(LAB,color.rgb(85, 219, 18, 37))
TradeisON:=false
if close >= SL
label.set_color(LAB,color.new(color.rgb(246, 7, 7),70))
TradeisON:=false
const bool DEBUG = false

const int maxBoxesCount = 500
const int showLastXLiqs = 500
const int maxDistanceToLastBar = 5000 // Affects Running Time
// Liquidity Grabs
pivotLenLiq = input.int(25, "Pivot Length", group = "General Configuration",

display = display.none)
WBR = input.float(0.5, "Wick-Body Ratio", step = 0.1, group = "General
Configuration", display = display.none)
sellsideColor = input(#08998180, 'Bullish', inline = 'bsColor', group = 'General

Configuration', display = display.none)
buysideColor = input(#f2364680, 'Bearish', inline = 'bsColor', group = 'General
Configuration', display = display.none)
showInvalidated = DEBUG ? input.bool(true, "Show Historic Zones", group = "General
Configuration", display = display.none) : true
bubbleSize = DEBUG ? input.int(5, "[DBG] Base Bubble Size", group = "Style",
display = display.none) : 5
minDist = DEBUG ? input.int(0, "[DBG] Min Distance", group = "Style", display =
display.none) : 0
grabsPerZone = DEBUG ? input.int(1, "[DBG] Max Grabs Per Zone", group = "Style",
minATRBetweenPivots = DEBUG ? input.float(1, "[DBG] Min ATR Between Pivots", group
= "Style", display = display.none) : 1
bubbleOffset = DEBUG ? input.float(20, "[DBG] Bubble Offset", group = "Style",
textColor = DEBUG ? input.color(#ffffff80, "[DBG] Text Color", group = "Style",
inline = "BBcolors") : #ffffff80
renderLiquidityZones = DEBUG ? input.bool(false, "[DBG] Render Liquidity Zones",
group = "Style") : false
type liqInfo
int startTime
int endTime
float price
string liqType
int grabsFound = 0
type liq
liqInfo info
bool isRendered = false
line liqZone
type bubble
int barIndex
float price
float bodySize
float wickSize
string liqType
safeDeleteLiq (liq liqF) =>

liqF.isRendered := false
line.delete(liqF.liqZone)
var liq[] allLiqList = array.new<liq>(0)
highestTALiq = ta.pivothigh(pivotLenLiq, pivotLenLiq)

lowestTALiq = ta.pivotlow(pivotLenLiq, pivotLenLiq)
curATR = ta.atr(5)
renderLiq (liq liqF) =>

if renderLiquidityZones
liqF.isRendered := true
liqF.liqZone := line.new(liqF.info.startTime, liqF.info.price,
nz(liqF.info.endTime, time + 1), liqF.info.price, xloc = xloc.bar_time, color =
liqF.info.liqType == "Buyside" ? buysideColor : sellsideColor)
handleLiqsFinal () =>
if DEBUG
log.info("Liqudities Count " + str.tostring(allLiqList.size()))
if allLiqList.size() > 0
for i = 0 to allLiqList.size() - 1
curLiq = allLiqList.get(i)
safeDeleteLiq(curLiq)
if not curLiq.isRendered and not (not showInvalidated and not
na(curLiq.info.endTime))
renderLiq(curLiq)
if bar_index > last_bar_index - maxDistanceToLastBar

if na(curLiq.info.endTime) and (curLiq.info.liqType == "Buyside" ?
close > curLiq.info.price : close < curLiq.info.price)
curLiq.info.endTime := time
if not na(highestTALiq)
newLiqInfo = liqInfo.new(time[pivotLenLiq], na, highestTALiq, "Buyside")
addLiq = true
liqInfo curInfo = allLiqList.get(i).info
if na(curInfo.endTime) and curInfo.liqType == "Buyside"
if math.abs(highestTALiq - curInfo.price) < curATR *
minATRBetweenPivots
addLiq := false
break
if addLiq
allLiqList.unshift(liq.new(newLiqInfo))
if allLiqList.size () > showLastXLiqs
safeDeleteLiq(allLiqList.pop())
if not na(lowestTALiq)
newLiqInfo = liqInfo.new(time[pivotLenLiq], na, lowestTALiq, "Sellside")
addLiq = true
liqInfo curInfo = allLiqList.get(i).info
if na(curInfo.endTime) and curInfo.liqType == "Sellside"
if math.abs(lowestTALiq - curInfo.price) < curATR *
minATRBetweenPivots
addLiq := false
break
if addLiq
allLiqList.unshift(liq.new(newLiqInfo))
if allLiqList.size () > showLastXLiqs
safeDeleteLiq(allLiqList.pop())
var lastHigh = 0
var lastLow = 0
renderHighCircle5 = false
float highCirclePrice = na
renderLowCircle5 = false
float lowCirclePrice = na
if not na(curLiq.info.endTime)
continue
if curLiq.info.grabsFound == grabsPerZone
continue
bodySize = math.abs(close - open)

wickSize = curLiq.info.liqType == "Buyside" ? (high - math.max(close,
open)) : (math.min(close, open) - low)
curWBR = wickSize / bodySize

if curLiq.info.liqType == "Buyside"
if high >= curLiq.info.price and (bar_index - lastHigh > minDist)
lastHigh := bar_index
if curWBR >= WBR * 3
renderHighCircle15 := true
else if curWBR >= WBR * 2
else if curWBR >= WBR
highCirclePrice := high + curATR * bubbleOffset / 100.0
curLiq.info.grabsFound += 1
else
if low <= curLiq.info.price and (bar_index - lastLow > minDist)
lastLow := bar_index
if curWBR >= WBR * 3
renderLowCircle15 := true
else if curWBR >= WBR * 2
else if curWBR >= WBR
lowCirclePrice := low - curATR * bubbleOffset / 100.0
curLiq.info.grabsFound += 1
plot(renderHighCircle5 and barstate.isconfirmed ? highCirclePrice : na, "",

buysideColor, bubbleSize, plot.style_circles, false, 0)
buysideColor, int(bubbleSize * 1.5), plot.style_circles, false, 0)
buysideColor, bubbleSize * 2, plot.style_circles, false, 0)
plot(renderLowCircle5 and barstate.isconfirmed ? lowCirclePrice : na, "",

sellsideColor, bubbleSize, plot.style_circles, false, 0)
sellsideColor, int(bubbleSize * 1.5), plot.style_circles, false, 0)
sellsideColor, bubbleSize * 2, plot.style_circles, false, 0)
alertcondition((renderHighCircle5 or renderHighCircle10 or renderHighCircle15) and

barstate.isconfirmed, "Buyside Liquidity Grab @ {{ticker}}", "Buyside Liquidity
Grab @ {{ticker}}")
alertcondition((renderLowCircle5 or renderLowCircle10 or renderLowCircle15) and
barstate.isconfirmed, "Sellside Liquidity Grab @ {{ticker}}", "Sellside Liquidity
Grab @ {{ticker}}")
if barstate.islast
handleLiqsFinal()

Price Action Concepts Indicator

Uploaded by

Copyright:

Available Formats

Price Action Concepts Indicator

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Price Action Concepts Indicator

Uploaded by

Copyright:

Available Formats

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

show_swing_ms = input.string ("All"

i_ms_up_BOS = input.color (#089981

lvl_daily = input.bool (false

ob_show = input.bool (true

ob_filter = input.string ("None"

show_acc_dist_zone = input.bool (false

show_lbl = input.bool (true

fvg_enable = input.bool (false

method txSz(string s) =>

alerts blalert = alerts.new()

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

f_zscore(src, lookback) =>

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

var int iLen = internal_r_lookback

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

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

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

hl () => [high, low]

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

out = switch style

'⎯⎯⎯' => line.style_solid

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

var line hl = line.new(

var line ll = line.new(

var label lbl = label.new(

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

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

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

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

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

up = ta.rma(math.max(ta.change(rsi_src), 0), rsi_length)

isoverbought() => rsi > rsi_overbought_length

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

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

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

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

if msline.size() >= 250

structure(bool mtf) =>

bool isdrw = false

var color css = na

var int itrend = 0

bool bull_ob = false

bool s_bull_ob = false

var ms sup = ms.new(

var ms sdn = ms.new(

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

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

// INTERNAL BULLISH STRUCTURE

not CHoCH =>

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

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

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

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

ob_filter == "None" =>

// INTERNAL BEARISH STRUCTURE

not CHoCH =>

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

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