CNPS23-VOLUME_ORDER BLOCK

PhaisinhOnline · strategy · 2033 行 · 点赞 12 · TradingView 原页

本页源码来自 TradingView 公开发布的开源脚本,版权归原作者所有, 请遵循其原始许可(Pine 脚本常见 CC BY-NC-SA / MPL-2.0 / MIT)。 本项目仅用于研究检索与许可范围内的移植。

Pine Script

//@version=6
strategy(
     title="CNPS23 VOLUME ORDER BLOCK RETEST",
     shorttitle="CNPS23 VOB RETEST",
     overlay=true,
     initial_capital=100000000,
     default_qty_type=strategy.fixed,
     default_qty_value=3,
     pyramiding=0,
     margin_long=0,
     margin_short=0,
     slippage=3,
     commission_type=strategy.commission.cash_per_contract,
     commission_value=10000,
     fill_orders_on_standard_ohlc=true,
     process_orders_on_close=true,
     calc_on_order_fills=true,
     max_labels_count=300,
     max_lines_count=300,
     max_bars_back=5000
)
 
 
// ============================================================================
// CNPS23 VOLUME ORDER BLOCK RETEST
//
// SOURCE LOGIC:
//
// 1. Detect displacement + volume impulse
// 2. Create an Order Block from the candle BEFORE the impulse
// 3. Keep multiple active zones
// 4. Wait for price to retest an active zone
// 5. Optional:
//      - Directional candle
//      - Rejection wick
//      - Retest volume dry-up
//      - EMA trend filter
// 6. One trade per zone by default
//
// CNPS EXECUTION:
// - Current chart timeframe
// - 100M initial capital
// - 3 contracts
// - Commission: VND 10,000 / contract
// - Slippage: 3 ticks
// - Entry: 09:00 -> 14:30
// - Force close: 14:45
//
// DEFAULT EXIT:
// - Fixed SL = 5 points
// - Fixed TP = 15 points
// ============================================================================
 
 
// ============================================================================
// SECTION 1: TRADE DIRECTION
// ============================================================================
 
tradeDirection = input.string(
     "Both",
     title="Trade Direction",
     options=["Long", "Short", "Both"],
     group="Trade Control"
)
 
bool allowLong = tradeDirection == "Long" or tradeDirection == "Both"
bool allowShort = tradeDirection == "Short" or tradeDirection == "Both"
 
maximumTradesPerDay = input.int(
     0,
     title="Maximum Trades Per Day (0 = Unlimited)",
     minval=0,
     maxval=50,
     group="Trade Control"
)
 
cooldownBars = input.int(
     0,
     title="Cooldown Bars After Entry",
     minval=0,
     maxval=100,
     group="Trade Control"
)
 
 
// ============================================================================
// SECTION 2: ORDER BLOCK DETECTION
// ============================================================================
 
atrLength = input.int(
     14,
     title="ATR Length",
     minval=1,
     group="Order Block Detection"
)
 
displacementMultiplier = input.float(
     0.8,
     title="Displacement Body >= ATR x",
     minval=0.1,
     step=0.1,
     group="Order Block Detection"
)
 
volumeLength = input.int(
     20,
     title="Volume SMA Length",
     minval=1,
     group="Order Block Detection"
)
 
impulseVolumeMultiplier = input.float(
     1.0,
     title="Impulse Volume >= SMA x",
     minval=0.0,
     step=0.1,
     group="Order Block Detection"
)
 
requireOppositeCandle = input.bool(
     false,
     title="Require Opposite Candle Before Impulse?",
     group="Order Block Detection"
)
 
requireImpulseBreak = input.bool(
     false,
     title="Require Impulse Close Beyond Previous Range?",
     group="Order Block Detection"
)
 
useBodyOnlyZone = input.bool(
     false,
     title="Use Previous Candle Body Only For Zone?",
     group="Order Block Detection"
)
 
maximumActiveZones = input.int(
     15,
     title="Maximum Active Zones",
     minval=1,
     maxval=40,
     group="Order Block Detection"
)
 
maximumZoneAge = input.int(
     300,
     title="Maximum Zone Age (Bars)",
     minval=10,
     group="Order Block Detection"
)
 
 
// ============================================================================
// SECTION 3: RETEST FILTERS
// ============================================================================
 
firstTouchOnly = input.bool(
     true,
     title="Each Zone Trades Once?",
     group="Retest Filters"
)
 
requireDirectionCandle = input.bool(
     true,
     title="Require Candle In Trade Direction?",
     group="Retest Filters"
)
 
useRejectionWick = input.bool(
     false,
     title="Require Rejection Wick?",
     group="Retest Filters"
)
 
minimumWickPercent = input.float(
     25.0,
     title="Minimum Rejection Wick %",
     minval=5.0,
     maxval=95.0,
     step=1.0,
     group="Retest Filters"
)
 
