Use of Bundle for Multiplayer

[Cluelessoreo]

In the Dokumentation you can read about the fxgl-net Module. Id like to implement a Muliplayer and to my understanding there is an Multiplayer option.
I was hoping there would be an easy way to send the entire game world state, but I'm a bit confused about the purpose of the Bundle() class. It seems like it just stores data similarly to a JSON object, meaning it only supports serializable objects.

So my question is, is there a way to send an entire Entity (or multiple entities) over the network?
Or do I always have to manually extract and send the entity's data as a separate object?

Where exactly is the net module used or integrated within FXGL? I’ve found some built-in features and a few examples that use it. I also came across the multiplayer system here:
https://github.com/AlmasB/FXGL/blob/dev/fxgl/src/main/kotlin/com/almasb/fxgl/multiplayer/MultiplayerService.ktt
I was hoping to find something similiar to net. But it seems scattert throughout the repository?

[AlmasB]

Hi,

You are correct about Bundle. Conceptually, it is similar to a JSON object.

So my question is, is there a way to send an entire Entity (or multiple entities) over the network?

The answer is yes and no. The multiplayer service is still in development, though basic replication exists. So whilst you cannot send 100% of your entity data, there are a few parts of it that you can send via the service. Here's a standalone sample that shows how to use multiplayer service and its basic replication. See if this supports your use case.

There is also an older video tutorial with a slightly different example, so may be useful.

Where exactly is the net module used or integrated within FXGL?

The net service (reasonably stable) provides lower level networking APIs, such as TCP/UDP/websocket connections or http requests. The multiplayer service (still in development) sits on top of the net service and provides gameplay APIs, such as the ability to send entity or input data.

Finally, if the above doesn't support your use case, feel free to elaborate on it here, so we can turn it into a feature request, for later implementation.

[Cluelessoreo]

Hi Almas,
Thank you very much for your quick reply.
Since you asked about our specific use case: We are currently working on a student project to create an isometric, turn-based versus game (inspired by Subset Games Into The Breach). You can check it out here if you like: Github Repository

We have continued to experiment with Bundle() and implemented a custom BundleFactory class. The functions are currently untested.

public class BundleFactory {

    // Entity to Bundle Serialisierung
    public static Bundle entityToBundle(Entity entity) {
        Bundle bundle = new Bundle("Entity");

        // Entity-Identity via IdComponent
        if (entity.hasComponent(IDComponent.class)) {
            bundle.put("id", entity.getComponent(IDComponent.class).getId());
        } else {
            bundle.put("id", -1); // oder optional: throw new IllegalStateException(...)
        }
        // Type
        bundle.put("type", entity.getType().toString());

        // Position
        Point2D gridPos = entity.getPosition();
        bundle.put("posX", gridPos.getX());
        bundle.put("posY", gridPos.getY());

        // HP/AP
        if (entity.hasComponent(APComponent.class)) {
            APComponent ap = entity.getComponent(APComponent.class);
            bundle.put("ap", ap.getCurrentAP());
            bundle.put("maxAP", 5); // Wenn dynamisch, dann ap.getMaxAP()
        }

        // Current direction as image name
        if (entity.hasComponent(RotateComponent.class)) {
            String facing = getTankDirection(entity);
            bundle.put("direction", facing);
        }

For more context you can check this out:
Source Code for the BundleFactory

This makes sense to our spaghetti-code minds, but we are still uncertain if this implementation will even work as we intended.
An alternative idea we are throwing around is just sending the actions. In the game, players take their turns locally, creating actions with the ActionComponent as they go along, and then sending those actions as instructions to 'their' vehicle on the other player's client instead of sending the new location. It works with the local game, but we don't know if it will online.

Our current multiplayer setup is structured as a multi-module setup where the client and server are organized in separate modules, each with its own gradle project.
This way we ensure our fat-client only sends data to our server. The Server is supposed to validate the actions. Can the FXGL multiplayer (or net) module work across independent modules? For example, is it possible to use the same Bundle serialization logic in both client and server even if they are not part of the same FXGL application?
It's just that in your tutorial videos, we kept seeing one of the clients also acting as the server and we are unsure how to change this since it kinda conflicts with this concept.

Thank you,
Kind regards,
Team Robust Games

P.S.: we are always available for a Discord call if you have the time and are interested in our project (or would like us to clarify our confusing code). Otherwise, we are more than happy to continue trying to explain our attempts at properly utilising your great library.

[AlmasB]

For example, is it possible to use the same Bundle serialization logic in both client and server even if they are not part of the same FXGL application?

Yes, based on the above code, I'm inclined to say that this should work. Before building the entire infrastructure, I'd recommend that you build a simple client and a simple server in their respective modules. Then send a Bundle object with some data types, including int, double, String for testing purposes. If the example works, it proves that your concept is correct.