@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

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

@@ -0,0 +1,127 @@
+"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.Stair = void 0;
+const PIXI = __importStar(require("pixi.js"));
+const matrixes_1 = require("../matrixes");
+class Stair extends PIXI.Container {
+    constructor(_props) {
+        super();
+        this._props = _props;
+        this._tileHeight = 0;
+        this._tileLeftColor = 0;
+        this._tileRightColor = 0;
+        this._tileTopColor = 0;
+        this._tileHeight = _props.tileHeight;
+        this.updateSprites();
+    }
+    update(data) {
+        this._tileHeight = data.tileHeight;
+        this._tileLeftColor = data.tileLeftColor;
+        this._tileRightColor = data.tileRightColor;
+        this._tileTopColor = data.tileTopColor;
+        this._texture = data.tileTexture;
+        this.updateSprites();
+    }
+    updateSprites() {
+        this.removeChildren();
+        const { direction } = this._props;
+        for (let i = 0; i < 4; i++) {
+            if (direction === 0) {
+                this.addChild(...this._createStairBoxDirection0(3 - i));
+            }
+            else if (direction === 2) {
+                this.addChild(...this._createStairBoxDirection2(3 - i));
+            }
+        }
+    }
+    _createStairBoxDirection0(index) {
+        const baseX = +stairBase * index;
+        const baseY = -stairBase * index * 1.5;
+        const texture = this._texture;
+        function createSprite(matrix, tint, tilePosition) {
+            const tile = new PIXI.TilingSprite({
+                texture: texture !== null && texture !== void 0 ? texture : PIXI.Texture.WHITE,
+            });
+            tile.tilePosition.set(tilePosition.x, tilePosition.y);
+            tile.setFromMatrix(matrix);
+            tile.tint = tint;
+            return tile;
+        }
+        const tile = createSprite((0, matrixes_1.getFloorMatrix)(baseX, baseY), this._tileTopColor, new PIXI.Point(0, 0));
+        tile.width = 32;
+        tile.height = 8;
+        const borderLeft = createSprite((0, matrixes_1.getLeftMatrix)(baseX, baseY, { width: 32, height: this._tileHeight }), this._tileLeftColor, new PIXI.Point(0, 0));
+        borderLeft.width = 32;
+        borderLeft.height = this._tileHeight;
+        const borderRight = createSprite((0, matrixes_1.getRightMatrix)(baseX, baseY, { width: 8, height: this._tileHeight }), this._tileRightColor, new PIXI.Point(0, 0));
+        borderRight.width = 8;
+        borderRight.height = this._tileHeight;
+        return [borderLeft, borderRight, tile];
+    }
+    _createStairBoxDirection2(index) {
+        const baseX = -stairBase * index;
+        const baseY = -stairBase * index * 1.5;
+        const texture = this._texture;
+        function createSprite(matrix, tint) {
+            const tile = new PIXI.TilingSprite({
+                texture: texture !== null && texture !== void 0 ? texture : PIXI.Texture.WHITE,
+            });
+            tile.tilePosition.set(0, 0);
+            tile.setFromMatrix(matrix);
+            tile.tint = tint;
+            return tile;
+        }
+        const tile = createSprite((0, matrixes_1.getFloorMatrix)(baseX + 32 - stairBase, baseY + stairBase * 1.5), this._tileTopColor);
+        tile.width = stairBase;
+        tile.height = 32;
+        const borderLeft = createSprite((0, matrixes_1.getLeftMatrix)(baseX + 32 - stairBase, baseY + stairBase * 1.5, {
+            width: stairBase,
+            height: this._tileHeight,
+        }), this._tileLeftColor);
+        borderLeft.width = stairBase;
+        borderLeft.height = this._tileHeight;
+        const borderRight = createSprite((0, matrixes_1.getRightMatrix)(baseX, baseY, { width: 32, height: this._tileHeight }), this._tileRightColor);
+        borderRight.width = 32;
+        borderRight.height = this._tileHeight;
+        return [borderLeft, borderRight, tile];
+    }
+    destroy() {
+        super.destroy();
+        this.removeChildren();
+    }
+}
+exports.Stair = Stair;
+const stairBase = 8;

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

