import TradingView/Strategy/3

// // This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0

International (CC BY-NC-SA 4.0) https://creativecommons.org/licenses/by-nc-sa/4.0/
// // © LuxAlgo

//@version=5
strategy( 'TTP ICT Unicorn Model [LuxAlgo]'
, 'TTP LuxAlgo - ICT Unicorn Model'
, max_boxes_count =500
, max_lines_count =500
, max_labels_count=500
, overlay=true
, default_qty_type = strategy.percent_of_equity
, initial_capital = 25
)

exposure = input.float(10,"exposure %")

payload = input.text_area("","payload")
uuid = input.string("","UUID")
symbol = input.string("","symbol")
trend = input.bool(false,"trend")
lenght = input.int(200,"lenght")
//ma =ta.vwma(close,lenght)
ma =ta.ema(close,lenght)
//ma =ta.sma(close,lenght)

filterLong = close > ma or not trend

filterShort = close < ma or not trend
plot(ma,"ma",color = close > ma ? color.green : color.red ,linewidth = 2)

buildPayload(_riskPrice,_entryPrice,_rewardPrice,_buy)=>
_result = ""
_posSize = 0.0

if not (na(_riskPrice) or na(_entryPrice) or na(_rewardPrice))

_d = (_buy ? _entryPrice - _riskPrice : _riskPrice - _entryPrice) /
_entryPrice
_posSize := (exposure / 100) / _d
_result := str.replace(payload,"$UUID", uuid)
_result := str.replace(_result,"$PERCENTAGE",str.tostring(_posSize,"#.##"))
_result := str.replace(_result,"$SYMBOL",symbol)
_result := str.replace(_result,"$SIDE",_buy ? "BUY": "SELL")
_result := str.replace(_result,"TP",str.tostring(_rewardPrice))
_result := str.replace(_result,"SL",str.tostring(_riskPrice))
[_result, _posSize]

//------------------------------------------------------------------------------
// Settings
//-----------------------------------------------------------------------------{
len = input.int ( 10 , 'Swings'
, group='Unicorn')

iBull = input.bool ( true , 'Bull' ,

inline = 'bl', group='Unicorn')
colBl = input.color ( #089981 , '' ,
inline = 'bl', group='Unicorn')
iBear = input.bool ( true , 'Bear' ,
inline = 'br', group='Unicorn')
colBr = input.color ( #f23645 , '' ,
inline = 'br', group='Unicorn')

