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

TS doc, refactored a bit, added a failed test

Browse Source
This commit is contained in:
martin 2023-05-28 14:39:53 +02:00
parent a473d8ce66
commit a14a54c279
2 changed files with 102 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -7,90 +7,110 @@ import {Direction} 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
* @returns {Path[]} An array of paths the character can move to
*/
export default function findPossiblePositions(board: GameMap, character: Character, steps: number): Path[] {
const possiblePositions: Path[] = [];
findPossibleRecursive(board, character.position, steps, // TODO sometimes the character steps on the same tile twice
character instanceof PacMan, possiblePositions);
return possiblePositions;
return findPossibleRecursive(board, character.position, steps, character instanceof PacMan);
}
function findPossibleRecursive(board: GameMap, currentPath: Path, steps: number,
isPacMan: boolean, possibleList: Path[]): void {
/**
* Uses recursion to move through the board and find all the possible positions
* @param board The board the character is on
* @param path The current path the character is on
* @param steps The number of steps the character can move
* @param isPacMan True if the character is Pac-Man, false if it is a ghost
* @returns {Path[]} An array of paths the character can move to
*/
function findPossibleRecursive(board: GameMap, path: Path, steps: number, isPacMan: boolean): Path[] {
if (isOutsideBoard(currentPath, board.length)) {
const paths: Path[] = [];
if (isOutsideBoard(path, board.length)) {
if (isPacMan) {
addTeleportationTiles(board, currentPath, steps, isPacMan, possibleList);
return addTeleportationTiles(board, path, steps, isPacMan);
}
return;
} else if (isWall(board, currentPath)) {
return;
}
} else if (!isWall(board, path)) {
if (steps === 0) {
paths.push(path);
} else {
if (steps === 0) {
pushTileToList(board, currentPath, possibleList);
} else {
steps--;
tryMove(board, currentPath, Direction.up, steps, isPacMan, possibleList);
tryMove(board, currentPath, Direction.right, steps, isPacMan, possibleList);
tryMove(board, currentPath, Direction.down, steps, isPacMan, possibleList);
tryMove(board, currentPath, Direction.left, steps, isPacMan, possibleList);
steps--;
paths.push(...tryMove(board, path, Direction.up, steps, isPacMan));
paths.push(...tryMove(board, path, Direction.right, steps, isPacMan));
paths.push(...tryMove(board, path, Direction.down, steps, isPacMan));
paths.push(...tryMove(board, path, Direction.left, steps, isPacMan));
}
}
return paths;
}
function tryMove(board: GameMap, currentPath: Path, direction: Direction, steps: number, isPacMan: boolean, possibleList: Path[]): void {
/**
* Tries to move the character in the given direction
* @param board The board the character is on
* @param path The current path the character is on
* @param direction The direction to move in
* @param steps The number of steps the character can move
* @param isPacMan True if the character is Pac-Man, false if it is a ghost
* @returns {Path[]} An array of paths the character can move to
*/
function tryMove(board: GameMap, path: Path, direction: Direction, steps: number, isPacMan: boolean): Path[] {
function getNewPosition(): Position {
switch (direction) {
case Direction.left:
return {
x: currentPath.end.x - 1,
y: currentPath.end.y
x: path.end.x - 1,
y: path.end.y
};
case Direction.up:
return {
x: currentPath.end.x,
y: currentPath.end.y - 1
x: path.end.x,
y: path.end.y - 1
};
case Direction.right:
return {
x: currentPath.end.x + 1,
y: currentPath.end.y
x: path.end.x + 1,
y: path.end.y
};
case Direction.down:
return {
x: currentPath.end.x,
y: currentPath.end.y + 1
x: path.end.x,
y: path.end.y + 1
};
}
}
if (currentPath.direction !== (direction + 2) % 4) {
findPossibleRecursive(board, {
if (path.direction !== (direction + 2) % 4) {
return findPossibleRecursive(board, {
end: getNewPosition(), direction: direction
}, steps, isPacMan, possibleList);
}, steps, isPacMan);
}
return [];
}
function addTeleportationTiles(board: GameMap, currentPath: Path, steps: number, isPacMan: boolean,
possibleList: Path[]): void {
/**
* Finds all the possible paths when using teleportation tiles
* @param board The board the character is on
* @param path The current path the character is on
* @param steps The number of steps the character can move
* @param isPacMan True if the character is Pac-Man, false if it is a ghost
*/
function addTeleportationTiles(board: GameMap, path: Path, steps: number, isPacMan: boolean): Path[] {
const possiblePositions = findTeleportationTiles(board);
const paths: Path[] = [];
for (const pos of possiblePositions) {
if (pos.end.x !== Math.max(currentPath.end.x, 0) || pos.end.y !== Math.max(currentPath.end.y, 0)) {
findPossibleRecursive(board, pos, steps, isPacMan, possibleList);
if (pos.end.x !== Math.max(path.end.x, 0) || pos.end.y !== Math.max(path.end.y, 0)) {
paths.push(...findPossibleRecursive(board, pos, steps, isPacMan));
}
}
return paths;
}
function pushTileToList(board: GameMap, tile: Path | null, list: Path[]): void {
if (tile !== null && !list.find(p => p.end.x === tile.end.x && p.end.y === tile.end.y) &&
!isOutsideBoard(tile, board.length) && !isSpawn(board, tile)) {
list.push(tile);
}
}
function findTeleportationTiles(board: number[][]): Path[] {
/**
* Finds all the teleportation tiles on the board
* @param board The board the character is on
* @returns {Path[]} An array of paths containing the teleportation tiles
*/
function findTeleportationTiles(board: GameMap): Path[] {
const possiblePositions: Path[] = [];
const edge = [0, board.length - 1];
@ -105,19 +125,32 @@ function findTeleportationTiles(board: number[][]): Path[] {
return possiblePositions;
}
/**
* Pushes a path to the array if the position is not a wall
* @param board The board the character is on
* @param possiblePositions The array of paths to push to
* @param x The x position of the path
* @param y The y position of the path
*/
function pushPath(board: GameMap, possiblePositions: Path[], x: number, y: number): void {
if (board[x][y] !== TileType.wall) {
possiblePositions.push({end: {x, y}, direction: findDirection(x, y, board.length)});
}
}
function findDirection(x: number, y: number, length: number): Direction {
/**
* Finds the direction the character will be facing when moving to the given position
* @param x The x position of the new position
* @param y The y position of the new position
* @param boardSize The length of the board
*/
function findDirection(x: number, y: number, boardSize: number): Direction {
let direction: Direction;
if (x === 0) {
direction = Direction.right;
} else if (y === 0) {
direction = Direction.down;
} else if (x === length - 1) {
} else if (x === boardSize - 1) {
direction = Direction.left;
} else {
direction = Direction.up;
@ -125,17 +158,32 @@ function findDirection(x: number, y: number, length: number): Direction {
return direction;
}
/**
* Checks if the character is outside the board
* @param currentPos The current position of the character
* @param boardSize The size of the board
*/
function isOutsideBoard(currentPos: Path, boardSize: number): boolean {
const pos = currentPos.end;
return pos.x < 0 || pos.x >= boardSize || pos.y < 0 || pos.y >= boardSize;
}
/**
* Checks if the character is on a wall
* @param board The board the character is on
* @param currentPos The current position of the character
*/
function isWall(board: GameMap, currentPos: Path): boolean {
const pos = currentPos.end;
return board[pos.y][pos.x] === TileType.wall; // Shouldn't work, but it does
}
function isSpawn(board: GameMap, currentPos: Path): boolean {
/**
* Checks if the character is on a spawn
* @param board The board the character is on
* @param currentPos The current position of the character
*/
function isSpawn(board: GameMap, currentPos: Path): boolean { // TODO check if character is on it's own spawn
const pos = currentPos.end;
return board[pos.x][pos.y] === TileType.pacmanSpawn || board[pos.x][pos.y] === TileType.ghostSpawn;
}

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

@ -57,6 +57,12 @@ test("Pac-Man rolls six from start, should return six positions", () => {
{at: {x: 5, y: 10}, direction: Direction.up}));
});
test("Pac-Man rolls four from position [5,1] (right), should return 11", () => {
pacMan.follow({end: {x: 5, y: 1}, direction: Direction.right});
const result = possibleMovesAlgorithm(testMap, pacMan, 4);
expect(result.length).toBe(11); // TODO a character can't move to a different character's spawn
});
test("Pac-Man rolls three from position [1,5] (left), should return 5", () => {
pacMan.follow({end: {x: 1, y: 5}, direction: Direction.left});
const result = possibleMovesAlgorithm(testMap, pacMan, 3);