dacha 0.13.0

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

@@ -0,0 +1,69 @@
+import { Component } from '../../../engine/component';
+export class Transform extends Component {
+    relativeOffsetX;
+    relativeOffsetY;
+    relativeOffsetZ;
+    relativeRotation;
+    relativeScaleX;
+    relativeScaleY;
+    constructor(config) {
+        super();
+        this.relativeOffsetX = config.offsetX;
+        this.relativeOffsetY = config.offsetY;
+        this.relativeOffsetZ = config.offsetZ;
+        this.relativeRotation = config.rotation;
+        this.relativeScaleX = config.scaleX || 1;
+        this.relativeScaleY = config.scaleY || 1;
+    }
+    _getPropertyFromParent(name, defaultValue) {
+        const parentComponent = this.getParentComponent();
+        return parentComponent ? parentComponent[name] : defaultValue;
+    }
+    set offsetX(offsetX) {
+        this.relativeOffsetX = offsetX - this._getPropertyFromParent('offsetX', 0);
+    }
+    get offsetX() {
+        return this.relativeOffsetX + this._getPropertyFromParent('offsetX', 0);
+    }
+    set offsetY(offsetY) {
+        this.relativeOffsetY = offsetY - this._getPropertyFromParent('offsetY', 0);
+    }
+    get offsetY() {
+        return this.relativeOffsetY + this._getPropertyFromParent('offsetY', 0);
+    }
+    set offsetZ(offsetZ) {
+        this.relativeOffsetZ = offsetZ - this._getPropertyFromParent('offsetZ', 0);
+    }
+    get offsetZ() {
+        return this.relativeOffsetZ + this._getPropertyFromParent('offsetZ', 0);
+    }
+    set rotation(rotation) {
+        this.relativeRotation = rotation - this._getPropertyFromParent('rotation', 0);
+    }
+    get rotation() {
+        return this.relativeRotation + this._getPropertyFromParent('rotation', 0);
+    }
+    set scaleX(scaleX) {
+        this.relativeScaleX = scaleX / this._getPropertyFromParent('scaleX', 1);
+    }
+    get scaleX() {
+        return this.relativeScaleX * this._getPropertyFromParent('scaleX', 1);
+    }
+    set scaleY(scaleY) {
+        this.relativeScaleY = scaleY / this._getPropertyFromParent('scaleY', 1);
+    }
+    get scaleY() {
+        return this.relativeScaleY * this._getPropertyFromParent('scaleY', 1);
+    }
+    clone() {
+        return new Transform({
+            offsetX: this.relativeOffsetX,
+            offsetY: this.relativeOffsetY,
+            offsetZ: this.relativeOffsetZ,
+            rotation: this.relativeRotation,
+            scaleX: this.relativeScaleX,
+            scaleY: this.relativeScaleY,
+        });
+    }
+}
+Transform.componentName = 'Transform';

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

