Opening Range & Session Breakouts [CandleChasers]

CandleChasers · study · 524 行 · 点赞 12 · TradingView 原页

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

Pine Script

//@version=6
// Opening Range & Session Breakouts [CandleChasers] | 1.1
// Closed-candle pattern notifications; no orders or performance claims.
indicator("Opening Range & Session Breakouts [CandleChasers]",shorttitle="[CC] ORB",overlay=true,scale=scale.none,max_boxes_count=60,max_lines_count=450,max_labels_count=200,max_bars_back=500)
 
string GS="1 · Sessions (local IANA timezones)"
bool useNY=input.bool(true,"New York · 09:30–16:00",group=GS,display=display.none)
bool useLondon=input.bool(false,"London · 08:00–16:30",group=GS,display=display.none)
bool useTokyo=input.bool(false,"Tokyo · 09:00–15:00",group=GS,display=display.none)
bool useCustom=input.bool(false,"Enable custom session",group=GS,display=display.none)
string customHours=input.session("1700-1600","Custom session hours",group=GS,display=display.none)
string timezoneChoice=input.string("Chicago","Custom session timezone",options=["Exchange timezone","UTC","New York / Toronto","Chicago","Denver","Los Angeles","London","Paris / Berlin","Dubai","India","Singapore / Hong Kong","Tokyo","Sydney","Auckland","Custom IANA"],tooltip="Session hours use this timezone. Regional choices follow local daylight-saving rules. Exchange timezone uses the symbol exchange, not the chart display timezone. Choose Custom IANA to enter another location.",group=GS,display=display.none)
string timezoneIANA=input.string("America/Chicago","Custom IANA timezone (only for Custom IANA)",tooltip="Used only when Custom session timezone is Custom IANA. Example: America/Toronto.",group=GS,display=display.none)
string customZone=switch timezoneChoice
    "Exchange timezone" => syminfo.timezone
    "UTC" => "Etc/UTC"
    "New York / Toronto" => "America/New_York"
    "Chicago" => "America/Chicago"
    "Denver" => "America/Denver"
    "Los Angeles" => "America/Los_Angeles"
    "London" => "Europe/London"
    "Paris / Berlin" => "Europe/Paris"
    "Dubai" => "Asia/Dubai"
    "India" => "Asia/Kolkata"
    "Singapore / Hong Kong" => "Asia/Singapore"
    "Tokyo" => "Asia/Tokyo"
    "Sydney" => "Australia/Sydney"
    "Auckland" => "Pacific/Auckland"
    => timezoneIANA
