Strategi Pemburu Ayunan Konvergen Ganda: Menangkap Tren Kerangka Waktu Rendah Berdasarkan Sistem Penilaian Lanjutan

/*backtest
start: 2024-06-30 00:00:00
end: 2025-06-28 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT","balance":50000000}]
*/

//   ____                    _     _______            _ _               _____  
//  / __ \                  | |   |__   __|          | (_)             |  __ \ 
// | |  | |_   _  __ _ _ __ | |_     | |_ __ __ _  __| |_ _ __   __ _  | |__) | 
// | |  | | | | |/ _` | '_ \| __|    | | '__/ _` |/ _` | | '_ \ / _` | |  ___/ '__/ _ \ 
// | |__| | |_| | (_| | | | | |_     | | | | (_| | (_| | | | | | (_| | | |   | | | (_) |
//  \___\_\\__,_|\__,_|_| |_|\__|    |_|_|  \__,_|\__,_|_|_| |_|\__, | |_|   |_|  \___/
//                                                               __/ |     
//                                                              |___/   
// Quant Trading Pro
//@version=6
strategy("Multi-Confluence Swing Hunter V1", overlay=true, 
         default_qty_type=strategy.percent_of_equity, default_qty_value=100,
         commission_type=strategy.commission.percent, commission_value=0.1,
         slippage=3, initial_capital=1000, margin_long=0, margin_short=0)

// === DESCRIPTION ===
// High-conviction swing bottom entry strategy using optimized MACD(3,10,3) and RSI(21)
// Entry: Point-based scoring system for swing bottoms (divergences, momentum, price action)
// Exit: Inverse scoring system for swing tops (no stop-loss, exit only on swing top signals)
// Position: Single position with 100% allocation, scores displayed only when ≥10 points
// Based on analysis showing 23.7% improvement over standard parameters

// === INPUT PARAMETERS ===

// Optimized Indicator Settings
macdFast = input.int(3, "MACD Fast Length", minval=1, maxval=50, group="Optimized Indicators")
macdSlow = input.int(10, "MACD Slow Length", minval=1, maxval=100, group="Optimized Indicators") 
macdSignal = input.int(3, "MACD Signal Length", minval=1, maxval=50, group="Optimized Indicators")
rsiLength = input.int(21, "RSI Length", minval=2, maxval=100, group="Optimized Indicators")

// Entry Settings - Swing Bottom Scoring
minEntryScore = input.int(13, "Minimum Entry Score", minval=5, maxval=20, group="Entry Settings")
showEntryScores = input.bool(true, "Show Entry Scores (Above 10)", group="Entry Settings")

// Exit Settings - Swing Top Scoring (Inverse of Entry Criteria)
minExitScore = input.int(13, "Minimum Exit Score", minval=5, maxval=20, group="Exit Settings")
showExitScores = input.bool(true, "Show Exit Scores (Above 10)", group="Exit Settings")

// Price Action Settings
minLowerWickPercent = input.float(50.0, "Min Lower Wick %", minval=10.0, maxval=90.0, step=5.0, group="Price Action")
quickRecoveryPercent = input.float(0.3, "Quick Recovery %", minval=0.1, maxval=2.0, step=0.1, group="Price Action")
quickRecoveryBars = input.int(3, "Quick Recovery Bars", minval=1, maxval=10, group="Price Action")

// RSI Levels
rsiOversold = input.float(30.0, "RSI Oversold Level", minval=10.0, maxval=50.0, step=1.0, group="RSI Settings")
rsiExtremeOversold = input.float(25.0, "RSI Extreme Oversold", minval=10.0, maxval=40.0, step=1.0, group="RSI Settings")
rsiOverbought = input.float(70.0, "RSI Overbought Level", minval=50.0, maxval=90.0, step=1.0, group="RSI Settings")
rsiExtremeOverbought = input.float(75.0, "RSI Extreme Overbought", minval=60.0, maxval=90.0, step=1.0, group="RSI Settings")

// Reversal Signals Settings
reversalLookback = input.int(12, "Reversal Candle Lookback", minval=5, maxval=50, group="Reversal Signals")
reversalConfirm = input.int(3, "Reversal Confirm Within", minval=1, maxval=10, group="Reversal Signals")
useVolumeConfirmation = input.bool(false, "Use Volume Confirmation", group="Reversal Signals")

// Trade Management
allowShortTrades = input.bool(false, "Allow Short Trades?", group="Short Trades")

