dacha 0.18.0-alpha.2 → 0.18.0-alpha.4

package/build/contrib/components/pixi-view/index.js

@@ -18,7 +18,8 @@ import { Component } from '../../../engine/component';
  *     return graphics;
  *   },
  *   sortingLayer: 'units',
- *   sortCenter: [0, 0],
+ *   sortOffsetX: 0,
+ *   sortOffsetY: 0,
  * });
  *
  * // Add to actor
@@ -33,7 +34,7 @@ export class PixiView extends Component {
     /** Sorting layer of the pixi view */
     sortingLayer;
     /** Center point of the pixi view */
-    sortCenter;
+    sortOffset;
     /** Internal rendering data */
     renderData;
     /**
@@ -45,18 +46,11 @@ export class PixiView extends Component {
         super();
         this.createView = config.createView;
         this.sortingLayer = config.sortingLayer;
-        this.sortCenter = config.sortCenter;
+        this.sortOffset = { x: config.sortOffsetX, y: config.sortOffsetY };
     }
     /** Get the pixi.js view. It's only available after the actor with this component is added to a scene */
     get view() {
         return this.renderData?.view;
     }
-    clone() {
-        return new PixiView({
-            createView: this.createView,
-            sortingLayer: this.sortingLayer,
-            sortCenter: this.sortCenter.slice(0),
-        });
-    }
 }
 PixiView.componentName = 'PixiView';

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

@@ -1,12 +1,15 @@
 import { Component } from '../../../engine/component';
 import { Vector2 } from '../../../engine/math-lib';
-export type RigidBodyType = 'dynamic' | 'static';
+export type RigidBodyType = 'dynamic' | 'static' | 'kinematic';
 export interface RigidBodyConfig {
     type: RigidBodyType;
-    mass: number;
-    gravityScale: number;
-    linearDamping: number;
+    mass?: number;
+    gravityScale?: number;
+    linearDamping?: number;
     disabled: boolean;
+    oneWay: boolean;
+    oneWayNormalX?: number;
+    oneWayNormalY?: number;
 }
 /**
  * RigidBody component for defining rigid body physics.
@@ -37,9 +40,10 @@ export interface RigidBodyConfig {
 export declare class RigidBody extends Component {
     private _mass;
     private _inverseMass;
-    /** Type of the rigid body */
-    type: RigidBodyType;
-    /** Mass of the rigid body */
+    /** @internal Pending one-step kinematic movement target */
+    _movementTarget: Vector2 | null;
+    /** Body type that defines how the rigid body participates in simulation */
+    readonly type: RigidBodyType;
     /** Gravity scale of the rigid body */
     gravityScale: number;
     /** Linear damping value used to slow down movement over time */
@@ -50,20 +54,61 @@ export declare class RigidBody extends Component {
     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 contacts should only be resolved from one side */
+    oneWay: boolean;
+    /** Local-space normal that points toward the blocking side */
+    oneWayNormal?: Vector2;
     /**
      * Creates a new RigidBody component.
      * @param config - Configuration for the rigid body
      */
     constructor(config: RigidBodyConfig);
     get mass(): number;
+    /**
+     * Sets the mass used by dynamic bodies.
+     *
+     * Non-positive values make the body immovable by forces and impulses.
+     */
     set mass(value: number);
+    /**
+     * Returns the inverse mass.
+     *
+     * Bodies with zero or negative mass return `0`.
+     */
     get inverseMass(): number;
+    /**
+     * Adds a continuous force to a dynamic body for the next physics step.
+     *
+     * Affects only active dynamic bodies.
+     */
     applyForce(force: Vector2): void;
+    /**
+     * Adds an instantaneous impulse to a dynamic body for the next physics step.
+     *
+     * Affects only active dynamic bodies.
+     */
     applyImpulse(impulse: Vector2): void;
+    /**
+     * Marks the rigid body as awake so it can be simulated.
+     */
     wakeUp(): void;
+    /**
+     * Marks the rigid body as sleeping so dynamic integration can skip it.
+     */
     sleep(): void;
+    /**
+     * Clears all accumulated force and impulse values.
+     */
     clearForces(): void;
-    clone(): RigidBody;
+    /**
+     * Moves a kinematic body to a target position on the next physics step.
+     *
+     * The physics system computes a one-step velocity from the current position
+     * to this target so contacts can react to the kinematic movement.
+     */
+    movePosition(position: Vector2): void;
 }

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

