dacha-game-systems 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Mikhail Remmele
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,4 @@
+# Dacha Game Systems
+
+## Description
+Library with common reusable game systems.

package/build/components/active-effects/index.d.ts

@@ -0,0 +1,12 @@
+import { Component } from 'dacha';
+import type { Actor } from 'dacha';
+export interface ActiveEffectsConfig {
+    list: Array<string>;
+    map: Record<string, Actor>;
+}
+export declare class ActiveEffects extends Component {
+    list: Array<string>;
+    map: Record<string, Actor>;
+    constructor(config?: ActiveEffectsConfig);
+    clone(): ActiveEffects;
+}

package/build/components/active-effects/index.js

@@ -0,0 +1,17 @@
+import { Component } from 'dacha';
+export class ActiveEffects extends Component {
+  constructor(config) {
+    super();
+    this.list = config ? [...config.list] : [];
+    this.map = config ? {
+      ...config.map
+    } : {};
+  }
+  clone() {
+    return new ActiveEffects({
+      list: this.list,
+      map: this.map
+    });
+  }
+}
+ActiveEffects.componentName = 'ActiveEffects';

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

@@ -0,0 +1,19 @@
+import { Component } from 'dacha';
+import type { EffectType, DelayedEffectOptions, PeriodicalEffectOptions, TimeLimitedEffectOptions } from './types';
+interface EffectConfig {
+    script: string;
+    type: EffectType;
+    options: Record<string, unknown>;
+    applicatorOptions?: DelayedEffectOptions | PeriodicalEffectOptions | TimeLimitedEffectOptions;
+}
+export declare class Effect extends Component {
+    script: string;
+    type: EffectType;
+    options: Record<string, unknown>;
+    applicatorOptions?: DelayedEffectOptions | PeriodicalEffectOptions | TimeLimitedEffectOptions;
+    isCancelled: boolean;
+    removeTimeout: number;
+    constructor(config: EffectConfig);
+    clone(): Effect;
+}
+export {};

package/build/components/effect/index.js

@@ -0,0 +1,28 @@
+import { Component } from 'dacha';
+const REMOVE_TIMEOUT = 5000;
+export class Effect extends Component {
+  constructor(config) {
+    super();
+    this.script = config.script;
+    this.type = config.type;
+    this.options = {
+      ...config.options
+    };
+    if (config.applicatorOptions) {
+      this.applicatorOptions = {
+        ...config.applicatorOptions
+      };
+    }
+    this.isCancelled = false;
+    this.removeTimeout = REMOVE_TIMEOUT;
+  }
+  clone() {
+    return new Effect({
+      script: this.script,
+      type: this.type,
+      options: this.options,
+      applicatorOptions: this.applicatorOptions
+    });
+  }
+}
+Effect.componentName = 'Effect';

package/build/components/effect/types.d.ts

@@ -0,0 +1,12 @@
+export type EffectType = 'instant' | 'delayed' | 'periodical' | 'continuous' | 'timeLimited';
+export interface DelayedEffectOptions {
+    timer: number;
+}
+export interface PeriodicalEffectOptions {
+    frequency: number;
+    duration: number;
+    cooldown: number;
+}
+export interface TimeLimitedEffectOptions {
+    duration: number;
+}

package/build/components/effect/types.js

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

package/build/components/index.d.ts

@@ -0,0 +1,4 @@
+export { ActiveEffects } from './active-effects';
+export { Effect } from './effect';
+export type { EffectType, DelayedEffectOptions, PeriodicalEffectOptions, TimeLimitedEffectOptions, } from './effect/types';
+export { Parallax } from './parallax';

package/build/components/index.js

@@ -0,0 +1,3 @@
+export { ActiveEffects } from './active-effects';
+export { Effect } from './effect';
+export { Parallax } from './parallax';

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

@@ -0,0 +1,12 @@
+import { Component } from 'dacha';
+interface ParallaxConfig {
+    distance: number;
+}
+export declare class Parallax extends Component {
+    distance: number;
+    startX: number;
+    startY: number;
+    constructor(config: ParallaxConfig);
+    clone(): Parallax;
+}
+export {};

package/build/components/parallax/index.js

@@ -0,0 +1,15 @@
+import { Component } from 'dacha';
+export class Parallax extends Component {
+  constructor(config) {
+    super();
+    this.distance = config.distance;
+    this.startX = 0;
+    this.startY = 0;
+  }
+  clone() {
+    return new Parallax({
+      distance: this.distance
+    });
+  }
+}
+Parallax.componentName = 'Parallax';

