@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/objects/room/parts/TileCursor.js

@@ -0,0 +1,193 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TileCursor = void 0;
+const PIXI = __importStar(require("pixi.js"));
+const rxjs_1 = require("rxjs");
+const isPointInside_1 = require("../../../util/isPointInside");
+const IEventGroup_1 = require("../../events/interfaces/IEventGroup");
+class TileCursor extends PIXI.Container {
+    constructor(_eventManager, _roomPosition, onClick, onOver, onOut) {
+        super();
+        this._eventManager = _eventManager;
+        this._roomPosition = _roomPosition;
+        this.onClick = onClick;
+        this.onOver = onOver;
+        this.onOut = onOut;
+        this._hover = false;
+        this._isTileCursorDestroyed = false;
+        this._subject = new rxjs_1.BehaviorSubject(undefined);
+        this._emitRectangle = () => {
+            var _a, _b;
+            let x = this.worldTransform.tx;
+            let y = this.worldTransform.ty;
+            let width = 64;
+            let height = 32;
+            const m = (_b = (_a = this._eventManager).getCoordinateRootMatrix) === null || _b === void 0 ? void 0 : _b.call(_a);
+            if (m != null) {
+                x = (x - m.tx) / m.a;
+                y = (y - m.ty) / m.d;
+            }
+            const last = this._lastRect;
+            if (last != null && last.x === x && last.y === y)
+                return;
+            this._lastRect = { x, y, width, height };
+            this._subject.next(this._lastRect);
+        };
+        this._roomX = _roomPosition.roomX;
+        this._roomY = _roomPosition.roomY;
+        this._roomZ = _roomPosition.roomZ;
+        this._graphics = this._createGraphics();
+        this._updateGraphics();
+        this.addChild(this._graphics);
+        this.onRender = this._emitRectangle;
+        this._eventManager.register(this);
+    }
+    getEventGroupIdentifier() {
+        return IEventGroup_1.TILE_CURSOR;
+    }
+    getGroup() {
+        return this;
+    }
+    getRectangleObservable() {
+        return this._subject;
+    }
+    getEventZOrder() {
+        return -1000;
+    }
+    triggerPointerTargetChanged(event) { }
+    triggerClick(event) {
+        this.onClick({
+            roomX: this._roomX,
+            roomY: this._roomY,
+            roomZ: this._roomZ,
+        }, event);
+    }
+    triggerPointerDown(event) { }
+    triggerPointerUp(event) { }
+    triggerPointerOver(event) {
+        if (this._isTileCursorDestroyed)
+            return;
+        this._updateHover(true);
+        this.onOver({ roomX: this._roomX, roomY: this._roomY, roomZ: this._roomZ });
+    }
+    triggerPointerOut(event) {
+        if (this._isTileCursorDestroyed)
+            return;
+        this._updateHover(false);
+        this.onOut({ roomX: this._roomX, roomY: this._roomY, roomZ: this._roomZ });
+    }
+    createDebugSprite() {
+        return undefined;
+    }
+    hits(x, y) {
+        const pos = this.getGlobalPosition();
+        const transform = this.worldTransform;
+        const scaleX = Math.sqrt(transform.a * transform.a + transform.b * transform.b) || 1;
+        const scaleY = Math.sqrt(transform.c * transform.c + transform.d * transform.d) || 1;
+        const diffX = (x - pos.x) / scaleX;
+        const diffY = (y - pos.y) / scaleY;
+        return this._pointInside([diffX, diffY], [
+            [points.p1.x, points.p1.y],
+            [points.p2.x, points.p2.y],
+            [points.p3.x, points.p3.y],
+            [points.p4.x, points.p4.y],
+        ]);
+    }
+    getHitDetectionZIndex() {
+        return -1000;
+    }
+    destroy() {
+        this._isTileCursorDestroyed = true;
+        this._eventManager.remove(this);
+        this._graphics.destroy();
+        super.destroy();
+    }
+    _createGraphics() {
+        const graphics = new PIXI.Graphics();
+        return graphics;
+    }
+    _updateGraphics() {
+        if (this._isTileCursorDestroyed)
+            return;
+        const graphics = this._graphics;
+        if (graphics == null)
+            return;
+        graphics.clear();
+        if (this._hover) {
+            drawBorder(graphics, 0x000000, 0.33, 0);
+            drawBorder(graphics, 0xa7d1e0, 1, -2);
+            drawBorder(graphics, 0xffffff, 1, -3);
+        }
+    }
+    _updateHover(hover) {
+        if (this._hover === hover)
+            return;
+        this._hover = hover;
+        this._updateGraphics();
+        if (hover) {
+            this.onOver(this._roomPosition);
+        }
+        else {
+            this.onOut(this._roomPosition);
+        }
+    }
+    _pointInside(point, vs) {
+        return (0, isPointInside_1.isPointInside)(point, vs);
+    }
+}
+exports.TileCursor = TileCursor;
+const points = {
+    p1: { x: 0, y: 16 },
+    p2: { x: 32, y: 0 },
+    p3: { x: 64, y: 16 },
+    p4: { x: 32, y: 32 },
+};
+function drawBorder(graphics, color, alpha = 1, offsetY) {
+    graphics
+        .moveTo(points.p1.x, points.p1.y + offsetY)
+        .lineTo(points.p2.x, points.p2.y + offsetY)
+        .lineTo(points.p3.x, points.p3.y + offsetY)
+        .lineTo(points.p4.x, points.p4.y + offsetY)
+        .closePath()
+        .fill({ color, alpha });
+    graphics
+        .moveTo(points.p1.x + 6, points.p1.y + offsetY)
+        .lineTo(points.p2.x, points.p2.y + 3 + offsetY)
+        .lineTo(points.p3.x - 6, points.p3.y + offsetY)
+        .lineTo(points.p4.x, points.p4.y - 3 + offsetY)
+        .closePath()
+        .cut();
+}

