@rpgjs/common 3.3.1 → 4.0.0-beta.1

package/lib/AbstractObject.js

@@ -1,30 +1,18 @@
-"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");
+import { intersection, generateUID, toRadians, isInstanceOf } from './Utils';
+import { Hit, HitType } from './Hit';
+import { RpgShape } from './Shape';
+import SAT from 'sat';
+import { RpgCommonMap } from './Map';
+import { RpgPlugin, HookServer } from './Plugin';
+import { GameSide } from './Game';
+import { Vector2d, Vector2dZero } from './Vector2d';
+import { Behavior, Direction, MoveClientMode, PlayerType } from '@rpgjs/types';
+import { from, map, mergeMap, Subject, tap, takeUntil } from 'rxjs';
 const ACTIONS = { IDLE: 0, RUN: 1, ACTION: 2 };
-class AbstractObject {
+export class AbstractObject {
+    static get ACTIONS() {
+        return ACTIONS;
+    }
     constructor(gameEngine, playerId) {
         this.gameEngine = gameEngine;
         this.playerId = playerId;
@@ -36,22 +24,21 @@ class AbstractObject {
             Properties for move mode
         */
         this.checkCollision = true;
-        this.clientModeMove = types_1.MoveClientMode.ByDirection;
-        this.behavior = types_1.Behavior.Direction;
+        this.clientModeMove = MoveClientMode.ByDirection;
+        this.behavior = 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.destroyMove$ = new Subject();
+        // notifier for destroy
+        this._destroy$ = new Subject();
+        this._hitboxPos = new SAT.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;
     }
@@ -65,10 +52,10 @@ class AbstractObject {
         }
     }
     get canMove() {
-        return this.clientModeMove == types_1.MoveClientMode.ByDirection;
+        return this.clientModeMove == MoveClientMode.ByDirection;
     }
     set canMove(val) {
-        this.clientModeMove = val ? types_1.MoveClientMode.ByDirection : types_1.MoveClientMode.Disabled;
+        this.clientModeMove = val ? MoveClientMode.ByDirection : MoveClientMode.Disabled;
     }
     /**
      * Get/Set position x, y and z of player
@@ -81,8 +68,8 @@ class AbstractObject {
      */
     set position(val) {
         const { x, y, z } = val;
-        if (!Utils_1.isInstanceOf(val, Vector2d_1.Vector2d)) {
-            val = new Vector2d_1.Vector2d(x, y, z);
+        if (!isInstanceOf(val, Vector2d)) {
+            val = new Vector2d(x, y, z);
         }
         this._hitboxPos.x = x;
         this._hitboxPos.y = y;
@@ -125,10 +112,10 @@ class AbstractObject {
     }
     /** @internal */
     get mapInstance() {
-        if (this.gameEngine.side == Game_1.GameSide.Client) {
-            return Map_1.RpgCommonMap.bufferClient.get(this.map);
+        if (this.gameEngine.side == GameSide.Client) {
+            return RpgCommonMap.bufferClient.get(this.map);
         }
-        return Map_1.RpgCommonMap.buffer.get(this.map);
+        return RpgCommonMap.buffer.get(this.map);
     }
     /**
     *
@@ -206,7 +193,7 @@ class AbstractObject {
         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);
+            this.hitbox = new SAT.Box(this._hitboxPos, obj.hitbox.width, obj.hitbox.height);
         }
     }
     /**
@@ -229,7 +216,7 @@ class AbstractObject {
             this.width = map.tileWidth;
             this.height = map.tileHeight;
         }
-        this.hitbox = new sat_1.default.Box(this._hitboxPos, width, height);
+        this.hitbox = new SAT.Box(this._hitboxPos, width, height);
         this.wHitbox = width;
         this.hHitbox = height;
         this.updateInVirtualGrid();
@@ -248,7 +235,7 @@ class AbstractObject {
     }
     directionToAngle(direction) {
         const angle = (direction < 2 ? +direction + 2 : direction - 2) * 90;
-        return Utils_1.toRadians(angle);
+        return toRadians(angle);
     }
     /** @internal */
     defineNextPosition(direction, deltaTimeInt) {
@@ -257,7 +244,7 @@ class AbstractObject {
             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);
+        return new Vector2d(~~computePosition('x'), ~~computePosition('y'), ~~this.position.z);
     }
     /** @internal */
     setPosition({ x, y, tileX, tileY }, move = true) {
@@ -272,20 +259,20 @@ class AbstractObject {
             this.posY = tileY * tileHeight;
     }
     /** @internal */
-    triggerCollisionWith(type) {
+    async triggerCollisionWith(type) {
         for (let collisionWith of this.collisionWith) {
-            if (collisionWith instanceof Shape_1.RpgShape) {
+            if (collisionWith instanceof RpgShape) {
                 const goMap = collisionWith.getProperty('go-map');
                 if (goMap && 'changeMap' in this)
-                    this.changeMap(goMap);
+                    await this.changeMap(goMap);
             }
             else {
                 if (type == AbstractObject.ACTIONS.ACTION) {
                     if ('onAction' in collisionWith)
-                        collisionWith.execMethod('onAction', [this]);
+                        await collisionWith.execMethod('onAction', [this]);
                 }
                 else if ('onPlayerTouch' in collisionWith)
-                    collisionWith.execMethod('onPlayerTouch', [this]);
+                    await collisionWith.execMethod('onPlayerTouch', [this]);
             }
         }
     }
@@ -293,7 +280,7 @@ class AbstractObject {
     zCollision(other) {
         const z = this.position.z;
         const otherZ = other.position.z;
-        return Utils_1.intersection([z, z + this.height], [otherZ, otherZ + other.height]);
+        return intersection([z, z + this.height], [otherZ, otherZ + other.height]);
     }
     /** @internal */
     moveByDirection(direction, deltaTimeInt) {
@@ -346,258 +333,248 @@ class AbstractObject {
         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))) {
+    async collisionObjects(playerSizeBox, hitbox, triggers) {
+        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.testPolyCollision(HitType.Box, hitbox, event.hitbox);
+            for (let shape of this.shapes) {
+                await this.collisionWithShape(shape, event);
+            }
+            for (let shape of event.shapes) {
+                await event.collisionWithShape(shape, this);
+            }
+            if (triggers?.near)
+                triggers.near(event);
+            if (collided) {
+                this.collisionWith.push(event);
+                this.triggerCollisionWith();
+                let throughOtherPlayer = false;
+                if (event.type == PlayerType.Player && this.type == PlayerType.Player) {
+                    if (!(event.throughOtherPlayer || this.throughOtherPlayer)) {
                         boolFound = true;
-                        if (!(triggers === null || triggers === void 0 ? void 0 : triggers.allSearch))
+                        if (!triggers?.allSearch)
                             return true;
                     }
+                    else {
+                        throughOtherPlayer = true;
+                    }
                 }
-                if (boolFound) {
-                    if (triggers === null || triggers === void 0 ? void 0 : triggers.collision)
-                        triggers.collision(event);
+                if (!throughOtherPlayer && (!(event.through || this.through))) {
+                    boolFound = true;
+                    if (!triggers?.allSearch)
+                        return true;
                 }
             }
-            return boolFound;
-        });
+            if (boolFound) {
+                if (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();
+    async collisionWithShape(shape, player, nextPosition) {
+        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.createObjectHitbox(position.x, position.y, position.z, hitbox.w, hitbox.h);
+        let collided = Hit.testPolyCollision(shape.type, hitboxObj, shape.hitbox);
+        const playerPositionSaved = player.position.copy();
+        // Position can changed after enter or exit shape. So, we need to verify if position changed and update if z is changed
+        // If X or Y changed, we need to return true, it means that stop the current movement, and apply the new position
+        const verifyIfPositionChanged = () => {
+            if (this.position.z != playerPositionSaved.z && nextPosition) {
+                nextPosition.z = this.position.z;
             }
-            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);
-            const playerPositionSaved = player.position.copy();
-            // Position can changed after enter or exit shape. So, we need to verify if position changed and update if z is changed
-            // If X or Y changed, we need to return true, it means that stop the current movement, and apply the new position
-            const verifyIfPositionChanged = () => {
-                if (this.position.z != playerPositionSaved.z && nextPosition) {
-                    nextPosition.z = this.position.z;
-                }
-                if (this.position.x != playerPositionSaved.x || this.position.y != playerPositionSaved.y) {
-                    return true;
-                }
-            };
-            if (collided) {
-                this._collisionWithShapes.push(shape);
-                // TODO: in shape after map load
-                if (!collision)
-                    yield shape.in(this);
-                if (verifyIfPositionChanged() === true)
-                    return true;
-                this.triggerCollisionWith();
-                if (collision)
-                    return true;
+            if (this.position.x != playerPositionSaved.x || this.position.y != playerPositionSaved.y) {
+                return true;
             }
-            else {
-                yield shape.out(this);
-                if (verifyIfPositionChanged() === true)
+        };
+        if (collided) {
+            this._collisionWithShapes.push(shape);
+            // TODO: in shape after map load
+            if (!collision)
+                await shape.in(this);
+            if (verifyIfPositionChanged() === true)
+                return true;
+            this.triggerCollisionWith();
+            if (collision)
+                return true;
+        }
+        else {
+            await shape.out(this);
+            if (verifyIfPositionChanged() === true)
+                return true;
+        }
+        return false;
+    }
+    async collisionShapes(playerSizeBox, nextPosition, triggers) {
+        const map = this.mapInstance;
+        if (!map)
+            return false;
+        const shapes = this.gameEngine.world.getShapesOfGroup(this.map);
+        const shapesInGrid = this.gameEngine.side == 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?.near)
+                triggers.near(shape);
+            const bool = await this.collisionWithShape(shape, this, nextPosition);
+            if (bool) {
+                if (triggers?.collision)
+                    triggers.collision(shape);
+                boolFound = true;
+                if (!triggers?.allSearch)
                     return true;
             }
-            return false;
-        });
+        }
+        return boolFound;
     }
-    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;
-                }
+    async computeNextPositionByTarget(nextPosition, target) {
+        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 Vector2dZero();
+        let contenders = 0;
+        const hitbox = Hit.createObjectHitbox(nextPosition.x, nextPosition.y, nextPosition.z, this.hitbox.w, this.hitbox.h);
+        const createObstacle = function (x, y, radius) {
+            const obstacle = new 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 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);
+            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.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 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));
         });
+        const playerSizeBox = this.getSizeMaxShape(nextPosition.x, nextPosition.y);
+        await this.collisionObjects(playerSizeBox, hitbox, {
+            collision: (event) => {
+                const { x, y } = event.position;
+                createObstacle(x, y, event.hitbox.w);
+            },
+            allSearch: true
+        });
+        await 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;
+    async isCollided(nextPosition, options = {}) {
+        this.collisionWith = [];
+        this._collisionWithTiles = [];
+        const prevMapId = this.map;
+        const hitbox = 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?.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;
             }
-            // if there is a change of map after a move, the moves are not changed
-            if (prevMapId != this.map) {
+            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 = await this.autoChangeMap(nextPosition);
+            if (changeMap) {
                 return true;
             }
-            return collided;
-        });
+        }
+        const playerSizeBox = this.getSizeMaxShape(nextPosition.x, nextPosition.y);
+        if (await this.collisionObjects(playerSizeBox, hitbox, options)) {
+            if (!options.allSearch)
+                return true;
+            else
+                collided = true;
+        }
+        if (await 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)
@@ -623,8 +600,11 @@ class AbstractObject {
      * @memberof Player
      */
     attachShape(obj) {
-        obj.name = (obj.name || Utils_1.generateUID());
-        const shape = new Shape_1.RpgShape(Object.assign(Object.assign({}, obj), { fixEvent: this }));
+        obj.name = (obj.name || generateUID());
+        const shape = new RpgShape({
+            ...obj,
+            fixEvent: this
+        });
         this.shapes.push(shape);
         return shape;
     }
@@ -647,18 +627,18 @@ class AbstractObject {
         const diff = Math.abs(x - nx) > Math.abs(y - ny);
         if (diff) {
             if (nx > x) {
-                this.changeDirection(types_1.Direction.Right);
+                this.changeDirection(Direction.Right);
             }
             else {
-                this.changeDirection(types_1.Direction.Left);
+                this.changeDirection(Direction.Left);
             }
         }
         else {
             if (ny > y) {
-                this.changeDirection(types_1.Direction.Down);
+                this.changeDirection(Direction.Down);
             }
             else {
-                this.changeDirection(types_1.Direction.Up);
+                this.changeDirection(Direction.Up);
             }
         }
     }
@@ -682,12 +662,12 @@ class AbstractObject {
         let count = 0;
         const lastPositions = [];
         this.stopMoveTo();
-        this.destroyMove$ = new rxjs_1.Subject();
+        this.destroyMove$ = new Subject();
         const { infinite, onStuck, onComplete } = options;
         const getPosition = () => {
             let pos;
             if ('x' in positionTarget) {
-                pos = new Vector2d_1.Vector2d(positionTarget.x, positionTarget.y);
+                pos = new Vector2d(positionTarget.x, positionTarget.y);
             }
             else {
                 pos = positionTarget.position;
@@ -695,10 +675,10 @@ class AbstractObject {
             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) => {
+            .pipe(takeUntil(this.destroyMove$), takeUntil(this._destroy$), mergeMap(() => from(this.computeNextPositionByTarget(this.position.copy(), getPosition()))), map((position) => {
             this.autoChangeDirection(position);
             return this.position.set(position);
-        }), rxjs_1.tap((position) => {
+        }), tap((position) => {
             lastPositions[i] = position.copy();
             i++;
             count++;
@@ -706,10 +686,10 @@ class AbstractObject {
                 i = 0;
             }
             if (lastPositions[2] && lastPositions[0].isEqual(lastPositions[2])) {
-                onStuck === null || onStuck === void 0 ? void 0 : onStuck(count);
+                onStuck?.(count);
             }
             else if (this.position.isEqual(getPosition())) {
-                onComplete === null || onComplete === void 0 ? void 0 : onComplete();
+                onComplete?.();
                 if (!infinite) {
                     this.stopMoveTo();
                 }
@@ -720,16 +700,14 @@ class AbstractObject {
         }));
     }
     /** @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;
-        });
+    async move(nextPosition) {
+        this.autoChangeDirection(nextPosition);
+        const notCollided = !(await this.isCollided(nextPosition));
+        if (notCollided || !this.checkCollision) {
+            this.position = nextPosition.copy();
+            await RpgPlugin.emit(HookServer.PlayerMove, this);
+        }
+        return true;
     }
     /**
      * Retrieves all shapes where the player is located
@@ -793,11 +771,11 @@ class AbstractObject {
     get nbPixelInTile() {
         const direction = this.getDirection();
         switch (direction) {
-            case types_1.Direction.Down:
-            case types_1.Direction.Up:
+            case Direction.Down:
+            case Direction.Up:
                 return Math.floor(this.mapInstance.tileHeight / this.speed);
-            case types_1.Direction.Left:
-            case types_1.Direction.Right:
+            case Direction.Left:
+            case Direction.Right:
                 return Math.floor(this.mapInstance.tileWidth / this.speed);
             default:
                 return NaN;
@@ -831,13 +809,10 @@ class AbstractObject {
         };
     }
     /** @internal */
-    execMethod(methodName, methodData, instance) {
-        return __awaiter(this, void 0, void 0, function* () { });
-    }
+    async execMethod(methodName, methodData, instance) { }
     /** @internal */
     onAction() { }
     /** @internal */
     onPlayerTouch() { }
 }
-exports.AbstractObject = AbstractObject;
 //# sourceMappingURL=AbstractObject.js.map