MassKribbl

1// Real-time drawing synchronization
2const handleDrawingEvent = (drawData: DrawingData) => {
3  // Optimize stroke data for transmission
4  const compressedStroke = {
5    x: Math.round(drawData.x),
6    y: Math.round(drawData.y),
7    tool: drawData.tool,
8    size: drawData.size,
9    color: drawData.color,
10    timestamp: Date.now()
11  };
12  
13  // Batch strokes for performance
14  strokeBuffer.push(compressedStroke);
15  
16  // Send batched strokes every 16ms (60fps)
17  if (strokeBuffer.length >= BATCH_SIZE || Date.now() - lastSend > 16) {
18    socket.emit('drawing', {
19      roomId,
20      strokes: strokeBuffer,
21      playerId: currentPlayer.id
22    });
23    strokeBuffer = [];
24    lastSend = Date.now();
25  }
26};

1// Game state management system
2class GameStateManager {
3  private gameStates = new Map<string, GameState>();
4  
5  updateGameState(roomId: string, action: GameAction) {
6    const game = this.gameStates.get(roomId);
7    if (!game) return;
8    
9    switch (action.type) {
10      case 'PLAYER_GUESS':
11        if (this.validateGuess(action.guess, game.currentWord)) {
12          game.scores[action.playerId] += this.calculateScore(action.timestamp);
13          this.broadcastCorrectGuess(roomId, action.playerId);
14        }
15        break;
16        
17      case 'TURN_END':
18        game.currentRound++;
19        game.currentPlayer = this.getNextPlayer(game);
20        this.startNewTurn(roomId);
21        break;
22        
23      case 'GAME_END':
24        this.calculateFinalScores(game);
25        this.broadcastGameResults(roomId);
26        break;
27    }
28    
29    this.saveGameState(roomId, game);
30  }
31}

1// Matchmaking and room management
2class MatchmakingService {
3  private waitingPlayers: Player[] = [];
4  private activeRooms = new Map<string, GameRoom>();
5  
6  async findMatch(player: Player): Promise<string> {
7    // Add to waiting queue
8    this.waitingPlayers.push(player);
9    
10    // Try to form a game when we have enough players
11    if (this.waitingPlayers.length >= MIN_PLAYERS) {
12      const selectedPlayers = this.selectBalancedPlayers();
13      const roomId = this.createRoom(selectedPlayers);
14      
15      // Remove selected players from queue
16      selectedPlayers.forEach(p => {
17        const index = this.waitingPlayers.indexOf(p);
18        this.waitingPlayers.splice(index, 1);
19      });
20      
21      this.startGame(roomId);
22      return roomId;
23    }
24    
25    return null; // Continue waiting
26  }
27  
28  private selectBalancedPlayers(): Player[] {
29    // Smart player selection based on skill level and connection quality
30    return this.waitingPlayers
31      .sort((a, b) => Math.abs(a.skillLevel - b.skillLevel))
32      .slice(0, OPTIMAL_PLAYERS);
33  }
34}