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

package/src/RpgServer.ts

@@ -227,251 +227,20 @@ export interface RpgPlayerHooks {
     canChangeMap?: (player: RpgPlayer, nextMap: RpgClassMap<RpgMap>) => boolean | Promise<boolean>
 }
 
-/**
- * Event hooks interface for handling various event lifecycle methods
- * 
- * @interface RpgEventHooks
- * @since 4.0.0
- */
 export interface RpgEventHooks {
-    /**
-     * Called as soon as the event is created on the map
-     * 
-     * @param {RpgEvent} event - The event instance being initialized
-     * @returns {any} 
-     * @memberof RpgEventHooks
-     * @example
-     * ```ts
-     * const eventHooks: RpgEventHooks = {
-     *     onInit(event) {
-     *         console.log(`Event ${event.name} initialized`)
-     *         event.graphic('default-sprite')
-     *     }
-     * }
-     * ```
-     */
     onInit?: (event: RpgEvent) => any,
-
-    /**
-     * Called when the event collides with a player and the player presses the action key
-     * 
-     * @param {RpgEvent} event - The event being interacted with
-     * @param {RpgPlayer} player - The player performing the action
-     * @returns {any}
-     * @memberof RpgEventHooks
-     * @example
-     * ```ts
-     * const eventHooks: RpgEventHooks = {
-     *     onAction(event, player) {
-     *         player.showText('You activated the chest!')
-     *         player.addItem('POTION', 1)
-     *     }
-     * }
-     * ```
-     */
     onAction?: (event: RpgEvent, player: RpgPlayer) => any
-
-    /**
-     * Called before an event object is created and added to the map
-     * Allows modification of event properties before instantiation
-     * 
-     * @param {any} object - The event object data before creation
-     * @param {RpgMap} map - The map where the event will be created
-     * @returns {any}
-     * @memberof RpgEventHooks
-     * @example
-     * ```ts
-     * const eventHooks: RpgEventHooks = {
-     *     onBeforeCreated(object, map) {
-     *         // Modify event properties based on map conditions
-     *         if (map.id === 'dungeon') {
-     *             object.graphic = 'monster-sprite'
-     *         }
-     *     }
-     * }
-     * ```
-     */
     onBeforeCreated?: (object: any, map: RpgMap) => any
-
-    /**
-     * Called when a player or another event enters a shape attached to this event
-     * 
-     * @param {RpgEvent} event - The event with the attached shape
-     * @param {RpgPlayer} player - The player entering the shape
-     * @param {RpgShape} shape - The shape being entered
-     * @returns {any}
-     * @since 4.1.0
-     * @memberof RpgEventHooks
-     * @example
-     * ```ts
-     * const eventHooks: RpgEventHooks = {
-     *     onDetectInShape(event, player, shape) {
-     *         console.log(`Player ${player.name} entered detection zone`)
-     *         player.showText('You are being watched...')
-     *     }
-     * }
-     * ```
-     */
     onDetectInShape?: (event: RpgEvent, player: RpgPlayer, shape: RpgShape) => any
-
-    /**
-     * Called when a player or another event leaves a shape attached to this event
-     * 
-     * @param {RpgEvent} event - The event with the attached shape
-     * @param {RpgPlayer} player - The player leaving the shape
-     * @param {RpgShape} shape - The shape being left
-     * @returns {any}
-     * @since 4.1.0
-     * @memberof RpgEventHooks
-     * @example
-     * ```ts
-     * const eventHooks: RpgEventHooks = {
-     *     onDetectOutShape(event, player, shape) {
-     *         console.log(`Player ${player.name} left detection zone`)
-     *         player.showText('You escaped the watch...')
-     *     }
-     * }
-     * ```
-     */
     onDetectOutShape?: (event: RpgEvent, player: RpgPlayer, shape: RpgShape) => any
-
-    /**
-     * Called when the event enters a shape on the map
-     * 
-     * @param {RpgEvent} event - The event entering the shape
-     * @param {RpgShape} shape - The shape being entered
-     * @returns {any}
-     * @memberof RpgEventHooks
-     * @example
-     * ```ts
-     * const eventHooks: RpgEventHooks = {
-     *     onInShape(event, shape) {
-     *         console.log(`Event entered shape: ${shape.id}`)
-     *         event.speed = 1 // Slow down in this area
-     *     }
-     * }
-     * ```
-     */
     onInShape?: (event: RpgEvent, shape: RpgShape) => any
-
-    /**
-     * Called when the event leaves a shape on the map
-     * 
-     * @param {RpgEvent} event - The event leaving the shape
-     * @param {RpgShape} shape - The shape being left
-     * @returns {any}
-     * @memberof RpgEventHooks
-     * @example
-     * ```ts
-     * const eventHooks: RpgEventHooks = {
-     *     onOutShape(event, shape) {
-     *         console.log(`Event left shape: ${shape.id}`)
-     *         event.speed = 3 // Resume normal speed
-     *     }
-     * }
-     * ```
-     */
     onOutShape?: (event: RpgEvent, shape: RpgShape) => any
-
-    /**
-     * Called when the event collides with a player (without requiring action key press)
-     * 
-     * @param {RpgEvent} event - The event touching the player
-     * @param {RpgPlayer} player - The player being touched
-     * @returns {any}
-     * @memberof RpgEventHooks
-     * @example
-     * ```ts
-     * const eventHooks: RpgEventHooks = {
-     *     onPlayerTouch(event, player) {
-     *         player.hp -= 10 // Damage on touch
-     *         player.showText('Ouch! You touched a spike!')
-     *     }
-     * }
-     * ```
-     */
     onPlayerTouch?: (event: RpgEvent, player: RpgPlayer) => any
-
-    /**
-     * Called whenever any event on the map (including itself) is executed or changes state
-     * Useful for creating reactive events that respond to map state changes
-     * 
-     * @param {RpgEvent} event - The event listening for changes
-     * @param {RpgPlayer} player - The player involved in the change
-     * @returns {any}
-     * @memberof RpgEventHooks
-     * @example
-     * ```ts
-     * const eventHooks: RpgEventHooks = {
-     *     onChanges(event, player) {
-     *         // Change chest graphic based on game state
-     *         if (player.getVariable('BATTLE_END')) {
-     *             event.graphic('chest-open')
-     *         } else {
-     *             event.graphic('chest-close')
-     *         }
-     *     }
-     * }
-     * ```
-     */
     onChanges?: (event: RpgEvent, player: RpgPlayer) => any
 }
 
