@rpgjs/common 3.0.1 → 3.2.0

package/lib/AbstractObject.js

@@ -0,0 +1,828 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractObject = void 0;
+const Utils_1 = require("./Utils");
+const Hit_1 = require("./Hit");
+const Shape_1 = require("./Shape");
+const sat_1 = __importDefault(require("sat"));
+const Map_1 = require("./Map");
+const Plugin_1 = require("./Plugin");
+const Game_1 = require("./Game");
+const Vector2d_1 = require("./Vector2d");
+const types_1 = require("@rpgjs/types");
+const rxjs_1 = require("rxjs");
+const ACTIONS = { IDLE: 0, RUN: 1, ACTION: 2 };
+class AbstractObject {
+    constructor(gameEngine, playerId) {
+        this.gameEngine = gameEngine;
+        this.playerId = playerId;
+        this.map = '';
+        this.height = 0;
+        this.width = 0;
+        this.direction = 3;
+        /*
+            Properties for move mode
+        */
+        this.checkCollision = true;
+        this.clientModeMove = types_1.MoveClientMode.ByDirection;
+        this.behavior = types_1.Behavior.Direction;
+        this.inShapes = {};
+        this.disableVirtualGrid = false;
+        this.shapes = [];
+        this.collisionWith = [];
+        this._collisionWithTiles = [];
+        this._collisionWithShapes = [];
+        this.destroyMove$ = new rxjs_1.Subject();
+        this._hitboxPos = new sat_1.default.Vector(0, 0);
+        this.setHitbox(this.width, this.height);
+        this.position = { x: 0, y: 0, z: 0 };
+    }
+    static get ACTIONS() {
+        return ACTIONS;
+    }
+    get id() {
+        return this.playerId;
+    }
+    set id(str) {
+        this.playerId = str;
+    }
+    updateInVirtualGrid() {
+        const map = this.mapInstance;
+        if (map && !this.disableVirtualGrid /*&& this.gameEngine.isWorker TODO */) {
+            map.grid.insertInCells(this.id, this.getSizeMaxShape());
+        }
+    }
+    get canMove() {
+        return this.clientModeMove == types_1.MoveClientMode.ByDirection;
+    }
+    set canMove(val) {
+        this.clientModeMove = val ? types_1.MoveClientMode.ByDirection : types_1.MoveClientMode.Disabled;
+    }
+    /**
+     * Get/Set position x, y and z of player
+     *
+     * z is the depth layer. By default, its value is 0. Collisions and overlays will be performed with other objects on the same z-position.
+     *
+     * @title Get/Set position
+     * @prop { { x: number, y: number, z: number } } position
+     * @memberof Player
+     */
+    set position(val) {
+        const { x, y, z } = val;
+        if (!Utils_1.isInstanceOf(val, Vector2d_1.Vector2d)) {
+            val = new Vector2d_1.Vector2d(x, y, z);
+        }
+        this._hitboxPos.x = x;
+        this._hitboxPos.y = y;
+        this._hitboxPos.z = z;
+        this.updateInVirtualGrid();
+        this._position = new Proxy(val, {
+            get: (target, prop) => target[prop],
+            set: (target, prop, value) => {
+                this._hitboxPos[prop] = value;
+                target[prop] = value;
+                return true;
+            }
+        });
+    }
+    get position() {
+        return this._position;
+    }
+    get worldPositionX() {
+        let x = this.position.x;
+        if (this.mapInstance) {
+            x += this.mapInstance.worldX;
+        }
+        return x;
+    }
+    get worldPositionY() {
+        let y = this.position.y;
+        if (this.mapInstance) {
+            y += this.mapInstance.worldY;
+        }
+        return y;
+    }
+    set posX(val) {
+        this.position.x = val;
+    }
+    set posY(val) {
+        this.position.y = val;
+    }
+    set posZ(val) {
+        this.position.z = val;
+    }
+    /** @internal */
+    get mapInstance() {
+        if (this.gameEngine.side == Game_1.GameSide.Client) {
+            return Map_1.RpgCommonMap.bufferClient.get(this.map);
+        }
+        return Map_1.RpgCommonMap.buffer.get(this.map);
+    }
+    /**
+    *
+    * Recovers all the colliding shapes of the current player
+    *
+    * @title Get Collision of shapes
+    * @since 3.2.0
+    * @readonly
+    * @prop { RpgShape[] } shapes
+    * @memberof Player
+    * @memberof RpgSpriteLogic
+    */
+    get shapesCollision() {
+        return this._collisionWithShapes;
+    }
+    /**
+    *
+    * Recovers all the colliding tiles of the current player
+    *
+    * @title Get Collision of tiles
+    * @since 3.0.0-beta.4
+    * @readonly
+    * @prop { TileInfo[] } tiles
+    * @memberof Player
+    * @memberof RpgSpriteLogic
+    */
+    get tilesCollision() {
+        return this._collisionWithTiles;
+    }
+    /**
+     *
+     * Recovers all other players and events colliding with the current player's hitbox
+     *
+     * @title Get Collision of other players/events
+     * @since 3.0.0-beta.4
+     * @readonly
+     * @prop { (RpgPlayer | RpgEvent)[] } otherPlayersCollision
+     * @memberof Player
+     * @memberof RpgSpriteLogic
+     */
+    get otherPlayersCollision() {
+        return this.collisionWith;
+    }
+    /**
+     * Define the size of the player. You can set the hitbox for collisions
+     *
+     * ```ts
+     * player.setSizes({
+     *      width: 32,
+     *      height: 32
+     * })
+     * ```
+     *
+     * and with hitbox:
+     *
+     *  ```ts
+     * player.setSizes({
+     *      width: 32,
+     *      height: 32,
+     *      hitbox: {
+     *          width: 20,
+     *          height: 20
+     *      }
+     * })
+     * ```
+     *
+     * @title Set Sizes
+     * @method player.setSizes(key,value)
+     * @param { { width: number, height: number, hitbox?: { width: number, height: number } } } obj
+     * @deprecated
+     * @returns {void}
+     * @memberof Player
+     */
+    setSizes(obj) {
+        this.width = obj.width;
+        this.height = obj.height;
+        if (obj.hitbox) {
+            this.hitbox = new sat_1.default.Box(this._hitboxPos, obj.hitbox.width, obj.hitbox.height);
+        }
+    }
+    /**
+     * Define the hitbox of the player.
+     *
+     * ```ts
+     * player.setHitbox(20, 20)
+     * ```
+     *
+     * @title Set Hitbox
+     * @method player.setHitbox(width,height)
+     * @param {number} width
+     * @param {number} height
+     * @returns {void}
+     * @memberof Player
+     */
+    setHitbox(width, height) {
+        const map = this.mapInstance;
+        if (map) {
+            this.width = map.tileWidth;
+            this.height = map.tileHeight;
+        }
+        this.hitbox = new sat_1.default.Box(this._hitboxPos, width, height);
+        this.wHitbox = width;
+        this.hHitbox = height;
+        this.updateInVirtualGrid();
+    }
+    set wHitbox(val) {
+        this.hitbox.w = val;
+    }
+    set hHitbox(val) {
+        this.hitbox.h = val;
+    }
+    get wHitbox() {
+        return this.hitbox.w;
+    }
+    get hHitbox() {
+        return this.hitbox.h;
+    }
+    directionToAngle(direction) {
+        const angle = (direction < 2 ? +direction + 2 : direction - 2) * 90;
+        return Utils_1.toRadians(angle);
+    }
+    /** @internal */
+    defineNextPosition(direction, deltaTimeInt) {
+        const angle = this.directionToAngle(direction);
+        const computePosition = (prop) => {
+            return this.position[prop] + this.speed * deltaTimeInt
+                * (Math.round(Math[prop == 'x' ? 'cos' : 'sin'](angle) * 100) / 100);
+        };
+        return new Vector2d_1.Vector2d(~~computePosition('x'), ~~computePosition('y'), ~~this.position.z);
+    }
+    /** @internal */
+    setPosition({ x, y, tileX, tileY }, move = true) {
+        const { tileWidth, tileHeight } = this.mapInstance;
+        if (x !== undefined)
+            this.posX = x;
+        if (y !== undefined)
+            this.posY = y;
+        if (tileX !== undefined)
+            this.posX = tileX * tileWidth;
+        if (tileY !== undefined)
+            this.posY = tileY * tileHeight;
+    }
+    /** @internal */
+    triggerCollisionWith(type) {
+        for (let collisionWith of this.collisionWith) {
+            if (collisionWith instanceof Shape_1.RpgShape) {
+                const goMap = collisionWith.getProperty('go-map');
+                if (goMap && 'changeMap' in this)
+                    this.changeMap(goMap);
+            }
+            else {
+                if (type == AbstractObject.ACTIONS.ACTION) {
+                    if ('onAction' in collisionWith)
+                        collisionWith.execMethod('onAction', [this]);
+                }
+                else if ('onPlayerTouch' in collisionWith)
+                    collisionWith.execMethod('onPlayerTouch', [this]);
+            }
+        }
+    }
+    /** @internal */
+    zCollision(other) {
+        const z = this.position.z;
+        const otherZ = other.position.z;
+        return Utils_1.intersection([z, z + this.height], [otherZ, otherZ + other.height]);
+    }
+    /** @internal */
+    moveByDirection(direction, deltaTimeInt) {
+        const nextPosition = this.defineNextPosition(direction, deltaTimeInt);
+        return this.move(nextPosition);
+    }
+    /**
+     * Retrieves a tile and checks if the player has a collision
+     *
+     * ```ts
+     * const tileInfo = player.getTile(20, 30)
+     * console.log(tileInfo)
+     * ```
+     *
+     * Example of returns:
+     *
+     ```ts
+        {
+            tiles: [
+                {
+                    id: 0,
+                    terrain: [],
+                    probability: null,
+                    properties: [Object],
+                    animations: [],
+                    objectGroups: [],
+                    image: null,
+                    gid: 1
+                }
+            ],
+            hasCollision: false,
+            isOverlay: undefined,
+            objectGroups: [],
+            isClimbable: undefined,
+            tileIndex: 93
+        }
+        ```
+     *
+     * @title Get Tile
+     * @since 3.0.0-beta.4
+     * @method player.getTile(x,y,z?)
+     * @param {number} x
+     * @param {number} y
+     * @param {number} [z]
+     * @returns {object}
+     * @memberof Player
+     * @memberof RpgSpriteLogic
+     */
+    getTile(x, y, z = 0, hitbox) {
+        const map = this.mapInstance;
+        return map.getTile(hitbox || this.hitbox, x, y, [z, this.height]);
+    }
+    collisionObjects(playerSizeBox, hitbox, triggers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const map = this.mapInstance;
+            if (!map)
+                return true;
+            const events = this.gameEngine.world.getObjectsOfGroup(this.map, this);
+            const objects = map.grid.getObjectsByBox(playerSizeBox);
+            let boolFound = false;
+            for (let objectId of objects) {
+                // client side: read "object" propertie
+                if (!events[objectId])
+                    continue;
+                const event = events[objectId]['object'] || events[objectId];
+                if (event.id == this.id)
+                    continue;
+                if (!this.zCollision(event))
+                    continue;
+                const collided = Hit_1.Hit.testPolyCollision(Hit_1.HitType.Box, hitbox, event.hitbox);
+                for (let shape of this.shapes) {
+                    yield this.collisionWithShape(shape, event);
+                }
+                for (let shape of event.shapes) {
+                    yield event.collisionWithShape(shape, this);
+                }
+                if (triggers === null || triggers === void 0 ? void 0 : triggers.near)
+                    triggers.near(event);
+                if (collided) {
+                    this.collisionWith.push(event);
+                    this.triggerCollisionWith();
+                    let throughOtherPlayer = false;
+                    if (event.type == types_1.PlayerType.Player && this.type == types_1.PlayerType.Player) {
+                        if (!(event.throughOtherPlayer || this.throughOtherPlayer)) {
+                            boolFound = true;
+                            if (!(triggers === null || triggers === void 0 ? void 0 : triggers.allSearch))
+                                return true;
+                        }
+                        else {
+                            throughOtherPlayer = true;
+                        }
+                    }
+                    if (!throughOtherPlayer && (!(event.through || this.through))) {
+                        boolFound = true;
+                        if (!(triggers === null || triggers === void 0 ? void 0 : triggers.allSearch))
+                            return true;
+                    }
+                }
+                if (boolFound) {
+                    if (triggers === null || triggers === void 0 ? void 0 : triggers.collision)
+                        triggers.collision(event);
+                }
+            }
+            return boolFound;
+        });
+    }
+    /** @internal */
+    collisionWithShape(shape, player, nextPosition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const collision = shape.hasCollision;
+            const z = shape.z;
+            if (shape.isShapePosition())
+                return false;
+            if (z !== undefined && !this.zCollision({
+                position: { z },
+                height: this.mapInstance.zTileHeight
+            })) {
+                return false;
+            }
+            let position;
+            let { hitbox } = player;
+            if (nextPosition) {
+                position = nextPosition.copy();
+            }
+            else {
+                position = player.position.copy();
+            }
+            const hitboxObj = Hit_1.Hit.createObjectHitbox(position.x, position.y, position.z, hitbox.w, hitbox.h);
+            let collided = Hit_1.Hit.testPolyCollision(shape.type, hitboxObj, shape.hitbox);
+            if (collided) {
+                this._collisionWithShapes.push(shape);
+                // TODO: in shape after map load
+                if (!collision)
+                    yield shape.in(this);
+                this.triggerCollisionWith();
+                if (collision)
+                    return true;
+            }
+            else {
+                yield shape.out(this);
+            }
+            return false;
+        });
+    }
+    collisionShapes(playerSizeBox, nextPosition, triggers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const map = this.mapInstance;
+            if (!map)
+                return false;
+            const shapes = this.gameEngine.world.getShapesOfGroup(this.map);
+            const shapesInGrid = this.gameEngine.side == Game_1.GameSide.Client
+                ? new Set(Object.keys(shapes))
+                : map.gridShapes.getObjectsByBox(playerSizeBox);
+            let boolFound = false;
+            for (let shapeId of shapesInGrid) {
+                const shape = shapes[shapeId]['object'] || shapes[shapeId];
+                if (triggers === null || triggers === void 0 ? void 0 : triggers.near)
+                    triggers.near(shape);
+                const bool = yield this.collisionWithShape(shape, this, nextPosition);
+                if (bool) {
+                    if (triggers === null || triggers === void 0 ? void 0 : triggers.collision)
+                        triggers.collision(shape);
+                    boolFound = true;
+                    if (!(triggers === null || triggers === void 0 ? void 0 : triggers.allSearch))
+                        return true;
+                }
+            }
+            return boolFound;
+        });
+    }
+    computeNextPositionByTarget(nextPosition, target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pullDistance = target.distanceWith(nextPosition);
+            if (pullDistance <= this.speed) {
+                return nextPosition.set(target);
+            }
+            const pull = (target.copy().subtract(nextPosition)).multiply((1 / pullDistance));
+            const totalPush = new Vector2d_1.Vector2dZero();
+            let contenders = 0;
+            const hitbox = Hit_1.Hit.createObjectHitbox(nextPosition.x, nextPosition.y, nextPosition.z, this.hitbox.w, this.hitbox.h);
+            const createObstacle = function (x, y, radius) {
+                const obstacle = new Vector2d_1.Vector2d(x, y);
+                let push = nextPosition.copy().subtract(obstacle);
+                let distance = (nextPosition.distanceWith(obstacle) - radius) - radius;
+                if (distance < radius * 2 * 10) {
+                    ++contenders;
+                    if (distance < 0.0001)
+                        distance = 0.0001; // avoid div by 0
+                    let weight = 1 / distance;
+                    totalPush.add(push.multiply(weight));
+                }
+                return obstacle;
+            };
+            const area = this.mapInstance.tileheight * 2;
+            this.mapInstance.gridTiles.getCells({
+                minX: nextPosition.x - area,
+                maxX: nextPosition.x + area,
+                minY: nextPosition.y - area,
+                maxY: nextPosition.y + area
+            }, (index) => {
+                if (index < 0)
+                    return;
+                const pos = this.mapInstance.getTilePosition(index);
+                const hitbox = Hit_1.Hit.createObjectHitbox(pos.x, pos.y, nextPosition.z, this.hitbox.w, this.hitbox.h);
+                const radius = this.mapInstance.tilewidth / 2;
+                const tile = this.getTile(pos.x, pos.y, nextPosition.z, hitbox);
+                if (tile.hasCollision) {
+                    createObstacle(pos.x, pos.y, radius);
+                }
+            });
+            const playerSizeBox = this.getSizeMaxShape(nextPosition.x, nextPosition.y);
+            yield this.collisionObjects(playerSizeBox, hitbox, {
+                collision: (event) => {
+                    const { x, y } = event.position;
+                    createObstacle(x, y, event.hitbox.w);
+                },
+                allSearch: true
+            });
+            yield this.collisionShapes(playerSizeBox, nextPosition, {
+                collision: (shape) => {
+                    const { x, y } = shape.position;
+                    createObstacle(x, y, shape.hitbox.w);
+                },
+                allSearch: true
+            });
+            pull
+                .multiply(Math.max(1, 4 * contenders))
+                .add(totalPush)
+                .normalize();
+            return nextPosition.add(pull.multiply(this.speed));
+        });
+    }
+    isCollided(nextPosition, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.collisionWith = [];
+            this._collisionWithTiles = [];
+            const prevMapId = this.map;
+            const hitbox = Hit_1.Hit.createObjectHitbox(nextPosition.x, nextPosition.y, 0, this.hitbox.w, this.hitbox.h);
+            const boundingMap = this.mapInstance.boundingMap(nextPosition, this.hitbox);
+            let collided = false;
+            if (boundingMap === null || boundingMap === void 0 ? void 0 : boundingMap.bounding) {
+                this.position.set(nextPosition);
+                if (!options.allSearch)
+                    return true;
+                else
+                    collided = true;
+            }
+            const tileCollision = (x, y) => {
+                const tile = this.getTile(x, y, nextPosition.z, hitbox);
+                if (tile.hasCollision) {
+                    this._collisionWithTiles.push(tile);
+                    return true;
+                }
+                return false;
+            };
+            if (tileCollision(nextPosition.x, nextPosition.y) ||
+                tileCollision(nextPosition.x + this.hitbox.w, nextPosition.y) ||
+                tileCollision(nextPosition.x, nextPosition.y + this.hitbox.h) ||
+                tileCollision(nextPosition.x + this.hitbox.w, nextPosition.y + this.hitbox.h)) {
+                if (!options.allSearch)
+                    return true;
+                else
+                    collided = true;
+            }
+            if (this.autoChangeMap) {
+                const changeMap = yield this.autoChangeMap(nextPosition);
+                if (changeMap) {
+                    return true;
+                }
+            }
+            const playerSizeBox = this.getSizeMaxShape(nextPosition.x, nextPosition.y);
+            if (yield this.collisionObjects(playerSizeBox, hitbox, options)) {
+                if (!options.allSearch)
+                    return true;
+                else
+                    collided = true;
+            }
+            if (yield this.collisionShapes(playerSizeBox, nextPosition, options)) {
+                if (!options.allSearch)
+                    return true;
+                else
+                    collided = true;
+            }
+            // if there is a change of map after a move, the moves are not changed
+            if (prevMapId != this.map) {
+                return true;
+            }
+            return collided;
+        });
+    }
+    /**
+     * Attach a shape to the player (and allow interaction with it)
+     *
+     * ```ts
+     * import { ShapePositioning } from '@rpgjs/server'
+     *
+     * player.attachShape({
+     *      width: 100,
+     *      height: 100,
+     *      positioning: ShapePositioning.Center
+     * })
+     * ```
+     *
+     * @title Attach Shape
+     * @method player.attachShape(parameters)
+     * @param { { width: number, height: number, positioning?, name?, properties?: object } } obj
+     * - positioning: Indicate where the shape is placed.
+     * - properties: An object in order to retrieve information when interacting with the shape
+     * - name: The name of the shape
+     * @since 3.0.0-beta.3
+     * @returns {RpgShape}
+     * @memberof Player
+     */
+    attachShape(obj) {
+        obj.name = (obj.name || Utils_1.generateUID());
+        const shape = new Shape_1.RpgShape(Object.assign(Object.assign({}, obj), { fixEvent: this }));
+        this.shapes.push(shape);
+        return shape;
+    }
+    /**
+     * Returns all shapes assigned to this player
+     *
+     * @title Get Shapes
+     * @method player.getShapes()
+     * @returns {RpgShape[]}
+     * @since 3.0.0-beta.3
+     * @memberof Player
+     * @memberof RpgSpriteLogic
+     */
+    getShapes() {
+        return this.shapes;
+    }
+    autoChangeDirection(nextPosition) {
+        const { x, y } = this.position;
+        const { x: nx, y: ny } = nextPosition;
+        const diff = Math.abs(x - nx) > Math.abs(y - ny);
+        if (diff) {
+            if (nx > x) {
+                this.changeDirection(types_1.Direction.Right);
+            }
+            else {
+                this.changeDirection(types_1.Direction.Left);
+            }
+        }
+        else {
+            if (ny > y) {
+                this.changeDirection(types_1.Direction.Down);
+            }
+            else {
+                this.changeDirection(types_1.Direction.Up);
+            }
+        }
+    }
+    /**
+    * Stops the movement of the player who moves towards his target
+    *
+    * @title Stop Move To
+    * @method player.stopMoveTo()
+    * @returns {void}
+    * @since 3.2.0
+    * @memberof MoveManager
+    */
+    stopMoveTo() {
+        if (this.destroyMove$.closed)
+            return;
+        this.destroyMove$.next(true);
+        this.destroyMove$.unsubscribe();
+    }
+    _moveTo(tick$, positionTarget, options = {}) {
+        let i = 0;
+        let count = 0;
+        const lastPositions = [];
+        this.stopMoveTo();
+        this.destroyMove$ = new rxjs_1.Subject();
+        const { infinite, onStuck, onComplete } = options;
+        const getPosition = () => {
+            let pos;
+            if ('x' in positionTarget) {
+                pos = new Vector2d_1.Vector2d(positionTarget.x, positionTarget.y);
+            }
+            else {
+                pos = positionTarget.position;
+            }
+            return pos;
+        };
+        return tick$
+            .pipe(rxjs_1.takeUntil(this.destroyMove$), rxjs_1.mergeMap(() => rxjs_1.from(this.computeNextPositionByTarget(this.position.copy(), getPosition()))), rxjs_1.map((position) => {
+            this.autoChangeDirection(position);
+            return this.position.set(position);
+        }), rxjs_1.tap((position) => {
+            lastPositions[i] = position.copy();
+            i++;
+            count++;
+            if (i >= 3) {
+                i = 0;
+            }
+            if (lastPositions[2] && lastPositions[0].isEqual(lastPositions[2])) {
+                onStuck === null || onStuck === void 0 ? void 0 : onStuck(count);
+            }
+            else if (this.position.isEqual(getPosition())) {
+                onComplete === null || onComplete === void 0 ? void 0 : onComplete();
+                if (!infinite) {
+                    this.stopMoveTo();
+                }
+            }
+            else {
+                count = 0;
+            }
+        }));
+    }
+    /** @internal */
+    move(nextPosition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.autoChangeDirection(nextPosition);
+            const notCollided = !(yield this.isCollided(nextPosition));
+            if (notCollided || !this.checkCollision) {
+                this.position = nextPosition.copy();
+                yield Plugin_1.RpgPlugin.emit(Plugin_1.HookServer.PlayerMove, this);
+            }
+            return true;
+        });
+    }
+    /**
+     * Retrieves all shapes where the player is located
+     *
+     * @title Get In-Shapes
+     * @method player.getInShapes()
+     * @returns {RpgShape[]}
+     * @since 3.0.0-beta.3
+     * @memberof Player
+     */
+    getInShapes() {
+        return Object.values(this.inShapes);
+    }
+    /**
+    * Get the current direction.
+    *
+    * ```ts
+    * player.getDirection()
+    * ```
+    *
+    * @title Get Direction
+    * @method player.getDirection()
+    * @returns {Direction | number} direction
+    * @memberof Player
+    */
+    getDirection(direction) {
+        return direction || this.direction;
+    }
+    /**
+    * Changes the player's direction
+    *
+    * ```ts
+    * import { Direction } from '@rpgjs/server'
+    *
+    * player.changeDirection(Direction.Left)
+    * ```
+    *
+    * @title Change direction
+    * @method player.changeDirection(direction)
+    * @param {Direction} direction
+    * @enum {string}
+    *
+    * Direction.Left | left
+    * Direction.Right | right
+    * Direction.Up | up
+    * Direction.Down | down
+    * @returns {boolean} the direction has changed
+    * @memberof Player
+    */
+    changeDirection(direction) {
+        const dir = +this.getDirection(direction);
+        if (dir === undefined)
+            return false;
+        this.direction = dir;
+        return true;
+    }
+    /**
+     * Gets the necessary number of pixels to allow the player to cross a tile.
+     * This is the ratio between the height or width of the tile and the speed of the player.
+     */
+    get nbPixelInTile() {
+        const direction = this.getDirection();
+        switch (direction) {
+            case types_1.Direction.Down:
+            case types_1.Direction.Up:
+                return Math.floor(this.mapInstance.tileHeight / this.speed);
+            case types_1.Direction.Left:
+            case types_1.Direction.Right:
+                return Math.floor(this.mapInstance.tileWidth / this.speed);
+            default:
+                return NaN;
+        }
+    }
+    getSizeMaxShape(x, y) {
+        const _x = x || this.position.x;
+        const _y = y || this.position.y;
+        let minX = _x;
+        let minY = _y;
+        let maxX = _x + this.wHitbox;
+        let maxY = _y + this.hHitbox;
+        const shapes = this.getShapes();
+        for (let shape of shapes) {
+            if (shape.x < minX)
+                minX = shape.x;
+            if (shape.y < minY)
+                minY = shape.y;
+            const shapeMaxX = shape.x + shape.width;
+            const shapeMaxY = shape.y + shape.height;
+            if (shapeMaxX > maxX)
+                maxX = shapeMaxX;
+            if (shapeMaxY > maxY)
+                maxY = shapeMaxY;
+        }
+        return {
+            minX,
+            minY,
+            maxX,
+            maxY
+        };
+    }
+    /** @internal */
+    execMethod(methodName, methodData, instance) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    /** @internal */
+    onAction() { }
+    /** @internal */
+    onPlayerTouch() { }
+}
+exports.AbstractObject = AbstractObject;
+//# sourceMappingURL=AbstractObject.js.map