Implementations for storing entities in an ECS system

Question

I'm restructuring my model of entities, components and systems, where entities are:

const createEntity = (name, components) => ({
    id: genUniqueId(),
    name: name,
    components: components
});

And I came across a question, and would like to hear someone's experience about it. The question is what are the advantages and disadvantages of each of the following implementation approaches:

1 - Implement all entities in a single global object, and traverse this object by applying the systems in each entity, example:

const entities = {};
for(let key in entities)
    for(let system of systems)
       system(entities[key]);

2 - Create several global variables for each group that the systems serve, example:

const players = {};
const monsters = {};
const clouds = {};

for(let key in players)
       systems['input'](players[key]);

for(let key in monsters)
       systems['simpleAI'](monsters[key]);

for(let key in clouds)
       systems['wind'](clouds[key]);

3 - Create local variables within the systems to store the entities, and functions for each system to add and remove entities from their internal objects, example:

const windSystem = () => {
    const clouds = {};
    for(let key in clouds)
       ...
};

const addEntityInWindSystem = () => {...};
const delEntityInWindSystem = () => {...};

My intention with the question is just to look for other solutions or even understandings about the cons and advantages that each implementation can bring me during development.

Answer 1

Sander's answer mentioned families, and I wanted to add some info:

• Families group entities together based on component criterion.
• Usually, a system has one family that forms its entity list.
• Entities can be added to the system/family when they are added to the game engine, and when the system itself is added to the game engine.

Here's a basic working implementation: (I normally don't write code for people, but this is best illustrated in a working example)

class Engine {
  constructor() {
    this.systems = [];
    this.entities = [];
  }

  process() {
    this.systems.forEach(system => { system.process(system.family.getEntities()) });
  }
}

class System {
  constructor(family) {
    this.family = family;
  }

  process() {}
}

class Family {
  constructor(engine, all=[], one=[], none=[]) {
    this.all = all;   // entity must have all of these components
    this.one = one;   // entity must have at least one of these
    this.none = none; // entity must have none of these
    this.engine = engine;
  }

  matches(entity) {
    let entityComponents = entity.components.map(comp => comp.constructor);  // get constructors
    let allPassed = this.all.every(comp => entityComponents.includes(comp));
    let onePassed = !this.some || this.one.some(comp => entityComponents.includes(comp)); // if there are no 'one's, it passed (you don't need this with Array.every)
    let nonePassed = entityComponents.every(comp => !this.one.includes(comp));
    return allPassed && onePassed && nonePassed;
  }

  getEntities() {
    return this.engine.entities.filter(entity => this.matches(entity));
  }
}

class Entity {
  constructor() {
    this.components = [];
    this.id = Entity.nextId;
    Entity.nextId++;
  }
  getComponent(constr) {
    for (let i=0; i<this.components.length; i++) {
      if (this.components[i].constructor === constr) return this.components[i];
    }
    return null;
  }
  toString() { return `Entity-${this.id}`; }
}
Entity.nextId = 1;

// --- sample usage ---
// no need to subclass a `Component` class, because you need to call `super`, and it's pretty useless to have to do for every component type
class HealthComponent {
  constructor(initial) {
    this.health = initial;
  }
}

class HealthSystem extends System {
  constructor(engine) {
    super(new Family(engine, [HealthComponent]));
  }

  process(entities) {
    entities.forEach(entity => {
      if (entity.getComponent(HealthComponent).health <= 0) console.log(entity + " died");
    });
  }
}

let engine = new Engine();
engine.systems.push(new HealthSystem(engine));

let deadEntity = new Entity();
deadEntity.components.push(new HealthComponent(0));
engine.entities.push(deadEntity);

let aliveEntity = new Entity();
deadEntity.components.push(new HealthComponent(1));
engine.entities.push(aliveEntity);

engine.process();

This needs to be optimized so that a family's matched entity list is only updated when it needs to, not every time it is queried. You need to update each family when either A) an entity is added to or removed from the engine or B) an entity gains or loses a component. I would store a cached list of matched entities in each family, and, when either A or B occurs, update each list.

Answer 2

Neither of the three approaches are typical. The first approach could be considered a "naive" approach as it works, but is not very efficient because you'd need to check for every entity if it matches the system.

What an ECS framework typically does is organize entities in groups that are based on the components that they have. The groups are then matched to the systems based on a system signature, which lists which components the system is interested in.

Lets say I have set of entities A with components [Position, Velocity]. I have another set B [Position, Velocity, Mass]. These two sets would be stored in different groups, and systems are matched against these groups. A system with a [Position, Mass] signature would only be matched against group B. A system with [Position, Velocity] would be matched against both.

You could represent this with something like this:

const A = [{entity: 0, components: {position: {x:1, y:2}, velocity: 5}}, ...]
const B = [{entity: 10, components: {position: {x:3, y:4}, velocity: 5, mass: 8}}, ...]

The groups here are "A" and "B". The system is "move". Note that entities are an id, similar to a primary key in a database table. You can then match your systems against these groups any way you like.