5 de marzo de 2026 · Mijaíl Vasíliev

Devlog de Nexus: el prototipo del motor

Watch on YouTube

Hace mes y medio publiqué en la web los planes del estudio - sobre el motor Nexus: qué es y qué proyectos vamos a hacer con él, hasta llegar a estrategias y a continuaciones de nuestra serie egipcia. Allí estaba también la hoja de ruta. El motor es complejo, y para reducir riesgos quería montarlo poco a poco. Pero en los comentarios los jugadores lo dijeron claro: montar algo así es imposible. Por eso decidí empezar por un prototipo - para enseñar que un motor de este tipo sí se puede montar. Y eso es lo que voy a enseñar.

El menú del prototipo: el motor propone elegir una de cuatro simulaciones - Stone Age, Slay the Spire, el generador de sistemas estelares y Oregon Trail

Así es como se ve el motor ahora mismo. A primera vista es una aplicación de consola bastante primitiva. Pero enseña bien lo importante - que mecánicas distintas funcionan sobre un mismo motor universal.

Ahora mismo corren sobre él cuatro simulaciones. La primera es Stone Age, el primer juego del estudio, de 2013. Las otras tres están hechas a partir de proyectos ajenos. No pienso copiarlas ni publicarlas, están aquí solo para enseñar que sobre un mismo motor pueden funcionar mecánicas de juego completamente distintas.

Stone Age

Stone Age está reproducida en el motor por completo. Las mismas características, los años y los turnos, la población, las tierras. Mandas a los trabajadores al bosque, recogen comida, la población crece, aparecen tecnologías - las investigas, desbloqueas construcciones y el árbol de evolución, del australopiteco al Homo habilis y más allá. Los eventos, el final - todo lo del original está aquí.

La consola del prototipo: Stone Age - las características de la tribu, las tierras, el menú de tecnologías y evolución

Slay the Spire

Después viene Slay the Spire, un roguelike de cartas estupendo, seguro que alguien lo ha jugado. En el motor está solo el combate: el jugador tiene cartas, energía y salud, y el enemigo tiene su intención. Strike (Golpe) ataca, Defend (Defensa) pone bloqueo. Gastas energía, terminas el turno, y así por turnos hasta que alguien gana.

La misma consola con Slay the Spire - salud, energía, la intención del enemigo y las cartas en la mano

GURPS

La tercera simulación es GURPS, un sistema de mesa, bastante complejo. De él cogí solo un módulo, el generador de sistemas estelares. Lo curioso es que ese módulo en sí no es un juego, sino un generador complejo. Montó un sistema con una estrella y un montón de propiedades: diez órbitas, con distintos mundos en ellas. El primero, pequeño y rocoso, se parece a Mercurio - con su propia masa, su presión atmosférica y lo demás. En total esta simulación tiene más de seis mil hechos. Es una buena prueba de estrés: se ve cuántos datos aguanta el motor.

Un sistema estelar generado en el módulo de GURPS - la estrella, las órbitas y las propiedades del primer mundo

Oregon Trail

La cuarta es Oregon Trail, un clásico de 1971 y uno de los primeros juegos de ordenador. Es el viaje de unos colonos por América en carretas: antes del camino compras suministros - bueyes, comida, munición, ropa - y luego cazas, repartes la ración y te las apañas con los eventos. A nosotros nos acaban de atacar. Y así hasta el final del trayecto.

Oregon Trail en la misma consola: los suministros - comida, munición, ropa, dinero - y la elección de qué hacer cuando aparecen unos jinetes

Los cuatro juegos funcionan sobre un mismo motor, y para ninguno hubo que escribir código.

Cambios sobre la marcha

Pero el motor no solo ejecuta estos juegos - se pueden cambiar sobre la marcha, sin tocar el código. Cojamos Slay the Spire.

El turno inicial de Slay the Spire en el motor: salud, energía, el enemigo y cinco cartas en la mano - el daño de Strike (Golpe) sigue siendo 6

Voy a cambiar el daño de la carta Strike (Golpe), lo pongo a 100:

/set Strike.CalcDamage Value 100

La propiedad cambió a la vez en las dos cartas de ese tipo, porque comparten la misma clase.

Dos cartas Strike (Golpe) en la mano, ambas ahora con 100 de daño - la propiedad cambió de golpe en todas las cartas de esa clase

