Rozpocznij

Wskaźniki i strategie

Aura Squeeze Projections [Pineify]Pineify - Aura Squeeze Projections This indicator combines the volatility compression detection of the TTM Squeeze methodology with an innovative "aura glow" visualization, offering traders a clear and aesthetically distinct way to identify low-volatility consolidation phases and anticipate breakout directions. By merging Bollinger Bands, Keltner Channels, and linear regression momentum analysis, the Aura Squeeze Projections provides actionable squeeze signals with directional bias. Key Features Visual "aura glow" effect highlighting squeeze zones and momentum shifts Squeeze detection combining Bollinger Bands and Keltner Channels Linear regression-based momentum for directional bias Dynamic candle coloring reflecting current market state Squeeze start and release signal markers How It Works The core logic identifies volatility compression by comparing Bollinger Bands to Keltner Channels. When the Bollinger Bands contract inside the Keltner Channel boundaries (BB upper < KC upper AND BB lower > KC lower), the market enters a "squeeze" state — a period of low volatility that often precedes significant price movement. Momentum direction is calculated using a linear regression slope of the difference between price and its moving average. A positive slope indicates bullish momentum; negative indicates bearish momentum. This determines the anticipated breakout direction when the squeeze releases. How Multiple Indicators Work Together Bollinger Bands measure statistical volatility through standard deviation, expanding during high volatility and contracting during consolidation. Keltner Channels use Average True Range (ATR) for a smoother volatility envelope. When BB fits entirely within KC, volatility has compressed below normal levels — the squeeze condition. The linear regression momentum component adds directional intelligence. Rather than simply detecting compression, it forecasts the likely breakout direction by analyzing the trend slope of price deviation from its mean. This synergy transforms a binary squeeze signal into an actionable directional setup. Unique Aspects The "aura glow" visualization creates gradient fills between the trend midline and Keltner boundaries, providing an intuitive heat-map style view of market conditions. Colors transition dynamically: gray during squeeze (consolidation), green for bullish momentum, and red for bearish momentum. This makes market state immediately recognizable at a glance. How to Use Watch for the gray squeeze state indicating volatility compression Note the circle marker appearing above bars when squeeze begins Observe when the diamond marker appears below bars — squeeze release The color at release (green/red) indicates anticipated breakout direction Use candle coloring for confirmation of momentum alignment Customization Lookback Length : Adjusts sensitivity (shorter = more signals, longer = fewer but stronger) BB/KC Multipliers : Fine-tune squeeze detection threshold Use EMA : Toggle between EMA (smoother) or SMA for the midline basis Aura Transparency : Control visual intensity of the glow effect Conclusion Aura Squeeze Projections offers a refined approach to squeeze-based trading by combining proven volatility compression detection with momentum-based directional analysis and distinctive visual presentation. The indicator helps traders identify consolidation periods and prepare for breakouts with directional confidence. Best used alongside price action analysis and support/resistance levels for confirmation.
Wskaźnik Pine Script®
od Pineify
DLR - Daily Liquidity Range Framework (v1.3)Daily Level Ranges This strategy targets discounted premiums for buying Call/Put Options in discounted areas based on liquidity levels that form ranges. Opening Range creates the strongest liquidity for the day. Premarket Highs/Lows are strong liquidity points. Previous Day Highs/Lows are reliable liquidity points. PMH/PML and PDH/PDL may alternate positions relative to OR. * Discounted Calls are taken under the OR in Bullish conditions * Discounted Puts are taken above the OR in bearish conditions. - Momentum Calls are taken at the OR in Bullish Conditions - Momentum Puts are taken at the OR in Bearish Conditions
Wskaźnik Pine Script®
od dlrtrades
QUARTERS THEORY XAUUSDThe “Quarter Theory XAUUSD” indicator on TradingView is designed to automatically plot horizontal price levels in $25 increments on your chart, providing traders with a clear visual representation of key psychological and technical price points. These levels are particularly useful for instruments like XAU/USD, where price often reacts to round numbers, forming support and resistance zones that can be leveraged for both scalping and swing trading strategies. By showing all $25 increments as horizontal white lines, the indicator ensures that traders can quickly identify potential entry and exit points, without the need for manual drawing or repeated calculations. The indicator works by calculating the nearest $25 multiple relative to the current market price and then drawing horizontal lines across the chart for all increments within a defined range. This range can be customized to suit the instrument being traded; for example, for gold (XAU/USD), a typical range might extend from 0 to 5000, covering all practical price levels that could be relevant in both high and low market conditions. By using Pine Script’s persistent variables, the indicator efficiently creates these lines only once at the start of the chart, avoiding unnecessary resource usage and preventing TradingView from slowing down, which can happen if lines are redrawn every bar. From a trading perspective, these levels serve multiple purposes. For scalpers, the $25 increments act as micro support and resistance points, helping to determine short-term price reactions and potential breakout zones. Scalpers can use these levels to enter positions with tight stop-loss orders just beyond a level and take profits near the next $25 increment, which aligns with common price behavior patterns in highly liquid instruments. For swing traders, the same levels provide broader context, allowing them to identify areas where price might pause or reverse over several days. Swing traders can use these levels to align trades with the prevailing trend, particularly when combined with other indicators such as moving averages or trendlines. Another key advantage of the Quarterly Levels indicator is its simplicity and visual clarity. By plotting lines in a uniform white color and extending them to the right, the chart remains clean and easy to read, allowing traders to focus on price action and market dynamics rather than cluttered technical drawings. This visual consistency also helps in backtesting and strategy development, as traders can quickly see how price interacts with each level over time. Additionally, the use of round-number increments leverages the psychological tendencies of market participants, as many traders place stop orders or entry points near these levels, making them natural zones of interest. Overall, the Quarterly Levels indicator combines efficiency, clarity, and practical trading utility into a single tool. It streamlines chart analysis, highlights meaningful price zones, and supports both scalping and swing trading approaches, making it an essential addition to a trader’s toolkit. By understanding how to integrate these levels into trading strategies, traders can make more informed decisions, manage risk effectively, and identify high-probability trade setups across various market conditions.
Wskaźnik Pine Script®
od ElvinLing
TDStochastic - TOM GOOD CAR (Center)Indicator Overview TDStochastic - TGC_Stoch_Center is a streamlined momentum analysis tool designed for clarity and efficiency. By integrating Stochastic calculations with a centralized real-time Dashboard, it allows traders to instantly identify market trends and momentum strength directly on the chart. Key Features Visual Dashboard: Features a top-center table displaying Trend Status (UP/DOWN), Price Strength (POWERFUL/WEAK), and the current percentage value. Dynamic Bar Coloring: Automatically changes the candlestick colors based on Stochastic %D direction to filter out market noise. Enhanced Smoothing: Utilizes SMA smoothing for K and D lines to provide a more stable and reliable signal compared to standard stochastic oscillators. How to Use Trend Identification: Monitor the "STATUS" cell. If the momentum is rising, it displays "UPTREND." Strength Assessment: When momentum is positive and accelerating, the "POWERFUL" status confirms the prevailing trend's strength. Execution: Ideally used for trend following. Traders can remain in positions as long as the bar color and dashboard status remain consistent with the direction. Trading involves significant risk. This indicator is a technical analysis tool based on historical data and does not guarantee future profits. Always use proper risk management and do not rely solely on a single indicator for trading decisions.
Wskaźnik Pine Script®
od tomgoodcarkhonsan
TJR asia session sweep//@version=5 strategy("TJR asia session sweep", "TJR Asia Sweep", overlay=true, max_lines_count=500, max_labels_count=500) // Input settings show_asian = input.bool(true, "Show Asian Session", group="Visual Settings") show_london = input.bool(true, "Show London Session", group="Visual Settings") show_swing_points = input.bool(true, "Show Asian Swing Points", group="Visual Settings") show_market_structure = input.bool(true, "Show Market Structure", group="Visual Settings") show_bos = input.bool(true, "Show Break of Structure", group="Visual Settings") // Session Time Settings asian_start_hour_input = input.int(22, "Asian Session Start Hour", minval=0, maxval=23, group="Session Times") asian_end_hour_input = input.int(3, "Asian Session End Hour", minval=0, maxval=23, group="Session Times") london_start_hour_input = input.int(3, "London Session Start Hour", minval=0, maxval=23, group="Session Times") london_end_hour_input = input.int(8, "London Session End Hour", minval=0, maxval=23, group="Session Times") session_timezone = input.string("America/New_York", "Session Timezone", options= , group="Session Times") // Risk Management Settings use_atr_sl = input.bool(false, "Use ATR Multiplier for Stop Loss", group="Risk Management") atr_length = input.int(14, "ATR Length", minval=1, maxval=50, group="Risk Management") atr_multiplier = input.float(2.0, "ATR Multiplier for Stop Loss", minval=0.5, maxval=10.0, group="Risk Management") force_london_close = input.bool(true, "Force Close at London Session End", group="Risk Management") cutoff_minutes = input.int(60, "Minutes Before Session End to Stop New Trades", minval=0, maxval=300, group="Risk Management") // Position Sizing Settings position_sizing_method = input.string("USD Risk", "Position Sizing Method", options= , group="Position Sizing") usd_risk_per_trade = input.float(100.0, "USD Risk Per Trade", minval=1.0, maxval=10000.0, group="Position Sizing") fixed_contracts = input.float(1.0, "Fixed Number of Contracts", minval=0.01, maxval=1000.0, step=0.01, group="Position Sizing") // Color settings asian_color = input.color(color.red, "Asian Session Color") london_color = input.color(color.blue, "London Session Color") swing_high_color = input.color(color.orange, "Swing High Color") swing_low_color = input.color(color.lime, "Swing Low Color") bullish_structure_color = input.color(color.green, "Bullish Structure Color") bearish_structure_color = input.color(color.red, "Bearish Structure Color") bos_color = input.color(color.orange, "Break of Structure Color") // Line settings line_width = input.int(2, "Line Width", minval=1, maxval=5) // ATR calculation for stop loss atr = ta.atr(atr_length) // Position size calculation function calculate_position_size(entry_price, stop_loss_price) => var float position_size = na if position_sizing_method == "Fixed Contracts" position_size := fixed_contracts else // USD Risk method stop_distance = math.abs(entry_price - stop_loss_price) if stop_distance > 0 // Calculate position size based on USD risk per trade // For forex: position_size = risk_amount / (stop_distance * point_value) // For most forex pairs, point value = 1 (since we're dealing with price differences directly) position_size := usd_risk_per_trade / stop_distance else position_size := fixed_contracts // Fallback to fixed contracts if stop distance is 0 position_size // Session time definitions (using input variables) asian_start_hour = asian_start_hour_input asian_end_hour = asian_end_hour_input london_start_hour = london_start_hour_input london_end_hour = london_end_hour_input // Get current hour using selected timezone current_hour = hour(time, session_timezone) // Previous hour for transition detection prev_hour = hour(time , session_timezone) // Session transition detection asian_start = current_hour == asian_start_hour and prev_hour != asian_start_hour asian_end = current_hour == asian_end_hour and prev_hour != asian_end_hour london_start = current_hour == london_start_hour and prev_hour != london_start_hour london_end = current_hour == london_end_hour and prev_hour != london_end_hour // Session activity detection asian_active = (current_hour >= asian_start_hour) or (current_hour < asian_end_hour) london_active = (current_hour >= london_start_hour) and (current_hour < london_end_hour) // Session boxes - keep previous sessions visible var box asian_session_box = na var box london_session_box = na // Create Asian session box if show_asian and asian_start // Create new box at session start (previous box remains visible) asian_session_box := box.new(bar_index, high, bar_index + 1, low, border_color=asian_color, bgcolor=color.new(asian_color, 90), border_width=2, border_style=line.style_solid) // Pre-calculate session highs and lows for consistency asian_session_length = asian_active and not na(asian_session_box) ? bar_index - box.get_left(asian_session_box) + 1 : 1 current_asian_high = ta.highest(high, asian_session_length) current_asian_low = ta.lowest(low, asian_session_length) // Update Asian session box continuously during session if show_asian and asian_active and not na(asian_session_box) box.set_right(asian_session_box, bar_index) // Update box to contain session highs and lows box.set_top(asian_session_box, current_asian_high) box.set_bottom(asian_session_box, current_asian_low) // Create London session box if show_london and london_start // Create new box at session start (previous box remains visible) london_session_box := box.new(bar_index, high, bar_index + 1, low, border_color=london_color, bgcolor=color.new(london_color, 90), border_width=2, border_style=line.style_solid) // Pre-calculate London session highs and lows for consistency london_session_length = london_active and not na(london_session_box) ? bar_index - box.get_left(london_session_box) + 1 : 1 current_london_high = ta.highest(high, london_session_length) current_london_low = ta.lowest(low, london_session_length) // Update London session box continuously during session if show_london and london_active and not na(london_session_box) box.set_right(london_session_box, bar_index) // Update box to contain session highs and lows box.set_top(london_session_box, current_london_high) box.set_bottom(london_session_box, current_london_low) // Asian Session Swing Points Detection var float asian_session_high = na var float asian_session_low = na var int asian_high_bar = na var int asian_low_bar = na // Asian Session Absolute High/Low for TP levels var float asian_absolute_high = na var float asian_absolute_low = na var line asian_high_line = na var line asian_low_line = na var label asian_high_label = na var label asian_low_label = na var bool high_broken = false var bool low_broken = false // London Session High/Low tracking for stop loss var float london_session_high = na var float london_session_low = na // Market structure tracking variables var string breakout_direction = na // "bullish" or "bearish" var float last_hh_level = na // Last Higher High level var float last_hl_level = na // Last Higher Low level var float last_ll_level = na // Last Lower Low level var float last_lh_level = na // Last Lower High level var int structure_count = 0 var string last_structure_type = na // "HH", "HL", "LL", "LH" // Legacy variables for compatibility var float last_swing_high = na var float last_swing_low = na var int last_high_bar = na var int last_low_bar = na // Market structure state tracking var float pending_high = na var float pending_low = na var int pending_high_bar = na var int pending_low_bar = na var bool waiting_for_confirmation = false // Break of Structure tracking variables var float most_recent_hl = na var float most_recent_lh = na var int most_recent_hl_bar = na var int most_recent_lh_bar = na var bool bos_detected = false // Trading variables var bool trade_taken = false // Trade visualization boxes (based on Casper strategy approach) var box current_profit_box = na var box current_sl_box = na // Update swing points during Asian session if asian_active and show_swing_points // Always track absolute high/low for both TP levels and breakout detection if na(asian_absolute_high) or high > asian_absolute_high asian_absolute_high := high if na(asian_absolute_low) or low < asian_absolute_low asian_absolute_low := low // Use absolute high/low for breakout levels (simplified logic) if na(asian_session_high) or high > asian_session_high asian_session_high := high asian_high_bar := bar_index if na(asian_session_low) or low < asian_session_low asian_session_low := low asian_low_bar := bar_index // Track London session high/low for stop loss levels if london_active if na(london_session_high) or high > london_session_high london_session_high := high if na(london_session_low) or low < london_session_low london_session_low := low // Draw initial lines when Asian session ends if asian_end and show_swing_points if not na(asian_session_high) and not na(asian_high_bar) // Draw extending line for high asian_high_line := line.new(asian_high_bar, asian_session_high, bar_index + 200, asian_session_high, color=swing_high_color, width=2, style=line.style_dashed, extend=extend.right) asian_high_label := label.new(bar_index + 5, asian_session_high, "Asian High: " + str.tostring(asian_session_high, "#.####"), style=label.style_label_left, color=swing_high_color, textcolor=color.white, size=size.small) if not na(asian_session_low) and not na(asian_low_bar) // Draw extending line for low asian_low_line := line.new(asian_low_bar, asian_session_low, bar_index + 200, asian_session_low, color=swing_low_color, width=2, style=line.style_dashed, extend=extend.right) asian_low_label := label.new(bar_index + 5, asian_session_low, "Asian Low: " + str.tostring(asian_session_low, "#.####"), style=label.style_label_left, color=swing_low_color, textcolor=color.white, size=size.small) // Reset break flags for new session high_broken := false low_broken := false // Check for breakouts during London session if london_active and show_swing_points and not na(asian_session_high) and not na(asian_session_low) // Check if Asian high is broken if not high_broken and not low_broken and high > asian_session_high high_broken := true // Update high line to end at break point if not na(asian_high_line) line.set_x2(asian_high_line, bar_index) line.set_extend(asian_high_line, extend.none) // Remove the low line (first break wins) if not na(asian_low_line) line.delete(asian_low_line) if not na(asian_low_label) label.delete(asian_low_label) // Add break marker label.new(bar_index, asian_session_high * 1.001, "HIGH BREAK!", style=label.style_label_down, color=color.red, textcolor=color.white, size=size.normal) // Set breakout direction and initialize structure tracking breakout_direction := "bullish" last_swing_high := asian_session_high last_swing_low := asian_session_low last_high_bar := bar_index structure_count := 0 // Check if Asian low is broken if not low_broken and not high_broken and low < asian_session_low low_broken := true // Update low line to end at break point if not na(asian_low_line) line.set_x2(asian_low_line, bar_index) line.set_extend(asian_low_line, extend.none) // Remove the high line (first break wins) if not na(asian_high_line) line.delete(asian_high_line) if not na(asian_high_label) label.delete(asian_high_label) // Add break marker label.new(bar_index, asian_session_low * 0.999, "LOW BREAK!", style=label.style_label_up, color=color.red, textcolor=color.white, size=size.normal) // Set breakout direction and initialize structure tracking breakout_direction := "bearish" last_swing_high := asian_session_high last_swing_low := asian_session_low last_low_bar := bar_index structure_count := 0 // Stop extending lines when London session ends (if not already broken) if london_end and show_swing_points if not high_broken and not na(asian_high_line) line.set_x2(asian_high_line, bar_index) line.set_extend(asian_high_line, extend.none) if not low_broken and not na(asian_low_line) line.set_x2(asian_low_line, bar_index) line.set_extend(asian_low_line, extend.none) // Force close all trades at London session end (if enabled) if london_end and force_london_close if strategy.position_size != 0 // Extend boxes immediately before session close to prevent timing issues if not na(current_profit_box) // Ensure minimum 8 bars width or extend to current bar, whichever is longer box_left = box.get_left(current_profit_box) min_right = box_left + 8 final_right = math.max(min_right, bar_index) box.set_right(current_profit_box, final_right) current_profit_box := na // Clear reference after extending if not na(current_sl_box) // Ensure minimum 8 bars width or extend to current bar, whichever is longer box_left = box.get_left(current_sl_box) min_right = box_left + 8 final_right = math.max(min_right, bar_index) box.set_right(current_sl_box, final_right) current_sl_box := na // Clear reference after extending strategy.close_all(comment="London Close") trade_taken := false // Reset trade flag for next session // Market structure detection after breakout (only during London session and before first BoS) if show_market_structure and not na(breakout_direction) and london_active and not bos_detected // Bullish structure tracking (HH, HL alternating) if breakout_direction == "bullish" // Check for Higher High pattern: Bullish candle followed by bearish candle pattern_high = math.max(high , high) prev_hh = na(last_hh_level) ? last_swing_high : last_hh_level // HH Detection: Only if we expect HH next (no last structure or last was HL) if (na(last_structure_type) or last_structure_type == "HL") and close > open and close < open and pattern_high > prev_hh and close > prev_hh // Check consolidation is_too_close = not na(last_high_bar) and (bar_index - last_high_bar) <= 4 should_create_hh = true if is_too_close and structure_count > 0 and pattern_high <= last_hh_level should_create_hh := false if should_create_hh structure_count := structure_count + 1 label.new(bar_index - 1, high + (high * 0.0003), "HH" + str.tostring(structure_count), style=label.style_none, color=color.new(color.white, 100), textcolor=color.white, size=size.small) last_hh_level := pattern_high last_swing_high := pattern_high last_high_bar := bar_index last_structure_type := "HH" // HL Detection: Only if we expect HL next (last was HH) pattern_low = math.min(low , low) prev_hl = na(last_hl_level) ? last_swing_low : last_hl_level if last_structure_type == "HH" and close < open and close > open and pattern_low > prev_hl and close > prev_hl // Check consolidation is_too_close = not na(last_low_bar) and (bar_index - last_low_bar) <= 4 should_create_hl = true if is_too_close and pattern_low <= last_hl_level should_create_hl := false if should_create_hl structure_count := structure_count + 1 label.new(bar_index - 1, low - (low * 0.0003), "HL" + str.tostring(structure_count), style=label.style_none, color=color.new(color.white, 100), textcolor=color.white, size=size.small) last_hl_level := pattern_low most_recent_hl := pattern_low // Update most recent HL for BoS detection most_recent_hl_bar := bar_index - 1 // Store HL bar position last_low_bar := bar_index last_structure_type := "HL" // Bearish structure tracking (LL, LH alternating) if breakout_direction == "bearish" // Check for Lower Low pattern: Bearish candle followed by bullish candle pattern_low = math.min(low , low) prev_ll = na(last_ll_level) ? last_swing_low : last_ll_level // LL Detection: Only if we expect LL next (no last structure or last was LH) if (na(last_structure_type) or last_structure_type == "LH") and close < open and close > open and pattern_low < prev_ll and close < prev_ll // Check consolidation is_too_close = not na(last_low_bar) and (bar_index - last_low_bar) <= 4 should_create_ll = true if is_too_close and structure_count > 0 and pattern_low >= last_ll_level should_create_ll := false if should_create_ll structure_count := structure_count + 1 label.new(bar_index - 1, low - (low * 0.0003), "LL" + str.tostring(structure_count), style=label.style_none, color=color.new(color.white, 100), textcolor=color.white, size=size.small) last_ll_level := pattern_low last_swing_low := pattern_low last_low_bar := bar_index last_structure_type := "LL" // LH Detection: Only if we expect LH next (last was LL) pattern_high = math.max(high , high) prev_lh = na(last_lh_level) ? last_swing_high : last_lh_level if last_structure_type == "LL" and close > open and close < open and pattern_high < prev_lh and close < prev_lh // Check consolidation is_too_close = not na(last_high_bar) and (bar_index - last_high_bar) <= 4 should_create_lh = true if is_too_close and pattern_high >= last_lh_level should_create_lh := false if should_create_lh structure_count := structure_count + 1 label.new(bar_index - 1, high + (high * 0.0003), "LH" + str.tostring(structure_count), style=label.style_none, color=color.new(color.white, 100), textcolor=color.white, size=size.small) last_lh_level := pattern_high most_recent_lh := pattern_high // Update most recent LH for BoS detection most_recent_lh_bar := bar_index - 1 // Store LH bar position last_high_bar := bar_index last_structure_type := "LH" // Check if we're within the cutoff period before London session end current_minute = minute(time, session_timezone) london_end_time_minutes = london_end_hour * 60 // Convert London end hour to minutes current_time_minutes = current_hour * 60 + current_minute // Current time in minutes // Calculate minutes remaining in London session london_session_minutes_remaining = london_end_time_minutes - current_time_minutes // Handle day rollover case (e.g., if london_end is 8:00 (480 min) and current is 23:30 (1410 min)) if london_session_minutes_remaining < 0 london_session_minutes_remaining := london_session_minutes_remaining + (24 * 60) // Add 24 hours in minutes // Only allow trades if more than cutoff_minutes remaining in London session allow_new_trades = london_session_minutes_remaining > cutoff_minutes // Break of Structure (BoS) Detection and Trading Logic - Only first BoS per London session and outside cutoff period if show_bos and london_active and show_market_structure and not bos_detected and not trade_taken and allow_new_trades // Bullish BoS: Price closes below the most recent HL (after bullish breakout) - SELL SIGNAL if breakout_direction == "bullish" and not na(most_recent_hl) and not na(most_recent_hl_bar) // Check minimum distance requirement (at least 4 candles between BoS and HL) if close < most_recent_hl and (bar_index - most_recent_hl_bar) >= 4 // Draw dotted line from HL position to BoS point line.new(most_recent_hl_bar, most_recent_hl, bar_index, most_recent_hl, color=bos_color, width=2, style=line.style_dotted, extend=extend.none) // Calculate center position for BoS label center_bar = math.round((most_recent_hl_bar + bar_index) / 2) // Draw BoS label below the line for HL break label.new(center_bar, most_recent_hl - (most_recent_hl * 0.0005), "BoS", style=label.style_none, color=color.new(color.white, 100), textcolor=bos_color, size=size.normal) // SELL ENTRY if not na(london_session_high) and not na(asian_absolute_low) // Calculate stop loss based on settings stop_loss_level = use_atr_sl ? close + (atr * atr_multiplier) : london_session_high take_profit_level = asian_absolute_low entry_price = close // Calculate position size based on user settings position_size = calculate_position_size(entry_price, stop_loss_level) strategy.entry("SELL", strategy.short, qty=position_size, comment="BoS Sell") strategy.exit("SELL EXIT", "SELL", stop=stop_loss_level, limit=take_profit_level, comment="SL/TP") // Create trade visualization boxes (TradingView style) - minimum 8 bars width // Blue profit zone box (from entry to take profit) current_profit_box := box.new(left=bar_index, top=take_profit_level, right=bar_index + 8, bottom=entry_price, bgcolor=color.new(color.blue, 70), border_width=0) // Red stop loss zone box (from entry to stop loss) current_sl_box := box.new(left=bar_index, top=entry_price, right=bar_index + 8, bottom=stop_loss_level, bgcolor=color.new(color.red, 70), border_width=0) trade_taken := true bos_detected := true // Mark BoS as detected for this session // Bearish BoS: Price closes above the most recent LH (after bearish breakout) - BUY SIGNAL if breakout_direction == "bearish" and not na(most_recent_lh) and not na(most_recent_lh_bar) // Check minimum distance requirement (at least 4 candles between BoS and LH) if close > most_recent_lh and (bar_index - most_recent_lh_bar) >= 4 // Draw dotted line from LH position to BoS point line.new(most_recent_lh_bar, most_recent_lh, bar_index, most_recent_lh, color=bos_color, width=1, style=line.style_dotted, extend=extend.none) // Calculate center position for BoS label center_bar = math.round((most_recent_lh_bar + bar_index) / 2) // Draw BoS label above the line for LH break label.new(center_bar, most_recent_lh + (most_recent_lh * 0.0005), "BoS", style=label.style_none, color=color.new(color.white, 100), textcolor=bos_color, size=size.normal) // BUY ENTRY if not na(london_session_low) and not na(asian_absolute_high) // Calculate stop loss based on settings stop_loss_level = use_atr_sl ? close - (atr * atr_multiplier) : london_session_low take_profit_level = asian_absolute_high entry_price = close // Calculate position size based on user settings position_size = calculate_position_size(entry_price, stop_loss_level) strategy.entry("BUY", strategy.long, qty=position_size, comment="BoS Buy") strategy.exit("BUY EXIT", "BUY", stop=stop_loss_level, limit=take_profit_level, comment="SL/TP") // Create trade visualization boxes (TradingView style) - minimum 8 bars width // Blue profit zone box (from entry to take profit) current_profit_box := box.new(left=bar_index, top=entry_price, right=bar_index + 8, bottom=take_profit_level, bgcolor=color.new(color.blue, 70), border_width=0) // Red stop loss zone box (from entry to stop loss) current_sl_box := box.new(left=bar_index, top=stop_loss_level, right=bar_index + 8, bottom=entry_price, bgcolor=color.new(color.red, 70), border_width=0) trade_taken := true bos_detected := true // Mark BoS as detected for this session // Position close detection for extending boxes (based on Casper strategy) if barstate.isconfirmed and strategy.position_size == 0 and strategy.position_size != 0 // Extend trade visualization boxes to exact exit point when position closes if not na(current_profit_box) // Ensure minimum 8 bars width or extend to current bar, whichever is longer box_left = box.get_left(current_profit_box) min_right = box_left + 8 final_right = math.max(min_right, bar_index) box.set_right(current_profit_box, final_right) current_profit_box := na // Clear reference after extending if not na(current_sl_box) // Ensure minimum 8 bars width or extend to current bar, whichever is longer box_left = box.get_left(current_sl_box) min_right = box_left + 8 final_right = math.max(min_right, bar_index) box.set_right(current_sl_box, final_right) current_sl_box := na // Clear reference after extending // Backup safety check - extend boxes if position is closed but boxes still active if not na(current_profit_box) and strategy.position_size == 0 box_left = box.get_left(current_profit_box) min_right = box_left + 8 final_right = math.max(min_right, bar_index) box.set_right(current_profit_box, final_right) current_profit_box := na if not na(current_sl_box) and strategy.position_size == 0 box_left = box.get_left(current_sl_box) min_right = box_left + 8 final_right = math.max(min_right, bar_index) box.set_right(current_sl_box, final_right) current_sl_box := na // Reset everything when new Asian session starts if asian_start and show_swing_points asian_session_high := na asian_session_low := na asian_high_bar := na asian_low_bar := na // Reset absolute levels asian_absolute_high := na asian_absolute_low := na asian_high_line := na asian_low_line := na asian_high_label := na asian_low_label := na high_broken := false low_broken := false // Reset London session levels london_session_high := na london_session_low := na // Reset market structure tracking breakout_direction := na last_hh_level := na last_hl_level := na last_ll_level := na last_lh_level := na last_swing_high := na last_swing_low := na last_high_bar := na last_low_bar := na structure_count := 0 last_structure_type := na pending_high := na pending_low := na pending_high_bar := na pending_low_bar := na waiting_for_confirmation := false // Reset BoS tracking most_recent_hl := na most_recent_lh := na most_recent_hl_bar := na most_recent_lh_bar := na bos_detected := false // Reset trading trade_taken := false // Reset current trade boxes current_profit_box := na current_sl_box := na // Debug info (optional) show_debug = input.bool(false, "Show Debug Info") if show_debug var table debug_table = table.new(position.top_right, 2, 3, bgcolor=color.white, border_width=1) if barstate.islast table.cell(debug_table, 0, 0, "Current Hour:", text_color=color.black) table.cell(debug_table, 1, 0, str.tostring(current_hour), text_color=color.black) table.cell(debug_table, 0, 1, "Asian Active:", text_color=color.black) table.cell(debug_table, 1, 1, str.tostring((current_hour >= asian_start_hour) or (current_hour < asian_end_hour)), text_color=color.black) table.cell(debug_table, 0, 2, "London Active:", text_color=color.black) table.cell(debug_table, 1, 2, str.tostring((current_hour >= london_start_hour) and (current_hour < london_end_hour)), text_color=color.black)
Strategia Pine Script®
od Elliodoh
Entry ChecklistEntry Checklist A comprehensive multi-factor analysis tool for stock and crypto entry decisions, combining fundamental, technical, and market sentiment indicators in a dynamic table display. 🎯 Overview This advanced Pine Script indicator provides traders and investors with a systematic checklist for evaluating potential entry points. It consolidates critical market data into a clean, color-coded table that adapts based on asset type and data availability. 📊 Key Features Market Context Analysis: Seasonality: Historical S&P 500 monthly return patterns with strength/weakness labels Market Breadth (S5TH): Percentage of S&P 500 stocks above their 50-day moving average Fear/Greed Index (VIX): Market sentiment indicator with threshold-based color coding Fundamental Analysis (Stocks Only): Earnings Dates: Upcoming earnings announcement tracking with 14-day warning Growth Metrics: Year-over-year sales and EPS growth rates Acceleration: Quarter-over-quarter growth acceleration analysis Sector & Industry Analysis: Sector Relative Strength: 20-day performance vs SPY benchmark Industry Relative Strength: Granular industry ETF performance comparison 120+ Industry ETF Mappings: Comprehensive sector and industry classifications Technical Analysis: IBD-Style RS Rating: Multi-timeframe relative strength scoring (1-99 scale) RS vs SPX: Stock performance relative to S&P 500 RS vs Sector: Performance relative to sector ETF RS vs Industry: Performance relative to industry ETF 🎨 Visual Design Dynamic Table: Bottom-right overlay with professional dark theme Color-Coded Signals: Green (bullish), red (bearish), neutral (white)
Wskaźnik Pine Script®
od billchanHK
SVE Pivot Points v5//@version=6 indicator(title="SVE Pivot Points", overlay=true, max_lines_count=500) // Input Parameters agg_period = input.timeframe("D", title="Aggregation period") show_labels = input.bool(true, title="Show Labels") line_width = input.int(1, title="Line Width", minval=1, maxval=4) // Detect new aggregation period bool new_agg_bar = bool(ta.change(time(agg_period))) // Calculate how many chart bars fit in one aggregation period get_bars_in_period(string tf) => tf_secs = timeframe.in_seconds(tf) chart_secs = timeframe.in_seconds(timeframe.period) // If aggregation period is smaller than or equal to chart timeframe, use 1 bar // Otherwise calculate how many chart bars fit math.max(1, int(math.ceil(tf_secs / chart_secs))) bars_in_period = get_bars_in_period(agg_period) // Fetch previous period's high, low, close ph = request.security(syminfo.tickerid, agg_period, high , barmerge.gaps_off, barmerge.lookahead_on) pl = request.security(syminfo.tickerid, agg_period, low , barmerge.gaps_off, barmerge.lookahead_on) pc = request.security(syminfo.tickerid, agg_period, close , barmerge.gaps_off, barmerge.lookahead_on) // Calculate pivot points pp = (ph + pl + pc) / 3 r1 = 2 * pp - pl r2 = pp + (ph - pl) r3 = 2 * pp + (ph - 2 * pl) s1 = 2 * pp - ph s2 = pp - (ph - pl) s3 = 2 * pp - (2 * ph - pl) // Calculate mean levels r1m = (pp + r1) / 2 r2m = (r1 + r2) / 2 r3m = (r2 + r3) / 2 s1m = (pp + s1) / 2 s2m = (s1 + s2) / 2 s3m = (s2 + s3) / 2 // Previous high and low hh = ph ll = pl // Colors color_r = color.red color_s = color.green color_pp = color.blue color_hl = color.gray // Arrays to store historical lines (for showing past periods) var line lines_r3 = array.new_line() var line lines_r3m = array.new_line() var line lines_r2 = array.new_line() var line lines_r2m = array.new_line() var line lines_r1 = array.new_line() var line lines_r1m = array.new_line() var line lines_hh = array.new_line() var line lines_pp = array.new_line() var line lines_ll = array.new_line() var line lines_s1m = array.new_line() var line lines_s1 = array.new_line() var line lines_s2m = array.new_line() var line lines_s2 = array.new_line() var line lines_s3m = array.new_line() var line lines_s3 = array.new_line() // Current period labels (only show for current period) var label lbl_r3 = na var label lbl_r3m = na var label lbl_r2 = na var label lbl_r2m = na var label lbl_r1 = na var label lbl_r1m = na var label lbl_hh = na var label lbl_pp = na var label lbl_ll = na var label lbl_s1m = na var label lbl_s1 = na var label lbl_s2m = na var label lbl_s2 = na var label lbl_s3m = na var label lbl_s3 = na // Track current period start var int current_period_start = 0 // On new aggregation period, create new lines if new_agg_bar current_period_start := bar_index // Create lines for this period - they start here and will be extended array.push(lines_r3, line.new(bar_index, r3, bar_index + bars_in_period, r3, color=color_r, width=line_width)) array.push(lines_r3m, line.new(bar_index, r3m, bar_index + bars_in_period, r3m, color=color_r, width=line_width)) array.push(lines_r2, line.new(bar_index, r2, bar_index + bars_in_period, r2, color=color_r, width=line_width)) array.push(lines_r2m, line.new(bar_index, r2m, bar_index + bars_in_period, r2m, color=color_r, width=line_width)) array.push(lines_r1, line.new(bar_index, r1, bar_index + bars_in_period, r1, color=color_r, width=line_width)) array.push(lines_r1m, line.new(bar_index, r1m, bar_index + bars_in_period, r1m, color=color_r, width=line_width)) array.push(lines_hh, line.new(bar_index, hh, bar_index + bars_in_period, hh, color=color_hl, width=line_width)) array.push(lines_pp, line.new(bar_index, pp, bar_index + bars_in_period, pp, color=color_pp, width=line_width)) array.push(lines_ll, line.new(bar_index, ll, bar_index + bars_in_period, ll, color=color_hl, width=line_width)) array.push(lines_s1m, line.new(bar_index, s1m, bar_index + bars_in_period, s1m, color=color_s, width=line_width)) array.push(lines_s1, line.new(bar_index, s1, bar_index + bars_in_period, s1, color=color_s, width=line_width)) array.push(lines_s2m, line.new(bar_index, s2m, bar_index + bars_in_period, s2m, color=color_s, width=line_width)) array.push(lines_s2, line.new(bar_index, s2, bar_index + bars_in_period, s2, color=color_s, width=line_width)) array.push(lines_s3m, line.new(bar_index, s3m, bar_index + bars_in_period, s3m, color=color_s, width=line_width)) array.push(lines_s3, line.new(bar_index, s3, bar_index + bars_in_period, s3, color=color_s, width=line_width)) // Delete old labels and create new ones if show_labels label.delete(lbl_r3) label.delete(lbl_r3m) label.delete(lbl_r2) label.delete(lbl_r2m) label.delete(lbl_r1) label.delete(lbl_r1m) label.delete(lbl_hh) label.delete(lbl_pp) label.delete(lbl_ll) label.delete(lbl_s1m) label.delete(lbl_s1) label.delete(lbl_s2m) label.delete(lbl_s2) label.delete(lbl_s3m) label.delete(lbl_s3) lbl_r3 := label.new(bar_index + bars_in_period, r3, "R3", style=label.style_label_left, color=color.new(color_r, 100), textcolor=color_r, size=size.small) lbl_r3m := label.new(bar_index + bars_in_period, r3m, "R3M", style=label.style_label_left, color=color.new(color_r, 100), textcolor=color_r, size=size.small) lbl_r2 := label.new(bar_index + bars_in_period, r2, "R2", style=label.style_label_left, color=color.new(color_r, 100), textcolor=color_r, size=size.small) lbl_r2m := label.new(bar_index + bars_in_period, r2m, "R2M", style=label.style_label_left, color=color.new(color_r, 100), textcolor=color_r, size=size.small) lbl_r1 := label.new(bar_index + bars_in_period, r1, "R1", style=label.style_label_left, color=color.new(color_r, 100), textcolor=color_r, size=size.small) lbl_r1m := label.new(bar_index + bars_in_period, r1m, "R1M", style=label.style_label_left, color=color.new(color_r, 100), textcolor=color_r, size=size.small) lbl_hh := label.new(bar_index + bars_in_period, hh, "HH", style=label.style_label_left, color=color.new(color_hl, 100), textcolor=color_hl, size=size.small) lbl_pp := label.new(bar_index + bars_in_period, pp, "PP", style=label.style_label_left, color=color.new(color_pp, 100), textcolor=color_pp, size=size.small) lbl_ll := label.new(bar_index + bars_in_period, ll, "LL", style=label.style_label_left, color=color.new(color_hl, 100), textcolor=color_hl, size=size.small) lbl_s1m := label.new(bar_index + bars_in_period, s1m, "S1M", style=label.style_label_left, color=color.new(color_s, 100), textcolor=color_s, size=size.small) lbl_s1 := label.new(bar_index + bars_in_period, s1, "S1", style=label.style_label_left, color=color.new(color_s, 100), textcolor=color_s, size=size.small) lbl_s2m := label.new(bar_index + bars_in_period, s2m, "S2M", style=label.style_label_left, color=color.new(color_s, 100), textcolor=color_s, size=size.small) lbl_s2 := label.new(bar_index + bars_in_period, s2, "S2", style=label.style_label_left, color=color.new(color_s, 100), textcolor=color_s, size=size.small) lbl_s3m := label.new(bar_index + bars_in_period, s3m, "S3M", style=label.style_label_left, color=color.new(color_s, 100), textcolor=color_s, size=size.small) lbl_s3 := label.new(bar_index + bars_in_period, s3, "S3", style=label.style_label_left, color=color.new(color_s, 100), textcolor=color_s, size=size.small) // On the last bar, update the current period's lines to extend properly into the future if barstate.islast and array.size(lines_pp) > 0 // Get the most recent lines line last_r3 = array.get(lines_r3, array.size(lines_r3) - 1) line last_r3m = array.get(lines_r3m, array.size(lines_r3m) - 1) line last_r2 = array.get(lines_r2, array.size(lines_r2) - 1) line last_r2m = array.get(lines_r2m, array.size(lines_r2m) - 1) line last_r1 = array.get(lines_r1, array.size(lines_r1) - 1) line last_r1m = array.get(lines_r1m, array.size(lines_r1m) - 1) line last_hh = array.get(lines_hh, array.size(lines_hh) - 1) line last_pp = array.get(lines_pp, array.size(lines_pp) - 1) line last_ll = array.get(lines_ll, array.size(lines_ll) - 1) line last_s1m = array.get(lines_s1m, array.size(lines_s1m) - 1) line last_s1 = array.get(lines_s1, array.size(lines_s1) - 1) line last_s2m = array.get(lines_s2m, array.size(lines_s2m) - 1) line last_s2 = array.get(lines_s2, array.size(lines_s2) - 1) line last_s3m = array.get(lines_s3m, array.size(lines_s3m) - 1) line last_s3 = array.get(lines_s3, array.size(lines_s3) - 1) // Calculate end point: period start + bars in period int end_bar = current_period_start + bars_in_period // Update line endpoints line.set_x2(last_r3, end_bar) line.set_x2(last_r3m, end_bar) line.set_x2(last_r2, end_bar) line.set_x2(last_r2m, end_bar) line.set_x2(last_r1, end_bar) line.set_x2(last_r1m, end_bar) line.set_x2(last_hh, end_bar) line.set_x2(last_pp, end_bar) line.set_x2(last_ll, end_bar) line.set_x2(last_s1m, end_bar) line.set_x2(last_s1, end_bar) line.set_x2(last_s2m, end_bar) line.set_x2(last_s2, end_bar) line.set_x2(last_s3m, end_bar) line.set_x2(last_s3, end_bar) // Update label positions if show_labels label.set_x(lbl_r3, end_bar) label.set_x(lbl_r3m, end_bar) label.set_x(lbl_r2, end_bar) label.set_x(lbl_r2m, end_bar) label.set_x(lbl_r1, end_bar) label.set_x(lbl_r1m, end_bar) label.set_x(lbl_hh, end_bar) label.set_x(lbl_pp, end_bar) label.set_x(lbl_ll, end_bar) label.set_x(lbl_s1m, end_bar) label.set_x(lbl_s1, end_bar) label.set_x(lbl_s2m, end_bar) label.set_x(lbl_s2, end_bar) label.set_x(lbl_s3m, end_bar) label.set_x(lbl_s3, end_bar) // Limit array sizes to prevent memory issues (keep last 100 periods) max_lines = 100 if array.size(lines_pp) > max_lines line.delete(array.shift(lines_r3)) line.delete(array.shift(lines_r3m)) line.delete(array.shift(lines_r2)) line.delete(array.shift(lines_r2m)) line.delete(array.shift(lines_r1)) line.delete(array.shift(lines_r1m)) line.delete(array.shift(lines_hh)) line.delete(array.shift(lines_pp)) line.delete(array.shift(lines_ll)) line.delete(array.shift(lines_s1m)) line.delete(array.shift(lines_s1)) line.delete(array.shift(lines_s2m)) line.delete(array.shift(lines_s2)) line.delete(array.shift(lines_s3m)) line.delete(array.shift(lines_s3))
Wskaźnik Pine Script®
od thexfounder
Multi TF Volume ATRThis indicator measures volatility using ATR applied to volume across multiple timeframes. It helps identify when real momentum enters the market by showing volume spikes on 1h, 4h, 12h, and Daily charts. When several timeframes spike at the same time, it often signals strong moves, breakouts, or major shifts in volatility. The script calculates Volume ATR for 1h, 4h, 12h, and 1D. Each timeframe generates its own spike condition. The indicator then checks for alignment between timeframes. The 1h histogram changes color based on the strength of the signal. Red means multi timeframe alignment. This is the strongest signal and shows that several timeframes are spiking together. Yellow means a 1h spike only. This is an early warning of local volatility. Blue means no spike. The indicator also plots higher timeframe ATR lines for context. These include 4h ATR, 12h ATR, and 1D ATR. When these lines rise together, volatility is building. Spike markers appear at the top of the pane when higher timeframes trigger. You can choose how strict the alignment should be. Options include all three timeframes (1h, 4h, 12h), at least two timeframes, or including the daily timeframe for even stronger confirmation. The script includes alert conditions for 1h spikes, multi timeframe alignment spikes, and daily spikes. These alerts help you stay ahead of volatility without watching charts constantly. This indicator is useful for many trading styles. Breakout traders use red bars to confirm momentum. Mean reversion traders use daily spikes to confirm volatility conditions. Trend traders watch rising 4h and 12h ATR lines. Scalpers use yellow bars as early warnings. Volume ATR shows how quickly volume is expanding. When several timeframes spike together, it often signals institutional activity, liquidity events, volatility shifts, breakouts, or reversals. This provides information that price alone cannot show.
Wskaźnik Pine Script®
od Blaiise
SHFE Silver Price Discovery (USD/oz)This indicator converts Shanghai Futures Exchange (SHFE) silver futures into USD per troy ounce and optionally overlays COMEX silver futures for direct, same-unit comparison. SHFE silver is quoted in CNY per kilogram, while COMEX is quoted in USD per troy ounce. To make SHFE prices comparable on the same chart, the script: pulls SHFE:AG1! close (CNY/kg) pulls USD/CNY FX rate converts to USD/oz using the exact kg → troy oz factor (32.1507466) Why this is useful: SHFE pricing often reflects different drivers than Western paper markets (currency effects, local liquidity, industrial demand, and regional availability). Normalizing SHFE into USD/oz lets traders and investors monitor inter-market alignment and spot periods where Eastern pricing diverges from COMEX. How to use: Use the SHFE USD/oz line as a “physical-demand-sensitive” reference. Overlay COMEX to compare regional pricing and identify multi-week divergence regimes. For the premium/discount histogram, use the companion indicator: “SHFE Silver Premium vs COMEX (USD/oz)”. This indicator is designed for macro and inter-market analysis rather than short-term scalping.
Wskaźnik Pine Script®
od HighGecko
ICT Trading Sessions IndiaICT Trading Sessions – India (IST GMT+5:30) This indicator plots the Asia, London, and New York trading sessions using Indian Standard Time (GMT+5:30). Session timing is fully locked to IST and does not change based on the user’s country, chart timezone, or device location, ensuring consistent session behavior for all users worldwide. Features: Asia, London & New York session boxes Correct session closing (no early close issue) New York session handled across midnight Customizable colors, borders, and widths Session labels with adjustable size and text color Designed for ICT / SMC traders, Forex, Indices, and Crypto.
Wskaźnik Pine Script®
od shemeer4823
Trading Sessions UAETrading Sessions – UAE (GMT+4) This indicator plots the Asia, London, and New York trading sessions as clean session boxes based on UAE time (GMT+4). Session timing is fully locked to UAE timezone and does not change with the user’s country, chart timezone, or device location. This ensures consistent session behavior for all users worldwide. Features include: Asia, London & New York session boxes Correct session closing (no early close issue) New York session handled across midnight Customizable colors, borders, and widths Session labels with adjustable size and text color Designed for ICT / SMC traders, Forex, Indices, and Crypto.
Wskaźnik Pine Script®
od shemeer4823
GEX Walls + Market Open Shading### Overview This Pine Script (version 6) creates a TradingView indicator called **"GEX Walls + Market Open Shading"**. It overlays directly on the price chart and is designed for intraday trading, particularly for indices like SPX or ES futures. The script combines two main features: - **GEX Walls**: Visual boxes and labels highlighting "Gamma Exposure" (GEX) levels—key support (Put Wall) and resistance (Call Wall) zones based on options gamma. It includes approach alerts. - **Market Open Shading**: A semi-transparent background shade during a customizable post-market-open session (e.g., first 2 hours after 9:30 AM EST). It uses up to 20 boxes and 20 labels, with right-scale positioning for better visibility on the price axis. The script detects new trading days to reset visuals dynamically. ### Key Inputs The script is highly customizable via inputs grouped into sections: #### GEX Walls Inputs - **Call Wall** (default: 6900.0): Upper resistance level. - **Put Wall** (default: 6850.0): Lower support level. - **Buffer** (default: 3.0 points): Vertical padding around each wall for box thickness. - **Alert Distance** (default: 10.0 points): Threshold for triggering "approach" alerts. - **Colors**: Semi-transparent yellow for Call Wall boxes (#ffeb3b at 80% opacity), orange for Put Wall (#ff9800 at 80%). - **Toggles**: Show/hide boxes; enable/disable alerts; restrict alerts to shaded session only. - **Labels**: Text color (white), offset (bars to the right, default -2), size (tiny/small/normal/large). #### Market Open Shading Inputs - **Shade Color** (default: white at 90% transparency): Background fill during session. - **Transparency** (0-100, default: 90): Opacity level. - **Open Time** (default: 9:30 EST): Hour/minute for session start. - **Duration**: Dropdown with pre-formatted options (e.g., "120 min: 11:30a EST / 8:30a PST" up to 195 min), showing both EST and PST end times for convenience. - **Toggle**: Show/hide shading. ### How It Works #### 1. Market Open Shading - Calculates end time from open hour/minute + selected duration (e.g., 120 minutes from 9:30 AM EST = 11:30 AM EST). - Builds a session string (e.g., "0930-1130") for TradingView's `time()` function. - Detects if the current bar is within the session using `not na(time("", sessionString))`. - Applies `bgcolor()` with the user-defined color/transparency only during the session. - Helper functions format times in 12-hour AM/PM style (e.g., "11:30a") for labels, with EST/PST variants. #### 2. Day Detection - Uses `time("D")` to track daily changes (`ta.change(dayTime) != 0` signals a new day). - Maintains variables for the current day's start bar index (`todayStartIndex`) and previous day's start (`prevStartIndex`). - This ensures boxes span exactly from yesterday's open to today (intraday reset on new days). #### 3. GEX Walls Visualization - **Boxes**: Drawn once `prevStartIndex` is known (i.e., on the second day onward). - Left edge: Previous day's start bar. - Right edge: Current bar (extends live). - Height: Wall level ± buffer (e.g., Call Wall box from 6900-3 to 6900+3). - Updated dynamically with `box.set_*` functions; hidden (100% transparent) if toggled off. - **Labels**: Placed at exact wall levels, offset to the right (e.g., 2 bars ahead for readability). - Text: "CALL WALL: 6900.0" or "PUT WALL: 6850.0". - Style: Right-aligned, black background (transparent), user-defined text color/size. - Deleted if toggled off. - All visuals use `xloc.bar_index` for bar-based positioning. #### 4. Alerts - **Call Wall Approach**: Triggers when close enters within `alertDistance` below the wall, but prior bar was further away (rising toward resistance). Message: "Price approaching Call Wall at from below (within points)". - **Put Wall Approach**: Symmetric for falling toward support (within distance above wall). - Filtered optionally to shaded session only. - Uses `alertcondition()` with hidden plots (`display=display.none`) for dynamic message placeholders (e.g., `{{plot_0}}` inserts wall level). ### Notable Features & Behaviors - **Intraday Focus**: Boxes/labels reset daily, making it ideal for day trading without historical clutter. - **Time Zone Handling**: Defaults to EST for market open but shows PST equivalents in dropdowns (subtracts 3 hours). - **Efficiency**: Uses `var` declarations for persistent objects (boxes/labels) to avoid recreation on every bar. - **Edge Cases**: Handles label offsets (clamped -10 to 50 bars); session wrapping (e.g., overnight via %24); new chart loads (initializes on first bar). - **Customization Depth**: 20+ inputs allow fine-tuning without code edits. Alerts integrate seamlessly with TradingView's system. - **Limitations**: Relies on bar_index for historical spanning (best on lower timeframes like 1-5 min); no historical backfill for walls (live-only). This script is a practical tool for options-aware traders monitoring gamma squeezes or pinning levels during market open volatility. To use it, paste into TradingView's Pine Editor, adjust inputs for your asset (e.g., update walls for current GEX data), and add to chart.
Wskaźnik Pine Script®
od skrillionaire1
updated swapsV-Tap (also called D-Tap) is a standardized auxiliary power output found on V-mount batteries. It provides direct DC power—typically around 14.4V—to run external accessories such as monitors, wireless video transmitters, follow-focus motors, LED lights, and audio equipment. V-Tap ports allow filmmakers to power multiple devices from a single battery, reducing cable clutter and improving mobility on set. If you want it shorter, more technical, or more marketing-style, tell me where you’re using it (product page, manual, school project, etc.).
Wskaźnik Pine Script®
od ldraco