Diseño Narrativo
Editor de Condiciones
Usa el modo Constructor y el modo Código para definir condiciones reutilizables en flujos y respuestas, y el modo Constructor en zonas y pines.
El Editor de Condiciones define comprobaciones que leen variables y devuelven verdadero o falso. Storyarn usa el mismo editor en varios sitios:
| Dónde | Qué controla la condición |
|---|---|
| Nodos de Condición | Qué rama del flujo se ejecuta a continuación. |
| Respuestas de diálogo | Si una respuesta del jugador está disponible. |
| Zonas de escena | Si un área es visible o interactiva durante la exploración. |
| Pines de escena | Si un marcador, personaje o punto interactivo es visible o interactivo durante la exploración. |
Las condiciones solo leen variables. No cambian estado. Usa el Editor de Instrucciones cuando necesites escribir valores.
Modos de edición
Una condición de un nodo de Condición o de una respuesta de diálogo tiene dos modos de edición. Las zonas y los pines de escena editan sus condiciones solo en el modo Constructor.
| Modo | Mejor para | Qué editas |
|---|---|---|
| Modo Constructor | La mayoría de usuarios, lógica legible, revisión colaborativa | Bloques en forma de frase con variables, operadores, valores y grupos lógicos. |
| Modo Código | Perfiles técnicos, edición rápida, expresiones compactas | Una expresión de texto como mc.jaime.health > 50 && quest.door.unlocked. |
Los dos modos editan la misma condición. Abrir el modo Código la muestra como texto y no cambia nada. Lo que editas en el modo Código se lee de vuelta en los bloques y grupos que muestra el modo Constructor, y se guarda cuando dejas de escribir o sales del texto. Por ahora, un comentario (//) se rechaza: el modo Constructor no tiene dónde guardarlo.
Modo Constructor
El modo Constructor crea condiciones con bloques y reglas.
| Nivel | Propósito |
|---|---|
| Regla | Una comparación variable/operador/valor, como mc.jaime.health > 50. |
| Bloque | Un conjunto de reglas combinado con Todas (AND) o Alguna (OR). |
| Grupo | Un conjunto anidado de bloques seleccionados con su propia lógica Todas o Alguna. Los grupos funcionan como paréntesis. |
Una condición simple se lee como una frase:
mc.jaime · health es mayor que 50
Usa Agrupar seleccionados cuando un subconjunto de bloques deba evaluarse junto:
((mc.jaime.has_key) && (door.lock_level < 3)) || mc.jaime.is_admin
En el modo Constructor, agrupa el bloque de la llave y el del nivel de cerradura con Todas, y después combina ese grupo con el bloque de admin usando Alguna. El modo Código escribe cada bloque de un grupo entre sus propios paréntesis, como arriba.
Operadores por tipo de variable
| Tipo de variable | Operadores |
|---|---|
| Número / fórmula | es igual a, no es igual a, mayor que, mayor o igual que, menor que, menor o igual que |
| Texto / enriquecido | es igual a, no es igual a, contiene, empieza por, termina en, está vacío |
| Booleano | es verdadero, es falso, no está definido |
| Selección | es igual a, no es igual a, no está definido |
| Selección múltiple | contiene, no contiene, está vacío |
| Fecha | es igual a, no es igual a, antes de, después de |
Los operadores disponibles dependen del tipo de variable seleccionado, así que el modo Constructor evita comparaciones inválidas cuando puede.
Modo Código
El modo Código escribe la condición en la sintaxis de expresiones. Es útil cuando ya conoces las rutas de variables o cuando una expresión es más rápida de escribir que de montar en el modo Constructor.
mc.jaime.health > 50 && (quest.door.unlocked || mc.jaime.has_key)
Cada regla compara una variable, a la izquierda, con un valor:
| Modo Constructor | Modo Código |
|---|---|
| es igual a, no es igual a | mc.jaime.class == "rogue", mc.jaime.class != "rogue" |
| mayor que, menor que, … | >, >=, <, <= |
| contiene, no contiene | mc.jaime.traits contains "brave", not_contains |
| empieza por, termina en | mc.jaime.name starts_with "Ja", ends_with |
| está vacío | mc.jaime.notes is_empty |
| es verdadero, es falso | quest.door.unlocked, !quest.door.unlocked |
| no está definido | mc.jaime.weapon == nil |
| antes de, después de | quest.deadline before "2026-01-01", after |
Los números se escriben tal cual, como 50, -5 o 0.5. Cualquier otro valor va entre comillas dobles, con \" para una comilla y \\ para una barra invertida dentro. Una regla que aún no tiene valor muestra ?: escribe el valor ahí. El modo Código también lee == true y == false como es verdadero y es falso, y != true y != false como sus opuestos.
&& (todas) se aplica antes que || (alguna), y los paréntesis contienen los bloques y grupos del modo Constructor:
- Una regla sola es un bloque con esa regla:
mc.jaime.alive && mc.jaime.health > 50son dos bloques. - Unos paréntesis alrededor de reglas unidas solo con
&&o solo con||son un bloque:(mc.jaime.has_key || mc.jaime.is_admin). - Unos paréntesis alrededor de paréntesis, o de reglas que mezclan
&&y||, son un grupo:((mc.jaime.has_key && door.lock_level < 3) || (mc.jaime.is_admin)).
El modo Constructor admite bloques dentro de grupos, sin más niveles, así que el modo Código rechaza más niveles de paréntesis.
! convierte la comprobación que le sigue en su opuesta, comparación incluida: !(mc.jaime.health > 50) y !mc.jaime.health > 50 son los dos mc.jaime.health <= 50, y !(a.x && a.y) es !a.x || !a.y. El modo Constructor no tiene opuesto de empieza por, termina en, está vacío, no está definido, antes de y después de, ni de una comprobación que el tipo de la variable perdería, como contiene en un texto, así que el modo Código no permite negarlos. nil solo se compara con ==, así que también se rechaza != nil.
Una comprobación sobre un valor que no está definido falla, y su opuesta también: mientras un booleano de tres estados no tiene valor, no se cumple ni quest.door.unlocked ni !quest.door.unlocked, y mientras una fórmula no se puede calcular, no se cumple ni mc.jaime.power == 5 ni !(mc.jaime.power == 5).
Lo que el modo Constructor no puede guardar se rechaza con un mensaje donde está escrito, y no se guarda nada hasta que la expresión se lee: un valor a la izquierda, un valor solo, una comparación entre dos variables o un comentario. El modo Código ofrece autocompletado, linting y formato. Usa el formato después de editar una expresión larga para que los paréntesis y grupos lógicos sigan siendo legibles.
Mientras el modo Constructor tenga algo que la sintaxis no puede escribir, como una regla sin variable, un bloque o grupo vacío, o un nombre de variable que la sintaxis no puede escribir, el modo Código muestra la condición en solo lectura y lo indica. Complétalo o cámbialo en el modo Constructor para editar la condición en el modo Código.
Nodos de condición y modo switch
El editor es compartido, pero algunas funciones dependen del sitio donde se usa la condición.
Los nodos de Condición pueden usar modo de salida Booleano o Switch. En modo switch, cada bloque de condición se convierte en una rama de salida y gana el primer bloque que coincida. Un switch se edita solo en el modo Constructor: cada caso tiene un nombre y una salida, que el modo Código no puede escribir. Las respuestas de diálogo, zonas y pines no usan salidas switch; usan la condición como puerta de acceso.