# Deepwick Script

Deepwick Script è il linguaggio dei grafici e dei backtest di Deepwick. È un
**sottoinsieme di Pine Script v5/v6**: la maggior parte delle chiamate `ta.*`, `math.*`,
`str.*`, `array.*`, `map.*`, `input.*`, `plot*` e `strategy.*` funziona esattamente come
in Pine. Deepwick non è affiliata a TradingView; Pine Script è un marchio di TradingView, Inc.

Uno script viene eseguito una volta per barra, dalla più vecchia alla più recente, e ogni
variabile conserva il suo storico: la stessa semantica di serie che in Pine.

## Le regole che contano quando generi codice

- **Guarda l'elenco delle non supportate prima di scrivere.** Una chiamata non supportata è l'errore più costoso qui: quasi tutte compilano e restituiscono `na` in silenzio, quindi uno script può sembrare corretto e non disegnare nulla.
- **`request.security()` funziona per una temporalità superiore del simbolo stesso del grafico.** `request.security(syminfo.tickerid, "240", close)` dà l'ultimo close *chiuso* a 4h, e l'espressione può essere una chiamata `ta.*`. Un altro **simbolo** restituisce `na`: il motore detiene solo le barre del grafico, quindi non andrà a cercarne un altro.
- **Niente lookahead.** Il broker del backtest non riempie mai un ordine con dati del futuro: gli ordini a mercato si riempiono all'*apertura della barra successiva*.
- **I costi sono reali.** Ogni esecuzione paga commissione e slippage come dichiarato in `strategy()`. Una strategia redditizia a costo zero può non esserlo con quelli.
- **Stop e limiti seguono la barra**, nell'ordine apertura, estremo più vicino, estremo più lontano, chiusura. Un ordine che il prezzo ha scavalcato con un gap si riempie all'apertura.
- **Dichiara con `=`, riassegna con `:=`.** Usa `var` per lo stato che deve persistere tra le barre.
- **L'indentazione è di quattro spazi.** Pine non ha graffe; i blocchi di `if`/`for`/`while`/`switch` sono blocchi indentati.
- **Gli argomenti con nome vanno per ultimi.** Appena scrivi `nome=`, anche tutti gli argomenti successivi devono avere un nome: `plotshape(series=x, title="t", style=shape.circle)` è valido, `plotshape(x, "t", style=…)` no. Mescolare un posizionale dopo uno con nome ferma lo script con un errore di sintassi.
- **Un'uscita non può scattare sulla barra che l'ha emessa.** Un `strategy.entry` a mercato si riempie all'*apertura della barra successiva*, quindi uno `strategy.exit` scritto su quella barra può riempirsi solo dalla successiva in poi. Un prezzo che era già sceso sotto il tuo stop sulla barra che l'ha emesso non viene eseguito contro di te.
- **Un'uscita a due gambe scatta una volta sola.** Quando una gamba di `strategy.exit(stop=…, limit=…)` si riempie, l'altra viene annullata con lei: un'operazione, mai due. Se la barra raggiunge entrambi i livelli, vince quello raggiunto per primo seguendo il percorso della barra.
- **Stop dinamici:** `strategy.exit(trail_points=N, trail_offset=M)`. Entrambi sono in **tick**, non in unità di prezzo. `trail_offset` è il profitto che va ripulito prima che lo stop si armi; `trail_points` è la distanza tenuta dal miglior prezzo raggiunto. Lo stop scatta solo a tuo favore e si muove su barre chiuse.

## Riferimento delle funzioni

Le firme e cosa fa ognuna. Gli argomenti sono nell'ordine in cui li scrivi.

### Linguaggio

Deepwick Script esegue un sottoinsieme di Pine Script, compresi enum, tipi definiti dall'utente, metodi e map; la riga //@version non viene controllata. Uno script viene eseguito una volta per barra, dalla più vecchia alla più recente, e ogni variabile conserva il suo storico.

