castle-web-cli 0.4.129 → 0.4.131

package/kits/physics-3d/systems/physics3d.js

@@ -0,0 +1,356 @@
+// The 3d physics system: one rapier world per scene runtime, registered as a
+// runtime system (auto-discovered from `systems/*.js` by the imported engine's
+// systemRegistry). Every actor with a Transform gets a rapier body -- fixed by
+// default, dynamic or kinematic via a `Body` behavior. Colliders come from the
+// actor's `Shape` and are sensors unless the actor is solid (a `Solid`
+// behavior, or `Shape.solid`), so pickups and trigger zones still get overlap
+// events. Behaviors get `onCollisionEnter` / `onCollisionExit` callbacks and
+// drive motion through `scene.physics3d`.
+//
+// rapier's wasm loads async; the system installs immediately and starts
+// simulating on the first frame after init resolves.
+import * as THREE from 'three';
+import * as RAPIER from '@dimforge/rapier3d-compat';
+
+const FIXED_STEP = 1 / 60;
+const MAX_STEPS_PER_FRAME = 4;
+const DEG = Math.PI / 180;
+
+let rapierReady = false;
+let rapierInitPromise = null;
+
+function ensureRapierInit() {
+  if (!rapierInitPromise) {
+    rapierInitPromise = RAPIER.init().then(() => {
+      rapierReady = true;
+    });
+  }
+  return rapierInitPromise;
+}
+
+export function installSystem(runtime) {
+  const system = new Physics3DSystem();
+  runtime.registerSystem(system);
+  system.attach(runtime);
+  return system;
+}
+
+export class Physics3DSystem {
+  constructor() {
+    this.world = null;
+    this.eventQueue = null;
+    this.bodies = new Map(); // actorId -> { body, collider, sig, pushedKey }
+    this.byCollider = new Map(); // collider handle -> actorId
+    this.acc = 0;
+    this.touching = new Set(); // "aId|bId" sorted pair keys
+    this.enter = [];
+    this.exit = [];
+  }
+
+  attach(runtime) {
+    runtime.physics3d = makeApi(this);
+    void ensureRapierInit();
+  }
+
+  reset() {
+    // Rapier objects live in wasm -- dropping the JS reference leaks them, so
+    // both the world and its event queue are freed explicitly. Runs on every
+    // scene load (the runtime resets registered systems) and on dispose.
+    if (this.world) this.world.free();
+    if (this.eventQueue) this.eventQueue.free();
+    this.world = null;
+    this.eventQueue = null;
+    this.bodies.clear();
+    this.byCollider.clear();
+    this.touching.clear();
+    this.enter.length = 0;
+    this.exit.length = 0;
+    this.acc = 0;
+  }
+
+  dispose() {
+    this.reset();
+  }
+
+  afterBehaviors(scene, dt) {
+    if (!rapierReady) return;
+    this.ensureWorld();
+    this.reconcileBodies(scene);
+    this.pushTransforms(scene);
+    this.step(dt);
+    this.writeBack(scene);
+    this.dispatchCallbacks(scene);
+  }
+
+  ensureWorld() {
+    if (this.world) return;
+    this.world = new RAPIER.World({ x: 0, y: -9.81, z: 0 });
+    this.eventQueue = new RAPIER.EventQueue(true);
+    // The ground everything stands on, matching the visual ground plane.
+    const groundBody = this.world.createRigidBody(
+      RAPIER.RigidBodyDesc.fixed().setTranslation(0, -0.5, 0)
+    );
+    this.world.createCollider(RAPIER.ColliderDesc.cuboid(100, 0.5, 100), groundBody);
+  }
+
+  reconcileBodies(scene) {
+    const seen = new Set();
+    for (const actor of scene.getActors()) {
+      if (!actor.components.Transform) continue;
+      seen.add(actor.id);
+      const sig = bodySignature(actor);
+      const existing = this.bodies.get(actor.id);
+      if (existing && existing.sig === sig) continue;
+      if (existing) this.removeBody(actor.id);
+      this.createBody(actor, sig);
+    }
+    for (const id of [...this.bodies.keys()]) {
+      if (!seen.has(id)) this.removeBody(id);
+    }
+  }
+
+  createBody(actor, sig) {
+    const t = actor.components.Transform;
+    const body = this.world.createRigidBody(bodyDescFor(actor, t));
+    body.userData = actor.id;
+    let collider = null;
+    const shape = actor.components.Shape;
+    if (shape) {
+      collider = this.world.createCollider(colliderDescFor(actor, shape), body);
+      this.byCollider.set(collider.handle, actor.id);
+    }
+    this.bodies.set(actor.id, { body, collider, sig, pushedKey: transformKey(t) });
+  }
+
+  removeBody(actorId) {
+    const entry = this.bodies.get(actorId);
+    if (!entry) return;
+    if (entry.collider) this.byCollider.delete(entry.collider.handle);
+    this.world.removeRigidBody(entry.body);
+    this.bodies.delete(actorId);
+    for (const key of [...this.touching]) {
+      if (key.startsWith(`${actorId}|`) || key.endsWith(`|${actorId}`)) this.touching.delete(key);
+    }
+  }
+
+  // Fixed bodies follow Transform edits (teleport); kinematic bodies follow
+  // with contact resolution. Dynamic bodies are the sim's to move.
+  pushTransforms(scene) {
+    for (const actor of scene.getActors()) {
+      const entry = this.bodies.get(actor.id);
+      const t = actor.components.Transform;
+      if (!entry || !t) continue;
+      const type = entry.body.bodyType();
+      if (type === RAPIER.RigidBodyType.KinematicPositionBased) {
+        entry.body.setNextKinematicTranslation({ x: t.x, y: t.y, z: t.z });
+        entry.body.setNextKinematicRotation(quatFromEuler(t));
+      } else if (type === RAPIER.RigidBodyType.Fixed) {
+        const key = transformKey(t);
+        if (key !== entry.pushedKey) {
+          entry.body.setTranslation({ x: t.x, y: t.y, z: t.z }, false);
+          entry.body.setRotation(quatFromEuler(t), false);
+          entry.pushedKey = key;
+        }
+      }
+    }
+  }
+
+  step(dt) {
+    this.enter.length = 0;
+    this.exit.length = 0;
+    this.acc += dt;
+    let steps = 0;
+    while (this.acc >= FIXED_STEP && steps < MAX_STEPS_PER_FRAME) {
+      // Snapshot dynamic bodies before each step so rendering can interpolate
+      // between the last two physics states -- without this, bodies advance
+      // only on step frames and stutter on displays faster than 60Hz.
+      for (const entry of this.bodies.values()) {
+        if (entry.body.bodyType() !== RAPIER.RigidBodyType.Dynamic) continue;
+        const p = entry.body.translation();
+        const q = entry.body.rotation();
+        entry.prev = { x: p.x, y: p.y, z: p.z, qx: q.x, qy: q.y, qz: q.z, qw: q.w };
+      }
+      this.world.timestep = FIXED_STEP;
+      this.world.step(this.eventQueue);
+      this.eventQueue.drainCollisionEvents((h1, h2, started) => this.recordPair(h1, h2, started));
+      this.acc -= FIXED_STEP;
+      steps += 1;
+    }
+    if (steps === MAX_STEPS_PER_FRAME) this.acc = 0;
+  }
+
+  recordPair(handle1, handle2, started) {
+    const a = this.byCollider.get(handle1);
+    const b = this.byCollider.get(handle2);
+    if (!a || !b) return; // the ground, or an already-removed collider
+    const key = a < b ? `${a}|${b}` : `${b}|${a}`;
+    if (started && !this.touching.has(key)) {
+      this.touching.add(key);
+      this.enter.push([a, b]);
+    } else if (!started && this.touching.has(key)) {
+      this.touching.delete(key);
+      this.exit.push([a, b]);
+    }
+  }
+
+  writeBack(scene) {
+    // Blend factor between the last two physics states: how far into the next
+    // fixed step this render frame sits.
+    const alpha = Math.max(0, Math.min(1, this.acc / FIXED_STEP));
+    for (const actor of scene.getActors()) {
+      const entry = this.bodies.get(actor.id);
+      if (!entry || entry.body.bodyType() !== RAPIER.RigidBodyType.Dynamic) continue;
+      const t = actor.components.Transform;
+      const p = entry.body.translation();
+      const prev = entry.prev;
+      if (prev) {
+        t.x = prev.x + (p.x - prev.x) * alpha;
+        t.y = prev.y + (p.y - prev.y) * alpha;
+        t.z = prev.z + (p.z - prev.z) * alpha;
+      } else {
+        t.x = p.x;
+        t.y = p.y;
+        t.z = p.z;
+      }
+      // Locked-rotation bodies (characters) keep Transform rotation under
+      // behavior control so they can face where they're going.
+      if (!actor.components.Body?.lockRotations) {
+        const q = entry.body.rotation();
+        if (prev) {
+          tmpQuat.set(prev.qx, prev.qy, prev.qz, prev.qw);
+          tmpQuat2.set(q.x, q.y, q.z, q.w);
+          tmpQuat.slerp(tmpQuat2, alpha);
+          actor.runtime.quat = { x: tmpQuat.x, y: tmpQuat.y, z: tmpQuat.z, w: tmpQuat.w };
+          setEulerFromQuat(t, actor.runtime.quat);
+        } else {
+          actor.runtime.quat = { x: q.x, y: q.y, z: q.z, w: q.w };
+          setEulerFromQuat(t, q);
+        }
+      }
+    }
+  }
+
+  dispatchCallbacks(scene) {
+    for (const [a, b] of this.enter) emitPair(scene, a, b, 'onCollisionEnter');
+    for (const [a, b] of this.exit) emitPair(scene, a, b, 'onCollisionExit');
+  }
+}
+
+function emitPair(scene, aId, bId, method) {
+  const a = scene.getActor(aId);
+  const b = scene.getActor(bId);
+  if (!a || !b) return;
+  scene.forEachBehavior(a, (instance) => instance[method]?.(a, scene, b));
+  scene.forEachBehavior(b, (instance) => instance[method]?.(b, scene, a));
+}
+
+function isSolid(actor) {
+  return Boolean(actor.components.Solid) || Boolean(actor.components.Shape?.solid);
+}
+
+function bodySignature(actor) {
+  return JSON.stringify([
+    actor.components.Body ?? null,
+    actor.components.Shape ?? null,
+    isSolid(actor),
+  ]);
+}
+
+function transformKey(t) {
+  return `${t.x},${t.y},${t.z},${t.rotationX},${t.rotationY},${t.rotationZ}`;
+}
+
+function bodyDescFor(actor, t) {
+  const opts = actor.components.Body;
+  let desc;
+  if (opts?.type === 'dynamic') desc = RAPIER.RigidBodyDesc.dynamic();
+  else if (opts?.type === 'kinematic') desc = RAPIER.RigidBodyDesc.kinematicPositionBased();
+  else desc = RAPIER.RigidBodyDesc.fixed();
+  desc.setTranslation(t.x, t.y, t.z);
+  desc.setRotation(quatFromEuler(t));
+  if (opts) {
+    desc.setGravityScale(opts.gravityScale);
+    if (opts.lockRotations) desc.lockRotations();
+  }
+  return desc;
+}
+
+function colliderDescFor(actor, shape) {
+  let desc;
+  if (shape.kind === 'sphere') desc = RAPIER.ColliderDesc.ball(shape.radius);
+  else if (shape.kind === 'capsule') {
+    desc = RAPIER.ColliderDesc.capsule(
+      Math.max(0.01, shape.height / 2 - shape.radius),
+      shape.radius
+    );
+  } else if (shape.kind === 'cylinder') {
+    desc = RAPIER.ColliderDesc.cylinder(shape.height / 2, shape.radius);
+  } else {
+    desc = RAPIER.ColliderDesc.cuboid(shape.width / 2, shape.height / 2, shape.depth / 2);
+  }
+  const opts = actor.components.Body;
+  desc.setFriction(opts?.friction ?? 0.6);
+  desc.setRestitution(opts?.restitution ?? 0);
+  if (!isSolid(actor)) desc.setSensor(true);
+  desc.setActiveEvents(RAPIER.ActiveEvents.COLLISION_EVENTS);
+  return desc;
+}
+
+const tmpEuler = new THREE.Euler();
+const tmpQuat = new THREE.Quaternion();
+const tmpQuat2 = new THREE.Quaternion();
+
+function quatFromEuler(t) {
+  tmpEuler.set(t.rotationX * DEG, t.rotationY * DEG, t.rotationZ * DEG);
+  tmpQuat.setFromEuler(tmpEuler);
+  return { x: tmpQuat.x, y: tmpQuat.y, z: tmpQuat.z, w: tmpQuat.w };
+}
+
+function setEulerFromQuat(t, q) {
+  tmpQuat.set(q.x, q.y, q.z, q.w);
+  tmpEuler.setFromQuaternion(tmpQuat);
+  t.rotationX = tmpEuler.x / DEG;
+  t.rotationY = tmpEuler.y / DEG;
+  t.rotationZ = tmpEuler.z / DEG;
+}
+
+// The author-facing API behaviors reach through `scene.physics3d`. Motion goes
+// through the body (never by writing a dynamic actor's Transform); rays
+// exclude sensors so ground checks don't land on pickups.
+function makeApi(system) {
+  const bodyOf = (actorOrId) => {
+    const id = typeof actorOrId === 'string' ? actorOrId : actorOrId?.id;
+    return system.bodies.get(id)?.body ?? null;
+  };
+  return {
+    ready: () => rapierReady && Boolean(system.world),
+    debugRender: () => (system.world ? system.world.debugRender() : null),
+    bodyOf,
+    mass: (actor) => bodyOf(actor)?.mass() ?? 0,
+    getVelocity: (actor) => {
+      const v = bodyOf(actor)?.linvel();
+      return v ? { x: v.x, y: v.y, z: v.z } : { x: 0, y: 0, z: 0 };
+    },
+    setVelocity: (actor, v) => bodyOf(actor)?.setLinvel(v, true),
+    applyImpulse: (actor, v) => bodyOf(actor)?.applyImpulse(v, true),
+    castRay: (origin, dir, maxToi, excludeActor) => {
+      if (!system.world) return null;
+      const ray = new RAPIER.Ray(origin, dir);
+      const exclude = excludeActor ? bodyOf(excludeActor) : undefined;
+      const hit = system.world.castRay(
+        ray,
+        maxToi,
+        true,
+        RAPIER.QueryFilterFlags.EXCLUDE_SENSORS,
+        undefined,
+        undefined,
+        exclude ?? undefined
+      );
+      if (!hit) return null;
+      return {
+        distance: hit.timeOfImpact,
+        actorId: system.byCollider.get(hit.collider.handle) ?? null,
+      };
+    },
+  };
+}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "castle-web-cli",
-  "version": "0.4.129",
+  "version": "0.4.131",
   "type": "module",
   "bin": {
     "castle-web": "./dist/index.js"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc && chmod +x dist/index.js && vite build && cp -R src/castle-host dist/castle-host && rm -rf kits && cp -R ../kits kits",
+    "build": "rm -rf dist && tsc && chmod +x dist/index.js && vite build && cp -R src/castle-host dist/castle-host && chmod -R u+w kits 2>/dev/null; rm -rf kits && cp -R ../kits kits && chmod -R u+w kits && rm -rf kits/*/imports",
     "dev": "tsc --watch",
     "check": "eslint . && jscpd && tsc --noEmit && tsc --noEmit -p src/shell/tsconfig.json"
   },
@@ -24,7 +24,10 @@
   },
   "dependencies": {
     "@codemirror/commands": "^6.10.4",
+    "@codemirror/lang-css": "^6.3.1",
+    "@codemirror/lang-html": "^6.4.12",
     "@codemirror/lang-javascript": "^6.2.5",
+    "@codemirror/lang-markdown": "^6.5.2",
     "@codemirror/language": "^6.12.3",
     "@codemirror/state": "^6.6.0",
     "@codemirror/view": "^6.41.1",