@directivegames/genesys.js 3.1.24 → 3.1.25

package/games/examples/vehicle/base-vehicle.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 import { VehicleGamePlayer } from './player.js';

package/games/examples/vehicle/game.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 import { MeshVehicle } from './mesh-vehicle.js';

package/games/examples/vehicle/mesh-vehicle.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 import { BaseVehicle } from './base-vehicle.js';

package/games/examples/vehicle/player.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 import { BaseVehicle } from './base-vehicle.js';

package/games/examples/vehicle/primitive-vehicle.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 import { BaseVehicle } from './base-vehicle.js';

package/games/examples/vr-game/VRAttachableCube.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 /**

package/games/examples/vr-game/VRInteractableCylinder.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 /**

package/games/examples/vr-game/VRPressableButton.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 export interface VRPressableButtonOptions {

package/games/examples/vr-game/VRProjectileActor.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 /**

package/games/examples/vr-game/VRRifleActor.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 import { VRProjectileActor } from './VRProjectileActor.js';

package/games/examples/vr-game/game.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 import { createVRScene } from './scene.js';

package/games/examples/vr-game/scene.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 import { VRAttachableCube } from './VRAttachableCube.js';

package/games/instanced-mesh-demo.ts

@@ -4,7 +4,7 @@
  * A comparison test between regular mesh components and instanced mesh components
  * with a toggle button to switch between them
  */
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 const MIN_SCALE = 0.03;

