# Deepwick Script

O Deepwick Script é a linguagem dos gráficos e backtests da Deepwick. É um
**subconjunto do Pine Script v5/v6**: a maioria das chamadas `ta.*`, `math.*`, `str.*`,
`array.*`, `map.*`, `input.*`, `plot*` e `strategy.*` funciona exatamente como no Pine.
A Deepwick não tem relação com o TradingView; Pine Script é uma marca registada da
TradingView, Inc.

Um script é executado uma vez por barra, da mais antiga para a mais recente, e cada
variável guarda o seu historial: a mesma semântica de séries que no Pine.

## Regras que importam ao gerar código

- **Consulta a lista de não suportado antes de escreveres.** Uma chamada não suportada é o erro mais caro aqui: quase todas compilam e devolvem `na` em silêncio, por isso um script pode parecer correto e não desenhar nada.
- **`request.security()` funciona para uma temporalidade superior do próprio símbolo do gráfico.** `request.security(syminfo.tickerid, "240", close)` dá o último fecho *fechado* de 4h, e a expressão pode ser uma chamada `ta.*`. Outro **símbolo** devolve `na`: o motor só tem as barras do gráfico, portanto não vai buscar outro.
- **Sem lookahead.** O bróker do backtest nunca preenche uma ordem com dados do futuro: as ordens a mercado preenchem-se na *apertura da barra seguinte*.
- **Os custos são reais.** Cada execução paga comissão e slippage conforme declarado em `strategy()`. Uma estratégia lucrativa a custo zero pode não o ser com eles.
- **Stops e limites seguem a barra**, pela ordem abertura, extremo mais próximo, extremo mais distante, fecho. Uma ordem que a barra saltou preenche-se na abertura.
- **Declara com `=`, reatribui com `:=`.** Usa `var` para o estado que tem de persistir entre barras.
- **A indentação são quatro espaços.** O Pine não tem chavetas; os blocos de `if`/`for`/`while`/`switch` são blocos indentados.
- **Os argumentos com nome vão no fim.** A partir do momento em que escreves `nome=`, todos os argumentos seguintes também têm de ter nome: `plotshape(series=x, title="t", style=shape.circle)` é válido, `plotshape(x, "t", style=…)` não. Misturar posicionais depois de nomeados trava o script com um erro de sintaxe.
- **Uma saída não pode disparar na barra que a emitiu.** Uma `strategy.entry` a mercado preenche-se na *apertura da barra seguinte*, por isso um `strategy.exit` escrito nessa barra só pode preencher-se a partir da seguinte. Um preço que já desceu abaixo do teu stop na barra que o emitiu não é executado contra ti.
- **Uma saída de duas pernas dispara uma vez.** Quando uma perna de `strategy.exit(stop=…, limit=…)` se preenche, a outra é cancelada com ela: uma operação, nunca duas. Se a barra alcançar os dois níveis, ganha o que for alcançado primeiro seguindo o percurso da barra.
- **Stops dinâmicos:** `strategy.exit(trail_points=N, trail_offset=M)`. Ambos estão em **ticks**, não em unidades de preço. `trail_offset` é o lucro que tem de ser limpo antes de o stop armar; `trail_points` é a distância mantida a partir do melhor preço alcançado. O stop só ratcheta a teu favor e move-se em barras fechadas.

## Referência de funções

As assinaturas e o que cada uma faz. Os argumentos vão na ordem em que os escreves.

### Linguagem

O Deepwick Script executa um subconjunto do Pine Script, incluindo enums, tipos definidos pelo utilizador, métodos e maps; a linha //@version não é verificada. Um script executa uma vez por barra, da mais antiga para a mais recente, e cada variável guarda o seu histórico.

