# Deepwick Script

Deepwick Script es el lenguaje de los gráficos y backtests de Deepwick. Es un
**subconjunto de Pine Script v5/v6**: la mayoría de llamadas `ta.*`, `math.*`, `str.*`,
`array.*`, `map.*`, `input.*`, `plot*` y `strategy.*` funcionan exactamente igual que en
Pine. Deepwick no tiene relación con TradingView; Pine Script es una marca de
TradingView, Inc.

Un script se ejecuta una vez por vela, de la más antigua a la más reciente, y cada
variable guarda su historial: la misma semántica de series que en Pine.

## Reglas que importan al generar código

- **Mira la lista de no soportado antes de escribir.** Una llamada no soportada es el error más caro aquí: casi todas compilan y devuelven `na` en silencio, así que un script puede parecer correcto y no dibujar nada.
- **`request.security()` funciona para una temporalidad superior del propio símbolo del gráfico.** `request.security(syminfo.tickerid, "240", close)` da el último cierre *cerrado* de 4h, y la expresión puede ser una llamada `ta.*`. Otro **símbolo** devuelve `na`: el motor solo tiene las velas del gráfico, así que no va a buscar otro símbolo.
- **Sin lookahead.** El bróker del backtest nunca llena una orden con datos del futuro: las órdenes a mercado se llenan en la *apertura de la vela siguiente*.
- **Los costes son reales.** Cada llenado paga comisión y deslizamiento según lo declarado en `strategy()`. Una estrategia rentable sin costes puede no serlo con ellos.
- **Los stops y límites siguen la vela**, en el orden apertura, extremo más cercano, extremo más lejano, cierre. Una orden que la vela saltó se llena en la apertura.
- **Declara con `=`, reasigna con `:=`.** Usa `var` para el estado que debe persistir entre velas.
- **La sangría es de cuatro espacios.** Pine no tiene llaves; los bloques de `if`/`for`/`while`/`switch` se sangran.
- **Los argumentos con nombre van al final.** En cuanto escribes `nombre=`, todos los argumentos siguientes también van nombrados: `plotshape(series=x, title="t", style=shape.circle)` vale, `plotshape(x, "t", style=…)` no. Mezclar posicional después de nombrado detiene el script con un error de sintaxis.
- **Una salida no puede dispararse en la vela que la creó.** Una `strategy.entry` a mercado se llena en la apertura de la vela siguiente, así que un `strategy.exit` escrito en esa vela solo puede llenarse a partir de la siguiente. Un precio que ya cayó por debajo de tu stop en la vela que lo creó no se ejecuta contra él.
- **Una salida de dos patas se dispara una vez.** Cuando una pata de `strategy.exit(stop=…, limit=…)` se llena, la otra se cancela con ella: una operación, nunca dos. Si la vela alcanza los dos niveles, gana el que se alcanza primero siguiendo el recorrido de la vela.
- **Stops dinámicos:** `strategy.exit(trail_points=N, trail_offset=M)`. Ambos van en **ticks**, no en unidades de precio. `trail_offset` es el beneficio que hay que superar antes de que el stop se arme; `trail_points` es la distancia que se guarda desde el mejor precio alcanzado. El stop solo se mueve a tu favor y se ajusta con velas cerradas.

## Referencia de funciones

Firmas y qué hace cada una. Los argumentos van en el orden en que los escribes.

### Lenguaje

Deepwick Script ejecuta un subconjunto de Pine Script, con enums, tipos propios, métodos y maps; la línea //@version no se comprueba. Un script se ejecuta una vez por vela, de la más antigua a la más reciente, y cada variable guarda su historial.