@@ -0,0 +1,22 @@
+import * as PIXI from "pixi.js";
+import { IRoomPart } from "./IRoomPart";
+import { RoomPartData } from "./RoomPartData";
+export declare class StairCorner extends PIXI.Container implements IRoomPart {
+    private _props;
+    private _container;
+    private _texture;
+    private _tileHeight;
+    private _tileLeftColor;
+    private _tileRightColor;
+    private _tileTopColor;
+    constructor(_props: {
+        type: "front" | "left" | "right";
+    });
+    update(data: RoomPartData): void;
+    updateSprites(): void;
+    destroySprites(): void;
+    destroy(): void;
+    private _createStairBoxFront;
+    private _createStairBoxLeft;
+    private _createStairBoxRight;
+}

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

@@ -0,0 +1,192 @@
+"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.StairCorner = void 0;
+const PIXI = __importStar(require("pixi.js"));
+const matrixes_1 = require("../matrixes");
+class StairCorner extends PIXI.Container {
+    constructor(_props) {
+        super();
+        this._props = _props;
+        this._tileHeight = 0;
+        this._tileLeftColor = 0;
+        this._tileRightColor = 0;
+        this._tileTopColor = 0;
+        this.sortableChildren = true;
+    }
+    update(data) {
+        this._tileHeight = data.tileHeight;
+        this._tileLeftColor = data.tileLeftColor;
+        this._tileRightColor = data.tileRightColor;
+        this._tileTopColor = data.tileTopColor;
+        this._texture = data.tileTexture;
+        this.updateSprites();
+    }
+    updateSprites() {
+        this.removeChildren();
+        const { type } = this._props;
+        for (let i = 0; i < 4; i++) {
+            if (type === "front") {
+                this.addChild(...this._createStairBoxFront(3 - i));
+            }
+            else if (type === "left") {
+                this.addChild(...this._createStairBoxLeft(3 - i));
+            }
+            else if (type === "right") {
+                this.addChild(...this._createStairBoxRight(3 - i));
+            }
+        }
+    }
+    destroySprites() {
+        var _a;
+        (_a = this._container) === null || _a === void 0 ? void 0 : _a.destroy();
+    }
+    destroy() {
+        super.destroy();
+        this.destroySprites();
+    }
+    _createStairBoxFront(index) {
+        const baseXLeft = +stairBase * index;
+        const baseYLeft = -stairBase * index * 1.5;
+        const baseXRight = 0;
+        const baseYRight = -stairBase * index * 2;
+        const texture = this._texture;
+        function createSprite(matrix, tint, tilePosition) {
+            const tile = new PIXI.TilingSprite({
+                texture: texture !== null && texture !== void 0 ? texture : PIXI.Texture.WHITE,
+            });
+            tile.tilePosition.set(tilePosition.x, tilePosition.y);
+            tile.setFromMatrix(matrix);
+            tile.tint = tint;
+            return tile;
+        }
+        const tileLeft = createSprite((0, matrixes_1.getFloorMatrix)(baseXLeft, baseYLeft), this._tileTopColor, new PIXI.Point());
+        tileLeft.width = 32 - 8 * index;
+        tileLeft.height = 8;
+        const tileRight = createSprite((0, matrixes_1.getFloorMatrix)(baseXRight + 32 - stairBase, baseYRight + stairBase * 1.5), this._tileTopColor, new PIXI.Point(0, 0));
+        tileRight.width = stairBase;
+        tileRight.height = 32 - 8 * index;
+        const borderLeft = createSprite((0, matrixes_1.getLeftMatrix)(baseXLeft - 8 * index, baseYLeft - 8 * index * 0.5, {
+            width: 32,
+            height: this._tileHeight,
+        }), this._tileLeftColor, new PIXI.Point(0, 0));
+        borderLeft.width = 32 - 8 * index;
+        borderLeft.height = this._tileHeight;
+        const borderRight = createSprite((0, matrixes_1.getRightMatrix)(baseXRight - stairBase * index, -stairBase * index * 1.5, {
+            width: 32,
+            height: this._tileHeight,
+        }), this._tileRightColor, new PIXI.Point(0, 0));
+        borderRight.width = 32 - 8 * index;
+        borderRight.height = this._tileHeight;
+        return [borderLeft, borderRight, tileLeft, tileRight];
+    }
+    _createStairBoxLeft(index) {
+        const baseX = -stairBase * index;
+        const baseY = -stairBase * index * 1.5;
+        const texture = this._texture;
+        function createSprite(matrix, tint, tilePosition) {
+            const tile = new PIXI.TilingSprite({
+                texture: texture !== null && texture !== void 0 ? texture : PIXI.Texture.WHITE,
+            });
+            tile.tilePosition.set(tilePosition.x, tilePosition.y);
+            tile.setFromMatrix(matrix);
+            tile.tint = tint;
+            return tile;
+        }
+        const tileRight = createSprite((0, matrixes_1.getFloorMatrix)(baseX + 32 - stairBase, baseY + stairBase * 1.5), this._tileTopColor, new PIXI.Point(0, 0));
+        tileRight.width = stairBase;
+        tileRight.height = 32 - 8 * index;
+        tileRight.zIndex = 2;
+        const borderRight = createSprite((0, matrixes_1.getRightMatrix)(baseX - stairBase * index, -stairBase * index, {
+            width: 32,
+            height: this._tileHeight,
+        }), this._tileRightColor, new PIXI.Point(0, 0));
+        borderRight.width = 32 - 8 * index;
+        borderRight.height = this._tileHeight;
+        borderRight.zIndex = 1;
+        if (index == 0) {
+            const cornerOne = createSprite((0, matrixes_1.getFloorMatrix)(baseX + 40, -4), this._tileTopColor, new PIXI.Point(0, 0));
+            cornerOne.width = 8;
+            cornerOne.height = 8;
+            cornerOne.zIndex = 0;
+            const cornerTwo = createSprite((0, matrixes_1.getFloorMatrix)(baseX + 24, -12), this._tileTopColor, new PIXI.Point(0, 0));
+            cornerTwo.width = 8;
+            cornerTwo.height = 8;
+            cornerTwo.zIndex = 0;
+            return [tileRight, borderRight, cornerOne, cornerTwo];
+        }
+        else {
+            return [tileRight, borderRight];
+        }
+    }
+    _createStairBoxRight(index) {
+        const baseX = +stairBase * index;
+        const baseY = -stairBase * index * 1.5;
+        const texture = this._texture;
+        function createSprite(matrix, tint, tilePosition) {
+            const tile = new PIXI.TilingSprite({
+                texture: texture !== null && texture !== void 0 ? texture : PIXI.Texture.WHITE,
+            });
+            tile.tilePosition.set(tilePosition.x, tilePosition.y);
+            tile.setFromMatrix(matrix);
+            tile.tint = tint;
+            return tile;
+        }
+        const tile = createSprite((0, matrixes_1.getFloorMatrix)(baseX + 8 * index, baseY + 8 * index * 0.5), this._tileTopColor, new PIXI.Point(0, 0));
+        tile.width = 32 - 8 * index;
+        tile.height = 8;
+        tile.zIndex = 2;
+        const borderLeft = createSprite((0, matrixes_1.getLeftMatrix)(baseX, baseY, { width: 32, height: this._tileHeight }), this._tileLeftColor, new PIXI.Point(0, 0));
+        borderLeft.width = 32 - 8 * index;
+        borderLeft.height = this._tileHeight;
+        borderLeft.zIndex = 1;
+        if (index == 0) {
+            const cornerOne = createSprite((0, matrixes_1.getFloorMatrix)(baseX + 8, -4), this._tileTopColor, new PIXI.Point(0, 0));
+            cornerOne.width = 8;
+            cornerOne.height = 8;
+            cornerOne.zIndex = 0;
+            const cornerTwo = createSprite((0, matrixes_1.getFloorMatrix)(baseX + 24, -12), this._tileTopColor, new PIXI.Point(0, 0));
+            cornerTwo.width = 8;
+            cornerTwo.height = 8;
+            cornerTwo.zIndex = 0;
+            return [tile, borderLeft, cornerOne, cornerTwo];
+        }
+        else {
+            return [tile, borderLeft];
+        }
+    }
+}
+exports.StairCorner = StairCorner;
+const stairBase = 8;

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