useRetestVolumeFilter = input.bool(
     false,
     title="Require Volume Dry-Up On Retest?",
     group="Retest Filters"
)
 
retestVolumeMaximum = input.float(
     1.0,
     title="Retest Volume <= Impulse Volume x",
     minval=0.1,
     step=0.05,
     group="Retest Filters"
)
 
useTrendFilter = input.bool(
     false,
     title="Use EMA Trend Filter?",
     group="Retest Filters"
)
 
trendEMALength = input.int(
     100,
     title="EMA Length",
     minval=2,
     group="Retest Filters"
)
 
 
// ============================================================================
// SECTION 4: EXIT MODE
// ============================================================================
 
exitMode = input.string(
     "Fixed Points",
     title="Exit Mode",
     options=["Fixed Points", "Zone RR"],
     group="Risk Management"
)
 
 
// ============================================================================
// SECTION 5: FIXED POINT EXIT
// ============================================================================
 
stopLossPoints = input.float(
     5.0,
     title="Fixed Stop Loss (Points)",
     minval=0.5,
     step=0.5,
     group="Risk Management"
)
 
takeProfitPoints = input.float(
     15.0,
     title="Fixed Take Profit (Points)",
     minval=0.5,
     step=0.5,
     group="Risk Management"
)
 
 
// ============================================================================
// SECTION 6: SOURCE-STYLE ZONE RR
// ============================================================================
 
zoneStopATRBuffer = input.float(
     0.2,
     title="Zone Stop Buffer (ATR x)",
     minval=0.0,
     step=0.05,
     group="Zone RR"
)
 
zoneRewardRisk = input.float(
     1.5,
     title="Zone Take Profit (R)",
     minval=0.2,
     step=0.1,
     group="Zone RR"
)
 
 
// ============================================================================
// SECTION 7: OPTIONAL BREAK EVEN
// ============================================================================
 
useBreakEven = input.bool(
     false,
     title="Use Break Even?",
     group="Break Even"
)
 
breakEvenTriggerR = input.float(
     1.0,
     title="Break Even Trigger (R)",
     minval=0.2,
     step=0.1,
     group="Break Even"
)
 
breakEvenOffsetPoints = input.float(
     0.0,
     title="Break Even Offset (Points)",
     minval=0.0,
     step=0.5,
     group="Break Even"
)
 
 
// ============================================================================
// SECTION 8: OPTIONAL TIME STOP
// ============================================================================
 
maximumBarsInTrade = input.int(
     0,
     title="Time Stop Bars (0 = Off)",
     minval=0,
     maxval=500,
     group="Time Stop"
)
 
 
// ============================================================================
// SECTION 9: SESSION
// ============================================================================
 
strategyTimezone = input.string(
     "Asia/Ho_Chi_Minh",
     title="Strategy Timezone",
     group="Session"
)
 
sessionStartHour = input.int(
     9,
     title="Entry Start Hour",
     minval=0,
     maxval=23,
     group="Session"
)
 
sessionStartMinute = input.int(
     0,
     title="Entry Start Minute",
     minval=0,
     maxval=59,
     group="Session"
)
 
lastEntryHour = input.int(
     14,
     title="Last Entry Hour",
     minval=0,
     maxval=23,
     group="Session"
)
 
lastEntryMinute = input.int(
     30,
     title="Last Entry Minute",
     minval=0,
     maxval=59,
     group="Session"
)
 
sessionEndHour = input.int(
     14,
     title="Force Close Hour",
     minval=0,
     maxval=23,
     group="Session"
)
 
sessionEndMinute = input.int(
     45,
     title="Force Close Minute",
     minval=0,
     maxval=59,
     group="Session"
)
 
 
// ============================================================================
// SECTION 10: ALERT CONTROL
// ============================================================================
 
disableSLTPAlerts = input.bool(
     false,
     title="Disable SL / TP Alerts?",
     group="Alerts"
)
 
 
// ============================================================================
// SECTION 11: DISPLAY
// ============================================================================
 
showTrendEMA = input.bool(
     false,
     title="Show Trend EMA?",
     group="Display"
)
 
showImpulseMarkers = input.bool(
     false,
     title="Show Impulse Markers?",
     group="Display"
)
 
showRetestMarkers = input.bool(
     false,
     title="Show Retest Signals?",
     group="Display"
)
 
showSelectedZone = input.bool(
     false,
     title="Show Selected Signal Zone?",
     group="Display"
)
 
showActiveSLTP = input.bool(
     true,
     title="Show Active SL / TP?",
     group="Display"
)
 
showDiagnostics = input.bool(
     false,
     title="Show Diagnostics?",
     group="Display"
)
 
 
// ============================================================================
// SECTION 12: TIME ENGINE
// ============================================================================
 
int currentMinute = hour(time, strategyTimezone) * 60 + minute(time, strategyTimezone)
 
int currentCloseMinute = hour(time_close, strategyTimezone) * 60 + minute(time_close, strategyTimezone)
 