-/**
- * Map hooks interface for handling map lifecycle events
- * 
- * @interface RpgMapHooks
- * @since 4.0.0
- */
 export interface RpgMapHooks {
-    /**
-     * Called before a map is updated with new data
-     * Allows modification of map data before the update is applied
-     * 
-     * The `mapData` parameter contains the loaded map data (retrieved from request body)
-     * You can modify the map before the update is processed
-     * 
-     * @template T - Type of the incoming map data
-     * @template U - Type of the map instance (defaults to RpgMap)
-     * @param {T} mapData - The map data loaded from external source (e.g., request body)
-     * @param {U} map - The current map instance being updated
-     * @returns {U | Promise<U>} The modified map instance or a promise resolving to it
-     * @memberof RpgMapHooks
-     * @example
-     * ```ts
-     * const mapHooks: RpgMapHooks = {
-     *     onBeforeUpdate(mapData, map) {
-     *         // Modify map properties based on incoming data
-     *         if (mapData.weather === 'rain') {
-     *             map.setWeatherEffect('rain')
-     *         }
-     *         
-     *         // Add custom properties from external data
-     *         map.customProperty = mapData.customValue
-     *         
-     *         return map
-     *     }
-     * }
-     * ```
-     * 
-     * @example
-     * ```ts
-     * // Async example with database operations
-     * const mapHooks: RpgMapHooks = {
-     *     async onBeforeUpdate(mapData, map) {
-     *         // Load additional data from database
-     *         const additionalData = await database.getMapExtras(map.id)
-     *         
-     *         // Apply modifications
-     *         map.events = [...map.events, ...additionalData.events]
-     *         map.npcs = additionalData.npcs
-     *         
-     *         return map
-     *     }
-     * }
-     * ```
-     */
-    onBeforeUpdate<T, U = RpgMap>(mapData: T, map: U): U | Promise<U>
+    onBeforeUpdate<T = RpgMap>(mapData: any, map: T): T
 }
 
 export interface RpgServer {

package/src/core/context.ts

@@ -1,4 +1,3 @@
 import { Context } from "@signe/di";
 
 export const context = new Context();
-context['side'] = 'server'

package/src/rooms/map.ts

@@ -220,7 +220,6 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     })
 
     const { x, y, event } = eventObj;
-
     let id = eventObj.id || generateShortUUID()
     let eventInstance: RpgPlayer;
 
@@ -292,83 +291,16 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     delete this.events()[eventId]
   }
 
