@irtio/client 0.6.0 → 0.8.0

package/dist/physics-rapier2d-TBOAJMVM.js

@@ -0,0 +1,186 @@
+import {
+  Predictor
+} from "./chunk-XFD6WYQW.js";
+import "./chunk-5Z4DHUA3.js";
+
+// src/physics-rapier2d.ts
+import {
+  angleFrom2d,
+  applyChannel2d,
+  channelOf2d
+} from "@irtio/schema";
+var engine;
+var loading;
+async function loadEngine() {
+  if (engine) return engine;
+  loading ??= (async () => {
+    const mod = await import("@dimforge/rapier2d-compat");
+    const ns = mod.default ?? mod;
+    await ns.init();
+    engine = ns;
+    return ns;
+  })();
+  return loading;
+}
+var Rapier2dAdapter = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  engineName = "@dimforge/rapier2d-compat";
+  optionName = "physics2d";
+  rapier;
+  world;
+  timestepSeconds = 1 / 30;
+  /** Reused by `readPose`, which runs per body per step and must not allocate. */
+  state = {
+    x: 0,
+    y: 0,
+    angle: 0,
+    vx: 0,
+    vy: 0,
+    angularVelocity: 0
+  };
+  /** `applyChannel2d`'s target shape, likewise reused. */
+  channels = { x: 0, y: 0, qz: 0, qw: 1, vx: 0, vy: 0, wz: 0 };
+  /** `moveKinematic`'s translation argument, reused: it runs per proxy per step (D71). */
+  moveTarget = { x: 0, y: 0 };
+  get timestep() {
+    return this.options.timestep;
+  }
+  async start(timestepSeconds) {
+    const rapier = await loadEngine();
+    this.rapier = rapier;
+    this.timestepSeconds = timestepSeconds;
+    const world = new rapier.World({ x: this.options.gravity.x, y: this.options.gravity.y });
+    world.timestep = timestepSeconds;
+    if (this.options.setup) this.options.setup(world, rapier);
+    this.world = world;
+  }
+  free() {
+    this.world?.free();
+    this.world = void 0;
+  }
+  hasFactory(collection) {
+    return this.options.bodies?.[collection] !== void 0;
+  }
+  createBody(desc, id, record, _warn) {
+    const world = this.world;
+    const rapier = this.rapier;
+    const factory = this.options.bodies?.[desc.name];
+    if (!world || !rapier || !factory) return void 0;
+    const spec = factory(rapier, record, id);
+    if (!spec || !spec.body) return void 0;
+    const body = world.createRigidBody(spec.body);
+    for (const collider of spec.colliders ?? []) world.createCollider(collider, body);
+    return body;
+  }
+  removeBody(body) {
+    this.world?.removeRigidBody(body);
+  }
+  /**
+   * D71: a proxy is a `KinematicPositionBased` body, exactly as in 3D — driven by the position it
+   * is told to be at next, never by a force, an impulse or a contact, with Rapier deriving the
+   * velocity its contacts see from the move itself. The body is *switched* rather than built
+   * kinematic, so its collider and mass properties are the ones the shared factory produced.
+   */
+  makeKinematic(handle) {
+    const rapier = this.rapier;
+    if (!rapier) return;
+    handle.setBodyType(rapier.RigidBodyType.KinematicPositionBased, true);
+  }
+  moveKinematic(handle, pose) {
+    const body = handle;
+    const to = this.moveTarget;
+    to.x = pose.t.x;
+    to.y = pose.t.y;
+    body.setNextKinematicTranslation(to);
+    body.setNextKinematicRotation(angleFrom2d(pose.r.z, pose.r.w));
+  }
+  step() {
+    this.world?.step();
+  }
+  /**
+   * Server record → body state, through `applyChannel2d` so the plane-to-channel mapping stays
+   * written once, and in `Rapier2dRuntime.applyRecordToBody`'s order — translation, rotation,
+   * linear velocity, spin — so the two sides write the same body the same way. Every setter takes
+   * `wakeUp = true`: a rebase writes state a sleeping body would otherwise ignore.
+   */
+  applyRecord(handle, channels, record) {
+    const body = handle;
+    const t = this.channels;
+    const pos = body.translation();
+    const vel = body.linvel();
+    const angle = body.rotation();
+    t.x = pos.x;
+    t.y = pos.y;
+    t.qz = Math.sin(angle / 2);
+    t.qw = Math.cos(angle / 2);
+    t.vx = vel.x;
+    t.vy = vel.y;
+    t.wz = body.angvel();
+    for (const [channel, field] of channels) {
+      const raw = record[field];
+      if (typeof raw !== "number") continue;
+      applyChannel2d(channel, raw, t);
+    }
+    body.setTranslation({ x: t.x, y: t.y }, true);
+    body.setRotation(angleFrom2d(t.qz, t.qw), true);
+    body.setLinvel({ x: t.vx, y: t.vy }, true);
+    body.setAngvel(t.wz, true);
+  }
+  /**
+   * Body state → a 3D pose, through `channelOf2d`: `t = (x, y, 0)`, `r` a quaternion about Z,
+   * `v = (vx, vy, 0)`, `w = (0, 0, spin)`.
+   */
+  readPose(handle, into) {
+    const body = handle;
+    const s = this.state;
+    const pos = body.translation();
+    const vel = body.linvel();
+    s.x = pos.x;
+    s.y = pos.y;
+    s.angle = body.rotation();
+    s.vx = vel.x;
+    s.vy = vel.y;
+    s.angularVelocity = body.angvel();
+    const b = s;
+    into.t.x = channelOf2d("x", b);
+    into.t.y = channelOf2d("y", b);
+    into.t.z = channelOf2d("z", b);
+    into.r.x = channelOf2d("qx", b);
+    into.r.y = channelOf2d("qy", b);
+    into.r.z = channelOf2d("qz", b);
+    into.r.w = channelOf2d("qw", b);
+    into.v.x = channelOf2d("vx", b);
+    into.v.y = channelOf2d("vy", b);
+    into.v.z = channelOf2d("vz", b);
+    into.w.x = channelOf2d("wx", b);
+    into.w.y = channelOf2d("wy", b);
+    into.w.z = channelOf2d("wz", b);
+  }
+  applyIntent(collection, body, instance) {
+    const hook = this.options.intents?.[collection];
+    const world = this.world;
+    const rapier = this.rapier;
+    if (!hook || !world || !rapier) return;
+    hook(body, instance, rapier, world, this.timestepSeconds);
+  }
+  // No `settle`. The world applies gravity; see the module docblock.
+  /** Rapier velocities are per second, so one tick of error is `epsilon` when `dv = eps / dt`. */
+  velocityTolerance(epsilon, timestepSeconds) {
+    return epsilon / timestepSeconds;
+  }
+};
+var Rapier2dPredictor = class extends Predictor {
+  constructor(ext, store, options, meOf, rttOf, tickIntervalOf, log = (m) => console.warn(m)) {
+    super(ext, store, new Rapier2dAdapter(options), options, meOf, rttOf, tickIntervalOf, log);
+  }
+};
+function createRapier2dAdapter(options) {
+  return new Rapier2dAdapter(options);
+}
+export {
+  Rapier2dPredictor,
+  createRapier2dAdapter
+};

