Strategi Pemulihan EMA Multi-Timeframe Elite

Tanggal Pembuatan: 2025-12-29 16:40:54 Akhirnya memodifikasi: 2025-12-29 16:40:54

menyalin: 9 Jumlah klik: 207

ianzeng123

fokus pada Pesan pribadi

fokus pada

413

Pengikut

Strategi Pemulihan EMA Multi-Timeframe Elite

EMA, MTF, ADX, ATR

Ini bukan strategi EMA biasa, ini adalah sistem sniper presisi multi-frame

Jangan sampai mata Anda terpesona oleh garis EMA yang penuh. Logika inti dari strategi EMA Reclaim dari Elite MTF ini sederhana dan kasar: menunggu harga mundur dari sistem EMA rata-rata, dan kemudian masuk dengan tepat saat mengambil kembali rata-rata kunci.

Data retrospektif menunjukkan bahwa saat berjalan pada siklus 6 menit, strategi ini secara efektif memfilter sejumlah besar sinyal penembusan palsu melalui persyaratan stacking EMA yang ketat ((5>10>20>50) dan mekanisme konfirmasi retrospektif. Kuncinya adalah bahwa itu tidak terlalu bodoh, tetapi mengharuskan harga harus kembali ke garis EMA yang ditentukan dan kemudian kembali untuk masuk.

Tiga set konfigurasi preset, optimasi kekerasan untuk pasar yang berbeda

Strategi ini menawarkan tiga jenis prediksi: Elite, Balanced, dan Aggressive, yang masing-masing dioptimalkan secara mendalam untuk empat pasar: Forex, XAUUSD, Crypto, dan Indices. Ini bukan parameter untuk bertepuk tangan, tetapi penyesuaian presisi berdasarkan banyak data pengembalian.

Sebagai contoh, pasar Forex:

Mode Elite: EMA20-50 selisih harga minimal 0,06%, ADX≥14, ATR stop loss 1,8 kali lipat, RRR 2:1
Balanced Mode: Relaksasi hingga selisih harga 0.045%, ADX≥12, stop loss 1,6 kali lipat, target 1.75:1
Modus agresif: lebih longgar hingga 0,03%, ADX≥10, stop loss 1,4 kali lipat, target 1,5:1

XAUUSD memiliki parameter yang lebih ketat, Mode Elite membutuhkan selisih EMA sebesar 0,09%, ADX≥16, ini karena sifat fluktuasi emas membutuhkan konfirmasi tren yang lebih kuat. Pasar Crypto relatif longgar, tetapi ATR stop loss multiplier meningkat menjadi 2,2 kali lipat, sesuai dengan lingkungan yang sangat fluktuatif untuk cryptocurrency.

Filter multi-frame adalah daya saing inti dari sistem ini.

Strategi ini memonitor status alignment EMA dari garis harian dan 1 jam secara bersamaan, dan hanya mengizinkan sinyal masuk di tingkat 6 menit ketika tren dalam kerangka waktu yang tinggi jelas. Desain ini secara langsung mengatasi masalah terbesar perdagangan periode kecil yang terganggu oleh kebisingan frekuensi tinggi.

HTF Alignment Mode menawarkan empat pilihan: Off, Sunline Only, Only 1 Hour, Sunline + 1 Hour. Dalam pertempuran nyata disarankan untuk menggunakan mode “Sunline + 1 Hour”, meskipun frekuensi sinyal akan berkurang sekitar 30%, tetapi keuntungan setelah kemenangan dan penyesuaian risiko meningkat secara signifikan.

Strategi ini secara otomatis memblokir sinyal masuk baru ketika EMA dalam kerangka waktu tinggi muncul dalam urutan yang kacau. Desain ini bekerja sangat baik di pasar yang bergoyang. Retrospektif menunjukkan bahwa penarikan maksimum menurun sekitar 25% setelah penyaringan HTF ditambahkan.

ADX+ATR Dual Filter, Menolak Pertarungan di Lumpur

Strategi ini mengharuskan ADX mencapai nilai terendah yang memungkinkan perdagangan, yang memastikan bahwa hanya beroperasi dalam lingkungan dengan tren yang jelas. ATR juga harus melebihi persentase tertentu dari harga, untuk menghindari sinyal yang tidak valid selama fluktuasi yang sangat rendah.

Kombinasi dari kedua filter ini sangat efektif: strategi berhenti berdagang sepenuhnya ketika ADX <12 dan ATR ,1%. Data historis menunjukkan bahwa desain “lebih baik melewatkan, tidak ada yang salah” ini membuat strategi mengurangi lebih dari 70% dari transaksi yang tidak valid selama penyusunan horizontal.

Desain tiga segmen logis masuk dengan standar ketat untuk setiap langkah

Ada tiga tahapan untuk masuk ke dalam strategi:

Tahap Pullback: Harga harus menyentuh garis EMA yang ditentukan (Ema10 default)
Tahap Reklamasi: Harga mengambil kembali garis EMA, dengan opsi konfirmasi close out atau konfirmasi garis K berikutnya
Tahap RetestDalam 18 garis K yang direbut kembali, harga kembali menguji garis EMA tetapi tidak turun

Hal yang menarik dari desain ini adalah bahwa ia meminta harga untuk menunjukkan pola “pengunduran diri-pengembalian-konfirmasi” yang jelas, bukan hanya melintasi garis rata-rata. Retest menunjukkan bahwa meskipun jumlah sinyal berkurang sekitar 20% setelah memasukkan persyaratan Retest, rata-rata keuntungan per transaksi meningkat sebesar 35%.

ATR: Sistem Stop Loss Dinamis, Manajemen Risiko Menjadi Cerdas

Strategi menggunakan 1,8 kali ATR sebagai jarak stop loss (Elite Mode), yang lebih dapat beradaptasi dengan perubahan pergerakan pasar daripada stop loss fixed point. Ketika ATR meluas, jarak stop loss secara otomatis melonggarkan; ketika turun naik berkurang, stop loss mengencangkan, memaksimalkan laba setelah risiko disesuaikan.

Fitur-fitur yang lebih canggih meliputi:

Pendapatan 1R setelah bergerak stop loss ke titik keseimbangan untung rugi
Setelah 1R keuntungan, ATR memulai tracking stop loss
Rasio risiko-pengembalian dinamis disesuaikan dengan 1.5:1 menjadi 2:1

Data lapangan menunjukkan bahwa penggunaan stop loss dinamis ATR lebih baik dari stop loss tetap sekitar 15%, terutama dalam lingkungan pasar dengan perubahan volatilitas yang tinggi.

Saran Resikonya: Ini Bukan Piala Suci, Perlu Berpikir Rasional

Strategi ini berkinerja baik di pasar dengan tren yang jelas, tetapi dapat menghasilkan kerugian berturut-turut di pasar yang bergolak. Rekaman historis menunjukkan bahwa kerugian berturut-turut maksimum dapat mencapai 5-7 transaksi, yang mengharuskan pedagang untuk memiliki ketahanan psikologis dan kemampuan pengelolaan uang yang cukup.

Periode kinerja terbaik dari strategi ini adalah awal dan pertengahan awal tren, yang rentan terhadap sinyal palsu di akhir tren dan di dekat titik balik. Analisis teknis yang disarankan untuk digabungkan dengan kerangka waktu yang lebih tinggi, untuk menghindari mengikuti sinyal secara membabi buta di dekat resistance support yang jelas.

Pertunjukan retrospektif masa lalu tidak mewakili pendapatan masa depan, perubahan lingkungan pasar dapat memengaruhi efektivitas strategi. Disarankan untuk menjalankan setidaknya 3 bulan di lingkungan simulasi, dan setelah mengetahui sepenuhnya karakteristik strategi, maka berinvestasi dalam modal nyata.

Kode Sumber Strategi

/*backtest
start: 2024-12-29 00:00:00
end: 2025-12-28 00:00:00
period: 1h
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT"}]
*/

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

//@version=6
strategy(
     "Elite MTF EMA Reclaim — 6m (1:1 Signals + Full Presets + Global Signal Toggle) [NA-Safe]",
     overlay=true,
     pyramiding=0,
     initial_capital=10000,
     commission_type=strategy.commission.percent,
     commission_value=0.01,
     slippage=1,
     process_orders_on_close=true,
     calc_on_order_fills=true,
     max_labels_count=200,
     max_lines_count=200
)

//──────────────────────────────────────────────────────────────────────────────
// MODE + GLOBAL SIGNAL DISPLAY
//──────────────────────────────────────────────────────────────────────────────
mode = input.string("Strategy (Backtest)", "Mode", options=["Strategy (Backtest)","Indicator (Signals Only)"])
allowOrders = (mode == "Strategy (Backtest)")
showSignals = input.bool(true, "Show Signals (All Modes)")

//──────────────────────────────────────────────────────────────────────────────
// MARKET + PRESET
//──────────────────────────────────────────────────────────────────────────────
market = input.string("Forex", "Market", options=["Forex","XAUUSD","Crypto","Indices"])
preset = input.string("Elite", "Preset", options=["Elite","Balanced","Aggressive"])

// HTF selection (optimized + toggle)
tfH1  = input.string("60", "HTF2 TF (minutes)")
tfD   = input.string("D",  "HTF1 TF")
htfMode = input.string("D + H1", "HTF Alignment Mode", options=["Off","D only","H1 only","D + H1"])

// Base behavior toggles
strictStackIn   = input.bool(true, "Base: Require STRICT EMA stack (5>10>20>50)")
requireRetestIn = input.bool(true, "Base: Require Retest")

// Optional looseners
looserLTF          = input.bool(false, "Looser LTF Mode (more 6m signals)")
allowReclaimNoPull = input.bool(false, "Allow reclaim without prior Pullback state")

// Dynamic default handled via "Preset" option:
reclaimTimingDefault = input.string("Preset", "Reclaim Timing Default",
     options=["Preset","Reclaim close","Next bar confirmation"])

// EMAs
len5  = input.int(5,  "EMA 5",  minval=1)
len10 = input.int(10, "EMA 10", minval=1)
len20 = input.int(20, "EMA 20", minval=1)
len50 = input.int(50, "EMA 50", minval=1)

// Base thresholds (override knobs)
curvMinIn        = input.float(0.0, "Base: Min Curvature Threshold", step=0.00001)
minSpreadIn      = input.float(0.0006, "Base: Min EMA20-50 Spread (% of price)", step=0.0001)
adxLen           = input.int(14, "ADX Length", minval=1)
minAdxIn         = input.float(14.0, "Base: Min ADX", step=0.5)
atrLen           = input.int(14, "ATR Length", minval=1)
minAtrPctIn      = input.float(0.0010, "Base: Min ATR (% of price)", step=0.0001)
crossLookbackIn  = input.int(30, "Base: Block if EMA20/50 crossed within N bars", minval=1)

// Base entry mechanics (override knobs)
pullbackToIn      = input.string("EMA10", "Base: Pullback To", options=["EMA5","EMA10","EMA20"])
reclaimOnIn       = input.string("EMA10", "Base: Reclaim On", options=["EMA5","EMA10","EMA20"])
retestOnIn        = input.string("EMA10", "Base: Retest On", options=["EMA5","EMA10","EMA20"])
maxBarsToRetestIn = input.int(18, "Base: Max bars allowed for retest after reclaim", minval=1)

// Visuals
showEma     = input.bool(true, "Show EMAs")
showBlocks  = input.bool(true, "Show BLOCK markers")
useChopKill = input.bool(true, "Kill Chop")

//──────────────────────────────────────────────────────────────────────────────
// ATR STOP + RR TARGETS
//──────────────────────────────────────────────────────────────────────────────
riskGroup = "Risk (ATR Stops / RR Targets)"
useAtrRisk     = input.bool(true, "Use ATR Stop + RR Target", group=riskGroup)
atrStopMultIn  = input.float(1.8, "ATR Stop Multiplier", step=0.1, group=riskGroup)
rrTargetIn     = input.float(2.0, "RR Target (TP = risk*RR)", step=0.25, group=riskGroup)
useBreakeven   = input.bool(false, "Move stop to breakeven at +1R", group=riskGroup)
useTrailAfterR = input.bool(false, "Trail stop after +1R (ATR)", group=riskGroup)
trailAtrMult   = input.float(1.0, "Trail ATR Multiplier", step=0.1, group=riskGroup)

//──────────────────────────────────────────────────────────────────────────────
// EFFECTIVE PARAMS (start from base, then overwrite by market+preset)
//──────────────────────────────────────────────────────────────────────────────
float minSpread       = minSpreadIn
float minAtrPct       = minAtrPctIn
float minAdx          = minAdxIn
float curvMin         = curvMinIn
int   crossLookback   = crossLookbackIn
int   maxBarsToRetest = maxBarsToRetestIn
bool  strictStack     = strictStackIn
bool  requireRetest   = requireRetestIn
string pullbackTo     = pullbackToIn
string reclaimOn      = reclaimOnIn
string retestOn       = retestOnIn

float atrStopMult = atrStopMultIn
float rrTarget    = rrTargetIn

//──────────────────────────────────────────────────────────────────────────────
// PRESET RECLAIM TIMING (best defaults per market/preset)
//──────────────────────────────────────────────────────────────────────────────
string presetReclaimTiming = "Reclaim close"
if market == "Forex"
    presetReclaimTiming := (preset == "Elite") ? "Next bar confirmation" : "Reclaim close"
else if market == "XAUUSD"
    presetReclaimTiming := (preset == "Aggressive") ? "Reclaim close" : "Next bar confirmation"
else if market == "Crypto"
    presetReclaimTiming := "Reclaim close"
else
    presetReclaimTiming := (preset == "Elite") ? "Next bar confirmation" : "Reclaim close"

string reclaimEntryTiming =
     reclaimTimingDefault == "Preset" ? presetReclaimTiming : reclaimTimingDefault

//──────────────────────────────────────────────────────────────────────────────
// FULL MARKET + PRESET OVERWRITE (matches your indicator presets)
//──────────────────────────────────────────────────────────────────────────────
if market == "Forex"
    if preset == "Elite"
        minSpread := 0.0006
        minAtrPct := 0.0010
        minAdx := 14.0
        curvMin := 0.0
        crossLookback := 30
        maxBarsToRetest := 18
        strictStack := true
        requireRetest := true
        pullbackTo := "EMA10"
        reclaimOn  := "EMA10"
        retestOn   := "EMA10"
        atrStopMult := 1.8
        rrTarget := 2.0
    else if preset == "Balanced"
        minSpread := 0.00045
        minAtrPct := 0.0008
        minAdx := 12.0
        curvMin := 0.0
        crossLookback := 25
        maxBarsToRetest := 20
        strictStack := true
        requireRetest := true
        pullbackTo := "EMA10"
        reclaimOn  := "EMA10"
        retestOn   := "EMA10"
        atrStopMult := 1.6
        rrTarget := 1.75
    else
        minSpread := 0.0003
        minAtrPct := 0.0006
        minAdx := 10.0
        curvMin := 0.0
        crossLookback := 20
        maxBarsToRetest := 24
        strictStack := false
        requireRetest := false
        pullbackTo := "EMA20"
        reclaimOn  := "EMA20"
        retestOn   := "EMA20"
        atrStopMult := 1.4
        rrTarget := 1.5

else if market == "XAUUSD"
    if preset == "Elite"
        minSpread := 0.0009
        minAtrPct := 0.0013
        minAdx := 16.0
        curvMin := 0.0
        crossLookback := 40
        maxBarsToRetest := 18
        strictStack := true
        requireRetest := true
        pullbackTo := "EMA10"
        reclaimOn  := "EMA10"
        retestOn   := "EMA10"
        atrStopMult := 2.0
        rrTarget := 2.0
    else if preset == "Balanced"
        minSpread := 0.0007
        minAtrPct := 0.0011
        minAdx := 14.0
        curvMin := 0.0
        crossLookback := 35
        maxBarsToRetest := 22
        strictStack := true
        requireRetest := true
        pullbackTo := "EMA20"
        reclaimOn  := "EMA10"
        retestOn   := "EMA20"
        atrStopMult := 1.8
        rrTarget := 1.75
    else
        minSpread := 0.0005
        minAtrPct := 0.0009
        minAdx := 12.0
        curvMin := 0.0
        crossLookback := 28
        maxBarsToRetest := 26
        strictStack := false
        requireRetest := false
        pullbackTo := "EMA20"
        reclaimOn  := "EMA20"
        retestOn   := "EMA20"
        atrStopMult := 1.6
        rrTarget := 1.5

else if market == "Crypto"
    if preset == "Elite"
        minSpread := 0.0008
        minAtrPct := 0.0015
        minAdx := 14.0
        curvMin := 0.0
        crossLookback := 28
        maxBarsToRetest := 18
        strictStack := true
        requireRetest := true
        pullbackTo := "EMA20"
        reclaimOn  := "EMA10"
        retestOn   := "EMA20"
        atrStopMult := 2.2
        rrTarget := 2.0
    else if preset == "Balanced"
        minSpread := 0.0006
        minAtrPct := 0.0012
        minAdx := 12.0
        curvMin := 0.0
        crossLookback := 24
        maxBarsToRetest := 22
        strictStack := true
        requireRetest := true
        pullbackTo := "EMA20"
        reclaimOn  := "EMA20"
        retestOn   := "EMA20"
        atrStopMult := 2.0
        rrTarget := 1.75
    else
        minSpread := 0.00045
        minAtrPct := 0.0010
        minAdx := 10.0
        curvMin := 0.0
        crossLookback := 18
        maxBarsToRetest := 26
        strictStack := false
        requireRetest := false
        pullbackTo := "EMA20"
        reclaimOn  := "EMA20"
        retestOn   := "EMA20"
        atrStopMult := 1.8
        rrTarget := 1.5

else
    if preset == "Elite"
        minSpread := 0.0007
        minAtrPct := 0.0010
        minAdx := 14.0
        curvMin := 0.0
        crossLookback := 30
        maxBarsToRetest := 18
        strictStack := true
        requireRetest := true
        pullbackTo := "EMA10"
        reclaimOn  := "EMA10"
        retestOn   := "EMA10"
        atrStopMult := 1.8
        rrTarget := 2.0
    else if preset == "Balanced"
        minSpread := 0.00055
        minAtrPct := 0.00085
        minAdx := 12.0
        curvMin := 0.0
        crossLookback := 26
        maxBarsToRetest := 22
        strictStack := true
        requireRetest := true
        pullbackTo := "EMA20"
        reclaimOn  := "EMA10"
        retestOn   := "EMA20"
        atrStopMult := 1.6
        rrTarget := 1.75
    else
        minSpread := 0.0004
        minAtrPct := 0.0007
        minAdx := 10.0
        curvMin := 0.0
        crossLookback := 20
        maxBarsToRetest := 26
        strictStack := false
        requireRetest := false
        pullbackTo := "EMA20"
        reclaimOn  := "EMA20"
        retestOn   := "EMA20"
        atrStopMult := 1.4
        rrTarget := 1.5

if looserLTF
    strictStack := false
    requireRetest := false
    pullbackTo := "EMA20"
    reclaimOn  := "EMA20"
    retestOn   := "EMA20"

//──────────────────────────────────────────────────────────────────────────────
// WARMUP GATING (NA-safety + reliable backtest on 6m)
//──────────────────────────────────────────────────────────────────────────────
warmupBars = math.max(math.max(len50, atrLen), adxLen) + 10
ready = (bar_index >= warmupBars)

//──────────────────────────────────────────────────────────────────────────────
// HELPERS (NA-safe)
//──────────────────────────────────────────────────────────────────────────────
f_pick(_e5,_e10,_e20,_c)=>
    float o = _e20
    if _c == "EMA5"
        o := _e5
    else if _c == "EMA10"
        o := _e10
    o

f_stackL(_e5,_e10,_e20,_e50,_strict)=>
    _strict ? (_e5 > _e10 and _e10 > _e20 and _e20 > _e50) : (_e20 > _e50)

f_stackS(_e5,_e10,_e20,_e50,_strict)=>
    _strict ? (_e5 < _e10 and _e10 < _e20 and _e20 < _e50) : (_e20 < _e50)

f_curv(_x)=>
    float c = 0.0
    if bar_index >= 2 and not na(_x) and not na(_x[1]) and not na(_x[2])
        float slope0 = _x - _x[1]
        float slope1 = _x[1] - _x[2]
        c := (slope0 - slope1)
    c

f_adx(_len)=>
    float out = na
    if bar_index >= 2
        float upMove   = high - high[1]
        float downMove = low[1] - low
        float plusDM  = (upMove > downMove and upMove > 0) ? upMove : 0.0
        float minusDM = (downMove > upMove and downMove > 0) ? downMove : 0.0

        float tr1 = high - low
        float tr2 = math.abs(high - close[1])
        float tr3 = math.abs(low  - close[1])
        float tr  = math.max(tr1, math.max(tr2, tr3))

        float trur = ta.rma(tr, _len)
        float plusDI  = trur == 0 ? 0.0 : 100.0 * ta.rma(plusDM, _len) / trur
        float minusDI = trur == 0 ? 0.0 : 100.0 * ta.rma(minusDM, _len) / trur

        float denom = plusDI + minusDI
        float dx = denom == 0 ? 0.0 : (100.0 * math.abs(plusDI - minusDI) / denom)
        out := ta.rma(dx, _len)
    out

//──────────────────────────────────────────────────────────────────────────────
// LOCAL TF
//──────────────────────────────────────────────────────────────────────────────
ema5  = ta.ema(close,len5)
ema10 = ta.ema(close,len10)
ema20 = ta.ema(close,len20)
ema50 = ta.ema(close,len50)

s20 = bar_index >= 1 ? (ema20 - ema20[1]) : 0.0
s50 = bar_index >= 1 ? (ema50 - ema50[1]) : 0.0
c20 = f_curv(ema20)
c50 = f_curv(ema50)

atr = ta.atr(atrLen)
adx = f_adx(adxLen)

spreadPct = close != 0 ? math.abs(ema20-ema50)/close : 0.0
atrPct    = close != 0 ? atr/close : 0.0
recentX   = ta.barssince(ta.cross(ema20,ema50))

// Treat "not ready" / "na ADX" as chop (safe, prevents early weirdness)
isChop = useChopKill and (
    (not ready) or
    spreadPct < minSpread or
    (na(adx) or adx < minAdx) or
    atrPct < minAtrPct or
    (recentX >= 0 and recentX < crossLookback)
)

localLongOk  = ready and f_stackL(ema5,ema10,ema20,ema50,strictStack) and (s20 > 0 and s50 > 0) and (c20 > curvMin and c50 > curvMin)
localShortOk = ready and f_stackS(ema5,ema10,ema20,ema50,strictStack) and (s20 < 0 and s50 < 0) and (c20 < -curvMin and c50 < -curvMin)

//──────────────────────────────────────────────────────────────────────────────
// HTF ALIGNMENT
//──────────────────────────────────────────────────────────────────────────────
sec(_tf, _expr)=>
    request.security(syminfo.tickerid, _tf, _expr, barmerge.gaps_off, barmerge.lookahead_off)

d20 = (htfMode == "D only" or htfMode == "D + H1") ? sec(tfD, ta.ema(close,len20)) : na
d50 = (htfMode == "D only" or htfMode == "D + H1") ? sec(tfD, ta.ema(close,len50)) : na
h20 = (htfMode == "H1 only" or htfMode == "D + H1") ? sec(tfH1, ta.ema(close,len20)) : na
h50 = (htfMode == "H1 only" or htfMode == "D + H1") ? sec(tfH1, ta.ema(close,len50)) : na

dOkLong  = (htfMode == "D only" or htfMode == "D + H1") ? (not na(d20) and not na(d50) and d20 > d50) : true
dOkShort = (htfMode == "D only" or htfMode == "D + H1") ? (not na(d20) and not na(d50) and d20 < d50) : true
hOkLong  = (htfMode == "H1 only" or htfMode == "D + H1") ? (not na(h20) and not na(h50) and h20 > h50) : true
hOkShort = (htfMode == "H1 only" or htfMode == "D + H1") ? (not na(h20) and not na(h50) and h20 < h50) : true

htfLong  = (htfMode == "Off") ? true : (dOkLong and hOkLong)
htfShort = (htfMode == "Off") ? true : (dOkShort and hOkShort)

//──────────────────────────────────────────────────────────────────────────────
// ENTRY STATE (Pullback → Reclaim → Retest) — unchanged logic (1:1)
//──────────────────────────────────────────────────────────────────────────────
pullLvl   = f_pick(ema5,ema10,ema20,pullbackTo)
reclLvl   = f_pick(ema5,ema10,ema20,reclaimOn)
retestLvl = f_pick(ema5,ema10,ema20,retestOn)

var int lState=0
var int sState=0
var int lBar=na
var int sBar=na

allow = ready and (not isChop)

lPull = allow and htfLong  and localLongOk  and (low <= pullLvl)  and (close > ema50)
sPull = allow and htfShort and localShortOk and (high >= pullLvl) and (close < ema50)

prevClose = bar_index >= 1 ? close[1] : na
lRecl = allow and htfLong  and localLongOk  and (close > reclLvl) and (not na(prevClose) and prevClose <= reclLvl)
sRecl = allow and htfShort and localShortOk and (close < reclLvl) and (not na(prevClose) and prevClose >= reclLvl)

lRet  = allow and htfLong  and localLongOk  and (low <= retestLvl)  and (close > retestLvl)
sRet  = allow and htfShort and localShortOk and (high >= retestLvl) and (close < retestLvl)

if lState==0 and lPull
    lState:=1
if sState==0 and sPull
    sState:=1

if allowReclaimNoPull
    if lState==0 and lRecl
        lState := 2
        lBar := bar_index
    if sState==0 and sRecl
        sState := 2
        sBar := bar_index

if lState==1 and lRecl
    lState:=2
    lBar:=bar_index
if sState==1 and sRecl
    sState:=2
    sBar:=bar_index

if lState==2 and not na(lBar) and (bar_index - lBar > maxBarsToRetest)
    lState:=0
if sState==2 and not na(sBar) and (bar_index - sBar > maxBarsToRetest)
    sState:=0

bool longReclaimTrigger  = false
bool shortReclaimTrigger = false
if reclaimEntryTiming == "Reclaim close"
    longReclaimTrigger  := lRecl
    shortReclaimTrigger := sRecl
else
    longReclaimTrigger  := (bar_index >= 1 ? lRecl[1] : false) and (close > reclLvl)
    shortReclaimTrigger := (bar_index >= 1 ? sRecl[1] : false) and (close < reclLvl)

bool longEntry  = false
bool shortEntry = false
if barstate.isconfirmed
    if allow and htfLong and localLongOk
        longEntry := requireRetest ? (lState==2 and lRet) : longReclaimTrigger
    if allow and htfShort and localShortOk
        shortEntry := requireRetest ? (sState==2 and sRet) : shortReclaimTrigger

if longEntry
    lState := 0
if shortEntry
    sState := 0

//──────────────────────────────────────────────────────────────────────────────
// ATR RISK ENGINE
//──────────────────────────────────────────────────────────────────────────────
var float longStop = na
var float longTp   = na
var float longR    = na
var float shortStop = na
var float shortTp   = na
var float shortR    = na

if allowOrders and longEntry
    strategy.entry("LONG", strategy.long)
    if useAtrRisk
        float risk = atr * atrStopMult
        longStop := close - risk
        longTp   := close + (risk * rrTarget)
        longR    := risk

if allowOrders and shortEntry
    strategy.entry("SHORT", strategy.short)
    if useAtrRisk
        float risk = atr * atrStopMult
        shortStop := close + risk
        shortTp   := close - (risk * rrTarget)
        shortR    := risk

inLong  = strategy.position_size > 0
inShort = strategy.position_size < 0
avg     = strategy.position_avg_price

if allowOrders and useAtrRisk
    if inLong and not na(longStop) and not na(longTp)
        float stopL = longStop
        if useBreakeven and not na(longR) and close >= avg + longR
            stopL := math.max(stopL, avg)
        if useTrailAfterR and not na(longR) and close >= avg + longR
            stopL := math.max(stopL, close - (atr * trailAtrMult))
        strategy.exit("L-Exit", from_entry="LONG", stop=stopL, limit=longTp)

    if inShort and not na(shortStop) and not na(shortTp)
        float stopS = shortStop
        if useBreakeven and not na(shortR) and close <= avg - shortR
            stopS := math.min(stopS, avg)
        if useTrailAfterR and not na(shortR) and close <= avg - shortR
            stopS := math.min(stopS, close + (atr * trailAtrMult))
        strategy.exit("S-Exit", from_entry="SHORT", stop=stopS, limit=shortTp)

if strategy.position_size == 0
    longStop := na
    longTp := na
    longR := na
    shortStop := na
    shortTp := na
    shortR := na

//──────────────────────────────────────────────────────────────────────────────
// PLOTS + BLOCKS + ALERTS
//──────────────────────────────────────────────────────────────────────────────
plot(ema5,  "EMA 5",  display = showEma ? display.all : display.none)
plot(ema10, "EMA 10", display = showEma ? display.all : display.none)
plot(ema20, "EMA 20", display = showEma ? display.all : display.none)
plot(ema50, "EMA 50", display = showEma ? display.all : display.none)

plotshape(showSignals and longEntry,  title="Long",  style=shape.triangleup,   location=location.belowbar, size=size.tiny, text="LONG")
plotshape(showSignals and shortEntry, title="Short", style=shape.triangledown, location=location.abovebar, size=size.tiny, text="SHORT")

showRiskLines = allowOrders and useAtrRisk
plot(showRiskLines and inLong  ? longStop  : na, "Long Stop",  style=plot.style_linebr)
plot(showRiskLines and inLong  ? longTp    : na, "Long TP",    style=plot.style_linebr)
plot(showRiskLines and inShort ? shortStop : na, "Short Stop", style=plot.style_linebr)
plot(showRiskLines and inShort ? shortTp   : na, "Short TP",   style=plot.style_linebr)

blockChop = showBlocks and isChop
blockHtf  = showBlocks and ready and (not isChop) and (htfMode != "Off") and (not htfLong and not htfShort)

plotshape(showBlocks and blockChop, title="Blocked: Chop", style=shape.circle, location=location.top, size=size.tiny, text="CHOP")
plotshape(showBlocks and blockHtf,  title="Blocked: HTF",  style=shape.circle, location=location.top, size=size.tiny, text="HTF")

alertcondition(longEntry,  "Long Entry",  "Elite EMA Reclaim LONG on {{ticker}}")
alertcondition(shortEntry, "Short Entry", "Elite EMA Reclaim SHORT on {{ticker}}")

Forums

PINE Language FAQ Summary MyLanguage Web3 About Us

Product

Robot Strategy Node Platforms Tickets

API

Syntax guide User guide Trading api Blockchain Indicator