@@ -29,9 +29,10 @@ import { Vector2 } from '../../../engine/math-lib';
 export class RigidBody extends Component {
     _mass;
     _inverseMass;
-    /** Type of the rigid body */
+    /** @internal Pending one-step kinematic movement target */
+    _movementTarget;
+    /** Body type that defines how the rigid body participates in simulation */
     type;
-    /** Mass of the rigid body */
     /** Gravity scale of the rigid body */
     gravityScale;
     /** Linear damping value used to slow down movement over time */
@@ -42,8 +43,14 @@ export class RigidBody extends Component {
     disabled;
     /** Whether rigid body is sleeping */
     sleeping;
+    /** Force applied to the rigid body */
     force;
+    /** Impulse applied to the rigid body */
     impulse;
+    /** Whether contacts should only be resolved from one side */
+    oneWay;
+    /** Local-space normal that points toward the blocking side */
+    oneWayNormal;
     /**
      * Creates a new RigidBody component.
      * @param config - Configuration for the rigid body
@@ -52,58 +59,98 @@ export class RigidBody extends Component {
         super();
         this._mass = 0;
         this._inverseMass = 0;
+        this._movementTarget = null;
         this.type = config.type;
-        this.mass = config.mass;
-        this.gravityScale = config.gravityScale;
-        this.linearDamping = config.linearDamping;
+        this.mass = config.mass ?? 0;
+        this.gravityScale = config.gravityScale ?? 0;
+        this.linearDamping = config.linearDamping ?? 0;
         this.linearVelocity = new Vector2(0, 0);
         this.disabled = config.disabled;
         this.sleeping = false;
         this.force = new Vector2(0, 0);
         this.impulse = new Vector2(0, 0);
+        this.oneWay = config.oneWay ?? false;
+        if (this.oneWay) {
+            this.oneWayNormal = new Vector2(config.oneWayNormalX ?? 0, config.oneWayNormalY ?? 0).normalize();
+            if (this.oneWayNormal.magnitude === 0) {
+                throw new Error('One-way rigid body normal must be non-zero');
+            }
+        }
     }
     get mass() {
         return this._mass;
     }
+    /**
+     * Sets the mass used by dynamic bodies.
+     *
+     * Non-positive values make the body immovable by forces and impulses.
+     */
     set mass(value) {
         this._mass = value;
         this._inverseMass = value > 0 ? 1 / value : 0;
     }
+    /**
+     * Returns the inverse mass.
+     *
+     * Bodies with zero or negative mass return `0`.
+     */
     get inverseMass() {
         return this._inverseMass;
     }
+    /**
+     * Adds a continuous force to a dynamic body for the next physics step.
+     *
+     * Affects only active dynamic bodies.
+     */
     applyForce(force) {
-        if (this.disabled || this.type === 'static') {
+        if (this.disabled || this.type !== 'dynamic') {
             return;
         }
         this.wakeUp();
         this.force.add(force);
     }
+    /**
+     * Adds an instantaneous impulse to a dynamic body for the next physics step.
+     *
+     * Affects only active dynamic bodies.
+     */
     applyImpulse(impulse) {
-        if (this.disabled || this.type === 'static') {
+        if (this.disabled || this.type !== 'dynamic') {
             return;
         }
         this.wakeUp();
         this.impulse.add(impulse);
     }
+    /**
+     * Marks the rigid body as awake so it can be simulated.
+     */
     wakeUp() {
         this.sleeping = false;
     }
+    /**
+     * Marks the rigid body as sleeping so dynamic integration can skip it.
+     */
     sleep() {
         this.sleeping = true;
     }
+    /**
+     * Clears all accumulated force and impulse values.
+     */
     clearForces() {
         this.force.multiplyNumber(0);
         this.impulse.multiplyNumber(0);
     }
-    clone() {
-        return new RigidBody({
-            mass: this.mass,
-            gravityScale: this.gravityScale,
-            linearDamping: this.linearDamping,
-            disabled: this.disabled,
-            type: this.type,
-        });
+    /**
+     * Moves a kinematic body to a target position on the next physics step.
+     *
+     * The physics system computes a one-step velocity from the current position
+     * to this target so contacts can react to the kinematic movement.
+     */
+    movePosition(position) {
+        if (this.disabled || this.type !== 'kinematic') {
+            return;
+        }
+        this._movementTarget = position.clone();
     }
 }
 RigidBody.componentName = 'RigidBody';

package/build/contrib/components/shape/index.d.ts

@@ -1,13 +1,13 @@
 import type { Graphics } from 'pixi.js';
 import { Component } from '../../../engine/component';
+import type { Point } from '../../../engine/math-lib';
 import { type BlendingMode } from '../../types/view';
 interface RenderData {
     view: Graphics;
     graphicsContextKey?: string;
 }
 export type ShapeType = 'rectangle' | 'roundRectangle' | 'circle' | 'ellipse' | 'line';
-export interface BaseShape {
-    type: ShapeType;
+export interface BaseShapeConfig {
     strokeColor?: string;
     strokeWidth: number;
     strokeAlignment: number;
@@ -17,36 +17,60 @@ export interface BaseShape {
     blending: BlendingMode;
     disabled: boolean;
     sortingLayer: string;
-    sortCenter: [number, number];
+    sortOffsetX: number;
+    sortOffsetY: number;
 }
-export interface Rectangle extends BaseShape {
+export interface RectangleShapeConfig extends BaseShapeConfig {
     type: 'rectangle';
-    width: number;
-    height: number;
+    sizeX: number;
+    sizeY: number;
 }
-export interface RoundRectangle extends BaseShape {
+export interface RoundRectangleShapeConfig extends BaseShapeConfig {
     type: 'roundRectangle';
-    width: number;
-    height: number;
+    sizeX: number;
+    sizeY: number;
     radius: number;
 }
-export interface Circle extends BaseShape {
+export interface CircleShapeConfig extends BaseShapeConfig {
     type: 'circle';
     radius: number;
 }
-export interface Ellipse extends BaseShape {
+export interface EllipseShapeConfig extends BaseShapeConfig {
     type: 'ellipse';
     radiusX: number;
     radiusY: number;
 }
-export interface Line extends BaseShape {
+export interface LineShapeConfig extends BaseShapeConfig {
     type: 'line';
     point1X: number;
     point1Y: number;
     point2X: number;
     point2Y: number;
 }
-export type ShapeConfig = BaseShape & Partial<Rectangle | RoundRectangle | Circle | Ellipse | Line>;
+export type ShapeConfig = RectangleShapeConfig | RoundRectangleShapeConfig | CircleShapeConfig | EllipseShapeConfig | LineShapeConfig;
+export interface RectangleShapeGeometry {
+    type: 'rectangle';
+    size: Point;
+}
+export interface RoundRectangleShapeGeometry {
+    type: 'roundRectangle';
+    size: Point;
+    radius: number;
+}
+export interface CircleShapeGeometry {
+    type: 'circle';
+    radius: number;
+}
+export interface EllipseShapeGeometry {
+    type: 'ellipse';
+    radius: Point;
+}
+export interface LineShapeGeometry {
+    type: 'line';
+    point1: Point;
+    point2: Point;
+}
+export type ShapeGeometry = RectangleShapeGeometry | RoundRectangleShapeGeometry | CircleShapeGeometry | EllipseShapeGeometry | LineShapeGeometry;
 /**
  * Shape component for rendering 2D geometry.
  *
@@ -58,8 +82,8 @@ export type ShapeConfig = BaseShape & Partial<Rectangle | RoundRectangle | Circl
  * // Create a basic shape
  * const shape = new Shape({
  *   type: 'rectangle',
- *   width: 100,
- *   height: 100,
+ *   sizeX: 100,
+ *   sizeY: 50,
  *   strokeWidth: 2,
  *   strokeColor: '#000',
  *   strokeAlignment: 0.5,
@@ -68,7 +92,8 @@ export type ShapeConfig = BaseShape & Partial<Rectangle | RoundRectangle | Circl
  *   blending: 'normal',
  *   disabled: false,
  *   sortingLayer: 'units',
- *   sortCenter: [0, 0],
+ *   sortOffsetX: 0,
+ *   sortOffsetY: 0,
  * });
  *
  * // Add to actor
@@ -82,8 +107,8 @@ export type ShapeConfig = BaseShape & Partial<Rectangle | RoundRectangle | Circl
  * @category Components
  */
 export declare class Shape extends Component {
-    /** Type of the shape */
-    type: ShapeType;
+    /** Geometry of the shape */
+    geometry: ShapeGeometry;
     /** Color of the stroke */
     strokeColor?: string;
     /** Width of the stroke */
@@ -108,25 +133,7 @@ export declare class Shape extends Component {
     /** Sorting layer of the shape */
     sortingLayer: string;
     /** Center point of the shape */
-    sortCenter: [number, number];
-    /** Width of the shape */
-    width?: number;
-    /** Height of the shape */
-    height?: number;
-    /** Radius of the shape */
-    radius?: number;
-    /** Radius X of the shape */
-    radiusX?: number;
-    /** Radius Y of the shape */
-    radiusY?: number;
-    /** Start point X coordinate for line shape */
-    point1X?: number;
-    /** Start point Y coordinate for line shape */
-    point1Y?: number;
-    /** End point X coordinate for line shape */
-    point2X?: number;
-    /** End point Y coordinate for line shape */
-    point2Y?: number;
+    sortOffset: Point;
     /** Internal rendering data */
     renderData?: RenderData;
     /**
@@ -135,6 +142,5 @@ export declare class Shape extends Component {
      * @param config - Configuration for the shape
      */
     constructor(config: ShapeConfig);
-    clone(): Shape;
 }
 export {};

package/build/contrib/components/shape/index.js

@@ -10,8 +10,8 @@ import { Component } from '../../../engine/component';
  * // Create a basic shape
  * const shape = new Shape({
  *   type: 'rectangle',
- *   width: 100,
- *   height: 100,
+ *   sizeX: 100,
+ *   sizeY: 50,
  *   strokeWidth: 2,
  *   strokeColor: '#000',
  *   strokeAlignment: 0.5,
@@ -20,7 +20,8 @@ import { Component } from '../../../engine/component';
  *   blending: 'normal',
  *   disabled: false,
  *   sortingLayer: 'units',
- *   sortCenter: [0, 0],
+ *   sortOffsetX: 0,
+ *   sortOffsetY: 0,
  * });
  *
  * // Add to actor
@@ -34,8 +35,8 @@ import { Component } from '../../../engine/component';
  * @category Components
  */
 export class Shape extends Component {
-    /** Type of the shape */
-    type;
+    /** Geometry of the shape */
+    geometry;
     /** Color of the stroke */
     strokeColor;
     /** Width of the stroke */
@@ -60,25 +61,7 @@ export class Shape extends Component {
     /** Sorting layer of the shape */
     sortingLayer;
     /** Center point of the shape */
-    sortCenter;
-    /** Width of the shape */
-    width;
-    /** Height of the shape */
-    height;
-    /** Radius of the shape */
-    radius;
-    /** Radius X of the shape */
-    radiusX;
-    /** Radius Y of the shape */
-    radiusY;
-    /** Start point X coordinate for line shape */
-    point1X;
-    /** Start point Y coordinate for line shape */
-    point1Y;
-    /** End point X coordinate for line shape */
-    point2X;
-    /** End point Y coordinate for line shape */
-    point2Y;
+    sortOffset;
     /** Internal rendering data */
     renderData;
     /**
@@ -88,7 +71,6 @@ export class Shape extends Component {
      */
     constructor(config) {
         super();
-        this.type = config.type;
         this.strokeColor = config.strokeColor;
         this.strokeWidth = config.strokeWidth;
         this.strokeAlignment = config.strokeAlignment;
@@ -98,40 +80,40 @@ export class Shape extends Component {
         this.blending = config.blending;
         this.disabled = config.disabled;
         this.sortingLayer = config.sortingLayer;
-        this.sortCenter = config.sortCenter;
-        this.width = config.width;
-        this.height = config.height;
-        this.radius = config.radius;
-        this.radiusX = config.radiusX;
-        this.radiusY = config.radiusY;
-        this.point1X = config.point1X;
-        this.point1Y = config.point1Y;
-        this.point2X = config.point2X;
-        this.point2Y = config.point2Y;
-    }
-    clone() {
-        return new Shape({
-            type: this.type,
-            strokeColor: this.strokeColor,
-            strokeWidth: this.strokeWidth,
-            strokeAlignment: this.strokeAlignment,
-            pixelLine: this.pixelLine,
-            opacity: this.opacity,
-            blending: this.blending,
-            disabled: this.disabled,
-            sortingLayer: this.sortingLayer,
-            sortCenter: this.sortCenter.slice(0),
-            width: this.width,
-            height: this.height,
-            radius: this.radius,
-            radiusX: this.radiusX,
-            radiusY: this.radiusY,
-            point1X: this.point1X,
-            point1Y: this.point1Y,
-            point2X: this.point2X,
-            point2Y: this.point2Y,
-            fill: this.fill,
-        });
+        this.sortOffset = { x: config.sortOffsetX, y: config.sortOffsetY };
+        switch (config.type) {
+            case 'rectangle':
+                this.geometry = {
+                    type: config.type,
+                    size: { x: config.sizeX, y: config.sizeY },
+                };
+                break;
+            case 'roundRectangle':
+                this.geometry = {
+                    type: config.type,
+                    size: { x: config.sizeX, y: config.sizeY },
+                    radius: config.radius,
+                };
+                break;
+            case 'circle':
+                this.geometry = {
+                    type: config.type,
+                    radius: config.radius,
+                };
+                break;
+            case 'ellipse':
+                this.geometry = {
+                    type: config.type,
+                    radius: { x: config.radiusX, y: config.radiusY },
+                };
+                break;
+            case 'line':
+                this.geometry = {
+                    type: config.type,
+                    point1: { x: config.point1X, y: config.point1Y },
+                    point2: { x: config.point2X, y: config.point2Y },
+                };
+        }
     }
 }
 Shape.componentName = 'Shape';

package/build/contrib/components/sprite/index.d.ts

@@ -1,5 +1,6 @@
 import type { Sprite as PixiSprite, TilingSprite } from 'pixi.js';
 import { Component } from '../../../engine/component';
+import type { Point } from '../../../engine/math-lib';
 import { type BlendingMode } from '../../types/view';
 interface RenderData {
     view: PixiSprite | TilingSprite;
@@ -16,7 +17,8 @@ export interface SpriteConfig {
     flipX: boolean;
     flipY: boolean;
     sortingLayer: string;
-    sortCenter: [number, number];
+    sortOffsetX: number;
+    sortOffsetY: number;
     fit: FitType;
     color: string;
     blending: BlendingMode;
@@ -40,7 +42,8 @@ export interface SpriteConfig {
  *   flipX: false,
  *   flipY: false,
  *   sortingLayer: 'units',
- *   sortCenter: [0, 0],
+ *   sortOffsetX: 0,
+ *   sortOffsetY: 0,
  *   fit: 'stretch',
  *   color: '#ffffff',
  *   blending: 'normal',
@@ -76,7 +79,7 @@ export declare class Sprite extends Component {
     /** Sorting layer name for rendering order */
     sortingLayer: string;
     /** Center point for sorting calculations */
-    sortCenter: [number, number];
+    sortOffset: Point;
     /** Current frame to render */
     currentFrame?: number;
     /** How the texture should fit within the sprite bounds */
@@ -95,5 +98,4 @@ export declare class Sprite extends Component {
      * @param config - Configuration for the sprite
      */
     constructor(config: SpriteConfig);
-    clone(): Sprite;
 }

package/build/contrib/components/sprite/index.js

@@ -16,7 +16,8 @@ import { Component } from '../../../engine/component';
  *   flipX: false,
  *   flipY: false,
  *   sortingLayer: 'units',
- *   sortCenter: [0, 0],
+ *   sortOffsetX: 0,
+ *   sortOffsetY: 0,
  *   fit: 'stretch',
  *   color: '#ffffff',
  *   blending: 'normal',
@@ -52,7 +53,7 @@ export class Sprite extends Component {
     /** Sorting layer name for rendering order */
     sortingLayer;
     /** Center point for sorting calculations */
-    sortCenter;
+    sortOffset;
     /** Current frame to render */
     currentFrame;
     /** How the texture should fit within the sprite bounds */
@@ -81,28 +82,11 @@ export class Sprite extends Component {
         this.flipY = config.flipY;
         this.disabled = config.disabled;
         this.sortingLayer = config.sortingLayer;
-        this.sortCenter = config.sortCenter;
+        this.sortOffset = { x: config.sortOffsetX, y: config.sortOffsetY };
         this.fit = config.fit;
         this.color = config.color ?? '#ffffff';
         this.blending = config.blending ?? 'normal';
         this.opacity = config.opacity ?? 1;
     }
-    clone() {
-        return new Sprite({
-            src: this.src,
-            width: this.width,
-            height: this.height,
-            slice: this.slice,
-            flipX: this.flipX,
-            flipY: this.flipY,
-            disabled: this.disabled,
-            sortingLayer: this.sortingLayer,
-            sortCenter: this.sortCenter.slice(0),
-            fit: this.fit,
-            color: this.color,
-            blending: this.blending,
-            opacity: this.opacity,
-        });
-    }
 }
 Sprite.componentName = 'Sprite';

package/build/contrib/components/transform/index.d.ts

@@ -95,5 +95,4 @@ export declare class Transform extends Component {
      * Useful for converting world-space coordinates to local space.
      */
     get invertedWorldMatrix(): Matrix;
-    clone(): Transform;
 }