package/build/events/index.d.ts

@@ -0,0 +1,21 @@
+import type { ActorEvent } from 'dacha';
+export declare const AddEffect = "AddEffect";
+export declare const RemoveEffect = "RemoveEffect";
+export declare const ApplyEffect = "ApplyEffect";
+export declare const CancelEffect = "CancelEffect";
+export type AddEffectEvent = ActorEvent<{
+    id: string;
+    options: Record<string, unknown>;
+}>;
+export type RemoveEffectEvent = ActorEvent<{
+    id: string;
+    options: Record<string, unknown>;
+}>;
+declare module 'dacha' {
+    interface ActorEventMap {
+        [AddEffect]: AddEffectEvent;
+        [RemoveEffect]: RemoveEffectEvent;
+        [ApplyEffect]: ActorEvent;
+        [CancelEffect]: ActorEvent;
+    }
+}

package/build/events/index.js

@@ -0,0 +1,4 @@
+export const AddEffect = 'AddEffect';
+export const RemoveEffect = 'RemoveEffect';
+export const ApplyEffect = 'ApplyEffect';
+export const CancelEffect = 'CancelEffect';

package/build/index.d.ts

@@ -0,0 +1,2 @@
+export * from './systems';
+export * from './components';

package/build/index.js

@@ -0,0 +1,2 @@
+export * from './systems';
+export * from './components';

package/build/schema/components/effect/index.d.ts

@@ -0,0 +1,2 @@
+import type { WidgetSchema } from 'dacha-workbench';
+export declare const effect: WidgetSchema;

package/build/schema/components/effect/index.js

@@ -0,0 +1,73 @@
+import { EffectWidget } from './view';
+export const effect = {
+  title: 'components.effect.title',
+  fields: [{
+    name: 'type',
+    title: 'components.effect.type.title',
+    type: 'select',
+    referenceId: 'types'
+  }, {
+    name: 'applicatorOptions.timer',
+    title: 'components.applicatorOptions.timer.title',
+    type: 'number',
+    dependency: {
+      name: 'type',
+      value: 'delayed'
+    }
+  }, {
+    name: 'applicatorOptions.frequency',
+    title: 'components.applicatorOptions.frequency.title',
+    type: 'number',
+    dependency: {
+      name: 'type',
+      value: 'periodical'
+    }
+  }, {
+    name: 'applicatorOptions.duration',
+    title: 'components.applicatorOptions.duration.title',
+    type: 'number',
+    dependency: {
+      name: 'type',
+      value: 'periodical|timeLimited'
+    }
+  }, {
+    name: 'applicatorOptions.cooldown',
+    title: 'components.applicatorOptions.cooldown.title',
+    type: 'number',
+    dependency: {
+      name: 'type',
+      value: 'periodical'
+    }
+  }, {
+    name: 'script',
+    title: 'components.effect.script.title',
+    type: 'select',
+    referenceId: 'scripts'
+  }],
+  references: {
+    types: {
+      items: [{
+        title: 'components.effect.types.instant.title',
+        value: 'instant'
+      }, {
+        title: 'components.effect.types.delayed.title',
+        value: 'delayed'
+      }, {
+        title: 'components.effect.types.periodical.title',
+        value: 'periodical'
+      }, {
+        title: 'components.effect.types.continuous.title',
+        value: 'continuous'
+      }, {
+        title: 'components.effect.types.timeLimited.title',
+        value: 'timeLimited'
+      }]
+    }
+  },
+  view: EffectWidget,
+  getInitialState: () => ({
+    type: 'instant',
+    applicatorOptions: {},
+    script: ''
+  })
+};

package/build/schema/components/effect/view.d.ts

@@ -0,0 +1,3 @@
+import type { FC } from 'react';
+import type { WidgetProps } from 'dacha-workbench';
+export declare const EffectWidget: FC<WidgetProps>;

package/build/schema/components/effect/view.js