package/dist/objects/room/parts/WallLeft.d.ts

@@ -0,0 +1,47 @@
+import * as PIXI from "pixi.js";
+import { IRoomPart } from "./IRoomPart";
+import { RoomPartData } from "./RoomPartData";
+export declare class WallLeft extends PIXI.Container implements IRoomPart {
+    private props;
+    protected _offsets: {
+        x: number;
+        y: number;
+    };
+    protected _borderWidth: number;
+    protected _wallHeight: number;
+    protected _wallWidth: number;
+    protected _tileHeight: number;
+    protected _wallLeftColor: number;
+    protected _wallRightColor: number;
+    protected _wallTopColor: number;
+    protected _wallTexture: PIXI.Texture | undefined;
+    private _drawHitArea;
+    private _hideBorder;
+    private _roomZ;
+    private _hitAreaElement;
+    constructor(props: WallProps);
+    get roomZ(): number;
+    /** Height of the wall in pixels, measured from the tile's floor line up. */
+    get pixelHeight(): number;
+    set roomZ(value: number);
+    private get wallY();
+    private get wallHeight();
+    update(data: RoomPartData): void;
+    destroy(): void;
+    protected _update(): void;
+    private _getDisplayPoints;
+    private _getOffsetX;
+    private _createPrimarySprite;
+    private _createBorderSprite;
+    private _createTopSprite;
+}
+export interface WallProps {
+    hideBorder: boolean;
+    hitAreaContainer: PIXI.Container;
+    onMouseMove: (event: {
+        offsetX: number;
+        offsetY: number;
+    }) => void;
+    onMouseOut: () => void;
+    cutawayHeight?: number;
+}

package/dist/objects/room/parts/WallLeft.js

