@rpgjs/server 5.0.0-alpha.10 → 5.0.0-alpha.2

package/src/Player/GuiManager.ts

@@ -1,45 +1,132 @@
 import { RpgPlayer } from "./Player";
 import { Gui, DialogGui, MenuGui, ShopGui, NotificationGui } from "../Gui";
 import { DialogOptions, Choice } from "../Gui/DialogGui";
-import { Constructor, PlayerCtor } from "@rpgjs/common";
+import { Constructor, RpgCommonPlayer } from "@rpgjs/common";
 
-/**
- * GUI Manager Mixin
- *
- * Provides graphical user interface management capabilities to any class. This mixin handles
- * dialog boxes, menus, notifications, shops, and custom GUI components. It manages the
- * complete GUI system including opening, closing, and data passing between client and server.
- *
- * @param Base - The base class to extend with GUI management
- * @returns Extended class with GUI management methods
- *
- * @example
- * ```ts
- * class MyPlayer extends WithGuiManager(BasePlayer) {
- *   constructor() {
- *     super();
- *     // GUI system is automatically initialized
- *   }
- * }
- *
- * const player = new MyPlayer();
- * await player.showText('Hello World!');
- * player.callMainMenu();
- * ```
- */
-export function WithGuiManager<TBase extends PlayerCtor>(
+export interface IGuiManager {
+    emit: any;
+    removeGui: (guiId: string, data?: any) => void;
+  }
+
+export function WithGuiManager<TBase extends Constructor<RpgCommonPlayer>>(
   Base: TBase
-): new (...args: ConstructorParameters<TBase>) => InstanceType<TBase> &
-  IGuiManager {
-  class GuiManagerMixin extends Base {
+) {
+  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
+     * @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> {
       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
+     * @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[],
@@ -54,6 +141,19 @@ export function WithGuiManager<TBase extends PlayerCtor>(
       });
     }
 
+    /**
+     * 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 } = {}
@@ -67,6 +167,14 @@ export function WithGuiManager<TBase extends PlayerCtor>(
       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;
@@ -145,11 +253,11 @@ export function WithGuiManager<TBase extends PlayerCtor>(
       }
     }
 
-    _attachedGui(players: RpgPlayer[] | RpgPlayer, display: boolean) {
+    private _attachedGui(players: RpgPlayer[] | RpgPlayer, display: boolean) {
       if (!Array.isArray(players)) {
         players = [players] as RpgPlayer[];
       }
-      (this as any).emit("gui.tooltip", {
+      this.emit("gui.tooltip", {
         players: (players as RpgPlayer[]).map((player) => player.id),
         display,
       });
@@ -205,160 +313,5 @@ export function WithGuiManager<TBase extends PlayerCtor>(
       const _players = players || this;
       this._attachedGui(_players as RpgPlayer[], false);
     }
-  }
-
-  return GuiManagerMixin as unknown as any;
-}
-
-/**
- * Interface for GUI management capabilities
- * Defines the methods that will be available on the player
- */
-export interface IGuiManager {
-  /**
-   * 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(): void;
-  callShop(items: any[]): void;
-  gui(guiId: string): Gui;
-  removeGui(guiId: string, data?: any): void;
-  showAttachedGui(players?: RpgPlayer[] | RpgPlayer): void;
-  hideAttachedGui(players?: RpgPlayer[] | RpgPlayer): void;
+  };
 }

package/src/Player/ItemFixture.ts

@@ -1,10 +1,11 @@
 import { ItemInstance } from "@rpgjs/database";
-import { PlayerCtor } from "@rpgjs/common";
+import { RpgCommonPlayer, type Constructor } from "@rpgjs/common";
+export class ItemFixture {}
 
-export function WithItemFixture<TBase extends PlayerCtor>(
+export function WithItemFixture<TBase extends Constructor<RpgCommonPlayer>>(
   Base: TBase
 ) {
-  return class extends Base {
+  return class extends Base implements IItemFixture {
     protected getFeature(name, prop): any {
       const array = {};
       for (let item of this.equipments()) {
@@ -20,7 +21,7 @@ export function WithItemFixture<TBase extends PlayerCtor>(
       }
       return Object.values(array);
     }
-  } as unknown as TBase;
+  };
 }
 
 export interface ItemFixture {

package/src/Player/ItemManager.ts

@@ -1,4 +1,4 @@
-import { isInstanceOf, isString, Item, PlayerCtor, type Constructor } from "@rpgjs/common";
+import { isInstanceOf, isString, Item, type Constructor } from "@rpgjs/common";
 import { RpgCommonPlayer, Matter } from "@rpgjs/common";
 import { ATK, PDEF, SDEF } from "../presets";
 import { ItemLog } from "../logs";
@@ -13,34 +13,27 @@ enum ClassHooks {
   canEquip = 'canEquip'
 }
 
+/**
+ * Interface defining what MoveManager adds to a class
+ */
+export interface IItemManager {
+  databaseById(id: string): ItemClass;
+}
+
 type Inventory = { nb: number; item: ItemInstance };
 
 /**
- * Item Manager Mixin
+ * Move Manager mixin
  *
- * Provides comprehensive item management capabilities to any class. This mixin handles
- * inventory management, item usage, equipment, buying/selling, and item effects.
- * It manages the complete item system including restrictions, transactions, and equipment.
+ * Adds methods to manage player movement
  *
- * @param Base - The base class to extend with item management
- * @returns Extended class with item management methods
- * 
- * @example
- * ```ts
- * class MyPlayer extends WithItemManager(BasePlayer) {
- *   constructor() {
- *     super();
- *     // Item system is automatically initialized
- *   }
- * }
- * 
- * const player = new MyPlayer();
- * player.addItem('potion', 5);
- * player.useItem('potion');
- * ```
+ * @param Base - The base class to extend
+ * @returns A new class with move management capabilities
  */
-export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
-  return class extends Base {
+export function WithItemManager<TBase extends Constructor<RpgCommonPlayer>>(
+  Base: TBase
+): Constructor<IItemManager> & TBase {
+  return class extends Base implements IItemManager {
 
     /**
      * Retrieves the information of an object: the number and the instance
@@ -61,7 +54,7 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
      */
     getItem(itemClass: ItemClass | string): Item {
       const index: number = this._getItemIndex(itemClass);
-      return (this as any).items()[index];
+      return this.items()[index];
     }
 
     /**
@@ -84,7 +77,7 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
     }
 
     _getItemIndex(itemClass: ItemClass | string): number {
-      return (this as any).items().findIndex((it: Item): boolean => {
+      return this.items().findIndex((it: Item): boolean => {
         if (isString(itemClass)) {
           return it.id() == itemClass;
         }
@@ -110,8 +103,8 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
      *  ```
      */
     addItem(itemId: string, nb: number = 1): Item {
-      const data = (this as any).databaseById(itemId);
-      const item = (this as any).items().find((it) => it.id() == itemId);
+      const data = this.databaseById(itemId);
+      const item = this.items().find((it) => it.id() == itemId);
       let instance: Item;
       if (item) {
         instance = item;
@@ -119,9 +112,9 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
       } else {
         instance = new Item(data);
         instance.id.set(itemId);
-        (this as any).items().push(instance);
+        this.items().push(instance);
       }
-      (this as any)["execMethod"]("onAdd", [this], instance);
+      this["execMethod"]("onAdd", [this], instance);
       return instance;
     }
 
@@ -217,7 +210,7 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
      * ```
      */
     buyItem(itemId: string, nb = 1): Item {
-      const data = (this as any).databaseById(itemId);
+      const data = this.databaseById(itemId);
       if (!data.price) {
         throw ItemLog.haveNotPrice(itemId);
       }
@@ -279,7 +272,7 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
      * ```
      */
     sellItem(itemId: string, nbToSell = 1): Item {
-      const data = (this as any).databaseById(itemId);
+      const data = this.databaseById(itemId);
       const inventory = this.getItem(itemId);
       if (!inventory) {
         throw ItemLog.notInInventory(itemId);
@@ -485,7 +478,7 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
       if (!inventory) {
         throw ItemLog.notInInventory(itemId);
       }
-      const data = (this as any).databaseById(itemId);
+      const data = this.databaseById(itemId);
       if (data._type == "item") {
         throw ItemLog.invalidToEquiped(itemId);
       }
@@ -515,11 +508,5 @@ export function WithItemManager<TBase extends PlayerCtor>(Base: TBase) {
       }
       this["execMethod"]("onEquip", [this, equip], item);
     }
-  } as unknown as TBase;
+  };
 }
-
-/**
- * Type helper to extract the interface from the WithItemManager mixin
- * This provides the type without duplicating method signatures
- */
-export type IItemManager = InstanceType<ReturnType<typeof WithItemManager>>;

package/src/Player/MoveManager.ts

@@ -1,4 +1,4 @@
-import { PlayerCtor, type Constructor } from "@rpgjs/common";
+import { type Constructor } from "@rpgjs/common";
 import { RpgCommonPlayer, Matter, Direction } from "@rpgjs/common";
 import { 
   MovementManager, 
@@ -34,7 +34,26 @@ interface PlayerWithMixins extends RpgCommonPlayer {
   changeDirection: (direction: Direction) => boolean;
 }
 
-
+export interface IMoveManager {
+  addMovement(strategy: MovementStrategy): void;
+  removeMovement(strategy: MovementStrategy): boolean;
+  clearMovements(): void;
+  hasActiveMovements(): boolean;
+  getActiveMovements(): MovementStrategy[];
+  
+  moveTo(target: RpgCommonPlayer | { x: number, y: number }): void;
+  stopMoveTo(): void;
+  dash(direction: { x: number, y: number }, speed?: number, duration?: number): void;
+  knockback(direction: { x: number, y: number }, force?: number, duration?: number): void;
+  followPath(waypoints: Array<{ x: number, y: number }>, speed?: number, loop?: boolean): void;
+  oscillate(direction: { x: number, y: number }, amplitude?: number, period?: number): void;
+  applyIceMovement(direction: { x: number, y: number }, maxSpeed?: number): void;
+  shootProjectile(type: ProjectileType, direction: { x: number, y: number }, speed?: number): void;
+  moveRoutes(routes: Routes): Promise<boolean>;
+  infiniteMoveRoute(routes: Routes): void;
+  breakRoutes(force?: boolean): void;
+  replayRoutes(): void;
+}
 
 
 function wait(sec: number) {
@@ -456,37 +475,15 @@ export const Move = new MoveList();
  * }
  * ```
  */
-/**
- * Move Manager Mixin
- * 
- * Provides comprehensive movement management capabilities to any class. This mixin handles
- * various types of movement including pathfinding, physics-based movement, route following,
- * and advanced movement strategies like dashing, knockback, and projectile movement.
- * 
- * @param Base - The base class to extend with movement management
- * @returns Extended class with movement management methods
- * 
- * @example
- * ```ts
- * class MyPlayer extends WithMoveManager(BasePlayer) {
- *   constructor() {
- *     super();
- *     this.frequency = Frequency.High;
- *   }
- * }
- * 
- * const player = new MyPlayer();
- * player.moveTo({ x: 100, y: 100 });
- * player.dash({ x: 1, y: 0 }, 8, 200);
- * ```
- */
-export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
-  return class extends Base {
+export function WithMoveManager<TBase extends Constructor<RpgCommonPlayer>>(
+  Base: TBase
+): Constructor<IMoveManager> & TBase {
+  return class extends Base implements IMoveManager {
     
-    // Properties for infinite route management
-    _infiniteRoutes: Routes | null = null;
-    _finishRoute: ((value: boolean) => void) | null = null;
-    _isInfiniteRouteActive: boolean = false;
+    // Private properties for infinite route management
+    private _infiniteRoutes: Routes | null = null;
+    private _finishRoute: ((value: boolean) => void) | null = null;
+    private _isInfiniteRouteActive: boolean = false;
 
     /** 
     * The player passes through the other players (or vice versa). But the player does not go through the events.
@@ -1100,7 +1097,7 @@ export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
      * @param routes - Routes array that may contain nested arrays
      * @returns Flattened array of routes
      */
-    flattenRoutes(routes: any[]): any[] {
+    private flattenRoutes(routes: any[]): any[] {
       const result: any[] = [];
       
       for (const route of routes) {
@@ -1244,11 +1241,5 @@ export function WithMoveManager<TBase extends PlayerCtor>(Base: TBase) {
         this.infiniteMoveRoute(this._infiniteRoutes);
       }
     }
-  } as unknown as TBase;
+  };
 }
-
-/**
- * Type helper to extract the interface from the WithMoveManager mixin
- * This provides the type without duplicating method signatures
- */
-export type IMoveManager = InstanceType<ReturnType<typeof WithMoveManager>>;