package/dist/{physics2d-ZV2IRRRZ.js → physics2d-CNSEWKP4.js}

@@ -1,7 +1,7 @@
 import {
   Predictor
-} from "./chunk-TE66EDBB.js";
-import "./chunk-6J6PKFUS.js";
+} from "./chunk-XFD6WYQW.js";
+import "./chunk-5Z4DHUA3.js";
 
 // src/physics2d.ts
 import {
@@ -47,6 +47,8 @@ var MatterAdapter = class {
   };
   /** `applyChannel2d`'s target shape, likewise reused. */
   channels = { x: 0, y: 0, qz: 0, qw: 1, vx: 0, vy: 0, wz: 0 };
+  /** `moveKinematic`'s position argument, reused: it runs per proxy per step (D71). */
+  moveTarget = { x: 0, y: 0 };
   get timestep() {
     return this.options.timestep;
   }
@@ -95,6 +97,53 @@ var MatterAdapter = class {
     matter.Composite.remove(engine2.world, pinned ? [body, ...pinned] : [body]);
     this.constraints.delete(body);
   }
+  /**
+   * D71: matter.js has no kinematic body type. Static is the only kind it never integrates and
+   * never moves from an impulse, so that is what a proxy is.
+   *
+   * `Body.setStatic` also overwrites the surface properties the factory set — `friction` to 1 and
+   * `restitution` to 0, on every part, and on a body that was *already* static it does that without
+   * even stashing the old values in `_original`. A proxy has to be the server's body rather than a
+   * stickier copy of it (matter pairs friction as the minimum of the two, so a proxy at friction 1
+   * is only invisible while the other body is the grippier one), so the factory's values are
+   * snapshotted here and put back. Mass and inertia keep the infinities that make it immovable.
+   */
+  makeKinematic(handle) {
+    const matter = this.matter;
+    if (!matter) return;
+    const body = handle;
+    const parts = body.parts;
+    const surfaces = parts.map((p) => ({ friction: p.friction, restitution: p.restitution }));
+    matter.Body.setStatic(body, true);
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      const surface = surfaces[i];
+      part.friction = surface.friction;
+      part.restitution = surface.restitution;
+    }
+  }
+  /**
+   * `updateVelocity: true` is the whole mechanism. It leaves `positionPrev` exactly one move behind
+   * the new position, and matter's resolver reads a body's velocity as precisely that difference
+   * (`Resolver.solveVelocity`: `position - positionPrev`), so a predicted body resting on the proxy
+   * is carried by friction the way it is on the server. Given the same pose twice the difference is
+   * zero and the proxy is at rest, which is what holds it still through a rebase's re-steps.
+   *
+   * The third parameter is real in matter-js 0.20 (`src/body/Body.js`) and missing from
+   * `@types/matter-js@0.20.2` on both setters, which is what the two casts are for.
+   */
+  moveKinematic(handle, pose) {
+    const matter = this.matter;
+    if (!matter) return;
+    const body = handle;
+    const setPosition = matter.Body.setPosition;
+    const setAngle = matter.Body.setAngle;
+    const to = this.moveTarget;
+    to.x = pose.t.x;
+    to.y = pose.t.y;
+    setPosition(body, to, true);
+    setAngle(body, angleFrom2d(pose.r.z, pose.r.w), true);
+  }
   step() {
     if (!this.matter || !this.engine) return;
     this.matter.Engine.update(this.engine, this.stepMs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@irtio/client",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "irtio client SDK: joinRoom, owned-write batching, corrections, typed RPCs, presence, reconnection",
   "license": "MIT",
   "publishConfig": {
@@ -20,14 +20,18 @@
   ],
   "dependencies": {
     "mediasoup-client": "^3.23.1",
-    "@irtio/protocol": "0.6.0",
-    "@irtio/schema": "0.6.0"
+    "@irtio/protocol": "0.8.0",
+    "@irtio/schema": "0.8.0"
   },
   "peerDependencies": {
+    "@dimforge/rapier2d-compat": ">=0.20.0",
     "@dimforge/rapier3d-compat": ">=0.20.0",
     "matter-js": ">=0.20.0"
   },
   "peerDependenciesMeta": {
+    "@dimforge/rapier2d-compat": {
+      "optional": true
+    },
     "@dimforge/rapier3d-compat": {
       "optional": true
     },
@@ -39,6 +43,7 @@
     "@dimforge/rapier3d-compat": "0.20.0",
     "@types/matter-js": "0.20.2",
     "matter-js": "0.20.0",
+    "@dimforge/rapier2d-compat": "0.20.0",
     "@irtio/sfu": "0.0.0"
   },
   "scripts": {