@@ -0,0 +1,63 @@
+import type { Actor } from '../../engine/actor';
+import type { Vector2 } from '../../engine/math-lib';
+import type { CustomMouseEvent, CustomKeyboardEvent } from '../types/input-events';
+import type { ActorEvent, SceneEvent } from '../../types/events';
+export declare const SetCamera = "SetCamera";
+export declare const GameStatsUpdate = "GameStatsUpdate";
+export declare const Collision = "Collision";
+export declare const KeyboardInput = "KeyboardInput";
+export declare const MouseInput = "MouseInput";
+export declare const CollisionEnter = "CollisionEnter";
+export declare const CollisionStay = "CollisionStay";
+export declare const CollisionLeave = "CollisionLeave";
+export declare const AddForce = "AddForce";
+export declare const AddImpulse = "AddImpulse";
+export declare const StopMovement = "StopMovement";
+export type MouseInputEvent = SceneEvent<CustomMouseEvent>;
+export type KeyboardInputEvent = SceneEvent<CustomKeyboardEvent>;
+export type SetCameraEvent = SceneEvent<{
+    actorId: string;
+}>;
+export type GameStatsUpdateEvent = SceneEvent<{
+    fps: number;
+    actorsCount: number;
+}>;
+export type CollisionEvent = SceneEvent<{
+    actor1: Actor;
+    actor2: Actor;
+    mtv1: Vector2;
+    mtv2: Vector2;
+}>;
+export type MouseControlEvent<T = Record<string, never>> = ActorEvent<Pick<CustomMouseEvent, 'x' | 'y' | 'screenX' | 'screenY' | 'nativeEvent'>> & T;
+export type KeyboardControlEvent<T = Record<string, never>> = ActorEvent<T>;
+type CollisionStateEvent = ActorEvent<{
+    actor: Actor;
+    mtv: Vector2;
+}>;
+export type CollisionEnterEvent = CollisionStateEvent;
+export type CollisionStayEvent = CollisionStateEvent;
+export type CollisionLeaveEvent = CollisionStateEvent;
+export type AddForceEvent = ActorEvent<{
+    value: Vector2;
+}>;
+export type AddImpulseEvent = ActorEvent<{
+    value: Vector2;
+}>;
+declare module '../../types/events' {
+    interface SceneEventMap {
+        [MouseInput]: MouseInputEvent;
+        [KeyboardInput]: KeyboardInputEvent;
+        [SetCamera]: SetCameraEvent;
+        [GameStatsUpdate]: GameStatsUpdateEvent;
+        [Collision]: CollisionEvent;
+    }
+    interface ActorEventMap {
+        [CollisionEnter]: CollisionEnterEvent;
+        [CollisionStay]: CollisionStayEvent;
+        [CollisionLeave]: CollisionLeaveEvent;
+        [AddForce]: AddForceEvent;
+        [AddImpulse]: AddImpulseEvent;
+        [StopMovement]: ActorEvent;
+    }
+}
+export {};

package/build/contrib/events/index.js

@@ -0,0 +1,11 @@
+export const SetCamera = 'SetCamera';
+export const GameStatsUpdate = 'GameStatsUpdate';
+export const Collision = 'Collision';
+export const KeyboardInput = 'KeyboardInput';
+export const MouseInput = 'MouseInput';
+export const CollisionEnter = 'CollisionEnter';
+export const CollisionStay = 'CollisionStay';
+export const CollisionLeave = 'CollisionLeave';
+export const AddForce = 'AddForce';
+export const AddImpulse = 'AddImpulse';
+export const StopMovement = 'StopMovement';

package/build/contrib/systems/animator/condition-controllers/comparator-condition-controller.d.ts

@@ -0,0 +1,10 @@
+import type { Actor } from '../../../../engine/actor';
+import type { ComparatorConditionProps } from '../../../components/animatable/comparator-condition-props';
+import { ConditionController } from './condition-controller';
+export declare class ComparatorConditionController implements ConditionController {
+    private actor;
+    private props;
+    constructor(props: ComparatorConditionProps, actor: Actor);
+    private getValue;
+    check(): boolean;
+}

package/build/contrib/systems/animator/condition-controllers/comparator-condition-controller.js

@@ -0,0 +1,32 @@
+import { getValue as getComponentValue } from '../utils';
+const operations = {
+    equals: (arg1, arg2) => arg1 === arg2,
+    notEquals: (arg1, arg2) => arg1 !== arg2,
+    greater: (arg1, arg2) => arg1 > arg2,
+    less: (arg1, arg2) => arg1 < arg2,
+    greaterOrEqual: (arg1, arg2) => arg1 >= arg2,
+    lessOrEqual: (arg1, arg2) => arg1 <= arg2,
+};
+export class ComparatorConditionController {
+    actor;
+    props;
+    constructor(props, actor) {
+        this.actor = actor;
+        this.props = props;
+    }
+    getValue(actor, arg) {
+        if (arg.type === 'componentValue') {
+            return getComponentValue(actor, arg.value);
+        }
+        return arg.value;
+    }
+    check() {
+        const { operation } = this.props;
+        if (!operations[operation]) {
+            throw new Error(`Unknown operation type: ${operation}`);
+        }
+        const arg1 = this.getValue(this.actor, this.props.arg1);
+        const arg2 = this.getValue(this.actor, this.props.arg2);
+        return operations[operation](arg1, arg2);
+    }
+}

package/build/contrib/systems/animator/condition-controllers/condition-controller.d.ts

@@ -0,0 +1,3 @@
+export interface ConditionController {
+    check(): boolean;
+}

package/build/contrib/systems/animator/condition-controllers/condition-controller.js

@@ -0,0 +1 @@
+export {};

