Implement main game mechanic

server/handler/connection.js

@@ -1,23 +1,79 @@
-const {
-    connectUserToRoom, 
-    roomExists, 
-    disconnectUser, 
-    getUserRoom, 
-    getRoomUsers, 
-    isRoomOpen, 
-    startGame,
-    isUserHost
-} = require("../controller/room");
+const roomController = require("../controller/room");
+const gameController = require("../controller/game");
 
 module.exports = (io) => (socket) => {
     let currentRoomId = null;
     let currentUser = null;
 
+    let phaseTimers = {};
+
+    const clearRoomTimers = (roomId) => {
+        if (phaseTimers[roomId]) {
+            clearTimeout(phaseTimers[roomId]);
+            delete phaseTimers[roomId];
+        }
+    };
+
+    const startPhaseTimer = (roomId) => {
+        clearRoomTimers(roomId);
+        
+        const timeRemaining = gameController.getTimeRemaining(roomId) * 1000;
+
+        phaseTimers[roomId] = setTimeout(() => {
+            const advanced = gameController.advancePhase(roomId);
+            
+            if (advanced) {
+                const currentPhase = advanced.phase || 'results';
+
+                if (currentPhase === 'guessing') {
+                    const roles = gameController.getRoles(roomId);
+                    const songOptions = gameController.getSongOptions(roomId);
+                    const timeLeft = gameController.getTimeRemaining(roomId);
+                    
+                    Object.entries(roles).forEach(([userId, role]) => {
+                        if (role === 'guesser') {
+                            io.to(userId).emit('guessing-phase-started', {
+                                timeRemaining: timeLeft,
+                                songOptions
+                            });
+                        }
+                    });
+
+                    startPhaseTimer(roomId);
+                } 
+                else if (currentPhase === 'results') {
+                    const results = gameController.getRoundResults(roomId);
+                    io.to(roomId).emit('round-results', results);
+                }
+                else if (typeof advanced === 'boolean' && advanced) {
+                    const roles = gameController.getRoles(roomId);
+                    const selectedSong = gameController.getSelectedSong(roomId);
+                    const timeLeft = gameController.getTimeRemaining(roomId);
+
+                    io.to(roomId).emit('roles-assigned', roles);
+
+                    Object.entries(roles).forEach(([userId, role]) => {
+                        if (role === 'composer') {
+                            io.to(userId).emit('song-selected', selectedSong);
+                        }
+                    });
+
+                    io.to(roomId).emit('round-started', {
+                        round: gameController.getRoundResults(roomId).round,
+                        timeRemaining: timeLeft
+                    });
+
+                    startPhaseTimer(roomId);
+                }
+            }
+        }, timeRemaining);
+    };
+
     socket.on("disconnect", () => {
-        const roomId = getUserRoom(socket.id);
+        const roomId = roomController.getUserRoom(socket.id);
         if (roomId) socket.to(roomId).emit("user-disconnected", socket.id);
 
-        disconnectUser(socket.id);
+        roomController.disconnectUser(socket.id);
     });
 
     socket.on("join-room", ({roomId, name}) => {
@@ -25,16 +81,16 @@ module.exports = (io) => (socket) => {
         
         roomId = roomId.toString().toUpperCase();
 
-        if (roomExists(roomId)) {
-            if (!isRoomOpen(roomId)) {
+        if (roomController.roomExists(roomId)) {
+            if (!roomController.isRoomOpen(roomId)) {
                 return socket.emit("room-closed", roomId);
             }
             
             currentUser = {id: socket.id, name: name.toString()};
-            connectUserToRoom(roomId, currentUser);
+            roomController.connectUserToRoom(roomId, currentUser);
             socket.join(roomId);
 
-            const users = getRoomUsers(roomId);
+            const users = roomController.getRoomUsers(roomId);
             io.to(roomId).emit("room-users-update", users);
 
             socket.to(roomId).emit("user-connected", currentUser);
@@ -49,26 +105,51 @@ module.exports = (io) => (socket) => {
     socket.on("create-room", ({name}) => {
         if (!name) return socket.emit("room-name-required");
         const roomId = Math.random().toString(36).substring(7).toUpperCase();
-        currentUser = {id: socket.id, name: name?.toString()};
-        connectUserToRoom(roomId, currentUser);
+        currentUser = {id: socket.id, name: name?.toString(), creator: true};
+        roomController.connectUserToRoom(roomId, currentUser);
         socket.join(roomId);
         socket.emit("room-created", roomId);
         currentRoomId = roomId;
     });
 
     socket.on("start-game", () => {
-        const roomId = getUserRoom(socket.id);
-        if (roomId && isUserHost(socket.id)) {
-            if (startGame(roomId)) {
-                io.to(roomId).emit("game-started");
+        const roomId = roomController.getUserRoom(socket.id);
+        if (roomId && roomController.isUserHost(socket.id)) {
+            roomController.validateRoomMembers(io, roomId);
+            const roomUsers = roomController.getRoomUsers(roomId);
+            
+            if (roomController.startGame(roomId)) {
+                gameController.initializeGameState(roomId);
+
+                if (gameController.startNewRound(roomId)) {
+                    const roles = gameController.getRoles(roomId);
+                    const selectedSong = gameController.getSelectedSong(roomId);
+
+                    io.to(roomId).emit("game-started");
+
+                    io.to(roomId).emit("roles-assigned", roles);
+
+                    Object.entries(roles).forEach(([userId, role]) => {
+                        if (role === 'composer') {
+                            io.to(userId).emit("song-selected", selectedSong);
+                        }
+                    });
+
+                    io.to(roomId).emit("round-started", {
+                        round: 1,
+                        timeRemaining: gameController.getTimeRemaining(roomId)
+                    });
+
+                    startPhaseTimer(roomId);
+                }
+            } else {
+                socket.emit("not-authorized");
             }
-        } else {
-            socket.emit("not-authorized");
         }
     });
 
     socket.on("send-message", (messageData) => {
-        const roomId = getUserRoom(socket.id);
+        const roomId = roomController.getUserRoom(socket.id);
         if (roomId) {
             socket.to(roomId).emit("chat-message", messageData);
         }
@@ -81,15 +162,15 @@ module.exports = (io) => (socket) => {
     });
 
     socket.on("get-room-users", () => {
-        const roomId = getUserRoom(socket.id);
+        const roomId = roomController.getUserRoom(socket.id);
         if (roomId) {
-            const users = getRoomUsers(roomId);
+            const users = roomController.getRoomUsers(roomId);
             socket.emit("room-users", users);
         }
     });
 
     socket.on("check-host-status", () => {
-        const isHost = isUserHost(socket.id);
+        const isHost = roomController.isUserHost(socket.id);
         socket.emit("host-status", { isHost });
     });
 
@@ -98,4 +179,63 @@ module.exports = (io) => (socket) => {
             socket.emit("room-code", currentRoomId);
         }
     });
-}
+    
+    socket.on("submit-frequency", ({ frequency }) => {
+        const roomId = roomController.getUserRoom(socket.id);
+        if (!roomId) return;
+
+        const userRole = gameController.getUserRole(roomId, socket.id);
+        if (userRole === 'composer') {
+            if (gameController.updateFrequency(roomId, frequency)) {
+                socket.to(roomId).emit("frequency-update", { frequency });
+            }
+        }
+    });
+    
+    socket.on("submit-guess", ({ songId }) => {
+        const roomId = roomController.getUserRoom(socket.id);
+        if (!roomId) return;
+
+        const result = gameController.submitGuess(roomId, socket.id, songId);
+        if (result) {
+            socket.emit("guess-result", result);
+        }
+    });
+    
+    socket.on("next-round", () => {
+        const roomId = roomController.getUserRoom(socket.id);
+        if (!roomId || !roomController.isUserHost(socket.id)) return;
+
+        roomController.validateRoomMembers(io, roomId);
+        const roomUsers = roomController.getRoomUsers(roomId);
+
+        if (gameController.startNewRound(roomId)) {
+            const roles = gameController.getRoles(roomId);
+            const selectedSong = gameController.getSelectedSong(roomId);
+            const timeLeft = gameController.getTimeRemaining(roomId);
+
+            io.to(roomId).emit("roles-assigned", roles);
+
+            Object.entries(roles).forEach(([userId, role]) => {
+                if (role === 'composer') {
+                    io.to(userId).emit("song-selected", selectedSong);
+                }
+            });
+
+            io.to(roomId).emit("round-started", {
+                round: gameController.getRoundResults(roomId).round,
+                timeRemaining: timeLeft
+            });
+
+            startPhaseTimer(roomId);
+        }
+    });
+    
+    socket.on("get-current-frequency", () => {
+        const roomId = roomController.getUserRoom(socket.id);
+        if (!roomId) return;
+        
+        const frequency = gameController.getCurrentFrequency(roomId);
+        socket.emit("current-frequency", { frequency });
+    });
+};