0% found this document useful (3 votes)

2K views

Price Action Concepts (StratifyTrade)

SMart money

Uploaded by

lcanto18.lc

Available Formats

Download as TXT, PDF, TXT or read online on Scribd

0% found this document useful (3 votes)

2K views

Price Action Concepts (StratifyTrade)

SMart money

Uploaded by

lcanto18.lc

Available Formats

Download as TXT, PDF, TXT or read online on Scribd

You are on page 1/ 59

// 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/
//TELEGRAM ==> https://t.me/+UAk3hqvoD89jZTlk
//@version=5
indicator("Price Action Concepts [StratifyTrade]", shorttitle = "Price Action
Concepts [1.2.1]", overlay = true, max_lines_count = 500, max_labels_count = 500,
max_boxes_count = 500, max_bars_back = 500, max_polylines_count = 100)

//-----------------------------------------------------------------------------{
//Boolean set
//-----------------------------------------------------------------------------{
s_BREAK = 0
s_CHANGE = 1
i_BREAK = 2
i_CHANGE = 3
i_pp_CHANGE = 4
green_candle = 5
red_candle = 6
s_CHANGEP = 7
i_CHANGEP = 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", "CHANGE", "CHANGE+", "BREAK", "None"])
show_internal_ms = input.string ("All"
, "Internal " , inline = "2", group = "MARKET STRUCTURE"
, options = ["All", "CHANGE", "CHANGE+", "BREAK", "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_BREAK = input.color (#089981

, "" , inline = "2", group = "MARKET STRUCTURE")
i_ms_dn_BREAK = input.color (#f23645
, "" , inline = "2", group = "MARKET STRUCTURE")
s_ms_up_BREAK = input.color (#089981
, "" , inline = "1", group = "MARKET STRUCTURE")
s_ms_dn_BREAK = 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 (2
, "" , 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 BREAK/CHANGE/CHANGE+", options =
["None", "BREAK", "CHANGE", "CHANGE+"])
ob_mitigation = input.string ("Absolute"
, "Mitigation " , inline = "4", group = "VOLUMETRIC ORDER BLOCKS"
, tooltip = "Trigger to remove volumetric order blocks", options = ["Absolute",
"Middle"])
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)
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//{ - UDT
}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}
//
{----------------------------------------------------------------------------------
------------------------------------------------------------}

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

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

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)

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
, text_font_family = font.family_monospace
)

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_BREAK , true ), boolean.set(s_CHANGE,

true ) , boolean.set(s_CHANGEP, true )
"CHANGE" => boolean.set(s_BREAK , false), boolean.set(s_CHANGE,
true ) , boolean.set(s_CHANGEP, false )
"CHANGE+" => boolean.set(s_BREAK , false), boolean.set(s_CHANGE,
false) , boolean.set(s_CHANGEP, true )
"BREAK" => boolean.set(s_BREAK , true ), boolean.set(s_CHANGE,
false) , boolean.set(s_CHANGEP, false )
"None" => boolean.set(s_BREAK , false), boolean.set(s_CHANGE,
false) , boolean.set(s_CHANGEP, false )
=> na

switch show_internal_ms

"All" => boolean.set(i_BREAK, true ), boolean.set(i_CHANGE, true ),

boolean.set(i_CHANGEP, true )
"CHANGE" => boolean.set(i_BREAK, false), boolean.set(i_CHANGE, true ),
boolean.set(i_CHANGEP, false)
"CHANGE+" => boolean.set(i_BREAK, false), boolean.set(i_CHANGE, false ),
boolean.set(i_CHANGEP, true )
"BREAK" => boolean.set(i_BREAK, true ), boolean.set(i_CHANGE, false ),
boolean.set(i_CHANGEP, false)
"None" => boolean.set(i_BREAK, false), boolean.set(i_CHANGE, false ),
boolean.set(i_CHANGEP, 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 CHANGE = na
string txt = na

if itrend < 0

CHANGE := true

switch
not CHANGE =>

txt := "BREAK"
css := i_ms_up_BREAK

blalert.bos := true

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

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

CHANGE =>

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

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

"CHANGE"
css := i_ms_up_BREAK.darkcss(0.25, true)

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

boolean.get(i_CHANGEP) : boolean.get(i_CHANGE)) and mtf == false and na(drw)

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

if mtf == false

switch

ob_filter == "None" =>

bull_ob := true
ob_filter == "BREAK" and txt == "BREAK" =>
bull_ob := true
ob_filter == "CHANGE" and txt == "CHANGE" =>
bull_ob := true
ob_filter == "CHANGE+" and txt == "CHANGE+" =>
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 CHANGE = na
string txt = na

if itrend > 0

CHANGE := true

switch

not CHANGE =>

bralert.bos := true

txt := "BREAK"
css := i_ms_dn_BREAK

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

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

CHANGE =>

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

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

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

"CHANGE"
css := i_ms_dn_BREAK.darkcss(0.25, false)

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

boolean.get(i_CHANGEP) : boolean.get(i_CHANGE)) and mtf == false and na(drw)

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

if mtf == false

switch

ob_filter == "None" =>

bear_ob := true
ob_filter == "BREAK" and txt == "BREAK" =>
bear_ob := true
ob_filter == "CHANGE" and txt == "CHANGE" =>
bear_ob := true
ob_filter == "CHANGE+" and txt == "CHANGE+" =>
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 CHANGE = na
string txt = na

if trend < 0

CHANGE := true

switch

not CHANGE =>

blalert.swingbos := true

txt := "BREAK"
icss := s_ms_up_BREAK

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

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

CHANGE =>

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

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

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

"CHANGE"
icss := s_ms_up_BREAK.darkcss(0.25, true)

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

boolean.get(s_CHANGEP) : boolean.get(s_CHANGE)) and mtf == false and na(drw)

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

if mtf == false

switch

ob_filter == "None" =>