package/build/contrib/systems/animator/condition-controllers/event-condition-controller.d.ts

@@ -0,0 +1,8 @@
+import type { Actor } from '../../../../engine/actor';
+import type { EventConditionProps } from '../../../components/animatable/event-condition-props';
+import { ConditionController } from './condition-controller';
+export declare class EventConditionController implements ConditionController {
+    private isEventFired;
+    constructor(props: EventConditionProps, actor: Actor);
+    check(): boolean;
+}

package/build/contrib/systems/animator/condition-controllers/event-condition-controller.js

@@ -0,0 +1,18 @@
+export class EventConditionController {
+    isEventFired;
+    constructor(props, actor) {
+        this.isEventFired = false;
+        const { eventType } = props;
+        const handleEvent = (event) => {
+            if (event.target !== actor) {
+                return;
+            }
+            this.isEventFired = true;
+            actor.removeEventListener(eventType, handleEvent);
+        };
+        actor.addEventListener(eventType, handleEvent);
+    }
+    check() {
+        return this.isEventFired;
+    }
+}

package/build/contrib/systems/animator/condition-controllers/index.d.ts

@@ -0,0 +1,3 @@
+import type { Constructor } from '../../../../types/utils';
+import type { ConditionController } from './condition-controller';
+export declare const conditionControllers: Record<string, Constructor<ConditionController>>;

package/build/contrib/systems/animator/condition-controllers/index.js

@@ -0,0 +1,6 @@
+import { EventConditionController } from './event-condition-controller';
+import { ComparatorConditionController } from './comparator-condition-controller';
+export const conditionControllers = {
+    event: EventConditionController,
+    comparator: ComparatorConditionController,
+};

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

@@ -0,0 +1,15 @@
+import { System } from '../../../engine/system';
+import type { SystemOptions, UpdateOptions } from '../../../engine/system';
+export declare class Animator extends System {
+    private actorCollection;
+    private substatePickers;
+    private actorConditions;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    private handleActorRemove;
+    private setUpConditionControllers;
+    private updateFrame;
+    private pickSubstate;
+    update(options: UpdateOptions): void;
+}

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

@@ -0,0 +1,93 @@
+import { System } from '../../../engine/system';
+import { ActorCollection } from '../../../engine/actor';
+import { Animatable } from '../../components/animatable';
+import { RemoveActor } from '../../../engine/events';
+import { conditionControllers } from './condition-controllers';
+import { substatePickers } from './substate-pickers';
+import { setValue } from './utils';
+const FRAME_RATE = 100;
+export class Animator extends System {
+    actorCollection;
+    substatePickers;
+    actorConditions;
+    constructor(options) {
+        super();
+        this.actorCollection = new ActorCollection(options.scene, {
+            components: [Animatable],
+        });
+        this.substatePickers = Object.keys(substatePickers)
+            .reduce((storage, key) => {
+            const SubstatePicker = substatePickers[key];
+            storage[key] = new SubstatePicker();
+            return storage;
+        }, {});
+        this.actorConditions = {};
+    }
+    mount() {
+        this.actorCollection.addEventListener(RemoveActor, this.handleActorRemove);
+    }
+    unmount() {
+        this.actorCollection.removeEventListener(RemoveActor, this.handleActorRemove);
+    }
+    handleActorRemove = (event) => {
+        delete this.actorConditions[event.actor.id];
+    };
+    setUpConditionControllers(actor) {
+        this.actorConditions[actor.id] = {};
+        const animatable = actor.getComponent(Animatable);
+        animatable.currentState?.transitions.forEach((transition) => {
+            this.actorConditions[actor.id][transition.id] ??= {};
+            const transitionMap = this.actorConditions[actor.id][transition.id];
+            transition.conditions.forEach((condition) => {
+                const ConditionController = conditionControllers[condition.type];
+                transitionMap[condition.id] = new ConditionController(condition.props, actor);
+            });
+        });
+    }
+    updateFrame(actor, frame) {
+        Object.keys(frame).forEach((fieldName) => setValue(actor, frame[fieldName].path, frame[fieldName].value));
+    }
+    pickSubstate(actor, state) {
+        const substatePicker = this.substatePickers[state.pickMode];
+        return substatePicker.getSubstate(actor, state.substates, state.pickProps);
+    }
+    update(options) {
+        const { deltaTime } = options;
+        this.actorCollection.forEach((actor) => {
+            const animatable = actor.getComponent(Animatable);
+            if (animatable.currentState === void 0) {
+                return;
+            }
+            if (!this.actorConditions[actor.id]) {
+                this.setUpConditionControllers(actor);
+            }
+            let { timeline } = animatable.currentState;
+            if (animatable.currentState.substates) {
+                const substate = this.pickSubstate(actor, animatable.currentState);
+                timeline = substate.timeline;
+            }
+            const framesCount = timeline.frames.length;
+            const actualFrameRate = FRAME_RATE / animatable.currentState.speed;
+            const baseDuration = framesCount * actualFrameRate;
+            animatable.duration += deltaTime / baseDuration;
+            const currentFrame = animatable.duration < 1 || timeline.looped
+                ? Math.trunc((animatable.duration % 1) * framesCount)
+                : framesCount - 1;
+            this.updateFrame(actor, timeline.frames[currentFrame]);
+            const nextTransition = animatable.currentState.transitions.find((transition) => {
+                if (transition.time && animatable.duration < transition.time) {
+                    return false;
+                }
+                return transition.conditions.every((condition) => {
+                    return this.actorConditions[actor.id][transition.id][condition.id].check();
+                });
+            });
+            if (nextTransition) {
+                animatable.setCurrentState(nextTransition.state);
+                animatable.duration = 0;
+                this.setUpConditionControllers(actor);
+            }
+        });
+    }
+}
+Animator.systemName = 'Animator';

