Mulakan

Cari dalam skrip untuk "bot"

Silver Futures Adaptive Strategy 1-18-20261. Hybrid Trading Logic The strategy doesn't rely on a single method; instead, it switches between three distinct entry archetypes depending on market conditions: Trend Following: Activated when ADX is high. It looks for "Golden Crosses" (EMA 21/50) confirmed by a long-term 200 EMA filter. Breakout: Enters when the price exceeds the 20-period highest high or lowest low, provided there is a "Volume Spike" to confirm the move. Mean Reversion: Activated when ADX is low (ranging market). It uses Bollinger Bands and RSI to buy oversold dips or sell overbought peaks. 2. Key Technical Indicators The strategy uses a robust stack of indicators to filter out "noise": ADX (Average Directional Index): Acts as the "brain" that determines if the market is trending (ADX > 20) or ranging. Triple EMA Filter: Uses 21, 50, and 200 EMAs to ensure trades are only taken in the direction of the dominant trend. Volume Filter: Requires volume to be 20% higher than the 20-period average to validate an entry, preventing "fake-outs." Silver-Adjusted ATR: Calculates volatility specifically for Silver, applying a 1.2x multiplier to account for the metal's unique price action. 3. Advanced Risk Management The strategy is built for execution with the following safeguards: Dynamic Stops/TP: Stop losses and take profits are not fixed dollar amounts; they are based on ATR (Average True Range), meaning they widen during high volatility and tighten during low volatility. Trailing Stop: Includes an optional trailing stop feature to lock in profits as the trade moves in your favor. Position Sizing: Defaults to 10% of equity per trade with a maximum of 3 "pyramiding" entries (scaling into a winning position). 4. Automation & UI Features JSON Alert Messages: The script generates machine-readable JSON alerts. This makes it "plug-and-play" for automated trading bots, sending the action, price, SL, and TP in a single message. Dashboard Info Panel: A table on the top-right of the chart displays real-time data: Market State: Trending vs. Ranging. Live Stats: Current ADX, RSI, and ATR values. Visual Cues: It plots support/resistance steplines and labels entries with green/red triangles for easy backtesting.
Strategi Pine Script®
oleh mattkelly914
Spot Taker Flow & Early Warning System How Does This Code Detect a "Fake" Rise? Spot VWMA Logic: The moving average looks not only at the price but also at how much "spot volume" is circulating at that price. Fake Rise Scenario: If the price (candles) is going up but the Yellow (Binance) or Blue (Coinbase) lines we've drawn are below it, or the price is drooping to the level of these lines; know that the rise is being triggered by bots in futures trading, not spot buyers. This is a "Fake" rise. Confirmed Rise: If the price is above all these L1 lines, there may be "real money behind it".
Penunjuk Pine Script®
oleh sabritonyali
BUZARA// © Buzzara // ================================= // PLEASE SUPPORT THE TEAM // ================================= // // Telegram: t.me // ================================= //@version=5 VERSION  = ' Buzzara2.0' strategy('ALGOX V6_1_24', shorttitle = '🚀〄 Buzzara2.0 〄🚀'+ VERSION, overlay = true, explicit_plot_zorder = true, pyramiding = 0, default_qty_type = strategy.percent_of_equity, initial_capital = 1000, default_qty_value = 1, calc_on_every_tick = false, process_orders_on_close = true) G_SCRIPT01   = '■ ' + 'SAIYAN OCC' //#region ———— <↓↓↓ G_SCRIPT01 ↓↓↓> { // === INPUTS === res                       = input.timeframe('15',  'TIMEFRAME', group ="NON REPAINT") useRes                    = input(true,            'Use Alternate Signals') intRes                    = input(10,               'Multiplier for Alernate Signals') basisType                 = input.string('ALMA',   'MA Type: ', options= ) basisLen                  = input.int(50,           'MA Period', minval=1) offsetSigma               = input.int(5,           'Offset for LSMA / Sigma for ALMA', minval=0) offsetALMA                = input.float(2,      'Offset for ALMA', minval=0, step=0.01) scolor                    = input(false,           'Show coloured Bars to indicate Trend?') delayOffset               = input.int(0,           'Delay Open/Close MA', minval=0, step=1,                   tooltip = 'Forces Non-Repainting') tradeType                 = input.string('BOTH',   'What trades should be taken : ',                   options = ) //=== /INPUTS === h                         = input(false,           'Signals for Heikin Ashi Candles') //INDICATOR SETTINGS swing_length              = input.int(10,          'Swing High/Low Length', group = 'Settings', minval = 1, maxval = 50) history_of_demand_to_keep = input.int(20,          'History To Keep', minval = 5, maxval = 50) box_width                 = input.float(2.5,       'Supply/Demand Box Width', group = 'Settings', minval = 1, maxval = 10, step = 0.5) //INDICATOR VISUAL SETTINGS show_zigzag               = input.bool(false,      'Show Zig Zag', group = 'Visual Settings', inline = '1') show_price_action_labels  = input.bool(false,      'Show Price Action Labels', group = 'Visual Settings', inline = '2') supply_color              = input.color(#00000000, 'Supply', group = 'Visual Settings', inline = '3') supply_outline_color      = input.color(#00000000, 'Outline', group = 'Visual Settings', inline = '3') demand_color              = input.color(#00000000, 'Demand', group = 'Visual Settings', inline = '4') demand_outline_color      = input.color(#00000000, 'Outline', group = 'Visual Settings', inline = '4') bos_label_color           = input.color(#00000000, 'BOS Label', group = 'Visual Settings', inline = '5') poi_label_color           = input.color(#00000000, 'POI Label', group = 'Visual Settings', inline = '7') poi_border_color          = input.color(#00000000, 'POI border', group = 'Visual Settings', inline = '7') swing_type_color          = input.color(#00000000, 'Price Action Label', group = 'Visual Settings', inline = '8') zigzag_color              = input.color(#00000000, 'Zig Zag', group = 'Visual Settings', inline = '9') //END SETTINGS //      FUNCTION TO ADD NEW AND REMOVE LAST IN ARRAY f_array_add_pop(array, new_value_to_add) =>     array.unshift(array, new_value_to_add)     array.pop(array) //      FUNCTION SWING H & L LABELS f_sh_sl_labels(array, swing_type) =>     var string label_text = na     if swing_type == 1         if array.get(array, 0) >= array.get(array, 1)             label_text := 'HH'         else             label_text := 'LH'         label.new(           bar_index - swing_length,           array.get(array,0),           text = label_text,           style = label.style_label_down,           textcolor = swing_type_color,           color = swing_type_color,           size = size.tiny)         else if swing_type == -1         if array.get(array, 0) >= array.get(array, 1)             label_text := 'HL'         else             label_text := 'LL'         label.new(           bar_index - swing_length,           array.get(array,0),           text = label_text,           style = label.style_label_up,           textcolor = swing_type_color,           color = swing_type_color,           size = size.tiny) //      FUNCTION MAKE SURE SUPPLY ISNT OVERLAPPING f_check_overlapping(new_poi, box_array, atrValue) =>     atr_threshold = atrValue * 2     okay_to_draw = true     for i = 0 to array.size(box_array) - 1         top = box.get_top(array.get(box_array, i))         bottom = box.get_bottom(array.get(box_array, i))         poi = (top + bottom) / 2         upper_boundary = poi + atr_threshold         lower_boundary = poi - atr_threshold         if new_poi >= lower_boundary and new_poi <= upper_boundary             okay_to_draw := false             break         else             okay_to_draw := true     okay_to_draw //      FUNCTION TO DRAW SUPPLY OR DEMAND ZONE f_supply_demand(value_array, bn_array, box_array, label_array, box_type, atrValue) =>     atr_buffer = atrValue * (box_width / 10)     box_left   = array.get(bn_array, 0)     box_right  = bar_index     var float box_top = 0.00     var float box_bottom = 0.00     var float poi = 0.00     if box_type == 1         box_top := array.get(value_array, 0)         box_bottom := box_top - atr_buffer         poi := (box_top + box_bottom) / 2     else if box_type == -1         box_bottom := array.get(value_array, 0)         box_top := box_bottom + atr_buffer         poi := (box_top + box_bottom) / 2     okay_to_draw = f_check_overlapping(poi, box_array, atrValue)     // okay_to_draw = true     //delete oldest box, and then create a new box and add it to the array     if box_type == 1 and okay_to_draw         box.delete( array.get(box_array, array.size(box_array) - 1) )         f_array_add_pop(box_array, box.new( left = box_left, top = box_top, right = box_right, bottom = box_bottom, border_color = supply_outline_color,              bgcolor = supply_color, extend = extend.right, text = 'SUPPLY', text_halign = text.align_center, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))                 box.delete( array.get(label_array, array.size(label_array) - 1) )         f_array_add_pop(label_array, box.new( left = box_left, top = poi, right = box_right, bottom = poi, border_color = poi_border_color,              bgcolor = poi_border_color, extend = extend.right, text = 'POI', text_halign = text.align_left, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))     else if box_type == -1 and okay_to_draw         box.delete( array.get(box_array, array.size(box_array) - 1) )         f_array_add_pop(box_array, box.new( left = box_left, top = box_top, right = box_right, bottom = box_bottom, border_color = demand_outline_color,              bgcolor = demand_color, extend = extend.right,  text = 'DEMAND', text_halign = text.align_center, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))                 box.delete( array.get(label_array, array.size(label_array) - 1) )         f_array_add_pop(label_array, box.new( left = box_left, top = poi, right = box_right, bottom = poi, border_color = poi_border_color,              bgcolor = poi_border_color, extend = extend.right,  text = 'POI', text_halign = text.align_left, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index)) //      FUNCTION TO CHANGE SUPPLY/DEMAND TO A BOS IF BROKEN f_sd_to_bos(box_array, bos_array, label_array, zone_type) =>     if zone_type == 1         for i = 0 to array.size(box_array) - 1             level_to_break = box.get_top(array.get(box_array,i))             // if ta.crossover(close, level_to_break)             if close >= level_to_break                 copied_box = box.copy(array.get(box_array,i))                 f_array_add_pop(bos_array, copied_box)                 mid = (box.get_top(array.get(box_array,i)) + box.get_bottom(array.get(box_array,i))) / 2                 box.set_top(array.get(bos_array,0), mid)                 box.set_bottom(array.get(bos_array,0), mid)                 box.set_extend( array.get(bos_array,0), extend.none)                 box.set_right( array.get(bos_array,0), bar_index)                 box.set_text( array.get(bos_array,0), 'BOS' )                 box.set_text_color( array.get(bos_array,0), bos_label_color)                 box.set_text_size( array.get(bos_array,0), size.small)                 box.set_text_halign( array.get(bos_array,0), text.align_center)                 box.set_text_valign( array.get(bos_array,0), text.align_center)                 box.delete(array.get(box_array, i))                 box.delete(array.get(label_array, i))     if zone_type == -1         for i = 0 to array.size(box_array) - 1             level_to_break = box.get_bottom(array.get(box_array,i))             // if ta.crossunder(close, level_to_break)             if close <= level_to_break                 copied_box = box.copy(array.get(box_array,i))                 f_array_add_pop(bos_array, copied_box)                 mid = (box.get_top(array.get(box_array,i)) + box.get_bottom(array.get(box_array,i))) / 2                 box.set_top(array.get(bos_array,0), mid)                 box.set_bottom(array.get(bos_array,0), mid)                 box.set_extend( array.get(bos_array,0), extend.none)                 box.set_right( array.get(bos_array,0), bar_index)                 box.set_text( array.get(bos_array,0), 'BOS' )                 box.set_text_color( array.get(bos_array,0), bos_label_color)                 box.set_text_size( array.get(bos_array,0), size.small)                 box.set_text_halign( array.get(bos_array,0), text.align_center)                 box.set_text_valign( array.get(bos_array,0), text.align_center)                 box.delete(array.get(box_array, i))                 box.delete(array.get(label_array, i)) //      FUNCTION MANAGE CURRENT BOXES BY CHANGING ENDPOINT f_extend_box_endpoint(box_array) =>     for i = 0 to array.size(box_array) - 1         box.set_right(array.get(box_array, i), bar_index + 100) // stratRes = timeframe.ismonthly  ? str.tostring(timeframe.multiplier * intRes, '###M') :            timeframe.isweekly   ? str.tostring(timeframe.multiplier * intRes, '###W') :            timeframe.isdaily    ? str.tostring(timeframe.multiplier * intRes, '###D') :            timeframe.isintraday ? str.tostring(timeframe.multiplier * intRes, '####') :            '60' src      = h ? request.security(ticker.heikinashi(syminfo.tickerid),            timeframe.period, close, lookahead = barmerge.lookahead_off) : close //      CALCULATE ATR atrValue = ta.atr(50) //      CALCULATE SWING HIGHS & SWING LOWS swing_high = ta.pivothigh(high, swing_length, swing_length) swing_low  = ta.pivotlow(low,   swing_length, swing_length) //      ARRAYS FOR SWING H/L & BN var swing_high_values  = array.new_float(5,0.00) var swing_low_values   = array.new_float(5,0.00) var swing_high_bns     = array.new_int(5,0) var swing_low_bns      = array.new_int(5,0) //      ARRAYS FOR SUPPLY / DEMAND var current_supply_box = array.new_box(history_of_demand_to_keep, na) var current_demand_box = array.new_box(history_of_demand_to_keep, na) //      ARRAYS FOR SUPPLY / DEMAND POI LABELS var current_supply_poi = array.new_box(history_of_demand_to_keep, na) var current_demand_poi = array.new_box(history_of_demand_to_keep, na) //      ARRAYS FOR BOS var supply_bos         = array.new_box(5, na) var demand_bos         = array.new_box(5, na) //END CALCULATIONS //      NEW SWING HIGH if not na(swing_high)     //MANAGE SWING HIGH VALUES     f_array_add_pop(swing_high_values, swing_high)     f_array_add_pop(swing_high_bns, bar_index )     if show_price_action_labels         f_sh_sl_labels(swing_high_values, 1)     f_supply_demand(swing_high_values, swing_high_bns, current_supply_box, current_supply_poi, 1, atrValue) //      NEW SWING LOW else if not na(swing_low)     //MANAGE SWING LOW VALUES     f_array_add_pop(swing_low_values, swing_low)     f_array_add_pop(swing_low_bns, bar_index )     if show_price_action_labels         f_sh_sl_labels(swing_low_values, -1)         f_supply_demand(swing_low_values, swing_low_bns, current_demand_box, current_demand_poi, -1, atrValue) f_sd_to_bos(current_supply_box, supply_bos, current_supply_poi, 1) f_sd_to_bos(current_demand_box, demand_bos, current_demand_poi, -1) f_extend_box_endpoint(current_supply_box) f_extend_box_endpoint(current_demand_box) channelBal     = input.bool(false, "Channel Balance", group = "CHART") lr_slope(_src, _len) =>     x = 0.0, y = 0.0, x2 = 0.0, xy = 0.0     for i = 0 to _len - 1         val = _src         per = i + 1         x += per         y += val         x2 += per * per         xy += val * per     _slp = (_len * xy - x * y) / (_len * x2 - x * x)     _avg = y / _len     _int = _avg - _slp * x / _len + _slp     lr_dev(_src, _len, _slp, _avg, _int) =>     upDev = 0.0, dnDev = 0.0     val = _int     for j = 0 to _len - 1         price = high - val         if price > upDev             upDev := price         price := val - low         if price > dnDev             dnDev := price         price := _src         val += _slp     // = ta.kc(close, 80, 10.5) = ta.kc(close, 80, 9.5) = ta.kc(close, 80, 8) = ta.kc(close, 80, 3) barsL          = 10 barsR          = 10 pivotHigh      = fixnan(ta.pivothigh(barsL, barsR) ) pivotLow       = fixnan(ta.pivotlow(barsL, barsR) ) source         = close, period = 150      = lr_slope(source, period) = lr_dev(source, period, s, a, i) y1 = low  - (ta.atr(30) * 2), y1B = low  - ta.atr(30) y2 = high + (ta.atr(30) * 2), y2B = high + ta.atr(30) x1 = bar_index - period + 1, _y1 = i + s * (period - 1), x2 = bar_index, _y2 = i //Functions //Line Style function get_line_style(style) =>     out = switch style         '???'  => line.style_solid         '----' => line.style_dashed         '    ' => line.style_dotted //Function to get order block coordinates get_coordinates(condition, top, btm, ob_val)=>     var ob_top  = array.new_float(0)     var ob_btm  = array.new_float(0)     var ob_avg  = array.new_float(0)     var ob_left = array.new_int(0)     float ob = na     //Append coordinates to arrays     if condition         avg = math.avg(top, btm)                 array.unshift(ob_top, top)         array.unshift(ob_btm, btm)         array.unshift(ob_avg, avg)             ob := ob_val         //Function to remove mitigated order blocks from coordinate arrays remove_mitigated(ob_top, ob_btm, ob_left, ob_avg, target, bull)=>     mitigated = false     target_array = bull ? ob_btm : ob_top     for element in target_array         idx = array.indexof(target_array, element)         if (bull ? target < element : target > element)             mitigated := true             array.remove(ob_top, idx)             array.remove(ob_btm, idx)             array.remove(ob_avg, idx)             array.remove(ob_left, idx)         mitigated //Function to set order blocks set_order_blocks(ob_top, ob_btm, ob_left, ob_avg, ext_last, bg_css, border_css, lvl_css)=>     var ob_box = array.new_box(0)     var ob_lvl = array.new_line(0) //Global elements var os = 0 var target_bull = 0. var target_bear = 0. // Create non-repainting security function rp_security(_symbol, _res, _src) =>     request.security(_symbol, _res, _src ) htfHigh = rp_security(syminfo.tickerid, res, high) htfLow  = rp_security(syminfo.tickerid, res, low) // Main Indicator // Functions smoothrng(x, t, m) =>     wper = t * 2 - 1     avrng = ta.ema(math.abs(x - x ), t)     smoothrng = ta.ema(avrng, wper) * m rngfilt(x, r) =>     rngfilt = x     rngfilt := x > nz(rngfilt ) ? x - r < nz(rngfilt ) ? nz(rngfilt ) : x - r : x + r > nz(rngfilt ) ? nz(rngfilt ) : x + r percWidth(len, perc) => (ta.highest(len) - ta.lowest(len)) * perc / 100 securityNoRep(sym, res, src) => request.security(sym, res, src, barmerge.gaps_off, barmerge.lookahead_on) swingPoints(prd) =>     pivHi = ta.pivothigh(prd, prd)     pivLo = ta.pivotlow (prd, prd)     last_pivHi = ta.valuewhen(pivHi, pivHi, 1)     last_pivLo = ta.valuewhen(pivLo, pivLo, 1)     hh = pivHi and pivHi > last_pivHi ? pivHi : na     lh = pivHi and pivHi < last_pivHi ? pivHi : na     hl = pivLo and pivLo > last_pivLo ? pivLo : na     ll = pivLo and pivLo < last_pivLo ? pivLo : na     f_chartTfInMinutes() =>     float _resInMinutes = timeframe.multiplier * (       timeframe.isseconds ? 1                   :       timeframe.isminutes ? 1.                  :       timeframe.isdaily   ? 60. * 24            :       timeframe.isweekly  ? 60. * 24 * 7        :       timeframe.ismonthly ? 60. * 24 * 30.4375  : na) f_kc(src, len, sensitivity) =>     basis = ta.sma(src, len)     span  = ta.atr(len)     wavetrend(src, chlLen, avgLen) =>     esa = ta.ema(src, chlLen)     d = ta.ema(math.abs(src - esa), chlLen)     ci = (src - esa) / (0.015 * d)     wt1 = ta.ema(ci, avgLen)     wt2 = ta.sma(wt1, 3)     f_top_fractal(_src) => _src < _src and _src < _src and _src > _src and _src > _src f_bot_fractal(_src) => _src > _src and _src > _src and _src < _src and _src < _src top_fractal    = f_top_fractal(src) bot_fractal    = f_bot_fractal(src) f_fractalize (_src) => top_fractal ? 1 : bot_fractal ? -1 : 0 f_findDivs(src, topLimit, botLimit) =>     fractalTop = f_fractalize(src) > 0 and src >= topLimit ? src : na     fractalBot = f_fractalize(src) < 0 and src <= botLimit ? src : na     highPrev   = ta.valuewhen(fractalTop, src , 0)     highPrice  = ta.valuewhen(fractalTop, high , 0)     lowPrev    = ta.valuewhen(fractalBot, src , 0)     lowPrice   = ta.valuewhen(fractalBot, low , 0)     bearSignal = fractalTop and high > highPrice and src < highPrev     bullSignal = fractalBot and low < lowPrice and src > lowPrev         // Get user input enableSR   = input(false          , "SR On/Off", group="SR") colorSup   = input(#00000000        , "Support Color", group="SR") colorRes   = input(#00000000        , "Resistance Color", group="SR") strengthSR = input.int(2          , "S/R Strength", 1, group="SR") lineStyle  = input.string("Dotted", "Line Style", , group="SR") lineWidth  = input.int(2          , "S/R Line Width", 1, group="SR") useZones   = input(true           , "Zones On/Off", group="SR") useHLZones = input(true           , "High Low Zones On/Off", group="SR") zoneWidth  = input.int(2          , "Zone Width %", 0,    tooltip = "it's calculated using % of the distance between highest/lowest in last 300 bars", group="SR") expandSR   = input(true           , "Expand SR") // Get components rb         = 10 prd        = 284 ChannelW   = 10 label_loc  = 55 style      = lineStyle == "Solid"  ? line.style_solid  :              lineStyle == "Dotted" ? line.style_dotted : line.style_dashed ph         = ta.pivothigh(rb, rb) pl         = ta.pivotlow (rb, rb) sr_levels  = array.new_float(21, na) prdhighest = ta.highest(prd) prdlowest  = ta.lowest(prd) cwidth     = percWidth(prd, ChannelW) zonePerc   = percWidth(300, zoneWidth) aas        = array.new_bool(41, true) u1         = 0.0, u1 := nz(u1 ) d1         = 0.0, d1 := nz(d1 ) highestph  = 0.0, highestph := highestph lowestpl   = 0.0, lowestpl := lowestpl var sr_levs   = array.new_float(21, na) label hlabel  = na, label.delete(hlabel ) label llabel  = na, label.delete(llabel ) var sr_lines  = array.new_line(21, na) var sr_linesH = array.new_line(21, na) var sr_linesL = array.new_line(21, na) var sr_linesF = array.new_linefill(21, na) var sr_labels = array.new_label(21, na) if (not na(ph) or not na(pl))     for x = 0 to array.size(sr_levels) - 1         array.set(sr_levels, x, na)     highestph := prdlowest     lowestpl := prdhighest     countpp = 0     for x = 0 to prd         if na(close )             break         if not na(ph ) or not na(pl )             highestph := math.max(highestph, nz(ph , prdlowest), nz(pl , prdlowest))             lowestpl := math.min(lowestpl, nz(ph , prdhighest), nz(pl , prdhighest))             countpp += 1             if countpp > 40                 break             if array.get(aas, countpp)                 upl = (not na(ph ) and (ph != 0) ? high : low ) + cwidth                 dnl = (not na(ph ) and (ph != 0) ? high : low ) - cwidth                 u1 := countpp == 1 ? upl : u1                 d1 := countpp == 1 ? dnl : d1                 tmp = array.new_bool(41, true)                 cnt = 0                 tpoint = 0                 for xx = 0 to prd                     if na(close )                         break                     if not na(ph ) or not na(pl )                         chg = false                         cnt += 1                         if cnt > 40                             break                         if array.get(aas, cnt)                             if not na(ph )                                 if high <= upl and high >= dnl                                     tpoint += 1                                     chg := true                             if not na(pl )                                 if low <= upl and low >= dnl                                     tpoint += 1                                     chg := true                         if chg and cnt < 41                             array.set(tmp, cnt, false)                 if tpoint >= strengthSR                     for g = 0 to 40 by 1                         if not array.get(tmp, g)                             array.set(aas, g, false)                     if (not na(ph ) and countpp < 21)                         array.set(sr_levels, countpp, high )                     if (not na(pl ) and countpp < 21)                         array.set(sr_levels, countpp, low ) // Plot var line highest_      = na, line.delete(highest_) var line lowest_       = na, line.delete(lowest_) var line highest_fill1 = na, line.delete(highest_fill1) var line highest_fill2 = na, line.delete(highest_fill2) var line lowest_fill1  = na, line.delete(lowest_fill1) var line lowest_fill2  = na, line.delete(lowest_fill2) hi_col = close >= highestph ? colorSup : colorRes lo_col = close >= lowestpl  ? colorSup : colorRes if enableSR     highest_ := line.new(bar_index - 311, highestph, bar_index, highestph, xloc.bar_index, expandSR ? extend.both : extend.right, hi_col, style, lineWidth)     lowest_  := line.new(bar_index - 311, lowestpl , bar_index, lowestpl , xloc.bar_index, expandSR ? extend.both : extend.right, lo_col, style, lineWidth)     if useHLZones         highest_fill1 := line.new(bar_index - 311, highestph + zonePerc, bar_index, highestph + zonePerc, xloc.bar_index, expandSR ? extend.both : extend.right, na)         highest_fill2 := line.new(bar_index - 311, highestph - zonePerc, bar_index, highestph - zonePerc, xloc.bar_index, expandSR ? extend.both : extend.right, na)         lowest_fill1  := line.new(bar_index - 311, lowestpl + zonePerc , bar_index, lowestpl + zonePerc , xloc.bar_index, expandSR ? extend.both : extend.right, na)         lowest_fill2  := line.new(bar_index - 311, lowestpl - zonePerc , bar_index, lowestpl - zonePerc , xloc.bar_index, expandSR ? extend.both : extend.right, na)         linefill.new(highest_fill1, highest_fill2, hi_col)         linefill.new(lowest_fill1 , lowest_fill2 , lo_col) if (not na(ph) or not na(pl))     for x = 0 to array.size(sr_lines) - 1         array.set(sr_levs, x, array.get(sr_levels, x)) for x = 0 to array.size(sr_lines) - 1     line.delete(array.get(sr_lines, x))     line.delete(array.get(sr_linesH, x))     line.delete(array.get(sr_linesL, x))     linefill.delete(array.get(sr_linesF, x))     if (not na(array.get(sr_levs, x)) and enableSR)         line_col = close >= array.get(sr_levs, x) ? colorSup : colorRes         array.set(sr_lines, x, line.new(bar_index - 355, array.get(sr_levs, x), bar_index, array.get(sr_levs, x), xloc.bar_index, expandSR ? extend.both : extend.right, line_col, style, lineWidth))         if useZones             array.set(sr_linesH, x, line.new(bar_index - 355, array.get(sr_levs, x) + zonePerc, bar_index, array.get(sr_levs, x) + zonePerc, xloc.bar_index, expandSR ? extend.both : extend.right, na))             array.set(sr_linesL, x, line.new(bar_index - 355, array.get(sr_levs, x) - zonePerc, bar_index, array.get(sr_levs, x) - zonePerc, xloc.bar_index, expandSR ? extend.both : extend.right, na))             array.set(sr_linesF, x, linefill.new(array.get(sr_linesH, x), array.get(sr_linesL, x), line_col)) for x = 0 to array.size(sr_labels) - 1     label.delete(array.get(sr_labels, x))     if (not na(array.get(sr_levs, x)) and enableSR)         lab_loc = close >= array.get(sr_levs, x) ? label.style_label_up : label.style_label_down         lab_col = close >= array.get(sr_levs, x) ? colorSup             : colorRes         array.set(sr_labels, x, label.new(bar_index + label_loc, array.get(sr_levs, x), str.tostring(math.round_to_mintick(array.get(sr_levs, x))), color=lab_col , textcolor=#000000, style=lab_loc)) hlabel := enableSR ? label.new(bar_index + label_loc + math.round(math.sign(label_loc)) * 20, highestph, "High Level : " + str.tostring(highestph), color=hi_col, textcolor=#000000, style=label.style_label_down) : na llabel := enableSR ? label.new(bar_index + label_loc + math.round(math.sign(label_loc)) * 20, lowestpl , "Low  Level : " + str.tostring(lowestpl) , color=lo_col, textcolor=#000000, style=label.style_label_up  ) : na // Get components rsi       = ta.rsi(close, 28) //rsiOb     = rsi > 78 and rsi > ta.ema(rsi, 10) //rsiOs     = rsi < 27 and rsi < ta.ema(rsi, 10) rsiOb     = rsi > 65 and rsi > ta.ema(rsi, 10) rsiOs     = rsi < 35 and rsi < ta.ema(rsi, 10) dHigh     = securityNoRep(syminfo.tickerid, "D", high ) dLow      = securityNoRep(syminfo.tickerid, "D", low   ) dClose    = securityNoRep(syminfo.tickerid, "D", close ) ema = ta.ema(close, 144) emaBull = close > ema equal_tf(res) => str.tonumber(res) == f_chartTfInMinutes() and not timeframe.isseconds higher_tf(res) => str.tonumber(res) > f_chartTfInMinutes() or timeframe.isseconds too_small_tf(res) => (timeframe.isweekly and res=="1") or (timeframe.ismonthly and str.tonumber(res) < 10) securityNoRep1(sym, res, src) =>     bool bull_ = na     bull_ := equal_tf(res) ? src : bull_     bull_ := higher_tf(res) ? request.security(sym, res, src, barmerge.gaps_off, barmerge.lookahead_on) : bull_     bull_array = request.security_lower_tf(syminfo.tickerid, higher_tf(res) ? str.tostring(f_chartTfInMinutes()) + (timeframe.isseconds ? "S" : "") : too_small_tf(res) ? (timeframe.isweekly ? "3" : "10") : res, src)     if array.size(bull_array) > 1 and not equal_tf(res) and not higher_tf(res)         bull_ := array.pop(bull_array)     array.clear(bull_array)     bull_ // === BASE FUNCTIONS === // Returns MA input selection variant, default to SMA if blank or typo. variant(type, src, len, offSig, offALMA) =>     v1    = ta.sma(src, len)  // Simple     v2    = ta.ema(src, len)  // Exponential     v3    = 2 * v2 - ta.ema(v2, len)  // Double Exponential     v4    = 3 * (v2 - ta.ema(v2, len)) + ta.ema(ta.ema(v2, len), len)  // Triple Exponential     v5    = ta.wma(src, len)  // Weighted     v6    = ta.vwma(src, len)  // Volume Weighted     v7    = 0.0     sma_1 = ta.sma(src, len)  // Smoothed     v7   := na(v7 ) ? sma_1 : (v7 * (len - 1) + src) / len     v8    = ta.wma(2 * ta.wma(src, len / 2) - ta.wma(src, len), math.round(math.sqrt(len)))  // Hull     v9    = ta.linreg(src, len, offSig)  // Least Squares     v10   = ta.alma(src, len, offALMA, offSig)  // Arnaud Legoux     v11   = ta.sma(v1, len)  // Triangular (extreme smooth)     // SuperSmoother filter     //   2013  John F. Ehlers     a1    = math.exp(-1.414 * 3.14159 / len)     b1    = 2 * a1 * math.cos(1.414 * 3.14159 / len)     c2    = b1     c3    = -a1 * a1     c1    = 1 - c2 - c3     v12   = 0.0     v12  := c1 * (src + nz(src )) / 2 + c2 * nz(v12 ) + c3 * nz(v12 )     type == 'EMA' ? v2 : type == 'DEMA' ? v3 : type == 'TEMA' ? v4 : type == 'WMA' ? v5 : type == 'VWMA' ? v6 : type == 'SMMA' ? v7 : type == 'HullMA' ? v8 : type == 'LSMA' ? v9 : type == 'ALMA' ? v10 : type == 'TMA' ? v11 : type == 'SSMA' ? v12 : v1 // security wrapper for repeat calls reso(exp, use, res) =>     security_1 = request.security(syminfo.tickerid, res, exp, gaps = barmerge.gaps_off, lookahead = barmerge.lookahead_on)     use ? security_1 : exp // === /BASE FUNCTIONS === // === SERIES SETUP === closeSeries = variant(basisType, close , basisLen, offsetSigma, offsetALMA) openSeries  = variant(basisType, open ,  basisLen, offsetSigma, offsetALMA) // === /SERIES === // Get Alternate resolution Series if selected. closeSeriesAlt = reso(closeSeries, useRes, stratRes) openSeriesAlt  = reso(openSeries, useRes, stratRes) // lxTrigger    = false sxTrigger    = false leTrigger    = ta.crossover (closeSeriesAlt, openSeriesAlt) seTrigger    = ta.crossunder(closeSeriesAlt, openSeriesAlt) G_RISK       = '■ ' + 'Risk Management' //#region ———— <↓↓↓ G_RISK ↓↓↓> { // ——————————— //Tooltip T_LVL        = '(%) Exit Level' T_QTY        = '(%) Adjust trade exit volume' T_MSG        = 'Paste JSON message for your bot' //Webhook Message O_LEMSG      = 'Long Entry' O_LXMSGSL    = 'Long SL' O_LXMSGTP1   = 'Long TP1' O_LXMSGTP2   = 'Long TP2' O_LXMSGTP3   = 'Long TP3' O_LXMSG      = 'Long Exit' O_SEMSG      = 'Short Entry' O_SXMSGSL    = 'Short SL' O_SXMSGA     = 'Short TP1' O_SXMSGB     = 'Short TP2' O_SXMSGC     = 'Short TP3' O_SXMSGX     = 'Short Exit' // ———————————          |           |                               |                        Line length guide | i_lxLvlTP1   = input.float      (0.2,         'Level TP1'                     , group = G_RISK,      tooltip =                   T_LVL) i_lxQtyTP1   = input.float      (80.0,        'Qty   TP1'                     , group = G_RISK,      tooltip =                   T_QTY) i_lxLvlTP2   = input.float      (0.5,       'Level TP2'                     , group = G_RISK,      tooltip =                   T_LVL) i_lxQtyTP2   = input.float      (10.0,        'Qty   TP2'                     , group = G_RISK,      tooltip =                   T_QTY) i_lxLvlTP3   = input.float      (7.0,         'Level TP3'                     , group = G_RISK,      tooltip =                   T_LVL) i_lxQtyTP3   = input.float      (2,        'Qty   TP3'                     , group = G_RISK,      tooltip =                   T_QTY) i_lxLvlSL    = input.float      (0.5,       'Stop Loss'                     , group = G_RISK,      tooltip =                   T_LVL) i_sxLvlTP1   = i_lxLvlTP1 i_sxQtyTP1   = i_lxQtyTP1 i_sxLvlTP2   = i_lxLvlTP2 i_sxQtyTP2   = i_lxQtyTP2 i_sxLvlTP3   = i_lxLvlTP3 i_sxQtyTP3   = i_lxQtyTP3 i_sxLvlSL    = i_lxLvlSL G_MSG        = '■ ' + 'Webhook Message' i_leMsg      = input.string     (O_LEMSG   ,'Long Entry'                   , group = G_MSG, tooltip = T_MSG) i_lxMsgSL    = input.string     (O_LXMSGSL ,'Long SL'                      , group = G_MSG, tooltip = T_MSG) i_lxMsgTP1   = input.string     (O_LXMSGTP1,'Long TP1'                     , group = G_MSG, tooltip = T_MSG) i_lxMsgTP2   = input.string     (O_LXMSGTP2,'Long TP2'                     , group = G_MSG, tooltip = T_MSG) i_lxMsgTP3   = input.string     (O_LXMSGTP3,'Long TP3'                     , group = G_MSG, tooltip = T_MSG) i_lxMsg      = input.string     (O_LXMSG   ,'Long Exit'                    , group = G_MSG, tooltip = T_MSG) i_seMsg      = input.string     (O_SEMSG   ,'Short Entry'                  , group = G_MSG, tooltip = T_MSG) i_sxMsgSL    = input.string     (O_SXMSGSL ,'Short SL'                     , group = G_MSG, tooltip = T_MSG) i_sxMsgTP1   = input.string     (O_SXMSGA  ,'Short TP1'                    , group = G_MSG, tooltip = T_MSG) i_sxMsgTP2   = input.string     (O_SXMSGB  ,'Short TP2'                    , group = G_MSG, tooltip = T_MSG) i_sxMsgTP3   = input.string     (O_SXMSGC  ,'Short TP3'                    , group = G_MSG, tooltip = T_MSG) i_sxMsg      = input.string     (O_SXMSGX  ,'Short Exit'                   , group = G_MSG, tooltip = T_MSG) i_src        = close G_DISPLAY    = 'Display' // i_alertOn    = input.bool       (true,      'Alert Labels On/Off'          , group = G_DISPLAY) i_barColOn   = input.bool       (true,      'Bar Color On/Off'             , group = G_DISPLAY) // ——————————— // @function        Calculate the Take Profit line, and the crossover or crossunder f_tp(_condition, _conditionValue, _leTrigger, _seTrigger, _src, _lxLvlTP, _sxLvlTP)=>     var float _tpLine = 0.0     _topLvl     = _src + (_src * (_lxLvlTP / 100))     _botLvl     = _src - (_src * (_sxLvlTP / 100))     _tpLine    := _condition !=  _conditionValue and _leTrigger ? _topLvl :                   _condition != -_conditionValue and _seTrigger ? _botLvl :                   nz(_tpLine )     // @function        Similar to "ta.crossover" or "ta.crossunder" f_cross(_scr1, _scr2, _over)=>     _cross   = _over ? _scr1 > _scr2 and _scr1 < _scr2 :                        _scr1 < _scr2 and _scr1 > _scr2 // ——————————— // var float condition = 0.0 var float slLine    = 0.0 var float entryLine = 0.0 // entryLine   := leTrigger and condition <=  0.0 ? close :                seTrigger and condition >=  0.0 ? close : nz(entryLine ) // slTopLvl    = i_src + (i_src * (i_lxLvlSL / 100)) slBotLvl    = i_src - (i_src * (i_sxLvlSL / 100)) slLine     := condition <=  0.0 and leTrigger ? slBotLvl :               condition >=  0.0 and seTrigger ? slTopLvl : nz(slLine ) slLong      = f_cross(low,  slLine, false) slShort     = f_cross(high, slLine, true ) //    = f_tp(condition, 1.2,leTrigger, seTrigger, i_src, i_lxLvlTP3, i_sxLvlTP3)    = f_tp(condition, 1.1,leTrigger, seTrigger, i_src, i_lxLvlTP2, i_sxLvlTP2)    = f_tp(condition, 1.0,leTrigger, seTrigger, i_src, i_lxLvlTP1, i_sxLvlTP1) tp3Long      = f_cross(high, tp3Line, true ) tp3Short     = f_cross(low,  tp3Line, false) tp2Long      = f_cross(high, tp2Line, true ) tp2Short     = f_cross(low,  tp2Line, false) tp1Long      = f_cross(high, tp1Line, true ) tp1Short     = f_cross(low,  tp1Line, false) switch     leTrigger and condition <=  0.0 => condition :=  1.0     seTrigger and condition >=  0.0 => condition := -1.0     tp3Long   and condition ==  1.2 => condition :=  1.3     tp3Short  and condition == -1.2 => condition := -1.3     tp2Long   and condition ==  1.1 => condition :=  1.2     tp2Short  and condition == -1.1 => condition := -1.2     tp1Long   and condition ==  1.0 => condition :=  1.1     tp1Short  and condition == -1.0 => condition := -1.1     slLong    and condition >=  1.0 => condition :=  0.0     slShort   and condition <= -1.0 => condition :=  0.0     lxTrigger and condition >=  1.0 => condition :=  0.0     sxTrigger and condition <= -1.0 => condition :=  0.0 longE        = leTrigger and condition <=  0.0 and condition ==  1.0 shortE       = seTrigger and condition >=  0.0 and condition == -1.0 longX        = lxTrigger and condition >=  1.0 and condition ==  0.0 shortX       = sxTrigger and condition <= -1.0 and condition ==  0.0 longSL       = slLong    and condition >=  1.0 and condition ==  0.0 shortSL      = slShort   and condition <= -1.0 and condition ==  0.0 longTP3      = tp3Long   and condition ==  1.2 and condition ==  1.3 shortTP3     = tp3Short  and condition == -1.2 and condition == -1.3 longTP2      = tp2Long   and condition ==  1.1 and condition ==  1.2 shortTP2     = tp2Short  and condition == -1.1 and condition == -1.2 longTP1      = tp1Long   and condition ==  1.0 and condition ==  1.1 shortTP1     = tp1Short  and condition == -1.0 and condition == -1.1 // ——————————— { // if strategy.position_size <= 0 and longE and barstate.isconfirmed     strategy.entry(       'Long',       strategy.long,       alert_message    = i_leMsg,       comment          = 'LE') if strategy.position_size > 0 and condition ==  1.0     strategy.exit(       id               = 'LXTP1',       from_entry       = 'Long',       qty_percent      = i_lxQtyTP1,       limit            = tp1Line,       stop             = slLine,       comment_profit   = 'LXTP1',       comment_loss     = 'SL',       alert_profit     = i_lxMsgTP1,       alert_loss       = i_lxMsgSL) if strategy.position_size > 0 and condition ==  1.1     strategy.exit(       id               = 'LXTP2',       from_entry       = 'Long',       qty_percent      = i_lxQtyTP2,       limit            = tp2Line,       stop             = slLine,       comment_profit   = 'LXTP2',       comment_loss     = 'SL',       alert_profit     = i_lxMsgTP2,       alert_loss       = i_lxMsgSL) if strategy.position_size > 0 and condition ==  1.2     strategy.exit(       id               = 'LXTP3',       from_entry       = 'Long',       qty_percent      = i_lxQtyTP3,       limit            = tp3Line,       stop             = slLine,       comment_profit   = 'LXTP3',       comment_loss     = 'SL',       alert_profit     = i_lxMsgTP3,       alert_loss       = i_lxMsgSL) if longX     strategy.close(       'Long',       alert_message    = i_lxMsg,       comment          = 'LX') // if strategy.position_size >= 0 and shortE and barstate.isconfirmed     strategy.entry(       'Short',       strategy.short,       alert_message    = i_leMsg,       comment          = 'SE') if strategy.position_size < 0 and condition == -1.0     strategy.exit(       id               = 'SXTP1',       from_entry       = 'Short',       qty_percent      = i_sxQtyTP1,       limit            = tp1Line,       stop             = slLine,       comment_profit   = 'SXTP1',       comment_loss     = 'SL',       alert_profit     = i_sxMsgTP1,       alert_loss       = i_sxMsgSL) if strategy.position_size < 0 and condition == -1.1     strategy.exit(       id               = 'SXTP2',       from_entry       = 'Short',       qty_percent      = i_sxQtyTP2,       limit            = tp2Line,       stop             = slLine,       comment_profit   = 'SXTP2',       comment_loss     = 'SL',       alert_profit     = i_sxMsgTP2,       alert_loss       = i_sxMsgSL) if strategy.position_size < 0 and condition == -1.2     strategy.exit(       id               = 'SXTP3',       from_entry       = 'Short',       qty_percent      = i_sxQtyTP3,       limit            = tp3Line,       stop             = slLine,       comment_profit   = 'SXTP3',       comment_loss     = 'SL',       alert_profit     = i_sxMsgTP3,       alert_loss       = i_sxMsgSL) if shortX     strategy.close(       'Short',       alert_message    = i_sxMsg,       comment          = 'SX') // ——————————— c_tp         = leTrigger or seTrigger ? na :                condition == 0.0       ? na : color.green c_entry      = leTrigger or seTrigger ? na :                condition == 0.0       ? na : color.blue c_sl         = leTrigger or seTrigger ? na :                condition == 0.0       ? na : color.red p_tp1Line    = plot (   condition ==  1.0 or   condition == -1.0 ? tp1Line : na,   title      = "TP Line 1",   color      = c_tp,   linewidth  = 1,   style      = plot.style_linebr) p_tp2Line    = plot (   condition ==  1.0 or   condition == -1.0 or   condition ==  1.1 or   condition == -1.1 ? tp2Line : na,   title      = "TP Line 2",   color      = c_tp,   linewidth  = 1,   style      = plot.style_linebr) p_tp3Line    = plot (   condition ==  1.0 or   condition == -1.0 or   condition ==  1.1 or   condition == -1.1 or   condition ==  1.2 or   condition == -1.2 ? tp3Line : na,   title      = "TP Line 3",   color      = c_tp,   linewidth  = 1,   style      = plot.style_linebr) p_entryLine  = plot (   condition >=  1.0 or   condition <= -1.0 ? entryLine : na,   title      = "Entry Line",   color      = c_entry,   linewidth  = 1,   style      = plot.style_linebr) p_slLine     = plot (   condition ==  1.0 or   condition == -1.0 or   condition ==  1.1 or   condition == -1.1 or   condition ==  1.2 or   condition == -1.2 ? slLine : na,   title      = "SL Line",   color      = c_sl,   linewidth  = 1,   style      = plot.style_linebr) fill(   p_tp3Line, p_entryLine,   color      = leTrigger or seTrigger ? na :color.new(color.green, 90)) fill(   p_entryLine, p_slLine,   color      = leTrigger or seTrigger ? na :color.new(color.red, 90)) // plotshape(   i_alertOn and longE,   title      = 'Long',   text       = 'Long',   textcolor  = color.white,   color      = color.green,   style      = shape.labelup,   size       = size.tiny,   location   = location.belowbar) plotshape(   i_alertOn and shortE,   title      = 'Short',   text       = 'Short',   textcolor  = color.white,   color      = color.red,   style      = shape.labeldown,   size       = size.tiny,   location   = location.abovebar) plotshape(   i_alertOn and (longX or shortX) ? close : na,   title      = 'Close',   text       = 'Close',   textcolor  = color.white,   color      = color.gray,   style      = shape.labelup,   size       = size.tiny,   location   = location.absolute) l_tp         = i_alertOn and (longTP1 or shortTP1) ? close : na plotshape(   l_tp,   title      = "TP1 Cross",   text       = "TP1",   textcolor  = color.white,   color      = color.olive,   style      = shape.labelup,   size       = size.tiny,   location   = location.absolute) plotshape(   i_alertOn and (longTP2 or shortTP2) ? close : na,   title      = "TP2 Cross",   text       = "TP2",   textcolor  = color.white,   color      = color.olive,   style      = shape.labelup,   size       = size.tiny,   location   = location.absolute) plotshape(   i_alertOn and (longTP3 or shortTP3) ? close : na,   title      = "TP3 Cross",   text       = "TP3",   textcolor  = color.white,   color      = color.olive,   style      = shape.labelup,   size       = size.tiny,   location   = location.absolute) plotshape(   i_alertOn and (longSL or shortSL) ? close : na,   title      = "SL Cross",   text       = "SL",   textcolor  = color.white,   color      = color.maroon,   style      = shape.labelup,   size       = size.tiny,   location   = location.absolute) // plot(   na,   title      = "─── ───",   editable   = false,   display    = display.data_window) plot(   condition,   title      = "condition",   editable   = false,   display    = display.data_window) plot(   strategy.position_size * 100,   title      = ".position_size",   editable   = false,   display    = display.data_window) //#endregion } // ——————————— <↑↑↑ G_RISK ↑↑↑> //#region ———— <↓↓↓ G_SCRIPT02 ↓↓↓> { // @function        Queues a new element in an array and de-queues its first element. f_qDq(_array, _val) =>     array.push(_array, _val)     _return = array.shift(_array)     _return var line  a_slLine     = array.new_line(1) var line  a_entryLine  = array.new_line(1) var line  a_tp3Line    = array.new_line(1) var line  a_tp2Line    = array.new_line(1) var line  a_tp1Line    = array.new_line(1) var label a_slLabel    = array.new_label(1) var label a_tp3label   = array.new_label(1) var label a_tp2label   = array.new_label(1) var label a_tp1label   = array.new_label(1) var label a_entryLabel = array.new_label(1) newEntry     = longE or shortE entryIndex   = 1 entryIndex  := newEntry ? bar_index : nz(entryIndex ) lasTrade     = bar_index >= entryIndex l_right      = 10 line.delete(   f_qDq(a_slLine,   line.new(    entryIndex,    slLine,    last_bar_index + l_right,    slLine,    style = line.style_solid,    color = c_sl))) line.delete(   f_qDq(a_entryLine,   line.new(    entryIndex,    entryLine,    last_bar_index + l_right,    entryLine,    style = line.style_solid,    color = color.blue))) line.delete(   f_qDq(a_tp3Line,   line.new(    entryIndex,    tp3Line,    last_bar_index + l_right,    tp3Line,    style = line.style_solid,    color = c_tp))) line.delete(   f_qDq(a_tp2Line,   line.new(    entryIndex,    tp2Line,    last_bar_index + l_right,    tp2Line,    style = line.style_solid,    color = c_tp))) line.delete(   f_qDq(a_tp1Line,   line.new(    entryIndex,    tp1Line,    last_bar_index + l_right,    tp1Line,    style = line.style_solid,    color = c_tp))) label.delete(   f_qDq(a_slLabel,   label.new(    last_bar_index + l_right,    slLine,    'SL: ' + str.tostring(slLine, '##.###'),    style = label.style_label_left,    textcolor  = color.white,    color = c_sl))) label.delete(   f_qDq(a_entryLabel,   label.new(    last_bar_index + l_right,    entryLine,    'Entry: ' + str.tostring(entryLine, '##.###'),    style = label.style_label_left,    textcolor  = color.white,    color = color.blue))) label.delete(   f_qDq(a_tp3label,   label.new(    last_bar_index + l_right,    tp3Line,    'TP3: ' + str.tostring(tp3Line, '##.###'),    style = label.style_label_left,    textcolor  = color.white,    color = c_tp))) label.delete(   f_qDq(a_tp2label,   label.new(    last_bar_index + l_right,    tp2Line,    'TP2: ' + str.tostring(tp2Line, '##.###'),    style = label.style_label_left,    textcolor  = color.white,    color = c_tp))) label.delete(   f_qDq(a_tp1label,   label.new(    last_bar_index + l_right,    tp1Line,    'TP1: ' + str.tostring(tp1Line, '##.###'),    style = label.style_label_left,    textcolor  = color.white,    color = c_tp))) // ——————————— // if longE or shortE or longX or shortX     alert(message = 'Any Alert',   freq = alert.freq_once_per_bar_close) if longE     alert(message = 'Long Entry',  freq = alert.freq_once_per_bar_close) if shortE     alert(message = 'Short Entry', freq = alert.freq_once_per_bar_close) if longX     alert(message = 'Long Exit',   freq = alert.freq_once_per_bar_close) if shortX     alert(message = 'Short Exit',  freq = alert.freq_once_per_bar_close) //#endregion } // ——————————— <↑↑↑ G_SCRIPT03 ↑↑↑>
Penunjuk Pine Script®
oleh asalya1690-90
1
UT Bot Alerts with R-Targets & Results< DONE BY RM ALOWAIS > Indicator Overview This indicator provides rule-based BUY and SELL signals with automatic risk management levels. Each trade setup includes a predefined Stop Loss and up to three Take Profit targets (TP1, TP2, TP3), allowing traders to manage risk and scale exits systematically. How It Works BUY and SELL signals are generated based on internal market conditions. Each signal plots: Entry point Stop Loss (SL) Take Profit levels (TP1, TP2, TP3) After price action completes, the indicator displays the actual result of the trade: Result: TP1 / TP2 / TP3 / SL Exit labels may appear when a trade is closed early due to invalidation or opposite conditions. Key Features Non-repainting signals Built-in risk-to-reward structure Visual trade tracking with clear outcomes Suitable for intraday and swing trading Works on multiple markets and timeframes Usage Notes This indicator is a decision-support tool, not financial advice. Best results are achieved when used with proper risk management and higher-timeframe confirmation. Performance may vary depending on market conditions (trend vs range). Disclaimer This script is provided for educational and informational purposes only. The author is not responsible for any financial losses. Always test and validate before using in live trading.
Penunjuk Pine Script®
oleh RMALOWAIS
2
Alpha Accumulator v3.4OVERVIEW Alpha Accumulator is an intelligent accumulation strategy that outperforms traditional Dollar-Cost Averaging (DCA) by deploying capital proportionally to market dip severity. Instead of buying the same amount every week regardless of price, Alpha Accumulator "starves" small pullbacks and "feasts" on corrections. The core philosophy: When the market gives you a real opportunity, take it seriously. HOW IT WORKS For Example: Traditional DCA: Buy $100 every week, no matter what. Alpha Accumulator: Buy based on how deep the dip is. ┌─────────────────┬───────────────┬─────────────────┐ │ Market Dip │ DCA Buys │ Alpha Buys │ ├─────────────────┼───────────────┼─────────────────┤ │ -5% pullback │ $100 │ $200 (2x) │ │ -10% correction│ $100 │ $1200 (12x) │ │ -16% deep dip │ $100 │ $3800 (38x) │ └─────────────────┴───────────────┴─────────────────┘ The result? Lower average cost, higher returns, same or similar total capital deployed. KEY FEATURES ⯁ SMART DIP DETECTION Combines multiple technical signals to identify high-probability accumulation zones: • Volume spike confirmation (panic selling = opportunity) • Volatility expansion (ATR/StdDev spike) • Price below EMAs (discount to trend) • Bearish structure (EMA20 < EMA50) ⯁ AUTO-DETECT SYMBOL PROFILES Automatically selects optimized multipliers based on your chart: • 🔵 SPY: Low volatility → Higher multipliers (fewer signals, must capitalize) • 🟢 QQQ: Medium volatility → Balanced multipliers • 🔴 SMH: High volatility → Lower multipliers (more frequent signals) 10-TIER MULTIPLIER SYSTEM ⯁ PROFESSIONAL METRICS DASHBOARD Real-time comparison between Alpha Accumulator and traditional DCA: • CAGR (Compound Annual Growth Rate) - Time-weighted returns • Sortino Ratio - Risk-adjusted performance • Maximum Drawdown - Worst decline experienced • Capital Ratio - How much capital deployed vs DCA • Cost Advantage - Average cost basis improvement MULTIPLIER PROFILES The indicator includes 9 pre-built profiles for different risk tolerances: SYMBOL-SPECIFIC (Auto-detected): • SPY Optimized • QQQ Optimized • SMH Optimized GENERIC PROFILES: • Conservative - Cap ~1.0x, Max 35x (Match DCA capital) • Balanced - Cap ~1.2x, Max 45x • CAGR Balanced - Cap ~1.5x, Max 50x • Aggressive - Cap ~1.8x, Max 60x • CAGR Optimized - Cap ~2.0x, Max 65x • Custom - Define your own 10-tier multiplier ladder VISUAL SIGNALS 🔵 Blue Triangle = STARVE signal (low multiplier, small buy) 🟠 Orange Triangle = RAMP signal (medium multiplier) 🟡 Yellow Triangle = TRANSITION signal 🟢 Green Triangle = FEAST signal (high multiplier, big buy) 💚 Bright Green = MAX FEAST signal (maximum deployment) Each signal displays: • Current multiplier (e.g., "12.5x") • Dollar amount to deploy • Entry price SETTINGS GUIDE DIP FINDER SETTINGS (Match to your Dip Finder indicator): • Vol Lookback: 65 (bars for volume average) • Vol Spike: 2.0x (volume must exceed this multiple) • Fast/Slow EMA: 20/50 • Volatility Len: 14 • Dip %: 2.0% (minimum price drop) • Min Gap: 5 bars (cooldown between signals) STRATEGY SETTINGS: • DCA Buy Amount: Your regular DCA amount (e.g., $100/week) • Base Lump-Sum: Base amount for Alpha signals (multiplied by tier) • Start Date: Backtest start date INTERPRETING RESULTS The results table shows head-to-head comparison: ✅ ALPHA WINS when: • Higher CAGR (better returns) • Higher Sortino (better risk-adjusted returns) • Lower Avg Cost (buying at better prices) • Positive Cost Advantage % 📊 CAP RATIO explained: • 1.0x = Alpha deployed same capital as DCA • 0.5x = Alpha deployed half the capital • 1.5x = Alpha deployed 50% more capital 🎯 IDEAL SETUP: • Cap Ratio: 0.9x - 1.3x (similar capital to DCA) • Cost Advantage: +5% to +15% • CAGR Outperformance: +1% to +5% █ BEST PRACTICES 1. MATCH YOUR DIP FINDER If you use a separate Dip Finder indicator, match its settings here for consistency. 2. SET REALISTIC BASE AMOUNTS Base Lump-Sum × Max Multiplier = Maximum single buy 3. HAVE CAPITAL READY Alpha Accumulator requires available capital when signals fire. Keep a "dry powder" reserve for deep corrections. 4. TRUST THE SIGNALS The system is designed to deploy heavily in corrections. If you can't stomach a higher buy during a crash, lower your base amount. 5. LONG-TERM MINDSET Best results come from multi-year holding periods. This is an accumulation strategy, not a trading system. ALERTS Set up alerts to never miss a signal: • "Buy Signal" - Triggers on every valid dip signal • Includes: Symbol, Price, Multiplier, Dollar Amount, Shares to Buy • Bot-friendly JSON format for automated trading DISCLAIMER This indicator is for educational purposes only. Past performance does not guarantee future results. Always do your own research and never invest more than you can afford to lose. The multiplier system can result in very large position sizes during market corrections - ensure you have appropriate risk management in place. Developed by Sahebson Built for long-term accumulators who believe in buying fear
Penunjuk Pine Script®
oleh Sahebson
EMA - SHORT (8/20)EMA SHORT (8/20) trades only the short side by waiting for bearish regime alignment and then capturing continuation once momentum confirms. It ignores long signals entirely and filters out sideways chop or late entries. Built to: ✔ Confirm bearish direction ✔ Avoid compression phases ✔ Filter weak flips ✔ Simulate short execution visually ✔ Enable automation via Webhooks Ideal for: Futures traders (short bias) Breakout & momentum traders Signal providers Copy-trading systems Bot builders Works across timeframes from scalping to swing, with strong performance in futures, crypto, and FX.
Penunjuk Pine Script®
oleh Boccalandro
EMA - LONG (8/20)EMA LONG (8/20) trades only the long side by waiting for bullish regime alignment and then capturing continuation after momentum confirms. It ignores short signals entirely and avoids early flip entries, focusing on cleaner post-flip continuation legs. Designed to: ✔ Filter out sideways compression ✔ Avoid counter-trend shorts ✔ Confirm long-side momentum ✔ Simulate entries/exits visually ✔ Enable alerts for automation Works across timeframes and instruments, with strong use cases in futures, crypto, and FX. Ideal for: Trend continuation traders Long-biased futures traders Bot automation / signal providers Copy trading setups
Penunjuk Pine Script®
oleh Boccalandro
Precision Trend Signal V5Strategy Logic OverviewThis indicator is a "Triple-Confirmation" trend-following system. It combines volume-weighted smoothing, immediate price action, and momentum filtering.1. Core ComponentsEMA 1 (The Trigger): Since the period is set to 1, this represents the raw price action. It acts as the fastest possible trigger to capture entries at the exact moment a trend shifts.SALMA (The Baseline): This is a double-smoothed moving average. It provides a stabilized support/resistance line that filters out market noise better than a standard SMA.Tillson T3 (The Trend Filter): Known for its low lag and extreme smoothness. We use this as a "Guardrail." We only take BUY signals when price is above the T3 and SELL signals when price is below it.RSI (The Momentum Filter): Ensures that we only enter a trade when there is sufficient strength ($> 50$ for Long, $< 50$ for Short).2. Signal Rules🚀 BUY SignalA green BUY label appears when:Crossover: EMA 1 crosses above the SALMA line.Trend: The current price is trading above the Tillson T3 line.Momentum: RSI is greater than 50.🔻 SELL SignalA red SELL label appears when:Crossunder: EMA 1 crosses below the SALMA line.Trend: The current price is trading below the Tillson T3 line.Momentum: RSI is less than 50.3. Execution & ManagementTake Profit (TP): Based on your preference, the suggested target is 2%.Alerts: The script includes alertcondition functions. You can set up TradingView alerts to send Webhooks to your quant infrastructure or bot, solving the "manual execution" problem you mentioned.
Penunjuk Pine Script®
oleh Oguzbey07
Crash Prevention OpenSource by exp3rtsOpen Source Version - no updates! Crash Prevention OpenSource by exp3rts – Automated Exit Strategy for TradingView This indicator allows you to automatically close positions based on dynamic price levels derived from the previous candle with a configurable offset. Perfect for risk management and automated “hard stop” exits. Key Features: Flexible Exit Directions: Choose to trigger exits for Long, Short, or Both directions. Dynamic Exit Levels: Lines are automatically calculated above/below the previous candle plus/minus a user-defined offset in points. Visual Cues: Clear arrows indicate the exact bar where price touched the exit line. Session-Independent: Works on any chart and timeframe without manual adjustments. Webhook Alerts: Sends JSON alerts on touch, enabling integration with external systems or bots. Auto-Close Logic: Ensures positions are closed immediately when the threshold is breached, keeping trades in check. How it works: For Long exits, the line is drawn below the previous bar’s low minus the offset. For Short exits, the line is drawn above the previous bar’s high plus the offset. When price crosses the line, the position is closed, an arrow is plotted on the chart, and an alert is fired. Ideal for traders who want strict stop management or automated exit conditions while keeping visual clarity on the chart.
Penunjuk Pine Script®
oleh exp3rts
Kalman Absorption/Distribution Tracker (1 Second)The Microstructure Revolution: Kalman Filtering and the Physics of Order Flow The evolution of technical analysis has historically been constrained by the limitations of available data and the processing power required to interpret it. For decades, retail traders have relied on indicators derived from Open, High, Low, and Close prices—metrics that are inherently reactive and fundamentally lagging. While these tools can effectively map the history of market movement, they often fail to capture the immediate, aggressive intent that dictates future price action. The financial markets are not merely a sequence of price prints; they are a continuous, high-velocity auction where liquidity is provided and consumed in milliseconds. To truly understand the mechanics of price delivery, one must look beyond the candlestick and into the microstructure of the order flow itself. The Kalman Absorption/Distribution Tracker, specifically designed to operate on 1-second intrabar intervals, represents a paradigm shift in this analytical approach. It abandons the simplistic smoothing of moving averages in favor of a state-space model that applies aerospace-grade signal processing to the chaotic environment of high-frequency market data. At the core of this concept is the understanding that volume alone is insufficient; it is the relationship between aggressive volume and price displacement that reveals the hand of institutional participants. Traditional volume analysis is often binary, categorizing bars as simply "up" or "down," a method that obscures the nuances of the battle taking place within the timeframe. By drilling down to the 1-second level, this script effectively bypasses the limitations of time-based charting, treating the market stream almost as a tick chart. In this granular domain, the noise is immense. Algorithms, high-frequency trading bots, and market makers generate a blizzard of data that can easily deceive a standard cumulative volume delta (CVD) indicator. This is where the Kalman Filter becomes indispensable. Originally developed for trajectory estimation in navigation systems, the Kalman Filter excels at separating the "signal"—the true vector of buying or selling pressure—from the "noise" of random market chatter. By estimating the velocity and position of order flow in real-time, the tracker provides a smoothed yet highly responsive visualization of market intent, allowing traders to discern between genuine momentum and the deceptive phenomena of absorption and distribution. The shift to 1-second intrabar resolution transforms the nature of the data being analyzed. In a standard 1-minute or 5-minute timeframe, the internal battle is aggregated into a single bar, hiding the specific sequence of events. A candle might close green, looking bullish, but the 1-second data might reveal that 90% of the buying occurred in the first ten seconds, followed by fifty seconds of passive selling that absorbed all further upside attempts. The 1-second processing logic implemented in this script utilizes a "Close-to-Close" methodology, which acts as a pseudo-tick reader. If the price of the current second is higher than the previous second, the volume is classified as aggressive buying; if lower, aggressive selling. This granularity offers a near-perfect correlation with true bid/ask data, providing the trader with an X-ray view of the auction. This level of detail is crucial because institutional accumulation and distribution rarely happen in obvious, large-block trades that spike volume histograms. Instead, they occur in a steady stream of smaller, algorithmic executions designed to mask intent. The 1-second granularity catches these footprints that larger timeframes simply average out. A critical innovation within this framework is the handling of "flat ticks"—moments where volume executes but price remains unchanged. In the world of microstructure, these moments are often the most significant. When aggressive buying volume pours into the market but price refuses to tick higher, it signifies the presence of a "limit wall" or a passive seller absorbing the demand. Standard indicators often discard this data or split it arbitrarily. This script, however, offers advanced logic to assign this volume based on the previous tick's direction, recognizing that in a high-velocity momentum move, a flat tick is often a continuation of the immediate aggressor's effort meeting temporary resistance. By accurately categorizing this "effort without result," the script identifies Absorption with pinpoint accuracy. It flags the precise moment when the laws of supply and demand seemingly break—when effort (volume) fails to produce a result (price change)—alerting the trader to a potential reversal or exhaustion point long before the price pattern confirms it. The concept of "Market Efficiency Benchmarking" serves as the analytical engine driving the script’s diagnostic capabilities. The market is not a static environment; liquidity conditions change depending on the time of day, the asset class, and the prevailing volatility regime. A 500-contract buy order might shatter resistance during the Asian session but barely move the needle during the New York open. To account for this, the tracker calculates a dynamic "Price per CVD" metric, effectively learning the current exchange rate between volume and price displacement. It utilizes an exponential decay mechanism to maintain a rolling baseline of market efficiency. By constantly asking, "How much price movement should this amount of volume create?", the script establishes a standard of normalcy. When the market deviates from this standard—for example, when a massive surge in buying velocity results in minimal price gain—the script registers a Distribution event. Conversely, when selling pressure evaporates into a stable price, it registers Absorption. This dynamic benchmarking ensures that the tool remains robust and adaptive, requiring less manual tuning as market conditions shift. The Kalman Filter’s role in this process is to calculate the "velocity" of the order flow. While cumulative volume delta (CVD) tells you the position of buyers versus sellers (who has bought more in total), the Kalman velocity tells you the rate of change of that aggression. This is analogous to the difference between a car’s odometer and its speedometer. In trading, the speed of the move matters. A slow, grinding move upward suggests a lack of aggressive selling, while a rapid vertical spike suggests an emotional imbalance. The script detects these velocity shifts instantly. When the velocity exceeds a specific threshold, the system enters a "Trend State." It is during these states that the benchmarking logic is most active, comparing the predicted price trajectory against reality. If the velocity is high but the price lags behind the Kalman prediction, the divergence is mathematically quantified. This removes the subjectivity from reading divergence; instead of "eyeballing" a chart, the trader receives a definitive, data-driven signal that the current trend is unhealthy. The visual interface of the tracker, the dashboard, is designed to synthesize this complex data into actionable intelligence. Trading is a game of context, and a single signal in isolation is often meaningless. The dashboard provides a multi-day memory, aggregating events from "Today," "Yesterday," and "Day Before (D-2)." This temporal perspective is vital because institutional campaigns often span several days. A single day of distribution might be a pause in a trend, but three consecutive days of distribution events in a rising market constitute a screaming warning sign of a reversal. The dashboard tracks "Confirmed" events (where price moves in harmony with volume) and "Hidden" events (Absorption/Distribution). By calculating the "Net" counts for each day, the script offers a directional bias summary. If the "Hidden Net" is positive, it implies that passive buyers are accumulating positions, supporting the trend. If negative, it implies smart money is using liquidity to exit. This high-level view allows the trader to align their intraday execution with the broader structural narrative of the market. One of the most powerful metrics presented on the dashboard is the "Ease of Movement" ratio. Derived from Wyckoff logic, this ratio compares the efficiency of buyers versus sellers. If the script calculates that it takes 1,000 contracts of buying to move the price 5 points, but 1,000 contracts of selling only moves it 2 points, the ratio reveals a fundamental asymmetry. The path of least resistance is up. This metric allows traders to filter their setups with a bias toward the "easier" side of the market. Even if a short setup presents itself technically, a high Ease of Movement ratio warns that the trade will be fighting against the market’s internal physics. This insight is invaluable for risk management, helping traders avoid "choppy" trades and focus on high-probability expansions where price and volume are working in concert. The granularity of the 1-second data also necessitates a discussion on the "State Change" counter. In a healthy, trending market, the Kalman state should remain relatively stable, holding a bullish or bearish velocity for extended periods. However, in a volatile, indecisive market, the state may flip rapidly back and forth. The "State Changes" metric quantifies this turbulence. A high number of state changes relative to the time elapsed indicates a "choppy" or "balanced" auction where neither side has seized control. This is an environment that destroys trend-following strategies. By observing this counter, a trader can gauge the "texture" of the market volatility. Is the market flowing smoothly, or is it erratic? This allows for dynamic strategy adjustment—tightening stops in high-state-change environments or letting winners run when the state is stable. The practical application of this tool requires a nuanced understanding of the four primary events it detects: Confirmed Bullish, Confirmed Bearish, Absorption, and Distribution. A "Confirmed" event is the market functioning efficiently. Aggressive buyers step in, velocity spikes, and price expands proportionally. These are the waves traders want to ride. They signify agreement between aggressive and passive participants. However, the edge lies in identifying the anomalies. An "Absorption" event (Cyan on the dashboard) often marks the bottom of a pullback. It visually represents the moment when sellers run out of ammunition or hit a limit buy wall. Seeing a cluster of Absorption events at a key support level provides the confidence to enter a long position with a tight stop, knowing that the structural support is real, not just a line on a chart. Conversely, "Distribution" (Orange) at highs is the hallmark of a "bull trap." Retail traders see the breakout and buy, but the tracker sees that the buying volume is not translating into price distance, indicating that a larger player is feeding the bulls their exit liquidity. The "Current State" section of the dashboard brings this analysis into the immediate present. It functions as a real-time monitor for the active candle or swing. By projecting an "Expected Price" based on the accumulated CVD of the current move, it gives the trader a live performance review of the trend. If the actual price is trading below the expected price during an uptrend, the text will flash "Distribution Risk." This is a leading indicator in the truest sense. It warns the trader before the candle closes, before the moving average crosses, and before the price structure breaks. This latency advantage is the primary benefit of the Kalman filter’s predictive capability. It allows for proactive trade management—taking partial profits as distribution appears, rather than waiting for the market to reverse and stop out the trade. It is important to acknowledge the technical sophistication required to run such a script. Processing 1-second arrays for an entire trading session pushes the Pine Script engine to its limits. The sheer volume of data points—tens of thousands per session—requires efficient coding and array management to prevent timeouts. This complexity is the barrier to entry that keeps such analysis out of the hands of the casual amateur. It is a tool for the serious market participant who understands that the quality of their output is dependent on the resolution of their input. The script’s ability to handle this data load and persist the calculations across sessions using var variables demonstrates a mastery of the platform’s capabilities, turning TradingView into a workstation that rivals professional institutional terminals. The psychological impact of using the Kalman Absorption/Distribution Tracker cannot be overstated. Uncertainty is the root of emotional error in trading. When a trader buys a pullback, the fear of the price continuing to drop is palpable. However, if that trader has quantitative evidence that selling pressure is being absorbed—if they can see the "Hidden Net" turning positive and the Kalman velocity slowing down despite the red candles—that fear is replaced by conviction. The tool acts as an objective third party, decoupling the decision-making process from the emotional sway of price ticks. It anchors the trader in the reality of the order flow. It fosters a mindset of "buying strength in weakness" and "selling weakness in strength," which is the antithesis of the typical retail urge to chase price. Furthermore, the adaptability of the script through its inputs allows it to be tuned to specific assets. The "Alpha" and "Beta" settings of the Kalman filter control its sensitivity. A higher Alpha makes the filter more responsive to recent price changes, suitable for scalping volatile assets like cryptocurrencies. A lower Alpha smooths the data further, ideal for capturing broader trends in thicker markets like the ES or Treasuries. The "Price Follow Threshold" allows the user to define what constitutes "efficiency" for a specific instrument. By tweaking these parameters, the trader effectively calibrates their radar to the specific frequency of the market they are trading, ensuring that the signals generated are relevant and actionable. This customizability ensures that the tool is not a black box but a transparent framework for market analysis. The distinction between "Confirmed Net" and "Hidden Net" on the dashboard offers a dual-layer view of market sentiment. "Confirmed Net" tracks the visible trend—the moves that everyone sees. A high positive Confirmed Net means the trend is healthy and obvious. "Hidden Net," however, tracks the invisible war. A divergence between these two is a powerful signal. For instance, if the market is grinding higher (Positive Confirmed Net) but the Hidden Net is deeply negative (Distribution), it indicates a "hollow rally." The price is rising due to a lack of selling, not the presence of strong buying, and passive sellers are unloading into the move. This setup often precedes a violent correction. Identifying this "hollow" structure allows the trader to avoid buying the top or to position themselves for a mean reversion trade. The 1-second granularity also shines during news events and the market open. These periods are characterized by extreme volatility and noise. Standard indicators often blow out or provide false signals during these times due to the sheer magnitude of the variance. The Kalman filter, however, is designed to handle noisy data streams. By dynamically adjusting its state estimates, it can track the dominant flow of capital even through the chaos of an FOMC release or the opening bell. The "Close-to-Close" logic ensures that every tick is accounted for, providing a cumulative picture of who won the opening battle. If the first minute of the session sees high volatility but the script registers massive "Absorption," it suggests that the initial volatility was a liquidity grab, setting the stage for a steady move in the opposite direction. Ultimately, the Kalman Absorption/Distribution Tracker is more than just a technical indicator; it is a philosophy of market engagement. It rejects the notion that price is the only truth, arguing instead that price is the result of a negotiation between aggression and liquidity. By quantifying this negotiation with the precision of 1-second intervals and the mathematical rigor of Kalman filtering, it provides a window into the "why" behind the move. It transforms the chart from a historical record of what happened into a real-time display of what is happening now. For the trader with the right mindset—one who values process over prediction and risk management over gambling—this tool offers a significant edge. It does not promise to predict the future, but it offers the most accurate possible description of the present. In the zero-sum game of trading, having a clearer, faster, and more detailed view of the battlefield is often the deciding factor between profitability and ruin. The script bridges the gap between the retail trader and the institutional algorithm, democratizing access to high-frequency order flow analysis and empowering the user to make decisions based on the structural reality of the market rather than the deceptive surface of price action. It is a testament to the power of modern scripting languages and a valuable addition to the arsenal of any serious technical analyst. # Trading View's premium subscription is required to run this script.
Penunjuk Pine Script®
oleh jaydesaigu
Pressure Reversal Engine - Scalp [BullByte]PRESSURE REVERSAL ENGINE - SCALP OVERVIEW Pressure Reversal Engine - Scalp is a professional reversal indicator built for scalping and active trading on any market including Forex, CFDs, crypto, and stocks. This multi-engine buy sell signal system works without volume data, making it ideal for instruments where volume is unavailable or unreliable. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ THE PROBLEM THIS INDICATOR SOLVES Traditional reversal indicators and buy sell signal systems often struggle with: - Dependence on volume data (unavailable for Forex pairs, CFD instruments, and many markets) - Single-indicator approaches that generate excessive false signals and noise - Static parameters that fail to adapt to changing volatility conditions - Lack of confluence validation across multiple analytical dimensions PRE Scalp addresses these limitations through a six-engine confluence architecture. Signals generate only when multiple independent analytical engines align, filtering noise while identifying potential reversal conditions across any timeframe. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ DEVELOPMENT APPROACH - MULTI-ENGINE ARCHITECTURE - NOT A MASHUP The Pressure Reversal Engine was developed to address specific limitations observed in traditional reversal detection and scalping indicator methods: Challenge 1: Volume Dependency Most reversal indicators require volume data, which is unreliable or unavailable for Forex, CFDs, indices, and many international instruments. The SAI engine was specifically designed to derive activity measurements purely from price action and candle structure. Challenge 2: Single-Dimension Analysis Individual indicators measuring only one aspect of price action generate excessive false signals. The multi-engine confluence approach requires confirmation across six independent analytical dimensions before generating buy or sell signals. Challenge 3: Static Parameters Fixed lookback periods fail during changing volatility conditions. The AVR engine dynamically adapts all parameters based on current market state, improving signal quality across different market environments. Challenge 4: Subjective Pattern Recognition Visual pattern identification is subjective and inconsistent. The DNA engine provides objective mathematical pattern matching with quantifiable scores for reversal candle detection. Each engine addresses a specific analytical dimension. The confluence requirement emerged from observation that aligned signals across multiple engines produced significantly higher quality reversal identification than any single method. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ THE SIX ANALYTICAL ENGINES EXPLAINED Each engine provides a unique analytical perspective. Buy and sell signals generate only when multiple engines confirm confluence: ENGINE 1: SYNTHETIC ACTIVITY INDEX (SAI) - Volumeless Activity Detection Purpose: Derives market activity from price structure without requiring volume data. Essential for Forex trading, CFD analysis, and any instrument lacking reliable volume. Calculation: Weighted composite of range expansion, body momentum, directional pressure, wick rejection, price acceleration, and volatility burst measurements. Formula: SAI = (RangeExpansion x 0.25) + (BodyMomentum x 0.20) + (DirectionalPressure x 0.15) + (WickRejection x 0.15) + (PriceAcceleration x 0.15) + (VolatilityBurst x 0.10) Signal Contribution: Validates that meaningful market activity is occurring at the potential reversal point. Without activity confirmation, apparent reversals may lack follow-through. ENGINE 2: PRESSURE WAVE OSCILLATOR (PWO) - Exhaustion Detection Purpose: Measures the balance between buying pressure and selling pressure through price geometry analysis. Calculation: Net pressure (buying minus selling) weighted by activity level, normalized by standard deviation over extended period. Formula: PWO = SMA(NetPressure x SAI, length) / StdDev(cumulative, length x 2) Signal Contribution: Identifies pressure exhaustion conditions using percentile ranking to detect when buyers or sellers are running out of momentum. Exhaustion often precedes trend reversal. ENGINE 3: FRACTAL CONFLUENCE MATRIX (FCM) - Multi-Timeframe Structure Analysis Purpose: Analyzes price position across multiple structural timeframes simultaneously for multi-timeframe confluence. Calculation: Evaluates price position within range at five Fibonacci-based periods (5, 8, 13, 21, 34 bars). These periods capture nested market structures from micro to macro. Formula: FractalPosition = (Close - LowestLow) / (HighestHigh - LowestLow) at each period Signal Contribution: Confirms that multiple structural levels align at extremes, indicating potential reversal zones where larger and smaller timeframes agree on price position. ENGINE 4: ENTROPIC EXHAUSTION DETECTOR (EED) - Information Theory Analysis Purpose: Applies Shannon entropy from information theory to measure market disorder and directional exhaustion. Calculation: Shannon entropy of bullish/bearish bar distribution over the lookback period. Formula: H = -Sum(p(x) x log2(p(x))) where p(x) is probability of bullish or bearish bars Range: 0 (complete order, all bars same direction) to 1 (maximum disorder, 50/50 distribution) Signal Contribution: High entropy combined with a directional streak breaking suggests the market has reached maximum uncertainty and may resolve in a new direction. ENGINE 5: CANDLE DNA FINGERPRINTING - Pattern Recognition System Purpose: Mathematical pattern recognition comparing current candle structure against ideal reversal patterns including hammer, shooting star, and engulfing formations. Calculation: Weighted similarity scoring across body ratio, upper wick ratio, lower wick ratio, close position, and range versus ATR. Formula: Score = Sum((1 - |actual - ideal|) x weight) for each metric Signal Contribution: Identifies candles with reversal characteristics through objective mathematical measurement rather than subjective visual pattern recognition. ENGINE 6: ADAPTIVE VOLATILITY REGIME (AVR) - Dynamic Parameter Adjustment Purpose: Dynamically adjusts all lookback parameters based on current volatility conditions for adaptive indicator behavior. Calculation: Ratio of fast ATR to slow ATR determines volatility regime classification. Formula: VolatilityRatio = ATR(fast period) / ATR(slow period) States: High volatility (ratio > 1.3) uses shorter lookbacks for faster adaptation. Low volatility (ratio < 0.7) uses longer lookbacks for noise reduction. Normal volatility maintains base parameters. Signal Contribution: Ensures the entire system adapts appropriately to current market conditions rather than using static parameters that may fail in different environments. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ WHY ENGINE SYNERGY MATTERS FOR SIGNAL QUALITY The effectiveness of PRE comes from requiring multiple engines to align before generating buy or sell signals: - SAI confirms activity is present (something meaningful is happening in price action) - PWO confirms pressure exhaustion (the current move is running out of steam) - FCM confirms structural alignment (multiple timeframes agree on position) - EED confirms disorder state (market uncertainty is elevated near potential turning point) - DNA confirms candle structure (the bar exhibits reversal pattern characteristics) - AVR ensures parameters are appropriate (system is calibrated to current volatility) A single indicator measuring one dimension generates many false signals. By requiring confluence across six independent analytical dimensions, this reversal indicator filters noise while identifying potential trading opportunities. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ SIGNAL GENERATION PROCESS FOR BUY AND SELL SIGNALS Step 1: ANCHOR DETECTION The system identifies potential reversal anchors when price breaks beyond recent structure using a mean-reversion approach. A bullish anchor forms when price breaks below prior lows, suggesting potential oversold conditions. A bearish anchor forms when price breaks above prior highs, suggesting potential overbought conditions. Step 2: ENGINE SCORING Each enabled engine contributes to a cumulative quality score. The anchor must achieve minimum scoring thresholds to activate a setup. Step 3: CONFIRMATION TRIGGER Price must confirm the setup by crossing back through the anchor zone within the confirmation window. This crossover or crossunder is validated at bar close to prevent repainting. Step 4: SIGNAL QUALITY SCORE The final buy or sell signal displays a quality score representing the total engine confluence. Higher scores indicate stronger alignment across more analytical engines. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ READING THE BUY SELL SIGNAL LABELS BUY Signal Label: - Displays "BUY" with quality score in brackets - Shows engine contribution breakdown when enabled in settings - indicates engine contributed to signal - indicates engine did not contribute - Higher total scores suggest stronger multi-engine confluence SELL Signal Label: - Displays "SELL" with quality score in brackets - Same engine breakdown format as BUY signals - Identical scoring interpretation Score Interpretation Guide: - Score 3-4: Minimum threshold met, basic confluence achieved - Score 5-6: Good confluence across multiple engines - S core 7-8: Strong confluence with most engines aligned ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ENGINE STATUS DASHBOARD - REAL-TIME ANALYSIS DISPLAY The Engine Status Panel displays real-time readings from all six analytical engines: Synthetic Activity Row: - HIGH ACTIVITY: SAI above threshold, significant price action detected (value shown) - ACTIVE: SAI above confirmation level, moderate activity present - LOW: SAI below activity thresholds, quiet market conditions - DISABLED: Engine turned off in settings Pressure Wave Row: - BULL EXHAUSTION: PWO in lower percentile tail and reversing upward, potential bottom - BEAR EXHAUSTION: PWO in upper percentile tail and reversing downward, potential top - NEUTRAL: PWO in normal range, no exhaustion detected Fractal Matrix Row: - BULL CONFLUENCE: Multiple fractal levels show price near structural lows (score shown) - BEAR CONFLUENCE: Multiple fractal levels show price near structural highs - NO CONFLUENCE: Insufficient alignment across fractal timeframe levels Entropic Exhaustion Row: - HIGH ENTROPY: Shannon entropy above threshold, maximum market disorder detected - ORDERED: Entropy below threshold, clear directional consistency present Candle DNA Row: - BULL PATTERN: Current candle matches bullish reversal profile (hammer-like structure) - BEAR PATTERN: Current candle matches bearish reversal profile (shooting star-like) - NO MATCH: Current candle does not match reversal pattern characteristics Market Regime Row: Shows DETECTED market conditions based on price action analysis: - FRESH MOVE: New directional move beginning, momentum increasing - NORMAL: Standard market conditions, no extreme factors detected - SCALP CONDITIONS: Extended move or decreasing momentum detected - CAUTION ZONE: Multiple warning factors present requiring conservative approach Note : This displays what market conditions look like, not necessarily what targets will be applied. Applied Style Row: Shows what target style is ACTUALLY being applied to trades and why: When Trade Style Setting = Auto: - RUNNER (Auto): System detected FRESH conditions, applying wide targets (0.8R, 1.8R, 3.0R) - EXTENDED (Auto): System detected NORMAL conditions, applying balanced targets (0.6R, 1.2R, 2.0R) - SCALP (Auto): System detected SCALP conditions, applying tight targets (0.4R, 0.8R, 1.2R) - CAUTION (Auto): System detected CAUTION conditions, applying very tight targets (0.3R, 0.5R, 0.8R) When Trade Style Setting = User Override: - SCALP (User): You selected Scalp style manually - EXTENDED (User): You selected Extended style manually - RUNNER (User): You selected Runner style manually This dual-row display ensures complete transparency. You always see both what market conditions exist AND what targets you are receiving. Volatility State Row: - HIGH VOLATILITY: Fast ATR significantly exceeds slow ATR, adaptive parameters shortened - NORMAL: Volatility ratio within standard range - LOW VOLATILITY: Fast ATR significantly below slow ATR, adaptive parameters extended ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ REGIME VS APPLIED STYLE - COMPLETE TRANSPARENCY The Engine Status Panel displays TWO separate rows for complete trading transparency: 1. Market Regime: What current market conditions look like based on analysis 2. Applied Style: What target calculations are actually being used for trades Why Two Separate Rows? When Trade Style is set to "Auto", the Applied Style will match the detected Regime automatically. For example: - Regime: FRESH MOVE leads to Applied Style: RUNNER (Auto) - Regime : NORMAL leads to Applied Style: EXTENDED (Auto) When you manually select a Trade Style (Scalp, Extended, or Runner), the Applied Style will show your selection regardless of the detected Regime: - Regime: FRESH MOVE but Applied Style: SCALP (User) (Market conditions look fresh, but you chose tight targets) This transparency ensures you always know: - What conditions is the market is currently showing - What targets you will you actually receive on signals - Whether the system chose automatically or you overrode the selection ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ TRADE PANEL - POSITION MANAGEMENT DISPLAY During Active Trade: - Position type (LONG/SHORT) with entry price level - Running P&L displayed in points (current price versus entry) - TP1, TP2, TP3 target levels with booking percentages for each - Current stop loss level (initial, protected, or trailing depending on trade progress) - Risk to Reward ratio (displayed before TP1 is reached) - Profit booked percentage showing locked gains - Trade status and total bars in trade count When Scanning for Signals: - Shows "SCANNING FOR SIGNALS" status message - Displays any active setup waiting for a confirmation trigger - Shows next signal TP multipliers based on the current detected regime - Indicates remaining bars in confirmation window before setup expires ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ TRADE MANAGEMENT AND RISK CONTROL FEATURES Take Profit System: - Supports 2 or 3 TP target levels for flexible exit strategy - Three calculation modes available: Auto (regime-based), Manual ATR, Fixed R:R - Configurable booking percentages at each level for position scaling - Visual lines and labels display all target levels on chart Stop Loss System: - Two calculation modes : Auto (anchor-based) or Manual ATR distance - Configurable buffer beyond calculated stop level for additional protection - Optional maximum stop loss cap in points to limit risk exposure - Visual display shows current stop level throughout trade Breakeven Protection: - None: Stop remains at original level after TP1 is reached - Buffer: Stop moves to entry plus percentage of original risk - Lock at TP1: Stop moves to TP1 level, securing that profit amount Trailing Stop Options: - ATR Trailing: Follows at dynamic ATR distance from price extreme - Step Trailing: Moves in fixed point increments as price advances favorably - Swing Trailing: Follows recent swing structure levels for dynamic protection - Configurable start point: Begin trailing from entry or only after TP1 achieved ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ KEY SETTINGS GUIDE FOR CONFIGURATION Core Engine Settings: - Base Lookback Period: Foundation for anchor detection, automatically adjusted by AVR engine - Confirmation Window: Number of bars allowed for price to confirm setup after anchor - Minimum Signal Quality Score : Required confluence level for valid buy sell signals - Signal Cooldown: Minimum bars between consecutive signals to prevent clustering Engine Toggles: Each of the six analytical engines can be independently enabled or disabled. Disabling engines reduces confluence requirements but may affect overall signal quality. Trade Style Options: - Auto: Automatically selects style based on detected market regime (FRESH leads to Runner, NORMAL leads to Extended, SCALP leads to Scalp, CAUTION leads to Caution) - Scalp: Forces tight targets for quick profit taking (TP1: 0.4R, TP2: 0.8R, TP3: 1.2R) - Extended: Forces balanced targets with room to develop (TP1: 0.6R, TP2: 1.2R, TP3: 2.0R) - Runner: Forces wide targets to capture larger moves (TP1: 0.8R, TP2: 1.8R, TP3: 3.0R) Aggressiveness Level: - Conservative: Tighter targets with earlier profit taking - Normal: Balanced approach as calculated - Aggressive: Extended targets for larger potential moves Session Filter: Optional restriction of signals to specific trading sessions including London, New York, Tokyo, Sydney, London plus New York overlap, or custom hours in UTC. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ VISUAL ELEMENTS AND DISPLAY OPTIONS Chart Display Elements: - BUY and SELL labels with quality scores and optional engine breakdown - Entry line displayed as dashed yellow - TP levels displayed as dotted green gradient - Stop loss line displayed as solid red - Protected and trailing stop line displayed as solid blue - Hit markers appear when TP or SL levels are reached - Optional regime label showing current market state classification Color Theme Options: - Vibrant: High contrast modern colors (default selection) - Classic : Traditional trading platform colors - Dark Pro: Subdued professional color scheme - Minimal : Low saturation subtle colors for clean charts Dashboard Display Modes: - Full : Complete detailed information display - Compact : Essential information only for smaller footprint - Ultra Compact : Minimal footprint display for maximum chart space ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ALERT SYSTEM FOR NOTIFICATIONS Individual Alert Conditions Available: - PRE Buy Signal: Triggers on new buy signal generation - PRE Sell Signal: Triggers on new sell signal generation - TP1 Achieved: Triggers when first target is reached - TP2 Achieved: Triggers when second target is reached - TP3 Achieved: Triggers when third target is reached - Stop Loss Hit: Triggers when stop level is reached before any TP - Protected Exit: Triggers when stop is hit after partial profit taken - Momentum Warning: Triggers when momentum weakening is detected in profitable trade Alert Format Options: - Standard: Brief notification with symbol and signal score - Detailed : Comprehensive information including all price levels - Webhook JSON: Machine-readable format for automated trading systems and bots ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ CHART EXAMPLES - VISUAL DEMONSTRATIONS Chart 1: Dashboard and Engine Status Overview This chart demonstrates the PRE indicator in scanning mode, showing the comprehensive Engine Status Panel (top right) and Trade Panel (bottom right). The dashboard provides real-time visibility into all six analytical engines and current market conditions. Key Features Shown: - Synthetic Activity Index (SAI): Currently showing HIGH ACTIVITY (50.6) detecting significant price action - Pressure Wave Oscillator (PWO): NEUTRAL (2.99) with no exhaustion detected yet - F ractal Confluence Matrix (FCM): BEAR CONFLUENCE (5) showing price at multi-timeframe highs - Entropic Exhaustion Detector (EED): HIGH ENTROPY (0.99) indicating maximum market uncertainty - Candle DNA Fingerprinting: BULL PATTERN (0.74) with reversal pattern detected - Market Regime: SCALP CONDITIONS suggesting tighter targets appropriate - Applied Style: SCALP (Auto) with system automatically selecting scalp mode based on regime - Volatility State: NORMAL (0.76) - Trade Panel: Shows SCANNING FOR SIGNALS with a BEARISH setup active (3 bars remaining) What This Demonstrates: The dashboard provides complete transparency into the indicator decision-making process. You can see exactly which engines are active, their current readings, and what trade style will be applied to the next signal. The Applied Style row shows both the detected regime AND the style that will be used. Chart 2: Trade Style Comparison - Extended vs Runner This split-screen comparison shows the SAME SELL signal and trade with two different trade style settings applied. The left panel uses EXTENDED (User) style while the right panel uses RUNNER (User) style. This demonstrates how manually selecting different trade styles affects take profit targets and position booking strategy for identical market conditions. Key Features Shown: LEFT PANEL - EXTENDED (User) Style: - Engine Status: Market Regime shows FRESH MOVE but Applied Style shows EXTENDED (User) - Entry: 4492.5 - TP1: 4487.75 at 4.6 pts away - TP2: 4483.01 at 9.4 pts away - Stop Loss: 4500.4 (8 pts) - Risk to Reward: 1:0.6 - Running P&L: -0.13 points - Position Booking: Balanced 50/50 split RIGHT PANEL - RUNNER (User) Style: - Engine Status: Same FRESH MOVE regime but Applied Style shows RUNNER (User) - Entry: 4492.5 (same entry) - TP1: 4486.17 at 6.2 pts away (WIDER target) - TP2: 4478.26 at 14.1 pts away (MUCH WIDER target) - Stop Loss: 4500.4 (8 pts - same stop) - Risk to Reward: 1:0.8 (better ratio) - Running P&L: -0.13 points (same moment) - Position Booking: Aggressive 35/65 split keeping more for runner What This Demonstrates: Both panels show the exact same trade at the same moment with same P&L, entry, and stop. The ONLY difference is the trade style setting. EXTENDED uses balanced approach with 50/50 booking at closer targets. RUNNER uses wider targets with 35/65 booking to let winners run further. Chart 3: Auto Mode vs Manual Override Comparison This split-screen comparison shows the SAME SELL signal with two different style control modes. The left panel uses RUNNER (Auto) where the system automatically selected Runner style based on detecting FRESH MOVE conditions. The right panel uses SCALP (User) where the trader manually forced Scalp style, overriding the system recommendation. Key Features Shown: LEFT PANEL - RUNNER (Auto) Style: - Engine Status: Market Regime shows FRESH MOVE and Applied Style shows RUNNER (Auto) - Entry: 4492.5 - TP1: 4489.33 at 3 pts away - TP2: 4487.17 at 6.2 pts away - Stop Loss : 4500.4 (8 pts) - Control Mode: System automatically selected this style RIGHT PANEL - SCALP (User) Style: - Engine Status: Same FRESH MOVE regime but Applied Style shows SCALP (User) - Entry: 4492.5 (same) - TP1: 4489.33 at 3 pts away (TIGHTER booking percentage) - TP2: 4487.17 at 6.2 pts away (SMALLER remainder) - Risk to Reward: 1:0.4 (more conservative) - Control Mode: User manually forced this style overriding system What This Demonstrates: The Applied Style row shows WHO is in control. (Auto) means system decides based on regime. (User) means you override. This complete transparency shows when you are trading WITH or AGAINST the system analysis. Chart 4: Trade Management and Protection System This split-screen comparison shows the SAME SHORT trade at DIFFERENT stages of execution. The left panel shows the trade at entry and setup phase while the right panel shows the trade after TP1 has been hit with protection activated. Key Features Shown: LEFT PANEL - Trade Setup and Initial Entry: - Engine Status: Market Regime shows FRESH MOVE and Applied Style shows RUNNER (Auto) - Trade Panel: Shows SCANNING FOR SIGNALS with BULLISH setup active (3 bars remaining) - TP Mode: Auto with Next Signal TP showing 0.8R / 1.8R (Runner style targets) - Exit Marker: Shows Exit @ +50% label indicating completed previous trade - Setup Phase: System ready for next signal with runner-focused targets pre-calculated RIGHT PANEL - Active Trade with TP1 Hit: - Engine Status: Same FRESH MOVE regime but Applied Style shows SCALP (User) - Entry: 4492.5 (yellow dashed line) - TP1: 4486.17 showing + HIT (green marker indicating TP1 reached) - TP2: 4486.17 at 11.4 pts away (green dotted line) - Protected Stop: 4491.31 (3.8 pts) shown as BLUE LINE (stop moved from initial level) - Running P&L: +4.96 points (in profit) - Profit Booked: 65% shown in trade panel - Trade Status: RUNNING TO TP2 - Bars in Trade: 10 - Protection Active: Stop loss moved to protect profits after TP1 achievement What This Demonstrates: Complete trade lifecycle and protection system. Initial stop placement, TP1 achievement, breakeven protection activation, position booking, and remaining position management with zero risk after partial profit taken. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ RECOMMENDED USE CASES AND APPLICATIONS Suitable Instruments: - Forex pairs including all majors, minors, and exotics (no volume required) - CFD instruments including indices, commodities, and metals - Cryptocurrency pairs on all exchanges - Stocks and ETFs with or without volume consideration - Futures contracts across all markets Suggested Timeframes: - Primary for scalping: 1-minute, 3-minute, 5-minute, 15-minute charts - Also effective on: 30-minute, 1-hour, 4-hour for swing entry identification Optimal Conditions: - Markets with clear structure and adequate liquidity - During active trading sessions with participation - When multiple engines show alignment and confluence ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ LIMITATIONS AND IMPORTANT CONSIDERATIONS What This Indicator Cannot Do: - Predict future price movements with certainty - Guarantee profitable trades or specific returns - Replace proper risk management and position sizing - Work effectively in all market conditions at all times - Eliminate all false signals completely Conditions Where Performance May Vary: - Extremely low liquidity periods with wide spreads - Major news events and high-impact economic releases - Strongly trending markets without meaningful pullbacks - Unusual market conditions or flash crash events The P&L tracking displayed is for the current visualized trade only and does not represent historical performance, backtested results, or guaranteed future outcomes. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ SIGNAL CONFIRMATION AND NON-REPAINTING BEHAVIOR This indicator is specifically designed to prevent repainting: - All signals are confirmed at bar close only using barstate.isconfirmed - Signals do not appear and disappear during intra-bar price action - Once a signal prints on the chart, it remains permanently - Historical signals accurately represent what would have been visible in real-time trading ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ RISK DISCLAIMER AND IMPORTANT NOTICES This indicator is provided for educational and informational purposes only. It does not constitute financial advice, investment recommendations, or trading signals that guarantee profits. Trading financial instruments carries substantial risk of loss and is not suitable for all investors. Past performance of any trading system or methodology is not necessarily indicative of future results. Users should: - Conduct their own analysis before making any trading decisions - Never risk more than they can afford to lose - Understand that no indicator can predict market movements with certainty - Use proper risk management and position sizing at all times - Consider consulting a licensed financial advisor before trading The author accepts no liability for any losses incurred through the use of this indicator. -BullByte
Penunjuk Pine Script®
oleh BullByte
2
XAUUSD Gold 1Min Scalping IndicatorDesigned specifically for gold scalpers and day traders who need lightning-fast entries with institutional-grade precision. This advanced indicator monitors Higher Timeframe (HTF) candle breaks on lower timeframes, dynamically tracks reference candles after the break, and confirms entries only when price action validates the move — eliminating false breakouts and whipsaw trades. Perfect for XAUUSD 1-minute charts, but fully adaptable to any timeframe or instrument (Forex, Crypto, Indices). 📦 What You Get — 2 Complete Versions 🎯 Version 1: Advanced Multi-Filter System (Original) The complete institutional-grade scalping system with multiple confirmation layers: ✅ HTF Break Detection — Monitors 15m/1H/4H candle levels ✅ Dynamic Reference Tracking — Adapts to price action in real-time ✅ Close-Based Entry Confirmation — Zero repaint signals ✅ 50% Midpoint Invalidation Filter — Kills setups that cross HTF 50% level ✅ Opposite Break Protection — Cancels setup if reverse HTF break occurs ✅ Visual System: 🔺 REF | ✅ ENTRY | ❌ Opposite Break | ❌50% Cross ✅ Auto-Clear Options — Keep charts clean with latest signals only Perfect for: Traders who want maximum filtration and disciplined entries with institutional-level invalidation rules. ⚡ Version 2: Simplified Pure Price Action System (NEW) Streamlined for speed and simplicity — removes complex filters for faster signals: ✅ HTF Break Detection — Same precision, CLOSE-based only (no touch triggers) ✅ Dynamic Reference Tracking — Forward-moving reference candle system ✅ Close-Based Entry Confirmation — Opposite candle closes beyond reference ✅ Opposite Break Invalidation Only — Single clean invalidation rule ✅ No 50% Midpoint Rule — More setups, faster execution ✅ Visual System: 🔺 REF | ✅ ENTRY | ❌ Opposite Break ✅ Cleaner State Machine — Faster processing, simpler logic flow Perfect for: Aggressive scalpers who prefer pure price action without midpoint filters, and traders who want more trading opportunities. 💡 How The System Works The indicator monitors Higher Timeframe (HTF) candle levels (e.g., 15m, 1H, 4H) and detects when Lower Timeframe (LTF) price CLOSES beyond the previous HTF high or low. Once a break occurs, it dynamically tracks reference candles moving forward and waits for opposite-direction candle confirmation before triggering entry signals. 🟢 Bull Setup (BUY Entry): ✅ LTF closes ABOVE HTF previous high → break detected ✅ System tracks bullish reference candles (making higher highs) ✅ When a bearish candle CLOSES below reference low → ✅ ENTRY signal fires → Clear visual markers + instant alerts for scalping precision 🔴 Bear Setup (SELL Entry): ✅ LTF closes BELOW HTF previous low → break detected ✅ System tracks bearish reference candles (making lower lows) ✅ When a bullish candle CLOSES above reference high → ✅ ENTRY signal fires → Perfect for catching Gold reversals at key institutional levels 🚨 Built-In Invalidation Logic: ❌ Opposite HTF break before confirmation → setup canceled ❌ Version 1 Only: Price crosses 50% midpoint → setup invalidated → Only clean, high-probability setups reach entry stage 🔥 Why Gold Scalpers Love This Indicator ✅ Multi-Timeframe Precision – Combines HTF structure with LTF execution for surgical entries ✅ Dynamic Reference Tracking – Adapts to price action in real-time, not static levels ✅ Zero Repaint Signals – All confirmations are CLOSE-based, never disappear ✅ Visual Clarity – Color-coded HTF levels, reference markers, entry labels, and invalidation alerts ✅ Fully Customizable – Adjust HTF timeframe, colors, label visibility, and line styles ✅ Automation-Ready – Built-in alerts for 3Commas, PineConnector, Tickerly, or manual trading ✅ Professional Risk Display – HTF high/low levels + 50% midpoint plotted automatically (Version 1) ✅ Two Trading Styles – Choose conservative (V1) or aggressive (V2) based on your risk profile ⚙️ Key Features (Both Versions) ✔️ HTF Break Detection (15m, 1H, 4H, or custom) ✔️ Forward-Moving Reference Candle System ✔️ Close-Based Entry Confirmation Logic ✔️ Visual Labels: 🔺 REF | ✅ ENTRY | ❌ Invalid ✔️ Customizable HTF Level Display (Lines or Plot Style) ✔️ Auto-Clear Old Labels Option (keeps charts clean) ✔️ Color Themes: Bull (Green) / Bear (Red) / Neutral (Gray) ✔️ Real-Time Alerts: Break Start, Entry Confirmed, Setup Invalidated ✔️ Works on Free & Premium TradingView Plans Version 1 Exclusive: ✔️ 50% Midpoint Invalidation Filter ✔️ ❌50% Cross Visual Alerts ✔️ HTF 50% Level Plotting Version 2 Exclusive: ✔️ Simplified State Machine (faster processing) ✔️ Pure price action (no midpoint interference) ✔️ More trading opportunities per session 💼 What You Get 📁 Full Pine Script Source Code for BOTH Versions (.txt files) ♾ Lifetime Access — No Subscriptions 🔔 Pre-Configured Alert Templates (for both versions) 📊 Version Comparison Guide — Choose the right system for your style 🎓 Quick Setup Instructions — Get trading in 5 minutes 💡 Installation (5 Easy Steps) 1️⃣ Open TradingView → Pine Editor 2️⃣ Paste Version 1 or Version 2 code (both delivered instantly after purchase) 3️⃣ Click "Add to Chart" 4️⃣ Customize HTF timeframe and visual settings 5️⃣ Enable alerts — scalp Gold with precision instantly Pro Tip: Start with Version 1 for disciplined entries, switch to Version 2 for aggressive scalping during high-volatility sessions. 🧩 Perfect For ✅ Gold Scalpers (1m, 5m charts) ✅ XAUUSD Day Traders ✅ Multi-Timeframe Strategy Builders ✅ Smart Money / ICT Practitioners ✅ Algorithmic Traders (bot-ready alerts) ✅ Traders seeking HTF confluence on LTF execution ✅ Conservative traders (Version 1) AND aggressive scalpers (Version 2) 🛠 Compatibility ✅ Works on TradingView (Free & Pro) ✅ Optimized for XAUUSD Gold Trading ✅ Compatible with 3Commas, PineConnector, Tickerly ✅ Supports all HTF intervals (15m, 1H, 4H, Daily) ✅ No repainting — 100% close-based logic ✅ Both versions fully commented and documented ⚠️ Disclaimer This indicator is for educational and strategy development purposes only. Trading Gold and Forex involves significant risk. Always backtest, use proper money management, and never risk more than you can afford to lose. By purchasing, you agree to our Terms of Use and No-Refund Policy. 🎉 Ready to Scalp Gold Like a Pro? Stop chasing fake breakouts. Start trading with structure. Get TWO complete systems in one purchase — conservative filtering OR aggressive scalping, your choice!
Penunjuk Pine Script®
oleh AkkiCodez
1
HA Signal Engine [Abusuhil]🎯 HA Signal Engine ═══════════════════════════════════════════════════════════════════ 📊 OVERVIEW A comprehensive professional trading system built on advanced Heikin Ashi analysis, combining 5 powerful strategies with intelligent multi-timeframe confluence, complete risk management, and optional visual zones for Support/Resistance and Order Blocks. This indicator is designed for serious traders who demand precision, flexibility, and professional-grade signals without repainting. ═══════════════════════════════════════════════════════════════════ ✨ KEY FEATURES 🔹 5 ADVANCED TRADING STRATEGIES: 1. Wave Momentum Sync → Catches unified trends across multiple timeframes → Perfect for trending markets → Detects HTF/MTF/CTF alignment 2. Stealth Reversal Detection → Identifies hidden reversals before they become obvious → Excellent for catching early trend changes → Uses candle sequence analysis 3. Compression-Expansion Cycle → Detects volatility compression followed by expansion → Ideal for breakout trading → VTD (Volatility Transition Detector) based 4. Hidden Acceleration → Catches momentum acceleration in trending markets → Progressive candle strength analysis → High-probability continuation signals 5. Early Exhaustion → Detects trend exhaustion before reversal → Consecutive candle analysis → Perfect for exit timing 🔹 PROPRIETARY METRICS: - HAMI (Heikin Ashi Momentum Index) → Measures momentum strength (0-200+) → Identifies oversold/overbought conditions → Filters weak signals - DPS (Directional Purity Score) → Measures trend quality (0-10) → Higher score = cleaner trend → Reduces false signals in choppy markets - VTD (Volatility Transition Detector) → Detects volatility changes (0-3+) → Compression/expansion cycles → Breakout confirmation - Confluence Score (0-100) → Combines all factors → Higher score = stronger signal → Customizable threshold 🔹 MULTI-TIMEFRAME ANALYSIS: - HTF (Higher Timeframe) - Default: 4H → Identifies major trend direction → Provides strong bias - MTF (Medium Timeframe) - Default: 1H → Confirms pullbacks and entries → Adds confluence layer - CTF (Current Timeframe) → Entry trigger timing → Final confirmation - Can be enabled/disabled for flexibility 🔹 SIGNAL FREQUENCY CONTROL: Choose your preferred signal frequency: 1. Conservative (Low Signals) → Strictest filters (Confluence 80+) → Highest quality signals only → Best win rate 2. Balanced (Default) ⭐ → Perfect balance (Confluence 70+) → Recommended for most traders → Quality + Quantity 3. Moderate (More Signals) → More opportunities (Confluence 60+) → Good for active trading → Acceptable quality 4. Aggressive (Max Signals) → Maximum opportunities (Confluence 50+) → High volume trading → Requires experience 5. Custom (User Values) → Full manual control → Set your own filters → Advanced traders only 🔹 ADVANCED FILTERING SYSTEM: - Min Confluence Score (0-100) → Minimum required quality score → Higher = fewer but better signals - Min Body/Range Ratio (0.1-1.0) → Candle strength requirement → Higher = stronger candles only - Max Opposite Shadow % (0-1.0) → Shadow rejection filter → Lower = cleaner candles - Min HAMI Score (0-200) → Momentum requirement → Higher = stronger momentum 🔹 COMPLETE RISK MANAGEMENT: Stop Loss Methods: 1. ATR Based (Dynamic) → Adapts to market volatility → ATR Multiplier: adjustable 2. Swing Low/High → Based on recent structure → Lookback period: customizable 3. Fixed Percentage → Simple fixed % from entry → Fully controllable 4. HA Shadow Based → Uses Heikin Ashi shadows → Tight stops Take Profit Methods: 1. Risk:Reward Ratio → Classic R:R approach → Adjustable ratio (0.5-10) 2. ATR Based → Volatility-adjusted targets → Dynamic exits 3. Fixed Percentage → Simple fixed % targets → Easy to manage 4. Multiple Targets → 3 separate targets → Target 1: 1.5R (default) → Target 2: 2.5R (default) → Target 3: 4.0R (default) → Scale out strategy 🔹 VISUAL ZONES MODULE (Optional): Enable beautiful visual analysis with one click: - Support & Resistance Zones → Automatic S/R detection → Pivot-based analysis → Shows active and broken levels - Order Blocks → Bullish OB detection → Bearish OB detection → Smart Money concepts - Display Options → Boxes or Lines → Fully customizable colors → Adjustable sensitivity - Historical Tracking → Optional broken S/R history → Clean chart mode available ⚠️ IMPORTANT: Visual Zones are for analysis ONLY → Does NOT affect trading signals → Completely independent module → Disabled by default 🔹 PROFESSIONAL DASHBOARD: Real-time metrics display: - HAMI Score with color coding - DPS Score (trend quality) - VTD Ratio (volatility state) - Body Ratio (candle strength) - HTF/MTF/CTF Trend status - Consecutive candle count - Active strategies count - Last signal status - Confluence score Dashboard Customization: - Language: English / العربية - Size: 6 levels (Tiny → Giant) - Position: 9 locations - Perfect for mobile + desktop - Great for visual impairment 🔹 SMART ALERTS: - Long Signal Alerts - Short Signal Alerts - Customizable messages - Once per bar close - No spam ═══════════════════════════════════════════════════════════════════ 🎯 HOW TO USE 📌 BEGINNER SETUP (Quick Start): 1. Add indicator to chart 2. Settings → Signal Frequency → "Balanced" 3. Enable all 5 strategies 4. Use default filters 5. Watch for 🎯 LONG/SHORT signals 6. Check Dashboard for confirmation 7. Enter when Confluence > 70 📌 INTERMEDIATE SETUP (Customized): 1. Choose Signal Frequency level 2. Adjust filters based on your style: • Scalping: Aggressive/Custom • Day Trading: Moderate/Balanced • Swing Trading: Conservative/Balanced 3. Set Risk Management: • Stop Loss: ATR Based (1.5x) • Take Profit: Multiple Targets • Or customize to your preference 4. Optional: Enable Visual Zones • Great for confluence • See S/R and OB levels 5. Monitor Dashboard metrics: • HAMI: 80-140 = ideal • DPS: >6 = good trend • VTD: >1.2 = expansion • Confluence: 70+ = tradeable 📌 ADVANCED SETUP (Professional): 1. Signal Frequency: Custom 2. Fine-tune all filters manually: • Confluence: 65-75 (sweet spot) • Body Ratio: 0.5-0.6 • Shadow: 0.4-0.5 • HAMI: 80-100 3. Multi-Timeframe Analysis: • Enable MTF • Set HTF = 4× current TF • Set MTF = 2× current TF • Trade only with 3-TF alignment 4. Strategy Selection: • Enable strategies matching market: • Trending: Wave Momentum + Acceleration • Ranging: Compression-Expansion • Reversal: Stealth Reversal + Exhaustion 5. Risk Management: • Use Multiple Targets • Scale out: 30% @ T1, 40% @ T2, 30% @ T3 • Or use Swing Low/High for stops 6. Visual Zones: • Use for confluence only • Entry near S/R = higher probability • OB zones = strong areas ═══════════════════════════════════════════════════════════════════ 📊 SIGNAL INTERPRETATION 🟢 LONG SIGNAL (BUY): Required Conditions: ✓ One or more strategies triggered ✓ Confluence Score ≥ threshold ✓ HTF/MTF bullish (if MTF enabled) ✓ Bullish HA candle ✓ Strong body ratio ✓ No/minimal upper shadow ✓ HAMI score sufficient Best Entry: → Green triangle appears below candle → Dashboard shows 🎯 LONG → Confluence 85+ = excellent → HTF + MTF + CTF all bullish = ideal → VTD > 1.5 = strong expansion 🔴 SHORT SIGNAL (SELL): Required Conditions: ✓ One or more strategies triggered ✓ Confluence Score ≥ threshold ✓ HTF/MTF bearish (if MTF enabled) ✓ Bearish HA candle ✓ Strong body ratio ✓ No/minimal lower shadow ✓ HAMI score sufficient Best Entry: → Red triangle appears above candle → Dashboard shows 🎯 SHORT → Confluence 85+ = excellent → HTF + MTF + CTF all bearish = ideal → VTD > 1.5 = strong expansion ═══════════════════════════════════════════════════════════════════ ⚙️ SETTINGS GUIDE 🔹 STRATEGIES (Enable/Disable): → All enabled = maximum signals → Selective = specific market conditions 🔹 TIMEFRAMES: → HTF: 4× your chart timeframe → MTF: 2× your chart timeframe → Disable MTF for single-TF trading 🔹 SIGNAL FREQUENCY: → Beginners: Balanced → Active traders: Moderate/Aggressive → Professionals: Custom 🔹 FILTERS: → Higher values = fewer, better signals → Lower values = more signals, less quality → Find your sweet spot through testing 🔹 RISK MANAGEMENT: → Match your trading style → ATR = dynamic, adapts to market → Fixed % = simple, predictable → Swing = structure-based 🔹 VISUAL: → Labels: Show/hide signal labels → Lines: Show/hide entry/SL/TP lines → Dashboard: Real-time metrics → Colors: Customize to your theme 🔹 VISUAL ZONES: → Disabled by default → Enable for S/R and OB analysis → Pure visual aid, no signal impact → Customize colors and sensitivity 🔹 DASHBOARD: → English or العربية → 6 sizes (mobile to desktop) → 9 positions (anywhere on chart) 🔹 ALERTS: → Enable for notifications → Works with all signals → Once per bar (no spam) ═══════════════════════════════════════════════════════════════════ ⚡ PERFORMANCE TIPS ✅ Best Practices: 1. Start with Balanced preset 2. Test on demo account first 3. Use higher timeframes (15m+) for better quality 4. Confluence 75+ for higher win rate 5. Check all 3 timeframes before entry 6. Avoid trading during low liquidity 7. Use proper position sizing 8. Set alerts and wait patiently 9. Don't overtrade 10. Combine with price action knowledge ❌ Avoid: 1. Trading every single signal 2. Ignoring Dashboard metrics 3. Using on very low timeframes (<5m) 4. Disabling all filters 5. Overriding risk management 6. Trading against HTF trend 7. Entering when VTD < 1.0 8. Ignoring Confluence score 9. FOMO trading 10. Using Visual Zones as entry signals ═══════════════════════════════════════════════════════════════════ 🎓 UNDERSTANDING THE METRICS 📊 HAMI Score (Heikin Ashi Momentum Index): - 0-70: Weak momentum (avoid) - 70-100: Decent momentum (ok) - 100-140: Strong momentum (ideal) ✓ - 140+: Overheated (caution) 📊 DPS Score (Directional Purity): - 0-5: Choppy/mixed (risky) - 5-8: Good trend (tradeable) - 8+: Excellent trend (ideal) ✓ 📊 VTD Ratio (Volatility Transition): - <1.0: Compression (wait) - 1.0-1.2: Normal (ok) - 1.2-1.5: Expansion starting (good) - 1.5+: Strong expansion (ideal) ✓ - 2.5+: Extreme (caution) 📊 Body Ratio: - <50%: Weak candle (avoid) - 50-60%: Acceptable (ok) - 60-70%: Good candle (good) - 70%+: Strong candle (ideal) ✓ 📊 Confluence Score: - 50-60: Minimum (aggressive) - 60-70: Decent (moderate) - 70-85: Good (balanced) ✓ - 85-100: Excellent (conservative) ✓ ═══════════════════════════════════════════════════════════════════ 🛡️ IMPORTANT NOTES ✅ NON-REPAINTING: → All signals use barstate.isconfirmed → What you see = what you get → Signals appear AFTER candle close → Reliable for backtesting and live trading ✅ NO STRATEGY COMMANDS: → Pure indicator, not a strategy → No automatic trading → You maintain full control → Use for manual or automated trading (with bot) ✅ VISUAL ZONES: → Completely independent module → Does NOT affect signals → Analysis tool only → Can be enabled/disabled anytime ✅ RESOURCE USAGE: → Optimized for performance → Respects TradingView limits → Works on all plans → No MTF security calls (except built-in HTF/MTF) ✅ CUSTOMIZATION: → Fully customizable colors → Adjustable thresholds → Flexible filters → Bilingual interface ═══════════════════════════════════════════════════════════════════ 📝 VERSION HISTORY v1.0 - Initial Release - 5 core strategies - Multi-timeframe analysis - Complete risk management - Professional dashboard v2.0 - Major Update - Signal Frequency presets - Custom mode - Enhanced filtering - Dashboard customization (language, size, position) v3.0 - Visual Enhancement - Visual Zones module added - Support/Resistance detection - Order Blocks - Full independence from signals ═══════════════════════════════════════════════════════════════════ 💬 SUPPORT & FEEDBACK Created by: Abusuhil Pine Script™ Version: 5 Indicator Type: Overlay For questions, suggestions, or bug reports: → Use TradingView comments section → Feedback is highly appreciated → Happy trading! 🚀 ═══════════════════════════════════════════════════════════════════ ⚠️ DISCLAIMER This indicator is for educational and informational purposes only. It is not financial advice. Trading involves substantial risk of loss. Past performance does not guarantee future results. Always do your own research, use proper risk management, and never risk more than you can afford to lose. ═══════════════════════════════════════════════════════════════════ ═══════════════════════════════════════════════════════════════════ 🎯 محرك إشارات الهايكن آشي ═══════════════════════════════════════════════════════════════════ 📊 نظرة عامة نظام تداول احترافي شامل مبني على تحليل الهايكن آشي المتقدم، يجمع بين 5 استراتيجيات قوية مع توافق ذكي متعدد الأطر الزمنية، إدارة مخاطر كاملة، ومناطق مرئية اختيارية للدعم/المقاومة و Order Blocks. هذا المؤشر مصمم للمتداولين الجادين الذين يطلبون الدقة والمرونة والإشارات الاحترافية بدون إعادة رسم. ═══════════════════════════════════════════════════════════════════ ✨ المميزات الرئيسية 🔹 5 استراتيجيات تداول متقدمة: 1. مزامنة زخم الموجة (Wave Momentum Sync) → يلتقط الاتجاهات الموحدة عبر أطر زمنية متعددة → مثالي للأسواق الترندية → يكتشف توافق HTF/MTF/CTF 2. كشف الانعكاس الخفي (Stealth Reversal Detection) → يحدد الانعكاسات المخفية قبل أن تصبح واضحة → ممتاز للقبض على تغيرات الاتجاه المبكرة → يستخدم تحليل تسلسل الشموع 3. دورة الانضغاط-التوسع (Compression-Expansion Cycle) → يكتشف انضغاط التذبذب يليه توسع → مثالي لتداول الاختراقات → مبني على VTD (كاشف انتقال التذبذب) 4. التسارع الخفي (Hidden Acceleration) → يلتقط تسارع الزخم في الأسواق الترندية → تحليل قوة الشمعة التدريجي → إشارات استمرار عالية الاحتمال 5. الإرهاق المبكر (Early Exhaustion) → يكتشف إرهاق الاتجاه قبل الانعكاس → تحليل الشموع المتتالية → مثالي لتوقيت الخروج 🔹 مقاييس احتكارية: - HAMI (مؤشر زخم الهايكن آشي) → يقيس قوة الزخم (0-200+) → يحدد حالات التشبع البيعي/الشرائي → يفلتر الإشارات الضعيفة - DPS (درجة نقاء الاتجاه) → يقيس جودة الاتجاه (0-10) → درجة أعلى = اتجاه أنظف → يقلل الإشارات الخاطئة في الأسواق المتقلبة - VTD (كاشف انتقال التذبذب) → يكتشف تغيرات التذبذب (0-3+) → دورات الانضغاط/التوسع → تأكيد الاختراق - درجة التوافق (0-100) → يجمع كل العوامل → درجة أعلى = إشارة أقوى → حد قابل للتخصيص 🔹 تحليل متعدد الأطر الزمنية: - HTF (الإطار الزمني الأعلى) - افتراضي: 4 ساعات → يحدد اتجاه الترند الرئيسي → يوفر انحياز قوي - MTF (الإطار الزمني المتوسط) - افتراضي: ساعة → يؤكد التصحيحات ونقاط الدخول → يضيف طبقة توافق - CTF (الإطار الزمني الحالي) → توقيت محفز الدخول → التأكيد النهائي - يمكن تفعيله/تعطيله للمرونة 🔹 التحكم في تكرار الإشارات: اختر تكرار الإشارات المفضل: 1. محافظ (إشارات قليلة) → أشد الفلاتر صرامة (توافق 80+) → أعلى جودة فقط → أفضل نسبة ربح 2. متوازن (افتراضي) ⭐ → توازن مثالي (توافق 70+) → موصى به لمعظم المتداولين → جودة + كمية 3. معتدل (إشارات أكثر) → فرص أكثر (توافق 60+) → جيد للتداول النشط → جودة مقبولة 4. عدواني (أقصى إشارات) → أقصى فرص (توافق 50+) → تداول بحجم كبير → يتطلب خبرة 5. مخصص (قيم المستخدم) → تحكم يدوي كامل → اضبط الفلاتر الخاصة بك → للمتداولين المتقدمين فقط 🔹 نظام فلترة متقدم: - الحد الأدنى لدرجة التوافق (0-100) → الحد الأدنى المطلوب لدرجة الجودة → أعلى = إشارات أقل لكن أفضل - الحد الأدنى لنسبة الجسم/النطاق (0.1-1.0) → متطلب قوة الشمعة → أعلى = شموع أقوى فقط - الحد الأقصى لنسبة الظل المعاكس (0-1.0) → فلتر رفض الظل → أقل = شموع أنظف - الحد الأدنى لدرجة HAMI (0-200) → متطلب الزخم → أعلى = زخم أقوى 🔹 إدارة مخاطر كاملة: طرق وقف الخسارة: 1. مبني على ATR (ديناميكي) → يتكيف مع تذبذب السوق → مضاعف ATR: قابل للتعديل 2. Swing Low/High → مبني على الهيكل الأخير → فترة الاسترجاع: قابلة للتخصيص 3. نسبة مئوية ثابتة → نسبة ثابتة بسيطة من الدخول → قابل للتحكم بالكامل 4. مبني على ظل HA → يستخدم ظلال الهايكن آشي → إيقافات ضيقة طرق جني الأرباح: 1. نسبة المخاطرة:المكافأة → نهج R:R الكلاسيكي → نسبة قابلة للتعديل (0.5-10) 2. مبني على ATR → أهداف معدلة بالتذبذب → خروج ديناميكي 3. نسبة مئوية ثابتة → أهداف نسبة مئوية ثابتة بسيطة → سهلة الإدارة 4. أهداف متعددة → 3 أهداف منفصلة → الهدف 1: 1.5R (افتراضي) → الهدف 2: 2.5R (افتراضي) → الهدف 3: 4.0R (افتراضي) → استراتيجية التدرج في الخروج 🔹 وحدة المناطق المرئية (اختيارية): فعّل تحليل مرئي جميل بنقرة واحدة: - مناطق الدعم والمقاومة → كشف تلقائي للدعم/المقاومة → تحليل مبني على Pivot → يعرض المستويات النشطة والمكسورة - Order Blocks → كشف OB الصاعد → كشف OB الهابط → مفاهيم Smart Money - خيارات العرض → صناديق أو خطوط → ألوان قابلة للتخصيص بالكامل → حساسية قابلة للتعديل - تتبع تاريخي → تاريخ اختياري للدعم/المقاومة المكسور → وضع الشارت النظيف متاح ⚠️ مهم: المناطق المرئية للتحليل فقط → لا تؤثر على إشارات التداول → وحدة مستقلة تماماً → معطّلة افتراضياً 🔹 لوحة معلومات احترافية: عرض مقاييس الوقت الفعلي: - درجة HAMI مع ترميز لوني - درجة DPS (جودة الاتجاه) - نسبة VTD (حالة التذبذب) - نسبة الجسم (قوة الشمعة) - حالة اتجاه HTF/MTF/CTF - عدد الشموع المتتالية - عدد الاستراتيجيات النشطة - حالة آخر إشارة - درجة التوافق تخصيص لوحة المعلومات: - اللغة: English / العربية - الحجم: 6 مستويات (صغير جداً → عملاق) - الموقع: 9 مواقع - مثالي للجوال + سطح المكتب - رائع لضعاف البصر 🔹 تنبيهات ذكية: - تنبيهات إشارة الشراء - تنبيهات إشارة البيع - رسائل قابلة للتخصيص - مرة واحدة لكل إغلاق شمعة - بدون إزعاج ═══════════════════════════════════════════════════════════════════ 🎯 كيفية الاستخدام 📌 إعداد المبتدئين (بدء سريع): 1. أضف المؤشر إلى الشارت 2. الإعدادات → تكرار الإشارات → "متوازن" 3. فعّل جميع الاستراتيجيات الخمس 4. استخدم الفلاتر الافتراضية 5. راقب إشارات 🎯 LONG/SHORT 6. تحقق من لوحة المعلومات للتأكيد 7. ادخل عندما التوافق > 70 📌 إعداد متوسط (مخصص): 1. اختر مستوى تكرار الإشارات 2. اضبط الفلاتر بناءً على أسلوبك: • سكالبينج: عدواني/مخصص • التداول اليومي: معتدل/متوازن • التداول المتأرجح: محافظ/متوازن 3. اضبط إدارة المخاطر: • وقف الخسارة: مبني على ATR (1.5x) • جني الأرباح: أهداف متعددة • أو خصص حسب تفضيلك 4. اختياري: فعّل المناطق المرئية • رائع للتوافق • شاهد مستويات الدعم/المقاومة و OB 5. راقب مقاييس لوحة المعلومات: • HAMI: 80-140 = مثالي • DPS: >6 = اتجاه جيد • VTD: >1.2 = توسع • التوافق: 70+ = قابل للتداول 📌 إعداد متقدم (احترافي): 1. تكرار الإشارات: مخصص 2. ضبط دقيق لجميع الفلاتر يدوياً: • التوافق: 65-75 (النقطة المثالية) • نسبة الجسم: 0.5-0.6 • الظل: 0.4-0.5 • HAMI: 80-100 3. تحليل متعدد الأطر الزمنية: • فعّل MTF • اضبط HTF = 4× الإطار الزمني الحالي • اضبط MTF = 2× الإطار الزمني الحالي • تداول فقط مع توافق 3 أطر زمنية 4. اختيار الاستراتيجية: • فعّل الاستراتيجيات المطابقة للسوق: • ترندي: زخم الموجة + التسارع • نطاقي: الانضغاط-التوسع • انعكاس: الانعكاس الخفي + الإرهاق 5. إدارة المخاطر: • استخدم أهداف متعددة • تدرج في الخروج: 30% @ T1، 40% @ T2، 30% @ T3 • أو استخدم Swing Low/High للإيقاف 6. المناطق المرئية: • استخدم للتوافق فقط • الدخول بالقرب من الدعم/المقاومة = احتمال أعلى • مناطق OB = مناطق قوية ═══════════════════════════════════════════════════════════════════ 📊 تفسير الإشارات 🟢 إشارة LONG (شراء): الشروط المطلوبة: ✓ واحدة أو أكثر من الاستراتيجيات مفعّلة ✓ درجة التوافق ≥ الحد الأدنى ✓ HTF/MTF صاعد (إذا كان MTF مفعّل) ✓ شمعة HA صاعدة ✓ نسبة جسم قوية ✓ لا ظل علوي/ظل علوي قليل ✓ درجة HAMI كافية أفضل دخول: → مثلث أخضر يظهر تحت الشمعة → لوحة المعلومات تعرض 🎯 LONG → التوافق 85+ = ممتاز → HTF + MTF + CTF كلها صاعدة = مثالي → VTD > 1.5 = توسع قوي 🔴 إشارة SHORT (بيع): الشروط المطلوبة: ✓ واحدة أو أكثر من الاستراتيجيات مفعّلة ✓ درجة التوافق ≥ الحد الأدنى ✓ HTF/MTF هابط (إذا كان MTF مفعّل) ✓ شمعة HA هابطة ✓ نسبة جسم قوية ✓ لا ظل سفلي/ظل سفلي قليل ✓ درجة HAMI كافية أفضل دخول: → مثلث أحمر يظهر فوق الشمعة → لوحة المعلومات تعرض 🎯 SHORT → التوافق 85+ = ممتاز → HTF + MTF + CTF كلها هابطة = مثالي → VTD > 1.5 = توسع قوي ═══════════════════════════════════════════════════════════════════ ⚙️ دليل الإعدادات 🔹 الاستراتيجيات (تفعيل/تعطيل): → الكل مفعّل = أقصى إشارات → انتقائي = ظروف سوق محددة 🔹 الأطر الزمنية: → HTF: 4× إطارك الزمني في الشارت → MTF: 2× إطارك الزمني في الشارت → عطّل MTF للتداول بإطار زمني واحد 🔹 تكرار الإشارات: → المبتدئون: متوازن → المتداولون النشطون: معتدل/عدواني → المحترفون: مخصص 🔹 الفلاتر: → قيم أعلى = إشارات أقل، أفضل → قيم أقل = إشارات أكثر، جودة أقل → اعثر على نقطتك المثالية من خلال الاختبار 🔹 إدارة المخاطر: → طابق أسلوب تداولك → ATR = ديناميكي، يتكيف مع السوق → ثابت % = بسيط، متوقع → Swing = مبني على الهيكل 🔹 المرئي: → التسميات: إظهار/إخفاء تسميات الإشارة → الخطوط: إظهار/إخفاء خطوط الدخول/SL/TP → لوحة المعلومات: مقاييس الوقت الفعلي → الألوان: خصص حسب موضوعك 🔹 المناطق المرئية: → معطّلة افتراضياً → فعّل لتحليل الدعم/المقاومة و OB → أداة مرئية بحتة، لا تأثير على الإشارة → خصص الألوان والحساسية 🔹 لوحة المعلومات: → English أو العربية → 6 أحجام (من الجوال إلى سطح المكتب) → 9 مواقع (في أي مكان على الشارت) 🔹 التنبيهات: → فعّل للإشعارات → يعمل مع جميع الإشارات → مرة واحدة لكل شمعة (بدون إزعاج) ═══════════════════════════════════════════════════════════════════ ⚡ نصائح الأداء ✅ أفضل الممارسات: 1. ابدأ بالإعداد المتوازن 2. اختبر على حساب تجريبي أولاً 3. استخدم أطر زمنية أعلى (15 دقيقة+) لجودة أفضل 4. التوافق 75+ لنسبة ربح أعلى 5. تحقق من جميع الأطر الزمنية الثلاثة قبل الدخول 6. تجنب التداول أثناء السيولة المنخفضة 7. استخدم حجم صفقة مناسب 8. اضبط التنبيهات وانتظر بصبر 9. لا تفرط في التداول 10. ادمج مع معرفة حركة السعر ❌ تجنب: 1. تداول كل إشارة 2. تجاهل مقاييس لوحة المعلومات 3. الاستخدام على أطر زمنية منخفضة جداً (<5 دقائق) 4. تعطيل جميع الفلاتر 5. تجاوز إدارة المخاطر 6. التداول ضد اتجاه HTF 7. الدخول عندما VTD < 1.0 8. تجاهل درجة التوافق 9. تداول FOMO 10. استخدام المناطق المرئية كإشارات دخول ═══════════════════════════════════════════════════════════════════ 🎓 فهم المقاييس 📊 درجة HAMI (مؤشر زخم الهايكن آشي): - 0-70: زخم ضعيف (تجنب) - 70-100: زخم لائق (مقبول) - 100-140: زخم قوي (مثالي) ✓ - 140+: محموم (حذر) 📊 درجة DPS (نقاء الاتجاه): - 0-5: متقلب/مختلط (محفوف بالمخاطر) - 5-8: اتجاه جيد (قابل للتداول) - 8+: اتجاه ممتاز (مثالي) ✓ 📊 نسبة VTD (انتقال التذبذب): - <1.0: انضغاط (انتظر) - 1.0-1.2: عادي (مقبول) - 1.2-1.5: توسع يبدأ (جيد) - 1.5+: توسع قوي (مثالي) ✓ - 2.5+: متطرف (حذر) 📊 نسبة الجسم: - <50%: شمعة ضعيفة (تجنب) - 50-60%: مقبول (مقبول) - 60-70%: شمعة جيدة (جيد) - 70%+: شمعة قوية (مثالي) ✓ 📊 درجة التوافق: - 50-60: الحد الأدنى (عدواني) - 60-70: لائق (معتدل) - 70-85: جيد (متوازن) ✓ - 85-100: ممتاز (محافظ) ✓ ═══════════════════════════════════════════════════════════════════ 🛡️ ملاحظات مهمة ✅ بدون إعادة رسم: → جميع الإشارات تستخدم barstate.isconfirmed → ما تراه = ما تحصل عليه → الإشارات تظهر بعد إغلاق الشمعة → موثوق للاختبار الخلفي والتداول المباشر ✅ لا أوامر استراتيجية: → مؤشر نقي، وليس استراتيجية → لا تداول تلقائي → تحافظ على السيطرة الكاملة → استخدم للتداول اليدوي أو الآلي (مع بوت) ✅ المناطق المرئية: → وحدة مستقلة تماماً → لا تؤثر على الإشارات → أداة تحليل فقط → يمكن تفعيلها/تعطيلها في أي وقت ✅ استخدام الموارد: → محسّن للأداء → يحترم حدود TradingView → يعمل على جميع الخطط → لا استدعاءات MTF security (باستثناء HTF/MTF المدمج) ✅ التخصيص: → ألوان قابلة للتخصيص بالكامل → حدود قابلة للتعديل → فلاتر مرنة → واجهة ثنائية اللغة ═══════════════════════════════════════════════════════════════════ 📝 سجل الإصدارات v1.0 - الإصدار الأولي - 5 استراتيجيات أساسية - تحليل متعدد الأطر الزمنية - إدارة مخاطر كاملة - لوحة معلومات احترافية v2.0 - تحديث رئيسي - إعدادات مسبقة لتكرار الإشارات - وضع مخصص - فلترة محسّنة - تخصيص لوحة المعلومات (اللغة، الحجم، الموقع) v3.0 - تحسين مرئي - إضافة وحدة المناطق المرئية - كشف الدعم/المقاومة - Order Blocks - استقلالية كاملة عن الإشارات ═══════════════════════════════════════════════════════════════════ 💬 الدعم والملاحظات من إعداد: Abusuhil إصدار Pine Script™: 5 نوع المؤشر: Overlay للأسئلة أو الاقتراحات أو الإبلاغ عن الأخطاء: → استخدم قسم التعليقات في TradingView → الملاحظات موضع تقدير كبير → تداول سعيد! 🚀 ═══════════════════════════════════════════════════════════════════ ⚠️ إخلاء المسؤولية هذا المؤشر لأغراض تعليمية وإعلامية فقط. إنه ليس نصيحة مالية. ينطوي التداول على مخاطر كبيرة للخسارة. الأداء السابق لا يضمن النتائج المستقبلية. قم دائماً بإجراء بحثك الخاص، واستخدم إدارة المخاطر المناسبة، ولا تخاطر أبداً بأكثر مما يمكنك تحمل خسارته. ═══════════════════════════════════════════════════════════════════
Penunjuk Pine Script®
oleh abusuhil
ScalpRirt Pro PublicScalpRirt Pro (Long-only) — User Guide & Indicator Description ScalpRirt Pro is a Long-only indicator for scalp / intraday scenarios that: • shows 2 entry types (Red and Yellow), • builds a visual trade guidance package: target (TP), guidance zone, and add-on levels (if enabled), • calculates the scenario exposure load on the deposit (%) across entries/add-ons, • displays a statistics table for closed scenarios, • supports alerts and prepares messages for external notifications. The indicator does not place orders, does not manage an exchange, and does not guarantee results. It is a tool that helps you make decisions quickly within a predefined scenario and follow trades in a disciplined way. 1) How to read signals on the chart 1.1 BUY signals (entries) The indicator draws a BUY arrow (below the bar) in two types: Red BUY (red) — “aggressive working mode”. This mode is for active trading when you want to take trades more often/more boldly, work price moves faster, and keep confirmations simple. Yellow BUY (yellow) — “confirmation mode”. These are more “cautious” entries: they may pass through additional filters (user-selected) to reduce noisy situations and make entries more context-aware. Important: on the same chart these are two different entry types, not “better/worse”. They represent different usage modes. 1.2 Only one active trade at a time At any moment the indicator tracks only one active scenario: either Red or Yellow. While a scenario is active: • new BUY signals are not started, • the guidance continues until the scenario ends at the target. This is done on purpose to: • avoid overlapping trades, • keep the chart clean, • preserve the add-on logic and statistics integrity. 2) What is built after entry (trade guidance) After a BUY appears, the indicator automatically plots: • TP (take profit) — the target level for taking profit (above entry, Long-only), • Add-on levels (Averaging #1 / #2 / #3) — if averaging is enabled, • Guidance zone — a visual range from the current scenario lower bound up to TP, • Labels with key parameters of the current scenario (entry price, total exposure %, add-on levels, TP), • A TP label on the right as price moves. Important: TP is recalculated if add-ons are triggered (because the scenario average price changes). 3) CLOSE (blue) — what it is and how to treat it A blue CLOSE marker may appear on the chart. This is not a forced trade close and not an “automatic close”. It is an informational marker displayed only during an active scenario and serves as a hint that the market is transitioning into a state where you may want to: • monitor the trade more closely, • consider partial profit-taking / switching to a more cautious mode, • watch the price reaction. In the current version, the scenario is actually completed when TP (the target) is reached. So the main “official” exit point is TP, while CLOSE is an additional indicator reference. 4) Settings: how to enable correctly and what each group means 4.1 Signal Type (Signal Mode) Signal Type: • Red — show and guide only Red scenarios, • Yellow — show and guide only Yellow scenarios, • Combined — allow both types; the indicator will pick one scenario by internal priority (so there are not two positions at the same time). Practice: • If you trade actively and want more trades — start with Red. • If you want a cleaner, more cautious mode with filters — Yellow. • If you want “let it choose the best entry for the situation” — Combined. 4.2 Sensitivity parameters (Parameter D1 / Parameter D2 / Close Y Param) These are sensitivity regulators that affect how “strictly” events are selected for entry / hints. • Parameter D2 — tunes Red behavior, • Parameter D1 — tunes Yellow behavior, • Close Y Param — tunes the sensitivity of the CLOSE marker. How to tune without guessing: • If you get too many signals and they feel “nervous” → make the mode stricter (typically move toward stricter values on the scale). • If you get too few signals → make the mode softer. Starter preset (universal baseline): • D1 = 8 • D2 = 8 • CloseY = 8 Then fine-tune per instrument and timeframe. 5) Averaging: enable or not, and how to use it 5.1 Enable “Enable averaging?” (useAveraging) — turns add-ons on/off. If OFF: • the indicator guides the trade only from the initial entry to TP. If ON: • up to 3 add-on levels become available. 5.2 Add-on parameters • Main entry, % of deposit — initial exposure (e.g., 2%), • Drop (%) for averaging #1/#2/#3 — distance down from the initial entry, • Add volume #1/#2/#3, % of deposit — how much is added to the scenario. Important to understand the exposure logic: Total deposit exposure = main entry + the add-on volumes that were actually triggered. More add-ons = higher exposure and higher risk requirements. 5.3 How it looks on the chart After entry you will see: • Averaging #1 • Averaging #2 • Averaging #3 and the TP target. When price reaches an add-on level: • the scenario average price is recalculated, • TP is recalculated, • the guidance zone updates. Important: this is scenario guidance. Real exchange execution depends on your orders/conditions, fees, and slippage. 6) Take Profit % Take Profit % sets the target as a percentage from the scenario average position price. After add-ons, TP is recalculated automatically. Practice: • On smaller timeframes (1m/3m/5m) traders usually use a smaller TP to take moves faster. • On larger timeframes (30m/1h/2h) TP can be higher because the move “range” is different. 7) Yellow filters: when to enable and why Yellow is a mode you can make stricter. The code includes 3 boosters: 7.1 Use Yellow Delay Filter (1 bar) Confirms the entry event on the next bar. Enable when: • on lower TF you get too many “false jerks”, • you want fewer early entries. Downside: entries sometimes occur later. 7.2 Use Yellow Delta Filter Adds a check of “impulse quality” based on the current bar. Enable when: • the instrument often makes sharp fake moves, • you want to cut out cases without a confirmed impulse. 7.3 SMA filter (regime/context filter for Yellow) • Enable SMA filter for Yellow? • SMA length • SMA timeframe Idea: Yellow signals pass only when the market is in a favorable regime relative to the chosen baseline on the specified timeframe. Example setups: • trend filter: SMA 200 on D or H4 • softer mode: SMA 200 on H1 8) Timeframes: how to use correctly (important) You can use the indicator on different TFs, but behavior will differ. 8.1 Lower TFs (1m–5m) • more signals, • more noise, • Yellow filters (Delay/Delta) and/or the regime filter are often useful. Working style: • Red — for an active series of trades, • Yellow — for “cleaner but rarer” entries when filters are enabled. 8.2 Medium TFs (15m–1h) • signals are less frequent, • moves are more stable, • add-ons and TP can be tuned more calmly. 8.3 Higher TFs (2h–4h–D) • signals are rare, • context impact is stronger, • regime settings matter more (e.g., Yellow + SMA filter). Recommendation: pick a TF based on your style. This is not a “universal button”, but a tool for different modes. 9) Statistics (table): what is calculated The table shows scenario metrics: • how many scenarios were closed, • maximum time in position (hours), • total PnL% across closed scenarios, • how often 1/2/3 add-ons were used, • maximum drawdown % (scenario-based). This is indicator statistics to evaluate scenario behavior. Real exchange statistics may differ due to fees, execution, and your money management. 10) Alerts and notifications The indicator supports: • manual alerts via alertcondition() (BUY/add-ons/close), • message preparation for external notifications. Telegram Chat ID / Telegram Thread ID fields are intended for your integration (via your own webhook/bot on your side). 11) Important limitations (to avoid surprises) • Long-only. • One active scenario at a time. • Main scenario completion is at TP. • CLOSE is an in-scenario reference, not “auto-close”. • Averaging increases exposure: use it only if you understand the risk. Quick start (60 seconds) 1) Choose mode: Red (active) or Yellow (more cautious). 2) Start parameters: D1=8, D2=8, CloseY=8. 3) Set main entry to 1–3% of deposit (per your risk). 4) Enable averaging only if you can handle higher exposure. 5) On 5m, try Yellow with Delay/Delta if there is too much noise. 6) Watch TP and the table — evaluate whether the scenario fits the instrument.
Penunjuk Pine Script®
oleh Trader_Journal
2