Fixed ghosts can take pac-men and added more tests

.github/workflows/node.js.yml

@@ -16,7 +16,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [18.x]
+        node-version: [14.x, 16.x, 18.x]
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
     steps:

pac-man-board-game/ClientApp/src/game/possibleMovesAlgorithm.ts

@@ -9,7 +9,7 @@ import {Direction, getDirections} from "./direction";
  * @param board The board the character is on
  * @param character The current position of the character
  * @param steps The number of steps the character can move
- * @param characters
+ * @param characters All the characters on the board
  * @returns An array of paths the character can move to
  */
 export default function findPossiblePositions(board: GameMap, character: Character, steps: number, characters: Character[]): Path[] {
@@ -41,8 +41,6 @@ function findPossibleRecursive(board: GameMap, currentPath: Path, steps: number,
           paths.push(currentPath);
         }
 
-      } else if (ghostHitsPacMan(character, currentPath, characters)) {
-        paths.push(currentPath);
       } else {
 
         addToPath(currentPath);
@@ -52,11 +50,20 @@ function findPossibleRecursive(board: GameMap, currentPath: Path, steps: number,
           paths.push(...tryMove(board, currentPath, direction, steps, character, characters));
         }
       }
+    } else {
+      const pacMan = ghostHitsPacMan(character, currentPath, characters);
+      if (pacMan instanceof Character && !isCharactersSpawn(currentPath, pacMan)) {
+        paths.push(currentPath);
+      }
     }
   }
   return paths;
 }
 
+function isCharactersSpawn(currentPath: Path, character: Character): boolean {
+  return character.SpawnPosition?.At.X === currentPath.End.X && character.SpawnPosition.At.Y === currentPath.End.Y;
+}
+
 /**
  * Checks if the current character is a ghost, and Pac-Man is on the same tile
  * @param character The current character
@@ -64,8 +71,8 @@ function findPossibleRecursive(board: GameMap, currentPath: Path, steps: number,
  * @param characters All the characters on the board
  * @returns True if the character is a ghost and hits Pac-Man
  */
-function ghostHitsPacMan(character: Character, currentPath: Path, characters: Character[]): boolean {
+function ghostHitsPacMan(character: Character, currentPath: Path, characters: Character[]): Character | undefined | false {
-  return character.isGhost() && characters.find(c => c.isPacMan() && c.isAt(currentPath.End)) !== undefined;
+  return character.isGhost() && characters.find(c => c.isPacMan() && c.isAt(currentPath.End));
 }
 
 /**

pac-man-board-game/ClientApp/tests/game/possibleMovesAlgorithm.test.ts

@@ -1,16 +1,20 @@
 import {beforeEach, expect, test} from "vitest";
 import possibleMovesAlgorithm from "../../src/game/possibleMovesAlgorithm";
 import {testMap} from "../../src/game/map";
-import {Character, PacMan} from "../../src/game/character";
+import {Ghost, PacMan} from "../../src/game/character";
 import {Direction} from "../../src/game/direction";
 import {Colour} from "../../src/game/colour";
 
-let pacMan: Character;
+let pacMan: PacMan;
+let ghost: Ghost;
 
 beforeEach(() => {
   pacMan = new PacMan({
     Colour: Colour.Yellow, SpawnPosition: {At: {X: 3, Y: 3}, Direction: Direction.up}
   });
+  ghost = new Ghost({
+    Colour: Colour.Red, SpawnPosition: {At: {X: 3, Y: 3}, Direction: Direction.up}
+  });
 });
 
 test("Pac-Man rolls one from start, should return one position", () => {
@@ -146,6 +150,42 @@ test("Pac-Man rolls 5 from position [9,3] (down), should return 7", () => {
   expect(result.length).toBe(7);
 });
 
+test("Ghost can take Pac-Man, stops exactly on Pac-Man unless Pac-Man is at spawn", () => {
+  ghost.follow({End: {X: 3, Y: 5}, Direction: Direction.up});
+  const result = possibleMovesAlgorithm(testMap, ghost, 2, [ghost, pacMan]);
+  expect(result.length).toBe(2);
+  arrayEquals(result, [
+    {End: {X: 1, Y: 5}, Direction: Direction.left, Path: [{X: 2, Y: 5}]},
+    {End: {X: 5, Y: 5}, Direction: Direction.right, Path: [{X: 4, Y: 5}]},
+  ])
+});
+
+test("Ghost can take Pac-Man, steps reach Pac-Man exactly", () => {
+  ghost.follow({End: {X: 7, Y: 3}, Direction: Direction.up});
+  pacMan.follow({End: {X: 5, Y: 1}, Direction: Direction.right});
+  const result = possibleMovesAlgorithm(testMap, ghost, 4, [ghost, pacMan]);
+  expect(result.length).toBe(2);
+  arrayEquals(result, [
+    {End: {X: 5, Y: 1}, Direction: Direction.left, Path: [{X: 7, Y: 2}, {X: 7, Y: 1}, {X: 6, Y: 1}]},
+    {End: {X: 9, Y: 1}, Direction: Direction.right, Path: [{X: 7, Y: 2}, {X: 7, Y: 1}, {X: 8, Y: 1}]},
+  ])
+});
+
+test("Ghost can take Pac-Man, steps overshoot Pac-Man", () => {
+  ghost.follow({End: {X: 7, Y: 3}, Direction: Direction.up});
+  pacMan.follow({End: {X: 5, Y: 1}, Direction: Direction.right});
+  const result = possibleMovesAlgorithm(testMap, ghost, 6, [ghost, pacMan]);
+  expect(result.length).toBe(2);
+  arrayEquals(result, [
+    {End: {X: 5, Y: 1}, Direction: Direction.left, Path: [{X: 7, Y: 2}, {X: 7, Y: 1}, {X: 6, Y: 1}]},
+    {
+      End: {X: 9, Y: 3},
+      Direction: Direction.down,
+      Path: [{X: 7, Y: 2}, {X: 7, Y: 1}, {X: 8, Y: 1}, {X: 9, Y: 1}, {X: 9, Y: 2}]
+    },
+  ])
+});
+
 function arrayEquals<T extends any[]>(result: T, expected: T, message?: string): void {
   for (const item of expected) {
     expect(result, message).toContainEqual(item);