# Recetas y Patrones AST

Buenas prácticas y patrones AST avanzados, incluyendo contadores, guard checks, selectores de usuario y sistemas de escudos.

Source: https://docs.domdimabot.com/es/commands/advanced/recipes/
Language: es
Documentation index: https://docs.domdimabot.com/llms.txt

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

## Buenas prácticas

### Incrementa correctamente

Mal:

```bash
%(#wins 1)
```

Bien:

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

### Inicializa antes de depender del valor

```bash
*(^(#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.

```bash
*( ^(**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.

```bash
%(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.

```bash
%(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

> tip:
>
> 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.