Ludo SDK — Libraries, Wrappers & SDK Design

// Install: npm install ludokingapi-js

import { LudoKingAPI, GameEvent, PlayerMove } from 'ludokingapi-js';

// Initialize the SDK with your API key
const ludo = new LudoKingAPI({
  apiKey: 'your_api_key_here',
  environment: 'production', // or 'sandbox'
  logLevel: 'info'
});

// Create a new game room
const room = await ludo.rooms.create({
  maxPlayers: 4,
  gameMode: 'classic',
  isPrivate: false
});

console.log('Room code:', room.code); // e.g. "ABCD1234"

// Listen for game events
ludo.on(GameEvent.DICE_ROLLED, ({ value, playerId }) => {
  console.log(`Player ${playerId} rolled: ${value}`);
  updateDiceUI(value);
});

ludo.on(GameEvent.TOKEN_MOVED, ({ playerId, from, to, captured }) => {
  animateToken(playerId, from, to);
  if (captured) playCaptureAnimation();
});

// Make a move (SDK validates client-side for instant feedback)
const result = await ludo.move({
  roomCode: room.code,
  tokenId: 'token_2'
});

if (!result.valid) {
  console.error('Invalid move:', result.reason);
}

// Get current game state at any time
const state = await ludo.getState(room.code);
console.log('Current turn:', state.currentPlayerId);
console.'Board state:', state.board);

# Install: pip install ludokingapi

import asyncio
from ludokingapi import AsyncLudoKingAPI, GameEvent

async def main():
    client = AsyncLudoKingAPI(api_key="your_api_key")

    await client.connect()
    print("Connected to LudoKingAPI")

    # Create a room and register event handlers
    room = await client.create_room(max_players=4)
    print(f"Room code: {room.code}")

    async for event in client.listen(room.code):
        if event.type == GameEvent.DICE_ROLLED:
            print(f"Dice: {event.value}")
            await client.move(room.code, token_id="token_1")
        elif event.type == GameEvent.GAME_OVER:
            print(f"Winner: {event.winner_id}")
            break

    await client.disconnect()

asyncio.run(main())

// src/ludo-sdk/core/Transport.ts — Abstract transport layer
export interface Transport {
  get<T>(path: string, params?: Record<string, unknown>): Promise<T>;
  post<T>(path: string, body?: unknown): Promise<T>;
  delete(path: string): Promise<void>;
}

// src/ludo-sdk/core/RESTTransport.ts — Axios-based HTTP transport
export class RESTTransport implements Transport {
  private baseURL: string;
  private headers: Record<string, string>;

  constructor(config: { baseURL: string; apiKey: string }) {
    this.baseURL = config.baseURL;
    this.headers = {
      'Authorization': `Bearer ${config.apiKey}`,
      'Content-Type': 'application/json'
    };
  }

  async get<T>(path: string, params?: Record<string, unknown>): Promise<T> {
    const url = new URL(`${this.baseURL}${path}`);
    if (params) url.search = new URLSearchParams(params as Record<string, string>).toString();
    const res = await fetch(url.toString(), { headers: this.headers });
    if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
    return res.json() as Promise<T>;
  }

  async post<T>(path: string, body?: unknown): Promise<T> {
    const res = await fetch(`${this.baseURL}${path}`, {
      method: 'POST',
      headers: this.headers,
      body: body ? JSON.stringify(body) : undefined
    });
    if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
    return res.json() as Promise<T>;
  }

  async delete(path: string): Promise<void> {
    const res = await fetch(`${this.baseURL}${path}`, {
      method: 'DELETE', headers: this.headers
    });
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
  }
}

// src/ludo-sdk/core/version.ts
import { version as SDK_VERSION } from '../package.json';

export const API_COMPATIBILITY = {
  // Maps SDK major version to minimum supported API version
  '3': 'v2025.01',
  '2': 'v2024.06',
  '1': 'v2024.01' // deprecated
};

export function checkCompatibility(apiVersion: string): boolean {
  const sdkMajor = SDK_VERSION.split('.')[0];
  const minApi = API_COMPATIBILITY[sdkMajor];
  return apiVersion >= minApi;
}