@@ -0,0 +1,37 @@
+import { useMemo } from 'react';
+import { Widget, useExtension, useConfig } from 'dacha-workbench';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+const SYSTEM_NAME = 'EffectsSystem';
+export const EffectWidget = ({
+  fields,
+  path,
+  references
+}) => {
+  const {
+    resourcesSchema
+  } = useExtension();
+  const scriptPath = useMemo(() => path.concat('script'), [path]);
+  const scriptName = useConfig(scriptPath);
+  const extendedReferences = useMemo(() => ({
+    ...references,
+    scripts: {
+      items: Object.keys(resourcesSchema[SYSTEM_NAME] || {}).map(key => ({
+        title: key,
+        value: key
+      }))
+    }
+  }), [references]);
+  const partFields = resourcesSchema[SYSTEM_NAME]?.[scriptName]?.fields;
+  const partReferences = resourcesSchema[SYSTEM_NAME]?.[scriptName]?.references;
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [/*#__PURE__*/_jsx(Widget, {
+      path: path,
+      fields: fields,
+      references: extendedReferences
+    }), partFields && /*#__PURE__*/_jsx(Widget, {
+      path: path,
+      fields: partFields,
+      references: partReferences
+    })]
+  });
+};

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

@@ -0,0 +1,2 @@
+export { effect } from './effect';
+export { parallax } from './parallax';

package/build/schema/components/index.js

@@ -0,0 +1,2 @@
+export { effect } from './effect';
+export { parallax } from './parallax';

package/build/schema/components/parallax/index.d.ts

@@ -0,0 +1,2 @@
+import type { WidgetSchema } from 'dacha-workbench';
+export declare const parallax: WidgetSchema;

package/build/schema/components/parallax/index.js

@@ -0,0 +1,11 @@
+export const parallax = {
+  title: 'components.parallax.title',
+  fields: [{
+    name: 'distance',
+    title: 'components.parallax.distance.title',
+    type: 'number'
+  }],
+  getInitialState: () => ({
+    distance: 0
+  })
+};

package/build/schema/index.d.ts

@@ -0,0 +1,22 @@
+export { effectsSystem, parallaxSystem } from './systems';
+export { effect, parallax } from './components';
+export declare const locales: {
+    en: {
+        'components.effect.title': string;
+        'components.effect.script.title': string;
+        'components.effect.type.title': string;
+        'components.effect.types.instant.title': string;
+        'components.effect.types.delayed.title': string;
+        'components.effect.types.periodical.title': string;
+        'components.effect.types.continuous.title': string;
+        'components.effect.types.timeLimited.title': string;
+        'components.applicatorOptions.timer.title': string;
+        'components.applicatorOptions.frequency.title': string;
+        'components.applicatorOptions.duration.title': string;
+        'components.applicatorOptions.cooldown.title': string;
+        'components.parallax.title': string;
+        'components.parallax.distance.title': string;
+        'systems.effectsSystem.title': string;
+        'systems.parallaxSystem.title': string;
+    };
+};

package/build/schema/index.js

@@ -0,0 +1,6 @@
+import { en } from './locales/en';
+export { effectsSystem, parallaxSystem } from './systems';
+export { effect, parallax } from './components';
+export const locales = {
+  en
+};

package/build/schema/locales/en.d.ts

@@ -0,0 +1,18 @@
+export const en: {
+    'components.effect.title': string;
+    'components.effect.script.title': string;
+    'components.effect.type.title': string;
+    'components.effect.types.instant.title': string;
+    'components.effect.types.delayed.title': string;
+    'components.effect.types.periodical.title': string;
+    'components.effect.types.continuous.title': string;
+    'components.effect.types.timeLimited.title': string;
+    'components.applicatorOptions.timer.title': string;
+    'components.applicatorOptions.frequency.title': string;
+    'components.applicatorOptions.duration.title': string;
+    'components.applicatorOptions.cooldown.title': string;
+    'components.parallax.title': string;
+    'components.parallax.distance.title': string;
+    'systems.effectsSystem.title': string;
+    'systems.parallaxSystem.title': string;
+};

package/build/schema/locales/en.js

@@ -0,0 +1,18 @@
+export const en = {
+  'components.effect.title': 'Effect',
+  'components.effect.script.title': 'Script',
+  'components.effect.type.title': 'Type',
+  'components.effect.types.instant.title': 'Instant',
+  'components.effect.types.delayed.title': 'Delayed',
+  'components.effect.types.periodical.title': 'Periodical',
+  'components.effect.types.continuous.title': 'Continuous',
+  'components.effect.types.timeLimited.title': 'Time Limited',
+  'components.applicatorOptions.timer.title': 'Timer',
+  'components.applicatorOptions.frequency.title': 'Frequency',
+  'components.applicatorOptions.duration.title': 'Duration',
+  'components.applicatorOptions.cooldown.title': 'Cooldown',
+  'components.parallax.title': 'Parallax',
+  'components.parallax.distance.title': 'Distance',
+  'systems.effectsSystem.title': 'Effects System',
+  'systems.parallaxSystem.title': 'Parallax System'
+};

