dacha 0.18.0-alpha.8 → 0.18.0-alpha.9

package/build/contrib/components/rigid-body/index.d.ts

@@ -1,21 +1,35 @@
 import { Component } from '../../../engine/component';
-import { Vector2 } from '../../../engine/math-lib';
+import { Vector2, type Point } from '../../../engine/math-lib';
 export type RigidBodyType = 'dynamic' | 'static' | 'kinematic';
 export interface RigidBodyConfig {
     type: RigidBodyType;
     mass?: number;
     gravityScale?: number;
     linearDamping?: number;
+    angularDamping?: number;
+    lockRotation?: boolean;
+    autoSleep?: boolean;
+    restitution?: number;
+    friction?: number;
     disabled: boolean;
     oneWay: boolean;
     oneWayNormalX?: number;
     oneWayNormalY?: number;
 }
+interface PointForce {
+    force: Vector2;
+    position: Point;
+}
+interface PointImpulse {
+    impulse: Vector2;
+    position: Point;
+}
 /**
  * RigidBody component for defining rigid body physics.
  *
- * Defines the physics properties for an actor. It's used by the
- * physics system to apply forces and impulses to the actor.
+ * Defines the physics properties for an actor. Dynamic bodies react to forces,
+ * impulses, gravity, collisions, and rotation. Static and kinematic bodies can
+ * participate in collisions but are not moved by solver impulses.
  *
  * @example
  * ```typescript
@@ -40,24 +54,54 @@ export interface RigidBodyConfig {
 export declare class RigidBody extends Component {
     private _mass;
     private _inverseMass;
+    private _inertia;
+    private _inverseInertia;
+    private _restitution;
+    private _friction;
     /** @internal Pending one-step kinematic movement target */
     _movementTarget: Vector2 | null;
+    /** @internal Linear velocity from the start of the current physics step */
+    _prevLinearVelocity: Vector2;
+    /** @internal Angular velocity from the start of the current physics step */
+    _prevAngularVelocity: number;
+    /** @internal Temporary solver velocity used for contact separation */
+    _biasLinearVelocity: Vector2;
+    /** @internal Temporary solver angular velocity used for contact separation */
+    _biasAngularVelocity: number;
+    /** @internal Time this body has stayed below automatic sleep thresholds */
+    _sleepTime: number;
     /** Body type that defines how the rigid body participates in simulation */
     readonly type: RigidBodyType;
-    /** Gravity scale of the rigid body */
+    /** Gravity multiplier. `0` ignores gravity, `1` uses normal world gravity. */
     gravityScale: number;
-    /** Linear damping value used to slow down movement over time */
+    /** Linear damping used to slow down movement over time */
     linearDamping: number;
-    /** Current linear velocity of the rigid body */
+    /** Angular damping used to slow down rotation over time */
+    angularDamping: number;
+    /** Current linear velocity in world units per second */
     linearVelocity: Vector2;
+    /** Current angular velocity of the rigid body in radians per second */
+    angularVelocity: number;
+    /** Whether dynamic rotation is locked. Locked bodies do not spin from torque or contacts. */
+    lockRotation: boolean;
     /** Whether rigid body simulation is disabled */
     disabled: boolean;
     /** Whether rigid body is sleeping */
     sleeping: boolean;
-    /** Force applied to the rigid body */
-    force: Vector2;
-    /** Impulse applied to the rigid body */
-    impulse: Vector2;
+    /** Whether this body may be put to sleep automatically when settled */
+    autoSleep: boolean;
+    /** @internal Force applied at the rigid body center */
+    _centralForce: Vector2;
+    /** @internal Impulse applied at the rigid body center */
+    _centralImpulse: Vector2;
+    /** @internal Forces applied at world-space positions */
+    _pointForces: PointForce[];
+    /** @internal Impulses applied at world-space positions */
+    _pointImpulses: PointImpulse[];
+    /** @internal Torque applied to the rigid body */
+    _torque: number;
+    /** @internal Angular impulse applied to the rigid body */
+    _angularImpulse: number;
     /** Whether contacts should only be resolved from one side */
     oneWay: boolean;
     /** Local-space normal that points toward the blocking side */
