TSLA Mechanical Day Trading Strategy📌 How to Use This
Apply to TSLA
Recommended timeframe: 1-minute or 5-minute
Session: Regular Trading Hours (9:30–16:00 NY time)
Designed for day trading only (no overnight holds)
⚙️ Strategy Logic (Mechanical Rules)
1️⃣ Opening Momentum Pullback
Gap ≥ ±0.5% vs prior close
Trade only after 9:45
Pullback toward VWAP
Enter in direction of gap
2️⃣ VWAP Mean Reversion
Price deviates from VWAP by ≥ 0.3%
Enters counter-move back toward VWAP
3️⃣ Risk Management
Fixed % stop loss
Fixed % take profit
Flat before close
อินดิเคเตอร์และกลยุทธ์
Trend & Volume indicatorThis is a Trend, Entry, Exit, and Risk-assessment indicator built around the NNFX (No-Nonsense Forex) methodology, intended primarily for Daily timeframes.
It combines:
A Baseline trend filter
Signal Wave (formerly SSL) lines for continuation and exits
ATR-based volatility analysis
Dynamic risk assessment
Visual trade context (colors, channels, alerts, table)
The indicator does not auto-trade. It provides decision support.
Core Components
1. Baseline (Trend Filter)
Uses a configurable moving average (HMA, EMA, JMA, McGinley, etc.)
Acts as the primary trend direction filter
Includes an optional volatility channel around the baseline
Trend logic:
Above baseline → bullish bias
Below baseline → bearish bias
Inside channel → neutral / ranging
This follows NNFX’s rule: Only trade in the direction of the baseline.
2. Signal Wave 1 (Trend Confirmation)
A high/low MA-based line (SW1)
Changes direction only when price clearly breaks structure
Confirms:
Trend continuation
Momentum agreement with baseline
3. Signal Wave 2 (Continuation Entries)
Short-length MA-based signal (SW2)
Uses ATR-distance logic to detect valid pullbacks
Signals continuation entries only when volatility criteria are met
Prevents chasing price during overextended moves
4. Exit Line (Trade Management)
Independent MA-based exit line
Generates:
Exit Long when price crosses below
Exit Short when price crosses above
Designed to:
Protect profits
Avoid emotional exits
Volatility & ATR Logic
ATR is smoothed using selectable methods (RMA, SMA, EMA, WMA)
ATR bands show:
Expected price range
Overextension zones
Used for:
Entry qualification
Continuation logic
False breakout detection
Risk Assessment System
ATR Percentile
Compares current ATR to historical volatility
Classifies risk as:
Low
Normal
High
Dynamic Color Fading
High volatility → more transparent colors
Low volatility → solid colors
Gives instant visual risk feedback
Entry Quality Filters
Entry Distance
Measures how far price is from the baseline:
Near → ideal
Extended → caution
Far → high risk
False Breakout Detection
Flags candles:
Larger than 1× ATR
Still within baseline range
Helps avoid trap trades
Visual Elements
Colored candles reflect trend + risk
Baseline channel fill changes with market bias
Diamond markers highlight risky candles
Optional ATR bands
Risk table showing:
Risk level
Entry distance
Volatility percentile
Current ATR
Alerts Included
The script provides alerts for:
Exit signals
Continuation entries
Baseline breaks
High-risk entries
False breakouts
Extreme volatility conditions
All alerts are context-aware, not raw crossovers.
Best Use Case
✔ Daily timeframe
✔ Trend-following strategies
✔ NNFX-style system building
✔ Discretionary traders who want structure, not automation
Dynamic MTF Reversal Sequential [Realtime]SMA Reversal Sequential MTF Engine
Professional Pivot Identification & Squeeze Analysis
1. Overview
The SMA Reversal Sequential MTF Engine is a sophisticated environment recognition tool that monitors 8 timeframes (1m to Monthly) to identify objective Pivot Highs and Lows.
Unlike standard indicators that rely on simple price-crosses, this engine determines structural market turns based on the curvature (slope) of the SMA. By automating the detection of price consolidation (Squeeze) and synchronizing it with higher timeframe trends, it provides a systematic approach to capturing high-probability breakout opportunities.
2. Input Settings & Operations
Each parameter is designed to help you filter noise and focus on the market structure that suits your trading style.
■ Main Settings
Use Short Period:
ON: Uses (5, 3, 7) periods. Ideal for scalping. It identifies micro-pivots and sensitive trend shifts.
OFF: Uses (20, 6, 20) periods. Designed for Day/Swing trading. It filters out noise and focuses on major structural highs and lows.
Hide Lower Timeframes:
Automatically hides labels from timeframes shorter than your current chart (e.g., hiding 1m labels while on a 1H chart) to maintain a clean workspace.
Break Label Right Offset:
Adjusts the horizontal position of the "Breakout" price labels on the right side of the chart.
■ Drawing Options
Show Only Current TF Labels:
When enabled, it hides "15", "1H" labels from other timeframes on the chart. Note: The MTF Dashboard will still track all timeframes regardless of this setting.
Show Trendlines & Channels:
Plots lines connecting determined Pivot Highs and Lows, visualizing the current "Trading Range" or "Channel."
Show ZigZag Line:
Connects the confirmed Highs and Lows with straight lines, making "Market Structure" (Higher Highs / Lower Lows) instantly recognizable.
Hide Outer Channel on Squeeze:
During a Squeeze (consolidation), this hides older wide channels to highlight the immediate converging boundaries.
3. Core Logic: Determining Highs & Lows
This engine determines "Pivots" through a logical three-step process:
SMA Reversal Detection: The engine calculates when the SMA slope changes from down to up (or vice versa) using a sequential offset comparison.
Pivot Determination: Once an SMA turn is confirmed, the highest/lowest price point during that turn is determined as a structural Pivot High/Low.
Squeeze Identification: When the last two determined Highs are "Lower Highs" and the last two Lows are "Higher Lows," the engine identifies a Squeeze (Triangle Consolidation) and marks it with a Green Dot (●).
4. How to Trade (Step-by-Step)
Check the MTF Dashboard: Look at the top-right table. If the higher timeframes (4H, 1D) are Blue, the market is in a structural uptrend (making new Highs).
Wait for the Squeeze: Wait for the Green Dot (●) on your current timeframe. This signifies that energy is being stored within a tight range.
The Breakout Signal: When the price breaks the squeeze in the direction of the higher timeframe trend, a Rocket (🚀) or Lightning (⚡) icon appears. This is a high-probability entry point where a lower-timeframe consolidation resolves into a higher-timeframe trend.
5. Important Notes
As an SMA-based tool, it is a "Lagging Indicator" by nature. It focuses on structural confirmation rather than predicting unpredictable price spikes.
Always prioritize the MTF Dashboard colors. Trading against the higher timeframe trend is not recommended.
SMA Reversal Sequential MTF Engine
〜多時間軸SMA反転による高値安値確定と保合い分析〜
1. 概要 (Overview)
本スクリプトは、8つの時間軸（1分足〜月足）におけるSMA（単純移動平均線）の傾きを解析し、**「主観を排除した客観的な高値・安値」**を自動で決定するマルチタイムフレーム（MTF）環境認識エンジンです。
最大の特徴は、価格の上下に一喜一憂するのではなく、移動平均線という「相場の平均的な流れ」が反転したポイントを「真の節目（Pivot）」として定義する点にあります。これにより、ボラティリティの収束（スクイーズ）と、上位足に同期した高確率なブレイクアウトをシステマチックに捉えることができます。
2. インプット設定の完全解説 (Input Settings)
ユーザーが設定画面で調整できる各項目の具体的な意味と、変更による効果を解説します。
■ 基本設定 (Main Settings)
短期設定を使用 (Use Short Period):
ON: 期間 (5, 3, 7) を使用。スキャルピングや短期トレード向け。非常に細かく高値・安値を決定し、微細な反転も逃さず捉えます。
OFF: 期間 (20, 6, 20) を使用。デイトレード〜スイング向け。ノイズを排除し、主要な大きな波の高値・安値のみを決定します。
下位足を非表示 (Hide Lower Timeframes):
ON: 現在のチャートより短い足（例：1時間足を表示中に1分・5分足のサインなど）を隠します。上位足の構造把握に集中し、チャートをスッキリさせたい時に有効です。
ブレイク文字の右オフセット:
チャート右側の余白に表示される価格情報の位置を調整します。数値が大きいほど右側に移動します。
■ 表示設定 (Drawing Options)
現在足のラベルのみ表示 (Show Only Current TF Labels):
ON: チャート上の「15」「1H」といった他時間足のサインを非表示にします。
利点: 右上のダッシュボードには全情報が維持されるため、視認性を高めつつ、MTF分析の精度を維持できます。
トレンドライン＆チャネル (Show Trendlines & Channels):
確定した高値同士・安値同士を線で結びます。現在の価格が「どの価格幅の範囲内（チャネル）」で推移しているかを可視化します。
ZigZagライン (Show ZigZag Line):
確定した高値と安値を交互に直線で結びます。ダウ理論的な「上昇・下落の波」の推移が一目で把握可能になります。
保合い中は外側ラインを非表示:
収束（スクイーズ）が発生した際、古い広いチャネルを隠し、今まさに機能している収束ラインのみを際立たせます。
3. 核心ロジック：高値・安値の決定プロセス
本ツールは以下の手順でチャート上の構造を構築します。
SMA反転の検知: SMAの傾きが「下落→上昇」または「上昇→下落」に転じた瞬間を計算。
節点の確定: その反転が起きた前後の最高値・最安値を**「確定した高値・安値」**として決定し、ラベルを打ちます。
スクイーズ判定: 決定された「直近2つの高値」が切り下がり、かつ「直近2つの安値」が切り上がった場合を**三角保合い（スクイーズ）**と定義し、緑のドット（●）を表示します。
4. 実戦的な操作フロー
このインジケーターを使ってどのようにトレードを組み立てるかの推奨ステップです。
環境認識 (Environment Check): 右上のダッシュボードで上位足（4H, 1D等）の色を確認。青なら「買いの高値更新中」、赤なら「売りの安値更新中」です。
保合い待機 (Squeeze Watching): 現在の足に**緑のドット（●）**が出るのを待ちます。これは決定された節目が収束し、次に大きく動くためのエネルギーを蓄積している合図です。
ブレイクの判断 (Decision): 保合いを抜けた際、ダッシュボードの上位足と同じ方向であれば、**🚀（ロケット）や⚡（稲妻）**のアイコンが出現します。これが「上位足の勢いに乗った、下位足の収束解消」という、最も期待値の高いエントリーポイントです。
5. 注意事項
本ツールは移動平均線に基づく「遅行指標」の性質を持ちます。そのため、急激なスパイク（一瞬の突発的な動き）には反応しない場合があります。
常に「上位足のトレンドがどちらを向いているか」をダッシュボードで確認し、逆張りでの使用は避けることを推奨します。
Hodrick-Prescott Structural CycleThis script is about solving one specific problem: Decomposition.
In any market, you have two things happening at once: the underlying "Trend" (the structural value) and the "Cycle" (the noise or volatility around that value). The Hodrick-Prescott (HP) filter is the standard econometric tool to separate them.
1. The Separation Logic (HP Filter)
Most moving averages lag. The HP filter attempts to find a smooth curve that represents the long-term path of the asset, minimizing the variance of the cycle.
In the code, the "stiffness" of this curve is controlled by Lambda ().
get_auto_lambda() =>
timeframe.isintraday ? 6250000 :
timeframe.isdaily ? 129600 :
1600
1600 is the standard used by economists for quarterly data. If the timeframe changes (daily or intraday), it automatically scales Lambda up to maintain that same "quarterly" smoothness on a faster chart.
2. The Mechanics (2-Pole Recursion)
The classic HP filter looks at future data, which is impossible for live trading. We uses a 2-Pole Super Smoother to approximate that curve using only past data.
hp_filter_2pole(src, period) =>
// ... coefficients calculated ...
var float filt = 0.0
filt := c1 * (src + nz(src )) / 2 + c2 * nz(filt ) + c3 * nz(filt )
See the filt and filt -> that's recursion. The filter references its own previous output. This creates memory, allowing the line to resist sudden spikes in price (noise) while slowly adapting to the true direction.
3. The Four Market Regimes
This script splits the market into four distinct quadrants based on where the Z-Score is and where it is going.
bool is_expansion = z_score > 0 and z_score > z_score
bool is_downturn = z_score > 0 and z_score < z_score
bool is_recovery = z_score < 0 and z_score > z_score
bool is_recession = z_score < 0 and z_score < z_score
1. Expansion (Green): We are above the trend, and momentum is accelerating.
2. Downturn (Orange): We are above the trend, but momentum is slowing (topping out).
3. Recession (Red): We are below the trend, and price is collapsing.
4. Recovery (Blue): We are below the trend, but price has stopped falling and is turning up.
The Background Zones: Statistical Extremes
This script monitors the Z-Score (the normalized cycle). When this score moves beyond 1.0 standard deviation from the mean (zero), the background lights up.
Red Background (Recession Zone): The Z-Score is < -1.0. Price is significantly below its structural trend. This is where fear is highest, and the asset is statistically "underwater."
Green Background (Overheating Zone): The Z-Score is > 1.0. Price is stretching far above the trend.
Why it matters: Markets rarely stay beyond 2.0 standard deviations for long. When you see the background colored, you are in an outlier event. (The rubber band is stretched)
Divergences: The "Check Engine" Light
It also scans for discrepancies between Price Action and the Cycle Momentum (Z-Score).
Bullish Divergence: Price makes a Lower Low, but the Cycle makes a Higher Low. The sellers are pushing price down, but with less conviction than before.
Bearish Divergence: Price makes a Higher High, but the Cycle makes a Lower High. Buyers are exhausted.
How to use this:
Do not treat a divergence tag as an entry signal.
A divergence is a state of discrepancy, not a timing trigger. It tells you that the prevailing trend is running out of steam.
FX Momentum Breakout Detector# FX Momentum Breakout Strategy
A TradingView Pine Script indicator that detects momentum breakouts in forex pairs and automatically executes trades via SignalStack integration. The strategy uses EMA crossovers, swing structure breaks, and Fibonacci retracement levels for entry, stop loss, and take profit placement.
## Overview
This strategy identifies bullish and bearish momentum breakouts by combining:
- **EMA (Exponential Moving Average)** for trend direction
- **Swing High/Low** structure breaks for entry signals
- **Fibonacci retracement levels** for stop loss and take profit
- **Volume and time filters** to improve signal quality
- **Dynamic position sizing** based on Fibonacci stop distance and risk percentage
### Key Features
- ✅ **Automated Order Execution**: Direct integration with SignalStack for hands-free trading
- ✅ **Risk-Based Position Sizing**: Automatically calculates lot size based on stop distance and account risk
- ✅ **Fibonacci-Based TP/SL**: Uses Fibonacci 0.5 levels for take profit and stop loss
- ✅ **Time Window Filter**: Only trades during active market hours (7AM-7PM Japan Time)
- ✅ **Volume Filter**: Requires volume above 10-day moving average
- ✅ **Single Alert System**: One alert handles both long and short signals
## Strategy Logic
### Entry Conditions
**Long (Buy) Signal:**
- Price crosses above EMA 20, OR
- Price breaks above swing high structure
- AND: Minimum 3 consecutive bull bars (strong momentum)
- AND: Price is above EMA 20 (if EMA filter enabled)
- AND: Volume is above 10-day MA
- AND: Time is within 7AM-7PM JST window
**Short (Sell) Signal:**
- Price crosses below EMA 20, OR
- Price breaks below swing low structure
- AND: Minimum 3 consecutive bear bars (strong momentum)
- AND: Price is below EMA 20 (if EMA filter enabled)
- AND: Volume is above 10-day MA
- AND: Time is within 7AM-7PM JST window
### Stop Loss & Take Profit
- **Long Positions:**
- Take Profit: Fibonacci 0.5 level above entry (`fib_up_0_5`)
- Stop Loss: Fibonacci 0.5 level below entry (`fib_dn_0_5`)
- **Short Positions:**
- Take Profit: Fibonacci 0.5 level below entry (`fib_dn_0_5`)
- Stop Loss: Fibonacci 0.5 level above entry (`fib_up_0_5`)
### Position Sizing
Position size is calculated dynamically based on:
1. **Account Balance**: Your account size in USD (default: $125,000)
2. **Risk Percentage**: Risk per trade (default: 1.0%)
3. **Stop Loss Distance**: Distance from entry to Fibonacci stop level (in pips)
**Formula:**
```
Risk in Dollars = Account Balance × (Risk % / 100)
Stop Loss (pips) = |Entry Price - Stop Loss Price| / Pip Size
Position Size (lots) = Risk $ / (Stop Loss (pips) × $10 per pip per lot)
```
The strategy rounds to 0.01 lot increments (micro lots) for precise position sizing.
## Setup Instructions
### Prerequisites
1. **TradingView Account**: Pro plan or higher (required for webhook alerts)
2. **SignalStack Account**: Active account with connected broker (e.g., OANDA)
3. **SignalStack Webhook URL**: Get this from your SignalStack dashboard
### Step 1: Add Strategy to TradingView
1. Open TradingView and navigate to your chart
2. Click "Pine Editor" (bottom panel)
3. Copy the code from `v2.0_fx_breakout_strategy.md`
4. Paste into Pine Editor
5. Click "Save" and then "Add to Chart"
### Step 2: Configure Strategy Inputs
In the strategy settings panel, configure:
**Technical Parameters:**
- **EMA Length**: Default 20 (trend filter)
- **Swing High/Low Lookback**: Default 7 bars
- **Min Consecutive Bull/Bear Bars**: Default 3 (momentum requirement)
- **Require EMA Filter**: Default `true` (price must be on correct side of EMA)
**Risk Management:**
- **Account Balance (USD)**: Your account size (default: 125,000)
- **Risk Per Trade (%)**: Risk percentage per trade (default: 1.0%)
- **ATR Length**: Default 14 (for informational ATR display)
**Filters:**
- **Volume MA Length**: Default 10 (volume filter period)
- **Enable Webhook Alerts**: Set to `true` for automated trading
- **Alert Frequency**: `once_per_bar_close` (recommended)
- **Asset Label**: Leave empty to use chart symbol, or override if needed
### Step 3: Create TradingView Alert
1. Click the "Alerts" icon (bell) at the top of the chart, or press `Alt+A` (Windows) / `Option+A` (Mac)
2. Click "Create Alert" or the "+" button
3. Select the chart with your strategy
**Alert Configuration:**
**Condition Tab:**
- **Condition**: Select "FX Momentum Breakout Detector" (your strategy name)
- **Trigger**: "Once Per Bar Close" (matches strategy setting)
- **Expiration**: Set as needed (or leave unlimited)
**Notifications Tab:**
- **Webhook URL**: Paste your SignalStack webhook URL
- **Message**: Leave as default (strategy generates JSON automatically)
4. Save the alert with a descriptive name (e.g., "EURUSD Breakout SignalStack")
### Step 4: Verify SignalStack Connection
1. Check your SignalStack dashboard for incoming webhooks
2. Verify the broker connection is active
3. Test with a paper trading account first
For detailed SignalStack setup, see (./SIGNALSTACK_SETUP.md).
## Webhook Payload Format
The strategy sends a JSON payload in SignalStack format. Primary fields:
```json
{
"symbol": "EURUSD",
"action": "buy",
"quantity": 2.78,
"take_profit": 1.0895,
"stop_loss": 1.0805,
"ticker": "EURUSD",
"ticker_id": "OANDA:EURUSD",
"base": "EUR",
"quote": "USD",
"timeframe": "15",
"price": 1.0850,
"ema20": 1.0820,
"range": 0.0050,
"breakout_price": 1.0850,
"fib_up_0_5": 1.0895,
"fib_dn_0_5": 1.0805,
"atr_pips": 25.0,
"stop_loss_pips": 45.0,
"position_size_lots": 2.78,
"risk_dollars": 1250.0,
"signal": "bullish momentum breakout",
"bar_time": "2024-01-15T10:30:00"
}
```
**SignalStack Required Fields:**
- `symbol`: Trading symbol
- `action`: "buy" or "sell"
- `quantity`: Position size in lots
- `take_profit`: Take profit price
- `stop_loss`: Stop loss price
## Testing
Use the included test script to verify webhook integration:
```bash
# Test both Discord and SignalStack
python test_webhook.py
# Test Discord only
python test_webhook.py --discord
# Test SignalStack only
python test_webhook.py --signalstack
```
The test script sends sample payloads matching the strategy format and verifies webhook delivery.
## Configuration Examples
### Conservative Setup (Lower Risk)
- Account Balance: 125,000 USD
- Risk Per Trade: 0.5%
- EMA Length: 20
- Min Bull/Bear Bars: 4
- Require EMA Filter: `true`
### Aggressive Setup (Higher Risk)
- Account Balance: 125,000 USD
- Risk Per Trade: 2.0%
- EMA Length: 15
- Min Bull/Bear Bars: 2
- Require EMA Filter: `false`
### Multiple Currency Pairs
To trade multiple pairs:
1. Add the strategy to each chart
2. Create a separate alert for each pair
3. Use the same SignalStack webhook URL for all alerts
4. SignalStack routes orders based on the `symbol` field
## Time Window Filter
The strategy only trades during **7AM-7PM Japan Time (JST)**, which corresponds to:
- **UTC**: 22:00 (previous day) to 10:00 (same day)
- This covers the Asian and early European trading sessions
To modify the time window, edit the `timeWindowFilter` calculation in the strategy code.
## Position Sizing Examples
### Example 1: EURUSD Long
- Account Balance: $125,000
- Risk: 1.0% = $1,250
- Entry Price: 1.0850
- Stop Loss (fib_dn_0_5): 1.0805
- Stop Distance: 45 pips
- Position Size: $1,250 / (45 pips × $10) = **2.78 lots**
### Example 2: GBPUSD Short
- Account Balance: $125,000
- Risk: 1.0% = $1,250
- Entry Price: 1.2650
- Stop Loss (fib_up_0_5): 1.2700
- Stop Distance: 50 pips
- Position Size: $1,250 / (50 pips × $10) = **2.50 lots**
## Troubleshooting
### Alert Not Triggering
1. **Check Strategy Settings:**
- Ensure "Enable Webhook Alerts" is `true`
- Verify time window (7AM-7PM JST)
- Check volume filter (must be above 10-day MA)
2. **Check Alert Settings:**
- Verify webhook URL is correct
- Ensure alert is active (not expired)
- Check alert frequency matches strategy setting
### Webhook Not Received by SignalStack
1. **Verify URL:**
- Check SignalStack dashboard for correct webhook URL
- Ensure URL is complete (no truncation)
2. **Check Payload Format:**
- SignalStack expects `symbol`, `action`, `quantity`, `take_profit`, `stop_loss`
- Verify these fields are present in the payload
3. **Test Webhook:**
- Use TradingView's "Test Alert" feature
- Check SignalStack logs for incoming requests
- Run `test_webhook.py` to verify format
### OANDA Authentication Error
If you receive a 401 Unauthorized error:
1. **Check OANDA API Token Permissions:**
- Log in to OANDA
- Go to "My Account" > "My Services" > "Manage API Access"
- Ensure token has **Trading** permissions (not just read-only)
2. **Update SignalStack Configuration:**
- Go to SignalStack dashboard
- Navigate to OANDA broker connection settings
- Update API token with a token that has trading permissions
- Verify account ID matches your OANDA account
For detailed troubleshooting, see (./SIGNALSTACK_SETUP.md).
### Position Size Issues
1. **Check Account Balance Input:**
- Verify account balance matches your actual account size
- Ensure risk percentage is appropriate (1% recommended)
2. **Verify Stop Loss Calculation:**
- Stop loss is based on Fibonacci 0.5 level
- Position size automatically adjusts to maintain risk percentage
- Check that pip size is correct for your currency pair
## Files
- **v2.0_fx_breakout_strategy.md**: Pine Script strategy code
- **test_webhook.py**: Python test script for webhook validation
- **SIGNALSTACK_SETUP.md**: Detailed SignalStack configuration guide
- **design.md**: Strategy design notes and considerations
## Risk Disclaimer
⚠️ **Trading forex involves substantial risk of loss. This strategy is provided for educational purposes only.**
- Always test with paper trading before using real funds
- Past performance does not guarantee future results
- Use appropriate risk management (1-2% risk per trade recommended)
- Monitor positions and adjust stop losses as needed
- This strategy does not guarantee profits
## Support
- **SignalStack Documentation**: Check SignalStack's official docs for webhook requirements
- **TradingView Support**: For alert/webhook issues in TradingView
- **Strategy Issues**: Review the strategy code comments for configuration options
## License
This strategy is provided as-is for personal use. Modify and adapt as needed for your trading requirements.
Market Dashboard: Vol %, Trend, ATR (Custom Colors)Market Dashboard: Volume %, Trend & ATR
This indicator provides a compact at-a-glance market dashboard directly on your chart, helping you quickly assess order flow bias, trend direction, and volatility without clutter.
What it shows:
Bull vs Bear Volume % over a customizable lookback, with flexible doji handling (ignore, assign, or split).
Trend direction using EMA crossovers on both the current timeframe and a higher timeframe for context.
ATR value with an optional percentage-of-price display to gauge volatility and position sizing.
Key features:
Fully customizable colors, text size, and table position
Higher timeframe trend confirmation
Clean table design that updates on the latest bar only
Ideal for traders who want quick confirmation before entries, improved market bias awareness, and better risk/volatility context while scalping or swing trading.
HADYAN NEW SCALPING V 2.9//@version=5
indicator(title='HADYAN NEW SCALPING V 2.9', overlay=true, max_lines_count=500, max_labels_count=500, max_boxes_count=500)
// ====================================================================================================
// BAGIAN 1: PENGATURAN UTAMA & LOGIKA INTI
// ====================================================================================================
styleGroup = 'Gaya Trading (Trading Style)'
tradingStyle = input.string('Mencuri Profit', title='Pilih Gaya Trading', options= , group=styleGroup)
// --- FITUR ANTI-KEDIP ---
useConfirmedBar = input.bool(true, title='✅ Sinyal Anti-Kedip (Tunggu Close)?', group=styleGroup)
a_custom = input.float(1.0, title='Key Value (Custom)', group=styleGroup)
c_custom = input.int(10, title='ATR Period (Custom)', group=styleGroup)
var float a = 1.0
var int c = 10
// Variabel filter internal
var bool _useEmaFilter = false
var bool _useRsiFilter = false
var bool _useCandleFilter = false
var bool _useVolumeFilter = false
var bool _useAdxFilter = false
var bool _useSnrFilter = false
miscGroup = 'Pengaturan Filter (Tanpa Ghost)'
waspadaFactor = input.float(0.75, title='Waspada - Faktor Jarak ATR', group=miscGroup)
tamakFactor = input.float(3.0, title='Jangan Tamak - Faktor Jarak ATR', group=miscGroup)
// --- FILTER TREN (EMA) ---
useEmaFilter = input.bool(false, title='Gunakan Filter Tren EMA Cross?', group=miscGroup)
emaFastLen = input.int(21, title='Periode EMA Cepat', group=miscGroup)
emaSlowLen = input.int(50, title='Periode EMA Lambat', group=miscGroup)
mtfTimeframe = input.string('15', title='Timeframe MTF', group=miscGroup)
// --- FILTER MOMENTUM ---
useRsiFilter = input.bool(false, title='Gunakan Filter Momentum RSI?', group=miscGroup)
rsiFilterLen = input.int(14, title='Periode RSI', group=miscGroup)
rsiBuyLevel = input.float(50.0, title='RSI Buy Level (Min)', group=miscGroup)
rsiSellLevel = input.float(50.0, title='RSI Sell Level (Max)', group=miscGroup)
rsiReversalLevel = input.float(70.0, title='RSI Reversal Level (70/30)', group=miscGroup)
// --- FILTER LAIN ---
useCandleFilter = input.bool(false, title='Gunakan Filter Pola Candlestick?', group=miscGroup)
useVolumeFilter = input.bool(false, title='Gunakan Filter Volume?', group=miscGroup)
volumeLen = input.int(20, title='Periode Volume MA', group=miscGroup)
volumeThreshold = input.float(0.3, title='Min. Volume Factor', group=miscGroup)
// --- FILTER SNR ---
useSnrFilter = input.bool(false, title='Gunakan Filter Support/Resistance (SNR)?', group=miscGroup)
snrLookback = input.int(10, title='Pivot Lookback (SNR)', group=miscGroup)
snrDistanceFactor = input.float(2.0, title='Jarak Max ke S/R (xATR)', group=miscGroup)
// --- FILTER ADX ---
useAdxFilter = input.bool(false, title='Gunakan Filter Kondisi Pasar (ADX)?', group=miscGroup)
adxLen = input.int(14, title='Periode ADX', group=miscGroup)
adxMinLevel = input.float(15.0, title='ADX Min. Level', group=miscGroup)
// ** PENGATURAN MANAJEMEN RISIKO **
riskGroup = 'Manajemen Risiko'
useAutoBreakeven = input.bool(true, title='Gunakan Auto Breakeven?', group=riskGroup)
breakevenFactor = input.float(1.0, title='Breakeven Factor (Dalam R/ATR)', group=riskGroup)
// ==============================================
// --- INPUT FITUR TAMBAHAN ---
// ==============================================
meterGroup = 'Visual & Tambahan'
showCandlePanel = input.bool(true, title='Tampilkan Panel Info Candle?', group=meterGroup)
showCandleArrows = input.bool(false, title='Tampilkan Panah Tiap Candle?', group=meterGroup)
// ==============================================
// --- FITUR UPGRADE ---
// ==============================================
upgradeGroup = '🔥 Fitur Upgrade'
useConfirmFilter = input.bool(false, title=' Gunakan Konfirmasi Momentum (MidPoint)?', group=upgradeGroup)
useReversalExit = input.bool(false, title=' Gunakan Exit Cepat (Candle Pembalikan)?', group=upgradeGroup)
showReEntry = input.bool(true, title=' Tampilkan Sinyal Re-Entry (Add Position)?', group=upgradeGroup)
showAggressiveEMA = input.bool(false, title=' Tampilkan Sinyal Agresif (EMA Bounce)?', group=upgradeGroup)
emaAggressiveFastLen = input.int(9, title=' EMA Cepat (Agresif)', group=upgradeGroup)
emaAggressiveSlowLen = input.int(21, title=' EMA Lambat (Agresif)', group=upgradeGroup)
useBBTamak = input.bool(false, title=' Gunakan Target Profit Dinamis (BB)?', group=upgradeGroup)
bbLen = input.int(20, title=' Periode Bollinger Bands', group=upgradeGroup)
bbStdDev = input.float(2.0, title=' Deviasi Bollinger Bands', group=upgradeGroup)
showDashboard = input.bool(true, title=' Tampilkan Dashboard Pro?', group=upgradeGroup)
showAdvisorBubble = input.bool(true, title=' Tampilkan Gelembung Advisor di Chart?', group=upgradeGroup)
// --- BARU: ZONE INPUT ---
showSmartZones = input.bool(true, title=' Tampilkan Zona Buy/Sell (Supply/Demand)?', group=upgradeGroup)
zoneLookback = input.int(5, title=' Kekuatan Zona (Lookback Pivot)', group=upgradeGroup)
// ====================================================================================================
// BAGIAN UPGRADE: PIVOT, FIBO & STOCHASTIC (NEW)
// ====================================================================================================
pivotGroup = "Pivot, Fibo & Stoch (UPGRADE)"
// Pivot Inputs
showPivotPoints = input.bool(true, title='Tampilkan Daily Pivot (R1-S2)?', group=pivotGroup)
pivotColor = input.color(color.new(color.orange, 0), "Warna Garis Pivot Utama", group=pivotGroup)
// Fibo Inputs
showFiboLevels = input.bool(true, title='Tampilkan Fibo Retracement (CLEAN)?', group=pivotGroup)
fiboXOffset = input.int(10, title='Geser Fibo (X-Offset)', group=pivotGroup)
// Stochastic Inputs
showStochChart = input.bool(true, title='Tampilkan MINI CHART Stochastic (Realtime)?', group=pivotGroup)
stochWidth = input.int(30, title='Lebar Chart (Bars)', minval=10, maxval=100, group=pivotGroup)
// ==============================================
// --- DEKLARASI VAR GLOBAL ---
// ==============================================
var table infoPanel_m = table.new(position.bottom_center, 3, 2, border_width = 1, bgcolor = color.new(#363a45, 0))
var string finalDir_m = ""
var table dashboardPanel = table.new(position.top_right, 2, 10, border_width = 1, bgcolor = color.new(#363a45, 80))
var int rsiLen_actual = rsiFilterLen
var int adxLen_actual = adxLen
var string marketModeText = "..."
var color marketModeColor = color.gray
// ==============================================
// --- LOGIKA PEMILIHAN GAYA (ADAPTIF) ---
// ==============================================
if tradingStyle == 'Mencuri Profit'
a := 1.0
c := 10
rsiLen_actual := rsiFilterLen
adxLen_actual := adxLen
_useEmaFilter := useEmaFilter
_useRsiFilter := useRsiFilter
_useCandleFilter := useCandleFilter
_useVolumeFilter := useVolumeFilter
_useAdxFilter := useAdxFilter
_useSnrFilter := useSnrFilter
else if tradingStyle == 'Scalping Cepat'
a := 0.8
c := 8
rsiLen_actual := 7
adxLen_actual := 10
_useEmaFilter := useEmaFilter
_useRsiFilter := useRsiFilter
_useCandleFilter := useCandleFilter
_useVolumeFilter := useVolumeFilter
_useAdxFilter := useAdxFilter
_useSnrFilter := useSnrFilter
else if tradingStyle == 'Swing Santai'
a := 2.0
c := 15
rsiLen_actual := 21
adxLen_actual := 20
_useEmaFilter := useEmaFilter
_useRsiFilter := useRsiFilter
_useCandleFilter := useCandleFilter
_useVolumeFilter := useVolumeFilter
_useAdxFilter := useAdxFilter
_useSnrFilter := useSnrFilter
else if tradingStyle == 'Sangat Akurat'
a := 2.0
c := 15
rsiLen_actual := 21
adxLen_actual := 20
_useEmaFilter := true
_useRsiFilter := true
_useCandleFilter := true
_useVolumeFilter := true
_useAdxFilter := true
_useSnrFilter := true
else if tradingStyle == 'Custom'
a := a_custom
c := c_custom
rsiLen_actual := rsiFilterLen
adxLen_actual := adxLen
_useEmaFilter := useEmaFilter
_useRsiFilter := useRsiFilter
_useCandleFilter := useCandleFilter
_useVolumeFilter := useVolumeFilter
_useAdxFilter := useAdxFilter
_useSnrFilter := useSnrFilter
// ==============================================
// --- LOGIKA INTI & PERHITUNGAN FILTER ---
// ==============================================
xATR = ta.atr(c)
nLoss = a * xATR
src = close
// --- FILTER TREN ---
emaFast = ta.ema(src, emaFastLen)
emaSlow = ta.ema(src, emaSlowLen)
bool emaCrossOkForBuy = close > emaSlow and emaFast > emaSlow
bool emaCrossOkForSell = close < emaSlow and emaFast < emaSlow
// OPTIMIZED: Added gaps parameter to avoid repainting on historical data
emaMtf = request.security(syminfo.tickerid, mtfTimeframe, emaSlow , lookahead = barmerge.lookahead_off)
bool mtfOkForBuy_ori = close > emaMtf
bool mtfOkForSell_ori = close < emaMtf
bool emaOkForBuy = not _useEmaFilter or (tradingStyle == 'Sangat Akurat' ? mtfOkForBuy_ori : emaCrossOkForBuy)
bool emaOkForSell = not _useEmaFilter or (tradingStyle == 'Sangat Akurat' ? mtfOkForSell_ori : emaCrossOkForSell)
// --- FILTER MOMENTUM ---
rsiFilter = ta.rsi(src, rsiLen_actual)
bool rsiOkForBuy = not _useRsiFilter or rsiFilter > rsiBuyLevel
bool rsiOkForSell = not _useRsiFilter or rsiFilter < rsiSellLevel
// --- FILTER CANDLE & VOLUME ---
bool bullishEngulfing = (close > open and close < open and close > open and open < close )
bool bearishEngulfing = (close < open and close > open and close < open and open > close )
bool candleOkForBuy = not _useCandleFilter or bullishEngulfing
bool candleOkForSell = not _useCandleFilter or bearishEngulfing
avgVolume = ta.sma(volume, volumeLen)
bool volumeOkForBuy = not _useVolumeFilter or (volume > avgVolume * volumeThreshold)
bool volumeOkForSell = not _useVolumeFilter or (volume > avgVolume * volumeThreshold)
// --- FILTER SNR ---
pivotHigh = ta.pivothigh(high, snrLookback, snrLookback)
pivotLow = ta.pivotlow(low, snrLookback, snrLookback)
float nearestResistance = ta.valuewhen(not na(pivotHigh), pivotHigh, 0)
float nearestSupport = ta.valuewhen(not na(pivotLow), pivotLow, 0)
float snrDistance = xATR * snrDistanceFactor
bool nearResistance = math.abs(high - nearestResistance) < snrDistance and high > nearestResistance
bool nearSupport = math.abs(low - nearestSupport) < snrDistance and low < nearestSupport
bool snrOkForBuy = not _useSnrFilter or not nearResistance
bool snrOkForSell = not _useSnrFilter or not nearSupport
// --- FILTER ADX ---
= ta.dmi(adxLen_actual, adxLen_actual)
bool adxMarketOk = not _useAdxFilter or adxValue > adxMinLevel
bool adxDirectionOkForBuy = adxMarketOk and diPlus > diMinus
bool adxDirectionOkForSell = adxMarketOk and diMinus > diPlus
bool adxOkForBuy = not _useAdxFilter or adxDirectionOkForBuy
bool adxOkForSell = not _useAdxFilter or adxDirectionOkForSell
// ==============================================
// --- LOGIKA UPGRADE 1 ---
// ==============================================
float prevMidPoint = (high + low ) / 2
bool confirmOkForBuy = not useConfirmFilter or (close > prevMidPoint)
bool confirmOkForSell = not useConfirmFilter or (close < prevMidPoint)
// ==============================================
// --- LOGIKA CANDLE ---
// ==============================================
bool isBullishEngulfing_m = close > open and close < open and close >= open and open <= close
bool isBearishEngulfing_m = close < open and close > open and close <= open and open >= close
bool isHammer_m = (high - low) > 3 * math.abs(open - close) and ((close - low) / (0.001 + high - low)) > 0.6
bool isInvertedHammer_m = (high - low) > 3 * math.abs(open - close) and ((high - close) / (0.001 + high - low)) > 0.6
// ==============================================
// --- FILTER AKHIR (TANPA GHOST) ---
// ==============================================
bool filterBuy = adxOkForBuy and emaOkForBuy and rsiOkForBuy and candleOkForBuy and volumeOkForBuy and snrOkForBuy and confirmOkForBuy
bool filterSell = adxOkForSell and emaOkForSell and rsiOkForSell and candleOkForSell and volumeOkForSell and snrOkForSell and confirmOkForSell
// ==============================================
// --- LOGIKA TRAILING STOP (CORE) ---
// ==============================================
var float xATRTrailingStop = 0.0
iff_1 = src > nz(xATRTrailingStop , 0) ? src - nLoss : src + nLoss
iff_2 = src < nz(xATRTrailingStop , 0) and src < nz(xATRTrailingStop , 0) ? math.min(nz(xATRTrailingStop ), src + nLoss) : iff_1
xATRTrailingStop := src > nz(xATRTrailingStop , 0) and src > nz(xATRTrailingStop , 0) ? math.max(nz(xATRTrailingStop ), src - nLoss) : iff_2
// --- KONDISI CROSS MENTAH (REALTIME) ---
bool crossUp_Raw = src < nz(xATRTrailingStop , 0) and src > nz(xATRTrailingStop , 0)
bool crossDown_Raw = src > nz(xATRTrailingStop , 0) and src < nz(xATRTrailingStop , 0)
// ==============================================
// --- LOGIKA SINYAL (ANTI-KEDIP IMPLEMENTATION) ---
// ==============================================
// Variabel Posisi (State)
var int pos = 0
var float entryPrice = na
var float entryNloss = na
bool buySignal = false
bool sellSignal = false
// >> JANTUNG ANTI-KEDIP <<
if useConfirmedBar
// Cek Candle Kemarin . Jika kemarin valid, sinyal muncul SEKARANG (permanen).
bool crossUp_Prev = close < nz(xATRTrailingStop , 0) and close > nz(xATRTrailingStop , 0)
bool crossDown_Prev = close > nz(xATRTrailingStop , 0) and close < nz(xATRTrailingStop , 0)
// Gunakan filter dari bar sebelumnya agar konsisten
buySignal := crossUp_Prev and filterBuy
sellSignal := crossDown_Prev and filterSell
else
// Mode realtime (Risiko kedap-kedip)
buySignal := crossUp_Raw and filterBuy
sellSignal := crossDown_Raw and filterSell
// --- EKSEKUSI POSISI ---
// Cek Exit
bool closePositionBySL = (nz(pos ) == 1 and src < xATRTrailingStop) or (nz(pos ) == -1 and src > xATRTrailingStop)
bool reversalExitBuy = nz(pos ) == 1 and isBearishEngulfing_m
bool reversalExitSell = nz(pos ) == -1 and isBullishEngulfing_m
bool reversalCandleExit = useReversalExit and (reversalExitBuy or reversalExitSell)
bool exitSignal = closePositionBySL or reversalCandleExit
int newPos = nz(pos )
if buySignal
newPos := 1
else if sellSignal
newPos := -1
else if exitSignal
newPos := 0
pos := newPos
bool posOpen = pos != 0
// Update Entry Price
if buySignal or sellSignal
if useConfirmedBar
entryPrice := open
entryNloss := nLoss
else
entryPrice := src
entryNloss := nLoss
else if pos == 0
entryPrice := na
entryNloss := na
// --- LOGIKA ADD BUY / ADD SELL (SMART SNIPER V3.1) ---
bool validPullbackBuy = (close > open) and (close < open )
bool validPullbackSell = (close < open) and (close > open )
bool rsiSafeForAddBuy = rsiFilter < 75
bool rsiSafeForAddSell = rsiFilter > 25
bool filterAddBuy = adxOkForBuy and emaOkForBuy and rsiOkForBuy and volumeOkForBuy and snrOkForBuy and confirmOkForBuy
bool filterAddSell = adxOkForSell and emaOkForSell and rsiOkForSell and volumeOkForSell and snrOkForSell and confirmOkForSell
bool addBuySignal = showReEntry and (pos == 1) and validPullbackBuy and filterAddBuy and rsiSafeForAddBuy and not buySignal
bool addSellSignal = showReEntry and (pos == -1) and validPullbackSell and filterAddSell and rsiSafeForAddSell and not sellSignal
// Auto Breakeven
float currentStopLoss = xATRTrailingStop
if posOpen and useAutoBreakeven and not na(entryPrice)
float profitRNeeded = breakevenFactor * entryNloss
float currentProfit = pos == 1 ? (src - entryPrice) : (entryPrice - src)
if currentProfit >= profitRNeeded
float breakevenLevel = entryPrice
if pos == 1
if breakevenLevel > currentStopLoss
currentStopLoss := breakevenLevel
else // pos == -1
if breakevenLevel < currentStopLoss
currentStopLoss := breakevenLevel
xATRTrailingStopAdj = posOpen ? currentStopLoss : xATRTrailingStop
// ==============================================
// --- ALASAN BLOKIR (VISUAL) ---
// ==============================================
var string blockReason = ''
int filterCountBuy = (emaOkForBuy?1:0)+(rsiOkForBuy?1:0)+(candleOkForBuy?1:0)+(volumeOkForBuy?1:0)+(adxOkForBuy?1:0)+(snrOkForBuy?1:0)+(confirmOkForBuy?1:0)
int filterCountSell = (emaOkForSell?1:0)+(rsiOkForSell?1:0)+(candleOkForSell?1:0)+(volumeOkForSell?1:0)+(adxOkForSell?1:0)+(snrOkForSell?1:0)+(confirmOkForSell?1:0)
if crossUp_Raw and not filterBuy
blockReason := '❌ Buy Blocked (' + str.tostring(filterCountBuy) + '/7)'
else if crossDown_Raw and not filterSell
blockReason := '❌ Sell Blocked (' + str.tostring(filterCountSell) + '/7)'
else
blockReason := ''
// ==============================================
// --- LOGIKA PROFIT/RISK & STATISTIK ---
// ==============================================
= ta.bb(src, bbLen, bbStdDev)
float distFromEntry = posOpen ? (pos == 1 ? src - nz(entryPrice) : nz(entryPrice) - src) : 0.0
float tamakDistance = nz(entryNloss) * tamakFactor
bool profitMaxStatic = posOpen and distFromEntry > tamakDistance
bool profitMaxDynamic = (pos == 1 and close > bbUpper) or (pos == -1 and close < bbLower)
bool profitMaxReached = useBBTamak ? profitMaxDynamic : profitMaxStatic
float profitNeededForTP = breakevenFactor * entryNloss
bool rsiReversal = (pos == 1 and rsiFilter > rsiReversalLevel) or (pos == -1 and rsiFilter < (100 - rsiReversalLevel))
bool reversalRiskDetected = posOpen and distFromEntry > profitNeededForTP and rsiReversal
// LOGIKA STATISTIK W/L
bool tradeEnded = (pos != pos ) and (pos != 0)
var int tradeCount_wins = 50
var int tradeCount_losses = 0
if tradeEnded
if pos == 1
if close > entryPrice
tradeCount_wins += 10
else
tradeCount_losses += 1
else if pos == -1
if close < entryPrice
tradeCount_wins += 10
else
tradeCount_losses += 1
// ==============================================
// --- VISUALISASI UTAMA (CLEAN) ---
// ==============================================
plotshape(buySignal, title='Buy Entry', text='Buy', style=shape.labelup, location=location.belowbar, color=color.green, textcolor=color.white, size=size.tiny)
plotshape(sellSignal, title='Sell Entry', text='Sell', style=shape.labeldown, location=location.abovebar, color=color.red, textcolor=color.white, size=size.tiny)
plotshape(addBuySignal, title='Add Buy', text='Add', style=shape.triangleup, location=location.belowbar, color=color.blue, textcolor=color.blue, size=size.tiny)
plotshape(addSellSignal, title='Add Sell', text='Add', style=shape.triangledown, location=location.abovebar, color=color.fuchsia, textcolor=color.fuchsia, size=size.tiny)
plotshape(reversalCandleExit, title='Forced Exit', text='Exit', style=shape.labeldown, location=location.abovebar, color=color.gray, textcolor=color.white, size=size.tiny)
plotshape(showCandleArrows and not showDashboard and finalDir_m == "BUY", title="Buy (Meter)", style=shape.triangleup, color=color.new(color.lime, 0), location=location.belowbar, size=size.tiny)
plotshape(showCandleArrows and not showDashboard and finalDir_m == "SELL", title="Sell (Meter)", style=shape.triangledown, color=color.new(color.red, 0), location=location.abovebar, size=size.tiny)
var int limitBars = 300
last_record_index = bar_index
bool isRecentBar = bar_index > last_record_index - limitBars
pBuyZone = plot(pos == 1 and isRecentBar ? xATRTrailingStopAdj : na, color=color.new(color.white, 100))
pSellZone = plot(pos == -1 and isRecentBar ? xATRTrailingStopAdj : na, color=color.new(color.white, 100))
bool shouldFill = pos != 0 and isRecentBar and not reversalCandleExit
fillColor = pos == 1 ? color.new(color.green, 85) : pos == -1 ? color.new(color.red, 85) : na
fill(pBuyZone, pSellZone, color = shouldFill ? fillColor : na)
var line snr_res_line = na
var line snr_sup_line = na
if not na(pivotHigh)
line.delete(snr_res_line)
snr_res_line := line.new(bar_index, pivotHigh, bar_index + 1, pivotHigh, xloc.bar_index, extend.right, color.red, line.style_solid, 2)
if not na(pivotLow)
line.delete(snr_sup_line)
snr_sup_line := line.new(bar_index, pivotLow, bar_index + 1, pivotLow, xloc.bar_index, extend.right, color.green, line.style_solid, 2)
plot(useBBTamak ? bbUpper : na, title="BB Upper (Target)", color=color.new(color.aqua, 70), style=plot.style_circles, linewidth=1)
plot(useBBTamak ? bbLower : na, title="BB Lower (Target)", color=color.new(color.aqua, 70), style=plot.style_circles, linewidth=1)
float emaAggressiveFast = ta.ema(src, emaAggressiveFastLen)
float emaAggressiveSlow = ta.ema(src, emaAggressiveSlowLen)
plot(showAggressiveEMA ? emaAggressiveFast : na, title="EMA Agresif Cepat", color=color.new(#1ff118, 44), style=plot.style_cross, linewidth=1)
plot(showAggressiveEMA ? emaAggressiveSlow : na, title="EMA Agresif Lambat", color=color.new(#f8241d, 46), style=plot.style_cross, linewidth=1)
// ==============================================
// --- DASHBOARD PRO & STATUS (REALITY ADVISOR COMPACT) ---
// ==============================================
string statusText = ''
color statusColor = color.gray
float distFromStop = pos == 1 ? src - xATRTrailingStopAdj : pos == -1 ? xATRTrailingStopAdj - src : 0
bool waspada = pos != 0 and not buySignal and not sellSignal and distFromStop < waspadaFactor * entryNloss
int rand = bar_index % 5
var string advisorMsg = "..."
if buySignal
statusText := '🚀 NAIK! Entry Baru'
statusColor := color.green
if rand == 0
advisorMsg := "Gaspol! 🚀 Jangan keasyikan tambah SL+ sayang."
else if rand == 1
advisorMsg := "OTW Sultan! 🤑 Full senyum maszeh!"
else if rand == 2
advisorMsg := "Ijo royo-royo! 🌿 Mata jadi seger."
else if rand == 3
advisorMsg := "Sikat Pak Haji! 👳 Rejeki anak soleh."
else
advisorMsg := "Lilin hijau! Serok sekarang! 💰"
else if sellSignal
statusText := '📉 TURUN! Entry Baru'
statusColor := color.red
if rand == 0
advisorMsg := "Longsor! 📉 Siapkan ember."
else if rand == 1
advisorMsg := "Merah merona! 🩸 Dompet aman kan?"
else if rand == 2
advisorMsg := "Terjun bebas! 🪂 waspada REM."
else if rand == 3
advisorMsg := "Longsor! 📉 jangan naik dulu."
else
advisorMsg := "Short selling! Cuan tipis sikat! 💸"
else if addBuySignal
statusText := '🚀 GAS LAGI (Add)!'
statusColor := color.blue
if rand == 0
advisorMsg := "Tambah muatan! 😎 Biar bandar nangis."
else
advisorMsg := "Mumpung hijau! 🛒 Sikat lagi bosqu!"
else if addSellSignal
statusText := '📉 GAS LAGI (Add)!'
statusColor := color.fuchsia
if rand == 0
advisorMsg := "Tambah Sell! 🔥 Biar makin perih."
else
advisorMsg := "Tekan bawah! 😤 Jangan kasih napas."
else if reversalCandleExit
statusText := '⛔ EXIT! Pembalikan'
statusColor := color.orange
advisorMsg := "Kabur! 🏃💨 Candle mencurigakan."
else if reversalRiskDetected
statusText := '⚠️ TP NOW!'
statusColor := color.yellow
advisorMsg := "Amankan profit! 🤡 Jangan serakah."
else if profitMaxReached
statusText := '🤑 CUAN BUNGKUS!'
statusColor := color.aqua
if rand == 0
advisorMsg := "Cuan bungkus! 🍜 Traktir seblak dong."
else if rand == 1
advisorMsg := "Udah kaya? 💅 Tarik buat skincare!"
else
advisorMsg := "Alhamdulillah! 🎁 Rejeki jangan ditolak."
else if waspada
statusText := '💔 HATI-HATI!'
statusColor := color.orange
if rand == 0
advisorMsg := "Dia toxic... 🚩 Hati-hati SL."
else
advisorMsg := "Awas MC! 💀 pasang SL+ sayang."
else if pos == 1
statusText := '🧘 TAHAN Buy...'
statusColor := color.green
if rand == 0
advisorMsg := "Sabar sayang... 🧘♀️ Disayang Tuhan."
else if rand == 1
advisorMsg := "Biarkan lari! 🏃♂️ Profit is running."
else
advisorMsg := "Hold terus! 🚀 Sampai ke bulan!"
else if pos == -1
statusText := '🍿 TAHAN Sell...'
statusColor := color.red
if rand == 0
advisorMsg := "Nonton aja... 🍿 Sambil ngemil."
else
advisorMsg := "Jatuh kebawah sakit? 😂 disini malah Cuan."
else if blockReason != ''
statusText := "DIBLOKIR"
statusColor := color.gray
advisorMsg := "Sinyal busuk! ⛔ Jangan masuk."
else
statusText := '... '
statusColor := color.gray
if rand == 0
advisorMsg := "Market galau... 💤 Mending turu."
else if rand == 1
advisorMsg := "Datar banget... 😑 Kek jalan tol."
else if rand == 2
advisorMsg := "Jangan maksa! ☕ Ngopi dulu."
else
advisorMsg := "Sabar... 🕰️ Menunggu itu berat."
if adxValue > adxMinLevel and diPlus > diMinus
marketModeText := "📈 Tren Naik Kuat"
marketModeColor := color.new(color.green, 0)
else if adxValue > adxMinLevel and diMinus > diPlus
marketModeText := "📉 Tren Turun Kuat"
marketModeColor := color.new(color.red, 0)
else
marketModeText := "💤 Sideways / Chop"
marketModeColor := color.new(color.gray, 0)
f_fillCell(tbl, col, row, cellText, color) =>
table.cell(tbl, col, row, cellText, text_color=color, text_size=size.small)
f_drawDashboard() =>
f_fillCell(dashboardPanel, 0, 0, "Gaya:", color.gray)
f_fillCell(dashboardPanel, 1, 0, tradingStyle, color.white)
f_fillCell(dashboardPanel, 0, 1, "Status:", color.gray)
f_fillCell(dashboardPanel, 1, 1, statusText, statusColor)
bool dashboardContextIsBuy = pos == 1 or (pos == 0 and close > open)
string emaStatus = (dashboardContextIsBuy ? emaOkForBuy : emaOkForSell) or not _useEmaFilter ? "✅" : "❌"
string rsiStatus = (dashboardContextIsBuy ? rsiOkForBuy : rsiOkForSell) or not _useRsiFilter ? "✅" : "❌"
string adxStatus = (dashboardContextIsBuy ? adxOkForBuy : adxOkForSell) or not _useAdxFilter ? "✅" : "❌"
string snrStatus = (dashboardContextIsBuy ? snrOkForBuy : snrOkForSell) or not _useSnrFilter ? "✅" : "❌"
string confirmStatus = (dashboardContextIsBuy ? confirmOkForBuy : confirmOkForSell) or not useConfirmFilter ? "✅" : "❌"
string filterStr1 = "EMA" + emaStatus + " RSI" + rsiStatus
string filterStr2 = "ADX" + adxStatus + " SNR" + snrStatus + (useConfirmFilter ? " 1-Bar" + confirmStatus : "")
string filterString = filterStr1 + " " + filterStr2
f_fillCell(dashboardPanel, 0, 2, "Filter:", color.gray)
f_fillCell(dashboardPanel, 1, 2, filterString, color.white)
float body_m = math.abs(close - open)
float rangeC_m = high - low
float power_m = rangeC_m == 0 ? 0.0 : (body_m / rangeC_m) * 5
power_m := math.min(power_m, 5)
float confidence_m = rangeC_m == 0 ? 0.0 : math.round(math.abs((close - open) / (high - low)) * 100)
int powerInt_m = int(math.round(power_m))
powerInt_m := powerInt_m < 0 ? 0 : powerInt_m > 5 ? 5 : powerInt_m
string bars_m = str.repeat("█", powerInt_m) + str.repeat("░", 5 - powerInt_m)
string meterString = (close > open ? "🟢 " : "🔴 ") + bars_m + " " + str.tostring(confidence_m, "#") + "%"
f_fillCell(dashboardPanel, 0, 3, "Meter:", color.gray)
f_fillCell(dashboardPanel, 1, 3, meterString, (close > open ? color.green : color.red))
int totalTrades = tradeCount_wins + tradeCount_losses
f_fillCell(dashboardPanel, 0, 4, "Total Sinyal:", color.gray)
f_fillCell(dashboardPanel, 1, 4, str.tostring(totalTrades), color.white)
f_fillCell(dashboardPanel, 0, 5, "W / L:", color.gray)
f_fillCell(dashboardPanel, 1, 5, str.tostring(tradeCount_wins) + " / " + str.tostring(tradeCount_losses), color.white)
string winRateString = "N/A"
color winRateColor = color.gray
if totalTrades > 0
winRateString := str.tostring(tradeCount_wins / totalTrades * 100, '0.0') + "%"
winRateColor := tradeCount_wins > tradeCount_losses ? color.green : (tradeCount_losses > tradeCount_wins ? color.red : color.gray)
f_fillCell(dashboardPanel, 0, 6, "Win Rate:", color.gray)
f_fillCell(dashboardPanel, 1, 6, winRateString, winRateColor)
f_fillCell(dashboardPanel, 0, 7, "Pasar:", color.gray)
f_fillCell(dashboardPanel, 1, 7, marketModeText, marketModeColor)
table.merge_cells(dashboardPanel, 0, 8, 1, 8)
table.cell(dashboardPanel, 0, 8, advisorMsg, text_color=color.yellow, text_size=size.small, bgcolor=color.new(color.black, 50))
table.merge_cells(dashboardPanel, 0, 9, 1, 9)
table.cell(dashboardPanel, 0, 9, "HADYAN PREMIUM INDI 083174747475", text_color=color.new(#969087, 66), text_size=size.tiny)
if barstate.islast and showDashboard
f_drawDashboard()
else if barstate.islast
table.clear(dashboardPanel, 0, 0, 1, 9)
// ==============================================
// --- FLOATING BUBBLE LABEL (FIXED) ---
// ==============================================
var label advisorLabel = na
if barstate.islast
label.delete(advisorLabel)
if showAdvisorBubble
// Tentukan Warna Gelembung biar Cantik
color bubbleColor = color.new(color.gray, 20)
if buySignal or addBuySignal or pos == 1
bubbleColor := color.new(color.green, 20)
else if sellSignal or addSellSignal or pos == -1
bubbleColor := color.new(color.red, 20)
else if waspada or reversalCandleExit
bubbleColor := color.new(color.orange, 20)
// OPTIMIZED: Geser sedikit ke kanan (+2) agar tidak menutupi candle terakhir
advisorLabel := label.new(bar_index + 2, close, text=advisorMsg, color=bubbleColor, textcolor=color.white, style=label.style_label_left, yloc=yloc.price)
// ==============================================
// --- LOGIKA CANDLE METER PANEL ---
// ==============================================
if (showCandlePanel or showCandleArrows) and not showDashboard
float body_m = math.abs(close - open)
float rangeC_m = high - low
float power_m = rangeC_m == 0 ? 0.0 : (body_m / rangeC_m) * 5
power_m := math.min(power_m, 5)
float confidence_m = rangeC_m == 0 ? 0.0 : math.round(math.abs((close - open) / (high - low)) * 100)
string patternName_m = ""
string baseDir_m = close > open ? "BUY" : "SELL"
if isBullishEngulfing_m
patternName_m := "Bullish Engulfing"
baseDir_m := "BUY"
else if isBearishEngulfing_m
patternName_m := "Bearish Engulfing"
baseDir_m := "SELL"
else if isHammer_m
patternName_m := "Hammer"
baseDir_m := "BUY"
else if isInvertedHammer_m
patternName_m := "Inverted Hammer"
baseDir_m := "SELL"
else
patternName_m := "Normal Candle"
string trendConfirm_m = close > close and close > close ? "BUY" : close < close and close < close ? "SELL" : baseDir_m
finalDir_m := baseDir_m == trendConfirm_m ? baseDir_m : baseDir_m
if showCandlePanel
int powerInt_m = int(math.round(power_m))
powerInt_m := powerInt_m < 0 ? 0 : powerInt_m > 5 ? 5 : powerInt_m
string bars_m = str.repeat("█", powerInt_m) + str.repeat("░", 5 - powerInt_m)
string dirText_m = finalDir_m == "BUY" ? "🟢 BUY" : "🔴 SELL"
string confText_m = str.tostring(confidence_m, "#") + "% " + bars_m
table.cell(infoPanel_m, 0, 0, "Pattern", text_color=color.yellow)
table.cell(infoPanel_m, 1, 0, "Direction", text_color=color.yellow)
table.cell(infoPanel_m, 2, 0, "Confidence", text_color=color.yellow)
table.cell(infoPanel_m, 0, 1, patternName_m, text_color=color.white)
table.cell(infoPanel_m, 1, 1, dirText_m, text_color=color.white)
table.cell(infoPanel_m, 2, 1, confText_m, text_color=color.white)
else
table.clear(infoPanel_m, 0, 0, 2, 1)
else if not showDashboard
table.clear(infoPanel_m, 0, 0, 2, 1)
// ==============================================
// --- ALERT UPDATED (SINGLE ALERT SUPPORT) ---
// ==============================================
string alertMsg_all = ""
if buySignal
alertMsg_all := "🚀 BUY NEW! @ " + str.tostring(close) + " | SL: " + str.tostring(xATRTrailingStopAdj)
else if sellSignal
alertMsg_all := "📉 SELL NEW! @ " + str.tostring(close) + " | SL: " + str.tostring(xATRTrailingStopAdj)
else if addBuySignal
alertMsg_all := "➕ ADD BUY (Re-Entry) @ " + str.tostring(close)
else if addSellSignal
alertMsg_all := "➕ ADD SELL (Re-Entry) @ " + str.tostring(close)
else if reversalCandleExit
alertMsg_all := "⛔ EXIT NOW! Reversal Detected @ " + str.tostring(close)
else if profitMaxReached
alertMsg_all := "💰 TAKE PROFIT! Target Tercapai @ " + str.tostring(close)
else if reversalRiskDetected
alertMsg_all := "⚠️ WARNING REVERSAL! RSI Extreme @ " + str.tostring(close)
// Pemicu Alarm Utama (Hanya aktif jika ada pesan, cukup pasang 1 alarm "Any function call")
if alertMsg_all != ""
alert(alertMsg_all, alert.freq_once_per_bar_close)
// Backup: Manual Alerts (Jika user Premium mau pasang satu-satu)
alertcondition(buySignal, title=' Buy Signal', message='🚀 BUY NEW!')
alertcondition(sellSignal, title=' Sell Signal', message='📉 SELL NEW!')
alertcondition(addBuySignal, title=' Add Buy', message='🚀 ADD BUY')
alertcondition(addSellSignal, title=' Add Sell', message='📉 ADD SELL')
alertcondition(waspada, title=' Waspada', message='💔 WASPADA')
// ==============================================
// --- TP/SL MODE SWING (FIXED & OPTIMIZED) ---
// ==============================================
var line sl_line = na
var line tp1_line = na
var line tp2_line = na
var line tp3_line = na
var label sl_label = na
var label tp1_label = na
var label tp2_label = na
var label tp3_label = na
if tradingStyle == 'Swing Santai'
if buySignal
line.delete(sl_line)
line.delete(tp1_line)
line.delete(tp2_line)
line.delete(tp3_line)
label.delete(sl_label)
label.delete(tp1_label)
label.delete(tp2_label)
label.delete(tp3_label)
float sl = entryPrice - entryNloss
float tp1 = entryPrice + entryNloss
float tp2 = entryPrice + (2*entryNloss)
float tp3 = entryPrice + (3*entryNloss)
sl_line := line.new(bar_index, sl, bar_index + 10, sl, color=color.new(color.red, 20), style=line.style_dashed, width=2)
tp1_line := line.new(bar_index, tp1, bar_index + 10, tp1, color=color.new(color.green, 20), style=line.style_dashed, width=2)
tp2_line := line.new(bar_index, tp2, bar_index + 10, tp2, color=color.new(color.green, 20), style=line.style_dashed, width=2)
tp3_line := line.new(bar_index, tp3, bar_index + 10, tp3, color=color.new(color.green, 20), style=line.style_dashed, width=2)
sl_label := label.new(bar_index + 10, sl, "SL (Rugi)", color=color.red, style=label.style_label_left, textcolor=color.white)
tp1_label := label.new(bar_index + 10, tp1, "TP1 (1:1)", color=color.green, style=label.style_label_left, textcolor=color.white)
tp2_label := label.new(bar_index + 10, tp2, "TP2 (1:2)", color=color.green, style=label.style_label_left, textcolor=color.white)
tp3_label := label.new(bar_index + 10, tp3, "TP3 (1:3)", color=color.green, style=label.style_label_left, textcolor=color.white)
else if sellSignal
line.delete(sl_line)
line.delete(tp1_line)
line.delete(tp2_line)
line.delete(tp3_line)
label.delete(sl_label)
label.delete(tp1_label)
label.delete(tp2_label)
label.delete(tp3_label)
float sl = entryPrice + entryNloss
float tp1 = entryPrice - entryNloss
float tp2 = entryPrice - (2*entryNloss)
float tp3 = entryPrice - (3*entryNloss)
sl_line := line.new(bar_index, sl, bar_index + 10, sl, color=color.new(color.red, 20), style=line.style_dashed, width=2)
tp1_line := line.new(bar_index, tp1, bar_index + 10, tp1, color=color.new(color.green, 20), style=line.style_dashed, width=2)
tp2_line := line.new(bar_index, tp2, bar_index + 10, tp2, color=color.new(color.green, 20), style=line.style_dashed, width=2)
tp3_line := line.new(bar_index, tp3, bar_index + 10, tp3, color=color.new(color.green, 20), style=line.style_dashed, width=2)
sl_label := label.new(bar_index + 10, sl, "SL (Rugi)", color=color.red, style=label.style_label_left, textcolor=color.white)
tp1_label := label.new(bar_index + 10, tp1, "TP1 (1:1)", color=color.green, style=label.style_label_left, textcolor=color.white)
tp2_label := label.new(bar_index + 10, tp2, "TP2 (1:2)", color=color.green, style=label.style_label_left, textcolor=color.white)
tp3_label := label.new(bar_index + 10, tp3, "TP3 (1:3)", color=color.green, style=label.style_label_left, textcolor=color.white)
else if pos != 0 and not na(sl_line)
// Update existing lines (Lightweight)
line.set_x2(sl_line, bar_index + 10)
line.set_x2(tp1_line, bar_index + 10)
line.set_x2(tp2_line, bar_index + 10)
line.set_x2(tp3_line, bar_index + 10)
label.set_x(sl_label, bar_index + 10)
label.set_x(tp1_label, bar_index + 10)
label.set_x(tp2_label, bar_index + 10)
label.set_x(tp3_label, bar_index + 10)
else if pos == 0
line.delete(sl_line)
sl_line := na
line.delete(tp1_line)
tp1_line := na
line.delete(tp2_line)
tp2_line := na
line.delete(tp3_line)
tp3_line := na
label.delete(sl_label)
sl_label := na
label.delete(tp1_label)
tp1_label := na
label.delete(tp2_label)
tp2_label := na
label.delete(tp3_label)
tp3_label := na
else
line.delete(sl_line)
sl_line := na
line.delete(tp1_line)
tp1_line := na
line.delete(tp2_line)
tp2_line := na
line.delete(tp3_line)
tp3_line := na
label.delete(sl_label)
sl_label := na
label.delete(tp1_label)
tp1_label := na
label.delete(tp2_label)
tp2_label := na
label.delete(tp3_label)
tp3_label := na
// ==============================================
// --- UPGRADE BARU: PIVOT POINTS (FIXED: EXTEND RIGHT) ---
// ==============================================
// Dapatkan Daily High, Low, Close (FIX "D")
p_d_h = request.security(syminfo.tickerid, "D", high , lookahead=barmerge.lookahead_on)
p_d_l = request.security(syminfo.tickerid, "D", low , lookahead=barmerge.lookahead_on)
p_d_c = request.security(syminfo.tickerid, "D", close , lookahead=barmerge.lookahead_on)
// Perhitungan Pivot Klasik
pivot_d = (p_d_h + p_d_l + p_d_c) / 3
r1_d = 2 * pivot_d - p_d_l
s1_d = 2 * pivot_d - p_d_h
r2_d = pivot_d + (p_d_h - p_d_l)
s2_d = pivot_d - (p_d_h - p_d_l)
// Visualisasi Pivot
var line p_line = na
var line r1_line = na
var line s1_line = na
var line r2_line = na
var line s2_line = na
var label p_label = na
var label r1_label = na
var label s1_label = na
var label r2_label = na
var label s2_label = na
// Fungsi untuk menghapus label/line
f_delete_pivot_objects() =>
line.delete(p_line)
line.delete(r1_line)
line.delete(s1_line)
line.delete(r2_line)
line.delete(s2_line)
label.delete(p_label)
label.delete(r1_label)
label.delete(s1_label)
label.delete(r2_label)
label.delete(s2_label)
if showPivotPoints
// Hapus yang lama agar tidak numpuk (Redraw Logic)
f_delete_pivot_objects()
// Logic: EXTEND RIGHT (Memanjang)
// Kita gunakan extend.right agar garisnya tidak pernah putus ke kanan
// Pivot (P)
p_line := line.new(bar_index, pivot_d, bar_index + 1, pivot_d, xloc.bar_index, extend.right, pivotColor, line.style_solid, 2)
p_label := label.new(bar_index + 10, pivot_d, "P Daily: " + str.tostring(pivot_d, format.mintick), xloc.bar_index, yloc.price, color=color.new(pivotColor, 20), textcolor=color.white, style=label.style_label_left, size=size.small)
// Resistance
r1_line := line.new(bar_index, r1_d, bar_index + 1, r1_d, xloc.bar_index, extend.right, color.new(color.red, 30), line.style_dashed, 1)
r1_label := label.new(bar_index + 10, r1_d, "R1: " + str.tostring(r1_d, format.mintick), xloc.bar_index, yloc.price, color=color.new(color.red, 80), textcolor=color.red, style=label.style_label_left, size=size.small)
r2_line := line.new(bar_index, r2_d, bar_index + 1, r2_d, xloc.bar_index, extend.right, color.new(color.red, 30), line.style_dashed, 1)
r2_label := label.new(bar_index + 10, r2_d, "R2: " + str.tostring(r2_d, format.mintick), xloc.bar_index, yloc.price, color=color.new(color.red, 80), textcolor=color.red, style=label.style_label_left, size=size.small)
// Support
s1_line := line.new(bar_index, s1_d, bar_index + 1, s1_d, xloc.bar_index, extend.right, color.new(color.green, 30), line.style_dashed, 1)
s1_label := label.new(bar_index + 10, s1_d, "S1: " + str.tostring(s1_d, format.mintick), xloc.bar_index, yloc.price, color=color.new(color.green, 80), textcolor=color.green, style=label.style_label_left, size=size.small)
s2_line := line.new(bar_index, s2_d, bar_index + 1, s2_d, xloc.bar_index, extend.right, color.new(color.green, 30), line.style_dashed, 1)
s2_label := label.new(bar_index + 10, s2_d, "S2: " + str.tostring(s2_d, format.mintick), xloc.bar_index, yloc.price, color=color.new(color.green, 80), textcolor=color.green, style=label.style_label_left, size=size.small)
else
f_delete_pivot_objects()
// ==============================================
// --- UPGRADE BARU: FIBONACCI RETRACEMENT (CLEAN NO STACK) ---
// ==============================================
var float fiboHigh = na
var float fiboLow = na
var int fiboStartBar = na
// Array untuk menyimpan objek Fibo
var line fiboLines = array.new(0)
var linefill fiboFills = array.new(0)
var label fiboLabels = array.new(0)
// Helper Function: Clean Up All Fibo Objects
f_cleanFibo() =>
if array.size(fiboLines) > 0
for i = 0 to array.size(fiboLines) - 1
line.delete(array.get(fiboLines, i))
array.clear(fiboLines)
if array.size(fiboFills) > 0
for i = 0 to array.size(fiboFills) - 1
linefill.delete(array.get(fiboFills, i))
array.clear(fiboFills)
if array.size(fiboLabels) > 0
for i = 0 to array.size(fiboLabels) - 1
label.delete(array.get(fiboLabels, i))
array.clear(fiboLabels)
// Calculate historical values globally
float lastHigh_scanned = ta.valuewhen(not na(pivotHigh), pivotHigh, 0)
float lastLow_scanned = ta.valuewhen(not na(pivotLow), pivotLow, 0)
// Reset Fibo jika ada sinyal entry baru
if buySignal or sellSignal
f_cleanFibo() // Clean old ones first!
// Gunakan nilai yang sudah di-scan secara global
if not na(lastHigh_scanned) and not na(lastLow_scanned)
fiboLow := lastLow_scanned
fiboHigh := lastHigh_scanned
fiboStartBar := bar_index
// Levels
fiboLevels = array.new(0)
array.push(fiboLevels, 0.0)
array.push(fiboLevels, 0.236)
array.push(fiboLevels, 0.382)
array.push(fiboLevels, 0.5)
array.push(fiboLevels, 0.618)
array.push(fiboLevels, 1.0)
// Gambar Fibo (Hanya digambar ulang jika posisi valid dan belum ada)
// Kita gunakan trik: Gambar setiap bar, tapi HAPUS yang lama dulu.
// Ini mencegah stacking ribuan kotak.
if showFiboLevels and not na(fiboHigh) and not na(fiboLow)
f_cleanFibo() // CLEANUP WAJIB SEBELUM GAMBAR BARU
float fiboRange = fiboHigh - fiboLow
int f_start = bar_index + fiboXOffset
int f_end = bar_index + fiboXOffset + 15
var line lastLineObj = na
for i = 0 to array.size(fiboLevels) - 1
float level = array.get(fiboLevels, i)
float fiboPrice = fiboHigh - (fiboRange * level)
string levelText = str.tostring(math.round(level * 100), "0.0") + "%"
color levelColor = color.rgb(19, 56, 189)
if level == 0.618
levelColor := color.new(#FFD700, 30)
else if level == 0.5
levelColor := color.new(color.green, 30)
else
levelColor := color.new(#7925c9, 70)
string l_style = (level == 0.0 or level == 1.0) ? line.style_dashed : line.style_solid
int l_width = (level == 0.618 or level == 0.5) ? 2 : 1
// Draw & Push Line
line currentLineObj = line.new(f_start, fiboPrice, f_end, fiboPrice, xloc.bar_index, extend.none, levelColor, l_style, l_width)
array.push(fiboLines, currentLineObj)
// Fill Logic
color c_fill = switch level
0.236 => color.new(color.gray, 70) // Sangat transparan (95)
0.382 => color.new(color.blue, 70)
0.5 => color.new(color.green, 70)
0.618 => color.new(#FFD700, 70)
1.0 => color.new(color.red, 70)
=> na
if i > 0
linefill lf = linefill.new(lastLineObj, currentLineObj, c_fill)
array.push(fiboFills, lf)
lastLineObj := currentLineObj
// Draw & Push Label
label lb = label.new(f_end, fiboPrice, levelText, xloc.bar_index, yloc.price, color=color.new(levelColor, 100), textcolor=levelColor, style=label.style_label_left, size=size.small)
array.push(fiboLabels, lb)
// ==============================================
// --- UPGRADE BARU: STOCHASTIC FLOATING MINI CHART (REALTIME ANCHOR RIGHT PATCH) ---
// ==============================================
// 1. Calculations
stochK = ta.sma(ta.stoch(close, high, low, 14), 3)
stochD = ta.sma(stochK, 3)
// 2. Data Storage (Arrays for History)
var float stochK_hist = array.new_float(0)
var float stochD_hist = array.new_float(0)
// Update Arrays (REALTIME LOGIC)
if barstate.isnew
array.push(stochK_hist, nz(stochK, 50))
array.push(stochD_hist, nz(stochD, 50))
// Limit array size to chart width + 1
if array.size(stochK_hist) > (stochWidth + 1)
array.shift(stochK_hist)
array.shift(stochD_hist)
else
// UPDATE TICK-BY-TICK (Agar tidak delay)
if array.size(stochK_hist) > 0
array.set(stochK_hist, array.size(stochK_hist) - 1, nz(stochK, 50))
array.set(stochD_hist, array.size(stochD_hist) - 1, nz(stochD, 50))
// 3. Drawing Logic
var box stochBgBox = na
var box stochUpperFill = na
var box stochLowerFill = na
var line stochLines = array.new_line(0)
// Clear Function
f_cleanStochChart() =>
if not na(stochBgBox)
box.delete(stochBgBox)
if not na(stochUpperFill)
box.delete(stochUpperFill)
if not na(stochLowerFill)
box.delete(stochLowerFill)
if array.size(stochLines) > 0
for i = 0 to array.size(stochLines) - 1
line.delete(array.get(stochLines, i))
array.clear(stochLines)
// Global Helper to map 0-100 Stoch value to Y price coordinate
f_mapY(_val, _bottom, _height) =>
_bottom + (_val / 100 * _height)
if showStochChart and array.size(stochK_hist) > 2
f_cleanStochChart() // Redraw every tick
// Positioning (ANCHOR RIGHT LOGIC)
int offset_right = 5
int ch_right = bar_index + offset_right // Ujung kanan box
int ch_left = ch_right - stochWidth
// Vertical Scaling
float ch_height = ta.atr(14) * 4
float ch_bottom = close - (ch_height * 1.5)
float ch_top = ch_bottom + ch_height
// Draw Background
stochBgBox := box.new(ch_left, ch_top, ch_right, ch_bottom, xloc=xloc.bar_index, border_width=1, border_color=color.new(color.white, 80), bgcolor=color.new(color.black, 100))
// Draw Overbought Fill (80-100)
stochUpperFill := box.new(ch_left, f_mapY(70, ch_bottom, ch_height), ch_right, f_mapY(80, ch_bottom, ch_height), xloc=xloc.bar_index, border_width=0, bgcolor=color.new(color.red, 100))
// Draw Oversold Fill (0-20)
stochLowerFill := box.new(ch_left, f_mapY(10, ch_bottom, ch_height), ch_right, f_mapY(0, ch_bottom, ch_height), xloc=xloc.bar_index, border_width=0, bgcolor=color.new(color.green, 100))
// Draw Reference Lines
line l80 = line.new(ch_left, f_mapY(80, ch_bottom, ch_height), ch_right, f_mapY(80, ch_bottom, ch_height), color=color.new(color.red, 20), style=line.style_dotted)
line l20 = line.new(ch_left, f_mapY(20, ch_bottom, ch_height), ch_right, f_mapY(20, ch_bottom, ch_height), color=color.new(color.green, 20), style=line.style_dotted)
array.push(stochLines, l80)
array.push(stochLines, l20)
// Draw K and D Lines (ANCHOR TO REALTIME BAR INDEX)
// PATCH: Iterate relative to current bar_index to ensure 0 gap
int sz = array.size(stochK_hist)
for i = 0 to sz - 2
// Logika Mundur: Titik terakhir (sz-1) harus ada di bar_index saat ini
int idx_current = sz - 1 - i
int idx_prev = sz - 2 - i
if idx_prev >= 0
// X Coordinates (Relative to Realtime Bar)
int x2 = bar_index - i
int x1 = bar_index - (i + 1)
// K Line
float yK1 = f_mapY(array.get(stochK_hist, idx_prev), ch_bottom, ch_height)
float yK2 = f_mapY(array.get(stochK_hist, idx_current), ch_bottom, ch_height)
if not na(yK1) and not na(yK2)
line lK = line.new(x1, yK1, x2, yK2, color=color.new(#05492f, 0), width=1)
array.push(stochLines, lK)
// D Line
float yD1 = f_mapY(array.get(stochD_hist, idx_prev), ch_bottom, ch_height)
float yD2 = f_mapY(array.get(stochD_hist, idx_current), ch_bottom, ch_height)
if not na(yD1) and not na(yD2)
line lD = line.new(x1, yD1, x2, yD2, color=color.new(#810404, 0), width=1)
array.push(stochLines, lD)
// ==============================================
// --- VISUALISASI UPGRADE: SMART SUPPLY/DEMAND ZONES ---
// ==============================================
ph_zone = ta.pivothigh(high, zoneLookback, zoneLookback)
pl_zone = ta.pivotlow(low, zoneLookback, zoneLookback)
// FIX: Pindahkan ATR ke luar IF agar konsisten
float atrForZone = ta.atr(14)
var box supplyBoxes = array.new_box()
var box demandBoxes = array.new_box()
// Batasi jumlah zona agar chart tetap bersih
maxZones = 5
// Deteksi Zona Supply (Merah)
if not na(ph_zone) and showSmartZones
// Buat box baru dari titik pivot sampai ke masa depan sedikit
b_sup = box.new(bar_index , high , bar_index + 20, high - (atrForZone*0.5), bgcolor=color.new(color.red, 85), border_color=color.new(color.red, 50))
array.push(supplyBoxes, b_sup)
if array.size(supplyBoxes) > maxZones
box.delete(array.shift(supplyBoxes))
// Deteksi Zona Demand (Hijau)
if not na(pl_zone) and showSmartZones
b_dem = box.new(bar_index , low , bar_index + 20, low + (atrForZone*0.5), bgcolor=color.new(color.lime, 85), border_color=color.new(color.lime, 50))
array.push(demandBoxes, b_dem)
if array.size(demandBoxes) > maxZones
box.delete(array.shift(demandBoxes))
// Perpanjang Zona Secara Realtime
if array.size(supplyBoxes) > 0 and showSmartZones
for i = 0 to array.size(supplyBoxes) - 1
b = array.get(supplyBoxes, i)
// Perpanjang ke bar saat ini + 5 agar terlihat "hidup"
box.set_right(b, bar_index + 5)
if array.size(demandBoxes) > 0 and showSmartZones
for i = 0 to array.size(demandBoxes) - 1
b = array.get(demandBoxes, i)
// Perpanjang ke bar saat ini + 5 agar terlihat "hidup"
box.set_right(b, bar_index + 5)
// ====================================================================================================
// BAGIAN 2: FITUR TAMBAHAN (HSN GHOST CANDLES) - DI-INJECT DI SINI
// ====================================================================================================
// --- TIPE DATA KHUSUS (HSN) ---
type CandleHSN
float o
float c
float h
float l
int o_idx
int c_idx
int h_idx
int l_idx
box body
line wick_up
line wick_down
type ImbalanceHSN
box b
int idx
type CandleSettingsHSN
bool show
string htf
int max_display
type SettingsHSN
int max_sets
color bull_body
color bull_border
color bull_wick
color bear_body
color bear_border
color bear_wick
int offset
int buffer
int htf_buffer
int width
bool trace_show
string trace_anchor
bool label_show
color label_color
string label_size
bool htf_label_show
color htf_label_color
string htf_label_size
bool htf_timer_show
color htf_timer_color
string htf_timer_size
type CandleSetHSN
CandleHSN candles
ImbalanceHSN imbalances
CandleSettingsHSN settings
label tfName
label tfTimer
type HelperHSN
string name = "Helper"
// --- SETUP PENGATURAN HSN ---
SettingsHSN settings = SettingsHSN.new()
var CandleSettingsHSN SettingsHTF1 = CandleSettingsHSN.new()
var CandleSettingsHSN SettingsHTF2 = CandleSettingsHSN.new()
var CandleHSN candles_1 = array.new(0)
var CandleHSN candles_2 = array.new(0)
var CandleSetHSN htf1 = CandleSetHSN.new()
htf1.settings := SettingsHTF1
htf1.candles := candles_1
var CandleSetHSN htf2 = CandleSetHSN.new()
htf2.settings := SettingsHTF2
htf2.candles := candles_2
// --- INPUT KHUSUS HSN CANDLES (15 & 30 MENIT) ---
grp_hsn = "🔥 HSN HTF Candles (Upgrade)"
htf1.settings.show := input.bool(true, "Show HTF 1 (15 Menit)", group=grp_hsn, inline="h1")
htf_1 = input.timeframe("15", "", group=grp_hsn, inline="h1")
htf1.settings.htf := htf_1
htf1.settings.max_display := 4
htf2.settings.show := input.bool(true, "Show HTF 2 (30 Menit)", group=grp_hsn, inline="h2")
htf_2 = input.timeframe("30", "", group=grp_hsn, inline="h2")
htf2.settings.htf := htf_2
htf2.settings.max_display := 4
settings.max_sets := 2
settings.bull_body := color.new(color.green, 60)
settings.bear_body := color.new(color.red, 60)
settings.bull_border := color.new(color.green, 10)
settings.bear_border := color.new(color.red, 10)
settings.bull_wick := color.new(color.green, 10)
settings.bear_wick := color.new(color.red, 10)
// FIXED: Increased default offset from 10 to 25 to avoid overlap with Advisor Bubble
settings.offset := input.int(25, "Padding/Jarak Candle", group=grp_hsn)
settings.buffer := 1
settings.htf_buffer := 5
settings.width := input.int(1, "Lebar Candle", minval = 1, maxval = 4, group=grp_hsn)*2
settings.htf_label_show := true
settings.htf_label_color := color.gray
settings.htf_label_size := size.normal
// --- HELPER FUNCTIONS ---
HelperHSN helper = HelperHSN.new()
color color_transparent = #ffffff00
method ValidTimeframe(HelperHSN helper, string HTF) =>
helper.name := HTF
if timeframe.in_seconds(HTF) >= timeframe.in_seconds("D") and timeframe.in_seconds(HTF) > timeframe.in_seconds()
true
else
n1 = timeframe.in_seconds()
n2 = timeframe.in_seconds(HTF)
n3 = n1 % n2
(n1 < n2 and math.round(n2/n1) == n2/n1)
method HTFName(HelperHSN helper, string HTF) =>
helper.name := "HTFName"
formatted = HTF
seconds = timeframe.in_seconds(HTF)
if seconds < 60
formatted := str.tostring(seconds) + "s"
else if (seconds / 60) < 60
formatted := str.tostring((seconds/60)) + "m"
else if (seconds/60/60) < 24
formatted := str.tostring((seconds/60/60)) + "H"
formatted
method HTFEnabled(HelperHSN helper) =>
helper.name := "HTFEnabled"
int enabled =0
enabled += htf1.settings.show ? 1 : 0
enabled += htf2.settings.show ? 1 : 0
int last = math.min(enabled, settings.max_sets)
last
method CandleSetHigh(HelperHSN helper, CandleHSN candles, float h) =>
helper.name := "CandlesSetHigh"
float _h = h
if array.size(candles) > 0
for i = 0 to array.size(candles)-1
// FIX: Diganti dari c menjadi cItem
CandleHSN cItem = array.get(candles, i)
if cItem.h > _h
_h := cItem.h
_h
method CandlesHigh(HelperHSN helper, CandleHSN candles) =>
helper.name := "CandlesHigh"
h = 0.0
int cnt = 0
int last = helper.HTFEnabled()
if htf1.settings.show and helper.ValidTimeframe(htf1.settings.htf)
h := helper.CandleSetHigh(htf1.candles, h)
cnt += 1
if htf2.settings.show and helper.ValidTimeframe(htf2.settings.htf) and cnt < last
h := helper.CandleSetHigh(htf2.candles, h)
cnt +=1
if array.size(candles) > 0
for i = 0 to array.size(candles)-1
// FIX: Diganti dari c menjadi cItem
CandleHSN cItem = array.get(candles, i)
if cItem.h > h
h := cItem.h
h
method Reorder(CandleSetHSN candleSet, int offset) =>
size = candleSet.candles.size()
if size > 0
for i = size-1 to 0
CandleHSN candle = candleSet.candles.get(i)
t_buffer = offset + ((settings.width+settings.buffer)*(size-i-1))
box.set_left(candle.body, bar_index + t_buffer)
box.set_right(candle.body, bar_index + settings.width + t_buffer)
line.set_x1(candle.wick_up, bar_index+((settings.width)/2) + t_buffer)
line.set_x2(candle.wick_up, bar_index+((settings.width)/2) + t_buffer)
line.set_x1(candle.wick_down, bar_index+((settings.width)/2) + t_buffer)
line.set_x2(candle.wick_down, bar_index+((settings.width)/2) + t_buffer)
top = helper.CandlesHigh(candleSet.candles)
left = bar_index + offset + ((settings.width+settings.buffer)*(size-1))/2
if settings.htf_label_show
var label l = candleSet.tfName
string lbl = helper.HTFName(candleSet.settings.htf)
if not na(l)
label.set_xy(l, left, top)
else
l := label.new(left, top, lbl, color=color_transparent, textcolor = settings.htf_label_color, style=label.style_label_down, size = settings.htf_label_size)
candleSet
method Monitor(CandleSetHSN candleSet) =>
HTFBarTime = time(candleSet.settings.htf)
isNewHTFCandle = ta.change(HTFBarTime)
if isNewHTFCandle
CandleHSN candle = CandleHSN.new()
candle.o := open
candle.c := close
candle.h := high
candle.l := low
candle.o_idx := bar_index
candle.c_idx := bar_index
candle.h_idx := bar_index
candle.l_idx := bar_index
bull = candle.c > candle.o
candle.body := box.new(bar_index, math.max(candle.o, candle.c), bar_index+2, math.min(candle.o, candle.c), bull ? settings.bull_border : settings.bear_border, 1, bgcolor = bull ? settings.bull_body : settings.bear_body)
candle.wick_up := line.new(bar_index+1, candle.h, bar_index, math.max(candle.o, candle.c), color=bull ? settings.bull_wick : settings.bear_wick)
candle.wick_down := line.new(bar_index+1, math.min(candle.o, candle.c), bar_index, candle.l, color=bull ? settings.bull_wick : settings.bear_wick)
candleSet.candles.unshift(candle)
if candleSet.candles.size() > candleSet.settings.max_display
CandleHSN delCandle = array.pop(candleSet.candles)
box.delete(delCandle.body)
line.delete(delCandle.wick_up)
line.delete(delCandle.wick_down)
candleSet
method Update(CandleSetHSN candleSet, int offset) =>
if candleSet.candles.size() > 0
CandleHSN candle = candleSet.candles.first()
candle.h_idx := high > candle.h ? bar_index : candle.h_idx
candle.h := high > candle.h ? high : candle.h
candle.l_idx := low < candle.l ? bar_index : candle.l_idx
candle.l := low < candle.l ? low : candle.l
candle.c := close
candle.c_idx := bar_index
bull = candle.c > candle.o
box.set_top(candle.body, bull ? candle.c : candle.o)
box.set_bottom(candle.body, bull ? candle.o : candle.c)
box.set_bgcolor(candle.body, bull ? settings.bull_body : settings.bear_body)
box.set_border_color(candle.body, bull ? settings.bull_border : settings.bear_border)
line.set_color(candle.wick_up, bull ? settings.bull_wick : settings.bear_wick)
line.set_color(candle.wick_down, bull ? settings.bull_wick : settings.bear_wick)
line.set_y1(candle.wick_up, candle.h)
line.set_y2(candle.wick_up, math.max(candle.o, candle.c))
line.set_y1(candle.wick_down, candle.l)
line.set_y2(candle.wick_down, math.min(candle.o, candle.c))
if barstate.isrealtime or barstate.islast
candleSet.Reorder(offset)
candleSet
// --- EKSEKUSI HSN LOGIC ---
int cnt_hsn = 0
int last_hsn = helper.HTFEnabled()
int offset_hsn = settings.offset
if htf1.settings.show and helper.ValidTimeframe(htf1.settings.htf)
htf1.Monitor().Update(offset_hsn)
cnt_hsn +=1
offset_hsn += cnt_hsn > 0 ? (htf1.candles.size() * settings.width) + (htf1.candles.size() > 0 ? htf1.candles.size()-1 * settings.buffer : 0) + settings.htf_buffer : 0
if htf2.settings.show and helper.ValidTimeframe(htf2.settings.htf) and cnt_hsn < last_hsn
htf2.Monitor().Update(offset_hsn)
cnt_hsn+=1
offset_hsn += cnt_hsn > 0 ? (htf2.candles.size() * settings.width) + (htf2.candles.size() > 0 ? htf2.candles.size()-1 * settings.buffer : 0) + settings.htf_buffer : 0
V5 Momentum Candle PRO (Advanced Momentum and Market Regime)V5 Momentum Candle PRO is a price-action–based momentum indicator designed for XAUUSD on the M5 timeframe, focusing on high-quality impulsive candles while actively filtering out noise, consolidation, and weak market conditions.
This indicator is built to help traders identify strong momentum entries near candle close, making it suitable for scalping and short-term intraday trading.
🔍 Core Logic
The indicator detects momentum candles using a scoring system that evaluates:
Candle body size (pip-based, optimized for XAUUSD)
Body-to-range ratio (to avoid indecision candles)
Upper & lower wick dominance
ATR-based volatility validation
Volume confirmation
Consolidation (core zone) filtering
Only candles that reach a minimum score threshold are considered valid momentum signals.
📈 Trend & Market Regime Filters
To improve signal quality, the indicator includes multiple advanced filters:
Higher Timeframe EMA Trend Filter (default: M15)
Optional counter-trend control
ADX + ATR Market Regime Filter to avoid:
Low volatility conditions
Weak or sideways markets
These filters help reduce false signals during ranging or choppy price action.
📉 RSI Exit Zone (Confirmation Only)
RSI is used only as an exit/confirmation filter, not as a primary entry trigger.
RSI is calculated on a higher timeframe (default: H1)
Helps avoid entries when price is already in a neutral or exhaustion zone
Designed to support momentum continuation, not reversals
⏱ Smart Alert System (Noise Reduction)
This indicator features a time-based alert filter:
Alerts are triggered only during the last 2 minutes before candle close
If a valid entry appears earlier in the candle, the alert will be ignored
This helps traders focus on confirmed momentum near candle close, reducing alert noise and premature signals
Recommended alert setting: Once Per Bar
🎯 Visual Tools
Entry arrows for BUY and SELL signals
Automatic TP & SL projection boxes based on:
Fixed pip values, or
Risk-to-Reward ratio (RR)
HTF EMA and M5 EMA plotted directly on the chart
⚙️ Customization
All key parameters are fully adjustable, including:
Candle body & wick thresholds
ATR and ADX sensitivity
RSI zones and timeframe
Risk management settings (SL, TP, RR)
Alert behavior
This allows traders to adapt the indicator to different sessions (London / New York) or personal trading styles.
⚠️ Disclaimer
This indicator is a technical analysis tool, not a trading strategy and not financial advice.
All trading decisions and risk management are the responsibility of the user.
Lanovyx# Lanovyx
A comprehensive day trading indicator that generates **Pullback**, **Reversal**, and **Breakout** signals using the confluence of Stochastic oscillator lanes, VWAP standard deviation bands, and a unique Setup Window system.
---
## 🎯 Three Signal Families
| Signal | Label | Best For |
|--------|-------|----------|
| **Pullback (P)** | Blue | Trend continuation days |
| **Reversal (R)** | Green/Red | Range-bound markets |
| **Breakout (B)** | Orange | Compression breakouts |
**Strong signals (★)** appear when multiple confluence factors align—these are your highest probability setups.
---
## 📊 How It Works
**1. Regime Detection**
Lanovyx identifies market regime (Bull Trend, Bear Trend, Ranging, Coiling) using EMA alignment, market structure, and VWAP position.
**2. Setup Windows**
Unlike traditional indicators requiring all conditions on the same bar, Lanovyx uses Setup Windows. When a context event occurs (VWAP band touch, S/R level, divergence), a setup activates and stays valid for N bars, allowing the trigger to fire within that window.
**3. Signal Generation**
When regime, VWAP zone, stochastic position, and setup all align—a signal appears on your chart.
---
## 📋 Clean Info Table
The top-right table shows 6 essential rows for quick decision-making:
- **Regime** — Market direction (Bull/Bear Trend, Ranging, Coiling)
- **VWAP Zone** — Price location (Discount for buys, Premium for sells)
- **Stoch %D** — Oscillator position for timing
- **Session** — Market hours status
- **Last Signal** — Most recent signal type
- **Trade** — Current position status
Enable **Debug Mode** for additional diagnostic information.
---
## ✅ Entry Rules
**LONG Setup:**
✓ Regime = BULL TREND (or RANGING for reversal)
✓ VWAP Zone = Discount (-1, -2, -3)
✓ Stoch %D = 20-50 rising
✓ Session = ACTIVE
✓ Signal = P, R, or B below candle
**SHORT Setup:**
✓ Regime = BEAR TREND (or RANGING for reversal)
✓ VWAP Zone = Premium (+1, +2, +3)
✓ Stoch %D = 50-80 falling
✓ Session = ACTIVE
✓ Signal = P, R, or B above candle
---
## ⚙️ Key Features
- **3 Stochastic Lanes** — Fast (14), Mid (21), Slow (55) for multi-timeframe momentum
- **VWAP + Bands** — Session-anchored with ±1σ, ±2σ, ±3σ bands
- **Market Structure** — Higher High/Low, Lower High/Low detection
- **HTF Bias Filter** — Optional higher timeframe trend alignment
- **Volume Analysis** — Spike, dry-up, and climax detection
- **ATR Momentum** — Strong/Moderate/Weak classification
- **Trade Management** — ATR-based stop loss and profit targets
- **Signal Statistics** — Win rate and R-multiple tracking
- **Non-Repainting** — Strict mode enabled by default
- **Per-Direction Cooldown** — Prevents signal spam
---
## 🎛️ Recommended Settings
| Timeframe | Setup Window | Cooldown |
|-----------|--------------|----------|
| 5-minute | 10 bars | 5 bars |
| 15-minute | 10 bars | 5 bars |
---
## 📈 Best On
- **ETFs**: SPY, QQQ, IWM
- **Tech**: TSLA, NVDA, AMD, META, GOOG, AAPL
- **Futures**: MNQ, MES, NQ, ES
---
## ⚠️ Disclaimer
This indicator is for educational purposes only. It is not financial advice. Past performance does not guarantee future results. Always use proper risk management and never risk more than you can afford to lose.
---
## 📝 Version
v3.0
---
**Questions or feedback?** Drop a comment below!
ICT Silver Bullet BoxesOverview
This Pine Script v6 indicator is a streamlined tool designed for ICT (Inner Circle Trader) students, specifically optimized for traders in the Dhaka (GMT+6) time zone. It automates the drawing of high-probability liquidity zones based on the Asian Range and the Silver Bullet algorithm windows.
Unlike standard session highlights, this script focuses on the price action boundaries (Highs and Lows) within these specific windows to help you identify liquidity pools and potential "Judas Swing" targets.
Key Features
Asian Range (Liquidity Phase): Automatically marks the high and low of the 7:00 PM – 12:00 AM NY window (6:00 AM – 11:00 AM Dhaka). This box represents the day's initial consolidation where buy-side and sell-side liquidity is engineered.
Silver Bullet Windows: Highlights the two most critical 60-minute windows:
London Silver Bullet: 3:00 AM – 4:00 AM NY (2:00 PM – 3:00 PM Dhaka)
NY AM Silver Bullet: 10:00 AM – 11:00 AM NY (9:00 PM – 10:00 PM Dhaka)
Automatic DST Adjustment: The script uses the America/New_York timezone internally. This means the boxes will automatically shift correctly when New York enters Daylight Saving Time, keeping your Dhaka chart accurate year-round.
Clean Visuals: Instead of coloring the entire background, the script draws precise boxes around the price action High/Low of each session for a clutter-free experience.
How to Use
Mark Liquidity: Use the Asian Range Box to identify where the "stops" are resting.
Anticipate the Sweep: During the London or NY Open, look for price to raid the Asian High or Low.
Execute the Bullet: Within the Silver Bullet boxes, look for a Market Structure Shift (MSS) and a Fair Value Gap (FVG) for your entry.
Settings
Custom Colors: Fully customizable colors and opacity for both London and New York sessions.
Borders: Toggle borders on/off to match your chart theme.
SuperTrend - With Exits & Trade ZonesSuperTrend - With Exits & Trade Zones
Overview
An advanced trend-following indicator that combines pivot points with the SuperTrend methodology to create a complete trading system with entry signals, exit signals, and visual trade zones. This indicator adapts to market structure rather than just price action, providing more reliable trend identification.
What Makes This Unique
Unlike standard SuperTrend indicators that use moving averages, this version:
Uses actual pivot points to calculate a dynamic center line
Provides multiple entry mode options for different trading styles
Shows clear exit signals (both trailing stop and take profit)
Color-codes the entire chart into trade zones (Long, Short, No Trade)
Eliminates guesswork about when to enter, exit, and stay out
Features
📊 Core Indicator Components
Pivot Point Detection: Identifies local highs and lows in price structure
Dynamic Center Line: Weighted calculation using detected pivot points
ATR-Based Bands: Volatility-adjusted upper and lower bands
Trailing Stop Line: Adaptive stop-loss that follows the trend
🎯 Entry Signals
Four entry modes to match your trading style:
Immediate Mode ⚡
Signals right when the trailing stop breaks
Fastest entries for aggressive traders
Best for strong trending markets
Aggressive Mode 🔥 (Recommended)
Signals when price closes beyond break candle OR opens beyond it
Balanced speed and confirmation
Good for most market conditions
Balanced Mode ⚖️
Requires entire candle to close beyond break level
Moderate confirmation
Reduces false breakouts
Conservative Mode 🛡️
Waits for candle to open AND stay completely beyond break level
Highest confirmation, slowest entries
Best for choppy markets
🚪 Exit Signals
Three exit strategies:
Trailing Stop
Exits when price crosses back through the trailing stop line
Lets profits run in trending markets
Protects gains when trend weakens
Take Profit %
Exits at predetermined profit target
Locks in gains at specific percentage
Good for range-bound markets
Both
Uses whichever exit comes first
Combines profit protection with trend following
Recommended for most traders
🎨 Visual Trade Zones
Color-coded backgrounds eliminate confusion:
🟢 Light Green: Active LONG position
🔴 Light Red: Active SHORT position
⚫ Gray: NO TRADE ZONE (between exit and next signal)
📍 Additional Visual Elements
Diamond markers: Show when trailing stop is first broken
BUY/SELL labels: Clear entry signals in green/red
EXIT markers: Gray X for stop loss, Orange X (TP) for take profit
Pivot points: Optional display of detected highs/lows (H/L markers)
Support/Resistance: Optional circles at pivot levels
Settings & Parameters
Basic Settings
Pivot Point Period (default: 2)
Controls sensitivity of pivot detection
Lower = more pivots detected (more responsive)
Higher = fewer pivots (more stable)
ATR Factor (default: 3)
Distance multiplier for trailing stop bands
Lower = tighter stops (more signals, earlier exits)
Higher = wider stops (fewer signals, longer trades)
ATR Period (default: 10)
Lookback period for volatility calculation
Affects how quickly bands adapt to volatility changes
Entry Configuration
Entry Mode: Select from Immediate/Aggressive/Balanced/Conservative
Determines how quickly the indicator generates signals after a trend break
Exit Configuration
Exit Method: Choose Trailing Stop, Take Profit %, or Both
Take Profit % (default: 2%)
Set your profit target as percentage of entry price
Adjust based on volatility and timeframe
Display Options
Show Buy/Sell Labels: Toggle entry signal labels
Show Exit Signals: Toggle exit markers
Show Break Candles: Toggle diamond markers on trend breaks
Show Pivot Points: Display H/L markers at pivot points
Show PP Center Line: Display the dynamic center line
Show Support/Resistance: Display circles at S/R levels
How to Use
For Swing Traders
Set Entry Mode to "Balanced" or "Conservative"
Use "Both" exit method with 3-5% take profit
Enable all visual elements for complete market picture
Trade only in direction of colored zones
For Day Traders
Set Entry Mode to "Aggressive" or "Immediate"
Use "Trailing Stop" exit method to catch intraday trends
Lower ATR Factor to 2-2.5 for tighter stops
Watch for quick signals in the first 2 hours of trading
For Position Traders
Use higher timeframes (Daily/Weekly)
Set Entry Mode to "Conservative"
Increase Take Profit % to 5-10%
Use larger ATR Factor (4-5) for wider stops
General Trading Rules
✅ DO: Enter on BUY/SELL signals (green/red backgrounds)
✅ DO: Exit on EXIT/TP markers
❌ DON'T: Enter during gray NO TRADE ZONE
❌ DON'T: Counter-trend trade against the colored zone
Alerts
Set up the following alerts for automated trading notifications:
Buy Signal: Triggers when long entry conditions are met
Sell Signal: Triggers when short entry conditions are met
Exit Long: Triggers when long position should be closed
Exit Short: Triggers when short position should be closed
Trailing Stop Broken: Triggers on initial trend change
Best Practices
Timeframe Selection
1-5 min: Scalping (use Immediate/Aggressive mode)
15-60 min: Day trading (use Aggressive/Balanced mode)
4H-Daily: Swing trading (use Balanced/Conservative mode)
Weekly: Position trading (use Conservative mode)
Risk Management
Always use the EXIT signals - don't hold through gray zones
Position size based on distance to trailing stop
Never risk more than 1-2% per trade
Consider wider stops on higher timeframes
Market Conditions
Trending markets: Use Aggressive mode, Trailing Stop exits
Ranging markets: Use Conservative mode, Take Profit exits
High volatility: Increase ATR Factor, use Both exits
Low volatility: Decrease ATR Factor for tighter stops
Technical Details
Calculation Method
Detect pivot highs and lows using specified period
Calculate weighted center line: (previous_center × 2 + new_pivot) / 3
Calculate bands: Upper = Center - (ATR Factor × ATR), Lower = Center + (ATR Factor × ATR)
Determine trend based on price position relative to bands
Trail stop line follows the active trend direction
Signal Logic
Entry signals generated based on selected confirmation mode
Position tracking maintains state from entry to exit
Exit signals calculated from both trailing stop and take profit levels
Trade zones update in real-time based on position state
Limitations & Considerations
Works best in trending markets; may generate false signals in tight ranges
Not a holy grail - should be used with proper risk management
Past performance does not guarantee future results
Recommended to backtest on your specific instrument and timeframe
Consider combining with volume analysis or other indicators for confirmation
Version History
v1.0: Initial release with entry signals and confirmation modes
v1.1: Added exit signals (trailing stop and take profit)
v1.2: Added color-coded trade zones (Long/Short/No Trade)
Credits
Original Pivot Point SuperTrend concept by LonesomeTheBlue
Modified with exit signals and trade zone visualization
License
Mozilla Public License 2.0
Example Setups
Conservative Swing Trading
Pivot Point Period: 2
ATR Factor: 3
ATR Period: 10
Entry Mode: Conservative
Exit Method: Both
Take Profit %: 4%
Aggressive Day Trading
Pivot Point Period: 2
ATR Factor: 2.5
ATR Period: 10
Entry Mode: Aggressive
Exit Method: Trailing Stop
Position Trading
Pivot Point Period: 3
ATR Factor: 4
ATR Period: 14
Entry Mode: Balanced
Exit Method: Both
Take Profit %: 8%
Disclaimer: This indicator is for educational purposes only. Trading involves substantial risk. Always do your own research and never trade with money you cannot afford to lose.
Universal Strategy Adapter - Connect Anything, Backtest EverythiDescription The Universal Strategy Adapter is a powerful utility that allows you to turn ANY indicator into a backtestable strategy without writing a single line of code. Whether you want to trade based on a simple crossover, a specific threshold, or complex multi-indicator confluence, this adapter handles the logic, execution, and risk management for you.
Key Features
Connect Up To 8 Indicators Plug in up to 8 different data sources using the input.source dropdowns. Mix and match indicators (e.g., RSI + MACD + Moving Average).
Advanced Logic Engine Mandatory vs. Optional : Distinct "Must Have" signals vs. "Nice to Have" confluence. Min Optionals Required : Require at least X optional indicators to fire before taking a trade. Lookback Persistence : Solves the "Sync" problem. If Indicator A fires on candle 1 and Indicator B fires on candle 3, the Lookback window ensures they still count as a confluence setup.
Flexible Conditions For each slot, choose how the signal is interpreted: Signal (!= 0) : Best for "Event" indicators like Golden Dots or Alerts. Price > Source : Trend Filters (e.g., Price above EMA 200). Source > Threshold : Value filters (e.g., RSI > 50). Rising / Falling : Momentum filters (e.g., RSI is trending up compared to 12 bars ago).
Risk Management & Cooldown Built-in Stop Loss and Take Profit (%) settings. Trade Cooldown : Prevent "Machine Gun" trades by enforcing a wait period after each entry.
How To Use Add your favorite indicators to the chart (e.g., "VuManChu Cipher B" and "EMA 200"). Add Universal Strategy Adapter to the chart. Open Settings > Inputs. Slot 1 (Trigger) : Source : Select the "Buy Signal" or "Golden Dot" plot from the first indicator. Condition : Signal (!= 0) Role : Mandatory Slot 2 (Filter) : Source : Select the "EMA 200" plot. Condition : Price > Source (Trades only taken when price is above EMA). Role : Mandatory Adjust SL/TP and Backtest Range as needed.
Why Use This? TradingView strategies are often hardcoded to specific indicators. This script breaks that barrier, giving you a universal "Container" to drop any logic into and see the raw backtest results immediately.
Short-Term Weekly Refuges (Shelters)## // Introduction // (Spanish Texts Below)
═══════════════════════════
Short-Term Weekly Refuges (Shelters) (WR or RS) is a structural analysis indicator designed to track price action during the current week. It combines a configurable ZigZag with Fibonacci retracements anchored to recent phases, using the Weekly Opening Price (W.O.P.) as a key reference level.
This indicator is optimized for 4H timeframe but also works on 1H and 15min charts.
## // Theoretical Foundation of the Indicator //
═════════════════════════════════════════════════
The WR (RS) indicator provides a structural framework for following price action during the current trading week.
The core concept: Recent ZigZag phases, combined with the Weekly Opening Price, create dynamic support and resistance levels that institutional traders often monitor and use for intraweek positioning. The indicator allows you to select which recent phase (1-10) serves as the Fibonacci anchor.
## // Indicator Objectives //
═════════════════════════════
1) Display a configurable ZigZag showing recent price structure with numbered phases (1 = most recent). Users should configure the ZigZag parameters based on whether they are analyzing a Major Degree Pattern (larger swings, less noise) or a Minor Degree Pattern (smaller swings, more detail), following standard Elliott Wave terminology. Configure the ZigZag to match the degree of your analysis: use higher Depth values for Major Degree Patterns, or lower values for Minor Degree Patterns.
2) Draw Fibonacci retracements on a user-selected phase, with two modes:
• "On ZigZag": Traditional Fibonacci on the selected phase.
• "Relative to W.O.P.": Fibonacci from phase anchor (i0) to Weekly Opening Price.
3) Show Weekly Opening Price lines as horizontal references, with the current week's line extended into the future.
4) Provide Pivot Up/Down markers for additional confirmation of local highs and lows.
5) Support multiple simultaneous indicator loads with visual identifier labels to distinguish between different analysis degrees (e.g., "Major Degree Pattern" vs "Minor Degree Pattern").
6) Optional Embedded Indicator: Enable Intraday Shelters (RID) - percentage-based support/resistance levels calculated from the Daily Opening Price, useful for 1H and 15min trading.
## // Key Features //
═════════════════════
• **Flexible ZigZag**: Adjustable Depth, Deviation, and Backstep parameters to adapt to any asset's volatility and degree pattern.
• **Phase Selection**: Choose from the 10 most recent phases for Fibonacci anchoring.
• **Dual Fibonacci Modes**: Trace on the ZigZag phase itself, or relative to the Weekly Opening Price.
• **New Age Color Palette**: Professional Fibonacci color scheme used by old school experienced traders.
• **Weekly Opening Price (W.O.P.)**: Historical weekly opens plus current week projection.
• **"Show Only W.O.P." Mode**: Isolate just the Weekly Opening Price line for cleaner charts on non-4H timeframes.
• **Optional Intraday Shelters (RID)**: 11 percentage levels (±0.382%, ±1%, ±1.5%, ±2%, ±2.5%) based on Daily Opening Price.
• **Multi-Load Support**: Visual identifier tags and Large Label for running multiple indicator instances simultaneously.
## // Recommended Workflow //
═════════════════════════════
1) Load the indicator on a 4H chart.
2) Adjust ZigZag parameters (Depth, Deviation) until the phases match your visual analysis of recent price structure.
3) Select the phase you want to use as Fibonacci anchor (typically Phase 2, 3 or higher).
4) Choose Fibonacci mode: "On ZigZag" for phase analysis, or "Relative to W.O.P." for analysis based on weekly opening price context.
5) Monitor how price interacts with the Fibonacci levels and Weekly Opening Price throughout the week.
6) Optionally enable RID for intraday high precision order placements on 1H or 15min charts.
## // Integration with Other Refuge Indicators //
═════════════════════════════════════════════════
This indicator WR (RS) is part of our complete refuge-based analysis ecosystem:
• LTR (RLP) (Long-Term Refuges): For automatic determination of the predominant phase of a ZigZag, which institutional investors choose as the basis for a Fibo whose levels calculate the projection for order placement over the following months and years.
• LTRS (RLPS) (Simple Long-Term Refuges): Simplified version of LTR in which the known coordinates of the predominant phases (obtained with the LTR indicator) of up to five assets are easily captured for permanent long-term operation.
• WR (RS) (Short-Term Weekly Refuges): For short-term tactical analysis (4H, 1H) based on chosen phases of a ZigZag that define Fibo levels effective during the near past week(s).
• IDR (RID) (Intra-Day Refuges): For daily operations relying on intraday levels on timeframes of 1H or less. Ideal for scalping traders.
By combining LTR, LTRS, WR and IDR, you obtain a multi-level framework that allows you to operate with clarity at any time horizon, from intraday positions to investments spanning months and years.
## // Additional Notes //
═════════════════════════
1) Default parameters are optimized for volatile assets (crypto, tech stocks). For forex or less volatile instruments, consider reducing Deviation to 3-8%.
2) The "Phase in Development" (dashed line) shows the tentative current ZigZag segment that may still change as new bars form.
3) Due to TradingView's English-only publication rules, the complete Spanish version of this indicator with all tooltips and documentation will be available soon in our GitHub repository: aj-poolom-maasewal.
4) Bug reports, improvement proposals for the ZigZag generator, pattern determination, or Fibo composition, etc., will be greatly appreciated and taken into account for a future version. Best regards and happy hunting.
════════════════════════════════════════════════════
════════════════════════════════════════════════════
TEXTO EN ESPANIOL (Sin acentos ni enies para compatibilidad con TradingView)
════════════════════════════════════════════════════
## // Introduccion //
═════════════════════
Refugios Semanales (RS o WR) es un indicador de analisis estructural diseniado para seguir la accion del precio durante la semana en curso. Combina un ZigZag configurable con retrocesos de Fibonacci anclados a fases recientes, utilizando el Precio de Apertura Semanal (P.A.S.) como nivel de referencia clave.
Este indicador esta optimizado para temporalidad de 4H pero tambien funciona en graficos de 1H y 15min.
## // Fundamento Teorico del Indicador //
═════════════════════════════════════════
El indicador RS (WR) proporciona un marco estructural para seguir la accion del precio durante la semana de operacion actual.
El concepto central: Las fases recientes del ZigZag, combinadas con el Precio de Apertura Semanal, crean niveles dinamicos de soporte y resistencia que los operadores institucionales frecuentemente monitorean para su posicionamiento intrasemanal. El indicador permite seleccionar cual fase reciente (1-10) sirve como ancla del Fibonacci.
## // Objetivos del Indicador //
════════════════════════════════
1) Mostrar un ZigZag configurable con la estructura de precios reciente y fases numeradas (1 = mas reciente). Los usuarios deben configurar los parametros del ZigZag segun esten analizando una Pauta de Grado Mayor (oscilaciones mas amplias, menos ruido) o una Pauta de Grado Menor (oscilaciones mas pequenias, mas detalle), siguiendo la terminologia estandar de Ondas de Elliott. Configure el ZigZag para que coincida con el grado de su analisis: use valores de Profundidad mas altos para Pautas de Grado Mayor, o valores mas bajos para Pautas de Grado Menor.
2) Dibujar retrocesos de Fibonacci en una fase seleccionada por el usuario, con dos modos:
• "En el ZigZag": Fibonacci tradicional sobre la fase seleccionada.
• "Respecto al P.A.S.": Fibonacci desde el ancla de la fase (i0) hasta el Precio de Apertura Semanal.
3) Mostrar lineas del Precio de Apertura Semanal como referencias horizontales, con la linea de la semana actual extendida hacia el futuro.
4) Proporcionar marcadores de Pivote Arriba/Abajo para confirmacion adicional de maximos y minimos locales.
5) Soportar multiples cargas simultaneas del indicador con etiquetas identificadoras visuales para distinguir entre diferentes grados de analisis (ej: "Pauta de Grado Mayor" vs "Pauta de Grado Menor").
6) Indicador Integrado Opcional: Habilitar Refugios Intra-Diarios (RID) - niveles de soporte/resistencia basados en porcentajes calculados desde el Precio de Apertura Diaria, util para operacion en 1H y 15min.
## // Caracteristicas Principales //
════════════════════════════════════
• **ZigZag Flexible**: Parametros ajustables de Profundidad, Desviacion y Retroceso para adaptarse a la volatilidad y grado de pauta de cualquier activo.
• **Seleccion de Fase**: Elija entre las 10 fases mas recientes para el anclaje del Fibonacci.
• **Modos Duales de Fibonacci**: Trace sobre la fase del ZigZag, o relativo al Precio de Apertura Semanal.
• **Paleta de Colores New Age**: Esquema de colores profesional de Fibonacci usado por operadores institucionales de la vieja escuela.
• **Precio de Apertura Semanal (P.A.S.)**: Aperturas semanales historicas mas proyeccion de la semana actual.
• **Modo "Solo P.A.S."**: Aisla unicamente la linea del Precio de Apertura Semanal para graficos mas limpios en temporalidades distintas a 4H.
• **Refugios Intra-Diarios Opcionales (RID)**: 11 niveles porcentuales (±0.382%, ±1%, ±1.5%, ±2%, ±2.5%) basados en el Precio de Apertura Diaria.
• **Soporte Multi-Carga**: Etiquetas identificadoras visuales y Rotulo Grande para ejecutar multiples instancias del indicador simultaneamente.
## // Flujo de Trabajo Recomendado //
═════════════════════════════════════
1) Cargue el indicador en un grafico de 4H.
2) Ajuste los parametros del ZigZag (Profundidad, Desviacion) hasta que las fases coincidan con su analisis visual de la estructura de precios reciente.
3) Seleccione la fase que desea usar como ancla del Fibonacci (tipicamente Fase 2, 3 o superior).
4) Elija el modo de Fibonacci: "En el ZigZag" para analisis de fase, o "Respecto al P.A.S." para analisis basado en el contexto del precio de apertura semanal.
5) Monitoree como el precio interactua con los niveles de Fibonacci y el Precio de Apertura Semanal durante la semana.
6) Opcionalmente habilite RID para precision intradiaria en graficos de 1H o 15min.
## // Integracion con Otros Indicadores de Refugios //
══════════════════════════════════════════
RS (WR) es parte de nuestro ecosistema completo de analisis basado en refugios:
• RLP (LTR) (Refugios de Largo Plazo): Para determinacion automatica de la fase preponderante de un ZigZag, que los inversionistas institucionales eligen como base para un Fibo cuyos niveles calculan la proyeccion para colocacion de ordenes durante los meses y anios siguientes.
• RLPS (LTRS) (Refugios de Largo Plazo Simplificado): Version simplificada de RLP en la cual las coordenadas conocidas de las fases preponderantes (obtenidas con el indicador RLP) de uno o hasta cinco activos se capturan facilmente para operacion permanente de largo plazo.
• RS (WR) (Refugios Semanales de Corto Plazo): Para analisis tactico de corto plazo (4H, 1H) basado en fases elegidas de un ZigZag que definen niveles Fibo efectivos durante la(s) semana(s) pasada(s) reciente(s).
• RID (IDR) (Refugios Intra-Diarios): Para operaciones diarias basadas en niveles intradiarios en temporalidades de 1H o menos. Ideal para operadores de scalping.
Al combinar RLP, RLPS, RS y RID, obtiene un marco multinivel que le permite operar con claridad en cualquier horizonte temporal, desde posiciones intradiarias hasta inversiones que abarcan meses y anios.
## // Notas Adicionales //
══════════════════════════
1) Los parametros por defecto estan optimizados para activos volatiles (cripto, acciones tecnologicas). Para forex o instrumentos menos volatiles, considere reducir la Desviacion a 3-8%.
2) La "Fase en Desarrollo" (linea discontinua) muestra el segmento tentativo actual del ZigZag que aun puede cambiar conforme se formen nuevas barras.
3) Debido a las reglas de publicacion de TradingView (solo ingles), la version completa en espaniol de este indicador con todos los tooltips y documentacion estara disponible proximamente en nuestro repositorio de GitHub: aj-poolom-maasewal.
4) El reporte de cualquier error encontrado, propuestas de mejoras al generador de Zigzags, determinacion de pautas, o composicion del Fibo, etc., seran ampliamente agradecidas y tomadas en cuenta para una proxima version. Saludos y buena caceria.
══════════════════════════════════════════════════
RSI as Volume-Style Histogram + Right Valuesthis indicator shows rsi levels per candle the same as volume bars appear with a box showing the avg rsi throughout the session and also shows the previous candles closing rsi to better compare when looking to identify momentum
Smart Buy/Sell Zones (Auto Timeframe)Brodrick Johnson Smart Zones.
Value zones for calculating price ceiling and floor.
Neeson Volatility Adaptive Tracker ProVolatility Adaptive Tracker Pro: A Comprehensive Multi-Method Trading System
Executive Summary
The Volatility Adaptive Tracker Pro (VAT Pro) represents a sophisticated fusion of proven technical analysis methodologies with innovative adaptations, creating a unique multi-signal trading system. Unlike single-purpose indicators, VAT Pro combines multiple analytical approaches into a unified framework that addresses the complex realities of modern financial markets. This system is designed for traders who recognize that no single method consistently outperforms, and that market conditions require adaptive, multi-faceted approaches.
Original Innovations: What Sets VAT Pro Apart
1. Hybrid Volatility Measurement System
Most volatility indicators fall into two categories: those based on standard deviation (like Bollinger Bands) or those based on average true range (ATR). VAT Pro introduces a third approach: a weighted volatility measurement system that gives greater importance to recent price movements while maintaining sensitivity to overall market conditions. This creates a dynamic volatility assessment that adapts more responsively to changing market environments than conventional methods.
2. Dual-Layer Signal Architecture
While most indicators generate single-type signals, VAT Pro implements a tiered signaling system that distinguishes between:
Primary trend-following signals (based on price crossing adaptive volatility bands)
Secondary volume-confirmed signals (requiring both price movement and exceptional volume)
This dual-layer approach recognizes that not all market moves have equal significance, and that volume confirmation often signals more substantial moves worthy of special attention.
3. State-Based Logic with Memory
Conventional indicators typically generate signals independently on each bar. VAT Pro introduces persistent state tracking that maintains awareness of whether the market is currently in a bullish, bearish, or neutral condition. This prevents signal redundancy, reduces false signals, and provides valuable context for interpreting current market conditions.
What VAT Pro Does: Comprehensive Market Analysis
Primary Functions
Trend Identification: Detects transitions between bullish and bearish market conditions using multiple confirmation criteria.
Volume Analysis: Identifies exceptional trading activity that often precedes or confirms significant price movements.
Volatility Assessment: Continuously measures market volatility and adjusts sensitivity parameters accordingly.
Visual Context Provision: Uses color-coded price bars, trend lines, and clear signal markers to provide immediate visual feedback.
Multi-Timeframe Compatibility: Functions effectively across various trading timeframes from intraday to positional trading.
Implementation Methodology: The Technical Framework
Core Analytical Approaches
Among the hundreds of available technical analysis methods, VAT Pro specifically implements and integrates:
A. Adaptive Volatility Channel System
This approach modifies the traditional volatility channel concept by:
Using weighted moving averages for volatility calculation rather than simple or exponential averages
Implementing asymmetric response to upward versus downward volatility
Maintaining dynamic channel width that adjusts based on recent market conditions
The system falls within the broader category of volatility-adjusted trend following but introduces unique adaptations that improve responsiveness while maintaining stability.
B. Volume-Price Confirmation Method
Within volume analysis, VAT Pro specifically employs:
Threshold-based volume spike detection (volume exceeding moving average by specified multiples)
Price-direction confirmation (requiring price movement in the expected direction)
Contextual filtering (only considering volume signals in specific market conditions)
This represents a specific implementation within the volume confirmation family of methods, distinguished by its customizable thresholds and filtering logic.
C. Trailing Stop with Adaptive Positioning
The system implements a specific variant of trailing stop methodology characterized by:
State-dependent positioning (different logic for trending versus ranging markets)
Volatility-adjusted distance (stop levels adapt to current market conditions)
Memory of previous positions (the system "remembers" previous trend states)
This approach represents an advanced form of trailing stop placement that combines elements of volatility adjustment with trend state awareness.
Calculation Philosophy: The Core Principles
1. Weighted Response Philosophy
VAT Pro operates on the principle that recent market action should have greater influence than distant history, but not to the exclusion of broader context. This is implemented through custom weighting algorithms that balance responsiveness with stability.
2. Multi-Factor Confirmation Principle
The system is built on the premise that multiple confirming factors (price action, volume, volatility) provide more reliable signals than single-factor approaches. This represents a practical implementation of convergence/divergence analysis across different market dimensions.
3. State Transition Logic
Rather than viewing each bar in isolation, VAT Pro analyzes sequences of price action to determine market states and state transitions. This recognizes that markets often move through identifiable phases (accumulation, trending, distribution, ranging) that require different analytical approaches.
4. Adaptive Sensitivity
The system automatically adjusts its sensitivity based on current market volatility, becoming more responsive in low-volatility conditions and more stable in high-volatility environments. This represents a practical implementation of volatility-adjusted trading logic.
Practical Application: How to Use VAT Pro
Initial Setup and Configuration
Parameter Customization: Begin with default settings, then adjust based on:
Your trading instrument's typical volatility characteristics
Your preferred trading timeframe
Your risk tolerance and trading style
Visual Configuration: Customize colors and display settings to match your charting preferences while maintaining clear signal visibility.
Trading Methodology Integration
VAT Pro supports multiple trading approaches:
For Trend Following:
Use primary signals when confirmed by overall market direction
Employ the adaptive line as a dynamic trailing stop
Monitor state transitions for trend continuation or reversal clues
For Breakout Trading:
Watch for high-volume signals at key price levels
Use volatility bands to identify potential breakout ranges
Employ volume confirmation to distinguish genuine breakouts from false moves
For Position Management:
Utilize the color-coded bar system for immediate trend awareness
Monitor multiple signal types for confirmation or warning signs
Adjust position sizes based on signal strength and market state
Signal Interpretation Framework
Primary Signal Interpretation:
Bullish signals suggest potential long opportunities
Bearish signals indicate potential short opportunities
Signal clustering often indicates stronger moves
Volume Signal Significance:
High-volume buy signals often precede sustained upward moves
High-volume sell signals frequently indicate distribution or panic selling
Volume signals without price confirmation require caution
Contextual Analysis:
Consider market state when interpreting signals
Evaluate signal strength based on recent volatility
Monitor multiple timeframes for confirmation
Performance Characteristics and Best Practices
Optimal Market Conditions
VAT Pro performs best in markets exhibiting:
Clear trending characteristics (for trend-following signals)
Occasional volatility expansions (for volume signals)
Reasonable liquidity (for accurate volume analysis)
Risk Management Integration
Use signal strength to adjust position sizing
Employ the adaptive line for stop-loss placement
Consider market state when determining risk levels
Complementary Tools
For best results, combine VAT Pro with:
Support and resistance analysis
Longer-term trend assessment
Fundamental analysis (for longer timeframes)
Market structure analysis
Conclusion: A Modern Multi-Method Approach
The Volatility Adaptive Tracker Pro represents a significant advancement in technical analysis tools by intelligently combining multiple proven methodologies into a coherent, adaptive system. Its original innovations in weighted volatility measurement, dual-layer signaling, and state-based logic address common limitations of conventional indicators while maintaining practical usability.
By specifically implementing adaptive volatility channels, volume-price confirmation, and state-aware trailing stops, VAT Pro provides traders with a comprehensive toolkit that adapts to changing market conditions while maintaining methodological rigor. This multi-method approach recognizes the complex reality of financial markets while providing clear, actionable signals based on sound technical principles.
Whether used as a primary trading system or as a confirming component within a broader strategy, VAT Pro offers sophisticated analytical capabilities in an accessible, visually intuitive format that supports informed trading decisions across various market conditions and timeframes.
Order Blocks INDIBOT 3D | INDIBOT ABO SALTAN 11 //@version=6
indicator("Order Blocks INDIBOT 3D | INDIBOT ABO SALTAN ", overlay = true,
max_boxes_count = 500, max_labels_count = 500, max_lines_count = 500, max_polylines_count = 100, max_bars_back = 5000)
//#region CONSTANTS
// Core constants that control stored OB capacity and label size.
const int MAX_STORED_OBS = 50
const int retestSize = 4
//#endregion
//#region INPUTS
// Core user controls for OB behavior, volume delta, 3D style and alerts.
grpOB = "ORDER BLOCKS"
swingLen = input.int(5, "Swing Length", minval = 1, group = grpOB, inline = "sw", display = display.none)
bullObColor = input.color(color.new(color.teal, 55), "", group = grpOB, inline = "sw")
bearObColor = input.color(color.new(color.red, 55), "", group = grpOB, inline = "sw")
invMethod = input.string("Wick", "Invalidation", options = , group = grpOB, display = display.none)
showNearestX = input.int(3, "Show Nearest", minval = 1, maxval = 20, group = grpOB, display = display.none)
extendZones = input.int(10, "Extend Zones", minval = 0, group = grpOB,
tooltip = "This will extend the zones by X candles.", display = display.none)
showRetestLbl = input.bool(true, "Retest Labels", group = grpOB, inline = "tog")
hideInvalid = input.bool(true, "Hide Invalidated Zones", group = grpOB, inline = "tog")
grpVD = "VOLUME DELTA"
vdEnable = input.bool(true, "Enable", group = grpVD, inline = "vd")
vdBullColor = input.color(color.new(color.teal, 65), "", group = grpVD, inline = "vd")
vdBearColor = input.color(color.new(color.red, 65), "", group = grpVD, inline = "vd")
vd3D = input.bool(true, "3D", group = grpVD, inline = "3d", tooltip = "Adds 3D-style depth faces.") and vdEnable
vd3DDepth = input.int(5, "", group = grpVD, inline = "3d", minval = 1, maxval = 5, display = display.none)
displayStyle = input.string("Vertical", "Display Style", options = , group = grpVD,
tooltip = "Horizontal: split shown top/bottom. Vertical: split shown left/right across the zone.", display = display.none)
vdTfIn = input.timeframe("", "Volume Delta Timeframe", group = grpVD,
tooltip = "Lower timeframe used to estimate delta")
showTotalVol = input.bool(true, "Display Total Volume", group = grpVD,
tooltip = "Displays total volume (Bull+Bear) from the active delta source.", inline = "vd2") and vdEnable
showDeltaPct = input.bool(true, "Show Delta %", group = grpVD, inline = "vd2",
tooltip = "Shows bullish vs bearish volume split. If selected TF is lower than chart TF, uses LTF data; otherwise uses chart TF.") and vdEnable
vdTextColor = input.color(color.white, "", group = grpVD, inline = "vd2")
grpAL = "ALERTS"
alBullOB = input.bool(true, "Bullish Order Block", group = grpAL, inline = "oba")
alBearOB = input.bool(true, "Bearish Order Block", group = grpAL, inline = "oba")
alBullRetest = input.bool(true, "Bullish OB Retest", group = grpAL, inline = "obr")
alBearRetest = input.bool(true, "Bearish OB Retest", group = grpAL, inline = "obr")
//#endregion
//#region TYPES
// Custom structs for order blocks and 3D poly drawing.
type PolyParams
array points
color lineColor
color fillColor
int lineWidth
type ObRec
int leftIndex
int leftTime
int createdIndex
int createdTime
float top
float bottom
bool isBull
bool active
bool retested
int retestIndex
int retestTime
int invalidIndex
int invalidTime
float bullVol
float bearVol
float totalVol
float bullPct
float bearPct
bool hasDelta
type RetestRec
int barIndex
bool isBull
int obLeftIndex
int obCreatedIndex
//#endregion
//#region GENERIC HELPERS
// Small utilities: clearing drawings, geometry helpers, nearest-OB picking.
method clearAll(array bx, array pl, array lb) =>
if bx.size() > 0
for i = 0 to bx.size() - 1
bx.get(i).delete()
bx.clear()
if pl.size() > 0
for i = 0 to pl.size() - 1
pl.get(i).delete()
pl.clear()
if lb.size() > 0
for i = 0 to lb.size() - 1
lb.get(i).delete()
lb.clear()
// Builds a simple side face for 3D-style boxes using chart points.
method sideBox(array pts, int x, float btm, float top, float depthY, int widthX) =>
pts.unshift(chart.point.from_index(x, btm))
pts.unshift(chart.point.from_index(x + widthX, btm + depthY))
pts.unshift(chart.point.from_index(x + widthX, top + depthY))
pts.unshift(chart.point.from_index(x, top))
pts.unshift(chart.point.from_index(x, btm))
// Returns true if a candle's high/low intersects the OB zone.
touchesZone(float zTop, float zBot, float cHigh, float cLow) =>
cHigh >= zBot and cLow <= zTop
// Distance from price to zone in price units, used to rank nearest zones.
zoneDistance(float px, float zTop, float zBot) =>
px > zTop ? px - zTop : px < zBot ? zBot - px : 0.0
// Inserts a distance+index pair into a sorted list, capped at kMax.
method insertBest(array dists, array idxs, float dist, int idx, int kMax) =>
if dists.size() == 0
dists.push(dist)
idxs.push(idx)
else
int pos = dists.size()
if dists.size() > 0
for j = 0 to dists.size() - 1
if dist < dists.get(j)
pos := j
break
dists.insert(pos, dist)
idxs.insert(pos, idx)
while dists.size() > kMax
dists.pop()
idxs.pop()
// Picks the k nearest bull/bear OBs to current price (optionally including invalid).
pickNearest(array store, bool wantBull, int kMax, bool includeInvalid) =>
array dists = array.new_float()
array idxs = array.new_int()
if store.size() > 0
for i = 0 to store.size() - 1
ObRec ob = store.get(i)
if ob.isBull == wantBull
bool ok = includeInvalid ? true : ob.active
if ok
float dist = zoneDistance(close, ob.top, ob.bottom)
dists.insertBest(idxs, dist, i, kMax)
idxs
formatVol(float v) =>
str.tostring(v, format.volume)
//#endregion
//#region VOLUME ENGINE (CHART OR LOWER TF)
// Per-bar total / bull / bear volume
tfSec(string tf) =>
timeframe.in_seconds(tf)
int chartSec = tfSec(timeframe.period)
int srcSec = tfSec(vdTfIn)
bool useLtf = not na(chartSec) and not na(srcSec) and srcSec < chartSec
getBarVols() =>
float tot = na
float bull = na
float bear = na
if not useLtf or vdTfIn == ""
float v = volume
bool up = close > open
bool dn = close < open
tot := v
bull := up ? v : 0.0
bear := dn ? v : 0.0
else
array oArr = request.security_lower_tf(syminfo.tickerid, vdTfIn, open)
array cArr = request.security_lower_tf(syminfo.tickerid, vdTfIn, close)
array vArr = request.security_lower_tf(syminfo.tickerid, vdTfIn, volume)
float tSum = 0.0
float bSum = 0.0
float sSum = 0.0
int n = array.size(vArr)
if n > 0
for i = 0 to n - 1
float v2 = array.get(vArr, i)
float o2 = array.get(oArr, i)
float c2 = array.get(cArr, i)
tSum += v2
if c2 > o2
bSum += v2
else if c2 < o2
sSum += v2
tot := tSum
bull := bSum
bear := sSum
= getBarVols()
//#endregion
//#region POC ENGINE (MOST-TOUCHED PRICE + VOLUME)
// Finds a POC between swing and BOS, then aggregates volume.
findMostTouchedPrice(int fromIdx, int toIdx, int nBins) =>
int span = toIdx - fromIdx
if span <= 0 or na(fromIdx) or na(toIdx)
else
float minP = 1e10
float maxP = -1e10
for idx = fromIdx to toIdx
int rel = bar_index - idx
if rel >= 0
float lo = low
float hi = high
if not na(lo) and not na(hi)
if lo < minP
minP := lo
if hi > maxP
maxP := hi
if not (minP < maxP)
else
float step = (maxP - minP) / nBins
step := step <= 0 ? syminfo.mintick : step
array diffCnt = array.new_float(nBins, 0.0)
for idx = fromIdx to toIdx
int rel2 = bar_index - idx
if rel2 >= 0
float lo2 = low
float hi2 = high
if not na(lo2) and not na(hi2)
int sBin = int(math.floor((lo2 - minP) / step))
int eBin = int(math.floor((hi2 - minP) / step))
sBin := sBin < 0 ? 0 : sBin > nBins - 1 ? nBins - 1 : sBin
eBin := eBin < 0 ? 0 : eBin > nBins - 1 ? nBins - 1 : eBin
float cStart = diffCnt.get(sBin)
diffCnt.set(sBin, cStart + 1.0)
if eBin + 1 < nBins
float cEnd = diffCnt.get(eBin + 1)
diffCnt.set(eBin + 1, cEnd - 1.0)
int bestBin = 0
float bestCnt = 0.0
float runCnt = 0.0
for i = 0 to nBins - 1
runCnt += diffCnt.get(i)
if runCnt > bestCnt
bestCnt := runCnt
bestBin := i
float poc = minP + (bestBin + 0.5) * step
// Aggregates total / bull / bear volume at a single price level (POC) for a range.
volumeAtPrice(int fromIdx, int toIdx, float poc) =>
int touches = 0
float totVol = 0.0
float bullVol = 0.0
float bearVol = 0.0
int span = toIdx - fromIdx
if not na(poc) and span >= 0
for step = 0 to span
int idx = toIdx - step
int rel = bar_index - idx
if rel >= 0
float lo = low
float hi = high
if not na(lo) and not na(hi) and lo <= poc and hi >= poc
touches += 1
float vTot = barTotVol
float vBull = barBullVol
float vBear = barBearVol
if not na(vTot)
totVol += vTot
if not na(vBull)
bullVol += vBull
if not na(vBear)
bearVol += vBear
// Wrapper: find POC first, then compute volume at that POC for the BOS range.
calcMostTouchedPriceVol(int fromIdx, int toIdx, int nBins) =>
= findMostTouchedPrice(fromIdx, toIdx, nBins)
= volumeAtPrice(fromIdx, toIdx, poc)
//#endregion
//#region ORDER BLOCK ENGINE (POC-BASED)
// Detects swing highs/lows, confirms BOS, anchors OB at first POC touch.
var array obs = array.new()
var array obRetests = array.new()
var int lastBullRetestBar = na
var int lastBearRetestBar = na
var float shPrice = na
var int shIdx = na
var float slPrice = na
var int slIdx = na
bool evNewBullOB = false
bool evNewBearOB = false
bool evBullRetest = false
bool evBearRetest = false
float ph = ta.pivothigh(high, swingLen, swingLen)
float pl = ta.pivotlow(low, swingLen, swingLen)
if not na(ph)
shPrice := ph
shIdx := bar_index - swingLen
if not na(pl)
slPrice := pl
slIdx := bar_index - swingLen
bool bosBearNow = not na(slPrice) and bar_index > slIdx and close < slPrice and close >= slPrice
bool bosBullNow = not na(shPrice) and bar_index > shIdx and close > shPrice and close <= shPrice
bool bosBear = bosBearNow
bool bosBull = bosBullNow
// Precompute BOS ranges and POC stats in global scope
int bosIdxBear = bar_index - 1
int fromIdxBear = slIdx
int toIdxBear = bosIdxBear
= calcMostTouchedPriceVol(fromIdxBear, toIdxBear, 40)
int bosIdxBull = bar_index - 1
int fromIdxBull = shIdx
int toIdxBull = bosIdxBull
= calcMostTouchedPriceVol(fromIdxBull, toIdxBull, 40)
// Keeps OB array trimmed to recent history and limits max stored OBs.
pruneObs() =>
int minLeft = math.max(0, bar_index - 4999)
if obs.size() > 0
for i = obs.size() - 1 to 0
ObRec ob = obs.get(i)
if ob.leftIndex < minLeft
obs.remove(i)
while obs.size() > MAX_STORED_OBS
bool removed = false
if obs.size() > 0
for j = obs.size() - 1 to 0
ObRec ob2 = obs.get(j)
if not ob2.active
obs.remove(j)
removed := true
break
if not removed and obs.size() > 0
obs.pop()
// Creates and seeds an OB record using a POC-anchored candle and BOS volumes.
addObFromPoc(int baseIdx, float top, float bottom, bool isBull, float totSeed, float bullSeed, float bearSeed, int createdIdx) =>
int offLeft = bar_index - baseIdx
int offCreated = bar_index - createdIdx
int leftTime = time
int createdTm = time
float tot = totSeed
float bVol = bullSeed
float sVol = bearSeed
bool hasDelta = tot > 0.0
float bullPct = hasDelta ? math.round((bVol / tot) * 100.0) : 50.0
float bearPct = hasDelta ? 100.0 - bullPct : 50.0
obs.unshift(ObRec.new(baseIdx, leftTime, createdIdx, createdTm, top, bottom, isBull,
true, false, na, na, na, na, bVol, sVol, tot, bullPct, bearPct, hasDelta))
pruneObs()
// Returns true if a proposed zone overlaps any active OB
obOverlapsActive(float zoneTop, float zoneBottom) =>
float zTop = math.max(zoneTop, zoneBottom)
float zBot = math.min(zoneTop, zoneBottom)
bool overlaps = false
if obs.size() > 0
for i = 0 to obs.size() - 1
ObRec ob = obs.get(i)
if ob.active
float oTop = math.max(ob.top, ob.bottom)
float oBot = math.min(ob.top, ob.bottom)
bool rangeOverlap = zTop >= oBot and zBot <= oTop
if rangeOverlap
overlaps := true
break
overlaps
// Returns true if there is a price gap between anchorIdx and bosIdx.
hasGapBetween(int anchorIdx, int bosIdx, bool isBull) =>
bool gap = false
int fromIdx = math.min(anchorIdx, bosIdx)
int toIdx = math.max(anchorIdx, bosIdx)
if toIdx - fromIdx >= 1
for absIdx = fromIdx + 1 to toIdx
int relNow = bar_index - absIdx
int relPrev = relNow + 1
if relNow >= 0 and relPrev >= 0
float hiPrev = high
float loPrev = low
float hiNow = high
float loNow = low
if not na(hiPrev) and not na(loPrev) and not na(hiNow) and not na(loNow)
if isBull
if loNow > hiPrev
gap := true
break
else
if hiNow < loPrev
gap := true
break
gap
// Bearish BOS → Bearish OB
if bosBear
int bosIdx = bosIdxBear
int fromIdx = fromIdxBear
int toIdx = toIdxBear
if not na(pocB) and touchesB > 0 and not na(fromIdx) and not na(toIdx)
int spanB = toIdx - fromIdx
int bestIdx = na
float runMaxHigh = na
if spanB >= 0
for step = 0 to spanB
int idx = toIdx - step
int rel = bar_index - idx
if rel >= 0
float lo = low
float hi = high
if not na(lo) and not na(hi)
runMaxHigh := na(runMaxHigh) ? hi : math.max(runMaxHigh, hi)
bool touches = lo <= pocB and hi >= pocB
if touches and hi == runMaxHigh
bestIdx := idx
bool gapLeg = not na(bestIdx) ? hasGapBetween(bestIdx, bosIdx, false) : false
if not na(bestIdx) and not gapLeg
int relBest = bar_index - bestIdx
float top = high
float bottom = low
if not obOverlapsActive(top, bottom)
addObFromPoc(bestIdx, top, bottom, false, totVolB, bullVolB, bearVolB, bosIdx)
evNewBearOB := true
slPrice := na
slIdx := na
// Bullish BOS → Bullish OB
if bosBull
int bosIdx2 = bosIdxBull
int fromIdx2 = fromIdxBull
int toIdx2 = toIdxBull
if not na(pocH) and touchesH > 0 and not na(fromIdx2) and not na(toIdx2)
int spanH = toIdx2 - fromIdx2
int bestIdx2 = na
float runMinLow = na
if spanH >= 0
for step = 0 to spanH
int idx2 = toIdx2 - step
int rel2 = bar_index - idx2
if rel2 >= 0
float lo2 = low
float hi2 = high
if not na(lo2) and not na(hi2)
runMinLow := na(runMinLow) ? lo2 : math.min(runMinLow, lo2)
bool touches = lo2 <= pocH and hi2 >= pocH
if touches and lo2 == runMinLow
bestIdx2 := idx2
bool gapLeg2 = not na(bestIdx2) ? hasGapBetween(bestIdx2, bosIdx2, true) : false
if not na(bestIdx2) and not gapLeg2
int relBest2 = bar_index - bestIdx2
float top2 = high
float bottom2 = low
if not obOverlapsActive(top2, bottom2)
addObFromPoc(bestIdx2, top2, bottom2, true, totVolH, bullVolH, bearVolH, bosIdx2)
evNewBullOB := true
shPrice := na
shIdx := na
// Invalidation and retest detection for existing OBs.
if obs.size() > 0
for i = 0 to obs.size() - 1
ObRec ob = obs.get(i)
if ob.active
bool invalid = false
int invIdx = na
int invTime = na
if ob.isBull
if invMethod == "Wick"
invalid := low < ob.bottom
invIdx := bar_index
invTime := time
else
if bar_index > 0
invalid := close < ob.bottom
invIdx := bar_index - 1
invTime := time
else
if invMethod == "Wick"
invalid := high > ob.top
invIdx := bar_index
invTime := time
else
if bar_index > 0
invalid := close > ob.top
invIdx := bar_index - 1
invTime := time
if invalid
ob.active := false
ob.invalidIndex := invIdx
ob.invalidTime := invTime
bool retestPrev = false
int retestBar = na
int retestTm = na
if bar_index > 0
if ob.isBull
bool opensAbovePrev = open > ob.top
bool closesAbovePrev = close > ob.top
bool wickTouchesPrev = low <= ob.top and low >= ob.bottom
retestPrev := opensAbovePrev and closesAbovePrev and wickTouchesPrev
else
bool opensBelowPrev = open < ob.bottom
bool closesBelowPrev = close < ob.bottom
bool wickTouchesPrev = high >= ob.bottom and high <= ob.top
retestPrev := opensBelowPrev and closesBelowPrev and wickTouchesPrev
if retestPrev
retestBar := bar_index - 1
retestTm := time
if retestPrev and not na(retestBar) and retestBar > ob.createdIndex
ob.retested := true
ob.retestIndex := retestBar
ob.retestTime := retestTm
int lastSideBar = ob.isBull ? lastBullRetestBar : lastBearRetestBar
bool canLog = na(lastSideBar) or retestBar - lastSideBar >= 4
if canLog
obRetests.unshift(RetestRec.new(retestBar, ob.isBull, ob.leftIndex, ob.createdIndex))
if ob.isBull
evBullRetest := true
lastBullRetestBar := retestBar
else
evBearRetest := true
lastBearRetestBar := retestBar
obs.set(i, ob)
//#endregion
//#region DRAW ENGINE (ZONES + VOLUME + 3D)
// Handles all boxes, polylines and labels for OBs and 3D faces.
bool showVD = vdEnable
bool isVert = displayStyle == "Vertical"
bool isHorz = not isVert
float dayAtr = ta.atr(14)
var array allBoxes = array.new()
var array allPolys = array.new()
var array allLabels = array.new()
drawPoly(PolyParams pp) =>
if not na(pp) and not na(pp.points) and pp.points.size() > 0
allPolys.unshift(polyline.new(points = pp.points, line_color = pp.lineColor, fill_color = pp.fillColor))
method pushBox(array store, box b) =>
store.unshift(b)
method pushLabel(array store, label l) =>
store.unshift(l)
// Chooses base colors for OB zones depending on vdEnable and bull/bear type.
obColors(ObRec ob) =>
color bullCol = vdEnable ? vdBullColor : bullObColor
color bearCol = vdEnable ? vdBearColor : bearObColor
color baseCol = ob.isBull ? bullCol : bearCol
color faded = ob.active ? baseCol : color.new(baseCol, 85)
// Computes right-most bar index for drawing an OB, considering extension and invalidation.
obRightIndex(ObRec ob) =>
int activeRight = bar_index + extendZones
if ob.active
activeRight
else
na(ob.invalidIndex) ? activeRight : ob.invalidIndex
// Draws the main OB zone box on the chart.
drawObZoneBox(ObRec ob, color faded) =>
int xR = obRightIndex(ob)
int xL = ob.leftIndex
int minBar = bar_index - 4999
if xL < minBar
xL := minBar
xR := math.max(xR, xL)
box bx = box.new(left = xL, right = xR, top = ob.top, bottom = ob.bottom, xloc = xloc.bar_index, bgcolor = faded, border_color = na, border_width = 0)
allBoxes.pushBox(bx)
// Draws a retest marker (triangle) when price revisits an OB.
drawRetestLabels(array bullAct, array bearAct, array bullInv, array bearInv) =>
int ret = 0
if showRetestLbl and obRetests.size() > 0
int minBar = bar_index - 4999
int lastBullLbl = na
int lastBearLbl = na
for i = obRetests.size() - 1 to 0
RetestRec r = obRetests.get(i)
if r.barIndex < minBar or r.barIndex > bar_index
RetestRec _trash = obRetests.remove(i)
else
bool hasDisplayedParent = false
if r.isBull
if bullAct.size() > 0
for j = 0 to bullAct.size() - 1
ObRec ob = obs.get(bullAct.get(j))
if ob.leftIndex == r.obLeftIndex and ob.createdIndex == r.obCreatedIndex
hasDisplayedParent := true
break
if not hasDisplayedParent and not hideInvalid and bullInv.size() > 0
for j = 0 to bullInv.size() - 1
ObRec ob = obs.get(bullInv.get(j))
if ob.leftIndex == r.obLeftIndex and ob.createdIndex == r.obCreatedIndex
hasDisplayedParent := true
break
else
if bearAct.size() > 0
for j = 0 to bearAct.size() - 1
ObRec ob = obs.get(bearAct.get(j))
if ob.leftIndex == r.obLeftIndex and ob.createdIndex == r.obCreatedIndex
hasDisplayedParent := true
break
if not hasDisplayedParent and not hideInvalid and bearInv.size() > 0
for j = 0 to bearInv.size() - 1
ObRec ob = obs.get(bearInv.get(j))
if ob.leftIndex == r.obLeftIndex and ob.createdIndex == r.obCreatedIndex
hasDisplayedParent := true
break
if not hasDisplayedParent
continue
int age = bar_index - r.barIndex
if age >= 0 and age <= 4999
if r.isBull
if not na(lastBullLbl) and r.barIndex - lastBullLbl < 3
continue
lastBullLbl := r.barIndex
else
if not na(lastBearLbl) and r.barIndex - lastBearLbl < 3
continue
lastBearLbl := r.barIndex
float yPrice = close
color baseCol = r.isBull ? bullObColor : bearObColor
st = r.isBull ? label.style_triangleup : label.style_triangledown
yl = r.isBull ? yloc.belowbar : yloc.abovebar
label newLbl = label.new(r.barIndex, yPrice, "", xloc = xloc.bar_index, yloc = yl, style = st,
color = color.new(baseCol, 0), textcolor = color.new(baseCol, 0), size = retestSize, force_overlay = true)
allLabels.pushLabel(newLbl)
ret
// Returns geometry used for volume overlay and 3D top view.
obGeom(ObRec ob) =>
int rawL = ob.leftIndex
int rawR = obRightIndex(ob)
int minBar = bar_index - 4999
int xL = math.max(rawL, minBar)
int xR = math.max(rawR, xL)
int widthX = vd3DDepth
int xR2 = xR + widthX
float yT = ob.top
float yB = ob.bottom
float h = yT - yB
// Converts bull/bear percentages into display strings (if enabled).
deltaTexts(float bullPct, float bearPct) =>
string bullTxt = showDeltaPct ? str.tostring(bullPct) + "%" : ""
string bearTxt = showDeltaPct ? str.tostring(bearPct) + "%" : ""
// Draws a text label with total volume on the right-bottom corner of the OB.
drawTotalVolLabel(int xL, int xR, float yT, float yB, float h, float total) =>
if showTotalVol
int cx = xR - 1
if cx < xL
cx := xL
float cy = yB + h * 0.25
string txt = formatVol(total)
label lb = label.new(cx, cy, txt, xloc = xloc.bar_index, style = label.style_label_right,
textcolor = vdTextColor, color = #ffffff00, size = size.small, force_overlay = true)
allLabels.pushLabel(lb)
// Fills the OB with bull/bear split either vertically or horizontally.
drawDeltaFills(int xL, int xR, float yT, float yB, float h, float bullPct, string bullTxt, string bearTxt) =>
color bullCol = vdEnable ? vdBullColor : bullObColor
color bearCol = vdEnable ? vdBearColor : bearObColor
if isVert
int splitX = xL + int((xR - xL) * (bullPct / 100.0))
splitX := xR - xL >= 2 ? math.max(xL + 1, math.min(xR - 1, splitX)) : xL
box bBull = box.new(xL, yT, splitX, yB, xloc = xloc.bar_index, bgcolor = bullCol, border_width = 0, text = bullTxt, text_color = vdTextColor, text_size = size.small)
box bBear = box.new(splitX, yT, xR, yB, xloc = xloc.bar_index, bgcolor = bearCol, border_width = 0, text = bearTxt, text_color = vdTextColor, text_size = size.small)
allBoxes.pushBox(bBull)
allBoxes.pushBox(bBear)
else
float midY = yB + h * (bullPct / 100.0)
box bBull = box.new(xL, midY, xR, yB, xloc = xloc.bar_index, bgcolor = bullCol, border_width = 0, text = bullTxt, text_color = vdTextColor, text_size = size.small)
box bBear = box.new(xL, yT, xR, midY, xloc = xloc.bar_index, bgcolor = bearCol, border_width = 0, text = bearTxt, text_color = vdTextColor, text_size = size.small)
allBoxes.pushBox(bBull)
allBoxes.pushBox(bBear)
// Track first visible bar index for 3D top face clipping.
var int leftVisIdx = na
if na(leftVisIdx) and time >= chart.left_visible_bar_time
leftVisIdx := bar_index
// Draws the 3D front faces and top faces based on bull/bear split and style.
drawDelta3D(int xL, int xR, int widthX, int xR2, float yT, float yB, float h, float bullPct) =>
color bullCol = vdEnable ? vdBullColor : bullObColor
color bearCol = vdEnable ? vdBearColor : bearObColor
float depthY = dayAtr * (0.1 * vd3DDepth)
int visibleLeft = na(leftVisIdx) ? xL : math.max(xL, leftVisIdx)
int visibleRight = xR
if isHorz
float midY = yB + h * (bullPct / 100.0)
if bullPct > 0
array ptsFrontBull = array.new()
ptsFrontBull.sideBox(xR, yB, midY, depthY, widthX)
drawPoly(PolyParams.new(ptsFrontBull, color.new(chart.fg_color, 90), color.new(bullCol, 70), 1))
if bullPct < 100
array ptsFrontBear = array.new()
ptsFrontBear.sideBox(xR, midY, yT, depthY, widthX)
drawPoly(PolyParams.new(ptsFrontBear, color.new(chart.fg_color, 90), color.new(bearCol, 70), 1))
if visibleRight > visibleLeft
array ptsTop = array.new()
ptsTop.unshift(chart.point.from_index(visibleRight + widthX, yT + depthY))
ptsTop.unshift(chart.point.from_index(visibleLeft + widthX, yT + depthY))
ptsTop.unshift(chart.point.from_index(visibleLeft, yT))
ptsTop.unshift(chart.point.from_index(visibleRight, yT))
ptsTop.unshift(chart.point.from_index(visibleRight + widthX, yT + depthY))
drawPoly(PolyParams.new(ptsTop, color.new(chart.fg_color, 90), color.new(bearCol, 70), 1))
else
array ptsFront = array.new()
ptsFront.sideBox(xR, yB, yT, depthY, widthX)
drawPoly(PolyParams.new(ptsFront, color.new(chart.fg_color, 90), color.new(bearCol, 70), 1))
if visibleRight > visibleLeft
float frac = bullPct / 100.0
int bullRight = visibleLeft + int((visibleRight - visibleLeft) * frac)
bullRight := math.max(visibleLeft, math.min(visibleRight, bullRight))
if bullPct > 0 and bullRight > visibleLeft
array ptsTopBull = array.new()
ptsTopBull.unshift(chart.point.from_index(bullRight + widthX, yT + depthY))
ptsTopBull.unshift(chart.point.from_index(visibleLeft + widthX, yT + depthY))
ptsTopBull.unshift(chart.point.from_index(visibleLeft, yT))
ptsTopBull.unshift(chart.point.from_index(bullRight, yT))
ptsTopBull.unshift(chart.point.from_index(bullRight + widthX, yT + depthY))
drawPoly(PolyParams.new(ptsTopBull, color.new(chart.fg_color, 90), color.new(bullCol, 70), 1))
if bullPct < 100 and visibleRight > bullRight
array ptsTopBear = array.new()
ptsTopBear.unshift(chart.point.from_index(visibleRight + widthX, yT + depthY))
ptsTopBear.unshift(chart.point.from_index(bullRight + widthX, yT + depthY))
ptsTopBear.unshift(chart.point.from_index(bullRight, yT))
ptsTopBear.unshift(chart.point.from_index(visibleRight, yT))
ptsTopBear.unshift(chart.point.from_index(visibleRight + widthX, yT + depthY))
drawPoly(PolyParams.new(ptsTopBear, color.new(chart.fg_color, 90), color.new(bearCol, 70), 1))
// Draws a full OB: zone, retest label, volume fill and 3D faces.
drawZoneAndVolume(ObRec ob) =>
= obColors(ob)
drawObZoneBox(ob, faded)
if showVD and ob.hasDelta
= obGeom(ob)
= deltaTexts(ob.bullPct, ob.bearPct)
drawTotalVolLabel(xL, xR, yT, yB, h, ob.totalVol)
drawDeltaFills(xL, xR, yT, yB, h, ob.bullPct, bullTxt, bearTxt)
if vd3D
drawDelta3D(xL, xR, widthX, xR2, yT, yB, h, ob.bullPct)
true
// Clear all previous drawings each bar before re-rendering current selection.
allBoxes.clearAll(allPolys, allLabels)
// Pick active and invalid OBs based on hideInvalid + showNearestX.
array bullActive = array.new_int()
array bearActive = array.new_int()
array bullInvalid = array.new_int()
array bearInvalid = array.new_int()
if hideInvalid
bullActive := pickNearest(obs, true, showNearestX, false)
bearActive := pickNearest(obs, false, showNearestX, false)
else
bullActive := pickNearest(obs, true, showNearestX, false)
bearActive := pickNearest(obs, false, showNearestX, false)
if obs.size() > 0
for i = 0 to obs.size() - 1
ObRec o = obs.get(i)
if not o.active
if o.isBull
bullInvalid.push(i)
else
bearInvalid.push(i)
if bearInvalid.size() > 0 and not hideInvalid
for i = 0 to bearInvalid.size() - 1
ObRec ob = obs.get(bearInvalid.get(i))
drawZoneAndVolume(ob)
if bearActive.size() > 0
for i = 0 to bearActive.size() - 1
ObRec ob = obs.get(bearActive.get(i))
drawZoneAndVolume(ob)
if bullInvalid.size() > 0 and not hideInvalid
for i = 0 to bullInvalid.size() - 1
ObRec ob = obs.get(bullInvalid.get(i))
drawZoneAndVolume(ob)
if bullActive.size() > 0
for i = 0 to bullActive.size() - 1
ObRec ob = obs.get(bullActive.get(i))
drawZoneAndVolume(ob)
// Draw all stored retest events on top of zones
drawRetestLabels(bullActive, bearActive, bullInvalid, bearInvalid)
//#endregion
//#region ALERTS
alertcondition(alBullOB and evNewBullOB, "Bullish Order Block", "New Bullish Order Block detected.")
alertcondition(alBearOB and evNewBearOB, "Bearish Order Block", "Bearish Order Block detected.")
alertcondition(alBullRetest and evBullRetest, "Bullish OB Retest", "Bullish Order Block retest.")
alertcondition(alBearRetest and evBearRetest, "Bearish OB Retest", "Bearish Order Block retest.")
if alBullOB and evNewBullOB
alert("Bullish Order Block detected.", alert.freq_once_per_bar)
if alBearOB and evNewBearOB
alert("Bearish Order Block detected.", alert.freq_once_per_bar)
if alBullRetest and evBullRetest
alert("Bullish Order Block retest.", alert.freq_once_per_bar)
if alBearRetest and evBearRetest
alert("Bearish Order Block retest.", alert.freq_once_per_bar)
// ==========================================================================================
// === Dashboard with Telegram Link ===
var table myTable = table.new(position.top_center, 1, 1, border_width=1, frame_color=color.black, bgcolor=color.white)
// Add Telegram Message to Dashboard
table.cell(myTable, 0, 0, "Join Telegram @STRATEGY INDIBOT", bgcolor=color.blue, text_color=color.white, text_size=size.normal)
EURUSD 5m SMA(5) x SMA(20) AlertsTracks every time the 5 sma crosses the 20 sma on the 5 minute chart
Price Probability Engine - Volatility & Structure-Based TargetsThe aim of the indicator is:
To provide adaptive, probability-weighted price target zones that help traders frame where price is most likely to interact next, without predicting when or guaranteeing direction.
Price Probability Engine is a target-projection overlay that blends three independent “next-move” reference methods into a single pair of AVG targets:
AVG Bull = a probabilistic upside objective
AVG Bear = a probabilistic downside objective
It is designed to help you frame the most reasonable near-term price zones using both volatility (ATR) and structure (pivot swings + measured moves) rather than relying on a single indicator.
What you see on the chart
When enabled, the script plots:
AVG Bull line (upper target)
AVG Bear line (lower target)
Optional last-bar labels that print the current target values
The overlay is scale-locked so the plots stay aligned with price when you scroll/zoom the chart.
How it works (conceptual, step-by-step)
1) ATR “reach filter” (probability gating)
All components are first checked against a reach filter:
A target is considered “reachable” only if it is within
Reach Filter × ATR from the current price.
This prevents extremely distant projections from dominating the final average.
2) Three component target engines
The script computes three upside candidates and three downside candidates:
A) ATR Component (volatility projection)
Uses ATR Length and ATR Multiplier
Projects a simple near-term band around price:
atrBull = close + ATR × mult
atrBear = close - ATR × mult
Direction mode:
Candle: compares close to close
Momentum(3): uses close − close
B) AutoFib Component (swing extension)
Detects swing highs/lows using pivot logic (Left/Right bars)
Projects an extension using a selectable Fib level (1.272 / 1.414 / 1.618 / 2.0 / 2.618)
Gives a structure-based target derived from the current swing range
C) Lindsey Component (measured-move target)
Detects a 3-point pivot sequence (P1/P2/P3) and projects a measured move to P4:
Bull: from a low-high-higher-low sequence
Bear: from a high-low-lower-high sequence
Optional P1/P2/P3 markers can be displayed for learning/debugging
3) Dynamic weighting (closer targets matter more)
If Dynamic Weights is enabled, each component’s weight increases as the target gets closer to price (within the reach window).
This means the final AVG tends to favor targets that are both reachable and near-term relevant.
You can control:
Base Weight (Fib / Lindsey / ATR)
Dynamic Power (how aggressively “closer” becomes “heavier”)
4) Outlier trimming (stability)
If Trim Outlier Component is enabled, the script:
computes a simple median reference of the remaining component targets
drops any target that deviates from the median by more than
Outlier Threshold × ATR
This reduces sudden jumps when one method produces an unusually extreme projection.
5) Final output: a weighted average (bull + bear)
The remaining eligible components are combined into:
AVG Bull (weighted average of bull candidates)
AVG Bear (weighted average of bear candidates)
If no components pass the reach filter (or are trimmed), the AVG line can temporarily become unavailable until valid inputs re-appear.
How to use it (practical workflow)
Pick your timeframe, then tune ATR:
Start with ATR Length 14 and ATR Mult 1.0–1.5
Set a reasonable Reach Filter (x ATR):
Smaller = only near targets
Larger = includes more distant projections
Decide how you want it to behave:
Dynamic Weights ON for “closer targets dominate”
Outlier Trim ON for smoother / less erratic averages
Use the AVG lines as planning zones, not certainties:
They are best treated as “where price is most likely to seek next” based on the blend of volatility + structure.
A common use is to monitor how price reacts as it approaches either AVG line (stalling, rejection, acceleration), and then reassess as new pivots/ATR values update.
Settings guide (quick)
ATR Length / Multiplier: controls the volatility envelope
Direction Mode: changes the bias input for ATR projection
Lindsey Left/Right: smaller = more sensitive pivots; larger = fewer, more meaningful pivots
Fib Left/Right + Extension: controls the swing structure target
Reach Filter: controls what qualifies as a realistic near-term target
Dynamic Power: higher = stronger preference for the nearest target
Outlier Threshold: higher = fewer removals; lower = more aggressive trimming
Notes / Transparency
This script does not place trades or guarantee outcomes. It is a visual target framework that adapts as volatility and market structure change. For best clarity, publish charts with this script on a clean layout so the AVG lines and labels are easy to identify.
