← Volver a la documentación
LootX

Язык Loot

LootScript — indicadores y alertas personalizados en el terminal, backtest de estrategias.

Generado: 2026-11-21 docs.lootx.trade
Основы

1Lenguaje LootScript

Qué es LootScript: indicadores, estrategias y bibliotecas que funcionan directamente en el terminal sobre los datos del gráfico. Qué datos están disponibles, cómo activar los scripts y qué no hacen.

LootScript es el lenguaje de scripts del terminal LootX. Con él se escriben indicadores propios, estrategias para probar ideas sobre el historial y bibliotecas de funciones comunes. Un script es un archivo de texto que se ejecuta directamente en el terminal sobre los datos del gráfico al que lo agregaste: velas, volumen, delta, clústeres, interés abierto, tasa de financiación.

Así se ve un indicador completo: el delta de cada vela en columnas debajo del gráfico:

Loot
indicator("Дельта бара", overlay = false)

d = delta.available ? delta.value : na
plot(d, "Дельта", style = plot.style_columns, color = d >= 0 ? color.teal : color.red)

Qué se puede escribir

La primera línea del script declara su tipo, y del tipo depende lo que el script tiene permitido hacer.

Tipo Primera línea Qué hace
Indicador indicator("Название") Calcula valores por velas y los dibuja: líneas, histogramas, niveles, marcadores, fondo, etiquetas. Dibuja sobre el precio o en un panel separado debajo del gráfico.
Estrategia strategy("Название") Lo mismo que un indicador, más reglas de entrada y salida. Las órdenes de la estrategia son virtuales: las ejecuta el Tester de estrategias sobre el historial y muestra operaciones, curva de capital y métricas.
Biblioteca library("Название", 1) Guarda funciones que otros scripts tuyos pueden incluir. No se agrega al gráfico y no dibuja nada.

Además de tus propios scripts, puedes importar scripts ya hechos en formato Pine Script: el terminal los traducirá a LootScript al importarlos. Cómo funciona y qué revisar después de la traducción, en la página Importar desde Pine Script.

Qué datos están disponibles para el script

  • Velas del gráfico: open, high, low, close, volume, el tiempo de la vela y derivados como hl2.
  • Flujo de órdenes: delta de compras y ventas agresivas, clústeres por niveles de precio, interés abierto, tasa de financiación, historial grabado del libro de órdenes, métricas del screener.
  • Libro de órdenes en vivo y cinta de operaciones — solo en la vela actual, aún no cerrada: su historial no se graba.
  • Otras temporalidades e instrumentos — mediante la consulta de una serie desde una temporalidad mayor o desde otra moneda.

Si el exchange no entrega algún indicador o no hay datos para una vela, el script recibe no un cero, sino el valor especial na — “sin valor”. En el gráfico eso es una interrupción de la línea, no un falso cero. Detalles y cobertura por exchange en la página Datos de mercado.

Dónde se ejecuta el script

El script funciona dentro del terminal en tu computadora. No se envía ni se ejecuta en el servidor de LootX.

  • Aislamiento. El script no tiene acceso a la red, a archivos, a conexiones de exchanges ni a API keys. Esas funciones simplemente no existen en el lenguaje: ni por accidente ni a propósito el script puede transmitir tus datos a ningún lado.
  • Límites. Un bucle demasiado largo o un arreglo enorme detiene solo ese script. Los demás indicadores, los paneles y el propio terminal siguen funcionando, y el motivo de la detención se ve en el editor.
  • Archivos. Cada script es un archivo separado con extensión .loot. En Windows se guardan en la carpeta %APPDATA%\TradingTerminal\scripts\, fuera de la carpeta de instalación, por eso las actualizaciones del terminal no los tocan. Mover un script a otra computadora es copiar el archivo.

Cómo activar los scripts

Los scripts son un módulo aparte que se activa para tu cuenta de LootX. Para que funcione, inicia sesión con tu cuenta en el terminal.

Cuando el módulo está activo, en la ventana de indicadores del gráfico (botón ƒ en el panel del gráfico) aparecen las secciones Favoritos, Mis scripts, Integrados y Estrategias, y arriba los botones Importar… y Editor….

Cuando el módulo no está activo, los scripts no se muestran en absoluto: la ventana de indicadores contiene solo los indicadores integrados, no hay editor ni importación. Tampoco hay candados ni ofertas de compra: el terminal se ve como si los scripts no existieran. En cuanto el acceso esté disponible, la ventana de indicadores se reorganiza sola, no hace falta reiniciar el terminal.

El acceso se otorga por cuenta, como parte de un plan o por separado. Los planes vigentes están en la página Suscripciones.

Qué no hacen los scripts

  • No accede a internet ni lee archivos. Todo lo que el script conoce son los datos del gráfico en el que está.
  • No se publica ni se vende. No hay catálogo de scripts: un script es tu archivo local, y solo puedes compartirlo pasando el archivo.
  • No ejecuta Pine Script directamente. Los scripts en ese formato primero se traducen a LootScript al importarlos; no se garantizan cifras idénticas a las de otras plataformas.

Siguiente

https://docs.lootx.trade/es/loot/overview

Справочник

2Referencia de funciones

Todas las funciones, series y constantes integradas de LootScript: ta, math, str, color, input, dibujo, colecciones, estrategias y datos de order flow — con parámetros y valores por defecto.

Aquí está todo lo que viene integrado en LootScript: declaraciones del script, series de la barra, funciones por espacios de nombres, constantes y datos de order flow. La lista está tomada de la tabla de nombres integrados del propio compilador: lo que no está en esta página no existe en el lenguaje, y llamar a ese nombre dará error LS2002.

El manual no enseña el lenguaje: cómo funcionan los tipos, na, el historial x[1] y la nueva ejecución de la barra se explica en Sintaxis y tipos, y el dibujo y las opciones en Ajustes y renderizado.

Cómo leer este manual

Cada función está escrita en una línea: nombre, parámetros en el orden que acepta la llamada posicional y el tipo de resultado.

Loot
ta.stdev(source, length, biased = true) → float
  • Un parámetro sin = … es obligatorio. Un parámetro con valor es opcional: si se omite, se usará el valor indicado.
  • = na en un parámetro opcional significa “no establecido”: la función se comportará como se describe en la línea.
  • Los nombres de parámetros se pueden escribir explícitamente en la llamada: ta.stdev(close, 20, biased = false). Los nombres son parte del lenguaje y no pueden abreviarse.
  • Un resultado [float, float, float] son varios valores a la vez. Se desempaquetan en variables: [mid, up, dn] = ta.bb(close, 20, 2).
  • Un nombre sin paréntesis (close, ta.obv, strategy.equity) es una serie o constante y se lee sin llamar.
  • El resultado — significa que la función no devuelve nada y se escribe en una línea separada.

Declaración del script

La primera línea del script debe ser exactamente una declaración: indicator, strategy o library. Sus argumentos se leen antes de la primera barra, por lo que solo sirven literales y constantes.

Declaración Qué crea
indicator(title, …) Un indicador en el gráfico
strategy(title, …) Una estrategia para el probador: las mismas capacidades que un indicador, más las órdenes strategy.*
library(title, version) Una biblioteca de funciones. Se importa con import Nombre/versión as alias. En una biblioteca no se puede dibujar ni declarar ajustes

Parámetros de indicator

Parámetro Por defecto Qué define
title — Nombre en la lista de indicadores y en la leyenda
shortTitle na Título corto para la leyenda
overlay false true — dibujar sobre las velas, false — en un área separada bajo el gráfico
format, precision, scale na Aceptados por compatibilidad: la escala y el formato de números los controla el terminal
maxBarsBack na Aceptado pero no efecto: la historia siempre se carga completa
timeframe na Aceptado pero no efecto: el script se calcula en la temporalidad del gráfico; otra temporalidad da request.security
maxLinesCount, maxLabelsCount, maxBoxesCount 500 Cuántas líneas, etiquetas y rectángulos de un tipo viven simultáneamente. Si se supera, se elimina la más antigua
maxPolylinesCount 500 Reservado: el tipo polyline aún no existe en el lenguaje

Constantes para format: format.inherit, format.price, format.volume, format.percent, format.mintick. Para scale: scale.right, scale.left, scale.none. Las cadenas format.* también las entiende str.tostring.

Parámetros de strategy

strategy tiene los mismos title, shortTitle, overlay y límites de objetos de dibujo que indicator, más parámetros del probador:

Parámetro Por defecto Qué define
initialCapital 10000 Capital inicial
currency "USD" Aceptado; no afecta al cálculo
defaultQtyType strategy.qty.fixed Cómo interpretar el tamaño por defecto: strategy.qty.fixed — unidades, strategy.qty.cash — monto en moneda, strategy.qty.percent_of_equity — porcentaje del capital, strategy.qty.risk_percent — porcentaje de riesgo hasta el stop
defaultQtyValue 1 Tamaño de orden por defecto
commissionType strategy.commission.percent Comisión en porcentaje, strategy.commission.cash_per_contract — por unidad, strategy.commission.cash_per_order — por orden
commissionValue na Tamaño de la comisión. na — usar las tasas maker/taker del instrumento
slippageTicks 0 Deslizamiento en ticks
pyramiding 0 Cuántas entradas adicionales en la misma dirección se permiten
positionModel strategy.model.netting Una posición global o separadas (strategy.model.hedging)
calcOnEveryTick false Calcular órdenes en cada tick de la barra en vivo, no solo al cierre
calcOnOrderFills false Aceptado; esta versión no lo usa
processOrdersOnClose false Ejecutar órdenes al precio de cierre de la misma barra. El informe se marcará como no alcanzable en vivo
marginLong, marginShort 0 Margen inicial long y short en porcentaje de la posición. 0 — sin simulación de margen ni liquidaciones
leverage 1 Apalancamiento
applyFunding true Incluir la tasa de financiación de futuros perpetuos en el resultado
fillModel strategy.fill.conservative Camino del precio dentro de la barra. El modelo conservador asume que el precio primero fue en la peor dirección: si stop y take están ambos dentro de la barra, se ejecutará el stop. strategy.fill.optimistic — al revés

Barra e instrumento

Series de la barra

Nombre Tipo Qué contiene
open, high, low, close, volume float Precios y volumen de la barra
hl2, hlc3, ohlc4, hlcc4 float Precios medios de la barra: (H+L)/2, (H+L+C)/3, (O+H+L+C)/4, (H+L+2C)/4
time, time_close int Tiempo de apertura y cierre de la barra, milisegundos UTC
bar_index int Número de la barra desde el inicio de la historia cargada, empezando en cero
last_bar_index int Número de la última barra cargada
timenow int Tiempo actual del terminal, en milisegundos UTC

Estado de la barra: barstate

Nombre Es verdadero cuando
barstate.isfirst Primera barra de la historia cargada
barstate.islast Última barra cargada
barstate.ishistory Barra de la historia, no en formación
barstate.isrealtime Barra formándose en tiempo real
barstate.isnew Primera pasada por una barra nueva
barstate.isconfirmed La barra cerró — su valor ya no cambiará

isrealtime, isnew y los valores dependientes de ellos difieren entre historia y en vivo — el compilador avisará si llegan al gráfico.

Instrumento: sym

Nombre Tipo Qué contiene
sym.ticker string Exchange e símbolo en la forma que acepta request.security
sym.exchange string Código del exchange
sym.base, sym.quote string Activo base y cotizado: BTC y USDT en BTCUSDT. na si no se pudo extraer la cotización
sym.tick_size float Tick de precio
sym.qty_step, sym.min_qty float Paso y mínimo de cantidad
sym.maker_fee, sym.taker_fee float Comisiones maker y taker en fracción: 0.0002 es 0.02 %

Temporalidad: tf

Nombre Tipo Qué contiene
tf.period string Temporalidad del gráfico como texto: "5", "60", "1D"
tf.ms, tf.seconds int Longitud de la barra en milisegundos y segundos
tf.isintraday, tf.isdaily bool Barra más corta que un día; barra exactamente de un día
tf.in_ms(period) int Longitud de una temporalidad arbitraria en milisegundos; na si la cadena no se parsea
tf.in_seconds(period = na) int Lo mismo en segundos; sin argumento — la temporalidad del gráfico

Tiempo y calendario

Todas las funciones de calendario por defecto calculan en UTC, no en la zona horaria del equipo: así el indicador luce igual para todos.

Función Devuelve Qué hace
year, month, dayofmonth, weekofyear (timestamp = time, timezone = "UTC") int Año, mes, día, número de semana ISO
dayofweek(timestamp = time, timezone = "UTC") int Día de la semana: domingo — 1, sábado — 7
hour, minute, second (timestamp = time, timezone = "UTC") int Hora, minuto, segundo
time_of_day(timestamp = time, timezone = "UTC") int Milisegundos desde medianoche en la zona dada
timestamp(year, month, day, hour = 0, minute = 0, second = 0, timezone = "UTC") int Marca de tiempo a partir de una fecha
time_in_range(session, timezone = "UTC") bool Si la barra cae en un intervalo del tipo "0930-1600"
session.ismarket, session.isfirstbar, session.islastbar bool Barra dentro de sesión, primera y última barra de sesión. En mercados 24/7 la sesión es el día UTC

Las constantes de días coinciden con lo que devuelve dayofweek: dayofweek.sunday (1), dayofweek.monday, dayofweek.tuesday, dayofweek.wednesday, dayofweek.thursday, dayofweek.friday, dayofweek.saturday (7). La zona horaria se especifica con un identificador IANA, por ejemplo "Europe/Moscow".

ta — análisis técnico

Las funciones ta.* recuerdan su estado entre barras, por eso el compilador las calcula en cada barra aunque la llamada esté dentro de un if. En las primeras barras, hasta que la ventana se llena, las funciones devuelven na.

Medias móviles

Función Devuelve Qué hace
ta.sma(source, length) float Media simple de length barras
ta.ema(source, length) float Media exponencial: peso del nuevo valor 2/(length+1)
ta.rma(source, length) float Suavizado de Wilder, peso 1/length. Sobre esto se construyen RSI y ATR; no es lo mismo que ta.ema de la misma longitud
ta.wma(source, length) float Media ponderada linealmente: barras recientes pesan más
ta.vwma(source, length) float Media ponderada por volumen
ta.hma(source, length) float Media de Hull: menos retardo en giros
ta.swma(source) float Media simétricamente ponderada en cuatro barras
ta.alma(source, length, offset = 0.85, sigma = 6) float Media con ventana gaussiana; offset desplaza el pico hacia barras recientes, sigma fija la anchura
ta.linreg(source, length, offset = 0) float Punto sobre la recta de regresión de los últimos length valores

Osciladores

Función Devuelve Qué hace
ta.rsi(source, length) float Índice de fuerza relativa, 0…100
ta.stoch(source, high, low, length) float Dónde está source dentro del rango high–low de length barras, 0…100
ta.cci(source, length) float Desviación de la media normalizada por la desviación absoluta media
ta.mfi(source, length) float Índice de flujo monetario: RSI que incluye volumen
ta.cmo(source, length) float Oscilador de Chande, −100…100
ta.roc(source, length) float Cambio en porcentaje respecto a length barras atrás
ta.mom(source, length) float Diferencia con el valor de length barras atrás
ta.tsi(source, shortLength, longLength) float Índice de fuerza verdadera: impulso doblemente suavizado sobre el módulo también suavizado
ta.wpr(length) float Williams %R, −100…0
ta.bop(length = 1) float Balance of power: qué parte del rango ocupó el cuerpo, con suavizado
ta.cog(source, length) float Centro de gravedad de la ventana

Volatilidad y canales

Función Devuelve Qué hace
ta.tr(handle_na = true) float Rango verdadero de la barra
ta.atr(length) float Average true range
ta.natr(length) float ATR en porcentaje respecto al cierre
ta.stdev(source, length, biased = true) float Desviación estándar. biased = false — muestral, divisor length−1
ta.variance(source, length, biased = true) float Varianza, con la misma elección de divisor
ta.dev(source, length) float Desviación absoluta media respecto a la media
ta.bb(source, length, mult) [float, float, float] Bandas de Bollinger: media, superior, inferior
ta.bbw(source, length, mult) float Ancho de las bandas respecto a la media
ta.kc(source, length, mult, useTrueRange = true) [float, float, float] Canal de Keltner: media, superior, inferior
ta.kcw(source, length, mult, useTrueRange = true) float Ancho del canal de Keltner respecto a la media
ta.range(length) float Altura de las últimas length barras: máximo high menos mínimo low

Tendencia

Función Devuelve Qué hace
ta.macd(source, fastLength, slowLength, signalLength) [float, float, float] MACD: línea, señal, histograma
ta.dmi(diLength, adxLength) [float, float, float] Índice direccional: +DI, −DI, ADX
ta.adx(diLength, adxLength) float Solo ADX
ta.supertrend(factor, atrLength) [float, int] Línea supertrend y dirección: 1 — tendencia alcista, −1 — bajista
ta.sar(start = 0.02, increment = 0.02, maximum = 0.2) float Parabolic SAR
ta.vortex(length) [float, float] Indicador vortex: VI+ y VI−
ta.aroon(length) [float, float] Aroon up y down: cuántas barras desde el máximo y mínimo de la ventana, 0…100

Volumen

Función Devuelve Qué hace
ta.obv, ta.pvt, ta.nvi, ta.pvi, ta.ad float Series acumulativas sin paréntesis: On-balance volume, precio por volumen, índices de volumen negativo y positivo, acumulación/distribución
ta.cmf(length) float Chaikin money flow
ta.eom(length = 14, divisor = 10000) float Ease of movement: movimiento de precio por unidad de volumen
ta.vwap(source = hlc3, anchor = session.isfirstbar) float VWAP desde la última barra en que anchor fue verdadera

Estructura y eventos

Función Devuelve Qué hace
ta.highest(source, length), ta.lowest(source, length) float Máximo y mínimo de length barras
ta.highestbars(source, length), ta.lowestbars(source, length) int Desplazamiento hasta la barra con máximo o mínimo: 0 — barra actual, valores negativos hacia atrás
ta.crossover(a, b) bool a cruzó b de abajo hacia arriba en esta barra
ta.crossunder(a, b) bool a cruzó b de arriba abajo
ta.cross(a, b) bool Cualquiera de los dos cruces
ta.change(source, length = 1) float Diferencia respecto al valor length barras atrás
ta.rising(source, length), ta.falling(source, length) bool Valor creció (cayó) en cada una de las últimas length barras
ta.barssince(condition) int Cuántas barras han pasado desde la última vez que la condición fue verdadera
ta.valuewhen(condition, source, occurrence = 0) float Valor de source en la barra donde la condición fue verdadera; occurrence = 1 — en la anterior de ese tipo
ta.pivothigh(source, leftBars, rightBars), ta.pivotlow(…) float Pico o valle confirmado. Aparece rightBars barras después del punto
ta.percentrank(source, length) float Qué porcentaje de valores pasados de la ventana no son mayores que el actual
ta.median(source, length), ta.mode(source, length) float Mediana y valor modal de la ventana
ta.correlation(source1, source2, length) float Correlación entre dos series, −1…1
ta.sum(source, length) float Suma en length barras
ta.cum(source) float Suma desde la primera barra cargada

Ausencia de valor: na

Función Devuelve Qué hace
na(x) bool Verdadero si no hay valor. Funciona con cualquier tipo, incluidos objetos y colecciones
nz(x, replacement = 0) float Reemplaza na por replacement
fixnan(x) float Extiende el último valor existente a través de huecos

La comparación x == na el compilador no la aceptará: siempre es falsa. Compruebe con na(x), y sustituya con el operador a ?? b.

math

Función Devuelve Qué hace
math.abs(x), math.sign(x) float Módulo y signo (−1, 0, 1). math.abs de entero sigue siendo entero
math.round(x, precision = na) int o float Sin precision — al entero, resultado int. Con precision — a los decimales, resultado float
math.floor(x), math.ceil(x), math.trunc(x) int Redondeo hacia abajo, arriba, truncamiento
math.min(a, b, c = na, d = na), math.max(…) float Mínimo y máximo de 2–4 valores; na se ignora. De enteros — entero
math.sum(a, b, c = na, d = na), math.avg(…) float Suma y promedio de 2–4 valores
math.clamp(x, lower, upper) float Restringe el valor entre límites
math.pow(base, exponent) float Potencia
math.sqrt(x), math.cbrt(x) float Raíz cuadrada y cúbica
math.exp(x), math.log(x), math.log10(x), math.log2(x) float Exponencial y logaritmos
math.hypot(x, y) float Longitud de la hipotenusa
math.gcd(a, b), math.lcm(a, b) int MCD y mcm
math.approx(a, b, tolerance = 1e-9) bool Números iguales con precisión relativa tolerance
math.random(min = 0, max = 1, seed = na) float Número aleatorio en [min, max). Cada llamada tiene su propia secuencia
math.pi, math.e, math.phi, math.rphi, math.inf, math.epsilon float Constantes: π, e, sección áurea y su inversa, infinito, epsilon de máquina
Trigonometría
Función Devuelve Qué hace
math.sin(x), math.cos(x), math.tan(x) float Seno, coseno, tangente; ángulo en radianes
math.asin(x), math.acos(x), math.atan(x) float Funciones inversas
math.atan2(y, x) float Ángulo del punto (x, y) considerando el cuadrante
math.sinh(x), math.cosh(x), math.tanh(x) float Funciones hiperbólicas
math.todegrees(radians), math.toradians(degrees) float Convertir radianes a grados y viceversa

str — cadenas

Función Devuelve Qué hace
str.tostring(value, format = na) string Número a texto; format — format.* o patrón
str.tonumber(text) float Texto a número; na si no se parsea
str.format(pattern, arg0, arg1 = na, arg2 = na, arg3 = na) string Sustituye valores en un patrón tipo "RSI {0}, ATR {1}"
str.format_time(timestamp, format = "yyyy-MM-dd HH:mm:ss", timezone = "UTC") string Marca de tiempo a texto
str.length(text) int Longitud de la cadena
str.substring(text, begin, end = na) string Subcadena; sin end — hasta el final
str.pos(text, needle) int Posición de la primera aparición
str.contains(text, needle), str.startswith(text, prefix), str.endswith(text, suffix) bool Comprobaciones de existencia, inicio y fin
str.replace(text, target, replacement, occurrence = 0) string Reemplaza una aparición, por defecto la primera
str.replace_all(text, target, replacement) string Reemplaza todas las apariciones
str.split(text, separator) array<string> Divide la cadena en partes
str.join(parts, separator = "") string Junta un array de cadenas
str.upper(text), str.lower(text), str.trim(text) string Mayúsculas/minúsculas y recorte de espacios
str.repeat(text, count, separator = "") string Repite text count veces
str.match(text, pattern) string Primera coincidencia regex o na
str.escape_regex(text) string Escapa caracteres especiales para búsqueda literal

