347 lines
8.4 KiB
TypeScript
347 lines
8.4 KiB
TypeScript
import type { PositionTag, Coord, CellTag, MazeCell, MazeData } from "./types";
|
|
|
|
export class MazeGenerator {
|
|
width: number;
|
|
height: number;
|
|
cols: number;
|
|
rows: number;
|
|
maze: MazeCell[][];
|
|
totalSteps: number = 0;
|
|
|
|
constructor(userCols: number, userRows: number) {
|
|
const cellsWide = Math.max(1, Math.floor(userCols / 2));
|
|
const cellsHigh = Math.max(1, Math.floor(userRows / 2));
|
|
|
|
this.width = cellsWide;
|
|
this.height = cellsHigh;
|
|
|
|
this.cols = 2 * this.width + 1;
|
|
this.rows = 2 * this.height + 1;
|
|
|
|
this.maze = this.initArray<MazeCell>([]);
|
|
|
|
this.maze.forEach((row, r) => {
|
|
row.forEach((_cell, c) => {
|
|
switch (r) {
|
|
case 0:
|
|
case this.rows - 1:
|
|
this.maze[r][c] = ["wall"];
|
|
break;
|
|
|
|
default:
|
|
if ((r % 2) === 1) {
|
|
if ((c === 0) || (c === this.cols - 1)) {
|
|
this.maze[r][c] = ["wall"];
|
|
}
|
|
} else if (c % 2 === 0) {
|
|
this.maze[r][c] = ["wall"];
|
|
}
|
|
}
|
|
});
|
|
|
|
if (r === 0) {
|
|
const doorPos = this.posToSpace(this.rand(1, this.width));
|
|
this.maze[r][doorPos] = ["door", "exit"];
|
|
}
|
|
|
|
if (r === this.rows - 1) {
|
|
const doorPos = this.posToSpace(this.rand(1, this.width));
|
|
this.maze[r][doorPos] = ["door", "entrance"];
|
|
}
|
|
});
|
|
|
|
this.partition(1, this.height - 1, 1, this.width - 1);
|
|
}
|
|
|
|
private initArray<T = unknown>(value?: T): T[][] {
|
|
return new Array(this.rows)
|
|
.fill(null)
|
|
.map(() => new Array(this.cols).fill(value as T));
|
|
}
|
|
|
|
private rand(min: number, max: number): number {
|
|
return min + Math.floor(Math.random() * (1 + max - min));
|
|
}
|
|
|
|
private posToSpace(x: number): number {
|
|
return 2 * (x - 1) + 1;
|
|
}
|
|
|
|
private posToWall(x: number): number {
|
|
return 2 * x;
|
|
}
|
|
|
|
private inBounds(r: number, c: number): boolean {
|
|
if (
|
|
typeof this.maze[r] === "undefined" ||
|
|
typeof this.maze[r]?.[c] === "undefined"
|
|
) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private shuffle<T>(array: T[]): T[] {
|
|
for (let i = array.length - 1; i > 0; i--) {
|
|
const j = Math.floor(Math.random() * (i + 1));
|
|
[array[i], array[j]] = [array[j], array[i]];
|
|
}
|
|
return array;
|
|
}
|
|
|
|
private partition(r1: number, r2: number, c1: number, c2: number): void {
|
|
let horiz: number, vert: number;
|
|
let x: number, y: number, start: number, end: number;
|
|
|
|
if (r2 < r1 || c2 < c1) {
|
|
return;
|
|
}
|
|
|
|
if (r1 === r2) {
|
|
horiz = r1;
|
|
} else {
|
|
x = r1 + 1;
|
|
y = r2 - 1;
|
|
start = Math.round(x + (y - x) / 4);
|
|
end = Math.round(x + (y - x) * 3 / 4);
|
|
horiz = this.rand(start, end);
|
|
}
|
|
|
|
if (c1 === c2) {
|
|
vert = c1;
|
|
} else {
|
|
x = c1 + 1;
|
|
y = c2 - 1;
|
|
start = Math.round(x + (y - x) / 3);
|
|
end = Math.round(x + (y - x) * 2 / 3);
|
|
vert = this.rand(start, end);
|
|
}
|
|
|
|
for (let i = this.posToWall(r1) - 1; i <= this.posToWall(r2) + 1; i++) {
|
|
for (let j = this.posToWall(c1) - 1; j <= this.posToWall(c2) + 1; j++) {
|
|
if (i === this.posToWall(horiz) || j === this.posToWall(vert)) {
|
|
this.maze[i][j] = ["wall"];
|
|
}
|
|
}
|
|
}
|
|
|
|
const gaps = this.shuffle([true, true, true, false]);
|
|
|
|
if (gaps[0]) {
|
|
const gapPosition = this.rand(c1, vert);
|
|
this.maze[this.posToWall(horiz)][this.posToSpace(gapPosition)] = [];
|
|
}
|
|
|
|
if (gaps[1]) {
|
|
const gapPosition = this.rand(vert + 1, c2 + 1);
|
|
this.maze[this.posToWall(horiz)][this.posToSpace(gapPosition)] = [];
|
|
}
|
|
|
|
if (gaps[2]) {
|
|
const gapPosition = this.rand(r1, horiz);
|
|
this.maze[this.posToSpace(gapPosition)][this.posToWall(vert)] = [];
|
|
}
|
|
|
|
if (gaps[3]) {
|
|
const gapPosition = this.rand(horiz + 1, r2 + 1);
|
|
this.maze[this.posToSpace(gapPosition)][this.posToWall(vert)] = [];
|
|
}
|
|
|
|
this.partition(r1, horiz - 1, c1, vert - 1);
|
|
this.partition(horiz + 1, r2, c1, vert - 1);
|
|
this.partition(r1, horiz - 1, vert + 1, c2);
|
|
this.partition(horiz + 1, r2, vert + 1, c2);
|
|
}
|
|
|
|
private isGap(...cells: Array<[number, number]>): boolean {
|
|
return cells.every(([row, col]) => {
|
|
const cell = this.maze[row][col];
|
|
if (cell.length > 0) {
|
|
if (!cell.includes("door")) return false;
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
|
|
private countSteps(
|
|
array: (number | undefined)[][],
|
|
r: number,
|
|
c: number,
|
|
val: number,
|
|
stop: CellTag
|
|
): boolean {
|
|
if (!this.inBounds(r, c)) {
|
|
return false;
|
|
}
|
|
|
|
if (array[r][c] !== undefined && (array[r][c] as number) <= val) {
|
|
return false;
|
|
}
|
|
|
|
if (!this.isGap([r, c])) {
|
|
return false;
|
|
}
|
|
|
|
array[r][c] = val;
|
|
|
|
if (this.maze[r][c].includes(stop)) {
|
|
return true;
|
|
}
|
|
|
|
this.countSteps(array, r - 1, c, val + 1, stop);
|
|
this.countSteps(array, r, c + 1, val + 1, stop);
|
|
this.countSteps(array, r + 1, c, val + 1, stop);
|
|
this.countSteps(array, r, c - 1, val + 1, stop);
|
|
|
|
return false;
|
|
}
|
|
|
|
private getKeyLocation(): Coord {
|
|
const fromEntrance = this.initArray<number | undefined>();
|
|
const fromExit = this.initArray<number | undefined>();
|
|
|
|
this.totalSteps = -1;
|
|
|
|
for (let j = 1; j < this.cols - 1; j++) {
|
|
if (this.maze[this.rows - 1][j].includes("entrance")) {
|
|
this.countSteps(fromEntrance, this.rows - 1, j, 0, "exit");
|
|
}
|
|
if (this.maze[0][j].includes("exit")) {
|
|
this.countSteps(fromExit, 0, j, 0, "entrance");
|
|
}
|
|
}
|
|
|
|
let fc = -1,
|
|
fr = -1;
|
|
|
|
this.maze.forEach((_row, r) => {
|
|
_row.forEach((_cell, c) => {
|
|
if (typeof fromEntrance[r]?.[c] === "undefined") {
|
|
return;
|
|
}
|
|
const stepCount =
|
|
(fromEntrance[r][c] ?? Infinity) + (fromExit[r][c] ?? Infinity);
|
|
if (stepCount > this.totalSteps) {
|
|
fr = r;
|
|
fc = c;
|
|
this.totalSteps = stepCount;
|
|
}
|
|
});
|
|
});
|
|
|
|
return [fr, fc];
|
|
}
|
|
|
|
placeKey(): void {
|
|
const [fr, fc] = this.getKeyLocation();
|
|
this.maze[fr][fc] = ["key"];
|
|
}
|
|
|
|
shortestPath(
|
|
fromTag: PositionTag,
|
|
toTag: PositionTag,
|
|
currentPosition?: Coord
|
|
): Coord[] {
|
|
let start: Coord | undefined;
|
|
let end: Coord | undefined;
|
|
|
|
if (fromTag === "hero" && currentPosition) {
|
|
start = currentPosition;
|
|
} else {
|
|
for (let r = 0; r < this.rows; r++) {
|
|
for (let c = 0; c < this.cols; c++) {
|
|
if (this.maze[r][c].includes(fromTag)) start = [r, c];
|
|
}
|
|
}
|
|
}
|
|
|
|
for (let r = 0; r < this.rows; r++) {
|
|
for (let c = 0; c < this.cols; c++) {
|
|
if (this.maze[r][c].includes(toTag)) end = [r, c];
|
|
}
|
|
}
|
|
|
|
if (!start || !end) return [];
|
|
|
|
const visited = this.initArray<boolean>(false);
|
|
const prev = this.initArray<Coord | null>(null);
|
|
const queue: Coord[] = [[...start]];
|
|
visited[start[0]][start[1]] = true;
|
|
|
|
const dirs: Coord[] = [
|
|
[-1, 0],
|
|
[1, 0],
|
|
[0, -1],
|
|
[0, 1],
|
|
];
|
|
|
|
while (queue.length > 0) {
|
|
const [r, c] = queue.shift() as Coord;
|
|
|
|
if (r === end[0] && c === end[1]) {
|
|
const path: Coord[] = [];
|
|
let curr: Coord | null = end;
|
|
while (curr) {
|
|
path.unshift(curr);
|
|
curr = prev[curr[0]][curr[1]];
|
|
}
|
|
return path;
|
|
}
|
|
|
|
for (const [dr, dc] of dirs) {
|
|
const nr = r + dr,
|
|
nc = c + dc;
|
|
if (!this.inBounds(nr, nc)) continue;
|
|
if (visited[nr][nc]) continue;
|
|
if (this.maze[nr][nc].includes("wall")) continue;
|
|
|
|
visited[nr][nc] = true;
|
|
prev[nr][nc] = [r, c];
|
|
queue.push([nr, nc]);
|
|
}
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
shortestPathToKey(currentPosition?: Coord): Coord[] {
|
|
return this.shortestPath(
|
|
currentPosition ? "hero" : "entrance",
|
|
"key",
|
|
currentPosition
|
|
);
|
|
}
|
|
|
|
shortestPathToExit(currentPosition?: Coord): Coord[] {
|
|
return this.shortestPath(
|
|
currentPosition ? "hero" : "entrance",
|
|
"exit",
|
|
currentPosition
|
|
);
|
|
}
|
|
|
|
getDistance(
|
|
fromTag: PositionTag,
|
|
toTag: PositionTag,
|
|
currentPosition?: Coord
|
|
): number {
|
|
const path = this.shortestPath(fromTag, toTag, currentPosition);
|
|
return path.length ? path.length - 1 : Infinity;
|
|
}
|
|
|
|
getData(): MazeData {
|
|
return {
|
|
maze: this.maze,
|
|
width: this.width,
|
|
height: this.height,
|
|
cols: this.cols,
|
|
rows: this.rows,
|
|
totalSteps: this.totalSteps,
|
|
};
|
|
}
|
|
|
|
toJSON(): MazeData {
|
|
return this.getData();
|
|
}
|
|
}
|