@@ -80,18 +124,59 @@ export declare class RigidBody extends Component {
      * Bodies with zero or negative mass return `0`.
      */
     get inverseMass(): number;
+    get inertia(): number;
+    /**
+     * Moment of inertia used by dynamic bodies.
+     *
+     * Inertia is the rotational equivalent of mass: higher values make the body
+     * harder to spin. It is automatically computed from the collider shape, mass,
+     * and collider offset every physics step, so user code usually should only
+     * read this value.
+     */
+    set inertia(value: number);
+    /**
+     * Returns the inverse moment of inertia.
+     *
+     * This is the solver-friendly form of inertia. Static bodies, kinematic
+     * bodies, locked rotation, or non-positive inertia return `0`.
+     */
+    get inverseInertia(): number;
+    /** Bounciness used by contact resolution. `0` does not bounce, `1` keeps full bounce speed. */
+    get restitution(): number;
+    set restitution(value: number);
+    /** Surface friction used by contact resolution. Higher values reduce sliding more strongly. */
+    get friction(): number;
+    set friction(value: number);
     /**
      * Adds a continuous force to a dynamic body for the next physics step.
      *
-     * Affects only active dynamic bodies.
+     * Affects only active dynamic bodies. When `position` is provided, it is a
+     * world-space point where the force is applied; off-center forces can also
+     * rotate the body.
      */
-    applyForce(force: Vector2): void;
+    applyForce(force: Vector2, position?: Point): void;
     /**
      * Adds an instantaneous impulse to a dynamic body for the next physics step.
      *
-     * Affects only active dynamic bodies.
+     * Affects only active dynamic bodies. An impulse is a one-step velocity kick.
+     * When `position` is provided, it is a world-space point where the impulse is
+     * applied; off-center impulses can also rotate the body.
+     */
+    applyImpulse(impulse: Vector2, position?: Point): void;
+    /**
+     * Adds a continuous torque to a dynamic body for the next physics step.
+     *
+     * Torque is rotational force: it changes angular velocity over time. Affects
+     * only active dynamic bodies with unlocked rotation.
+     */
+    applyTorque(torque: number): void;
+    /**
+     * Adds an instantaneous angular impulse to a dynamic body for the next physics step.
+     *
+     * Angular impulse is an immediate rotational kick. Affects only active dynamic
+     * bodies with unlocked rotation.
      */
-    applyImpulse(impulse: Vector2): void;
+    applyAngularImpulse(impulse: number): void;
     /**
      * Marks the rigid body as awake so it can be simulated.
      */
@@ -112,3 +197,4 @@ export declare class RigidBody extends Component {
      */
     movePosition(position: Vector2): void;
 }
+export {};

package/build/contrib/components/rigid-body/index.js

@@ -3,8 +3,9 @@ import { Vector2 } from '../../../engine/math-lib';
 /**
  * RigidBody component for defining rigid body physics.
  *
- * Defines the physics properties for an actor. It's used by the
- * physics system to apply forces and impulses to the actor.
+ * Defines the physics properties for an actor. Dynamic bodies react to forces,
+ * impulses, gravity, collisions, and rotation. Static and kinematic bodies can
+ * participate in collisions but are not moved by solver impulses.
  *
  * @example
  * ```typescript
@@ -29,24 +30,54 @@ import { Vector2 } from '../../../engine/math-lib';
 export class RigidBody extends Component {
     _mass;
     _inverseMass;
+    _inertia;
+    _inverseInertia;
+    _restitution;
+    _friction;
     /** @internal Pending one-step kinematic movement target */
     _movementTarget;
+    /** @internal Linear velocity from the start of the current physics step */
+    _prevLinearVelocity;
+    /** @internal Angular velocity from the start of the current physics step */
+    _prevAngularVelocity;
+    /** @internal Temporary solver velocity used for contact separation */
+    _biasLinearVelocity;
+    /** @internal Temporary solver angular velocity used for contact separation */
+    _biasAngularVelocity;
+    /** @internal Time this body has stayed below automatic sleep thresholds */
+    _sleepTime;
     /** Body type that defines how the rigid body participates in simulation */
     type;
-    /** Gravity scale of the rigid body */
+    /** Gravity multiplier. `0` ignores gravity, `1` uses normal world gravity. */
     gravityScale;
-    /** Linear damping value used to slow down movement over time */
+    /** Linear damping used to slow down movement over time */
     linearDamping;
-    /** Current linear velocity of the rigid body */
+    /** Angular damping used to slow down rotation over time */
+    angularDamping;
+    /** Current linear velocity in world units per second */
     linearVelocity;
+    /** Current angular velocity of the rigid body in radians per second */
+    angularVelocity;
+    /** Whether dynamic rotation is locked. Locked bodies do not spin from torque or contacts. */
+    lockRotation;
     /** Whether rigid body simulation is disabled */
     disabled;
     /** Whether rigid body is sleeping */
     sleeping;
-    /** Force applied to the rigid body */
-    force;
-    /** Impulse applied to the rigid body */
-    impulse;
+    /** Whether this body may be put to sleep automatically when settled */
+    autoSleep;
+    /** @internal Force applied at the rigid body center */
+    _centralForce;
+    /** @internal Impulse applied at the rigid body center */
+    _centralImpulse;
+    /** @internal Forces applied at world-space positions */
+    _pointForces;
+    /** @internal Impulses applied at world-space positions */
+    _pointImpulses;
+    /** @internal Torque applied to the rigid body */
+    _torque;
+    /** @internal Angular impulse applied to the rigid body */
+    _angularImpulse;
     /** Whether contacts should only be resolved from one side */
     oneWay;
     /** Local-space normal that points toward the blocking side */
@@ -59,16 +90,36 @@ export class RigidBody extends Component {
         super();
         this._mass = 0;
         this._inverseMass = 0;
+        this._inertia = 0;
+        this._inverseInertia = 0;
+        this._restitution = 0;
+        this._friction = 0;
         this._movementTarget = null;
+        this._prevLinearVelocity = new Vector2(0, 0);
+        this._prevAngularVelocity = 0;
+        this._biasLinearVelocity = new Vector2(0, 0);
+        this._biasAngularVelocity = 0;
+        this._sleepTime = 0;
         this.type = config.type;
-        this.mass = config.mass ?? 0;
-        this.gravityScale = config.gravityScale ?? 0;
+        this.mass = config.mass ?? (this.type === 'dynamic' ? 1 : 0);
+        this.gravityScale =
+            config.gravityScale ?? (this.type === 'dynamic' ? 1 : 0);
         this.linearDamping = config.linearDamping ?? 0;
-        this.linearVelocity = new Vector2(0, 0);
+        this.angularDamping = config.angularDamping ?? 0;
+        this.restitution = config.restitution ?? 0;
+        this.friction = config.friction ?? 0.6;
+        this.lockRotation = config.lockRotation ?? false;
+        this.autoSleep = config.autoSleep ?? true;
         this.disabled = config.disabled;
+        this.linearVelocity = new Vector2(0, 0);
+        this.angularVelocity = 0;
         this.sleeping = false;
-        this.force = new Vector2(0, 0);
-        this.impulse = new Vector2(0, 0);
+        this._centralForce = new Vector2(0, 0);
+        this._centralImpulse = new Vector2(0, 0);
+        this._pointForces = [];
+        this._pointImpulses = [];
+        this._torque = 0;
+        this._angularImpulse = 0;
         this.oneWay = config.oneWay ?? false;
         if (this.oneWay) {
             this.oneWayNormal = new Vector2(config.oneWayNormalX ?? 0, config.oneWayNormalY ?? 0).normalize();
@@ -95,50 +146,160 @@ export class RigidBody extends Component {
      * Bodies with zero or negative mass return `0`.
      */
     get inverseMass() {
+        if (this.type === 'static' || this.type === 'kinematic' || this.sleeping) {
+            return 0;
+        }
         return this._inverseMass;
     }
+    get inertia() {
+        return this._inertia;
+    }
+    /**
+     * Moment of inertia used by dynamic bodies.
+     *
+     * Inertia is the rotational equivalent of mass: higher values make the body
+     * harder to spin. It is automatically computed from the collider shape, mass,
+     * and collider offset every physics step, so user code usually should only
+     * read this value.
+     */
+    set inertia(value) {
+        this._inertia = value;
+        this._inverseInertia = value > 0 ? 1 / value : 0;
+    }
+    /**
+     * Returns the inverse moment of inertia.
+     *
+     * This is the solver-friendly form of inertia. Static bodies, kinematic
+     * bodies, locked rotation, or non-positive inertia return `0`.
+     */
+    get inverseInertia() {
+        if (this.type === 'static' ||
+            this.type === 'kinematic' ||
+            this.sleeping ||
+            this.lockRotation) {
+            return 0;
+        }
+        return this._inverseInertia;
+    }
+    /** Bounciness used by contact resolution. `0` does not bounce, `1` keeps full bounce speed. */
+    get restitution() {
+        return this._restitution;
+    }
+    set restitution(value) {
+        this._restitution = Math.max(0, Math.min(value, 1));
+    }
+    /** Surface friction used by contact resolution. Higher values reduce sliding more strongly. */
+    get friction() {
+        return this._friction;
+    }
+    set friction(value) {
+        this._friction = Math.max(0, value);
+    }
     /**
      * Adds a continuous force to a dynamic body for the next physics step.
      *
-     * Affects only active dynamic bodies.
+     * Affects only active dynamic bodies. When `position` is provided, it is a
+     * world-space point where the force is applied; off-center forces can also
+     * rotate the body.
      */
-    applyForce(force) {
+    applyForce(force, position) {
         if (this.disabled || this.type !== 'dynamic') {
             return;
         }
         this.wakeUp();
-        this.force.add(force);
+        if (!position) {
+            this._centralForce.add(force);
+            return;
+        }
+        this._pointForces.push({
+            force: force.clone(),
+            position: { x: position.x, y: position.y },
+        });
     }
     /**
      * Adds an instantaneous impulse to a dynamic body for the next physics step.
      *
-     * Affects only active dynamic bodies.
+     * Affects only active dynamic bodies. An impulse is a one-step velocity kick.
+     * When `position` is provided, it is a world-space point where the impulse is
+     * applied; off-center impulses can also rotate the body.
      */
-    applyImpulse(impulse) {
+    applyImpulse(impulse, position) {
         if (this.disabled || this.type !== 'dynamic') {
             return;
         }
         this.wakeUp();
-        this.impulse.add(impulse);
+        if (!position) {
+            this._centralImpulse.add(impulse);
+            return;
+        }
+        this._pointImpulses.push({
+            impulse: impulse.clone(),
+            position: { x: position.x, y: position.y },
+        });
+    }
+    /**
+     * Adds a continuous torque to a dynamic body for the next physics step.
+     *
+     * Torque is rotational force: it changes angular velocity over time. Affects
+     * only active dynamic bodies with unlocked rotation.
+     */
+    applyTorque(torque) {
+        if (this.disabled || this.type !== 'dynamic' || this.lockRotation) {
+            return;
+        }
+        this.wakeUp();
+        this._torque += torque;
+    }
+    /**
+     * Adds an instantaneous angular impulse to a dynamic body for the next physics step.
+     *
+     * Angular impulse is an immediate rotational kick. Affects only active dynamic
+     * bodies with unlocked rotation.
+     */
+    applyAngularImpulse(impulse) {
+        if (this.disabled || this.type !== 'dynamic' || this.lockRotation) {
+            return;
+        }
+        this.wakeUp();
+        this._angularImpulse += impulse;
     }
     /**
      * Marks the rigid body as awake so it can be simulated.
      */
     wakeUp() {
+        if (this.disabled || this.type !== 'dynamic') {
+            return;
+        }
         this.sleeping = false;
+        this._sleepTime = 0;
     }
     /**
      * Marks the rigid body as sleeping so dynamic integration can skip it.
      */
     sleep() {
+        if (this.disabled || this.type !== 'dynamic') {
+            return;
+        }
         this.sleeping = true;
+        this._sleepTime = 0;
+        this._prevLinearVelocity.multiplyNumber(0);
+        this._prevAngularVelocity = 0;
+        this.linearVelocity.multiplyNumber(0);
+        this.angularVelocity = 0;
+        this._biasLinearVelocity.multiplyNumber(0);
+        this._biasAngularVelocity = 0;
+        this.clearForces();
     }
     /**
      * Clears all accumulated force and impulse values.
      */
     clearForces() {
-        this.force.multiplyNumber(0);
-        this.impulse.multiplyNumber(0);
+        this._centralForce.multiplyNumber(0);
+        this._centralImpulse.multiplyNumber(0);
+        this._pointForces.length = 0;
+        this._pointImpulses.length = 0;
+        this._torque = 0;
+        this._angularImpulse = 0;
     }
     /**
      * Moves a kinematic body to a target position on the next physics step.

package/build/contrib/systems/animator/index.d.ts

@@ -1,5 +1,5 @@
 import { SceneSystem } from '../../../engine/system';
-import type { UpdateOptions, SceneSystemOptions } from '../../../engine/system';
+import type { SceneSystemOptions } from '../../../engine/system';
 /**
  * Animator system that manages the animation of actors with {@link Animatable} components
  * using the state machine approach
@@ -10,6 +10,7 @@ import type { UpdateOptions, SceneSystemOptions } from '../../../engine/system';
  */
 export declare class Animator extends SceneSystem {
     private actorQuery;
+    private time;
     private substatePickers;
     private actorConditions;
     constructor(options: SceneSystemOptions);
@@ -18,5 +19,5 @@ export declare class Animator extends SceneSystem {
     private setUpConditionControllers;
     private updateFrame;
     private pickSubstate;
-    update(options: UpdateOptions): void;
+    update(): void;
 }

package/build/contrib/systems/animator/index.js

@@ -5,7 +5,8 @@ import { RemoveActor } from '../../../engine/events';
 import { conditionControllers } from './condition-controllers';
 import { substatePickers } from './substate-pickers';
 import { setValue } from './utils';
-const FRAME_RATE = 100;
+// Seconds per animation frame at speed 1.
+const FRAME_RATE = 0.1;
 /**
  * Animator system that manages the animation of actors with {@link Animatable} components
  * using the state machine approach
@@ -16,10 +17,12 @@ const FRAME_RATE = 100;
  */
 export class Animator extends SceneSystem {
     actorQuery;
+    time;
     substatePickers;
     actorConditions;
     constructor(options) {
         super();
+        this.time = options.time;
         this.actorQuery = new ActorQuery({
             scene: options.scene,
             filter: [Animatable],
@@ -64,8 +67,8 @@ export class Animator extends SceneSystem {
         const substatePicker = this.substatePickers[state.pickMode];
         return substatePicker.getSubstate(actor, state.substates, state.pickProps);
     }
-    update(options) {
-        const { deltaTime } = options;
+    update() {
+        const { deltaTime } = this.time;
         this.actorQuery.getActors().forEach((actor) => {
             const animatable = actor.getComponent(Animatable);
             if (animatable.currentState === void 0) {

package/build/contrib/systems/behavior-system/system.d.ts

@@ -1,5 +1,5 @@
 import { SceneSystem } from '../../../engine/system';
-import type { SceneSystemOptions, UpdateOptions } from '../../../engine/system';
+import type { SceneSystemOptions } from '../../../engine/system';
 /**
  * Behavior system that manages custom behavior execution for actors
  * with {@link Behaviors} components
@@ -15,6 +15,7 @@ export declare class BehaviorSystem extends SceneSystem {
     private behaviors;
     private world;
     private scene;
+    private time;
     private activeBehaviors;
     constructor(options: SceneSystemOptions);
     onSceneEnter(): void;
@@ -22,5 +23,6 @@ export declare class BehaviorSystem extends SceneSystem {
     private handleActorAdd;
     private handleActorRemove;
     private setUpBehavior;
-    update(options: UpdateOptions): void;
+    update(): void;
+    fixedUpdate(): void;
 }

package/build/contrib/systems/behavior-system/system.js

@@ -17,12 +17,14 @@ export class BehaviorSystem extends SceneSystem {
     behaviors;
     world;
     scene;
+    time;
     activeBehaviors;
     constructor(options) {
         super();
-        const { actorSpawner, world, scene, globalOptions, resources = [], } = options;
+        const { actorSpawner, world, scene, globalOptions, time, resources = [], } = options;
         this.world = world;
         this.scene = scene;
+        this.time = time;
         this.behaviorQuery = new ActorQuery({
             scene,
             filter: [Behaviors],
@@ -79,14 +81,20 @@ export class BehaviorSystem extends SceneSystem {
                 world: this.world,
                 scene: this.scene,
                 globalOptions: this.globalOptions,
+                time: this.time,
             };
             const BehaviorClass = this.behaviors[config.name];
             return new BehaviorClass(options);
         });
     }
-    update(options) {
+    update() {
         this.behaviorQuery.getActors().forEach((actor) => {
-            this.activeBehaviors[actor.id].forEach((behavior) => behavior.update?.(options));
+            this.activeBehaviors[actor.id].forEach((behavior) => behavior.update?.());
+        });
+    }
+    fixedUpdate() {
+        this.behaviorQuery.getActors().forEach((actor) => {
+            this.activeBehaviors[actor.id].forEach((behavior) => behavior.fixedUpdate?.());
         });
     }
 }

package/build/contrib/systems/behavior-system/types.d.ts

@@ -1,6 +1,7 @@
 import type { Actor, ActorSpawner } from '../../../engine/actor';
 import type { World } from '../../../engine/world';
 import type { Scene } from '../../../engine/scene';
+import type { Time } from '../../../engine/time';
 import type { Constructor } from '../../../types/utils';
 /**
  * Options for the behavior
@@ -16,13 +17,8 @@ export interface BehaviorOptions {
     actorSpawner: ActorSpawner;
     /** Global game options */
     globalOptions: Record<string, unknown>;
-}
-/**
- * Options for the update method
- */
-interface UpdateOptions {
-    /** Time elapsed since the last update in milliseconds */
-    deltaTime: number;
+    /** Shared timing state */
+    time: Time;
 }
 /**
  * Base class for all behaviors
@@ -35,8 +31,10 @@ export declare abstract class Behavior {
     static behaviorName: string;
     /** Destroy the behavior */
     destroy?(): void;
-    /** Update the behavior */
-    update?(options: UpdateOptions): void;
+    /** Update the behavior every frame with a variable timestep */
+    update?(): void;
+    /** Update the behavior with a fixed timestep, aligned with physics */
+    fixedUpdate?(): void;
 }
 /**
  * Constructor for all behaviors
@@ -44,4 +42,3 @@ export declare abstract class Behavior {
 export type BehaviorConstructor = Constructor<Behavior> & {
     behaviorName: string;
 };
-export {};

package/build/contrib/systems/character-controller/index.d.ts

@@ -1,5 +1,5 @@
 import { SceneSystem } from '../../../engine/system';
-import type { SceneSystemOptions, UpdateOptions } from '../../../engine/system';
+import type { SceneSystemOptions } from '../../../engine/system';
 /**
  * Kinematic character controller system with sweep/slide collision movement.
  *
@@ -13,9 +13,11 @@ import type { SceneSystemOptions, UpdateOptions } from '../../../engine/system';
 export declare class CharacterController extends SceneSystem {
     private actorQuery;
     private world;
+    private time;
     private oneWayValidator;
     constructor(options: SceneSystemOptions);
     onSceneDestroy(): void;
+    private handleRemoveActor;
     private isBlockingHit;
     private isWalkable;
     private isRecoverableOverlap;
@@ -28,5 +30,5 @@ export declare class CharacterController extends SceneSystem {
     private handleHit;
     private move;
     private updateGroundState;
-    fixedUpdate(options: UpdateOptions): void;
+    fixedUpdate(): void;
 }