incanto 0.74.0 → 0.75.0

package/bin/incanto-multiplay.mjs

@@ -143,18 +143,26 @@ for (const name of spawnerScenes) {
  * Found where the templates put it, or named with `--server`.
  */
 let server;
+let serverAt = null;
 const serverFlag = flag('--server', null);
+// The project root is one level above `src/game.scene.json` and two above
+// `src/scenes/game.scene.json`; the templates use both. Looking only two up
+// found nothing for every online example, said nothing, and ran the match on
+// the bare kernel — `roomState {}`, nobody seated, two cars on one grid slot.
 const serverGuesses = serverFlag
   ? [resolve(serverFlag)]
-  : ['server/src/server.ts', 'server/src/server.js', 'src/server.ts'].map((g) =>
+  : ['server/src/server.ts', 'server/src/server.js', 'src/server.ts'].flatMap((g) => [
+      resolve(sceneDir, '..', g),
       resolve(sceneDir, '..', '..', g),
-    );
+      resolve(g),
+    ]);
 for (const at of serverGuesses) {
   if (!existsSync(at)) continue;
   try {
     const mod = await import(pathToFileURL(at).href);
     server = mod.Server ?? mod.default;
     if (server) {
+      serverAt = at;
       if (!argv.includes('--json')) console.log(`· server: ${at} (${server.name || 'default'})`);
       break;
     }
@@ -171,7 +179,17 @@ if (serverFlag && !server) {
   console.error(`--server '${serverFlag}' exports neither \`Server\` nor a default.`);
   process.exit(1);
 }
+// A multiplayer scene with no server is a game whose rules are not in the
+// run. Not a failure — the bare kernel joins rooms and replicates — but a
+// thing the reader has to know, or every ✓ below is about a game without its referee.
+const serverNote = server
+  ? null
+  : 'no server loaded — looked for server/src/server.ts beside the project (or --server FILE); ' +
+    'the match ran on the bare kernel, so room state is empty and no remote function exists';
+if (serverNote && !argv.includes('--json')) console.log(`· ${serverNote}`);
 
+const driveSeconds = Number(flag('--seconds', 5)) || 5;
+const driveFrames = Math.max(1, Math.round(driveSeconds * 60));
 let report;
 try {
   report = await playMultiplayer({
@@ -179,7 +197,7 @@ try {
     scenes,
     ...(server ? { server } : {}),
     players: Number(flag('--players', 2)) || 2,
-    seconds: Number(flag('--seconds', 5)) || 5,
+    seconds: driveSeconds,
     seed: Number(flag('--seed', 1)) || 1,
     lateJoin: !argv.includes('--no-late-join'),
     load: {
@@ -188,11 +206,41 @@ try {
     },
     // Move the owner, or every replicated key holds its authored value and two
     // motionless clients agree about nothing in particular.
+    //
+    // A PHYSICS body (it has a `linearVelocity`) is driven by velocity, not by
+    // writing its position: teleporting a car every frame dropped it through
+    // kerbs into the infield, tumbling, and the rung then compared a body the
+    // instrument itself had thrown. The last drive frame stops what it started;
+    // whatever still coasts after that is the game's, and the comparison gives
+    // it one send window of slack.
     drive: (player, frame) => {
       const root = player.engine.scene?.root;
       const owner = root && findOwner(root);
       if (!owner || !Array.isArray(owner.position)) return;
       const spin = (player.account.charCodeAt(1) || 1) * 0.7;
+      if (Array.isArray(owner.linearVelocity)) {
+        // along the body's OWN forward (+z, the +Z-forward rule; a 2D body's
+        // +x) — a car dragged sideways fights its tyres and rolls over
+        const last = frame === driveFrames - 1;
+        const v = owner.linearVelocity;
+        const speed = last ? 0 : 3;
+        if (v.length === 3) {
+          // the heading from the Euler XYZ BASIS, not from `rotation[1]`: a
+          // body facing +x sits on the gimbal lock (yaw 90°) and its triple
+          // reads `[96, 88, -95]` — the forward column is right either way
+          const r = Array.isArray(owner.rotation) ? owner.rotation : [0, 0, 0];
+          const rx = ((r[0] ?? 0) * Math.PI) / 180;
+          const ry = ((r[1] ?? 0) * Math.PI) / 180;
+          const fx = Math.sin(ry);
+          const fz = Math.cos(rx) * Math.cos(ry);
+          const len = Math.hypot(fx, fz) || 1;
+          owner.linearVelocity = [(fx / len) * speed, v[1], (fz / len) * speed];
+        } else {
+          const a = ((typeof owner.rotation === 'number' ? owner.rotation : 0) * Math.PI) / 180;
+          owner.linearVelocity = [Math.cos(a) * speed, Math.sin(a) * speed];
+        }
+        return;
+      }
       owner.position = owner.position.map((v, i) =>
         i === 1 && owner.position.length === 3 ? v : Math.sin(frame / 20 + spin + i) * 4,
       );
@@ -214,7 +262,7 @@ function findOwner(node) {
 }
 
 if (argv.includes('--json')) {
-  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  process.stdout.write(`${JSON.stringify({ ...report, server: serverAt, serverNote }, null, 2)}\n`);
 } else {
   process.stdout.write(`${multiplayText(report)}\n`);
 }

package/dist/2d.d.ts

@@ -1,10 +1,10 @@
-import { c as showBootFailure, i as ParticleSim, o as ParticleView, r as SpatialPose, s as isWebGLAvailable } from "./audio-player-BOrk4eQx.js";
-import { P as Scene$1, S as Scheduler, T as RendererStats, b as Engine, d as PropSchema, jt as Node, n as BehaviorCtor, w as GameStats, x as EngineOptions } from "./behavior-J1cmVah0.js";
+import { c as showBootFailure, i as ParticleSim, o as ParticleView, r as SpatialPose, s as isWebGLAvailable } from "./audio-player-BRo2uvG6.js";
+import { P as Scene$1, S as Scheduler, T as RendererStats, b as Engine, d as PropSchema, jt as Node, n as BehaviorCtor, w as GameStats, x as EngineOptions } from "./behavior-B_245qRy.js";
 import { t as DiagnosticSink } from "./diagnostics-Cu85N3tL.js";
-import { a as SceneJson, s as JsonObject } from "./rng-Bb-IutXB.js";
-import { t as EditorSwitchOptions } from "./editor-switch-CFU9mCec.js";
+import { a as SceneJson, s as JsonObject } from "./rng-BsXZg3D6.js";
+import { t as EditorSwitchOptions } from "./editor-switch-O8mxpgRX.js";
 import { r as FrameStats } from "./frame-report-DNxDAb1w.js";
-import { t as LoadSceneOptions } from "./loader-BAeWMYfF.js";
+import { t as LoadSceneOptions } from "./loader-CbkVdXL8.js";
 import { n as AnimationEntry } from "./sprite-animation-CMr6f1K2.js";
 import { Group, Mesh, Object3D, Scene, Texture } from "three";
 import * as RapierNs from "@dimforge/rapier2d-compat";
@@ -246,6 +246,8 @@ declare class RigidBody2D extends PhysicsBody2D {
 declare class CharacterBody2D extends PhysicsBody2D {
   static override readonly typeName: string;
   static override readonly props: PropSchema;
+  /** See CharacterBody3D.pushes — a piston or a sweeping arm pushes; a character stops. */
+  pushes: number;
   /**
   * Renamed to match the 3D body, where `snapToGround` had to give the name
   * back to `Node3D`'s PLACEMENT prop. 2D has no placement prop, so nothing is
@@ -395,6 +397,8 @@ declare class Physics2D {
   * read the AUTHORED `mass` prop and hope it was the number Rapier settled on.
   */
   massOf(node: PhysicsBody2D): number;
+  /** The solver's rotation of a body, in degrees (the node's own unit). */
+  rotationOf(node: PhysicsBody2D): number;
   /**
   * Current solver velocity in px/s (fresher than the node prop mid-step).
   *
@@ -450,6 +454,29 @@ declare class Physics2D {
   private lastRoot;
   private readonly jointSet;
   private readonly joints;
+  /** The two bodies each live joint ties, so a departed joint can be unlinked. */
+  private readonly jointBodies;
+  /** What a pin's limits/motor were last pushed as, so a write re-applies. */
+  private readonly hingeState;
+  /** Joints refused at creation (bodies that disagree about the axis) — said once. */
+  private readonly refusedJoints;
+  /** A rope's or spring's numbers as last made, so a write REMAKES the joint. */
+  private readonly tetherState;
+  private tetherKey;
+  /**
+  * Who is jointed to whom, and whether that pair's contacts are on — see the
+  * 3D twin: a joint's own bodies are not the world to the character
+  * controller (not its obstacle when the contacts are off, never its ground).
+  */
+  private readonly jointed;
+  private linkJointed;
+  private unlinkJointed;
+  /**
+  * Push a pin's `limits` and motor to the solver — on creation, and again
+  * whenever either changes. Limits and `angle` are this body relative to the
+  * target; Rapier measures the other way round, hence the flip.
+  */
+  private applyHinge;
   private readonly bodySet;
   /**
   * Move every body to its node's current transform — outline mode only.
@@ -530,6 +557,14 @@ interface CreateGame2DOptions {
   */
   debug?: boolean;
   /**
+  * Start the frame loop as soon as the game is built (default `true`).
+  * `false` hands back a game that has not run a frame; call
+  * `game.engine.start()` once everything that must exist BEFORE the first
+  * frame does — a `NetworkManager`, whose join takes a moment during which
+  * every behaviour would otherwise run the game offline. See the 3D twin.
+  */
+  autoStart?: boolean;
+  /**
   * LIVE EDITING: the ☰ debug menu gains "edit this scene", which turns this
   * page into the scene editor — same window, no reload — and the editor's play
   * button turns it back into the game.
@@ -809,6 +844,16 @@ declare class Camera2D extends Node2D {
   /** [minX, minY, maxX, maxY] world px; empty = unlimited. */
   limits: number[];
   current: boolean;
+  /**
+  * Make THIS the scene's camera and no other: the renderer takes the first
+  * camera whose `current` is true in tree order, so setting your own without
+  * clearing the gameplay camera's changed nothing visible. A handler a
+  * connection can name — `triggerEnter → DoorCam.makeCurrent`.
+  */
+  makeCurrent(blendSeconds?: number | undefined): void;
+  blendSeconds: number;
+  /** @internal `makeCurrent(seconds)` — read once by the renderer. */
+  _blendRequest: number | undefined;
   /** `zoom` clamped to a positive floor — 0/negative zoom must never produce NaN views. */
   get effectiveZoom(): number;
   /** The `follow` path already reported as untrackable — cleared by a new one. */
@@ -857,10 +902,17 @@ declare class CharacterController2D extends Node {
   dashSpeed: number;
   dashSeconds: number;
   dashAction: string;
+  crouchHeight: number;
+  crouchSpeedMultiplier: number;
+  crouchAction: string;
+  /** Read-only: shorter right now — by the key, or by a ceiling. */
+  crouching: boolean;
+  /** The collider height to stand back up to. */
+  private standingHeight;
   wallSlideSpeed: number;
   wallJumpImpulse: number[];
   /** What the character is doing — drive `AnimatedSprite2D.play(state)` off it. */
-  state: "idle" | "run" | "jump" | "fall" | "wallSlide" | "dash";
+  state: "idle" | "run" | "jump" | "fall" | "wallSlide" | "dash" | "crouch" | "sneak";
   private coyoteLeft;
   private bufferLeft;
   private jumpsUsed;
@@ -936,7 +988,7 @@ declare class ColorRect2D extends Node2D {
 }
 //#endregion
 //#region src/2d/nodes/joint-2d.d.ts
-type JointType2D = "fixed" | "revolute" | "rope" | "spring";
+type JointType2D = "fixed" | "revolute" | "prismatic" | "rope" | "spring";
 /**
 * A physics joint linking its PARENT body to `target` (a node path to the
 * other body). Godot-style placement: the joint lives as a child of body A.
@@ -956,6 +1008,27 @@ declare class Joint2D extends Node2D {
   target: string;
   anchor: number[];
   targetAnchor: number[];
+  /**
+  * `[min, max]` in degrees for a `revolute` swing; `[]` = no stops. Measured
+  * as `angle` is: this body turned relative to the target, `rotation`'s sign.
+  */
+  limits: number[];
+  /** Degrees a second the motor drives the pin at; `0` = no motor (free). */
+  motorSpeed: number;
+  /** The motor's gain — how quickly it reaches and holds `motorSpeed`. */
+  motorStrength: number;
+  /**
+  * The pin's current angle in degrees — this body's rotation relative to the
+  * target, written by physics every step. `0` unless `revolute` and simulated.
+  */
+  angle: number;
+  /** The line of a `prismatic` slide (local to this body). */
+  axis: number[];
+  /**
+  * A `prismatic` slide's current travel in px — this body's anchor along
+  * `axis` relative to the target's; `0` where the anchors coincide.
+  */
+  travel: number;
   /** rope/spring rest length in px; 0 = measure body distance at creation. */
   length: number;
   stiffness: number;
@@ -1085,6 +1158,8 @@ declare class Particles2D extends Node2D {
   shimmer: number;
   blend: string;
   maxParticles: number;
+  emitBox: number[];
+  drift: number[];
   /** Loader hook: unknown presets and bad blends fail at LOAD. */
   static validateJson(node: Node): void;
   private sim;
@@ -1353,6 +1428,7 @@ declare class Renderer2D {
     cy: number;
     zoom: number;
   } | null;
+  private readonly viewBlend;
   private readonly webgl;
   /**
   * The pixels of the next drawn frame — how `incanto-frame` sees a 2D game.

package/dist/2d.js

@@ -1,9 +1,10 @@
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as showBootFailure } from "./boot-failure-CKYrEcGF.js";
 import { t as isWebGLAvailable } from "./webgl-unavailable-C8aDbGmR.js";
-import { a as AssetStore2D, i as syncTree2D, r as Renderer2D, t as createGame2D } from "./create-game-ssvGvP7W.js";
-import { _ as RigidBody2D, a as parseCells, c as ColorRect2D, d as AnimatedSprite2D, f as Sprite2D, g as PhysicsBody2D, h as CharacterBody2D, i as mergeSolidRects, l as CharacterController2D, m as Area2D, n as UILayer, o as Particles2D, p as Joint2D, r as TileMap2D, s as Label, t as registerNodes2D, u as Camera2D, v as StaticBody2D, y as Node2D } from "./register-DRQyZKGU.js";
-import { n as enablePhysics2D, t as Physics2D } from "./physics-2d-C-SfvjzH.js";
+import { a as AssetStore2D, i as syncTree2D, r as Renderer2D, t as createGame2D } from "./create-game-DnwhJ5nW.js";
+import { _ as Node2D, f as Area2D, g as StaticBody2D, h as RigidBody2D, m as PhysicsBody2D, p as CharacterBody2D } from "./gameplay-D-JuGura.js";
+import { a as parseCells, c as ColorRect2D, d as AnimatedSprite2D, f as Sprite2D, i as mergeSolidRects, l as CharacterController2D, n as UILayer, o as Particles2D, p as Joint2D, r as TileMap2D, s as Label, t as registerNodes2D, u as Camera2D } from "./register-DxAbTO2T.js";
+import { n as enablePhysics2D, t as Physics2D } from "./physics-2d-x3bCrQf0.js";
 //#region src/2d/library-sprite.ts
 /**
 * What a `CharacterController2D`/`3D` will ask a skin to play, and the clip in