@rpgjs/server 4.3.0 → 5.0.0-alpha.1

package/lib/Player/ElementManager.d.ts

@@ -1,108 +0,0 @@
-import { RpgPlayer } from './Player';
-import { ItemFixture } from './ItemFixture';
-import { ItemInstance } from '@rpgjs/database';
-export declare class ElementManager extends ItemFixture {
-    _elementsEfficiency: {
-        rate: number;
-        element: any;
-    }[];
-    /**
-    * Recovers the player's elements defense on inventory.  This list is generated from the `elementsDefense` property defined on the weapons or armors equipped.
-    * If several items have the same element, only the highest rate will be taken into account.
-    *
-    * ```ts
-    * import { Armor } from '@rpgjs/server'
-    *
-    * enum Elements {
-    *   Fire = 'fire'
-    * }
-    *
-    * @Armor({
-    *      name: 'Shield',
-    *      elementsDefense: [{ rate: 1, element: Elements.Fire }]
-    * })
-    * class Shield {}
-    *
-    * @Armor({
-    *      name: 'FireShield',
-    *      elementsDefense: [{ rate: 0.5, element: Elements.Fire }]
-    * })
-    * class FireShield {}
-    *
-    * player.addItem(Shield)
-    * player.addItem(FireShield)
-    * player.equip(Shield)
-    * player.equip(FireShield)
-    *
-    * console.log(player.elementsDefense) // [{ rate: 1, element: 'fire' }]
-    * ```
-    * @title Get Elements Defense
-    * @prop {Array<{ rate: number, element: Element}>} player.elementsDefense
-    * @readonly
-    * @memberof ElementManager
-    * */
-    get elementsDefense(): {
-        rate: number;
-        element: any;
-    }[];
-    /**
-    * Set or retrieves all the elements where the player is vulnerable or not.
-    *
-    * ```ts
-    * import { Class } from '@rpgjs/server'
-    *
-    * enum Elements {
-    *   Fire = 'fire',
-    *   Ice = 'ice'
-    * }
-    *
-    * @Class({
-    *      name: 'Fighter',
-    *      elementsEfficiency: [{ rate: 1, element: Elements.Fire }]
-    * })
-    * class Hero {}
-    *
-    * player.setClass(Hero)
-    *
-    * console.log(player.elementsEfficiency) // [{ rate: 1, element: 'fire' }]
-    *
-    * player.elementsEfficiency = [{ rate: 2, element: Elements.Ice }]
-    *
-    * console.log(player.elementsEfficiency) // [{ rate: 1, element: 'fire' }, { rate: 2, element: 'ice' }]
-    * ```
-    * @title Set/Get Elements Efficiency
-    * @prop {Array<{ rate: number, element: Element}>} player.elementsEfficiency
-    * @memberof ElementManager
-    * */
-    get elementsEfficiency(): {
-        rate: number;
-        element: any;
-    }[];
-    set elementsEfficiency(val: {
-        rate: number;
-        element: any;
-    }[]);
-    /**
-     * Retrieves a array of elements assigned to the player and the elements of the weapons / armor equipped
-     *
-     * ```ts
-     * console.log(player.elements)
-     * ```
-     * @title Get Elements
-     * @prop {Array<Element>} player.elements
-     * @readonly
-     * @memberof ElementManager
-     * */
-    get elements(): {
-        rate: number;
-        element: string;
-    }[];
-    coefficientElements(otherPlayer: RpgPlayer): number;
-}
-export interface ElementManager {
-    equipments: ItemInstance[];
-    getFormulas: (name: string) => any;
-    _class: any;
-}
-export interface ElementManager extends ItemFixture {
-}

package/lib/Player/ElementManager.js