package/build/schema/systems/effect-system/index.d.ts

@@ -0,0 +1,3 @@
+export declare const effectsSystem: {
+    title: string;
+};

package/build/schema/systems/effect-system/index.js

@@ -0,0 +1,3 @@
+export const effectsSystem = {
+  title: 'systems.effectsSystem.title'
+};

package/build/schema/systems/index.d.ts

@@ -0,0 +1,2 @@
+export { effectsSystem } from './effect-system';
+export { parallaxSystem } from './parallax-system';

package/build/schema/systems/index.js

@@ -0,0 +1,2 @@
+export { effectsSystem } from './effect-system';
+export { parallaxSystem } from './parallax-system';

package/build/schema/systems/parallax-system/index.d.ts

@@ -0,0 +1,2 @@
+import type { WidgetSchema } from 'dacha-workbench';
+export declare const parallaxSystem: WidgetSchema;

package/build/schema/systems/parallax-system/index.js

@@ -0,0 +1,3 @@
+export const parallaxSystem = {
+  title: 'systems.parallaxSystem.title'
+};

package/build/systems/effects-system/effect-applicators/continuous-effect-applicator.d.ts

@@ -0,0 +1,10 @@
+import type { Actor } from 'dacha';
+import type { EffectScript } from '../effect-script';
+import { EffectApplicator } from './effect-applicator';
+export declare class ContinuousEffectApplicator extends EffectApplicator {
+    isFinished: boolean;
+    isApplied: boolean;
+    constructor(script: EffectScript, actor: Actor);
+    update(): void;
+    cancel(): void;
+}

package/build/systems/effects-system/effect-applicators/continuous-effect-applicator.js

@@ -0,0 +1,23 @@
+import { EffectApplicator } from './effect-applicator';
+export class ContinuousEffectApplicator extends EffectApplicator {
+  constructor(script, actor) {
+    super(script, actor);
+    this.isApplied = false;
+    this.isFinished = false;
+  }
+  update() {
+    if (this.isApplied) {
+      return;
+    }
+    this.script.apply();
+    this.handleApply();
+    this.isApplied = true;
+  }
+  cancel() {
+    if (!this.isApplied) {
+      return;
+    }
+    this.script.onCancel();
+    this.handleCancel();
+  }
+}

package/build/systems/effects-system/effect-applicators/delayed-effect-applicator.d.ts

@@ -0,0 +1,9 @@
+import type { Actor } from 'dacha';
+import type { EffectScript } from '../effect-script';
+import { EffectApplicator } from './effect-applicator';
+export declare class DelayedEffectApplicator extends EffectApplicator {
+    isFinished: boolean;
+    constructor(script: EffectScript, actor: Actor);
+    update(deltaTime: number): void;
+    cancel(): void;
+}

package/build/systems/effects-system/effect-applicators/delayed-effect-applicator.js

@@ -0,0 +1,23 @@
+import { Effect } from '../../../components';
+import { EffectApplicator } from './effect-applicator';
+export class DelayedEffectApplicator extends EffectApplicator {
+  constructor(script, actor) {
+    super(script, actor);
+    this.isFinished = false;
+  }
+  update(deltaTime) {
+    if (this.isFinished) {
+      return;
+    }
+    const applicatorOptions = this.actor.getComponent(Effect).applicatorOptions;
+    applicatorOptions.timer -= deltaTime;
+    if (applicatorOptions.timer <= 0) {
+      this.script.apply();
+      this.handleApply();
+      this.isFinished = true;
+    }
+  }
+  cancel() {
+    this.handleCancel();
+  }
+}

package/build/systems/effects-system/effect-applicators/effect-applicator.d.ts

@@ -0,0 +1,12 @@
+import type { Actor } from 'dacha';
+import type { EffectScript } from '../effect-script';
+export declare abstract class EffectApplicator {
+    protected script: EffectScript;
+    protected actor: Actor;
+    abstract isFinished: boolean;
+    constructor(script: EffectScript, actor: Actor);
+    protected handleCancel(): void;
+    protected handleApply(): void;
+    abstract update(deltaTime: number): void;
+    abstract cancel(): void;
+}

