ECS: entidades y sistemas
Posicion :: struct {
x : float = 0
y : float = 01 · Un componenteUn **componente** son datos sueltos que se pegan a una entidad. Se escribe como un struct, igual que los del módulo 2.}
fn _ready() void {
p : Posicion = Posicion{ .x = 5.0 }
print(p.x)
}5.0
Posicion :: struct {
x : float = 0
y : float = 0
}
fn _ready() void {
abeja : Entity = ECS.world().entity()
ECS.world().ecs_set(abeja, Posicion{ .x = 5.0 })2 · Una entidadUna **entidad** es solo una identidad, sin código propio. entity() crea una y ecs_set le pega un componente con sus valores. print(abeja.has_component("Posicion"))
}true
Posicion :: struct {
x : float = 0
y : float = 0
}
fn avanzar(it: EcsSystemIterator) void {
posiciones := it.field("Posicion")
for i : int in range(it.count()) {
posicion := posiciones[i]
posicion.x += 10.0 * it.delta()
}
}
fn _ready() void {
ECS.world().system(avanzar, "process", ["Posicion"])3 · Un sistemaUn **sistema** es una función que recibe un iterador, it, con los componentes de todas las entidades que cumplen. Lo registras una vez y corre en cada frame.}Este código todavía no imprime nada.
Posicion :: struct {
x : float = 0
y : float = 0
}
fn avanzar(it: EcsSystemIterator) void {
posiciones := it.field("Posicion")
for i : int in range(it.count()) {
posicion := posiciones[i]
posicion.x += 10.0 * it.delta()
}
}
async fn _ready() void {
abeja : Entity = ECS.world().entity()
ECS.world().ecs_set(abeja, Posicion{})
ECS.world().system(avanzar, "process", ["Posicion"])
await sleep(1.0)
x : float = (abeja.get_component_field("Posicion", "x") as float) ?? 0.0
print(roundi(x))4 · Verlo funcionarAl cabo de un segundo, el sistema ha movido la abeja 10 unidades. Con mil abejas sería la misma función, una sola vez por frame.}10
Un juego con tres enemigos se arregla con un prefab por enemigo, cada uno con su código. Pero ¿y una tormenta con miles de gotas, o un enjambre de mil abejas? Un script por cada una cuesta demasiado.
Para eso Gobu tiene un ECS (de Entity Component System: entidades, componentes y sistemas). En vez de mil scripts que mueven una abeja cada uno, hay una función que mueve mil abejas.
Tres piezas
Un ECS reparte el juego de otra forma:
| Pieza | Qué es | En un enjambre |
|---|---|---|
| Entidad | Solo una identidad: no tiene código propio | Cada abeja |
| Componente | Datos sueltos pegados a una entidad | Su posición, su velocidad |
| Sistema | Una función que corre sobre todas las entidades que tienen ciertos componentes | Mover todas las abejas |
Los datos están en los componentes y el comportamiento en los sistemas. La entidad solo junta sus componentes.
Componentes y entidades
Un componente es un struct, como los del módulo 2:
module Colmena
Posicion :: struct { x : float = 0 y : float = 0}
fn _ready() void { mundo : World = ECS.world() abeja : Entity = mundo.entity() mundo.ecs_set(abeja, Posicion{ .x = 5.0, .y = 2.0 }) print(abeja.has_component("Posicion")) print(abeja.get_component_field("Posicion", "x"))}ECS.world()es el mundo del ECS: donde viven las entidades del juego.mundo.entity()crea una entidad vacía. No es un actor: no tiene escena ni código, y por eso cuesta muy poco.mundo.ecs_set(abeja, Posicion{ ... })le pega el componentePosicioncon esos valores.has_componentdice si la entidad lo tiene, yget_component_fieldlee uno de sus campos.
Un componente guarda campos de tipo bool, int, float, vectores y Color.
Sistemas: una función para todas
Un sistema es una función que recibe un iterador (it): algo que te da los componentes de
todas las entidades que cumplen. Este mueve mil abejas hacia la derecha:
module Enjambre
Posicion :: struct { x : float = 0 y : float = 0}
Velocidad :: struct { x : float = 0 y : float = 0}
fn mover(it: EcsSystemIterator) void { dt : float = it.delta() posiciones := it.field("Posicion") velocidades := it.field("Velocidad") for i : int in range(it.count()) { posicion := posiciones[i] velocidad := velocidades[i] posicion.x += velocidad.x * dt posicion.y += velocidad.y * dt }}
async fn _ready() void { mundo : World = ECS.world() mut abejas : []Entity = [] for i : int in range(1000) { abeja : Entity = mundo.entity() mundo.ecs_set(abeja, Posicion{ .y = 2.0 * i }) mundo.ecs_set(abeja, Velocidad{ .x = 10.0 }) abejas.append(abeja) } mundo.system(mover, "process", ["Posicion", "Velocidad"]) await sleep(1.0) x : float = (abejas[0].get_component_field("Posicion", "x") as float) ?? 0.0 print(roundi(x))}Dentro del sistema:
it.count()dice cuántas entidades hay en esta llamada.it.delta()da los segundos desde el frame anterior, como eldeltade_process.it.field("Posicion")da una lista con laPosicionde cada entidad. El elementoideposicionesy el elementoidevelocidadesson de la misma abeja.- Cambiar
posicion.xcambia el componente de esa entidad.
Y para registrarlo, mundo.system(mover, "process", ["Posicion", "Velocidad"]):
| Argumento | Qué es |
|---|---|
mover | La función, sin llamarla: sin paréntesis |
"process" | Cuándo corre: "process" en cada frame, "physics_process" en cada frame de física, "ready" una vez |
["Posicion", "Velocidad"] | Los componentes que necesita una entidad para entrar |
Al cabo de un segundo, cada abeja ha avanzado 10. get_component_field da un valor sin tipo
conocido: as float lo toma como número, y roundi lo redondea a un entero.
Una corrutina por entidad
Hay cosas que no son un cálculo por frame, sino una historia con esperas: un faro que parpadea,
una trampa que se abre y se cierra. Para eso está task_system, que arranca una corrutina
(lección anterior) por cada entidad que tiene los componentes:
module Faros
Faro :: struct { brillo : float = 1.0}
async fn parpadear(_faro: Entity) void { defer { print("faro apagado") } loop { print("luz") await sleep(1.0) }}
async fn _ready() void { mundo : World = ECS.world() faro : Entity = mundo.entity() mundo.ecs_set(faro, Faro{}) mundo.task_system(parpadear, ["Faro"]) await sleep(2.5) faro.remove_component("Faro")}- La función es una
async fnque recibe la entidad. - Arranca una vez cuando una entidad pasa a tener todos los componentes. Una entidad nueva que cumple después recibe la suya.
- Cuando la entidad pierde uno de esos componentes, o se destruye, su corrutina se cancela:
corren sus
defer, así que puede recoger. Aquí, al quitarleFaro, se apaga.
Cuál usar
| Quieres | Usa |
|---|---|
| Pocas cosas con comportamiento propio (el jugador, un jefe, un menú) | Un prefab con su código |
| El mismo cálculo, en cada frame, en muchas entidades (mover, envejecer, desvanecer) | ECS.world().system |
| Una secuencia con esperas, por entidad (puertas, trampas, faros) | ECS.world().task_system |
Puedes mezclarlos en el mismo juego: prefabs para los personajes y sistemas para el enjambre.
Hora de practicar
¿Qué es una entidad en un ECS?
Completa el sistema que cura una vida por frame a todas las entidades con Vida, y regístralo.
Vida :: struct {
puntos : int = 3
}
fn curar(it: EcsSystemIterator) void {
vidas := it.("Vida")
for i : int in range(it.()) {
vida := vidas[i]
vida.puntos += 1
}
}
fn _ready() void {
ECS.world().(curar, "process", ["Vida"])
}Vida :: struct {
puntos : int = 3
}
fn curar(it: EcsSystemIterator) void {
vidas := it.field("Vida")
for i : int in range(it.count()) {
vida := vidas[i]
vida.puntos += 1
}
}
fn _ready() void {
ECS.world().system(curar, "process", ["Vida"])
}Quieres que tres mil chispas se desvanezcan un poco en cada frame. ¿Qué usas?
loop sin await congelaría el juego.¿Qué le pasa a la corrutina de un task_system cuando su entidad pierde uno de sus componentes?
defer pueden recoger.