@@ -0,0 +1,179 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WallLeft = void 0;
+const PIXI = __importStar(require("pixi.js"));
+class WallLeft extends PIXI.Container {
+    constructor(props) {
+        super();
+        this.props = props;
+        this._offsets = { x: 0, y: 0 };
+        this._borderWidth = 0;
+        this._wallHeight = 0;
+        this._wallWidth = 32;
+        this._tileHeight = 0;
+        this._wallLeftColor = 0;
+        this._wallRightColor = 0;
+        this._wallTopColor = 0;
+        this._drawHitArea = false;
+        this._hideBorder = false;
+        this._roomZ = 0;
+        this._hideBorder = props.hideBorder;
+        //this._update();
+    }
+    get roomZ() {
+        return this._roomZ;
+    }
+    /** Height of the wall in pixels, measured from the tile's floor line up. */
+    get pixelHeight() {
+        return this._wallHeight;
+    }
+    set roomZ(value) {
+        this._roomZ = value;
+        this._update();
+    }
+    get wallY() {
+        return -this._wallHeight;
+    }
+    get wallHeight() {
+        if (this.props.cutawayHeight != null) {
+            return this._wallHeight - this.props.cutawayHeight;
+        }
+        return this._wallHeight;
+    }
+    update(data) {
+        this._borderWidth = data.borderWidth;
+        this._wallHeight = data.wallHeight - this.roomZ * 32;
+        this._tileHeight = data.tileHeight;
+        this._wallLeftColor = data.wallLeftColor;
+        this._wallRightColor = data.wallRightColor;
+        this._wallTopColor = data.wallTopColor;
+        this._wallTexture = data.wallTexture;
+        this._update();
+    }
+    destroy() {
+        var _a;
+        super.destroy();
+        (_a = this._hitAreaElement) === null || _a === void 0 ? void 0 : _a.destroy();
+        this.removeChildren();
+    }
+    _update() {
+        if (this._hitAreaElement != null) {
+            this.props.hitAreaContainer.removeChild(this._hitAreaElement);
+            this._hitAreaElement = undefined;
+        }
+        this.removeChildren();
+        const hitArea = new PIXI.Polygon(this._getDisplayPoints());
+        this.hitArea = hitArea;
+        const primary = this._createPrimarySprite();
+        const border = this._createBorderSprite();
+        const top = this._createTopSprite();
+        this.addChild(primary);
+        if (!this._hideBorder) {
+            this.addChild(border);
+        }
+        this.addChild(top);
+        const graphics = new PIXI.Graphics();
+        graphics.poly(this._getDisplayPoints()).fill(0xff00ff);
+        graphics.alpha = this._drawHitArea ? 1 : 0;
+        const handleMoveEvent = (event) => {
+            if (event.target === graphics) {
+                const position = event.getLocalPosition(graphics);
+                this.props.onMouseMove({ offsetX: position.x, offsetY: position.y });
+            }
+        };
+        graphics.on("pointermove", handleMoveEvent);
+        graphics.on("pointerover", handleMoveEvent);
+        graphics.on("pointerout", () => {
+            this.props.onMouseOut();
+        });
+        graphics.eventMode = "static";
+        this._hitAreaElement = graphics;
+        this._hitAreaElement.x = this.x;
+        this._hitAreaElement.y = this.y;
+        this._hitAreaElement.scale.copyFrom(this.scale);
+        this.props.hitAreaContainer.addChild(this._hitAreaElement);
+    }
+    _getDisplayPoints() {
+        var _a, _b;
+        return [
+            new PIXI.Point(this._getOffsetX() + this._borderWidth, this._wallWidth / 2 - ((_a = this.props.cutawayHeight) !== null && _a !== void 0 ? _a : 0)),
+            new PIXI.Point(this._getOffsetX() + this._wallWidth + this._borderWidth, -((_b = this.props.cutawayHeight) !== null && _b !== void 0 ? _b : 0)),
+            new PIXI.Point(this._getOffsetX() + this._wallWidth + this._borderWidth, -this._wallHeight),
+            new PIXI.Point(this._getOffsetX() + this._borderWidth, -this._wallHeight + this._wallWidth / 2),
+        ];
+    }
+    _getOffsetX() {
+        return this.scale.x * this._offsets.x - this._borderWidth;
+    }
+    _createPrimarySprite() {
+        var _a;
+        const sprite = new PIXI.TilingSprite({
+            texture: (_a = this._wallTexture) !== null && _a !== void 0 ? _a : PIXI.Texture.WHITE,
+            width: this._wallWidth,
+            height: this.wallHeight,
+        });
+        sprite.setFromMatrix(new PIXI.Matrix(-1, 0.5, 0, 1));
+        sprite.x = this._getOffsetX() + this._borderWidth + this._wallWidth;
+        sprite.y = this.wallY;
+        sprite.tint = this._wallLeftColor;
+        return sprite;
+    }
+    _createBorderSprite() {
+        const border = new PIXI.TilingSprite({
+            texture: PIXI.Texture.WHITE,
+            width: this._borderWidth,
+            height: this._wallHeight + this._tileHeight,
+        });
+        border.setFromMatrix(new PIXI.Matrix(-1, -0.5, 0, 1));
+        border.y = this.wallY + this._wallWidth / 2;
+        border.x = this._getOffsetX() + this._borderWidth;
+        border.tint = this._wallRightColor;
+        return border;
+    }
+    _createTopSprite() {
+        const border = new PIXI.TilingSprite({
+            texture: PIXI.Texture.WHITE,
+            width: this._borderWidth,
+            height: this._wallWidth,
+        });
+        border.setFromMatrix(new PIXI.Matrix(1, 0.5, 1, -0.5));
+        border.x = this._getOffsetX() + 0;
+        border.y = this.wallY + this._wallWidth / 2 - this._borderWidth / 2;
+        border.tint = this._wallTopColor;
+        return border;
+    }
+}
+exports.WallLeft = WallLeft;

