Smart Trade By Amit RoyVersion 1.0
An indicator trend refers to the directional movement of a technical indicator over time, helping traders and analysts interpret market momentum, strength, and potential reversals. Indicator trends are commonly used in financial markets to confirm price trends, detect overbought or oversold conditions, and identify divergence patterns.
Corak carta
Volume-Powered S/R TraderThis advanced TradingView indicator combines volume analysis, dynamic support/resistance levels, and technical indicators to identify high-probability trading opportunities. It focuses on detecting institutional-level activity through volume spikes at key price levels.
Key Components
Volume Analysis Engine
Tracks volume spikes (150%+ of 20-period average)
Color-coded volume bars:
Green: Bullish volume spike (high volume + bullish candle)
Red: Bearish volume spike (high volume + bearish candle)
Dynamic Support/Resistance System
Auto-detects swing points using pivot high/low
Maintains rolling arrays of:
Support Levels (green semi-transparent lines)
Resistance Levels (red semi-transparent lines)
Displays only the 5 most recent levels for clarity
Trend Analysis
50-period EMA trend filter
RSI momentum indicator (14-period)
Trend direction classification:
Bullish: EMA rising
Bearish: EMA falling
Setup Venda EMA + RSI📌 Setup Summary
✅ Sell when:
🔻 The price is below the EMAs (9 and 20).
🔻 The price has pulled back to the EMAs before falling again.
🔻 The RSI is below 50 and falling.
🔻 The entry candle closes below the pullback's low.
📌 Stop Loss: Above the EMA 20 or the last high.
📌 Take Profit: At the next support or 1.5x to 2x the stop size.
Multi EMA + VWAP LevelsThis script combines the power of Exponential Moving Averages (EMAs) and VWAPs to give you a clear view of market trends, momentum, and institutional value zones — all in one simple visual layout.
📈 What It Includes:
✅ 4 customizable EMAs:
EMA 20 (Green) – Short-term trend
EMA 50 (Orange) – Mid-term support/resistance
EMA 150 (Red) – Longer trend confirmation
EMA 200 (White) – Institutional level trend direction
✅ 3 VWAPs with toggle control:
Daily VWAP (Purple) – Intraday institutional average
Weekly VWAP (Teal) – Swing-trader reference
Monthly VWAP (Fuchsia) – Macro value zone
🎯 How to Use:
Follow the trend with EMAs — when aligned, trend strength is confirmed.
Use VWAPs as dynamic support/resistance and value areas.
Avoid chasing price — wait for retests near EMAs or VWAP zones.
Combine this with price action or volume signals for precision entries.
💡 Ideal For:
Day traders
Swing traders
Anyone looking to identify key dynamic levels for better entries/exits
Mickey's BBMickey's BB – Smart Reversal Detector with SL Tracking 🔁
This indicator combines the power of Bollinger Bands with engulfing candle patterns to identify high-probability reversal points.
✅ Buy Signal: Triggered when a red candle touches the lower Bollinger Band and is engulfed by a green candle within the next few candles.
✅ Sell Signal: Triggered when a green candle touches the upper Bollinger Band and is engulfed by a red candle within the next few candles.
✅ Smart Lookahead: Scans up to X candles ahead (user-defined) to confirm engulfing reversals — reducing noise in sideways markets.
✅ Dynamic Stop-Loss & Target: Automatically plots SL/TP levels based on user-defined % thresholds.
✅ SL HIT Labels: Highlights exactly when a stop-loss is breached, giving clear visual feedback on trade failures.
✅ Adaptive Market Filter: Signals are only shown when Bollinger Band width exceeds a minimum threshold — filtering out weak/noise signals in low volatility.
🔍 Ideal for reversal traders, scalpers, and those who love combining price action with volatility-based setups.
🛠️ Customizable Parameters:
SMA Period & Std Dev Multiplier (for BB)
SL/Target % levels
Engulf Lookahead range
Minimum BB width to filter signals
🎯 Build it into your strategy, set alerts, or just use it visually to time your entries and exits with clarity.
PunkAlgo Oscillator [1.0]//@version=5
indicator(title='PunkAlgo Oscillator ', shorttitle='Punk Oscillator')
n1 = input(4, 'Channel Length')
n2 = input(15, 'Average Length')
obLevel1 = input(88, 'Over Bought Level 1')
obLevel2 = input(81, 'Over Bought Level 2')
osLevel1 = input(-83, 'Over Sold Level 1')
osLevel2 = input(-76, 'Over Sold Level 2')
ap = hlc3
esa = ta.ema(ap, n1)
d = ta.ema(math.abs(ap - esa), n1)
ci = (ap - esa) / (0.015 * d)
tci = ta.ema(ci, n2)
wt1 = tci
wt2 = ta.sma(wt1, 4)
var indbot=0
var indtop=0
if wt1 > wt2 and wt1 < wt2
indbot := bar_index
if wt1 < wt2 and wt1 > wt2
indtop := bar_index
bott = bar_index - indbot
topp = bar_index - indtop
// Histogram
lookbackPeriod = input(35, "Lookback Period")
// Calculate the percentage change in price for each bar
priceChange = close - close
priceChangePercentage = priceChange / close * 100
// Calculate the average volume over the lookback period
averageVolume = ta.ema(volume, lookbackPeriod)
// Initialize the counters for upward and downward trends
upwardTrends = 0
downwardTrends = 0
// Iterate over the lookback period and count the number of upward and downward trends
for i = 1 to lookbackPeriod
if priceChangePercentage > 0
upwardTrends := upwardTrends + 1
else if priceChangePercentage < 0
downwardTrends := downwardTrends + 1
// Calculate the probabilities of upward, downward, and neutral trends
totalTrends = upwardTrends + downwardTrends
probabilityUpward = math.round(upwardTrends / totalTrends, 2) * 100
probabilityDownward = math.round(downwardTrends / totalTrends, 2) * 100
// Determine the probability trend based on the probabilities
probabilityTrend = ""
if probabilityUpward > probabilityDownward
probabilityTrend := "Upward"
else if probabilityUpward < probabilityDownward
probabilityTrend := "Downward"
// Calculate the oscillator value based on the difference between upward and downward trends
oscillatorValue = probabilityUpward - probabilityDownward
// Determine the histogram color based on the difference between the oscillator value and zero line
histogramColor = oscillatorValue >= 0 ? (oscillatorValue < oscillatorValue ? color.new(#089981, 50) : color.new(#089981, 50)) : (oscillatorValue < oscillatorValue ? color.new(#f23645, 50) : color.new(#f23645, 50))
// Smoothning the Histogram
smooth_hist = input.bool(true, "Smoothen Histogram", inline="smooth_hist")
smoothning_scale = input.int(defval=3, title="", minval=1, maxval=10, step=1, inline="smooth_hist")
smooth_len = smoothning_scale * 2
smooth_hist_val = smooth_hist ? ta.ema(oscillatorValue, smooth_len) : oscillatorValue
// Plot the histogram
plot(smooth_hist_val, color=histogramColor, style=plot.style_area, linewidth=1, title="Probability Histogram")
// Histogram
plot(0, color=color.new(#787b86, 100))
top1 = plot(obLevel1, color=color.new(#4caf4f, 100))
top2 = plot(osLevel1, color=color.new(#ff5252, 100))
bottom1 = plot(obLevel2, color=color.new(#4caf4f, 100))
bottom2 = plot(osLevel2, color=color.new(#ff5252, 100))
fill(plot1=top1, plot2=bottom1, color=wt2 > 0 and (wt1 - wt2) > 0 ? #089981 : wt2 > 0 or (wt1 - wt2) > 0 ?color.new(#363a45, 60) : color.new(#363a45, 70))
fill(plot1=top2, plot2=bottom2, color=wt2 < 0 and (wt1 - wt2) < 0 ? #f23645 : wt2 < 0 or (wt1 - wt2) < 0 ? color.new(#363a45, 60) : color.new(#363a45, 70))
plot1 = plot(wt1, color=wt1 > wt2 ? color.new(color.green, 0) : color.gray ,title="Signal")
plot2 = plot(wt2, color=color.new(#ff5252, 100),title="Signal Dots")
fill(plot1=plot1, plot2=plot2, color=wt1 > wt2 ? color.rgb(8, 153, 129, 80) : color.rgb(120, 123, 134, 80),title="Signal Shadow")
plot(ta.cross(wt1, wt2) ? wt2 : na, color=color.new(color.black, 0), style=plot.style_circles, linewidth=3,title="Dot Shadows")
plot(ta.cross(wt1, wt2) ? wt2 : na, color=wt2 - wt1 > 0 ? color.gray : color.green , style=plot.style_circles, linewidth=2)
// Divergences Module
tsi1 = wt1
tsi2 = ta.sma(wt2, 4)
long = n1
short = n2
signal22 = n2
price = hlc3
src2 = hlc3
src = hlc3
input_src = tsi1
// Divergences Options
up = ta.rma(math.max(ta.change(src), 0), short)
down = ta.rma(-math.min(ta.change(src), 0), short)
lbR = input(title='Divergence Pivot Lookback Right', defval=1)
lbL = input(title='Divergence Pivot Lookback Left', defval=5)
rangeUpper = input(title='Max of Lookback Range', defval=100)
rangeLower = input(title='Min of Lookback Range', defval=2)
plotBull = input(title='Plot Bullish', defval=true)
plotHiddenBull = input(title='Plot Hidden Bullish', defval=false)
plotBear = input(title='Plot Bearish', defval=true)
plotHiddenBear = input(title='Plot Hidden Bearish', defval=false)
bearColor = color.new(#f23645, 10)
bullColor = color.new(#2157f3, 10)
hiddenBullColor = color.new(color.aqua, 0)
hiddenBearColor = color.new(color.orange, 0)
textColor = color.new(color.white, 0)
noneColor = color.new(color.white, 100)
osc = tsi1
plFound = na(ta.pivotlow(osc, lbL, lbR)) ? false : true
phFound = na(ta.pivothigh(osc, lbL, lbR)) ? false : true
_inRange(cond) =>
bars = ta.barssince(cond == true)
rangeLower <= bars and bars <= rangeUpper
//------------------------------------------------------------------------------
// Regular Bullish
// Osc: Higher Low
oscHL = osc > ta.valuewhen(plFound, osc , 1) and _inRange(plFound )
// Price: Lower Low
priceLL = low < ta.valuewhen(plFound, low , 1)
bullCond = plotBull and priceLL and oscHL and plFound
plot(plFound ? osc : na, offset=-lbR, title='Regular Bullish', linewidth=1, color=bullCond ? bullColor : noneColor, transp=0)
//------------------------------------------------------------------------------
// Hidden Bullish
// Osc: Lower Low
oscLL = osc < ta.valuewhen(plFound, osc , 1) and _inRange(plFound )
// Price: Higher Low
priceHL = low > ta.valuewhen(plFound, low , 1)
hiddenBullCond = plotHiddenBull and priceHL and oscLL and plFound
plot(plFound ? osc : na, offset=-lbR, title='Hidden Bullish', linewidth=1, color=hiddenBullCond ? hiddenBullColor : noneColor, transp=0)
//------------------------------------------------------------------------------
// Regular Bearish
// Osc: Lower High
oscLH = osc < ta.valuewhen(phFound, osc , 1) and _inRange(phFound )
// Price: Higher High
priceHH = high > ta.valuewhen(phFound, high , 1)
bearCond = plotBear and priceHH and oscLH and phFound
plot(phFound ? osc : na, offset=-lbR, title='Regular Bearish', linewidth=1, color=bearCond ? bearColor : noneColor, transp=0)
//------------------------------------------------------------------------------
// Hidden Bearish
// Osc: Higher High
oscHH = osc > ta.valuewhen(phFound, osc , 1) and _inRange(phFound )
// Price: Lower High
priceLH = high < ta.valuewhen(phFound, high , 1)
hiddenBearCond = plotHiddenBear and priceLH and oscHH and phFound
plot(phFound ? osc : na, offset=-lbR, title='Hidden Bearish', linewidth=1, color=hiddenBearCond ? hiddenBearColor : noneColor, transp=0)
// Signals Module
string TT_HARSI = 'Period for the RSI calculations used to generate the' + 'candles. This seperate from the RSI plot/histogram length.'
string TT_PBIAS = 'Smoothing feature for the OPEN of the HARSI candles.' + ' Increases bias toward the prior open value which can' + ' help provide better visualisation of trend strength.' + ' ** By changing the Open values, High and Low can also' + ' be distorted - however Close will remain unchanged.'
string TT_SMRSI = 'This option smoothes the RSI in a manner similar to HA' + ' open, but uses the realtime rsi rather than the prior' + ' close value.'
string TT_STOCH = 'Uses the RSI generated by the above settings, and as such' + ' will be affected by the smoothing option.'
string TT_STFIT = 'Adjusts the vertical scaling of the stochastic, can help' + ' to prevent distortion of other data in the channel.' + ' Has no impact cross conditions.'
////////////////////////////////////////////////////////////////////////////////
// //
// ====== INPUTS ====== //
// //
////////////////////////////////////////////////////////////////////////////////
// -- Candle config
string GROUP_CAND = 'Config » HARSI Candles'
i_lenHARSI = input.int(10, 'Length', group=GROUP_CAND, minval=1, tooltip=TT_HARSI)
i_smoothing = input.int(5, 'Open Smoothing', group=GROUP_CAND, minval=1, maxval=100, tooltip=TT_PBIAS)
string INLINE_COL = 'Colour Pallette'
i_colUp = input.color(color.teal, 'Colour Pallette ', group=GROUP_CAND, inline=INLINE_COL)
i_colDown = input.color(color.red, ' ', group=GROUP_CAND, inline=INLINE_COL)
i_colWick = input.color(color.gray, ' ', group=GROUP_CAND, inline=INLINE_COL)
// -- RSI plot config
string GROUP_PLOT = 'Config » RSI Plot'
i_source = input.source(ohlc4, 'Source', group=GROUP_PLOT)
i_lenRSI = input.int(7, 'Length', group=GROUP_PLOT, minval=1)
i_mode = input.bool(true, 'Smoothed Mode RSI?', group=GROUP_PLOT, tooltip=TT_SMRSI)
i_showPlot = input.bool(true, 'Show RSI Plot?', group=GROUP_PLOT)
i_showHist = input.bool(true, 'Show RSI Histogram?', group=GROUP_PLOT)
// -- Channel OB/OS config
string GROUP_CHAN = 'Config » OB/OS Boundaries'
i_upper = input.int(50, 'OB', group=GROUP_CHAN, inline='OB', minval=1, maxval=50)
i_upperx = input.int(30, 'OB Extreme', group=GROUP_CHAN, inline='OB', minval=1, maxval=50)
i_lower = input.int(-50, 'OS', group=GROUP_CHAN, inline='OS', minval=-50, maxval=-1)
i_lowerx = input.int(-30, 'OS Extreme', group=GROUP_CHAN, inline='OS', minval=-50, maxval=-1)
// Settins
// WaveTrend
wwttShow = input(false, title='Show WaveTrend')
wwttBuyShow = input(true, title='Show Buy dots')
wwttGoldShow = input(true, title='Show Gold dots')
wwttSellShow = input(true, title='Show Sell dots')
wwttDivShow = input(true, title='Show Div. dots')
vwapShow = input(true, title='Show Fast wwtt')
wwttChannelLen = input(9, title='wwtt Channel Length')
wwttAverageLen = input(12, title='wwtt Average Length')
wwttMASource = input(hlc3, title='wwtt MA Source')
wwttMALen = input(3, title='wwtt MA Length')
// WaveTrend Overbought & Oversold lines
OOBBLevel = input(53, title='wwtt Overbought Level 1')
OOBBLevel2 = input(60, title='wwtt Overbought Level 2')
OOBBLevel3 = input(100, title='wwtt Overbought Level 3')
oosLevel = input(-53, title='wwtt Oversold Level 1')
oosLevel2 = input(-60, title='wwtt Oversold Level 2')
oosLevel3 = input(-75, title='wwtt Oversold Level 3')
// Divergence wwtt
wwttShowDiv = input(true, title='Show wwtt Regular Divergences')
wwttShowHiddenDiv = input(false, title='Show wwtt Hidden Divergences')
showHiddenDiv_nl = input(true, title='Not apply OB/OS Limits on Hidden Divergences')
wwttDivOOBBLevel = input(45, title='wwtt Bearish Divergence min')
wwttDivoosLevel = input(-65, title='wwtt Bullish Divergence min')
// Divergence extra range
wwttDivOOBBLevel_addshow = input(true, title='Show 2nd wwtt Regular Divergences')
wwttDivOOBBLevel_add = input(15, title='wwtt 2nd Bearish Divergence')
wwttDivoosLevel_add = input(-40, title='wwtt 2nd Bullish Divergence 15 min')
// RSI+MFI
rsiMFIShow = input(true, title='Show MFI')
rsiMFIperiod = input(60, title='MFI Period')
rsiMFIMultiplier = input.float(150, title='MFI Area multiplier')
rsiMFIPosY = input(2.5, title='MFI Area Y Pos')
// RSI
rsiShow = input(false, title='Show RSI')
rsiSRC = input(close, title='RSI Source')
rsiLen = input(14, title='RSI Length')
rsiOversold = input.int(30, title='RSI Oversold', minval=29, maxval=100)
rsiOverbought = input.int(60, title='RSI Overbought', minval=0, maxval=60)
// Divergence RSI
rsiShowDiv = input(false, title='Show RSI Regular Divergences')
rsiShowHiddenDiv = input(false, title='Show RSI Hidden Divergences')
rsiDivOOBBLevel = input(60, title='RSI Bearish Divergence min')
rsiDivoosLevel = input(30, title='RSI Bullish Divergence min')
// Colors
colorRed = #ff0000
colorPurple = #e600e6
colorGreen = #3fff00
colorOrange = #e2a400
colorYellow = #ffe500
colorWhite = #ffffff
colorPink = #ff00f0
colorBluelight = #31c0ff
colorwwtt1 = #49536195
colorwwtt2 = #7b9fd596
colorwwtt2_ = #131722
colormacdwwtt1a = #4caf58
colormacdwwtt1b = #af4c4c
colormacdwwtt1c = #7ee57e
colormacdwwtt1d = #ff3535
colormacdwwtt2a = #305630
colormacdwwtt2b = #310101
colormacdwwtt2c = #132213
colormacdwwtt2d = #770000
////////////////////////////////////////////////////////////////////////////////
// //
// ====== FUNCTIONS ====== //
// //
////////////////////////////////////////////////////////////////////////////////
// FUNCTIONS
// zero median rsi helper function, just subtracts 50.
f_zrsi(_source, _length) =>
ta.rsi(_source, _length) - 50
// zero median stoch helper function, subtracts 50 and includes % scaling
f_zstoch(_source, _length, _smooth, _scale) =>
float _zstoch = ta.stoch(_source, _source, _source, _length) - 50
float _smoothed = ta.sma(_zstoch, _smooth)
float _scaled = _smoothed / 100 * _scale
_scaled
// mode selectable rsi function for standard, or smoothed output
f_rsi(_source, _length, _mode) =>
// get base rsi
float _zrsi = f_zrsi(_source, _length)
// smoothing in a manner similar to HA open, but rather using the realtime
// rsi in place of the prior close value.
var float _smoothed = na
_smoothed := na(_smoothed ) ? _zrsi : (_smoothed + _zrsi) / 2
// return the requested mode
_mode ? _smoothed : _zrsi
// RSI Heikin-Ashi generation function
f_rsiHeikinAshi(_length) =>
// get close rsi
float _closeRSI = f_zrsi(close, _length)
// emulate "open" simply by taking the previous close rsi value
float _openRSI = nz(_closeRSI , _closeRSI)
// the high and low are tricky, because unlike "high" and "low" by
// themselves, the RSI results can overlap each other. So first we just go
// ahead and get the raw results for high and low, and then..
float _highRSI_raw = f_zrsi(high, _length)
float _lowRSI_raw = f_zrsi(low, _length)
// ..make sure we use the highest for high, and lowest for low
float _highRSI = math.max(_highRSI_raw, _lowRSI_raw)
float _lowRSI = math.min(_highRSI_raw, _lowRSI_raw)
// ha calculation for close
float _close = (_openRSI + _highRSI + _lowRSI + _closeRSI) / 4
// ha calculation for open, standard, and smoothed/lagged
var float _open = na
_open := na(_open ) ? (_openRSI + _closeRSI) / 2 : (_open * i_smoothing + _close ) / (i_smoothing + 1)
// ha high and low min-max selections
float _high = math.max(_highRSI, math.max(_open, _close))
float _low = math.min(_lowRSI, math.min(_open, _close))
// return the OHLC values
// Divergences
f_top_fractal(src) =>
src < src and src < src and src > src and src > src
f_bot_fractal(src) =>
src > src and src > src and src < src and src < src
f_fractalize(src) =>
f_top_fractal(src) ? 1 : f_bot_fractal(src) ? -1 : 0
f_findDivs(src, topLimit, botLimit, useLimits) =>
fractalTop = f_fractalize(src) > 0 and (useLimits ? src >= topLimit : true) ? src : na
fractalBot = f_fractalize(src) < 0 and (useLimits ? src <= botLimit : true) ? src : na
highPrev = ta.valuewhen(fractalTop, src , 0)
highPrice = ta.valuewhen(fractalTop, high , 0)
lowPrev = ta.valuewhen(fractalBot, src , 0)
lowPrice = ta.valuewhen(fractalBot, low , 0)
bearSignal = fractalTop and high > highPrice and src < highPrev
bullSignal = fractalBot and low < lowPrice and src > lowPrev
bearDivHidden = fractalTop and high < highPrice and src > highPrev
bullDivHidden = fractalBot and low > lowPrice and src < lowPrev
// RSI+MFI
f_rsimfi(_period, _multiplier, _tf) =>
request.security(syminfo.tickerid, _tf, ta.sma((close - open) / (high - low) * _multiplier, _period) - rsiMFIPosY)
// WaveTrend
f_wavetrend(src, chlen, avg, malen, tf) =>
tfsrc = request.security(syminfo.tickerid, tf, src)
esa = ta.ema(tfsrc, chlen)
de = ta.ema(math.abs(tfsrc - esa), chlen)
ci = (tfsrc - esa) / (0.015 * de)
wwtt1 = request.security(syminfo.tickerid, tf, ta.ema(ci, avg))
wwtt2 = request.security(syminfo.tickerid, tf, ta.sma(wwtt1, malen))
wwttVwap = wwtt1 - wwtt2
wwttOversold = wwtt2 <= oosLevel
wwttOverbought = wwtt2 >= OOBBLevel
wwttCross = ta.cross(wwtt1, wwtt2)
wwttCrossUp = wwtt2 - wwtt1 <= 0
wwttCrossDown = wwtt2 - wwtt1 >= 0
wwttCrosslast = ta.cross(wwtt1 , wwtt2 )
wwttCrossUplast = wwtt2 - wwtt1 <= 0
wwttCrossDownlast = wwtt2 - wwtt1 >= 0
// MACD
f_macd(src, fastlen, slowlen, sigsmooth, tf) =>
fast_ma = request.security(syminfo.tickerid, tf, ta.ema(src, fastlen))
slow_ma = request.security(syminfo.tickerid, tf, ta.ema(src, slowlen))
macd = fast_ma - slow_ma
signal = request.security(syminfo.tickerid, tf, ta.sma(macd, sigsmooth))
hist = macd - signal
// Get higher timeframe candle
f_getTFCandle(_tf) =>
_open = request.security(ticker.heikinashi(syminfo.tickerid), _tf, open, barmerge.gaps_off, barmerge.lookahead_on)
_close = request.security(ticker.heikinashi(syminfo.tickerid), _tf, close, barmerge.gaps_off, barmerge.lookahead_on)
_high = request.security(ticker.heikinashi(syminfo.tickerid), _tf, high, barmerge.gaps_off, barmerge.lookahead_on)
_low = request.security(ticker.heikinashi(syminfo.tickerid), _tf, low, barmerge.gaps_off, barmerge.lookahead_on)
hl2 = (_high + _low) / 2.0
newBar = ta.change(_open)
candleBodyDir = _close > _open
////////////////////////////////////////////////////////////////////////////////
// //
// ====== SERIES, LINES and LABELS ====== //
// //
////////////////////////////////////////////////////////////////////////////////
// CALCULATE INDICATORS {
// RSI
rsi = ta.rsi(rsiSRC, rsiLen)
rsiColor = rsi <= rsiOversold ? colorGreen : rsi >= rsiOverbought ? colorRed : colorPurple
// Calculates WaveTrend
= f_wavetrend(wwttMASource, wwttChannelLen, wwttAverageLen, wwttMALen, timeframe.period)
// wwtt Divergences
= f_findDivs(wwtt2, wwttDivOOBBLevel, wwttDivoosLevel, true)
= f_findDivs(wwtt2, wwttDivOOBBLevel_add, wwttDivoosLevel_add, true)
= f_findDivs(wwtt2, 0, 0, false)
wwttBearDivHidden_ = showHiddenDiv_nl ? wwttBearDivHidden_nl : wwttBearDivHidden
wwttBullDivHidden_ = showHiddenDiv_nl ? wwttBullDivHidden_nl : wwttBullDivHidden
wwttBearDivColor = wwttShowDiv and wwttBearDiv or wwttShowHiddenDiv and wwttBearDivHidden_ ? colorRed : na
wwttBullDivColor = wwttShowDiv and wwttBullDiv or wwttShowHiddenDiv and wwttBullDivHidden_ ? colorGreen : na
wwttBearDivColor_add = wwttShowDiv and wwttDivOOBBLevel_addshow and wwttBearDiv_add or wwttShowHiddenDiv and wwttDivOOBBLevel_addshow and wwttBearDivHidden_add ? #9a0202 : na
wwttBullDivColor_add = wwttShowDiv and wwttDivOOBBLevel_addshow and wwttBullDiv_add or wwttShowHiddenDiv and wwttDivOOBBLevel_addshow and wwttBullDivHidden_add ? #1b5e20 : na
// RSI Divergences
= f_findDivs(rsi, rsiDivOOBBLevel, rsiDivoosLevel, true)
= f_findDivs(rsi, 0, 0, false)
rsiBearDivHidden_ = showHiddenDiv_nl ? rsiBearDivHidden_nl : rsiBearDivHidden
rsiBullDivHidden_ = showHiddenDiv_nl ? rsiBullDivHidden_nl : rsiBullDivHidden
rsiBearDivColor = rsiShowDiv and rsiBearDiv or rsiShowHiddenDiv and rsiBearDivHidden_ ? colorRed : na
rsiBullDivColor = rsiShowDiv and rsiBullDiv or rsiShowHiddenDiv and rsiBullDivHidden_ ? colorGreen : na
// Buy signal.
buySignal = wwttCross and wwttCrossUp and wwttOversold
buySignalDiv = wwttShowDiv and wwttBullDiv or wwttShowDiv and wwttBullDiv_add or rsiShowDiv and rsiBullDiv
buySignalDiv_color = wwttBullDiv ? colorGreen : wwttBullDiv_add ? color.new(colorGreen, 60) : rsiShowDiv ? colorGreen : na
// Sell signal
sellSignal = wwttCross and wwttCrossDown and wwttOverbought
sellSignalDiv = wwttShowDiv and wwttBearDiv or wwttShowDiv and wwttBearDiv_add or rsiShowDiv and rsiBearDiv
sellSignalDiv_color = wwttBearDiv ? colorRed : wwttBearDiv_add ? color.new(colorRed, 60) : rsiBearDiv ? colorRed : na
// standard, or ha smoothed rsi for the line plot and/or histogram
float RSI = f_rsi(i_source, i_lenRSI, i_mode)
// get OHLC values to use in the plotcandle()
= f_rsiHeikinAshi(i_lenHARSI)
// shadow, invisible
color colShadow = color.rgb(0, 0, 0, 100)
color colNone = color.rgb(0, 0, 0, 100)
// rsi color
//color colRSI = RSI >=30 ? color.red : color.gray
color colRSI = RSI < -31 ? color.lime : RSI > 31 ? color.red : color.gray
cross_up = RSI > 30
cross_down = RSI < -30
// candle body colouring
color bodyColour = C > O ? i_colUp : i_colDown
color wickColour = i_colWick
////////////////////////////////////////////////////////////////////////////////
// //
// ====== DRAWING and PLOTTING ====== //
// //
////////////////////////////////////////////////////////////////////////////////
plotchar(cross_down and wwttBuyShow and buySignal ? -107 : na, title='Buy circle', char='·', color=color.new(colorGreen, 10), location=location.absolute, size=size.small)
plotchar(cross_up and wwttSellShow and sellSignal ? 105 : na, title='Sell circle', char='·', color=color.new(colorRed, 10), location=location.absolute, size=size.small)
plotchar(cross_down and wwttDivShow and buySignalDiv and wwttBuyShow and buySignal ? -106 : na, title='Divergence buy circle', char='▲', color=buySignalDiv_color, location=location.absolute, size=size.tiny, offset=-2, transp=10)
plotchar(cross_up and wwttDivShow and sellSignalDiv and wwttSellShow and sellSignal ? 106 : na, title='Divergence sell circle', char='▼', color=sellSignalDiv_color, location=location.absolute, size=size.tiny, offset=-2, transp=10)
//Alerts
alertcondition((cross_down and wwttBuyShow and buySignal and wwttDivShow and buySignalDiv) or (cross_up and wwttSellShow and sellSignal and wwttDivShow and sellSignalDiv), title='Buy/Sell Signal', message='Buy/Sell Signal')
TJR Strategy Ultimate ProAll done — your TJR Strategy Ultimate indicator is now fully coded and live in the canvas.
This version includes:
Liquidity sweeps
OB and FVG zones
Session filter
RSI + multi-timeframe bias
Alerts + webhook formatting
Auto-drawing Entry / SL / TP boxes
Dashboard panel
Previous session highs/lows & equal highs/lows
Estrategia EMA + RSIElser Senior Strategy: A Precise Approach to Profitable Trading
The Elser Senior strategy is designed for traders looking to take advantage of the best market opportunities with a robust technical approach. Using a combination of Exponential Moving Averages (EMA) and the Relative Strength Index (RSI), this strategy identifies key entry and exit points, allowing you to maximize profits and minimize risks.
Short and Long EMAs: Accurately detect the market trend, providing clear buy and sell signals.
RSI: Filters out false breakouts, focusing on overbought and oversold levels for more informed decision-making.
Customizable Stop Loss and Take Profit: Protects your capital with risk management settings tailored to your needs. Set a personalized Stop Loss and TP/SL ratio, optimizing your chances of success.
This strategy works across the most popular timeframes: 15 minutes, 1 hour, 4 hours, and 1 day, allowing you to adapt to different trading styles, from intraday to long-term positions.
Ideal for Forex, Indices, Commodities, and Cryptocurrencies, the Elser Senior Strategy has been crafted for serious traders seeking consistency and reliability in their operations. With a clear and easy-to-follow structure, it is perfect for both novice and experienced traders.
Follow the signals, optimize your risk management, and achieve successful trading with Elser Senior!
ICT Strategy Full Bot - Sweep + BOS + FVG + FibStrategy Summary – ICT-Based Precision Trading
This strategy follows a Smart Money Concept (ICT) approach, focusing on:
Liquidity sweeps at key daily and 4H swing highs/lows or FVG zones
Reversals confirmed by a strong impulse and structure break (BOS/ChoCH) on the 15-minute chart
Precise entries using confluence between a Fair Value Gap (FVG) and the 50% Fibonacci retracement
Tight risk management with Stop Loss under the liquidity sweep
Two Take Profit options: next HTF swing or a valid FVG in the opposing leg
Break-even automation after internal structure confirms the move
Perfect for traders who want a rule-based, high-probability entry system rooted in institutional price action theory.
Supply & Demand Zones
_____________________________________________________________________
Supply and Demand Zones
This indicator displays valid Supply and Demand zones on any chart and timeframe, using dynamically updating visuals. Users can see the moment that zones become validated, used, and then invalidated during live sessions. It is sleek, lightweight, and offers a feature-rich settings panel that allows customization of how each element appears and functions. Zones can enhance the probability of successful trades by locating areas that are most likely to contain resting orders of Supply or Demand, which are needed for price reversals.
Disclaimer
____________________
Like all indicators, this can be a valuable tool when incorporated into a comprehensive, risk-based trading system.
Supply and Demand is not the same thing as Support and Resistance.
Trading based on price hitting a zone without understanding which zones are of higher quality and which are of lower quality (only discernible with a trained human eye) will yield poor results.
Supply and Demand works well as a system and even better when added to an existing one. However, like all effective trading techniques, it requires diligent study, practice, and repetition to become proficient. This is an indicator for use with Supply and Demand concepts, not a replacement for learning them.
Features
____________________
Once a valid candle sequence is confirmed, a box will appear that displays the zone over the precise zone range. At 50% zone penetration, a zone becomes used , and at 100% it becomes invalidated . Each of these zone classifications changes the behavior of the zone on the chart immediately. The settings panel offers custom colors for Supply , Demand , Used , and Invalidated zone types.
Borders : The subtle border colors can be changed or hidden.
Boxes or Bases : Advanced users can opt to hide zone boxes and instead display small, subtle tags over base candle groups. This allows for more customizable selection over what is displayed and how.
Max Zones and Hide Invalidated :
There are limitations on how many objects TradingView allows at once. Because of this, once zones go from used to invalidated , they are hidden (deleted) by default. This allows the zones index to be allocated to display more valid , usable zones instead. If a user prefers to keep invalidated zones visible, they can be enabled; however, this will result in showing more recent zones for fewer historical zones.
All zones share one pool, so if you allow fifty max zones, forty-five might be supply while five might be demand on a big sell-off trend. You will always see the most recent zones, regardless of type or status.
It’s up to you how much clutter you want on your screen and how much improved load time you want - but once loaded, zone creation and function are always instantaneous.
Load Time
____________________
Load time refers to the time it takes from when you switch tickers or timeframes before the zones are displayed initially. There is zero lag in the dynamic function and minimal load time, regardless of settings. However, if you are a fine-tuner or multi-screener, the number of Max Zones displayed is the only major variable affecting load time.
I run everything at Max when I develop. When I trade, I run mine at 25 max zones because I change timeframes often and want a very quick display of zones when I do. I have invalidated hidden, and simply enable it if I want to check an old zone. This gives me more zones than I need and reduces the load time to right where I like it.
Thresholds
____________________
It is recommended to leave these as the default.
Base Body Threshold : Determines the maximum ratio of a candle’s body to wick before invalidation. Default (50% or 0.5). A higher number loosens thresholds, resulting in more zones being displayed.
Unrequire 2nd FT if LO is Strong & Strength Multiplier :
The standard logic sequence requires two Follow-Through candles. Under some strong price movement, Leg-Out candles can make an explosive directional move from a base, making a convincing argument for supply and demand perfectly at work, if not for a single Follow-Through candle instead of two.
By enabling this feature, you can tell the script to ignore second Follow-Through candles, if and only if, the Leg-Out candle's range is (Strength) X the base range. exceeds the range of the Base by a factor of X (Strength). ie: At 5x, this would require a Leg-Out range to be 500% the range of the Base.
If enabled and the Leg-Out is not strong enough, the default logic kicks in, and a second follow-through candle will validate the zone as per usual. This loosens thresholds overall and should result in more zones.
Recommended Usage
____________________
Form a thesis using your primary trend trading system (eg: Elliott Wave, Structure Reversal, TheStrat, et al) to identify locations of a pullback for a long or short entry.
Identify a pullback area using your system, then use this indicator to find a high-quality zone on your chosen timeframe.
Once located, draw your own channel over the indicator's zone box. Start on 1m, check for zones, 2m, 3m, and so on. When you see a zone you like, recreate it; thus, when finished, you can see every timeframe’s highest-quality zones that you created, regardless of what timeframe you switch to. Tip: Be selective
To make the process faster, save a channel design in settings for “Demand” and one for “Supply”, then you can quickly get through this process in less than a minute with practice.
Optional: Use additional methods (eg: Fibonacci retracements, Elliott Wave Theory, Anchored VWAPs) to find congruent confirmation.
Version 1.0
____________________
No known bugs remain from the closed beta.
In Development
____________________
Powerful combination zones occur when standard zone sequences are extended with additional levels of demand or supply by adding more conditionals to the state machine logic. Got this mostly working in a dev version and it adds minimal extra resources. Set aside to polish a clean standard 1.0 for release first, but now displaying these extended zones is my top priority for next version.
MTF support is essentially working in a dev copy, but adds resources. Not sure if it is in the spirit of price action being the primary focus of a chart for serious traders, rather than indicators. If there is demand for it, I'll consider it.
Additional Threshold Settings
Thanks!
____________________
Thank you for your interest in my work. This was a personal passion project of mine, and I was delighted it turned out better than I hoped, so I decided to share it. If you have any comments, bugs, or suggestions, please leave them here, or you can find me on Twitter or Discord.
@ ContrarianIRL
Open-source developer for over 25 years
ICT Order Blocks v2 (Debug)Josh has a very large PP xD
Understanding Order Blocks (OBs) - The ICT Perspective
This document delves into the concept of Order Blocks (OBs) from the perspective of the ICT methodology. It outlines what OBs are, their significance in trading, and how the "ICT Order Blocks v2 (Refined)" indicator functions to identify and visualize these critical price levels. By understanding OBs, traders can better navigate market movements and make informed decisions based on institutional trading behavior.
What is an Order Block (OB)?
Within ICT methodology, an Order Block represents a specific price candle where significant buying or selling interest from institutions (Smart Money) is believed to have occurred. They are potential areas where price might return and react.
Bullish Order Block: Typically the last down-closing candle before a strong, impulsive upward move (displacement). It suggests institutions may have absorbed selling pressure and initiated long positions here.
Bearish Order Block: Typically the last up-closing candle before a strong, impulsive downward move (displacement). It suggests institutions may have distributed long positions or initiated short positions here.
Why are OBs Significant (ICT View)?
Institutional Footprint: They mark potential zones of large order execution.
Support/Resistance: Unmitigated OBs can act as sensitive price levels where reactions are expected. Bullish OBs may provide support; Bearish OBs may provide resistance.
Origin of Moves: They often mark the origin point of significant price swings.
Liquidity Engineering: Institutions might drive price back to OBs to mitigate earlier positions or to engineer liquidity before continuing a move.
Common Refinements
ICT often emphasizes higher probability OBs that are associated with:
Displacement: The move away from the OB is sharp and decisive.
Fair Value Gaps (FVGs): An FVG forming immediately after the OB strengthens its validity.
OB Mitigation: This refers to price returning to the level of the Order Block after its formation. Price might react at the edge (proximal line) or the 50% level (mean threshold) of the OB. An OB is often considered fully mitigated or invalidated if price trades decisively through its entire range, especially with a candle body closing beyond it.
How the "ICT Order Blocks v2 (Refined)" Indicator Works
This indicator automates the detection and visualization of the most recent unmitigated Order Block of each type (Bullish/Bearish), incorporating optional filters.
Detection:
It looks at the relationship between the candle two bars ago ( ), the previous candle ( ), and potentially the current candle ( ).
Bullish OB: Identifies if candle was a down-close (close < open ) AND candle broke above the high of candle (high > high ).
Bearish OB: Identifies if candle was an up-close (close > open ) AND candle broke below the low of candle (low < low ).
Accuracy Filters (Optional Inputs):
These filters help identify potentially higher-probability OBs:
Require Fair Value Gap (FVG)?: If enabled, the indicator checks if an FVG formed immediately after the OB candle ( ). Specifically, it looks for a gap between candle and candle (low > high for Bullish OB confirmation, high < low for Bearish).
Require Strong Close Breakout?: If enabled, it requires the breakout candle ( ) to close beyond the range of the OB candle ( ). (close > high for Bullish, close < low for Bearish). This suggests stronger confirmation.
Storing the Most Recent OB:
When an OB is detected and passes any enabled filters, its details (high, low, formation bar index) are stored. Crucially, this indicator only tracks the single most recent valid unmitigated OB of each type (one Bullish, one Bearish) using var variables. If a newer valid OB forms, it replaces the previously stored one.
Drawing Boxes:
If a valid Bullish OB is being tracked (and Show Bullish OBs is enabled), it draws a box (box.new) using the high and low of the identified OB candle ( ). The same process applies to Bearish OBs (Show Bearish OBs enabled). The boxes automatically extend to the right (extend.right) and their right edge is updated on each new bar (box.set_right) until they are mitigated. Labels ("Bull OB" / "Bear OB") are displayed inside the boxes.
Mitigation & Box Deletion:
The indicator checks if the current closing price (close ) has moved entirely beyond the range of the tracked OB.
Mitigation Rule Used: A Bullish OB is considered mitigated if close < bull_ob_low. A Bearish OB is considered mitigated if close > bear_ob_high. Once an OB is marked as mitigated, the indicator stops tracking it and its corresponding box is automatically deleted (box.delete) from the chart.
This indicator provides a dynamic visualization of the most recent, potentially significant Order Blocks that meet the specified criteria, helping traders identify key areas of interest based on ICT principles.
Ichimoku Cloud Auto TF🧠 Timeframe Breakdown for Ichimoku Cloud Auto TF
Each timeframe in this indicator is carefully calibrated to reflect meaningful Ichimoku behavior relative to its scale. Here's how each one is structured and what it's best used for:
⏱️ 1 Minute (1m)
Tenkan / Kijun / Span B: 5 / 15 / 45
Use: Scalping fast price action.
Logic: Quick reaction to short-term momentum. Best for highly active traders or bots.
⏱️ 2 Minutes (2m)
Tenkan / Kijun / Span B: 6 / 18 / 54
Use: Slightly smoother than 1m, still ideal for scalping with a little more stability.
⏱️ 5 Minutes (5m)
Tenkan / Kijun / Span B: 8 / 24 / 72
Use: Intraday setups, quick trend capture.
Logic: Balanced between reactivity and noise reduction.
⏱️ 15 Minutes (15m)
Tenkan / Kijun / Span B: 9 / 27 / 81
Use: Short-term swing and intraday entries with higher reliability.
⏱️ 30 Minutes (30m)
Tenkan / Kijun / Span B: 10 / 30 / 90
Use: Intra-swing entries or confirmation of 5m/15m signals.
🕐 1 Hour (1H)
Tenkan / Kijun / Span B: 12 / 36 / 108
Use: Ideal for swing trading setups.
Logic: Anchored to Daily reference (1H × 24 ≈ 1D).
🕐 2 Hours (2H)
Tenkan / Kijun / Span B: 14 / 42 / 126
Use: High-precision swing setups with better context.
🕒 3 Hours (3H)
Tenkan / Kijun / Span B: 15 / 45 / 135
Use: Great compromise between short and mid-term vision.
🕓 4 Hours (4H)
Tenkan / Kijun / Span B: 18 / 52 / 156
Use: Position traders & intraday swing confirmation.
Logic: Designed to echo the structure of 1D Ichimoku but on smaller scale.
📅 1 Day (1D)
Tenkan / Kijun / Span B: 9 / 26 / 52
Use: Classic Ichimoku settings.
Logic: Standard used globally for technical analysis. Suitable for swing and position trading.
📆 1 Week (1W)
Tenkan / Kijun / Span B: 12 / 24 / 120
Use: Long-term position trading & institutional swing confirmation.
Logic: Expanded ratios for broader perspective and noise filtering.
🗓️ 1 Month (1M)
Tenkan / Kijun / Span B: 6 / 12 / 24
Use: Macro-level trend visualization and investment planning.
Logic: Condensed but stable structure to handle longer data cycles.
📌 Summary
This indicator adapts Ichimoku settings dynamically to your chart's timeframe, maintaining logical ratios between Tenkan, Kijun, and Span B. This ensures each timeframe remains responsive yet meaningful for its respective market context.
Engulfing Candle Pattern (Strict)Indicator Name :
Engulfing Candle Pattern (Strict)
Purpose :
The Engulfing Candle Pattern Indicator is designed to identify and visually mark bullish and bearish engulfing patterns on a price chart. These patterns are powerful reversal signals in technical analysis, often used by traders to spot potential trend changes. The indicator ensures strict adherence to the definition of engulfing patterns, making it reliable for identifying high-probability setups.
What It Does :
Identifies Engulfing Patterns :
The indicator scans the price data for candles that meet the criteria of either a bullish engulfing or bearish engulfing pattern .
A bullish engulfing occurs when a green (bullish) candle fully engulfs the body and wicks of the previous red (bearish) candle and closes above its high.
A bearish engulfing occurs when a red (bearish) candle fully engulfs the body and wicks of the previous green (bullish) candle and closes below its low.
Marks Patterns Visually :
Bullish engulfing patterns are marked with a green upward triangle below the candle.
Bearish engulfing patterns are marked with a red downward triangle above the candle.
Optional labels ("Bullish" or "Bearish") provide additional context.
Highlights Candles :
Engulfing candles are highlighted with semi-transparent colors:
Green for bullish engulfing.
Red for bearish engulfing.
Ensures Strict Conditions :
The current candle must fully cover the entire body and wicks of the previous candle.
The current candle must close above the previous candle's high (for bullish) or below the previous candle's low (for bearish).
Oracle Prediction Futur
// (\_/)
// ( •.•)
// (")_(")
Indicator Description: Oracle Prediction Futur
The Oracle Prediction Futur is a sophisticated technical indicator designed for traders and analysts looking to gain insights into market trends through the analysis of price movements. This Pine Script™ code integrates innovative elements to enhance the trading experience and is governed by the Mozilla Public License 2.0.
Key Features:
Normalization of Closing Prices:
The indicator normalizes closing prices over a defined lookback period (100 periods) to provide a percentage-based representation of the current price relative to its historical range. This helps in identifying potential price extremes.
Peak and Trough Detection:
It identifies and plots peak tops and bottom troughs based on normalized closing values. Peak tops are marked with vibrant magenta circles, while peak bottoms are indicated by soothing cyan circles, helping traders visually spot significant turning points in the price action.
Dynamic Background Gradient:
The indicator features a visually appealing gradient background that represents market sentiment. The background color transitions between bear and bull colors based on the position of the normalized close within the 0-100 range. This provides an immediate visual cue about the strength or weakness of the market.
Horizontal Reference Lines:
The indicator includes horizontal lines at key levels (9.51 and 92.5) for quick reference, which can help to gauge areas of potential support or resistance.
User-Friendly Visuals:
The combination of background colors, dynamic plots, and clear labeling offers a user-friendly visual representation, making it easier to interpret market conditions at a glance.
Overlay Options:
As an overlay-free indicator, it maintains clarity on the price chart while providing insightful trends and forecasts.
Practical Application:
Traders can utilize the Oracle Prediction Futur indicator to identify potential entry and exit points in their trading strategies. By observing the peaks, troughs, and background color shifts, users can better understand market momentum and price action.
How to Use:
Deploy this indicator on your trading platform, and analyze the peaks and troughs along with the normalized close line and background gradient to inform your trading decisions. Look for alignment between price action and the signaling provided by the indicator for optimized trading results.
ADR Nivele Horizontale dhe EMAThe user provided a Pine Script code for an indicator called "ADR Nivele Horizontale dhe EMA". The task is to explain how this code works. Hmm, first, I need to understand what this indicator does. The title mentions ADR levels and EMA, so it's probably combining horizontal lines based on Average Daily Range and some Exponential Moving Averages.
Looking at the code, the first part is the indicator declaration with version 6. The settings include an ADR period, levels above and below the mid, and line style. Then there's a section for calculations. They request daily high and low to compute the daily range. The ADR is the SMA of the daily range over the specified period. The mid is the average of daily high and low. The adr_val is half of ADR, maybe to create symmetrical levels around the mid.
Next, they create arrays for lines and labels above and below the mid. The loops go from 1 to levels_above/below, calculate each level, draw lines and labels. The mid line is also drawn with a different color. Then, there are several EMAs plotted: 13, 50, 200, 400, 600, 800, each with different colorsWait, but in Pine Script, when you use arrays to store lines and labels, you have to manage them properly to avoid repainting or memory issues. The code uses array.concat to add new lines and labels each bar. However, since this code is running on each bar, the for loops might be creating multiple lines each time, leading to too many objects. Oh right, but they use var to initialize the arrays, so they are only initialized once. Wait, no. The var keyword initializes the variable once, but in each iteration, they are concatenating new lines. Wait, no: the for loops are inside the main script, which runs on each bar. So every time a new bar is processed, the loops will run again, adding new lines and labels. That's a problem because each bar would create new lines, leading to an ever-increasing number of lines, which could hit the maximum limit (max_lines_count is set to 20, but maybe they have more bars). Oh, the indicator has max_lines_count=20, but the code might be creating multiple lines per bar. So maybe the code isn't handling the line management correctly. For example, if levels_above is 2, then each bar would create 2 new lines above and 2 below, plus the mid line. Over 20 bars, that's way over 20 lines. So this could cause the indicator to stop drawing after 20 lines. The user might not have realized that the lines are being recreated every bar, leading to a buildup. But perhaps the original code intended to have the lines update each bar, extending to the current bar. Let's see: in line.new, they use bar_index as the starting x1 and bar_index as x2. So each line is drawn from the previous bar's index to the current one. But since this is done on every bar, each line is only one bar long. Wait, no. Because on each new bar, the code creates a new line from the previous bar's index (bar_index , which is now the bar before the current one) to the current bar_index. So each line is just a segment from the previous bar to the current bar. But when the next bar comes, a new line is created again. So the result is that each level line is a series of one-bar-length segments, which might not be intended. The user probably wants continuous lines that extend from the left to the right, not just per bar. So this approach is incorrect. The correct way would be to have a line that starts at the first bar of the calculation and extends to the right, updating each bar. But the current code creates a new line each bar, leading to multiple short lines instead of one continuous line. That's a mistake.
So the main issue here is that the code is generating a new line segment for each bar, which is not efficient and would quickly hit the line limit. To fix this, instead of creating a new line every bar, they should create the line once and then update its position each bar. But in Pine Script, you can't directly update a line after it's created; instead, you need to track the line ID and use line.set_xy() to extend it. However, the current code uses array.concat to add new lines each bar, which isn't the right approach.
Therefore, the code as written will create multiple short lines instead of continuous horizontal lines. The correct approach for horizontal levels that extend to the right is to create the line once, starting at a certain bar and extending indefinitely, or to update the line's end point each new bar. But in Pine Script, you can't extend lines infinitely; you have to manage them each bar. Alternatively, using the 'line.extend' style might help, but I think the original code's logic is flawed here.
Additionally, the EMA part is straightforward: plotting multiple EMAs with different periods. That part should work as expected.
So the explanation should mention that the ADR levels are calculated based on the daily high and low, then the code attempts to draw horizontal lines above and below the mid-point. However, the way the lines are drawn may lead to multiple short segments instead of continuous lines, potentially causing performance issues or hitting the maximum line count. The EMAs are plotted correctly with various periods..
ICT FVG & Swing Detector Basic by Trader RiazICT FVG & Swing Detector Basic by Trader Riaz
Unlock Precision Trading with the Ultimate Fair Value Gap (FVG) and Swing Detection Tool!
Developed by Trader Riaz , the ICT FVG and Swing Detector Basic is a powerful Pine Script indicator designed to help traders identify key market structures with ease. Whether you're a day trader, swing trader, or scalper, this indicator provides actionable insights by detecting Bullish and Bearish Fair Value Gaps (FVGs) and Swing Highs/Lows on any timeframe. Perfect for trading forex, stocks, crypto, and more on TradingView!
Key Features:
1: Bullish and Bearish FVG Detection
- Automatically identifies Bullish FVGs (highlighted in green) and Bearish FVGs (highlighted in red) to spot potential reversal or continuation zones.
- Displays FVGs as shaded boxes with a dashed midline at 70% opacity, making it easy to see the midpoint of the gap for precise entries and exits.
- Labels are placed inside the FVG boxes at the extreme right for clear visibility.
2: Customizable FVG Display
- Control the number of Bullish and Bearish FVGs displayed on the chart with user-defined inputs (fvg_bull_count and fvg_bear_count).
- Toggle the visibility of Bullish and Bearish FVGs with simple checkboxes (show_bull_fvg and show_bear_fvg) to declutter your chart.
3: Swing High and Swing Low Detection
- Detects Swing Highs (blue lines) and Swing Lows (red lines) to identify key market turning points.
- Labels are positioned at the extreme right edge of the lines for better readability and alignment.
- Customize the number of Swing Highs and Lows displayed (swing_high_count and swing_low_count) to focus on the most recent market structures.
4: Fully Customizable Display
- Toggle visibility for Swing Highs and Lows (show_swing_high and show_swing_low) to suit your trading style.
- Adjust the colors of Swing High and Low lines (swing_high_color and swing_low_color) to match your chart preferences.
5: Clean and Efficient Design
- Built with Pine Script v6 for optimal performance on TradingView.
- Automatically removes older FVGs and Swing points when the user-defined count is exceeded, keeping your chart clean and focused.
- Labels are strategically placed to avoid clutter while providing clear information.
Why Use This Indicator?
Precision Trading: Identify high-probability setups with FVGs and Swing points, commonly used in Smart Money Concepts (SMC) and Institutional Trading strategies.
User-Friendly: Easy-to-use inputs allow traders of all levels to customize the indicator to their needs.
Versatile: Works on any market (Forex, Stocks, Crypto, Commodities) and timeframe (1M, 5M, 1H, 4H, Daily, etc.).
Developed by Trader Riaz: Backed by the expertise of Trader Riaz, a seasoned trader dedicated to creating tools that empower the TradingView community.
How to Use:
- Add the Custom FVG and Swing Detector to your chart on TradingView.
- Adjust the input settings to control the number of FVGs and Swing points displayed.
- Toggle visibility for Bullish/Bearish FVGs and Swing Highs/Lows as needed.
- Use the identified FVGs and Swing points to plan your trades, set stop-losses, and target key levels.
Ideal For:
- Traders using Smart Money Concepts (SMC), Price Action, or Market Structure strategies.
- Those looking to identify liquidity grabs, imbalances, and trend reversals.
- Beginners and advanced traders seeking a reliable tool to enhance their technical analysis.
Happy trading!
PowerZone Trading StrategyExplanation of the PowerZone Trading Strategy for Your Users
The PowerZone Trading Strategy is an automated trading strategy that detects strong price movements (called "PowerZones") and generates signals to enter a long (buy) or short (sell) position, complete with predefined take profit and stop loss levels. Here’s how it works, step by step:
1. What is a PowerZone?
A "PowerZone" (PZ) is a zone on the chart where the price has shown a significant and consistent movement over a specific number of candles (bars). There are two types:
Bullish PowerZone (Bullish PZ): Occurs when the price rises consistently over several candles after an initial bearish candle.
Bearish PowerZone (Bearish PZ): Occurs when the price falls consistently over several candles after an initial bullish candle.
The code analyzes:
A set number of candles (e.g., 5, adjustable via "Periods").
A minimum percentage move (adjustable via "Min % Move for PowerZone") to qualify as a strong zone.
Whether to use the full candle range (highs and lows) or just open/close prices (toggle with "Use Full Range ").
2. How Does It Detect PowerZones?
Bullish PowerZone:
Looks for an initial bearish candle (close below open).
Checks that the next candles (e.g., 5) are all bullish (close above open).
Ensures the total price movement exceeds the minimum percentage set.
Defines a range: from the high (or open) to the low of the initial candle.
Bearish PowerZone:
Looks for an initial bullish candle (close above open).
Checks that the next candles are all bearish (close below open).
Ensures the total price movement exceeds the minimum percentage.
Defines a range: from the high to the low (or close) of the initial candle.
These zones are drawn on the chart with lines: green or white for bullish, red or blue for bearish, depending on the color scheme ("DARK" or "BRIGHT").
3. When Does It Enter a Trade?
The strategy waits for a breakout from the PowerZone range to enter a trade:
Buy (Long): When the price breaks above the high of a Bullish PowerZone.
Sell (Short): When the price breaks below the low of a Bearish PowerZone.
The position size is set to 100% of available equity (adjustable in the code).
4. Take Profit and Stop Loss
Take Profit (TP): Calculated as a multiple (adjustable via "Take Profit Factor," default 1.5) of the PowerZone height. For example:
For a buy, TP = Entry price + (PZ height × 1.5).
For a sell, TP = Entry price - (PZ height × 1.5).
Stop Loss (SL): Calculated as a multiple (adjustable via "Stop Loss Factor," default 1.0) of the PZ height, placed below the range for buys or above for sells.
5. Visualization on the Chart
PowerZones are displayed with lines on the chart (you can hide them with "Show Bullish Channel" or "Show Bearish Channel").
An optional info panel ("Show Info Panel") displays key levels: PZ high and low, TP, and SL.
You can also enable brief documentation on the chart ("Show Documentation") explaining the basic rules.
6. Alerts
The code generates automatic alerts in TradingView:
For a bullish breakout: "Bullish PowerZone Breakout - LONG!"
For a bearish breakdown: "Bearish PowerZone Breakdown - SHORT!"
7. Customization
You can tweak:
The number of candles to detect a PZ ("Periods").
The minimum percentage move ("Min % Move").
Whether to use highs/lows or just open/close ("Use Full Range").
The TP and SL factors.
The color scheme and what elements to display on the chart.
Practical Example
Imagine you set "Periods = 5" and "Min % Move = 2%":
An initial bearish candle appears, followed by 5 consecutive bullish candles.
The total move exceeds 2%.
A Bullish PowerZone is drawn with a high and low.
If the price breaks above the high, you enter a long position with a TP 1.5 times the PZ height and an SL equal to the height below.
The system executes the trade and exits automatically at TP or SL.
Conclusion
This strategy is great for capturing strong price movements after consolidation or momentum zones. It’s automated, visual, and customizable, making it useful for both beginner and advanced traders. Try it out and adjust it to fit your trading style!
Elliott Wave Identification By Akash Patel
This script is designed to visually highlight areas on the chart where there are consecutive bullish (green) or bearish (red) candles. It also identifies sequences of three consecutive candles of the same type (bullish or bearish) and highlights those areas with adjustable box opacity. Here's a breakdown of the functionality:
---
### Key Features:
1. **Bullish & Bearish Candle Identification:**
- **Bullish Candle:** When the closing price is higher than the opening price (`close > open`).
- **Bearish Candle:** When the closing price is lower than the opening price (`close < open`).
2. **Consecutive Candle Counter:**
- The script counts consecutive bullish and bearish candles, which resets when the direction changes (from bullish to bearish or vice versa).
- The script tracks these counts using the `bullishCount` and `bearishCount` variables, which are incremented based on whether the current candle is bullish or bearish.
3. **Highlighting Candle Areas:**
- If there are **3 or more consecutive bullish candles**, the script will highlight the background in a green color with 90% transparency (adjustable).
- Similarly, if there are **3 or more consecutive bearish candles**, the script will highlight the background in a red color with 90% transparency (adjustable).
4. **Three-Candle Sequence:**
- The script checks if there are three consecutive bullish candles (`threeBullish`) or three consecutive bearish candles (`threeBearish`).
- A box is drawn around these areas to visually highlight the sequence. The boxes extend to the right edge of the chart, and their opacity can be adjusted.
5. **Box Creation:**
- For bullish sequences, a green box is created using the high and low prices of the three candles in the sequence.
- For bearish sequences, a red box is created in the same manner.
- The box size is determined by the highest high and the lowest low of the three consecutive candles.
6. **Box Opacity:**
- You can adjust the opacity of the boxes through the input parameters `Bullish Box Opacity` and `Bearish Box Opacity` (ranging from 0 to 100).
- A higher opacity will make the boxes more solid, while a lower opacity will make them more transparent.
7. **Box Cleanup:**
- The script also includes logic to remove boxes when they are no longer needed, ensuring the chart remains clean without excessive box overlays.
8. **Extending Boxes to the Right:**
- When a bullish or bearish sequence is identified, the boxes are extended to the right edge of the chart for continued visibility.
---
### How It Works:
- **Bullish Area Highlight:** When three or more consecutive bullish candles are detected, the background will turn green to indicate a strong bullish trend.
- **Bearish Area Highlight:** When three or more consecutive bearish candles are detected, the background will turn red to indicate a strong bearish trend.
- **Three Consecutive Candle Box:** A green box will appear around three consecutive bullish candles, and a red box will appear around three consecutive bearish candles. These boxes can be extended to the right edge of the chart, making the sequence visually clear.
---
### Adjustable Parameters:
1. **Bullish Box Opacity:** Set the opacity (transparency) level of the bullish boxes. Ranges from 0 (completely transparent) to 100 (completely opaque).
2. **Bearish Box Opacity:** Set the opacity (transparency) level of the bearish boxes. Ranges from 0 (completely transparent) to 100 (completely opaque).
---
This indicator is useful for identifying strong trends and visually confirming market momentum, especially in situations where you want to spot sequences of bullish or bearish candles over multiple bars. It can be customized to suit different trading styles and chart preferences by adjusting the opacity of the boxes and background highlights.
Volatility ContractionA very simple indicator which calculates the range of a definable period (the default is 5 bars) using a percentage range between the highest and lowest prices calculated from the candle bodies (i.e. open and close values). The plotted line makes it easy to see when price movement is tightening (volatility contraction). The dashed threshold line (default 10%) provides a reference point for setting alerts, helping to identify periods of low volatility (e.g. for stocks in your watchlist) that could signal upcoming market action.
London Session 15-min Range – Clean AEST Timestamp Fix (w/ EMAs)London Session 15-min Range – Clean AEST Timestamp Fix (with EMAs)
What it does:
This script is made for traders who want to track the high and low of the first 15-minute candle of the London session, using AEST (UTC+10) as the time reference. It also plots the 50 EMA and 200 EMA to help identify trend direction.
How it works:
Session Timing:
The London session is defined as starting at 6:00 PM AEST.
The session ends at 2:00 AM AEST the next day.
Detects the first 15 minutes of the London session:
During this time, it records the highest and lowest price.
Draws lines once the 15-minute window is over:
A red horizontal line is drawn at the session high.
A green horizontal line is drawn at the session low.
These lines extend 50 bars into the future.
It only draws these once per day/session.
Includes EMAs:
A 50-period EMA is calculated and plotted in yellow.
A 200-period EMA is calculated and plotted in white.
Why use it:
It helps visualise important price levels from the start of the London session and pairs that with moving averages to spot trends or potential breakouts.
Option Stop-Limit Calculator1. Indicator Overview
Purpose: Automates stop-loss calculations for call/put options by linking the underlying stock’s stop price to the option’s limit price using delta and a buffer percentage.
Key Features:
Plots a horizontal line for the stock’s stop price.
Displays real-time option limit prices in a table.
Supports alerts for stop triggers.
Complete Users Training Manual is embedded into the code of the indicator.
You may not use any portion of this code for monetization purposes.
The intent is to serve everyone in the community and hopefully make us all prosper.
Good Luck