int sessionStartTotal = sessionStartHour * 60 + sessionStartMinute
 
int lastEntryTotal = lastEntryHour * 60 + lastEntryMinute
 
int sessionEndTotal = sessionEndHour * 60 + sessionEndMinute
 
bool entrySession = currentMinute >= sessionStartTotal and currentMinute <= lastEntryTotal
 
 
// ============================================================================
// SECTION 13: DAILY TRADE COUNTER
// ============================================================================
 
int dayKey = year(time, strategyTimezone) * 10000 + month(time, strategyTimezone) * 100 + dayofmonth(time, strategyTimezone)
 
bool newTradingDay = bar_index == 0 or dayKey != nz(dayKey[1], dayKey)
 
var int tradesToday = 0
 
if newTradingDay
    tradesToday := 0
 
 
// ============================================================================
// SECTION 14: POSITION STATE
// ============================================================================
 
bool flat = strategy.position_size == 0
 
bool inLong = strategy.position_size > 0
 
bool inShort = strategy.position_size < 0
 
bool newLongPosition = inLong and strategy.position_size[1] <= 0
 
bool newShortPosition = inShort and strategy.position_size[1] >= 0
 
bool positionJustClosed = flat and strategy.position_size[1] != 0
 
 
// ============================================================================
// SECTION 15: COOLDOWN / TRADE LIMIT
// ============================================================================
 
var int lastEntryBar = na
 
bool cooldownOK = na(lastEntryBar) or bar_index - lastEntryBar > cooldownBars
 
bool tradeLimitOK = maximumTradesPerDay == 0 or tradesToday < maximumTradesPerDay
 
bool commonEntryApproval = (
     flat and
     entrySession and
     currentCloseMinute < sessionEndTotal and
     cooldownOK and
     tradeLimitOK and
     barstate.isconfirmed
)
 
 
// ============================================================================
// SECTION 16: CORE CALCULATIONS
// ============================================================================
 
float atrValue = ta.atr(
     atrLength
)
 
float volumeSMA = ta.sma(
     volume,
     volumeLength
)
 
float trendEMA = ta.ema(
     close,
     trendEMALength
)
 
float candleBody = math.abs(close - open)
 
float candleRange = high - low
 
float upperWick = high - math.max(open, close)
 
float lowerWick = math.min(open, close) - low
 
 
// ============================================================================
// SECTION 17: IMPULSE DETECTION
// ============================================================================
 
float previousATR = nz(
     atrValue[1]
)
 
float previousVolumeSMA = nz(
     volumeSMA[1]
)
 
bool largeBody = candleBody >= previousATR * displacementMultiplier
 
bool largeVolume = volume >= previousVolumeSMA * impulseVolumeMultiplier
 
 
bool bullishImpulse = (
     close > open and
     largeBody and
     largeVolume and
     (
         not requireImpulseBreak or
         close > high[1]
     ) and
     (
         not requireOppositeCandle or
         close[1] < open[1]
     )
)
 
 
bool bearishImpulse = (
     close < open and
     largeBody and
     largeVolume and
     (
         not requireImpulseBreak or
         close < low[1]
     ) and
     (
         not requireOppositeCandle or
         close[1] > open[1]
     )
)
 
 
// ============================================================================
// SECTION 18: ORDER BLOCK ARRAYS
// ============================================================================
//
// Every array index represents one active Order Block.
//
// zoneTop
// zoneBottom
// zoneImpulseVolume
// zoneBornBar
// zoneBull
// zoneUsed
//
// ============================================================================
 
var array<float> zoneTop = array.new<float>()
 
var array<float> zoneBottom = array.new<float>()
 
var array<float> zoneImpulseVolume = array.new<float>()
 
var array<int> zoneBornBar = array.new<int>()
 
var array<bool> zoneBull = array.new<bool>()
 
var array<bool> zoneUsed = array.new<bool>()
 
 
// ============================================================================
// SECTION 19: SIGNAL STATE FOR CURRENT BAR
// ============================================================================
 
bool longSignal = false
 
bool shortSignal = false
 
float signalZoneTop = na
 
float signalZoneBottom = na
 
float signalImpulseVolume = na
 
int signalZoneIndex = na
 
 
// ============================================================================
// SECTION 20: MANAGE EXISTING ZONES
// ============================================================================
//
// Source logic:
//
// Bull zone dies:
//     Close < Zone Bottom
//
// Bear zone dies:
//     Close > Zone Top
//
// Any zone dies:
//     Age > Maximum Zone Age
//
// Touch:
//     High >= Bottom
//     Low <= Top
//
// Search newest zone first.
//
// ============================================================================
 
int zoneIndex = array.size(zoneTop) - 1
 
