size=size.

auto)
// Order Block Detector Functions
get_line_style(style) =>
switch style
'⎯⎯⎯' => line.style_solid
'----' => line.style_dashed

set_order_blocks(ob_top, ob_btm, ob_left, ob_avg, ext_last, bg_css, border_css,

lvl_css) =>
var ob_box = array.new_box(0)
var ob_lvl = array.new_line(0)

if barstate.isfirst
for i = 0 to ext_last-1
array.unshift(ob_box, box.new(na,na,na,na, xloc = xloc.bar_time, extend
= extend.right, bgcolor = bg_css, border_color = color.new(border_css, 70)))
array.unshift(ob_lvl, line.new(na,na,na,na, xloc = xloc.bar_time,
extend = extend.right, color = lvl_css, style = get_line_style(line_style), width =
line_width))

if barstate.islast
if array.size(ob_top) > 0
for i = 0 to math.min(ext_last-1, array.size(ob_top)-1)
get_box = array.get(ob_box, i)
get_lvl = array.get(ob_lvl, i)
box.set_lefttop(get_box, array.get(ob_left, i), array.get(ob_top,
i))
box.set_rightbottom(get_box, array.get(ob_left, i),
array.get(ob_btm, i))
line.set_xy1(get_lvl, array.get(ob_left, i), array.get(ob_avg, i))
line.set_xy2(get_lvl, array.get(ob_left, i)+1, array.get(ob_avg,
i))

// Order Block Detector Logic

var os = 0
var target_bull = 0.
var target_bear = 0.

n = bar_index
upper = ta.highest(length)
lower = ta.lowest(length)

if mitigation == 'Close'
target_bull := ta.lowest(close, length)
target_bear := ta.highest(close, length)
else
target_bull := lower
target_bear := upper

os := high[length] > upper ? 0 : low[length] < lower ? 1 : os[1]

phv = ta.pivothigh(volume, length, length)

[bull_top, bull_btm, bull_avg, bull_left, bull_ob] = get_coordinates(phv and os ==

1, hl2[length], low[length], low[length])
[bear_top, bear_btm, bear_avg, bear_left, bear_ob] = get_coordinates(phv and os ==
0, high[length], hl2[length], high[length])

mitigated_bull = remove_mitigated(bull_top, bull_btm, bull_left, bull_avg,

target_bull, true)
mitigated_bear = remove_mitigated(bear_top, bear_btm, bear_left, bear_avg,
target_bear, false)

set_order_blocks(bull_top, bull_btm, bull_left, bull_avg, bull_ext_last,

bg_bull_css, bull_css, bull_avg_css)
set_order_blocks(bear_top, bear_btm, bear_left, bear_avg, bear_ext_last,
bg_bear_css, bear_css, bear_avg_css)

plot(bull_ob, 'Bull OB', bull_css, 2, plot.style_linebr, offset = -length)

plot(bear_ob, 'Bear OB', bear_css, 2, plot.style_linebr, offset = -length)

// EMA Calculations and Plotting

ema9 = ta.ema(src_ema, len1)
ema20 = ta.ema(src_ema, len2)

