@aethervtt/shard-physics 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick Dias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @aethervtt/shard-physics
+
+Part of [Shard](https://github.com/aethervtt/shard), a WebGPU-first 2D/3D game engine in TypeScript. See the repository for documentation.

package/dist/character.d.ts

@@ -0,0 +1,62 @@
+import { type PhysicsWorld } from './world.js';
+type Vec = {
+    x: number;
+    y: number;
+    z: number;
+};
+type Rot = {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+};
+/** Columns of one table, looked up once per table. */
+interface Columns {
+    radius: Float32Array;
+    up: Uint8Array;
+    fixedUp: Float32Array;
+    gravity: Float32Array;
+    jumpSpeed: Float32Array;
+    airControl: Float32Array;
+    pushForce: Float32Array;
+    layers: Uint16Array;
+    mask: Uint16Array;
+    align: Uint8Array;
+    move: Float32Array;
+    jump: Uint8Array;
+    grounded: Uint8Array;
+    groundNormal: Float32Array;
+    groundEntity: Float64Array;
+    velocity: Float32Array;
+    stateUp: Float32Array;
+    airTime: Float32Array;
+    translation: Float32Array;
+    rotation: Float32Array;
+}
+/**
+ * Moves every character by its intent (spec 0029): up from gravity, velocity from intent, gravity,
+ * and jumps, Rapier's controller for the move, then state, ground events, pushes, and platforms.
+ */
+export declare const characterSystem: import("@aethervtt/shard-core").SystemDef<{
+    controllers: import("@aethervtt/shard-core").Query;
+    query: import("@aethervtt/shard-core").Query;
+    sources: import("@aethervtt/shard-core").Query;
+    gravity: import("./gravity.js").GravitySources;
+    cols: Columns;
+    pose: import("./pose.js").Pose;
+    g: Float64Array<ArrayBuffer>;
+    tmp: Float64Array<ArrayBuffer>;
+    q: Float64Array<ArrayBuffer>;
+    arc: Float64Array<ArrayBuffer>;
+    pos: Float64Array<ArrayBuffer>;
+    carry: Float64Array<ArrayBuffer>;
+    ray: InstanceType<PhysicsWorld['R']['Ray']> | undefined;
+    hit: InstanceType<PhysicsWorld['R']['CharacterCollision']> | undefined;
+    t1: Vec;
+    t2: Vec;
+    r1: Rot;
+    r2: Rot;
+    moved: Vec;
+    rootIdentity: boolean;
+}>;
+export {};

package/dist/character.js

@@ -0,0 +1,509 @@
+import { defineSystem } from "@aethervtt/shard-core";
+import { FixedTime } from "@aethervtt/shard-runtime";
+import { GlobalTransform, GridFramesResource, Transform } from "@aethervtt/shard-transform";
+import {
+  CharacterController,
+  CharacterGroundEvent,
+  CharacterIntent,
+  CharacterState,
+  GravitySource
+} from "./components.js";
+import { createGravitySources, gatherGravitySources, sampleGravity } from "./gravity.js";
+import { createPose, parentOf, poseOf, rotate, worldToLocal } from "./pose.js";
+import { CHARACTER_OFFSET, Physics } from "./world.js";
+const KIND_KINEMATIC_POSITION = 2;
+const KIND_KINEMATIC_VELOCITY = 3;
+function columns(table, out) {
+  out.radius = table.column(CharacterController, "radius");
+  out.up = table.column(CharacterController, "up");
+  out.fixedUp = table.column(CharacterController, "fixedUp");
+  out.gravity = table.column(CharacterController, "gravity");
+  out.jumpSpeed = table.column(CharacterController, "jumpSpeed");
+  out.airControl = table.column(CharacterController, "airControl");
+  out.pushForce = table.column(CharacterController, "pushForce");
+  out.layers = table.column(CharacterController, "layers");
+  out.mask = table.column(CharacterController, "mask");
+  out.align = table.column(CharacterController, "alignRotation");
+  out.move = table.column(CharacterIntent, "move");
+  out.jump = table.column(CharacterIntent, "jump");
+  out.grounded = table.column(CharacterState, "grounded");
+  out.groundNormal = table.column(CharacterState, "groundNormal");
+  out.groundEntity = table.column(CharacterState, "groundEntity");
+  out.velocity = table.column(CharacterState, "velocity");
+  out.stateUp = table.column(CharacterState, "up");
+  out.airTime = table.column(CharacterState, "airTime");
+  out.translation = table.column(Transform, "translation");
+  out.rotation = table.column(Transform, "rotation");
+}
+const vec = () => ({ x: 0, y: 0, z: 0 });
+const rot = () => ({ x: 0, y: 0, z: 0, w: 1 });
+const characterSystem = defineSystem({
+  name: "physics/character",
+  description: "Moves CharacterController entities by their CharacterIntent: up and rotation from gravity, walking, jumping, stepping, sliding, pushing bodies, riding platforms. Writes CharacterState.",
+  setup: (world) => ({
+    controllers: world.query({ with: [CharacterController] }),
+    query: world.query({ with: [CharacterController, CharacterIntent, CharacterState, Transform] }),
+    sources: world.query({ with: [GravitySource, GlobalTransform] }),
+    gravity: createGravitySources(),
+    cols: {},
+    pose: createPose(),
+    g: new Float64Array(4),
+    tmp: new Float64Array(3),
+    q: new Float64Array(4),
+    arc: new Float64Array(4),
+    pos: new Float64Array(3),
+    carry: new Float64Array(3),
+    ray: void 0,
+    hit: void 0,
+    t1: vec(),
+    t2: vec(),
+    r1: rot(),
+    r2: rot(),
+    moved: vec(),
+    rootIdentity: true
+  }),
+  run: (s, world, ctx) => {
+    const p = world.tryResource(Physics);
+    if (!p) return;
+    const since = ctx.lastRunTick;
+    for (let t = 0; t < s.controllers.tables.length; t++) {
+      const table = s.controllers.tables[t];
+      if (table.lastChanged(CharacterController) <= since) continue;
+      const ticks = table.changedTicks(CharacterController);
+      for (let row = 0; row < table.count; row++) {
+        if (ticks[row] > since) p.createCharacter(world, table.entities[row]);
+      }
+    }
+    if (p.characters.size === 0 || p.config.paused) return;
+    const dt = world.resource(FixedTime).step;
+    p.raw.timestep = dt;
+    gatherGravitySources(s.sources, s.gravity);
+    s.hit ??= new p.R.CharacterCollision();
+    s.rootIdentity = world.tryResource(GridFramesResource)?.rootIdentity !== false;
+    for (let t = 0; t < s.query.tables.length; t++) {
+      const table = s.query.tables[t];
+      columns(table, s.cols);
+      for (let row = 0; row < table.count; row++) {
+        const record = p.characters.get(table.entities[row]);
+        if (record && !record.body.parked) stepCharacter(s, world, p, table, row, record, dt);
+      }
+      table.markChanged(CharacterState);
+      table.markChanged(Transform);
+    }
+  }
+});
+function stepCharacter(s, world, p, table, row, record, dt) {
+  const c = s.cols;
+  const dim = p.dim;
+  const entity = record.entity;
+  const body = record.body.body;
+  const o3 = row * 3;
+  const pose = poseOf(world, entity, s.pose);
+  const bt = body.translation(s.t1);
+  const ex = bt.x - pose[0];
+  const ey = bt.y - pose[1];
+  const ez = dim === 3 ? bt.z - pose[2] : 0;
+  const tol = 1e-4 + 1e-6 * (Math.abs(pose[0]) + Math.abs(pose[1]) + Math.abs(pose[2]));
+  if (ex * ex + ey * ey + ez * ez > tol * tol) {
+    body.setTranslation(p.vec(pose[0], pose[1], pose[2]), true);
+    body.setRotation(p.rotation(pose, 3), true);
+    p.raw.propagateModifiedBodyPositionsToColliders();
+  }
+  const px = pose[0];
+  const py = pose[1];
+  const pz = pose[2];
+  let ux;
+  let uy;
+  let uz;
+  let ax = 0;
+  let ay = 0;
+  let az = 0;
+  if (c.up[row] === 0) {
+    ux = c.fixedUp[o3];
+    uy = c.fixedUp[o3 + 1];
+    uz = dim === 3 ? c.fixedUp[o3 + 2] : 0;
+    const len = Math.sqrt(ux * ux + uy * uy + uz * uz);
+    if (len < 1e-9) {
+      ux = 0;
+      uy = 1;
+      uz = 0;
+    } else {
+      ux /= len;
+      uy /= len;
+      uz /= len;
+    }
+    const g = c.gravity[row];
+    ax = -ux * g;
+    ay = -uy * g;
+    az = -uz * g;
+  } else {
+    const g = s.g;
+    sampleGravity(s.gravity, dim, px, py, pz, true, g);
+    if (g[3] < 1e-9) {
+      const cg = p.config.gravity;
+      g[0] = cg[0];
+      g[1] = cg[1];
+      g[2] = dim === 3 ? cg[2] : 0;
+      g[3] = Math.sqrt(g[0] * g[0] + g[1] * g[1] + g[2] * g[2]);
+    }
+    if (g[3] > 1e-9) {
+      ax = g[0];
+      ay = g[1];
+      az = g[2];
+      ux = -ax / g[3];
+      uy = -ay / g[3];
+      uz = -az / g[3];
+    } else {
+      ux = c.stateUp[o3];
+      uy = c.stateUp[o3 + 1];
+      uz = dim === 3 ? c.stateUp[o3 + 2] : 0;
+      const len = Math.sqrt(ux * ux + uy * uy + uz * uz) || 1;
+      ux /= len;
+      uy /= len;
+      uz /= len;
+    }
+  }
+  const q = s.q;
+  q[0] = pose[3];
+  q[1] = pose[4];
+  q[2] = pose[5];
+  q[3] = pose[6];
+  if (c.align[row] === 1) alignUp(q, ux, uy, uz, s.arc, s.tmp);
+  const mx = c.move[o3];
+  const mz = dim === 3 ? c.move[o3 + 2] : 0;
+  rotate(s.tmp, 0, q, 0, mx, 0, mz);
+  let hx = s.tmp[0];
+  let hy = s.tmp[1];
+  let hz = dim === 3 ? s.tmp[2] : 0;
+  const hu = hx * ux + hy * uy + hz * uz;
+  hx -= ux * hu;
+  hy -= uy * hu;
+  hz -= uz * hu;
+  const speed = Math.sqrt(mx * mx + mz * mz);
+  const hl = Math.sqrt(hx * hx + hy * hy + hz * hz);
+  if (hl > 1e-9) {
+    hx *= speed / hl;
+    hy *= speed / hl;
+    hz *= speed / hl;
+  } else {
+    hx = hy = hz = 0;
+  }
+  const wasGrounded = c.grounded[row] === 1;
+  let vx;
+  let vy;
+  let vz;
+  let jumped = false;
+  if (wasGrounded) {
+    const nx = c.groundNormal[o3];
+    const ny = c.groundNormal[o3 + 1];
+    const nz = c.groundNormal[o3 + 2];
+    const nu = nx * ux + ny * uy + nz * uz;
+    const k = nu > 1e-3 ? Math.max(0, hx * nx + hy * ny + hz * nz) / nu : 0;
+    vx = hx - ux * k;
+    vy = hy - uy * k;
+    vz = hz - uz * k;
+    if (c.jump[row] === 1) {
+      const j = c.jumpSpeed[row];
+      vx += ux * j;
+      vy += uy * j;
+      vz += uz * j;
+      jumped = true;
+      c.jump[row] = 0;
+      table.markChanged(CharacterIntent, row);
+    }
+  } else {
+    vx = c.velocity[o3];
+    vy = c.velocity[o3 + 1];
+    vz = dim === 3 ? c.velocity[o3 + 2] : 0;
+    const vu = vx * ux + vy * uy + vz * uz;
+    let wx = vx - ux * vu;
+    let wy = vy - uy * vu;
+    let wz = vz - uz * vu;
+    const air = c.airControl[row];
+    const blend = air >= 1 ? 1 : 1 - (1 - air) ** (dt * 60);
+    wx += (hx - wx) * blend;
+    wy += (hy - wy) * blend;
+    wz += (hz - wz) * blend;
+    vx = wx + ux * vu;
+    vy = wy + uy * vu;
+    vz = wz + uz * vu;
+  }
+  const carry = s.carry;
+  carry[0] = carry[1] = carry[2] = 0;
+  if (wasGrounded) platformCarry(s, p, c.groundEntity[row], px, py, pz, dt, carry);
+  const half = wasGrounded && !jumped ? 0 : 0.5 * dt * dt;
+  const dx = vx * dt + ax * half + carry[0];
+  const dy = vy * dt + ay * half + carry[1];
+  const dz = vz * dt + az * half + carry[2];
+  const rising = jumped || !wasGrounded && vx * ux + vy * uy + vz * uz > 0;
+  if (record.snapDistance > 0 && record.snapping === rising) {
+    record.snapping = !rising;
+    if (rising) record.kcc.disableSnapToGround();
+    else record.kcc.enableSnapToGround(record.snapDistance);
+  }
+  const kcc = record.kcc;
+  const rv = p.rawVec;
+  rv.x = ux;
+  rv.y = uy;
+  if (dim === 3) rv.z = uz;
+  kcc.raw.setUp(rv);
+  rv.x = dx;
+  rv.y = dy;
+  if (dim === 3) rv.z = dz;
+  const raw = p.raw;
+  kcc.raw.computeColliderMovement(
+    dt,
+    raw.broadPhase.raw,
+    raw.narrowPhase.raw,
+    raw.bodies.raw,
+    raw.colliders.raw,
+    record.collider.handle,
+    rv,
+    false,
+    void 0,
+    p.R.QueryFilterFlags.EXCLUDE_SENSORS,
+    (c.layers[row] & 65535) << 16 | c.mask[row] & 65535,
+    void 0
+  );
+  const mv = record.kcc.computedMovement(s.moved);
+  const mvx = mv.x;
+  const mvy = mv.y;
+  const mvz = dim === 3 ? mv.z : 0;
+  const grounded = record.kcc.computedGrounded();
+  const pos = s.pos;
+  pos[0] = Math.fround(px + mvx);
+  pos[1] = Math.fround(py + mvy);
+  pos[2] = Math.fround(pz + mvz);
+  const groups = (c.layers[row] & 65535) << 16 | c.mask[row] & 65535;
+  let groundDot = -2;
+  let gnx = ux;
+  let gny = uy;
+  let gnz = uz;
+  let groundEntity = -1;
+  const hit = s.hit;
+  const push = c.pushForce[row] * dt;
+  const n = record.kcc.numComputedCollisions();
+  for (let i = 0; i < n; i++) {
+    if (!record.kcc.computedCollision(i, hit)) continue;
+    const normal = hit.normal1;
+    const nx = normal.x;
+    const ny = normal.y;
+    const nz = dim === 3 ? normal.z : 0;
+    const nd = nx * ux + ny * uy + nz * uz;
+    const collider = hit.collider;
+    if (nd >= record.cosMaxSlope - 1e-3) {
+      if (nd > groundDot && collider) {
+        groundDot = nd;
+        gnx = nx;
+        gny = ny;
+        gnz = nz;
+        const e = p.colliderEntity.get(collider.handle);
+        groundEntity = e === void 0 ? -1 : p.colliderOwner.get(e) ?? e;
+      }
+    } else if (collider && push > 0 && speed > 1e-6) {
+      pushBody(s, p, collider, hx / speed, hy / speed, hz / speed, speed, push);
+    }
+    if (!grounded) {
+      const d = vx * nx + vy * ny + vz * nz;
+      if (d < 0) {
+        vx -= nx * d;
+        vy -= ny * d;
+        vz -= nz * d;
+      }
+    }
+  }
+  if (grounded && groundEntity === -1) {
+    const g = s.g;
+    if (probeGround(s, p, record, pos, ux, uy, uz, groups, g)) {
+      gnx = g[0];
+      gny = g[1];
+      gnz = g[2];
+      groundEntity = g[3];
+    } else if (wasGrounded) {
+      gnx = c.groundNormal[o3];
+      gny = c.groundNormal[o3 + 1];
+      gnz = c.groundNormal[o3 + 2];
+      groundEntity = c.groundEntity[row];
+    }
+  }
+  if (grounded) {
+    const d = vx * gnx + vy * gny + vz * gnz;
+    vx -= gnx * d;
+    vy -= gny * d;
+    vz -= gnz * d;
+  } else {
+    vx += ax * dt;
+    vy += ay * dt;
+    vz += az * dt;
+  }
+  body.setNextKinematicTranslation(p.vec(pos[0], pos[1], pos[2]));
+  body.setNextKinematicRotation(p.rotation(q, 0));
+  const parent = parentOf(world, entity);
+  if (parent === void 0 && s.rootIdentity) {
+    c.translation[o3] = pos[0];
+    c.translation[o3 + 1] = pos[1];
+    c.translation[o3 + 2] = pos[2];
+    c.rotation[row * 4] = q[0];
+    c.rotation[row * 4 + 1] = q[1];
+    c.rotation[row * 4 + 2] = q[2];
+    c.rotation[row * 4 + 3] = q[3];
+  } else {
+    worldToLocal(world, parent, entity, pos, q, c.translation, o3, c.rotation, row * 4);
+  }
+  c.grounded[row] = grounded ? 1 : 0;
+  c.groundNormal[o3] = gnx;
+  c.groundNormal[o3 + 1] = gny;
+  c.groundNormal[o3 + 2] = gnz;
+  c.groundEntity[row] = grounded ? groundEntity : -1;
+  c.velocity[o3] = vx;
+  c.velocity[o3 + 1] = vy;
+  c.velocity[o3 + 2] = vz;
+  c.stateUp[o3] = ux;
+  c.stateUp[o3 + 1] = uy;
+  c.stateUp[o3 + 2] = uz;
+  c.airTime[row] = grounded ? 0 : c.airTime[row] + dt;
+  if (grounded !== wasGrounded) world.send(CharacterGroundEvent, { entity, grounded });
+}
+function alignUp(q, ux, uy, uz, arc, tmp) {
+  rotate(tmp, 0, q, 0, 0, 1, 0);
+  const yx = tmp[0];
+  const yy = tmp[1];
+  const yz = tmp[2];
+  const d = yx * ux + yy * uy + yz * uz;
+  if (d > 1 - 1e-12) return;
+  if (d < -1 + 1e-9) {
+    rotate(tmp, 0, q, 0, 1, 0, 0);
+    arc[0] = tmp[0];
+    arc[1] = tmp[1];
+    arc[2] = tmp[2];
+    arc[3] = 0;
+  } else {
+    arc[0] = yy * uz - yz * uy;
+    arc[1] = yz * ux - yx * uz;
+    arc[2] = yx * uy - yy * ux;
+    arc[3] = 1 + d;
+    const len2 = Math.sqrt(arc[0] ** 2 + arc[1] ** 2 + arc[2] ** 2 + arc[3] ** 2);
+    arc[0] /= len2;
+    arc[1] /= len2;
+    arc[2] /= len2;
+    arc[3] /= len2;
+  }
+  const bx = q[0];
+  const by = q[1];
+  const bz = q[2];
+  const bw = q[3];
+  const ax = arc[0];
+  const ay = arc[1];
+  const az = arc[2];
+  const aw = arc[3];
+  let x = aw * bx + ax * bw + ay * bz - az * by;
+  let y = aw * by - ax * bz + ay * bw + az * bx;
+  let z = aw * bz + ax * by - ay * bx + az * bw;
+  let w = aw * bw - ax * bx - ay * by - az * bz;
+  const len = Math.sqrt(x * x + y * y + z * z + w * w) || 1;
+  x /= len;
+  y /= len;
+  z /= len;
+  w /= len;
+  q[0] = x;
+  q[1] = y;
+  q[2] = z;
+  q[3] = w;
+}
+function probeGround(s, p, record, pos, ux, uy, uz, groups, out) {
+  s.ray ??= new p.R.Ray({ x: 0, y: 0, z: 0 }, { x: 0, y: -1, z: 0 });
+  const ray = s.ray;
+  const o = ray.origin;
+  const d = ray.dir;
+  o.x = pos[0];
+  o.y = pos[1];
+  d.x = -ux;
+  d.y = -uy;
+  if (p.dim === 3) {
+    o.z = pos[2];
+    d.z = -uz;
+  }
+  const reach = record.bottom + CHARACTER_OFFSET + record.snapDistance + 0.05;
+  const hit = p.raw.castRayAndGetNormal(
+    ray,
+    reach,
+    true,
+    p.R.QueryFilterFlags.EXCLUDE_SENSORS,
+    groups,
+    void 0,
+    record.body.body
+  );
+  if (!hit) return false;
+  const n = hit.normal;
+  const nz = p.dim === 3 ? n.z : 0;
+  if (n.x * ux + n.y * uy + nz * uz < record.cosMaxSlope - 1e-3) return false;
+  out[0] = n.x;
+  out[1] = n.y;
+  out[2] = nz;
+  const e = p.colliderEntity.get(hit.collider.handle);
+  out[3] = e === void 0 ? -1 : p.colliderOwner.get(e) ?? e;
+  return true;
+}
+function platformCarry(s, p, ground, px, py, pz, dt, out) {
+  if (ground < 0) return;
+  const record = p.bodies.get(ground);
+  if (!record || p.characters.has(record.entity)) return;
+  const body = record.body;
+  const t = body.translation(s.t1);
+  const rx = px - t.x;
+  const ry = py - t.y;
+  const rz = p.dim === 3 ? pz - t.z : 0;
+  if (record.kind === KIND_KINEMATIC_POSITION) {
+    const nt = body.nextTranslation(s.t2);
+    if (p.dim === 3) {
+      const r = body.rotation(s.r1);
+      const nr = body.nextRotation(s.r2);
+      const tmp = s.tmp;
+      const q = s.arc;
+      q[0] = -r.x;
+      q[1] = -r.y;
+      q[2] = -r.z;
+      q[3] = r.w;
+      rotate(tmp, 0, q, 0, rx, ry, rz);
+      q[0] = nr.x;
+      q[1] = nr.y;
+      q[2] = nr.z;
+      q[3] = nr.w;
+      rotate(tmp, 0, q, 0, tmp[0], tmp[1], tmp[2]);
+      out[0] = nt.x + tmp[0] - px;
+      out[1] = nt.y + tmp[1] - py;
+      out[2] = nt.z + tmp[2] - pz;
+    } else {
+      const a = body.nextRotation() - body.rotation();
+      const cos = Math.cos(a);
+      const sin = Math.sin(a);
+      out[0] = nt.x + rx * cos - ry * sin - px;
+      out[1] = nt.y + rx * sin + ry * cos - py;
+    }
+  } else if (record.kind === KIND_KINEMATIC_VELOCITY) {
+    const lv = body.linvel(s.t2);
+    if (p.dim === 3) {
+      const av = body.angvel(s.r1);
+      out[0] = (lv.x + av.y * rz - av.z * ry) * dt;
+      out[1] = (lv.y + av.z * rx - av.x * rz) * dt;
+      out[2] = (lv.z + av.x * ry - av.y * rx) * dt;
+    } else {
+      const w = body.angvel();
+      out[0] = (lv.x - w * ry) * dt;
+      out[1] = (lv.y + w * rx) * dt;
+    }
+  }
+}
+function pushBody(s, p, collider, dx, dy, dz, speed, impulse) {
+  const body = collider.parent();
+  if (!body?.isDynamic()) return;
+  const v = body.linvel(s.t2);
+  const along = v.x * dx + v.y * dy + (p.dim === 3 ? v.z * dz : 0);
+  const dv = speed - along;
+  if (dv <= 0) return;
+  const j = Math.min(impulse, body.mass() * dv);
+  body.applyImpulse(p.vec(dx * j, dy * j, dz * j), true);
+}
+export {
+  characterSystem
+};