dacha 0.13.0

package/build/contrib/components/collider-container/index.js

@@ -0,0 +1,28 @@
+import { Component } from '../../../engine/component';
+import { BoxCollider } from './box-collider';
+import { CircleCollider } from './circle-collider';
+const COLLIDER_MAP = {
+    boxCollider: BoxCollider,
+    circleCollider: CircleCollider,
+};
+export class ColliderContainer extends Component {
+    type;
+    collider;
+    constructor(config) {
+        super();
+        const colliderContainerConfig = config;
+        this.type = colliderContainerConfig.type;
+        if (!COLLIDER_MAP[this.type]) {
+            throw new Error(`Not found collider with same type: ${this.type}`);
+        }
+        const Collider = COLLIDER_MAP[this.type];
+        this.collider = new Collider(colliderContainerConfig.collider);
+    }
+    clone() {
+        return new ColliderContainer({
+            type: this.type,
+            collider: this.collider,
+        });
+    }
+}
+ColliderContainer.componentName = 'ColliderContainer';

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

@@ -0,0 +1,20 @@
+export { Camera } from './camera';
+export type { CameraConfig } from './camera';
+export { KeyboardControl } from './keyboard-control';
+export type { KeyboardControlConfig } from './keyboard-control';
+export { ColliderContainer } from './collider-container';
+export type { ColliderContainerConfig } from './collider-container';
+export { RigidBody } from './rigid-body';
+export type { RigidBodyConfig } from './rigid-body';
+export { Animatable } from './animatable';
+export type { AnimatableConfig } from './animatable';
+export { Sprite } from './sprite';
+export type { SpriteConfig } from './sprite';
+export { Transform } from './transform';
+export type { TransformConfig } from './transform';
+export { MouseControl } from './mouse-control';
+export type { MouseControlConfig } from './mouse-control';
+export { ScriptBundle } from './script-bundle';
+export type { ScriptBundleConfig } from './script-bundle';
+export { Light } from './light';
+export type { LightConfig } from './light';

package/build/contrib/components/index.js

@@ -0,0 +1,10 @@
+export { Camera } from './camera';
+export { KeyboardControl } from './keyboard-control';
+export { ColliderContainer } from './collider-container';
+export { RigidBody } from './rigid-body';
+export { Animatable } from './animatable';
+export { Sprite } from './sprite';
+export { Transform } from './transform';
+export { MouseControl } from './mouse-control';
+export { ScriptBundle } from './script-bundle';
+export { Light } from './light';

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

@@ -0,0 +1,28 @@
+import { Component } from '../../../engine/component';
+import type { InputEventAttributes, InputEventAttributeConfig } from '../../types';
+export interface KeyboardEventBind {
+    eventType: string;
+    attrs: InputEventAttributes;
+    keepEmit: boolean;
+}
+export interface InputEventBindings {
+    [key: string]: {
+        pressed?: KeyboardEventBind;
+        released?: KeyboardEventBind;
+    };
+}
+export interface KeyboardEventBindConfig {
+    key: string;
+    pressed: boolean;
+    keepEmit?: boolean;
+    eventType: string;
+    attrs: Array<InputEventAttributeConfig>;
+}
+export interface KeyboardControlConfig extends Record<string, unknown> {
+    inputEventBindings: Array<KeyboardEventBindConfig>;
+}
+export declare class KeyboardControl extends Component {
+    inputEventBindings: InputEventBindings;
+    constructor(config: KeyboardControlConfig);
+    clone(): KeyboardControl;
+}

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

