@rpgjs/server 5.0.0-alpha.42 → 5.0.0-alpha.44

package/src/Player/SkillManager.ts

@@ -176,6 +176,48 @@ export interface SkillObject extends SkillHooks {
  */
 export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
   return class extends (Base as any) {
+    private _getSkillSnapshot(skillData: any) {
+      if (!skillData) return null;
+
+      const snapshot = {
+        ...((skillData as any)._skillData || skillData),
+      };
+
+      const reactiveKeys = [
+        "id",
+        "name",
+        "description",
+        "spCost",
+        "icon",
+        "hitRate",
+        "power",
+        "coefficient",
+      ];
+
+      for (const key of reactiveKeys) {
+        const value = (skillData as any)[key];
+        if (typeof value === "function") {
+          if (key === "hitRate" && !(key in snapshot)) {
+            continue;
+          }
+          snapshot[key] = value();
+        } else if (value !== undefined) {
+          snapshot[key] = value;
+        }
+      }
+
+      if ((skillData as any)._skillInstance) {
+        snapshot._skillInstance = (skillData as any)._skillInstance;
+      }
+
+      return snapshot;
+    }
+
+    private _getLearnedSkillEntry(skillInput: SkillClass | SkillObject | string): Skill | null {
+      const index = this._getSkillIndex(skillInput);
+      return index >= 0 ? ((this as any).skills()[index] as Skill) : null;
+    }
+
     private _getSkillMap(required: boolean = true) {
       // Use this.map directly to support both RpgMap and LobbyRoom
       const map = (this as any).getCurrentMap?.() || (this as any).map;
@@ -246,6 +288,10 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
     ) {
       const instance = new Skill(skillData);
       instance.id.set(skillId);
+      (instance as any)._skillData = {
+        ...skillData,
+        id: skillId,
+      };
 
       if (skillInstance) {
         (instance as any)._skillInstance = skillInstance;
@@ -349,8 +395,8 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
      * ```
      */
     getSkill(skillInput: SkillClass | SkillObject | string): Skill | null {
-      const index = this._getSkillIndex(skillInput);
-      return (this as any).skills()[index] as Skill ?? null;
+      const skill = this._getLearnedSkillEntry(skillInput);
+      return this._getSkillSnapshot(skill) as Skill | null;
     }
 
     /**
@@ -389,7 +435,7 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
       const { skillId, skillData, skillInstance } = this._resolveSkillInput(skillInput, map);
 
       // Check if already learned
-      if (this.getSkill(skillId)) {
+      if (this._getLearnedSkillEntry(skillId)) {
         throw SkillLog.alreadyLearned(skillData);
       }
 
@@ -438,11 +484,15 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
         throw SkillLog.notLearned(skillData);
       }
       
-      const skillData = (this as any).skills()[index];
+      const skillEntry = (this as any).skills()[index];
+      const skillData = this._getSkillSnapshot(skillEntry);
       (this as any).skills().splice(index, 1);
       
       // Call onForget hook
-      const hookTarget = (skillData as any)?._skillInstance || skillData;
+      const hookTarget =
+        (skillEntry as any)?._skillInstance ||
+        (skillEntry as any)?._skillData ||
+        skillData;
       this["execMethod"]("onForget", [this], hookTarget);
       
       return skillData;
@@ -475,7 +525,8 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
      * ```
      */
     useSkill(skillInput: SkillClass | SkillObject | string, otherPlayer?: RpgPlayer | RpgPlayer[]): any {
-      const skill = this.getSkill(skillInput);
+      const skillEntry = this._getLearnedSkillEntry(skillInput);
+      const skill = this._getSkillSnapshot(skillEntry);
       
       // Check for skill restriction effect
       if ((this as any).hasEffect(Effect.CAN_NOT_SKILL)) {
@@ -488,7 +539,7 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
       }
       
       // Check SP cost
-      const spCost = skill.spCost || 0;
+      const spCost = typeof skill.spCost === "number" ? skill.spCost : 0;
       if (spCost > (this as any).sp) {
         throw SkillLog.notEnoughSp(skill, spCost, (this as any).sp);
       }
@@ -498,9 +549,12 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
       (this as any).sp -= spCost / costMultiplier;
       
       // Check hit rate
-      const hitRate = skill.hitRate ?? 1;
+      const hitRate = typeof skill.hitRate === "number" ? skill.hitRate : 1;
       if (Math.random() > hitRate) {
-        const hookTarget = (skill as any)?._skillInstance || skill;
+        const hookTarget =
+          (skillEntry as any)?._skillInstance ||
+          (skillEntry as any)?._skillData ||
+          skill;
         this["execMethod"]("onUseFailed", [this, otherPlayer], hookTarget);
         throw SkillLog.chanceToUseFailed(skill);
       }
@@ -515,7 +569,10 @@ export function WithSkillManager<TBase extends PlayerCtor>(Base: TBase): TBase {
       }
       
       // Call onUse hook
-      const hookTarget = (skill as any)?._skillInstance || skill;
+      const hookTarget =
+        (skillEntry as any)?._skillInstance ||
+        (skillEntry as any)?._skillData ||
+        skill;
       this["execMethod"]("onUse", [this, otherPlayer], hookTarget);
       
       return skill;

package/src/Player/VariableManager.ts

@@ -30,7 +30,9 @@ export function WithVariableManager<TBase extends PlayerCtor>(Base: TBase) {
     variables = type(signal<Record<string, any>>({}) as any, 'variables', { persist: true }, this as any);
 
     setVariable(key: string, val: any): void {
-      this.variables()[key] = val;
+      this.variables.mutate((variables) => {
+        variables[key] = val;
+      });
     }
 
     getVariable<U = any>(key: string): U | undefined {
@@ -38,7 +40,13 @@ export function WithVariableManager<TBase extends PlayerCtor>(Base: TBase) {
     }
 
     removeVariable(key: string): boolean {
-      delete this.variables()[key];
+      const variables = this.variables();
+      if (!(key in variables)) {
+        return false;
+      }
+      this.variables.mutate((draft) => {
+        delete draft[key];
+      });
       return true;
     }
 
@@ -110,4 +118,4 @@ export interface IVariableManager {
    * Clear all variables
    */
   clearVariables(): void;
-}
+}

package/src/node/connection.ts

@@ -0,0 +1,254 @@
+import type { RpgWebSocketConnection } from "./types";
+
+type RuntimeProcess = {
+  env?: Record<string, string | undefined>;
+};
+
+function readEnvVariable(name: string): string | undefined {
+  const value = (globalThis as { process?: RuntimeProcess }).process?.env?.[name];
+  return typeof value === "string" ? value : undefined;
+}
+
+export class PartyConnection {
+  public id: string;
+  public uri: string;
+  private _state: any = {};
+  private messageQueue: Array<{ message: string; timestamp: number; sequence: number }> = [];
+  private isProcessingQueue = false;
+  private sequenceCounter = 0;
+  private incomingQueue: Array<{
+    message: string;
+    timestamp: number;
+    processor: (messages: string[]) => Promise<void>;
+  }> = [];
+  private isProcessingIncomingQueue = false;
+
+  public static packetLossRate = parseFloat(readEnvVariable("RPGJS_PACKET_LOSS_RATE") || "0.1");
+  public static packetLossEnabled = readEnvVariable("RPGJS_ENABLE_PACKET_LOSS") === "true";
+  public static packetLossFilter = readEnvVariable("RPGJS_PACKET_LOSS_FILTER") || "";
+  public static bandwidthEnabled = readEnvVariable("RPGJS_ENABLE_BANDWIDTH") === "true";
+  public static bandwidthKbps = parseInt(readEnvVariable("RPGJS_BANDWIDTH_KBPS") || "100");
+  public static bandwidthFilter = readEnvVariable("RPGJS_BANDWIDTH_FILTER") || "";
+  public static latencyEnabled = readEnvVariable("RPGJS_ENABLE_LATENCY") === "true";
+  public static latencyMs = parseInt(readEnvVariable("RPGJS_LATENCY_MS") || "50");
+  public static latencyFilter = readEnvVariable("RPGJS_LATENCY_FILTER") || "";
+
+  constructor(private ws: RpgWebSocketConnection, id?: string, uri?: string) {
+    this.id = id || this.generateId();
+    this.uri = uri || "";
+  }
+
+  private generateId(): string {
+    return `conn_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+  }
+
+  async send(data: any): Promise<void> {
+    if (this.ws.readyState !== 1) {
+      return;
+    }
+
+    const message = typeof data === "string" ? data : JSON.stringify(data);
+    const timestamp = Date.now();
+    const sequence = ++this.sequenceCounter;
+
+    this.messageQueue.push({ message, timestamp, sequence });
+
+    if (!this.isProcessingQueue) {
+      void this.processMessageQueue();
+    }
+  }
+
+  private async processMessageQueue(): Promise<void> {
+    if (this.isProcessingQueue) {
+      return;
+    }
+    this.isProcessingQueue = true;
+
+    while (this.messageQueue.length > 0) {
+      const queueItem = this.messageQueue.shift()!;
+
+      if (this.shouldApplyLatency(queueItem.message)) {
+        await this.waitUntil(queueItem.timestamp + PartyConnection.latencyMs);
+      }
+
+      if (PartyConnection.bandwidthEnabled && PartyConnection.bandwidthKbps > 0) {
+        if (!PartyConnection.bandwidthFilter || queueItem.message.includes(PartyConnection.bandwidthFilter)) {
+          const messageSizeBits = queueItem.message.length * 8;
+          const transmissionTimeMs = (messageSizeBits / (PartyConnection.bandwidthKbps * 1000)) * 1000;
+          const bandwidthDelayMs = Math.max(transmissionTimeMs, 10);
+          console.log(
+            `\x1b[34m[BANDWIDTH SIMULATION]\x1b[0m Connection ${this.id}: Message #${queueItem.sequence} transmission time: ${bandwidthDelayMs.toFixed(1)}ms`,
+          );
+          await new Promise((resolve) => setTimeout(resolve, bandwidthDelayMs));
+        }
+      }
+
+      this.ws.send(queueItem.message);
+    }
+
+    this.isProcessingQueue = false;
+  }
+
+  private shouldApplyLatency(message: string): boolean {
+    if (!PartyConnection.latencyEnabled || PartyConnection.latencyMs <= 0) {
+      return false;
+    }
+    if (!PartyConnection.latencyFilter) {
+      return true;
+    }
+    return message.includes(PartyConnection.latencyFilter);
+  }
+
+  private async waitUntil(targetTimestamp: number): Promise<void> {
+    const delayMs = targetTimestamp - Date.now();
+    if (delayMs <= 0) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+
+  close(): void {
+    if (this.ws.readyState === 1) {
+      this.ws.close();
+    }
+  }
+
+  setState(value: any): void {
+    this._state = value;
+  }
+
+  get state(): any {
+    return this._state;
+  }
+
+  bufferIncoming(message: string, processor: (messages: string[]) => Promise<void>): void {
+    this.incomingQueue.push({
+      message,
+      timestamp: Date.now(),
+      processor,
+    });
+
+    if (!this.isProcessingIncomingQueue) {
+      void this.processIncomingQueue();
+    }
+  }
+
+  private async processIncomingQueue(): Promise<void> {
+    if (this.isProcessingIncomingQueue) {
+      return;
+    }
+    this.isProcessingIncomingQueue = true;
+
+    while (this.incomingQueue.length > 0) {
+      const item = this.incomingQueue.shift()!;
+      if (this.shouldApplyLatency(item.message)) {
+        await this.waitUntil(item.timestamp + PartyConnection.latencyMs);
+      }
+      try {
+        await item.processor([item.message]);
+      } catch (err) {
+        console.error("Error processing incoming message:", err);
+      }
+    }
+
+    this.isProcessingIncomingQueue = false;
+  }
+
+  static configurePacketLoss(enabled: boolean, rate: number, filter?: string): void {
+    PartyConnection.packetLossEnabled = enabled;
+    PartyConnection.packetLossRate = Math.max(0, Math.min(1, rate));
+    PartyConnection.packetLossFilter = filter || "";
+
+    if (enabled && rate > 0) {
+      const filterInfo = filter ? ` (filtered: "${filter}")` : "";
+      console.log(`\x1b[35m[PACKET LOSS SIMULATION]\x1b[0m Enabled with ${(rate * 100).toFixed(1)}% loss rate${filterInfo}`);
+    } else if (enabled) {
+      console.log("\x1b[35m[PACKET LOSS SIMULATION]\x1b[0m Enabled but rate is 0% (no messages will be dropped)");
+    } else {
+      console.log("\x1b[35m[PACKET LOSS SIMULATION]\x1b[0m Disabled");
+    }
+  }
+
+  static getPacketLossStatus(): { enabled: boolean; rate: number; filter: string } {
+    return {
+      enabled: PartyConnection.packetLossEnabled,
+      rate: PartyConnection.packetLossRate,
+      filter: PartyConnection.packetLossFilter,
+    };
+  }
+
+  static configureBandwidth(enabled: boolean, kbps: number, filter?: string): void {
+    PartyConnection.bandwidthEnabled = enabled;
+    PartyConnection.bandwidthKbps = Math.max(1, kbps);
+    PartyConnection.bandwidthFilter = filter || "";
+
+    if (enabled && kbps > 0) {
+      const filterInfo = filter ? ` (filtered: "${filter}")` : "";
+      console.log(`\x1b[35m[BANDWIDTH SIMULATION]\x1b[0m Enabled with ${kbps} kbps bandwidth${filterInfo}`);
+    } else if (enabled) {
+      console.log("\x1b[35m[BANDWIDTH SIMULATION]\x1b[0m Enabled but bandwidth is 0 kbps (no delay will be applied)");
+    } else {
+      console.log("\x1b[35m[BANDWIDTH SIMULATION]\x1b[0m Disabled");
+    }
+  }
+
+  static getBandwidthStatus(): { enabled: boolean; kbps: number; filter: string } {
+    return {
+      enabled: PartyConnection.bandwidthEnabled,
+      kbps: PartyConnection.bandwidthKbps,
+      filter: PartyConnection.bandwidthFilter,
+    };
+  }
+
+  static configureLatency(enabled: boolean, ms: number, filter?: string): void {
+    PartyConnection.latencyEnabled = enabled;
+    PartyConnection.latencyMs = Math.max(0, ms);
+    PartyConnection.latencyFilter = filter || "";
+
+    if (enabled && ms > 0) {
+      const filterInfo = filter ? ` (filtered: "${filter}")` : "";
+      console.log(`\x1b[35m[LATENCY SIMULATION]\x1b[0m Enabled with ${ms}ms fixed latency${filterInfo}`);
+    } else if (enabled) {
+      console.log("\x1b[35m[LATENCY SIMULATION]\x1b[0m Enabled but latency is 0ms (no delay will be applied)");
+    } else {
+      console.log("\x1b[35m[LATENCY SIMULATION]\x1b[0m Disabled");
+    }
+  }
+
+  static getLatencyStatus(): { enabled: boolean; ms: number; filter: string } {
+    return {
+      enabled: PartyConnection.latencyEnabled,
+      ms: PartyConnection.latencyMs,
+      filter: PartyConnection.latencyFilter,
+    };
+  }
+}
+
+export function logNetworkSimulationStatus(): void {
+  const packetLossStatus = PartyConnection.getPacketLossStatus();
+  const bandwidthStatus = PartyConnection.getBandwidthStatus();
+  const latencyStatus = PartyConnection.getLatencyStatus();
+
+  if (packetLossStatus.enabled) {
+    const filterInfo = packetLossStatus.filter ? ` (filter: "${packetLossStatus.filter}")` : "";
+    console.log(
+      `\x1b[36m[NETWORK SIMULATION]\x1b[0m Packet loss simulation: ${(packetLossStatus.rate * 100).toFixed(1)}% loss rate${filterInfo}`,
+    );
+  } else {
+    console.log("\x1b[36m[NETWORK SIMULATION]\x1b[0m Packet loss simulation: disabled");
+  }
+
+  if (bandwidthStatus.enabled) {
+    const filterInfo = bandwidthStatus.filter ? ` (filter: "${bandwidthStatus.filter}")` : "";
+    console.log(`\x1b[36m[NETWORK SIMULATION]\x1b[0m Bandwidth simulation: ${bandwidthStatus.kbps} kbps${filterInfo}`);
+  } else {
+    console.log("\x1b[36m[NETWORK SIMULATION]\x1b[0m Bandwidth simulation: disabled");
+  }
+
+  if (latencyStatus.enabled) {
+    const filterInfo = latencyStatus.filter ? ` (filter: "${latencyStatus.filter}")` : "";
+    console.log(`\x1b[36m[NETWORK SIMULATION]\x1b[0m Latency simulation: ${latencyStatus.ms}ms ping${filterInfo}`);
+  } else {
+    console.log("\x1b[36m[NETWORK SIMULATION]\x1b[0m Latency simulation: disabled");
+  }
+}

package/src/node/index.ts

@@ -0,0 +1,22 @@
+export { PartyConnection, logNetworkSimulationStatus } from "./connection";
+export {
+  createMapUpdateHeaders,
+  isMapUpdateAuthorized,
+  MAP_UPDATE_TOKEN_ENV,
+  MAP_UPDATE_TOKEN_HEADER,
+  readMapUpdateToken,
+  resolveMapUpdateToken,
+} from "./map";
+export { PartyRoom } from "./room";
+export { createRpgServerTransport, RpgServerTransport } from "./transport";
+export type {
+  CreateRpgServerTransportOptions,
+  HandleNodeRequestOptions,
+  RpgTransportRequestLike,
+  RpgTransportServer,
+  RpgTransportServerConstructor,
+  RpgWebSocketConnection,
+  RpgWebSocketRequestLike,
+  RpgWebSocketServer,
+  SendMapUpdateOptions,
+} from "./types";