- `x = expr / x := expr` — Dichiara una variabile e poi la riassegna con :=. Davanti al nome può precedere un tipo facoltativo (int, float, bool, string, color, series, simple, const, line, label).
- `var / varip` — Si inizializza una sola volta sulla prima barra e conserva il valore da una barra all'altra. varip si comporta come var, perché gli script girano su barre chiuse.
- `x[n]` — Operatore di storico: il valore di x di n barre fa (na prima della prima barra).
- `if / else` — Blocchi condizionali, con rientro di quattro spazi. if si può usare anche come espressione.
- `cond ? a : b` — Operatore ternario.
- `switch` — Ramificazione multipla, con o senza un valore da confrontare.
- `for i = a to b [by step]` — Loop con contatore. break e continue sono supportati.
- `while cond` — Loop finché una condizione resta vera.
- `f(x, y) => expr` — Funzione definita dall'utente, su una riga o come blocco rientrato la cui ultima espressione viene restituita. Ogni punto di chiamata conserva il proprio stato ta.*, come in Pine.
- `[a, b] = f()` — Tuple: le funzioni possono restituire più valori, e lo fanno anche le native come ta.macd() e ta.bb().
- `and / or / not` — Operatori logici. Aritmetica: + - * / %; confronto: == != < <= > >=.

### Dichiarazioni

- `indicator(title, shorttitle, overlay, precision)` (study) — Dichiara un indicatore: disegna sul grafico e non ha nulla da testare. study() è accettato come alias.
- `strategy(title, overlay, initial_capital, default_qty_type, default_qty_value, commission_type, commission_value, slippage, pyramiding)` — Dichiara una strategia. Predefiniti: initial_capital 100000, 1 contratto per ordine, commissione 0, slippage 0 tick, pyramiding 1. Gli altri argomenti, come process_orders_on_close, vengono ignorati.

### Ingressi

Gli ingressi compaiono accanto all'editor e nelle impostazioni dell'indicatore, così puoi cambiarli senza toccare il codice.

- `input.int(defval, title, minval, maxval, step)` — Numero intero.
- `input.float(defval, title, minval, maxval, step)` — Numero decimale.
- `input.bool(defval, title)` — Casella di controllo.
- `input.string(defval, title, options)` — Testo, o un elenco di opzioni.
- `input.session(defval, title)` — Una sessione di trading come "0930-1600", o giorni come "23456". Passala a session.ismarket() e agli altri predicati session.*.
- `input.source(defval, title)` — Una fonte di prezzo: open, high, low, close, hl2, hlc3, ohlc4 o hlcc4.
- `input.color(defval, title)` — Selettore di colore.
- `input(defval, title)` — Ingresso generico; il tipo segue il valore predefinito.

### Dati e tempo della barra

I tempi sono millisecondi UTC. hour() e le altre funzioni di tempo accettano un tempo facoltativo; hour() accetta anche un fuso orario da un elenco fisso di scostamenti, senza l'ora legale.

- `open, high, low, close, volume` (open, high, low, close, volume) — Prezzi e volume della barra corrente.
- `hl2, hlc3, ohlc4, hlcc4` (hl2, hlc3, ohlc4, hlcc4) — Medie di prezzo usuali.
- `bar_index, last_bar_index` (bar_index, last_bar_index) — Indice della barra corrente (0 è la più vecchia) e dell'ultima barra.
- `time, time_close` (time, time_close) — Ora di apertura e di chiusura della barra. Come funzioni — time("D"), time(timeframe.period, "0000-0900:23456", "UTC") — l'inizio (o la fine) della barra di temporalità superiore che la contiene, o na quando la barra è fuori sessione. Sessioni: "HHMM-HHMM", anche notturne, più finestre separate da virgole, giorni facoltativi dopo i due punti (1 = domenica … 7 = sabato), "24x7".
- `timeframe.change(timeframe)` — Vero sulla prima barra di ogni nuovo periodo, ad es. timeframe.change("D") sulla prima barra di ogni giorno (le settimane iniziano il lunedì).
- `timestamp(timezone?, year, month, day, hour, minute, second)` — Un tempo in millisecondi dalle sue parti, o da una data in testo: timestamp("2026-01-05T09:30:00Z").
- `dayofweek.sunday … dayofweek.saturday` (dayofweek.monday, dayofweek.tuesday, dayofweek.wednesday, dayofweek.thursday, dayofweek.friday, dayofweek.saturday) — Costanti di giorno da confrontare con dayofweek (1 … 7).
- `session.ismarket, isfirstbar, islastbar, ispremarket, ispostmarket` (session.ismarket, session.isfirstbar, session.islastbar, session.ispremarket, session.ispostmarket) — Stato della sessione. Qui i mercati negoziano pressoché senza sosta, quindi ogni barra è in sessione; isfirstbar / islastbar segnano la prima e l'ultima barra di ogni giorno UTC.
- `year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second` (year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second) — Parti di calendario dell'ora della barra; chiamabili anche con un tempo, ad es. hour(time, "America/New_York"). dayofweek: 1 = domenica … 7 = sabato.
- `barstate.isfirst, islast, isnew, isconfirmed, ishistory, isrealtime` (barstate.isfirst, barstate.islast, barstate.isnew, barstate.isconfirmed, barstate.ishistory, barstate.isrealtime) — Dove si trova lo script nella storia delle barre.
- `timeframe.period, multiplier, isintraday, isdaily, isweekly, ismonthly` (timeframe.period, timeframe.multiplier, timeframe.isintraday, timeframe.isdaily, timeframe.isweekly, timeframe.ismonthly) — La temporalità del grafico.
- `syminfo.ticker, tickerid, mintick, pointvalue` (syminfo.ticker, syminfo.tickerid, syminfo.mintick, syminfo.pointvalue) — Il simbolo del grafico, il suo passo di prezzo e il suo valore del punto.