combine = input.bool ( false , 'Combine'

, tooltip= 'Bull and Bear pattern can be present at the same
time' , group='Unicorn')

//Targets
risk = input.float ( 1 ,
'Risk/Reward' , step = .1, inline = 'r' , group='Targets')
reward = input.float ( 1 ,
':' , step = .1, inline = 'r' , group='Targets')
rr = reward / risk

trail = input.bool ( false , 'Trailing Stop' ,

inline = 'ts', group='Targets')
lenS = input.int ( 5 , '', minval =3, maxval=10,
inline = 'ts', group='Targets')

showTargets = input(true, 'Target Areas' ,

inline='target_css', group='Targets')
colRisk = input.color(color.new(#787b86, 80), '' ,
inline='target_css', group='Targets')
colReward = input.color(color.new(#5b9cf6, 80), '' ,
inline='target_css', group='Targets')

//-----------------------------------------------------------------------------}
//UDT's
//-----------------------------------------------------------------------------{
type piv
int b
float p
bool br

type ZZ
int [] d
int [] x
float [] y

type unicorn
box box
box fvg
box Risk
box Reward

line lT
line lB
line SL
line linSL

label labC

bool active
bool isTaR
bool isTsL
bool trig
 float swing
float TaR
float TsL

//-----------------------------------------------------------------------------}
//Variables
//-----------------------------------------------------------------------------{
var x = 0
var y = 0.
var z = 0.

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

var patL = array.new< line >(3, line.new(na, na, na, na))

var aUniBl = array.new<unicorn>(2, unicorn.new(

box.new (na, 0, 0, na)
, box.new (na, 0, 0, na)
, box.new (na, 0, 0, na)
, box.new (na, 0, 0, na)
, line.new(na, 0, 0, na)
, line.new(na, 0, 0, na)
, line.new(na, 0, 0, na)
, line.new(na, 0, 0, na)
, label.new (na, na)
, false, false, false, false
, na , na , na
)
)
var aUniBr = array.new<unicorn>(2, unicorn.new(
box.new (na, 0, 0, na)
, box.new (na, 0, 0, na)
, box.new (na, 0, 0, na)
, box.new (na, 0, 0, na)
, line.new(na, 0, 0, na)
, line.new(na, 0, 0, na)
, line.new(na, 0, 0, na)
, line.new(na, 0, 0, na)
, label.new (na, na)
, false, false, false, false
, na , na , na
)
)

piv[] swingH = na
piv[] swingL = na
float mnPiv = na
float mxPiv = 0

//-----------------------------------------------------------------------------}
//Methods
//-----------------------------------------------------------------------------{
method in_out(ZZ aZZ, int d, int Cx, float Cy, int Dx, float Dy) =>
aZZ.d.unshift(d), aZZ.x.unshift(Dx), aZZ.y.unshift(Dy), aZZ.d.pop(),
aZZ.x.pop(), aZZ.y.pop()

method n(float p) => bool out = not na(p)

method remove(unicorn uni) =>

uni.active := false
uni.swing := na
uni.TaR := na
uni.fvg .delete()
uni.linSL.delete()
uni.lT .delete()
uni.lB .delete()
uni.SL .delete()
uni.labC .delete()
uni.box.set_bgcolor(color.new(na, na))

//-----------------------------------------------------------------------------}
//Execution
//-----------------------------------------------------------------------------{
n = bar_index
atr = ta.atr(14)
cFg = chart.fg_color

lenL = 1
ph = ta.pivothigh(len, lenL)
pl = ta.pivotlow (len, lenL)

phTsL = ta.pivothigh(lenS, lenS)

plTsL = ta.pivotlow (lenS, lenS)

highest = ta.highest(5)
lowest = ta.lowest (5)

firstBl = aUniBl.first()
firstBr = aUniBr.first()

secndBl = aUniBl.get (1)

secndBr = aUniBr.get (1)

bool chS_bl = ta.change(firstBl.swing) != 0

bool chS_br = ta.change(firstBr.swing) != 0

//Creating ZZ
if ph.n()
if ph > mxPiv
mxPiv := ph
if swingH.size() > 0
for i = swingH.size() -1 to 0
get = swingH.get(i)
if ph >= get.p
swingH.remove(i)

swingH.unshift(piv.new(n -1, ph))

dr_ = aZZ.d.get (0)

 Cx_ = aZZ.x.get (0)
Cy_ = aZZ.y.get (0)
Dx_ = n -lenL
Dy_ = high[lenL]

if dr_ < 1 // if previous point was a pl, add, and change direction ( 1)
aZZ.in_out( 1, Cx_, Cy_, Dx_, Dy_)
else
if dr_ == 1 and ph > Cy_
aZZ.x.set(0, Dx_), aZZ.y.set(0, Dy_)

if pl.n()
if pl < mnPiv
mnPiv := pl
if swingL.size() > 0
for i = swingL.size() -1 to 0
get = swingL.get(i)
if pl <= get.p
swingL.remove(i)

swingL.unshift(piv.new(n -1, pl))

dr_ = aZZ.d.get (0)

Cx_ = aZZ.x.get (0)
Cy_ = aZZ.y.get (0)
Dx_ = n -lenL
Dy_ = low[lenL]

if dr_ > -1 // if previous point was a ph, add, and change direction (-1)
aZZ.in_out(-1, Cx_, Cy_, Dx_, Dy_)
else
if dr_ == -1 and pl < Cy_
aZZ.x.set(0, Dx_), aZZ.y.set(0, Dy_)

Ax = aZZ.x.get (3)
Ay = aZZ.y.get (3)
Bx = aZZ.x.get (2)
By = aZZ.y.get (2)
Cx = aZZ.x.get (1)
Cy = aZZ.y.get (1)
Dx = aZZ.x.get (0)
Dy = aZZ.y.get (0)
dir = aZZ.d.get (0)

//Unicorn Pattern
if firstBl.active
if combine or (not combine and (not firstBl.active[1] or chS_bl))
if not secndBl.trig
secndBl.remove()

if not firstBl.trig and

close < firstBl.fvg.get_bottom()
firstBl.remove()

if firstBr.active
if combine or (not combine and (not firstBr.active[1] or chS_br))
if not secndBr.trig
secndBr.remove()
 if not firstBr.trig and
close > firstBr.fvg.get_top()
firstBr.remove()

if n -lenL == Dx

if dir < 1 and iBear

and close[lenL] < By and Cy > Ay
and Dx - Cx > (len > 1 ? 1 : 0 )
and Cx - Bx > (len > 1 ? 1 : 0 )
and Bx - Ax > (len > 1 ? 1 : 0 )

// BRB
switch
close[n - Bx +0] < open[n - Bx +0] => x := Bx -0, y := high[n - Bx +0],
z := low[n - Bx +0]
close[n - Bx +1] < open[n - Bx +1] => x := Bx -1, y := high[n - Bx +1],
z := low[n - Bx +1]
close[n - Bx +2] < open[n - Bx +2] => x := Bx -2, y := high[n - Bx +2],
z := low[n - Bx +2]
close[n - Bx +3] < open[n - Bx +3] => x := Bx -3, y := high[n - Bx +3],
z := low[n - Bx +3]
close[n - Bx +4] < open[n - Bx +4] => x := Bx -4, y := high[n - Bx +4],
z := low[n - Bx +4]

// FVG
for i = 0 to n - Cx
fvgT = low[i+2]
fvgB = high[i]
if fvgB < fvgT
and ((fvgT < y and fvgT > z) or (fvgB < y and fvgB > z))
and fvgT - fvgB > atr * 0.05 // FVG large enough
if y != firstBr.box.get_top()
aUniBr.unshift(unicorn.new(
box = box.new( x , y , n -i-2 , z
, border_color = color.new( cFg , 100)
, bgcolor = color.new( cFg , 97))
, fvg = box.new(n -i-2, low[i+2], n-1, high[i]
, border_color = color.new( na , na )
, bgcolor = color.new( colBr , 75))
, active = true , swing = Cy
, isTaR = false, TaR = na
, lT = line.new(x, y, n-1, y
, color=color.new(cFg, 50)
, style=line.style_dashed)
, lB = line.new(x, z, n-1, z
, color=color.new(cFg, 50)
, style=line.style_dashed)
, SL = line.new(Cx, Cy, Cx, Cy
, color=color.new(cFg, 65)
, style=line.style_dotted)
, trig=false
)
)

if not combine
 if not firstBl.trig
firstBl.remove()

firstBl.active := false
firstBl.TaR := na
firstBl.TsL := na
firstBl.swing := na

break

if dir > -1 and iBull

and close[lenL] > By and Cy < Ay
and Dx - Cx > (len > 1 ? 1 : 0 )
and Cx - Bx > (len > 1 ? 1 : 0 )
and Bx - Ax > (len > 1 ? 1 : 0 )

// BRB
switch
close[n - Bx +0] > open[n - Bx +0] => x := Bx -0, y := high[n - Bx +0],
z := low[n - Bx +0]
close[n - Bx +1] > open[n - Bx +1] => x := Bx -1, y := high[n - Bx +1],
z := low[n - Bx +1]
close[n - Bx +2] > open[n - Bx +2] => x := Bx -2, y := high[n - Bx +2],
z := low[n - Bx +2]
close[n - Bx +3] > open[n - Bx +3] => x := Bx -3, y := high[n - Bx +3],
z := low[n - Bx +3]
close[n - Bx +4] > open[n - Bx +4] => x := Bx -4, y := high[n - Bx +4],
z := low[n - Bx +4]

// FVG
for i = 0 to n - Cx
fvgB = high[i+2]
fvgT = low [i]
if fvgB < fvgT
and ((fvgT < y and fvgT > z) or (fvgB < y and fvgB > z))
and fvgT - fvgB > atr * 0.05 // FVG large enough
if y != firstBl.box.get_top()
aUniBl.unshift(unicorn.new(
box = box.new( x , y , n-i-2 , z
, border_color = color.new( cFg , 100)
, bgcolor = color.new( cFg , 97))
, fvg = box.new(n -i-2, low[i], n-1, high[i+2]
, border_color = color.new( na , na )
, bgcolor = color.new( colBl , 75))
, active = true , swing = Cy
, isTaR = false, TaR = na
, lT = line.new(x, y, n-1, y
, color=color.new(cFg, 50)
, style=line.style_dashed)
, lB = line.new(x, z, n-1, z
, color=color.new(cFg, 50)
, style=line.style_dashed)
, SL = line.new(Cx, Cy, Cx, Cy
, color=color.new(cFg, 65)
, style=line.style_dotted)
, trig = false
)
)
 if not combine

if not firstBr.trig
firstBr.remove()

firstBr.active := false
firstBr.TaR := na
firstBr.TsL := na
firstBr.swing := na

break

if firstBr.active

firstBr.Risk .set_right(n +1)

firstBr.Reward.set_right(n +1)

rgt = firstBr.fvg.get_right()
top = firstBr.lT .get_y2 ()
btm = firstBr.lB .get_y2 ()

isStopBr = high > firstBr.swing

if isStopBr
if showTargets
firstBr.linSL :=
line.new(
rgt, firstBr.swing
, n, firstBr.swing
, color
= color.new(cFg, 50))

firstBr.active := false
firstBr.TaR := na
firstBr.TsL := na
firstBr.swing := na

if not firstBr.trig
firstBr.fvg.set_right(n-1)

if firstBr.isTaR
if low < firstBr.TaR
if showTargets
line.new(
rgt, firstBr.TaR
, n, firstBr.TaR
, color
= color.new(cFg, 50))

firstBr.isTaR := false
firstBr.active := false
firstBr.TaR := na
firstBr.TsL := na

if trail

switch
close[1] > firstBr.TsL[1] => firstBr.TsL := na
close > firstBr.TsL => firstBr.isTsL := false
 if phTsL.n()
firstBr.TsL := math.min(firstBr.TsL, phTsL)
else
trigger =
close < btm
and open > btm and open < top
and math.max(close[1], open[1]) > btm
and math.min(close[1], open[1]) < top

if trigger
label.new(n, high, text='●'
, color=color.new(na, na), textcolor=colBr
, style=label.style_label_center
, size=size.tiny
)

firstBr.trig := true
firstBr.isTaR := true

firstBr.SL .set_x2 (n)

firstBr.lT .set_x2 (n)
firstBr.lB .set_x2 (n)
firstBr.fvg.set_right(n)

diff = (firstBr.swing - btm) * rr

firstBr.TaR := btm - diff
firstBr.TsL := firstBr.swing

if showTargets
riskPrice = chart.point.from_index(n , firstBr.swing).price
entryPrice = chart.point.from_index(n +1, btm ).price
rewardPrice = chart.point.from_index(n +1, btm - diff).price

log.info(("short riskPrice:" + str.tostring(riskPrice)))

log.info(("short entryPrice:" + str.tostring(entryPrice)))
log.info(("short rewardPrice:" + str.tostring(rewardPrice)))

[sellPayload,posSize] =
buildPayload(riskPrice,entryPrice,rewardPrice,false)

if strategy.opentrades == 0 and filterShort

_qty = strategy.equity * posSize / close
strategy.entry("sell",strategy.short, qty = _qty)
strategy.exit("sell exit", from_entry = "sell",qty_percent =
100 , limit = rewardPrice , stop = riskPrice)

log.info("sell payload\n",sellPayload)
alert(sellPayload, alert.freq_once_per_bar_close)

firstBr.Risk := box.new(
chart.point.from_index(n , firstBr.swing)
, chart.point.from_index(n +1, btm )
, border_color=color.new(na , na )
, bgcolor =colRisk
)
firstBr.Reward := box.new(
chart.point.from_index(n , btm )
, chart.point.from_index(n +1, btm - diff)
 , border_color=color.new(na , na )
, bgcolor =colReward
)

if firstBl.active

firstBl.Risk .set_right(n +1)

firstBl.Reward.set_right(n +1)

top = firstBl.lT .get_y2 ()

btm = firstBl.lB .get_y2 ()
rgt = firstBl.fvg.get_right()

isStopBl = low < firstBl.swing

if isStopBl
if showTargets
firstBl.linSL :=
line.new(
rgt, firstBl.swing
, n, firstBl.swing
, color
= color.new(cFg, 50))

firstBl.active := false
firstBl.TaR := na
firstBl.TsL := na
firstBl.swing := na

if not firstBl.trig
firstBl.fvg.set_right(n-1)

if firstBl.isTaR
if high > firstBl.TaR
if showTargets
line.new(
rgt, firstBl.TaR
, n, firstBl.TaR
, color
= color.new(cFg, 50))

firstBl.isTaR := false
firstBl.active := false
firstBl.TaR := na
firstBl.TsL := na

if trail
switch
close[1] < firstBl.TsL[1] => firstBl.TsL := na
close < firstBl.TsL => firstBl.isTsL := false

if plTsL.n()
firstBl.TsL := math.max(firstBl.TsL, plTsL)
else
trigger =
close > top
and open < top and open > btm
and math.min(close[1], open[1]) < top
and math.max(close[1], open[1]) > btm
 if trigger
label.new(n, low, text='●'
, color=color.new(na, na), textcolor=colBl
, style=label.style_label_center
, size=size.tiny
)

firstBl.trig := true
firstBl.isTaR := true

firstBl.SL .set_x2 (n)

firstBl.lT .set_x2 (n)
firstBl.lB .set_x2 (n)
firstBl.fvg.set_right(n)

diff = (top - firstBl.swing) * rr

firstBl.TaR := top + diff
firstBl.TsL := firstBl.swing

if showTargets

riskPrice = chart.point.from_index(n , firstBr.swing).price

entryPrice = chart.point.from_index(n +1, btm ).price
rewardPrice = chart.point.from_index(n +1, btm - diff).price

log.info(("long riskPrice:" + str.tostring(riskPrice)))

log.info(("long entryPrice:" + str.tostring(entryPrice)))
log.info(("long rewardPrice:" + str.tostring(rewardPrice)))

[buyPayload,posSize] =
buildPayload(riskPrice,entryPrice,rewardPrice,true)

if strategy.opentrades == 0 and filterLong

_qty =strategy.equity * posSize /close
strategy.entry("buy",strategy.long, qty = _qty)
strategy.exit("buy exit", from_entry = "buy",qty_percent =
100 , limit = rewardPrice , stop = riskPrice)

log.info("buyPayload:\n"+ buyPayload)
alert(buyPayload,alert.freq_once_per_bar_close)

firstBl.Risk := box.new(
chart.point.from_index(n , firstBl.swing)
, chart.point.from_index(n +1, top )
, border_color=color.new(na , na )
, bgcolor =colRisk
)
firstBl.Reward := box.new(
chart.point.from_index(n , top )
, chart.point.from_index(n +1, top + diff)
, border_color=color.new(na , na )
, bgcolor =colReward
)

//-----------------------------------------------------------------------------}
//Plot
//-----------------------------------------------------------------------------{
plot(trail and (firstBl.TsL >= firstBl.TsL[1] or na(firstBl.TsL[1])) ?
firstBl.TsL : na, color = colBl, style=plot.style_linebr)
plot(trail and (firstBr.TsL <= firstBr.TsL[1] or na(firstBr.TsL[1])) ?
firstBr.TsL : na, color = colBr, style=plot.style_linebr)

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