@gamerstake/game-core 0.1.0

package/DEVELOPER_GUIDE.md

@@ -0,0 +1,996 @@
+# Developer Guide - @gamerstake/game-core
+
+> **A comprehensive guide to building multiplayer games with game-core**
+
+This guide will teach you everything you need to know to build multiplayer games using the `@gamerstake/game-core` engine.
+
+## Table of Contents
+
+1. [Introduction](#introduction)
+2. [Core Concepts](#core-concepts)
+3. [Getting Started](#getting-started)
+4. [Architecture Overview](#architecture-overview)
+5. [Building Your First Game](#building-your-first-game)
+6. [Advanced Topics](#advanced-topics)
+7. [Performance Optimization](#performance-optimization)
+8. [Common Patterns](#common-patterns)
+9. [Troubleshooting](#troubleshooting)
+10. [Best Practices](#best-practices)
+
+---
+
+## Introduction
+
+`@gamerstake/game-core` is a **game-agnostic multiplayer engine** that handles the complex infrastructure of real-time multiplayer games so you can focus on your game logic.
+
+### What game-core provides
+
+**Fixed tick rate game loop** (20 TPS with drift compensation)
+**Authoritative server architecture** (server is the source of truth)
+**Client-server networking** (via Socket.io)
+**State synchronization** (full snapshots + delta updates)
+**Input buffering** (reliable command processing)
+**Entity management** (ECS-lite with dirty tracking)
+**Spatial partitioning** (grid-based O(1) queries)
+**Basic 2D physics** (velocity, position, AABB collision)
+**Performance monitoring** (real-time metrics)
+
+### What you need to provide
+
+**Game rules** (implement the `GameRules` interface)
+**Game client** (render game state, send inputs)
+**Persistence** (optional - save/load game state)
+**Authentication** (optional - player identity)
+
+---
+
+## Core Concepts
+
+### 1. Game Server
+
+The **GameServer** manages multiple rooms (game instances).
+
+```typescript
+const gameServer = new GameServer();
+gameServer.setServer(io); // Socket.io instance
+```
+
+- One GameServer per process
+- Can host multiple rooms
+- Handles room lifecycle
+
+### 2. Room
+
+A **Room** is a single game instance (match, level, world).
+
+```typescript
+const room = gameServer.createRoom('room-1', gameRules, config);
+```
+
+- Has its own game loop running at fixed tick rate (default: 20 TPS)
+- Contains entities (players, items, NPCs)
+- Manages networking, spatial partitioning, input processing
+- Can be **persistent** (metaverse) or **match-based** (battle royale)
+
+### 3. GameRules Interface
+
+The **GameRules** interface is where YOU implement your game logic.
+
+```typescript
+interface GameRules {
+  onRoomCreated(room: Room): void;
+  onPlayerJoin(room: Room, player: Entity): void;
+  onPlayerLeave(room: Room, playerId: string): void;
+  onTick(room: Room, delta: number): void;
+  onCommand(room: Room, playerId: string, command: Command): void;
+  shouldEndRoom(room: Room): boolean;
+}
+```
+
+**Think of it as hooks** - the engine calls your code at the right times.
+
+### 4. Entity
+
+An **Entity** represents any game object (player, NPC, item, projectile).
+
+```typescript
+const player = new Entity('player-1', x, y);
+player.setVelocity(100, 0); // Move right at 100 units/sec
+player.updatePosition(deltaMs); // Apply velocity
+```
+
+**Key features:**
+
+- Position (x, y) and velocity (vx, vy)
+- Dirty flag tracking (only broadcast changed entities)
+- Extensible (subclass for custom properties)
+
+### 5. Registry
+
+The **Registry** manages entity lifecycle (add, remove, iterate).
+
+```typescript
+room.getRegistry().forEach((entity) => {
+  // Process all entities
+});
+
+const player = room.getRegistry().get(playerId);
+```
+
+### 6. Grid (Spatial Partitioning)
+
+The **Grid** divides the world into cells for efficient spatial queries.
+
+```typescript
+const nearby = room.getGrid().getNearbyEntities(x, y, range);
+```
+
+- **O(1) queries** instead of O(n²) distance checks
+- Essential for collision detection, visibility, etc.
+
+### 7. Networking
+
+The **Network** layer abstracts Socket.io and handles state broadcasting.
+
+```typescript
+room.broadcast({ op: 'GAME_EVENT', data: ... });
+room.sendTo(playerId, { op: 'PRIVATE_MSG', msg: 'Hello' });
+```
+
+### 8. Snapshot System
+
+**Snapshots** synchronize game state to clients.
+
+- **Full snapshot** on initial connection (all entities)
+- **Delta updates** every tick (only changed entities)
+- Bandwidth efficient
+
+---
+
+## Getting Started
+
+### Prerequisites
+
+- Node.js 20+
+- TypeScript 5.3+
+- Socket.io 4.7+
+
+### Installation
+
+```bash
+pnpm add @gamerstake/game-core socket.io
+pnpm add -D @types/node typescript
+```
+
+### Project Structure
+
+```
+my-game/
+ server/
+ index.ts # Server entry point
+ GameRules.ts # Your game logic
+ entities/
+ Player.ts # Custom entity types
+ client/
+ index.ts # Client entry point
+ renderer.ts # Game rendering
+ shared/
+ types.ts # Shared types
+```
+
+---
+
+## Architecture Overview
+
+### Data Flow
+
+```
+Client Server
+
+ C_MOVE (input) >
+
+ [InputQueue]
+
+ [Game Tick]
+ - Process inputs
+ - Update entities
+ - Check collisions
+
+ < S_UPDATE (state)
+
+ [Render]
+```
+
+### Tick Cycle (20 TPS = 50ms per tick)
+
+```
+1. Process queued inputs (onCommand)
+2. Update game state (onTick)
+3. Check win conditions (shouldEndRoom)
+4. Broadcast state changes (automatic)
+5. Sleep until next tick
+```
+
+---
+
+## Building Your First Game
+
+Let's build a simple **multiplayer tag game** where players chase each other!
+
+### Step 1: Define Game Rules
+
+```typescript
+// server/TagGameRules.ts
+import { GameRules, Room, Entity, Command, MoveCommand } from '@gamerstake/game-core';
+
+interface TagPlayer extends Entity {
+  isIt: boolean;
+}
+
+export class TagGameRules implements GameRules<TagPlayer> {
+  onRoomCreated(room: Room<TagPlayer>): void {
+    console.log('Tag game created! Waiting for players...');
+  }
+
+  onPlayerJoin(room: Room<TagPlayer>, player: TagPlayer): void {
+    // Spawn at random position
+    player.setPosition(Math.random() * 1000, Math.random() * 1000);
+
+    // First player is "it"
+    const players = Array.from(room.getRegistry().values());
+    player.isIt = players.length === 1;
+
+    room.broadcast({
+      op: 'PLAYER_JOINED',
+      playerId: player.id,
+      isIt: player.isIt,
+    });
+  }
+
+  onPlayerLeave(room: Room<TagPlayer>, playerId: string): void {
+    room.broadcast({
+      op: 'PLAYER_LEFT',
+      playerId,
+    });
+
+    // If "it" player left, pick a new one
+    const players = Array.from(room.getRegistry().values());
+    if (players.length > 0 && !players.some((p) => p.isIt)) {
+      players[0].isIt = true;
+      room.broadcast({
+        op: 'NEW_IT',
+        playerId: players[0].id,
+      });
+    }
+  }
+
+  onTick(room: Room<TagPlayer>, delta: number): void {
+    const players = Array.from(room.getRegistry().values());
+
+    // Update positions
+    players.forEach((p) => {
+      if (p.vx !== 0 || p.vy !== 0) {
+        p.updatePosition(delta);
+
+        // Keep in bounds
+        p.x = Math.max(0, Math.min(1000, p.x));
+        p.y = Math.max(0, Math.min(1000, p.y));
+      }
+    });
+
+    // Check for tag collisions
+    const itPlayer = players.find((p) => p.isIt);
+    if (!itPlayer) return;
+
+    for (const other of players) {
+      if (other.id === itPlayer.id) continue;
+
+      const dist = Math.hypot(itPlayer.x - other.x, itPlayer.y - other.y);
+
+      if (dist < 50) {
+        // Tag range
+        // Tagged!
+        itPlayer.isIt = false;
+        other.isIt = true;
+
+        room.broadcast({
+          op: 'TAGGED',
+          tagger: itPlayer.id,
+          tagged: other.id,
+        });
+
+        break;
+      }
+    }
+  }
+
+  onCommand(room: Room<TagPlayer>, playerId: string, command: Command): void {
+    const player = room.getRegistry().get(playerId);
+    if (!player) return;
+
+    if (command.type === 'move') {
+      const moveCmd = command as MoveCommand;
+      const speed = player.isIt ? 250 : 200; // "It" is faster!
+
+      const len = Math.hypot(moveCmd.dir.x, moveCmd.dir.y);
+      if (len > 0) {
+        player.setVelocity((moveCmd.dir.x / len) * speed, (moveCmd.dir.y / len) * speed);
+      }
+    } else if (command.type === 'stop') {
+      player.setVelocity(0, 0);
+    }
+  }
+
+  shouldEndRoom(room: Room<TagPlayer>): boolean {
+    // End if no players left
+    return room.getRegistry().size === 0;
+  }
+}
+```
+
+### Step 2: Create the Server
+
+```typescript
+// server/index.ts
+import { Server } from 'socket.io';
+import { GameServer, Entity } from '@gamerstake/game-core';
+import { TagGameRules } from './TagGameRules.js';
+
+const io = new Server(3000, {
+  cors: { origin: '*' },
+});
+
+const gameServer = new GameServer();
+gameServer.setServer(io);
+
+const room = gameServer.createRoom('tag-game', new TagGameRules(), {
+  tickRate: 20,
+  cellSize: 256,
+});
+
+io.on('connection', (socket) => {
+  const playerId = socket.id;
+
+  // Create player
+  const player = new Entity(playerId, 0, 0) as any;
+  player.isIt = false;
+  room.addPlayer(player);
+
+  // Register socket
+  room.getNetwork().registerSocket(playerId, socket);
+
+  // Send initial state
+  socket.emit('S_INIT', {
+    playerId,
+    ...room.getSnapshot(),
+  });
+
+  // Handle inputs
+  socket.on('C_MOVE', (data) => {
+    room.queueInput(playerId, {
+      seq: data.seq,
+      type: 'move',
+      dir: data.dir,
+      timestamp: Date.now(),
+    });
+  });
+
+  socket.on('C_STOP', (data) => {
+    room.queueInput(playerId, {
+      seq: data.seq,
+      type: 'stop',
+      timestamp: Date.now(),
+    });
+  });
+
+  socket.on('disconnect', () => {
+    room.removePlayer(playerId);
+    room.getNetwork().unregisterSocket(playerId);
+  });
+});
+
+console.log(' Tag game server running on port 3000');
+```
+
+### Step 3: Create the Client
+
+```typescript
+// client/index.ts
+import { io } from 'socket.io-client';
+
+const socket = io('http://localhost:3000');
+let seq = 0;
+let playerId: string;
+let entities = new Map();
+
+// Receive initial state
+socket.on('S_INIT', (data) => {
+  playerId = data.playerId;
+  data.entities.forEach((e) => entities.set(e.id, e));
+  render();
+});
+
+// Receive updates
+socket.on('S_UPDATE', (data) => {
+  data.entities?.forEach((e) => entities.set(e.id, e));
+  data.deleted?.forEach((id) => entities.delete(id));
+  render();
+});
+
+// Game events
+socket.on('TAGGED', (data) => {
+  console.log(`Player ${data.tagged} was tagged by ${data.tagger}!`);
+});
+
+// Send movement input
+function move(dirX: number, dirY: number) {
+  socket.emit('C_MOVE', {
+    seq: ++seq,
+    dir: { x: dirX, y: dirY },
+  });
+}
+
+function stop() {
+  socket.emit('C_STOP', { seq: ++seq });
+}
+
+// Keyboard controls
+document.addEventListener('keydown', (e) => {
+  switch (e.key) {
+    case 'w':
+      move(0, -1);
+      break;
+    case 's':
+      move(0, 1);
+      break;
+    case 'a':
+      move(-1, 0);
+      break;
+    case 'd':
+      move(1, 0);
+      break;
+  }
+});
+
+document.addEventListener('keyup', () => stop());
+
+// Simple canvas rendering
+function render() {
+  const canvas = document.getElementById('game') as HTMLCanvasElement;
+  const ctx = canvas.getContext('2d')!;
+
+  ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+  entities.forEach((entity, id) => {
+    // Draw player
+    ctx.fillStyle = entity.isIt ? 'red' : 'blue';
+    ctx.beginPath();
+    ctx.arc(entity.x * 0.5, entity.y * 0.5, 10, 0, Math.PI * 2);
+    ctx.fill();
+
+    // Highlight your player
+    if (id === playerId) {
+      ctx.strokeStyle = 'yellow';
+      ctx.lineWidth = 3;
+      ctx.stroke();
+    }
+  });
+}
+```
+
+### Step 4: Run It!
+
+```bash
+# Terminal 1: Start server
+node server/index.js
+
+# Terminal 2: Start client dev server
+npm run dev
+
+# Open http://localhost:5173 in multiple browser tabs
+```
+
+**Congratulations! You've built your first multiplayer game!**
+
+---
+
+## Advanced Topics
+
+### Custom Entity Types
+
+Extend `Entity` to add game-specific properties:
+
+```typescript
+class Warrior extends Entity {
+  health = 100;
+  mana = 50;
+  inventory: Item[] = [];
+
+  takeDamage(amount: number) {
+    this.health -= amount;
+    this.markDirty(); // Important!
+  }
+
+  serialize() {
+    return {
+      ...super.serialize(),
+      health: this.health,
+      mana: this.mana,
+    };
+  }
+}
+```
+
+**Important:** Call `markDirty()` when you modify properties so they're broadcast!
+
+### Collision Detection
+
+Use the built-in AABB system:
+
+```typescript
+import { AABBCollision, AABB } from '@gamerstake/game-core';
+
+const collision = new AABBCollision();
+
+const a: AABB = { x: 10, y: 10, width: 50, height: 50 };
+const b: AABB = { x: 40, y: 40, width: 50, height: 50 };
+
+if (collision.check(a, b)) {
+  console.log('Collision detected!');
+}
+```
+
+### Spatial Queries
+
+Find entities near a point efficiently:
+
+```typescript
+onTick(room: Room, delta: number) {
+ const player = room.getRegistry().get('player-1');
+
+ // Find all entities within 200 units
+ const nearby = room.getGrid().getNearbyEntities(
+ player.x,
+ player.y,
+ 200
+ );
+
+ nearby.forEach(entity => {
+ // Check for interactions
+ });
+}
+```
+
+### Custom Commands
+
+Define your own command types:
+
+```typescript
+// shared/commands.ts
+interface AttackCommand extends Command {
+ type: 'attack';
+ targetId: string;
+}
+
+// server/GameRules.ts
+onCommand(room: Room, playerId: string, command: Command) {
+ if (command.type === 'attack') {
+ const cmd = command as AttackCommand;
+ const attacker = room.getRegistry().get(playerId);
+ const target = room.getRegistry().get(cmd.targetId);
+
+ if (attacker && target) {
+ // Process attack
+ target.health -= attacker.attackPower;
+ target.markDirty();
+ }
+ }
+}
+```
+
+### State Persistence
+
+Save and restore room state:
+
+```typescript
+// Save state
+const snapshot = room.getSnapshot();
+await db.saveGameState(roomId, snapshot);
+
+// Load state
+const savedState = await db.loadGameState(roomId);
+savedState.entities.forEach((data) => {
+  const entity = new Entity(data.id, data.x, data.y);
+  // Restore other properties
+  room.spawnEntity(entity);
+});
+```
+
+### Multiple Rooms
+
+Create different room types:
+
+```typescript
+// Lobby room (persistent)
+const lobby = gameServer.createRoom('lobby', new LobbyRules(), {
+  tickRate: 10, // Lower rate for lobby
+});
+
+// Match room (temporary)
+function createMatch(players: string[]) {
+  const matchId = `match-${Date.now()}`;
+  const match = gameServer.createRoom(matchId, new BattleRules(), {
+    tickRate: 20,
+  });
+
+  players.forEach((playerId) => {
+    // Transfer player from lobby to match
+  });
+
+  return match;
+}
+```
+
+### Visibility/Interest Management
+
+Only send updates about nearby entities:
+
+```typescript
+onTick(room: Room, delta: number) {
+ const snapshot = room.getSnapshot();
+
+ // Send custom snapshots per player
+ room.getRegistry().forEach((player) => {
+ const nearby = room.getGrid().getNearbyEntities(
+ player.x,
+ player.y,
+ 500 // Visibility range
+ );
+
+ const visibleEntities = snapshot.entities.filter(e =>
+ nearby.has(e.id) || e.id === player.id
+ );
+
+ room.sendTo(player.id, {
+ op: 'S_UPDATE',
+ entities: visibleEntities,
+ });
+ });
+}
+```
+
+---
+
+## Performance Optimization
+
+### 1. Avoid Allocations in Hot Paths
+
+**Bad:**
+
+```typescript
+onTick(room: Room, delta: number) {
+ const players = room.getRegistry().values(); // Allocates!
+ Array.from(players).forEach(...); // Allocates!
+}
+```
+
+**Good:**
+
+```typescript
+onTick(room: Room, delta: number) {
+ room.getRegistry().forEach((player) => {
+ // Direct iteration, no allocation
+ });
+}
+```
+
+### 2. Use Dirty Flags
+
+Only process/broadcast changed entities:
+
+```typescript
+onTick(room: Room, delta: number) {
+ room.getRegistry().forEach((entity) => {
+ if (entity.dirty) {
+ // This entity changed, process it
+ }
+ });
+}
+```
+
+### 3. Batch Operations
+
+Process similar entities together:
+
+```typescript
+// Good: Process all projectiles at once
+const projectiles = Array.from(room.getRegistry().values()).filter((e) => e.type === 'projectile');
+
+projectiles.forEach((p) => p.updatePosition(delta));
+```
+
+### 4. Use Grid for Collision Detection
+
+**Bad - O(n²):**
+
+```typescript
+const entities = Array.from(room.getRegistry().values());
+for (const a of entities) {
+ for (const b of entities) {
+ if (checkCollision(a, b)) { ... }
+ }
+}
+```
+
+**Good - O(n):**
+
+```typescript
+room.getRegistry().forEach((entity) => {
+ const nearby = room.getGrid().getNearbyEntities(
+ entity.x,
+ entity.y,
+ entity.collisionRadius * 2
+ );
+
+ nearby.forEach(other => {
+ if (checkCollision(entity, other)) { ... }
+ });
+});
+```
+
+### 5. Monitor Tick Performance
+
+```typescript
+const metrics = gameServer.getMetrics();
+metrics.rooms.forEach((room) => {
+  if (room.avgTickTime > 40) {
+    console.warn(`Room ${room.id} tick time too high: ${room.avgTickTime}ms`);
+  }
+});
+```
+
+**Target:** Keep average tick time below 40ms (80% of 50ms budget)
+
+---
+
+## Common Patterns
+
+### Pattern 1: Ability System
+
+```typescript
+interface Ability {
+  cooldown: number;
+  lastUsed: number;
+  execute(caster: Entity, target?: Entity): void;
+}
+
+class FireballAbility implements Ability {
+  cooldown = 5000; // 5 seconds
+  lastUsed = 0;
+
+  execute(caster: Entity, target?: Entity) {
+    const now = Date.now();
+    if (now - this.lastUsed < this.cooldown) {
+      return; // Still on cooldown
+    }
+
+    this.lastUsed = now;
+
+    // Create projectile
+    const projectile = new Entity(`fireball-${now}`, caster.x, caster.y);
+    // ... set velocity toward target
+  }
+}
+```
+
+### Pattern 2: State Machine
+
+```typescript
+enum GameState {
+  WAITING,
+  COUNTDOWN,
+  PLAYING,
+  ENDED,
+}
+
+class MatchRules implements GameRules {
+  private state = GameState.WAITING;
+  private countdown = 0;
+
+  onTick(room: Room, delta: number) {
+    switch (this.state) {
+      case GameState.WAITING:
+        if (room.getRegistry().size >= 2) {
+          this.state = GameState.COUNTDOWN;
+          this.countdown = 5000;
+        }
+        break;
+
+      case GameState.COUNTDOWN:
+        this.countdown -= delta;
+        if (this.countdown <= 0) {
+          this.state = GameState.PLAYING;
+          room.broadcast({ op: 'GAME_START' });
+        }
+        break;
+
+      case GameState.PLAYING:
+        // Game logic here
+        if (this.checkWinCondition(room)) {
+          this.state = GameState.ENDED;
+        }
+        break;
+
+      case GameState.ENDED:
+        // Cleanup
+        break;
+    }
+  }
+}
+```
+
+### Pattern 3: Event System
+
+```typescript
+type GameEvent = { type: 'player_died'; playerId: string } | { type: 'item_collected'; itemId: string; playerId: string } | { type: 'match_ended'; winner: string };
+
+class EventBus {
+  private listeners = new Map<string, ((event: GameEvent) => void)[]>();
+
+  on(type: string, handler: (event: GameEvent) => void) {
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, []);
+    }
+    this.listeners.get(type)!.push(handler);
+  }
+
+  emit(event: GameEvent) {
+    const handlers = this.listeners.get(event.type) || [];
+    handlers.forEach((h) => h(event));
+  }
+}
+
+// Usage in GameRules
+class MyRules implements GameRules {
+  private events = new EventBus();
+
+  constructor() {
+    this.events.on('player_died', (event) => {
+      // Award kill to attacker
+      // Respawn player
+    });
+  }
+}
+```
+
+### Pattern 4: Component System (ECS-lite)
+
+```typescript
+interface Component {
+  update?(delta: number): void;
+}
+
+class HealthComponent implements Component {
+  constructor(
+    public max: number,
+    public current: number,
+  ) {}
+
+  takeDamage(amount: number) {
+    this.current = Math.max(0, this.current - amount);
+  }
+}
+
+class GameObject extends Entity {
+  private components = new Map<string, Component>();
+
+  addComponent(name: string, component: Component) {
+    this.components.set(name, component);
+  }
+
+  getComponent<T>(name: string): T | undefined {
+    return this.components.get(name) as T;
+  }
+
+  update(delta: number) {
+    this.components.forEach((c) => c.update?.(delta));
+  }
+}
+```
+
+---
+
+## Troubleshooting
+
+### Problem: Tick time too high (>50ms)
+
+**Solutions:**
+
+- Profile with `console.time()` to find slow code
+- Use grid for spatial queries
+- Reduce entity count
+- Optimize collision detection
+- Use dirty flags
+
+### Problem: State desync between client/server
+
+**Solutions:**
+
+- Always trust the server
+- Implement client-side prediction
+- Send position corrections from server
+- Add sequence numbers to commands
+
+### Problem: Network lag
+
+**Solutions:**
+
+- Implement client-side prediction
+- Use delta compression
+- Reduce broadcast frequency for distant entities
+- Add interest management
+
+### Problem: Memory leaks
+
+**Solutions:**
+
+- Call `room.destroyEntity()` to remove entities
+- Unregister sockets on disconnect
+- Clear intervals/timeouts
+- Destroy rooms when empty
+
+---
+
+## Best Practices
+
+### DO
+
+- **Keep tick time under 40ms** (80% of 50ms budget)
+- **Use dirty flags** to minimize broadcasts
+- **Validate all client inputs** (never trust the client!)
+- **Use spatial grid** for collision/visibility queries
+- **Log metrics** for monitoring
+- **Implement reconnection logic** for clients
+- **Version your protocol** for updates
+- **Test with multiple clients** regularly
+
+### DON'T
+
+- **Don't allocate in hot paths** (onTick, etc.)
+- **Don't trust client positions** (validate server-side)
+- **Don't do O(n²) operations** every tick
+- **Don't forget to call markDirty()** on entity changes
+- **Don't broadcast to all players** if unnecessary
+- **Don't block the tick loop** (use async wisely)
+- **Don't forget error handling** (socket disconnects, etc.)
+
+---
+
+## Next Steps
+
+Now that you understand game-core, you can:
+
+1. **Build your game** - Start with the tag game example and expand
+2. **Add a client UI** - Use Phaser, Three.js, or canvas
+3. **Implement game mechanics** - Combat, inventory, progression
+4. **Add persistence** - Save game state to database
+5. **Deploy** - Docker, Kubernetes, cloud hosting
+6. **Monitor** - Add logging, metrics, alerting
+
+### Resources
+
+- **Examples:** `/examples/` directory
+- **Tests:** `/tests/` for usage patterns
+- **API Docs:** See README.md
+- **Architecture:** See RFC documents
+
+### Need Help?
+
+- Check the examples directory
+- Read the test files for usage patterns
+- Review the source code (it's well-documented!)
+- Contact the GamerStake engineering team
+
+---
+
+**Happy game building!**