dacha 0.15.2 → 0.16.0

package/build/contrib/components/animatable/comparator-condition-component-value.d.ts

@@ -1,5 +1,5 @@
 export declare class ComparatorConditionComponentValue {
     type: string;
-    value: string | Array<string>;
+    value: string | string[];
     constructor(config: unknown);
 }

package/build/contrib/components/animatable/group-state.d.ts

@@ -4,7 +4,7 @@ import { OneDimensionalProps } from './one-dimensional-props';
 import { TwoDimensionalProps } from './two-dimensional-props';
 import type { GroupStateConfig } from './types';
 export declare class GroupState extends State {
-    substates: Array<Substate>;
+    substates: Substate[];
     pickMode: '1D' | '2D';
     pickProps: OneDimensionalProps | TwoDimensionalProps;
     constructor(config: GroupStateConfig);

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

@@ -4,7 +4,7 @@ import { GroupState } from './group-state';
 import type { AnimatableConfig } from './types';
 export type { AnimatableConfig };
 export declare class Animatable extends Component {
-    states: Array<IndividualState | GroupState>;
+    states: (IndividualState | GroupState)[];
     initialState: string;
     currentState?: IndividualState | GroupState;
     duration: number;

package/build/contrib/components/animatable/one-dimensional-props.d.ts

@@ -1,4 +1,4 @@
 export declare class OneDimensionalProps {
-    x: string | Array<string>;
+    x: string | string[];
     constructor(config: unknown);
 }

package/build/contrib/components/animatable/one-dimensional-props.js

@@ -3,8 +3,6 @@ export class OneDimensionalProps {
     x;
     constructor(config) {
         const { x = '' } = config;
-        this.x = Array.isArray(x)
-            ? x.slice(0)
-            : x.split(SEPARATOR);
+        this.x = Array.isArray(x) ? x.slice(0) : x.split(SEPARATOR);
     }
 }

package/build/contrib/components/animatable/state.d.ts

@@ -5,6 +5,6 @@ export declare class State {
     name: string;
     speed: number;
     type: 'individual' | 'group';
-    transitions: Array<Transition>;
+    transitions: Transition[];
     constructor(config: StateConfig);
 }

package/build/contrib/components/animatable/timeline.d.ts

@@ -1,11 +1,11 @@
 import type { TimelineConfig } from './types';
 export interface FrameField {
-    path: Array<string>;
+    path: string[];
     value: string | number | boolean;
 }
 export type Frame = Record<string, FrameField>;
 export declare class Timeline {
-    frames: Array<Frame>;
+    frames: Frame[];
     looped: boolean;
     constructor(config: TimelineConfig);
 }

package/build/contrib/components/animatable/transition.d.ts

@@ -4,6 +4,6 @@ export declare class Transition {
     id: string;
     state: string;
     time: number;
-    conditions: Array<Condition>;
+    conditions: Condition[];
     constructor(config: TransitionConfig);
 }

package/build/contrib/components/animatable/two-dimensional-props.d.ts

@@ -1,5 +1,5 @@
 import { OneDimensionalProps } from './one-dimensional-props';
 export declare class TwoDimensionalProps extends OneDimensionalProps {
-    y: string | Array<string>;
+    y: string | string[];
     constructor(config: unknown);
 }

package/build/contrib/components/animatable/two-dimensional-props.js

@@ -5,8 +5,6 @@ export class TwoDimensionalProps extends OneDimensionalProps {
     constructor(config) {
         super(config);
         const { y = '' } = config;
-        this.y = Array.isArray(y)
-            ? y.slice(0)
-            : y.split(SEPARATOR);
+        this.y = Array.isArray(y) ? y.slice(0) : y.split(SEPARATOR);
     }
 }

package/build/contrib/components/animatable/types.d.ts

@@ -6,15 +6,15 @@ export interface FrameFieldConfig {
 }
 export interface FrameConfig {
     id: string;
-    fields: Array<FrameFieldConfig>;
+    fields: FrameFieldConfig[];
 }
 export interface TimelineConfig {
-    frames: Array<FrameConfig>;
+    frames: FrameConfig[];
     looped: boolean;
 }
 export interface ComparatorConditionComponentValueConfig {
     type: string;
-    value: string | Array<string>;
+    value: string | string[];
 }
 export interface ComparatorConditionSimpleValueConfig {
     type: string;
@@ -42,14 +42,14 @@ export interface TransitionConfig {
     id: string;
     state: string;
     time: number;
-    conditions: Array<ConditionConfig>;
+    conditions: ConditionConfig[];
 }
 export interface StateConfig {
     id: string;
     name: string;
     speed: number;
     type: 'individual' | 'group';
-    transitions: Array<TransitionConfig>;
+    transitions: TransitionConfig[];
 }
 export interface IndividualStateConfig extends StateConfig {
     timeline: TimelineConfig;
@@ -62,17 +62,17 @@ export interface SubstateConfig {
     y: number;
 }
 export interface OneDimensionalPropsConfig {
-    x: string | Array<string>;
+    x: string | string[];
 }
 export interface TwoDimensionalPropsConfig extends OneDimensionalPropsConfig {
-    y: string | Array<string>;
+    y: string | string[];
 }
 export interface GroupStateConfig extends StateConfig {
-    substates: Array<SubstateConfig>;
+    substates: SubstateConfig[];
     pickMode: '1D' | '2D';
     pickProps: OneDimensionalPropsConfig | TwoDimensionalPropsConfig;
 }
 export interface AnimatableConfig extends Record<string, unknown> {
-    states: Array<unknown>;
+    states: unknown[];
     initialState: string;
 }

package/build/contrib/components/bitmap-text/index.d.ts

@@ -0,0 +1,36 @@
+import type { BitmapText as PixiBitmapText } from 'pixi.js';
+import { Component } from '../../../engine/component';
+import { type BlendingMode } from '../../types/view';
+interface RenderData {
+    view: PixiBitmapText;
+    graphicsContextKey?: string;
+}
+type TextAlign = 'left' | 'center' | 'right';
+export interface BitmapTextConfig {
+    text: string;
+    font: string;
+    fontSize: number;
+    align: TextAlign;
+    color: string;
+    opacity: number;
+    blending: BlendingMode;
+    disabled: boolean;
+    sortingLayer: string;
+    sortCenter: [number, number];
+}
+export declare class BitmapText extends Component {
+    text: string;
+    font: string;
+    fontSize: number;
+    align: TextAlign;
+    color: string;
+    opacity: number;
+    blending: BlendingMode;
+    disabled: boolean;
+    sortingLayer: string;
+    sortCenter: [number, number];
+    renderData?: RenderData;
+    constructor(config: BitmapTextConfig);
+    clone(): BitmapText;
+}
+export {};

package/build/contrib/components/bitmap-text/index.js

@@ -0,0 +1,42 @@
+import { Component } from '../../../engine/component';
+export class BitmapText extends Component {
+    text;
+    font;
+    fontSize;
+    align;
+    color;
+    opacity;
+    blending;
+    disabled;
+    sortingLayer;
+    sortCenter;
+    renderData;
+    constructor(config) {
+        super();
+        this.text = config.text;
+        this.font = config.font;
+        this.fontSize = config.fontSize;
+        this.align = config.align;
+        this.color = config.color;
+        this.opacity = config.opacity;
+        this.blending = config.blending;
+        this.disabled = config.disabled;
+        this.sortingLayer = config.sortingLayer;
+        this.sortCenter = config.sortCenter;
+    }
+    clone() {
+        return new BitmapText({
+            text: this.text,
+            font: this.font,
+            fontSize: this.fontSize,
+            align: this.align,
+            color: this.color,
+            opacity: this.opacity,
+            blending: this.blending,
+            disabled: this.disabled,
+            sortingLayer: this.sortingLayer,
+            sortCenter: this.sortCenter.slice(0),
+        });
+    }
+}
+BitmapText.componentName = 'BitmapText';

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

@@ -16,7 +16,8 @@ export { MouseControl } from './mouse-control';
 export type { MouseControlConfig } from './mouse-control';
 export { Behaviors } from './behaviors';
 export type { BehaviorsConfig } from './behaviors';
-export { Light } from './light';
-export type { LightConfig } from './light';
 export { AudioSource } from './audio-source';
 export type { AudioSourceConfig } from './audio-source';
+export { Shape, type ShapeConfig } from './shape';
+export { PixiView } from './pixi-view';
+export { BitmapText, type BitmapTextConfig } from './bitmap-text';

package/build/contrib/components/index.js

@@ -7,5 +7,7 @@ export { Sprite } from './sprite';
 export { Transform } from './transform';
 export { MouseControl } from './mouse-control';
 export { Behaviors } from './behaviors';
-export { Light } from './light';
 export { AudioSource } from './audio-source';
+export { Shape } from './shape';
+export { PixiView } from './pixi-view';
+export { BitmapText } from './bitmap-text';

package/build/contrib/components/keyboard-control/index.d.ts

@@ -5,21 +5,19 @@ export interface KeyboardEventBind {
     attrs: InputEventAttributes;
     keepEmit: boolean;
 }
-export interface InputEventBindings {
-    [key: string]: {
-        pressed?: KeyboardEventBind;
-        released?: KeyboardEventBind;
-    };
-}
+export type InputEventBindings = Record<string, {
+    pressed?: KeyboardEventBind;
+    released?: KeyboardEventBind;
+}>;
 export interface KeyboardEventBindConfig {
     key: string;
     pressed: boolean;
     keepEmit?: boolean;
     eventType: string;
-    attrs: Array<InputEventAttributeConfig>;
+    attrs: InputEventAttributeConfig[];
 }
 export interface KeyboardControlConfig extends Record<string, unknown> {
-    inputEventBindings: Array<KeyboardEventBindConfig>;
+    inputEventBindings: KeyboardEventBindConfig[];
 }
 export declare class KeyboardControl extends Component {
     inputEventBindings: InputEventBindings;

package/build/contrib/components/keyboard-control/index.js

@@ -27,7 +27,10 @@ export class KeyboardControl extends Component {
                         eventType: pressed.eventType,
                         pressed: true,
                         keepEmit: pressed.keepEmit,
-                        attrs: Object.keys(pressed.attrs).map((name) => ({ name, value: pressed.attrs[name] })),
+                        attrs: Object.keys(pressed.attrs).map((name) => ({
+                            name,
+                            value: pressed.attrs[name],
+                        })),
                     });
                 }
                 if (released !== undefined) {
@@ -35,7 +38,10 @@ export class KeyboardControl extends Component {
                         key: inputEvent,
                         eventType: released.eventType,
                         pressed: false,
-                        attrs: Object.keys(released.attrs).map((name) => ({ name, value: released.attrs[name] })),
+                        attrs: Object.keys(released.attrs).map((name) => ({
+                            name,
+                            value: released.attrs[name],
+                        })),
                     });
                 }
                 return acc;

package/build/contrib/components/mouse-control/index.d.ts

@@ -4,19 +4,15 @@ export interface MouseEventBind {
     eventType: string;
     attrs: InputEventAttributes;
 }
-export interface InputEventBindings {
-    [key: string]: {
-        [button: string]: MouseEventBind;
-    };
-}
+export type InputEventBindings = Record<string, Record<string, MouseEventBind>>;
 export interface MouseEventBindConfig {
     event: string;
     button?: number;
     eventType: string;
-    attrs: Array<InputEventAttributeConfig>;
+    attrs: InputEventAttributeConfig[];
 }
 export interface MouseControlConfig {
-    inputEventBindings: Array<MouseEventBindConfig>;
+    inputEventBindings: MouseEventBindConfig[];
 }
 export declare class MouseControl extends Component {
     inputEventBindings: InputEventBindings;

package/build/contrib/components/mouse-control/index.js

@@ -35,7 +35,10 @@ export class MouseControl extends Component {
                         event: inputEvent,
                         button: Number(button),
                         eventType: buttonBinds[button].eventType,
-                        attrs: Object.keys(buttonBinds[button].attrs).map((name) => ({ name, value: buttonBinds[button].attrs[name] })),
+                        attrs: Object.keys(buttonBinds[button].attrs).map((name) => ({
+                            name,
+                            value: buttonBinds[button].attrs[name],
+                        })),
                     });
                 });
                 return acc;

