Elite Multi-Timeframe EMA Recapture Strategy
ianzeng123
EMA, MTF, ADX, ATR
Das ist keine gewöhnliche EMA-Strategie, sondern ein Präzisionsscharfschützen-System für mehrere Zeitrahmen.
Die Kernlogik dieser Elite MTF EMA Reclaim Strategie ist einfach und grob: Sie warten, bis der Preis sich vom EMA-Gleichgewicht zurückzieht, um dann den Schlüssel-Gleichgewicht zurückzuerobern. Aber der Teufel spielt in den Details mit mehreren Zeitrahmen-Filtern, ADX-Bestätigung der Trendstärke, ATR-Dynamik und macht einfache Gleichgewichtshandlungen aus.
Die Rücklaufdaten zeigen, dass die Strategie, wenn sie auf einem 6-Minuten-Zyklus läuft, eine große Anzahl von falschen Durchbruchsignalen durch strenge EMA-Stack-Anforderungen ((5>10>20>50) und Rücklaufbestätigungsmechanismen effektiv filtert. Die Schlüssel ist, dass es nicht unvernünftig ist, sondern dass der Preis zuerst auf die angegebene EMA-Linie zurückkehren muss, um dann wieder zurückzugreifen.
Drei voreingestellte Konfigurationen, gewaltsame Optimierung für verschiedene Märkte
Die Strategie bietet drei Berechnungen: Elite, Balanced und Aggressive, die jeweils für die vier Märkte Forex, XAUUSD, Crypto und Indices in der Tiefe optimiert sind. Es handelt sich nicht um Parameter für den Kopfstoß, sondern um eine präzise Anpassung basierend auf einer großen Menge an Rückmeldedaten.
Der Forex-Markt zum Beispiel:
- Elite-Modus: EMA20-50 minimale Kursdifferenz 0,06%, ADX≥14, ATR Stop-Loss 1,8 Mal, Risikobereitschaft im Verhältnis 2:1
- Balanced Modus: Lockerung bis zu einer Kursdifferenz von 0,045%, ADX≥12, Stop-Loss um das 1,6-fache, Ziel 1,75:1
- Aggressive Modus: Weitere Lockerung auf 0,03%, ADX≥10, Stop-Loss um das 1,4-fache, Ziel 1,5:1
Die XAUUSD-Parameter sind strenger, die Elite-Mode erfordert eine EMA-Differenz von 0,09%, ADX≥16, da die schwankenden Eigenschaften von Gold eine stärkere Trendbestätigung erfordern. Der Krypto-Markt ist relativ locker, aber der ATR-Stop-Loss-Multiplier erhöht sich um das 2,2-Fache, um sich an die hohe Volatilität von Kryptowährungen anzupassen.
Mehrfache Zeitrahmen-Filterung ist die Kernkompetenz des Systems
Die Strategie überwacht gleichzeitig die EMA-Aufstellung der Tages- und der 1-Stunden-Charts und erlaubt nur ein Eingangssignal auf der 6-Minuten-Ebene, wenn ein Trend im hohen Zeitrahmen eindeutig ist. Diese Konstruktion löst direkt die größten Schmerzpunkte des Kleine-Perioden-Handels, die durch Hochfrequenz-Lärm gestört werden.
Die HTF-Alignment-Modus bietet vier Optionen: Off, nur Sonnenlicht, nur 1 Stunde, Sonnenlicht + 1 Stunde. In der Praxis wird empfohlen, die “Sonnenlicht + 1 Stunde” -Modus zu verwenden, obwohl die Signalfrequenz um etwa 30% reduziert wird, aber die Gewinne nach der Gewinnrate und Risikobereinigung deutlich erhöht werden.
Die Strategie blockiert automatisch neue Eintrittssignale, wenn ein chaotischer Aufbau in einem hohen Zeitrahmen EMA auftritt. Diese Konstruktion funktioniert besonders gut in einem bewegten Markt. Die Rückmeldung zeigt, dass die maximale Rücknahme nach der Hinzufügung des HTF-Filters um etwa 25% reduziert wurde.
ADX+ATR-Doppelfilter, die sich weigern, im Schlamm zu kämpfen
Die Strategie verlangt, dass die ADX den niedrigsten Wert erreicht, um den Handel zu erlauben, was sicherstellt, dass der Handel nur in einer Umgebung mit einem klaren Trend stattfindet. Die ATR muss außerdem einen bestimmten Prozentsatz des Preises überschreiten, um ein ungültiges Signal während extrem niedriger Schwankungen zu vermeiden.
Die Kombination dieser beiden Filter ist erstaunlich: Die Strategie stoppt den Handel vollständig, wenn ADX <12 und ATR ,1% ist. Historische Daten zeigen, dass diese “Lieber nicht verpassen, nichts falsch machen” -Design die Strategie dazu veranlasst hat, ungültige Geschäfte während der Querverarbeitung um mehr als 70% zu reduzieren.
Drei-Stufen-Entwurf für die Eintrittslogik mit strengen Standards für jeden Schritt
Die Einführung der Strategie erfolgt in drei Phasen:
- Pullback-PhaseDer Preis muss die angegebene EMA-Linie (die Standard EMA10) erreichen.
- Phase der ReklamationDer Kurs erobert die EMA-Linie zurück und kann die Schließung bestätigen oder die nächste K-Linie bestätigen.
- WiederholungsphaseDer Preis hat die EMA-Linie erneut getestet, ohne zu brechen.
Das Fein an dieser Konstruktion ist, dass sie die Preise auf ein eindeutiges “Retest-Retest-Bestätigungs” -Modell anstelle eines einfachen Durchschnittsbruchs hinweist. Die Rückmeldung zeigt, dass nach dem Hinzufügen der Retest-Anforderung der Gewinn pro Handel durchschnittlich um 35% erhöht wurde, obwohl die Anzahl der Signale um etwa 20% reduziert wurde.
ATR-Dynamische Stop-Loss-Systeme, die das Risikomanagement intelligent machen
Die Strategie verwendet das 1,8-fache des ATR als Stop-Range (Elite-Modus), was besser an Veränderungen der Marktschwankungen angepasst ist als ein fester Punktstop. Wenn der ATR sich erweitert, wird der Stop-Range automatisch gelockert; wenn die Schwankungen sich zusammenziehen, wird der Stop-Range verschärft, um den risikobereinigten Gewinn zu maximieren.
Weiterentwickelte Funktionen umfassen:
- Verlagerung von Stop-Loss nach Gewinn 1R bis zum Gewinn-Verlust-Gleichgewicht
- ATR-Tracking-Stopp nach Gewinn 1R aktiviert
- Anpassung des dynamischen Risiko-Rendite-Verhältnisses (RRR) von 1,5:1 auf 2:1
Die praktischen Daten zeigen, dass die Verwendung von ATR-Dynamischen Stop-Losses etwa 15% besser als die Verwendung von Fixed Stop-Losses ist, insbesondere in einem Marktumfeld mit hoher Volatilität.
RISK-HINWEIS: Das ist nicht die Gläubige Gläubigkeit, man muss vernünftig sein
Diese Strategie funktioniert gut in trendschaffenden Märkten, führt jedoch zu Verlusten in Folge in turbulenten Zeiten. Die historische Rückschau zeigt, dass die größten Verluste in Folge 5-7 Geschäfte betragen können, was die psychologische Belastbarkeit und die Fähigkeit des Geldmanagements erfordert.
Die Strategie ist am besten geeignet für die Anfangs- und Mittelphase des Trendstartes, wobei falsche Signale am Ende des Trends und in der Nähe von Wendepunkten erzeugt werden können. Es wird empfohlen, die technische Analyse in Verbindung mit einem höheren Zeitrahmen zu kombinieren, um zu vermeiden, dass Signale in der Nähe von offensichtlichen Widerstandsstützpunkten blind gefolgt werden.
Die Vergangenheit der Rückmeldung ist nicht repräsentativ für zukünftige Erträge. Veränderungen der Marktumgebung können die Wirksamkeit der Strategie beeinflussen. Es wird empfohlen, zuerst mindestens 3 Monate in einer Simulationsumgebung zu arbeiten, um die Strategie zu verstehen, und dann in das reale Kapital zu investieren.
/*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}}")