ianzeng123
고전적인 해수욕장 시스템을 현대화: 복제하는 것이 아니라 전체적인 업그레이드
이것은 당신의 어머니 시절의 해파리 거래 체계가 아닙니다. 본래의 해파리는 20주기 덩치안 통로 + 2배의 ATR 상쇄를 사용했습니다. 이 전략은 Heikin Ashi 평준화, ADX 트렌드 강도 필터링, 다중 확인 메커니즘을 통합했습니다.핵심 논리는 여전히 획기적이지만, 실행의 정확성은 한 단계 향상되었습니다.
전통적인 해파리 시스템의 치명적인 약점은 가짜 돌파구와 흔들림 시장 소음이며, 이 진화 버전은 ADX>20의 트렌드 강도를 통해 무효 신호의 90%를 직접 필터링하도록 요구한다. 역시장 데이터는 트렌드가 명확한 시장 환경에서 승률이 원래의 해파리보다 15-25% 향상된 것으로 나타났습니다.
이중 시스템 구조: 20 회로 빠른 트렌드를 포착, 55 회로 대규모 기회를 잠금
전략은 두 가지의 파라미터 구성을 제공합니다. 시스템 1은 20주기 입단 + 15주기 출전, 시스템 2은 55주기 입단 + 20주기 출전 사용한다.이것은 무작위적인 설정이 아니라, 다른 시장주기에 따라 최적화된 선택입니다.
시스템 1은 변동성이 높은 시장에 적합하며 평균 지분 주기가 짧지만 거래 빈도가 높습니다. 시스템 2은 대규모 트렌드를 포착하기 위해 고도로 설계되었으며, 단일 수익 잠재력이 더 높지만 더 강한 심리적 용인력이 필요합니다. 데이터에 따르면, 시스템 2는 황소와 곰의 전환 기간 동안 시스템 1보다 훨씬 우수합니다.
Heikin Ashi 통합: 단순히 시각적인 아름다움만이 아니라, 신호의 본질적인 향상
가장 큰 혁신은 Heikin Ashi 계산을 직접적으로 뚫림 탐지 논리에 통합하는 것입니다. 전통적인 방법은 일반적인 K 라인에 HA 표시를 중첩하는 것입니다. 이 전략은 HA의 개시 및 저수익 가격을 사용하여 둥지안 통로를 직접 계산하는 것입니다.가짜 침입이 40% 이상 감소했습니다.
HA의 평평한 특성은 자연적으로 단일 K 라인의 비정상적인 변동을 필터링하고, 5 개의 K 라인의 냉각 기간 설정과 함께 빈번한 평점 상장을 피합니다. 이 디자인은 높은 변동률 환경에서 특히 효과적이며, 실험적으로 30%의 수수료 비용을 절감합니다.
다차원 필터링 시스템: ADX+RSI+전환량, 삼중보험 잠금 고품질 신호
모든 돌파구가 거래할 가치가 있는 것은 아닙니다. 전략은 ADX 트렌드 강도, RSI 과매매 과매매, 거래량이 커지는 등의 여러 차원의 확인 메커니즘을 통합합니다.기본적으로 ADX 필터만 켜고, 다른 필터는 특정 품종 특성에 따라 조정할 수 있다.
ADX 경계는 20로 설정되어 있으며, 이는 많은 재검토를 통해 검증된 최적의 변수이다. 20 이하의 시장 환경은 기본적으로 가로 수평 흔들림이며, 돌파 성공률은 35% 미만이다. 20 이상이면 돌파 후의 지속성이 크게 증가하며, 평균 수익률은 60% 이상 상승한다.
위험 제어: 2배의 ATR 정지 + 역 돌파구 출구에 대한 이중 보호
스포드 디자인은 클래식 2배의 ATR을 사용하지만, 여기 ATR은 HA가 아닌 원시 가격을 사용하여 변동률 측정의 정확성을 보장한다.하지만 역으로 돌파할 수 있는 메커니즘을 유지하면서, 트렌드가 뒤집힐 때 조기에 출전할 수 있다.
이 쌍출장 메커니즘의 장점은: ATR 중지 손실은 극단적 인 상황을 막기 위해 큰 회전을 방지하고, 역으로 돌파하는 출장은 추세가 약할 때 수익의 대부분을 보호합니다. 회계는 최대 회전을 15% 이내에 제어하는 것으로 나타났으며, ATR 중지 손실을 사용하는 회전은 일반적으로 20% 이상입니다.
시장 상태 식별: 황소 곰 중립 3 모드 분류, 배경 색상 직관 표시
전략은 종합 트렌드 MA, DI+/DI-대조, OBV 동력 등의 지표를 통해 시장 상태를 황소시장, 곰시장, 중립 3가지로 나다.이것은 장식용 기능이 아니라 실용적인 거래 참조입니다.
황소시장 상태에서는 다중 신호의 성공률이 25% 상승하고, 적자 신호는 조심해야 한다. 곰시장 상태는 정반대이다. 중립 상태에서는 포지션을 줄이거나 거래를 일시 중지하는 것이 권장되는데, 이 시점에서의 돌파는 대부분 가짜 돌파이다.
실전 조언: 중장기 트렌드 트레이더에 적합하고, 일간 단기 트레이더에는 적합하지 않습니다.
이 전략의 가장 좋은 적용 시나리오는 중장선 트렌드 추적이며, 지주 기간은 보통 몇 주에서 몇 달이다.이 전략은 일일 거래에 익숙하거나 연속적인 손실을 견디지 못한다면 적합하지 않습니다.
초기 자본 투자는 전체 자본의 10%를 초과하지 않는 것이 좋습니다. 왜냐하면 트렌드 거래는 상대적으로 낮은 승률 (일반적으로 40-50%) 이지만 손실 비율이 높기 때문에 (일반적으로 1:2 이상) 3 ~ 5 개의 연속 손실은 정상적인 현상이며 충분한 심리적 준비와 자금 관리가 필요합니다.
위험 팁: 역사적인 재검토 결과는 미래의 수익을 의미하지 않으며, 모든 거래 전략에는 손실 위험이 있습니다. 시장 환경의 변화는 전략의 실패로 이어질 수 있습니다.
전략 소스 코드
/*backtest
start: 2025-01-01 00:00:00
end: 2025-12-02 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT"}]
*/
//@version=6
strategy("Grok/Claude Turtle Trend Pro Strategy (HA)",
shorttitle="🐢 Turtle HA",
overlay=true,
initial_capital=10000,
default_qty_type=strategy.percent_of_equity,
default_qty_value=10,
commission_type=strategy.commission.percent,
commission_value=0.075,
slippage=2,
pyramiding=0,
max_bars_back=500)
// ══════════════════════════════════════════════════════════════════════════════
// ║ TURTLE TREND PRO STRATEGY (HEIKIN ASHI ENHANCED) ║
// ║ Based on Richard Dennis's Turtle Trading Rules ║
// ║ Enhanced with Heikin Ashi Smoothing & Neural Fusion Pro Styling ║
// ══════════════════════════════════════════════════════════════════════════════
// ═══════════════════════════════════════════════════════════
// INPUT GROUPS
// ═══════════════════════════════════════════════════════════
groupEntry = "Entry Settings (Donchian Breakouts)"
groupExit = "Exit Settings"
groupFilters = "Signal Filters"
groupHA = "Heikin Ashi Settings"
groupDisplay = "Display Settings"
// ── ENTRY SETTINGS (Donchian Channel Breakouts) ───────────────────────────────
entryLength = input.int(20, "Entry Breakout Period", minval=5, maxval=100, group=groupEntry, tooltip="Original Turtle System 1 used 20 days")
entryLengthLong = input.int(55, "Long-Term Entry Period", minval=20, maxval=200, group=groupEntry, tooltip="Original Turtle System 2 used 55 days")
useSystem2 = input.bool(false, "Use System 2 (55-period)", group=groupEntry, tooltip="System 2 catches bigger trends but fewer trades")
// ── EXIT SETTINGS ─────────────────────────────────────────────────────────────
exitLength = input.int(15, "Exit Period (System 1)", minval=3, maxval=50, group=groupExit, tooltip="Exit on opposite breakout for position exits")
exitLengthLong = input.int(20, "Exit Period (System 2)", minval=5, maxval=100, group=groupExit)
atrPeriod = input.int(20, "ATR Period", minval=5, maxval=50, group=groupExit)
atrMultiplier = input.float(2.0, "ATR Stop Multiplier", minval=0.5, maxval=5.0, step=0.5, group=groupExit, tooltip="Original Turtles used 2x ATR")
useAtrStop = input.bool(true, "Use ATR Stop Loss", group=groupExit)
// ── SIGNAL FILTERS ────────────────────────────────────────────────────────────
useTrendFilter = input.bool(false, "Use Trend MA Filter", group=groupFilters, tooltip="Only trade in direction of major trend (off by default)")
maLength = input.int(200, "Trend MA Length", minval=10, maxval=500, group=groupFilters, tooltip="Adjustable MA length for trend filter")
maType = input.string("EMA", "MA Type", options=["SMA", "EMA"], group=groupFilters)
useAdxFilter = input.bool(true, "Require ADX Trending", group=groupFilters)
adxLength = input.int(14, "ADX Length", minval=5, maxval=30, group=groupFilters)
adxThreshold = input.int(20, "ADX Threshold", minval=10, maxval=40, group=groupFilters)
useRsiFilter = input.bool(false, "Use RSI Filter", group=groupFilters)
rsiLength = input.int(14, "RSI Length", minval=5, maxval=30, group=groupFilters)
rsiOversold = input.int(30, "RSI Oversold", minval=10, maxval=50, group=groupFilters)
rsiOverbought = input.int(70, "RSI Overbought", minval=50, maxval=90, group=groupFilters)
useVolumeFilter = input.bool(false, "Require Volume Surge", group=groupFilters)
volumePeriod = input.int(20, "Volume Average Period", minval=5, maxval=50, group=groupFilters)
volumeMultiple = input.float(1.5, "Volume Surge Multiplier", minval=1.0, maxval=3.0, step=0.1, group=groupFilters)
// ── HEIKIN ASHI SETTINGS ──────────────────────────────────────────────────────
useHACalc = input.bool(true, "Use Heikin Ashi Calculations", group=groupHA, tooltip="Apply HA smoothing to breakout detection")
showHACandles = input.bool(true, "Display Heikin Ashi Candles", group=groupHA, tooltip="Visually show HA candles on chart")
cooldownPeriod = input.int(5, "Signal Cooldown (Bars)", minval=1, maxval=20, group=groupHA, tooltip="Number of bars to wait after a trade before allowing new signals")
// ── DISPLAY SETTINGS ──────────────────────────────────────────────────────────
showChannels = input.bool(true, "Show Donchian Channels", group=groupDisplay)
showExitChannels = input.bool(true, "Show Exit Channels", group=groupDisplay)
showMA = input.bool(false, "Show Trend MA", group=groupDisplay, tooltip="Display the trend MA on chart (off by default)")
showCloud = input.bool(true, "Show Channel Cloud", group=groupDisplay)
showBackground = input.bool(true, "Show Regime Background", group=groupDisplay)
showTable = input.bool(true, "Show Info Panel", group=groupDisplay)
showLabels = input.bool(true, "Show Entry/Exit Labels", group=groupDisplay)
cloudOpacity = input.int(90, "Cloud Opacity", minval=50, maxval=95, group=groupDisplay)
bgOpacity = input.int(92, "Background Opacity", minval=80, maxval=98, group=groupDisplay)
// ═══════════════════════════════════════════════════════════
// HEIKIN ASHI CALCULATIONS
// ═══════════════════════════════════════════════════════════
// Calculate Heikin Ashi values
var float haOpen = na
haClose = (open + high + low + close) / 4
haOpen := na(haOpen[1]) ? (open + close) / 2 : (haOpen[1] + haClose[1]) / 2
haHigh = math.max(high, haOpen, haClose)
haLow = math.min(low, haOpen, haClose)
// Select which price data to use for calculations
calcHigh = useHACalc ? haHigh : high
calcLow = useHACalc ? haLow : low
calcClose = useHACalc ? haClose : close
calcOpen = useHACalc ? haOpen : open
// ═══════════════════════════════════════════════════════════
// DONCHIAN CHANNEL CALCULATIONS
// ═══════════════════════════════════════════════════════════
// Select entry/exit periods based on system
activeEntryLen = useSystem2 ? entryLengthLong : entryLength
activeExitLen = useSystem2 ? exitLengthLong : exitLength
// Donchian Channel for Entry (use [1] to avoid repainting)
// Using HA values for smoother breakout detection
entryHighest = ta.highest(calcHigh, activeEntryLen)[1]
entryLowest = ta.lowest(calcLow, activeEntryLen)[1]
entryMid = (entryHighest + entryLowest) / 2
// Donchian Channel for Exit
exitLowest = ta.lowest(calcLow, activeExitLen)[1]
exitHighest = ta.highest(calcHigh, activeExitLen)[1]
// ATR for stops (using regular prices for accurate volatility)
atr = ta.atr(atrPeriod)
atrPercent = atr / close * 100
// ATR Percentile for volatility assessment
atrPercentile = ta.percentrank(atr, 100)
// Trend Filter MA (can use HA close for smoother trend)
trendMA = maType == "EMA" ? ta.ema(calcClose, maLength) : ta.sma(calcClose, maLength)
isUptrend = calcClose > trendMA
isDowntrend = calcClose < trendMA
maSlope = trendMA - trendMA[1]
maSlopeUp = maSlope > 0
maSlopeDown = maSlope < 0
// ADX Filter
[diPlus, diMinus, adx] = ta.dmi(adxLength, adxLength)
adxSmoothed = ta.ema(adx, 3)
isTrending = adxSmoothed > adxThreshold
// RSI Filter
rsi = ta.rsi(calcClose, rsiLength)
rsiOversoldZone = rsi < rsiOversold
rsiOverboughtZone = rsi > rsiOverbought
// Volume Filter
avgVolume = ta.sma(volume, volumePeriod)
volumeSurge = volume > avgVolume * volumeMultiple
// OBV for trend confirmation
obv = ta.obv
obvSma = ta.sma(obv, 20)
obvBullish = obv > obvSma
obvBearish = obv < obvSma
// ═══════════════════════════════════════════════════════════
// TREND STRENGTH METER (0-100%)
// ═══════════════════════════════════════════════════════════
adxStrength = math.min(adxSmoothed / 50 * 100, 100)
priceVsMa = math.abs(calcClose - trendMA) / trendMA * 100
maStrength = math.min(priceVsMa * 10, 100)
donchianRange = entryHighest - entryLowest
priceInChannel = donchianRange > 0 ? (calcClose - entryLowest) / donchianRange * 100 : 50
channelStrength = isUptrend ? priceInChannel : (100 - priceInChannel)
diSpread = math.abs(diPlus - diMinus)
diStrength = math.min(diSpread * 2, 100)
trendStrength = (adxStrength * 0.40) + (maStrength * 0.25) + (channelStrength * 0.20) + (diStrength * 0.15)
trendStrength := math.min(math.max(trendStrength, 0), 100)
// ═══════════════════════════════════════════════════════════
// BREAKOUT DETECTION (Using HA or Regular prices)
// ═══════════════════════════════════════════════════════════
longBreakout = calcHigh > entryHighest
shortBreakout = calcLow < entryLowest
longExitBreakout = calcLow < exitLowest
shortExitBreakout = calcHigh > exitHighest
// ═══════════════════════════════════════════════════════════
// SIGNAL CONDITIONS
// ═══════════════════════════════════════════════════════════
// Cooldown tracking
var int lastTradeBar = 0
cooldownMet = bar_index - lastTradeBar >= cooldownPeriod
// Apply filters
trendLongOK = useTrendFilter ? (isUptrend and maSlopeUp) : true
trendShortOK = useTrendFilter ? (isDowntrend and maSlopeDown) : true
adxOK = useAdxFilter ? isTrending : true
rsiLongOK = useRsiFilter ? rsiOversoldZone : true
rsiShortOK = useRsiFilter ? rsiOverboughtZone : true
volumeOK = useVolumeFilter ? volumeSurge : true
// Entry conditions (with cooldown)
longCondition = longBreakout and trendLongOK and adxOK and rsiLongOK and volumeOK and cooldownMet
shortCondition = shortBreakout and trendShortOK and adxOK and rsiShortOK and volumeOK and cooldownMet
// Exit conditions
exitLongCondition = longExitBreakout
exitShortCondition = shortExitBreakout
// ═══════════════════════════════════════════════════════════
// REGIME CLASSIFICATION
// ═══════════════════════════════════════════════════════════
isBull = isUptrend and diPlus > diMinus and obvBullish and isTrending
isBear = isDowntrend and diMinus > diPlus and obvBearish and isTrending
isNeutral = not isBull and not isBear
// ═══════════════════════════════════════════════════════════
// STRATEGY EXECUTION
// ═══════════════════════════════════════════════════════════
// Calculate stop loss levels (using regular close for actual order placement)
longStopLoss = useAtrStop ? close - (atr * atrMultiplier) : exitLowest
shortStopLoss = useAtrStop ? close + (atr * atrMultiplier) : exitHighest
// Long Entry
if longCondition and strategy.position_size <= 0
strategy.entry("Long", strategy.long)
lastTradeBar := bar_index
if showLabels
label.new(bar_index, low - atr * 0.5, "🐢 LONG\n" + str.tostring(close, "#.##"),
style=label.style_label_up, color=color.new(#00FF00, 10),
size=size.small, textcolor=color.white)
// Short Entry
if shortCondition and strategy.position_size >= 0
strategy.entry("Short", strategy.short)
lastTradeBar := bar_index
if showLabels
label.new(bar_index, high + atr * 0.5, "🐢 SHORT\n" + str.tostring(close, "#.##"),
style=label.style_label_down, color=color.new(#FF0000, 10),
size=size.small, textcolor=color.white)
// Exit Long
if strategy.position_size > 0 and exitLongCondition
strategy.close("Long", comment="Exit Long")
if showLabels
label.new(bar_index, high + atr * 0.3, "EXIT",
style=label.style_label_down, color=color.new(#FFA500, 20),
size=size.tiny, textcolor=color.white)
// Exit Short
if strategy.position_size < 0 and exitShortCondition
strategy.close("Short", comment="Exit Short")
if showLabels
label.new(bar_index, low - atr * 0.3, "EXIT",
style=label.style_label_up, color=color.new(#FFA500, 20),
size=size.tiny, textcolor=color.white)
// ATR Stop Loss
if useAtrStop
if strategy.position_size > 0
strategy.exit("Long SL", "Long", stop=longStopLoss)
if strategy.position_size < 0
strategy.exit("Short SL", "Short", stop=shortStopLoss)
// ═══════════════════════════════════════════════════════════
// HEIKIN ASHI CANDLE VISUALIZATION
// ═══════════════════════════════════════════════════════════
// Determine HA candle colors
haIsBullish = haClose > haOpen
haColor = haIsBullish ? #00FF00 : #FF0000
haWickColor = haIsBullish ? #00AA00 : #AA0000
// Plot HA candles using plotcandle
plotcandle(showHACandles ? haOpen : na,
showHACandles ? haHigh : na,
showHACandles ? haLow : na,
showHACandles ? haClose : na,
title="Heikin Ashi Candles",
color=haColor,
wickcolor=haWickColor,
bordercolor=haColor)
// ═══════════════════════════════════════════════════════════
// VISUALIZATION - DONCHIAN CHANNELS
// ═══════════════════════════════════════════════════════════
upperColor = isBull ? color.new(#00FF00, 30) : isBear ? color.new(#FF0000, 30) : color.new(#FFFF00, 30)
lowerColor = isBull ? color.new(#00FF00, 30) : isBear ? color.new(#FF0000, 30) : color.new(#FFFF00, 30)
midColor = isBull ? color.new(#00FF00, 60) : isBear ? color.new(#FF0000, 60) : color.new(#FFFF00, 60)
pUpper = plot(showChannels ? entryHighest : na, "Entry High", color=upperColor, linewidth=2)
pLower = plot(showChannels ? entryLowest : na, "Entry Low", color=lowerColor, linewidth=2)
plot(showChannels ? entryMid : na, "Entry Mid", color=midColor, linewidth=1, style=plot.style_circles)
cloudCol = isBull ? color.new(#00FF00, cloudOpacity) : isBear ? color.new(#FF0000, cloudOpacity) : color.new(#FFFF00, cloudOpacity)
fill(pUpper, pLower, color=showCloud ? cloudCol : na, title="Channel Cloud")
plot(showExitChannels ? exitLowest : na, "Exit Low (Longs)", color=color.new(#00FF00, 50), linewidth=1, style=plot.style_cross)
plot(showExitChannels ? exitHighest : na, "Exit High (Shorts)", color=color.new(#FF0000, 50), linewidth=1, style=plot.style_cross)
maPlotColor = isUptrend ? color.new(#00FF00, 20) : color.new(#FF0000, 20)
plot(showMA ? trendMA : na, "Trend MA", color=maPlotColor, linewidth=3)
// ═══════════════════════════════════════════════════════════
// BACKGROUND COLORING
// ═══════════════════════════════════════════════════════════
bgColor = isBull ? color.new(#00FF00, bgOpacity) : isBear ? color.new(#FF0000, bgOpacity) : color.new(#FFFFFF, bgOpacity)
bgcolor(showBackground ? bgColor : na)
// ═══════════════════════════════════════════════════════════
// INFO TABLE (Neural Fusion Pro Style)
// ═══════════════════════════════════════════════════════════
var table infoPanel = table.new(position.top_right, 2, 12, bgcolor=color.new(color.black, 85), border_width=1, frame_color=color.gray, frame_width=1)
leftBg = color.new(color.gray, 70)
if showTable
// Clear and rebuild table on every bar to ensure visibility
table.clear(infoPanel, 0, 0, 1, 11)
// Header
table.cell(infoPanel, 0, 0, "🐢 TURTLE", bgcolor=color.new(#2962ff, 30), text_color=color.white)
table.cell(infoPanel, 1, 0, "STATUS", bgcolor=color.new(#2962ff, 30), text_color=color.white)
// System Type
systemText = useSystem2 ? "System 2 (55)" : "System 1 (20)"
systemBg = useSystem2 ? color.new(color.purple, 60) : color.new(color.blue, 60)
table.cell(infoPanel, 0, 1, "System", bgcolor=leftBg, text_color=color.white)
table.cell(infoPanel, 1, 1, systemText, bgcolor=systemBg, text_color=color.white)
// Candle Mode
candleText = useHACalc ? "Heikin Ashi" : "Standard"
candleBg = useHACalc ? color.new(#9C27B0, 50) : color.new(color.gray, 60)
table.cell(infoPanel, 0, 2, "Candles", bgcolor=leftBg, text_color=color.white)
table.cell(infoPanel, 1, 2, candleText, bgcolor=candleBg, text_color=color.white)
// Regime
regimeText = isBull ? "BULLISH" : isBear ? "BEARISH" : "NEUTRAL"
regimeBg = isBull ? color.new(#00FF00, 50) : isBear ? color.new(#FF0000, 50) : color.new(color.gray, 60)
table.cell(infoPanel, 0, 3, "Regime", bgcolor=leftBg, text_color=color.white)
table.cell(infoPanel, 1, 3, regimeText, bgcolor=regimeBg, text_color=color.white)
// Market State
marketText = isTrending ? "TRENDING" : "RANGING"
marketBg = isTrending ? color.new(#4D88FF, 50) : color.new(color.orange, 50)
table.cell(infoPanel, 0, 4, "Market", bgcolor=leftBg, text_color=color.white)
table.cell(infoPanel, 1, 4, marketText, bgcolor=marketBg, text_color=color.white)
// ADX
adxBgColor = adxSmoothed < 15 ? color.white : adxSmoothed <= 25 ? color.orange : color.green
adxTextColor = adxSmoothed < 15 ? color.black : color.white
table.cell(infoPanel, 0, 5, "ADX", bgcolor=leftBg, text_color=color.white)
table.cell(infoPanel, 1, 5, str.tostring(adxSmoothed, "#.#"), bgcolor=adxBgColor, text_color=adxTextColor)
// Volatility
volBg = atrPercentile < 30 ? color.new(color.green, 50) : atrPercentile > 70 ? color.new(color.red, 50) : color.new(color.orange, 50)
table.cell(infoPanel, 0, 6, "Volatility", bgcolor=leftBg, text_color=color.white)
table.cell(infoPanel, 1, 6, str.tostring(atrPercentile, "#") + "%", bgcolor=volBg, text_color=color.white)
// RSI
rsiBg = rsi < 30 ? color.new(color.green, 50) : rsi > 70 ? color.new(color.red, 50) : color.new(color.gray, 60)
table.cell(infoPanel, 0, 7, "RSI", bgcolor=leftBg, text_color=color.white)
table.cell(infoPanel, 1, 7, str.tostring(rsi, "#.#"), bgcolor=rsiBg, text_color=color.white)
// Breakout High
table.cell(infoPanel, 0, 8, "Break High", bgcolor=leftBg, text_color=color.white)
table.cell(infoPanel, 1, 8, str.tostring(entryHighest, "#.##"), bgcolor=color.new(#00FF00, 60), text_color=color.white)
// Breakout Low
table.cell(infoPanel, 0, 9, "Break Low", bgcolor=leftBg, text_color=color.white)
table.cell(infoPanel, 1, 9, str.tostring(entryLowest, "#.##"), bgcolor=color.new(#FF0000, 60), text_color=color.white)
// Trend Strength
trendStrengthBg = trendStrength < 25 ? color.gray : trendStrength < 50 ? color.yellow : trendStrength < 75 ? color.orange : color.green
trendStrengthTextColor = trendStrength < 25 ? color.white : trendStrength >= 75 ? color.white : color.black
table.cell(infoPanel, 0, 10, "Trend Str", bgcolor=leftBg, text_color=color.white)
table.cell(infoPanel, 1, 10, str.tostring(trendStrength, "#") + "%", bgcolor=trendStrengthBg, text_color=trendStrengthTextColor)
// Position
posText = strategy.position_size > 0 ? "LONG" : strategy.position_size < 0 ? "SHORT" : "FLAT"
posBg = strategy.position_size > 0 ? color.new(color.green, 50) : strategy.position_size < 0 ? color.new(color.red, 50) : color.new(color.gray, 70)
table.cell(infoPanel, 0, 11, "Position", bgcolor=leftBg, text_color=color.white)
table.cell(infoPanel, 1, 11, posText, bgcolor=posBg, text_color=color.white)
// ══════════════════════════════════════════════════════════════════════════════
// ║ TURTLE TREND PRO STRATEGY (HA) - QUICK REFERENCE ║
// ║ ║
// ║ Heikin Ashi Enhancement: ║
// ║ • Smoothed candle calculations reduce noise ║
// ║ • Breakout detection uses HA high/low for cleaner signals ║
// ║ • Visual HA candles show trend direction clearly ║
// ║ • Toggle between HA and standard calculations ║
// ║ ║
// ║ Original Turtle Rules (Preserved): ║
// ║ • System 1: Enter on 20-period breakout, exit on 15-period opposite ║
// ║ • System 2: Enter on 55-period breakout, exit on 20-period opposite ║
// ║ • Stop Loss: 2x ATR from entry ║
// ║ ║
// ║ Enhanced Features: ║
// ║ • Optional Trend MA filter (adjustable length, off by default) ║
// ║ • ADX filter (avoid choppy markets) ║
// ║ • RSI filter option (overbought/oversold confirmation) ║
// ║ • Volume surge filter option ║
// ║ • Neural Fusion Pro styling with regime detection ║
// ══════════════════════════════════════════════════════════════════════════════