Y también se puede añadir una carta completamente nueva, Fireball (Bola de fuego):

/add Fireball Is DirectDamage
/set Fireball.CostEnergy Value 2
/add Fireball Has CalcDamage
/set Fireball.CalcDamage Value 20
/add Fireball Has ApplyDamage
/add Fireball.ExecutionEffects Has CostEnergy
/add Fireball.ExecutionEffects Has CalcDamage
/add Fireball.ExecutionEffects Has ApplyDamage

No existía, y ahora está en el juego - está en la mano, se juega, hace 20 de daño y se va al descarte, como cualquier otra:

Tras los cambios: las dos cartas Strike (Golpe) están a 100 de daño, y en la mano ha aparecido una carta nueva, Fireball (Bola de fuego), de 20 de daño

También se pueden cambiar las propias reglas, con un solo comando. Voy a quitar la regla por la que las cartas jugadas se van al descarte.

/remove PlayCard Has MovePlayedCard

Ahora se quedan en la mano. Jugué Defend (Defensa): el bloqueo subió, la energía se gastó, pero la carta se quedó.

Tras cambiar la regla: Defend (Defensa) está jugada - energía 0/3, bloqueo 5 - pero todas las cartas jugadas se han quedado en la mano, marcadas con [X]

En un juego normal, escrito en un lenguaje de programación, para esto habría que meterse en el código y recompilar el proyecto. Aquí no hace falta.

Igual se le añade al juego algo que antes no existía en absoluto. Por ejemplo, el oro - lo creo y describo cómo se gasta:

/set Player.Gold Value 100
/add CostGold Output Owner.Gold
/add CostGold Math.Subtract.Apply true

Aparece una característica que hace un momento no estaba - el oro, y de golpe cien de una.

En la línea de estado ha aparecido el oro - cien de golpe - una característica que el juego no tenía hace un momento

Sobre ese oro se puede montar también una acción nueva - Bribe (Soborno). Gasta oro en vez de energía:

/add Bribe Is DirectDamage
/set Bribe.CostEnergy Value 0
/set Bribe.CostGold Value 30
/add Bribe Has CalcDamage
/set Bribe.CalcDamage Value 15
/add Bribe Has ApplyDamage
/add Bribe Has CostGold
/add Bribe.ExecutionEffects Has CostGold
/add Bribe.ExecutionEffects Has CalcDamage
/add Bribe.ExecutionEffects Has ApplyDamage
/create Bribe Player.Hand

Bribe (Soborno) cuesta treinta de oro y hace quince de daño - y funciona al momento.

En la mano ha aparecido una acción nueva, Bribe (Soborno): cero de energía, treinta de oro y quince de daño

Puede parecer que esto son trucos y que escribir esos comandos es incómodo. Pero no son trucos. Es la edición de los hechos lógicos y los datos sobre los que se sostiene todo el juego - sus objetos, sus propiedades y sus mecánicas. En el fondo es el lenguaje en el que el juego está escrito.

No hace falta aprender este lenguaje. Se le puede pedir a la IA que traduzca una frase normal a los comandos que Nexus entiende. Por ejemplo:

give 999 gold

En la práctica esto es simplemente «Añade 999 de oro».

Una petición a la IA con palabras normales - «give 999 gold». El propio motor da con el comando adecuado y lo ejecuta

La IA piensa, encuentra el comando que toca y lo ejecuta, y ya tenemos 999 de oro.

Se puede decir de otra forma, «oro 100» - también funciona. «Hazme un dios» - la IA te da invulnerabilidad. Terminar el turno, atacar, curarse - todo eso se puede hacer con palabras, el motor lo entiende. Y nada de esto está guionizado, todo funciona de verdad.

Planes

Los comandos quiero simplificarlos. Ahora mismo, para crear ese mismo Fireball (Bola de fuego), hacen falta unos ocho comandos, y pienso reducirlo a tres o cuatro. Y en el próximo vídeo intentaré enseñar algo más visual - un render 2D.

Más sobre el motor y los planes en la sección de Nexus.

Aclaración: Stone Age es un juego del estudio. Slay the Spire, GURPS y Oregon Trail pertenecen a sus respectivos propietarios y se muestran solo como demostración del motor - estas versiones no se distribuyen en ningún sitio.