78 lines
2.7 KiB
TypeScript
78 lines
2.7 KiB
TypeScript
import Phaser from "phaser";
|
|
import { Player } from "../entities/Player";
|
|
import { Exit } from "../entities/Exit";
|
|
import { Platform } from "../entities/Platform";
|
|
import { LevelMatrix, TILE_SIZE, TileType } from "./levels";
|
|
|
|
export interface LoadedLevel {
|
|
player: Player;
|
|
exit: Exit;
|
|
platforms: Platform[];
|
|
}
|
|
|
|
interface Cell {
|
|
row: number;
|
|
col: number;
|
|
}
|
|
|
|
export class LevelLoader {
|
|
constructor(private readonly scene: Phaser.Scene) {}
|
|
|
|
load(matrix: LevelMatrix): LoadedLevel {
|
|
const platforms = this.buildPlatforms(matrix);
|
|
const player = this.buildPlayer(matrix);
|
|
const exit = this.buildExit(matrix);
|
|
return { player, exit, platforms };
|
|
}
|
|
|
|
/**
|
|
* Merge contiguous Platform tiles in each row into a single rectangle to
|
|
* avoid corner-catching issues between adjacent 1-tile static bodies.
|
|
*/
|
|
private buildPlatforms(matrix: LevelMatrix): Platform[] {
|
|
const result: Platform[] = [];
|
|
for (let row = 0; row < matrix.length; row++) {
|
|
const cols = matrix[row].length;
|
|
let runStart = -1;
|
|
for (let col = 0; col <= cols; col++) {
|
|
const isPlatform = col < cols && matrix[row][col] === TileType.Platform;
|
|
if (isPlatform && runStart === -1) {
|
|
runStart = col;
|
|
} else if (!isPlatform && runStart !== -1) {
|
|
const width = (col - runStart) * TILE_SIZE;
|
|
const x = runStart * TILE_SIZE + width / 2;
|
|
const y = row * TILE_SIZE + TILE_SIZE / 2;
|
|
result.push(new Platform(this.scene, x, y, width, TILE_SIZE));
|
|
runStart = -1;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private buildPlayer(matrix: LevelMatrix): Player {
|
|
const cell = this.findTile(matrix, TileType.Player);
|
|
if (!cell) throw new Error("Level matrix has no Player tile");
|
|
const x = cell.col * TILE_SIZE + TILE_SIZE / 2;
|
|
const y = (cell.row + 1) * TILE_SIZE - Player.SIZE / 2;
|
|
return new Player(this.scene, x, y);
|
|
}
|
|
|
|
private buildExit(matrix: LevelMatrix): Exit {
|
|
const cell = this.findTile(matrix, TileType.Exit);
|
|
if (!cell) throw new Error("Level matrix has no Exit tile");
|
|
const x = cell.col * TILE_SIZE + TILE_SIZE / 2;
|
|
const y = (cell.row + 1) * TILE_SIZE - Exit.HEIGHT / 2;
|
|
return new Exit(this.scene, x, y);
|
|
}
|
|
|
|
private findTile(matrix: LevelMatrix, tile: TileType): Cell | null {
|
|
for (let row = 0; row < matrix.length; row++) {
|
|
for (let col = 0; col < matrix[row].length; col++) {
|
|
if (matrix[row][col] === tile) return { row, col };
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|