Ir al contenido
Descargar
El libro de Grost

ECS: entidades y sistemas

A un juego con tres enemigos le basta un prefab por enemigo, cada uno con su código. A uno con tres mil balas, chispas o abejas, no: un script por actor cuesta demasiado tiempo en cada frame.

Para eso Gobu tiene un ECS (Entity Component System), construido sobre flecs.

La idea es repartir de otra forma:

  • Una entidad es solo una identidad: no tiene código propio.
  • Un componente son datos sueltos pegados a una entidad (una posición, una velocidad, una marca “Puerta”).
  • Un sistema es una función que corre sobre todas las entidades que tienen ciertos componentes.

Así, en vez de tres mil scripts que mueven una bala cada uno, hay una función que mueve tres mil balas.

En un juego: los datos que comparten muchas cosas, como dónde está cada abeja y a qué velocidad vuela.

Un componente es un struct (capítulo 5) registrado en el ECS. En un proyecto, los componentes viven en sus propios archivos y un script los importa con use component::, como los demás espacios de use del capítulo 6.

Los sistemas de este capítulo solo necesitan sus nombres y sus campos: los sistemas se refieren a los componentes por nombre, como texto. Aquí los dos structs están en el mismo script que el sistema, y así Grost da un tipo a sus campos:

Position :: struct {
x : float = 0
y : float = 0
}
Velocity :: struct {
x : float = 0
y : float = 0
}

ECS.world().component("Position") registra un struct como componente. Pocas veces hace falta: un sistema registra los componentes que usa, si un script los declara.

En un juego: cada abeja del enjambre es una entidad, con un Position y un Velocity.

Cada actor ya es una entidad, y el Add Component del inspector le pone componentes. Las entidades también se crean desde código, sin ningún actor, y así cuestan mucho menos. ECS.world().entity() crea una vacía, y ecs_set le pone un componente, con un literal del struct:

Position :: struct {
x : float = 0
y : float = 0
}
fn _ready() void {
world : World = ECS.world()
for i : int in range(3) {
abeja : Entity = world.entity()
world.ecs_set(abeja, Position{ .x = 10.0 * i })
}
}

Sistemas: una función para muchas entidades

Sección titulada «Sistemas: una función para muchas entidades»

En un juego: cada bala avanza un poco en cada frame. El cálculo es el mismo para todas; solo cambian sus datos.

Un sistema es una función que recibe un iterador (it), un objeto que recorre las entidades que cumplen. El iterador te da, por componente, un array con un elemento por cada entidad que cumple:

fn move_all(it: EcsSystemIterator) void {
dt : float = it.delta()
positions := it.field("Position")
velocities := it.field("Velocity")
for i : int in range(it.count()) {
position := positions[i]
velocity := velocities[i]
position.x += velocity.x * dt
position.y += velocity.y * dt
}
}
  • it.count(): cuántas entidades cubre esta llamada.
  • it.delta(): los segundos desde el frame anterior, como delta en _process.
  • it.field("Position"): un Array con la Position de cada entidad, en el mismo orden para todos los componentes. El elemento i de positions y el elemento i de velocities son de la misma entidad.
  • Cada elemento lee y escribe los campos de su componente (position.x). Con el struct Position en el script tienen sus tipos: position.x es un float, y un campo que el struct no tiene es un error antes de ejecutar el juego. Escribirlos cambia el componente de la entidad. Un sistema llega a los campos de tipo bool, int, float, los vectores y Color.
  • Sin el struct en el script, los elementos llegan sin un tipo conocido: toma cada uno con as ((position.x as float) ?? 0.0).

Lo registras una vez, normalmente en _ready:

fn _ready() void {
ECS.world().system(move_all, "process", ["Position", "Velocity"])
}

ECS.world().system(callback, fase, componentes):

ArgumentoQué es
callbackLa función, sin llamarla (move_all, no move_all())
faseCuándo corre: "process" (cada frame), "physics_process" (cada frame de física) o "ready" (una vez)
componentesLos nombres de los componentes que necesita una entidad para entrar

Registrar otra vez la misma función la sustituye: nunca corre dos veces por frame.

Sistemas de tareas: una corrutina por entidad

Sección titulada «Sistemas de tareas: una corrutina por entidad»

En un juego: puertas, trampas o generadores, cada uno siguiendo su pequeña rutina.

Hay lógica que es una historia, no un cálculo por frame: “espera a que alguien la pise, abre, espera tres segundos, cierra”. Escrita como sistema necesitaría un estado por entidad; escrita como corrutina (capítulo 10) se lee de arriba abajo.

ECS.world().task_system(callback, componentes) arranca una corrutina por cada entidad que tiene los componentes:

async fn blink(e: Entity) void {
defer { print("beacon off: ", e) }
loop {
await sleep(0.5)
print("blink ", e)
}
}
fn _ready() void {
ECS.world().task_system(blink, ["Beacon"])
}
  • La función es una async fn que recibe la entidad (e).
  • Arranca una vez cuando una entidad pasa a tener todos los componentes, y no se vuelve a arrancar mientras sigue corriendo.
  • Cuando la entidad pierde uno de esos componentes, o se destruye, su corrutina se cancela: corren sus bloques defer, así que puede limpiar.
  • Una entidad nueva que cumple después recibe su propia corrutina.
  • Corre en la fase "process". Registrar otra vez la misma función la sustituye (sus corrutinas se cancelan).

A través de la entidad llegas a sus componentes por nombre. Esta puerta, de un proyecto, espera una señal de su componente Trigger y llama a funciones de su componente Door:

async fn door_logic(e: Entity) void {
while true {
await e.Trigger.entered
e.Door.open()
await sleep(3.0)
e.Door.close()
}
}
fn _ready() void {
ECS.world().task_system(door_logic, ["Door", "Trigger"])
}
QuieresUsa
Pocas cosas con comportamiento propio (jugador, jefe, menú)Un prefab con su código
El mismo cálculo, cada frame, en muchas entidades (mover, envejecer, desvanecer)ECS.world().system
Una secuencia con esperas, por entidad (puertas, trampas, generadores)ECS.world().task_system

Puedes mezclarlos: prefabs para los personajes, sistemas para el enjambre.