Blockcircle Heikin-Ashi Multi-TimeframeThe BLOCKCIRCLE HEIKIN-ASHI MULTI-TIMEFRAME indicator displays Heikin-Ashi price data across multiple timeframes simultaneously, giving you a clear picture of trend direction from your current chart all the way up to monthly views.
Instead of flipping between charts to check if higher timeframes agree with your trade idea, everything sits right in front of you on a single unified view.
The core concept is simple: when multiple timeframes show the same trend direction, the probability of a successful trade increases. When they disagree, you might want to wait for better alignment or reduce your position size.
WHAT MAKES THIS INDICATOR ORIGINAL AND DIFFERENT
While Heikin-Ashi candles and multi-timeframe analysis are established concepts, this indicator extends beyond simple HA plotting in several ways that justify its protected source status.
First, the summary scoring algorithm calculates a directional score from 0 to 100 that quantifies trend alignment across all enabled timeframes. This is not simply counting bullish versus bearish readings. The score incorporates the current timeframe alongside higher timeframes, weights each contribution, and produces a single metric that represents overall market structure bias.
Second, the indicator includes an intelligent auto-timeframe system that dynamically selects appropriate higher timeframes based on your current chart. Rather than requiring manual configuration, the algorithm maps each chart timeframe to a logical hierarchy of higher timeframes. A 15-minute chart automatically receives 30-minute, 1-hour, 2-hour, 4-hour, and 8-hour references. A daily chart receives 3-day, weekly, 2-week, monthly, and quarterly references. This mapping logic ensures meaningful timeframe relationships regardless of where you trade.
Third, the alignment quality calculation measures how decisive the current trend reading is, regardless of direction. A score where 80 percent of timeframes agree in either direction produces a high alignment quality rating, while a 50/50 split produces low quality. This helps traders distinguish between strong conviction setups and ambiguous market conditions.
Fourth, the stability factor tracks how many timeframes have recently changed direction. Markets where multiple timeframes are actively flipping carry different risk characteristics than markets where all timeframes have maintained their direction for extended periods. The stability calculation converts recent change counts into a percentage that feeds into the overall assessment.
Fifth, the confidence rating system interprets the raw data and translates it into actionable guidance. High confidence requires near-complete alignment across timeframes. Medium confidence requires majority agreement. Low confidence indicates mixed conditions. This interpretation layer helps traders who prefer clear guidance over raw numbers.
These proprietary elements, particularly the auto-timeframe mapping, the multi-factor scoring system, and the stability tracking, represent original development work that extends meaningfully beyond standard Heikin-Ashi MTF implementations available elsewhere.
KEY FEATURES
Multi-Timeframe Heikin-Ashi Display: View up to five higher timeframes plotted directly on your chart alongside the current timeframe
Each timeframe shows both the open and close values as separate lines, with optional fill between them
Heikin-Ashi smoothing filters out market noise better than standard candlesticks, making trend direction easier to identify
All timeframe data updates in real-time as new bars form
Professional Dashboard Panel
Summary score from 0 to 100 that quantifies overall trend alignment at a glance
Individual timeframe breakdown showing exact open and close prices, trend direction, and whether a change just occurred
Statistics section with trend strength percentage, timeframe alignment count, and recent change tracking
Signal status that interprets the data and suggests whether conditions favour buying, selling, or staying neutral
Confidence rating based on how many timeframes agree with each other
Compact mode option for traders who prefer a smaller footprint on their charts
Visual Customisation Options
Three display modes: lines only for a clean look, lines with fill for easier trend visualisation, or cloud style for a more distinct separation between levels
Full colour control for each timeframe so you can match your existing chart theme
Adjustable line widths and optional midline display showing the average of open and close
Background colour shading that changes based on overall trend alignment
Trend change arrows that appear automatically when a timeframe flips direction
Practical Alert System
Individual alerts for each timeframe when it switches from bullish to bearish or vice versa
Combined alert when all enabled timeframes align in the same direction
Single master alert that fires whenever any timeframe changes, useful for staying informed without setting up multiple notifications
Strong trend detection alert when alignment score crosses above key thresholds
HOW TO USE
Setting Up Your Timeframes
Start by choosing timeframes that match your trading style. If you trade the 15-minute chart, enable the 1-hour, 4-hour, and daily timeframes. If you swing trade on the daily, consider the 3-day, weekly, and monthly timeframes.
Give each timeframe a custom label that makes sense to you. The dashboard will display these labels, so use whatever helps you read the information quickly.
You do not need to enable all five timeframes. Many traders find that three or four provide enough context without cluttering the chart.
How to Read the Dashboard
Check the summary row first. A score above 70 with a clear bullish or bearish bias suggests strong alignment. Scores between 40 and 70 indicate mixed conditions where caution is warranted.
Look at the alignment count to see exactly how many timeframes agree. Four out of five being bullish is more convincing than two out of five.
Pay attention to the change indicator, shown as a yellow dot next to any timeframe that just flipped. Recent changes often signal the start of a new move but can also be false signals that reverse quickly.
The confidence rating helps newer traders interpret the data. High confidence means most or all timeframes agree, while low confidence suggests waiting for better conditions.
Identifying Trade Opportunities
The strongest signals occur when all enabled timeframes show the same direction. If you see all green across the board, bullish setups are more likely to succeed. The opposite applies when everything points to bearishness.
When the current timeframe flips to match the higher timeframes, this often marks a good entry point. The lower timeframe is now in agreement with the bigger picture.
Avoid trading against multiple higher timeframes. If the 4-hour, daily, and weekly are all bearish, taking long positions on the 15-minute chart is fighting the overall trend.
Use divergences between timeframes as warning signs. If lower timeframes turn bullish but higher timeframes remain bearish, the rally may be a pullback within a larger downtrend rather than a true reversal.
Managing Risk with Timeframe Analysis
Consider position sizing based on alignment. Full positions when alignment is strong, reduced size when conditions are mixed.
Place stops beyond the higher timeframe structure. If the daily Heikin-Ashi open sits at a certain level, that level often acts as support or resistance.
When higher timeframes start changing direction one by one, this often signals a larger trend shift developing. Take profits or tighten stops on existing positions.
The trend strength percentage gives you a quick read on momentum. Above 80 percent suggests strong conviction in one direction. Below 40 percent suggests the opposite direction dominates.
Combining with Other Analysis
This indicator works well alongside volume analysis. Strong trend alignment with increasing volume adds confidence to the signal.
You can see use the trend change arrows as added confluence towards a trend break as you see below
Support and resistance levels from higher timeframes carry more weight. Use the higher timeframe Heikin-Ashi values as dynamic support and resistance zones.
Combine with momentum oscillators for timing. When the indicator shows alignment and an oscillator shows oversold or overbought conditions, the setup becomes more compelling.
Price action patterns that form in the direction of multi-timeframe alignment have better follow-through than those forming against it.
LIMITATIONS
This indicator uses Heikin-Ashi calculations, which by design lag behind standard price action. Signals confirm trends rather than predict them, and early entries require additional confirmation from other methods.
The auto-timeframe feature selects higher timeframes based on predefined mappings. These mappings work well for most trading styles but may not suit every specific use case. Manual override is available for traders who prefer custom timeframe combinations.
During extended consolidation periods, the summary score may oscillate around 50 percent and produce mixed readings. The indicator performs best when markets exhibit clear directional movement.
Multi-timeframe alignment does not guarantee trade success. Markets can and do reverse even when multiple timeframes agree. Proper risk management and position sizing remain essential regardless of alignment score.
This indicator should be used as part of a complete trading approach. It provides trend context and alignment analysis but does not replace fundamental analysis, risk management, or trading discipline.
Candlestick analysis
Hazmeed HTF Candles Aligned)HTF Candles Overlay (v6, Aligned + Accurate Wicks)
This indicator overlays higher timeframe candles on your current chart.
It allows you to visually compare HTF price action directly on your lower timeframe chart without switching timeframes.
⭐ Features
Displays Higher Timeframe (HTF) candles on the current chart
Fully aligned to HTF candle start time
Option to show accurate wicks
Supports configurable:
HTF timeframe (e.g., 1D, 4H, 1W)
Number of HTF candles displayed
Candle width (in bars)
Bull/Bear colors and wick color
BK AK-King Quazi🦁👑 BK AK–KING QUAZI — MEASURED HAND, CLEAN BLADE. 👑🦁
All glory to Gd — the true source of wisdom, restraint, and endurance.
AK is honor — my mentor’s standard: clarity, patience, no shortcuts, no gambling.
Update / Record: A previous version of this publication was hidden by PineCoders moderation due to insufficient description. This republish includes a fully self-contained explanation of what the script does, how it works, and how to use it.
1) What this script does (outputs)
BK AK–King Quazi is a Quasimodo (QM) structure manager that turns the pattern into a permissioned process:
PROTO → BOS proof → RETEST → CONFIRM → resolve or invalidate
On-chart you get:
Stage labels: P↑ / P↓ (PROTO), R↑ / R↓ (RETEST), C↑ / C↓ (CONFIRM), X (INVALIDATED), ✓ (TARGET HIT)
Execution map lines: QM, BOS, INV (invalidation)
Optional projection extension forward (QM/BOS/INV + optional T1/T2)
Optional entry zone around QM (ATR buffer)
MTF “War Room” table: 5 timeframes showing STATE and NOW (recent events)
This is not a “pattern sticker.” It’s a workflow + object lifecycle so outcomes are visible and charts stay clean.
2) Definitions (what each stage means)
PROTO (P): “Sweep + BOS candidate.” Early awareness that a QM setup is forming.
BOS (Break of Structure): requires a body displacement vs ATR (proof filter).
RETEST (R): price returns to the QM level and holds it (permission test).
CONFIRM (C): full QM geometry is complete (structure + proof + timing aligned).
INV: invalidation level. If breached, the pattern is failed and marked X.
Targets: optional T1/T2 mapped from selected target mode.
3) How it works (actual logic in plain English)
A) Swing engine (how structure is built)
The script uses a ZigZag-style swing detector based on lookbacks:
A “to_up” swing trigger occurs when high reaches the highest high over zz_len
A “to_down” swing trigger occurs when low reaches the lowest low over zz_len
Trend flips on those triggers and the script stores the last 3 swing points:
Highs: h2 → h1 → h0
Lows: l2 → l1 → l0
This creates repeatable swing structure without manual drawing.
B) BOS displacement filter (proof of intent)
A BOS is only accepted if the candle body displacement is large enough:
Displacement condition: abs(close - open) ≥ disp_used * ATR(atr_len)
disp_used can be:
Manual, or
Auto (TF Map), or
Auto (ATR%)
This is the “no wick theater” filter.
C) PROTO detection (sweep + BOS)
Bull PROTO fires when:
structure suggests a sweep (higher swing high behavior) and
price sweeps below a prior swing low, then BOS closes above h1 with displacement
Bear PROTO is the mirror:
sweep above a prior swing high, then BOS closes below l1 with displacement
On PROTO, the script defines the key levels:
Bull: QM = l1, BOS = h1, INV = current low
Bear: QM = h1, BOS = l1, INV = current high
D) RETEST + CONFIRM
RETEST checks the return to QM with a hold:
Bull retest: low ≤ QM and close ≥ QM
Bear retest: high ≥ QM and close ≤ QM
CONFIRM triggers only when the full swing sequence meets the “QM complete” rules (the script’s bu_conf / be_conf conditions).
E) Targets / projection math (if enabled)
Targets are optional:
Measured (1.0 / 1.618): uses the distance |BOS − QM| times multipliers
BOS + prior swing: uses BOS + prior swing extreme
Neck→Head (H&S projection): projects neck/head distance from BOS
F) Object lifecycle (keeps chart honest and readable)
If opposite PROTO appears, you can:
do nothing, or
clear projections, or
mark X + clear the prior campaign
On invalidation, the script replaces the existing P/C label with X (no overlapping junk)
On target hit, it can resolve the campaign and optionally remove projections/tags
4) MTF War Room (what the table means)
The table shows 5 user-selectable timeframes (TF1–TF5) with:
STATE: current posture on that TF (P↑, C↑, P↓, C↓, —)
NOW: highlights recent PROTO/CONFIRM events on that TF
Implementation note (what’s original here):
It computes zigzag + displacement inside each TF context
“NOW” flash timing is measured in that TF (not chart TF)
It packs NOW + RECENT + STAGE into one request.security() call per TF (performance-aware)
5) How to use it (clean execution workflow)
Suggested workflow (AK standard):
Use MTF first: don’t fight higher court structure
Treat PROTO as awareness, not permission
Require BOS displacement (proof)
Execute only on RETEST of QM or on your CONFIRM rules
Stop is INV (if INV breaks, mark X and stand down)
Use mapped T1/T2 for planning + resolution (no improvising mid-trade)
Label key:
P = Proto (sweep + BOS)
R = Retest (QM hold)
C = Confirm (full QM)
X = Invalidated (broke INV)
✓ = Target hit (T1/T2 resolution)
6) What’s original (why it’s not “another QM clone”)
Quasimodo is public. The originality here is the system around it:
staged sequencing (PROTO → BOS proof → RETEST → CONFIRM) instead of “shape = signal”
ATR displacement proof filter to cut fake BOS
standardized level mapping (QM/BOS/INV + targets + entry zone)
object lifecycle management (replace labels with X, clear/gray projections, remove on target)
MTF packed engine (one call per TF; “NOW” measured on that TF)
controlled alert routing by event type (PROTO vs CONFIRM)
7) Limitations (important)
This is bar-based structure logic; it can change during an unclosed realtime candle.
ZigZag swings are lookback-based, not a broker “official” swing definition.
It’s a structure/permission tool, not a guarantee engine.
🧑🏫 BK / AK / Faith
BK is the mark I’m building.
AK is honor — discipline, patience, clean execution.
All glory to Gd — the true source of wisdom and endurance.
🗡️ King David Lens (Deep — Discipline Under Fire)
David’s power wasn’t impulse. It was governed force — strength that answers to law.
He learned early that the most dangerous trap is moving before you’re sent.
That’s why his life is full of the same pattern traders ignore:
He was anointed long before he was crowned.
Meaning: truth can be real before it’s allowed to manifest.
He fought Goliath with a weapon people mocked — not because it was flashy, but because it was mastered.
Meaning: edge isn’t what looks impressive — it’s what’s trained and repeatable.
He had Saul in his hands and still refused the shortcut.
Meaning: opportunity is not permission; proximity is not assignment.
He waited through wilderness seasons where nothing “looked like progress.”
Meaning: silence isn’t rejection — sometimes it’s preparation.
That is the trader’s war.
Price will always offer motion.
But motion without permission is bait.
David didn’t survive by chasing what was available.
He survived by waiting until the moment was proved, the ground was chosen, and the strike was clean.
That’s what King Quazi enforces:
PROTO is the rumor.
BOS displacement is the proof.
Retest is the test of legitimacy.
Confirm is permission to strike.
Invalidation is humility — stand down immediately.
A lion doesn’t chase every shadow.
A lion waits until the prey is committed — then ends it.
🦁👑 BK AK–KING QUAZI — execute with proof. 👑🦁
Gd bless. 🙏
Chip Distribution Pro// This source code is subject to the terms of the Mozilla Public License 2.0 at mozilla.org
// Enhanced Position Cost Distribution - Auto-adaptive with improved visualization
// Works with ETFs, commodities, forex, crypto, stocks - any instrument
// @version=5
indicator('Chip Distribution Pro', overlay = true, max_lines_count = 500, max_bars_back = 500)
//#region Inputs
string GRP_GENERAL = "General Settings"
int LOOKBACK = input.int(1000, 'Lookback Bars', maxval = 20000, minval = 500, step = 250, group = GRP_GENERAL)
int CHART_X_OFFSET = input.int(100, 'Chart Offset', step = 10, group = GRP_GENERAL)
int LABEL_X_OFFSET = CHART_X_OFFSET + 4
int CHART_MAX_WIDTH = input.int(80, 'Max Width', maxval = 500, minval = 10, step = 10, group = GRP_GENERAL)
int NUM_BUCKETS = input.int(400, 'Price Buckets', maxval = 500, minval = 50, step = 50, group = GRP_GENERAL)
string GRP_AUTO = "Auto-Tuning"
bool AUTO_TUNE = input.bool(true, 'Enable Auto-Tuning', group = GRP_AUTO,
tooltip = 'Automatically adjusts turnover rate based on volatility and volume characteristics')
float MANUAL_DECAY = input.float(0.1, 'Manual Turnover Rate', minval = 0.01, maxval = 0.5, step = 0.01, group = GRP_AUTO,
tooltip = 'Only used when Auto-Tuning is disabled')
int VOLATILITY_PERIOD = input.int(20, 'Volatility Period', minval = 5, maxval = 100, group = GRP_AUTO)
string GRP_VISUAL = "Visualization"
string COLOR_SCHEME = input.string("Rainbow", "Color Scheme", options = , group = GRP_VISUAL)
color PROFIT_COLOR_LIGHT = input.color(#26a69a, 'Profit Light', group = GRP_VISUAL)
color PROFIT_COLOR_DARK = input.color(#004d40, 'Profit Dark', group = GRP_VISUAL)
color LOSS_COLOR_LIGHT = input.color(#ef5350, 'Loss Light', group = GRP_VISUAL)
color LOSS_COLOR_DARK = input.color(#b71c1c, 'Loss Dark', group = GRP_VISUAL)
color CURRENT_PRICE_COLOR = input.color(color.yellow, 'Current Price', group = GRP_VISUAL)
color AVG_PRICE_COLOR = input.color(#2196F3, 'Average Cost', group = GRP_VISUAL)
color PEAK_COLOR = input.color(#FF9800, 'Peak Concentration', group = GRP_VISUAL)
color STATS_COLOR = input.color(#434651, 'Stats Background', group = GRP_VISUAL)
string GRP_LEVELS = "Key Levels"
bool SHOW_SUPPORT_RESISTANCE = input.bool(true, 'Show Support/Resistance Zones', group = GRP_LEVELS)
bool SHOW_PEAK = input.bool(true, 'Show Peak Concentration', group = GRP_LEVELS)
float SR_THRESHOLD = input.float(0.7, 'S/R Detection Threshold', minval = 0.3, maxval = 0.95, step = 0.05, group = GRP_LEVELS,
tooltip = 'Minimum concentration (relative to peak) to mark as support/resistance')
string GRP_SIGNALS = "Signals Panel"
bool SHOW_SIGNALS = input.bool(true, 'Show Signal Panel', group = GRP_SIGNALS)
bool SHOW_KEY_LEVELS = input.bool(true, 'Show Key Price Levels', group = GRP_SIGNALS)
bool SHOW_TREND_ARROW = input.bool(true, 'Show Trend Arrow', group = GRP_SIGNALS)
bool SHOW_PRESSURE_BAR = input.bool(true, 'Show Pressure Bar', group = GRP_SIGNALS)
// Colors for key levels
color SUPPORT_COLOR = input.color(#00E676, 'Support Level', group = GRP_LEVELS)
color RESISTANCE_COLOR = input.color(#FF5252, 'Resistance Level', group = GRP_LEVELS)
color BREAKOUT_COLOR = input.color(#FFD600, 'Breakout Level', group = GRP_LEVELS)
//#endregion
//#region Candle Type
type Candle
int idx
float hi
float lo
float vol
float relativeVol
float atrPct
//#endregion
//#region PCD Type
type PCD
array candles
float minPrice
float maxPrice
float priceStep
array lines
label currentPriceLabel
label avgPriceLabel
label peakLabel
label statsLabel
label signalLabel
array srZones
float calculatedTurnover
// New visualization elements
line supportLine
line resistanceLine
line avgCostLine
label trendArrow
box pressureBar
box pressureFill
label pressureLabel
// Create a new price label
newPriceLabel(color bg, color txtColor) =>
label.new(0, 0, '', style = label.style_label_left, color = bg, textcolor = txtColor, size = size.small)
// Create a new PCD instance
newPCD() =>
array lns = array.new(NUM_BUCKETS)
for i = 0 to NUM_BUCKETS - 1
array.set(lns, i, line.new(0, 0, 0, 0))
PCD.new(
candles = array.new(0),
lines = lns,
currentPriceLabel = newPriceLabel(color.new(#00BCD4, 0), color.white),
avgPriceLabel = newPriceLabel(AVG_PRICE_COLOR, color.white),
peakLabel = newPriceLabel(PEAK_COLOR, color.white),
statsLabel = label.new(0, 0, '', style = label.style_label_up, size = size.small,
textalign = text.align_left, color = color.new(STATS_COLOR, 20), textcolor = color.white),
signalLabel = label.new(0, 0, '', style = label.style_label_left, size = size.small,
textalign = text.align_left, color = color.new(#1a1a2e, 20), textcolor = color.white),
srZones = array.new(0),
calculatedTurnover = 0.1,
minPrice = na,
maxPrice = na,
priceStep = na,
supportLine = line.new(0, 0, 0, 0, color = SUPPORT_COLOR, width = 2, style = line.style_dashed),
resistanceLine = line.new(0, 0, 0, 0, color = RESISTANCE_COLOR, width = 2, style = line.style_dashed),
avgCostLine = line.new(0, 0, 0, 0, color = AVG_PRICE_COLOR, width = 2, style = line.style_dotted),
trendArrow = label.new(0, 0, '', style = label.style_label_center, size = size.large, textcolor = color.white),
pressureBar = box.new(0, 0, 0, 0, bgcolor = color.new(#424242, 50), border_color = color.gray),
pressureFill = box.new(0, 0, 0, 0, bgcolor = color.green, border_color = na),
pressureLabel = label.new(0, 0, '', style = label.style_label_right, size = size.tiny, color = color.new(#000000, 100), textcolor = color.white))
// Auto-calculate turnover rate based on instrument characteristics
calcAdaptiveTurnover(float atrPct, float volRatio) =>
float safeAtrPct = na(atrPct) or atrPct <= 0 ? 0.02 : atrPct
float safeVolRatio = na(volRatio) or volRatio <= 0 ? 1.0 : volRatio
float volBasedTurnover = math.max(0.03, math.min(0.3, safeAtrPct * 3))
float volAdjustment = math.max(0.5, math.min(2.0, safeVolRatio))
float turnover = volBasedTurnover * volAdjustment
math.max(0.02, math.min(0.4, turnover))
// Store candle method
method storeCandle(PCD this, int barIdx, float hiPrice, float loPrice, float volVal, float avgVol, float atrPct) =>
if not na(hiPrice) and not na(loPrice) and not na(volVal) and volVal > 0
float safeAvgVol = na(avgVol) or avgVol <= 0 ? volVal : avgVol
float relVol = volVal / safeAvgVol
float safeAtrPct = na(atrPct) ? 0.02 : atrPct
bool modified = false
int candleSize = array.size(this.candles)
if candleSize > 0
Candle c = array.get(this.candles, candleSize - 1)
if c.idx == barIdx
c.hi := hiPrice
c.lo := loPrice
c.vol := volVal
c.relativeVol := relVol
c.atrPct := safeAtrPct
modified := true
if not modified
Candle c = Candle.new(barIdx, hiPrice, loPrice, volVal, relVol, safeAtrPct)
array.push(this.candles, c)
this.minPrice := na(this.minPrice) ? loPrice : math.min(this.minPrice, loPrice)
this.maxPrice := na(this.maxPrice) ? hiPrice : math.max(this.maxPrice, hiPrice)
float priceRange = this.maxPrice - this.minPrice
this.priceStep := priceRange > 0 ? priceRange / NUM_BUCKETS : 0.0001
// Get bucket index for price
method getBucketIndex(PCD this, float price) =>
if na(this.priceStep) or this.priceStep <= 0 or na(this.minPrice)
0
else
int idx = int(math.floor((price - this.minPrice) / this.priceStep))
math.max(0, math.min(idx, NUM_BUCKETS - 1))
// Get price for bucket index
method getBucketedPrice(PCD this, int bucketIdx) =>
int safeIndex = math.max(0, math.min(bucketIdx, NUM_BUCKETS - 1))
float safeStep = na(this.priceStep) or this.priceStep <= 0 ? 0.0001 : this.priceStep
float safeMin = na(this.minPrice) ? 0.0 : this.minPrice
(safeIndex + 0.5) * safeStep + safeMin
// Get rainbow color based on position (0.0 = bottom/red, 1.0 = top/violet)
getRainbowColor(float position, float intensityRatio) =>
float pos = math.max(0.0, math.min(1.0, position))
int transparency = int(math.round((1.0 - intensityRatio) * 50))
// Rainbow spectrum: red -> orange -> yellow -> green -> cyan -> blue -> violet
if pos < 0.166
color.new(color.from_gradient(pos, 0.0, 0.166, #FF0000, #FF7F00), transparency)
else if pos < 0.333
color.new(color.from_gradient(pos, 0.166, 0.333, #FF7F00, #FFFF00), transparency)
else if pos < 0.5
color.new(color.from_gradient(pos, 0.333, 0.5, #FFFF00, #00FF00), transparency)
else if pos < 0.666
color.new(color.from_gradient(pos, 0.5, 0.666, #00FF00, #00FFFF), transparency)
else if pos < 0.833
color.new(color.from_gradient(pos, 0.666, 0.833, #00FFFF, #0000FF), transparency)
else
color.new(color.from_gradient(pos, 0.833, 1.0, #0000FF, #8B00FF), transparency)
// Get color based on scheme and intensity
getColor(bool isProfitable, float intensity, float maxIntensity, int bucketIdx) =>
float safeMax = maxIntensity > 0 ? maxIntensity : 1.0
float ratio = math.max(0.0, math.min(1.0, intensity / safeMax))
float positionRatio = bucketIdx / math.max(1.0, NUM_BUCKETS - 1.0)
if COLOR_SCHEME == "Rainbow"
getRainbowColor(positionRatio, ratio)
else if COLOR_SCHEME == "Gradient"
if isProfitable
color.from_gradient(ratio, 0.0, 1.0, PROFIT_COLOR_DARK, PROFIT_COLOR_LIGHT)
else
color.from_gradient(ratio, 0.0, 1.0, LOSS_COLOR_DARK, LOSS_COLOR_LIGHT)
else if COLOR_SCHEME == "Heatmap"
color.from_gradient(ratio, 0.0, 1.0, #1a237e, #f44336)
else
if isProfitable
color.new(#5d606b, int(math.round((1.0 - ratio) * 70)))
else
color.new(#e91e63, int(math.round((1.0 - ratio) * 70)))
// Update method
method update(PCD this) =>
int candleCount = array.size(this.candles)
if candleCount > 0 and not na(this.priceStep) and this.priceStep > 0
// Create distribution array
array dist = array.new_float(NUM_BUCKETS, 0.0)
// Process each candle
for candleIdx = 0 to candleCount - 1
Candle candle = array.get(this.candles, candleIdx)
bool isFirstCandle = candleIdx == 0
float turnover = AUTO_TUNE ? calcAdaptiveTurnover(candle.atrPct, candle.relativeVol) : MANUAL_DECAY * candle.relativeVol
turnover := math.min(turnover, 0.95)
this.calculatedTurnover := turnover
int startIdx = this.getBucketIndex(candle.lo)
int endIdx = this.getBucketIndex(candle.hi)
int buckets = math.max(1, endIdx - startIdx + 1)
if isFirstCandle
float initialWeight = 1.0 / buckets
for i = startIdx to endIdx
array.set(dist, i, initialWeight)
else
float decayedAmount = 0.0
for i = 0 to NUM_BUCKETS - 1
float oldVal = array.get(dist, i)
float newVal = oldVal * (1.0 - turnover)
array.set(dist, i, newVal)
decayedAmount += oldVal - newVal
float addPerBucket = decayedAmount / buckets
for i = startIdx to endIdx
array.set(dist, i, array.get(dist, i) + addPerBucket)
// Normalize distribution
float totalWeight = 0.0
for i = 0 to NUM_BUCKETS - 1
totalWeight += array.get(dist, i)
if totalWeight > 0
for i = 0 to NUM_BUCKETS - 1
array.set(dist, i, array.get(dist, i) / totalWeight)
// Find peak
float maxWeight = array.max(dist)
if na(maxWeight) or maxWeight <= 0
maxWeight := 0.001
int peakIndex = array.indexof(dist, maxWeight)
if peakIndex < 0
peakIndex := 0
float peakPrice = this.getBucketedPrice(peakIndex)
// Find support/resistance zones
array srIndices = array.new(0)
if SHOW_SUPPORT_RESISTANCE
bool inZone = false
int zoneStart = 0
for i = 0 to NUM_BUCKETS - 1
bool isHighConcentration = array.get(dist, i) >= maxWeight * SR_THRESHOLD
if isHighConcentration and not inZone
inZone := true
zoneStart := i
else if not isHighConcentration and inZone
inZone := false
array.push(srIndices, int(math.floor((zoneStart + i) / 2)))
if inZone
array.push(srIndices, int(math.floor((zoneStart + NUM_BUCKETS - 1) / 2)))
// Clear old SR zones
int srZoneSize = array.size(this.srZones)
if srZoneSize > 0
for i = 0 to srZoneSize - 1
box b = array.get(this.srZones, i)
box.set_lefttop(b, 0, 0)
box.set_rightbottom(b, 0, 0)
// Draw the distribution
float lowestDisplayedPrice = na
float highestDisplayedPrice = na
for i = 0 to NUM_BUCKETS - 1
float weight = array.get(dist, i)
float price = (i + 0.5) * this.priceStep + this.minPrice
int width = int(math.round(weight / maxWeight * CHART_MAX_WIDTH))
line ln = array.get(this.lines, i)
if width > 0
if na(lowestDisplayedPrice)
lowestDisplayedPrice := price
highestDisplayedPrice := price
int x1 = bar_index + CHART_X_OFFSET
int x2 = x1 - width
bool isProfitable = price < close
color c = getColor(isProfitable, weight, maxWeight, i)
line.set_xy1(ln, x1, price)
line.set_xy2(ln, x2, price)
line.set_color(ln, c)
else
line.set_xy1(ln, 0, 0)
line.set_xy2(ln, 0, 0)
// Draw S/R zones
if SHOW_SUPPORT_RESISTANCE
int srCount = array.size(srIndices)
int leftBar = math.max(0, bar_index - LOOKBACK)
if srCount > 0
for i = 0 to srCount - 1
int idx = array.get(srIndices, i)
float zonePrice = this.getBucketedPrice(idx)
float zoneHalfHeight = this.priceStep * 3
box b = na
if i < array.size(this.srZones)
b := array.get(this.srZones, i)
box.set_lefttop(b, leftBar, zonePrice + zoneHalfHeight)
box.set_rightbottom(b, bar_index, zonePrice - zoneHalfHeight)
else
b := box.new(leftBar, zonePrice + zoneHalfHeight, bar_index, zonePrice - zoneHalfHeight, bgcolor = color.new(PEAK_COLOR, 85), border_color = color.new(PEAK_COLOR, 60))
array.push(this.srZones, b)
// Calculate cumulative distribution
array cumdist = array.copy(dist)
for i = 1 to NUM_BUCKETS - 1
array.set(cumdist, i, array.get(cumdist, i - 1) + array.get(cumdist, i))
// Highlight current price
int closeIndex = this.getBucketIndex(close)
if closeIndex >= 0 and closeIndex < NUM_BUCKETS
line.set_color(array.get(this.lines, closeIndex), CURRENT_PRICE_COLOR)
// Calculate stats
float totalShares = array.get(cumdist, NUM_BUCKETS - 1)
int profitIndex = math.min(closeIndex + 1, NUM_BUCKETS - 1)
float profitRatio = totalShares > 0 ? array.get(cumdist, profitIndex) / totalShares : 0.0
// Calculate average price
float avg = 0.0
for i = 0 to NUM_BUCKETS - 1
float weight = array.get(dist, i)
float price = this.getBucketedPrice(i)
avg += price * weight
int avgIndex = this.getBucketIndex(avg)
if avgIndex >= 0 and avgIndex < NUM_BUCKETS
line.set_color(array.get(this.lines, avgIndex), AVG_PRICE_COLOR)
// Peak concentration - highlight line
if SHOW_PEAK and peakIndex >= 0 and peakIndex < NUM_BUCKETS
line.set_color(array.get(this.lines, peakIndex), PEAK_COLOR)
// Smart label positioning - avoid overlaps
float priceRange = na(highestDisplayedPrice) or na(lowestDisplayedPrice) ? close * 0.01 : (highestDisplayedPrice - lowestDisplayedPrice)
float minLabelSpacing = priceRange * 0.025
// Sort prices and assign staggered X offsets
float currentY = close
float avgY = avg
float peakY = peakPrice
// Adjust avg label if too close to current
if math.abs(avgY - currentY) < minLabelSpacing
avgY := currentY > avgY ? avgY - minLabelSpacing : avgY + minLabelSpacing
// Adjust peak label if too close to current or avg
if SHOW_PEAK
if math.abs(peakY - currentY) < minLabelSpacing
peakY := currentY > peakY ? peakY - minLabelSpacing : peakY + minLabelSpacing
if math.abs(peakY - avgY) < minLabelSpacing
peakY := avgY > peakY ? peakY - minLabelSpacing : peakY + minLabelSpacing
// Position price labels - compact format, right side of distribution
label.set_text(this.currentPriceLabel, str.format('{0,number,#.##}', close))
label.set_xy(this.currentPriceLabel, bar_index + LABEL_X_OFFSET + 2, close)
label.set_style(this.currentPriceLabel, label.style_label_left)
label.set_size(this.currentPriceLabel, size.tiny)
label.set_text(this.avgPriceLabel, str.format('{0,number,#.##} AVG', avg))
label.set_xy(this.avgPriceLabel, bar_index + LABEL_X_OFFSET + 2, avgY)
label.set_style(this.avgPriceLabel, label.style_label_left)
label.set_size(this.avgPriceLabel, size.tiny)
if SHOW_PEAK
label.set_text(this.peakLabel, str.format('{0,number,#.##} PEAK', peakPrice))
label.set_xy(this.peakLabel, bar_index + LABEL_X_OFFSET + 2, peakY)
label.set_style(this.peakLabel, label.style_label_left)
label.set_size(this.peakLabel, size.tiny)
// Calculate ranges safely
float safeTotalShares = totalShares > 0 ? totalShares : 1.0
int idx05 = array.binary_search_leftmost(cumdist, safeTotalShares * 0.05)
int idx95 = array.binary_search_leftmost(cumdist, safeTotalShares * 0.95)
int idx15 = array.binary_search_leftmost(cumdist, safeTotalShares * 0.15)
int idx85 = array.binary_search_leftmost(cumdist, safeTotalShares * 0.85)
float ninetyPctLow = this.getBucketedPrice(idx05)
float ninetyPctHigh = this.getBucketedPrice(idx95)
float seventyPctLow = this.getBucketedPrice(idx15)
float seventyPctHigh = this.getBucketedPrice(idx85)
float rangeDenom = ninetyPctHigh - ninetyPctLow
float rangeOverlap = rangeDenom != 0 ? (seventyPctHigh - seventyPctLow) / rangeDenom : 0.0
// Calculate chip concentration
float concentration = rangeOverlap * 100
string concentrationDesc = concentration < 50 ? "High" : concentration < 70 ? "Medium" : "Dispersed"
// Pressure analysis
float safeAvg = avg > 0 ? avg : close
float priceVsAvg = ((close - safeAvg) / safeAvg) * 100
string pressure = priceVsAvg > 5 ? "Strong Bullish" : priceVsAvg > 1 ? "Bullish" :
priceVsAvg < -5 ? "Strong Bearish" : priceVsAvg < -1 ? "Bearish" : "Neutral"
// Price vs Peak
float safePeak = peakPrice > 0 ? peakPrice : close
float priceVsPeak = ((close - safePeak) / safePeak) * 100
string peakRelation = close > peakPrice ? "Above Peak" : close < peakPrice ? "Below Peak" : "At Peak"
// Stats panel - positioned at bottom, compact
float displayedRange = na(highestDisplayedPrice) or na(lowestDisplayedPrice) ? close * 0.02 : highestDisplayedPrice - lowestDisplayedPrice
label.set_text(this.statsLabel, str.format(
'90%: {0,number,#.##} - {1,number,#.##} | 70%: {2,number,#.##} - {3,number,#.##}',
ninetyPctLow, ninetyPctHigh, seventyPctLow, seventyPctHigh))
if not na(lowestDisplayedPrice) and displayedRange > 0
label.set_y(this.statsLabel, lowestDisplayedPrice - displayedRange * 0.05)
label.set_style(this.statsLabel, label.style_label_up)
label.set_x(this.statsLabel, bar_index + CHART_X_OFFSET - 30)
label.set_size(this.statsLabel, size.tiny)
// Signal panel - hidden (info moved to trend arrow and pressure bar)
label.set_text(this.signalLabel, "")
label.set_xy(this.signalLabel, bar_index, close)
// === NEW PROFESSIONAL VISUALIZATIONS ===
// 1. Key Level Lines - Support, Resistance, and Average Cost extending across chart
if SHOW_KEY_LEVELS
int chartLeft = math.max(0, bar_index - LOOKBACK)
int chartRight = bar_index + CHART_X_OFFSET - 5
// Average cost line (horizontal dotted blue line)
line.set_xy1(this.avgCostLine, chartLeft, avg)
line.set_xy2(this.avgCostLine, chartRight, avg)
line.set_color(this.avgCostLine, AVG_PRICE_COLOR)
// Find strongest support (highest concentration below current price)
float strongestSupport = na
float strongestSupportWeight = 0.0
float strongestResistance = na
float strongestResistanceWeight = 0.0
for i = 0 to NUM_BUCKETS - 1
float bucketPrice = this.getBucketedPrice(i)
float bucketWeight = array.get(dist, i)
if bucketPrice < close and bucketWeight > strongestSupportWeight
strongestSupport := bucketPrice
strongestSupportWeight := bucketWeight
if bucketPrice > close and bucketWeight > strongestResistanceWeight
strongestResistance := bucketPrice
strongestResistanceWeight := bucketWeight
// Support line (green dashed)
if not na(strongestSupport)
line.set_xy1(this.supportLine, chartLeft, strongestSupport)
line.set_xy2(this.supportLine, chartRight, strongestSupport)
line.set_color(this.supportLine, SUPPORT_COLOR)
else
line.set_xy1(this.supportLine, bar_index, close)
line.set_xy2(this.supportLine, bar_index, close)
line.set_color(this.supportLine, color.new(SUPPORT_COLOR, 100))
// Resistance line (red dashed)
if not na(strongestResistance)
line.set_xy1(this.resistanceLine, chartLeft, strongestResistance)
line.set_xy2(this.resistanceLine, chartRight, strongestResistance)
line.set_color(this.resistanceLine, RESISTANCE_COLOR)
else
line.set_xy1(this.resistanceLine, bar_index, close)
line.set_xy2(this.resistanceLine, bar_index, close)
line.set_color(this.resistanceLine, color.new(RESISTANCE_COLOR, 100))
// 2. Trend Direction Arrow
if SHOW_TREND_ARROW
string trendSymbol = priceVsAvg > 5 ? "▲▲" : priceVsAvg > 1 ? "▲" :
priceVsAvg < -5 ? "▼▼" : priceVsAvg < -1 ? "▼" : "◆"
color trendColor = priceVsAvg > 5 ? color.new(#00E676, 0) : priceVsAvg > 1 ? color.new(#4CAF50, 0) :
priceVsAvg < -5 ? color.new(#FF1744, 0) : priceVsAvg < -1 ? color.new(#EF5350, 0) : color.new(#9E9E9E, 0)
string trendText = trendSymbol + " " + pressure
label.set_text(this.trendArrow, trendText)
float arrowY = na(highestDisplayedPrice) ? close : highestDisplayedPrice + displayedRange * 0.12
label.set_xy(this.trendArrow, bar_index + CHART_X_OFFSET - 40, arrowY)
label.set_color(this.trendArrow, color.new(trendColor, 70))
label.set_textcolor(this.trendArrow, trendColor)
label.set_size(this.trendArrow, size.large)
// 3. Pressure Bar (Profit/Loss ratio visualization)
if SHOW_PRESSURE_BAR
float barWidth = 8.0
float barHeight = displayedRange * 0.25
float barX = bar_index + CHART_X_OFFSET + 5
float barTop = na(highestDisplayedPrice) ? close + barHeight/2 : highestDisplayedPrice - displayedRange * 0.02
float barBottom = barTop - barHeight
// Background bar
box.set_lefttop(this.pressureBar, int(barX), barTop)
box.set_rightbottom(this.pressureBar, int(barX + barWidth), barBottom)
box.set_bgcolor(this.pressureBar, color.new(#424242, 60))
// Fill based on profit ratio (green from bottom)
float fillHeight = barHeight * profitRatio
float fillTop = barBottom + fillHeight
color fillColor = profitRatio > 0.7 ? color.new(#00E676, 30) :
profitRatio > 0.5 ? color.new(#4CAF50, 30) :
profitRatio > 0.3 ? color.new(#FFC107, 30) : color.new(#FF5252, 30)
box.set_lefttop(this.pressureFill, int(barX), fillTop)
box.set_rightbottom(this.pressureFill, int(barX + barWidth), barBottom)
box.set_bgcolor(this.pressureFill, fillColor)
// Pressure label
string pressureText = str.format('{0,number,#}%', profitRatio * 100)
label.set_text(this.pressureLabel, pressureText)
label.set_xy(this.pressureLabel, int(barX - 1), barTop + displayedRange * 0.01)
label.set_textcolor(this.pressureLabel, fillColor)
//#endregion
//#region Main
= request.security(syminfo.tickerid, 'D', , lookahead = barmerge.lookahead_off)
float atrPercent = dailyClose > 0 ? dailyATR / dailyClose : 0.02
if timeframe.in_seconds(timeframe.period) <= timeframe.in_seconds('D')
var PCD pcd = newPCD()
if last_bar_index - bar_index < LOOKBACK
pcd.storeCandle(dailyBarIdx, dailyHigh, dailyLow, dailyVolume, avgVolume, atrPercent)
if barstate.islast
pcd.update()
//#endregion
Wickless indicator, Kunno wick strategy indicator
shows 9 candle validity line, and all wickless candles that show up for visual ease
Analyze**Smart Money & OB Finder (MTF)** is a professional trading indicator designed to help traders identify high-probability **Buy Zones and Sell Zones** based on **Smart Money Concepts (SMC)** and **Order Blocks (OB)** across multiple timeframes.
This indicator automatically marks **institutional Order Blocks**, allowing traders to see where **big players enter the market**, instead of chasing price in the middle of nowhere.
### 🔍 Key Features
• Automatic **Buy & Sell Order Block detection**
• **Multi-Timeframe (MTF)** analysis for higher-timeframe confirmation
• Clear **zone marking** (no late signals, no repaint)
• Works on **all markets** (Forex, Gold, Indices, Crypto)
• Suitable for **scalping, intraday, and swing trading**
### 🎯 How to Use
• Mark zones on higher timeframe (H1 / H4)
• Execute entries on lower timeframe (M5 / M15)
• Use Order Blocks as **reaction areas**, not ins
Support & Resistance Detector [PRO]Professional Support & Resistance Detector 🟠
Executive Summary 🟠
The **Professional Support & Resistance Detector ** is an institutional-grade technical analysis instrument built for precision traders. It automates the complex task of identifying significant market structure by detecting valid Swing Highs (Resistance) and Swing Lows (Support) using a customizable dynamic lookback algorithm. Unlike basic indicators that clutter the chart with irrelevant lines, this tool employs smart filtration and FIFO (First-In, First-Out) logic to present only the most actionable price levels.
Whether you are a scalper needing real-time feedback or a swing trader looking for confirmed structural levels, this indicator adapts to your workflow with "Confirmed Only" and "Realtime" calculation modes.
Why Standard Indicators Fail 🟠
Most Support & Resistance indicators suffer from two major problems:
1. **Noise**: They identify too many insignificant levels, making the chart unreadable.
2. **Rigidity**: They fail to account for "Role Reversal" (where old Resistance becomes new Support).
The Solution: Advanced Feature Set 🟠
This script addresses these issues with a suite of advanced features designed for the modern market environment:
1. **Dynamic Algorithmic Detection**:
* The core engine uses a user-defined `Left` and `Right` bar lookback system. This allows you to differentiate between "Major" structural pivots (high lookback) and "Minor" intraday levels (low lookback).
* **Zone Visualization**: Prices rarely turn at an exact micro-level. The indicator draws a transparent "Zone" around the key level to visualize the area of liquidity, helping you avoid premature entries during wick tests.
2. **Smart Breakout Logic (The "Brain" of the Indicator)**:
* **History Mode (Faded)**: When a level is broken, it doesn't just vanish. It stays on the chart but fades out. This is critical for backtesting to see how price reacted to past levels.
* **Role Reversal (Flip) Mode**: This is for active trading. When price breaks Resistance, the line automatically flips color to Support (and vice versa). This allows you to trade the "Break & Retest" strategy effortlessly.
3. **Active Chart Management**:
* Markets evolve. Old levels become irrelevant. The built-in **FIFO Memory System** ensures that you never have more than your specified limit (e.g., 25 lines) on the chart. As new structure forms, the oldest irrelevant data is recycled, keeping your workspace pristine.
4. **Multi-Mode Calculation Engine**:
* **Confirmed Only (Default)**: The professional standard. Levels are only drawn/updated when the candle closes. This guarantees zero repainting and reliable signals.
* **Realtime (Tick-by-Tick)**: Designed for aggressive scalpers who need to see potential pivots forming before the candle closes.
Comprehensive Settings & Customization 🟠
Every aspect of the indicator is customizable to fit your trading style.
Logic & Calculation 🟠
* **Max Active Lines**: Set the buffer size for active levels. Recommended: 20-30 for clean analysis.
* **Line Extension**: Choose "Right" (standard), "Both" (chart-wide context), or "Segment Only" (local structure).
Pivot Identification 🟠
* **Lookback Left/Right**: The sensitivity dial.
* *Scalping Setup*: Left 10 / Right 5.
* *Swing Setup*: Left 50 / Right 25.
* **Zone Width**: Controls the vertical thickness of the S/R zone.
Visual Aesthetics 🟠
* **Markers**: Select from a library of professionally designed Unicode symbols (Diamonds ◈, Arrows ⯅/⯆, Stars ★, etc.) to mark the exact pivot candle.
* **Breakout Markers**: Visual confirmation icons (Crosses ✖, Checks ✔) appear exactly where the breakout occurred.
Professional Trading Strategies 🟠
**Strategy 1: The S/R Flip (Break & Retest)**
1. Set **Breakout Behavior** to "Role Reversal (Flip)".
2. Wait for price to break a **Red Resistance Zone**.
3. Watch the Zone turn **Blue (Support)**.
4. **Entry**: Wait for price to pull back and touch the new Blue Support zone. Look for a rejection wick.
5. **Stop Loss**: Just below the zone.
Strategy 2: Range Containment
1. Identify a market moving sideways between a parallel Blue Support and Red Resistance.
2. **Sell** at the Red Zone touch (Resistance).
3. **Buy** at the Blue Zone touch (Support).
4. **Filter**: Use the "Confirmed Only" mode to ensure the candle closes inside the range before taking a trade.
Alert System 🟠
Never miss a move. The indicator offers fully integrated alerts for automation:
* **New Level Found**: Instant notification when fresh structure is identified.
* **Breakout Alert**: When a level is breached.
* **Flip Alert**: Specific notification when Resistance becomes Support (or vice versa).
Disclaimer 🟠
This tool is provided for educational and analytical purposes. Financial trading carries a high level of risk. Past performance of any trading system is not indicative of future results. Please trade responsibly.
High-volume buy and sell signals with OB and FVGBuy and sell signals on ob
Pivot Point Usage: Instead of detecting each candle of an opposite color, the script uses `ta.pivothigh/low`. This means it only marks a Pivot Point if the price has actually made a significant high or low relative to the 10 preceding and following candles.
Dynamic Cleanup (Mitigation): As soon as the price returns to "fill" the area (depending on your choice: simple contact or close), the box disappears from the chart. This keeps your view clean and focused on the remaining untouched areas.
Period Setting: You can increase the "Detection Period" (e.g., from 10 to 20) in the settings to filter out even more noise and keep only the major areas.
How to use it?
Pattern Pro [Josh]1. Overview
Pattern Pro is a hybrid technical analysis suite designed to bridge the gap between Classic Chart Patterns and Smart Money Concepts (SMC). Reimagined with a high-contrast "Alien HUD" visual style, this script helps traders identify structural breaks, reversal patterns, and institutional zones with clarity.
2. How it Works (Methodology & Calculations)
The core engine of this script relies on identifying significant market swings using ta.pivothigh and ta.pivotlow functions. These pivot points are stored in dynamic arrays to perform geometric calculations:
Geometric Pattern Recognition:
The script calculates the slope between historical pivots using linear regression logic.
Double Tops/Bottoms: Detects equal highs/lows within a user-defined tolerance (default 0.25%) and validates them with RSI Divergence logic.
Head & Shoulders: Validates the structural hierarchy (Left Shoulder < Head > Right Shoulder) relative to the neckline.
Wedges & Flags: Analyzes trendlines connecting multiple pivots. Converging slopes indicate Wedges, while parallel slopes indicate Flags.
Smart Money Concepts (SMC):
BOS (Break of Structure): Automatically draws lines where price closes beyond a key pivot, signaling trend continuation.
FVG (Fair Value Gaps): Scans for 3-candle price imbalances and projects the 50% equilibrium level.
Supply & Demand Zones: Highlights order blocks derived from the specific candles that formed a confirmed pivot.
Confidence Score: An internal algorithm assigns a percentage score based on pattern clarity and momentum divergence (RSI).
3. Visual Features (Alien HUD)
Neon & Glow Effects: Lines are rendered with multi-layered transparency to create a "glowing" effect, ensuring visibility on dark themes.
Fog/Smoke FX: Adds depth to critical levels without cluttering the chart.
Customization: Users can toggle specific patterns, adjust pivot sensitivity (Lookback), and customize colors.
Disclaimer: This indicator is developed strictly for educational purposes regarding chart behavior and algorithmic pattern recognition.
The signals and patterns generated do not guarantee profitability or future accuracy.
Past performance is not indicative of future results.
Trading involves significant risk. Users should always practice proper risk management and use their own judgment.
Multi-Timeframe Open Levels [Vertical Rays]█ OVERVIEW
This indicator displays higher timeframe open levels using a unique vertical ray design. It draws vertical separators above and below the opening candle, clearly marking the higher timeframe session boundaries on the lower timeframe without interfering with price action or altering chart scale.
Supports up to 5 timeframes with full control over styling and history depth.
█ KEY FEATURES
- Up to 5 independent timeframes — combine any timeframe (minutes, hours, days, weeks) with individual styling
- Vertical ray design — marks timeframe transitions without obscuring price action or distorting chart scale
- Smart overlap handling — when multiple timeframes align (e.g., Daily and 4H), the higher timeframe takes visual priority
- Performance optimized — efficient processing that only calculates what's needed based on visible history
- Minimal footprint — preserves your chart's natural aspect ratio
- Fully customizable — colors, line styles, thickness, and label formatting per timeframe
█ HOW IT WORKS
At each higher timeframe open, the indicator draws two vertical rays:
• One extending upward from above opening candle
• One extending downward from below the opening candle
This creates visual "bookends" that instantly identify where new sessions or timeframe periods begin on the lower timeframe.
█ SETTINGS
Each timeframe slot includes:
• Enable/disable toggle
• Timeframe value and unit (M/H/D/W)
• Color, style (solid/dashed/dotted), and line width
• Maximum historical levels to display
Label options include timezone selection, optional price display, and positioning adjustments.
Mayor Trend Phase Schedule PAI (2025-2026) - Close 23:00 + TableA proprietary time-based analytical tool designed to identify predetermined cyclical windows where major market movements exhibit heightened statistical probability. This indicator synthesizes chronological patterns with price structure confirmation to provide traders with temporally optimized decision frameworks.
Core Components
1. Chronological Phase Mapping
Pre-calibrated 3-day windows across 2025-2026 identified through historical cyclical analysis
Visual background highlighting of active phase periods
Systematic scheduling of potential volatility expansion periods
2. Dynamic Session Reference
Real-time tracking of critical session closing levels (configurable time zone)
Continuous plotting of reference price levels that adapt to market conditions
Integration of temporal price behavior into phase analysis
3. Multi-Timeframe Context Framework
Proprietary EMA combination (157, 200, 257 periods) representing institutional, macro, and intermediate trend perspectives
Visual trend structure assessment during active phases
Confluence verification between temporal and technical factors
4. Informative Dashboard
Real-time phase status monitoring
Active schedule visualization
Reference level tracking with timestamp verification
Analytical Methodology
Phase-Confluence Trading Approach
The indicator operates on the principle of temporal-technical confluence, where trades are considered only when multiple analytical dimensions align:
Primary Conditions:
Temporal Alignment - Active phase window confirmation
Structural Alignment - Price positioned relative to institutional trend framework
Session Alignment - Price interaction with critical session reference levels
Operational Logic
Identification: Automatic detection of active phase windows
Verification: Multi-factor confirmation of trading environments
Visualization: Clear graphical representation of confluence conditions
Monitoring: Real-time tracking of phase progression and price interaction
Application Framework
Strategic Implementation
Phase Awareness - Monitor upcoming windows for preparation
Confluence Verification - Confirm multiple alignment conditions
Reference Level Analysis - Assess price behavior relative to session dynamics
Context Integration - Evaluate within broader market structure
Risk Management Considerations
Temporal-based position sizing adjustments
Phase-duration aware trade management
Confluence-level dependent risk parameters
Technical Specifications
Customization Options
Adjustable session time references
Configurable visual display parameters
Selective component activation/deactivation
Table presentation customization
Compatibility
Multi-asset class applicability
Various timeframe adaptability
Integration with existing trading frameworks
Theoretical Foundation
Underlying Principles
Cyclical market behavior patterns
Institutional trading periodicity
Session-based price memory effects
Multi-timeframe confluence significance
Analytical Value Proposition
Reduced temporal uncertainty
Enhanced timing precision
Structured decision frameworks
Objective phase identification
Usage Guidelines
Optimal Implementation
As a Timing Filter - Primary use for trade timing optimization
As a Context Tool - Supplementary market condition assessment
As a Planning Aid - Forward schedule awareness and preparation
Integration Recommendations
Combine with price action analysis
Correlate with fundamental catalysts
Align with broader market cycles
Validate with volume and volatility metrics
Performance Characteristics
Analytical Strengths
Objective temporal identification
Clear visual communication
Systematic approach to timing
Historical pattern recognition
Practical Limitations
Requires supplementary technical analysis
Not a standalone trading system
Dependent on proper interpretation
Historical performance not indicative of future results
Professional Applications
Institutional Use Cases
Portfolio rebalancing timing
Option expiration planning
Risk window identification
Strategic entry/exit scheduling
Retail Trader Applications
Trade timing optimization
Market condition awareness
Risk period identification
Planning and preparation tool
Conclusion
The Mayor Trend Phase Schedule indicator represents a sophisticated approach to temporal market analysis, providing traders with structured frameworks for identifying statistically significant time windows. By focusing on chronological patterns and their interaction with price structure, the tool offers a unique perspective on market timing that complements traditional technical analysis methods.
Note: This tool is designed for analytical purposes and should be used as part of a comprehensive trading methodology with appropriate risk management protocols.
Volume Profile: Date-Range ObservationI have refined the strategy developed by kv4coins , incorporating an additional option for the observation date range. Previously, when seeking a fixed date range—particularly to track data from the onset of an event-driven trigger up to the present—it was somewhat cumbersome. To address this, I added a new date selection feature to accommodate the need for observing specific time periods.
Gold Pin Bar Pivot Alerts - FixedThis script is designed for the high volatility of Gold (XAU/USD). It identifies Pin Bars with body less than 30% of the candle's total range, and the candle occuring at a structural Pivot High or Pivot Low
KAPISH Professional Trend Re-entry SystemThe Professional Trend Re-entry System is a high-precision momentum-trading tool designed to identify high-probability entries within established trends. Unlike standard lagging indicators, this system utilizes a 5-Point Multi-Data Consensus engine to verify trend health before issuing any signals. By combining the power of volatility-adjusted trend tracking with mean-reversion logic, it helps traders "buy the dip" in uptrends and "sell the rip" in downtrends with surgical timing.
Phantom UltimatePhantom Ultimate: The Professional’s Head-Up Display (HUD)
Headline: Clarity in a Chaotic Market.
The Problem: Modern markets are noisy. Most indicators are fragmented—you have one script for trends, one for divergences, and another for support/resistance. Your chart becomes a mess of conflicting lines, and you spend more time managing indicators than trading price.
The Solution: Phantom Ultimate isn't just an indicator; it is a complete trading operating system. It consolidates an entire institutional trading desk into a single, clean interface. It synthesizes Trend, Momentum, Volume, and Structure into one "Head-Up Display" so you can execute with precision.
Why You Need It:
Zero-Clutter "Smart-Line" Technology: Our dynamic engine keeps your chart pristine. Moving Averages and S&R lines only appear when price is interacting with them. If a line isn't relevant to the current price action, it vanishes. You trade what matters, not the noise.
Institutional Price Action & Alerts: Phantom doesn't just draw lines; it watches them for you. It automatically detects and alerts on high-probability interactions across every level (MAs, Fibs, and Fractal S&R):
Pin Bar Rejections: Catch "Perfect" rejections (Top 34% body rule) the moment a candle closes.
Level Retests: Know immediately when a broken level is being tested as support.
Zone Reclaims: Get alerted instantly when price reclaims a key level after a deviation.
The Market HUD: A professional dashboard pinned to your chart. Instantly see the trend status, signal strength, and RSI conditions for the 1H, 4H, and Daily timeframes simultaneously. Never flip tabs again to check the trend.
The "Wizard" Signal Engine: A composite algorithm that detects "Mega" entries by aligning Momentum (CCI), Trend (EMAs), and Volume (VFI). It doesn't guess; it calculates confluence.
🎁 Bonus: Full Discord Ecosystem Access Your license to Phantom Ultimate includes exclusive access to our Discord Community.
Get real-time server-side alerts (powered by Phantom God Mode).
Join a community of serious traders executing the same strategies.
Never miss a setup, even when you are away from your charts.
Upgrade your vision. Trade with Phantom Ultimate.
9-20 STRADDLE FOR INTRADAY TRADING9-20 STRADDLE FOR INTRADAY TRADING
The 9–20 Straddle Strategy is a popular intraday options trading setup that focuses on capturing volatility after the market opens. In this strategy, traders place a straddle at 9:20 AM by buying or selling both ATM Call and Put options of the same strike and expiry. The objective is to benefit from strong directional moves or time decay, depending on execution style. Risk management is crucial, with predefined stop-loss and profit targets to control losses. This strategy works best on high-liquidity indices like Nifty and Bank Nifty, especially on volatile trading days.
A-A-M Dots + Failed Acceptance (Gold) [CLEAN v6]What this indicator does
This indicator visualizes real market behavior using an Order Flow logic sequence:
Absorption → Acceptance → Momentum (A-A-M)
plus a critical Failed Acceptance condition (trap detection).
It is designed specifically to help traders:
Validate price movement quality
Detect traps early
Avoid false continuation signals
This indicator does not predict price.
It highlights what the market is doing right now based on volume behavior and price response.
Core Concepts Explained
1️⃣ Absorption
Appears when:
Volume is high
Price fails to move far
Long wicks + small body
This suggests large passive orders absorbing aggression.
Absorption is often where moves start or fail — but never confirmation by itself.
2️⃣ Acceptance
Occurs when price:
Breaks above/below the absorption zone
Closes and holds beyond that level
Acceptance confirms the market is willing to trade at a new price.
3️⃣ Momentum
Triggered when:
Strong candle body
Clear follow-through after acceptance
Momentum confirms continuation strength, not entry timing.
4️⃣ Failed Acceptance (Trap)
Appears when:
Acceptance happens
Price then returns back into the absorption zone
This signals a trap:
Failed bullish acceptance → potential downside
Failed bearish acceptance → potential upside
This is one of the most powerful reversal validations in order flow trading.
How to Use This Indicator
Use it as a confirmation tool, not a standalone entry signal
Best combined with:
Market structure
Higher-timeframe bias
Risk management rules
Recommended for:
Gold (XAUUSD / Gold Futures)
Intraday & swing traders
Traders who want context, not signals
What This Indicator Is NOT
❌ Not a signal generator
❌ Not a prediction tool
❌ Not a shortcut to profits
It is a market behavior validator.
Final Note
If you understand why price moves,
you no longer need to chase where price might go.
D1 High/LowThis indicator automatically plots the previous day’s high and low (D1) as thin dashed horizontal lines on the chart.
The levels are calculated strictly from yesterday’s daily candle only.
The lines are anchored directly at the previous day’s candle and extend to the right, matching institutional-style reference levels.
Visible on Daily (D1) and all lower timeframes (H4, H1, M15, etc.).
The lines reset at the start of each new trading day to reflect the latest completed session.
Designed as a context and liquidity reference, not as a predictive indicator.
