refactored backend

backend/handlers/gameHandler.js

@@ -1,88 +1,34 @@
-const Room = require('../schemas/room');
+const { getRoom, updateRoom } = require('../controllers/roomController');
+const { sendToPlayersRolledNumber } = require('../socket/emits');
 const { getPawnPositionAfterMove } = require('../utils/functions');
+const { rollDice, isMoveValid } = require('./handlersFunctions');
 
-module.exports = (io, socket) => {
+module.exports = socket => {
     const req = socket.request;
 
     const handleMovePawn = async pawnId => {
-        const room = await getRoom();
+        const room = await getRoom(req.session.roomId);
         const pawn = room.getPawn(pawnId);
-        if (isMoveValid(pawn, room)) {
+        if (isMoveValid(req.session, pawn, room)) {
             const newPositionOfMovedPawn = getPawnPositionAfterMove(room.rolledNumber, pawn);
             room.changePositionOfPawn(pawn, newPositionOfMovedPawn);
             room.beatPawns(newPositionOfMovedPawn, req.session.color);
-            handleChangeOfPlayer(room);
+            room.changeMovingPlayer();
+            await updateRoom(room);
         }
     };
 
     const handleRollDice = async () => {
         const rolledNumber = rollDice();
-        const room = await updateRoom({ rolledNumber: rolledNumber });
-        if (!canPlayerMove(room, rolledNumber)) {
-            handleChangeOfPlayer(room);
+        sendToPlayersRolledNumber(req.session.roomId, rolledNumber);
+        const room = await updateRoom({ _id: req.session.roomId, rolledNumber: rolledNumber });
+        const player = room.getPlayer(req.session.playerId);
+        if (!player.canMove(room, rolledNumber)) {
+            room.changeMovingPlayer();
+            await updateRoom(room);
         }
     };
 
-    const rollDice = () => {
-        const rolledNumber = Math.ceil(Math.random() * 6);
-        sendToPlayersRolledNumber(rolledNumber);
-        return rolledNumber;
-    };
-
-    const canPlayerMove = (room, rolledNumber) => {
-        const playerPawns = room.getPlayerPawns(req.session.color);
-        for (const pawn of playerPawns) {
-            if (pawn.canMove(rolledNumber)) return true;
-        }
-        return false;
-    };
-
-    const isMoveValid = (pawn, room) => {
-        if (req.session.color !== pawn.color) {
-            return false;
-        }
-        if (req.session.playerId !== room.getCurrentlyMovingPlayer()._id.toString()) {
-            return false;
-        }
-        return true;
-    };
-
-    const handleChangeOfPlayer = async room => {
-        room.changeMovingPlayer();
-        room.timeoutID = setTimeout(makeRandomMove, 15000, room);
-        await updateRoom(room);
-    };
-
-    const makeRandomMove = async room => {
-        if (room.rolledNumber === null) room.rolledNumber = rollDice();
-        const pawnsThatCanMove = room.getPawnsThatCanMove()
-        if (pawnsThatCanMove.length > 0) {
-            const randomPawn = pawnsThatCanMove[Math.floor(Math.random() * pawnsThatCanMove.length)];
-            room.movePawn(randomPawn);
-        }
-        await handleChangeOfPlayer(room);
-    };
-
-    Room.watch().on('change', async () => {
-        sendToPlayersData(await getRoom());
-    });
-
-    const getRoom = async () => {
-        return await Room.findOne({ _id: req.session.roomId }).exec();
-    };
-
-    const updateRoom = async room => {
-        return await Room.findOneAndUpdate({ _id: req.session.roomId }, room).exec();
-    };
-
-    const sendToPlayersRolledNumber = rolledNumber => {
-        io.to(req.session.roomId).emit('game:roll', rolledNumber);
-    };
-
-    const sendToPlayersData = room => {
-        io.to(req.session.roomId).emit('room:data', JSON.stringify(room));
-    };
-
     socket.on('game:roll', handleRollDice);
     socket.on('game:move', handleMovePawn);
 };

backend/handlers/handlersFunctions.js

@@ -0,0 +1,35 @@
+const { sendToPlayersRolledNumber } = require('../socket/emits');
+
+const rollDice = () => {
+    const rolledNumber = Math.ceil(Math.random() * 6);
+    return rolledNumber;
+};
+
+const makeRandomMove = async roomId => {
+    const { updateRoom, getRoom } = require('../controllers/roomController');
+    const room = await getRoom(roomId);
+    if (room.rolledNumber === null) {
+        room.rolledNumber = rollDice();
+        sendToPlayersRolledNumber(room._id.toString(), room.rolledNumber);
+    }
+
+    const pawnsThatCanMove = room.getPawnsThatCanMove();
+    if (pawnsThatCanMove.length > 0) {
+        const randomPawn = pawnsThatCanMove[Math.floor(Math.random() * pawnsThatCanMove.length)];
+        room.movePawn(randomPawn);
+    }
+    room.changeMovingPlayer();
+    await updateRoom(room);
+};
+
+const isMoveValid = (session, pawn, room) => {
+    if (session.color !== pawn.color) {
+        return false;
+    }
+    if (session.playerId !== room.getCurrentlyMovingPlayer()._id.toString()) {
+        return false;
+    }
+    return true;
+};
+
+module.exports = { rollDice, makeRandomMove, isMoveValid };

backend/handlers/playerHandler.js

@@ -1,32 +1,31 @@
-const RoomModel = require('../schemas/room');
+const { getRoom, updateRoom, getJoinableRoom, createNewRoom, findPlayer } = require('../controllers/roomController');
 const { colors } = require('../utils/constants');
 
-module.exports = (io, socket) => {
+module.exports = socket => {
     const req = socket.request;
 
     const handleLogin = async data => {
-        const room = await RoomModel.findOne({ full: false, started: false });
+        if (await findPlayer(req.sessionID)) return;
+        const room = await getJoinableRoom();
         if (room) {
             addPlayerToExistingRoom(room, data);
         } else {
-            createNewRoom(data);
+            addNewRoom(data);
         }
     };
 
     const handleReady = async () => {
-        const { roomId, playerId } = req.session;
-        const room = await RoomModel.findOne({ _id: roomId });
-        room.getPlayer(playerId).changeReadyStatus();
+        const room = await getRoom(req.session.roomId);
+        room.getPlayer(req.session.playerId).changeReadyStatus();
         if (room.canStartGame()) {
             room.startGame();
         }
-        await RoomModel.findOneAndUpdate({ _id: roomId }, room);
-        io.to(roomId).emit('room:data', JSON.stringify(room));
+        await updateRoom(room);
     };
 
-    const createNewRoom = async data => {
-        const room = new RoomModel();
-        room.addPlayer(data.name);
+    const addNewRoom = async data => {
+        const room = createNewRoom();
+        room.addPlayer(data.name, req.sessionID);
         await room.save();
         reloadSession(room);
     };
@@ -36,7 +35,7 @@ module.exports = (io, socket) => {
         if (room.isFull()) {
             room.startGame();
         }
-        await RoomModel.findOneAndUpdate({ _id: room._id }, room);
+        await updateRoom(room);
         reloadSession(room);
     };
 

backend/handlers/roomHandler.js

@@ -1,39 +1,37 @@
-const RoomModel = require('../schemas/room');
+const { getRooms, getRoom, updateRoom } = require('../controllers/roomController');
+const { sendToOnePlayerRooms, sendToOnePlayerData, sendToPlayersData } = require('../socket/emits');
 
-module.exports = (io, socket) => {
+module.exports = socket => {
     const req = socket.request;
 
     const getData = async () => {
-        let room = await RoomModel.findOne({ _id: req.session.roomId });
+        const room = await getRoom(req.session.roomId);
         // Handle the situation when the server crashes and any player reconnects after the time has expired
         // Typically, the responsibility for changing players is managed by gameHandler.js.
         if (room.nextMoveTime <= Date.now()) {
             room.changeMovingPlayer();
-            await RoomModel.findOneAndUpdate({ _id: req.session.roomId }, room);
-            io.to(req.session.roomId).emit('room:data', JSON.stringify(room));
-        } else {
-            io.to(socket.id).emit('room:data', JSON.stringify(room));
+            await updateRoom(room);
         }
+        sendToOnePlayerData(socket.id, room);
     };
 
-    const getRooms = async () => {
-        let rooms = await RoomModel.find({});
+    const getAllRooms = async () => {
+        let rooms = await getRooms();
         const response = [];
         rooms.forEach(room => {
             if (!room.isStarted && !room.isFull()) {
                 response.push({
                     _id: room._id,
+                    private: room.private,
                     name: room.name,
                     players: room.players,
                     isStarted: room.isStarted,
                 });
             }
         });
-        io.to(socket.id).emit('room:rooms', JSON.stringify(response));
+        sendToOnePlayerRooms(socket.id, response);
     };
 
-    
-
     socket.on('room:data', getData);
-    socket.on('room:rooms', getRooms);
+    socket.on('room:rooms', getAllRooms);
 };