Average Price Range Screener [KFB Quant]Average Price Range Screener
Overview:
The Average Price Range Screener is a technical analysis tool designed to provide insights into the average price volatility across multiple symbols over user-defined time periods. The indicator compares price ranges from different assets and displays them in a visual table and chart for easy reference. This can be especially helpful for traders looking to identify symbols with high or low volatility across various time frames.
Key Features:
Multiple Symbols Supported:
The script allows for analysis of up to 10 symbols, such as major cryptocurrencies and market indices. Symbols can be selected by the user and configured for tracking price volatility.
Dynamic Range Calculation:
The script calculates the average price range of each symbol over three distinct time periods (default are 30, 60, and 90 bars). The price range for each symbol is calculated as a percentage of the bar's high-to-low difference relative to its low value.
Range Visualization:
The results are visually represented using:
- A color-coded table showing the calculated average ranges of each symbol and the current chart symbol.
- A line plot that visually tracks the volatility for each symbol on the chart, with color gradients representing the range intensity from low (red/orange) to high (blue/green).
Customizable Inputs:
- Length Inputs: Users can define the time lengths (default are 30, 60, and 90 bars) for calculating average price ranges for each symbol.
- Symbol Inputs: 10 symbols can be tracked at once, with default values set to popular crypto pairs and indices.
- Color Inputs: Users can customize the color scheme for the range values displayed in the table and chart.
Real-Time Ranking:
The indicator ranks symbols by their average price range, providing a clear view of which assets are exhibiting higher volatility at any given time.
Each symbol's range value is color-coded based on its relative volatility within the selected symbols (using a gradient from low to high range).
Data Table:
The table shows the average range values for each symbol in real-time, allowing users to compare volatility across multiple assets at a glance. The table is dynamically updated as new data comes in.
Interactive Labels:
The indicator adds labels to the chart, showing the average range for each symbol. These labels adjust in real-time as the price range values change, giving users an immediate view of volatility rankings.
How to Use:
Set Time Periods: Adjust the time periods (lengths) to match your trading strategy's timeframe and volatility preference.
Symbol Selection: Add and track the price range for your preferred symbols (cryptocurrencies, stocks, indices).
Monitor Volatility: Use the visual table and plot to identify symbols with higher or lower volatility, and adjust your trading strategy accordingly.
Interpret the Table and Chart: Ranges that are color-coded from red/orange (lower volatility) to blue/green (higher volatility) allow you to quickly gauge which symbols are most volatile.
Disclaimer: This tool is provided for informational and educational purposes only and should not be considered as financial advice. Always conduct your own research and consult with a licensed financial advisor before making any investment decisions.
Cari dalam skrip untuk "track"
Globex time (New York Time)This indicator is designed to highlight and analyze price movements within the Globex session. Primarily geared toward the Globex Trap trading strategy, this tool visually identifies the session's high and low prices, allowing traders to better assess price action during extended hours. Hereโs a comprehensive breakdown of its features and functionality:
Purpose
The "Globex Time (New York Time)" indicator tracks price levels during the Globex trading session, providing a clear view of overnight market activity. This session, typically running from 6 p.m. ET (18:00) until the following morning at 8:30 a.m. ET, is a critical period where significant market positioning can occur before the regular session opens. In the Globex Trap strategy, the session high and low are essential levels, as price movements around these areas often indicate potential support, resistance, or reversal zones, which traders use to set up entries or exits when the regular trading session begins.
Key Features
Customizable Session Start and End Times
The indicator allows users to specify the exact start and end times of the Globex session in New York time. The default settings are:
Start: 6 p.m. ET (18:00)
End: 8:30 a.m. ET
These settings can be adjusted to align with specific market hours or personal preferences.
Session High and Low Identification
Throughout the defined session, the indicator dynamically calculates and tracks:
Session High: The highest price reached within the session.
Session Low: The lowest price reached within the session.
These levels are essential for the Globex Trap strategy, as price action around them can indicate likely breakout or reversal points when regular trading resumes.
Vertical Lines for Session Start and End
The indicator draws vertical lines at both the session start and end times:
Session Start Line: A solid line marking the exact beginning of the Globex session.
Session End Line: A similar vertical line marking the sessionโs conclusion.
Both lines are customizable in terms of color and thickness, making it easy to distinguish the session boundaries visually on the chart.
Horizontal Lines for Session High and Low
At the end of the session, the indicator plots horizontal lines representing the Globex session's high and low levels. Users can customize these lines:
Color: Define specific colors for the session high (default: red) and session low (default: green) to easily differentiate them.
Line Style: Options to set the line style (solid, dashed, or dotted) provide flexibility for visual preferences and chart organization.
Automatic Reset for Daily Tracking
To adapt to the next trading day, the indicator resets the session high and low data once the current session ends. This reset prepares it to start tracking new levels at the beginning of the next session without manual intervention.
Practical Application in the Globex Trap Strategy
In the Globex Trap strategy, traders are primarily interested in price behavior around the high and low levels established during the overnight session. Common applications of this indicator for this strategy include:
Breakout Trades: Watching for price to break above the Globex high or below the Globex low, indicating potential momentum in the breakout direction.
Reversal Trades: Monitoring for failed breakouts or traps where price tests and rejects the Globex high or low, suggesting a reversal as liquidity is trapped in these zones.
Support and Resistance Zones: Using the session high and low as key support and resistance levels during the regular trading session, with potential entry or exit points when price approaches these areas.
Additional Configuration Options
Vertical Line Color and Width: Define the color and thickness of the vertical session start and end lines to match your chartโs theme.
Upper and Lower Line Colors and Styles: Customize the appearance of the session high and low horizontal lines by setting color and line style (solid, dashed, or dotted), making it easy to distinguish these critical levels from other chart markings.
Summary
This indicator is a valuable tool for traders implementing the Globex Trap strategy. It visually segments the Globex session and marks essential price levels, helping traders analyze market behavior overnight. Through its customizable options and clear visual representation, it simplifies tracking overnight price activity and identifying strategic levels for potential trade setups during the regular session.
Winning and Losing StreaksThe Pine Script indicator "Winning and Losing Streaks" tracks and visualizes the length of consecutive winning and losing streaks in a financial series, such as stock prices. Hereโs a detailed description of the indicator, including the relevance of statistical analysis and streak tracking.
Indicator Description
The "Winning and Losing Streaks" indicator in Pine Script is designed to analyze and display streaks of consecutive winning and losing days in trading data. It helps traders and analysts understand the persistence of trends in price movements.
Hereโs how it functions:
Streak Calculation:
Winning Streak: A series of consecutive days where the closing price is higher than the previous day's closing price.
Losing Streak: A series of consecutive days where the closing price is lower than the previous day's closing price.
Doji Candles: The indicator also considers Doji candles, where the difference between the opening and closing prices is minimal relative to the high-low range, and excludes these from being counted as winning or losing days.
Statistical Analysis:
The indicator computes the maximum and average lengths of winning and losing streaks.
It also tracks the current streak lengths and maintains arrays to store the historical streak data.
Visualization:
Histograms: Winning and losing streaks are visualized using histograms, which provide a clear graphical representation of streak lengths over time.
Relevance of Statistical Analysis and Streak Tracking
1. Statistical Significance of Streaks
Tracking winning and losing streaks has significant statistical implications for trading strategies and risk management:
Autocorrelation: Streaks in financial time series can reveal autocorrelation, where past returns influence future returns. Studies have shown that financial time series often exhibit autocorrelation, which can be used to forecast future price movements (Lo, 1991; Jegadeesh & Titman, 1993). Understanding streaks helps in identifying and leveraging these patterns.
Behavioral Finance: Streak analysis aligns with concepts from behavioral finance, such as the "hot-hand fallacy," where investors may perceive trends as more persistent than they are (Gilovich, Vallone, & Tversky, 1985). Statistical streak analysis provides a more objective view of trend persistence, helping to avoid biases.
2. Risk Management and Strategy Development
Risk Assessment: Identifying the length and frequency of losing streaks is crucial for managing risk and adjusting trading strategies. Long losing streaks can indicate potential strategy weaknesses or market regime changes, prompting a reassessment of trading rules and risk management practices (Brock, Lakonishok, & LeBaron, 1992).
Strategy Optimization: Statistical analysis of streaks can aid in optimizing trading strategies. For example, understanding the average length of winning and losing streaks can help in setting more effective stop-loss and take-profit levels, as well as in determining the optimal position sizing (Fama & French, 1993).
Scientific References:
Lo, A. W. (1991). "Long-Term Memory in Stock Market Prices." Econometrica, 59(5), 1279-1313. This paper discusses the presence of long-term memory in stock prices, which is relevant for understanding the persistence of streaks.
Jegadeesh, N., & Titman, S. (1993). "Returns to Buying Winners and Selling Losers: Implications for Stock Market Efficiency." Journal of Finance, 48(1), 65-91. This study explores momentum and reversal strategies, which are related to the concept of streaks.
Gilovich, T., Vallone, R., & Tversky, A. (1985). "The Hot Hand in Basketball: On the Misperception of Random Sequences." Cognitive Psychology, 17(3), 295-314. This paper provides insight into the psychological aspects of streaks and persistence.
Brock, W., Lakonishok, J., & LeBaron, B. (1992). "Simple Technical Trading Rules and the Stochastic Properties of Stock Returns." Journal of Finance, 47(5), 1731-1764. This research examines the effectiveness of technical trading rules, relevant for streak-based strategies.
Fama, E. F., & French, K. R. (1993). "Common Risk Factors in the Returns on Stocks and Bonds." Journal of Financial Economics, 33(1), 3-56. This paper provides a foundation for understanding risk factors and strategy performance.
By analyzing streaks, traders can gain valuable insights into market dynamics and refine their trading strategies based on empirical evidence.
Crypto McClellan Oscillator (SLN Fix)This is an adaption of the Mcclellan Oscillator for crypto. Instead of tracking the S&P500 it tracks a selection of cryptos to make sure the indicator follows this sector instead.
Full credit goes to the creator of this indicator: Fadior. It has since been fixed by SLN.
The following description explains the standard McClellan Oscillator. Full credit to Investopedia , my fav source of financial explanations.
The same principles applies to its use in the crypto sector, but please be cautious of the last point, the limitations. Since crypto is more volatile, that could amplify choppy behavior.
This is not financial advice, please be extremely cautious. This indicator is only suitable as a confirmation signal and needs support of other signals to be profitable.
This indicator usually produces the best signals on slightly above daily time frame. I personally like 2 or 3 day, but you have to find the settings suitable for your trading style.
What Is the McClellan Oscillator?
The McClellan Oscillator is a market breadth indicator that is based on the difference between the number of advancing and declining issues on a stock exchange, such as the New York Stock Exchange (NYSE) or NASDAQ.
The indicator is used to show strong shifts in sentiment in the indexes, called breadth thrusts. It also helps in analyzing the strength of an index trend via divergence or confirmation.
The McClellan Oscillator formula can be applied to any stock exchange or group of stocks.
A reading above zero helps confirm a rise in the index, while readings below zero confirm a decline in the index.
When the index is rising but the oscillator is falling, that warns that the index could start declining too. When the index is falling and the oscillator is rising, that indicates the index could start rising soon. This is called divergence.
A significant change, such as moving 100 points or more, from a negative reading to a positive reading is called a breadth thrust. It may indicate a strong reversal from downtrend to uptrend is underway on the stock exchange.
How to Calculate the McClellan Oscillator
To get the calculation started, track Advances - Declines on a stock exchange for 19 and 39 days. Calculate a simple average for these, not exponential moving average (EMA).
Use these simple values as the Prior Day EMA values in the 19- and 39-day EMA formulas.
Calculate the 19- and 39-day EMAs.
Calculate the McClellan Oscillator value.
Now that the value has been calculated, on the next calculation use this value for the Prior Day EMA. Start calculating EMAs for the formula instead of simple averages.
If using the adjusted formula, the steps are the same, except use ANA instead of using Advances - Declines.
What Does the McClellan Oscillator Tell You?
The McClellan Oscillator is an indicator based on market breadth which technical analysts can use in conjunction with other technical tools to determine the overall state of the stock market and assess the strength of its current trend.
Since the indicator is based on all the stocks in an exchange, it is compared to the price movements of indexes that reflect that exchange, or compared to major indexes such as the S&P 500.
Positive and negative values indicate whether more stocks, on average, are advancing or declining. The indicator is positive when the 19-day EMA is above the 39-day EMA, and negative when the 19-day EMA is below the 39-day EMA.
A positive and rising indicator suggests that stocks on the exchange are being accumulated. A negative and falling indicator signals that stocks are being sold. Typically such action confirms the current trend in the index.
Crossovers from positive to negative, or vice versa, may signal the trend has changed in the index or exchange being tracked. When the indicator makes a large move, typically of 100 points or more, from negative to positive territory, that is called a breadth thrust.
It means a large number of stocks moved up after a bearish move. Since the stock market tends to rise over time, this a positive signal and may indicate that a bottom in the index is in and prices are heading higher overall.
When index prices and the indicator are moving in different directions, then the current index trend may lack strength. Bullish divergence occurs when the oscillator is rising while the index is falling. This indicates the index could head higher soon since more stocks are starting to advance.
Bearish divergence is when the index is rising and the indicator is falling. This means fewer stocks are keeping the advance going and prices may start to head lower.
Limitations of Using the McClellan Oscillator
The indicator tends to produce lots of signals. Breadth thrusts, divergence, and crossovers all occur with some frequency, but not all these signals will result in the price/index moving in the expected direction.
The indicator is prone to producing false signals and therefore should be used in conjunction with price action analysis and other technical indicators.
The indicator can also be quite choppy, moving between positive and negative territory rapidly. Such action indicates a choppy market, but this isn't evident until the indicator has made this whipsaw move a few times.
Good luck and a big thanks to Fadior!
Session Highlighter with Kill Zones [Exponential-X]Session Highlighter with Kill Zones
Overview
This indicator provides comprehensive visualization of major forex trading sessions (Asian, London, and New York) with integrated kill zone detection and real-time session analytics. It helps traders identify optimal trading times by highlighting high-volatility periods and tracking session-specific price ranges.
What Makes This Original
While session indicators are common, this script uniquely combines several features that work together:
Kill Zone Integration: Highlights specific high-volatility windows within sessions (London: 02:00-05:00 EST, NY: 08:30-11:00 EST) when institutional activity typically peaks
Session Overlap Detection: Automatically detects and highlights when major sessions overlap (London-NY, Asian-London) with distinct visual cues
Real-Time Range Tracking: Calculates and displays percentage-based session ranges as they develop, not just historical data
Dynamic Statistics Dashboard: Live table showing current active session, session times, and comparative range percentages
Customizable Visual System: Flexible styling options including background shading, box overlays, and configurable line styles for session boundaries
How It Works
Session Detection Logic
The script uses timezone-normalized session detection based on EST/EDT times. It converts the current bar's timestamp to New York time and determines which session(s) are active using minute-based calculations. This approach ensures accurate session detection regardless of your chart's timezone settings.
Kill Zones
Kill zones represent periods within sessions when institutional traders are most active. The London kill zone (02:00-05:00 EST) captures pre-London open volatility, while the NY kill zone (08:30-11:00 EST) aligns with US economic data releases and market open activity.
Range Calculations
Session highs, lows, and opens are tracked from the first bar of each session and updated in real-time. Range percentages are calculated as: ((High - Low) / Low) ร 100 , providing a volatility measure that's comparable across different instruments and price levels.
Visual System
Background shading: Color-coded zones for each session
Session boxes: Outline entire session ranges
H/L lines: Dynamic lines showing current session extremes
Open lines: Reference levels from session start
Overlap highlighting: Distinct colors when multiple sessions are active simultaneously
How to Use
Intraday Trading: Use kill zones to time entries during high-liquidity periods
Session Breakouts: Monitor for price breaks above/below session highs/lows
Range Trading: Trade between session boundaries during consolidation
Session Continuity: Observe how price behaves as sessions transition
Volatility Assessment: Compare current session ranges to typical values
Recommended Timeframes: Works on any timeframe, but most useful on 1m to 1H charts for intraday trading.
Settings Explained
Sessions Group
Toggle each major session on/off independently
Customize colors for visual clarity
Enable/disable overlap highlighting
Levels Group
Show/hide session high/low lines
Show/hide session open levels
Choose line styles (Solid/Dashed/Dotted)
Kill Zones Group
Toggle kill zone highlighting
Select which kill zones to display
Customize kill zone color intensity
Display Group
Show/hide statistics table
Show/hide session labels on chart
Important Notes
All times are displayed in EST/EDT
Session ranges reset at the start of each new session
Kill zones are session sub-periods, not separate sessions
Overlap colors override individual session colors when multiple sessions are active
The statistics table updates in real-time and shows percentage-based ranges for cross-instrument comparison
Session Times Reference
Asian Session: 19:00 - 04:00 EST (Tokyo open through early Sydney close)
London Session: 03:00 - 12:00 EST (Full European trading hours)
New York Session: 08:00 - 17:00 EST (US market hours)
London Kill Zone: 02:00 - 05:00 EST (Pre-London volatility spike)
NY Kill Zone: 08:30 - 11:00 EST (US open and news releases)
Alerts Available
The script includes six pre-configured alert conditions:
London Kill Zone start
NY Kill Zone start
London-NY Overlap start
Asian Session open
London Session open
NY Session open
Create alerts through TradingView's alert system to get notified when specific sessions or kill zones begin.
Disclaimer: This indicator is for informational purposes only. Session times and kill zones are based on typical market patterns but do not guarantee specific trading outcomes. Always use proper risk management.
FVG Maxing - Fair Value Gaps, Equilibrium, and Candle Patterns
What this script does
This open-source indicator highlights 3-candle fair value gaps (FVGs) on the active chart timeframe, draws their midpoint ("equilibrium") line, tracks when each gap is mitigated, and optionally marks simple candle patterns (engulfing and doji) for confluence. It is intended as an educational tool to study how price interacts with imbalances.
3-candle bullish and bearish FVG zones drawn as forward-extending boxes.
Equilibrium line at 50% of each gap.
Different styling for mitigated vs unmitigated gaps.
Compact statistics panel showing how many gaps are currently active and filled.
Optional overlays for bullish/bearish engulfing patterns and doji candles.
1. FVG logic (3-candle gaps)
The script focuses on a strict 3-candle definition of a fair value gap:
Three consecutive candles with the same body direction.
The wick of candle 3 is separated from the wick of candle 1 (no overlap).
A bullish gap is created when price moves up fast enough to leave a gap between candle 1 and 3. A bearish gap is the mirror case to the downside.
In Pine, the core detection looks like this:
// Three candles with the same body direction
bull_seq = close > open and close > open and close > open
bear_seq = close < open and close < open and close < open
// Wick gap between candle 1 and candle 3
bull_gap = bull_seq and low > high
bear_gap = bear_seq and high < low
// Final FVG flags
is_bull_fvg = bull_gap
is_bear_fvg = bear_gap
For each detected FVG:
Bullish FVG range: from high up to low (gap below current price).
Bearish FVG range: from low down to high (gap above current price).
Each zone is stored in a custom FVGData structure so it can be updated when price later trades back inside it.
2. Equilibrium line (0.5 of the gap)
Every FVG box gets an optional equilibrium line plotted at the midpoint between its top and bottom:
eq_level = (top + bottom) / 2.0
right_index = extend_boxes ? bar_index + extend_length_bars : bar_index
bx = box.new(bar_index - 2, top, right_index, bottom)
eq_ln = line.new(bar_index - 2, eq_level, right_index, eq_level)
line.set_style(eq_ln, line.style_dashed)
line.set_color(eq_ln, eq_color)
You can use this line as a neutral โfair valueโ reference inside the zone, or as a simple way to think in terms of premium/discount within each gap.
3. Mitigation rules and styling
Each FVG stays active until price trades back into the gap:
Bullish FVG is considered mitigated when the low touches or moves below the top of the gap.
Bearish FVG is considered mitigated when the high touches or moves above the bottom of the gap.
When that happens, the script:
Marks the internal FVGData entry as mitigated.
Softens the box fill and border colors.
Optionally updates the label text from "BULL EQ / BEAR EQ" to "BULL FILLED / BEAR FILLED".
Can hide mitigated zones almost completely if you only want to see unfilled imbalances.
This allows you to distinguish between current areas of interest and zones that have already been traded through.
4. Candle pattern overlays (engulfing and doji)
For additional confluence, the script can mark simple candle patterns on top of the FVG view:
Bullish engulfing โ current candle body fully wraps the previous bearish body and is larger in size.
Bearish engulfing โ current candle body fully wraps the previous bullish body and is larger in size.
Doji โ candles where the real body is small relative to the full range (highโlow).
The detection is based on basic body and range geometry:
curr_body = math.abs(close - open)
prev_body = math.abs(close - open )
curr_range = high - low
body_ratio = curr_range > 0 ? curr_body / curr_range : 1.0
bull_engulfing = close > open and close < open and open <= close and close >= open and curr_body > prev_body
bear_engulfing = close < open and close > open and open >= close and close <= open and curr_body > prev_body
is_doji = curr_range > 0 and body_ratio <= doji_body_ratio
On the chart, they appear as:
Small triangle markers below bullish engulfing candles.
Small triangle markers above bearish engulfing candles.
Small circles above doji candles.
All three overlays are optional and can be turned on or off and recolored in the CANDLE PATTERNS group of inputs.
5. Inputs overview
The script organizes settings into clear groups:
DISPLAY SETTINGS : Show bullish/bearish FVGs, show/hide mitigated zones, box extension length, box border width, and maximum number of boxes.
EQUILIBRIUM : Toggle equilibrium lines, color, and line width.
LABELS : Enable labels, choose whether to label unmitigated and/or mitigated zones, and select label size.
BULLISH COLORS / BEARISH COLORS : Separate fill and border colors for bullish and bearish gaps.
MITIGATED STYLE : Opacity used when a gap is marked as mitigated.
STATISTICS : Toggle the on-chart FVG statistics panel.
CANDLE PATTERNS : Show engulfing patterns, show dojis, colors, and the body-to-range threshold that defines a doji.
6. Statistics panel
An optional table in the corner of the chart summarizes the current state of all tracked gaps:
Total number of FVGs still being tracked.
Number of bullish vs bearish FVGs.
Number of unfilled vs mitigated FVGs.
Simple fill rate: percentage of tracked FVGs that have been marked as mitigated.
This can help you study how a particular market tends to treat gaps over time.
7. How you might use it (examples)
These are usage ideas only, not recommendations:
Study how often your symbol mitigates gaps and where inside the zone price tends to react.
Use higher-timeframe context and then refine entries near the equilibrium line on your trading timeframe.
Combine FVG zones with basic candle patterns (engulfing/doji) as an extra visual anchor, if that fits your process.
Hope you enjoy, give your feedback in the comments!
- officialjackofalltrades
Bar Index & TimeLibrary to convert a bar index to a timestamp and vice versa.
Utilizes runtime memory to store the ๐๐๐๐ and ๐๐๐๐_๐๐๐๐๐ values of every bar on the chart (and optional future bars), with the ability of storing additional custom values for every chart bar.
โโ PREFACE
This library aims to tackle some problems that pine coders (from beginners to advanced) often come across, such as:
I'm trying to draw an object with a ๐๐๐_๐๐๐๐๐ก that is more than 10,000 bars into the past, but this causes my script to fail. How can I convert the ๐๐๐_๐๐๐๐๐ก to a UNIX time so that I can draw visuals using xloc.bar_time ?
I have a diagonal line drawing and I want to get the "y" value at a specific time, but line.get_price() only accepts a bar index value. How can I convert the timestamp into a bar index value so that I can still use this function?
I want to get a previous ๐๐๐๐ value that occurred at a specific timestamp. How can I convert the timestamp into a historical offset so that I can use ๐๐๐๐ ?
I want to reference a very old value for a variable. How can I access a previous value that is older than the maximum historical buffer size of ๐๐๐๐๐๐๐๐ ?
This library can solve the above problems (and many more) with the addition of a few lines of code, rather than requiring the coder to refactor their script to accommodate the limitations.
โโ OVERVIEW
The core functionality provided is conversion between xloc.bar_index and xloc.bar_time values.
The main component of the library is the ๐ฒ๐๐๐๐๐ณ๐๐๐ object, created via the ๐๐๐๐๐๐๐๐ฒ๐๐๐๐๐ณ๐๐๐() function which basically stores the ๐๐๐๐ and ๐๐๐๐_๐๐๐๐๐ of every bar on the chart, and there are 3 more overloads to this function that allow collecting and storing additional data. Once a ๐ฒ๐๐๐๐๐ณ๐๐๐ object is created, use any of the exported methods:
Methods to convert a UNIX timestamp into a bar index or bar offset:
๐๐๐๐๐๐๐๐๐๐๐๐ฑ๐๐๐ธ๐๐๐๐ก(), ๐๐๐๐ฝ๐๐๐๐๐๐พ๐๐ฑ๐๐๐๐ฑ๐๐๐()
Methods to retrieve the stored data for a bar index:
๐๐๐๐๐ฐ๐๐ฑ๐๐๐ธ๐๐๐๐ก(), ๐๐๐๐๐ฒ๐๐๐๐๐ฐ๐๐ฑ๐๐๐ธ๐๐๐๐ก(), ๐๐๐๐๐๐ฐ๐๐ฑ๐๐๐ธ๐๐๐๐ก(), ๐๐๐๐ฐ๐๐๐
๐๐๐๐๐๐๐๐๐ฐ๐๐ฑ๐๐๐ธ๐๐๐๐ก()
Methods to retrieve the stored data at a number of bars back (i.e., historical offset):
๐๐๐๐(), ๐๐๐๐๐ฒ๐๐๐๐(), ๐๐๐๐๐()
Methods to retrieve all the data points from the earliest bar (or latest bar) stored in memory, which can be useful for debugging purposes:
๐๐๐๐ด๐๐๐๐๐๐๐๐๐๐๐๐๐๐ณ๐๐๐(), ๐๐๐๐ป๐๐๐๐๐๐๐๐๐๐๐๐ณ๐๐๐()
Note: the library's strong suit is referencing data from very old bars in the past, which is especially useful for scripts that perform its necessary calculations only on the last bar.
โโ USAGE
Step 1
Import the library. Replace with the latest available version number for this library.
//@version=6
indicator("Usage")
import n00btraders/ChartData/
Step 2
Create a ๐ฒ๐๐๐๐๐ณ๐๐๐ object to collect data on every bar. Do not declare as `var` or `varip`.
chartData = ChartData.collectChartData() // call on every bar to accumulate the necessary data
Step 3
Call any method(s) on the ๐ฒ๐๐๐๐๐ณ๐๐๐ object. Do not modify its fields directly.
if barstate.islast
int firstBarTime = chartData.timeAtBarIndex(0)
int lastBarTime = chartData.time(0)
log.info("First `time`: " + str.format_time(firstBarTime) + ", Last `time`: " + str.format_time(lastBarTime))
โโ EXAMPLES
โข Collect Future Times
The overloaded ๐๐๐๐๐๐๐๐ฒ๐๐๐๐๐ณ๐๐๐() functions that accept a ๐๐๐๐๐ต๐๐๐ ๐๐๐ argument can additionally store time values for up to 500 bars into the future.
//@version=6
indicator("Example `collectChartData(barsForward)`")
import n00btraders/ChartData/1
chartData = ChartData.collectChartData(barsForward = 500)
var rectangle = box.new(na, na, na, na, xloc = xloc.bar_time, force_overlay = true)
if barstate.islast
int futureTime = chartData.timeAtBarIndex(bar_index + 100)
int lastBarTime = time
box.set_lefttop(rectangle, lastBarTime, open)
box.set_rightbottom(rectangle, futureTime, close)
box.set_text(rectangle, "Extending box 100 bars to the right. Time: " + str.format_time(futureTime))
โข Collect Custom Data
The overloaded ๐๐๐๐๐๐๐๐ฒ๐๐๐๐๐ณ๐๐๐() functions that accept a ๐๐๐๐๐๐๐๐๐ argument can additionally store custom user-specified values for every bar on the chart.
//@version=6
indicator("Example `collectChartData(variables)`")
import n00btraders/ChartData/1
var map variables = map.new()
variables.put("open", open)
variables.put("close", close)
variables.put("open-close midpoint", (open + close) / 2)
variables.put("boolean", open > close ? 1 : 0)
chartData = ChartData.collectChartData(variables = variables)
var fgColor = chart.fg_color
var table1 = table.new(position.top_right, 2, 9, color(na), fgColor, 1, fgColor, 1, true)
var table2 = table.new(position.bottom_right, 2, 9, color(na), fgColor, 1, fgColor, 1, true)
if barstate.isfirst
table.cell(table1, 0, 0, "ChartData.value()", text_color = fgColor)
table.cell(table2, 0, 0, "open ", text_color = fgColor)
table.merge_cells(table1, 0, 0, 1, 0)
table.merge_cells(table2, 0, 0, 1, 0)
for i = 1 to 8
table.cell(table1, 0, i, text_color = fgColor, text_halign = text.align_left, text_font_family = font.family_monospace)
table.cell(table2, 0, i, text_color = fgColor, text_halign = text.align_left, text_font_family = font.family_monospace)
table.cell(table1, 1, i, text_color = fgColor)
table.cell(table2, 1, i, text_color = fgColor)
if barstate.islast
for i = 1 to 8
float open1 = chartData.value("open", 5000 * i)
float open2 = i < 3 ? open : -1
table.cell_set_text(table1, 0, i, "chartData.value(\"open\", " + str.tostring(5000 * i) + "): ")
table.cell_set_text(table2, 0, i, "open : ")
table.cell_set_text(table1, 1, i, str.tostring(open1))
table.cell_set_text(table2, 1, i, open2 >= 0 ? str.tostring(open2) : "Error")
โข xloc.bar_index โ xloc.bar_time
The ๐๐๐๐ value (or ๐๐๐๐_๐๐๐๐๐ value) can be retrieved for any bar index that is stored in memory by the ๐ฒ๐๐๐๐๐ณ๐๐๐ object.
//@version=6
indicator("Example `timeAtBarIndex()`")
import n00btraders/ChartData/1
chartData = ChartData.collectChartData()
if barstate.islast
int start = bar_index - 15000
int end = bar_index - 100
// line.new(start, close, end, close) // !ERROR - `start` value is too far from current bar index
start := chartData.timeAtBarIndex(start)
end := chartData.timeAtBarIndex(end)
line.new(start, close, end, close, xloc.bar_time, width = 10)
โข xloc.bar_time โ xloc.bar_index
Use ๐๐๐๐๐๐๐๐๐๐๐๐ฑ๐๐๐ธ๐๐๐๐ก() to find the bar that a timestamp belongs to.
If the timestamp falls in between the close of one bar and the open of the next bar,
the ๐๐๐๐ parameter can be used to determine which bar to choose:
๐๐๐๐.๐ป๐ด๐ต๐ - prefer to choose the leftmost bar (typically used for closing times)
๐๐๐๐.๐๐ธ๐ถ๐ท๐ - prefer to choose the rightmost bar (typically used for opening times)
๐๐๐๐.๐ณ๐ด๐ต๐ฐ๐๐ป๐ (or ๐๐) - copies the same behavior as xloc.bar_time uses for drawing objects
//@version=6
indicator("Example `timestampToBarIndex()`")
import n00btraders/ChartData/1
startTimeInput = input.time(timestamp("01 Aug 2025 08:30 -0500"), "Session Start Time")
endTimeInput = input.time(timestamp("01 Aug 2025 15:15 -0500"), "Session End Time")
chartData = ChartData.collectChartData()
if barstate.islastconfirmedhistory
int startBarIndex = chartData.timestampToBarIndex(startTimeInput, ChartData.Snap.RIGHT)
int endBarIndex = chartData.timestampToBarIndex(endTimeInput, ChartData.Snap.LEFT)
line1 = line.new(startBarIndex, 0, startBarIndex, 1, extend = extend.both, color = color.new(color.green, 60), force_overlay = true)
line2 = line.new(endBarIndex, 0, endBarIndex, 1, extend = extend.both, color = color.new(color.green, 60), force_overlay = true)
linefill.new(line1, line2, color.new(color.green, 90))
// using Snap.DEFAULT to show that it is equivalent to drawing lines using `xloc.bar_time` (i.e., it aligns to the same bars)
startBarIndex := chartData.timestampToBarIndex(startTimeInput)
endBarIndex := chartData.timestampToBarIndex(endTimeInput)
line.new(startBarIndex, 0, startBarIndex, 1, extend = extend.both, color = color.yellow, width = 3)
line.new(endBarIndex, 0, endBarIndex, 1, extend = extend.both, color = color.yellow, width = 3)
line.new(startTimeInput, 0, startTimeInput, 1, xloc.bar_time, extend.both, color.new(color.blue, 85), width = 11)
line.new(endTimeInput, 0, endTimeInput, 1, xloc.bar_time, extend.both, color.new(color.blue, 85), width = 11)
โข Get Price of Line at Timestamp
The pine script built-in function line.get_price() requires working with bar index values. To get the price of a line in terms of a timestamp, convert the timestamp into a bar index or offset.
//@version=6
indicator("Example `line.get_price()` at timestamp")
import n00btraders/ChartData/1
lineStartInput = input.time(timestamp("01 Aug 2025 08:30 -0500"), "Line Start")
chartData = ChartData.collectChartData()
var diagonal = line.new(na, na, na, na, force_overlay = true)
if time <= lineStartInput
line.set_xy1(diagonal, bar_index, open)
if barstate.islastconfirmedhistory
line.set_xy2(diagonal, bar_index, close)
if barstate.islast
int timeOneWeekAgo = timenow - (7 * timeframe.in_seconds("1D") * 1000)
// Note: could also use `timetampToBarIndex(timeOneWeekAgo, Snap.DEFAULT)` and pass the value directly to `line.get_price()`
int barsOneWeekAgo = chartData.getNumberOfBarsBack(timeOneWeekAgo)
float price = line.get_price(diagonal, bar_index - barsOneWeekAgo)
string formatString = "Time 1 week ago: {0,number,#}\n - Equivalent to {1} bars ago\n\n๐๐๐๐.๐๐๐_๐๐๐๐๐(): {2,number,#.##}"
string labelText = str.format(formatString, timeOneWeekAgo, barsOneWeekAgo, price)
label.new(timeOneWeekAgo, price, labelText, xloc.bar_time, style = label.style_label_lower_right, size = 16, textalign = text.align_left, force_overlay = true)
โโ RUNTIME ERROR MESSAGES
This library's functions will generate a custom runtime error message in the following cases:
๐๐๐๐๐๐๐๐ฒ๐๐๐๐๐ณ๐๐๐() is not called consecutively, or is called more than once on a single bar
Invalid ๐๐๐๐๐ต๐๐๐ ๐๐๐ argument in the ๐๐๐๐๐๐๐๐ฒ๐๐๐๐๐ณ๐๐๐() function
Invalid ๐๐๐๐๐๐๐๐๐ argument in the ๐๐๐๐๐๐๐๐ฒ๐๐๐๐๐ณ๐๐๐() function
Invalid ๐๐๐๐๐๐ argument in any of the functions that accept a number of bars back
Note: there is no runtime error generated for an invalid ๐๐๐๐๐๐๐๐๐ or ๐๐๐๐ธ๐๐๐๐ก argument in any of the functions. Instead, the functions will assign ๐๐ to the returned values.
Any other runtime errors are due to incorrect usage of the library.
โโ NOTES
โข Function Descriptions
The library source code uses Markdown for the exported functions. Hover over a function/method call in the Pine Editor to display formatted, detailed information about the function/method.
//@version=6
indicator("Demo Function Tooltip")
import n00btraders/ChartData/1
chartData = ChartData.collectChartData()
int barIndex = chartData.timestampToBarIndex(timenow)
log.info(str.tostring(barIndex))
โข Historical vs. Realtime Behavior
Under the hood, the data collector for this library is declared as `var`. Because of this, the ๐ฒ๐๐๐๐๐ณ๐๐๐ object will always reflect the latest available data on realtime updates. Any data that is recorded for historical bars will remain unchanged throughout the execution of a script.
//@version=6
indicator("Demo Realtime Behavior")
import n00btraders/ChartData/1
var map variables = map.new()
variables.put("open", open)
variables.put("close", close)
chartData = ChartData.collectChartData(variables)
if barstate.isrealtime
varip float initialOpen = open
varip float initialClose = close
varip int updateCount = 0
updateCount += 1
float latestOpen = open
float latestClose = close
float recordedOpen = chartData.valueAtBarIndex("open", bar_index)
float recordedClose = chartData.valueAtBarIndex("close", bar_index)
string formatString = "# of updates: {0}\n\n๐๐๐๐ at update #1: {1,number,#.##}\n๐๐๐๐๐ at update #1: {2,number,#.##}\n\n"
+ "๐๐๐๐ at update #{0}: {3,number,#.##}\n๐๐๐๐๐ at update #{0}: {4,number,#.##}\n\n"
+ "๐๐๐๐ stored in memory: {5,number,#.##}\n๐๐๐๐๐ stored in memory: {6,number,#.##}"
string labelText = str.format(formatString, updateCount, initialOpen, initialClose, latestOpen, latestClose, recordedOpen, recordedClose)
label.new(bar_index, close, labelText, style = label.style_label_left, force_overlay = true)
โข Collecting Chart Data for Other Contexts
If your use case requires collecting chart data from another context, avoid directly retrieving the ๐ฒ๐๐๐๐๐ณ๐๐๐ object as this may exceed memory limits .
//@version=6
indicator("Demo Return Calculated Results")
import n00btraders/ChartData/1
timeInput = input.time(timestamp("01 Sep 2025 08:30 -0500"), "Time")
var int oneMinuteBarsAgo = na
// !ERROR - Memory Limits Exceeded
// chartDataArray = request.security_lower_tf(syminfo.tickerid, "1", ChartData.collectChartData())
// oneMinuteBarsAgo := chartDataArray.last().getNumberOfBarsBack(timeInput)
// function that returns calculated results (a single integer value instead of an entire `ChartData` object)
getNumberOfBarsBack() =>
chartData = ChartData.collectChartData()
chartData.getNumberOfBarsBack(timeInput)
calculatedResultsArray = request.security_lower_tf(syminfo.tickerid, "1", getNumberOfBarsBack())
oneMinuteBarsAgo := calculatedResultsArray.size() > 0 ? calculatedResultsArray.last() : na
if barstate.islast
string labelText = str.format("The selected timestamp occurs 1-minute bars ago", oneMinuteBarsAgo)
label.new(bar_index, hl2, labelText, style = label.style_label_left, size = 16, force_overlay = true)
โข Memory Usage
The library's convenience and ease of use comes at the cost of increased usage of computational resources. For simple scripts, using this library will likely not cause any issues with exceeding memory limits. But for large and complex scripts, you can reduce memory issues by specifying a lower ๐๐๐๐_๐๐๐๐_๐๐๐๐๐ amount in the indicator() or strategy() declaration statement.
//@version=6
// !ERROR - Memory Limits Exceeded using the default number of bars available (~20,000 bars for Premium plans)
//indicator("Demo `calc_bars_count` parameter")
// Reduce number of bars using `calc_bars_count` parameter
indicator("Demo `calc_bars_count` parameter", calc_bars_count = 15000)
import n00btraders/ChartData/1
map variables = map.new()
variables.put("open", open)
variables.put("close", close)
variables.put("weekofyear", weekofyear)
variables.put("dayofmonth", dayofmonth)
variables.put("hour", hour)
variables.put("minute", minute)
variables.put("second", second)
// simulate large memory usage
chartData0 = ChartData.collectChartData(variables)
chartData1 = ChartData.collectChartData(variables)
chartData2 = ChartData.collectChartData(variables)
chartData3 = ChartData.collectChartData(variables)
chartData4 = ChartData.collectChartData(variables)
chartData5 = ChartData.collectChartData(variables)
chartData6 = ChartData.collectChartData(variables)
chartData7 = ChartData.collectChartData(variables)
chartData8 = ChartData.collectChartData(variables)
chartData9 = ChartData.collectChartData(variables)
log.info(str.tostring(chartData0.time(0)))
log.info(str.tostring(chartData1.time(0)))
log.info(str.tostring(chartData2.time(0)))
log.info(str.tostring(chartData3.time(0)))
log.info(str.tostring(chartData4.time(0)))
log.info(str.tostring(chartData5.time(0)))
log.info(str.tostring(chartData6.time(0)))
log.info(str.tostring(chartData7.time(0)))
log.info(str.tostring(chartData8.time(0)))
log.info(str.tostring(chartData9.time(0)))
if barstate.islast
result = table.new(position.middle_right, 1, 1, force_overlay = true)
table.cell(result, 0, 0, "Script Execution Successful โ
", text_size = 40)
โโ EXPORTED ENUMS
Snap
โโBehavior for determining the bar that a timestamp belongs to.
โโFields:
โโโโ LEFT : Snap to the leftmost bar.
โโโโ RIGHT : Snap to the rightmost bar.
โโโโ DEFAULT : Default `xloc.bar_time` behavior.
Note: this enum is used for the ๐๐๐๐ parameter of ๐๐๐๐๐๐๐๐๐๐๐๐ฑ๐๐๐ธ๐๐๐๐ก().
โโ EXPORTED TYPES
Note: users of the library do not need to worry about directly accessing the fields of these types; all computations are done through method calls on an object of the ๐ฒ๐๐๐๐๐ณ๐๐๐ type.
Variable
โโRepresents a user-specified variable that can be tracked on every chart bar.
โโFields:
โโโโ name (series string) : Unique identifier for the variable.
โโโโ values (array) : The array of stored values (one value per chart bar).
ChartData
โโRepresents data for all bars on a chart.
โโFields:
โโโโ bars (series int) : Current number of bars on the chart.
โโโโ timeValues (array) : The `time` values of all chart (and future) bars.
โโโโ timeCloseValues (array) : The `time_close` values of all chart (and future) bars.
โโโโ variables (array) : Additional custom values to track on all chart bars.
โโ EXPORTED FUNCTIONS
collectChartData()
โโCollects and tracks the `time` and `time_close` value of every bar on the chart.
โโReturns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`.
collectChartData(barsForward)
โโCollects and tracks the `time` and `time_close` value of every bar on the chart as well as a specified number of future bars.
โโParameters:
โโโโ barsForward (simple int) : Number of future bars to collect data for.
โโReturns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`.
collectChartData(variables)
โโCollects and tracks the `time` and `time_close` value of every bar on the chart. Additionally, tracks a custom set of variables for every chart bar.
โโParameters:
โโโโ variables (simple map) : Custom values to collect on every chart bar.
โโReturns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`.
collectChartData(barsForward, variables)
โโCollects and tracks the `time` and `time_close` value of every bar on the chart as well as a specified number of future bars. Additionally, tracks a custom set of variables for every chart bar.
โโParameters:
โโโโ barsForward (simple int) : Number of future bars to collect data for.
โโโโ variables (simple map) : Custom values to collect on every chart bar.
โโReturns: `ChartData` object to convert between `xloc.bar_index` and `xloc.bar_time`.
โโ EXPORTED METHODS
method timestampToBarIndex(chartData, timestamp, snap)
โโConverts a UNIX timestamp to a bar index.
โโNamespace types: ChartData
โโParameters:
โโโโ chartData (series ChartData) : The `ChartData` object.
โโโโ timestamp (series int) : A UNIX time.
โโโโ snap (series Snap) : A `Snap` enum value.
โโReturns: A bar index, or `na` if unable to find the appropriate bar index.
method getNumberOfBarsBack(chartData, timestamp)
โโConverts a UNIX timestamp to a history-referencing length (i.e., number of bars back).
โโNamespace types: ChartData
โโParameters:
โโโโ chartData (series ChartData) : The `ChartData` object.
โโโโ timestamp (series int) : A UNIX time.
โโReturns: A bar offset, or `na` if unable to find a valid number of bars back.
method timeAtBarIndex(chartData, barIndex)
โโRetrieves the `time` value for the specified bar index.
โโNamespace types: ChartData
โโParameters:
โโโโ chartData (series ChartData) : The `ChartData` object.
โโโโ barIndex (int) : The bar index.
โโReturns: The `time` value, or `na` if there is no `time` stored for the bar index.
method time(chartData, length)
โโRetrieves the `time` value of the bar that is `length` bars back relative to the latest bar.
โโNamespace types: ChartData
โโParameters:
โโโโ chartData (series ChartData) : The `ChartData` object.
โโโโ length (series int) : Number of bars back.
โโReturns: The `time` value `length` bars ago, or `na` if there is no `time` stored for that bar.
method timeCloseAtBarIndex(chartData, barIndex)
โโRetrieves the `time_close` value for the specified bar index.
โโNamespace types: ChartData
โโParameters:
โโโโ chartData (series ChartData) : The `ChartData` object.
โโโโ barIndex (series int) : The bar index.
โโReturns: The `time_close` value, or `na` if there is no `time_close` stored for the bar index.
method timeClose(chartData, length)
โโRetrieves the `time_close` value of the bar that is `length` bars back from the latest bar.
โโNamespace types: ChartData
โโParameters:
โโโโ chartData (series ChartData) : The `ChartData` object.
โโโโ length (series int) : Number of bars back.
โโReturns: The `time_close` value `length` bars ago, or `na` if there is none stored.
method valueAtBarIndex(chartData, name, barIndex)
โโRetrieves the value of a custom variable for the specified bar index.
โโNamespace types: ChartData
โโParameters:
โโโโ chartData (series ChartData) : The `ChartData` object.
โโโโ name (series string) : The variable name.
โโโโ barIndex (series int) : The bar index.
โโReturns: The value of the variable, or `na` if that variable is not stored for the bar index.
method value(chartData, name, length)
โโRetrieves a variable value of the bar that is `length` bars back relative to the latest bar.
โโNamespace types: ChartData
โโParameters:
โโโโ chartData (series ChartData) : The `ChartData` object.
โโโโ name (series string) : The variable name.
โโโโ length (series int) : Number of bars back.
โโReturns: The value `length` bars ago, or `na` if that variable is not stored for the bar index.
method getAllVariablesAtBarIndex(chartData, barIndex)
โโRetrieves all custom variables for the specified bar index.
โโNamespace types: ChartData
โโParameters:
โโโโ chartData (series ChartData) : The `ChartData` object.
โโโโ barIndex (series int) : The bar index.
โโReturns: Map of all custom variables that are stored for the specified bar index.
method getEarliestStoredData(chartData)
โโGets all values from the earliest bar data that is currently stored in memory.
โโNamespace types: ChartData
โโParameters:
โโโโ chartData (series ChartData) : The `ChartData` object.
โโReturns: A tuple:
method getLatestStoredData(chartData, futureData)
โโGets all values from the latest bar data that is currently stored in memory.
โโNamespace types: ChartData
โโParameters:
โโโโ chartData (series ChartData) : The `ChartData` object.
โโโโ futureData (series bool) : Whether to include the future data that is stored in memory.
โโReturns: A tuple:
Dynamic Swing Anchored VWAP (Zeiierman)โ Overview
Dynamic Swing Anchored VWAP (Zeiierman) is a priceโvolume tool that anchors VWAP at fresh swing highs/lows and then adapts its responsiveness as conditions change. Instead of one static VWAP that drifts away over time, this indicator re-anchors at meaningful structure points (swings). It computes a decayed, volume-weighted average that can speed up in volatile markets and slow down during quiet periods.
Blending swing structure with an adaptive VWAP engine creates a fair-value path that stays aligned with current price behavior, making retests, pullbacks, and mean reversion opportunities easier to spot and trade.
โ How It Works
โช Swing Anchor Engine
The script scans for swing highs/lows using your Swing Period.
When market direction flips (new pivot confirmed), the indicator anchors a new VWAP at that pivot and starts tracking from there.
โช Adaptive VWAP Core
From each anchor , VWAP is computed using a decay model (recent priceรvolume matters more; older data matters less).
Adaptive Price Tracking lets you set the base responsiveness in โbars.โ Lower = more reactive, higher = smoother.
Volatility Adjustment (ATR vs Avg ATR) can automatically speed up the VWAP during spikes and slow it during compression, so the line stays relevant to live conditions.
โ Why This Adaptive Approach Beats a Simple VWAP
Standard VWAP is cumulative from the anchor point. As time passes and volume accumulates, it often drifts far from current price, especially in prolonged trends or multi-session moves. That drift makes retests rare and unreliable.
Dynamic Swing Anchored VWAP solves this in two ways:
โช Event-Driven Anchoring (Swings):
By restarting at fresh swing highs/lows, the VWAP reference reflects todayโs structure. You get frequent, meaningful retests because the anchor stays near the action.
โช Adaptive Responsiveness (Volatility-Aware):
Markets donโt move at one speed. When volatility expands, a fixed VWAP lags; when volatility contracts, it can overreact to noise. Here, the โtracking speedโ can auto-adjust using ATR vs its average.
High Volatility โ faster tracking: VWAP hugs price more tightly, preserving retest relevance.
Low Volatility โ smoother tracking: VWAP filters chop and stays stable.
Result: A VWAP that follows price more accurately, creating plenty of credible retest opportunities and more trustworthy mean-reversion/continuation reads than a simple, ever-growing VWAP.
โ How to Use
โช S wing-Aware Fair Value
Use the VWAP as a dynamic fair-value guide that restarts at key structural pivots. Pullbacks to the VWAP after impulsive moves often provide retest entries.
โช Trend Trading
In trends, the adaptive VWAP will ride closer to price, offering continuation pullbacks.
โ Settings
Swing Period: Number of bars to confirm swing highs/lows. Larger = bigger, cleaner pivots (slower); smaller = more frequent pivots (noisier).
Adaptive Price Tracking: Sets the base reaction speed (in bars). Lower = faster, tighter to price; higher = smoother, slower.
Adapt APT by ATR ratio: When ON, the tracking speed auto-adjusts with market volatility (ATR vs its own average). High vol โ faster; low vol โ calmer.
Volatility Bias: Controls how strongly volatility affects the speed. >1 = stronger effect; <1 = lighter touch.
-----------------
Disclaimer
The content provided in my scripts, indicators, ideas, algorithms, and systems is for educational and informational purposes only. It does not constitute financial advice, investment recommendations, or a solicitation to buy or sell any financial instruments. I will not accept liability for any loss or damage, including without limitation any loss of profit, which may arise directly or indirectly from the use of or reliance on such information.
All investments involve risk, and the past performance of a security, industry, sector, market, financial product, trading strategy, backtest, or individual's trading does not guarantee future results or returns. Investors are fully responsible for any investment decisions they make. Such decisions should be based solely on an evaluation of their financial circumstances, investment objectives, risk tolerance, and liquidity needs.
Ultimate Market Structure [Alpha Extract]Ultimate Market Structure
A comprehensive market structure analysis tool that combines advanced swing point detection, imbalance zone identification, and intelligent break analysis to identify high-probability trading opportunities.Utilizing a sophisticated trend scoring system, this indicator classifies market conditions and provides clear signals for structure breaks, directional changes, and fair value gap detection with institutional-grade precision.
๐ถ Advanced Swing Point Detection
Identifies pivot highs and lows using configurable lookback periods with optional close-based analysis for cleaner signals. The system automatically labels swing points as Higher Highs (HH), Lower Highs (LH), Higher Lows (HL), and Lower Lows (LL) while providing advanced classifications including "rising_high", "falling_high", "rising_low", "falling_low", "peak_high", and "valley_low" for nuanced market analysis.
swingHighPrice = useClosesForStructure ? ta.pivothigh(close, swingLength, swingLength) : ta.pivothigh(high, swingLength, swingLength)
swingLowPrice = useClosesForStructure ? ta.pivotlow(close, swingLength, swingLength) : ta.pivotlow(low, swingLength, swingLength)
classification = classifyStructurePoint(structureHighPrice, upperStructure, true)
significance = calculateSignificance(structureHighPrice, upperStructure, true)
๐ถ Significance Scoring System
Each structure point receives a significance level on a 1-5 scale based on its distance from previous points, helping prioritize the most important levels. This intelligent scoring system ensures traders focus on the most meaningful structure breaks while filtering out minor noise.
๐ถ Comprehensive Trend Analysis
Calculates momentum, strength, direction, and confidence levels using volatility-normalized price changes and multi-timeframe correlation. The system provides real-time trend state tracking with bullish (+1), bearish (-1), or neutral (0) direction assessment and 0-100 confidence scoring.
// Calculate trend momentum using rate of change and volatility
calculateTrendMomentum(lookback) =>
priceChange = (close - close ) / close * 100
avgVolatility = ta.atr(lookback) / close * 100
momentum = priceChange / (avgVolatility + 0.0001)
momentum
// Calculate trend strength using multiple timeframe correlation
calculateTrendStrength(shortPeriod, longPeriod) =>
shortMA = ta.sma(close, shortPeriod)
longMA = ta.sma(close, longPeriod)
separation = math.abs(shortMA - longMA) / longMA * 100
strength = separation * slopeAlignment
โHow It Works
๐ถ Imbalance Zone Detection
Identifies Fair Value Gaps (FVGs) between consecutive candles where price gaps create unfilled areas. These zones are displayed as semi-transparent boxes with optional center line mitigation tracking, highlighting potential support and resistance levels where institutional players often react.
// Detect Fair Value Gaps
detectPriceImbalance() =>
currentHigh = high
currentLow = low
refHigh = high
refLow = low
if currentOpen > currentClose
if currentHigh - refLow < 0
upperBound = currentClose - (currentClose - refLow)
lowerBound = currentClose - (currentClose - currentHigh)
centerPoint = (upperBound + lowerBound) / 2
newZone = ImbalanceZone.new(
zoneBox = box.new(bar_index, upperBound, rightEdge, lowerBound,
bgcolor=bullishImbalanceColor, border_color=hiddenColor)
)
๐ถ Structure Break Analysis
Determines Break of Structure (BOS) for trend continuation and Directional Change (DC) for trend reversals with advanced classification as "continuation", "reversal", or "neutral". The system compares pre-trend and post-trend states for each break, providing comprehensive trend change momentum analysis.
๐ถ Intelligent Zone Management
Features partial mitigation tracking when price enters but doesn't fully fill zones, with automatic zone boundary adjustment during partial fills. Smart array management keeps only recent structure points for optimal performance while preventing duplicate signals from the same level.
๐ถ Liquidity Zone Detection
Automatically identifies potential liquidity zones at key structure points for institutional trading analysis. The system tracks broken structure points and provides adaptive zone extension with configurable time-based limits for imbalance areas.
๐ถ Visual Structure Mapping
Provides clear visual indicators including swing labels with color-coded significance levels, dashed lines connecting break points with BOS/DC labels, and break signals for continuation and reversal patterns. The adaptive zones feature smart management with automatic mitigation tracking.
๐ถ Market Structure Interpretation
HH/HL patterns indicate bullish market structure with trend continuation likelihood, while LH/LL patterns signal bearish structure with downtrend continuation expected. BOS signals represent structure breaks in trend direction for continuation opportunities, while DC signals warn of potential reversals.
๐ถ Performance Optimization
Automatic cleanup of old structure points (keeps last 8 points), recent break tracking (keeps last 5 break events), and efficient array management ensure smooth performance across all timeframes and market conditions.
Why Choose Ultimate Market Structure ?
This indicator provides traders with institutional-grade market structure analysis, combining multiple analytical approaches into one comprehensive tool. By identifying key structure levels, imbalance zones, and break patterns with advanced significance scoring, it helps traders understand market dynamics and position themselves for high-probability trade setups in alignment with smart money concepts. The sophisticated trend scoring system and intelligent zone management make it an essential tool for any serious trader looking to decode market structure with precision and confidence.
Eigenvector Centrality Drift (ECD) - Market State Network What is Eigenvector Centrality Drift (ECD)?
Eigenvector Centrality Drift (ECD) is a groundbreaking indicator that applies concepts from network science to financial markets. Instead of viewing price as a simple series, ECD models the market as a dynamic network of โmicro-statesโโdistinct combinations of price, volatility, and volume. By tracking how the influence of these states changes over time, ECD helps you spot regime shifts and transitions in market character before they become obvious in price.
This is not another moving average or momentum oscillator. ECD is inspired by eigenvector centralityโa measure of influence in network theoryโand adapts it to the world of price action, volatility, and volume. Itโs about understanding which market states are โin controlโ and when that control is about to change.
Theoretical Foundation
Network Science: In complex systems, nodes (states) and edges (transitions) form a network. Eigenvector centrality measures how influential a node is, not just by its direct connections, but by the influence of the nodes it connects to.
Market Micro-States: Each bar is classified into a โstateโ based on price change, volatility, and volume. The market transitions between these states, forming a network of possible regimes.
Centrality Drift: By tracking the centrality (influence) of the current state, and how it changes (drifts) over time, ECD highlights when the marketโs โcenter of gravityโ is shiftingโoften a precursor to major moves or regime changes.
How ECD Works
State Classification: Each bar is assigned to one of N market micro-states, based on a weighted combination of normalized price change, volatility, and volume.
Transition Matrix: Over a rolling window, ECD tracks how often the market transitions from each state to every other state, forming a transition probability matrix.
Centrality Calculation: Using a simplified eigenvector approach, ECD calculates the โinfluenceโ score for each state, reflecting how central it is to the network of recent market behavior.
Centrality Drift: The indicator tracks the Z-score of the change in centrality for the current state. Rapid increases or decreases, or a shift in the dominant state, signal a potential regime shift.
Dominant State: ECD also highlights which state currently has the highest influence, providing insight into the prevailing market character.
Inputs:
๐ Market State Configuration
Number of Market States (n_states, default 6): Number of distinct micro-states to track.
3โ4: Simple (Up/Down/Sideways)
5โ6: Balanced (recommended)
7โ9: Complex, more nuanced
Price Change Weight (price_weight, default 0.4):
How much price movement defines a state. Higher = more directional.
Volatility Weight (vol_weight, default 0.3):
How much volatility defines a state. Higher = more regime focus.
Volume Weight (volume_weight, default 0.3):
How much volume defines a state. Higher = more participation focus.
๐ Network Analysis
Transition Matrix Window (transition_window, default 50): Lookback for building the state transition matrix.
Shorter: Adapts quickly
Longer: More stable
Influence Decay Factor (influence_decay, default 0.85): How much influence propagates through the network.
Higher: Distant transitions matter more
Lower: Only immediate transitions matter
Drift Detection Sensitivity (drift_sensitivity, default 1.5): Z-score threshold for significant centrality drift.
Lower: More signals
Higher: Only major shifts
๐จ Visualization
Show Network Visualization (show_network, default true): Background color and effects based on network structure.
Show Centrality Score (show_centrality, default true): Plots the current stateโs centrality measure.
Show Drift Indicator (show_drift, default true): Plots the centrality drift Z-score.
Show State Map (show_state_map, default true): Dashboard showing all state centralities and which is dominant.
Color Scheme (color_scheme, default "Quantum"):
โQuantumโ: Cyan/Magenta
โNeuralโ: Green/Blue
โPlasmaโ: Yellow/Pink
โMatrixโ: Green/Black
Color Schemes
Dynamic gradients reflect the current stateโs centrality and drift, using your chosen color palette.
Background network effect: The more central the current state, the more intense the background.
Centrality and drift lines: Color-coded for clarity and regime shift detection.
Visual Logic
Centrality Score Line: Plots the influence of the current state, with glow for emphasis.
Drift Indicator: Histogram of centrality drift Z-score, green for positive, red for negative.
Threshold Lines: Dotted lines mark the drift sensitivity threshold for regime shift alerts.
State Map Dashboard: Top-right panel shows all state centralities, highlights the current and dominant state, and visualizes influence with bars.
Information Panel: Bottom-left panel summarizes current state, centrality, dominant state, drift Z-score, and regime shift status.
How to Use ECD
Centrality Score: High = current state is highly influential; low = state is peripheral.
Drift Z-Score:
Large positive/negative = rapid change in influence, regime shift likely.
Near zero = stable network, no major shift.
Dominant State: The state with the highest centrality is โin controlโ of the marketโs transitions.
State Map: Use to see which states are rising or falling in influence.
Tips:
Use fewer states for simple markets, more for nuanced analysis.
Watch for drift Z-score crossing the thresholdโthese are your regime shift signals.
Combine with your own system for confirmation.
Alerts:
ECD Regime Shift: Significant centrality drift detectedโpotential regime change.
ECD State Change: Market state transition occurred.
ECD Dominance Shift: Dominant market state has changed.
Originality & Usefulness
ECD is not a mashup or rehash of standard indicators. It is a novel application of network science and eigenvector centrality to market microstructure, providing a new lens for understanding regime shifts and market transitions. The state network, centrality drift, and dashboard are unique to this script. ECD is designed for anticipation, not confirmationโhelping you see the marketโs โcenter of gravityโ shift before price action makes it obvious.
Chart Info
Script Name: Eigenvector Centrality Drift (ECD) โ Market State Network
Recommended Use: Any asset, any timeframe. Tune parameters to your style.
Disclaimer
This script is for research and educational purposes only. It does not provide financial advice or direct buy/sell signals. Always use proper risk management and combine with your own strategy. Past performance is not indicative of future results.
See the market as a network. Anticipate the shift in influence.
โ Dskyz , for DAFE Trading Systems
Magic Touch Line DetectorSummary of the Magic Touch Line Detector Script:
Purpose:
The Magic Touch Line Detector script is designed to identify significant price points in the market by analyzing candlestick wicks and bodies. It plots lines based on the detected wicks, classifying them as either ascending or descending. The script tracks how frequently price touches these lines and highlights the "most touched" lines for both ascending and descending categories. This script is particularly useful for traders looking to identify key price levels and trends over time.
How It Works:
Wick and Body Detection:
The script starts by analyzing the highs and lows of candlestick wicks relative to their bodies over a user-defined lookback period. A significant wick is identified based on a specified wick-to-body ratio and a deviation threshold measured against the Average True Range (ATR).
Line Creation:
Once a significant upper or lower wick is detected, the script calculates unconventional highs and lows (i.e., points that differ from the absolute highs and lows of the lookback period). Lines are then drawn from these unconventional price points using the slope between the detected wick and the current bar, ensuring a smooth extension.
Line Refinement and Touch Tracking:
As new bars are added, the script tracks how often the price touches the previously drawn lines. The number of touches each line receives is counted and updated in real-time, and the script ensures that only the most touched line is highlighted.
Highlighting and Labeling:
For each category (ascending and descending), the most touched line is identified and given special highlighting with thicker lines and different colors. Labels are also generated to show the number of touches that the most touched line has received. Old labels are cleared to avoid clutter.
Explanation of the Settings:
Lookback Period for Highs and Lows:
This sets the number of bars the script will use to detect the highest highs and lowest lows. A larger lookback period gives the script a broader context to work with, potentially identifying more significant price points.
Minimum Wick-to-Body Ratio:
This ratio determines what qualifies as a "significant" wick. It compares the length of the wick to the body of the candle. A higher ratio means that only wicks that are much longer than the candle body will be considered significant.
Price Deviation Threshold (in ATR multiples):
This setting controls how much price deviation from the ATR is required for a wick to be deemed significant. It acts as a filter to reduce noise by ignoring smaller wicks that are within normal price movements.
Line Touch Tolerance Factor (ATR multiple):
When checking if a price touches a line, the script uses this setting to define how close the price must be to the line to count as a "touch." This tolerance is a multiplier of the ATR, allowing for some flexibility in what is considered a touch.
Price Difference Threshold:
This defines the minimum price difference required to plot a line. If the price difference between the high and low of a detected wick is too small, the script can avoid plotting a line for insignificant moves.
Slope Adjustment Multiplier:
This multiplier adjusts the slope of the lines that are drawn from detected price points. It affects the length and angle of the lines, allowing users to control how far and at what angle the lines should extend across the chart.
Customization Options:
Show Ascending/Descending Lines:
These toggles allow users to decide whether ascending (bullish) or descending (bearish) lines should be shown on the chart.
Line Color, Style, and Width (for Ascending and Descending Lines):
These settings give users control over how the lines appear visually. You can customize the color, style (solid, dashed, dotted), and width of both ascending and descending lines.
Most Touched Line Color:
Users can define a different color for the "most touched" line, which is automatically identified by the script. This setting helps highlight the line that has been interacted with the most by the price.
How to Use the Script:
Setup the Lookback Period and Deviation Filters:
Start by setting the lookback period and the filters for wick-to-body ratio and deviation threshold. These settings help control the script's sensitivity to market movements.
Refine the Tolerance and Slope:
Adjust the line touch tolerance and slope adjustment multiplier to control how closely the script tracks price touches and how the lines are extended on the chart.
Customize Visuals:
Once the lines are being drawn, customize the colors, styles, and widths to ensure the lines are easy to read on your chart. You can also decide if you want to display both ascending and descending lines or focus on just one.
By setting up the script based on these inputs and parameters, you can get a real-time view of significant price levels and how often the price interacts with them, helping you make more informed trading decisions.
DRIP Yearly PerformanceOverview: The DRIP Yearly Performance indicator is designed for long-term investors using Dividend Reinvestment Plans (DRIP). This script calculates both the total and average yearly performance of an asset, factoring in the reinvestment of dividends over time. It provides key insights into portfolio growth by tracking the number of accumulated units from dividend reinvestment and how this impacts overall performance.
Key Features:
Dividend Reinvestment (DRIP) Calculation: Automatically adjusts the number of units held by reinvesting dividends, enhancing the calculation of total returns.
Custom Start Date: Choose a custom start date to begin tracking performance from a specific time period, allowing for more tailored performance analysis.
Performance Metrics: Displays key metrics such as the initial investment value, current value, total performance percentage, and the average yearly performance, all in an easy-to-read table format.
Visual Representation: Plots accumulated units and overall performance on the chart, with customizable colors for clarity.
Inputs Explained:
Start Quantity: Define the initial number of units (shares) held at the start of the investment.
Dividend Type: Choose between tracking Net or Gross dividends for reinvestment purposes. Net is always better unless you have a special case and you need to base your calculations on gross.
Start Date: Select a custom date to begin tracking performance. This allows users to focus on performance from any historical point.
Table Size: Customize the size of the text in the performance table to suit your visual preferences.
Performance Line Color: Choose the color of the performance plot line that tracks the value of your investment over time.
Accumulator Line Color: Customize the color of the line that tracks the accumulated units (shares) due to reinvested dividends.
Who Can Benefit: This indicator is ideal for long-term investors and dividend growth investors who want to measure their investment returns over time while factoring in the effects of dividend reinvestment.
Use Cases:
Tracking Dividend Impact: See how reinvesting dividends enhances your overall portfolio value.
Custom Performance Analysis: Set a custom start date to analyze performance from a specific point in time.
Visualizing Growth: Use the chart's plots to visually track your growing number of shares (units) and overall performance.
Trading Sessions + IB [midst]What It Does
Displays the three major global trading sessions (Asia, London, New York) with Initial Balance (IB) ranges and extension levels. Automatically detects instrument type (ES, NQ, Gold, Silver) and applies correct IB period.
Key Features
Session Boxes: Visual high-to-low range for each session
Initial Balance: First 60 minutes of session range with IB high/mid/low lines
IB Extensions: Automatic calculation of +/-25%, 50%, 100% levels
Live IB Tracker: Real-time statistics table showing IB range, analysis, and market structure
Fully Customizable: Colors, line styles, labels, and display options
Why Use This
Identify key support/resistance levels based on session structure
Track IB breakouts for high-probability trade setups
Use extensions as profit targets or reversal zones
Compare session ranges to gauge volatility
Spot session overlaps for increased liquidity
Default Times (Chicago/Central Time)
Asia: 5:00 PM - 2:00 AM
London: 2:00 AM - 11:00 AM
New York: 7:30 AM - 4:00 PM
How To Use
Add indicator to your chart (works best on 5-15 minute timeframes)
Indicator auto-detects ES, NQ, GC, SI and applies correct 60-minute IB
Watch for price action at IB levels and extensions
Use IB Tracker table for real-time market analysis
Customization
Adjust everything: session times, IB period, colors, line styles, labels, table position. Toggle historical sessions, IB boxes, lines, extensions, and more.
Supported Instruments: ES/MES, NQ/MNQ, GC/MGC (Gold), SI (Silver) - auto-detection included
DCA Percent SignalOverview
The DCA Percent Signal Indicator generates buy and sell signals based on percentage drops from all-time highs and percentage gains from lowest lows since ATH. This indicator is designed for pyramiding strategies where each signal represents a configurable percentage of equity allocation.
Definitions
DCA (Dollar-Cost Averaging): An investment strategy where you invest a fixed amount at regular intervals, regardless of price fluctuations. This indicator generates signals for a DCA-style pyramiding approach.
Gann Bar Types: Classification system for price bars based on their relationship to the previous bar:
Up Bar: High > previous high AND low โฅ previous low
Down Bar: High โค previous high AND low < previous low
Inside Bar: High โค previous high AND low โฅ previous low
Outside Bar: High > previous high AND low < previous low
ATH (All-Time High): The highest price level reached during the entire chart period
ATL (All-Time Low): The lowest price level reached since the most recent ATH
Pyramiding: A trading strategy that adds to positions on favorable price movements
Look-Ahead Bias: Using future information that wouldn't be available in real-time trading
Default Properties
Signal Thresholds:
Buy Threshold: 10% (triggers every 10% drop from ATH)
Sell Threshold: 30% (triggers every 30% gain from lowest low since ATH)
Price Sources:
ATH Tracking: High (ATH detection)
ATL Tracking: Low (low detection)
Buy Signal Source: Low (buy signals)
Sell Signal Source: High (sell signals)
Filter Options:
Apply Gann Filter: False (disabled by default)
Buy Sets ATL: False (disabled by default)
Display Options:
Show Buy/Sell Signals: True
Show Reference Lines: True
Show Info Table: False
Show Bar Type: False
How It Works
Buy Signals: Trigger every 10% drop from the all-time highest price reached
Sell Signals: Trigger every 30% increase from the lowest low since the most recent all-time high
Smart Tracking: Uses configurable price sources for signal generation
Key Features
Configurable Thresholds: Adjustable buy/sell percentage thresholds (default: 10%/30%)
Separate Price Sources: Independent sources for ATH tracking, ATL tracking, and signal triggers
Configurable Signals: Uses low for buy signals and high for sell signals by default
Optional Gann Filter: Apply Gann bar analysis for additional signal filtering
Optional Buy Sets ATL: Option to set ATL reference point when buy signals occur
Visual Debug: Detailed labels showing signal parameters and values
Usage Instructions
Apply to Chart: Use on any timeframe (recommended: 1D or higher for better signal quality)
Risk Management: Adjust thresholds based on your risk tolerance and market volatility
Signal Analysis: Monitor debug labels for detailed signal information and validation
Signal Logic
Buy signals are blocked when ATH increases to prevent buying at peaks
Sell signals are blocked when ATL decreases to prevent selling at lows
This ensures signals only trigger on subsequent bars, not the same bar that establishes new reference points
Buy Signals:
Calculate drop percentage from ATH to buy signal source
Trigger when drop reaches threshold increments (10%, 20%, 30%, etc.)
Always blocked on ATH bars to prevent buying at peaks
Optional: Also blocked on up/outside bars when Gann filter enabled
Sell Signals:
Calculate gain percentage from lowest low to sell signal source
Trigger when gain reaches threshold increments (30%, 60%, 90%, etc.)
Always blocked when ATL decreases to prevent selling at lows
Optional: Also blocked on down bars when Gann filter enabled
Limitations
Designed for trending markets; may generate many signals in sideways/ranging markets
Requires sufficient price movement to be effective
Not suitable for scalping or very short timeframes
Implementation Notes
Signals use optimistic price sources (low for buys, high for sells), these can be configured to be more conservative
Gann filter provides additional signal filtering based on bar types
Debug information available in data window for real-time analysis
Detailed labels on each signal show ATH, lowest low, buy level, sell level, and drop/gain percentages
BK AK-SILENCER (P8N)๐จIntroducing BK AK-SILENCER (P8N) โ Institutional Order Flow Tracking for Silent Precision๐จ
After months of meticulous tuning and refinement, I'm proud to unleash the next weapon in my trading arsenalโBK AK-SILENCER (P8N).
๐ฅ Why "AK-SILENCER"? The True Meaning
Institutions donโt announce their movesโthey move silently, hidden beneath the noise. The SILENCER is built specifically to detect and track these stealth institutional maneuvers, giving you the power to hunt quietly, execute decisively, and strike precisely before the market catches on.
๐น "AK" continues the legacy, honoring my mentor, A.K., whose teachings on discipline, precision, and clarity form the cornerstone of my trading.
๐น "SILENCER" symbolizes the stealth aspect of institutional tradingโquiet but deadly moves. This indicator equips you to silently track, expose, and capitalize on their hidden footprints.
๐ง What Exactly is BK AK-SILENCER (P8N)?
It's a next-generation Cumulative Volume Delta (CVD) tool crafted specifically for traders who hunt institutional order flow, combining adaptive volatility bands, enhanced momentum gradients, and precise divergence detection into a single deadly-accurate weapon.
Built for silent executionโtracking moves quietly and trading with lethal precision.
โ๏ธ Core Weapon Systems
โ
Institutional CVD Engine
โ Dynamically measures hidden volume shifts (buying/selling pressure) to reveal institutional footprints that price alone won't show.
โ
Adaptive AK-9 Bollinger Bands
โ Bollinger Bands placed around a custom CVD signal line, pinpointing exactly when institutional accumulation or distribution reaches critical extremes.
โ
Gradient Momentum Intelligence
โ Color-coded momentum gradients reveal the strength, speed, and silent intent behind institutional order flow:
๐ข Strong Bullish (aggressive buying)
๐ก Moderate Bullish (steady accumulation)
๐ต Neutral (balance)
๐ Moderate Bearish (quiet distribution)
๐ด Strong Bearish (aggressive selling)
โ
Silent Divergence Detection
โ Instantly spots divergence between price and hidden volumeโyour earliest indication that institutions are stealthily reversing direction.
โ
Background Flash Alerts
โ Visually highlights institutional extremes through subtle background flashes, alerting you quietly yet powerfully when market-moving players make their silent moves.
โ
Structural & Institutional Clarity
โ Optional structural pivots, standard deviation bands, volume profile anchors, and session lines clearly identify the exact levels institutions defend or attack silently.
๐ก๏ธ Why BK AK-SILENCER (P8N) is Your Edge
๐น Tracks Institutional FootprintsโSilently identifies hidden volume signals of institutional intentions before theyโre obvious.
๐น Precision ExecutionโCuts through noise, allowing you to execute silently, confidently, and precisely.
๐น Perfect for Traders Using:
Elliott Wave
Gann Methods (Angles, Squares)
Fibonacci Time & Price
Harmonic Patterns
Market Profile & Order Flow Analysis
๐ฏ How to Use BK AK-SILENCER (P8N)
๐ธ Institutional Reversal Hunting (Stealth Mode)
Bearish divergence + CVD breaking below lower BB โ stealth short signal.
Bullish divergence + CVD breaking above upper BB โ quiet, early long entry.
๐ธ Momentum Confirmation (Silent Strength)
Strong bullish gradient + CVD above upper BB โ follow institutional buying quietly.
Strong bearish gradient + CVD below lower BB โ confidently short institutional selling.
๐ธ Noise Filtering (Patience & Precision)
Neutral gradient (blue) โ remain quiet, wait patiently to strike precisely when institutional activity resumes.
๐ธ Structural Precision (Institutional Levels)
Optional StdDev, POC, Value Areas, Session Anchors clearly identify exact institutional defense/offense zones.
๐ Final Thoughts
Institutions move in silence, leaving subtle footprints. BK AK-SILENCER (P8N) is your specialized weapon for tracking and hunting their quiet, decisive actions before the market reacts.
๐น Dedicated in deep gratitude to my mentor, A.K.โwhose silent wisdom shapes every line of code.
๐น Engineered for the disciplined, quiet hunter who knows when to wait patiently and when to strike decisively.
Above all, honor and gratitude to Gdโthe ultimate source of wisdom, clarity, and disciplined execution. Without Him, markets are chaos. With Him, we move silently, purposefully, and precisely.
โก Stay Quiet. Stay Precise. Hunt Silently.
๐ฅ BK AK-SILENCER (P8N) โ Track the Silent Moves. Strike with Precision. ๐ฅ
May Gd bless every silent step you take. ๐
[FS] Time & Cycles Time & Cycles
A comprehensive trading session indicator that helps traders identify and track key market sessions and their price levels. This tool is particularly useful for forex and futures traders who need to monitor multiple trading sessions.
Key Features:
โข Multiple Session Support:
- London Session
- New York Session
- Sydney Session
- Asia Session
- Customizable TBD Session
โข Session Visualization:
- Clear session boxes with customizable colors
- Session labels with adjustable visibility
- Support for sessions crossing midnight
- Timezone-aware calculations
โข Price Level Tracking:
- Daily High/Low levels
- Weekly High/Low levels
- Previous session High/Low levels
- Customizable history depth for each level type
โข Customization Options:
- Adjustable colors for each session
- Customizable border styles
- Label visibility controls
- Timezone selection
- History level depth settings
โข Technical Features:
- High-performance calculation engine
- Support for multiple timeframes
- Efficient memory usage
- Clean and intuitive visual display
Perfect for:
โข Forex traders monitoring multiple sessions
โข Futures traders tracking market hours
โข Swing traders identifying key session levels
โข Day traders planning their trading hours
โข Market analysts studying session patterns
The indicator helps traders:
- Identify active trading sessions
- Track session-specific price levels
- Monitor market activity across different time zones
- Plan trades based on session boundaries
- Analyze price action within specific sessions
Note: This indicator is designed to work across all timeframes and is optimized for performance with minimal impact on chart loading times.
lib_smcLibrary "lib_smc"
This is an adaptation of LuxAlgo's Smart Money Concepts indicator with numerous changes. Main changes include integration of object based plotting, plenty of performance improvements, live tracking of Order Blocks, integration of volume profiles to refine Order Blocks, and many more.
This is a library for developers, if you want this converted into a working strategy, let me know.
buffer(item, len, force_rotate)
โโParameters:
โโโโ item (float)
โโโโ len (int)
โโโโ force_rotate (bool)
buffer(item, len, force_rotate)
โโParameters:
โโโโ item (int)
โโโโ len (int)
โโโโ force_rotate (bool)
buffer(item, len, force_rotate)
โโParameters:
โโโโ item (Profile type from robbatt/lib_profile/32)
โโโโ len (int)
โโโโ force_rotate (bool)
swings(len)
โโINTERNAL: detect swing points (HH and LL) in given range
โโParameters:
โโโโ len (simple int) : range to check for new swing points
โโReturns: values are the price level where and if a new HH or LL was detected, else na
method init(this)
โโNamespace types: OrderBlockConfig
โโParameters:
โโโโ this (OrderBlockConfig)
method delete(this)
โโNamespace types: OrderBlock
โโParameters:
โโโโ this (OrderBlock)
method clear_broken(this, broken_buffer)
โโINTERNAL: delete internal order blocks box coordinates if top/bottom is broken
โโNamespace types: map
โโParameters:
โโโโ this (map)
โโโโ broken_buffer (map)
โโReturns: any_bull_ob_broken, any_bear_ob_broken, broken signals are true if an according order block was broken/mitigated, broken contains the broken block(s)
create_ob(id, mode, start_t, start_i, top, end_t, end_i, bottom, break_price, early_confirmation_price, config, init_plot, force_overlay)
โโINTERNAL: set internal order block coordinates
โโParameters:
โโโโ id (int)
โโโโ mode (int) : 1: bullish, -1 bearish block
โโโโ start_t (int)
โโโโ start_i (int)
โโโโ top (float)
โโโโ end_t (int)
โโโโ end_i (int)
โโโโ bottom (float)
โโโโ break_price (float)
โโโโ early_confirmation_price (float)
โโโโ config (OrderBlockConfig)
โโโโ init_plot (bool)
โโโโ force_overlay (bool)
โโReturns: signals are true if an according order block was broken/mitigated
method align_to_profile(block, align_edge, align_break_price)
โโNamespace types: OrderBlock
โโParameters:
โโโโ block (OrderBlock)
โโโโ align_edge (bool)
โโโโ align_break_price (bool)
method create_profile(block, opens, tops, bottoms, closes, values, resolution, vah_pc, val_pc, args, init_calculated, init_plot, force_overlay)
โโNamespace types: OrderBlock
โโParameters:
โโโโ block (OrderBlock)
โโโโ opens (array)
โโโโ tops (array)
โโโโ bottoms (array)
โโโโ closes (array)
โโโโ values (array)
โโโโ resolution (int)
โโโโ vah_pc (float)
โโโโ val_pc (float)
โโโโ args (ProfileArgs type from robbatt/lib_profile/32)
โโโโ init_calculated (bool)
โโโโ init_plot (bool)
โโโโ force_overlay (bool)
method create_profile(block, resolution, vah_pc, val_pc, args, init_calculated, init_plot, force_overlay)
โโNamespace types: OrderBlock
โโParameters:
โโโโ block (OrderBlock)
โโโโ resolution (int)
โโโโ vah_pc (float)
โโโโ val_pc (float)
โโโโ args (ProfileArgs type from robbatt/lib_profile/32)
โโโโ init_calculated (bool)
โโโโ init_plot (bool)
โโโโ force_overlay (bool)
track_obs(swing_len, hh, ll, top, btm, bull_bos_alert, bull_choch_alert, bear_bos_alert, bear_choch_alert, min_block_size, max_block_size, config_bull, config_bear, init_plot, force_overlay, enabled, extend_blocks, clear_broken_buffer_before, align_edge_to_value_area, align_break_price_to_poc, profile_args_bull, profile_args_bear, use_soft_confirm, soft_confirm_offset, use_retracements_with_FVG_out)
โโParameters:
โโโโ swing_len (int)
โโโโ hh (float)
โโโโ ll (float)
โโโโ top (float)
โโโโ btm (float)
โโโโ bull_bos_alert (bool)
โโโโ bull_choch_alert (bool)
โโโโ bear_bos_alert (bool)
โโโโ bear_choch_alert (bool)
โโโโ min_block_size (float)
โโโโ max_block_size (float)
โโโโ config_bull (OrderBlockConfig)
โโโโ config_bear (OrderBlockConfig)
โโโโ init_plot (bool)
โโโโ force_overlay (bool)
โโโโ enabled (bool)
โโโโ extend_blocks (simple bool)
โโโโ clear_broken_buffer_before (simple bool)
โโโโ align_edge_to_value_area (simple bool)
โโโโ align_break_price_to_poc (simple bool)
โโโโ profile_args_bull (ProfileArgs type from robbatt/lib_profile/32)
โโโโ profile_args_bear (ProfileArgs type from robbatt/lib_profile/32)
โโโโ use_soft_confirm (simple bool)
โโโโ soft_confirm_offset (float)
โโโโ use_retracements_with_FVG_out (simple bool)
method draw(this, config, extend_only)
โโNamespace types: OrderBlock
โโParameters:
โโโโ this (OrderBlock)
โโโโ config (OrderBlockConfig)
โโโโ extend_only (bool)
method draw(blocks, config)
โโINTERNAL: plot order blocks
โโNamespace types: array
โโParameters:
โโโโ blocks (array)
โโโโ config (OrderBlockConfig)
method draw(blocks, config)
โโINTERNAL: plot order blocks
โโNamespace types: map
โโParameters:
โโโโ blocks (map)
โโโโ config (OrderBlockConfig)
method cleanup(this, ob_bull, ob_bear)
โโremoves all Profiles that are older than the latest OrderBlock from this profile buffer
โโNamespace types: array
โโParameters:
โโโโ this (array type from robbatt/lib_profile/32)
โโโโ ob_bull (OrderBlock)
โโโโ ob_bear (OrderBlock)
_plot_swing_points(mode, x, y, show_swing_points, linecolor_swings, keep_history, show_latest_swings_levels, trail_x, trail_y, trend)
โโINTERNAL: plot swing points
โโParameters:
โโโโ mode (int) : 1: bullish, -1 bearish block
โโโโ x (int) : x-coordingate of swing point to plot (bar_index)
โโโโ y (float) : y-coordingate of swing point to plot (price)
โโโโ show_swing_points (bool) : switch to enable/disable plotting of swing point labels
โโโโ linecolor_swings (color) : color for swing point labels and lates level lines
โโโโ keep_history (bool) : weater to remove older swing point labels and only keep the most recent
โโโโ show_latest_swings_levels (bool)
โโโโ trail_x (int) : x-coordinate for latest swing point (bar_index)
โโโโ trail_y (float) : y-coordinate for latest swing point (price)
โโโโ trend (int) : the current trend 1: bullish, -1: bearish, to determine Strong/Weak Low/Highs
_pivot_lvl(mode, trend, hhll_x, hhll, super_hhll, filter_insignificant_internal_breaks)
โโINTERNAL: detect whether a structural level has been broken and if it was in trend direction (BoS) or against trend direction (ChoCh), also track the latest high and low swing points
โโParameters:
โโโโ mode (simple int) : detect 1: bullish, -1 bearish pivot points
โโโโ trend (int) : current trend direction
โโโโ hhll_x (int) : x-coordinate of newly detected hh/ll (bar_index)
โโโโ hhll (float) : y-coordinate of newly detected hh/ll (price)
โโโโ super_hhll (float) : level/y-coordinate of superior hhll (if this is an internal structure pivot level)
โโโโ filter_insignificant_internal_breaks (bool) : if true pivot points / internal structure will be ignored where the wick in trend direction is longer than the opposite (likely to push further in direction of main trend)
โโReturns: coordinates of internal structure that has been broken (x,y): start of structure, (trail_x, trail_y): tracking hh/ll after structure break, (bos_alert, choch_alert): signal whether a structural level has been broken
_plot_structure(x, y, is_bos, is_choch, line_color, line_style, label_style, label_size, keep_history)
โโINTERNAL: plot structural breaks (BoS/ChoCh)
โโParameters:
โโโโ x (int) : x-coordinate of newly broken structure (bar_index)
โโโโ y (float) : y-coordinate of newly broken structure (price)
โโโโ is_bos (bool) : whether this structural break was in trend direction
โโโโ is_choch (bool) : whether this structural break was against trend direction
โโโโ line_color (color) : color for the line connecting the structural level and the breaking candle
โโโโ line_style (string) : style (line.style_dashed/solid) for the line connecting the structural level and the breaking candle
โโโโ label_style (string) : style (label.style_label_down/up) for the label above/below the line connecting the structural level and the breaking candle
โโโโ label_size (string) : size (size.small/tiny) for the label above/below the line connecting the structural level and the breaking candle
โโโโ keep_history (bool) : weater to remove older swing point labels and only keep the most recent
structure_values(length, super_hh, super_ll, filter_insignificant_internal_breaks)
โโdetect (and plot) structural breaks and the resulting new trend
โโParameters:
โโโโ length (simple int) : lookback period for swing point detection
โโโโ super_hh (float) : level/y-coordinate of superior hh (for internal structure detection)
โโโโ super_ll (float) : level/y-coordinate of superior ll (for internal structure detection)
โโโโ filter_insignificant_internal_breaks (bool) : if true pivot points / internal structure will be ignored where the wick in trend direction is longer than the opposite (likely to push further in direction of main trend)
โโReturns: trend: direction 1:bullish -1:bearish, (bull_bos_alert, bull_choch_alert, top_x, top_y, trail_up_x, trail_up): whether and which level broke in a bullish direction, trailing high, (bbear_bos_alert, bear_choch_alert, tm_x, btm_y, trail_dn_x, trail_dn): same in bearish direction
structure_plot(trend, bull_bos_alert, bull_choch_alert, top_x, top_y, trail_up_x, trail_up, hh, bear_bos_alert, bear_choch_alert, btm_x, btm_y, trail_dn_x, trail_dn, ll, color_bull, color_bear, show_swing_points, show_latest_swings_levels, show_bos, show_choch, line_style, label_size, keep_history)
โโdetect (and plot) structural breaks and the resulting new trend
โโParameters:
โโโโ trend (int) : crrent trend 1: bullish, -1: bearish
โโโโ bull_bos_alert (bool) : if there was a bullish bos alert -> plot it
โโโโ bull_choch_alert (bool) : if there was a bullish choch alert -> plot it
โโโโ top_x (int) : latest shwing high x
โโโโ top_y (float) : latest swing high y
โโโโ trail_up_x (int) : trailing high x
โโโโ trail_up (float) : trailing high y
โโโโ hh (float) : if there was a higher high
โโโโ bear_bos_alert (bool) : if there was a bearish bos alert -> plot it
โโโโ bear_choch_alert (bool) : if there was a bearish chock alert -> plot it
โโโโ btm_x (int) : latest swing low x
โโโโ btm_y (float) : latest swing low y
โโโโ trail_dn_x (int) : trailing low x
โโโโ trail_dn (float) : trailing low y
โโโโ ll (float) : if there was a lower low
โโโโ color_bull (color) : color for bullish BoS/ChoCh levels
โโโโ color_bear (color) : color for bearish BoS/ChoCh levels
โโโโ show_swing_points (bool) : whether to plot swing point labels
โโโโ show_latest_swings_levels (bool) : whether to track and plot latest swing point levels with lines
โโโโ show_bos (bool) : whether to plot BoS levels
โโโโ show_choch (bool) : whether to plot ChoCh levels
โโโโ line_style (string) : whether to plot BoS levels
โโโโ label_size (string) : label size of plotted BoS/ChoCh levels
โโโโ keep_history (bool) : weater to remove older swing point labels and only keep the most recent
structure(length, color_bull, color_bear, super_hh, super_ll, filter_insignificant_internal_breaks, show_swing_points, show_latest_swings_levels, show_bos, show_choch, line_style, label_size, keep_history, enabled)
โโdetect (and plot) structural breaks and the resulting new trend
โโParameters:
โโโโ length (simple int) : lookback period for swing point detection
โโโโ color_bull (color) : color for bullish BoS/ChoCh levels
โโโโ color_bear (color) : color for bearish BoS/ChoCh levels
โโโโ super_hh (float) : level/y-coordinate of superior hh (for internal structure detection)
โโโโ super_ll (float) : level/y-coordinate of superior ll (for internal structure detection)
โโโโ filter_insignificant_internal_breaks (bool) : if true pivot points / internal structure will be ignored where the wick in trend direction is longer than the opposite (likely to push further in direction of main trend)
โโโโ show_swing_points (bool) : whether to plot swing point labels
โโโโ show_latest_swings_levels (bool) : whether to track and plot latest swing point levels with lines
โโโโ show_bos (bool) : whether to plot BoS levels
โโโโ show_choch (bool) : whether to plot ChoCh levels
โโโโ line_style (string) : whether to plot BoS levels
โโโโ label_size (string) : label size of plotted BoS/ChoCh levels
โโโโ keep_history (bool) : weater to remove older swing point labels and only keep the most recent
โโโโ enabled (bool)
_check_equal_level(mode, len, eq_threshold, enabled)
โโINTERNAL: detect equal levels (double top/bottom)
โโParameters:
โโโโ mode (int) : detect 1: bullish/high, -1 bearish/low pivot points
โโโโ len (int) : lookback period for equal level (swing point) detection
โโโโ eq_threshold (float) : maximum price offset for a level to be considered equal
โโโโ enabled (bool)
โโReturns: eq_alert whether an equal level was detected and coordinates of the first and the second level/swing point
_plot_equal_level(show_eq, x1, y1, x2, y2, label_txt, label_style, label_size, line_color, line_style, keep_history)
โโINTERNAL: plot equal levels (double top/bottom)
โโParameters:
โโโโ show_eq (bool) : whether to plot the level or not
โโโโ x1 (int) : x-coordinate of the first level / swing point
โโโโ y1 (float) : y-coordinate of the first level / swing point
โโโโ x2 (int) : x-coordinate of the second level / swing point
โโโโ y2 (float) : y-coordinate of the second level / swing point
โโโโ label_txt (string) : text for the label above/below the line connecting the equal levels
โโโโ label_style (string) : style (label.style_label_down/up) for the label above/below the line connecting the equal levels
โโโโ label_size (string) : size (size.tiny) for the label above/below the line connecting the equal levels
โโโโ line_color (color) : color for the line connecting the equal levels (and it's label)
โโโโ line_style (string) : style (line.style_dotted) for the line connecting the equal levels
โโโโ keep_history (bool) : weater to remove older swing point labels and only keep the most recent
equal_levels_values(len, threshold, enabled)
โโdetect (and plot) equal levels (double top/bottom), returns coordinates
โโParameters:
โโโโ len (int) : lookback period for equal level (swing point) detection
โโโโ threshold (float) : maximum price offset for a level to be considered equal
โโโโ enabled (bool) : whether detection is enabled
โโReturns: (eqh_alert, eqh_x1, eqh_y1, eqh_x2, eqh_y2) whether an equal high was detected and coordinates of the first and the second level/swing point, (eql_alert, eql_x1, eql_y1, eql_x2, eql_y2) same for equal lows
equal_levels_plot(eqh_x1, eqh_y1, eqh_x2, eqh_y2, eql_x1, eql_y1, eql_x2, eql_y2, color_eqh, color_eql, show, keep_history)
โโdetect (and plot) equal levels (double top/bottom), returns coordinates
โโParameters:
โโโโ eqh_x1 (int) : coordinates of first point of equal high
โโโโ eqh_y1 (float) : coordinates of first point of equal high
โโโโ eqh_x2 (int) : coordinates of second point of equal high
โโโโ eqh_y2 (float) : coordinates of second point of equal high
โโโโ eql_x1 (int) : coordinates of first point of equal low
โโโโ eql_y1 (float) : coordinates of first point of equal low
โโโโ eql_x2 (int) : coordinates of second point of equal low
โโโโ eql_y2 (float) : coordinates of second point of equal low
โโโโ color_eqh (color) : color for the line connecting the equal highs (and it's label)
โโโโ color_eql (color) : color for the line connecting the equal lows (and it's label)
โโโโ show (bool) : whether plotting is enabled
โโโโ keep_history (bool) : weater to remove older swing point labels and only keep the most recent
โโReturns: (eqh_alert, eqh_x1, eqh_y1, eqh_x2, eqh_y2) whether an equal high was detected and coordinates of the first and the second level/swing point, (eql_alert, eql_x1, eql_y1, eql_x2, eql_y2) same for equal lows
equal_levels(len, threshold, color_eqh, color_eql, enabled, show, keep_history)
โโdetect (and plot) equal levels (double top/bottom)
โโParameters:
โโโโ len (int) : lookback period for equal level (swing point) detection
โโโโ threshold (float) : maximum price offset for a level to be considered equal
โโโโ color_eqh (color) : color for the line connecting the equal highs (and it's label)
โโโโ color_eql (color) : color for the line connecting the equal lows (and it's label)
โโโโ enabled (bool) : whether detection is enabled
โโโโ show (bool) : whether plotting is enabled
โโโโ keep_history (bool) : weater to remove older swing point labels and only keep the most recent
โโReturns: (eqh_alert) whether an equal high was detected, (eql_alert) same for equal lows
_detect_fvg(mode, enabled, o, h, l, c, filter_insignificant_fvgs, change_tf)
โโINTERNAL: detect FVG (fair value gap)
โโParameters:
โโโโ mode (int) : detect 1: bullish, -1 bearish gaps
โโโโ enabled (bool) : whether detection is enabled
โโโโ o (float) : reference source open
โโโโ h (float) : reference source high
โโโโ l (float) : reference source low
โโโโ c (float) : reference source close
โโโโ filter_insignificant_fvgs (bool) : whether to calculate and filter small/insignificant gaps
โโโโ change_tf (bool) : signal when the previous reference timeframe closed, triggers new calculation
โโReturns: whether a new FVG was detected and its top/mid/bottom levels
_clear_broken_fvg(mode, upper_boxes, lower_boxes)
โโINTERNAL: clear mitigated FVGs (fair value gaps)
โโParameters:
โโโโ mode (int) : detect 1: bullish, -1 bearish gaps
โโโโ upper_boxes (array) : array that stores the upper parts of the FVG boxes
โโโโ lower_boxes (array) : array that stores the lower parts of the FVG boxes
_plot_fvg(mode, show, top, mid, btm, border_color, extend_box)
โโINTERNAL: plot (and clear broken) FVG (fair value gap)
โโParameters:
โโโโ mode (int) : plot 1: bullish, -1 bearish gap
โโโโ show (bool) : whether plotting is enabled
โโโโ top (float) : top level of fvg
โโโโ mid (float) : center level of fvg
โโโโ btm (float) : bottom level of fvg
โโโโ border_color (color) : color for the FVG box
โโโโ extend_box (int) : how many bars into the future the FVG box should be extended after detection
fvgs_values(o, h, l, c, filter_insignificant_fvgs, change_tf, enabled)
โโdetect (and plot / clear broken) FVGs (fair value gaps), and return alerts and level values
โโParameters:
โโโโ o (float) : reference source open
โโโโ h (float) : reference source high
โโโโ l (float) : reference source low
โโโโ c (float) : reference source close
โโโโ filter_insignificant_fvgs (bool) : whether to calculate and filter small/insignificant gaps
โโโโ change_tf (bool) : signal when the previous reference timeframe closed, triggers new calculation
โโโโ enabled (bool) : whether detection is enabled
โโReturns: (bullish_fvg_alert, bull_top, bull_mid, bull_btm): whether a new bullish FVG was detected and its top/mid/bottom levels, (bearish_fvg_alert, bear_top, bear_mid, bear_btm): same for bearish FVGs
fvgs_plot(bullish_fvg_alert, bull_top, bull_mid, bull_btm, bearish_fvg_alert, bear_top, bear_mid, bear_btm, color_bull, color_bear, extend_box, show)
โโParameters:
โโโโ bullish_fvg_alert (bool)
โโโโ bull_top (float)
โโโโ bull_mid (float)
โโโโ bull_btm (float)
โโโโ bearish_fvg_alert (bool)
โโโโ bear_top (float)
โโโโ bear_mid (float)
โโโโ bear_btm (float)
โโโโ color_bull (color) : color for bullish FVG boxes
โโโโ color_bear (color) : color for bearish FVG boxes
โโโโ extend_box (int) : how many bars into the future the FVG box should be extended after detection
โโโโ show (bool) : whether plotting is enabled
โโReturns: (bullish_fvg_alert, bull_top, bull_mid, bull_btm): whether a new bullish FVG was detected and its top/mid/bottom levels, (bearish_fvg_alert, bear_top, bear_mid, bear_btm): same for bearish FVGs
fvgs(o, h, l, c, filter_insignificant_fvgs, change_tf, color_bull, color_bear, extend_box, enabled, show)
โโdetect (and plot / clear broken) FVGs (fair value gaps)
โโParameters:
โโโโ o (float) : reference source open
โโโโ h (float) : reference source high
โโโโ l (float) : reference source low
โโโโ c (float) : reference source close
โโโโ filter_insignificant_fvgs (bool) : whether to calculate and filter small/insignificant gaps
โโโโ change_tf (bool) : signal when the previous reference timeframe closed, triggers new calculation
โโโโ color_bull (color) : color for bullish FVG boxes
โโโโ color_bear (color) : color for bearish FVG boxes
โโโโ extend_box (int) : how many bars into the future the FVG box should be extended after detection
โโโโ enabled (bool) : whether detection is enabled
โโโโ show (bool) : whether plotting is enabled
โโReturns: (bullish_fvg_alert): whether a new bullish FVG was detected, (bearish_fvg_alert): same for bearish FVGs
OrderBlock
โโFields:
โโโโ id (series int)
โโโโ dir (series int)
โโโโ left_top (chart.point)
โโโโ right_bottom (chart.point)
โโโโ break_price (series float)
โโโโ early_confirmation_price (series float)
โโโโ ltf_high (array)
โโโโ ltf_low (array)
โโโโ ltf_volume (array)
โโโโ plot (Box type from robbatt/lib_plot_objects/49)
โโโโ profile (Profile type from robbatt/lib_profile/32)
โโโโ trailing (series bool)
โโโโ extending (series bool)
โโโโ awaiting_confirmation (series bool)
โโโโ touched_break_price_before_confirmation (series bool)
โโโโ soft_confirmed (series bool)
โโโโ has_fvg_out (series bool)
โโโโ hidden (series bool)
โโโโ broken (series bool)
OrderBlockConfig
โโFields:
โโโโ show (series bool)
โโโโ show_last (series int)
โโโโ show_id (series bool)
โโโโ show_profile (series bool)
โโโโ args (BoxArgs type from robbatt/lib_plot_objects/49)
โโโโ txt (series string)
โโโโ txt_args (BoxTextArgs type from robbatt/lib_plot_objects/49)
โโโโ delete_when_broken (series bool)
โโโโ broken_args (BoxArgs type from robbatt/lib_plot_objects/49)
โโโโ broken_txt (series string)
โโโโ broken_txt_args (BoxTextArgs type from robbatt/lib_plot_objects/49)
โโโโ broken_profile_args (ProfileArgs type from robbatt/lib_profile/32)
โโโโ use_profile (series bool)
โโโโ profile_args (ProfileArgs type from robbatt/lib_profile/32)
FS Scorpion TailKey Features & Components:
1. Custom Date & Chart-Based Controls
The software allows users to define whether they want signals to start on a specific date (useSpecificDate) or base calculations on the visible chartโs range (useRelativeScreenSumLeft and useRelativeScreenSumRight).
Users can input the number of stocks to buy/sell per signal and decide whether to sell only for profit.
2. Technical Indicators Used
EMA (Exponential Moving Average): Users can define the length of the EMA and specify if buy/sell signals should occur when the EMA is rising or falling.
MACD (Moving Average Convergence Divergence): MACD crossovers, slopes of the MACD line, signal line, and histogram are used for generating buy/sell signals.
ATR (Average True Range): Signals are generated based on rising or falling ATR.
Aroon Indicator: Buy and sell signals are based on the behavior of the Aroon upper and lower lines.
RSI (Relative Strength Index): Tracks whether the RSI and its moving average are rising or falling to generate signals.
Bollinger Bands: Buy/sell signals depend on the basis, upper, and lower band behavior (rising or falling).
3. Signal Detection
The software creates arrays for each indicator to store conditions for buy/sell signals.
The allTrue() function checks whether all conditions for buy/sell signals are true, ensuring that only valid signals are plotted.
Signals are differentiated between buy-only, sell-only, and both buy and sell (dual signal).
4. Visual Indicators
Vertical Lines: When buy, sell, or dual signals are detected, vertical lines are drawn at the corresponding bar with configurable colors (green for buy, red for sell, silver for dual).
Buy/Sell Labels: Visual labels are plotted directly on the chart to denote buy or sell signals, allowing for clear interpretation of the strategy.
5. Cash Flow & Metrics Display
The software maintains an internal ledger of how many stocks are bought/sold, their prices, and whether a profit is being made.
A table is displayed at the bottom right of the chart, showing:
Initial investment
Current stocks owned
Last buy price
Market stake
Net profit
The table background turns green for profit and red for loss.
6. Dynamic Decision Making
Buy Condition: If a valid buy signal is generated, the software decrements the cash balance and adds stocks to the inventory.
Sell Condition: If the sell signal is valid (and meets the profit requirement), stocks are sold, and cash is incremented.
A fallback check ensures the sell logic prevents selling more stocks than are available and adjusts stock holding appropriately (e.g., sell half).
Customization and Usage
Indicator Adjustments: The user can choose which indicators to activate (e.g., EMA, MACD, RSI) via input controls. Each indicator has specific customizable parameters such as lengths, slopes, and conditions.
Signal Flexibility: The user can adjust conditions for buying and selling based on various technical indicators, which adds flexibility in implementing trading strategies. For example, users may require the RSI to be higher than its moving average or trigger sales only when MACD crosses under the signal line.
Profit Sensitivity: The software allows the option to sell only when a profit is assured by checking if the current price is higher than the last buy price.
Summary of Usage:
Indicator Selection: Enable or disable technical indicators like EMA, MACD, RSI, Aroon, ATR, and Bollinger Bands to fit your trading strategy.
Custom Date/Chart Settings: Choose whether to calculate based on specific time ranges or visible portions of the chart.
Dynamic Signal Plotting: Once buy or sell conditions are met, the software will visually plot signals on your chart, giving clear entry and exit points.
Investment Tracking: Real-time tracking of stock quantities, investments, and profit ensures a clear view of your trading performance.
Backtesting: Use this software for backtesting your strategy by analyzing how buy and sell signals would have performed historically based on the chosen indicators.
Conclusion
The FS Scorpion Tail software is a robust and flexible trading tool, allowing traders to develop custom strategies based on multiple well-known technical indicators. Its visual aid, coupled with real-time investment tracking, makes it valuable for systematic traders looking to automate or refine their trading approach.
BTC - DCA vs HODL Calculator MatrixBTC - DCA vs. HODL Calculator Matrix | RM
Overview
The BTC - DCA vs. HODL Calculator Matrix is a high-performance telemetry laboratory designed to settle the ultimate debate in Bitcoin accumulation: Is it more efficient to deploy all capital at once ( Lump Sum & HODL ) or utilize a recurring purchase strategy ( DCA )? More importantly, if DCA is the choice, which exact frequency and weekday provides the mathematical edge?
The Calculator Matrix was engineered to solve a critical limitation in the current script ecosystem (at least I couldnt find such an indicator): the inability to compare multiple DCA frequencies and specific calendar days simultaneously within a single dashboard. While developing this tool, I found that existing calculators typically only permit testing one strategy at a time (e.g., a generic "Weekly" buy). This script fills that gap by utilizing a high-performance array-based "Telemetry Engine" to rank dozens of variablesโincluding every individual weekday and specific monthly datesโagainst a HODL benchmark in real-time. This unique simultaneous comparison allows investors to mathematically identify "Weekday Alpha" across any user-defined timeframe.
Core Philosophy
The script utilizes a Normalized Capital Model . To ensure a true "apples-to-apples" comparison, your total capital (e.g., $10,000) is distributed with mathematical precision across the exact number of entries for each specific strategy. This eliminates the ROI skewing commonly found in basic scripts, ensuring that every strategy is judged on the same total dollar expenditure over the same "Race Track."
Key Features & Analytics
โข The Podium System: An automated ranking algorithm that awards ๐ฅ Gold, ๐ฅ Silver, and ๐ฅ Bronze medals to the top three performing strategies. Spoiler: Regular Winner: 1-time HODL (Lump Sum)
โข Simultaneous Strategy Testing: Compare Daily, 7 different Weekly days (Mon-Sun), and Monthly dates (1stโ28th) all at once.
โข Risk Telemetry: Integrated Max Drawdown (MDD) sensors for every strategy, revealing the "Emotional Cost" of your accumulation path.
โข Race Track Visuals: Blue dashed "Green Flag" and "Checkered Flag" lines visually define the boundaries of your backtest.
โข Dashboard Customization: Use the "Odd/Even" filter to keep the matrix sleek and readable on (nearly) any screen resolution.
The Strategies Tested
โข 1-TIME HODL: The benchmark (Lump sum entry on Day 1 - meaning all the capital is deployed at the start date).
โข DAILY DCA: High-frequency, day-by-day accumulation (the capital is split amongst the different entries).
โข WEEKLY (SUN-SAT): Evaluates which specific day of the week historically captures the best entries (e.g., "Weekend Dips").(The capital is split amongst the different entries).
โข MONTHLY (1-28 + END): Tests monthly date performance to optimize for beginning-of-month or end-of-month cycles. (The capital is split amongst the different entries).
Monte Carlo Simulation & Python Research
While this tool allows you to manually check any specific timeframe, manual testing is limited by "Start Date Bias." To find the Universal Winner , I have conducted a Monte Carlo Simulation using 100 random entry dates over the last 5 years via Python/Colab. This research reveals the statistical probability of a day (like Saturday) winning the Gold medal across all market conditions.
Access the Python Heatmap Research in my substack article (link for substack in Bio).
How to Use
1. Set the Race Track: Input Start and End dates in the settings.
2. Fuel the Engine: Set your Total Capital ($).
3. Analyze the Matrix: Compare ROI vs. MAX DD. The goal is not just the highest return, but the best Risk-Adjusted return.
Technical Implementation
This script utilizes an array-based telemetry engine to handle the simultaneous calculation of 30+ independent investment strategies. To ensure computational efficiency and bypass the limitations of standard security-based backtesting, I implemented a custom-built accumulator logic using array.new_float() and array.set() . The core calculation loop ( if in_race and is_new_day ) processes capital deployment on a per-bar basis, utilizing ta.change(time("D")) to ensure entry synchronization with the Daily UTC close. By decoupling the unit accumulation ( u_weekly , u_monthly ) from the final valuation logic ( f_get_stats ), the script maintains a Normalized Capital Model. This ensures that even with complex comparative logic across varying frequencies, the script provides a mathematically rigorous, reproducible result that matches real-world execution at the Daily UTC Midnight close.
Note: All calculations are made on the "close" bar, which means UTC 00:00. By creating a strategy or using the research, make sure to be aware of your time zone
Disclaimer: Past performance is not indicative of future results. This tool is for educational and research purposes only. Rob Maths is not liable for any financial losses.
Tags:
robmaths, Rob Maths, DCA, HODL, Bitcoin, BTC, Backtest, RiskManagement, Investment, Strategy, Statistics
My Price Curtain by @magasineMy Price Curtain by @magasine
Functional Description
My Price Curtain is a high-performance visual analysis tool designed to provide traders with immediate context regarding price positioning relative to institutional benchmarks. Unlike standard moving averages, this indicator creates a "curtain" of data that dynamically colors the chart background and provides real-time performance metrics to identify trend dominance at a glance.
Key Features & Differential Value
Multi-Method Dynamic Benchmarking: Choose between five different calculation methods: SMA, EMA, WMA, RMA, or a manual Fixed Price. This allows you to switch from a standard technical trend (MA) to a "break-even" or "entry point" analysis (Fixed Price) instantly.
Intelligent Visual Feedback: The "Curtain" logic automatically colors the chart backgroundโGreen for Bullish dominance and Red for Bearish dominanceโreducing cognitive load during fast-paced sessions.
Advanced Statistical Tracking: The indicator includes a built-in Performance Table that tracks the percentage of bars closing above or below the selected benchmark. This helps traders quantify the strength of a trend over the entire visible dataset.
Precision Labeling & Distance Analysis: A dynamic, color-coded label tracks the price on the Y-axis. It calculates and displays the exact percentage distance from the price to the benchmark in real-time, helping to identify overextended moves.
Optional Deviation Zones: Enable visual "Safety Zones" (boxes) that project a user-defined percentage deviation from the average, assisting in identifying potential volatility expansion or exhaustion areas.
Trading Utilities
Trend Confirmation: Use the background color and "Bars Above" percentage to confirm if you are trading with the path of least resistance.
Scalping & Intraday Support: The "Distance" metric is essential for scalpers to avoid entering trades too far from the average (mean reversion risk).
Custom Strategy Benchmark: Use the "Fixed Price" mode to set your specific entry price and see your real-time performance and "curtain" status relative to your position.
Cave Diving 3 Lines System
๐คฟ Cave Diving Dashboard - A Deep Dive into Market Structure
## The Cave Diving Analogy
Imagine you're a cave diver exploring underwater caverns. As you descend deeper, you encounter different layers of the cave system:
- **The Surface (Internal Levels)** - Where you currently are, constantly shifting with each breath
- **The First Chamber (De Novo Levels)** - Your last known safe position, recently established
- **Deep Caverns (External Levels)** - Ancient, untouched chambers deeper in the system
Just as a cave diver must constantly monitor their position relative to these reference points, traders must track price action against key structural levels.
---
## ๐ฏ Understanding the Three-Tiered System
### ๐ **INTERNAL LEVELS** (Current 15m Candle)
*Your real-time position in the market*
**Internal High** ๐ก - The highest point reached in the current unfinished 15-minute candle
**Internal Low** ๐ข - The lowest point reached in the current unfinished 15-minute candle
**Think of these as:**
- Your current depth while actively diving
- They update continuously as price moves
- Status shows "Updating" when actively changing, "Intact" when stable
- These are NOT trade levelsโthey're awareness zones
**Key Insight:** When Internal Low drops below De Novo Low, you're in **Situation A** (bearish pressure building)โthe indicator highlights this with red coloring.
---
### ๐ฏ **DE NOVO LEVELS** (Previous Closed 15m Candle)
*Your most recent confirmed safe zone*
**De Novo High** ๐ต - The high of the last completed 15-minute candle
**De Novo Low** ๐ฃ - The low of the last completed 15-minute candle
**Etymology:** "De Novo" = Latin for "from new" or "anew"โthese are freshly established reference points
**Think of these as:**
- The last solid ground you stood on
- Your most recent confirmed position
- The bridge between where you are (Internal) and where you've been (External)
**Status Tracking:**
- **โฌ๏ธ Upgrade** - Level moved favorably (Higher high for resistance, Higher low for support)
- **โฌ๏ธ Downgrade** - Level moved unfavorably (Lower high, Lower low)
- **๏ผ Same** - No structural change from previous candle
**Trading Significance:**
- Primary reference points for intraday structure
- Breaking De Novo levels often signals directional commitment
- Can merge with External Level 1 when they align (shown as "DN๐ฐExt1")
---
### โฝ๐คฟ **EXTERNAL LEVELS** (Unmitigated Historical 15m Levels)
*Deep liquidity pools waiting to be discovered*
**External High 1 & 2** ๐ข๐ต - The two most recent unmitigated 15m highs
**External Low 1 & 2** ๐ ๐ธ - The two most recent unmitigated 15m lows
**Think of these as:**
- Untouched chambers in the cave system
- Liquidity pools that smart money is targeting
- Levels that "remember" and attract price
**What Makes a Level "Unmitigated"?**
- **Highs**: Price has NOT yet traded through them (broken above)
- **Lows**: Price has NOT yet swept them (broken below)
- Once touched, they're "mitigated" and removed from tracking
- The indicator automatically maintains the two most recent unmitigated levels
**Why "External"?**
They exist outside your current candle structureโhistorical reference points that institutions use for:
- Stop loss placement
- Profit taking targets
- Liquidity hunting zones
---
## ๐จ Color Coding System
### HIGHS (Resistance/Targets) - Cool Colors
- ๐ต **Ext High 2** - Light Blue (Distant target)
- ๐ข **Ext High 1** - Lime Green (Primary target)
- ๐ต **De Novo High** - Cyan (Recent resistance)
- ๐ก **Internal High** - Lemon Yellow (Current ceiling)
### LOWS (Support/Stops) - Warm Colors
- ๐ข **Internal Low** - Lime (Current floor)
- ๐ฃ **De Novo Low** - Purple (Recent support)
- ๐ **Ext Low 1** - Orange-Red (Primary stop zone)
- ๐ธ **Ext Low 2** - Pink (Distant support)
---
## ๐ Dashboard Breakdown
### The Table Shows:
1. **Level** - Which level you're tracking
2. **Price** - Exact price of the level
3. **Pts** - Distance from current price (+ above, - below)
4. **Status** - Current state or role of the level
### Special Features:
- **โฐ Countdown Timer** - Shows time remaining until next 15m candle close (next De Novo update)
- **โ ๏ธ Proximity Alerts** - Bottom row warns when within threshold distance of key levels (default: 25 points, adjustable)
---
## ๐ฏ Trading Applications
### **For Buyers (Going Long):**
- **Entry Zone**: Between De Novo Low and Ext Low 1
- **Stops**: Below Ext Low 1 (or Ext Low 2 for wider stops)
- **Targets**: De Novo High โ Ext High 1 โ Ext High 2
- **Confirmation**: Internal Low holds above De Novo Low
### **For Sellers (Going Short):**
- **Entry Zone**: Between De Novo High and Ext High 1
- **Stops**: Above Ext High 1 (or Ext High 2 for wider stops)
- **Targets**: De Novo Low โ Ext Low 1 โ Ext Low 2
- **Warning**: Watch for Situation A (Internal Low < De Novo Low)
### **Risk Management:**
- **DN๐ฐExt1** status means De Novo = External 1 (tighter range, use caution)
- Proximity alerts help you avoid chasing price into resistance/support
- "Updating" status on Internal levels = active volatility
- "Upgrade/Downgrade" signals = structural shift in progress
---
## โ๏ธ Customization Options
### Lookback Period
- Default: 500 candles (searches 125 hours of 15m data)
- Increase for more historical External levels
- Decrease for focus on recent structure
### Proximity Threshold
- Default: 25 points
- Set based on your instrument's average range
- Lower = tighter alerts (for scalping)
- Higher = strategic warnings (for swing trading)
### Visual Customization
- Line thickness (1-5)
- Line style (Solid/Dashed/Dotted)
- All colors fully customizable
- Show/hide lines independently
---
## ๐งญ The Cave Diving Mindset
**Never dive deeper than you can safely return from.**
In trading terms:
- Know your Internal position (real-time awareness)
- Respect your De Novo levels (recent structure)
- Hunt for External liquidity (where the targets are)
- Always have an exit plan (stops below Ext Lows, above Ext Highs)
The market, like a cave, has structure. This indicator illuminates that structure across three timeframes of reference, helping you navigate with precision rather than guessing in the dark.
---
## ๐ Key Takeaways
1. **Internal** = Real-time, unfinished, awareness only
2. **De Novo** = Just confirmed, primary reference, updates every 15m
3. **External** = Historical, unmitigated, high-probability targets/stops
4. **Upgrades/Downgrades** = Trend signals
5. **DN๐ฐExt1** = Structural alignment (tighter range)
6. **Situation A** = Bearish warning (Internal < De Novo Low)
---
## ๐ Credits
*"In cave diving, you plan your dive and dive your plan. In trading, you plan your levels and trade your levels."*
**Indicator:** Cave Diving Dashboard - Part 1: Price Levels
**Timeframe:** Optimized for 15-minute structure on any chart timeframe
**Philosophy:** Structure first, price second. Know where you are, where you've been, and where the liquidity waits.
---
Happy Diving! ๐คฟ๐
Monthly High/Low - [JTCAPITAL]Monthly High/Low Probability Table - is a modified way to use historical monthly high and low tracking combined with probabilistic analysis for bullish and bearish months to detect potential patterns in monthly price behavior.
The indicator works by calculating in the following steps:
Variable Declaration
Persistent variables ( var ) are used to store monthly highs, lows, open and close prices, and the days on which highs and lows occurred. Separate arrays track bullish and bearish month statistics for highs and lows ( highBull, lowBull, highBear, lowBear ). Counters ( bullCount, bearCount ) store the number of bullish and bearish months recorded.
New Month Detection
The script detects the start of a new month by comparing the current barโs month to the previous barโs month. If a new month is detected, the script proceeds to update statistics for the previous month.
Monthly High/Low Recording and Classification
At the start of each new month, the previous monthโs high, low, open, and close are evaluated:
If monthClose > monthOpen , the month is classified as bullish.
If monthClose < monthOpen , the month is classified as bearish.
The arrays ( highBull, lowBull, highBear, lowBear ) are updated at the respective high and low days of the month by incrementing counts, which allows the script to keep track of the frequency of monthly highs and lows occurring on specific days.
Monthly High/Low Tracking
During the month, the script continuously updates monthHigh and monthLow if the current barโs high exceeds monthHigh or the low is below monthLow . The days on which these highs and lows occur are recorded ( highDay and lowDay ). The monthClose variable is continuously updated to the latest closing price.
Probability Calculation
Once monthly data is accumulated, the script calculates probabilities for each day of the month:
bullHighProb and bullLowProb represent the probability (in percentage) that a bullish monthโs high or low occurred on a given day.
bearHighProb and bearLowProb represent the probability for bearish months.
These probabilities are calculated by dividing the count of high or low occurrences on each day by the total number of bullish or bearish months, then multiplying by 100. This probabilistic approach allows traders to see recurring patterns for highs and lows across multiple months.
Gradient Coloring Function
The helper function gradientRelative computes a color gradient between lowColor and highColor based on the relative probability value. Higher probabilities are colored closer to highColor , and lower probabilities closer to lowColor . This visual representation allows for quick identification of the most probable days for highs and lows in bullish or bearish months.
Dynamic Updates
As new bars are processed, the table is updated in real-time with new probabilities reflecting the most recent monthโs data. This dynamic behavior ensures that the table remains accurate and responsive to the latest market information.
Buy and Sell Conditions:
This indicator does not provide direct buy or sell signals. Instead, it provides probabilistic information about historical patterns for bullish and bearish months. Traders can use the table to:
Identify days in the month where highs or lows are statistically more likely to occur.
Combine with other trend-following or reversal strategies to optimize entry and exit points.
For example, if a trader notices that bullish month highs frequently occur around day 15, they may plan trades around that period when other indicators align.
Features and Parameters:
Dynamic Probability Table : Updates in real-time as new monthly data becomes available.
Historical Pattern Tracking : Maintains arrays for highs and lows in bullish and bearish months.
Gradient Visualization : Uses color interpolation to quickly highlight higher probability days.
Specifications:
Monthly High/Low Tracking
Tracks the highest and lowest prices within each month. This is the foundation of the probability calculations. It allows traders to understand when significant price events historically occur.
Bullish/Bearish Month Classification
Each month is classified based on the relationship between monthClose and monthOpen . This provides context for the high/low occurrences: whether they happened in bullish or bearish months.
High/Low Occurrence Arrays
Four arrays ( highBull, lowBull, highBear, lowBear ) store the count of high and low occurrences for each day of the month. These arrays are the core of the statistical analysis.
Probability Calculation
Divides the count of occurrences for each day by the total number of months in that category (bullish/bearish). Multiplying by 100 converts this to a percentage probability, giving traders a numerical sense of recurrence.
Real-Time Updates
The table and probabilities are recalculated and refreshed with each new bar. This ensures that traders have the most current information available without manual recalculation.
User-Centric Visualization
By showing probabilities for both bullish and bearish months separately, traders gain a deeper understanding of market tendencies and recurring monthly patterns, which can be leveraged for improved timing and strategy alignment.
Important:
There is a misalign in percentages due to not all months having the same amount of days.
CISD by tncylyvCISD (Change in State of Delivery) by tncylyv
The CISD (Change in State of Delivery) indicator is a precision price action tool designed to help traders identify key reversal points based on ICT concepts. Unlike standard support and resistance indicators, this script tracks the specific algorithmic opening prices responsible for the current delivery state and highlights when that state has been invalidated.
๐ง What is CISD?
Change in State of Delivery refers to the moment price shifts from a Buy Program to a Sell Program (or vice versa).
โข Bearish CISD (-CISD): Occurs when price closes below the opening price of the up-candle sequence that created the most recent High.
โข Bullish CISD (+CISD): Occurs when price closes above the opening price of the down-candle sequence that created the most recent Low.
This indicator automates the identification of these levels, tracking the "Active" reference price in real-time and marking historical reversals.
๐ Key Features
1. Continuous Active Level Tracking:
o The indicator plots a continuous, stepped line (The "Active CISD") that follows the market structure. As the market expands (makes new highs or lows), the line updates to the new valid reference point.
o This allows you to see the current invalidation level at a glance without cluttering the chart with old lines.
2. Triggered Reversal Lines:
o When a candle closes beyond the Active CISD level, a "Triggered" line is drawn to mark the exact price and location of the reversal.
o These lines serve as excellent historical references for potential Order Blocks or Breakers later in time.
3. Smart Filtering:
o You can choose to display Both Bullish and Bearish setups, or filter to see Bullish Only or Bearish Only. This is ideal for traders who have a specific daily bias and want to remove noise from the chart.
4. Clean & Customizable:
o Fully customizable colors for Bullish and Bearish events.
o Options to toggle Labels, adjust Line Width, and change Line Styles (Solid, Dashed, Dotted).
o "No Continuation" Logic: This version focuses purely on major reversals (Change in State) rather than minor pullbacks, keeping your chart clean.
โ๏ธ Settings Guide
โข Show Active CISD Level: Toggles the continuous stepped line representing the current threshold for a reversal.
โข Triggered CISD Display: Choose between Both, Bullish Only, Bearish Only, or None. This controls the historical lines left behind after a reversal occurs.
โข Visual Settings: Adjust line width, label sizes, and font styles to match your chart aesthetic.
โข Colors: Customize the Shrek Mode (Bullish) and Blood Bath (Bearish) colors.
โ ๏ธ A Note for Developers
This indicator is open source! If you are a Pine Script developer, feel free to check the source code. Iโve utilized some... creative variable naming conventions to make the coding experience more entertaining. Enjoy the read!
________________________________________
Risk Disclaimer: This tool is for educational purposes and market analysis. It does not guarantee future performance. Always manage your risk.