package/build/systems/effects-system/effect-applicators/effect-applicator.js

@@ -0,0 +1,13 @@
+import * as EventType from '../../../events';
+export class EffectApplicator {
+  constructor(script, actor) {
+    this.script = script;
+    this.actor = actor;
+  }
+  handleCancel() {
+    this.actor.dispatchEvent(EventType.CancelEffect);
+  }
+  handleApply() {
+    this.actor.dispatchEvent(EventType.ApplyEffect);
+  }
+}

package/build/systems/effects-system/effect-applicators/index.d.ts

@@ -0,0 +1,12 @@
+import { InstantEffectApplicator } from './instant-effect-applicator';
+import { DelayedEffectApplicator } from './delayed-effect-applicator';
+import { PeriodicalEffectApplicator } from './periodical-effect-applicator';
+import { ContinuousEffectApplicator } from './continuous-effect-applicator';
+import { TimeLimitedEffectApplicator } from './time-limited-effect-applicator';
+export declare const effectApplicators: {
+    instant: typeof InstantEffectApplicator;
+    delayed: typeof DelayedEffectApplicator;
+    periodical: typeof PeriodicalEffectApplicator;
+    continuous: typeof ContinuousEffectApplicator;
+    timeLimited: typeof TimeLimitedEffectApplicator;
+};

package/build/systems/effects-system/effect-applicators/index.js

@@ -0,0 +1,12 @@
+import { InstantEffectApplicator } from './instant-effect-applicator';
+import { DelayedEffectApplicator } from './delayed-effect-applicator';
+import { PeriodicalEffectApplicator } from './periodical-effect-applicator';
+import { ContinuousEffectApplicator } from './continuous-effect-applicator';
+import { TimeLimitedEffectApplicator } from './time-limited-effect-applicator';
+export const effectApplicators = {
+  instant: InstantEffectApplicator,
+  delayed: DelayedEffectApplicator,
+  periodical: PeriodicalEffectApplicator,
+  continuous: ContinuousEffectApplicator,
+  timeLimited: TimeLimitedEffectApplicator
+};

package/build/systems/effects-system/effect-applicators/instant-effect-applicator.d.ts

@@ -0,0 +1,9 @@
+import type { Actor } from 'dacha';
+import type { EffectScript } from '../effect-script';
+import { EffectApplicator } from './effect-applicator';
+export declare class InstantEffectApplicator extends EffectApplicator {
+    isFinished: boolean;
+    constructor(script: EffectScript, actor: Actor);
+    update(): void;
+    cancel(): void;
+}

package/build/systems/effects-system/effect-applicators/instant-effect-applicator.js

@@ -0,0 +1,18 @@
+import { EffectApplicator } from './effect-applicator';
+export class InstantEffectApplicator extends EffectApplicator {
+  constructor(script, actor) {
+    super(script, actor);
+    this.isFinished = false;
+  }
+  update() {
+    if (this.isFinished) {
+      return;
+    }
+    this.script.apply();
+    this.handleApply();
+    this.isFinished = true;
+  }
+  cancel() {
+    this.handleCancel();
+  }
+}

package/build/systems/effects-system/effect-applicators/periodical-effect-applicator.d.ts

@@ -0,0 +1,9 @@
+import type { Actor } from 'dacha';
+import type { EffectScript } from '../effect-script';
+import { EffectApplicator } from './effect-applicator';
+export declare class PeriodicalEffectApplicator extends EffectApplicator {
+    isFinished: boolean;
+    constructor(script: EffectScript, actor: Actor);
+    update(deltaTime: number): void;
+    cancel(): void;
+}

package/build/systems/effects-system/effect-applicators/periodical-effect-applicator.js

@@ -0,0 +1,29 @@
+import { Effect } from '../../../components';
+import { EffectApplicator } from './effect-applicator';
+export class PeriodicalEffectApplicator extends EffectApplicator {
+  constructor(script, actor) {
+    super(script, actor);
+    this.isFinished = false;
+  }
+  update(deltaTime) {
+    if (this.isFinished) {
+      return;
+    }
+    const applicatorOptions = this.actor.getComponent(Effect).applicatorOptions;
+    applicatorOptions.cooldown -= deltaTime;
+    while (applicatorOptions.cooldown <= 0) {
+      this.script.apply();
+      this.handleApply();
+      applicatorOptions.cooldown += applicatorOptions.frequency;
+    }
+    if (applicatorOptions.duration) {
+      applicatorOptions.duration -= deltaTime;
+      if (applicatorOptions.duration <= 0) {
+        this.isFinished = true;
+      }
+    }
+  }
+  cancel() {
+    this.handleCancel();
+  }
+}

