dacha 0.13.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 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,8 @@
+# Dacha
+
+## Intro
+Dacha is a JavaScript game engine for building games in browser.
+
+## Examples
+* [Roosters Fight](https://github.com/michailRemmele/roosters-fight)
+* [Infinite Battle](https://github.com/michailRemmele/ludum-dare-47)

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

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

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

@@ -0,0 +1,12 @@
+const SEPARATOR = '.';
+export class ComparatorConditionComponentValue {
+    type;
+    value;
+    constructor(config) {
+        const { value, type } = config;
+        this.type = type;
+        this.value = Array.isArray(value)
+            ? value.slice(0)
+            : String(value).split(SEPARATOR);
+    }
+}

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

@@ -0,0 +1,5 @@
+export declare class ComparatorConditionSimpleValue {
+    type: string;
+    value: string | number | boolean;
+    constructor(config: unknown);
+}

package/build/contrib/components/animatable/comparator-condition-number-value.js

@@ -0,0 +1,9 @@
+export class ComparatorConditionSimpleValue {
+    type;
+    value;
+    constructor(config) {
+        const { type, value } = config;
+        this.type = type;
+        this.value = value;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { ComparatorConditionComponentValue } from './comparator-condition-component-value';
+import { ComparatorConditionSimpleValue } from './comparator-condition-number-value';
+import type { OperationType } from './types';
+export declare class ComparatorConditionProps {
+    operation: OperationType;
+    arg1: ComparatorConditionComponentValue | ComparatorConditionSimpleValue;
+    arg2: ComparatorConditionComponentValue | ComparatorConditionSimpleValue;
+    constructor(config: unknown);
+}

package/build/contrib/components/animatable/comparator-condition-props.js

@@ -0,0 +1,12 @@
+import { conditionValues } from './comparator-condition-values';
+export class ComparatorConditionProps {
+    operation;
+    arg1;
+    arg2;
+    constructor(config) {
+        const { operation, arg1, arg2 } = config;
+        this.operation = operation;
+        this.arg1 = new conditionValues[arg1.type](arg1);
+        this.arg2 = new conditionValues[arg2.type](arg2);
+    }
+}

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

@@ -0,0 +1,8 @@
+import { ComparatorConditionSimpleValue } from './comparator-condition-number-value';
+import { ComparatorConditionComponentValue } from './comparator-condition-component-value';
+export declare const conditionValues: {
+    string: typeof ComparatorConditionSimpleValue;
+    number: typeof ComparatorConditionSimpleValue;
+    boolean: typeof ComparatorConditionSimpleValue;
+    componentValue: typeof ComparatorConditionComponentValue;
+};

package/build/contrib/components/animatable/comparator-condition-values.js

@@ -0,0 +1,8 @@
+import { ComparatorConditionSimpleValue } from './comparator-condition-number-value';
+import { ComparatorConditionComponentValue } from './comparator-condition-component-value';
+export const conditionValues = {
+    string: ComparatorConditionSimpleValue,
+    number: ComparatorConditionSimpleValue,
+    boolean: ComparatorConditionSimpleValue,
+    componentValue: ComparatorConditionComponentValue,
+};

package/build/contrib/components/animatable/condition-props.d.ts

@@ -0,0 +1,6 @@
+import { ComparatorConditionProps } from './comparator-condition-props';
+import { EventConditionProps } from './event-condition-props';
+export declare const conditionProps: {
+    comparator: typeof ComparatorConditionProps;
+    event: typeof EventConditionProps;
+};

package/build/contrib/components/animatable/condition-props.js

@@ -0,0 +1,6 @@
+import { ComparatorConditionProps } from './comparator-condition-props';
+import { EventConditionProps } from './event-condition-props';
+export const conditionProps = {
+    comparator: ComparatorConditionProps,
+    event: EventConditionProps,
+};

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

@@ -0,0 +1,9 @@
+import { ComparatorConditionProps } from './comparator-condition-props';
+import { EventConditionProps } from './event-condition-props';
+import type { ConditionConfig } from './types';
+export declare class Condition {
+    id: string;
+    type: 'comparator' | 'event';
+    props: ComparatorConditionProps | EventConditionProps;
+    constructor(config: ConditionConfig);
+}

package/build/contrib/components/animatable/condition.js

@@ -0,0 +1,12 @@
+import { conditionProps } from './condition-props';
+export class Condition {
+    id;
+    type;
+    props;
+    constructor(config) {
+        const { id, type, props = {} } = config;
+        this.id = id;
+        this.type = type;
+        this.props = new conditionProps[type](props);
+    }
+}

package/build/contrib/components/animatable/event-condition-props.d.ts

@@ -0,0 +1,4 @@
+export declare class EventConditionProps {
+    eventType: string;
+    constructor(config: unknown);
+}

package/build/contrib/components/animatable/event-condition-props.js

@@ -0,0 +1,6 @@
+export class EventConditionProps {
+    eventType;
+    constructor(config) {
+        this.eventType = config.eventType;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { State } from './state';
+import { Substate } from './substate';
+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>;
+    pickMode: '1D' | '2D';
+    pickProps: OneDimensionalProps | TwoDimensionalProps;
+    constructor(config: GroupStateConfig);
+}

package/build/contrib/components/animatable/group-state.js

@@ -0,0 +1,16 @@
+import { State } from './state';
+import { Substate } from './substate';
+import { pickProps as defaultPickProps } from './pick-props';
+export class GroupState extends State {
+    substates;
+    pickMode;
+    pickProps;
+    constructor(config) {
+        super(config);
+        const { substates = [], pickMode = '1D', pickProps = {}, } = config;
+        this.substates = substates.map((substate) => new Substate(substate));
+        this.pickMode = pickMode;
+        const PickProps = defaultPickProps[pickMode];
+        this.pickProps = new PickProps(pickProps);
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Component } from '../../../engine/component';
+import { IndividualState } from './individual-state';
+import { GroupState } from './group-state';
+import type { AnimatableConfig } from './types';
+export type { AnimatableConfig };
+export declare class Animatable extends Component {
+    states: Array<IndividualState | GroupState>;
+    initialState: string;
+    currentState?: IndividualState | GroupState;
+    duration: number;
+    constructor(config: AnimatableConfig);
+    setCurrentState(currentState: string): void;
+    clone(): Animatable;
+}

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

@@ -0,0 +1,41 @@
+import { Component } from '../../../engine/component';
+import { IndividualState } from './individual-state';
+import { GroupState } from './group-state';
+export class Animatable extends Component {
+    states;
+    initialState;
+    currentState;
+    duration;
+    constructor(config) {
+        super();
+        const { initialState, states = [], } = config;
+        this.states = states
+            .reduce((acc, state) => {
+            const { type } = state;
+            if (type === 'individual') {
+                acc.push(new IndividualState(state));
+            }
+            if (type === 'group') {
+                acc.push(new GroupState(state));
+            }
+            return acc;
+        }, []);
+        this.initialState = initialState;
+        this.currentState = this.states.find((state) => state.id === this.initialState);
+        this.duration = 0;
+    }
+    setCurrentState(currentState) {
+        const newState = this.states.find((state) => state.id === currentState);
+        if (!newState) {
+            throw new Error(`Can't find state with same name: ${currentState}`);
+        }
+        this.currentState = newState;
+    }
+    clone() {
+        return new Animatable({
+            states: this.states,
+            initialState: this.initialState,
+        });
+    }
+}
+Animatable.componentName = 'Animatable';

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

@@ -0,0 +1,7 @@
+import { State } from './state';
+import { Timeline } from './timeline';
+import type { IndividualStateConfig } from './types';
+export declare class IndividualState extends State {
+    timeline: Timeline;
+    constructor(config: IndividualStateConfig);
+}

package/build/contrib/components/animatable/individual-state.js

@@ -0,0 +1,10 @@
+import { State } from './state';
+import { Timeline } from './timeline';
+export class IndividualState extends State {
+    timeline;
+    constructor(config) {
+        super(config);
+        const { timeline = { frames: [], looped: false } } = config;
+        this.timeline = new Timeline(timeline);
+    }
+}

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

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

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

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

package/build/contrib/components/animatable/pick-props.d.ts

@@ -0,0 +1,6 @@
+import { OneDimensionalProps } from './one-dimensional-props';
+import { TwoDimensionalProps } from './two-dimensional-props';
+export declare const pickProps: {
+    '1D': typeof OneDimensionalProps;
+    '2D': typeof TwoDimensionalProps;
+};

package/build/contrib/components/animatable/pick-props.js

@@ -0,0 +1,6 @@
+import { OneDimensionalProps } from './one-dimensional-props';
+import { TwoDimensionalProps } from './two-dimensional-props';
+export const pickProps = {
+    '1D': OneDimensionalProps,
+    '2D': TwoDimensionalProps,
+};

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

@@ -0,0 +1,10 @@
+import { Transition } from './transition';
+import type { StateConfig } from './types';
+export declare class State {
+    id: string;
+    name: string;
+    speed: number;
+    type: 'individual' | 'group';
+    transitions: Array<Transition>;
+    constructor(config: StateConfig);
+}

package/build/contrib/components/animatable/state.js

@@ -0,0 +1,16 @@
+import { Transition } from './transition';
+export class State {
+    id;
+    name;
+    speed;
+    type;
+    transitions;
+    constructor(config) {
+        const { id, name, speed, type, transitions = [], } = config;
+        this.id = id;
+        this.name = name;
+        this.speed = speed;
+        this.type = type;
+        this.transitions = transitions.map((transition) => new Transition(transition));
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Timeline } from './timeline';
+import type { SubstateConfig } from './types';
+export declare class Substate {
+    name: string;
+    timeline: Timeline;
+    x: number;
+    y: number;
+    constructor(config: SubstateConfig);
+}

package/build/contrib/components/animatable/substate.js

@@ -0,0 +1,13 @@
+import { Timeline } from './timeline';
+export class Substate {
+    name;
+    timeline;
+    x;
+    y;
+    constructor(config) {
+        this.name = config.name;
+        this.timeline = new Timeline(config.timeline);
+        this.x = config.x;
+        this.y = config.y;
+    }
+}

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

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

package/build/contrib/components/animatable/timeline.js

@@ -0,0 +1,28 @@
+const SEPARATOR = '.';
+export class Timeline {
+    frames;
+    looped;
+    constructor(config) {
+        this.frames = config.frames.map((frame) => {
+            if (!Array.isArray(frame.fields)) {
+                // Frame fields already been parsed and we just need to copy it
+                const parsedFrame = frame;
+                return Object.keys(parsedFrame).reduce((acc, fieldName) => {
+                    acc[fieldName] = {
+                        path: parsedFrame[fieldName].path.slice(0),
+                        value: parsedFrame[fieldName].value,
+                    };
+                    return acc;
+                }, {});
+            }
+            return frame.fields.reduce((acc, field) => {
+                acc[field.name] = {
+                    path: field.name.split(SEPARATOR),
+                    value: field.value,
+                };
+                return acc;
+            }, {});
+        });
+        this.looped = config.looped;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Condition } from './condition';
+import type { TransitionConfig } from './types';
+export declare class Transition {
+    id: string;
+    state: string;
+    time: number;
+    conditions: Array<Condition>;
+    constructor(config: TransitionConfig);
+}

package/build/contrib/components/animatable/transition.js

@@ -0,0 +1,14 @@
+import { Condition } from './condition';
+export class Transition {
+    id;
+    state;
+    time;
+    conditions;
+    constructor(config) {
+        const { id, state, time, conditions = [], } = config;
+        this.id = id;
+        this.state = state;
+        this.time = time;
+        this.conditions = conditions.map((condition) => new Condition(condition));
+    }
+}

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

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

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

@@ -0,0 +1,12 @@
+import { OneDimensionalProps } from './one-dimensional-props';
+const SEPARATOR = '.';
+export class TwoDimensionalProps extends OneDimensionalProps {
+    y;
+    constructor(config) {
+        super(config);
+        const { y = '' } = config;
+        this.y = Array.isArray(y)
+            ? y.slice(0)
+            : y.split(SEPARATOR);
+    }
+}

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

@@ -0,0 +1,78 @@
+export interface FrameFieldConfig {
+    id: string;
+    name: string;
+    type: 'string' | 'number' | 'boolean';
+    value: string | number | boolean;
+}
+export interface FrameConfig {
+    id: string;
+    fields: Array<FrameFieldConfig>;
+}
+export interface TimelineConfig {
+    frames: Array<FrameConfig>;
+    looped: boolean;
+}
+export interface ComparatorConditionComponentValueConfig {
+    type: string;
+    value: string | Array<string>;
+}
+export interface ComparatorConditionSimpleValueConfig {
+    type: string;
+    value: string | number | boolean;
+}
+export type OperationType = 'equals' | 'notEquals' | 'greater' | 'less' | 'greaterOrEqual' | 'lessOrEqual';
+export interface ComparatorConditionArg {
+    type: 'string' | 'number' | 'boolean' | 'componentValue';
+    [key: string]: unknown;
+}
+export interface ComparatorConditionPropsConfig {
+    operation: OperationType;
+    arg1: ComparatorConditionArg;
+    arg2: ComparatorConditionArg;
+}
+export interface EventConditionPropsConfig {
+    eventType: string;
+}
+export interface ConditionConfig {
+    id: string;
+    type: 'comparator' | 'event';
+    props: Record<string, unknown>;
+}
+export interface TransitionConfig {
+    id: string;
+    state: string;
+    time: number;
+    conditions: Array<ConditionConfig>;
+}
+export interface StateConfig {
+    id: string;
+    name: string;
+    speed: number;
+    type: 'individual' | 'group';
+    transitions: Array<TransitionConfig>;
+}
+export interface IndividualStateConfig extends StateConfig {
+    timeline: TimelineConfig;
+}
+export interface SubstateConfig {
+    id: string;
+    name: string;
+    timeline: TimelineConfig;
+    x: number;
+    y: number;
+}
+export interface OneDimensionalPropsConfig {
+    x: string | Array<string>;
+}
+export interface TwoDimensionalPropsConfig extends OneDimensionalPropsConfig {
+    y: string | Array<string>;
+}
+export interface GroupStateConfig extends StateConfig {
+    substates: Array<SubstateConfig>;
+    pickMode: '1D' | '2D';
+    pickProps: OneDimensionalPropsConfig | TwoDimensionalPropsConfig;
+}
+export interface AnimatableConfig extends Record<string, unknown> {
+    states: Array<unknown>;
+    initialState: string;
+}

package/build/contrib/components/animatable/types.js

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

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

@@ -0,0 +1,13 @@
+import { Component } from '../../../engine/component';
+export interface CameraConfig {
+    zoom: number;
+    current: boolean;
+}
+export declare class Camera extends Component {
+    zoom: number;
+    current: boolean;
+    windowSizeX: number;
+    windowSizeY: number;
+    constructor(config: CameraConfig);
+    clone(): Camera;
+}

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

@@ -0,0 +1,21 @@
+import { Component } from '../../../engine/component';
+export class Camera extends Component {
+    zoom;
+    current;
+    windowSizeX;
+    windowSizeY;
+    constructor(config) {
+        super();
+        this.current = config.current;
+        this.zoom = config.zoom;
+        this.windowSizeX = 0;
+        this.windowSizeY = 0;
+    }
+    clone() {
+        return new Camera({
+            zoom: this.zoom,
+            current: this.current,
+        });
+    }
+}
+Camera.componentName = 'Camera';

package/build/contrib/components/collider-container/box-collider.d.ts

@@ -0,0 +1,7 @@
+export declare class BoxCollider {
+    sizeX: number;
+    sizeY: number;
+    centerX: number;
+    centerY: number;
+    constructor(config: Record<string, number>);
+}

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

@@ -0,0 +1,12 @@
+export class BoxCollider {
+    sizeX;
+    sizeY;
+    centerX;
+    centerY;
+    constructor(config) {
+        this.sizeX = config.sizeX;
+        this.sizeY = config.sizeY;
+        this.centerX = config.centerX;
+        this.centerY = config.centerY;
+    }
+}

package/build/contrib/components/collider-container/circle-collider.d.ts

@@ -0,0 +1,6 @@
+export declare class CircleCollider {
+    radius: number;
+    centerX: number;
+    centerY: number;
+    constructor(config: Record<string, number>);
+}

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

@@ -0,0 +1,10 @@
+export class CircleCollider {
+    radius;
+    centerX;
+    centerY;
+    constructor(config) {
+        this.radius = config.radius;
+        this.centerX = config.centerX;
+        this.centerY = config.centerY;
+    }
+}

package/build/contrib/components/collider-container/index.d.ts

@@ -0,0 +1,13 @@
+import { Component } from '../../../engine/component';
+import { BoxCollider } from './box-collider';
+import { CircleCollider } from './circle-collider';
+export interface ColliderContainerConfig {
+    type: 'boxCollider' | 'circleCollider';
+    collider: Record<string, number>;
+}
+export declare class ColliderContainer extends Component {
+    type: 'boxCollider' | 'circleCollider';
+    collider: BoxCollider | CircleCollider;
+    constructor(config: ColliderContainerConfig);
+    clone(): ColliderContainer;
+}