while zoneIndex >= 0
 
    float zTop = array.get(
         zoneTop,
         zoneIndex
    )
 
    float zBottom = array.get(
         zoneBottom,
         zoneIndex
    )
 
    float zImpulseVolume = array.get(
         zoneImpulseVolume,
         zoneIndex
    )
 
    int zBornBar = array.get(
         zoneBornBar,
         zoneIndex
    )
 
    bool zBull = array.get(
         zoneBull,
         zoneIndex
    )
 
    bool zUsed = array.get(
         zoneUsed,
         zoneIndex
    )
 
 
    bool zoneDead = (
         (
             zBull and
             close < zBottom
         ) or
         (
             not zBull and
             close > zTop
         ) or
         (
             bar_index - zBornBar >
             maximumZoneAge
         )
    )
 
 
    if zoneDead
 
        array.remove(
             zoneTop,
             zoneIndex
        )
 
        array.remove(
             zoneBottom,
             zoneIndex
        )
 
        array.remove(
             zoneImpulseVolume,
             zoneIndex
        )
 
        array.remove(
             zoneBornBar,
             zoneIndex
        )
 
        array.remove(
             zoneBull,
             zoneIndex
        )
 
        array.remove(
             zoneUsed,
             zoneIndex
        )
 
 
    else
 
        bool zoneTouched = (
             high >= zBottom and
             low <= zTop
        )
 
 
        bool zoneAvailable = (
             not firstTouchOnly or
             not zUsed
        )
 
 
        if (
             zoneTouched and
             commonEntryApproval and
             zoneAvailable and
             not longSignal and
             not shortSignal
        )
 
            bool retestVolumeOK = (
                 not useRetestVolumeFilter or
                 volume <=
                 zImpulseVolume *
                 retestVolumeMaximum
            )
 
 
            if zBull and allowLong
 
                bool rejectionOK = (
                     not useRejectionWick or
                     (
                         candleRange >
                         0 and
                         lowerWick /
                         candleRange *
                         100.0 >=
                         minimumWickPercent
                     )
                )
 
 
                bool trendOK = (
                     not useTrendFilter or
                     close >
                     trendEMA
                )
 
 
                bool directionCandleOK = (
                     not requireDirectionCandle or
                     close >
                     open
                )
 
 
                float candidateStop = zBottom - atrValue * zoneStopATRBuffer
 
                float candidateRisk = close - candidateStop
 
 
                bool zoneRiskOK = (
                     exitMode !=
                     "Zone RR" or
                     candidateRisk >
                     syminfo.mintick
                )
 
 
                bool longConditions = (
                     directionCandleOK and
                     close >
                     zBottom and
                     rejectionOK and
                     retestVolumeOK and
                     trendOK and
                     zoneRiskOK
                )
 
 
                if longConditions
 
                    longSignal := true
 
                    signalZoneTop := zTop
 
                    signalZoneBottom := zBottom
 
                    signalImpulseVolume := zImpulseVolume
 
                    signalZoneIndex := zoneIndex
 
 
            else if (
                 not zBull and
                 allowShort
            )
 
                bool rejectionOK = (
                     not useRejectionWick or
                     (
                         candleRange >
                         0 and
                         upperWick /
                         candleRange *
                         100.0 >=
                         minimumWickPercent
                     )
                )
 
 
                bool trendOK = (
                     not useTrendFilter or
                     close <
                     trendEMA
                )
 
 
                bool directionCandleOK = (
                     not requireDirectionCandle or
                     close <
                     open
                )
 
 
                float candidateStop = zTop + atrValue * zoneStopATRBuffer
 
                float candidateRisk = candidateStop - close
 
 
                bool zoneRiskOK = (
                     exitMode !=
                     "Zone RR" or
                     candidateRisk >
                     syminfo.mintick
                )
 
 
                bool shortConditions = (
                     directionCandleOK and
                     close <
                     zTop and
                     rejectionOK and
                     retestVolumeOK and
                     trendOK and
                     zoneRiskOK
                )
 
 
                if shortConditions
 
                    shortSignal := true
 
                    signalZoneTop := zTop
 
                    signalZoneBottom := zBottom
 
                    signalImpulseVolume := zImpulseVolume
 
                    signalZoneIndex := zoneIndex
 
 
    zoneIndex -= 1
 
 
// ============================================================================
// SECTION 21: CREATE BULLISH ORDER BLOCK
// ============================================================================
//
// A bullish impulse creates a bullish OB using the PREVIOUS candle.
//
// Full-zone default:
//     Top    = High[1]
//     Bottom = Low[1]
//
// Body-only:
//     Top    = max(Open[1], Close[1])
//     Bottom = min(Open[1], Close[1])
//
// ============================================================================
 