@@ -1,120 +0,0 @@
-import { Utils } from '@rpgjs/common';
-import { ItemFixture } from './ItemFixture.js';
-const { arrayUniq, applyMixins } = Utils;
-export class ElementManager extends ItemFixture {
-    /**
-    * Recovers the player's elements defense on inventory.  This list is generated from the `elementsDefense` property defined on the weapons or armors equipped.
-    * If several items have the same element, only the highest rate will be taken into account.
-    *
-    * ```ts
-    * import { Armor } from '@rpgjs/server'
-    *
-    * enum Elements {
-    *   Fire = 'fire'
-    * }
-    *
-    * @Armor({
-    *      name: 'Shield',
-    *      elementsDefense: [{ rate: 1, element: Elements.Fire }]
-    * })
-    * class Shield {}
-    *
-    * @Armor({
-    *      name: 'FireShield',
-    *      elementsDefense: [{ rate: 0.5, element: Elements.Fire }]
-    * })
-    * class FireShield {}
-    *
-    * player.addItem(Shield)
-    * player.addItem(FireShield)
-    * player.equip(Shield)
-    * player.equip(FireShield)
-    *
-    * console.log(player.elementsDefense) // [{ rate: 1, element: 'fire' }]
-    * ```
-    * @title Get Elements Defense
-    * @prop {Array<{ rate: number, element: Element}>} player.elementsDefense
-    * @readonly
-    * @memberof ElementManager
-    * */
-    get elementsDefense() {
-        return this.getFeature('elementsDefense', 'element');
-    }
-    /**
-    * Set or retrieves all the elements where the player is vulnerable or not.
-    *
-    * ```ts
-    * import { Class } from '@rpgjs/server'
-    *
-    * enum Elements {
-    *   Fire = 'fire',
-    *   Ice = 'ice'
-    * }
-    *
-    * @Class({
-    *      name: 'Fighter',
-    *      elementsEfficiency: [{ rate: 1, element: Elements.Fire }]
-    * })
-    * class Hero {}
-    *
-    * player.setClass(Hero)
-    *
-    * console.log(player.elementsEfficiency) // [{ rate: 1, element: 'fire' }]
-    *
-    * player.elementsEfficiency = [{ rate: 2, element: Elements.Ice }]
-    *
-    * console.log(player.elementsEfficiency) // [{ rate: 1, element: 'fire' }, { rate: 2, element: 'ice' }]
-    * ```
-    * @title Set/Get Elements Efficiency
-    * @prop {Array<{ rate: number, element: Element}>} player.elementsEfficiency
-    * @memberof ElementManager
-    * */
-    get elementsEfficiency() {
-        if (this._class) {
-            return [...this._elementsEfficiency, ...this._class.elementsEfficiency];
-        }
-        return this._elementsEfficiency;
-    }
-    set elementsEfficiency(val) {
-        this._elementsEfficiency = val;
-    }
-    /**
-     * Retrieves a array of elements assigned to the player and the elements of the weapons / armor equipped
-     *
-     * ```ts
-     * console.log(player.elements)
-     * ```
-     * @title Get Elements
-     * @prop {Array<Element>} player.elements
-     * @readonly
-     * @memberof ElementManager
-     * */
-    get elements() {
-        let elements = [];
-        for (let item of this.equipments) {
-            if (item.elements) {
-                elements = [...elements, ...item.elements];
-            }
-        }
-        return arrayUniq(elements);
-    }
-    coefficientElements(otherPlayer) {
-        const atkPlayerElements = otherPlayer.elements;
-        const playerElements = this.elementsEfficiency;
-        let coefficient = 1;
-        for (let atkElement of atkPlayerElements) {
-            const elementPlayer = playerElements.find(el => el.element == atkElement.element);
-            const elementPlayerDef = this.elementsDefense.find(el => el.element == atkElement.element);
-            if (!elementPlayer)
-                continue;
-            const fn = this.getFormulas('coefficientElements');
-            if (!fn) {
-                return coefficient;
-            }
-            coefficient += fn(atkElement, elementPlayer, elementPlayerDef || { rate: 0 });
-        }
-        return coefficient;
-    }
-}
-applyMixins(ElementManager, [ItemFixture]);
-//# sourceMappingURL=ElementManager.js.map