package/games/manifold-demo.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 export class ManifoldDemo extends ENGINE.BaseGameLoop {

package/games/navigation-demo.ts

@@ -1,5 +1,5 @@
+import * as ENGINE from '@directivegames/genesys.js';
 import * as dat from 'dat.gui';
-import * as ENGINE from 'genesys.js';
 import * as THREE from 'three';
 
 

package/games/navmesh-primitives-demo.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
 import * as SkeletonUtils from 'three/examples/jsm/utils/SkeletonUtils.js';

package/games/postprocess-demo.ts

@@ -1,6 +1,6 @@
+import * as ENGINE from '@directivegames/genesys.js';
+import { ObjectOutlineEffect } from '@directivegames/genesys.js';
 import * as dat from 'dat.gui';
-import * as ENGINE from 'genesys.js';
-import { ObjectOutlineEffect } from 'genesys.js';
 import * as THREE from 'three';
 
 /**

package/games/ragdoll-demo-simple.ts

@@ -14,7 +14,7 @@
  * - F: Apply random force to character (when ragdoll is active)
  */
 
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 

package/games/ragdoll-demo.ts

@@ -15,7 +15,7 @@
  * - F: Apply random force to character (when ragdoll is active)
  */
 
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 

package/games/swipe-tap-demo.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 /**

package/games/tween-demo.ts

@@ -1,5 +1,5 @@
+import * as ENGINE from '@directivegames/genesys.js';
 import * as TWEEN from '@tweenjs/tween.js';
-import * as ENGINE from 'genesys.js';
 import * as THREE from 'three';
 
 /**

package/games/ui-demo.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 

package/games/vfx-demo.ts

@@ -1,5 +1,5 @@
+import * as ENGINE from '@directivegames/genesys.js';
 import * as dat from 'dat.gui';
-import * as ENGINE from 'genesys.js';
 import * as THREE from 'three';
 
 

package/games/vfx-wawa-demo.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 /**

package/games/vr-ui-demo-minimal.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 /**

package/games/vr-ui-demo.ts

@@ -1,4 +1,4 @@
-import * as ENGINE from 'genesys.js';
+import * as ENGINE from '@directivegames/genesys.js';
 import * as THREE from 'three';
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directivegames/genesys.js",
-  "version": "3.1.24",
+  "version": "3.1.25",
   "description": "Mini game engine built on top of three.js",
   "license": "UNLICENSED",
   "main": "./dist/src/index.js",

package/scripts/dump-templates.ts

@@ -6,7 +6,7 @@ import { generateClassTemplate } from '../src/world-commands/generate-code.js';
 
 function fixUpTemplate(template: string): string {
   return template
-    .replace('genesys.js', '../index.js')  // fix import path
+    .replace('@directivegames/genesys.js', '../index.js')  // fix import path
     .replace('@ENGINE.GameClass()', '// @ENGINE.GameClass()');  // skip registering as that's not really needed
 }
 

package/src/global.d.ts

@@ -1,11 +1,11 @@
-// src/env.d.ts
-
-/// <reference types="vite/client" />
-
-interface ImportMetaEnv {
-  readonly [key: string]: any;
-}
-
-interface ImportMeta {
-  readonly env: ImportMetaEnv;
-}
+// src/env.d.ts
+
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly [key: string]: any;
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}

package/src/multiplayer/MovementPrediction.ts

@@ -1,202 +1,202 @@
-import type * as THREE from 'three';
-
-type NetTransform = {
-  position: THREE.Vector3;
-  rotation: THREE.Quaternion;
-  scale: THREE.Vector3;
-};
-
-type TimedTransform = NetTransform & {
-  timestamp: number;
-};
-
-export class NetMovementPredictor {
-  public static PredictionEnabled: boolean = true;
-  public static LerpAlpha: number = 0.1;
-  private remoteBuffer: TimedTransform[] = [];
-  private localBuffer: TimedTransform[] = [];
-  constructor(private maxCachedFrames: number = 100) {}
-
-  public static currentTime(): number {
-    return Date.now();
-  }
-
-  /*
-  * Returns current * (1 - alpha) + desired * alpha
-  */
-  public static lerpTransform(current: NetTransform, desired: NetTransform, alpha: number = NetMovementPredictor.LerpAlpha): NetTransform {
-    return {
-      position: current.position.clone().lerp(desired.position, alpha),
-      rotation: current.rotation.clone().slerp(desired.rotation, alpha),
-      scale: current.scale.clone().lerp(desired.scale, alpha),
-    };
-  }
-
-  public addRemoteTransform(transform: TimedTransform): void {
-    this.remoteBuffer.push(transform);
-    if (this.remoteBuffer.length > this.maxCachedFrames) {
-      this.remoteBuffer.shift();
-    }
-  }
-
-  public addLocalTransform(transform: TimedTransform): void {
-    this.localBuffer.push(transform);
-    if (this.localBuffer.length > this.maxCachedFrames) {
-      this.localBuffer.shift();
-    }
-  }
-
-  // Interpolates/extrapolates the local buffer to find the transform at a given timestamp
-  private getLocalAtTimestamp(targetTimestamp: number): TimedTransform | null {
-    const buf = this.localBuffer;
-    if (buf.length === 0) return null;
-    if (targetTimestamp <= buf[0].timestamp) return buf[0];
-    if (targetTimestamp >= buf[buf.length - 1].timestamp) return buf[buf.length - 1];
-    for (let i = 0; i < buf.length - 1; ++i) {
-      const a = buf[i], b = buf[i + 1];
-      if (targetTimestamp >= a.timestamp && targetTimestamp <= b.timestamp) {
-        const t = (targetTimestamp - a.timestamp) / (b.timestamp - a.timestamp);
-        return {
-          timestamp: targetTimestamp,
-          position: a.position.clone().lerp(b.position, t),
-          rotation: a.rotation.clone().slerp(b.rotation, t),
-          scale: a.scale.clone().lerp(b.scale, t),
-        };
-      }
-    }
-    return buf[buf.length - 1];
-  }
-
-  public predictCurrentTransform(): {
-    position: THREE.Vector3,
-    rotation: THREE.Quaternion,
-    scale: THREE.Vector3
-  } | null {
-    if (this.remoteBuffer.length === 0 || this.localBuffer.length === 0) {
-      return null;
-    }
-
-    if (!NetMovementPredictor.PredictionEnabled) {
-      return this.remoteBuffer[this.remoteBuffer.length - 1];
-    }
-
-    const latestRemote = this.remoteBuffer[this.remoteBuffer.length - 1];
-    const latestLocal = this.localBuffer[this.localBuffer.length - 1];
-    const clockDiff = latestLocal.timestamp - latestRemote.timestamp;
-
-    // 1. Target local timestamp that matches latest remote, shifted by clock diff
-    const localAnchorTime = latestRemote.timestamp + clockDiff;
-
-    // 2. Interpolate/extrapolate local buffer to get transform at that anchor time
-    const localAtAnchor = this.getLocalAtTimestamp(localAnchorTime);
-    if (!localAtAnchor) {
-      // Should not happen, fallback to latest local
-      return {
-        position: latestLocal.position.clone(),
-        rotation: latestLocal.rotation.clone(),
-        scale: latestLocal.scale.clone(),
-      };
-    }
-
-    // 3. Calculate local movement since anchor
-    const deltaPos = latestLocal.position.clone().sub(localAtAnchor.position);
-    const deltaRot = latestLocal.rotation.clone().multiply(localAtAnchor.rotation.clone().invert());
-    const deltaScale = latestLocal.scale.clone().divide(localAtAnchor.scale);
-
-    // 4. Apply delta to latest remote
-    return {
-      position: latestRemote.position.clone().add(deltaPos),
-      rotation: latestRemote.rotation.clone().multiply(deltaRot),
-      scale: latestRemote.scale.clone().multiply(deltaScale),
-    };
-  }
-}
-
-/*
-export class NetMovementPredictor {
-  private remoteBuffer: TimedTransform[] = [];
-  private localBuffer: TimedTransform[] = [];
-  constructor(private maxCachedFrames: number = 100) {}
-
-  public static currentTime(): number {
-    return Date.now();
-  }
-
-  public addRemoteTransform(transform: TimedTransform): void {
-    this.remoteBuffer.push(transform);
-    if (this.remoteBuffer.length > this.maxCachedFrames) {
-      this.remoteBuffer.shift();
-    }
-  }
-
-  public addLocalTransform(transform: TimedTransform): void {
-    this.localBuffer.push(transform);
-    if (this.localBuffer.length > this.maxCachedFrames) {
-      this.localBuffer.shift();
-    }
-  }
-
-  public predictCurrentTransform(): {
-    position: THREE.Vector3,
-    rotation: THREE.Quaternion,
-    scale: THREE.Vector3
-    } | null {
-    if (this.remoteBuffer.length === 0 || this.localBuffer.length === 0) {
-      return null;
-    }
-
-    const latestRemote = this.remoteBuffer[this.remoteBuffer.length - 1];
-    const latestLocal  = this.localBuffer[this.localBuffer.length - 1];
-    const clockDiff = latestLocal.timestamp - latestRemote.timestamp;
-
-    // Walk both buffers, find best pair with (local.timestamp - remote.timestamp) closest to clockDiff
-    let localIdx = 0;
-    let bestPair: { remote: TimedTransform; local: TimedTransform } | null = null;
-    let minAbsDiff = Number.POSITIVE_INFINITY;
-
-    for (let remoteIdx = 0; remoteIdx < this.remoteBuffer.length; remoteIdx++) {
-      const remote = this.remoteBuffer[remoteIdx];
-      const idealLocalTimestamp = remote.timestamp + clockDiff;
-
-      // Advance localIdx until local.timestamp >= remote.timestamp + clockDiff, or end of buffer
-      while (
-        localIdx + 1 < this.localBuffer.length &&
-        this.localBuffer[localIdx + 1].timestamp <= idealLocalTimestamp
-      ) {
-        localIdx++;
-      }
-
-      // Check current local
-      const local = this.localBuffer[localIdx];
-      const absDiff = Math.abs(local.timestamp - idealLocalTimestamp);
-      if (absDiff < minAbsDiff) {
-        minAbsDiff = absDiff;
-        bestPair = { remote, local };
-      }
-
-      if (localIdx + 1 < this.localBuffer.length) {
-        const nextLocal = this.localBuffer[localIdx + 1];
-        const nextAbsDiff = Math.abs(nextLocal.timestamp - idealLocalTimestamp);
-        if (nextAbsDiff < minAbsDiff) {
-          minAbsDiff = nextAbsDiff;
-          bestPair = { remote, local: nextLocal };
-        }
-      }
-    }
-
-    if (!bestPair) {
-      return null;
-    }
-
-    const deltaPos = bestPair.local.position.clone().sub(bestPair.remote.position);
-    const deltaRot = bestPair.local.rotation.clone().multiply(bestPair.remote.rotation.clone().invert());
-    const deltaScale = bestPair.local.scale.clone().divide(bestPair.remote.scale);
-
-    return {
-      position: latestRemote.position.clone().add(deltaPos),
-      rotation: latestRemote.rotation.clone().multiply(deltaRot),
-      scale: latestRemote.scale.clone().multiply(deltaScale),
-    };
-  }
-}
-*/
+import type * as THREE from 'three';
+
+type NetTransform = {
+  position: THREE.Vector3;
+  rotation: THREE.Quaternion;
+  scale: THREE.Vector3;
+};
+
+type TimedTransform = NetTransform & {
+  timestamp: number;
+};
+
+export class NetMovementPredictor {
+  public static PredictionEnabled: boolean = true;
+  public static LerpAlpha: number = 0.1;
+  private remoteBuffer: TimedTransform[] = [];
+  private localBuffer: TimedTransform[] = [];
+  constructor(private maxCachedFrames: number = 100) {}
+
+  public static currentTime(): number {
+    return Date.now();
+  }
+
+  /*
+  * Returns current * (1 - alpha) + desired * alpha
+  */
+  public static lerpTransform(current: NetTransform, desired: NetTransform, alpha: number = NetMovementPredictor.LerpAlpha): NetTransform {
+    return {
+      position: current.position.clone().lerp(desired.position, alpha),
+      rotation: current.rotation.clone().slerp(desired.rotation, alpha),
+      scale: current.scale.clone().lerp(desired.scale, alpha),
+    };
+  }
+
+  public addRemoteTransform(transform: TimedTransform): void {
+    this.remoteBuffer.push(transform);
+    if (this.remoteBuffer.length > this.maxCachedFrames) {
+      this.remoteBuffer.shift();
+    }
+  }
+
+  public addLocalTransform(transform: TimedTransform): void {
+    this.localBuffer.push(transform);
+    if (this.localBuffer.length > this.maxCachedFrames) {
+      this.localBuffer.shift();
+    }
+  }
+
+  // Interpolates/extrapolates the local buffer to find the transform at a given timestamp
+  private getLocalAtTimestamp(targetTimestamp: number): TimedTransform | null {
+    const buf = this.localBuffer;
+    if (buf.length === 0) return null;
+    if (targetTimestamp <= buf[0].timestamp) return buf[0];
+    if (targetTimestamp >= buf[buf.length - 1].timestamp) return buf[buf.length - 1];
+    for (let i = 0; i < buf.length - 1; ++i) {
+      const a = buf[i], b = buf[i + 1];
+      if (targetTimestamp >= a.timestamp && targetTimestamp <= b.timestamp) {
+        const t = (targetTimestamp - a.timestamp) / (b.timestamp - a.timestamp);
+        return {
+          timestamp: targetTimestamp,
+          position: a.position.clone().lerp(b.position, t),
+          rotation: a.rotation.clone().slerp(b.rotation, t),
+          scale: a.scale.clone().lerp(b.scale, t),
+        };
+      }
+    }
+    return buf[buf.length - 1];
+  }
+
+  public predictCurrentTransform(): {
+    position: THREE.Vector3,
+    rotation: THREE.Quaternion,
+    scale: THREE.Vector3
+  } | null {
+    if (this.remoteBuffer.length === 0 || this.localBuffer.length === 0) {
+      return null;
+    }
+
+    if (!NetMovementPredictor.PredictionEnabled) {
+      return this.remoteBuffer[this.remoteBuffer.length - 1];
+    }
+
+    const latestRemote = this.remoteBuffer[this.remoteBuffer.length - 1];
+    const latestLocal = this.localBuffer[this.localBuffer.length - 1];
+    const clockDiff = latestLocal.timestamp - latestRemote.timestamp;
+
+    // 1. Target local timestamp that matches latest remote, shifted by clock diff
+    const localAnchorTime = latestRemote.timestamp + clockDiff;
+
+    // 2. Interpolate/extrapolate local buffer to get transform at that anchor time
+    const localAtAnchor = this.getLocalAtTimestamp(localAnchorTime);
+    if (!localAtAnchor) {
+      // Should not happen, fallback to latest local
+      return {
+        position: latestLocal.position.clone(),
+        rotation: latestLocal.rotation.clone(),
+        scale: latestLocal.scale.clone(),
+      };
+    }
+
+    // 3. Calculate local movement since anchor
+    const deltaPos = latestLocal.position.clone().sub(localAtAnchor.position);
+    const deltaRot = latestLocal.rotation.clone().multiply(localAtAnchor.rotation.clone().invert());
+    const deltaScale = latestLocal.scale.clone().divide(localAtAnchor.scale);
+
+    // 4. Apply delta to latest remote
+    return {
+      position: latestRemote.position.clone().add(deltaPos),
+      rotation: latestRemote.rotation.clone().multiply(deltaRot),
+      scale: latestRemote.scale.clone().multiply(deltaScale),
+    };
+  }
+}
+
+/*
+export class NetMovementPredictor {
+  private remoteBuffer: TimedTransform[] = [];
+  private localBuffer: TimedTransform[] = [];
+  constructor(private maxCachedFrames: number = 100) {}
+
+  public static currentTime(): number {
+    return Date.now();
+  }
+
+  public addRemoteTransform(transform: TimedTransform): void {
+    this.remoteBuffer.push(transform);
+    if (this.remoteBuffer.length > this.maxCachedFrames) {
+      this.remoteBuffer.shift();
+    }
+  }
+
+  public addLocalTransform(transform: TimedTransform): void {
+    this.localBuffer.push(transform);
+    if (this.localBuffer.length > this.maxCachedFrames) {
+      this.localBuffer.shift();
+    }
+  }
+
+  public predictCurrentTransform(): {
+    position: THREE.Vector3,
+    rotation: THREE.Quaternion,
+    scale: THREE.Vector3
+    } | null {
+    if (this.remoteBuffer.length === 0 || this.localBuffer.length === 0) {
+      return null;
+    }
+
+    const latestRemote = this.remoteBuffer[this.remoteBuffer.length - 1];
+    const latestLocal  = this.localBuffer[this.localBuffer.length - 1];
+    const clockDiff = latestLocal.timestamp - latestRemote.timestamp;
+
+    // Walk both buffers, find best pair with (local.timestamp - remote.timestamp) closest to clockDiff
+    let localIdx = 0;
+    let bestPair: { remote: TimedTransform; local: TimedTransform } | null = null;
+    let minAbsDiff = Number.POSITIVE_INFINITY;
+
+    for (let remoteIdx = 0; remoteIdx < this.remoteBuffer.length; remoteIdx++) {
+      const remote = this.remoteBuffer[remoteIdx];
+      const idealLocalTimestamp = remote.timestamp + clockDiff;
+
+      // Advance localIdx until local.timestamp >= remote.timestamp + clockDiff, or end of buffer
+      while (
+        localIdx + 1 < this.localBuffer.length &&
+        this.localBuffer[localIdx + 1].timestamp <= idealLocalTimestamp
+      ) {
+        localIdx++;
+      }
+
+      // Check current local
+      const local = this.localBuffer[localIdx];
+      const absDiff = Math.abs(local.timestamp - idealLocalTimestamp);
+      if (absDiff < minAbsDiff) {
+        minAbsDiff = absDiff;
+        bestPair = { remote, local };
+      }
+
+      if (localIdx + 1 < this.localBuffer.length) {
+        const nextLocal = this.localBuffer[localIdx + 1];
+        const nextAbsDiff = Math.abs(nextLocal.timestamp - idealLocalTimestamp);
+        if (nextAbsDiff < minAbsDiff) {
+          minAbsDiff = nextAbsDiff;
+          bestPair = { remote, local: nextLocal };
+        }
+      }
+    }
+
+    if (!bestPair) {
+      return null;
+    }
+
+    const deltaPos = bestPair.local.position.clone().sub(bestPair.remote.position);
+    const deltaRot = bestPair.local.rotation.clone().multiply(bestPair.remote.rotation.clone().invert());
+    const deltaScale = bestPair.local.scale.clone().divide(bestPair.remote.scale);
+
+    return {
+      position: latestRemote.position.clone().add(deltaPos),
+      rotation: latestRemote.rotation.clone().multiply(deltaRot),
+      scale: latestRemote.scale.clone().multiply(deltaScale),
+    };
+  }
+}
+*/