- `x = expr / x := expr` — Declara una variable y reasígnala con :=. Puede llevar delante un tipo opcional (int, float, bool, string, color, series, simple, const, line, label).
- `var / varip` — Inicializa una sola vez en la primera vela y conserva el valor entre velas. varip se comporta como var, porque los scripts se ejecutan sobre velas cerradas.
- `x[n]` — Operador de historial: el valor de x hace n velas (na antes de la primera vela).
- `if / else` — Bloques condicionales, con sangría de cuatro espacios. if también puede usarse como expresión.
- `cond ? a : b` — Operador ternario.
- `switch` — Selección múltiple, con o sin un valor que comparar.
- `for i = a to b [by step]` — Bucle con contador. Admite break y continue.
- `while cond` — Bucle mientras se cumpla una condición.
- `f(x, y) => expr` — Función definida por el usuario, en una línea o como bloque con sangría cuya última expresión se devuelve. Cada llamada mantiene su propio estado de ta.*, como en Pine.
- `[a, b] = f()` — Tuplas: una función puede devolver varios valores, como hacen ta.macd() y ta.bb().
- `and / or / not` — Operadores lógicos. Aritméticos: + - * / %; comparación: == != < <= > >=.

### Declaraciones

- `indicator(title, shorttitle, overlay, precision)` (study) — Declara un indicador: dibuja en el gráfico y no tiene nada que testear. study() se acepta como alias.
- `strategy(title, overlay, initial_capital, default_qty_type, default_qty_value, commission_type, commission_value, slippage, pyramiding)` — Declara una estrategia. Valores por defecto: initial_capital 100000, 1 contrato por orden, comisión 0, slippage 0 ticks, pyramiding 1. Otros argumentos, como process_orders_on_close, se ignoran.

### Inputs

Los inputs aparecen junto al editor y en los ajustes del indicador, para cambiarlos sin tocar el código.

- `input.int(defval, title, minval, maxval, step)` — Número entero.
- `input.float(defval, title, minval, maxval, step)` — Número decimal.
- `input.bool(defval, title)` — Casilla de verificación.
- `input.string(defval, title, options)` — Texto, o una lista de opciones.
- `input.session(defval, title)` — Una sesión de trading como "0930-1600", o días como "23456". Aliméntala a session.ismarket() y los demás predicados session.*.
- `input.source(defval, title)` — Una fuente de precio: open, high, low, close, hl2, hlc3, ohlc4 o hlcc4.
- `input.color(defval, title)` — Selector de color.
- `input(defval, title)` — Input genérico; el tipo sale del valor por defecto.

### Datos de la vela y tiempo

Los tiempos van en milisegundos UTC. hour() y las demás funciones de tiempo aceptan un tiempo opcional; hour() acepta además una zona horaria de una lista de desfases fijos, sin horario de verano.

- `open, high, low, close, volume` (open, high, low, close, volume) — Precios y volumen de la vela actual.
- `hl2, hlc3, ohlc4, hlcc4` (hl2, hlc3, ohlc4, hlcc4) — Promedios de precio habituales.
- `bar_index, last_bar_index` (bar_index, last_bar_index) — Índice de la vela actual (0 es la más antigua) y de la última.
- `time, time_close` (time, time_close) — Hora de apertura y de cierre de la vela. Como funciones — time("D"), time(timeframe.period, "0000-0900:23456", "UTC") — el inicio (o el final) de la vela de temporalidad mayor que la contiene, o na si la vela está fuera de la sesión. Sesiones: "HHMM-HHMM", también nocturnas, varias ventanas separadas por comas, días opcionales tras dos puntos (1 = domingo … 7 = sábado), "24x7".
- `timeframe.change(timeframe)` — Verdadero en la primera vela de cada periodo nuevo, p. ej. timeframe.change("D") en la primera vela de cada día (las semanas empiezan el lunes).
- `timestamp(timezone?, year, month, day, hour, minute, second)` — Un tiempo en milisegundos a partir de sus partes, o de una fecha en 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 día para comparar con dayofweek (1 … 7).
- `session.ismarket, isfirstbar, islastbar, ispremarket, ispostmarket` (session.ismarket, session.isfirstbar, session.islastbar, session.ispremarket, session.ispostmarket) — Estado de la sesión. Aquí los mercados cotizan todo el día, así que toda vela está en sesión de mercado; isfirstbar / islastbar marcan la primera y la última vela de cada día UTC.
- `year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second` (year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second) — Partes de la fecha de la vela; también se pueden llamar con un tiempo, p. ej. 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) — En qué punto del historial está el script.
- `timeframe.period, multiplier, isintraday, isdaily, isweekly, ismonthly` (timeframe.period, timeframe.multiplier, timeframe.isintraday, timeframe.isdaily, timeframe.isweekly, timeframe.ismonthly) — La temporalidad del gráfico.
- `syminfo.ticker, tickerid, mintick, pointvalue` (syminfo.ticker, syminfo.tickerid, syminfo.mintick, syminfo.pointvalue) — El símbolo del gráfico, su paso de precio y el valor del punto.

