MA - Multi-Indicator Dashboard📊 MULTI-INDICATOR DASHBOARD WITH ENTRY QUALITY SCORE
A comprehensive trading dashboard that combines multiple technical indicators into a single, easy-to-read display with a proprietary Entry Quality Scoring System (0-100).
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🎯 ENTRY QUALITY SCORE (0-100)
Based on Mark Minervini's Trend Template and academic research on indicator correlations, this scoring system evaluates 5 key categories with 15 sub-criteria:
📈 TREND STRUCTURE (30%)
• SMA Hierarchy: 20>50>150>200 alignment (/15)
• 200 SMA Direction: Rising for at least 1 month (/10)
• SMA20-50 Momentum: Positive and increasing (/5)
⚡ MOMENTUM (25%)
• ADX Trend Strength: 25+ indicates strong trend (/10)
• RSI Goldilocks Zone: 50-65 ideal entry range (/8)
• MACD: Positive histogram and increasing (/7)
📊 VOLUME/MONEY FLOW (20%)
• Relative Volume: 1.5x+ shows strong participation (/7)
• OBV Trend: Institutional accumulation signal (/6)
• CMF: 0.10+ indicates strong accumulation (/5)
• Volume Oscillator: Volume expansion (/2)
🌊 VOLATILITY & SQUEEZE (15%)
• Squeeze Status: Fired + positive momentum (/8)
• VCR: <0.75 contraction signal (/4)
• ATR: Normal range volatility (/3)
📍 52-WEEK POSITION (10%)
• Range Position: 70-95% ideal zone (/6)
• Distance from Low: 30%+ Minervini criterion (/4)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🎯 SCORE LEVELS
🟢 85-100: EXCELLENT → Aggressive entry
🟢 70-84: STRONG → Normal entry
🟡 55-69: MODERATE → Cautious entry
🟠 40-54: WEAK → Wait/Watch
🔴 0-39: AVOID → No entry
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📋 DASHBOARD INDICATORS
• Price & SMA Values (20, 50, 150, 200)
• SMA Differences & Ratios
• RSI (14), MACD (20,50,9), ADX (14/50)
• ATR (50), 52-Week High/Low
• OBV Trend, Volume Oscillator, Relative Volume
• CMF (21), Volatility Contraction Ratio
• BB/KC Squeeze Status & Momentum
• 3-Month Net Area calculations
• Sub-score breakdown by category
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚙️ SETTINGS
• Show/Hide Dashboard
• Table Position (6 options)
• Table Size (tiny/small/normal/large)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📚 REFERENCES
• Mark Minervini - "Trade Like a Stock Market Wizard"
• Mark Minervini - "Think & Trade Like a Champion"
• Wilder, J.W. - "New Concepts in Technical Trading Systems"
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⚠️ DISCLAIMER
This indicator is for educational purposes only. Always do your own research and use proper risk management. Past performance does not guarantee future results.
Educational
Short Position (Manual Setup)TVC:GOLD
This script is for short position setup manually....
Just enter the following data ......
1. higher entry price
2. lower entry price
3. stop loss price
4. targets ( up to 5 targets)
5- extra targets ( up to 3 extra targets)
then you will have the short position draw in the chart with the trade summary including risk and reward percentage.
by @Crypto_alphabit
ChannellerChanneller Pro - Multi-Pivot Regression Channels with Trend Validation
What This Indicator Does
Channeller Pro automatically detects and draws price channels by connecting multiple pivot points using linear regression rather than simply connecting two points. The indicator displays parallel support and resistance lines that define the current trend channel, along with an optional mid-line for mean reversion analysis.
Channels automatically appear when valid trend conditions are met and disappear when the trend structure breaks, keeping your chart clean and showing only actionable information.
---
How It Works (Methodology)
1. Multi-Pivot Linear Regression
Unlike simple channel indicators that connect only 2 pivot points, this indicator collects 3-5 pivot lows (for bullish channels) or pivot highs (for bearish channels) and calculates a least-squares linear regression line through them. This produces a statistically best-fit trendline that is more resistant to noise from a single errant pivot.
The regression calculation outputs:
- Slope: The angle/direction of the trend
- Intercept: The starting price level
- R² (coefficient of determination): A value from 0 to 1 measuring how well the pivot points align. Higher R² means the pivots form a cleaner, more reliable trendline. The default minimum is 0.70.
2. Higher-Low / Lower-High Pattern Validation
For a bullish channel to form, the indicator requires each successive pivot low to be higher than the previous pivot low (the definition of an uptrend). For bearish channels, each pivot high must be lower than the previous (downtrend structure). This filter prevents channels from forming during choppy, non-trending conditions.
3. ADX Trend Strength Filter
The indicator calculates the Average Directional Index (ADX) to measure trend strength. Channels only appear when ADX exceeds a user-defined threshold (default: 20). When ADX drops below this level, indicating the trend has weakened, channels automatically disappear. This prevents false channels during sideways/ranging markets.
4. Channel Width Calculation
Once the regression support line is established, the indicator finds the highest high (for bull channels) or lowest low (for bear channels) between the first and last pivot. A parallel line is drawn at this distance to form the opposite channel boundary.
5. Channel Respect Monitoring
The indicator tracks how price interacts with channel boundaries:
- Bounces: Price touches the boundary and reverses
- Pierces: Price closes beyond the boundary
If price pierces through a channel boundary multiple times, the channel is invalidated and removed, signaling the trend structure has broken.
---
How to Use This Indicator
Identifying Trends
- A green channel (bullish) indicates an uptrend with higher lows
- A red channel (bearish) indicates a downtrend with lower highs
- The R² value in the label shows channel quality (higher = more reliable)
Trading Applications
- Trend Following: Trade in the direction of the channel slope
- Support/Resistance: Use channel boundaries as potential reaction zones
- Mean Reversion: The optional mid-line (dashed) can serve as a target for pullback entries
- Breakout Preparation: When a channel disappears, it signals the prior trend structure has ended
Reading the Labels
- "BULL R²:0.85 (4 pivots)" means a bullish channel with 85% regression fit using 4 pivot points
- Orange-colored labels indicate weaker channels (R² between 0.70-0.85)
- Green/red labels indicate stronger channels (R² above 0.85)
---
Input Settings Explained
| Setting | Description |
|---------|-------------|
| Pivot Lookback Left/Right | Bars required on each side to confirm a pivot high/low |
| Min Pivots for Channel | Minimum pivot points required (more = stricter) |
| Max Pivots to Track | Maximum pivots stored (older pivots are dropped) |
| Min R² Score | Minimum regression quality (0.70 = 70% fit) |
| ADX Threshold | Minimum ADX value to show channels (20 = moderate trend) |
| Require HL/LH Pattern | Enforce higher-lows for bull, lower-highs for bear |
---
What Makes This Different
This indicator combines multiple validation layers that work together:
1. Regression vs. 2-point lines: More statistically robust trendlines
2. R² quality scoring: Quantifies how clean the trend structure is
3. Pattern validation: Ensures proper trend structure (HL/LH)
4. ADX filtering: Confirms trend exists before drawing channels
5. Auto-invalidation: Channels disappear when broken, not manually
These components create a self-cleaning channel system that only displays high-probability trend channels.
---
Alerts Available
- Bull/Bear Channel Formed
- Bull/Bear Channel Broken
- New Pivot High/Low Detected
SMCCPR and FVGHLthis indicator shows the CPR, FVG and supply and Demand zones automatically. its good for education purpose . by using this information you can trade like a rocket trader.
SMC and FVGHLThis indicator shows FVG and fib level also shows previous day high low , weekly high low, and monthly high low.. apply this indicator on chart and make trading easy...
TASC 2026.02 Portfolio Diversification█ OVERVIEW
This indicator is a simplified framework for analyzing hypothetical portfolios, based on the concepts in the February 2026 edition of the TASC Traders' Tips , "Foundational Portfolio Design, Not Stock-Picking”. It requests datasets for spread symbols that represent weighted combinations of user-selected or predefined instruments, compares the returns in the data to those of a selected benchmark, and calculates risk-related metrics.
█ CONCEPTS
One of the core concepts of portfolio design is diversification. A diversified portfolio distributes market exposure across multiple, ideally uncorrelated, instruments to reduce potential risks. Investors often diversify their portfolios by allocating capital to instruments from different classes, sectors, or regions rather than investing in only a single instrument or multiple related instruments.
As described in the article, the motivation behind creating diversified portfolios is simple:
"No single position should have the capacity to sink the entire portfolio."
This indicator estimates a portfolio's performance by requesting combined price data for spread symbols from user inputs or predefined options, and then analyzing the data's annual arithmetic returns alongside those of a specified benchmark instrument. It displays the returns of the spread and the benchmark in a table at the bottom left.
The indicator also displays the following metrics described in the article in a table at the bottom right of the pane for additional performance information:
Max drawdown: The maximum drop in the portfolio's value from a local peak.
Standard deviation: The dispersion of portfolio values relative to their mean.
Sharpe ratio: The ratio of excess returns in an investment compared to a hypothetical risk-free rate of return.
Pain index: A measure of risk based on the depth, duration, and frequency of losses. The metric in this script considers only the bars where drawdown is nonzero.
Ulcer index: A measure of downside risk based on the root mean square of drawdowns. The metric in this script considers only the bars where drawdown is nonzero.
Correlation: The Pearson correlation coefficient between the returns of the hypothetical portfolio and those of a selected benchmark.
The first five metrics are direct risk measures. The correlation metric helps assess whether the hypothetical portfolio closely follows the broader market. High correlation with a broad benchmark might indicate an elevated sensitivity to systematic risk.
█ USAGE
Users can select a combination of up to 10 symbols with specific weights to construct a hypothetical portfolio to analyze. Alternatively, users can select a predefined combination of symbols and weights based on the article's examples of optimized portfolios for different levels of risk tolerance.
The script plots the calculated returns from the selected combination and the benchmark instrument for visual comparison. It also generates tables to compare returns and display risk metrics.
Note: This indicator is intended to provide a simplified demonstration of portfolio concepts, and some metric calculations differ slightly from those in the article. The script does not produce any signals, and the calculated metrics are estimates intended for EOD timeframes such as 1D. If the hypothetical portfolio consists of instruments with different sessions, we recommend using 1W or a higher timeframe.
█ INPUTS
Benchmark: The symbol of the instrument to compare against the hypothetical portfolio.
Portfolio Type: Choose between named options for predefined portfolio configurations based on risk profiles outlined in the article. To create a custom portfolio from up to 10 symbols, select "Custom" and adjust the 10 sets of inputs below.
Risk-free rate: The hypothetical annual risk-free rate for the Sharpe ratio.
Periods per year: If not zero, the script uses the value as the number of bars per year for annualization, which affects Sharpe ratio and standard deviation metrics.
Display Toggles: The display for the returns and metrics tables can be toggled on or off.
Order Blocks INDIBOT 3D | INDIBOT ABO SALTAN 11 //@version=6
indicator("Order Blocks INDIBOT 3D | INDIBOT ABO SALTAN ", overlay = true,
max_boxes_count = 500, max_labels_count = 500, max_lines_count = 500, max_polylines_count = 100, max_bars_back = 5000)
//#region CONSTANTS
// Core constants that control stored OB capacity and label size.
const int MAX_STORED_OBS = 50
const int retestSize = 4
//#endregion
//#region INPUTS
// Core user controls for OB behavior, volume delta, 3D style and alerts.
grpOB = "ORDER BLOCKS"
swingLen = input.int(5, "Swing Length", minval = 1, group = grpOB, inline = "sw", display = display.none)
bullObColor = input.color(color.new(color.teal, 55), "", group = grpOB, inline = "sw")
bearObColor = input.color(color.new(color.red, 55), "", group = grpOB, inline = "sw")
invMethod = input.string("Wick", "Invalidation", options = , group = grpOB, display = display.none)
showNearestX = input.int(3, "Show Nearest", minval = 1, maxval = 20, group = grpOB, display = display.none)
extendZones = input.int(10, "Extend Zones", minval = 0, group = grpOB,
tooltip = "This will extend the zones by X candles.", display = display.none)
showRetestLbl = input.bool(true, "Retest Labels", group = grpOB, inline = "tog")
hideInvalid = input.bool(true, "Hide Invalidated Zones", group = grpOB, inline = "tog")
grpVD = "VOLUME DELTA"
vdEnable = input.bool(true, "Enable", group = grpVD, inline = "vd")
vdBullColor = input.color(color.new(color.teal, 65), "", group = grpVD, inline = "vd")
vdBearColor = input.color(color.new(color.red, 65), "", group = grpVD, inline = "vd")
vd3D = input.bool(true, "3D", group = grpVD, inline = "3d", tooltip = "Adds 3D-style depth faces.") and vdEnable
vd3DDepth = input.int(5, "", group = grpVD, inline = "3d", minval = 1, maxval = 5, display = display.none)
displayStyle = input.string("Vertical", "Display Style", options = , group = grpVD,
tooltip = "Horizontal: split shown top/bottom. Vertical: split shown left/right across the zone.", display = display.none)
vdTfIn = input.timeframe("", "Volume Delta Timeframe", group = grpVD,
tooltip = "Lower timeframe used to estimate delta")
showTotalVol = input.bool(true, "Display Total Volume", group = grpVD,
tooltip = "Displays total volume (Bull+Bear) from the active delta source.", inline = "vd2") and vdEnable
showDeltaPct = input.bool(true, "Show Delta %", group = grpVD, inline = "vd2",
tooltip = "Shows bullish vs bearish volume split. If selected TF is lower than chart TF, uses LTF data; otherwise uses chart TF.") and vdEnable
vdTextColor = input.color(color.white, "", group = grpVD, inline = "vd2")
grpAL = "ALERTS"
alBullOB = input.bool(true, "Bullish Order Block", group = grpAL, inline = "oba")
alBearOB = input.bool(true, "Bearish Order Block", group = grpAL, inline = "oba")
alBullRetest = input.bool(true, "Bullish OB Retest", group = grpAL, inline = "obr")
alBearRetest = input.bool(true, "Bearish OB Retest", group = grpAL, inline = "obr")
//#endregion
//#region TYPES
// Custom structs for order blocks and 3D poly drawing.
type PolyParams
array points
color lineColor
color fillColor
int lineWidth
type ObRec
int leftIndex
int leftTime
int createdIndex
int createdTime
float top
float bottom
bool isBull
bool active
bool retested
int retestIndex
int retestTime
int invalidIndex
int invalidTime
float bullVol
float bearVol
float totalVol
float bullPct
float bearPct
bool hasDelta
type RetestRec
int barIndex
bool isBull
int obLeftIndex
int obCreatedIndex
//#endregion
//#region GENERIC HELPERS
// Small utilities: clearing drawings, geometry helpers, nearest-OB picking.
method clearAll(array bx, array pl, array lb) =>
if bx.size() > 0
for i = 0 to bx.size() - 1
bx.get(i).delete()
bx.clear()
if pl.size() > 0
for i = 0 to pl.size() - 1
pl.get(i).delete()
pl.clear()
if lb.size() > 0
for i = 0 to lb.size() - 1
lb.get(i).delete()
lb.clear()
// Builds a simple side face for 3D-style boxes using chart points.
method sideBox(array pts, int x, float btm, float top, float depthY, int widthX) =>
pts.unshift(chart.point.from_index(x, btm))
pts.unshift(chart.point.from_index(x + widthX, btm + depthY))
pts.unshift(chart.point.from_index(x + widthX, top + depthY))
pts.unshift(chart.point.from_index(x, top))
pts.unshift(chart.point.from_index(x, btm))
// Returns true if a candle's high/low intersects the OB zone.
touchesZone(float zTop, float zBot, float cHigh, float cLow) =>
cHigh >= zBot and cLow <= zTop
// Distance from price to zone in price units, used to rank nearest zones.
zoneDistance(float px, float zTop, float zBot) =>
px > zTop ? px - zTop : px < zBot ? zBot - px : 0.0
// Inserts a distance+index pair into a sorted list, capped at kMax.
method insertBest(array dists, array idxs, float dist, int idx, int kMax) =>
if dists.size() == 0
dists.push(dist)
idxs.push(idx)
else
int pos = dists.size()
if dists.size() > 0
for j = 0 to dists.size() - 1
if dist < dists.get(j)
pos := j
break
dists.insert(pos, dist)
idxs.insert(pos, idx)
while dists.size() > kMax
dists.pop()
idxs.pop()
// Picks the k nearest bull/bear OBs to current price (optionally including invalid).
pickNearest(array store, bool wantBull, int kMax, bool includeInvalid) =>
array dists = array.new_float()
array idxs = array.new_int()
if store.size() > 0
for i = 0 to store.size() - 1
ObRec ob = store.get(i)
if ob.isBull == wantBull
bool ok = includeInvalid ? true : ob.active
if ok
float dist = zoneDistance(close, ob.top, ob.bottom)
dists.insertBest(idxs, dist, i, kMax)
idxs
formatVol(float v) =>
str.tostring(v, format.volume)
//#endregion
//#region VOLUME ENGINE (CHART OR LOWER TF)
// Per-bar total / bull / bear volume
tfSec(string tf) =>
timeframe.in_seconds(tf)
int chartSec = tfSec(timeframe.period)
int srcSec = tfSec(vdTfIn)
bool useLtf = not na(chartSec) and not na(srcSec) and srcSec < chartSec
getBarVols() =>
float tot = na
float bull = na
float bear = na
if not useLtf or vdTfIn == ""
float v = volume
bool up = close > open
bool dn = close < open
tot := v
bull := up ? v : 0.0
bear := dn ? v : 0.0
else
array oArr = request.security_lower_tf(syminfo.tickerid, vdTfIn, open)
array cArr = request.security_lower_tf(syminfo.tickerid, vdTfIn, close)
array vArr = request.security_lower_tf(syminfo.tickerid, vdTfIn, volume)
float tSum = 0.0
float bSum = 0.0
float sSum = 0.0
int n = array.size(vArr)
if n > 0
for i = 0 to n - 1
float v2 = array.get(vArr, i)
float o2 = array.get(oArr, i)
float c2 = array.get(cArr, i)
tSum += v2
if c2 > o2
bSum += v2
else if c2 < o2
sSum += v2
tot := tSum
bull := bSum
bear := sSum
= getBarVols()
//#endregion
//#region POC ENGINE (MOST-TOUCHED PRICE + VOLUME)
// Finds a POC between swing and BOS, then aggregates volume.
findMostTouchedPrice(int fromIdx, int toIdx, int nBins) =>
int span = toIdx - fromIdx
if span <= 0 or na(fromIdx) or na(toIdx)
else
float minP = 1e10
float maxP = -1e10
for idx = fromIdx to toIdx
int rel = bar_index - idx
if rel >= 0
float lo = low
float hi = high
if not na(lo) and not na(hi)
if lo < minP
minP := lo
if hi > maxP
maxP := hi
if not (minP < maxP)
else
float step = (maxP - minP) / nBins
step := step <= 0 ? syminfo.mintick : step
array diffCnt = array.new_float(nBins, 0.0)
for idx = fromIdx to toIdx
int rel2 = bar_index - idx
if rel2 >= 0
float lo2 = low
float hi2 = high
if not na(lo2) and not na(hi2)
int sBin = int(math.floor((lo2 - minP) / step))
int eBin = int(math.floor((hi2 - minP) / step))
sBin := sBin < 0 ? 0 : sBin > nBins - 1 ? nBins - 1 : sBin
eBin := eBin < 0 ? 0 : eBin > nBins - 1 ? nBins - 1 : eBin
float cStart = diffCnt.get(sBin)
diffCnt.set(sBin, cStart + 1.0)
if eBin + 1 < nBins
float cEnd = diffCnt.get(eBin + 1)
diffCnt.set(eBin + 1, cEnd - 1.0)
int bestBin = 0
float bestCnt = 0.0
float runCnt = 0.0
for i = 0 to nBins - 1
runCnt += diffCnt.get(i)
if runCnt > bestCnt
bestCnt := runCnt
bestBin := i
float poc = minP + (bestBin + 0.5) * step
// Aggregates total / bull / bear volume at a single price level (POC) for a range.
volumeAtPrice(int fromIdx, int toIdx, float poc) =>
int touches = 0
float totVol = 0.0
float bullVol = 0.0
float bearVol = 0.0
int span = toIdx - fromIdx
if not na(poc) and span >= 0
for step = 0 to span
int idx = toIdx - step
int rel = bar_index - idx
if rel >= 0
float lo = low
float hi = high
if not na(lo) and not na(hi) and lo <= poc and hi >= poc
touches += 1
float vTot = barTotVol
float vBull = barBullVol
float vBear = barBearVol
if not na(vTot)
totVol += vTot
if not na(vBull)
bullVol += vBull
if not na(vBear)
bearVol += vBear
// Wrapper: find POC first, then compute volume at that POC for the BOS range.
calcMostTouchedPriceVol(int fromIdx, int toIdx, int nBins) =>
= findMostTouchedPrice(fromIdx, toIdx, nBins)
= volumeAtPrice(fromIdx, toIdx, poc)
//#endregion
//#region ORDER BLOCK ENGINE (POC-BASED)
// Detects swing highs/lows, confirms BOS, anchors OB at first POC touch.
var array obs = array.new()
var array obRetests = array.new()
var int lastBullRetestBar = na
var int lastBearRetestBar = na
var float shPrice = na
var int shIdx = na
var float slPrice = na
var int slIdx = na
bool evNewBullOB = false
bool evNewBearOB = false
bool evBullRetest = false
bool evBearRetest = false
float ph = ta.pivothigh(high, swingLen, swingLen)
float pl = ta.pivotlow(low, swingLen, swingLen)
if not na(ph)
shPrice := ph
shIdx := bar_index - swingLen
if not na(pl)
slPrice := pl
slIdx := bar_index - swingLen
bool bosBearNow = not na(slPrice) and bar_index > slIdx and close < slPrice and close >= slPrice
bool bosBullNow = not na(shPrice) and bar_index > shIdx and close > shPrice and close <= shPrice
bool bosBear = bosBearNow
bool bosBull = bosBullNow
// Precompute BOS ranges and POC stats in global scope
int bosIdxBear = bar_index - 1
int fromIdxBear = slIdx
int toIdxBear = bosIdxBear
= calcMostTouchedPriceVol(fromIdxBear, toIdxBear, 40)
int bosIdxBull = bar_index - 1
int fromIdxBull = shIdx
int toIdxBull = bosIdxBull
= calcMostTouchedPriceVol(fromIdxBull, toIdxBull, 40)
// Keeps OB array trimmed to recent history and limits max stored OBs.
pruneObs() =>
int minLeft = math.max(0, bar_index - 4999)
if obs.size() > 0
for i = obs.size() - 1 to 0
ObRec ob = obs.get(i)
if ob.leftIndex < minLeft
obs.remove(i)
while obs.size() > MAX_STORED_OBS
bool removed = false
if obs.size() > 0
for j = obs.size() - 1 to 0
ObRec ob2 = obs.get(j)
if not ob2.active
obs.remove(j)
removed := true
break
if not removed and obs.size() > 0
obs.pop()
// Creates and seeds an OB record using a POC-anchored candle and BOS volumes.
addObFromPoc(int baseIdx, float top, float bottom, bool isBull, float totSeed, float bullSeed, float bearSeed, int createdIdx) =>
int offLeft = bar_index - baseIdx
int offCreated = bar_index - createdIdx
int leftTime = time
int createdTm = time
float tot = totSeed
float bVol = bullSeed
float sVol = bearSeed
bool hasDelta = tot > 0.0
float bullPct = hasDelta ? math.round((bVol / tot) * 100.0) : 50.0
float bearPct = hasDelta ? 100.0 - bullPct : 50.0
obs.unshift(ObRec.new(baseIdx, leftTime, createdIdx, createdTm, top, bottom, isBull,
true, false, na, na, na, na, bVol, sVol, tot, bullPct, bearPct, hasDelta))
pruneObs()
// Returns true if a proposed zone overlaps any active OB
obOverlapsActive(float zoneTop, float zoneBottom) =>
float zTop = math.max(zoneTop, zoneBottom)
float zBot = math.min(zoneTop, zoneBottom)
bool overlaps = false
if obs.size() > 0
for i = 0 to obs.size() - 1
ObRec ob = obs.get(i)
if ob.active
float oTop = math.max(ob.top, ob.bottom)
float oBot = math.min(ob.top, ob.bottom)
bool rangeOverlap = zTop >= oBot and zBot <= oTop
if rangeOverlap
overlaps := true
break
overlaps
// Returns true if there is a price gap between anchorIdx and bosIdx.
hasGapBetween(int anchorIdx, int bosIdx, bool isBull) =>
bool gap = false
int fromIdx = math.min(anchorIdx, bosIdx)
int toIdx = math.max(anchorIdx, bosIdx)
if toIdx - fromIdx >= 1
for absIdx = fromIdx + 1 to toIdx
int relNow = bar_index - absIdx
int relPrev = relNow + 1
if relNow >= 0 and relPrev >= 0
float hiPrev = high
float loPrev = low
float hiNow = high
float loNow = low
if not na(hiPrev) and not na(loPrev) and not na(hiNow) and not na(loNow)
if isBull
if loNow > hiPrev
gap := true
break
else
if hiNow < loPrev
gap := true
break
gap
// Bearish BOS → Bearish OB
if bosBear
int bosIdx = bosIdxBear
int fromIdx = fromIdxBear
int toIdx = toIdxBear
if not na(pocB) and touchesB > 0 and not na(fromIdx) and not na(toIdx)
int spanB = toIdx - fromIdx
int bestIdx = na
float runMaxHigh = na
if spanB >= 0
for step = 0 to spanB
int idx = toIdx - step
int rel = bar_index - idx
if rel >= 0
float lo = low
float hi = high
if not na(lo) and not na(hi)
runMaxHigh := na(runMaxHigh) ? hi : math.max(runMaxHigh, hi)
bool touches = lo <= pocB and hi >= pocB
if touches and hi == runMaxHigh
bestIdx := idx
bool gapLeg = not na(bestIdx) ? hasGapBetween(bestIdx, bosIdx, false) : false
if not na(bestIdx) and not gapLeg
int relBest = bar_index - bestIdx
float top = high
float bottom = low
if not obOverlapsActive(top, bottom)
addObFromPoc(bestIdx, top, bottom, false, totVolB, bullVolB, bearVolB, bosIdx)
evNewBearOB := true
slPrice := na
slIdx := na
// Bullish BOS → Bullish OB
if bosBull
int bosIdx2 = bosIdxBull
int fromIdx2 = fromIdxBull
int toIdx2 = toIdxBull
if not na(pocH) and touchesH > 0 and not na(fromIdx2) and not na(toIdx2)
int spanH = toIdx2 - fromIdx2
int bestIdx2 = na
float runMinLow = na
if spanH >= 0
for step = 0 to spanH
int idx2 = toIdx2 - step
int rel2 = bar_index - idx2
if rel2 >= 0
float lo2 = low
float hi2 = high
if not na(lo2) and not na(hi2)
runMinLow := na(runMinLow) ? lo2 : math.min(runMinLow, lo2)
bool touches = lo2 <= pocH and hi2 >= pocH
if touches and lo2 == runMinLow
bestIdx2 := idx2
bool gapLeg2 = not na(bestIdx2) ? hasGapBetween(bestIdx2, bosIdx2, true) : false
if not na(bestIdx2) and not gapLeg2
int relBest2 = bar_index - bestIdx2
float top2 = high
float bottom2 = low
if not obOverlapsActive(top2, bottom2)
addObFromPoc(bestIdx2, top2, bottom2, true, totVolH, bullVolH, bearVolH, bosIdx2)
evNewBullOB := true
shPrice := na
shIdx := na
// Invalidation and retest detection for existing OBs.
if obs.size() > 0
for i = 0 to obs.size() - 1
ObRec ob = obs.get(i)
if ob.active
bool invalid = false
int invIdx = na
int invTime = na
if ob.isBull
if invMethod == "Wick"
invalid := low < ob.bottom
invIdx := bar_index
invTime := time
else
if bar_index > 0
invalid := close < ob.bottom
invIdx := bar_index - 1
invTime := time
else
if invMethod == "Wick"
invalid := high > ob.top
invIdx := bar_index
invTime := time
else
if bar_index > 0
invalid := close > ob.top
invIdx := bar_index - 1
invTime := time
if invalid
ob.active := false
ob.invalidIndex := invIdx
ob.invalidTime := invTime
bool retestPrev = false
int retestBar = na
int retestTm = na
if bar_index > 0
if ob.isBull
bool opensAbovePrev = open > ob.top
bool closesAbovePrev = close > ob.top
bool wickTouchesPrev = low <= ob.top and low >= ob.bottom
retestPrev := opensAbovePrev and closesAbovePrev and wickTouchesPrev
else
bool opensBelowPrev = open < ob.bottom
bool closesBelowPrev = close < ob.bottom
bool wickTouchesPrev = high >= ob.bottom and high <= ob.top
retestPrev := opensBelowPrev and closesBelowPrev and wickTouchesPrev
if retestPrev
retestBar := bar_index - 1
retestTm := time
if retestPrev and not na(retestBar) and retestBar > ob.createdIndex
ob.retested := true
ob.retestIndex := retestBar
ob.retestTime := retestTm
int lastSideBar = ob.isBull ? lastBullRetestBar : lastBearRetestBar
bool canLog = na(lastSideBar) or retestBar - lastSideBar >= 4
if canLog
obRetests.unshift(RetestRec.new(retestBar, ob.isBull, ob.leftIndex, ob.createdIndex))
if ob.isBull
evBullRetest := true
lastBullRetestBar := retestBar
else
evBearRetest := true
lastBearRetestBar := retestBar
obs.set(i, ob)
//#endregion
//#region DRAW ENGINE (ZONES + VOLUME + 3D)
// Handles all boxes, polylines and labels for OBs and 3D faces.
bool showVD = vdEnable
bool isVert = displayStyle == "Vertical"
bool isHorz = not isVert
float dayAtr = ta.atr(14)
var array allBoxes = array.new()
var array allPolys = array.new()
var array allLabels = array.new()
drawPoly(PolyParams pp) =>
if not na(pp) and not na(pp.points) and pp.points.size() > 0
allPolys.unshift(polyline.new(points = pp.points, line_color = pp.lineColor, fill_color = pp.fillColor))
method pushBox(array store, box b) =>
store.unshift(b)
method pushLabel(array store, label l) =>
store.unshift(l)
// Chooses base colors for OB zones depending on vdEnable and bull/bear type.
obColors(ObRec ob) =>
color bullCol = vdEnable ? vdBullColor : bullObColor
color bearCol = vdEnable ? vdBearColor : bearObColor
color baseCol = ob.isBull ? bullCol : bearCol
color faded = ob.active ? baseCol : color.new(baseCol, 85)
// Computes right-most bar index for drawing an OB, considering extension and invalidation.
obRightIndex(ObRec ob) =>
int activeRight = bar_index + extendZones
if ob.active
activeRight
else
na(ob.invalidIndex) ? activeRight : ob.invalidIndex
// Draws the main OB zone box on the chart.
drawObZoneBox(ObRec ob, color faded) =>
int xR = obRightIndex(ob)
int xL = ob.leftIndex
int minBar = bar_index - 4999
if xL < minBar
xL := minBar
xR := math.max(xR, xL)
box bx = box.new(left = xL, right = xR, top = ob.top, bottom = ob.bottom, xloc = xloc.bar_index, bgcolor = faded, border_color = na, border_width = 0)
allBoxes.pushBox(bx)
// Draws a retest marker (triangle) when price revisits an OB.
drawRetestLabels(array bullAct, array bearAct, array bullInv, array bearInv) =>
int ret = 0
if showRetestLbl and obRetests.size() > 0
int minBar = bar_index - 4999
int lastBullLbl = na
int lastBearLbl = na
for i = obRetests.size() - 1 to 0
RetestRec r = obRetests.get(i)
if r.barIndex < minBar or r.barIndex > bar_index
RetestRec _trash = obRetests.remove(i)
else
bool hasDisplayedParent = false
if r.isBull
if bullAct.size() > 0
for j = 0 to bullAct.size() - 1
ObRec ob = obs.get(bullAct.get(j))
if ob.leftIndex == r.obLeftIndex and ob.createdIndex == r.obCreatedIndex
hasDisplayedParent := true
break
if not hasDisplayedParent and not hideInvalid and bullInv.size() > 0
for j = 0 to bullInv.size() - 1
ObRec ob = obs.get(bullInv.get(j))
if ob.leftIndex == r.obLeftIndex and ob.createdIndex == r.obCreatedIndex
hasDisplayedParent := true
break
else
if bearAct.size() > 0
for j = 0 to bearAct.size() - 1
ObRec ob = obs.get(bearAct.get(j))
if ob.leftIndex == r.obLeftIndex and ob.createdIndex == r.obCreatedIndex
hasDisplayedParent := true
break
if not hasDisplayedParent and not hideInvalid and bearInv.size() > 0
for j = 0 to bearInv.size() - 1
ObRec ob = obs.get(bearInv.get(j))
if ob.leftIndex == r.obLeftIndex and ob.createdIndex == r.obCreatedIndex
hasDisplayedParent := true
break
if not hasDisplayedParent
continue
int age = bar_index - r.barIndex
if age >= 0 and age <= 4999
if r.isBull
if not na(lastBullLbl) and r.barIndex - lastBullLbl < 3
continue
lastBullLbl := r.barIndex
else
if not na(lastBearLbl) and r.barIndex - lastBearLbl < 3
continue
lastBearLbl := r.barIndex
float yPrice = close
color baseCol = r.isBull ? bullObColor : bearObColor
st = r.isBull ? label.style_triangleup : label.style_triangledown
yl = r.isBull ? yloc.belowbar : yloc.abovebar
label newLbl = label.new(r.barIndex, yPrice, "", xloc = xloc.bar_index, yloc = yl, style = st,
color = color.new(baseCol, 0), textcolor = color.new(baseCol, 0), size = retestSize, force_overlay = true)
allLabels.pushLabel(newLbl)
ret
// Returns geometry used for volume overlay and 3D top view.
obGeom(ObRec ob) =>
int rawL = ob.leftIndex
int rawR = obRightIndex(ob)
int minBar = bar_index - 4999
int xL = math.max(rawL, minBar)
int xR = math.max(rawR, xL)
int widthX = vd3DDepth
int xR2 = xR + widthX
float yT = ob.top
float yB = ob.bottom
float h = yT - yB
// Converts bull/bear percentages into display strings (if enabled).
deltaTexts(float bullPct, float bearPct) =>
string bullTxt = showDeltaPct ? str.tostring(bullPct) + "%" : ""
string bearTxt = showDeltaPct ? str.tostring(bearPct) + "%" : ""
// Draws a text label with total volume on the right-bottom corner of the OB.
drawTotalVolLabel(int xL, int xR, float yT, float yB, float h, float total) =>
if showTotalVol
int cx = xR - 1
if cx < xL
cx := xL
float cy = yB + h * 0.25
string txt = formatVol(total)
label lb = label.new(cx, cy, txt, xloc = xloc.bar_index, style = label.style_label_right,
textcolor = vdTextColor, color = #ffffff00, size = size.small, force_overlay = true)
allLabels.pushLabel(lb)
// Fills the OB with bull/bear split either vertically or horizontally.
drawDeltaFills(int xL, int xR, float yT, float yB, float h, float bullPct, string bullTxt, string bearTxt) =>
color bullCol = vdEnable ? vdBullColor : bullObColor
color bearCol = vdEnable ? vdBearColor : bearObColor
if isVert
int splitX = xL + int((xR - xL) * (bullPct / 100.0))
splitX := xR - xL >= 2 ? math.max(xL + 1, math.min(xR - 1, splitX)) : xL
box bBull = box.new(xL, yT, splitX, yB, xloc = xloc.bar_index, bgcolor = bullCol, border_width = 0, text = bullTxt, text_color = vdTextColor, text_size = size.small)
box bBear = box.new(splitX, yT, xR, yB, xloc = xloc.bar_index, bgcolor = bearCol, border_width = 0, text = bearTxt, text_color = vdTextColor, text_size = size.small)
allBoxes.pushBox(bBull)
allBoxes.pushBox(bBear)
else
float midY = yB + h * (bullPct / 100.0)
box bBull = box.new(xL, midY, xR, yB, xloc = xloc.bar_index, bgcolor = bullCol, border_width = 0, text = bullTxt, text_color = vdTextColor, text_size = size.small)
box bBear = box.new(xL, yT, xR, midY, xloc = xloc.bar_index, bgcolor = bearCol, border_width = 0, text = bearTxt, text_color = vdTextColor, text_size = size.small)
allBoxes.pushBox(bBull)
allBoxes.pushBox(bBear)
// Track first visible bar index for 3D top face clipping.
var int leftVisIdx = na
if na(leftVisIdx) and time >= chart.left_visible_bar_time
leftVisIdx := bar_index
// Draws the 3D front faces and top faces based on bull/bear split and style.
drawDelta3D(int xL, int xR, int widthX, int xR2, float yT, float yB, float h, float bullPct) =>
color bullCol = vdEnable ? vdBullColor : bullObColor
color bearCol = vdEnable ? vdBearColor : bearObColor
float depthY = dayAtr * (0.1 * vd3DDepth)
int visibleLeft = na(leftVisIdx) ? xL : math.max(xL, leftVisIdx)
int visibleRight = xR
if isHorz
float midY = yB + h * (bullPct / 100.0)
if bullPct > 0
array ptsFrontBull = array.new()
ptsFrontBull.sideBox(xR, yB, midY, depthY, widthX)
drawPoly(PolyParams.new(ptsFrontBull, color.new(chart.fg_color, 90), color.new(bullCol, 70), 1))
if bullPct < 100
array ptsFrontBear = array.new()
ptsFrontBear.sideBox(xR, midY, yT, depthY, widthX)
drawPoly(PolyParams.new(ptsFrontBear, color.new(chart.fg_color, 90), color.new(bearCol, 70), 1))
if visibleRight > visibleLeft
array ptsTop = array.new()
ptsTop.unshift(chart.point.from_index(visibleRight + widthX, yT + depthY))
ptsTop.unshift(chart.point.from_index(visibleLeft + widthX, yT + depthY))
ptsTop.unshift(chart.point.from_index(visibleLeft, yT))
ptsTop.unshift(chart.point.from_index(visibleRight, yT))
ptsTop.unshift(chart.point.from_index(visibleRight + widthX, yT + depthY))
drawPoly(PolyParams.new(ptsTop, color.new(chart.fg_color, 90), color.new(bearCol, 70), 1))
else
array ptsFront = array.new()
ptsFront.sideBox(xR, yB, yT, depthY, widthX)
drawPoly(PolyParams.new(ptsFront, color.new(chart.fg_color, 90), color.new(bearCol, 70), 1))
if visibleRight > visibleLeft
float frac = bullPct / 100.0
int bullRight = visibleLeft + int((visibleRight - visibleLeft) * frac)
bullRight := math.max(visibleLeft, math.min(visibleRight, bullRight))
if bullPct > 0 and bullRight > visibleLeft
array ptsTopBull = array.new()
ptsTopBull.unshift(chart.point.from_index(bullRight + widthX, yT + depthY))
ptsTopBull.unshift(chart.point.from_index(visibleLeft + widthX, yT + depthY))
ptsTopBull.unshift(chart.point.from_index(visibleLeft, yT))
ptsTopBull.unshift(chart.point.from_index(bullRight, yT))
ptsTopBull.unshift(chart.point.from_index(bullRight + widthX, yT + depthY))
drawPoly(PolyParams.new(ptsTopBull, color.new(chart.fg_color, 90), color.new(bullCol, 70), 1))
if bullPct < 100 and visibleRight > bullRight
array ptsTopBear = array.new()
ptsTopBear.unshift(chart.point.from_index(visibleRight + widthX, yT + depthY))
ptsTopBear.unshift(chart.point.from_index(bullRight + widthX, yT + depthY))
ptsTopBear.unshift(chart.point.from_index(bullRight, yT))
ptsTopBear.unshift(chart.point.from_index(visibleRight, yT))
ptsTopBear.unshift(chart.point.from_index(visibleRight + widthX, yT + depthY))
drawPoly(PolyParams.new(ptsTopBear, color.new(chart.fg_color, 90), color.new(bearCol, 70), 1))
// Draws a full OB: zone, retest label, volume fill and 3D faces.
drawZoneAndVolume(ObRec ob) =>
= obColors(ob)
drawObZoneBox(ob, faded)
if showVD and ob.hasDelta
= obGeom(ob)
= deltaTexts(ob.bullPct, ob.bearPct)
drawTotalVolLabel(xL, xR, yT, yB, h, ob.totalVol)
drawDeltaFills(xL, xR, yT, yB, h, ob.bullPct, bullTxt, bearTxt)
if vd3D
drawDelta3D(xL, xR, widthX, xR2, yT, yB, h, ob.bullPct)
true
// Clear all previous drawings each bar before re-rendering current selection.
allBoxes.clearAll(allPolys, allLabels)
// Pick active and invalid OBs based on hideInvalid + showNearestX.
array bullActive = array.new_int()
array bearActive = array.new_int()
array bullInvalid = array.new_int()
array bearInvalid = array.new_int()
if hideInvalid
bullActive := pickNearest(obs, true, showNearestX, false)
bearActive := pickNearest(obs, false, showNearestX, false)
else
bullActive := pickNearest(obs, true, showNearestX, false)
bearActive := pickNearest(obs, false, showNearestX, false)
if obs.size() > 0
for i = 0 to obs.size() - 1
ObRec o = obs.get(i)
if not o.active
if o.isBull
bullInvalid.push(i)
else
bearInvalid.push(i)
if bearInvalid.size() > 0 and not hideInvalid
for i = 0 to bearInvalid.size() - 1
ObRec ob = obs.get(bearInvalid.get(i))
drawZoneAndVolume(ob)
if bearActive.size() > 0
for i = 0 to bearActive.size() - 1
ObRec ob = obs.get(bearActive.get(i))
drawZoneAndVolume(ob)
if bullInvalid.size() > 0 and not hideInvalid
for i = 0 to bullInvalid.size() - 1
ObRec ob = obs.get(bullInvalid.get(i))
drawZoneAndVolume(ob)
if bullActive.size() > 0
for i = 0 to bullActive.size() - 1
ObRec ob = obs.get(bullActive.get(i))
drawZoneAndVolume(ob)
// Draw all stored retest events on top of zones
drawRetestLabels(bullActive, bearActive, bullInvalid, bearInvalid)
//#endregion
//#region ALERTS
alertcondition(alBullOB and evNewBullOB, "Bullish Order Block", "New Bullish Order Block detected.")
alertcondition(alBearOB and evNewBearOB, "Bearish Order Block", "Bearish Order Block detected.")
alertcondition(alBullRetest and evBullRetest, "Bullish OB Retest", "Bullish Order Block retest.")
alertcondition(alBearRetest and evBearRetest, "Bearish OB Retest", "Bearish Order Block retest.")
if alBullOB and evNewBullOB
alert("Bullish Order Block detected.", alert.freq_once_per_bar)
if alBearOB and evNewBearOB
alert("Bearish Order Block detected.", alert.freq_once_per_bar)
if alBullRetest and evBullRetest
alert("Bullish Order Block retest.", alert.freq_once_per_bar)
if alBearRetest and evBearRetest
alert("Bearish Order Block retest.", alert.freq_once_per_bar)
// ==========================================================================================
// === Dashboard with Telegram Link ===
var table myTable = table.new(position.top_center, 1, 1, border_width=1, frame_color=color.black, bgcolor=color.white)
// Add Telegram Message to Dashboard
table.cell(myTable, 0, 0, "Join Telegram @STRATEGY INDIBOT", bgcolor=color.blue, text_color=color.white, text_size=size.normal)
SMC Structure [PickMyTrade]Concept & Methodology
This strategy is an implementation of Smart Money Concepts (SMC) logic combined with structured risk management rules. The purpose of the script is to demonstrate how market structure analysis and position sizing logic can be applied in a systematic, rule-based approach.
The design emphasizes consistency, trade management, and controlled risk rather than signal frequency.
How It Works
1. Market Structure Detection
The strategy evaluates market structure using swing points:
Swings are identified using pivot highs and lows with a configurable lookback period.
Break of Structure (BOS) is detected when price breaks a prior swing level, indicating a potential structural shift or continuation.
Order Blocks are identified after a valid BOS and represent the candle range associated with the structure break.
2. Entry Logic
After a valid structure break, the strategy waits for price to retrace into the identified Order Block zone. Optional filters can be enabled to refine entries:
Trend Filter: Uses the 50 EMA to align trades with directional bias.
Volatility Filter: Uses ATR to avoid low-volatility conditions.
Candle Confirmation: Requires a directional candle within the Order Block area.
3. Risk Management Logic
Risk is handled through predefined and configurable rules:
Dynamic Position Sizing: Position size is calculated based on a fixed percentage of account equity and the distance to the stop loss.
Multiple Take-Profit Levels (optional):
TP1 at a fixed risk-to-reward ratio.
TP2 with an optional trailing stop mechanism.
Stop loss placement is derived from structure-based levels.
Settings Guide
Risk and Position Sizing: Controls the percentage of equity risked per trade.
Filters: Enable or disable trend, volatility, and confirmation logic.
Display Options: Toggle structure points, order blocks, and trade labels.
Strategy Explanation (Code Overview)
The script defines realistic strategy properties such as commission, margin, and pyramiding limits to improve backtesting accuracy.
Market structure is identified using pivot-based swing detection, with BOS logic tracking the most recent swing levels. Order Blocks are derived from candles preceding valid structure breaks.
Trade execution occurs only when no active position is present. Entry conditions require price interaction with a valid Order Block and confirmation from enabled filters. Position size is calculated dynamically based on risk settings.
Exit management supports partial exits at predefined risk-to-reward levels, with optional trailing stop logic for remaining position size.
A statistics panel is displayed on the chart to summarize current settings and account information. This panel is informational only and does not affect strategy logic or results.
Disclaimer
This strategy is provided for educational and analytical purposes only. It does not constitute financial or investment advice. Past performance does not guarantee future results. Users should independently evaluate and backtest the strategy on their own instruments and timeframes before using it for any trading decisions.
Advanced Bull-Bear Power IndicatorAdvanced Bull–Bear Power Indicator
The Advanced Bull–Bear Power Indicator is a momentum and market strength tool that quantifies the balance of power between buyers (bulls) and sellers (bears) over a selected lookback period. Rather than focusing only on price direction, it measures how much effort each side applies to move the price, combining both candle magnitude and candle frequency into a normalized strength metric.
How It Works
For every candle, the indicator calculates the absolute percentage change between the open and close. This represents the true price effort of that candle, independent of direction.
Each candle is then classified:
- Bullish candle: close > open
- Bearish candle: close ≤ open
Bullish candles contribute their strength only to bulls, while bearish candles contribute only to bears.
Over the selected period, the indicator computes:
- Average bullish candle strength
- Average bearish candle strength
- Percentage of bullish candles
- Percentage of bearish candles
Using the average strength values, a Power Ratio is calculated:
Power Ratio = Bull Avg / (Bull Avg + Bear Avg) × 100
This produces a clean 0–100 scale:
- Above 50 → Bullish dominance
- Below 50 → Bearish dominance
Visual Interpretation
The main line represents the Bull–Bear Power Ratio. Color gradients reflect dominance, where green tones indicate bullish control and red tones indicate bearish control.
Key reference levels:
- 50 → Neutral balance
- 60 → Strong bullish dominance
- 40 → Strong bearish dominance
Background highlights appear in extreme conditions:
- Above 70 → Extreme bull pressure
- Below 30 → Extreme bear pressure
Statistics Table
An optional statistics table displays:
- Average bullish strength
- Average bearish strength
- Bullish and bearish candle ratios
- Current power ratio
- Market state classification (Strong Bull, Weak Bull, Weak Bear, Strong Bear)
This allows quick assessment of whether dominance comes from consistent pressure or isolated strong moves.
Alerts
Alerts are triggered when:
- Power crosses above 60 → Strong bullish momentum
- Power crosses below 40 → Strong bearish momentum
- Power crosses 50 → Market balance shift
Practical Applications
This indicator can be used for trend strength confirmation, detecting early dominance shifts before breakouts, filtering trades in sideways or low-quality markets, and comparing momentum quality across assets or timeframes.
Key Insight
This indicator does not simply ask “Is price going up or down?”
It answers a more important question:
Which side is truly exerting more force on the market right now?
Disclaimer
This indicator should not be used as a standalone decision-making tool. It is designed to complement other forms of technical, fundamental, or contextual analysis. Always confirm signals with additional indicators, market structure, and risk management techniques. The user is solely responsible for any trading decisions made using this indicator.
myZones [eFe]myZones
This indicator is designed for traders utilizing Smart Money Concepts (SMC) and Price Action , focusing on the precise validation of market structure. Unlike standard pivot indicators that look at neighboring bars, myZones uses a logic based on "Inducement" or "Candle Validation".
🟢 Concept: Valid Highs & Lows
The core of this indicator is how it defines a structural point:
Valid High : A high is only valid (confirmed) when a subsequent candle closes below the low of the specific candle that made that high.
Valid Low : A low is only valid (confirmed) when a subsequent candle closes above the high of the specific candle that made that low.
This method helps filter out noise and identifies true structural points that the market has committed to.
🔵 Features
1. Structural Markers
Visualizes confirmed Tops (Valid Highs) and Bottoms (Valid Lows) with customizable icons (Triangles, Circles, Diamonds, etc.).
2. Break of Structure (BOS) / MSS Zones
When price breaks a Valid High , a Bullish Structure Break occurs.
When price breaks a Valid Low , a Bearish Structure Break occurs.
Zones : The indicator draws a visual "Zone" connecting the broken structure level to the candle that broke it.
Zone 1 : Usually indicates the first break (Market Structure Shift / MSS) signaling a potential reversal.
Zone 2+ : Indicates trend continuation (BOS).
3. Real-Time Validation Line
A dashed line tracks the current "Candidate" High or Low level.
It shows you exactly where the candle needs to close to confirm the current structure point.
⚙️ Settings
Valid Highs & Lows : Customize marker style, size, and colors.
Validation Line : Toggle the visual aid for pending structure validation.
Zones :
Show Lines : Dropdown to select "None", "Zone 1 (MSS)", or "All (MSS + BoS)".
Zone Fills : Separate dropdowns for Bullish and Bearish fills. Use this to create a unique setup—for instance, show all Bullish zones to track a sub-trend, but only show Zone 1 for Bearish zones to spot major reversals.
Colors : Fully adjustable transparency and colors.
Usage Tip :
Use "Zone 1" fills to easily spot potential reversals (MSS), and use the Validation Line to anticipate when a new structural point is about to be confirmed in real-time.
Inside Bar Breakout ( candlestick pattern).📌 What Is This Indicator?
BOIB Pro identifies a very strict form of inside bar:
✅ The inside bar candle’s entire range (body + wicks) must be inside the BODY of the previous candle (mother candle).
❌ If even a single wick is outside the mother body, the setup is rejected.
This filters out weak and noisy inside bars and focuses only on true compression candles.
⸻
📐 Pattern Rules (Strict)
1️⃣ Mother Candle
• The candle immediately before the inside bar
2️⃣ Body-Only Inside Bar (BOIB)
A valid BOIB must satisfy:
• Inside bar high ≤ mother candle body high
• Inside bar low ≥ mother candle body low
⚠️ Normal inside bars (inside wicks only) are ignored.
⸻
⏱️ Breakout Window Logic
After a valid BOIB forms:
• The indicator waits for the next 1 to 5 candles (user-configurable)
• Entry is triggered only if price CLOSES outside the BOIB range
✅ Long Signal
• Candle closes above BOIB high
✅ Short Signal
• Candle closes below BOIB low
If no breakout occurs within the window → setup expires automatically
⸻
🎯 Entry, Stop Loss & Take Profit Logic
Once a valid breakout/breakdown occurs, the indicator automatically draws a professional trade template:
Entry
• At the close of the breakout candle
Stop Loss
• Long → below BOIB low
• Short → above BOIB high
• Optional buffer:
• ATR-based
• Percentage-based
• Or none
Take Profits
• TP1: Risk-Reward based (default 1R)
• TP2: Extended target (default 2R)
All levels are clearly visualized using:
• Horizontal price lines
• Risk and reward boxes
• Informational labels
⸻
📊 Best Use Cases
• Crypto (BTC, ETH, major alts)
• Timeframes:
• Scalping: 5m
• Day trading: 15m / 30m
• Works best when combined with:
• Market structure
• Trend bias
• Support / resistance
⸻
⚠️ Important Notes
• This is NOT an auto-trading system
• Signals should always be used with:
• Proper risk management
• Market context
• Inside bars in sideways or low-volume markets may fail
⸻
📚 Educational Purpose Disclaimer
This indicator is provided for educational and analytical purposes only.
It does not constitute financial advice.
Trading involves risk, and past behavior does not guarantee future results.
Gemini Trend & Momentum Synergy (With Sound Alerts)** هذا المؤشر لا يعمل ك محلل تداول بديل لكنه يستخدم لمعرفة الاتجاه العام و مناطق الدخول والخروج لطفا ..
خطوة مهمة جداً: كيف تفعل الصوت؟ 🔊
الكود وحده لا يصدر صوتاً، هو فقط يرسل "إشارة" للمنصة. لكي تسمع الصوت، عليك اتباع الخطوات التالية في TradingView بعد حفظ الكود:
1. اضغط على أيقونة "الساعة" (Alerts) في القائمة الجانبية اليمنى، أو اضغط Alt + A.
2. اضغط على زر Create Alert.
3. في خانة Condition، اختر اسم المؤشر: Gemini Trend & Momentum....
سيكون لديك خياران الآن:
الخيار السهل: اختر "Any alert() function call". هذا سيفعل التنبيه تلقائياً لأي إشارة شراء أو بيع يطلقها الكود.
الخيار المخصص: اختر Gemini Buy Alert أو Gemini Sell Alert إذا كنت تريد تنبيهاً لاتجاه واحد فقط.
الأهم: اذهب لتبويب Notifications وتأكد من وضع علامة صح (✅) على Play Sound.
اضغط Create.
Here is the translation of the text, organized exactly as requested:
**Please Note: This indicator does not serve as a replacement for a trading analyst; rather, it is used to identify the general trend as well as potential entry and exit zones.**
**Very Important Step: How to Enable Sound Alerts? 🔊**
The code alone does not generate sound; it merely sends a "signal" to the platform. To hear audio alerts, you must follow these steps in TradingView after saving the code:
1. Click the **"Clock" icon (Alerts)** in the right-hand sidebar, or press `Alt + A`.
2. Click the **Create Alert** button.
3. In the **Condition** field, select the indicator name: `Gemini Trend & Momentum...`.
4. You will now have two options:
* **The Easy Option:** Select **"Any alert() function call"**. This automatically activates the alert for any Buy or Sell signal triggered by the code.
* **The Custom Option:** Select `Gemini Buy Alert` or `Gemini Sell Alert` if you only want alerts for a specific direction.
5. **Most Importantly:** Go to the **Notifications** tab and ensure the **Play Sound** box is checked (✅).
6. Click **Create**.
---
**Would you like me to translate the installation instructions or the strategy logic as well?**
KCP Dynamic Support Resistance [Dr.K.C.Prakash]KCP Dynamic Support Resistance
KCP Dynamic Support Resistance is a pivot-based indicator that automatically identifies key Support and Resistance levels from recent price action and plots them as clean, horizontal lines on the chart.
🔹 How it works
Uses pivot highs to mark Resistance levels
Uses pivot lows to mark Support levels
Levels extend to the right side of the chart and act as potential reaction zones
Optionally highlights the highest and lowest price levels within the selected lookback period
🔹 Key Features
📌 Dynamic S/R based on real market structure
⏱ Lookback control to focus on recent price relevance
📊 Custom line style, color, and thickness
🔼 Optional pivot point markers for clarity
🔒 Non-repainting (levels form only after pivots are confirmed)
🔹 Best Use Cases
Identifying buy zones near support
Spotting sell / rejection zones near resistance
Combining with VWAP, EMA, RSI, or price action
Works well on 15m, 30m, 1H, and higher timeframes
🔹 Trading Insight
Price often:
Bounces near support
Rejects near resistance
Breaks out with volume and momentum
This indicator helps traders visually map those zones with minimal chart clutter.
Institutional Flow DetectorOverview
InstFlow 1S Delta identifies institutional order flow by analyzing volume anomalies and directional bias using 1-second sub-bar data. The indicator detects when large players are likely entering or exiting positions, providing actionable trade recommendations with confidence scoring.
Unlike traditional volume indicators that only show total volume, InstFlow breaks down each bar into 1-second micro-bars, classifies buying vs selling pressure, and identifies statistically significant volume events that likely represent institutional activity.
How It Works
1-Second Delta Analysis
The indicator fetches all 1-second bars within each candle and classifies each micro-bar as buying (close ≥ open) or selling (close < open). This achieves ~85-90% directional accuracy compared to ~55-65% from traditional bar-based methods.
Delta = Buy Volume - Sell Volume
Delta Ratio = |Delta| / Total Volume
Volume Anomaly Detection (Z-Score)
Volume is compared to a rolling 20-bar average using statistical z-scores:
- T1: Z-Score ≥ 1.5 (top ~7% of volume bars)
- T2: Z-Score ≥ 2.0 (top ~2% of volume bars)
- T3: Z-Score ≥ 3.0 (top ~0.1% of volume bars)
Signal Types
- Big Trades (T1/T2/T3) : Unusual volume with clear directional bias
- Absorption (ABS) : High volume + small price move + delta imbalance = hidden liquidity absorbing orders
- Exhaustion (EXH) : Capitulation pattern - big flush followed by immediate reversal with opposing delta
- Divergence (DIV) : Price and cumulative delta disagreeing over 5 bars
ACTION Recommendation System
Synthesizes all signals into a single trade direction (LONG/SHORT/WAIT) with confidence scoring (1-10):
- Exhaustion signals: +5 points (strongest reversal)
- Counter-trend absorption: +4 points
- Volume tier: +1 to +3 points
- Divergence confirmation: +2 points
- Strong trend (ADX>30): +1 point
- High delta imbalance (>50%): +1 point
Features
Real-time 1-second delta classification for accurate buy/sell detection
Statistical volume anomaly detection adapts to each instrument
Absorption detection finds hidden liquidity/iceberg orders
Exhaustion patterns catch capitulation reversals
Delta divergence warns of weakening moves
ACTION + Confidence system provides clear trade recommendations
Price-locked markers stay fixed at detection level (don't float)
Info table displays all metrics in real-time
RTH session filtering
Comprehensive alert conditions
Settings Guide
Detection Settings
Volume Lookback (20): Bars for calculating average volume and standard deviation
T1/T2/T3 Thresholds : Z-score thresholds for volume tiers. Lower = more signals.
1-Second Delta
Delta Resolution (1S): Use 1S for ES/NQ. Try 5S if 1S unavailable.
Min Delta Imbalance (10%): Minimum ratio to classify direction.
Absorption Detection
Min Volume Multiple (1.2x): Volume must exceed average by this multiple
Max Price Move Multiple (0.5x): Price move must be less than this × average range
Delta Imbalance Threshold (20%): Minimum delta ratio for absorption
Exhaustion Detection
Minimum Tier for Flush (T1): Required volume tier for the flush bar
New High/Low Lookback (10): Bars to check for price extremes
Min Reversal Size (0.3x ATR): Required body size for reversal bar
Divergence Detection
Divergence Lookback (5): Bars to compare price vs cumulative delta
Delta Trend Threshold (0.4): Sensitivity for divergence detection
How to Use
Add to ES, NQ, MES, or MNQ chart (1-5 minute timeframe)
Check 1S Data quality in table (green = 30+ bars = reliable)
Monitor ACTION field for trade direction
Use Confidence score for position sizing: HIGH (7+) = full size, GOOD (5-6) = standard, MED (3-4) = reduced
EXH signals are highest priority reversals
ABS + DIV combination is strong reversal confirmation
T2/T3 with trend are continuation signals
Avoid counter-trend T1/T2 without EXH/ABS/DIV confirmation
Visual Guide
Green circles below bar = Buy pressure (T1 small, T2 medium, T3 large)
Red circles above bar = Sell pressure (T1 small, T2 medium, T3 large)
Purple diamond + "ABS" = Absorption detected
Cyan label + "EXH" = Exhaustion pattern
Orange triangle + "DIV" = Delta divergence
Yellow background = Counter-trend warning
Best Practices
Trade during RTH (9:30am - 4:00pm ET) for most reliable signals
Wait for HIGH or GOOD confidence before full position
Use EXH as primary reversal trigger
Check cumulative delta supports trade direction
Combine with price action and support/resistance levels
Limitations
Requires 1-second data availability (ES, NQ, MES, MNQ have this)
ETH signals less reliable due to lower volume
EMA-based trend lags on sharp reversals
Not suitable for stocks without adjusting parameters significantly
Absorption/Exhaustion patterns may not occur every session
Disclaimer
This indicator is for educational and informational purposes only. It does not constitute financial advice.
Past performance does not guarantee future results
The indicator shows where institutional activity is LIKELY - it does not predict the future
Always conduct your own research and analysis
Never risk more than you can afford to lose
Paper trade any new strategy before using real capital
KCP EMA Trend [Dr.K.C.Prakash]KCP EMA Trend
KCP EMA Trend is a clean, rule-based trend indicator designed to capture early and reliable trend shifts using EMA 20 and EMA 50 crossovers, with VWAP shown only as a visual reference.
🔹 Core Logic
BUY Signal
EMA 20 crosses above EMA 50
First signal of the bullish trend (no re-entry)
SELL Signal
EMA 20 crosses below EMA 50
First signal of the bearish trend (no re-entry)
🔹 VWAP Usage
VWAP is plotted only for visual guidance
Helps judge:
Strength of trend
Over-extension from mean
VWAP does not affect signals
🔹 Key Features
One signal per trend (no over-trading)
Works on all instruments
Best suited for intraday trading
Clean chart with minimal lag
Non-repainting logic
🔹 Best Use Case
Timeframes: 3-min / 5-min
Instruments: Index & liquid stocks
Trade direction confidence improves when:
BUY occurs near or above VWAP
SELL occurs near or below VWAP
🔹 Trading Philosophy
Trend first. Discipline always.
One clean signal is better than many noisy ones.
Lanovyx# Lanovyx
A comprehensive day trading indicator that generates **Pullback**, **Reversal**, and **Breakout** signals using the confluence of Stochastic oscillator lanes, VWAP standard deviation bands, and a unique Setup Window system.
---
## 🎯 Three Signal Families
| Signal | Label | Best For |
|--------|-------|----------|
| **Pullback (P)** | Blue | Trend continuation days |
| **Reversal (R)** | Green/Red | Range-bound markets |
| **Breakout (B)** | Orange | Compression breakouts |
**Strong signals (★)** appear when multiple confluence factors align—these are your highest probability setups.
---
## 📊 How It Works
**1. Regime Detection**
Lanovyx identifies market regime (Bull Trend, Bear Trend, Ranging, Coiling) using EMA alignment, market structure, and VWAP position.
**2. Setup Windows**
Unlike traditional indicators requiring all conditions on the same bar, Lanovyx uses Setup Windows. When a context event occurs (VWAP band touch, S/R level, divergence), a setup activates and stays valid for N bars, allowing the trigger to fire within that window.
**3. Signal Generation**
When regime, VWAP zone, stochastic position, and setup all align—a signal appears on your chart.
---
## 📋 Clean Info Table
The top-right table shows 6 essential rows for quick decision-making:
- **Regime** — Market direction (Bull/Bear Trend, Ranging, Coiling)
- **VWAP Zone** — Price location (Discount for buys, Premium for sells)
- **Stoch %D** — Oscillator position for timing
- **Session** — Market hours status
- **Last Signal** — Most recent signal type
- **Trade** — Current position status
Enable **Debug Mode** for additional diagnostic information.
---
## ✅ Entry Rules
**LONG Setup:**
✓ Regime = BULL TREND (or RANGING for reversal)
✓ VWAP Zone = Discount (-1, -2, -3)
✓ Stoch %D = 20-50 rising
✓ Session = ACTIVE
✓ Signal = P, R, or B below candle
**SHORT Setup:**
✓ Regime = BEAR TREND (or RANGING for reversal)
✓ VWAP Zone = Premium (+1, +2, +3)
✓ Stoch %D = 50-80 falling
✓ Session = ACTIVE
✓ Signal = P, R, or B above candle
---
## ⚙️ Key Features
- **3 Stochastic Lanes** — Fast (14), Mid (21), Slow (55) for multi-timeframe momentum
- **VWAP + Bands** — Session-anchored with ±1σ, ±2σ, ±3σ bands
- **Market Structure** — Higher High/Low, Lower High/Low detection
- **HTF Bias Filter** — Optional higher timeframe trend alignment
- **Volume Analysis** — Spike, dry-up, and climax detection
- **ATR Momentum** — Strong/Moderate/Weak classification
- **Trade Management** — ATR-based stop loss and profit targets
- **Signal Statistics** — Win rate and R-multiple tracking
- **Non-Repainting** — Strict mode enabled by default
- **Per-Direction Cooldown** — Prevents signal spam
---
## 🎛️ Recommended Settings
| Timeframe | Setup Window | Cooldown |
|-----------|--------------|----------|
| 5-minute | 10 bars | 5 bars |
| 15-minute | 10 bars | 5 bars |
---
## 📈 Best On
- **ETFs**: SPY, QQQ, IWM
- **Tech**: TSLA, NVDA, AMD, META, GOOG, AAPL
- **Futures**: MNQ, MES, NQ, ES
---
## ⚠️ Disclaimer
This indicator is for educational purposes only. It is not financial advice. Past performance does not guarantee future results. Always use proper risk management and never risk more than you can afford to lose.
---
## 📝 Version
v3.0
---
**Questions or feedback?** Drop a comment below!
Nerot YapanimCandle Patterns Pro: Momentum & Multilingual
Overview
Candle Patterns Pro is an advanced, high-conviction candlestick pattern detector built for Pine Script v5. Unlike standard indicators that trigger on every technical occurrence, this script utilizes Momentum-Verified Logic to filter out market noise and "indecisive" price action.
Designed for clarity and precision, it features a unique Multilingual Toggle, allowing users to switch between professional English and Hebrew terminology instantly.
Key Features
1. Momentum-Verified Logic (Anti-Doji Filter)
Most pattern detectors fail by triggering on small-bodied "Doji" candles that lack direction. This indicator uses a custom isStrong algorithm: a signal only triggers if the real body of the candle represents at least 50% of the total candle range. This ensures you only see patterns where bulls or bears have shown true dominance.
2. "Real Body" Engulfing
To prioritize high-probability reversals, the Engulfing logic is calculated using Real Bodies (Open to Close) rather than wicks. By ignoring the "noise" of the thicks/wicks, the signals identify much stronger shifts in institutional pressure.
Shutterstock
3. Integrated Trend Filter (Moving Average)
Align your trades with the primary trend. When the MA Filter is enabled, bullish signals are only displayed if the price is above the Moving Average, while bearish signals appear only when the price is below it.
4. Professional Multilingual Support
This indicator is built for a global audience. Through the settings menu, users can toggle between English and Professional Hebrew labels.
English: Engulfing, 3 Soldiers, 3 Crows, Dark Cloud, etc.
Hebrew: בולען, שלושה חיילים, שלושה עורבים, ענן כהה, etc.
Supported Patterns
Engulfing (Body-Only): Clean reversal signals optimized for momentum.
Three Soldiers & Three Crows: Momentum-verified (Filtered for strength).
Morning & Evening Star: Three-candle structural reversals.
Meeting Line: Precise alignment strike patterns.
Piercing Line & Dark Cloud: Deep-penetration momentum shifts.
Harami: Traditional inside-bar setups.
User Instructions
Selection: Toggle specific patterns on or off in the inputs tab.
Clean UI: The indicator is pre-configured to keep your Status Line clean by hiding values and inputs by default.
Y-Axis Fix: If labels appear "static" or do not move with price, right-click your Price Scale and select "Merge All Scales into One (Right)".
Language: Switch between English and Hebrew via the "Language / שפה" dropdown in settings.
Technical Specifications
Version: Pine Script v5
Execution: Real-time calculation on bar close.
Alerts: Fully compatible with TradingView alerts (Push, Email, Webhook).
Candle PatternsOverview
This indicator is a modernized, high-signal-quality candlestick pattern detector designed for the price-action trader. Unlike standard pattern recognizers that trigger on "weak" or indecisive candles (Dojis), this script uses a Momentum-Verified Logic to ensure that multi-candle patterns represent true market conviction.
The script scans for the most reliable reversal and continuation patterns while providing a built-in Moving Average filter to align signals with the prevailing trend.
Key Features
1. Momentum-Verified Logic (Anti-Doji)
Standard patterns like 3 Soldiers or 3 Crows often trigger with small-bodied candles that lack momentum. This indicator uses a custom isStrong() function requiring the candle body to be at least 50% of the total candle range. This effectively filters out weak signals and "leggy" wicks, showing you only when the bulls or bears are truly in control.
2. "Real Body" Engulfing
To reduce noise, the Engulfing logic is calculated using the Real Bodies (Open to Close). The current candle's body must completely engulf the previous candle's body, ignoring the "noise" of long wicks (thicks).
3. Integrated MA Filter
Trade only in the direction of the trend. When the MA Filter is enabled, bullish signals are only shown if price is above the Moving Average, and bearish signals if price is below it.
Supported Patterns
Engulfing (Body-to-Body): Powerful reversal signals ignoring wick noise.
3 Soldiers & 3 Crows: Momentum-verified (no Dojis allowed).
Morning Star & Evening Star: Three-candle bottom/top reversal patterns.
Meeting Line: Strike patterns where closing prices align.
Piercing Line & Dark Cloud: Deep-penetration reversal signals.
Harami: Traditional "inside bar" reversal setups.
How to Use
Select Your Patterns: Use the Settings menu to toggle specific patterns on or off.
Trend Alignment: Enable the "MA Filter" and set your period (e.g., 50 or 200) to filter for high-probability trend-following setups.
Y-Axis Alignment: For the best experience, ensure your Price Scale is set to "Merge All Scales into One (Right)" to keep labels perfectly pinned to price action.
Technical Details
Version: Pine Script v5
Overlay: Yes (Plots directly on candles)
Alerts: Compatible with alertcondition for "Once Per Bar Close" notifications.
Intraday Toolkit1. Visual Components of the Indicator
Understanding the visual cues is essential for quick decision-making during fast-moving intraday sessions:
Trend Background: The background color represents the Primary Cycle (80-period) bias. Green indicates a bullish trend (price is above the primary cycle), and red indicates a bearish trend (price is below the primary cycle).
The Three Cycles:
Yellow Line: Short Cycle (20) – Used for momentum triggers.
Orange Line: Mid Cycle (40) – Represents the baseline for volatility envelopes.
Red Line: Primary Cycle (80) – Defines the overall trend direction.
Volatility Envelopes: Two green lines plotted at a distance (1.5x ATR) from the Mid Cycle. These act as exhaustion zones where price is likely to revert or consolidate.
Rule 3 Signals (Purple Circles): These appear when a specific 3-candle momentum breakout occurs.
2. Trading Strategy for 5m & 15m
This toolkit is most effective when you use the 15m chart for trend confirmation and the 5m chart for precise entries.
Long (Buy) Setup
Enter a long position when the following alignment occurs:
Bullish Bias: The background must be Green (Price > Primary Cycle).
Cycle Low: A pivot low must have been detected (the indicator identifies a local bottom).
Momentum Trigger: Price must close above the Yellow Short Cycle line while the previous candle was below it.
Rule 3 Confirmation: If a purple circle appears simultaneously, it confirms strong buying momentum.
Short (Sell) Setup
Enter a short position when the following alignment occurs:
Bearish Bias: The background must be Red (Price < Primary Cycle).
Cycle High: A pivot high must have been detected (the indicator identifies a local top).
Momentum Trigger: Price must close below the Yellow Short Cycle line while the previous candle was above it.
Rule 3 Confirmation: A purple circle above the price confirms a bearish momentum shift.
3. Exit and Take-Profit Logic
The script includes "State Control" to manage your exits effectively:
Targeting the Envelopes: The primary profit target is the Outer Green Envelope. If price touches the upper envelope (for longs) or lower envelope (for shorts), the trend may be exhausted.
Momentum Exit: If price crosses back over the Yellow Short Cycle line in the opposite direction of your trade, the toolkit considers the move over and signals an exit.
4. Specific Tips for Day Trading
Avoid "Counter-Trend" Signals: Do not take Buy signals if the background is Red, or Sell signals if the background is Green. The logic is built to filter these out for better win rates.
The "Rule 3" Advantage: Use the purple circles as a "second chance" entry. If you missed the initial Buy/Sell signal, a Rule 3 circle indicates momentum is still strong in that direction.
Timeframe Synergy: * 15m: Best for seeing the "Big Picture" and avoiding noise.
5m: Best for finding entries with smaller stop-losses near the Yellow Short Cycle line.
XAUUSD Trend Continuation ProXAUUSD Trend Continuation Pro — EMA Pullback System is a professional trend-following indicator designed specifically for trading Gold (XAUUSD) using high-probability continuation setups.
The indicator uses a 200 EMA trend filter to identify the dominant market direction and waits for a healthy pullback before generating breakout entry signals. This allows traders to enter trades in the direction of momentum with strong confirmation.
It is optimized for trending gold markets and works across all broker feeds without relying on fixed price levels.
🔍 How It Works
• Identifies bullish and bearish trend using 200 EMA
• Waits for pullback into value zone
• Triggers entry on breakout confirmation
• Filters trades during low-liquidity sessions
• Projects automatic Stop Loss & Take Profit levels
⚙️ Key Features
✔ Buy & Sell signals
✔ Smart trend filter
✔ London & New York session filter
✔ Automatic SL & TP projection
✔ Alert-ready for automation
✔ Works on all XAUUSD brokers
📌 Best Settings
Symbol: XAUUSD
Timeframe: 1H (Confirm on 15M)
EMA: 200
Risk/Reward: 1:2 or higher
📈 Market Type
Best suited for trending gold markets with strong momentum and strong volume.
Session Highs & LowsCustom Highs & Lows
This indicator displays Previous Day High & Low along with session Highs & Lows for the Asian, London, and New York sessions.
Each session can be configured individually, allowing you to show or hide Highs, Lows, or both.
Basic customization options are included, such as:
level colors
line thickness
line extension length
transparency
line style
The main feature of this indicator is sweep detection.
For example, when the London session sweeps the Asian High or Low, the level automatically changes:
from a solid line to a dotted or dashed line
with reduced opacity
This makes it easy to see that the level has already been swept, while keeping the chart clean and uncluttered when looking for further confluences.
The indicator also supports alerts for all session Highs and Lows when they are swept, so you can receive notifications without constantly watching the chart.
Use it, test it, and if you have a solid idea for improvement, feel free to reach out. A lot of time went into building this indicator, and meaningful enhancements can always be discussed.
How RSI Pullbacks Work Best in a Trend EMA Momentum ConceptRSI is one of the most widely used momentum indicators, but it works best when traded in the direction of the trend rather than in isolation.
This idea demonstrates a simple RSI pullback / retest concept combined with a 50 EMA to identify high-probability trend continuation trades.
🔹 Strategy Concept
The core idea is to trade pullbacks within an existing trend instead of chasing price or predicting reversals.
A 50 EMA is used as a trend filter:
• Price above EMA → bullish bias
• Price below EMA → bearish bias
This keeps trades aligned with market structure and momentum.
🟢 BUY Setup (RSI Pullback in Uptrend)
A buy signal appears when:
• Price is above the 50 EMA
• RSI pulls back below the 45 level
• RSI crosses back above 45
• Price shows bullish confirmation
This represents a healthy pullback, not weakness.
🔴 SELL Setup (RSI Retest in Downtrend)
A sell signal appears when:
• Price is below the 50 EMA
• RSI rises above the 55 level
• RSI crosses back below 55
• Price confirms bearish momentum
This captures continuation after a corrective move.
📊 Chart Observation
As seen on the chart, signals occur after pullbacks rather than at random points.
Trades align with trend direction and avoid sideways conditions.
The highlighted buy and sell markers show how RSI reacts during momentum pauses and resumes in the direction of the trend.
This behavior is clearly visible on intraday charts like the 15-minute timeframe.
🧠 How to Use This Idea
This concept works best when combined with:
• Support and resistance levels
• Market structure
• Candle confirmations (engulfing, strong rejection candles)
• Proper risk management
Technical analysis provides a high-probability edge, but it does not offer certainty. As seen in these examples, trades can frequently move in the opposite direction post-entry. To protect your capital, you must implement a stop-loss for every position and maintain the discipline to honor it, regardless of your conviction.
RSI here is used as a momentum pullback tool, not as a traditional overbought/oversold indicator.
If you find this concept useful, feel free to Boost and share your feedback.
Suggestions for improvements are always welcome.
pacplindicators.com
//@version=5
strategy("PACPL – RSI Pullback / Retest Strategy v2.1 (Live Version)",
overlay=true, max_labels_count=500, initial_capital=100000,
commission_type=strategy.commission.percent, commission_value=0.02)
//------------------------------------------------------
// ⚙️ INPUTS
//------------------------------------------------------
rsiLen = input.int(14, "RSI Length", minval=1)
emaLen = input.int(50, "Trend EMA Length", minval=1)
pullbackBuy = input.int(45, "RSI Pullback Level (BUY Zone)", minval=20, maxval=60)
pullbackSell= input.int(55, "RSI Retest Level (SELL Zone)", minval=40, maxval=80)
confirmBars = input.int(1, "Price Confirmation Bars", minval=1)
showLabels = input.bool(true, "Show Buy/Sell Triangles")
showZones = input.bool(true, "Highlight Pullback Zones")
//------------------------------------------------------
// 📊 CORE INDICATORS
//------------------------------------------------------
rsiValue = ta.rsi(close, rsiLen)
emaPrice = ta.ema(close, emaLen)
trendUp = close > emaPrice
trendDn = close < emaPrice
//------------------------------------------------------
// 🔄 SIMPLIFIED PULLBACK / RETEST LOGIC
//------------------------------------------------------
// BUY → In uptrend, RSI dips below 45 and comes back above it
rsiBuyCond = ta.cross(rsiValue, pullbackBuy) and trendUp
// SELL → In downtrend, RSI rises above 55 and comes back below it
rsiSellCond = ta.cross(rsiValue, pullbackSell) and trendDn
// Confirmation with price direction
priceConfirmUp = close > close
priceConfirmDown = close < close
// Final entry conditions
longCond = rsiBuyCond and priceConfirmUp
shortCond = rsiSellCond and priceConfirmDown
//------------------------------------------------------
// 🧾 STRATEGY EXECUTION
//------------------------------------------------------
if longCond and strategy.position_size <= 0
strategy.entry("BUY", strategy.long)
if shortCond and strategy.position_size >= 0
strategy.entry("SELL", strategy.short)
// Opposite signal exit
if strategy.position_size > 0 and shortCond
strategy.close("BUY", comment="Opposite RSI Retest Exit")
if strategy.position_size < 0 and longCond
strategy.close("SELL", comment="Opposite RSI Pullback Exit")
//------------------------------------------------------
// 📈 VISUALS
//------------------------------------------------------
plot(emaPrice, "EMA", color=color.new(color.teal, 0), linewidth=2)
// Triangles
plotshape(showLabels and longCond, title="Buy", style=shape.triangleup, location=location.belowbar,
color=color.new(color.green, 0), size=size.small, text="BUY")
plotshape(showLabels and shortCond, title="Sell", style=shape.triangledown, location=location.abovebar,
color=color.new(color.red, 0), size=size.small, text="SELL")
// Background zones
bgcolor(showZones and trendUp and rsiValue < pullbackBuy ? color.new(color.green, 85) : na)
bgcolor(showZones and trendDn and rsiValue > pullbackSell ? color.new(color.red, 85) : na)
//------------------------------------------------------
// 🔔 ALERTS
//------------------------------------------------------
alertcondition(longCond, title="BUY Triggered", message="RSI Pullback Retest → BUY Signal")
alertcondition(shortCond, title="SELL Triggered", message="RSI Retest Pullback → SELL Signal")
//------------------------------------------------------
// 🧠 NOTES
//------------------------------------------------------
// ✅ Live, non-repainting RSI pullback logic
// BUY: RSI crosses back above pullback zone while price above EMA
// SELL: RSI crosses back below retest zone while price below EMA
// Simple, effective continuation system for trend pullback entries
// Works on all timeframes (NIFTY, BANKNIFTY, Stocks, Crypto)
XRP Athey Mitchnick Implied Price (Ramp + Analytical 2030 Label)This indicator implements a fundamental valuation framework for XRP based on the Athey–Mitchnick cryptoasset valuation model. Unlike traditional technical indicators (RSI, MACD, etc.), this tool is not designed to predict short-term price movements. Instead, it models what XRP should be worth over time under explicit adoption and demand assumptions.
It answers the question:
If XRP becomes a real settlement rail and a long-term store of value, what price would be required for the system to function?
What This Indicator Adds
This implementation extends the static Athey–Mitchnick model by introducing a time-based ramp:
1. Adoption grows over time
You specify:
TV CAGR (%)
SoV CAGR (%)
These values compound annually from a start date to an end date (e.g., 2030), producing a dynamic implied valuation curve.
2. Terminal 2030 price is computed analytically
The indicator explicitly computes the implied price at the target year (e.g., 2030) and displays it as:
“2030 Implied Price = $X”
This is done analytically, so the chart does not need to extend to 2030 for you to see the terminal valuation.
3. This is not a trading indicator
This model is not designed for:
Scalping
Breakouts
Entry timing
Momentum trading
It is designed for:
Long-term valuation anchoring
Scenario modeling
Macro thesis testing
Adoption-based forecasting
Narrative vs fundamentals comparison
How to Read the Chart
Market Price (Close)
This is the actual XRP market price. It reflects:
Speculation
Liquidity
Leverage
Narrative
Emotion
Implied Price (Ramp)
This is the fundamental valuation curve.
It shows what XRP’s price would need to be at each point in time for your adoption and store-of-value assumptions to be true.
Bands (Optional)
The ±% bands are valuation tolerance zones. They are not volatility bands.
They help visualize:
Overvaluation
Undervaluation
Reversion zones
2030 Label
The label:
2030 Implied Price = $X
represents the terminal valuation implied by your assumptions. This is the most important output of the model.
What Makes the Price Go Higher
To increase the implied 2030 price, one or more of these must change:
1. Higher Transaction Adoption (TV)
Inputs:
TV0
TV CAGR %
This reflects real-world economic usage.
Higher TV means XRP is settling more real value per day.
Examples:
Cross-border payments
Tokenized assets
Treasury settlement
Interbank liquidity rails
2. Higher Store-of-Value Demand (SoV)
Inputs:
SoV0
SoV CAGR %
This reflects long-term holding demand.
This is the most powerful driver of long-term price.
It models:
Institutional holdings
Strategic reserves
Collateral usage
Long-term investor behavior
3. Lower Velocity
Input:
Velocity V
Lower velocity means XRP must be held longer to support the same transaction volume.
This implies:
Reserve-like behavior
Collateralization
Treasury holding
Structural stickiness
Price is inversely proportional to velocity.
4. Lower Effective Supply
Inputs:
Supply0
Supply CAGR
Supply cap
If XRP becomes locked, escrowed, staked, or structurally held, the effective circulating supply shrinks, increasing price.
Why This Matters
Most crypto price models are:
Technical
Reflexive
Narrative-driven
Non-falsifiable
This one is:
Structural
Adoption-based
Testable
Falsifiable
If XRP never achieves the adoption implied by your inputs, the model will not justify high prices.
This indicator is a forward-looking valuation engine, not a trading tool.
It shows:
What XRP’s price must be for your beliefs about its future to be true.
It forces clarity.
It forces discipline.
And it converts stories into structure.