package/build/contrib/systems/animator/substate-pickers/index.d.ts

@@ -0,0 +1,4 @@
+import type { Picker } from './picker';
+export declare const substatePickers: Record<string, {
+    new (): Picker;
+}>;

package/build/contrib/systems/animator/substate-pickers/index.js

@@ -0,0 +1,6 @@
+import { OneDimensionalPicker } from './one-dimensional-picker';
+import { TwoDimensionalPicker } from './two-dimensional-picker';
+export const substatePickers = {
+    '1D': OneDimensionalPicker,
+    '2D': TwoDimensionalPicker,
+};

package/build/contrib/systems/animator/substate-pickers/one-dimensional-picker.d.ts

@@ -0,0 +1,8 @@
+import type { Actor } from '../../../../engine/actor';
+import type { Substate } from '../../../components/animatable/substate';
+import type { OneDimensionalProps } from '../../../components/animatable/one-dimensional-props';
+import type { Picker } from './picker';
+export declare class OneDimensionalPicker implements Picker {
+    private getDistance;
+    getSubstate(actor: Actor, substates: Array<Substate>, props: OneDimensionalProps): Substate;
+}

package/build/contrib/systems/animator/substate-pickers/one-dimensional-picker.js

@@ -0,0 +1,25 @@
+import { getValue } from '../utils';
+export class OneDimensionalPicker {
+    getDistance(x1, x2) {
+        return Math.abs(x1 - x2);
+    }
+    getSubstate(actor, substates, props) {
+        if (!substates.length) {
+            throw new Error('Can\'t pick substate, because current state doesn\'t contain any substates');
+        }
+        if (substates.length === 1) {
+            return substates[0];
+        }
+        const x = getValue(actor, props.x);
+        let pickedSubstate = substates[0];
+        let minDistance = this.getDistance(x, pickedSubstate.x);
+        for (let i = 1; i < substates.length; i += 1) {
+            const distance = this.getDistance(x, substates[i].x);
+            if (distance < minDistance) {
+                pickedSubstate = substates[i];
+                minDistance = distance;
+            }
+        }
+        return pickedSubstate;
+    }
+}

package/build/contrib/systems/animator/substate-pickers/picker.d.ts

@@ -0,0 +1,7 @@
+import type { Actor } from '../../../../engine/actor';
+import type { Substate } from '../../../components/animatable/substate';
+import type { OneDimensionalProps } from '../../../components/animatable/one-dimensional-props';
+import type { TwoDimensionalProps } from '../../../components/animatable/two-dimensional-props';
+export interface Picker {
+    getSubstate(actor: Actor, substates: Array<Substate>, props: OneDimensionalProps | TwoDimensionalProps): Substate;
+}

package/build/contrib/systems/animator/substate-pickers/picker.js