### Analisi tecnica (ta.*)

Ogni punto di chiamata conserva il proprio stato, come in Pine: due chiamate ta.ema() su righe diverse sono due medie indipendenti. Il risultato è na finché non ci sono barre sufficienti.

- `ta.sma(source, length)` — Media mobile semplice.
- `ta.ema(source, length)` — Media mobile esponenziale.
- `ta.rma(source, length)` — Media mobile di Wilder, usata da RSI e ATR.
- `ta.wma(source, length)` — Media mobile ponderata.
- `ta.vwma(source, length)` — Media mobile ponderata sul volume.
- `ta.hma(source, length)` — Media mobile di Hull.
- `ta.linreg(source, length, offset)` — Valore della retta di regressione lineare.
- `ta.vwap(source)` — Prezzo medio ponderato sul volume, che riparte alle 00:00 UTC di ogni giorno.
- `ta.rsi(source, length)` — Indice di forza relativa, da 0 a 100.
- `ta.macd(source, fastlen, slowlen, siglen)` — Restituisce [macd, signal, histogram].
- `ta.stoch(source, high, low, length)` — Stochastic %K, da 0 a 100.
- `ta.cci(source, length)` — Commodity Channel Index.
- `ta.mfi(series, length)` — Money Flow Index.
- `ta.wpr(length)` — Williams %R, da -100 a 0.
- `ta.dmi(diLength, adxSmoothing)` — Restituisce [+DI, -DI, ADX].
- `ta.supertrend(factor, atrPeriod)` — Restituisce [supertrend, direction]; la direzione è -1 in un rialzo e 1 in un ribasso.
- `ta.sar(start, inc, max)` — SAR parabolico.
- `ta.mom(source, length)` — Momentum: la fonte meno la fonte di length barre fa.
- `ta.roc(source, length)` — Variazione percentuale, in percentuale.
- `ta.change(source, length)` — Differenza rispetto a length barre fa (1 per predefinito).
- `ta.tr / ta.tr(handle_na)` — True range.
- `ta.atr(length)` — Average true range (Wilder).
- `ta.bb(series, length, mult)` — Bande di Bollinger: restituisce [middle, upper, lower].
- `ta.bbw(series, length, mult)` — Ampiezza delle bande di Bollinger: (upper - lower) / middle.
- `ta.kc(series, length, mult)` — Canali di Keltner: restituisce [middle, upper, lower], con una media esponenziale del true range.
- `ta.stdev(source, length, biased)` — Deviazione standard.
- `ta.variance(source, length, biased)` — Varianza.
- `ta.dev(source, length)` — Scarto medio assoluto.
- `ta.median(source, length)` — Mediana.
- `ta.highest(source, length) / ta.highest(length)` — Valore massimo sulle ultime length barre (il high per predefinito).
- `ta.lowest(source, length) / ta.lowest(length)` — Valore minimo sulle ultime length barre (il low per predefinito).
- `ta.highestbars(source, length)` — Scostamento rispetto al valore massimo: 0 o negativo.
- `ta.lowestbars(source, length)` — Scostamento rispetto al valore minimo: 0 o negativo.
- `ta.rising(source, length)` — Vero se la fonte è sopra ognuno dei suoi length valori precedenti.
- `ta.falling(source, length)` — Vero se la fonte è sotto ognuno dei suoi length valori precedenti.
- `ta.crossover(source1, source2)` — Vero sulla barra in cui source1 incrocia sopra source2.
- `ta.crossunder(source1, source2)` — Vero sulla barra in cui source1 incrocia sotto source2.
- `ta.cross(source1, source2)` — Vero su un incrocio in entrambe le direzioni.
- `ta.pivothigh(source, leftbars, rightbars)` — Il prezzo del pivot high, noto rightbars barre dopo il pivot; na altrimenti. La fonte è facoltativa (il high per predefinito).
- `ta.pivotlow(source, leftbars, rightbars)` — Il prezzo del pivot low, noto rightbars barre dopo il pivot; na altrimenti. La fonte è facoltativa (il low per predefinito).
- `ta.valuewhen(condition, source, occurrence)` — Valore della fonte sulla occurrence-esima barra più recente in cui la condizione era vera.
- `ta.barssince(condition)` — Barre da quando la condizione è stata vera l'ultima volta.
- `ta.cum(source)` — Totale cumulato dalla prima barra.