package/dist/objects/room/parts/WallOuterCorner.d.ts

@@ -0,0 +1,16 @@
+import * as PIXI from "pixi.js";
+import { IRoomPart } from "./IRoomPart";
+import { RoomPartData } from "./RoomPartData";
+export declare class WallOuterCorner extends PIXI.Container implements IRoomPart {
+    private _borderWidth;
+    private _wallHeight;
+    private _roomZ;
+    private _wallTopColor;
+    constructor();
+    get roomZ(): number;
+    set roomZ(value: number);
+    get wallY(): number;
+    update(data: RoomPartData): void;
+    private _createTopSprite;
+    private _update;
+}

package/dist/objects/room/parts/WallOuterCorner.js

@@ -0,0 +1,84 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WallOuterCorner = void 0;
+const PIXI = __importStar(require("pixi.js"));
+class WallOuterCorner extends PIXI.Container {
+    constructor() {
+        super();
+        this._borderWidth = 0;
+        this._wallHeight = 0;
+        this._roomZ = 0;
+        this._wallTopColor = 0;
+    }
+    get roomZ() {
+        return this._roomZ;
+    }
+    set roomZ(value) {
+        this._roomZ = value;
+        this._update();
+    }
+    get wallY() {
+        return -this._wallHeight;
+    }
+    update(data) {
+        this._borderWidth = data.borderWidth;
+        this._wallHeight = data.wallHeight;
+        this._wallTopColor = data.wallTopColor;
+        this._update();
+    }
+    _createTopSprite() {
+        const border = new PIXI.TilingSprite({
+            texture: PIXI.Texture.WHITE,
+            width: this._borderWidth,
+            height: this._borderWidth,
+        });
+        border.setFromMatrix(new PIXI.Matrix(1, 0.5, 1, -0.5));
+        border.tint = this._wallTopColor;
+        border.x = -this._borderWidth;
+        border.y =
+            -this._wallHeight +
+                this.roomZ * 32 -
+                32 / 2 +
+                this._borderWidth / 2 +
+                (32 - this._borderWidth);
+        return border;
+    }
+    _update() {
+        this.removeChildren();
+        this.addChild(this._createTopSprite());
+    }
+}
+exports.WallOuterCorner = WallOuterCorner;

package/dist/objects/room/parts/WallRight.d.ts

@@ -0,0 +1,5 @@
+import { WallLeft, WallProps } from "./WallLeft";
+export declare class WallRight extends WallLeft {
+    constructor(props: WallProps);
+    _update(): void;
+}

package/dist/objects/room/parts/WallRight.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WallRight = void 0;
+const WallLeft_1 = require("./WallLeft");
+class WallRight extends WallLeft_1.WallLeft {
+    constructor(props) {
+        super(props);
+    }
+    _update() {
+        this._offsets = { x: this._wallWidth, y: 0 };
+        this.scale.x = -1;
+        const left = this._wallLeftColor;
+        this._wallLeftColor = this._wallRightColor;
+        this._wallRightColor = left;
+        super._update();
+    }
+}
+exports.WallRight = WallRight;

package/dist/objects/room/util/LegacyWallGeometry.d.ts

@@ -0,0 +1,33 @@
+import { ParsedTileType } from "../../../util/parseTileMap";
+export declare class LegacyWallGeometry {
+    private _heightmap;
+    private static readonly RIGHT_WALL;
+    private static readonly LEFT_WALL;
+    /** Habbo caps how much taller than the floor a wall may grow. */
+    static readonly MAX_WALL_ADDITIONAL_HEIGHT = 20;
+    /** Habbo's default wall height, in tiles. */
+    static readonly WALL_HEIGHT = 3.6;
+    private _width;
+    private _height;
+    private _scale;
+    private _wallTop;
+    constructor(_heightmap: ParsedTileType[][]);
+    getLocation(roomX: number, roomY: number, offsetX: number, offsetY: number, wall: string): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Inverse of `getLocation`, ported from nitro's `getOldLocation`. */
+    getSpot(x: number, y: number, z: number, wall: string): {
+        roomX: number;
+        roomY: number;
+        offsetX: number;
+        offsetY: number;
+    };
+    /**
+     * Height of the tile a wall item hangs on. Anywhere there is no floor — a wall
+     * or a gap in the model — Habbo answers with the height of the wall top, not
+     * zero, and wall item offsets are measured against that.
+     */
+    getHeight(x: number, y: number): number;
+}

