Cripto chart for updated
//@version=6
// ══════════════════════════════════════════════════════════
// GOLD BREAKOUT 15M STRATEGY [WillyAlgoTrader]
// ══════════════════════════════════════════════════════════
// Author: Willy | WillyAlgoTrader
// Version: 1.0.0
//
// Trades the breakout of the overnight range on gold.
// • Range: high / low built between Range Start and Range End (broker time, default 00:00–07:00)
// • Entry: stop orders on both range boundaries; the first fill cancels the other. One trade per day
// • Stop: percent of the entry price (default 1%) or the opposite range boundary. No take-profit
// • Exit: stop-loss, or forced close at Close Hour (default 20:00)
// • Size: percent of equity at risk, capped by Max Leverage, rounded down to the quantity step
//
// Before you trade it
// • Built for gold on the 15-minute chart. Use a timeframe that divides an hour evenly (1–60 min), regular candles
// • Set Broker Time Mode / Broker Timezone to your broker's server time: the range depends on it
// • Default costs: commission 0.4 per order, slippage 0. Spread is not modeled. Adjust them in Properties
// • Risk per trade is a target: commission, spread, slippage and gaps come on top of it
// • Orders are calculated on bar close and filled on the next bar
// • Alerts: create an alert on the strategy and leave only {{strategy.order.alert_message}} in the Message field
// ══════════════════════════════════════════════════════════
strategy(
title = "Gold Breakout 15M Strategy [WillyAlgoTrader]",
shorttitle = "Gold BO 15M",
overlay = true,
initial_capital = 10000,
default_qty_type = strategy.fixed,
default_qty_value = 1,
calc_on_every_tick = false,
process_orders_on_close = false,
margin_long = 5,
margin_short = 5,
commission_type = strategy.commission.cash_per_order,
commission_value = 0.4,
slippage = 0,
max_lines_count = 500,
max_labels_count = 500,
max_boxes_count = 500,
max_bars_back = 5000)
// ══════════════════════════════════════════════════════════
// 2. CONSTANTS
// ══════════════════════════════════════════════════════════
GRP_MAIN = "⚙️ Main Settings"
GRP_RISK = "π‘️ Risk Management"
GRP_VISUAL = "π¨ Visual Settings"
GRP_DASH = "π Dashboard"
GRP_PERF = "π Performance Chart"
GRP_ALERT = "π Alerts"
GRP_COLORS = "π¨ Colors"
STRATEGY_VERSION = "v1.0.0"
TZ_MODE_FIXED = "Fixed timezone"
TZ_MODE_NY7 = "New York + 7h"
NY7_SHIFT_MS = 7 * 3600000
NY_TZ = "America/New_York"
SL_MODE_PCT = "% of entry"
SL_MODE_RANGE = "Range boundary"
SIZE_RISK = "% equity at risk"
SIZE_FIXED = "Fixed quantity"
OCA_GROUP = "RB"
NO_VALUE = "—"
DEF_JSON_IN = '{"strategy":"Gold Breakout 15M","event":"entry","action":"{{action}}","side":"{{side}}","ticker":"{{ticker}}","price":{{price}},"sl":{{sl}},"qty":{{qty}},"lots":{{lots}},"risk_usd":{{risk_usd}},"range_high":{{range_high}},"range_low":{{range_low}},"secret":"{{secret}}"}'
DEF_JSON_OUT = '{"strategy":"Gold Breakout 15M","event":"exit","action":"{{action}}","side":"{{side}}","ticker":"{{ticker}}","reason":"{{reason}}","price":{{price}},"qty":{{qty}},"secret":"{{secret}}"}'
DEF_TEXT_LONG_IN = "π’ BUY | {{tickerid}} | TF: {{interval}} | Price: {{price}} | SL: {{sl}} | Qty: {{qty}} ({{lots}} lots) | Risk: {{risk_usd}}"
DEF_TEXT_SHORT_IN = "π΄ SELL | {{tickerid}} | TF: {{interval}} | Price: {{price}} | SL: {{sl}} | Qty: {{qty}} ({{lots}} lots) | Risk: {{risk_usd}}"
DEF_TEXT_LONG_OUT = "⚪ EXIT LONG | {{tickerid}} | TF: {{interval}} | Price: {{price}} | Reason: {{reason}} | Qty: {{qty}}"
DEF_TEXT_SHORT_OUT = "⚪ EXIT SHORT | {{tickerid}} | TF: {{interval}} | Price: {{price}} | Reason: {{reason}} | Qty: {{qty}}"
TIP_TEMPLATE = "Editable message template. Placeholders are listed in the tooltip of 'Webhook JSON Format'."
// ══════════════════════════════════════════════════════════
// 3. INPUTS
// ══════════════════════════════════════════════════════════
// ── Main ────────────────────────────────────────
tzModeInput = input.string(TZ_MODE_FIXED, "Broker Time Mode", options = [TZ_MODE_FIXED, TZ_MODE_NY7], group = GRP_MAIN,
tooltip = "How broker server time is derived.\n" +
"• Fixed timezone: uses 'Broker Timezone' below all year round\n" +
"• New York + 7h: server clock used by most FX/CFD brokers (GMT+2 in winter, GMT+3 in summer, US daylight-saving calendar)\n" +
"Pick the one matching your broker's server time; a wrong choice shifts the range by an hour for part of the year.")
tzInput = input.string("GMT+3", "Broker Timezone", group = GRP_MAIN,
tooltip = "Used in 'Fixed timezone' mode. Timezone of your broker's server: all session hours below are in this time.\n" +
"• Most FX/CFD brokers use GMT+2 in winter and GMT+3 in summer\n" +
"• Examples: GMT+3, GMT+2, UTC, Europe/Moscow")
rangeFromInput = input.int(0, "Range Start Hour", minval = 0, maxval = 22, step = 1, group = GRP_MAIN,
tooltip = "Hour (broker time) when the daily range starts building.\n" +
"• Default: 0 (start of the broker day)")
rangeToInput = input.int(7, "Range End / Trading Start Hour", minval = 1, maxval = 23, step = 1, group = GRP_MAIN,
tooltip = "Hour when the range is fixed and breakout trading begins.\n" +
"• Default 7: range 00:00–06:59, trading from 07:00\n" +
"• Later hour = wider range, fewer breakouts")
closeHourInput = input.int(20, "Close All Positions Hour", minval = 2, maxval = 23, step = 1, group = GRP_MAIN,
tooltip = "Hour when any open position is force-closed.\n" +
"• Default: 20. The strategy has no take-profit, this is the main exit")
// ── Risk Management ─────────────────────────────
slModeInput = input.string(SL_MODE_PCT, "SL Mode", options = [SL_MODE_PCT, SL_MODE_RANGE], group = GRP_RISK,
tooltip = "Where the stop-loss is placed.\n" +
"• % of entry: fixed percent from the entry price (default 1%). Placed from the breakout level, then re-set from the actual fill price at the close of the entry bar\n" +
"• Range boundary: opposite side of the range; a narrow range means a tight stop and a larger position")
slPctInput = input.float(1.0, "SL, % of Entry Price", minval = 0.05, maxval = 20.0, step = 0.05, group = GRP_RISK,
tooltip = "Stop distance in percent of entry price (used in '% of entry' mode).\n" +
"• Higher = wider stop, smaller position\n" +
"• Default: 1.0")
sizeModeInput = input.string(SIZE_RISK, "Position Size Mode", options = [SIZE_RISK, SIZE_FIXED], group = GRP_RISK,
tooltip = "How the order quantity is calculated.\n" +
"• % equity at risk: qty = equity × risk% / loss to stop\n" +
"• Fixed quantity: constant number of contracts")
riskPctInput = input.float(1.0, "Risk per Trade, % of Equity", minval = 0.01, maxval = 100.0, step = 0.1, group = GRP_RISK,
tooltip = "Share of equity lost if the stop is hit.\n" +
"• Conservative 0.5, balanced 1.0, aggressive 2.0\n" +
"• This is a target: commission, spread, slippage and gaps add to the actual loss")
fixedQtyInput = input.float(1.0, "Fixed Quantity (contracts)", minval = 0.0001, maxval = 1000000.0, step = 0.01, group = GRP_RISK,
tooltip = "Order quantity used in 'Fixed quantity' mode.")
lotOzInput = input.float(0.0, "Ounces per Lot (0 = auto)", minval = 0.0, maxval = 1000000.0, step = 1.0, group = GRP_RISK,
tooltip = "Used only to show size in lots (labels, dashboard, {{lots}} placeholder) on ounce-quoted instruments.\n" +
"• 0 = auto: 100 oz for gold, 5000 oz for silver (standard broker lots)\n" +
"• Does not affect trades")
maxLeverageInput = input.float(10.0, "Max Leverage", minval = 0.1, maxval = 100.0, step = 1.0, group = GRP_RISK,
tooltip = "Upper limit for position notional ÷ equity. Size = the smaller of risk-based size and this cap.\n" +
"• 1% risk with 1% stop needs ×1; range-boundary stops usually need ×2–5\n" +
"• When the cap is hit, actual risk is lower than requested (shown in the dashboard)\n" +
"• Strategy margin is declared as 5% (20x in Properties), so this input is the effective limiter\n" +
"• Values near or above 20 also need a higher Long/Short leverage in Properties, otherwise the tester may reject the orders")
qtyStepInput = input.float(0.0, "Quantity Step (0 = auto)", minval = 0.0, maxval = 1000000.0, step = 0.01, group = GRP_RISK,
tooltip = "Order quantity is rounded DOWN to this step, so the planned risk (before commission, spread and gaps) stays within the budget.\n" +
"• 0 = minimum contract size reported by TradingView for the symbol\n" +
"• Set your exchange / bot step if it differs\n" +
"• If the size is below one step, the entry is skipped")
guardOnInput = input.bool(false, "Prop Firm Guard: Close on Daily Drawdown", group = GRP_RISK,
tooltip = "Closes everything and stops trading until the next day when equity falls from the daily peak by the limit below.\n" +
"• Drawdown is measured at the worst point of each candle (not on the entry candle), but the guard reacts only at candle close\n" +
"• For a live prop account use a low timeframe; this is not a guarantee of staying within a firm's limit")
guardDdInput = input.float(4.0, "Max Drawdown from Daily Equity Peak, %", minval = 0.1, maxval = 100.0, step = 0.1, group = GRP_RISK,
tooltip = "Daily drawdown limit for the Prop Firm Guard.\n" +
"• Typical prop firm daily limit: 4–5%")
showSlInput = input.bool(true, "Show Entry / SL Levels", group = GRP_RISK,
tooltip = "Draw entry price and stop-loss lines with a risk zone while a position is open.")
// ── Visual ──────────────────────────────────────
themeInput = input.string("Auto", "Theme", options = ["Auto", "Dark", "Light"], group = GRP_VISUAL,
tooltip = "Chart color theme.\n" +
"• Auto: detects from chart background\n" +
"• Dark: optimized for dark backgrounds\n" +
"• Light: optimized for light/white backgrounds")
showRangeInput = input.bool(true, "Show Range Box & Boundaries", group = GRP_VISUAL,
tooltip = "Draw the daily range box and its high/low lines extended over the trading session.")
showEntryLabelsInput = input.bool(true, "Show Entry Labels", group = GRP_VISUAL,
tooltip = "Label at each entry: direction, entry price, stop, size and risk.")
showExitLabelsInput = input.bool(true, "Show Exit Labels (Trade Result)", group = GRP_VISUAL,
tooltip = "Label at each exit: P&L in money and in R, price move, exit price and reason.")
showTradeBoxInput = input.bool(true, "Show Trade Box (Entry → Exit)", group = GRP_VISUAL,
tooltip = "Green/red box between entry and exit of every closed trade.")
labelSizeInput = input.string("Small", "Label Size", options = ["Small", "Normal"], group = GRP_VISUAL,
tooltip = "Text size of entry/exit labels.")
showWarningsInput = input.bool(true, "Show Accuracy Warnings", group = GRP_VISUAL,
tooltip = "Note on the last bar when the range may be inaccurate: timeframe above 1H or not dividing an hour evenly, or a non-standard chart (Heikin Ashi, Renko…).\n" +
"Informational only: trading is not disabled.")
showWatermarkInput = input.bool(true, "Show Watermark", group = GRP_VISUAL,
tooltip = "Display 'WillyAlgoTrader' watermark on chart")
// ── Dashboard ───────────────────────────────────
showDashInput = input.bool(true, "Show Dashboard", group = GRP_DASH,
tooltip = "Status panel with range, session and position calculator.")
showMathInput = input.bool(true, "Show Strategy Math", group = GRP_DASH,
tooltip = "Trade statistics: win rate, breakeven win rate, profit factor, payoff, expectancy in money and in R, drawdown, losing streak.\n" +
"R = trade result divided by the initial risk to the stop.")
dashPosInput = input.string("Top Right", "Dashboard Position", options = ["Top Left", "Top Right", "Bottom Left", "Bottom Right", "Middle Right"], group = GRP_DASH,
tooltip = "Corner of the chart where the dashboard is placed.")
dashSizeInput = input.string("Small", "Dashboard Text Size", options = ["Small", "Normal", "Large"], group = GRP_DASH,
tooltip = "Text size of dashboard rows.")
// ── Performance Chart ───────────────────────────
showPerfInput = input.bool(false, "Show Performance Chart", group = GRP_PERF,
tooltip = "Cumulative PnL curve with key stats, drawn over the chart.\n" +
"• Built from closed trades on the bars loaded on the chart — NOT from the Deep Backtesting range\n" +
"• Covers the candles behind it while enabled")
perfPosInput = input.string("Bottom Left", "Chart Position", options = ["Bottom Left", "Bottom Center", "Bottom Right", "Middle Center", "Top Left", "Top Center"], group = GRP_PERF,
tooltip = "Where the performance chart is placed.\n" +
"• Bottom Center: the watermark is hidden while the chart is there\n" +
"• Same corner as the dashboard: a warning is shown, move one of them")
perfColsInput = input.int(80, "Chart Columns", minval = 20, maxval = 150, step = 10, group = GRP_PERF,
tooltip = "Horizontal resolution of the curve.\n" +
"• Higher = smoother curve, slower drawing\n" +
"• Recommended: 60–100")
perfRowsInput = input.int(30, "Chart Rows", minval = 10, maxval = 60, step = 5, group = GRP_PERF,
tooltip = "Vertical resolution of the curve.\n" +
"• Higher = finer steps, slower drawing\n" +
"• Recommended: 24–40")
perfWidthInput = input.float(50.0, "Chart Width, % of Screen", minval = 20.0, maxval = 90.0, step = 5.0, group = GRP_PERF,
tooltip = "Width of the curve area as a share of the chart pane.")
perfHeightInput = input.float(35.0, "Chart Height, % of Screen", minval = 10.0, maxval = 70.0, step = 5.0, group = GRP_PERF,
tooltip = "Height of the curve area as a share of the chart pane.")
// ── Alerts ──────────────────────────────────────
enableAlertsInput = input.bool(true, "Enable Alert Messages", group = GRP_ALERT,
tooltip = "When off, order alert messages are sent empty.\n" +
"Setup: create an alert on this strategy and leave only {{strategy.order.alert_message}} in the Message field.")
webhookInput = input.bool(false, "Webhook JSON Format", group = GRP_ALERT,
tooltip = "On: JSON templates are sent (for bots / webhooks). Off: text templates.\n\n" +
"Placeholders filled by the strategy:\n" +
"{{ticker}} {{tickerid}} {{exchange}} {{interval}}\n" +
"{{event}} = entry / exit\n" +
"{{side}} = long / short\n" +
"{{action}} = buy / sell\n" +
"{{reason}} = breakout / sl / time / equity_guard\n" +
"{{price}} = order level (entry stop / SL) or bar close for time and guard exits — not the fill price\n" +
"{{entry}} = entry reference price, {{sl}} = planned stop-loss, {{sl_pct}} = stop distance in % of entry\n" +
"{{trade_id}} = ticker + day, identical in the entry and exit messages of one trade\n" +
"Note: in '% of entry' mode the stop is re-set from the actual fill and no separate alert is sent. " +
"A bot that places its own stop should compute it as {{sl_pct}} from its own fill price.\n" +
"{{qty}} = contracts, {{oz}} = qty × point value (ounces on ounce-quoted instruments), {{lots}} = lots\n" +
"{{risk_usd}} {{risk_pct}} = initial risk of the trade (entry to SL)\n" +
"{{equity}} {{range_high}} {{range_low}} {{secret}}\n\n" +
"TradingView's own placeholders (e.g. {{strategy.order.price}}, {{timenow}}) are NOT processed inside these templates. " +
"Put them into the Message field of the alert itself, next to {{strategy.order.alert_message}}.")
secretInput = input.string("", "Bot Secret → {{secret}}", group = GRP_ALERT,
tooltip = "Replaces {{secret}} in templates.\n" +
"Note: stored in chart settings and visible to anyone you share the chart with.")
jsonLongInInput = input.text_area(DEF_JSON_IN, "JSON · Long Entry", group = GRP_ALERT, tooltip = TIP_TEMPLATE)
jsonShortInInput = input.text_area(DEF_JSON_IN, "JSON · Short Entry", group = GRP_ALERT, tooltip = TIP_TEMPLATE)
jsonLongOutInput = input.text_area(DEF_JSON_OUT, "JSON · Long Exit", group = GRP_ALERT, tooltip = TIP_TEMPLATE)
jsonShortOutInput = input.text_area(DEF_JSON_OUT, "JSON · Short Exit", group = GRP_ALERT, tooltip = TIP_TEMPLATE)
textLongInInput = input.text_area(DEF_TEXT_LONG_IN, "Text · Long Entry", group = GRP_ALERT, tooltip = TIP_TEMPLATE)
textShortInInput = input.text_area(DEF_TEXT_SHORT_IN, "Text · Short Entry", group = GRP_ALERT, tooltip = TIP_TEMPLATE)
textLongOutInput = input.text_area(DEF_TEXT_LONG_OUT, "Text · Long Exit", group = GRP_ALERT, tooltip = TIP_TEMPLATE)
textShortOutInput = input.text_area(DEF_TEXT_SHORT_OUT, "Text · Short Exit", group = GRP_ALERT, tooltip = TIP_TEMPLATE)
showPreviewInput = input.bool(false, "Preview Messages in Pine Logs", group = GRP_ALERT,
tooltip = "Writes all four messages to Pine Logs as they would be sent (values of the last historical bar), with the bot secret masked as ***. Use it to check a template without waiting for a signal.")
// ── Colors ──────────────────────────────────────
bullColorInput = input.color(#00E676, "Bull", inline = "colors", group = GRP_COLORS,
tooltip = "Background of long entry labels, winning exit labels and winning trade boxes.")
bearColorInput = input.color(#FF5252, "Bear", inline = "colors", group = GRP_COLORS,
tooltip = "Background of short entry labels, losing exit labels and losing trade boxes.")
rangeColorInput = input.color(#2962FF, "Range", inline = "colors", group = GRP_COLORS,
tooltip = "Color of the daily range box, its boundaries and range labels.")
// ══════════════════════════════════════════════════════════
// 4. THEME DETECTION & COLORS
// ══════════════════════════════════════════════════════════
isDark = switch themeInput
"Dark" => true
"Light" => false
=> color.r(chart.bg_color) < 128 // Auto
// ── Text ────────────────────────────────────────
TEXT_COLOR = isDark ? #E0E0E0 : #1A1A1A
TEXT_MUTED = isDark ? color.new(#9E9E9E, 0) : color.new(#757575, 0)
// ── Signal colors for text on the chart / table ─
BULL_TEXT = isDark ? #00E676 : #00A152
BEAR_TEXT = isDark ? #FF5252 : #D32F2F
NEUTRAL_TEXT = isDark ? #FFEB3B : #F57F17
// ── Labels ──────────────────────────────────────
BULL_LABEL_TEXT = #004D25
BEAR_LABEL_TEXT = #FFFFFF
WARN_BG = #FFEB3B
WARN_TEXT = #1A1A1A
// ── Zones ───────────────────────────────────────
BULL_BG = color.new(bullColorInput, 85)
BEAR_BG = color.new(bearColorInput, 85)
RANGE_BG = color.new(rangeColorInput, 85)
RANGE_BORDER = color.new(rangeColorInput, 40)
// ── Dashboard ───────────────────────────────────
TABLE_BG = isDark ? color.new(#131722, 5) : color.new(#FFFFFF, 5)
TABLE_BORDER = isDark ? color.new(#2A2E39, 0) : color.new(#D0D0D0, 0)
TABLE_ROW_ALT = isDark ? color.new(#1C2030, 0) : color.new(#F0F4F8, 0)
HEADER_BG = isDark ? color.new(#0D47A1, 0) : color.new(#1565C0, 0)
HEADER_TEXT = #FFFFFF
// ── Levels ──────────────────────────────────────
SL_COLOR = color.new(#FF5252, 0)
ENTRY_COLOR = color.new(#2962FF, 0)
WM_COLOR = isDark ? color.new(#FFFFFF, 80) : color.new(#000000, 80)
TRANSPARENT = color.new(#000000, 100)
// ── Performance Chart ───────────────────────────
PERF_FILL_UP = color.new(BULL_TEXT, 82)
PERF_FILL_DN = color.new(BEAR_TEXT, 82)
labelSize = labelSizeInput == "Normal" ? size.normal : size.small
dashSize = dashSizeInput == "Large" ? size.large : dashSizeInput == "Normal" ? size.normal : size.small
dashPos = switch dashPosInput
"Top Left" => position.top_left
"Top Right" => position.top_right
"Bottom Left" => position.bottom_left
"Bottom Right" => position.bottom_right
"Middle Right" => position.middle_right
=> position.top_right
perfPos = switch perfPosInput
"Bottom Left" => position.bottom_left
"Bottom Center" => position.bottom_center
"Bottom Right" => position.bottom_right
"Middle Center" => position.middle_center
"Top Left" => position.top_left
"Top Center" => position.top_center
=> position.bottom_left
// ── Broker time mode ────────────────────────────
bool useNy7 = tzModeInput == TZ_MODE_NY7
string calcTz = useNy7 ? "UTC" : tzInput
string tzLabel = useNy7 ? "NY+7h" : tzInput
// ── Instrument type ─────────────────────────────
// Used only for size units (oz / units) and lot size in labels, dashboard and alerts. It does not restrict trading.
string tickerUpper = str.upper(syminfo.ticker)
string rootUpper = str.upper(syminfo.root)
string prefixUpper = str.upper(syminfo.prefix)
bool isFutures = syminfo.type == "futures"
bool isXauName = str.contains(tickerUpper, "XAU") and not str.startswith(tickerUpper, "XAG")
bool isGoldName = str.contains(tickerUpper, "GOLD") or str.contains(tickerUpper, "PAXG") or str.startswith(tickerUpper, "GLDRUB")
bool isCmeRoot = isFutures and (rootUpper == "GC" or rootUpper == "MGC" or rootUpper == "1OZ" or rootUpper == "QO")
bool isHkexRoot = isFutures and (rootUpper == "GDU" or rootUpper == "GDR")
bool isShfeRoot = isFutures and rootUpper == "AU" and syminfo.currency == "CNY"
bool isMoexRoot = isFutures and rootUpper == "GD" and (prefixUpper == "MOEX" or prefixUpper == "RUS")
bool isSgeName = prefixUpper == "SGE" and (str.startswith(tickerUpper, "AU") or str.startswith(tickerUpper, "MAU"))
bool isGold = isXauName or isGoldName or isCmeRoot or isHkexRoot or isShfeRoot or isMoexRoot or isSgeName
bool isXagName = str.contains(tickerUpper, "XAG")
bool isSilverName = str.contains(tickerUpper, "SILVER") or str.startswith(tickerUpper, "SLVRUB")
bool isCmeSilver = isFutures and (rootUpper == "SIL" or rootUpper == "QI" or (rootUpper == "SI" and syminfo.currency == "USD"))
bool isShfeSilver = isFutures and rootUpper == "AG" and syminfo.currency == "CNY"
bool isMoexSilver = isFutures and (rootUpper == "SV" or rootUpper == "SILV") and (prefixUpper == "MOEX" or prefixUpper == "RUS")
bool isSgeSilver = prefixUpper == "SGE" and str.startswith(tickerUpper, "AG")
bool isSilver = not isGold and (isXagName or isSilverName or isCmeSilver or isShfeSilver or isMoexSilver or isSgeSilver)
float lotOz = lotOzInput > 0 ? lotOzInput : isSilver ? 5000.0 : 100.0
bool isOunceGold = isXauName or str.contains(tickerUpper, "PAXG") or isCmeRoot or isMoexRoot or (str.contains(tickerUpper, "GOLD") and syminfo.currency == "USD")
bool isOunceSilver = isSilver and (isXagName or isCmeSilver or isMoexSilver or (str.contains(tickerUpper, "SILVER") and syminfo.currency == "USD"))
bool isOunceQuoted = isOunceGold or isOunceSilver
string unitLabel = isOunceQuoted ? "oz" : "units"
// ══════════════════════════════════════════════════════════
// 5. FUNCTIONS
// ══════════════════════════════════════════════════════════
safeDiv(float num, float den, float fallback = 0.0) =>
den != 0 and not na(num) and not na(den) ? num / den : fallback
// Rounds quantity down to the instrument step, so the planned risk never grows from rounding
roundQtyDown(float qty, float step) =>
float q = math.max(nz(qty), 0.0)
step > 0 ? math.floor(q / step + 1e-9) * step : q
signedStr(float x, string fmt) =>
na(x) ? NO_VALUE : (x > 0 ? "+" : "") + str.tostring(x, fmt)
priceStr(float x) =>
na(x) ? NO_VALUE : str.tostring(x, format.mintick)
numStr(float x, string fmt) =>
na(x) ? NO_VALUE : str.tostring(x, fmt)
maskSecret(string s) =>
secretInput == "" ? s : str.replace_all(s, secretInput, "***")
// Fills an alert template. entryRef is the entry price the risk is measured from; tradeId is shared by the entry
// and exit messages of one trade; equityRef is equity at entry, so {{risk_pct}} stays the initial risk.
fillTemplate(string tpl, bool isLong, string event, string reason, float price, float entryRef, float sl, float qty, float rHigh, float rLow, string tradeId, float equityRef) =>
string s = ""
if enableAlertsInput
float oz = nz(qty) * syminfo.pointvalue
float riskUsd = math.abs(nz(entryRef) - nz(sl)) * oz
s := tpl
s := str.replace_all(s, "{{ticker}}", syminfo.ticker)
s := str.replace_all(s, "{{tickerid}}", syminfo.tickerid)
s := str.replace_all(s, "{{exchange}}", syminfo.prefix)
s := str.replace_all(s, "{{interval}}", timeframe.period)
s := str.replace_all(s, "{{event}}", event)
s := str.replace_all(s, "{{trade_id}}", tradeId)
s := str.replace_all(s, "{{side}}", isLong ? "long" : "short")
s := str.replace_all(s, "{{action}}", (event == "entry") == isLong ? "buy" : "sell")
s := str.replace_all(s, "{{reason}}", reason)
s := str.replace_all(s, "{{price}}", str.tostring(nz(price), format.mintick))
s := str.replace_all(s, "{{entry}}", str.tostring(nz(entryRef), format.mintick))
s := str.replace_all(s, "{{sl}}", str.tostring(nz(sl), format.mintick))
s := str.replace_all(s, "{{sl_pct}}", str.tostring(safeDiv(math.abs(nz(entryRef) - nz(sl)), entryRef) * 100.0, "0.####"))
s := str.replace_all(s, "{{qty}}", str.tostring(nz(qty), "0.########"))
s := str.replace_all(s, "{{oz}}", str.tostring(oz, "0.########"))
s := str.replace_all(s, "{{lots}}", str.tostring(safeDiv(oz, lotOz), "0.########"))
s := str.replace_all(s, "{{risk_usd}}", str.tostring(riskUsd, "0.00"))
s := str.replace_all(s, "{{risk_pct}}", str.tostring(safeDiv(riskUsd, equityRef) * 100.0, "0.00"))
s := str.replace_all(s, "{{equity}}", str.tostring(strategy.equity, "0.00"))
s := str.replace_all(s, "{{range_high}}", str.tostring(nz(rHigh), format.mintick))
s := str.replace_all(s, "{{range_low}}", str.tostring(nz(rLow), format.mintick))
s := str.replace_all(s, "{{secret}}", secretInput)
s
// Broker server time. In "New York + 7h" mode: New York local time plus 7 hours (follows the US daylight-saving calendar)
brokerClock(int t) =>
useNy7 ? timestamp("UTC", year(t, NY_TZ), month(t, NY_TZ), dayofmonth(t, NY_TZ), hour(t, NY_TZ), minute(t, NY_TZ), second(t, NY_TZ)) + NY7_SHIFT_MS : t
// Row index (from the bottom) of a PnL value on the performance chart
perfLevel(float v, float vMin, float span, int rows) =>
span > 0 ? math.round((v - vMin) / span * (rows - 1)) : 0
drawEntryLabel(bool isLong, float price, float sl, float qty) =>
label result = na
if showEntryLabelsInput and not na(price) and not na(sl)
float oz = nz(qty) * syminfo.pointvalue
string txt = (isLong ? "▲ LONG" : "▼ SHORT") + "\nEntry " + priceStr(price) + "\nSL " + priceStr(sl) + " (" + str.tostring(safeDiv(math.abs(price - sl), price) * 100.0, "0.00") + "%)" + "\nSize " + str.tostring(oz, "0.####") + " " + unitLabel + (isOunceQuoted ? " · " + str.tostring(safeDiv(oz, lotOz), "0.####") + " lots" : "") + "\nRisk " + str.tostring(math.abs(price - sl) * oz, "0.00") + " " + syminfo.currency
result := label.new(bar_index, price, txt,
yloc = isLong ? yloc.belowbar : yloc.abovebar,
style = isLong ? label.style_label_up : label.style_label_down,
color = isLong ? bullColorInput : bearColorInput,
textcolor = isLong ? BULL_LABEL_TEXT : BEAR_LABEL_TEXT,
size = labelSize,
textalign = text.align_left,
tooltip = (isLong ? "Buy Signal" : "Sell Signal") + "\nReason: range breakout")
result
// Dashboard helpers: each returns the index of the next row
dashHeader(table t, int r, string s) =>
table.cell(t, 0, r, s, text_color = HEADER_TEXT, bgcolor = HEADER_BG, text_size = dashSize, text_halign = text.align_center)
table.merge_cells(t, 0, r, 1, r)
r + 1
dashRow(table t, int r, string k, string v, color valueColor) =>
color rowBg = r % 2 == 0 ? TABLE_BG : TABLE_ROW_ALT
table.cell(t, 0, r, k, text_color = TEXT_MUTED, bgcolor = rowBg, text_size = dashSize, text_halign = text.align_left)
table.cell(t, 1, r, v, text_color = valueColor, bgcolor = rowBg, text_size = dashSize, text_halign = text.align_right)
r + 1
// ══════════════════════════════════════════════════════════
// 6. CALCULATIONS
// ══════════════════════════════════════════════════════════
// The strategy runs on bar close only, so the forming bar is never the "last" one while the market is open;
// the last confirmed bar is used as well, otherwise tables would appear only after the next bar closes.
bool isLastBar = barstate.islast or barstate.islastconfirmedhistory
// The range is exact only when the timeframe divides an hour evenly; otherwise a warning is shown.
// Trading is disabled only when the session hours are out of order.
int tfSec = timeframe.in_seconds()
bool tfOk = tfSec > 0 and tfSec <= 3600 and 3600 % tfSec == 0
bool hoursOk = rangeFromInput < rangeToInput and rangeToInput < closeHourInput
bool envOk = hoursOk
// ── Bar time (broker clock) ─────────────────────
// nextHour is the hour of the next bar's open: orders placed now are filled on that bar.
int barTime = brokerClock(time)
int barHour = hour(barTime, calcTz)
int nextHour = hour(brokerClock(time_close), calcTz)
int dayKey = year(barTime, calcTz) * 10000 + month(barTime, calcTz) * 100 + dayofmonth(barTime, calcTz)
bool isNewDay = dayKey != nz(dayKey[1], -1)
bool inRange = barHour >= rangeFromInput and barHour < rangeToInput
// ── Daily range ─────────────────────────────────
var float rangeHigh = na
var float rangeLow = na
var int rangeStartBar = na
var int tradedDay = -1
var bool isHalted = false
var float dayEquityPeak = na
var float slActiveLong = na
var float slActiveShort = na
// The first day of loaded history is skipped: its range may be incomplete
var int firstDayKey = na
if na(firstDayKey)
firstDayKey := dayKey
float prevEquity = nz(strategy.equity[1], strategy.equity)
if isNewDay
rangeHigh := na
rangeLow := na
rangeStartBar := na
isHalted := false
dayEquityPeak := prevEquity
if inRange
if na(rangeHigh)
rangeStartBar := bar_index
rangeHigh := na(rangeHigh) ? high : math.max(rangeHigh, high)
rangeLow := na(rangeLow) ? low : math.min(rangeLow, low)
bool rangeReady = not na(rangeHigh) and not na(rangeLow) and rangeHigh > rangeLow
bool nextInWindow = nextHour >= rangeToInput and nextHour < closeHourInput
// ── Position state ──────────────────────────────
bool inPos = strategy.position_size != 0
bool posLong = strategy.position_size > 0
bool justOpened = inPos and strategy.position_size[1] == 0
if justOpened
tradedDay := dayKey // one trade per day
strategy.cancel("Long")
strategy.cancel("Short")
// In % mode the stop is re-set once from the actual fill price and then stays fixed
if slModeInput == SL_MODE_PCT
if posLong
slActiveLong := math.round_to_mintick(strategy.position_avg_price * (1.0 - slPctInput / 100.0))
else
slActiveShort := math.round_to_mintick(strategy.position_avg_price * (1.0 + slPctInput / 100.0))
// ── Closed-trade statistics ─────────────────────
// R = trade result divided by its initial risk (entry to stop)
var int seenClosed = 0
var int tradeCount = 0
var int winCount = 0
var int lossCount = 0
var float grossWin = 0.0
var float grossLoss = 0.0
var float sumR = 0.0
var int lossStreak = 0
var int maxLossStreak = 0
var float lastPnl = na
var float lastR = na
var array equityCurve = array.new()
var float cumPnl = 0.0
var int firstTradeTime = na
var int lastTradeTime = na
int newClosedFrom = seenClosed
int newClosedTo = strategy.closedtrades - 1
if newClosedTo >= newClosedFrom
for i = newClosedFrom to newClosedTo
float tSize = strategy.closedtrades.size(i)
float tPnl = strategy.closedtrades.profit(i)
float tEntry = strategy.closedtrades.entry_price(i)
float tSl = tSize > 0 ? slActiveLong : slActiveShort
float tRisk = strategy.convert_to_account(math.abs(tEntry - nz(tSl, tEntry)) * math.abs(tSize) * syminfo.pointvalue)
float tR = tRisk > 0 ? tPnl / tRisk : na
// Entry and exit inside one bar: the position is already flat at bar close, so count the day here
if strategy.closedtrades.entry_bar_index(i) == strategy.closedtrades.exit_bar_index(i)
tradedDay := dayKey
tradeCount += 1
if tPnl > 0
winCount += 1
grossWin += tPnl
lossStreak := 0
else if tPnl < 0
lossCount += 1
grossLoss += -tPnl
lossStreak += 1
maxLossStreak := math.max(maxLossStreak, lossStreak)
sumR += nz(tR)
lastPnl := tPnl
lastR := tR
cumPnl += tPnl
if showPerfInput
array.push(equityCurve, cumPnl)
if na(firstTradeTime)
firstTradeTime := strategy.closedtrades.entry_time(i)
lastTradeTime := strategy.closedtrades.exit_time(i)
seenClosed := strategy.closedtrades
// ── Equity drawdown (estimate) ──────────────────
// Uses the worst point of each candle (low for longs, high for shorts) against the equity peak reached before
// that candle. It is an estimate: the order of high and low inside a candle is unknown and the entry candle
// is measured at its close only.
var float equityHigh = strategy.initial_capital
var float maxDdPct = 0.0
var float maxDdMoney = 0.0
float adverseMove = inPos and not justOpened ? (posLong ? close - low : high - close) : 0.0
float worstEquity = strategy.equity - strategy.convert_to_account(math.max(adverseMove, 0.0) * math.abs(strategy.position_size) * syminfo.pointvalue)
maxDdPct := math.max(maxDdPct, safeDiv(equityHigh - worstEquity, equityHigh) * 100.0)
maxDdMoney := math.max(maxDdMoney, equityHigh - worstEquity)
equityHigh := math.max(equityHigh, strategy.equity)
float dayDdPct = math.max(safeDiv(dayEquityPeak - worstEquity, dayEquityPeak) * 100.0, 0.0)
dayEquityPeak := math.max(nz(dayEquityPeak, strategy.equity), strategy.equity)
// ══════════════════════════════════════════════════════════
// 7. SIGNAL LOGIC
// ══════════════════════════════════════════════════════════
// A breakout can be armed when the range is complete, the next bar opens inside the trading window,
// there is no position and no trade has been taken today
bool setupReady = envOk and rangeReady and nextInWindow and not inPos and tradedDay != dayKey and dayKey != firstDayKey
// ══════════════════════════════════════════════════════════
// 8. RISK MANAGEMENT (SL / SIZE / GUARD)
// ══════════════════════════════════════════════════════════
// Planned stop from the breakout level. Size = equity × risk% / (stop distance × point value),
// capped by Max Leverage and rounded down to the quantity step. Equity is converted to the symbol currency.
float slLong = slModeInput == SL_MODE_PCT ? math.round_to_mintick(rangeHigh * (1.0 - slPctInput / 100.0)) : rangeLow
float slShort = slModeInput == SL_MODE_PCT ? math.round_to_mintick(rangeLow * (1.0 + slPctInput / 100.0)) : rangeHigh
float riskLong = rangeHigh - slLong
float riskShort = slShort - rangeLow
float equitySym = strategy.convert_to_symbol(strategy.equity)
float riskMoney = equitySym * riskPctInput / 100.0
float rawQtyLong = sizeModeInput == SIZE_FIXED ? fixedQtyInput : (riskLong > 0 ? safeDiv(riskMoney, riskLong * syminfo.pointvalue) : 0.0)
float rawQtyShort = sizeModeInput == SIZE_FIXED ? fixedQtyInput : (riskShort > 0 ? safeDiv(riskMoney, riskShort * syminfo.pointvalue) : 0.0)
float capQtyLong = math.max(safeDiv(equitySym * maxLeverageInput, rangeHigh * syminfo.pointvalue), 0.0)
float capQtyShort = math.max(safeDiv(equitySym * maxLeverageInput, rangeLow * syminfo.pointvalue), 0.0)
bool isCappedLong = rawQtyLong > capQtyLong
bool isCappedShort = rawQtyShort > capQtyShort
float qtyStep = qtyStepInput > 0 ? qtyStepInput : nz(syminfo.mincontract)
float qtyLong = roundQtyDown(math.min(rawQtyLong, capQtyLong), qtyStep)
float qtyShort = roundQtyDown(math.min(rawQtyShort, capQtyShort), qtyStep)
string tplLongIn = webhookInput ? jsonLongInInput : textLongInInput
string tplShortIn = webhookInput ? jsonShortInInput : textShortInInput
string tplLongOut = webhookInput ? jsonLongOutInput : textLongOutInput
string tplShortOut = webhookInput ? jsonShortOutInput : textShortOutInput
string idPlan = syminfo.ticker + "-" + str.tostring(dayKey)
string idOpen = syminfo.ticker + "-" + str.tostring(tradedDay)
var float entryEquitySym = na
// ── Equity guard ────────────────────────────────
// Pending orders are cancelled before the close order is created: cancel_all would remove that order too
bool guardFired = false
if guardOnInput and not isHalted and dayDdPct >= guardDdInput
string guardMsg = inPos ? fillTemplate(posLong ? tplLongOut : tplShortOut, posLong, "exit", "equity_guard", close, strategy.position_avg_price, posLong ? slActiveLong : slActiveShort, math.abs(strategy.position_size), rangeHigh, rangeLow, idOpen, entryEquitySym) : ""
strategy.cancel_all()
strategy.close_all(comment = "Equity guard", alert_message = guardMsg)
isHalted := true
guardFired := true
// ── Orders ──────────────────────────────────────
// Both breakout entries share an OCA group: the first fill cancels the other. Each entry has its stop attached.
bool canTrade = setupReady and not isHalted
if canTrade
slActiveLong := slLong
slActiveShort := slShort
entryEquitySym := equitySym
if qtyLong > 0 and riskLong > 0
strategy.entry("Long", strategy.long, qty = qtyLong, stop = rangeHigh, oca_name = OCA_GROUP, oca_type = strategy.oca.cancel, comment = "RB long",
alert_message = fillTemplate(tplLongIn, true, "entry", "breakout", rangeHigh, rangeHigh, slLong, qtyLong, rangeHigh, rangeLow, idPlan, equitySym))
strategy.exit("SL-L", from_entry = "Long", stop = slLong, comment = "SL",
alert_message = fillTemplate(tplLongOut, true, "exit", "sl", slLong, rangeHigh, slLong, qtyLong, rangeHigh, rangeLow, idPlan, equitySym))
if qtyShort > 0 and riskShort > 0
strategy.entry("Short", strategy.short, qty = qtyShort, stop = rangeLow, oca_name = OCA_GROUP, oca_type = strategy.oca.cancel, comment = "RB short",
alert_message = fillTemplate(tplShortIn, false, "entry", "breakout", rangeLow, rangeLow, slShort, qtyShort, rangeHigh, rangeLow, idPlan, equitySym))
strategy.exit("SL-S", from_entry = "Short", stop = slShort, comment = "SL",
alert_message = fillTemplate(tplShortOut, false, "exit", "sl", slShort, rangeLow, slShort, qtyShort, rangeHigh, rangeLow, idPlan, equitySym))
else if not inPos
strategy.cancel("Long")
strategy.cancel("Short")
// ── Open position ───────────────────────────────
// No alert is sent when the stop is re-set: a bot placing its own stop should use {{sl_pct}} from its own fill
if inPos
float posQty = math.abs(strategy.position_size)
float posSl = posLong ? slActiveLong : slActiveShort
string posTpl = posLong ? tplLongOut : tplShortOut
float posEntry = strategy.position_avg_price
if posLong
strategy.exit("SL-L", from_entry = "Long", stop = slActiveLong, comment = "SL",
alert_message = fillTemplate(posTpl, true, "exit", "sl", posSl, posEntry, posSl, posQty, rangeHigh, rangeLow, idOpen, entryEquitySym))
else
strategy.exit("SL-S", from_entry = "Short", stop = slActiveShort, comment = "SL",
alert_message = fillTemplate(posTpl, false, "exit", "sl", posSl, posEntry, posSl, posQty, rangeHigh, rangeLow, idOpen, entryEquitySym))
// Time exit: the close order is filled on the open of the next bar
if (nextHour >= closeHourInput or nextHour < rangeToInput) and not guardFired
strategy.close_all(comment = "Time exit " + str.tostring(closeHourInput) + ":00",
alert_message = fillTemplate(posTpl, posLong, "exit", "time", close, posEntry, posSl, posQty, rangeHigh, rangeLow, idOpen, entryEquitySym))
// ══════════════════════════════════════════════════════════
// 9. PLOTS & VISUALS
// ══════════════════════════════════════════════════════════
// Range box while the range is building, then its boundaries extended over the trading session
var box rangeBox = na
var line highLine = na
var line lowLine = na
if showRangeInput
if isNewDay
rangeBox := na
highLine := na
lowLine := na
if inRange and not na(rangeHigh)
if na(rangeBox)
rangeBox := box.new(rangeStartBar, rangeHigh, bar_index, rangeLow, border_color = RANGE_BORDER, bgcolor = RANGE_BG)
else
box.set_top(rangeBox, rangeHigh)
box.set_bottom(rangeBox, rangeLow)
box.set_right(rangeBox, bar_index)
if not inRange and rangeReady and barHour < closeHourInput
if na(highLine)
string widthStr = priceStr(rangeHigh - rangeLow) + " (" + str.tostring(safeDiv(rangeHigh - rangeLow, rangeLow) * 100.0, "0.00") + "%)"
highLine := line.new(bar_index - 1, rangeHigh, bar_index, rangeHigh, color = rangeColorInput, width = 2)
lowLine := line.new(bar_index - 1, rangeLow, bar_index, rangeLow, color = rangeColorInput, width = 2)
label.new(bar_index, rangeHigh, "Range High " + priceStr(rangeHigh), style = label.style_label_down, color = rangeColorInput, textcolor = HEADER_TEXT, size = size.small)
label.new(bar_index, rangeLow, "Range Low " + priceStr(rangeLow) + " · width " + widthStr, style = label.style_label_up, color = rangeColorInput, textcolor = HEADER_TEXT, size = size.small)
else
line.set_x2(highLine, bar_index)
line.set_x2(lowLine, bar_index)
// ══════════════════════════════════════════════════════════
// 10. LABELS & SHAPES
// ══════════════════════════════════════════════════════════
// Entry label, then result label and trade box for every trade closed on this bar
var int lastEntryBar = -1
if justOpened
drawEntryLabel(posLong, strategy.position_avg_price, posLong ? slActiveLong : slActiveShort, math.abs(strategy.position_size))
lastEntryBar := bar_index
if newClosedTo >= newClosedFrom
for i = newClosedFrom to newClosedTo
float cSize = strategy.closedtrades.size(i)
bool cIsLong = cSize > 0
float cPnl = strategy.closedtrades.profit(i)
float cEntry = strategy.closedtrades.entry_price(i)
float cExit = strategy.closedtrades.exit_price(i)
int cEntryBar = strategy.closedtrades.entry_bar_index(i)
int cExitBar = strategy.closedtrades.exit_bar_index(i)
string cComment = strategy.closedtrades.exit_comment(i)
float cSl = cIsLong ? slActiveLong : slActiveShort
float cRisk = strategy.convert_to_account(math.abs(cEntry - nz(cSl, cEntry)) * math.abs(cSize) * syminfo.pointvalue)
float cR = cRisk > 0 ? cPnl / cRisk : na
float cMovePct = safeDiv(cExit - cEntry, cEntry) * 100.0 * (cIsLong ? 1.0 : -1.0)
bool cIsWin = cPnl >= 0
if cEntryBar == cExitBar and cEntryBar != lastEntryBar
drawEntryLabel(cIsLong, cEntry, cSl, math.abs(cSize))
lastEntryBar := cEntryBar
if showExitLabelsInput
string cReason = cComment == "SL" ? "stop-loss" : str.startswith(cComment, "Time") ? "time exit " + str.tostring(closeHourInput) + ":00" : cComment == "Equity guard" ? "equity guard" : cComment
string cRStr = na(cR) ? "" : signedStr(cR, "0.00") + "R · "
string cText = (cIsWin ? "✔ " : "✖ ") + signedStr(cPnl, "0.00") + " " + strategy.account_currency + "\n" + cRStr + "move " + signedStr(cMovePct, "0.00") + "%\nExit " + priceStr(cExit) + "\n" + cReason
label.new(cExitBar, cExit, cText,
yloc = cIsLong ? yloc.abovebar : yloc.belowbar,
style = cIsLong ? label.style_label_down : label.style_label_up,
color = cIsWin ? bullColorInput : bearColorInput,
textcolor = cIsWin ? BULL_LABEL_TEXT : BEAR_LABEL_TEXT,
size = labelSize,
textalign = text.align_left,
tooltip = "Trade closed\nReason: " + cReason)
if showTradeBoxInput
box.new(cEntryBar, math.max(cEntry, cExit), cExitBar, math.min(cEntry, cExit), border_color = color.new(cIsWin ? bullColorInput : bearColorInput, 50), bgcolor = cIsWin ? BULL_BG : BEAR_BG)
line.new(cEntryBar, cEntry, cExitBar, cExit, color = cIsWin ? BULL_TEXT : BEAR_TEXT, style = line.style_dotted, width = 1)
// Warnings: wrong session hours disable trading; timeframe and chart type only affect range accuracy
var label warnLabel = na
if isLastBar
string warnHours = not hoursOk ? "Trading is disabled:\n• Hours must satisfy: Range Start < Range End < Close Hour.\n" : ""
string warnChart = not chart.is_standard ? "• Non-standard chart (Heikin Ashi, Renko…): the range is built from synthetic candles.\n" : ""
string warnTf = not tfOk ? "• Timeframe above 1H or not dividing an hour evenly: candles cross the range window.\n" : ""
string warnNote = showWarningsInput and (warnChart != "" or warnTf != "") ? "Range may be inaccurate:\n" + warnChart + warnTf : ""
bool isSameCorner = showPerfInput and (showDashInput or showMathInput) and perfPosInput == dashPosInput
string warnLayout = isSameCorner ? "Layout:\n• Dashboard and Performance Chart share the same corner: move one of them.\n" : ""
string warnText = warnHours + warnNote + warnLayout
if warnText != ""
if na(warnLabel)
warnLabel := label.new(bar_index, high, warnText, style = label.style_label_down, color = WARN_BG, textcolor = WARN_TEXT, size = size.small, textalign = text.align_left)
else
label.set_xy(warnLabel, bar_index, high)
// ══════════════════════════════════════════════════════════
// 11. SL / ENTRY LINES
// ══════════════════════════════════════════════════════════
bool showLevels = showSlInput and inPos
entryPlot = plot(showLevels ? strategy.position_avg_price : na, "Entry Price", color = ENTRY_COLOR, style = plot.style_linebr, linewidth = 1)
slPlot = plot(showLevels ? (posLong ? slActiveLong : slActiveShort) : na, "Stop-Loss", color = SL_COLOR, style = plot.style_linebr, linewidth = 2)
fill(entryPlot, slPlot, color = color.new(#FF5252, 88), title = "Risk Zone")
// ══════════════════════════════════════════════════════════
// 12. DASHBOARD
// ══════════════════════════════════════════════════════════
var table dashTable = table.new(
position = dashPos,
columns = 2,
rows = 40,
bgcolor = TABLE_BG,
border_color = TABLE_BORDER,
border_width = 1,
frame_color = TABLE_BORDER,
frame_width = 1)
if isLastBar and (showDashInput or showMathInput)
int row = 0
string cur = " " + strategy.account_currency
string symCur = " " + syminfo.currency
if showDashInput
string trendStr = not rangeReady ? NO_VALUE : close > rangeHigh ? "Bullish (above range)" : close < rangeLow ? "Bearish (below range)" : "Neutral (inside range)"
color trendColor = not rangeReady ? TEXT_COLOR : close > rangeHigh ? BULL_TEXT : close < rangeLow ? BEAR_TEXT : NEUTRAL_TEXT
string disabledStr = "Disabled (check hours)"
string signalStr = not envOk ? disabledStr : isHalted ? "Halted: equity guard" : inPos ? (posLong ? "Long" : "Short") : inRange ? "Building range" : tradedDay == dayKey ? "Done for today" : rangeReady and barHour >= rangeToInput and barHour < closeHourInput ? "Wait breakout" : "Outside session"
color signalColor = inPos ? (posLong ? BULL_TEXT : BEAR_TEXT) : isHalted or not envOk ? BEAR_TEXT : TEXT_COLOR
string widthStr = rangeReady ? priceStr(rangeHigh - rangeLow) + " (" + str.tostring(safeDiv(rangeHigh - rangeLow, rangeLow) * 100.0, "0.00") + "%)" : NO_VALUE
row := dashHeader(dashTable, row, "Gold Breakout 15M · " + syminfo.ticker)
row := dashRow(dashTable, row, "Trend", trendStr, trendColor)
row := dashRow(dashTable, row, "Signal", signalStr, signalColor)
row := dashRow(dashTable, row, "Timeframe", timeframe.period + " · " + tzLabel, TEXT_COLOR)
row := dashRow(dashTable, row, "Session", str.tostring(rangeToInput) + ":00 – " + str.tostring(closeHourInput) + ":00", TEXT_COLOR)
row := dashRow(dashTable, row, "Range", rangeReady ? priceStr(rangeLow) + " – " + priceStr(rangeHigh) : NO_VALUE, TEXT_COLOR)
row := dashRow(dashTable, row, "Range width", widthStr, TEXT_COLOR)
float openRisk = inPos ? strategy.convert_to_account(math.abs(strategy.position_avg_price - nz(posLong ? slActiveLong : slActiveShort, strategy.position_avg_price)) * math.abs(strategy.position_size) * syminfo.pointvalue) : 0.0
string openRStr = openRisk > 0 ? " · " + signedStr(strategy.openprofit / openRisk, "0.00") + "R" : ""
string openStr = inPos ? signedStr(strategy.openprofit, "0.00") + cur + openRStr : NO_VALUE
row := dashRow(dashTable, row, "Open P&L", openStr, not inPos ? TEXT_COLOR : strategy.openprofit >= 0 ? BULL_TEXT : BEAR_TEXT)
row := dashRow(dashTable, row, "Day drawdown (est.)", str.tostring(dayDdPct, "0.00") + "%", guardOnInput and dayDdPct >= guardDdInput ? BEAR_TEXT : TEXT_COLOR)
float ozLong = nz(qtyLong) * syminfo.pointvalue
float ozShort = nz(qtyShort) * syminfo.pointvalue
float slPctLong = safeDiv(riskLong, rangeHigh) * 100.0
float slPctShort = safeDiv(riskShort, rangeLow) * 100.0
float slPctMax = math.max(slPctLong, slPctShort)
color riskColor = slPctMax > 3.0 ? BEAR_TEXT : slPctMax > 1.0 ? NEUTRAL_TEXT : BULL_TEXT
string slStr = rangeReady ? priceStr(slLong) + " / " + priceStr(slShort) : NO_VALUE
string distStr = rangeReady ? priceStr(riskLong) + " / " + priceStr(riskShort) : NO_VALUE
string riskPctStr = rangeReady ? str.tostring(slPctLong, "0.00") + "% / " + str.tostring(slPctShort, "0.00") + "%" : NO_VALUE
string riskUsdStr = rangeReady ? str.tostring(riskLong * ozLong, "0.00") + " / " + str.tostring(riskShort * ozShort, "0.00") + symCur : NO_VALUE
string ozStr = rangeReady ? str.tostring(ozLong, "0.####") + " / " + str.tostring(ozShort, "0.####") : NO_VALUE
string lotsStr = rangeReady and isOunceQuoted ? str.tostring(safeDiv(ozLong, lotOz), "0.####") + " / " + str.tostring(safeDiv(ozShort, lotOz), "0.####") : NO_VALUE
string notionalStr = rangeReady ? str.tostring(ozLong * rangeHigh, "0") + " / " + str.tostring(ozShort * rangeLow, "0") + symCur : NO_VALUE
string leverageStr = rangeReady ? "×" + str.tostring(safeDiv(ozLong * rangeHigh, equitySym), "0.00") + " / ×" + str.tostring(safeDiv(ozShort * rangeLow, equitySym), "0.00") : NO_VALUE
row := dashHeader(dashTable, row, "Position Plan · current range (long / short)")
row := dashRow(dashTable, row, "SL", slStr, SL_COLOR)
row := dashRow(dashTable, row, "SL distance", distStr, TEXT_COLOR)
row := dashRow(dashTable, row, "SL distance, % of price", riskPctStr, rangeReady ? riskColor : TEXT_COLOR)
row := dashRow(dashTable, row, "Risk amount", riskUsdStr, TEXT_COLOR)
row := dashRow(dashTable, row, "Size, " + unitLabel, ozStr, TEXT_COLOR)
row := dashRow(dashTable, row, "Size, lots", lotsStr, TEXT_COLOR)
row := dashRow(dashTable, row, "Notional", notionalStr, TEXT_COLOR)
row := dashRow(dashTable, row, "Leverage vs equity", leverageStr, TEXT_COLOR)
bool isBelowStep = rangeReady and (qtyLong <= 0 or qtyShort <= 0)
bool isCapped = rangeReady and (isCappedLong or isCappedShort)
string limitStr = not rangeReady ? NO_VALUE : isBelowStep ? "Below min step: side skipped" : isCapped ? "Capped by max leverage" : "OK"
color limitColor = not rangeReady ? TEXT_COLOR : isBelowStep ? BEAR_TEXT : isCapped ? NEUTRAL_TEXT : BULL_TEXT
row := dashRow(dashTable, row, "Size limits", limitStr, limitColor)
if showMathInput
float winRate = tradeCount > 0 ? 100.0 * winCount / tradeCount : na
float avgWin = winCount > 0 ? grossWin / winCount : na
float avgLoss = lossCount > 0 ? grossLoss / lossCount : na
float payoff = not na(avgWin) and not na(avgLoss) and avgLoss > 0 ? avgWin / avgLoss : na
float profitFactor = grossLoss > 0 ? grossWin / grossLoss : na
float expectancy = tradeCount > 0 ? (grossWin - grossLoss) / tradeCount : na
float expectancyR = tradeCount > 0 ? sumR / tradeCount : na
float breakevenWr = not na(payoff) ? 100.0 / (1.0 + payoff) : na
float netPct = safeDiv(strategy.netprofit, strategy.initial_capital) * 100.0
string tradesStr = str.tostring(tradeCount) + " (" + str.tostring(winCount) + " / " + str.tostring(lossCount) + ")"
string avgStr = numStr(avgWin, "0.00") + " / " + numStr(avgLoss, "0.00") + cur
string expStr = na(expectancy) ? NO_VALUE : signedStr(expectancy, "0.00") + cur + " · " + signedStr(expectancyR, "0.00") + "R"
string netStr = signedStr(strategy.netprofit, "0.00") + cur + " (" + signedStr(netPct, "0.00") + "%)"
string lastStr = na(lastPnl) ? NO_VALUE : signedStr(lastPnl, "0.00") + cur + (na(lastR) ? "" : " · " + signedStr(lastR, "0.00") + "R")
color wrColor = na(breakevenWr) or na(winRate) ? TEXT_COLOR : winRate >= breakevenWr ? BULL_TEXT : BEAR_TEXT
color pfColor = na(profitFactor) ? TEXT_COLOR : profitFactor >= 1 ? BULL_TEXT : BEAR_TEXT
color expColor = na(expectancy) ? TEXT_COLOR : expectancy >= 0 ? BULL_TEXT : BEAR_TEXT
color lastColor = na(lastPnl) ? TEXT_COLOR : lastPnl >= 0 ? BULL_TEXT : BEAR_TEXT
row := dashHeader(dashTable, row, "Strategy Math")
row := dashRow(dashTable, row, "Trades (win / loss)", tradesStr, TEXT_COLOR)
row := dashRow(dashTable, row, "Win rate", na(winRate) ? NO_VALUE : str.tostring(winRate, "0.0") + "%", wrColor)
row := dashRow(dashTable, row, "Breakeven win rate", na(breakevenWr) ? NO_VALUE : str.tostring(breakevenWr, "0.0") + "%", TEXT_COLOR)
row := dashRow(dashTable, row, "Profit factor", numStr(profitFactor, "0.00"), pfColor)
row := dashRow(dashTable, row, "Avg win / avg loss", avgStr, TEXT_COLOR)
row := dashRow(dashTable, row, "Payoff (win ÷ loss)", numStr(payoff, "0.00"), TEXT_COLOR)
row := dashRow(dashTable, row, "Expectancy per trade", expStr, expColor)
row := dashRow(dashTable, row, "Net profit", netStr, strategy.netprofit >= 0 ? BULL_TEXT : BEAR_TEXT)
row := dashRow(dashTable, row, "Max equity drawdown (est.)", str.tostring(maxDdPct, "0.00") + "%", TEXT_COLOR)
row := dashRow(dashTable, row, "Max losing streak", str.tostring(maxLossStreak), TEXT_COLOR)
row := dashRow(dashTable, row, "Last trade", lastStr, lastColor)
table.cell(dashTable, 0, row, "Version", text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.tiny, text_halign = text.align_left)
table.cell(dashTable, 1, row, STRATEGY_VERSION, text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.tiny, text_halign = text.align_right)
// ══════════════════════════════════════════════════════════
// 12b. PERFORMANCE CHART
// ══════════════════════════════════════════════════════════
// Cumulative PnL of closed trades, drawn with table cells so it stays fixed on screen.
// X axis is the trade number; each column spans the lowest and highest PnL of its trades.
// It covers the bars loaded on the chart, not the Deep Backtesting range. Redrawn only after a new closed trade.
var table perfTable = na
var bool perfMerged = false
var int perfDrawnCount = -1
if isLastBar and showPerfInput
int pCols = perfColsInput
int pRows = perfRowsInput
int pTop = 3
int pDates = pRows + pTop
if na(perfTable)
perfTable := table.new(
position = perfPos,
columns = pCols + 1,
rows = pRows + pTop + 1,
bgcolor = TABLE_BG,
border_color = TRANSPARENT,
border_width = 0,
frame_color = TABLE_BORDER,
frame_width = 1)
// ── Key stats ───────────────────────────────
string pCur = " " + strategy.account_currency
float pNetPct = safeDiv(strategy.netprofit, strategy.initial_capital) * 100.0
float pWinRate = tradeCount > 0 ? 100.0 * winCount / tradeCount : na
float pPf = grossLoss > 0 ? grossWin / grossLoss : na
string pPnlStr = signedStr(strategy.netprofit, "#,##0.00") + pCur + " " + signedStr(pNetPct, "0.00") + "%"
string pDdStr = str.tostring(maxDdMoney, "#,##0.00") + pCur + " " + str.tostring(maxDdPct, "0.00") + "%"
string pWinStr = (na(pWinRate) ? NO_VALUE : str.tostring(pWinRate, "0.00") + "%") + " " + str.tostring(winCount) + "/" + str.tostring(tradeCount)
string pPfStr = numStr(pPf, "0.000")
color pPnlColor = strategy.netprofit >= 0 ? BULL_TEXT : BEAR_TEXT
int pBlock = int(pCols / 4)
table.cell(perfTable, 0, 0, "Key stats · Cumulative PnL · " + syminfo.ticker + " " + timeframe.period, text_color = HEADER_TEXT, bgcolor = HEADER_BG, text_size = size.small, text_halign = text.align_left)
table.cell(perfTable, 0, 1, "Total PnL", text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.small, text_halign = text.align_left)
table.cell(perfTable, pBlock, 1, "Max drawdown", text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.small, text_halign = text.align_left)
table.cell(perfTable, pBlock * 2, 1, "Profitable trades", text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.small, text_halign = text.align_left)
table.cell(perfTable, pBlock * 3, 1, "Profit factor", text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.small, text_halign = text.align_left)
table.cell(perfTable, 0, 2, pPnlStr, text_color = pPnlColor, bgcolor = TABLE_BG, text_size = size.normal, text_halign = text.align_left)
table.cell(perfTable, pBlock, 2, pDdStr, text_color = TEXT_COLOR, bgcolor = TABLE_BG, text_size = size.normal, text_halign = text.align_left)
table.cell(perfTable, pBlock * 2, 2, pWinStr, text_color = TEXT_COLOR, bgcolor = TABLE_BG, text_size = size.normal, text_halign = text.align_left)
table.cell(perfTable, pBlock * 3, 2, pPfStr, text_color = TEXT_COLOR, bgcolor = TABLE_BG, text_size = size.normal, text_halign = text.align_left)
int pMid = int(pRows / 2)
int pHalf = int(pCols / 2)
int pCount = array.size(equityCurve)
if pCount != perfDrawnCount
int pPts = pCount + 1
float pMax = pCount > 0 ? math.max(array.max(equityCurve), 0.0) : 0.0
float pMin = pCount > 0 ? math.min(array.min(equityCurve), 0.0) : 0.0
float pSpan = pMax - pMin
int pZero = perfLevel(0.0, pMin, pSpan, pRows)
float pCellW = perfWidthInput / pCols
float pCellH = perfHeightInput / pRows
int pPrevIdx = -1
int pPrevLevel = pZero
for c = 0 to pCols - 1
int pIdx = math.round(1.0 * c * (pPts - 1) / (pCols - 1))
float pVal = pIdx == 0 ? 0.0 : array.get(equityCurve, pIdx - 1)
float pBMin = pVal
float pBMax = pVal
if pIdx - pPrevIdx > 1
for k = pPrevIdx + 1 to pIdx - 1
float pMidVal = k == 0 ? 0.0 : array.get(equityCurve, k - 1)
pBMin := math.min(pBMin, pMidVal)
pBMax := math.max(pBMax, pMidVal)
int pLevel = perfLevel(pVal, pMin, pSpan, pRows)
int pLineLo = math.min(perfLevel(pBMin, pMin, pSpan, pRows), pPrevLevel)
int pLineHi = math.max(perfLevel(pBMax, pMin, pSpan, pRows), pPrevLevel)
for r = 0 to pRows - 1
int pH = pRows - 1 - r
bool pIsLine = pH >= pLineLo and pH <= pLineHi
color pColor = pIsLine ? (pVal >= 0 ? BULL_TEXT : BEAR_TEXT) : (pH >= pZero and pH < pLineLo) ? PERF_FILL_UP : (pH <= pZero and pH > pLineHi) ? PERF_FILL_DN : TRANSPARENT
table.cell(perfTable, c, r + pTop, "", width = pCellW, height = pCellH, bgcolor = pColor, text_size = size.tiny)
pPrevIdx := pIdx
pPrevLevel := pLevel
string pMaxStr = signedStr(pMax, "#,##0")
string pMinStr = signedStr(pMin, "#,##0")
table.cell(perfTable, pCols, pTop, pMaxStr, text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.small, text_halign = text.align_left, text_valign = text.align_top)
table.cell(perfTable, pCols, pTop + pMid, pMinStr, text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.small, text_halign = text.align_left, text_valign = text.align_bottom)
perfDrawnCount := pCount
string pFromStr = na(firstTradeTime) ? "No closed trades yet" : str.format_time(firstTradeTime, "yyyy-MM-dd", syminfo.timezone) + " · closed trades, x = trade #"
string pToStr = na(lastTradeTime) ? "" : str.format_time(lastTradeTime, "yyyy-MM-dd", syminfo.timezone)
table.cell(perfTable, 0, pDates, pFromStr, text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.small, text_halign = text.align_left)
table.cell(perfTable, pHalf, pDates, pToStr, text_color = TEXT_MUTED, bgcolor = TABLE_BG, text_size = size.small, text_halign = text.align_right)
if not perfMerged
table.merge_cells(perfTable, 0, 0, pCols, 0)
table.merge_cells(perfTable, 0, 1, pBlock - 1, 1)
table.merge_cells(perfTable, pBlock, 1, pBlock * 2 - 1, 1)
table.merge_cells(perfTable, pBlock * 2, 1, pBlock * 3 - 1, 1)
table.merge_cells(perfTable, pBlock * 3, 1, pCols, 1)
table.merge_cells(perfTable, 0, 2, pBlock - 1, 2)
table.merge_cells(perfTable, pBlock, 2, pBlock * 2 - 1, 2)
table.merge_cells(perfTable, pBlock * 2, 2, pBlock * 3 - 1, 2)
table.merge_cells(perfTable, pBlock * 3, 2, pCols, 2)
table.merge_cells(perfTable, pCols, pTop, pCols, pTop + pMid - 1)
table.merge_cells(perfTable, pCols, pTop + pMid, pCols, pTop + pRows - 1)
table.merge_cells(perfTable, 0, pDates, pHalf - 1, pDates)
table.merge_cells(perfTable, pHalf, pDates, pCols, pDates)
perfMerged := true
// ══════════════════════════════════════════════════════════
// 13. WATERMARK
// ══════════════════════════════════════════════════════════
bool isWmBlocked = showPerfInput and perfPosInput == "Bottom Center"
if isLastBar and showWatermarkInput and not isWmBlocked
var wmTable = table.new(
position = position.bottom_center,
columns = 1,
rows = 1,
bgcolor = TRANSPARENT,
border_color = TRANSPARENT,
border_width = 0,
frame_color = TRANSPARENT,
frame_width = 0)
table.cell(wmTable, 0, 0, "WillyAlgoTrader",
text_color = WM_COLOR,
text_size = size.normal,
text_halign = text.align_center,
bgcolor = TRANSPARENT)
// ══════════════════════════════════════════════════════════
// 14. ALERTS
// ══════════════════════════════════════════════════════════
// Alert messages are attached to the orders in section 8 and are sent when an order is filled.
// This block only previews the four templates in Pine Logs.
if showPreviewInput and barstate.islastconfirmedhistory
float pvHigh = nz(rangeHigh, close)
float pvLow = nz(rangeLow, close)
float pvSlL = nz(slLong, pvHigh * 0.99)
float pvSlS = nz(slShort, pvLow * 1.01)
log.info("LONG ENTRY → " + maskSecret(fillTemplate(tplLongIn, true, "entry", "breakout", pvHigh, pvHigh, pvSlL, nz(qtyLong, 1.0), pvHigh, pvLow, idPlan, equitySym)))
log.info("SHORT ENTRY → " + maskSecret(fillTemplate(tplShortIn, false, "entry", "breakout", pvLow, pvLow, pvSlS, nz(qtyShort, 1.0), pvHigh, pvLow, idPlan, equitySym)))
log.info("LONG EXIT → " + maskSecret(fillTemplate(tplLongOut, true, "exit", "time", close, pvHigh, pvSlL, nz(qtyLong, 1.0), pvHigh, pvLow, idPlan, equitySym)))
log.info("SHORT EXIT → " + maskSecret(fillTemplate(tplShortOut, false, "exit", "time", close, pvLow, pvSlS, nz(qtyShort, 1.0), pvHigh, pvLow, idPlan, equitySym)))