if (
     bar_index >
     math.max(
         atrLength,
         volumeLength
     ) +
     1 and
     bullishImpulse and
     allowLong
)
 
    float newBullTop = (
         useBodyOnlyZone
         ? math.max(
             open[1],
             close[1]
         )
         : high[1]
    )
 
 
    float newBullBottom = (
         useBodyOnlyZone
         ? math.min(
             open[1],
             close[1]
         )
         : low[1]
    )
 
 
    bool overlapsExistingBull = false
 
    int bullCheckIndex = 0
 
    while bullCheckIndex < array.size(zoneTop)
 
        bool existingBull = array.get(
             zoneBull,
             bullCheckIndex
        )
 
        float existingTop = array.get(
             zoneTop,
             bullCheckIndex
        )
 
        float existingBottom = array.get(
             zoneBottom,
             bullCheckIndex
        )
 
 
        if (
             existingBull and
             newBullTop >=
             existingBottom and
             newBullBottom <=
             existingTop
        )
 
            overlapsExistingBull := true
 
 
        bullCheckIndex += 1
 
 
    if not overlapsExistingBull
 
        array.push(
             zoneTop,
             newBullTop
        )
 
        array.push(
             zoneBottom,
             newBullBottom
        )
 
        array.push(
             zoneImpulseVolume,
             volume
        )
 
        array.push(
             zoneBornBar,
             bar_index
        )
 
        array.push(
             zoneBull,
             true
        )
 
        array.push(
             zoneUsed,
             false
        )
 
 
// ============================================================================
// SECTION 22: CREATE BEARISH ORDER BLOCK
// ============================================================================
 
if (
     bar_index >
     math.max(
         atrLength,
         volumeLength
     ) +
     1 and
     bearishImpulse and
     allowShort
)
 
    float newBearTop = (
         useBodyOnlyZone
         ? math.max(
             open[1],
             close[1]
         )
         : high[1]
    )
 
 
    float newBearBottom = (
         useBodyOnlyZone
         ? math.min(
             open[1],
             close[1]
         )
         : low[1]
    )
 
 
    bool overlapsExistingBear = false
 
    int bearCheckIndex = 0
 
    while bearCheckIndex < array.size(zoneTop)
 
        bool existingBull = array.get(
             zoneBull,
             bearCheckIndex
        )
 
        float existingTop = array.get(
             zoneTop,
             bearCheckIndex
        )
 
        float existingBottom = array.get(
             zoneBottom,
             bearCheckIndex
        )
 
 
        if (
             not existingBull and
             newBearTop >=
             existingBottom and
             newBearBottom <=
             existingTop
        )
 
            overlapsExistingBear := true
 
 
        bearCheckIndex += 1
 
 
    if not overlapsExistingBear
 
        array.push(
             zoneTop,
             newBearTop
        )
 
        array.push(
             zoneBottom,
             newBearBottom
        )
 
        array.push(
             zoneImpulseVolume,
             volume
        )
 
        array.push(
             zoneBornBar,
             bar_index
        )
 
        array.push(
             zoneBull,
             false
        )
 
        array.push(
             zoneUsed,
             false
        )
 
 
// ============================================================================
// SECTION 23: LIMIT NUMBER OF ACTIVE ZONES
// ============================================================================
 
while array.size(zoneTop) > maximumActiveZones
 
    array.shift(
         zoneTop
    )
 
    array.shift(
         zoneBottom
    )
 
    array.shift(
         zoneImpulseVolume
    )
 
    array.shift(
         zoneBornBar
    )
 
    array.shift(
         zoneBull
    )
 
    array.shift(
         zoneUsed
    )
 
 
// ============================================================================
// SECTION 24: FINAL SIGNALS
// ============================================================================
//
// Only one signal can be selected because zones were scanned newest-first.
//
// ============================================================================
 
bool finalLongSignal = longSignal and not shortSignal
 
bool finalShortSignal = shortSignal and not longSignal
 
 
// ============================================================================
// SECTION 25: PENDING SOURCE-STYLE STOPS
// ============================================================================
 
var float pendingLongZoneStop = na
 
var float pendingShortZoneStop = na
 
 
// ============================================================================
// SECTION 26: LONG ENTRY
// ============================================================================
 
if finalLongSignal
 
    if exitMode == "Zone RR"
 
        pendingLongZoneStop := signalZoneBottom - atrValue * zoneStopATRBuffer
 
    else
 
        pendingLongZoneStop := na
 
 
    strategy.entry(
         "Long",
         strategy.long,
         qty=3,
         comment="VOB Retest Long",
         alert_message="ENTRY_LONG_CNPS23"
    )
 
 
    if (
         firstTouchOnly and
         not na(signalZoneIndex) and
         signalZoneIndex >=
         0 and
         signalZoneIndex <
         array.size(zoneUsed)
    )
 
        array.set(
             zoneUsed,
             signalZoneIndex,
             true
        )
 
 
    lastEntryBar := bar_index
 
    tradesToday += 1
 
 
// ============================================================================
// SECTION 27: SHORT ENTRY
// ============================================================================
 
