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.
Componentes
Sección titulada «Componentes»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.
Entidades
Sección titulada «Entidades»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, comodeltaen_process.it.field("Position"): unArraycon laPositionde cada entidad, en el mismo orden para todos los componentes. El elementoidepositionsy el elementoidevelocitiesson de la misma entidad.- Cada elemento lee y escribe los campos de su componente (
position.x). Con el structPositionen el script tienen sus tipos:position.xes 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):
| Argumento | Qué es |
|---|---|
callback | La función, sin llamarla (move_all, no move_all()) |
fase | Cuándo corre: "process" (cada frame), "physics_process" (cada frame de física) o "ready" (una vez) |
componentes | Los 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 fnque 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"])}Cuál usar
Sección titulada «Cuál usar»| Quieres | Usa |
|---|---|
| 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.