- `x = expr / x := expr` — Declara uma variável e depois reatribui-a com :=. Pode ser precedida por um tipo opcional (int, float, bool, string, color, series, simple, const, line, label).
- `var / varip` — Inicializa uma única vez na primeira barra e mantém o valor entre barras. O varip comporta-se como o var, porque os scripts correm sobre barras fechadas.
- `x[n]` — Operador de histórico: o valor de x há n barras (na antes da primeira barra).
- `if / else` — Blocos condicionais, com indentação de quatro espaços. O if também pode ser usado como expressão.
- `cond ? a : b` — Operador ternário.
- `switch` — Ramificação múltipla, com ou sem um valor a comparar.
- `for i = a to b [by step]` — Loop com contador. O break e o continue são suportados.
- `while cond` — Loop enquanto uma condição se mantiver.
- `f(x, y) => expr` — Função definida pelo utilizador, numa linha ou como um bloco indentado cuja última expressão é devolvida. Cada ponto de chamada guarda o seu próprio estado ta.*, tal como no Pine.
- `[a, b] = f()` — Tuplas: as funções podem devolver vários valores, e as nativas como ta.macd() e ta.bb() também.
- `and / or / not` — Operadores lógicos. Aritmética: + - * / %; comparação: == != < <= > >=.

### Declarações

- `indicator(title, shorttitle, overlay, precision)` (study) — Declara um indicador: desenha no gráfico e não tem nada para testar. study() é aceite como apelido.
- `strategy(title, overlay, initial_capital, default_qty_type, default_qty_value, commission_type, commission_value, slippage, pyramiding)` — Declara a estratégia. Predefinições: initial_capital 100000, 1 contrato por ordem, comissão 0, slippage 0 ticks, pyramiding 1. Outros argumentos, como process_orders_on_close, são ignorados.

### Entradas

As entradas aparecem ao lado do editor e nas definições do indicador, para as poderes mudar sem tocar no código.

- `input.int(defval, title, minval, maxval, step)` — Número inteiro.
- `input.float(defval, title, minval, maxval, step)` — Número decimal.
- `input.bool(defval, title)` — Caixa de verificação.
- `input.string(defval, title, options)` — Texto, ou uma lista de opções.
- `input.session(defval, title)` — Uma sessão de trading como "0930-1600", ou dias como "23456". Passe-a a session.ismarket() e aos outros predicados session.*.
- `input.source(defval, title)` — Uma fonte de preço: open, high, low, close, hl2, hlc3, ohlc4 ou hlcc4.
- `input.color(defval, title)` — Seletor de cor.
- `input(defval, title)` — Entrada genérica; o tipo segue o valor por defeito.

### Dados e tempo da barra

Os tempos são milissegundos UTC. hour() e as outras funções de tempo aceitam um tempo opcional; hour() aceita também um fuso horário de uma lista fixa de desvios, sem hora de verão.

- `open, high, low, close, volume` (open, high, low, close, volume) — Preços e volume da barra atual.
- `hl2, hlc3, ohlc4, hlcc4` (hl2, hlc3, ohlc4, hlcc4) — Médias de preço usuais.
- `bar_index, last_bar_index` (bar_index, last_bar_index) — Índice da barra atual (0 é a mais antiga) e da última barra.
- `time, time_close` (time, time_close) — Hora de abertura e de fecho da barra. Como funções — time("D"), time(timeframe.period, "0000-0900:23456", "UTC") — o início (ou o fim) da barra de temporalidade maior que contém esta, ou na quando a barra está fora da sessão. Sessões: "HHMM-HHMM", também nocturnas, várias janelas separadas por vírgulas, dias opcionais após dois pontos (1 = domingo … 7 = sábado), "24x7".
- `timeframe.change(timeframe)` — Verdadeiro na primeira barra de cada novo período, p. ex. timeframe.change("D") na primeira barra de cada dia (as semanas começam à segunda-feira).
- `timestamp(timezone?, year, month, day, hour, minute, second)` — Um tempo em milissegundos a partir das suas partes, ou de uma data em texto: timestamp("2026-01-05T09:30:00Z").
- `dayofweek.sunday … dayofweek.saturday` (dayofweek.monday, dayofweek.tuesday, dayofweek.wednesday, dayofweek.thursday, dayofweek.friday, dayofweek.saturday) — Constantes de dia para comparar com dayofweek (1 … 7).
- `session.ismarket, isfirstbar, islastbar, ispremarket, ispostmarket` (session.ismarket, session.isfirstbar, session.islastbar, session.ispremarket, session.ispostmarket) — Estado da sessão. Aqui os mercados negociam quase sem parar, por isso cada barra está na sessão de mercado; isfirstbar / islastbar marcam a primeira e a última barra de cada dia UTC.
- `year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second` (year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second) — Partes de calendário da hora da barra; também se podem chamar com um tempo, p. ex. hour(time, "America/New_York"). dayofweek: 1 = domingo … 7 = sábado.
- `barstate.isfirst, islast, isnew, isconfirmed, ishistory, isrealtime` (barstate.isfirst, barstate.islast, barstate.isnew, barstate.isconfirmed, barstate.ishistory, barstate.isrealtime) — Onde o script está no histórico de barras.
- `timeframe.period, multiplier, isintraday, isdaily, isweekly, ismonthly` (timeframe.period, timeframe.multiplier, timeframe.isintraday, timeframe.isdaily, timeframe.isweekly, timeframe.ismonthly) — A temporalidade do gráfico.
- `syminfo.ticker, tickerid, mintick, pointvalue` (syminfo.ticker, syminfo.tickerid, syminfo.mintick, syminfo.pointvalue) — O símbolo do gráfico, o seu passo de preço e o seu valor do ponto.