package/build/systems/effects-system/effect-applicators/time-limited-effect-applicator.d.ts

@@ -0,0 +1,10 @@
+import type { Actor } from 'dacha';
+import type { EffectScript } from '../effect-script';
+import { EffectApplicator } from './effect-applicator';
+export declare class TimeLimitedEffectApplicator extends EffectApplicator {
+    isFinished: boolean;
+    isApplied: boolean;
+    constructor(script: EffectScript, actor: Actor);
+    update(deltaTime: number): void;
+    cancel(): void;
+}

package/build/systems/effects-system/effect-applicators/time-limited-effect-applicator.js

@@ -0,0 +1,33 @@
+import { Effect } from '../../../components';
+import { EffectApplicator } from './effect-applicator';
+export class TimeLimitedEffectApplicator extends EffectApplicator {
+  constructor(script, actor) {
+    super(script, actor);
+    this.isApplied = false;
+    this.isFinished = false;
+  }
+  update(deltaTime) {
+    if (this.isFinished) {
+      return;
+    }
+    const applicatorOptions = this.actor.getComponent(Effect).applicatorOptions;
+    applicatorOptions.duration -= deltaTime;
+    if (applicatorOptions.duration <= 0) {
+      this.isFinished = true;
+      return;
+    }
+    if (this.isApplied) {
+      return;
+    }
+    this.script.apply();
+    this.handleApply();
+    this.isApplied = true;
+  }
+  cancel() {
+    if (!this.isApplied) {
+      return;
+    }
+    this.script.onCancel();
+    this.handleCancel();
+  }
+}

package/build/systems/effects-system/effect-script.d.ts

@@ -0,0 +1,4 @@
+export interface EffectScript {
+    apply(): void;
+    onCancel(): void;
+}

package/build/systems/effects-system/effect-script.js

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

package/build/systems/effects-system/effects-system.d.ts

@@ -0,0 +1,19 @@
+import { System } from 'dacha';
+import type { SystemOptions, UpdateOptions } from 'dacha';
+export declare class EffectsSystem extends System {
+    private scene;
+    private activeEffectsCollection;
+    private effectsCollection;
+    private actorSpawner;
+    private scripts;
+    private applicatorsMap;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    private handleActorRemove;
+    private handleAddEffect;
+    private handleRemoveEffect;
+    private cancelEffect;
+    private addEffect;
+    update(options: UpdateOptions): void;
+}

package/build/systems/effects-system/effects-system.js