package/build/contrib/components/pixi-view/index.d.ts

@@ -0,0 +1,20 @@
+import type { ViewContainer } from 'pixi.js';
+import { Component } from '../../../engine/component';
+interface RenderData {
+    view: ViewContainer;
+}
+export interface PixiViewConfig {
+    createView: () => ViewContainer;
+    sortingLayer: string;
+    sortCenter: [number, number];
+}
+export declare class PixiView extends Component {
+    createView: () => ViewContainer;
+    sortingLayer: string;
+    sortCenter: [number, number];
+    renderData?: RenderData;
+    constructor(config: PixiViewConfig);
+    get view(): ViewContainer | undefined;
+    clone(): PixiView;
+}
+export {};

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

@@ -0,0 +1,24 @@
+import { Component } from '../../../engine/component';
+export class PixiView extends Component {
+    createView;
+    sortingLayer;
+    sortCenter;
+    renderData;
+    constructor(config) {
+        super();
+        this.createView = config.createView;
+        this.sortingLayer = config.sortingLayer;
+        this.sortCenter = config.sortCenter;
+    }
+    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/shape/index.d.ts

@@ -0,0 +1,64 @@
+import type { Graphics } from 'pixi.js';
+import { Component } from '../../../engine/component';
+import { type BlendingMode } from '../../types/view';
+interface RenderData {
+    view: Graphics;
+    graphicsContextKey?: string;
+}
+export type ShapeType = 'rectangle' | 'roundRectangle' | 'circle' | 'ellipse';
+export interface BaseShape {
+    type: ShapeType;
+    strokeColor?: string;
+    strokeWidth: number;
+    strokeAlignment: number;
+    pixelLine: boolean;
+    fill?: string;
+    opacity: number;
+    blending: BlendingMode;
+    disabled: boolean;
+    sortingLayer: string;
+    sortCenter: [number, number];
+}
+export interface Rectangle extends BaseShape {
+    type: 'rectangle';
+    width: number;
+    height: number;
+}
+export interface RoundRectangle extends BaseShape {
+    type: 'roundRectangle';
+    width: number;
+    height: number;
+    radius: number;
+}
+export interface Circle extends BaseShape {
+    type: 'circle';
+    radius: number;
+}
+export interface Ellipse extends BaseShape {
+    type: 'ellipse';
+    radiusX: number;
+    radiusY: number;
+}
+export type ShapeConfig = BaseShape & Partial<Rectangle | RoundRectangle | Circle | Ellipse>;
+export declare class Shape extends Component {
+    type: ShapeType;
+    strokeColor?: string;
+    strokeWidth: number;
+    strokeAlignment: number;
+    pixelLine: boolean;
+    fill?: string;
+    opacity: number;
+    blending: BlendingMode;
+    disabled: boolean;
+    sortingLayer: string;
+    sortCenter: [number, number];
+    width?: number;
+    height?: number;
+    radius?: number;
+    radiusX?: number;
+    radiusY?: number;
+    renderData?: RenderData;
+    constructor(config: ShapeConfig);
+    clone(): Shape;
+}
+export {};

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

@@ -0,0 +1,60 @@
+import { Component } from '../../../engine/component';
+export class Shape extends Component {
+    type;
+    strokeColor;
+    strokeWidth;
+    strokeAlignment;
+    pixelLine;
+    fill;
+    opacity;
+    blending;
+    disabled;
+    sortingLayer;
+    sortCenter;
+    width;
+    height;
+    radius;
+    radiusX;
+    radiusY;
+    renderData;
+    constructor(config) {
+        super();
+        this.type = config.type;
+        this.strokeColor = config.strokeColor;
+        this.strokeWidth = config.strokeWidth;
+        this.strokeAlignment = config.strokeAlignment;
+        this.pixelLine = config.pixelLine;
+        this.fill = config.fill;
+        this.opacity = config.opacity;
+        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;
+    }
+    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,
+            fill: this.fill,
+        });
+    }
+}
+Shape.componentName = 'Shape';

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

