@rpgjs/server 4.3.0 → 5.0.0-alpha.1

package/src/Player/StateManager.ts

@@ -1,40 +1,67 @@
-import { Utils }  from '@rpgjs/common'
-import { ItemFixture } from './ItemFixture'
-import { RpgPlayer } from './Player'
-import { StateLog } from '../logs/state'
+import { isInstanceOf, isString, type Constructor } from "@rpgjs/common";
+import { RpgCommonPlayer, Matter, SeekAvoid } from "@rpgjs/common";
+import { signal, type WritableArraySignal } from "@signe/reactive";
+import { ATK, PDEF, SDEF } from "../presets";
+import { ItemLog, StateLog } from "../logs";
+import { persist } from "@signe/sync";
+import { RpgPlayer } from "./Player";
 
-const { 
-    isInstanceOf,
-    applyMixins,
-    isString
-} = Utils
-
-type StateClass = { new(...args: any[]) }
+interface StateManagerDependencies {
+  equipments(): any[];
+  databaseById(id: string | StateClass): any;
+  addState(stateClass: StateClass | string, chance?: number): object | null;
+  removeState(stateClass: StateClass | string, chance?: number): void;
+}
 
-export class StateManager {
+/**
+ * Interface defining what MoveManager adds to a class
+ */
+export interface IStateManager {
+  statesDefense: { rate: number; state: any }[];
+  statesEfficiency: WritableArraySignal<any[]>;
+  applyStates(
+    player: RpgPlayer,
+    states: { addStates?: any[]; removeStates?: any[] }
+  ): void;
+  getState(stateClass: StateClass | string): any;
+  addState(stateClass: StateClass | string, chance?: number): object | null;
+  removeState(stateClass: StateClass | string, chance?: number): void;
+}
 
-    states: any[] = []
+type StateClass = { new (...args: any[]) };
 
-    _statesEfficiency: { rate: number, state: any }[]
+/**
+ * Move Manager mixin
+ *
+ * Adds methods to manage player movement
+ *
+ * @param Base - The base class to extend
+ * @returns A new class with move management capabilities
+ */
+export function WithStateManager<
+  TBase extends Constructor<RpgCommonPlayer & StateManagerDependencies>
+>(Base: TBase): Constructor<IStateManager> & TBase {
+  return class extends Base implements IStateManager {
+    _statesEfficiency = signal<any[]>([]);
 
-    /** 
+    /**
      * Recovers the player's states defense on inventory.  This list is generated from the `statesDefense` 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, State } from '@rpgjs/server'
-     * 
+     *
      * @State({
      *      name: 'Paralyze'
      * })
      * class Paralyze {}
-     * 
+     *
      * @Armor({
      *      name: 'Shield',
      *      statesDefense: [{ rate: 1, state: Paralyze }]
      * })
      * class Shield {}
-     * 
+     *
      * @Armor({
      *      name: 'FireShield',
      *      statesDefense: [{ rate: 0.5, state: Paralyze }]
@@ -45,81 +72,84 @@ export class StateManager {
      * player.addItem(FireShield)
      * player.equip(Shield)
      * player.equip(FireShield)
-     * 
+     *
      * console.log(player.statesDefense) // [{ rate: 1, state: instance of Paralyze }]
-     * ``` 
+     * ```
      * @title Get States Defense
      * @prop {Array<{ rate: number, state: StateClass}>} player.statesDefense
      * @readonly
      * @memberof StateManager
      * */
-    get statesDefense(): { rate: number, state: any }[] {
-        return this.getFeature('statesDefense', 'state')
+    get statesDefense(): { rate: number; state: any }[] {
+      return this.getFeature("statesDefense", "state");
     }
 
-    /** 
-     * Set or retrieves all the states where the player is vulnerable or not. 
-     * 
+    /**
+     * Set or retrieves all the states where the player is vulnerable or not.
+     *
      * ```ts
      * import { Class, State } from '@rpgjs/server'
-     * 
+     *
      * @State({
      *      name: 'Paralyze'
      * })
      * class Paralyze {}
-     * 
+     *
      * @State({
      *      name: 'Sleep'
      * })
      * class Sleep {}
-     * 
+     *
      * @Class({
      *      name: 'Fighter',
      *      statesEfficiency: [{ rate: 1, state: Paralyze }]
      * })
      * class Hero {}
-     * 
+     *
      * player.setClass(Hero)
-     * 
+     *
      * console.log(player.statesEfficiency) // [{ rate: 1, instance of Paralyze }]
-     * 
+     *
      * player.statesEfficiency = [{ rate: 2, state: Sleep }]
-     * 
+     *
      * console.log(player.statesEfficiency) // [{ rate: 1, state: instance of Paralyze }, { rate: 2, state: instance of Sleep }]
-     * ``` 
+     * ```
      * @title Set/Get States Efficiency
      * @prop {Array<{ rate: number, state: StateClass}>} player.statesEfficiency
      * @memberof StateManager
      * */
     get statesEfficiency() {
-        return this._statesEfficiency
+      return this._statesEfficiency;
     }
 
     set statesEfficiency(val) {
-        this._statesEfficiency = val
+      this._statesEfficiency = val;
     }
 
-    applyStates(player: RpgPlayer, { addStates, removeStates }) {
-        if (addStates) {
-            for (let { state, rate } of addStates) {
-                player.addState(state, rate)
-            }
+    applyStates(
+      player: RpgPlayer & IStateManager,
+      { addStates, removeStates }
+    ) {
+      if (addStates) {
+        for (let { state, rate } of addStates) {
+          player.addState(state, rate);
         }
-        if (removeStates) {
-            for (let { state, rate } of removeStates) {
-                player.removeState(state, rate)
-            }
-        } 
+      }
+      if (removeStates) {
+        for (let { state, rate } of removeStates) {
+          player.removeState(state, rate);
+        }
+      }
     }
 
     /**
      * Get a state to the player. Returns `null` if the state is not present on the player
      * ```ts
      * import Paralyze from 'your-database/states/paralyze'
-     * 
+     *
      * player.getState(Paralyze)
      *  ```
-     * 
+     *
      * @title Get State
      * @method player.getState(stateClass)
      * @param {StateClass | string} stateClass or state id
@@ -127,33 +157,33 @@ export class StateManager {
      * @memberof StateManager
      */
     getState(stateClass: StateClass | string) {
-        if (isString(stateClass)) stateClass = this.databaseById(stateClass)
-        return this.states.find((state) => {
-            if (isString(stateClass)) {
-                return state.id == stateClass
-            }
-            return isInstanceOf(state, stateClass)
-        })
+      if (isString(stateClass)) stateClass = this.databaseById(stateClass);
+      return this.states().find((state) => {
+        if (isString(stateClass)) {
+          return state.id == stateClass;
+        }
+        return isInstanceOf(state, stateClass);
+      });
     }
 
     /**
      * Adds a state to the player. Set the chance between 0 and 1 that the state can apply
      * ```ts
      * import Paralyze from 'your-database/states/paralyze'
-     * 
-     * try { 
+     *
+     * try {
      *      player.addState(Paralyze)
      * }
      * catch (err) {
      *      console.log(err)
      * }
      *  ```
-     * 
+     *
      * @title Add State
      * @method player.addState(stateClass,chance=1)
      * @param {StateClass | string} stateClass state class or state id
      * @param {number} [chance] 1 by default
-     * @throws {StateLog} addFailed 
+     * @throws {StateLog} addFailed
      * If the chance to add the state has failed (defined with the `chance` param)
      *  ```
      * {
@@ -166,41 +196,41 @@ export class StateManager {
      * @todo
      */
     addState(stateClass: StateClass | string, chance = 1): object | null {
-        const state = this.getState(stateClass)
-        if (isString(stateClass)) {
-            stateClass = this.databaseById(stateClass)
+      const state = this.getState(stateClass);
+      if (isString(stateClass)) {
+        stateClass = this.databaseById(stateClass);
+      }
+      if (!state) {
+        if (Math.random() > chance) {
+          throw StateLog.addFailed(stateClass);
         }
-        if (!state) {
-            if (Math.random() > chance) {
-                throw StateLog.addFailed(stateClass)
-            }
-            //const efficiency = this.findStateEfficiency(stateClass)
-            const instance = new (stateClass as StateClass)()
-            this.states.push(instance)
-            this.applyStates(<any>this, instance)
-            return instance
-        }
-        return null
+        //const efficiency = this.findStateEfficiency(stateClass)
+        const instance = new (stateClass as StateClass)();
+        this.states().push(instance);
+        this.applyStates(<any>this, instance);
+        return instance;
+      }
+      return null;
     }
 
     /**
      * Remove a state to the player. Set the chance between 0 and 1 that the state can be removed
      * ```ts
      * import Paralyze from 'your-database/states/paralyze'
-     * 
-     * try { 
+     *
+     * try {
      *      player.removeState(Paralyze)
      * }
      * catch (err) {
      *      console.log(err)
      * }
      *  ```
-     * 
+     *
      * @title Remove State
      * @method player.removeState(stateClass,chance=1)
      * @param {StateClass|string} stateClass class state or state id
      * @param {number} [chance] 1 by default
-     * @throws {StateLog} removeFailed 
+     * @throws {StateLog} removeFailed
      * If the chance to remove the state has failed (defined with the `chance` param)
      *  ```
      * {
@@ -208,7 +238,7 @@ export class StateManager {
      *      msg: '...'
      * }
      * ```
-     * @throws {StateLog} notApplied 
+     * @throws {StateLog} notApplied
      * If the status does not exist
      *  ```
      * {
@@ -220,30 +250,26 @@ export class StateManager {
      * @memberof StateManager
      */
     removeState(stateClass: StateClass | string, chance = 1) {
-        const index = this.states.findIndex((state) => {
-            if (isString(stateClass)) {
-                return state.id == stateClass
-            }
-            return isInstanceOf(state, stateClass)
-        })
-        if (index != -1) {
-            if (Math.random() > chance) {
-                throw StateLog.removeFailed(stateClass)
-            }
-            this.states.splice(index, 1)
+      const index = this.states().findIndex((state) => {
+        if (isString(stateClass)) {
+          return state.id == stateClass;
         }
-        else {
-            throw StateLog.notApplied(stateClass)
+        return isInstanceOf(state, stateClass);
+      });
+      if (index != -1) {
+        if (Math.random() > chance) {
+          throw StateLog.removeFailed(stateClass);
         }
+        this.states().splice(index, 1);
+      } else {
+        throw StateLog.notApplied(stateClass);
+      }
     }
 
     private findStateEfficiency(stateClass) {
-        return this.statesEfficiency.find(state => isInstanceOf(state.state, stateClass))
+      return this.statesEfficiency().find((state) =>
+        isInstanceOf(state.state, stateClass)
+      );
     }
+  };
 }
-
-applyMixins(StateManager, [ItemFixture])
-
-export interface StateManager extends ItemFixture { 
-    databaseById(stateClass: any),
-}

package/src/Player/VariableManager.ts

@@ -1,5 +1,24 @@
-export class VariableManager {
-    variables: Map<string, any>
+import { type Constructor } from "@rpgjs/common";
+import { RpgCommonPlayer } from "@rpgjs/common";
+
+/**
+ * Interface defining what MoveManager adds to a class
+ */
+export interface IWithVariableManager {
+  variables: Map<string, any>
+}
+
+/**
+ * Move Manager mixin
+ * 
+ * Adds methods to manage player movement
+ * 
+ * @param Base - The base class to extend
+ * @returns A new class with move management capabilities
+ */
+export function WithVariableManager<TBase extends Constructor<RpgCommonPlayer>>(Base: TBase) {
+  return class extends Base implements IWithVariableManager {
+    variables: Map<string, any> = new Map()
 
     /** 
      * Assign a variable to the player
@@ -52,4 +71,5 @@ export class VariableManager {
     removeVariable(key: string) {
         return this.variables.delete(key)
     }
-}
+  };
+}

package/src/RpgServer.ts

@@ -1,13 +1,17 @@
-import { ModuleType, RpgShape, Direction, Control } from '@rpgjs/common'
-import { RpgClassEvent, RpgEvent, RpgPlayer } from './Player/Player'
-import { RpgMap } from './Game/Map'
-import { RpgServerEngine } from './server'
-import { MapOptions } from './decorators/map'
-import { RpgClassMap } from './Scenes/Map'
-import { TiledMap } from '@rpgjs/tiled'
-import { WorldMap } from './Game/WorldMaps'
-import { MatchMakerOption, RpgMatchMaker } from './MatchMaker'
-import { IStoreState } from './Interfaces/StateStore'
+import { RpgPlayer } from "./Player/Player"
+import { type RpgMap } from "./rooms/map"
+import { RpgServerEngine } from "./RpgServerEngine"
+
+type RpgShape = any
+type RpgClassMap<T> = any
+type RpgClassEvent<T> = any
+type RpgEvent = any
+type MatchMakerOption = any
+type RpgMatchMaker = any
+type IStoreState = any
+type TiledMap = any
+type WorldMap = any
+type MapOptions = any
 
 export interface RpgServerEngineHooks {
     /**
@@ -152,7 +156,7 @@ export interface RpgPlayerHooks {
     * @prop { (player: RpgPlayer, data: { input: Direction | Control | string, moving: boolean }) => any } [onInput]
     * @memberof RpgPlayerHooks
     */
-    onInput?: (player: RpgPlayer, data: { input: Direction | Control | string, moving: boolean }) => any
+    onInput?: (player: RpgPlayer, data: any) => any
 
     /**
     *  When the player leaves the map
@@ -223,6 +227,22 @@ export interface RpgPlayerHooks {
     canChangeMap?: (player: RpgPlayer, nextMap: RpgClassMap<RpgMap>) => boolean | Promise<boolean>
 }
 
+export interface RpgEventHooks {
+    onInit?: (event: RpgEvent) => any,
+    onAction?: (event: RpgEvent, player: RpgPlayer) => any
+    onBeforeCreated?: (object: any, map: RpgMap) => any
+    onDetectInShape?: (event: RpgEvent, player: RpgPlayer, shape: RpgShape) => any
+    onDetectOutShape?: (event: RpgEvent, player: RpgPlayer, shape: RpgShape) => any
+    onInShape?: (event: RpgEvent, shape: RpgShape) => any
+    onOutShape?: (event: RpgEvent, shape: RpgShape) => any
+    onPlayerTouch?: (event: RpgEvent, player: RpgPlayer) => any
+    onChanges?: (event: RpgEvent, player: RpgPlayer) => any
+}
+
+export interface RpgMapHooks {
+    onBeforeUpdate<T = RpgMap>(mapData: any, map: T): T
+}
+
 export interface RpgServer {
     /**
      * Add hooks to the player or engine. All modules can listen to the hook
@@ -275,7 +295,7 @@ export interface RpgServer {
      * @prop { { client: null | Function, server: null | Function }[]} [imports]
      * @memberof RpgServer
      */
-    imports?: ModuleType[]
+    imports?: any
 
     /**
      * Object containing the hooks concerning the engine
@@ -395,6 +415,10 @@ export interface RpgServer {
      * */
     maps?: RpgClassMap<RpgMap>[] | MapOptions[] | string[] | TiledMap[],
 
+    map?: RpgMapHooks
+
+    event?: RpgEventHooks
+
     /**
      * Array of all events. Each element is an `RpgEvent` class
      * Events can be used by placing a shape with the name of the event on Tiled Map Editor

package/src/RpgServerEngine.ts

@@ -0,0 +1,7 @@
+import { Server } from "@signe/room";
+import { RpgMap } from "./rooms/map";
+import { LobbyRoom } from "./rooms/lobby";
+
+export class RpgServerEngine extends Server {
+  rooms = [RpgMap, LobbyRoom];
+}

package/src/core/context.ts

@@ -0,0 +1,3 @@
+import { Context } from "@signe/di";
+
+export const context = new Context();

package/src/core/inject.ts

@@ -0,0 +1,17 @@
+import { Context, inject as injector } from "@signe/di";
+
+export let context: Context | null = null
+
+export function inject<T>(service: (new (...args: any[]) => T) | string, _context?: Context): T {
+    const c = _context ?? context
+    if (!c) throw new Error("Context is not set. use setInject() to set the context");
+    return injector(c, service);
+}
+
+export function setInject(_context: Context) {
+    context = _context;
+}
+
+export function clearInject() {
+    context = null
+}

package/src/core/setup.ts

@@ -0,0 +1,20 @@
+import { injector, Providers } from "@signe/di";
+import { RpgServerEngine } from "../RpgServerEngine";
+import { context } from "./context";
+import { setInject } from "./inject";
+
+interface SetupOptions {
+  providers: Providers;
+}
+
+export function createServer(options: SetupOptions): any {
+  return class extends RpgServerEngine {
+    config = options;
+    
+    async onStart() {
+      setInject(context);
+      await injector(context, options.providers);
+      return super.onStart();
+    }
+  };
+}

package/src/index.ts

@@ -1,31 +1,9 @@
-export { default as entryPoint } from './entry-point'
-export {
-    Direction,
-    Input,
-    Control,
-    RpgPlugin,
-    HookServer,
-    HookClient,
-    RpgModule,
-    RpgShape,
-    ShapePositioning,
-    AbstractObject
-} from '@rpgjs/common'
-export type { RpgServer, RpgPlayerHooks, RpgServerEngineHooks } from './RpgServer'
-export { EventData } from './decorators/event'
-export { MapData } from './decorators/map'
-export { RpgPlayer, RpgEvent } from './Player/Player'
-export { EventMode } from './Game/EventManager'
-export { RpgMap } from './Game/Map'
-export { RpgWorldMaps } from './Game/WorldMaps'
-export { Query, Query as RpgWorld } from './Query'
-export { default as Monitor } from './Monitor'
-export * as Presets from './presets'
-export { Move, Frequency, Speed } from './Player/MoveManager'
-export { RpgServerEngine } from './server'
-export { SceneMap as RpgSceneMap, type RpgClassMap } from './Scenes/Map'
-export { RpgMatchMaker } from './MatchMaker'
-export type { IStoreState } from './Interfaces/StateStore'
-export { Components } from './Player/ComponentManager'
-export { Gui } from './Gui/Gui'
-export { inject } from './inject'
+export * from "./RpgServerEngine";
+export * from "./Player/MoveManager";
+export * from "./RpgServer";
+export * from "./core/setup";
+export * from "./core/inject";
+export * from "./Player/Player";
+export * from "./module";
+export * from "./rooms/map";
+export * from "./presets";

package/src/module.ts

@@ -0,0 +1,32 @@
+import { findModules, provideModules } from "@rpgjs/common";
+import { FactoryProvider } from "@signe/di";
+import { RpgServerEngine } from "./RpgServerEngine";
+import { RpgMap } from "./rooms/map";
+
+export function provideServerModules(modules: any[]): FactoryProvider {
+  return provideModules(modules, "server", (modules, context) => {
+    const mainModuleServer = findModules(context, 'Server')
+    modules = [...mainModuleServer, ...modules]
+    modules = modules.map((module) => {
+      if ('server' in module) {
+        module = module.server as any;
+      }
+      if (module.maps && Array.isArray(module.maps)) {
+        const maps = [...module.maps];
+        module = {
+          ...module,
+          maps: {
+            load: (engine: RpgMap) => {
+              maps.forEach((map) => {
+                engine.maps.push(map);
+              });
+            },
+          }
+        };
+      }
+      return module;
+    })
+    return modules
+  });
+}
+ 

package/src/presets/index.ts

@@ -1,6 +1,4 @@
-import { Utils } from '@rpgjs/common'
-
-const { random } = Utils
+import { random } from "@rpgjs/common"
 
 export const MAXHP: string = 'maxHp'
 export const MAXSP: string = 'maxSp'

package/src/rooms/lobby.ts

@@ -0,0 +1,24 @@
+import { inject } from "@signe/di";
+import { MockConnection, Room } from "@signe/room";
+import { Hooks, ModulesToken } from "@rpgjs/common";
+import { context } from "../core/context";
+import { users } from "@signe/sync";
+import { signal } from "@signe/reactive";
+import { RpgPlayer } from "../Player/Player";
+
+@Room({
+  path: "lobby-{id}",
+})
+export class LobbyRoom {
+  @users(RpgPlayer) players = signal({});
+
+  onJoin(player: RpgPlayer, conn: MockConnection) {
+    player.map = this;
+    player.context = context;
+    player.conn = conn;
+    const hooks = inject<Hooks>(context, ModulesToken);
+    hooks
+      .callHooks("server-player-onConnected", player)
+      .subscribe();
+  }
+}