### Strategie (strategy.*)

Gli ordini a mercato vengono eseguiti all'apertura della barra successiva. Stop e limit si eseguono lungo la barra: apertura, poi l'estremo più vicino all'apertura, poi l'altro estremo, poi la chiusura. Se il prezzo apre un gap attraverso un ordine, l'ordine viene eseguito all'apertura. La commissione è addebitata a ogni esecuzione; lo slippage vale per le esecuzioni a mercato e stop.

- `strategy.entry(id, direction, qty, limit, stop, comment)` — Apre o aumenta una posizione; ordine a mercato se non sono indicati limit o stop.
- `strategy.order(id, direction, qty, limit, stop, comment)` — Gli stessi argomenti di strategy.entry().
- `strategy.exit(id, from_entry, qty_percent, profit, limit, loss, stop, trail_points, trail_offset, comment)` — Take-profit, stop-loss e trailing stop di un ingresso: profitto e perdita in tick, limit e stop come prezzi. trail_points è la distanza in TICK dal miglior prezzo raggiunto; trail_offset è il profitto in tick che va ripulito prima che il trailing stop si armi. Lo stop scatta solo a tuo favore e si muove su barre CHIUSE, così una barra non può mai eseguire lo stop che il suo stesso massimo ha impostato.
- `strategy.close(id, comment, qty_percent)` — Chiude un ingresso a mercato alla barra successiva.
- `strategy.close_all(comment)` — Chiude tutte le posizioni aperte.
- `strategy.cancel(id) / strategy.cancel_all()` (strategy.cancel_all) — Annulla gli ordini in attesa.
- `strategy.position_size, position_avg_price` (strategy.position_size, strategy.position_avg_price) — Posizione attuale (positiva long, negativa short) e il suo prezzo medio.
- `strategy.opentrades.entry_bar_index(n), entry_price, entry_time, entry_id, size, profit, commission, max_runup, max_drawdown` (strategy.opentrades.entry_price, strategy.opentrades.entry_time, strategy.opentrades.entry_id, strategy.opentrades.size, strategy.opentrades.profit, strategy.opentrades.commission, strategy.opentrades.max_runup, strategy.opentrades.max_drawdown) — Dettagli dell'operazione aperta n (0 = la più vecchia); na se non esiste. size è negativo sulle short. Es. uscire dopo 10 barre: bar_index - strategy.opentrades.entry_bar_index(0) >= 10.
- `strategy.closedtrades.entry_bar_index(n), exit_bar_index, entry_price, exit_price, entry_time, exit_time, entry_id, size, profit, commission, max_runup, max_drawdown` (strategy.closedtrades.exit_bar_index, strategy.closedtrades.entry_price, strategy.closedtrades.exit_price, strategy.closedtrades.entry_time, strategy.closedtrades.exit_time, strategy.closedtrades.entry_id, strategy.closedtrades.size, strategy.closedtrades.profit, strategy.closedtrades.commission, strategy.closedtrades.max_runup, strategy.closedtrades.max_drawdown) — Dettagli dell'operazione chiusa n (0 = la più vecchia; l'ultima è strategy.closedtrades - 1).
- `strategy.equity, netprofit, openprofit, grossprofit, grossloss, initial_capital` (strategy.equity, strategy.netprofit, strategy.openprofit, strategy.grossprofit, strategy.grossloss, strategy.initial_capital) — Numeri del conto.
- `strategy.closedtrades, opentrades, wintrades, losstrades` (strategy.closedtrades, strategy.opentrades, strategy.wintrades, strategy.losstrades) — Conteggi delle operazioni.
- `strategy.long, strategy.short` (strategy.long, strategy.short) — Direzioni.
- `strategy.fixed, strategy.cash, strategy.percent_of_equity` (strategy.fixed, strategy.cash, strategy.percent_of_equity) — Valori per default_qty_type.
- `strategy.commission.percent, cash_per_order, cash_per_contract` (strategy.commission.percent, strategy.commission.cash_per_order, strategy.commission.cash_per_contract) — Valori per commission_type.