package/lib/Player/ElementManager.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ElementManager.js","sourceRoot":"","sources":["../../src/Player/ElementManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAO,eAAe,CAAA;AAEtC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C,MAAM,EACF,SAAS,EACT,WAAW,EACd,GAAG,KAAK,CAAA;AAET,MAAM,OAAO,cAAe,SAAQ,WAAW;IAG1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkCI;IACL,IAAI,eAAe;QACf,OAAO,IAAI,CAAC,UAAU,CAAC,iBAAiB,EAAE,SAAS,CAAC,CAAA;IACxD,CAAC;IAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA4BI;IACL,IAAI,kBAAkB;QAClB,IAAI,IAAI,CAAC,MAAM,EAAE;YACb,OAAY,CAAC,GAAG,IAAI,CAAC,mBAAmB,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAA;SAC/E;QACD,OAAO,IAAI,CAAC,mBAAmB,CAAA;IACnC,CAAC;IAED,IAAI,kBAAkB,CAAC,GAAG;QACtB,IAAI,CAAC,mBAAmB,GAAG,GAAG,CAAA;IAClC,CAAC;IAED;;;;;;;;;;SAUK;IACL,IAAI,QAAQ;QAIR,IAAI,QAAQ,GAAQ,EAAE,CAAA;QACtB,KAAK,IAAI,IAAI,IAAI,IAAI,CAAC,UAAU,EAAE;YAC9B,IAAI,IAAI,CAAC,QAAQ,EAAE;gBACf,QAAQ,GAAG,CAAC,GAAG,QAAQ,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAA;aAC7C;SACJ;QACD,OAAO,SAAS,CAAC,QAAQ,CAAC,CAAA;IAC9B,CAAC;IAED,mBAAmB,CAAC,WAAsB;QACtC,MAAM,iBAAiB,GAAQ,WAAW,CAAC,QAAQ,CAAA;QACnD,MAAM,cAAc,GAAQ,IAAI,CAAC,kBAAkB,CAAA;QACnD,IAAI,WAAW,GAAG,CAAC,CAAA;QAEnB,KAAK,IAAI,UAAU,IAAI,iBAAiB,EAAE;YACtC,MAAM,aAAa,GAAG,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,OAAO,IAAI,UAAU,CAAC,OAAO,CAAC,CAAA;YACjF,MAAM,gBAAgB,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,OAAO,IAAI,UAAU,CAAC,OAAO,CAAC,CAAA;YAC1F,IAAI,CAAC,aAAa;gBAAE,SAAQ;YAC5B,MAAM,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,qBAAqB,CAAC,CAAA;YAClD,IAAI,CAAC,EAAE,EAAE;gBACL,OAAO,WAAW,CAAA;aACrB;YACD,WAAW,IAAI,EAAE,CAAC,UAAU,EAAE,aAAa,EAAE,gBAAgB,IAAI,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAA;SAChF;QACD,OAAO,WAAW,CAAA;IACtB,CAAC;CACJ;AASD,WAAW,CAAC,cAAc,EAAE,CAAC,WAAW,CAAC,CAAC,CAAA"}

package/lib/Player/GoldManager.d.ts

@@ -1,17 +0,0 @@
-export declare class GoldManager {
-    private _gold;
-    /**
-    * You can change the game money
-    *
-    * ```ts
-    * player.gold += 100
-    * ```
-    *
-    * @title Change Gold
-    * @prop {number} player.gold
-    * @default 0
-    * @memberof GoldManager
-    * */
-    set gold(val: number);
-    get gold(): number;
-}

package/lib/Player/GoldManager.js

@@ -1,27 +0,0 @@
-export class GoldManager {
-    constructor() {
-        this._gold = 0;
-    }
-    /**
-    * You can change the game money
-    *
-    * ```ts
-    * player.gold += 100
-    * ```
-    *
-    * @title Change Gold
-    * @prop {number} player.gold
-    * @default 0
-    * @memberof GoldManager
-    * */
-    set gold(val) {
-        if (val < 0) {
-            val = 0;
-        }
-        this._gold = val;
-    }
-    get gold() {
-        return this._gold;
-    }
-}
-//# sourceMappingURL=GoldManager.js.map

