Stratégie de tendance OTT à double voie

/*backtest
start: 2025-03-11 00:00:00
end: 2026-02-03 00:00:00
period: 1h
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"PAXG_USDT","balance":500000}]
*/

//@version=5
strategy("NEW TOTT Strategy", overlay=true)

// === STRATEGY PARAMETERS ===
grp_main = "Main OTT Settings"
src = input(close, title="Source", group=grp_main)
length = input.int(40, "OTT Period", minval=1, group=grp_main)
percent = input.float(1, "Optimization Constant", step=0.1, minval=0, group=grp_main)
coeff = input.float(0.001, "Twin OTT Coefficient", step=0.001, minval=0, group=grp_main)
mav = input.string(title="Moving Average Type", defval="VAR", options=["SMA", "EMA", "WMA", "TMA", "VAR", "WWMA", "ZLEMA", "TSF", "DEMA", "HMA", "ALMA", "LSMA", "RMA"], group=grp_main)

// === RISK MANAGEMENT (Optional) ===
grp_rm = "Risk Management (SL / TP / BE)"

use_sl = input.bool(false, "🔴 Enable Stop-Loss", group=grp_rm)
sl_pct = input.float(1.0, "Stop-Loss (%)", step=0.1, group=grp_rm)

use_be = input.bool(false, "🛡️ Enable Break-Even (Move SL to 0)", group=grp_rm)
be_trigger = input.float(1.5, "BE Activation at Profit (%)", step=0.1, group=grp_rm)

use_tp = input.bool(false, "🟢 Enable Take-Profit", group=grp_rm)
use_multi = input.bool(false, "Use 3 Tiers (Multi-TP)", group=grp_rm)

tp1_pct = input.float(1.0, "TP 1 (%)", step=0.1, group=grp_rm, inline="tp1")
tp1_qty = input.float(30.0, "Volume (%)", step=1.0, group=grp_rm, inline="tp1")

tp2_pct = input.float(2.0, "TP 2 (%)", step=0.1, group=grp_rm, inline="tp2")
tp2_qty = input.float(30.0, "Volume (%)", step=1.0, group=grp_rm, inline="tp2")

tp3_pct = input.float(3.0, "TP 3 (%)", step=0.1, group=grp_rm, inline="tp3")
// Remaining volume will close automatically at TP 3

// === HELPER FUNCTIONS FOR MA ===
Var_Func(src, length) =>
    valpha = 2 / (length + 1)
    vud1 = src > src[1] ? src - src[1] : 0
    vdd1 = src < src[1] ? src[1] - src : 0
    vUD = math.sum(vud1, 9)
    vDD = math.sum(vdd1, 9)
    vCMO = nz((vUD - vDD) / (vUD + vDD))
    VAR = 0.0
    VAR := nz(valpha * math.abs(vCMO) * src) + (1 - valpha * math.abs(vCMO)) * nz(VAR[1])
    VAR

Wwma_Func(src, length) =>
    wwalpha = 1 / length
    WWMA = 0.0
    WWMA := wwalpha * src + (1 - wwalpha) * nz(WWMA[1])
    WWMA

Zlema_Func(src, length) =>
    zxLag = length / 2 == math.round(length / 2) ? length / 2 : (length - 1) / 2
    zxEMAData = src + src - src[zxLag]
    ta.ema(zxEMAData, length)

Tsf_Func(src, length) =>
    lrc = ta.linreg(src, length, 0)
    lrc1 = ta.linreg(src, length, 1)
    lrs = lrc - lrc1
    ta.linreg(src, length, 0) + lrs

DEMA_Func(src, length) =>
    ema1 = ta.ema(src, length)
    ema2 = ta.ema(ema1, length)
    2 * ema1 - ema2

HMA_Func(src, length) =>
    wma1 = ta.wma(src, length / 2)
    wma2 = ta.wma(src, length)
    ta.wma(2 * wma1 - wma2, math.round(math.sqrt(length)))

getMA(src, length, type) =>
    switch type
        "SMA"   => ta.sma(src, length)
        "EMA"   => ta.ema(src, length)
        "WMA"   => ta.wma(src, length)
        "TMA"   => ta.sma(ta.sma(src, math.ceil(length / 2)), math.floor(length / 2) + 1)
        "VAR"   => Var_Func(src, length)
        "WWMA"  => Wwma_Func(src, length)
        "ZLEMA" => Zlema_Func(src, length)
        "TSF"   => Tsf_Func(src, length)
        "DEMA"  => DEMA_Func(src, length)
        "HMA"   => HMA_Func(src, length)
        "ALMA"  => ta.alma(src, length, 0.85, 6)
        "LSMA"  => ta.linreg(src, length, 0)
        "RMA"   => ta.rma(src, length)
        => ta.sma(src, length) // Default