-  /**
-   * Display a component animation at a specific position on the map
-   * 
-   * This method broadcasts a component animation to all clients connected to the map,
-   * allowing temporary visual effects to be displayed at any location on the map.
-   * Component animations are custom Canvas Engine components that can display
-   * complex effects with custom logic and parameters.
-   * 
-   * @param id - The ID of the component animation to display
-   * @param position - The x, y coordinates where to display the animation
-   * @param params - Parameters to pass to the component animation
-   * 
-   * @example
-   * ```ts
-   * // Show explosion at specific coordinates
-   * map.showComponentAnimation("explosion", { x: 300, y: 400 }, {
-   *   intensity: 2.5,
-   *   duration: 1500
-   * });
-   * 
-   * // Show area damage effect
-   * map.showComponentAnimation("area-damage", { x: player.x, y: player.y }, {
-   *   radius: 100,
-   *   color: "red",
-   *   damage: 50
-   * });
-   * 
-   * // Show treasure spawn effect
-   * map.showComponentAnimation("treasure-spawn", { x: 150, y: 200 }, {
-   *   sparkle: true,
-   *   sound: "treasure-appear"
-   * });
-   * ```
-   */
-  showComponentAnimation(id: string, position: { x: number, y: number }, params: any) {
+  showAnimation(animationName: string, object: RpgPlayer) {
     this.$broadcast({
-      type: "showComponentAnimation",
+      type: 'showEffect',
       value: {
-        id,
-        params,
-        position,
-      },
-    });
-  }
-
-  /**
-   * Display a spritesheet animation at a specific position on the map
-   * 
-   * This method displays a temporary visual animation using a spritesheet at any
-   * location on the map. It's a convenience method that internally uses showComponentAnimation
-   * with the built-in 'animation' component. This is useful for spell effects, environmental
-   * animations, or any visual feedback that uses predefined spritesheets.
-   * 
-   * @param position - The x, y coordinates where to display the animation
-   * @param graphic - The ID of the spritesheet to use for the animation
-   * @param animationName - The name of the animation within the spritesheet (default: 'default')
-   * 
-   * @example
-   * ```ts
-   * // Show explosion at specific coordinates
-   * map.showAnimation({ x: 100, y: 200 }, "explosion");
-   * 
-   * // Show spell effect at player position
-   * const playerPos = { x: player.x, y: player.y };
-   * map.showAnimation(playerPos, "spell-effects", "lightning");
-   * 
-   * // Show environmental effect
-   * map.showAnimation({ x: 300, y: 150 }, "nature-effects", "wind-gust");
-   * 
-   * // Show portal opening animation
-   * map.showAnimation({ x: 500, y: 400 }, "portals", "opening");
-   * ```
-   */
-  showAnimation(position: { x: number, y: number }, graphic: string, animationName: string = 'default') {
-    this.showComponentAnimation('animation', position, {
-      graphic,
-      animationName,
+        id: 'animation',
+        params: {
+          name: animationName
+        },
+        object: object.id
+      }
     })
   }
 }

package/dist/Player/ComponentManager.d.ts

@@ -1,60 +0,0 @@
-import { PlayerCtor } from '@rpgjs/common';
-/**
- * Component Manager Mixin
- *
- * Provides graphic management capabilities to any class. This mixin allows
- * setting single or multiple graphics for player representation, enabling
- * dynamic visual changes and animation sequences.
- *
- * @param Base - The base class to extend with component management
- * @returns Extended class with component management methods
- *
- * @example
- * ```ts
- * class MyPlayer extends WithComponentManager(BasePlayer) {
- *   constructor() {
- *     super();
- *     this.setGraphic("hero");
- *   }
- * }
- *
- * const player = new MyPlayer();
- * player.setGraphic(["hero_idle", "hero_walk"]);
- * ```
- */
-export declare function WithComponentManager<TBase extends PlayerCtor>(Base: TBase): new (...args: ConstructorParameters<TBase>) => InstanceType<TBase> & IComponentManager;
-/**
- * Interface for component management capabilities
- * Defines the method signature that will be available on the player
- */
-export interface IComponentManager {
-    /**
-       * Set the graphic(s) for this player
-       *
-       * Allows setting either a single graphic or multiple graphics for the player.
-       * When multiple graphics are provided, they are used for animation sequences.
-       * The graphics system provides flexible visual representation that can be
-       * dynamically changed during gameplay for different states, equipment, or animations.
-       *
-       * @param graphic - Single graphic name or array of graphic names for animation sequences
-       * @returns void
-       *
-       * @example
-       * ```ts
-       * // Set a single graphic for static representation
-       * player.setGraphic("hero");
-       *
-       * // Set multiple graphics for animation sequences
-       * player.setGraphic(["hero_idle", "hero_walk", "hero_run"]);
-       *
-       * // Dynamic graphic changes based on equipment
-       * if (player.hasArmor('platemail')) {
-       *   player.setGraphic("hero_armored");
-       * }
-       *
-       * // Animation sequences for different actions
-       * player.setGraphic(["mage_cast_1", "mage_cast_2", "mage_cast_3"]);
-       * ```
-       */
-    setGraphic(graphic: string | string[]): void;
-}

