incanto 0.31.0 → 0.33.0

package/dist/{register-tkR_8tWg.js → register-FIJtNbub.js}

@@ -1,9 +1,9 @@
-import { f as Node } from "./loader-BlaRQGaA.js";
-import { t as registerCoreNodes } from "./register-Dzkd6-os.js";
+import { f as Node } from "./loader-Buk8Bu1h.js";
+import { t as registerCoreNodes } from "./register-CscIzJEO.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
 import { i as getNodeSchema, l as registerNode } from "./registry-CJdGpT2V.js";
-import { r as effectiveOrder } from "./duplicate-KRPtUtzl.js";
+import { r as effectiveOrder } from "./duplicate-BgnG1Lqz.js";
 import { i as applyParticlePreset, r as PARTICLE_PRESET_NAMES, t as ParticleSim } from "./particle-sim-Bw7hB93B.js";
 import { AdditiveBlending, BufferAttribute, BufferGeometry, CanvasTexture, Color, DynamicDrawUsage, Group, InstancedMesh, MathUtils, Matrix4, Mesh, MeshBasicMaterial, NearestFilter, NormalBlending, Object3D, PlaneGeometry } from "three";
 //#region src/2d/physics/collider-validate.ts
@@ -214,6 +214,28 @@ var CharacterBody2D = class extends PhysicsBody2D {
 		if (!this._physics) throw new IncantoError("TREE_VIOLATION", this.collider.shape === void 0 ? `CharacterBody2D '${this.name}' has no collider — set a collider prop (physics skips collider-less bodies).` : `CharacterBody2D '${this.name}' has no physics world — await enablePhysics2D(engine) first.`);
 		this._physics.moveAndSlide(this);
 	}
+	/** @internal Set by the physics step from the KCC's resolved collisions. */
+	_onWall = 0;
+	/** @internal */
+	_onCeiling = false;
+	/**
+	* Touching a wall, and which side (-1 left, +1 right, 0 neither).
+	*
+	* Wall jump and wall slide are unbuildable without it — not awkward to build,
+	* impossible: `isOnFloor()` was the only surface a character could report, so
+	* even a hand-written behavior had nothing to ask.
+	*/
+	isOnWall() {
+		return this._onWall !== 0;
+	}
+	/** -1 the wall is to the left, +1 to the right, 0 no wall. */
+	wallSide() {
+		return this._onWall;
+	}
+	/** Head hit something — cut the jump short, the way every platformer does. */
+	isOnCeiling() {
+		return this._onCeiling;
+	}
 	isOnFloor() {
 		return this._grounded;
 	}
