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 pasa lo mismo, y de forma aún más directa: la llamada corre dentro de la misma ejecución.

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 B

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.