Upload server.js

server.js

@@ -0,0 +1,771 @@
+const express = require('express');
+const http = require('http');
+const { Server } = require('socket.io');
+const path = require('path');
+const wordLists = require('./words');
+
+const app = express();
+const server = http.createServer(app);
+const io = new Server(server, { cors: { origin: '*' } });
+const PORT = process.env.PORT || 7860;
+
+app.use(express.static(path.join(__dirname, 'public')));
+// /game now served by index.html (single page app)
+app.get('*', (req, res) => res.sendFile(path.join(__dirname, 'public', 'index.html')));
+
+// ─── In-memory game state ───────────────────────────────────────────────────
+const rooms = {};
+
+function genCode() {
+  let code;
+  do { code = Math.random().toString(36).substring(2, 8).toUpperCase(); } while (rooms[code]);
+  return code;
+}
+
+function getWords(settings, count = 3) {
+  let pool = [];
+  if (settings.wordMode === 'custom' && settings.customWords.length >= count) {
+    pool = [...settings.customWords];
+  } else if (settings.wordMode === 'mixed') {
+    const cats = settings.categories || Object.keys(wordLists);
+    cats.forEach(c => { if (wordLists[c]) pool = pool.concat(wordLists[c]); });
+    pool = pool.concat(settings.customWords || []);
+  } else {
+    const cats = settings.categories || Object.keys(wordLists);
+    cats.forEach(c => { if (wordLists[c]) pool = pool.concat(wordLists[c]); });
+  }
+  pool = [...new Set(pool)];
+  const choices = [];
+  while (choices.length < count && pool.length > 0) {
+    const i = Math.floor(Math.random() * pool.length);
+    choices.push(pool.splice(i, 1)[0]);
+  }
+  return choices;
+}
+
+function hintMask(word, revealed) {
+  return word.split('').map((c, i) => c === ' ' ? ' ' : revealed.includes(i) ? c : '_').join('');
+}
+
+function levenshtein(a, b) {
+  const dp = Array.from({ length: a.length + 1 }, (_, i) =>
+    Array.from({ length: b.length + 1 }, (_, j) => i === 0 ? j : j === 0 ? i : 0));
+  for (let i = 1; i <= a.length; i++)
+    for (let j = 1; j <= b.length; j++)
+      dp[i][j] = a[i-1] === b[j-1] ? dp[i-1][j-1] : 1 + Math.min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]);
+  return dp[a.length][b.length];
+}
+
+function createRoom(settings = {}) {
+  const id = genCode();
+  rooms[id] = {
+    id,
+    host: null,
+    players: [],
+    spectators: [],
+    state: 'waiting',
+    settings: {
+      maxPlayers: 10,
+      rounds: 3,
+      drawTime: 80,
+      wordChoices: 3,
+      customWords: [],
+      wordMode: 'normal',
+      categories: Object.keys(wordLists),
+      teamMode: false,
+      suddenDeath: false,
+      quickDraw: false,
+      hintsEnabled: true,
+      ...settings
+    },
+    currentRound: 0,
+    drawerOrder: [],
+    currentDrawerIndex: 0,
+    currentWord: null,
+    wordChoices: [],
+    drawStrokes: [],
+    timer: null,
+    chooseTimer: null,
+    hintTimer1: null,
+    hintTimer2: null,
+    timeLeft: 0,
+    totalTime: 80,
+    hintsRevealed: [],
+    roundStartTime: null,
+    roundScores: [],
+    usedWords: [],
+    teams: { red: [], blue: [] },
+    scoreHistory: [], // [{round, scores:[{id,score}]}] for graph
+  };
+  return id;
+}
+
+function addPlayer(room, sid, name, avatar) {
+  const player = {
+    id: sid,
+    name: (name || 'Player').substring(0, 20),
+    score: 0,
+    avatar: avatar || { color: `hsl(${Math.floor(Math.random()*360)},70%,60%)`, icon: '😀' },
+    team: null,
+    streak: 0,
+    powerUps: { revealLetter: 1, timeWarp: 1, bomb: 1 },
+    achievements: [],
+    isDrawing: false,
+    hasGuessed: false,
+    guessTime: null,
+    isSpectator: false,
+    wordsDrawn: 0,
+  };
+  room.players.push(player);
+  return player;
+}
+
+function getPlayer(room, sid) {
+  return room.players.find(p => p.id === sid) || room.spectators.find(p => p.id === sid);
+}
+
+function clearAllTimers(room) {
+  if (room.timer) { clearInterval(room.timer); room.timer = null; }
+  if (room.chooseTimer) { clearTimeout(room.chooseTimer); room.chooseTimer = null; }
+  if (room.hintTimer1) { clearTimeout(room.hintTimer1); room.hintTimer1 = null; }
+  if (room.hintTimer2) { clearTimeout(room.hintTimer2); room.hintTimer2 = null; }
+}
+
+function shuffle(arr) {
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+  return arr;
+}
+
+function getRoomData(room) {
+  return {
+    id: room.id,
+    host: room.host,
+    state: room.state,
+    settings: room.settings,
+    players: room.players,
+    spectators: room.spectators,
+    currentRound: room.currentRound,
+    totalRounds: room.settings.rounds,
+    teams: room.teams,
+  };
+}
+
+function broadcastPlayers(room) {
+  io.to(room.id).emit('playerUpdate', { players: room.players });
+}
+
+// ─── Game Flow ───────────────────────────────────────────────────────────────
+function startGame(room) {
+  if (room.players.length === 0) return;
+  room.state = 'playing';
+  room.currentRound = 1;
+  room.scoreHistory = [];
+  room.usedWords = [];
+  room.players.forEach(p => {
+    p.score = 0; p.streak = 0; p.achievements = [];
+    p.powerUps = { revealLetter: 1, timeWarp: 1, bomb: 1 };
+  });
+
+  if (room.settings.teamMode) assignTeams(room);
+
+  room.drawerOrder = shuffle(room.players.map(p => p.id));
+  room.currentDrawerIndex = 0;
+  startRound(room);
+}
+
+function assignTeams(room) {
+  room.teams = { red: [], blue: [] };
+  room.players.forEach((p, i) => {
+    p.team = i % 2 === 0 ? 'red' : 'blue';
+    room.teams[p.team].push(p.id);
+  });
+}
+
+function startRound(room) {
+  clearAllTimers(room);
+  room.players.forEach(p => { p.hasGuessed = false; p.isDrawing = false; p.guessTime = null; });
+  room.drawStrokes = [];
+  room.hintsRevealed = [];
+  room.roundScores = [];
+  room.currentWord = null;
+
+  // Find drawer, skip if missing
+  let drawerFound = false;
+  while (!drawerFound && room.currentDrawerIndex < room.drawerOrder.length) {
+    const drawerId = room.drawerOrder[room.currentDrawerIndex];
+    const drawer = room.players.find(p => p.id === drawerId);
+    if (drawer) { drawer.isDrawing = true; drawerFound = true; }
+    else room.currentDrawerIndex++;
+  }
+
+  if (!drawerFound) { nextTurn(room); return; }
+
+  const drawer = room.players.find(p => p.isDrawing);
+  const choices = getWords(room.settings, room.settings.wordChoices);
+  room.wordChoices = choices;
+  room.state = 'choosing';
+
+  io.to(room.id).emit('roundStart', {
+    round: room.currentRound,
+    totalRounds: room.settings.rounds,
+    drawer: { id: drawer.id, name: drawer.name, avatar: drawer.avatar },
+    players: room.players,
+  });
+
+  io.to(drawer.id).emit('chooseWord', { choices });
+
+  room.chooseTimer = setTimeout(() => {
+    if (room.state === 'choosing') {
+      wordChosen(room, choices[Math.floor(Math.random() * choices.length)]);
+    }
+  }, 15000);
+}
+
+function wordChosen(room, word) {
+  clearAllTimers(room);
+  room.currentWord = word;
+  room.usedWords.push(word);
+  room.state = 'drawing';
+
+  const drawTime = room.settings.quickDraw ? 20 : room.settings.drawTime;
+  room.timeLeft = drawTime;
+  room.totalTime = drawTime;
+  room.roundStartTime = Date.now();
+
+  const drawer = room.players.find(p => p.isDrawing);
+  const mask = hintMask(word, []);
+  const lengths = word.split(' ').map(w => w.length);
+
+  io.to(drawer.id).emit('wordChosen', { word, hint: mask, lengths, isDrawer: true });
+  socket_to_room_except(room.id, drawer.id, 'wordChosen', { word: null, hint: mask, lengths, isDrawer: false });
+
+  // Auto hints
+  if (room.settings.hintsEnabled) {
+    room.hintTimer1 = setTimeout(() => { if (room.state === 'drawing') revealHint(room); }, drawTime * 500);
+    room.hintTimer2 = setTimeout(() => { if (room.state === 'drawing') revealHint(room); }, drawTime * 750);
+  }
+
+  // Countdown
+  room.timer = setInterval(() => {
+    room.timeLeft--;
+    io.to(room.id).emit('timerUpdate', { timeLeft: room.timeLeft, totalTime: room.totalTime });
+    if (room.timeLeft <= 0) endRound(room);
+  }, 1000);
+}
+
+function socket_to_room_except(roomId, exceptId, event, data) {
+  io.to(roomId).except(exceptId).emit(event, data);
+}
+
+function revealHint(room) {
+  const word = room.currentWord;
+  if (!word) return;
+  const unrevealed = [];
+  word.split('').forEach((c, i) => { if (c !== ' ' && !room.hintsRevealed.includes(i)) unrevealed.push(i); });
+  if (unrevealed.length === 0) return;
+  const n = Math.max(1, Math.floor(unrevealed.length * 0.3));
+  const picks = shuffle([...unrevealed]).slice(0, n);
+  room.hintsRevealed.push(...picks);
+  const drawer = room.players.find(p => p.isDrawing);
+  const hint = hintMask(word, room.hintsRevealed);
+  socket_to_room_except(room.id, drawer?.id || '', 'hintUpdate', { hint, revealed: room.hintsRevealed });
+}
+
+function checkGuess(room, sid, text) {
+  if (!room.currentWord || room.state !== 'drawing') return 'ignore';
+  const player = room.players.find(p => p.id === sid);
+  if (!player || player.hasGuessed || player.isDrawing) return 'ignore';
+
+  const guess = text.trim().toLowerCase();
+  const answer = room.currentWord.toLowerCase();
+
+  if (guess === answer) {
+    const elapsed = (Date.now() - room.roundStartTime) / 1000;
+    const timeRatio = Math.max(0, 1 - elapsed / room.totalTime);
+    const baseScore = 200;
+    const timeBonus = Math.round(timeRatio * 300);
+    const firstBonus = room.roundScores.length === 0 ? 50 : 0;
+    const streakBonus = player.streak * 25;
+    const total = baseScore + timeBonus + firstBonus + streakBonus;
+
+    player.hasGuessed = true;
+    player.guessTime = elapsed;
+    player.score += total;
+    player.streak++;
+    player.wordsDrawn;
+
+    const drawer = room.players.find(p => p.isDrawing);
+    if (drawer) {
+      const drawerGain = Math.round(50 + (room.roundScores.length === 0 ? 0 : 10));
+      drawer.score += drawerGain;
+    }
+
+    room.roundScores.push({ id: sid, score: total, time: elapsed });
+    checkAchievements(room, player);
+
+    const nonDrawers = room.players.filter(p => !p.isDrawing && !p.isSpectator);
+    if (nonDrawers.every(p => p.hasGuessed)) setTimeout(() => endRound(room), 1500);
+
+    return { correct: true, score: total, streak: player.streak, firstBonus };
+  }
+
+  const dist = levenshtein(guess, answer);
+  if (dist <= 2 && guess.length > 2) return 'close';
+
+  if (room.settings.suddenDeath) {
+    player.score = Math.max(0, player.score - 15);
+    broadcastPlayers(room);
+  }
+  return 'wrong';
+}
+
+function checkAchievements(room, player) {
+  const unlocked = [];
+  const add = (id, name, desc) => {
+    if (!player.achievements.includes(id)) {
+      player.achievements.push(id);
+      unlocked.push({ id, name, desc });
+    }
+  };
+  if (player.guessTime < 8) add('speed_demon', '⚡ Speed Demon', 'Guessed in under 8 seconds!');
+  if (player.streak >= 3) add('on_fire', '🔥 On Fire', '3 correct guesses in a row!');
+  if (player.streak >= 5) add('unstoppable', '💎 Unstoppable', '5 in a row!');
+  if (room.roundScores.length === 1) add('first_blood', '🩸 First Blood', 'First to guess the word!');
+  if (room.hintsRevealed.length === 0 && player.guessTime < room.totalTime * 0.5)
+    add('no_hints', '🕵️ Sherlock', 'Guessed with zero hints revealed!');
+  if (unlocked.length > 0) io.to(player.id).emit('achievementUnlocked', unlocked);
+}
+
+function endRound(room) {
+  clearAllTimers(room);
+  if (room.state === 'intermission' || room.state === 'ended') return;
+  room.state = 'intermission';
+
+  const drawer = room.players.find(p => p.isDrawing);
+
+  // Picasso achievement
+  const nonDrawers = room.players.filter(p => !p.isDrawing && !p.isSpectator);
+  if (drawer && nonDrawers.length > 0 && nonDrawers.every(p => p.hasGuessed)) {
+    if (!drawer.achievements.includes('picasso')) {
+      drawer.achievements.push('picasso');
+      io.to(drawer.id).emit('achievementUnlocked', [{ id: 'picasso', name: '🎨 Picasso', desc: 'Everyone guessed your drawing!' }]);
+    }
+    drawer.score += 100; // bonus
+  }
+
+  // Record score history
+  room.scoreHistory.push({
+    round: room.currentRound,
+    drawerTurn: room.currentDrawerIndex,
+    scores: room.players.map(p => ({ id: p.id, name: p.name, score: p.score }))
+  });
+
+  io.to(room.id).emit('roundEnd', {
+    word: room.currentWord,
+    scores: room.players.map(p => ({
+      id: p.id, name: p.name, score: p.score, avatar: p.avatar,
+      roundGain: room.roundScores.find(r => r.id === p.id)?.score || 0,
+      guessTime: p.guessTime,
+    })),
+    drawStrokes: room.drawStrokes,
+    drawer: drawer ? { id: drawer.id, name: drawer.name } : null,
+    scoreHistory: room.scoreHistory,
+  });
+
+  room.timer = setTimeout(() => {
+    if (!rooms[room.id]) return;
+    nextTurn(room);
+  }, 7000);
+}
+
+function nextTurn(room) {
+  clearAllTimers(room);
+  room.currentDrawerIndex++;
+
+  if (room.currentDrawerIndex >= room.drawerOrder.length) {
+    room.currentRound++;
+    if (room.currentRound > room.settings.rounds) { endGame(room); return; }
+    room.drawerOrder = shuffle(room.players.map(p => p.id));
+    room.currentDrawerIndex = 0;
+  }
+
+  if (room.players.length < 1) {
+    room.state = 'waiting';
+    io.to(room.id).emit('gameAborted', { reason: 'Not enough players' });
+    return;
+  }
+  startRound(room);
+}
+
+function endGame(room) {
+  clearAllTimers(room);
+  room.state = 'ended';
+
+  const sorted = [...room.players].sort((a, b) => b.score - a.score);
+
+  // Victory achievement
+  if (sorted[0]) {
+    const winner = sorted[0];
+    if (!winner.achievements.includes('champion')) {
+      winner.achievements.push('champion');
+      io.to(winner.id).emit('achievementUnlocked', [{ id: 'champion', name: '👑 Champion', desc: 'You won the game!' }]);
+    }
+  }
+
+  io.to(room.id).emit('gameEnd', {
+    players: sorted.map((p, i) => ({
+      id: p.id, name: p.name, score: p.score,
+      rank: i + 1, achievements: p.achievements, avatar: p.avatar, streak: p.streak
+    })),
+    scoreHistory: room.scoreHistory,
+  });
+
+  setTimeout(() => { if (rooms[room.id]) delete rooms[room.id]; }, 60000);
+}
+
+// ─── Socket.IO ───────────────────────────────────────────────────────────────
+io.on('connection', (socket) => {
+
+  socket.on('createRoom', ({ name, avatar, settings }) => {
+    const id = createRoom(settings || {});
+    const room = rooms[id];
+    room.host = socket.id;
+    const player = addPlayer(room, socket.id, name, avatar);
+    socket.join(id);
+    socket.roomId = id;
+    socket.emit('roomCreated', { roomId: id, player, room: getRoomData(room) });
+  });
+
+  socket.on('joinRoom', ({ roomId, name, avatar, asSpectator }) => {
+    const code = (roomId || '').toUpperCase().trim();
+    const room = rooms[code];
+    if (!room) { socket.emit('joinError', { message: 'Room not found. Check the code!' }); return; }
+    if (room.players.length >= room.settings.maxPlayers) {
+      socket.emit('joinError', { message: 'Room is full! (max ' + room.settings.maxPlayers + ')' }); return;
+    }
+
+    socket.join(code);
+    socket.roomId = code;
+
+    let player;
+    if (asSpectator) {
+      player = addPlayer(room, socket.id, name, avatar);
+      player.isSpectator = true;
+      room.players = room.players.filter(p => p.id !== socket.id);
+      room.spectators.push(player);
+    } else {
+      player = addPlayer(room, socket.id, name, avatar);
+      // If joining mid-game, mark as late joiner (they wait for next round to draw)
+      if (room.state !== 'waiting') {
+        player.lateJoin = true;
+      }
+    }
+
+    socket.emit('roomJoined', { player, room: getRoomData(room) });
+    socket.to(code).emit('playerJoined', { player, players: room.players, spectators: room.spectators });
+  });
+
+  socket.on('joinRandom', ({ name, avatar }) => {
+    // Find existing matchmaking room
+    let room = Object.values(rooms).find(r =>
+      r.state === 'waiting' &&
+      r.isMatchmaking === true &&
+      r.players.length < r.settings.maxPlayers
+    );
+
+    if (!room) {
+      // Create a new matchmaking room
+      const id = createRoom();
+      room = rooms[id];
+      room.isMatchmaking = true;
+      room.host = socket.id;
+    }
+
+    const player = addPlayer(room, socket.id, name, avatar);
+    socket.join(room.id);
+    socket.roomId = room.id;
+
+    // If first player, set as host
+    if (room.players.length === 1) room.host = socket.id;
+
+    socket.emit('roomJoined', { player, room: getRoomData(room) });
+    socket.to(room.id).emit('playerJoined', { player, players: room.players });
+
+    // Broadcast updated matchmaking count
+    io.to(room.id).emit('matchmakingUpdate', {
+      players: room.players.length,
+      needed: 2,
+      countdown: null
+    });
+
+    // Cancel any existing auto-start timer
+    if (room.matchmakingTimer) { clearTimeout(room.matchmakingTimer); room.matchmakingTimer = null; }
+    if (room.matchmakingCountdown) { clearInterval(room.matchmakingCountdown); room.matchmakingCountdown = null; }
+
+    if (room.players.length >= 2) {
+      // Start countdown (10s) to allow more players to join
+      let secs = 10;
+      io.to(room.id).emit('matchmakingUpdate', { players: room.players.length, needed: 2, countdown: secs });
+
+      room.matchmakingCountdown = setInterval(() => {
+        secs--;
+        io.to(room.id).emit('matchmakingUpdate', { players: room.players.length, needed: 2, countdown: secs });
+        if (secs <= 0) {
+          clearInterval(room.matchmakingCountdown);
+          room.matchmakingCountdown = null;
+        }
+      }, 1000);
+
+      room.matchmakingTimer = setTimeout(() => {
+        if (rooms[room.id] && room.state === 'waiting' && room.players.length >= 2) {
+          room.isMatchmaking = false;
+          startGame(room);
+        }
+      }, 10000);
+
+    } else {
+      // Only 1 player — wait up to 30s then start solo (practice) mode
+      io.to(room.id).emit('matchmakingUpdate', { players: 1, needed: 2, countdown: null, waiting: true });
+
+      room.matchmakingTimer = setTimeout(() => {
+        if (rooms[room.id] && room.state === 'waiting') {
+          if (room.players.length >= 2) {
+            room.isMatchmaking = false;
+            startGame(room);
+          } else {
+            // Solo mode - start with 1 player (they draw, no one guesses but they can practice)
+            room.isMatchmaking = false;
+            room.settings.rounds = 2;
+            startGame(room);
+          }
+        }
+      }, 8000);
+    }
+  });
+
+  // CRITICAL: When page reloads after game starts, new socket must rejoin room
+  socket.on('rejoinGame', ({ roomId, name, avatar }) => {
+    const code = (roomId || '').toUpperCase().trim();
+    const room = rooms[code];
+    if (!room) { socket.emit('rejoinError', { message: 'Room expired or not found' }); return; }
+
+    socket.join(code);
+    socket.roomId = code;
+
+    // Check if player with same name already exists (reconnect)
+    let player = room.players.find(p => p.name === name);
+    if (player) {
+      // Update their socket id to the new one
+      const oldId = player.id;
+      player.id = socket.id;
+      // Update host if needed
+      if (room.host === oldId) room.host = socket.id;
+      // Update drawerOrder
+      const di = room.drawerOrder.indexOf(oldId);
+      if (di !== -1) room.drawerOrder[di] = socket.id;
+    } else {
+      // New player joining mid-game
+      if (room.players.length >= room.settings.maxPlayers) {
+        socket.emit('rejoinError', { message: 'Room is full!' }); return;
+      }
+      player = addPlayer(room, socket.id, name, avatar);
+      player.lateJoin = true;
+    }
+
+    // Send current game state so they can sync up
+    const drawer = room.players.find(p => p.isDrawing);
+    socket.emit('gameRejoined', {
+      player,
+      room: getRoomData(room),
+      state: room.state,
+      round: room.currentRound,
+      totalRounds: room.settings.rounds,
+      drawer: drawer ? { id: drawer.id, name: drawer.name, avatar: drawer.avatar } : null,
+      players: room.players,
+      hint: room.currentWord ? hintMask(room.currentWord, room.hintsRevealed) : null,
+      timeLeft: room.timeLeft,
+      totalTime: room.totalTime,
+      drawStrokes: room.drawStrokes,
+      isDrawer: drawer?.id === socket.id,
+      word: drawer?.id === socket.id ? room.currentWord : null,
+    });
+
+    // Tell others this player is back
+    socket.to(code).emit('playerJoined', { player, players: room.players });
+  });
+
+  socket.on('startGame', () => {
+    const room = rooms[socket.roomId];
+    if (!room) return;
+    if (room.host !== socket.id) { socket.emit('gameError', { message: 'Only the host can start' }); return; }
+    if (room.players.length < 2) { socket.emit('gameError', { message: 'Need at least 2 players' }); return; }
+    startGame(room);
+  });
+
+  socket.on('chooseWord', ({ word }) => {
+    const room = rooms[socket.roomId];
+    if (!room || room.state !== 'choosing') return;
+    const player = room.players.find(p => p.id === socket.id);
+    if (!player?.isDrawing || !room.wordChoices.includes(word)) return;
+    wordChosen(room, word);
+  });
+
+  socket.on('draw', (data) => {
+    const room = rooms[socket.roomId];
+    if (!room || room.state !== 'drawing') return;
+    const player = room.players.find(p => p.id === socket.id);
+    if (!player?.isDrawing) return;
+    const stamped = { ...data, t: Date.now() - (room.roundStartTime || Date.now()) };
+    room.drawStrokes.push(stamped);
+    socket.to(socket.roomId).emit('draw', data);
+  });
+
+  socket.on('clearCanvas', () => {
+    const room = rooms[socket.roomId];
+    if (!room || room.state !== 'drawing') return;
+    const player = room.players.find(p => p.id === socket.id);
+    if (!player?.isDrawing) return;
+    room.drawStrokes = [{ type: 'clear', t: 0 }];
+    io.to(socket.roomId).emit('clearCanvas');
+  });
+
+  socket.on('guess', ({ text }) => {
+    const room = rooms[socket.roomId];
+    if (!room || !text) return;
+    const player = getPlayer(room, socket.id);
+    if (!player) return;
+
+    // Block drawer from revealing word in chat
+    if (player.isDrawing) {
+      socket.emit('chatMessage', { system: true, text: '🤫 You cannot chat while drawing!', type: 'warn' });
+      return;
+    }
+
+    const result = checkGuess(room, socket.id, text);
+
+    if (result === 'ignore') return;
+
+    if (result?.correct) {
+      socket.emit('correctGuess', { score: result.score, streak: result.streak, firstBonus: result.firstBonus });
+      io.to(socket.roomId).emit('chatMessage', {
+        system: true,
+        text: `🎉 ${player.name} guessed it! (+${result.score}pts${result.streak > 1 ? ` 🔥x${result.streak}` : ''})`,
+        type: 'correct'
+      });
+      broadcastPlayers(room);
+    } else if (result === 'close') {
+      socket.emit('chatMessage', { system: true, text: `🌡️ So close! Keep trying...`, type: 'close' });
+      io.to(socket.roomId).emit('chatMessage', { sender: player.name, text: '...', playerId: socket.id, type: 'guess' });
+    } else {
+      io.to(socket.roomId).emit('chatMessage', { sender: player.name, text, playerId: socket.id, type: 'guess' });
+    }
+  });
+
+  socket.on('chatMessage', ({ text }) => {
+    const room = rooms[socket.roomId];
+    if (!room || !text) return;
+    const player = getPlayer(room, socket.id);
+    if (!player) return;
+    // Only allow chat in non-drawing state or for spectators
+    if (room.state === 'drawing' && !player.isSpectator) {
+      // This goes through guess flow - ignore raw chat
+      return;
+    }
+    io.to(socket.roomId).emit('chatMessage', { sender: player.name, text: text.substring(0, 120), playerId: socket.id, type: 'chat' });
+  });
+
+  socket.on('usePowerUp', ({ type }) => {
+    const room = rooms[socket.roomId];
+    if (!room || room.state !== 'drawing') return;
+    const player = room.players.find(p => p.id === socket.id);
+    if (!player || player.isDrawing || !player.powerUps[type] || player.powerUps[type] <= 0) return;
+
+    player.powerUps[type]--;
+
+    if (type === 'revealLetter') {
+      revealHint(room);
+      io.to(socket.roomId).emit('chatMessage', { system: true, text: `🔍 ${player.name} revealed a letter!`, type: 'powerup' });
+    } else if (type === 'timeWarp') {
+      room.timeLeft = Math.min(room.timeLeft + 15, room.totalTime);
+      io.to(socket.roomId).emit('timerUpdate', { timeLeft: room.timeLeft, totalTime: room.totalTime });
+      io.to(socket.roomId).emit('chatMessage', { system: true, text: `⏰ ${player.name} warped time! +15s`, type: 'powerup' });
+    } else if (type === 'bomb') {
+      room.drawStrokes = [{ type: 'clear', t: Date.now() - room.roundStartTime }];
+      io.to(socket.roomId).emit('clearCanvas');
+      io.to(socket.roomId).emit('chatMessage', { system: true, text: `💣 ${player.name} dropped a BOMB! Canvas cleared!`, type: 'powerup' });
+    }
+
+    socket.emit('powerUpUsed', { type, remaining: player.powerUps });
+  });
+
+  socket.on('reaction', ({ emoji }) => {
+    const room = rooms[socket.roomId];
+    if (!room) return;
+    const player = getPlayer(room, socket.id);
+    io.to(socket.roomId).emit('reaction', { emoji, name: player?.name || 'Someone' });
+  });
+
+  socket.on('updateSettings', (settings) => {
+    const room = rooms[socket.roomId];
+    if (!room || room.host !== socket.id || room.state !== 'waiting') return;
+    Object.assign(room.settings, settings);
+    io.to(socket.roomId).emit('settingsUpdated', room.settings);
+  });
+
+  socket.on('kickPlayer', ({ playerId }) => {
+    const room = rooms[socket.roomId];
+    if (!room || room.host !== socket.id) return;
+    const target = io.sockets.sockets.get(playerId);
+    if (target) {
+      target.emit('kicked', { reason: 'You were kicked by the host' });
+      target.leave(socket.roomId);
+    }
+    room.players = room.players.filter(p => p.id !== playerId);
+    io.to(socket.roomId).emit('playerLeft', { playerId, players: room.players });
+  });
+
+  socket.on('requestReplay', () => {
+    // Allow replay of last round strokes - sent on roundEnd already
+  });
+
+  socket.on('disconnect', () => {
+    const room = rooms[socket.roomId];
+    if (!room) return;
+
+    const wasDrawing = room.players.find(p => p.id === socket.id)?.isDrawing;
+    room.players = room.players.filter(p => p.id !== socket.id);
+    room.spectators = room.spectators.filter(p => p.id !== socket.id);
+
+    if (room.players.length === 0 && room.spectators.length === 0) {
+      clearAllTimers(room);
+      delete rooms[socket.roomId];
+      if (room.matchmakingTimer) clearTimeout(room.matchmakingTimer);
+      if (room.matchmakingCountdown) clearInterval(room.matchmakingCountdown);
+      return;
+    }
+
+    if (room.host === socket.id && room.players.length > 0) {
+      room.host = room.players[0].id;
+      io.to(room.host).emit('youAreHost');
+    }
+
+    io.to(socket.roomId).emit('playerLeft', { playerId: socket.id, players: room.players });
+
+    if (wasDrawing && (room.state === 'drawing' || room.state === 'choosing')) {
+      endRound(room);
+    }
+
+    if (room.players.length < 1 && room.state !== 'waiting' && room.state !== 'ended') {
+      clearAllTimers(room);
+      room.state = 'waiting';
+      io.to(socket.roomId).emit('gameAborted', { reason: 'Not enough players to continue' });
+    }
+  });
+});
+
+server.listen(PORT, '0.0.0.0', () => {
+  console.log(`🎨 Drawable running at http://localhost:${PORT}`);
+});