API Bridge

1. messageType     → String (UTF-8)       nombre del MessageType enum
2. playerId        → long, long           UUID como dos longs (MSB, LSB)
3. messageId       → long, long           UUID del mensaje
4. replyToId       → boolean + long,long  null flag + UUID si no es null
5. timestamp       → long                 epoch millis
6. payloadSize     → int                  número de entradas en el payload
7. payload entries → String, String       clave y valor UTF-8 por cada entrada

<dependency>
    <groupId>com.eventui</groupId>
    <artifactId>eventui-common</artifactId>
    <version>1.0.0</version>
    <scope>provided</scope>
</dependency>

import com.eventui.api.bridge.MessageType;
import org.bukkit.entity.Player;

public void sendProgressUpdate(Player player, String eventId,
                               String objectiveId, int current, int target,
                               String description) {

    // Construir el payload como bytes con DataOutputStream
    try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
         DataOutputStream out = new DataOutputStream(baos)) {

        // 1. Tipo de mensaje
        out.writeUTF(MessageType.PROGRESS_UPDATE.name());

        // 2. Player UUID
        UUID uuid = player.getUniqueId();
        out.writeLong(uuid.getMostSignificantBits());
        out.writeLong(uuid.getLeastSignificantBits());

        // 3. Message ID
        UUID msgId = UUID.randomUUID();
        out.writeLong(msgId.getMostSignificantBits());
        out.writeLong(msgId.getLeastSignificantBits());

        // 4. ReplyTo (null)
        out.writeBoolean(false);

        // 5. Timestamp
        out.writeLong(System.currentTimeMillis());

        // 6. Payload
        Map<String, String> payload = Map.of(
            "event_id",     eventId,
            "objective_id", objectiveId,
            "current",      String.valueOf(current),
            "target",       String.valueOf(target),
            "description",  description
        );

        out.writeInt(payload.size());
        for (Map.Entry<String, String> entry : payload.entrySet()) {
            out.writeUTF(entry.getKey());
            out.writeUTF(entry.getValue());
        }

        // 7. Enviar al canal
        player.sendPluginMessage(yourPlugin, "eventui:bridge", baos.toByteArray());

    } catch (IOException e) {
        getLogger().severe("Error sending EventUI progress: " + e.getMessage());
    }
}

import org.bukkit.plugin.messaging.PluginMessageListener;
import com.eventui.api.bridge.MessageType;

public class MiPlugin extends JavaPlugin implements PluginMessageListener {

    @Override
    public void onEnable() {
        // Registrar como listener del canal de EventUI
        getServer().getMessenger().registerIncomingPluginChannel(
            this, "eventui:bridge", this
        );
    }

    @Override
    public void onPluginMessageReceived(String channel, Player player, byte[] data) {
        if (!channel.equals("eventui:bridge")) return;

        try (DataInputStream in = new DataInputStream(new ByteArrayInputStream(data))) {

            String typeStr = in.readUTF();
            MessageType type = MessageType.valueOf(typeStr);

            // Leer y descartar playerId, messageId, replyTo, timestamp
            in.readLong(); in.readLong(); // playerId
            in.readLong(); in.readLong(); // messageId
            if (in.readBoolean()) { in.readLong(); in.readLong(); } // replyTo
            in.readLong(); // timestamp

            // Leer payload
            int size = in.readInt();
            Map<String, String> payload = new HashMap<>();
            for (int i = 0; i < size; i++) {
                payload.put(in.readUTF(), in.readUTF());
            }

            if (type == MessageType.UI_BUTTON_CLICKED) {
                String buttonId = payload.get("button_id");
                String eventId  = payload.get("event_id");
                handleButtonClick(player, buttonId, eventId);
            }

        } catch (IOException e) {
            getLogger().warning("Error reading EventUI message: " + e.getMessage());
        }
    }

