Variable de contexto
En Wired Code: variable.context
Declara una variable temporal: vive solo mientras la pila se está ejecutando y desaparece al terminar.
Cómo funciona
Es el bloc de notas del sistema. Sirve para guardar un cálculo intermedio —una suma a medias, un valor que hay que comparar dos veces— sin ensuciar los datos de la sala ni de los jugadores.
Como no se guarda en ningún sitio, es la más barata de todas y la que puedes usar sin pensártelo.
Hasta dónde llega
"Mientras la pila se está ejecutando" se queda corto, y esta es la parte que abre la mitad de los montajes avanzados: la variable acompaña a toda la cadena de señales que salga de esa pila.
Si la pila A declara motivo y manda una señal, la pila B que la recibe ve motivo. Y la que B
llame después, también. La cadena entera comparte el mismo bloc de notas.
Con Ejecuta Pilas la llamada también abre una rama, pero antes de que
corran los efectos de la pila que llama, no después como la señal. Por eso la pila llamada ve lo que
traía la que llama (lo que le llegó por la señal), pero no lo que esta declare: si la pila A da
motivo y llama a la C, C no lo ve. Tampoco al revés: lo que declare C se queda en C. Y si las dos dan
la misma variable, cada una tiene la suya.
Lo que no se comparte son las ramas hermanas. Si dos pilas escuchan la misma antena, cada una abre su propia rama: lo que declare una no lo ve la otra. Comparten lo que venía de antes, no lo que cada una añade.
Pila A declara motivo = 5
│
┌────┴────┐
▼ ▼
Pila B Pila C las dos ven motivo = 5
│
▼
Pila D también lo ve — viene de A por la rama de BPor un Link WIRED no viaja. La pila que recibe un mensaje o un dataframe empieza una ejecución nueva, aunque esté en la misma sala, y no ve las variables de contexto de la que lo envió. Si quieres pasar un valor, mándalo dentro de un dataframe: el Recibir Dataframe por Link lo guarda en una variable de contexto de la pila que recibe.
Las reglas de ámbito
De ahí salen cuatro comportamientos que conviene tener claros, porque son exactamente los de un lenguaje de programación con bloques:
| Lo que haces | Lo que pasa |
|---|---|
| Leer, o Contiene variable | Busca en esta pila; si no está, sube por la cadena |
| Dar variable sin sobrescribir | Si ya existe en cualquier punto de la cadena, no hace nada |
| Dar variable con sobrescribir | Declara una nueva aquí, que tapa la de arriba — y a partir de ese momento dejas de compartirla |
| Cambiar valor | Modifica la que encuentre subiendo. Si no existe en ningún punto, no la crea: no hace nada |
| Eliminar variable | Borra la que se ve. Si estaba arriba, las ramas hermanas también dejan de verla |
Sobrescribir es lo que rompe el vínculo
Es la línea fina que más cuesta. Si tu rama hace Cambiar valor, el cambio lo notan las demás porque estáis tocando la misma variable. Si hace Dar variable con sobrescribir, te acabas de fabricar una propia y las demás siguen con la vieja.
Cuando quieras que una rama trabaje con su copia sin molestar al resto, esa casilla es la respuesta. Cuando quieras que el resultado suba, no la marques.
Configuración
Nombre de la variable, cómo se llama.
Opciones de la variable, con Tiene valor.
Ejemplo
Calcular un premio antes de darlo:
Caja de variable:
Variable de contexto [premio · tiene valor]
Pila A
│
├─ Causante: Sobre un Furni
│ └─ Elige Furni ............................. Alfombra de la meta
│
├─ Efecto: Dar variable
│ ├─ Escoge una variable ..................... premio (variable de contexto)
│ └─ Valor inicial ........................... 100
│
├─ Efecto: Cambiar valor de variable
│ ├─ Escoge una variable ..................... premio (ámbito contexto)
│ ├─ Escoge una operación .................... Multiplicación
│ └─ Valor de referencia ..................... racha (variable de usuario)
│
└─ Efecto: Cambiar valor de variable
├─ Escoge una variable ..................... puntos (ámbito usuario)
├─ Escoge una operación .................... Suma
└─ Valor de referencia ..................... premio (variable de contexto)La caja solo declara el nombre: dentro de la ejecución premio no existe hasta que un Dar variable
la crea. Un Cambiar valor sobre una variable de contexto que nadie ha dado no hace nada (ver la tabla
de arriba), por eso el primer efecto de la pila es darla con su valor inicial.
Notas
No tiene opciones de disponibilidad porque no dura, y esa es toda su gracia: nada que limpiar, nada que se quede colgado entre partidas.
Es la que hay que usar para los cálculos. Guardar un valor intermedio en una variable permanente funciona, pero deja basura, cuesta más y se puede quedar a medias — mira la ejecución se puede cortar.
Y es la que hay que usar para pasar datos entre pilas. Con una variable de usuario tendrías que haber exactamente una persona en la cadena, y acordarte de borrarla después. De aquí salen las retrollamadas, y lo que pasa cuando una ejecución se abre en ramas está en Lo que vive durante la ejecución.
Y es la que apunta una Variable puntero. Si le das como valor el @id
de la caja de otra variable del mismo ámbito que el puntero en la pila que manda la señal, el puntero de
la pila que la recibe hace de esa variable. El puntero lee la de contexto al empezar la pila: dársela en la misma pila no lo apunta.