added handling for end of game

backend/handlers/gameHandler.js

@@ -1,5 +1,5 @@
 const { getRoom, updateRoom } = require('../services/roomService');
-const { sendToPlayersRolledNumber } = require('../socket/emits');
+const { sendToPlayersRolledNumber, sendWinner } = require('../socket/emits');
 const { rollDice, isMoveValid } = require('./handlersFunctions');
 
 module.exports = socket => {
@@ -7,12 +7,18 @@ module.exports = socket => {
 
     const handleMovePawn = async pawnId => {
         const room = await getRoom(req.session.roomId);
+        if (room.winner) return;
         const pawn = room.getPawn(pawnId);
         if (isMoveValid(req.session, pawn, room)) {
             const newPositionOfMovedPawn = pawn.getPositionAfterMove(room.rolledNumber);
             room.changePositionOfPawn(pawn, newPositionOfMovedPawn);
             room.beatPawns(newPositionOfMovedPawn, req.session.color);
             room.changeMovingPlayer();
+            const winner = room.getWinner();
+            if (winner) {
+                room.endGame(winner);
+                sendWinner(room._id.toString(), winner);
+            }
             await updateRoom(room);
         }
     };

backend/handlers/handlersFunctions.js

@@ -1,4 +1,4 @@
-const { sendToPlayersRolledNumber } = require('../socket/emits');
+const { sendToPlayersRolledNumber, sendWinner } = require('../socket/emits');
 
 const rollDice = () => {
     const rolledNumber = Math.ceil(Math.random() * 6);
@@ -8,6 +8,7 @@ const rollDice = () => {
 const makeRandomMove = async roomId => {
     const { updateRoom, getRoom } = require('../services/roomService');
     const room = await getRoom(roomId);
+    if (room.winner) return;
     if (room.rolledNumber === null) {
         room.rolledNumber = rollDice();
         sendToPlayersRolledNumber(room._id.toString(), room.rolledNumber);
@@ -19,6 +20,11 @@ const makeRandomMove = async roomId => {
         room.movePawn(randomPawn);
     }
     room.changeMovingPlayer();
+    const winner = room.getWinner();
+    if (winner) {
+        room.endGame(winner);
+        sendWinner(room._id.toString(), winner);
+    }
     await updateRoom(room);
 };
 

backend/handlers/playerHandler.js

@@ -12,6 +12,14 @@ module.exports = socket => {
         addPlayerToExistingRoom(room, data);
     };
 
+    const handleExit = async () => {
+        req.session.reload(err => {
+            if (err) return socket.disconnect();
+            req.session.destroy();
+            socket.emit('redirect');
+        });
+    };
+
     const handleReady = async () => {
         const room = await getRoom(req.session.roomId);
         room.getPlayer(req.session.playerId).changeReadyStatus();
@@ -45,4 +53,5 @@ module.exports = socket => {
 
     socket.on('player:login', handleLogin);
     socket.on('player:ready', handleReady);
+    socket.on('player:exit', handleExit);
 };

backend/handlers/roomHandler.js

@@ -1,5 +1,5 @@
 const { getRooms, getRoom, updateRoom, createNewRoom } = require('../services/roomService');
-const { sendToOnePlayerRooms, sendToOnePlayerData } = require('../socket/emits');
+const { sendToOnePlayerRooms, sendToOnePlayerData, sendWinner } = require('../socket/emits');
 
 module.exports = socket => {
     const req = socket.request;
@@ -13,6 +13,7 @@ module.exports = socket => {
             await updateRoom(room);
         }
         sendToOnePlayerData(socket.id, room);
+        if (room.winner) sendWinner(socket.id, room.winner);
     };
 
     const handleGetAllRooms = async () => {

backend/models/room.js

@@ -15,6 +15,7 @@ const RoomSchema = new mongoose.Schema({
     timeoutID: Number,
     rolledNumber: Number,
     players: [PlayerSchema],
+    winner: { type: String, default: null },
     pawns: {
         type: [PawnSchema],
         default: () => {
@@ -45,6 +46,7 @@ RoomSchema.methods.beatPawns = function (position, attackingPawnColor) {
 };
 
 RoomSchema.methods.changeMovingPlayer = function () {
+    if (this.winner) return;
     const playerIndex = this.players.findIndex(player => player.nowMoving === true);
     this.players[playerIndex].nowMoving = false;
     if (playerIndex + 1 === this.players.length) {
@@ -87,6 +89,31 @@ RoomSchema.methods.startGame = function () {
     this.timeoutID = setTimeout(makeRandomMove, 15000, this._id.toString());
 };
 
+RoomSchema.methods.endGame = function (winner) {
+    this.timeoutID = null;
+    this.rolledNumber = null;
+    this.nextMoveTime = null;
+    this.players.map(player => (player.nowMoving = false));
+    this.winner = winner;
+    this.save();
+};
+
+RoomSchema.methods.getWinner = function () {
+    if (this.pawns.filter(pawn => pawn.color === 'red' && pawn.position === 73).length === 4) {
+        return 'red';
+    }
+    if (this.pawns.filter(pawn => pawn.color === 'blue' && pawn.position === 79).length === 4) {
+        return 'blue';
+    }
+    if (this.pawns.filter(pawn => pawn.color === 'green' && pawn.position === 85).length === 4) {
+        return 'green';
+    }
+    if (this.pawns.filter(pawn => pawn.color === 'yellow' && pawn.position === 91).length === 4) {
+        return 'yellow';
+    }
+    return null;
+};
+
 RoomSchema.methods.isFull = function () {
     if (this.players.length === 4) {
         this.full = true;

backend/socket/emits.js

@@ -16,4 +16,14 @@ const sendToOnePlayerRooms = (id, rooms) => {
     socketManager.getIO().to(id).emit('room:rooms', JSON.stringify(rooms));
 };
 
-module.exports = { sendToPlayersData, sendToPlayersRolledNumber, sendToOnePlayerData, sendToOnePlayerRooms };
+const sendWinner = (id, winner) => {
+    socketManager.getIO().to(id).emit('game:winner', winner);
+};
+
+module.exports = {
+    sendToPlayersData,
+    sendToPlayersRolledNumber,
+    sendToOnePlayerData,
+    sendToOnePlayerRooms,
+    sendWinner,
+};