Phase3: make endTurn pass

Fix bug introduced previously with oversimplifying ships
Refactor names
Implement the game state for players
Simplify mocks and tests

Author: vfarah-if

test-pnpm/battleships/command.handler.should.test.ts

@@ -1,3 +1,4 @@
+import { EOL } from 'os';
 import { CommandHandler } from './command.handler';
 import { GameService } from './game.service';
 import { ShipType } from './game.types';
@@ -19,31 +20,26 @@ describe('CommandHandler should', () => {
     expect(print).toHaveBeenLastCalledWith('Player "Player1" added.');
   });
 
-  test.skip('delegate valid start game command with carrier', () => {
-    addPlayerOne(handler);
-    handler.execute('start Player1 c:2,2:2,3:2,4:2,5:2,6');
-    expect(gameService.printBoard('Player1')).toContain(ShipType.Carrier);
-  });
-
-  test.skip('delegate valid start game command with destroyer', () => {
-    addPlayerOne(handler);
-    handler.execute('start Player1 d:2,2:2,3:2,4');
-    expect(gameService.printBoard('Player1')).toContain(ShipType.Destroyer);
-  });
-
-  test.skip('delegate a valid start game command with one player and a gunship', () => {
-    addPlayerOne(handler);
-    handler.execute('start Player1 g:2,2');
-    expect(gameService.printBoard('Player1')).toContain(ShipType.Gunship);
-  });
-
   test('delegate valid start game command with all ship types', () => {
     addPlayerOne(handler);
     handler.execute('start Player1 c:2,2:2,3:2,4:2,5:2,6 d:3,2:3,3:3,4 g:4,2');
     const board = gameService.printBoard('Player1');
     expect(board).toContain(ShipType.Carrier);
     expect(board).toContain(ShipType.Destroyer);
     expect(board).toContain(ShipType.Gunship);
+    expect(board.split(EOL)).toEqual([
+      '   | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |',
+      '  0|   |   |   |   |   |   |   |   |   |   |',
+      '  1|   |   |   |   |   |   |   |   |   |   |',
+      '  2|   |   | c | d | g |   |   |   |   |   |',
+      '  3|   |   | c | d |   |   |   |   |   |   |',
+      '  4|   |   | c | d |   |   |   |   |   |   |',
+      '  5|   |   | c |   |   |   |   |   |   |   |',
+      '  6|   |   | c |   |   |   |   |   |   |   |',
+      '  7|   |   |   |   |   |   |   |   |   |   |',
+      '  8|   |   |   |   |   |   |   |   |   |   |',
+      '  9|   |   |   |   |   |   |   |   |   |   |',
+    ]);
   });
 
   test('throw error for unknown command', () => {

test-pnpm/battleships/command.handler.ts

@@ -15,6 +15,7 @@ export class CommandHandler {
       start: (args) => this.startGameForPlayer(args),
       print: (args) => this.printPlayerBoard(args),
       fire: (args) => this.processFireCommand(args),
+      endTurn: () => this.processTurnCommand(),
     };
 
     const handler = commands[command];
@@ -47,6 +48,11 @@ export class CommandHandler {
     this.print(message);
   }
 
+  private processTurnCommand() {
+    const nextPlayer = this.gameService.switchTurn();
+    this.print(`Turn switched to ${nextPlayer}`);
+  }
+
   private printPlayerBoard(args: string[]) {
     const playerName = args[0];
     this.ensurePlayerExists(playerName);

test-pnpm/battleships/game.service.should.test.ts

@@ -154,7 +154,7 @@ describe('GameService should', () => {
       '   | 0 | 1 | 2 | 3 | 4 |',
       '  0|   |   |   |   |   |',
       '  1|   |   |   |   |   |',
-      '  2|   |   | s |   |   |',
+      '  2|   |   | g |   |   |',
       '  3|   |   |   |   |   |',
       '  4|   |   |   |   |   |',
     ]);
@@ -311,4 +311,97 @@ describe('GameService should', () => {
       expect(gameService.getWinner('Player1')).toBe('Player1');
     });
   });
+
+  describe('turn-based gameplay', () => {
+    test('track current player', () => {
+      const gameService = new GameService();
+      gameService.addPlayer('Player1');
+      gameService.addPlayer('Player2');
+      gameService.startGame('Player1', [
+        {
+          type: ShipType.Gunship,
+          coordinates: [{ x: 2, y: 2 }],
+          hits: new Set<string>(),
+        },
+      ]);
+      gameService.startGame('Player2', [
+        {
+          type: ShipType.Gunship,
+          coordinates: [{ x: 3, y: 3 }],
+          hits: new Set<string>(),
+        },
+      ]);
+
+      expect(gameService.getCurrentPlayer()).toBe('Player1');
+    });
+
+    test('switch turns between players', () => {
+      const gameService = new GameService();
+      gameService.addPlayer('Player1');
+      gameService.addPlayer('Player2');
+      gameService.startGame('Player1', [
+        {
+          type: ShipType.Gunship,
+          coordinates: [{ x: 2, y: 2 }],
+          hits: new Set<string>(),
+        },
+      ]);
+      gameService.startGame('Player2', [
+        {
+          type: ShipType.Gunship,
+          coordinates: [{ x: 3, y: 3 }],
+          hits: new Set<string>(),
+        },
+      ]);
+
+      expect(gameService.getCurrentPlayer()).toBe('Player1');
+      expect(gameService.switchTurn()).toBe('Player2');
+      expect(gameService.getCurrentPlayer()).toBe('Player2');
+      expect(gameService.switchTurn()).toBe('Player1');
+      expect(gameService.getCurrentPlayer()).toBe('Player1');
+    });
+
+    test('throw error when switching turns with less than 2 players', () => {
+      const gameService = new GameService();
+      gameService.addPlayer('Player1');
+      gameService.startGame('Player1', [
+        {
+          type: ShipType.Gunship,
+          coordinates: [{ x: 2, y: 2 }],
+          hits: new Set<string>(),
+        },
+      ]);
+
+      expect(() => gameService.switchTurn()).toThrow('Need at least 2 players to switch turns');
+    });
+
+    test('only allow current player to fire', () => {
+      const gameService = new GameService();
+      gameService.addPlayer('Player1');
+      gameService.addPlayer('Player2');
+      gameService.startGame('Player1', [
+        {
+          type: ShipType.Gunship,
+          coordinates: [{ x: 2, y: 2 }],
+          hits: new Set<string>(),
+        },
+      ]);
+      gameService.startGame('Player2', [
+        {
+          type: ShipType.Gunship,
+          coordinates: [{ x: 3, y: 3 }],
+          hits: new Set<string>(),
+        },
+      ]);
+
+      expect(() => gameService.fire('Player2', { x: 2, y: 2 })).toThrow(
+        'Not your turn. Current player: Player1',
+      );
+
+      gameService.switchTurn();
+      expect(() => gameService.fire('Player1', { x: 3, y: 3 })).toThrow(
+        'Not your turn. Current player: Player2',
+      );
+    });
+  });
 });

