本页源码来自 TradingView 公开发布的开源脚本,版权归原作者所有, 请遵循其原始许可(Pine 脚本常见 CC BY-NC-SA / MPL-2.0 / MIT)。 本项目仅用于研究检索与许可范围内的移植。
// This Pine Script® code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © officialjackofalltrades
//@version=6
indicator("Opening Range Breakout Session Strategy [JOAT]", "ORB Session [JOAT]", overlay = true, max_labels_count = 500, max_lines_count = 500, max_boxes_count = 500)
// ─────────────────────────────────────────────────────────────────────────
// PALETTE (clean black & white / grey — one faint red, one faint green)
// ─────────────────────────────────────────────────────────────────────────
WHITE = #F5F7FA
LGREY = #C7CDD6
MGREY = #8A93A3
INK = #14181F
GRN = #4E8C6A // restrained, muted green (reward only)
RED = #B5595E // restrained, muted red (risk only)
// ─────────────────────────────────────────────────────────────────────────
// INPUTS
// ─────────────────────────────────────────────────────────────────────────
gS = "Sessions"
orbSess = input.session("0930-1000", "Opening Range window", group = gS, tooltip = "The early window whose high/low form the Opening Range.")
tradeSess= input.session("1000-1600", "Trade session window", group = gS, tooltip = "Signals are only permitted inside this window.")
tz = input.string("America/New_York", "Timezone", options = ["America/New_York","America/Chicago","America/Los_Angeles","Europe/London","Europe/Berlin","Asia/Tokyo","Asia/Shanghai","Asia/Kolkata","Australia/Sydney","UTC"], group = gS)
gR = "Risk / Targets"
atrLen = input.int(14, "ATR length", minval = 1, group = gR)
useAtrSL = input.bool(false, "SL from ATR (else opposite OR edge)", group = gR, tooltip = "On: stop is ATR×mult from entry. Off: stop is the opposite Opening Range edge.")
slMult = input.float(1.0, "SL = ATR ×", minval = 0.1, step = 0.1, group = gR)
buffMult = input.float(0.10,"Breakout buffer = ATR ×", minval = 0.0, step = 0.05, group = gR, tooltip = "Small cushion beyond the OR edge required to confirm a break.")
tp1R = input.float(1.0, "TP1 (R)", step = 0.5, group = gR)
tp2R = input.float(2.0, "TP2 (R)", step = 0.5, group = gR)
tp3R = input.float(3.0, "TP3 (R)", step = 0.5, group = gR)
maxTrades= input.int(2, "Max trades / day", minval = 1, maxval = 10, group = gR)
gV = "Visuals"
showBox = input.bool(true, "Opening Range box", group = gV)
showLevels=input.bool(true, "ORH / ORL extended lines", group = gV)
showTargets=input.bool(true,"1R / 2R extension targets", group = gV)
showRR = input.bool(true, "TP/SL box on signal", group = gV)
paintBars= input.bool(true, "Monochrome candle paint", group = gV, tooltip = "White up bars, grey down bars.")
shadeORB = input.bool(true, "Shade opening-range window", group = gV)
boxExtend= input.int(20, "Signal box width (bars)", minval = 5, maxval = 100, group = gV)
gP = "Dashboard"
showHUD = input.bool(true, "Show dashboard", group = gP)
hudPos = input.string("Top Right","Position", options = ["Top Right","Top Left","Bottom Right","Bottom Left","Middle Right"], group = gP)
// ─────────────────────────────────────────────────────────────────────────
// HELPERS
// ─────────────────────────────────────────────────────────────────────────
f_pos(string s) =>
switch s
"Top Right" => position.top_right
"Top Left" => position.top_left
"Bottom Right" => position.bottom_right
"Bottom Left" => position.bottom_left
=> position.middle_right
// compact 5-segment DASH meter — filled ▬ vs empty ▭
f_dash(float p01) =>
n = math.round(math.max(0.0, math.min(1.0, p01)) * 5)
out = ""
for i = 1 to 5
out := out + (i <= n ? "▬" : "▭")
out
// ─────────────────────────────────────────────────────────────────────────
// SESSION STATE
// ─────────────────────────────────────────────────────────────────────────
atr = ta.atr(atrLen)
inOrb = not na(time(timeframe.period, orbSess, tz))
inTrade = not na(time(timeframe.period, tradeSess, tz))
orbStart = inOrb and not inOrb[1] // first bar of the OR window
orbEnd = not inOrb and inOrb[1] // first bar after window closes
newDay = timeframe.change("D")
// ─────────────────────────────────────────────────────────────────────────
// OPENING RANGE (build during window, lock when it ends)
// ─────────────────────────────────────────────────────────────────────────
var float orH = na
var float orL = na
var bool orLock = false
if orbStart
orH := high
orL := low
orLock := false
else if inOrb
orH := math.max(nz(orH, high), high)
orL := math.min(nz(orL, low), low)
if orbEnd
orLock := true
if newDay and not inOrb
// fresh day before the window opens — clear the stale range
orLock := false
orValid = orLock and not na(orH) and not na(orL)
orMid = orValid ? (orH + orL) / 2 : na
orRange = orValid ? orH - orL : na
// R-extension targets projected from the range edges
tgtUp1 = orValid ? orH + nz(orRange) * tp1R : na
tgtUp2 = orValid ? orH + nz(orRange) * tp2R : na
tgtDn1 = orValid ? orL - nz(orRange) * tp1R : na
tgtDn2 = orValid ? orL - nz(orRange) * tp2R : na
// ─────────────────────────────────────────────────────────────────────────
// BREAKOUT SIGNALS (trade session only, capped per day)
// ─────────────────────────────────────────────────────────────────────────
var int tradesToday = 0
if newDay
tradesToday := 0
buffer = atr * buffMult
crossUp = orValid and inTrade and close > orH + buffer and close[1] <= orH[1] + buffer
crossDn = orValid and inTrade and close < orL - buffer and close[1] >= orL[1] - buffer
canTrade = tradesToday < maxTrades
buy = crossUp and canTrade
sell = crossDn and canTrade
sig = buy or sell
// ── signal debounce — Buy/Sell can never stack on any timeframe
minGap = input.int(5, "Min bars between signals", minval = 0, group = "Signals", tooltip = "Minimum bar spacing between printed signals so labels never overlap on lower timeframes. 0 = off.")
var int lastSigBar = na
okGap = na(lastSigBar) or (bar_index - lastSigBar) >= minGap
buy := buy and okGap
sell := sell and okGap
sig := buy or sell
if sig
lastSigBar := bar_index
if sig
tradesToday += 1
bias = orValid ? (close > orH ? 1 : close < orL ? -1 : 0) : 0
// ─────────────────────────────────────────────────────────────────────────
// LIVE STATS (resolve open trade before arming a new one — no lookahead)
// ─────────────────────────────────────────────────────────────────────────
var float sEntry = na
var float sSL = na
var float sT1 = na
var int sDir = 0
var bool sOpen = false
var int wins = 0
var int losses = 0
if sOpen
if sDir == 1
if high >= sT1
wins += 1
sOpen := false
else if low <= sSL
losses += 1
sOpen := false
else
if low <= sT1
wins += 1
sOpen := false
else if high >= sSL
losses += 1
sOpen := false
// ─────────────────────────────────────────────────────────────────────────
// TP/SL BOX (single active, redrawn per signal)
// ─────────────────────────────────────────────────────────────────────────
var box slBox = na // red RISK box (entry → SL)
var box tpBox = na // green REWARD box (entry → TP3)
var line lnE = na // solid ENTRY line
var line lnS = na // dashed SL line (risk-box floor)
var line ln1 = na // TP1 divider across reward box
var line ln2 = na // TP2 divider across reward box
var label lbE = na
var label lbS = na
var label lb1 = na
var label lb2 = na
var label lb3 = na
f_setLbl(label lb, float p, string txt) =>
label.set_xy(lb, bar_index + boxExtend, p)
label.set_text(lb, txt)
if sig
if sOpen
losses += 1
sOpen := false
entry = close
risk = useAtrSL ? atr * slMult : (buy ? entry - orL : orH - entry)
risk := risk <= 0 ? atr * slMult : risk // guard degenerate range
sl = buy ? entry - risk : entry + risk
t1 = buy ? entry + risk * tp1R : entry - risk * tp1R
t2 = buy ? entry + risk * tp2R : entry - risk * tp2R
t3 = buy ? entry + risk * tp3R : entry - risk * tp3R
sDir := buy ? 1 : -1
sEntry:= entry
sSL := sl
sT1 := t1
sOpen := true
if showRR
rx = bar_index + boxExtend
box.delete(slBox)
box.delete(tpBox)
// red RISK box: entry → SL | green REWARD box: entry → TP3
slBox := box.new(bar_index, entry, rx, sl, border_color = color.new(RED, 35), border_width = 1, bgcolor = color.new(RED, 91))
tpBox := box.new(bar_index, entry, rx, t3, border_color = color.new(GRN, 35), border_width = 1, bgcolor = color.new(GRN, 92))
if na(lbE)
lnE := line.new(bar_index, entry, rx, entry, color = INK, width = 1, style = line.style_solid)
lnS := line.new(bar_index, sl, rx, sl, color = color.new(RED, 25), width = 1, style = line.style_dashed)
ln1 := line.new(bar_index, t1, rx, t1, color = color.new(GRN, 40), width = 1, style = line.style_dotted)
ln2 := line.new(bar_index, t2, rx, t2, color = color.new(GRN, 40), width = 1, style = line.style_dotted)
lbE := label.new(rx, entry, "", style = label.style_label_left, color = WHITE, textcolor = INK, size = size.small)
lbS := label.new(rx, sl, "", style = label.style_label_left, color = WHITE, textcolor = INK, size = size.small)
lb1 := label.new(rx, t1, "", style = label.style_label_left, color = WHITE, textcolor = INK, size = size.small)
lb2 := label.new(rx, t2, "", style = label.style_label_left, color = WHITE, textcolor = INK, size = size.small)
lb3 := label.new(rx, t3, "", style = label.style_label_left, color = WHITE, textcolor = INK, size = size.small)
line.set_xy1(lnE, bar_index, entry)
line.set_xy2(lnE, rx, entry)
line.set_xy1(lnS, bar_index, sl)
line.set_xy2(lnS, rx, sl)
line.set_xy1(ln1, bar_index, t1)
line.set_xy2(ln1, rx, t1)
line.set_xy1(ln2, bar_index, t2)
line.set_xy2(ln2, rx, t2)
f_setLbl(lbE, entry, " ENTRY " + str.tostring(entry, format.mintick))
f_setLbl(lbS, sl, " SL " + str.tostring(sl, format.mintick))
f_setLbl(lb1, t1, " TP1 · " + str.tostring(tp1R, "#.#") + "R " + str.tostring(t1, format.mintick))
f_setLbl(lb2, t2, " TP2 · " + str.tostring(tp2R, "#.#") + "R " + str.tostring(t2, format.mintick))
f_setLbl(lb3, t3, " TP3 · " + str.tostring(tp3R, "#.#") + "R " + str.tostring(t3, format.mintick))
// keep the active trade box/labels pinned to the right edge while price develops
if showRR and sOpen and not na(slBox) and barstate.islast
rx2 = bar_index + boxExtend
box.set_right(slBox, rx2)
box.set_right(tpBox, rx2)
line.set_x2(lnE, rx2)
line.set_x2(lnS, rx2)
line.set_x2(ln1, rx2)
line.set_x2(ln2, rx2)
label.set_x(lbE, rx2)
label.set_x(lbS, rx2)
label.set_x(lb1, rx2)
label.set_x(lb2, rx2)
label.set_x(lb3, rx2)
resolved = wins + losses
winRate = resolved > 0 ? wins / resolved * 100.0 : na
// ─────────────────────────────────────────────────────────────────────────
// OPENING-RANGE BOX (clean: light fill, thin near-black border)
// ─────────────────────────────────────────────────────────────────────────
var box orBox = na
if orbEnd and showBox
orBox := box.new(bar_index, orH, bar_index + boxExtend, orL, border_color = color.new(INK, 25), border_width = 1, bgcolor = color.new(LGREY, 88))
if showBox and orValid and not na(orBox) and barstate.islast
box.set_right(orBox, bar_index + boxExtend)
// small clean ORH / ORL labels riding the right edge of the range
var label orhLbl = na
var label orlLbl = na
if showLevels and orValid and barstate.islast
if na(orhLbl)
orhLbl := label.new(bar_index + boxExtend, orH, "", style = label.style_label_left, color = WHITE, textcolor = INK, size = size.small)
orlLbl := label.new(bar_index + boxExtend, orL, "", style = label.style_label_left, color = WHITE, textcolor = INK, size = size.small)
label.set_xy(orhLbl, bar_index + boxExtend, orH)
label.set_text(orhLbl, " ORH " + str.tostring(orH, format.mintick))
label.set_xy(orlLbl, bar_index + boxExtend, orL)
label.set_text(orlLbl, " ORL " + str.tostring(orL, format.mintick))
// ─────────────────────────────────────────────────────────────────────────
// PLOTS
// ─────────────────────────────────────────────────────────────────────────
plotLevels = showLevels and orValid
plot(plotLevels ? orH : na, "ORH", color = color.new(INK, 0), linewidth = 1, style = plot.style_linebr)
plot(plotLevels ? orL : na, "ORL", color = color.new(INK, 0), linewidth = 1, style = plot.style_linebr)
plot(plotLevels ? orMid : na, "OR Mid", color = color.new(MGREY, 20), linewidth = 1, style = plot.style_linebr)
plotTgt = showTargets and orValid
plot(plotTgt ? tgtUp1 : na, "Up 1R", color = color.new(MGREY, 45), linewidth = 1, style = plot.style_linebr)
plot(plotTgt ? tgtUp2 : na, "Up 2R", color = color.new(LGREY, 40), linewidth = 1, style = plot.style_linebr)
plot(plotTgt ? tgtDn1 : na, "Dn 1R", color = color.new(MGREY, 45), linewidth = 1, style = plot.style_linebr)
plot(plotTgt ? tgtDn2 : na, "Dn 2R", color = color.new(LGREY, 40), linewidth = 1, style = plot.style_linebr)
// monochrome candle paint
paintCol = close >= open ? WHITE : MGREY
barcolor(paintBars ? paintCol : na, title = "Monochrome candles")
// subtle grey shading during the OR window only
bgcolor(shadeORB and inOrb ? color.new(MGREY, 92) : na, title = "OR window shade")
// clean breakout markers (monochrome)
plotshape(buy, "BUY", style = shape.triangleup, location = location.belowbar, color = INK, size = size.tiny)
plotshape(sell, "SELL", style = shape.triangledown, location = location.abovebar, color = MGREY, size = size.tiny)
// ─────────────────────────────────────────────────────────────────────────
// DASHBOARD (understated: white/grey surfaces, near-black text)
// ─────────────────────────────────────────────────────────────────────────
// dashboard is fully adjustable — reposition (hudPos) and resize text (hudSize)
hudSize = input.string("Normal", "Dashboard text size", options = ["Tiny", "Small", "Normal", "Large"], group = "Dashboard")
hudTS = hudSize == "Tiny" ? size.tiny : hudSize == "Small" ? size.small : hudSize == "Large" ? size.large : size.normal
var table hud = na
if showHUD and barstate.islast
if not na(hud)
table.delete(hud)
hud := table.new(f_pos(hudPos), 2, 7, bgcolor = color.new(WHITE, 6), frame_color = color.new(INK, 40), frame_width = 1, border_color = color.new(LGREY, 40), border_width = 1)
SURF = color.new(WHITE, 6)
HEADR = color.new(LGREY, 22) // grey header / footer strip
BADGE = color.new(MGREY, 12) // session-phase badge cell
// session phase → short badge label
phaseT = inOrb ? "OPENING" : orValid ? (inTrade ? "SESSION" : "LOCKED") : "PRE-OPEN"
rangeT = orValid ? str.tostring(orRange, format.mintick) : "—"
biasT = bias == 1 ? "Above OR ▲" : bias == -1 ? "Below OR ▼" : "Inside range"
biasC = bias == 1 ? INK : MGREY
// breakout extension = how far price has pushed past the OR mid (in range units)
brkP = orValid and not na(orRange) and orRange > 0 ? math.min(1.0, math.abs(close - orMid) / orRange) : 0.0
brkT = f_dash(brkP)
sigT = buy ? "BUY — break ▲" : sell ? "SELL — break ▼" : inTrade and orValid ? "Watching" : "—"
sigC = buy ? INK : MGREY
tradeT = str.tostring(tradesToday) + " / " + str.tostring(maxTrades)
tradeC = tradesToday >= maxTrades ? MGREY : INK
wrT = na(winRate) ? "—" : str.tostring(math.round(winRate)) + "% (" + str.tostring(resolved) + ")"
// ── header strip: ticket title + session-phase badge ──
table.cell(hud, 0, 0, " ▸ ORB TICKET", text_color = INK, text_halign = text.align_left, bgcolor = HEADR, text_size = hudTS)
table.cell(hud, 1, 0, phaseT + " ", text_color = INK, text_halign = text.align_right, bgcolor = BADGE, text_size = hudTS)
// ── body ──
table.cell(hud, 0, 1, " Bias", text_color = MGREY, text_halign = text.align_left, bgcolor = SURF, text_size = hudTS)
table.cell(hud, 1, 1, biasT + " ", text_color = biasC, text_halign = text.align_right, bgcolor = SURF, text_size = hudTS)
table.cell(hud, 0, 2, " OR range", text_color = MGREY, text_halign = text.align_left, bgcolor = SURF, text_size = hudTS)
table.cell(hud, 1, 2, rangeT + " ", text_color = INK, text_halign = text.align_right, bgcolor = SURF, text_size = hudTS)
table.cell(hud, 0, 3, " Breakout", text_color = MGREY, text_halign = text.align_left, bgcolor = SURF, text_size = hudTS)
table.cell(hud, 1, 3, brkT + " ", text_color = INK, text_halign = text.align_right, bgcolor = SURF, text_size = hudTS)
table.cell(hud, 0, 4, " Signal", text_color = MGREY, text_halign = text.align_left, bgcolor = SURF, text_size = hudTS)
table.cell(hud, 1, 4, sigT + " ", text_color = sigC, text_halign = text.align_right, bgcolor = SURF, text_size = hudTS)
table.cell(hud, 0, 5, " Trades", text_color = MGREY, text_halign = text.align_left, bgcolor = SURF, text_size = hudTS)
table.cell(hud, 1, 5, tradeT + " ", text_color = tradeC, text_halign = text.align_right, bgcolor = SURF, text_size = hudTS)
// ── footer strip: live win-rate ──
table.cell(hud, 0, 6, " Win (TP1)", text_color = INK, text_halign = text.align_left, bgcolor = HEADR, text_size = hudTS)
table.cell(hud, 1, 6, wrT + " ", text_color = INK, text_halign = text.align_right, bgcolor = HEADR, text_size = hudTS)
// ─────────────────────────────────────────────────────────────────────────
// ALERTS
// ─────────────────────────────────────────────────────────────────────────
alertcondition(buy, "Buy", "ORB Session: bullish breakout above the Opening Range high")
alertcondition(sell, "Sell", "ORB Session: bearish breakdown below the Opening Range low")
alertcondition(sig, "Any signal", "ORB Session: Opening Range breakout signal")
alertcondition(orbEnd, "OR locked", "ORB Session: Opening Range window has closed and locked")