### Grafici e avvisi

- `plot(series, title, color, linewidth, style)` — Disegna una serie sul grafico o in un riquadro.
- `plotshape(series, title, style, location, color, text)` — Disegna una forma sulle barre in cui series è vera.
- `plotchar(series, title, char, location, color)` — Disegna un carattere sulle barre in cui series è vera.
- `hline(price, title, color, linestyle)` — Linea orizzontale a un livello fisso.
- `fill(plot1, plot2, color)` — Riempie tra due grafici o due hlines.
- `bgcolor(color)` — Colora lo sfondo della barra.
- `barcolor(color)` — Colora la barra stessa.
- `alertcondition(condition, title, message)` — Dichiara una condizione che puoi trasformare in un avviso via email, Telegram, Discord o webhook.
- `plot.style_*` (plot.style_line, plot.style_linebr, plot.style_stepline, plot.style_histogram, plot.style_columns, plot.style_circles, plot.style_cross, plot.style_area) — line, linebr, stepline, histogram, columns, circles, cross, area.
- `hline.style_*` (hline.style_solid, hline.style_dashed, hline.style_dotted) — solid, dashed, dotted.
- `shape.*` (shape.triangleup, shape.triangledown, shape.arrowup, shape.arrowdown, shape.circle, shape.xcross, shape.cross, shape.diamond, shape.square, shape.flag, shape.labelup, shape.labeldown) — triangleup, triangledown, arrowup, arrowdown, circle, xcross, cross, diamond, square, flag, labelup, labeldown.
- `location.*` (location.abovebar, location.belowbar, location.top, location.bottom, location.absolute) — abovebar, belowbar, top, bottom, absolute.
- `size.*` (size.auto, size.tiny, size.small, size.normal, size.large, size.huge) — auto, tiny, small, normal, large, huge. Accettato, ma le forme vengono disegnate tutte della stessa dimensione.

### Linee e riquadri

- `line.new(x1, y1, x2, y2, extend, color, style, width)` — Disegna una linea tra due indici di barra e due prezzi; restituisce il suo id.
- `line.set_x1, set_y1, set_x2, set_y2, set_xy1, set_xy2, set_color, set_style, set_width` (line.set_x1, line.set_y1, line.set_x2, line.set_y2, line.set_xy1, line.set_xy2, line.set_color, line.set_style, line.set_width) — Modifica una linea.
- `line.delete(id)` — Rimuove una linea.
- `box.new(left, top, right, bottom, border_color, bgcolor, extend)` — Disegna un rettangolo; restituisce il suo id.
- `box.set_left, set_top, set_right, set_bottom, set_bgcolor, set_border_color, set_extend` (box.set_left, box.set_top, box.set_right, box.set_bottom, box.set_bgcolor, box.set_border_color, box.set_extend) — Modifica un riquadro.
- `box.delete(id)` — Rimuove un riquadro.
- `line.style_*, box.style_*` (line.style_solid, line.style_dashed, line.style_dotted, box.style_solid, box.style_dashed, box.style_dotted) — solid, dashed, dotted.
- `extend.*` (extend.none, extend.left, extend.right, extend.both) — none, left, right, both.

