ENTT and synchronizing registry over the network

[Show-vars]

Hello everyone!

Surely this issue has been discussed more than once and I think this problem has been solved already, but I have not yet been able to find such a solution for myself.

The entt library is gorgeous and I have successfully used a lot including ECS ​​itself in new project. But I am facing the problem of using entt with networking. It is supposed to use an authoritative server and dummy clients to create a multiplayer game. The basic idea is to keep the server registry synchronized with the client's one. This synchronization should happen every iteration of the game loop (like every 33 ms). Ideally, when forming a packet with the next updated world, you need to send only what has changed directly and at the same time be able to send the full state if a connection failure occurs.

I know that entt has a lot of building blocks for this, like continuous loader, change observers, dependencies. But I can't manage to combine all this into a convenient API for working with synchronization. It is possible to mark an entity with the NetSync like component, take these entities in the appropriate system, and what next? How do I get only those components that have been changed? It is possible to make a callback function in the component NetSync, which will provide a call list of components required for synchronization, but how to understand if a specific component has been changed at this moment?

Moreover, there is a wonderful thing as a continuous loader. How will the synchronization of the removal of components or the removal of entities take place?

[skypjack]

How to synchronize a registry over a network really depends on what you're trying to achieve. There doesn't exist a one-catch-all solution and this doesn't depend on the specific library in use.
For example, just the fact that entities are spawned locally or not changes the approach I would use. So, it's hard to provide you with a pre-cooked method.
You can try to give more details about your use case if you want, maybe we can be able to help you somehow.
Also, considering the upcoming holidays, forgive any lag in case. 🙂

To answer your questions instead, of course you can tag entities with a dedicated component. Probably you don't want to take all the components that have been changed though. More often than not there are data that should not be sent to a server because they are useful only for the local simulation.
So, if your set is fixed and you know that you're only interested in N component types, you can put something like a bitset on your NetSync, update it on change (maybe using on_update?) and read it when sending over the network. If you want something more flexible than a fixed size bitset, you can listen for changes and use observers or something similar to track entities or you can mark your components as dirty when changed.
Another approach that uses a feature available upstream is that of defining a custom pool instead. You don't have to listen for changes in this case, because the pool will keep track of them for you. Then you can serialize a pool at a time and ask them what components have changed. You could also move instances at the top or the end of an array to have them fully packed and therefore to serialize them in a blink.
Something more rude but that could work is to define your own entity identifier, reserve some bits for your own uses and set them when needed to mark a component as changed on a per-pool basis. I wouldn't suggest this approach to be honest, but still.

Among other things, while writing I realized that the best approach for your case also depends on how you want to send the data over the network. Divided by entity, by component type, and so on. Again, the problem defines the solution.

I'm looking forward to your feedback to continue the discussion. 👍

[gamecoder-nz]

I know this is an old post but I have been thinking about this problem for my game. Yes have something like a NetSync component and when the client creates an entity it will send a message to the server saying an entity is created. The server will create an entity in its own registry and put the client entity ID into the component. It will then send its entity ID back to the client which will put it into the clients NetSync component. The server will send a message to all other clients saying that a new entity has been created and the other clients will create a new entity with the server's entity ID in the NetSync component.

I think the better approach would be to update the server when an event has occurred like creating a new entity or if the user and pressed the forward button etc

[xissburg]

I assign a network_tag to all networked entities and listen to on_construct<network_tag>() to add all new networked entities to a vector which is later consumed in an update where a packet is created to notify the other end of the created entities and components.

I also use a dirty component which contains the type ids of components that have changed. I mark them as dirty manually. Then, in every update, I consume the dirty components, adding the information to a packet which contains the updated data. The packet can either contain a set of pools, where each element is made of the type id (which has to be the same across client and server) and a list of (entity, component) pairs, or it can be a list where each element contains an entity followed by its components, which is a list of (type id, component) pairs.

When a create_entity packet is received, corresponding entities are created in the local registry and an entity map is used to store the mapping from remote to local and vice-versa. It's essentially a pair of reversed hash maps that is kept synchronized. The new entity mappings are relayed back so the other end knows into which remote entities their local entities have been mapped to. Packets are always sent containing the local entities in them, so on the receiving end, entities have to be mapped into local space, thus the need to know the entity mappings in the other end.

Components that contains entities in them must go through entity mapping as well. That means either overloading a function for each type or using entt::meta to provide type information which allows a generic piece of code to find all members that contain entities and replacing their data by the mapped value.