@@ -0,0 +1 @@
+export {};

package/build/contrib/systems/animator/substate-pickers/two-dimensional-picker.d.ts

@@ -0,0 +1,8 @@
+import type { Actor } from '../../../../engine/actor';
+import type { Substate } from '../../../components/animatable/substate';
+import type { TwoDimensionalProps } from '../../../components/animatable/two-dimensional-props';
+import { Picker } from './picker';
+export declare class TwoDimensionalPicker implements Picker {
+    private getDistance;
+    getSubstate(actor: Actor, substates: Array<Substate>, props: TwoDimensionalProps): Substate;
+}

package/build/contrib/systems/animator/substate-pickers/two-dimensional-picker.js

@@ -0,0 +1,27 @@
+import { MathOps } from '../../../../engine/math-lib';
+import { getValue } from '../utils';
+export class TwoDimensionalPicker {
+    getDistance(x1, x2, y1, y2) {
+        return MathOps.getDistanceBetweenTwoPoints(x1, x2, y1, y2);
+    }
+    getSubstate(actor, substates, props) {
+        if (!substates.length) {
+            throw new Error('Can\'t pick substate, because current state doesn\'t contain any substates');
+        }
+        if (substates.length === 1) {
+            return substates[0];
+        }
+        const x = getValue(actor, props.x);
+        const y = getValue(actor, props.y);
+        let pickedSubstate = substates[0];
+        let minDistance = this.getDistance(x, pickedSubstate.x, y, pickedSubstate.y);
+        for (let i = 1; i < substates.length; i += 1) {
+            const distance = this.getDistance(x, substates[i].x, y, substates[i].y);
+            if (distance < minDistance) {
+                pickedSubstate = substates[i];
+                minDistance = distance;
+            }
+        }
+        return pickedSubstate;
+    }
+}

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

@@ -0,0 +1,3 @@
+import { Actor } from '../../../engine/actor';
+export declare const getValue: (actor: Actor, path: Array<string> | string) => unknown;
+export declare const setValue: (actor: Actor, path: Array<string>, value: unknown) => void;

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

@@ -0,0 +1,32 @@
+import { Actor } from '../../../engine/actor';
+const PATH_COMPONENTS = 'components';
+const PATH_CHILDREN = 'children';
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const _getValue = (actor, path, pathDepth) => {
+    let soughtValue = actor;
+    for (let i = 0; i < pathDepth && soughtValue !== undefined; i += 1) {
+        if (soughtValue instanceof Actor && path[i] === PATH_CHILDREN) {
+            i += 1;
+            soughtValue = soughtValue.children.find((child) => child.name === path[i]);
+        }
+        else if (soughtValue instanceof Actor && path[i] === PATH_COMPONENTS) {
+            i += 1;
+            soughtValue = soughtValue.getComponent(path[i]);
+        }
+        else {
+            soughtValue = soughtValue[path[i]];
+        }
+    }
+    return soughtValue;
+};
+export const getValue = (actor, path) => _getValue(actor, path, path.length);
+export const setValue = (actor, path, value) => {
+    const soughtValue = _getValue(actor, path, path.length - 1);
+    if (!soughtValue) {
+        return;
+    }
+    if (soughtValue instanceof Actor) {
+        throw new Error(`Can't set frame value for path: ${path.join('.')}. Setting value as actor property is restricted`);
+    }
+    soughtValue[path[path.length - 1]] = value;
+};

package/build/contrib/systems/camera-system/index.d.ts

@@ -0,0 +1,2 @@
+export { CameraSystem } from './system';
+export { CameraService } from './service';

package/build/contrib/systems/camera-system/index.js

@@ -0,0 +1,2 @@
+export { CameraSystem } from './system';
+export { CameraService } from './service';

package/build/contrib/systems/camera-system/service.d.ts

@@ -0,0 +1,13 @@
+import type { Actor, ActorCollection } from '../../../engine/actor';
+interface CameraServiceOptions {
+    cameraCollection: ActorCollection;
+    onCameraUpdate: () => void;
+}
+export declare class CameraService {
+    private cameraCollection;
+    private onCameraUpdate;
+    constructor({ cameraCollection, onCameraUpdate }: CameraServiceOptions);
+    setCurrentCamera(actor: Actor): void;
+    getCurrentCamera(): Actor | undefined;
+}
+export {};