### Matematica, stringhe e colori

- `math.abs, ceil, floor, round(number, precision), sign, sqrt, exp, log, log10, pow(base, exponent)` (math.abs, math.ceil, math.floor, math.round, math.sign, math.sqrt, math.exp, math.log, math.log10, math.pow) — Aritmetica.
- `math.max(...), math.min(...), math.avg(...)` (math.min, math.avg) — Su un numero qualsiasi di valori.
- `math.sum(source, length)` — Somma sulle ultime length barre.
- `math.pi, math.e` (math.pi, math.e) — Costanti.
- `na, na(x), nz(x, replacement), fixnan(x)` (na, nz, fixnan) — Il valore mancante, un test per esso, una sostituzione e l'ultimo valore non-na.
- `int(x), float(x), bool(x)` (float, bool) — Conversioni.
- `str.tostring(value, format), str.format(text, ...), str.length(s), str.contains(s, part)` (str.format, str.length, str.contains) — Stringhe. str.format sostituisce {0}, {1}… con gli argomenti.
- `color.new(color, transp), color.rgb(red, green, blue, transp)` (color.rgb) — Costruisce un colore; la trasparenza va da 0 a 100.
- `color.*` (color.red, color.green, color.blue, color.orange, color.yellow, color.purple, color.aqua, color.lime, color.fuchsia, color.teal, color.maroon, color.navy, color.olive, color.gray, color.silver, color.white, color.black) — red, green, blue, orange, yellow, purple, aqua, lime, fuchsia, teal, maroon, navy, olive, gray, silver, white, black.

### Array (array.*)

- `array.new_float, new_int, new_bool, new_string, new_color, new_line, new_box, new_label, new_table(size)` (array.new_float, array.new_int, array.new_bool, array.new_string, array.new_color, array.new_line, array.new_box, array.new_label, array.new_table) — Crea un array.
- `array.get, set, insert, push, pop, shift, unshift` (array.get, array.set, array.insert, array.push, array.pop, array.shift, array.unshift) — Legge e modifica gli elementi.
- `array.size, first, last, sum, avg, min, max, stdev` (array.size, array.first, array.last, array.sum, array.avg, array.min, array.max, array.stdev) — Dimensione e statistiche.

### Map e tipi definiti dall'utente

I tipi definiti dall'utente e la collezione `map.<fn>` sono supportati. Entrambi sono dichiarazioni di primo livello; i metodi di istanza su un valore usano la sintassi `obj.method(args...)`.

- `enum Name
    Member
    Member = N
    ...` — Dichiarazione di enum di primo livello. I membri senza valore si incrementano da soli da 0; i valori espliciti possono essere numeri o stringhe. Si accede come `Name.Member` in qualsiasi posizione di espressione. I valori di enum sono numeri (o stringhe) semplici, quindi funzionano con gli operatori di confronto e con `int()` senza conversione.
- `type Name
    field1
    field2: int
    field3 = default` — Tipo definito dall'utente, di primo livello. I campi si elencano uno per riga; le parti `: type` e `= default` sono accettate per compatibilità futura ma non sono ancora validate. Si costruisce con `Type.new(arg1, arg2, ...)` e i campi si leggono con `instance.field`.
- `m = map.new<int, float>()` (map.new) — Crea una map vuota. Gli argomenti di tipo `<K, V>` sono accettati ma ignorati a runtime.
- `m = map.put(m, key, value)` (map.put) — Imposta una chiave. Restituisce la map, così le chiamate possono essere concatenate o riassegnate.
- `v = map.get(m, key)` (map.get) — Legge un valore. Restituisce na se la chiave non c'è.
- `n = map.size(m)` (map.size) — Numero di voci.
- `keys = map.keys(m), values = map.values(m)` (map.keys, map.values) — Restituisce le chiavi o i valori come array di Pine (ordine di inserimento).
- `map.contains(m, key), map.remove(m, key)` (map.remove) — Test di appartenenza e cancellazione. Entrambi restituiscono la map.

## Non ancora disponibile