@@ -0,0 +1,33 @@
+import * as PIXI from "pixi.js";
+import { IRoomPart } from "./IRoomPart";
+import { RoomPartData } from "./RoomPartData";
+interface Props {
+    edge?: boolean;
+    tileHeight: number;
+    color: string;
+    texture?: PIXI.Texture;
+    door?: boolean;
+    showBorders: {
+        showLeftBorder: boolean;
+        showRightBorder: boolean;
+    };
+}
+export declare class Tile extends PIXI.Container implements IRoomPart {
+    private props;
+    private _texture;
+    private _color;
+    private _tileHeight;
+    private _roomPartData;
+    private _tilePositions;
+    private _showBorders;
+    get color(): string | undefined;
+    set color(value: string | undefined);
+    get tilePositions(): PIXI.Point;
+    set tilePositions(value: PIXI.Point);
+    get tileHeight(): number;
+    set tileHeight(value: number);
+    constructor(props: Props);
+    update(data: RoomPartData): void;
+    private _updateSprites;
+}
+export {};

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

@@ -0,0 +1,138 @@
+"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.Tile = void 0;
+const PIXI = __importStar(require("pixi.js"));
+const matrixes_1 = require("../matrixes");
+class Tile extends PIXI.Container {
+    get color() {
+        return this._color;
+    }
+    set color(value) {
+        this._color = value;
+        this._updateSprites();
+    }
+    get tilePositions() {
+        return this._tilePositions;
+    }
+    set tilePositions(value) {
+        this._tilePositions = value;
+        this._updateSprites();
+    }
+    get tileHeight() {
+        return this._tileHeight;
+    }
+    set tileHeight(value) {
+        this._tileHeight = value;
+        this._updateSprites();
+    }
+    constructor(props) {
+        super();
+        this.props = props;
+        this._tilePositions = new PIXI.Point(0, 0);
+        this._showBorders = { showLeftBorder: true, showRightBorder: true };
+        this._texture = props.texture;
+        this._color = props.color;
+        this._tileHeight = props.tileHeight;
+        this._showBorders = props.showBorders;
+        this._updateSprites();
+    }
+    update(data) {
+        this.tileHeight = data.tileHeight;
+        this._roomPartData = data;
+        this._texture = data.tileTexture;
+        this._updateSprites();
+    }
+    _updateSprites() {
+        var _a, _b, _c;
+        var _d, _e, _f, _g, _h, _j;
+        this.removeChildren();
+        const tileMatrix = (0, matrixes_1.getFloorMatrix)(0, 0);
+        const top = new PIXI.Graphics()
+            .moveTo(0, 0)
+            .lineTo(32, -16)
+            .lineTo(64, 0)
+            .lineTo(32, 16)
+            .lineTo(0, 0)
+            .fill({
+            textureSpace: "global",
+            texture: (_d = this._texture) !== null && _d !== void 0 ? _d : PIXI.Texture.WHITE,
+            color: (_e = (_a = this._roomPartData) === null || _a === void 0 ? void 0 : _a.tileTopColor) !== null && _e !== void 0 ? _e : 0,
+            matrix: new PIXI.Matrix(1, 0.5, 1, -0.5, 0, 0),
+        });
+        top.position.set(tileMatrix.tx, tileMatrix.ty);
+        this.addChild(top);
+        if (this._showBorders.showLeftBorder) {
+            const borderLeftMatrix = (0, matrixes_1.getLeftMatrix)(0, 0, {
+                width: 32,
+                height: this.tileHeight,
+            });
+            const left = new PIXI.Graphics()
+                .moveTo(0, 0)
+                .lineTo(0, this.tileHeight)
+                .lineTo(32, 16 + this.tileHeight)
+                .lineTo(32, 16)
+                .fill({
+                textureSpace: "global",
+                texture: (_f = this._texture) !== null && _f !== void 0 ? _f : PIXI.Texture.WHITE,
+                color: (_g = (_b = this._roomPartData) === null || _b === void 0 ? void 0 : _b.tileLeftColor) !== null && _g !== void 0 ? _g : 0,
+                matrix: borderLeftMatrix,
+            });
+            left.position.set(0, 16);
+            this.addChild(left);
+        }
+        if (this._showBorders.showRightBorder) {
+            const borderRightMatrix = (0, matrixes_1.getRightMatrix)(0, 0, {
+                width: 32,
+                height: this.tileHeight,
+            });
+            const right = new PIXI.Graphics()
+                .moveTo(32, 16)
+                .lineTo(32, 16 + this.tileHeight)
+                .lineTo(64, this.tileHeight)
+                .lineTo(64, 0)
+                .lineTo(32, 16)
+                .fill({
+                textureSpace: "global",
+                texture: (_h = this._texture) !== null && _h !== void 0 ? _h : PIXI.Texture.WHITE,
+                color: (_j = (_c = this._roomPartData) === null || _c === void 0 ? void 0 : _c.tileRightColor) !== null && _j !== void 0 ? _j : 0,
+                matrix: borderRightMatrix,
+            });
+            right.position.set(0, 16);
+            this.addChild(right);
+        }
+    }
+}
+exports.Tile = Tile;

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