package/lib/Player/GoldManager.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GoldManager.js","sourceRoot":"","sources":["../../src/Player/GoldManager.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,WAAW;IAAxB;QACY,UAAK,GAAW,CAAC,CAAA;IAwB7B,CAAC;IAtBI;;;;;;;;;;;QAWI;IACL,IAAI,IAAI,CAAC,GAAW;QAChB,IAAI,GAAG,GAAG,CAAC,EAAE;YACT,GAAG,GAAG,CAAC,CAAA;SACV;QACD,IAAI,CAAC,KAAK,GAAG,GAAG,CAAA;IACpB,CAAC;IAED,IAAI,IAAI;QACJ,OAAO,IAAI,CAAC,KAAK,CAAA;IACrB,CAAC;CACJ"}

package/lib/Player/GuiManager.d.ts

@@ -1,247 +0,0 @@
-import { RpgPlayer } from './Player';
-import { Gui } from '../Gui';
-import { DialogOptions, Choice } from '../Gui/DialogGui';
-export declare class GuiManager {
-    _gui: {
-        [id: string]: Gui;
-    };
-    /**
-     * Show a text. This is a graphical interface already built. Opens the GUI named `rpg-dialog`
-     *
-     * ```ts
-     * player.showText('Hello World')
-     * ```
-     *
-     * The method returns a promise. It is resolved when the dialog box is closed.
-     *
-     * ```ts
-     * await player.showText('Hello World')
-     * // dialog box is closed, then ...
-     * ```
-     *
-     * **Option: position**
-     *
-     * You can define how the dialog box is displayed:
-     * - top
-     * - middle
-     * - bottom
-     *
-     * (bottom by default)
-     *
-     * ```ts
-     * player.showText('Hello World', {
-     *      position: 'top'
-     * })
-     * ```
-     *
-     * **Option: fullWidth**
-     *
-     * `boolean` (true by default)
-     *
-     * Indicate that the dialog box will take the full width of the screen.
-     *
-     * ```ts
-     * player.showText('Hello World', {
-     *      fullWidth: true
-     * })
-     * ```
-     *
-     * **Option: autoClose**
-     *
-     * `boolean` (false by default)
-     *
-     * If false, the user will have to press Enter to close the dialog box.
-     *
-     *  ```ts
-     * player.showText('Hello World', {
-     *      autoClose: true
-     * })
-     * ```
-     *
-     * **Option: typewriterEffect**
-     *
-     * `boolean` (true by default)
-     *
-     * Performs a typewriter effect
-     *
-     *  ```ts
-     * player.showText('Hello World', {
-     *      typewriterEffect: false
-     * })
-     * ```
-     *
-     * **Option: talkWith**
-     *
-     * `RpgPlayer` (nothing by default)
-     *
-     * If you specify the event or another player, the other player will stop his or her movement and look in the player's direction.
-     *
-     *  ```ts
-     * // Code in an event
-     * player.showText('Hello World', {
-     *      talkWith: this
-     * })
-     * ```
-     *
-     * @title Show Text
-     * @method player.showText(text,options)
-     * @param {string} text
-     * @param {object} [options] the different options, see usage below
-     * @returns {Promise}
-     * @memberof GuiManager
-     */
-    showText(msg: string, options?: DialogOptions): Promise<any>;
-    /**
-     * Shows a dialog box with a choice. Opens the GUI named `rpg-dialog`
-     *
-     * ```ts
-     * const choice = await player.showChoices('What color do you prefer?', [
-     *      { text: 'Black', value: 'black' },
-     *      { text: 'Rather the blue', value: 'blue' },
-     *      { text: 'I don\'t have a preference!', value: 'none' }
-     * ])
-     *
-     * // If the player selects the first
-     * console.log(choice) // { text: 'Black', value: 'black' }
-     * ```
-     *
-     * @title Show Choices
-     * @method player.showChoices(text,choices)
-     * @param {string} text
-     * @param {Array<{ text: string, value: any }>} choices
-     * @param {object} [options] Same options as the openDialog method
-     * @returns {Promise<Choice | null>}
-     * @memberof GuiManager
-     */
-    showChoices(msg: string, choices: Choice[], options?: DialogOptions): Promise<Choice | null>;
-    /**
-     * Displays a notification . Opens the GUI named `rpg-notification`
-     *
-     * @title Displays a notification
-     * @method player.showNotification()
-     * @param {string} message - The message to display in the notification
-     * @param {object} options - An object containing options for the notification
-     * @param {number} options.time - The time to display the notification for (in ms). Default: 2000ms
-     * @param {string} options.icon - The icon to display in the notification. Put the identifier of the spritesheet (defined on the client side)
-     * @param {string} options.sound - The sound to play when the notification is shown. Set the sound ID (defined on the client side)
-     * @returns {void}
-     * @memberof GuiManager
-     */
-    showNotification(message: string, options?: {
-        time?: number;
-        icon?: string;
-        sound?: string;
-    }): Promise<any>;
-    /**
-     * Calls main menu. Opens the GUI named `rpg-main-menu`
-     *
-     * @title Call Main Menu
-     * @method player.callMainMenu()
-     * @returns {void}
-     * @memberof GuiManager
-     */
-    callMainMenu(): Promise<any>;
-    /**
-     * Calls shop menu. Opens the GUI named `rpg-shop`
-     *
-     * @title Call Shop Menu
-     * @method player.callShop()
-     * @returns {void}
-     * @memberof GuiManager
-     */
-    callShop(items: any[]): Promise<any>;
-    /**
-     * Call a custom Gui
-
-     * ```ts
-     * // Calls a client-side component, created with VueJS, named "inn".
-     * const gui = player.gui('inn')
-     *
-     *  // You can wait for actions on the menu. It only works if the menu is open.
-     * gui.on('accept', () => {
-     *      player.allRecovery()
-     * })
-     *
-     * // The GUI is opened by passing recoverable data on the client side.
-     * gui.open({ hello: 'world' })
-     * ```
-     *
-     * When opening the GUI, one can give options
-     *
-     * ```ts
-     * await gui.open({ hello: 'world' }, {
-     *      waitingAction: true,
-     *      blockPlayerInput: true
-     * })
-     * // After the GUI is closed
-     * ```
-     *
-     * - `blockPlayerInput`: while the GUI is open, the player can not move on the map
-     * - `waitingAction`: We explicitly wait until the GUI is closed for the promise to be resolved.
-     *
-     * @title Call custom GUI
-     * @method player.gui(guiId)
-     * @param {string} guiId
-     * @returns {Gui}
-     * @memberof GuiManager
-     */
-    gui(guiId: string): Gui;
-    /**
-     * Closes the GUI and removes it from memory
-     *
-     * @title Close custom GUI
-     * @method player.removeGui(guiId,data)
-     * @param {string} guiId
-     * @param {object} [data] Passing data if you close the GUI
-     * @returns {Gui}
-     * @memberof GuiManager
-     */
-    removeGui(guiId: string, data?: any): void;
-    private _attachedGui;
-    /**
-     * Display the GUI attached to the players
-     *
-     * If you don't specify the players as parameters, it will display the GUI of the instance
-     * But you can specify which GUIs to display by specifying the players as the first parameter
-     *
-     * @title View to GUI attached
-     * @method player.showAttachedGui(players?)
-     * @param {RpgPlayer[] | RpgPlayer} [players] The GUIs attached to the players to display
-     * @since 3.0.0-beta.5
-     * @example
-     * ```ts
-     * player.showAttachedGui()
-     * ```
-     * ```ts
-     * player.showAttachedGui(aPlayer)
-     * ```
-     * ```ts
-     * player.showAttachedGui([player1, player2])
-     * ```
-     * @memberof GuiManager
-     * */
-    showAttachedGui(players?: RpgPlayer[] | RpgPlayer): void;
-    /**
-     * Hide the GUI attached to the players
-     *
-     * @title Hide to GUI attached
-     * @method player.hideAttachedGui(players?)
-     * @param {RpgPlayer[] | RpgPlayer} [players] The GUIs attached to the players to hide
-     * @since 3.0.0-beta.5
-     * @example
-     * ```ts
-     * player.hideAttachedGui()
-     * ```
-     * ```ts
-     * player.hideAttachedGui(aPlayer)
-     * ```
-     * ```ts
-     * player.hideAttachedGui([player1, player2])
-     * ```
-     * @memberof GuiManager
-     * */
-    hideAttachedGui(players?: RpgPlayer[] | RpgPlayer): void;
-}
-export interface GuiManager {
-    emit: any;
-}