@@ -1,7 +1,13 @@
+import type { Sprite as PixiSprite, TilingSprite } from 'pixi.js';
 import { Component } from '../../../engine/component';
-import { Material, MaterialConfig } from './material';
+import { type BlendingMode } from '../../types/view';
+interface RenderData {
+    view: PixiSprite | TilingSprite;
+    textureSourceKey?: string;
+    textureArrayKey?: string;
+}
 type FitType = 'stretch' | 'repeat';
-export type { MaterialType, BasicMaterialOptions, BlendingMode } from './material';
+export { type BlendingMode } from '../../types/view';
 export interface SpriteConfig {
     src: string;
     width: number;
@@ -10,11 +16,13 @@ export interface SpriteConfig {
     rotation: number;
     flipX: boolean;
     flipY: boolean;
-    disabled: boolean;
     sortingLayer: string;
     sortCenter: [number, number];
     fit: FitType;
-    material: MaterialConfig;
+    color: string;
+    blending: BlendingMode;
+    opacity: number;
+    disabled: boolean;
 }
 export declare class Sprite extends Component {
     src: string;
@@ -28,8 +36,11 @@ export declare class Sprite extends Component {
     sortingLayer: string;
     sortCenter: [number, number];
     currentFrame?: number;
-    fit: FitType;
-    material: Material;
+    readonly fit: FitType;
+    color: string;
+    blending: BlendingMode;
+    opacity: number;
+    renderData?: RenderData;
     constructor(config: SpriteConfig);
     clone(): Sprite;
 }

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

@@ -1,5 +1,4 @@
 import { Component } from '../../../engine/component';
-import { Material } from './material';
 export class Sprite extends Component {
     src;
     width;
@@ -13,7 +12,10 @@ export class Sprite extends Component {
     sortCenter;
     currentFrame;
     fit;
-    material;
+    color;
+    blending;
+    opacity;
+    renderData;
     constructor(config) {
         super();
         this.src = config.src;
@@ -28,7 +30,9 @@ export class Sprite extends Component {
         this.sortingLayer = config.sortingLayer;
         this.sortCenter = config.sortCenter;
         this.fit = config.fit;
-        this.material = new Material(config.material);
+        this.color = config.color ?? '#ffffff';
+        this.blending = config.blending ?? 'normal';
+        this.opacity = config.opacity ?? 1;
     }
     clone() {
         return new Sprite({
@@ -43,7 +47,9 @@ export class Sprite extends Component {
             sortingLayer: this.sortingLayer,
             sortCenter: this.sortCenter.slice(0),
             fit: this.fit,
-            material: this.material,
+            color: this.color,
+            blending: this.blending,
+            opacity: this.opacity,
         });
     }
 }

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

@@ -1,7 +1,7 @@
 import { SceneSystem } from '../../../engine/system';
 import type { UpdateOptions, SceneSystemOptions } from '../../../engine/system';
 export declare class Animator extends SceneSystem {
-    private actorCollection;
+    private actorQuery;
     private substatePickers;
     private actorConditions;
     constructor(options: SceneSystemOptions);

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

@@ -1,5 +1,5 @@
 import { SceneSystem } from '../../../engine/system';
-import { ActorCollection } from '../../../engine/actor';
+import { ActorQuery } from '../../../engine/actor';
 import { Animatable } from '../../components/animatable';
 import { RemoveActor } from '../../../engine/events';
 import { conditionControllers } from './condition-controllers';
@@ -7,25 +7,25 @@ import { substatePickers } from './substate-pickers';
 import { setValue } from './utils';
 const FRAME_RATE = 100;
 export class Animator extends SceneSystem {
-    actorCollection;
+    actorQuery;
     substatePickers;
     actorConditions;
     constructor(options) {
         super();
-        this.actorCollection = new ActorCollection(options.scene, {
-            components: [Animatable],
+        this.actorQuery = new ActorQuery({
+            scene: options.scene,
+            filter: [Animatable],
         });
-        this.substatePickers = Object.keys(substatePickers)
-            .reduce((storage, key) => {
+        this.substatePickers = Object.keys(substatePickers).reduce((storage, key) => {
             const SubstatePicker = substatePickers[key];
             storage[key] = new SubstatePicker();
             return storage;
         }, {});
         this.actorConditions = {};
-        this.actorCollection.addEventListener(RemoveActor, this.handleActorRemove);
+        this.actorQuery.addEventListener(RemoveActor, this.handleActorRemove);
     }
     onSceneDestroy() {
-        this.actorCollection.removeEventListener(RemoveActor, this.handleActorRemove);
+        this.actorQuery.removeEventListener(RemoveActor, this.handleActorRemove);
         Object.values(this.actorConditions).forEach((transitions) => {
             Object.values(transitions).forEach((conditions) => {
                 Object.values(conditions).forEach((controller) => {
@@ -58,7 +58,7 @@ export class Animator extends SceneSystem {
     }
     update(options) {
         const { deltaTime } = options;
-        this.actorCollection.forEach((actor) => {
+        this.actorQuery.getActors().forEach((actor) => {
             const animatable = actor.getComponent(Animatable);
             if (animatable.currentState === void 0) {
                 return;