Entity Component System?

[msakuta]

ECS and Rust seems to get along well:
https://youtu.be/aKLntZcp27M

Why not implement it in our game?

I tested with 100 pipes and measured performance in ecs-specs-structure-slice

and this is pre-ECS (Box dynamic polymorphism) :

[msakuta]

I increased number of pipes to 400 to measure differences more accurately.

ECS:

pre-ECS (dynamic polymorphism):

Clearly both of them scale poorly, but pre-ECS is an order of magnitude faster.

[msakuta]

There is a third option, which I call half-baked ECS. The components can be grouped together in the same allocation unit.

pub(crate) struct StructureComponents {
    pub position: Option<Position>,
    pub rotation: Option<Rotation>,
    pub burner: Option<Burner>,
    pub energy: Option<Energy>,
    pub factory: Option<Factory>,
    pub fluid_boxes: Vec<FluidBox>,
}

It is not very good at utilizing memory, since it has a lot of wasted space in absent components, but it performs marginally better than dynamic polymorphism, probably due to less invocations of virtual functions. Also we can always reduce an empty component by putting in a Box or Vec.

And we can optimize the fluid simulation even further by calculating connections only something has changed.

And dynamic polymorphism is still slower after the optimization, probably due to the virtual function call:

[msakuta]

Now I implemented generational id so that each structure can hold references to each other that can be dereferenced in constant time.

pub(crate) struct StructureId {
    pub id: u32,
    pub gen: u32,
}

Now the performance with 400 pipes is unmeasurable. (We don't care too much about rendering time here because we won't render the whole map at once and ECS's goal is not to improve rendering performance, and we will migrate to WebGL or WebGPU if we really need rendering performance.)

[msakuta]

Now I test with 400 chests and inserters that move items in circle!

With dynamic polymorphism without generational id optimization:

With generational id optimization:

So much improvement!

In fact, the most effective optimization is generational id, rather than ECS.

[msakuta]

Now testing a lot of wire connections

We optimize electricity grid calculation by using a cache data structure called PowerNetwork. Each PowerNetwork contains a list of power sources and sinks as StructureId lists, so the sinks can quickly query sources.

pub(crate) struct PowerNetwork {
    pub wires: Vec<PowerWire>,
    pub sources: HashSet<StructureId>,
    pub sinks: HashSet<StructureId>,
}

Each color of the wires indicate distinct networks in the picture below.

with dynamic polymorphism:

[msakuta]

I ported 400 chests and inserters test with ECS + generational id, and it shows pretty similar performance to dynamic polymorphism.

[msakuta]

And finally, 400 assemblers and electric wires on half-baked ECS + generational id

In conclusion, generational ids improves so much that we can't miss it, and half-baked ECS can further improve the performance 1-2 times.