@rpgjs/server 5.0.0-alpha.14 → 5.0.0-alpha.15

package/src/Player/Player.ts

@@ -23,7 +23,7 @@ import {
 } from "./ParameterManager";
 import { WithItemFixture } from "./ItemFixture";
 import { IItemManager, WithItemManager } from "./ItemManager";
-import { lastValueFrom } from "rxjs";
+import { combineLatest, lastValueFrom } from "rxjs";
 import { IEffectManager, WithEffectManager } from "./EffectManager";
 import { AGI, AGI_CURVE, DEX, DEX_CURVE, INT, INT_CURVE, MAXHP, MAXHP_CURVE, MAXSP, MAXSP_CURVE, STR, STR_CURVE } from "../presets";
 import { IElementManager, WithElementManager } from "./ElementManager";
@@ -98,6 +98,20 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
   context?: Context;
   conn: MockConnection | null = null;
   touchSide: boolean = false; // Protection against map change loops
+  /** Last processed client input timestamp for reconciliation */
+  lastProcessedInputTs: number = 0;
+  /** Last processed client input frame for reconciliation with server tick */
+  _lastFramePositions: {
+    frame: number;
+    position: {
+      x: number;
+      y: number;
+      direction: Direction;
+    };
+    serverTick?: number; // Server tick at which this position was computed
+  } | null = null;
+
+  frames: { x: number; y: number; ts: number }[] = [];
 
   @sync(RpgPlayer) events = signal<RpgEvent[]>([]);
 
@@ -118,6 +132,14 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     (this as any).addParameter(DEX, DEX_CURVE);
     (this as any).addParameter(AGI, AGI_CURVE);
     (this as any).allRecovery();
+
+    combineLatest([this.x.observable, this.y.observable]).subscribe(([x, y]) => {
+      this.frames = [...this.frames, {
+        x: x,
+        y: y,
+        ts: Date.now(),
+      }]
+    })
   }
   
   _onInit() {
@@ -128,6 +150,11 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
     return inject<Hooks>(this.context as any, ModulesToken);
   }
 
