本页源码来自 TradingView 公开发布的开源脚本,版权归原作者所有, 请遵循其原始许可(Pine 脚本常见 CC BY-NC-SA / MPL-2.0 / MIT)。 本项目仅用于研究检索与许可范围内的移植。
//@version=6
// ============================================================================
// ICT Setup Screener — Liquidity Sweep, MSS & FVG Scanner, 20 Symbols [LunqFX]
// ----------------------------------------------------------------------------
// An ICT entry is a SEQUENCE, not a signal: liquidity is swept, structure
// shifts, the displacement leaves an imbalance, price returns to it. Watching
// one chart you see one instrument's sequence. This tool runs the same
// sequence on twenty instruments at once and ranks them by how far along
// each one is — so the question "where is a setup forming right now" is
// answered by one table instead of twenty tabs.
//
// Every row is a state machine on its own symbol:
//
// SCANNING → SWEPT (waiting for the shift) → SETUP (MSS confirmed,
// FVG entry mapped) → OPEN (price has returned into the imbalance) →
// TARGET or STOPPED
//
// Rows are sorted live, hottest first. Quality 0-100 grades each setup by
// sweep depth, displacement, FVG size and how fast the shift came.
//
// NON-REPAINTING: swings are confirmed pivots and every transition happens
// on a closed bar of the scan timeframe. A row never walks back a stage.
// ============================================================================
indicator("ICT Setup Screener, Liquidity Sweep, MSS & FVG Scanner [LunqFX]",
"ICT Screener", overlay = true)
// ─────────────────────────────────────────────────────────────────────────
// PALETTE
// ─────────────────────────────────────────────────────────────────────────
UP = #00F5D4
DN = #FF2E88
AMBER = #FBBF24
INK = #0B0E14
CARD = #131A24
CARD2 = #1B2431
TXT = #F1F5F9
MUTE = #94A3B8
DIMTX = #5B6B80
// ─────────────────────────────────────────────────────────────────────────
// INPUTS
// ─────────────────────────────────────────────────────────────────────────
gM = "Entry model"
scanTF = input.timeframe("", "Scan timeframe", group = gM, tooltip = "Blank = the chart's timeframe. Set a fixed one (15, 60) so the table reads the same on any chart you open. Rows on a higher timeframe update when that timeframe's bar closes.")
pivLen = input.int(8, "Liquidity swing length", minval = 2, maxval = 50, group = gM, tooltip = "Which swings hold the stops that get swept. Higher = only major liquidity.")
intLen = input.int(3, "Internal structure length", minval = 1, maxval = 20, group = gM, tooltip = "The short-term swing whose break confirms the shift after the sweep.")
maxWait = input.int(20, "Max bars sweep → MSS", minval = 3, maxval = 100, group = gM, tooltip = "If structure does not shift within this many bars the sweep is discarded.")
lifeN = input.int(30, "Max bars setup → entry", minval = 3, maxval = 200, group = gM, tooltip = "A mapped setup that price never returns to within this many bars is dropped.")
openN = input.int(80, "Max bars in trade", minval = 5, maxval = 500, group = gM, tooltip = "An entered setup that has touched neither stop nor target within this many bars is retired from the table. The screener is for finding setups, not for babysitting a position for a week.")
rrMult = input.float(2.0, "Take profit (R)", minval = 0.5, maxval = 10, step = 0.5, group = gM)
minRisk = input.float(0.20, "Min stop distance (× ATR)", minval = 0.0, maxval = 2.0, step = 0.05, group = gM)
minQual = input.int(0, "Hide setups below quality", minval = 0, maxval = 90, group = gM)
gW1 = "Watchlist 1 – 10"
s01 = input.symbol("OANDA:EURUSD", "1", group = gW1)
s02 = input.symbol("OANDA:GBPUSD", "2", group = gW1)
s03 = input.symbol("OANDA:USDJPY", "3", group = gW1)
s04 = input.symbol("OANDA:AUDUSD", "4", group = gW1)
s05 = input.symbol("OANDA:USDCAD", "5", group = gW1)
s06 = input.symbol("OANDA:XAUUSD", "6", group = gW1)
s07 = input.symbol("OANDA:XAGUSD", "7", group = gW1)
s08 = input.symbol("OANDA:NZDUSD", "8", group = gW1)
s09 = input.symbol("OANDA:USDCHF", "9", group = gW1)
s10 = input.symbol("OANDA:EURGBP", "10", group = gW1)
gW2 = "Watchlist 11 – 20"
s11 = input.symbol("BINANCE:BTCUSDT", "11", group = gW2)
s12 = input.symbol("BINANCE:ETHUSDT", "12", group = gW2)
s13 = input.symbol("BINANCE:SOLUSDT", "13", group = gW2)
s14 = input.symbol("CME_MINI:ES1!", "14", group = gW2)
s15 = input.symbol("CME_MINI:NQ1!", "15", group = gW2)
s16 = input.symbol("TVC:DXY", "16", group = gW2)
s17 = input.symbol("TVC:NDX", "17", group = gW2)
s18 = input.symbol("TVC:SPX", "18", group = gW2)
s19 = input.symbol("OANDA:EURJPY", "19", group = gW2)
s20 = input.symbol("OANDA:GBPJPY", "20", group = gW2)
nRows = input.int(20, "Rows in use", minval = 1, maxval = 20, group = gW2, tooltip = "Only the first N symbols are scanned and shown. Lower it for a shorter table.")
gV = "Visuals"
candSty = input.string("Neon Bloom", "Candle palette", options = ["Neon Bloom","Midnight Cyan","Vibrant Neon","Classic Soft","Cool Blue","Off"], group = gV)
hudPos = input.string("Top Right", "Table position", options = ["Top Right","Top Left","Bottom Right","Bottom Left","Middle Right","Middle Left"], group = gV)
hudSize = input.string("Normal", "Table text", options = ["Small","Normal","Large"], group = gV)
drawMe = input.bool(true, "Draw this chart's setup", group = gV, tooltip = "The sequence is also run on the chart you are looking at and its live stage is drawn on the candles: the swept level, the shift level, the entry with stop and target. Twenty rows in the table, one setup on the chart.")
hideIdle= input.bool(false, "Hide SCANNING rows", group = gV, tooltip = "Show only symbols with something in progress.")
alertOn = input.bool(true, "Alert on new setup / entry", group = gV, tooltip = "Fires one alert per bar naming the symbol and stage. Create the alert with 'Any alert() function call'.")
// ─────────────────────────────────────────────────────────────────────────
// THE ENTRY MODEL AS A FUNCTION
// Runs inside request.security, once per symbol. All state is per call site,
// which is what makes twenty independent state machines possible from one
// body of code. Nothing here draws — it only reports.
//
// Stages: 0 scanning · 1 swept · 2 setup mapped · 3 in entry · 4 target ·
// 5 stopped
// ─────────────────────────────────────────────────────────────────────────
scan() =>
atr = ta.atr(14)
ph = ta.pivothigh(pivLen, pivLen)
pl = ta.pivotlow(pivLen, pivLen)
iph = ta.pivothigh(intLen, intLen)
ipl = ta.pivotlow(intLen, intLen)
var float swHigh = na
var float swLow = na
var bool hiTaken = false
var bool loTaken = false
if not na(ph)
swHigh := ph
hiTaken := false
if not na(pl)
swLow := pl
loTaken := false
var float intHigh = na
var float intLow = na
if not na(iph)
intHigh := iph
if not na(ipl)
intLow := ipl
var int stage = 0
var int dir = 0
var float sweepExt = na
var float sweptLvl = na
var float mssLevel = na
var int waited = 0
var int age = 0 // bars in the current stage
var float entry = na
var float sl = na
var float tp = na
var int qual = 0
var int holdN = 0 // bars a terminal state stays visible
if barstate.isconfirmed
age += 1
// terminal states hold for a few bars, then the row goes back to work
if stage >= 4
holdN += 1
if holdN > 8
stage := 0
dir := 0
age := 0
// ── 0 → 1 : liquidity sweep, wick through and close back inside ──
if stage == 0
if not na(swLow) and not loTaken and low < swLow and close > swLow and not na(intHigh) and intHigh > close
loTaken := true
stage := 1
dir := 1
sweepExt := low
sweptLvl := swLow
mssLevel := intHigh
waited := 0
age := 0
else if not na(swHigh) and not hiTaken and high > swHigh and close < swHigh and not na(intLow) and intLow < close
hiTaken := true
stage := 1
dir := -1
sweepExt := high
sweptLvl := swHigh
mssLevel := intLow
waited := 0
age := 0
// ── 1 → 2 : market structure shift confirms the sweep ──
else if stage == 1
waited += 1
// a close beyond the sweep's own extreme means the stops were not
// rejected, they were run through — the sweep has failed
failed = dir == 1 ? close < sweepExt : close > sweepExt
if waited > maxWait or failed
stage := 0
dir := 0
age := 0
else if (dir == 1 and close > mssLevel) or (dir == -1 and close < mssLevel)
// the imbalance belongs to the displacement leg, so it is close by
fvgT = 0.0
fvgB = 0.0
fvgAt = -1
span = math.min(waited + 4, 18)
for j = 0 to span
if fvgAt < 0
if dir == 1 and low[j] > high[j + 2]
fvgT := low[j]
fvgB := high[j + 2]
fvgAt := j
if dir == -1 and high[j] < low[j + 2]
fvgT := low[j + 2]
fvgB := high[j]
fvgAt := j
e = fvgAt >= 0 ? (dir == 1 ? fvgT : fvgB) : mssLevel
s = sweepExt
risk = math.abs(e - s)
a = math.max(nz(atr), syminfo.mintick)
depth = math.abs(sweepExt - sweptLvl) / a
disp = math.abs(close - mssLevel) / a
fSize = fvgAt >= 0 ? math.abs(fvgT - fvgB) / a : 0.0
q = int(math.round(0.30 * math.min(1.0, depth / 0.45) * 100 + 0.30 * math.min(1.0, disp / 1.20) * 100 + 0.25 * math.min(1.0, fSize / 0.40) * 100 + 0.15 * math.max(0.0, 1.0 - waited / float(maxWait)) * 100))
valid = risk > a * minRisk and (dir == 1 ? e > s : e < s) and q >= minQual
if valid
stage := 2
entry := e
sl := s
tp := dir == 1 ? e + risk * rrMult : e - risk * rrMult
qual := q
age := 0
else
stage := 0
dir := 0
age := 0
// ── 2 → 3 : price returns into the entry ──
else if stage == 2
// a close through the stop before the entry was ever reached
// invalidates the setup — there is nothing left to return to
broken = dir == 1 ? close < sl : close > sl
if age > lifeN or broken
stage := 0
dir := 0
age := 0
else if (dir == 1 and low <= entry) or (dir == -1 and high >= entry)
stage := 3
age := 0
holdN := 0
// ── 3 → 4 / 5 : the trade resolves ──
else if stage == 3
hitSL = dir == 1 ? low <= sl : high >= sl
hitTP = dir == 1 ? high >= tp : low <= tp
// stop is checked first: a bar that spans both is a loss, not a
// win — the honest reading when the order of fills is unknown
if hitSL
stage := 5
holdN := 0
age := 0
else if hitTP
stage := 4
holdN := 0
age := 0
else if age > openN
stage := 0
dir := 0
age := 0
// before the entry: how far away price is, in that instrument's ATR.
// after it: how the trade stands, in R — the only unit twenty different
// instruments share.
risk0 = math.abs(entry - sl)
toEn = dir == 1 ? close - entry : entry - close
prog = stage == 3 and risk0 > 0 ? toEn / risk0 : na(entry) or na(atr) or atr == 0 ? na : toEn / atr
// for idle rows: how far the nearest untaken liquidity sits, in ATR
// a level price has already closed through is not liquidity any more,
// even if it was never swept in the wick-and-reject sense
liqUp = na(swHigh) or hiTaken or close > swHigh or na(atr) or atr == 0 ? na : (swHigh - close) / atr
liqDn = na(swLow) or loTaken or close < swLow or na(atr) or atr == 0 ? na : (close - swLow) / atr
[stage, dir, age, qual, entry, sl, tp, prog, liqUp, liqDn, sweptLvl, mssLevel]
// ─────────────────────────────────────────────────────────────────────────
// TWENTY SYMBOLS, TWENTY MACHINES
// One request per symbol, plus one for the chart itself: twenty-one of the
// forty requests a script is allowed.
// ─────────────────────────────────────────────────────────────────────────
tf = scanTF == "" ? timeframe.period : scanTF
[st01, d01, a01, q01, e01, l01, t01, x01, u01, n01, w01, m01] = request.security(s01, tf, scan(), lookahead = barmerge.lookahead_off)
[st02, d02, a02, q02, e02, l02, t02, x02, u02, n02, w02, m02] = request.security(s02, tf, scan(), lookahead = barmerge.lookahead_off)
[st03, d03, a03, q03, e03, l03, t03, x03, u03, n03, w03, m03] = request.security(s03, tf, scan(), lookahead = barmerge.lookahead_off)
[st04, d04, a04, q04, e04, l04, t04, x04, u04, n04, w04, m04] = request.security(s04, tf, scan(), lookahead = barmerge.lookahead_off)
[st05, d05, a05, q05, e05, l05, t05, x05, u05, n05, w05, m05] = request.security(s05, tf, scan(), lookahead = barmerge.lookahead_off)
[st06, d06, a06, q06, e06, l06, t06, x06, u06, n06, w06, m06] = request.security(s06, tf, scan(), lookahead = barmerge.lookahead_off)
[st07, d07, a07, q07, e07, l07, t07, x07, u07, n07, w07, m07] = request.security(s07, tf, scan(), lookahead = barmerge.lookahead_off)
[st08, d08, a08, q08, e08, l08, t08, x08, u08, n08, w08, m08] = request.security(s08, tf, scan(), lookahead = barmerge.lookahead_off)
[st09, d09, a09, q09, e09, l09, t09, x09, u09, n09, w09, m09] = request.security(s09, tf, scan(), lookahead = barmerge.lookahead_off)
[st10, d10, a10, q10, e10, l10, t10, x10, u10, n10, w10, m10] = request.security(s10, tf, scan(), lookahead = barmerge.lookahead_off)
[st11, d11, a11, q11, e11, l11, t11, x11, u11, n11, w11, m11] = request.security(s11, tf, scan(), lookahead = barmerge.lookahead_off)
[st12, d12, a12, q12, e12, l12, t12, x12, u12, n12, w12, m12] = request.security(s12, tf, scan(), lookahead = barmerge.lookahead_off)
[st13, d13, a13, q13, e13, l13, t13, x13, u13, n13, w13, m13] = request.security(s13, tf, scan(), lookahead = barmerge.lookahead_off)
[st14, d14, a14, q14, e14, l14, t14, x14, u14, n14, w14, m14] = request.security(s14, tf, scan(), lookahead = barmerge.lookahead_off)
[st15, d15, a15, q15, e15, l15, t15, x15, u15, n15, w15, m15] = request.security(s15, tf, scan(), lookahead = barmerge.lookahead_off)
[st16, d16, a16, q16, e16, l16, t16, x16, u16, n16, w16, m16] = request.security(s16, tf, scan(), lookahead = barmerge.lookahead_off)
[st17, d17, a17, q17, e17, l17, t17, x17, u17, n17, w17, m17] = request.security(s17, tf, scan(), lookahead = barmerge.lookahead_off)
[st18, d18, a18, q18, e18, l18, t18, x18, u18, n18, w18, m18] = request.security(s18, tf, scan(), lookahead = barmerge.lookahead_off)
[st19, d19, a19, q19, e19, l19, t19, x19, u19, n19, w19, m19] = request.security(s19, tf, scan(), lookahead = barmerge.lookahead_off)
[st20, d20, a20, q20, e20, l20, t20, x20, u20, n20, w20, m20] = request.security(s20, tf, scan(), lookahead = barmerge.lookahead_off)
// ─────────────────────────────────────────────────────────────────────────
// THE CHART'S OWN SETUP
// A twenty-first run of the same sequence, on the chart itself, drawn live.
// Six drawings, redrawn each bar, so the chart always shows the current
// stage and nothing older — the table is the history, the chart is now.
// ─────────────────────────────────────────────────────────────────────────
// requested through the same path as the twenty rows, on the same scan
// timeframe, so the chart and its ◂ row can never disagree
[cSt, cDir, cAge, cQ, cEn, cSl, cTp, cPr, cLu, cLd, cSw, cMs] = request.security(syminfo.tickerid, tf, scan(), lookahead = barmerge.lookahead_off)
// the bar the current sequence began on — the sweep bar
var int cStart = na
if cSt == 1 and cSt[1] != 1
cStart := bar_index
if cSt == 0
cStart := na
var line gSweep = na
var line gMss = na
var line gEntry = na
var box gRisk = na
var box gReward= na
var label gTag = na
if drawMe and barstate.islast
line.delete(gSweep)
line.delete(gMss)
line.delete(gEntry)
box.delete(gRisk)
box.delete(gReward)
label.delete(gTag)
if cSt >= 1 and cSt <= 3 and not na(cStart)
col = cDir == 1 ? UP : DN
x0 = math.max(cStart, bar_index - 300)
x1 = bar_index + 6
gSweep := line.new(x0, cSw, x1, cSw, color = color.new(AMBER, 10), width = 2, style = line.style_dotted)
gMss := line.new(x0, cMs, x1, cMs, color = color.new(col, 0), width = 2)
if cSt >= 2
gEntry := line.new(x0, cEn, x1, cEn, color = color.new(TXT, 10), width = 2, style = line.style_dashed)
gRisk := box.new(x0, math.max(cEn, cSl), x1, math.min(cEn, cSl), border_color = color.new(DN, 55), bgcolor = color.new(DN, 90))
gReward := box.new(x0, math.max(cEn, cTp), x1, math.min(cEn, cTp), border_color = color.new(UP, 55), bgcolor = color.new(UP, 90))
arrow = cDir == 1 ? "▲ " : "▼ "
tagTx = cSt == 1 ? arrow + "SWEPT · waiting MSS" : cSt == 2 ? arrow + (cDir == 1 ? "LONG" : "SHORT") + " SETUP · Q" + str.tostring(cQ) : arrow + "OPEN " + (cPr >= 0 ? "+" : "") + str.tostring(cPr, "0.0") + " R"
tagY = cSt == 1 ? cSw : cEn
gTag := label.new(x1, tagY, " " + tagTx + " ", style = label.style_label_left, color = INK, textcolor = cSt == 1 ? AMBER : col, size = size.normal)
// ─────────────────────────────────────────────────────────────────────────
// CANDLES — neon pair, translucent body against a solid edge
// ─────────────────────────────────────────────────────────────────────────
cBull = switch candSty
"Neon Bloom" => #00F5D4
"Midnight Cyan" => #34E89E
"Vibrant Neon" => #00E5B0
"Classic Soft" => #3FB68B
"Cool Blue" => #4C9AFF
=> #00F5D4
cBear = switch candSty
"Neon Bloom" => #FF2E88
"Midnight Cyan" => #FF4D7D
"Vibrant Neon" => #FF2E63
"Classic Soft" => #E0556B
"Cool Blue" => #8A94A6
=> #FF2E88
cEdge = close >= open ? cBull : cBear
plotcandle(candSty == "Off" ? na : open, high, low, close, "Candles",
color = color.new(cEdge, 24), wickcolor = color.new(cEdge, 18), bordercolor = cEdge)
// ─────────────────────────────────────────────────────────────────────────
// HELPERS
// ─────────────────────────────────────────────────────────────────────────
hudP(string s) =>
switch s
"Top Right" => position.top_right
"Top Left" => position.top_left
"Bottom Right" => position.bottom_right
"Bottom Left" => position.bottom_left
"Middle Left" => position.middle_left
=> position.middle_right
tSize(string s) =>
switch s
"Small" => size.small
"Large" => size.large
=> size.normal
// "OANDA:EURUSD" → "EURUSD"
shortName(string s) =>
p = str.pos(s, ":")
p >= 0 ? str.substring(s, p + 1) : s
// lower rank = higher in the table: entries first, then mapped setups, then
// pending sweeps, then finished trades, then idle rows. Within a stage the
// freshest row wins.
rankOf(int stage, int age) =>
base = stage == 3 ? 0 : stage == 2 ? 1 : stage == 1 ? 2 : stage == 4 ? 3 : stage == 5 ? 4 : 5
base * 100000 + age
stageText(int stage, int dir) =>
arrow = dir == 1 ? "▲ " : dir == -1 ? "▼ " : ""
switch stage
1 => arrow + "SWEPT · waiting MSS"
2 => arrow + (dir == 1 ? "LONG SETUP" : "SHORT SETUP")
3 => arrow + "OPEN"
4 => arrow + "TARGET HIT"
5 => arrow + "STOPPED"
=> "scanning"
stageBg(int stage, int dir) =>
switch stage
1 => #5A3E0A
2 => dir == 1 ? #0A5F55 : #8E1148
3 => dir == 1 ? #00A38B : #C21B5E
4 => #14532D
5 => #4A1020
=> CARD
// ─────────────────────────────────────────────────────────────────────────
// TABLE
// ─────────────────────────────────────────────────────────────────────────
var table hud = table.new(position.top_right, 7, 22)
if barstate.islast
// gather the twenty rows into arrays so they can be ranked
syms = array.from(s01, s02, s03, s04, s05, s06, s07, s08, s09, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20)
stg = array.from(st01, st02, st03, st04, st05, st06, st07, st08, st09, st10, st11, st12, st13, st14, st15, st16, st17, st18, st19, st20)
dirs = array.from(d01, d02, d03, d04, d05, d06, d07, d08, d09, d10, d11, d12, d13, d14, d15, d16, d17, d18, d19, d20)
ages = array.from(a01, a02, a03, a04, a05, a06, a07, a08, a09, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
quals = array.from(q01, q02, q03, q04, q05, q06, q07, q08, q09, q10, q11, q12, q13, q14, q15, q16, q17, q18, q19, q20)
ents = array.from(e01, e02, e03, e04, e05, e06, e07, e08, e09, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20)
sls = array.from(l01, l02, l03, l04, l05, l06, l07, l08, l09, l10, l11, l12, l13, l14, l15, l16, l17, l18, l19, l20)
tps = array.from(t01, t02, t03, t04, t05, t06, t07, t08, t09, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20)
dist = array.from(x01, x02, x03, x04, x05, x06, x07, x08, x09, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)
lqU = array.from(u01, u02, u03, u04, u05, u06, u07, u08, u09, u10, u11, u12, u13, u14, u15, u16, u17, u18, u19, u20)
lqD = array.from(n01, n02, n03, n04, n05, n06, n07, n08, n09, n10, n11, n12, n13, n14, n15, n16, n17, n18, n19, n20)
ranks = array.new<int>()
for i = 0 to nRows - 1
array.push(ranks, rankOf(array.get(stg, i), array.get(ages, i)))
ord = array.sort_indices(ranks, order.ascending)
nEntry = 0
nSetup = 0
nSweep = 0
for i = 0 to nRows - 1
s = array.get(stg, i)
nEntry += s == 3 ? 1 : 0
nSetup += s == 2 ? 1 : 0
nSweep += s == 1 ? 1 : 0
table.delete(hud)
hud := table.new(hudP(hudPos), 7, nRows + 2, bgcolor = CARD, border_color = color.new(#28323F, 0), border_width = 1)
ts = tSize(hudSize)
// hero row — what the whole list adds up to
heroBg = nEntry > 0 ? #0A5F55 : nSetup > 0 ? #1E2A38 : CARD2
heroTx = nEntry > 0 ? str.tostring(nEntry) + " OPEN" : nSetup > 0 ? str.tostring(nSetup) + " SETUP" + (nSetup > 1 ? "S" : "") + " MAPPED" : nSweep > 0 ? str.tostring(nSweep) + " SWEEP" + (nSweep > 1 ? "S" : "") + " PENDING" : "NO SETUPS · scanning " + str.tostring(nRows)
table.cell(hud, 0, 0, " ICT SETUP SCREENER · " + heroTx + " ", text_color = color.white, text_size = size.large, text_halign = text.align_left, bgcolor = heroBg)
table.merge_cells(hud, 0, 0, 4, 0)
table.cell(hud, 5, 0, str.tostring(nSetup) + (nSetup == 1 ? " setup · " : " setups · ") + str.tostring(nSweep) + (nSweep == 1 ? " sweep " : " sweeps "), text_color = color.white, text_size = size.normal, text_halign = text.align_right, bgcolor = heroBg)
table.merge_cells(hud, 5, 0, 6, 0)
// column headers
hdr = array.from(" Symbol", "Stage", "Bars", "Quality", "Entry", "Stop / Target", "To entry · R · liquidity ")
for c = 0 to 6
table.cell(hud, c, 1, array.get(hdr, c), text_color = MUTE, text_size = size.small, text_halign = c == 0 ? text.align_left : c == 6 ? text.align_right : text.align_center, bgcolor = CARD2)
r = 2
for k = 0 to nRows - 1
i = array.get(ord, k)
s = array.get(stg, i)
d = array.get(dirs, i)
if not (hideIdle and s == 0)
live = s >= 1 and s <= 3
fg = live ? TXT : s == 0 ? DIMTX : MUTE
bg = stageBg(s, d)
rowBg = s == 0 ? CARD : CARD2
en = array.get(ents, i)
sp = array.get(sls, i)
tg = array.get(tps, i)
dx = array.get(dist, i)
q = array.get(quals, i)
isMe = syminfo.ticker == shortName(array.get(syms, i))
table.cell(hud, 0, r, " " + shortName(array.get(syms, i)) + (isMe ? " ◂" : ""), text_color = isMe ? UP : fg, text_size = ts, text_halign = text.align_left, bgcolor = rowBg)
table.cell(hud, 1, r, " " + stageText(s, d) + " ", text_color = s == 0 ? DIMTX : color.white, text_size = ts, text_halign = text.align_center, bgcolor = bg)
table.cell(hud, 2, r, s == 0 ? "" : str.tostring(array.get(ages, i)), text_color = fg, text_size = ts, text_halign = text.align_center, bgcolor = rowBg)
table.cell(hud, 3, r, s >= 2 ? "Q " + str.tostring(q) : "", text_color = s >= 2 ? (q >= 70 ? UP : q >= 45 ? AMBER : DN) : fg, text_size = ts, text_halign = text.align_center, bgcolor = rowBg)
table.cell(hud, 4, r, s >= 2 and not na(en) ? str.tostring(en, "#.#####") : "", text_color = fg, text_size = ts, text_halign = text.align_center, bgcolor = rowBg)
table.cell(hud, 5, r, s >= 2 and not na(sp) ? str.tostring(sp, "#.#####") + " / " + str.tostring(tg, "#.#####") : "", text_color = fg, text_size = ts, text_halign = text.align_center, bgcolor = rowBg)
// distance reads in ATRs so twenty different instruments compare
// idle rows are not dead rows: they show how far the nearest untaken
// liquidity sits, which is where the next sweep can come from
lu = array.get(lqU, i)
ld = array.get(lqD, i)
liqTx = na(lu) and na(ld) ? "" : (na(ld) or (not na(lu) and lu < ld)) ? "liq ▲ " + str.tostring(lu, "0.0") + " ATR" : "liq ▼ " + str.tostring(ld, "0.0") + " ATR"
dxTx = s == 3 and not na(dx) ? (dx >= 0 ? "+" : "") + str.tostring(dx, "0.0") + " R" : s == 2 and not na(dx) ? (dx <= 0 ? "touching" : str.tostring(dx, "0.0") + " ATR") : s == 0 ? liqTx : ""
dxCol = s == 3 and not na(dx) ? (dx >= 0 ? UP : DN) : s == 2 and not na(dx) and dx <= 0.5 ? AMBER : s == 0 ? DIMTX : fg
table.cell(hud, 6, r, dxTx + " ", text_color = dxCol, text_size = ts, text_halign = text.align_right, bgcolor = rowBg)
r += 1
// ─────────────────────────────────────────────────────────────────────────
// ALERTS — one message per bar, naming the symbol
// ─────────────────────────────────────────────────────────────────────────
// A stage is named the bar it changes. Comparing against the previous bar's
// stage — rather than a "fired" flag carried out of the request — is what
// keeps a higher scan timeframe from repeating the same alert on every chart
// bar until that timeframe's bar closes.
if alertOn and barstate.isconfirmed
cur = array.from(st01, st02, st03, st04, st05, st06, st07, st08, st09, st10, st11, st12, st13, st14, st15, st16, st17, st18, st19, st20)
prev = array.from(st01[1], st02[1], st03[1], st04[1], st05[1], st06[1], st07[1], st08[1], st09[1], st10[1], st11[1], st12[1], st13[1], st14[1], st15[1], st16[1], st17[1], st18[1], st19[1], st20[1])
ds = array.from(d01, d02, d03, d04, d05, d06, d07, d08, d09, d10, d11, d12, d13, d14, d15, d16, d17, d18, d19, d20)
qs = array.from(q01, q02, q03, q04, q05, q06, q07, q08, q09, q10, q11, q12, q13, q14, q15, q16, q17, q18, q19, q20)
ss = array.from(s01, s02, s03, s04, s05, s06, s07, s08, s09, s10, s11, s12, s13, s14, s15, s16, s17, s18, s19, s20)
msg = ""
for i = 0 to nRows - 1
c = array.get(cur, i)
if c != array.get(prev, i) and (c == 2 or c == 3)
side = array.get(ds, i) == 1 ? "long" : "short"
msg := msg + shortName(array.get(ss, i)) + (c == 2 ? " " + side + " setup mapped Q" + str.tostring(array.get(qs, i)) : " " + side + " entered") + " · "
if msg != ""
alert("LunqFX ICT Screener: " + msg, alert.freq_once_per_bar_close)