s_bull_ob := true
ob_filter == "BREAK" and txt == "BREAK" =>
s_bull_ob := true
ob_filter == "CHANGE" and txt == "CHANGE" =>
s_bull_ob := true
ob_filter == "CHANGE+" and txt == "CHANGE+" =>
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 CHANGE = na
string txt = na

if trend > 0

CHANGE := true

switch

not CHANGE =>

bralert.swingbos := true

txt := "BREAK"
icss := s_ms_dn_BREAK

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

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

CHANGE =>

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

bralert.chochplusswing := true
else
bralert.chochswing := true

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

"CHANGE"
icss := s_ms_dn_BREAK.darkcss(0.25, false)

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

boolean.get(s_CHANGEP) : boolean.get(s_CHANGE)) and mtf == false and na(drw)

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

if mtf == false

switch

ob_filter == "None"
=> s_bear_ob := true
ob_filter == "BREAK" and txt == "BREAK" =>
s_bear_ob := true
ob_filter == "CHANGE" and txt == "CHANGE" =>
s_bear_ob := true
ob_filter == "CHANGE+" and txt == "CHANGE+" =>
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,
text_font_family = font.family_monospace, 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,
text_font_family = font.family_monospace, 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,
text_font_family = font.family_monospace, 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,
text_font_family = font.family_monospace, 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_BREAK.darkcss(-0.25, true) : itrend15 == -1 ?
i_ms_dn_BREAK.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color,
text_font_family = font.family_monospace)
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_BREAK.darkcss(-0.25, true) : itrend1H == -1 ?
i_ms_dn_BREAK.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color,
text_font_family = font.family_monospace)
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_BREAK.darkcss(-0.25, true) : itrend4H == -1 ?
i_ms_dn_BREAK.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color,
text_font_family = font.family_monospace)
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_BREAK.darkcss(-0.25, true) : itrend1D == -1 ?
i_ms_dn_BREAK.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color,
text_font_family = font.family_monospace)

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, text_font_family = font.family_monospace)
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_BREAK.darkcss(-0.25, true) : p.bull == false ? i_ms_dn_BREAK.darkcss(0.25,
false) : na, bgcolor = chart.bg_color, text_font_family = font.family_monospace)

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_BREAK , style =
label.style_label_down , size = size.tiny , text = "")
, label.new(na , na , color = invcol , textcolor = i_ms_up_BREAK , 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
)

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

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.tup - close) / close) * 100

label.set_text (lbl, trend < 0 ? "Strong High" + " (" +
str.tostring(math.round(dist,0)) + "%)" : "Weak High" + " (" +
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 ? "LL" : "LH"

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

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.tdn - close) / close) * 100

