Peak Traker by Futures.RobbyOverview
Peak Tracker is a specialized tool designed to assist traders in proprietary trading challenges. Its main purpose is to help you identify and track the maximum value (the "peak") within an active trade. This is crucial for keeping an eye on your trailing drawdown and avoiding rule violations. The indicator visualizes up to three separate trade windows and provides all necessary data in a clear table.
Key Features
Trailing Drawdown Tracking: The primary function of this indicator is to accurately track the peak value from your entry point to your exit. This helps you minimize the risk of violating drawdown rules in your funding challenge.
Visual Representation: It draws vertical lines for the entry (green) and exit (red) points directly on the chart. This clearly visualizes the exact time frames that are relevant for managing your drawdown.
Dynamic Real-Time Tracking: Within an active trade window, the indicator continuously tracks the highest price reached (Peak) while the entry price (Entry) remains fixed. This allows you to calculate your current drawdown at any moment.
Clear Data Table: A customizable table provides all relevant information at a glance: Trade ID, Entry/Peak prices, and exact timestamps for entry and exit. The numbers are formatted for easy reading using the German number style (e.g., 12.345,67).
Flexible Input: The indicator supports various date and time formats (17:47:00, 2025-08-30 17:14:00, 27.08.25 15:00). The time zone is automatically converted from your local time to the chart's time for precise line placement.
How to Use
Add the indicator to your chart.
Open the indicator's settings (⚙️).
Under "Datums- und Zeit-Eingaben," enter the desired time frames for your trades.
The indicator updates in real time, showing your trade's progress.
Conclusion
This indicator is an essential tool for any trader participating in prop firm challenges who needs a precise method to monitor their trailing drawdown. It provides clarity and visual support to help you avoid rule violations and maximize your chances of success.
Индикаторы и стратегии
Overlay Candles (Multi-TF, right side projection)This script overlays candles from a custom selectable timeframe (5m to 1M) on the right side of the chart as projections.
It helps visualize and compare the ongoing price action with the last higher-timeframe candles without switching chart intervals.
Features:
Choose timeframe for overlay candles (5m, 15m, 1H, 4H, 1D, 1W, 1M).
Adjustable number of candles to display (1–8).
Fixed candle width (in bars) and configurable gap between candles.
Custom colors for bullish and bearish candles.
Adjustable wick and border thickness (px).
Candle borders drawn with four lines to ensure visibility at all zoom levels.
Use cases:
Multi-timeframe price action analysis.
Visualizing higher-timeframe structure alongside lower-timeframe trading.
Educational / visual aid for understanding candlestick context.
Liquidity Pulse Revealer (LPR) — by Qabas_algoLiquidity Pulse Revealer (LPR) — by Qabas_algo
The Liquidity Pulse Revealer (LPR) is a technical framework designed to uncover hidden phases of institutional activity by combining volatility (ATR Z-Score) and liquidity (Volume Z-Score) into a dual-condition detection model. Instead of relying on price action alone, LPR measures how volatility and traded volume behave relative to their historical distributions, revealing when the market is either “compressed” or “expanding with force.”
⸻
🔹 Core Mechanics
1. ATR Z-Score (Volatility Normalization)
• LPR calculates the Average True Range (ATR) on a higher timeframe (HTF).
• It applies a Z-Score transformation across a configurable lookback period to determine if volatility is statistically compressed (below mean) or expanded (above mean).
2. Volume Z-Score (Liquidity Normalization)
• Simultaneously, traded volume is normalized using the same Z-Score method.
• Elevated Volume Z-Scores signal the presence of institutional activity (accumulation/distribution or aggressive breakout participation).
3. Dual Conditions → Regimes
• 🧊 Iceberg Volume = Low ATR Z-Score + High Volume Z-Score.
→ Indicates a “hidden liquidity build-up” phase where price compresses but big players are positioning.
• ⚡ Revealed Momentum = High ATR Z-Score + High Volume Z-Score.
→ Marks explosive volatility phases where institutional activity is fully expressed in directional moves.
⸻
🔹 Visualization
• Iceberg Zones (blue shaded boxes):
Drawn automatically around periods of statistical compression + elevated volume. These zones act as launchpads; once broken, they often precede strong directional expansions.
• Revealed Zones (green shaded boxes):
Highlight expansionary phases with both volatility and volume spiking. They often align with trend acceleration or terminal exhaustion zones.
• Midline Tracking:
Each zone maintains a dynamic average (mid-price), updated as the session evolves, providing reference for breakout confirmation and invalidation levels.
⸻
🔹 Practical Use Cases
• Accumulation/Distribution Detection:
Spot where “smart money” is quietly building or unloading positions before large moves.
• Breakout Confirmation:
A breakout occurring after an Iceberg zone carries higher conviction than random volatility.
• Profit Management:
If a Revealed Momentum zone appears after a strong uptrend, it often signals distribution or exhaustion — useful for partial profit taking.
• Multi-Timeframe Adaptability:
With Auto, Multiplier, and Manual higher-timeframe modes, LPR adapts seamlessly to intraday scalping or swing trading contexts.
⸻
🔹 Alerts
• Instant alerts for the start of new Iceberg or Revealed zones.
• Optional alerts for breakouts above/below the last Iceberg zone boundaries.
⸻
🔹 Example Trading Scenario
1. Detection: An 🧊 Iceberg Volume zone forms around support (low volatility + high volume).
2. Trigger: Price closes above the upper boundary of this Iceberg zone.
3. Entry: Go long on the breakout.
4. Stop Loss: Place stop just below the Iceberg zone’s low (where the liquidity build-up started).
5. Target: Hold until a ⚡ Revealed Momentum zone forms — then start scaling out as the expansion matures.
This simple framework transforms hidden institutional behavior into actionable trade setups with clear risk management.
⸻
⚠️ Disclaimer: The LPR is a research and educational tool. It does not provide financial advice. Always apply proper risk management and use in combination with your own trading framework.
SMC Suite – OB • Breaker • Liquidity Sweep • FVGSMC Suite — Order Blocks • Breaker • Liquidity Sweep • FVG
What it does:
Maps institutional SMC structure (OB → Breaker flips, Liquidity Sweeps, and 3-bar FVGs) and alerts when price retests those zones with optional r ejection-wick confirmation .
Why this isn’t “just a mashup”?
This tool implements a specific interaction between four classic SMC concepts instead of only plotting them side-by-side:
1. OB → Breaker Flip (automated): When price invalidates an Order Block (OB), the script converts that zone into a Breaker of opposite bias (bullish ⇄ bearish), extends it, and uses it for retest signals.
2. Liquidity-Gated FVGs : Fair Value Gaps (3-bar imbalances) are optionally gated—they’re only drawn/used if a recent liquidity sweep occurred within a user-defined lookback.
3. Retest Engine with Rejection Filter : Entries are not whenever a zone prints. Signals fire only if price retests the zone, and (optionally) the candle shows a rejection wick ≥ X% of its range.
4. Signal Cooldown : Prevents spam by enforcing a minimum bar gap between consecutive signals.
These behaviors work together to catch the sequence many traders look for: sweep → impulse → OB/FVG → retest + rejection.
Concepts & exact rules
1) Impulsive move and swing structure
• A bar is “ impulsive ” when its range ≥ ATR × Impulsive Mult and it closes in the direction of the move.
• Swings use Pivot Length (lenSwing) on both sides (HH/LL detection). These HH/LLs are also used for sweep checks.
2) Order Blocks (OB)
• Bullish OB : last bearish candle body before an i mpulsive up-move that breaks the prior swing high . Zone = min(open, close) to low of that candle.
• Bearish OB : last bullish candle body before an impulsive down-move that breaks the prior swing low . Zone = high to max(open, close).
• Zones extend right for OB Forward Extend bars.
3) Breaker Blocks (automatic flip)
If price invalidates an OB (closes below a bullish OB’s low or above a bearish OB’s high), that OB flips into a Breaker of opposite bias:
• Invalidated bullish OB → Bearish Breaker (resistance).
• Invalidated bearish OB → Bullish Breaker (support).
Breakers get their own style/opacity and are used for separate Breaker Retest signals.
4) Liquidity Sweeps (decluttered)
• Bullish sweep : price takes prior high but closes back below it.
• Bearish sweep : price takes prior low but closes back above it.
Display can be tiny arrows (default), short non-extending lines, or hidden. Old marks auto-expire to keep the chart clean.
5) Fair Value Gaps (FVG, 3-bar)
• Bearish FVG : high < low and current high < low .
• Bullish FVG : low > high and current low > high .
• Optional gating: only create/use FVGs if a sweep occurred within ‘Recent sweep’ lookback.
6) Retest signals (what actually alerts)
A signal is true when price re-enters a zone and (optionally) the candle shows a rejection wick:
• OB Retest LONG/SHORT — same-direction retest of OB.
• Breaker LONG/SHORT — opposite-direction retest of flipped breaker.
• FVG LONG/SHORT — touch/fill of FVG with rejection.
You can require a wick ratio (e.g., bottom wick ≥ 60% of range for longs; top wick for shorts). A cooldown prevents back-to-back alerts.
How to use
1. Pick timeframe/market : Works on any symbol/TF. Many use 15m–4h intraday and 1D swing.
2. *Tune Pivot Length & Impulsive Mult:
• Smaller = more zones and quicker flips; larger = fewer but stronger.
3. Decide whether to gate FVGs with sweeps : Turn on “Require prior Liquidity Sweep” to focus on post-liquidity setups.
4. Set wick filter : Start with 0.6 (60%) for cleaner signals; lower it if too strict.
5. Style : Use the Style / Zones & Style / Breakers groups to set colors & opacity for OB, Breakers, FVGs.
6. Alerts : Add alerts on any of:
• OB Retest LONG/SHORT
• Breaker LONG/SHORT
• FVG LONG/SHORT
Choose “Once per bar close” to avoid intrabar noise.
Inputs (key)
• Swing Pivot Length — swing sensitivity for HH/LL and sweeps.
• Impulsive Move (ATR ×) — defines the impulse that validates OBs.
• OB/FVG Forward Extend — how long zones project.
• Require prior Liquidity Sweep — gate FVG creation/usage.
• Rejection Wick ≥ % — confirmation filter for retests.
• Signal Cooldown (bars) — throttles repeated alerts.
• Display options for sweep marks — arrows vs short lines vs hidden.
• Full color/opacity controls — independent palettes for OB, Breakers, and FVGs (fills & borders).
What’s original here
• Automatic OB → Breaker conversion with separate retest logic.
• Liquidity-conditioned FVGs (FVGs can be required to follow a recent sweep).
• Unified retest engine with wick-ratio confirmation + cooldown.
• Decluttered liquidity visualization (caps, expiry, and non-extending lines).
• Complete styling controls for zone types (fills & borders), plus matching signal label colors.
🔹 Notes
• This script is invite-only.
• It is designed for educational and discretionary trading use, not as an autotrader.
• No performance guarantees are implied — always test on multiple markets and timeframes.
Trendline + Bull/Bear Flag + EMA 9/21 Buy-Sell Signalseasy scalping and buy sell signals on 9-21 ema cross and trendline breakout
💎 Quantum Big Move MTF Indicator 💎1. Purpose of the Indicator
The Quantum Big Move MTF Indicator is designed to identify significant market moves using multiple moving averages across different timeframes (multi-timeframe).
Its goal is to filter market noise and provide visual signals of major moves, helping traders to identify strong trends and potential turning points.
2. Key Components
a) Moving Averages (MAs)
The indicator uses two main moving averages:
Fast MA (short-term):
Captures short-term price behavior.
Can be SMA, EMA, WMA, Hull, VWMA, RMA, or TEMA.
Configurable by the user for length and type.
Slow MA (long-term):
Represents the longer-term trend.
Helps filter false signals and focus on significant moves.
Also configurable for type and length.
b) Multi-Timeframe
Both MAs are calculated in a selected timeframe (either the current chart timeframe or a custom one).
This allows detection of strong moves in a broader context, increasing signal reliability.
c) Color Logic
MAs change color based on the trend:
Green → uptrend.
Red → downtrend.
Gray → no clear trend or transition.
This helps visually interpret the strength and direction of the trend.
d) Cross Signals (Big Moves)
Upward Move Signal
Appears when the Fast MA crosses above the Slow MA while in an uptrend.
Downward Move Signal
Appears when the Fast MA crosses below the Slow MA while in a downtrend.
Note: These signals are indicative only and are not buy or sell orders. They are visual tools to aid decision-making.
3. How to Interpret the Indicator
Identify the Trend:
Observe the color of the Fast and Slow MAs.
Green = positive trend, Red = negative trend.
Wait for a Significant Cross:
Only consider signals if the Fast MA aligns with the trend direction.
Avoid acting on contradictory signals or crossovers in a sideways market.
Combine with Other Tools:
Use volume, support/resistance levels, or momentum indicators to confirm the strength of the move.
4. Recommended Settings
Fast MA: 20–30 periods (captures short-term moves).
Slow MA: 60–100 periods (filters noise and highlights major trends).
Smoothing factor: 2–4 to smooth color changes and reduce false signals.
Adjust based on the asset and timeframe being analyzed.
5. Disclaimer
Important:
This indicator does not guarantee profits and is not financial advice.
Signals are for educational and informational purposes only, and should be used together with your own risk analysis and capital management.
Users are responsible for any trading decisions made based on this indicator.
Equities OpenThe Equities Open indicator makes it easy to spot the highest and lowest prices during the equities open or a customizable time you choose. It draws lines to show the high and low points and extends them across the chart to a time you pick, such as 3:00 PM that same day. A shaded box highlights the price range during that session. You can customize things such as the session time, timezone, line thickness, colors, and choose if you want the shaded box to show up. It’s built to run smoothly and works best for charts with short timeframes (up to 59 minutes). Perfect for traders who want to focus on key price levels set during pre-market hours!
ICT KEY LEVELS (L3J)📊 Overview
The ICT KEY LEVELS (L3J) indicator is a tool designed to automatically identify and display key levels based on Inner Circle Trader (ICT) concepts.
This indicator combines session-based levels with multi-timeframe highs/lows analysis to provide traders with critical price zones for decision-making.
Developed by L3J - This indicator can be used in conjunction with other indicators I have developed for enhanced market analysis.
🎯 Key Features
Session-Based Levels
- Previous Day High/Low (PDH/PDL): Automatically identifies and displays the previous trading day's high and low levels
- Asian Session Levels: Tracks high and low during Asian trading hours (20:00-03:00 GMT+4)
- European Session Levels: Captures London session high and low levels (03:00-08:30 GMT+4)
Multi-Timeframe Analysis
- H1 Pivot Levels: Identifies 2-candle reversal patterns on 1-hour timeframe
- H4 Pivot Levels: Detects 4-hour pivot points using advanced pattern recognition
- Smart Visibility: Levels are only shown on appropriate timeframes (H1 levels on H1, H4 levels on H4)
Advanced Features
- Priority System: Automatically hides overlapping levels based on importance (Previous Day > Sessions > H4 > H1)
- Dynamic Labels: Real-time labels that update with price action
- Intelligent Cleanup: Removes crossed or outdated levels to maintain chart clarity
- Customizable Anchoring: Choose between precise timestamp anchoring or candle middle anchoring
- Performance Optimized: Built with efficient code structure for smooth chart performance
⚙️ Configuration Options
Note: Currently, the user interface settings are displayed in French. This will be updated to English in a future version.
General Settings
- Timezone: Configurable timezone for session calculations (default: GMT+4)
- Trading Days: Number of trading days to analyze (1-20 days)
- Extension: Right extension length for level lines
- Anchoring Mode: Precise timestamp or candle middle anchoring
Visual Customization
Each level type (Asia, Europe, Previous Day, H1, H4) includes:
- Color Selection: Separate colors for highs and lows
- Line Styles: Solid, Dotted, or Dashed lines
- Line Width: Adjustable thickness (1-4 pixels)
- Show/Hide Toggle: Individual control for each level type
🕒 Session Times
- Trading Day: 18:00-16:00 (CME session)
- Asian Session: 20:00-03:00 GMT+4
- European Session: 03:00-08:30 GMT+4
All times are configurable and timezone-aware
📈 How It Works
Level Detection
1. Session Levels: Continuously tracks price action during specific trading sessions
2. Pivot Detection: Uses 2-candle reversal patterns (bullish then bearish for highs, bearish then bullish for lows)
3. Multi-Timeframe Data: Requests higher timeframe data for H1 and H4 analysis
Smart Management
- Automatic Cleanup: Removes levels that have been crossed or are too old
- Priority Filtering: Hides duplicate levels based on importance hierarchy
- Dynamic Updates: Real-time adjustment of level positions and labels
🎨 Visual Elements
- Horizontal Lines: Extend from level creation point to the right
- Dynamic Labels: Show level type and session information
- Color Coding: Different colors for each session and timeframe
- Transparency: Automatically hides overlapping or less important levels
🔧 Technical Specifications
- Pine Script Version: v6
- Chart Overlay: True
- Max Lines: 500
- Max Labels: 50
- Performance: Optimized with intelligent memory management
📋 Usage Tips
1. Best Timeframe: Works on all timeframes, but H1 and lower provide optimal detail
2. Combine with Price Action: Use levels as confluence zones for entry/exit decisions
3. Risk Management: Levels can serve as stop-loss and take-profit targets
4. Market Structure: Helps identify key support/resistance in market structure analysis
🔄 Compatibility
This indicator is designed to work alongside other L3J indicators for comprehensive market analysis.
📞 Support & Updates
For questions, suggestions, or updates, please contact L3J through TradingView messaging.
---
Disclaimer : This indicator is for educational and analysis purposes. Always practice proper risk management and never risk more than you can afford to lose.
Version: 1.0
Author: L3J
Last Updated: 30/08/2025
Open High Low Close & Pivot Points [Prakash Kannan]Best Indicator to have previous day OHLC and Pivot Points
Dynamic Support & Resistance Zones v2 | Adaptive Channel System1. Overview of the Indicator
The Dynamic Support & Resistance Zones v2 indicator identifies key support and resistance levels based on the price action and volatility of the market. The indicator adapts to market conditions in real-time, dynamically adjusting the support and resistance zones as the price moves.
Support refers to the price level where a downward movement tends to stop, as buyers step in and push the price up.
Resistance refers to the price level where an upward movement tends to halt, as sellers come in and push the price back down.
The indicator combines two key elements:
Adaptive Channels: The support and resistance levels adjust based on market volatility (using the Average True Range - ATR).
Dynamic Zones: The support and resistance zones have gradients that change based on the proximity of price movements to these levels.
2. The Core Calculations:
a. ATR for Volatility:
ATR (Average True Range) is calculated to determine market volatility. This tells us how much the price has been moving over a certain period.
The indicator uses ATR to determine the width of the support and resistance channels. A higher ATR means wider channels (greater volatility), while a lower ATR leads to narrower channels (less volatility).
b. Dynamic Support & Resistance Levels:
Support Levels: The indicator calculates the lowest low over a specified lookback period (e.g., 20 bars). The support zone is then adjusted using a factor based on the ATR to create a dynamic channel.
Support Upper & Lower Levels: These form the outer boundaries of the support channel.
Smooth Support: The indicator uses a smoothing period to make these support levels less volatile and more accurate.
Resistance Levels: Similarly, the highest high over the lookback period is used to calculate the resistance levels. The ATR is again used to adjust the channel width.
Resistance Upper & Lower Levels: These form the outer boundaries of the resistance channel.
Smooth Resistance: The resistance levels are smoothed to create more consistent boundaries.
c. Midlines:
The indicator calculates "midlines" within the support and resistance zones. These help visualize the gradual transition between the upper and lower levels of the zones.
Midlines are plotted between the outer bands of the channels, giving a more nuanced view of the market's strength.
3. How It Visualizes the Zones:
a. Gradient Zones:
The indicator colors the space between the upper and lower boundaries of the support and resistance channels with gradient fills. These fills change color based on the price's proximity to the support or resistance zone, offering an immediate visual cue for traders.
Resistance Gradient: The closer the price is to the resistance zone, the more intense the red color becomes.
Support Gradient: Similarly, the closer the price is to the support zone, the greener the color becomes.
Extreme Zones: The outermost regions of the support and resistance zones (based on the highest and lowest levels) are also shaded differently to indicate extreme areas where the price might reverse with a higher probability.
b. Signals for Breakouts and Bounces:
Resistance Break: If the price crosses above the resistance upper boundary, a downward triangle symbol appears, signaling a potential breakout.
Support Break: If the price crosses below the support lower boundary, an upward triangle symbol appears, signaling a potential breakdown.
Bounce from Resistance/Support: If the price moves within the channel and bounces off the lower or upper boundary, it signals a rejection or bounce from support or resistance.
4. The Key Indicators:
Resistance Breakout: A signal that the price has broken above the resistance level, potentially indicating an upward trend.
Support Breakdown: A signal that the price has broken below the support level, potentially indicating a downward trend.
Resistance Rejection (Bounce): A price rejection at the resistance zone, signaling a potential reversal or continuation within the channel.
Support Bounce: A price rejection at the support zone, signaling a potential reversal or continuation within the channel.
5. Alerts and Notifications:
The indicator includes alert conditions for various events like:
Breakouts above resistance or below support.
Price bounces off support or resistance.
When these events occur, users can set alerts to notify them in real-time.
6. Customization:
Users can customize:
Lookback Period: How many bars the indicator should consider when calculating support and resistance levels.
Multipliers: Adjustments to the width of the channels (both for support and resistance).
Smoothing Period: The level of smoothing applied to the support and resistance zones to make the channels less volatile.
7. Summary of the Indicator's Key Features:
Dynamic, Adaptive Channels: The support and resistance zones adjust in real-time based on market volatility (ATR).
Smooth Transitions: Smooth, visual gradients help users understand the strength of the price action and potential reversal zones.
Real-Time Alerts: Users are notified when important price action events, such as breakouts or bounces, occur.
Customizable: Adjust the sensitivity of the support/resistance levels, channel width, and smoothing period based on personal preferences.
8. Use Case Example:
Imagine the price is near the upper resistance zone. If the price breaks above this level, it’s a Resistance Break signal, which could indicate the start of an upward trend. Conversely, if the price breaks below the lower support level, it’s a Support Breakdown signal, suggesting a potential downward trend.
Disclaimer:
The "Dynamic Support & Resistance Zones v2 | Adaptive Channel System" indicator is a tool designed to assist with technical analysis by identifying key support and resistance levels, as well as potential price action signals. While it is a powerful tool for trend analysis and trading decision-making, it is not a guaranteed predictor of market outcomes.
Risk Warning: Trading involves significant risk of loss, and the use of this indicator does not guarantee any specific results. It is recommended to combine the indicator with other forms of technical analysis, fundamental analysis, and risk management strategies.
Past Performance: The indicator's past performance is not indicative of future results. Market conditions are dynamic and constantly evolving, and past price action may not necessarily reflect future price behavior.
No Investment Advice: The indicator does not constitute financial or investment advice. Always perform your own research and consult with a professional financial advisor before making trading decisions.
Use at Your Own Risk: By using this indicator, you acknowledge that you are fully responsible for your trading decisions, and that you understand the potential risks involved.
AlgoFlex Buy Sell Signal (1h only)
**Overview**
AlgoFlex Scalper plots buy/sell signal markers using:
* a range filter (EMA of absolute bar changes) to define short-term bias,
* an Adaptive Moving Average (AMA) slope to confirm direction, and
* an ATR threshold to filter weak momentum.
Signals are evaluated on bar close to reduce intrabar noise. This is an indicator, not a strategy.
**How it works (concepts)**
* Range filter: smooths price with an EMA-based range measure and forms upper/lower bands.
* Trend state: counts consecutive movements of the filtered series (up/down counters) to avoid whipsaws.
* AMA + ATR gate: rising AMA with change > ATR \* atrMult can produce a long signal; falling AMA with change < -ATR \* atrMult can produce a short signal.
* TP/SL markers: projected using ATR multiples (tpMult, slMult). Visual guides only.
* Buy Signal, Sell Signal, plus optional TP/SL notifications. Designed to fire on bar close.
RVWAP % Distance Oscillator (30D vs 365D)RVWAP % Distance Oscillator (30D vs 365D)
Does what it says.
Goldbach Time IndicatorGoldbach Time Indicator (Minute Algebra + Core Levels)
A time-based discovery tool that maps minute arithmetic to a curated set of “Goldbach levels” (0–77) and highlights core reliable levels (29, 35, 71, 77) on any symbol/timeframe. It’s designed for session timing, event clustering, and pattern research—not price prediction.
What it shows
Three per-bar minute transforms:
Min = current minute (00–59)
Min+Hr = minute + hour (mapped, 60 → 00; valid up to 77)
Min−Hr = |minute − hour| (auto-chooses positive variant; 60 → 00)
Hit detection: marks a bar if any transform lands on an allowed Goldbach level.
Core emphasis: special tint/labels for 29, 35, 71, 77.
Optional background highlight (green for hits, blue tint when a core level is present).
Large corner readouts (optional): current Min / Min+Hr / Min−Hr with ✓ or ⭐ for core.
Detailed table: current time (your chosen timezone) + the three values and their status.
Histogram (optional): total hits and core hits under the chart.
Hover tooltips: per-bar time + which transforms hit (and whether they’re core).
Inputs & controls
Timezone Preset: UTC, New York, Tokyo, London, Sydney, or Custom UTC Offset.
Display toggles: Large number panels, Detailed table, Histogram, Horizontal reference lines.
Levels:
Standard set: 0,3,7,11,14,17,23,29,35,41,44,47,50,53,56,59,65,71,77
Core Only: show just 29, 35, 71, 77
Custom: paste your own comma-separated list (0–77)
Test Mode: assists with visual verification (e.g., consistent tooltips across all bars).
Core highlighting: stronger visual emphasis when a core level is hit.
How it helps
Session research: check if your strategy events cluster around certain minute signatures.
Timing filters: avoid entries during “no-hit” windows or focus on core hits.
Backtest guidance: the histogram and info panels make it easy to log/compare timing regimes.
Multi-market: independent of price scale—works for FX, indices, crypto, metals, single stocks.
Reading the visuals
Dots:
Yellow = Min, Lime = Min+Hr, Orange = Min−Hr, Blue = Core
Background:
Green = at least one hit, Blue tint = core level present
Tables/Panels: show current time (with timezone), raw values, and ✓/⭐ status.
Quick start
Choose your Timezone Preset (or set Custom UTC offset).
Start with Standard Levels; enable Core highlighting.
Turn on Detailed Table to confirm values match your venue/session.
(Optional) Show Histogram to see hit density; add Horizontal Lines for fixed references.
If needed, switch to Core Only or define Custom Levels to fit your hypothesis.
Notes & disclaimers
This is a time analytics overlay, not a buy/sell signal engine.
“Goldbach levels” here are a research framework (minute algebra 0–77) used for market-timing studies.
Always forward-test any timing rules with your strategy and risk plan.
Tags: timing, minute math, session research, clustering, core levels, UTC offset, macro timing, exploration
KING4R_swingGeneral
This script is called "KING4R_swing", designed to identify high-probability swing trading entries based on technical setups. It overlays the chart and uses conditions based on volume, EMAs, SPY index trend, and price structure.
Main Features
User Options:
Enable/disable SPY EMA conditions.
Show/hide checklist and final message.
Adjust label positions (vertical/horizontal).
Local EMAs:
Calculates 13-EMA and 48-EMA on the current symbol.
Flags whether EMA13 is above EMA48 and whether price is above EMA48.
Volume Spike Detection:
Searches for unusual volume spikes in the last 30 candles.
Then checks 60 candles after the spike for either:
Lateral movement (no new lows).
Higher lows (suggesting a change in structure).
Visual Tags:
When a volume spike is detected, it adds:
“📦 Post-volume Lateral” label if price goes sideways.
“📈 Structure Change” if higher lows are confirmed.
SPY Conditions:
Pulls EMAs from SPY on the daily timeframe.
Two optional conditions: EMA13 > EMA48 and EMA8 > EMA21.
Stopping Volume:
Checks if there's stopping volume in the last 30 candles (volume 1.5x above average).
Checklist + Scoring:
Assigns up to 6 points based on:
EMA13 > EMA48
Lateral structure after high volume
Price above EMA48
Stopping volume
SPY EMA13 > EMA48
SPY EMA8 > EMA21
Each condition adds 1 point.
Dynamic Labels:
Shows a red checklist, a final message with score, and a warning (“NO SETUP, NO TRADE”).
If score is 6/6, shows a 🚀 rocket icon above the bar.
Alert:
Triggers an alert when score = 6/6, indicating a possible high-probability entry.
ICT Advanced Entry Models ICT Advanced Entry Models & Market Analysis
A complete ICT-style execution suite that blends multi-timeframe structure, session logic, and 12 refined entry models into one confluence engine. Built for traders who want rule-based signals, transparent reasoning, and on-chart risk management.
What It Does
Detects market structure (BOS/CHoCH), swing failures, ranges, and premium/discount zones.
Tracks FVGs and Order Blocks with mitigation status and visual boxes.
Scores 12 ICT entry models and issues tiered alerts when confluence ≥ your threshold.
Adapts to market regime (trending vs ranging) and volatility to filter noise.
Shows risk:reward, dynamic stops/targets, and position size guidance per trade.
Logs rolling performance metrics (win rate, average R, max drawdown).
Adds a probability heatmap of high-interaction price zones.
Entry models included (toggle any on/off)
1- Optimal Trade Entry (OTE)
2- Silver Bullet (London/NY windows)
3- Unicorn Model (stop hunt → FVG/OB)
4- FVG Entry (mitigation & confluence aware)
5- Order Block Entry (mitigation-aware)
6- Breaker Block Entry
7- Stop Hunt Entry (volume/ATR-validated)
8- Liquidity Grab Entry (equal highs/lows)
9- Market Maker Model (accumulation/manipulation/distribution)
10- Power of 3 (session behavior + Asian range context)
11- Judas Swing
12- Asian Range Breakout
Confluence & filters
Weighted scoring per model (customizable weights).
MTF alignment: pick Higher TF for bias, Lower TF for trigger.
Regime & volatility gates (ADX/ATR derived).
Zone logic: premium/discount & extreme zones influence signals.
Session context: kill zones, macro times, Silver Bullet windows.
Visuals & overlays
BOS/CHoCH/SF labels.
OB/FVG boxes (solid when active, dashed when mitigated).
Daily/Weekly/Monthly key levels + Equilibrium line.
Asian High/Low and OTE 62–79% bands.
Market-regime background tint and probability heatmap lines.
Top-right Info Table shows bias, zone, regime, MTF alignment, active models, and performance stats.
Risk management (on-chart)
Dynamic structural/ATR stops and 3 staged targets (TP1/TP2/TP3).
Shows R:R, estimated position size from account size and risk %.
Alerts (tiered & specific)
High / Medium / Low Probability ICT Signal (based on confluence).
Model-specific: Unicorn, Silver Bullet, OTE.
Structure: Break of Structure, CHoCH, Swing Failure.
Regime and Volatility state changes.
(Create alerts via “Add Alert” → choose this indicator’s conditions.)
Inputs you’ll use most
Entry Models (enable all or cherry-pick).
Model Weights & Confluence Threshold.
MTF: Higher TF for bias, Lower TF for entries.
Risk: Account size, risk %, min R:R.
Sessions: Kill zones, macro times, DST adjust.
Structure: Lookback, show BOS/CHoCH/SF.
FVG: Minimum size, mitigation tracking, confluence zones.
Regime: Trend/volatility periods.
Performance: Tracking window.
How to use (quick start)
Select market & timeframe (commonly M5–H1 for execution; set HTF to H4/D for bias).
Enable your preferred models and set weights.
Keep Confluence Threshold modest (e.g., 3.0–4.5) and raise it in choppy periods.
Only act when MTF alignment agrees with market regime, and R:R meets your minimum.
Manage trades using the suggested structural/ATR stop and staged TPs.
Notes
Designed for liquid FX, indices, metals, and crypto.
Not a promise of future performance—use with prudent risk and forward test first.
Session times are exchange-agnostic; adjust DST toggle if your venue differs.
Tags: ICT, Smart Money Concepts, FVG, Order Block, BOS, CHoCH, Silver Bullet, OTE, Liquidity, MTF, Confluence, Risk Management, Algorithmic, Session Killzones, Market Regime.
FMF15
The Traders Trend Dashboard (FMF15) is a comprehensive trend analysis tool designed to assist traders in making informed trading decisions across various markets and timeframes. Unlike conventional trend-following scripts,FMF15 goes beyond simple trend detection by incorporating
VT – Dashboard05🚀 Overview
VT – Dashboard05 is a multi-timeframe market state dashboard for Forex and other liquid markets. It summarizes Trend, RSI state, RSM, and ICT structure (BOS/MSS) across H1 / M30 / M15 / M5 / M1 in one compact table—plus clean rejection markers (“S” at the top, “B” at the bottom) controlled entirely from the Style tab. All higher-timeframe values are computed without lookahead and only confirm on their candle close.
✨ Key Features
5-TF Dashboard (H1, M30, M15, M5, M1) — Columns for TREND / RSI / RSM / ICT, color-coded for quick reads.
EMA-Stack Trend — Fast/Mid/Slow EMA alignment for Up / Sideways / Down bias.
RSI & RSM States — OB/OS plus RSI vs RSM momentum (RYB / RLLT).
ICT Structure (BOS / MSS) — Choose Close Break or Body Break; signals confirm only on TF close.
Rejection Markers (Style-only) — “S” at top, “B” at bottom; change colors/visibility in Style (no Inputs clutter).
Alerts — State-change alerts for TREND, RSI, RSM, ICT on each TF, plus rejection alerts on the chart TF.
No repaint tricks — HTF data pulled with gaps filled, lookahead off, confirmation on close.
🛠 How to Use
Add to chart → set Dashboard Position (Inputs).
Pick ICT Break Method (Close Break or Body Break).
Tune Structure Swing Length for H1/M30/M15/M5/M1.
(Optional) Toggle EMA1–EMA4 overlays for context.
Style the markers in Settings → Style:
Rejection (Top) → “S” at top (color/visibility here).
Rejection (Bottom) → “B” at bottom (color/visibility here).
Create alerts using built-in conditions (e.g., ICT change H1, TREND change M15, Rejection Bullish (chart TF)).
⚙️ Settings
Dashboard: Dashboard Position, Compact Mode.
Trend: EMA Fast / Mid / Slow Lengths.
RSI: RSI Length, OB/OS Levels.
RSM: RSM RSI Length, RSM EMA Length.
ICT Structure: ICT Break Method (Close vs Body), Structure Swing Length per TF (H1/M30/M15/M5/M1).
EMAs on Chart: EMA1–EMA4 lengths & show/hide.
Style Tab: Rejection (Top) and Rejection (Bottom) series for color/visibility.
📈 Trading Concepts
TREND: EMA stacking—aligned = UP, mixed = SW, bearish stack = DOWN.
RSI: OB > overbought, OS < oversold, else SW.
RSM: RYB when Uptrend, RLLT when Downtrend.
ICT (BOS/MSS):
BOS↑/BOS↓ = break of last swing high/low.
MSS↑/MSS↓ = break against the prior BOS direction (structure shift).
Signals are evaluated with Close Break or Body Break and confirm only on TF close.
Rejection: Bar-based reversal patterns—“S” marks bearish rejection (top), “B” marks bullish rejection (bottom).
Note: This is a technical analysis tool. Always practice proper risk management and combine with other analysis techniques for best results.
Category: Multi-Timeframe / Dashboard / Structure
Version: 1.0
Developer: VT
HSM MACROS//@version=5
indicator('HSM MACROS', 'HSM MACROS', overlay=true, max_bars_back=500, explicit_plot_zorder=true)
import boitoki/AwesomeColor/4 as ac
import boitoki/Utilities/3 as util
///////////////
// Groups
///////////////
g0 = 'GENERAL'
g1_01 = '♯1 SESSION'
g1_02 = '♯2 SESSION'
g1_03 = '♯3 SESSION'
g1_04 = '♯4 SESSION'
g4 = 'BOX'
g6 = 'LABELS'
g5 = 'OPENING RANGE'
g7 = 'FIBONACCI LEVELS'
g8 = 'OPTIONS'
g11 = 'CANDLE'
g10 = 'Alerts visualized'
///////////////
// Defined
///////////////
max_bars = 500
option_yes = 'Yes'
option_no = '× No'
option_extend1 = 'Yes'
option_hide = '× Hide'
option_border_style1 = '────'
option_border_style2 = '- - - - - -'
option_border_style3 = '•••••••••'
option_chart_x = '× No'
option_chart_1 = 'Bar color'
option_chart_2 = 'Candles'
fmt_price = '{0,number,#.#####}'
fmt_pips = '{0,number,#.#}'
icon_separator = ' • '
color_none = color.new(color.black, 100)
color_text = color.new(color.white, 0)
///////////////
// Functions
///////////////
f_get_time_by_bar(bar_count) => timeframe.multiplier * bar_count * 60 * 1000
f_border_style (_style) =>
switch _style
option_border_style1 => line.style_solid
option_border_style2 => line.style_dashed
option_border_style3 => line.style_dotted
=> _style
f_get_period (_session, _start, _lookback) =>
result = math.max(_start, 1)
for i = result to _lookback
if na(_session ) and _session
result := i+1
break
result
f_get_label_position (_y, _side) =>
switch _y
'top' => _side == 'outside' ? label.style_label_lower_left : label.style_label_upper_left
'bottom' => _side == 'outside' ? label.style_label_upper_left : label.style_label_lower_left
f_get_started (_session) => na(_session ) and _session
f_get_ended (_session) => na(_session) and _session
f_message_limit_bars (_v) => '⚠️ This box\'s right position exceeds 500 bars(' + str.tostring(_v) + '). This box is not displayed correctly.'
f_set_line_x1 (_line, _x) =>
if (line.get_x1(_line) != _x)
line.set_x1(_line, _x)
f_set_line_x2 (_line, _x) =>
if (line.get_x2(_line) != _x)
line.set_x2(_line, _x)
f_set_box_right (_box, _x) =>
if box.get_right(_box) != _x
box.set_right(_box, _x)
///////////////
// Inputs
///////////////
// Timezone
i_tz = input.string('GMT-4', title='Timezone', options= , tooltip='e.g. \'America/New_York\', \'Asia/Tokyo\', \'GMT-4\', \'GMT+9\'...', group=g0)
i_history_period = input.int(10, 'History', minval=0, group=g0)
i_show = i_history_period > 0
i_lookback = 12 * 60
// Sessions
i_show_sess1 = input.bool(true, 'Session 1 ', group=g1_01, inline='session1_1') and i_show
i_sess1_label = input.string('MC1', '', group=g1_01, inline='session1_1')
i_sess1_color = input.color(#0a0a0a, '', group=g1_01, inline='session1_1')
i_sess1_barcolor1 = input.color(#0a0a0a, '•', group=g1_01, inline='session1_1')
i_sess1_barcolor2 = input.color(#0a0a0a, '', group=g1_01, inline='session1_1')
i_sess1 = input.session('0820-0830', 'Time', group=g1_01)
i_sess1_extend = input.string(option_no, 'Extend', options= , group=g1_01)
i_sess1_fib = input.string(option_no, 'Fibonacci levels', group=g1_01, options= ) != option_no
i_sess1_op = input.string(option_no, 'Opening range', group=g1_01, options= ) != option_no and i_show
i_sess1_chart = input.string(option_chart_x, 'Bar', options= , group=g1_01)
i_sess1_barcolor = i_sess1_chart == option_chart_1
i_sess1_plotcandle = i_sess1_chart == option_chart_2
i_show_sess2 = input.bool(true, 'Session 2 ', group=g1_02, inline='session2_1') and i_show
i_sess2_label = input.string('MC2', '', group=g1_02, inline='session2_1')
i_sess2_color = input.color(#0a0a0a, '', group=g1_02, inline='session2_1')
i_sess2_barcolor1 = input.color(#0a0a0a, '•', group=g1_02, inline='session2_1')
i_sess2_barcolor2 = input.color(#0a0a0a, '', group=g1_02, inline='session2_1')
i_sess2 = input.session('0920-0930', 'Time', group=g1_02)
i_sess2_extend = input.string(option_no, 'Extend', options= , group=g1_02)
i_sess2_fib = input.string(option_no, 'Fibonacci levels', group=g1_02, options= ) != option_no
i_sess2_op = input.string(option_no, 'Opening range', group=g1_02, options= ) != option_no and i_show
i_sess2_chart = input.string(option_chart_x, 'Bar', options= , group=g1_02)
i_sess2_barcolor = i_sess2_chart == option_chart_1
i_sess2_plotcandle = i_sess2_chart == option_chart_2
i_show_sess3 = input.bool(true, 'Session 3 ', group=g1_03, inline='session3_1') and i_show
i_sess3_label = input.string('MC3', '', group=g1_03, inline='session3_1')
i_sess3_color = input.color(#0a0a0a, '', group=g1_03, inline='session3_1')
i_sess3_barcolor1 = input.color(#0a0a0a, '•', group=g1_03, inline='session3_1')
i_sess3_barcolor2 = input.color(#0a0a0a, '', group=g1_03, inline='session3_1')
i_sess3 = input.session('0950-1010', 'Time', group=g1_03)
i_sess3_extend = input.string(option_no, 'Extend', options= , group=g1_03)
i_sess3_fib = input.string(option_no, 'Fibonacci levels', group=g1_03, options= ) != option_no
i_sess3_op = input.string(option_no, 'Opening range', group=g1_03, options= ) != option_no and i_show
i_sess3_chart = input.string(option_chart_x, 'Bar', options= , group=g1_03)
i_sess3_barcolor = i_sess3_chart == option_chart_1
i_sess3_plotcandle = i_sess3_chart == option_chart_2
i_show_sess4 = input.bool(true, 'Session 4 ', group=g1_04, inline='session4_1') and i_show
i_sess4_label = input.string('MC4', '', group=g1_04, inline='session4_1')
i_sess4_color = input.color(#0a0a0a, '', group=g1_04, inline='session4_1')
i_sess4_barcolor1 = input.color(#0a0a0a, '•', group=g1_04, inline='session4_1')
i_sess4_barcolor2 = input.color(#0a0a0a, '', group=g1_04, inline='session4_1')
i_sess4 = input.session('1050-1110', 'Time', group=g1_04)
i_sess4_extend = input.string(option_no, 'Extend', options= , group=g1_04)
i_sess4_fib = input.string(option_no, 'Fibonacci levels', group=g1_04, options= ) != option_no
i_sess4_op = input.string(option_no, 'Opening range', group=g1_04, options= ) != option_no and i_show
i_sess4_chart = input.string(option_chart_x, 'Bar', options= , group=g1_04)
i_sess4_barcolor = i_sess4_chart == option_chart_1
i_sess4_plotcandle = i_sess4_chart == option_chart_2
// Show & Styles
i_sess_box_style = input.string('Box', 'Style', options= , group=g4)
i_sess_border_style = f_border_style(input.string(option_border_style2, 'Line style', options= , group=g4))
i_sess_border_width = input.int(1, 'Thickness', minval=0, group=g4)
i_sess_bgopacity = input.int(94, 'Transp', minval=0, maxval=100, step=1, group=g4, tooltip='Setting the 100 is no background color')
// Candle
option_candle_body = 'OC'
option_candle_wick = 'OHLC'
i_candle = input.string(option_hide, 'Display', options= , group=g11)
i_candle_border_width = input.int(2, 'Thickness', minval=0, group=g11)
i_show_candle = (i_candle != option_hide) and (i_candle_border_width > 0)
i_show_candle_wick = i_candle == option_candle_wick
option_candle_color1 = 'Session\'s'
option_candle_color2 = 'Red • Green'
i_candle_color = input.string(option_candle_color2, 'Color ', options= , group=g11, inline='candle_color')
i_candle_color_g = input.color(#A6E22E, '', group=g11, inline='candle_color')
i_candle_color_r = input.color(#F92672, '', group=g11, inline='candle_color')
// Labels
i_label_show = input.bool(true, 'Labels', inline='label_show', group=g6) and i_show
i_label_size = str.lower(input.string('Small', '', options= , inline='label_show', group=g6))
i_label_position_y = str.lower(input.string('Top', '', options= , inline='label_show', group=g6))
i_label_position_s = str.lower(input.string('Outside', '', options= , inline='label_show', group=g6))
i_label_position = f_get_label_position(i_label_position_y, i_label_position_s)
i_label_format_name = input.bool(true, 'Name', inline='label_format', group=g6)
i_label_format_day = input.bool(false, 'Day', inline='label_format', group=g6)
i_label_format_price = input.bool(false, 'Price', inline='label_format', group=g6)
i_label_format_pips = input.bool(false, 'Pips', inline='label_format', group=g6)
// Fibonacci levels
i_f_linestyle = f_border_style(input.string(option_border_style1, title="Style", options= , group=g7))
i_f_linewidth = input.int(1, title="Thickness", minval=1, group=g7)
// Opening range
i_o_minutes = input.int(15, title='Periods (minutes)', minval=1, step=1, group=g5)
i_o_minutes := math.max(i_o_minutes, timeframe.multiplier + 1)
i_o_transp = input.int(88, title='Transp', minval=0, maxval=100, step=1, group=g5)
// Alerts
i_alert1_show = input.bool(false, 'Alerts - Sessions stard/end', group=g10)
i_alert2_show = input.bool(false, 'Alerts - Opening range breakouts', group=g10)
i_alert3_show = input.bool(false, 'Alerts - Price crossed session\'s High/Low after session closed', group=g10)
// ------------------------
// Drawing labels
// ------------------------
f_render_label (_show, _session, _is_started, _color, _top, _bottom, _text, _labels) =>
var label my_label = na
var int start_time = na
v_position_y = (i_label_position_y == 'top') ? _top : _bottom
v_label = array.new_string()
v_chg = _top - _bottom
if _is_started
start_time := time
if i_label_format_name and not na(_text)
array.push(v_label, _text)
if i_label_format_day
array.push(v_label, util.get_day(dayofweek(start_time, i_tz)))
if i_label_format_price
array.push(v_label, str.format(fmt_price, v_chg))
if i_label_format_pips
array.push(v_label, str.format(fmt_pips, util.toPips(v_chg)) + ' pips')
if _show
if _is_started
my_label := label.new(bar_index, v_position_y, array.join(v_label, icon_separator), textcolor=_color, color=color_none, size=i_label_size, style=i_label_position)
array.push(_labels, my_label)
util.clear_labels(_labels, i_history_period)
else if _session
label.set_y(my_label, v_position_y)
label.set_text(my_label, array.join(v_label, icon_separator))
// ------------------------
// Drawing Fibonacci levels
// ------------------------
f_render_fibonacci (_show, _session, _is_started, _x1, _x2, _color, _top, _bottom, _level, _width, _style, _is_extend, _lines) =>
var line my_line = na
if _show
y = (_top - _bottom) * _level + _bottom
if _is_started
my_line := line.new(_x1, y, _x2, y, width=_width, color=color.new(_color, 30), style=_style)
array.push(_lines, my_line)
if _is_extend
line.set_extend(my_line, extend.right)
else if _session
line.set_y1(my_line, y)
line.set_y2(my_line, y)
f_set_line_x2(my_line, _x2)
// ------------------------
// Drawing Opening range
// ------------------------
f_render_oprange (_show, _session, _is_started, _x1, _x2, _color, _max, _is_extend, _boxes) =>
var int start_time = na
var box my_box = na
top = ta.highest(high, _max)
bottom = ta.lowest(low, _max)
is_crossover = ta.crossover(close, box.get_top(my_box))
is_crossunder = ta.crossunder(close, box.get_bottom(my_box))
if _show
if _is_started
util.clear_boxes(_boxes, math.max(0, i_history_period - 1))
start_time := time
my_box := na
else if _session
time_op = start_time + (i_o_minutes * 60 * 1000)
time_op_delay = time_op - f_get_time_by_bar(1)
if time <= time_op and time > time_op_delay
my_box := box.new(_x1, top, _x2, bottom, border_width=0, bgcolor=color.new(_color, i_o_transp))
array.push(_boxes, my_box)
if _is_extend
box.set_extend(my_box, extend.right)
my_box
else
f_set_box_right(my_box, _x2)
if is_crossover
alert('Price crossed over the opening range', alert.freq_once_per_bar)
if i_alert2_show
label.new(bar_index, box.get_top(my_box), "×", color=color.blue, textcolor=ac.tradingview('blue'), style=label.style_none, size=size.large)
if is_crossunder
alert('Price crossed under the opening range', alert.freq_once_per_bar)
if i_alert2_show
label.new(bar_index, box.get_bottom(my_box), "×", color=color.red, textcolor=ac.tradingview('red'), style=label.style_none, size=size.large)
my_box
// ------------------------
// Drawing candle
// ------------------------
f_render_candle (_show, _session, _is_started, _is_ended, _color, _top, _bottom, _open, _x1, _x2, _boxes, _lines) =>
var box body = na
var line wick1 = na
var line wick2 = na
border_width = i_candle_border_width
cx = math.round(math.avg(_x2, _x1)) - math.round(border_width / 2)
body_color = i_candle_color == option_candle_color2 ? close > _open ? i_candle_color_g : i_candle_color_r : _color
if _show
if _is_started
body := box.new(_x1, _top, _x2, _bottom, body_color, border_width, line.style_solid, bgcolor=color.new(color.black, 100))
wick1 := i_show_candle_wick ? line.new(cx, _top, cx, _top, color=_color, width=border_width, style=line.style_solid) : na
wick2 := i_show_candle_wick ? line.new(cx, _bottom, cx, _bottom, color=_color, width=border_width, style=line.style_solid) : na
array.push(_boxes, body)
array.push(_lines, wick1)
array.push(_lines, wick2)
util.clear_boxes(_boxes, i_history_period)
util.clear_lines(_lines, i_history_period * 2)
else if _session
top = math.max(_open, close)
bottom = math.min(_open, close)
box.set_top(body, top)
box.set_bottom(body, bottom)
box.set_right(body, _x2)
box.set_border_color(body, body_color)
line.set_y1(wick1, _top)
line.set_y2(wick1, top)
f_set_line_x1(wick1, cx)
f_set_line_x2(wick1, cx)
line.set_color(wick1, body_color)
line.set_y1(wick2, _bottom)
line.set_y2(wick2, bottom)
f_set_line_x1(wick2, cx)
f_set_line_x2(wick2, cx)
line.set_color(wick2, body_color)
else if _is_ended
box.set_right(body, bar_index)
// ------------------------
// Rendering limit message
// ------------------------
f_render_limitmessage (_show, _session, _is_started, _is_ended, _x, _y, _rightbars) =>
var label my_note = na
if _show
if _is_started
if _rightbars > max_bars
my_note := label.new(_x, _y, f_message_limit_bars(_rightbars), style=label.style_label_upper_left, color=color.yellow, textalign=text.align_left, yloc=yloc.price)
else if _session
if _rightbars > max_bars
label.set_y(my_note, _y)
label.set_text(my_note, f_message_limit_bars(_rightbars))
else
label.delete(my_note)
else if _is_ended
label.delete(my_note)
true
// Rendering session
//
f_render_sessionrange (_show, _session, _is_started, _is_ended, _color, _top, _bottom, _x1, _x2, _is_extend, _lines) =>
var line above_line = na
var line below_line = na
if _show
if _is_started
above_line := line.new(_x1, _top, _x2, _top, width=i_sess_border_width, style=i_sess_border_style, color=_color)
below_line := line.new(_x1, _bottom, _x2, _bottom, width=i_sess_border_width, style=i_sess_border_style, color=_color)
linefill.new(above_line, below_line, color.new(_color, i_sess_bgopacity))
array.push(_lines, above_line)
array.push(_lines, below_line)
util.clear_lines(_lines, i_history_period * 2)
if _is_extend
line.set_extend(above_line, extend.right)
line.set_extend(below_line, extend.right)
else if _session
line.set_y1(above_line, _top)
line.set_y2(above_line, _top)
line.set_x2(above_line, _x2)
line.set_y1(below_line, _bottom)
line.set_y2(below_line, _bottom)
line.set_x2(below_line, _x2)
true
else if _is_ended
true
true
// ------------------------
// Rendering session box
// ------------------------
f_render_session (_show, _session, _is_started, _is_ended, _color, _top, _bottom, _x1, _x2, _is_extend, _boxes) =>
var box my_box = na
if _show
if _is_started
my_box := box.new(_x1, _top, _x2, _bottom, _color, i_sess_border_width, i_sess_border_style, bgcolor=color.new(_color, i_sess_bgopacity))
array.push(_boxes, my_box)
util.clear_boxes(_boxes, i_history_period)
if _is_extend
box.set_extend(my_box, extend.right)
else if _session
box.set_top(my_box, _top)
box.set_bottom(my_box, _bottom)
f_set_box_right(my_box, _x2)
else if _is_ended
box.set_right(my_box, bar_index)
my_box
// ------------------------
// Drawing market
// ------------------------
f_render_main (_show, _session, _is_started, _is_ended, _color, _top, _bottom) =>
var box my_box = na
var label my_note = na
var x1 = 0
var x2 = 0
var session_open = 0.0
var session_high = 0.0
var session_low = 0.0
x0_1 = ta.valuewhen(na(_session ) and _session, bar_index, 1)
x0_2 = ta.valuewhen(na(_session) and _session , bar_index, 0)
x0_d = math.abs(x0_2 - x0_1)
limit_bars = max_bars
rightbars = x0_d
if _show
if _is_started
x1 := bar_index
x2 := bar_index + (math.min(x0_d, limit_bars))
session_open := open
session_high := _top
session_low := _bottom
else if _session
true_x2 = x1 + x0_d
rightbars := true_x2 - bar_index
limit_bars := bar_index + max_bars
x2 := math.min(true_x2, limit_bars)
session_high := _top
session_low := _bottom
else if _is_ended
session_open := na
// ------------------------
// Drawing
// ------------------------
draw (_show, _session, _color, _label, _extend, _show_fib, _show_op, _lookback, _boxes_session, _lines_session, _boxes_candle_body, _lines_candle_wick, _boxes_op, _lines_fib, _labels) =>
max = f_get_period(_session, 1, _lookback)
top = ta.highest(high, max)
bottom = ta.lowest(low, max)
is_started = f_get_started(_session)
is_ended = f_get_ended(_session)
is_extend = _extend != option_no
= f_render_main(_show, _session, is_started, is_ended, _color, top, bottom)
if i_sess_box_style == 'Box'
f_render_session(_show, _session, is_started, is_ended, _color, top, bottom, x1, x2, is_extend, _boxes_session)
if i_sess_box_style == 'Sandwich'
f_render_sessionrange(_show, _session, is_started, is_ended, _color, top, bottom, x1, x2, is_extend, _lines_session)
if i_show_candle
f_render_candle(_show, _session, is_started, is_ended, _color, top, bottom, _open, x1, x2, _boxes_candle_body, _lines_candle_wick)
if i_label_show
f_render_label(_show, _session, is_started, _color, top, bottom, _label, _labels)
if _show_op
f_render_oprange(_show, _session, is_started, x1, x2, _color, max, is_extend, _boxes_op)
if _show_fib
f_render_fibonacci(_show, _session, is_started, x1, x2, _color, top, bottom, 0.500, 2, line.style_solid, is_extend, _lines_fib)
f_render_fibonacci(_show, _session, is_started, x1, x2, _color, top, bottom, 0.628, i_f_linewidth, i_f_linestyle, is_extend, _lines_fib)
f_render_fibonacci(_show, _session, is_started, x1, x2, _color, top, bottom, 0.382, i_f_linewidth, i_f_linestyle, is_extend, _lines_fib)
util.clear_lines(_lines_fib, i_history_period * 3)
f_render_limitmessage(_show, _session, is_started, is_ended, x1, bottom, _rightbars)
///////////////////
// Calculating
///////////////////
string tz = (i_tz == option_no or i_tz == '') ? na : i_tz
int sess1 = time(timeframe.period, i_sess1, tz)
int sess2 = time(timeframe.period, i_sess2, tz)
int sess3 = time(timeframe.period, i_sess3, tz)
int sess4 = time(timeframe.period, i_sess4, tz)
///////////////////
// Plotting
///////////////////
var sess1_box = array.new()
var sess2_box = array.new()
var sess3_box = array.new()
var sess4_box = array.new()
var sess1_line = array.new()
var sess2_line = array.new()
var sess3_line = array.new()
var sess4_line = array.new()
var sess1_op = array.new()
var sess2_op = array.new()
var sess3_op = array.new()
var sess4_op = array.new()
var sess1_fib = array.new()
var sess2_fib = array.new()
var sess3_fib = array.new()
var sess4_fib = array.new()
var sess1_candle_body = array.new()
var sess2_candle_body = array.new()
var sess3_candle_body = array.new()
var sess4_candle_body = array.new()
var sess1_candle_wick = array.new()
var sess2_candle_wick = array.new()
var sess3_candle_wick = array.new()
var sess4_candle_wick = array.new()
var sess1_labels = array.new()
var sess2_labels = array.new()
var sess3_labels = array.new()
var sess4_labels = array.new()
= draw(i_show_sess1, sess1, i_sess1_color, i_sess1_label, i_sess1_extend, i_sess1_fib, i_sess1_op, i_lookback, sess1_box, sess1_line, sess1_candle_body, sess1_candle_wick, sess1_op, sess1_fib, sess1_labels)
= draw(i_show_sess2, sess2, i_sess2_color, i_sess2_label, i_sess2_extend, i_sess2_fib, i_sess2_op, i_lookback, sess2_box, sess2_line, sess2_candle_body, sess2_candle_wick, sess2_op, sess2_fib, sess2_labels)
= draw(i_show_sess3, sess3, i_sess3_color, i_sess3_label, i_sess3_extend, i_sess3_fib, i_sess3_op, i_lookback, sess3_box, sess3_line, sess3_candle_body, sess3_candle_wick, sess3_op, sess3_fib, sess3_labels)
= draw(i_show_sess4, sess4, i_sess4_color, i_sess4_label, i_sess4_extend, i_sess4_fib, i_sess4_op, i_lookback, sess4_box, sess4_line, sess4_candle_body, sess4_candle_wick, sess4_op, sess4_fib, sess4_labels)
is_positive_bar = close > open
color c_barcolor = na
color c_plotcandle = na
c_sess1_barcolor = (is_sess1) ? (is_positive_bar ? i_sess1_barcolor1 : i_sess1_barcolor2) : na
c_sess2_barcolor = (is_sess2) ? (is_positive_bar ? i_sess2_barcolor1 : i_sess2_barcolor2) : na
c_sess3_barcolor = (is_sess3) ? (is_positive_bar ? i_sess3_barcolor1 : i_sess3_barcolor2) : na
c_sess4_barcolor = (is_sess4) ? (is_positive_bar ? i_sess4_barcolor1 : i_sess4_barcolor2) : na
if (i_sess1_chart != option_chart_x) and is_sess1
c_barcolor := i_sess1_barcolor ? c_sess1_barcolor : na
c_plotcandle := i_sess1_plotcandle ? c_sess1_barcolor : na
if (i_sess2_chart != option_chart_x) and is_sess2
c_barcolor := i_sess2_barcolor ? c_sess2_barcolor : na
c_plotcandle := i_sess2_plotcandle ? c_sess2_barcolor : na
if (i_sess3_chart != option_chart_x) and is_sess3
c_barcolor := i_sess3_barcolor ? c_sess3_barcolor : na
c_plotcandle := i_sess3_plotcandle ? c_sess3_barcolor : na
if (i_sess4_chart != option_chart_x) and is_sess4
c_barcolor := i_sess4_barcolor ? c_sess4_barcolor : na
c_plotcandle := i_sess4_plotcandle ? c_sess4_barcolor : na
barcolor(c_barcolor)
plotcandle(open, high, low, close, color=is_positive_bar ? color_none : c_plotcandle, bordercolor=c_plotcandle, wickcolor=c_plotcandle)
////////////////////
// Alerts
////////////////////
// Session alerts
sess1_started = is_sess1 and not is_sess1 , sess1_ended = not is_sess1 and is_sess1
sess2_started = is_sess2 and not is_sess2 , sess2_ended = not is_sess2 and is_sess2
sess3_started = is_sess3 and not is_sess3 , sess3_ended = not is_sess3 and is_sess3
sess4_started = is_sess4 and not is_sess4 , sess4_ended = not is_sess4 and is_sess4
alertcondition(sess1_started, 'Session #1 started')
alertcondition(sess1_ended, 'Session #1 ended')
alertcondition(sess2_started, 'Session #2 started')
alertcondition(sess2_ended, 'Session #2 ended')
alertcondition(sess3_started, 'Session #3 started')
alertcondition(sess3_ended, 'Session #3 ended')
alertcondition(sess4_started, 'Session #4 started')
alertcondition(sess4_ended, 'Session #4 ended')
alertcondition((not is_sess1) and ta.crossover(close, sess1_high), 'Session #1 High crossed (after session closed)')
alertcondition((not is_sess1) and ta.crossunder(close, sess1_low), 'Session #1 Low crossed (after session closed)')
alertcondition((not is_sess2) and ta.crossover(close, sess2_high), 'Session #2 High crossed (after session closed)')
alertcondition((not is_sess2) and ta.crossunder(close, sess2_low), 'Session #2 Low crossed (after session closed)')
alertcondition((not is_sess3) and ta.crossover(close, sess3_high), 'Session #3 High crossed (after session closed)')
alertcondition((not is_sess3) and ta.crossunder(close, sess3_low), 'Session #3 Low crossed (after session closed)')
alertcondition((not is_sess4) and ta.crossover(close, sess4_high), 'Session #4 High crossed (after session closed)')
alertcondition((not is_sess4) and ta.crossunder(close, sess4_low), 'Session #4 Low crossed (after session closed)')
// Alerts visualized
if i_alert1_show
if i_show_sess1
if sess1_started
label.new(bar_index, close, 'Start', yloc=yloc.abovebar, color=i_sess1_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if sess1_ended
label.new(bar_index, close, 'End' , yloc=yloc.abovebar, color=i_sess1_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if i_show_sess2
if sess2_started
label.new(bar_index, close, 'Start', yloc=yloc.abovebar, color=i_sess2_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if sess2_ended
label.new(bar_index, close, 'End' , yloc=yloc.abovebar, color=i_sess2_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if i_show_sess3
if sess3_started
label.new(bar_index, close, 'Start', yloc=yloc.abovebar, color=i_sess3_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if sess3_ended
label.new(bar_index, close, 'End' , yloc=yloc.abovebar, color=i_sess3_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if i_show_sess4
if sess4_started
label.new(bar_index, close, 'Start', yloc=yloc.abovebar, color=i_sess4_color, textcolor=color_text, size=size.small, style=label.style_label_down)
if sess4_ended
label.new(bar_index, close, 'End' , yloc=yloc.abovebar, color=i_sess4_color, textcolor=color_text, size=size.small, style=label.style_label_down)
plot(i_alert3_show ? sess1_high : na, 'sess1_high', style=plot.style_linebr, color=i_sess1_color)
plot(i_alert3_show ? sess1_low : na, 'sess1_low' , style=plot.style_linebr, color=i_sess1_color, linewidth=2)
plot(i_alert3_show ? sess2_high : na, 'sess2_high', style=plot.style_linebr, color=i_sess2_color)
plot(i_alert3_show ? sess2_low : na, 'sess2_low' , style=plot.style_linebr, color=i_sess2_color, linewidth=2)
plot(i_alert3_show ? sess3_high : na, 'sess3_high', style=plot.style_linebr, color=i_sess3_color)
plot(i_alert3_show ? sess3_low : na, 'sess3_low' , style=plot.style_linebr, color=i_sess3_color, linewidth=2)
plot(i_alert3_show ? sess4_high : na, 'sess4_high', style=plot.style_linebr, color=i_sess4_color)
plot(i_alert3_show ? sess4_low : na, 'sess4_low' , style=plot.style_linebr, color=i_sess4_color, linewidth=2)
plotshape(i_alert3_show and (not is_sess1) and ta.crossover(close, sess1_high) ? sess1_high : na, 'cross sess1_high', color=i_sess1_color, style=shape.triangleup, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess1) and ta.crossunder(close, sess1_low) ? sess1_low : na, 'cross sess1_low', color=i_sess1_color, style=shape.triangledown, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess2) and ta.crossover(close, sess2_high) ? sess2_high : na, 'cross sess2_high', color=i_sess2_color, style=shape.triangleup, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess2) and ta.crossunder(close, sess2_low) ? sess2_low : na, 'cross sess2_low', color=i_sess2_color, style=shape.triangledown, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess3) and ta.crossover(close, sess3_high) ? sess3_high : na, 'cross sess3_high', color=i_sess3_color, style=shape.triangleup, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess3) and ta.crossunder(close, sess3_low) ? sess3_low : na, 'cross sess3_low', color=i_sess3_color, style=shape.triangledown, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess4) and ta.crossover(close, sess4_high) ? sess4_high : na, 'cross sess4_high', color=i_sess4_color, style=shape.triangleup, location=location.absolute, size=size.tiny)
plotshape(i_alert3_show and (not is_sess4) and ta.crossunder(close, sess4_low) ? sess4_low : na, 'cross sess4_low', color=i_sess4_color, style=shape.triangledown, location=location.absolute, size=size.tiny)
MACD_V5 with Divergence
MACD_V5 with Divergence is an EMA-based Bull/Bear Power oscillator. It computes
BBP = (high − EMA(close, Length)) + (low − EMA(close, Length)), plots BBP as columns with a zero line, and overlays a slope-colored BBP moving average. The script flags fresh Overbought/Oversold extremes within a rolling window and draws dashed levels, and it detects Regular and Hidden divergences using confirmed pivots (non-repainting after confirmation; appears with an lbR-bar delay).
Built-in alerts fire on OB/OS prints and on BBP ↔ BBP-MA crosses (use “Any alert() function call”).
How to use
• Treat crosses as triggers and divergence as confirmation.
• Always read signals in the context of the higher-timeframe or a price-based trend filter (e.g., EMA on price).
• Backtest and paper trade before going live.
Inputs: EMA Length, Highest/Lowest Period, Overbought/Oversold levels, BBP MA Length.
Works on any symbol and timeframe.
EMA-based Bull/Bear Power oscillator (BBP) with slope-colored MA. Marks fresh OB/OS extremes and detects Regular/Hidden divergences via confirmed pivots (no repaint after confirmation; lbR delay). Alerts on OB/OS and BBP ↔ MA cross. Use crosses to trigger, divergences to confirm, and trend context to filter. Inputs: Length, Period, OB/OS, MA Length.
EMA-based BBPower oscillator with OB/OS extremes, slope MA, and regular/hidden divergence. Alerts on OB/OS and BBP↔MA cross. Use crosses to trigger, divergences to confirm. Pivot signals show after lbR delay.
Initial public release
EMA-based BBP with slope-colored MA
OB/OS extreme labels + dashed levels
Regular & Hidden divergence (confirmed pivots; non-repainting after confirm)
Built-in alerts for OB/OS and BBP↔MA cross
Signifikante HochsThis indicator was created to highlight significant highs in the price chart. It is intentionally kept simple and lightweight, since its primary purpose is to serve as a test and learning tool for exploring the functions of the TradingView platform.
How it works:
A user-defined lookback period is applied to check whether a local high has been formed.
A minimum percentage change threshold is used as an additional filter, so that only highs with a certain level of significance are marked.
Once such a high is detected, a visual marker is plotted above the corresponding candle.
The main goal of this script is not to provide a complete trading strategy, but rather to help users understand the basic elements of Pine Script, chart visualization, and platform workflows. In particular, this script is a practical way to test and demonstrate:
The use of input parameters.
Core functions such as ta.pivothigh.
Conditional checks for price significance.
Simple plotting of signals directly on the chart.
At the same time, this test indicator can serve as a foundation for further development. The logic can easily be extended to:
Display significant lows as well as highs.
Draw connecting trendlines between pivots.
Generate alerts whenever a new significant high appears.
Incorporate multi-timeframe logic for deeper analysis.
Important note:
This script is not intended to be a full trading strategy in its current form. Instead, it acts as a test environment for learning how to publish, manage, and experiment with indicators on TradingView.
For the TradingView community, this simple tool can still be valuable, as it provides a quick visual reference for key highs that traders may use as additional context in their market analysis.