@@ -0,0 +1,46 @@
+import { Component } from '../../../engine/component';
+export class KeyboardControl extends Component {
+    inputEventBindings;
+    constructor(config) {
+        super();
+        const { inputEventBindings } = config;
+        this.inputEventBindings = inputEventBindings.reduce((acc, bind) => {
+            acc[bind.key] ??= {};
+            acc[bind.key][bind.pressed ? 'pressed' : 'released'] = {
+                eventType: bind.eventType,
+                keepEmit: !!bind.keepEmit,
+                attrs: bind.attrs.reduce((attrs, attr) => {
+                    attrs[attr.name] = attr.value;
+                    return attrs;
+                }, {}),
+            };
+            return acc;
+        }, {});
+    }
+    clone() {
+        return new KeyboardControl({
+            inputEventBindings: Object.keys(this.inputEventBindings).reduce((acc, inputEvent) => {
+                const { pressed, released } = this.inputEventBindings[inputEvent];
+                if (pressed !== undefined) {
+                    acc.push({
+                        key: inputEvent,
+                        eventType: pressed.eventType,
+                        pressed: true,
+                        keepEmit: pressed.keepEmit,
+                        attrs: Object.keys(pressed.attrs).map((name) => ({ name, value: pressed.attrs[name] })),
+                    });
+                }
+                if (released !== undefined) {
+                    acc.push({
+                        key: inputEvent,
+                        eventType: released.eventType,
+                        pressed: false,
+                        attrs: Object.keys(released.attrs).map((name) => ({ name, value: released.attrs[name] })),
+                    });
+                }
+                return acc;
+            }, []),
+        });
+    }
+}
+KeyboardControl.componentName = 'KeyboardControl';

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

@@ -0,0 +1,20 @@
+import { Component } from '../../../engine/component';
+export interface BaseLightOptions {
+    color: string;
+    intensity: number;
+}
+export interface PointLightOptions extends BaseLightOptions {
+    distance: number;
+}
+export type LightType = 'ambient' | 'point';
+export type LightOptions = BaseLightOptions | PointLightOptions;
+export interface LightConfig {
+    type: LightType;
+    options: BaseLightOptions | PointLightOptions;
+}
+export declare class Light extends Component {
+    type: LightType;
+    options: BaseLightOptions | PointLightOptions;
+    constructor(config: LightConfig);
+    clone(): Light;
+}

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

@@ -0,0 +1,18 @@
+import { Component } from '../../../engine/component';
+export class Light extends Component {
+    type;
+    options;
+    constructor(config) {
+        super();
+        const lightConfig = config;
+        this.type = lightConfig.type;
+        this.options = { ...lightConfig.options };
+    }
+    clone() {
+        return new Light({
+            type: this.type,
+            options: this.options,
+        });
+    }
+}
+Light.componentName = 'Light';

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

@@ -0,0 +1,25 @@
+import { Component } from '../../../engine/component';
+import type { InputEventAttributes, InputEventAttributeConfig } from '../../types';
+export interface MouseEventBind {
+    eventType: string;
+    attrs: InputEventAttributes;
+}
+export interface InputEventBindings {
+    [key: string]: {
+        [button: string]: MouseEventBind;
+    };
+}
+export interface MouseEventBindConfig {
+    event: string;
+    button?: number;
+    eventType: string;
+    attrs: Array<InputEventAttributeConfig>;
+}
+export interface MouseControlConfig {
+    inputEventBindings: Array<MouseEventBindConfig>;
+}
+export declare class MouseControl extends Component {
+    inputEventBindings: InputEventBindings;
+    constructor(config: MouseControlConfig);
+    clone(): MouseControl;
+}

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

