@rpgjs/server 4.2.2 → 5.0.0-alpha.0

package/src/Player/ElementManager.ts

@@ -1,145 +1,143 @@
-import { Utils }  from '@rpgjs/common'
-import { RpgPlayer } from './Player';
-import { ItemFixture } from './ItemFixture';
-import { ItemInstance } from '@rpgjs/database';
+import { arrayUniq, RpgCommonPlayer } from "@rpgjs/common";
+import { Constructor } from "@rpgjs/common";
+import { RpgPlayer } from "./Player";
 
-const { 
-    arrayUniq,
-    applyMixins
-} = Utils
+export function WithElementManager<TBase extends Constructor<RpgCommonPlayer>>(
+  Base: TBase
+) {
+  return class extends Base implements IWithElementManager {
+    _elementsEfficiency: { rate: number; element: any }[] = [];
 
-export 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 }[] {
-        return this.getFeature('elementsDefense', 'element')
+    get elementsDefense(): { rate: number; element: any }[] {
+      return this.getFeature("elementsDefense", "element");
     }
 
-     /** 
-     * Set or retrieves all the elements where the player is vulnerable or not. 
-     * 
+    /**
+     * 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 }[] {
-        if (this._class) {
-            return <any>[...this._elementsEfficiency, ...this._class.elementsEfficiency]
-        }
-        return this._elementsEfficiency
+    get elementsEfficiency(): { rate: number; element: any }[] {
+      if (this._class) {
+        return <any>[
+          ...this._elementsEfficiency,
+          ...(this._class()?.elementsEfficiency || []),
+        ];
+      }
+      return this._elementsEfficiency;
     }
 
     set elementsEfficiency(val) {
-        this._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(): {
-        rate: number,
-        element: string
+      rate: number;
+      element: string;
     }[] {
-        let elements: any = []
-        for (let item of this.equipments) {
-            if (item.elements) {
-                elements = [...elements, ...item.elements]
-            }
+      let elements: any = [];
+      for (let item of this.equipments()) {
+        if (item.elements) {
+          elements = [...elements, ...item.elements];
         }
-        return arrayUniq(elements)
+      }
+      return arrayUniq(elements);
     }
 
     coefficientElements(otherPlayer: RpgPlayer): number {
-        const atkPlayerElements: any = otherPlayer.elements
-        const playerElements: any = this.elementsEfficiency
-        let coefficient = 1
+      const atkPlayerElements: any = otherPlayer.elements;
+      const playerElements: any = 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 })
+      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;
         }
-        return coefficient
+        coefficient += fn(
+          atkElement,
+          elementPlayer,
+          elementPlayerDef || { rate: 0 }
+        );
+      }
+      return coefficient;
     }
+  };
 }
-
-export interface ElementManager{ 
-    equipments: ItemInstance[]
-    getFormulas: (name: string) => any, 
-    _class: any
-}
-
-
-applyMixins(ElementManager, [ItemFixture])
-
-export interface ElementManager extends ItemFixture { }

package/src/Player/GoldManager.ts

@@ -1,7 +1,24 @@
-export class GoldManager {
-    private _gold: number = 0
+import { type Constructor } from "@rpgjs/common";
+import { RpgCommonPlayer } from "@rpgjs/common";
 
-     /** 
+/**
+ * Interface defining what MoveManager adds to a class
+ */
+export interface IGoldManager {
+  
+}
+
+/**
+ * Move Manager mixin
+ * 
+ * Adds methods to manage player gold
+ * 
+ * @param Base - The base class to extend
+ * @returns A new class with gold management capabilities
+ */
+export function WithGoldManager<TBase extends Constructor<RpgCommonPlayer>>(Base: TBase) {
+  return class extends Base implements IGoldManager {
+    /** 
      * You can change the game money
      * 
      * ```ts
@@ -17,10 +34,11 @@ export class GoldManager {
         if (val < 0) {
             val = 0
         }
-        this._gold = val
+        this._gold.set(val)
     }
 
     get gold(): number {
-        return this._gold
+        return this._gold()
     }
-}
+  };
+}

package/src/Player/GuiManager.ts

@@ -1,140 +1,149 @@
-import { Utils } from '@rpgjs/common'
-import { RpgPlayer } from './Player'
-import { Gui, DialogGui, MenuGui, ShopGui, NotificationGui } from '../Gui'
-import { DialogOptions, Choice } from '../Gui/DialogGui'
+import { RpgPlayer } from "./Player";
+import { Gui, DialogGui, MenuGui, ShopGui, NotificationGui } from "../Gui";
+import { DialogOptions, Choice } from "../Gui/DialogGui";
+import { Constructor, RpgCommonPlayer } from "@rpgjs/common";
 
-export class GuiManager {
+export interface IGuiManager {
+    emit: any;
+    removeGui: (guiId: string, data?: any) => void;
+  }
 
-    _gui: { [id: string]: Gui }
+export function WithGuiManager<TBase extends Constructor<RpgCommonPlayer>>(
+  Base: TBase
+) {
+  return class extends Base implements IGuiManager {
+    _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 
+     *
+     * @title Show Text
      * @method player.showText(text,options)
-     * @param {string} text 
+     * @param {string} text
      * @param {object} [options] the different options, see usage below
      * @returns {Promise}
      * @memberof GuiManager
      */
     showText(msg: string, options: DialogOptions = {}): Promise<any> {
-        const gui = new DialogGui(<any>this)
-        this._gui[gui.id] = gui
-        return gui.openDialog(msg, options)
+      const gui = new DialogGui(<any>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 
+     *
+     * @title Show Choices
      * @method player.showChoices(text,choices)
-     * @param {string} text 
+     * @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> {
-        return this
-            .showText(msg, {
-                choices,
-                ...options
-            })
-            .then((indexSelected: number) => {
-                if (!choices[indexSelected]) return null
-                return choices[indexSelected]
-            })
+    showChoices(
+      msg: string,
+      choices: Choice[],
+      options?: DialogOptions
+    ): Promise<Choice | null> {
+      return this.showText(msg, {
+        choices,
+        ...options,
+      }).then((indexSelected: number) => {
+        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
@@ -145,42 +154,45 @@ export class GuiManager {
      * @returns {void}
      * @memberof GuiManager
      */
-    showNotification(message: string, options: { time?: number, icon?: string, sound?: string } = {}): Promise<any> {
-        const gui = new NotificationGui(<any>this)
-        this._gui[gui.id] = gui
-        const data = {
-            message,
-            ...options
-        }
-        return gui.open(data)
+    showNotification(
+      message: string,
+      options: { time?: number; icon?: string; sound?: string } = {}
+    ): Promise<any> {
+      const gui = new NotificationGui(<any>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(<any>this)
-        this._gui[gui.id] = gui
-        return gui.open()
+      const gui = new MenuGui(<any>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: any[]) {
-        const gui = new ShopGui(<any>this)
-        this._gui[gui.id] = gui
-        return gui.open(items)
+      const gui = new ShopGui(<any>this);
+      this._gui[gui.id] = gui;
+      return gui.open(items);
     }
 
     /**
@@ -219,44 +231,44 @@ export class GuiManager {
      * @memberof GuiManager
      */
     gui(guiId: string) {
-        const gui = new Gui(guiId, <any>this)
-        this._gui[guiId] = gui
-        return gui
+      const gui = new Gui(guiId, <any>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 
+     * @param {object} [data] Passing data if you close the GUI
      * @returns {Gui}
      * @memberof GuiManager
      */
     removeGui(guiId: string, data?: any) {
-        if (this._gui[guiId]) {
-            this._gui[guiId].close(data)
-            delete this._gui[guiId]
-        }
+      if (this._gui[guiId]) {
+        this._gui[guiId].close(data);
+        delete this._gui[guiId];
+      }
     }
 
     private _attachedGui(players: RpgPlayer[] | RpgPlayer, display: boolean) {
-        if (!Utils.isArray(players)) {
-            players = [players] as RpgPlayer[]
-        }
-        this.emit('gui.tooltip', {
-            players: (players as RpgPlayer[]).map(player => player.id),
-            display
-        })
+      if (!Array.isArray(players)) {
+        players = [players] as RpgPlayer[];
+      }
+      this.emit("gui.tooltip", {
+        players: (players as RpgPlayer[]).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 
+     *
+     * 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
@@ -274,13 +286,13 @@ export class GuiManager {
      * @memberof GuiManager
      * */
     showAttachedGui(players?: RpgPlayer[] | RpgPlayer) {
-        const _players = players || this
-        this._attachedGui(_players as RpgPlayer[], true)
+      const _players = players || this;
+      this._attachedGui(_players as RpgPlayer[], 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
@@ -298,11 +310,8 @@ export class GuiManager {
      * @memberof GuiManager
      * */
     hideAttachedGui(players?: RpgPlayer[] | RpgPlayer) {
-        const _players = players || this
-        this._attachedGui(_players as RpgPlayer[], false)
+      const _players = players || this;
+      this._attachedGui(_players as RpgPlayer[], false);
     }
+  };
 }
-
-export interface GuiManager {
-    emit: any
-}

package/src/Player/ItemFixture.ts

@@ -1,24 +1,29 @@
-import { ItemInstance } from "@rpgjs/database"
+import { ItemInstance } from "@rpgjs/database";
+import { RpgCommonPlayer, type Constructor } from "@rpgjs/common";
+export class ItemFixture {}
 
-export class ItemFixture {
+export function WithItemFixture<TBase extends Constructor<RpgCommonPlayer>>(
+  Base: TBase
+) {
+  return class extends Base implements IItemFixture {
     protected getFeature(name, prop): any {
-        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
-                }
-            }
+      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)
+      }
+      return Object.values(array);
     }
+  };
 }
 
-
-export interface ItemFixture{ 
-    equipments: ItemInstance[]
+export interface ItemFixture {
+  equipments: ItemInstance[];
 }