Price Step Channel [BigBeluga]Price Step Channel is designed to provide a structured look at price trends through a dynamic step line channel, highlighting trend direction and volatility boundaries.
🔵 Key Features:
Step Line with Boundaries: The central step line adjusts with price movements, creating upper and lower boundaries based on price volatility. The channel is green during uptrends and red during downtrends, visually signaling the trend’s direction.
Fakeout Markers: "✖" markers identify potential fakeouts—moments when the price breaches the channel boundary without confirming a trend change. These markers help you spot possible mean reversion points.
Dynamic Boundary Labels: Labels at the end of the channel show the price levels of the upper and lower boundaries. In uptrends, the upper label turns green; in downtrends, the lower label turns red, providing an instant read on the trend's direction.
Customizable Display: You can toggle off the boundaries and labels for a cleaner view, focusing only on the step line and its color-coded trend signals.
🔵 When to Use:
Price Step Channel is ideal for traders looking to follow structured trends with defined volatility boundaries. The step line and color-coded channel provide clear trend insights, while the fakeout markers and customizable display options enhance flexibility in different market conditions. Whether you’re focusing on clean trend signals or detailed boundary interactions, this tool adapts to your style.
Indicators and strategies
Crystal Order Block Introducing Crystal Order Block – a powerful TradingView indicator designed to identify high-probability order blocks with precision. 🚀📈
🔹 Key Features:
✅ Detects valid institutional order blocks automatically
✅ Highlights high-probability zones for entries
✅ Helps in Smart Money trading strategies (ICT, SMC, VSA)
✅ Works on all timeframes for scalping & swing trading
✅ Enhances risk management & trade accuracy
This indicator is perfect for traders who want to trade like professionals by using refined order block concepts.
💡 Test it now and take your trading to the next level!
#CrystalOrderBlock #OrderBlockIndicator #SmartMoneyConcepts #SMC #ICT #ForexTrading #TradingView #PriceAction #Liquidity #InstitutionalTrading #OrderBlocks
Fibonacci Volume Profiles [AlgoAlpha]Unlock a deeper understanding of price action with the Fibonacci Volume Profiles indicator by AlgoAlpha! This powerful tool blends Fibonacci retracement levels with customizable volume profiles, helping traders identify high-probability areas of support, resistance, and accumulation. Designed for both continuous dynamic levels and custom time periods, this indicator is a must-have for traders seeking confluence in market structure analysis.
🔑 Key Features
📈 Dual Mode Selection : Choose between Continuous Fibonacci levels, which adapt dynamically to pivots, or a Custom Period mode, where you set your own start and end points.
📊 Integrated Volume Profile : Visualize volume distributions at key Fibonacci retracement levels, revealing areas of strong buying/selling interest.
🎨 Customizable Colors & Transparency : Adjust Fibonacci level colors, fill zones, and profile transparency for a visually clear experience.
🔍 Profile Resolution & Scaling : Control the number of price levels and width of the volume profile for detailed market insights.
🛠 Extendable Levels : Optionally extend Fibonacci levels to the right of the chart for better visualization of future price interaction.
📌 How to Use
Add the Indicator: Click on the star icon to add it to your favorites and apply it to your TradingView chart.
Analyze The Market: Observe how price interacts with Fibonacci levels alongside the volume profile to confirm support/resistance zones. Switch between custom range or continuous mode to align the tool with your trading style.
⚙️ How It Works
The indicator calculates pivot highs/lows dynamically (or uses user-defined time periods) to plot Fibonacci retracement levels. It then builds a volume profile by analyzing historical volume data, grouping it into price bins to highlight volume-heavy zones. The Point of Control (PoC) is identified as the level with the highest traded volume, acting as a key price magnet. The color-coded Fibonacci levels help traders spot retracement zones, while the volume profile confirms strength or weakness in those areas.
Trader Criptom4N//@version=5
indicator("Trader Criptom4N", "🐳Criptom4N®🐳"
, overlay = true
, max_labels_count = 500
, max_lines_count = 500
, max_boxes_count = 500
, max_bars_back = 500)
//INICIA MODULO SUPERTREND
// Get user input
//INICIA MODULO SUPERTREND
// Get user input
// Instead of inputs, define constants or variables directly
// Instead of inputs, define constants or variables directly
var float nsensitivity = 1
nbuysell = input.bool(true, 'Buy/Sell Signal', inline = "BSNM",group='BUY/SELL SIGNAL')
// SMA
sma4_strong = ta.sma(close, 8)
sma5_strong = ta.sma(close, 9)
// Signal Generation
// Signal Generation Function
supertrend(_src, factor, atrLen) =>
atr = ta.atr(atrLen)
upperBand = _src + factor * atr
lowerBand = _src - factor * atr
prevLowerBand = nz(lowerBand )
prevUpperBand = nz(upperBand )
lowerBand := lowerBand > prevLowerBand or close < prevLowerBand ? lowerBand : prevLowerBand
upperBand := upperBand < prevUpperBand or close > prevUpperBand ? upperBand : prevUpperBand
var int direction = na
var float superTrend = na
prevSuperTrend = nz(superTrend )
if na(atr )
direction := 1
else if prevSuperTrend == prevUpperBand
direction := close > upperBand ? -1 : 1
else
direction := close < lowerBand ? 1 : -1
superTrend := direction == -1 ? lowerBand : upperBand
= supertrend(close, nsensitivity*7,10)
//señales
bull = ta.crossover(close, supertrend)
bear = ta.crossunder(close, supertrend)
//FIN MODULO SUPERTREND
// Risk Management
levels2 = input.bool(true, "Show TP/SL Levels2" , group = "Risk Management" , inline = "MMDB2")
lvlLines = input.bool(true, "Show Lines ", inline="levels2", group = "Risk Management")
linesStyle = input.string("SOLID", "", , inline="levels2", group = "Risk Management")
lvlDistance = input.int(40, "Distance", 1, inline="levels2", group = "Risk Management")
lvlDecimals = input.int(4, " Decimals", 1, 8, inline="levels2", group = "Risk Management")
atrRisk = input.int(3, "Risk % ", 1, group = "Risk Management" , inline="levels3")
atrLen = input.int(14, " ATR Length", 1, group = "Risk Management" , inline="levels3")
decimals = lvlDecimals == 1 ? "#.#" : lvlDecimals == 2 ? "#.##" : lvlDecimals == 3 ? "#.###" : lvlDecimals == 4 ? "#.####" : lvlDecimals == 5 ? "#.#####" : lvlDecimals == 6 ? "#.######" : lvlDecimals == 7 ? "#.#######" : "#.########"
CirrusCloud = input(true, 'Cirrus Cloud', group='TREND FEATURES')
// Plots
windowsize = 100
offset = 0.9
sigma = 6
//plot(ta.alma(source, windowsize, offset, sigma))
windowsize2 = 310
offset2 = 0.85
sigma2 = 32
//plot(ta.alma(source, windowsize2, offset2, sigma2))
// Chart Features
smoothrng(x, t, m) =>
wper = t * 2 - 1
avrng = ta.ema(math.abs(x - x ), t)
smoothrng = ta.ema(avrng, wper) * m
smoothrng
smrng = smoothrng(close, 22, 6)
rngfilt(x, r) =>
rngfilt = x
rngfilt := x > nz(rngfilt ) ? x - r < nz(rngfilt ) ? nz(rngfilt ) : x - r : x + r > nz(rngfilt ) ? nz(rngfilt ) : x + r
rngfilt
filt = rngfilt(close, smrng)
// ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
upward = 0.0
upward := filt > filt ? nz(upward ) + 1 : filt < filt ? 0 : nz(upward )
downward = 0.0
downward := filt < filt ? nz(downward ) + 1 : filt > filt ? 0 : nz(downward )
filtcolor = upward > 0 ? color.new(#00e2ff, 50) : downward > 0 ? color.new(#fe0100, 50) : color.new(#56328f, 0)
// Trend Cloud
tclength = 600
hullma = ta.wma(2*ta.wma(close, tclength/2)-ta.wma(close, tclength), math.floor(math.sqrt(tclength)))
// Chart Features
x1 = 22
x2 = 9
x3 = 15
x4 = 5
smoothrngX1(x, t, m) =>
wper = t * 2 - 1
avrng = ta.ema(math.abs(x - x ), t)
smoothrngX1 = ta.ema(avrng, wper) * m
smoothrngX1
smrngx1x = smoothrngX1(close, x1, x2)
smrngx1x2 = smoothrngX1(close, x3, x4)
rngfiltx1x1(x, r) =>
rngfiltx1x1 = x
rngfiltx1x1 := x > nz(rngfiltx1x1 ) ? x - r < nz(rngfiltx1x1 ) ? nz(rngfiltx1x1 ) : x - r : x + r > nz(rngfiltx1x1 ) ? nz(rngfiltx1x1 ) : x + r
rngfiltx1x1
filtx1 = rngfiltx1x1(close, smrngx1x)
filtx12 = rngfiltx1x1(close, smrngx1x2)
// ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
upwardx1 = 0.0
upwardx1 := filtx1 > filtx1 ? nz(upwardx1 ) + 1 : filtx1 < filtx1 ? 0 : nz(upwardx1 )
downwardx1 = 0.0
downwardx1 := filtx1 < filtx1 ? nz(downwardx1 ) + 1 : filtx1 > filtx1 ? 0 : nz(downwardx1 )
filtx1colorx1 = color.rgb(0, 187, 212, 100)
xxx1 = plot(CirrusCloud ? filtx1 : na, color=filtx1colorx1, linewidth=1, title='Trend Tracer', editable = false)
xxx2 = plot(CirrusCloud ? filtx12 : na, color=filtx1colorx1, linewidth=1, title='Trend Tracer', editable = false)
fill(xxx1, xxx2, color= filtx1 > filtx12 ? color.rgb(254, 0, 0, 86) : color.rgb(21, 255, 0, 86))
trigger2 = bull ? 1 : 0
countBull = ta.barssince(bull)
countBear = ta.barssince(bear)
trigger = nz(countBull, bar_index) < nz(countBear, bar_index) ? 1 : 0
atrBand = ta.atr(atrLen) * atrRisk
atrStop = trigger == 1 ? low - atrBand : high + atrBand
// Colors
green = #2BBC4D, green2 = color.rgb(0, 221, 0, 27)
red = #C51D0B, red2 = #c51d0b
adxlen = 15
dilen = 15
dirmov(len) =>
up = ta.change(high)
down = -ta.change(low)
plusDM = na(up) ? na : up > down and up > 0 ? up : 0
minusDM = na(down) ? na : down > up and down > 0 ? down : 0
truerange = ta.rma(ta.tr, len)
plus = fixnan(100 * ta.rma(plusDM, len) / truerange)
minus = fixnan(100 * ta.rma(minusDM, len) / truerange)
adx(dilen, adxlen) =>
= dirmov(dilen)
sum = plus + minus
adx = 100 * ta.rma(math.abs(plus - minus) / (sum == 0 ? 1 : sum), adxlen)
adx
sig = adx(dilen, adxlen)
// range ADX threshold
sidewaysThreshold = input.int(title='ADX Sideways Threshold (10-30)', minval=2, defval=15)
// boolean expression to see if the ADX is below tehe sideways threshold
bool isSideways = sig < sidewaysThreshold
// adding the option to color the bars when in a trading range
useBarColor = true
bColor = isSideways ? #b102fc : na
barcolor(useBarColor ? bColor : na)
barcolor(close > supertrend ? #3cff00 : #fe0100)
percentStop = input.float(1, "Stop Loss % (0 to Disable)", 0, group="BUY & SELL SIGNALS")
srcStop = close
lastTrade(src) => ta.valuewhen(bull or bear, src, 0)
entry_y = lastTrade(srcStop)
stop_y = lastTrade(atrStop)
tp1_y = (entry_y - lastTrade(atrStop)) * 1 + entry_y
tp2_y = (entry_y - lastTrade(atrStop)) * 2 + entry_y
tp3_y = (entry_y - lastTrade(atrStop)) * 3 + entry_y
labelTpSl(y, txt, color) =>
label labelTpSl = percentStop != 0 ? label.new(bar_index + 1, y, txt, xloc.bar_index, yloc.price, color, label.style_label_left, #000000, size.normal) : na
label.delete(labelTpSl )
if (levels2)
labelTpSl(entry_y, " Entry -- " + str.tostring(entry_y, decimals), color.gray)
labelTpSl(stop_y , " Stop Loss -- " + str.tostring(stop_y, decimals), #f90808)
labelTpSl(tp1_y, " TP 1 -- " + str.tostring(tp1_y, decimals), #00ff08)
labelTpSl(tp2_y, " TP 2 -- " + str.tostring(tp2_y, decimals), #00ff08)
labelTpSl(tp3_y, " TP 3 -- " + str.tostring(tp3_y, decimals), #00ff08)
style2 = linesStyle == "SOLID" ? line.style_solid : linesStyle == "DASHED" ? line.style_dashed : line.style_dotted
lineTpSl(y, color) =>
line lineTpSl = percentStop != 0 ? line.new(bar_index - (trigger ? countBull : countBear) + 4, y, bar_index + 1, y, xloc.bar_index, extend.none, color, style2) : na
line.delete(lineTpSl )
if (lvlLines)
lineTpSl(entry_y, color.green)
lineTpSl(stop_y, color.red)
lineTpSl(tp1_y, color.green)
lineTpSl(tp2_y, color.green)
lineTpSl(tp3_y, color.green)
y1 = low - (ta.atr(30) * 2), y1B = low - ta.atr(30)
y2 = high + (ta.atr(30) * 2), y2B = high + ta.atr(30)
buy = bull and nbuysell ? label.new(bar_index, y1, sma4_strong >= sma5_strong ? "🚀" : "🚀", xloc.bar_index, yloc.price, color.rgb(10, 247, 18, 60), label.style_label_up, #000000, size.normal) : na
sell = bear and nbuysell ? label.new(bar_index, y2, sma4_strong <= sma5_strong ? "🐻" : "🐻", xloc.bar_index, yloc.price, color.rgb(239, 12, 12, 66), label.style_label_down, #000000, size.normal) : na
int volSen = 3
plotchar(volSen, "volSen", "", location.top)
// Get Components
ema1 = ta.ema(ohlc4, 5*volSen)
ema2 = ta.ema(ohlc4, 9*volSen)
ema3 = ta.ema(ohlc4, 13*volSen)
ema4 = ta.ema(ohlc4, 34*volSen)
ema5 = ta.ema(ohlc4, 50*volSen)
alertcondition(bull, title='Buy Signal', message = "BUY")
alertcondition(bear, title='sell Signal', message = "BUY")
//-----------------------------------------------------------------------------{
//Constants
//-----------------------------------------------------------------------------{
color TRANSP_CSS = #ffffff00
//Tooltips
string MODE_TOOLTIP = 'Allows to display historical Structure or only the recent ones'
string STYLE_TOOLTIP = 'Indicator color theme'
string COLOR_CANDLES_TOOLTIP = 'Display additional candles with a color reflecting the current trend detected by structure'
string SHOW_INTERNAL = 'Display internal market structure'
string CONFLUENCE_FILTER = 'Filter non significant internal structure breakouts'
string SHOW_SWING = 'Display swing market Structure'
string SHOW_SWING_POINTS = 'Display swing point as labels on the chart'
string SHOW_SWHL_POINTS = 'Highlight most recent strong and weak high/low points on the chart'
string INTERNAL_OB = 'Display internal order blocks on the chart Number of internal order blocks to display on the chart'
string SWING_OB = 'Display swing order blocks on the chart Number of internal swing blocks to display on the chart'
string FILTER_OB = 'Method used to filter out volatile order blocks It is recommended to use the cumulative mean range method when a low amount of data is available'
string SHOW_EQHL = 'Display equal highs and equal lows on the chart'
string EQHL_BARS = 'Number of bars used to confirm equal highs and equal lows'
string EQHL_THRESHOLD = 'Sensitivity threshold in a range (0, 1) used for the detection of equal highs & lows Lower values will return fewer but more pertinent results'
string SHOW_FVG = 'Display fair values gaps on the chart'
string AUTO_FVG = 'Filter out non significant fair value gaps'
string FVG_TF = 'Fair value gaps timeframe'
string EXTEND_FVG = 'Determine how many bars to extend the Fair Value Gap boxes on chart'
string PED_ZONES = 'Display premium, discount, and equilibrium zones on chart'
//-----------------------------------------------------------------------------{
//Settings
//-----------------------------------------------------------------------------{
//General
//----------------------------------------{
mode = input.string('Historical'
, options =
, group = 'Smart Money Concepts'
, tooltip = MODE_TOOLTIP)
style = input.string('Colored'
, options =
, group = 'Smart Money Concepts'
, tooltip = STYLE_TOOLTIP)
show_trend = input(false, 'Color Candles'
, group = 'Smart Money Concepts'
, tooltip = COLOR_CANDLES_TOOLTIP)
//----------------------------------------}
//Internal Structure
//----------------------------------------{
show_internals = input(false, 'Show Internal Structure'
, group = 'Real Time Internal Structure'
, tooltip = SHOW_INTERNAL)
show_ibull = input.string('All', 'Bullish Structure'
, options =
, inline = 'ibull'
, group = 'Real Time Internal Structure')
swing_ibull_css = input(#089981, ''
, inline = 'ibull'
, group = 'Real Time Internal Structure')
//Bear Structure
show_ibear = input.string('All', 'Bearish Structure'
, options =
, inline = 'ibear'
, group = 'Real Time Internal Structure')
swing_ibear_css = input(#f23645, ''
, inline = 'ibear'
, group = 'Real Time Internal Structure')
ifilter_confluence = input(false, 'Confluence Filter'
, group = 'Real Time Internal Structure'
, tooltip = CONFLUENCE_FILTER)
internal_structure_size = input.string('Tiny', 'Internal Label Size'
, options =
, group = 'Real Time Internal Structure')
//----------------------------------------}
//Swing Structure
//----------------------------------------{
show_Structure = input(true, 'Show Swing Structure'
, group = 'Real Time Swing Structure'
, tooltip = SHOW_SWING)
//Bull Structure
show_bull = input.string('All', 'Bullish Structure'
, options =
, inline = 'bull'
, group = 'Real Time Swing Structure')
swing_bull_css = input(color.rgb(0, 0, 0), ''
, inline = 'bull'
, group = 'Real Time Swing Structure')
//Bear Structure
show_bear = input.string('All', 'Bearish Structure'
, options =
, inline = 'bear'
, group = 'Real Time Swing Structure')
swing_bear_css = input(#000000, ''
, inline = 'bear'
, group = 'Real Time Swing Structure')
swing_structure_size = input.string('Small', 'Swing Label Size'
, options =
, group = 'Real Time Swing Structure')
//Swings
show_swings = input(false, 'Show Swings Points'
, inline = 'swings'
, group = 'Real Time Swing Structure'
, tooltip = SHOW_SWING_POINTS)
length = input.int(50, ''
, minval = 10
, inline = 'swings'
, group = 'Real Time Swing Structure')
show_hl_swings = input(true, 'Show Strong/Weak High/Low'
, group = 'Real Time Swing Structure'
, tooltip = SHOW_SWHL_POINTS)
//----------------------------------------}
//Order Blocks
//----------------------------------------{
show_iob = input(false, 'Internal Order Blocks'
, inline = 'iob'
, group = 'Order Blocks'
, tooltip = INTERNAL_OB)
iob_showlast = input.int(5, ''
, minval = 1
, inline = 'iob'
, group = 'Order Blocks')
show_ob = input(true, 'Swing Order Blocks'
, inline = 'ob'
, group = 'Order Blocks'
, tooltip = SWING_OB)
ob_showlast = input.int(5, ''
, minval = 1
, inline = 'ob'
, group = 'Order Blocks')
ob_filter = input.string('Atr', 'Order Block Filter'
, options =
, group = 'Order Blocks'
, tooltip = FILTER_OB)
ibull_ob_css = input.color(#ffdd0033, 'Internal Bullish OB'
, group = 'Order Blocks')
ibear_ob_css = input.color(#ffdd0033, 'Internal Bearish OB'
, group = 'Order Blocks')
bull_ob_css = input.color(color.rgb(255, 255, 255, 80), 'Bullish OB'
, group = 'Order Blocks')
bear_ob_css = input.color(color.rgb(255, 255, 255, 80), 'Bearish OB'
, group = 'Order Blocks')
//----------------------------------------}
//EQH/EQL
//----------------------------------------{
show_eq = input(false, 'Equal High/Low'
, group = 'EQH/EQL'
, tooltip = SHOW_EQHL)
eq_len = input.int(3, 'Bars Confirmation'
, minval = 1
, group = 'EQH/EQL'
, tooltip = EQHL_BARS)
eq_threshold = input.float(0.1, 'Threshold'
, minval = 0
, maxval = 0.5
, step = 0.1
, group = 'EQH/EQL'
, tooltip = EQHL_THRESHOLD)
eq_size = input.string('Tiny', 'Label Size'
, options =
, group = 'EQH/EQL')
//----------------------------------------}
//Fair Value Gaps
//----------------------------------------{
show_fvg = input(true, 'Fair Value Gaps'
, group = 'Fair Value Gaps'
, tooltip = SHOW_FVG)
fvg_auto = input(true, "Auto Threshold"
, group = 'Fair Value Gaps'
, tooltip = AUTO_FVG)
fvg_tf = input.timeframe('', "Timeframe"
, group = 'Fair Value Gaps'
, tooltip = FVG_TF)
bull_fvg_css = input.color(#ddff006f, 'Bullish FVG'
, group = 'Fair Value Gaps')
bear_fvg_css = input.color(#f2ff0060, 'Bearish FVG'
, group = 'Fair Value Gaps')
fvg_extend = input.int(10, "Extend FVG"
, minval = 0
, group = 'Fair Value Gaps'
, tooltip = EXTEND_FVG)
//----------------------------------------}
//Previous day/week high/low
//----------------------------------------{
//Daily
show_pdhl = input(false, 'Daily'
, inline = 'daily'
, group = 'Highs & Lows MTF')
pdhl_style = input.string('⎯⎯⎯', ''
, options =
, inline = 'daily'
, group = 'Highs & Lows MTF')
pdhl_css = input(#2157f3, ''
, inline = 'daily'
, group = 'Highs & Lows MTF')
//Weekly
show_pwhl = input(false, 'Weekly'
, inline = 'weekly'
, group = 'Highs & Lows MTF')
pwhl_style = input.string('⎯⎯⎯', ''
, options =
, inline = 'weekly'
, group = 'Highs & Lows MTF')
pwhl_css = input(#2157f3, ''
, inline = 'weekly'
, group = 'Highs & Lows MTF')
//Monthly
show_pmhl = input(false, 'Monthly'
, inline = 'monthly'
, group = 'Highs & Lows MTF')
pmhl_style = input.string('⎯⎯⎯', ''
, options =
, inline = 'monthly'
, group = 'Highs & Lows MTF')
pmhl_css = input(#2157f3, ''
, inline = 'monthly'
, group = 'Highs & Lows MTF')
//----------------------------------------}
//Premium/Discount zones
//----------------------------------------{
show_sd = input(false, 'Premium/Discount Zones'
, group = 'Premium & Discount Zones'
, tooltip = PED_ZONES)
premium_css = input.color(#f23645, 'Premium Zone'
, group = 'Premium & Discount Zones')
eq_css = input.color(#b2b5be, 'Equilibrium Zone'
, group = 'Premium & Discount Zones')
discount_css = input.color(#089981, 'Discount Zone'
, group = 'Premium & Discount Zones')
//-----------------------------------------------------------------------------}
//Functions
//-----------------------------------------------------------------------------{
n = bar_index
atr = ta.atr(200)
cmean_range = ta.cum(high - low) / n
//HL Output function
hl() =>
//Get ohlc values function
get_ohlc()=> [close , open , high, low, high , low ]
//Display Structure function
display_Structure(x, y, txt, css, dashed, down, lbl_size)=>
structure_line = line.new(x, y, n, y
, color = css
, style = dashed ? line.style_dashed : line.style_solid)
structure_lbl = label.new(int(math.avg(x, n)), y, txt
, color = TRANSP_CSS
, textcolor = css
, style = down ? label.style_label_down : label.style_label_up
, size = lbl_size)
if mode == 'Present'
line.delete(structure_line )
label.delete(structure_lbl )
//Swings detection/measurements
swings(len)=>
var os = 0
upper = ta.highest(len)
lower = ta.lowest(len)
os := high > upper ? 0 : low < lower ? 1 : os
top = os == 0 and os != 0 ? high : 0
btm = os == 1 and os != 1 ? low : 0
//Order block coordinates function
ob_coord(use_max, loc, target_top, target_btm, target_left, target_type)=>
min = 99999999.
max = 0.
idx = 1
ob_threshold = ob_filter == 'Atr' ? atr : cmean_range
//Search for highest/lowest high within the structure interval and get range
if use_max
for i = 1 to (n - loc)-1
if (high - low ) < ob_threshold * 2
max := math.max(high , max)
min := max == high ? low : min
idx := max == high ? i : idx
else
for i = 1 to (n - loc)-1
if (high - low ) < ob_threshold * 2
min := math.min(low , min)
max := min == low ? high : max
idx := min == low ? i : idx
array.unshift(target_top, max)
array.unshift(target_btm, min)
array.unshift(target_left, time )
array.unshift(target_type, use_max ? -1 : 1)
//Set order blocks
display_ob(boxes, target_top, target_btm, target_left, target_type, show_last, swing, size)=>
for i = 0 to math.min(show_last-1, size-1)
get_box = array.get(boxes, i)
box.set_lefttop(get_box, array.get(target_left, i), array.get(target_top, i))
box.set_rightbottom(get_box, array.get(target_left, i), array.get(target_btm, i))
box.set_extend(get_box, extend.right)
color css = na
if swing
if style == 'Monochrome'
css := array.get(target_type, i) == 1 ? color.new(#b2b5be, 80) : color.new(#5d606b, 80)
border_css = array.get(target_type, i) == 1 ? #b2b5be : #5d606b
box.set_border_color(get_box, border_css)
else
css := array.get(target_type, i) == 1 ? bull_ob_css : bear_ob_css
box.set_border_color(get_box, css)
box.set_bgcolor(get_box, css)
else
if style == 'Monochrome'
css := array.get(target_type, i) == 1 ? color.new(#b2b5be, 80) : color.new(#5d606b, 80)
else
css := array.get(target_type, i) == 1 ? ibull_ob_css : ibear_ob_css
box.set_border_color(get_box, css)
box.set_bgcolor(get_box, css)
//Line Style function
get_line_style(style) =>
out = switch style
'⎯⎯⎯' => line.style_solid
'----' => line.style_dashed
'····' => line.style_dotted
//Set line/labels function for previous high/lows
phl(h, l, tf, css)=>
var line high_line = line.new(na,na,na,na
, xloc = xloc.bar_time
, color = css
, style = get_line_style(pdhl_style))
var label high_lbl = label.new(na,na
, xloc = xloc.bar_time
, text = str.format('P{0}H', tf)
, color = TRANSP_CSS
, textcolor = css
, size = size.small
, style = label.style_label_left)
var line low_line = line.new(na,na,na,na
, xloc = xloc.bar_time
, color = css
, style = get_line_style(pdhl_style))
var label low_lbl = label.new(na,na
, xloc = xloc.bar_time
, text = str.format('P{0}L', tf)
, color = TRANSP_CSS
, textcolor = css
, size = size.small
, style = label.style_label_left)
hy = ta.valuewhen(h != h , h, 1)
hx = ta.valuewhen(h == high, time, 1)
ly = ta.valuewhen(l != l , l, 1)
lx = ta.valuewhen(l == low, time, 1)
if barstate.islast
ext = time + (time - time )*20
//High
line.set_xy1(high_line, hx, hy)
line.set_xy2(high_line, ext, hy)
label.set_xy(high_lbl, ext, hy)
//Low
line.set_xy1(low_line, lx, ly)
line.set_xy2(low_line, ext, ly)
label.set_xy(low_lbl, ext, ly)
//-----------------------------------------------------------------------------}
//Global variables
//-----------------------------------------------------------------------------{
var trend = 0, var itrend = 0
var top_y = 0., var top_x = 0
var btm_y = 0., var btm_x = 0
var itop_y = 0., var itop_x = 0
var ibtm_y = 0., var ibtm_x = 0
var trail_up = high, var trail_dn = low
var trail_up_x = 0, var trail_dn_x = 0
var top_cross = true, var btm_cross = true
var itop_cross = true, var ibtm_cross = true
var txt_top = '', var txt_btm = ''
//Alerts
bull_choch_alert = false
bull_bos_alert = false
bear_choch_alert = false
bear_bos_alert = false
bull_ichoch_alert = false
bull_ibos_alert = false
bear_ichoch_alert = false
bear_ibos_alert = false
bull_iob_break = false
bear_iob_break = false
bull_ob_break = false
bear_ob_break = false
eqh_alert = false
eql_alert = false
//Structure colors
var bull_css = style == 'Monochrome' ? #b2b5be
: swing_bull_css
var bear_css = style == 'Monochrome' ? #b2b5be
: swing_bear_css
var ibull_css = style == 'Monochrome' ? #b2b5be
: swing_ibull_css
var ibear_css = style == 'Monochrome' ? #b2b5be
: swing_ibear_css
//Labels size
var internal_structure_lbl_size = internal_structure_size == 'Tiny'
? size.tiny
: internal_structure_size == 'Small'
? size.small
: size.normal
var swing_structure_lbl_size = swing_structure_size == 'Tiny'
? size.tiny
: swing_structure_size == 'Small'
? size.small
: size.normal
var eqhl_lbl_size = eq_size == 'Tiny'
? size.tiny
: eq_size == 'Small'
? size.small
: size.normal
//Swings
= swings(length)
= swings(5)
//-----------------------------------------------------------------------------}
//Pivot High
//-----------------------------------------------------------------------------{
var line extend_top = na
var label extend_top_lbl = label.new(na, na
, color = TRANSP_CSS
, textcolor = bear_css
, style = label.style_label_down
, size = size.tiny)
if top
top_cross := true
txt_top := top > top_y ? 'HH' : 'LH'
if show_swings
top_lbl = label.new(n-length, top, txt_top
, color = TRANSP_CSS
, textcolor = bear_css
, style = label.style_label_down
, size = swing_structure_lbl_size)
if mode == 'Present'
label.delete(top_lbl )
//Extend recent top to last bar
line.delete(extend_top )
extend_top := line.new(n-length, top, n, top
, color = bear_css)
top_y := top
top_x := n - length
trail_up := top
trail_up_x := n - length
if itop
itop_cross := true
itop_y := itop
itop_x := n - 5
//Trailing maximum
trail_up := math.max(high, trail_up)
trail_up_x := trail_up == high ? n : trail_up_x
//Set top extension label/line
if barstate.islast and show_hl_swings
line.set_xy1(extend_top, trail_up_x, trail_up)
line.set_xy2(extend_top, n + 20, trail_up)
label.set_x(extend_top_lbl, n + 20)
label.set_y(extend_top_lbl, trail_up)
label.set_text(extend_top_lbl, trend < 0 ? 'Strong High' : 'Weak High')
//-----------------------------------------------------------------------------}
//Pivot Low
//-----------------------------------------------------------------------------{
var line extend_btm = na
var label extend_btm_lbl = label.new(na, na
, color = TRANSP_CSS
, textcolor = bull_css
, style = label.style_label_up
, size = size.tiny)
if btm
btm_cross := true
txt_btm := btm < btm_y ? 'LL' : 'HL'
if show_swings
btm_lbl = label.new(n - length, btm, txt_btm
, color = TRANSP_CSS
, textcolor = bull_css
, style = label.style_label_up
, size = swing_structure_lbl_size)
if mode == 'Present'
label.delete(btm_lbl )
//Extend recent btm to last bar
line.delete(extend_btm )
extend_btm := line.new(n - length, btm, n, btm
, color = bull_css)
btm_y := btm
btm_x := n-length
trail_dn := btm
trail_dn_x := n-length
if ibtm
ibtm_cross := true
ibtm_y := ibtm
ibtm_x := n - 5
//Trailing minimum
trail_dn := math.min(low, trail_dn)
trail_dn_x := trail_dn == low ? n : trail_dn_x
//Set btm extension label/line
if barstate.islast and show_hl_swings
line.set_xy1(extend_btm, trail_dn_x, trail_dn)
line.set_xy2(extend_btm, n + 20, trail_dn)
label.set_x(extend_btm_lbl, n + 20)
label.set_y(extend_btm_lbl, trail_dn)
label.set_text(extend_btm_lbl, trend > 0 ? 'Strong Low' : 'Weak Low')
//-----------------------------------------------------------------------------}
//Order Blocks Arrays
//-----------------------------------------------------------------------------{
var iob_top = array.new_float(0)
var iob_btm = array.new_float(0)
var iob_left = array.new_int(0)
var iob_type = array.new_int(0)
var ob_top = array.new_float(0)
var ob_btm = array.new_float(0)
var ob_left = array.new_int(0)
var ob_type = array.new_int(0)
//-----------------------------------------------------------------------------}
//Pivot High BOS/CHoCH
//-----------------------------------------------------------------------------{
//Filtering
var bull_concordant = true
if ifilter_confluence
bull_concordant := high - math.max(close, open) > math.min(close, open - low)
//Detect internal bullish Structure
if ta.crossover(close, itop_y) and itop_cross and top_y != itop_y and bull_concordant
bool choch = na
if itrend < 0
choch := true
bull_ichoch_alert := true
else
bull_ibos_alert := true
txt = choch ? 'CHoCH' : 'BOS'
if show_internals
if show_ibull == 'All' or (show_ibull == 'BOS' and not choch) or (show_ibull == 'CHoCH' and choch)
display_Structure(itop_x, itop_y, txt, ibull_css, true, true, internal_structure_lbl_size)
itop_cross := false
itrend := 1
//Internal Order Block
if show_iob
ob_coord(false, itop_x, iob_top, iob_btm, iob_left, iob_type)
//Detect bullish Structure
if ta.crossover(close, top_y) and top_cross
bool choch = na
if trend < 0
choch := true
bull_choch_alert := true
else
bull_bos_alert := true
txt = choch ? 'CHoCH' : 'BOS'
if show_Structure
if show_bull == 'All' or (show_bull == 'BOS' and not choch) or (show_bull == 'CHoCH' and choch)
display_Structure(top_x, top_y, txt, bull_css, false, true, swing_structure_lbl_size)
//Order Block
if show_ob
ob_coord(false, top_x, ob_top, ob_btm, ob_left, ob_type)
top_cross := false
trend := 1
//-----------------------------------------------------------------------------}
//Pivot Low BOS/CHoCH
//-----------------------------------------------------------------------------{
var bear_concordant = true
if ifilter_confluence
bear_concordant := high - math.max(close, open) < math.min(close, open - low)
//Detect internal bearish Structure
if ta.crossunder(close, ibtm_y) and ibtm_cross and btm_y != ibtm_y and bear_concordant
bool choch = false
if itrend > 0
choch := true
bear_ichoch_alert := true
else
bear_ibos_alert := true
txt = choch ? 'CHoCH' : 'BOS'
if show_internals
if show_ibear == 'All' or (show_ibear == 'BOS' and not choch) or (show_ibear == 'CHoCH' and choch)
display_Structure(ibtm_x, ibtm_y, txt, ibear_css, true, false, internal_structure_lbl_size)
ibtm_cross := false
itrend := -1
//Internal Order Block
if show_iob
ob_coord(true, ibtm_x, iob_top, iob_btm, iob_left, iob_type)
//Detect bearish Structure
if ta.crossunder(close, btm_y) and btm_cross
bool choch = na
if trend > 0
choch := true
bear_choch_alert := true
else
bear_bos_alert := true
txt = choch ? 'CHoCH' : 'BOS'
if show_Structure
if show_bear == 'All' or (show_bear == 'BOS' and not choch) or (show_bear == 'CHoCH' and choch)
display_Structure(btm_x, btm_y, txt, bear_css, false, false, swing_structure_lbl_size)
//Order Block
if show_ob
ob_coord(true, btm_x, ob_top, ob_btm, ob_left, ob_type)
btm_cross := false
trend := -1
//-----------------------------------------------------------------------------}
//Order Blocks
//-----------------------------------------------------------------------------{
//Set order blocks
var iob_boxes = array.new_box(0)
var ob_boxes = array.new_box(0)
//Delete internal order blocks box coordinates if top/bottom is broken
for element in iob_type
index = array.indexof(iob_type, element)
if close < array.get(iob_btm, index) and element == 1
array.remove(iob_top, index)
array.remove(iob_btm, index)
array.remove(iob_left, index)
array.remove(iob_type, index)
bull_iob_break := true
else if close > array.get(iob_top, index) and element == -1
array.remove(iob_top, index)
array.remove(iob_btm, index)
array.remove(iob_left, index)
array.remove(iob_type, index)
bear_iob_break := true
//Delete internal order blocks box coordinates if top/bottom is broken
for element in ob_type
index = array.indexof(ob_type, element)
if close < array.get(ob_btm, index) and element == 1
array.remove(ob_top, index)
array.remove(ob_btm, index)
array.remove(ob_left, index)
array.remove(ob_type, index)
bull_ob_break := true
else if close > array.get(ob_top, index) and element == -1
array.remove(ob_top, index)
array.remove(ob_btm, index)
array.remove(ob_left, index)
array.remove(ob_type, index)
bear_ob_break := true
iob_size = array.size(iob_type)
ob_size = array.size(ob_type)
if barstate.isfirst
if show_iob
for i = 0 to iob_showlast-1
array.push(iob_boxes, box.new(na,na,na,na, xloc = xloc.bar_time))
if show_ob
for i = 0 to ob_showlast-1
array.push(ob_boxes, box.new(na,na,na,na, xloc = xloc.bar_time))
if iob_size > 0
if barstate.islast
display_ob(iob_boxes, iob_top, iob_btm, iob_left, iob_type, iob_showlast, false, iob_size)
if ob_size > 0
if barstate.islast
display_ob(ob_boxes, ob_top, ob_btm, ob_left, ob_type, ob_showlast, true, ob_size)
//-----------------------------------------------------------------------------}
//EQH/EQL
//-----------------------------------------------------------------------------{
var eq_prev_top = 0.
var eq_top_x = 0
var eq_prev_btm = 0.
var eq_btm_x = 0
if show_eq
eq_top = ta.pivothigh(eq_len, eq_len)
eq_btm = ta.pivotlow(eq_len, eq_len)
if eq_top
max = math.max(eq_top, eq_prev_top)
min = math.min(eq_top, eq_prev_top)
if max < min + atr * eq_threshold
eqh_line = line.new(eq_top_x, eq_prev_top, n-eq_len, eq_top
, color = bear_css
, style = line.style_dotted)
eqh_lbl = label.new(int(math.avg(n-eq_len, eq_top_x)), eq_top, 'EQH'
, color = #00000000
, textcolor = bear_css
, style = label.style_label_down
, size = eqhl_lbl_size)
if mode == 'Present'
line.delete(eqh_line )
label.delete(eqh_lbl )
eqh_alert := true
eq_prev_top := eq_top
eq_top_x := n-eq_len
if eq_btm
max = math.max(eq_btm, eq_prev_btm)
min = math.min(eq_btm, eq_prev_btm)
if min > max - atr * eq_threshold
eql_line = line.new(eq_btm_x, eq_prev_btm, n-eq_len, eq_btm
, color = bull_css
, style = line.style_dotted)
eql_lbl = label.new(int(math.avg(n-eq_len, eq_btm_x)), eq_btm, 'EQL'
, color = #00000000
, textcolor = bull_css
, style = label.style_label_up
, size = eqhl_lbl_size)
eql_alert := true
if mode == 'Present'
line.delete(eql_line )
label.delete(eql_lbl )
eq_prev_btm := eq_btm
eq_btm_x := n-eq_len
//-----------------------------------------------------------------------------}
//Fair Value Gaps
//-----------------------------------------------------------------------------{
var bullish_fvg_max = array.new_box(0)
var bullish_fvg_min = array.new_box(0)
var bearish_fvg_max = array.new_box(0)
var bearish_fvg_min = array.new_box(0)
float bullish_fvg_avg = na
float bearish_fvg_avg = na
bullish_fvg_cnd = false
bearish_fvg_cnd = false
=
request.security(syminfo.tickerid, fvg_tf, get_ohlc())
if show_fvg
delta_per = (src_c1 - src_o1) / src_o1 * 100
change_tf = timeframe.change(fvg_tf)
threshold = fvg_auto ? ta.cum(math.abs(change_tf ? delta_per : 0)) / n * 2
: 0
//FVG conditions
bullish_fvg_cnd := src_l > src_h2
and src_c1 > src_h2
and delta_per > threshold
and change_tf
bearish_fvg_cnd := src_h < src_l2
and src_c1 < src_l2
and -delta_per > threshold
and change_tf
//FVG Areas
if bullish_fvg_cnd
array.unshift(bullish_fvg_max, box.new(n-1, src_l, n + fvg_extend, math.avg(src_l, src_h2)
, border_color = bull_fvg_css
, bgcolor = bull_fvg_css))
array.unshift(bullish_fvg_min, box.new(n-1, math.avg(src_l, src_h2), n + fvg_extend, src_h2
, border_color = bull_fvg_css
, bgcolor = bull_fvg_css))
if bearish_fvg_cnd
array.unshift(bearish_fvg_max, box.new(n-1, src_h, n + fvg_extend, math.avg(src_h, src_l2)
, border_color = bear_fvg_css
, bgcolor = bear_fvg_css))
array.unshift(bearish_fvg_min, box.new(n-1, math.avg(src_h, src_l2), n + fvg_extend, src_l2
, border_color = bear_fvg_css
, bgcolor = bear_fvg_css))
for bx in bullish_fvg_min
if low < box.get_bottom(bx)
box.delete(bx)
box.delete(array.get(bullish_fvg_max, array.indexof(bullish_fvg_min, bx)))
for bx in bearish_fvg_max
if high > box.get_top(bx)
box.delete(bx)
box.delete(array.get(bearish_fvg_min, array.indexof(bearish_fvg_max, bx)))
//-----------------------------------------------------------------------------}
//Previous day/week high/lows
//-----------------------------------------------------------------------------{
//Daily high/low
= request.security(syminfo.tickerid, 'D', hl()
, lookahead = barmerge.lookahead_on)
//Weekly high/low
= request.security(syminfo.tickerid, 'W', hl()
, lookahead = barmerge.lookahead_on)
//Monthly high/low
= request.security(syminfo.tickerid, 'M', hl()
, lookahead = barmerge.lookahead_on)
//Display Daily
if show_pdhl
phl(pdh, pdl, 'D', pdhl_css)
//Display Weekly
if show_pwhl
phl(pwh, pwl, 'W', pwhl_css)
//Display Monthly
if show_pmhl
phl(pmh, pml, 'M', pmhl_css)
//-----------------------------------------------------------------------------}
//Premium/Discount/Equilibrium zones
//-----------------------------------------------------------------------------{
var premium = box.new(na, na, na, na
, bgcolor = color.new(premium_css, 80)
, border_color = na)
var premium_lbl = label.new(na, na
, text = 'Premium'
, color = TRANSP_CSS
, textcolor = premium_css
, style = label.style_label_down
, size = size.small)
var eq = box.new(na, na, na, na
, bgcolor = color.rgb(120, 123, 134, 80)
, border_color = na)
var eq_lbl = label.new(na, na
, text = 'Equilibrium'
, color = TRANSP_CSS
, textcolor = eq_css
, style = label.style_label_left
, size = size.small)
var discount = box.new(na, na, na, na
, bgcolor = color.new(discount_css, 80)
, border_color = na)
var discount_lbl = label.new(na, na
, text = 'Discount'
, color = TRANSP_CSS
, textcolor = discount_css
, style = label.style_label_up
, size = size.small)
//Show Premium/Discount Areas
if barstate.islast and show_sd
avg = math.avg(trail_up, trail_dn)
box.set_lefttop(premium, math.max(top_x, btm_x), trail_up)
box.set_rightbottom(premium, n, .95 * trail_up + .05 * trail_dn)
label.set_xy(premium_lbl, int(math.avg(math.max(top_x, btm_x), n)), trail_up)
box.set_lefttop(eq, math.max(top_x, btm_x), .525 * trail_up + .475*trail_dn)
box.set_rightbottom(eq, n, .525 * trail_dn + .475 * trail_up)
label.set_xy(eq_lbl, n, avg)
box.set_lefttop(discount, math.max(top_x, btm_x), .95 * trail_dn + .05 * trail_up)
box.set_rightbottom(discount, n, trail_dn)
label.set_xy(discount_lbl, int(math.avg(math.max(top_x, btm_x), n)), trail_dn)
//-----------------------------------------------------------------------------}
//Trend
//-----------------------------------------------------------------------------{
var color trend_css = na
if show_trend
if style == 'Colored'
trend_css := itrend == 1 ? bull_css : bear_css
else if style == 'Monochrome'
trend_css := itrend == 1 ? #b2b5be : #5d606b
plotcandle(open, high, low, close
, color = trend_css
, wickcolor = trend_css
, bordercolor = trend_css
, editable = false)
//-----------------------------------------------------------------------------}
//Alerts
//-----------------------------------------------------------------------------{
//Internal Structure
alertcondition(bull_ibos_alert, 'Internal Bullish BOS', 'Internal Bullish BOS formed')
alertcondition(bull_ichoch_alert, 'Internal Bullish CHoCH', 'Internal Bullish CHoCH formed')
alertcondition(bear_ibos_alert, 'Internal Bearish BOS', 'Internal Bearish BOS formed')
alertcondition(bear_ichoch_alert, 'Internal Bearish CHoCH', 'Internal Bearish CHoCH formed')
//Swing Structure
alertcondition(bull_bos_alert, 'Bullish BOS', 'Internal Bullish BOS formed')
alertcondition(bull_choch_alert, 'Bullish CHoCH', 'Internal Bullish CHoCH formed')
alertcondition(bear_bos_alert, 'Bearish BOS', 'Bearish BOS formed')
alertcondition(bear_choch_alert, 'Bearish CHoCH', 'Bearish CHoCH formed')
//order Blocks
alertcondition(bull_iob_break, 'Bullish Internal OB Breakout', 'Price broke bullish internal OB')
alertcondition(bear_iob_break, 'Bearish Internal OB Breakout', 'Price broke bearish internal OB')
alertcondition(bull_ob_break, 'Bullish Swing OB Breakout', 'Price broke bullish swing OB')
alertcondition(bear_ob_break, 'Bearish Swing OB Breakout', 'Price broke bearish swing OB')
//EQH/EQL
alertcondition(eqh_alert, 'Equal Highs', 'Equal highs detected')
alertcondition(eql_alert, 'Equal Lows', 'Equal lows detected')
//FVG
alertcondition(bullish_fvg_cnd, 'Bullish FVG', 'Bullish FVG formed')
alertcondition(bearish_fvg_cnd, 'Bearish FVG', 'Bearish FVG formed')
//-----------------------------------------------------------------------------}
MOATH EMAD 12
//@version=5
indicator("MOATH EMAD", overlay=true)
enableIndicator = input.bool(true, title="تشغيل EMA")
enableIndicator2 = input.bool(true, title="تشغيل RSI")
// حساب EMA 200
ema200 = ta.ema(close, 200)
rsi = request.security(syminfo.tickerid, "5", ta.rsi(close, 14))
// المسافة المطلوبة بين الافتتاح والـ EMA
pointDistance = 2 // عدّلها حسب السوق (مثلاً 0.2 للعملات الرقمية)
// التحقق من الشرط
isAbove = open > ema200 + pointDistance
isBelow = open < ema200 - pointDistance
// تحديد اللون بناءً على الشرط
// رسم EMA 200
plotrealclosedots = input(true, title = 'Show real close dots')
realclosecolour = input(color.new(#41ffb0, 1), title = 'Real close dot color') // بدون شفافية
real_price = syminfo.prefix + ":" + syminfo.ticker
real_close = request.security(real_price, "", close, gaps = barmerge.gaps_off, lookahead = barmerge.lookahead_off)
// رسم النقاط باستخدام plot مع تكبير النقطة
plot(series = plotrealclosedots ? real_close : na,
title = 'Real close dots',
color = realclosecolour,
linewidth = 3, // زيادة حجم النقطة
style = plot.style_circles)
// Input variables
lowhigh_long_prop = input.float(10, title="Low / High Proportion")
body_prop_size = input.float(7, title="Body Proportion Size")
waveLength = input(6, title="Minimum Wave Length") // Number of candles required to determine wave
colorUp = color.new(color.green, 100) // Bullish wave color
colorDown = color.new(color.red, 100) // Bearish wave color
dojiBoxColor = color.new(color.yellow, 90) // Doji box color
defineDojiExtension = 6 // Number of candles to extend the doji box
// Bar calculations
bar_size_h = high - close
bar_size_l = math.max(open, close) - math.min(close, open)
body_size_h = high - low
low_body_prop = close - low
high_body_prop = high - close
// حساب خصائص الشمعة
upper_tail = high - math.max(open, close) // طول الذيل العلوي
lower_tail = math.min(open, close) - low // طول الذيل السفلي
total_tails = upper_tail + lower_tail // مجموع الذيول
// نسبة كل ذيل بالنسبة إلى مجموع الذيول
upper_tail_ratio = (upper_tail / total_tails) * 100
lower_tail_ratio = (lower_tail / total_tails) * 100
// Wave Detection
isBullish = close > open
isBearish = close < open
bullishStreak = ta.barssince(not isBullish)
bearishStreak = ta.barssince(not isBearish)
isWaveUp = isBullish and bullishStreak >= waveLength - 1
isWaveDown = isBearish and bearishStreak >= waveLength - 1
// شرط شمعة التوقف (الذيل الحالي أصغر من الذيل السابق في الاتجاه الصاعد أو أكبر في الاتجاه الهابط)
previous_upper_tail = high
previous_lower_tail = low
is_stop_candle_up = isWaveUp and (high < high or high < high )// شمعة توقف في الاتجاه الصاعد
is_stop_candle_down = isWaveDown and (low > low or low > low ) // شمعة توقف في الاتجاه الهابط
// Boxes for waves
var box bullishBox = na
var box bearishBox = na
if isWaveUp
if na(bullishBox)
bullishBox := box.new(bar_index , high , bar_index, low, border_color=na, bgcolor=colorUp)
else
box.set_right(bullishBox, bar_index)
box.set_top(bullishBox, math.max(box.get_top(bullishBox), high))
box.set_bottom(bullishBox, math.min(box.get_bottom(bullishBox), low))
if not isWaveUp and not na(bullishBox)
bullishBox := na
if isWaveDown
if na(bearishBox)
bearishBox := box.new(bar_index , high , bar_index, low, border_color=na, bgcolor=colorDown)
else
box.set_right(bearishBox, bar_index)
box.set_top(bearishBox, math.max(box.get_top(bearishBox), high))
box.set_bottom(bearishBox, math.min(box.get_bottom(bearishBox), low))
if not isWaveDown and not na(bearishBox)
bearishBox := na
// Doji Box Conditions
isDoji = (upper_tail_ratio >= 40 and upper_tail_ratio <= 60) and (lower_tail_ratio >= 40 and lower_tail_ratio <= 60)
// خطوط الدوجي بناءً على الاتجاه السابق
var line dojiLineUp = na
var line dojiLineDown = na
var int dojiLineUpBarIndex = na
var int dojiLineDownBarIndex = na
var bool labelPlacedUp = false
var bool labelPlacedDown = false
var line dojiLineUp2 = na
var line dojiLineDown2 = na
var int dojiLineUpBarIndex2 = na
var int dojiLineDownBarIndex2 = na
var bool labelPlacedUp2 = false
var bool labelPlacedDown2 = false
if isDoji
if isWaveUp // إذا كان الاتجاه السابق صاعدًا
dojiLineUp := line.new(bar_index, low, bar_index + defineDojiExtension, low, color=color.white, width=1)
line.set_color(dojiLineUp,color.new(color.red,100))
dojiLineUpBarIndex := bar_index
labelPlacedUp := false // إعادة تعيين الإشارة للخط الجديد
if isWaveDown // إذا كان الاتجاه السابق هابطًا
dojiLineDown := line.new(bar_index, high, bar_index + defineDojiExtension, high, color=color.white, width=1)
line.set_color(dojiLineDown,color.new(color.red,100))
dojiLineDownBarIndex := bar_index
labelPlacedDown := false // إعادة تعيين الإشارة للخط الجديد
if isDoji
if isWaveUp // إذا كان الاتجاه السابق صاعدًا
dojiLineUp2 := line.new(bar_index, low, bar_index + defineDojiExtension, low, color=color.white, width=1)
line.set_color(dojiLineUp2,color.new(color.red,100))
dojiLineUpBarIndex2 := bar_index
labelPlacedUp2 := false // إعادة تعيين الإشارة للخط الجديد
if isWaveDown // إذا كان الاتجاه السابق هابطًا
dojiLineDown2 := line.new(bar_index, high, bar_index + defineDojiExtension, high, color=color.white, width=1)
line.set_color(dojiLineDown2,color.new(color.red,100))
dojiLineDownBarIndex2 := bar_index
labelPlacedDown2 := false // إعادة تعيين الإشارة للخط الجديد
// تحديد الشروط للتلامس مع الخطوط
touchesGreenLine = not na(dojiLineUp) and
(low <= line.get_y1(dojiLineUp) and high >= line.get_y1(dojiLineUp)) and
(open > line.get_y1(dojiLineUp) and close < line.get_y1(dojiLineUp)) and // تفتح فوق الخط وتغلق تحته
(real_close < line.get_y1(dojiLineUp)) and // إضافة شرط السعر الحقيقي تحت الخط الأخضر
(bar_index - dojiLineUpBarIndex <= 5) and // فقط خلال 5 شموع
not labelPlacedUp and // التأكد من أن الإشارة لم توضع مسبقًا
(((close < ema200 - pointDistance)and enableIndicator)or not enableIndicator) and
(((rsi >70 )and enableIndicator2)or not enableIndicator2) and not is_stop_candle_up
// الشرط الجديد: الشمعة تحت الـ EMA بمقدار نقطتين
touchesRedLine = not na(dojiLineDown) and
(low <= line.get_y1(dojiLineDown) and high >= line.get_y1(dojiLineDown)) and
(open < line.get_y1(dojiLineDown) and close > line.get_y1(dojiLineDown)) and // تفتح تحت الخط وتغلق فوقه
(real_close > line.get_y1(dojiLineDown)) and // إضافة شرط السعر الحقيقي فوق الخط الأحمر
(bar_index - dojiLineDownBarIndex <= 5) and // فقط خلال 5 شموع
not labelPlacedDown and // التأكد من أن الإشارة لم توضع مسبقًا
(((close > ema200 + pointDistance)and enableIndicator)or not enableIndicator) and
(((rsi<30 )and enableIndicator2)or not enableIndicator2) and not is_stop_candle_down // الشرط الجديد: الشمعة فوق الـ EMA بمقدار نقطتين
// تحديد الشروط للتلامس مع الخطوط
touchesGreenLine2 = not na(dojiLineUp2) and
(low <= line.get_y1(dojiLineUp2) and high >= line.get_y1(dojiLineUp2)) and
(open > line.get_y1(dojiLineUp2) and close < line.get_y1(dojiLineUp2)) and // تفتح فوق الخط وتغلق تحته
(real_close < line.get_y1(dojiLineUp2)) and // إضافة شرط السعر الحقيقي تحت الخط الأخضر
(bar_index - dojiLineUpBarIndex2 <= 5) and // فقط خلال 5 شموع
not labelPlacedUp and // التأكد من أن الإشارة لم توضع مسبقًا
(((close < ema200 - pointDistance)and enableIndicator)or not enableIndicator) and
(((rsi >70 )and enableIndicator2)or not enableIndicator2)and is_stop_candle_up
// الشرط الجديد: الشمعة تحت الـ EMA بمقدار نقطتين
touchesRedLine2 = not na(dojiLineDown2) and
(low <= line.get_y1(dojiLineDown2) and high >= line.get_y1(dojiLineDown2)) and
(open < line.get_y1(dojiLineDown2) and close > line.get_y1(dojiLineDown2)) and // تفتح تحت الخط وتغلق فوقه
(real_close > line.get_y1(dojiLineDown2)) and // إضافة شرط السعر الحقيقي فوق الخط الأحمر
(bar_index - dojiLineDownBarIndex2 <= 5) and // فقط خلال 5 شموع
not labelPlacedDown and // التأكد من أن الإشارة لم توضع مسبقًا
(((close > ema200 + pointDistance)and enableIndicator)or not enableIndicator) and
(((rsi<30 )and enableIndicator2)or not enableIndicator2) and is_stop_candle_down// الشرط الجديد: الشمعة فوق الـ EMA بمقدار نقطتين
if touchesGreenLine
label.new(bar_index, high, text="Sell", color=color.orange, textcolor=color.white, size=size.small, style=label.style_label_down)
labelPlacedUp := true
if touchesRedLine
label.new(bar_index, low, text="Buy", color=color.blue, textcolor=color.white, size=size.small, style=label.style_label_up)
labelPlacedDown := true // تم وضع الإشارة
if touchesGreenLine2
label.new(bar_index, high, text="Sell", color=color.orange, textcolor=color.white, size=size.small, style=label.style_label_down)
labelPlacedUp := true
if touchesRedLine2
label.new(bar_index, low, text="Buy", color=color.blue, textcolor=color.white, size=size.small, style=label.style_label_up)
labelPlacedDown := true // تم وضع الإشارة
alertcondition(touchesGreenLine or touchesRedLine or touchesGreenLine2 or touchesRedLine2 , title="Buy/Sell Alert", message="Signal detected: Buy or Sell")
var table statsTable = table.new(position.top_right, 1, 1, border_color=color.purple, bgcolor=color.new(color.black, 90))
table.cell(statsTable, 0, 0, "Moath Emad", text_color=color.white, bgcolor=color.black, text_size=size.auto)
Liquidations Script + buyside/sellside ratioThis enhanced version of the liquidations indicator is designed for use with Pine Script™ version 6 and provides a more detailed view of potential liquidation levels on your chart. The key features include:
Volume-Based Liquidation Calculations:
The script calculates a volume difference over a user-defined lookback period and uses the mean difference to filter out noise. It then determines whether the current volume difference exceeds specific thresholds (e.g., 5x, 10x, 25x, 50x, and 100x leverage conditions).
Pivot Point Integration:
Pivot high and low points are identified using configurable parameters. Optionally, these pivot lines can be displayed to visually aid in understanding where the price reversals occur.
Dynamic Liquidation Lines:
For each leverage group, the script draws corresponding liquidation lines above and below the price. The calculations adjust the liquidation level based on whether the signal is from a pivot high or pivot low, reflecting potential liquidation prices for both long and short positions.
Real-Time Ratio Display:
An additional feature of this version is the display of a ratio label. This label, positioned on the right side of the price (using yloc.price and label.style_label_right), shows:
The number of liquidation lines above the price (from pivot highs)
The number of liquidation lines below the price (from pivot lows)
The ratio (or proportion) of liquidation lines above to those below the price
This offers traders an at-a-glance summary of the market’s liquidation pressure.
Customizability and Flexibility:
Users can toggle the display of pivot settings and each leverage group’s liquidation lines individually. Colors and line extensions can be adjusted to fit the user’s charting preferences.
Overall, this improved script aims to deliver clearer, more actionable information regarding potential liquidation levels while keeping the code organized and fully compliant with Pine Script™ version 6.
Order Block Forex Trading 4.0Order Block Forex Trading 4.0-Order Block Forex Trading 4.0-Order Block Forex Trading 4.0-Order Block Forex Trading 4.0-Order Block Forex Trading 4.0-Order Block Forex Trading 4.0-Order Block Forex Trading 4.0-Order Block Forex Trading 4.0-Order Block Forex Trading 4.0-Order Block Forex Trading 4.0
MainFX session indicatorINDICATOR Plot line on the open and close of all session its is only visible for 1min for Horc user << if it was useful to you >> consider praying for me to find profitability in trading BY OLAMIDE SIYANBOLA AKA MainFX
RSI/MOM/MACD/Squezee/Donchian/HULL/SUPERTREND/Waddath Attar GAOOptimized Trading Strategy with RSI, MOM, MACD, Donchian, Squeeze, HULL, Supertrend & Waddah Attar
Our trading strategy combines multiple technical indicators to maximize trend identification, momentum confirmation, and trade execution precision.
📌 RSI (Relative Strength Index) – Measures overbought and oversold conditions, helping to spot potential reversals.
📌 MOM (Momentum Indicator) – Confirms price acceleration and strength, identifying possible breakouts or trend exhaustion.
📌 MACD (Moving Average Convergence Divergence) – A trend-following momentum indicator that highlights bullish or bearish crossovers.
📌 Donchian Channel – Defines support and resistance levels, signaling breakouts when price moves beyond its range.
📌 Squeeze (TTM Squeeze) – Detects periods of low volatility before explosive moves, ideal for breakout trading.
📌 HULL Moving Average – A fast and smooth moving average used to reduce lag and provide better trend direction.
📌 Supertrend – A dynamic trend indicator that adjusts based on volatility, providing clear buy and sell signals.
📌 Waddah Attar Explosion – Measures momentum and volatility, helping to confirm strong breakouts with volume-based signals.
By integrating these indicators on higher timeframes (such as 4H and Daily), traders can refine entry and exit points, minimize false signals, and maximize profits. 🚀📈
𝓜𝓐 𝓢𝓶𝓸𝓸𝓽𝓱𝓮𝓭 𝓡𝓢𝓘 𝓕𝓸𝓻 𝓛𝓸𝓸𝓹MA Smoothed Source For RSI Loop | Crypto_Mercenary_
Conceptual Foundation and Innovation
The "MA Smoothed Source For RSI Loop" indicator developed by Crypto_Mercenary_ innovates by smoothing the source data used for RSI calculation with various moving averages before feeding it into a for-loop scoring system. Rather than smoothing the RSI itself, this approach focuses on pre-processing the price data to reduce noise, thereby providing a cleaner input for RSI computation. The for-loop then evaluates this smoothed RSI to generate momentum signals, offering traders a refined method for detecting market trends and potential reversals.
Technical Composition and Calculation
The indicator's functionality is divided into two main parts:
Source Smoothing: Before calculating RSI, the source data (typically close price) is smoothed using one of several moving averages (EMA, SMA, WMA, VWMA, HMA, RMA, DEMA, or none) as selected by the user. This smoothing aims to filter out short-term volatility, providing a more consistent base for RSI calculation.
RSI Calculation and For-Loop Scoring:
RSI: Calculated using the smoothed source data over a user-defined length.
For-Loop Mechanism: A loop runs from a to b, comparing the current RSI value with past values of this smoothed RSI. A score (counter) is generated, which increases or decreases based on whether the current RSI exceeds or falls below past values. If the weighted option is activated, this comparison gives more weight to recent data points, adjusting the score accordingly.
The final score is then potentially normalized for better interpretation, compared against thresholds to determine market momentum signals.
Features and User Inputs
This indicator is highly customizable, allowing traders to tailor its behavior:
Weighted Calculation: Option to adjust scoring to favor recent price action.
RSI Length: Sets the period for RSI calculation.
Source: The price data to be smoothed before RSI calculation, default is close.
MA Type: Choice from various moving averages to smooth the source data.
Smooth Length: Length of the moving average used for smoothing.
For Loop Range: Defines the historical range (a to b) for the scoring loop.
Thresholds: Custom thresholds to define when signals for uptrends or downtrends are generated.
Practical Applications
This indicator is particularly beneficial for:
Identifying Momentum Shifts: The scoring system helps in detecting potential changes in market momentum.
Noise Reduction: By smoothing the source data, it aims to provide more reliable RSI signals in volatile markets.
Trend Analysis: Assists in confirming or challenging the current market trend based on the smoothed RSI's performance.
Advantages and Strategic Value
The "MA Smoothed Source For RSI Loop" offers an advantage by focusing on cleaning the input data for RSI, which can lead to more accurate momentum readings. Its flexibility in configuration allows traders to adapt the indicator to different market conditions or asset volatilities, enhancing its strategic value in trading decisions.
Alerts and Visual Cues
Visual Signals: The indicator plots the loop score, with colors indicating uptrends (gold) or downtrends (blue). Horizontal lines at thresholds and shaded areas between them provide visual aids for trend analysis.
**No explicit alerts in the script, but users can set up custom alerts based on the signals.
Summary and Usage Tips
The "MA Smoothed Source For RSI Loop | Crypto_Mercenary_" provides a nuanced approach to RSI by smoothing the price data before its calculation, resulting in potentially more reliable signals. Traders can use this indicator to gain a clearer picture of market momentum, adjusting parameters to fit different market behaviors or trading strategies. Remember, the effectiveness of this tool largely depends on its customization to the specific market context.
Note: Backtests are based on past results and do not guarantee future performance.
Market Structure IDM BY AitssamHow It Works:
Buy Signals: Triggered at Swing Lows, bullish CHoCH, bullish IDM, and bullish BOS.
Sell Signals: Triggered at Swing Highs, bearish CHoCH, bearish IDM, and bearish BOS.
Aggressive/Defensive Mode: Signals are displayed based on the selected mode (aggressive or defensive).
Fractal Breakout Oscillator (BETA)Fractal Breakout Oscillator (BETA)
This custom indicator is designed to help traders identify local tops and local bottoms using fractal analysis, price distance, and trend direction. It combines weighted components to generate the Fractal Breakout Oscillator (FBO). The oscillator reacts to extreme levels in price and trend behavior, with the ability to adjust sensitivity and smoothing parameters.
Components and Usage
1. Fractal Detection:
o Detects fractal tops and bottoms using a 3-bar pattern.
o The number of fractals averaged can be adjusted with the Fractals for Average parameter.
2. Oscillator Calculation:
o Combines price distance, trend direction, and fractal frequency using adjustable weights.
o Use the sensitivity control to tune how strictly the fractal signals respond.
o Extreme values of the oscillators indicate potential overbought or oversold conditions.
3. Customization:
o Customize top/bottom marker colors.
o Enable multipliers (e.g., Golden Ratio) to refine component behavior.
o Adjust smoothing periods and lookback to improve signal reliability.
Disclaimer
This indicator is provided for educational and research purposes only. It should not be considered as financial or trading advice. Always perform your own analysis and consult a financial advisor before making trading decisions. Past performance does not guarantee future results.
IKNOW 4SMA Strategy with Targets and Stop LossDescription:
The IKNOW 4SMA Strategy is a simple yet effective trading strategy designed for trend-following traders. It utilizes a 4-period Simple Moving Average (SMA) to identify trend direction and generate Buy (B) and Sell (S) signals when the price crosses the SMA. This strategy also includes a customizable Take Profit (%) and Stop Loss (%) to help traders manage risk efficiently.
How It Works:
✅ Buy Signal (B - Blue): When the price crosses above the 4SMA, a long position is entered.
✅ Sell Signal (S - Red): When the price crosses below the 4SMA, a short position is entered.
✅ Take Profit & Stop Loss: The strategy automatically sets a Take Profit (default 2%) and Stop Loss (default 1%), both of which can be adjusted as per trading style.
Features:
✔ Clear Buy (B) & Sell (S) Labels – Small and non-intrusive for easy chart analysis.
✔ Customizable Take Profit & Stop Loss – Adjust percentage values to fit your strategy.
✔ Simple & Effective for Trend Following – Based on SMA crossovers for quick entries and exits.
✔ Works on Multiple Timeframes – Can be used on Forex, Crypto, Stocks, and Commodities.
✔ Lightweight & Non-Lagging – Does not overload your TradingView chart.
How to Use:
Add to Chart: Click on "Add to Chart" after enabling the script in TradingView.
Adjust Parameters: Modify Take Profit (%) and Stop Loss (%) to suit your risk appetite.
Follow the Signals: Enter Long when a B (Blue) appears and enter Short when an S (Red) appears.
Manage Risk: Keep an eye on the Stop Loss and Take Profit levels for controlled risk exposure.
🚀 This strategy is perfect for traders who prefer quick, trend-based entries and exits with proper risk management! 🚀
Disclaimer:
This strategy is for educational purposes only. Always backtest and demo trade before using it in live markets. Trading involves risk; trade responsibly.
🔹 Created by: Kashif Abbas (IKNOW Digital Marketing & eCommerce Solution)
🔹 Trademark: IKNOW 4SMA Strategy
SUPER3_Brahmastra mybrahmastra strategy for option buying
if you get buy signal go for in the money option buying.
if you get sell signal go for in the money option selling.
Turtle Soup Model [PhenLabs]📊 Turtle Soup Model
Version: PineScript™ v6
Description
The Turtle Soup Model is an innovative technical analysis tool that combines market structure analysis with inter-market comparison and gap detection. Unlike traditional structure indicators, it validates market movements against a comparison symbol (default: ES1!) to identify high-probability trading opportunities. The indicator features a unique “soup pattern” detection system, comprehensive gap analysis, and real-time structure breaks visualization.
Innovation Points:
First indicator to combine structure analysis with gap detection and inter-market validation
Advanced memory management system for efficient long-term analysis
Sophisticated pattern recognition with multi-market confirmation
Real-time structure break detection with comparative validation
🔧 Core Components
Structure Analysis: Advanced pivot detection with inter-market validation
Gap Detection: Sophisticated gap identification and classification system
Inversion Patterns: “Soup pattern” recognition for reversal opportunities
Visual System: Dynamic rendering of structure levels and gaps
Alert Framework: Multi-condition notification system
🚨 Key Features 🚨
The indicator provides comprehensive analysis through:
Structure Levels: Validated support and resistance zones
Gap Patterns: Identification of significant market gaps
Inversion Signals: Detection of potential reversal points
Real-time Comparison: Continuous inter-market analysis
Visual Alerts: Dynamic structure break notifications
📈 Visualization
Structure Lines: Color-coded for highs and lows
Gap Boxes: Visual representation of gap zones
Inversion Patterns: Clear marking of potential reversal points
Comparison Overlay: Inter-market divergence visualization
Alert Indicators: Visual signals for structure breaks
💡Example
📌 Usage Guidelines
The indicator offers multiple customization options:
Structure Settings:
Pivot Period: Adjustable for different market conditions
Comparison Symbol: Customizable reference market
Visual Style: Configurable colors and line widths
Gap Analysis:
Signal Mode: Choice between close and wick-based signals
Box Rendering: Automatic gap zone visualization
Middle Line: Reference point for gap measurements
✅ Best Practices:
🚨Use comparison symbol from related market🚨
Monitor both structure breaks and gap inversions
Combine signals for higher probability trades
Pay attention to inter-market divergences
⚠️ Limitations
Requires comparison symbol data
Performance depends on market correlation
Best suited for liquid markets
What Makes This Unique
Inter-market Validation: Uses comparison symbol for signal confirmation
Gap Integration: Combines structure and gap analysis
Soup Pattern Detection: Identifies specific reversal patterns
Dynamic Structure Management: Automatically updates and removes invalid levels
Memory-Efficient Design: Optimized for long-term chart analysis
🔧 How It Works
The indicator processes market data through three main components:
1. Structure Analysis:
Detects pivot points with comparison validation
Tracks structure levels with array management
Identifies and processes structure breaks
2. Gap Analysis:
Identifies significant market gaps
Processes gap inversions
Manages gap zones visualization
3. Pattern Recognition:
Detects “soup” patterns
Validates with comparison market
Generates structure break signals
💡 Note: The indicator performs best when used with correlated comparison symbols and appropriate timeframe selection. Its unique inter-market validation system provides additional confirmation for traditional structure-based trading strategies.
Blockchain Fundamentals: Global LiquidityGlobal Liquidity Indicator Overview
This indicator provides a comprehensive technical analysis of liquidity trends by deriving a Global Liquidity metric from multiple data sources. It applies a suite of technical indicators directly on this liquidity measure, rather than on price data. When this metric is expanding Bitcoin and crypto tends to bullish conditions.
Features:
1. Global Liquidity Calculation
Data Integration: Combines multiple market data sources using a ratio-based formula to produce a unique liquidity measure.
Custom Metric: This liquidity metric serves as the foundational input for further technical analysis.
2. Timeframe Customization
User-Selected Period: Users can select the data timeframe (default is 2 months) to ensure consistency and flexibility in analysis.
3. Additional Technical Indicators
RSI, Momentum, ROC, MACD, and Stochastic:
Each indicator is computed using the Global Liquidity series rather than price.
User-selectable toggles allow for enabling or disabling each individual indicator as desired.
4. Enhanced MACD Visualization
Dynamic Histogram Coloring:
The MACD histogram color adjusts dynamically: brighter hues indicate rising histogram values while darker hues indicate falling values.
When the histogram is above zero, green is used; when below zero, red is applied, offering immediate visual insight into momentum shifts.
Conclusion
This indicator is an enlightening tool for understanding liquidity dynamics, aiding in macroeconomic analysis and investment decision-making by highlighting shifts in liquidity conditions and market momentum.
Pipstocrat Market Participant Analysis📊 Pipstocrat Market Participant Analysis (MPA) Indicator
🔍 Uncover Market Intentions & Trade with Confidence
The MPA Indicator is a powerful sentiment tool that reveals the activity of different trader groups, helping you identify smart money movements, retail traps, and liquidity shifts.
📌 Who’s in Control?
🟠 Retail Traders (Gray) – Typically react late and move against institutional trends.
🔵 Hot Money (Blue/Orange) – Short-term aggressive traders who create liquidity spikes.
🟢 Smart Money (Green/Red) – Institutional traders who drive the market’s real direction.
Using RSI-based calculations, volume confirmation, and engulfing patterns, the MPA indicator highlights key liquidity zones and price exhaustion points.
⚡ Key Features
✅ Multi-Layered Market Analysis – Distinguish between retail speculation and institutional positioning.
✅ 🔥 Engulfing Volume Detection – Identifies high-volume bullish & bearish engulfing bars.
✅ 🎨 Dynamic Coloring – Histogram bars adapt based on market conditions.
✅ 🏦 Institutional vs. Retail Activity – Understand liquidity flow and market bias.
✅ 📏 Support, Neutral & Resistance Levels – Levels 5, 10, and 15 mark liquidity exhaustion zones.
✅ 🔍 Volume-Weighted Movements – Ensures signals align with actual liquidity shifts.
✅ 🎛️ Customizable Settings – Adjust transparency, background color, and visibility.
📈 How to Use MPA for Trading
🔹 Identify Smart Money Activity
🟢 Green → Institutions are accumulating (bullish bias).
🔴 Red → Institutions are distributing (bearish bias).
🔹 Spot Liquidity Grabs with Hot Money
🔵 Blue (Bullish Spike) → Short-term upside pressure (possible pullback before continuation).
🟠 Orange (Bearish Spike) → Short-term downside pressure (possible retracement).
🔹 Engulfing Volume Confirmation
📈 Bullish Engulfing + High Volume → Possible buy signal if in confluence with Smart Money accumulation.
📉 Bearish Engulfing + High Volume → Possible sell signal if institutions are distributing.
🔹 Use Key Support & Resistance Levels
🔹 Level 5 → Minor liquidity zone, watch for price reactions.
🔸 Level 10 → Neutral ground – Wait for a breakout confirmation.
🔺 Level 15 → Strong liquidity area; potential reversal zone.
🚀 Why MPA is a Game-Changer?
⚡ Avoid Retail Traps – Follow the money, not the herd.
🎯 Improve Entry Timing – Identify high-probability liquidity-driven setups.
🔍 Enhance Confluence – Works well with ICT, SMC, or any smart money strategy.
❌ Eliminate Noise – Focus on real market dynamics, not lagging indicators.
🔥 **Maximize Your Edge – Trade with Market Knowledge. 🔥
💾 Save, Share & Add to Favorites if you find MPA useful!
Dynamic SL - 1 Pip (Up and Down)The Dynamic SL - 1 Pip Up and Down indicator creates two dynamic lines that follow the price at a distance of 1 pip above and below the closing price. This feature can be particularly useful for traders who want to visualize small stop-loss (SL) levels or track price movement in a highly responsive manner.
Unlike traditional stop-loss indicators, this script ensures that the lines only last for 5 seconds, keeping the chart clean and focusing only on the most relevant price movement.
Key Features
✔ Dynamic Stop-Loss Visualization:
The script draws a green line above the price (+1 pip).
A red line below the price (-1 pip) is also drawn.
✔ Auto-Clearing for a Clean Chart:
Each line lasts for 5 seconds only before automatically disappearing.
This prevents unnecessary clutter on the chart and ensures only the latest price movements are visualized.
✔ Adaptable to Multiple Assets:
Automatically calculates the pip size based on the instrument type:
Forex → Uses 0.0001 per pip.
Futures & Stocks → Uses the minimum tick size.
✔ Ideal for High-Frequency Traders & Scalpers:
Designed for 1-minute (M1) or lower timeframes where traders need to monitor price action closely.
Helps visualize ultra-tight stop-loss levels in scalping strategies.
Maverick Henderson Strategy
Maverick Henderson Strategy
A comprehensive technical analysis indicator that combines several powerful tools:
1. Volume Profile with POC (Point of Control)
- Displays volume distribution across price levels
- Shows value areas and POC line
- Helps identify key support/resistance levels
2. Multiple EMAs (10, 50, 100, 200)
- Trend identification and dynamic support/resistance
- Price action confirmation
- Works best with Heikin Ashi candles
3. Swing Detection & Counting System
- Identifies and counts higher highs/lower lows
- Dynamic trend strength measurement
- Automatically resets on EMA200 crossovers
4. RSI Divergence Detection
- Regular bullish/bearish divergences
- Hidden bullish/bearish divergences
- Filtered by EMA200 position
5. Multi-Timeframe Squeeze Momentum
- Analyzes momentum across 1H, 2H, 3H, and 4H timeframes
- Shows momentum convergence/divergence
- Visual color-coded momentum representation
Usage Tips:
- Best performance with Heikin Ashi candles
- Use EMA crossovers for trend confirmation
- Watch for momentum convergence signals
- Monitor RSI divergences for potential reversals
// ═══════════════════════════════════════════════════════════
Estrategia Maverick Henderson
Un indicador de análisis técnico completo que combina varias herramientas poderosas:
1. Perfil de Volumen con POC
- Muestra la distribución del volumen por niveles de precio
- Visualiza áreas de valor y línea POC
- Ayuda a identificar niveles clave de soporte/resistencia
2. Múltiples EMAs (10, 50, 100, 200)
- Identificación de tendencias y soporte/resistencia dinámica
- Confirmación de acción del precio
- Funciona mejor con velas Heikin Ashi
3. Sistema de Detección y Conteo de Swings
- Identifica y cuenta máximos más altos/mínimos más bajos
- Medición dinámica de la fuerza de la tendencia
- Se reinicia automáticamente en cruces de EMA200
4. Detección de Divergencias RSI
- Divergencias regulares alcistas/bajistas
- Divergencias ocultas alcistas/bajistas
- Filtradas por posición respecto a EMA200
5. Momentum Multi-Temporal
- Analiza momentum en marcos de 1H, 2H, 3H y 4H
- Muestra convergencia/divergencia de momentum
- Representación visual codificada por colores
Consejos de Uso:
- Mejor rendimiento con velas Heikin Ashi
- Usar cruces de EMA para confirmación de tendencia
- Observar señales de convergencia de momentum
- Monitorear divergencias RSI para posibles reversiones
// ═══════════════════════════════════════════════════════════
Stochastic Divergence Detection
New feature added! The indicator now includes Stochastic divergence detection, just like the RSI, providing additional tools for identifying potential reversals and trend confirmations.
Regular Divergences:
-Bullish: Signals a potential upward reversal when price makes lower lows, but the Stochastic shows higher lows.
-Bearish: Signals a potential downward reversal when price makes higher highs, but the Stochastic shows lower highs.
Hidden Divergences (optional):
-Bullish: Occurs during uptrends when price makes higher lows, but the Stochastic shows lower lows.
-Bearish: Occurs during downtrends when price makes lower highs, but the Stochastic shows higher highs.
Detección de Divergencias en el Estocástico
¡Nueva función añadida! Ahora el indicador incluye detección de divergencias en el Estocástico, al igual que en el RSI, ofreciendo herramientas adicionales para identificar posibles reversiones y confirmaciones de tendencia.
Divergencias regulares:
-Alcistas: Señala una posible reversión al alza cuando el precio marca mínimos más bajos y el Estocástico muestra mínimos más altos.
-Bajistas: Señala una posible reversión a la baja cuando el precio marca máximos más altos y el Estocástico muestra máximos más bajos.
Divergencias ocultas (opcional):
-Alcistas: Ocurre en tendencias alcistas cuando el precio hace mínimos más altos, pero el Estocástico muestra mínimos más bajos.
-Bajistas: Ocurre en tendencias bajistas cuando el precio marca máximos más bajos, pero el Estocástico muestra máximos más altos.
Volume Delta with PVSRAVolume Delta with PVSRA
Volume Delta with PVSRA is an advanced volume indicator that dissects each bar’s volume into its directional components using higher resolution data. It visually distinguishes between buying and selling volume, so that for a bullish candle the bottom portion represents buying volume and for a bearish candle it represents selling volume. A dot is plotted at the 50% mark of the candle’s total volume, serving as a clear reference point.
Key Features:
Directional Volume Breakdown:
The indicator calculates the delta volume by analyzing lower timeframe data. The bottom portion of a bullish candle (displayed in green) represents buying volume, while that of a bearish candle (displayed in red) represents selling volume.
PVSRA Analysis:
Using Price-Volume Spread Range Analysis, the indicator compares the current volume to the 10-bar average. When volume is significantly higher (using thresholds of 150% and 200%), the candle borders are highlighted in custom colors, indicating medium or strong volume conditions.
Volume Moving Averages:
Three moving averages are plotted:
Total Volume MA (yellow): Tracks overall volume.
Buying Volume MA (green) and Selling Volume MA (red): These are re-centered around the total volume MA. A crossover of the green over the red typically signals rising buying pressure, while the opposite indicates increasing selling pressure.
Scalable Volume Bars:
The indicator scales the volume bars to provide optimal visualization on your chart.
Setup Instructions:
For best results, open your chart settings, navigate to the Canvas tab, and set the bottom margin to 0%. This ensures the indicator displays like a standard volume indicator without any unwanted gaps at the bottom.
Customize the various settings—including colors, border opacity, and moving average parameters—to suit your trading style.
Angel Signal proA fully prepared indicator:10 in 1, numerical values of such indexes as-Rsi,Masd,CCI. Look at the rectangle and all the values are in front of you
EE's Levels & TargetsThis indicator is meant to be used by subscribers of Efficient Enzyme's daily plans for /ES, but it can be used by anyone that prefers to draw levels on their chart with a simple copy and paste. The code is largely based off the "honey marks" indicator created by honeybear, but it has been slimmed down to focus on just the newsletter levels.
There are options to draw levels of support and resistance, as well as bull and bear targets. Each can be styled to personal taste. Values can be copied and pasted directly from EE's newsletter.
Like in the original code, levels that are provided as "zones" because they are trendlines can be drawn as boxes by entering a range as a value (i.e. 6120-6124).
You now have the option to draw any/all of the levels as zones rather than single values, and you are able to specify the height of the zone boxes.
If you are not a subscriber, you need to check out EE's Substack at efficientenzyme.substack.com/ . Take a free trial, join the group, and learn price action from the best in the business.
Pivot Point с зигзагом и Фибоначчи [DaVinchi]Название:
Supertrend Zone Pivot Point с зигзагом и Фибоначчи (RU) с выбором таймфрейма
Описание:
Данный индикатор объединяет в себе несколько популярных инструментов технического анализа, позволяющих получить комплексное представление о тренде, определить ключевые точки разворота, а также выявить важные уровни поддержки и сопротивления с помощью Фибоначчи. Индикатор отображается поверх графика и работает на выбранном таймфрейме, что дает возможность проводить многовременной анализ.
Основные компоненты и функциональность:
Supertrend и Premium/Discount Zone:
Supertrend:
Индикатор рассчитывает линию Supertrend на основе выбранного периода ATR и множителя (factor). Эта линия помогает определить направление тренда:
При нахождении цены выше линии – тренд считается восходящим (отображается с настраиваемым зелёным цветом).
При нахождении цены ниже линии – тренд считается нисходящим (отображается с настраиваемым красным цветом).
Премиум/Дискаунт:
Дополнительно можно отобразить линии премиум/дискаунт, которые вычисляются как отступ от линии Supertrend на основе дополнительного множителя ATR (atrline). Эти линии помогают оценить зону перекупленности или перепроданности по отношению к Supertrend.
Пивоты и Зигзаг:
При изменении направления Supertrend (определяемом по смене знака изменения) происходит фиксация экстремальных значений – пивотов максимум (при смене на нисходящий тренд) и пивотов минимум (при смене на восходящий тренд).
На уровне каждого пивота создаются метки (labels) с указанием цены, а также проводятся линии, соединяющие предыдущие и текущие экстремумы, формируя зигзаг.
Отображение зигзага можно включать или отключать в настройках, а его цвет, толщина и стиль (сплошная, пунктирная или штриховая линия) задаются пользователем.
Уровни Фибоначчи:
На основе последних найденных пивотов (максимум и минимум) определяется диапазон, по которому рассчитываются уровни Фибоначчи. Если пивоты не обнаружены, используются экстремумы за последние 50 баров.
Строятся линии Фибоначчи с уровнями 0.0, 0.236, 0.382, 0.5, 0.618 и 1.0. Для каждого уровня можно задать:
Возможность отображения (вкл./выкл.).
Значение уровня, цвет, толщину и стиль линии.
Смещение линии (в барах) и направление смещения (влево или вправо).
Рядом с каждой линией выводится метка с указанием названия уровня, цены и процентного соотношения, что помогает быстро оценить, где располагаются потенциальные уровни поддержки или сопротивления.
Выбор таймфрейма и входные данные:
Все расчёты (цены открытия, максимума, минимума, закрытия, ATR и Supertrend) осуществляются на основе данных выбранного таймфрейма. Это позволяет применять индикатор для анализа как краткосрочных, так и долгосрочных графиков.
Пользователь задаёт основные параметры: период ATR, множитель для расчёта Supertrend, множитель для линии премиум/дискаунт и сам таймфрейм.
Настраиваемость и визуальные параметры:
Отображение: Возможность включать или отключать отдельные элементы: зигзаг, линию Supertrend, линию премиум/дискаунт, уровни Фибоначчи.
Настройки внешнего вида:
Для зигзага: цвет, толщина и стиль линии.
Для Supertrend: цвета линий для восходящего и нисходящего трендов, толщина линии, а также полупрозрачное залитие между линией и серединой тела свечи.
Для пивотов: цвета текста и фона меток, а также цвета и толщина линий, соединяющих пивоты.
Для Фибоначчи: индивидуальные настройки для каждого уровня (цвет, толщина, стиль линии), а также смещение и направление вывода линий и меток.
Преимущества и применение:
Комплексный анализ тренда: Сочетание Supertrend с пивотами и зигзагом позволяет не только определить общее направление движения цены, но и зафиксировать ключевые точки разворота.
Определение уровней поддержки/сопротивления: Построенные уровни Фибоначчи помогают выявить зоны, где цена может отскочить или пробить уровень, что является важным для постановки стоп-лоссов и тейк-профитов.
Гибкая настройка: Большое количество входных параметров позволяет адаптировать индикатор под различные торговые стратегии и личные предпочтения трейдера.
Многовременной анализ: Возможность выбора таймфрейма делает индикатор универсальным для анализа как краткосрочных, так и долгосрочных трендов.
Как использовать:
Установите необходимые параметры (ATR, множители, таймфрейм, цвета и стили линий) в настройках индикатора.
Включите отображение нужных элементов (например, зигзаг, Supertrend, уровни Фибоначчи) в зависимости от вашей торговой стратегии.
Используйте линию Supertrend для определения направления тренда, а пивоты и зигзаг для выявления точек разворота.
Анализируйте уровни Фибоначчи для поиска потенциальных зон поддержки и сопротивления, где цена может замедлить движение или развернуться.