MAvg = getMA(src, length, mav)

// === OTT LOGIC ===
fark = MAvg * percent * 0.01
longStop = MAvg - fark
longStopPrev = nz(longStop[1], longStop)
longStop := MAvg > longStopPrev ? math.max(longStop, longStopPrev) : longStop
shortStop = MAvg + fark
shortStopPrev = nz(shortStop[1], shortStop)
shortStop := MAvg < shortStopPrev ? math.min(shortStop, shortStopPrev) : shortStop
dir = 1
dir := nz(dir[1], dir)
dir := dir == -1 and MAvg > shortStopPrev ? 1 : dir == 1 and MAvg < longStopPrev ? -1 : dir
MT = dir == 1 ? longStop : shortStop
OTT = MAvg > MT ? MT * (200 + percent) / 200 : MT * (200 - percent) / 200
OTTup = OTT * (1 + coeff)
OTTdn = OTT * (1 - coeff)

// === SIGNALS ===
buySignal = ta.crossover(MAvg, OTTup)
sellSignal = ta.crossunder(MAvg, OTTdn)

// === POSITION ENTRY ===
if buySignal
    strategy.entry("Long", strategy.long)
if sellSignal
    strategy.entry("Short", strategy.short)

// === BREAK-EVEN LOGIC (CALCULATE PRICE) ===
var float entry_price = 0.0
var bool be_long_active = false
var bool be_short_active = false

if strategy.position_size > 0
    entry_price := strategy.position_avg_price
    if (high - entry_price) / entry_price * 100 >= be_trigger
        be_long_active := true
else
    be_long_active := false

if strategy.position_size < 0
    entry_price := strategy.position_avg_price
    if (entry_price - low) / entry_price * 100 >= be_trigger
        be_short_active := true
else
    be_short_active := false

// === CALCULATE SL AND TP LEVELS ===
long_sl = use_sl ? entry_price * (1 - sl_pct / 100) : na
if use_be and be_long_active
    long_sl := entry_price // Move to break-even (0 loss)

short_sl = use_sl ? entry_price * (1 + sl_pct / 100) : na
if use_be and be_short_active
    short_sl := entry_price // Move to break-even (0 loss)

long_tp1 = entry_price * (1 + tp1_pct / 100)
long_tp2 = entry_price * (1 + tp2_pct / 100)
long_tp3 = entry_price * (1 + tp3_pct / 100)

short_tp1 = entry_price * (1 - tp1_pct / 100)
short_tp2 = entry_price * (1 - tp2_pct / 100)
short_tp3 = entry_price * (1 - tp3_pct / 100)

// === POSITION EXIT (RISK MANAGEMENT) ===
if strategy.position_size > 0
    if use_tp and use_multi
        strategy.exit("TP1", "Long", qty_percent=tp1_qty, limit=long_tp1, stop=long_sl)
        strategy.exit("TP2", "Long", qty_percent=tp2_qty, limit=long_tp2, stop=long_sl)
        strategy.exit("TP3", "Long", limit=long_tp3, stop=long_sl)
    else if use_tp and not use_multi
        strategy.exit("TP/SL", "Long", limit=long_tp1, stop=long_sl)
    else if use_sl
        strategy.exit("SL", "Long", stop=long_sl)

if strategy.position_size < 0
    if use_tp and use_multi
        strategy.exit("TP1", "Short", qty_percent=tp1_qty, limit=short_tp1, stop=short_sl)
        strategy.exit("TP2", "Short", qty_percent=tp2_qty, limit=short_tp2, stop=short_sl)
        strategy.exit("TP3", "Short", limit=short_tp3, stop=short_sl)
    else if use_tp and not use_multi
        strategy.exit("TP/SL", "Short", limit=short_tp1, stop=short_sl)
    else if use_sl
        strategy.exit("SL", "Short", stop=short_sl)

// === CLOSE ON REVERSAL SIGNAL (ALWAYS ACTIVE) ===
if strategy.position_size > 0 and sellSignal
    strategy.close("Long", comment="Reverse")

if strategy.position_size < 0 and buySignal
    strategy.close("Short", comment="Reverse")