@@ -0,0 +1,128 @@
+import { ActorCollection, System } from 'dacha';
+import { RemoveActor } from 'dacha/events';
+import * as EventType from '../../events';
+import { ActiveEffects, Effect } from '../../components';
+import { effectApplicators } from './effect-applicators';
+export class EffectsSystem extends System {
+  constructor(options) {
+    super();
+    const {
+      actorSpawner,
+      resources = {},
+      scene
+    } = options;
+    this.scene = scene;
+    this.activeEffectsCollection = new ActorCollection(scene, {
+      components: [ActiveEffects]
+    });
+    this.effectsCollection = new ActorCollection(scene, {
+      components: [Effect]
+    });
+    this.actorSpawner = actorSpawner;
+    this.scripts = resources;
+    this.applicatorsMap = {};
+  }
+  mount() {
+    this.scene.addEventListener(EventType.AddEffect, this.handleAddEffect);
+    this.scene.addEventListener(EventType.RemoveEffect, this.handleRemoveEffect);
+    this.activeEffectsCollection.addEventListener(RemoveActor, this.handleActorRemove);
+  }
+  unmount() {
+    this.scene.removeEventListener(EventType.AddEffect, this.handleAddEffect);
+    this.scene.removeEventListener(EventType.RemoveEffect, this.handleRemoveEffect);
+    this.activeEffectsCollection.removeEventListener(RemoveActor, this.handleActorRemove);
+  }
+  handleActorRemove = event => {
+    const {
+      actor
+    } = event;
+    Object.keys(this.applicatorsMap[actor.id])?.forEach(name => {
+      delete this.applicatorsMap[actor.id][name];
+    });
+  };
+  handleAddEffect = event => {
+    const {
+      id,
+      options,
+      target
+    } = event;
+    this.cancelEffect(id, target);
+    this.addEffect(id, target, options);
+  };
+  handleRemoveEffect = event => {
+    const {
+      id,
+      target
+    } = event;
+    this.cancelEffect(id, target);
+  };
+  cancelEffect(id, actor) {
+    if (!this.applicatorsMap[actor.id] || !this.applicatorsMap[actor.id][id]) {
+      return;
+    }
+    this.applicatorsMap[actor.id][id].cancel();
+    delete this.applicatorsMap[actor.id][id];
+    const activeEffects = actor.getComponent(ActiveEffects);
+    const effectActor = activeEffects.map[id];
+    delete activeEffects.map[id];
+    activeEffects.list = activeEffects.list.filter(activeEffectId => id !== activeEffectId);
+    const effect = effectActor.getComponent(Effect);
+    effect.isCancelled = true;
+  }
+  addEffect(id, actor, options) {
+    const effectActor = this.actorSpawner.spawn(id);
+    actor.appendChild(effectActor);
+    const {
+      script,
+      type,
+      options: constOptions
+    } = effectActor.getComponent(Effect);
+    if (!actor.getComponent(ActiveEffects)) {
+      actor.setComponent(new ActiveEffects());
+    }
+    const activeEffects = actor.getComponent(ActiveEffects);
+    activeEffects.list.push(id);
+    activeEffects.map[id] = effectActor;
+    const EffectScript = this.scripts[script];
+    const EffectApplicator = effectApplicators[type];
+    const effectApplicator = new EffectApplicator(new EffectScript(actor, {
+      ...constOptions,
+      ...options
+    }), effectActor);
+    this.applicatorsMap[actor.id] ??= {};
+    this.applicatorsMap[actor.id][id] = effectApplicator;
+  }
+  update(options) {
+    const {
+      deltaTime
+    } = options;
+    this.effectsCollection.forEach(actor => {
+      const effect = actor.getComponent(Effect);
+      if (!effect.isCancelled) {
+        return;
+      }
+      effect.removeTimeout -= deltaTime;
+      if (effect.removeTimeout <= 0) {
+        actor.remove();
+      }
+    });
+    this.activeEffectsCollection.forEach(actor => {
+      const activeEffects = actor.getComponent(ActiveEffects);
+      activeEffects.list = activeEffects.list.filter(id => {
+        const effectApplicator = this.applicatorsMap[actor.id][id];
+        const effectActor = activeEffects.map[id];
+        const effect = effectActor.getComponent(Effect);
+        effectApplicator.update(deltaTime);
+        if (effectApplicator.isFinished) {
+          effectApplicator.cancel();
+          delete this.applicatorsMap[actor.id][id];
+          delete activeEffects.map[id];
+          effect.isCancelled = true;
+          return false;
+        }
+        return true;
+      });
+    });
+  }
+}
+EffectsSystem.systemName = 'EffectsSystem';

package/build/systems/effects-system/index.d.ts

@@ -0,0 +1,2 @@
+export { EffectsSystem } from './effects-system';
+export type { EffectScript } from './effect-script';

package/build/systems/effects-system/index.js

@@ -0,0 +1 @@
+export { EffectsSystem } from './effects-system';

package/build/systems/index.d.ts

@@ -0,0 +1,3 @@
+export { EffectsSystem } from './effects-system';
+export type { EffectScript } from './effects-system';
+export { ParallaxSystem } from './parallax-system';

package/build/systems/index.js

@@ -0,0 +1,2 @@
+export { EffectsSystem } from './effects-system';
+export { ParallaxSystem } from './parallax-system';

package/build/systems/parallax-system/index.d.ts

@@ -0,0 +1,12 @@
+import { System } from 'dacha';
+import type { SystemOptions } from 'dacha';
+export declare class ParallaxSystem extends System {
+    private actorCollection;
+    private cameraService;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    private handleAddActor;
+    private setStartPosition;
+    update(): void;
+}

package/build/systems/parallax-system/index.js