plot(ema9, title="9 EMA", linewidth=2, color=#0000FF)

plot(ema20, title="20 EMA", linewidth=2, color=#11DCBF)

// UNTESTED

temp0 = input.bool(title='••••••••••••••••••• Fractals ••••••••••••••••••••••',

defval=false)
showFractals = input.bool(title='Show Fractal Points ?', defval=false)
filterFractal = input.string(title='Filter 3/5 bar fractal', defval='3',
options=['3', '5'])

temp1 = input.bool(title='••••••••••••••••••• Orderblocks •••••••••••••••••••',

defval=false)
findObType = input.string(title='Find OB after fractal break of close/HL',
defval='Close', options=['Close', 'HL'])
filterFvgs = input.bool(title='Filter only OB that follow with FVG ?', defval=true)
fvgDistance = input.int(3, title='Max bars between the OB and FVG', minval=1,
maxval=6)
lineHeight = input.string(title='Line Height', defval='Body', options=['Body',
'Wick'])
delLines = input.bool(title='Delete lines after fill ?', defval=true)

temp3 = input.bool(title='•••••••••••••••••••• Styles ••••••••••••••••••••••••',

defval=false)
lines_style = input.string(title='Lines style', defval='Solid', options=['Solid',
'Dashed', 'Dotted'])
line_length = input.int(5, 'Length of lines', minval=1, maxval=100)
lineStyle = lines_style == 'Solid' ? line.style_solid : lines_style == 'Dashed' ?
line.style_dashed : line.style_dotted
linesWidth = input.int(2, 'Lines Width ?', minval=1, maxval=4)
bear_line_color = input.color(color.red, 'Bear OB Line color')
bull_line_color = input.color(color.blue, 'Bull OB Line color')

// -------------------- FUNCTIONS --------------------

bullishImb(i=0) => close[i+1] > high[i+2] and low[i] > high[i+2]
bearishImb(i=0) => close[i+1] < low[i+2] and high[i] < low[i+2]

// Fractals
isRegularFractal(mode) =>
ret = mode == 'Buy' ? high[0] < high[1] and (high[2] < high[1] or high[2] ==
high[1] and high[3] < high[2]) : mode == 'Sell' ? low[0] > low[1] and (low[2] >
low[1] or low[2] == low[1] and low[3] > low[2]) : false
ret

isBWFractal(mode) =>
ret = mode == 'Buy' ? high[0] < high[2] and high[1] < high[2] and high[3] <
high[2] and high[4] < high[2] : mode == 'Sell' ? low[0] > low[2] and low[1] >
low[2] and low[3] > low[2] and low[4] > low[2] : false
ret

isFractalHigh() =>
filterFractal == '3' ? isRegularFractal('Buy') : isBWFractal('Buy')

isFractalLow() =>
filterFractal == '3' ? isRegularFractal('Sell') : isBWFractal('Sell')

resolutionInMinutes() =>
resInMinutes = timeframe.multiplier * (timeframe.isseconds ? 1. / 60 :
timeframe.isminutes ? 1. : timeframe.isdaily ? 60. * 24 : timeframe.isweekly ? 60.
* 24 * 7 : timeframe.ismonthly ? 60. * 24 * 30.4375 : na)
resInMinutes

f_timeFrom(_from, length, _units, i) =>

var int _timeFrom = na
_unit = str.replace_all(_units, 's', '')
_timeFrom := int(time[i] + resolutionInMinutes() * 60 * 1000 * length)
_timeFrom

// -------------------- FUNCTIONS --------------------

// -------------------- Fractals --------------------

var float fractal_high_val = na
var float fractal_low_val = na

var fractal_highs = array.new_float(0) // array of high fractal values

var fractal_high_times = array.new_int(0) // array of high fractal times
var fractal_lows = array.new_float(0) // array of low fractal values
var fractal_low_times = array.new_int(0) // array or low fractal times

// Check if fractal and add it to array

if isFractalHigh()
if filterFractal == '3'
array.push(fractal_highs, high[1])
array.push(fractal_high_times, time[1])
fractal_high_val := high[1]
else
array.push(fractal_highs, high[2])
array.push(fractal_high_times, time[2])
fractal_high_val := high[2]

if isFractalLow()
if filterFractal == '3'
array.push(fractal_lows, low[1])
array.push(fractal_low_times, time[1])
fractal_low_val := low[1]
else
array.push(fractal_lows, low[2])
array.push(fractal_low_times, time[2])
 fractal_low_val := low[2]
// -------------------- Fractals --------------------

var bars_back = 500

// -------------------- Orderblocks --------------------

var line1 = array.new_line()
var line2 = array.new_line()
var line3 = array.new_line()
var line4 = array.new_line()

var label1 = array.new_label()

var label2 = array.new_label()

// Bearish loop
if array.size(fractal_lows) > 0
for i = array.size(fractal_lows) - 1 to 0
if (findObType == 'Close' ? close : low) < array.get(fractal_lows, i)
idx = 0
max = low //current low
gapIndex = 0

for k = 0 to bars_back
bearishGap = (close[k+1] < low[k+2]) and (high[k] < low[k+2])

//stop loop if reached time limit

if time[k] < array.get(fractal_low_times, i)
break

//Get all bullish candles in range

if close[k] > open[k] and high[k] > max
idx := k
max := high[k]

if bearishGap and high[k] > max

gapIndex := k+2

_filterFvg = filterFvgs ? gapIndex > 0 and idx - gapIndex >= 0 and idx
- gapIndex <= fvgDistance : true
// Line on OB
if idx != 0 and _filterFvg
// label.new(bar_index, high, str.tostring(idx) + "\n" +
str.tostring(gapIndex))
TimeTo = f_timeFrom('bar', line_length, 'chart', idx)
loc = lineHeight == 'Body' ? open[idx] : low[idx]

array.push(line1, line.new(x1=time[idx], y1=high[idx], x2=TimeTo,

y2=high[idx], xloc=xloc.bar_time, style=lineStyle, color=bear_line_color,
width=linesWidth))
array.push(line2, line.new(x1=time[idx], y1=loc, x2=TimeTo, y2=loc,
xloc=xloc.bar_time, style=lineStyle, color=bear_line_color, width=linesWidth))

array.remove(fractal_lows, i)
array.remove(fractal_low_times, i)

// Bullish loop
if array.size(fractal_highs) > 0
for i = array.size(fractal_highs) - 1 to 0
 if (findObType == 'Close' ? close : high) > array.get(fractal_highs, i)
idx = 0
min = low
gapIndex = 0

for k = 0 to bars_back
bullishGap = (close[k+1] > high[k+2]) and (low[k] > high[k+2])

// Stop the loop once it reaches the last fractal high

if time[k] < array.get(fractal_high_times, i)
break

// if bearish candle
if close[k] < open[k] and low[k] < min
idx := k
min := low[k]

if bullishGap
gapIndex := k+2

_filterFvg = filterFvgs ? gapIndex > 0 and idx - gapIndex >= 0 and idx
- gapIndex <= fvgDistance : true
// Line on OB
if idx != 0 and _filterFvg
// label.new(bar_index, high, str.tostring(idx) + "\n" +
str.tostring(gapIndex))
TimeTo = f_timeFrom('bar', line_length, 'chart', idx)
loc = lineHeight == 'Body' ? open[idx] : high[idx]

