Recetas y Patrones AST

Esta página muestra patrones AST reutilizables que puedes adaptar a tus propios comandos.

Buenas prácticas

Incrementa correctamente

Mal:

%(#wins 1)

Bien:

%(#wins *(%(#wins) + 1))

Inicializa antes de depender del valor

*(^(#wins) ? %(#wins) : 0)

Elige el almacenamiento correcto

• usa # o ## para datos temporales de 24h
• usa * o ** para datos permanentes de Premium / Pro

Mantén los bucles pequeños

• respeta los límites del plan
• usa $(break) si puedes salir antes

Usa contexto real para comandos EventSub

• las pruebas desde chat no representan del todo redemptions, cheers, raids o subs

Resumen de patrones

Patrón	Idea de sintaxis	Propósito
Inicializar-o-incrementar	*(^(**x) ? %(**x + 1) : %(**x 1))	Contador inteligente
Selector de usuario	%(**var(%(target)))	Leer o escribir estado de otro usuario
Guard check	*(^(**target) ? FAIL : ACT)	Evitar una acción si existe una condición
Side effect en ternaria	*(cond ? $(action) : "")	Ejecutar una acción dentro de una rama
Comparación anidada	*(a > b ? A_WIN : B_WIN)	Lógica de combate con varias ramas
Aritmética de estado	%(winner *(%(winner) - %(loser)))	Actualizar estado guardado con matemáticas

Receta 1: inicializar o incrementar

Este es uno de los patrones AST más comunes.

*( ^(**escudos) ? %(**escudos *(%(**escudos) + 1)) : %(**escudos 1) ) $(user) ha comprado un escudo, ahora tiene %(**escudos) escudos

Qué hace:

1. comprueba si **escudos existe
2. si existe, suma 1
3. si no existe, lo crea con valor 1
4. imprime el total final

Receta 2: guard check / rebote de escudos

Si el objetivo tiene escudos, el ataque rebota. Si no, el objetivo es baneado y pierde los escudos.

%(target $(reward.input))
*( ^(**escudos(%(target))) ?
    $(ban.mod $(user) 300 true) "¡%(target) tiene escudos! El ataque rebotó hacia %(user)."
:
    $(ban.mod %(target) 300 true)
    %(**escudos(%(target)) 0)
    "¡%(user) atacó y baneó a %(target)! Los escudos de %(target) se han perdido."
)

Ideas clave usadas aquí:

• guardar el input del evento en una variable local
• usar un selector de usuario para inspeccionar datos de otro usuario
• ejecutar una acción dentro de una rama ternaria
• resetear el estado después de la acción

Receta 3: batalla completa de escudos

Quien tenga más escudos gana. El perdedor es baneado. El ganador pierde una cantidad de escudos igual a los del perdedor.

%(attacker %(user))
%(defender $(reward.input))
*( ^(**escudos(%(defender))) ?
    *( ^(**escudos(%(attacker))) ?
        *( %(**escudos(%(attacker))) > %(**escudos(%(defender))) ?
            $(ban.mod %(defender) 300 true)
            %(**escudos(%(defender)) 0)
            %(**escudos(%(attacker)) *(%(**escudos(%(attacker))) - %(**escudos(%(defender)))))
            "¡%(attacker) gana! %(defender) baneado. %(attacker) ahora tiene %(**escudos(%(attacker))) escudos."
        :
            $(ban.mod %(attacker) 300 true)
            %(**escudos(%(attacker)) 0)
            %(**escudos(%(defender)) *(%(**escudos(%(defender))) - %(**escudos(%(attacker)))))
            "¡%(defender) gana! %(attacker) baneado. %(defender) ahora tiene %(**escudos(%(defender))) escudos."
        )
    : "¡%(defender) tiene escudos pero %(attacker) no tiene ninguno!"
:
    $(ban.mod %(defender) 300 true)
    "¡%(defender) no tiene escudos y fue baneado por %(user)!"
)

Por qué esto ya es avanzado:

• ternarias anidadas
• lectura del estado guardado de dos usuarios
• múltiples escrituras en una rama
• actualizaciones aritméticas basadas en el estado previo

Cómo construir tus propios sistemas

Cuando diseñes un comando AST avanzado, este orden suele funcionar bien:

1. define la entrada
2. decide qué estado necesitas guardar
3. define los guard checks
4. define la rama de éxito
5. define la rama de fallo
6. solo después añade side effects como bans, cambio de título o triggers

Buenos casos de uso para recetas AST

• sistemas de lealtad
• economías con contadores
• inventarios de coleccionables
• batallas entre viewers
• mini juegos activados por redemptions
• shoutouts dinámicos
• flujos automáticos de chat

Consejo

Si tu lógica empieza a ser difícil de leer, divide el sistema en más de un comando y usa referencias #(...) para que cada pieza sea más pequeña.