### Análisis técnico (ta.*)

Cada llamada mantiene su propio estado, como en Pine: dos ta.ema() en líneas distintas son dos medias independientes. El resultado es na hasta que hay velas suficientes.

- `ta.sma(source, length)` — Media móvil simple.
- `ta.ema(source, length)` — Media móvil exponencial.
- `ta.rma(source, length)` — Media de Wilder, la que usan el RSI y el ATR.
- `ta.wma(source, length)` — Media móvil ponderada.
- `ta.vwma(source, length)` — Media móvil ponderada por volumen.
- `ta.hma(source, length)` — Media móvil de Hull.
- `ta.linreg(source, length, offset)` — Valor de la recta de regresión lineal.
- `ta.vwap(source)` — Precio medio ponderado por volumen, que se reinicia cada día a las 00:00 UTC.
- `ta.rsi(source, length)` — Índice de fuerza relativa, de 0 a 100.
- `ta.macd(source, fastlen, slowlen, siglen)` — Devuelve [macd, señal, histograma].
- `ta.stoch(source, high, low, length)` — Estocástico %K, de 0 a 100.
- `ta.cci(source, length)` — Commodity Channel Index.
- `ta.mfi(series, length)` — Money Flow Index.
- `ta.wpr(length)` — Williams %R, de -100 a 0.
- `ta.dmi(diLength, adxSmoothing)` — Devuelve [+DI, -DI, ADX].
- `ta.supertrend(factor, atrPeriod)` — Devuelve [supertrend, dirección]; la dirección es -1 en tendencia alcista y 1 en bajista.
- `ta.sar(start, inc, max)` — SAR parabólico.
- `ta.mom(source, length)` — Momento: source menos source de hace length velas.
- `ta.roc(source, length)` — Tasa de variación, en porcentaje.
- `ta.change(source, length)` — Diferencia con hace length velas (1 por defecto).
- `ta.tr / ta.tr(handle_na)` — Rango verdadero.
- `ta.atr(length)` — Rango verdadero medio (Wilder).
- `ta.bb(series, length, mult)` — Bandas de Bollinger: devuelve [media, superior, inferior].
- `ta.bbw(series, length, mult)` — Anchura de las Bandas de Bollinger: (superior - inferior) / media.
- `ta.kc(series, length, mult)` — Canales de Keltner: devuelve [media, superior, inferior], con una EMA del rango verdadero.
- `ta.stdev(source, length, biased)` — Desviación típica.
- `ta.variance(source, length, biased)` — Varianza.
- `ta.dev(source, length)` — Desviación media absoluta.
- `ta.median(source, length)` — Mediana.
- `ta.highest(source, length) / ta.highest(length)` — Valor más alto de las últimas length velas (el máximo por defecto).
- `ta.lowest(source, length) / ta.lowest(length)` — Valor más bajo de las últimas length velas (el mínimo por defecto).
- `ta.highestbars(source, length)` — Desplazamiento hasta el valor más alto: 0 o negativo.
- `ta.lowestbars(source, length)` — Desplazamiento hasta el valor más bajo: 0 o negativo.
- `ta.rising(source, length)` — Verdadero si source supera cada uno de sus length valores anteriores.
- `ta.falling(source, length)` — Verdadero si source está por debajo de cada uno de sus length valores anteriores.
- `ta.crossover(source1, source2)` — Verdadero en la vela en la que source1 cruza por encima de source2.
- `ta.crossunder(source1, source2)` — Verdadero en la vela en la que source1 cruza por debajo de source2.
- `ta.cross(source1, source2)` — Verdadero con un cruce en cualquier sentido.
- `ta.pivothigh(source, leftbars, rightbars)` — El precio del pivote alto, conocido rightbars velas después del pivote; na en otro caso. source es opcional (el máximo por defecto).
- `ta.pivotlow(source, leftbars, rightbars)` — El precio del pivote bajo, conocido rightbars velas después del pivote; na en otro caso. source es opcional (el mínimo por defecto).
- `ta.valuewhen(condition, source, occurrence)` — Valor de source en la ocurrencia número occurrence, contando hacia atrás, en que condition fue verdadera.
- `ta.barssince(condition)` — Velas desde la última vez que condition fue verdadera.
- `ta.cum(source)` — Suma acumulada desde la primera vela.