@@ -0,0 +1,43 @@
+import * as PIXI from "pixi.js";
+import { Observable } from "rxjs";
+import { RoomPosition } from "../../../types/RoomPosition";
+import { EventGroupIdentifier, IEventGroup } from "../../events/interfaces/IEventGroup";
+import { IEventManager } from "../../events/interfaces/IEventManager";
+import { IEventManagerEvent } from "../../events/interfaces/IEventManagerEvent";
+import { IEventTarget } from "../../events/interfaces/IEventTarget";
+import { Rectangle } from "../IRoomRectangle";
+export declare class TileCursor extends PIXI.Container implements IEventTarget, IEventGroup {
+    private _eventManager;
+    private _roomPosition;
+    private onClick;
+    private onOver;
+    private onOut;
+    private _roomX;
+    private _roomY;
+    private _roomZ;
+    private _graphics;
+    private _hover;
+    private _isTileCursorDestroyed;
+    private _subject;
+    constructor(_eventManager: IEventManager, _roomPosition: RoomPosition, onClick: (position: RoomPosition, event: IEventManagerEvent) => void, onOver: (position: RoomPosition) => void, onOut: (position: RoomPosition) => void);
+    getEventGroupIdentifier(): EventGroupIdentifier;
+    getGroup(): IEventGroup;
+    getRectangleObservable(): Observable<Rectangle | undefined>;
+    getEventZOrder(): number;
+    triggerPointerTargetChanged(event: IEventManagerEvent): void;
+    triggerClick(event: IEventManagerEvent): void;
+    triggerPointerDown(event: IEventManagerEvent): void;
+    triggerPointerUp(event: IEventManagerEvent): void;
+    triggerPointerOver(event: IEventManagerEvent): void;
+    triggerPointerOut(event: IEventManagerEvent): void;
+    createDebugSprite(): undefined;
+    hits(x: number, y: number): boolean;
+    getHitDetectionZIndex(): number;
+    destroy(): void;
+    private _lastRect;
+    private _emitRectangle;
+    private _createGraphics;
+    private _updateGraphics;
+    private _updateHover;
+    private _pointInside;
+}