@@ -0,0 +1,46 @@
+import { Component } from '../../../engine/component';
+const MOUSE_BUTTONS_MAP = {
+    mousedown: 0,
+    mouseup: 0,
+    mousemove: 0,
+    click: 0,
+    contextmenu: 2,
+    dblclick: 0,
+    mouseenter: 0,
+    mouseleave: 0,
+};
+export class MouseControl extends Component {
+    inputEventBindings;
+    constructor(config) {
+        super();
+        const { inputEventBindings } = config;
+        this.inputEventBindings = inputEventBindings.reduce((acc, bind) => {
+            acc[bind.event] ??= {};
+            acc[bind.event][bind.button ?? MOUSE_BUTTONS_MAP[bind.event]] = {
+                eventType: bind.eventType,
+                attrs: bind.attrs.reduce((attrs, attr) => {
+                    attrs[attr.name] = attr.value;
+                    return attrs;
+                }, {}),
+            };
+            return acc;
+        }, {});
+    }
+    clone() {
+        return new MouseControl({
+            inputEventBindings: Object.keys(this.inputEventBindings).reduce((acc, inputEvent) => {
+                const buttonBinds = this.inputEventBindings[inputEvent];
+                Object.keys(buttonBinds).forEach((button) => {
+                    acc.push({
+                        event: inputEvent,
+                        button: Number(button),
+                        eventType: buttonBinds[button].eventType,
+                        attrs: Object.keys(buttonBinds[button].attrs).map((name) => ({ name, value: buttonBinds[button].attrs[name] })),
+                    });
+                });
+                return acc;
+            }, []),
+        });
+    }
+}
+MouseControl.componentName = 'MouseControl';

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

@@ -0,0 +1,44 @@
+import { Component } from '../../../engine/component';
+import { Material, MaterialConfig } from './material';
+type RenderableType = 'sprite' | 'static';
+type FitType = 'stretch' | 'repeat';
+export type { MaterialType, BasicMaterialOptions, BlendingMode } from './material';
+export interface RenderableConfig {
+    src: string;
+    width: number;
+    height: number;
+    type: RenderableType;
+    slice?: number;
+    spacing: number;
+    extruding: number;
+    rotation: number;
+    flipX: boolean;
+    flipY: boolean;
+    disabled: boolean;
+    sortingLayer: string;
+    sortCenter: [number, number];
+    fit: FitType;
+    material: MaterialConfig;
+}
+export declare class Renderable extends Component {
+    private _slice?;
+    src: string;
+    width: number;
+    height: number;
+    type: RenderableType;
+    spacing: number;
+    extruding: number;
+    rotation: number;
+    flipX: boolean;
+    flipY: boolean;
+    disabled: boolean;
+    sortingLayer: string;
+    sortCenter: [number, number];
+    currentFrame?: number;
+    fit: FitType;
+    material: Material;
+    constructor(config: RenderableConfig);
+    get slice(): number;
+    set slice(value: number);
+    clone(): Renderable;
+}

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

@@ -0,0 +1,65 @@
+import { Component } from '../../../engine/component';
+import { Material } from './material';
+export class Renderable extends Component {
+    _slice;
+    src;
+    width;
+    height;
+    type;
+    spacing;
+    extruding;
+    rotation;
+    flipX;
+    flipY;
+    disabled;
+    sortingLayer;
+    sortCenter;
+    currentFrame;
+    fit;
+    material;
+    constructor(config) {
+        super();
+        this.src = config.src;
+        this.width = config.width;
+        this.height = config.height;
+        this.type = config.type;
+        this._slice = config.slice;
+        this.spacing = config.spacing || 0;
+        this.extruding = config.extruding || 0;
+        this.currentFrame = config.type === 'sprite' ? 0 : void 0;
+        this.rotation = config.rotation;
+        this.flipX = config.flipX;
+        this.flipY = config.flipY;
+        this.disabled = config.disabled;
+        this.sortingLayer = config.sortingLayer;
+        this.sortCenter = config.sortCenter;
+        this.fit = config.fit;
+        this.material = new Material(config.material);
+    }
+    get slice() {
+        return this.type === 'sprite' ? (this._slice || 0) : 1;
+    }
+    set slice(value) {
+        this._slice = value;
+    }
+    clone() {
+        return new Renderable({
+            src: this.src,
+            width: this.width,
+            height: this.height,
+            type: this.type,
+            slice: this.slice,
+            spacing: this.spacing,
+            extruding: this.extruding,
+            rotation: this.rotation,
+            flipX: this.flipX,
+            flipY: this.flipY,
+            disabled: this.disabled,
+            sortingLayer: this.sortingLayer,
+            sortCenter: this.sortCenter.slice(0),
+            fit: this.fit,
+            material: this.material,
+        });
+    }
+}
+Renderable.componentName = 'Renderable';

