//@version=5

indicator('Smart Money Concepts [LuxAlgo]', 'LuxAlgo - Smart Money Concepts',

overlay = true, max_labels_count = 500, max_lines_count = 500, max_boxes_count =
500)
//---------------------------------------------------------------------------------
------------------------------------}
//CONSTANTS & STRINGS & INPUTS
//---------------------------------------------------------------------------------
------------------------------------{
BULLISH_LEG = 1
BEARISH_LEG = 0

BULLISH = +1
BEARISH = -1

GREEN = #089981
RED = #F23645
BLUE = #2157f3
GRAY = #878b94
MONO_BULLISH = #b2b5be
MONO_BEARISH = #5d606b

HISTORICAL = 'Historical'
PRESENT = 'Present'

COLORED = 'Colored'
MONOCHROME = 'Monochrome'

ALL = 'All'
BOS = 'BOS'
CHOCH = 'CHoCH'

TINY = size.tiny
SMALL = size.small
NORMAL = size.normal

ATR = 'Atr'
RANGE = 'Cumulative Mean Range'

CLOSE = 'Close'
HIGHLOW = 'High/Low'

SOLID = '⎯⎯⎯'
DASHED = '----'
DOTTED = '····'

SMART_GROUP = 'Smart Money Concepts'

INTERNAL_GROUP = 'Real Time Internal Structure'
SWING_GROUP = 'Real Time Swing Structure'
BLOCKS_GROUP = 'Order Blocks'
EQUAL_GROUP = 'EQH/EQL'
GAPS_GROUP = 'Fair Value Gaps'
LEVELS_GROUP = 'Highs & Lows MTF'
ZONES_GROUP = 'Premium & Discount Zones'

modeTooltip = 'Allows to display historical Structure or only

the recent ones'
styleTooltip = 'Indicator color theme'
showTrendTooltip = 'Display additional candles with a color
reflecting the current trend detected by structure'
showInternalsTooltip = 'Display internal market structure'
internalFilterConfluenceTooltip = 'Filter non significant internal structure
breakouts'
showStructureTooltip = 'Display swing market Structure'
showSwingsTooltip = 'Display swing point as labels on the chart'
showHighLowSwingsTooltip = 'Highlight most recent strong and weak high/low
points on the chart'
showInternalOrderBlocksTooltip = 'Display internal order blocks on the chart\n\
nNumber of internal order blocks to display on the chart'
showSwingOrderBlocksTooltip = 'Display swing order blocks on the chart\n\
nNumber of internal swing blocks to display on the chart'
orderBlockFilterTooltip = 'Method used to filter out volatile order
blocks \n\nIt is recommended to use the cumulative mean range method when a low
amount of data is available'
orderBlockMitigationTooltip = 'Select what values to use for order block
mitigation'
showEqualHighsLowsTooltip = 'Display equal highs and equal lows on the chart'
equalHighsLowsLengthTooltip = 'Number of bars used to confirm equal highs and
equal lows'
equalHighsLowsThresholdTooltip = 'Sensitivity threshold in a range (0, 1) used for
the detection of equal highs & lows\n\nLower values will return fewer but more
pertinent results'
showFairValueGapsTooltip = 'Display fair values gaps on the chart'
fairValueGapsThresholdTooltip = 'Filter out non significant fair value gaps'
fairValueGapsTimeframeTooltip = 'Fair value gaps timeframe'
fairValueGapsExtendTooltip = 'Determine how many bars to extend the Fair Value
Gap boxes on chart'
showPremiumDiscountZonesTooltip = 'Display premium, discount, and equilibrium zones
on chart'

modeInput = input.string( HISTORICAL, 'Mode',

group = SMART_GROUP, tooltip = modeTooltip, options = [HISTORICAL, PRESENT])
styleInput = input.string( COLORED, 'Style',
group = SMART_GROUP, tooltip = styleTooltip,options = [COLORED, MONOCHROME])
showTrendInput = input( false, 'Color Candles',
group = SMART_GROUP, tooltip = showTrendTooltip)

showInternalsInput = input( true, 'Show Internal

Structure', group = INTERNAL_GROUP, tooltip = showInternalsTooltip)
showInternalBullInput = input.string( ALL, 'Bullish Structure',
group = INTERNAL_GROUP, inline = 'ibull', options = [ALL,BOS,CHOCH])
internalBullColorInput = input( GREEN, '',
group = INTERNAL_GROUP, inline = 'ibull')
showInternalBearInput = input.string( ALL, 'Bearish Structure' ,
group = INTERNAL_GROUP, inline = 'ibear', options = [ALL,BOS,CHOCH])
internalBearColorInput = input( RED, '',
group = INTERNAL_GROUP, inline = 'ibear')
internalFilterConfluenceInput = input( false, 'Confluence Filter',
group = INTERNAL_GROUP, tooltip = internalFilterConfluenceTooltip)
internalStructureSize = input.string( TINY, 'Internal Label Size',
group = INTERNAL_GROUP, options = [TINY,SMALL,NORMAL])

showStructureInput = input( true, 'Show Swing Structure',

group = SWING_GROUP, tooltip = showStructureTooltip)
showSwingBullInput = input.string( ALL, 'Bullish Structure',
group = SWING_GROUP, inline = 'bull', options = [ALL,BOS,CHOCH])
swingBullColorInput = input( GREEN, '',
group = SWING_GROUP, inline = 'bull')
showSwingBearInput = input.string( ALL, 'Bearish Structure',
group = SWING_GROUP, inline = 'bear', options = [ALL,BOS,CHOCH])
swingBearColorInput = input( RED, '',
group = SWING_GROUP, inline = 'bear')
swingStructureSize = input.string( SMALL, 'Swing Label Size',
group = SWING_GROUP, options = [TINY,SMALL,NORMAL])
showSwingsInput = input( false, 'Show Swings Points',
group = SWING_GROUP, tooltip = showSwingsTooltip,inline = 'swings')
swingsLengthInput = input.int( 50, '',
group = SWING_GROUP, minval = 10, inline = 'swings')
showHighLowSwingsInput = input( true, 'Show Strong/Weak
High/Low',group = SWING_GROUP, tooltip = showHighLowSwingsTooltip)

showInternalOrderBlocksInput = input( true, 'Internal Order Blocks'

, group = BLOCKS_GROUP, tooltip = showInternalOrderBlocksTooltip, inline =
'iob')
internalOrderBlocksSizeInput = input.int( 5, '',
group = BLOCKS_GROUP, minval = 1, maxval = 20, inline = 'iob')
showSwingOrderBlocksInput = input( false, 'Swing Order Blocks',
group = BLOCKS_GROUP, tooltip = showSwingOrderBlocksTooltip, inline = 'ob')
swingOrderBlocksSizeInput = input.int( 5, '',
group = BLOCKS_GROUP, minval = 1, maxval = 20, inline = 'ob')
orderBlockFilterInput = input.string( 'Atr', 'Order Block Filter',
group = BLOCKS_GROUP, tooltip = orderBlockFilterTooltip, options = [ATR,
RANGE])
orderBlockMitigationInput = input.string( HIGHLOW, 'Order Block
Mitigation', group = BLOCKS_GROUP, tooltip = orderBlockMitigationTooltip,
options = [CLOSE,HIGHLOW])
internalBullishOrderBlockColor = input.color(color.new(#3179f5, 80), 'Internal
Bullish OB', group = BLOCKS_GROUP)
internalBearishOrderBlockColor = input.color(color.new(#f77c80, 80), 'Internal
Bearish OB', group = BLOCKS_GROUP)
swingBullishOrderBlockColor = input.color(color.new(#1848cc, 80), 'Bullish OB',
group = BLOCKS_GROUP)
swingBearishOrderBlockColor = input.color(color.new(#b22833, 80), 'Bearish OB',
group = BLOCKS_GROUP)

showEqualHighsLowsInput = input( true, 'Equal High/Low',

group = EQUAL_GROUP, tooltip = showEqualHighsLowsTooltip)
equalHighsLowsLengthInput = input.int( 3, 'Bars Confirmation',
group = EQUAL_GROUP, tooltip = equalHighsLowsLengthTooltip, minval = 1)
equalHighsLowsThresholdInput = input.float( 0.1, 'Threshold',
group = EQUAL_GROUP, tooltip = equalHighsLowsThresholdTooltip, minval = 0,
maxval = 0.5, step = 0.1)
equalHighsLowsSizeInput = input.string( TINY, 'Label Size',
group = EQUAL_GROUP, options = [TINY,SMALL,NORMAL])

showFairValueGapsInput = input( false, 'Fair Value Gaps',

group = GAPS_GROUP, tooltip = showFairValueGapsTooltip)
fairValueGapsThresholdInput = input( true, 'Auto Threshold',
group = GAPS_GROUP, tooltip = fairValueGapsThresholdTooltip)
fairValueGapsTimeframeInput = input.timeframe('', 'Timeframe',
group = GAPS_GROUP, tooltip = fairValueGapsTimeframeTooltip)
fairValueGapsBullColorInput = input.color(color.new(#00ff68, 70), 'Bullish FVG'
, group = GAPS_GROUP)
fairValueGapsBearColorInput = input.color(color.new(#ff0008, 70), 'Bearish FVG'
, group = GAPS_GROUP)
fairValueGapsExtendInput = input.int( 1, 'Extend FVG',
group = GAPS_GROUP, tooltip = fairValueGapsExtendTooltip, minval = 0)
showDailyLevelsInput = input( false, 'Daily', group =
LEVELS_GROUP, inline = 'daily')
dailyLevelsStyleInput = input.string( SOLID, '', group =
LEVELS_GROUP, inline = 'daily', options = [SOLID,DASHED,DOTTED])
dailyLevelsColorInput = input( BLUE, '', group =
LEVELS_GROUP, inline = 'daily')
showWeeklyLevelsInput = input( false, 'Weekly', group =
LEVELS_GROUP, inline = 'weekly')
weeklyLevelsStyleInput = input.string( SOLID, '', group =
LEVELS_GROUP, inline = 'weekly', options = [SOLID,DASHED,DOTTED])
weeklyLevelsColorInput = input( BLUE, '', group =
LEVELS_GROUP, inline = 'weekly')
showMonthlyLevelsInput = input( false, 'Monthly', group =
LEVELS_GROUP, inline = 'monthly')
monthlyLevelsStyleInput = input.string( SOLID, '', group =
LEVELS_GROUP, inline = 'monthly', options = [SOLID,DASHED,DOTTED])
monthlyLevelsColorInput = input( BLUE, '', group =
LEVELS_GROUP, inline = 'monthly')

showPremiumDiscountZonesInput = input( false, 'Premium/Discount

Zones', group = ZONES_GROUP , tooltip = showPremiumDiscountZonesTooltip)
premiumZoneColorInput = input.color( RED, 'Premium Zone',
group = ZONES_GROUP)
equilibriumZoneColorInput = input.color( GRAY, 'Equilibrium Zone',
group = ZONES_GROUP)
discountZoneColorInput = input.color( GREEN, 'Discount Zone',
group = ZONES_GROUP)

//---------------------------------------------------------------------------------
------------------------------------}
//DATA STRUCTURES & VARIABLES
//---------------------------------------------------------------------------------
------------------------------------{
// @type UDT representing alerts as bool fields
// @field internalBullishBOS internal structure custom alert
// @field internalBearishBOS internal structure custom alert
// @field internalBullishCHoCH internal structure custom alert
// @field internalBearishCHoCH internal structure custom alert
// @field swingBullishBOS swing structure custom alert
// @field swingBearishBOS swing structure custom alert
// @field swingBullishCHoCH swing structure custom alert
// @field swingBearishCHoCH swing structure custom alert
// @field internalBullishOrderBlock internal order block custom alert
// @field internalBearishOrderBlock internal order block custom alert
// @field swingBullishOrderBlock swing order block custom alert
// @field swingBearishOrderBlock swing order block custom alert
// @field equalHighs equal high low custom alert
// @field equalLows equal high low custom alert
// @field bullishFairValueGap fair value gap custom alert
// @field bearishFairValueGap fair value gap custom alert
type alerts
bool internalBullishBOS = false
bool internalBearishBOS = false
bool internalBullishCHoCH = false
bool internalBearishCHoCH = false
bool swingBullishBOS = false
bool swingBearishBOS = false
bool swingBullishCHoCH = false
 bool swingBearishCHoCH = false
bool internalBullishOrderBlock = false
bool internalBearishOrderBlock = false
bool swingBullishOrderBlock = false
bool swingBearishOrderBlock = false
bool equalHighs = false
bool equalLows = false
bool bullishFairValueGap = false
bool bearishFairValueGap = false

// @type UDT representing last swing extremes (top &

bottom)
// @field top last top swing price
// @field bottom last bottom swing price
// @field barTime last swing bar time
// @field barIndex last swing bar index
// @field lastTopTime last top swing time
// @field lastBottomTime last bottom swing time
type trailingExtremes
float top
float bottom
int barTime
int barIndex
int lastTopTime
int lastBottomTime

// @type UDT representing Fair Value Gaps

// @field top top price
// @field bottom bottom price
// @field bias bias (BULLISH or BEARISH)
// @field topBox top box
// @field bottomBox bottom box
type fairValueGap
float top
float bottom
int bias
box topBox
box bottomBox

// @type UDT representing trend bias

// @field bias BULLISH or BEARISH
type trend
int bias

// @type UDT representing Equal Highs Lows display

// @field l_ine displayed line
// @field l_abel displayed label
type equalDisplay
line l_ine = na
label l_abel = na

// @type UDT representing a pivot point (swing point)

// @field currentLevel current price level
// @field lastLevel last price level
// @field crossed true if price level is crossed
// @field barTime bar time
// @field barIndex bar index
type pivot
float currentLevel
 float lastLevel
bool crossed
int barTime = time
int barIndex = bar_index

// @type UDT representing an order block

// @field barHigh bar high
// @field barLow bar low
// @field barTime bar time
// @field bias BULLISH or BEARISH
type orderBlock
float barHigh
float barLow
int barTime
int bias

// @variable current swing pivot high

var pivot swingHigh = pivot.new(na,na,false)
// @variable current swing pivot low
var pivot swingLow = pivot.new(na,na,false)
// @variable current internal pivot high
var pivot internalHigh = pivot.new(na,na,false)
// @variable current internal pivot low
var pivot internalLow = pivot.new(na,na,false)
// @variable current equal high pivot
var pivot equalHigh = pivot.new(na,na,false)
// @variable current equal low pivot
var pivot equalLow = pivot.new(na,na,false)
// @variable swing trend bias
var trend swingTrend = trend.new(0)
// @variable internal trend bias
var trend internalTrend = trend.new(0)
// @variable equal high display
var equalDisplay equalHighDisplay = equalDisplay.new()
// @variable equal low display
var equalDisplay equalLowDisplay = equalDisplay.new()
// @variable storage for fairValueGap UDTs
var array<fairValueGap> fairValueGaps = array.new<fairValueGap>()
// @variable storage for parsed highs
var array<float> parsedHighs = array.new<float>()
// @variable storage for parsed lows
var array<float> parsedLows = array.new<float>()
// @variable storage for raw highs
var array<float> highs = array.new<float>()
// @variable storage for raw lows
var array<float> lows = array.new<float>()
// @variable storage for bar time values
var array<int> times = array.new<int>()
// @variable last trailing swing high and low
var trailingExtremes trailing = trailingExtremes.new()
// @variable storage for orderBlock UDTs (swing
order blocks)
var array<orderBlock> swingOrderBlocks = array.new<orderBlock>()
// @variable storage for orderBlock UDTs (internal
order blocks)
var array<orderBlock> internalOrderBlocks = array.new<orderBlock>()
// @variable storage for swing order blocks boxes
var array<box> swingOrderBlocksBoxes = array.new<box>()
// @variable storage for internal order blocks boxes
var array<box> internalOrderBlocksBoxes = array.new<box>()
// @variable color for swing bullish structures
var swingBullishColor = styleInput == MONOCHROME ? MONO_BULLISH :
swingBullColorInput
// @variable color for swing bearish structures
var swingBearishColor = styleInput == MONOCHROME ? MONO_BEARISH :
swingBearColorInput
// @variable color for bullish fair value gaps
var fairValueGapBullishColor = styleInput == MONOCHROME ?
color.new(MONO_BULLISH,70) : fairValueGapsBullColorInput
// @variable color for bearish fair value gaps
var fairValueGapBearishColor = styleInput == MONOCHROME ?
color.new(MONO_BEARISH,70) : fairValueGapsBearColorInput
// @variable color for premium zone
var premiumZoneColor = styleInput == MONOCHROME ? MONO_BEARISH :
premiumZoneColorInput
// @variable color for discount zone
var discountZoneColor = styleInput == MONOCHROME ? MONO_BULLISH :
discountZoneColorInput
// @variable bar index on current script iteration
varip int currentBarIndex = bar_index
// @variable bar index on last script iteration
varip int lastBarIndex = bar_index
// @variable alerts in current bar
alerts currentAlerts = alerts.new()
// @variable time at start of chart
var initialTime = time

// we create the needed boxes for displaying order blocks at the first execution
if barstate.isfirst
if showSwingOrderBlocksInput
for index = 1 to swingOrderBlocksSizeInput
swingOrderBlocksBoxes.push(box.new(na,na,na,na,xloc =
xloc.bar_time,extend = extend.right))
if showInternalOrderBlocksInput
for index = 1 to internalOrderBlocksSizeInput
internalOrderBlocksBoxes.push(box.new(na,na,na,na,xloc =
xloc.bar_time,extend = extend.right))

// @variable source to use in bearish order blocks

mitigation
bearishOrderBlockMitigationSource = orderBlockMitigationInput == CLOSE ? close :
high
// @variable source to use in bullish order blocks
mitigation
bullishOrderBlockMitigationSource = orderBlockMitigationInput == CLOSE ? close :
low
// @variable default volatility measure
atrMeasure = ta.atr(200)
// @variable parsed volatility measure by user settings
volatilityMeasure = orderBlockFilterInput == ATR ? atrMeasure :
ta.cum(ta.tr)/bar_index
// @variable true if current bar is a high volatility bar
highVolatilityBar = (high - low) >= (2 * volatilityMeasure)
// @variable parsed high
parsedHigh = highVolatilityBar ? low : high
// @variable parsed low
parsedLow = highVolatilityBar ? high : low
// we store current values into the arrays at each bar
parsedHighs.push(parsedHigh)
parsedLows.push(parsedLow)
highs.push(high)
lows.push(low)
times.push(time)

//---------------------------------------------------------------------------------
------------------------------------}
//USER-DEFINED FUNCTIONS
//---------------------------------------------------------------------------------
------------------------------------{
// @function Get the value of the current leg, it can be 0 (bearish) or
1 (bullish)
// @returns int
leg(int size) =>
var leg = 0
newLegHigh = high[size] > ta.highest( size)
newLegLow = low[size] < ta.lowest( size)

if newLegHigh
leg := BEARISH_LEG
else if newLegLow
leg := BULLISH_LEG
leg

// @function Identify whether the current value is the start of a new

leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfNewLeg(int leg) => ta.change(leg) != 0

// @function Identify whether the current level is the start of a new

bearish leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfBearishLeg(int leg) => ta.change(leg) == -1

// @function Identify whether the current level is the start of a new

bullish leg (swing)
// @param leg (int) Current leg value
// @returns bool
startOfBullishLeg(int leg) => ta.change(leg) == +1

// @function create a new label

// @param labelTime bar time coordinate
// @param labelPrice price coordinate
// @param tag text to display
// @param labelColor text color
// @param labelStyle label style
// @returns label ID
drawLabel(int labelTime, float labelPrice, string tag, color labelColor, string
labelStyle) =>
var label l_abel = na

if modeInput == PRESENT
l_abel.delete()

l_abel :=
label.new(chart.point.new(labelTime,na,labelPrice),tag,xloc.bar_time,color=color(na
),textcolor=labelColor,style = labelStyle,size = size.small)

// @function create a new line and label representing an EQH or EQL

// @param p_ivot starting pivot
// @param level price level of current pivot
// @param size how many bars ago was the current pivot detected
// @param equalHigh true for EQH, false for EQL
// @returns label ID
drawEqualHighLow(pivot p_ivot, float level, int size, bool equalHigh) =>
equalDisplay e_qualDisplay = equalHigh ? equalHighDisplay : equalLowDisplay

string tag = 'EQL'

color equalColor = swingBullishColor
string labelStyle = label.style_label_up

if equalHigh
tag := 'EQH'
equalColor := swingBearishColor
labelStyle := label.style_label_down

if modeInput == PRESENT
line.delete( e_qualDisplay.l_ine)
label.delete( e_qualDisplay.l_abel)

e_qualDisplay.l_ine :=
line.new(chart.point.new(p_ivot.barTime,na,p_ivot.currentLevel),
chart.point.new(time[size],na,level), xloc = xloc.bar_time, color = equalColor,
style = line.style_dotted)
labelPosition = math.round(0.5*(p_ivot.barIndex + bar_index - size))
e_qualDisplay.l_abel := label.new(chart.point.new(na,labelPosition,level),
tag, xloc.bar_index, color = color(na), textcolor = equalColor, style = labelStyle,
size = equalHighsLowsSizeInput)

// @function store current structure and trailing swing points, and also
display swing points and equal highs/lows
// @param size (int) structure size
// @param equalHighLow (bool) true for displaying current highs/lows
// @param internal (bool) true for getting internal structures
// @returns label ID
getCurrentStructure(int size,bool equalHighLow = false, bool internal = false) =>
currentLeg = leg(size)
newPivot = startOfNewLeg(currentLeg)
pivotLow = startOfBullishLeg(currentLeg)
pivotHigh = startOfBearishLeg(currentLeg)

if newPivot
if pivotLow
pivot p_ivot = equalHighLow ? equalLow : internal ? internalLow :
swingLow

if equalHighLow and math.abs(p_ivot.currentLevel - low[size]) <

equalHighsLowsThresholdInput * atrMeasure
drawEqualHighLow(p_ivot, low[size], size, false)

p_ivot.lastLevel := p_ivot.currentLevel
p_ivot.currentLevel := low[size]
p_ivot.crossed := false
p_ivot.barTime := time[size]
 p_ivot.barIndex := bar_index[size]

if not equalHighLow and not internal

trailing.bottom := p_ivot.currentLevel
trailing.barTime := p_ivot.barTime
trailing.barIndex := p_ivot.barIndex
trailing.lastBottomTime := p_ivot.barTime

if showSwingsInput and not internal and not equalHighLow

drawLabel(time[size], p_ivot.currentLevel, p_ivot.currentLevel <
p_ivot.lastLevel ? 'LL' : 'HL', swingBullishColor, label.style_label_up)
else
pivot p_ivot = equalHighLow ? equalHigh : internal ? internalHigh :
swingHigh

if equalHighLow and math.abs(p_ivot.currentLevel - high[size]) <

equalHighsLowsThresholdInput * atrMeasure
drawEqualHighLow(p_ivot,high[size],size,true)

p_ivot.lastLevel := p_ivot.currentLevel
p_ivot.currentLevel := high[size]
p_ivot.crossed := false
p_ivot.barTime := time[size]
p_ivot.barIndex := bar_index[size]

if not equalHighLow and not internal

trailing.top := p_ivot.currentLevel
trailing.barTime := p_ivot.barTime
trailing.barIndex := p_ivot.barIndex
trailing.lastTopTime := p_ivot.barTime

if showSwingsInput and not internal and not equalHighLow

drawLabel(time[size], p_ivot.currentLevel, p_ivot.currentLevel >
p_ivot.lastLevel ? 'HH' : 'LH', swingBearishColor, label.style_label_down)

// @function draw line and label representing a structure

// @param p_ivot base pivot point
// @param tag test to display
// @param structureColor base color
// @param lineStyle line style
// @param labelStyle label style
// @param labelSize text size
// @returns label ID
drawStructure(pivot p_ivot, string tag, color structureColor, string lineStyle,
string labelStyle, string labelSize) =>
var line l_ine = line.new(na,na,na,na,xloc = xloc.bar_time)
var label l_abel = label.new(na,na)

if modeInput == PRESENT
l_ine.delete()
l_abel.delete()

l_ine := line.new(chart.point.new(p_ivot.barTime,na,p_ivot.currentLevel),
chart.point.new(time,na,p_ivot.currentLevel), xloc.bar_time, color=structureColor,
style=lineStyle)
l_abel :=
label.new(chart.point.new(na,math.round(0.5*(p_ivot.barIndex+bar_index)),p_ivot.cur
rentLevel), tag, xloc.bar_index, color=color(na), textcolor=structureColor,
style=labelStyle, size = labelSize)
// @function delete order blocks
// @param internal true for internal order blocks
// @returns orderBlock ID
deleteOrderBlocks(bool internal = false) =>
array<orderBlock> orderBlocks = internal ? internalOrderBlocks :
swingOrderBlocks

for [index,eachOrderBlock] in orderBlocks

bool crossedOderBlock = false

if bearishOrderBlockMitigationSource > eachOrderBlock.barHigh and

eachOrderBlock.bias == BEARISH
crossedOderBlock := true
if internal
currentAlerts.internalBearishOrderBlock := true
else
currentAlerts.swingBearishOrderBlock := true
else if bullishOrderBlockMitigationSource < eachOrderBlock.barLow and
eachOrderBlock.bias == BULLISH
crossedOderBlock := true
if internal
currentAlerts.internalBullishOrderBlock := true
else
currentAlerts.swingBullishOrderBlock := true
if crossedOderBlock
orderBlocks.remove(index)

// @function fetch and store order blocks

// @param p_ivot base pivot point
// @param internal true for internal order blocks
// @param bias BULLISH or BEARISH
// @returns void
storeOrdeBlock(pivot p_ivot,bool internal = false,int bias) =>
if (not internal and showSwingOrderBlocksInput) or (internal and
showInternalOrderBlocksInput)

array<float> a_rray = na
int parsedIndex = na

if bias == BEARISH
a_rray := parsedHighs.slice(p_ivot.barIndex,bar_index)
parsedIndex := p_ivot.barIndex + a_rray.indexof(a_rray.max())
else
a_rray := parsedLows.slice(p_ivot.barIndex,bar_index)
parsedIndex := p_ivot.barIndex + a_rray.indexof(a_rray.min())

orderBlock o_rderBlock =
orderBlock.new(parsedHighs.get(parsedIndex), parsedLows.get(parsedIndex),
times.get(parsedIndex),bias)
array<orderBlock> orderBlocks = internal ? internalOrderBlocks :
swingOrderBlocks

if orderBlocks.size() >= 100

orderBlocks.pop()
orderBlocks.unshift(o_rderBlock)

// @function draw order blocks as boxes

// @param internal true for internal order blocks
// @returns void
drawOrderBlocks(bool internal = false) =>
array<orderBlock> orderBlocks = internal ? internalOrderBlocks :
swingOrderBlocks
orderBlocksSize = orderBlocks.size()

if orderBlocksSize > 0
maxOrderBlocks = internal ?
internalOrderBlocksSizeInput : swingOrderBlocksSizeInput
array<orderBlock> parsedOrdeBlocks = orderBlocks.slice(0,
math.min(maxOrderBlocks,orderBlocksSize))
array<box> b_oxes = internal ? internalOrderBlocksBoxes :
swingOrderBlocksBoxes

for [index,eachOrderBlock] in parsedOrdeBlocks

orderBlockColor = styleInput == MONOCHROME ? (eachOrderBlock.bias ==
BEARISH ? color.new(MONO_BEARISH,80) : color.new(MONO_BULLISH,80)) : internal ?
(eachOrderBlock.bias == BEARISH ? internalBearishOrderBlockColor :
internalBullishOrderBlockColor) : (eachOrderBlock.bias == BEARISH ?
swingBearishOrderBlockColor : swingBullishOrderBlockColor)

box b_ox = b_oxes.get(index)

b_ox.set_top_left_point( chart.point.new(eachOrderBlock.barTime,na,eachOrderBloc
k.barHigh))

b_ox.set_bottom_right_point(chart.point.new(last_bar_time,na,eachOrderBlock.barLow)
)
b_ox.set_border_color( internal ? na : orderBlockColor)
b_ox.set_bgcolor( orderBlockColor)

// @function detect and draw structures, also detect and store order
blocks
// @param internal true for internal structures or order blocks
// @returns void
displayStructure(bool internal = false) =>
var bullishBar = true
var bearishBar = true

if internalFilterConfluenceInput
bullishBar := high - math.max(close, open) > math.min(close, open - low)
bearishBar := high - math.max(close, open) < math.min(close, open - low)

pivot p_ivot = internal ? internalHigh : swingHigh

trend t_rend = internal ? internalTrend : swingTrend

lineStyle = internal ? line.style_dashed : line.style_solid

labelSize = internal ? internalStructureSize : swingStructureSize

extraCondition = internal ? internalHigh.currentLevel !=

swingHigh.currentLevel and bullishBar : true
bullishColor = styleInput == MONOCHROME ? MONO_BULLISH : internal ?
internalBullColorInput : swingBullColorInput

if ta.crossover(close,p_ivot.currentLevel) and not p_ivot.crossed and

extraCondition
string tag = t_rend.bias == BEARISH ? CHOCH : BOS

if internal
 currentAlerts.internalBullishCHoCH := tag == CHOCH
currentAlerts.internalBullishBOS := tag == BOS
else
currentAlerts.swingBullishCHoCH := tag == CHOCH
currentAlerts.swingBullishBOS := tag == BOS

p_ivot.crossed := true
t_rend.bias := BULLISH

displayCondition = internal ? showInternalsInput and (showInternalBullInput

== ALL or (showInternalBullInput == BOS and tag != CHOCH) or (showInternalBullInput
== CHOCH and tag == CHOCH)) : showStructureInput and (showSwingBullInput == ALL or
(showSwingBullInput == BOS and tag != CHOCH) or (showSwingBullInput == CHOCH and
tag == CHOCH))

if displayCondition

drawStructure(p_ivot,tag,bullishColor,lineStyle,label.style_label_down,labelSize)

if (internal and showInternalOrderBlocksInput) or (not internal and

showSwingOrderBlocksInput)
storeOrdeBlock(p_ivot,internal,BULLISH)

p_ivot := internal ? internalLow : swingLow

extraCondition := internal ? internalLow.currentLevel != swingLow.currentLevel
and bearishBar : true
bearishColor = styleInput == MONOCHROME ? MONO_BEARISH : internal ?
internalBearColorInput : swingBearColorInput

if ta.crossunder(close,p_ivot.currentLevel) and not p_ivot.crossed and

extraCondition
string tag = t_rend.bias == BULLISH ? CHOCH : BOS

if internal
currentAlerts.internalBearishCHoCH := tag == CHOCH
currentAlerts.internalBearishBOS := tag == BOS
else
currentAlerts.swingBearishCHoCH := tag == CHOCH
currentAlerts.swingBearishBOS := tag == BOS

p_ivot.crossed := true
t_rend.bias := BEARISH

displayCondition = internal ? showInternalsInput and (showInternalBearInput

== ALL or (showInternalBearInput == BOS and tag != CHOCH) or (showInternalBearInput
== CHOCH and tag == CHOCH)) : showStructureInput and (showSwingBearInput == ALL or
(showSwingBearInput == BOS and tag != CHOCH) or (showSwingBearInput == CHOCH and
tag == CHOCH))

if displayCondition

drawStructure(p_ivot,tag,bearishColor,lineStyle,label.style_label_up,labelSize)

if (internal and showInternalOrderBlocksInput) or (not internal and

showSwingOrderBlocksInput)
storeOrdeBlock(p_ivot,internal,BEARISH)

// @function draw one fair value gap box (each fair value gap has two
boxes)
// @param leftTime left time coordinate
// @param rightTime right time coordinate
// @param topPrice top price level
// @param bottomPrice bottom price level
// @param boxColor box color
// @returns box ID
fairValueGapBox(leftTime,rightTime,topPrice,bottomPrice,boxColor) =>
box.new(chart.point.new(leftTime,na,topPrice),chart.point.new(rightTime +
fairValueGapsExtendInput * (time-time[1]),na,bottomPrice), xloc=xloc.bar_time,
border_color = boxColor, bgcolor = boxColor)

// @function delete fair value gaps

// @returns fairValueGap ID
deleteFairValueGaps() =>
for [index,eachFairValueGap] in fairValueGaps
if (low < eachFairValueGap.bottom and eachFairValueGap.bias == BULLISH) or
(high > eachFairValueGap.top and eachFairValueGap.bias == BEARISH)
eachFairValueGap.topBox.delete()
eachFairValueGap.bottomBox.delete()
fairValueGaps.remove(index)

// @function draw fair value gaps

// @returns fairValueGap ID
drawFairValueGaps() =>
[lastClose, lastOpen, lastTime, currentHigh, currentLow, currentTime,
last2High, last2Low] = request.security(syminfo.tickerid,
fairValueGapsTimeframeInput, [close[1], open[1], time[1], high[0], low[0], time[0],
high[2], low[2]],lookahead = barmerge.lookahead_on)

barDeltaPercent = (lastClose - lastOpen) / (lastOpen * 100)

newTimeframe = timeframe.change(fairValueGapsTimeframeInput)
threshold = fairValueGapsThresholdInput ?
ta.cum(math.abs(newTimeframe ? barDeltaPercent : 0)) / bar_index * 2 : 0

bullishFairValueGap = currentLow > last2High and lastClose > last2High and

barDeltaPercent > threshold and newTimeframe
bearishFairValueGap = currentHigh < last2Low and lastClose < last2Low and -
barDeltaPercent > threshold and newTimeframe

if bullishFairValueGap
currentAlerts.bullishFairValueGap := true

fairValueGaps.unshift(fairValueGap.new(currentLow,last2High,BULLISH,fairValueGapBox
(lastTime,currentTime,currentLow,math.avg(currentLow,last2High),fairValueGapBullish
Color),fairValueGapBox(lastTime,currentTime,math.avg(currentLow,last2High),last2Hig
h,fairValueGapBullishColor)))
if bearishFairValueGap
currentAlerts.bearishFairValueGap := true

fairValueGaps.unshift(fairValueGap.new(currentHigh,last2Low,BEARISH,fairValueGapBox
(lastTime,currentTime,currentHigh,math.avg(currentHigh,last2Low),fairValueGapBearis
hColor),fairValueGapBox(lastTime,currentTime,math.avg(currentHigh,last2Low),last2Lo
w,fairValueGapBearishColor)))

// @function get line style from string

// @param style line style
// @returns string
getStyle(string style) =>
switch style
 SOLID => line.style_solid
DASHED => line.style_dashed
DOTTED => line.style_dotted

// @function draw MultiTimeFrame levels

// @param timeframe base timeframe
// @param sameTimeframe true if chart timeframe is same as base timeframe
// @param style line style
// @param levelColor line and text color
// @returns void
drawLevels(string timeframe, bool sameTimeframe, string style, color levelColor) =>
[topLevel, bottomLevel, leftTime, rightTime] =
request.security(syminfo.tickerid, timeframe, [high[1], low[1], time[1],
time],lookahead = barmerge.lookahead_on)

float parsedTop = sameTimeframe ? high : topLevel

float parsedBottom = sameTimeframe ? low : bottomLevel

int parsedLeftTime = sameTimeframe ? time : leftTime

int parsedRightTime = sameTimeframe ? time : rightTime

int parsedTopTime = time

int parsedBottomTime = time

if not sameTimeframe
int leftIndex = times.binary_search_rightmost(parsedLeftTime)
int rightIndex =
times.binary_search_rightmost(parsedRightTime)

array<int> timeArray = times.slice(leftIndex,rightIndex)

array<float> topArray = highs.slice(leftIndex,rightIndex)
array<float> bottomArray = lows.slice(leftIndex,rightIndex)

parsedTopTime := timeArray.size() > 0 ?

timeArray.get(topArray.indexof(topArray.max())) : initialTime
parsedBottomTime := timeArray.size() > 0 ?
timeArray.get(bottomArray.indexof(bottomArray.min())) : initialTime

var line topLine = line.new(na, na, na, na, xloc = xloc.bar_time, color
= levelColor, style = getStyle(style))
var line bottomLine = line.new(na, na, na, na, xloc = xloc.bar_time, color
= levelColor, style = getStyle(style))
var label topLabel = label.new(na, na, xloc = xloc.bar_time, text =
str.format('P{0}H',timeframe), color=color(na), textcolor = levelColor, size =
size.small, style = label.style_label_left)
var label bottomLabel = label.new(na, na, xloc = xloc.bar_time, text =
str.format('P{0}L',timeframe), color=color(na), textcolor = levelColor, size =
size.small, style = label.style_label_left)

topLine.set_first_point( chart.point.new(parsedTopTime,na,parsedTop))
topLine.set_second_point( chart.point.new(last_bar_time + 20 * (time-
time[1]),na,parsedTop))
topLabel.set_point( chart.point.new(last_bar_time + 20 * (time-
time[1]),na,parsedTop))

bottomLine.set_first_point( chart.point.new(parsedBottomTime,na,parsedBottom))
bottomLine.set_second_point(chart.point.new(last_bar_time + 20 * (time-
time[1]),na,parsedBottom))
bottomLabel.set_point( chart.point.new(last_bar_time + 20 * (time-
time[1]),na,parsedBottom))

// @function true if chart timeframe is higher than provided timeframe

// @param timeframe timeframe to check
// @returns bool
higherTimeframe(string timeframe) => timeframe.in_seconds() >
timeframe.in_seconds(timeframe)

// @function update trailing swing points

// @returns int
updateTrailingExtremes() =>
trailing.top := math.max(high,trailing.top)
trailing.lastTopTime := trailing.top == high ? time : trailing.lastTopTime
trailing.bottom := math.min(low,trailing.bottom)
trailing.lastBottomTime := trailing.bottom == low ? time :
trailing.lastBottomTime

// @function draw trailing swing points

// @returns void
drawHighLowSwings() =>
var line topLine = line.new(na, na, na, na, color = swingBearishColor,
xloc = xloc.bar_time)
var line bottomLine = line.new(na, na, na, na, color = swingBullishColor,
xloc = xloc.bar_time)
var label topLabel = label.new(na, na, color=color(na), textcolor =
swingBearishColor, xloc = xloc.bar_time, style = label.style_label_down, size =
size.tiny)
var label bottomLabel = label.new(na, na, color=color(na), textcolor =
swingBullishColor, xloc = xloc.bar_time, style = label.style_label_up, size =
size.tiny)

rightTimeBar = last_bar_time + 20 * (time - time[1])

topLine.set_first_point( chart.point.new(trailing.lastTopTime, na,

trailing.top))
topLine.set_second_point( chart.point.new(rightTimeBar, na, trailing.top))
topLabel.set_point( chart.point.new(rightTimeBar, na, trailing.top))
topLabel.set_text( swingTrend.bias == BEARISH ? 'Strong High' : 'Weak
High')

bottomLine.set_first_point( chart.point.new(trailing.lastBottomTime, na,

trailing.bottom))
bottomLine.set_second_point(chart.point.new(rightTimeBar, na, trailing.bottom))
bottomLabel.set_point( chart.point.new(rightTimeBar, na, trailing.bottom))
bottomLabel.set_text( swingTrend.bias == BULLISH ? 'Strong Low' : 'Weak
Low')

// @function draw a zone with a label and a box

// @param labelLevel price level for label
// @param labelIndex bar index for label
// @param top top price level for box
// @param bottom bottom price level for box
// @param tag text to display
// @param zoneColor base color
// @param style label style
// @returns void
drawZone(float labelLevel, int labelIndex, float top, float bottom, string tag,
color zoneColor, string style) =>
var label l_abel = label.new(na,na,text = tag, color=color(na),textcolor =
zoneColor, style = style, size = size.small)
var box b_ox = box.new(na,na,na,na,bgcolor =
color.new(zoneColor,80),border_color = color(na), xloc = xloc.bar_time)

b_ox.set_top_left_point( chart.point.new(trailing.barTime,na,top))
b_ox.set_bottom_right_point(chart.point.new(last_bar_time,na,bottom))

l_abel.set_point( chart.point.new(na,labelIndex,labelLevel))

// @function draw premium/discount zones

// @returns void
drawPremiumDiscountZones() =>
drawZone(trailing.top, math.round(0.5*(trailing.barIndex + last_bar_index)),
trailing.top, 0.95*trailing.top + 0.05*trailing.bottom, 'Premium',
premiumZoneColor, label.style_label_down)

equilibriumLevel = math.avg(trailing.top, trailing.bottom)

drawZone(equilibriumLevel, last_bar_index, 0.525*trailing.top +
0.475*trailing.bottom, 0.525*trailing.bottom + 0.475*trailing.top, 'Equilibrium',
equilibriumZoneColorInput, label.style_label_left)

drawZone(trailing.bottom, math.round(0.5*(trailing.barIndex + last_bar_index)),

0.95*trailing.bottom + 0.05*trailing.top, trailing.bottom, 'Discount',
discountZoneColor, label.style_label_up)

//---------------------------------------------------------------------------------
------------------------------------}
//MUTABLE VARIABLES & EXECUTION
//---------------------------------------------------------------------------------
------------------------------------{
parsedOpen = showTrendInput ? open : na
candleColor = internalTrend.bias == BULLISH ? swingBullishColor : swingBearishColor
plotcandle(parsedOpen,high,low,close,color = candleColor, wickcolor = candleColor,
bordercolor = candleColor)

if showHighLowSwingsInput or showPremiumDiscountZonesInput
updateTrailingExtremes()

if showHighLowSwingsInput
drawHighLowSwings()

if showPremiumDiscountZonesInput
drawPremiumDiscountZones()

if showFairValueGapsInput
deleteFairValueGaps()

getCurrentStructure(swingsLengthInput,false)
getCurrentStructure(5,false,true)

if showEqualHighsLowsInput
getCurrentStructure(equalHighsLowsLengthInput,true)

if showInternalsInput or showInternalOrderBlocksInput or showTrendInput

displayStructure(true)

if showStructureInput or showSwingOrderBlocksInput or showHighLowSwingsInput

displayStructure()
if showInternalOrderBlocksInput
deleteOrderBlocks(true)

if showSwingOrderBlocksInput
deleteOrderBlocks()

if showFairValueGapsInput
drawFairValueGaps()

if barstate.islastconfirmedhistory or barstate.islast
if showInternalOrderBlocksInput
drawOrderBlocks(true)

if showSwingOrderBlocksInput
drawOrderBlocks()

lastBarIndex := currentBarIndex
currentBarIndex := bar_index
newBar = currentBarIndex != lastBarIndex

if barstate.islastconfirmedhistory or (barstate.isrealtime and newBar)

if showDailyLevelsInput and not higherTimeframe('D')

drawLevels('D',timeframe.isdaily,dailyLevelsStyleInput,dailyLevelsColorInput)

if showWeeklyLevelsInput and not higherTimeframe('W')

drawLevels('W',timeframe.isweekly,weeklyLevelsStyleInput,weeklyLevelsColorInput)

if showMonthlyLevelsInput and not higherTimeframe('M')

drawLevels('M',timeframe.ismonthly,monthlyLevelsStyleInput,monthlyLevelsColorInput)

//---------------------------------------------------------------------------------
------------------------------------}
//ALERTS
//---------------------------------------------------------------------------------
------------------------------------{
alertcondition(currentAlerts.internalBullishBOS, 'Internal Bullish BOS',
'Internal Bullish BOS formed')
alertcondition(currentAlerts.internalBullishCHoCH, 'Internal Bullish CHoCH',
'Internal Bullish CHoCH formed')
alertcondition(currentAlerts.internalBearishBOS, 'Internal Bearish BOS',
'Internal Bearish BOS formed')
alertcondition(currentAlerts.internalBearishCHoCH, 'Internal Bearish CHoCH',
'Internal Bearish CHoCH formed')

alertcondition(currentAlerts.swingBullishBOS, 'Bullish BOS',

'Internal Bullish BOS formed')
alertcondition(currentAlerts.swingBullishCHoCH, 'Bullish CHoCH',
'Internal Bullish CHoCH formed')
alertcondition(currentAlerts.swingBearishBOS, 'Bearish BOS',
'Bearish BOS formed')
alertcondition(currentAlerts.swingBearishCHoCH, 'Bearish CHoCH',
'Bearish CHoCH formed')

alertcondition(currentAlerts.internalBullishOrderBlock, 'Bullish Internal OB

Breakout', 'Price broke bullish internal OB')
alertcondition(currentAlerts.internalBearishOrderBlock, 'Bearish Internal OB
Breakout', 'Price broke bearish internal OB')
alertcondition(currentAlerts.swingBullishOrderBlock, 'Bullish Swing OB
Breakout', 'Price broke bullish swing OB')
alertcondition(currentAlerts.swingBearishOrderBlock, 'Bearish Swing OB
Breakout', 'Price broke bearish swing OB')

alertcondition(currentAlerts.equalHighs, 'Equal Highs',

'Equal highs detected')
alertcondition(currentAlerts.equalLows, 'Equal Lows',
'Equal lows detected')

alertcondition(currentAlerts.bullishFairValueGap, 'Bullish FVG',

'Bullish FVG formed')
alertcondition(currentAlerts.bearishFairValueGap, 'Bearish FVG',
'Bearish FVG formed')

//@version=5
indicator("ICT Concepts [LuxAlgo]", max_lines_count=500, max_boxes_count=500,
max_labels_count=500, max_bars_back=3000, overlay=true)
//-----------------------------------------------------------------------------}
//Strings
//-----------------------------------------------------------------------------{
o = 'Options'
sp1 = ' '
sp2 = ' '
hl = 'High / Low ' + sp1
ny_ = 'New York' + sp1
lo_ = 'London Open'
lc_ = 'London Close'
as_ = 'Asian'

//-----------------------------------------------------------------------------}
//Settings
//-----------------------------------------------------------------------------{
i_mode = input.string( 'Present' , title = 'Mode'
, options =['Present', 'Historical'] )

//Market Structure Shift

showMS = input.bool ( true , title = ''
, group = 'Market Structures', inline = 'MS' )
len = input.int ( 5 , title = ' Length ' +sp2
, group = 'Market Structures', inline = 'MS' , minval = 3, maxval = 10 )

iMSS = input.bool ( true , title = ' MSS' +sp1

, group = 'Market Structures', inline = 'M1' )
cMSSbl = input.color (color.new(#00e6a1, 0), title =
'bullish' , group = 'Market Structures', inline = 'M1'
)
cMSSbr = input.color (color.new(#e60400, 0), title =
'bearish' , group = 'Market Structures', inline = 'M1'
)

iBOS = input.bool ( true , title = ' BOS' +sp1

, group = 'Market Structures', inline = 'BS' )
cBOSbl = input.color (color.new(#00e6a1, 0), title =
'bullish' , group = 'Market Structures', inline = 'BS'
)
cBOSbr = input.color (color.new(#e60400, 0), title =
'bearish' , group = 'Market Structures', inline = 'BS'
)

//Displacement
sDispl = input.bool ( false , title = 'Show Displacement'
, group = 'Displacement' )

perc_Body = 0.36 // input.int( 36, minval=1, maxval=36) / 100

bxBack = 10 // input.int( 10, minval=0, maxval=10)

sVimbl = input.bool ( true , title = ''

, group = 'Volume Imbalance' , inline = 'VI' )
visVim = input.int ( 2 , title = " # Visible
VI's "+sp1, group = 'Volume Imbalance' , inline = 'VI' , minval = 2, maxval
= 100 )
cVimbl = input.color (color.new(#06b2d0, 0), title =
'' , group = 'Volume Imbalance' , inline = 'VI'
)

//Order Blocks
showOB = input.bool ( true , title = 'Show Order Blocks'
, group = 'Order Blocks' )
length = input.int ( 10 , title = 'Swing Lookback'
, group = 'Order Blocks' , minval = 3 )
showBull = input.int ( 1 , title = 'Show Last Bullish OB'
, group = 'Order Blocks' , minval = 0 )
showBear = input.int ( 1 , title = 'Show Last Bearish OB'
, group = 'Order Blocks' , minval = 0 )
useBody = input.bool ( true , title = 'Use Candle Body'
)

//OB Style
bullCss = input.color (color.new(#3e89fa, 0), title = 'Bullish
OB ' , group = 'Order Blocks' , inline = 'bullcss'
)
bullBrkCss = input.color (color.new(#4785f9, 85), title = 'Bullish
Break ' , group = 'Order Blocks' , inline = 'bullcss'
)

bearCss = input.color (color.new(#FF3131, 0), title = 'Bearish

OB' , group = 'Order Blocks' , inline = 'bearcss'
)
bearBrkCss = input.color (color.new(#f9ff57, 85), title = 'Bearish
Break' , group = 'Order Blocks' , inline = 'bearcss'
)

showLabels = input.bool ( false, title = 'Show Historical Polarity

Changes', group = 'Order Blocks'
)

//Liquidity
showLq = input.bool ( true , title = 'Show Liquidity'
, group = 'Liquidity' )
a = 10 / input.float ( 4 , title = 'margin'
, group = 'Liquidity' , step = 0.1, minval = 2, maxval = 7 )
visLiq = input.int ( 2 , title = '# Visible Liq. boxes'
, group = 'Liquidity'
, minval = 1 , maxval = 50
, tooltip = 'In the same direction' )
cLIQ_B = input.color (color.new(#fa451c, 0), title = 'Buyside
Liquidity ' , group = 'Liquidity'
)
cLIQ_S = input.color (color.new(#1ce4fa, 0), title = 'Sellside
Liquidity' , group = 'Liquidity'
)

//FVG
shwFVG = input.bool ( true , title = 'Show FVGs'
, group = 'Fair Value Gaps' )
i_BPR = input.bool ( false , title = 'Balance Price Range'
, group = 'Fair Value Gaps' )
i_FVG = input.string( 'FVG' , title = o
, group = 'Fair Value Gaps' , options=['FVG', 'IFVG']
,
tooltip = 'Fair Value Gaps\nor\nImplied Fair Value Gaps' )
visBxs = input.int ( 2 , title = '# Visible FVG\'s'
, group = 'Fair Value Gaps'
, minval = 1 , maxval = 20
, tooltip = 'In the same direction' )

//FVG Style
cFVGbl = input.color (color.new(#00e676, 0), title = 'Bullish
FVG ' , group = 'Fair Value Gaps' , inline = 'FVGbl'
)
cFVGblBR = input.color (color.new(#808000, 0), title =
'Break' , group = 'Fair Value Gaps' , inline = 'FVGbl'
)
cFVGbr = input.color (color.new(#ff5252, 0), title = 'Bearish
FVG ' , group = 'Fair Value Gaps' , inline = 'FVGbr'
)
cFVGbrBR = input.color (color.new(#FF0000, 0), title =
'Break' , group = 'Fair Value Gaps' , inline = 'FVGbr'
)

//NWOG/NDOG
iNWOG = input.bool ( true , title = '' ,
inline='NWOG', group = 'NWOG/NDOG'
)
cNWOG1 = input.color (color.new(#ff5252, 28), title = 'NWOG ',
inline='NWOG', group = 'NWOG/NDOG'
)
cNWOG2 = input.color (color.new(#b2b5be, 50), title = '' ,
inline='NWOG', group = 'NWOG/NDOG'
)
maxNWOG = input.int ( 3 , title = 'Show max',
inline='NWOG', group = 'NWOG/NDOG' , minval = 0, maxval = 50
)

iNDOG = input.bool ( false , title = '' ,

inline='NDOG', group = 'NWOG/NDOG'
)
cNDOG1 = input.color (color.new(#ff9800, 20), title = 'NDOG ',
inline='NDOG', group = 'NWOG/NDOG'
)
cNDOG2 = input.color (color.new(#4dd0e1, 65), title = '' ,
inline='NDOG', group = 'NWOG/NDOG'
)
maxNDOG = input.int ( 1 , title = 'Show max',
inline='NDOG', group = 'NWOG/NDOG' , minval = 0, maxval = 50
)

//Fibonacci
iFib = input.string( 'NONE' , title = 'Fibonacci between last:
', group = 'Fibonacci', options=['FVG', 'BPR', 'OB', 'Liq', 'VI', 'NWOG',
'NONE'])
iExt = input.bool ( false , title = 'Extend lines'
, group = 'Fibonacci' )

//Killzones
showKZ = input.bool ( false , title = 'Show Killzones'
, group = 'Killzones' )
//New York
showNy = input.bool ( true , title = ny_ , inline =
'ny' , group = 'Killzones'
) and showKZ
nyCss = input.color (color.new(#ff5d00, 93), title = '' , inline =
'ny' , group = 'Killzones'
)
//London Open
showLdno = input.bool ( true , title = lo_ , inline =
'lo' , group = 'Killzones'
) and showKZ
ldnoCss = input.color (color.new(#00bcd4, 93), title = '' , inline =
'lo' , group = 'Killzones'
)
//London Close
showLdnc = input.bool ( true , title = lc_ , inline =
'lc' , group = 'Killzones'
) and showKZ
ldncCss = input.color (color.new(#2157f3, 93), title = '' , inline =
'lc' , group = 'Killzones'
)
//Asian
showAsia = input.bool ( true , title = as_ + sp2, inline =
'as' , group = 'Killzones'
) and showKZ
asiaCss = input.color (color.new(#e91e63, 93), title = '' , inline =
'as' , group = 'Killzones'
)

//-----------------------------------------------------------------------------}
//General Calculations
//-----------------------------------------------------------------------------{
n = bar_index
hi = high
lo = low
tf_msec = timeframe.in_seconds(timeframe.period) * 1000
maxSize = 50
atr = ta.atr(10)
per = i_mode == 'Present' ? last_bar_index - bar_index <= 500 : true
perB = last_bar_index - bar_index <= 1000 ? true : false
xloc = iFib == 'OB' ? xloc.bar_time : xloc.bar_index
ext = iExt ? extend.right : extend.none
plus = iFib == 'OB' ? tf_msec * 50 : 50
mx = math.max(close , open)
mn = math.min(close , open)
body = math.abs(close - open)
meanBody = ta.sma (body , len)
max = useBody ? mx : high
min = useBody ? mn : low
blBrkConf = 0
brBrkConf = 0
r = color.r(chart.bg_color)
g = color.g(chart.bg_color)
b = color.b(chart.bg_color)
isDark = r < 80 and g < 80 and b < 80

//-----------------------------------------------------------------------------}
//User Defined Types
//-----------------------------------------------------------------------------{
type ZZ
int [] d
int [] x
float [] y
bool [] b

type ln_d
line l
int d

type _2ln_lb
line l1
line l2
label lb

type bx_ln
box b
line l

type bx_ln_lb
box bx
line ln
label lb

type mss
int dir
line [] l_mssBl
line [] l_mssBr
line [] l_bosBl
line [] l_bosBr
label[] lbMssBl
label[] lbMssBr
label[] lbBosBl
label[] lbBosBr

type liq
box bx
bool broken
bool brokenTop
bool brokenBtm
line ln
type ob
float top = na
float btm = na
int loc = bar_index
bool breaker = false
int break_loc = na

type swing
float y = na
int x = na
bool crossed = false

type FVG
box box
bool active
int pos

var mss MSS = mss.new(

0
, array.new < line >()
, array.new < line >()
, array.new < line >()
, array.new < line >()
, array.new < label >()
, array.new < label >()
, array.new < label >()
, array.new < label >()
)

//-----------------------------------------------------------------------------}
//Variables
//-----------------------------------------------------------------------------{
maxVimb = 2

var float friCp = na, var int friCi = na // Friday Close price/index
var float monOp = na, var int monOi = na // Monday Open price/index

var float prDCp = na, var int prDCi = na // Previous Day Open price/index
var float cuDOp = na, var int cuDOi = na // Current Day Open price/index

var _2ln_lb [] Vimbal = array.new< _2ln_lb >()

var liq [] b_liq_B = array.new< liq >(1, liq.new(box(na), false, false,

false, line(na)))
var liq [] b_liq_S = array.new< liq >(1, liq.new(box(na), false, false,
false, line(na)))

var ob [] bullish_ob = array.new< ob >()

var ob [] bearish_ob = array.new< ob >()

var bx_ln [] bl_NWOG = array.new< bx_ln >()

var bx_ln [] bl_NDOG = array.new< bx_ln >()

var bx_ln_lb[] a_bx_ln_lb = array.new< bx_ln_lb >()

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

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

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

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

var ZZ aZZ =
ZZ.new(
array.new < int >(maxSize, 0),
array.new < int >(maxSize, 0),
array.new < float >(maxSize, na),
array.new < bool >(maxSize, na))

var line _diag = line.new(na, na, na, na, color=color.new(color.silver, 50),

style=line.style_dashed, xloc= xloc )
var line _vert = line.new(na, na, na, na, color=color.new(color.silver, 50),
style=line.style_dotted, xloc= xloc )
var line _zero = line.new(na, na, na, na, color=color.new(color.silver, 5),
style=line.style_solid , xloc= xloc, extend=ext)
var line _0236 = line.new(na, na, na, na, color=color.new(color.orange, 25),
style=line.style_solid , xloc= xloc, extend=ext)
var line _0382 = line.new(na, na, na, na, color=color.new(color.yellow, 25),
style=line.style_solid , xloc= xloc, extend=ext)
var line _0500 = line.new(na, na, na, na, color=color.new(color.green , 25),
style=line.style_solid , xloc= xloc, extend=ext)
var line _0618 = line.new(na, na, na, na, color=color.new(color.yellow, 25),
style=line.style_solid , xloc= xloc, extend=ext)
var line _0786 = line.new(na, na, na, na, color=color.new(color.orange, 25),
style=line.style_solid , xloc= xloc, extend=ext)
var line _one_ = line.new(na, na, na, na, color=color.new(color.silver, 5),
style=line.style_solid , xloc= xloc, extend=ext)
var line _1618 = line.new(na, na, na, na, color=color.new(color.yellow, 25),
style=line.style_solid , xloc= xloc, extend=ext)

//-----------------------------------------------------------------------------}
//Functions/methods
//-----------------------------------------------------------------------------{
method in_out(ZZ aZZ, int d, int x1, float y1, int x2, float y2, color col, bool b)
=>
aZZ.d.unshift(d), aZZ.x.unshift(x2), aZZ.y.unshift(y2), aZZ.b.unshift(b),
aZZ.d.pop(), aZZ.x.pop(), aZZ.y.pop(), aZZ.b.pop()

method timeinrange(string res, string sess) => not na(time(timeframe.period, res,

sess))

method setLine(line ln, int x1, float y1, int x2, float y2) => ln.set_xy1(x1, y1),
ln.set_xy2(x2, y2)

method clear_aLine(line[] l) =>

if l.size() > 0
for i = l.size() -1 to 0
l.pop().delete()

method clear_aLabLin(label[] l) =>

if l.size() > 0
for i = l.size() -1 to 0
l.pop().delete()

method clear_aLabLin(line[] l) =>

if l.size() > 0
for i = l.size() -1 to 0
l.pop().delete()
method notransp(color css) => color.rgb(color.r(css), color.g(css), color.b(css))

method display(ob id, css, break_css, str)=>

if showOB
if id.breaker
a_bx_ln_lb.unshift(
bx_ln_lb.new(
box.new(id.loc, id.top, timenow + (tf_msec * 10), id.btm, na
, bgcolor = break_css
, extend = extend.none
, xloc = xloc.bar_time)
, line (na)
, label(na))
)
else
y = str == 'bl' ? id.btm : id.top
s = str == 'bl' ? label.style_label_up : label.style_label_down
a_bx_ln_lb.unshift(
bx_ln_lb.new(
box(na)
, line.new(id.loc, y , id.loc + (tf_msec * 10), y
, xloc = xloc.bar_time, color=css, width=2)
, label.new( id.loc + (tf_msec * 10), y
, text = str == 'bl' ? '+OB' : '-OB'
, xloc = xloc.bar_time
, style = s , color = color(na)
, textcolor=css, size = size.small))
)

swings(len)=>
var os = 0
var swing top = swing.new(na, na)
var swing btm = swing.new(na, na)

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

os := high[len] > upper ? 0

: low [len] < lower ? 1 : os

if os == 0 and os[1] != 0
top := swing.new(high[length], bar_index[length])

if os == 1 and os[1] != 1
btm := swing.new(low[length], bar_index[length])

[top, btm]

set_lab(i, str) =>

style = str == 'Bl' ? label.style_label_down : label.style_label_up
txcol = str == 'Bl' ? color.lime : color.red
label.new(math.round(math.avg(aZZ.x.get(i), n)), aZZ.y.get(i), text='BOS'
, style=style, color=color(na), textcolor=txcol, size=size.tiny)
set_lin(i, str) =>
color = str == 'Bl' ? color.lime : color.red
line.new(aZZ.x.get(i), aZZ.y.get(i), n, aZZ.y.get(i), color=color,
style=line.style_dotted)

draw(left, col) =>

 //
max_bars_back(time, 1000)
var int dir= na, var int x1= na, var float y1= na, var int x2= na, var float
y2= na
//
sz = aZZ.d.size( )
x2 := bar_index -1
ph = ta.pivothigh(hi, left, 1)
pl = ta.pivotlow (lo, left, 1)
if ph
dir := aZZ.d.get (0)
x1 := aZZ.x.get (0)
y1 := aZZ.y.get (0)
y2 := nz(hi[1])
//
if dir < 1 // if previous point was a pl, add, and change direction ( 1)
aZZ.in_out( 1, x1, y1, x2, y2, col, true)
else
if dir == 1 and ph > y1
aZZ.x.set(0, x2), aZZ.y.set(0, y2)
//
// liquidity
if showLq and per and sz > 0
count = 0
st_P = 0.
st_B = 0
minP = 0.
maxP = 10e6
for i = 0 to math.min(sz, 50) -1
if aZZ.d.get(i) == 1
if aZZ.y.get(i) > ph + (atr/a)
break
else
if aZZ.y.get(i) > ph - (atr/a) and aZZ.y.get(i) < ph +
(atr/a)
count += 1
st_B := aZZ.x.get(i)
st_P := aZZ.y.get(i)
if aZZ.y.get(i) > minP
minP := aZZ.y.get(i)
if aZZ.y.get(i) < maxP
maxP := aZZ.y.get(i)
if count > 2
getB = b_liq_B.get(0)
if st_B == getB.bx.get_left()
getB.bx.set_top(math.avg(minP, maxP) + (atr/a))
getB.bx.set_rightbottom(n +10, math.avg(minP, maxP) - (atr/a))
else
b_liq_B.unshift(liq.new(
box.new(
st_B, math.avg(minP, maxP) + (atr/a), n +10, math.avg(minP,
maxP) - (atr/a)
, text = 'Buyside liquidity', text_size = size.tiny,
text_halign = text.align_left
, text_valign = text.align_bottom, text_color =
color.new(cLIQ_B, 25)
, bgcolor=color(na), border_color=color(na)
)
, false
 , false
, false
, line.new(st_B, st_P, n -1, st_P, color = color.new(cLIQ_B,
0))
)
)
if b_liq_B.size() > visLiq
getLast = b_liq_B.pop()
getLast.bx.delete()
getLast.ln.delete()
//
if pl
dir := aZZ.d.get (0)
x1 := aZZ.x.get (0)
y1 := aZZ.y.get (0)
y2 := nz(lo[1])
//
if dir > -1 // if previous point was a ph, add, and change direction (-1)
aZZ.in_out(-1, x1, y1, x2, y2, col, true)
else
if dir == -1 and pl < y1
aZZ.x.set(0, x2), aZZ.y.set(0, y2)
//
//Liquidity
if showLq and per and sz > 0
count = 0
st_P = 0.
st_B = 0
minP = 0.
maxP = 10e6
for i = 0 to math.min(sz, 50) -1
if aZZ.d.get(i) == -1
if aZZ.y.get(i) < pl - (atr/a)
break
else
if aZZ.y.get(i) > pl - (atr/a) and aZZ.y.get(i) < pl +
(atr/a)
count += 1
st_B := aZZ.x.get(i)
st_P := aZZ.y.get(i)
if aZZ.y.get(i) > minP
minP := aZZ.y.get(i)
if aZZ.y.get(i) < maxP
maxP := aZZ.y.get(i)
if count > 2
getB = b_liq_S.get(0)
if st_B == getB.bx.get_left()
getB.bx.set_top(math.avg(minP, maxP) + (atr/a))
getB.bx.set_rightbottom(n +10, math.avg(minP, maxP) - (atr/a))
else
b_liq_S.unshift(liq.new(
box.new(
st_B, math.avg(minP, maxP) + (atr/a), n +10, math.avg(minP,
maxP) - (atr/a)
, text = 'Sellside liquidity', text_size = size.tiny,
text_halign = text.align_left
, text_valign = text.align_bottom, text_color =
color.new(cLIQ_S, 25)
, bgcolor=color(na), border_color=color(na)
 )
, false
, false
, false
, line.new(st_B, st_P, n -1, st_P, color = color.new(cLIQ_S,
0))
)
)
if b_liq_S.size() > visLiq
getLast = b_liq_S.pop()
getLast.bx.delete()
getLast.ln.delete()
//
//Market Structure Shift
if showMS
//
iH = aZZ.d.get(2) == 1 ? 2 : 1
iL = aZZ.d.get(2) == -1 ? 2 : 1
//
switch
// MSS Bullish
close > aZZ.y.get(iH) and aZZ.d.get(iH) == 1 and MSS.dir < 1 =>
MSS.dir := 1
if i_mode == 'Present'
MSS.l_bosBl.clear_aLabLin(), MSS.l_bosBr.clear_aLabLin()
MSS.lbBosBl.clear_aLabLin(), MSS.lbBosBr.clear_aLabLin()
MSS.l_mssBl.clear_aLabLin(), MSS.l_mssBr.clear_aLabLin()
MSS.lbMssBl.clear_aLabLin(), MSS.lbMssBr.clear_aLabLin()
//
MSS.l_mssBl.unshift(line.new (
aZZ.x.get(iH), aZZ.y.get(iH), n, aZZ.y.get(iH), color=cMSSbl))
MSS.lbMssBl.unshift(label.new(
math.round(math.avg(aZZ.x.get(iH), n)), aZZ.y.get(iH), text
='MSS'
, style=label.style_label_down, size=size.tiny, color=color(na),
textcolor=cMSSbl))
// MSS Bearish
close < aZZ.y.get(iL) and aZZ.d.get(iL) == -1 and MSS.dir > -1 =>
MSS.dir := -1
if i_mode == 'Present'
MSS.l_bosBl.clear_aLabLin(), MSS.l_bosBr.clear_aLabLin()
MSS.lbBosBl.clear_aLabLin(), MSS.lbBosBr.clear_aLabLin()
MSS.l_mssBl.clear_aLabLin(), MSS.l_mssBr.clear_aLabLin()
MSS.lbMssBl.clear_aLabLin(), MSS.lbMssBr.clear_aLabLin()
//
MSS.l_mssBr.unshift(line.new (
aZZ.x.get(iL), aZZ.y.get(iL), n, aZZ.y.get(iL), color=cMSSbr))
MSS.lbMssBr.unshift(label.new(
math.round(math.avg(aZZ.x.get(iL), n)), aZZ.y.get(iL), text
='MSS'
, style=label.style_label_up , size=size.tiny, color=color(na),
textcolor=cMSSbr))
// BOS Bullish
MSS.dir == 1 and close > aZZ.y.get(iH) and iBOS =>
if MSS.l_bosBl.size() > 0
if aZZ.y.get(iH) != MSS.l_bosBl.get(0).get_y2() and
aZZ.y.get(iH) != MSS.l_mssBl.get(0).get_y2()
MSS.l_bosBl.unshift(set_lin(iH, 'Bl')),
MSS.lbBosBl.unshift(set_lab(iH, 'Bl'))
 else
if aZZ.y.get(iH) != MSS.l_mssBl.get(0).get_y2()
MSS.l_bosBl.unshift(set_lin(iH, 'Bl')),
MSS.lbBosBl.unshift(set_lab(iH, 'Bl'))
// BOS Bearish
MSS.dir == -1 and close < aZZ.y.get(iL) and iBOS =>
if MSS.l_bosBr.size() > 0
if aZZ.y.get(iL) != MSS.l_bosBr.get(0).get_y2() and
aZZ.y.get(iL) != MSS.l_mssBr.get(0).get_y2()
MSS.l_bosBr.unshift(set_lin(iL, 'Br')),
MSS.lbBosBr.unshift(set_lab(iL, 'Br'))
else
if aZZ.y.get(iL) != MSS.l_mssBr.get(0).get_y2()
MSS.l_bosBr.unshift(set_lin(iL, 'Br')),
MSS.lbBosBr.unshift(set_lab(iL, 'Br'))
if not iMSS
MSS.l_mssBl.get(0).set_color(color(na)),
MSS.lbMssBl.get(0).set_textcolor(color(na))
MSS.l_mssBr.get(0).set_color(color(na)),
MSS.lbMssBr.get(0).set_textcolor(color(na))

//-----------------------------------------------------------------------------}
//Calculations
//-----------------------------------------------------------------------------{
draw(len, color.yellow)

if MSS.l_bosBl.size() > 200

MSS.l_bosBl.pop().delete()
MSS.lbBosBl.pop().delete()

if MSS.l_bosBr.size() > 200

MSS.l_bosBr.pop().delete()
MSS.lbBosBr.pop().delete()

//Killzones
ny = time(timeframe.period, input.session('0700-0900', '', inline = 'ny',
group = 'Killzones'), 'America/New_York') and showNy
ldn_open = time(timeframe.period, input.session('0700-1000', '', inline = 'lo',
group = 'Killzones'), 'Europe/London' ) and showLdno // 0200-0500 UTC-5
ldn_close = time(timeframe.period, input.session('1500-1700', '', inline = 'lc',
group = 'Killzones'), 'Europe/London' ) and showLdnc // 1000-1200 UTC-5
asian = time(timeframe.period, input.session('1000-1400', '', inline = 'as',
group = 'Killzones'), 'Asia/Tokyo' ) and showAsia // 2000-0000 UTC-5

//Pivotpoints
ph = ta.pivothigh(3, 1), lPh = fixnan(ph)
pl = ta.pivotlow (3, 1), lPl = fixnan(pl)

//Candles
L_body =
high - mx < body * perc_Body and
mn - low < body * perc_Body

L_bodyUP = body > meanBody and L_body and close > open
L_bodyDN = body > meanBody and L_body and close < open

bsNOTbodyUP = ta.barssince(not L_bodyUP)

bsNOTbodyDN = ta.barssince(not L_bodyDN)

bsIs_bodyUP = ta.barssince( L_bodyUP)

bsIs_bodyDN = ta.barssince( L_bodyDN)

lwst = math.min(lPh [bsNOTbodyUP[1]], low[bsNOTbodyUP[1]])

hgst = math.max(high[bsNOTbodyDN[1]], lPl[bsNOTbodyDN[1]])

//Imbalance
imbalanceUP = L_bodyUP[1] and (i_FVG == 'FVG' ? low > high[2] : low < high[2])
imbalanceDN = L_bodyDN[1] and (i_FVG == 'FVG' ? high < low [2] : high > low [2])

//Volume Imbalance
vImb_Bl = open > close[1] and high[1] > low and close > close[1] and open >
open[1] and high[1] < mn
vImb_Br = open < close[1] and low [1] < high and close < close[1] and open <
open[1] and low [1] > mx

if sVimbl
if vImb_Bl
Vimbal.unshift(
_2ln_lb.new(
line.new (n -1, mx[1], n +3, mx[1], color=cVimbl)
, line.new (n , mn , n +3, mn , color=cVimbl)
, label.new(n +3, math.avg (mx[1], mn), text='VI'
, color=color(na) , textcolor=cVimbl, style=label.style_label_left)
)
)
if vImb_Br
Vimbal.unshift(
_2ln_lb.new(
line.new (n -1, mn[1], n +3, mn[1], color=cVimbl)
, line.new (n , mx , n +3, mx , color=cVimbl)
, label.new(n +3, math.avg (mn[1], mx), text='VI'
, color=color(na) , textcolor=cVimbl, style=label.style_label_left)
)
)
if Vimbal.size() > visVim
pop = Vimbal.pop()
pop.l1.delete()
pop.l2.delete()
pop.lb.delete()

//Fair Value Gap

if barstate.isfirst
for i = 0 to visBxs -1
bFVG_UP.unshift(FVG.new(box(na), false))
bFVG_DN.unshift(FVG.new(box(na), false))
if i_BPR
bBPR_UP.unshift(FVG.new(box(na), false))
bBPR_DN.unshift(FVG.new(box(na), false))

if imbalanceUP and per and shwFVG

if imbalanceUP[1]
bFVG_UP.get(0).box.set_lefttop (n -2, low )
bFVG_UP.get(0).box.set_rightbottom(n +8, high[2])
else
bFVG_UP.unshift(FVG.new(
box.new(
 n -2
, i_FVG == 'FVG' ? low : high[2]
, n, i_FVG == 'FVG' ? high[2] : low
, bgcolor = i_BPR ? color(na) : color.new(cFVGbl, 90)
, border_color= i_BPR ? color(na) : color.new(cFVGbl, 65)
, text_color = i_BPR ? color(na) : color.new(cFVGbl, 65)
, text_size=size.small
, text=i_FVG
)
, true)
)
bFVG_UP.pop().box.delete()

if imbalanceDN and per and shwFVG

if imbalanceDN[1]
bFVG_DN.get(0).box.set_lefttop (n -2, low[2])
bFVG_DN.get(0).box.set_rightbottom(n +8, high )
else
bFVG_DN.unshift(FVG.new(
box.new(
n -2
, i_FVG == 'FVG' ? low[2] : high
, n, i_FVG == 'FVG' ? high : low[2]
, bgcolor = i_BPR ? color(na) : color.new(cFVGbr, 90)
, border_color= i_BPR ? color(na) : color.new(cFVGbr, 65)
, text_color = i_BPR ? color(na) : color.new(cFVGbr, 65)
, text_size=size.small
, text=i_FVG
)
, true)
)
bFVG_DN.pop().box.delete()

//Balance Price Range (overlap of 2 latest FVG bull/bear)

if i_BPR and bFVG_UP.size() > 0 and bFVG_DN.size() > 0
bxUP = bFVG_UP.get(0)
bxDN = bFVG_DN.get(0)
bxUPbtm = bxUP.box.get_bottom()
bxDNbtm = bxDN.box.get_bottom()
bxUPtop = bxUP.box.get_top()
bxDNtop = bxDN.box.get_top()
left = math.min(bxUP.box.get_left (), bxDN.box.get_left ())
right = math.max(bxUP.box.get_right(), bxDN.box.get_right())
//
if bxUPbtm < bxDNtop and
bxDNbtm < bxUPbtm
if left == bBPR_UP.get(0).box.get_left()
if bBPR_UP.get(0).active
bBPR_UP.get(0).box.set_right(right)
else
bBPR_UP.unshift(FVG.new(
box.new(
left, bxDNtop, right, bxUPbtm
, bgcolor = i_BPR ? color.new(cFVGbl, 90) : color(na)
, border_color= i_BPR ? color.new(cFVGbl, 65) : color(na)
, text_color = i_BPR ? color.new(cFVGbl, 65) : color(na)
, text_size=size.small
, text= 'BPR'
)
 , true
, close > bxUPbtm ? 1 : close < bxDNtop ? -1 : 0
)
)
bBPR_UP.pop().box.delete()
//
if bxDNbtm < bxUPtop and
bxUPbtm < bxDNbtm
if left == bBPR_DN.get(0).box.get_left()
if bBPR_DN.get(0).active
bBPR_DN.get(0).box.set_right(right)
else
bBPR_DN.unshift(FVG.new(
box.new(
left, bxUPtop, right, bxDNbtm
, bgcolor = i_BPR ? color.new(cFVGbr, 90) : color(na)
, border_color= i_BPR ? color.new(cFVGbr, 65) : color(na)
, text_color = i_BPR ? color.new(cFVGbr, 65) : color(na)
, text_size=size.small
, text= 'BPR'
)
, true
, close > bxDNbtm ? 1 : close < bxUPtop ? -1 : 0
)
)
bBPR_DN.pop().box.delete()

//FVG's breaks
for i = 0 to math.min(bxBack, bFVG_UP.size() -1)
getUPi = bFVG_UP.get(i)
if getUPi.active
getUPi.box.set_right(bar_index +8)
if low < getUPi.box.get_top() and not i_BPR
getUPi.box.set_border_style(line.style_dashed)
if low < getUPi.box.get_bottom()
if not i_BPR
getUPi.box.set_bgcolor(color.new(cFVGblBR, 95))
getUPi.box.set_border_style(line.style_dotted)
getUPi.box.set_right(bar_index)
getUPi.active := false

for i = 0 to math.min(bxBack, bFVG_DN.size() -1)

getDNi = bFVG_DN.get(i)
if getDNi.active
getDNi.box.set_right(bar_index +8)
if high > getDNi.box.get_bottom() and not i_BPR
getDNi.box.set_border_style(line.style_dashed)
if high > getDNi.box.get_top()
if not i_BPR
getDNi.box.set_bgcolor(color.new(cFVGbrBR, 95))
getDNi.box.set_border_style(line.style_dotted)
getDNi.box.set_right(bar_index)
getDNi.active := false

if i_BPR
for i = 0 to math.min(bxBack, bBPR_UP.size() -1)
getUPi = bBPR_UP.get(i)
if getUPi.active
getUPi.box.set_right(bar_index +8)
 switch getUPi.pos
-1 =>
if high > getUPi.box.get_bottom()
getUPi.box.set_border_style(line.style_dashed)
if high > getUPi.box.get_top ()
getUPi.box.set_bgcolor(color.new(cFVGblBR, 95))
getUPi.box.set_border_style(line.style_dotted)
getUPi.box.set_right(bar_index)
getUPi.active := false
1 =>
if low < getUPi.box.get_top ()
getUPi.box.set_border_style(line.style_dashed)
if low < getUPi.box.get_bottom()
getUPi.box.set_bgcolor(color.new(cFVGblBR, 95))
getUPi.box.set_border_style(line.style_dotted)
getUPi.box.set_right(bar_index)
getUPi.active := false

for i = 0 to math.min(bxBack, bBPR_DN.size() -1)

getDNi = bBPR_DN.get(i)
if getDNi.active
getDNi.box.set_right(bar_index +8)
switch getDNi.pos
-1 =>
if high > getDNi.box.get_bottom()
getDNi.box.set_border_style(line.style_dashed)
if high > getDNi.box.get_top ()
getDNi.box.set_bgcolor(color.new(cFVGbrBR, 95))
getDNi.box.set_border_style(line.style_dotted)
getDNi.box.set_right(bar_index)
getDNi.active := false
1 =>
if low < getDNi.box.get_top ()
getDNi.box.set_border_style(line.style_dashed)
if low < getDNi.box.get_bottom()
getDNi.box.set_bgcolor(color.new(cFVGbrBR, 95))
getDNi.box.set_border_style(line.style_dotted)
getDNi.box.set_right(bar_index)
getDNi.active := false

//NWOG/NDOG
if barstate.isfirst
for i = 0 to maxNWOG -1
bl_NWOG.unshift(bx_ln.new(box(na), line(na)))
for i = 0 to maxNDOG -1
bl_NDOG.unshift(bx_ln.new(box(na), line(na)))

if dayofweek == dayofweek.friday
friCp := close, friCi := n

if ta.change(dayofweek)
if dayofweek == dayofweek.monday and iNWOG
monOp := open , monOi := n
bl_NWOG.unshift(bx_ln.new(
box.new(
friCi , math.max (friCp , monOp )
, monOi , math.min (friCp , monOp )
, bgcolor = color ( na )
, border_color = cNWOG2
 , extend = extend.right )
,
line.new(
monOi , math.avg (friCp , monOp )
, monOi +1 , math.avg (friCp , monOp )
, color = cNWOG1
, style = line.style_dotted
, extend = extend.right )
))
bl = bl_NWOG.pop(), bl.b.delete(), bl.l.delete()
if iNDOG
cuDOp := open , cuDOi := n
prDCp := close[1], prDCi := n -1
//
bl_NDOG.unshift(bx_ln.new(
box.new(
prDCi , math.max (prDCp , cuDOp )
, cuDOi , math.min (prDCp , cuDOp )
, bgcolor = color ( na )
, border_color = cNDOG2
, extend = extend.right )
,
line.new(
cuDOi , math.avg (prDCp , cuDOp )
, cuDOi +1 , math.avg (prDCp , cuDOp )
, color = cNDOG1
, style = line.style_dotted
, extend = extend.right )
))
bl = bl_NDOG.pop(), bl.b.delete(), bl.l.delete()

//Liquidity
for i = 0 to b_liq_B.size() -1
x = b_liq_B.get(i)
if not x.broken
x.bx.set_right(n +3)
x.ln.set_x2 (n +3)
if not x.brokenTop
if close > x.bx.get_top ()
x.brokenTop := true
if not x.brokenBtm
if close > x.bx.get_bottom()
x.brokenBtm := true
if x.brokenBtm
x.bx.set_bgcolor(color.new(cLIQ_B, 90))
x.ln.delete()
if x.brokenTop
x.broken := true
x.bx.set_right(n)

for i = 0 to b_liq_S.size() -1
x = b_liq_S.get(i)
if not x.broken
x.bx.set_right(n +3)
x.ln.set_x2 (n +3)
if not x.brokenTop
if close < x.bx.get_top ()
x.brokenTop := true
if not x.brokenBtm
 if close < x.bx.get_bottom()
x.brokenBtm := true
if x.brokenTop
x.bx.set_bgcolor(color.new(cLIQ_S, 90))
x.ln.delete()
if x.brokenBtm
x.broken := true
x.bx.set_right(n)

//Order Blocks
[top, btm] = swings(length)

if showOB and per

if close > top.y and not top.crossed
top.crossed := true

minima = max[1]
maxima = min[1]
loc = time[1]

for i = 1 to (n - top.x)-1
minima := math.min(min[i], minima)
maxima := minima == min[i] ? max[i] : maxima
loc := minima == min[i] ? time[i] : loc
bullish_ob.unshift(ob.new(maxima, minima, loc))

if bullish_ob.size() > 0
for i = bullish_ob.size()-1 to 0
element = bullish_ob.get(i)

if not element.breaker
if math.min(close, open) < element.btm
element.breaker := true
element.break_loc := time
else
if close > element.top
bullish_ob.remove(i)
else if i < showBull and top.y < element.top and top.y >
element.btm
blBrkConf := 1

//Set label
if blBrkConf > blBrkConf[1] and showLabels
label.new(top.x, top.y, '▼', color = na
, textcolor = bearCss.notransp()
, style = label.style_label_down
, size = size.tiny)

if showOB and per

if close < btm.y and not btm.crossed
btm.crossed := true

minima = min[1]
maxima = max[1]
loc = time[1]

for i = 1 to (n - btm.x)-1
maxima := math.max(max[i], maxima)
minima := maxima == max[i] ? min[i] : minima
 loc := maxima == max[i] ? time[i] : loc
bearish_ob.unshift(ob.new(maxima, minima, loc))

if bearish_ob.size() > 0
for i = bearish_ob.size()-1 to 0
element = bearish_ob.get(i)

if not element.breaker
if math.max(close, open) > element.top
element.breaker := true
element.break_loc := time
else
if close < element.btm
bearish_ob.remove(i)
else if i < showBear and btm.y > element.btm and btm.y <
element.top
brBrkConf := 1

//Set label
if brBrkConf > brBrkConf[1] and showLabels
label.new(btm.x, btm.y, '▲', color = na
, textcolor = bullCss.notransp()
, style = label.style_label_up
, size = size.tiny)

//-----------------------------------------------------------------------------}
//Set Order Blocks
//-----------------------------------------------------------------------------{
if barstate.islast and showOB
if a_bx_ln_lb.size() > 0
for i = a_bx_ln_lb.size() -1 to 0
item = a_bx_ln_lb.remove(i)
item.bx.delete()
item.ln.delete()
item.lb.delete()
//Bullish
if showBull > 0
blSz = bullish_ob.size()
if blSz > 0
for i = 0 to math.min(showBull, bullish_ob.size()) -1
get_ob = bullish_ob.get(i)
get_ob.display(bullCss, bullBrkCss, 'bl')
//Bearish
if showBear > 0
brSz = bearish_ob.size()
if brSz > 0
for i = 0 to math.min(showBear, bearish_ob.size()) -1
get_ob = bearish_ob.get(i)
get_ob.display(bearCss, bearBrkCss, 'br')

//-----------------------------------------------------------------------------}
//Fibonacci
//-----------------------------------------------------------------------------{
if barstate.islast
x1 = 0, y1 = 0., x2 = 0, y2 = 0., box up = na, box dn = na
switch iFib
'FVG' =>
if bFVG_UP.size() > 0 and bFVG_DN.size() > 0
up := bFVG_UP.get(0).box
 dn := bFVG_DN.get(0).box
dnFirst = up.get_left() > dn.get_left()
dnBottm = up.get_top () > dn.get_top ()
x1 := dnFirst ? dn.get_left () : up.get_left ()
x2 := dnFirst ? up.get_right () : dn.get_right ()
y1 := dnFirst ?
dnBottm ? dn.get_bottom() : dn.get_top () :
dnBottm ? up.get_top () : up.get_bottom()
y2 := dnFirst ?
dnBottm ? up.get_top () : up.get_bottom() :
dnBottm ? dn.get_bottom() : dn.get_top ()
'BPR' =>
if bBPR_UP.size() > 0 and bBPR_DN.size() > 0
up := bBPR_UP.get(0).box
dn := bBPR_DN.get(0).box
dnFirst = up.get_left() > dn.get_left()
dnBottm = up.get_top () > dn.get_top ()
x1 := dnFirst ? dn.get_left () : up.get_left ()
x2 := dnFirst ? up.get_right () : dn.get_right ()
y1 := dnFirst ?
dnBottm ? dn.get_bottom() : dn.get_top () :
dnBottm ? up.get_top () : up.get_bottom()
y2 := dnFirst ?
dnBottm ? up.get_top () : up.get_bottom() :
dnBottm ? dn.get_bottom() : dn.get_top ()
'OB' =>
oSz = a_bx_ln_lb.size()
if oSz > 1
xA = nz(
a_bx_ln_lb.get(oSz -1).ln.get_x1 ()
, a_bx_ln_lb.get(oSz -1).bx.get_left ()
)
xB = nz(
a_bx_ln_lb.get(oSz -2).ln.get_x1 ()
, a_bx_ln_lb.get(oSz -2).bx.get_left ()
)
AFirst = xB > xA
//
yAT = nz(
a_bx_ln_lb.get(oSz -1).ln.get_y1 ()
, a_bx_ln_lb.get(oSz -1).bx.get_top ()
)
yAB = nz(
a_bx_ln_lb.get(oSz -1).ln.get_y1 ()
, a_bx_ln_lb.get(oSz -1).bx.get_bottom()
)
yBT = nz(
a_bx_ln_lb.get(oSz -2).ln.get_y1 ()
, a_bx_ln_lb.get(oSz -2).bx.get_top ()
)
yBB = nz(
a_bx_ln_lb.get(oSz -2).ln.get_y1 ()
, a_bx_ln_lb.get(oSz -2).bx.get_bottom()
)
ABottom = yAB < yBB
//
x1 := AFirst ? xA : xB
x2 := AFirst ? xB : xA
y1 := AFirst ?
 ABottom ? yAB : yAT :
ABottom ? yBT : yBB
y2 := AFirst ?
ABottom ? yBT : yBB :
ABottom ? yAB : yAT
'Liq' =>
if b_liq_B.size() > 0 and b_liq_S.size() > 0
xA = nz(
b_liq_B.get(0).ln.get_x1 ()
, b_liq_B.get(0).bx.get_left ()
)
xB = nz(
b_liq_S.get(0).ln.get_x1 ()
, b_liq_S.get(0).bx.get_left ()
)
AFirst = xB > xA
//
yAT = nz(
b_liq_B.get(0).ln.get_y1 ()
, b_liq_B.get(0).bx.get_top ()
)
yAB = nz(
b_liq_B.get(0).ln.get_y1 ()
, b_liq_B.get(0).bx.get_bottom()
)
yBT = nz(
b_liq_S.get(0).ln.get_y1 ()
, b_liq_S.get(0).bx.get_top ()
)
yBB = nz(
b_liq_S.get(0).ln.get_y1 ()
, b_liq_S.get(0).bx.get_bottom()
)
ABottom = yAB < yBB
//
x1 := AFirst ? xA : xB
x2 := AFirst ? xB : xA
y1 := AFirst ?
ABottom ? yAB : yAT :
ABottom ? yBT : yBB
y2 := AFirst ?
ABottom ? yBT : yBB :
ABottom ? yAB : yAT
'VI' =>
if Vimbal.size() > 1
AxA = Vimbal.get(1).l2.get_x1(), AxB = Vimbal.get(1).l1.get_x1()
BxA = Vimbal.get(0).l2.get_x1(), BxB = Vimbal.get(0).l1.get_x1()
AyA = Vimbal.get(1).l2.get_y1(), AyB = Vimbal.get(1).l1.get_y1()
ByA = Vimbal.get(0).l2.get_y1(), ByB = Vimbal.get(0).l1.get_y1()
ABt = math.min(ByA, ByB) > math.min(AyA, AyB)
x1 := math.max(AxA, AxB)
x2 := math.max(BxA, BxB)
y1 := ABt ? math.min(AyA, AyB) : math.max(AyA, AyB)
y2 := ABt ? math.max(ByA, ByB) : math.min(ByA, ByB)
'NWOG' =>
if bl_NWOG.size() > 1
up := bl_NWOG.get(0).b
dn := bl_NWOG.get(1).b
dnFirst = up.get_left() > dn.get_left()
 dnBottm = up.get_top () > dn.get_top ()
x1 := dnFirst ? dn.get_left () : up.get_left ()
x2 := dnFirst ? up.get_right() : dn.get_right()
y1 := dnFirst ?
dnBottm ? dn.get_bottom() : dn.get_top () :
dnBottm ? up.get_top () : up.get_bottom()
y2 := dnFirst ?
dnBottm ? up.get_top () : up.get_bottom() :
dnBottm ? dn.get_bottom() : dn.get_top ()
//
if iFib != 'NONE'
rt = math.max(x1, x2)
lt = math.min(x1, x2)
tp = math.max(y1, y2)
bt = math.min(y1, y2)
_0 = rt == x1 ? y1 : y2
_1 = rt == x1 ? y2 : y1
//
df = _1 - _0
m0236 = df * 0.236
m0382 = df * 0.382
m0500 = df * 0.500
m0618 = df * 0.618
m0786 = df * 0.786
m1618 = df * 1.618
//
_diag.setLine(x1, y1 , x2 , y2 )
_vert.setLine(rt, _0 , rt , _0 + m1618)
_zero.setLine(rt, _0 , rt + plus, _0 )
_0236.setLine(rt, _0 + m0236, rt + plus, _0 + m0236)
_0382.setLine(rt, _0 + m0382, rt + plus, _0 + m0382)
_0500.setLine(rt, _0 + m0500, rt + plus, _0 + m0500)
_0618.setLine(rt, _0 + m0618, rt + plus, _0 + m0618)
_0786.setLine(rt, _0 + m0786, rt + plus, _0 + m0786)
_one_.setLine(rt, _1 , rt + plus, _1 )
_1618.setLine(rt, _0 + m1618, rt + plus, _0 + m1618)

//-----------------------------------------------------------------------------}
//Displacement
//-----------------------------------------------------------------------------{
plotshape(sDispl ? per ?
L_bodyUP ? low : na : na : na
, title = 'Displacement UP'
, style = shape.labelup
, color = color.lime
, location = location.belowbar)
plotshape(sDispl ? per ?
L_bodyDN ? high : na : na : na
, title = 'Displacement DN'
, style = shape.labeldown
, color = color.red
, location = location.abovebar)

//-----------------------------------------------------------------------------}
//background - Killzones
//-----------------------------------------------------------------------------{
bgcolor (per ? ny ? nyCss : na : na, editable = false)
bgcolor (per ? ldn_open ? ldnoCss : na : na, editable = false)
bgcolor (per ? ldn_close ? ldncCss : na : na, editable = false)
bgcolor (per ? asian ? asiaCss : na : na, editable = false)

//-----------------------------------------------------------------------------}

//@version=5
indicator("Liquidity Swings [LuxAlgo]"
, overlay = true
, max_lines_count = 500
, max_labels_count = 500
, max_boxes_count = 500)
//------------------------------------------------------------------------------
//Settings
//-----------------------------------------------------------------------------{
length = input(14, 'Pivot Lookback')

area = input.string('Wick Extremity', 'Swing Area', options = ['Wick Extremity',

'Full Range'])

intraPrecision = input(false, 'Intrabar Precision', inline = 'intrabar')

intrabarTf = input.timeframe('1', '' , inline = 'intrabar')

filterOptions = input.string('Count', 'Filter Areas By', options = ['Count',

'Volume'], inline = 'filter')
filterValue = input.float(0, '' ,
inline = 'filter')

//Style
showTop = input(true, 'Swing High' , inline = 'top', group =
'Style')
topCss = input(color.red, '' , inline = 'top', group =
'Style')
topAreaCss = input(color.new(color.red, 50), 'Area', inline = 'top', group =
'Style')

showBtm = input(true, 'Swing Low' , inline = 'btm', group =

'Style')
btmCss = input(color.teal, '' , inline = 'btm', group =
'Style')
btmAreaCss = input(color.new(color.teal, 50), 'Area', inline = 'btm', group =
'Style')

labelSize = input.string('Tiny', 'Labels Size', options = ['Tiny', 'Small',

'Normal'], group = 'Style')

//-----------------------------------------------------------------------------}
//Functions
//-----------------------------------------------------------------------------{
n = bar_index

get_data()=> [high, low, volume]

[h, l, v] = request.security_lower_tf(syminfo.tickerid, intrabarTf, get_data())

get_counts(condition, top, btm)=>

var count = 0
var vol = 0.

if condition
 count := 0
vol := 0.
else
if intraPrecision
if n > length
if array.size(v[length]) > 0
for [index, element] in v[length]
vol += array.get(l[length], index) < top and
array.get(h[length], index) > btm ? element : 0
else
vol += low[length] < top and high[length] > btm ? volume[length] : 0

count += low[length] < top and high[length] > btm ? 1 : 0

[count, vol]

set_label(count, vol, x, y, css, lbl_style)=>

var label lbl = na
var label_size = switch labelSize
'Tiny' => size.tiny
'Small' => size.small
'Normal' => size.normal

target = switch filterOptions

'Count' => count
'Volume' => vol

if ta.crossover(target, filterValue)
lbl := label.new(x, y, str.tostring(vol, format.volume)
, style = lbl_style
, size = label_size
, color = #00000000
, textcolor = css)

if target > filterValue

label.set_text(lbl, str.tostring(vol, format.volume))

set_level(condition, crossed, value, count, vol, css)=>

var line lvl = na

target = switch filterOptions

'Count' => count
'Volume' => vol

if condition
if target[1] < filterValue[1]
line.delete(lvl[1])
else if not crossed[1]
line.set_x2(lvl, n - length)

lvl := line.new(n - length, value, n, value

, color = na)

if not crossed[1]
line.set_x2(lvl, n+3)

if crossed and not crossed[1]

line.set_x2(lvl, n)
line.set_style(lvl, line.style_dashed)
 if target > filterValue
line.set_color(lvl, css)

set_zone(condition, x, top, btm, count, vol, css)=>

var box bx = na

target = switch filterOptions

'Count' => count
'Volume' => vol

if ta.crossover(target, filterValue)
bx := box.new(x, top, x + count, btm
, border_color = na
, bgcolor = css)

if target > filterValue

box.set_right(bx, x + count)

//-----------------------------------------------------------------------------}
//Global variables
//-----------------------------------------------------------------------------{
//Pivot high
var float ph_top = na
var float ph_btm = na
var bool ph_crossed = na
var ph_x1 = 0
var box ph_bx = box.new(na,na,na,na
, bgcolor = color.new(topAreaCss, 80)
, border_color = na)

//Pivot low
var float pl_top = na
var float pl_btm = na
var bool pl_crossed = na
var pl_x1 = 0
var box pl_bx = box.new(na,na,na,na
, bgcolor = color.new(btmAreaCss, 80)
, border_color = na)

//-----------------------------------------------------------------------------}
//Display pivot high levels/blocks
//-----------------------------------------------------------------------------{
ph = ta.pivothigh(length, length)

//Get ph counts
[ph_count, ph_vol] = get_counts(ph, ph_top, ph_btm)

//Set ph area and level

if ph and showTop
ph_top := high[length]
ph_btm := switch area
'Wick Extremity' => math.max(close[length], open[length])
'Full Range' => low[length]

ph_x1 := n - length
ph_crossed := false

box.set_lefttop(ph_bx, ph_x1, ph_top)

 box.set_rightbottom(ph_bx, ph_x1, ph_btm)
else
ph_crossed := close > ph_top ? true : ph_crossed

if ph_crossed
box.set_right(ph_bx, ph_x1)
else
box.set_right(ph_bx, n+3)

if showTop
//Set ph zone
set_zone(ph, ph_x1, ph_top, ph_btm, ph_count, ph_vol, topAreaCss)

//Set ph level
set_level(ph, ph_crossed, ph_top, ph_count, ph_vol, topCss)

//Set ph label
set_label(ph_count, ph_vol, ph_x1, ph_top, topCss, label.style_label_down)

//-----------------------------------------------------------------------------}
//Display pivot low levels/blocks
//-----------------------------------------------------------------------------{
pl = ta.pivotlow(length, length)

//Get pl counts
[pl_count, pl_vol] = get_counts(pl, pl_top, pl_btm)

//Set pl area and level

if pl and showBtm
pl_top := switch area
'Wick Extremity' => math.min(close[length], open[length])
'Full Range' => high[length]
pl_btm := low[length]

pl_x1 := n - length
pl_crossed := false

box.set_lefttop(pl_bx, pl_x1, pl_top)

box.set_rightbottom(pl_bx, pl_x1, pl_btm)
else
pl_crossed := close < pl_btm ? true : pl_crossed

if pl_crossed
box.set_right(pl_bx, pl_x1)
else
box.set_right(pl_bx, n+3)

if showBtm
//Set pl zone
set_zone(pl, pl_x1, pl_top, pl_btm, pl_count, pl_vol, btmAreaCss)

//Set pl level
set_level(pl, pl_crossed, pl_btm, pl_count, pl_vol, btmCss)

//Set pl labels
set_label(pl_count, pl_vol, pl_x1, pl_btm, btmCss, label.style_label_up)