array.push(line3, line.new(x1=time[idx], y1=low[idx], x2=TimeTo,

y2=low[idx], xloc=xloc.bar_time, style=lineStyle, color=bull_line_color,
width=linesWidth))
array.push(line4, line.new(x1=time[idx], y1=loc, x2=TimeTo, y2=loc,
xloc=xloc.bar_time, style=lineStyle, color=bull_line_color, width=linesWidth))

array.remove(fractal_highs, i)
array.remove(fractal_high_times, i)

// -------------------- Orderblocks --------------------

// Delete Lines/Labels
if array.size(line1) > 0
var int i = array.size(line1) - 1
while i >= 0
if high >= line.get_y1(array.get(line1, i)) and high >=
line.get_y1(array.get(line2, i))
if delLines
line.delete(array.get(line1, i))
line.delete(array.get(line2, i))
//label.delete(array.get(label1, i))
array.remove(line1, i)
array.remove(line2, i)
//array.remove(label1,i)
i -= 1

if array.size(line3) > 0
var int j = array.size(line3) - 1
while j >= 0
 if low <= line.get_y1(array.get(line3, j)) and low <=
line.get_y1(array.get(line4, j))
if delLines
line.delete(array.get(line3, j))
line.delete(array.get(line4, j))
//label.delete(array.get(label2, j))
array.remove(line3, j)
array.remove(line4, j)
//array.remove(label2,j)
j -= 1

//Plot fractal points

plotshape(showFractals and isFractalHigh(), title='Fractal High',
style=shape.triangledown, location=location.abovebar, color=color.new(color.red,
0), offset=filterFractal == '3' ? -1 : -2, size=size.auto)
plotshape(showFractals and isFractalLow(), title='Fractal Low',
style=shape.triangleup, location=location.belowbar, color=color.new(color.blue, 0),
offset=filterFractal == '3' ? -1 : -2,
'····' => line.style_dotted

remove_mitigated(ob_top, ob_btm, ob_left, ob_avg, target, bull) =>

mitigated = false
target_array = bull ? ob_btm : ob_top

for element in target_array

idx = array.indexof(target_array, element)
if (bull ? target < element : target > element)
mitigated := true
array.remove(ob_top, idx)
array.remove(ob_btm, idx)
array.remove(ob_avg, idx)
array.remove(ob_left, idx)

mitigated