Move with collision reacts along the contact normal: it travels to the surface, stays flush and slides the rest of the move along it with Coulomb friction (the mean of both colliders, a tile counts as 0.5), a circle now rolls over an edge instead of catching on it, pushed dynamic bodies move off along the normal, Move gains the outputs hit, normal x and normal y, an object without its own collider moves freely, and editor run and play share the same path through Solids; contact point and normal come from our own f64 geometry (contactBetween), because Rapier's castShape lands 3e-6 px inside the wall in f32 (#150)

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/core/graph/NodeContext.ts

@@ -97,6 +97,17 @@ export interface PhysicsControl {
   setGravity(x: number, y: number): void;
 }
 
+/**
+ * What a move with collision met: which of the object's own axes something stood against, whether
+ * it hit anything, and the world normal of the first contact (pointing away from what was hit).
+ */
+export interface MoveOutcome {
+  blockedX: boolean;
+  blockedY: boolean;
+  hit: boolean;
+  normal: { x: number; y: number };
+}
+
 /**
  * Everything the graph does to the world goes through here, so the core stays free of runtime
  * imports. Implemented by the runtime (BehaviorSystem) and by test doubles.
@@ -132,10 +143,10 @@ export interface NodeContext {
   /** A collider entity stands for itself; any other entity for its direct collider children. */
   isTouching(a: EntityHandle, b: EntityHandle): boolean;
   /**
-   * Moves `target` by (dx, dy) in local units, stopping solid colliders at other solid ones axis by
-   * axis (x first, then y) so it slides along walls.
+   * Moves `target` by (dx, dy) in local units; its solid colliders stop flush at other solid ones
+   * and the rest of the move goes on along the surface, less what friction takes.
    */
-  moveAndSlide(target: EntityHandle, dx: number, dy: number): { blockedX: boolean; blockedY: boolean };
+  moveAndSlide(target: EntityHandle, dx: number, dy: number): MoveOutcome;
   /** Absent where nothing is simulated: the editor run, and a test double that does not ask for it. */
   physics?: PhysicsControl;
   log(message: string): void;

src/core/graph/nodes/action/Move.ts

@@ -1,15 +1,30 @@
+import type { MoveOutcome } from '../../NodeContext';
 import type { NodeDef } from '../../NodeRegistry';
 import { asBoolean, asEntity, asNumber } from '../../values';
 import { bool, exec, num, obj, withDefault } from '../shared';
 
