@rpgjs/common 3.0.1 → 3.2.0

package/lib/Player.d.ts

@@ -1,52 +1,20 @@
-import { RpgShape } from './Shape';
-import SAT from 'sat';
-import { TileInfo } from './Map';
-import { RpgCommonGame } from './Game';
-export declare type Position = {
-    x: number;
-    y: number;
-    z: number;
-};
-export declare enum Direction {
-    Up = 1,
-    Down = 3,
-    Left = 4,
-    Right = 2,
-    UpRight = 1.5,
-    DownRight = 2.5,
-    DownLeft = 3.5,
-    UpLeft = 2.5
-}
+import { PendingMove } from '@rpgjs/types';
+import { AbstractObject } from './AbstractObject';
 export declare const LiteralDirection: {
     1: string;
     2: string;
     3: string;
     4: string;
 };
-export declare enum PlayerType {
-    Player = "player",
-    Event = "event",
-    Shape = "shape"
-}
-export declare class RpgCommonPlayer {
-    private gameEngine;
-    playerId: string;
-    map: string;
+export declare class RpgCommonPlayer extends AbstractObject {
+    events: any[];
     layerName: string;
     components: any[];
-    height: number;
-    width: number;
-    canMove: boolean;
-    speed: number;
-    events: any[];
-    direction: number;
-    private collisionWith;
-    private _collisionWithTiles;
-    hitbox: SAT.Box;
-    pendingMove: {
-        input: string;
-        frame: number;
-    }[];
+    data: any;
+    pendingMove: PendingMove;
+    inputsTimestamp: {
+        [inputName: string]: number;
+    };
     /**
     * Display/Hide the GUI attached to this sprite
     *
@@ -55,259 +23,4 @@ export declare class RpgCommonPlayer {
     * @memberof RpgSprite
     * */
     guiDisplay: boolean;
-    inShapes: {
-        [shapeId: string]: RpgShape;
-    };
-    private shapes;
-    private _position;
-    private _hitboxPos;
-    static get ACTIONS(): {
-        IDLE: number;
-        RUN: number;
-        ACTION: number;
-    };
-    constructor(gameEngine: RpgCommonGame, playerId: string);
-    get id(): string;
-    set id(str: string);
-    updateInVirtualGrid(): void;
-    /**
-     * 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: Position);
-    get position(): Position;
-    get worldPositionX(): number;
-    get worldPositionY(): number;
-    set posX(val: any);
-    set posY(val: any);
-    set posZ(val: any);
-    /**
-    *
-    * 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(): TileInfo[];
-    /**
-     *
-     * 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(): RpgCommonPlayer[];
-    /**
-     * 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: {
-        width: number;
-        height: number;
-        hitbox?: {
-            width: number;
-            height: number;
-        };
-    }): void;
-    /**
-     * 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: number, height: number): void;
-    set wHitbox(val: any);
-    set hHitbox(val: any);
-    get wHitbox(): any;
-    get hHitbox(): any;
-    private directionToAngle;
-    /**
-     * 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: number, y: number, z?: number, hitbox?: SAT.Box): TileInfo;
-    isCollided(nextPosition: Position): Promise<boolean>;
-    /**
-     * 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: {
-        width: number;
-        height: number;
-        positioning?: string;
-        name?: string;
-        properties?: object;
-    }): RpgShape;
-    /**
-     * 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(): RpgShape[];
-    /**
-     * 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(): RpgShape[];
-    /**
-    * Get the current direction.
-    *
-    * ```ts
-    * player.getDirection()
-    * ```
-    *
-    * @title Get Direction
-    * @method player.getDirection()
-    * @returns {Direction | number} direction
-    * @memberof Player
-    */
-    getDirection(direction?: Direction | number): string | number;
-    /**
-    * 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: Direction): boolean;
-    /**
-     * 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(): any;
-}
-export interface RpgCommonPlayer {
-    readonly type: string;
-    through: boolean;
-    throughOtherPlayer: boolean;
-    autoChangeMap?(nextPosition: Position): Promise<boolean>;
-    execMethod(methodName: string, methodData?: any, instance?: any): any;
 }