martials/pac-man-board-game
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed ghosts can take pac-men and added more tests

Browse Source
This commit is contained in:
Martin Berg Alstad 2023-07-16 20:07:15 +02:00
parent 6ecb9515b9
commit ec73c7df65
3 changed files with 55 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/node.js.yml vendored
View File

@ -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:

17
pac-man-board-game/ClientApp/src/game/possibleMovesAlgorithm.ts
View File

@ -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 {
return character.isGhost() && characters.find(c => c.isPacMan() && c.isAt(currentPath.End)) !== undefined;
function ghostHitsPacMan(character: Character, currentPath: Path, characters: Character[]): Character | undefined | false {
return character.isGhost() && characters.find(c => c.isPacMan() && c.isAt(currentPath.End));
}
/**

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

@ -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);