@rpgjs/server 4.3.0 → 5.0.0-alpha.1

package/lib/Player/GuiManager.js

@@ -1,291 +0,0 @@
-import { Utils } from '@rpgjs/common';
-import { Gui, DialogGui, MenuGui, ShopGui, NotificationGui } from '../Gui/index.js';
-export class GuiManager {
-    /**
-     * 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, options = {}) {
-        const gui = new DialogGui(this);
-        this._gui[gui.id] = gui;
-        return gui.openDialog(msg, options);
-    }
-    /**
-     * 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, choices, options) {
-        return this
-            .showText(msg, {
-            choices,
-            ...options
-        })
-            .then((indexSelected) => {
-            if (!choices[indexSelected])
-                return null;
-            return choices[indexSelected];
-        });
-    }
-    /**
-     * 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, options = {}) {
-        const gui = new NotificationGui(this);
-        this._gui[gui.id] = gui;
-        const data = {
-            message,
-            ...options
-        };
-        return gui.open(data);
-    }
-    /**
-     * Calls main menu. Opens the GUI named `rpg-main-menu`
-     *
-     * @title Call Main Menu
-     * @method player.callMainMenu()
-     * @returns {void}
-     * @memberof GuiManager
-     */
-    callMainMenu() {
-        const gui = new MenuGui(this);
-        this._gui[gui.id] = gui;
-        return gui.open();
-    }
-    /**
-     * Calls shop menu. Opens the GUI named `rpg-shop`
-     *
-     * @title Call Shop Menu
-     * @method player.callShop()
-     * @returns {void}
-     * @memberof GuiManager
-     */
-    callShop(items) {
-        const gui = new ShopGui(this);
-        this._gui[gui.id] = gui;
-        return gui.open(items);
-    }
-    /**
-     * 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) {
-        const gui = new Gui(guiId, this);
-        this._gui[guiId] = gui;
-        return 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, data) {
-        if (this._gui[guiId]) {
-            this._gui[guiId].close(data);
-            delete this._gui[guiId];
-        }
-    }
-    _attachedGui(players, display) {
-        if (!Utils.isArray(players)) {
-            players = [players];
-        }
-        this.emit('gui.tooltip', {
-            players: players.map(player => player.id),
-            display
-        });
-    }
-    /**
-     * 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) {
-        const _players = players || this;
-        this._attachedGui(_players, true);
-    }
-    /**
-     * 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) {
-        const _players = players || this;
-        this._attachedGui(_players, false);
-    }
-}
-//# sourceMappingURL=GuiManager.js.map

package/lib/Player/GuiManager.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"GuiManager.js","sourceRoot":"","sources":["../../src/Player/GuiManager.ts"],"names":[],"mappings":"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"}

package/lib/Player/ItemFixture.d.ts

@@ -1,7 +0,0 @@
-import { ItemInstance } from "@rpgjs/database";
-export declare class ItemFixture {
-    protected getFeature(name: any, prop: any): any;
-}
-export interface ItemFixture {
-    equipments: ItemInstance[];
-}

package/lib/Player/ItemFixture.js

@@ -1,19 +0,0 @@
-export class ItemFixture {
-    getFeature(name, prop) {
-        const array = {};
-        for (let item of this.equipments) {
-            if (item[name]) {
-                for (let feature of item[name]) {
-                    const { rate } = feature;
-                    const instance = feature[prop];
-                    const cache = array[instance.id];
-                    if (cache && cache.rate >= rate)
-                        continue;
-                    array[instance.id] = feature;
-                }
-            }
-        }
-        return Object.values(array);
-    }
-}
-//# sourceMappingURL=ItemFixture.js.map

package/lib/Player/ItemFixture.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ItemFixture.js","sourceRoot":"","sources":["../../src/Player/ItemFixture.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,WAAW;IACV,UAAU,CAAC,IAAI,EAAE,IAAI;QAC3B,MAAM,KAAK,GAAG,EAAE,CAAA;QAChB,KAAK,IAAI,IAAI,IAAI,IAAI,CAAC,UAAU,EAAE;YAC9B,IAAI,IAAI,CAAC,IAAI,CAAC,EAAE;gBACZ,KAAK,IAAI,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,EAAE;oBAC5B,MAAM,EAAE,IAAI,EAAE,GAAG,OAAO,CAAA;oBACxB,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;oBAC9B,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAA;oBAChC,IAAI,KAAK,IAAI,KAAK,CAAC,IAAI,IAAI,IAAI;wBAAE,SAAQ;oBACzC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,OAAO,CAAA;iBAC/B;aACJ;SACJ;QACD,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IAC/B,CAAC;CACJ"}

package/lib/Player/ItemManager.d.ts

@@ -1,331 +0,0 @@
-import { ItemClass, ItemInstance, WeaponClass, ArmorClass } from '@rpgjs/database';
-import { EffectManager } from './EffectManager';
-import { GoldManager } from './GoldManager';
-import { StateManager } from './StateManager';
-type Inventory = {
-    nb: number;
-    item: ItemInstance;
-};
-export declare class ItemManager {
-    items: Inventory[];
-    equipments: ItemInstance[];
-    /**
-    * Retrieves the information of an object: the number and the instance
-    * @title Get Item
-    * @method player.getItem(itemClass)
-    * @param {ItemClass | string} itemClass Identifier of the object if the parameter is a string
-    * @returns {{ nb: number, item: instance of ItemClass }}
-    * @memberof ItemManager
-    * @example
-    *
-    * ```ts
-    * import Potion from 'your-database/potion'
-    *
-    * player.addItem(Potion, 5)
-    * const inventory = player.getItem(Potion)
-    * console.log(inventory) // { nb: 5, item: <instance of Potion> }
-    *  ```
-    */
-    getItem(itemClass: ItemClass | string): Inventory;
-    /**
-     * Check if the player has the item in his inventory.
-     * @title Has Item
-     * @method player.hasItem(itemClass)
-     * @param {ItemClass | string} itemClass Identifier of the object if the parameter is a string
-     * @returns {boolean}
-     * @memberof ItemManager
-     * @example
-     *
-     * ```ts
-     * import Potion from 'your-database/potion'
-     *
-     * player.hasItem(Potion) // false
-     *  ```
-     */
-    hasItem(itemClass: ItemClass | string): boolean;
-    _getItemIndex(itemClass: ItemClass | string): number;
-    /**
-     * Add an item in the player's inventory. You can give more than one by specifying `nb`
-     *
-     * `onAdd()` method is called on the ItemClass
-     *
-     * @title Add Item
-     * @method player.addItem(item,nb=1)
-     * @param {ItemClass} itemClass
-     * @param {number} [nb] Default 1
-     * @returns {{ nb: number, item: instance of ItemClass }}
-     * @memberof ItemManager
-     * @example
-     *
-     * ```ts
-     * import Potion from 'your-database/potion'
-     * player.addItem(Potion, 5)
-     *  ```
-     */
-    addItem(itemClass: ItemClass | string, nb?: number): Inventory;
-    /**
-     * Deletes an item. Decreases the value `nb`. If the number falls to 0, then the item is removed from the inventory. The method then returns `undefined`
-     *
-     * `onRemove()` method is called on the ItemClass
-     *
-     * @title Remove Item
-     * @method player.removeItem(item,nb=1)
-     * @param {ItemClass | string} itemClass string is item id
-     * @param {number} [nb] Default 1
-     * @returns {{ nb: number, item: instance of ItemClass } | undefined}
-     * @throws {ItemLog} notInInventory
-     * If the object is not in the inventory, an exception is raised
-     *  ```
-     * {
-     *      id: ITEM_NOT_INVENTORY,
-     *      msg: '...'
-     * }
-     * ```
-     * @memberof ItemManager
-     * @example
-     *
-     * ```ts
-     * import Potion from 'your-database/potion'
-     *
-     * try {
-     *    player.removeItem(Potion, 5)
-     * }
-     * catch (err) {
-     *    console.log(err)
-     * }
-     * ```
-     */
-    removeItem(itemClass: ItemClass | string, nb?: number): Inventory | undefined;
-    /**
-     * Purchases an item and reduces the amount of gold
-     *
-     * `onAdd()` method is called on the ItemClass
-     *
-     * @title Buy Item
-     * @method player.buyItem(item,nb=1)
-     * @param {ItemClass | string} itemClass string is item id
-     * @param {number} [nb] Default 1
-     * @returns {{ nb: number, item: instance of ItemClass }}
-     * @throws {ItemLog} haveNotPrice
-     * If you have not set a price on the item
-     *  ```
-     * {
-     *      id: NOT_PRICE,
-     *      msg: '...'
-     * }
-     * ```
-     * @throws {ItemLog} notEnoughGold
-     * If the player does not have enough money
-     *  ```
-     * {
-     *      id: NOT_ENOUGH_GOLD,
-     *      msg: '...'
-     * }
-     * ```
-     * @memberof ItemManager
-     * @example
-     *
-     * ```ts
-     * import Potion from 'your-database/potion'
-     *
-     * try {
-     *    player.buyItem(Potion)
-     * }
-     * catch (err) {
-     *    console.log(err)
-     * }
-     * ```
-     */
-    buyItem(itemClass: ItemClass | string, nb?: number): Inventory;
-    /**
-     * Sell an item and the player wins the amount of the item divided by 2
-     *
-     * `onRemove()` method is called on the ItemClass
-     *
-     * @title Sell Item
-     * @method player.sellItem(item,nb=1)
-     * @param {ItemClass | string} itemClass string is item id
-     * @param {number} [nbToSell] Default 1
-     * @returns {{ nb: number, item: instance of ItemClass }}
-     * @throws {ItemLog} haveNotPrice
-     * If you have not set a price on the item
-     *   ```
-     * {
-     *      id: NOT_PRICE,
-     *      msg: '...'
-     * }
-     * ```
-     * @throws {ItemLog} notInInventory
-     * If the object is not in the inventory, an exception is raised
-     *  ```
-     * {
-     *      id: ITEM_NOT_INVENTORY,
-     *      msg: '...'
-     * }
-     * ```
-     * @throws {ItemLog} tooManyToSell
-     * If the number of items for sale exceeds the number of actual items in the inventory
-     *  ```
-     * {
-     *      id: TOO_MANY_ITEM_TO_SELL,
-     *      msg: '...'
-     * }
-     * ```
-     * @memberof ItemManager
-     * @example
-     *
-     * ```ts
-     * import Potion from 'your-database/potion'
-     *
-     * try {
-     *     player.addItem(Potion)
-     *     player.sellItem(Potion)
-     * }
-     * catch (err) {
-     *    console.log(err)
-     * }
-     * ```
-     */
-    sellItem(itemClass: ItemClass | string, nbToSell?: number): Inventory;
-    private getParamItem;
-    /**
-     * recover the attack sum of items equipped on the player.
-     *
-     * @title Get the player's attack
-     * @prop {number} player.atk
-     * @memberof ItemManager
-     */
-    get atk(): number;
-    /**
-    * recover the physic defense sum of items equipped on the player.
-    *
-    * @title Get the player's pdef
-    * @prop {number} player.pdef
-    * @memberof ItemManager
-    */
-    get pdef(): number;
-    /**
-    * recover the skill defense sum of items equipped on the player.
-    *
-    * @title Get the player's sdef
-    * @prop {number} player.sdef
-    * @memberof ItemManager
-    */
-    get sdef(): number;
-    /**
-     *  Use an object. Applies effects and states. Removes the object from the inventory then
-     *
-     * `onUse()` method is called on the ItemClass (If the use has worked)
-     * `onRemove()` method is called on the ItemClass
-     *
-     * @title Use an Item
-     * @method player.useItem(item,nb=1)
-     * @param {ItemClass | string} itemClass string is item id
-     * @returns {{ nb: number, item: instance of ItemClass }}
-     * @throws {ItemLog} restriction
-     * If the player has the `Effect.CAN_NOT_ITEM` effect
-     *   ```
-     * {
-     *      id: RESTRICTION_ITEM,
-     *      msg: '...'
-     * }
-     * ```
-     * @throws {ItemLog} notInInventory
-     * If the object is not in the inventory, an exception is raised
-     *  ```
-     * {
-     *      id: ITEM_NOT_INVENTORY,
-     *      msg: '...'
-     * }
-     * ```
-     * @throws {ItemLog} notUseItem
-     * If the `consumable` property is on false
-     *  ```
-     * {
-     *      id: NOT_USE_ITEM,
-     *      msg: '...'
-     * }
-     * ```
-     * @throws {ItemLog} chanceToUseFailed
-     * Chance to use the item has failed. Chances of use is defined with `ItemClass.hitRate`
-     *  ```
-     * {
-     *      id: USE_CHANCE_ITEM_FAILED,
-     *      msg: '...'
-     * }
-     * ```
-     * > the item is still deleted from the inventory
-     *
-     * `onUseFailed()` method is called on the ItemClass
-     *
-     * @memberof ItemManager
-     * @example
-     *
-     * ```ts
-     * import Potion from 'your-database/potion'
-     *
-     * try {
-     *     player.addItem(Potion)
-     *     player.useItem(Potion)
-     * }
-     * catch (err) {
-     *    console.log(err)
-     * }
-     * ```
-     */
-    useItem(itemClass: ItemClass | string): Inventory;
-    /**
-     * Equips a weapon or armor on a player. Think first to add the item in the inventory with the `addItem()` method before equipping the item.
-     *
-     * `onEquip()` method is called on the ItemClass
-     *
-     * @title Equip Weapon or Armor
-     * @method player.equip(itemClass,equip=true)
-     * @param {ItemClass | string} itemClass string is item id
-     * @param {number} [equip] Equip the object if true or un-equipped if false
-     * @returns {void}
-     * @throws {ItemLog} notInInventory
-     * If the item is not in the inventory
-     *  ```
-        {
-            id: ITEM_NOT_INVENTORY,
-            msg: '...'
-        }
-        ```
-     * @throws {ItemLog} invalidToEquiped
-        If the item is not by a weapon or armor
-        ```
-        {
-            id: INVALID_ITEM_TO_EQUIP,
-            msg: '...'
-        }
-        ```
-    * @throws {ItemLog} isAlreadyEquiped
-        If the item Is already equipped
-        ```
-        {
-            id: ITEM_ALREADY_EQUIPED,
-            msg: '...'
-        }
-        ```
-     * @memberof ItemManager
-     * @example
-     *
-     * ```ts
-     * import Sword from 'your-database/sword'
-     *
-     * try {
-     *      player.addItem(Sword)
-     *      player.equip(Sword)
-     * }
-     * catch (err) {
-     *    console.log(err)
-     * }
-     * ```
-     */
-    equip(itemClass: WeaponClass | ArmorClass | string, equip?: boolean): void;
-}
-export interface ItemManager extends GoldManager, StateManager, EffectManager {
-    databaseById(itemClass: any): any;
-}
-export {};