package/dist/Player/EffectManager.d.ts

@@ -1,40 +0,0 @@
-import { PlayerCtor } from '@rpgjs/common';
-export declare enum Effect {
-    CAN_NOT_SKILL = "CAN_NOT_SKILL",
-    CAN_NOT_ITEM = "CAN_NOT_ITEM",
-    CAN_NOT_STATE = "CAN_NOT_STATE",
-    CAN_NOT_EQUIPMENT = "CAN_NOT_EQUIPMENT",
-    HALF_SP_COST = "HALF_SP_COST",
-    GUARD = "GUARD",
-    SUPER_GUARD = "SUPER_GUARD"
-}
-/**
- * Effect Manager Mixin
- *
- * Provides effect management capabilities to any class. This mixin handles
- * player effects including restrictions, buffs, and debuffs. Effects can come
- * from various sources like states, equipment, and temporary conditions.
- *
- * @param Base - The base class to extend with effect management
- * @returns Extended class with effect management methods
- *
- * @example
- * ```ts
- * class MyPlayer extends WithEffectManager(BasePlayer) {
- *   constructor() {
- *     super();
- *     // Effect system is automatically initialized
- *   }
- * }
- *
- * const player = new MyPlayer();
- * player.effects = [Effect.GUARD];
- * console.log(player.hasEffect(Effect.GUARD)); // true
- * ```
- */
-export declare function WithEffectManager<TBase extends PlayerCtor>(Base: TBase): TBase;
-/**
- * Type helper to extract the interface from the WithEffectManager mixin
- * This provides the type without duplicating method signatures
- */
-export type IEffectManager = InstanceType<ReturnType<typeof WithEffectManager>>;

package/dist/Player/ElementManager.d.ts

@@ -1,31 +0,0 @@
-import { PlayerCtor } from '@rpgjs/common';
-/**
- * Element Manager Mixin
- *
- * Provides elemental management capabilities to any class. This mixin handles
- * elemental resistances, vulnerabilities, and attack elements. It manages both
- * defensive capabilities (elementsDefense) and offensive elements from equipment,
- * as well as player-specific elemental efficiency modifiers.
- *
- * @param Base - The base class to extend with element management
- * @returns Extended class with element management methods
- *
- * @example
- * ```ts
- * class MyPlayer extends WithElementManager(BasePlayer) {
- *   constructor() {
- *     super();
- *     this.elementsEfficiency = [{ rate: 0.5, element: 'fire' }];
- *   }
- * }
- *
- * const player = new MyPlayer();
- * const fireResistance = player.elementsDefense.find(e => e.element === 'fire');
- * ```
- */
-export declare function WithElementManager<TBase extends PlayerCtor>(Base: TBase): TBase;
-/**
- * Type helper to extract the interface from the WithElementManager mixin
- * This provides the type without duplicating method signatures
- */
-export type IElementManager = InstanceType<ReturnType<typeof WithElementManager>>;

package/dist/Player/GoldManager.d.ts

@@ -1,22 +0,0 @@
-import { PlayerCtor } from '@rpgjs/common';
-export interface GoldManager {
-    /**
-     * You can change the game money
-     *
-     * ```ts
-     * player.gold += 100
-     * ```
-     *
-     * @title Change Gold
-     * @prop {number} player.gold
-     * @default 0
-     * @memberof GoldManager
-     * */
-    gold: number;
-}
-export declare function WithGoldManager<TBase extends PlayerCtor>(Base: TBase): new (...args: ConstructorParameters<TBase>) => InstanceType<TBase> & GoldManager;
-/**
- * Type helper to extract the interface from the WithGoldManager mixin
- * This provides the type without duplicating method signatures
- */
-export type IGoldManager = InstanceType<ReturnType<typeof WithGoldManager>>;

package/dist/Player/GuiManager.d.ts

@@ -1,176 +0,0 @@
-import { RpgPlayer } from './Player';
-import { Gui } from '../Gui';
-import { DialogOptions, Choice } from '../Gui/DialogGui';
-import { PlayerCtor } 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 declare function WithGuiManager<TBase extends PlayerCtor>(Base: TBase): new (...args: ConstructorParameters<TBase>) => InstanceType<TBase> & IGuiManager;
-/**
- * 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/dist/Player/ItemFixture.d.ts

@@ -1,6 +0,0 @@
-import { ItemInstance } from '@rpgjs/database';
-import { PlayerCtor } from '@rpgjs/common';
-export declare function WithItemFixture<TBase extends PlayerCtor>(Base: TBase): TBase;
-export interface ItemFixture {
-    equipments: ItemInstance[];
-}