// Risk/Reward TP/SL Settings
useRiskReward = input.bool(true, "Use Risk/Reward TP/SL", group="Risk Management")
riskRewardRatio = input.float(5, "Risk/Reward Ratio", minval=1.0, maxval=5.0, step=0.1, group="Risk Management")
stopLossLookback = input.int(10, "Stop Loss Lookback Bars", minval=3, maxval=50, group="Risk Management")
stopLossBuffer = input.float(0.15, "Stop Loss Buffer %", minval=0.05, maxval=1.0, step=0.05, group="Risk Management")

// Advanced Settings
maxLookbackBars = input.int(8, "Divergence Lookback Bars", minval=3, maxval=20, group="Advanced")

// === 1️⃣ CALCULATIONS ===

// Optimized MACD Calculation
[macdLine, signalLine, macdHist] = ta.macd(close, macdFast, macdSlow, macdSignal)

// Optimized RSI Calculation  
rsi = ta.rsi(close, rsiLength)

// Price Action Calculations
bodySize = math.abs(close - open)
lowerWick = math.min(open, close) - low
upperWick = high - math.max(open, close)
totalRange = high - low
lowerWickPercent = totalRange > 0 ? (lowerWick / totalRange) * 100 : 0
upperWickPercent = totalRange > 0 ? (upperWick / totalRange) * 100 : 0
bodyPercent = totalRange > 0 ? (bodySize / totalRange) * 100 : 0

// Reversal Signals Calculation
var int bullCandleScore = 0
var int bearCandleScore = 0
var bool bullReversalCandidate = false
var bool bearReversalCandidate = false
var float bullReversalLow = 0.0
var float bullReversalHigh = 0.0
var float bearReversalLow = 0.0
var float bearReversalHigh = 0.0
var bool bullSignalConfirmed = false
var bool bearSignalConfirmed = false
var int bullCandleCounter = 0
var int bearCandleCounter = 0

volumeIsHigh = volume > ta.sma(volume, 20)

// Reset scores
bullCandleScore := 0
bearCandleScore := 0

// Calculate reversal scores
if bar_index >= reversalLookback
    for i = 0 to (reversalLookback - 1)
        if close < low[i]
            bullCandleScore += 1
        if close > high[i]
            bearCandleScore += 1

// Bear signal setup
if bearCandleScore == (reversalLookback - 1)
    bearReversalCandidate := true
    bearReversalLow := low
    bearReversalHigh := high
    bearSignalConfirmed := false
    bearCandleCounter := 0

if bearReversalCandidate
    bearCandleCounter += 1
    if close > bearReversalHigh
        bearReversalCandidate := false

bearCondition = bearReversalCandidate and close < bearReversalLow and not bearSignalConfirmed and bearCandleCounter <= (reversalConfirm + 1)
bearSignal = false
if bearCondition
    bearSignalConfirmed := true
    if not useVolumeConfirmation or volumeIsHigh
        bearSignal := true

// Bull signal setup
if bullCandleScore == (reversalLookback - 1)
    bullReversalCandidate := true
    bullReversalLow := low
    bullReversalHigh := high
    bullSignalConfirmed := false
    bullCandleCounter := 0

if bullReversalCandidate
    bullCandleCounter += 1
    if close < bullReversalLow
        bullReversalCandidate := false

bullCondition = bullReversalCandidate and close > bullReversalHigh and not bullSignalConfirmed and bullCandleCounter <= (reversalConfirm + 1)
bullSignal = false
if bullCondition
    bullSignalConfirmed := true
    if not useVolumeConfirmation or volumeIsHigh
        bullSignal := true

// === 2️⃣ ENTRY & EXIT LOGIC ===

// Helper Functions for Divergence Detection
findLowerLow(lookback) =>
    var float lowestPrice = na
    var int lowestIndex = na
    
    if bar_index >= lookback
        lowestPrice := low
        lowestIndex := bar_index
        
        for i = 1 to lookback
            if low[i] < lowestPrice
                lowestPrice := low[i]
                lowestIndex := bar_index - i
    
    [lowestPrice, lowestIndex]

findHigherHigh(lookback) =>
    var float highestPrice = na
    var int highestIndex = na
    
    if bar_index >= lookback
        highestPrice := high
        highestIndex := bar_index
        
        for i = 1 to lookback
            if high[i] > highestPrice
                highestPrice := high[i]
                highestIndex := bar_index - i
    
    [highestPrice, highestIndex]

// SWING BOTTOM SCORING SYSTEM

// 1. RSI Signals
rsiOversoldSignal = rsi < rsiOversold
rsiExtremeOversoldSignal = rsi < rsiExtremeOversold
rsiTurningUp = rsi > rsi[1]

