Narrow Range + Inside Day, Long Only Strategy (by ChartArt)This long only strategy determines when there is both a NR7 (narrow range 7, a trading day in which the range is narrower than any of the previous six days), plus a inside day (high of the current day is lower than the high of the previous day and the low of the current day is higher than the low of the previous day) both on the same trading day and enters a long trade when the close is larger than the open and the slope of the simple moving average is upwards, too.
The strategy closes the long trade next time the daily close is larger than the open in any of the next trading days. In addition the NR7ID can be colored (the color is green when the close is larger that day than the open, else the color is red) and the SMA can be drawn with a color based on the direction of the SMA slope. To fine-tune the strategy it is highly recommended to change the period length of the SMA, which determines if the measured SMA slope is upwards or not.
Inspiration:
How to trade NR7 and Inside Day Pattern
paststat.com
Code credit:
NR7 indicator script from Tradingview user Lazybear:
pastebin.com
Cari dalam skrip untuk "chart"
The Always Winning Holy Grail Strategy - Not (by ChartArt)How to win all the time if 1+1 = 2
The most upvoted strategies on Tradingview are those which seemingly work 100%, but they actually don't at all because they are repainting and would not work in live trading reality. They are using the multi-time-frame strategy testing bug and thereby trade during the backtest on close prices before the bar has closed in reality.
Top list of these cheating repainting strategies:
1569 upvotes ANN Strategy
877 upvotes Vdub FX SniperVX3 Strategy
481 upvotes Get Trend Strategy
I guess there are much more strategies among the top upvoted strategies on Tradingview which cheat with a multi-time-frame close price, but three examples are enough. The ANN Strategy uses the daily close price as multi-time-frame and cheats with that. The Vdub FX SniperVX3 Strategy uses the half-day (720 minute) close price to cheat and the Get Trend Strategy uses the 160 minute bar close for repaint cheating (at least here the author of this strategy explains that his strategy is only demo and would not work, which might be the reason why it has 1000 less upvotes than the ANN Strategy. I already wrote months ago a comment underneat these strategies to explain this issue but it hasn't stopped these strategies from getting more and more upvotes and staying in the top list.
I thought this way of cheating is lame, so I invented a new way to cheat my way to seemingly reach 100% profitable trades all the time by going long if 1+1 is equal to 2. Welcome to super wide stop losses. Simply use a extreme unrealistic large stop loss and take profit after a realistic amount of pips and according to Tradingview's current backtest module you win 100% all the time. Yay! :)
My recommendation for the Tradingview team is to add a function to let the user define a stop out and margin call level and maybe set a realistic setting as default, like 100%.
Please don't trade with this strategy!
Buy Tuesday Strategy (by ChartArt)This strategy is as simple as possible: Every Tuesday a new long trade is opened, when Monday (yesterday) closed higher than it opened the week. The strategy closes all orders when the next close is larger than the open.
This strategy does not have any other stop loss or take profit money management logic and is therefore VERY risky, because it always waits to close all orders until the close is larger than the open. I recommend to mainly use it to find stocks or assets which are trending higher and are following this very basic trading idea.
--
P.S. The code of the strategy does not work on digital assets like Bitcoin, Litecoin or Ethereum, which are traded every day including Saturday and Sunday, because the code checks if Monday was preceded by a Friday (and not by a Sunday and Saturday).
Fractal Breakout Strategy (by ChartArt)This long only strategy determines the price of the last fractal top and enters a trade when the price breaks above the last fractal top. The strategy also calculates the average price of the last fractal tops to get the trend direction. The strategy exits the long trade, when the average of the fractal tops is falling (when the trend is lower highs as measured by fractals). And the user can manually set a time delay of this exit condition. The default setting is a long strategy exit always 3 bars after the long entry condition appeared.
In addition as gimmicks the fractals tops can be highlighted (the default is blue) and a line can be drawn based on the fractal tops.This fractal top line is colored by the fractal top average trend in combination with the fractal breakout condition.
This strategy works better on higher time-frames (weekly and monthly), but it also works on the daily and some other time-frames. This strategy does not repaint, no repainting.
P.S. I thank Tradingview user barracuda who helped me with the time based exit condition code. And user RicardoSantos for coding the definition of the fractal top, which he uses in his " Fractals" scripts.
All trading involves high risk; past performance is not necessarily indicative of future results. Hypothetical or simulated performance results have certain inherent limitations. Unlike an actual performance record, simulated results do not represent actual trading. Also, since the trades have not actually been executed, the results may have under- or over-compensated for the impact, if any, of certain market factors, such as lack of liquidity. Simulated trading programs in general are also subject to the fact that they are designed with the benefit of hindsight. No representation is being made that any account will or is likely to achieve profits or losses similar to those shown.
Daily Close Comparison Strategy (by ChartArt via sirolf2009)Comparing daily close prices as a strategy.
This strategy is equal to the very popular "ANN Strategy" coded by sirolf2009(1) which calculates the percentage difference of the daily close price, but this bar-bone version works completely without his Artificial Neural Network (ANN) part.
Main difference besides stripping out the ANN is that my version uses close prices instead of OHLC4 prices, because they perform better in backtesting. And the default threshold is set to 0 to keep it simple instead of 0.0014 with a larger step value of 0.001 instead of 0.0001. Just like the ANN strategy this strategy goes long if the close of the current day is larger than the close price of the last day. If the inverse logic is true, the strategy goes short (last close larger current close). (2)
This basic strategy does not have any stop loss or take profit money management logic. And I repeat, the credit for the fundamental code idea goes to sirolf2009.
(2) Because the multi-time-frame close of the current day is future data, meaning not available in live-trading (also described as repainting), is the reason why this strategy and the original "ANN Strategy" coded by sirolf2009 perform so excellent in backtesting.
All trading involves high risk; past performance is not necessarily indicative of future results. Hypothetical or simulated performance results have certain inherent limitations. Unlike an actual performance record, simulated results do not represent actual trading. Also, since the trades have not actually been executed, the results may have under- or over-compensated for the impact, if any, of certain market factors, such as lack of liquidity. Simulated trading programs in general are also subject to the fact that they are designed with the benefit of hindsight. No representation is being made that any account will or is likely to achieve profits or losses similar to those shown.
(1) You can get the original code by sirolf2009 including the ANN as indicator here:
(1) and this is sirolf2009's very popular strategy version of his ANN:
MACD + Stochastic, Double Strategy (by ChartArt)This strategy combines the classic stochastic strategy to buy when the stochastic is oversold with a classic MACD strategy to buy when the MACD histogram value goes above the zero line. Only difference to the classic stochastic is a default setting of 71 for overbought (classic setting 80) and 29 for oversold (classic setting 20).
Therefore this strategy goes long if the MACD histogram goes above zero and the stochastic indicator detects a oversold condition (value below 29). If the inverse logic is true, the strategy goes short (stochastic overbought condition with a value above 71 and the MACD histogram falling below the zero line value).
Please be aware that this pure double strategy using simply two classic indicators does not have any stop loss or take profit money management logic.
All trading involves high risk; past performance is not necessarily indicative of future results. Hypothetical or simulated performance results have certain inherent limitations. Unlike an actual performance record, simulated results do not represent actual trading. Also, since the trades have not actually been executed, the results may have under- or over-compensated for the impact, if any, of certain market factors, such as lack of liquidity. Simulated trading programs in general are also subject to the fact that they are designed with the benefit of hindsight. No representation is being made that any account will or is likely to achieve profits or losses similar to those shown.
Bollinger + RSI, Double Strategy (by ChartArt) v1.1This strategy uses the RSI indicator together with the Bollinger Bands to sell when the price is above the upper Bollinger Band (and to buy when this value is below the lower band). This simple strategy only triggers when both the RSI and the Bollinger Band indicators are at the same time in a overbought or oversold condition.
UPDATE
In this updated version 1.1 the strategy was both simplified for the user (less inputs) and made more successful in backtesting by now using a 200 period for the SMA which is the basis for the Bollinger Band. I also reduced the number of color alerts to show fewer, but more relevant trading opportunities.
And just like the first version this strategy does not use close prices from higher-time frame and should not repaint after the current candle has closed. It might repaint like every Tradingview indicator while the current candle hasn't closed.
All trading involves high risk; past performance is not necessarily indicative of future results. Hypothetical or simulated performance results have certain inherent limitations. Unlike an actual performance record, simulated results do not represent actual trading. Also, since the trades have not actually been executed, the results may have under- or over-compensated for the impact, if any, of certain market factors, such as lack of liquidity. Simulated trading programs in general are also subject to the fact that they are designed with the benefit of hindsight. No representation is being made that any account will or is likely to achieve profits or losses similar to those shown.
P.S. For advanced users if you want access to more functions of this strategy script, then please use version 1.0:
Bollinger + RSI, Double Strategy (by ChartArt)Bollinger Bands + RSI, Double Strategy
This strategy uses a slower RSI with period 16 to sell when the RSI increases over the value of 55 (or to buy when the value falls below 45), with the classic Bollinger Bands strategy to sell when the price is above the upper Bollinger Band and falls below it (and to buy when the price is below the lower band and rises above it). This strategy only triggers when both the RSI and the Bollinger Bands indicators are at the same time in the described overbought or oversold condition. In addition there are color alerts which can be deactivated.
This basic strategy is based upon the "RSI Strategy" and "Bollinger Bands Strategy" which were created by Tradingview and uses no money management like a trailing stop loss and no scalping methods. Every win/loss trade is simply counted from the last overbought/oversold condition to the next one.
This strategy does not use close prices from higher-time frame and should not repaint after the current candle has closed. It might repaint like every Tradingview indicator while the current candle hasn't closed.
All trading involves high risk; past performance is not necessarily indicative of future results. Hypothetical or simulated performance results have certain inherent limitations. Unlike an actual performance record, simulated results do not represent actual trading. Also, since the trades have not actually been executed, the results may have under- or over-compensated for the impact, if any, of certain market factors, such as lack of liquidity. Simulated trading programs in general are also subject to the fact that they are designed with the benefit of hindsight. No representation is being made that any account will or is likely to achieve profits or losses similar to those shown.
Moving Average Consecutive Up/Down Strategy (by ChartArt)This simple strategy goes long (or short) if there are several consecutive increasing (or decreasing) moving average values in a row in the same direction. The bars can be colored using the raw moving average trend. And the background can be colored using the consecutive moving average trend setting. In addition a experimental line of the moving average change can be drawn.
The strategy is based upon the "Consecutive Up/Down Strategy" which was created by Tradingview.
All trading involves high risk; past performance is not necessarily indicative of future results. Hypothetical or simulated performance results have certain inherent limitations. Unlike an actual performance record, simulated results do not represent actual trading. Also, since the trades have not actually been executed, the results may have under- or over-compensated for the impact, if any, of certain market factors, such as lack of liquidity. Simulated trading programs in general are also subject to the fact that they are designed with the benefit of hindsight. No representation is being made that any account will or is likely to achieve profits or losses similar to those shown.
Rounded Weekly Pivot (by ChartArt)Trade with the trend. This is an overlay indicator which shows the weekly pivot (rounded) either as line or circle drawing, select-able by the user. The width of the pivot line (or circle) overlay is also adjustable.
In addition the bars can be colored by the trend, depending if the close price is above or below both the weekly and monthly pivots. If the close price is neither above or below both the weekly and monthly pivot prices the trend color is neutral blue.
The weekly pivot indicator with the optional setting that the pivot price is drawn as circles instead of a line:
And here with the pivot drawing disabled, showing only the pivot bar trend color
Outsidebar vs Insidebar, Illusion Strategy (by ChartArt)WARNING: This strategy does not work! Please don't trade with this strategy
I'm sharing this strategy for the following three educational reasons:
1. You can easily find 100% strategies, but if they only seem to work 100% on one asset, they actually don't work at all. Therefore never backtest your strategy only on one asset, especially forward testing is useless, because it tends to repeat the old patterns. Your strategy has to work on as many different assets as possible.
2. The pyramiding of orders can have an impact on the strategy. In this case if you manually change the strategy settings by increasing it from 1 to 100 pyramiding orders changes the percent profitable on "UKOIL" monthly from 100% to 90% profitable. On other assets you can see very different results. Allowing much more pyramiding orders in this case results in opening orders where the background color highlights appear.
3. The Tradingview backtest beta version currently does not close the last open trade during the backtest. In this case going long on "UKOIL" near the top in 2011 as this strategy did would result in a big loss in 2015. But since the trade is still open and not canceled out by a new short order it still appears as if this strategy works 100% profitable. Which it doesn't.
Moving Average Cross Alert, Multi-Timeframe (MTF) (by ChartArt)See when two moving averages cross. With the option to choose between four moving average calculations:
SMA = simple moving average
EMA = exponential moving average (default)
WMA = weighted moving average
Linear = linear regression
The moving averages can be plotted from different time-frames, like e.g. the weekly or 4 hour time-frame using HL2, HLC3 or OHLC4 as price source for the calculation. In addition there is a background color alert and arrows when the moving averages cross each other when the price also rises or falls. And the moving averages are colored depending on their trend direction (if they are trending up or down).
Market Trend Strength (MTS) (by ChartArt)See the current trend strength of the market. An additional filter makes trend consolidation areas visible. The color changes there each bar back and forth between green and red.
This area was interesting. Would have been a better example:
If the filter is deactivated the indicator shows the last measured price trend (green for up and down for red).
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")
HITESH SOMANI Strategy Technical based strategy. Strong chart pattern based strategy for working professionals who dont have much time for trading
KRX RS OverlayKRX RS Overlay (Manual, Pine v6) (한국어 설명 아래에)
What it does
Plots a Relative Strength (RS) line of the current symbol versus a selected Korean market index on the price chart (overlay). RS is computed as Close(symbol) / Close(benchmark) and rebased to 100 N bars ago for easy comparison. An SMA of RS is included for signal smoothing.
Benchmarks (manual selection only)
• KOSPI (KRX:KOSPI) — default
• KOSDAQ (KRX:KOSDAQ)
• KOSPI200 (KRX:KOSPI200)
• KOSDAQ150 (KRX:KOSDAQ150)
Inputs
• Benchmark: choose one of the four indices above (default: KOSPI)
• Rebase N bars ago to 100: sets the normalization point (e.g., 252 ≈ 1 trading year on daily)
• RS SMA length: smoothing period for the RS line
• Show 100 base line: toggle the reference line at 100
How to read
• RS rising → the symbol is outperforming the selected index.
• RS above RS-SMA and sloping up → strengthening leadership vs. the benchmark.
• RS crossing above RS-SMA → momentum-style confirmation (an alert is provided).
Tips
• Works on any timeframe; the benchmark is requested on the same timeframe.
• If the RS line scale conflicts with price, place the indicator on the Left scale (Chart Settings → Scales) or set the series to use the left axis.
Notes
• This script is manual only (no auto index detection).
• Educational use; not financial advice.
⸻
KRX RS 오버레이 (수동, Pine v6)
기능
현재 종목을 선택한 한국 지수와 비교한 상대강도(RS) 라인을 가격 차트 위(오버레이)에 표시합니다. RS는 종목 종가 / 지수 종가로 계산하며, 비교를 쉽게 하기 위해 N봉 전 = 100으로 리베이스합니다. 신호 완화를 위해 RS의 SMA도 함께 제공합니다.
벤치마크(수동 선택만 지원)
• KOSPI (KRX:KOSPI) — 기본값
• KOSDAQ (KRX:KOSDAQ)
• KOSPI200 (KRX:KOSPI200)
• KOSDAQ150 (KRX:KOSDAQ150)
입력값
• Benchmark: 위 4개 지수 중 선택(기본: KOSPI)
• Rebase N bars ago to 100: 리베이스 기준(일봉 252 ≈ 1년)
• RS SMA length: RS 스무딩 기간
• Show 100 base line: 100 기준선 표시 여부
해석 가이드
• RS 상승 → 선택 지수 대비 초과성과.
• RS가 RS-SMA 위 & 우상향 → 벤치마크 대비 리더십 강화.
• RS가 RS-SMA 상향 돌파 → 모멘텀 확인(알림 제공).
팁
• 모든 타임프레임에서 동작하며, 지수도 동일 타임프레임으로 요청됩니다.
• 가격 축과 스케일이 겹치면 왼쪽 스케일로 표시하도록 설정하세요(차트 설정 → Scales).
유의사항
• 자동 지수 판별 기능은 포함하지 않았습니다(수동 전용).
Consecutive Gap FinderLooks for consecutive gaps based on daily chart using ATR multiplier.
Highlights them when a certain number are found.
Gold 15m: Trend + S/R + Liquidity Sweep (RR 1:2)This strategy is designed for short-term trading on XAUUSD (Gold) using the 15-minute timeframe. It combines trend direction, support/resistance pivots, liquidity sweep detection, and momentum confirmation to identify high-probability reversal setups in line with the dominant market trend.
⚙️ Core Logic:
Trend Filter (EMA 200):
The strategy only takes long positions when price is above the 200 EMA and short positions when price is below it.
Support/Resistance via Pivots:
Dynamic swing highs and lows are identified using pivot points. These act as local supply and demand levels where liquidity is likely to accumulate.
Liquidity Sweep Detection:
A bullish liquidity sweep occurs when price briefly breaks below the last pivot low (grabbing liquidity) and then closes back above it.
A bearish sweep occurs when price breaks above the last pivot high and then closes back below.
Momentum & Candle Strength:
The strategy filters signals based on candle range and body size to ensure entries occur during strong price reactions, not weak retracements.
Risk Management (1:2 RR):
Stop-loss is placed slightly beyond the last pivot level using ATR-based buffers, and take-profit is set at 2× the risk distance, maintaining a reward-to-risk ratio of 1:2.
💼 Trade Logic Summary:
Long Entry:
After a bullish liquidity sweep & reclaim, momentum confirmation, and trend alignment (above EMA 200).
Short Entry:
After a bearish sweep & reclaim, momentum confirmation, and trend alignment (below EMA 200).
Exit:
Automated via ATR-based Stop Loss and Take Profit targets.
📊 Customization Options:
Adjustable EMA length, pivot settings, ATR multipliers, and RR ratio.
Option to enable/disable trend filter.
Toggle display of S/R zones on chart.
🧠 Best Use:
Works best during London and New York sessions when Gold shows strong momentum.
Can be adapted for forex pairs and indices by tuning ATR and pivot parameters.
QQQ overlay over NQ/NDXThis enhanced version of the QQQ overlay script builds on the original by © PtGambler, adding smoothing via stepped ratios updated on candle close to eliminate oscillation, optimizing performance by reusing lines/labels, restricting visibility to relevant symbols (NDX, NQ1!, NAS100USD), and improving visuals with rounded levels, adjustable level counts (default 5 total), extended lines, and label styles matching "Key Levels" indicator for better readability (gray text, transparent background). Removed unnecessary table and floating labels for a cleaner chart. Thanks to © PtGambler for the foundational work!
XAUUSD 5m — CET 13:00→01:00 Supertrend + RSI (1:2 RR) — $240KThis strategy is designed for XAUUSD (Gold) on the 5-minute chart, optimized for trading during the most active hours (13:00–01:00 CET).
It combines a Supertrend direction filter with RSI crossovers for precise entries, and applies a 1:2 risk–reward ratio for consistent risk management.
🧠 Logic Overview:
Buy Signal: RSI crosses above 55 while Supertrend is bullish
Sell Signal: RSI crosses below 45 while Supertrend is bearish
Trading Hours: 13:00 → 01:00 CET (corresponding to 07:00 → 19:00 New York time)
Risk Management: Fixed 1:2 RR (TP = 2× SL distance from Supertrend line)
Session Management: Automatically closes all trades after 01:00 CET
Order Size: $240,000 notional exposure per position
💡 Best used for:
Scalping or intraday trading on XAUUSD during high-volatility hours.
The setup works best when combined with strong price action or volume confirmation.
⚠️ Disclaimer:
This script is for educational and testing purposes only.
Past performance does not guarantee future results.
Always test on demo before using live funds.
FVG SizeFVG Size Indicator – Description
Overview
This Pine Script v5 indicator detects and visualizes Fair Value Gaps (FVGs) on the chart. It draws colored boxes for FVGs, center lines (CE), and displays the size of each FVG as a label. The indicator is designed for manual analysis, helping traders identify potential price imbalances.
Key Features
FVG Detection:
Identifies bullish and bearish FVGs based on price structure.
Draws colored boxes for FVGs and dotted center lines (CE).
FVG Size Display:
Shows the size of each FVG as a label inside the box.
Customizable minimum size threshold to filter out smaller FVGs.
Dynamic Adjustments:
Extends FVG boxes to the right as new bars form.
Removes FVGs that are filled (mitigated) by price action.
Customizable Settings:
Adjustable colors, text size, and display options.
Settings and Translations
Here are the German settings with their English translations:
FVG Settings
Long FVG Farbe → Long FVG Color (Color for bullish FVG boxes)
Short FVG Farbe → Short FVG Color (Color for bearish FVG boxes)
CE Farbe → CE Color (Color for the center line)
Tage Rückblick → Lookback Days (Number of days to look back for FVGs)
Lösche gefüllte Boxen & Linien → Delete Filled Boxes & Lines (Removes FVGs that have been filled by price)
FVG Display
FVG Größe anzeigen → Show FVG Size (Displays the size of each FVG as a label)
Text → Text Size (Size of the FVG size label text)
Mindestgröße → Minimum Size (Minimum FVG size to display, filtering out smaller FVGs)
How It Works
FVG Detection Logic:
A bullish FVG is detected if the high of the 3rd bar is lower than the low of the 1st bar.
A bearish FVG is detected if the low of the 3rd bar is higher than the high of the 1st bar.
Drawing FVGs:
The indicator draws a box between the high/low of the 1st and 3rd bars.
A center line (CE) is drawn at the midpoint of the FVG.
The size of the FVG is displayed as a label inside the box.
Dynamic Adjustments:
FVG boxes are extended to the right as new bars form.
If the price fills the FVG, the box and line are removed (depending on settings).
Mitigation Logic:
If the price closes beyond the FVG boundaries, the FVG is considered "filled" and removed.
HA Reversal + Doji 🔥 Heikin Ashi Reversal + Stochastic Filter (Precision Entry System)
This indicator is designed to detect high–quality reversal entries using a Heikin Ashi candle pattern (Doji + 2 no–wick confirmation) combined with a strict Stochastic filter that uses memory of extreme touches to control trade direction.
✅ Entry Logic
🔹 Bullish BUY Signal
A BUY is triggered only when:
A valid reversal pattern is detected:
Doji candle (pivot) 3 bars back
Followed by 2 bullish candles with no lower wicks
Stochastic touched Oversold (≤ 20) at least once before the signal
Pattern + Stoch alignment = BUY
🔹 Bearish SELL Signal
A SELL is triggered only when:
Valid bearish reversal pattern:
Doji candle (pivot) 3 bars back
Followed by 2 bearish candles with no upper wicks
Stochastic touched Overbought (≥ 80) before the signal
Pattern + Stoch alignment = SELL
🧠 Stochastic “Memory” Filter
This is not a basic OB/OS filter — it uses event memory:
If Stochastic touches Oversold, the system becomes ready for BUY
If it touches Overbought, it becomes ready for SELL
Both directions can be armed at once
Once a BUY or SELL actually triggers, memory resets to neutral
Prevents “signal spam” during chop and keeps direction meaningful
🎯 Why This Works
✔ Filters out random countertrend noise
✔ Only trades after momentum exhaustion
✔ Uses strict Heikin Ashi reversal structure
✔ Works great across crypto, forex, indices, metals
✔ Designed for precision entries and swing continuation traps
⚙️ Customizable Options
Doji detection mode (body % / ticks / hybrid)
Wick tolerance
Heikin Ashi source (chart or calculated)
Stochastic source (raw or smoothed)
Option to avoid duplicate same-direction signals
Visual aids: pattern markers, blocked signals, doji debugging
📌 Best Use Cases
Reversal scalping on 5m/15m
Swing entries on 1H/4H
Trend exhaustion confirmation
Smart Money Concepts entry refinement
Entry timing after liquidity sweeps
🚨 Important
This is not a repainting system. Signals are generated at bar close only. Always combine with proper risk management and market context.
Let me know if you want:
✅ A shorter description
✅ An SEO optimized TradingView title
✅ A strategy version with backtesting
✅ Alerts version for automation
Ripster Labels + Air Gaps (v6)What it shows (on one chart)
EMA Clouds (current timeframe)
Plots EMA 8/12/21/34/50/200 with three cloud fills:
12–21 = “fast” cloud
34–50 = “mid” cloud
50–200 = “base” cloud
Cloud color: green when the faster EMA is above the slower (bullish), red/maroon/orange when below (bearish).
Toggle lines vs. clouds via A) EMA Clouds settings.
MTF Rails (higher-TF EMAs)
For three higher timeframes (defaults 30m / 60m / 240m), draws two EMAs each (defaults 34 & 50).
These are stepline-like rails you can visually use as higher-TF supports/resistances.
Configure in B) MTF Rails (turn on/off, change TFs/lengths/colors).
Relative Volume Box (RVol)
Small table (top-center) showing:
Candle Vol (formatted K/M/B if enabled)
RVol = current bar volume / SMA 20 of volume (as a %)
Color scale: blue (<100%), yellow (100–150%), red (>150%).
Settings in C) RVol Box.
DTR vs ATR Box
Daily True Range (DTR = day high − day low) vs ATR(14) on the daily timeframe, with DTR as % of ATR.
Placed at top-right; toggle in D) DTR/ATR Box.
Ripster Trend Label (10m 12/50)
Looks at a separate timeframe (default 10m): EMA 12 vs EMA 50.
Bottom-right table cell shows “10m Trend ↑/↓/Sideways” (green/red/gray).
Configure in E) Ripster Trend Labels (TF and lengths).
Air Gaps (single EMA per TF)
Three horizontal, auto-extending lines showing an EMA from 30m / 60m / 240m (default length 12).
“Air gaps” are the price spaces between these lines—often lighter-resistance zones for price.
Start point logic:
All Bars = draw from the chart’s left
Start of Day = draw from today’s first bar
Bars Offset = draw from N bars back (default 100)
Settings in F) Air Gaps (TFs, length, draw-from, bars-back).
Inputs & where to tweak
A) EMA Clouds
Show EMA Clouds: master toggle
Source: close (default)
Lengths: 8/12/21/34/50/200
Show EMA lines: toggle plotted lines (clouds remain)
B) MTF Rails
Show MTF Rails
TF1/TF2/TF3 (defaults 30/60/240)
EMA A/B (defaults 34/50)
C) RVol Box
Show box
Format as K/M/B: K=1e3, M=1e6, B=1e9
D) DTR/ATR Box
Show DTR/ATR
ATR len: default 14 (daily)
E) Ripster Trend Labels
Show labels
Trend TF: default 10 (10-minute)
Trend EMA Fast/Slow: default 12/50
F) Air Gaps
Show Air Gap lines
TF1/TF2/TF3 (30/60/240)
EMA length: default 12
Draw from: All Bars | Start of Day | Bars Offset
Bars back: used if Draw from = Bars Offset
How it makes decisions
Cloud bias = sign of (faster EMA − slower EMA) for each cloud pair.
Example: 12>21 → fast cloud is bullish (green); 34>50 → mid cloud bullish (teal).
10m trend label = sign of (EMA12−EMA50) on the Trend TF (default 10m).
RVol = volume / sma(volume, 20); formatted as a percent and color-coded.
Practical read of the screen
Fast cloud flips (12/21) often mark short-term momentum changes; mid cloud flips (34/50) reflect swing bias.
Air Gap lines from higher TFs frequently act as support/resistance. Larger spaces between lines = “air gaps” where price can move with less friction.
RVol color tells you how “real” a move is: red/yellow often confirms momentum; blue warns of thin/liquidy bars.
DTR vs ATR shows if today’s range is stretched vs recent norm.
Design choices (why your prior errors are gone)
Removed multiline ?: chains → replaced by if/else (Pine v6 is picky about line continuations).
Moved fill() calls outside of local if blocks (Pine limitation).
ta.change(time("D")) != 0 makes the if condition boolean.
Declared G_drawFrom / G_barsBack before startX() so identifiers exist.