### Análise técnica (ta.*)

Cada ponto de chamada guarda o seu próprio estado, tal como no Pine: duas chamadas ta.ema() em linhas diferentes são duas médias independentes. O resultado é na até existirem barras suficientes.

- `ta.sma(source, length)` — Média móvel simples.
- `ta.ema(source, length)` — Média móvel exponencial.
- `ta.rma(source, length)` — Média móvel de Wilder, usada pelo RSI e pelo ATR.
- `ta.wma(source, length)` — Média móvel ponderada.
- `ta.vwma(source, length)` — Média móvel ponderada pelo volume.
- `ta.hma(source, length)` — Média móvel de Hull.
- `ta.linreg(source, length, offset)` — Valor da reta de regressão linear.
- `ta.vwap(source)` — Preço médio ponderado pelo volume, que reinicia às 00:00 UTC de cada dia.
- `ta.rsi(source, length)` — Índice de Força Relativa, de 0 a 100.
- `ta.macd(source, fastlen, slowlen, siglen)` — Devolve [macd, signal, histogram].
- `ta.stoch(source, high, low, length)` — Estocástico %K, de 0 a 100.
- `ta.cci(source, length)` — Índice do Canal de Commodities.
- `ta.mfi(series, length)` — Índice de Fluxo de Dinheiro.
- `ta.wpr(length)` — Williams %R, de -100 a 0.
- `ta.dmi(diLength, adxSmoothing)` — Devolve [+DI, -DI, ADX].
- `ta.supertrend(factor, atrPeriod)` — Devolve [supertrend, direction]; a direção é -1 numa tendência de alta e 1 numa de baixa.
- `ta.sar(start, inc, max)` — SAR Parabólico.
- `ta.mom(source, length)` — Momento: a fonte menos a fonte de há length barras.
- `ta.roc(source, length)` — Variação percentual, em percentagem.
- `ta.change(source, length)` — Diferença face a há length barras (1 por defeito).
- `ta.tr / ta.tr(handle_na)` — True range.
- `ta.atr(length)` — Average true range (Wilder).
- `ta.bb(series, length, mult)` — Bandas de Bollinger: devolve [middle, upper, lower].
- `ta.bbw(series, length, mult)` — Largura das bandas de Bollinger: (upper - lower) / middle.
- `ta.kc(series, length, mult)` — Canais de Keltner: devolve [middle, upper, lower], com uma média exponencial do true range.
- `ta.stdev(source, length, biased)` — Desvio-padrão.
- `ta.variance(source, length, biased)` — Variância.
- `ta.dev(source, length)` — Desvio absoluto médio.
- `ta.median(source, length)` — Mediana.
- `ta.highest(source, length) / ta.highest(length)` — Valor máximo nas últimas length barras (o high por defeito).
- `ta.lowest(source, length) / ta.lowest(length)` — Valor mínimo nas últimas length barras (o low por defeito).
- `ta.highestbars(source, length)` — Deslocamento até ao valor máximo: 0 ou negativo.
- `ta.lowestbars(source, length)` — Deslocamento até ao valor mínimo: 0 ou negativo.
- `ta.rising(source, length)` — Verdadeiro se a fonte estiver acima de cada um dos seus length valores anteriores.
- `ta.falling(source, length)` — Verdadeiro se a fonte estiver abaixo de cada um dos seus length valores anteriores.
- `ta.crossover(source1, source2)` — Verdadeiro na barra em que source1 cruza por cima de source2.
- `ta.crossunder(source1, source2)` — Verdadeiro na barra em que source1 cruza por baixo de source2.
- `ta.cross(source1, source2)` — Verdadeiro num cruzamento em qualquer direção.
- `ta.pivothigh(source, leftbars, rightbars)` — O preço do pivot high, conhecido rightbars barras depois do pivô; na caso contrário. A fonte é opcional (o high por defeito).
- `ta.pivotlow(source, leftbars, rightbars)` — O preço do pivot low, conhecido rightbars barras depois do pivô; na caso contrário. A fonte é opcional (o low por defeito).
- `ta.valuewhen(condition, source, occurrence)` — Valor da fonte na ocorrência-ésima barra mais recente em que a condição foi verdadeira.
- `ta.barssince(condition)` — Barras desde a última vez em que a condição foi verdadeira.
- `ta.cum(source)` — Total acumulado desde a primeira barra.