package/build/contrib/components/renderable/material.d.ts

@@ -0,0 +1,16 @@
+export type BlendingMode = 'normal' | 'addition' | 'substract' | 'multiply';
+export interface BasicMaterialOptions {
+    color?: string;
+    blending?: BlendingMode;
+    opacity?: number;
+}
+export type MaterialType = 'lightsensitive' | 'basic';
+export interface MaterialConfig {
+    type: MaterialType;
+    options?: BasicMaterialOptions;
+}
+export declare class Material {
+    type: MaterialType;
+    options: BasicMaterialOptions;
+    constructor(config: MaterialConfig);
+}

package/build/contrib/components/renderable/material.js

@@ -0,0 +1,8 @@
+export class Material {
+    type;
+    options;
+    constructor(config) {
+        this.type = config.type;
+        this.options = config.options ? { ...config.options } : {};
+    }
+}

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

@@ -0,0 +1,20 @@
+import { Component } from '../../../engine/component';
+export type RigidBodyType = 'dynamic' | 'static';
+export interface RigidBodyConfig {
+    type: RigidBodyType;
+    mass: number;
+    useGravity: boolean;
+    drag: number;
+    isPermeable: boolean;
+    ghost: boolean;
+}
+export declare class RigidBody extends Component {
+    type: RigidBodyType;
+    mass: number;
+    useGravity: boolean;
+    isPermeable: boolean;
+    ghost: boolean;
+    drag: number;
+    constructor(config: RigidBodyConfig);
+    clone(): RigidBody;
+}

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

@@ -0,0 +1,29 @@
+import { Component } from '../../../engine/component';
+export class RigidBody extends Component {
+    type;
+    mass;
+    useGravity;
+    isPermeable;
+    ghost;
+    drag;
+    constructor(config) {
+        super();
+        this.type = config.type;
+        this.mass = config.mass;
+        this.useGravity = config.useGravity;
+        this.isPermeable = config.isPermeable;
+        this.ghost = config.ghost;
+        this.drag = config.drag;
+    }
+    clone() {
+        return new RigidBody({
+            mass: this.mass,
+            useGravity: this.useGravity,
+            isPermeable: this.isPermeable,
+            ghost: this.ghost,
+            type: this.type,
+            drag: this.drag,
+        });
+    }
+}
+RigidBody.componentName = 'RigidBody';

package/build/contrib/components/script-bundle/index.d.ts

@@ -0,0 +1,14 @@
+import { Component } from '../../../engine/component';
+interface ScriptConfig {
+    name: string;
+    options: Record<string, unknown>;
+}
+export interface ScriptBundleConfig {
+    scripts: Array<ScriptConfig>;
+}
+export declare class ScriptBundle extends Component {
+    scripts: Array<ScriptConfig>;
+    constructor(config: ScriptBundleConfig);
+    clone(): ScriptBundle;
+}
+export {};

package/build/contrib/components/script-bundle/index.js

@@ -0,0 +1,15 @@
+import { Component } from '../../../engine/component';
+export class ScriptBundle extends Component {
+    scripts;
+    constructor(config) {
+        super();
+        const { scripts } = config;
+        this.scripts = scripts;
+    }
+    clone() {
+        return new ScriptBundle({
+            scripts: this.scripts.map(({ name, options }) => ({ name, options: { ...options } })),
+        });
+    }
+}
+ScriptBundle.componentName = 'ScriptBundle';

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