+  applyFrames() {
+    this._frames.set(this.frames)
+    this.frames = []
+  }
+
   async execMethod(method: string, methodData: any[] = [], target?: any) {
     let ret: any;
     if (target) {
@@ -293,8 +320,15 @@ export class RpgPlayer extends BasicPlayerMixins(RpgCommonPlayer) {
 
   async teleport(positions: { x: number; y: number }) {
     if (!this.map) return false;
-    // For movable objects like players, the position represents the center
-    this.map.physic.updateHitbox(this.id, positions.x, positions.y);
+    if (this.map.physic) {
+      // Skip collision check for teleportation (allow teleporting through walls)
+      this.map.physic.updateHitbox(this.id, positions.x, positions.y, undefined, undefined, true);
+    }
+    else {
+      this.x.set(positions.x)
+      this.y.set(positions.y)
+    }
+    this._frames.set(this.frames)
   }
 
   getCurrentMap<T extends RpgMap = RpgMap>(): T | null {

package/src/rooms/map.ts

@@ -1,5 +1,5 @@
 import { Action, MockConnection, Request, Room, RoomOnJoin } from "@signe/room";
-import { Hooks, IceMovement, ModulesToken, ProjectileMovement, ProjectileType, RpgCommonMap, ZoneData, Direction } from "@rpgjs/common";
+import { Hooks, IceMovement, ModulesToken, ProjectileMovement, ProjectileType, RpgCommonMap, ZoneData, Direction, RpgCommonPlayer } from "@rpgjs/common";
 import { WorldMapsManager, type WorldMapConfig } from "@rpgjs/common";
 import { RpgPlayer, RpgEvent } from "../Player/Player";
 import { generateShortUUID, sync, type, users } from "@signe/sync";
@@ -12,6 +12,22 @@ import { BehaviorSubject } from "rxjs";
 import { COEFFICIENT_ELEMENTS, DAMAGE_CRITICAL, DAMAGE_PHYSIC, DAMAGE_SKILL } from "../presets";
 import { z } from "zod";
 
+/**
+ * Interface for input controls configuration
+ * 
+ * Defines the structure for input validation and anti-cheat controls
+ */
+export interface Controls {
+  /** Maximum allowed time delta between inputs in milliseconds */
+  maxTimeDelta?: number;
+  /** Maximum allowed frame delta between inputs */
+  maxFrameDelta?: number;
+  /** Minimum time between inputs in milliseconds */
+  minTimeBetweenInputs?: number;
+  /** Whether to enable anti-cheat validation */
+  enableAntiCheat?: boolean;
+}
+
 /**
  * Zod schema for validating map update request body
  * 
@@ -89,31 +105,57 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
   constructor() {
     super();
     this.hooks.callHooks("server-map-onStart", this).subscribe();
-    this.throttleSync = this.isStandalone ? 0 : 100;
+    this.throttleSync = this.isStandalone ? 0 : 50; // Reduced from 100ms to 50ms for better responsiveness
     this.throttleStorage = this.isStandalone ? 0 : 1000;
+    this.sessionExpiryTime = 1000 * 60 * 5; //5 minutes
+    this.loop();
   }
 
-  get isStandalone() {
-    return typeof window !== 'undefined'
+  // autoload by @signe/room
+  interceptorPacket(player: RpgPlayer, packet: any, conn: MockConnection) {
+    let obj: any = {}
+
+    if (!player) {
+      return null
+    }
+
+    // Add timestamp to sync packets for client-side prediction reconciliation
+    if (packet && typeof packet === 'object') {
+      obj.timestamp = Date.now();
+
+      // Add ack info: last processed frame and authoritative position
+      if (player) {
+        const lastFramePositions = player._lastFramePositions;
+        obj.ack = {
+          frame: lastFramePositions?.frame ?? player.pendingInputs.length,
+          x: lastFramePositions?.position?.x ?? player.x(),
+          y: lastFramePositions?.position?.y ?? player.y(),
+          direction: lastFramePositions?.position?.direction ?? player.direction(),
+        };
+      }
+    }
+
+    if (typeof packet.value == 'string') {
+      return packet
+    }
+
+    return {
+      ...packet,
+      value: {
+        ...packet.value,
+        ...obj
+      }
+    };
   }
 
   onJoin(player: RpgPlayer, conn: MockConnection) {
     player.map = this;
     player.context = context;
     player.conn = conn;
-    this.physic.addMovableHitbox(player, player.x(), player.y(), player.hitbox().w, player.hitbox().h, {}, {
-      enabled: true,
-      friction: 0.8,
-      minVelocity: 0.5
-    });
-    this.physic.registerMovementEvents(player.id, () => {
-      player.animationName.set('walk')
-    }, () => {
-      player.animationName.set('stand')
-    })
     player._onInit()
     this.dataIsReady$.pipe(
       finalize(() => {
+        player.applyFrames()
         this.hooks
           .callHooks("server-player-onJoinMap", player, this)
           .subscribe();
@@ -122,10 +164,10 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
   }
 
   onLeave(player: RpgPlayer, conn: MockConnection) {
-    this.physic.removeHitbox(player.id)
     this.hooks
       .callHooks("server-player-onLeaveMap", player, this)
       .subscribe();
+    player.pendingInputs = [];
   }
 
   get hooks() {
@@ -166,7 +208,8 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
 
   @Action('action')
   onAction(player: RpgPlayer, action: any) {
-    const collisions = this.physic.getCollisions(player.id)
+    // Get collisions using the helper method from RpgCommonMap
+    const collisions = (this as any).getCollisions(player.id);
     const events: (RpgEvent | undefined)[] = collisions.map(id => this.getEvent(id))
     if (events.length > 0) {
       events.forEach(event => {
@@ -178,7 +221,19 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
 
   @Action('move')
   async onInput(player: RpgPlayer, input: any) {
-   await this.movePlayer(player, input.input)
+    if (typeof input?.frame === 'number') {
+      // Check if we already have this frame to avoid duplicates
+      const existingInput = player.pendingInputs.find(pending => pending.frame === input.frame);
+      if (existingInput) {
+        return; // Skip duplicate frame
+      }
+
+      player.pendingInputs.push({
+        input: input.input,
+        frame: input.frame,
+        timestamp: input.timestamp || Date.now(),
+      });
+    }
   }
 
   @Request({
@@ -191,11 +246,11 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     this.globalConfig = map.config
     this.damageFormulas = map.damageFormulas || {};
     this.damageFormulas = {
-        damageSkill: DAMAGE_SKILL,
-        damagePhysic: DAMAGE_PHYSIC,
-        damageCritical: DAMAGE_CRITICAL,
-        coefficientElements: COEFFICIENT_ELEMENTS,
-        ...this.damageFormulas
+      damageSkill: DAMAGE_SKILL,
+      damagePhysic: DAMAGE_PHYSIC,
+      damageCritical: DAMAGE_CRITICAL,
+      coefficientElements: COEFFICIENT_ELEMENTS,
+      ...this.damageFormulas
     }
     await lastValueFrom(this.hooks.callHooks("server-maps-load", this))
     await lastValueFrom(this.hooks.callHooks("server-worldMaps-load", this))
@@ -203,13 +258,13 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     map.events = map.events ?? []
 
     if (map.id) {
-     const mapFound = this.maps.find(m => m.id === map.id)
-     if (mapFound?.events) {
-      map.events = [
-        ...mapFound.events,
-        ...map.events
-       ] 
-     }
+      const mapFound = this.maps.find(m => m.id === map.id)
+      if (mapFound?.events) {
+        map.events = [
+          ...mapFound.events,
+          ...map.events
+        ]
+      }
     }
 
     await lastValueFrom(this.hooks.callHooks("server-map-onBeforeUpdate", map, this))
@@ -247,7 +302,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
       const parts = urlObj.pathname.split('/');
       // ['', 'world', ':id', 'update'] → index 2
       worldId = parts[2] ?? '';
-    } catch {}
+    } catch { }
     const payload = await request.json();
 
     // Normalize input to array of WorldMapConfig
@@ -272,6 +327,160 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     return { ok: true } as any;
   }
 
+  /**
+   * Process pending inputs for a player with anti-cheat validation
+   * 
+   * This method processes all pending inputs for a player while performing
+   * anti-cheat validation to prevent time manipulation and frame skipping.
+   * It validates the time deltas between inputs and ensures they are within
+   * acceptable ranges. After processing, it saves the last frame position
+   * for use in packet interception.
+   * 
+   * @param playerId - The ID of the player to process inputs for
+   * @param controls - Optional anti-cheat configuration
+   * @returns Promise containing the player and processed input strings
+   * 
+   * @example
+   * ```ts
+   * // Process inputs with default anti-cheat settings
+   * const result = await map.processInput('player1');
+   * console.log('Processed inputs:', result.inputs);
+   * 
+   * // Process inputs with custom anti-cheat configuration
+   * const result = await map.processInput('player1', {
+   *   maxTimeDelta: 100,
+   *   maxFrameDelta: 5,
+   *   minTimeBetweenInputs: 16,
+   *   enableAntiCheat: true
+   * });
+   * ```
+   */
+  async processInput(playerId: string, controls?: Controls): Promise<{
+    player: RpgPlayer,
+    inputs: string[]
+  }> {
+    const player = this.getPlayer(playerId);
+    if (!player) {
+      throw new Error(`Player ${playerId} not found`);
+    }
+
+    if (!player.isConnected()) {
+      player.pendingInputs = [];
+      return {
+        player,
+        inputs: []
+      }
+    }
+
+    const processedInputs: string[] = [];
+    const defaultControls: Required<Controls> = {
+      maxTimeDelta: 1000, // 1 second max between inputs
+      maxFrameDelta: 10,  // Max 10 frames skipped
+      minTimeBetweenInputs: 16, // ~60fps minimum
+      enableAntiCheat: false
+    };
+
+    const config = { ...defaultControls, ...controls };
+    let lastProcessedTime = player.lastProcessedInputTs || 0;
+    let lastProcessedFrame = 0;
+
+    // Sort inputs by frame number to ensure proper order
+    player.pendingInputs.sort((a, b) => (a.frame || 0) - (b.frame || 0));
+
+    let hasProcessedInputs = false;
+
+    // Process all pending inputs
+    while (player.pendingInputs.length > 0) {
+      const input = player.pendingInputs.shift();
+
+      if (!input || typeof input.frame !== 'number') {
+        continue;
+      }
+
+      // Anti-cheat validation
+      if (config.enableAntiCheat) {
+        // Check frame delta
+        if (input.frame > lastProcessedFrame + config.maxFrameDelta) {
+          // Reset to last valid frame
+          input.frame = lastProcessedFrame + 1;
+        }
+
+        // Check time delta if timestamp is available
+        if (input.timestamp && lastProcessedTime > 0) {
+          const timeDelta = input.timestamp - lastProcessedTime;
+          if (timeDelta > config.maxTimeDelta) {
+            input.timestamp = lastProcessedTime + config.minTimeBetweenInputs;
+          }
+        }
+
+        // Check minimum time between inputs
+        if (input.timestamp && lastProcessedTime > 0) {
+          const timeDelta = input.timestamp - lastProcessedTime;
+          if (timeDelta < config.minTimeBetweenInputs) {
+            continue;
+          }
+        }
+      }
+
+      // Skip if frame is too old (more than 10 frames behind)
+      if (input.frame < lastProcessedFrame - 10) {
+        continue;
+      }
+
+      // Process the input - update velocity based on the latest input
+      if (input.input) {
+        await this.movePlayer(player, input.input);
+        processedInputs.push(input.input);
+        hasProcessedInputs = true;
+        lastProcessedTime = input.timestamp || Date.now();
+      }
+
+      // Update tracking variables
+      lastProcessedFrame = input.frame;
+    }
+
+    // Step physics once after processing all inputs for deterministic physics processing
+    // This matches the pattern used in the physic example where stepOneTick() 
+    // is called in the game loop, not after each individual input. We process all inputs
+    // first to determine the final velocity, then step once.
+    // By processing all inputs before stepping, we avoid multiple steps that cause sliding
+    if (hasProcessedInputs) {
+      this.forceSingleTick();
+      player.lastProcessedInputTs = lastProcessedTime;
+    } else {
+      const idleTimeout = Math.max(config.minTimeBetweenInputs * 4, 50);
+      const lastTs = player.lastProcessedInputTs || 0;
+      if (lastTs > 0 && Date.now() - lastTs > idleTimeout) {
+        (this as any).stopMovement(player);
+        player.lastProcessedInputTs = 0;
+      }
+    }
+
+    // Apply frames after all physics steps have been processed
+    player.applyFrames()
+
+    return {
+      player,
+      inputs: processedInputs
+    };
+  }
+
+  private loop() {
+    setInterval(async () => {
+      for (const player of this.getPlayers()) {
+        if (player.pendingInputs.length > 0) {
+          const anyPlayer = player as RpgPlayer;
+          if (!anyPlayer._isProcessingInputs) {
+            anyPlayer._isProcessingInputs = true;
+            await this.processInput(player.id).finally(() => {
+              anyPlayer._isProcessingInputs = false;
+            });
+          }
+        }
+      }
+    }, 50); // Increased frequency from 100ms to 50ms for better responsiveness
+  }
+
   /**
    * Get a world manager by id (if multiple supported in future)
    */
@@ -359,7 +568,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     if (!eventObj.event) {
       // @ts-ignore
       eventObj = {
-        event: eventObj 
+        event: eventObj
       }
     }
 
@@ -381,7 +590,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     // Check if event is a constructor function (class)
     if (typeof event === 'function') {
       eventInstance = new event();
-    } 
+    }
     // Handle event as an object with hooks
     else {
       // Create a new instance extending RpgPlayer with the hooks from the event object
@@ -397,7 +606,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
 
         constructor() {
           super();
-          
+
           // Copy hooks from the event object
           const hookObj = event as EventHooks;
           if (hookObj.onInit) this.onInit = hookObj.onInit.bind(this);
@@ -419,8 +628,9 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
 
     eventInstance.x.set(x);
     eventInstance.y.set(y);
+    eventInstance.applyFrames()
     if (event.name) eventInstance.name.set(event.name);
-  
+
     this.events()[id] = eventInstance;
 
     await eventInstance.execMethod('onInit')
@@ -434,6 +644,10 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
     return this.players()[playerId]
   }
 
+  getPlayers(): RpgPlayer[] {
+    return Object.values(this.players())
+  }
+
   getEvents(): RpgEvent[] {
     return Object.values(this.events())
   }
@@ -555,7 +769,7 @@ export class RpgMap extends RpgCommonMap<RpgPlayer> implements RoomOnJoin {
 }
 
 export interface RpgMap {
-  $send: (conn: MockConnection, data: any) => void; 
+  $send: (conn: MockConnection, data: any) => void;
   $broadcast: (data: any) => void;
   $sessionTransfer: (userOrPublicId: any | string, targetRoomId: string) => void;
 }