Ir al contenido
Descargar
Curso de Grost

ECS: entidades y sistemas

Módulo 4 · Herramientas de juegoLección 17 de 209 min de lectura4 retos
main.groPaso 1 de 4
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)
}
Output
5.0
main.groPaso 2 de 4
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"))
}
Output
true
main.groPaso 3 de 4
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.}
Output

Este código todavía no imprime nada.

main.groPaso 4 de 4
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.}
Output
10
También con las flechas ← →

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:

PiezaQué esEn un enjambre
EntidadSolo una identidad: no tiene código propioCada abeja
ComponenteDatos sueltos pegados a una entidadSu posición, su velocidad
SistemaUna función que corre sobre todas las entidades que tienen ciertos componentesMover 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:

main.gro
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"))
}
Outputtrue 5.0
  • 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 componente Posicion con esos valores.
  • has_component dice si la entidad lo tiene, y get_component_field lee 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:

main.gro
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))
}
Output10

Dentro del sistema:

  • it.count() dice cuántas entidades hay en esta llamada.
  • it.delta() da los segundos desde el frame anterior, como el delta de _process.
  • it.field("Posicion") da una lista con la Posicion de cada entidad. El elemento i de posiciones y el elemento i de velocidades son de la misma abeja.
  • Cambiar posicion.x cambia el componente de esa entidad.

Y para registrarlo, mundo.system(mover, "process", ["Posicion", "Velocidad"]):

ArgumentoQué es
moverLa 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:

main.gro
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")
}
Outputluz luz luz faro apagado
  • La función es una async fn que 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 quitarle Faro, se apaga.

Cuál usar

QuieresUsa
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

Retos: 0/4 resueltosSe guardan en este navegador
Reto 1 de 4sin resolver

¿Qué es una entidad en un ECS?

Una entidad no tiene código ni datos propios: los datos son sus componentes y el comportamiento lo ponen los sistemas.
Piensa en quién tiene los datos y quién tiene el código en un ECS.
Reto 2 de 4sin resolver

Completa el sistema que cura una vida por frame a todas las entidades con Vida, y regístralo.

main.gro
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"])
}
El iterador da los componentes con una función y el número de entidades con otra. El mundo registra el sistema.
Solución:
main.gro
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"])
}
Reto 3 de 4sin resolver

Quieres que tres mil chispas se desvanezcan un poco en cada frame. ¿Qué usas?

Un sistema hace el mismo cálculo sobre todas las entidades en cada frame. Tres mil scripts costarían demasiado, y un loop sin await congelaría el juego.
Es el mismo cálculo, en cada frame, sobre muchas cosas.
Reto 4 de 4sin resolver

¿Qué le pasa a la corrutina de un task_system cuando su entidad pierde uno de sus componentes?

La corrutina solo vive mientras la entidad tiene todos los componentes. Al perder uno se cancela, y sus bloques defer pueden recoger.
Recuerda el faro de la lección.