Killzones SMT + IFVG detectorSummary
Killzones SMT + IFVG detector is a rules-based tool for intraday setups inside defined “killzone” windows. It combines SMT (cross-market divergence between NQ and ES) with strict ICT-style IFVG confirmation (3-bar imbalance), plus safety gates and optional stop/target management.
Design rationale — how the pieces work together
Context first : time-boxed killzones + recorded session extremes (H/L) focus the search on likely liquidity areas.
Selective divergence : signals require exclusive SMT sweeps (one index takes the level while the other does not), which filters noise.
Strict confirmation : only confirms when price closes beyond the IFVG boundary in the candle’s direction (bull close above upper gap for longs; bear close below lower gap for shorts).
Safety gating : same-bar H&L sweep on the same symbol pauses until the next killzone; weekend lockout; cooldown; and a max initial-stop gate that skips oversized setups.
How it works (high level)
Session extremes inside killzones : during each window, the script stores NQ/ES highs/lows and keeps a limited number of untouched levels.
SMT (exclusive sweep) : a candidate forms when, on the same bar, only one index sweeps its stored H/L while the other does not.
• Bullish SMT: one index sweeps the low while the other remains above its session low.
• Bearish SMT: one index sweeps the high while the other remains below its session high.
Detection supports Sweep (Cross) with minimum-tick penetration or Exact Tick equality.
IFVG lock & confirmation : after an SMT candidate, the script locks a qualifying 3-bar IFVG on the chosen confirmation symbol (NQ or ES). Confirmation requires a close through the gap boundary in the candle’s direction. Optional “re-lock” keeps tracking the newest valid IFVG until confirmation/expiry.
(Strategy option) Exits : initial stop from last opposite-candle wick (+ buffer), fixed TP in points, and step-ups to BE → 50% → 80% of target as progress thresholds are reached.
Killzones (what they are + default times)
Times are interpreted in the chart’s timezone . The logic stores extremes made inside these windows and monitors them forward.
19:00–23:00 — Early overnight liquidity formation.
01:00–04:00 — London/European activity window.
08:30–10:00 — U.S. morning discovery (major data at :30).
11:00–12:00 — Midday probe/pause; thinner liquidity.
12:30–15:00 — U.S. afternoon continuation/unwind into close.
How to use
Apply on a chart with NQ and ES data (e.g., continuous futures). Choose killzone windows and detection mode (Cross vs Exact Tick).
Select the confirmation symbol (NQ or ES) and optionally enable IFVG re-lock until confirmation/expiry.
set realistic Properties and run on “Once per bar close.”
*
Alerts: enable SMT Bullish/Bearish and/or Confirm LONG/SHORT ; “Once per bar close” is generally recommended.
What the alerts mean
SMT Bullish/Bearish : an exclusive sweep + divergence printed this bar.
Confirm LONG/SHORT : the close crossed the IFVG boundary in the candle’s direction per the rules.
Limitations
Signals depend on data quality, feeds, and timeframe. Divergence and confirmations can fail. Designed primarily for the NQ/ES pair. Past performance is not indicative of future results; use prudent risk controls.
Disclaimer
Educational tool only; not financial advice. Trade at your own risk.
圖表形態
Bruno iarussi GodFather Crypto 1M 107% week return
1 m chart
need to make some innput changes to make better
sdfjnsoifnsoi
sdfno'dsnfo'idsnf
sdfnoosdifnsdfp
nsdfosdinfiods
nmfsodpikds
Мой скрипт// © Buzzara
// =================================
// PLEASE SUPPORT THE TEAM
// =================================
//
// Telegram: t.me
a_trade// =================================
//@version=5
VERSION = ' Buzzara2.0'
strategy('ALGOX V6_1_24', shorttitle = '🚀〄 Buzzara2.0 〄🚀'+ VERSION, overlay = true, explicit_plot_zorder = true, pyramiding = 0, default_qty_type = strategy.percent_of_equity, initial_capital = 1000, default_qty_value = 1, calc_on_every_tick = false, process_orders_on_close = true)
G_SCRIPT01 = '■ ' + 'SAIYAN OCC'
//#region ———— <↓↓↓ G_SCRIPT01 ↓↓↓> {
// === INPUTS ===
res = input.timeframe('15', 'TIMEFRAME', group ="NON REPAINT")
useRes = input(true, 'Use Alternate Signals')
intRes = input(10, 'Multiplier for Alernate Signals')
basisType = input.string('ALMA', 'MA Type: ', options= )
basisLen = input.int(50, 'MA Period', minval=1)
offsetSigma = input.int(5, 'Offset for LSMA / Sigma for ALMA', minval=0)
offsetALMA = input.float(2, 'Offset for ALMA', minval=0, step=0.01)
scolor = input(false, 'Show coloured Bars to indicate Trend?')
delayOffset = input.int(0, 'Delay Open/Close MA', minval=0, step=1,
tooltip = 'Forces Non-Repainting')
tradeType = input.string('BOTH', 'What trades should be taken : ',
options = )
//=== /INPUTS ===
h = input(false, 'Signals for Heikin Ashi Candles')
//INDICATOR SETTINGS
swing_length = input.int(10, 'Swing High/Low Length', group = 'Settings', minval = 1, maxval = 50)
history_of_demand_to_keep = input.int(20, 'History To Keep', minval = 5, maxval = 50)
box_width = input.float(2.5, 'Supply/Demand Box Width', group = 'Settings', minval = 1, maxval = 10, step = 0.5)
//INDICATOR VISUAL SETTINGS
show_zigzag = input.bool(false, 'Show Zig Zag', group = 'Visual Settings', inline = '1')
show_price_action_labels = input.bool(false, 'Show Price Action Labels', group = 'Visual Settings', inline = '2')
supply_color = input.color(#00000000, 'Supply', group = 'Visual Settings', inline = '3')
supply_outline_color = input.color(#00000000, 'Outline', group = 'Visual Settings', inline = '3')
demand_color = input.color(#00000000, 'Demand', group = 'Visual Settings', inline = '4')
demand_outline_color = input.color(#00000000, 'Outline', group = 'Visual Settings', inline = '4')
bos_label_color = input.color(#00000000, 'BOS Label', group = 'Visual Settings', inline = '5')
poi_label_color = input.color(#00000000, 'POI Label', group = 'Visual Settings', inline = '7')
poi_border_color = input.color(#00000000, 'POI border', group = 'Visual Settings', inline = '7')
swing_type_color = input.color(#00000000, 'Price Action Label', group = 'Visual Settings', inline = '8')
zigzag_color = input.color(#00000000, 'Zig Zag', group = 'Visual Settings', inline = '9')
//END SETTINGS
// FUNCTION TO ADD NEW AND REMOVE LAST IN ARRAY
f_array_add_pop(array, new_value_to_add) =>
array.unshift(array, new_value_to_add)
array.pop(array)
// FUNCTION SWING H & L LABELS
f_sh_sl_labels(array, swing_type) =>
var string label_text = na
if swing_type == 1
if array.get(array, 0) >= array.get(array, 1)
label_text := 'HH'
else
label_text := 'LH'
label.new(
bar_index - swing_length,
array.get(array,0),
text = label_text,
style = label.style_label_down,
textcolor = swing_type_color,
color = swing_type_color,
size = size.tiny)
else if swing_type == -1
if array.get(array, 0) >= array.get(array, 1)
label_text := 'HL'
else
label_text := 'LL'
label.new(
bar_index - swing_length,
array.get(array,0),
text = label_text,
style = label.style_label_up,
textcolor = swing_type_color,
color = swing_type_color,
size = size.tiny)
// FUNCTION MAKE SURE SUPPLY ISNT OVERLAPPING
f_check_overlapping(new_poi, box_array, atrValue) =>
atr_threshold = atrValue * 2
okay_to_draw = true
for i = 0 to array.size(box_array) - 1
top = box.get_top(array.get(box_array, i))
bottom = box.get_bottom(array.get(box_array, i))
poi = (top + bottom) / 2
upper_boundary = poi + atr_threshold
lower_boundary = poi - atr_threshold
if new_poi >= lower_boundary and new_poi <= upper_boundary
okay_to_draw := false
break
else
okay_to_draw := true
okay_to_draw
// FUNCTION TO DRAW SUPPLY OR DEMAND ZONE
f_supply_demand(value_array, bn_array, box_array, label_array, box_type, atrValue) =>
atr_buffer = atrValue * (box_width / 10)
box_left = array.get(bn_array, 0)
box_right = bar_index
var float box_top = 0.00
var float box_bottom = 0.00
var float poi = 0.00
if box_type == 1
box_top := array.get(value_array, 0)
box_bottom := box_top - atr_buffer
poi := (box_top + box_bottom) / 2
else if box_type == -1
box_bottom := array.get(value_array, 0)
box_top := box_bottom + atr_buffer
poi := (box_top + box_bottom) / 2
okay_to_draw = f_check_overlapping(poi, box_array, atrValue)
// okay_to_draw = true
//delete oldest box, and then create a new box and add it to the array
if box_type == 1 and okay_to_draw
box.delete( array.get(box_array, array.size(box_array) - 1) )
f_array_add_pop(box_array, box.new( left = box_left, top = box_top, right = box_right, bottom = box_bottom, border_color = supply_outline_color,
bgcolor = supply_color, extend = extend.right, text = 'SUPPLY', text_halign = text.align_center, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))
box.delete( array.get(label_array, array.size(label_array) - 1) )
f_array_add_pop(label_array, box.new( left = box_left, top = poi, right = box_right, bottom = poi, border_color = poi_border_color,
bgcolor = poi_border_color, extend = extend.right, text = 'POI', text_halign = text.align_left, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))
else if box_type == -1 and okay_to_draw
box.delete( array.get(box_array, array.size(box_array) - 1) )
f_array_add_pop(box_array, box.new( left = box_left, top = box_top, right = box_right, bottom = box_bottom, border_color = demand_outline_color,
bgcolor = demand_color, extend = extend.right, text = 'DEMAND', text_halign = text.align_center, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))
box.delete( array.get(label_array, array.size(label_array) - 1) )
f_array_add_pop(label_array, box.new( left = box_left, top = poi, right = box_right, bottom = poi, border_color = poi_border_color,
bgcolor = poi_border_color, extend = extend.right, text = 'POI', text_halign = text.align_left, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))
// FUNCTION TO CHANGE SUPPLY/DEMAND TO A BOS IF BROKEN
f_sd_to_bos(box_array, bos_array, label_array, zone_type) =>
if zone_type == 1
for i = 0 to array.size(box_array) - 1
level_to_break = box.get_top(array.get(box_array,i))
// if ta.crossover(close, level_to_break)
if close >= level_to_break
copied_box = box.copy(array.get(box_array,i))
f_array_add_pop(bos_array, copied_box)
mid = (box.get_top(array.get(box_array,i)) + box.get_bottom(array.get(box_array,i))) / 2
box.set_top(array.get(bos_array,0), mid)
box.set_bottom(array.get(bos_array,0), mid)
box.set_extend( array.get(bos_array,0), extend.none)
box.set_right( array.get(bos_array,0), bar_index)
box.set_text( array.get(bos_array,0), 'BOS' )
box.set_text_color( array.get(bos_array,0), bos_label_color)
box.set_text_size( array.get(bos_array,0), size.small)
box.set_text_halign( array.get(bos_array,0), text.align_center)
box.set_text_valign( array.get(bos_array,0), text.align_center)
box.delete(array.get(box_array, i))
box.delete(array.get(label_array, i))
if zone_type == -1
for i = 0 to array.size(box_array) - 1
level_to_break = box.get_bottom(array.get(box_array,i))
// if ta.crossunder(close, level_to_break)
if close <= level_to_break
copied_box = box.copy(array.get(box_array,i))
f_array_add_pop(bos_array, copied_box)
mid = (box.get_top(array.get(box_array,i)) + box.get_bottom(array.get(box_array,i))) / 2
box.set_top(array.get(bos_array,0), mid)
box.set_bottom(array.get(bos_array,0), mid)
box.set_extend( array.get(bos_array,0), extend.none)
box.set_right( array.get(bos_array,0), bar_index)
box.set_text( array.get(bos_array,0), 'BOS' )
box.set_text_color( array.get(bos_array,0), bos_label_color)
box.set_text_size( array.get(bos_array,0), size.small)
box.set_text_halign( array.get(bos_array,0), text.align_center)
box.set_text_valign( array.get(bos_array,0), text.align_center)
box.delete(array.get(box_array, i))
box.delete(array.get(label_array, i))
// FUNCTION MANAGE CURRENT BOXES BY CHANGING ENDPOINT
f_extend_box_endpoint(box_array) =>
for i = 0 to array.size(box_array) - 1
box.set_right(array.get(box_array, i), bar_index + 100)
//
stratRes = timeframe.ismonthly ? str.tostring(timeframe.multiplier * intRes, '###M') :
timeframe.isweekly ? str.tostring(timeframe.multiplier * intRes, '###W') :
timeframe.isdaily ? str.tostring(timeframe.multiplier * intRes, '###D') :
timeframe.isintraday ? str.tostring(timeframe.multiplier * intRes, '####') :
'60'
src = h ? request.security(ticker.heikinashi(syminfo.tickerid),
timeframe.period, close, lookahead = barmerge.lookahead_off) : close
// CALCULATE ATR
atrValue = ta.atr(50)
// CALCULATE SWING HIGHS & SWING LOWS
swing_high = ta.pivothigh(high, swing_length, swing_length)
swing_low = ta.pivotlow(low, swing_length, swing_length)
// ARRAYS FOR SWING H/L & BN
var swing_high_values = array.new_float(5,0.00)
var swing_low_values = array.new_float(5,0.00)
var swing_high_bns = array.new_int(5,0)
var swing_low_bns = array.new_int(5,0)
// ARRAYS FOR SUPPLY / DEMAND
var current_supply_box = array.new_box(history_of_demand_to_keep, na)
var current_demand_box = array.new_box(history_of_demand_to_keep, na)
// ARRAYS FOR SUPPLY / DEMAND POI LABELS
var current_supply_poi = array.new_box(history_of_demand_to_keep, na)
var current_demand_poi = array.new_box(history_of_demand_to_keep, na)
// ARRAYS FOR BOS
var supply_bos = array.new_box(5, na)
var demand_bos = array.new_box(5, na)
//END CALCULATIONS
// NEW SWING HIGH
if not na(swing_high)
//MANAGE SWING HIGH VALUES
f_array_add_pop(swing_high_values, swing_high)
f_array_add_pop(swing_high_bns, bar_index )
if show_price_action_labels
f_sh_sl_labels(swing_high_values, 1)
f_supply_demand(swing_high_values, swing_high_bns, current_supply_box, current_supply_poi, 1, atrValue)
// NEW SWING LOW
else if not na(swing_low)
//MANAGE SWING LOW VALUES
f_array_add_pop(swing_low_values, swing_low)
f_array_add_pop(swing_low_bns, bar_index )
if show_price_action_labels
f_sh_sl_labels(swing_low_values, -1)
f_supply_demand(swing_low_values, swing_low_bns, current_demand_box, current_demand_poi, -1, atrValue)
f_sd_to_bos(current_supply_box, supply_bos, current_supply_poi, 1)
f_sd_to_bos(current_demand_box, demand_bos, current_demand_poi, -1)
f_extend_box_endpoint(current_supply_box)
f_extend_box_endpoint(current_demand_box)
channelBal = input.bool(false, "Channel Balance", group = "CHART")
lr_slope(_src, _len) =>
x = 0.0, y = 0.0, x2 = 0.0, xy = 0.0
for i = 0 to _len - 1
val = _src
per = i + 1
x += per
y += val
x2 += per * per
xy += val * per
_slp = (_len * xy - x * y) / (_len * x2 - x * x)
_avg = y / _len
_int = _avg - _slp * x / _len + _slp
lr_dev(_src, _len, _slp, _avg, _int) =>
upDev = 0.0, dnDev = 0.0
val = _int
for j = 0 to _len - 1
price = high - val
if price > upDev
upDev := price
price := val - low
if price > dnDev
dnDev := price
price := _src
val += _slp
//
= ta.kc(close, 80, 10.5)
= ta.kc(close, 80, 9.5)
= ta.kc(close, 80, 8)
= ta.kc(close, 80, 3)
barsL = 10
barsR = 10
pivotHigh = fixnan(ta.pivothigh(barsL, barsR) )
pivotLow = fixnan(ta.pivotlow(barsL, barsR) )
source = close, period = 150
= lr_slope(source, period)
= lr_dev(source, period, s, a, i)
y1 = low - (ta.atr(30) * 2), y1B = low - ta.atr(30)
y2 = high + (ta.atr(30) * 2), y2B = high + ta.atr(30)
x1 = bar_index - period + 1, _y1 = i + s * (period - 1), x2 = bar_index, _y2 = i
//Functions
//Line Style function
get_line_style(style) =>
out = switch style
'???' => line.style_solid
'----' => line.style_dashed
' ' => line.style_dotted
//Function to get order block coordinates
get_coordinates(condition, top, btm, ob_val)=>
var ob_top = array.new_float(0)
var ob_btm = array.new_float(0)
var ob_avg = array.new_float(0)
var ob_left = array.new_int(0)
float ob = na
//Append coordinates to arrays
if condition
avg = math.avg(top, btm)
array.unshift(ob_top, top)
array.unshift(ob_btm, btm)
array.unshift(ob_avg, avg)
ob := ob_val
//Function to remove mitigated order blocks from coordinate arrays
remove_mitigated(ob_top, ob_btm, ob_left, ob_avg, target, bull)=>
mitigated = false
target_array = bull ? ob_btm : ob_top
for element in target_array
idx = array.indexof(target_array, element)
if (bull ? target < element : target > element)
mitigated := true
array.remove(ob_top, idx)
array.remove(ob_btm, idx)
array.remove(ob_avg, idx)
array.remove(ob_left, idx)
mitigated
//Function to set order blocks
set_order_blocks(ob_top, ob_btm, ob_left, ob_avg, ext_last, bg_css, border_css, lvl_css)=>
var ob_box = array.new_box(0)
var ob_lvl = array.new_line(0)
//Global elements
var os = 0
var target_bull = 0.
var target_bear = 0.
// Create non-repainting security function
rp_security(_symbol, _res, _src) =>
request.security(_symbol, _res, _src )
htfHigh = rp_security(syminfo.tickerid, res, high)
htfLow = rp_security(syminfo.tickerid, res, low)
// Main Indicator
// Functions
smoothrng(x, t, m) =>
wper = t * 2 - 1
avrng = ta.ema(math.abs(x - x ), t)
smoothrng = ta.ema(avrng, wper) * m
rngfilt(x, r) =>
rngfilt = x
rngfilt := x > nz(rngfilt ) ? x - r < nz(rngfilt ) ? nz(rngfilt ) : x - r : x + r > nz(rngfilt ) ? nz(rngfilt ) : x + r
percWidth(len, perc) => (ta.highest(len) - ta.lowest(len)) * perc / 100
securityNoRep(sym, res, src) => request.security(sym, res, src, barmerge.gaps_off, barmerge.lookahead_on)
swingPoints(prd) =>
pivHi = ta.pivothigh(prd, prd)
pivLo = ta.pivotlow (prd, prd)
last_pivHi = ta.valuewhen(pivHi, pivHi, 1)
last_pivLo = ta.valuewhen(pivLo, pivLo, 1)
hh = pivHi and pivHi > last_pivHi ? pivHi : na
lh = pivHi and pivHi < last_pivHi ? pivHi : na
hl = pivLo and pivLo > last_pivLo ? pivLo : na
ll = pivLo and pivLo < last_pivLo ? pivLo : na
f_chartTfInMinutes() =>
float _resInMinutes = timeframe.multiplier * (
timeframe.isseconds ? 1 :
timeframe.isminutes ? 1. :
timeframe.isdaily ? 60. * 24 :
timeframe.isweekly ? 60. * 24 * 7 :
timeframe.ismonthly ? 60. * 24 * 30.4375 : na)
f_kc(src, len, sensitivity) =>
basis = ta.sma(src, len)
span = ta.atr(len)
wavetrend(src, chlLen, avgLen) =>
esa = ta.ema(src, chlLen)
d = ta.ema(math.abs(src - esa), chlLen)
ci = (src - esa) / (0.015 * d)
wt1 = ta.ema(ci, avgLen)
wt2 = ta.sma(wt1, 3)
f_top_fractal(_src) => _src < _src and _src < _src and _src > _src and _src > _src
f_bot_fractal(_src) => _src > _src and _src > _src and _src < _src and _src < _src
top_fractal = f_top_fractal(src)
bot_fractal = f_bot_fractal(src)
f_fractalize (_src) => top_fractal ? 1 : bot_fractal ? -1 : 0
f_findDivs(src, topLimit, botLimit) =>
fractalTop = f_fractalize(src) > 0 and src >= topLimit ? src : na
fractalBot = f_fractalize(src) < 0 and src <= botLimit ? src : na
highPrev = ta.valuewhen(fractalTop, src , 0)
highPrice = ta.valuewhen(fractalTop, high , 0)
lowPrev = ta.valuewhen(fractalBot, src , 0)
lowPrice = ta.valuewhen(fractalBot, low , 0)
bearSignal = fractalTop and high > highPrice and src < highPrev
bullSignal = fractalBot and low < lowPrice and src > lowPrev
// Get user input
enableSR = input(false , "SR On/Off", group="SR")
colorSup = input(#00000000 , "Support Color", group="SR")
colorRes = input(#00000000 , "Resistance Color", group="SR")
strengthSR = input.int(2 , "S/R Strength", 1, group="SR")
lineStyle = input.string("Dotted", "Line Style", , group="SR")
lineWidth = input.int(2 , "S/R Line Width", 1, group="SR")
useZones = input(true , "Zones On/Off", group="SR")
useHLZones = input(true , "High Low Zones On/Off", group="SR")
zoneWidth = input.int(2 , "Zone Width %", 0,
tooltip = "it's calculated using % of the distance between highest/lowest in last 300 bars", group="SR")
expandSR = input(true , "Expand SR")
// Get components
rb = 10
prd = 284
ChannelW = 10
label_loc = 55
style = lineStyle == "Solid" ? line.style_solid :
lineStyle == "Dotted" ? line.style_dotted : line.style_dashed
ph = ta.pivothigh(rb, rb)
pl = ta.pivotlow (rb, rb)
sr_levels = array.new_float(21, na)
prdhighest = ta.highest(prd)
prdlowest = ta.lowest(prd)
cwidth = percWidth(prd, ChannelW)
zonePerc = percWidth(300, zoneWidth)
aas = array.new_bool(41, true)
u1 = 0.0, u1 := nz(u1 )
d1 = 0.0, d1 := nz(d1 )
highestph = 0.0, highestph := highestph
lowestpl = 0.0, lowestpl := lowestpl
var sr_levs = array.new_float(21, na)
label hlabel = na, label.delete(hlabel )
label llabel = na, label.delete(llabel )
var sr_lines = array.new_line(21, na)
var sr_linesH = array.new_line(21, na)
var sr_linesL = array.new_line(21, na)
var sr_linesF = array.new_linefill(21, na)
var sr_labels = array.new_label(21, na)
if (not na(ph) or not na(pl))
for x = 0 to array.size(sr_levels) - 1
array.set(sr_levels, x, na)
highestph := prdlowest
lowestpl := prdhighest
countpp = 0
for x = 0 to prd
if na(close )
break
if not na(ph ) or not na(pl )
highestph := math.max(highestph, nz(ph , prdlowest), nz(pl , prdlowest))
lowestpl := math.min(lowestpl, nz(ph , prdhighest), nz(pl , prdhighest))
countpp += 1
if countpp > 40
break
if array.get(aas, countpp)
upl = (not na(ph ) and (ph != 0) ? high : low ) + cwidth
dnl = (not na(ph ) and (ph != 0) ? high : low ) - cwidth
u1 := countpp == 1 ? upl : u1
d1 := countpp == 1 ? dnl : d1
tmp = array.new_bool(41, true)
cnt = 0
tpoint = 0
for xx = 0 to prd
if na(close )
break
if not na(ph ) or not na(pl )
chg = false
cnt += 1
if cnt > 40
break
if array.get(aas, cnt)
if not na(ph )
if high <= upl and high >= dnl
tpoint += 1
chg := true
if not na(pl )
if low <= upl and low >= dnl
tpoint += 1
chg := true
if chg and cnt < 41
array.set(tmp, cnt, false)
if tpoint >= strengthSR
for g = 0 to 40 by 1
if not array.get(tmp, g)
array.set(aas, g, false)
if (not na(ph ) and countpp < 21)
array.set(sr_levels, countpp, high )
if (not na(pl ) and countpp < 21)
array.set(sr_levels, countpp, low )
// Plot
var line highest_ = na, line.delete(highest_)
var line lowest_ = na, line.delete(lowest_)
var line highest_fill1 = na, line.delete(highest_fill1)
var line highest_fill2 = na, line.delete(highest_fill2)
var line lowest_fill1 = na, line.delete(lowest_fill1)
var line lowest_fill2 = na, line.delete(lowest_fill2)
hi_col = close >= highestph ? colorSup : colorRes
lo_col = close >= lowestpl ? colorSup : colorRes
if enableSR
highest_ := line.new(bar_index - 311, highestph, bar_index, highestph, xloc.bar_index, expandSR ? extend.both : extend.right, hi_col, style, lineWidth)
lowest_ := line.new(bar_index - 311, lowestpl , bar_index, lowestpl , xloc.bar_index, expandSR ? extend.both : extend.right, lo_col, style, lineWidth)
if useHLZones
highest_fill1 := line.new(bar_index - 311, highestph + zonePerc, bar_index, highestph + zonePerc, xloc.bar_index, expandSR ? extend.both : extend.right, na)
highest_fill2 := line.new(bar_index - 311, highestph - zonePerc, bar_index, highestph - zonePerc, xloc.bar_index, expandSR ? extend.both : extend.right, na)
lowest_fill1 := line.new(bar_index - 311, lowestpl + zonePerc , bar_index, lowestpl + zonePerc , xloc.bar_index, expandSR ? extend.both : extend.right, na)
lowest_fill2 := line.new(bar_index - 311, lowestpl - zonePerc , bar_index, lowestpl - zonePerc , xloc.bar_index, expandSR ? extend.both : extend.right, na)
linefill.new(highest_fill1, highest_fill2, hi_col)
linefill.new(lowest_fill1 , lowest_fill2 , lo_col)
if (not na(ph) or not na(pl))
for x = 0 to array.size(sr_lines) - 1
array.set(sr_levs, x, array.get(sr_levels, x))
for x = 0 to array.size(sr_lines) - 1
line.delete(array.get(sr_lines, x))
line.delete(array.get(sr_linesH, x))
line.delete(array.get(sr_linesL, x))
linefill.delete(array.get(sr_linesF, x))
if (not na(array.get(sr_levs, x)) and enableSR)
line_col = close >= array.get(sr_levs, x) ? colorSup : colorRes
array.set(sr_lines, x, line.new(bar_index - 355, array.get(sr_levs, x), bar_index, array.get(sr_levs, x), xloc.bar_index, expandSR ? extend.both : extend.right, line_col, style, lineWidth))
if useZones
array.set(sr_linesH, x, line.new(bar_index - 355, array.get(sr_levs, x) + zonePerc, bar_index, array.get(sr_levs, x) + zonePerc, xloc.bar_index, expandSR ? extend.both : extend.right, na))
array.set(sr_linesL, x, line.new(bar_index - 355, array.get(sr_levs, x) - zonePerc, bar_index, array.get(sr_levs, x) - zonePerc, xloc.bar_index, expandSR ? extend.both : extend.right, na))
array.set(sr_linesF, x, linefill.new(array.get(sr_linesH, x), array.get(sr_linesL, x), line_col))
for x = 0 to array.size(sr_labels) - 1
label.delete(array.get(sr_labels, x))
if (not na(array.get(sr_levs, x)) and enableSR)
lab_loc = close >= array.get(sr_levs, x) ? label.style_label_up : label.style_label_down
lab_col = close >= array.get(sr_levs, x) ? colorSup : colorRes
array.set(sr_labels, x, label.new(bar_index + label_loc, array.get(sr_levs, x), str.tostring(math.round_to_mintick(array.get(sr_levs, x))), color=lab_col , textcolor=#000000, style=lab_loc))
hlabel := enableSR ? label.new(bar_index + label_loc + math.round(math.sign(label_loc)) * 20, highestph, "High Level : " + str.tostring(highestph), color=hi_col, textcolor=#000000, style=label.style_label_down) : na
llabel := enableSR ? label.new(bar_index + label_loc + math.round(math.sign(label_loc)) * 20, lowestpl , "Low Level : " + str.tostring(lowestpl) , color=lo_col, textcolor=#000000, style=label.style_label_up ) : na
// Get components
rsi = ta.rsi(close, 28)
//rsiOb = rsi > 78 and rsi > ta.ema(rsi, 10)
//rsiOs = rsi < 27 and rsi < ta.ema(rsi, 10)
rsiOb = rsi > 65 and rsi > ta.ema(rsi, 10)
rsiOs = rsi < 35 and rsi < ta.ema(rsi, 10)
dHigh = securityNoRep(syminfo.tickerid, "D", high )
dLow = securityNoRep(syminfo.tickerid, "D", low )
dClose = securityNoRep(syminfo.tickerid, "D", close )
ema = ta.ema(close, 144)
emaBull = close > ema
equal_tf(res) => str.tonumber(res) == f_chartTfInMinutes() and not timeframe.isseconds
higher_tf(res) => str.tonumber(res) > f_chartTfInMinutes() or timeframe.isseconds
too_small_tf(res) => (timeframe.isweekly and res=="1") or (timeframe.ismonthly and str.tonumber(res) < 10)
securityNoRep1(sym, res, src) =>
bool bull_ = na
bull_ := equal_tf(res) ? src : bull_
bull_ := higher_tf(res) ? request.security(sym, res, src, barmerge.gaps_off, barmerge.lookahead_on) : bull_
bull_array = request.security_lower_tf(syminfo.tickerid, higher_tf(res) ? str.tostring(f_chartTfInMinutes()) + (timeframe.isseconds ? "S" : "") : too_small_tf(res) ? (timeframe.isweekly ? "3" : "10") : res, src)
if array.size(bull_array) > 1 and not equal_tf(res) and not higher_tf(res)
bull_ := array.pop(bull_array)
array.clear(bull_array)
bull_
// === BASE FUNCTIONS ===
// Returns MA input selection variant, default to SMA if blank or typo.
variant(type, src, len, offSig, offALMA) =>
v1 = ta.sma(src, len) // Simple
v2 = ta.ema(src, len) // Exponential
v3 = 2 * v2 - ta.ema(v2, len) // Double Exponential
v4 = 3 * (v2 - ta.ema(v2, len)) + ta.ema(ta.ema(v2, len), len) // Triple Exponential
v5 = ta.wma(src, len) // Weighted
v6 = ta.vwma(src, len) // Volume Weighted
v7 = 0.0
sma_1 = ta.sma(src, len) // Smoothed
v7 := na(v7 ) ? sma_1 : (v7 * (len - 1) + src) / len
v8 = ta.wma(2 * ta.wma(src, len / 2) - ta.wma(src, len), math.round(math.sqrt(len))) // Hull
v9 = ta.linreg(src, len, offSig) // Least Squares
v10 = ta.alma(src, len, offALMA, offSig) // Arnaud Legoux
v11 = ta.sma(v1, len) // Triangular (extreme smooth)
// SuperSmoother filter
// 2013 John F. Ehlers
a1 = math.exp(-1.414 * 3.14159 / len)
b1 = 2 * a1 * math.cos(1.414 * 3.14159 / len)
c2 = b1
c3 = -a1 * a1
c1 = 1 - c2 - c3
v12 = 0.0
v12 := c1 * (src + nz(src )) / 2 + c2 * nz(v12 ) + c3 * nz(v12 )
type == 'EMA' ? v2 : type == 'DEMA' ? v3 : type == 'TEMA' ? v4 : type == 'WMA' ? v5 : type == 'VWMA' ? v6 : type == 'SMMA' ? v7 : type == 'HullMA' ? v8 : type == 'LSMA' ? v9 : type == 'ALMA' ? v10 : type == 'TMA' ? v11 : type == 'SSMA' ? v12 : v1
// security wrapper for repeat calls
reso(exp, use, res) =>
security_1 = request.security(syminfo.tickerid, res, exp, gaps = barmerge.gaps_off, lookahead = barmerge.lookahead_on)
use ? security_1 : exp
// === /BASE FUNCTIONS ===
// === SERIES SETUP ===
closeSeries = variant(basisType, close , basisLen, offsetSigma, offsetALMA)
openSeries = variant(basisType, open , basisLen, offsetSigma, offsetALMA)
// === /SERIES ===
// Get Alternate resolution Series if selected.
closeSeriesAlt = reso(closeSeries, useRes, stratRes)
openSeriesAlt = reso(openSeries, useRes, stratRes)
//
lxTrigger = false
sxTrigger = false
leTrigger = ta.crossover (closeSeriesAlt, openSeriesAlt)
seTrigger = ta.crossunder(closeSeriesAlt, openSeriesAlt)
G_RISK = '■ ' + 'Risk Management'
//#region ———— <↓↓↓ G_RISK ↓↓↓> {
// ———————————
//Tooltip
T_LVL = '(%) Exit Level'
T_QTY = '(%) Adjust trade exit volume'
T_MSG = 'Paste JSON message for your bot'
//Webhook Message
O_LEMSG = 'Long Entry'
O_LXMSGSL = 'Long SL'
O_LXMSGTP1 = 'Long TP1'
O_LXMSGTP2 = 'Long TP2'
O_LXMSGTP3 = 'Long TP3'
O_LXMSG = 'Long Exit'
O_SEMSG = 'Short Entry'
O_SXMSGSL = 'Short SL'
O_SXMSGA = 'Short TP1'
O_SXMSGB = 'Short TP2'
O_SXMSGC = 'Short TP3'
O_SXMSGX = 'Short Exit'
// ——————————— | | | Line length guide |
i_lxLvlTP1 = input.float (0.2, 'Level TP1' , group = G_RISK,
tooltip = T_LVL)
i_lxQtyTP1 = input.float (80.0, 'Qty TP1' , group = G_RISK,
tooltip = T_QTY)
i_lxLvlTP2 = input.float (0.5, 'Level TP2' , group = G_RISK,
tooltip = T_LVL)
i_lxQtyTP2 = input.float (10.0, 'Qty TP2' , group = G_RISK,
tooltip = T_QTY)
i_lxLvlTP3 = input.float (7.0, 'Level TP3' , group = G_RISK,
tooltip = T_LVL)
i_lxQtyTP3 = input.float (2, 'Qty TP3' , group = G_RISK,
tooltip = T_QTY)
i_lxLvlSL = input.float (0.5, 'Stop Loss' , group = G_RISK,
tooltip = T_LVL)
i_sxLvlTP1 = i_lxLvlTP1
i_sxQtyTP1 = i_lxQtyTP1
i_sxLvlTP2 = i_lxLvlTP2
i_sxQtyTP2 = i_lxQtyTP2
i_sxLvlTP3 = i_lxLvlTP3
i_sxQtyTP3 = i_lxQtyTP3
i_sxLvlSL = i_lxLvlSL
G_MSG = '■ ' + 'Webhook Message'
i_leMsg = input.string (O_LEMSG ,'Long Entry' , group = G_MSG, tooltip = T_MSG)
i_lxMsgSL = input.string (O_LXMSGSL ,'Long SL' , group = G_MSG, tooltip = T_MSG)
i_lxMsgTP1 = input.string (O_LXMSGTP1,'Long TP1' , group = G_MSG, tooltip = T_MSG)
i_lxMsgTP2 = input.string (O_LXMSGTP2,'Long TP2' , group = G_MSG, tooltip = T_MSG)
i_lxMsgTP3 = input.string (O_LXMSGTP3,'Long TP3' , group = G_MSG, tooltip = T_MSG)
i_lxMsg = input.string (O_LXMSG ,'Long Exit' , group = G_MSG, tooltip = T_MSG)
i_seMsg = input.string (O_SEMSG ,'Short Entry' , group = G_MSG, tooltip = T_MSG)
i_sxMsgSL = input.string (O_SXMSGSL ,'Short SL' , group = G_MSG, tooltip = T_MSG)
i_sxMsgTP1 = input.string (O_SXMSGA ,'Short TP1' , group = G_MSG, tooltip = T_MSG)
i_sxMsgTP2 = input.string (O_SXMSGB ,'Short TP2' , group = G_MSG, tooltip = T_MSG)
i_sxMsgTP3 = input.string (O_SXMSGC ,'Short TP3' , group = G_MSG, tooltip = T_MSG)
i_sxMsg = input.string (O_SXMSGX ,'Short Exit' , group = G_MSG, tooltip = T_MSG)
i_src = close
G_DISPLAY = 'Display'
//
i_alertOn = input.bool (true, 'Alert Labels On/Off' , group = G_DISPLAY)
i_barColOn = input.bool (true, 'Bar Color On/Off' , group = G_DISPLAY)
// ———————————
// @function Calculate the Take Profit line, and the crossover or crossunder
f_tp(_condition, _conditionValue, _leTrigger, _seTrigger, _src, _lxLvlTP, _sxLvlTP)=>
var float _tpLine = 0.0
_topLvl = _src + (_src * (_lxLvlTP / 100))
_botLvl = _src - (_src * (_sxLvlTP / 100))
_tpLine := _condition != _conditionValue and _leTrigger ? _topLvl :
_condition != -_conditionValue and _seTrigger ? _botLvl :
nz(_tpLine )
// @function Similar to "ta.crossover" or "ta.crossunder"
f_cross(_scr1, _scr2, _over)=>
_cross = _over ? _scr1 > _scr2 and _scr1 < _scr2 :
_scr1 < _scr2 and _scr1 > _scr2
// ———————————
//
var float condition = 0.0
var float slLine = 0.0
var float entryLine = 0.0
//
entryLine := leTrigger and condition <= 0.0 ? close :
seTrigger and condition >= 0.0 ? close : nz(entryLine )
//
slTopLvl = i_src + (i_src * (i_lxLvlSL / 100))
slBotLvl = i_src - (i_src * (i_sxLvlSL / 100))
slLine := condition <= 0.0 and leTrigger ? slBotLvl :
condition >= 0.0 and seTrigger ? slTopLvl : nz(slLine )
slLong = f_cross(low, slLine, false)
slShort = f_cross(high, slLine, true )
//
= f_tp(condition, 1.2,leTrigger, seTrigger, i_src, i_lxLvlTP3, i_sxLvlTP3)
= f_tp(condition, 1.1,leTrigger, seTrigger, i_src, i_lxLvlTP2, i_sxLvlTP2)
= f_tp(condition, 1.0,leTrigger, seTrigger, i_src, i_lxLvlTP1, i_sxLvlTP1)
tp3Long = f_cross(high, tp3Line, true )
tp3Short = f_cross(low, tp3Line, false)
tp2Long = f_cross(high, tp2Line, true )
tp2Short = f_cross(low, tp2Line, false)
tp1Long = f_cross(high, tp1Line, true )
tp1Short = f_cross(low, tp1Line, false)
switch
leTrigger and condition <= 0.0 => condition := 1.0
seTrigger and condition >= 0.0 => condition := -1.0
tp3Long and condition == 1.2 => condition := 1.3
tp3Short and condition == -1.2 => condition := -1.3
tp2Long and condition == 1.1 => condition := 1.2
tp2Short and condition == -1.1 => condition := -1.2
tp1Long and condition == 1.0 => condition := 1.1
tp1Short and condition == -1.0 => condition := -1.1
slLong and condition >= 1.0 => condition := 0.0
slShort and condition <= -1.0 => condition := 0.0
lxTrigger and condition >= 1.0 => condition := 0.0
sxTrigger and condition <= -1.0 => condition := 0.0
longE = leTrigger and condition <= 0.0 and condition == 1.0
shortE = seTrigger and condition >= 0.0 and condition == -1.0
longX = lxTrigger and condition >= 1.0 and condition == 0.0
shortX = sxTrigger and condition <= -1.0 and condition == 0.0
longSL = slLong and condition >= 1.0 and condition == 0.0
shortSL = slShort and condition <= -1.0 and condition == 0.0
longTP3 = tp3Long and condition == 1.2 and condition == 1.3
shortTP3 = tp3Short and condition == -1.2 and condition == -1.3
longTP2 = tp2Long and condition == 1.1 and condition == 1.2
shortTP2 = tp2Short and condition == -1.1 and condition == -1.2
longTP1 = tp1Long and condition == 1.0 and condition == 1.1
shortTP1 = tp1Short and condition == -1.0 and condition == -1.1
// ——————————— {
//
if strategy.position_size <= 0 and longE and barstate.isconfirmed
strategy.entry(
'Long',
strategy.long,
alert_message = i_leMsg,
comment = 'LE')
if strategy.position_size > 0 and condition == 1.0
strategy.exit(
id = 'LXTP1',
from_entry = 'Long',
qty_percent = i_lxQtyTP1,
limit = tp1Line,
stop = slLine,
comment_profit = 'LXTP1',
comment_loss = 'SL',
alert_profit = i_lxMsgTP1,
alert_loss = i_lxMsgSL)
if strategy.position_size > 0 and condition == 1.1
strategy.exit(
id = 'LXTP2',
from_entry = 'Long',
qty_percent = i_lxQtyTP2,
limit = tp2Line,
stop = slLine,
comment_profit = 'LXTP2',
comment_loss = 'SL',
alert_profit = i_lxMsgTP2,
alert_loss = i_lxMsgSL)
if strategy.position_size > 0 and condition == 1.2
strategy.exit(
id = 'LXTP3',
from_entry = 'Long',
qty_percent = i_lxQtyTP3,
limit = tp3Line,
stop = slLine,
comment_profit = 'LXTP3',
comment_loss = 'SL',
alert_profit = i_lxMsgTP3,
alert_loss = i_lxMsgSL)
if longX
strategy.close(
'Long',
alert_message = i_lxMsg,
comment = 'LX')
//
if strategy.position_size >= 0 and shortE and barstate.isconfirmed
strategy.entry(
'Short',
strategy.short,
alert_message = i_leMsg,
comment = 'SE')
if strategy.position_size < 0 and condition == -1.0
strategy.exit(
id = 'SXTP1',
from_entry = 'Short',
qty_percent = i_sxQtyTP1,
limit = tp1Line,
stop = slLine,
comment_profit = 'SXTP1',
comment_loss = 'SL',
alert_profit = i_sxMsgTP1,
alert_loss = i_sxMsgSL)
if strategy.position_size < 0 and condition == -1.1
strategy.exit(
id = 'SXTP2',
from_entry = 'Short',
qty_percent = i_sxQtyTP2,
limit = tp2Line,
stop = slLine,
comment_profit = 'SXTP2',
comment_loss = 'SL',
alert_profit = i_sxMsgTP2,
alert_loss = i_sxMsgSL)
if strategy.position_size < 0 and condition == -1.2
strategy.exit(
id = 'SXTP3',
from_entry = 'Short',
qty_percent = i_sxQtyTP3,
limit = tp3Line,
stop = slLine,
comment_profit = 'SXTP3',
comment_loss = 'SL',
alert_profit = i_sxMsgTP3,
alert_loss = i_sxMsgSL)
if shortX
strategy.close(
'Short',
alert_message = i_sxMsg,
comment = 'SX')
// ———————————
c_tp = leTrigger or seTrigger ? na :
condition == 0.0 ? na : color.green
c_entry = leTrigger or seTrigger ? na :
condition == 0.0 ? na : color.blue
c_sl = leTrigger or seTrigger ? na :
condition == 0.0 ? na : color.red
p_tp1Line = plot (
condition == 1.0 or
condition == -1.0 ? tp1Line : na,
title = "TP Line 1",
color = c_tp,
linewidth = 1,
style = plot.style_linebr)
p_tp2Line = plot (
condition == 1.0 or
condition == -1.0 or
condition == 1.1 or
condition == -1.1 ? tp2Line : na,
title = "TP Line 2",
color = c_tp,
linewidth = 1,
style = plot.style_linebr)
p_tp3Line = plot (
condition == 1.0 or
condition == -1.0 or
condition == 1.1 or
condition == -1.1 or
condition == 1.2 or
condition == -1.2 ? tp3Line : na,
title = "TP Line 3",
color = c_tp,
linewidth = 1,
style = plot.style_linebr)
p_entryLine = plot (
condition >= 1.0 or
condition <= -1.0 ? entryLine : na,
title = "Entry Line",
color = c_entry,
linewidth = 1,
style = plot.style_linebr)
p_slLine = plot (
condition == 1.0 or
condition == -1.0 or
condition == 1.1 or
condition == -1.1 or
condition == 1.2 or
condition == -1.2 ? slLine : na,
title = "SL Line",
color = c_sl,
linewidth = 1,
style = plot.style_linebr)
fill(
p_tp3Line, p_entryLine,
color = leTrigger or seTrigger ? na :color.new(color.green, 90))
fill(
p_entryLine, p_slLine,
color = leTrigger or seTrigger ? na :color.new(color.red, 90))
//
plotshape(
i_alertOn and longE,
title = 'Long',
text = 'Long',
textcolor = color.white,
color = color.green,
style = shape.labelup,
size = size.tiny,
location = location.belowbar)
plotshape(
i_alertOn and shortE,
title = 'Short',
text = 'Short',
textcolor = color.white,
color = color.red,
style = shape.labeldown,
size = size.tiny,
location = location.abovebar)
plotshape(
i_alertOn and (longX or shortX) ? close : na,
title = 'Close',
text = 'Close',
textcolor = color.white,
color = color.gray,
style = shape.labelup,
size = size.tiny,
location = location.absolute)
l_tp = i_alertOn and (longTP1 or shortTP1) ? close : na
plotshape(
l_tp,
title = "TP1 Cross",
text = "TP1",
textcolor = color.white,
color = color.olive,
style = shape.labelup,
size = size.tiny,
location = location.absolute)
plotshape(
i_alertOn and (longTP2 or shortTP2) ? close : na,
title = "TP2 Cross",
text = "TP2",
textcolor = color.white,
color = color.olive,
style = shape.labelup,
size = size.tiny,
location = location.absolute)
plotshape(
i_alertOn and (longTP3 or shortTP3) ? close : na,
title = "TP3 Cross",
text = "TP3",
textcolor = color.white,
color = color.olive,
style = shape.labelup,
size = size.tiny,
location = location.absolute)
plotshape(
i_alertOn and (longSL or shortSL) ? close : na,
title = "SL Cross",
text = "SL",
textcolor = color.white,
color = color.maroon,
style = shape.labelup,
size = size.tiny,
location = location.absolute)
//
plot(
na,
title = "─── ───",
editable = false,
display = display.data_window)
plot(
condition,
title = "condition",
editable = false,
display = display.data_window)
plot(
strategy.position_size * 100,
title = ".position_size",
editable = false,
display = display.data_window)
//#endregion }
// ——————————— <↑↑↑ G_RISK ↑↑↑>
//#region ———— <↓↓↓ G_SCRIPT02 ↓↓↓> {
// @function Queues a new element in an array and de-queues its first element.
f_qDq(_array, _val) =>
array.push(_array, _val)
_return = array.shift(_array)
_return
var line a_slLine = array.new_line(1)
var line a_entryLine = array.new_line(1)
var line a_tp3Line = array.new_line(1)
var line a_tp2Line = array.new_line(1)
var line a_tp1Line = array.new_line(1)
var label a_slLabel = array.new_label(1)
var label a_tp3label = array.new_label(1)
var label a_tp2label = array.new_label(1)
var label a_tp1label = array.new_label(1)
var label a_entryLabel = array.new_label(1)
newEntry = longE or shortE
entryIndex = 1
entryIndex := newEntry ? bar_index : nz(entryIndex )
lasTrade = bar_index >= entryIndex
l_right = 10
line.delete(
f_qDq(a_slLine,
line.new(
entryIndex,
slLine,
last_bar_index + l_right,
slLine,
style = line.style_solid,
color = c_sl)))
line.delete(
f_qDq(a_entryLine,
line.new(
entryIndex,
entryLine,
last_bar_index + l_right,
entryLine,
style = line.style_solid,
color = color.blue)))
line.delete(
f_qDq(a_tp3Line,
line.new(
entryIndex,
tp3Line,
last_bar_index + l_right,
tp3Line,
style = line.style_solid,
color = c_tp)))
line.delete(
f_qDq(a_tp2Line,
line.new(
entryIndex,
tp2Line,
last_bar_index + l_right,
tp2Line,
style = line.style_solid,
color = c_tp)))
line.delete(
f_qDq(a_tp1Line,
line.new(
entryIndex,
tp1Line,
last_bar_index + l_right,
tp1Line,
style = line.style_solid,
color = c_tp)))
label.delete(
f_qDq(a_slLabel,
label.new(
last_bar_index + l_right,
slLine,
'SL: ' + str.tostring(slLine, '##.###'),
style = label.style_label_left,
textcolor = color.white,
color = c_sl)))
label.delete(
f_qDq(a_entryLabel,
label.new(
last_bar_index + l_right,
entryLine,
'Entry: ' + str.tostring(entryLine, '##.###'),
style = label.style_label_left,
textcolor = color.white,
color = color.blue)))
label.delete(
f_qDq(a_tp3label,
label.new(
last_bar_index + l_right,
tp3Line,
'TP3: ' + str.tostring(tp3Line, '##.###'),
style = label.style_label_left,
textcolor = color.white,
color = c_tp)))
label.delete(
f_qDq(a_tp2label,
label.new(
last_bar_index + l_right,
tp2Line,
'TP2: ' + str.tostring(tp2Line, '##.###'),
style = label.style_label_left,
textcolor = color.white,
color = c_tp)))
label.delete(
f_qDq(a_tp1label,
label.new(
last_bar_index + l_right,
tp1Line,
'TP1: ' + str.tostring(tp1Line, '##.###'),
style = label.style_label_left,
textcolor = color.white,
color = c_tp)))
// ———————————
//
if longE or shortE or longX or shortX
alert(message = 'Any Alert', freq = alert.freq_once_per_bar_close)
if longE
alert(message = 'Long Entry', freq = alert.freq_once_per_bar_close)
if shortE
alert(message = 'Short Entry', freq = alert.freq_once_per_bar_close)
if longX
alert(message = 'Long Exit', freq = alert.freq_once_per_bar_close)
if shortX
alert(message = 'Short Exit', freq = alert.freq_once_per_bar_close)
//#endregion }
// ——————————— <↑↑↑ G_SCRIPT03 ↑↑↑>
Super Signals (High Accuracy)Test it and you will juge it by yourself..a high winrate +90%
NO REPAINTING, NO LAGGING
NISHIN 12NISHIN 12 – First 30-Minute Session High/Low (Asian & European Sessions)
NISHIN 12 is a price action–based indicator that highlights the first 30 minutes (3 × 10-minute candles) of two key trading sessions in IST (Indian Standard Time):
Asian Session → 5:30 AM – 6:00 AM IST
European Session → 12:30 PM – 1:00 PM IST
📌 After the first 30 minutes, the indicator automatically locks the session high and low and extends them forward as support and resistance levels.
Features:
Marks the high and low of the first 30 minutes of Asian and European sessions.
Customizable colors and line extensions.
Alerts for breakouts above session highs or breakdowns below session lows.
Helps intraday traders spot early volatility zones and plan trades.
This indicator is ideal for breakout traders, scalpers, and intraday price action traders who rely on session-based ranges to make trading decisions.
⚡ Use it along with your trading strategy for improved precision and risk management.
Support & Resistance （高成交量箱体）支撑与阻力（高成交量箱体）— 基于成交量方向与枢轴点自动绘制“箱体”支撑/阻力，突破变虚线、保持为实线，并用中文字符“阻/撑”与标签提示突破与回测；作者：李天天；Pine v5，叠加到主图。
Name: Support & Resistance (High-Volume Boxes) — auto-draws “box” support/resistance from directional volume and pivot points; dashed when broken and solid when held, with Chinese glyphs “阻/撑” and labels highlighting breakouts/retests; Author: Li Tiantian; Pine v5, overlay on price.
阻力支撑箱体
原理：以 K 线涨跌判定买卖量，构造“正负成交量”序列；当出现 pivot low 且正量显著 时在低位绘制支撑箱体，出现 pivot high 且负量显著 时在高位绘制阻力箱体；箱体厚度 = ATR(200) × 宽度系数，右边界随时间自适应延展。
Mechanism: classify up/down bars to build a signed volume stream; draw a support box at a pivot low with strong positive volume and a resistance box at a pivot high with strong negative volume; box thickness = ATR(200) × width factor, with the right edge auto-extended over time.
阻力支撑箱体
突破与保持：价格 向上穿越阻力上沿 记为突破阻力，未上破阻力 记为阻力保持；价格 向下穿越支撑下沿 记为跌破支撑，未跌破支撑 记为支撑保持；突破后箱体边框改为虚线并改变底色透明度。
Break & hold: crossing above resistance upper band flags a breakout, failing to close above resistance means it holds; crossing below support lower band flags a breakdown, failing to close below support means it holds; after break, the box switches to dashed border and adjusted fill.
阻力支撑箱体
可视化：图上绘制 “阻力保持=‘阻’（红，K线上方）/ 支撑保持=‘撑’（绿，K线下方）”；当 阻力转支撑 或 支撑转阻力 且保持时，分别用“撑”或“阻”标记；同时在突破当根前一根位置打出 “突破阻力 / 跌破支撑” 标签。
Visualization: plots “阻” (red, above bars) for resistance hold and “撑” (green, below bars) for support hold; when resistance flips to support or support flips to resistance and holds, it prints “撑” or “阻” accordingly; breakout labels (“Break Resistance” / “Break Support”) are printed one bar back at the level.
阻力支撑箱体
参数与设置：回看周期 控制 pivot 灵敏度（越大越稳健）；成交量差过滤长度 用于筛除低量噪声（越大越严格）；箱体宽度调整 以 ATR(200) 为基准控制箱体厚度；最大箱体数默认 50。
Inputs & settings: Lookback period tunes pivot sensitivity (larger = more robust); volume-delta length filters low-volume noise (larger = stricter); box width factor scales thickness from ATR(200); max box count defaults to 50.
阻力支撑箱体
使用方法：将脚本添加至图表并叠加主图→根据品种与周期调大/调小回看周期与成交量过滤→用箱体边界作为结构位，观察“阻/撑”与标签提示 突破/保持/转换 来辅助判定进出场与止损迁移。
How to use: add to chart (overlay) → calibrate lookback and volume filtering for your symbol/timeframe → treat box bounds as structure levels; read “阻/撑” and labels for break/hold/flip to guide entries and stop adjustments.
阻力支撑箱体
调参建议：波动剧烈或假突破多时，提高回看周期 与 加大过滤长度；趋势单边强时，可略 放宽过滤 以更快识别新箱体；箱体过厚影响精度时，下调 箱体宽度调整。
Tuning tips: in whipsaw/high-noise markets, increase lookback and raise filter length; in strong one-sided trends, loosen filtering to detect fresh boxes earlier; if boxes look too thick, reduce the width factor.
阻力支撑箱体
注意事项：本指标不含 alertcondition，主要依靠可视标记；对象数量受平台上限影响，历史过长或频繁触发时可适当缩短回看或减少过滤开销；仅作为技术参考，不构成交易建议。
Notes: no built-in alertcondition; use the on-chart marks for cues; object counts are platform-limited—trim history or adjust filters if performance/clutter arises; for research only, not investment advice.
Aslan | Price Action Toolkit [6.5]A high-precision suite of tools designed for traders who rely on market structure, liquidity, and smart money concepts. Each component is engineered to provide deeper insight into price behavior across multiple timeframes, helping you make more informed decisions with greater confidence.
🚀| Market Structure (BOS, CHoCH, CHoCH+, EQH/L – Internal & Swing | Multi-Timeframe)
This feature automatically detects critical structural shifts in price, including:
Break of Structure (BOS): Indicates continuation of a trend after surpassing a key swing high or low.
Change of Character (CHoCH): Marks the potential beginning of a reversal in market direction.
CHoCH+: A more aggressive variant of CHoCH with additional confirmation logic.
Equal Highs/Lows (EQH/EQL): Highlights areas of engineered liquidity and potential sweep zones.
The system distinguishes between internal and swing structure and supports multi-timeframe mapping, giving you a complete picture of short-term and long-term market behavior.
📈| Volumetric Order Blocks & Mitigation Methods (Bullish & Bearish)
Order Blocks represent zones where institutional orders are likely placed.
This tool identifies bullish and bearish order blocks with volumetric validation, increasing confidence in their strength.
It includes multiple mitigation techniques—such as close-based or wick-based validation—to help determine whether an order block remains valid or has been absorbed.
💸| Liquidity Concepts
A robust framework for identifying where liquidity is building and how it may be exploited:
Highlights areas where traders are trapped or clustered.
Supports both internal and external liquidity mapping.
Helps traders anticipate stop hunts and engineered price moves.
💰| Trend Line Liquidity Zones
Trendlines often act as liquidity traps. This tool automatically detects zones where price may sweep liquidity resting along diagonal support/resistance levels—commonly used in smart money and stop-hunting strategies.
💎| Imbalance Concepts (MTF) with Multiple Mitigation Methods
Maps out price imbalances (Fair Value Gaps) across multiple timeframes, which often act as magnets for price.
Includes several mitigation techniques to assess whether an imbalance has been filled or still holds relevance—ideal for refining entry and exit zones.
✨| Fair Value Gaps (FVGs)
These represent areas where price moved too aggressively, leaving inefficiencies in the market. The toolkit identifies FVGs in real time, often aligning with institutional re-entry zones for trend continuation or reversals.
🪙| Strong/Weak Highs & Lows
Automatically differentiates between strong and weak highs/lows based on how price interacts with them.
Strong levels suggest continuation.
Weak levels signal vulnerability and potential for being swept.
This provides critical confluence when combined with structure and liquidity analysis.
💹| Premium & Discount Zones
Defines whether price is trading in a premium (overvalued) or discount (undervalued) zone relative to a key range (often based on swing structure). These zones help you frame entries in alignment with institutional pricing models.
💷|Previous Highs/Lows
Tracks and plots important historical levels, including:
Daily High/Low, Monday’s High/Low, Weekly, Monthly, and Quarterly Highs/Lows
These levels are frequently used as targets or reversal zones due to their psychological and algorithmic importance in institutional trading.
Our Price Action Toolkit offers a powerful, data-driven edge for traders who rely on structure, liquidity, and institutional-level insights. By combining advanced market logic with real-time automation, it equips you to read the market with greater clarity, precision, and confidence—across any timeframe or asset. Whether you're trading breakouts, reversals, or liquidity sweeps, this toolkit adapts to your style and sharpens your edge in every market condition.
VCP-MinerviniThis script is built on Mark Minervini’s famous Volatility Contraction Pattern (VCP) and shows you automatic breakout signals directly on the chart.
VCP Detection: The script checks if volatility (ATR) is contracting. A yellow dot marks potential VCP setups.
Pivot Level: A resistance (pivot high) is calculated and displayed as a red line.
Breakout Signal: When price breaks above the pivot and stays over the EMA filter, a green dot confirms the breakout.
Exit Logic: If volume and range drop below average, the breakout is considered ended.
EMA Filter: Ensures setups only appear when price is above the moving average.
With this, you get a clear visualization: yellow shows setups, red the key resistance, and green confirms the breakout.
Trapped Orders by AlphaTrapped orders detector
it looks at volume price patterns and many other things.
- Alpha
THUẬN-VolumeOverall Purpose
This indicator is a powerful tool based on the foundational principles of the Wyckoff Method and Volume Spread Analysis (VSA). Its primary goal is to decode the story behind the price chart by analyzing the intricate relationship between price action (spread), volume (effort), and the closing price (result). By doing so, it helps traders identify supply and demand imbalances, anticipate potential trend changes, and spot the activity of institutional players or "Smart Money."
Core Concepts Explained
The indicator is built upon Richard Wyckoff's law of "Effort vs. Result."
Effort is represented by the volume on a price bar.
Result is represented by the price spread (the range from the high to the low of the bar).
By comparing the effort (volume) to the result (price spread), the indicator detects critical market confirmations and anomalies. For example, high volume (great effort) that results in a narrow price spread (poor result) signals a potential turning point.
Key Features
Relative Volume Analysis:
The indicator doesn't just show raw volume. It automatically analyzes and classifies volume levels by comparing the current bar's volume to a moving average of recent volume.
Volume bars are color-coded for instant interpretation:
Ultra-High Volume (Climactic): Signals potential trend exhaustion or major institutional activity.
High Volume: Confirms the strength behind a price move.
Average Volume: Represents normal market activity.
Low Volume: Indicates a lack of interest, often crucial for "No Supply" or "No Demand" signals.
VSA Signal Detection & On-Chart Labels:
The core of the indicator is its ability to automatically detect classic VSA patterns and display clear labels on the chart. These signals are grouped into signs of strength and weakness.
Signs of Strength - Bullish Signals:
Stopping Volume: An alert for ultra-high volume at the bottom of a downtrend, suggesting that massive buying is absorbing the selling pressure.
Test for Supply: A down-bar with a narrow spread on low volume, indicating that sellers are exhausted and the market is ready to move up.
No Supply Bar: A down-bar with low volume, showing a lack of selling interest, often confirming the path is clear for higher prices.
Signs of Weakness - Bearish Signals:
Upthrust Bar: A sharp move up that is quickly rejected, closing near the low. It signals that demand has been overwhelmed by supply.
No Demand Bar: An up-bar with low volume, indicating a lack of buying interest and warning that the uptrend is weak.
Selling Climax: An ultra-high volume bar at the top of an uptrend, signaling trend exhaustion and a potential reversal.
Customizable Settings:
Users can adjust the lookback period for the volume moving average, change the sensitivity for signal detection, and toggle specific signals on or off to declutter the chart and focus on their preferred setups.
How to Use in Trading
Confirmation: Use VSA signals to confirm price action at key support, resistance, or supply/demand zones. A "Test for Supply" at a support level is a strong confirmation for a long entry.
Trend Analysis: Spot trend weakness when you see consecutive "No Demand" bars in an uptrend or "No Supply" bars in a downtrend.
Anticipating Reversals: Climactic volume signals (Buying/Selling Climax, Stopping Volume) often appear at major market turning points, providing early warnings of a potential trend reversal.
In summary, this indicator allows traders to move beyond simple technical patterns and gain a deeper understanding of the market dynamics, helping to align their trades with the flow of institutional capital.
Stocks PDH/PDL (RTH) + Pre-Mkt H/L + Silver Bullet + DirectionStocks PDH/PDL (RTH) + Pre-Mkt H/L + Silver Bullet + Direction
Avivs Market Dashboard • Draws a clean watermark table on the chart (position/size/color configurable).
• Shows ATR(14) with a green/yellow/red emoji based on % thresholds.
• Shows earnings countdown (“X days remaining”) if available.
• Plots SMA 20 and SMA 150 on the chart (colors/width toggles).
• Adds a row with % distance to SMA150 (no plotting of the % on price).
• Adds a row with % distance to the all-time high (ATH) (“below/above”).
• Includes optional inputs for symbol/timeframe/sector/company info (currently commented out in the table)
MACD + RSI + Supertrend + ATR Filter Signals (15min) Azam JaniThis indicator combines MACD crossover, RSI, and Supertrend with a volatility filter to generate high-probability buy and sell signals on the 15-minute timeframe. It is designed to avoid signals during sideways or low-volatility markets, helping traders focus only on strong trending conditions.
Pipnotic HTF BarsDescription:
Pipnotic HTF Bars projects higher-timeframe (HTF) candles to the right of current price so you can “peek ahead” with clean, fixed-width silhouettes. The latest HTF bar updates live until it closes; completed HTF bars are frozen and kept in a tidy row to the right. Bodies inherit up/down colours, wicks sit on the body edge (no line through the body), and transparency/borders are configurable for a lightweight, elegant overlay.
How It Works:
The script reads true HTF opens via request.security and detects new HTF boundaries precisely.
Completed HTF bars are captured with look ahead off and stored; they never repaint.
The current HTF bar uses look ahead on and updates tick-by-tick until the next HTF bar begins.
Each candle is drawn as a fixed bar-index width box and wick, anchored a set number of bars to the right of the chart, then spaced evenly.
Visualization and Management:
Candles are rendered as boxes (bodies) plus edge-wicks (coloured to match the body).
You choose how many completed HTF candles to keep visible; older ones are automatically pruned.
Width, spacing, transparency, and borders make the projection readable without cluttering price.
Designed to stay performant and within TradingView’s shape limits.
Key Features & Inputs:
Higher Timeframe (HTF): W, D, 240, 120, 60, 30, 15.
Live Current Bar: The most recent HTF candle updates until it closes (no duplicate static bar).
Number of Candles: Keep the last N completed HTF candles to the right.
Fixed Projection Geometry:
Projected width (bars) : set a constant visual width per candle.
Gap (bars) : spacing between projected candles.
Right shift : anchor the projection a fixed distance beyond the latest bar.
Styling : Up/Down colours, body transparency, optional borders, wicks coloured same as body and drawn from body edge → high/low (never through the body).
Overlay : Works on any symbol and chart timeframe.
Enhanced Visualization:
Edge-wicks align visually with the close side of the body, producing a crisp, unobstructed read of range (H–L) and direction (O→C).
Fixed widths and even spacing create a timeline-like panel to the right of price, ideal for multi-timeframe context without compressing your main chart.
Transparency lets you “ghost” the projection so LTF price action remains visible beneath.
Benefits of Using the Pipnotic HTF Script:
Instant HTF context without switching charts or compressing the main view.
Non-repainting history: Completed HTF candles are locked the moment a new one starts.
Cleaner decision surface: Edge-wicks and soft transparency reduce visual noise.
Time-saving workflow: Scan upcoming HTF structure at a glance (range, bias, progress).
Configurable & lightweight: Tune width, spacing, and count to fit any layout.
Tip: Using the daily HTF on an hourly or less timeframe and watching as price tests the open of the current day, especially if prices e.g. traded below the open, can provide some great trades as prices move above and retest the open.
10% of 50 EMA//@version=5
indicator("10% of 50 EMA", overlay=true)
// 50-period EMA
ema50 = ta.ema(close, 50)
// 10% of 50 EMA
ema10pct = ema50 * 0.10
// Plot only 10% line
plot(ema10pct, color=color.red, title="10% of 50 EMA")
All in One 指标套件🔵 Double Harami
The Double Harami indicator identifies a two-step inside-bar compression: the first inside bar is fully contained within the mother bar, and the second inside bar is fully contained within the first. This pattern often signals volatility contraction ahead of a potential strong breakout. The indicator confirms signals at bar close and marks them above price for clear visual detection. It also supports alert conditions, allowing traders to be notified when the pattern completes. Use it to monitor periods of tightening price action and prepare for possible momentum expansion, while combining with context (trend, S/R, volume) for higher-confidence setups.
gold scaling_V2.2 (Zone-Driven Entries + BB Entries) — Dual-Set
Short Description (for the “Description” box)
gold scaling_V2.2 (Zone-Driven Entries + BB Entries) — Dual-Set
Two coordinated entry engines. Set A (Zone-Driven): dynamic buy/sell zones with anti-chase (first-touch, flip-guard, hysteresis), TP1–TP5 ladder, and smart SL (BE/Follow/Chandelier). Set B (BB mini): fast Bollinger-based entries with HTF/BBW filters. Compact HUD, Heads-Up ETA, and full Text/JSON alerts (ENTRY/TP/SL). Built for disciplined entries, not FOMO.
Full Description
Overview
This indicator enforces disciplined entries by combining two complementary systems:
Set A — Zone-Driven Entries: builds adaptive buy/sell zones (ATR-aware), confirms entries in two steps (touch → confirm), and manages exits with a TP ladder and intelligent SL logic (move to Break-Even at TP1, follow by TP levels, or optional Chandelier trail). Includes zone lock/re-arm after real breakouts.
Set B — BB Entries (mini): lightweight Bollinger-based “mini” entries (Revert Cross or Cross Threshold) that respect HTF EMA slope and BB Width filters.
Timeframes:
Set A (Zone) works best on M15–H1; Set B (mini) is great for M5–M30 to catch tactical moves inside the bigger structure.
Quick Start
Add to chart → Entry Sets: enable Set A (Zone) and/or Set B (BB mini).
Alerts: turn on Enable Auto Alerts and create one alert with Any alert() function call → Once per bar close.
Webhook/automation: toggle Use JSON to emit machine-readable alerts.
Filters: enable HTF Trend Filter and/or BB Width filter to improve signal quality.
Stops: choose SL mode (ATR ×, Percent, Points). Configure SL→BE on TP1, Follow by TP, or Chandelier Trail.
Signal Architecture
Set A — Zone-Driven (primary entries)
Trigger: price touches/crosses zone edge → pending → confirm with hysteresis and minimum real body (ATR-scaled) aligned with side.
Anti-Chase: firstTouchOnly, max entries per zone, flipGuardBars, optional body-displacement (ATR×), and global lock after any entry.
Breakout Handling: lock zones after a meaningful break (close beyond edge ≥ ATR×). Re-arm by Retest / Time / Retest OR Time.
TP Ladder: TP1–TP5 lines with labels and fills.
Smart SL: move to BE at TP1, follow TP levels (rate-limited and ATR-buffered), or Chandelier.
Set B — BB Entries (mini)
Modes: Revert Cross (default) or Cross Threshold.
Honors HTF EMA slope and BB Width if enabled.
Separate per-side cooldown to reduce spam.
Heads-Up & HUD
Heads-Up ETA: estimates minutes to nearest band/basis or compression-to-expansion spike.
HUD: shows symbol/TF/side, Entry/SL, TP1–TP5 RR snapshot, W/L from Zone set, and HU/Vol lines.
Alerts
Auto alerts (recommended, via alert())
Create one alert: Any alert() function call → Once per bar close. It covers everything.
ENTRY (Zone):
Key Settings (what matters most)
Strategy Settings: tradeDirection (gate signals by side), entryStrategy for BB.
Entry Sets: toggle Set A (Zone) and Set B (BB mini) independently.
Bollinger Bands Settings: bbLength, bbMult; if BB Width filter is on, define min/max width (% of price).
Alert Settings: Enable Auto Alerts, Use JSON, cooldownSeconds, maxOneTPPerBar.
Anti-Chase / Zone State: firstTouchOnly, maxEntriesPerZonePerSide, flipGuardBars, requireRetest, hysteresisAtrMult, confirmBodyAtrMult, globalLockBars, lockZonesOnBreakout, rearmMode.
Stop Loss: SL mode + SL→BE on TP1, Follow by TP (slMoveFraction, confirm/hold bars, ATR buffer), Chandelier.
TP Zones: mult_dist for step size, zoneExpireBars for auto-cleanup.
HUD/Labels: mini label colors, HUD theme/size.
Tuning Guide
Too few entries: reduce flipGuardBars, confirmBodyAtrMult, or hysteresisAtrMult; relax BB width bounds; increase maxEntriesPerZonePerSide.
Noisy/fake entries: raise flipGuardBars, enable requireFlipDisplacement (increase flipDispATRmult), tighten BB width bounds, enable alertsFollowTradeDirection.
SL moves too fast/slow: adjust slMinBarsBetweenMoves, slFollowConfirmBars, slMoveFraction, and slFollowAtrBufferMult.
Prefer retests after breaks: lockZonesOnBreakout = true + rearmMode = "Retest only".
Repaint & Transparency
Entries fire on bar close when alertsOnClose=true (default), with multi-layer confirmation to reduce hindsight changes.
Heads-Up/Spike are predictive helpers, not entry rules; they may update as new data comes in.
Visual overlays (divergence/oscillators) are supportive, not mandatory to the entry logic.
NISHIN 11NISHIN 11 is a price action tool that automatically marks the first 5-minute high and low of two key market sessions in IST (Indian Standard Time):
Asian Session → 5:30 AM – 5:35 AM IST
European Session → 12:30 PM – 12:35 PM IST
📌 Once these ranges are formed, the indicator extends horizontal lines across the chart, helping traders visualize session-based support and resistance levels.
Key Features:
Marks the high and low of the first 5 minutes of both sessions.
Configurable colors and line extensions.
Alerts when price breaks above the high or drops below the low of each session.
Helps in breakout/breakdown trading strategies.
This tool is particularly useful for intraday traders who want to track early-session volatility and plan entries/exits around these critical levels.
⚡ Use it with your own trading system for better precision and confidence.
Sigma Reversal Print [FxScripts]Indicator Overview
The Sigma Reversal Print is a powerful tool designed for traders who like to trade reversal strategies plus trend traders looking to enter on strong pullbacks. It integrates advanced price action with volume analysis, highlighting areas where a trend reversal or pullback may be in progress, providing insights into where markets may be exhausted or about to surge.
Key Features and Functionality
Reversal Trading: Tailored primarily for reversal traders, the Sigma Reversal Print highlights zones where the market is likely to change direction. While this approach offers significant potential, it inherently carries a degree of risk due to the precision required in predicting market turning points. The Sigma Reversal Print uses advanced methodology to forecast such reversals with a high degree of accuracy.
Signal Generation Based on Reversal and Pullback Zones: The Reversal Print generates signals when price enters specific conditions, representing exhaustion followed by a change in order flow. These conditions allow the indicator to filter out low-probability signals and focus on those with higher potential for a trend change.
Settings
Sensitivity Control: The sensitivity setting allows traders to adjust the strength of the pattern required for a signal to be generated. The scale ranges from 2-10 with higher sensitivity demanding more confirmation, leading to fewer, generally more reliable, signals however backtesting is highly recommended. Adjusting the sensitivity enables traders to balance early entries with signal accuracy, accommodating both aggressive and more conservative strategies.
Customizable Length: The length setting allows users to fine-tune the calculation period, adjusting the indicator’s responsiveness to overall market conditions. Adjusting length allows the Reversal Print to adapt to the user’s trading style and timeframe of choice. Similar to the sensitivity control, the scale ranges from 2-10 with a higher length demanding more confirmation. This can lead to fewer, often more reliable, signals however, once again, backtesting is highly recommended.
Advanced Filters
Opening Gap Filter: Turning this on allows the system to avoid painting false signals that can be triggered by the daily or weekly opening gap at market open. This setting is toggled on by default.
Price Filter: This filter applies an additional weighted price action algorithm to the signal being painted thus further filtering out weaker signals. Warning dots will still paint however the larger break arrow will no longer paint if the filter is triggered. This setting is toggled on by default.
Volume Filter: This filters out low volume entries which have a lower probability of turning into successful trades. Variable from 1-10 with 1 being the most lenient and 10 the most stringent. Warning dots will still paint however the larger break arrow will no longer paint if the filter is triggered. This setting is toggled on by default.
Alerts
Configure alerts and receive notifications when the first warning dot in a sequence appears (the series of dots seen on the chart) and again when a breakpoint is triggered (the larger arrow on the chart). This feature is particularly beneficial for traders who like to monitor multiple instruments or prefer not to stare at a screen all day.
Performance and Optimization
Backtesting Results: The Reversal Print has undergone extensive backtesting across various instruments, timeframes and market conditions, demonstrating strong performance in identifying reversal points, particularly during volatile or overextended price movements. User backtesting is strongly encouraged as it allows traders to optimize settings for their preferred instruments and timeframes.
Optimization for Diverse Markets: The Reversal Print can be used on crypto, forex, indices, commodities or stocks. The Reversal Print's algorithmic foundation ensures consistent performance across a variety of instruments. Key settings such as Sensitivity and Length will require adjustment based on the volatility and characteristics of each market.
Educational Resources and Support
Users of the Sigma Reversal Print benefit from comprehensive educational resources and full access to FxScripts Support. This ensures traders can maximize the potential of the Reversal Print and other tools in the Sigma Indicator Suite by learning best practices and gaining insights from an experienced team of traders.
Summary
The Reversal Print is a powerful and adaptable tool for reversal and pullback traders, combining statistical analysis and price action to identify high-probability turning points. Its advanced customization options, flexible controls and integration with the Sigma Indicator Suite offer significant advantages over standard indicators. By pinpointing precise entry points, the Reversal Print enables traders to make informed trading decisions with confidence.
