Amazing Crossover System - 100+ pips per day!I got the main concept for this system on another site. While I have made one important change, I must stress that the heart of this system was created by someone else! We must give credit where credit is due!
Y'all know baby pips. @ForexPhantom published about this system and did both back and forward test around 10 years ago.
I found it on the sit and now I put it to code to see how it performs. I assume 10 points spread for every trade. I use Renesource or AxiTrader to get the low spreads.
There are 2 mods, the single trades and constant trading on the direction.
Main concept
Indicators
5 EMA -- YELLOW
10 EMA -- RED
RSI (10 - Apply to Median Price: HL/2) -- One level at 50.
TIME FRAME
1 Hour Only (very important!)
PAIRS
Virtually any pair seems to work as this is strictly technical analysis.
I recommend sticking to the main currencies and avoiding cross currencies (just his preference).
WHEN TO ENTER A TRADE
Enter LONG when the Yellow EMA crosses the Red EMA from underneath.
RSI must be approaching 50 from the BOTTOM and cross 50 to warrant entry.
Enter SHORT when the Yellow EMA crosses the Red EMA from the top.
RSI must be approaching 50 from the TOP and cross 50 to warrant entry.
I've attached a picture which demonstrates all these conditions.
That's it!
f.bpcdn.co
ابحث في النصوص البرمجية عن "entry"
Build A BotThis is the Robot we built during the 60 Minute Build-A-Bot webinar on September 12, 2018. We had a great time, and a lot of participation and the best part was that we finished up this robot and even ran a backtest in exactly 60 minutes! We built this robot based on recommendations and suggestions from those who were attending live. Lots of pieces in this robot, but you can always tinker with it, remove stuff, add things, whatever you want!
This version uses the CCI as a trigger for trade entry. The other version uses the Hull Moving Average as a trigger for trade entry.
Hoffman A/D BreakoutStudy based on Rob Hoffman's Accumulation/Distribution Breakout strategy.
- Green circle on the top wick indicates a "Distribution" wick
- Red circle on the bottom wick indicates an "Accumulation" wick
- A distribution wick in an uptrend gets marked as a Key Resistance. This is marked with green crosses
- An Accumulation wick in a downtrend gets marked as a Key Support. This is marked with red crosses
- Breaking above the Key Resistance indicates a buy entry. This is marked by a green background.
- Breaking below the Key Support indicates a sell entry. This is marked by a red background
Algorithm Predator - ML-liteAlgorithm Predator - ML-lite
This indicator combines four specialized trading agents with an adaptive multi-armed bandit selection system to identify high-probability trade setups. It is designed for swing and intraday traders who want systematic signal generation based on institutional order flow patterns , momentum exhaustion , liquidity dynamics , and statistical mean reversion .
Core Architecture
Why These Components Are Combined:
The script addresses a fundamental challenge in algorithmic trading: no single detection method works consistently across all market conditions. By deploying four independent agents and using reinforcement learning algorithms to select or blend their outputs, the system adapts to changing market regimes without manual intervention.
The Four Trading Agents
1. Spoofing Detector Agent 🎭
Detects iceberg orders through persistent volume at similar price levels over 5 bars
Identifies spoofing patterns via asymmetric wick analysis (wicks exceeding 60% of bar range with volume >1.8× average)
Monitors order clustering using simplified Hawkes process intensity tracking (exponential decay model)
Signal Logic: Contrarian—fades false breakouts caused by institutional manipulation
Best Markets: Consolidations, institutional trading windows, low-liquidity hours
2. Exhaustion Detector Agent ⚡
Calculates RSI divergence between price movement and momentum indicator over 5-bar window
Detects VWAP exhaustion (price at 2σ bands with declining volume)
Uses VPIN reversals (volume-based toxic flow dissipation) to identify momentum failure
Signal Logic: Counter-trend—enters when momentum extreme shows weakness
Best Markets: Trending markets reaching climax points, over-extended moves
3. Liquidity Void Detector Agent 💧
Measures Bollinger Band squeeze (width <60% of 50-period average)
Identifies stop hunts via 20-bar high/low penetration with immediate reversal and volume spike
Detects hidden liquidity absorption (volume >2× average with range <0.3× ATR)
Signal Logic: Breakout anticipation—enters after liquidity grab but before main move
Best Markets: Range-bound pre-breakout, volatility compression zones
4. Mean Reversion Agent 📊
Calculates price z-scores relative to 50-period SMA and standard deviation (triggers at ±2σ)
Implements Ornstein-Uhlenbeck process scoring (mean-reverting stochastic model)
Uses entropy analysis to detect algorithmic trading patterns (low entropy <0.25 = high predictability)
Signal Logic: Statistical reversion—enters when price deviates significantly from statistical equilibrium
Best Markets: Range-bound, low-volatility, algorithmically-dominated instruments
Adaptive Selection: Multi-Armed Bandit System
The script implements four reinforcement learning algorithms to dynamically select or blend agents based on performance:
Thompson Sampling (Default - Recommended):
Uses Bayesian inference with beta distributions (tracks alpha/beta parameters per agent)
Balances exploration (trying underused agents) vs. exploitation (using proven winners)
Each agent's win/loss history informs its selection probability
Lite Approximation: Uses pseudo-random sampling from price/volume noise instead of true random number generation
UCB1 (Upper Confidence Bound):
Calculates confidence intervals using: average_reward + sqrt(2 × ln(total_pulls) / agent_pulls)
Deterministic algorithm favoring agents with high uncertainty (potential upside)
More conservative than Thompson Sampling
Epsilon-Greedy:
Exploits best-performing agent (1-ε)% of the time
Explores randomly ε% of the time (default 10%, configurable 1-50%)
Simple, transparent, easily tuned via epsilon parameter
Gradient Bandit:
Uses softmax probability distribution over agent preference weights
Updates weights via gradient ascent based on rewards
Best for Blend mode where all agents contribute
Selection Modes:
Switch Mode: Uses only the selected agent's signal (clean, decisive)
Blend Mode: Combines all agents using exponentially weighted confidence scores controlled by temperature parameter (smooth, diversified)
Lock Agent Feature:
Optional manual override to force one specific agent
Useful after identifying which agent dominates your specific instrument
Only applies in Switch mode
Four choices: Spoofing Detector, Exhaustion Detector, Liquidity Void, Mean Reversion
Memory System
Dual-Layer Architecture:
Short-Term Memory: Stores last 20 trade outcomes per agent (configurable 10-50)
Long-Term Memory: Stores episode averages when short-term reaches transfer threshold (configurable 5-20 bars)
Memory Boost Mechanism: Recent performance modulates agent scores by up to ±20%
Episode Transfer: When an agent accumulates sufficient results, averages are condensed into long-term storage
Persistence: Manual restoration of learned parameters via input fields (alpha, beta, weights, microstructure thresholds)
How Memory Works:
Agent generates signal → outcome tracked after 8 bars (performance horizon)
Result stored in short-term memory (win = 1.0, loss = 0.0)
Short-term average influences agent's future scores (positive feedback loop)
After threshold met (default 10 results), episode averaged into long-term storage
Long-term patterns (weighted 30%) + short-term patterns (weighted 70%) = total memory boost
Market Microstructure Analysis
These advanced metrics quantify institutional order flow dynamics:
Order Flow Toxicity (Simplified VPIN):
Measures buy/sell volume imbalance over 20 bars: |buy_vol - sell_vol| / (buy_vol + sell_vol)
Detects informed trading activity (institutional players with non-public information)
Values >0.4 indicate "toxic flow" (informed traders active)
Lite Approximation: Uses simple open/close heuristic instead of tick-by-tick trade classification
Price Impact Analysis (Simplified Kyle's Lambda):
Measures market impact efficiency: |price_change_10| / sqrt(volume_sum_10)
Low values = large orders with minimal price impact ( stealth accumulation )
High values = retail-dominated moves with high slippage
Lite Approximation: Uses simplified denominator instead of regression-based signed order flow
Market Randomness (Entropy Analysis):
Counts unique price changes over 20 bars / 20
Measures market predictability
High entropy (>0.6) = human-driven, chaotic price action
Low entropy (<0.25) = algorithmic trading dominance (predictable patterns)
Lite Approximation: Simple ratio instead of true Shannon entropy H(X) = -Σ p(x)·log₂(p(x))
Order Clustering (Simplified Hawkes Process):
Tracks self-exciting event intensity (coordinated order activity)
Decays at 0.9× per bar, spikes +1.0 when volume >1.5× average
High intensity (>0.7) indicates clustering (potential spoofing/accumulation)
Lite Approximation: Simple exponential decay instead of full λ(t) = μ + Σ α·exp(-β(t-tᵢ)) with MLE
Signal Generation Process
Multi-Stage Validation:
Stage 1: Agent Scoring
Each agent calculates internal score based on its detection criteria
Scores must exceed agent-specific threshold (adjusted by sensitivity multiplier)
Agent outputs: Signal direction (+1/-1/0) and Confidence level (0.0-1.0)
Stage 2: Memory Boost
Agent scores multiplied by memory boost factor (0.8-1.2 based on recent performance)
Successful agents get amplified, failing agents get dampened
Stage 3: Bandit Selection/Blending
If Adaptive Mode ON:
Switch: Bandit selects single best agent, uses only its signal
Blend: All agents combined using softmax-weighted confidence scores
If Adaptive Mode OFF:
Traditional consensus voting with confidence-squared weighting
Signal fires when consensus exceeds threshold (default 70%)
Stage 4: Confirmation Filter
Raw signal must repeat for consecutive bars (default 3, configurable 2-4)
Minimum confidence threshold: 0.25 (25%) enforced regardless of mode
Trend alignment check: Long signals require trend_score ≥ -2, Short signals require trend_score ≤ 2
Stage 5: Cooldown Enforcement
Minimum bars between signals (default 10, configurable 5-15)
Prevents over-trading during choppy conditions
Stage 6: Performance Tracking
After 8 bars (performance horizon), signal outcome evaluated
Win = price moved in signal direction, Loss = price moved against
Results fed back into memory and bandit statistics
Trading Modes (Presets)
Pre-configured parameter sets:
Conservative: 85% consensus, 4 confirmations, 15-bar cooldown
Expected: 60-70% win rate, 3-8 signals/week
Best for: Swing trading, capital preservation, beginners
Balanced: 70% consensus, 3 confirmations, 10-bar cooldown
Expected: 55-65% win rate, 8-15 signals/week
Best for: Day trading, most traders, general use
Aggressive: 60% consensus, 2 confirmations, 5-bar cooldown
Expected: 50-58% win rate, 15-30 signals/week
Best for: Scalping, high-frequency trading, active management
Elite: 75% consensus, 3 confirmations, 12-bar cooldown
Expected: 58-68% win rate, 5-12 signals/week
Best for: Selective trading, high-conviction setups
Adaptive: 65% consensus, 2 confirmations, 8-bar cooldown
Expected: Varies based on learning
Best for: Experienced users leveraging bandit system
How to Use
1. Initial Setup (5 Minutes):
Select Trading Mode matching your style (start with Balanced)
Enable Adaptive Learning (recommended for automatic agent selection)
Choose Thompson Sampling algorithm (best all-around performance)
Keep Microstructure Metrics enabled for liquid instruments (>100k daily volume)
2. Agent Tuning (Optional):
Adjust Agent Sensitivity multipliers (0.5-2.0):
<0.8 = Highly selective (fewer signals, higher quality)
0.9-1.2 = Balanced (recommended starting point)
1.3 = Aggressive (more signals, lower individual quality)
Monitor dashboard for 20-30 signals to identify dominant agent
If one agent consistently outperforms, consider using Lock Agent feature
3. Bandit Configuration (Advanced):
Blend Temperature (0.1-2.0):
0.3 = Sharp decisions (best agent dominates)
0.5 = Balanced (default)
1.0+ = Smooth (equal weighting, democratic)
Memory Decay (0.8-0.99):
0.90 = Fast adaptation (volatile markets)
0.95 = Balanced (most instruments)
0.97+ = Long memory (stable trends)
4. Signal Interpretation:
Green triangle (▲): Long signal confirmed
Red triangle (▼): Short signal confirmed
Dashboard shows:
Active agent (highlighted row with ► marker)
Win rate per agent (green >60%, yellow 40-60%, red <40%)
Confidence bars (█████ = maximum confidence)
Memory size (short-term buffer count)
Colored zones display:
Entry level (current close)
Stop-loss (1.5× ATR)
Take-profit 1 (2.0× ATR)
Take-profit 2 (3.5× ATR)
5. Risk Management:
Never risk >1-2% per signal (use ATR-based stops)
Signals are entry triggers, not complete strategies
Combine with your own market context analysis
Consider fundamental catalysts and news events
Use "Confirming" status to prepare entries (not to enter early)
6. Memory Persistence (Optional):
After 50-100 trades, check Memory Export Panel
Record displayed alpha/beta/weight values for each agent
Record VPIN and Kyle threshold values
Enable "Restore From Memory" and input saved values to continue learning
Useful when switching timeframes or restarting indicator
Visual Components
On-Chart Elements:
Spectral Layers: EMA8 ± 0.5 ATR bands (dynamic support/resistance, colored by trend)
Energy Radiance: Multi-layer glow boxes at signal points (intensity scales with confidence, configurable 1-5 layers)
Probability Cones: Projected price paths with uncertainty wedges (15-bar projection, width = confidence × ATR)
Connection Lines: Links sequential signals (solid = same direction continuation, dotted = reversal)
Kill Zones: Risk/reward boxes showing entry, stop-loss, and dual take-profit targets
Signal Markers: Triangle up/down at validated entry points
Dashboard (Configurable Position & Size):
Regime Indicator: 4-level trend classification (Strong Bull/Bear, Weak Bull/Bear)
Mode Status: Shows active system (Adaptive Blend, Locked Agent, or Consensus)
Agent Performance Table: Real-time win%, confidence, and memory stats
Order Flow Metrics: Toxicity and impact indicators (when microstructure enabled)
Signal Status: Current state (Long/Short/Confirming/Waiting) with confirmation progress
Memory Panel (Configurable Position & Size):
Live Parameter Export: Alpha, beta, and weight values per agent
Adaptive Thresholds: Current VPIN sensitivity and Kyle threshold
Save Reminder: Visual indicator if parameters should be recorded
What Makes This Original
This script's originality lies in three key innovations:
1. Genuine Meta-Learning Framework:
Unlike traditional indicator mashups that simply display multiple signals, this implements authentic reinforcement learning (multi-armed bandits) to learn which detection method works best in current conditions. The Thompson Sampling implementation with beta distribution tracking (alpha for successes, beta for failures) is statistically rigorous and adapts continuously. This is not post-hoc optimization—it's real-time learning.
2. Episodic Memory Architecture with Transfer Learning:
The dual-layer memory system mimics human learning patterns:
Short-term memory captures recent performance (recency bias)
Long-term memory preserves historical patterns (experience)
Automatic transfer mechanism consolidates knowledge
Memory boost creates positive feedback loops (successful strategies become stronger)
This architecture allows the system to adapt without retraining , unlike static ML models that require batch updates.
3. Institutional Microstructure Integration:
Combines retail-focused technical analysis (RSI, Bollinger Bands, VWAP) with institutional-grade microstructure metrics (VPIN, Kyle's Lambda, Hawkes processes) typically found in academic finance literature and professional trading systems, not standard retail platforms. While simplified for Pine Script constraints, these metrics provide insight into informed vs. uninformed trading , a dimension entirely absent from traditional technical analysis.
Mashup Justification:
The four agents are combined specifically for risk diversification across failure modes:
Spoofing Detector: Prevents false breakout losses from manipulation
Exhaustion Detector: Prevents chasing extended trends into reversals
Liquidity Void: Exploits volatility compression (different regime than trending)
Mean Reversion: Provides mathematical anchoring when patterns fail
The bandit system ensures the optimal tool is automatically selected for each market situation, rather than requiring manual interpretation of conflicting signals.
Why "ML-lite"? Simplifications and Approximations
This is the "lite" version due to necessary simplifications for Pine Script execution:
1. Simplified VPIN Calculation:
Academic Implementation: True VPIN uses volume bucketing (fixed-volume bars) and tick-by-tick buy/sell classification via Lee-Ready algorithm or exchange-provided trade direction flags
This Implementation: 20-bar rolling window with simple open/close heuristic (close > open = buy volume)
Impact: May misclassify volume during ranging/choppy markets; works best in directional moves
2. Pseudo-Random Sampling:
Academic Implementation: Thompson Sampling requires true random number generation from beta distributions using inverse transform sampling or acceptance-rejection methods
This Implementation: Deterministic pseudo-randomness derived from price and volume decimal digits: (close × 100 - floor(close × 100)) + (volume % 100) / 100
Impact: Not cryptographically random; may have subtle biases in specific price ranges; provides sufficient variation for agent selection
3. Hawkes Process Approximation:
Academic Implementation: Full Hawkes process uses maximum likelihood estimation with exponential kernels: λ(t) = μ + Σ α·exp(-β(t-tᵢ)) fitted via iterative optimization
This Implementation: Simple exponential decay (0.9 multiplier) with binary event triggers (volume spike = event)
Impact: Captures self-exciting property but lacks parameter optimization; fixed decay rate may not suit all instruments
4. Kyle's Lambda Simplification:
Academic Implementation: Estimated via regression of price impact on signed order flow over multiple time intervals: Δp = λ × Δv + ε
This Implementation: Simplified ratio: price_change / sqrt(volume_sum) without proper signed order flow or regression
Impact: Provides directional indicator of impact but not true market depth measurement; no statistical confidence intervals
5. Entropy Calculation:
Academic Implementation: True Shannon entropy requires probability distribution: H(X) = -Σ p(x)·log₂(p(x)) where p(x) is probability of each price change magnitude
This Implementation: Simple ratio of unique price changes to total observations (variety measure)
Impact: Measures diversity but not true information entropy with probability weighting; less sensitive to distribution shape
6. Memory System Constraints:
Full ML Implementation: Neural networks with backpropagation, experience replay buffers (storing state-action-reward tuples), gradient descent optimization, and eligibility traces
This Implementation: Fixed-size array queues with simple averaging; no gradient-based learning, no state representation beyond raw scores
Impact: Cannot learn complex non-linear patterns; limited to linear performance tracking
7. Limited Feature Engineering:
Advanced Implementation: Dozens of engineered features, polynomial interactions (x², x³), dimensionality reduction (PCA, autoencoders), feature selection algorithms
This Implementation: Raw agent scores and basic market metrics (RSI, ATR, volume ratio); minimal transformation
Impact: May miss subtle cross-feature interactions; relies on agent-level intelligence rather than feature combinations
8. Single-Instrument Data:
Full Implementation: Multi-asset correlation analysis (sector ETFs, currency pairs, volatility indices like VIX), lead-lag relationships, risk-on/risk-off regimes
This Implementation: Only OHLCV data from displayed instrument
Impact: Cannot incorporate broader market context; vulnerable to correlated moves across assets
9. Fixed Performance Horizon:
Full Implementation: Adaptive horizon based on trade duration, volatility regime, or profit target achievement
This Implementation: Fixed 8-bar evaluation window
Impact: May evaluate too early in slow markets or too late in fast markets; one-size-fits-all approach
Performance Impact Summary:
These simplifications make the script:
✅ Faster: Executes in milliseconds vs. seconds (or minutes) for full academic implementations
✅ More Accessible: Runs on any TradingView plan without external data feeds, APIs, or compute servers
✅ More Transparent: All calculations visible in Pine Script (no black-box compiled models)
✅ Lower Resource Usage: <500 bars lookback, minimal memory footprint
⚠️ Less Precise: Approximations may reduce statistical edge by 5-15% vs. academic implementations
⚠️ Limited Scope: Cannot capture tick-level dynamics, multi-order-book interactions, or cross-asset flows
⚠️ Fixed Parameters: Some thresholds hardcoded rather than dynamically optimized
When to Upgrade to Full Implementation:
Consider professional Python/C++ versions with institutional data feeds if:
Trading with >$100K capital where precision differences materially impact returns
Operating in microsecond-competitive environments (HFT, market making)
Requiring regulatory-grade audit trails and reproducibility
Backtesting with tick-level precision for strategy validation
Need true real-time adaptation with neural network-based learning
For retail swing/day trading and position management, these approximations provide sufficient signal quality while maintaining usability, transparency, and accessibility. The core logic—multi-agent detection with adaptive selection—remains intact.
Technical Notes
All calculations use standard Pine Script built-in functions ( ta.ema, ta.atr, ta.rsi, ta.bb, ta.sma, ta.stdev, ta.vwap )
VPIN and Kyle's Lambda use simplified formulas optimized for OHLCV data (see "Lite" section above)
Thompson Sampling uses pseudo-random noise from price/volume decimal digits for beta distribution sampling
No repainting: All calculations use confirmed bar data (no forward-looking)
Maximum lookback: 500 bars (set via max_bars_back parameter)
Performance evaluation: 8-bar forward-looking window for reward calculation (clearly disclosed)
Confidence threshold: Minimum 0.25 (25%) enforced on all signals
Memory arrays: Dynamic sizing with FIFO queue management
Limitations and Disclaimers
Not Predictive: This indicator identifies patterns in historical data. It cannot predict future price movements with certainty.
Requires Human Judgment: Signals are entry triggers, not complete trading strategies. Must be confirmed with your own analysis, risk management rules, and market context.
Learning Period Required: The adaptive system requires 50-100 bars minimum to build statistically meaningful performance data for bandit algorithms.
Overfitting Risk: Restoring memory parameters from one market regime to a drastically different regime (e.g., low volatility to high volatility) may cause poor initial performance until system re-adapts.
Approximation Limitations: Simplified calculations (see "Lite" section) may underperform academic implementations by 5-15% in highly efficient markets.
No Guarantee of Profit: Past performance, whether backtested or live-traded, does not guarantee future performance. All trading involves risk of loss.
Forward-Looking Bias: Performance evaluation uses 8-bar forward window—this creates slight look-ahead for learning (though not for signals). Real-time performance may differ from indicator's internal statistics.
Single-Instrument Limitation: Does not account for correlations with related assets or broader market regime changes.
Recommended Settings
Timeframe: 15-minute to 4-hour charts (sufficient volatility for ATR-based stops; adequate bar volume for learning)
Assets: Liquid instruments with >100k daily volume (forex majors, large-cap stocks, BTC/ETH, major indices)
Not Recommended: Illiquid small-caps, penny stocks, low-volume altcoins (microstructure metrics unreliable)
Complementary Tools: Volume profile, order book depth, market breadth indicators, fundamental catalysts
Position Sizing: Risk no more than 1-2% of capital per signal using ATR-based stop-loss
Signal Filtering: Consider external confluence (support/resistance, trendlines, round numbers, session opens)
Start With: Balanced mode, Thompson Sampling, Blend mode, default agent sensitivities (1.0)
After 30+ Signals: Review agent win rates, consider increasing sensitivity of top performers or locking to dominant agent
Alert Configuration
The script includes built-in alert conditions:
Long Signal: Fires when validated long entry confirmed
Short Signal: Fires when validated short entry confirmed
Alerts fire once per bar (after confirmation requirements met)
Set alert to "Once Per Bar Close" for reliability
Taking you to school. — Dskyz, Trade with insight. Trade with anticipation.
Boss Short Setup ScannerThis indicator identifies a specific short setup based on trend and candle structure.
Conditions include:
• 20 EMA below 50 EMA (downtrend confirmation)
• Price trading below both EMAs
• Bearish flip candle (shift from buyers to sellers)
• Confirmation candle closing below the flip candle’s low
When all criteria align, the script plots a signal to highlight a potential short entry.
This is designed for trade identification only — always confirm with your own supply zones, market structure, volume context, and risk management plan.
This script does not execute trades automatically.
OsMA by A8/4 - Limited Edition🌟 **OsMA by A8/4 — The Ultimate Indicator for XAUUSD Trading** 🌟
An intelligent **automated system** designed exclusively for **gold trading**, equipped with everything you need in one tool 🔥
💡 **Key Features of OsMA by A8/4**
✅ **Auto Entry Signals**
Automatically detects trade opportunities using a **refined MACD Histogram formula** for enhanced accuracy.
Displays **LONG/SHORT arrows only on the first bar** to keep your chart clean and readable.
✅ **Auto Take Profit & Stop Loss System (Auto TP/SL)**
Once a signal appears, the system automatically sets:
* **TP1 = +15 USD**
* **TP2 = +25 USD**
* **SL = -10 USD**
These levels are displayed as **dashed lines** on the chart — clear and updated in real-time.
✅ **Smart DCA System (3 Orders)**
Works for both LONG and SHORT positions:
* **Order 1:** Entry upon signal confirmation (after candle close)
* **Order 2:** Entry at 5 USD below/above Order 1
* **Order 3:** Entry at another 5 USD below/above Order 2
The system automatically **calculates the average entry price** and **adjusts the SL** to -10 USD from the average cost.
This helps **spread risk** and **increase recovery potential** when prices rebound 💰
✅ **Specially Designed for XAUUSD Trading**
Compatible with both **Spot Gold** and **TFEX Gold Futures**.
Perfect for traders who value **clear, structured entry and exit strategies**.
MAOs🌟 **MAOs By A8/4 — The Ultimate Indicator for XAUUSD Trading** 🌟
An intelligent **automated system** designed exclusively for **gold trading**, equipped with everything you need in one tool 🔥
💡 **Key Features of MAOs By A8/4**
✅ **Auto Entry Signals**
Automatically detects trade opportunities using a **refined MACD Histogram formula** for enhanced accuracy.
Displays **LONG/SHORT arrows only on the first bar** to keep your chart clean and readable.
✅ **Auto Take Profit & Stop Loss System (Auto TP/SL)**
Once a signal appears, the system automatically sets:
* **TP1 = +15 USD**
* **TP2 = +25 USD**
* **SL = -10 USD**
These levels are displayed as **dashed lines** on the chart — clear and updated in real-time.
✅ **Smart DCA System (3 Orders)**
Works for both LONG and SHORT positions:
* **Order 1:** Entry upon signal confirmation (after candle close)
* **Order 2:** Entry at 5 USD below/above Order 1
* **Order 3:** Entry at another 5 USD below/above Order 2
The system automatically **calculates the average entry price** and **adjusts the SL** to -10 USD from the average cost.
This helps **spread risk** and **increase recovery potential** when prices rebound 💰
✅ **Specially Designed for XAUUSD Trading**
Compatible with both **Spot Gold** and **TFEX Gold Futures**.
Perfect for traders who value **clear, structured entry and exit strategies**.
Put Option Profits inspired by Travis Wilkerson; SPX BacktesterPut Option Profits — Travis Wilkerson inspired. This tester evaluates a simple monthly SPX at-the-money credit-spread timing idea: enter on a fixed calendar rule (e.g., 1st Friday or 8th day with business-day shifting) at Open or Close, then exit exactly N calendar days later (first tradable day >= target, at Close). A trade is marked WIN if price at exit is above the entry price (1:1 risk proxy).
The book suggests forward testing 60-day and 180-day expirations to prove the concept. This tool lets you backtest both (and more) to see what actually works best. In the book, profits are taken when the spread reaches ~80% of max credit; losers are left to expire and cash-settle. This backtester does not model early profit-taking—every trade is held to the configured hold period and evaluated on price vs entry at the exit close. Think of it as a pure “set it and forget it” stress test. In live trading, you can still follow Travis’s 80% take-profit rule; TradingView just doesn’t simulate that here. Happy trading!
Features:
Schedule: Day-of-Month (with Prev/Next business-day shift, optional “stay in month”) or Nth Weekday (e.g., 1st Friday).
Entry timing: Open or Close.
Exit: N calendar days later at Close (holiday/weekend aware).
Filters: Optional EMA-200 “risk-on” filter.
Scope: Date range limiter.
Visuals: Entry/exit bubbles (paired colors) or simple win/loss dots.
Table: Overall Win% and N (within range).
Alerts: Entry alert (static condition + dynamic alert() message).
How to use:
[* ]Choose Start Mode (NthWeekday or DayOfMonth) and parameters (e.g., 1st Friday or DOM=8, PrevBizDay).
Pick Entry Timing (Open or Close).
Set Days In Trade (e.g., 150).
(Optional) Enable EMA filter and set Date Range.
Turn Bubbles on/off and/or Dots on/off.
Create alert:
Simple ping: Condition = this indicator -> Monthly Entry Signal -> “Once per bar” (Open) or “Once per bar close” (Close).
Rich message: Condition = this indicator -> Any alert() function call.
Notes:
Keep DOM shift in same month: when a DOM falls on a weekend/holiday, PrevBizDay/NextBizDay shift will stay inside the month if enabled; otherwise it can spill into the prior/next month. (Ignored for NthWeekday.)
Credits: Concept sparked by “Put Option Profits – How to turn ten minutes of free time into consistent cash flow each month” by Travis Wilkerson; this script is a neutral research tool (not financial advice).
Target Trend + Filter Toggles Strategy [ChadAnt]The strategy aims to enter a trade when the price crosses over/under a dynamic trend band and when a combination of user-selected filters confirms the move.
1. Trend Bands (Entry)
The core trend is defined by two smoothed moving averages (SMA based on length input) offset by a smoothed Average True Range (ATR) value.
Upper Band (sma_high): ta.sma(high, length) + atr_value
Lower Band (sma_low): ta.sma(low, length) - atr_value
atr_value is ta.sma(ta.atr(atrLength), smaLength) * atrMultiplier.
Trend Determination:
Long Trend (trend = true): Price crossovers the sma_high band.
Short Trend (trend = false): Price crossesunder the sma_low band.
Raw Signal: A trade signal (signal_up_raw / signal_down_raw) is triggered only when the trend state changes.
2. Stop Loss and Take Profit
Stop Loss (SL):
For a Long entry, the original stop price is the Lower Band (sma_low) at the time of the cross.
For a Short entry, the original stop price is the Upper Band (sma_high) at the time of the cross.
The Stop Loss Price is calculated using the distance from the entry price to the original stop, adjusted by the slAdjustment multiplier.
Take Profit (TP):
Calculated based on a Risk/Reward (R:R) ratio, which is rr_increment * tp_target_number.
TP Distance = Adjusted Stop Distance * R:R Ratio.
The strategy enters and exits in a single order pair using strategy.entry and strategy.exit, using the calculated stop_loss_price and take_profit_price.
3. Filters and Confirmation
The strategy includes toggles (use_..._filter) for many popular indicators: MACD, Volume, StochRSI, Awesome Oscillator (AO), and Moving Average/VWAP (Trend/Counter-Trend).
Filter Logic: Each filter checks for its specific confirmation condition (e.g., MACD zero-cross, AO color change, StochRSI out of extreme, Volume > SMA, Price above MA).
Lookback Period: The script uses a for loop (i = 0 to filter_lookback) to check if the required confirmation happened within the last filter_lookback bars.
Final Signal: The actual entry signal (signal_up / signal_down) is triggered only if the Raw Trend Change Signal occurs AND all currently active (toggled on) filters had their required confirmation event within the lookback period AND the trade is within the Time Window.
The draw_targets method is responsible for the powerful visual display on the chart:
When a new filtered signal occurs, it clears any old lines/labels and draws the new:
Entry line
Stop Loss line
Multiple Take Profit lines (up to num_targets), with the strategy's active TP level highlighted (🎯).
It also features logic to dynamically change the label/line of a TP level to a "✔" or the SL level to a "✖" if the price touches that level on subsequent bars.
The strategy is a highly flexible, multi-factor system built on the concept of trend reversal confirmation.
Target Trend + Filter Toggles [ChadAnt] V3Minor Update that allows the user to adjust the size of the stop loss.
Indicator Overview and Core Logic CREDIT TO BIGBELUGA FOR THE MAIN INDICATOR
The indicator, named "Target Trend + Filter Toggles", is an overlay that draws directly on the price chart.
1. Core Trend Detection (Modified SMA Channel)
The indicator uses a primary trend-following mechanism based on a custom channel built with Simple Moving Averages (SMAs) and Average True Range (ATR):
SMA High: ta.sma(high, length) + atr_value
SMA Low: ta.sma(low, length) - atr_value
The length is set by the user (default 20).
The atr_value is a smoothed ATR (SMA of ATR(200), multiplied by 0.8), acting as an offset to create a channel around the price action.
Trend Logic:
Uptrend (trend=true): When the close price crosses over the sma_high line.
Downtrend (trend=false): When the close price crosses under the sma_low line.
Visual Trend: The candles are colored based on this determined trend, and the SMA High/Low lines are plotted.
2. Signal Generation (Raw vs. Filtered)
Raw Signal: A raw signal (signal_up_raw or signal_down_raw) is triggered simply when the core trend logic changes (e.g., trend changes from down to up).
Filtered Signal: The final buy/sell signal (signal_up or signal_down) is triggered only when the raw signal is true AND all currently active filter toggles are confirmed within a specified filter_lookback period (default 3 bars).
⚙️ Filter Toggles and Calculations
The script includes an extensive system of boolean (on/off) toggles for various popular technical indicators, allowing the user to customize which filters must be confirmed for a signal to be valid.
FILTER CATEGORIES:
MACD,
VOLUME,
STOCHRSI,
AWESOME OSCILLATOR,
MOVING AVERAGE,
VWAP,
COUNTERTREND MA
COUNTERTREND VWAP
The script uses a for loop to check if the required confirmation happened within the last filter_lookback number of bars.
🎯 Target and Stop-Loss Levels
Upon a valid filtered signal (signal_up or signal_down), the indicator uses an extensive user-defined type (TrendTargets) and a custom draw_targets method to draw potential trade management lines:
Entry Price: The close price of the bar where the filtered signal occurred.
Stop Loss (SL):
For a Long signal: The sma_low line (the lower band of the trend channel).
For a Short signal: The sma_high line (the upper band of the trend channel).
Profit Targets (T1, T2, T3): These are calculated based on the ATR multiplier (atr_value) and an adjustable user input called target (default 1).
Targets are a multiple of atr_value added to (for longs) or subtracted from (for shorts) the Entry Price.
T1: Entry +/- (5 + target) * atr_value
T2: Entry +/- (10 + target * 2) * atr_value
T3: Entry +/- (15 + target * 3) * atr_value
These levels are plotted as extended lines with corresponding labels (e.g., "SL," "Entry," "T1"). The script also includes logic to mark targets with a "✔" and the stop-loss with an "✖" if the price hits those levels.
🎨 Visualization
The script provides clear visual cues:
Candle Coloring: Candles are colored with up_color (Green/Teal) for an uptrend and dn_color (Brown/Orange) for a downtrend.
Trend Lines: The sma_high and sma_low lines are plotted and subtly shaded between the price action.
Signal Shapes: A filtered signal triggers a set of two colored triangles (one small solid, one large transparent) plotted below the low for a long signal and above the high for a short signal.
Trade Zones: The area between the Stop Loss and the Entry line is shaded in the counter-trend color, and the area between the Entry line and the T3 line is shaded in the trend color.
This indicator is essentially a complete trading system that uses a combination of an ATR-based trend channel for entries, a multitude of technical indicators for confirmation, and an ATR-based system for trade management (SL/TPs).
Would you like me to focus on a specific filter's logic, or perhaps help you configure the indicator's inputs for a certain trading style?
Target Trend + Filter Toggles [ChadAnt] V2Minor Update that allows the user to add/remove profit targets!
Indicator Overview and Core Logic CREDIT TO BIGBELUGA FOR THE MAIN INDICATOR
The indicator, named "Target Trend + Filter Toggles", is an overlay that draws directly on the price chart.
1. Core Trend Detection (Modified SMA Channel)
The indicator uses a primary trend-following mechanism based on a custom channel built with Simple Moving Averages (SMAs) and Average True Range (ATR):
SMA High: ta.sma(high, length) + atr_value
SMA Low: ta.sma(low, length) - atr_value
The length is set by the user (default 20).
The atr_value is a smoothed ATR (SMA of ATR(200), multiplied by 0.8), acting as an offset to create a channel around the price action.
Trend Logic:
Uptrend (trend=true): When the close price crosses over the sma_high line.
Downtrend (trend=false): When the close price crosses under the sma_low line.
Visual Trend: The candles are colored based on this determined trend, and the SMA High/Low lines are plotted.
2. Signal Generation (Raw vs. Filtered)
Raw Signal: A raw signal (signal_up_raw or signal_down_raw) is triggered simply when the core trend logic changes (e.g., trend changes from down to up).
Filtered Signal: The final buy/sell signal (signal_up or signal_down) is triggered only when the raw signal is true AND all currently active filter toggles are confirmed within a specified filter_lookback period (default 3 bars).
⚙️ Filter Toggles and Calculations
The script includes an extensive system of boolean (on/off) toggles for various popular technical indicators, allowing the user to customize which filters must be confirmed for a signal to be valid.
FILTER CATEGORIES:
MACD,
VOLUME,
STOCHRSI,
AWESOME OSCILLATOR,
MOVING AVERAGE,
VWAP,
COUNTERTREND MA
COUNTERTREND VWAP
The script uses a for loop to check if the required confirmation happened within the last filter_lookback number of bars.
🎯 Target and Stop-Loss Levels
Upon a valid filtered signal (signal_up or signal_down), the indicator uses an extensive user-defined type (TrendTargets) and a custom draw_targets method to draw potential trade management lines:
Entry Price: The close price of the bar where the filtered signal occurred.
Stop Loss (SL):
For a Long signal: The sma_low line (the lower band of the trend channel).
For a Short signal: The sma_high line (the upper band of the trend channel).
Profit Targets (T1, T2, T3): These are calculated based on the ATR multiplier (atr_value) and an adjustable user input called target (default 1).
Targets are a multiple of atr_value added to (for longs) or subtracted from (for shorts) the Entry Price.
T1: Entry +/- (5 + target) * atr_value
T2: Entry +/- (10 + target * 2) * atr_value
T3: Entry +/- (15 + target * 3) * atr_value
These levels are plotted as extended lines with corresponding labels (e.g., "SL," "Entry," "T1"). The script also includes logic to mark targets with a "✔" and the stop-loss with an "✖" if the price hits those levels.
🎨 Visualization
The script provides clear visual cues:
Candle Coloring: Candles are colored with up_color (Green/Teal) for an uptrend and dn_color (Brown/Orange) for a downtrend.
Trend Lines: The sma_high and sma_low lines are plotted and subtly shaded between the price action.
Signal Shapes: A filtered signal triggers a set of two colored triangles (one small solid, one large transparent) plotted below the low for a long signal and above the high for a short signal.
Trade Zones: The area between the Stop Loss and the Entry line is shaded in the counter-trend color, and the area between the Entry line and the T3 line is shaded in the trend color.
This indicator is essentially a complete trading system that uses a combination of an ATR-based trend channel for entries, a multitude of technical indicators for confirmation, and an ATR-based system for trade management (SL/TPs).
Would you like me to focus on a specific filter's logic, or perhaps help you configure the indicator's inputs for a certain trading style?
Target Trend + Filter Toggles ChadAntIndicator Overview and Core Logic CREDIT TO BIGBELUGA FOR THE MAIN INDICATOR
The indicator, named "Target Trend + Filter Toggles", is an overlay that draws directly on the price chart.
1. Core Trend Detection (Modified SMA Channel)
The indicator uses a primary trend-following mechanism based on a custom channel built with Simple Moving Averages (SMAs) and Average True Range (ATR):
SMA High: ta.sma(high, length) + atr_value
SMA Low: ta.sma(low, length) - atr_value
The length is set by the user (default 20).
The atr_value is a smoothed ATR (SMA of ATR(200), multiplied by 0.8), acting as an offset to create a channel around the price action.
Trend Logic:
Uptrend (trend=true): When the close price crosses over the sma_high line.
Downtrend (trend=false): When the close price crosses under the sma_low line.
Visual Trend: The candles are colored based on this determined trend, and the SMA High/Low lines are plotted.
2. Signal Generation (Raw vs. Filtered)
Raw Signal: A raw signal (signal_up_raw or signal_down_raw) is triggered simply when the core trend logic changes (e.g., trend changes from down to up).
Filtered Signal: The final buy/sell signal (signal_up or signal_down) is triggered only when the raw signal is true AND all currently active filter toggles are confirmed within a specified filter_lookback period (default 3 bars).
⚙️ Filter Toggles and Calculations
The script includes an extensive system of boolean (on/off) toggles for various popular technical indicators, allowing the user to customize which filters must be confirmed for a signal to be valid.
FILTER CATEGORIES:
MACD,
VOLUME,
STOCHRSI,
AWESOME OSCILLATOR,
MOVING AVERAGE,
VWAP,
COUNTERTREND MA
COUNTERTREND VWAP
The script uses a for loop to check if the required confirmation happened within the last filter_lookback number of bars.
🎯 Target and Stop-Loss Levels
Upon a valid filtered signal (signal_up or signal_down), the indicator uses an extensive user-defined type (TrendTargets) and a custom draw_targets method to draw potential trade management lines:
Entry Price: The close price of the bar where the filtered signal occurred.
Stop Loss (SL):
For a Long signal: The sma_low line (the lower band of the trend channel).
For a Short signal: The sma_high line (the upper band of the trend channel).
Profit Targets (T1, T2, T3): These are calculated based on the ATR multiplier (atr_value) and an adjustable user input called target (default 1).
Targets are a multiple of atr_value added to (for longs) or subtracted from (for shorts) the Entry Price.
T1: Entry +/- (5 + target) * atr_value
T2: Entry +/- (10 + target * 2) * atr_value
T3: Entry +/- (15 + target * 3) * atr_value
These levels are plotted as extended lines with corresponding labels (e.g., "SL," "Entry," "T1"). The script also includes logic to mark targets with a "✔" and the stop-loss with an "✖" if the price hits those levels.
🎨 Visualization
The script provides clear visual cues:
Candle Coloring: Candles are colored with up_color (Green/Teal) for an uptrend and dn_color (Brown/Orange) for a downtrend.
Trend Lines: The sma_high and sma_low lines are plotted and subtly shaded between the price action.
Signal Shapes: A filtered signal triggers a set of two colored triangles (one small solid, one large transparent) plotted below the low for a long signal and above the high for a short signal.
Trade Zones: The area between the Stop Loss and the Entry line is shaded in the counter-trend color, and the area between the Entry line and the T3 line is shaded in the trend color.
This indicator is essentially a complete trading system that uses a combination of an ATR-based trend channel for entries, a multitude of technical indicators for confirmation, and an ATR-based system for trade management (SL/TPs).
Would you like me to focus on a specific filter's logic, or perhaps help you configure the indicator's inputs for a certain trading style?
W%R Pullback+EMA Trend [TS_Indie]🔰 Core Concept of the Strategy
The main idea is “Trend-Following with Momentum Pullback.”
This means trading in the direction of the main trend (defined by EMA) while using Williams %R to identify pullback entries (buying the dip or selling the rally) where momentum returns to the trend direction.
📊 Indicators Used
1. EMA Fast – Defines the short-term trend.
2. EMA Slow – Defines the long-term trend (used as a trend filter).
3. Williams %R
• Overbought zone: above -20
• Oversold zone: below -80
⚙️ Entry Rules
🔹 Buy Setup
1. EMA Fast > EMA Slow → Uptrend condition.
2. Williams %R on the previous candle dropped below -80, and on the current candle, it crosses back above -80 → indicates momentum returning to the upside.
3. Current close is above EMA Fast.
4. Entry Buy at the close of the candle where %R crosses above -80.
🎯 Entry, Stop Loss, and Take Profit
1. Entry : At the candle close where the signal occurs.
2. Stop Loss : At the lowest low between the current and previous candles.
3. Take Profit : Calculated based on entry price and stop loss distance multiplied by the Risk/Reward Ratio.
🔹 Sell Setup
1. EMA Fast < EMA Slow → Downtrend condition.
2. Williams %R on the previous candle went above -20, and on the current candle, it crosses back below -20 → indicates renewed selling momentum.
3. Current price is below EMA Fast.
4. Entry Sell at the close of the candle where %R crosses below -20.
🎯 Entry, Stop Loss, and Take Profit
1. Entry : At the candle close where the signal occurs.
2. Stop Loss : At the highest high between the current and previous candles.
3. Take Profit : Calculated based on entry price and stop loss distance multiplied by the Risk/Reward Ratio.
⚙️ Optional Parameters
• Custom Risk/Reward Ratio for Take Profit.
• Option to add ATR buffer to Stop Loss.
• Adjustable EMA Fast period.
• Adjustable EMA Slow period.
• Adjustable Williams %R period.
• Option to enable Long only / Short only positions.
• Customizable Backtest start and end date.
• Customizable trading session time.
⏰ Alert Function
Alerts display:
• Entry price
• Stop Loss price
• Take Profit price
Guys, try adjusting the parameters yourselves!
I’ve been tweaking the settings for several days and managed to get great results on XAU/USD in the 5-minute timeframe.
I think this strategy is quite interesting and could potentially deliver good results on other instruments as well.
⚠️ Disclaimer
This indicator is designed for educational and research purposes only.
It does not guarantee profits and should not be considered financial advice.
Trading in financial markets involves significant risk, including the potential loss of capital.
Daily Pivot Breakout Strategy IndicatorTagline:
A pivot-based breakout system that identifies confirmed daily breakouts with momentum and volume filters, with precise entry timing across all timeframes.
How It Works:
This indicator detects strict pivot high breakouts on daily data, filtered by Rate of Change (ROC ≥30%) and Relative Volume (RVOL >1). It displays both the breakout confirmation signal and the next-day entry signal directly on your chart, regardless of timeframe.
Visual Signals:
Orange Pivot Line: The most recent confirmed pivot high (within 250-day lookback)
Day-0 Label (Teal): Appears on the breakout confirmation day (when price closes above daily pivot with filters met)
Entry Banner (Green): Appears on the next trading day at market open - your actual entry point
Cross-Timeframe Consistency:
Daily Chart: View the big picture - Day-0 on breakout bar, Entry on next bar
Any Timeframe: Logic remains consistent to daily pivots and data, signals adapt to show at the correct time
Built-in Alert Conditions:
5PivotBreakout_Scan (Day-0): Fires when breakout is confirmed. Use this for after-hours scanning to build watchlists of confirmed breakouts
5PivotBreakout_Strategy (Next): Fires at market open the next day. Use this to automate entries on confirmed breakouts
Typical Workflow:
Set up Day-0 alerts on your watchlist to catch breakouts as they happen
Review confirmed breakouts each evening
Set up Entry alerts on selected tickers to automate next-day execution (fires at market open)
Optional: Convert to strategy() for backtesting with custom exits (20% trail is good)
Key Features:
Strict pivot detection: No ties allowed - center must be highest point
Momentum filter: 100-day ROC ensures trending strength
Volume confirmation: 20-day RVOL validates participation
No repainting: Uses lookahead_off for realistic, tradeable signals
Customizable Inputs:
Pivot strength parameters (left/right bars)
Pivot lookback period
ROC period and minimum threshold
RVOL period
Toggle visibility of pivot line and labels
Note: This indicator is for educational purposes only and does not constitute financial advice. Past performance does not guarantee future results. Always test thoroughly before live trading.
Complete DashboardPA+AI PRE/GO Trading Dashboard v0.1.2 - Publication Summary
Overview
A comprehensive multi-component trading system that combines technical analysis with an intelligent probability scoring framework to identify high-quality trade setups. The indicator features TTM Squeeze integration, volatility regime adaptation, and professional risk management tools—all presented in an intuitive 4-dashboard interface.
Key Features
🎯 8-Component Probability Scoring System (0-100%)
VWAP Position & Momentum - Price location and directional bias
MACD Alignment - Trend confirmation and momentum strength
EMA Trend Analysis - Multi-timeframe trend validation
Volume Surge Detection - Relative volume analysis (RVOL)
Price Extension Analysis - Distance from VWAP in ATR multiples
TTM Squeeze Status - Volatility compression/expansion cycles
Squeeze Momentum - Directional thrust measurement
Confluence Scoring - Multi-indicator alignment bonus
🔥 TTM Squeeze Integration
Squeeze Detection - Identifies consolidation phases (BB inside KC)
Strength Classification - Distinguishes tight vs. loose squeezes
Fire Signals - Premium entry alerts when squeeze releases
Building Alerts - Early warnings when tight squeezes are coiling
📊 Volatility Regime Adaptation
Dynamic Thresholds - Auto-adjusts based on ATR percentile (100-bar)
Three Regimes - LOW VOL, NORMAL, HIGH VOL classification
Adaptive Parameters - RVOL requirements and distance limits adjust automatically
Context-Aware Scoring - Volume expectations scale with market volatility
💰 Professional Risk Management
Position Sizing Calculator - Risk-based share calculation (% of account)
ATR Trailing Stops - Dynamic stop-loss that tightens with profits
Multiple Entry Strategies - VWAP reversion and pullback entries
Complete Trade Info - Entry, stop, target, and size for every signal
📈 Multi-Timeframe Analysis Dashboard
4 Timeframes - Daily, 4H, 15m, 5m (customizable)
6 Metrics per TF - Price change, MACD, RSI, RVOL, EMA trend
Alignment Visualization - Color-coded bull/bear indicators
HTF Context - Understand broader market structure
🛡️ Reliability Features
Confirm-on-Close - Eliminates intrabar repainting
Minimum Bars Filter - Prevents premature signals on chart load
NA-Safe Calculations - Works reliably on all symbols/timeframes
Zero Division Protection - Bulletproof math across all market conditions
What Makes This Indicator Unique
Intelligent Probability Weighting
Unlike binary "buy/sell" indicators, this system quantifies setup quality from 0-100%, allowing traders to:
Filter by confidence - Only take 70%+ probability setups
Size accordingly - Larger positions on higher probability signals
Understand context - Know exactly why a signal fired
Squeeze-Enhanced Entries
The integration of TTM Squeeze analysis adds a powerful timing dimension:
Premium Signals - 🔥 when squeeze fires + high probability (75%+)
Regular Signals - Standard entries during trending conditions
Avoid Chop - No entries during squeeze consolidation
Strength Matters - Tight squeezes (BB width <20th percentile) get bonus points
Adaptive Intelligence
The volatility regime system ensures the indicator performs across all market conditions:
Dead markets - Tighter thresholds prevent false signals
Volatile markets - Loosened requirements catch real moves
Automatic adjustment - No manual intervention needed
Dashboard-Centric Design
All critical information visible at a glance:
Top-right - Probability breakdown & regime status
Middle-right - Multi-timeframe alignment matrix
Middle-left - RVOL status (volume confirmation)
Bottom-right - Entry strategies with exact prices & sizes
Ideal For
✅ Day Traders - Intraday setups with clear entry/exit
✅ Swing Traders - Multi-timeframe confirmation for position trades
✅ Options Traders - Squeeze timing for volatility expansion plays
✅ Systematic Traders - Quantified probabilities for rule-based systems
✅ Risk Managers - Built-in position sizing & stop placement
Technical Specifications
Indicator Type: Overlay (draws on price chart)
Pine Script Version: v6
Calculation Method: Real-time, confirm-on-close option
Alerts: 8 different alert types (premium entries, exits, squeeze warnings)
Customization: 30+ input parameters
Performance: Optimized for real-time updates
Entry Strategies Included
1. VWAP Reversion
Enter when price bounces off VWAP ± 0.7 ATR
Targets mean reversion moves
Best for range-bound or choppy markets
2. Pullback to Structure
Enter on 50% retracement from swing high/low
Targets trend continuation after healthy pullback
Best for strong trending markets
Both strategies include:
Precise entry levels
ATR-based stop placement
Risk/reward targets
Position size calculation
Alert System
8 Alert Types:
🔥 Premium Long - Squeeze firing + bullish + high probability
🔥 Premium Short - Squeeze firing + bearish + high probability
🟢 High Probability Long - Standard bullish setup (70%+)
🔴 High Probability Short - Standard bearish setup (70%+)
⚡ Squeeze Coiling Long - Tight squeeze building, bullish bias
⚡ Squeeze Coiling Short - Tight squeeze building, bearish bias
Exit Long - Long position exit signal
Exit Short - Short position exit signal
Settings & Customization
Basic Settings
ATR Length (default: 14)
Confirm on Close (default: ON)
Minimum Bars Required (default: 50)
Squeeze Settings
Bollinger Band Length & Multiplier
Keltner Channel Length & Multiplier
Momentum Length
Squeeze strength classification
Probability Settings
MACD Parameters (12, 26, 9)
Volume Surge Multiplier (1.5x)
High/Medium Probability Thresholds (70%/50%)
Volatility Regime Adaptation (ON/OFF)
Risk Management
Account Equity
Risk % per Trade (default: 1%)
ATR Trailing Stop (ON/OFF)
Trail Multiplier (default: 2.0x)
Visual Settings
RVOL Period (20 bars)
Fast/Slow EMA (9/21)
Show/Hide each timeframe
Dashboard positioning
Use Cases
Conservative Trading
Set High Probability Threshold to 75%+
Enable Confirm-on-Close
Only take Premium (🔥) entries
Use 0.5% risk per trade
Aggressive Trading
Set Medium Probability Threshold to 50%
Disable Confirm-on-Close (live signals)
Take all High Probability entries
Use 1.5-2% risk per trade
Squeeze Specialist
Focus exclusively on Premium entries (squeeze firing)
Wait for "TIGHT SQUEEZE" status
Monitor squeeze building alerts
Enter immediately on fire signal
Range Trading
Use VWAP reversion entries only
Lower probability threshold to 60%
Tighter trailing stops (1.5x ATR)
Focus on low volatility regime periods
Performance Expectations
Based on backtesting and design principles:
Signal Quality:
False signals reduced ~20-30% vs. single-indicator systems
Win rate improvement ~5-10% from regime adaptation
Average win size +15-20% from trailing stops
Execution:
Clear entry signals with exact prices
Defined risk on every trade (stop loss)
Consistent position sizing (% of account)
Professional trade management
Adaptability:
Works across stocks, futures, forex, crypto
Performs in trending and ranging markets
Adjusts to changing volatility automatically
Version History
v0.1.2 (Current)
Added squeeze momentum scoring (was calculated but unused)
Implemented volatility regime adaptation
Added confluence scoring (multi-indicator alignment)
Enhanced squeeze strength classification (tight vs. loose)
Improved reliability (confirm-on-close, NA-safe calculations)
Added ATR trailing stops
Added position sizing calculator
Consolidated alert system
v0.1.1
Initial release with 6-component probability system
Basic TTM Squeeze integration
Multi-timeframe analysis
Entry strategy frameworks
Limitations & Disclaimers
⚠️ Not a Holy Grail - No indicator is 100% accurate; losses will occur
⚠️ Requires Judgment - Use probability scores to guide, not replace, decision-making
⚠️ Backtesting Recommended - Test on paper/demo before live trading
⚠️ Market Dependent - Performance varies by asset class and market conditions
⚠️ Risk Management Essential - Always use stops; never risk more than you can afford to lose
Installation & Setup
Copy the Pine Script code
Open TradingView chart
Pine Editor → Paste code → "Add to Chart"
Configure inputs for your trading style
Set up alerts via TradingView alert menu
Paper trade for 20+ signals before going live
Future Development Roadmap
Phase 3 (Planned)
HTF alignment filter (require Daily + 4H confirmation)
Session filters (avoid low-liquidity periods)
Probability decay (signals lose value over time)
Squeeze pre-alert enhancements
Phase 4 (AI Integration)
Feature vector export via webhooks
ML-based parameter optimization
Neural network regime classification
Reinforcement learning for exits
Support & Documentation
Included Documentation:
Complete changelog with implementation details
Technical guide explaining all components
Risk management best practices
Alert configuration guide
Best Practices:
Start with default settings
Enable Confirm-on-Close initially
Use 1% risk per trade or less
Focus on Premium (🔥) entries first
Keep a trade journal to track performance
Credits & Methodology
Indicators Used:
TTM Squeeze (John Carter)
VWAP (Volume-Weighted Average Price)
MACD (Gerald Appel)
Exponential Moving Averages
Average True Range (Wilder)
Relative Volume
Original Contributions:
Multi-component probability weighting system
Volatility regime adaptation framework
Confluence scoring methodology
Integrated risk management calculator
Dashboard-centric visualization
License & Terms
Usage: Free for personal trading
Modification: Open source, modify as needed
Distribution: Credit original author if sharing modified versions
Commercial Use: Contact author for licensing
No Warranty: This indicator is provided "as-is" without guarantees of profitability. Trading involves substantial risk. Past performance does not guarantee future results.
Quick Stats
📊 Components: 8
🎯 Probability Range: 0-100%
📈 Timeframes: 4 (customizable)
🔔 Alert Types: 8
⚙️ Input Parameters: 30+
📱 Dashboards: 4
💰 Entry Strategies: 2 (VWAP + Pullback)
🛡️ Risk Management: Integrated
Status: Production Ready ✅
Version: 0.1.2
Last Updated: November 2025
Pine Script: v6
File Name: PA_AI_PRE_GO_v0.1.2_FIXED.pine
One-Line Summary
A professional-grade trading dashboard combining 8 technical components with TTM Squeeze analysis, volatility-adaptive thresholds, and integrated risk management—delivering quantified probability scores (0-100%) for every trade setup.
[AA] - Market Valuation (Mean Based) - Market Valuation (Mean Based)
What it does
This indicator estimates whether price is overvalued, undervalued, or fairly valued relative to its structural mean across multiple lookback windows. It builds a single normalized oscillator from short-, mid-, and long-term ranges so traders can quickly see when price is stretched away from equilibrium.
This is not a mashup of existing tools. It’s a custom mean-deviation model that aggregates multi-window range positioning into one score.
How it works (concepts)
For each lookback length (13, 25, 30, 50, 100, 200):
Range & midpoint:
Highest high H and lowest low L.
Structural midpoint Mid = (H + L)/2.
Normalized deviation:
Dev = (Close − Mid) / (H − L) → location of price within its own range.
Aggregation:
The oscillator z_struct is the average of the deviations from the five windows.
Result: a smoothed, dimensionless value (roughly −1 to +1 in typical markets) showing multi-horizon displacement from the mean.
Plots & levels
Oscillator (area): z_struct
Reference lines: +0.40 (OB), 0.00 (equilibrium), −0.30 (OS)
Coloring:
Red when z_struct > OB (extended above mean)
Blue when z_struct < OS (extended below mean)
White in between
Suggested use
Mean reversion context: Fade extremes in range-bound conditions; take profits into OB/OS.
Trend awareness: In strong trends, extremes can persist—use levels as exhaustion context rather than standalone entry.
Filter/confirm: Combine with your trend filter or structure tools to time pullbacks and avoid chasing extended moves.
Inputs
Lookbacks: 13, 25, 30, 50, 100, 200
Thresholds: OB = 0.40, OS = −0.30
Notes & limitations
Works on the current symbol/timeframe only; no security() calls and no repainting beyond normal bar completion.
In very tight or flat ranges (H ≈ L), normalized deviations can become sensitive; consider longer windows or higher timeframes.
This is an indicator, not a strategy. No signals are generated; use with risk management.
Originality statement
This script implements an original, multi-window mean-deviation aggregation. It does not replicate a built-in or a public indicator; its purpose is to quantify cross-horizon valuation in a single, normalized measure.
DAX ORB Ultimate - ALGO Suite//@version=5
indicator("DAX ORB Ultimate - ALGO Suite", overlay=true, max_labels_count=200, max_lines_count=100)
// ═══════════════════════════════════════════════════════════════════════════════
// DAX OPENING RANGE BREAKOUT - ULTIMATE EDITION
// Real-time ORB building | Multi-timeframe support | Key levels with bias
// Works on ANY timeframe - uses M1 data for ORB construction
// ═══════════════════════════════════════════════════════════════════════════════
// ════════════════════════ INPUTS ════════════════════════
orb_start_h = input.int(7, "Start Hour (UTC)", minval=0, maxval=23, group="ORB Settings")
orb_start_m = input.int(40, "Start Minute", minval=0, maxval=59, group="ORB Settings")
orb_end_h = input.int(8, "End Hour (UTC)", minval=0, maxval=23, group="ORB Settings")
orb_end_m = input.int(0, "End Minute", minval=0, maxval=59, group="ORB Settings")
exclude_wicks = input.bool(true, "Exclude Wicks", group="ORB Settings")
close_hour = input.int(16, "Market Close Hour", minval=0, maxval=23, group="ORB Settings")
use_tf = input.bool(true, "1. Trend Following", group="Strategies")
use_mr = input.bool(true, "2. Mean Reversion", group="Strategies")
use_sa = input.bool(true, "3. Statistical Arb", group="Strategies")
use_mm = input.bool(true, "4. Market Making", group="Strategies")
use_ba = input.bool(true, "5. Basis Arb", group="Strategies")
use_ema = input.bool(true, "EMA Filter", group="Technical Filters")
use_rsi = input.bool(true, "RSI Filter", group="Technical Filters")
use_macd = input.bool(true, "MACD Filter", group="Technical Filters")
use_vol = input.bool(true, "Volume Filter", group="Technical Filters")
use_bb = input.bool(true, "Bollinger Filter", group="Technical Filters")
use_fixed = input.bool(false, "Fixed SL/TP", group="Risk Management")
fixed_sl = input.float(50, "Fixed SL Points", minval=10, group="Risk Management")
fixed_tp = input.float(150, "Fixed TP Points", minval=10, group="Risk Management")
atr_sl = input.float(2.0, "ATR SL Mult", minval=0.5, group="Risk Management")
atr_tp = input.float(3.0, "ATR TP Mult", minval=0.5, group="Risk Management")
min_rr = input.float(2.0, "Min R:R", minval=1.0, group="Risk Management")
show_dash = input.bool(true, "Show Dashboard", group="Display")
show_lines = input.bool(true, "Show Lines", group="Display")
show_levels = input.bool(true, "Show Key Levels", group="Display")
// ════════════════════════ FUNCTIONS ════════════════════════
is_orb_period(_h, _m) =>
start = orb_start_h * 60 + orb_start_m
end = orb_end_h * 60 + orb_end_m
curr = _h * 60 + _m
curr >= start and curr < end
orb_ended(_h, _m) =>
end = orb_end_h * 60 + orb_end_m
curr = _h * 60 + _m
curr == end
is_market_open() =>
h = hour(time)
h >= orb_start_h and h <= close_hour
// ════════════════════════ DATA GATHERING (M1) ════════════════════════
// Get M1 data for ORB construction (works on ANY chart timeframe)
= request.security(syminfo.tickerid, "1", , barmerge.gaps_off, barmerge.lookahead_off)
// Daily data
d_high = request.security(syminfo.tickerid, "D", high, barmerge.gaps_off, barmerge.lookahead_on)
d_low = request.security(syminfo.tickerid, "D", low, barmerge.gaps_off, barmerge.lookahead_on)
d_open = request.security(syminfo.tickerid, "D", open, barmerge.gaps_off, barmerge.lookahead_on)
// Current day high/low (intraday)
var float today_high = na
var float today_low = na
var float prev_day_high = na
var float prev_day_low = na
var float yest_size = 0
if ta.change(time("D")) != 0
prev_day_high := d_high
prev_day_low := d_low
yest_size := d_high - d_low
today_high := high
today_low := low
else
today_high := math.max(na(today_high) ? high : today_high, high)
today_low := math.min(na(today_low) ? low : today_low, low)
// ════════════════════════ ORB CONSTRUCTION (REAL-TIME) ════════════════════════
var float orb_h = na
var float orb_l = na
var bool orb_ready = false
var float orb_building_h = na
var float orb_building_l = na
var bool is_building = false
// Get M1 bar time components
m1_hour = hour(m1_time)
m1_minute = minute(m1_time)
// Reset daily
if ta.change(time("D")) != 0
orb_h := na
orb_l := na
orb_ready := false
orb_building_h := na
orb_building_l := na
is_building := false
// Build ORB using M1 data
if is_orb_period(m1_hour, m1_minute) and not orb_ready
is_building := true
val_h = exclude_wicks ? m1_close : m1_high
val_l = exclude_wicks ? m1_close : m1_low
if na(orb_building_h)
orb_building_h := val_h
orb_building_l := val_l
else
orb_building_h := math.max(orb_building_h, val_h)
orb_building_l := math.min(orb_building_l, val_l)
// FIX #1: Set is_building to false when NOT in ORB period anymore
if not is_orb_period(m1_hour, m1_minute) and is_building and not orb_ready
is_building := false
// Finalize ORB when period ends
if orb_ended(m1_hour, m1_minute) and not orb_ready
orb_h := orb_building_h
orb_l := orb_building_l
orb_ready := true
is_building := false
// Display building values in real-time
current_orb_h = is_building ? orb_building_h : orb_h
current_orb_l = is_building ? orb_building_l : orb_l
// ════════════════════════ INDICATORS ════════════════════════
ema9 = ta.ema(close, 9)
ema21 = ta.ema(close, 21)
ema50 = ta.ema(close, 50)
rsi = ta.rsi(close, 14)
= ta.macd(close, 12, 26, 9)
= ta.bb(close, 20, 2)
atr = ta.atr(14)
vol_ma = ta.sma(volume, 20)
// ════════════════════════ STRATEGY SIGNALS ════════════════════════
// 1. Trend Following
tf_short = ta.sma(close, 10)
tf_long = ta.sma(close, 30)
tf_bull = tf_short > tf_long
tf_bear = tf_short < tf_long
// 2. Mean Reversion
mr_mean = ta.sma(close, 20)
mr_dev = (close - mr_mean) / mr_mean * 100
mr_bull = mr_dev <= -0.5
mr_bear = mr_dev >= 0.5
// 3. Statistical Arb
sa_mean = ta.sma(close, 120)
sa_std = ta.stdev(close, 120)
sa_z = sa_std > 0 ? (close - sa_mean) / sa_std : 0
var string sa_st = "flat"
if sa_st == "flat"
if sa_z <= -2.0
sa_st := "long"
else if sa_z >= 2.0
sa_st := "short"
else if math.abs(sa_z) <= 0.5 or math.abs(sa_z) >= 4.0
sa_st := "flat"
sa_bull = sa_st == "long"
sa_bear = sa_st == "short"
// 4. Market Making
mm_spread = (high - low) / close * 100
mm_mid = (high + low) / 2
mm_bull = close < mm_mid and mm_spread >= 0.5
mm_bear = close > mm_mid and mm_spread >= 0.5
// 5. Basis Arb
ba_fair = ta.sma(close, 50)
ba_bps = ba_fair != 0 ? (close - ba_fair) / ba_fair * 10000 : 0
ba_bull = ba_bps <= -8.0
ba_bear = ba_bps >= 8.0
// Vote counting
bull_v = 0
bear_v = 0
if use_tf
bull_v := bull_v + (tf_bull ? 1 : 0)
bear_v := bear_v + (tf_bear ? 1 : 0)
if use_mr
bull_v := bull_v + (mr_bull ? 1 : 0)
bear_v := bear_v + (mr_bear ? 1 : 0)
if use_sa
bull_v := bull_v + (sa_bull ? 1 : 0)
bear_v := bear_v + (sa_bear ? 1 : 0)
if use_mm
bull_v := bull_v + (mm_bull ? 1 : 0)
bear_v := bear_v + (mm_bear ? 1 : 0)
if use_ba
bull_v := bull_v + (ba_bull ? 1 : 0)
bear_v := bear_v + (ba_bear ? 1 : 0)
// Technical filters - Simplified scoring system
ema_ok_b = not use_ema or (ema9 > ema21 and close > ema50)
ema_ok_s = not use_ema or (ema9 < ema21 and close < ema50)
rsi_ok_b = not use_rsi or (rsi > 40 and rsi < 80) // More lenient
rsi_ok_s = not use_rsi or (rsi < 60 and rsi > 20) // More lenient
macd_ok_b = not use_macd or macd > sig
macd_ok_s = not use_macd or macd < sig
vol_ok = not use_vol or volume > vol_ma * 1.2 // More lenient
bb_ok_b = not use_bb or close > bb_mid
bb_ok_s = not use_bb or close < bb_mid
// Technical score (need at least 2 out of 5 filters)
tech_score_b = (ema_ok_b ? 1 : 0) + (rsi_ok_b ? 1 : 0) + (macd_ok_b ? 1 : 0) + (bb_ok_b ? 1 : 0) + (vol_ok ? 1 : 0)
tech_score_s = (ema_ok_s ? 1 : 0) + (rsi_ok_s ? 1 : 0) + (macd_ok_s ? 1 : 0) + (bb_ok_s ? 1 : 0) + (vol_ok ? 1 : 0)
tech_bull = tech_score_b >= 2
tech_bear = tech_score_s >= 2
// Breakout - SIMPLIFIED (just need close above/below ORB)
brk_bull = orb_ready and close > current_orb_h
brk_bear = orb_ready and close < current_orb_l
// Consensus - At least 2 strategies agree (not majority)
total_st = (use_tf ? 1 : 0) + (use_mr ? 1 : 0) + (use_sa ? 1 : 0) + (use_mm ? 1 : 0) + (use_ba ? 1 : 0)
consensus_b = bull_v >= 2
consensus_s = bear_v >= 2
// Final signals - MUCH MORE LENIENT
daily_ok = yest_size >= 50 // Reduced from 100
buy = brk_bull and consensus_b and tech_bull and is_market_open()
sell = brk_bear and consensus_s and tech_bear and is_market_open()
// ════════════════════════ SL/TP ════════════════════════
// IMMEDIATE SL/TP LEVELS - Calculated as soon as ORB is ready (at 8:00)
var float long_entry = na
var float long_sl = na
var float long_tp = na
var float short_entry = na
var float short_sl = na
var float short_tp = na
// Calculate potential levels immediately when ORB is ready
if orb_ready and not na(orb_h) and not na(orb_l)
// Long scenario: Entry at ORB high breakout
long_entry := orb_h
long_sl := use_fixed ? long_entry - fixed_sl : long_entry - atr * atr_sl
long_tp := use_fixed ? long_entry + fixed_tp : long_entry + atr * atr_tp
// Short scenario: Entry at ORB low breakout
short_entry := orb_l
short_sl := use_fixed ? short_entry + fixed_sl : short_entry + atr * atr_sl
short_tp := use_fixed ? short_entry - fixed_tp : short_entry - atr * atr_tp
// Signal-based entry tracking (for dashboard and alerts)
var float buy_entry = na
var float buy_sl = na
var float buy_tp = na
var float sell_entry = na
var float sell_sl = na
var float sell_tp = na
if buy
buy_entry := close
buy_sl := use_fixed ? buy_entry - fixed_sl : buy_entry - atr * atr_sl
buy_tp := use_fixed ? buy_entry + fixed_tp : buy_entry + atr * atr_tp
if sell
sell_entry := close
sell_sl := use_fixed ? sell_entry + fixed_sl : sell_entry + atr * atr_sl
sell_tp := use_fixed ? sell_entry - fixed_tp : sell_entry - atr * atr_tp
buy_rr = not na(buy_entry) ? (buy_tp - buy_entry) / (buy_entry - buy_sl) : 0
sell_rr = not na(sell_entry) ? (sell_entry - sell_tp) / (sell_sl - sell_entry) : 0
buy_final = buy and buy_rr >= min_rr
sell_final = sell and sell_rr >= min_rr
// ════════════════════════ TRAILING STOPS ════════════════════════
// Trailing Stop Loss and Take Profit Management
var float trailing_sl_long = na
var float trailing_sl_short = na
var float trailing_tp_long = na
var float trailing_tp_short = na
var bool in_long = false
var bool in_short = false
var float highest_since_entry = na
var float lowest_since_entry = na
// Enter long position
if buy_final and not in_long
in_long := true
in_short := false
trailing_sl_long := buy_sl
trailing_tp_long := buy_tp
highest_since_entry := close
// Enter short position
if sell_final and not in_short
in_short := true
in_long := false
trailing_sl_short := sell_sl
trailing_tp_short := sell_tp
lowest_since_entry := close
// Update trailing stops for LONG
if in_long
// Track highest price since entry
highest_since_entry := math.max(highest_since_entry, high)
// Trail stop loss (moves up as price moves up)
// When price moves 1 ATR in profit, move SL to breakeven
// When price moves 2 ATR in profit, move SL to +1 ATR
profit_atr = (highest_since_entry - buy_entry) / atr
if profit_atr >= 2.0
trailing_sl_long := math.max(trailing_sl_long, buy_entry + atr * 1.0)
else if profit_atr >= 1.0
trailing_sl_long := math.max(trailing_sl_long, buy_entry)
// Smart trailing TP - extends TP if strong momentum
if highest_since_entry > trailing_tp_long * 0.9 and rsi > 60 // Within 10% of TP and strong momentum
trailing_tp_long := trailing_tp_long + atr * 0.5 // Extend TP
// Exit conditions
if close <= trailing_sl_long or close >= trailing_tp_long
in_long := false
trailing_sl_long := na
trailing_tp_long := na
highest_since_entry := na
// Update trailing stops for SHORT
if in_short
// Track lowest price since entry
lowest_since_entry := math.min(lowest_since_entry, low)
// Trail stop loss (moves down as price moves down)
profit_atr = (sell_entry - lowest_since_entry) / atr
if profit_atr >= 2.0
trailing_sl_short := math.min(trailing_sl_short, sell_entry - atr * 1.0)
else if profit_atr >= 1.0
trailing_sl_short := math.min(trailing_sl_short, sell_entry)
// Smart trailing TP - extends TP if strong momentum
if lowest_since_entry < trailing_tp_short * 1.1 and rsi < 40 // Within 10% of TP and strong momentum
trailing_tp_short := trailing_tp_short - atr * 0.5 // Extend TP
// Exit conditions
if close >= trailing_sl_short or close <= trailing_tp_short
in_short := false
trailing_sl_short := na
trailing_tp_short := na
lowest_since_entry := na
// ════════════════════════ ANALYTICS ════════════════════════
prob_strat = total_st > 0 ? math.max(bull_v, bear_v) / total_st * 100 : 50
prob_tech = (tech_bull or tech_bear) ? 75 : 35
prob_vol = vol_ok ? 85 : 50
prob_daily = daily_ok ? 85 : 30
prob_orb = orb_ready ? 80 : 20
probability = prob_strat * 0.3 + prob_tech * 0.25 + prob_vol * 0.15 + prob_daily * 0.15 + prob_orb * 0.15
dir_score = 0
dir_score := dir_score + (ema9 > ema21 ? 2 : -2)
dir_score := dir_score + (tf_bull ? 2 : -2)
dir_score := dir_score + (macd > sig ? 1 : -1)
dir_score := dir_score + (rsi > 50 ? 1 : -1)
direction = dir_score >= 2 ? "STRONG BULL" : (dir_score > 0 ? "BULL" : (dir_score <= -2 ? "STRONG BEAR" : (dir_score < 0 ? "BEAR" : "NEUTRAL")))
clean_trend = math.abs(ema9 - ema21) / close * 100
clean_noise = atr / close * 100
clean_struct = close > ema9 and close > ema21 and close > ema50 or close < ema9 and close < ema21 and close < ema50
clean_score = (clean_trend > 0.5 ? 30 : 10) + (clean_noise < 1.5 ? 30 : 10) + (clean_struct ? 40 : 10)
quality = clean_score >= 70 ? "CLEAN" : (clean_score >= 50 ? "GOOD" : (clean_score >= 30 ? "OK" : "CHOPPY"))
mom = ta.mom(close, 10)
mom_str = math.abs(mom) / close * 100
vol_rat = atr / ta.sma(atr, 20)
movement = buy_final or sell_final ? (mom_str > 0.8 and vol_rat > 1.3 ? "STRONG" : (mom_str > 0.5 ? "MODERATE" : "GRADUAL")) : "WAIT"
ok_score = (daily_ok ? 25 : 0) + (orb_ready ? 25 : 0) + (is_market_open() ? 20 : 0) + (clean_score >= 50 ? 20 : 5) + (probability >= 60 ? 10 : 0)
ok_trade = ok_score >= 65
// ════════════════════════ KEY LEVELS WITH BIAS ════════════════════════
// Calculate potential reaction levels with directional bias
var float key_levels = array.new_float(0)
var string key_bias = array.new_string(0)
if barstate.islast and show_levels
array.clear(key_levels)
array.clear(key_bias)
// Add levels with bias
if not na(current_orb_h)
array.push(key_levels, current_orb_h)
array.push(key_bias, consensus_b ? "BULL BREAK" : "RESISTANCE")
if not na(current_orb_l)
array.push(key_levels, current_orb_l)
array.push(key_bias, consensus_s ? "BEAR BREAK" : "SUPPORT")
if not na(prev_day_high)
array.push(key_levels, prev_day_high)
bias_pdh = close > prev_day_high ? "BULLISH" : (close < prev_day_high and close > prev_day_high * 0.995 ? "WATCH" : "RESIST")
array.push(key_bias, bias_pdh)
if not na(prev_day_low)
array.push(key_levels, prev_day_low)
bias_pdl = close < prev_day_low ? "BEARISH" : (close > prev_day_low and close < prev_day_low * 1.005 ? "WATCH" : "SUPPORT")
array.push(key_bias, bias_pdl)
if not na(today_high)
array.push(key_levels, today_high)
array.push(key_bias, "TODAY HIGH")
if not na(today_low)
array.push(key_levels, today_low)
array.push(key_bias, "TODAY LOW")
// Add EMA50 as dynamic level
array.push(key_levels, ema50)
ema_bias = close > ema50 ? "BULL SUPPORT" : "BEAR RESIST"
array.push(key_bias, ema_bias)
// ════════════════════════ VISUALS ════════════════════════
// Previous day lines
plot(show_lines ? prev_day_high : na, "Prev Day H", color.new(color.yellow, 0), 1, plot.style_line)
plot(show_lines ? prev_day_low : na, "Prev Day L", color.new(color.orange, 0), 1, plot.style_line)
// Current day high/low
plot(show_lines ? today_high : na, "Today High", color.new(color.lime, 40), 2, plot.style_circles)
plot(show_lines ? today_low : na, "Today Low", color.new(color.red, 40), 2, plot.style_circles)
// ORB lines (show building values in real-time with separate plots)
// Building phase - circles (orange during building)
plot(show_lines and is_building and not na(current_orb_h) ? current_orb_h : na, "ORB High Building", color.new(color.orange, 30), 3, plot.style_circles)
plot(show_lines and is_building and not na(current_orb_l) ? current_orb_l : na, "ORB Low Building", color.new(color.orange, 30), 3, plot.style_circles)
// Ready phase - ULTRA BRIGHT solid lines
plot(show_lines and not is_building and not na(current_orb_h) ? current_orb_h : na, "ORB High Ready", color.new(color.aqua, 0), 4, plot.style_line)
plot(show_lines and not is_building and not na(current_orb_l) ? current_orb_l : na, "ORB Low Ready", color.new(color.aqua, 0), 4, plot.style_line)
// ORB zone fill
p1 = plot(not na(current_orb_h) ? current_orb_h : na, display=display.none)
p2 = plot(not na(current_orb_l) ? current_orb_l : na, display=display.none)
fill_color = is_building ? color.new(color.blue, 93) : color.new(color.blue, 88)
fill(p1, p2, fill_color, title="ORB Zone")
// FIX #2: Draw ORB rectangle box ONLY ONCE when ready (use var to track if already drawn)
var box orb_box = na
var int orb_start_bar = na
var bool orb_box_drawn = false
// Reset box drawn flag on new day
if ta.change(time("D")) != 0
orb_box_drawn := false
// Capture the bar when ORB becomes ready
if orb_ready and not orb_ready
orb_start_bar := bar_index
orb_box_drawn := false // Allow new box to be drawn
// Draw box ONLY ONCE when ORB first becomes ready
if orb_ready and not orb_box_drawn and not na(orb_h) and not na(orb_l) and show_lines
if not na(orb_box)
box.delete(orb_box)
// Ultra clear rectangle with thick bright borders
box_color = color.new(color.aqua, 85) // Bright aqua fill
border_color = color.new(color.aqua, 0) // Solid bright aqua border
orb_box := box.new(orb_start_bar, orb_h, bar_index + 50, orb_l,
border_color=border_color,
border_width=3, // Thicker border
bgcolor=box_color,
extend=extend.right,
text="ORB ZONE",
text_size=size.normal, // Larger text
text_color=color.new(color.aqua, 0)) // Bright text
orb_box_drawn := true
// Update box right edge on each bar (without creating new box)
if orb_box_drawn and not na(orb_box) and show_lines
box.set_right(orb_box, bar_index)
// EMAs
plot(use_ema ? ema9 : na, "EMA9", color.new(color.blue, 20), 1)
plot(use_ema ? ema21 : na, "EMA21", color.new(color.orange, 20), 1)
plot(use_ema ? ema50 : na, "EMA50", color.new(color.purple, 30), 2)
// Signals
plotshape(buy_final, "BUY", shape.triangleup, location.belowbar, color.new(color.lime, 0), size=size.small, text="BUY")
plotshape(sell_final, "SELL", shape.triangledown, location.abovebar, color.new(color.red, 0), size=size.small, text="SELL")
// Exit signals
plotshape(in_long and not in_long, "EXIT LONG", shape.xcross, location.abovebar, color.new(color.orange, 0), size=size.tiny, text="EXIT")
plotshape(in_short and not in_short, "EXIT SHORT", shape.xcross, location.belowbar, color.new(color.orange, 0), size=size.tiny, text="EXIT")
// Trailing stop lines
plot(in_long and not na(trailing_sl_long) ? trailing_sl_long : na, "Trail SL Long", color.new(color.red, 0), 2, plot.style_cross)
plot(in_long and not na(trailing_tp_long) ? trailing_tp_long : na, "Trail TP Long", color.new(color.lime, 0), 2, plot.style_cross)
plot(in_short and not na(trailing_sl_short) ? trailing_sl_short : na, "Trail SL Short", color.new(color.red, 0), 2, plot.style_cross)
plot(in_short and not na(trailing_tp_short) ? trailing_tp_short : na, "Trail TP Short", color.new(color.lime, 0), 2, plot.style_cross)
// FIX #3: IMMEDIATE SL/TP LINES - Draw ONLY ONCE when ORB is ready
var line long_sl_ln = na
var line long_tp_ln = na
var line short_sl_ln = na
var line short_tp_ln = na
var label long_sl_lbl = na
var label long_tp_lbl = na
var label short_sl_lbl = na
var label short_tp_lbl = na
var bool sltp_lines_drawn = false
// Reset lines drawn flag on new day
if ta.change(time("D")) != 0
sltp_lines_drawn := false
// Draw lines ONLY ONCE when ORB first becomes ready
if orb_ready and not orb_ready and show_lines
sltp_lines_drawn := false // Allow new lines to be drawn
if orb_ready and not sltp_lines_drawn and show_lines
// Delete old lines
if not na(long_sl_ln)
line.delete(long_sl_ln)
line.delete(long_tp_ln)
line.delete(short_sl_ln)
line.delete(short_tp_ln)
label.delete(long_sl_lbl)
label.delete(long_tp_lbl)
label.delete(short_sl_lbl)
label.delete(short_tp_lbl)
// LONG scenario (green - bullish breakout above ORB high)
if not na(long_sl) and not na(long_tp)
long_sl_ln := line.new(bar_index, long_sl, bar_index + 100, long_sl, color=color.new(color.red, 0), width=2, style=line.style_solid, extend=extend.right)
long_tp_ln := line.new(bar_index, long_tp, bar_index + 100, long_tp, color=color.new(color.lime, 0), width=2, style=line.style_solid, extend=extend.right)
long_sl_lbl := label.new(bar_index, long_sl, "LONG SL: " + str.tostring(long_sl, "#.##"), style=label.style_label_left, color=color.new(color.red, 0), textcolor=color.white, size=size.small)
long_tp_lbl := label.new(bar_index, long_tp, "LONG TP: " + str.tostring(long_tp, "#.##"), style=label.style_label_left, color=color.new(color.lime, 0), textcolor=color.black, size=size.small)
// SHORT scenario (red - bearish breakout below ORB low)
if not na(short_sl) and not na(short_tp)
short_sl_ln := line.new(bar_index, short_sl, bar_index + 100, short_sl, color=color.new(color.red, 0), width=2, style=line.style_solid, extend=extend.right)
short_tp_ln := line.new(bar_index, short_tp, bar_index + 100, short_tp, color=color.new(color.lime, 0), width=2, style=line.style_solid, extend=extend.right)
short_sl_lbl := label.new(bar_index, short_sl, "SHORT SL: " + str.tostring(short_sl, "#.##"), style=label.style_label_left, color=color.new(color.red, 0), textcolor=color.white, size=size.small)
short_tp_lbl := label.new(bar_index, short_tp, "SHORT TP: " + str.tostring(short_tp, "#.##"), style=label.style_label_left, color=color.new(color.lime, 0), textcolor=color.black, size=size.small)
sltp_lines_drawn := true
// FIX #4: Key level labels - Track and delete old labels to prevent duplication
var label key_level_labels = array.new_label(0)
// Delete all old key level labels
if array.size(key_level_labels) > 0
for i = 0 to array.size(key_level_labels) - 1
label.delete(array.get(key_level_labels, i))
array.clear(key_level_labels)
// Create key level labels only on last bar
if barstate.islast and show_levels and array.size(key_levels) > 0
for i = 0 to array.size(key_levels) - 1
lvl = array.get(key_levels, i)
bias = array.get(key_bias, i)
// Color based on bias
lbl_color = str.contains(bias, "BULL") ? color.new(color.green, 70) : (str.contains(bias, "BEAR") ? color.new(color.red, 70) : (str.contains(bias, "SUPPORT") ? color.new(color.blue, 70) : (str.contains(bias, "RESIST") ? color.new(color.orange, 70) : color.new(color.gray, 70))))
txt_color = str.contains(bias, "BULL") ? color.green : (str.contains(bias, "BEAR") ? color.red : (str.contains(bias, "SUPPORT") ? color.blue : (str.contains(bias, "RESIST") ? color.orange : color.gray)))
new_lbl = label.new(bar_index + 2, lvl, str.tostring(lvl, "#.##") + "\n" + bias, style=label.style_label_left, color=lbl_color, textcolor=txt_color, size=size.tiny, textalign=text.align_left)
array.push(key_level_labels, new_lbl)
// FIX #5: Compact chart info labels - Track and delete to prevent duplication
var label prob_label = na
var label dir_label = na
if barstate.islast and show_lines
// Delete old labels
if not na(prob_label)
label.delete(prob_label)
if not na(dir_label)
label.delete(dir_label)
// Create new labels
prob_c = probability >= 70 ? color.green : (probability >= 50 ? color.yellow : color.red)
prob_label := label.new(bar_index, high + atr * 1.2, str.tostring(probability, "#") + "%", style=label.style_none, textcolor=prob_c, size=size.small)
dir_c = str.contains(direction, "BULL") ? color.green : (str.contains(direction, "BEAR") ? color.red : color.gray)
dir_label := label.new(bar_index, high + atr * 2, direction, style=label.style_none, textcolor=dir_c, size=size.tiny)
// ════════════════════════ DASHBOARD ════════════════════════
var table dash = table.new(position.top_right, 2, 20, bgcolor=color.new(color.black, 5), border_width=1, border_color=color.new(color.gray, 60))
if barstate.islast and show_dash
r = 0
// Header
table.cell(dash, 0, r, "DAX ORB ULTIMATE", text_color=color.white, bgcolor=color.new(color.blue, 30), text_size=size.small)
table.cell(dash, 1, r, timeframe.period, text_color=color.yellow, bgcolor=color.new(color.blue, 30), text_size=size.tiny)
// Current Day
r += 1
table.cell(dash, 0, r, "TODAY H/L", text_color=color.aqua, text_size=size.tiny)
table.cell(dash, 1, r, "", text_color=color.white)
r += 1
table.cell(dash, 0, r, "High", text_color=color.gray, text_size=size.tiny)
table.cell(dash, 1, r, str.tostring(today_high, "#.##"), text_color=color.lime, text_size=size.tiny)
r += 1
table.cell(dash, 0, r, "Low", text_color=color.gray, text_size=size.tiny)
table.cell(dash, 1, r, str.tostring(today_low, "#.##"), text_color=color.red, text_size=size.tiny)
r += 1
table.cell(dash, 0, r, "Range", text_color=color.gray, text_size=size.tiny)
today_range = today_high - today_low
table.cell(dash, 1, r, str.tostring(today_range, "#") + "p", text_color=color.aqua, text_size=size.tiny)
// Previous Day
r += 1
table.cell(dash, 0, r, "PREV H/L", text_color=color.aqua, text_size=size.tiny)
table.cell(dash, 1, r, str.tostring(yest_size, "#") + "p", text_color=daily_ok ? color.lime : color.red, text_size=size.tiny)
// ORB Status with real-time values
r += 1
table.cell(dash, 0, r, "ORB 7:40-8:00", text_color=color.aqua, text_size=size.tiny)
orb_status = is_building ? "BUILDING" : (orb_ready ? "READY" : "WAIT")
orb_clr = is_building ? color.orange : (orb_ready ? color.lime : color.gray)
table.cell(dash, 1, r, orb_status, text_color=orb_clr, text_size=size.tiny)
r += 1
table.cell(dash, 0, r, "High", text_color=color.gray, text_size=size.tiny)
orb_h_txt = not na(current_orb_h) ? str.tostring(current_orb_h, "#.##") : "---"
table.cell(dash, 1, r, orb_h_txt, text_color=is_building ? color.orange : color.green, text_size=size.tiny)
r += 1
table.cell(dash, 0, r, "Low", text_color=color.gray, text_size=size.tiny)
orb_l_txt = not na(current_orb_l) ? str.tostring(current_orb_l, "#.##") : "---"
table.cell(dash, 1, r, orb_l_txt, text_color=is_building ? color.orange : color.red, text_size=size.tiny)
r += 1
table.cell(dash, 0, r, "Size", text_color=color.gray, text_size=size.tiny)
orb_size = not na(current_orb_h) and not na(current_orb_l) ? current_orb_h - current_orb_l : 0
table.cell(dash, 1, r, str.tostring(orb_size, "#") + "p", text_color=color.yellow, text_size=size.tiny)
// Strategies
r += 1
table.cell(dash, 0, r, "STRATEGIES", text_color=color.aqua, text_size=size.tiny)
table.cell(dash, 1, r, str.tostring(bull_v) + "B " + str.tostring(bear_v) + "S", text_color=color.yellow, text_size=size.tiny)
// Analytics
r += 1
table.cell(dash, 0, r, "PROBABILITY", text_color=color.white, bgcolor=color.new(color.purple, 70), text_size=size.small)
prob_c = probability >= 70 ? color.lime : (probability >= 50 ? color.yellow : color.red)
table.cell(dash, 1, r, str.tostring(probability, "#") + "%", text_color=prob_c, bgcolor=color.new(color.purple, 70), text_size=size.small)
r += 1
table.cell(dash, 0, r, "Direction", text_color=color.gray, text_size=size.tiny)
dir_c = str.contains(direction, "BULL") ? color.lime : (str.contains(direction, "BEAR") ? color.red : color.gray)
table.cell(dash, 1, r, direction, text_color=dir_c, text_size=size.tiny)
r += 1
table.cell(dash, 0, r, "Chart", text_color=color.gray, text_size=size.tiny)
qual_c = quality == "CLEAN" ? color.lime : (quality == "GOOD" ? color.green : (quality == "OK" ? color.yellow : color.red))
table.cell(dash, 1, r, quality, text_color=qual_c, text_size=size.tiny)
r += 1
table.cell(dash, 0, r, "OK Trade?", text_color=color.gray, text_size=size.tiny)
table.cell(dash, 1, r, ok_trade ? "YES" : "NO", text_color=ok_trade ? color.lime : color.red, text_size=size.tiny)
// Position Status
r += 1
pos_txt = in_long ? "IN LONG" : (in_short ? "IN SHORT" : "NO POSITION")
pos_c = in_long ? color.lime : (in_short ? color.red : color.gray)
table.cell(dash, 0, r, "POSITION", text_color=color.white, bgcolor=color.new(color.blue, 50), text_size=size.small)
table.cell(dash, 1, r, pos_txt, text_color=pos_c, bgcolor=color.new(color.blue, 50), text_size=size.small)
// Show trailing stops if in position
if in_long and not na(trailing_sl_long)
r += 1
table.cell(dash, 0, r, "Trail SL", text_color=color.gray, text_size=size.tiny)
table.cell(dash, 1, r, str.tostring(trailing_sl_long, "#.##"), text_color=color.red, text_size=size.tiny)
r += 1
table.cell(dash, 0, r, "Trail TP", text_color=color.gray, text_size=size.tiny)
table.cell(dash, 1, r, str.tostring(trailing_tp_long, "#.##"), text_color=color.lime, text_size=size.tiny)
r += 1
table.cell(dash, 0, r, "Profit", text_color=color.gray, text_size=size.tiny)
pnl = close - buy_entry
pnl_c = pnl > 0 ? color.lime : color.red
table.cell(dash, 1, r, str.tostring(pnl, "#.#") + "p", text_color=pnl_c, text_size=size.tiny)
if in_short and not na(trailing_sl_short)
r += 1
table.cell(dash, 0, r, "Trail SL", text_color=color.gray, text_size=size.tiny)
table.cell(dash, 1, r, str.tostring(trailing_sl_short, "#.##"), text_color=color.red, text_size=size.tiny)
r += 1
table.cell(dash, 0, r, "Trail TP", text_color=color.gray, text_size=size.tiny)
table.cell(dash, 1, r, str.tostring(trailing_tp_short, "#.##"), text_color=color.lime, text_size=size.tiny)
r += 1
table.cell(dash, 0, r, "Profit", text_color=color.gray, text_size=size.tiny)
pnl = sell_entry - close
pnl_c = pnl > 0 ? color.lime : color.red
table.cell(dash, 1, r, str.tostring(pnl, "#.#") + "p", text_color=pnl_c, text_size=size.tiny)
// Signal
r += 1
table.cell(dash, 0, r, "SIGNAL", text_color=color.white, bgcolor=color.new(color.green, 50), text_size=size.small)
sig_txt = buy_final ? "BUY NOW" : (sell_final ? "SELL NOW" : "WAIT")
sig_c = buy_final ? color.lime : (sell_final ? color.red : color.gray)
table.cell(dash, 1, r, sig_txt, text_color=sig_c, bgcolor=color.new(color.green, 50), text_size=size.small)
// IMMEDIATE Trade Levels - Show as soon as ORB is ready
if orb_ready and not na(long_entry) and not na(short_entry)
r += 1
table.cell(dash, 0, r, "LONG LEVELS", text_color=color.lime, bgcolor=color.new(color.green, 70), text_size=size.tiny)
table.cell(dash, 1, r, "", text_color=color.white)
r += 1
table.cell(dash, 0, r, "Entry", text_color=color.gray, text_size=size.tiny)
table.cell(dash, 1, r, str.tostring(long_entry, "#.##"), text_color=color.white, text_size=size.tiny)
r += 1
table.cell(dash, 0, r, "SL", text_color=color.gray, text_size=size.tiny)
table.cell(dash, 1, r, str.tostring(long_sl, "#.##"), text_color=color.red, text_size=size.tiny)
r += 1
table.cell(dash, 0, r, "TP", text_color=color.gray, text_size=size.tiny)
table.cell(dash, 1, r, str.tostring(long_tp, "#.##"), text_color=color.lime, text_size=size.tiny)
r += 1
table.cell(dash, 0, r, "SHORT LEVELS", text_color=color.red, bgcolor=color.new(color.red, 70), text_size=size.tiny)
table.cell(dash, 1, r, "", text_color=color.white)
r += 1
table.cell(dash, 0, r, "Entry", text_color=color.gray, text_size=size.tiny)
table.cell(dash, 1, r, str.tostring(short_entry, "#.##"), text_color=color.white, text_size=size.tiny)
r += 1
table.cell(dash, 0, r, "SL", text_color=color.gray, text_size=size.tiny)
table.cell(dash, 1, r, str.tostring(short_sl, "#.##"), text_color=color.red, text_size=size.tiny)
r += 1
table.cell(dash, 0, r, "TP", text_color=color.gray, text_size=size.tiny)
table.cell(dash, 1, r, str.tostring(short_tp, "#.##"), text_color=color.lime, text_size=size.tiny)
// ════════════════════════ ALERTS ════════════════════════
alertcondition(buy_final, "BUY Signal", "DAX ORB BUY")
alertcondition(sell_final, "SELL Signal", "DAX ORB SELL")
alertcondition(orb_ready and not orb_ready , "ORB Ready", "DAX ORB READY")
alertcondition(is_building and not is_building , "ORB Building", "DAX ORB BUILDING")
alertcondition(ok_trade and not ok_trade , "Ready to Trade", "DAX OK")
Sigma Trinity ModelAbstract
Sigma Trinity Model is an educational framework that studies how three layers of market behavior interact within the same trend: (1) structural momentum (Rasta), (2) internal strength (RSI), and (3) continuation/compounding structure (Pyramid). The model deliberately combines bar-close momentum logic with intrabar, wick-aware strength checks to help users see how reversals form, confirm, and extend. It is not a signal service or automation tool; it is a transparent learning instrument for chart study and backtesting.
Why this is not “just a mashup”
Many scripts merge indicators without explaining the purpose. Sigma Trinity is a coordinated, three-engine study designed for a specific learning goal:
Rasta (structure): defines when momentum actually flips using a dual-line EMA vs smoothed EMA. It gives the entry/exit framework on bar close for clean historical study.
RSI (energy): measures internal strength with wick-aware triggers. It uses RSI of LOW (for bottom touches/reclaims) and RSI of HIGH (for top touches/exhaustion) so users can see intrabar strength/weakness that the close can hide.
Pyramid (progression): demonstrates how continuation behaves once momentum and strength align. It shows the logic of adds (compounding) as a didactic layer, also on bar close to keep historical alignment consistent.
These three roles are complementary, not redundant: structure → strength → progression.
Architecture Overview
Execution model
Rasta & Pyramid: bar close only by default (historically stable, easy to audit).
RSI: per tick (realtime) with bar-close backup by default, using RSI of LOW for entries and RSI of HIGH for exits. This makes the module sensitive to intra-bar wicks while still giving a close-based safety net for backtests.
Stops (optional in strategy builds): wick-accurate: trail arms/ratchets on HIGH; stop hit checks with LOW (or Close if selected) with a small undershoot buffer to avoid micro-noise hits.
Visual model
Dual lines (EMA vs smoothed EMA) for Rasta + color fog to see direction and compression/expansion.
Rungs (small vertical lines) drawn between the two Rasta lines to visualize wave spacing and rhythm.
Clean labels for Entry/Exit/Pyramid Add/RSI events. Everything is state-locked to avoid spamming.
Module 1 — Rasta (Structural Momentum Layer)
Goal: Identify structural momentum reversals and maintain a consistent, replayable backbone for study.
Method:
Compute an EMA of a chosen price source (default Close), and a smoothed version (SMA/EMA/RMA/WMA/None selectable).
Flip points occur when the EMA line crosses the smoothed line.
Optional EMA 8/21 trend filter can gate entries (long-bias when EMA8 > EMA21). A small “adaptive on flip” option lets an entry fire when the filter itself flips to ON and the EMA is already above the smoothed line—useful for trend resumption.
Why bar close only?
Bar-close Rasta gives a stable, auditable timeline for the structure of the trend. It teaches users to separate “structure” (close-resolved) from “energy” (intrabar, via RSI).
Visuals:
Fog between the lines (green/red) to show regime.
Rungs between lines to show spread (compression vs expansion).
Optional plotting of EMA8/EMA21 so users can see the gating effect.
Module 2 — RSI (Internal Strength / Energy Layer)
Goal: Reveal the intrabar strength/weakness that often precedes or confirms structural flips.
Method:
Standard RSI with adjustable length and signal smoothing for the panel view.
Logic uses wick-aware sources:
Entry trigger: RSI of LOW (same RSI length) touching or below a lower band (default 15). Think of it as intraband reactivation from the bottom, using the candle’s deepest excursion.
Exit trigger: RSI of HIGH touching or above an upper band (default 85). Think of it as exhaustion at the top, using the candle’s highest excursion.
Realtime + Close Backup: fires intrabar on tick, but if the realtime event was missed, the close backup will note it at bar end.
Cooldown control: optional bars-between-signals to avoid rapid re-triggers on choppy sequences.
Why wick-aware RSI?
A close-only RSI can miss the true micro-extremes that cause reversals. Using LOW/HIGH for triggers captures the behavior that traders actually react to during the bar, while the bar-close backup preserves historical reproducibility.
Module 3 — Pyramid (Continuation / Compounding Layer)
Goal: Teach how continuation behaves once a trend is underway, and how adds can be structured.
Method:
Same dual-line logic as Rasta (EMA vs smoothed EMA), but only fires when already in a position (or after prior entry conditions).
Supports the same EMA 8/21 filter and optional adaptive-on-flip behavior.
Bar close only to maintain historical cohesion.
What it teaches:
Adds tend to cluster when momentum persists.
Students can experiment with add spacing and compare “one-shot entries” vs “laddered adds” during strong regimes.
How the Pieces Work Together
Rasta establishes the structural frame (when the wave flip is real enough to record at close).
RSI validates or challenges that structure by tracking intrabar energy at the extremes (low/high touches).
Pyramid shows what sustained continuation looks like once (1) and (2) align.
This produces a layered view: Structure → Energy → Progression. Users can see when all three line up (strongest phases) and when they diverge (riskier phases or transitions).
How to Use It (Step-by-Step)
Quick Start
Apply script to any symbol/timeframe.
In Strategy/Indicator Properties:
Enable On every tick (recommended).
If available, enable Using bar magnifier and choose a lower resolution (e.g., 1m) to simulate intrabar fills more realistically.
Keep On bar close unchecked if you want to observe realtime logic in live charts (strategies still place orders on close by platform design).
Default behavior: Rasta & Pyramid = bar close; RSI = per tick with close backup.
Reading the Chart
Watch for Rasta Entry/Exit labels: they define clean structural turns on close.
Watch RSI Entry (LOW touch at/below lower band) and RSI Exit (HIGH touch at/above upper band) to gauge internal energy extremes.
Pyramid Add labels reveal continuation phases once a move is already in progress.
Tuning
Rasta smoothing: choose SMA/EMA/RMA/WMA or None. Higher smoothing → later but cleaner flips; lower smoothing → earlier but choppier.
RSI bands: a common educational setting is 15/85 for strong extremes; 20/80 is a bit looser.
Cooldown: increase if you see too many RSI re-fires in chop.
EMA 8/21 filter: toggle ON to study “trend-gated” entries, OFF to study raw momentum flips.
Backtesting Notes (for Strategy Builds)
Stops (optional): trail is armed when price advances by a trigger (default D–F₀), ratchets only upward from HIGH, and hits from LOW (or Close if chosen) with a tiny undershoot buffer to avoid micro-wicks.
Order sequencing per bar (mirrors the script’s code comments):
Trail ratchet via HIGH
Intrabar stop hit via LOW/CLOSE → immediate close
If still in position at bar close: process exits (Rasta/RSI)
If still in position at bar close: process Pyramid Add
If flat at bar close: process entries (Rasta/RSI)
Platform reality: strategies place orders at bar close in historical testing; the intrabar logic improves realism for stops and event marking but final order timestamps are still close-resolved.
Inputs Reference (common)
Modules: enable/disable RSI and Pyramid learning layers.
Rasta: EMA length, smoothing type/length, EMA8/21 filter & adaptive flip, fog opacity, rungs on/off & limit.
RSI: RSI length, signal MA length (panel), Entry band (LOW), Exit band (HIGH), cooldown bars, labels.
Pyramid: EMA length, smoothing, EMA8/21 filter & adaptive adds.
Execution: toggle Bar Close Only for Rasta/Pyramid; toggle Realtime + Close Backup for RSI.
Stops (strategy): Fixed Stop % (first), Fixed Stop % (add), Trail Distance %, Trigger rule (auto D–F₀ or custom), undershoot buffer %, and hit source (LOW/CLOSE).
What to Study With It
Convergence: how often RSI-LOW entry touches precede the next Rasta flip.
Divergence: cases where RSI screams exhaustion (HIGH >= upper band) but Rasta hasn’t flipped yet—often transition zones.
Continuation: how Pyramid adds cluster in strong moves; how spacing changes with smoothing/filter choices.
Regime changes: use EMA8/21 filter toggles to see what happens at macro turns vs chop.
Limitations & Scope
This is a learning tool, not a trade copier. It does not provide financial advice or automated execution.
Intrabar results depend on data granularity; bar magnifier (when available) can help simulate lower-resolution ticks, but true tick-by-tick fills are a platform-level feature and not guaranteed across all symbols.
Suggested Publication Settings (Strategy)
Initial capital: 100
Order size: 100 USD (cash)
Pyramiding: 10
Commission: 0.25%
Slippage: 3 ticks
Recalculate: ✓ On every tick
Fill orders: ✓ Using bar magnifier (choose 1m or similar); leave On bar close unchecked for live viewing.
Educational License
Released under the Michael Culpepper Gratitude License (2025).
Use and modify freely for education and research with attribution. No resale. No promises of profitability. Purpose is understanding, not signals.
chart Pattern & Candle sticks Strategy# **XAUUSD Pattern & Candle Strategy - Complete Description**
## **Overview**
This Pine Script indicator is a comprehensive multi-factor trading system specifically designed for **XAUUSD (Gold) scalping and swing trading**. It combines classical technical analysis methods including candlestick patterns, chart patterns, moving averages, and volume analysis to generate high-probability buy/sell signals with automatic stop-loss and take-profit levels.
***
## **Core Components**
### **1. Moving Average System (Triple MA)**
**Purpose:** Identifies trend direction and momentum
- **Fast MA (20-period)** - Short-term price action
- **Medium MA (50-period)** - Intermediate trend
- **Slow MA (200-period)** - Long-term trend direction
**How it works:**
- **Bullish alignment**: MA20 > MA50 > MA200 (all pointing up)
- **Bearish alignment**: MA20 < MA50 < MA200 (all pointing down)
- **Crossover signals**: When Fast MA crosses Medium MA, it triggers buy/sell signals
- **Choice of SMA or EMA**: Adjustable based on preference
**Visual indicators:**
- Blue line = Fast MA
- Orange line = Medium MA
- Light red line = Slow MA
- Green background tint = Bullish trend
- Red background tint = Bearish trend
---
### **2. Candlestick Pattern Recognition (13 Patterns)**
**Purpose:** Identifies reversal and continuation signals based on price action
#### **Bullish Patterns (Signal potential upward moves):**
1. **Hammer** 🔨
- Long lower wick (2x body size)
- Small body at top
- Indicates rejection of lower prices (buyers stepping in)
- Best at support levels
2. **Inverted Hammer**
- Long upper wick
- Small body at bottom
- Shows buying pressure despite initial selling
3. **Bullish Engulfing** 📈
- Green candle completely engulfs previous red candle
- Strong reversal signal
- Body must be 1.2x larger than previous
4. **Morning Star** ⭐
- 3-candle pattern
- Red candle → Small indecision candle → Large green candle
- Powerful reversal at bottoms
5. **Piercing Line** ⚡
- Green candle closes above 50% of previous red candle
- Indicates strong buying interest
6. **Bullish Marubozu**
- Almost no wicks (95% body)
- Very strong bullish momentum
- Body must be 1.3x average size
#### **Bearish Patterns (Signal potential downward moves):**
7. **Shooting Star** 💫
- Long upper wick
- Small body at bottom
- Indicates rejection of higher prices (sellers in control)
- Best at resistance levels
8. **Hanging Man**
- Similar to hammer but appears at top
- Warning of potential reversal down
9. **Bearish Engulfing** 📉
- Red candle completely engulfs previous green candle
- Strong reversal signal
10. **Evening Star** 🌙
- 3-candle pattern (opposite of Morning Star)
- Green → Small → Large red candle
- Powerful top reversal
11. **Dark Cloud Cover** ☁️
- Red candle closes below 50% of previous green candle
- Indicates strong selling pressure
12. **Bearish Marubozu**
- Almost no wicks, pure red body
- Very strong bearish momentum
#### **Neutral Pattern:**
13. **Doji**
- Open and close nearly equal (tiny body)
- Indicates indecision
- Often precedes major moves
**Detection Logic:**
- Compares body size, wick ratios, and position relative to previous candles
- Uses 14-period average body size as reference
- All patterns validated against volume confirmation
***
### **3. Chart Pattern Recognition**
**Purpose:** Identifies major support/resistance and reversal patterns
#### **Patterns Detected:**
**Double Bottom** 📊 (Bullish)
- Two lows at approximately same level
- Indicates strong support
- Breakout above neckline triggers buy signal
- Most reliable at major support zones
**Double Top** 📊 (Bearish)
- Two highs at approximately same level
- Indicates strong resistance
- Breakdown below neckline triggers sell signal
- Most reliable at major resistance zones
**Support & Resistance Levels**
- Automatically plots recent pivot highs (resistance)
- Automatically plots recent pivot lows (support)
- Uses 3-bar strength for validation
- Levels shown as dashed horizontal lines
**Price Action Patterns**
- **Uptrend detection**: Higher highs + higher lows
- **Downtrend detection**: Lower highs + lower lows
- Confirms overall market structure
***
### **4. Volume Analysis**
**Purpose:** Confirms signal strength and filters false signals
**Metrics tracked:**
- **Volume MA (20-period)**: Baseline average volume
- **High volume threshold**: 1.5x the volume average
- **Volume increase**: Current volume > previous 2 bars
**How it's used:**
- All buy/sell signals **require volume confirmation**
- High volume = institutional participation
- Low volume signals are filtered out
- Prevents whipsaw trades during quiet periods
**Visual indicator:**
- Dashboard shows "High" volume in orange when active
- "Normal" shown in gray during low volume
***
### **5. Signal Generation Logic**
**BUY SIGNALS triggered when ANY of these occur:**
1. **Candlestick + Volume**
- Bullish candle pattern detected
- High volume confirmation
- Price above Fast MA
2. **MA Crossover + Volume**
- Fast MA crosses above Medium MA
- High volume confirmation
3. **Double Bottom Breakout**
- Price breaks above support level
- Volume confirmation present
4. **Trend Continuation**
- Uptrend structure intact (higher highs/lows)
- All MAs in bullish alignment
- Price above Fast MA
- Volume confirmation
**SELL SIGNALS triggered when ANY of these occur:**
1. **Candlestick + Volume**
- Bearish candle pattern detected
- High volume confirmation
- Price below Fast MA
2. **MA Crossunder + Volume**
- Fast MA crosses below Medium MA
- High volume confirmation
3. **Double Top Breakdown**
- Price breaks below resistance level
- Volume confirmation present
4. **Trend Continuation**
- Downtrend structure intact (lower highs/lows)
- All MAs in bearish alignment
- Price below Fast MA
- Volume confirmation
***
### **6. Risk Management System**
**Automatic Stop Loss Calculation:**
- Based on ATR (Average True Range) - 14 periods
- **Formula**: Entry price ± (ATR × SL Multiplier)
- **Default multiplier**: 1.5 (adjustable)
- Adapts to market volatility automatically
**Automatic Take Profit Calculation:**
- **Formula**: Entry price ± (ATR × TP Multiplier)
- **Default multiplier**: 2.5 (adjustable)
- **Default Risk:Reward ratio**: 1:1.67
- Higher TP multiplier = more aggressive targets
**Position Management:**
- Tracks ONE position at a time (no pyramiding)
- Automatically closes position when:
- Stop loss is hit
- Take profit is reached
- Opposite MA crossover occurs
- Prevents revenge trading and over-leveraging
**Visual Representation:**
- **Red horizontal line** = Stop Loss level
- **Green horizontal line** = Take Profit level
- Lines remain on chart while position is active
- Automatically disappear when position closes
***
### **7. Visual Elements**
**On-Chart Displays:**
1. **Moving Average Lines**
- Fast MA (Blue, thick)
- Medium MA (Orange, thick)
- Slow MA (Red, thin)
2. **Support/Resistance**
- Green crosses = Support levels
- Red crosses = Resistance levels
3. **Buy/Sell Arrows**
- Large GREEN "BUY" label below bars
- Large RED "SELL" label above bars
4. **Pattern Labels** (Small markers)
- "Hammer", "Bull Engulf", "Morning Star" (green, below bars)
- "Shooting Star", "Bear Engulf", "Evening Star" (red, above bars)
- "Double Bottom" / "Double Top" (blue/orange)
5. **Signal Detail Labels** (Medium size)
- Shows signal reason (e.g., "Bullish Candle", "MA Cross Up")
- Displays Entry, SL, and TP prices
- Color-coded (green for long, red for short)
6. **Background Coloring**
- Light green tint = Bullish MA alignment
- Light red tint = Bearish MA alignment
***
### **8. Information Dashboard**
**Top-right corner table showing:**
| Metric | Description |
|--------|-------------|
| **Position** | Current trade status (LONG/SHORT/None) |
| **MA Trend** | Overall trend direction (Bullish/Bearish/Neutral) |
| **Volume** | Current volume status (High/Normal) |
| **Pattern** | Last detected candlestick pattern |
| **ATR** | Current volatility measurement |
**Purpose:**
- Quick at-a-glance market assessment
- Real-time position tracking
- No need to check multiple indicators
***
### **9. Alert System**
**Complete alert coverage for:**
✅ **Entry Alerts**
- "Buy Signal" - Triggers when buy conditions met
- "Sell Signal" - Triggers when sell conditions met
✅ **Exit Alerts**
- "Long TP Hit" - Take profit reached on long position
- "Long SL Hit" - Stop loss triggered on long position
- "Short TP Hit" - Take profit reached on short position
- "Short SL Hit" - Stop loss triggered on short position
**How to use:**
1. Click "Create Alert" button
2. Select desired alert from dropdown
3. Set notification method (popup, email, SMS, webhook)
4. Never miss a trade opportunity
***
## **Recommended Settings**
### **For Scalping (Quick trades):**
- **Timeframe**: 5-minute
- **Fast MA**: 9
- **Medium MA**: 21
- **Slow MA**: 50
- **SL Multiplier**: 1.0
- **TP Multiplier**: 2.0
- **Volume Threshold**: 1.5x
### **For Swing Trading (Longer holds):**
- **Timeframe**: 1-hour or 4-hour
- **Fast MA**: 20
- **Medium MA**: 50
- **Slow MA**: 200
- **SL Multiplier**: 2.0
- **TP Multiplier**: 3.0
- **Volume Threshold**: 1.3x
### **Best Trading Hours for XAUUSD:**
- **Asian Session**: 00:00 - 08:00 GMT (lower volatility)
- **London Session**: 08:00 - 16:00 GMT (high volatility) ⭐
- **New York Session**: 13:00 - 21:00 GMT (highest volume) ⭐
- **London-NY Overlap**: 13:00 - 16:00 GMT (BEST for scalping) 🔥
***
## **How to Use This Strategy**
### **Step 1: Setup**
1. Open TradingView
2. Load XAUUSD chart
3. Select timeframe (5m, 15m, 1H, or 4H)
4. Add indicator from Pine Editor
5. Adjust settings based on your trading style
### **Step 2: Wait for Signals**
- Watch for GREEN "BUY" or RED "SELL" labels
- Check the signal reason in the detail label
- Verify dashboard shows favorable conditions
- Confirm volume is "High" (not required but preferred)
### **Step 3: Enter Trade**
- Enter at market or limit order near signal price
- Note the displayed Entry, SL, and TP prices
- Set your broker's SL/TP to match indicator levels
### **Step 4: Manage Position**
- Watch for SL/TP lines on chart
- Monitor dashboard for trend changes
- Exit manually if opposite MA crossover occurs
- Let SL/TP do their job (don't move them!)
### **Step 5: Review & Learn**
- Track win rate over 20+ trades
- Adjust multipliers if needed
- Note which patterns work best for you
- Refine entry timing
***
## **Key Advantages**
✅ **Multi-confirmation approach** - Reduces false signals significantly
✅ **Automatic risk management** - No manual calculation needed
✅ **Adapts to volatility** - ATR-based SL/TP adjusts to market conditions
✅ **Volume filtered** - Ensures institutional participation
✅ **Visual clarity** - Easy to understand at a glance
✅ **Complete alert system** - Never miss opportunities
✅ **Pattern education** - Learn patterns as they appear
✅ **Works on all timeframes** - Scalping to swing trading
***
## **Limitations & Considerations**
⚠️ **Not a holy grail** - No strategy wins 100% of trades
⚠️ **Requires practice** - Demo trade first to understand signals
⚠️ **Market conditions matter** - Works best in trending or volatile markets
⚠️ **News events** - Avoid trading during major economic releases
⚠️ **Slippage on 5m** - Fast markets may have execution delays
⚠️ **Pattern subjectivity** - Some patterns may trigger differently than expected
***
## **Risk Management Rules**
1. **Never risk more than 1-2% per trade**
2. **Maximum 3 positions per day** (avoid overtrading)
3. **Don't trade during major news** (NFP, FOMC, etc.)
4. **Use proper position sizing** (0.01 lot per $100 for micro accounts)
5. **Keep trade journal** (track patterns, win rate, mistakes)
6. **Stop trading after 3 consecutive losses** (psychological reset)
7. **Don't move stop loss further away** (accept losses)
8. **Take partial profits** at 1:1 R:R if desired
***
## **Expected Performance**
**Realistic expectations:**
- **Win rate**: 50-65% (depending on market conditions and timeframe)
- **Risk:Reward**: 1:1.67 default (adjustable to 1:2 or 1:3)
- **Signals per day**: 3-8 on 5m, 1-3 on 1H
- **Best months**: High volatility periods (news events, economic uncertainty)
- **Drawdowns**: Expect 3-5 losing trades in a row occasionally
***
## **Customization Options**
All inputs are adjustable in settings panel:
**Moving Averages:**
- Type (SMA or EMA)
- All three period lengths
**Volume:**
- Volume MA length
- High volume multiplier threshold
**Chart Patterns:**
- Pattern strength (bars for pivot detection)
- Show/hide pattern labels
**Risk Management:**
- ATR period
- Stop loss multiplier
- Take profit multiplier
**Display:**
- Toggle pattern labels
- Customize colors (in code)
***
## **Conclusion**
This is a **professional-grade, multi-factor trading system** that combines the best of classical technical analysis with modern risk management. It's designed to give clear, actionable signals while automatically handling the complex calculations of stop loss and take profit levels.
**Best suited for traders who:**
- Understand basic technical analysis
- Can follow rules consistently
- Prefer systematic approach over gut feeling
- Want visual confirmation before entering trades
- Value proper risk management
**Start with demo trading** for at least 20-30 trades to understand how the signals work in different market conditions. Once comfortable and profitable on demo, transition to live trading with minimal risk per trade.
Happy trading! 📈🎯
Directional Strength and Momentum Index█ OVERVIEW
“Directional Strength and Momentum Index” (DSMI) is a technical analysis indicator inspired by DMI, but due to different source data, it produces distinct results. DSMI combines direction measurement, trend strength, and overheat levels into a single index, enhanced with gradient fills, extreme zones, entry signals, candle coloring, and a summary table.
█ CONCEPT
The classic DMI, despite its relatively simple logic, can seem somewhat chaotic due to separate +DI and -DI lines and the need for manual interpretation of their relationships. The DSMI indicator was created to increase clarity and speed up results, consolidating key information into a single index from 0 to 100 that simultaneously:
- Indicates trend direction (bullish/bearish)
- Measures movement strength
- Identifies overheat levels
- Generates ready entry signals
DMI (ADX + +DI / -DI) measures trend direction and strength, but does so based solely on comparing price movements between candles. ADX shows whether the trend is orderly and growing (e.g., above 20–30), but does not assess how dynamic the movement is.
DSMI, on the other hand, takes into account candle size and actual market aggression, thus showing directional momentum — whether the trend has real “fuel” to sustain or accelerate, not just whether it is orderly.
The main calculation difference involves replacing True Range with candle size (high-low) and using directional EMA instead of Wilder smoothing. This allows DSMI to react faster to momentum changes, eliminating delays typical of classic DMI based on TR.
This gives the trader an immediate picture of the market situation without analyzing multiple lines.
█ FEATURES
DSMI Main Line:
- EMA(Directional Index) based on +DS and -DS
- Scale 0–100, smooth color gradient depending on strength
+DS / -DS:
- Positive and Negative Directional Strength
- Gradient fill between lines — more intense with stronger trend
Extreme Zones:
- Default 20 and 80
- Gradient fill outside zones
Trend Strength Levels:
- Weak (<10) → neutral
- Moderate (up to 35)
- Strong (up to 45)
- Overheated (up to 55)
- Extreme (>55)
All levels editable
Entry Signals:
- Activated on crossing entry level (default 20)
Or on direction change when DSMI already ≥ entry level
- Highlighted background (green/red)
Candle Coloring:
- According to current trend
Trend Strength Table:
- Top-right corner
- Shows current strength (WEAK/STRONG etc.) + DSMI value
Alerts:
- DSMI Bullish Entry
- DSMI Bearish Entry
█ HOW TO USE
Add to Chart: Paste code in Pine Editor or find in indicator library.
Settings:
DSMI Parameters:
- DSMI Period → default 20
- Show DSMI Line → on/off
Extreme Zones:
- Lower Level → default 20
- Upper Level → default 80
Trend Strength Levels:
- Weak, Moderate, Strong, Overheated → adjust to strategy
Trend Colors:
- BULLISH → default green
- BEARISH → default red
- NEUTRAL → gray
Entry Signals:
- Show Highlight → on/off
- DSMI Entry Level → default 20
Signal Interpretation:
- DSMI Line: Main strength indicator.
- Gradient between +DS and -DS: Visualizes side dominance.
- Crossing 18 with direction confirmation → entry signal.
- Extreme Zones: Potential reversal or continuation points after correction.
- Table: Quick overview of current trend condition.
█ APPLICATIONS
The indicator works well in:
- Trend-following: Enter on signal, exit on direction change or overheat. When a new trend appears, consider entering a position, preferably with a rising trend strength indicator.
- Scalping/daytrading: Shorter period (7–10), lower entry level.
- Swing/position: Longer period (20–30), higher entry level, extreme zones as filters.
- Noise filtering: Ignores consolidation below “Weak” – increasing value e.g. to 15 highlights consolidation zones, but no signals appear there.
Style Adjustment:
- Aggressive strategies → shorten period and entry level
- Conservative → extend period, raise entry level (25–30), watch “Overheated”
“Weak” level (<10 default) → neutral; increasing it e.g. to 15 gives fewer but higher-quality signals. The Weak zone value controls the level below which no signals appear, and the gradient turns gray (often aligned with consolidation zones).
Combine with:
- Support/resistance levels
- Fair Value Gaps (FVG)
- Volume (Volume Profile, VWAP)
- Other oscillators (RSI, Stochastic)
█ NOTES
- Works on all markets and timeframes.
- Adjust period and levels to instrument volatility.
- Higher entry level → fewer signals, higher quality.
- Neutral color below “Weak” – avoids trading in consolidation.
- Gradient and table enable quick assessment without line analysis.
ScalpGawd Risk Reward//@version=5
indicator("ScalpGawd Risk Reward", overlay=true)
i_fromDate = input.time(timestamp("2024-02-01T00:00:00"), title="Entry Time")
i_entryPrice = input.float(4000, "Entry Price")
i_slPrice = input.float(3900, "Stop Loss Price")
i_distance = input.int(100, "Horizontal Distance (in Time Units)", group="Styling")
i_entryColor = input.color(color.white, "Entry Line", inline="Entry", group="Styling")
i_entryStyle = input.string("solid", title="", options= , inline="Entry", group="Styling")
i_entryWidth = input.int(1, "", inline="Entry", group="Styling")
i_slColor = input.color(color.red, "SL Line", inline="SL", group="Styling")
i_slStyle = input.string("solid", title="", options= , inline="SL", group="Styling")
i_slWidth = input.int(2, "", inline="SL", group="Styling")
i_tpColor = input.color(color.green, "TP Line", inline="TP", group="Styling")
i_tpStyle = input.string("solid", title="", options= , inline="TP", group="Styling")
i_tpWidth = input.int(2, "", inline="TP", group="Styling")
i_labelSize = input.string("tiny", "Label Size", options= , group="Label")
i_labelOffset = input.int(2, "Label Offset", group="Label")
i_useTP1 = input.bool(true, "1", inline="1", group="Show Take Profit")
i_useTP2 = input.bool(true, "2", inline="1", group="Show Take Profit")
i_useTP3 = input.bool(true, "3", inline="1", group="Show Take Profit")
i_useTP4 = input.bool(true, "4", inline="1", group="Show Take Profit")
i_useTP5 = input.bool(true, "5", inline="1", group="Show Take Profit")
i_useTP6 = input.bool(true, "6", inline="1", group="Show Take Profit")
i_useTP7 = input.bool(true, "7", inline="1", group="Show Take Profit")
i_useTP8 = input.bool(true, "8", inline="1", group="Show Take Profit")
i_useTP9 = input.bool(true, "9", inline="1", group="Show Take Profit")
i_useTP10 = input.bool(true, "10", inline="1", group="Show Take Profit")
var int barDistance = na
if bar_index < 2
barDistance := time - time
else
barDistance := math.min(barDistance, time - time )
int distanceInTime = barDistance * i_distance
var line entryLine = na, line.delete(entryLine)
var line stopLossLine = na, line.delete(stopLossLine)
var line tpLine1 = na, line.delete(tpLine1)
var line tpLine2 = na, line.delete(tpLine2)
var line tpLine3 = na, line.delete(tpLine3)
var line tpLine4 = na, line.delete(tpLine4)
var line tpLine5 = na, line.delete(tpLine5)
var line tpLine6 = na, line.delete(tpLine6)
var line tpLine7 = na, line.delete(tpLine7)
var line tpLine8 = na, line.delete(tpLine8)
var line tpLine9 = na, line.delete(tpLine9)
var line tpLine10 = na, line.delete(tpLine10)
var label entryLabel = na, label.delete(entryLabel)
var label slLabel = na, label.delete(slLabel)
var label tpLabel1 = na, label.delete(tpLabel1)
var label tpLabel2 = na, label.delete(tpLabel2)
var label tpLabel3 = na, label.delete(tpLabel3)
var label tpLabel4 = na, label.delete(tpLabel4)
var label tpLabel5 = na, label.delete(tpLabel5)
var label tpLabel6 = na, label.delete(tpLabel6)
var label tpLabel7 = na, label.delete(tpLabel7)
var label tpLabel8 = na, label.delete(tpLabel8)
var label tpLabel9 = na, label.delete(tpLabel9)
var label tpLabel10 = na, label.delete(tpLabel10)
float i_tp1Price = i_entryPrice + (i_entryPrice - i_slPrice)
float i_tp2Price = i_entryPrice + (i_entryPrice - i_slPrice) * 2
float i_tp3Price = i_entryPrice + (i_entryPrice - i_slPrice) * 3
float i_tp4Price = i_entryPrice + (i_entryPrice - i_slPrice) * 4
float i_tp5Price = i_entryPrice + (i_entryPrice - i_slPrice) * 5
float i_tp6Price = i_entryPrice + (i_entryPrice - i_slPrice) * 6
float i_tp7Price = i_entryPrice + (i_entryPrice - i_slPrice) * 7
float i_tp8Price = i_entryPrice + (i_entryPrice - i_slPrice) * 8
float i_tp9Price = i_entryPrice + (i_entryPrice - i_slPrice) * 9
float i_tp10Price = i_entryPrice + (i_entryPrice - i_slPrice) * 10
f_getStyle(_style) =>
ret = line.style_solid
if _style == "dotted"
ret := line.style_dotted
else if _style == "dashed"
ret := line.style_dashed
ret
f_getLabelSize() =>
ret = size.normal
if i_labelSize == "small"
ret := size.small
else if i_labelSize == "tiny"
ret := size.tiny
ret
entryLine := line.new(i_fromDate, i_entryPrice, i_fromDate + distanceInTime, i_entryPrice, xloc=xloc.bar_time, color=i_entryColor, width=i_entryWidth, style=f_getStyle(i_entryStyle))
stopLossLine := line.new(i_fromDate, i_slPrice, i_fromDate + distanceInTime, i_slPrice, xloc=xloc.bar_time, color=i_slColor, width=i_slWidth, style=f_getStyle(i_slStyle))
tpLine1 := i_useTP1 ? line.new(i_fromDate, i_tp1Price, i_fromDate + distanceInTime, i_tp1Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine2 := i_useTP2 ? line.new(i_fromDate, i_tp2Price, i_fromDate + distanceInTime, i_tp2Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine3 := i_useTP3 ? line.new(i_fromDate, i_tp3Price, i_fromDate + distanceInTime, i_tp3Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine4 := i_useTP4 ? line.new(i_fromDate, i_tp4Price, i_fromDate + distanceInTime, i_tp4Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine5 := i_useTP5 ? line.new(i_fromDate, i_tp5Price, i_fromDate + distanceInTime, i_tp5Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine6 := i_useTP6 ? line.new(i_fromDate, i_tp6Price, i_fromDate + distanceInTime, i_tp6Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine7 := i_useTP7 ? line.new(i_fromDate, i_tp7Price, i_fromDate + distanceInTime, i_tp7Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine8 := i_useTP8 ? line.new(i_fromDate, i_tp8Price, i_fromDate + distanceInTime, i_tp8Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine9 := i_useTP9 ? line.new(i_fromDate, i_tp9Price, i_fromDate + distanceInTime, i_tp9Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
tpLine10 := i_useTP10 ? line.new(i_fromDate, i_tp10Price, i_fromDate + distanceInTime, i_tp10Price, xloc=xloc.bar_time, color=i_tpColor, width=i_tpWidth, style=f_getStyle(i_tpStyle)) : na
entryLabel := label.new(i_fromDate + barDistance * i_labelOffset, i_entryPrice, text="Entry @ " + str.tostring(i_entryPrice, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_entryColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize())
slLabel := label.new(i_fromDate + barDistance * i_labelOffset, i_slPrice, text="Stop Loss " + str.tostring((i_slPrice - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_slPrice, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_slColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize())
tpLabel1 := i_useTP1 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp1Price, text="Target 1 " + str.tostring((i_tp1Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp1Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel2 := i_useTP2 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp2Price, text="Target 2 " + str.tostring((i_tp2Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp2Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel3 := i_useTP3 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp3Price, text="Target 3 " + str.tostring((i_tp3Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp3Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel4 := i_useTP4 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp4Price, text="Target 4 " + str.tostring((i_tp4Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp4Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel5 := i_useTP5 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp5Price, text="Target 5 " + str.tostring((i_tp5Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp5Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel6 := i_useTP6 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp6Price, text="Target 6 " + str.tostring((i_tp6Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp6Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel7 := i_useTP7 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp7Price, text="Target 7 " + str.tostring((i_tp7Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp7Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel8 := i_useTP8 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp8Price, text="Target 8 " + str.tostring((i_tp8Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp8Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel9 := i_useTP9 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp9Price, text="Target 9 " + str.tostring((i_tp9Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp9Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
tpLabel10 := i_useTP10 ? label.new(i_fromDate + barDistance * i_labelOffset, i_tp10Price, text="Target 10 " + str.tostring((i_tp10Price - i_entryPrice) / syminfo.mintick, "#")+ " Ticks @ " + str.tostring(i_tp10Price, '#.##'), xloc=xloc.bar_time, yloc=yloc.price, textcolor=i_tpColor, style=label.style_none,textalign = text.align_center, size=f_getLabelSize()) : na
i_showBox = input.bool(true, "Show Background", group="Show Background")
var box greenBox = na, box.delete(greenBox)
var box redBox = na, box.delete(redBox)
f_findHighestTP() =>
ret = i_tp1Price
if i_useTP10
ret := i_tp10Price
else if i_useTP9
ret := i_tp9Price
else if i_useTP8
ret := i_tp8Price
else if i_useTP7
ret := i_tp7Price
else if i_useTP6
ret := i_tp6Price
else if i_useTP5
ret := i_tp5Price
else if i_useTP4
ret := i_tp4Price
else if i_useTP3
ret := i_tp3Price
else if i_useTP2
ret := i_tp2Price
ret
greenBox := i_showBox ? box.new(i_fromDate, i_entryPrice, i_fromDate + distanceInTime, f_findHighestTP(), xloc=xloc.bar_time, bgcolor=color.new(i_tpColor, 70), border_width = 0) : na
redBox := i_showBox ? box.new(i_fromDate, i_entryPrice, i_fromDate + distanceInTime, i_slPrice, xloc=xloc.bar_time, bgcolor=color.new(i_slColor, 70), border_width = 0) : na
TMB Invest - Smart Money Concept StrategyEnglish:
**Quick Overview**
The "TMB_SMC_Strategy_v1.1.3" combines a classic trend filter using two EMAs with contrarian RSI entries and simple SMC elements (Fair Value Gaps & Order Blocks). Stop-loss and take-profit orders are volatility-adaptive and controlled via the ATR. An integrated dashboard displays the setup status, stop-loss/take-profit levels, entry reference, and trend, RSI, and ATR values.
---
## Operating Principle
1. **Trend Filter:** A fast EMA (default 50) is compared to a slow EMA (default 200). Trading occurs only in the direction of the trend: long in uptrends, short in downtrends.
2. **Timing via RSI:** Contrarian entries within the trend. Go long when the RSI is below a buy level (default 40); Short when the RSI is above a sell level (standard 60).
3. **Structure Check (SMC Proxy):** An "FVG Touch" serves as additional confirmation that an inefficient price zone has been tested. Order blocks are visualized for guidance but are not a direct entry trigger.
4. **Risk Management via ATR:** Stop-loss and take-profit levels are set as multipliers of the current ATR (e.g., SL = 1×ATR, TP = 2×ATR). This allows target and risk distances to adjust to market volatility.
5. **Simple Position Logic:** Only one position is held at a time (no pyramiding). After entry, stop and limit orders (bracket exit) are automatically placed.
---
## Input Values
* **EMA Fast / EMA Slow:** Lengths of the moving averages for the trend filter.
* **RSI Length / Levels:** Length of the RSI as well as buy and sell thresholds (contra signals within the trend direction).
* **Take Profit (RR) / Stop Loss (RR):** ATR multipliers for TP and SL.
* **Show FVGs & Order Blocks:** Toggles the visual SMC elements (zones/boxes) on or off.
--
## Signals & Execution
* **Long Setup:** Uptrend (fast EMA above slow EMA) **and** RSI below the buy level **and** a current FVG signal in a bullish direction.
* **Short Setup:** Downtrend (fast EMA below slow EMA) **and** RSI above the sell level **and** a current FVG touch in a bearish direction.
* **Entry & Exit:** If the setup is met, the market is entered; stop-loss/take-profit orders are placed immediately according to ATR multiples.
--
## Visualization
* **EMAs:** The fast and slow EMAs are plotted to illustrate the trend.
* **FVGs:** Fair Value Gaps are drawn as semi-transparent boxes in the trend color and projected slightly into the future.
* **Order Blocks:** Potential order block zones from the previous candle are visually highlighted (for informational purposes only).
---
## Integrated Dashboard
A compact table dashboard (bottom left) displays:
* Current **Setup Status** (Long/Short active, Long/Short ready, No Setup),
* **Stop-Loss**, **Take-Profit**, and **Entry Reference**,
* **Trend Status** (Bull/Bear/Sideways),
* **RSI Value**, and **ATR Value**.
Active long/short positions are highlighted in color (green/red).
--
## Practical Guide
1. **Place on Chart** and select the desired timeframe.
2. **Calibrate Parameters** (EMA lengths, RSI levels, ATR multipliers) to match the market and timeframe.
3. **Backtest** across different market phases; prioritize robustness over maximum curve fit.
4. **Fine-Tuning:**
* Shorter EMAs are often useful intraday (e.g., 20/100 or 34/144).
* Adjust RSI levels to market characteristics (45/55 for aggressive trading, 30/70 for conservative trading).
* Increase or decrease ATR multipliers depending on volatility/trading style.
--
## Notes, Limitations & Extensions
* **FVG Definition:** The FVG detection used here is intentionally simplified. Those who prefer a more rigorous approach can switch to a 3-candle definition and fill levels.
* **Order Blocks:** These primarily serve as a guide. Integration into entry/exit logic (e.g., retests) is possible as an extension.
* **Backtest Realism:** Fills may differ from the displayed closing price. For greater accuracy, intrabar backtests or an entry indicator based on the average position price are conceivable.
* **Alerts:** Currently, no alert conditions are defined; these can be added for long/short setups and status messages.
* **Position Management:** By default, no scaling is performed. Partial sales, trailing stops, or multiple entries can be added.
---
## Purpose & Benefits
The strategy offers a clear, modular framework: trend filter (direction), RSI contra timing (entry), SMC proxy via FVG Touch (structure), and ATR-based exits (risk adaptation). This makes it robust, easy to understand, and highly extensible—both for discretionary traders who appreciate visual SMC elements and for systematic testers who prefer a clean, parameterizable foundation.
Enhanced MA Crossover Pro📝 Strategy Summary: Enhanced MA Crossover Pro
This strategy is an advanced, highly configurable moving average (MA) crossover system designed for algorithmic trading. It uses the crossover of two customizable MAs (a "Fast" MA 1 and a "Slow" MA 2) as its core entry signal, but aggressively integrates multiple technical filters, time controls, and dynamic position management to create a robust and comprehensive trading system.
💡 Core Logic
Entry Signal: A bullish crossover (MA1 > MA2) generates a Long signal, and a bearish crossover (MA1 < MA2) generates a Short signal. Users can opt to use MA crossovers from a Higher Timeframe (HTF) for the entry signal.
Confirmation/Filters: The basic MA cross signal is filtered by several optional indicators (see Filters section below) to ensure trades align with a broader trend or momentum context.
Position Management: Trades are managed with a sophisticated system of Stop Loss, Take Profit, Trailing Stops, and Breakeven stops that can be fixed, ATR-based, or dynamically adjusted.
Risk Management: Daily limits are enforced for maximum profit/loss and maximum trades per day.
⚙️ Key Features and Customization
1. Moving Averages
Primary MAs (MA1 & MA2): Highly configurable lengths (default 8 & 20) and types: EMA, WMA, SMA, or SMMA/RMA.
Higher Timeframe (HTF) MAs: Optional MAs calculated on a user-defined resolution (e.g., "60" for 1-hour) for use as an entry signal or as a trend confirmation filter.
2. Multi-Filter System
The entry signal can be filtered by the following optional conditions:
SMA Filter: Price must be above a 200-period SMA for long trades, and below it for short trades.
VWAP Filter: Price must be above VWAP for long trades, and below it for short trades.
RSI Filter: Long trades are blocked if RSI is overbought (default 70); short trades are blocked if RSI is oversold (default 30).
MACD Filter: Requires the MACD Line to be above the Signal Line for long trades (and vice versa for short trades).
HTF Confirmation: Requires the HTF MA1 to be above HTF MA2 for long entries (and vice versa).
3. Dynamic Stop and Target Management (S/L & T/P)
The strategy provides extensive control over exits:
Stop Loss Methods:
Fixed: Fixed tick amount.
ATR: Based on a multiple of the Average True Range (ATR).
Capped ATR: ATR stop limited by a maximum fixed tick amount.
Exit on Close Cross MA: Position is closed if the price crosses back over the chosen MA (MA1 or MA2).
Breakeven Stop: A stop can be moved to the entry price once a trigger distance (fixed ticks or Adaptive Breakeven based on ATR%) is reached.
Trailing Stop: Can be fixed or ATR-based, with an optional feature to auto-tighten the trailing multiplier after the breakeven condition is met.
Profit Target: Can be a fixed tick amount or a dynamic target based on an ATR multiplier.
4. Time and Session Control
Trading Session: Trades are only taken between defined Start/End Hours and Minutes (e.g., 9:30 to 16:00).
Forced Close: All open positions are closed near the end of the session (e.g., 15:45).
Trading Days: Allows specific days of the week to be enabled or disabled for trading.
5. Risk and Position Limits
Daily Profit/Loss Limits: The strategy tracks daily realized and unrealized PnL in ticks and will close all positions and block new entries if the user-defined maximum profit or maximum loss is hit.
Max Trades Per Day: Limits the number of executed trades in a single day.
🎨 Outputs and Alerts
Plots: Plots the MA1, MA2, SMA, VWAP, and HTF MAs (if enabled) on the chart.
Shapes: Plots visual markers (BUY/SELL labels) on the bar where the MA crossover occurs.
Trailing Stop: Plots the dynamic trailing stop level when a position is open.
Alerts: Generates JSON-formatted alerts for entry ({"action":"buy", "price":...}) and exit ({"action":"exit", "position":"long", "price":...}).