No se puede concatenar una cadena con un número usando + — convierta el número con str.tostring.

color — colores

Función Devuelve Qué hace
color.rgb(red, green, blue, alpha = 255) color Color por canales 0…255
color.new(base, alpha) color Mismo color con otra opacidad
color.from_gradient(value, bottomValue, topValue, bottomColor, topColor) color Color intermedio según value en el rango
color.r(c), color.g(c), color.b(c), color.t(c) int Canales rojo, verde, azul y alfa, 0…255

El alfa en LootScript es la opacidad: 255 — color sólido, 0 — totalmente transparente. Colores listos: color.red, color.green, color.blue, color.teal, color.orange, color.purple, color.yellow, color.white, color.black, color.gray, color.silver, color.maroon, color.navy, color.olive, color.lime, color.aqua, color.fuchsia. También se puede escribir un color literal: #FF9800 o #FF980080.

input — ajustes del script

Cada llamada input.* añade una línea en la ventana de ajustes del indicador. El valor es constante durante toda la ejecución, por eso vale para la longitud de ventana ta.*.

Función Devuelve Línea de ajustes
input.int(defval, title = na, minval = na, maxval = na, step = 1, tooltip = na, group = na, inline = na) int Entero
input.float(defval, title = na, minval = na, maxval = na, step = 0.1, tooltip = na, group = na, inline = na) float Número decimal
input.bool(defval, title = na, tooltip = na, group = na, inline = na) bool Checkbox
input.string(defval, title = na, options = na, tooltip = na, group = na, inline = na) string Texto o lista de options
input.color(defval, title = na, tooltip = na, group = na, inline = na) color Selector de color
input.source(defval, title = na, tooltip = na, group = na, inline = na) float Selección de serie: close, hl2, volume, etc.
input.enum(defval, title = na, tooltip = na, group = na, inline = na) tipo enumerado Lista de miembros del enum
input.symbol(defval, title = na, tooltip = na, group = na, inline = na) string Instrumento en formato "EXCHANGE:SYMBOL"
input.timeframe(defval, title = na, options = na, tooltip = na, group = na, inline = na) string Temporalidad: "5", "60", "1D"

group agrupa líneas bajo un encabezado común, inline coloca varias en la misma fila, tooltip muestra ayuda. El valor guardado está ligado al nombre de la variable: si renombras la variable, la opción vuelve a defval.

Salida en el gráfico

Estas funciones se escriben en una línea aparte. Un script puede tener hasta 64 salidas, pero el panel de gráficos solo dibuja las primeras tres series plot.

