Estrategia Elite de recuperación de EMA multi-temporal
ianzeng123
EMA, MTF, ADX, ATR
Esta no es una estrategia de EMA común, es un sistema de precisión de francotiradores de varios marcos de tiempo.
La lógica central de esta estrategia de Elite MTF EMA Reclaim es simple y grosera: esperar a que el precio retroceda del sistema de medias de EMA y luego volver a tomar la mediana clave para entrar en juego. Pero el diablo se mete en los detalles con filtros de múltiples marcos de tiempo, ADX para confirmar la fuerza de la tendencia, paradas de ATR, y jugar con las operaciones de medias simples.
Los datos de retroalimentación muestran que, cuando se ejecuta en ciclos de 6 minutos, la estrategia filtra de manera efectiva una gran cantidad de falsas señales de ruptura a través de estrictos requisitos de acumulación de EMA ((5>10>20>50) y un mecanismo de confirmación de retroalimentación. La clave es que no es poco inteligente, sino que requiere que el precio primero retroceda a la línea de EMA designada y luego vuelva a recuperarse para entrar en juego.
Tres conjuntos de configuraciones predeterminadas, optimizadas para diferentes mercados
La estrategia ofrece tres tipos de pronóstico: Elite, Balanced y Aggressive, cada uno optimizado en profundidad para los cuatro mercados: Forex, XAUUSD, Crypto e Indices. No se trata de parámetros de brainstorming, sino de ajustes de precisión basados en una gran cantidad de datos de retroalimentación.
Por ejemplo, en el mercado Forex:
- Modo Elite: EMA20-50 con una diferencia mínima de precio de 0.06%, ADX≥14, pérdidas de detención de ATR de 1.8 veces, con un riesgo de retorno de 2: 1
- Modo balanceado: expansión hasta una diferencia de precio de 0.045%, ADX≥12, pérdida de pérdidas de 1.6 veces, objetivo de 1.75:1
- Modo agresivo: más flexibilidad a 0.03%, ADX≥10, pérdidas de 1.4 veces, objetivo 1.5:1
Los parámetros de XAUUSD son más estrictos, el modelo Elite requiere una diferencia de EMA de 0.09% y ADX≥16, debido a que las características de volatilidad del oro requieren una confirmación de tendencia más fuerte. El mercado de criptomonedas es relativamente relajado, pero el ATR se ha multiplicado por 2.2 para adaptarse a un entorno de alta volatilidad de las criptomonedas.
El filtro de múltiples marcos de tiempo es la principal ventaja de este sistema.
La estrategia monitorea simultáneamente el estado de la alineación EMA del diagrama y el diagrama de 1 hora, y solo permite señales de entrada a nivel de 6 minutos cuando la tendencia del marco de tiempo alto es clara. Este diseño resuelve directamente el mayor problema de las operaciones de pequeño ciclo que son interrumpidas por el ruido de alta frecuencia.
El modo de alineación HTF ofrece cuatro opciones: apagado, solo línea diurna, solo 1 hora, línea diurna + 1 hora. En combate real se recomienda usar el modo “línea diurna + 1 hora”, aunque la frecuencia de la señal se reduce en un 30%, pero los beneficios después de ajustar la tasa de victoria y el riesgo aumentan significativamente.
El diseño funciona especialmente bien en mercados convulsionados. La retrospectiva muestra que, después de agregar el filtro HTF, la retirada máxima se redujo en un 25% aproximadamente.
ADX + ATR, doble filtro, rechazó pelear en el barro
La estrategia requiere que el ADX alcance el mínimo de desvalorización antes de permitir el comercio, lo que garantiza que solo se opere en un entorno con una clara tendencia. Al mismo tiempo, el ATR debe superar un porcentaje específico del precio para evitar que se produzca una señal de invalidez durante las fluctuaciones extremadamente bajas.
La combinación de estos dos filtros tiene un efecto sorprendente: la estrategia se detiene completamente cuando el ADX es <12 y el ATR es <0.1%. Los datos históricos muestran que este diseño “preferiría perderse, no hacer nada malo” permitió que la estrategia redujera en más del 70% las transacciones no válidas durante la recopilación horizontal.
Diseño en tres fases de la lógica de entrada, con estrictos estándares en cada paso
El acceso a la estrategia requiere tres etapas:
- Etapa de retorno hacia atrás: El precio debe tocar primero la línea EMA designada (default EMA10)
- Etapa de recuperaciónEl precio retomó la línea EMA, con la opción de confirmar el cierre o la siguiente línea K.
- La etapa de la nueva pruebaEl precio de la línea EMA se ha vuelto a probar en las 18 líneas K recuperadas, pero no ha caído.
La particularidad de este diseño es que requiere que los precios muestren un claro patrón de “retirada-retirada-confirmación”, en lugar de una simple ruptura de la línea media. La retrospectiva muestra que después de agregar el requisito de Retest, aunque la cantidad de señales se redujo en aproximadamente un 20%, el promedio de ganancias por transacción aumentó en un 35%.
ATR, un sistema de detención de pérdidas dinámicas para la inteligencia de la gestión de riesgos
La estrategia utiliza 1.8 veces el ATR como distancia de parada (en el modo Elite), que es más adaptable a los cambios en la volatilidad del mercado que el número fijo de puntos de parada. Cuando el ATR se expande, la distancia de parada se relaja automáticamente; cuando la volatilidad se contrae, el stop se aprieta para maximizar el beneficio ajustado al riesgo.
Las funciones más avanzadas incluyen:
- Ganancias 1R tras el movimiento del stop loss al punto de equilibrio de ganancias y pérdidas
- Ganancias 1R después de iniciar el seguimiento de ATR para detener los pérdidas
- Ajuste de la relación de riesgo-retorno dinámico (de 1.5:1 a 2:1)
Los datos reales muestran que el uso de la parada dinámica de ATR tiene un rendimiento superior al de la parada fija de aproximadamente 15%, especialmente en un entorno de mercado con grandes cambios en la volatilidad.
La advertencia estricta: no es la copa sagrada, hay que ser razonable
Esta estrategia funciona muy bien en mercados con una clara tendencia, pero puede generar pérdidas continuas en situaciones de agitación. La retrospectiva histórica muestra que las pérdidas continuas máximas pueden llegar a 5-7 operaciones, lo que requiere que el comerciante tenga suficiente capacidad de soporte psicológico y capacidad de gestión de fondos.
La estrategia funciona mejor durante el inicio y la mitad de la tendencia, y es propensa a generar falsas señales al final de la tendencia y cerca de los puntos de inflexión. Se recomienda combinar el análisis técnico con un marco de tiempo más alto y evitar seguir ciegamente las señales cerca de los soportes de resistencia más evidentes.
El rendimiento de la retroalimentación pasada no representa los beneficios futuros, los cambios en el entorno del mercado pueden afectar la eficacia de la estrategia. Se recomienda que primero se ejecute en un entorno simulado por lo menos 3 meses, y luego de conocer las características de la estrategia, se invierta en capital real.
/*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}}")