@@ -0,0 +1,35 @@
+import { Component } from '../../../engine/component';
+import { Material, MaterialConfig } from './material';
+type FitType = 'stretch' | 'repeat';
+export type { MaterialType, BasicMaterialOptions, BlendingMode } from './material';
+export interface SpriteConfig {
+    src: string;
+    width: number;
+    height: number;
+    slice: number;
+    rotation: number;
+    flipX: boolean;
+    flipY: boolean;
+    disabled: boolean;
+    sortingLayer: string;
+    sortCenter: [number, number];
+    fit: FitType;
+    material: MaterialConfig;
+}
+export declare class Sprite extends Component {
+    src: string;
+    width: number;
+    height: number;
+    slice: number;
+    rotation: number;
+    flipX: boolean;
+    flipY: boolean;
+    disabled: boolean;
+    sortingLayer: string;
+    sortCenter: [number, number];
+    currentFrame?: number;
+    fit: FitType;
+    material: Material;
+    constructor(config: SpriteConfig);
+    clone(): Sprite;
+}

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

@@ -0,0 +1,50 @@
+import { Component } from '../../../engine/component';
+import { Material } from './material';
+export class Sprite extends Component {
+    src;
+    width;
+    height;
+    slice;
+    rotation;
+    flipX;
+    flipY;
+    disabled;
+    sortingLayer;
+    sortCenter;
+    currentFrame;
+    fit;
+    material;
+    constructor(config) {
+        super();
+        this.src = config.src;
+        this.width = config.width;
+        this.height = config.height;
+        this.slice = config.slice;
+        this.currentFrame = 0;
+        this.rotation = config.rotation;
+        this.flipX = config.flipX;
+        this.flipY = config.flipY;
+        this.disabled = config.disabled;
+        this.sortingLayer = config.sortingLayer;
+        this.sortCenter = config.sortCenter;
+        this.fit = config.fit;
+        this.material = new Material(config.material);
+    }
+    clone() {
+        return new Sprite({
+            src: this.src,
+            width: this.width,
+            height: this.height,
+            slice: this.slice,
+            rotation: this.rotation,
+            flipX: this.flipX,
+            flipY: this.flipY,
+            disabled: this.disabled,
+            sortingLayer: this.sortingLayer,
+            sortCenter: this.sortCenter.slice(0),
+            fit: this.fit,
+            material: this.material,
+        });
+    }
+}
+Sprite.componentName = 'Sprite';

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

@@ -0,0 +1,16 @@
+export type BlendingMode = 'normal' | 'addition' | 'substract' | 'multiply';
+export interface BasicMaterialOptions {
+    color?: string;
+    blending?: BlendingMode;
+    opacity?: number;
+}
+export type MaterialType = 'lightsensitive' | 'basic';
+export interface MaterialConfig {
+    type: MaterialType;
+    options?: BasicMaterialOptions;
+}
+export declare class Material {
+    type: MaterialType;
+    options: BasicMaterialOptions;
+    constructor(config: MaterialConfig);
+}

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

@@ -0,0 +1,8 @@
+export class Material {
+    type;
+    options;
+    constructor(config) {
+        this.type = config.type;
+        this.options = config.options ? { ...config.options } : {};
+    }
+}

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

@@ -0,0 +1,32 @@
+import { Component } from '../../../engine/component';
+export interface TransformConfig {
+    offsetX: number;
+    offsetY: number;
+    offsetZ: number;
+    rotation: number;
+    scaleX: number;
+    scaleY: number;
+}
+export declare class Transform extends Component {
+    relativeOffsetX: number;
+    relativeOffsetY: number;
+    relativeOffsetZ: number;
+    relativeRotation: number;
+    relativeScaleX: number;
+    relativeScaleY: number;
+    constructor(config: TransformConfig);
+    _getPropertyFromParent(name: string, defaultValue: number): number;
+    set offsetX(offsetX: number);
+    get offsetX(): number;
+    set offsetY(offsetY: number);
+    get offsetY(): number;
+    set offsetZ(offsetZ: number);
+    get offsetZ(): number;
+    set rotation(rotation: number);
+    get rotation(): number;
+    set scaleX(scaleX: number);
+    get scaleX(): number;
+    set scaleY(scaleY: number);
+    get scaleY(): number;
+    clone(): Transform;
+}