    private void handleButtonClick(Player player, String buttonId, String eventId) {
        // Tu lógica aquí
        getLogger().info(player.getName() + " clicked button: " + buttonId);
    }
}

dependencies {
    modImplementation "com.eventui:eventui-common:1.0.0"
}

import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
import net.minecraft.util.Identifier;
import com.eventui.api.bridge.MessageType;

public class MiModClient implements ClientModInitializer {

    private static final Identifier EVENTUI_CHANNEL =
        Identifier.of("eventui", "bridge");

    @Override
    public void onInitializeClient() {
        ClientPlayNetworking.registerGlobalReceiver(
            EVENTUI_CHANNEL,
            (client, handler, buf, responseSender) -> {

                // Leer el mensaje en el hilo de red
                byte[] data = new byte[buf.readableBytes()];
                buf.readBytes(data);

                try (DataInputStream in =
                     new DataInputStream(new ByteArrayInputStream(data))) {

                    String typeStr = in.readUTF();
                    MessageType type = MessageType.valueOf(typeStr);

                    // Descartar campos de metadata
                    in.readLong(); in.readLong(); // playerId
                    in.readLong(); in.readLong(); // messageId
                    if (in.readBoolean()) { in.readLong(); in.readLong(); }
                    in.readLong(); // timestamp

                    // Leer payload
                    int size = in.readInt();
                    Map<String, String> payload = new HashMap<>();
                    for (int i = 0; i < size; i++) {
                        payload.put(in.readUTF(), in.readUTF());
                    }

                    if (type == MessageType.EVENT_STATE_CHANGED) {
                        String eventId  = payload.get("event_id");
                        String newState = payload.get("new_state");

                        // Ejecutar en el hilo del juego (obligatorio para rendering)
                        client.execute(() -> {
                            if ("COMPLETED".equals(newState)) {
                                spawnCompletionParticles(client, eventId);
                            }
                        });
                    }

                } catch (IOException e) {
                    // ignorar mensajes malformados
                }
            }
        );
    }

    private void spawnCompletionParticles(MinecraftClient client, String eventId) {
        // Tu lógica de partículas aquí
    }
}

import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
import net.fabricmc.fabric.api.networking.v1.PacketByteBufs;
import com.eventui.api.bridge.MessageType;

public static void sendButtonClick(String buttonId, String eventId, UUID playerId) {
    try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
         DataOutputStream out = new DataOutputStream(baos)) {

        out.writeUTF(MessageType.UI_BUTTON_CLICKED.name());

        out.writeLong(playerId.getMostSignificantBits());
        out.writeLong(playerId.getLeastSignificantBits());

        UUID msgId = UUID.randomUUID();
        out.writeLong(msgId.getMostSignificantBits());
        out.writeLong(msgId.getLeastSignificantBits());

        out.writeBoolean(false); // sin replyTo
        out.writeLong(System.currentTimeMillis());

        out.writeInt(2);
        out.writeUTF("button_id"); out.writeUTF(buttonId);
        out.writeUTF("event_id");  out.writeUTF(eventId);

        PacketByteBuf buf = PacketByteBufs.create();
        buf.writeBytes(baos.toByteArray());

        ClientPlayNetworking.send(
            Identifier.of("eventui", "bridge"), buf
        );

    } catch (IOException e) {
        // manejar error
    }
}

import com.eventui.fabric.client.bridge.ClientEventBridge;
import com.eventui.api.bridge.MessageType;

// En tu ClientModInitializer, después de que EventUI se haya inicializado:
ClientEventBridge bridge = ClientEventBridge.getInstance();

bridge.registerMessageHandler(MessageType.EVENT_STATE_CHANGED, message -> {
    String eventId  = message.getPayload().get("event_id");
    String newState = message.getPayload().get("new_state");

    MinecraftClient.getInstance().execute(() -> {
        if ("COMPLETED".equals(newState)) {
            // Tu lógica aquí
        }
    });
});