### Estratégias (strategy.*)

As ordens a mercado executam na abertura da barra seguinte. As ordens stop e limitada executam ao longo da barra: abertura, depois o extremo mais perto da abertura, depois o outro extremo, depois o fecho. Se o preço abrir um intervalo por cima da ordem, executa na abertura. A comissão é cobrada em cada execução; o slippage aplica-se às execuções a mercado e stop.

- `strategy.entry(id, direction, qty, limit, stop, comment)` — Abre ou aumenta uma posição; ordem a mercado salvo se for dado limit ou stop.
- `strategy.order(id, direction, qty, limit, stop, comment)` — Os mesmos argumentos que 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 de uma entrada: lucro e perda em ticks, limit e stop como preços. trail_points é a distância em TICKS desde o melhor preço alcançado; trail_offset é o lucro em ticks que tem de ser limpo antes de o trailing stop armar. O stop só ratcheta a teu favor e move-se em barras FECHADAS, por isso nenhuma barra pode executar o stop que o seu próprio máximo definiu.
- `strategy.close(id, comment, qty_percent)` — Fecha uma entrada a mercado na barra seguinte.
- `strategy.close_all(comment)` — Fecha todas as posições abertas.
- `strategy.cancel(id) / strategy.cancel_all()` (strategy.cancel_all) — Cancela as ordens pendentes.
- `strategy.position_size, position_avg_price` (strategy.position_size, strategy.position_avg_price) — Posição atual (positiva longa, negativa curta) e o seu preço médio.
- `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) — Detalhes da operação aberta n (0 = a mais antiga); na se não existir. O size é negativo nas curtas. Ex. sair após 10 barras: 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) — Detalhes da operação fechada n (0 = a mais antiga; a última é strategy.closedtrades - 1).
- `strategy.equity, netprofit, openprofit, grossprofit, grossloss, initial_capital` (strategy.equity, strategy.netprofit, strategy.openprofit, strategy.grossprofit, strategy.grossloss, strategy.initial_capital) — Cifras da conta.
- `strategy.closedtrades, opentrades, wintrades, losstrades` (strategy.closedtrades, strategy.opentrades, strategy.wintrades, strategy.losstrades) — Contagens de operações.
- `strategy.long, strategy.short` (strategy.long, strategy.short) — Direções.
- `strategy.fixed, strategy.cash, strategy.percent_of_equity` (strategy.fixed, strategy.cash, strategy.percent_of_equity) — Valores para 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) — Valores para commission_type.

### Gráficos e alertas

- `plot(series, title, color, linewidth, style)` — Desenha uma série no gráfico ou num painel.
- `plotshape(series, title, style, location, color, text)` — Desenha uma forma nas barras onde series é verdadeira.
- `plotchar(series, title, char, location, color)` — Desenha um carácter nas barras onde series é verdadeira.
- `hline(price, title, color, linestyle)` — Linha horizontal num nível fixo.
- `fill(plot1, plot2, color)` — Preenche entre dois plots ou duas hlines.
- `bgcolor(color)` — Colore o fundo da barra.
- `barcolor(color)` — Colore a própria barra.
- `alertcondition(condition, title, message)` — Declara uma condição que podes converter num alerta por email, Telegram, Discord ou 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. Aceite, mas as formas são desenhadas todas com o mesmo tamanho.

### Linhas e caixas

- `line.new(x1, y1, x2, y2, extend, color, style, width)` — Desenha uma linha entre dois índices de barra e dois preços; devolve o seu 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) — Altera uma linha.
- `line.delete(id)` — Remove uma linha.
- `box.new(left, top, right, bottom, border_color, bgcolor, extend)` — Desenha um retângulo; devolve o seu 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) — Altera uma caixa.
- `box.delete(id)` — Remove uma caixa.
- `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.