if finalShortSignal
 
    if exitMode == "Zone RR"
 
        pendingShortZoneStop := signalZoneTop + atrValue * zoneStopATRBuffer
 
    else
 
        pendingShortZoneStop := na
 
 
    strategy.entry(
         "Short",
         strategy.short,
         qty=3,
         comment="VOB Retest Short",
         alert_message="ENTRY_SHORT_CNPS23"
    )
 
 
    if (
         firstTouchOnly and
         not na(signalZoneIndex) and
         signalZoneIndex >=
         0 and
         signalZoneIndex <
         array.size(zoneUsed)
    )
 
        array.set(
             zoneUsed,
             signalZoneIndex,
             true
        )
 
 
    lastEntryBar := bar_index
 
    tradesToday += 1
 
 
// ============================================================================
// SECTION 28: ACTIVE TRADE STATE
// ============================================================================
 
var float activeEntryPrice = na
 
var float activeInitialRisk = na
 
var float activeLongSL = na
 
var float activeLongTP = na
 
var float activeShortSL = na
 
var float activeShortTP = na
 
var bool breakEvenActivated = false
 
var int activeEntryBar = na
 
 
// ============================================================================
// SECTION 29: INITIALIZE LONG EXIT
// ============================================================================
 
if newLongPosition
 
    activeEntryPrice := strategy.position_avg_price
 
 
    if exitMode == "Zone RR"
 
        float sourceLongRisk = activeEntryPrice - pendingLongZoneStop
 
        if (
             na(sourceLongRisk) or
             sourceLongRisk <=
             syminfo.mintick
        )
 
            sourceLongRisk := stopLossPoints
 
 
        activeInitialRisk := sourceLongRisk
 
        activeLongSL := activeEntryPrice - activeInitialRisk
 
        activeLongTP := activeEntryPrice + activeInitialRisk * zoneRewardRisk
 
 
    else
 
        activeInitialRisk := stopLossPoints
 
        activeLongSL := activeEntryPrice - stopLossPoints
 
        activeLongTP := activeEntryPrice + takeProfitPoints
 
 
    activeShortSL := na
 
    activeShortTP := na
 
    breakEvenActivated := false
 
    activeEntryBar := bar_index
 
    pendingLongZoneStop := na
 
 
// ============================================================================
// SECTION 30: INITIALIZE SHORT EXIT
// ============================================================================
 
if newShortPosition
 
    activeEntryPrice := strategy.position_avg_price
 
 
    if exitMode == "Zone RR"
 
        float sourceShortRisk = pendingShortZoneStop - activeEntryPrice
 
        if (
             na(sourceShortRisk) or
             sourceShortRisk <=
             syminfo.mintick
        )
 
            sourceShortRisk := stopLossPoints
 
 
        activeInitialRisk := sourceShortRisk
 
        activeShortSL := activeEntryPrice + activeInitialRisk
 
        activeShortTP := activeEntryPrice - activeInitialRisk * zoneRewardRisk
 
 
    else
 
        activeInitialRisk := stopLossPoints
 
        activeShortSL := activeEntryPrice + stopLossPoints
 
        activeShortTP := activeEntryPrice - takeProfitPoints
 
 
    activeLongSL := na
 
    activeLongTP := na
 
    breakEvenActivated := false
 
    activeEntryBar := bar_index
 
    pendingShortZoneStop := na
 
 
// ============================================================================
// SECTION 31: LONG BREAK EVEN
// ============================================================================
 
if (
     inLong and
     useBreakEven and
     not breakEvenActivated and
     not na(activeEntryPrice) and
     not na(activeInitialRisk) and
     activeInitialRisk >
     0
)
 
    float longBreakEvenTrigger = activeEntryPrice + activeInitialRisk * breakEvenTriggerR
 
 
    if high >= longBreakEvenTrigger
 
        float newLongStop = activeEntryPrice + breakEvenOffsetPoints
 
 
        if (
             na(activeLongSL) or
             newLongStop >
             activeLongSL
        )
 
            activeLongSL := newLongStop
 
 
        breakEvenActivated := true
 
 
// ============================================================================
// SECTION 32: SHORT BREAK EVEN
// ============================================================================
 
if (
     inShort and
     useBreakEven and
     not breakEvenActivated and
     not na(activeEntryPrice) and
     not na(activeInitialRisk) and
     activeInitialRisk >
     0
)
 
    float shortBreakEvenTrigger = activeEntryPrice - activeInitialRisk * breakEvenTriggerR
 
 
    if low <= shortBreakEvenTrigger
 
        float newShortStop = activeEntryPrice - breakEvenOffsetPoints
 
 
        if (
             na(activeShortSL) or
             newShortStop <
             activeShortSL
        )
 
            activeShortSL := newShortStop
 
 
        breakEvenActivated := true
 
 
// ============================================================================
// SECTION 33: LONG EXIT
// ============================================================================
 
if (
     inLong and
     not na(activeLongSL) and
     not na(activeLongTP)
)
 
    strategy.exit(
         "Long Exit",
         from_entry="Long",
         stop=activeLongSL,
         limit=activeLongTP,
         alert_profit="EXIT_LONG_TP_CNPS23",
         alert_loss="EXIT_LONG_SL_CNPS23",
         disable_alert=disableSLTPAlerts
    )
 
 