string sessionDays=input.string("23456","Session days · 1=Sunday ... 7=Saturday",group=GS,display=display.none)
string GO="2 · Opening range"
string rangePreset=input.string("15","Opening range / minutes",options=["5","15","30","60","Custom"],group=GO,display=display.none)
int customMinutes=input.int(20,"Custom opening minutes",minval=1,maxval=240,group=GO,display=display.none)
bool showMidpoint=input.bool(true,"Show range midpoint",group=GO,display=display.none)
bool showExtensions=input.bool(true,"Show measured range extensions",group=GO,display=display.none)
float extension1=input.float(0.5,"First extension / range width",minval=0.1,step=0.1,group=GO,display=display.none)
float extension2=input.float(1,"Second extension / range width",minval=0.2,step=0.1,group=GO,display=display.none)
float extension3=input.float(2,"Third extension / range width",minval=0.3,step=0.1,group=GO,display=display.none)
string GB="3 · Breakouts, retests, and failures"
string signalMode=input.string("Breakout close","Main signal",options=["Breakout close","Retest confirmation"],group=GB,display=display.none)
float breakoutBuffer=input.float(0,"Breakout buffer / range width",minval=0,maxval=0.5,step=0.01,group=GB,display=display.none)
bool oncePerSide=input.bool(true,"One qualified breakout per direction / session",group=GB,display=display.none)
int signalMinutes=input.int(0,"New-break cutoff after range / minutes (0=session end)",minval=0,maxval=600,group=GB,display=display.none)
int retestBars=input.int(10,"Retest deadline / subsequent chart bars",minval=1,maxval=100,group=GB,display=display.none)
float retestTolerance=input.float(0.05,"Retest tolerance either side / range width",minval=0,maxval=0.5,step=0.01,group=GB,display=display.none)
bool directionalRetest=input.bool(true,"Retest requires a directional candle body",group=GB,display=display.none)
int failureBars=input.int(6,"Failed-break classification window / bars",minval=1,maxval=100,group=GB,display=display.none)
string GF="4 · Optional qualification filters"
int atrLength=input.int(14,"ATR length",minval=2,maxval=100,group=GF,display=display.none)
bool useBody=input.bool(false,"Require breakout directional body",group=GF,display=display.none)
float bodyATR=input.float(0.25,"Minimum breakout body / current ATR",minval=0.05,step=0.05,group=GF,display=display.none)
bool useVolume=input.bool(false,"Require breakout relative volume",group=GF,display=display.none)
int volumeLength=input.int(20,"Previous chart-volume baseline bars",minval=5,maxval=100,group=GF,display=display.none)
float minimumRV=input.float(1.2,"Minimum breakout relative volume",minval=0.1,step=0.1,group=GF,display=display.none)
bool useSize=input.bool(false,"Filter opening width by ATR at lock",group=GF,display=display.none)
float minimumWidthATR=input.float(0.1,"Minimum range / lock ATR",minval=0,step=0.1,group=GF,display=display.none)
float maximumWidthATR=input.float(3,"Maximum range / lock ATR",minval=0.1,step=0.1,group=GF,display=display.none)
string GC="5 · Previous-session range context"
int contextLength=input.int(20,"Prior valid opening ranges per session",minval=5,maxval=100,group=GC,display=display.none)
int contextMinimum=input.int(3,"Minimum prior ranges for comparison",minval=1,maxval=20,group=GC,display=display.none)
bool useContext=input.bool(false,"Require width within prior-average bounds",group=GC,display=display.none)
float minimumRelative=input.float(0.5,"Minimum width / prior average",minval=0,step=0.1,group=GC,display=display.none)
float maximumRelative=input.float(2,"Maximum width / prior average",minval=0.1,step=0.1,group=GC,display=display.none)
string GV="6 · Appearance and history"
int historyCount=input.int(5,"Completed ranges retained per session",minval=0,maxval=10,group=GV,display=display.none)
bool showPriceTags=input.bool(true,"Show current range price labels",group=GV,display=display.none)
bool labelExtensions=input.bool(false,"Label current extension prices",group=GV,display=display.none)
string labelSize=input.string("Medium","Price label font",options=["Small","Medium","Large","Extra Large"],group=GV,display=display.none)
bool showBreakMarks=input.bool(true,"Mark qualified breakouts",group=GV,display=display.none)
bool showRetestMarks=input.bool(true,"Mark retest confirmations",group=GV,display=display.none)
bool showFailureMarks=input.bool(true,"Mark failed breaks",group=GV,display=display.none)
int eventLimit=input.int(60,"Maximum retained event labels",minval=10,maxval=100,group=GV,display=display.none)
string panelSize=input.string("Small","Dashboard size",options=["Small","Medium","Large","Hidden"],group=GV,display=display.none)
string panelCorner=input.string("Top Right","Dashboard corner",options=["Top Left","Top Right","Bottom Left","Bottom Right"],group=GV,display=display.none)
color nyColor=input.color(#67B4FF,"New York range",group=GV,display=display.none)
color londonColor=input.color(#BD98FF,"London range",group=GV,display=display.none)
color tokyoColor=input.color(#FFCC75,"Tokyo range",group=GV,display=display.none)
color customColor=input.color(#83DCC2,"Custom range",group=GV,display=display.none)
color upColor=input.color(#2AD4AF,"Upper levels / bullish patterns",group=GV,display=display.none)
color downColor=input.color(#FF7897,"Lower levels / bearish patterns",group=GV,display=display.none)
string GA="7 · Alerts"
bool alertSignal=input.bool(true,"Selected main signal alerts",group=GA,display=display.none)
bool alertBreakout=input.bool(false,"Qualified breakout observations",group=GA,display=display.none)
bool alertRetest=input.bool(false,"Retest observations",group=GA,display=display.none)
bool alertFailure=input.bool(true,"Failed-break observations",group=GA,display=display.none)
bool alertRange=input.bool(false,"Opening range locked",group=GA,display=display.none)
 
int openingMinutes=rangePreset=="Custom" ? customMinutes : int(str.tonumber(rangePreset))
float barSeconds=timeframe.in_seconds()
if barstate.isfirst
    if not timeframe.isintraday or barSeconds>openingMinutes*60
        runtime.error("Use an intraday time-based chart no longer than the opening range. Its candles must align with the session start and range end.")
    if not (extension1<extension2 and extension2<extension3)
        runtime.error("Extensions must satisfy first < second < third.")
    if minimumWidthATR>maximumWidthATR or minimumRelative>maximumRelative
        runtime.error("Minimum filter bounds must not exceed maximum bounds.")
    if contextMinimum>contextLength
        runtime.error("Minimum prior ranges must not exceed the comparison lookback.")
float atr=ta.atr(atrLength)
float volumeBase=ta.sma(volume,volumeLength)[1]
float rv=not na(volume) and volume>=0 and volumeBase>0 ? volume/volumeBase : na
color panelBG=color.rgb(18,24,35)
string priceFont=labelSize=="Extra Large" ? size.huge : labelSize=="Large" ? size.large : labelSize=="Medium" ? size.normal : size.small
f_price(float value) =>
    na(value) ? "Unavailable" : str.tostring(value,format.mintick)
f_event(string events,bool enabled,string name) =>
    enabled ? events+(str.length(events)>0 ? " | " : "")+name : events
f_bounds(string hours,string zone) =>
    int sh=int(str.tonumber(str.substring(hours,0,2)))
    int sm=int(str.tonumber(str.substring(hours,2,4)))
    int eh=int(str.tonumber(str.substring(hours,5,7)))
    int em=int(str.tonumber(str.substring(hours,7,9)))
    bool beforeStart=hour(time,zone)*60+minute(time,zone)<sh*60+sm
    int start=timestamp(zone,year(time,zone),month(time,zone),dayofmonth(time,zone)-(beforeStart ? 1 : 0),sh,sm)
    int finish=timestamp(zone,year(start,zone),month(start,zone),dayofmonth(start,zone)+(eh*60+em<=sh*60+sm ? 1 : 0),eh,em)
    [start,finish]
 
type Drawing
    array<line> levels
    array<label> tags
    box area=na
    label heading=na
 
type SessionState
    string name
    string shortName
    int slot
    color tint
    array<float> widths
    array<Drawing> history
    string zone=""
    Drawing drawing=na
    int key=na
    int start=na
    int finish=na
    int orEnd=na
    int covered=na
    int lastSeen=na
    bool valid=false
    bool done=false
    bool locked=false
    bool finished=true
    float hi=na
    float lo=na
    int lockBar=na
    float lockATR=na
    float relative=na
    int priorCount=0
    bool sizePass=true
    bool contextPass=true
    string state="Waiting for session"
    string reason=""
    float lastClose=na
    bool usedUp=false
    bool usedDown=false
    int attempt=0
    int breakBar=na
    bool retested=false
    bool retestExpired=false
    int breakouts=0
    int retests=0
    int failures=0
var SessionState ny=SessionState.new("New York","NY",0,nyColor,array.new<float>(),array.new<Drawing>())
var SessionState london=SessionState.new("London","LDN",1,londonColor,array.new<float>(),array.new<Drawing>())
var SessionState tokyo=SessionState.new("Tokyo","TYO",2,tokyoColor,array.new<float>(),array.new<Drawing>())
var SessionState custom=SessionState.new("Custom","CUS",3,customColor,array.new<float>(),array.new<Drawing>())
var array<label> eventTags=array.new<label>()
f_delete(Drawing d) =>
    if not na(d.area)
        box.delete(d.area)
    if not na(d.heading)
        label.delete(d.heading)
    if array.size(d.levels)>0
        for i=0 to array.size(d.levels)-1
            line.delete(array.get(d.levels,i))
    if array.size(d.tags)>0
        for i=0 to array.size(d.tags)-1
            label.delete(array.get(d.tags,i))
    true
f_details(SessionState s) =>
    float width=s.hi-s.lo
    string atrContext=s.lockATR>0 ? str.tostring(width/s.lockATR,"#.##") : "Unavailable"
    s.name+" | OR "+str.tostring(openingMinutes)+"m\nHigh: "+f_price(s.hi)+" | Low: "+f_price(s.lo)+"\nWidth: "+f_price(width)+" | Width/lock ATR: "+atrContext+"\nBreak triggers: > "+f_price(s.hi+width*breakoutBuffer)+" / < "+f_price(s.lo-width*breakoutBuffer)+"\nPrior-average ratio: "+(na(s.relative) ? "warming up" : str.tostring(s.relative,"#.##"))+" ("+str.tostring(s.priorCount)+" prior ranges)\nQualified breaks / retests / failed breaks: "+str.tostring(s.breakouts)+" / "+str.tostring(s.retests)+" / "+str.tostring(s.failures)+"\n"+s.state+"\nThese are pattern counts, not wins, losses, or trade fills."
 
f_finish(SessionState s) =>
    if not s.finished
        s.finished:=true
        s.attempt:=0
        s.state:=s.locked ? "Session complete" : "Incomplete / invalid session"
        if not na(s.drawing)
            Drawing d=s.drawing
            if array.size(d.tags)>0
                for i=0 to array.size(d.tags)-1
                    label.delete(array.get(d.tags,i))
                array.clear(d.tags)
            if not na(d.heading)
                label.set_y(d.heading,not na(s.hi) ? s.hi : high)
                label.set_text(d.heading,s.shortName+" "+str.format_time(s.start,"MMM dd",s.zone)+" · OR "+str.tostring(openingMinutes)+"m")
                label.set_tooltip(d.heading,f_details(s)+"\n"+s.reason)
            if s.locked and historyCount>0
                while array.size(s.history)>=historyCount
                    f_delete(array.shift(s.history))
                array.push(s.history,d)
                true
            else
                f_delete(d)
                true
            s.drawing:=na
    true
f_start(SessionState s,int start,int finish) =>
    s.key:=start
    s.start:=start
    s.finish:=finish
    s.orEnd:=start+openingMinutes*60000
    s.covered:=start
    s.lastSeen:=na
    s.valid:=time==start and s.orEnd<finish
    s.reason:=time!=start ? "Session start missing / chart misalignment" : s.orEnd>=finish ? "Opening window must end before session end" : ""
    s.done:=false
    s.locked:=false
    s.finished:=false
    s.hi:=na
    s.lo:=na
    s.lockBar:=na
    s.lockATR:=na
    s.relative:=na
    s.priorCount:=array.size(s.widths)
    s.sizePass:=true
    s.contextPass:=true
    s.lastClose:=na
    s.usedUp:=false
    s.usedDown:=false
    s.attempt:=0
    s.breakBar:=na
    s.retested:=false
    s.retestExpired:=false
    s.breakouts:=0
    s.retests:=0
    s.failures:=0
    s.state:=s.valid ? "Forming opening range" : "Invalid · "+s.reason
    Drawing d=Drawing.new(array.new<line>(),array.new<label>())
    d.heading:=label.new(time,high,s.shortName+" · OR "+str.tostring(openingMinutes)+"m",xloc=xloc.bar_time,style=label.style_label_lower_left,color=panelBG,textcolor=s.tint,size=priceFont,force_overlay=true)
    s.drawing:=d
    true
f_lock(SessionState s) =>
    float width=s.hi-s.lo
    s.done:=true
    if s.valid and width>=syminfo.mintick
        s.locked:=true
        s.lockBar:=bar_index
        s.lockATR:=atr
        s.lastClose:=close
        s.priorCount:=array.size(s.widths)
        float average=s.priorCount>0 ? array.avg(s.widths) : na
        s.relative:=s.priorCount>=contextMinimum and average>0 ? width/average : na
        s.sizePass:=not useSize or (not na(atr) and atr>0 and width/atr>=minimumWidthATR and width/atr<=maximumWidthATR)
        s.contextPass:=not useContext or (not na(s.relative) and s.relative>=minimumRelative and s.relative<=maximumRelative)
        // Context snapshot is taken BEFORE adding this range to the baseline.
        array.push(s.widths,width)
        if array.size(s.widths)>contextLength
            array.shift(s.widths)
        s.state:="Range locked"
        Drawing d=s.drawing
        array<float> prices=array.from(s.hi,s.lo,(s.hi+s.lo)/2,s.hi+extension1*width,s.hi+extension2*width,s.hi+extension3*width,s.lo-extension1*width,s.lo-extension2*width,s.lo-extension3*width)
        for i=0 to 8
            bool visible=i<2 or (i==2 ? showMidpoint : showExtensions)
            line level=na
            label tag=na
            color tint=i==0 or (i>=3 and i<=5) ? upColor : i==1 or i>=6 ? downColor : color.silver
            if visible
                level:=line.new(s.orEnd,array.get(prices,i),s.finish,array.get(prices,i),xloc=xloc.bar_time,color=color.new(tint,i<3 ? 5 : 45),width=i<2 ? 2 : 1,style=i<2 ? line.style_solid : line.style_dashed,force_overlay=true)
                if showPriceTags and (i<3 or labelExtensions)
                    tag:=label.new(time_close,array.get(prices,i),"",xloc=xloc.bar_time,style=label.style_label_lower_left,color=panelBG,textcolor=tint,size=priceFont,force_overlay=true)
            array.push(d.levels,level)
            array.push(d.tags,tag)
    else
        s.valid:=false
        s.reason:=str.length(s.reason)>0 ? s.reason : "Flat / sub-tick opening range"
        s.state:="Invalid · "+s.reason
    s.locked
f_mark(SessionState s,string caption,int direction,color tint,string details) =>
    float offset=(not na(atr) ? atr : syminfo.mintick*10)*0.12*s.slot
    float y=direction==1 ? low-offset : high+offset
    label tag=label.new(bar_index,y,s.shortName+" "+caption,style=direction==1 ? label.style_label_up : label.style_label_down,color=panelBG,textcolor=tint,size=size.normal,tooltip=details,force_overlay=true)
    array.push(eventTags,tag)
    while array.size(eventTags)>eventLimit
        label.delete(array.shift(eventTags))
    true
// Each written call has its own session inputs; state is carried in its explicit object.
f_process(SessionState s,bool enabled,string hours,string zone) =>
    bool longSignal=false
    bool shortSignal=false
    bool breakUp=false
    bool breakDown=false
    bool retestUp=false
    bool retestDown=false
    bool failedUp=false
    bool failedDown=false
    bool lockedNow=false
    string events=""
    if enabled and barstate.isconfirmed
        s.zone:=zone
        bool inside=not na(time(timeframe.period,hours+":"+sessionDays,zone))
        [start,finish]=f_bounds(hours,zone)
        if inside
            if na(s.key) or start!=s.key
                f_finish(s)
                f_start(s,start,finish)
            if not s.finished
                if na(time_close) or time_close>s.finish
                    s.reason:="Final chart candle crosses session end; excluded"
                    f_finish(s)
                else
                    if not s.done
                        if time<s.orEnd
                            if time!=s.covered
                                s.valid:=false
                                s.reason:="Missing / misaligned chart bars inside opening window"
                            if time_close>s.orEnd
                                s.valid:=false
                                s.reason:="Chart candle straddles opening-range end"
                            else
                                s.hi:=na(s.hi) ? high : math.max(s.hi,high)
                                s.lo:=na(s.lo) ? low : math.min(s.lo,low)
                                Drawing d=s.drawing
                                if na(d.area)
                                    d.area:=box.new(time,s.hi,time_close,s.lo,xloc=xloc.bar_time,border_color=s.tint,bgcolor=color.new(s.tint,90),force_overlay=true)
                                box.set_top(d.area,s.hi)
                                box.set_bottom(d.area,s.lo)
                                box.set_right(d.area,time_close)
                                if barstate.isconfirmed
                                    s.covered:=time_close
                                    if time_close==s.orEnd
                                        lockedNow:=f_lock(s)
                        else
                            s.valid:=false
                            s.done:=true
                            if str.length(s.reason)==0
                                s.reason:="Opening window did not have complete aligned coverage"
                        if not s.valid
                            s.state:="Invalid · "+s.reason
                    if barstate.isconfirmed and s.locked and bar_index>s.lockBar
                        float width=s.hi-s.lo
                        float upper=s.hi+width*breakoutBuffer
                        float lower=s.lo-width*breakoutBuffer
                        float tolerance=width*retestTolerance
                        bool handled=false
                        // Return through the broken edge cancels pending confirmation at any age.
                        if s.attempt!=0
                            int direction=s.attempt
                            int elapsed=bar_index-s.breakBar
                            bool returned=direction==1 ? close<=s.hi : close>=s.lo
                            if returned
                                if elapsed<=failureBars
                                    failedUp:=direction==1
                                    failedDown:=direction==-1
                                    s.failures+=1
                                    s.state:="Failed "+(direction==1 ? "upper" : "lower")+" break"
                                    if showFailureMarks
                                        f_mark(s,direction==1 ? "FAIL ↑" : "FAIL ↓",-direction,direction==1 ? downColor : upColor,f_details(s)+"\nClose returned through the broken boundary within "+str.tostring(failureBars)+" bars; this is not a stop-loss result.")
                                else
                                    s.state:="Returned through edge · outside failure window"
                                s.attempt:=0
                                handled:=true
                            else
                                bool overlaps=direction==1 ? low<=s.hi+tolerance and high>=s.hi-tolerance : high>=s.lo-tolerance and low<=s.lo+tolerance
                                bool outside=direction==1 ? close>upper : close<lower
                                bool body=not directionalRetest or direction*(close-open)>0
                                if not s.retested and not s.retestExpired and elapsed<=retestBars and overlaps and outside and body
                                    s.retested:=true
                                    s.retests+=1
                                    retestUp:=direction==1
                                    retestDown:=direction==-1
                                    longSignal:=signalMode=="Retest confirmation" and direction==1
                                    shortSignal:=signalMode=="Retest confirmation" and direction==-1
                                    s.state:="Retest confirmed"
                                    if showRetestMarks
                                        f_mark(s,direction==1 ? "RETEST ↑" : "RETEST ↓",direction,direction==1 ? upColor : downColor,f_details(s)+"\nLater candle overlaps the boundary tolerance zone and closes beyond the breakout trigger. Filters were captured at breakout.")
                                if not s.retested and elapsed>retestBars and not s.retestExpired
                                    s.retestExpired:=true
                                    s.state:="Retest deadline expired"
                                if elapsed>math.max(retestBars,failureBars)
                                    s.attempt:=0
                                    handled:=true
                                    s.state:="Monitoring completed range"
                        bool cutoff=signalMinutes==0 or time_close<=s.orEnd+signalMinutes*60000
                        if s.attempt==0 and not handled and cutoff
                            bool crossesUp=not na(s.lastClose) and s.lastClose<=upper and close>upper
                            bool crossesDown=not na(s.lastClose) and s.lastClose>=lower and close<lower
                            int direction=crossesUp ? 1 : crossesDown ? -1 : 0
                            bool unused=direction==1 ? not s.usedUp : not s.usedDown
                            if direction!=0 and (not oncePerSide or unused)
                                bool volumeOK=not useVolume or (not na(rv) and rv>=minimumRV)
                                bool bodyOK=not useBody or (not na(atr) and atr>0 and direction*(close-open)>=atr*bodyATR)
                                if s.sizePass and s.contextPass and volumeOK and bodyOK
                                    s.attempt:=direction
                                    s.breakBar:=bar_index
                                    s.retested:=false
                                    s.retestExpired:=false
                                    s.usedUp:=s.usedUp or direction==1
                                    s.usedDown:=s.usedDown or direction==-1
                                    s.breakouts+=1
                                    breakUp:=direction==1
                                    breakDown:=direction==-1
                                    longSignal:=signalMode=="Breakout close" and direction==1
                                    shortSignal:=signalMode=="Breakout close" and direction==-1
                                    s.state:=signalMode=="Retest confirmation" ? "Qualified break · awaiting retest" : "Qualified breakout close"
                                    if showBreakMarks
                                        f_mark(s,direction==1 ? "BREAK ↑" : "BREAK ↓",direction,direction==1 ? upColor : downColor,f_details(s)+"\nBreakout RV: "+(na(rv) ? "Unavailable" : str.tostring(rv,"#.##"))+"\nRange ATR / prior-average filters: "+(s.sizePass and s.contextPass ? "passed / off" : "failed")+"\nMain signal mode: "+signalMode)
                                else
                                    s.state:=not s.sizePass ? "Break skipped · range/ATR filter" : not s.contextPass ? "Break skipped · prior-range context" : not volumeOK ? "Break skipped · relative volume" : "Break skipped · candle body"
                        s.lastClose:=close
                    if barstate.isconfirmed
                        s.lastSeen:=time_close
                    if time_close==s.finish and barstate.isconfirmed
                        f_finish(s)
        else
            f_finish(s)
        events:=f_event(events,alertRange and lockedNow,s.shortName+" RANGE_LOCKED")
        events:=f_event(events,alertBreakout and breakUp,s.shortName+" QUALIFIED_BREAK_UP")
        events:=f_event(events,alertBreakout and breakDown,s.shortName+" QUALIFIED_BREAK_DOWN")
        events:=f_event(events,alertRetest and retestUp,s.shortName+" RETEST_UP")
        events:=f_event(events,alertRetest and retestDown,s.shortName+" RETEST_DOWN")
        events:=f_event(events,alertFailure and failedUp,s.shortName+" FAILED_UP_BREAK")
        events:=f_event(events,alertFailure and failedDown,s.shortName+" FAILED_DOWN_BREAK")
        events:=f_event(events,alertSignal and longSignal,s.shortName+" MAIN_BULLISH_SIGNAL")
        events:=f_event(events,alertSignal and shortSignal,s.shortName+" MAIN_BEARISH_SIGNAL")
        if str.length(events)>0
            events+=" [OR "+f_price(s.lo)+"–"+f_price(s.hi)+"]"
    [longSignal,shortSignal,breakUp,breakDown,retestUp,retestDown,failedUp,failedDown,lockedNow,events]
 
[nyLong,nyShort,nyBU,nyBD,nyRU,nyRD,nyFU,nyFD,nyLock,nyEvents]=f_process(ny,useNY,"0930-1600","America/New_York")
[ldLong,ldShort,ldBU,ldBD,ldRU,ldRD,ldFU,ldFD,ldLock,ldEvents]=f_process(london,useLondon,"0800-1630","Europe/London")
[tkLong,tkShort,tkBU,tkBD,tkRU,tkRD,tkFU,tkFD,tkLock,tkEvents]=f_process(tokyo,useTokyo,"0900-1500","Asia/Tokyo")
[cuLong,cuShort,cuBU,cuBD,cuRU,cuRD,cuFU,cuFD,cuLock,cuEvents]=f_process(custom,useCustom,customHours,customZone)
 
f_render(SessionState s,string zone) =>
    if not na(s.drawing)
        Drawing d=s.drawing
        if not na(d.heading)
            bool preview=not barstate.isconfirmed and s.valid and not s.done and time==s.covered and time<s.orEnd and not na(time_close) and time_close<=s.orEnd
            float previewHigh=preview ? math.max(s.hi,high) : s.hi
            float previewLow=preview ? math.min(s.lo,low) : s.lo
            if preview and not na(d.area)
                box.set_top(d.area,previewHigh)
                box.set_bottom(d.area,previewLow)
                box.set_right(d.area,time_close)
            float y=not na(previewHigh) ? previewHigh : high
            label.set_y(d.heading,y)
            label.set_text(d.heading,s.shortName+" "+str.format_time(s.start,"MMM dd",zone)+" · OR "+str.tostring(openingMinutes)+"m · "+(s.locked ? "LOCKED" : s.valid ? "FORMING" : "INVALID"))
            label.set_tooltip(d.heading,f_details(s)+"\n"+s.reason)
        if not na(d.area)
            box.set_border_color(d.area,s.valid ? s.tint : color.gray)
            box.set_bgcolor(d.area,color.new(s.valid ? s.tint : color.gray,90))
        if s.locked and array.size(d.tags)==9
            float width=s.hi-s.lo
            array<float> prices=array.from(s.hi,s.lo,(s.hi+s.lo)/2,s.hi+extension1*width,s.hi+extension2*width,s.hi+extension3*width,s.lo-extension1*width,s.lo-extension2*width,s.lo-extension3*width)
            array<string> names=array.from("OR HIGH","OR LOW","OR MID","UP +"+str.tostring(extension1)+"×","UP +"+str.tostring(extension2)+"×","UP +"+str.tostring(extension3)+"×","DN −"+str.tostring(extension1)+"×","DN −"+str.tostring(extension2)+"×","DN −"+str.tostring(extension3)+"×")
            for i=0 to 8
                label tag=array.get(d.tags,i)
                if not na(tag)
                    int x=int(math.min(s.finish,time+int(barSeconds*1000)*3))
                    label.set_xy(tag,x,array.get(prices,i))
                    label.set_text(tag,s.shortName+" "+array.get(names,i)+" "+f_price(array.get(prices,i)))
                    label.set_tooltip(tag,f_details(s)+"\nExtension multipliers use opening-range width, not trade risk. Levels were fixed at range confirmation.")
    true
if barstate.islast
    f_render(ny,"America/New_York")
    f_render(london,"Europe/London")
    f_render(tokyo,"Asia/Tokyo")
    f_render(custom,customZone)
 
bool anyLongSignal=nyLong or ldLong or tkLong or cuLong
bool anyShortSignal=nyShort or ldShort or tkShort or cuShort
bool anyBreakUp=nyBU or ldBU or tkBU or cuBU
bool anyBreakDown=nyBD or ldBD or tkBD or cuBD
bool anyRetestUp=nyRU or ldRU or tkRU or cuRU
bool anyRetestDown=nyRD or ldRD or tkRD or cuRD
bool anyFailedUp=nyFU or ldFU or tkFU or cuFU
bool anyFailedDown=nyFD or ldFD or tkFD or cuFD
bool anyRangeLocked=nyLock or ldLock or tkLock or cuLock
string panelPosition=panelCorner=="Top Left" ? position.top_left : panelCorner=="Bottom Left" ? position.bottom_left : panelCorner=="Bottom Right" ? position.bottom_right : position.top_right
var table panel=table.new(panelPosition,4,7,bgcolor=panelBG,frame_color=color.gray,frame_width=1)
if barstate.islast
    if panelSize!="Hidden"
        string panelFont=panelSize=="Large" ? size.large : panelSize=="Medium" ? size.normal : size.small
        table.cell(panel,0,0,"[CandleChasers]",bgcolor=panelBG,text_color=color.white,text_size=panelFont)
        table.cell(panel,1,0,"OPENING RANGE 1.1",bgcolor=panelBG,text_color=color.white,text_size=panelFont)
        table.cell(panel,2,0,str.tostring(openingMinutes)+" min",bgcolor=panelBG,text_color=color.white,text_size=panelFont)
        table.cell(panel,3,0,signalMode,bgcolor=panelBG,text_color=color.white,text_size=panelFont)
        array<string> headers=array.from("Session","State","OR width","Vs prior OR")
        for col=0 to 3
            table.cell(panel,col,1,array.get(headers,col),bgcolor=panelBG,text_color=color.silver,text_size=panelFont)
        array<SessionState> sessions=array.from(ny,london,tokyo,custom)
        array<bool> enabled=array.from(useNY,useLondon,useTokyo,useCustom)
        for i=0 to 3
            SessionState s=array.get(sessions,i)
            string context=na(s.relative) ? "Warmup "+str.tostring(s.priorCount)+"/"+str.tostring(contextMinimum) : str.tostring(s.relative*100,"#")+"% · "+(s.relative<0.75 ? "Narrow" : s.relative>1.25 ? "Wide" : "Typical")
            array<string> values=array.from(s.name,array.get(enabled,i) ? s.state : "Off",na(s.hi) ? "—" : f_price(s.hi-s.lo),context)
            for col=0 to 3
                table.cell(panel,col,i+2,array.get(values,col),bgcolor=panelBG,text_color=col==0 ? s.tint : color.white,text_size=panelFont,tooltip=f_details(s)+"\n"+s.reason)
        table.cell(panel,0,6,"Closed-bar signals",bgcolor=panelBG,text_color=color.silver,text_size=panelFont)
        table.cell(panel,1,6,"Strict aligned OR coverage",bgcolor=panelBG,text_color=color.silver,text_size=panelFont)
        table.cell(panel,2,6,"No orders",bgcolor=panelBG,text_color=color.silver,text_size=panelFont)
        table.cell(panel,3,6,"Counts ≠ win rate",bgcolor=panelBG,text_color=color.silver,text_size=panelFont)
    else
        table.clear(panel,0,0,3,6)
if barstate.isconfirmed
    string events=""
    events:=f_event(events,str.length(nyEvents)>0,nyEvents)
    events:=f_event(events,str.length(ldEvents)>0,ldEvents)
    events:=f_event(events,str.length(tkEvents)>0,tkEvents)
    events:=f_event(events,str.length(cuEvents)>0,cuEvents)
    if str.length(events)>0
        alert("[CandleChasers] "+syminfo.tickerid+" "+timeframe.period+" | "+events,alert.freq_once_per_bar_close)
alertcondition(alertSignal and anyLongSignal,"Main bullish signal","[CandleChasers] Selected bullish OR pattern confirmed on {{ticker}} {{interval}}.")
alertcondition(alertSignal and anyShortSignal,"Main bearish signal","[CandleChasers] Selected bearish OR pattern confirmed on {{ticker}} {{interval}}.")
alertcondition(alertBreakout and anyBreakUp,"Qualified upper breakout","[CandleChasers] Qualified close above an opening range on {{ticker}} {{interval}}.")
alertcondition(alertBreakout and anyBreakDown,"Qualified lower breakout","[CandleChasers] Qualified close below an opening range on {{ticker}} {{interval}}.")
alertcondition(alertRetest and anyRetestUp,"Upper retest confirmed","[CandleChasers] Upper OR retest confirmed on {{ticker}} {{interval}}.")
alertcondition(alertRetest and anyRetestDown,"Lower retest confirmed","[CandleChasers] Lower OR retest confirmed on {{ticker}} {{interval}}.")
alertcondition(alertFailure and anyFailedUp,"Failed upper breakout","[CandleChasers] Close returned through upper OR edge inside the failure window on {{ticker}} {{interval}}.")
alertcondition(alertFailure and anyFailedDown,"Failed lower breakout","[CandleChasers] Close returned through lower OR edge inside the failure window on {{ticker}} {{interval}}.")
alertcondition(alertRange and anyRangeLocked,"Opening range locked","[CandleChasers] Complete aligned opening range confirmed on {{ticker}} {{interval}}.")

← 返回列表