label.set_text (lbl, trend > 0 ? "Strong Low" + " (" +
str.tostring(math.round(dist,0)) + "%)" : "Weak Low" + " (" +
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 dZone = hqlzone.new(

box.new(left = int(math.max(phl.topx, phl.bottomx)), top = phl.tup
, right = b.n + 50, bottom = 0.95 * phl.tup + 0.05 * phl.tdn , bgcolor =
color.new(toplvl, 70), border_color = na)
, box.new(left = int(math.max(phl.topx, phl.bottomx)), top = 0.535 *
phl.tup + 0.465 * phl.tdn, right = b.n + 50, bottom = 0.535 * phl.tdn + 0.465 *
phl.tup , bgcolor = color.new(midlvl, 70), border_color = na)
, box.new(left = int(math.max(phl.topx, phl.bottomx)), top = 0.95 *
phl.tdn + 0.05 * phl.tup, right = b.n + 50, bottom = phl.tdn
, bgcolor = color.new(btmlvl, 70), border_color = na)

, label.new(x = int(math.avg(math.max(phl.topx, phl.bottomx), int(b.n

+ 50))), y = phl.tup, text = "Premium" , color = invcol, textcolor = toplvl, style
= label.style_label_down, size = size.small)
, label.new(x = int(b.n + 50)
, y = math.avg(phl.tup, phl.tdn), text = "Equilibrium", color = invcol, textcolor =
midlvl, style = label.style_label_left, size = size.small)
, label.new(x = int(math.avg(math.max(phl.topx, phl.bottomx), int(b.n
+ 50))), y = phl.tdn, text = "Discount", color = invcol, textcolor = btmlvl, style
= label.style_label_up, size = size.small)
)

if show_mtb

upphl (trend)
dnphl (trend)
hqlzone()

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

b.unshift(
box.new(
na
, na
, na
, na
, xloc = xloc.bar_time
, text_font_family = font.family_monospace
, extend = ext ? extend.right : extend.none
, border_color = color.new(color.white,100)
, bgcolor = css
)
)

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

[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
)
draw.blB.eB(false, css_metric_up
)
draw.brB.eB(false, css_metric_dn
)
draw.eOB.eB(true , use_grayscale ? color.new(color.gray, 90) : css
)

if cdn

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

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

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

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

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

obj.top.unshift(
bull
? (
math.avg(
obj.h.max(), obj.l.min()) > obj.h.get(iU)
? obj.h.get(iU)
: math.avg(obj.h.max(), obj.l.min())
)
: obj.h.max()
)

obj.btm.unshift(
bull
? obj.l.min()
: (
math.avg(
obj.h.max(), obj.l.min()) < obj.l.get(iD)
? obj.l.get(iD)
: math.avg(obj.h.max(), obj.l.min())
)
)

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

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

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

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 (size.auto)
deOB.set_text_halign(text.align_left)
deOB.set_text_color (use_grayscale ? color.rgb(255, 255, 255) :
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())

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

if ob_swings

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

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

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
change_tf = 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 change_tf : gh < l and change_tf
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 change_tf
: go < gc[1] and gl[1] < gh and gc < gc[1] and go < go[1] and
gl[1] > math.max(gc, go) and change_tf
pos := 1

"OG" =>

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

pdn := bull ? gh[1] : gh
cdn := bull ? gl > gh[1] and change_tf : gh < gl[1] and change_tf
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)

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(4).p, bottom = z.get(5).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)

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_BREAK, style = line.style_dotted))
aL.unshift(label.new(int(math.avg(b.n - 1, w.t)), top, "EQH",
color = invcol, textcolor = i_ms_dn_BREAK, 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_BREAK, style = line.style_dotted))
aL.unshift(label.new(int(math.avg(b.n - 1, w.b)), btm, "EQL",
color = invcol, textcolor = i_ms_up_BREAK, 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)

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(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")

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)

//@version=5
//// indicator("zizou's Garbage Algo - ", overlay = true)

// Get user input

nbuysell = input.bool(true, 'Buy/Sell Signal', inline = "BSNM",group='BUY/SELL
SIGNAL')
nsensitivity = input.float(defval=2, title="-", inline = "BSNM", minval=1,
maxval=20, group='BUY/SELL SIGNAL')

//candlecolor = input.bool(true, 'Buy/Sell Signal', inline =

"BSNM",group='BUY/SELL SIGNAL')

// Trend Features
LongTrendAverage = input(false, 'Trend Cloud', group='TREND FEATURES')
TrendFollower = input(false, 'Trend Follower', group='TREND FEATURES')
ShowComulus = input(false, 'Comulus Cloud', group='TREND FEATURES')
CirrusCloud = input(false, 'Cirrus Cloud', group='TREND FEATURES')

// Risk Management

levels = input.bool(false, "Show TP/SL Levels" , group = "Risk Management" ,

inline = "MMDB2")
lvlLines = input.bool(false, "Show Lines ", inline="levels", group = "Risk
Management")
linesStyle = input.string("SOLID", "", ["SOLID", "DASHED", "DOTTED"],
inline="levels", group = "Risk Management")
lvlDistance = input.int(1, "Distance", 1, inline="levels2", group = "Risk
Management")
lvlDecimals = input.int(2, " Decimals", 1, 8, inline="levels2", group = "Risk
Management")
atrRisk = input.int(1, "Risk % ", 1, group = "Risk Management" ,
inline="levels3")
atrLen = input.int(14, " ATR Length", 1, group = "Risk Management" ,
inline="levels3")
decimals = lvlDecimals == 1 ? "#.#" : lvlDecimals == 2 ? "#.##" : lvlDecimals == 3
? "#.###" : lvlDecimals == 4 ? "#.####" : lvlDecimals == 5 ? "#.#####" :
lvlDecimals == 6 ? "#.######" : lvlDecimals == 7 ? "#.#######" : "#.########"
// Input settings
history_of_demand_to_keep = 20
show_zigzag = false
show_price_action_labels = false
showsr = input(true, title="Show Support & Resistance", group = 'Support &
Resistance')
swing_length = input.int(defval=8, title="Sensitivity", group = 'Support &
Resistance')
box_width = input.float(defval=4, title="Zone Width", group = 'Support &
Resistance')
box_extend_option = input.string("Right", title="Extend Box", options=["Right",
"Both"], group = 'Support & Resistance')
res = input.timeframe(title='Time Frame', defval='', group="Support & Resistance")
s1 = request.security(syminfo.tickerid, res, showsr, gaps=barmerge.gaps_on)
demand_color = input.color(color.rgb(0,188,212,70), title = 'Support & Resistance
Color', group = 'Support & Resistance')
supply_color = input.color(color.rgb(178,40,51,70), title = '', group = 'Support &
Resistance')

// Signal Generation
supertrend(_close, factor, atrLen) =>
atr = ta.atr(atrLen)
upperBand = _close + factor * atr
lowerBand = _close - factor * atr
prevLowerBand = nz(lowerBand[1])
prevUpperBand = nz(upperBand[1])
lowerBand := lowerBand > prevLowerBand or close[1] < prevLowerBand ?
lowerBand : prevLowerBand
upperBand := upperBand < prevUpperBand or close[1] > prevUpperBand ?
upperBand : prevUpperBand
int direction = na
float superTrend = na
prevSuperTrend = superTrend[1]
if na(atr[1])
direction := 1
else if prevSuperTrend == prevUpperBand
direction := close > upperBand ? -1 : 1
else
direction := close < lowerBand ? 1 : -1
superTrend := direction == -1 ? lowerBand : upperBand
[superTrend, direction]

// SMA
ocAvg = math.avg(open, close)
sma4 = ta.sma(close, 8)
sma5 = ta.sma(close, 9)
sma9 = ta.sma(close, 13)
psar = ta.sar(0.02, 0.02, 0.2)

//*in Easy Words Super Trend + SMA = Signals

[supertrend, direction] = supertrend(close, nsensitivity*2, 11)

source = close, period = 150

// Colors
green = #68b4d0, green2 = #68b4d0
red = #d18c6e, red2 = #d18c6e

adxlen = 15
dilen = 15
dirmov(len) =>
up = ta.change(high)
down = -ta.change(low)
plusDM = na(up) ? na : up > down and up > 0 ? up : 0
minusDM = na(down) ? na : down > up and down > 0 ? down : 0
truerange = ta.rma(ta.tr, len)
plus = fixnan(100 * ta.rma(plusDM, len) / truerange)
minus = fixnan(100 * ta.rma(minusDM, len) / truerange)
[plus, minus]
adx(dilen, adxlen) =>
[plus, minus] = dirmov(dilen)
sum = plus + minus
adx = 100 * ta.rma(math.abs(plus - minus) / (sum == 0 ? 1 : sum), adxlen)
adx
sig = adx(dilen, adxlen)

// range ADX threshold

sidewaysThreshold = input.int(title='ADX Sideways Threshold (10-30)', minval=2,
defval=15)

// boolean expression to see if the ADX is below tehe sideways threshold

bool isSideways = sig < sidewaysThreshold

// adding the option to color the bars when in a trading range

useBarColor = true
bColor = isSideways ? color.new(#4b148d, 0) : na
barcolor(useBarColor ? bColor : na)

barcolor(close > supertrend ? #54b7c4 : #3c3f0d)

// High Lows
y3 = low - (ta.atr(30) * 2), y1B = low - ta.atr(30)
y4 = high + (ta.atr(30) * 2), y2B = high + ta.atr(30)

bull = ta.crossover(close, supertrend) and close >= sma9

bear = ta.crossunder(close, supertrend) and close <= sma9

// Plots

windowsize = 100
offset = 0.9
sigma = 6
//plot(ta.alma(source, windowsize, offset, sigma))
windowsize2 = 310
offset2 = 0.85
sigma2 = 32
//plot(ta.alma(source, windowsize2, offset2, sigma2))

// Chart Features

smoothrng(x, t, m) =>
wper = t * 2 - 1
avrng = ta.ema(math.abs(x - x[1]), t)
smoothrng = ta.ema(avrng, wper) * m
smoothrng
smrng = smoothrng(close, 22, 6)

rngfilt(x, r) =>
rngfilt = x
rngfilt := x > nz(rngfilt[1]) ? x - r < nz(rngfilt[1]) ? nz(rngfilt[1]) : x - r
: x + r > nz(rngfilt[1]) ? nz(rngfilt[1]) : x + r
rngfilt
filt = rngfilt(close, smrng)

//
▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒

upward = 0.0
upward := filt > filt[1] ? nz(upward[1]) + 1 : filt < filt[1] ? 0 : nz(upward[1])
downward = 0.0
downward := filt < filt[1] ? nz(downward[1]) + 1 : filt > filt[1] ? 0 :
nz(downward[1])

filtcolor = upward > 0 ? color.new(#00e2ff, 50) : downward > 0 ? color.new(#fe0100,

50) : color.new(#56328f, 0)

plot(TrendFollower ? filt : na, color=filtcolor, linewidth=1, title='Trend Tracer')

// Trend Cloud
tclength = 600
hullma = ta.wma(2*ta.wma(close, tclength/2)-ta.wma(close, tclength),
math.floor(math.sqrt(tclength)))
plot(LongTrendAverage ? hullma : na, 'Trend Cloud', linewidth=4, color=close[8] >
hullma ? color.new(#00e2ff, 65) : color.new(#fe0100, 65))

// Comulus Cloud
candle = ta.alma(source, windowsize2, offset2, sigma2)
reach = ta.alma(source, windowsize, offset, sigma)
candlep = plot(ShowComulus ? candle : na, color=color.new(color.white, 100))
reachp = plot(ShowComulus ? reach : na, color=color.new(color.white, 100))
fill(reachp, candlep, color= candle > reach ? color.new(#fe0100, 85) :
color.new(#00e2ff, 85))

// Chart Features

x3 = 22
x4 = 9
x5 = 15
x6 = 5

smoothrngX1(x, t, m) =>
wper = t * 2 - 1
avrng = ta.ema(math.abs(x - x[1]), t)
smoothrngX1 = ta.ema(avrng, wper) * m
smoothrngX1
smrngx1x = smoothrngX1(close, x3, x4)
smrngx1x2 = smoothrngX1(close, x5, x6)

rngfiltx1x1(x, r) =>
rngfiltx1x1 = x
rngfiltx1x1 := x > nz(rngfiltx1x1[1]) ? x - r < nz(rngfiltx1x1[1]) ?
nz(rngfiltx1x1[1]) : x - r : x + r > nz(rngfiltx1x1[1]) ? nz(rngfiltx1x1[1]) : x +
r
rngfiltx1x1
filtx1 = rngfiltx1x1(close, smrngx1x)
filtx12 = rngfiltx1x1(close, smrngx1x2)

upwardx1 = 0.0
upwardx1 := filtx1 > filtx1[1] ? nz(upwardx1[1]) + 1 : filtx1 < filtx1[1] ? 0 :
nz(upwardx1[1])
downwardx1 = 0.0
downwardx1 := filtx1 < filtx1[1] ? nz(downwardx1[1]) + 1 : filtx1 > filtx1[1] ? 0 :
nz(downwardx1[1])

filtx1colorx1 = color.rgb(0, 187, 212, 100)

xxx1 = plot(CirrusCloud ? filtx1 : na, color=filtx1colorx1, linewidth=1,
title='Trend Tracer', editable = false)
xxx2 = plot(CirrusCloud ? filtx12 : na, color=filtx1colorx1, linewidth=1,
title='Trend Tracer', editable = false)

fill(xxx1, xxx2, color= filtx1 > filtx12 ? color.new(#fe0100, 65) :

color.new(#00e2ff, 65))

buy = bull and nbuysell ? label.new(bar_index, y3, sma4 >= sma5 ? "Strong Buy" :
"Buy", xloc.bar_index, yloc.price, #68b4d0, label.style_label_up, color.white,
size.normal) : na
sell = bear and nbuysell ? label.new(bar_index, y4, sma4 <= sma5 ? "Strong Sell" :
"Sell", xloc.bar_index, yloc.price, #d18c6e, label.style_label_down, color.white,
size.normal) : na

// Other initializations
avg_volume = ta.sma(volume, 20)
very_weak_multiplier = 0.5
weak_multiplier = 1
strong_multiplier = 1.5
// Rejection handling
var int[] demandRejections = array.new_int(history_of_demand_to_keep, 0)
var int[] supplyRejections = array.new_int(history_of_demand_to_keep, 0)
var int[] demandCreationBars = array.new_int(history_of_demand_to_keep, na)
var int[] supplyCreationBars = array.new_int(history_of_demand_to_keep, na)

var box[] current_demand_box = array.new_box(history_of_demand_to_keep, na)

var box[] current_supply_box = array.new_box(history_of_demand_to_keep, na)

f_check_demand_rejections() =>
for i = 0 to history_of_demand_to_keep - 1
if not na(array.get(demandCreationBars, i))
if bar_index - array.get(demandCreationBars, i) > 15 and bar_index -
array.get(demandCreationBars, i) % 15 == 0
label.new(bar_index, high, "Checking demand rejection",
color=color.red)
dBox = array.get(current_demand_box, i)
if (na(dBox))
continue
withinBox = (high >= box.get_bottom(dBox) and high <=
box.get_top(dBox)) or (close >= box.get_bottom(dBox) and close <=
box.get_top(dBox))
bearishCandlesCount = math.sum(close < open ? 1 : 0, 15)
if withinBox and bearishCandlesCount >= 7
label.new(bar_index, low, "Bearish count > 7",
color=color.blue)
array.set(demandRejections, i, array.get(demandRejections, i) +
1)

f_check_supply_rejections() =>
for i = 0 to history_of_demand_to_keep - 1
if not na(array.get(supplyCreationBars, i))
if bar_index - array.get(supplyCreationBars, i) > 15 and bar_index -
array.get(supplyCreationBars, i) % 15 == 0
label.new(bar_index, low, "Checking supply rejection",
color=color.red)
sBox = array.get(current_supply_box, i)
if (na(sBox))
continue
withinBox = (low <= box.get_top(sBox) and low >=
box.get_bottom(sBox)) or (close <= box.get_top(sBox) and close >=
box.get_bottom(sBox))
bullishCandlesCount = math.sum(close > open ? 1 : 0, 15)
if withinBox and bullishCandlesCount >= 7
label.new(bar_index, high, "Bullish count > 7",
color=color.blue)
array.set(supplyRejections, i, array.get(supplyRejections, i) +
1)

f_array_add_pop(array, new_value_to_add) =>

array.unshift(array, new_value_to_add)
array.pop(array)

f_sh_sl_labels(array, swing_type) =>

var string label_text = na
if swing_type == 1
if array.get(array, 0) >= array.get(array, 1)
label_text := 'HH'
else
label_text := 'LH'
label.new(bar_index - swing_length, array.get(array,0), text = label_text,
style=label.style_label_down, textcolor = color.white, color =
color.new(color.white, 100), size = size.tiny)
else if swing_type == -1
if array.get(array, 0) >= array.get(array, 1)
label_text := 'HL'
else
label_text := 'LL'
label.new(bar_index - swing_length, array.get(array,0), text = label_text,
style=label.style_label_up, textcolor = color.white, color = color.new(color.white,
100), size = size.tiny)

f_check_overlapping(new_poi, box_array, atr) =>

atr_threshold = atr * 2
okay_to_draw = true
for i = 0 to array.size(box_array) - 1
top = box.get_top(array.get(box_array, i))
bottom = box.get_bottom(array.get(box_array, i))
poi = (top + bottom) / 2
upper_boundary = poi + atr_threshold
lower_boundary = poi - atr_threshold
if new_poi >= lower_boundary and new_poi <= upper_boundary
okay_to_draw := false
break
else
okay_to_draw := true
okay_to_draw

f_supply_demand(value_array, bn_array, box_array, label_array, box_type, atr) =>

atr_buffer = atr * (box_width / 10)
box_left = array.get(bn_array, 0)
box_right = bar_index + 20
var float box_top = 0.00
var float box_bottom = 0.00
var float poi = 0.00
if box_type == 1
box_top := array.get(value_array, 0)
box_bottom := box_top - atr_buffer
poi := (box_top + box_bottom) / 2
else if box_type == -1
box_bottom := array.get(value_array, 0)
box_top := box_bottom + atr_buffer
poi := (box_top + box_bottom) / 2
okay_to_draw = f_check_overlapping(poi, box_array, atr)
swing_volume = volume[swing_length]
var string strength_text = ""

highest_volume_last_20 = ta.highest(volume, 20)

volume_percentage = math.round(swing_volume / highest_volume_last_20 * 100)
volume_percentage := math.min(volume_percentage, 100) // Cap the volume
percentage to 100

var extend_option = extend.right

if box_extend_option == "Right"
extend_option := extend.right
else if box_extend_option == "Both"
extend_option := extend.both
if box_type == 1 and okay_to_draw and s1
box.delete( array.get(box_array, array.size(box_array) - 5) )
f_array_add_pop(box_array, box.new( left = box_left, top = box_top, right =
box_right, bottom = box_bottom, border_color = color.rgb(242,54,69,50),
border_width=1,
bgcolor = supply_color, extend = extend_option, text = strength_text,
text_halign = text.align_right, text_valign = text.align_center, text_color =
color.white, text_size = size.small, xloc = xloc.bar_index))
box.delete( array.get(label_array, array.size(label_array) - 5) )
f_array_add_pop(label_array, box.new( left = box_left, top = poi, right =
box_right, bottom = poi, border_color = color.rgb(242,54,69,50), border_width=1,
border_style=line.style_dotted,
bgcolor = color.new(color.black,100), extend = extend_option, text =
'', text_halign = text.align_left, text_valign = text.align_center, text_color =
color.white, text_size = size.small, xloc = xloc.bar_index))
else if box_type == -1 and okay_to_draw and s1
box.delete( array.get(box_array, array.size(box_array) - 5) )
f_array_add_pop(box_array, box.new( left = box_left, top = box_top, right =
box_right, bottom = box_bottom, border_color = color.rgb(0,188,212,50),
border_width=1,
bgcolor = demand_color, extend = extend_option, text = strength_text,
text_halign = text.align_right, text_valign = text.align_center, text_color =
color.white, text_size = size.small, xloc = xloc.bar_index))
box.delete( array.get(label_array, array.size(label_array) - 5) )
f_array_add_pop(label_array, box.new( left = box_left, top = poi, right =
box_right, bottom = poi, border_color = color.rgb(0,188,212,50), border_width=1,
border_style=line.style_dotted,
bgcolor = color.new(color.black,100), extend = extend_option, text =
'', text_halign = text.align_left, text_valign = text.align_center, text_color =
color.white, text_size = size.small, xloc = xloc.bar_index))

f_sd_to_bos(box_array, bos_array, label_array, zone_type) =>

if zone_type == 1
for i = 0 to array.size(box_array) - 1
level_to_break = box.get_top(array.get(box_array,i))
if close >= level_to_break
box.delete(array.get(box_array, i))
box.delete(array.get(label_array, i))
if zone_type == -1
for i = 0 to array.size(box_array) - 1
level_to_break = box.get_bottom(array.get(box_array,i))
if close <= level_to_break
box.delete(array.get(box_array, i))
box.delete(array.get(label_array, i))

f_extend_box_endpoint(box_array) =>
for i = 0 to array.size(box_array) - 1
box.set_right(array.get(box_array, i), bar_index + 30) // Extend only 20
bars
atr567 = ta.atr(50)
swing_high = ta.pivothigh(high, swing_length, swing_length)
swing_low = ta.pivotlow(low, swing_length, swing_length)
var swing_high_values = array.new_float(5,0.00)
var swing_low_values = array.new_float(5,0.00)
var swing_high_bns = array.new_int(5,0)
var swing_low_bns = array.new_int(5,0)
var current_supply_poi = array.new_box(history_of_demand_to_keep, na)
var current_demand_poi = array.new_box(history_of_demand_to_keep, na)
var supply_bos = array.new_box(5, na)
var demand_bos = array.new_box(5, na)
if not na(swing_high)
f_array_add_pop(swing_high_values, swing_high)
f_array_add_pop(swing_high_bns, bar_index[swing_length])
if show_price_action_labels
f_sh_sl_labels(swing_high_values, 1)
f_supply_demand(swing_high_values, swing_high_bns, current_supply_box,
current_supply_poi, 1, atr567)
else if not na(swing_low)
f_array_add_pop(swing_low_values, swing_low)
f_array_add_pop(swing_low_bns, bar_index[swing_length])
if show_price_action_labels
f_sh_sl_labels(swing_low_values, -1)
f_supply_demand(swing_low_values, swing_low_bns, current_demand_box,
current_demand_poi, -1, atr567)
f_sd_to_bos(current_supply_box, supply_bos, current_supply_poi, 1)
f_sd_to_bos(current_demand_box, demand_bos, current_demand_poi, -1)
f_extend_box_endpoint(current_supply_box)
f_extend_box_endpoint(current_demand_box)

// Inside the main execution, after the box is drawn, check for rejections
if not na(swing_low)
f_array_add_pop(swing_low_values, swing_low)
f_array_add_pop(swing_low_bns, bar_index[swing_length])
if show_price_action_labels
f_sh_sl_labels(swing_low_values, -1)
f_supply_demand(swing_low_values, swing_low_bns, current_demand_box,
current_demand_poi, -1, atr567)
f_check_demand_rejections()

if not na(swing_high)
f_array_add_pop(swing_high_values, swing_high)
f_array_add_pop(swing_high_bns, bar_index[swing_length])
if show_price_action_labels
f_sh_sl_labels(swing_high_values, 1)
f_supply_demand(swing_high_values, swing_high_bns, current_supply_box,
current_supply_poi, 1, atr567)
f_check_supply_rejections()

trigger2 = bull ? 1 : 0
countBull = ta.barssince(bull)
countBear = ta.barssince(bear)
trigger = nz(countBull, bar_index) < nz(countBear, bar_index) ? 1 : 0
atrBand = ta.atr(atrLen) * atrRisk
atrStop = trigger == 1 ? low - atrBand : high + atrBand

lastTrade(close) => ta.valuewhen(bull or bear , close, 0)

entry = levels ? label.new(time, close, "ENTRY " + str.tostring(lastTrade(close),

decimals), xloc.bar_time, yloc.price, #18282b, label.style_label_left, color.white,
size.normal) : na
label.set_x(entry, label.get_x(entry) + math.round(ta.change(time) * lvlDistance))
label.set_y(entry, lastTrade(close))
label.delete(entry[1])

stop_y = lastTrade(atrStop)
stop = levels ? label.new(time, close, "SL " + str.tostring(stop_y, decimals),
xloc.bar_time, yloc.price, red2, label.style_label_left, color.white,
size.normal) : na
label.set_x(stop, label.get_x(stop) + math.round(ta.change(time) * lvlDistance))
label.set_y(stop, stop_y)
label.delete(stop[1])

tp1Rl_y = (lastTrade(close)-lastTrade(atrStop))*1 + lastTrade(close)

tp1Rl = levels ? label.new(time, close, "1:1 TP " + str.tostring(tp1Rl_y,
decimals), xloc.bar_time, yloc.price, green2, label.style_label_left, color.white,
size.normal ) : na
label.set_x(tp1Rl, label.get_x(tp1Rl) + math.round(ta.change(time) * lvlDistance))
label.set_y(tp1Rl, tp1Rl_y)
label.delete(tp1Rl[1])

tp2RL_y = (lastTrade(close)-lastTrade(atrStop))*2 + lastTrade(close)

tp2RL = levels ? label.new(time, close, "2:1 TP " + str.tostring(tp2RL_y,
decimals), xloc.bar_time, yloc.price, green2, label.style_label_left, color.white,
size.normal) : na
label.set_x(tp2RL, label.get_x(tp2RL) + math.round(ta.change(time) * lvlDistance))
label.set_y(tp2RL, tp2RL_y)
label.delete(tp2RL[1])

tp3RL_y = (lastTrade(close)-lastTrade(atrStop))*3 + lastTrade(close)

tp3RL = levels ? label.new(time, close, "3:1 TP " + str.tostring(tp3RL_y,
decimals), xloc.bar_time, yloc.price, green2, label.style_label_left, color.white,
size.normal) : na
label.set_x(tp3RL, label.get_x(tp3RL) + math.round(ta.change(time) * lvlDistance))
label.set_y(tp3RL, tp3RL_y)
label.delete(tp3RL[1])

style = linesStyle == "SOLID" ? line.style_solid : linesStyle == "DASHED" ?

line.style_dashed : line.style_dotted
lineEntry = levels and lvlLines ? line.new(bar_index - (trigger == 0 ? countBull :
countBear), lastTrade(close), bar_index + lvlDistance, lastTrade(close),
xloc.bar_index, extend.none, #19292c, style, 2) : na, line.delete(lineEntry[1])
lineStop = levels and lvlLines ? line.new(bar_index - (trigger == 0 ? countBull :
countBear), stop_y, bar_index + lvlDistance, stop_y, xloc.bar_index, extend.none,
#423535, style, 2) : na, line.delete(lineStop[1])
lineTp1Rl = levels and lvlLines ? line.new(bar_index - (trigger == 0 ?
countBull : countBear), tp1Rl_y, bar_index + lvlDistance, tp1Rl_y, xloc.bar_index,
extend.none, green2, style, 2) : na, line.delete(lineTp1Rl[1])
lineTp2RL = levels and lvlLines ? line.new(bar_index - (trigger == 0 ?
countBull : countBear), tp2RL_y, bar_index + lvlDistance, tp2RL_y, xloc.bar_index,
extend.none, green2, style, 2) : na, line.delete(lineTp2RL[1])
lineTp3RL = levels and lvlLines ? line.new(bar_index - (trigger == 0 ?
countBull : countBear), tp3RL_y, bar_index + lvlDistance, tp3RL_y, xloc.bar_index,
extend.none, green2, style, 2) : na, line.delete(lineTp3RL[1])

alertcondition(bull, title='Buy Signal', message = "BUY")

alertcondition(bear, title='Buy Signal', message = "BUY")

//import protradingart/pta_plot/6 as pp
//pp.peakprofit(bull, bear)

LuxAlgo Signals & Overlays™ [6.1.1]
100% (1)
LuxAlgo Signals & Overlays™ [6.1.1]
33 pages
Elite Algo v22
0% (4)
Elite Algo v22
16 pages
Saiyan Occ Strategy r5.41
50% (2)
Saiyan Occ Strategy r5.41
15 pages
EzAlgo V12
No ratings yet
EzAlgo V12
13 pages
Elite Algo + TP + Smart Money
33% (3)
Elite Algo + TP + Smart Money
58 pages
EzAlgo1 0
100% (3)
EzAlgo1 0
10 pages
Trade Bulls v1.2
100% (1)
Trade Bulls v1.2
5 pages
Signals & Overlays
No ratings yet
Signals & Overlays
30 pages
Elitealgo
100% (5)
Elitealgo
16 pages
LuxAlgo Matrix Oscillator Cloned
No ratings yet
LuxAlgo Matrix Oscillator Cloned
7 pages
Elite Algo Modded by AlgoPoint Premium
100% (2)
Elite Algo Modded by AlgoPoint Premium
23 pages
Price Action Concepts
No ratings yet
Price Action Concepts
35 pages
AlgoRyze Pro-Sol
No ratings yet
AlgoRyze Pro-Sol
23 pages
GodSlayer Price Action Toolkit v1.6.3
No ratings yet
GodSlayer Price Action Toolkit v1.6.3
65 pages
VP (Maps) + OB + S&R + GGSHOT + HH
0% (3)
VP (Maps) + OB + S&R + GGSHOT + HH
60 pages
Pieki Algo v1.1
No ratings yet
Pieki Algo v1.1
33 pages
Ezalgo v11 Cleaned
No ratings yet
Ezalgo v11 Cleaned
13 pages
Lux Algo Trend
100% (1)
Lux Algo Trend
21 pages
Fresh Algo Leaked.
0% (2)
Fresh Algo Leaked.
39 pages
Premium Liquidity Hunter Algo
No ratings yet
Premium Liquidity Hunter Algo
20 pages
EzAlgo Oscillator
No ratings yet
EzAlgo Oscillator
1 page
AlgoPoint - Zero Repaint
0% (1)
AlgoPoint - Zero Repaint
15 pages
Trading - Learner Brahmastra
50% (2)
Trading - Learner Brahmastra
16 pages
Crypto Slaya
No ratings yet
Crypto Slaya
12 pages
BNT5.0 Premium Indicator
100% (2)
BNT5.0 Premium Indicator
12 pages
Signals & Overlayst
100% (2)
Signals & Overlayst
30 pages
Price Action Concepts Indicator
100% (1)
Price Action Concepts Indicator
60 pages
Gaussian Signals Candle AlgoPoint
No ratings yet
Gaussian Signals Candle AlgoPoint
4 pages
Oscillator Matrix With Alerts
No ratings yet
Oscillator Matrix With Alerts
14 pages
EzAlgo SR
100% (2)
EzAlgo SR
4 pages
Price Action Toolkit
No ratings yet
Price Action Toolkit
46 pages
FxAlgo (AlgoPoint)
No ratings yet
FxAlgo (AlgoPoint)
26 pages
Infinity Algo ZZ
100% (2)
Infinity Algo ZZ
4 pages
Crypto Wolf Occ
0% (1)
Crypto Wolf Occ
47 pages
AI Gold Digger
No ratings yet
AI Gold Digger
5 pages
Market Structure CHoCH BOS LEO
No ratings yet
Market Structure CHoCH BOS LEO
6 pages
Algo Lux
No ratings yet
Algo Lux
3 pages
Lux Algo Next-Gen Stock, Crypto, & Forex Indica
No ratings yet
Lux Algo Next-Gen Stock, Crypto, & Forex Indica
1 page
Setup Mafia 3.5
100% (1)
Setup Mafia 3.5
5 pages
Dashboard
No ratings yet
Dashboard
6 pages
Tradview Strategy
No ratings yet
Tradview Strategy
4 pages
v1.5.3 Price Action ICT Toolkit-2
No ratings yet
v1.5.3 Price Action ICT Toolkit-2
65 pages
AlgoPoint PA Toolkit V1
0% (1)
AlgoPoint PA Toolkit V1
78 pages
Price Action Concepts Open Source (Algoman)
No ratings yet
Price Action Concepts Open Source (Algoman)
50 pages
Elite Algo v22
No ratings yet
Elite Algo v22
16 pages
RMI Trend Sniper + AAFLI Merged by Lupen
No ratings yet
RMI Trend Sniper + AAFLI Merged by Lupen
11 pages
Ut Bot Strategy Tp1 Tp2
No ratings yet
Ut Bot Strategy Tp1 Tp2
5 pages
Script Bandera
No ratings yet
Script Bandera
2 pages
Elite Algo v30 Fix
No ratings yet
Elite Algo v30 Fix
25 pages
EasyAlgo V20
No ratings yet
EasyAlgo V20
3 pages
SAIYANATOR Strategy v1.37
No ratings yet
SAIYANATOR Strategy v1.37
9 pages
AlgoPoint Signals
No ratings yet
AlgoPoint Signals
13 pages
(Imba) Algo
No ratings yet
(Imba) Algo
16 pages
SAB PRO Pivot Master@free - FX - Pro
No ratings yet
SAB PRO Pivot Master@free - FX - Pro
24 pages
Price Action Concepts
No ratings yet
Price Action Concepts
49 pages
Price Action 152 Bns
No ratings yet
Price Action 152 Bns
53 pages
Price Action 152
No ratings yet
Price Action 152
66 pages
Pat 6
No ratings yet
Pat 6
48 pages
Price Action Concepts 1.0.0
No ratings yet
Price Action Concepts 1.0.0
24 pages
Price Action
No ratings yet
Price Action
24 pages
Bhasma Pariksha PDF
No ratings yet
Bhasma Pariksha PDF
8 pages
6.tacneng Barry
No ratings yet
6.tacneng Barry
34 pages
Detention Volume Estimating Workbook (PDF) - 201404301105510967
No ratings yet
Detention Volume Estimating Workbook (PDF) - 201404301105510967
300 pages
Shopping List Management System Using Inheritance in C++ (1)
No ratings yet
Shopping List Management System Using Inheritance in C++ (1)
5 pages
OOP - Project (Gym Management)
No ratings yet
OOP - Project (Gym Management)
11 pages
MAT8 CH 4 Cubesandcuberoots AK
No ratings yet
MAT8 CH 4 Cubesandcuberoots AK
7 pages
CS6201 Digital Principles and System Design Question Paper Nov Dec 2017
No ratings yet
CS6201 Digital Principles and System Design Question Paper Nov Dec 2017
2 pages
Class 6 Maths
No ratings yet
Class 6 Maths
2 pages
Time Series Characteristic
No ratings yet
Time Series Characteristic
72 pages
An Applicable Method For Extraction of Whole Seeds Through Bradford
No ratings yet
An Applicable Method For Extraction of Whole Seeds Through Bradford
7 pages
BITS-Pilani Hyderabad Campus CS F303 (Computer Networks) Laboratory 1
No ratings yet
BITS-Pilani Hyderabad Campus CS F303 (Computer Networks) Laboratory 1
7 pages
Gis
No ratings yet
Gis
15 pages
MAF11 Revision Question Sem 1 2019 Final Exam
No ratings yet
MAF11 Revision Question Sem 1 2019 Final Exam
2 pages
Sharp Lq065t5ar01 Lcdpanel Datasheet
No ratings yet
Sharp Lq065t5ar01 Lcdpanel Datasheet
33 pages
Increased Screen Time and Its Association
No ratings yet
Increased Screen Time and Its Association
11 pages
Saveetha University, Tiruvallur
No ratings yet
Saveetha University, Tiruvallur
7 pages
Vsphere Esxi Vcenter Server 65 Host Profiles Guide
No ratings yet
Vsphere Esxi Vcenter Server 65 Host Profiles Guide
26 pages
Northside Piers - Brooklyn, NY: Structural System Redesign
No ratings yet
Northside Piers - Brooklyn, NY: Structural System Redesign
27 pages
Level 3
No ratings yet
Level 3
20 pages
Operations On Large Numbers - Part 9
No ratings yet
Operations On Large Numbers - Part 9
11 pages
Gann Grids Ultra 6
100% (1)
Gann Grids Ultra 6
141 pages
Beket I Jonesko (Engl.) Drama Knjizevnost Teorija
No ratings yet
Beket I Jonesko (Engl.) Drama Knjizevnost Teorija
5 pages
Whole School Numeracy Program
No ratings yet
Whole School Numeracy Program
2 pages
Real Gas Thermodynamics
No ratings yet
Real Gas Thermodynamics
112 pages
DCCN Numerical:: 1. The Period of A Signal Is 100 Ms. What Is Its Frequency in Kilohertz?
No ratings yet
DCCN Numerical:: 1. The Period of A Signal Is 100 Ms. What Is Its Frequency in Kilohertz?
19 pages
Fortran Tutorial 6
No ratings yet
Fortran Tutorial 6
9 pages
3C1.5 2xwy LSZH
No ratings yet
3C1.5 2xwy LSZH
1 page
Running Head: Testing Correlation and Bivariate Regression 1
No ratings yet
Running Head: Testing Correlation and Bivariate Regression 1
6 pages
Expert Systems With Applications
No ratings yet
Expert Systems With Applications
22 pages
Specific Energy As A Criterion For Drill Performance Prediction
No ratings yet
Specific Energy As A Criterion For Drill Performance Prediction
4 pages