+const FREE = { blockedX: false, blockedY: false, hit: false, normalX: 0, normalY: 0 };
+
+function outputsOf(outcome: MoveOutcome) {
+  return {
+    blockedX: outcome.blockedX,
+    blockedY: outcome.blockedY,
+    hit: outcome.hit,
+    normalX: outcome.normal.x,
+    normalY: outcome.normal.y,
+  };
+}
+
 export const Move: NodeDef = {
   type: 'Move',
   label: 'Move',
   category: 'action',
   description:
     "Moves an object by (dx, dy) × scale × dt. Connect dt to an event's dt for per-second movement; " +
-    'leave it at 1 for per-frame. With "Collide with solids" on, the object\'s solid colliders stop at ' +
-    'other solid colliders and slide along them; blocked x/y tell which axes hit.',
+    'leave it at 1 for per-frame. With "Collide with solids" on, the object\'s solid colliders stop ' +
+    'flush at other solid colliders and the rest of the move goes on along the surface, less what the ' +
+    'friction of both colliders takes; blocked x/y tell which axes something stood against, hit whether ' +
+    'anything was met, and normal x/y which way the first surface faces.',
   inputs: [
     exec(),
     obj('object'),
@@ -18,17 +33,25 @@ export const Move: NodeDef = {
     withDefault(num('scale'), 1),
     withDefault(num('dt'), 1),
   ],
-  outputs: [exec(), bool('blockedX', 'blocked x'), bool('blockedY', 'blocked y')],
+  outputs: [
+    exec(),
+    bool('blockedX', 'blocked x'),
+    bool('blockedY', 'blocked y'),
+    bool('hit'),
+    num('normalX', 'normal x'),
+    num('normalY', 'normal y'),
+  ],
   params: [{ key: 'collide', label: 'Collide with solids', kind: 'boolean', default: false }],
   run: (ctx, inputs, params) => {
     const target = asEntity(inputs.object);
-    if (!target) return { next: 'exec', outputs: { blockedX: false, blockedY: false } };
+    if (!target) return { next: 'exec', outputs: FREE };
     const factor = asNumber(inputs.scale) * asNumber(inputs.dt);
     const dx = asNumber(inputs.dx) * factor;
     const dy = asNumber(inputs.dy) * factor;
-    if (asBoolean(params.collide)) return { next: 'exec', outputs: ctx.moveAndSlide(target, dx, dy) };
+    if (asBoolean(params.collide))
+      return { next: 'exec', outputs: outputsOf(ctx.moveAndSlide(target, dx, dy)) };
     target.x += dx;
     target.y += dy;
-    return { next: 'exec', outputs: { blockedX: false, blockedY: false } };
+    return { next: 'exec', outputs: FREE };
   },
 };

src/core/properties/collider.ts

@@ -18,9 +18,6 @@ export type ColliderShape =
 type Box = Extract<ColliderShape, { kind: 'box' }>;
 type Circle = Extract<ColliderShape, { kind: 'circle' }>;
 
-/** A movement axis in the plane (`z` is draw order, not geometry). */
-export type PlaneAxis = 'x' | 'y';
-
 /** The shape as it sits in the world: sized by the transform's scale, a box turned by its angle. */
 export function colliderShape(props: PropertyBag, m: Mat): ColliderShape {
   const scale = scaleOf(m);
@@ -120,6 +117,86 @@ export function shapesOverlap(a: ColliderShape, b: ColliderShape): boolean {
   return distanceToBox(toBoxFrame(box, circle), box.w / 2, box.h / 2) < circle.r - EPSILON;
 }
 
+/**
+ * How two shapes meet: `separation` is the gap between them (negative when they overlap, then its
+ * size is the shortest way out) and `normal` the unit direction from `obstacle` towards `mover` that
+ * gap is measured along – the face that was hit, or the direction from a hit corner. Where the
+ * shapes give no direction (centres on top of each other) it runs against `travel`.
+ */
+export function contactBetween(
+  mover: ColliderShape,
+  obstacle: ColliderShape,
+  travel: Vec2,
+): { separation: number; normal: Vec2 } {
+  const against = (n: Vec2, offset: number): Vec2 => {
+    const sign = offset !== 0 ? Math.sign(offset) : dot(n, travel) > 0 ? -1 : 1;
+    return { x: sign * n.x + 0, y: sign * n.y + 0 };
+  };
+  if (mover.kind === 'box' && obstacle.kind === 'box') {
+    const centres = { x: mover.x - obstacle.x, y: mover.y - obstacle.y };
+    let best = { separation: -Infinity, normal: { x: 0, y: 0 } };
+    for (const n of [...axesOf(mover), ...axesOf(obstacle)]) {
+      const offset = dot(centres, n);
+      const separation = Math.abs(offset) - reach(mover, n) - reach(obstacle, n);
+      const normal = against(n, offset);
+      // On a tie (a corner on a corner) the face the travel runs into more squarely wins.
+      if (
+        separation > best.separation + EPSILON ||
+        (separation > best.separation - EPSILON && dot(normal, travel) < dot(best.normal, travel))
+      )
+        best = { separation: Math.max(separation, best.separation), normal };
+    }
+    return best;
+  }
+  if (mover.kind === 'circle' && obstacle.kind === 'circle') {
+    const d = { x: mover.x - obstacle.x, y: mover.y - obstacle.y };
+    const length = Math.hypot(d.x, d.y);
+    const normal = length > 0 ? { x: d.x / length, y: d.y / length } : against(unit(travel), 0);
+    return { separation: length - mover.r - obstacle.r, normal };
+  }
+  const { box, circle } = boxAndCircle(mover, obstacle);
+  const [ux, uy] = axesOf(box);
+  const p = toBoxFrame(box, circle);
+  const hw = box.w / 2;
+  const hh = box.h / 2;
+  // Local direction from the box towards the circle, and the gap along it.
+  let dir: Vec2;
+  let separation: number;
+  if (Math.abs(p.x) > hw || Math.abs(p.y) > hh) {
+    const d = { x: p.x - clamp(p.x, hw), y: p.y - clamp(p.y, hh) };
+    const length = Math.hypot(d.x, d.y);
+    dir = { x: d.x / length, y: d.y / length };
+    separation = length - circle.r;
+  } else {
+    // The centre is inside: out through the nearer face.
+    const sign = mover.kind === 'circle' ? 1 : -1;
+    const local = { x: sign * dot(travel, ux), y: sign * dot(travel, uy) };
+    const byX = hw - Math.abs(p.x) <= hh - Math.abs(p.y);
+    dir = byX
+      ? { x: p.x !== 0 ? Math.sign(p.x) : -Math.sign(local.x) || 1, y: 0 }
+      : { x: 0, y: p.y !== 0 ? Math.sign(p.y) : -Math.sign(local.y) || 1 };
+    separation = -(byX ? hw - Math.abs(p.x) : hh - Math.abs(p.y)) - circle.r;
+  }
+  const world = { x: dir.x * ux.x + dir.y * uy.x, y: dir.x * ux.y + dir.y * uy.y };
+  // `world` runs from the box to the circle; the normal runs from the obstacle to the mover.
+  const sign = mover.kind === 'circle' ? 1 : -1;
+  return { separation, normal: { x: sign * world.x + 0, y: sign * world.y + 0 } };
+}
+
+/** How deep two shapes overlap by the measure `shapesOverlap` uses: 0 when they only touch. */
+export function overlapDepth(separation: number): number {
+  return separation < -EPSILON ? -separation : 0;
+}
+
+function clamp(v: number, half: number): number {
+  return Math.min(half, Math.max(-half, v));
+}
+
+function unit(v: Vec2): Vec2 {
+  const length = Math.hypot(v.x, v.y);
+  return length > 0 ? { x: v.x / length, y: v.y / length } : { x: 1, y: 0 };
+}
+
 /**
  * How far `mover` has to travel along `direction` until it just clears `obstacle`; 0 when they are
  * apart already. This is what stops a moving object at a wall: it is pushed back against its

src/runtime/physics/PhysicsSystem.ts

@@ -26,6 +26,7 @@ import {
   bodyOf,
   type CollisionPair,
   type CollisionSource,
+  type MoveResult,
   partsOf,
   shapeOf,
   Solids,
@@ -169,12 +170,7 @@ export class PhysicsSystem implements System, CollisionSource {
    * `Move` with "Collide with solids": the object stops at what is in the way and slides along it,
    * as in the editor run, and a dynamic body that stops it gets a push (#147).
    */
-  moveAndSlide(
-    world: World,
-    entity: Entity,
-    dx: number,
-    dy: number,
-  ): { blockedX: boolean; blockedY: boolean } {
+  moveAndSlide(world: World, entity: Entity, dx: number, dy: number): MoveResult {
     return this.solids.moveAndSlide(world, entity, dx, dy, (blocked) => this.push(world, entity, blocked));
   }
 
@@ -253,7 +249,7 @@ export class PhysicsSystem implements System, CollisionSource {
   }
 
   /**
-   * A mover that runs into a dynamic body pushes it along its travel, as one body meeting another
+   * A mover that runs into a dynamic body pushes it into the contact, as one body meeting another
    * without bounce: the wanted speed is the move spread over the frame, and a light mover barely
    * shifts a heavy crate. Both keep moving – the mover as the graph says, the crate as the engine does.
    */

src/runtime/systems/BehaviorSystem.ts

@@ -30,7 +30,7 @@ import type { World } from '../World';
 import type { Rapier } from '../physics/engine';
 import { PhysicsSystem } from '../physics/PhysicsSystem';
 import { CollisionSystem } from './CollisionSystem';
-import { bodyOf, type CollisionPair, type CollisionSource } from './solids';
+import { bodyOf, type CollisionPair, type CollisionSource, NOT_BLOCKED } from './solids';
 import { AnimationSystem } from './AnimationSystem';
 import type { Input } from './Input';
 import type { System } from './System';
@@ -563,11 +563,11 @@ export class BehaviorSystem implements System {
       },
       moveAndSlide: (target, dx, dy) => {
         const found = resolve(target);
-        if (!found) return { blockedX: false, blockedY: false };
+        if (!found) return NOT_BLOCKED;
         if (this.collisions) return this.collisions.moveAndSlide(world, found, dx, dy);
         found.x += dx;
         found.y += dy;
-        return { blockedX: false, blockedY: false };
+        return NOT_BLOCKED;
       },
       physics:
         this.collisions instanceof PhysicsSystem

src/runtime/systems/CollisionSystem.ts

@@ -2,7 +2,15 @@ import { isHandleEnabled } from '../../core/graph';
 import { shapesOverlap } from '../../core/properties/collider';
 import type { Entity } from '../Entity';
 import type { World } from '../World';
-import { bodyOf, type CollisionPair, type CollisionSource, isCollisionBody, partsOf, Solids } from './solids';
+import {
+  bodyOf,
+  type CollisionPair,
+  type CollisionSource,
+  isCollisionBody,
+  type MoveResult,
+  partsOf,
+  Solids,
+} from './solids';
 import type { System } from './System';
 
 /**
@@ -67,12 +75,7 @@ export class CollisionSystem implements System, CollisionSource {
     return false;
   }
 
-  moveAndSlide(
-    world: World,
-    entity: Entity,
-    dx: number,
-    dy: number,
-  ): { blockedX: boolean; blockedY: boolean } {
+  moveAndSlide(world: World, entity: Entity, dx: number, dy: number): MoveResult {
     return this.solids.moveAndSlide(world, entity, dx, dy);
   }
 }

src/runtime/systems/solids.ts

@@ -1,5 +1,5 @@
 import { isHandleEnabled, worldMatrixOf } from '../../core/graph';
-import { applyVector, IDENTITY } from '../../core/model/matrix';
+import { applyVector, determinant, IDENTITY, invert, linearOf, type Mat } from '../../core/model/matrix';
 import type { Vec2 } from '../../core/model/Properties';
 import { findAssetOf } from '../../core/model/Project';
 import { type CellRect, cellRectShape, solidRects } from '../../core/model/tilemapCollision';
@@ -7,18 +7,24 @@ import { parentChain } from '../../core/model/walk';
 import {
   type ColliderShape,
   colliderShape,
+  contactBetween,
   exitDistance,
   isTrigger,
-  type PlaneAxis,
+  overlapDepth,
   shapeExtent,
 } from '../../core/properties/collider';
+import { colliderMaterial } from '../../core/properties/rigidbody';
 import type { Entity } from '../Entity';
 import type { World } from '../World';
 
-/** Overlaps up to this depth (world units) count as contact, not as "already inside". */
-const SKIN = 0.05;
-/** Upper bound for the sub-steps of a single move, so a huge delta cannot stall a frame. */
+/** Upper bound for the sub-steps of a single sweep, so a huge delta cannot stall a frame. */
 const MAX_STEPS = 256;
+/** A move is swept this many times at most: into a contact, along it, into the next one, and on. */
+const MAX_PASSES = 4;
+/** Deepening an overlap by no more than this is rounding, not moving in. */
+const DEEPER = 1e-9;
+/** A normal this close to square with an axis does not stand against a move along it. */
+const SQUARE = 1e-6;
 
 /**
  * Two bodies that overlap (or overlapped) – always the same pair order per key. Either side is a
@@ -34,8 +40,8 @@ export interface CollisionPair {
 }
 
 /**
- * What stopped a move along one axis: the collider or tilemap in the way, the world direction the
- * move was going, and how far it wanted to go there (world units).
+ * What a move ran into: the collider or tilemap in the way, the world direction into it (against
+ * the contact normal), and how far the whole move wanted to go that way (world units).
  */
 export interface Blocked {
   by: Entity;
@@ -43,24 +49,46 @@ export interface Blocked {
   distance: number;
 }
 
+/**
+ * What `Move` with "Collide with solids" reports: which of the object's own axes something stood
+ * against, whether it hit anything, and the normal of the first contact (world, pointing away from
+ * what was hit; zero without a hit).
+ */
+export interface MoveResult {
+  blockedX: boolean;
+  blockedY: boolean;
+  hit: boolean;
+  normal: Vec2;
+}
+
+export const NOT_BLOCKED: MoveResult = Object.freeze({
+  blockedX: false,
+  blockedY: false,
+  hit: false,
+  normal: Object.freeze({ x: 0, y: 0 }),
+});
+
 /** A shape in the mover's way and the collider or tilemap it belongs to. */
 interface Obstacle {
   shape: ColliderShape;
   body: Entity;
 }
 
+/** Where a sweep stopped: what it met, with which own collider, the normal, and the move left over. */
+interface Contact {
+  by: Entity;
+  own: Entity;
+  normal: Vec2;
+  left: Vec2;
+}
+
 /** What the behaviors read of collisions, whichever system works them out. */
 export interface CollisionSource {
   readonly enters: CollisionPair[];
   readonly stays: CollisionPair[];
   readonly exits: CollisionPair[];
   touching(world: World, a: Entity, b: Entity): boolean;
-  moveAndSlide(
-    world: World,
-    entity: Entity,
-    dx: number,
-    dy: number,
-  ): { blockedX: boolean; blockedY: boolean };
+  moveAndSlide(world: World, entity: Entity, dx: number, dy: number): MoveResult;
 }
 
 /**
@@ -101,10 +129,13 @@ export class Solids {
   }
 
   /**
-   * Moves one axis at a time, stopping each at contact so the object slides along walls. An existing
-   * overlap is never resolved (no jolt) but never deepened, so an object can leave a wall but not burrow in.
-   * The axes are the entity's own: under a turned parent, "x" runs wherever that parent points it.
-   * `onBlocked` hears what stopped each axis.
+   * Moves the object towards (dx, dy) and, where a solid is in the way, stops flush at it and goes
+   * on along its surface: what is left of the move loses the part into the surface, and friction
+   * takes off the part along it in proportion (Coulomb) – so a circle rolls off an edge, and a
+   * pressed object slides the less the rougher the pair (#150). An existing overlap is never
+   * resolved (no jolt) but never deepened, so an object can leave a wall but not burrow in.
+   * (dx, dy) are in the entity's own axes: under a turned parent, "x" runs wherever that parent
+   * points it. `onBlocked` hears each solid the move ran into, once.
    */
   moveAndSlide(
     world: World,
@@ -112,117 +143,149 @@ export class Solids {
     dx: number,
     dy: number,
     onBlocked?: (blocked: Blocked) => void,
-  ): { blockedX: boolean; blockedY: boolean } {
+  ): MoveResult {
     const own = blockingCollidersOf(world, entity);
+    const frame = parentFrame(entity);
+    const wanted = applyVector(frame, { x: dx, y: dy });
+    if (own.length === 0) {
+      entity.x += dx;
+      entity.y += dy;
+      return NOT_BLOCKED;
+    }
     // Nothing that blocks moves while this one does, so its shapes are taken once for the whole move.
-    const obstacles =
-      own.length === 0
-        ? []
-        : world.entities
-            .filter((c) => blocksMover(c, entity))
-            .flatMap((body) => this.shapesOf(world, body).map((shape) => ({ shape, body })));
-    const slide = (axis: PlaneAxis, delta: number) => {
-      const blocked = slideAxis(entity, own, obstacles, axis, delta);
-      if (blocked) onBlocked?.(blocked);
-      return blocked !== null;
+    const obstacles = world.entities
+      .filter((c) => blocksMover(c, entity))
+      .flatMap((body) => this.shapesOf(world, body).map((shape) => ({ shape, body })));
+    const contacts: Contact[] = [];
+    let rest = wanted;
+    for (let pass = 0; pass < MAX_PASSES && (rest.x !== 0 || rest.y !== 0); pass++) {
+      const contact = sweep(entity, frame, own, obstacles, rest);
+      if (!contact) break;
+      contacts.push(contact);
+      rest = slideAlong(contact.left, contact.normal, frictionBetween(contact.own, contact.by));
+    }
+    if (contacts.length === 0) return NOT_BLOCKED;
+    const pushed = new Set<Entity>();
+    for (const { by, normal } of contacts) {
+      if (pushed.has(by)) continue;
+      pushed.add(by);
+      const along = { x: -normal.x, y: -normal.y };
+      onBlocked?.({ by, along, distance: Math.max(0, dot(wanted, along)) });
+    }
+    const against = (axis: Vec2, delta: number) =>
+      delta !== 0 && contacts.some(({ normal }) => Math.sign(delta) * dot(normal, unitOf(axis)) < -SQUARE);
+    const first = contacts[0]!.normal;
+    return {
+      blockedX: against({ x: frame.a, y: frame.b }, dx),
+      blockedY: against({ x: frame.c, y: frame.d }, dy),
+      hit: true,
+      normal: { x: first.x || 0, y: first.y || 0 },
     };
-    return { blockedX: slide('x', dx), blockedY: slide('y', dy) };
   }
 }
 
-function slideAxis(
-  entity: Entity,
-  own: Entity[],
-  obstacles: Obstacle[],
-  axis: PlaneAxis,
-  delta: number,
-): Blocked | null {
-  if (delta === 0 || own.length === 0) return null;
-  const travel = axisTravel(entity, axis);
-  const distance = Math.abs(delta) * travel.length;
-  const steps = Math.min(
-    MAX_STEPS,
-    Math.max(1, Math.ceil(distance / stepLimit(own, obstacles, travel.unit))),
-  );
+/**
+ * The linear map from the entity's own axes to the world: its parent's. A parent scaled to nothing
+ * leaves no direction to move in, so there the world's axes stand in.
+ */
+function parentFrame(entity: Entity): Mat {
+  const parent = entity.parent ? linearOf(worldMatrixOf(entity.parent)) : IDENTITY;
+  return Math.abs(determinant(parent)) < 1e-12 ? IDENTITY : parent;
+}
+
+/**
+ * Moves the entity along `move` (world) in steps no solid is thinner than, until a step runs into
+ * one: then it is set back flush against it and the contact is reported with what is left of the move.
+ */
+function sweep(entity: Entity, frame: Mat, own: Entity[], obstacles: Obstacle[], move: Vec2): Contact | null {
+  const distance = Math.hypot(move.x, move.y);
+  const forward = { x: move.x / distance, y: move.y / distance };
+  const steps = Math.min(MAX_STEPS, Math.max(1, Math.ceil(distance / stepLimit(own, obstacles, forward))));
+  const step = distance / steps;
+  const toLocal = invert(frame);
+  const shift = (length: number) => {
+    const local = applyVector(toLocal, { x: forward.x * length, y: forward.y * length });
+    entity.x += local.x;
+    entity.y += local.y;
+  };
   for (let i = 0; i < steps; i++) {
-    const by = stepAxis(entity, own, obstacles, axis, delta / steps, travel);
-    if (by) {
-      const dir = Math.sign(delta);
-      return { by, along: { x: dir * travel.unit.x, y: dir * travel.unit.y }, distance };
+    // How deep each pair already overlaps. A step may never deepen that, but resolving it is not
+    // our job (no jolt, and leaving a wall is always possible).
+    const before = own.map((a) => {
+      const mover = shapeOf(a);
+      return obstacles.map(({ shape }) => overlapDepth(contactBetween(mover, shape, forward).separation));
+    });
+    shift(step);
+    let correction = 0;
+    let found: { own: Entity; obstacle: Obstacle } | null = null;
+    for (const [k, a] of own.entries()) {
+      const mover = shapeOf(a);
+      for (const [j, obstacle] of obstacles.entries()) {
+        const was = before[k]![j]!;
+        if (overlapDepth(contactBetween(mover, obstacle.shape, forward).separation) <= was + DEEPER) continue;
+        // Coming from outside, the step goes back exactly to where the two met; from inside, all
+        // of it is taken back.
+        const back =
+          was === 0
+            ? Math.min(step, exitDistance(mover, obstacle.shape, { x: -forward.x, y: -forward.y }))
+            : step;
+        if (back > correction || !found) {
+          correction = back;
+          found = { own: a, obstacle };
+        }
+      }
     }
+    if (!found) continue;
+    const { own: collider, obstacle } = found;
+    shift(-correction);
+    const left = distance - i * step - (step - correction);
+    return {
+      by: obstacle.body,
+      own: collider,
+      normal: contactBetween(shapeOf(collider), obstacle.shape, forward).normal,
+      left: { x: forward.x * left, y: forward.y * left },
+    };
   }
   return null;
 }
 
-/** One indivisible move along `axis`; returns the obstacle that stopped it, if one did. */
-function stepAxis(
-  entity: Entity,
-  own: Entity[],
-  obstacles: Obstacle[],
-  axis: PlaneAxis,
-  delta: number,
-  travel: AxisTravel,
-): Entity | null {
-  const dir: 1 | -1 = delta > 0 ? 1 : -1;
-  const forward = { x: dir * travel.unit.x, y: dir * travel.unit.y };
-  // How deep each pair already sits in the other before the step. A step may never deepen
-  // that, but resolving it is not our job (no jolt, and leaving a wall is always possible).
-  // Overlaps below the skin count as plain contact – that is where rounding leftovers of a
-  // previous correction land, and taking those for "already inside" would open the wall.
-  const before = own.map((a) => {
-    const mover = shapeOf(a);
-    return obstacles.map(({ shape }) => {
-      const p = penetration(mover, shape, forward);
-      return p > SKIN ? p : 0;
-    });
-  });
-  entity[axis] += delta;
-  let correction = 0;
-  let by: Entity | null = null;
-  own.forEach((a, i) => {
-    const mover = shapeOf(a);
-    obstacles.forEach(({ shape, body }, j) => {
-      const t = penetration(mover, shape, forward) - before[i]![j]!;
-      if (t > correction) {
-        correction = t;
-        by = body;
-      }
-    });
-  });
-  if (correction <= 0) return null;
-  entity[axis] -= dir * Math.min(correction / travel.length, Math.abs(delta));
-  return by;
+/**
+ * What of a move goes on after a contact: nothing into the surface, and along it what friction
+ * leaves – shortened by `friction` times the part that pressed into the surface, down to nothing.
+ */
+function slideAlong(move: Vec2, normal: Vec2, friction: number): Vec2 {
+  const into = dot(move, normal);
+  if (into >= 0) return move;
+  const along = { x: move.x - into * normal.x, y: move.y - into * normal.y };
+  const length = Math.hypot(along.x, along.y);
+  const kept = length - friction * -into;
+  if (kept <= 0 || length === 0) return { x: 0, y: 0 };
+  return { x: (along.x * kept) / length, y: (along.y * kept) / length };
 }
 
-/** Where one unit along an entity's local axis goes in the world, and how far. */
-interface AxisTravel {
-  unit: Vec2;
-  length: number;
+/**
+ * The friction of a pair, as the physics engine combines it for its bodies (the average), so an
+ * object moved by the graph slides as far as one the engine moves. A tile has no material of its
+ * own and has what a new collider starts with.
+ */
+function frictionBetween(own: Entity, obstacle: Entity): number {
+  const of = (e: Entity) => colliderMaterial(e.type === 'collider' ? e.props : {}).friction;
+  return (of(own) + of(obstacle)) / 2;
 }
 
-function axisTravel(entity: Entity, axis: PlaneAxis): AxisTravel {
-  const parent = entity.parent ? worldMatrixOf(entity.parent) : IDENTITY;
-  const v = applyVector(parent, axis === 'x' ? { x: 1, y: 0 } : { x: 0, y: 1 });
+function dot(a: Vec2, b: Vec2): number {
+  return a.x * b.x + a.y * b.y;
+}
+
+function unitOf(v: Vec2): Vec2 {
   const length = Math.hypot(v.x, v.y);
-  return length > 0
-    ? { unit: { x: v.x / length, y: v.y / length }, length }
-    : { unit: { x: 1, y: 0 }, length: 1 };
+  return length > 0 ? { x: v.x / length, y: v.y / length } : v;
 }
 
 export function shapeOf(collider: Entity): ColliderShape {
   return colliderShape(collider.props, worldMatrixOf(collider));
 }
 
-/**
- * How far `a` would have to be pushed back against its travel to just clear `b` (0 when they are
- * apart). Once a's centre has passed b's centre along the travel the shorter way out is forwards,
- * so nothing blocks – that keeps an object that ended up inside something able to leave.
- */
-function penetration(mover: ColliderShape, obstacle: ColliderShape, forward: Vec2): number {
-  if ((mover.x - obstacle.x) * forward.x + (mover.y - obstacle.y) * forward.y >= 0) return 0;
-  return exitDistance(mover, obstacle, { x: -forward.x, y: -forward.y });
-}
-
 /** What of an entity stops at walls when it moves: its solid colliders that are switched on. */
 export function blockingCollidersOf(world: World, entity: Entity): Entity[] {
   return collidersOf(world, entity).filter((c) => !isTrigger(c.props) && isHandleEnabled(c));