GameService.Sdk.LudoDoubles 1.0.0

GameService DoubleDice SDK

The DoubleDice SDK is a relay client for client-authoritative games. Game logic runs entirely on the Unity client — the server simply broadcasts data between all players in a room.

Installation in Unity

1. Install NuGetForUnity
2. Install NuGet packages:
   • GameService.Sdk.Core
   • GameService.Sdk.DoubleDice
   • protobuf-net
3. Or copy the source files into Assets/Scripts/Sdk/

Quick Start

1. Connect & Create Client

using GameService.Sdk.Core;
using GameService.Sdk.LudoDoubles;

public class DoubleDiceManager : MonoBehaviour
{
    private GameClient gameClient;
    private LudoClient ludoClient;

    private async void Start()
    {
        // Connect to GameService
        gameClient = await GameClient.Create("https://your-server.com")
            .WithAccessToken(accessToken)
            .WithSynchronizationContext(true) // Ensures callbacks run on Unity main thread
            .ConnectAsync();

        // Create the DoubleDice client wrapper
        ludoClient = new LudoClient(gameClient);

        // Listen for data from other players
        ludoClient.OnDataReceived += OnDataReceived;
    }

    private void OnDataReceived(string actionName, byte[] data)
    {
        // Handle incoming game data from other players
        Debug.Log($"Received '{actionName}' ({data.Length} bytes)");
    }
}

2. Room Management

// Create a room (uses a server-side template name)
var createResult = await ludoClient.CreateRoomAsync("DoubleDice");
if (createResult.Success)
    Debug.Log($"Room: {createResult.RoomId}, Code: {createResult.ShortCode}");

// Join an existing room by short code or room ID
var joinResult = await ludoClient.JoinRoomAsync("12345");
if (joinResult.Success)
    Debug.Log($"Joined at seat {joinResult.SeatIndex}");

// Matchmaking: auto-join an available room or create a new one
var matchResult = await ludoClient.CreateOrJoinRoomAsync("DoubleDice");

// Leave the room
await ludoClient.LeaveRoomAsync();

3. Sending Game Data

Use SendData to broadcast any data to all players in the room.

Raw Bytes

// Send raw byte array
byte[] myGameState = SerializeMyState();
var result = await ludoClient.SendData("Sync", myGameState);

if (result.Success)
    Debug.Log("Data sent to all players!");

Protobuf Objects

Define your game messages with protobuf-net:

using ProtoBuf;

[ProtoContract]
public class DiceRollMessage
{
    [ProtoMember(1)] public int Dice1 { get; set; }
    [ProtoMember(2)] public int Dice2 { get; set; }
    [ProtoMember(3)] public string PlayerId { get; set; }
}

// Send typed data (auto-serialized via protobuf)
var roll = new DiceRollMessage { Dice1 = 4, Dice2 = 6, PlayerId = "player1" };
await ludoClient.SendData("Roll", roll);

4. Receiving Game Data

All incoming data arrives via the OnDataReceived event:

ludoClient.OnDataReceived += (actionName, data) =>
{
    switch (actionName)
    {
        case "Roll":
            var roll = Deserialize<DiceRollMessage>(data);
            Debug.Log($"Player {roll.PlayerId} rolled {roll.Dice1} + {roll.Dice2}");
            break;

        case "Sync":
            ApplyGameState(data);
            break;

        case "Move":
            var move = Deserialize<MoveMessage>(data);
            AnimateToken(move);
            break;
    }
};

// Helper to deserialize protobuf messages
T Deserialize<T>(byte[] data)
{
    using var ms = new MemoryStream(data);
    return ProtoBuf.Serializer.Deserialize<T>(ms);
}

5. Player Events (via GameClient)

Player join/leave events come from the underlying GameClient:

gameClient.OnPlayerJoined += async (player) =>
{
    Debug.Log($"{player.UserName} joined at seat {player.SeatIndex}");
};

gameClient.OnPlayerLeft += async (player) =>
{
    Debug.Log($"{player.UserName} left the game");
};

gameClient.OnPlayerDisconnected += async (info) =>
{
    Debug.Log($"{info.UserName} disconnected (grace: {info.GracePeriodSeconds}s)");
};

gameClient.OnPlayerReconnected += async (info) =>
{
    Debug.Log($"{info.UserName} reconnected!");
};

API Reference

LudoClient

Events

Architecture

Unity Client A                    Server                     Unity Client B
     │                              │                              │
     │  SendData("Roll", bytes) ──► │                              │
     │                              │ ── GameEvent("Roll") ──────► │
     │                              │    (broadcast to room)       │
     │ ◄── OnDataReceived ──────── │                              │

• Transport: SignalR (WebSockets)
• Serialization: Protobuf (binary, efficient for mobile)
• Server Role: Relay only — no game logic, no validation
• Thread Safety: Use .WithSynchronizationContext(true) to receive callbacks on Unity's main thread

Important Notes

• The actionName string is arbitrary — define whatever actions your game needs ("Roll", "Move", "Sync", "Chat", etc.)
• Data is opaque to the server — it forwards bytes without inspecting them
• The sender also receives their own OnDataReceived callback
• Use Protobuf for structured data (compact binary format, ideal for real-time games)
• Always call LeaveRoomAsync() or gameClient.DisposeAsync() when done