package/dist/objects/room/util/LegacyWallGeometry.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyWallGeometry = void 0;
+class LegacyWallGeometry {
+    constructor(_heightmap) {
+        this._heightmap = _heightmap;
+        this._width = _heightmap[0].length;
+        this._height = _heightmap.length;
+        this._scale = 64;
+        this._wallTop = getWallTop(_heightmap);
+    }
+    getLocation(roomX, roomY, offsetX, offsetY, wall) {
+        let rX = roomX;
+        let rY = roomY;
+        let rZ = this.getHeight(roomX, roomY);
+        if (wall == LegacyWallGeometry.LEFT_WALL) {
+            rX = rX + (offsetX / (this._scale / 2) - 0.5);
+            rY = rY + 0.5;
+            rZ = rZ - (offsetY - offsetX / 2) / (this._scale / 2);
+        }
+        else {
+            rY = rY + ((this._scale / 2 - offsetX) / (this._scale / 2) - 0.5);
+            rX = rX + 0.5;
+            rZ = rZ - (offsetY - (this._scale / 2 - offsetX) / 2) / (this._scale / 2);
+        }
+        return {
+            x: rX,
+            y: rY,
+            z: rZ,
+        };
+    }
+    /** Inverse of `getLocation`, ported from nitro's `getOldLocation`. */
+    getSpot(x, y, z, wall) {
+        const half = this._scale / 2;
+        if (wall == LegacyWallGeometry.RIGHT_WALL) {
+            const roomX = Math.floor(x - 0.5);
+            const roomY = Math.floor(y + 0.5);
+            const offsetX = half - (y - roomY + 0.5) * half;
+            const offsetY = (this.getHeight(roomX, roomY) - z) * half + (half - offsetX) / 2;
+            return { roomX, roomY, offsetX, offsetY };
+        }
+        const roomX = Math.floor(x + 0.5);
+        const roomY = Math.floor(y - 0.5);
+        const offsetX = (x + 0.5 - roomX) * half;
+        const offsetY = (this.getHeight(roomX, roomY) - z) * half + offsetX / 2;
+        return { roomX, roomY, offsetX, offsetY };
+    }
+    /**
+     * Height of the tile a wall item hangs on. Anywhere there is no floor — a wall
+     * or a gap in the model — Habbo answers with the height of the wall top, not
+     * zero, and wall item offsets are measured against that.
+     */
+    getHeight(x, y) {
+        if (x < 0 || x >= this._width || y < 0 || y >= this._height)
+            return this._wallTop;
+        const row = this._heightmap[y];
+        if (row == null)
+            return this._wallTop;
+        const cell = row[x];
+        if (cell == null)
+            return this._wallTop;
+        switch (cell.type) {
+            case "stairs":
+            case "stairCorner":
+            case "door":
+            case "tile":
+                return cell.z;
+        }
+        return this._wallTop;
+    }
+}
+exports.LegacyWallGeometry = LegacyWallGeometry;
+LegacyWallGeometry.RIGHT_WALL = "l";
+LegacyWallGeometry.LEFT_WALL = "r";
+/** Habbo caps how much taller than the floor a wall may grow. */
+LegacyWallGeometry.MAX_WALL_ADDITIONAL_HEIGHT = 20;
+/** Habbo's default wall height, in tiles. */
+LegacyWallGeometry.WALL_HEIGHT = 3.6;
+function getWallTop(heightmap) {
+    let highest = 0;
+    heightmap.forEach((row) => row.forEach((cell) => {
+        switch (cell.type) {
+            case "stairs":
+            case "stairCorner":
+            case "door":
+            case "tile":
+                if (cell.z > highest)
+                    highest = cell.z;
+        }
+    }));
+    return (Math.min(LegacyWallGeometry.MAX_WALL_ADDITIONAL_HEIGHT, highest) +
+        LegacyWallGeometry.WALL_HEIGHT);
+}