// ============================================================================
// SECTION 34: SHORT EXIT
// ============================================================================
 
if (
     inShort and
     not na(activeShortSL) and
     not na(activeShortTP)
)
 
    strategy.exit(
         "Short Exit",
         from_entry="Short",
         stop=activeShortSL,
         limit=activeShortTP,
         alert_profit="EXIT_SHORT_TP_CNPS23",
         alert_loss="EXIT_SHORT_SL_CNPS23",
         disable_alert=disableSLTPAlerts
    )
 
 
// ============================================================================
// SECTION 35: OPTIONAL TIME STOP
// ============================================================================
 
int barsInTrade = 0
 
if (
     not flat and
     not na(activeEntryBar)
)
 
    barsInTrade := bar_index - activeEntryBar
 
 
bool longTimeStop = (
     inLong and
     maximumBarsInTrade >
     0 and
     barsInTrade >=
     maximumBarsInTrade
)
 
bool shortTimeStop = (
     inShort and
     maximumBarsInTrade >
     0 and
     barsInTrade >=
     maximumBarsInTrade
)
 
 
if longTimeStop
 
    strategy.close(
         "Long",
         comment="Time Stop Long",
         alert_message="TIME_EXIT_LONG_CNPS23"
    )
 
 
if shortTimeStop
 
    strategy.close(
         "Short",
         comment="Time Stop Short",
         alert_message="TIME_EXIT_SHORT_CNPS23"
    )
 
 
// ============================================================================
// SECTION 36: POSITION CLEANUP
// ============================================================================
 
if positionJustClosed
 
    activeEntryPrice := na
 
    activeInitialRisk := na
 
    activeLongSL := na
 
    activeLongTP := na
 
    activeShortSL := na
 
    activeShortTP := na
 
    breakEvenActivated := false
 
    activeEntryBar := na
 
 
// ============================================================================
// SECTION 37: SESSION END
// ============================================================================
 
bool finalSessionBar = currentMinute < sessionEndTotal and currentCloseMinute >= sessionEndTotal
 
 
if finalSessionBar
 
    if strategy.position_size != 0
 
        strategy.close_all(
             immediately=true,
             comment="Session End",
             alert_message="SESSION_END_CNPS23"
        )
 
 
// ============================================================================
// SECTION 38: TREND EMA DISPLAY
// ============================================================================
 
plot(
     showTrendEMA and useTrendFilter
     ? trendEMA
     : na,
     title="Trend EMA",
     color=color.gray,
     linewidth=1
)
 
 
// ============================================================================
// SECTION 39: IMPULSE MARKERS
// ============================================================================
 
plotshape(
     showImpulseMarkers and bullishImpulse,
     title="Bullish Impulse",
     style=shape.triangleup,
     location=location.belowbar,
     color=color.teal,
     size=size.tiny,
     text="I"
)
 
plotshape(
     showImpulseMarkers and bearishImpulse,
     title="Bearish Impulse",
     style=shape.triangledown,
     location=location.abovebar,
     color=color.red,
     size=size.tiny,
     text="I"
)
 
 
// ============================================================================
// SECTION 40: RETEST SIGNAL MARKERS
// ============================================================================
 
plotshape(
     showRetestMarkers and finalLongSignal,
     title="Long Retest",
     style=shape.triangleup,
     location=location.belowbar,
     color=color.green,
     size=size.small,
     text="L",
     textcolor=color.white
)
 
plotshape(
     showRetestMarkers and finalShortSignal,
     title="Short Retest",
     style=shape.triangledown,
     location=location.abovebar,
     color=color.red,
     size=size.small,
     text="S",
     textcolor=color.white
)
 
 
// ============================================================================
// SECTION 41: SELECTED SIGNAL ZONE
// ============================================================================
 
plot(
     showSelectedZone
     ? signalZoneTop
     : na,
     title="Signal Zone Top",
     color=color.new(color.orange, 30),
     linewidth=1,
     style=plot.style_linebr
)
 
plot(
     showSelectedZone
     ? signalZoneBottom
     : na,
     title="Signal Zone Bottom",
     color=color.new(color.orange, 30),
     linewidth=1,
     style=plot.style_linebr
)
 
 
// ============================================================================
// SECTION 42: ACTIVE SL / TP
// ============================================================================
 
plot(
     showActiveSLTP and inLong
     ? activeLongSL
     : na,
     title="Long SL",
     color=color.red,
     linewidth=2,
     style=plot.style_linebr
)
 
plot(
     showActiveSLTP and inLong
     ? activeLongTP
     : na,
     title="Long TP",
     color=color.green,
     linewidth=2,
     style=plot.style_linebr
)
 
plot(
     showActiveSLTP and inShort
     ? activeShortSL
     : na,
     title="Short SL",
     color=color.red,
     linewidth=2,
     style=plot.style_linebr
)
 
