435 lines
10 KiB
JavaScript
435 lines
10 KiB
JavaScript
class Cell {
|
|
character;
|
|
characterColor;
|
|
backgroundColor;
|
|
|
|
constructor(char, charColor) {
|
|
this.character = char;
|
|
}
|
|
|
|
floor() { this.character = "."; }
|
|
upStair() { this.character = "<"; }
|
|
downStair() { this.character = ">"; }
|
|
cooridor() { this.character = "#"; }
|
|
topLeftWall() { this.character = "┌"; }
|
|
topRightWall() { this.character = "┐"; }
|
|
bottomLeftWall() { this.character = "└"; }
|
|
bottomRightWall() { this.character = "┘"; }
|
|
horizontalWall() { this.character = "─"; }
|
|
verticalWall() { this.character = "│"; }
|
|
}
|
|
|
|
class Point {
|
|
x = 0;
|
|
y = 0;
|
|
|
|
constructor(x, y) {
|
|
this.x = x;
|
|
this.y = y;
|
|
}
|
|
}
|
|
|
|
class Size {
|
|
width = 0;
|
|
height = 0;
|
|
|
|
constructor(width, height) {
|
|
this.width = width;
|
|
this.height = height;
|
|
}
|
|
}
|
|
|
|
class Rect {
|
|
origin = new Point();
|
|
size = new Size();
|
|
|
|
static fromCoordinates(x, y, w, h) {
|
|
return new Rect(new Point(x, y), new Size(w, h));
|
|
}
|
|
|
|
constructor(origin, size) {
|
|
this.origin = origin;
|
|
this.size = size;
|
|
}
|
|
|
|
get minX() { return this.origin.x; }
|
|
get minY() { return this.origin.y; }
|
|
get maxX() { return this.origin.x + this.size.width; }
|
|
get maxY() { return this.origin.y + this.size.height; }
|
|
get area() { return this.size.width * this.size.height; }
|
|
|
|
insetRect(inset) {
|
|
const twiceInset = 2 * inset;
|
|
|
|
return Rect.fromCoordinates(
|
|
this.origin.x + inset,
|
|
this.origin.y + inset,
|
|
this.size.width - twiceInset,
|
|
this.size.height - twiceInset
|
|
);
|
|
}
|
|
|
|
intersects(otherRect) {
|
|
if (otherRect.minX > this.maxX)
|
|
return false;
|
|
|
|
if (otherRect.maxX < this.minX)
|
|
return false;
|
|
|
|
if (otherRect.minY > this.maxY)
|
|
return false;
|
|
|
|
if (otherRect.maxY < this.minY)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
class Grid {
|
|
#size;
|
|
#cells = [];
|
|
|
|
#rooms = [];
|
|
|
|
constructor(width, height) {
|
|
this.#size = new Size(width, height);
|
|
|
|
this.#cells = new Array(width * height);
|
|
for (let i = 0; i < this.#cells.length; i++) {
|
|
this.#cells[i] = new Cell(" ");
|
|
}
|
|
}
|
|
|
|
get width() {
|
|
return this.#size.width;
|
|
}
|
|
|
|
get height() {
|
|
return this.#size.height;
|
|
}
|
|
|
|
generate(p, roomGenerator) {
|
|
this.#generateRooms(p, roomGenerator);
|
|
this.#placeStairs();
|
|
}
|
|
|
|
#generateRooms(p, generator) {
|
|
this.#rooms = generator.rooms;
|
|
|
|
for (let room of this.#rooms) {
|
|
for (let y = room.minY; y <= room.maxY; y++) {
|
|
for (let x = room.minX; x <= room.maxX; x++) {
|
|
let point = new Point(x, y);
|
|
let cell = this.cellAt(x, y);
|
|
room.transformCellAt(point, cell);
|
|
cell.characterColor = p.color(255);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#placeStairs() {
|
|
const indexOfRoomWithUpStairs = randomInt(this.#rooms.length);
|
|
const coordinateOfUpStair = this.#rooms[indexOfRoomWithUpStairs].randomPoint();
|
|
this.cellAt(coordinateOfUpStair.x, coordinateOfUpStair.y).upStair();
|
|
|
|
while (true) {
|
|
let indexOfRoomForDownStair = randomInt(this.#rooms.length);
|
|
if (indexOfRoomForDownStair == indexOfRoomWithUpStairs) {
|
|
continue;
|
|
}
|
|
|
|
const coordinateOfDownStair = this.#rooms[indexOfRoomForDownStair].randomPoint();
|
|
this.cellAt(coordinateOfDownStair.x, coordinateOfDownStair.y).downStair();
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
cellAt(x, y) {
|
|
return this.#cells[y * this.width + x];
|
|
}
|
|
}
|
|
|
|
class Room {
|
|
#rect;
|
|
|
|
constructor(rect) {
|
|
this.#rect = rect;
|
|
}
|
|
|
|
get minX() { return this.#rect.minX; }
|
|
get minY() { return this.#rect.minY; }
|
|
get maxX() { return this.#rect.maxX; }
|
|
get maxY() { return this.#rect.maxY; }
|
|
|
|
randomPoint() {
|
|
return new Point(
|
|
this.#rect.minX + 1 + randomInt(this.#rect.size.width - 2),
|
|
this.#rect.minY + 1 + randomInt(this.#rect.size.height - 2)
|
|
);
|
|
}
|
|
|
|
transformCellAt(pt, cell) {
|
|
const minX = this.minX;
|
|
const minY = this.minY;
|
|
const maxX = this.maxX;
|
|
const maxY = this.maxY;
|
|
|
|
const x = pt.x;
|
|
const y = pt.y;
|
|
|
|
if (y === minY && x === minX) { cell.topLeftWall(); }
|
|
else if (y === minY && x === maxX) { cell.topRightWall(); }
|
|
else if (y === maxY && x === minX) { cell.bottomLeftWall(); }
|
|
else if (y === maxY && x === maxX) { cell.bottomRightWall(); }
|
|
else if (y === minY || y === maxY) { cell.horizontalWall(); }
|
|
else if (x === minX || x === maxX) { cell.verticalWall(); }
|
|
else if ((x > minX && x < maxX) && (y > minY && y < maxY)) { return cell.floor(); }
|
|
}
|
|
}
|
|
|
|
class BSPNode {
|
|
static MIN_AREA = 36;
|
|
static MIN_ROOM_DIMENSION = 5;
|
|
|
|
x;
|
|
y;
|
|
width;
|
|
height;
|
|
leftChild;
|
|
rightChild;
|
|
room;
|
|
#done = false;
|
|
|
|
constructor(x, y, w, h) {
|
|
this.x = x;
|
|
this.y = y;
|
|
this.width = w;
|
|
this.height = h;
|
|
|
|
this.leftChild;
|
|
this.rightChild;
|
|
this.room;
|
|
}
|
|
|
|
get maxX() {
|
|
return this.x + this.width;
|
|
}
|
|
|
|
get maxY() {
|
|
return this.y + this.height;
|
|
}
|
|
|
|
get rooms() {
|
|
let rooms = new Array();
|
|
|
|
if (this.room) {
|
|
rooms.push(this.room);
|
|
return rooms;
|
|
}
|
|
|
|
if (this.leftChild) {
|
|
rooms = rooms.concat(this.leftChild.rooms);
|
|
}
|
|
|
|
if (this.rightChild) {
|
|
rooms = rooms.concat(this.rightChild.rooms);
|
|
}
|
|
|
|
return rooms;
|
|
}
|
|
|
|
divide() {
|
|
if (this.#done) {
|
|
return;
|
|
}
|
|
|
|
const area = this.width * this.height;
|
|
if (area < BSPNode.MIN_AREA) {
|
|
if (!this.#done && Math.random() > 0.8) {
|
|
this.#createRoom();
|
|
}
|
|
this.#done = true;
|
|
return;
|
|
}
|
|
|
|
if (area < 100 && Math.random() > 0.9) {
|
|
this.#createRoom();
|
|
this.#done = true;
|
|
return;
|
|
}
|
|
|
|
let shouldSplitVertically = Math.random() < 0.5;
|
|
console.debug("Should split vertically:", shouldSplitVertically);
|
|
|
|
if (shouldSplitVertically) {
|
|
let xCoordinateOfDivision = this.#randomIntBetween(this.x, this.maxX);
|
|
if (xCoordinateOfDivision) {
|
|
this.leftChild = new BSPNode(this.x, this.y, xCoordinateOfDivision - this.x, this.height);
|
|
this.rightChild = new BSPNode(xCoordinateOfDivision, this.y, this.maxX - xCoordinateOfDivision, this.height);
|
|
}
|
|
} else {
|
|
let yCoordinateOfDivision = this.#randomIntBetween(this.y, this.maxY);
|
|
if (yCoordinateOfDivision) {
|
|
this.leftChild = new BSPNode(this.x, this.y, this.width, yCoordinateOfDivision - this.y);
|
|
this.rightChild = new BSPNode(this.x, yCoordinateOfDivision, this.width, this.maxY - yCoordinateOfDivision);
|
|
}
|
|
}
|
|
|
|
if (!this.leftChild && !this.rightChild) {
|
|
if (!this.#done && Math.random() > 0.5) {
|
|
this.#createRoom();
|
|
}
|
|
this.#done = true;
|
|
}
|
|
}
|
|
|
|
divideRecursively() {
|
|
this.divide();
|
|
|
|
if (this.room) {
|
|
return;
|
|
}
|
|
|
|
if (this.leftChild) {
|
|
this.leftChild.divideRecursively();
|
|
}
|
|
if (this.rightChild) {
|
|
this.rightChild.divideRecursively();
|
|
}
|
|
}
|
|
|
|
#createRoom() {
|
|
this.room = new Room(this.x + 1, this.y + 1, this.width - 2, this.height - 2);
|
|
console.log("Created a room:", this.room);
|
|
}
|
|
|
|
#randomIntBetween(lower, upper) {
|
|
const randomMin = lower + BSPNode.MIN_ROOM_DIMENSION;
|
|
const randomMax = upper - BSPNode.MIN_ROOM_DIMENSION;
|
|
|
|
console.debug(`Random int between: ${lower} -> ${randomMin} and ${upper} -> ${randomMax}`);
|
|
|
|
const result = randomMax > randomMin ? randomMin + Math.floor(Math.random() * (randomMax - randomMin + 1)) : null;
|
|
console.debug("Result:", result);
|
|
|
|
return result;
|
|
}
|
|
}
|
|
|
|
class NRandomRoomsGenerator {
|
|
static MIN_ROOM_DIMENSION = 7;
|
|
static MAX_ROOM_DIMENSION = 12;
|
|
|
|
#numberOfRooms = 12;
|
|
#rooms;
|
|
|
|
#bounds;
|
|
|
|
constructor(bounds, numberOfRooms) {
|
|
if (bounds) {
|
|
this.#bounds = bounds;
|
|
}
|
|
|
|
if (numberOfRooms) {
|
|
this.#numberOfRooms = numberOfRooms;
|
|
}
|
|
}
|
|
|
|
get numberOfRooms() {
|
|
return this.#numberOfRooms;
|
|
}
|
|
|
|
get rooms() {
|
|
if (!this.#rooms) {
|
|
this.#generateRooms();
|
|
}
|
|
|
|
return this.#rooms;
|
|
}
|
|
|
|
#generateRooms() {
|
|
let rects = new Array();
|
|
|
|
const sizeRange = NRandomRoomsGenerator.MAX_ROOM_DIMENSION - NRandomRoomsGenerator.MIN_ROOM_DIMENSION;
|
|
|
|
while (rects.length < this.#numberOfRooms) {
|
|
const randomSize = new Size(
|
|
NRandomRoomsGenerator.MIN_ROOM_DIMENSION + randomInt(sizeRange),
|
|
NRandomRoomsGenerator.MIN_ROOM_DIMENSION + randomInt(sizeRange)
|
|
);
|
|
|
|
const randomOrigin = new Point(
|
|
this.#bounds.minX + randomInt(this.#bounds.maxX - randomSize.width),
|
|
this.#bounds.minY + randomInt(this.#bounds.maxY - randomSize.height)
|
|
);
|
|
|
|
const proposedRoomRect = new Rect(randomOrigin, randomSize);
|
|
|
|
// Check that the rect doesn't intersect with any other rects.
|
|
if (rects.some(e => e.intersects(proposedRoomRect))) {
|
|
continue;
|
|
}
|
|
|
|
rects.push(proposedRoomRect);
|
|
}
|
|
|
|
this.#rooms = rects.map(r => new Room(r.insetRect(1)));
|
|
}
|
|
}
|
|
|
|
function randomInt(n) {
|
|
max = Math.floor(n);
|
|
return Math.floor(Math.random() * max);
|
|
}
|
|
|
|
let grid;
|
|
|
|
new p5(p => {
|
|
const CELL_WIDTH = 20;
|
|
const CELL_HEIGHT = Math.floor(CELL_WIDTH * 1.3);
|
|
|
|
p.setup = () => {
|
|
const container = document.querySelector('#dungeon-background');
|
|
canvasWidth = parseFloat(getComputedStyle(container).width);
|
|
canvasHeight = parseFloat(getComputedStyle(container).height);
|
|
|
|
let canvas = p.createCanvas(canvasWidth, canvasHeight);
|
|
canvas.canvas.removeAttribute('style');
|
|
container.appendChild(canvas.canvas);
|
|
|
|
p.pixelDensity(p.displayDensity());
|
|
p.textFont("Courier");
|
|
|
|
const gridBounds = Rect.fromCoordinates(
|
|
0, 0,
|
|
Math.ceil(canvasWidth / CELL_WIDTH) - 1, Math.ceil(canvasHeight / CELL_HEIGHT) - 1
|
|
);
|
|
|
|
console.log(`Generating grid with size ${gridBounds.size.width} x ${gridBounds.size.height}`);
|
|
|
|
grid = new Grid(gridBounds.size.width, gridBounds.size.height);
|
|
grid.generate(p, new NRandomRoomsGenerator(gridBounds));
|
|
}
|
|
|
|
p.draw = () => {
|
|
p.textSize(CELL_HEIGHT);
|
|
|
|
for (let y = 0; y < grid.height; y++) {
|
|
for (let x = 0; x < grid.width; x++) {
|
|
let cell = grid.cellAt(x, y);
|
|
|
|
let fillColor = cell.characterColor ? cell.characterColor : p.color(255);
|
|
p.fill(fillColor);
|
|
|
|
p.textAlign(p.CENTER, p.CENTER);
|
|
p.text(cell.character, x * CELL_WIDTH, y * CELL_HEIGHT, CELL_WIDTH, CELL_HEIGHT);
|
|
}
|
|
}
|
|
|
|
p.noLoop();
|
|
};
|
|
|
|
}, '#dungeon-background');
|