mr-crocs-adventures/js/retro/RetroArchitecture.js

import RetroSprite from "./RetroSprite.js";
import RetroArchitectureTile from "./RetroArchitectureTile.js";
import GeometryRectCollection from "../geometry/GeometryRectCollection.js";
import GeometryPoint from "../geometry/GeometryPoint.js";
import GeometryRect from "../geometry/GeometryRect.js";

export default class RetroArchitecture
{
    constructor(tilesetSprite, tiles, columns, rows)
    {
        this.tileset = tilesetSprite;
        this.tiles = tiles;
        this.rows = rows;
        this.columns = columns;
        this.matrix = [];
        this.tileWidth = this.tileset.getWidth() / this.tiles;
        this.tileHeight = this.tileset.getHeight();
        this.startX = 0;
        this.startY = 0;

        this.init();
    }

    init()
    {
        for (let y = 0; y < this.rows; y++) {
            let row = [];

            for (let x = 0; x < this.columns; x++) {
                row.push(null);
            }

            this.matrix.push(row);
        }
    }

    getCollisionRects(rect)
    {
        let posX = Math.floor(rect.position.x / this.tileWidth) - 2;
        let posY = Math.floor(rect.position.y / this.tileHeight) - 2;
        let rangeX = parseInt( posX + rect.width / this.tileWidth) + 4;
        let rangeY = parseInt(posY + rect.height / this.tileHeight) + 4;

        let collection = new GeometryRectCollection();

        for (let y = Math.max(0, posY); y < rangeY; y++) {
            for (let x = Math.max(0, posX); x < rangeX; x++) {
                if (y < this.matrix.length && x < this.matrix[y].length && this.matrix[y][x] !== null) {
                    let intersection = this.matrix[y][x].rect.getRectIntersection(rect);
                    if (intersection !== null) {
                        collection.addRect(intersection);
                    }
                }
            }
        }

        return collection;
    }

    hasRectCollision(rect)
    {
        let posX = Math.floor(rect.position.x / this.tileWidth) - 2;
        let posY = Math.floor(rect.position.y / this.tileHeight) - 2;
        let rangeX = parseInt( posX + rect.width / this.tileWidth) + 4;
        let rangeY = parseInt(posY + rect.height / this.tileHeight) + 4;

        for (let y = Math.max(0, posY); y < rangeY; y++) {
            for (let x = Math.max(0, posX); x < rangeX; x++) {
                if (this.matrix[y][x] !== null) {
                    if (this.matrix[y][x].rect.getRectIntersection(rect) !== null) {
                        return true;
                    }
                }
            }
        }

        return false;
    }

    getTileForPosition(position, offsetX = 0, offsetY = 0)
    {
        let x = parseInt(position.x / this.tileWidth) + offsetX;
        let y = parseInt(position.y / this.tileHeight) + offsetY;

        if (x < 0 || x >= this.columns || y < 0 || y >= this.rows) {
            return null;
        }

        return {x: x, y: y};
    }

    getCeilingHeight(position)
    {
        let tilePosition = this.getTileForPosition(position, 0);

        while (tilePosition !== null && tilePosition.y > 0) {
            if (this.matrix[tilePosition.y][tilePosition.x] !== null) {
                return tilePosition.y * this.tileHeight + this.tileHeight;
            }

            tilePosition.y--;
        }

        return 0;
    }

    getGroundHeight(position)
    {
        let tilePosition = this.getTileForPosition(position);

        while (tilePosition !== null && tilePosition.y < this.rows) {
            if (this.matrix[tilePosition.y][tilePosition.x] !== null) {
                return tilePosition.y * this.tileHeight;
            }

            tilePosition.y++;
        }

        return 9999999999;
    }

    getWallRight(position)
    {
        let tilePosition = this.getTileForPosition(new GeometryPoint(position.x, position.y), 1, 0);

        while (tilePosition !== null && tilePosition.x < this.columns) {
            if (this.matrix[tilePosition.y][tilePosition.x] !== null) {
                return tilePosition.x * this.tileWidth;
            }

            tilePosition.x++;
        }

        return this.tileWidth * this.columns;
    }

    getWallLeft(position)
    {
        let tilePosition = this.getTileForPosition(new GeometryPoint(position.x, position.y), -1,0);

        while (tilePosition !== null && tilePosition.x > 0) {
            if (this.matrix[tilePosition.y][tilePosition.x] !== null) {
                return tilePosition.x * this.tileWidth + this.tileWidth;
            }

            tilePosition.x--;
        }

        return 0;
    }

    isInsideArchitecture(geometryPoint)
    {
        let architectureRect = new GeometryRect(
            0, 0, this.tileWidth * this.columns, this.tileHeight * this.rows
        );

        return architectureRect.isContainingPoint(geometryPoint);
    }

    resetMovableToStartPosition(movable)
    {
        movable.position.x = this.tileWidth * this.startX + this.tileWidth * 0.5;
        movable.position.y = this.tileHeight * this.startY + this.tileHeight * 0.5;
    }

    draw(context, camera = null)
    {
        let viewX = parseInt(Math.floor(Math.max(0, camera.position.x) / this.tileWidth));
        let viewWidth = parseInt(Math.min(Math.ceil(camera.width), this.columns));
        let viewY = parseInt(Math.floor(Math.max(0, camera.position.y)) / this.tileHeight);
        let viewHeight = parseInt(Math.min(Math.ceil(camera.height), this.rows));

        for (let y = viewY; y < viewHeight; y++) {
            for (let x = viewX; x < viewWidth; x++) {
                let field = this.matrix[y][x];

                if (field !== null && field !== undefined) {
                    context.drawImage(
                        this.tileset.canvas,
                        field.tile * this.tileWidth,
                        0,
                        this.tileWidth,
                        this.tileHeight,
                        x * this.tileWidth - camera.position.x,
                        y * this.tileHeight - camera.position.y,
                        this.tileWidth,
                        this.tileHeight
                    );
                }
            }
        }
    }

    static createFromData(data)
    {
        let tileset = new RetroSprite(data.tileset, data.scale);

        let architecture = new RetroArchitecture(
            tileset,
            data.tiles,
            data.columns,
            data.rows
        );

        architecture.startX = data.startX;
        architecture.startY = data.startY;

        for (let y = 0; y < data.rows; y++) {
            for (let x = 0; x < data.columns; x++) {
                if (data.matrix[y][x] > -1) {
                    architecture.matrix[y][x] = new RetroArchitectureTile(
                        data.matrix[y][x],
                        x * architecture.tileWidth,
                        y * architecture.tileHeight,
                        architecture.tileWidth,
                        architecture.tileHeight
                    )
                }
            }
        }

        return architecture;
    }
}