True Trend Average BandsThis is the indicator I am most proud of. After reading Glenn Neely's book "Mastering Eliott Waves" / "Neowave" and chatting with @timwest who got acknowledged by Neely, we came up with the idea of an moving average which does calculate the real average price since a trend started. Addionally I adapted a method from Neely Neowave and Tim Wests TimeAtMode to not force a timeframe on a chart but instead let the charts data decide which timeframe to use, to then calculate the real average price since the trend started.
It took me a while to get this right and coded, so take a moment and dive deeper and you might learn something new.
We assume that the price is in multiple trends on multiple timeframes, this is caused by short term traders, long term traders and investors who trade on different timeframes. To find out in which timeframe the important trends are, we have to look out for significant lows and highs. Then we change the timeframe in the chart to a value so that we have 10 to 20 bars since the significant low/high. While new bars are printed, and we reach more than 20 bars, we have to switch to a higher timeframe so we have 10 to 20 bars again. In the chart you see two significant trends: a downtrend on the 3 week timeframe and an uptrend from the 2 month timeframe. Based on the logic I have described, these are the two important timeframes to watch right now for the spx (there is another uptrend in the yearly chart, which is not shown here).
Now that we understand how to find the important timeframes, let's look what the magic in this script is that tells us the real average price since a trend started.
I developed a new type of moving average, which includes only the prices since a trend started. The difference to the regular sma is that it will not include prices which happened before the significant low or high happened. For example, if a top happened in a market 10 days ago, the regular sma20 would be calculated by 10 bars which happened before the top and 10 bars which happened after the top. If we want to know the average price of the last 10 bars we manually have to change the ma20 to the ma10 which is annoying manual work, additionally even if we use the ma10 in this case, and we look at yesterday's bar the ma10 will include 9 bars from after the top and one bar before the top, so the ma10 would only show the real average price for the current bar which is not what we want.
To come up with a solution to this problem, the True Trend Average searches for the lowest/highest bar in a given period (20 bars). Then starts to calculate the average value since the low/high. For example: if the price reaches a new 20 day high and then trades below it, the day of the high will be the sma1, the day after it's the sma2, ... up to the maximum look back length.
This way, we always know what the average price would have been if someone sold/bought a little bit every bar of his investment since the high/low.
Why is this even important? Let's assume we missed selling the top or buying the low, and think it would have been at least better to buy/sell a little bit since the new trend started. Once the price reaches the true trend average again, we can buy/sell, and it would be as good as selling/buying a little bit every day. We find prices to buy the dip and sell the bounce, which are as good as scaling in/out.
There is a lot more we can learn from these price levels but I think it is better to let you figure out yourself what you can learn from the information given by this indicator. Think about how market participants who accumulate or distribute feel when prices are above or below certain levels.
Now that we understand this new type of moving average, let's look into the lines we see in the chart:
The upper red band line shows the true trend average high price since the last significant top within 20 bars.
The lower red band line shows the true trend average hl2 price since the last significant top within 20 bars.
The lower green band line shows the true trend average low price since the last significant low within 20 bars.
The upper green band line shows the true trend average hl2 price since the last significant low within 20 bars.
The centerline is the average between the upper red band and the lower green band.
The teal lines show 1 standard deviation from the outer bands.
Before today only a few people had access to this indicator, now that it is public and open source, I am curious if you will find it useful and what you will do with it. Please share your findings.
/edit: The chart only shows the 3week timeframe so here are the other two trends from the 2month and 1year timeframe
Поиск скриптов по запросу "A股+股票筛选器+10元以下"
[blackcat] L1 Old Duck HeadLevel 1
Background
The old duck head is a classic form formed by a series of behaviors such as bankers opening positions, washing dishes, and pulling over the top of the duck head.
Function
A form of stock candles:
(1) Moving averages using 5, 10 and 60 parameters. When the 5-day and 10-day moving averages crossed the 60-day moving average, a duck neck was formed.
(2) The high point when the stock price fell back formed a duck head.
(3) When the stock price fell back soon, the 5-day and 10-day moving averages again turned up to form a duckbill.
(4) Duck nose refers to the hole formed when the 5-day moving average crosses the 10-day moving average and the two lines cross again.
Market significance:
(1) When the dealer starts to collect chips, the stock price rises slowly, and the 5-day and 10-day moving averages cross the 60-day moving average, forming a duck neck.
(2) When the stock price of the banker shakes the position and starts to pull back, the high point of the stock price forms the top of the duck's head.
(3) When the dealer builds a position again to collect chips, the stock price rises again, forming a duck bill.
Operation method:
(1) Buy when the 5-day and 10-day moving averages cross the 60-day moving average and form a duck neck.
(2) Buy on dips near the sesame point of trading volume near the duckbill.
(3) Intervene when the stock price crosses the top of the duck's head in heavy volume.
The top of the duck’s head should be a little far away from the 60-day moving average, otherwise it means that the dealer is not willing to open a position at this old duck’s head, and the bottom of the old duck’s head must be heavy. Small is better, nothing is the strongest! There must be a lot of sesame dots under the nostrils of the duck, otherwise it means that the dealer has poor control. There must be ventilation under the duck bill, the higher the ventilation, the better!
Remarks
Feedbacks are appreciated.
Variety N-Tuple Moving Averages w/ Variety Stepping [Loxx]Variety N-Tuple Moving Averages w/ Variety Stepping is a moving average indicator that allows you to create 1- 30 tuple moving average types; i.e., Double-MA, Triple-MA, Quadruple-MA, Quintuple-MA, ... N-tuple-MA. This version contains 2 different moving average types. For example, using "50" as the depth will give you Quinquagintuple Moving Average. If you'd like to find the name of the moving average type you create with the depth input with this indicator, you can find a list of tuples here: Tuples extrapolated
Due to the coding required to adapt a moving average to fit into this indicator, additional moving average types will be added as they are created to fit into this unique use case. Since this is a work in process, there will be many future updates of this indicator. For now, you can choose from either EMA or RMA.
This indicator is also considered one of the top 10 forex indicators. See details here: forex-station.com
Additionally, this indicator is a computationally faster, more streamlined version of the following indicators with the addition of 6 stepping functions and 6 different bands/channels types.
STD-Stepped, Variety N-Tuple Moving Averages
STD-Stepped, Variety N-Tuple Moving Averages is the standard deviation stepped/filtered indicator of the following indicator
Last but not least, a big shoutout to @lejmer for his help in formulating a looping solution for this streamlined version. this indicator is speedy even at 50 orders deep. You can find his scripts here: www.tradingview.com
How this works
Step 1: Run factorial calculation on the depth value,
Step 2: Calculate weights of nested moving averages
factorial(depth) / (factorial(depth - k) * factorial(k); where depth is the depth and k is the weight position
Examples of coefficient outputs:
6 Depth: 6 15 20 15 6
7 Depth: 7 21 35 35 21 7
8 Depth: 8 28 56 70 56 28 8
9 Depth: 9 36 34 84 126 126 84 36 9
10 Depth: 10 45 120 210 252 210 120 45 10
11 Depth: 11 55 165 330 462 462 330 165 55 11
12 Depth: 12 66 220 495 792 924 792 495 220 66 12
13 Depth: 13 78 286 715 1287 1716 1716 1287 715 286 78 13
Step 3: Apply coefficient to each moving average
For QEMA, which is 5 depth EMA , the calculation is as follows
ema1 = ta. ema ( src , length)
ema2 = ta. ema (ema1, length)
ema3 = ta. ema (ema2, length)
ema4 = ta. ema (ema3, length)
ema5 = ta. ema (ema4, length)
In this new streamlined version, these MA calculations are packed into an array inside loop so Pine doesn't have to keep all possible series information in memory. This is handled with the following code:
temp = array.get(workarr, k + 1) + alpha * (array.get(workarr, k) - array.get(workarr, k + 1))
array.set(workarr, k + 1, temp)
After we pack the array, we apply the coefficients to derive the NTMA:
qema = 5 * ema1 - 10 * ema2 + 10 * ema3 - 5 * ema4 + ema5
Stepping calculations
First off, you can filter by both price and/or MA output. Both price and MA output can be filtered/stepped in their own way. You'll see two selectors in the input settings. Default is ATR ATR. Here's how stepping works in simple terms: if the price/MA output doesn't move by X deviations, then revert to the price/MA output one bar back.
ATR
The average true range (ATR) is a technical analysis indicator, introduced by market technician J. Welles Wilder Jr. in his book New Concepts in Technical Trading Systems, that measures market volatility by decomposing the entire range of an asset price for that period.
Standard Deviation
Standard deviation is a statistic that measures the dispersion of a dataset relative to its mean and is calculated as the square root of the variance. The standard deviation is calculated as the square root of variance by determining each data point's deviation relative to the mean. If the data points are further from the mean, there is a higher deviation within the data set; thus, the more spread out the data, the higher the standard deviation.
Adaptive Deviation
By definition, the Standard Deviation (STD, also represented by the Greek letter sigma σ or the Latin letter s) is a measure that is used to quantify the amount of variation or dispersion of a set of data values. In technical analysis we usually use it to measure the level of current volatility .
Standard Deviation is based on Simple Moving Average calculation for mean value. This version of standard deviation uses the properties of EMA to calculate what can be called a new type of deviation, and since it is based on EMA , we can call it EMA deviation. And added to that, Perry Kaufman's efficiency ratio is used to make it adaptive (since all EMA type calculations are nearly perfect for adapting).
The difference when compared to standard is significant--not just because of EMA usage, but the efficiency ratio makes it a "bit more logical" in very volatile market conditions.
See how this compares to Standard Devaition here:
Adaptive Deviation
Median Absolute Deviation
The median absolute deviation is a measure of statistical dispersion. Moreover, the MAD is a robust statistic, being more resilient to outliers in a data set than the standard deviation. In the standard deviation, the distances from the mean are squared, so large deviations are weighted more heavily, and thus outliers can heavily influence it. In the MAD, the deviations of a small number of outliers are irrelevant.
Because the MAD is a more robust estimator of scale than the sample variance or standard deviation, it works better with distributions without a mean or variance, such as the Cauchy distribution.
For this indicator, I used a manual recreation of the quantile function in Pine Script. This is so users have a full inside view into how this is calculated.
Efficiency-Ratio Adaptive ATR
Average True Range (ATR) is widely used indicator in many occasions for technical analysis . It is calculated as the RMA of true range. This version adds a "twist": it uses Perry Kaufman's Efficiency Ratio to calculate adaptive true range
See how this compares to ATR here:
ER-Adaptive ATR
Mean Absolute Deviation
The mean absolute deviation (MAD) is a measure of variability that indicates the average distance between observations and their mean. MAD uses the original units of the data, which simplifies interpretation. Larger values signify that the data points spread out further from the average. Conversely, lower values correspond to data points bunching closer to it. The mean absolute deviation is also known as the mean deviation and average absolute deviation.
This definition of the mean absolute deviation sounds similar to the standard deviation (SD). While both measure variability, they have different calculations. In recent years, some proponents of MAD have suggested that it replace the SD as the primary measure because it is a simpler concept that better fits real life.
For Pine Coders, this is equivalent of using ta.dev()
Bands/Channels
See the information above for how bands/channels are calculated. After the one of the above deviations is calculated, the channels are calculated as output +/- deviation * multiplier
Signals
Green is uptrend, red is downtrend, yellow "L" signal is Long, fuchsia "S" signal is short.
Included:
Alerts
Loxx's Expanded Source Types
Bar coloring
Signals
6 bands/channels types
6 stepping types
Related indicators
3-Pole Super Smoother w/ EMA-Deviation-Corrected Stepping
STD-Stepped Fast Cosine Transform Moving Average
ATR-Stepped PDF MA
Tendies Heist Auto Compounding ExampleThis is an example of how we can use compounding to control our position size. This example shows how we can automatically add and reduce position size based on account equity. The "initial capital" in properties is the starting account equity. At default its set to 100,000. If our max position size is set to 25 then the very first position that's taken has a position size of 10, IF our leverage is set to 10,000. Account equity divided by leverage equals position size. So in that example 100,000 divided by 10,000 in leverage gives us a max position size of 10. However the max position size was set to 25 meaning we would need 250k in equity for it to open a position size of 25 with the leverage set at 10k. Now if the initial capital was set to 100,000 and the max position size was set to 5 and leverage remained at 10,000, all though 100,000 divided by 10,000 equals 10 it will ONLY open a position size of 5, because the max position size in this example was set at 5. Since this works for strategies you may look through the trade log on the posted back test and check out the position size, you can see in this back test the default 100k is used for the initial capital and the default 10k was used for the leverage. You will be able to see as this logic loses money it takes contracts away and as it gains money it adds contracts. I'm using trading view's basic strategy logic example to provide an example of how the compounding logic works.
Note, don't forget to add the syntax below to your strategy.entry call for this logic to work.
qty = size
Tendies Heist LLC 2021
Combo Backtest 123 Reversal & D_Three Ten OscThis is combo strategies for get a cumulative signal.
First strategy
This System was created from the Book "How I Tripled My Money In The
Futures Market" by Ulf Jensen, Page 183. This is reverse type of strategies.
The strategy buys at market, if close price is higher than the previous close
during 2 days and the meaning of 9-days Stochastic Slow Oscillator is lower than 50.
The strategy sells at market, if close price is lower than the previous close price
during 2 days and the meaning of 9-days Stochastic Fast Oscillator is higher than 50.
Second strategy
TradeStation does not allow the user to make a Multi Data Chart with
a Tick Bar Chart and any other type a chart. This indicator allows the
user to plot a daily 3-10 Oscillator on a Tick Bar Chart or any intraday interval.
Walter Bressert's 3-10 Oscillator is a detrending oscillator derived
from subtracting a 10 day moving average from a 3 day moving average.
The second plot is an 16 day simple moving average of the 3-10 Oscillator.
The 16 period moving average is the slow line and the 3/10 oscillator is
the fast line.
For more information on the 3-10 Oscillator see Walter Bressert's book
"The Power of Oscillator/Cycle Combinations"
WARNING:
- For purpose educate only
- This script to change bars colors.
Combo Backtest 123 Reversal & D_Three Ten Osc This is combo strategies for get a cumulative signal.
First strategy
This System was created from the Book "How I Tripled My Money In The
Futures Market" by Ulf Jensen, Page 183. This is reverse type of strategies.
The strategy buys at market, if close price is higher than the previous close
during 2 days and the meaning of 9-days Stochastic Slow Oscillator is lower than 50.
The strategy sells at market, if close price is lower than the previous close price
during 2 days and the meaning of 9-days Stochastic Fast Oscillator is higher than 50.
Second strategy
TradeStation does not allow the user to make a Multi Data Chart with
a Tick Bar Chart and any other type a chart. This indicator allows the
user to plot a daily 3-10 Oscillator on a Tick Bar Chart or any intraday interval.
Walter Bressert's 3-10 Oscillator is a detrending oscillator derived
from subtracting a 10 day moving average from a 3 day moving average.
The second plot is an 16 day simple moving average of the 3-10 Oscillator.
The 16 period moving average is the slow line and the 3/10 oscillator is
the fast line.
For more information on the 3-10 Oscillator see Walter Bressert's book
"The Power of Oscillator/Cycle Combinations"
WARNING:
- For purpose educate only
- This script to change bars colors.
D_Three Ten Osc Strategy Backtest This indicator allows the user to plot a daily 3-10 Oscillator on a Tick Bar Chart or any intraday interval.
Walter Bressert's 3-10 Oscillator is a detrending oscillator derived
from subtracting a 10 day moving average from a 3 day moving average.
The second plot is an 16 day simple moving average of the 3-10 Oscillator.
The 16 period moving average is the slow line and the 3/10 oscillator is
the fast line.
For more information on the 3-10 Oscillator see Walter Bressert's book
"The Power of Oscillator/Cycle Combinations"
You can change long to short in the Input Settings
Please, use it only for learning or paper trading. Do not for real trading.
D_Three Ten Osc Strategy This indicator allows the user to plot a daily 3-10 Oscillator on a Tick Bar
Chart or any intraday interval.
Walter Bressert's 3-10 Oscillator is a detrending oscillator derived
from subtracting a 10 day moving average from a 3 day moving average.
The second plot is an 16 day simple moving average of the 3-10 Oscillator.
The 16 period moving average is the slow line and the 3/10 oscillator is
the fast line.
For more information on the 3-10 Oscillator see Walter Bressert's book
"The Power of Oscillator/Cycle Combinations"
Sladkaya BulochkaAccording to the statistics of Thomas Bulkovski collected over several years on the 1-minute chart (21 million candles), there is a statistically significant periods, where the higher the probability of reversal rates on short-term timeframe.
By reversal, on average, had in mind the movement to 5 candles.
This three periods, they remain unchanged, depending on the hour:
- the first minute of each hour (10:01, 11:01, etc.)
- the first minute after the hour (10:31, 11:31)
- 51 minutes each hour (10:51, 11:51)
------------------------------------------------------
По статистике Томаса Булковски, собранной за несколько лет на 1-минутном графике (21 миллион свечей), есть статистически значимые периоды, где более высока вероятность разворота цены на краткосрочных ТФ.
Под разворотом, в среднем, имелось в виду движение на 5 свечей.
Это три периода, они неизменны в зависимости от часа:
- первая минута каждого часа (10:01, 11:01 и т.д.)
- первая минута после получаса (10:31, 11:31)
- каждая 51 минута часа (10:51, 11:51)
HL BREAKOUTThe base of the indicator is the breakout of historic High and lows.
There are 3 basic configurations
1° The High length that measure the latest 10 bars and make the "higher high"
2° The Low length taht measure the latest 10 bars and make the "lower low"
3° The Breakout PIPs administrator that defines how much pips are needed from the latest higher high to be defined as a level breakout.
So the strategy is super easy. The indicators show you the 10...20.. or whatever you need old bars high and lows.
When a breakout of that levels occurs and the candle "close" above or below and the close are more than "X" amount of PIPs a marker show up. The marker are the signals of buy and sell
I test some configurations, and work in all timeframes but.
I suggest
10, 10, 0.0003 for timeframes from 1m to 15m
and 10, 10, 0.0005 for timeframes higher than 15m
Maybe you need to test other configurations for 4h 1 day, etc the basics are the same in all timeframes, the main difference is the amount of pips that will be considered as "breakout" the higher timeframe the higher amount you need to prevent false positives.
Last words: 0.000X are for the PIPs for currencies that have 4 or 5 decimals like euro and other, if you use in YEN change it to a configuration of 2 digits decimal. Just that.
Have "fun" !
D_Three Ten Osc on the IntradayHi
Let me introduce my D_Three Ten Osc script.
This indicator allows the
user to plot a daily 3-10 Oscillator on a Tick Bar Chart or any intraday interval.
Walter Bressert's 3-10 Oscillator is a detrending oscillator derived
from subtracting a 10 day moving average from a 3 day moving average.
The second plot is an 16 day simple moving average of the 3-10 Oscillator.
The 16 period moving average is the slow line and the 3/10 oscillator is
the fast line.
For more information on the 3-10 Oscillator see Walter Bressert's book
"The Power of Oscillator/Cycle Combinations"
D_Three Ten Osc on the DailyHi
Let me introduce my D_Three Ten Osc script.
This indicator allows the
user to plot a daily 3-10 Oscillator on a Tick Bar Chart or any intraday interval.
Walter Bressert's 3-10 Oscillator is a detrending oscillator derived
from subtracting a 10 day moving average from a 3 day moving average.
The second plot is an 16 day simple moving average of the 3-10 Oscillator.
The 16 period moving average is the slow line and the 3/10 oscillator is
the fast line.
For more information on the 3-10 Oscillator see Walter Bressert's book
"The Power of Oscillator/Cycle Combinations"
Global Macro IndexGlobal Macro Index
The Global Macro Index is a comprehensive economic sentiment indicator that aggregates 23 real-time macroeconomic data points from the world's largest economies (US, EU, China, Japan, Taiwan). It provides a single normalized score that reflects the overall health and momentum of the global economy, helping traders identify macro trends that drive asset prices.
⚠️ Important: Timeframe Settings
This indicator is designed exclusively for the 1W (weekly) timeframe. The indicator is hardcoded to pull weekly data and will not function correctly on other timeframes.
What It Measures
The indicator tracks normalized Trend Power Index (TPI) values across multiple economic categories:
United States (7 components)
Business Confidence Index (BCOI) - Business sentiment and outlook
Composite Leading Indicator (CLI) - Forward-looking economic indicators
Consumer Confidence Index (CCI) - Consumer sentiment and spending intentions
Terms of Trade (TOT) - Import/export price relationships
Manufacturing Composite - Combines business confidence, production, and new orders
Comprehensive Economic Composite - Broad aggregation including employment, business activity, and regional indicators
Business Inventory (BI) - Stock levels and supply chain health
European Union (10 components)
Sentiment Survey (SS) - Overall economic sentiment
Business Confidence Index - EU business outlook
Economic Sentiment Indicator (ESI) - Combined confidence metrics
Manufacturing Production (MPRYY) - Industrial output year-over-year
New Orders - Germany, France, Netherlands, Spain manufacturing orders
Composite Leading Indicators - Germany, France forward-looking metrics
Business Climate Index (BCLI) - France business conditions
Asia (6 components)
New Orders - China, Japan, Taiwan manufacturing demand
Composite Leading Indicators - China, Japan economic momentum
The Formula
The indicator calculates a weighted average of normalized TPI scores:
Global Macro Index = (1/23) × Σ
Each of the 23 economic indicators is:
Converted to a Trend Power Index (TPI) using 4-day Bitcoin normalization
Weighted equally (1/23 ≈ 4.35% each)
Summed and smoothed with a 1-period SMA
The result is a single oscillator that ranges typically between -1 and +1, with extreme readings beyond ±0.6.
Z-Score Signal System
The indicator includes an optional Z-Score overlay that identifies extreme macro conditions:
Calculation:
Z-Score = (Current Value - 50-period Mean) / Standard Deviation
Smoothed with 35-period Hull Moving Average
Inverted for intuitive interpretation
Signals:
Green background (Z-Score ≥ 2) = Extremely positive macro conditions, potential overbought
Red background (Z-Score ≤ -2) = Extremely negative macro conditions, potential oversold
These extreme readings occur approximately 5% of the time statistically
How to Use It
Interpreting the Main Plot (Red Line):
Above 0 = Positive macro momentum, risk-on environment
Below 0 = Negative macro momentum, risk-off environment
Above +0.6 = Strong expansion, bullish for equities and crypto
Below -0.6 = Severe contraction, bearish conditions
Trend direction = More important than absolute level
Z-Score Signals:
Z ≥ 2 (Green) = Macro sentiment extremely positive, consider taking profits or preparing for pullback
Z ≤ -2 (Red) = Macro sentiment extremely negative, potential buying opportunity for contrarians
Works best as a regime filter, not precise timing tool
Best Practices:
Use as a macro regime filter for other strategies
Combines well with liquidity indicators and price action
Leading indicator for risk assets (equities, Bitcoin, emerging markets)
Lagging indicator - confirms macro trends rather than predicting reversals
Watch for divergences: price making new highs while macro weakens (bearish) or vice versa (bullish)
Settings
Show Zscore Signals: Toggle green/red background shading for extreme readings
Overlay Zscore Signals: Display Z-Score signals on the price chart as well as the indicator panel
Reference Lines
0 (gray) = Neutral macro conditions
+0.6 (green) = Strong positive threshold
-0.6 (red) = Strong negative threshold
Data Sources
Real-time economic data from TradingView's ECONOMICS database, including:
OECD leading indicators
Manufacturing PMIs and new orders
Consumer and business confidence surveys
Trade and inventory metrics
Regional economic sentiment indices
Notes
This is a macro trend indicator, not a day-trading tool. Economic data updates weekly and reflects the aggregate health of global growth. Best used on weekly timeframes to identify favorable or unfavorable macro regimes for risk asset allocation.
The indicator distills complex global economic data into a single actionable score, answering: "Is the global economy expanding or contracting right now?"
NIFTY Options Breakout StrategyThis strategy trades NIFTY 50 Options (CALL & PUT) using 5-minute breakout logic, strict trend filters, expiry-based symbol validation, and a dynamic trailing-profit engine.
1️⃣ Entry Logic
Only trades NIFTY 50 options, filtered automatically by symbol.
Trades only between 10:00 AM – 2:15 PM (5m bars).
Breakout trigger:
Price enters the buy breakout zone (high of last boxLookback bars ± buffer).
Trend filter:
Price must be above EMA50 or EMA200,
AND EMA50 ≥ EMA100 (to avoid weak conditions).
Optional strengthening:
EMA20>EMA50 OR EMA50>EMA100 recent cross can be enforced.
Higher-timeframe trend check:
EMA50 > EMA200 (bullish regime only).
Start trading options only after expiry–2 months (auto-parsed).
2️⃣ One Trade Per Day
Maximum 1 long trade per day.
No shorting (long-only strategy).
3️⃣ Risk Management — SL, TP & Trailing
Includes three types of exits:
🔹 A) Hard SL/TP
Hard Stop-Loss: -15%
Hard Take-Profit: +40%
🔹 B) Step-Ladder Trailing Profit
As the option price rises, trailing activates:
Max Profit Reached Exit Trigger When Falls To
≥ 35% ≤ 30%
≥ 30% ≤ 25%
≥ 25% ≤ 20%
≥ 20% ≤ 15%
≥ 15% ≤ 10%
≥ 5% ≤ 0%
🔹 C) Loss-Recovery Exit
If loss reaches –10% but then recovers to 0%, exit at breakeven.
4️⃣ Trend-Reversal Exit
If price closes below 5m EMA50, the long is exited instantly.
5️⃣ Optional Intraday Exit
EOD square-off at 3:15 PM.
6️⃣ Alerts for Automation
The strategy provides alerts for:
BUY entry
TP/SL/Trailing exit
EMA50 reversal exit
EOD exit
Nifty Breakout Levels Strategy (v7 Hybrid)Nifty Breakout Levels Strategy (v7 Hybrid – Compounding from Start Date)
Instrument / TF: Designed for current-month NIFTY futures on 1-hour timeframe, with at most 1 trade per day.
Entry logic: Uses a 10-bar breakout box with a 0.3% buffer, plus EMA-based trend + proximity filter.
Longs: price in breakout-high zone, above EMA50/EMA200 and within proximityPts.
Shorts: price in breakout-low zone and strong downtrend (EMA10 < EMA20 < EMA50 < EMA200, price below EMA200).
Trades only when ATR(14) > atrTradeThresh and during regular hours (till 15:15).
Risk / exits: Stop loss is ATR-adaptive – max of slBasePoints (100 pts) and ATR * atrSLFactor; TP is fixed (tpPoints, e.g. 350 pts).
Longs have stepped trailing profit levels (100/150/200/250/320 pts) that lock in gains on pullbacks.
Shorts have trailing loss-reduction levels (80/120/140 pts) to cut improving losses.
Additional exit: 1H EMA50 2-bar reversal against the position, plus optional EOD flatten at 3:15 PM.
Compounding engine: From a chosen start date, equity is rebased to startCapital, and lot size scales dynamically as equity / capitalPerLot, with automatic lot reductions at three drawdown thresholds (ddCut1 / 2 / 3).
Automation: All entries and exits are exposed via alertconditions (long/short entry & exit) so the strategy can be connected to broker/webhook automation.
Price Action Concepts [RUDYINDICATOR]/// This work is licensed under a Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0) creativecommons.org
// © RUDYBANK INDICATOR - formerly know as RUDY INDICATOR
//@version=5
indicator("Price Action Concepts ", shorttitle = "RUDYINDICATOR-V1
- Price Action RUDYINDICATOR ", overlay = true, max_lines_count = 500, max_labels_count = 500, max_boxes_count = 500, max_bars_back = 500, max_polylines_count = 100)
//-----------------------------------------------------------------------------{
//Boolean set
//-----------------------------------------------------------------------------{
s_BOS = 0
s_CHoCH = 1
i_BOS = 2
i_CHoCH = 3
i_pp_CHoCH = 4
green_candle = 5
red_candle = 6
s_CHoCHP = 7
i_CHoCHP = 8
boolean =
array.from(
false
, false
, false
, false
, false
, false
, false
, false
, false
)
//-----------------------------------------------------------------------------{
// User inputs
//-----------------------------------------------------------------------------{
show_swing_ms = input.string ("All" , "Swing        " , inline = "1", group = "MARKET STRUCTURE" , options = )
show_internal_ms = input.string ("All" , "Internal     " , inline = "2", group = "MARKET STRUCTURE" , options = )
internal_r_lookback = input.int (5 , "" , inline = "2", group = "MARKET STRUCTURE" , minval = 2)
swing_r_lookback = input.int (50 , "" , inline = "1", group = "MARKET STRUCTURE" , minval = 2)
ms_mode = input.string ("Manual" , "Market Structure Mode" , inline = "a", group = "MARKET STRUCTURE" , tooltip = " Use selected lenght\n Use automatic lenght" ,options = )
show_mtf_str = input.bool (true , "MTF Scanner" , inline = "9", group = "MARKET STRUCTURE" , tooltip = "Display Multi-Timeframe Market Structure Trend Directions. Green = Bullish. Red = Bearish")
show_eql = input.bool (false , "Show EQH/EQL" , inline = "6", group = "MARKET STRUCTURE")
plotcandle_bool = input.bool (false , "Plotcandle" , inline = "3", group = "MARKET STRUCTURE" , tooltip = "Displays a cleaner colored candlestick chart in place of the default candles. (requires hiding the current ticker candles)")
barcolor_bool = input.bool (false , "Bar Color" , inline = "4", group = "MARKET STRUCTURE" , tooltip = "Color the candle bodies according to market strucutre trend")
i_ms_up_BOS = input.color (#089981 , "" , inline = "2", group = "MARKET STRUCTURE")
i_ms_dn_BOS = input.color (#f23645 , "" , inline = "2", group = "MARKET STRUCTURE")
s_ms_up_BOS = input.color (#089981 , "" , inline = "1", group = "MARKET STRUCTURE")
s_ms_dn_BOS = input.color (#f23645 , "" , inline = "1", group = "MARKET STRUCTURE")
lvl_daily = input.bool (false , "Day   " , inline = "1", group = "HIGHS & LOWS MTF")
lvl_weekly = input.bool (false , "Week " , inline = "2", group = "HIGHS & LOWS MTF")
lvl_monthly = input.bool (false , "Month" , inline = "3", group = "HIGHS & LOWS MTF")
lvl_yearly = input.bool (false , "Year  " , inline = "4", group = "HIGHS & LOWS MTF")
css_d = input.color (color.blue , "" , inline = "1", group = "HIGHS & LOWS MTF")
css_w = input.color (color.blue , "" , inline = "2", group = "HIGHS & LOWS MTF")
css_m = input.color (color.blue , "" , inline = "3", group = "HIGHS & LOWS MTF")
css_y = input.color (color.blue , "" , inline = "4", group = "HIGHS & LOWS MTF")
s_d = input.string ('⎯⎯⎯' , '' , inline = '1', group = 'HIGHS & LOWS MTF' , options = )
s_w = input.string ('⎯⎯⎯' , '' , inline = '2', group = 'HIGHS & LOWS MTF' , options = )
s_m = input.string ('⎯⎯⎯' , '' , inline = '3', group = 'HIGHS & LOWS MTF' , options = )
s_y = input.string ('⎯⎯⎯' , '' , inline = '4', group = 'HIGHS & LOWS MTF' , options = )
ob_show = input.bool (true , "Show Last    " , inline = "1", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Display volumetric order blocks on the chart \n\n Ammount of volumetric order blocks to show")
ob_num = input.int (5 , "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Orderblocks number", minval = 1, maxval = 10)
ob_metrics_show = input.bool (true , "Internal Buy/Sell Activity" , inline = "2", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Display volume metrics that have formed the orderblock")
css_metric_up = input.color (color.new(#089981, 50) , "         " , inline = "2", group = "VOLUMETRIC ORDER BLOCKS")
css_metric_dn = input.color (color.new(#f23645 , 50) , "" , inline = "2", group = "VOLUMETRIC ORDER BLOCKS")
ob_swings = input.bool (false , "Swing Order Blocks" , inline = "a", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Display swing volumetric order blocks")
css_swing_up = input.color (color.new(color.gray , 90) , "                 " , inline = "a", group = "VOLUMETRIC ORDER BLOCKS")
css_swing_dn = input.color (color.new(color.silver, 90) , "" , inline = "a", group = "VOLUMETRIC ORDER BLOCKS")
ob_filter = input.string ("None" , "Filtering             " , inline = "d", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Filter out volumetric order blocks by BOS/CHoCH/CHoCH+", options = )
ob_mitigation = input.string ("Absolute" , "Mitigation           " , inline = "4", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Trigger to remove volumetric order blocks", options = )
ob_pos = input.string ("Precise" , "Positioning          " , inline = "k", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Position of the Order Block\n Cover the whole candle\n Cover half candle\n Adjust to volatility\n Same as Accurate but more precise", options = )
use_grayscale = input.bool (false , "Grayscale" , inline = "6", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Use gray as basic order blocks color")
use_show_metric = input.bool (true , "Show Metrics" , inline = "7", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Show volume associated with the orderblock and his relevance")
use_middle_line = input.bool (true , "Show Middle-Line" , inline = "8", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Show mid-line order blocks")
use_overlap = input.bool (true , "Hide Overlap" , inline = "9", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Hide overlapping order blocks")
use_overlap_method = input.string ("Previous" , "Overlap Method    " , inline = "Z", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = " Preserve the most recent volumetric order blocks\n\n Preserve the previous volumetric order blocks", options = )
ob_bull_css = input.color (color.new(#089981 , 90) , "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS")
ob_bear_css = input.color (color.new(#f23645 , 90) , "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS")
show_acc_dist_zone = input.bool (false , "" , inline = "1", group = "Accumulation And Distribution")
zone_mode = input.string ("Fast" , "" , inline = "1", group = "Accumulation And Distribution" , tooltip = " Find small zone pattern formation\n Find bigger zone pattern formation" ,options = )
acc_css = input.color (color.new(#089981 , 60) , "" , inline = "1", group = "Accumulation And Distribution")
dist_css = input.color (color.new(#f23645 , 60) , "" , inline = "1", group = "Accumulation And Distribution")
show_lbl = input.bool (false , "Show swing point" , inline = "1", group = "High and Low" , tooltip = "Display swing point")
show_mtb = input.bool (false , "Show High/Low/Equilibrium" , inline = "2", group = "High and Low" , tooltip = "Display Strong/Weak High And Low and Equilibrium")
toplvl = input.color (color.red , "Premium Zone   " , inline = "3", group = "High and Low")
midlvl = input.color (color.gray , "Equilibrium Zone" , inline = "4", group = "High and Low")
btmlvl = input.color (#089981 , "Discount Zone    " , inline = "5", group = "High and Low")
fvg_enable = input.bool (false , "        " , inline = "1", group = "FAIR VALUE GAP" , tooltip = "Display fair value gap")
what_fvg = input.string ("FVG" , "" , inline = "1", group = "FAIR VALUE GAP" , tooltip = "Display fair value gap", options = )
fvg_num = input.int (5 , "Show Last  " , inline = "1a", group = "FAIR VALUE GAP" , tooltip = "Number of fvg to show")
fvg_upcss = input.color (color.new(#089981, 80) , "" , inline = "1", group = "FAIR VALUE GAP")
fvg_dncss = input.color (color.new(color.red , 80) , "" , inline = "1", group = "FAIR VALUE GAP")
fvg_extend = input.int (10 , "Extend FVG" , inline = "2", group = "FAIR VALUE GAP" , tooltip = "Extend the display of the FVG.")
fvg_src = input.string ("Close" , "Mitigation  " , inline = "3", group = "FAIR VALUE GAP" , tooltip = " Use the close of the body as trigger\n\n Use the extreme point of the body as trigger", options = )
fvg_tf = input.timeframe ("" , "Timeframe " , inline = "4", group = "FAIR VALUE GAP" , tooltip = "Timeframe of the fair value gap")
t = color.t (ob_bull_css)
invcol = color.new (color.white , 100)
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - UDT }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
type bar
float o = open
float c = close
float h = high
float l = low
float v = volume
int n = bar_index
int t = time
type Zphl
line top
line bottom
label top_label
label bottom_label
bool stopcross
bool sbottomcross
bool itopcross
bool ibottomcross
string txtup
string txtdn
float topy
float bottomy
float topx
float bottomx
float tup
float tdn
int tupx
int tdnx
float itopy
float itopx
float ibottomy
float ibottomx
float uV
float dV
type FVG
box box
line ln
bool bull
float top
float btm
int left
int right
type ms
float p
int n
float l
type msDraw
int n
float p
color css
string txt
bool bull
type obC
float top
float btm
int left
float avg
float dV
float cV
int wM
int blVP
int brVP
int dir
float h
float l
int n
type obD
box ob
box eOB
box blB
box brB
line mL
type zone
chart.point points
float p
int c
int t
type hqlzone
box pbx
box ebx
box lbx
label plb
label elb
label lbl
type ehl
float pt
int t
float pb
int b
type pattern
string found = "None"
bool isfound = false
int period = 0
bool bull = false
type alerts
bool chochswing = false
bool chochplusswing = false
bool swingbos = false
bool chochplus = false
bool choch = false
bool bos = false
bool equal = false
bool ob = false
bool swingob = false
bool zone = false
bool fvg = false
bool obtouch = false
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - General Setup }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
bar b = bar.new()
var pattern p = pattern.new()
alerts blalert = alerts.new()
alerts bralert = alerts.new()
if p.isfound
p.period += 1
if p.period == 50
p.period := 0
p.found := "None"
p.isfound := false
p.bull := na
switch
b.c > b.o => boolean.set(green_candle, true)
b.c < b.o => boolean.set(red_candle , true)
f_zscore(src, lookback) =>
(src - ta.sma(src, lookback)) / ta.stdev(src, lookback)
var int iLen = internal_r_lookback
var int sLen = swing_r_lookback
vv = f_zscore(((close - close ) / close ) * 100,iLen)
if ms_mode == "Dynamic"
switch
vv >= 1.5 or vv <= -1.5 => iLen := 10
vv >= 1.6 or vv <= -1.6 => iLen := 9
vv >= 1.7 or vv <= -1.7 => iLen := 8
vv >= 1.8 or vv <= -1.8 => iLen := 7
vv >= 1.9 or vv <= -1.9 => iLen := 6
vv >= 2.0 or vv <= -2.0 => iLen := 5
=> iLen
var msline = array.new(0)
iH = ta.pivothigh(high, iLen, iLen)
sH = ta.pivothigh(high, sLen, sLen)
iL = ta.pivotlow (low , iLen, iLen)
sL = ta.pivotlow (low , sLen, sLen)
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - ARRAYS }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
hl () =>
= request.security(syminfo.tickerid , 'D' , hl() , lookahead = barmerge.lookahead_on)
= request.security(syminfo.tickerid , 'W' , hl() , lookahead = barmerge.lookahead_on)
= request.security(syminfo.tickerid , 'M' , hl() , lookahead = barmerge.lookahead_on)
= request.security(syminfo.tickerid , '12M', hl() , lookahead = barmerge.lookahead_on)
lstyle(style) =>
out = switch style
'⎯⎯⎯' => line.style_solid
'----' => line.style_dashed
'····' => line.style_dotted
mtfphl(h, l ,tf ,css, pdhl_style) =>
var line hl = line.new(
na
, na
, na
, na
, xloc = xloc.bar_time
, color = css
, style = lstyle(pdhl_style)
)
var line ll = line.new(
na
, na
, na
, na
, xloc = xloc.bar_time
, color = css
, style = lstyle(pdhl_style)
)
var label lbl = label.new(
na
, na
, xloc = xloc.bar_time
, text = str.format('P{0}L', tf)
, color = invcol
, textcolor = css
, size = size.small
, style = label.style_label_left
)
var label hlb = label.new(
na
, na
, xloc = xloc.bar_time
, text = str.format('P{0}H', tf)
, color = invcol
, 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
extension = time + (time - time ) * 50
line.set_xy1(hl , hx , hy)
line.set_xy2(hl , extension , hy)
label.set_xy(hlb, extension , hy)
line.set_xy1(ll , lx , ly)
line.set_xy2(ll , extension , ly)
label.set_xy(lbl, extension , ly)
if lvl_daily
mtfphl(pdh , pdl , 'D' , css_d, s_d)
if lvl_weekly
mtfphl(pwh , pwl , 'W' , css_w, s_w)
if lvl_monthly
mtfphl(pmh , pml, 'M' , css_m, s_m)
if lvl_yearly
mtfphl(pyh , pyl , '12M', css_y, s_y)
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - Market Structure }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
method darkcss(color css, float factor, bool bull) =>
blue = color.b(css) * (1 - factor)
red = color.r(css) * (1 - factor)
green = color.g(css) * (1 - factor)
color.rgb(red, green, blue, 0)
method f_line(msDraw d, size, style) =>
var line id = na
var label lbl = na
id := line.new(
d.n
, d.p
, b.n
, d.p
, color = d.css
, width = 1
, style = style
)
if msline.size() >= 250
line.delete(msline.shift())
msline.push(id)
lbl := label.new(
int(math.avg(d.n, b.n))
, d.p
, d.txt
, color = invcol
, textcolor = d.css
, style = d.bull ? label.style_label_down : label.style_label_up
, size = size
, text_font_family = font.family_monospace
)
structure(bool mtf) =>
msDraw drw = na
bool isdrw = false
bool isdrwS = false
var color css = na
var color icss = na
var int itrend = 0
var int trend = 0
bool bull_ob = false
bool bear_ob = false
bool s_bull_ob = false
bool s_bear_ob = false
n = bar_index
var ms up = ms.new(
array.new()
, array.new< int >()
, array.new()
)
var ms dn = ms.new(
array.new()
, array.new< int >()
, array.new()
)
var ms sup = ms.new(
array.new()
, array.new< int >()
, array.new()
)
var ms sdn = ms.new(
array.new()
, array.new< int >()
, array.new()
)
switch show_swing_ms
"All" => boolean.set(s_BOS , true ), boolean.set(s_CHoCH, true ) , boolean.set(s_CHoCHP, true )
"CHoCH" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, true ) , boolean.set(s_CHoCHP, false )
"CHoCH+" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, false) , boolean.set(s_CHoCHP, true )
"BOS" => boolean.set(s_BOS , true ), boolean.set(s_CHoCH, false) , boolean.set(s_CHoCHP, false )
"None" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, false) , boolean.set(s_CHoCHP, false )
=> na
switch show_internal_ms
"All" => boolean.set(i_BOS, true ), boolean.set(i_CHoCH, true ), boolean.set(i_CHoCHP, true )
"CHoCH" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, true ), boolean.set(i_CHoCHP, false)
"CHoCH+" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, false ), boolean.set(i_CHoCHP, true )
"BOS" => boolean.set(i_BOS, true ), boolean.set(i_CHoCH, false ), boolean.set(i_CHoCHP, false)
"None" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, false ), boolean.set(i_CHoCHP, false)
=> na
switch
iH =>
up.p.unshift(b.h )
up.l.unshift(b.h )
up.n.unshift(n )
iL =>
dn.p.unshift(b.l )
dn.l.unshift(b.l )
dn.n.unshift(n )
sL =>
sdn.p.unshift(b.l )
sdn.l.unshift(b.l )
sdn.n.unshift(n )
sH =>
sup.p.unshift(b.h )
sup.l.unshift(b.h )
sup.n.unshift(n )
// INTERNAL BULLISH STRUCTURE
if up.p.size() > 0 and dn.l.size() > 1
if ta.crossover(b.c, up.p.first())
bool CHoCH = na
string txt = na
if itrend < 0
CHoCH := true
switch
not CHoCH =>
txt := "BOS"
css := i_ms_up_BOS
blalert.bos := true
if boolean.get(i_BOS) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
up.n.first()
, up.p.first()
, i_ms_up_BOS
, txt
, true
)
CHoCH =>
dn.l.first() > dn.l.get(1) ? blalert.chochplus : blalert.choch
txt := dn.l.first() > dn.l.get(1) ? "CHoCH+" : "CHoCH"
css := i_ms_up_BOS.darkcss(0.25, true)
if (dn.l.first() > dn.l.get(1) ? boolean.get(i_CHoCHP) : boolean.get(i_CHoCH)) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
up.n.first()
, up.p.first()
, i_ms_up_BOS.darkcss(0.25, true)
, txt
, true
)
if mtf == false
switch
ob_filter == "None" => bull_ob := true
ob_filter == "BOS" and txt == "BOS" => bull_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" => bull_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" => bull_ob := true
itrend := 1
up.n.clear()
up.p.clear()
// INTERNAL BEARISH STRUCTURE
if dn.p.size() > 0 and up.l.size() > 1
if ta.crossunder(b.c, dn.p.first())
bool CHoCH = na
string txt = na
if itrend > 0
CHoCH := true
switch
not CHoCH =>
bralert.bos := true
txt := "BOS"
css := i_ms_dn_BOS
if boolean.get(i_BOS) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
dn.n.first()
, dn.p.first()
, i_ms_dn_BOS
, txt
, false
)
CHoCH =>
if up.l.first() < up.l.get(1)
bralert.chochplus := true
else
bralert.choch := true
txt := up.l.first() < up.l.get(1) ? "CHoCH+" : "CHoCH"
css := i_ms_dn_BOS.darkcss(0.25, false)
if (up.l.first() < up.l.get(1) ? boolean.get(i_CHoCHP) : boolean.get(i_CHoCH)) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
dn.n.first()
, dn.p.first()
, i_ms_dn_BOS.darkcss(0.25, false)
, txt
, false
)
if mtf == false
switch
ob_filter == "None" => bear_ob := true
ob_filter == "BOS" and txt == "BOS" => bear_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" => bear_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" => bear_ob := true
itrend := -1
dn.n.clear()
dn.p.clear()
// SWING BULLISH STRUCTURE
if sup.p.size() > 0 and sdn.l.size() > 1
if ta.crossover(b.c, sup.p.first())
bool CHoCH = na
string txt = na
if trend < 0
CHoCH := true
switch
not CHoCH =>
blalert.swingbos := true
txt := "BOS"
icss := s_ms_up_BOS
if boolean.get(s_BOS) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sup.n.first()
, sup.p.first()
, s_ms_up_BOS
, txt
, true
)
CHoCH =>
if sdn.l.first() > sdn.l.get(1)
blalert.chochplusswing := true
else
blalert.chochswing := true
txt := sdn.l.first() > sdn.l.get(1) ? "CHoCH+" : "CHoCH"
icss := s_ms_up_BOS.darkcss(0.25, true)
if (sdn.l.first() > sdn.l.get(1) ? boolean.get(s_CHoCHP) : boolean.get(s_CHoCH)) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sup.n.first()
, sup.p.first()
, s_ms_up_BOS.darkcss(0.25, true)
, txt
, true
)
if mtf == false
switch
ob_filter == "None" => s_bull_ob := true
ob_filter == "BOS" and txt == "BOS" => s_bull_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" => s_bull_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" => s_bull_ob := true
trend := 1
sup.n.clear()
sup.p.clear()
// SWING BEARISH STRUCTURE
if sdn.p.size() > 0 and sup.l.size() > 1
if ta.crossunder(b.c, sdn.p.first())
bool CHoCH = na
string txt = na
if trend > 0
CHoCH := true
switch
not CHoCH =>
bralert.swingbos := true
txt := "BOS"
icss := s_ms_dn_BOS
if boolean.get(s_BOS) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sdn.n.first()
, sdn.p.first()
, s_ms_dn_BOS
, txt
, false
)
CHoCH =>
if sup.l.first() < sup.l.get(1)
bralert.chochplusswing := true
else
bralert.chochswing := true
txt := sup.l.first() < sup.l.get(1) ? "CHoCH+" : "CHoCH"
icss := s_ms_dn_BOS.darkcss(0.25, false)
if (sup.l.first() < sup.l.get(1) ? boolean.get(s_CHoCHP) : boolean.get(s_CHoCH)) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sdn.n.first()
, sdn.p.first()
, s_ms_dn_BOS.darkcss(0.25, false)
, txt
, false
)
if mtf == false
switch
ob_filter == "None" => s_bear_ob := true
ob_filter == "BOS" and txt == "BOS" => s_bear_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" => s_bear_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" => s_bear_ob := true
trend := -1
sdn.n.clear()
sdn.p.clear()
= structure(false)
if isdrw
f_line(drw, size.small, line.style_dashed)
if isdrwS
f_line(drw, size.small, line.style_solid)
= request.security("", "15" , structure(true))
= request.security("", "60" , structure(true))
= request.security("", "240" , structure(true))
= request.security("", "1440" , structure(true))
if show_mtf_str
var tab = table.new(position = position.top_right, columns = 10, rows = 10, bgcolor = na, frame_color = color.rgb(54, 58, 69, 0), frame_width = 1, border_color = color.rgb(54, 58, 69, 100), border_width = 1)
table.cell(tab, 0, 1, text = "15" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2)
table.cell(tab, 0, 2, text = "1H" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2)
table.cell(tab, 0, 3, text = "4H" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2)
table.cell(tab, 0, 4, text = "1D" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2)
table.cell(tab, 1, 1, text = itrend15 == 1 ? "BULLISH" : itrend15 == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend15 == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend15 == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 1, 2, text = itrend1H == 1 ? "BULLISH" : itrend1H == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend1H == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1H == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 1, 3, text = itrend4H == 1 ? "BULLISH" : itrend4H == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend4H == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend4H == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 1, 4, text = itrend1D == 1 ? "BULLISH" : itrend1D == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend1D == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1D == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 0, 5, text = "Detected Pattern", text_halign = text.align_center, text_size = size.normal, text_color = color.silver, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 0, 6, text = p.found, text_halign = text.align_center, text_size = size.normal, text_color = na(p.bull) ? color.white : p.bull ? i_ms_up_BOS.darkcss(-0.25, true) : p.bull == false ? i_ms_dn_BOS.darkcss(0.25, false) : na, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.merge_cells(tab, 0, 5, 1, 5)
table.merge_cells(tab, 0, 6, 1, 6)
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - Strong/Weak High/Low And Equilibrium }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
var phl = Zphl.new(
na
, na
, label.new(na , na , color = invcol , textcolor = i_ms_dn_BOS , style = label.style_label_down , size = size.tiny , text = "")
, label.new(na , na , color = invcol , textcolor = i_ms_up_BOS , style = label.style_label_up , size = size.tiny , text = "")
, true
, true
, true
, true
, ""
, ""
, 0
, 0
, 0
, 0
, high
, low
, 0
, 0
, 0
, 0
, 0
, 0
, na
, na
)
zhl(len)=>
upper = ta.highest(len)
lower = ta.lowest(len)
var float out = 0
out := b.h > upper ? 0 : b.l < lower ? 1 : out
top = out == 0 and out != 0 ? b.h : 0
btm = out == 1 and out != 1 ? b.l : 0
= zhl(sLen)
= zhl(iLen)
upphl(trend) =>
var label lbl = label.new(
na
, na
, color = invcol
, textcolor = toplvl
, style = label.style_label_down
, size = size.small
)
if top
phl.stopcross := true
phl.txtup := top > phl.topy ? "HH" : "HL"
if show_lbl
topl = label.new(
b.n - swing_r_lookback
, top
, phl.txtup
, color = invcol
, textcolor = toplvl
, style = label.style_label_down
, size = size.small
)
line.delete(phl.top )
phl.top := line.new(
b.n - sLen
, top
, b.n
, top
, color = toplvl)
phl.topy := top
phl.topx := b.n - sLen
phl.tup := top
phl.tupx := b.n - sLen
if itop
phl.itopcross := true
phl.itopy := itop
phl.itopx := b.n - iLen
phl.tup := math.max(high, phl.tup)
phl.tupx := phl.tup == high ? b.n : phl.tupx
phl.uV := phl.tup != phl.tup ? b.v : phl.uV
if barstate.islast
line.set_xy1(
phl.top
, phl.tupx
, phl.tup
)
line.set_xy2(
phl.top
, b.n + 50
, phl.tup
)
label.set_x(
lbl
, b.n + 50
)
label.set_y(
lbl
, phl.tup
)
dist = math.abs(phl.uV / (phl.uV + phl.dV)) * 100
label.set_text (lbl, trend < 0
? "Strong High | " + str.tostring(phl.uV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)"
: "Weak High | " + str.tostring(phl.uV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)")
dnphl(trend) =>
var label lbl = label.new(
na
, na
, color = invcol
, textcolor = btmlvl
, style = label.style_label_up
, size = size.small
)
if btm
phl.sbottomcross := true
phl.txtdn := btm > phl.bottomy ? "LH" : "LL"
if show_lbl
btml = label.new(
b.n - swing_r_lookback
, btm, phl.txtdn
, color = invcol
, textcolor = btmlvl
, style = label.style_label_up
, size = size.small
)
line.delete(phl.bottom )
phl.bottom := line.new(
b.n - sLen
, btm
, b.n
, btm
, color = btmlvl
)
phl.bottomy := btm
phl.bottomx := b.n - sLen
phl.tdn := btm
phl.tdnx := b.n - sLen
if ibtm
phl.ibottomcross := true
phl.ibottomy := ibtm
phl.ibottomx := b.n - iLen
phl.tdn := math.min(low, phl.tdn)
phl.tdnx := phl.tdn == low ? b.n : phl.tdnx
phl.dV := phl.tdn != phl.tdn ? b.v : phl.dV
if barstate.islast
line.set_xy1(
phl.bottom
, phl.tdnx
, phl.tdn
)
line.set_xy2(
phl.bottom
, b.n + 50
, phl.tdn
)
label.set_x(
lbl
, b.n + 50
)
label.set_y(
lbl
, phl.tdn
)
dist = math.abs(phl.dV / (phl.uV + phl.dV)) * 100
label.set_text (lbl, trend > 0
? "Strong Low | " + str.tostring(phl.dV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)"
: "Weak Low | " + str.tostring(phl.uV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)")
midphl() =>
avg = math.avg(phl.bottom.get_y2(), phl.top.get_y2())
var line l = line.new(
y1 = avg
, y2 = avg
, x1 = b.n - sLen
, x2 = b.n + 50
, color = midlvl
, style = line.style_solid
)
var label lbl = label.new(
x = b.n + 50
, y = avg
, text = "Equilibrium"
, style = label.style_label_left
, color = invcol
, textcolor = midlvl
, size = size.small
)
if barstate.islast
more = (phl.bottom.get_x1() + phl.bottom.get_x2()) > (phl.top.get_x1() + phl.top.get_x2()) ? phl.top.get_x1() : phl.bottom.get_x1()
line.set_xy1(l , more , avg)
line.set_xy2(l , b.n + 50, avg)
label.set_x (lbl , b.n + 50 )
label.set_y (lbl , avg )
dist = math.abs((l.get_y2() - close) / close) * 100
label.set_text (lbl, "Equilibrium (" + str.tostring(math.round(dist,0)) + "%)")
hqlzone() =>
if barstate.islast
var hqlzone dZone = hqlzone.new(
box.new(
na
, na
, na
, na
, bgcolor = color.new(toplvl, 70)
, border_color = na
)
, box.new(
na
, na
, na
, na
, bgcolor = color.new(midlvl, 70)
, border_color = na
)
, box.new(
na
, na
, na
, na
, bgcolor = color.new(btmlvl, 70)
, border_color = na
)
, label.new(na, na, text = "Premium" , color = invcol, textcolor = toplvl, style = label.style_label_down, size = size.small)
, label.new(na, na, text = "Equilibrium", color = invcol, textcolor = midlvl, style = label.style_label_left, size = size.small)
, label.new(na, na, text = "Discount" , color = invcol, textcolor = btmlvl, style = label.style_label_up , size = size.small)
)
dZone.pbx.set_lefttop(int(math.max(phl.topx, phl.bottomx)) , phl.tup)
dZone.pbx.set_rightbottom(b.n + 50 , 0.95 * phl.tup + 0.05 * phl.tdn)
dZone.ebx.set_lefttop(int(math.max(phl.topx, phl.bottomx)), 0.525 * phl.tup + 0.475 * phl.tdn)
dZone.ebx.set_rightbottom(b.n + 50 , 0.525 * phl.tdn + 0.475 * phl.tup)
dZone.lbx.set_lefttop(int(math.max(phl.topx, phl.bottomx)), 0.95 * phl.tdn + 0.05 * phl.tup)
dZone.lbx.set_rightbottom(b.n + 50 , phl.tdn)
dZone.plb.set_xy( int(math.avg(math.max(phl.topx, phl.bottomx), int(b.n + 50))) , phl.tup)
dZone.elb.set_xy( int(b.n + 50) , math.avg(phl.tup, phl.tdn))
dZone.lbl.set_xy( int(math.avg(math.max(phl.topx, phl.bottomx), int(b.n + 50))) , phl.tdn)
if show_mtb
upphl (trend)
dnphl (trend)
hqlzone()
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - Volumetric Order Block }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
method eB(box b, bool ext, color css, bool swing) =>
b.unshift(
box.new(
na
, na
, na
, na
, xloc = xloc.bar_time
, text_font_family = font.family_monospace
, extend = ext ? extend.right : extend.none
, border_color = swing ? color.new(css, 0) : color.new(color.white,100)
, bgcolor = css
, border_width = 1
)
)
method eL(line l, bool ext, bool solid, color css) =>
l.unshift(
line.new(
na
, na
, na
, na
, width = 1
, color = css
, xloc = xloc.bar_time
, extend = ext ? extend.right : extend.none
, style = solid ? line.style_solid : line.style_dashed
)
)
method drawVOB(bool cdn, bool bull, color css, int loc, bool swing) =>
= request.security(
syminfo.tickerid
, ""
,
, lookahead = barmerge.lookahead_off
)
var obC obj = obC.new(
array.new()
, array.new()
, array.new< int >()
, array.new()
, array.new()
, array.new()
, array.new< int >()
, array.new< int >()
, array.new< int >()
, array.new< int >()
, array.new()
, array.new()
, array.new< int >()
)
var obD draw = obD.new(
array.new()
, array.new()
, array.new()
, array.new()
, array.new()
)
if barstate.isfirst
for i = 0 to ob_num - 1
draw.mL .eL(false, false, use_grayscale ? color.new(color.gray, 0) : color.new(css,0))
draw.ob .eB(false, use_grayscale ? color.new(color.gray, 90) : css, swing)
draw.blB.eB(false, css_metric_up , swing)
draw.brB.eB(false, css_metric_dn , swing)
draw.eOB.eB(true , use_grayscale ? color.new(color.gray, 90) : css, swing)
float pos = ob_pos == "Full"
? (bull ? high : low)
: ob_pos == "Middle"
? ohlc4
: ob_pos == "Accurate"
? hl2
: hl2
if cdn
obj.h.clear()
obj.l.clear()
obj.n.clear()
for i = 0 to math.abs((loc - b.n)) - 1
obj.h.push(hH )
obj.l.push(lL )
obj.n.push(b.t )
// obj.h.reverse()
// obj.l.reverse()
int iU = obj.l.indexof(obj.l.min()) + 1
int iD = obj.h.indexof(obj.h.max()) + 1
obj.dir.unshift(
bull
? (b.c > b.o ? 1 : -1)
: (b.c > b.o ? 1 : -1)
)
obj.top.unshift(
bull
? pos
: obj.h.max()
)
obj.btm.unshift(
bull
? obj.l.min()
: pos
)
obj.left.unshift(
bull
? obj.n.get(obj.l.indexof(obj.l.min()))
: obj.n.get(obj.h.indexof(obj.h.max()))
)
obj.avg.unshift(
math.avg(obj.top.first(), obj.btm.first())
)
obj.cV.unshift(
bull
? b.v
: b.v
)
if ob_pos == "Precise"
switch bull
true =>
if obj.avg.get(0) < (b.c < b.o ? b.c : b.o ) and obj.top.get(0) > hlcc4
obj.top.set(0, obj.avg.get(0))
obj.avg.set(0, math.avg(obj.top.first(), obj.btm.first()))
false =>
if obj.avg.get(0) > (b.c < b.o ? b.o : b.c ) and obj.btm.get(0) < hlcc4
obj.btm.set(0, obj.avg.get(0))
obj.avg.set(0, math.avg(obj.top.first(), obj.btm.first()))
obj.blVP.unshift ( 0 )
obj.brVP.unshift ( 0 )
obj.wM .unshift ( 1 )
if use_overlap
int rmP = use_overlap_method == "Recent" ? 1 : 0
if obj.avg.size() > 1
if bull
? obj.btm.first() < obj.top.get(1)
: obj.top.first() > obj.btm.get(1)
obj.wM .remove(rmP)
obj.cV .remove(rmP)
obj.dir .remove(rmP)
obj.top .remove(rmP)
obj.avg .remove(rmP)
obj.btm .remove(rmP)
obj.left .remove(rmP)
obj.blVP .remove(rmP)
obj.brVP .remove(rmP)
if barstate.isconfirmed
for x = 0 to ob_num - 1
tg = switch ob_mitigation
"Middle" => obj.avg
"Absolute" => bull ? obj.btm : obj.top
for in tg
if (bull ? cC < pt : cC > pt)
obj.wM .remove(idx)
obj.cV .remove(idx)
obj.dir .remove(idx)
obj.top .remove(idx)
obj.avg .remove(idx)
obj.btm .remove(idx)
obj.left .remove(idx)
obj.blVP .remove(idx)
obj.brVP .remove(idx)
if barstate.islast
if obj.avg.size() > 0
// Alert
if bull
? ta.crossunder(low , obj.top.get(0))
: ta.crossover (high, obj.btm.get(0))
switch bull
true => blalert.obtouch := true
false => bralert.obtouch := true
float tV = 0
obj.dV.clear()
seq = math.min(ob_num - 1, obj.avg.size() - 1)
for j = 0 to seq
tV += obj.cV.get(j)
if j == seq
for y = 0 to seq
obj.dV.unshift(
math.floor(
(obj.cV.get(y) / tV) * 100)
)
obj.dV.reverse()
for i = 0 to math.min(ob_num - 1, obj.avg.size() - 1)
dmL = draw.mL .get(i)
dOB = draw.ob .get(i)
dblB = draw.blB.get(i)
dbrB = draw.brB.get(i)
deOB = draw.eOB.get(i)
dOB.set_lefttop (obj.left .get(i) , obj.top.get(i))
deOB.set_lefttop (b.t , obj.top.get(i))
dOB.set_rightbottom (b.t , obj.btm.get(i))
deOB.set_rightbottom(b.t + (b.t - b.t ) * 100 , obj.btm.get(i))
if use_middle_line
dmL.set_xy1(obj.left.get(i), obj.avg.get(i))
dmL.set_xy2(b.t , obj.avg.get(i))
if ob_metrics_show
dblB.set_lefttop (obj.left.get(i), obj.top.get(i))
dbrB.set_lefttop (obj.left.get(i), obj.avg.get(i))
dblB.set_rightbottom(obj.left.get(i), obj.avg.get(i))
dbrB.set_rightbottom(obj.left.get(i), obj.btm.get(i))
rpBL = dblB.get_right()
rpBR = dbrB.get_right()
dbrB.set_right(rpBR + (b.t - b.t ) * obj.brVP.get(i))
dblB.set_right(rpBL + (b.t - b.t ) * obj.blVP.get(i))
if use_show_metric
txt = switch
obj.cV.get(i) >= 1000000000 => str.tostring(math.round(obj.cV.get(i) / 1000000000,3)) + "B"
obj.cV.get(i) >= 1000000 => str.tostring(math.round(obj.cV.get(i) / 1000000,3)) + "M"
obj.cV.get(i) >= 1000 => str.tostring(math.round(obj.cV.get(i) / 1000,3)) + "K"
obj.cV.get(i) < 1000 => str.tostring(math.round(obj.cV.get(i)))
deOB.set_text(
str.tostring(
txt + " (" + str.tostring(obj.dV.get(i)) + "%)")
)
deOB.set_text_size (size.auto)
deOB.set_text_halign(text.align_left)
deOB.set_text_color (use_grayscale ? color.silver : color.new(css, 0))
if ob_metrics_show and barstate.isconfirmed
if obj.wM.size() > 0
for i = 0 to obj.avg.size() - 1
switch obj.dir.get(i)
1 =>
switch obj.wM.get(i)
1 => obj.blVP.set(i, obj.blVP.get(i) + 1), obj.wM.set(i, 2)
2 => obj.blVP.set(i, obj.blVP.get(i) + 1), obj.wM.set(i, 3)
3 => obj.brVP.set(i, obj.brVP.get(i) + 1), obj.wM.set(i, 1)
-1 =>
switch obj.wM.get(i)
1 => obj.brVP.set(i, obj.brVP.get(i) + 1), obj.wM.set(i, 2)
2 => obj.brVP.set(i, obj.brVP.get(i) + 1), obj.wM.set(i, 3)
3 => obj.blVP.set(i, obj.blVP.get(i) + 1), obj.wM.set(i, 1)
var hN = array.new(1, b.n)
var lN = array.new(1, b.n)
var hS = array.new(1, b.n)
var lS = array.new(1, b.n)
if iH
hN.pop()
hN.unshift(int(b.n ))
if iL
lN.pop()
lN.unshift(int(b.n ))
if sH
hS.pop()
hS.unshift(int(b.n ))
if sL
lS.pop()
lS.unshift(int(b.n ))
if ob_show
bull_ob.drawVOB(true , ob_bull_css, hN.first(), false)
bear_ob.drawVOB(false, ob_bear_css, lN.first(), false)
if ob_swings
s_bull_ob.drawVOB(true , css_swing_up, hS.first(), true)
s_bear_ob.drawVOB(false, css_swing_dn, lS.first(), true)
if bull_ob
blalert.ob := true
if bear_ob
bralert.ob := true
if s_bull_ob
blalert.swingob := true
if s_bear_ob
blalert.swingob := true
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - FVG | VI | OG }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
ghl() => request.security(syminfo.tickerid, fvg_tf, [high , low , close , open ])
tfG() => request.security(syminfo.tickerid, fvg_tf, )
cG(bool bull) =>
= ghl()
= tfG()
var FVG draw = FVG.new(
array.new()
, array.new()
)
var FVG cords = array.new()
float pup = na
float pdn = na
bool cdn = na
int pos = 2
cc = timeframe.change(fvg_tf)
if barstate.isfirst
for i = 0 to fvg_num - 1
draw.box.unshift(box.new (na, na, na, na, border_color = color.new(color.white, 100), xloc = xloc.bar_time))
draw.ln.unshift (line.new(na, na, na, na, xloc = xloc.bar_time, width = 1, style = line.style_solid))
switch what_fvg
"FVG" =>
pup := bull ? gl : l
pdn := bull ? h : gh
cdn := bull ? gl > h and cc : gh < l and cc
pos := 2
"VI" =>
pup := bull
? (gc > go
? go
: gc)
: (gc > go
? go
: gc )
pdn := bull
? (gc > go
? gc
: go )
: (gc > go
? gc
: go)
cdn := bull
? go > gc and gh >
TenUp Bots S R - Fixed (ta.highest)//@version=5
indicator("TenUp Bots S R - Fixed (ta.highest)", overlay = true)
// Inputs
a = input.int(10, "Sensitivity (bars)", minval = 1, maxval = 9999)
d_pct = input.int(85, "Transparency (%)", minval = 0, maxval = 100)
// Convert 0-100% to 0-255 transparency (color.new uses 0..255)
transp = math.round(d_pct * 255 / 100)
// Colors with transparency applied
resColor = color.new(color.red, transp)
supColor = color.new(color.blue, transp)
// Helper (calculations only)
getRes(len) => ta.highest(high, len)
getSup(len) => ta.lowest(low, len)
// === PLOTS (all in global scope) ===
plot(getRes(a*1), title="Resistance 1", color=resColor, linewidth=2)
plot(getSup(a*1), title="Support 1", color=supColor, linewidth=2)
plot(getRes(a*2), title="Resistance 2", color=resColor, linewidth=2)
plot(getSup(a*2), title="Support 2", color=supColor, linewidth=2)
plot(getRes(a*3), title="Resistance 3", color=resColor, linewidth=2)
plot(getSup(a*3), title="Support 3", color=supColor, linewidth=2)
plot(getRes(a*4), title="Resistance 4", color=resColor, linewidth=2)
plot(getSup(a*4), title="Support 4", color=supColor, linewidth=2)
plot(getRes(a*5), title="Resistance 5", color=resColor, linewidth=2)
plot(getSup(a*5), title="Support 5", color=supColor, linewidth=2)
plot(getRes(a*6), title="Resistance 6", color=resColor, linewidth=2)
plot(getSup(a*6), title="Support 6", color=supColor, linewidth=2)
plot(getRes(a*7), title="Resistance 7", color=resColor, linewidth=2)
plot(getSup(a*7), title="Support 7", color=supColor, linewidth=2)
plot(getRes(a*8), title="Resistance 8", color=resColor, linewidth=2)
plot(getSup(a*8), title="Support 8", color=supColor, linewidth=2)
plot(getRes(a*9), title="Resistance 9", color=resColor, linewidth=2)
plot(getSup(a*9), title="Support 9", color=supColor, linewidth=2)
plot(getRes(a*10), title="Resistance 10", color=resColor, linewidth=2)
plot(getSup(a*10), title="Support 10", color=supColor, linewidth=2)
plot(getRes(a*15), title="Resistance 15", color=resColor, linewidth=2)
plot(getSup(a*15), title="Support 15", color=supColor, linewidth=2)
plot(getRes(a*20), title="Resistance 20", color=resColor, linewidth=2)
plot(getSup(a*20), title="Support 20", color=supColor, linewidth=2)
plot(getRes(a*25), title="Resistance 25", color=resColor, linewidth=2)
plot(getSup(a*25), title="Support 25", color=supColor, linewidth=2)
plot(getRes(a*30), title="Resistance 30", color=resColor, linewidth=2)
plot(getSup(a*30), title="Support 30", color=supColor, linewidth=2)
plot(getRes(a*35), title="Resistance 35", color=resColor, linewidth=2)
plot(getSup(a*35), title="Support 35", color=supColor, linewidth=2)
plot(getRes(a*40), title="Resistance 40", color=resColor, linewidth=2)
plot(getSup(a*40), title="Support 40", color=supColor, linewidth=2)
plot(getRes(a*45), title="Resistance 45", color=resColor, linewidth=2)
plot(getSup(a*45), title="Support 45", color=supColor, linewidth=2)
plot(getRes(a*50), title="Resistance 50", color=resColor, linewidth=2)
plot(getSup(a*50), title="Support 50", color=supColor, linewidth=2)
plot(getRes(a*75), title="Resistance 75", color=resColor, linewidth=2)
plot(getSup(a*75), title="Support 75", color=supColor, linewidth=2)
plot(getRes(a*100), title="Resistance 100", color=resColor, linewidth=2)
plot(getSup(a*100), title="Support 100", color=supColor, linewidth=2)
plot(getRes(a*150), title="Resistance 150", color=resColor, linewidth=2)
plot(getSup(a*150), title="Support 150", color=supColor, linewidth=2)
plot(getRes(a*200), title="Resistance 200", color=resColor, linewidth=2)
plot(getSup(a*200), title="Support 200", color=supColor, linewidth=2)
plot(getRes(a*250), title="Resistance 250", color=resColor, linewidth=2)
plot(getSup(a*250), title="Support 250", color=supColor, linewidth=2)
plot(getRes(a*300), title="Resistance 300", color=resColor, linewidth=2)
plot(getSup(a*300), title="Support 300", color=supColor, linewidth=2)
plot(getRes(a*350), title="Resistance 350", color=resColor, linewidth=2)
plot(getSup(a*350), title="Support 350", color=supColor, linewidth=2)
plot(getRes(a*400), title="Resistance 400", color=resColor, linewidth=2)
plot(getSup(a*400), title="Support 400", color=supColor, linewidth=2)
plot(getRes(a*450), title="Resistance 450", color=resColor, linewidth=2)
plot(getSup(a*450), title="Support 450", color=supColor, linewidth=2)
plot(getRes(a*500), title="Resistance 500", color=resColor, linewidth=2)
plot(getSup(a*500), title="Support 500", color=supColor, linewidth=2)
plot(getRes(a*750), title="Resistance 750", color=resColor, linewidth=2)
plot(getSup(a*750), title="Support 750", color=supColor, linewidth=2)
plot(getRes(a*1000), title="Resistance 1000", color=resColor, linewidth=2)
plot(getSup(a*1000), title="Support 1000", color=supColor, linewidth=2)
plot(getRes(a*1250), title="Resistance 1250", color=resColor, linewidth=2)
plot(getSup(a*1250), title="Support 1250", color=supColor, linewidth=2)
plot(getRes(a*1500), title="Resistance 1500", color=resColor, linewidth=2)
plot(getSup(a*1500), title="Support 1500", color=supColor, linewidth=2)
TenUp Bots S R - Fixed (ta.highest)//@version=5
indicator("TenUp Bots S R - Fixed (ta.highest)", overlay = true)
// Inputs
a = input.int(10, "Sensitivity (bars)", minval = 1, maxval = 9999)
d_pct = input.int(85, "Transparency (%)", minval = 0, maxval = 100)
// Convert 0-100% to 0-255 transparency (color.new uses 0..255)
transp = math.round(d_pct * 255 / 100)
// Colors with transparency applied
resColor = color.new(color.red, transp)
supColor = color.new(color.blue, transp)
// Helper (calculations only)
getRes(len) => ta.highest(high, len)
getSup(len) => ta.lowest(low, len)
// === PLOTS (all in global scope) ===
plot(getRes(a*1), title="Resistance 1", color=resColor, linewidth=2)
plot(getSup(a*1), title="Support 1", color=supColor, linewidth=2)
plot(getRes(a*2), title="Resistance 2", color=resColor, linewidth=2)
plot(getSup(a*2), title="Support 2", color=supColor, linewidth=2)
plot(getRes(a*3), title="Resistance 3", color=resColor, linewidth=2)
plot(getSup(a*3), title="Support 3", color=supColor, linewidth=2)
plot(getRes(a*4), title="Resistance 4", color=resColor, linewidth=2)
plot(getSup(a*4), title="Support 4", color=supColor, linewidth=2)
plot(getRes(a*5), title="Resistance 5", color=resColor, linewidth=2)
plot(getSup(a*5), title="Support 5", color=supColor, linewidth=2)
plot(getRes(a*6), title="Resistance 6", color=resColor, linewidth=2)
plot(getSup(a*6), title="Support 6", color=supColor, linewidth=2)
plot(getRes(a*7), title="Resistance 7", color=resColor, linewidth=2)
plot(getSup(a*7), title="Support 7", color=supColor, linewidth=2)
plot(getRes(a*8), title="Resistance 8", color=resColor, linewidth=2)
plot(getSup(a*8), title="Support 8", color=supColor, linewidth=2)
plot(getRes(a*9), title="Resistance 9", color=resColor, linewidth=2)
plot(getSup(a*9), title="Support 9", color=supColor, linewidth=2)
plot(getRes(a*10), title="Resistance 10", color=resColor, linewidth=2)
plot(getSup(a*10), title="Support 10", color=supColor, linewidth=2)
plot(getRes(a*15), title="Resistance 15", color=resColor, linewidth=2)
plot(getSup(a*15), title="Support 15", color=supColor, linewidth=2)
plot(getRes(a*20), title="Resistance 20", color=resColor, linewidth=2)
plot(getSup(a*20), title="Support 20", color=supColor, linewidth=2)
plot(getRes(a*25), title="Resistance 25", color=resColor, linewidth=2)
plot(getSup(a*25), title="Support 25", color=supColor, linewidth=2)
plot(getRes(a*30), title="Resistance 30", color=resColor, linewidth=2)
plot(getSup(a*30), title="Support 30", color=supColor, linewidth=2)
plot(getRes(a*35), title="Resistance 35", color=resColor, linewidth=2)
plot(getSup(a*35), title="Support 35", color=supColor, linewidth=2)
plot(getRes(a*40), title="Resistance 40", color=resColor, linewidth=2)
plot(getSup(a*40), title="Support 40", color=supColor, linewidth=2)
plot(getRes(a*45), title="Resistance 45", color=resColor, linewidth=2)
plot(getSup(a*45), title="Support 45", color=supColor, linewidth=2)
plot(getRes(a*50), title="Resistance 50", color=resColor, linewidth=2)
plot(getSup(a*50), title="Support 50", color=supColor, linewidth=2)
plot(getRes(a*75), title="Resistance 75", color=resColor, linewidth=2)
plot(getSup(a*75), title="Support 75", color=supColor, linewidth=2)
plot(getRes(a*100), title="Resistance 100", color=resColor, linewidth=2)
plot(getSup(a*100), title="Support 100", color=supColor, linewidth=2)
plot(getRes(a*150), title="Resistance 150", color=resColor, linewidth=2)
plot(getSup(a*150), title="Support 150", color=supColor, linewidth=2)
plot(getRes(a*200), title="Resistance 200", color=resColor, linewidth=2)
plot(getSup(a*200), title="Support 200", color=supColor, linewidth=2)
plot(getRes(a*250), title="Resistance 250", color=resColor, linewidth=2)
plot(getSup(a*250), title="Support 250", color=supColor, linewidth=2)
plot(getRes(a*300), title="Resistance 300", color=resColor, linewidth=2)
plot(getSup(a*300), title="Support 300", color=supColor, linewidth=2)
plot(getRes(a*350), title="Resistance 350", color=resColor, linewidth=2)
plot(getSup(a*350), title="Support 350", color=supColor, linewidth=2)
plot(getRes(a*400), title="Resistance 400", color=resColor, linewidth=2)
plot(getSup(a*400), title="Support 400", color=supColor, linewidth=2)
plot(getRes(a*450), title="Resistance 450", color=resColor, linewidth=2)
plot(getSup(a*450), title="Support 450", color=supColor, linewidth=2)
plot(getRes(a*500), title="Resistance 500", color=resColor, linewidth=2)
plot(getSup(a*500), title="Support 500", color=supColor, linewidth=2)
plot(getRes(a*750), title="Resistance 750", color=resColor, linewidth=2)
plot(getSup(a*750), title="Support 750", color=supColor, linewidth=2)
plot(getRes(a*1000), title="Resistance 1000", color=resColor, linewidth=2)
plot(getSup(a*1000), title="Support 1000", color=supColor, linewidth=2)
plot(getRes(a*1250), title="Resistance 1250", color=resColor, linewidth=2)
plot(getSup(a*1250), title="Support 1250", color=supColor, linewidth=2)
plot(getRes(a*1500), title="Resistance 1500", color=resColor, linewidth=2)
plot(getSup(a*1500), title="Support 1500", color=supColor, linewidth=2)
Elliott Wave + SMC Fusion # Elliott Wave + SMC Fusion
## TITLE:
Elliott Wave + Smart Money Concepts Fusion
---
## SHORT DESCRIPTION:
Automated Elliott Wave pattern detection with Smart Money Concepts confirmation, EWO oscillator integration, and confluence scoring system.
---
## FULL DESCRIPTION:
### 📊 OVERVIEW
This indicator combines three powerful trading methodologies into a unified system:
- **Elliott Wave Theory** - Automated detection of Wave 1-2 impulse patterns
- **Smart Money Concepts (SMC)** - Order Blocks and Fair Value Gaps for institutional confirmation
- **Elliott Wave Oscillator (EWO)** - Momentum-based signal validation
The core concept is to identify high-probability Wave 3 entries by detecting completed Wave 1-2 structures and validating them with SMC and momentum indicators.
---
### 🔧 HOW IT WORKS
**1. Pattern Detection (ZigZag Method)**
- Uses pivot high/low detection to identify swing points
- Validates Wave 2 retracement using Fibonacci ratios (default: 38.2% - 88.6%)
- Requires minimum wave size to filter noise
- Applies confirmation bars to avoid premature signals
**2. Wave Projections**
- Wave 3 target: Fibonacci extension of Wave 1 (default: 1.618)
- Wave 4 retracement: Percentage of Wave 3 (default: 38.2%)
- Wave 5 projection: Extension of Wave 1 from Wave 4
**3. Smart Money Validation**
- **Order Blocks**: Identifies last opposing candle before breakout (institutional footprint)
- **Fair Value Gaps**: Detects price imbalances for potential support/resistance
**4. EWO Confirmation**
- Calculates momentum: (EMA5 / EMA34 - 1) × 100
- Signal line crossovers confirm trend direction
- Strong signals occur at extremes (< -13 or > 13 threshold)
**5. Confluence Scoring (0-100%)**
Points awarded for:
- Fibonacci quality of Wave 2 retracement (10-30 pts)
- Order Block presence (15 pts)
- Fair Value Gap presence (10 pts)
- Volume confirmation (10-15 pts)
- Trend alignment with EMA50 (10 pts)
- EWO confirmation (10-20 pts)
---
### 🎯 UNIQUE FEATURES
**Pattern Locking System**
- Once a valid pattern is detected, it locks until:
- Pattern invalidates (price breaks Wave 0)
- Pattern completes (Wave 5 reached)
- Auto-timeout (configurable bars)
- Prevents rapid signal flipping and false alerts
**Signal Stability Controls**
- Adjustable cooldown between signals (default: 20 bars)
- Minimum bar distance between wave points
- Direction change requirement option
- Confirmation bars after Wave 2 formation
**Visual Wave Tracking**
- Solid lines for impulse waves (0→1, 2→3, 4→5)
- Dashed lines for corrective waves (1→2, 3→4)
- Numbered labels on each wave point
- Real-time projection lines to targets
**Comprehensive Dashboard**
- Current wave status and lock state
- Pattern grade (A+ to D based on confluence)
- Projected vs actual wave levels (✓ when completed)
- SMC confirmation status
- Risk/Reward ratio calculation
- EWO trend direction
---
### 📈 TRADING APPLICATION
**Entry Strategy**
- Wait for Wave 1-2 pattern detection (diamond signal)
- Check confluence score (>65% = higher probability)
- Verify EWO alignment with pattern direction
- Enter after 30% retracement of Wave 2 (customizable)
**Risk Management**
- Stop Loss: Below Wave 0 (with buffer)
- Take Profit 1: Wave 3 projection
- Take Profit 2: Wave 5 projection
- R:R displayed in dashboard
**Invalidation Rules**
- Price breaks below Wave 0 (bullish) or above (bearish)
- Wave 2 level violated before Wave 3 forms
- Pattern timeout exceeded
---
### ⚙️ KEY SETTINGS
**Elliott Wave**
- ZigZag Length: Pivot detection sensitivity
- Fib Tolerance: Acceptable retracement range
- Min Wave Size: Filter small movements
**Signal Stability**
- Signal Cooldown: Minimum bars between signals
- Lock Pattern Until Invalid: Prevent signal changes
- Confirmation Bars: Wait after Wave 2
**Wave Projection**
- Wave 3/4/5 Fibonacci extensions
- Projection display distance
**EWO Settings**
- Fast/Slow EMA lengths
- Signal smoothing
- Strength threshold
**SMC Settings**
- Order Block lookback period
- FVG minimum size percentage
---
### 🔔 ALERTS
- New bullish/bearish pattern detected
- High confluence setup (>75%)
- Pattern invalidation
- Wave completion
---
### ⚠️ IMPORTANT NOTES
- This indicator identifies **potential** Elliott Wave patterns based on mathematical rules
- Elliott Wave analysis is subjective - patterns may be interpreted differently
- Always combine with other analysis methods and proper risk management
- Past pattern performance does not guarantee future results
- Pattern locking prevents repainting but delays new pattern detection
- Best used on higher timeframes (1H+) for cleaner wave structures
---
### 📚 METHODOLOGY REFERENCES
**Elliott Wave Theory**
- Wave 2 typically retraces 38.2% - 88.6% of Wave 1
- Wave 3 is often the strongest, extending 161.8% of Wave 1
- Wave 4 usually retraces 38.2% of Wave 3
- Wave 5 completes the impulse structure
**Smart Money Concepts**
- Order Blocks represent institutional supply/demand zones
- FVGs indicate price inefficiencies that may act as magnets
**Elliott Wave Oscillator**
- Developed to identify wave momentum
- Crossovers signal potential wave transitions
- Extreme readings often coincide with wave completions
---
### 🎨 VISUAL ELEMENTS
- **Green**: Bullish patterns and projections
- **Red**: Bearish patterns and projections
- **Orange**: Wave projection levels
- **Purple**: Order Block zones
- **Yellow**: Fair Value Gaps
- **Blue**: Entry levels
- **Diamond shapes**: New pattern signals
- **Triangle shapes**: EWO crossover signals
---
### 💡 TIPS FOR BEST RESULTS
1. Use on liquid markets with clear trend behavior
2. Higher timeframes produce more reliable patterns
3. Look for confluence scores above 65%
4. Verify EWO alignment before entry
5. Consider market context (overall trend, key levels)
6. Adjust ZigZag length based on your trading style
7. Increase cooldown period for longer-term signals
---
**Indicator Type**: Overlay
**Markets**: All (Crypto, Forex, Stocks, Commodities)
**Timeframes**: All (1H+ recommended)
**Style**: Pattern Recognition + Momentum + Price Action
EMA Dynamic Crossover Detector with Real-Time Signal TableDescriptionWhat This Indicator Does:This indicator monitors all possible crossovers between four key exponential moving averages (20, 50, 100, and 200 periods) and displays them both visually on the chart and in an organized data table. Unlike standard EMA indicators that only plot the lines, this tool actively detects every crossover event, marks the exact crossover point with a circle, records the precise price level, and maintains a running log of all crossovers during the trading session. It's designed for traders who want comprehensive EMA crossover analysis without manually watching multiple moving average pairs.Key Features:
Four Essential EMAs: Plots 20, 50, 100, and 200-period exponential moving averages with color-coded thin lines for clean chart presentation
Complete Crossover Detection: Monitors all 6 possible EMA pair combinations (20×50, 20×100, 20×200, 50×100, 50×200, 100×200) in both directions
Precise Price Marking: Places colored circles at the exact average price where crossovers occur (not just at candle close)
Real-Time Signal Table: Displays up to 10 most recent crossovers with timestamp, direction, exact price, and signal type
Session Filtering: Only records crossovers during active trading hours (10:00-18:00 Istanbul time) to avoid noise from low-liquidity periods
Automatic Daily Reset: Clears the signal table at the start of each new trading day for fresh analysis
Built-In Alerts: Two alert conditions (bullish and bearish crossovers) that can be configured to send notifications
How It Works:The indicator calculates four exponential moving averages using the standard EMA formula, then continuously monitors for crossover events using Pine Script's ta.crossover() and ta.crossunder() functions:Bullish Crossovers (Green ▲):
When a faster EMA crosses above a slower EMA, indicating potential upward momentum:
20 crosses above 50, 100, or 200
50 crosses above 100 or 200
100 crosses above 200 (Golden Cross when it's the 50×200)
Bearish Crossovers (Red ▼):
When a faster EMA crosses below a slower EMA, indicating potential downward momentum:
20 crosses below 50, 100, or 200
50 crosses below 100 or 200
100 crosses below 200 (Death Cross when it's the 50×200)
Price Calculation:
Instead of marking crossovers at the candle's close price (which might not be where the actual cross occurred), the indicator calculates the average price between the two crossing EMAs, providing a more accurate representation of the crossover point.Signal Table Structure:The table in the top-right corner displays four columns:
Saat (Time): Exact time of crossover in HH:MM format
Yön (Direction): Arrow indicator (▲ green for bullish, ▼ red for bearish)
Fiyat (Price): Calculated average price at the crossover point
Durum (Status): Signal classification ("ALIŞ" for buy signals, "SATIŞ" for sell signals) with color-coded background
The table shows up to 10 most recent crossovers, automatically updating as new signals appear. If no crossovers have occurred during the session within the time filter, it displays "Henüz kesişim yok" (No crossovers yet).EMA Color Coding:
EMA 20 (Aqua/Turquoise): Fastest-reacting, most sensitive to recent price changes
EMA 50 (Green): Short-term trend indicator
EMA 100 (Yellow): Medium-term trend indicator
EMA 200 (Red): Long-term trend baseline, key support/resistance level
How to Use:For Day Traders:
Monitor 20×50 crossovers for quick entry/exit signals within the day
Use the time filter (10:00-18:00) to focus on high-volume trading hours
Check the signal table throughout the session to track momentum shifts
Look for confirmation: if 20 crosses above 50 and price is above EMA 200, bullish bias is stronger
For Swing Traders:
Focus on 50×200 crossovers (Golden Cross/Death Cross) for major trend changes
Use higher timeframes (4H, Daily) for more reliable signals
Wait for price to close above/below the crossover point before entering
Combine with support/resistance levels for better entry timing
For Position Traders:
Monitor 100×200 crossovers on daily/weekly charts for long-term trend changes
Use as confirmation of major market shifts
Don't react to every crossover—wait for sustained movement after the cross
Consider multiple timeframe analysis (if crossovers align on weekly and daily, signal is stronger)
Understanding EMA Hierarchies:The indicator becomes most powerful when you understand EMA relationships:Bullish Hierarchy (Strongest to Weakest):
All EMAs ascending (20 > 50 > 100 > 200): Strong uptrend
20 crosses above 50 while both are above 200: Pullback ending in uptrend
50 crosses above 200 while 20/50 below: Early trend reversal signal
Bearish Hierarchy (Strongest to Weakest):
All EMAs descending (20 < 50 < 100 < 200): Strong downtrend
20 crosses below 50 while both are below 200: Rally ending in downtrend
50 crosses below 200 while 20/50 above: Early trend reversal signal
Trading Strategy Examples:Pullback Entry Strategy:
Identify major trend using EMA 200 (price above = uptrend, below = downtrend)
Wait for pullback (20 crosses below 50 in uptrend, or above 50 in downtrend)
Enter when 20 re-crosses 50 in the trend direction
Place stop below/above the recent swing point
Exit when 20 crosses 50 against the trend again
Golden Cross/Death Cross Strategy:
Wait for 50×200 crossover (appears in the signal table)
Verify: Check if crossover occurs with increasing volume
Entry: Enter in the direction of the cross after a pullback
Stop: Place stop below/above the 200 EMA
Target: Swing high/low or when opposite crossover occurs
Multi-Crossover Confirmation:
Watch for multiple crossovers in the same direction within a short period
Example: 20×50 crossover followed by 20×100 = strengthening momentum
Enter after the second confirmation crossover
More crossovers = stronger signal but also means you're entering later
Time Filter Benefits:The 10:00-18:00 Istanbul time filter prevents recording crossovers during:
Pre-market volatility and gaps
Low-volume overnight sessions (for 24-hour markets)
After-hours erratic movements
Moving Average ProjectionDisplays 2-5 moving averages (solid lines) and projects their future trajectory (dashed lines) based on current trend momentum. This helps you anticipate where key MAs are heading and identify potential future support/resistance levels.
Important: Projections show where MAs would move IF the current trend continues—they're not predictions. Market conditions change, so use projections as planning tools, not trading signals.
General Settings
Number of MAs (2-5) controls how many moving averages display on your chart. Start with 2-3 to avoid clutter. Projection Bars (1-100) determines how far into the future to project—use 10-20 for intraday charts and 20-40 for daily charts. Lookback for Slope (2-100) sets the number of bars used to calculate trend slope, where shorter lookbacks are more responsive and longer ones are smoother. The default of 20 works well for most situations.
Individual MA Settings (MA 1-5)
Each MA has four settings: Length sets the period for the MA (common values are 9, 20, 50, 100, and 200), Type lets you choose between SMA, EMA, WMA, HMA, VWMA, or RMA (EMA is most popular), Color sets the historical MA line color, and Projection Color sets the projected line color (usually a lighter or transparent version of the main color).
MA Types Quick Reference: EMA is most popular and responsive to recent prices. SMA gives equal weight to all periods and is the smoothest. HMA is very responsive with low lag. VWMA incorporates volume data.
Quick Setup Examples
Day Trading: 3 MAs (9/21/50 EMA), 10-15 projection bars, 10-15 lookback
Swing Trading: 2 MAs (50/200 EMA), 20-30 projection bars, 20 lookback
Scalping: 2 MAs (9/20 EMA), 5-10 projection bars, 5-10 lookback
How to Use
Trend Identification: An uptrend shows price above rising MAs with projections pointing up. A downtrend shows price below falling MAs with projections pointing down. Consolidation appears as flat MAs with horizontal projections.
Support & Resistance: Rising MA projections act as future dynamic support levels, while falling MA projections act as future dynamic resistance levels.
Anticipating Changes: Watch for projected MA crossovers before they happen. When projections converge, expect volatility or consolidation. Steep projections suggest unsustainable trends, so be cautious. Flat projections indicate ranging markets.
Trade Planning: Check the current trend using MA alignment, then look at projections to gauge trend continuation likelihood. Use projected MA levels for potential targets or stop placement.
Important Tips
When Projections Work Best: Projections are most reliable in stable trending markets with consistent momentum, low volatility environments, and away from major news events.
When to Be Cautious: Use caution during high volatility or choppy price action, around major economic releases, when projections show extreme or parabolic angles, and during trend transitions.
Combine With Other Analysis: Don't trade projections alone. Use them alongside price action, volume, support and resistance levels, and other indicators for confirmation.
Best Practices
Start with 2-3 MAs to avoid chart clutter. Match your projection and lookback bars to your trading timeframe. Use consistent color schemes for quick interpretation. Adjust settings as market conditions change. Always use proper risk management—projections are planning tools, not guarantees.
Troubleshooting
Projections not showing: Check that Projection Bars > 0 and you're viewing the most recent bar
Chart too cluttered: Reduce number of MAs or increase projection color transparency
Projections too volatile: Increase lookback bars or switch to EMA/SMA from HMA
Can't see certain MAs: Verify "Number of MAs" setting includes them (MA 3 won't show if set to 2)
ADX Color Change by BehemothI find this tool to be the most valuable and accurate entry point indicator along with moving averages and the VWAP.
ADX Color Indicator - Controls & Intraday Trading Benefits
Indicator Controls:
1. ADX Length (default: 14)
- Controls the calculation period for ADX
- Lower values (7-10) = more sensitive, faster signals (better for scalping)
- Higher values (14-20) = smoother, fewer false signals (better for swing trades)
- *Intraday tip:* Try 10-14 for most intraday timeframes
2. Show Threshold Levels (default: On)
- Displays the 20 and 25 horizontal lines
- Helps you quickly identify when ADX crosses key strength levels
3. Use Custom Timeframe (default: Off)
- Allows viewing higher timeframe ADX on lower timeframe charts
- *Example:* Trade on 5-min chart but see 15-min or 1-hour ADX
4. Custom Timeframe
- Select any timeframe: 1m, 5m, 15m, 30m, 1H, 4H, D, etc.
- *Intraday tip:* Use 15m or 1H ADX on 5m charts for better trend context
5. Show +DI and -DI (default: Off)
- Shows directional movement indicators
- Green line (+DI) > Red line (-DI) = bullish trend
- Red line (-DI) > Green line (+DI) = bearish trend
6. Show Background Zon es (default: Off)
- Visual background colors for quick trend strength identification
- Green = strong trend (ADX > 25)
- Yellow = moderate trend (ADX 20-25)
Intraday Trading Benefits:
1. Avoid Choppy Markets
- When ADX < 20 (no background color), market is ranging
- Reduces false breakout trades and whipsaws
- Save time and capital by stepping aside during low-quality setups
2. Identify High-Probability Trend Trades
- **Green line + Green zone** = strong trend building, look for pullback entries
- Yellow line crossing above 20 = early trend formation signal
- Catch trends early when ADX starts rising from below 20
3. Multi-Timeframe Analysis
- Use custom timeframe to align with higher timeframe trends
- *Example:* If 1H ADX shows green (strong trend), take breakout trades on 5m chart in same direction
- Increases win rate by trading with the bigger picture
4. Exit Signals
- When ADX turns red (falling), trend is weakening
- Consider tightening stops or taking profits
- Avoid entering new positions when ADX is declining
5. Quick Visual Confirmation
- Color coding eliminates need to analyze numbers
- Instant recognition: Green = go, Yellow = caution, Red = trend dying
- Faster decision-making during fast market moves
6. Scalping Strategy
- Set ADX length to 7-10 for sensitive signals
- Only scalp when ADX is rising (blue, yellow, or green)
- Exit when ADX turns red
7. Breakout Confirmation
- Wait for ADX to rise above 20 after a breakout
- Filters false breakouts in ranging markets
- Yellow or green color confirms momentum behind the move
Optimal Intraday Settings:
- Day Trading (5-15 min charts):** ADX Length = 10-14
- Scalping (1-5 min charts):** ADX Length = 7-10, watch custom 15m timeframe
- Swing Intraday (30min-1H charts):** ADX Length = 14-20
Simple Trading Rules:
✅ Trade: ADX rising + above 20 (yellow or green)
⚠️ Caution: ADX flat or just crossed 20
❌ Avoid:*ADX falling (red) or below 20
The key advantage is staying out of low-quality, choppy price action which is where most intraday traders lose money!
