-
Notifications
You must be signed in to change notification settings - Fork 0
Scripting
Sergi edited this page Jan 1, 2026
·
1 revision
Guia completa del sistema de programacion visual de XiloAdventures
El sistema de scripts permite crear comportamientos complejos sin escribir codigo, conectando nodos visuales que representan eventos, condiciones y acciones. XiloAdventures incluye mas de 50 tipos de nodos organizados en categorias.
+---------+ +---------+ +---------+
| Verde |---->| Amarillo|---->| Azul |
| Evento | |Condicion| | Accion |
+---------+ +---------+ +---------+
Ejemplo conceptual - Script basico:
Cuando el jugador entra en la taberna:
Si tiene la mision "buscar_pista" activa:
Mostrar mensaje: "El tabernero te mira con interes"
Si no:
Mostrar mensaje: "La taberna esta tranquila"
+------------------------------------------------------------------+
| Script: [Dropdown] [Nombre del script] [Eliminar] |
+---------+--------------------------------+-----------------------+
| | | Paleta de Nodos |
| Arbol | Canvas de Nodos +-----------------------+
| de | | Diagnostico |
| Entidad.| +-----------------------+
| | | Propiedades |
| | | |
+---------+--------------------------------+-----------------------+
- Lista jerarquica de todas las entidades del juego
-
Colores de estado:
- Blanco: Sin script
- Amarillo: Script incompleto
- Verde: Script valido
- Buscador para filtrar entidades
Ejemplo de uso:
Para crear un script para la puerta del castillo:
1. Expande "Puertas" en el arbol de entidades
2. Haz clic en "puerta_castillo"
3. Aparece "(Sin script)" junto al nombre
4. Arrastra un nodo evento al canvas
5. El color cambia a amarillo (incompleto)
6. Conecta nodos de accion
7. El color cambia a verde (valido)
Nodos organizados por categorias:
| Color | Categoria | Ejemplo de uso |
|---|---|---|
| Verde | Eventos (puntos de entrada) | Al entrar en sala, al usar objeto |
| Morado | Dialogo (conversaciones) | NPC dice, opciones del jugador |
| Amarillo | Condiciones (bifurcaciones) | Tiene objeto?, esta en sala? |
| Azul | Acciones (efectos) | Dar objeto, mover NPC |
| Gris | Control de flujo | Secuencia, bifurcacion, espera |
| Naranja | Variables y datos | Obtener oro, operaciones matematicas |
Ejemplo de arrastrar nodos:
1. En la paleta, localiza "Eventos > Al Entrar"
2. Arrastra el nodo al canvas (aparece en verde)
3. Localiza "Acciones > Mostrar Mensaje"
4. Arrastra al canvas a la derecha del evento
5. Conecta el puerto blanco del evento al puerto blanco de la accion
6. Escribe el mensaje en el panel de Propiedades
Validacion en tiempo real:
| Estado | Mensaje | Solucion |
|---|---|---|
| Valido | Script valido | Listo para usar |
| Advertencia | Falta nodo de evento | Anadir un evento como punto de entrada |
| Advertencia | Falta nodo de accion | Anadir al menos una accion |
| Error | Propiedades incompletas | Completar los campos requeridos |
| Error | Conexion invalida | Revisar tipos de puertos |
Ejemplo de diagnostico:
Diagnostico muestra:
[!] Falta nodo de evento
Solucion:
Arrastra "Al Entrar" o cualquier evento verde al canvas
Nuevo diagnostico:
[!] Falta nodo de accion
Solucion:
Arrastra "Mostrar Mensaje" y conectalo al evento
Nuevo diagnostico:
[!] Propiedad "Mensaje" esta vacia
Solucion:
Selecciona el nodo y escribe el mensaje en Propiedades
Diagnostico final:
[OK] Script valido
Edita las propiedades del nodo seleccionado:
| Tipo de control | Ejemplo | Como usarlo |
|---|---|---|
| Campo de texto | Mensaje | Escribe directamente |
| Campo numerico | Cantidad | Escribe un numero o usa flechas |
| Checkbox | Visible | Marca o desmarca |
| Desplegable | Estado de mision | Selecciona de la lista |
| Selector de entidad | Puerta | Haz clic y elige de la lista |
Ejemplo de editar propiedades:
Nodo seleccionado: "Dar Objeto"
Panel de Propiedades muestra:
Objeto: [Seleccionar...] <- Haz clic aqui
Aparece lista:
- espada_oxidada
- pocion_vida
- llave_mazmorra
Selecciona "llave_mazmorra"
El nodo ahora muestra "Dar: llave_mazmorra"
| Accion | Control |
|---|---|
| Anadir nodo | Arrastrar desde paleta |
| Seleccionar | Clic en nodo |
| Seleccion multiple |
Ctrl + Clic |
| Seleccionar area | Arrastrar rectangulo |
| Mover nodo | Arrastrar nodo |
| Conectar | Arrastrar de puerto a puerto |
| Eliminar conexion | Clic derecho en conexion |
| Zoom | Rueda del raton |
| Desplazar | Boton central + arrastrar |
| Eliminar | Delete |
Ejemplo de conexion de nodos:
Para conectar "Al Entrar" con "Mostrar Mensaje":
1. Pasa el cursor sobre el puerto blanco de salida de "Al Entrar"
(aparece un circulo brillante)
2. Haz clic y mantén presionado
3. Arrastra hacia el puerto blanco de entrada de "Mostrar Mensaje"
4. Suelta cuando el puerto destino se ilumine
5. Aparece una linea blanca conectando ambos nodos
| Atajo | Funcion |
|---|---|
G |
Mostrar/ocultar cuadricula |
H |
Activar/desactivar snap (alineacion automatica) |
F |
Centrar vista en nodos |
Ctrl+A |
Seleccionar todo |
Ctrl+C |
Copiar nodos |
Ctrl+X |
Cortar nodos |
Ctrl+V |
Pegar nodos |
Ctrl+Z |
Deshacer |
Ctrl+Y |
Rehacer |
Delete |
Eliminar seleccion |
Escape |
Limpiar seleccion |
Ejemplo de copiar scripts:
Para reutilizar una secuencia de nodos:
1. Selecciona los nodos con Ctrl+clic o rectangulo
2. Pulsa Ctrl+C para copiar
3. Navega a otra entidad en el arbol
4. Pulsa Ctrl+V para pegar
5. Ajusta las propiedades segun sea necesario
Controlan el flujo del script - determinan el orden en que se ejecutan los nodos:
+---------+ +---------+
| Evento |---->>----| Accion |
+---------+ +---------+
Puerto Puerto
salida entrada
- Un nodo puede tener multiples salidas (ej: condicion True/False)
- Cada entrada acepta una o mas conexiones
- El flujo sigue las flechas de izquierda a derecha
Ejemplo de flujo de ejecucion:
[Al Entrar] ---> [Tiene llave?] --True--> [Abrir puerta]
|
+---False--> [Mostrar "Necesitas la llave"]
El flujo:
1. Jugador entra en la sala
2. Se verifica si tiene la llave
3a. Si la tiene: se abre la puerta
3b. Si no la tiene: se muestra el mensaje
Transmiten valores entre nodos - numeros, booleanos o texto:
+-------------+ +-------------+
| Obtener Oro |----o----o| Comparar |
+-------------+ | +-------------+
Puerto Valor Puerto
datos (100) datos
- Tipos:
int(numeros),bool(verdadero/falso),string(texto) - Solo conectan tipos compatibles
- El valor fluye cuando el nodo destino lo necesita
Ejemplo de conexion de datos:
Para verificar si el jugador tiene mas de 50 de oro:
[Obtener Oro del Jugador] ---- valor int ----> [Comparar Enteros]
|
[Constante: 50] ----------- valor int -------> A > B?
|
resultado bool
|
v
[Bifurcacion]
True / False
Los eventos son los puntos de entrada de los scripts. Detectan cuando algo sucede en el juego.
Para scripts globales que afectan a todo el mundo.
| Nodo | Descripcion | Salidas |
|---|---|---|
| Event_OnGameStart | Se ejecuta al empezar nueva partida | Exec |
| Event_OnGameEnd | Se ejecuta al finalizar el juego | Exec |
| Event_EveryMinute | Se ejecuta cada minuto de tiempo de juego | Exec |
| Event_EveryHour | Se ejecuta cada hora de tiempo de juego | Exec |
| Event_OnTurnStart | Se ejecuta en cada turno del jugador | Exec, TurnNumber (int) |
| Event_OnWeatherChange | Se ejecuta cuando cambia el clima | Exec, NewWeather (string) |
Ejemplo 1 - Mensaje de bienvenida al iniciar:
[Al Iniciar Juego]
|
v
[Mostrar Mensaje: "Bienvenido a las Tierras de Xilo.
Tu aventura comienza ahora..."]
|
v
[Dar Objeto: "mapa_antiguo"]
|
v
[Establecer Flag: "juego_iniciado" = true]
Resultado: Al empezar nueva partida, el jugador recibe
un mensaje de bienvenida, el mapa antiguo, y se activa
un flag para saber que ya inicio.
Ejemplo 2 - Sistema de hambre cada hora:
[Cada Hora]
|
v
[Incrementar Contador: "hambre" +1]
|
v
[Comparar Contador: "hambre" >= 5]
|
+---+---+
v v
True False
|
v
[Mostrar Mensaje: "Tienes mucha hambre. Deberias comer algo."]
|
v
[Reproducir Sonido: "gruñido_estomago"]
Resultado: Cada hora de juego aumenta el hambre.
Cuando llega a 5 o mas, avisa al jugador.
Ejemplo 3 - Eventos climaticos:
[Al Cambiar Clima] --> (Nuevo clima: tormenta?)
| |
v +---+---+
[Obtener clima] -------> Si No
|
v
[Mostrar: "Los rayos iluminan el cielo"]
|
v
[Reproducir Sonido: "trueno"]
Resultado: Cuando el clima cambia a tormenta,
se muestra un mensaje atmosferico y suena un trueno.
Para scripts asociados a habitaciones especificas.
| Nodo | Descripcion | Salidas |
|---|---|---|
| Event_OnEnter | Jugador entra en la sala | Exec |
| Event_OnExit | Jugador sale de la sala | Exec, Direction (string) |
Ejemplo 1 - Primera visita a una sala:
[Al Entrar]
|
v
[Tiene Flag: "visito_biblioteca"]
|
+---+---+
v v
Si No
|
v
[Mostrar: "Entras en la antigua biblioteca.
El olor a pergamino viejo te envuelve."]
|
v
[Establecer Flag: "visito_biblioteca" = true]
|
v
[Dar Objeto: "nota_misteriosa"]
Resultado: Solo la primera vez que entra muestra
la descripcion especial y da la nota.
Ejemplo 2 - Trampa al salir:
[Al Salir]
|
v
[Probabilidad: 30%]
|
+---+---+
v v
Si No
|
v
[Mostrar: "Una piedra cae del techo detras de ti!"]
|
v
[Reproducir Sonido: "roca_cayendo"]
Resultado: 30% de probabilidad de que caiga
una piedra al salir de la sala.
Ejemplo 3 - Detectar direccion de salida:
[Al Salir] --> Direccion: "norte"?
| |
v +---+---+
[Comparar Si No
direccion] |
v
[Mostrar: "Te diriges hacia las montañas heladas.
El frio se hace mas intenso."]
Resultado: Mensaje especial solo cuando
el jugador sale hacia el norte.
Para scripts asociados a puertas especificas.
| Nodo | Descripcion | Salidas |
|---|---|---|
| Event_OnDoorOpen | La puerta se abre | Exec |
| Event_OnDoorClose | La puerta se cierra | Exec |
| Event_OnDoorLock | La puerta se cierra con llave | Exec |
| Event_OnDoorUnlock | La puerta se abre con llave | Exec |
| Event_OnDoorKnock | El jugador llama/golpea la puerta | Exec |
Ejemplo 1 - Puerta chirriante:
[Al Abrir Puerta]
|
v
[Reproducir Sonido: "chirrido_puerta"]
|
v
[Mostrar: "La vieja puerta se abre con un largo chirrido."]
Resultado: Efecto de sonido atmosferico al abrir.
Ejemplo 2 - Llamar a una puerta:
[Al Llamar Puerta]
|
v
[Probabilidad: 50%]
|
+---+---+
v v
Si No
| |
v v
[Mostrar: "Una voz [Mostrar: "Nadie
responde: 'Quien es?'"] responde..."]
|
v
[Establecer Flag: "alguien_en_casa" = true]
Resultado: 50% de que alguien responda al llamar.
Ejemplo 3 - Puerta secreta:
[Al Desbloquear Puerta]
|
v
[Mostrar: "La pared se desliza revelando un pasaje oculto!"]
|
v
[Reproducir Sonido: "piedra_deslizando"]
|
v
[Establecer Flag: "pasaje_descubierto" = true]
|
v
[Iniciar Mision: "explorar_pasaje"]
Resultado: Al desbloquear, se revela dramaticamente
el pasaje y comienza una nueva mision.
Para scripts de personajes no jugables.
| Nodo | Descripcion | Salidas |
|---|---|---|
| Event_OnTalk | El jugador inicia conversacion | Exec |
| Event_OnNpcAttack | El jugador ataca al NPC | Exec |
| Event_OnNpcDeath | El NPC muere | Exec |
| Event_OnNpcSee | El NPC ve al jugador en su sala | Exec |
Ejemplo 1 - NPC que saluda:
[Al Hablar]
|
v
[Tiene Flag: "conoce_jugador"]
|
+---+---+
v v
Si No
| |
v v
[NPC dice: [NPC dice: "Bienvenido, extranjero.
"Hola de Soy Marcus, el herrero."]
nuevo!"] |
v
[Establecer Flag: "conoce_jugador" = true]
Resultado: El NPC recuerda si ya conoce al jugador.
Ejemplo 2 - NPC que detecta al jugador:
[Al Ver Jugador]
|
v
[Tiene Flag: "es_enemigo"]
|
+---+---+
v v
Si No
| |
v v
[Mostrar: [Mostrar: "El guardia
"El guardia te saluda con la cabeza."]
grita: 'Alto!'"]
|
v
[Bloquear Puerta: "puerta_salida"]
Resultado: Si eres enemigo, el guardia reacciona hostilmente.
Ejemplo 3 - NPC que muere y deja objetos:
[Al Morir NPC]
|
v
[Mostrar: "El goblin cae derrotado con un alarido."]
|
v
[Dar Objeto: "monedas_goblin"]
|
v
[Probabilidad: 25%]
|
+---+---+
v v
Si No
|
v
[Dar Objeto: "daga_oxidada"]
[Mostrar: "Encuentras una daga entre sus pertenencias."]
Resultado: Siempre deja monedas, 25% de
probabilidad de dejar una daga extra.
Para scripts asociados a objetos del juego.
| Nodo | Descripcion | Salidas |
|---|---|---|
| Event_OnTake | El jugador toma el objeto | Exec |
| Event_OnDrop | El jugador suelta el objeto | Exec |
| Event_OnUse | El jugador usa el objeto | Exec |
| Event_OnExamine | El jugador examina el objeto | Exec |
| Event_OnEquip | El jugador equipa el objeto | Exec |
| Event_OnUnequip | El jugador desequipa el objeto | Exec |
| Event_OnContainerOpen | Se abre el contenedor | Exec |
| Event_OnContainerClose | Se cierra el contenedor | Exec |
Ejemplo 1 - Objeto maldito:
[Al Coger]
|
v
[Mostrar: "Al tocar el amuleto, sientes un escalofrio."]
|
v
[Establecer Flag: "maldicion_activa" = true]
|
v
[Reproducir Sonido: "susurro_siniestro"]
Resultado: Coger el amuleto activa una maldicion.
Ejemplo 2 - Usar pocion:
[Al Usar]
|
v
[Mostrar: "Bebes la pocion de vida.
Te sientes revigorizado!"]
|
v
[Reproducir Sonido: "beber_pocion"]
|
v
[Quitar Objeto: "pocion_vida"] <-- Se consume
|
v
[Establecer Flag: "curado" = true]
Resultado: La pocion se consume al usarla y cura al jugador.
Ejemplo 3 - Examinar objeto con pista:
[Al Examinar]
|
v
[Mostrar: "Es un viejo libro de hechizos.
En la primera pagina lees: 'La palabra clave es XILO'."]
|
v
[Tiene Flag: "pista_revelada"]
|
+---+---+
v v
Si No
|
v
[Establecer Flag: "pista_revelada" = true]
|
v
[Mostrar: "*Anotas la palabra en tu diario*"]
Resultado: Examinar el libro revela una pista importante.
Ejemplo 4 - Cofre con trampa:
[Al Abrir Contenedor]
|
v
[Tiene Flag: "trampa_desactivada"]
|
+---+---+
v v
Si No
| |
v v
[Mostrar: [Mostrar: "Al abrir el cofre,
"El cofre una aguja te pincha!"]
se abre |
sin v
problemas."] [Quitar Oro: 20]
|
v
[Mostrar: "Pierdes 20 monedas
intentando curar la herida."]
Resultado: El cofre tiene una trampa que
cuesta oro si no la desactivas primero.
Ejemplo 5 - Equipar armadura maldita:
[Al Equipar]
|
v
[Mostrar: "Al ponerte la armadura, sientes un frio sobrenatural."]
|
v
[Establecer Flag: "armadura_maldita_equipada" = true]
|
v
[Reproducir Sonido: "susurro_oscuro"]
Resultado: Al equipar el objeto se activa un efecto.
Ejemplo 6 - Desequipar objeto especial:
[Al Desequipar]
|
v
[Tiene Flag: "armadura_maldita_equipada"]
|
+---+---+
v v
Si No
|
v
[Mostrar: "Sientes un alivio al quitarte la armadura maldita."]
|
v
[Establecer Flag: "armadura_maldita_equipada" = false]
Resultado: Detecta cuando el jugador se quita un objeto especifico.
Para scripts de seguimiento de misiones.
| Nodo | Descripcion | Salidas |
|---|---|---|
| Event_OnQuestStart | La mision comienza | Exec |
| Event_OnQuestComplete | La mision se completa | Exec |
| Event_OnQuestFail | La mision falla | Exec |
| Event_OnObjectiveComplete | Un objetivo se completa | Exec, ObjectiveIndex (int) |
Ejemplo 1 - Inicio de mision:
[Al Iniciar Mision]
|
v
[Mostrar: "NUEVA MISION: El Tesoro Perdido
Encuentra el mapa en la biblioteca."]
|
v
[Reproducir Sonido: "mision_aceptada"]
|
v
[Visibilidad NPC: "informante" = true]
Resultado: Al aceptar la mision, aparece un NPC informante.
Ejemplo 2 - Completar mision:
[Al Completar Mision]
|
v
[Mostrar: "MISION COMPLETADA: El Tesoro Perdido
Has encontrado el legendario tesoro!"]
|
v
[Dar Oro: 500]
|
v
[Dar Objeto: "medalla_aventurero"]
|
v
[Reproducir Sonido: "fanfarria"]
Resultado: Recompensa generosa al completar.
Ejemplo 3 - Objetivos parciales:
[Al Completar Objetivo] --> Indice del objetivo
|
v
[El indice es 0?] (Primer objetivo)
|
+---+---+
v v
Si No
| |
v v
[Mostrar: [El indice es 1?] (Segundo objetivo)
"Objetivo |
1 completado: +---+---+
Encontrar el v v
mapa."] Si No
|
v
[Mostrar: "Objetivo 2 completado:
Descifrar las runas."]
Resultado: Mensaje diferente segun que objetivo se complete.
Las condiciones bifurcan el flujo segun se cumplan o no. Tienen dos salidas: True (Si) y False (No).
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Condition_HasItem | ObjectId |
Tiene el jugador este objeto? |
Ejemplo - Puerta que requiere llave:
[Al Intentar Abrir Puerta]
|
v
[Tiene Objeto: "llave_mazmorra"]
|
+---+---+
v v
True False
| |
v v
[Abrir [Mostrar: "La puerta esta cerrada.
Puerta: Necesitas una llave."]
"puerta_
mazmorra"]
Resultado: Solo abre si tiene la llave especifica.
Ejemplo - Multiples llaves:
[Al Usar en Puerta]
|
v
[Tiene Objeto: "llave_maestra"]
|
+---+---+
v v
True False
| |
v +---> [Tiene Objeto: "llave_normal"]
| |
| +---+---+
| v v
| True False
| | |
+------------------+ v
| [Mostrar: "Ninguna
v de tus llaves funciona."]
[Abrir Puerta]
|
v
[Mostrar: "Click. La puerta se abre."]
Resultado: La llave maestra o la normal funcionan.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Condition_IsInRoom | RoomId |
Esta el jugador en esta sala? |
Ejemplo - NPC que solo actua en su tienda:
[Cada Turno]
|
v
[Esta en Sala: "tienda_armas"]
|
+---+---+
v v
True False
|
v
[Probabilidad: 10%]
|
+---+---+
v v
Si No
|
v
[Mostrar: "El herrero dice: 'Las mejores
armas de la region, aqui mismo!'"]
Resultado: Solo en la tienda, ocasionalmente
el herrero promociona sus productos.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Condition_IsQuestStatus |
QuestId, Status
|
La mision tiene este estado? |
Estados disponibles: NotStarted, InProgress, Completed, Failed
Ejemplo - NPC que da mision:
[Al Hablar]
|
v
[Estado Mision: "rescatar_princesa" = NotStarted]
|
+---+---+
v v
True False
| |
v +---> [Estado Mision: "rescatar_princesa" = InProgress]
[NPC dice: |
"La princesa +---+---+
ha sido v v
capturada! True False
Puedes | |
ayudar?"] v +---> [Estado Mision: ... = Completed]
| [NPC dice: |
v "Aun no la +---+---+
[Iniciar has rescatado? v v
Mision: Date prisa!"] True False
"rescatar_ |
princesa"] v
[NPC dice: "Gracias
por salvar a mi hija!"]
|
v
[Dar Oro: 1000]
Resultado: El NPC recuerda el progreso de la mision.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Condition_HasFlag | FlagName |
El flag esta activo? |
| Condition_CompareCounter |
CounterName, Operator, Value
|
Comparar valor de contador |
Operadores disponibles: ==, !=, <, <=, >, >=
Ejemplo - Flag para evitar repeticion:
[Al Entrar en Sala]
|
v
[Tiene Flag: "vio_fantasma"]
|
+---+---+
v v
True False
| |
v v
(nada) [Mostrar: "Un fantasma aparece
frente a ti y desaparece!"]
|
v
[Reproducir Sonido: "aullido"]
|
v
[Establecer Flag: "vio_fantasma" = true]
Resultado: El fantasma solo aparece la primera vez.
Ejemplo - Sistema de reputacion con contador:
[Al Completar Mision]
|
v
[Incrementar Contador: "reputacion" +10]
|
v
[Comparar Contador: "reputacion" >= 50]
|
+---+---+
v v
True False
|
v
[Tiene Flag: "titulo_heroe"]
|
+---+---+
v v
Si No
|
v
[Mostrar: "Tu fama se extiende por el reino.
Ahora te conocen como 'El Heroe'!"]
|
v
[Establecer Flag: "titulo_heroe" = true]
Resultado: Al llegar a 50 de reputacion,
se otorga un titulo (solo una vez).
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Condition_IsTimeOfDay | TimeRange |
Es este periodo del dia? |
Periodos: Manana (6-11), Tarde (12-17), Noche (18-23), Madrugada (0-5)
Ejemplo - Tienda con horario:
[Al Hablar con Tendero]
|
v
[Es Hora del Dia: "Manana"]
|
+---+---+
v v
True False
| +---> [Es Hora del Dia: "Tarde"]
| |
| +---+---+
| v v
| True False
| | |
+------------------+ v
| [NPC dice: "La tienda
v esta cerrada. Vuelve
[Abrir Tienda] por la manana."]
Resultado: La tienda solo abre de manana y tarde.
Ejemplo - Evento nocturno:
[Cada Hora]
|
v
[Es Hora del Dia: "Noche"]
|
+---+---+
v v
True False
|
v
[Probabilidad: 20%]
|
+---+---+
v v
Si No
|
v
[Mostrar: "Escuchas aullidos a lo lejos..."]
|
v
[Reproducir Sonido: "lobo_aullando"]
Resultado: De noche, ocasionalmente se escuchan lobos.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Condition_IsDoorOpen | DoorId |
La puerta esta abierta? |
| Condition_IsNpcVisible | NpcId |
El NPC es visible? |
| Condition_IsPatrolling | NpcId |
El NPC esta patrullando? |
| Condition_IsFollowingPlayer | NpcId |
El NPC esta siguiendo al jugador? |
Ejemplo - Puerta que debe estar abierta:
[Al Intentar Salir al Norte]
|
v
[Puerta Abierta: "porton_principal"]
|
+---+---+
v v
True False
| |
v v
(permite [Mostrar: "El porton esta cerrado.
salir) Debes abrirlo primero."]
Resultado: Bloquea el movimiento si la puerta esta cerrada.
Ejemplo - Verificar si el guardian te sigue:
[Al Entrar en Zona Peligrosa]
|
v
[NPC Siguiendo: "guardian"]
|
+---+---+
v v
True False
| |
v v
[Mostrar: [Mostrar: "Es peligroso
"El ir solo aqui.
guardian Busca un aliado."]
te protege |
mientras v
avanzas."] [Teletransportar: "entrada_zona"]
Resultado: Sin acompanante, te devuelve a la entrada.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Condition_PlayerHasEquipped |
ObjectId, Slot
|
Tiene el jugador este objeto equipado? |
| Condition_NpcHasEquipped |
NpcId, ObjectId, Slot
|
Tiene el NPC este objeto equipado? |
| Condition_IsPlayerSlotEmpty | Slot |
El slot del jugador esta vacio? |
Slots disponibles: RightHand, LeftHand, Torso, Head, Any
Ejemplo - Verificar arma equipada:
[Al Atacar]
|
v
[Jugador Tiene Equipado: slot="RightHand"]
|
+---+---+
v v
True False
| |
v v
[Calcular [Mostrar: "No tienes un arma equipada.
dano con Usa 'equipar' primero."]
bonificacion]
Resultado: Solo permite atacar con bonificacion si tiene arma equipada.
Ejemplo - NPC con armadura especial:
[Al Atacar NPC]
|
v
[NPC Tiene Equipado: npc="guardian", slot="Torso"]
|
+---+---+
v v
True False
| |
v v
[Mostrar: [Mostrar: "Tu golpe
"La armadura impacta de
del guardian lleno!"]
detiene |
parte del v
golpe!"] [Dano completo]
|
v
[Dano reducido]
Resultado: El NPC con armadura recibe menos dano.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Condition_IsObjectLit | ObjectId |
El objeto luminoso esta encendido? |
| Condition_IsRoomLit | - | La sala actual esta iluminada? |
Ejemplo - Verificar antorcha encendida:
[Al Entrar en Cueva Oscura]
|
v
[Objeto Encendido: "antorcha_jugador"]
|
+---+---+
v v
True False
| |
v v
[Mostrar: [Mostrar: "Esta muy oscuro.
"La No puedes ver nada."]
antorcha |
ilumina v
el camino."] [Teletransportar: "entrada_cueva"]
Resultado: Necesitas luz para explorar la cueva.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Condition_Random |
Probability (0-100) |
Probabilidad de exito |
Ejemplo - Encuentro aleatorio:
[Al Entrar en Bosque]
|
v
[Probabilidad: 25%]
|
+---+---+
v v
True False
| |
v v
[Mostrar: [Mostrar: "El bosque
"Un lobo esta tranquilo."]
salvaje
te ataca!"]
|
v
[Visibilidad NPC: "lobo_salvaje" = true]
|
v
[Mover NPC: "lobo_salvaje" -> sala actual]
Resultado: 25% de encuentro con un lobo cada vez que entras.
Las acciones hacen que sucedan cosas en el juego.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_ShowMessage | Message |
Muestra texto al jugador |
Ejemplo - Mensaje atmosferico:
[Al Entrar en Cripta]
|
v
[Mostrar Mensaje: "El aire es frio y humedo.
Antorchas titilantes iluminan viejas tumbas.
Un escalofrio recorre tu espalda."]
Resultado: Descripcion inmersiva de la sala.
Ejemplo - Mensajes secuenciales:
[Al Usar Cristal]
|
v
[Secuencia]
| | |
v v v
1 2 3
| | |
v v v
[Mostrar: [Esperar 2s] [Mostrar:
"El cristal "Una vision
brilla aparece ante
intensamente..."] tus ojos!"]
Resultado: Pausa dramatica entre mensajes.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_GiveItem | ObjectId |
Anade objeto al inventario |
| Action_RemoveItem | ObjectId |
Quita objeto del inventario |
Ejemplo - Intercambio de objetos:
[Al Hablar con Alquimista]
|
v
[Tiene Objeto: "ingredientes_pocion"]
|
+---+---+
v v
True False
| |
v v
[Quitar [NPC dice: "Trae los
Objeto: ingredientes y te
"ingredientes preparare algo especial."]
_pocion"]
|
v
[Dar Objeto: "pocion_fuerza"]
|
v
[Mostrar: "El alquimista prepara una pocion
y te la entrega."]
Resultado: Cambia ingredientes por pocion terminada.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_AddGold | Amount |
Suma oro al jugador |
| Action_RemoveGold | Amount |
Resta oro al jugador |
| Action_SetGold |
Amount (puerto) |
Fija el oro a un valor especifico |
Ejemplo - Sistema de recompensas:
[Al Completar Mision: "matar_dragon"]
|
v
[Dar Oro: 1000]
|
v
[Mostrar: "El rey te recompensa con 1000 monedas de oro!"]
|
v
[Comparar Oro >= 5000]
|
+---+---+
v v
True False
|
v
[Mostrar: "Con esta fortuna podrias comprar una casa."]
Resultado: Recompensa + comentario si eres muy rico.
Ejemplo - Peaje para cruzar puente:
[Al Intentar Cruzar Puente]
|
v
[Comparar Oro >= 10]
|
+---+---+
v v
True False
| |
v v
[Quitar [Mostrar: "El guardian dice:
Oro: 10] 'Necesitas 10 monedas para cruzar.'"]
| |
v v
[Mostrar: [Teletransportar: sala_anterior]
"Pagas el
peaje."]
|
v
(permite pasar)
Resultado: Cobra peaje o impide el paso.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_TeleportPlayer | RoomId |
Teletransporta al jugador |
Ejemplo - Portal magico:
[Al Usar Portal]
|
v
[Mostrar: "El portal brilla y te absorbe..."]
|
v
[Reproducir Sonido: "magia_portal"]
|
v
[Esperar: 1 segundo]
|
v
[Teletransportar: "torre_mago"]
|
v
[Mostrar: "Apareces en la torre del mago."]
Resultado: Teletransporte con efectos.
Ejemplo - Trampa que te envia a prision:
[Al Pisar Trampa]
|
v
[Mostrar: "El suelo cede bajo tus pies!"]
|
v
[Esperar: 0.5 segundos]
|
v
[Teletransportar: "celda_prision"]
|
v
[Bloquear Puerta: "reja_celda"]
|
v
[Quitar Objeto: "espada"] (te desarman)
|
v
[Mostrar: "Despiertas en una celda oscura.
Tus armas han desaparecido."]
Resultado: Trampa elaborada con consecuencias.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_MoveNpc |
NpcId, RoomId
|
Mueve NPC a otra sala |
| Action_SetNpcVisible |
NpcId, Visible
|
Muestra/oculta NPC |
| Action_FollowPlayer |
NpcId, Speed
|
El NPC sigue al jugador |
| Action_StopFollowing | NpcId |
El NPC deja de seguir |
| Action_StartPatrol | NpcId |
El NPC comienza su patrulla |
| Action_StopPatrol | NpcId |
El NPC detiene su patrulla |
Ejemplo - NPC que aparece:
[Al Completar Puzzle]
|
v
[Visibilidad NPC: "fantasma_guia" = true]
|
v
[Mover NPC: "fantasma_guia" -> sala_actual]
|
v
[Mostrar: "Un espiritu se materializa frente a ti.
'Bien hecho, mortal. Te mostrare el camino.'"]
Resultado: El fantasma aparece al resolver el puzzle.
Ejemplo - Contratar companero:
[Al Pagar a Mercenario]
|
v
[Quitar Oro: 50]
|
v
[NPC dice: "Por 50 monedas, te seguire hasta la muerte."]
|
v
[NPC Seguir Jugador: "mercenario"]
|
v
[Establecer Flag: "tiene_companero" = true]
Resultado: El mercenario te sigue tras pagarle.
Ejemplo - Despedir companero:
[Al Hablar con Companero]
|
v
[Opciones del Jugador]
|
+---+---+
1 2
| |
v v
"Quedate "Puedes
aqui" irte"
| |
v v
[NPC Dejar [NPC Dejar
de Seguir] de Seguir]
| |
v v
[NPC dice: [Visibilidad NPC:
"Esperare "mercenario" = false]
aqui."] |
v
[Mostrar: "El mercenario
se despide y se marcha."]
Resultado: Opciones para despedir al companero.
Ejemplo - Guardia patrullando:
[Al Iniciar Juego]
|
v
[NPC Iniciar Patrulla: "guardia_1"]
|
v
[NPC Iniciar Patrulla: "guardia_2"]
---
[Cuando Suena Alarma]
|
v
[NPC Detener Patrulla: "guardia_1"]
|
v
[Mover NPC: "guardia_1" -> "puerta_principal"]
|
v
[Mostrar: "Los guardias corren hacia la entrada!"]
Resultado: Guardias patrullan normalmente,
pero reaccionan ante la alarma.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_OpenDoor | DoorId |
Abre la puerta |
| Action_CloseDoor | DoorId |
Cierra la puerta |
| Action_LockDoor | DoorId |
Cierra con llave |
| Action_UnlockDoor | DoorId |
Quita el bloqueo |
Ejemplo - Palanca que abre puerta:
[Al Usar Palanca]
|
v
[Tiene Flag: "palanca_activada"]
|
+---+---+
v v
Si No
| |
v v
[Cerrar [Abrir Puerta: "puerta_secreta"]
Puerta: |
"puerta_ v
secreta"] [Establecer Flag: "palanca_activada" = true]
| |
v v
[Establecer [Mostrar: "La pared se desliza
Flag: revelando un pasaje!"]
"palanca_ |
activada" v
= false] [Reproducir Sonido: "piedra_moviendo"]
Resultado: La palanca alterna entre abrir y cerrar.
Ejemplo - Cerrar puerta tras entrar:
[Al Entrar en Trampa]
|
v
[Cerrar Puerta: "puerta_trampa"]
|
v
[Bloquear Puerta: "puerta_trampa"]
|
v
[Mostrar: "La puerta se cierra de golpe detras de ti!
Estas atrapado!"]
|
v
[Reproducir Sonido: "puerta_cerrando"]
Resultado: La sala se convierte en trampa.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_SetObjectVisible |
ObjectId, Visible
|
Muestra/oculta objeto |
Ejemplo - Revelar objeto oculto:
[Al Examinar Cuadro]
|
v
[Tiene Flag: "caja_fuerte_visible"]
|
+---+---+
v v
Si No
| |
v v
[Mostrar: [Visibilidad Objeto: "caja_fuerte" = true]
"El cuadro |
oculta una v
caja fuerte."] [Establecer Flag: "caja_fuerte_visible" = true]
|
v
[Mostrar: "Detras del cuadro descubres
una caja fuerte empotrada en la pared!"]
Resultado: Examinar revela la caja fuerte la primera vez.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_StartQuest | QuestId |
Activa una mision |
| Action_CompleteQuest | QuestId |
Marca como completada |
| Action_FailQuest | QuestId |
Marca como fallida |
Ejemplo - Cadena de misiones:
[Al Completar Mision: "encontrar_mapa"]
|
v
[Iniciar Mision: "seguir_mapa"]
|
v
[Mostrar: "NUEVA MISION: Seguir el Mapa
El mapa indica un lugar en las montanas."]
Resultado: Completar una mision inicia la siguiente.
Ejemplo - Mision fallida por tiempo:
[Cada Hora de Juego]
|
v
[Estado Mision: "rescate_urgente" = InProgress]
|
+---+---+
v v
True False
|
v
[Incrementar Contador: "horas_rescate" +1]
|
v
[Comparar Contador: "horas_rescate" >= 24]
|
+---+---+
v v
True False
|
v
[Fallar Mision: "rescate_urgente"]
|
v
[Mostrar: "MISION FALLIDA: Rescate Urgente
Llegaste demasiado tarde..."]
Resultado: 24 horas de juego para completar la mision.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_SetFlag |
FlagName, Value
|
Establece valor de flag |
| Action_SetCounter |
CounterName, Value
|
Fija valor de contador |
| Action_IncrementCounter |
CounterName, Amount
|
Suma al contador |
Ejemplo - Sistema de karma:
[Al Ayudar a Mendigo]
|
v
[Incrementar Contador: "karma" +5]
|
v
[Mostrar: "El mendigo te bendice. Sientes paz interior."]
---
[Al Robar]
|
v
[Incrementar Contador: "karma" -10]
|
v
[Mostrar: "Una sensacion de culpa te invade."]
---
[Al Hablar con Sacerdote]
|
v
[Comparar Contador: "karma" >= 50]
|
+---+---+
v v
True False
| |
v +---> [Comparar Contador: "karma" <= -50]
[NPC dice: |
"Tu alma +---+---+
brilla con v v
luz divina."] True False
| |
v v
[NPC dice: [NPC dice: "Tu
"Veo alma esta
oscuridad en equilibrio."]
en tu
corazon."]
Resultado: El karma afecta como te ven los NPCs.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_PlaySound | SoundId |
Reproduce efecto de sonido |
Ejemplo - Ambiente sonoro:
[Al Entrar en Bosque]
|
v
[Reproducir Sonido: "pajaros_cantando"]
---
[Al Entrar en Cueva]
|
v
[Reproducir Sonido: "goteo_agua"]
---
[Al Abrir Cofre]
|
v
[Reproducir Sonido: "cofre_abriendo"]
|
v
[Reproducir Sonido: "monedas_tintineando"]
Resultado: Sonidos que dan vida al mundo.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_EquipPlayerItem |
ObjectId, Slot
|
Equipa un objeto al jugador |
| Action_UnequipPlayerSlot | Slot |
Desequipa el slot del jugador |
| Action_EquipNpcItem |
NpcId, ObjectId, Slot
|
Equipa un objeto a un NPC |
| Action_UnequipNpcSlot |
NpcId, Slot
|
Desequipa el slot de un NPC |
Slots disponibles: RightHand, LeftHand, Torso, Head
Ejemplo - Dar y equipar arma:
[Al Completar Entrenamiento]
|
v
[Dar Objeto: "espada_inicial"]
|
v
[Equipar Jugador: objeto="espada_inicial", slot="RightHand"]
|
v
[Mostrar: "El maestro te entrega una espada y te ayuda a equiparla."]
Resultado: El jugador recibe y equipa automaticamente el arma.
Ejemplo - Desarmar al jugador:
[Al Entrar en Prision]
|
v
[Desequipar Jugador: slot="RightHand"]
|
v
[Desequipar Jugador: slot="LeftHand"]
|
v
[Desequipar Jugador: slot="Torso"]
|
v
[Mostrar: "Los guardias te confiscan todo tu equipo."]
Resultado: El jugador pierde todo su equipamiento al ser capturado.
Ejemplo - Equipar NPC aliado:
[Al Dar Armadura a Companero]
|
v
[Quitar Objeto: "armadura_cuero"]
|
v
[Equipar NPC: npc="companero", objeto="armadura_cuero", slot="Torso"]
|
v
[Mostrar: "Tu companero se pone la armadura de cuero."]
Resultado: El companero usa el equipo que le das.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_SetObjectLit |
ObjectId, IsLit
|
Enciende o apaga un objeto luminoso |
| Action_SetLightTurns |
ObjectId, Turns
|
Establece turnos de luz (-1 = infinito) |
| Action_SetRoomIllumination |
RoomId, IsIlluminated
|
Enciende o apaga la luz de una sala |
Ejemplo - Encender antorcha por script:
[Al Encontrar Pedernal]
|
v
[Tiene Objeto: "antorcha"]
|
+---+---+
v v
True False
|
v
[Encender/Apagar Objeto: objeto="antorcha", encendido=true]
|
v
[Mostrar: "Usas el pedernal para encender tu antorcha."]
Resultado: El script enciende la antorcha del jugador.
Ejemplo - Antorcha que se consume:
[Cada Turno]
|
v
[Objeto Encendido: "antorcha_jugador"]
|
+---+---+
v v
True False
|
v
[Incrementar Contador: "turnos_antorcha" +1]
|
v
[Comparar Contador: "turnos_antorcha" >= 20]
|
+---+---+
v v
True False
|
v
[Turnos de Luz: objeto="antorcha_jugador", turnos=0]
|
v
[Mostrar: "Tu antorcha se ha consumido completamente."]
|
v
[Quitar Objeto: "antorcha_jugador"]
Resultado: La antorcha dura 20 turnos antes de consumirse.
Ejemplo - Recargar lampara magica:
[Al Usar Aceite en Lampara]
|
v
[Tiene Objeto: "aceite_lampara"]
|
+---+---+
v v
True False
| |
v v
[Quitar [Mostrar: "Necesitas
Objeto: aceite para
"aceite_ recargar la
lampara"] lampara."]
|
v
[Turnos de Luz: objeto="lampara_magica", turnos=-1]
|
v
[Mostrar: "Recargas la lampara. Ahora brilla con luz infinita."]
Resultado: El aceite recarga la lampara con luz infinita.
Ejemplo - Iluminar sala con palanca:
[Al Usar Palanca de Luz]
|
v
[Sala Iluminada?]
|
+---+---+
v v
True False
| |
v v
[Iluminacion [Iluminacion
Sala: Sala:
"mazmorra", "mazmorra",
false] true]
| |
v v
[Mostrar: [Mostrar:
"Las luces "Las antorchas
se apagan."] de la sala
se encienden."]
Resultado: La palanca alterna la iluminacion de la sala.
Nodos para controlar como se ejecuta el script.
| Nodo | Descripcion | Entradas | Salidas |
|---|---|---|---|
| Flow_Branch | Bifurca segun condicion bool | Exec, Condition | True, False |
| Flow_Sequence | Ejecuta multiples salidas en orden | Exec | Then1, Then2, Then3 |
| Flow_RandomBranch | Elige aleatoriamente entre salidas | Exec | Out1, Out2, Out3 |
| Flow_Delay | Pausa antes de continuar | Exec | Exec |
Usa una entrada booleana para decidir el camino.
Ejemplo - Bifurcacion con datos:
[Obtener Oro del Jugador] ----> [Comparar: Oro >= 100]
|
resultado bool
|
v
[Bifurcacion]
True / False
| |
v v
[Mostrar: [Mostrar:
"Eres "Necesitas
rico!"] mas oro."]
Resultado: Mensaje diferente segun cuanto oro tengas.
Ejemplo - Multiples condiciones:
[Obtener Fuerza] ---> [Comparar: Fuerza >= 15]
|
resultado bool
|
v
[Bifurcacion]
True / False
| |
v v
[Abrir [Mostrar:
Puerta] "No tienes
suficiente
fuerza."]
Resultado: Se necesita fuerza 15+ para forzar la puerta.
Ejecuta multiples acciones en orden garantizado.
Ejemplo - Ritual magico:
[Al Usar Pergamino]
|
v
[Secuencia]
| | |
1 2 3
| | |
v v v
[Mostrar: [Esperar [Mostrar:
"Recitas 1.5s] "Una luz
las envuelve
palabras la sala!"]
antiguas..."] |
v
[Dar Objeto:
"amuleto_proteccion"]
|
v
[Quitar Objeto:
"pergamino_ritual"]
Resultado: Secuencia dramatica con pausas.
Elige una salida al azar entre las disponibles.
Ejemplo - Dialogo variado:
[Al Hablar con Tabernero]
|
v
[Rama Aleatoria]
| | |
1 2 3
| | |
v v v
[NPC: [NPC: [NPC:
"Que "Otra "El
sera?" cerveza?" especial
de hoy
es
estofado."]
Resultado: El tabernero dice algo diferente cada vez.
Ejemplo - Tesoro aleatorio:
[Al Abrir Cofre]
|
v
[Rama Aleatoria]
| | |
1 2 3
| | |
v v v
[Dar: [Dar: [Dar:
"espada "pocion "oro_50"]
_rara"] _vida"] |
| | v
| | [Dar Oro: 50]
v v
[Mostrar: [Mostrar:
"Encuentras "Encuentras
una espada una pocion!"]
brillante!"]
Resultado: Diferentes recompensas aleatorias.
Pausa la ejecucion un tiempo determinado.
Ejemplo - Cuenta regresiva:
[Al Activar Bomba]
|
v
[Mostrar: "La bomba esta activada!"]
|
v
[Mostrar: "3..."]
|
v
[Esperar: 1 segundo]
|
v
[Mostrar: "2..."]
|
v
[Esperar: 1 segundo]
|
v
[Mostrar: "1..."]
|
v
[Esperar: 1 segundo]
|
v
[Mostrar: "BOOM!"]
|
v
[Reproducir Sonido: "explosion"]
Resultado: Tension con cuenta regresiva.
Nodos para obtener y manipular valores.
| Nodo | Tipo | Descripcion |
|---|---|---|
| Variable_GetGameHour | int |
Hora actual (0-23) |
| Variable_GetPlayerGold | int |
Cantidad de oro |
| Variable_GetCurrentRoom | string |
ID de sala actual |
| Variable_GetCurrentWeather | string |
Estado del tiempo |
Ejemplo - Tienda nocturna:
[Al Hablar con Vendedor]
|
v
[Obtener Hora] ---> [Comparar: Hora >= 22]
|
resultado bool
|
+---> [Comparar: Hora <= 6]
|
resultado bool
|
v
[Logica OR]
|
resultado bool
|
v
[Bifurcacion]
True / False
| |
v v
[NPC: "Bienvenido [NPC: "Vuelve
a la tienda de noche.
nocturna."] Solo abrimos
tarde."]
Resultado: Tienda que solo abre de noche (22:00 a 6:00).
| Nodo | Tipo | Descripcion |
|---|---|---|
| Variable_GetPlayerStrength | int |
Fuerza |
| Variable_GetPlayerConstitution | int |
Constitucion |
| Variable_GetPlayerIntelligence | int |
Inteligencia |
| Variable_GetPlayerDexterity | int |
Destreza |
| Variable_GetPlayerCharisma | int |
Carisma |
Ejemplo - Dialogo segun carisma:
[Al Hablar con Guardia]
|
v
[Obtener Carisma] ---> [Comparar: Carisma >= 15]
|
resultado bool
|
v
[Bifurcacion]
True / False
| |
v v
[NPC: "Pasa, [NPC: "No puedes
amigo. Te pasar. Ordenes
dejo del capitan."]
entrar."]
Resultado: Alto carisma permite convencer al guardia.
Ejemplo - Puzzle de fuerza:
[Al Intentar Mover Roca]
|
v
[Obtener Fuerza] ---> [Comparar: Fuerza >= 18]
|
resultado bool
|
v
[Bifurcacion]
True / False
| |
v v
[Mostrar: [Mostrar:
"Con un "La roca
gran es demasiado
esfuerzo, pesada.
mueves Necesitas
la roca."] mas fuerza."]
|
v
[Visibilidad Objeto:
"entrada_secreta" = true]
Resultado: Solo personajes fuertes pueden mover la roca.
| Nodo | Tipo | Descripcion |
|---|---|---|
| Variable_GetFlag | bool |
Valor de un flag |
| Variable_GetCounter | int |
Valor de un contador |
| Variable_ConstantInt | int |
Valor numerico fijo |
| Variable_ConstantBool | bool |
Valor booleano fijo |
Ejemplo - Mostrar contador:
[Al Hablar con Cazarrecompensas]
|
v
[Obtener Contador: "monstruos_derrotados"]
|
v
[Mostrar: "Has derrotado {valor} monstruos."]
Nota: El mensaje puede incluir el valor del contador
usando la sintaxis de variables del juego.
| Nodo | Operacion | Entradas | Salida |
|---|---|---|---|
| Math_Add | A + B | A, B (int) | Result (int) |
| Math_Subtract | A - B | A, B (int) | Result (int) |
| Math_Multiply | A x B | A, B (int) | Result (int) |
| Math_Divide | A / B | A, B (int) | Result (int) |
| Math_Random | aleatorio | Min, Max (int) | Result (int) |
| Math_Clamp | limitar | Value, Min, Max | Result (int) |
Ejemplo - Calculo de dano:
[Al Atacar]
|
v
[Obtener Fuerza] ---> [Math: Fuerza * 2]
|
dano base (int)
|
v
[Aleatorio 1-6] ---------> [Math: dano + dado]
|
dano total (int)
|
v
[Mostrar: "Causas {dano}
puntos de dano!"]
Resultado: Dano = (Fuerza * 2) + dado aleatorio.
Ejemplo - Precio con descuento:
[Al Preguntar Precio]
|
v
[Tiene Flag: "miembro_gremio"]
|
+---+---+
v v
True False
| |
v v
[Constante: [Constante:
80] 100]
| |
+-----------+
|
v
[Mostrar: "El precio es {precio} monedas."]
Resultado: Miembros del gremio pagan 80, otros 100.
| Nodo | Operacion | Entradas | Salida |
|---|---|---|---|
| Logic_And | A && B | A, B (bool) | Result (bool) |
| Logic_Or | A || B | A, B (bool) | Result (bool) |
| Logic_Not | !A | A (bool) | Result (bool) |
| Logic_Xor | A XOR B | A, B (bool) | Result (bool) |
Ejemplo - Condicion compuesta:
[Tiene Objeto: "llave_oro"] -----> [Logica AND]
|
[Tiene Flag: "conoce_secreto"] ------> |
|
resultado bool
|
v
[Bifurcacion]
True / False
| |
v v
[Abrir [Mostrar:
Puerta: "Necesitas
"camara_ la llave
tesoro"] Y conocer
el secreto."]
Resultado: Se necesitan ambas condiciones para abrir.
Ejemplo - Alternativa con OR:
[Tiene Objeto: "llave_maestra"] ---> [Logica OR]
|
[Tiene Flag: "puede_forzar"] -----------> |
|
resultado bool
|
v
[Bifurcacion]
True / False
Resultado: Pasa si tiene llave maestra O sabe forzar.
| Nodo | Descripcion | Entradas | Salida |
|---|---|---|---|
| Select_Int | Devuelve A o B segun condicion | Condition, A, B | Result (int) |
| Select_Bool | Devuelve A o B segun condicion | Condition, A, B | Result (bool) |
Ejemplo - Precio variable:
[Es Hora: Noche] -----> [Seleccionar Int]
|
[Constante: 150] -----------> True (precio noche)
|
[Constante: 100] -----------> False (precio dia)
|
resultado int
|
v
[Quitar Oro: {precio}]
Resultado: Las habitaciones cuestan mas de noche.
Para crear conversaciones interactivas con NPCs.
| Nodo | Descripcion | Propiedades |
|---|---|---|
| Conversation_Start | Punto de entrada | - |
| Conversation_NpcSay | El NPC dice algo | Text, Emotion, SpeakerName |
| Conversation_PlayerChoice | Opciones del jugador | Text1-4 |
| Conversation_Branch | Bifurca segun condicion | ConditionType, params |
| Conversation_End | Termina el dialogo | - |
| Conversation_Action | Ejecuta accion | ActionType, params |
| Emocion | Uso recomendado |
|---|---|
| Neutral | Conversacion normal |
| Feliz | Buenas noticias, exito |
| Triste | Malas noticias, perdida |
| Enfadado | Conflicto, rechazo |
| Sorprendido | Revelaciones, descubrimientos |
Ejemplo - Conversacion con emociones:
[Inicio Conversacion]
|
v
[NPC Dice: "Bienvenido, viajero." (Neutral)]
|
v
[Opciones del Jugador]
| |
1 2
| |
v v
"Hola" "Dame
tu oro"
| |
v v
[NPC: [NPC:
(Feliz) (Enfadado)
"Un "Como te
placer atreves!
conocerte!"] Largo!"]
| |
v v
(continua) [Fin]
Resultado: El NPC reacciona emocionalmente.
[Inicio Conversacion]
|
v
[Bifurcacion Dialogo: HasFlag "conoce_comerciante"]
|
+---+---+
Si No
| |
v v
[NPC: [NPC: "Soy Marco, el
"Hola mejor comerciante
de del reino.
nuevo, En que puedo
amigo!"] ayudarte?"]
| |
+---------+ |
| |
v v
[Accion: SetFlag "conoce_comerciante" = true]
|
v
[Opciones del Jugador]
| | |
1 2 3
| | |
v v v
"Comprar" "Vender" "Adios"
| | |
v v v
[Abrir [NPC: [NPC:
Tienda] "Que "Vuelve
tienes cuando
para quieras!"]
ofrecer?"] |
| | v
| v [Fin]
| [Tienda:
| modo venta]
v
[NPC: "Mira
mis mejores
productos!"]
Resultado: Conversacion ramificada completa con tienda.
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Conversation_Shop | Title, WelcomeMessage | Abre interfaz de tienda |
| Conversation_BuyItem | ObjectId, Price | Compra especifica |
| Conversation_SellItem | ObjectId, Price | Venta especifica |
Ejemplo - Tienda especializada:
[Inicio Conversacion]
|
v
[NPC: "Bienvenido a la armeria imperial!"]
|
v
[Opciones del Jugador]
| | |
1 2 3
| | |
v v v
"Ver "Tengo "Me
armas" algo voy"
para
vender"
| | |
v v v
[Abrir [Bifurcacion: HasItem "espada_goblin"]
Tienda: |
"Armas +---+---+
Imperiales"] v v
Si No
| |
v v
[Comprar [NPC: "No
Item: tienes
"espada_ nada que
goblin" me interese."]
precio: |
25] v
| [Fin]
v
[NPC: "Te doy
25 monedas
por esa
espada."]
Resultado: Tienda que compra objetos especificos.
[Inicio Conversacion]
|
v
[NPC: "Necesito que encuentres el amuleto perdido."]
|
v
[Bifurcacion: QuestStatus "buscar_amuleto" = Completed]
|
+---+---+
Si No
| |
v +---> [Bifurcacion: QuestStatus = InProgress]
[NPC: |
(Feliz) +---+---+
"Lo Si No
encontraste!"] | |
| v v
v [NPC: [Bifurcacion: HasItem "mapa_tesoro"]
[Accion: "Aun |
GiveItem no lo +---+---+
"anillo_mago"] tienes?"] Si No
| | |
v v v
[Accion: [NPC: [NPC:
AddGold 500] "Toma "Primero
| este necesitas
v mapa. un mapa.
[NPC: "Toma Te Habla con
esta ayudara el
recompensa."] a cartografo."]
| encontrarlo."]
v |
[Fin] v
[Accion:
StartQuest
"buscar_amuleto"]
|
v
[Accion:
GiveItem "mapa_tesoro"]
|
v
[Fin]
Resultado: NPC que da mision, recuerda progreso y recompensa.
| Tipo | Control | Ejemplo de uso |
|---|---|---|
string |
Campo de texto | Mensajes, nombres de flags |
int |
Campo numerico | Cantidades, probabilidades |
float |
Campo decimal | Tiempos de espera |
bool |
Checkbox | Visible si/no |
select |
Desplegable | Estados de mision, emociones |
entity |
Selector | Elegir sala, objeto, NPC |
Ejemplo de propiedades por tipo de nodo:
Nodo: "Mostrar Mensaje"
- Message (string): "Bienvenido al juego"
Nodo: "Dar Oro"
- Amount (int): 100
Nodo: "Esperar"
- Seconds (float): 1.5
Nodo: "Visibilidad NPC"
- NpcId (entity): guardian_entrada
- Visible (bool): true
Nodo: "Estado Mision"
- QuestId (entity): mision_principal
- Status (select): InProgress
Los nodos con propiedades requeridas muestran advertencia hasta que se completen:
Nodo "Dar Objeto" sin configurar:
[!] Diagnostico: "ObjectId es requerido"
Solucion:
1. Selecciona el nodo
2. En Propiedades, haz clic en "Objeto"
3. Elige de la lista (ej: "espada_larga")
4. El diagnostico cambia a "Script valido"
Un script valido necesita:
| Requisito | Descripcion | Ejemplo valido |
|---|---|---|
| Evento | Al menos un nodo de evento | "Al Entrar" |
| Accion | Al menos un nodo de accion | "Mostrar Mensaje" |
| Conexion | Evento y accion conectados | Linea entre ambos |
| Propiedades | Campos requeridos completos | Mensaje no vacio |
Ejemplo de script invalido y como arreglarlo:
PROBLEMA 1: Sin evento
Canvas: [Mostrar Mensaje: "Hola"]
Diagnostico: "Falta nodo de evento"
Solucion: Agregar "Al Entrar" y conectar
PROBLEMA 2: Sin accion
Canvas: [Al Entrar]
Diagnostico: "Falta nodo de accion"
Solucion: Agregar "Mostrar Mensaje" y conectar
PROBLEMA 3: Sin conexion
Canvas: [Al Entrar] [Mostrar Mensaje]
Diagnostico: "Nodos no conectados"
Solucion: Arrastrar desde puerto de Al Entrar a Mostrar Mensaje
PROBLEMA 4: Propiedad vacia
Canvas: [Al Entrar] --> [Dar Objeto: (vacio)]
Diagnostico: "ObjectId es requerido"
Solucion: Seleccionar un objeto en Propiedades
=== Script del NPC Comerciante ===
[Al Hablar]
|
v
[Bifurcacion: Es hora 8-20?]
|
+---+---+
Si No
| |
v v
[NPC: [NPC: "La tienda
"Bienvenido esta cerrada.
a mi Vuelve
tienda!"] manana."]
| |
v v
[Opciones] [Fin]
|
+----+----+----+
1 2 3 4
| | | |
v v v v
"Ver "Vender" "Info" "Adios"
tienda" | | |
| | | v
v | | [NPC: "Hasta
[Abrir | | pronto!"]
Tienda] | | |
| | | v
| | | [Fin]
| | |
| | v
| | [NPC: "Compro
| | armas y armaduras
| | al 50% de su valor.
| | Vendo con 20% de
| | ganancia."]
| | |
| | v
| | (volver a opciones)
| |
| v
| [Bifurcacion: tiene items vendibles?]
| |
| +---+---+
| Si No
| | |
| v v
| [Abrir [NPC: "No
| modo tienes nada
| venta] que me
| interese."]
|
v
[Fin despues de transaccion]
=== Puzzle de las 3 palancas ===
[Al Usar Palanca 1]
|
v
[Toggle Flag: "palanca_1"]
|
v
[Verificar Combo]
---
[Al Usar Palanca 2]
|
v
[Toggle Flag: "palanca_2"]
|
v
[Verificar Combo]
---
[Al Usar Palanca 3]
|
v
[Toggle Flag: "palanca_3"]
|
v
[Verificar Combo]
---
=== Verificar Combo (script de la sala) ===
[Verificar Combo es llamado cuando]
|
v
[Tiene Flag: "palanca_1"] ---> [Logica AND]
|
[Tiene Flag: "palanca_2"] -------> |
|
[NO Tiene Flag: "palanca_3"] ---> |
|
resultado bool
|
v
[Bifurcacion]
True / False
|
v
[Abrir Puerta: "puerta_puzzle"]
|
v
[Mostrar: "Las palancas
activan un mecanismo
y la puerta se abre!"]
|
v
[Reproducir Sonido: "mecanismo"]
Resultado: La combinacion correcta es
palanca 1 ON, palanca 2 ON, palanca 3 OFF.
=== Script Global del Juego ===
[Cada Hora]
|
v
[Obtener Hora] ---> [Comparar: Hora == 6]
|
+---+---+
Si No
| |
v +---> [Comparar: Hora == 22]
[Amanecer] |
| +---+---+
v Si No
[Mostrar: |
"El sol sale v
en el [Anochecer]
horizonte."] |
| v
v [Mostrar:
[Iniciar "La noche
Patrullas cae sobre
Diurnas] el reino."]
|
v
[Iniciar
Patrullas
Nocturnas]
---
=== Iniciar Patrullas Diurnas ===
[Secuencia]
| | |
v v v
[NPC Visible: [NPC Visible: [NPC Iniciar
"guardian_dia" "comerciante" Patrulla:
= true] = true] "guardian_dia"]
| |
v v
[NPC Visible: [NPC Detener
"guardian_noche" Patrulla:
= false] "guardian_noche"]
---
=== Iniciar Patrullas Nocturnas ===
[Secuencia]
| | |
v v v
[NPC Visible: [NPC Visible: [NPC Iniciar
"guardian_noche" "comerciante" Patrulla:
= true] = false] "guardian_noche"]
|
v
[NPC Visible:
"guardian_dia"
= false]
|
v
[NPC Detener
Patrulla:
"guardian_dia"]
=== Al ayudar a la Faccion A ===
[Incrementar Contador: "rep_faccion_a" +10]
|
v
[Comparar Contador: "rep_faccion_a" >= 100]
|
+---+---+
Si No
|
v
[Tiene Flag: "aliado_faccion_a"]
|
+---+---+
Si No
|
v
[Establecer Flag: "aliado_faccion_a" = true]
|
v
[Mostrar: "La Faccion A te considera
un aliado! Tienes acceso a su base."]
|
v
[Desbloquear Puerta: "puerta_base_a"]
---
=== Al hablar con NPC de Faccion A ===
[Tiene Flag: "aliado_faccion_a"]
|
+---+---+
Si No
| |
v +---> [Comparar Contador: "rep_faccion_a" >= 50]
[NPC: |
"Saludos, +---+---+
aliado! Si No
Que | |
necesitas?"] v +---> [Comparar: rep >= 0]
| [NPC: |
v "Hola, +---+---+
[Mostrar simpatizante. Si No
opciones En que puedo | |
especiales] ayudarte?"] v v
[NPC: [NPC: "No
"Que hablo con
quieres, enemigos de
forastero?"] mi faccion."]
|
v
[Fin]
Cada script pertenece a un tipo de entidad:
| OwnerType | Descripcion | Eventos disponibles |
|---|---|---|
| Game | Scripts globales | OnGameStart, OnGameEnd, EveryMinute, EveryHour, OnTurnStart, OnWeatherChange |
| Room | Scripts de sala | OnEnter, OnExit |
| Door | Scripts de puerta | OnDoorOpen, OnDoorClose, OnDoorLock, OnDoorUnlock, OnDoorKnock |
| Npc | Scripts de NPC | OnTalk, OnNpcAttack, OnNpcDeath, OnNpcSee + todos los de Conversacion |
| GameObject | Scripts de objeto | OnTake, OnDrop, OnUse, OnExamine, OnEquip, OnUnequip, OnContainerOpen, OnContainerClose |
| Quest | Scripts de mision | OnQuestStart, OnQuestComplete, OnQuestFail, OnObjectiveComplete |
Ejemplo de organizacion de scripts:
Juego "Aventura Medieval"
|
+-- Game
| +-- script_inicio: Da equipo inicial, muestra tutorial
| +-- script_clima: Cambia musica segun clima
|
+-- Salas
| +-- taberna
| | +-- script: Primera visita muestra descripcion especial
| +-- bosque
| +-- script: 30% encuentro aleatorio con lobos
|
+-- Puertas
| +-- puerta_castillo
| +-- script: Requiere llave dorada
|
+-- NPCs
| +-- herrero
| | +-- script_hablar: Conversacion con tienda
| +-- guardian
| +-- script_ver: Reacciona si eres enemigo
|
+-- Objetos
| +-- pocion_vida
| | +-- script: Se consume al usar
| +-- cofre_tesoro
| +-- script: Trampa si no esta desactivada
|
+-- Misiones
+-- rescatar_princesa
+-- script_inicio: Marca NPCs relevantes
+-- script_completar: Da recompensa
- Agrupa nodos relacionados cerca unos de otros
- Usa flujo izquierda-derecha para facilitar la lectura
-
Nombra tus flags y contadores de forma descriptiva
- Bien:
visito_biblioteca,monstruos_derrotados - Mal:
flag1,contador_a
- Bien:
Ejemplo de buena organizacion:
Evento --> Condiciones --> Acciones principales
|
+--> Rama alternativa
En lugar de:
Evento Accion2 Condicion
\ / /
Accion1 Accion3 (confuso!)
- Evita loops infinitos - siempre ten una condicion de salida
- No uses demasiados nodos en un solo script (max ~50)
- Divide scripts complejos en varios mas pequenos
- Usa flags en lugar de verificar condiciones costosas repetidamente
Ejemplo de optimizacion:
MAL (verifica cada turno):
[Cada Turno]
|
v
[Tiene Objeto: "llave" AND Esta en Sala: "entrada" AND ...]
(muchas condiciones costosas)
BIEN (usa flag):
[Al Obtener Llave]
|
v
[Establecer Flag: "puede_entrar" = true]
---
[Cada Turno]
|
v
[Tiene Flag: "puede_entrar"] <-- rapido!
- Usa "Mostrar Mensaje" temporalmente para ver por donde pasa el flujo
- Verifica el panel de diagnostico frecuentemente
- Prueba cada rama de las bifurcaciones
- Guarda frecuentemente mientras editas
Ejemplo de mensajes de depuracion:
[Al Entrar]
|
v
[Mostrar: "[DEBUG] Entro en sala"] <-- temporal
|
v
[Condicion]
| |
v v
True False
| |
v v
[Mostrar: [Mostrar:
"[DEBUG] "[DEBUG]
True!"] False!"]
| |
... ...
Despues de verificar, elimina los mensajes DEBUG.
Nodos disponibles cuando el combate esta habilitado en las propiedades del juego.
| Nodo | Descripcion | Salidas |
|---|---|---|
| Event_OnCombatStart | Se ejecuta al iniciar combate con este NPC | Exec |
| Event_OnCombatVictory | Se ejecuta al vencer a este NPC | Exec |
| Event_OnCombatDefeat | Se ejecuta al ser vencido por este NPC | Exec |
| Event_OnCombatFlee | Se ejecuta al huir del combate | Exec |
| Event_OnPlayerAttack | Se ejecuta cuando el jugador ataca | Exec, Damage (int) |
| Event_OnNpcTurn | Se ejecuta en el turno del NPC | Exec, Round (int) |
| Event_OnPlayerDefend | Se ejecuta al defenderse el jugador | Exec |
| Event_OnCriticalHit | Se ejecuta en golpe critico | Exec, Damage (int), IsPlayerCrit (bool) |
| Event_OnMiss | Se ejecuta al fallar un ataque | Exec, IsPlayerMiss (bool) |
| Event_OnPlayerDeath | Se ejecuta al morir el jugador | Exec |
| Event_OnHealthLow | Se ejecuta al bajar la salud del umbral | Exec, CurrentHealth (int) |
| Event_OnHealthCritical | Se ejecuta en salud critica | Exec, CurrentHealth (int) |
Ejemplo - Boss con fases:
[Al Iniciar Combate]
|
v
[Mostrar: "El dragon ruge furioso!"]
|
v
[Reproducir Sonido: "rugido_dragon"]
---
[En Turno del NPC] --> Ronda
|
v
[Comparar: Ronda >= 5]
|
+---+---+
v v
True False
|
v
[Mostrar: "El dragon se enfurece y ataca con mas fuerza!"]
|
v
[Establecer Ataque NPC: +10]
Ejemplo - Recompensa al vencer:
[Al Ganar Combate]
|
v
[Dar Oro: 200]
|
v
[Probabilidad: 30%]
|
+---+---+
v v
Si No
|
v
[Dar Objeto: "escama_dragon"]
|
v
[Mostrar: "Encuentras una escama brillante entre los restos."]
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Condition_IsInCombat | - | Hay combate activo? |
| Condition_IsPlayerAlive | - | El jugador esta vivo? |
| Condition_IsNpcAlive | NpcId |
El NPC esta vivo? |
| Condition_PlayerHealthBelow |
Threshold (%) |
Salud del jugador bajo X%? |
| Condition_PlayerHealthAbove |
Threshold (%) |
Salud del jugador sobre X%? |
| Condition_NpcHealthBelow |
NpcId, Threshold (%) |
Salud del NPC bajo X%? |
| Condition_PlayerHasWeaponType | DamageType |
Tiene arma del tipo especificado? |
| Condition_PlayerHasArmor | - | Tiene armadura equipada? |
| Condition_IsCombatRound | Round |
Es la ronda especificada? |
Ejemplo - NPC que huye con poca salud:
[En Turno del NPC]
|
v
[Salud NPC Baja: npc="goblin", umbral=25]
|
+---+---+
v v
True False
|
v
[Mostrar: "El goblin intenta huir!"]
|
v
[Forzar Huida]
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_StartCombat | NpcId |
Inicia combate con el NPC |
| Action_DamagePlayer | Amount |
Inflige dano al jugador |
| Action_HealPlayer | Amount |
Cura al jugador |
| Action_DamageNpc |
NpcId, Amount
|
Inflige dano a un NPC |
| Action_HealNpc |
NpcId, Amount
|
Cura a un NPC |
| Action_SetNpcMaxHealth |
NpcId, Value
|
Establece salud maxima del NPC |
| Action_ReviveNpc | NpcId |
Revive un NPC muerto |
| Action_KillNpc | NpcId |
Mata instantaneamente a un NPC |
| Action_SetNpcAttack |
NpcId, Value
|
Modifica el ataque del NPC |
| Action_SetNpcDefense |
NpcId, Value
|
Modifica la defensa del NPC |
| Action_EndCombatVictory | - | Termina combate con victoria |
| Action_EndCombatDefeat | - | Termina combate con derrota |
| Action_ForceFlee | - | Fuerza huida del combate |
Ejemplo - Trampa que inicia combate:
[Al Entrar en Emboscada]
|
v
[Mostrar: "Bandidos salen de los arbustos!"]
|
v
[Visibilidad NPC: "bandido_lider" = true]
|
v
[Iniciar Combate: "bandido_lider"]
Ejemplo - Ejecutar NPC debilitado:
[Al Atacar NPC]
|
v
[Salud NPC Baja: npc=owner, umbral=10]
|
+---+---+
v v
True False
|
v
[Mostrar: "Ejecutas al enemigo con un golpe definitivo!"]
|
v
[Matar NPC: owner]
|
v
[Terminar Combate Victoria]
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_AddAbility | AbilityId |
Da una habilidad al jugador |
| Action_RemoveAbility | AbilityId |
Quita una habilidad al jugador |
| Action_AddAbilityToNpc |
NpcId, AbilityId
|
Da habilidad a un NPC |
| Action_RemoveAbilityFromNpc |
NpcId, AbilityId
|
Quita habilidad a un NPC |
Nodos disponibles cuando las necesidades basicas estan habilitadas.
| Nodo | Descripcion | Salidas |
|---|---|---|
| Event_OnEat | El jugador come algo | Exec, NutritionAmount (int) |
| Event_OnDrink | El jugador bebe algo | Exec, NutritionAmount (int) |
| Event_OnSleep | El jugador comienza a dormir | Exec, Hours (int) |
| Event_OnWakeUp | El jugador despierta normalmente | Exec, HoursSlept (int) |
| Event_OnWakeUpStartled | El jugador despierta sobresaltado | Exec, Reason (string) |
| Event_OnHungerHigh | El hambre supera umbral | Exec, CurrentHunger (int) |
| Event_OnThirstHigh | La sed supera umbral | Exec, CurrentThirst (int) |
| Event_OnSleepHigh | El cansancio supera umbral | Exec, CurrentSleep (int) |
| Event_OnEnergyLow | La energia baja del umbral | Exec, CurrentEnergy (int) |
| Event_OnSanityLow | La cordura baja del umbral | Exec, CurrentSanity (int) |
| Event_OnManaLow | El mana baja del umbral | Exec, CurrentMana (int) |
Ejemplo - Comida que restaura hambre:
[Al Comer] --> Cantidad de nutricion
|
v
[Mostrar: "El pan te sacia el hambre."]
|
v
[Reproducir Sonido: "comer"]
Ejemplo - Despertar por pesadilla:
[Al Despertar Sobresaltado] --> Razon
|
v
[Comparar Razon == "pesadilla"]
|
+---+---+
v v
Si No
|
v
[Mostrar: "Te despiertas empapado en sudor.
Una pesadilla terrible te perseguia."]
|
v
[Modificar Estado: Sanity -10]
Ejemplo - Aviso de hambre:
[Al Tener Hambre] --> Umbral: 80
|
v
[Mostrar: "Tu estomago ruge. Necesitas comer pronto."]
|
v
[Reproducir Sonido: "estomago"]
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Condition_PlayerStateAbove |
StateType, Threshold
|
Estado sobre umbral? |
| Condition_PlayerStateBelow |
StateType, Threshold
|
Estado bajo umbral? |
| Condition_PlayerStateEquals |
StateType, Value
|
Estado igual a valor? |
| Condition_PlayerStateBetween |
StateType, Min, Max
|
Estado entre valores? |
| Condition_HasModifier | ModifierName |
Tiene modificador activo? |
| Condition_HasModifierForState | StateType |
Tiene modificador de ese tipo? |
Estados disponibles: Health, MaxHealth, Hunger, Thirst, Energy, Sanity, Mana, MaxMana, Strength, Constitution, Intelligence, Dexterity, Charisma, Money
Ejemplo - Accion segun cansancio:
[Al Intentar Correr]
|
v
[Estado Jugador Bajo: Energy < 20]
|
+---+---+
v v
True False
| |
v v
[Mostrar: (permite correr)
"Estas
demasiado
cansado
para
correr."]
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_SetPlayerState |
StateType, Value
|
Establece valor de estado |
| Action_ModifyPlayerState |
StateType, Amount
|
Suma/resta a un estado |
| Action_HealPlayer | Amount |
Cura salud |
| Action_DamagePlayer | Amount |
Inflige dano |
| Action_RestoreMana | Amount |
Restaura mana |
| Action_ConsumeMana | Amount |
Consume mana |
| Action_SetPlayerMaxHealth | Value |
Establece salud maxima |
Ejemplo - Pocion de mana:
[Al Usar Pocion de Mana]
|
v
[Restaurar Mana: 50]
|
v
[Mostrar: "El liquido azul te llena de energia magica."]
|
v
[Quitar Objeto: "pocion_mana"]
| Nodo | Descripcion | Salidas |
|---|---|---|
| Event_OnModifierApplied | Se aplica un modificador | Exec, ModifierName (string) |
| Event_OnModifierExpired | Un modificador expira | Exec, ModifierName (string) |
Ejemplo - Notificar modificador:
[Al Aplicar Modificador] --> Nombre
|
v
[Mostrar: "Efecto aplicado: {nombre}"]
---
[Al Expirar Modificador] --> Nombre
|
v
[Mostrar: "El efecto de {nombre} ha terminado."]
Nodos para el sistema de compra y venta con NPCs comerciantes.
| Nodo | Descripcion | Salidas |
|---|---|---|
| Event_OnTradeStart | Se inicia comercio con este NPC | Exec |
| Event_OnTradeEnd | Se cierra el comercio | Exec |
| Event_OnItemBought | El jugador compra un item | Exec, ObjectId (string), Price (int) |
| Event_OnItemSold | El jugador vende un item | Exec, ObjectId (string), Price (int) |
| Event_OnMoneyGained | El jugador gana dinero | Exec, Amount (int) |
| Event_OnMoneyLost | El jugador pierde dinero | Exec, Amount (int) |
| Event_OnMoneyThreshold | El dinero cruza un umbral | Exec, CurrentMoney (int) |
Ejemplo - Comerciante que saluda:
[Al Iniciar Comercio]
|
v
[NPC Dice: "Bienvenido a mi tienda! Tengo los mejores precios."]
Ejemplo - Rastrear compras:
[Al Comprar] --> ObjectId, Price
|
v
[Incrementar Contador: "compras_totales" +1]
|
v
[Comparar Contador: "compras_totales" >= 10]
|
+---+---+
v v
Si No
|
v
[Mostrar: "El comerciante te ofrece una tarjeta de cliente VIP!"]
|
v
[Establecer Flag: "cliente_vip" = true]
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Condition_IsInTrade | - | Hay comercio activo? |
| Condition_PlayerHasMoney | Amount |
El jugador tiene al menos X oro? |
| Condition_NpcHasMoney |
NpcId, Amount
|
El NPC tiene al menos X oro? |
| Condition_NpcHasInfiniteMoney | NpcId |
El NPC tiene oro infinito? |
| Condition_PlayerOwnsItem |
ObjectId, Quantity
|
El jugador tiene X unidades de objeto? |
| Condition_NpcHasItem |
NpcId, ObjectId
|
El NPC tiene el objeto? |
Ejemplo - Verificar antes de vender:
[Al Intentar Vender Objeto Especial]
|
v
[Tiene Flag: "permiso_vender_reliquia"]
|
+---+---+
v v
True False
| |
v v
(permite) [Mostrar: "No puedes vender reliquias
sin permiso del gremio."]
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_OpenTrade | NpcId |
Abre la ventana de comercio |
| Action_CloseTrade | - | Cierra el comercio activo |
| Action_AddPlayerMoney | Amount |
Da oro al jugador |
| Action_RemovePlayerMoney | Amount |
Quita oro al jugador |
| Action_SetNpcMoney |
NpcId, Amount
|
Establece oro del NPC |
| Action_AddNpcItem |
NpcId, ObjectId
|
Anade objeto al inventario del NPC |
| Action_RemoveNpcItem |
NpcId, ObjectId
|
Quita objeto del inventario del NPC |
| Action_SetBuyMultiplier |
NpcId, Multiplier
|
Cambia multiplicador de compra |
| Action_SetSellMultiplier |
NpcId, Multiplier
|
Cambia multiplicador de venta |
Ejemplo - Descuento por reputacion:
[Al Hablar con Comerciante]
|
v
[Comparar Contador: "reputacion_gremio" >= 50]
|
+---+---+
v v
True False
| |
v v
[Multiplicador [Multiplicador
Compra: 0.8] Compra: 1.0]
(20% descuento) (precio normal)
| |
+---------+-----+
|
v
[Abrir Comercio]
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Condition_IsObjectVisible | ObjectId |
El objeto es visible? |
| Condition_IsObjectTakeable | ObjectId |
El objeto se puede coger? |
| Condition_IsContainerOpen | ObjectId |
El contenedor esta abierto? |
| Condition_IsContainerLocked | ObjectId |
El contenedor esta bloqueado? |
| Condition_ObjectInContainer |
ObjectId, ContainerId
|
El objeto esta en el contenedor? |
| Condition_ObjectInRoom |
ObjectId, RoomId
|
El objeto esta en la sala? |
| Condition_NpcInRoom |
NpcId, RoomId
|
El NPC esta en la sala? |
| Condition_IsWeather | Weather |
El clima actual es este? |
| Condition_IsDoorVisible | DoorId |
La puerta es visible? |
| Condition_CompareProperty |
EntityType, EntityId, PropertyName, Operator, Value
|
Compara cualquier propiedad |
Climas disponibles: Despejado, Nublado, Lluvia, Tormenta, Nieve, Niebla
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_SetObjectTakeable |
ObjectId, Takeable
|
Hace el objeto cogible o no |
| Action_OpenContainer | ObjectId |
Abre un contenedor |
| Action_CloseContainer | ObjectId |
Cierra un contenedor |
| Action_LockContainer | ObjectId |
Bloquea un contenedor |
| Action_UnlockContainer | ObjectId |
Desbloquea un contenedor |
| Action_SetContentsVisible |
ObjectId, Visible
|
Muestra/oculta contenido |
| Action_SetObjectPrice |
ObjectId, Price
|
Cambia el precio del objeto |
| Action_SetObjectDurability |
ObjectId, Durability
|
Cambia durabilidad |
| Action_MoveObjectToRoom |
ObjectId, RoomId
|
Mueve objeto a una sala |
| Action_PutObjectInContainer |
ObjectId, ContainerId
|
Mete objeto en contenedor |
| Action_RemoveObjectFromContainer | ObjectId |
Saca objeto del contenedor |
| Action_SetDoorVisible |
DoorId, Visible
|
Muestra/oculta puerta |
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Action_SetWeather | Weather |
Cambia el clima |
| Action_SetGameHour |
Hour (0-23) |
Establece la hora |
| Action_AdvanceTime | Hours |
Avanza el tiempo X horas |
| Action_SetRoomMusic |
RoomId, MusicId
|
Cambia musica de la sala |
| Action_SetRoomDescription |
RoomId, Description
|
Cambia descripcion de sala |
| Nodo | Propiedades | Descripcion |
|---|---|---|
| Event_OnStateThreshold |
StateType, Threshold, Direction
|
Al cruzar cualquier umbral de estado |
| Event_OnPropertyChanged |
EntityType, PropertyName
|
Al cambiar cualquier propiedad |
| Problema | Causa | Solucion |
|---|---|---|
| Script no se ejecuta | Sin evento | Agregar nodo de evento verde |
| Diagnostico amarillo | Script incompleto | Conectar todos los nodos, completar propiedades |
| NPC no responde | Sin script OnTalk | Crear conversacion con Conversation_Start |
| Flag no funciona | Nombre mal escrito | Verificar que el nombre sea identico en todas partes |
| Puerta no abre | Conexion faltante | Verificar que Action_OpenDoor este conectado |
| Contador siempre 0 | No inicializado | Usar SetCounter al inicio del juego |