### Estrategias (strategy.*)

Las órdenes a mercado se ejecutan en la apertura de la vela siguiente. Las stop y limit se ejecutan a lo largo de la vela: apertura, el extremo más cercano a la apertura, el otro extremo y el cierre. Si el precio salta por encima de una orden (gap), se ejecuta en la apertura. La comisión se cobra en cada ejecución; el slippage se aplica a las órdenes a mercado y stop.

- `strategy.entry(id, direction, qty, limit, stop, comment)` — Abre una posición o añade a ella; a mercado salvo que se indique limit o stop.
- `strategy.order(id, direction, qty, limit, stop, comment)` — Mismos argumentos que strategy.entry().
- `strategy.exit(id, from_entry, qty_percent, profit, limit, loss, stop, trail_points, trail_offset, comment)` — Take profit, stop loss y stop dinámico de una entrada: profit y loss en ticks, limit y stop como precios. trail_points es la distancia en TICKS desde el mejor precio alcanzado; trail_offset es el beneficio en ticks que hay que superar antes de que el stop dinámico se arme. El stop solo se mueve a tu favor y se ajusta con velas CERRADAS, así que una vela nunca puede ejecutar el stop que su propio máximo acaba de fijar.
- `strategy.close(id, comment, qty_percent)` — Cierra una entrada a mercado en la vela siguiente.
- `strategy.close_all(comment)` — Cierra todas las posiciones abiertas.
- `strategy.cancel(id) / strategy.cancel_all()` (strategy.cancel_all) — Cancela órdenes pendientes.
- `strategy.position_size, position_avg_price` (strategy.position_size, strategy.position_avg_price) — Posición actual (positiva larga, negativa corta) y su precio 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) — Datos de la operación abierta n (0 = la más antigua); na si no existe. size es negativo en cortos. P. ej. salir tras 10 velas: 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) — Datos de la operación cerrada n (0 = la más antigua; la última es 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 de la cuenta.
- `strategy.closedtrades, opentrades, wintrades, losstrades` (strategy.closedtrades, strategy.opentrades, strategy.wintrades, strategy.losstrades) — Número de operaciones.
- `strategy.long, strategy.short` (strategy.long, strategy.short) — Direcciones.
- `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 y alertas

- `plot(series, title, color, linewidth, style)` — Dibuja una serie en el gráfico o en un panel.
- `plotshape(series, title, style, location, color, text)` — Dibuja una forma en las velas donde series es verdadero.
- `plotchar(series, title, char, location, color)` — Dibuja un carácter en las velas donde series es verdadero.
- `hline(price, title, color, linestyle)` — Línea horizontal en un nivel fijo.
- `fill(plot1, plot2, color)` — Rellena entre dos plots o dos hlines.
- `bgcolor(color)` — Colorea el fondo de la vela.
- `barcolor(color)` — Colorea la propia vela.
- `alertcondition(condition, title, message)` — Declara una condición que puedes convertir en una alerta por 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. Se aceptan, pero las formas se dibujan a un solo tamaño.

### Líneas y cajas

- `line.new(x1, y1, x2, y2, extend, color, style, width)` — Dibuja una línea entre dos índices de vela y dos precios; devuelve su 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) — Modifican una línea.
- `line.delete(id)` — Elimina una línea.
- `box.new(left, top, right, bottom, border_color, bgcolor, extend)` — Dibuja un rectángulo; devuelve su 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) — Modifican una caja.
- `box.delete(id)` — Elimina una caja.
- `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áticas, textos y colores

- `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 cualquier número de valores.
- `math.sum(source, length)` — Suma de las últimas length velas.
- `math.pi, math.e` (math.pi, math.e) — Constantes.
- `na, na(x), nz(x, replacement), fixnan(x)` (na, nz, fixnan) — El valor ausente, la prueba de si lo es, su sustituto y el último valor que no es na.
- `int(x), float(x), bool(x)` (float, bool) — Conversiones.
- `str.tostring(value, format), str.format(text, ...), str.length(s), str.contains(s, part)` (str.format, str.length, str.contains) — Textos. str.format sustituye {0}, {1}… por los argumentos.
- `color.new(color, transp), color.rgb(red, green, blue, transp)` (color.rgb) — Construye un color; transparencia 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) — 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) — Leen y modifican 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) — Tamaño y estadísticas.

### Maps y tipos definidos por el usuario

Se admiten los tipos definidos por el usuario y la colección `map.<fn>`. Ambas son declaraciones de nivel superior; los métodos de instancia sobre un valor usan la sintaxis `obj.method(args...)`.

- `enum Name
    Member
    Member = N
    ...` — Declaración de enum a nivel superior. Los miembros sin valor se incrementan automáticamente desde 0; los valores explícitos pueden ser números o cadenas. Se accede como `Name.Member` en cualquier posición de expresión. Los valores del enum son números (o cadenas) normales, así que funcionan con operadores de comparación y con `int()` sin conversión.
- `type Name
    field1
    field2: int
    field3 = default` — Tipo definido por el usuario a nivel superior. Los campos se listan uno por línea; las partes `: tipo` y `= default` se aceptan por compatibilidad futura pero todavía no se validan. Se construye con `Type.new(arg1, arg2, ...)` y se leen los campos con `instancia.field`.
- `m = map.new<int, float>()` (map.new) — Crea un mapa vacío. Los argumentos de tipo `<K, V>` se aceptan pero se ignoran en tiempo de ejecución.
- `m = map.put(m, key, value)` (map.put) — Asigna una clave. Devuelve el mapa para que las llamadas se puedan encadenar o reasignar.
- `v = map.get(m, key)` (map.get) — Lee un valor. Devuelve na si la clave no existe.
- `n = map.size(m)` (map.size) — Número de entradas.
- `keys = map.keys(m), values = map.values(m)` (map.keys, map.values) — Devuelven las claves o los valores como un array Pine (orden de inserción).
- `map.contains(m, key), map.remove(m, key)` (map.remove) — Prueba de pertenencia y borrado. Ambos devuelven el mapa.

## Todavía no disponible

Una función que el motor no conoce detiene el script con «Unknown function» y la línea y la columna.

- `label.new(), table.new()`: Todavía no. Las líneas y las cajas sí.
- `import, matrix.*, array.new<type>()`: Las librerías, las matrices y los constructores de array tipados todavía no están implementados.
- `strategy.risk.*`: Las reglas de riesgo (max_position_size, max_intraday_loss, max_drawdown, allow_entry_in) no están soportadas. Los stops dinámicos en strategy.exit() sí: usa trail_points y trail_offset.

## Ejemplos ejecutables

Scripts incluidos que compilan 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/docs/script
- Try a script with no signup: https://deepwick.com/try