package/build/contrib/systems/camera-system/service.js

@@ -0,0 +1,25 @@
+import { Camera } from '../../components';
+export class CameraService {
+    cameraCollection;
+    onCameraUpdate;
+    constructor({ cameraCollection, onCameraUpdate }) {
+        this.cameraCollection = cameraCollection;
+        this.onCameraUpdate = onCameraUpdate;
+    }
+    setCurrentCamera(actor) {
+        if (!actor.getComponent(Camera)) {
+            throw new Error(`Can't set current camera. Actor with id: ${actor.id} doesn't contain Camera component.`);
+        }
+        this.cameraCollection.forEach((cameraActor) => {
+            const camera = cameraActor.getComponent(Camera);
+            camera.current = actor.id === cameraActor.id;
+        });
+        this.onCameraUpdate();
+    }
+    getCurrentCamera() {
+        return this.cameraCollection.find((actor) => {
+            const camera = actor.getComponent(Camera);
+            return camera.current;
+        });
+    }
+}

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

@@ -0,0 +1,16 @@
+import { System } from '../../../engine/system';
+import type { SystemOptions } from '../../../engine/system';
+export declare class CameraSystem extends System {
+    private actorCollection;
+    private scene;
+    private window;
+    private cameraService;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    /**
+     * @deprecated Use CameraService instead
+     */
+    private handleSetCamera;
+    private handleCameraUpdate;
+}

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

@@ -0,0 +1,65 @@
+import { System } from '../../../engine/system';
+import { ActorCollection } from '../../../engine/actor';
+import { Camera } from '../../components/camera';
+import { getWindowNode } from '../../utils/get-window-node';
+import { SetCamera } from '../../events';
+import { CameraService } from './service';
+export class CameraSystem extends System {
+    actorCollection;
+    scene;
+    window;
+    cameraService;
+    constructor(options) {
+        super();
+        const { windowNodeId, scene, } = options;
+        const windowNode = getWindowNode(windowNodeId);
+        this.actorCollection = new ActorCollection(scene, {
+            components: [
+                Camera,
+            ],
+        });
+        this.scene = scene;
+        this.window = windowNode;
+        this.cameraService = new CameraService({
+            cameraCollection: this.actorCollection,
+            onCameraUpdate: this.handleCameraUpdate,
+        });
+        scene.addService(this.cameraService);
+    }
+    mount() {
+        this.handleCameraUpdate();
+        window.addEventListener('resize', this.handleCameraUpdate);
+        this.scene.addEventListener(SetCamera, this.handleSetCamera);
+    }
+    unmount() {
+        window.removeEventListener('resize', this.handleCameraUpdate);
+        this.scene.removeEventListener(SetCamera, this.handleSetCamera);
+    }
+    /**
+     * @deprecated Use CameraService instead
+     */
+    handleSetCamera = (event) => {
+        const { actorId } = event;
+        const newCamera = this.actorCollection.getById(actorId);
+        if (!newCamera) {
+            throw new Error(`Could not set camera with id ${actorId} for the scene`);
+        }
+        this.cameraService.setCurrentCamera(newCamera);
+        this.handleCameraUpdate();
+    };
+    handleCameraUpdate = () => {
+        const width = this.window.innerWidth || this.window.clientWidth;
+        const height = this.window.innerHeight || this.window.clientHeight;
+        const camera = this.cameraService.getCurrentCamera();
+        if (!camera) {
+            return;
+        }
+        const cameraComponent = camera.getComponent(Camera);
+        const { windowSizeX, windowSizeY } = cameraComponent;
+        if (width !== windowSizeX || height !== windowSizeY) {
+            cameraComponent.windowSizeX = width;
+            cameraComponent.windowSizeY = height;
+        }
+    };
+}
+CameraSystem.systemName = 'CameraSystem';

package/build/contrib/systems/game-stats-meter/index.d.ts

@@ -0,0 +1,11 @@
+import { System } from '../../../engine/system';
+import type { SystemOptions, UpdateOptions } from '../../../engine/system';
+export declare class GameStatsMeter extends System {
+    private scene;
+    private actorCollection;
+    private frequency;
+    private fps;
+    private time;
+    constructor(options: SystemOptions);
+    update(options: UpdateOptions): void;
+}