Función Qué dibuja
plot(series, title = na, color = #2196F3, linewidth = na, style = plot.style_line, offset = 0, join = false, editable = true, show_last = na, display = display.all) Una serie de valores. na crea hueco en la línea. Sin linewidth se usa el grosor del panel
plotshape(condition, title = na, style = shape.triangleup, location = location.belowbar, color = color.blue, text = na, size = size.small, offset = 0) Icono en las barras donde la condición es verdadera
plotchar(condition, title = na, char = "▲", location = location.abovebar, color = color.blue, text = na, size = size.auto, offset = 0) Carácter en las barras donde la condición es verdadera
hline(price, title = na, color = color.gray, linestyle = hline.style_dashed, linewidth = na) Línea horizontal. El precio es constante
fill(plot1, plot2, color = na, title = na, top_value = na, bottom_value = na, top_color = na, bottom_color = na) Relleno entre dos plot o hline: color sólido o gradiente con los cuatro últimos parámetros
bgcolor(color, offset = 0, title = na) Fondo de la barra; na — sin fondo
barcolor(color, offset = 0, title = na) Color de la vela

plot y hline devuelven una referencia que se pasa a fill: p1 = plot(a), luego fill(p1, p2, color = …).

Estilos plot: plot.style_line, plot.style_linebr, plot.style_stepline, plot.style_stepline_diamond, plot.style_histogram, plot.style_columns, plot.style_area, plot.style_areabr, plot.style_circles, plot.style_cross. Estilos hline: hline.style_solid, hline.style_dashed, hline.style_dotted. Iconos: shape.triangleup, shape.triangledown, shape.circle, shape.square, shape.diamond, shape.arrowup, shape.arrowdown, shape.cross, shape.xcross, shape.flag, shape.labelup, shape.labeldown. Posición del icono: location.abovebar, location.belowbar, location.top, location.bottom, location.absolute. Tamaño: size.auto, size.tiny, size.small, size.normal, size.large, size.huge. Dónde mostrar la serie: display.all, display.pane, display.price_scale, display.status_line, display.data_window, display.none.

Objetos de dibujo

Líneas, rectángulos, etiquetas y tablas se crean con .new y viven hasta que se borren o los expulse el límite (por defecto 500 objetos de un tipo). .new devuelve una referencia con la que se modifica el objeto. Un setter a na no hace nada, por lo que el patrón “borrar y crear de nuevo” no requiere comprobaciones. Todos los objetos de un tipo están en arrays line.all, box.all, label.all, table.all.

La coordenada X por defecto es el número de barra (xloc.bar_index); con xloc.bar_time es el tiempo de la barra en ms. La coordenada Y es precio o valor de la escala del panel.

line

Función Devuelve Qué hace
line.new(x1, y1, x2, y2, xloc = xloc.bar_index, extend = extend.none, color = color.blue, style = line.style_solid, width = 1) line Segmento entre dos puntos
line.set_x1(id, x), line.set_y1(id, y), line.set_x2(id, x), line.set_y2(id, y) — Cambia un extremo
line.set_xy1(id, x, y), line.set_xy2(id, x, y) — Cambia el punto entero
line.set_xloc(id, x1, x2, xloc) — Cambia ambos X y la forma de leerlos
line.set_extend(id, extend), line.set_color(id, color), line.set_style(id, style), line.set_width(id, width) — Extensión, color, estilo, grosor
line.get_x1(id), line.get_x2(id) int Coordenadas X de los extremos
line.get_y1(id), line.get_y2(id) float Coordenadas Y de los extremos
line.get_price(id, x) float Precio en la línea en el punto x
line.copy(id) line Copia de la línea
line.delete(id) — Borra la línea

Extensión: extend.none, extend.left, extend.right, extend.both. Estilos: line.style_solid, line.style_dotted, line.style_dashed, line.style_arrow_left, line.style_arrow_right, line.style_arrow_both.

label

Función Devuelve Qué hace
label.new(x, y, text = na, xloc = xloc.bar_index, yloc = yloc.price, color = color.blue, style = label.style_label_down, textcolor = color.white, size = size.normal, textalign = text.align_center, tooltip = na, text_font_family = font.family_default) label Etiqueta con texto
label.set_x(id, x), label.set_y(id, y), label.set_xy(id, x, y) — Posición
label.set_text(id, text), label.set_tooltip(id, text) — Texto y tooltip
label.set_color(id, color), label.set_textcolor(id, color) — Color de fondo y del texto
label.set_style(id, style), label.set_size(id, size), label.set_textalign(id, align), label.set_text_font_family(id, family) — Forma, tamaño, alineación, fuente
label.set_xloc(id, x, xloc), label.set_yloc(id, yloc) — Forma de leer las coordenadas
label.get_x(id) int Coordenada X
label.get_y(id) float Coordenada Y
label.get_text(id) string Texto
label.copy(id) label Copia
label.delete(id) — Borra la etiqueta

Anclaje en Y: yloc.price, yloc.abovebar, yloc.belowbar. Formas: label.style_none, label.style_label_up, label.style_label_down, label.style_label_left, label.style_label_right, label.style_label_center, label.style_circle, label.style_square, label.style_diamond, label.style_arrowup, label.style_arrowdown, label.style_triangleup, label.style_triangledown, label.style_flag, label.style_cross, label.style_xcross, label.style_text_outline. Fuentes: font.family_default, font.family_monospace.

box — rectángulos
Función Devuelve Qué hace
box.new(left, top, right, bottom, border_color = color.blue, border_width = 1, border_style = line.style_solid, extend = extend.none, xloc = xloc.bar_index, bgcolor = na, text = na, text_size = size.auto, text_color = color.white, text_halign = text.align_center, text_valign = text.align_center, text_wrap = text.wrap_none) box Rectángulo con texto opcional
box.set_left(id, x), box.set_right(id, x), box.set_top(id, y), box.set_bottom(id, y) — Un lado
box.set_lefttop(id, x, y), box.set_rightbottom(id, x, y) — Esquina completa
box.set_xloc(id, left, right, xloc) — Ambos X y forma de leerlos
box.set_border_color(id, color), box.set_border_width(id, width), box.set_border_style(id, style) — Borde
box.set_bgcolor(id, color), box.set_extend(id, extend) — Fondo y extensión
box.set_text(id, text), box.set_text_color(id, color), box.set_text_size(id, size), box.set_text_halign(id, align), box.set_text_valign(id, align) — Texto interior
box.get_left(id), box.get_right(id) int Coordenadas X
box.get_top(id), box.get_bottom(id) float Coordenadas Y
box.copy(id) box Copia
box.delete(id) — Borra el rectángulo

Alineación de texto: text.align_left, text.align_center, text.align_right, text.align_top, text.align_bottom. Ajuste de línea: text.wrap_none, text.wrap_auto.

table — tablas

La tabla está fijada en una esquina del panel y no se mueve con las velas. No más de 2000 celdas.

Función Devuelve Qué hace
table.new(position, columns, rows, bgcolor = na, frame_color = na, frame_width = 0, border_color = na, border_width = 0) table Tabla del tamaño pedido
table.cell(id, column, row, text = "", width = 0, height = 0, text_color = color.black, text_halign = text.align_center, text_valign = text.align_center, text_size = size.normal, bgcolor = na, tooltip = na, text_font_family = font.family_default) — Rellena una celda
table.cell_set_text(id, column, row, text), table.cell_set_tooltip(…, text) — Texto y tooltip de la celda
table.cell_set_text_color(…, color), table.cell_set_bgcolor(…, color) — Colores de la celda
table.cell_set_text_size(…, size), table.cell_set_text_halign(…, align), table.cell_set_text_valign(…, align), table.cell_set_text_font_family(…, family) — Formato del texto
table.cell_set_width(…, width), table.cell_set_height(…, height) — Tamaño de la celda
table.set_position(id, position) — Esquina del panel
table.set_bgcolor(id, color), table.set_frame_color(id, color), table.set_frame_width(id, width), table.set_border_color(id, color), table.set_border_width(id, width) — Fondo, marco, líneas entre celdas
table.merge_cells(id, start_column, start_row, end_column, end_row) — Fusiona un rectángulo de celdas
table.clear(id, start_column, start_row, end_column = na, end_row = na) — Limpia una celda o rango
table.delete(id) — Borra la tabla

Posición: position.top_left, position.top_center, position.top_right, position.middle_left, position.middle_center, position.middle_right, position.bottom_left, position.bottom_center, position.bottom_right.

heatmap — mapa de calor

Dibuja celdas “precio × barra” bajo las velas igual que la heatmap incorporada. Funciona solo en scripts con overlay = true. Hasta cuatro capas (layer 0…3).

Función Qué hace
heatmap.cell(price, value, layer = 0) Coloca un valor en la celda a precio price de la barra actual
heatmap.depth(side = 0, min_qty = na, layer = 0) Rellena la capa con el libro de órdenes grabado de esa barra. side: 1 — solo bids, −1 — solo asks, 0 — ambos
heatmap.config(layer = 0, grid = na, palette = na, opacity = na, gamma = na, low = na, high = na, scale = na, cut = na, merge = na) Estilo de la capa: paso de precio, paleta, opacidad en %, contraste, umbrales de paleta en %, cima de escala, recorte de celdas débiles, forma de sumar repeticiones

Paletas: heatmap.viridis (por defecto), heatmap.magma, heatmap.inferno, heatmap.plasma, heatmap.turbo, heatmap.cividis, heatmap.ocean, heatmap.fire, heatmap.mono, heatmap.spectrum, heatmap.forest, heatmap.violet. Repeticiones de celda en la barra: heatmap.merge_max (por defecto) o heatmap.merge_sum.

Colecciones: array, map, matrix

El tipo de elemento se indica al crear: array.new<float>(0), map.new<string, float>(). Para que la colección sobreviva entre barras, créala con var. Las funciones se pueden llamar también como métodos: a.push(x) es lo mismo que array.push(a, x).

array

Función Devuelve Qué hace
array.new<T>(size = 0, initial = na) array<T> Array de size elementos con valor initial
array.from(v0, v1, …) array<T> Array de los valores listados, hasta diez
array.size(id) int Número de elementos
array.get(id, index), array.set(id, index, value) T, — Lectura y escritura por índice
array.push(id, value), array.pop(id) —, T Añadir al final, sacar del final
array.unshift(id, value), array.shift(id) —, T Añadir al inicio, sacar del inicio
array.insert(id, index, value), array.remove(id, index) —, T Insertar y eliminar por índice
array.clear(id) — Vaciar
array.includes(id, value) bool ¿Existe el valor?
array.indexof(id, value), array.lastindexof(id, value) int Primera y última posición del valor
array.sort(id, order = order.ascending) — Ordena in-place; order.descending — descendente
array.sum(id), array.avg(id) float Suma y promedio; na se ignoran
array.min(id, nth = 0), array.max(id, nth = 0) float Mínimo y máximo; nth = 1 — segundo en orden
array.join(id, separator = ",") string Elementos unidos por separador
Otras funciones array
Función Devuelve Qué hace
array.fill(id, value, index_from = 0, index_to = na) — Rellena un rango con un valor
array.slice(id, index_from, index_to) array<T> Parte del array
array.concat(id1, id2) array<T> Añade el segundo al primero
array.copy(id) array<T> Copia
array.reverse(id) — Invierte in-place
array.sort_indices(id, order = order.ascending) array<int> Índices en orden de ordenación
array.binary_search(id, value), array.binary_search_leftmost(…), array.binary_search_rightmost(…) int Búsqueda binaria en array ordenado
array.equals(id1, id2) bool Arrays iguales elemento a elemento
array.median(id), array.mode(id), array.range(id) float Mediana, moda, rango
array.stdev(id, biased = true), array.variance(id, biased = true) float Desviación estándar y varianza
array.covariance(id1, id2, biased = true) float Covarianza de dos arrays
array.abs(id) array<float> Array de módulos
array.percentile_linear_interpolation(id, percentage) float Percentil con interpolación
array.percentrank(id, index) float Rango porcentual del elemento

map

Función Devuelve Qué hace
map.new<K, V>() map<K, V> Diccionario vacío
map.put(id, key, value) V Escribe un valor, devuelve el anterior
map.get(id, key) V Valor por clave o na
map.contains(id, key) bool ¿Existe la clave?
map.remove(id, key) V Elimina la clave, devuelve el valor
map.clear(id), map.size(id) —, int Vaciar; número de pares
map.keys(id), map.values(id) array<K>, array<V> Claves y valores como array
map.copy(id) map<K, V> Copia
matrix — matrices
Función Devuelve Qué hace
matrix.new<T>(rows = 0, columns = 0, initial = na) matrix<T> Matriz del tamaño pedido
matrix.get(id, row, column), matrix.set(id, row, column, value) T, — Leer y escribir elemento
matrix.rows(id), matrix.columns(id) int Dimensiones
matrix.add_row(id, row = na, values = na), matrix.add_col(id, column = na, values = na) — Añade fila o columna; sin índice — al final
matrix.remove_row(id, row = na), matrix.remove_col(id, column = na) array<T> Elimina fila/columna y la devuelve
matrix.row(id, row), matrix.col(id, column) array<T> Fila o columna como array
matrix.fill(id, value, from_row = 0, to_row = na, from_column = 0, to_column = na) — Rellena un área
matrix.copy(id), matrix.transpose(id) matrix<T> Copia y transpuesta
matrix.mult(id1, id2), matrix.sum(id1, id2), matrix.diff(id1, id2) matrix<float> Producto, suma, diferencia de matrices
matrix.det(id), matrix.trace(id) float Determinante y traza
matrix.inv(id) matrix<float> Matriz inversa
matrix.is_square(id) bool ¿Matriz cuadrada?

Límites: array — 100 000 elementos, map — 50 000 pares, matrix — 1 000 000 elementos.

request.security — otra temporalidad e instrumento

Función Devuelve Qué hace
request.security(symbol, timeframe, expression, gaps = false, lookahead = false, ignore_invalid_symbol = false) float Calcula expression en otra temporalidad o instrumento y devuelve el resultado en las barras del gráfico
Loot
htfEma = request.security(sym.ticker, "60", ta.ema(close, 20))
  • symbol — "EXCHANGE:SYMBOL" o sym.ticker, timeframe — cadenas como "5", "60", "4h", "1D", "1W".
  • Una barra no cerrada del marco superior cambia hasta su cierre — tome expression[1] si necesita historia inmutable.
  • lookahead = true mira al futuro en la historia; el compilador lo avisará.
  • Dentro de expression no se puede leer el libro de órdenes ni la cinta de operaciones ni variables del gráfico — solo entradas y las propias series.
  • Límite — 8 pares distintos “instrumento + temporalidad” y 32 llamadas por script.

Ejemplos en la sección Otra temporalidad y otro instrumento.

Alertas y registro

Función Qué hace
alert(message, freq = alert.freq_once_per_bar_close) Envía una alerta con texto. Solo funciona en vivo; en la historia está silenciosa
alertcondition(condition, title, message = na) Declara una condición para que el usuario ponga una alerta desde el terminal. Se dispara al cierre de barra
log.info(message), log.warning(message), log.error(message) Escribe una línea en la pestaña «Registro» del Editor. En la historia está silencioso

Frecuencia alert: alert.freq_all — en cada pasada, alert.freq_once_per_bar — una vez por barra en la primera ocurrencia, alert.freq_once_per_bar_close — una vez por barra al cierre. Más detalles en Alertas desde scripts.

strategy — estrategias

Funciona solo en un script declarado con strategy(...). El probador ejecuta órdenes emuladas sobre la historia — no se colocan en el exchange. Cómo está hecho el probador se explica en Estrategias y probador.

Órdenes

Función Qué hace
strategy.entry(id, direction, qty = na, limit = na, stop = na, oca_name = na, oca_type = strategy.oca.none, comment = na, when = true) Entrada en strategy.long o strategy.short. Tiene en cuenta el modelo de posición y pyramiding; una entrada contra la posición la invertirá
strategy.order(id, direction, qty = na, limit = na, stop = na, oca_name = na, oca_type = strategy.oca.none, comment = na, when = true) Orden que elude las reglas de entrada: no respeta el modelo de posición ni pyramiding
strategy.exit(id, from_entry = na, qty = na, qty_percent = na, profit = na, limit = na, loss = na, stop = na, trail_price = na, trail_points = na, trail_offset = na, oca_name = na, comment = na, when = true) Salida por take, stop o trailing. profit, loss, trail_points — en ticks; limit, stop, trail_price — en precio
strategy.close(id, comment = na, qty = na, qty_percent = na, when = true) Cierra la posición de la entrada id al mercado
strategy.close_all(comment = na, when = true) Cierra todo
strategy.cancel(id, when = true), strategy.cancel_all(when = true) Cancela órdenes no ejecutadas

Si qty no se especifica, el tamaño se toma de defaultQtyType y defaultQtyValue de la declaración. Grupos OCA: strategy.oca.none, strategy.oca.cancel, strategy.oca.reduce.

Estado

Nombre Tipo Qué contiene
strategy.position_size float Tamaño de la posición: positivo — largo, negativo — corto
strategy.position_avg_price float Precio medio de entrada
strategy.position_entry_name string Nombre de la entrada que abrió la posición
strategy.openprofit, strategy.netprofit float Resultado no realizado y realizado
strategy.grossprofit, strategy.grossloss float Suma de ganancias y suma de pérdidas
strategy.equity, strategy.initial_capital float Capital actual e inicial
strategy.max_drawdown, strategy.max_runup float Mayor drawdown y mayor runup
strategy.wintrades, strategy.losstrades, strategy.eventrades int Operaciones ganadoras, perdedoras, en cero
strategy.opentrades, strategy.closedtrades int Operaciones abiertas y cerradas
strategy.margin_liquidation_price float Precio de liquidación dado un margen
strategy.funding_paid float Funding pagado y recibido
Campos de operaciones y constantes

Los campos de una operación abierta por índice i — strategy.opentrades.<campo>(i), y de una cerrada — strategy.closedtrades.<campo>(i):

Campo Tipo Qué contiene
entry_price, entry_bar_index, entry_time, entry_id float, int, int, string Precio, barra, tiempo y nombre de la entrada
size float Tamaño de la operación
profit, max_runup, max_drawdown float Resultado, mejor y peor momento de la operación
commission, funding float Comisión y funding de la operación
exit_price, exit_bar_index, exit_time, exit_id, exit_reason float, int, int, string, int Solo en cerradas: precio, barra, tiempo, nombre y razón de salida

Razones de salida: strategy.exit_reason.stop_loss, take_profit, trailing_stop, market_order, reverse, oca, liquidation, end_of_data. Esta versión no devuelve la razón oca.

Constantes de la declaración: strategy.long, strategy.short, strategy.model.netting, strategy.model.hedging, strategy.qty.fixed, strategy.qty.cash, strategy.qty.percent_of_equity, strategy.qty.risk_percent, strategy.commission.percent, strategy.commission.cash_per_contract, strategy.commission.cash_per_order, strategy.fill.conservative, strategy.fill.optimistic.

Datos de order flow

Estos espacios son lo que no existe en lenguajes de indicadores normales: clústeres, delta, interés abierto, tasa de financiación, historia del libro de órdenes y datos en vivo. Si no hay datos para la barra, el valor es na, no cero. De dónde vienen los datos y cómo comprobar su disponibilidad se explica en Datos de mercado: clústeres, delta, interés abierto, tasa de financiación, historia del libro, libro de órdenes y cinta de operaciones en vivo, screener.

Historia: disponible en cada barra

Espacio Nombres
cluster — clústeres de la barra available (datos cargados), levels (número de niveles), total (volumen de la barra), delta, poc y poc_index (precio y índice del nivel con más volumen), max_cell (volumen de la celda más grande), grid_step (paso de precio), stacked_buy / stacked_sell (precio de inicio de una serie de desbalances), stacked_buy_steps / stacked_sell_steps (longitud de la serie en niveles)
cluster — funciones cluster.price(index), cluster.bid(index), cluster.ask(index) — precio y volúmenes del nivel, contado desde abajo; cluster.imbalance(index) → int: 1 — predominio de compras, −1 — ventas, 0 — ninguno; cluster.value_area(coverage) → [low, high] — zona de valor con la fracción de volumen coverage
delta — delta de la barra available, value (compras menos ventas), buy, sell, cum (acumulada), min / max (extremos dentro de la barra), open / high / low / close (delta como vela), trades (número de operaciones), usd (en moneda cotizada)
oi — interés abierto available, open, high, low, close, usd, coins, change (cambio respecto a la barra anterior)
funding — tasa de financiación available, rate (estimación de la tasa), interval_hours (int, horas entre liquidaciones), settled (en la barra hubo liquidación), settled_rate (tasa aplicada), cum (acumulada)
depth — historia del libro de órdenes available, levels, grid_step, best_bid, best_ask, max_cell; depth.price(index), depth.qty(index), depth.side(index) (1 — bid, −1 — ask); depth.at(price); depth.bid_sum(percent), depth.ask_sum(percent), depth.imbalance(percent) — en la franja percent % desde el centro; depth.max_bid(percent), depth.max_ask(percent) → [price, qty]

Solo en vivo: en la historia siempre na

Espacio Nombres
book — libro de órdenes available, spread, mid; book.bid(index), book.ask(index) — precios de niveles desde el mejor; book.bid_qty(index), book.ask_qty(index) — volúmenes; book.imbalance(depth) — desbalance en depth niveles, −1…1
tape — cinta de operaciones available, last_price, last_qty, last_side (1 — comprador, −1 — vendedor); tape.count(window_ms) → int, tape.buy_volume(window_ms), tape.sell_volume(window_ms), tape.max_print(window_ms) — en los últimos window_ms milisegundos
screener — métricas del screener available; screener.natr(window), screener.rvol(window), screener.avg_vol(window), screener.btc_corr(window), screener.change(window), screener.oi_delta(window), screener.vol(window)

Las ventanas del screener son cadenas: natr — "1m", "5m"; rvol — "1h", "24h"; avg_vol — "1m", "5m", "15m", "1h"; btc_corr — "1m", "5m"; change y oi_delta — "1m", "5m", "1h", "24h" (change además "15m"); vol — "1m", "5m", "15m", "1h", "24h". Una ventana no listada devuelve na.

Siguiente

https://docs.lootx.trade/es/loot/reference

Основы

3Primer script

Paso a paso: cómo abrir el editor de LootScript, escribir un indicador de dos líneas, añadirlo al gráfico, leer errores y encontrar el archivo del script. Segundo ejemplo: un canal con ajustes.

En esta página recorrerá el camino desde un editor vacío hasta su propio indicador en el gráfico: escribirá un script de dos líneas, verá cómo el editor detecta errores, sabrá dónde está el archivo y añadirá la ventana de ajustes. Necesitará un gráfico abierto y scripts activados; si no están en la ventana de indicadores, lea la sección Cómo activar los scripts.

Abra el editor

Abra la ventana de indicadores

En el panel del gráfico, haga clic en el botón ƒ — su tooltip es «Indicadores».

Inicie el editor

Haga clic en Editor… junto al campo de búsqueda o en Nuevo script en la parte inferior de la ventana. Para abrir un script existente, búsquelo en la sección Mis scripts y haga clic en el lápiz Editar script de su fila (o seleccione la fila y pulse Ctrl+E).

Localice los botones necesarios

El editor se abre en una ventana separada con su propio botón en la barra de tareas; puede moverla a un segundo monitor. En la parte superior está la lista desplegable de scripts y los botones Nuevo, Guardar y Añadir al gráfico; abajo, las pestañas Problemas, Registro y Salida.

El editor recuerda el panel del gráfico desde cuya ventana de indicadores se abrió; añadirá el script en ese panel. Si el editor se abre de otra manera, el script irá al panel de gráfico activo.

Escriba el indicador

El botón Nuevo (Ctrl+N) crea un script a partir de una plantilla: una media móvil con un ajuste:

Loot
indicator("Без названия", overlay = true)

length = input.int(20, "Length", minval = 1)
plot(ta.ema(close, length), "EMA", color = color.orange)

Sustituya el texto por el indicador funcional más corto: una media simple de 20 velas:

Loot
indicator("Мой первый индикатор", overlay = true)

plot(ta.sma(close, 20), "Средняя 20", color = color.orange)

Qué está escrito aquí:

  • indicator(...) es la declaración, primera línea obligatoria de cualquier script. El nombre aparecerá en la lista Mis scripts y en la leyenda del gráfico. overlay = true dibuja sobre las velas; con overlay = false el indicador tendrá un panel separado bajo el gráfico.
  • ta.sma(close, 20) es la media de los precios de cierre de las últimas 20 velas.
  • plot(...) dibuja una línea: un valor por cada vela. El segundo argumento es el nombre de la línea en los ajustes, color es el color.

El script se ejecuta para cada vela, en orden desde la más antigua hasta la actual. Las primeras 19 velas no tienen suficiente historial para la media, por lo que la línea no comienza desde el borde izquierdo; es normal. El editor indica cuántas velas tarda este «calentamiento» en la barra de estado inferior.

Mientras escribe, el editor sugiere nombres de funciones y constantes; tras el paréntesis de apertura muestra los parámetros de la función y, al pasar el cursor sobre un nombre, su descripción. La lista de sugerencias se puede invocar manualmente con Ctrl+Space.

Guarde y añada al gráfico

  • Guardar (Ctrl+S) escribe el script en la carpeta de scripts. Mientras haya cambios sin guardar, aparece un punto • antes del nombre del archivo en el título de la ventana.
  • Añadir al gráfico (Ctrl+Enter) comprueba el script, lo guarda y lo coloca en el panel del gráfico. En el panel del editor aparecerá el mensaje: «Mi primer indicador» añadido al gráfico.

Listo: la línea está en el gráfico y el nombre del indicador en la leyenda. El indicador se guarda en la vista y volverá tras reiniciar el terminal.

Cómo muestra el editor los errores

El script se comprueba solo, un instante después de que deje de escribir. El resultado se ve en la cabecera del editor: compilando…, luego ok · 12 ms o, si algo va mal, errores: 1 o advertencias: 1.

Pruebe a equivocarse: escriba ta.smaa en lugar de ta.sma. El lugar del error se subraya con una línea ondulada, el contador de la cabecera muestra errores: 1 y en la pestaña Problemas aparece una fila con el código de error, la explicación y la posición:

TEXT
LS2002  Неизвестное имя «ta.smaa» — проверьте написание или объявите его выше   Стр 3:6

Un doble clic en la fila lleva el cursor al lugar del error. Cada error tiene un código permanente del tipo LS####, y el texto sugiere de inmediato cómo corregirlo. El análisis de errores frecuentes está en la página Errores de compilación y ejecución.

Un script con errores no se añadirá al gráfico: Añadir al gráfico responderá «Un script con errores no se coloca en el gráfico; véase «Problemas»» y moverá el cursor al primer error. En la ventana de indicadores, dicho script se marca con una etiqueta roja con el número de errores en lugar de la etiqueta Script.

También hay errores en tiempo de ejecución; por ejemplo, un bucle que no cabe en el tiempo asignado. Entonces el script se detiene y la causa se ve en la pestaña Salida: «Script detenido: …». Los demás indicadores y el terminal siguen funcionando.

Edición de un script que ya está en el gráfico

Mientras edita, el gráfico sigue mostrando la versión que añadió. En cuanto el editor tiene una versión correcta distinta de la del gráfico, ocurren dos cosas:

  • en el panel del editor aparece el botón Actualizar indicador;
  • en la leyenda del indicador en el gráfico aparece un icono de actualización.

Cualquiera de ellos guarda el script y lo sustituye en todos los gráficos donde esté. Añadir al gráfico para un script que ya está añadido en algún lugar hace lo mismo: actualiza todas las copias, no coloca una segunda. Cuántos paneles recibirán la nueva versión lo muestra la etiqueta en gráficos: N en la cabecera del editor.

Dónde están los archivos

En Windows, los scripts se guardan en la carpeta %APPDATA%\TradingTerminal\scripts\, un archivo .loot por script. Es texto plano; puede abrirlo con cualquier editor, copiarlo o guardarlo en una copia de seguridad. La carpeta está fuera de la carpeta de instalación, por lo que las actualizaciones del terminal no la tocan.

El nombre del archivo se genera a partir del título en el primer guardado: los espacios se sustituyen por guiones bajos y la cirílica se conserva. «Mi primer indicador» se convertirá en el archivo Мой_первый_индикатор.loot.

Cuando la carpeta se crea por primera vez, se incluyen seis scripts iniciales: Dos medias móviles, RSI con zonas, Impulso de volumen, Delta acumulada, Interés frente a precio y Tasa de financiación anualizada. Están en la sección Mis scripts; conviene abrirlos y analizarlos.

Segundo ejemplo: canal con ajustes

Hagamos un script más útil: un canal de una media y dos bordes a una distancia de varias desviaciones estándar. El periodo, la anchura y la fuente de precio se llevarán a los ajustes, y los bordes superior e inferior se resaltarán en rojo cuando el precio los supere.

Loot
indicator("Канал вокруг средней", overlay = true)

length = input.int(20, "Период", minval = 2)
mult   = input.float(2.0, "Ширина в сигмах", minval = 0.1, step = 0.1)
src    = input.source(close, "Источник")

basis = ta.sma(src, length)
dev   = mult * ta.stdev(src, length)
upper = basis + dev
lower = basis - dev

plot(basis, "Середина", color = color.gray)
plot(upper, "Верх", color = close > upper ? color.red : color.teal)
plot(lower, "Низ", color = close < lower ? color.red : color.teal)

Novedades:

  • Cada llamada input.* se convierte en una fila en la ventana de ajustes del indicador, en el orden en que está escrita. minval impide introducir un periodo menor que dos, y step = 0.1 significa que el campo de anchura muestra un decimal.
  • input.source se convierte en una lista desplegable de series: close, open, hl2, volume y otras.
  • El color de los bordes es una expresión, por lo que se calcula para cada vela por separado.

Añada el script al gráfico y haga doble clic en su fila de la leyenda (o haga clic en el icono de ajustes que hay en ella). En la pestaña Entradas están sus tres ajustes: cambie el periodo y las líneas se recalcularán al instante. Los valores se recuerdan para este indicador en este gráfico; el botón Por defecto devuelve los escritos en el código. En la pestaña Estilo están el color de la media y el grosor de cada línea; en la pestaña Visibilidad, las casillas para ocultar cualquiera de las tres líneas. El color de los bordes no está en los ajustes: lo elige el propio script en cada vela.

Siguientes pasos

https://docs.lootx.trade/es/loot/first-script

Основы

4Синтаксис и типы

Как устроен LootScript: выполнение по барам, объявление скрипта, пять форм присваивания, типы и квалификаторы, na, история x[n], операторы, условия, switch, циклы, функции и свои типы.

Эта страница — краткое описание языка: как выполняется скрипт, как объявлять переменные, какие есть типы, что такое na, как читать прошлые бары, как писать условия, циклы и функции. Все примеры — целые рабочие скрипты: их можно вставить в редактор и добавить на график.

Как выполняется скрипт

Всё, что написано на верхнем уровне файла, выполняется один раз на каждый бар — от самого старого загруженного к текущему, строка за строкой. Поэтому переменная в LootScript хранит не одно число, а значение на каждом баре, и к прошлым значениям можно обратиться.

Loot
indicator("Тело свечи")

body = close - open          // считается заново на каждом баре
plot(body, "Тело", style = plot.style_columns)

На текущем, ещё не закрытом баре скрипт пересчитывается с каждым новым тиком, начиная с состояния, которое было на закрытии предыдущего бара. Закрытые бары при этом не пересчитываются.

Объявление

Первая инструкция скрипта — ровно одно объявление: indicator(...), strategy(...) или library(...). Выше него могут стоять только комментарии и необязательная строка версии #version 1. Без объявления скрипт не скомпилируется с ошибкой «Нет объявления скрипта — начните с indicator(“Название”)».

Loot
#version 1
// Комментарии и строка версии могут стоять выше объявления.
indicator("Размах бара", shortTitle = "Размах", overlay = false)

plot(high - low, "Размах", style = plot.style_histogram)

Главные параметры индикатора: title — название в списке скриптов, shortTitle — короткое имя для легенды, overlay — рисовать поверх цены (true) или в отдельной панели (false, по умолчанию). Параметры стратегии описаны на странице Стратегии и тестер.

Переменные и присваивание

Форма Что делает
x = выражение Объявляет переменную. На каждом баре она считается заново.
x := выражение Присваивает новое значение уже объявленной переменной. Тип должен совпадать.
var x = выражение Объявляет переменную один раз, на первом баре. Значение переходит на следующие бары.
varip x = выражение Как var, но значение сохраняется и между тиками текущего бара.
[a, b, c] = функция(...) Раскладывает несколько результатов функции по переменным.

Для изменения уже объявленной переменной есть и короткие формы: +=, -=, *=, /=, %=. Тип можно указать явно: float level = 0. Имена встроенных рядов и пространств (close, volume, ta и других) заняты — назвать так свою переменную нельзя.

Главное отличие от привычных языков — обычная переменная не накапливает значение между барами. Для счётчиков и сумм нужен var:

Loot
indicator("Счётчик зелёных свечей")

var greens = 0          // объявляется один раз и переживает переход к следующему бару
if close > open {
    greens += 1
}

today = 0               // а эта переменная равна 0 на каждом новом баре
today := today + 1      // поэтому здесь всегда 1

plot(greens, "Зелёных с начала истории")

varip нужен редко — например, чтобы считать тики внутри бара. На истории тиков нет, поэтому такое значение на прошлых барах будет другим, чем было вживую. Если значение varip попадает на график, редактор предупредит о перерисовке.

Типы

Тип Что хранит Пример
int целое число 14, 1_000_000, 0xFF
float дробное число 2.5, .5, 1e-9
bool истина или ложь true, false
string текст "BTC", 'BTC'
color цвет с прозрачностью #FF9800, #FF980080, color.teal

Есть и составные типы: массивы array<float>, словари map<string, float>, матрицы matrix<float>, а также ваши собственные типы и перечисления (см. ниже) и графические объекты line, box, label, table.

Правила, о которые спотыкаются чаще всего:

  • Тип фиксируется при объявлении. После x = 1 присвоить x := 2.5 нельзя: x — целое. Пишите x = 1.0 или float x = 1.
  • Целое превращается в дробное само, обратно — только явно: math.round, math.floor, math.ceil, math.trunc.
  • Деление целых — целое: 7 / 2 равно 3. Нужна дробь — сделайте одно из чисел дробным: 7.0 / 2.
  • Возведение в степень ^ всегда даёт дробное число: 2 ^ 3 равно 8.0.
  • Строку нельзя сложить с числом. "Цена: " + close не скомпилируется — пишите "Цена: " + str.tostring(close).
  • Условие — только bool. if volume { … } — ошибка; пишите if volume > 0 { … }.

Квалификаторы: насколько значение постоянно

Кроме типа у каждого значения есть квалификатор — насколько оно постоянно во время работы скрипта. От слабого к сильному:

Квалификатор Когда известно значение Пример
const уже при компиляции 14, "EMA"
input после чтения настроек, дальше не меняется input.int(14, "Период")
simple при запуске, дальше не меняется шаг цены инструмента
series может меняться на каждом баре close, bar_index

На практике это важно в одном месте: периоды функций ta.* должны быть постоянными — литералом или настройкой. Иначе функции пришлось бы пересобирать своё состояние на каждом баре.

Loot
indicator("Период из настроек")

len = input.int(14, "Период", minval = 2)
plot(ta.rsi(close, len), "RSI")

// ta.rsi(close, bar_index) не скомпилируется:
// «length» в «ta.rsi» требует значение не слабее input, а передано series

na — нет значения

na означает «значения нет»: не хватает истории для расчёта, биржа не отдаёт показатель, в данных дыра. na есть в любом типе.

  • Арифметика с na даёт na: na + 1 — это na.
  • Любое сравнение с na ложно, поэтому if x > 0 при x = na не выполнится.
  • Проверяйте отсутствие только через na(x). Запись x == na компилятор отклонит с ошибкой «Сравнение с na всегда ложно — используйте na(x)».
  • nz(x) подставляет 0 вместо na, nz(x, v) — значение v. То же короче: x ?? v.
  • na на графике — разрыв линии, а не ноль.
Loot
indicator("Средняя без пустого начала", overlay = true)

avg = ta.sma(close, 50)             // на первых 49 барах — na

line1 = na(avg) ? close : avg       // проверка через na(x)
line2 = avg ?? close                // то же короче

plot(line2, "Средняя или цена", color = color.orange)

История: x[n]

x[n] — значение x на баре, который был n баров назад; x[0] — текущее. Работает с любым рядом, в том числе с вашими переменными.

Loot
indicator("Наклон средней")

ma    = ta.ema(close, 20)
slope = ma - ma[1]                  // изменение за один бар

plot(slope, "Наклон", style = plot.style_histogram,
     color = slope >= 0 ? color.teal : color.red)
  • Если n больше числа баров до начала истории, результат — na, а не ошибка.
  • n может меняться от бара к бару: close[len] при переменном len допустимо.
  • Отрицательный индекс — ошибка: заглядывать в будущие бары нельзя.
  • Настраивать глубину истории не нужно: скрипту доступна вся история, загруженная на график.

Операторы

От высшего приоритета к низшему:

Приоритет Операторы
1 x[n], вызов f(…), доступ через точку a.b
2 ^ — степень, вычисляется справа налево
3 унарные -, +, not
4 *, /, %
5 +, -
6 <, >, <=, >=
7 ==, !=
8 and
9 or
10 ?? — замена na
11 ? : — условное выражение
  • Сравнения не сцепляются: вместо a < b < c пишите a < b and b < c.
  • and и or не вычисляют правую часть, если ответ уже ясен по левой.
  • Степень старше унарного минуса: -2 ^ 2 равно -4. Нужно 4 — пишите (-2) ^ 2.
  • Дробные числа сравнивайте с допуском: math.approx(a, b), потому что 0.1 + 0.2 == 0.3 ложно.

Условия

Блоки всегда в фигурных скобках. if бывает инструкцией и выражением; для простого выбора из двух есть ? :.

Loot
indicator("Направление бара")

dir = 0
if close > open {
    dir := 1
} else if close < open {
    dir := -1
}

// if как выражение: обе ветки обязательны
bodySize = if close >= open { close - open } else { open - close }

// условный оператор для простых случаев
barColor = dir > 0 ? color.teal : color.red

plot(bodySize, "Тело", style = plot.style_columns, color = barColor)

switch

switch выбирает первую подходящую ветку. Форма с объектом сравнивает его со значениями веток, форма без объекта проверяет условия по порядку. Ветка => без условия — ветка по умолчанию. Проваливания в следующую ветку нет. Когда switch возвращает значение, ветка по умолчанию обязательна.

Loot
indicator("Средняя на выбор", overlay = true)

kind = input.string("EMA", "Тип средней", options = ["EMA", "SMA", "WMA"])

ma = switch kind {
    "EMA" => ta.ema(close, 20)
    "SMA" => ta.sma(close, 20)
    =>       ta.wma(close, 20)
}

zone = switch {
    close > ma * 1.02 => 1
    close < ma * 0.98 => -1
    =>                   0
}

plot(ma, "Средняя", color = zone == 1 ? color.teal : zone == -1 ? color.red : color.gray)

Циклы

for i in a .. b перебирает числа от a включительно до b не включительно. Шаг задаётся словом by, в том числе отрицательный. Переменная цикла существует только внутри цикла и не меняется в теле.

Loot
indicator("Зелёные свечи за N баров")

n = input.int(10, "Сколько баров", minval = 1, maxval = 200)

greens = 0
for i in 0 .. n {               // i = 0, 1, …, n − 1
    if close[i] > open[i] {
        greens += 1
    }
}

plot(greens, "Зелёных", style = plot.style_columns)
Loot
indicator("Виды циклов")

total = 0
for i in 0 .. 10 by 2 {         // 0, 2, 4, 6, 8
    total += i
}
for i in 10 .. 0 by -1 {        // 10, 9, …, 1
    if i % 3 == 0 {
        continue                // сразу к следующему шагу
    }
    total += i
}

var closes = array.new<float>(0)
closes.push(close)
if closes.size() > 20 {
    closes.shift()
}
sum = 0.0
for v in closes {               // по элементам массива; for [i, v] in … — с индексом
    sum += v
}

k = 0
while k < 100 {
    k += 7
    if k > 50 {
        break                   // выход из цикла
    }
}

plot(sum / closes.size(), "Средняя из массива")

Бесконечный цикл терминал не повесит: у скрипта есть бюджет операций на бар и лимит времени. Превысив их, скрипт остановится с сообщением «Скрипт исчерпал бюджет операций на бар — упростите цикл» или «Скрипт превысил лимит времени на проход».

Функции

Функция объявляется словом func. Короткая форма — выражение после =>, длинная — тело в скобках с return. Типы параметров можно не указывать — они выводятся из вызовов, а у параметров могут быть значения по умолчанию. Аргументы передаются по порядку или по имени.

Loot
indicator("Z-оценка объёма")

func barRange(h, l) => h - l

func zscore(series float src, input int len) => float {
    m = ta.sma(src, len)
    s = ta.stdev(src, len)
    return s == 0 ? na : (src - m) / s
}

func scaled(x, k = 2.0) => x * k

z = zscore(volume, 50)
plot(z, "Z объёма", style = plot.style_columns, color = z > 2 ? color.orange : color.gray)
plot(scaled(barRange(high, low), k = 0.5), "Полразмаха")
  • Рекурсии нет. Функция не может вызывать саму себя, ни напрямую, ни через другую функцию. Повторение пишется циклом.
  • Состояние — у каждого вызова своё. Если внутри функции есть ta.* или var, два вызова одной функции ведут независимые расчёты:
Loot
indicator("Два вызова одной функции", overlay = true)

func smooth(src, len) => ta.ema(src, len)

fast = smooth(close, 10)        // своя средняя
slow = smooth(close, 30)        // другая, независимая средняя

plot(fast, "Быстрая", color = color.teal)
plot(slow, "Медленная", color = color.orange)

Функции, нужные в нескольких скриптах, выносят в библиотеку: скрипт с объявлением library("Имя", 1), перед функциями — слово export, в другом скрипте — import Имя/1 as имя. Библиотека берётся из вашей папки скриптов.

Несколько результатов

Некоторые функции возвращают сразу несколько рядов: ta.bb, ta.macd, ta.kc, ta.dmi, ta.supertrend и другие. Их результат раскладывается по переменным в квадратных скобках; число имён должно совпадать с числом результатов.

Loot
indicator("Полосы Боллинджера", overlay = true)

[basis, upper, lower] = ta.bb(close, 20, 2.0)

plot(basis, "Середина", color = color.gray)
plot(upper, "Верх", color = color.teal)
plot(lower, "Низ", color = color.teal)

Свои типы и перечисления

type собирает несколько полей в одну структуру. Объект создаётся через Имя.new(...), поля читаются и меняются через точку.

Loot
indicator("Последний локальный максимум", overlay = true)

type Swing {
    int   barIndex
    float price
}

var Swing last = Swing.new(barIndex = 0, price = high)

ph = ta.pivothigh(high, 5, 5)
if not na(ph) {
    last.barIndex := bar_index - 5
    last.price := ph
}

plot(last.price, "Максимум", style = plot.style_stepline, color = color.orange)

enum — закрытый список вариантов с подписями. Удобнее строк: опечатка в имени варианта — ошибка компиляции, а не тихо не сработавшее условие. Вместе с input.enum перечисление превращается в выпадающий список в настройках — см. Настройки и отрисовка.

Loot
indicator("Режим рынка")

enum Regime {
    trend = "Тренд"
    flat  = "Флэт"
}

regime = math.abs(close - close[20]) > ta.atr(14) * 3 ? Regime.trend : Regime.flat

plot(regime == Regime.trend ? 1 : 0, "Тренд", style = plot.style_stepline)

Функции ta.* внутри условий

Функции вроде ta.ema, ta.rsi или ta.atr помнят своё состояние с прошлого бара. Если бы такой вызов выполнялся только на части баров — внутри if или одной ветки ? :, — его расчёт пропускал бы бары и тихо давал неверные числа.

LootScript этого не допускает: компилятор сам выносит каждый вызов ta.* из условия и выполняет его на каждом баре, а условие лишь выбирает, использовать ли результат. Поэтому такой код считает RSI правильно:

Loot
indicator("RSI только на зелёных барах")

r = close > open ? ta.rsi(close, 14) : na

plot(r, "RSI", style = plot.style_circles)

Вынести вызов нельзя, только если его аргумент сам рождается внутри ветки. Тогда компилятор не угадывает, а сообщает: «Аргумент «len» нельзя вычислить вне ветки — вынесите вызов ta.* на верхний уровень». Решение — посчитать аргумент до условия:

Loot
indicator("Аргумент до условия")

// Так нельзя — len объявлена внутри ветки:
// if close > open {
//     len = 10
//     e = ta.ema(close, len)
// }

len = 10
e = ta.ema(close, len)

plot(close > open ? e : na, "EMA на зелёных барах", style = plot.style_circles)

Комментарии и перенос строк

  • // — комментарий до конца строки, /* … */ — блочный, блоки можно вкладывать друг в друга.
  • Инструкция заканчивается с концом строки, точка с запятой не нужна.
  • Длинное выражение продолжается на следующей строке, если строка оборвана внутри скобок, заканчивается оператором или следующая строка начинается с оператора, ? или :.
Loot
indicator("Перенос строк")

typical = high
        + low
        + close

signal = close > open
    ? typical / 3
    : na

plot(signal, "Типичная цена на зелёных барах", style = plot.style_circles)

Дальше

https://docs.lootx.trade/es/loot/syntax

Основы

5Ajustes y renderizado

Ajustes input.* en la ventana del indicador, líneas plot y sus estilos, niveles hline, rellenos fill, fondo y color de velas, marcadores, etiquetas, segmentos, rectángulos, tablas, colores y transparencia. Límites: tres plot dibujables y 500 objetos de cada tipo.

Esta página trata sobre lo que el usuario ve y puede cambiar. Aquí se describen los ajustes que el script expone en la ventana del indicador, las líneas y sus estilos, los niveles y rellenos, el fondo y el color de las velas, los marcadores, las etiquetas, los segmentos, los rectángulos y las tablas, así como los colores y la transparencia. Al final hay una sección sobre los límites que conviene conocer de antemano.

Ajustes: input.*

Cada llamada a input.* se convierte en una fila de la pestaña Entradas en la ventana de ajustes del indicador. Las filas aparecen en el orden en que están escritas las llamadas en el script. El primer argumento establece el valor por defecto; el segundo, la etiqueta de la fila.

Llamada Qué aparece en la ventana de ajustes
input.int Campo para un número entero
input.float Campo para un número decimal
input.bool Casilla de verificación
input.color Selector de color
input.string Lista desplegable si se define options; sin ella, campo de texto
input.source Lista desplegable de series: open, high, low, close, hl2, hlc3, ohlc4, hlcc4, volume
input.enum Lista desplegable con las etiquetas del enum
input.timeframe Campo de texto; con options, lista desplegable
input.symbol Campo de texto

El ejemplo siguiente reúne cinco tipos de ajustes en un solo script:

Loot
indicator("Средняя на выбор", overlay = true)

enum Basis {
    sma = "Простая"
    ema = "Экспоненциальная"
    wma = "Взвешенная"
}

basis     = input.enum(Basis.ema, "Тип средней")
length    = input.int(50, "Период", minval = 1, maxval = 500)
src       = input.source(close, "Источник")
lineColor = input.color(color.orange, "Цвет линии")
showBg    = input.bool(false, "Подсвечивать фон")

avg = switch basis {
    Basis.sma => ta.sma(src, length)
    Basis.ema => ta.ema(src, length)
    =>           ta.wma(src, length)
}

plot(avg, "Средняя", color = lineColor, linewidth = 2)
bgcolor(showBg and close > avg ? color.new(color.teal, 40) : na, title = "Фон")

En la ventana de ajustes aparecerá la lista desplegable «Тип средней» con los elementos «Простая», «Экспоненциальная» y «Взвешенная». Debajo estarán el campo del período, la lista de fuentes, el selector de color y la casilla de verificación. Cómo declarar enums se explica en la sección Свои типы и перечисления.

Parámetros de números y cadenas

  • minval y maxval establecen los límites: el campo no aceptará un período menor que minval ni mayor que maxval.
  • step en input.float define cuántos decimales muestra el campo: con step = 0.1 se ve un decimal. El campo no tiene flechas; el valor se escribe con el teclado.
  • options en input.string y input.timeframe convierte el campo en una lista desplegable. El valor por defecto debe ser uno de los elementos; de lo contrario, el compilador dará un error.
  • tooltip, group e inline son aceptados por el compilador, pero por ahora no afectan el aspecto de la ventana de ajustes.
Loot
indicator("Цена для расчёта")

mode  = input.string("Закрытие", "Считать по", options = ["Закрытие", "Середина свечи"])
price = mode == "Закрытие" ? close : hl2

plot(ta.rsi(price, 14), "RSI", color = color.purple)

En input.source, el valor por defecto también puede ser una serie de datos de mercado, como delta.cum. Esa serie aparecerá como primer elemento de la lista, antes de las series de precios. Si el valor por defecto es una expresión como (high + low) / 2, no habrá fila en la ventana de ajustes: no hay nada que elegir.

Todavía no existen ajustes separados para la hora, la sesión de trading ni para el precio que se elige con un clic en el gráfico.

Dónde se guardan los valores elegidos

Los valores se recuerdan por separado para cada indicador en cada gráfico: dos copias del mismo script en paneles distintos pueden tener períodos diferentes. El botón Por defecto en la ventana de ajustes restaura los valores escritos en el código.

El valor está vinculado al nombre de la variable en la que se guarda la llamada a input.*. La etiqueta de la fila se puede cambiar libremente y el valor elegido se conserva. Las filas también se pueden reordenar. Pero si se renombra la variable (length por period), el ajuste volverá al valor del código.

La ventana de ajustes se abre con doble clic en la fila del indicador en la leyenda del gráfico o con el icono de ajustes de esa fila. Además de la pestaña Entradas, contiene Estilo y Visibilidad, de las que se habla más adelante.

Líneas: plot

plot dibuja una serie, un valor por cada vela. Solo el primer argumento (la propia serie) es obligatorio. Los demás parámetros se indican por nombre:

  • title: nombre de la línea en la leyenda y en la ventana de ajustes;
  • color: color, constante o calculado en cada vela;
  • linewidth: grosor;
  • style: modo de renderizado, véase la tabla;
  • offset: desplazamiento de un número determinado de velas: positivo a la derecha, negativo a la izquierda;
  • show_last: dibujar solo las últimas N velas;
  • join = true: unir con una línea los puntos de los estilos circles y cross;
  • editable = false: quitar la línea de la ventana de ajustes;
  • display = display.none: ocultar la línea al añadirla; se puede activar en la pestaña Visibilidad.
Estilo Aspecto
plot.style_line Línea quebrada, estilo por defecto
plot.style_linebr Igual que line
plot.style_stepline Escalones
plot.style_stepline_diamond Escalones con rombos
plot.style_histogram Columnas finas desde cero, con grosor de línea
plot.style_columns Columnas desde cero, con ancho de vela
plot.style_area Área rellena hasta cero
plot.style_areabr Igual que area
plot.style_circles Puntos
plot.style_cross Cruces

La línea siempre se interrumpe donde la serie no tiene valor (na) y no salta el hueco con un segmento recto. Por eso los pares line/linebr y area/areabr se dibujan igual.

Loot
indicator("Стили линий")

d = close - open

plot(d, "Тело свечи", style = plot.style_histogram, color = d >= 0 ? color.teal : color.red)
plot(ta.sma(d, 10), "Средняя 10", style = plot.style_stepline, color = color.orange, linewidth = 2)
plot(ta.sma(d, 30), "Средняя 30", style = plot.style_circles, color = color.gray)

Color por velas

El color puede ser una expresión: en ese caso se calcula de nuevo en cada vela. El color na significa que en esa vela no hay línea:

Loot
indicator("Средняя только над ценой", overlay = true)

m = ta.sma(close, 50)
plot(m, "Средняя", color = close > m ? color.teal : na)

Qué obtiene la línea en la ventana de ajustes

  • En la pestaña Estilo se ajusta el grosor de cada línea. La fila de color aparece solo en las líneas con color constante: si el script elige el color en cada vela, no hay nada que cambiar en la ventana.
  • En la pestaña Visibilidad, cada línea tiene una casilla para mostrarla u ocultarla. Aparece si hay más de una línea o si la línea está oculta mediante display.
  • Una línea con editable = false no recibe filas en ninguna pestaña.

Niveles y rellenos

hline dibuja una línea horizontal a un precio constante, por ejemplo, los límites de las zonas del RSI. El precio debe ser un número o un ajuste input.*: una serie que cambia vela a vela no sirve aquí. Para una línea así se necesita plot. El estilo de la línea se define con hline.style_solid, hline.style_dashed y hline.style_dotted.

fill rellena el área entre dos fronteras. Para obtener una frontera, el resultado de hline o plot se guarda en una variable:

Loot
indicator("RSI с зонами")

length = input.int(14, "Период", minval = 1)
r = ta.rsi(close, length)

top    = hline(70, "Перекупленность", color = color.gray, linestyle = hline.style_dashed)
bottom = hline(30, "Перепроданность", color = color.gray, linestyle = hline.style_dashed)
fill(top, bottom, color = color.new(color.purple, 30), title = "Зона")

plot(r, "RSI", color = r > 70 ? color.red : r < 30 ? color.teal : color.purple)

Las dos fronteras deben ser del mismo tipo: dos niveles hline o dos líneas plot. El compilador no acepta un relleno entre una línea y un nivel.

El color de relleno entre dos líneas puede cambiar vela a vela. Así se obtiene una «nube» a partir de dos medias móviles:

Loot
indicator("Облако", overlay = true)

fast = ta.ema(close, 9)
slow = ta.ema(close, 21)

pf = plot(fast, "Быстрая", color = color.teal)
ps = plot(slow, "Медленная", color = color.orange)
fill(pf, ps, color = fast > slow ? color.new(color.teal, 50) : color.new(color.red, 50), title = "Облако")

También hay relleno con degradado. Defina top_value y bottom_value para indicar las alturas donde el color es igual a top_color y bottom_color; entre ellas, el color transita suavemente. Esas alturas deben ser números constantes. Si se necesita un relleno hasta un nivel constante, conviértalo en una línea: plot(50). Pero recuerde que cuenta como una de las tres líneas dibujables.

Loot
indicator("RSI с градиентом")

r  = ta.rsi(close, 14)
pr = plot(r, "RSI", color = color.purple)
pm = plot(50, "Середина", color = color.gray)
fill(pr, pm, top_value = 80, bottom_value = 50,
     top_color = color.new(color.teal, 160), bottom_color = color.new(color.teal, 0))

Fondo y color de velas

bgcolor pinta el fondo debajo de la vela; barcolor cambia el color de la propia vela. Ambos aceptan un color calculado en cada vela; en las velas con color na no cambia nada.

Loot
indicator("Подсветка объёма", overlay = true)

avgVol = ta.sma(volume, 20)
spike  = volume > avgVol * 2

bgcolor(spike ? color.new(color.orange, 40) : na, title = "Всплеск объёма")
barcolor(close > open ? color.teal : color.red, title = "Цвет свечей")

Marcadores: plotshape y plotchar

plotshape coloca un icono en las velas donde la condición es verdadera. plotchar hace lo mismo con cualquier símbolo.

Loot
indicator("Пересечения", overlay = true)

fast = ta.ema(close, 9)
slow = ta.ema(close, 21)

plotshape(ta.crossover(fast, slow), "Вверх", style = shape.triangleup,
          location = location.belowbar, color = color.teal, size = size.small)
plotshape(ta.crossunder(fast, slow), "Вниз", style = shape.triangledown,
          location = location.abovebar, color = color.red, size = size.small)
plotchar(volume > ta.sma(volume, 20) * 3, "Объём", char = "●", location = location.top, color = color.orange)
  • Forma, shape.*: triangleup, triangledown, arrowup, arrowdown, circle, square, diamond, cross, xcross, flag, labelup, labeldown.
  • Ubicación, location.*: abovebar — encima de la vela, belowbar — debajo de la vela, top y bottom — en los bordes superior e inferior del panel. En un panel separado debajo del gráfico, «encima de la vela» y «debajo de la vela» también significan el borde superior y el inferior: ese panel tiene su propia escala y los precios de las velas no están marcados en ella.
  • Tamaño, size.*: auto, tiny, small, normal, large, huge.
  • text añade una etiqueta corta al icono. Cuando el gráfico está muy alejado y las velas son estrechas, las etiquetas se ocultan y los iconos permanecen.

Objetos gráficos

Además de las series, el script puede dibujar objetos individuales: etiquetas label.new, segmentos line.new, rectángulos box.new y tablas table.new. Cada llamada a *.new devuelve un objeto. Se puede mover con las funciones set_* (label.set_xy, line.set_x2, box.set_top, etc.), leer con get_*, copiar con copy o eliminar con delete.

En horizontal, el objeto está vinculado por defecto al número de vela, bar_index. Con el parámetro xloc = xloc.bar_time, la coordenada se define por el tiempo de la vela. El parámetro extend (extend.right, extend.left, extend.both) prolonga el borde de un segmento o rectángulo hasta el límite del gráfico.

El objeto permanece en el gráfico hasta que se elimina. El script se ejecuta en cada vela, por lo que label.new sin condición creará una etiqueta por cada vela. Para mantener un solo objeto y moverlo, guárdelo en una variable var y elimine el anterior:

Loot
indicator("Последний пивот", overlay = true, maxLabelsCount = 50)

ph = ta.pivothigh(high, 10, 10)

var line level = na
if not na(ph) {
    label.new(bar_index - 10, ph, str.tostring(ph), style = label.style_label_down,
              color = color.orange, textcolor = color.white, size = size.small)
    line.delete(level)
    level := line.new(bar_index - 10, ph, bar_index, ph, extend = extend.right,
                      color = color.orange, style = line.style_dashed)
}

El script etiqueta cada máximo encontrado y traza una línea punteada desde el último hacia la derecha. Al mismo tiempo elimina la línea punteada anterior.

No puede haber más de 500 objetos vivos de cada tipo a la vez. Cuando aparece el número 501, el más antiguo desaparece. Los parámetros maxLinesCount, maxLabelsCount y maxBoxesCount en indicator() reducen este límite. Un valor mayor que 500 se recorta a 500.

Tablas

La tabla no está vinculada a las velas, sino a una esquina o borde del panel, y no se mueve al desplazar el gráfico. La posición se define con position.*: top_left, top_center, top_right, middle_left, middle_center, middle_right, bottom_left, bottom_center, bottom_right. Las celdas se rellenan con table.cell. Conviene hacerlo solo en la última vela, para no reescribir la tabla en todo el historial:

Loot
indicator("Сводка", overlay = true)

var t = table.new(position.top_right, 2, 2, bgcolor = color.new(color.black, 160))
if barstate.islast {
    table.cell(t, 0, 0, "RSI", text_color = color.white)
    table.cell(t, 1, 0, str.tostring(math.round(ta.rsi(close, 14), 1)), text_color = color.white)
    table.cell(t, 0, 1, "ATR", text_color = color.white)
    table.cell(t, 1, 1, str.tostring(math.round(ta.atr(14), 2)), text_color = color.white)
}

Una tabla no puede tener más de 200 columnas ni 200 filas. No se crea una tabla con más de 2000 celdas.

Colores

Colores con nombre: color.red, color.green, color.blue, color.teal, color.orange, color.purple, color.yellow, color.white, color.black, color.gray, color.silver, color.maroon, color.navy, color.olive, color.lime, color.aqua, color.fuchsia.

El color también se puede escribir con código: #FF8800 es opaco, #FF880040 tiene transparencia. El último par de dígitos define la opacidad: 00 es completamente transparente, FF es sólido.

  • color.rgb(r, g, b) compone un color a partir de componentes de 0 a 255. El cuarto argumento es la opacidad; por defecto, 255.
  • color.from_gradient(value, bottomValue, topValue, bottomColor, topColor) devuelve un color intermedio entre los dos extremos según la posición de value en el rango. Es útil para colorear un oscilador de frío a caliente.
  • na en lugar de un color significa «no dibujar».
Loot
indicator("RSI в цвете")

r = ta.rsi(close, 14)
heat = color.from_gradient(r, 30, 70, color.rgb(0, 150, 136), color.rgb(244, 67, 54))

plot(r, "RSI", color = heat, linewidth = 2)
bgcolor(r > 70 ? color.new(color.red, 30) : r < 30 ? color.new(color.teal, 30) : na, title = "Зоны")

Siguiente

https://docs.lootx.trade/es/loot/inputs-drawing

Основы

6Datos de mercado: clústeres, delta, interés abierto y libro de órdenes

Qué lee un script en LootScript además de las velas: clústeres, delta, interés abierto, tasa de financiación, historial y libro de órdenes en vivo, cinta de operaciones, screener, otra temporalidad e instrumento.

Además de las velas, un script en LootScript lee datos del flujo de órdenes: clústeres, delta, interés abierto, tasa de financiación, el historial del libro de órdenes grabado, el libro de órdenes en vivo y la cinta de operaciones, y las métricas del screener. No hace falta activar nada: en cuanto el script referencia, por ejemplo, cluster.poc, el terminal se suscribe automáticamente a los clústeres del instrumento y de la temporalidad del gráfico —incluso si el gráfico muestra velas normales. Cuando se quita el script del gráfico, la suscripción se libera.

En esta página — qué hay en cada espacio de nombres, de dónde vienen los datos, en qué exchanges están disponibles y cómo obtener valores de otra temporalidad u otro instrumento.

Regla principal: ausencia de datos = na, no 0

Cualquier valor referido en esta página puede ser na. Sucede si el exchange no está cubierto por el servidor, la temporalidad no está soportada, la historia aún se está cargando o la barra es más antigua que la historia disponible. Un cero significaría «no hubo trades», y eso es un hecho diferente: sumar ceros sustituidos puede parecer plausible y a la vez ser incorrecto.

Cada espacio de nombres tiene una bandera de disponibilidad — cluster.available, delta.available, oi.available, etc. Compruébala o usa la función na(x). El compilador no permite comparar con na usando ==.

Loot
indicator("Накопленная дельта без подмены нулём", overlay = false)
var float cvd = 0.0
if delta.available {
    cvd := cvd + delta.value
}
plot(delta.available ? cvd : na, "CVD", color = color.teal)

Por qué faltan datos lo indica la leyenda del gráfico junto al nombre del script: “exchange no cubierto”, “temporalidad no compatible”, “cargando datos…”, “no hay libro de órdenes abierto”, “screener no disponible”.

Origen de los datos

Espacio Qué es Historia en el gráfico
cluster.* Clústeres (footprint) de la barra: volumen por precios Hay, desde el servidor de clústeres
delta.* Delta de compras y ventas agresivas Hay
oi.* Interés abierto Hay
funding.* Tasa de financiación y sus cálculos Hay
depth.* Libro de órdenes grabado por el servidor, por barras Hay, con profundidad limitada
book.* Libro de órdenes en vivo Solo la última barra
tape.* Cinta de operaciones en vivo Solo la última barra
screener.* Métricas del screener por instrumento Solo la última barra

Clústeres: cluster.*

El volumen de cada nivel de precio dentro de la barra, separado en compras y ventas agresivas — los mismos datos que dibuja el gráfico footprint. Los niveles se numeran de abajo arriba, de 0 a cluster.levels - 1.

Nombre Qué devuelve
cluster.available Si hay clústeres en esta barra
cluster.levels Número de niveles de precio en la barra
cluster.price(i) Precio del nivel i
cluster.bid(i) Compras agresivas en el nivel i
cluster.ask(i) Ventas agresivas en el nivel i
cluster.total Todo el volumen de la barra
cluster.delta Compras menos ventas en todos los niveles
cluster.poc, cluster.poc_index Precio y número del nivel con mayor volumen
cluster.max_cell Volumen de la celda más grande de la barra
cluster.imbalance(i) Desbalance del nivel: +1 compras, -1 ventas, 0 ninguno
cluster.stacked_buy, cluster.stacked_sell Precio desde el que comienza la serie más larga de niveles con desbalance
cluster.stacked_buy_steps, cluster.stacked_sell_steps Longitud de esa serie en niveles
cluster.value_area(pct) Límite inferior y superior de la zona de valor; pct — fracción de volumen, 0.7 = 70 %
cluster.grid_step Paso de la rejilla de precios de la barra

Fíjate en los nombres: cluster.bid(i) son compras que “quitaron” un ask, no órdenes de compra en el libro.

Hay clústeres en temporalidades desde 30 segundos hasta 1 día.

Loot
indicator("POC и зона стоимости", overlay = true)
[vaLow, vaHigh] = cluster.value_area(0.7)
plot(cluster.poc, "POC", color = color.orange, style = plot.style_circles)
plot(vaHigh, "Верх зоны", color = color.gray, style = plot.style_linebr)
plot(vaLow, "Низ зоны", color = color.gray, style = plot.style_linebr)

Delta: delta.*

La diferencia entre compras agresivas y ventas agresivas en la barra. Los volúmenes están en monedas (la divisa base).

Nombre Qué devuelve
delta.value Delta de la barra: compras menos ventas
delta.buy, delta.sell Esas dos partes por separado
delta.cum Delta acumulada desde el inicio de la historia cargada
delta.min, delta.max Mínima y máxima de la delta dinámica dentro de la barra
delta.open, delta.high, delta.low, delta.close Delta de la barra en formato vela
delta.trades Número de operaciones en la barra
delta.usd Delta en la moneda cotizada, por sumas de las propias operaciones
delta.available Si hay delta en esta barra

delta.min y delta.max no se pueden deducir de los clústeres — indican el recorrido de la delta dentro de la barra y las calcula el servidor. Muestran, por ejemplo, que los compradores llevaron la barra y luego fue cerrada por vendedores. delta.usd es más preciso que delta.value * close: en barras volátiles el precio de las operaciones difiere mucho del precio de cierre.

delta.cum empieza en cero en la primera barra cargada, por lo que su nivel depende de la profundidad de la historia cargada. Compara cambios, no valores absolutos.

La delta está disponible en temporalidades desde 30 segundos.

Loot
indicator("Дельта и разворот внутри бара", overlay = false)
d = delta.value
reversed = delta.available and d < 0 and delta.max > -d
plot(d, "Дельта", style = plot.style_columns, color = d >= 0 ? color.teal : color.red)
plotshape(reversed, "Разворот", style = shape.xcross, location = location.top, color = color.orange, size = size.tiny)

Interés abierto: oi.*

Nombre Qué devuelve
oi.open, oi.high, oi.low, oi.close Interés abierto por barra en las unidades que publica el exchange
oi.coins Interés abierto en monedas
oi.usd Interés abierto en la moneda cotizada
oi.change Cambio de oi.close respecto a la barra anterior
oi.available Si hay datos en esta barra

Las unidades de oi.open…oi.close varían entre exchanges; para comparar exchanges usa oi.coins u oi.usd. El interés abierto llega en una rejilla de minutos: en temporalidades en segundos todos los valores son na.

Loot
indicator("Цена и открытый интерес", overlay = false)
dp = ta.change(close)
build = oi.available and dp > 0 and oi.change > 0
plot(oi.change, "Изменение OI", style = plot.style_columns, color = build ? color.teal : color.gray)

Tasa de financiación: funding.*

Nombre Qué devuelve
funding.rate Pronóstico de la tasa para el próximo cálculo
funding.interval_hours Horas entre cálculos
funding.settled true en la barra donde se hizo el cálculo
funding.settled_rate Tasa efectivamente debitada en esa barra; si hay varios cálculos en la barra — su suma
funding.cum Suma de tasas debitadas en la historia cargada
funding.available Si el instrumento tiene tasa de financiación

La tasa es una fracción, no porcentajes: 0.0001 = 0.01 %. El gráfico la muestra en porcentajes; el lenguaje no la reescala. Para comprobar hipótesis en la historia usa funding.settled_rate: funding.rate es un pronóstico que puede cambiar hasta el mismo cálculo. El spot no tiene funding; en temporalidades en segundos los valores son na.

Loot
indicator("Фандинг за расчёт, %", overlay = false)
plot(funding.rate * 100, "Прогноз ставки", style = plot.style_area, color = funding.rate >= 0 ? color.teal : color.red)
plotshape(funding.settled, "Расчёт", style = shape.circle, location = location.bottom, color = color.orange, size = size.tiny)

Historial del libro de órdenes: depth.*

El libro de órdenes tal como lo grabó el servidor — los mismos datos que dibuja el mapa de calor — desglosado por barras. A diferencia del book.* en vivo, estos valores existen en cada barra grabada. Los precios se agrupan en cestas; el volumen de la cesta es el mayor volumen que estuvo en esa cesta durante la barra, en monedas.

Nombre Qué devuelve
depth.available Si el libro está grabado para esa barra
depth.levels Número de cestas no vacías en la barra
depth.price(i) Límite inferior de la cesta i, en orden ascendente
depth.qty(i) Mayor volumen que estuvo en la cesta durante la barra
depth.side(i) +1 bids, -1 asks, 0 cesta estuvo en ambas caras
depth.at(price) Volumen en la cesta donde cae el precio
depth.grid_step Tamaño de la cesta en unidades de precio
depth.best_bid, depth.best_ask Mejores precios al final de la barra
depth.max_cell Volumen de la cesta más pesada
depth.bid_sum(pct), depth.ask_sum(pct) Volumen del lado dentro de pct % desde el centro
depth.imbalance(pct) Desbalance en la misma banda: de -1 a +1
depth.max_bid(pct), depth.max_ask(pct) Precio y volumen de la cesta más pesada del lado dentro de la banda

Limitaciones:

  • Los datos están donde está la mapa de calor del servidor, y en temporalidades desde un segundo.
  • El servidor guarda una banda de aproximadamente ±4 % respecto al precio. Fuera de ella depth.at devuelve na; dentro de la banda una cesta vacía devuelve 0.
  • La profundidad histórica es limitada: las barras más antiguas de una historia larga devuelven na.
  • Los valores de la barra en formación cambian mientras llegan datos.
Loot
indicator("Перекос записанного стакана", overlay = false)
band = input.float(1.0, "Полоса, % от цены", minval = 0.1, maxval = 4.0, step = 0.1)
imb = depth.imbalance(band)
plot(imb, "Перекос", style = plot.style_columns, color = imb >= 0 ? color.teal : color.red)

Para dibujar el libro grabado bajo las velas basta una sola línea heatmap.depth() en el script con overlay = true. Colores y umbrales están en la página Настройки и отрисовка.

Loot
indicator("Записанный стакан теплом", overlay = true)
heatmap.config(palette = heatmap.inferno, low = 25)
heatmap.depth()

Libro de órdenes en vivo y cinta: book.* y tape.*

El libro de órdenes en vivo y la cinta no los graba nadie, por eso los valores existen solo en la última barra, y en la historia siempre son na. Requieren tener abierta la panel del libro de órdenes del mismo instrumento: de lo contrario book.available y tape.available son falsos, y en la leyenda aparece “no hay libro de órdenes abierto”. En modo repetición estos datos no están disponibles.

Nombre Qué devuelve
book.bid(i), book.ask(i) Precio del nivel i; 0 — mejor precio
book.bid_qty(i), book.ask_qty(i) Volumen en el nivel, en monedas
book.spread Mejor ask menos mejor bid
book.mid Punto medio entre los mejores precios
book.imbalance(n) Desbalance de volumen en los n niveles superiores de cada lado: de -1 a +1
book.available Si hay snapshot del libro
tape.last_price, tape.last_qty Precio y volumen de la última operación
tape.last_side +1 comprador agresor, -1 vendedor, 0 — aún no hubo operaciones
tape.count(ms) Número de operaciones en los últimos ms milisegundos
tape.buy_volume(ms), tape.sell_volume(ms) Volumen de compras y ventas agresivas en la ventana
tape.max_print(ms) Operación más grande en la ventana
tape.available Si la cinta está conectada

La ventana de la cinta y la profundidad de book.imbalance se fijan con un número en el código o con la opción input.int. La ventana se cuenta desde la hora de la última operación en el exchange, no desde el reloj del equipo. El script solo tiene acceso al tail de la cinta —unas dos mil últimas operaciones—, por lo que en mercados muy activos una ventana larga no mostrará todo el intervalo.

Cuando un valor así se pasa a plot, el editor avisa: “Los datos sólo están en tiempo real — en el historial la serie está vacía”. Es esperado: a la izquierda de la última barra la serie está vacía. Las estrategias no pueden leer estos datos — véase Стратегии и тестер.

Loot
indicator("Перекос стакана", overlay = false)
levels = input.int(20, "Уровней с каждой стороны", minval = 1, maxval = 200)
imb = book.available ? book.imbalance(levels) : na
plot(imb, "Перекос", style = plot.style_area, color = imb >= 0 ? color.teal : color.red)
hline(0, "Ноль", color = color.gray)

Screener: screener.*

Las métricas del screener para el instrumento del gráfico son los mismos números que aparecen en sus columnas. No tienen historia: el valor existe solo en la última barra. La ventana se pasa como cadena, y no todas las métricas aceptan todas las ventanas.

Función Qué muestra Ventanas
screener.change(w) Cambio de precio "1m" "5m" "15m" "1h" "24h"
screener.vol(w) Volumen "1m" "5m" "15m" "1h" "24h"
screener.avg_vol(w) Volumen promedio "1m" "5m" "15m" "1h"
screener.rvol(w) Volumen relativo "1h" "24h"
screener.natr(w) NATR "1m" "5m"
screener.oi_delta(w) Cambio del interés abierto "1m" "5m" "1h" "24h"
screener.btc_corr(w) Correlación con BTC "1m" "5m"
screener.available Si el instrumento está cubierto por el screener —

Una ventana no listada en la tabla da na. Una métrica que no entra en tu suscripción al screener también es na. El editor marca la salida de estos valores con la misma advertencia que para el libro: en la historia la serie está vacía.

Loot
indicator("Скринер: RVOL и NATR", overlay = false)
plot(screener.rvol("1h"), "RVOL 1h", color = color.orange)
plot(screener.natr("5m"), "NATR 5m", color = color.teal)

Cobertura por exchange

Exchange Clústeres y delta Interés abierto y tasa de financiación
Binance, Bybit, OKX, Bitget, Gate.io, MEXC, KuCoin, BingX, AsterDEX spot y futuros Futuros
Hyperliquid Futuros; spot — no Futuros
Binance Alpha No: el exchange no publica el lado agresor No
Upbit No No
Datos Temporalidades
Clústeres De 30 segundos a 1 día
Delta Desde 30 segundos
Interés abierto, tasa de financiación Desde 1 minuto
Historial del libro de órdenes Desde 1 segundo, donde esté la mapa de calor del servidor
Libro en vivo, cinta Cualquier temporalidad, si está abierto el panel del libro
Screener Cualquier temporalidad, para instrumentos que el screener ve

La cobertura la determina el servidor de datos y puede cambiar. Es más seguro fiarse de la bandera .available y de la indicación en la leyenda.

Otra temporalidad y otro instrumento

request.security evalúa una expresión en otra serie — una temporalidad superior o otra moneda — y alinea el resultado con las barras del gráfico.

TEXT
request.security(symbol, timeframe, expression, gaps = false, lookahead = false, ignore_invalid_symbol = false)
  • symbol — en formato «EXCHANGE:Ticker», como en TradingView: "BINANCE:BTCUSDT.P", donde .P es el futuro perpetuo. El instrumento del gráfico es sym.ticker.
  • timeframe — cadena tipo "5", "60", "4h", "1D", "1W". La temporalidad del gráfico es tf.period.
  • expression — un número o varios números entre corchetes: [high, low].

Sin adelantarse al cierre. Por defecto la barra del gráfico ve el valor del último cierre de la barra superior. Por eso una EMA horaria en 5 minutos es en escalón que solo se mueve al cierre de la hora. Así el resultado en historia coincide con lo que habrías visto en vivo.

  • gaps = true — el valor solo está en la primera barra del gráfico donde aparece la barra superior nueva; después na.
  • ignore_invalid_symbol = true — un símbolo desconocido da na. Sin esto el script falla con error “Символ … неизвестен”.

Dentro de la expresión están disponibles las velas de la otra serie y los cálculos sobre ellas. No puedes pasar la variable del gráfico allí — solo los valores de input.*. El libro, la cinta y el screener no compilan dentro de la petición; clústeres, delta, interés abierto y funding de la otra serie devuelven na. Un script puede pedir hasta 8 pares “instrumento + temporalidad” distintos y hasta 32 llamadas a request.security.

Loot
indicator("EMA старшего таймфрейма", overlay = true)
len = input.int(20, "Длина EMA", minval = 2, maxval = 500)
tfHigh = input.timeframe("60", "Старший таймфрейм")
emaHigh = request.security(sym.ticker, tfHigh, ta.ema(close, len))
plot(emaHigh, "EMA", color = color.orange, style = plot.style_stepline)
Loot
indicator("Спред к другой бирже", overlay = false)
other = input.symbol("BYBIT:BTCUSDT.P", "Сравнить с")
px = request.security(other, tf.period, close, ignore_invalid_symbol = true)
plot(close - px, "Разница", color = color.orange)

Siguientes lecturas

https://docs.lootx.trade/es/loot/market-data

Основы

7Estrategias y Probador de estrategias

Cómo escribir una estrategia en LootScript y probarla sobre el historial en el probador: declaración strategy(), órdenes, modelo de ejecución, costes, pestañas del informe y limitaciones del backtest.

Una estrategia es un script que, además de dibujar líneas en el gráfico, envía órdenes. Las órdenes no las ejecuta un exchange real sino un simulador dentro del terminal: ejecuta la estrategia sobre el historial del gráfico con comisiones, deslizamiento y tasa de financiación, y muestra el resultado en la ventana Probador de estrategias.

Declaración strategy()

La primera línea diferencia una estrategia de un indicador: strategy(...) en lugar de indicator(...). Todo lo demás —ajustes, renderizado, datos de mercado— funciona igual. Las funciones strategy.* en un indicador no se compilan: “strategy.* disponible solo en strategy(…)”.

Parámetro Por defecto Qué establece
initialCapital 10000 Capital inicial
defaultQtyType, defaultQtyValue strategy.qty.fixed, 1 Tamaño de la orden si no se especifica qty
commissionType, commissionValue porcentaje, no definido Comisión: strategy.commission.percent — porcentaje sobre el volumen (0.05 = 0,05 %), strategy.commission.cash_per_contract — importe por unidad de cantidad, strategy.commission.cash_per_order — importe por ejecución
slippageTicks 0 Deslizamiento en ticks
pyramiding 0 Cuántas entradas en una misma dirección pueden estar abiertas; 0 — una sola
positionModel strategy.model.netting Una posición agregada o posiciones separadas long/short (strategy.model.hedging)
processOrdersOnClose false Ejecutar órdenes de mercado al cierre de la vela actual
calcOnEveryTick false Permitir órdenes en la vela en formación
marginLong, marginShort, leverage 0, 0, 1 Margen en porcentaje o apalancamiento; con 0 la liquidación no se modela
applyFunding true Tener en cuenta la tasa de financiación
fillModel strategy.fill.conservative Suposición sobre el recorrido del precio dentro de la vela

Los valores de parámetros solo pueden ser números y constantes literales. Una expresión o input.* en la declaración es un error de compilación. El parámetro calcOnOrderFills es aceptado, pero en esta versión no tiene efecto: en la pestaña “Propiedades” del probador aparece marcado como “no actúa en esta build”.

El tamaño de la orden cuando qty = na lo define defaultQtyType:

Tipo Qué significa defaultQtyValue
strategy.qty.fixed Cantidad en monedas (moneda base)
strategy.qty.cash Importe en la moneda cotizada
strategy.qty.percent_of_equity Porcentaje del capital actual
strategy.qty.risk_percent Porcentaje del capital que arriesgas hasta un stop protector

Para strategy.qty.risk_percent se necesita un strategy.exit con stop (loss o stop); de lo contrario el compilador aborta: “requiere un stop respecto al cual calcular el tamaño”. La cantidad se redondea hacia abajo al paso de cantidad del instrumento. Si tras redondear queda cero, la orden se rechaza y se cuenta en el probador como “Rechazadas (por tamaño)”.

Órdenes

Función Qué hace
strategy.entry(id, direction, qty, limit, stop, …) Abre o gira una posición. Respeta el modelo de posición y pyramiding
strategy.order(id, direction, qty, limit, stop, …) Igual pero sin respetar el modelo de posición ni pyramiding
strategy.exit(id, from_entry, qty, qty_percent, profit, limit, loss, stop, trail_price, trail_points, trail_offset, …) Coloca la salida —take, stop o trailing— para una entrada abierta
strategy.close(id, comment, qty, qty_percent) Cierra la entrada con una orden de mercado
strategy.close_all(comment) Cierra todo
strategy.cancel(id), strategy.cancel_all() Elimina órdenes aún no ejecutadas

La dirección — strategy.long o strategy.short. Todas las funciones admiten el opcional when: when = false evita la ejecución. Entradas, salidas y cierres admiten además comment — etiqueta de texto para la orden.

  • Tipo de entrada. Sin limit ni stop — orden de mercado; con limit — orden límite; con stop — orden stop; con ambos — stop-limit. Un strategy.entry repetido con el mismo id reemplaza la orden pendiente.
  • Giro. En el modelo netting una entrada en la dirección opuesta cierra la posición actual y abre la nueva en una sola acción.
  • Unidades de salida. profit y loss — en ticks desde el precio de entrada; limit y stop — precios absolutos. El trailing se define con el par: trail_offset más trail_price o trail_points.
  • Un strategy.exit sin niveles no hace nada. El compilador avisará: “strategy.exit sin ningún nivel (profit/loss/stop/limit/trail) — operación vacía”.
  • Mover el stop. Un strategy.exit repetido con el mismo id reemplaza la salida — así se mueve el stop.

El estado de la estrategia se lee por filas: strategy.position_size (con signo, short es negativo), strategy.position_avg_price, strategy.equity, strategy.netprofit, strategy.openprofit, strategy.opentrades, strategy.closedtrades, strategy.funding_paid y más — la lista completa está en el referente.

Cómo el probador ejecuta las órdenes

Una orden enviada en una vela se ejecuta no antes de la siguiente vela. La decisión se toma al cierre de la vela, y ejecutarla al mismo precio implicaría mirar hacia adelante.

Orden Ejecución
Mercado En la apertura de la siguiente vela más el deslizamiento. Con processOrdersOnClose = true — al cierre de la vela actual
Límite Cuando el precio pasa el límite, al precio límite. Si la vela abrió más allá del límite — en la apertura
Stop Cuando el precio pasa el stop, al precio del stop más deslizamiento. En caso de gap — en la apertura más deslizamiento

Recorrido del precio dentro de la vela. El probador no conoce el recorrido real del precio dentro de la vela y lo asume. El modelo strategy.fill.conservative (por defecto) considera que el precio primero fue al peor extremo: en una vela alcista — apertura → mínimo → máximo → cierre; en una bajista — al revés. Si en una sola vela están stop y take, se dispara el stop. El modelo strategy.fill.optimistic asume lo contrario — sirve solo para comparar. En esta versión no hay reejecución sobre marcos menores: en la columna «Ruta» cada operación se marca como supuesta por el modelo.

Costes.

  • Comisión. Si commissionValue no está definido, el probador usa la tarifa por defecto: 0,02 % en ejecuciones límite y 0,05 % en órdenes de mercado y stop. La tarifa de tu cuenta y los rebates al terminal son desconocidos. Un valor especificado se aplica a todas las ejecuciones.
  • Deslizamiento — slippageTicks en tu contra en ejecuciones de mercado y stop. Las órdenes límite no deslizan.
  • Tasa de financiación se descuenta en cada liquidación real del exchange — a la tasa real y al precio de cierre de la vela de cálculo. Para ello se requieren datos de financiación: futuros de exchanges desde la tabla de cobertura.
  • Margen. Con marginLong/marginShort o apalancamiento > 1 el probador modela un margen aislado simplificado. Una posición larga se liquida en precio entrada × (1 − m/2), la corta en entrada × (1 + m/2), donde m es la fracción del margen inicial. Una operación liquidada pierde todo el margen inicial.

Las operaciones no cerradas al final del historial se cierran al cierre de la última vela por la razón “fin de datos”.

Probador de estrategias

Añada la estrategia al gráfico

En el Editor pulse Añadir al gráfico (Ctrl+Enter). Un script con errores no se añadirá al gráfico.

Abra el probador

En la barra de herramientas del Editor pulse Probador de estrategias… — el botón está activo solo para scripts con strategy(...). Otra vía: desde los ajustes de la estrategia en la leyenda del gráfico (engranaje), botón Probador de estrategias….

Espere a que termine el proceso

El probador calcula sobre las velas cargadas en el gráfico. Mientras no haya velas, la ventana muestra “La estrategia aún no se ha calculado: espere a la carga de velas”. Cuando llegan nuevas velas, el resultado se recalcula automáticamente; el botón Recalcular lanza un recorrido completo manualmente.

Si hay varias estrategias en el gráfico, puedes seleccionar la que quieras directamente en la ventana del probador.

Pestaña Qué contiene
Resumen Baldosas “Beneficio neto”, “Profit factor”, “Máx. drawdown (por cierres)”, “Porcentaje ganadoras”, “SQN”; franja “Qué no conoce este backtest”; curvas de capital, “comprar y mantener”, capital sin tasa de financiación y dos drawdowns
Métricas Resultado, riesgo (drawdown por cierres y dentro de vela por separado, Sharpe, Sortino, Calmar), operaciones (porcentaje ganadoras, medias y mayores, rachas), costes (comisión y tasa de financiación)
Operaciones Tabla de operaciones: entrada, salida, motivo, volumen, P&L, run-up, drawdown, comisión, financiación. Clic en la fila centra el gráfico en la vela de entrada; Ctrl+C copia las filas seleccionadas
Propiedades Parámetros de la declaración, rango de velas, paso de precio, paso de cantidad, lote mínimo, comisión, contadores del proceso: órdenes rechazadas, saltadas por pyramiding, liquidaciones, cálculos de financiación

En el título de la ventana — etiquetas de modo: conservative o optimistic por el modelo de ejecución y close-fill si processOrdersOnClose = true. Las etiquetas optimistic y close-fill indican que el resultado en vivo probablemente será peor.

Qué no puede leer la estrategia

Libro de órdenes en vivo y cinta de operaciones. Una estrategia que lea book.* o tape.* no se compila: “La estrategia lee … el libro y la cinta no tienen historial, el backtest sería ficticio”. Para historial del libro existe depth.*, para operaciones — delta.* y cluster.*.

Screener. screener.* también existe solo en la última vela, pero el compilador permite compilar esa estrategia. En el historial los valores del screener son na, por eso las condiciones con ellos no se cumplen y no habrá operaciones basadas en ellos en el informe.

Mirar hacia adelante. request.security(..., lookahead = true) en una estrategia muestra en el editor la advertencia “La estrategia mira hacia adelante … el informe está marcado como inalcanzable en tiempo real”. Trata ese informe como optimista: en el historial la estrategia ve valores que en vivo todavía no existirían. Más detalles en la sección de Datos de mercado.

Ejemplo

Ruptura de canal con confirmación por delta. Entrada — al cierre fuera del canal de los últimos len velas, si la delta de la vela coincide. Stop en ATR, take al doble.

Loot
strategy("Пробой канала с дельтой", overlay = true,
         initialCapital = 10000,
         defaultQtyType = strategy.qty.percent_of_equity, defaultQtyValue = 20,
         commissionValue = 0.05, slippageTicks = 2)

len      = input.int(20, "Канал, баров", minval = 5, maxval = 200)
stopAtr  = input.float(1.5, "Стоп, ATR", minval = 0.5, maxval = 10, step = 0.1)
needFlow = input.bool(true, "Подтверждать дельтой")

upper = ta.highest(high, len)[1]
lower = ta.lowest(low, len)[1]
atr   = ta.atr(14)

flowLong  = not needFlow or (delta.available and delta.value > 0)
flowShort = not needFlow or (delta.available and delta.value < 0)

if close > upper and flowLong and strategy.position_size <= 0 {
    strategy.entry("L", strategy.long, comment = "пробой вверх")
}
if close < lower and flowShort and strategy.position_size >= 0 {
    strategy.entry("S", strategy.short, comment = "пробой вниз")
}

stopTicks = math.round(atr * stopAtr / sym.tick_size)
strategy.exit("L-x", from_entry = "L", loss = stopTicks, profit = stopTicks * 2)
strategy.exit("S-x", from_entry = "S", loss = stopTicks, profit = stopTicks * 2)

plot(upper, "Верх канала", color = color.teal)
plot(lower, "Низ канала", color = color.red)

En un exchange sin delta (por ejemplo, Binance Alpha) con la opción “Confirmar por delta” activada la estrategia no realizará ninguna operación: delta.available allí es falso. Esto es la regla na en acción, no un error.

Limitaciones

  • Solo simulación: no hay órdenes reales.
  • Las órdenes límite se ejecutan como si fueras el primero en la cola. Para estrategias maker esto es la principal causa de resultados inflados.
  • Tus operaciones no mueven el precio; no hay ejecuciones parciales: una orden se ejecuta entera o no se ejecuta.
  • El recorrido del precio dentro de la vela se asume por un modelo, no se extrae de un timeframe menor.
  • La liquidación está simplificada: no se modelan el motor de liquidaciones del exchange, ADL ni el fondo de seguros.
  • La comisión es la tarifa por defecto, no la de tu cuenta.
  • Falta de datos no es falta de movimiento: una vela sin clústeres igualmente tuvo movimiento.
  • El resultado depende de cuánto historial esté cargado en el gráfico.

Dónde seguir

https://docs.lootx.trade/es/loot/strategies

Основы

8Alertas desde scripts

Cómo un script en LootScript notifica que se cumplió una condición: alert() y alertcondition(), frecuencia, activación de condiciones, adónde llega la notificación y qué no ofrecen las alertas desde scripts.

Un script puede notificarte de que en el mercado en vivo se cumplió una condición: ruptura de un nivel, un pico de delta, cruce de líneas. Para eso en LootScript hay dos funciones — alert(), que el script llama por sí mismo, y alertcondition(), una condición que activas manualmente.

La activación pasa por el mismo flujo que las demás notificaciones del terminal: registro en la pestaña Alertas, sonido, etiqueta emergente. Todo eso se procesa localmente en tu equipo: las alertas funcionan mientras el terminal esté en ejecución y el script esté en el gráfico.

Dos maneras

alert() alertcondition()
Quién decide si debe sonar Código del script Tú: debes activar la condición
Cuándo suena Según la frecuencia elegida, incluida en una vela sin cerrar Solo al cierre de la vela, no más de una vez por vela
Texto Cualquier cadena; puedes ensamblarla con números Texto fijo en el código
Dónde se activa Siempre, mientras el script esté en el gráfico Con la casilla en la consola del editor

Si la alerta debe sonar siempre, usa alert(). Si el script declara varias señales y solo algunas deben sonar, decláralas con alertcondition() y activa las que necesites.

alert(): alerta desde el código

TEXT
alert(message, freq = alert.freq_once_per_bar_close)

message — cadena. Los números se insertan con str.tostring: "Цена " + str.tostring(close). El texto llega en la notificación tal cual; el terminal no lo traduce ni lo corrige.

La frecuencia se fija con la constante:

Frecuencia Cuándo suena
alert.freq_once_per_bar_close Por defecto. Una vez, cuando la vela cerró: en la primera actualización de la vela siguiente, con los valores de la vela cerrada
alert.freq_once_per_bar En el primer momento en que la llamada se ejecutó en esa vela — incluso si la vela aún se está formando. Luego guarda silencio hasta la siguiente vela
alert.freq_all En cada recálculo de la vela en vivo donde se ejecutó la llamada

La frecuencia se evalúa por cada llamada a alert() por separado: dos llamadas en un mismo script no se silencian entre sí. En un recálculo el script no envía más de 16 alertas; las restantes se descartan.

Ejemplo: alerta por un pico de delta, en cuanto aparece en la vela que se está formando.

Loot
indicator("Всплеск дельты", overlay = false)
mult = input.float(3.0, "Во сколько раз больше обычного", minval = 1.5, step = 0.5)
base = ta.sma(math.abs(delta.value), 50)
spike = delta.available and math.abs(delta.value) > base * mult
plot(delta.value, "Дельта", style = plot.style_columns, color = delta.value >= 0 ? color.teal : color.red)
if spike {
    alert("Всплеск дельты: " + str.tostring(delta.value, "#.##"), freq = alert.freq_once_per_bar)
}

Donde no hay delta, delta.available es falso y la alerta guarda silencio — más detalles sobre la regla na en la sección Datos de mercado.

alertcondition(): condición que activas tú

TEXT
alertcondition(condition, title, message)

condition — expresión booleana, title — nombre de la condición, message — texto de la notificación. title y message son cadenas literales en el código; no puedes construirlas a partir de números. Si no hay message, en la notificación irá title.

La condición suena solo al cierre de la vela, no más de una vez por vela y solo si está activada. Por defecto todas las condiciones están desactivadas.

Añade el script al gráfico

En el Editor de scripts haz clic en Añadir al gráfico.

Abre la pestaña «Salida»

En la consola bajo el código selecciona la pestaña Salida. Allí se muestran los valores de las series en la última vela y la lista «Condiciones de alertas (alertcondition) — activa las que necesites».

Activa las condiciones

Marca las casillas de las condiciones por las que quieras recibir notificaciones. Si el script está en varios gráficos, cada uno tiene su propia lista.

El historial no genera alertas

Las alertas suenan solo en actualizaciones en vivo. El primer cálculo tras cargar el gráfico, tras cambiar de instrumento o tras cargar historial más antiguo se considera historia: sobre velas pasadas ni alert() ni alertcondition() se disparan. Por eso, al añadir un script al gráfico no recibirás una oleada de notificaciones por el pasado.

Puedes comprobar la condición sobre el historial visualmente: dibuja su marca con plotshape — señalará cada vela donde la alerta se habría disparado.

Adónde llega la alerta

Cada activación:

  • Se registra en la pestaña «Alertas» con la fuente «Alerta de script». En la entrada aparecen el texto del mensaje, el nombre del script y, para alertcondition(), el nombre de la condición. La lista se abre en una ventana separada o panel del espacio de trabajo; el filtro Fuentes deja solo las alertas de script.
  • Reproduce un sonido. Se selecciona en Ajustes → Alertas, bloque «Sonidos», línea «Alerta de script»: lista de sonidos y un interruptor que silencia el sonido.
  • Muestra una etiqueta «Nombre del script: texto».
  • Resalta la pestaña del espacio de trabajo donde está el gráfico con el script.

Las demás notificaciones del terminal se describen en la página Alertas y niveles.

Registro: log.*

Para depurar condiciones hay un registro. log.info, log.warning y log.error escriben una línea en la pestaña Registro de la consola del editor — la misma donde están Problemas y Salida.

  • El registro, como las alertas, solo se escribe en actualizaciones en vivo — en el historial guarda silencio.
  • Por vela — no más de 16 líneas; las restantes se descartan.
  • La consola guarda las últimas 256 líneas. Las más antiguas se expulsan; su número se muestra como «filas desplazadas». El botón Limpiar borra el registro.
Loot
indicator("Проверка условия", overlay = true)
len = input.int(20, "Канал, баров", minval = 2, maxval = 500)
upper = ta.highest(high, len)[1]
plot(upper, "Верх канала", color = color.teal)
if barstate.islast {
    log.info("Закрытие " + str.tostring(close) + ", верх канала " + str.tostring(upper))
}

Ejemplo: ruptura del canal

El script dibuja el límite superior del canal, marca las rupturas con un triángulo y las notifica de dos maneras: alert() suena siempre, y la condición «Ruptura al alza» solo si la activas.

Loot
indicator("Пробой канала с алертом", overlay = true)
len = input.int(20, "Канал, баров", minval = 2, maxval = 500)
upper = ta.highest(high, len)[1]
breakUp = ta.crossover(close, upper)
plot(upper, "Верх канала", color = color.teal)
plotshape(breakUp, "Пробой", style = shape.triangleup, location = location.belowbar, color = color.teal, size = size.small)
if breakUp {
    alert("Пробой вверх, цена " + str.tostring(close), alert.freq_once_per_bar_close)
}
alertcondition(breakUp, "Пробой вверх", "Цена закрылась выше канала")

El límite se toma con un desplazamiento [1] — sobre velas previas; de lo contrario el máximo actual siempre estaría dentro del canal. La frecuencia freq_once_per_bar_close significa que la alerta llegará tras el cierre de la vela por encima del canal, y el triángulo en el gráfico quedará exactamente donde sonó la alerta. En un script real normalmente se deja uno de los dos métodos — aquí están ambos para comparar.

Siguiente lectura

https://docs.lootx.trade/es/loot/alerts

Основы

9Asistente IA en el Editor

Chat con un modelo IA en el Editor de LootScript: escribe y corrige scripts, los prueba en velas reales y responde sobre el mercado. Qué proveedores hay, dónde pegar la clave y qué sale del equipo.

En el Editor de LootScript hay un chat con un modelo IA. Describa con palabras qué indicador necesita: el asistente escribirá el código directamente en el editor, lo compilará, lo ejecutará sobre velas reales y explicará el resultado. También corrige scripts ya hechos, aclara código ajeno y responde preguntas del mercado usando los datos del terminal.

Usted elige el modelo: en la nube —con su propia API key— o local —en su propio equipo. Las solicitudes van desde el terminal directamente al proveedor elegido, sin pasar por servidores de LootX.

Cómo abrir el asistente

  1. Pulse ƒ en la barra del gráfico —se abrirá la ventana Indicadores.
  2. Pulse Editor… junto a la barra de búsqueda o abra su script.
  3. En la barra superior del editor, junto a Añadir al gráfico, pulse Asistente.

El chat se colocará a la derecha del código. Puede ajustar el ancho arrastrando el separador. La cruz en la cabecera del chat (Ocultar chat) lo cierra sin borrar la conversación; volver a pulsar Asistente lo restaura.

Conexión del modelo

Abra la tarjeta de conexión

La primera vez que haga una pregunta la tarjeta se abrirá sola. Después podrá abrirla con el engranaje Clave y conexión en la cabecera del chat.

Elija proveedor

La lista está en la tabla abajo. Por defecto está seleccionado Claude.

Pegue la API key

Debajo del campo hay un enlace Obtener clave en … —lleva al panel del proveedor. La clave guardada no se muestra: déjelo vacío para no cambiarla, o pulse Eliminar clave.

Verifique el modelo y guarde

El campo Modelo viene con un valor por defecto; en las sugerencias hay otros. Puede escribir cualquier nombre que conozca el proveedor. Pulse Guardar.

Proveedor Qué se necesita
Claude API key de Anthropic. La suscripción de Claude no sirve — Anthropic prohíbe que programas de terceros la usen.
Gemini API key de Google. La suscripción de Gemini no sirve por la misma razón.
OpenAI, DeepSeek, Grok, Mistral, Qwen, Kimi, GLM, Groq API key del proveedor.
OpenRouter API key de OpenRouter: a través de él están disponibles modelos de distintas compañías.
Ollama, LM Studio No se necesita clave: el modelo funciona en su equipo. Arranque el servidor, cargue el modelo y escriba su nombre.
Compatible con OpenAI Cualquier servidor con API en formato OpenAI Chat Completions: gateway, vLLM, proxy corporativo. Indique la dirección (suele terminar en /v1), el modelo y la clave, si el servidor la requiere.

Las solicitudes en la nube se facturan según la tarifa de su cuenta con el proveedor, por separado de LootX. Después de cada respuesta en el chat se muestra cuántos tokens se consumieron en entrada y en salida.

Un modelo local necesita soporte de tool calling. Sin él el asistente no podrá escribir en el editor ni comprobar código.

Proxy y su propia dirección

Si el servicio del proveedor no es accesible directamente desde su red, indique un proxy en el campo Proxy — http://host:port o socks5://usuario:contraseña@host:port. El proxy es común para todos los proveedores. El campo Dirección API (para su gateway) se usa solo si accede al proveedor a través de su propio gateway.

Qué puede hacer el asistente

  • Escribe un script nuevo según su descripción y coloca el código en el editor.
  • Corrige uno existente —de forma puntual, sin reescribir todo el archivo.
  • Se prueba a sí mismo. Compila el código y lo ejecuta sobre velas reales —por defecto en el instrumento y la temporalidad del gráfico, hasta 5000 barras anteriores; a petición, en cualquier otra. Verifica resultados fila por fila y busca errores de ejecución.
  • Añade el script al gráfico cuando lo pida.
  • Responde sobre el mercado. Toma velas de cualquier instrumento del terminal, métricas del screener (volatilidad, volumen, interés abierto, tasa de financiación, spread) y ordena el mercado: «¿Qué contratos de futuros son ahora los más volátiles?».
  • Consulta la referencia del lenguaje, revisa los indicadores integrados y los scripts de su biblioteca.

Cada paso aparece en la cinta como una línea: «Compilando», «Ejecutando sobre velas», «Corrigiendo código». Si el modelo muestra su razonamiento, este queda plegado en el bloque Razonamiento. Puede interrumpir la respuesta con el botón Detener.

Todo lo que el asistente escribe en el editor se deshace con el habitual Ctrl+Z. Si el código viene como bloque, en su cabecera aparecen botones. Para un script completo está Al editor —reemplaza el código en el editor; para un fragmento está Insertar en la posición del cursor. Ambos tienen Copiar.

Comandos rápidos

Escriba / en el campo de entrada —aparecerá la ayuda. Los mismos comandos están también como botones en un chat vacío. El texto tras el comando es su aclaración: /fix mire el volumen.

Команда Что делает
/fix Encuentra y corrige errores: compila, ejecuta sobre velas, repara errores y filas con na. Conserva su intención y estilo; al final enumera los cambios.
/explain Explica en palabras sencillas qué calcula el script, qué efecto tiene cada ajuste, qué dibuja y cómo leer las señales. No cambia el código.
/optimize Acelera el script sin cambiar resultados: sustituye loops caseros por funciones integradas, elimina trabajo innecesario y verifica con una ejecución que los valores no cambiaron.

Otra palabra tras la barra se envía al modelo como una pregunta normal.

Imágenes y capturas del gráfico

Puede adjuntar una imagen a la pregunta: con el clip bajo el campo de entrada, pegando desde el portapapeles (Ctrl+V) o arrastrando el archivo al chat. El botón con el icono de gráfico junto al clip adjunta una captura del mismo panel donde se añadirá el script. En una sola pregunta puede adjuntar hasta seis imágenes. Antes de enviar, las imágenes grandes se reducen.

No todos los modelos procesan imágenes. Si el modelo elegido no soporta imágenes, el chat mostrará un aviso antes de enviar. Si el terminal no sabe si el modelo ve imágenes y el proveedor rechaza la pregunta, las imágenes volverán al campo de entrada.

Historial de conversaciones

La conversación está ligada al script. Abra otro script —verá la conversación asociada a él. Cierre el editor o reinicie el terminal —la conversación permanecerá.

  • En un script nuevo sin guardar la conversación no se escribe en disco. Se guardará junto al script cuando pulse Guardar por primera vez.
  • El icono Nuevo chat en la cabecera inicia una conversación nueva y borra la anterior del disco.
  • Si borra el script, se borra también su conversación.
  • Mientras el asistente responde no puede abrir otro script: primero detenga la respuesta.

Toda la conversación se envía al modelo con cada pregunta, por eso un chat largo encarece las consultas. El tamaño de la conversación en tokens se muestra con un número en la cabecera del chat, por ejemplo «42k». Pulse sobre él para comprimir la conversación en un resumen: a partir de entonces el asistente la recordará por ese resumen. El terminal pliega los resultados de ejecuciones antiguas y las imágenes. En el historial guardado, las imágenes antiguas se sustituirán con el tiempo por la nota «La imagen de esta pregunta ya no se almacena».

Qué sale del equipo

Al proveedor elegido, directamente:

  • sus mensajes y las imágenes adjuntas;
  • el nombre del script, número de líneas y errores, el instrumento y la temporalidad del gráfico —con cada pregunta;
  • el código del editor y el informe del compilador —cuando el asistente lee o corrige el script;
  • los datos que el asistente haya pedido: velas, métricas del screener, resultados de ejecuciones, fragmentos de la documentación del lenguaje.

No sale:

  • Secrets. El asistente no ve API keys de exchanges. La API key del proveedor se guarda en este equipo cifrada, no se sincroniza con la configuración y solo se transmite al propio proveedor —para autenticación. Del texto que se envía al modelo el terminal elimina todo lo que se parezca a una clave, token o contraseña, así como rutas a archivos en disco. Un mensaje en el que usted mismo haya pegado algo que parezca una clave no se envía: el chat le pedirá eliminar el secreto.
  • Saldo. El asistente no tiene acceso a saldos, posiciones ni órdenes —solo ve lo que usted muestre en una captura. No puede poner órdenes.
  • Historial del chat. Está en este equipo cifrado y no entra en la sincronización, ni en la exportación de ajustes, ni en el Informe del programa.

Con Ollama o LM Studio la conversación y el código no salen del equipo.

Limitaciones

  • No hay datos en tiempo real en las ejecuciones de verificación. Clústeres, delta, interés abierto, tasa de financiación, libro de órdenes, cinta de operaciones, screener e historial del libro al ejecutar sobre velas están a na. La lógica que dependa de ellos el asistente no puede comprobarla —añada el script al gráfico y compruébelo usted mismo.
  • Límite de pasos. Por respuesta el asistente no realiza más de 24 pasos; después resume. Una respuesta truncada por longitud se puede continuar: pídalo.
  • El modelo se equivoca. La ejecución detecta errores de compilación y de runtime, pero no errores de idea. Antes de confiar en señales, revise el script en el gráfico.
  • Rechazos del proveedor. El chat muestra el texto con el nombre del proveedor: clave no aceptada, límite de peticiones agotado, saldo o cuota insuficientes, sin conexión, servidor local sin respuesta. Para reestablecer la conexión compruebe Internet o indique un proxy.

Siguientes pasos

https://docs.lootx.trade/es/loot/ai-assistant

Основы

10Importar desde Pine Script

Cómo trasladar un indicador de Pine Script a LootScript: dónde está el botón de importación, qué convierte el conversor automáticamente, qué marca para revisar y cómo pulir el resultado.

Si un indicador ya está escrito en Pine Script, no hace falta reescribirlo a mano. El terminal convierte el archivo .pine a LootScript: cambia la sintaxis y los nombres, añade lo que falta y escribe notas al principio del archivo indicando qué se modificó y dónde el conversor tuvo que adivinar.

El conversor es un traductor, no una capa de compatibilidad. No garantiza los mismos números que en el entorno original, y no añade al terminal funciones que allí no existen. Por eso, después de importar debes abrir el script, leer las notas y comprobarlo en el Gráfico. LootScript se desarrolló de forma independiente y no está ligado a TradingView: la sintaxis es similar a propósito, pero los lenguajes no son compatibles.

Cómo importar

Abra la ventana Indicadores

Presione ƒ en el panel del Gráfico — se abrirá la ventana Indicadores.

Haga clic en «Importar…»

El botón está junto a la barra de búsqueda. Seleccione un archivo .pine, .loot o .txt. El archivo .loot irá a la biblioteca tal cual. El archivo .pine —o un archivo de texto similar a Pine Script— pasará por el conversor.

Lea el resultado

Debajo de la barra de búsqueda aparecerá una de estas líneas:

  • «Importado «…»» — no hay notas, el script está listo;
  • «Importado «…»: notas del conversor — N, ver encabezado del script»;
  • «Importado «…», pero el script no compila (errores: N)…» — junto al texto se mostrará el primer error.

La ventana cambiará a la sección Mis scripts, y en la búsqueda se pondrá el nombre del nuevo script.

Abra el script en el Editor

Lea el encabezado con las notas y corrija lo que indique. Cómo — más abajo.

La importación no sobrescribe un script con el mismo nombre: el nuevo recibirá un sufijo, por ejemplo -2. El archivo original no se modifica.

A través de la carpeta de scripts

También puedes simplemente colocar el archivo nombre.pine en la carpeta de scripts — en Windows es %APPDATA%\TradingTerminal\scripts. Al siguiente inicio, el terminal creará junto a él nombre.loot. Si nombre.loot ya existe, no se tocará — no perderás tus cambios. Para convertir de nuevo, por ejemplo después de actualizar el terminal, elimina el .loot.

Qué hace el conversor

  • Indentación → llaves. Los bloques if, else if, else, bucles y funciones reciben llaves. Las líneas de continuación se unen en una sola.
  • Funciones. f(x) => se convierte en func f(x), y la última expresión de la función se convierte en un return explícito.
  • Bucles. El inclusivo for i = 0 to 9 pasa a semi-abierto for i in 0 .. 10. La dirección se toma del paso o de literales de los límites; si no se ve, el conversor asume que el bucle es ascendente y lo indica.
  • Condicionales como valores. Un if con una sola expresión en las ramas se convierte en operador ternario; switch recibe llaves.
  • Transparencia → alfa. En Pine Script la transparencia va de 0 a 100, donde 0 es opaco. En LootScript alfa va de 0 a 255, donde 255 es opaco. color.new(c, 50) se convertirá en color.new(c, 128), y el argumento transp= se transformará en un color.new(…) alrededor del color.
  • Nombres. Los nombres antiguos sin espacio de nombres reciben uno: sma → ta.sma. study → indicator, security → request.security, tostring → str.tostring, syminfo.* → sym.*, timeframe.* → tf.*. La forma corta input(…) recibe tipo: input.int, input.source, etc.
  • Nombres reservados. Una variable cuyo nombre en LootScript sea palabra clave o espacio de nombres (delta, oi, tf, sym, func …) recibe un guion bajo al final en todas sus apariciones: delta → delta_.
  • Argumentos extra — aquellos que no existen en la función en LootScript — se eliminan.
  • Declaración. Si el archivo no contenía indicator(…) o strategy(…), el conversor añadirá un indicator con el nombre del archivo.
  • Comentarios y líneas vacías permanecen en su sitio.

El conversor no rechaza ningún archivo. La línea que no entienda no la elimina, la deja como comentario // [не разобрано] … en la misma posición.

Encabezado con notas

La primera línea del encabezado indica de dónde viene el archivo — «Importado desde un script en Pine Script (versión 5). Notas del conversor:». Luego, una línea por cada modificación, en orden de las líneas del origen: «Línea N: tipo: qué — detalles». Las notas se escriben en el idioma de la interfaz.

Tipo de nota Qué significa ¿Revisar?
renombrado Nombre reemplazado por el análogo en LootScript no
recalculado Transparencia convertida a alfa no
reescrito Cambió la forma: bucle, return, tipo de input corto echar un vistazo
el nombre «…» está reservado en LootScript A la variable se le añadió un guion bajo no
no había declaración indicator(…) Se añadió la declaración usando el nombre del archivo no
argumento eliminado La función en LootScript no tiene ese parámetro sí
suposición El conversor adivinó: dirección del bucle, tipo de entrada que no pudo deducir sí
no está en esta build Esa función no existe en el terminal — el script no compilará por “nombre desconocido” sí
no analizado La línea no se pudo parsear; se conserva como comentario sí

Cuando lo hayas comprobado, puedes eliminar el encabezado — son comentarios ordinarios.

Ejemplo

Pequeño indicador en Pine Script: columnas del rango de la vela, resaltadas cuando el rango es el doble del promedio.

PINE
//@version=5
indicator("Range spike", overlay=false)
len = input.int(20, "Length")
avgRange(n) =>
    r = high - low
    ta.sma(r, n)
base = avgRange(len)
spike = high - low > base * 2
plot(high - low, style=plot.style_columns, color=spike ? color.orange : color.new(color.gray, 60))
plot(base, color=color.blue, trackprice=true)

Así lo escribe el conversor:

Loot
// Импортировано из скрипта на Pine Script (версия 5). Заметки конвертера:
//
// Строка 6: переписано: avgRange — неявный возврат последнего оператора записан как return
// Строка 9: пересчитано: transp → alpha — прозрачность 0…100 пересчитана в альфу 0…255
// Строка 10: аргумент снят: plot: trackprice — такого параметра в LootScript нет

indicator("Range spike", overlay = false)
len = input.int(20, "Length")
func avgRange(n) {
    r = high - low
    return ta.sma(r, n)
}
base = avgRange(len)
spike = high - low > base * 2
plot(high - low, color = spike ? color.orange : color.new(color.gray, 102), style = plot.style_columns)
plot(base, color = color.blue)

La función recibió llaves y return, la transparencia 60 pasó a alfa 102, y trackprice se eliminó — ese parámetro no existe. La nota «argumento eliminado» pide que verifiques si ese parámetro era necesario en sentido lógico. Aquí solo dibujaba la línea del último valor, y el script funciona sin él.

Cómo comprobar y pulir

  1. Lee el encabezado. Empieza por las líneas con tipos «argumento eliminado», «suposición», «no está en esta build» y «no analizado».
  2. Mira la pestaña Problemas en la consola del Editor. Un script con errores no se añadirá al Gráfico.
  3. Usa ‘Añadir al gráfico’ y compáralo con lo que mostraba el original en varios tramos del histórico.
  4. Pide ayuda al asistente. Abre el Asistente de IA y escribe /fix — él compilará el script, lo ejecutará sobre velas y corregirá errores. Puedes añadir una aclaración: /fix analiza las notas del conversor en el encabezado. /explain explicará qué hace el script.

Qué no se transfiere

  • Funciones que no existen en el terminal. El nombre queda en el código, la nota «no está en esta build» y el error del compilador señalan la misma ubicación. Sustituye la llamada a mano o pide al asistente que sugiera un análogo.
  • Cadenas multilínea, importación de librerías ajenas, exportación de funciones. El conversor traslada lo que puede serializar y marca lo demás.
  • Más de tres líneas. El panel de Gráfico dibuja solo las primeras tres plot del script. Distribuye filas adicionales en scripts separados.
  • Trading real. La declaración strategy(…) se traslada, pero una estrategia en LootScript solo opera en el Probador de estrategias — en cuenta simulada.

Siguientes pasos

https://docs.lootx.trade/es/loot/pine-import

Справочник

11Errores de compilación y ejecución

Todos los códigos LS que puede mostrar el Editor y el gráfico de LootScript: texto del mensaje, causa y solución, errores frecuentes con ejemplos, límites de ejecución y casos en los que en vez de error se obtiene na.

Cada mensaje del compilador y del ejecutor de LootScript empieza por un código del tipo LS2008. El código no cambia entre versiones ni depende del idioma de la interfaz, por eso conviene buscarlo: aquí están todos los códigos que puede mostrar el terminal, con el texto del mensaje, la causa y la forma de arreglarlo.

Los mensajes se muestran en ruso si la interfaz del terminal está en ruso, y en inglés en cualquier otro idioma. Primero están los errores que aparecen con más frecuencia, luego los errores de ejecución y la tabla completa.

Где видны ошибки

При компиляции. El Editor compila el script en cada pausa de escritura. Lo que encuentra aparece en la pestaña “Problemas” en la parte inferior del Editor: código, texto y posición como «Стр 6:6». Un doble clic en la línea lleva el cursor al lugar del error. En el encabezado del Editor se muestra el resultado: «ок · 12 мс», «предупреждений: 2» o «ошибок: 1».

При выполнении. Un script sin errores de compilación puede detenerse en algún bar: se acabó el presupuesto de operaciones, un índice salió de los límites de un array, el símbolo es desconocido. Entonces en la pestaña “Salida” aparecerá una línea «Script detenido: LS6004: …», y en la ventana del Probador de estrategias se verá la misma causa. Los demás scripts, paneles y el terminal siguen funcionando.

Las diagnósticas son de tres niveles:

Уровень Что значит Что с графиком
Ошибка Скрипт не собран No se añade al gráfico: «Un script con errores no se coloca en el gráfico — vea “Problemas”». Si el script ya estaba en los gráficos, permanece la versión anterior que funcionaba
Предупреждение Скрипт собран, но результат может обмануть: например, перерисуется на живом баре El script funciona
Сведение Скрипт собран, но какая-то его настройка ничего не делает El script funciona

Как устроены коды

Коды Этап О чём
LS0001–LS0009 Чтение текста Символы, строки, числа, цвета, директива #version
LS1000–LS1012 Разбор Скобки, блоки, порядок операторов, объявление скрипта
LS2000–LS2030 Типы и имена Неизвестные имена, типы, аргументы, na
LS3000–LS3033 Смысл программы ta.* в ветках, рекурсия, стратегии, библиотеки, request.security
LS4000–LS4009 Пределы компиляции Слишком много рядов, выводов, вызовов
LS5000–LS5013 Перерисовка и честность теста Значения, которые на истории выглядят иначе, чем вживую
LS6000–LS6036 Выполнение Бюджеты, индексы, коллекции, строки, объекты рисования
LS0999 Внутренний сбой Дефект компилятора — о нём нужно сообщить

Частые ошибки компиляции

LS1009 — нет объявления скрипта

«Нет объявления скрипта — начните с indicator(“Название”)». El primer operador del fichero debe ser indicator(...), strategy(...) o library(...). Esta misma ошибка aparece si la declaración existe pero hay algo escrito antes. Los comentarios y la directiva #version 1 no molestan.

Loot
// Так нельзя: объявление не первое
len = input.int(14, "Длина")
indicator("RSI")
Loot
indicator("RSI")
len = input.int(14, "Длина")

Una segunda declaración en el mismo fichero da LS1008: el script sólo puede tener una.

LS2002 — неизвестное имя

«Неизвестное имя «…» — проверьте написание или объявите его выше». Normalmente es una errata o una función sin su namespace: todas las funciones de indicadores están en ta, las matemáticas en math, los colores en color.

Loot
avg = sma(close, 20)
Loot
avg = ta.sma(close, 20)

La misma falla ocurre si se lee una variable antes de la línea donde se declara. La lista completa de nombres está en la Referencia de funciones.

LS2008 — сравнение с na

«Сравнение с na всегда ложно — используйте na(x)». Cualquier comparación con na, incluyendo == y !=, da false, por eso el compilador no permite esa escritura.

Loot
x = ta.sma(close, 50)
plot(x == na ? close : x)
Loot
x = ta.sma(close, 50)
plot(na(x) ? close : x)

Lo mismo se escribe más corto con ??: plot(x ?? close).

LS2014 — значение меняется от бара к бару там, где нужна постоянная

««…» в «…» требует значение не слабее input, а передано series — возьмите input.*(…) или литерал». La longitud de la ventana en ta.* debe conocerse antes del primer bar. Una longitud que se elige condicionalmente en cada bar no es válida.

Loot
len = close > open ? 10 : 20
avg = ta.sma(close, len)

Calcule ambas variantes y elija el resultado, no la longitud:

Loot
fast = ta.sma(close, 10)
slow = ta.sma(close, 20)
avg  = close > open ? fast : slow

Si la longitud debe fijarla el usuario, tómela de input.int(...).

LS3004 — вызов ta.* зависит от переменной из ветки

«Аргумент «…» нельзя вычислить вне ветки — вынесите вызов ta.* на верхний уровень». Las funciones ta.* recuerdan barras pasadas, por eso el compilador las evalúa en cada bar aunque la llamada esté dentro de un if. Si el argumento se declara solo dentro de la rama, en otras barras simplemente no existe.

Loot
var float avgBody = na
if close > open {
    body = close - open
    avgBody := ta.sma(body, 10)
}
Loot
body    = close - open
avgBody = ta.sma(body, 10)

LS2017, LS2007, LS1006 — строки, условия и сравнения

Estas tres errores comparten causa: LootScript no convierte tipos implícitamente.

Код Сообщение Как исправить
LS2017 «Строку нельзя складывать с числом (… + …) — используйте str.tostring(…)» "RSI " + str.tostring(r) en lugar de "RSI " + r
LS2007 «Условие должно быть bool, а здесь …» if volume > 0 en lugar de if volume — los números no son truthy
LS1006 «Сравнения не сцепляются — напишите a < b and b < c» low < close and close < high en lugar de low < close < high

LS2018 и LS2019 — имя уже занято

««…» уже объявлено в этой области» (LS2018) — la variable se declaró por segunda vez con =. Para cambiar su valor use :=.

Loot
level = high
level := low

««…» затеняет встроенное имя — выберите другое» (LS2019) — variable, función o tipo se llamaron igual que un series o función incorporada: close, time, hour, volume. Renombre, por ejemplo startHour en vez de hour. Los nombres de espacios como color o position pueden usarse como nombres de variable.

LS2004 и LS2005 — аргументы вызова

««…» ожидает … аргумент(ов), а передано …» (LS2004) и «У «…» нет параметра «…»» (LS2005). Compruebe la llamada con la firma en la Referencia: los nombres de parámetros se escriben exactamente como allí.

Loot
plot(close, colour = color.red)
Loot
plot(close, color = color.red)

LS3011 и LS5011 — стратегии

«strategy.* доступно только в strategy(…)» (LS3011): órdenes y estado de posición existen solo en un script declarado con strategy(...). Reemplace indicator("…") por strategy("…").

«Стратегия читает «…»: у стакана и ленты нет истории, бэктест был бы вымыслом» (LS5011): la estrategia se prueba sobre la historia, y book.* y tape.* no tienen historia — en cada bar pasado allí hay na.

Loot
strategy("Перекос стакана")
if book.imbalance(10) > 0.5 {
    strategy.entry("L", strategy.long)
}

Para historia del libro de órdenes existe el espacio depth: donde el libro está grabado, depth.* da valores en cada bar.

Loot
strategy("Перекос стакана")
if depth.imbalance(1.0) > 0.5 {
    strategy.entry("L", strategy.long)
}

LS5000–LS5006 — предупреждения о перерисовке

Estas advertencias no impiden que el script funcione. Indican que una línea en la historia se verá distinta de como se vio en vivo:

  • LS5001 — llega al gráfico un valor que solo existe en el bar en vivo (barstate.isrealtime, barstate.isnew).
  • LS5000 — llega al gráfico la variable varip: acumula ticks del bar en vivo que no existen en la historia.
  • LS5006 — llegan al gráfico book.* o tape.*: en la historia la serie está vacía.
  • LS5003 — valor de un higher timeframe desde request.security sin [1]: el bar no cerrado aún va a cambiar.
  • LS5002 — lookahead = true en request.security: en la historia el script ve el futuro.
  • LS5005 — llegan al gráfico math.random o timenow: dos ejecuciones dan líneas distintas.

Si es intencionado — por ejemplo un indicador solo para trading en vivo — la advertencia puede dejarse.

LS3016 — настройка принята и ничего не делает

Esto es un aviso informativo, no un error. Aparece en scripts trasladados de otras plataformas: el parámetro existe por compatibilidad pero no influye en el terminal. La segunda parte del mensaje explica por qué.

Что написано Пояснение в сообщении
maxBarsBack в объявлении la historia se carga por columnas completas
format, precision, scale в объявлении el formato y escala los gestiona el terminal
timeframe в объявлении el script se calcula en la temporalidad del gráfico; otra da request.security
Grosor, estilo u otra opción de salida definida por expresión y no por constante (el color de plot o marcas que cambian por barra) esta compilación sólo lee esa opción como constante
color en el cuarto y siguientes plot el panel dibuja solo las tres primeras series
location.absolute en plotshape o plotchar la marca no tiene un series al que pegarse
display, que el series no soporta ese series no tiene esa superficie

Ошибки выполнения

Un error de ejecución detiene el script en el bar donde ocurrió. El texto aparece en la pestaña “Salida” como «Script detenido: LS6004: …».

LS6004 и LS6005 — скрипт работает слишком долго

«Скрипт исчерпал бюджет операций на бар — упростите цикл» (LS6004) y «Скрипт превысил лимит времени на проход» (LS6005). Cada bar tiene un presupuesto de 2 000 000 de operaciones. El tiempo también está limitado: todo el pase por la historia — 2 s, un tick de bar en vivo — 20 ms. Casi siempre la causa es un bucle que no termina o que procesa demasiados datos en cada bar.

Loot
var int n = 0
i = 0
while i < 10 {
    n := n + 1
}
Loot
var int n = 0
i = 0
while i < 10 {
    n := n + 1
    i := i + 1
}

LS6002 и LS5004 — чтение будущего

El índice de la historia x[n] no puede ser negativo: close[-1] significaría el siguiente bar. Si el número negativo está literal en el texto, el compilador lo detendrá inmediatamente (LS5004). Si nace de un cálculo, el script se detendrá en el bar con el error «Desplazamiento negativo de historia — no se puede leer el futuro» (LS6002). Un índice mayor que el número de barras cargadas no provoca error: da na.

LS6001, LS6007, LS6019 — коллекции и объекты

  • LS6001 «Индекс … вне границ» — array.get, array.set o matrix.get fuera del tamaño. Compruebe array.size(a) antes de acceder.
  • LS6007 «Обращение к пустому объекту (na)» — la colección se declaró pero no se creó: var array<float> a = na y luego a.push(x). Créela con array.new<float>().
  • LS6019 «Объект рисования уже удалён или вытеснен по потолку — создайте его заново». Viven simultáneamente 500 objetos del mismo tipo, el más antiguo es desalojado. Eleve el límite con maxLinesCount, maxLabelsCount o maxBoxesCount en la declaración o reutilice el objeto con set_*.

LS6017 и LS6018 — инструмент и таймфрейм в request.security

«Символ «…» неизвестен — проверьте формат «ПЛОЩАДКА:СИМВОЛ» или задайте ignore_invalid_symbol = true» (LS6017) y «Таймфрейм «…» не разбирается — ожидается «5», «60», «4h», «1D», «1W»» (LS6018). Con ignore_invalid_symbol = true un instrumento desconocido da na en vez de detenerse.

Пределы выполнения

Что ограничено Предел Код при превышении
Операций на бар 2 000 000 LS6004
Время прохода по истории / тика живого бара 2 с / 20 мс LS6005
Элементов массива 100 000 LS6003
Пар в словаре 50 000 LS6003
Элементов матрицы 1 000 000 LS6003
Длина окна ta.* 100 000 баров LS6034
Длина одной строки 100 000 символов LS6014
Ячеек в таблице 2000 LS6029
Слоёв теплового поля 4 (от 0 до 3) LS6036
Объектов рисования одного вида 500 по умолчанию старые вытесняются
Разных пар «инструмент + таймфрейм» в request.security 8 —
Вызовов request.security 32 LS4009 при компиляции

Когда ошибки нет, а значения нет

Muchas situaciones que en otros lenguajes harían caer el programa en LootScript dan na — un hueco en el gráfico, no una detención:

  • la aritmética con na da na: close - x con x vacío también es vacío;
  • x[n] más allá del inicio de la historia — na;
  • la división entera por cero — na, y la división en coma flotante por cero no detiene el script;
  • book.*, tape.* y screener.* en barras históricas — na;
  • clústeres, delta, interés abierto y la historia del libro de órdenes — na en barras donde no hay datos. Compruebe cluster.available, delta.available y las flags adyacentes;
  • ta.* en las primeras barras, hasta que la ventana se llena, — na.

na en el gráfico nunca se dibuja como cero: la línea se corta. Para sustituir el valor use nz(x), x ?? fallback o fixnan(x).

Все коды

LS0001–LS0009 и LS0999 — чтение текста

Код Сообщение Что делать
LS0001 Неожиданный символ «…» Уберите символ, которого нет в языке
LS0002 Строка не закрыта — добавьте закрывающую кавычку до конца строки Закройте кавычку на той же строке
LS0003 Блочный комментарий не закрыт — добавьте */ Закройте /* … */
LS0004 Неизвестная escape-последовательность «…» в строке Допустимы \n, \r, \t, \0, \\, \", \' и \u{…}; одиночную \ удвойте
LS0005 Неверный числовой литерал «…» Проверьте запись числа
LS0006 Число «…» не помещается в тип Уменьшите число
LS0007 Неверный литерал цвета «…» — ожидается #RRGGBB или #RRGGBBAA Шесть или восемь шестнадцатеричных цифр
LS0008 Разделитель разрядов «_» стоит в начале, в конце или сдвоен Пишите 1_000_000
LS0009 Неверная директива версии — ожидается #version <число> первой строкой #version 1 в первой строке
LS0999 Компилятор не справился с этим файлом — это дефект сборки, сообщите о нём Сообщите в поддержку, приложите скрипт

LS1000–LS1012 — разбор

Код Сообщение Что делать
LS1000 Неожиданно: … Проверьте строку на лишние символы
LS1001 Ожидалось «…», а встретилось … Чаще всего не закрыта скобка
LS1002 Ожидалось выражение, а встретилось … После оператора или запятой не хватает значения
LS1004 Ожидалось имя, а встретилось … После var, func, . нужно имя
LS1005 Ожидался блок в фигурных скобках, а встретилось … Добавьте { … }
LS1006 Сравнения не сцепляются — напишите a < b and b < c Разбейте на два сравнения через and
LS1008 Второе объявление скрипта — у скрипта может быть только одно Оставьте одно объявление
LS1009 Нет объявления скрипта — начните с indicator(“Название”) Первой строкой — indicator, strategy или library
LS1010 Слишком глубокая вложенность (больше 64) — вынесите часть в функцию Разбейте выражение или блок
LS1012 Тело if / for / while пишется в фигурных скобках: if cond { … } Добавьте фигурные скобки

LS2000–LS2030 — типы и имена

Код Сообщение Что делать
LS2000 Несовпадение типов: ожидался …, а получен … Передайте значение нужного типа
LS2001 Нельзя преобразовать … в … Преобразуйте явно: str.tostring, math.round
LS2002 Неизвестное имя «…» — проверьте написание или объявите его выше Исправьте опечатку, добавьте пространство (ta.), объявите выше
LS2003 «…» — не функция, вызывать нельзя Уберите скобки: это ряд или константа
LS2004 «…» ожидает … аргумент(ов), а передано … Сверьте число аргументов со справочником
LS2005 У «…» нет параметра «…» Исправьте имя параметра
LS2006 Аргумент «…» передан дважды Уберите повтор
LS2007 Условие должно быть bool, а здесь … Сравните явно: x > 0, not na(x)
LS2008 Сравнение с na всегда ложно — используйте na(x) na(x) вместо x == na
LS2014 «…» в «…» требует значение не слабее …, а передано … — возьмите input.*(…) или литерал Литерал, input.* или константа вместо ряда
LS2015 «…» объявлено константой — присваивать нельзя; объявите через var Настройку input.*, переменную цикла и параметр функции менять нельзя — скопируйте значение в свою переменную
LS2017 Строку нельзя складывать с числом (… + …) — используйте str.tostring(…) str.tostring или str.format
LS2018 «…» уже объявлено в этой области := для нового значения или другое имя
LS2019 «…» затеняет встроенное имя — выберите другое Переименуйте
LS2020 Ветви дают разные типы: … и … Приведите ветви к одному типу
LS2021 switch без ветви по умолчанию «=> …» — добавьте её Добавьте => значение
LS2022 У «…» не выведен тип элемента — укажите его: … array.new<float>()
LS2028 У поля «…» типа «…» не указан тип — напишите его перед именем: float … float price в объявлении type
LS2029 export «…»: у экспортируемой функции обязаны быть объявлены типы всех параметров и тип результата Укажите типы
LS2030 «…» в «…» читается до первого бара — нужен литерал или именованная константа В объявлении — только постоянные значения

LS3000–LS3033 — смысл программы

Код Сообщение Что делать
LS3002 «…» вызывает саму себя — рекурсия в LootScript запрещена Замените рекурсию циклом
LS3003 Взаимная рекурсия запрещена: … Разорвите круг вызовов
LS3004 Аргумент «…» нельзя вычислить вне ветки — вынесите вызов ta.* на верхний уровень Вычислите аргумент и вызов вне if
LS3006 «…» затеняет имя из внешней области (предупреждение) Переименуйте внутреннюю переменную
LS3007 «…» вне цикла break и continue — только в цикле
LS3008 return вне функции return — только в теле функции
LS3009 export «…» возможен только в library(…) Уберите export или сделайте файл библиотекой
LS3010 «…» без единого уровня (profit/loss/stop/limit/trail) — пустая операция (предупреждение) Задайте стоп, тейк или трейлинг
LS3011 strategy.* доступно только в strategy(…) Объявите скрипт через strategy(...)
LS3012 В библиотеке нельзя рисовать и объявлять входы: … Перенесите вывод и настройки в индикатор
LS3013 «…» внутри request.security не станет строкой настроек — объявите вход выше и передайте его значение Объявите input.* выше и передайте переменную
LS3016 Настройка «…» принята и ничего не делает: … (сведение) Можно оставить или удалить
LS3018 Библиотека «…» не найдена в папке библиотек — имя берётся из её library(“…”, N), a не из имени файла Проверьте имя в объявлении библиотеки
LS3019 Библиотеки «…» версии … нет; установлены: … Укажите установленную версию
LS3020 «…» внутри request.security: у стакана и ленты нет истории на чужой серии Уберите book.*, tape.* из выражения
LS3025 Функция «…» объявлена, но не вызывается — её тело проверено лишь пробно (предупреждение) Вызовите функцию или удалите
LS3026 «…» требует стоп, от которого считать размер: loss/stop у входа или в strategy.exit Добавьте стоп к входу или strategy.exit
LS3028 Эта сборка не поддерживает: … Перепишите без этой конструкции
LS3029 Ветвь switch для «…» повторяется — вторая недостижима Уберите повтор
LS3030 «…» — переменная графика, а выражение request.security считается на другой серии; передайте значение через input.* или посчитайте его внутри выражения Посчитайте внутри выражения
LS3031 Библиотеки импортируют друг друга по кругу: … Разорвите круг импортов
LS3032 В библиотеке «…» допустимы только объявления функций и импорты — здесь … Уберите из библиотеки остальной код
LS3033 Библиотека «…» не компилируется (…) — откройте её в Editor и почините Исправьте ошибку в самой библиотеке

LS4000–LS4009 — пределы компиляции

Код Сообщение Что делать
LS4000 Слишком много рядов: … при пределе 512 — уберите лишние ta.* или переиспользуйте переменные Сократите число вызовов ta.* и переменных с историей
LS4001 Программа слишком велика (больше 4096 встраиваний) — упростите функции Уменьшите число вызовов пользовательских функций
LS4002 Слишком много plot — панель рисует не больше трёх рядов Выводов — рядов plot, отметок plotshape и plotchar, фона bgcolor — не больше 64; рисуются первые три plot
LS4009 Слишком много вызовов request.security: …, предел 32 Объедините вызовы

LS5000–LS5013 — перерисовка и тестер

Код Сообщение Что делать
LS5000 Значение varip доходит до вывода — на истории оно будет другим (перерисовка) (предупреждение) Используйте var, если нужна одинаковая история
LS5001 Значение только живого бара доходит до вывода — на истории его нет (перерисовка) (предупреждение) Используйте barstate.isconfirmed
LS5002 lookahead = true читает будущее — на истории результат недостижим в реальном времени (предупреждение) Уберите lookahead = true
LS5003 Старший таймфрейм без смещения — незакрытый бар перерисуется; добавьте [1] (предупреждение) request.security(…, close[1])
LS5004 Отрицательное смещение сдвигает вывод в прошлое — на истории линия знает будущее Уберите отрицательный индекс x[-n]
LS5005 Недетерминированное значение доходит до вывода — два прогона дадут разный ряд (предупреждение) Не выводите math.random и timenow на график
LS5006 Данные есть только в реальном времени — на истории ряд пуст (предупреждение) Для истории libro de órdenes используйте depth.*
LS5011 Стратегия читает «…»: у стакана и ленты нет истории, бэктест был бы вымыслом Уберите book.*, tape.* из стратегии
LS5012 Стратегия заглядывает вперёд («…») — отчёт помечен как недостижимый в реальном времени (предупреждение) Уберите lookahead = true
LS5013 «…» включён: заявки исполняются по закрытию бара, отчёт помечен (сведение) Уберите processOrdersOnClose, если нужен реалистичный отчёт

LS6000–LS6036 — выполнение

Код Сообщение Что делать
LS6001 Индекс … вне границ Проверьте размер коллекции перед обращением
LS6002 Отрицательное смещение истории — читать будущее нельзя Индекс истории должен быть ≥ 0
LS6003 Превышен предел размера коллекции (…) — коллекция создана в строке … Ограничьте рост: удаляйте старые элементы
LS6004 Скрипт исчерпал бюджет операций на бар — упростите цикл Проверьте условие выхода из цикла
LS6005 Скрипт превысил лимит времени на проход Уменьшите работу на каждом баре
LS6007 Обращение к пустому объекту (na) Создайте коллекцию или объект до обращения
LS6014 Строка длиннее потолка в 100000 знаков — укоротите её или соберите по частям Сократите строку
LS6015 Неизвестный часовой пояс «…» — нужен идентификатор IANA, например «Europe/Berlin» Пояс в формате IANA
LS6017 Символ «…» неизвестен — проверьте формат «ПЛОЩАДКА:СИМВОЛ» или задайте ignore_invalid_symbol = true Исправьте символ
LS6018 Таймфрейм «…» не разбирается — ожидается «5», «60», «4h», «1D», «1W» Исправьте таймфрейм
LS6019 Объект рисования уже удалён или вытеснен по потолку — создайте его заново Проверяйте объект или поднимите предел
LS6020 str.format: плейсхолдеру {…} не передан аргумент Передайте аргумент для каждого {n}
LS6021 str.match: шаблон исчерпал бюджет шагов — упростите его Упростите регулярное выражение
LS6026 Исчерпан общий бюджет коллекций скрипта (… ячеек) — не влезла коллекция из строки … Сократите число или размер коллекций
LS6027 Недопустимый аргумент «…» в … Например, отрицательный размер в array.new
LS6028 Исчерпан бюджет строк скрипта (…) — переиспользуйте строки вместо новых на каждом баре Не собирайте новые строки на каждом баре
LS6029 В таблице больше 2000 ячеек — это потолок панели Уменьшите таблицу
LS6030 Ячейка таблицы вне сетки: … Номер столбца и строки — внутри размера таблицы
LS6031 Встроенная функция «…» объявлена, но не реализована — это дефект сборки, сообщите о нём Сообщите в поддержку
LS6032 Хэндл не указывает на объект нужного вида — объект освобождён или хэндл из другого прогона Не храните ссылки на удалённые объекты
LS6033 Поле … вне объявления типа «…» — это дефект сборки, сообщите о нём Сообщите в поддержку
LS6034 Длина окна … больше потолка 100000 — такое окно не поместится в память Уменьшите длину окна
LS6035 Шаг цикла равен нулю — счётчик не двигается, и конец недостижим by в цикле for не может быть нулём
LS6036 Слой тепла … вне 0…3 layer от 0 до 3
Коды, которые эта версия не выдаёт

Эти номера закреплены в языке, но текущая версия терминала их не показывает: LS1003, LS1007, LS1011, LS2016, LS3000, LS3001, LS3005, LS4003, LS4004, LS5007, LS6000, LS6006, LS6008, LS6022, LS6023. Например, объявление не первой строкой сейчас сообщается как LS1009, а деление на ноль не останавливает скрипт с LS6000.

Дальше

https://docs.lootx.trade/es/loot/errors

Справочник

12Ejemplos de scripts

Ocho scripts listos en LootScript: medias móviles, RSI, VWAP con bandas, CVD con divergencias, interés abierto, tasa de financiación, disbalances de clústeres y una estrategia para el probador.

Ocho scripts listos en LootScript: desde medias móviles y RSI hasta CVD, interés abierto, tasa de financiación y clústeres. Cada uno es un indicador funcional que puedes añadir al Gráfico y ajustar. Todos los ejemplos compilan sin errores ni advertencias con el compilador de la versión actual.

Cómo ejecutar un ejemplo

  1. Haga clic en ƒ en el panel del Gráfico; en la ventana Indicadores — Editor….
  2. En el Editor haga clic en Nuevo (Ctrl+N), reemplace la plantilla por el código del ejemplo y pulse Guardar.
  3. Pulse Añadir al gráfico (Ctrl+Enter). Las opciones de input.* aparecerán en la ventana de configuración del indicador.

1. Tres medias móviles con selección de tipo

Rápida, media y lenta del mismo tipo, seleccionable. El fondo se ilumina cuando las tres se alinean a favor de la tendencia.

Loot
indicator("Три скользящие", shortTitle = "MA×3", overlay = true)
maType = input.string("EMA", "Тип средней", options = ["EMA", "SMA", "WMA", "HMA"])
src    = input.source(close, "Источник")
len1   = input.int(20, "Быстрая", minval = 1)
len2   = input.int(50, "Средняя", minval = 1)
len3   = input.int(200, "Медленная", minval = 1)

func ma(s, len) => switch maType {
    "SMA" => ta.sma(s, len)
    "WMA" => ta.wma(s, len)
    "HMA" => ta.hma(s, len)
    => ta.ema(s, len)
}

m1 = ma(src, len1)
m2 = ma(src, len2)
m3 = ma(src, len3)

plot(m1, "Быстрая", color = m1 >= m1[1] ? color.teal : color.red, linewidth = 2)
plot(m2, "Средняя", color = color.orange)
plot(m3, "Медленная", color = color.gray, linewidth = 2)
bgcolor(m1 > m2 and m2 > m3 ? color.new(color.teal, 20) : m1 < m2 and m2 < m3 ? color.new(color.red, 20) : na)

Cómo funciona

  • input.string con options se convierte en un menú desplegable en la configuración.
  • La función ma elige la media mediante switch. El estado ta.* vive por cada llamada, por eso tres llamadas a ma son tres medias independientes.
  • El color de la línea rápida es una expresión: si sube respecto a la barra anterior (m1[1]) es teal, si baja es rojo.
  • El panel puede dibujar hasta tres líneas plot por script — de ahí que haya tres medias.

2. RSI con zonas y alertas

RSI con una banda rellenada entre niveles. La línea y el fondo se colorean cuando el RSI está en sobrecompra o sobreventa.

Loot
indicator("RSI с зонами", shortTitle = "RSI", overlay = false)
len = input.int(14, "Период", minval = 2)
src = input.source(close, "Источник")
ob  = input.float(70, "Перекупленность", minval = 50, maxval = 100)
os  = input.float(30, "Перепроданность", minval = 0, maxval = 50)

r = ta.rsi(src, len)

hOb = hline(ob, "Перекупленность", color = color.red)
hOs = hline(os, "Перепроданность", color = color.teal)
fill(hOb, hOs, color = color.new(color.purple, 20))
plot(r, "RSI", color = r > ob ? color.red : r < os ? color.teal : color.purple, linewidth = 2)
bgcolor(r > ob ? color.new(color.red, 35) : r < os ? color.new(color.teal, 35) : na)

alertcondition(ta.crossunder(r, ob), "RSI вышел из перекупленности", "RSI опустился ниже верхнего уровня")
alertcondition(ta.crossover(r, os), "RSI вышел из перепроданности", "RSI поднялся выше нижнего уровня")

Cómo funciona

  • hline devuelve una asa del nivel, y fill rellena la franja entre dos asas.
  • Los niveles son ajustes input.float, por eso las líneas y la relleno se mueven con ellos.
  • alertcondition declara dos alertas. Por sí solas no suenan — cómo activarlas está en la página Alertas de script.
  • La alfa en color.new va de 0 (transparente) a 255 (opaco).

3. VWAP del día con bandas de desviación

Precio ponderado por volumen desde el inicio del día en UTC y una banda de ±σ alrededor.

Loot
indicator("VWAP дня с полосами", shortTitle = "VWAP", overlay = true)
src  = input.source(hlc3, "Цена")
mult = input.float(1.0, "Ширина полосы, σ", minval = 0.1, step = 0.1)

anchor = session.isfirstbar
vw = ta.vwap(src, anchor)

// Сумма объёма и сумма объёма на квадрат цены с начала дня — для разброса вокруг VWAP.
var float sumV  = 0.0
var float sumV2 = 0.0
if anchor {
    sumV  := 0.0
    sumV2 := 0.0
}
if not na(volume) and not na(src) {
    sumV  := sumV + volume
    sumV2 := sumV2 + volume * src * src
}
sigma = sumV > 0 and not na(vw) ? math.sqrt(math.max(sumV2 / sumV - vw * vw, 0)) : na

pUp = plot(vw + mult * sigma, "Верх", color = color.new(color.blue, 150))
plot(vw, "VWAP", color = color.blue, linewidth = 2)
pDn = plot(vw - mult * sigma, "Низ", color = color.new(color.blue, 150))
fill(pUp, pDn, color = color.new(color.blue, 25))

Cómo funciona

  • ta.vwap reinicia el cálculo en la barra donde el ancla es verdadera. En cripto, session.isfirstbar es la primera barra después de las 00:00 UTC.
  • Las variables var sobreviven entre barras. El mismo ancla las pone a cero, por eso la banda se calcula para el mismo período que el VWAP.
  • La desviación es la raíz de la media ponderada del cuadrado del precio menos el cuadrado del VWAP. math.max(…, 0) protege contra pequeños negativos por redondeo.
  • Tiene sentido en temporalidades intradía. Si quieres VWAP desde la última liquidación de funding, pon anchor = funding.settled.

4. CVD diaria con divergencias

Delta acumulada que se reinicia cada día, y marcas en las barras donde el precio renovó extremo pero la delta no lo confirmó.

Loot
indicator("Дневная кумдельта с расхождениями", shortTitle = "CVD", overlay = false)
len = input.int(20, "Окно поиска максимумов", minval = 3)

var float cvd = 0.0
if session.isfirstbar {
    cvd := 0.0
}
if delta.available {
    cvd := cvd + delta.value
}
cvdLine = delta.available ? cvd : na

// Цена обновила максимум окна, а кумдельта — нет: покупатели не подтверждают рост.
bearish = high >= ta.highest(high, len) and cvdLine < ta.highest(cvdLine, len)
bullish = low <= ta.lowest(low, len) and cvdLine > ta.lowest(cvdLine, len)

plot(cvdLine, "Кумдельта", color = cvdLine >= 0 ? color.teal : color.red, linewidth = 2)
hline(0, "Ноль", color = color.gray)
plotshape(bearish, "Медвежье расхождение", style = shape.triangledown, location = location.top, color = color.red, size = size.tiny)
plotshape(bullish, "Бычье расхождение", style = shape.triangleup, location = location.bottom, color = color.teal, size = size.tiny)

Cómo funciona

  • delta.value son compras agresivas menos ventas agresivas por barra. Donde no hay cobertura, delta.available es falso y la línea se interrumpe en vez de dibujar un cero.
  • El acumulador var se reinicia al inicio del día. Si necesitas una CVD que no se reinicie en todo el histórico cargado, usa la serie delta.cum ya preparada.
  • Divergencia: el precio marca el máximo de la ventana, pero la CVD está por debajo de su máximo en la misma ventana. Para mínimos, el criterio es simétrico.
  • location.top y location.bottom colocan las marcas en los bordes del subpanel, no en el precio.

5. Picos de interés abierto

Cambio del interés abierto barra a barra en porcentaje y marcas donde se sale del rango habitual de variación.

Loot
indicator("Изменение открытого интереса", shortTitle = "ΔOI %", overlay = false)
len = input.int(50, "Окно для всплесков", minval = 5)
k   = input.float(3.0, "Порог всплеска, σ", minval = 0.5, step = 0.5)

pct = oi.available and oi.close[1] > 0 ? 100 * (oi.close - oi.close[1]) / oi.close[1] : na
sd  = ta.stdev(pct, len)
spike = not na(sd) and math.abs(pct) > k * sd

plot(pct, "ΔOI, %", style = plot.style_columns, color = pct >= 0 ? color.teal : color.red)
hline(0, "Ноль", color = color.gray)
plotshape(spike, "Всплеск", style = shape.circle, location = location.top, color = color.orange, size = size.tiny)

Cómo funciona

  • oi.close es el interés abierto al cierre de la barra; oi.close[1] el de la barra anterior. La comprobación oi.available evita calcular cambios desde datos faltantes.
  • Un pico es una barra donde el cambio absoluto excede k desviaciones estándar sobre la ventana len.
  • El interés abierto llega con frecuencia minuto a minuto. En temporalidades menores al minuto las barras contiguas repiten el mismo valor y el cambio es cero — eso son datos, no un error.

6. Tasa de financiación

La tasa de financiación de un futuro perpetuo, en porcentaje por periodo o reexpresada a anual, con marcas de pago y resaltado de tasa alta.

Loot
indicator("Ставка финансирования", shortTitle = "Funding", overlay = false)
mode = input.string("За период", "Показывать", options = ["За период", "Годовых"])
thr  = input.float(0.05, "Порог, %", minval = 0.0, step = 0.01)

perPeriod = funding.rate * 100
periodsPerYear = funding.interval_hours > 0 ? 24.0 / funding.interval_hours * 365 : na
value = mode == "Годовых" ? perPeriod * periodsPerYear : perPeriod
level = mode == "Годовых" ? thr * periodsPerYear : thr

plot(value, "Ставка, %", style = plot.style_columns, color = value >= 0 ? color.teal : color.red)
hline(0, "Ноль", color = color.gray)
plotshape(funding.settled, "Выплата", style = shape.circle, location = location.bottom, color = color.gray, size = size.tiny)
bgcolor(math.abs(value) > level ? color.new(color.orange, 30) : na)

Cómo funciona

  • funding.rate es el factor, no el porcentaje: 0.0001 representa 0,01 %. Por eso la tasa se multiplica por 100.
  • Para anualizar, la tasa se multiplica por el número de pagos al año. 24.0 está escrito con punto para evitar división entera.
  • funding.settled es verdadero en la barra donde hubo pago; ahí se coloca un punto en la parte inferior.
  • El umbral se define por periodo y para las anualizadas se recalcula con el mismo multiplicador.

7. Disbalances en clústeres

Marcas en el precio donde en los clústeres hay una “escalera” de disbalances o simplemente muchos disbalances, más el nivel de volumen máximo (POC) de cada barra.

Loot
indicator("Дисбалансы кластеров", shortTitle = "Imbalance", overlay = true)
minSteps = input.int(3, "Уровней подряд", minval = 2)
minCount = input.int(5, "Дисбалансов в баре", minval = 1)

levels = cluster.available ? cluster.levels : 0
buys  = 0
sells = 0
for i in 0 .. levels {
    side = cluster.imbalance(i)
    if side == 1 {
        buys := buys + 1
    } else if side == -1 {
        sells := sells + 1
    }
}

plot(cluster.poc, "POC", style = plot.style_circles, color = color.orange)
plotshape(cluster.stacked_buy_steps >= minSteps, "Лесенка покупок", style = shape.triangleup, location = location.belowbar, color = color.teal, size = size.small)
plotshape(cluster.stacked_sell_steps >= minSteps, "Лесенка продаж", style = shape.triangledown, location = location.abovebar, color = color.red, size = size.small)
plotshape(buys >= minCount, "Много дисбалансов покупок", style = shape.circle, location = location.belowbar, color = color.new(color.teal, 120), size = size.tiny)
plotshape(sells >= minCount, "Много дисбалансов продаж", style = shape.circle, location = location.abovebar, color = color.new(color.red, 120), size = size.tiny)

Cómo funciona

  • cluster.imbalance(i) devuelve +1, −1 o 0 para el nivel de precio i. El umbral de disbalance lo toma la configuración de clústeres del Gráfico, así que el script ve lo mismo que tú.
  • cluster.stacked_buy_steps es cuántos niveles consecutivos hay con disbalance de compras. El bucle for i in 0 .. levels cuenta todos los disbalances de la barra, no solo los consecutivos.
  • El script se suscribe a los clústeres y funciona sobre un gráfico de velas normal. En exchanges sin cobertura y en temporalidades menores a 30 segundos o mayores a un día no hay clústeres — entonces levels es 0 y no habrá marcas.

8. Estrategia: cruce de EMA con stop basado en ATR

Entrada largo al cruce de medias, stop y objetivo en múltiplos de ATR, salida por cruce inverso.

Loot
strategy("EMA-кросс со стопом по ATR", overlay = true, initialCapital = 10000,
         defaultQtyType = strategy.qty.percent_of_equity, defaultQtyValue = 10,
         slippageTicks = 2)
fastLen = input.int(12, "Быстрая EMA", minval = 1)
slowLen = input.int(26, "Медленная EMA", minval = 2)
atrLen  = input.int(14, "Период ATR", minval = 1)
stopK   = input.float(1.5, "Стоп, в ATR", minval = 0.1, step = 0.1)
takeK   = input.float(3.0, "Цель, в ATR", minval = 0.1, step = 0.1)

fast = ta.ema(close, fastLen)
slow = ta.ema(close, slowLen)
atr  = ta.atr(atrLen)

// ATR запоминается в момент сигнала, чтобы стоп и цель не ползли вслед за волатильностью.
var float riskAtr = na
if ta.crossover(fast, slow) and strategy.position_size == 0 {
    riskAtr := atr
    strategy.entry("Long", strategy.long)
}
if ta.crossunder(fast, slow) {
    strategy.close("Long", comment = "Обратный кросс")
}
if strategy.position_size > 0 {
    entry = strategy.position_avg_price
    strategy.exit("Стоп/цель", from_entry = "Long", stop = entry - stopK * riskAtr, limit = entry + takeK * riskAtr)
}

plot(fast, "Быстрая", color = color.teal)
plot(slow, "Медленная", color = color.orange)

Cómo funciona

  • Los parámetros de strategy(…) son literales: capital 10 000, tamaño de posición 10 % del capital, deslizamiento 2 ticks. No hay comisión fijada, por eso el probador usa la tarifa por defecto: 0,02 % para ejecución límite y 0,05 % para mercado y stop. Tu propia tarifa en porcentaje se define con commissionValue.
  • La entrada de mercado se ejecuta en la apertura de la barra siguiente, no en el cierre de la señal: así el probador no mira al futuro.
  • strategy.exit coloca stop y objetivo desde el precio medio de entrada. Si en una barra se tocan ambos, el probador por defecto considera que se ejecutó el stop.
  • Resultados — operaciones, curva de capital, drawdowns — aparecen en la ventana Probador de estrategias… del Editor. Más detalles en Estrategias y probador.

Más

https://docs.lootx.trade/es/loot/examples