@@ -521,6 +543,18 @@ function clampCentered(v, lo, hi) {
 * - `platformer`: x movement + gravity (from the scene `physics.gravity[1]`,
 *   default 980) + jump (`jumpHeight` px → impulse √(2·g·h))
 * - `topDown`: full-axis movement, no gravity
+*
+* ## Why the extra platformer props exist
+*
+* A jump that only works while `isOnFloor()` is true feels BROKEN, and players
+* do not report it as "the coyote time is missing" — they report the game as
+* unresponsive. The whole schema used to be five props, so a JSON-only game got
+* a character that felt wrong and could not drive `AnimatedSprite2D.play('run')`
+* either. `examples/platformer-2d` hand-rolls all of this in a 541-line
+* behavior; these are those constants, as props.
+*
+* Every one defaults to OFF (0 / 1 / false), so an existing scene behaves
+* exactly as before until it asks for something.
 */
 var CharacterController2D = class extends Node {
 	static typeName = "CharacterController2D";
@@ -532,14 +566,48 @@ var CharacterController2D = class extends Node {
 		maxSpeed: { default: 220 },
 		jumpHeight: { default: 64 },
 		moveAction: { default: "move" },
-		jumpAction: { default: "jump" }
+		jumpAction: { default: "jump" },
+		/** Jump this long AFTER walking off a ledge. The single biggest one. */
+		coyoteSeconds: { default: 0 },
+		/** Press jump this long BEFORE landing and still get it. */
+		jumpBufferSeconds: { default: 0 },
+		/** Releasing jump early cuts the rise to this fraction (1 = fixed height). */
+		jumpCutMultiplier: { default: 1 },
+		/** 2 = double jump. Extra jumps work in mid-air. */
+		maxJumps: { default: 1 },
+		/** 0 = no dash. Speed while dashing, in px/s. */
+		dashSpeed: { default: 0 },
+		dashSeconds: { default: .15 },
+		dashAction: { default: "dash" },
+		/** 0 = no wall slide. Terminal fall speed while against a wall (px/s). */
+		wallSlideSpeed: { default: 0 },
+		/** 0 = no wall jump. `[away, up]` impulse in px/s. */
+		wallJumpImpulse: { default: [0, 0] }
 	};
+	static signals = ["movementStateChanged"];
 	mode = "platformer";
 	maxSpeed = 220;
 	/** Pixels (platformer mode). */
 	jumpHeight = 64;
 	moveAction = "move";
 	jumpAction = "jump";
+	coyoteSeconds = 0;
+	jumpBufferSeconds = 0;
+	jumpCutMultiplier = 1;
+	maxJumps = 1;
+	dashSpeed = 0;
+	dashSeconds = .15;
+	dashAction = "dash";
+	wallSlideSpeed = 0;
+	wallJumpImpulse = [0, 0];
+	/** What the character is doing — drive `AnimatedSprite2D.play(state)` off it. */
+	state = "idle";
+	coyoteLeft = 0;
+	bufferLeft = 0;
+	jumpsUsed = 0;
+	dashLeft = 0;
+	dashDir = 1;
+	rising = false;
 	onReady() {
 		if (!(this.parent instanceof CharacterBody2D)) throw new IncantoError("TREE_VIOLATION", `CharacterController2D '${this.name}' must be a child of a CharacterBody2D (parent is '${this.parent?.name ?? "none"}').`);
 		if (this.mode !== "platformer" && this.mode !== "topDown") throw new IncantoError("PROP_TYPE_MISMATCH", `CharacterController2D.mode must be 'platformer' or 'topDown', got '${this.mode}'.`);
@@ -557,12 +625,81 @@ var CharacterController2D = class extends Node {
 			return;
 		}
 		const gravityY = (engine.scene.physics?.gravity)?.[1] ?? 980;
+		const grounded = body.isOnFloor();
+		const jumpImpulse = -Math.sqrt(2 * gravityY * this.jumpHeight);
+		if (this.dashLeft > 0) {
+			this.dashLeft -= dt;
+			body.velocity[0] = this.dashDir * this.dashSpeed;
+			body.velocity[1] = 0;
+			body.moveAndSlide();
+			this.setState("dash");
+			return;
+		}
+		if (this.dashSpeed > 0 && input.justPressed(this.dashAction)) {
+			this.dashLeft = this.dashSeconds;
+			this.dashDir = dir.x !== 0 ? Math.sign(dir.x) : this.dashDir;
+			body.velocity[0] = this.dashDir * this.dashSpeed;
+			body.velocity[1] = 0;
+			body.moveAndSlide();
+			this.setState("dash");
+			return;
+		}
 		body.velocity[0] = dir.x * this.maxSpeed;
-		if (body.isOnFloor()) {
-			const jumped = input.justPressed(this.jumpAction);
-			body.velocity[1] = jumped ? -Math.sqrt(2 * gravityY * this.jumpHeight) : 20;
-		} else body.velocity[1] = (body.velocity[1] ?? 0) + gravityY * dt;
+		if (grounded) {
+			this.coyoteLeft = this.coyoteSeconds;
+			this.jumpsUsed = 0;
+		} else {
+			this.coyoteLeft = Math.max(0, this.coyoteLeft - dt);
+			if (this.coyoteLeft <= 0 && this.jumpsUsed === 0) this.jumpsUsed = 1;
+		}
+		if (input.justPressed(this.jumpAction)) this.bufferLeft = Math.max(this.jumpBufferSeconds, 0);
+		else this.bufferLeft = Math.max(0, this.bufferLeft - dt);
+		const wantsJump = this.bufferLeft > 0 || input.justPressed(this.jumpAction);
+		const onWall = this.wallSlideSpeed > 0 || this.wallJumpImpulse.some((v) => v !== 0) ? body.isOnWall() : false;
+		if (wantsJump && onWall && !grounded && this.wallJumpImpulse.some((v) => v !== 0)) {
+			const away = -body.wallSide();
+			body.velocity[0] = away * (this.wallJumpImpulse[0] ?? 0);
+			body.velocity[1] = -(this.wallJumpImpulse[1] ?? 0);
+			this.bufferLeft = 0;
+			this.rising = true;
+			this.jumpsUsed = 1;
+		} else if (wantsJump && (grounded || this.coyoteLeft > 0 || this.jumpsUsed < this.maxJumps)) {
+			body.velocity[1] = jumpImpulse;
+			this.bufferLeft = 0;
+			this.coyoteLeft = 0;
+			this.rising = true;
+			this.jumpsUsed = grounded ? 1 : this.jumpsUsed + 1;
+		} else if (grounded) {
+			body.velocity[1] = 20;
+			this.rising = false;
+		} else {
+			body.velocity[1] = (body.velocity[1] ?? 0) + gravityY * dt;
+			if (this.rising && this.jumpCutMultiplier < 1 && !input.isPressed(this.jumpAction)) {
+				body.velocity[1] = (body.velocity[1] ?? 0) * this.jumpCutMultiplier;
+				this.rising = false;
+			}
+			if ((body.velocity[1] ?? 0) >= 0) this.rising = false;
+			if (this.wallSlideSpeed > 0 && onWall && (body.velocity[1] ?? 0) > this.wallSlideSpeed) body.velocity[1] = this.wallSlideSpeed;
+		}
+		if (body.isOnCeiling() && (body.velocity[1] ?? 0) < 0) {
+			body.velocity[1] = 0;
+			this.rising = false;
+		}
 		body.moveAndSlide();
+		const vy = body.velocity[1] ?? 0;
+		if (this.wallSlideSpeed > 0 && !body.isOnFloor() && body.isOnWall() && vy > 0) this.setState("wallSlide");
+		else if (body.isOnFloor()) this.setState(Math.abs(dir.x) > .01 ? "run" : "idle");
+		else this.setState(vy < 0 ? "jump" : "fall");
+	}
+	/**
+	* Emits `movementStateChanged(state)` on a change — the 3D sibling has had
+	* this since it shipped, and it is what drives `AnimatedSprite2D.play(...)`
+	* from scene JSON instead of a behavior polling velocities.
+	*/
+	setState(next) {
+		if (next === this.state) return;
+		this.state = next;
+		this.emit("movementStateChanged", next);
 	}
 };
 //#endregion