// RSI Bullish Divergence
[prevLowPrice, prevLowIndex] = findLowerLow(maxLookbackBars)
rsiBullishDivergence = false
if not na(prevLowPrice) and not na(prevLowIndex) and bar_index > prevLowIndex
    prevRSI = rsi[bar_index - prevLowIndex]
    if low < prevLowPrice and rsi > prevRSI and not na(prevRSI)
        rsiBullishDivergence := true

// 2. MACD Signals  
macdNegative = macdLine < 0
macdTurningUp = macdLine > macdLine[1] 
macdHistImproving = macdHist > macdHist[1]

// MACD Bullish Divergence
macdBullishDivergence = false
if not na(prevLowPrice) and not na(prevLowIndex) and bar_index > prevLowIndex
    prevMACD = macdLine[bar_index - prevLowIndex]
    if low < prevLowPrice and macdLine > prevMACD and not na(prevMACD)
        macdBullishDivergence := true

// 3. Price Action Signals
longLowerWick = lowerWickPercent > minLowerWickPercent
smallBody = bodyPercent < 30.0
bullishClose = close > open

// 4. Quick Recovery Check
quickRecovery = false
if bar_index >= quickRecoveryBars
    recoveryTarget = close * (1 + quickRecoveryPercent / 100)
    for i = 1 to quickRecoveryBars
        if high[i] > recoveryTarget
            quickRecovery := true
            break

// ENTRY SCORE CALCULATION
entryScore = 0
entryScore := entryScore + (rsiOversoldSignal ? 2 : 0)
entryScore := entryScore + (rsiExtremeOversoldSignal ? 2 : 0)  
entryScore := entryScore + (rsiBullishDivergence ? 4 : 0)
entryScore := entryScore + (rsiTurningUp ? 1 : 0)
entryScore := entryScore + (macdNegative ? 1 : 0)
entryScore := entryScore + (macdTurningUp ? 2 : 0)
entryScore := entryScore + (macdHistImproving ? 2 : 0)
entryScore := entryScore + (macdBullishDivergence ? 3 : 0)
entryScore := entryScore + (longLowerWick ? 2 : 0)
entryScore := entryScore + (smallBody ? 1 : 0)
entryScore := entryScore + (bullishClose ? 1 : 0)
entryScore := entryScore + (quickRecovery ? 2 : 0)
entryScore := entryScore + (bullSignal ? 4 : 0)  // Green reversal signal +4

// SWING TOP SCORING SYSTEM (for exits)

// 1. RSI Exit Signals
rsiOverboughtSignal = rsi > rsiOverbought
rsiExtremeOverboughtSignal = rsi > rsiExtremeOverbought
rsiTurningDown = rsi < rsi[1]

// RSI Bearish Divergence
[prevHighPrice, prevHighIndex] = findHigherHigh(maxLookbackBars)
rsiBearishDivergence = false
if not na(prevHighPrice) and not na(prevHighIndex) and bar_index > prevHighIndex
    prevRSIHigh = rsi[bar_index - prevHighIndex]
    if high > prevHighPrice and rsi < prevRSIHigh and not na(prevRSIHigh)
        rsiBearishDivergence := true

// 2. MACD Exit Signals
macdPositive = macdLine > 0
macdTurningDown = macdLine < macdLine[1]
macdHistDeclining = macdHist < macdHist[1]

// MACD Bearish Divergence  
macdBearishDivergence = false
if not na(prevHighPrice) and not na(prevHighIndex) and bar_index > prevHighIndex
    prevMACDHigh = macdLine[bar_index - prevHighIndex]
    if high > prevHighPrice and macdLine < prevMACDHigh and not na(prevMACDHigh)
        macdBearishDivergence := true

// 3. Price Action Exit Signals
longUpperWick = upperWickPercent > minLowerWickPercent
bearishClose = close < open

// EXIT SCORE CALCULATION
exitScore = 0
exitScore := exitScore + (rsiOverboughtSignal ? 2 : 0)
exitScore := exitScore + (rsiExtremeOverboughtSignal ? 2 : 0)
exitScore := exitScore + (rsiBearishDivergence ? 4 : 0)
exitScore := exitScore + (rsiTurningDown ? 1 : 0)
exitScore := exitScore + (macdPositive ? 1 : 0)
exitScore := exitScore + (macdTurningDown ? 2 : 0)
exitScore := exitScore + (macdHistDeclining ? 2 : 0)
exitScore := exitScore + (macdBearishDivergence ? 3 : 0)
exitScore := exitScore + (longUpperWick ? 2 : 0)
exitScore := exitScore + (bearishClose ? 1 : 0)
exitScore := exitScore + (bearSignal ? 1 : 0)  // Red reversal signal +1

