@rpgjs/server 4.2.2 → 5.0.0-alpha.0

package/lib/Player/MoveManager.d.ts

@@ -1,333 +0,0 @@
-import { Direction, RpgShape, Vector2d } from '@rpgjs/common';
-import { Behavior, ClientMode, MoveMode, MoveTo, PositionXY, SocketEvents } from '@rpgjs/types';
-import { Observable, Subject } from 'rxjs';
-import { RpgServerEngine } from '../server';
-import { RpgEvent, RpgPlayer } from './Player';
-type CallbackTileMove = (player: RpgPlayer, map: any) => Direction[];
-type CallbackTurnMove = (player: RpgPlayer, map: any) => string;
-type Routes = (string | Promise<any> | Direction | Direction[] | Function)[];
-export declare enum Frequency {
-    Lowest = 600,
-    Lower = 400,
-    Low = 200,
-    High = 100,
-    Higher = 50,
-    Highest = 25,
-    None = 0
-}
-export declare enum Speed {
-    Slowest = 0.2,
-    Slower = 0.5,
-    Slow = 1,
-    Normal = 3,
-    Fast = 5,
-    Faster = 7,
-    Fastest = 10
-}
-/**
-* @title Move
-* @enum {Object}
-*
-* Move.right(repeat=1) | Movement of a number of pixels on the right
-* Move.left(repeat=1) | Movement of a number of pixels on the left
-* Move.up(repeat=1) | Movement of a number of pixels on the up
-* Move.down(repeat=1) | Movement of a number of pixels on the down
-* Move.random(repeat=1) | Movement of a number of pixels in a random direction
-* Move.towardPlayer(player, repeat=1) | Moves a number of pixels in the direction of the designated player
-* Move.awayFromPlayer(player, repeat=1) | Moves a number of pixels in the opposite direction of the designated player
-* Move.tileRight(repeat=1) | Movement of a number of tiles on the right
-* Move.tileLeft(repeat=1) | Movement of a number of tiles on the left
-* Move.tileUp(repeat=1) | Movement of a number of tiles on the up
-* Move.tileDown(repeat=1) | Movement of a number of tiles on the down
-* Move.tileRandom(repeat=1) | Movement of a number of tiles in a random direction
-* Move.tileTowardPlayer(player, repeat=1) | Moves a number of tiles in the direction of the designated player
-* Move.tileAwayFromPlayer(player, repeat=1) | Moves a number of tiles in the opposite direction of the designated player
-* Move.turnRight() | Turn to the right
-* Move.turnLeft() | Turn to the left
-* Move.turnUp() | Turn to the up
-* Move.turnDown() | Turn to the down
-* Move.turnRandom() | Turn to random direction
-* Move.turnAwayFromPlayer(player) | Turns in the opposite direction of the designated player
-* Move.turnTowardPlayer(player) | Turns in the direction of the designated player
-* @memberof Move
-* */
-declare class MoveList {
-    repeatMove(direction: Direction, repeat: number): Direction[];
-    private repeatTileMove;
-    right(repeat?: number): Direction[];
-    left(repeat?: number): Direction[];
-    up(repeat?: number): Direction[];
-    down(repeat?: number): Direction[];
-    wait(sec: number): Promise<unknown>;
-    random(repeat?: number): Direction[];
-    tileRight(repeat?: number): CallbackTileMove;
-    tileLeft(repeat?: number): CallbackTileMove;
-    tileUp(repeat?: number): CallbackTileMove;
-    tileDown(repeat?: number): CallbackTileMove;
-    tileRandom(repeat?: number): CallbackTileMove;
-    private _awayFromPlayerDirection;
-    private _towardPlayerDirection;
-    private _awayFromPlayer;
-    towardPlayer(player: RpgPlayer, repeat?: number): (player: RpgPlayer, map: any) => any;
-    tileTowardPlayer(player: RpgPlayer, repeat?: number): (player: RpgPlayer, map: any) => any;
-    awayFromPlayer(player: RpgPlayer, repeat?: number): CallbackTileMove;
-    tileAwayFromPlayer(player: RpgPlayer, repeat?: number): CallbackTileMove;
-    turnLeft(): string;
-    turnRight(): string;
-    turnUp(): string;
-    turnDown(): string;
-    turnRandom(): string;
-    turnAwayFromPlayer(otherPlayer: RpgPlayer): CallbackTurnMove;
-    turnTowardPlayer(otherPlayer: RpgPlayer): CallbackTurnMove;
-}
-export declare const Move: MoveList;
-export declare class MoveManager {
-    private movingSubscription;
-    private _infiniteRoutes;
-    private _finishRoute;
-    /**
-     * Changes the player's speed
-     *
-     * ```ts
-     * player.speed = 1
-     * ```
-     *
-     * You can use Speed enum
-     *
-     * ```ts
-     * import { Speed } from '@rpgjs/server'
-     * player.speed = Speed.Slow
-     * ```
-     *
-     * @title Change Speed
-     * @prop {number} player.speed
-     * @enum {number}
-     *
-     * Speed.Slowest | 0.2
-     * Speed.Slower | 0.5
-     * Speed.Slow | 1
-     * Speed.Normal | 3
-     * Speed.Fast | 5
-     * Speed.Faster | 7
-     * Speed.Fastest | 10
-     * @default 3
-     * @memberof MoveManager
-     * */
-    speed: number;
-    /**
-     * Blocks the movement. The player will not be able to move even if he presses the direction keys on the keyboard.
-     *
-     * ```ts
-     * player.canMove = false
-     * ```
-     *
-     * @title Block movement
-     * @prop {boolean} player.canMove
-     * @default true
-     * @memberof MoveManager
-     * */
-    canMove: boolean;
-    /**
-    * The player passes through the other players (or vice versa). But the player does not go through the events.
-    *
-    * ```ts
-    * player.throughOtherPlayer = true
-    * ```
-    *
-    * @title Go through to other player
-    * @prop {boolean} player.throughOtherPlayer
-    * @default true
-    * @memberof MoveManager
-    * */
-    throughOtherPlayer: boolean;
-    /**
-     * The player goes through the event or the other players (or vice versa)
-     *
-     * ```ts
-     * player.through = true
-     * ```
-     *
-     * @title Go through the player
-     * @prop {boolean} player.through
-     * @default false
-     * @memberof MoveManager
-     * */
-    through: boolean;
-    /**
-     * The frequency allows to put a stop time between each movement in the array of the moveRoutes() method.
-     * The value represents a dwell time in milliseconds. The higher the value, the slower the frequency.
-     *
-     * ```ts
-     * player.frequency = 400
-     * ```
-     *
-     * You can use Frequency enum
-     *
-     * ```ts
-     * import { Frequency } from '@rpgjs/server'
-     * player.frequency = Frequency.Low
-     * ```
-     *
-     * @title Change Frequency
-     * @prop {number} player.speed
-     * @enum {number}
-     *
-     * Frequency.Lowest | 600
-     * Frequency.Lower | 400
-     * Frequency.Low | 200
-     * Frequency.High | 100
-     * Frequency.Higher | 50
-     * Frequency.Highest | 25
-     * Frequency.None | 0
-     * @default 0
-     * @memberof MoveManager
-     * */
-    frequency: number;
-    /**
-     * Gives an itinerary.
-     *
-     * You can create your own motion function:
-     *
-     * ```ts
-     * import { Direction } from '@rpgjs/server'
-     *
-     * const customMove = () => {
-     *      return [Direction.Left, Direction.Up]
-     * }
-     *
-     * player.moveRoutes([ customMove() ])
-     * ```
-     *
-     * Your function can also return a function:
-     *
-     *  ```ts
-     * import { Direction, RpgPlayer } from '@rpgjs/server'
-     *
-     * // This function can be found in another file. By returning a function, you have access to the player who is making a move.
-     * const customMove = (otherPlayer: RpgPlayer) => {
-     *      return (player: RpgPlayer, map) => {
-     *          return otherPlayer.position.x > player.position.x ? Direction.Left : Direction.Right
-     *      }
-     * }
-     *
-     * player.moveRoutes([ customMove(otherPlayer) ])
-     * ```
-     *
-     * the function contains two parameters:
-     *
-     * - `player`: the player concerned by the movement
-     * - `map`: The information of the current map
-     *
-     * @title Give an itinerary
-     * @method player.moveRoutes(routes)
-     * @param {Array<Move>} routes
-     * @returns {Promise}
-     * @memberof MoveManager
-     * @example
-     *
-     * ```ts
-     * import { Move } from '@rpgjs/server'
-     *
-     * await player.moveRoutes([ Move.tileLeft(), Move.tileDown(2) ])
-     * // The path is over when the promise is resolved
-     * ```
-     */
-    moveRoutes(routes: Routes): Promise<boolean>;
-    /**
-     * Giving a path that repeats itself in a loop to a character
-     *
-     * You can stop the movement at any time with `breakRoutes()` and replay it with `replayRoutes()`.
-     *
-     * @title Infinite Move Routes
-     * @method player.infiniteMoveRoute(routes)
-     * @param {Array<Move>} routes
-     * @returns {void}
-     * @memberof MoveManager
-     * @example
-     *
-     * ```ts
-     * import { Move } from '@rpgjs/server'
-     *
-     * player.infiniteMoveRoute([ Move.tileRandom() ])
-     * ```
-     */
-    infiniteMoveRoute(routes: Routes): void;
-    /**
-     * Works only for infinite movements. You must first use the method `infiniteMoveRoute()`
-     *
-     * @title Stop an infinite movement
-     * @method player.breakRoutes(force=false)
-     * @param {boolean} [force] Forces the stop of the infinite movement
-     * @returns {void}
-     * @memberof MoveManager
-     * @example
-     *
-     * ```ts
-     * import { Move } from '@rpgjs/server'
-     *
-     * player.infiniteMoveRoute([ Move.tileRandom() ])
-     * player.breakRoutes(true)
-     * ```
-     */
-    breakRoutes(force?: boolean): void;
-    /**
-     * Works only for infinite movements. You must first use the method `infiniteMoveRoute()`
-     * If the road was stopped with `breakRoutes()`, you can restart it with this method
-     *
-     * @title Replay an infinite movement
-     * @method player.replayRoutes()
-     * @returns {void}
-     * @memberof MoveManager
-     * @example
-     *
-     * ```ts
-     * import { Move } from '@rpgjs/server'
-     *
-     * player.infiniteMoveRoute([ Move.tileRandom() ])
-     * player.breakRoutes(true)
-     * player.replayRoutes()
-     * ```
-     */
-    replayRoutes(): void;
-    /**
-     * Move the event to another event, a player, a shape or a specific position.
-     * The event will avoid obstacles, but you can tell if it is stuck or has completed its path
-     *
-     * @title Move To
-     * @method player.moveTo()
-     * @param {RpgPlayer|RpgEvent|RpgShape|Position} target the target
-     * @param {object} [options] - animate. Set a boolean to use default parameters
-     * @param {boolean} [options.infinite=false] - moves infinitely towards the target, you have to stop its movement manually with the method `stopMoveTo()`
-     * @param {() => void} [options.onComplete] - Callback when the event arrives at the destination
-     * @param {(duration:number) => void} [options.onStuck] - callback when the event is blocked against a wall. Duration gives you the duration (in frames) of the blocking time
-     * @returns {Observable<void>}
-     * @since 3.2.0
-     * @memberof MoveManager
-     * @example
-     *
-     * ```ts
-     * import { Move } from '@rpgjs/server'
-     *
-     * player.moveTo(otherPlayer).subscribe()
-     * ```
-     */
-    moveTo(event: RpgEvent, options?: MoveTo): Observable<void>;
-    moveTo(player: RpgPlayer, options?: MoveTo): Observable<void>;
-    moveTo(position: PositionXY, options?: MoveTo): Observable<void>;
-    moveTo(shape: RpgShape, options?: MoveTo): Observable<void>;
-    setMoveMode(mode: MoveMode): void;
-}
-export interface MoveManager {
-    moveByDirection: (direction: Direction, deltaTimeInt: number) => Promise<boolean>;
-    changeDirection: (direction: Direction) => boolean;
-    getCurrentMap: any;
-    checkCollision: boolean;
-    clientModeMove: ClientMode;
-    behavior: Behavior;
-    emit(name: SocketEvents, params: any): any;
-    id: string;
-    server: RpgServerEngine;
-    position: Vector2d;
-    _destroy$: Subject<void>;
-}
-export {};