plot(
     showActiveSLTP and inShort
     ? activeShortTP
     : na,
     title="Short TP",
     color=color.green,
     linewidth=2,
     style=plot.style_linebr
)
 
 
// ============================================================================
// SECTION 43: DIAGNOSTIC COUNTERS
// ============================================================================
 
var int bullishImpulseCount = 0
 
var int bearishImpulseCount = 0
 
var int longSignalCount = 0
 
var int shortSignalCount = 0
 
var int longEntryCount = 0
 
var int shortEntryCount = 0
 
 
if bullishImpulse
    bullishImpulseCount += 1
 
 
if bearishImpulse
    bearishImpulseCount += 1
 
 
if longSignal
    longSignalCount += 1
 
 
if shortSignal
    shortSignalCount += 1
 
 
if finalLongSignal
    longEntryCount += 1
 
 
if finalShortSignal
    shortEntryCount += 1
 
 
// ============================================================================
// SECTION 44: DIAGNOSTICS
// ============================================================================
 
var table diagnostics = table.new(
     position.top_right,
     2,
     16,
     border_width=1
)
 
 
if showDiagnostics and barstate.islast
 
    string positionText = "FLAT"
 
    if inLong
        positionText := "LONG"
 
    else if inShort
        positionText := "SHORT"
 
 
    table.cell(
         diagnostics,
         0,
         0,
         "CNPS23"
    )
 
    table.cell(
         diagnostics,
         1,
         0,
         timeframe.period
    )
 
 
    table.cell(
         diagnostics,
         0,
         1,
         "Active Zones"
    )
 
    table.cell(
         diagnostics,
         1,
         1,
         str.tostring(
             array.size(zoneTop)
         )
    )
 
 
    table.cell(
         diagnostics,
         0,
         2,
         "Bull Impulse"
    )
 
    table.cell(
         diagnostics,
         1,
         2,
         str.tostring(
             bullishImpulseCount
         )
    )
 
 
    table.cell(
         diagnostics,
         0,
         3,
         "Bear Impulse"
    )
 
    table.cell(
         diagnostics,
         1,
         3,
         str.tostring(
             bearishImpulseCount
         )
    )
 
 
    table.cell(
         diagnostics,
         0,
         4,
         "Long Retests"
    )
 
    table.cell(
         diagnostics,
         1,
         4,
         str.tostring(
             longSignalCount
         )
    )
 
 
    table.cell(
         diagnostics,
         0,
         5,
         "Short Retests"
    )
 
    table.cell(
         diagnostics,
         1,
         5,
         str.tostring(
             shortSignalCount
         )
    )
 
 
    table.cell(
         diagnostics,
         0,
         6,
         "Long Entries"
    )
 
    table.cell(
         diagnostics,
         1,
         6,
         str.tostring(
             longEntryCount
         )
    )
 
 
    table.cell(
         diagnostics,
         0,
         7,
         "Short Entries"
    )
 
    table.cell(
         diagnostics,
         1,
         7,
         str.tostring(
             shortEntryCount
         )
    )
 
 
    table.cell(
         diagnostics,
         0,
         8,
         "ATR"
    )
 
    table.cell(
         diagnostics,
         1,
         8,
         str.tostring(
             atrValue,
             "0.00"
         )
    )
 
 
    table.cell(
         diagnostics,
         0,
         9,
         "Volume / SMA"
    )
 
    float volumeRatio = 0.0
 
    if volumeSMA > 0
        volumeRatio := volume / volumeSMA
 
 
    table.cell(
         diagnostics,
         1,
         9,
         str.tostring(
             volumeRatio,
             "0.00"
         )
    )
 
 
    table.cell(
         diagnostics,
         0,
         10,
         "Bull Impulse Now"
    )
 
    table.cell(
         diagnostics,
         1,
         10,
         bullishImpulse
         ? "YES"
         : "NO"
    )
 
 
    table.cell(
         diagnostics,
         0,
         11,
         "Bear Impulse Now"
    )
 
    table.cell(
         diagnostics,
         1,
         11,
         bearishImpulse
         ? "YES"
         : "NO"
    )
 
 
    table.cell(
         diagnostics,
         0,
         12,
         "Exit Mode"
    )
 
    table.cell(
         diagnostics,
         1,
         12,
         exitMode
    )
 
 
    table.cell(
         diagnostics,
         0,
         13,
         "Trades Today"
    )
 
    table.cell(
         diagnostics,
         1,
         13,
         str.tostring(
             tradesToday
         )
    )
 
 
    table.cell(
         diagnostics,
         0,
         14,
         "Bars In Trade"
    )
 
    table.cell(
         diagnostics,
         1,
         14,
         str.tostring(
             barsInTrade
         )
    )
 
 
    table.cell(
         diagnostics,
         0,
         15,
         "Position"
    )
 
    table.cell(
         diagnostics,
         1,
         15,
         positionText
    )

← 返回列表