Una funzione che il motore non conosce ferma lo script con «Unknown function» e la riga e la colonna.

- `label.new(), table.new()`: Non ancora disponibile. Linee e riquadri sì.
- `import, matrix.*, array.new<type>()`: Librerie, matrici e costruttori di array tipati non sono ancora implementati.
- `strategy.risk.*`: Le regole di rischio (max_position_size, max_intraday_loss, max_drawdown, allow_entry_in) non sono supportate. I trailing stop in strategy.exit() sì: usa trail_points e trail_offset.

## Esempi eseguibili

Script inclusi che compilano con questo motore:

**RSI Mean Reversion**

```pine
//@version=5
strategy("RSI Mean Reversion", overlay=false, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=10, commission_type=strategy.commission.percent, commission_value=0.1)
len = input.int(14, "RSI length", minval=2)
oversold = input.float(30, "Oversold")
exitLevel = input.float(50, "Exit level")
stopPct = input.float(2, "Stop loss %", minval=0, step=0.1)
tpPct = input.float(6, "Take profit %", minval=0, step=0.1)
if strategy.position_size > 0
    strategy.exit("Risk", stop=stopPct > 0 ? strategy.position_avg_price * (1 - stopPct / 100) : na, limit=tpPct > 0 ? strategy.position_avg_price * (1 + tpPct / 100) : na)
r = ta.rsi(close, len)
if strategy.position_size == 0 and r < oversold
    strategy.entry("Long", strategy.long)
if strategy.position_size > 0 and r > exitLevel
    strategy.close("Long", comment="RSI exit")
plot(r, "RSI", color=color.purple)
hline(oversold, "Oversold", color=color.green)
hline(exitLevel, "Exit", color=color.gray)
```

**MACD Crossover**

```pine
//@version=5
strategy("MACD Crossover", overlay=false, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=10, commission_type=strategy.commission.percent, commission_value=0.1)
fast = input.int(12, "Fast", minval=1)
slow = input.int(26, "Slow", minval=2)
sig = input.int(9, "Signal", minval=1)
stopPct = input.float(2, "Stop loss %", minval=0, step=0.1)
tpPct = input.float(6, "Take profit %", minval=0, step=0.1)
if strategy.position_size > 0
    strategy.exit("Risk", stop=stopPct > 0 ? strategy.position_avg_price * (1 - stopPct / 100) : na, limit=tpPct > 0 ? strategy.position_avg_price * (1 + tpPct / 100) : na)
[m, s, h] = ta.macd(close, fast, slow, sig)
if ta.crossover(m, s)
    strategy.entry("Long", strategy.long)
if ta.crossunder(m, s)
    strategy.close("Long", comment="MACD cross")
plot(h, "Histogram", color=h >= 0 ? color.new(color.green, 40) : color.new(color.red, 40), style=plot.style_columns)
plot(m, "MACD", color=color.orange)
plot(s, "Signal", color=color.blue)
```

**Bollinger Bounce**

```pine
//@version=5
strategy("Bollinger Bounce", overlay=true, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=10, commission_type=strategy.commission.percent, commission_value=0.1)
len = input.int(20, "Length", minval=2)
mult = input.float(2, "StdDev", minval=0.5, step=0.1)
stopPct = input.float(2, "Stop loss %", minval=0, step=0.1)
tpPct = input.float(6, "Take profit %", minval=0, step=0.1)
if strategy.position_size > 0
    strategy.exit("Risk", stop=stopPct > 0 ? strategy.position_avg_price * (1 - stopPct / 100) : na, limit=tpPct > 0 ? strategy.position_avg_price * (1 + tpPct / 100) : na)
[basis, upper, lower] = ta.bb(close, len, mult)
if strategy.position_size == 0 and close <= lower
    strategy.entry("Long", strategy.long)
if strategy.position_size > 0 and close >= basis
    strategy.close("Long", comment="Back to mean")
u = plot(upper, "Upper", color=color.blue)
plot(basis, "Basis", color=color.gray)
l = plot(lower, "Lower", color=color.blue)
fill(u, l, color=color.new(color.blue, 92))
```

## Elsewhere

- Human reference: https://deepwick.com/it/docs/script
- Try a script with no signup: https://deepwick.com/try