How does an ECS work for a world subdivided into chunks (example)?

Question

I am trying to use an ECS for my 2d game at the moment. Up until now I had my world subdivided into chunks (as minecraft does) of size 64x64. They are loaded and drawn when they come onto screen. I did this to reduce the drawing calls.

How would something like this work in an ECS? I would say my Chunks have the following properties at the moment: tile_is_water[64,64], humidity[64,64], sprite_batch (the thing that is drawn)

At some intervals I will need to call some kind of updatefunction which uses tile_is_water and humidity to generate a new sprite_batch (but not very often, these change rarely). On every frame I need to draw the sprite_batch. On every (or maybe every few) frame I need to check which areas are visible and set some kind of flag s.t. I only draw the visible ones.

It would help me a lot of someone could explain to me what the components, the entities and systems would be in this case.

Edit: To clarify. I don't have this modelled as an ECS yet and I have problems modelling this particular issue. What I have until now is just seperated everything into components: Components: Is_Water_Area, HumidityArea, SpriteBatch Is_Water_Area and HumidityArea just contain the corresponding 64x64 arrays and sprite_batch contains the drawable spritebatch. I also have a BatchDrawer system that draws everything that has a SpriteBatch. But where do I do the updating of the SpriteBatch for example? Where do I check which areas are drawn?

For example I could just check this every frame or I could keep a list of drawable Areas and update that. But where would I keep such a list of the drawable areas?

Answer 1

This answer is focused on how I would approach solving the problem instead of a prebaked specific answer.

For google reference, the basic ideas are based on broad phase and narrow phase collision detection.

First, list out the facts and invariants that you can depend on. E.g.

• Size of Chunk.
• Player movement
• Calculate (d) the time required for a player to cross one Chunk of map.
• Calculate (d_2) the time required to traverse 1/2 of one Chunk.

Create a Component for tracking Player_Loaded_Chunks

Create a System which runs every (d_2) intervals of time. (d_2 because you need to load the world BEFORE it comes into view)

foreach available chunk:
    Is the player within (d) travel time of a chunk which is not loaded/generated/rendered yet?
        yup
            Load the chunk the player just moved into range of.
            (Other Systems should use this as a trigger to create your various Terrain/Object/Map entities in that chunk)
        nope
            chunk out of range, ignore
foreach loaded chunk:
    Is the player OUT OF RANGE of this already loaded chunk?
        yup
            Unload the chunk
        nope
            keep it loaded

This approach allows you to run far less than every frame, potentially only every few seconds.

Obviously you'll need to tune many factors for your specific case.

• Are you allowing teleports? Better have a teleport delay to allow loading the other end of the map

• Speed boosting items? Same deal.

• If your chunks are huge, you can't hold as many in memory, but you run the algorithm less often
• If your chunks are tiny compared to player speed, you need to run the load/unload more often

Highly advanced drawing to add flavor to this answer: