Regime Detector [StrixEDGE]📊 WHAT IT DOES
StrixEDGE Regime Detector automatically classifies the market into four distinct states — Strong Trend, Weak Trend, Ranging, or Volatile Chop — using a proprietary four-metric analysis system. Subtle background colors make the current regime instantly visible without cluttering your chart.
🔬 WHY IT'S DIFFERENT
Most regime indicators rely solely on ADX. This indicator combines four independent dimensions: ADX for trend strength, RSI range-shift analysis for bull/bear regime identification, KAMA slope for adaptive trend direction, and ATR volatility ratio for market character assessment. The four-layer approach catches regime changes that single-metric tools miss entirely.
⚙️ HOW IT WORKS
The indicator evaluates four metrics simultaneously:
• ADX measures raw trend strength (>25 = trending)
• RSI tracks whether momentum is operating in bull mode (40-80) or bear mode (20-60)
• KAMA's normalized slope detects whether price is directional or flat
• ATR ratio reveals if volatility is above or below its historical average
These combine into a decision matrix: all four must agree for a "Strong Trend" classification. Partial agreement produces "Weak Trend." Low ADX + flat KAMA = "Ranging." High volatility without trend = "Volatile Chop."
📈 HOW TO USE
• Green background = Strong Uptrend → trade with trend, trail stops
• Red background = Strong Downtrend → look for shorts or stay flat
• Blue background = Ranging → use mean-reversion setups, avoid trend strategies
• Amber background = Volatile Chop → reduce size or sit out
• Diamond markers appear when regime shifts — these are key decision points
🎛️ INPUTS & DEFAULTS
ADX Period: 14 | RSI Period: 14 | KAMA Length: 21 | ATR Period: 14
ATR Lookback: 50 | Flat Threshold: 0.05 | Sensitivity: Normal
All inputs adjustable. Conservative mode raises thresholds for fewer signals. Aggressive lowers them.
═══════════════════════════════════════════════════════
🔧 CUSTOMIZATION
All parameters are fully adjustable through the indicator settings panel. Inputs are grouped logically:
• ⚙️ Core Parameters — main calculation settings
• 📊 Table Settings — table size (Tiny to Huge), position (4 corners), visibility toggle
• 🎨 Visual Settings — colors, show/hide elements
• 🔔 Alert Settings — threshold values for notifications
📊 DATA TABLE
A built-in data table displays all key metrics in real-time. Adjust the table size from Tiny to Huge to match your chart layout. Position it in any corner. Toggle visibility on/off.
🔔 ALERTS
Pre-built alert conditions for all major signals. Set up alerts via PulseWire's alert dialog — select this indicator and choose from the available conditions.
⏱️ RECOMMENDED TIMEFRAMES
Works on all timeframes. Recommended: 1H, 4H, Daily for best signal quality. Lower timeframes produce more signals but with higher noise. Weekly/Monthly for position trading context.
✅ COMPLIANCE
• No repainting — all signals based on confirmed bar close data
• No future data references
• Open-source code — verify the logic yourself
⚠️ DISCLAIMER
This indicator is a technical analysis tool, not financial advice. It does not predict future price movements. Past patterns and signals do not guarantee future results. Trading involves substantial risk of loss. Always use proper risk management, including stop losses and appropriate position sizing. Never risk more than you can afford to lose. Indicator
Heikin Ashi Cloud Overlay | Rainbow MatrixGENERAL OVERVIEW
The Heikin Ashi Cloud Overlay renders a Heikin Ashi cloud directly on top of traditional candlesticks, giving traders both views in a single chart. HA candles smooth macro trend perception by filtering individual-bar noise, but they sacrifice entry-bar precision because each HA candle does not represent the actual price range traded on that bar. This script preserves both signals simultaneously: the HA cloud surfaces directional context, while the underlying real candles preserve precise execution-bar timing.
A compact corner HUD reports current HA direction, consecutive streak length, and body-size anomalies relative to a 20-bar rolling average — useful for monitoring momentum exhaustion and impulsive expansion in real time without analyzing the cloud manually.
The script adds a visual intelligence layer on top of the standard HA pattern: cloud fill opacity dynamically reflects body intensity (impulsive bars render densely opaque, normal bars render lightly), and small colored dots flag body anomalies (current body > 3× rolling average) directly on the chart.
WHAT IS THE THEORY BEHIND THIS INDICATOR?
Heikin Ashi candles are derived from traditional OHLC via a recursive smoothing formula introduced by Munehisa Homma in 18th-century Japanese rice trading and popularized in modern Western technical analysis through the work of Dan Valcu and others. The transformation produces candles that emphasize trend persistence over discrete price action: consecutive same-color HA candles indicate ongoing directional pressure, while doji-like HA candles or sudden color flips often signal pivots.
The trade-off is well-known: HA candles do not show real OHLC. The haOpen of each candle is the average of the previous haOpen and haClose, not the actual session open. This makes HA excellent for trend reading but unreliable for entry timing — orders need to reference the actual price range of the bar, not the smoothed projection.
The conventional solutions are either to switch back and forth between HA and regular candle views (cognitive overhead), or to use HA as the primary chart and lose precision on entries (execution cost). This indicator takes a third approach: render the HA candles as a transparent overlay envelope on top of the standard candlesticks. The trader sees both at once. The HA envelope communicates trend context; the underlying candles preserve real-bar precision.
The state machine layered on top — direction tracking, streak counting, and body-size anomaly detection against a rolling average — converts the visual cloud into a numerical readout, surfacing exhaustion and impulsive moves that might be missed at a glance.
HA CLOUD OVERLAY FEATURES
The indicator includes 5 main components:
Heikin Ashi Cloud Overlay
Body Intensity Modulation (dynamic opacity)
Body Anomaly Visual Markers
HA State HUD Panel
Three Optional Alerts
HEIKIN ASHI CLOUD OVERLAY
🔹 What It Does
For each bar on the chart, the indicator computes the four Heikin Ashi values (haOpen, haClose, haHigh, haLow) using Pine Script's canonical recursive formula. It then renders a thin envelope between haHigh and haLow with semi-transparent fill, plotted on top of the underlying traditional candles.
🔹 Method
The computation follows the standard HA definition:
◇ haClose = (open + high + low + close) / 4
◇ haOpen = average of the previous haOpen and the previous haClose (recursive)
◇ haHigh = max of (high, haOpen, haClose)
◇ haLow = min of (low, haOpen, haClose)
A `var float ha_open = na` seed pattern handles the first-bar initialization safely, avoiding NA propagation that would corrupt the recursive chain.
🔹 Visual Behavior
The envelope is rendered as a thin top-bottom band with translucent fill. The fill color reflects the HA direction: bullish (haClose ≥ haOpen) renders in the configured bull color (PulseWire native teal by default); bearish (haClose < haOpen) renders in the bear color (PulseWire native red by default). An optional midline (dotted) at the (haOpen + haClose) / 2 level can be toggled for traders who prefer an explicit midpoint reference.
BODY INTENSITY MODULATION
🔹 What It Does
The cloud fill transparency is dynamically modulated based on the current HA body size relative to the 20-bar rolling average. Bars with above-average body push the fill toward more opaque, surfacing impulsive expansion clusters visually without requiring HUD analysis.
🔹 Tier Logic
◇ Body < 1× average: standard transparency (user-configured slider value)
◇ Body 1-2× average: −10 transparency (notable bar — slightly more opaque)
◇ Body 2-3× average: −30 transparency (strong bar — clearly more opaque)
◇ Body ≥ 3× average: −50 transparency, floor 20 (anomaly — densely opaque)
The floor cap of 20 prevents the fill from becoming so opaque that the underlying candle wicks become unreadable, preserving the dual-view principle of the indicator.
🔹 Why It Helps
Body intensity modulation converts the cloud from a static color band into a momentum-aware visualization. During quiet conditions, the cloud whispers; during impulsive expansion or capitulation phases, the cloud intensifies visually. Traders monitoring multiple charts can identify regime changes peripherally without focusing on any single chart's HUD.
🔹 Toggle
The feature is enabled by default and can be disabled via the "Body Intensity Cloud Opacity" input in the HA CLOUD group, which restores fixed transparency from the slider.
BODY ANOMALY VISUAL MARKERS
🔹 What It Does
A small colored dot appears on the chart whenever the current HA body exceeds 3× the 20-bar rolling average. Bull anomalies render as a dot below the bar (location.belowbar); bear anomalies render as a dot above the bar (location.abovebar). Dot colors match the configured bull/bear palette.
🔹 Why It Helps
The markers convert the alert-only body anomaly detection into a persistent visual signal that remains visible on chart history. Traders reviewing past price action can identify impulsive expansion or capitulation events at a glance, without scrolling through alert history or replaying bars.
🔹 Independent of the Alert
The visual markers and the body anomaly alert are independently toggleable. Traders can show the markers without enabling the alert (visual-only mode) or enable the alert without showing the markers (sound/notification-only mode).
🔹 Toggle
Enabled by default via the "Show Body Anomaly Markers" input in the HA CLOUD group.
HA STATE HUD PANEL
🔹 What It Shows
A compact 4-row corner panel reports three live values:
◇ Direction — current HA candle direction (Bull / Bear), color-coded
◇ Streak — consecutive same-direction count (in current locale, e.g., "7 velas (candles)" in PT)
◇ Avg Body — the average HA body size over the last 20 bars, expressed as a percentage of price
🔹 Why It Helps
The HUD converts the cloud into a numerical readout. Instead of visually estimating streak length or body proportion, traders can read the exact values on each bar. This is particularly useful for traders monitoring multiple charts or running automated rules where consecutive-bar conditions need to be tracked precisely.
🔹 Customization
The HUD can be positioned in any of the four chart corners and rendered in any of five font sizes. The Direction row uses contrasting colors (bull vs bear) for immediate parsing.
THREE OPTIONAL ALERTS
🔹 Alert Types
Each alert is independently toggleable in the indicator settings:
◇ HA Direction Change — fires on the close of a confirmed bar when the HA direction flips (bull→bear or bear→bull). Useful as a confirmation filter on top of other entry signals.
◇ HA Streak Exhaustion — fires when the absolute streak length crosses a user-configurable threshold (default 7). Long consecutive streaks often precede mean-reversion phases, especially in ranging markets.
◇ HA Body Anomaly — fires when the current HA body exceeds 3× the 20-bar rolling average. Anomalous body sizes typically signal impulsive expansion, capitulation, or news-driven moves worth investigating.
🔹 Firing Mechanism
All alerts are gated by `barstate.isconfirmed`, which means they only trigger on the close of the bar that satisfies the condition — never intra-bar. This prevents false signals from intrabar fluctuations that get rejected before close. Each alert uses `alert.freq_once_per_bar` to avoid duplicate firings on the same candle.
🔹 alertcondition() Mode
A dummy `alertcondition` titled "HOW TO SETUP ALERTS (READ)" is exposed at the bottom of the script. It provides setup guidance via its message field, instructing users to select "Any alert() function call" in the PulseWire alert condition menu and filter individual alerts via the indicator settings.
MULTILINGUAL INTERFACE
The indicator supports five languages for the HUD display and alert messages: English (default), Português, Español, Русский, and 中文 (Chinese). Code, comments, and configuration tooltips remain in English regardless of the selected language.
For reference, examples of multilingual UI strings used in the HUD:
◇ Direction labels: "Direction:" / "Direção:" / "Dirección:" / "Направление:" / "方向:"
◇ Direction text: "🟢 BULL"/"🔴 BEAR" / "🟢 ALTA"/"🔴 BAIXA" / "🟢 ALCISTA"/"🔴 BAJISTA" / "🟢 БЫЧИЙ"/"🔴 МЕДВЕЖИЙ" / "🟢 多头"/"🔴 空头"
◇ Streak units use a bilingual pattern: "candles" stays in English as a universal technical term; native terms appear in parentheses where the local equivalent is well-established (e.g., "7 velas (candles)").
CUSTOM PALETTE TOGGLE
🔹 What It Does
By default, the indicator uses native PulseWire teal/red colors for visual familiarity. A "Use Custom Cloud Colors" toggle in the settings switches to user-configurable bull/bear colors, useful for traders who want to align the cloud palette with their personal indicator stack or color preferences.
HOW TO USE
This indicator is a visualization tool, not a signal generator. It surfaces three categories of structural information: HA direction (smoothed trend context), streak length (momentum persistence), and body anomalies (impulsive moves).
🔹 Reading the Cloud
◇ Bull cloud (default teal) = current HA candle is bullish (haClose ≥ haOpen).
◇ Bear cloud (default red) = current HA candle is bearish (haClose < haOpen).
◇ A long sequence of same-color HA candles indicates strong directional pressure; mixed colors or doji-like HA candles indicate consolidation or pivot zones.
◇ Cloud density (opacity): denser fills mark bars with above-average body — pay attention to these zones, they often correspond to ignition or capitulation phases.
◇ Anomaly dots: when a dot appears below a bull bar or above a bear bar, the bar's body is 3× the recent average — exceptional impulse worth contextualizing against your other signals.
🔹 Reading the HUD
◇ Direction row: parse the current HA candle's directional state at a glance.
◇ Streak row: |streak| ≥ 7 → trend is mature, increasing probability of mean reversion or pullback. Streak just flipped sign → fresh direction.
◇ Avg Body row: current bar body > 3× this value → impulsive expansion or capitulation, worth investigating contextually.
🔹 Tactical Reading
◇ HA color flip + confirmation on the underlying candle: potential trend reversal or pullback entry.
◇ HA streak crosses the exhaustion threshold while price approaches a key level (from another indicator or manual S/R): increased probability of structural reaction.
◇ Body anomaly during otherwise quiet conditions: impulsive move (often news-driven or stop-cascade) — trade with reduced size or wait for retest.
◇ Cluster of dense-opacity bars: regime change or ongoing impulsive move — momentum is structurally elevated.
🔹 Multi-Indicator Workflow
The HA Cloud Overlay is designed to layer cleanly with other indicators. It does not add lines or boxes that compete visually with structural indicators (VWAP, Volume Profile, S/R). The cloud sits behind the candles, the markers are minimal dots, and the HUD sits in a corner — total chart footprint is minimal.
INPUTS EXPLAINED
🔹 System Language
Display language for the HUD and alert messages. Options: English (default), Português, Español, Русский, 中文.
🔹 Show Cloud Envelope
Master toggle for the HA top-bottom envelope and fill.
🔹 Cloud Fill Transparency
Base alpha of the cloud fill (60 = denser, 95 = barely visible). Floor of 60 keeps candle wicks readable. Default 80. When Body Intensity Modulation is ON, this value is the baseline; bars with above-average body intensity become progressively more opaque from this baseline.
🔹 Show HA Midline (dots)
Optional thin dotted line at (haOpen + haClose) / 2.
🔹 Use Custom Cloud Colors
OFF: native PulseWire teal/red. ON: apply custom bull/bear colors below.
🔹 Custom Bull Color / Custom Bear Color
Used when "Use Custom Cloud Colors" is ON.
🔹 Body Intensity Cloud Opacity
When ON: cloud fill becomes progressively more opaque on bars with above-average body size. When OFF: cloud uses fixed transparency from the slider above. Recommended ON.
🔹 Show Body Anomaly Markers
When ON: small colored dots appear on bars whose body exceeds 3× the 20-period average. Independent of the body anomaly alert.
🔹 Show HA State HUD
Toggle for the corner HUD reporting Direction / Streak / Avg Body.
🔹 HUD Position
Top Right (default), Top Left, Bottom Right, Bottom Left.
🔹 Font Size
Tiny, Small (default), Normal, Large, Huge.
🔹 Streak Warning Threshold
Streak length at which the Streak Exhaustion alert fires. Range 3–30, default 7.
🔹 Alert: HA Direction Change / HA Streak Extreme / HA Body Anomaly
Independent toggles for each of the three alert types.
IMPORTANT NOTES
The Heikin Ashi Cloud Overlay works on any timeframe and any instrument. The HA computation is timeframe-agnostic — it transforms whatever OHLC data the chart provides.
Alerts fire once per confirmed bar. Historical bars never repaint after they close. The live bar updates intra-bar as expected for a real-time indicator, but alerts will only fire after the bar closes. Body anomaly visual markers can update intra-bar (preview behavior) and settle on close.
The body anomaly threshold (3× rolling average) and streak warning threshold (default 7) are derived from empirical observation across common timeframes and instruments. Both are user-configurable and should be tuned to the trader's instrument and timeframe — high-volatility crypto on 1m may warrant a higher anomaly multiplier than large-cap equities on Daily.
The 20-bar body rolling average uses `ta.sma` of the percentage-based body size. The first 20 bars after script start will show partial values; once enough history is available, the value stabilizes.
The body intensity modulation tier floors (50, 30, 20) are calibrated to preserve candle wick readability even on extreme anomaly bars — the floor 20 ensures the cloud never becomes fully opaque.
Pine Script v6. Open-source under Mozilla Public License 2.0.
UNIQUENESS
The Heikin Ashi Cloud Overlay differs from the standard PulseWire Heikin Ashi chart type and from other HA-based indicators in four structural ways.
First, it preserves both views simultaneously rather than replacing one with the other. Standard HA chart mode hides the real candles entirely; this overlay keeps the underlying candles visible at all times, giving traders smoothed trend context (the cloud) and precise entry-bar timing (the underlying candles) in the same visual without context-switching cost.
Second, the cloud fill opacity is dynamically modulated by body intensity relative to a 20-bar rolling average. Standard HA cloud indicators render fills with a single static transparency; this script renders impulsive bars (≥1×, ≥2×, ≥3× average body) with progressively more opaque fills, transforming the cloud from a static visualization into a momentum-aware density map. Capitulation, ignition, and impulsive expansion phases become visually identifiable peripheral signals.
Third, it adds an explicit state machine layer over the raw HA visualization. Direction tracking, consecutive streak counting, 20-bar rolling body-size anomaly detection, and on-chart visual anomaly markers convert the visual cloud into a numerical readout reported live on a corner HUD. This converts subjective visual estimation (is this a long streak? is this body unusually large?) into deterministic measurements with configurable thresholds and a persistent visual record on the chart history.
Fourth, it exposes three independently-toggleable alerts (direction change, streak exhaustion, body anomaly) gated by bar confirmation, making the indicator usable as a confirmation filter or trigger source in automated workflows. Most HA-based indicators are visualization-only or expose a single direction-flip alert; the multi-condition alert set here is designed for traders building structured rules around HA state rather than just observing it.
The combination of dual-view preservation, body-intensity opacity modulation, state machine readout, visual anomaly markers, and multilingual UI produces a single overlay that combines the readability of Heikin Ashi smoothing with the precision of real candles, the rigor of a deterministic state readout, and the visual intuition of a density-aware momentum map. Indicator
Indicator
Asterion Regime Lattice [JOAT]Asterion Regime Lattice
Introduction
Asterion Regime Lattice is an open-source market regime oscillator designed to classify whether conditions are directional, transitional, or balanced by combining multiple independent measurements into one continuous score. Instead of relying on a single trend indicator, it evaluates trend displacement, momentum, volatility behavior, directional movement, efficiency, choppiness, entropy, and higher-timeframe confirmation.
The problem this script solves is regime ambiguity. Many entries fail because traders apply trend logic in rotational conditions or mean-reversion logic in expanding directional phases. Asterion Regime Lattice provides a higher-level state model first, so any downstream tool can be interpreted in the proper context. The pane output uses layered lattice bands, a smoothed score curve, regime shading, and a compact dashboard to make the current state readable at a glance without covering price.
Core Concepts
1. Composite Regime Scoring
The script builds a regime score from several independent components rather than one oscillator. It measures fast/slow trend displacement, momentum direction, volatility expansion, directional movement, efficiency ratio, choppiness, Shannon entropy, fractal dimension, RSI state, and ADX-derived trend strength. Each component is normalized, weighted, and added into a single signed score where positive values indicate bullish expansion and negative values indicate bearish expansion.
2. Higher-Timeframe Confirmation
Two higher timeframes are requested with `request.security()` using `lookahead = barmerge.lookahead_off`. This keeps the script non-repainting while allowing the current timeframe to compare itself against broader directional conditions. The higher-timeframe pack contributes trend bias, momentum bias, volatility bias, directional movement bias, slope, ROC, and ADX strength.
=
request.security(syminfo.tickerid, htfOne, f_htfPack(), lookahead = barmerge.lookahead_off)
3. Structure Quality and Noise Separation
The script uses efficiency, choppiness, entropy, and fractal-dimension style measurements to separate clean directional movement from noisy rotation. That matters because two markets can have similar momentum but very different trade quality. Asterion does not only ask "is price moving?" It also asks whether the move is organized enough to treat as a real regime.
4. Lattice Bands and Regime Zones
The oscillator uses inner and outer bands around the smoothed score curve to display soft and strong regime zones. When the score pushes beyond soft thresholds the state becomes directional. When it pushes through stronger thresholds with quality and higher-timeframe agreement, the state becomes more decisive. This layered presentation makes the transition from balance to expansion visible before and during the full move.
5. Confirmed State Transitions
Alerts and state changes are only confirmed on closed bars. This keeps the script suitable for live use and avoids intrabar state flips being treated as final.
Features
Composite regime score: Blends trend, momentum, volatility, efficiency, entropy, fractal behavior, RSI, and DMI/ADX context
Dual higher-timeframe confirmation: Uses two configurable timeframes with `lookahead_off`
Trend quality layer: Separates clean directional movement from noisy or choppy conditions
Inner and outer lattice bands: Visualize soft and strong directional zones
Pane regime shading: Background tint shifts with the current market state
Optional bar tinting: Can color price bars by current regime while keeping the oscillator in a separate pane
Dashboard summary: Reports regime, quality, HTF alignment, volatility, momentum, efficiency, entropy, and directional state
Confirmed-bar alerts: Bull, bear, soft bull, soft bear, and transition events trigger only after bar confirmation
Input Parameters
Core:
Fast Length and Slow Length: Trend displacement backbone
Momentum Length and Trend Slope Length: Speed and directional persistence measurements
Structure Length, Volume Length, Volatility Length: Core normalization windows
Efficiency Length, Choppiness Length, Entropy Length, Entropy Bins, Fractal Length: Noise and organization diagnostics
RSI Length and ADX Length: Directional strength and internal pressure inputs
Higher-Timeframe Confirmation:
Primary HTF and Secondary HTF
Strong ADX and Weak ADX thresholds
Visuals:
Pane shading toggle
Lattice band toggle
Score curve toggle
Bar tint toggle
Curve smoothing and band multipliers
How to Use This Indicator
Step 1: Read the Regime Row
Start with the Regime row in the dashboard and the position of the score relative to the soft and hard thresholds. This tells you whether the market is directional, balanced, or in transition.
Step 2: Check Quality Before Acting
A high-magnitude regime score with weak quality is less reliable than a slightly smaller score with strong quality. Use the Quality row to decide whether the move is organized enough to trust.
Step 3: Compare With Higher Timeframes
The HTF row helps determine whether the current timeframe is aligned with the broader backdrop or fighting it. Stronger follow-through usually appears when local and higher-timeframe states agree.
Step 4: Use It as a Context Filter
Asterion is best used as a regime filter. Trend systems generally perform better when the oscillator is directional and quality is strong. Mean-reversion logic is generally more appropriate when the score is near balance and noise metrics dominate.
Indicator Limitations
The script is a classifier, not a predictive model. It describes current conditions; it does not forecast future direction
Higher-timeframe confirmation can lag turning points because those bars must close before their state is final
In low-range grinding markets, the oscillator can remain transitional for extended periods
Any weighted composite reflects design choices; different markets may require threshold adjustments
Originality Statement
Asterion Regime Lattice is original in the way it combines directional scoring, higher-timeframe agreement, and multiple noise-quality measurements into one structured regime model. It is not a simple trend oscillator with a new color scheme. The script is built around the idea that regime is a blend of direction, organization, and alignment across timeframes, and its lattice presentation is designed to make those layers visible rather than hiding them behind a single line.
Disclaimer
This script is provided for educational and informational purposes only. It is not financial advice and does not guarantee any outcome. Regime measurements are based on historical price and volume behavior and can produce false or delayed readings, especially during sudden event-driven changes in market conditions. Always use independent judgment and risk management.
Indicator
Fixed Range Control Box [AGPro Series]Fixed Range Control Box
🔹 Overview
Fixed Range Control Box isolates a single high-conviction price range on your chart and classifies who is in control inside it. The tool draws one clean hero box around the most recent structural range, places a volume-weighted Control Line inside it, and tracks state transitions in real time: Inside, Upper, Lower, or Failed. When price structurally breaks the box, the range freezes, locking the reference so you can study the aftermath without visual drift.
Four range-definition modes are available — Pivot, Lookback, Compression, and Manual-Date — so the tool adapts to discretionary range traders, systematic rotation traders, and anyone who wants a fixed reference zone for backtesting or journaling.
🔸 Unique Edge
Most range tools on PulseWire draw many boxes and leave the user to guess which one matters. Fixed Range Control Box is built around a different philosophy: one range, one story, one decision. The hero box is the visual focus; historical ranges fade into the background; the Control Line tells you which side of the range is winning the statistical argument.
Three design choices separate this from standard range-box scripts:
- Volume-weighted Control Line. Rather than dropping a midpoint line, the Control Line is computed from the volume-weighted typical price across the life of the range, with an edge-fallback to midpoint if the line drifts too close to either boundary. This produces a structurally meaningful reference instead of a geometric one.
- Retrospective fill on range rebuild. When a new range is committed, the script walks back through the range window and retroactively computes touch count, hold quality, and the Control Line. You see a fully-formed box with accurate statistics the moment it appears, not an empty box that slowly populates.
- Freeze-on-failure. When price closes beyond the range and the state transitions to Failed, the box locks at the break bar. No more drifting endpoints on broken structures — the reference stays where the story ended.
🔷 Methodology
The script cycles through four stages on every bar:
1. Range detection. Depending on the selected mode, the script looks for a qualifying range: confirmed swing pivots (Pivot), rolling highest/lowest (Lookback), short-ATR over long-ATR compression (Compression), or a user-defined date window (Manual). Gating rules — minimum lifespan, minimum width percentage, and a failed-state cooldown — prevent rapid re-triggers on noisy conditions.
2. Commit and retrospective fill. Once a range qualifies, the script snapshots the old range into history, installs the new one, and walks back through the window to compute the Control Line, touch count, and hold quality in a single pass. No warm-up period.
3. State machine. Each confirmed bar feeds the state machine. Strict logic requires bar closes on one side of the Control Line for the configured number of bars before switching to Upper or Lower; a close beyond either range boundary transitions to Failed.
4. Rendering. On the last bar, the hero box, Control Line, origin marker, and state badge are rebuilt from scratch. Historical ranges persist as muted boxes up to a configurable cap.
🔶 Signals & Alerts
Three alert conditions cover the full range lifecycle:
- New Control Box. Fires once per bar close when a new range is committed.
- Line Reclaimed (Bull or Bear). Fires when state transitions into Upper or Lower control, confirming directional bias inside the range.
- Control Failed. Fires once when price closes beyond the range and the box is frozen.
All alerts use alert() calls with once-per-bar-close frequency.
🔹 Key Inputs
- Range Mode — Auto-Pivot, Auto-Lookback, Auto-Compression, or Manual-Date.
- Pivot Length / Lookback Bars / Compression Window — window controls for each detection mode.
- Min Range Lifespan / Min Range Width % — structural filters to suppress micro-ranges.
- Failed Cooldown — bars to wait after a broken range before searching for a new one.
- Strict Control Logic + Reclaim Confirmation — governs how the Control Line state machine transitions.
- Visual controls — fade old boxes, max boxes kept, show state badge, show range origin, future projection bars, panel and label font sizes.
🔸 How to Use
1. Start on your primary timeframe and select the Range Mode that matches your style: Pivot for discretionary swing structures, Lookback for mechanical windows, Compression for auto-locking onto consolidations, Manual-Date for backtesting a specific episode.
2. Tune Min Range Width % and Min Range Lifespan so only structurally meaningful ranges appear.
3. Read the panel top-down: Mode confirms what you are tracking, Control tells you which side of the Control Line is winning, Range Age and Touches describe maturity and confluence, Hold Quality summarizes how cleanly price has respected the range, and State shows the live classification.
4. Use alerts to monitor the range lifecycle without staring at the chart.
🔻 Limitations & Transparency
- This is an analytical tool, not a strategy. It does not generate buy or sell recommendations and does not compute entries, stops, or targets.
- Past range behavior does not forecast future range behavior. Structural breaks can occur at any time.
- In very thin or illiquid markets, the volume-weighted Control Line can drift toward a boundary; the edge-fallback defaults to midpoint to protect against degenerate cases.
- Auto-Compression mode requires sufficient ATR history; expect a warm-up period on very recent symbols.
- The script is overlay-only and does not access other timeframes.
🔶 Risk Disclosure
Nothing in this script constitutes financial advice. Trading involves substantial risk of loss and is not suitable for every investor. Always do your own research and manage risk appropriately. Indicator
Realtime Non-Repaint PathName:
Realtime Non-Repaint Path
Searchable Name:
Realtime Non-Repaint Path
Technical name:
Realtime Non-Repaint Percentage-Reversal Path
Short title:
RT NR Path
Summary
Realtime Non-Repaint Path is a standalone path-visualization and path-state script designed to show live non-repainting directional path structure and a simplified hidden path reveal. It uses a percentage-reversal path model to classify live path direction, maintain a live anchor/candidate structure, draw a live eased path, rebuild a simplified hidden path from reversal pivots, and display state labels, alerts, and a compact status table. Its strongest advantages are live path clarity, non-repainting state transitions on closed bars, simpler path interpretation, and visual structure that can complement entry-focused scripts. Its main known weakness is that it is not a full trading engine: it does not perform full pivot confirmation, trade management, advanced filtering, replay-state reconstruction, or broader regime/stat handling.
This script is best understood as a path-focused operational visualization and state-classification script rather than a complete trading engine. It is designed to be useful on its own while remaining simple enough to inspect, test, and modify.
How it works
The script begins with a simple percentage-reversal path model. It tracks a live anchor price, a live candidate extreme, and a current live path direction. When price moves far enough away from the current anchor by the user-defined reversal percentage, a live directional path is established. As long as price continues making new extremes in that direction, the live candidate continues updating. When price reverses enough from that candidate extreme by the same percentage threshold, the live path flips and a new anchor/candidate cycle begins.
The displayed live path is not drawn as a raw straight jump between points. Instead, it is eased between the current live anchor and live candidate so that the path remains visually readable while still staying tied to the current live state model. Because the live state is updated bar by bar using only information available so far, the live path is intended to function as a non-repainting path-state view on closed bars rather than as a hindsight-only reconstruction.
In addition to the live path, the script can also reveal a simplified hidden path. That hidden path is rebuilt from percentage-reversal pivots over a user-defined recent history window. It detects reversal pivots using the same percentage-reversal logic and then draws an eased pivot-to-pivot hidden path across the selected history range. This keeps the script path-focused, visually useful, and easier to interpret.
The script also displays optional confirmed turn labels, a last-bar live state label, path-up/path-down alerts, background coloring based on current path direction, and a compact status table showing the current live state, anchor, candidate, and percentage distances. These features make it useful as a visual path-state companion script rather than as a full signal-and-execution engine.
Path model note
This script’s path model is based on percentage reversal. That makes it intentionally simpler and easier to understand, but it also means it does not attempt to replicate the broader complexity of a full trading engine. The hidden path shown here should be interpreted as a simplified path reveal, not as a complete trade-selection or execution model.
Features
Live non-repainting path state machine
User-defined percentage reversal threshold
Live anchor and candidate path structure
Eased live path display
Simplified hidden path reveal over recent history
Confirmed path turn labels
Last-bar live state label
Background coloring by live path direction
Path-up and path-down alerts
Compact status table with anchor/candidate/path-distance information
Strengths
Path Clarity edge — provides a cleaner live view of path direction than raw candles alone.
Non-Repainting State edge — live path direction and flips are based on the current bar-by-bar percentage-reversal model rather than hindsight-only reconstruction.
Simplicity edge — simpler structure makes it easier to inspect, test, and modify.
Companion Script edge — pairs naturally with entry-oriented scripts by showing whether path direction is currently up, down, or neutral.
Visual Structure edge — live path, hidden path, labels, background, and status table make path structure easier to read quickly.
Interpretability edge — the script is straightforward enough to be useful as both a live visual aid and a path-study tool.
Weaknesses
Not a full trading engine weakness — does not include full trade management, entry/exit handling, or execution logic.
No advanced filtering weakness — does not include broader filtering or replay/stat reconstruction layers.
Threshold sensitivity weakness — path behavior depends heavily on the user-selected reversal percentage, so different settings can materially change the path and turn structure.
Path-state, not profit-state weakness — path direction does not guarantee profitable entries or strong follow-through.
Simplified hidden path weakness — the hidden path is intentionally simplified and should not be mistaken for a complete internal market model.
No regime/stat engine weakness — does not contain broader regime scoring, detailed replay diagnostics, or a larger state/stat engine.
Who it’s for
This script is best suited for traders and PulseWire users who want a simpler live path script, users interested in non-repainting path direction on closed bars, users who want a visual companion to entry-focused scripts, users who want to inspect market path structure with less complexity than a full trading engine, and users interested in learning from or modifying a smaller path-focused script. It is especially suited for users who want a practical path/state layer rather than a complete trading engine.
Who it’s not for
This script is not best suited for:
users looking for a complete pre-built trading engine
users expecting advanced pre-entry classification
users expecting full entry/exit/trade management
users looking for advanced regime, replay, and state/stat reconstruction
users expecting this script by itself to solve the false-pivot or follow-through problem
users looking for a complete trade-selection and execution workflow rather than a smaller standalone path script
Known limitations
Realtime Non-Repaint Path is much better at showing live path direction and simplified path structure than it is at acting as a complete trading system. The live path is driven by a percentage-reversal state machine and the hidden path is rebuilt from simplified percentage-reversal pivots with eased pivot-to-pivot connections. Because of that, it should be viewed primarily as a path/state visualization and classification script, not as a complete trade-selection or execution engine. Different reversal-percentage settings can also materially change how often the path flips and how sensitive the script is to movement.
Final note
This is a standalone path script, not a guaranteed predictive system and not a full operational trading engine. Its strengths are concentrated in live path visibility, simplified hidden path structure, non-repainting state handling on closed bars, and quick visual interpretation. It is best used as a path-focused companion or as a simpler standalone script for studying live path behavior rather than as a substitute for a more complete engine. Indicator
AG Pro Williams %R Exhaustion Map [AGPro Series]AG Pro Williams %R Exhaustion Map
Overview / What it does
AG Pro Williams %R Exhaustion Map is a bounded-oscillator reaction map built to study exhaustion behavior around the extreme ends of Williams %R. Instead of treating Williams %R as a simple overbought/oversold trigger, this script maps whether an extreme reading is only being touched briefly, held with persistence, beginning to release, failing to release, or unwinding with more structure. The goal is to organize extreme-zone behavior into readable states rather than reduce the tool to a basic reversal shortcut.
The script is designed for traders who want to understand when an extreme condition is still being sustained and when that same condition may be starting to lose efficiency. In practice, that means the script focuses less on isolated crossings and more on the sequence around them: entry into an extreme zone, time spent there, the first release attempt, the possibility of a failed release, and the confirmation of an exhaustion unwind. This sequence-based framing is what gives the tool its map identity.
Within the AG Pro series, this script is intentionally separate from tools that revolve around trend confirmation, centerline balance, divergence, or generic momentum shifts. It is also intentionally separate from the series' Stochastic-based exhaustion work. Stochastic can be useful for reading swing rhythm and rotational turns, while this Williams %R version is centered more tightly on bounded extreme persistence and release behavior. In other words, this script is not presented as an alternative skin for another oscillator. It is a different framework for reading how price behaves when an oscillator remains pinned near an edge and then attempts to escape that condition.
Unique Edge
The unique edge of this script is not that it plots Williams %R, but that it classifies the life cycle of an extreme reading. The script distinguishes between stretch, locked conditions, release attempts, failed releases, and exhaustion unwinds. That structure helps separate three situations that are often mixed together in standard oscillator use:
1) an extreme reading that is still being sustained,
2) an extreme reading that has started to weaken but may still fail, and
3) an extreme reading that is releasing with enough follow-through to qualify as an exhaustion unwind.
This matters because many standard oscillator workflows treat every exit from an extreme zone as if it carried the same informational value. This script does not. It places more emphasis on persistence, release quality, and post-release follow-through, which can help users avoid treating every early reversal attempt as equivalent.
Methodology
The script begins with Williams %R and user-defined extreme thresholds. From there, it evaluates how long the oscillator remains in the upper or lower extreme zone and how deeply it is embedded in that zone. This forms the basis of the lock-strength logic. A fast touch into an extreme area and an extended embedded condition are therefore not interpreted in the same way.
Once an extreme condition has persisted long enough, the script begins monitoring for a release. A release is not defined as any random movement away from the boundary. It requires the prior extreme condition to have had sufficient persistence and then looks for a buffered move away from the threshold. This helps reduce noise from trivial fluctuations around the extreme lines.
After a release is detected, the script continues to track what happens next. If the oscillator quickly slips back into the same extreme region, the move can be classified as a failed release. If the move continues far enough away from the release anchor within the confirmation window, it can be classified as an exhaustion unwind. This post-release tracking is a central part of the script's design because it helps distinguish between temporary relief and more meaningful exhaustion release.
The panel summarizes this process using state, side, lock strength, and release quality. Lock strength is intended to reflect how established the prior extreme condition was. Release quality is intended to reflect the quality of the release sequence, not forecast what price must do next. These metrics are descriptive and contextual. They are not guarantees.
Signals & Alerts
This script provides event-style labels and alert conditions for the main transitions in the exhaustion sequence. The alerts are deterministic and tied to explicit script conditions rather than discretionary interpretation.
Main event types:
- Bullish release detected
- Bearish release detected
- Bullish release failed
- Bearish release failed
- Bull exhaustion unwind confirmed
- Bear exhaustion unwind confirmed
How to interpret them:
- A release event marks the first qualified move away from a persistent extreme condition.
- A failed release marks a release attempt that reverted back into the prior extreme condition too quickly.
- An exhaustion unwind confirmation marks a release that traveled far enough from its anchor within the configured window to qualify as a more established unwind sequence.
These events are intended to help structure chart reading. They are not standalone trade instructions, and they are not framed as guaranteed reversal signals.
Key Inputs
Williams %R Length
Controls the oscillator lookback period.
Upper Extreme / Lower Extreme
Define the zones used to classify upper and lower exhaustion behavior.
Lock Bars
Controls how much persistence is required before an extreme condition is treated as locked rather than only stretched.
Release Buffer
Adds distance beyond the raw threshold so the script does not treat every minor edge fluctuation as a release.
Confirm Distance / Confirm Window
Control how far and how quickly a release must extend to qualify as an exhaustion unwind.
Fail Window
Controls how quickly a release can revert back into the extreme zone and still be classified as a failed release.
Event Memory Bars
Controls how long the release state is remembered on the chart.
Visual Settings
Allow users to control event labels, minimum spacing between labels, background tint, and optional price-bar coloring.
Panel Settings
Allow users to control panel visibility, placement, font size, and theme.
How this differs from related AG Pro scripts
This script should not be confused with the series' other momentum or exhaustion tools.
Compared with Stochastic-based exhaustion work in the AG Pro series, this script is less about oscillator rhythm and more about the persistence and release structure of a bounded extreme condition. The emphasis here is on whether Williams %R remains pinned, whether the first escape attempt fails, and whether the unwind becomes established.
Compared with RSI-, CCI-, or MFI-oriented workflows, this script is not a centerline trend model, not a divergence engine, and not a money-flow proxy. Its purpose is narrower and more specific: to map the state transition of extreme Williams %R conditions.
Compared with broader trend or regime tools in the AG Pro series, this script is not trying to classify the full market environment by itself. It is better understood as a focused reaction map that can be used alongside a user's own structure, trend, or risk framework.
Limitations & Transparency
This is an indicator, not a strategy. It does not place orders, it does not calculate performance statistics, and it does not claim to predict future price direction. It visualizes oscillator-state transitions derived from Williams %R and user-defined thresholds.
Like all bounded oscillators, Williams %R can remain in extreme territory for extended periods during strong directional conditions. For that reason, an extreme reading should not automatically be interpreted as a reversal condition. This script attempts to improve that interpretation by separating stretch, lock, release, failed release, and unwind behavior, but it does not eliminate false positives.
Results can vary meaningfully with symbol, timeframe, volatility regime, and input configuration. Traders should expect the script to behave differently on very quiet markets, strongly trending markets, and highly reactive instruments. Label frequency and state persistence can also change materially when thresholds and confirmation settings are adjusted.
This tool is intended to support chart organization and decision framing. It should be used with the user's own market structure analysis, execution model, and risk management process.
Risk Disclosure
This script is provided for educational and analytical purposes only. It is not financial advice, not a solicitation, and not a promise of results. Trading and investing involve risk, including the risk of loss. No indicator can remove uncertainty from markets, and no exhaustion signal guarantees reversal, continuation, or trade success.
Users should validate any workflow with their own testing, judgment, and risk controls before using it in live decision-making.
Indicator
Auto Play Ping/Pong [UAlgo]Auto Play Ping/Pong is a fully self running arcade style mini game built entirely in Pine Script and rendered directly on the chart. Instead of analyzing price, this script turns the chart area into a compact game field where two AI controlled paddles rally a moving ball from one side to the other while the score updates in real time.
The script is designed as a visual and technical showcase of what Pine Script can do with custom objects such as boxes, lines, labels, arrays, and user defined types. It demonstrates persistent state handling, frame by frame physics updates, collision detection, automatic paddle control, scoring logic, and motion trail rendering, all inside a chart overlay.
The left and right paddles are both controlled by simple AI logic. Each paddle reacts to the vertical position of the ball and tries to align itself for the next return. The ball bounces off the top and bottom boundaries, changes direction when it touches a paddle, and resets to the center when one side misses. A trail effect is also added to make movement easier to follow and visually more dynamic.
What makes this script interesting is that it is not simply drawing static shapes. It maintains a persistent game state across updates, modifies that state on every bar, and redraws the field using live object coordinates. This makes it a playful but technically instructive example of animation and object control in Pine Script.
In practical terms, this script is a creative visual project rather than a trading tool. It is useful for demonstrating real time state management, chart object animation, and game style logic inside PulseWire.
🔹 Features
🔸 Fully Automated Gameplay
Both paddles are controlled automatically. The script continuously tracks the ball position and moves each paddle vertically to intercept the ball without user input.
🔸 Persistent Game State
The script uses a dedicated game state object to store ball position, paddle positions, scores, trail points, and drawing references. This allows the whole game to evolve smoothly over time.
🔸 Ball Physics and Collision Logic
The ball moves with its own horizontal and vertical velocity, bounces off the top and bottom walls, reacts to paddle contact, and changes its vertical angle depending on where it hits the paddle.
🔸 Score Tracking
If one paddle misses the ball, the opposing side scores a point. The ball then resets to the center and starts a fresh rally with directional variation.
🔸 Paddle AI With Speed Limits
Each paddle follows the ball using its own maximum movement speed. This gives the game a natural chase behavior and prevents instant teleport style motion.
🔸 Motion Trail Effect
The ball leaves a fading trail behind it using a sequence of stored points and prebuilt lines. This improves visual clarity and gives the movement a smoother arcade feel.
🔸 Custom Game Field Rendering
The play area is drawn with a background box, two paddle lines, a circular ball label, a score label, and trail segments. Everything is positioned relative to the current bar index.
🔸 Chart Overlay Animation
The game is drawn directly over the chart with overlay=true , which turns the chart into a moving visual canvas.
🔹 Calculations
1) Defining the Game Geometry and Core Constants
var int GAME_WIDTH = 80
var float GAME_HEIGHT = 100.0
var float PADDLE_H = 20.0
var float BALL_SPD_X = 1.8
var float BALL_SPD_Y = 1.2
var int TRAIL_LEN = 10
var float AI_SPEED_1 = 1.1
var float AI_SPEED_2 = 1.2
This block defines the full physical layout and motion parameters of the game.
GAME_WIDTH sets the horizontal size of the play area.
GAME_HEIGHT sets the vertical size.
PADDLE_H defines paddle height.
BALL_SPD_X and BALL_SPD_Y define the initial ball speed.
TRAIL_LEN defines how many trail segments are stored.
AI_SPEED_1 and AI_SPEED_2 define how quickly each paddle can move.
So before any gameplay starts, the script already establishes the dimensions and motion rules of the whole arena.
2) Defining the Point and Game State Objects
type Point
float x
float y
type GameState
float ball_x
float ball_y
float ball_vx
float ball_vy
float p1_y
float p2_y
int p1_score
int p2_score
box bg_box
line p1_line
line p2_line
label ball_lbl
label score_lbl
array trail_pts
array trail_lines
This is the structural foundation of the script.
The Point type stores one coordinate pair. It is used for the trail system.
The GameState type stores the full live state of the game:
the ball position,
the ball velocity,
the vertical positions of both paddles,
both scores,
the main drawing objects,
and the trail arrays.
This design is important because the script is not just drawing shapes independently. It is managing a complete game world through one persistent object.
3) Creating the Visual Objects on the First Bar
method init_drawings(GameState state) =>
state.bg_box := box.new(na, na, na, na, border_color=color.new(color.gray, 60), border_width=1, bgcolor=C_BG)
state.p1_line := line.new(na, na, na, na, color=C_P1, width=4)
state.p2_line := line.new(na, na, na, na, color=C_P2, width=4)
state.ball_lbl := label.new(na, na, "", color=C_BALL, style=label.style_circle, size=size.small)
state.score_lbl := label.new(na, na, "0 - 0", color=color.new(color.white, 100), textcolor=color.silver, style=label.style_none, size=size.large)
This method creates the core objects that will later be updated every frame.
The script builds:
a background box for the game field,
a line for the left paddle,
a line for the right paddle,
a circular label for the ball,
and a score label.
These are created only once, then reused and repositioned as the game evolves. This is much more efficient than deleting and recreating everything on every update.
4) Preparing the Ball Trail System
for i = 0 to TRAIL_LEN - 1
color fade_color = color.new(C_BALL, 100 - int((TRAIL_LEN - i) * 100 / TRAIL_LEN))
state.trail_lines.push(line.new(na, na, na, na, color=fade_color, width=2))
state.trail_pts.push(Point.new(state.ball_x, state.ball_y))
This loop initializes the trail effect.
For each trail slot, the script creates:
a line object with progressively changing transparency,
and a point initialized at the current ball position.
The idea is simple. The newest trail segments remain more visible, while older trail segments fade away. This creates the illusion of motion persistence behind the ball.
So the trail is not a single effect. It is a chain of stored points and lines that move along with the ball.
5) Updating Ball Position Each Frame
method update_physics(GameState state) =>
state.ball_x += state.ball_vx
state.ball_y += state.ball_vy
This is the first step of the physics engine.
On every update, the ball position is advanced by its horizontal and vertical velocity values. This is the basic motion rule of the game.
If nothing else happened, the ball would keep moving in a straight line forever. The rest of the physics method exists to modify that path through AI movement, wall bounces, paddle collisions, and scoring resets.
6) Left Paddle AI Logic
if state.ball_vx < 0
if state.p1_y + PADDLE_H/2 < state.ball_y
state.p1_y += math.min(AI_SPEED_1, state.ball_y - (state.p1_y + PADDLE_H/2))
else if state.p1_y - PADDLE_H/2 > state.ball_y
state.p1_y -= math.min(AI_SPEED_1, (state.p1_y - PADDLE_H/2) - state.ball_y)
This block controls the left paddle.
The paddle only reacts when the ball is moving toward the left side, which is why the script first checks:
state.ball_vx < 0
Then it compares the ball’s vertical position to the top and bottom edges of the paddle. If the ball is above the paddle center zone, the paddle moves upward. If the ball is below it, the paddle moves downward.
The amount of movement is limited by AI_SPEED_1 , which prevents the paddle from moving instantly.
So the left paddle behaves like a simple tracking AI that tries to align itself with incoming ball position.
7) Right Paddle AI Logic
if state.ball_vx > 0
if state.p2_y + PADDLE_H/2 < state.ball_y
state.p2_y += math.min(AI_SPEED_2, state.ball_y - (state.p2_y + PADDLE_H/2))
else if state.p2_y - PADDLE_H/2 > state.ball_y
state.p2_y -= math.min(AI_SPEED_2, (state.p2_y - PADDLE_H/2) - state.ball_y)
This is the mirror logic for the right paddle.
It only moves when the ball is traveling toward the right side. It uses the same tracking idea as the left paddle, but its maximum speed is set independently by AI_SPEED_2 .
That means each side can have slightly different behavior and difficulty characteristics.
8) Keeping Paddles Inside the Arena
state.p1_y := math.max(PADDLE_H/2, math.min(GAME_HEIGHT - PADDLE_H/2, state.p1_y))
state.p2_y := math.max(PADDLE_H/2, math.min(GAME_HEIGHT - PADDLE_H/2, state.p2_y))
After paddle movement is updated, the script clamps both paddles so they cannot leave the top or bottom of the field.
The center of each paddle must remain between:
PADDLE_H/2
and
GAME_HEIGHT - PADDLE_H/2
This ensures that the visible paddle body never extends outside the game frame.
9) Ball Bounce on Top and Bottom Walls
if state.ball_y >= GAME_HEIGHT
state.ball_y := GAME_HEIGHT
state.ball_vy := -state.ball_vy
else if state.ball_y <= 0
state.ball_y := 0
state.ball_vy := -state.ball_vy
This block handles vertical wall collisions.
If the ball reaches or exceeds the top boundary, its vertical position is snapped to the top edge and its vertical velocity is reversed.
If the ball reaches or drops below the bottom boundary, the same thing happens at the lower edge.
This creates a classic arcade bounce effect where the ball reflects off the horizontal walls and stays inside the arena.
10) Left Side Paddle Collision and Right Side Scoring
if state.ball_x <= 0
if math.abs(state.ball_y - state.p1_y) <= PADDLE_H/2 + 3
state.ball_x := 0
state.ball_vx := -state.ball_vx
state.ball_vy += (state.ball_y - state.p1_y) * 0.15
state.ball_vy := math.max(-4.0, math.min(4.0, state.ball_vy))
else
state.p2_score += 1
state.ball_x := GAME_WIDTH / 2
state.ball_y := GAME_HEIGHT / 2
state.ball_vx := BALL_SPD_X
state.ball_vy := BALL_SPD_Y * (state.p2_score % 2 == 0 ? 1 : -1)
This is one of the main gameplay blocks.
When the ball reaches the left boundary, the script checks whether the ball is close enough to the left paddle vertically. If yes, it counts as a successful return.
On a successful return:
the ball is snapped to the left edge,
its horizontal velocity is reversed,
and its vertical velocity is modified based on where it hit the paddle.
This extra adjustment is important because it creates angled returns rather than perfectly repetitive motion. The farther from the paddle center the hit occurs, the more the vertical speed is changed.
The vertical speed is then clamped between negative four and positive four to keep the game stable.
If the left paddle misses, the right side scores a point. The ball resets to the center, moves back toward the right, and gets a vertical direction that alternates based on score parity.
11) Right Side Paddle Collision and Left Side Scoring
else if state.ball_x >= GAME_WIDTH
if math.abs(state.ball_y - state.p2_y) <= PADDLE_H/2 + 3
state.ball_x := GAME_WIDTH
state.ball_vx := -state.ball_vx
state.ball_vy += (state.ball_y - state.p2_y) * 0.15
state.ball_vy := math.max(-4.0, math.min(4.0, state.ball_vy))
else
state.p1_score += 1
state.ball_x := GAME_WIDTH / 2
state.ball_y := GAME_HEIGHT / 2
state.ball_vx := -BALL_SPD_X
state.ball_vy := BALL_SPD_Y * (state.p1_score % 2 == 0 ? 1 : -1)
This is the mirror version of the left side logic.
When the ball reaches the right boundary, the script tests whether the right paddle is in position. If it is, the ball bounces back left and its vertical speed changes according to impact location. If not, the left player scores and the ball resets to center.
Together, the left and right boundary blocks define the full rally and scoring logic of the game.
12) Updating the Trail Memory
state.trail_pts.unshift(Point.new(state.ball_x, state.ball_y))
state.trail_pts.pop()
After the new ball position is resolved, the script stores it at the front of the trail point array. Then it removes the oldest stored point from the end.
This gives the script a rolling history of recent ball positions. Those points are later used to position each trail segment.
So the trail always follows the newest motion path while keeping a fixed length.
13) Converting Game Coordinates Into Chart Coordinates
method draw_frame(GameState state, int base_x) =>
int right_x = base_x + 5
int left_x = right_x - GAME_WIDTH
This method begins the rendering step.
The game is not drawn in a separate graphics window. It is projected directly onto chart coordinates. The current bar index acts as the base anchor, and the script defines a right edge slightly ahead of it. From that right edge, it subtracts the game width to get the left edge.
So the whole game field is mapped into a section of chart space that moves with the current bar position.
14) Drawing the Background and Paddles
state.bg_box.set_lefttop(left_x, GAME_HEIGHT)
state.bg_box.set_rightbottom(right_x, 0)
state.p1_line.set_xy1(left_x, state.p1_y + PADDLE_H/2)
state.p1_line.set_xy2(left_x, state.p1_y - PADDLE_H/2)
state.p2_line.set_xy1(right_x, state.p2_y + PADDLE_H/2)
state.p2_line.set_xy2(right_x, state.p2_y - PADDLE_H/2)
This block updates the main field and the paddle drawings.
The background box spans from the left edge to the right edge and from zero to the full game height.
The left paddle is drawn as a vertical line on the left boundary.
The right paddle is drawn as a vertical line on the right boundary.
Each paddle extends above and below its center position by half the paddle height. That makes the paddle length consistent and easy to manage mathematically.
15) Drawing the Ball and the Score
state.ball_lbl.set_xy(left_x + int(math.round(state.ball_x)), state.ball_y)
state.score_lbl.set_xy(left_x + GAME_WIDTH/2, GAME_HEIGHT - 10)
state.score_lbl.set_text(str.tostring(state.p1_score) + " - " + str.tostring(state.p2_score))
This block positions the moving ball and updates the scoreboard.
The ball label is placed by adding the ball’s internal game x coordinate to the left boundary of the field. Its y coordinate is the current ball height.
The score label is placed near the top center of the arena and updated with the current left and right scores.
So every frame, the game communicates both live motion and match progress.
16) Drawing the Motion Trail
for i = 0 to TRAIL_LEN - 1
Point p1 = state.trail_pts.get(i)
Point p2 = i + 1 < TRAIL_LEN ? state.trail_pts.get(i + 1) : p1
line l = state.trail_lines.get(i)
l.set_xy1(left_x + int(math.round(p1.x)), p1.y)
l.set_xy2(left_x + int(math.round(p2.x)), p2.y)
This loop converts stored trail points into visible trail segments.
For each trail slot, the script reads one point and the next point after it. Then it updates the corresponding trail line so it connects those two positions.
Because the trail lines were created with different transparency levels earlier, the newest segments appear stronger and older segments fade out.
This gives the ball a continuous motion streak that makes gameplay easier to follow visually.
17) Persistent State Initialization
varip GameState state = GameState.new(
ball_x = GAME_WIDTH / 2,
ball_y = GAME_HEIGHT / 2,
ball_vx = BALL_SPD_X,
ball_vy = BALL_SPD_Y,
p1_y = GAME_HEIGHT / 2,
p2_y = GAME_HEIGHT / 2,
p1_score = 0,
p2_score = 0,
trail_pts = array.new(),
trail_lines = array.new()
)
This block creates the persistent live game state.
The ball starts in the center of the arena.
Both paddles start in the vertical center.
Both scores start at zero.
Empty arrays are prepared for the trail points and trail lines.
The use of varip is important here because it keeps the game state persistent as the script updates, allowing the game to evolve continuously rather than resetting each time.
18) First Bar Initialization and Main Update Loop
if barstate.isfirst
state.init_drawings()
state.update_physics()
state.draw_frame(bar_index)
This is the main execution flow.
On the very first bar, the script creates all required drawings through init_drawings() .
After that, every update performs two steps:
first the game physics are advanced,
then the new state is rendered onto the chart.
This is the standard game loop pattern:
update state,
then draw state.
19) Invisible Plot Anchors
plot(100, color=color.new(color.white, 100))
plot(0, color=color.new(color.white, 100))
These invisible plots help stabilize the vertical scale for the game area.
Because the whole arena is designed between zero and one hundred on the y axis, plotting hidden values at those levels ensures the script keeps a consistent vertical drawing space.
This is a subtle but important implementation detail. Without it, the game objects could be compressed or mispositioned by automatic scaling behavior.
20) Practical Interpretation
Auto Play Ping/Pong is best understood as a Pine Script animation and state management demo rather than as a market analysis indicator. Its real value comes from showing how chart objects, arrays, persistent state, and update logic can be combined to create a living visual system inside PulseWire.
The script demonstrates:
state persistence,
object reuse,
basic game physics,
simple AI motion,
collision handling,
score management,
and visual effects such as motion trails.
That makes it a strong example for anyone exploring creative Pine development, chart animation, or non traditional overlay design. Indicator
Market Acceptance Envelope [Interakktive]The Market Acceptance Envelope (MAE) is a diagnostic tool that shows where price statistically belongs — not where it might go. Unlike traditional bands that expand with volatility, MAE expands with acceptance: regions where price rotates comfortably, efficiency drops, and the market agrees on fair value.
This is the anti-Bollinger thesis: bands should represent where price IS accepted, not where it MIGHT reach based on standard deviation.
█ USAGE
The filled corridor represents the current acceptance zone — where price has demonstrated rotational behavior with low directional efficiency. When price is inside the corridor, it's "home." When outside, it's exploring territory the market hasn't yet accepted.
For discretionary traders, MAE provides instant context: "Is price where it belongs, or is it extended?"
For systematic traders, the exported values (confidence, asymmetry, position) can inform position sizing and filter logic.
█ ACCEPTANCE CENTROID
Unlike traditional bands centered on a moving average, MAE uses an Acceptance Centroid — a time-weighted price level where acceptance behavior concentrates. The centroid is calculated by weighting price by:
• Inverse efficiency (low efficiency = high acceptance)
• Volatility stability (stable vol = higher weight)
• Dwell factor (time spent near level)
This means the centroid drifts toward where price actually rotates, not simply where it averages.
█ ASYMMETRIC BOUNDARIES
MAE calculates upper and lower boundaries independently. Markets rarely treat up and down equally — during uptrends, the upper boundary may be wider (more accepted upside exploration), while the lower boundary stays tight (quick rejection of dips).
This asymmetry is visible on the chart and exported as a metric (-1 to +1).
█ CONFIDENCE-BASED VISIBILITY
The corridor's opacity reflects acceptance confidence:
• High confidence → clearly visible corridor (price is in accepted rotation)
• Low confidence → faded corridor (trending/directional market, acceptance not established)
When the corridor fades, it's telling you: "Acceptance hasn't been earned here yet."
█ WHAT THIS INDICATOR IS
• A diagnostic acceptance envelope showing where price statistically belongs
• Asymmetric by design — upper and lower calculated independently
• Confidence-weighted visibility — fades when acceptance is not earned
• Non-repainting — uses closed-bar data only
█ WHAT THIS INDICATOR IS NOT
• NOT Bollinger Bands (no standard deviation around a mean)
• NOT Keltner Channels (no ATR-scaled envelope)
• NOT a signal generator — no touches = signals philosophy
• NO arrows, NO entries/exits, NO buy/sell recommendations
█ HOW IT WORKS
MAE uses an acceptance-weighted calculation approach:
1. ACCEPTANCE WEIGHT
Each bar receives a weight based on:
• Efficiency: (1 - efficiency) — low efficiency = rotational = high acceptance
• Volatility Stability: stable vol environment = higher weight
• Dwell Factor: price staying near central tendency = higher weight
2. ACCEPTANCE CENTROID
Weighted average of price using acceptance weights:
centroid = Σ(price × weight) / Σ(weight)
Smoothed adaptively — faster during drift, slower when stable.
3. ASYMMETRIC BOUNDARIES
Upper and lower distances calculated separately:
• rngUp = acceptance-weighted average of (price - centroid) when price > centroid
• rngDn = acceptance-weighted average of (centroid - price) when price < centroid
4. CONFIDENCE SCORE
Composite of average acceptance weight, volatility stability, and centroid stability.
Maps to corridor opacity: high confidence = visible, low confidence = faded.
█ SETTINGS
Market Acceptance Envelope — Core
• Acceptance Lookback (20): Bars to evaluate for acceptance conditions. Higher = smoother, slower response.
• Preset (Swing): Scalper = tight/fast, Swing = balanced, Position = wide/stable.
• Envelope Sensitivity (1.0): Width multiplier. Higher = wider corridor.
Market Acceptance Envelope — Visuals
• Show Corridor (true): Display the acceptance corridor.
• Show Centroid (false): Display the acceptance centroid line.
Market Acceptance Envelope — Data Window
• Show Data Window Values (false): Export MAE metrics for external use.
█ EXPORTED VALUES
When Data Window is enabled:
• mae_upper: Upper boundary value
• mae_lower: Lower boundary value
• mae_centroid: Acceptance centroid value
• mae_width: Corridor width (upper - lower)
• mae_asymmetry: Asymmetry ratio (-1 to +1, negative = lower wider)
• mae_confidence: Acceptance confidence (0-100)
• mae_position: Price position (-1 = below, 0 = inside, +1 = above)
█ SUITABLE MARKETS
Works on all markets: Stocks, Futures, Forex, Crypto, Indices.
Works on all timeframes. Higher timeframes show more stable acceptance zones.
█ DISCLAIMER
This indicator is for educational and informational purposes only. It does not constitute financial advice. Past performance does not guarantee future results. Always conduct your own analysis and use proper risk management. This is a diagnostic tool — it provides context, not signals. Indicator
Market State Intelligence [Interakktive]Market State Intelligence (MSI) is a diagnostic market-context indicator that reveals how the market is behaving — not where price "should" go.
MSI does not generate buy/sell signals. Instead, it classifies market conditions into clear behavioural regimes by continuously measuring:
- DRIVE (directional effort)
- OPPOSITION (absorption / resistance)
- STABILITY (structural persistence)
MSI is designed to answer three practical questions:
- What state is the market in right now?
- Is energy building, releasing, or decaying?
- Is participation aligned with price, or opposing it?
█ WHAT MSI DOES
MSI operates as a real-time regime classification engine that processes each closed bar through three independent measurement systems:
DRIVE — Directional Effort (0–100)
- Displacement efficiency (net progress vs total path)
- Range expansion quality (actual range vs expected ATR range)
- Body dominance (body vs candle range)
OPPOSITION — Absorption / Resistance (0–100)
- Wick pressure (rejection relative to attempt)
- Effort–result gap (high effort, low progress)
- Reversal density (counter-moves frequency)
STABILITY — Persistence (0–100)
- Condition persistence (how long conditions hold)
- Variance score (flip frequency)
- Follow-through consistency (reaction continuity)
These three forces feed a deterministic classifier with hysteresis (anti-flicker) to identify five regimes:
COMPRESSION — low drive, low opposition, higher stability (pressure building, direction unclear)
EXPANSION — high drive, low opposition (directional energy release)
TREND — medium-high drive, higher stability, low-medium opposition (healthy continuation)
DISTRIBUTION — medium drive, high opposition (effort absorbed; progress blocked)
TRANSITION — rapidly rising opposition, low stability (regime breakdown / uncertainty)
█ WHAT MSI DOES NOT DO
- No buy/sell signals, entries/exits, or performance claims
- No prediction of future direction
- No repainting: calculations use closed-bar data only
MSI is a market state layer intended to support your execution framework.
█ VISUAL SYSTEM
MSI uses a layered visual grammar designed to remain readable on live charts:
Regime Ribbon
A thin horizontal band showing the current regime via colour. Ribbon opacity reflects regime confidence (stronger confidence = more visible).
Pressure Envelope (core visual)
A soft corridor around price that expands with Drive and becomes more visible as Opposition increases. This visualises "pressure thickness" around current action (not a volatility band for entries).
Structural Memory
Faint background stains appear where regimes previously failed (e.g., expansion collapsing into absorption). These are behavioural context zones showing where market intention was rejected — not support/resistance.
Regime Change Markers (optional)
Subtle labels appear when regimes transition after confirmation. Useful for replay and education.
Effort Halo (optional)
Candle highlighting when Opposition materially exceeds Drive, indicating absorption/inefficiency.
█ HUD PANEL
The HUD displays:
- Current regime name + colour indicator
- A context gate showing whether conditions are aligned with long-bias or short-bias context (not an entry/exit system)
█ REGIME LEGEND
When enabled, displays:
- A one-line definition of the current regime
- Live Drive / Opposition / Stability values for interpretation
█ TIME-TO-DECISION METER
A visual pressure gauge that tends to fill during Compression (energy building) and drain during Expansion (energy releasing). It is a state-tracking meter, not a timing tool.
█ SETTINGS
MSI — Settings
- Preset Mode: Scalper / Swing / Position
- Analysis Mode (Minimal): ON = subtle visuals, OFF = full intensity
- Regime Ribbon, Structural Memory, HUD Panel, Time-to-Decision Meter, Effort Halo
MSI — Visual Options
- Show Regime Changes: Labels when regime transitions occur
- Show Regime Legend: Definition and live values display
- Panel Position: Move the entire panel anywhere on chart
MSI — Advanced (Tuning)
- Sensitivity (0.5–2.0)
- Smoothing (0.5–2.0)
- Memory Decay (0.5–2.0)
- Visual Intensity (Low / Medium / High)
█ PRESETS EXPLAINED
Scalper
Higher sensitivity + lower smoothing + faster memory decay. Best for 1m–15m monitoring.
Swing (default)
Balanced behaviour. Best for 15m–4H analysis.
Position
Lower sensitivity + higher smoothing + slower memory decay. Best for 4H–1D macro context.
█ STRUCTURAL MEMORY
When a regime fails (example: Expansion → Distribution), MSI creates a memory imprint:
- Fixed stain window (preset dependent)
- Strength decays over time
- Limited to a maximum number of imprints to reduce chart clutter
These zones represent behavioural rejection, not levels.
█ SUITABLE MARKETS
MSI is designed for Forex, Crypto, Indices, Stocks, and Commodities.
Works from intraday to Daily, with particularly strong readability on 15m–4H.
█ DISCLAIMER
This indicator is for educational and informational purposes only. It does not constitute financial advice, trading recommendations, or solicitation. Trading involves substantial risk. Always use proper risk management and make independent decisions. Indicator
Market Pressure Regime [Interakktive]The Market Pressure Regime (MPR) is a 4-state market classifier that models how structural forces create "pressure zones" — regions where price movement is either supported (Release) or suppressed (Pinned) by market microstructure.
It combines compression analysis, follow-through efficiency, and stress detection into a composite pressure score, classifying markets into Release, Suppressed, Transition, or Trap states — helping traders understand WHY price is moving (or not moving) in the current environment.
█ USAGE
MPR addresses a core question traders face: Is the market in a regime where directional moves are likely to follow through, or is it structurally pinned?
For swing traders, MPR identifies Release phases where momentum strategies work best, and Suppressed phases where mean reversion dominates.
For day traders, it highlights Trap conditions — high effort with no follow-through — where reversals are probable and trend entries fail.
🔹 The 4-State Model
The indicator classifies markets into four distinct regimes:
• Release (Teal): Pressure score ≥ +5. Directional flow dominates. Price moves efficiently with follow-through. Favor trend continuation.
• Suppressed (Grey): Pressure score ≤ -5. Compression dominates. Price is range-bound or pinned. Fade extremes, expect reversion.
• Transition (Amber): Score between thresholds OR instability detected. Regime is uncertain — wait for confirmation before committing.
• Trap (Magenta): High stress + low follow-through. Effort without result. Expect reversals.
🔹 Reading the Pressure Histogram
The histogram displays the composite Pressure Score (range approximately -100 to +100):
• Positive values: Follow-through exceeds compression. Market is "releasing" — directional moves are supported.
• Negative values: Compression exceeds follow-through. Market is "suppressed" — price movement is constrained.
• Color reflects confirmed state: The histogram uses persistence filtering — a state must hold for N bars before the color changes, preventing false signals from noise.
🔹 The 5-Stage Calculation
MPR synthesizes five analytical stages into the final state:
1. Compression Score: Measures how tight the current range is relative to ATR. High compression suggests structural forces are pinning price.
2. Follow-Through Score: Measures price path efficiency (MER-style). Efficient moves indicate genuine directional flow, not chop.
3. Stress Score: Detects effort-without-result (ERD-style). High volume or range with no price progress = absorption.
4. Composite Pressure: Combines follow-through and compression into a single directional score.
5. Persistence Filter: Requires states to hold for configurable bars before confirming, eliminating flickering.
█ SETTINGS
Core Settings
• ATR Length: Period for volatility normalization. Default 14.
• Baseline Lookback: Period for compression and efficiency baselines. Default 20.
• Volume Average Length: Period for stress calculation baseline. Default 20.
State Classification
• Release Threshold: Pressure score above this = Release. Default +5.
• Suppressed Threshold: Pressure score below this = Suppressed. Default -5.
• Trap Threshold: Stress score above this (with low follow-through) = Trap. Default 30.
• Persistence Bars: Bars required to confirm state change. Default 3.
• Stability Lookback: Period for stability calculation. Default 20.
• Stability Threshold: Below this = forced Transition state. Default 0.5.
Visual Settings
• Show Pressure Histogram: Display the main pressure score histogram.
• Show Zero Line: Display the zero reference line.
• Show Background Tint: Subtle background color by state (default OFF).
Data Window
• Show Data Window Values: Export all calculated scores for analysis.
█ INTERPRETATION GUIDE
When to Use Trend Strategies (Release):
• Histogram tall and positive
• Teal coloring confirmed
• Price making efficient higher highs or lower lows
When to Use Mean Reversion (Suppressed):
• Histogram flat or negative
• Grey coloring confirmed
• Price oscillating without follow-through
When to Wait (Transition):
• Amber coloring
• Mixed signals — don't force trades
• Wait for state to resolve
When to Expect Reversals (Trap):
• Magenta coloring
• High volume moves that don't stick
• Often occurs at structural inflection points
█ COMPLEMENTARY TOOLS
MPR pairs well with:
• Volatility State Index (VSI) — Confirms whether volatility is expanding into the pressure regime
• Effort-Result Divergence (ERD) — Provides bar-by-bar absorption/vacuum detection
• Market Efficiency Ratio (MER) — Validates follow-through quality
█ SUITABLE MARKETS
Works across all liquid markets:
• Equities: SPY, QQQ, liquid single stocks
• Futures: ES, NQ, CL, GC
• Crypto: BTC, ETH
• Forex: Major pairs
Works on any timeframe, but 1H–Daily provides cleanest regime classification. Intraday (5m–15m) useful for session-level tactical decisions.
█ OPEN SOURCE
This indicator is open-source for educational purposes. Review the code to understand the full calculation methodology.
█ DISCLAIMER
This indicator is for educational and informational purposes only. It does not constitute financial advice. Past performance does not guarantee future results. Always conduct your own analysis and use proper risk management. Indicator
Volatility State Index [Interakktive]The Volatility State Index (VSI) classifies market volatility into three behavioral states: Expansion, Decay, and Transition. It answers one question visually: Is volatility supporting price movement, withdrawing, or unstable?
Unlike traditional volatility indicators that show levels or bands, VSI diagnoses the current volatility regime so traders can adapt their approach accordingly.
█ WHAT IT DOES
• Classifies volatility into three states: Expansion (teal), Decay (grey), Transition (amber)
• Measures volatility momentum as a percentage rate-of-change
• Applies stability filtering to detect unstable/choppy conditions
• Uses persistence logic to prevent state flickering
• Exports state data for use in alerts and strategies
█ WHAT IT DOES NOT DO
• NO buy/sell signals
• NO entry/exit recommendations
• NO alerts (v1 is diagnostic only)
• NO performance claims
This is a volatility diagnostic tool, not a trading system.
█ HOW IT WORKS
The VSI processes volatility through a five-stage pipeline:
STAGE 1 — Base Volatility
Calculates ATR as the foundation for volatility measurement.
STAGE 2 — Smoothing
Applies EMA smoothing to reduce noise in the volatility series.
STAGE 3 — Volatility Momentum
Computes the percentage rate-of-change of smoothed volatility:
Volatility Momentum (%) = ((Current ATR - Previous ATR) / Previous ATR) × 100
Positive values indicate expanding volatility; negative values indicate contracting volatility.
STAGE 4 — Stability Filter
Tracks how frequently volatility momentum changes direction. Frequent sign changes indicate unstable, choppy conditions.
Stability Score = 1 - (Average Flip Rate)
Low stability forces the Transition state regardless of momentum level.
STAGE 5 — State Classification
Combines momentum thresholds and stability to determine the final state:
• Expansion: Momentum ≥ +5% (default threshold)
• Decay: Momentum ≤ -5% (default threshold)
• Transition: Between thresholds OR low stability
A persistence filter requires states to hold for multiple bars before confirming, preventing visual noise.
█ INTERPRETATION
EXPANSION (Teal)
Volatility is increasing in a sustained way. Price moves are becoming larger.
What it suggests:
• Breakouts are more likely to follow through
• Stops may need wider placement
• Trend-following approaches tend to work better
• Mean-reversion weakens
DECAY (Grey)
Volatility is decreasing. Price is compressing into tighter ranges.
What it suggests:
• Breakouts are more likely to fail
• Ranges tend to hold
• Trend-following underperforms
• Mean-reversion strengthens
TRANSITION (Amber)
Volatility behavior is unclear or unstable. This is NOT neutral — it is uncertainty.
What it suggests:
• Mixed signals — one bar huge, next bar dead
• Higher whipsaw risk
• Reduced conviction in either direction
• Consider waiting for clarity
The key insight: Amber is a warning, not a middle ground. It appears when volatility cannot decide what it wants to do.
█ VISUAL DESIGN
The indicator uses a state-first histogram design:
• Histogram height shows volatility momentum percentage
• Histogram color shows the classified state
• Zero line provides visual anchor
• Optional momentum line for confirmation
• Optional background tint (default OFF for clean charts)
The visual hierarchy prioritizes instant state recognition. A trader should understand the volatility environment in under one second without reading numbers.
█ INPUTS
Core Settings
• ATR Length: Base volatility measurement period (default: 14)
• Smoothing Length: EMA smoothing applied to ATR (default: 10)
• Momentum Length: Rate-of-change lookback (default: 10)
State Classification
• Expansion Threshold (%): Momentum above this = Expansion (default: 5.0)
• Decay Threshold (%): Momentum below this = Decay (default: -5.0)
• Persistence Bars: Bars required to confirm state change (default: 3)
• Stability Lookback: Window for stability calculation (default: 20)
• Stability Threshold: Below this = forced Transition (default: 0.5)
Visual Settings
• Show State Histogram: Toggle main display (default: ON)
• Show Momentum Line: Thin confirmation line (default: OFF)
• Show Zero Line: Baseline reference (default: ON)
• Show Background Tint: Subtle state coloring (default: OFF)
█ DATA WINDOW EXPORTS
When enabled, the following values are exported:
• ATR (Raw)
• ATR (Smoothed)
• Volatility Momentum (%)
• Stability Score (0-1)
• State (-1/0/1): Decay = -1, Transition = 0, Expansion = 1
• Is Expansion (0/1)
• Is Decay (0/1)
• Is Transition (0/1)
These exports allow VSI to be used as a filter in Pine Script strategies or alert conditions.
█ ORIGINALITY
While ATR and volatility indicators are common, VSI is original because it:
1. Classifies volatility into behavioral states rather than showing raw levels
2. Applies momentum analysis to volatility itself (rate-of-change of ATR)
3. Uses stability filtering to detect genuinely unstable conditions
4. Implements persistence logic to prevent state flickering
5. Provides a state-first visual design optimized for instant recognition
VSI is state-first: it classifies volatility regimes (Expansion/Decay/Transition) rather than plotting volatility level alone, using momentum and stability to reduce false regime reads.
This is not a modified ATR or Bollinger Band — it is a volatility regime classifier.
█ SUITABLE MARKETS
Works on: Stocks, Futures, Forex, Crypto
Timeframes: All timeframes — state classification adapts accordingly
Best on: Instruments with consistent volatility patterns
█ RELATED
• Market Efficiency Ratio — measures price path efficiency
• Effort-Result Divergence — compares volume effort to price result
█ DISCLAIMER
This indicator is for educational purposes only. It does not constitute financial advice. Past performance does not guarantee future results. Always conduct your own analysis before making trading decisions. Indicator
lib_statemachine_modifiedLibrary "lib_statemachine_modified"
Modified to fix bugs and create getState and priorState methods.
method step(this, before, after, condition)
Namespace types: StateMachine
Parameters:
this (StateMachine)
before (int) : (int): Current state before transition
after (int) : (int): State to transition to
condition (bool) : (bool): Condition to trigger the transition
Returns: (bool): True if the state changed, else False
method step(this, after, condition)
Namespace types: StateMachine
Parameters:
this (StateMachine)
after (int) : (int): State to transition to
condition (bool) : (bool): Condition to trigger the transition
Returns: (bool): True if the state changed, else False
method currentState(this)
Namespace types: StateMachine
Parameters:
this (StateMachine)
method previousState(this)
Namespace types: StateMachine
Parameters:
this (StateMachine)
method changed(this, within_bars)
Namespace types: StateMachine
Parameters:
this (StateMachine)
within_bars (int) : (int): Number of bars to look back for a state change
Returns: (bool): True if a state change occurred within the timeframe, else False
method reset(this, condition, min_occurrences)
Namespace types: StateMachine
Parameters:
this (StateMachine)
condition (bool) : (bool): Condition to trigger the reset
min_occurrences (int) : (int): Minimum number of times the condition must be true to reset
Returns: (bool): True if the state was reset, else False
StateMachine
Fields:
state (series int)
neutral (series int)
enabled (series bool)
reset_counter (series int)
prior_state (series int)
last_change_bar (series int) Library
Correlation Cycle, CorrelationAngle, Market State - John EhlersHot off the press, I present this "Correlation Cycle, CorrelationAngle, and Market State" multicator employing PSv4.0, originally formulated by Dr. John Ehlers for TASC - June 2020 Traders Tips. Basically it's an all-in-one combination of three Ehlers' indicators. This power packed triplet indicator, being less than a 100 line implementation at initial release, is a heavily modified version of the original indicator using novel techniques that surpass John Ehlers' original intended design.
This is also a profound script in numerous ways. First of all, these three indicators are directly from the illustrious mastermind himself Dr. John Ehlers. Secondarily, this is my "50th" script published on TV, which makes it even more significant. I'm especially proud of this script to "degrees" of imagination I once didn't know was theoretically possible in code. My intellect has once again been mathemagically unlocked pondering new innovations with this code revelation. Thirdly, this PSv4.0 script shows the empowering beauty and elegance of hacking the stock markets with TV's ultra utilitarian Pine Editor(PE) in a common browser! Some of you may be wondering if I worked on this for days... nope! This only took a few hours, followed by writing this description for another hour plus.
I have created many of Ehlers' indicators in PE, a few of which I have published in my profile, but I wanted to show how programming with Pine Script can be an artistic form of craftsmanship and poetry. None of this would be possible without the ingeniously minded Tradingview staff revolutionizing algorithmic trading at it's finest. If you should ever encounter them by chance, ponder humbly thanking these computing wizards for their diligence and dedication. They are providing, and shall award to us members, some of the most fascinating conceptualized tech imaginable in the coming future. I can assure you, much, much more is yet to be unveiled for us TV members/enthusiasts. Thank you TV and all you offer to this community.
As always, I have included advanced Pine programming techniques that conform to proper "Pine Etiquette" by example. There are so many Pine mastery techniques included, I don't have an abundance of time to elaborate on all of them. For those of you are code savvy, you may have notice I only used one "for" loop for increased server efficiency, instead of the two "for" loops in the original formulation. For those of you who are newcomers to Pine Script, this code release may also help you comprehend the immense "Power of Pine" by employing advanced programming techniques while exhibiting code utilization in a most effective manner. This is commonly what my dense intricate code looks like behind the veil. If you are wondering why there is hardly any notes, that's because the notation is primarily in the variable naming.
Features List Includes:
Dark Background - Easily disabled in indicator Settings->Style for "Light" charts or with Pine commenting
AND a few more... Why list them, when you have the source code!
The comments section below is solely just for commenting and other remarks, ideas, compliments, etc... regarding only this indicator, not others. When available time provides itself, I will consider your inquiries, thoughts, and concepts presented below in the comments section, should you have any questions or comments regarding this indicator. When my indicators achieve more prevalent use by TV members, I may implement more ideas when they present themselves as worthy additions. As always, "Like" it if you simply just like it with a proper thumbs up, and also return to my scripts list occasionally for additional postings. Have a profitable future everyone! Indicator
