Add class Player and Game (#25)

* Add class Player, Game and their tests

* Add class Player, Game and their tests

* Replace variables with `Game` class methods and properties

* Update `addPlayer`, `removePlayer` to fix the issue with #currentTurnPlayer; Move `gameMode` and `lineLengthLimit` to public

* Fix when there's only one player or the current player is leaving the game, a turn change should be triggered; Replace some test methods with jest built-in matchers

* Fix bugs of `index.ts` introduced by the last breaking changes; Rewrite tests of `Game` class for more coverage and resilience; Reorganise files

* Remove `Game` interface

* Remove jest coverage requirements

* Update and simplify game tests

---------

Co-authored-by: LivingLimes <[email protected]>

Author: realtomkwok

backend/jest.config.ts

@@ -14,15 +14,6 @@ const config: Config = {
   coveragePathIgnorePatterns: ['/node_modules/'],
   coverageProvider: 'v8',
   coverageReporters: ['json', 'text', 'lcov', 'clover', 'text-summary'],
-  // Jest will fail if there is less than 80% branch, line, and function coverage, or if there are more than 10 uncovered statements:
-  coverageThreshold: {
-    global: {
-      branches: 80,
-      functions: 80,
-      lines: 80,
-      statements: -10,
-    },
-  },
 
   // Test Environment
   testEnvironment: 'jest-environment-node',

backend/src/__test__/drawing.test.ts

@@ -1,4 +1,4 @@
-import Drawing from '../drawing'
+import Drawing from '../models/drawing'
 
 const canvasHeight = 300
 const canvasWidth = 300

backend/src/__test__/game.test.ts

@@ -0,0 +1,161 @@
+import Game from '../models/game'
+import Player from '../models/player'
+import Drawing from '../models/drawing'
+import GameMode from '../game-mode'
+
+describe('Game', () => {
+  const DRAWING_BUFFER_SIZE = 300 * 300 * 4
+  const firstPlayerId = 'first player'
+  const secondPlayerId = 'second player'
+
+  describe('Initialise a game', () => {
+    it('should initialise an empty drawing', () => {
+      const game = new Game()
+
+      expect(game.drawing).toEqual(Drawing.createEmpty())
+    })
+
+    it('should initialise an empty array of players', () => {
+      const game = new Game()
+      expect(game.players).toHaveLength(0)
+    })
+
+    it('should initialise no current turn player', () => {
+      const game = new Game()
+      expect(game.currentPlayer).toBeNull()
+    })
+
+    it('should initialise an undefined game mode', () => {
+      const game = new Game()
+      expect(game.gameMode).toBeUndefined()
+    })
+
+    it('should initialise the default line limit', () => {
+      const game = new Game()
+      expect(game.lineLengthLimit).toEqual(150)
+    })
+  })
+
+  describe('adding a new player', () => {
+    it('should add player to player list', () => {
+      const game = new Game()
+
+      game.addPlayer(firstPlayerId)
+      expect(game.players.some((player) => player.id === firstPlayerId)).toBe(
+        true,
+      )
+    })
+
+    it('should set the new player as current turn player when there is only player', () => {
+      const game = new Game()
+      game.addPlayer(firstPlayerId)
+
+      expect(game.currentPlayer?.id).toEqual(firstPlayerId)
+    })
+
+    it('should not trigger a turn change when there is already one player in the game', () => {
+      const game = new Game()
+      game.addPlayer(firstPlayerId)
+      game.addPlayer(secondPlayerId)
+
+      expect(game.currentPlayer?.id).not.toEqual(secondPlayerId)
+    })
+  })
+
+  describe('reset game', () => {
+    it('should reset the drawing', () => {
+      const game = new Game()
+      const emptyDrawing = Drawing.createEmpty()
+      const newDrawing = Drawing.createFrom(Buffer.alloc(DRAWING_BUFFER_SIZE, 1))
+      game.updateDrawing(newDrawing)
+      
+      game.resetGame()
+
+      expect(game.drawing).toEqual(emptyDrawing)
+    })
+
+    it('should reset the game mode', () => {
+      const game = new Game()
+      game.gameMode = GameMode.LineLengthLimit
+
+      game.resetGame()
+
+      expect(game.gameMode).toEqual(null)
+    })
+  })
+
+  describe('remove a given player', () => {
+    it('should be able to remove when the given player exists', () => {
+      const game = new Game()
+      game.addPlayer(firstPlayerId)
+
+      game.removePlayer(firstPlayerId)
+      expect(game.players).not.toContain(new Player(firstPlayerId))
+    })
+
+    it('should throw error when removing a non-existent player', () => {
+      const game = new Game()
+      const nonExistentPlayerId = 'ghost-player'
+
+      expect(() => game.removePlayer(nonExistentPlayerId)).toThrow()
+    })
+
+    it('should trigger a turn change if the current player leaves the game', () => {
+      const game = new Game()
+      game.addPlayer(firstPlayerId)
+      game.addPlayer(secondPlayerId)
+
+      game.removePlayer(firstPlayerId)
+
+      expect(game.currentPlayer?.id).toEqual(secondPlayerId)
+    })
+  })
+
+  describe('next turn', () => {
+    it('if only one player in the game, current turn player should not change', () => {
+      const game = new Game()
+
+      game.addPlayer(firstPlayerId)
+      game.nextTurn()
+
+      expect(game.currentPlayer?.id).toEqual(firstPlayerId)
+    })
+
+    it('should go to next player in list', () => {
+      const game = new Game()
+
+      game.addPlayer(firstPlayerId)
+      game.addPlayer(secondPlayerId)
+      game.nextTurn()
+      expect(game.currentPlayer?.id).toEqual(secondPlayerId)
+
+      game.nextTurn()
+      expect(game.currentPlayer?.id).toEqual(firstPlayerId)
+    })
+
+    it('should loop back to first player from last player in list', () => {
+      const game = new Game()
+
+      game.addPlayer(firstPlayerId)
+      game.addPlayer(secondPlayerId)
+      game.nextTurn()
+      game.nextTurn()
+
+      expect(game.currentPlayer?.id).toEqual(firstPlayerId)
+    })
+  })
+  
+  describe('check if the given player in the list', () => {
+    it('should return true if the given player is in the list', () => {
+      const game = new Game()
+      game.addPlayer(firstPlayerId)
+
+      expect(game.hasPlayer(firstPlayerId)).toBe(true)
+    })
+  
+    it('should return false if the given player is not in the list', () => {
+      const game = new Game()
+      expect(game.hasPlayer(firstPlayerId)).toBe(false)
+    })
+  })
+})

backend/src/events.ts

@@ -0,0 +1,18 @@
+export const SOCKET_EVENTS_OUTBOUND = {
+  DRAW: 'draw',
+  CONNECT: 'connect',
+  INITIAL_DATA: 'initial-data',
+  UPDATE_TURN: 'update-turn',
+  CLEAR_CANVAS: 'clear-canvas',
+  SELECTED_GAME_MODE: 'selected-game-mode',
+} as const
+
+export const SOCKET_EVENTS_INBOUND = {
+  CONNECTION: 'connection',
+  DISCONNECT: 'disconnect',
+
+  DRAW: 'draw',
+  END_TURN: 'end-turn',
+  CLEAR_CANVAS: 'clear-canvas',
+  SELECT_GAME_MODE: 'select-game-mode',
+} as const

backend/src/game-mode.ts

@@ -0,0 +1,6 @@
+enum GameMode {
+  OneLine = 'One Line',
+  LineLengthLimit = 'Line Length Limit',
+}
+
+export default GameMode

backend/src/index.ts

@@ -1,6 +1,9 @@
 import { createServer } from 'http'
 import { Server } from 'socket.io'
-import Drawing from '@/drawing'
+import Drawing from '@/models/drawing'
+import { SOCKET_EVENTS_INBOUND, SOCKET_EVENTS_OUTBOUND } from '@/events'
+import Game from '@/models/game'
+import GameMode from '@/game-mode'
 
 const PORT = 3001
 
@@ -17,119 +20,80 @@ const io = new Server(httpServer, {
   },
 })
 
-const SOCKET_EVENTS_OUTBOUND = {
-  DRAW: 'draw',
-  CONNECT: 'connect',
-  INITIAL_DATA: 'initial-data',
-  UPDATE_TURN: 'update-turn',
-  CLEAR_CANVAS: 'clear-canvas',
-  SELECTED_GAME_MODE: 'selected-game-mode',
-} as const
-
-const SOCKET_EVENTS_INBOUND = {
-  CONNECTION: 'connection',
-  DISCONNECT: 'disconnect',
-
-  DRAW: 'draw',
-  END_TURN: 'end-turn',
-  CLEAR_CANVAS: 'clear-canvas',
-  SELECT_GAME_MODE: 'select-game-mode',
-} as const
-
-enum GameMode {
-  OneLine = 'One Line',
-  LineLengthLimit = 'Line Length Limit',
-}
-
-let drawing = Drawing.createEmpty()
-let players: Array<string> = []
-let gameMode: GameMode | undefined | null = undefined
-const lineLengthLimit: number = 150
-let turnPlayer: string | undefined | null = undefined
+const game = new Game()
 
 io.on(SOCKET_EVENTS_INBOUND.CONNECTION, (socket) => {
   console.log('User connected:', socket.id)
 
-  players.push(socket.id)
-
-  if (players.length === 1) {
-    turnPlayer = socket.id
-  }
+  game.addPlayer(socket.id)
 
   socket.emit(SOCKET_EVENTS_OUTBOUND.UPDATE_TURN, {
-    turnPlayer,
+    turnPlayer: game.currentPlayer?.id,
   })
 
   socket.emit(SOCKET_EVENTS_OUTBOUND.INITIAL_DATA, {
-    lineLengthLimit,
-    drawing: drawing.getValue(),
-    gameMode,
+    lineLengthLimit: game.lineLengthLimit,
+    drawing: game.drawing.getValue(),
+    gameMode: game.gameMode,
   })
 
-  socket.on(SOCKET_EVENTS_INBOUND.DRAW, (drawingAsArray) => {
-    if (turnPlayer !== socket.id || !players.includes(socket.id)) {
-      return
-    }
-
-    if (!Drawing.canCreate(drawingAsArray)) {
-      return
-    }
-    drawing = Drawing.createFrom(drawingAsArray)
-
-    socket.broadcast.emit(SOCKET_EVENTS_OUTBOUND.DRAW, drawing.getValue())
-  })
+  socket.on(
+    SOCKET_EVENTS_INBOUND.DRAW,
+    (drawingAsArray: Buffer<ArrayBufferLike>) => {
+      if (game.currentPlayer?.id !== socket.id || !game.hasPlayer(socket.id)) {
+        return
+      }
+
+      if (!Drawing.canCreate(drawingAsArray)) {
+        return
+      }
+      game.updateDrawing(Drawing.createFrom(drawingAsArray))
+
+      socket.broadcast.emit(
+        SOCKET_EVENTS_OUTBOUND.DRAW,
+        game.drawing.getValue(),
+      )
+    },
+  )
 
   socket.on(SOCKET_EVENTS_INBOUND.SELECT_GAME_MODE, (mode: GameMode) => {
-    gameMode = mode
+    game.gameMode = mode
 
     socket.broadcast.emit(SOCKET_EVENTS_OUTBOUND.SELECTED_GAME_MODE, mode)
   })
 
   socket.on(SOCKET_EVENTS_INBOUND.CLEAR_CANVAS, () => {
-    if (!players.includes(socket.id)) {
+    if (!game.hasPlayer(socket.id)) {
       return
     }
 
-    drawing = Drawing.createEmpty()
-    gameMode = null
+    game.resetGame()
 
     socket.broadcast.emit(SOCKET_EVENTS_OUTBOUND.CLEAR_CANVAS, {
-      gameMode,
+      gameMode: game.gameMode,
     })
   })
 
   socket.on(SOCKET_EVENTS_INBOUND.END_TURN, () => {
-    if (turnPlayer !== socket.id || !players.includes(socket.id)) {
+    if (game.currentPlayer?.id !== socket.id || !game.hasPlayer(socket.id)) {
       return
     }
 
-    const nextPlayer = getNextElement(players, turnPlayer)
-    turnPlayer = nextPlayer ?? players[0] ?? null
+    game.nextTurn()
 
     io.emit(SOCKET_EVENTS_OUTBOUND.UPDATE_TURN, {
-      turnPlayer,
+      turnPlayer: game.currentPlayer.id,
     })
   })
 
   socket.on(SOCKET_EVENTS_INBOUND.DISCONNECT, (reason) => {
     console.log('User disconnected', socket.id, reason)
 
-    // Turn player disconnect special case
-    if (turnPlayer === socket.id) {
-      const nextPlayer = getNextElement(players, turnPlayer)
-      turnPlayer = nextPlayer ?? players[0] ?? null
-    }
-
     // Turn player and viewer disconnect
-    players = players.filter((p) => p !== socket.id)
+    game.removePlayer(socket.id)
   })
 })
 
 httpServer.listen(PORT, () => {
   console.log(`Server running on port ${PORT}`)
 })
-
-function getNextElement<T>(array: Array<T>, element: T) {
-  const currentIndex = array.indexOf(element)
-  return currentIndex === -1 ? null : array[(currentIndex + 1) % array.length]
-}