test-pnpm/battleships/game.service.ts

@@ -1,5 +1,5 @@
 import { DEFAULT_BOARD_SIZE } from './constants';
-import { Ship, Coordinate, CellState, ShotResult, GameState } from './game.types';
+import { Ship, Coordinate, CellState, ShotResult, GameState, Game } from './game.types';
 import { EOL } from 'os';
 
 export interface IGameService {
@@ -10,11 +10,13 @@ export interface IGameService {
   getBoardSize(): number;
   fire(playerName: string, target: Coordinate): ShotResult;
   getWinner(playerName: string): string | null;
+  getCurrentPlayer(): string | null;
+  switchTurn(): string;
 }
 
 export class GameService implements IGameService {
   private readonly _players: Set<string>;
-  private readonly _gameStates: Map<string, GameState>;
+  private readonly _game: Game;
   private readonly _boardSize: number;
 
   constructor(boardSize: number = DEFAULT_BOARD_SIZE) {
@@ -23,7 +25,11 @@ export class GameService implements IGameService {
     }
     this._boardSize = boardSize;
     this._players = new Set<string>();
-    this._gameStates = new Map<string, GameState>();
+    this._game = {
+      players: [],
+      currentPlayerIndex: 0,
+      states: new Map<string, GameState>(),
+    };
   }
 
   getBoardSize(): number {
@@ -34,51 +40,37 @@ export class GameService implements IGameService {
     this.ensurePlayerExists(playerName);
     const board = this.createEmptyBoard();
 
-    const shipsWithHits = ships.map((ship) => ({
+    const shipsWithNoHits = ships.map((ship) => ({
       ...ship,
       hits: new Set<string>(),
     }));
 
-    for (const ship of shipsWithHits) {
+    for (const ship of shipsWithNoHits) {
       for (const coord of ship.coordinates) {
         this.ensureWithinBoard(coord);
         this.ensureNoShipOverlap(board, coord);
-        board[coord.y][coord.x] = CellState.Ship;
+        board[coord.y][coord.x] = ship.type;
       }
     }
 
-    this._gameStates.set(playerName, {
-      ships: shipsWithHits,
+    const gameState = this._game.states.get(playerName) || {
+      ships: shipsWithNoHits,
       board,
       winner: null,
-    });
-  }
-
-  addPlayer(name: string): void {
-    this._players.add(name);
-  }
-
-  hasPlayer(name: string): boolean {
-    return this._players.has(name);
-  }
+    };
+    this._game.states.set(playerName, gameState);
 
-  printBoard(playerName: string): string {
-    const board = this._gameStates.get(playerName)?.board;
-    if (!board) {
-      throw new Error(`No board found for player: ${playerName}`);
+    if (!this._game.players.includes(playerName)) {
+      this._game.players.push(playerName);
     }
-
-    const lines: string[] = [];
-    this.printHeader(lines);
-    this.printContent(board, lines);
-    return lines.join(EOL);
   }
 
   fire(playerName: string, target: Coordinate): ShotResult {
     this.ensurePlayerExists(playerName);
     this.ensureWithinBoard(target);
+    this.ensurePlayerTurn(playerName);
 
-    const gameState = this._gameStates.get(playerName);
+    const gameState = this._game.states.get(playerName);
     if (!gameState) {
       throw new Error(`No board found for player: ${playerName}`);
     }
@@ -91,7 +83,7 @@ export class GameService implements IGameService {
       };
     }
 
-    const hit = currentState === CellState.Ship;
+    const hit = currentState !== CellState.Empty;
     gameState.board[target.y][target.x] = hit ? CellState.Hit : CellState.Miss;
 
     if (hit) {
@@ -122,10 +114,49 @@ export class GameService implements IGameService {
   }
 
   getWinner(playerName: string): string | null {
-    const gameState = this._gameStates.get(playerName);
+    const gameState = this._game.states.get(playerName);
     return gameState?.winner ?? null;
   }
 
+  getCurrentPlayer(): string | null {
+    return this._game.players[this._game.currentPlayerIndex] || null;
+  }
+
+  switchTurn(): string {
+    if (this._game.players.length < 2) {
+      throw new Error('Need at least 2 players to switch turns');
+    }
+    this._game.currentPlayerIndex = (this._game.currentPlayerIndex + 1) % this._game.players.length;
+    return this.getCurrentPlayer()!;
+  }
+
+  addPlayer(name: string): void {
+    this._players.add(name);
+  }
+
+  hasPlayer(name: string): boolean {
+    return this._players.has(name);
+  }
+
+  printBoard(playerName: string): string {
+    const gameState = this._game.states.get(playerName);
+    if (!gameState) {
+      throw new Error(`No board found for player: ${playerName}`);
+    }
+
+    const lines: string[] = [];
+    this.printHeader(lines);
+    this.printContent(gameState.board, lines);
+    return lines.join(EOL);
+  }
+
+  private ensurePlayerTurn(playerName: string) {
+    const currentPlayer = this.getCurrentPlayer();
+    if (currentPlayer !== playerName) {
+      throw new Error(`Not your turn. Current player: ${currentPlayer}`);
+    }
+  }
+
   private ensureNoShipOverlap(board: string[][], coord: Coordinate) {
     if (this.checkForShipOverlap(board, coord)) {
       throw new Error(`Ship overlap at (${coord.x}, ${coord.y})`);
@@ -144,6 +175,26 @@ export class GameService implements IGameService {
     }
   }
 
+  private findShipAtCoordinate(ships: Ship[], target: Coordinate): Ship | undefined {
+    return ships.find((ship) =>
+      ship.coordinates.some((coord) => coord.x === target.x && coord.y === target.y),
+    );
+  }
+
+  private isShipDestroyed(ship: Ship): boolean {
+    return ship.coordinates.every((coord) => ship.hits.has(`${coord.x},${coord.y}`));
+  }
+
+  private checkForWin(ships: Ship[]): boolean {
+    return ships.every((ship) => this.isShipDestroyed(ship));
+  }
+
+  private createEmptyBoard(): string[][] {
+    return Array(this._boardSize)
+      .fill(null)
+      .map(() => Array(this._boardSize).fill(CellState.Empty));
+  }
+
   private checkForShipOverlap(board: string[][], coord: Coordinate): boolean {
     return board[coord.y][coord.x] !== CellState.Empty;
   }
@@ -169,24 +220,4 @@ export class GameService implements IGameService {
     }
     lines.push(header);
   }
-
-  private findShipAtCoordinate(ships: Ship[], target: Coordinate): Ship | undefined {
-    return ships.find((ship) =>
-      ship.coordinates.some((coord) => coord.x === target.x && coord.y === target.y),
-    );
-  }
-
-  private isShipDestroyed(ship: Ship): boolean {
-    return ship.coordinates.every((coord) => ship.hits.has(`${coord.x},${coord.y}`));
-  }
-
-  private checkForWin(ships: Ship[]): boolean {
-    return ships.every((ship) => this.isShipDestroyed(ship));
-  }
-
-  private createEmptyBoard(): string[][] {
-    return Array(this._boardSize)
-      .fill(null)
-      .map(() => Array(this._boardSize).fill(CellState.Empty));
-  }
 }