TD RSI Strategy

// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © rhapsodyz

//@version=5


// #########################
// === Strategy Settings ===
// #########################

strategy(title = "TD RSI Strategy", 
     overlay            = true, 
     pyramiding         = 1, 
     initial_capital    = 10000, 
     default_qty_type   = strategy.percent_of_equity, 
     default_qty_value  = 100, 
     commission_type    = strategy.commission.percent, 
     commission_value   = 0.04, 
     slippage           = 2)

strat_dir_input = 
     input.string(title ="Strategy Direction", 
         defval         ="long", 
         options        =["long", "short", "all"])

strat_dir_value = 
     strat_dir_input == "long" ? strategy.direction.long : 
     strat_dir_input == "short" ? strategy.direction.short : 
     strategy.direction.all

strategy.risk.allow_entry_in(strat_dir_value)

// #######################
// === General Numbers ===
// #######################

// === Equity Usage ===
equityUsage = input(0.9, title="Equity Usage Percentage")
_qty = (strategy.equity * equityUsage) / close

// === Input A TD Sequential ===
tdSetup() =>
    var int setupCount = 0
    var int setupDirection = 0
    if close > close[4]
        if setupDirection != 1
            setupCount := 1
            setupDirection := 1
        else
            setupCount += 1
    else if close < close[4]
        if setupDirection != -1
            setupCount := -1
            setupDirection := -1
        else
            setupCount -= 1
    else
        setupCount := 0
    [setupCount, setupDirection]

// === Input B RSI ===
rsiLength       = input.int(14, minval=1, title="RSI Length", group="RSI Settings")
rsiSource       = input.source(hlc3, "RSI Source", group="RSI Settings")
rsiMALength     = input.int(14, title="MA Length", group="Boll Settings")
rsiBollMult     = input.float(2.0, minval=0.001, maxval=50, title="Boll StdDev", group="Boll Settings")
showBreakout    = input.bool(true, title="Show Breakout", group="RSI Settings")
rsiDivBreakLow  = input.float(1.0, minval=0.001, maxval=3, title="Breakout Value Low", group="RSI Settings")
rsiDivBreakHigh = input.float(1.3, minval=0.001, maxval=3, title="Breakout Value High", group="RSI Settings")
rsiRawBreak     = input.int(25, minval = 1, title = "RSI Raw Breakout Value", group = "RSI Settings")

// === Input C MACD ===
macdFastLength      = input(12, title="Fast Length", group="MACD Settings")
macdSlowLength      = input(26, title="Slow Length", group="MACD Settings")
macdSignalLength    = input(9, title="Signal Length", group="MACD Settings")

// === Input D SMI ===
smiLengthK     = input.int(10, "%K Length",  minval = 1, maxval = 150)
smiLengthD     = input.int(3,  "%D Length",  minval = 1, maxval = 50)
smiLengthEMA   = input.int(8,  "EMA Length", minval = 1, maxval = 50)
smiOversold    = - 40
smiOverbought  =   40

// ##################
// === Indicators ===
// ##################

// === Indicator A TD Sequential ===
[setup, direction] = tdSetup()
td9_down = setup == 9
td9_up = setup == -9
tdSignal = td9_down or td9_up

// === Indicator B RSI ===
up          = ta.rma(math.max(ta.change(rsiSource), 0), rsiLength)
down        = ta.rma(-math.min(ta.change(rsiSource), 0), rsiLength)
rsi         = down == 0 ? 50 : up == 0 ? -50 : 50 - (100 / (1 + up / down))
rsiMA       = ta.sma(rsi, rsiMALength)
rsiDiv      = (rsi - rsiMA) / (ta.stdev(rsi, rsiMALength) * rsiBollMult)
rsiBreak_up    = false
rsiBreak_down  = false

if rsiDiv <= -rsiDivBreakLow and rsiDiv >= -rsiDivBreakHigh and rsi <= -rsiRawBreak and showBreakout
    rsiBreak_down := true

if rsiDiv >= rsiDivBreakLow and rsiDiv <= rsiDivBreakHigh and rsi >= rsiRawBreak and showBreakout
    rsiBreak_up := true

rsiSignal = rsiBreak_down or rsiBreak_up

// === Indicator C MACD ===
[macdLine, signalLine, histLine] = ta.macd(close, fastLength, slowLength, signalLength)
diffHist = histLine - histLine[1]

macdCross_up = ta.crossover(macdLine, signalLine)
macdCross_down = ta.crossunder(macdLine, signalLine)
macdSignal = macdCross_down or macdCross_up

// === Indicator D SMI ===
highestHigh         = ta.highest(lengthK)
lowestLow           = ta.lowest(lengthK)
highestLowestRange  = highestHigh - lowestLow
relativeRange       = close - (highestHigh + lowestLow) / 2
smi                 = 200 * (emaEma(relativeRange, lengthD) / emaEma(highestLowestRange, lengthD))
smiEMA              = ta.ema(smi, lengthEMA)
smiDiff             = smi - smiEMA
smiDiv              = smiDiff - smiDiff[1]

smiBreak_up = ta.crossover(smi, smiEMA)
smiBreak_down = ta.crossunder(smi, smiEMA)
smiSignal = smiBreak_down or smiBreak_up

// ##########################
// === Observation Window ===
// ##########################
// Observation window
var int observationWindow = 0

if tdSignal
    observationWindow := 8
else if observationWindow > 0
    observationWindow := observationWindow - 1

// ##################
// === Conditions ===
// ##################

var bool LongEntry = false
var bool ShortEntry = false

if observationWindow > 0
    if (macdCross_up or smiBreak_up or rsiBreak_up) and td9_up
        LongEntry := true
        observationWindow := 0
    else if (macdCross_down or smiBreak_down or rsiBreak_down) and td9_down
        ShortEntry := true
        observationWindow := 0


// #######################
// === Risk Management ===
// #######################

per(pcnt) =>
    strategy.position_size != 0 ? math.round(pcnt / 100 * strategy.position_avg_price / syminfo.mintick) : float(na)

q1=input.int(title=" qty_percent1", defval=25, minval=1)
q2=input.int(title=" qty_percent2", defval=25, minval=1)
q3=input.int(title=" qty_percent3", defval=25, minval=1)



// === Stop-loss ===
stoploss = input.float(title="Stop Loss", defval = 0.02, minval = 0.01)
los = per(stoploss)

// === Take-profit ===
tp1=input.float(title=" Take profit1", defval=3, minval=0.01)
tp2=input.float(title=" Take profit2", defval=5, minval=0.01)
tp3=input.float(title=" Take profit3", defval=7, minval=0.01)
tp4=input.float(title=" Take profit4", defval=10, minval=0.01)



// #######################
// === Order Execution ===
// #######################

// === Execute long entry ===
if LongEntry 
    strategy.order(id = "Long", strategy.long, qty = _qty)
    strategy.exit("LongStop", "Long", loss = los)

if ShortEntry 
    strategy.order(id = "Short", strategy.short, qty = _qty)
    strategy.exit("ShortStop", "Short", loss = los)

if direction != direction[1]
    strategy.order(id = "Long", strategy.short, qty_percent = 100)

if direction != direction[1]
    strategy.order(id = "Short", strategy.long, qty_percent = 100)