Phase3: Refactor fire big method and minor type fixes

Refactored a ShotResult for an error message

Author: vfarah-if

test-pnpm/battleships/constants.ts

@@ -1,2 +1,8 @@
+import { ShotResult } from './game.types';
+
 export const BLANK_BOARD_CELL = ' ';
 export const DEFAULT_BOARD_SIZE = 10;
+export const NO_HIT = {
+  hit: false,
+  message: 'Miss!',
+} as ShotResult;

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

@@ -211,9 +211,7 @@ describe('GameService should', () => {
       ]);
 
       gameService.fire('Player1', { x: 2, y: 2 });
-      const result = gameService.fire('Player1', { x: 2, y: 2 });
-      expect(result.hit).toBe(false);
-      expect(result.message).toBe('Already fired at (2, 2)');
+      expect(() => gameService.fire('Player1', { x: 2, y: 2 })).toThrow('Already fired at (2, 2)');
     });
 
     test('throw error when firing out of bounds', () => {

test-pnpm/battleships/game.service.ts

@@ -1,4 +1,4 @@
-import { DEFAULT_BOARD_SIZE } from './constants';
+import { DEFAULT_BOARD_SIZE, NO_HIT } from './constants';
 import { Ship, Coordinate, CellState, ShotResult, GameState, Game } from './game.types';
 import { EOL } from 'os';
 
@@ -69,48 +69,12 @@ export class GameService implements IGameService {
     this.ensurePlayerExists(playerName);
     this.ensureWithinBoard(target);
     this.ensurePlayerTurn(playerName);
-
-    const gameState = this._game.states.get(playerName);
-    if (!gameState) {
-      throw new Error(`No board found for player: ${playerName}`);
-    }
-
-    const currentState = gameState.board[target.y][target.x];
-    if (currentState === CellState.Hit || currentState === CellState.Miss) {
-      return {
-        hit: false,
-        message: `Already fired at (${target.x}, ${target.y})`,
-      };
-    }
-
+    const game = this.fetchGame(playerName);
+    const currentState = game.board[target.y][target.x];
+    this.ensureCellNotAlreadyUsed(currentState, target);
     const hit = currentState !== CellState.Empty;
-    gameState.board[target.y][target.x] = hit ? CellState.Hit : CellState.Miss;
-
-    if (hit) {
-      const coordString = `${target.x},${target.y}`;
-      const ship = this.findShipAtCoordinate(gameState.ships, target);
-      if (ship) {
-        ship.hits.add(coordString);
-        const shipDestroyed = this.isShipDestroyed(ship);
-        const gameWon = this.checkForWin(gameState.ships);
-
-        if (gameWon) {
-          gameState.winner = playerName;
-        }
-
-        return {
-          hit: true,
-          message: shipDestroyed ? 'Ship destroyed!' : 'Hit!',
-          shipDestroyed,
-          gameWon,
-        };
-      }
-    }
-
-    return {
-      hit: false,
-      message: 'Miss!',
-    };
+    game.board[target.y][target.x] = hit ? CellState.Hit : CellState.Miss;
+    return hit ? this.getShotResult(target, game, playerName) : NO_HIT;
   }
 
   getWinner(playerName: string): string | null {
@@ -150,26 +114,65 @@ export class GameService implements IGameService {
     return lines.join(EOL);
   }
 
-  private ensurePlayerTurn(playerName: string) {
+  private ensureCellNotAlreadyUsed(currentState: string, target: Coordinate): void {
+    if (this.isCellHitOrMissed(currentState)) {
+      throw new Error(`Already fired at (${target.x}, ${target.y})`);
+    }
+  }
+
+  private getShotResult(target: Coordinate, game: GameState, playerName: string): ShotResult {
+    const ship = this.findShipAtCoordinate(game.ships, target);
+    ship.hits.add(`${target.x},${target.y}`);
+    const shipDestroyed = this.isShipDestroyed(ship);
+    const isWinner = this.checkForWin(game.ships);
+    if (isWinner) {
+      game.winner = playerName;
+    }
+
+    return {
+      hit: true,
+      message: shipDestroyed ? 'Ship destroyed!' : 'Hit!',
+      shipDestroyed,
+      gameWon: isWinner,
+    };
+  }
+
+  private isCellHitOrMissed(currentState: string): boolean {
+    return currentState === CellState.Hit || currentState === CellState.Miss;
+  }
+
+  private fetchGame(playerName: string): GameState {
+    const gameState = this._game.states.get(playerName);
+    this.ensureGameExists(gameState, playerName);
+    return gameState;
+  }
+
+  private ensureGameExists(gameState: GameState, playerName: string): void {
+    if (!gameState) {
+      throw new Error(`No board found for player: ${playerName}`);
+    }
+  }
+
+  private ensurePlayerTurn(playerName: string): void {
     const currentPlayer = this.getCurrentPlayer();
     if (currentPlayer !== playerName) {
       throw new Error(`Not your turn. Current player: ${currentPlayer}`);
     }
   }
 
-  private ensureNoShipOverlap(board: string[][], coord: Coordinate) {
+  private ensureNoShipOverlap(board: string[][], coord: Coordinate): void {
     if (this.checkForShipOverlap(board, coord)) {
       throw new Error(`Ship overlap at (${coord.x}, ${coord.y})`);
     }
   }
 
-  private ensureWithinBoard(coord: Coordinate) {
-    if (this.outsideBoard(coord)) {
+  private ensureWithinBoard(coord: Coordinate): void {
+    if (this.isOutsideBoard(coord)) {
       throw new Error(`Ship placement out of bounds: (${coord.x}, ${coord.y})`);
     }
   }
 
-  private ensurePlayerExists(playerName: string) {
+  private ensurePlayerExists(playerName: string): void {
     if (!this.hasPlayer(playerName)) {
       throw new Error(`Unknown player: ${playerName}`);
     }
@@ -199,11 +202,11 @@ export class GameService implements IGameService {
     return board[coord.y][coord.x] !== CellState.Empty;
   }
 
-  private outsideBoard(coord: Coordinate) {
+  private isOutsideBoard(coord: Coordinate): boolean {
     return coord.x < 0 || coord.x >= this._boardSize || coord.y < 0 || coord.y >= this._boardSize;
   }
 
-  private printContent(board: string[][], lines: string[]) {
+  private printContent(board: string[][], lines: string[]): void {
     for (let y = 0; y < this._boardSize; y++) {
       let row = `  ${y}|`;
       for (let x = 0; x < this._boardSize; x++) {
@@ -213,7 +216,7 @@ export class GameService implements IGameService {
     }
   }
 
-  private printHeader(lines: string[]) {
+  private printHeader(lines: string[]): void {
     let header = '   |';
     for (let x = 0; x < this._boardSize; x++) {
       header += ` ${x} |`;