### Matemática, cadeias de caracteres e cores

- `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) — Aritmética.
- `math.max(...), math.min(...), math.avg(...)` (math.min, math.avg) — De qualquer número de valores.
- `math.sum(source, length)` — Soma nas últimas length barras.
- `math.pi, math.e` (math.pi, math.e) — Constantes.
- `na, na(x), nz(x, replacement), fixnan(x)` (na, nz, fixnan) — O valor em falta, um teste para ele, uma substituição e o último valor não-na.
- `int(x), float(x), bool(x)` (float, bool) — Conversões.
- `str.tostring(value, format), str.format(text, ...), str.length(s), str.contains(s, part)` (str.format, str.length, str.contains) — Cadeias de caracteres. str.format substitui {0}, {1}… pelos argumentos.
- `color.new(color, transp), color.rgb(red, green, blue, transp)` (color.rgb) — Constrói uma cor; a transparência vai de 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.

### Arrays (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) — Cria um array.
- `array.get, set, insert, push, pop, shift, unshift` (array.get, array.set, array.insert, array.push, array.pop, array.shift, array.unshift) — Lê e altera elementos.
- `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) — Tamanho e estatística.

### Maps e tipos definidos pelo utilizador

Os tipos definidos pelo utilizador e a coleção `map.<fn>` são suportados. Ambos são declarações de topo; os métodos de instância sobre um valor usam a sintaxe `obj.method(args...)`.

- `enum Name
    Member
    Member = N
    ...` — Declaração de enum de topo. Os membros sem valor incrementam automaticamente desde 0; os valores explícitos podem ser números ou cadeias. Acede-se como `Name.Member` em qualquer posição de expressão. Os valores de enum são números (ou cadeias) simples, por isso funcionam com operadores de comparação e com `int()` sem conversão.
- `type Name
    field1
    field2: int
    field3 = default` — Tipo definido pelo utilizador, de topo. Os campos listam-se um por linha; as partes `: type` e `= default` são aceites para compatibilidade futura mas ainda não são validadas. Constrói-se com `Type.new(arg1, arg2, ...)` e leem-se os campos com `instance.field`.
- `m = map.new<int, float>()` (map.new) — Cria um map vazio. Os argumentos de tipo `<K, V>` são aceites mas ignorados em execução.
- `m = map.put(m, key, value)` (map.put) — Define uma chave. Devolve o map para que as chamadas possam ser encadeadas ou reatribuídas.
- `v = map.get(m, key)` (map.get) — Lê um valor. Devolve na se a chave não existir.
- `n = map.size(m)` (map.size) — Número de entradas.
- `keys = map.keys(m), values = map.values(m)` (map.keys, map.values) — Devolve as chaves ou os valores como um array do Pine (ordem de inserção).
- `map.contains(m, key), map.remove(m, key)` (map.remove) — Teste de pertença e eliminação. Ambos devolvem o map.

## Ainda não disponível

Uma função que o motor não conhece interrompe o script com "Unknown function" e a linha e a coluna.

- `label.new(), table.new()`: Ainda não disponível. Linhas e caixas já estão.
- `import, matrix.*, array.new<type>()`: As bibliotecas, as matrizes e os construtores de array tipados ainda não estão implementados.
- `strategy.risk.*`: As regras de risco (max_position_size, max_intraday_loss, max_drawdown, allow_entry_in) não são suportadas. Os trailing stops em strategy.exit() são: usa trail_points e trail_offset.

## Exemplos executáveis

Scripts incluídos que compilam contra este motor:

**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/pt/docs/script
- Try a script with no signup: https://deepwick.com/try