@@ -0,0 +1,45 @@
+import { ActorCollection, System, CameraService, Transform } from 'dacha';
+import { AddActor } from 'dacha/events';
+import { Parallax } from '../../components';
+export class ParallaxSystem extends System {
+  constructor(options) {
+    super();
+    this.actorCollection = new ActorCollection(options.scene, {
+      components: [Transform, Parallax]
+    });
+    this.cameraService = options.scene.getService(CameraService);
+  }
+  mount() {
+    this.actorCollection.forEach(actor => this.setStartPosition(actor));
+    this.actorCollection.addEventListener(AddActor, this.handleAddActor);
+  }
+  unmount() {
+    this.actorCollection.removeEventListener(AddActor, this.handleAddActor);
+  }
+  handleAddActor = event => {
+    this.setStartPosition(event.actor);
+  };
+  setStartPosition(actor) {
+    const transform = actor.getComponent(Transform);
+    const parallax = actor.getComponent(Parallax);
+    parallax.startX = transform.offsetX;
+    parallax.startY = transform.offsetY;
+  }
+  update() {
+    const currentCamera = this.cameraService.getCurrentCamera();
+    if (!currentCamera) {
+      return;
+    }
+    const {
+      offsetX: cameraOffsetX,
+      offsetY: cameraOffsetY
+    } = currentCamera.getComponent(Transform);
+    this.actorCollection.forEach(actor => {
+      const transform = actor.getComponent(Transform);
+      const parallax = actor.getComponent(Parallax);
+      transform.offsetX = parallax.startX + (cameraOffsetX - parallax.startX) * parallax.distance;
+      transform.offsetY = parallax.startY + (cameraOffsetY - parallax.startY) * parallax.distance;
+    });
+  }
+}
+ParallaxSystem.systemName = 'ParallaxSystem';

package/build/types/utils.d.ts

@@ -0,0 +1 @@
+export type Constructor<T> = new (...args: any[]) => T;

package/build/types/utils.js

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

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "dacha-game-systems",
+  "version": "0.0.2",
+  "exports": {
+    ".": {
+      "require": "./build/index.js",
+      "import": "./build/index.js",
+      "types": "./build/index.d.ts"
+    },
+    "./events": {
+      "require": "./build/events/index.js",
+      "import": "./build/events/index.js",
+      "types": "./build/events/index.d.ts"
+    },
+    "./schema": {
+      "require": "./build/schema/index.js",
+      "import": "./build/schema/index.js",
+      "types": "./build/schema/index.d.ts"
+    }
+  },
+  "devDependencies": {
+    "@babel/cli": "7.16.8",
+    "@babel/core": "7.16.0",
+    "@babel/eslint-parser": "7.16.5",
+    "@babel/preset-typescript": "7.23.3",
+    "@babel/preset-react": "7.24.1",
+    "@types/jest": "29.5.11",
+    "@types/three": "0.150.2",
+    "@types/react": "^18.2.73",
+    "@types/react-dom": "^18.2.23",
+    "eslint": "8.57.0",
+    "eslint-config-airbnb": "19.0.4",
+    "eslint-config-airbnb-typescript": "18.0.0",
+    "eslint-import-resolver-typescript": "3.6.1",
+    "eslint-plugin-import": "2.29.1",
+    "husky": "7.0.4",
+    "jest": "29.7.0",
+    "ts-jest": "29.1.1",
+    "typescript": "5.3.3",
+    "dacha": "0.13.0",
+    "dacha-workbench": "0.0.22",
+    "react": "18.1.0",
+    "react-dom": "18.1.0"
+  },
+  "peerDependencies": {
+    "dacha": ">=0.13.0",
+    "dacha-workbench": ">=0.0.22",
+    "react": ">=18.1.0",
+    "react-dom": ">=18.1.0"
+  },
+  "sideEffects": false,
+  "files": [
+    "build",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "npm run build:clean && npm run build:esm && npm run build:types",
+    "build:clean": "rm -rf build",
+    "build:esm": "npx babel src --out-dir build --extensions \".ts,.js,.tsx,.jsx\" --ignore \"src/**/*.test.ts,src/__mocks__\"",
+    "build:types": "tsc --project tsconfig.types.json",
+    "lint": "eslint .",
+    "test": "jest",
+    "prepare": "husky install",
+    "prepublishOnly": "npm run build"
+  },
+  "description": "Dacha is a JavaScript game engine for building games in browser.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/michailRemmele/dacha-game-systems.git"
+  },
+  "author": "Mikhail Remmele",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/michailRemmele/dacha-game-systems/issues"
+  },
+  "homepage": "https://github.com/michailRemmele/dacha-game-systems#readme"
+}