// SIGNAL CONDITIONS
longCondition = entryScore >= minEntryScore and barstate.isconfirmed
exitCondition = exitScore >= minExitScore and barstate.isconfirmed

// === TP/SL LEVELS (Clean Logic) ===
var float stopLossLevel = na
var float takeProfitLevel = na
var bool tpslSet = false

// Clear levels when no position
if strategy.position_size == 0
    stopLossLevel := na
    takeProfitLevel := na
    tpslSet := false

// Calculate TP/SL levels ONCE when position is opened
if strategy.position_size > 0 and strategy.position_size[1] == 0 and useRiskReward and not tpslSet
    // Find recent low for stop loss
    recentLow = low
    for i = 1 to stopLossLookback
        if low[i] < recentLow
            recentLow := low[i]
    
    // Set levels using actual entry price
    entryPrice = strategy.opentrades.entry_price(0)
    stopLossLevel := recentLow * (1 - stopLossBuffer / 100)  // Configurable buffer below recent low
    riskAmount = entryPrice - stopLossLevel
    takeProfitLevel := entryPrice + (riskAmount * riskRewardRatio)
    tpslSet := true

// === 3️⃣ TRADE EXECUTIONS ===

// Long Entry - Single Position Only
if longCondition and strategy.position_size == 0
    strategy.entry("Long", strategy.long, comment="Entry Score: " + str.tostring(entryScore))

// Set TP/SL ONLY ONCE per trade (when levels are calculated and not yet set)
if strategy.position_size > 0 and useRiskReward and tpslSet and not na(stopLossLevel) and not na(takeProfitLevel)
    strategy.exit("TP/SL", "Long", stop=stopLossLevel, limit=takeProfitLevel)

// Long Exit - Close Position on Swing Top Signal (Only when NOT using TP/SL)
if exitCondition and strategy.position_size > 0 and not useRiskReward
    strategy.close("Long", comment="Exit Score: " + str.tostring(exitScore))

// === 4️⃣ VISUALIZATIONS ===

// Entry Score Display (Only When Score ≥ 10) - Shows on ALL qualifying bars
if showEntryScores and entryScore >= 10 and barstate.isconfirmed
    label.new(bar_index, low, 
             text=str.tostring(entryScore), 
             yloc=yloc.belowbar,
             color=na,
             style=label.style_label_up, 
             textcolor=color.green, 
             size=size.small)

// Exit Score Display (Only When Score ≥ 10) - Shows on ALL qualifying bars  
if showExitScores and exitScore >= 10 and barstate.isconfirmed
    label.new(bar_index, high, 
             text=str.tostring(exitScore), 
             yloc=yloc.abovebar,
             color=na,
             style=label.style_label_down, 
             textcolor=color.red, 
             size=size.small)

// Large Trade Entry Triangle (Only when actually entering a position) - Using plotshape to avoid label limits
plotshape(longCondition and strategy.position_size == 0, title="Trade Entry", location=location.belowbar, color=color.green, style=shape.triangleup, size=size.normal, text="BUY")

// Large Trade Exit Triangle (Only when actually exiting a position) - Using plotshape to avoid label limits  
plotshape(exitCondition and strategy.position_size > 0, title="Trade Exit", location=location.abovebar, color=color.red, style=shape.triangledown, size=size.normal, text="SELL")

// Reversal Signal Triangles
plotshape(bullSignal, title="Bull Reversal", location=location.belowbar, 
         color=color.lime, style=shape.triangleup, size=size.tiny)

plotshape(bearSignal, title="Bear Reversal", location=location.abovebar, 
         color=color.red, style=shape.triangledown, size=size.tiny)

// === TP/SL LEVEL PLOTS ===
plot(strategy.position_size > 0 and useRiskReward ? stopLossLevel : na, title="Stop Loss", color=color.red, linewidth=2, style=plot.style_linebr)
plot(strategy.position_size > 0 and useRiskReward ? takeProfitLevel : na, title="Take Profit", color=color.green, linewidth=2, style=plot.style_linebr)

// MACD and RSI Plots (in separate panes)
macdPlot = plot(macdLine, title="MACD Line", color=color.blue, display=display.none)
signalPlot = plot(signalLine, title="Signal Line", color=color.red, display=display.none) 
histPlot = plot(macdHist, title="MACD Histogram", color=color.gray, style=plot.style_histogram, display=display.none)

rsiPlot = plot(rsi, title="RSI", color=color.purple, display=display.none)
rsiOverboughtLine = hline(rsiOverbought, title="RSI Overbought", color=color.red, linestyle=hline.style_dashed, display=display.none)
rsiOversoldLine = hline(rsiOversold, title="RSI Oversold", color=color.green, linestyle=hline.style_dashed, display=display.none)