@combos-fun/engine 0.0.1

package/dist/engine.esm.js

@@ -0,0 +1,1664 @@
+import EventEmitter from 'eventemitter3';
+import { isEqual, isObject } from 'lodash-es';
+import { __decorate } from 'tslib';
+import { type, step } from '@combos-fun/inspector-decorator';
+import { ResourceState, ResourceType, Resource as Resource$1, Loader, XhrLoadStrategy, VideoLoadStrategy, MediaElementLoadStrategy, XhrResponseType, ImageLoadStrategy, AudioLoadStrategy, AbstractLoadStrategy } from 'resource-loader';
+
+/**
+ * Get component name from component instance or Component class
+ * @param component - component instance or Component class
+ * @returns component' name
+ * @example
+ * ```typescript
+ * import { Transform } from '@combos-fun/engine'
+ *
+ * assert(getComponentName(Transform) === 'Transform')
+ * assert(getComponentName(new Transform()) === 'Transform')
+ * ```
+ */
+function getComponentName(component) {
+    if (component instanceof Component) {
+        return component.name;
+    }
+    else if (component instanceof Function) {
+        return component.componentName;
+    }
+}
+/**
+ * Component contain raw data apply to gameObject and how it interacts with the world
+ * @public
+ */
+class Component extends EventEmitter {
+    constructor(params) {
+        super();
+        /**
+         * Represents the status of the component, If component has started, the value is true
+         * @defaultValue false
+         */
+        this.started = false;
+        const Ctor = this.constructor;
+        this.name = Ctor.componentName;
+        this.__componentDefaultParams = params;
+    }
+}
+
+/** Observer event type */
+var ObserverType;
+(function (ObserverType) {
+    ObserverType["ADD"] = "ADD";
+    ObserverType["REMOVE"] = "REMOVE";
+    ObserverType["CHANGE"] = "CHANGE";
+})(ObserverType || (ObserverType = {}));
+const objectCache = {};
+const systemInstance = {};
+const observerInfos = {};
+const componentProps = {};
+/**
+ * Get the `ObjectCache` on `component` access by `keys`
+ * @example
+ * ```typescript
+ * getObjectCache(testComponent, ['style', 'transform', 'scale'])
+ * ```
+ * @param {Component} component
+ * @param {string[]} keys - access path to properties, such as ['style', 'transform', 'scale', 'x']
+ * @returns {ObservableItem}
+ */
+function getObjectCache(component, keys) {
+    if (!objectCache[component.gameObject.id]) {
+        objectCache[component.gameObject.id] = {};
+    }
+    const cache = objectCache[component.gameObject.id];
+    const key = component.name + '_' + keys.join(',');
+    if (cache[key]) {
+        return cache[key];
+    }
+    const keyIndex = keys.length - 1;
+    let property = component;
+    // FIXME: Bug is here, property[keys[i]] maybe undefined
+    for (let i = 0; i < keyIndex; i++) {
+        property = property[keys[i]];
+    }
+    cache[key] = { property, key: keys[keyIndex] };
+    return cache[key];
+}
+/**
+ * Remove property cache by component
+ * @remarks
+ * The component should added to a gameObject, otherwise there is no gameObject on component
+ * @param {Component} component - a component that has been added to gameObject
+ */
+function removeObjectCache(component) {
+    if (component.gameObject) {
+        delete objectCache[component.gameObject.id];
+    }
+}
+/**
+ * Add observe event to `componentObserver` on system
+ * @param {string} param0.systemName - system name
+ * @param {string} param0.componentName - compnent name
+ * @param {Component} param0.component - component instance
+ * @param {pureObserverProp} param0.prop - pure observer prop
+ * @param {ObserverType} param0.type - observer type
+ */
+function addObserver({ systemName, componentName, component, prop, type }) {
+    systemInstance[systemName]?.componentObserver?.add({
+        component,
+        prop,
+        type,
+        componentName,
+    });
+}
+function pushToQueue({ prop, component, componentName, }) {
+    for (const systemName in observerInfos) {
+        const observerInfo = observerInfos[systemName] || {};
+        const info = observerInfo[componentName];
+        if (!info)
+            continue;
+        const index = info.findIndex(p => {
+            return isEqual(p, prop);
+        });
+        if (index > -1) {
+            addObserver({
+                systemName,
+                componentName,
+                component,
+                prop,
+                type: ObserverType.CHANGE,
+            });
+        }
+    }
+}
+/**
+ * Define property `key` for obj, make `key` observable
+ * @param {Object} param0.obj - object contains the 'key'
+ * @param {string} param0.key - the key will be observed
+ * @param {PureObserverProp} param0.prop
+ * @param {Component} param0.component
+ * @param {strng} param0.componentName
+ */
+function defineProperty({ obj, key, prop, component, componentName, }) {
+    if (obj === undefined) {
+        return;
+    }
+    if (!(key in obj)) {
+        console.error(`prop ${key} not in component: ${componentName}, Can not observer`);
+        return;
+    }
+    Object.defineProperty(obj, `_${key}`, {
+        enumerable: false,
+        writable: true,
+        value: obj[key],
+    });
+    if (prop.deep && isObject(obj[key])) {
+        for (const childKey of Object.keys(obj[key])) {
+            defineProperty({
+                obj: obj[key],
+                key: childKey, // Bug is here
+                prop,
+                component,
+                componentName,
+            });
+        }
+    }
+    Object.defineProperty(obj, key, {
+        enumerable: true,
+        set(val) {
+            if (obj[`_${key}`] === val)
+                return;
+            obj[`_${key}`] = val;
+            pushToQueue({ prop, component, componentName });
+        },
+        get() {
+            return obj[`_${key}`];
+        },
+    });
+}
+/**
+ * Return true if parameter is a component
+ * @param comp - any thing
+ * @returns {bool}
+ */
+function isComponent(comp) {
+    return comp && comp.constructor && 'componentName' in comp.constructor;
+}
+/**
+ * Collect observerInfo on system
+ * @param Systems - array of system or just a system
+ */
+function initObserver(Systems) {
+    const Ss = [];
+    if (Systems instanceof Array) {
+        Ss.push(...Systems);
+    }
+    else {
+        Ss.push(Systems);
+    }
+    for (const S of Ss) {
+        for (const componentName in S.observerInfo) {
+            componentProps[componentName] = componentProps[componentName] || [];
+            const props = componentProps[componentName];
+            for (const prop of S.observerInfo[componentName]) {
+                const index = props.findIndex(p => {
+                    return isEqual(p, prop);
+                });
+                if (index === -1) {
+                    componentProps[componentName].push(prop);
+                }
+            }
+        }
+    }
+}
+/**
+ * Make component observerable
+ * @remarks
+ * Throw an error if component not added to a gameObject
+ * @param {Component} component
+ * @param {string} componentName - default value is `component.name`, it will be deprecated
+ */
+function observer(component, componentName = component.name) {
+    if (!componentName || !componentProps[componentName]) {
+        return;
+    }
+    if (!component || !isComponent(component)) {
+        throw new Error('component param must be an instance of Component');
+    }
+    if (!component.gameObject || !component.gameObject.id) {
+        throw new Error('component should be add to a gameObject');
+    }
+    for (const item of componentProps[componentName]) {
+        const { property, key } = getObjectCache(component, item.prop);
+        defineProperty({
+            obj: property,
+            key,
+            prop: item,
+            component,
+            componentName,
+        });
+    }
+}
+/**
+ * Push a `Add` event to componentObserver
+ * @param component
+ * @param componentName - default value is `component.name`, it will be deprecated
+ */
+function observerAdded(component, componentName = component.name) {
+    for (const systemName in observerInfos) {
+        const observerInfo = observerInfos[systemName] || {};
+        const info = observerInfo[componentName];
+        if (info) {
+            systemInstance[systemName]?.componentObserver?.add({
+                component,
+                type: ObserverType.ADD,
+                componentName,
+            });
+        }
+    }
+}
+/**
+ * Push a `Remove` event to componentObserver
+ * @param component
+ * @param componentName - default value is `component.name`, it will be deprecated
+ */
+function observerRemoved(component, componentName = component.name) {
+    for (const systemName in observerInfos) {
+        const observerInfo = observerInfos[systemName] || {};
+        const info = observerInfo[componentName];
+        if (info) {
+            systemInstance[systemName]?.componentObserver?.add({
+                component,
+                type: ObserverType.REMOVE,
+                componentName,
+            });
+        }
+    }
+    removeObjectCache(component);
+}
+/**
+ * Collect observerInfo from system
+ * @param system - system instance
+ * @param S - system constructor
+ */
+function setSystemObserver(system, S) {
+    observerInfos[S.systemName] = S.observerInfo;
+    systemInstance[S.systemName] = system;
+}
+
+/** Basic component for gameObject, See {@link TransformParams}  */
+class Transform extends Component {
+    constructor() {
+        super(...arguments);
+        this.name = 'Transform';
+        this._parent = null;
+        /** Whether this transform in a scene object */
+        this.inScene = false;
+        /** Child transform components */
+        this.children = [];
+        this.position = { x: 0, y: 0 };
+        this.size = { width: 0, height: 0 };
+        this.origin = { x: 0, y: 0 };
+        this.anchor = { x: 0, y: 0 };
+        this.scale = { x: 1, y: 1 };
+        this.skew = { x: 0, y: 0 };
+        this.rotation = 0;
+    }
+    /**
+     * component's name
+     * @readonly
+     */
+    static { this.componentName = 'Transform'; }
+    /**
+     * Init component
+     * @param params - Transform init data
+     */
+    init(params = {}) {
+        const props = ['position', 'size', 'origin', 'anchor', 'scale', 'skew'];
+        for (const key of props) {
+            Object.assign(this[key], params[key]);
+        }
+        this.rotation = params.rotation || this.rotation;
+    }
+    set parent(val) {
+        if (val) {
+            val.addChild(this);
+        }
+        else if (this.parent) {
+            this.parent.removeChild(this);
+        }
+    }
+    /**
+     * Get parent of this component
+     */
+    get parent() {
+        return this._parent;
+    }
+    /**
+     * Add Child Transform
+     * @remarks
+     * If `child` is already a child of this component, `child` will removed to the last of children list
+     * If `child` is already a child of other component, `child` will removed from its parent first
+     * @param child - child gameObject's transform component
+     */
+    addChild(child) {
+        if (child.parent === this) {
+            const index = this.children.findIndex(item => item === child);
+            this.children.splice(index, 1);
+        }
+        else if (child.parent) {
+            child.parent.removeChild(child);
+        }
+        child._parent = this;
+        this.children.push(child);
+    }
+    /**
+     * Remove child transform
+     * @param child - child gameObject's transform component
+     */
+    removeChild(child) {
+        const index = this.children.findIndex(item => item === child);
+        if (index > -1) {
+            this.children.splice(index, 1);
+            child._parent = null;
+        }
+    }
+    /** Clear all child transform */
+    clearChildren() {
+        this.children.length = 0;
+    }
+}
+__decorate([
+    type('vector2'),
+    step(1)
+], Transform.prototype, "position", void 0);
+__decorate([
+    type('size'),
+    step(1)
+], Transform.prototype, "size", void 0);
+__decorate([
+    type('vector2'),
+    step(0.1)
+], Transform.prototype, "origin", void 0);
+__decorate([
+    type('vector2'),
+    step(0.1)
+], Transform.prototype, "anchor", void 0);
+__decorate([
+    type('vector2'),
+    step(0.1)
+], Transform.prototype, "scale", void 0);
+__decorate([
+    type('vector2'),
+    step(0.1)
+], Transform.prototype, "skew", void 0);
+__decorate([
+    type('number'),
+    step(0.1)
+], Transform.prototype, "rotation", void 0);
+
+let _id = 0;
+/** Generate unique id for gameObject */
+function getId() {
+    return ++_id;
+}
+/**
+ * GameObject is a general purpose object. It consists of a unique id and components.
+ * @public
+ */
+class GameObject {
+    /**
+     * Consruct a new gameObject
+     * @param name - the name of this gameObject
+     * @param obj - optional transform parameters for default Transform component
+     */
+    constructor(name, obj) {
+        /** A key-value map for components on this gameObject */
+        this._componentCache = {};
+        /** Components apply to this gameObject */
+        this.components = [];
+        /** GameObject has been destroyed */
+        this.destroyed = false;
+        this._name = name;
+        this.id = getId();
+        this.addComponent(Transform, obj);
+    }
+    /**
+     * Get default transform component
+     * @returns transform component on this gameObject
+     * @readonly
+     */
+    get transform() {
+        return this.getComponent(Transform);
+    }
+    /**
+     * Get parent gameObject
+     * @returns parent gameObject
+     * @readonly
+     */
+    get parent() {
+        return this.transform && this.transform.parent && this.transform.parent.gameObject;
+    }
+    /**
+     * Get the name of this gameObject
+     * @readonly
+     */
+    get name() {
+        return this._name;
+    }
+    set scene(val) {
+        if (this._scene === val)
+            return;
+        const scene = this._scene;
+        this._scene = val;
+        if (this.transform && this.transform.children) {
+            for (const child of this.transform.children) {
+                child.gameObject.scene = val;
+            }
+        }
+        if (val) {
+            val.addGameObject(this);
+        }
+        else {
+            scene && scene.removeGameObject(this);
+        }
+    }
+    /**
+     * Get the scene which this gameObject added on
+     * @returns scene
+     * @readonly
+     */
+    get scene() {
+        return this._scene;
+    }
+    /**
+     * Add child gameObject
+     * @param gameObject - child gameobject
+     */
+    addChild(gameObject) {
+        if (!gameObject || !gameObject.transform || gameObject === this)
+            return;
+        if (!(gameObject instanceof GameObject)) {
+            throw new Error('addChild only receive GameObject');
+        }
+        if (!this.transform) {
+            throw new Error(`gameObject '${this.name}' has been destroy`);
+        }
+        gameObject.transform.parent = this.transform;
+        gameObject.scene = this.scene;
+    }
+    /**
+     * Remove child gameObject
+     * @param gameObject - child gameobject
+     */
+    removeChild(gameObject) {
+        if (!(gameObject instanceof GameObject) || !gameObject.parent || gameObject.parent !== this) {
+            return gameObject;
+        }
+        gameObject.transform.parent = null;
+        gameObject.scene = null;
+        return gameObject;
+    }
+    addComponent(C, obj) {
+        if (this.destroyed)
+            return;
+        const componentName = getComponentName(C);
+        if (this._componentCache[componentName])
+            return;
+        let component;
+        if (C instanceof Function) {
+            component = new C(obj);
+        }
+        else if (C instanceof Component) {
+            component = C;
+        }
+        else {
+            throw new Error('addComponent recieve Component and Component Constructor');
+        }
+        if (component.gameObject) {
+            throw new Error(`component has been added on gameObject ${component.gameObject.name}`);
+        }
+        component.gameObject = this;
+        component.init && component.init(component.__componentDefaultParams);
+        observerAdded(component, component.name);
+        observer(component, component.name);
+        this.components.push(component);
+        this._componentCache[componentName] = component;
+        component.awake && component.awake();
+        return component;
+    }
+    removeComponent(c) {
+        let componentName;
+        if (typeof c === 'string') {
+            componentName = c;
+        }
+        else if (c instanceof Component) {
+            componentName = c.name;
+        }
+        else if (c.componentName) {
+            componentName = c.componentName;
+        }
+        if (componentName === 'Transform') {
+            throw new Error("Transform can't be removed");
+        }
+        return this._removeComponent(componentName);
+    }
+    _removeComponent(componentName) {
+        const index = this.components.findIndex(({ name }) => name === componentName);
+        if (index === -1)
+            return;
+        const component = this.components.splice(index, 1)[0];
+        delete this._componentCache[componentName];
+        delete component.__componentDefaultParams;
+        component.onDestroy && component.onDestroy();
+        observerRemoved(component, componentName);
+        component.gameObject = undefined;
+        return component;
+    }
+    getComponent(c) {
+        let componentName;
+        if (typeof c === 'string') {
+            componentName = c;
+        }
+        else if (c instanceof Component) {
+            componentName = c.name;
+        }
+        else if (c.componentName) {
+            componentName = c.componentName;
+        }
+        if (typeof this._componentCache[componentName] !== 'undefined') {
+            return this._componentCache[componentName];
+        }
+        else {
+            return;
+        }
+    }
+    /**
+     * Remove this gameObject on its parent
+     * @returns return this gameObject
+     */
+    remove() {
+        if (this.parent)
+            return this.parent.removeChild(this);
+    }
+    /** Destory this gameObject */
+    destroy() {
+        if (!this.transform) {
+            console.error('Cannot destroy gameObject that have already been destroyed.');
+            return;
+        }
+        Array.from(this.transform.children).forEach(({ gameObject }) => {
+            gameObject.destroy();
+        });
+        this.remove();
+        this.transform.clearChildren();
+        for (const key in this._componentCache) {
+            this._removeComponent(key);
+        }
+        this.components.length = 0;
+        this.destroyed = true;
+    }
+}
+
+/**
+ * Management observe events
+ * @remarks
+ * See {@link System} for more details
+ * @public
+ */
+class ComponentObserver {
+    constructor() {
+        /**
+         * Component property change events
+         * @defaultValue []
+         */
+        this.events = [];
+    }
+    /**
+     * Add event
+     * @remarks
+     * The same event will be placed last
+     * @param component - changed component
+     * @param prop - changed property on `component`
+     * @param type - change event type
+     * @param componentName - `component.name` this parameter will deprecated
+     */
+    add({ component, prop, type, componentName }) {
+        if (type === ObserverType.REMOVE) {
+            if (this.events.find((changed) => changed.component === component && changed.type === ObserverType.ADD)) {
+                this.events = this.events.filter(changed => changed.component !== component);
+                return;
+            }
+            this.events = this.events.filter(changed => changed.component !== component);
+        }
+        const index = this.events.findIndex(changed => changed.component === component && isEqual(changed.prop, prop) && changed.type === type);
+        if (index > -1) {
+            this.events.splice(index, 1);
+        }
+        this.events.push({
+            gameObject: component.gameObject,
+            component,
+            prop: prop,
+            type,
+            componentName,
+        });
+    }
+    /** Return change events */
+    getChanged() {
+        return this.events;
+    }
+    /**
+     * Return change events
+     * @readonly
+     */
+    get changed() {
+        return this.events;
+    }
+    /** Clear events */
+    clear() {
+        const events = this.events;
+        this.events = [];
+        return events;
+    }
+}
+
+/**
+ * Each System runs continuously and performs global actions on every Entity that possesses a Component of the same aspect as that System.
+ * @public
+ */
+class System {
+    constructor(params) {
+        /** Represents the status of the component, if component has started, the value is true */
+        this.started = false;
+        this.componentObserver = new ComponentObserver();
+        this.__systemDefaultParams = params;
+        const Ctor = this.constructor;
+        this.name = Ctor.systemName;
+    }
+    /** Default destory method */
+    destroy() {
+        this.componentObserver = null;
+        this.__systemDefaultParams = null;
+        this.onDestroy?.();
+    }
+}
+
+function createNowTime() {
+    let nowtime = null;
+    if (Date.now) {
+        nowtime = Date.now;
+    }
+    else {
+        nowtime = () => new Date().getTime();
+    }
+    return nowtime;
+}
+
+const _nowtime = createNowTime();
+const defaultOptions$1 = {
+    originTime: 0,
+    playbackRate: 1.0,
+};
+class Timeline {
+    constructor(options, parent) {
+        if (options instanceof Timeline) {
+            parent = options;
+            options = {};
+        }
+        options = Object.assign({}, defaultOptions$1, options);
+        if (parent) {
+            this._parent = parent;
+        }
+        this._createTime = _nowtime();
+        this._timeMark = [
+            {
+                globalTime: this.globalTime,
+                localTime: -options.originTime,
+                entropy: -options.originTime,
+                playbackRate: options.playbackRate,
+                globalEntropy: 0,
+            },
+        ];
+        if (this._parent) {
+            this._timeMark[0].globalEntropy = this._parent.entropy;
+        }
+        this._playbackRate = options.playbackRate;
+    }
+    get globalTime() {
+        return this.parent ? this.parent.currentTime : _nowtime() - this._createTime;
+    }
+    get parent() {
+        return this._parent;
+    }
+    get lastTimeMark() {
+        return this._timeMark[this._timeMark.length - 1];
+    }
+    markTime({ time = this.currentTime, entropy = this.entropy, playbackRate = this.playbackRate } = {}) {
+        const timeMark = {
+            globalTime: this.globalTime,
+            localTime: time,
+            entropy,
+            playbackRate,
+            globalEntropy: this.globalEntropy,
+        };
+        this._timeMark.push(timeMark);
+    }
+    get currentTime() {
+        const { localTime, globalTime } = this.lastTimeMark;
+        return localTime + (this.globalTime - globalTime) * this.playbackRate;
+    }
+    set currentTime(time) {
+        this.markTime({ time });
+    }
+    get globalEntropy() {
+        return this._parent ? this._parent.entropy : this.globalTime;
+    }
+    get entropy() {
+        const { entropy, globalEntropy } = this.lastTimeMark;
+        return entropy + Math.abs((this.globalEntropy - globalEntropy) * this.playbackRate);
+    }
+    // eslint-disable-next-line @typescript-eslint/adjacent-overload-signatures
+    set entropy(entropy) {
+        if (this.entropy > entropy) {
+            const idx = this.seekTimeMark(entropy);
+            this._timeMark.length = idx + 1;
+        }
+        this.markTime({ entropy });
+    }
+    fork(options) {
+        return new Timeline(options, this);
+    }
+    seekGlobalTime(seekEntropy) {
+        const idx = this.seekTimeMark(seekEntropy), timeMark = this._timeMark[idx];
+        const { entropy, playbackRate, globalTime } = timeMark;
+        return globalTime + (seekEntropy - entropy) / Math.abs(playbackRate);
+    }
+    seekLocalTime(seekEntropy) {
+        const idx = this.seekTimeMark(seekEntropy), timeMark = this._timeMark[idx];
+        const { localTime, entropy, playbackRate } = timeMark;
+        if (playbackRate > 0) {
+            return localTime + (seekEntropy - entropy);
+        }
+        return localTime - (seekEntropy - entropy);
+    }
+    seekTimeMark(entropy) {
+        const timeMark = this._timeMark;
+        let l = 0, r = timeMark.length - 1;
+        if (entropy <= timeMark[l].entropy) {
+            return l;
+        }
+        if (entropy >= timeMark[r].entropy) {
+            return r;
+        }
+        let m = Math.floor((l + r) / 2); // binary search
+        while (m > l && m < r) {
+            if (entropy === timeMark[m].entropy) {
+                return m;
+            }
+            if (entropy < timeMark[m].entropy) {
+                r = m;
+            }
+            else if (entropy > timeMark[m].entropy) {
+                l = m;
+            }
+            m = Math.floor((l + r) / 2);
+        }
+        return l;
+    }
+    get playbackRate() {
+        return this._playbackRate;
+    }
+    set playbackRate(rate) {
+        if (rate !== this.playbackRate) {
+            this.markTime({ playbackRate: rate });
+            this._playbackRate = rate;
+        }
+    }
+    get paused() {
+        if (this.playbackRate === 0)
+            return true;
+        let parent = this.parent;
+        while (parent) {
+            if (parent.playbackRate === 0)
+                return true;
+            parent = parent.parent;
+        }
+        return false;
+    }
+}
+
+/** Default Ticker Options */
+const defaultOptions = {
+    autoStart: true,
+    frameRate: 60,
+};
+/**
+ * Timeline tool
+ */
+class Ticker {
+    /**
+     * @param autoStart - auto start game
+     * @param frameRate - game frame rate
+     */
+    constructor(options) {
+        options = Object.assign({}, defaultOptions, options);
+        this._frameCount = 0;
+        this._frameDuration = 1000 / options.frameRate;
+        this.autoStart = options.autoStart;
+        this.frameRate = options.frameRate;
+        this.timeline = new Timeline({ originTime: 0, playbackRate: 1.0 });
+        this._lastFrameTime = this.timeline.currentTime;
+        this._tickers = new Set();
+        this._requestId = null;
+        this._ticker = () => {
+            if (this._started) {
+                this._requestId = requestAnimationFrame(this._ticker);
+                this.update();
+            }
+        };
+        if (this.autoStart) {
+            this.start();
+        }
+    }
+    /** Main loop, all _tickers will called in this method */
+    update() {
+        const currentTime = this.timeline.currentTime;
+        const durationTime = currentTime - this._lastFrameTime;
+        if (durationTime >= this._frameDuration) {
+            const frameTime = currentTime - (durationTime % this._frameDuration);
+            const deltaTime = frameTime - this._lastFrameTime;
+            this._lastFrameTime = frameTime;
+            const options = {
+                deltaTime,
+                time: frameTime,
+                currentTime: frameTime,
+                frameCount: ++this._frameCount,
+                fps: Math.round(1000 / deltaTime),
+            };
+            for (const func of this._tickers) {
+                if (typeof func === 'function') {
+                    func(options);
+                }
+            }
+        }
+    }
+    /** Add ticker function */
+    add(fn) {
+        this._tickers.add(fn);
+    }
+    /** Remove ticker function */
+    remove(fn) {
+        this._tickers.delete(fn);
+    }
+    /** Start main loop */
+    start() {
+        if (this._started)
+            return;
+        this._started = true;
+        this.timeline.playbackRate = 1.0;
+        this._requestId = requestAnimationFrame(this._ticker);
+    }
+    /** Pause main loop */
+    pause() {
+        this._started = false;
+        this.timeline.playbackRate = 0;
+    }
+    setPlaybackRate(rate) {
+        this.timeline.playbackRate = rate;
+    }
+}
+
+/**
+ * Scene is a gameObject container
+ */
+class Scene extends GameObject {
+    constructor(name, obj) {
+        super(name, obj);
+        this.gameObjects = [];
+        this.scene = this; // gameObject.scene = this
+    }
+    /**
+     * Add gameObject
+     * @param gameObject - game object
+     */
+    addGameObject(gameObject) {
+        this.gameObjects.push(gameObject);
+        if (gameObject.transform) {
+            gameObject.transform.inScene = true;
+        }
+    }
+    /**
+     * Remove gameObject
+     * @param gameObject - game object
+     */
+    removeGameObject(gameObject) {
+        const index = this.gameObjects.indexOf(gameObject);
+        if (index === -1)
+            return;
+        if (gameObject.transform) {
+            gameObject.transform.inScene = false;
+        }
+        this.gameObjects.splice(index, 1);
+    }
+    /**
+     * Destroy scene
+     */
+    destroy() {
+        this.scene = null;
+        super.destroy();
+        this.gameObjects = null;
+        this.canvas = null;
+    }
+}
+
+function systemClassName(ctor) {
+    if ('systemName' in ctor) {
+        const sn = ctor.systemName;
+        if (typeof sn === 'string')
+            return sn;
+    }
+    return 'UnknownSystem';
+}
+function componentClassName(ctor) {
+    if ('componentName' in ctor) {
+        const cn = ctor.componentName;
+        if (typeof cn === 'string')
+            return cn;
+    }
+    return 'UnknownComponent';
+}
+var LOAD_SCENE_MODE;
+(function (LOAD_SCENE_MODE) {
+    LOAD_SCENE_MODE["SINGLE"] = "SINGLE";
+    LOAD_SCENE_MODE["MULTI_CANVAS"] = "MULTI_CANVAS";
+})(LOAD_SCENE_MODE || (LOAD_SCENE_MODE = {}));
+const triggerStart = (obj) => {
+    if (!(obj instanceof System) && !(obj instanceof Component))
+        return;
+    if (obj.started)
+        return;
+    obj.started = true;
+    try {
+        obj.start && obj.start();
+    }
+    catch (e) {
+        if (obj instanceof Component) {
+            console.error(`${componentClassName(obj.constructor)} start error`, e);
+        }
+        else {
+            console.error(`${systemClassName(obj.constructor)} start error`, e);
+        }
+    }
+};
+const getAllGameObjects = game => {
+    const mainSceneGameObjects = game?.scene?.gameObjects || [];
+    const gameObjectsArray = game?.multiScenes.map(({ gameObjects }) => gameObjects);
+    let otherSceneGameObjects = [];
+    for (const gameObjects of gameObjectsArray) {
+        otherSceneGameObjects = [...otherSceneGameObjects, ...gameObjects];
+    }
+    return [...mainSceneGameObjects, ...otherSceneGameObjects];
+};
+const gameObjectLoop = (e, gameObjects = []) => {
+    for (const gameObject of gameObjects) {
+        for (const component of gameObject.components) {
+            try {
+                triggerStart(component);
+                component.update && component.update(e);
+            }
+            catch (e) {
+                console.error(`gameObject: ${gameObject.name} ${component.name} update error`, e);
+            }
+        }
+    }
+    for (const gameObject of gameObjects) {
+        for (const component of gameObject.components) {
+            try {
+                component.lateUpdate && component.lateUpdate(e);
+            }
+            catch (e) {
+                console.error(`gameObject: ${gameObject.name} ${component.name} lateUpdate error`, e);
+            }
+        }
+    }
+};
+const gameObjectResume = gameObjects => {
+    for (const gameObject of gameObjects) {
+        for (const component of gameObject.components) {
+            try {
+                component.onResume && component.onResume();
+            }
+            catch (e) {
+                console.error(`gameObject: ${gameObject.name}, ${component.name}, onResume error`, e);
+            }
+        }
+    }
+};
+const gameObjectPause = gameObjects => {
+    for (const gameObject of gameObjects) {
+        for (const component of gameObject.components) {
+            try {
+                component.onPause && component.onPause();
+            }
+            catch (e) {
+                console.error(`gameObject: ${gameObject.name}, ${component.name}, onResume error`, e);
+            }
+        }
+    }
+};
+class Game extends EventEmitter {
+    constructor({ systems, frameRate = 60, autoStart = true, needScene = true, onSystemsBootstrapComplete, } = {}) {
+        super();
+        /**
+         * State of game
+         * @defaultValue false
+         */
+        this.playing = false;
+        this.started = false;
+        this.multiScenes = [];
+        /** Systems alled to this game */
+        this.systems = [];
+        this.ticker = new Ticker({ autoStart: false, frameRate });
+        this.initTicker();
+        if (systems && systems.length) {
+            const systemsToAdd = [...systems];
+            void this.bootstrapSystemsAndMaybeStart(systemsToAdd, needScene, autoStart, onSystemsBootstrapComplete);
+        }
+        else {
+            onSystemsBootstrapComplete?.(this);
+        }
+    }
+    /** When `systems` is passed in the constructor, run async `init` for each before `loadScene` / `start`. */
+    async bootstrapSystemsAndMaybeStart(systemsToAdd, needScene, autoStart, onComplete) {
+        let error;
+        try {
+            for (const system of systemsToAdd) {
+                await this.addSystem(system);
+            }
+            if (needScene) {
+                this.loadScene(new Scene('scene'));
+            }
+            if (autoStart) {
+                this.start();
+            }
+        }
+        catch (e) {
+            error = e;
+            console.error('Game bootstrap failed', e);
+        }
+        finally {
+            onComplete?.(this, error);
+        }
+    }
+    /**
+     * Get scene on this game
+     */
+    get scene() {
+        return this._scene;
+    }
+    set scene(scene) {
+        this._scene = scene;
+    }
+    get gameObjects() {
+        return getAllGameObjects(this);
+    }
+    /**
+     * Add system
+     * @param S - system instance or system Class
+     * @typeParam T - system which extends base `System` class
+     * @typeparam U - type of system class
+     */
+    async addSystem(S, obj) {
+        let system;
+        if (S instanceof Function) {
+            system = new S(obj);
+        }
+        else if (S instanceof System) {
+            system = S;
+        }
+        else {
+            console.warn('can only add System');
+            return;
+        }
+        const hasTheSystem = this.systems.find(item => {
+            return item.constructor === system.constructor;
+        });
+        if (hasTheSystem) {
+            console.warn(`${systemClassName(system.constructor)} System has been added`);
+            return;
+        }
+        system.game = this;
+        if (system.init) {
+            await Promise.resolve(system.init(system.__systemDefaultParams));
+        }
+        setSystemObserver(system, system.constructor);
+        initObserver(system.constructor);
+        try {
+            system.awake && system.awake();
+        }
+        catch (e) {
+            console.error(`${systemClassName(system.constructor)} awake error`, e);
+        }
+        this.systems.push(system);
+        return system;
+    }
+    /**
+     * Remove system from this game
+     * @param system - one of system instance / system Class or system name
+     */
+    removeSystem(system) {
+        if (!system)
+            return;
+        let index = -1;
+        if (typeof system === 'string') {
+            index = this.systems.findIndex(s => s.name === system);
+        }
+        else if (system instanceof Function) {
+            index = this.systems.findIndex(s => s.constructor === system);
+        }
+        else if (system instanceof System) {
+            index = this.systems.findIndex(s => s === system);
+        }
+        if (index > -1) {
+            this.systems[index].destroy && this.systems[index].destroy();
+            this.systems.splice(index, 1);
+        }
+    }
+    /**
+     * Get system
+     * @param S - system class or system name
+     * @returns system instance
+     */
+    getSystem(S) {
+        return this.systems.find(system => {
+            if (typeof S === 'string') {
+                return system.name === S;
+            }
+            else {
+                return system instanceof S;
+            }
+        });
+    }
+    /** Pause game */
+    pause() {
+        if (!this.playing)
+            return;
+        this.playing = false;
+        this.ticker.pause();
+        this.triggerPause();
+    }
+    /** Start game */
+    start() {
+        if (this.playing)
+            return;
+        this.playing = true;
+        this.started = true;
+        this.ticker.start();
+    }
+    /** Resume game */
+    resume() {
+        if (this.playing)
+            return;
+        this.playing = true;
+        this.ticker.start();
+        this.triggerResume();
+    }
+    /**
+     * add main render method to ticker
+     * @remarks
+     * the method added to ticker will called in each requestAnimationFrame,
+     * 1. call update method on all gameObject
+     * 2. call lastUpdate method on all gameObject
+     * 3. call update method on all system
+     * 4. call lastUpdate method on all system
+     */
+    initTicker() {
+        this.ticker.add(e => {
+            this.scene && gameObjectLoop(e, this.gameObjects);
+            for (const system of this.systems) {
+                try {
+                    triggerStart(system);
+                    system.update && system.update(e);
+                }
+                catch (e) {
+                    console.error(`${systemClassName(system.constructor)} update error`, e);
+                }
+            }
+            for (const system of this.systems) {
+                try {
+                    system.lateUpdate && system.lateUpdate(e);
+                }
+                catch (e) {
+                    console.error(`${systemClassName(system.constructor)} lateUpdate error`, e);
+                }
+            }
+        });
+    }
+    /** Call onResume method on all gameObject's, and then call onResume method on all system */
+    triggerResume() {
+        gameObjectResume(this.gameObjects);
+        for (const system of this.systems) {
+            try {
+                system.onResume && system.onResume();
+            }
+            catch (e) {
+                console.error(`${systemClassName(system.constructor)}, onResume error`, e);
+            }
+        }
+    }
+    /** Call onPause method on all gameObject */
+    triggerPause() {
+        gameObjectPause(this.gameObjects);
+        for (const system of this.systems) {
+            try {
+                system.onPause && system.onPause();
+            }
+            catch (e) {
+                console.error(`${systemClassName(system.constructor)}, onPause error`, e);
+            }
+        }
+    }
+    // TODO: call system destroy method
+    /** remove all system on this game */
+    destroySystems() {
+        for (const system of [...this.systems]) {
+            this.removeSystem(system);
+        }
+        this.systems.length = 0;
+    }
+    /** Destroy game instance */
+    destroy() {
+        this.removeAllListeners();
+        this.pause();
+        this.scene.destroy();
+        this.destroySystems();
+        this.ticker = null;
+        this.scene = null;
+        this.canvas = null;
+        this.multiScenes = null;
+    }
+    loadScene({ scene, mode = LOAD_SCENE_MODE.SINGLE, params = {} }) {
+        if (!scene) {
+            return;
+        }
+        switch (mode) {
+            case LOAD_SCENE_MODE.SINGLE:
+                this.scene = scene;
+                break;
+            case LOAD_SCENE_MODE.MULTI_CANVAS:
+                this.multiScenes.push(scene);
+                break;
+        }
+        this.emit('sceneChanged', { scene, mode, params });
+    }
+}
+
+/**
+ * Collect property which react in Editor tooling
+ * @param target - component instance
+ * @param propertyKey - property name
+ */
+function IDEProp(target, propertyKey) {
+    if (!target.constructor.IDEProps) {
+        target.constructor.IDEProps = [];
+    }
+    target.constructor.IDEProps.push(propertyKey);
+}
+
+/**
+ * Normailize system observer info
+ * @param obj - system observer info
+ */
+function componentObserver(observerInfo = {}) {
+    return function (constructor) {
+        if (!constructor.observerInfo) {
+            for (const key in observerInfo) {
+                for (const index in observerInfo[key]) {
+                    if (typeof observerInfo[key][index] === 'string') {
+                        observerInfo[key][index] = [observerInfo[key][index]];
+                    }
+                    let observerProp;
+                    if (Array.isArray(observerInfo[key][index])) {
+                        observerProp = {
+                            prop: observerInfo[key][index],
+                            deep: false,
+                        };
+                        observerInfo[key][index] = observerProp;
+                    }
+                    observerProp = observerInfo[key][index];
+                    if (typeof observerProp.prop === 'string') {
+                        observerProp.prop = [observerProp.prop];
+                    }
+                }
+            }
+            constructor.observerInfo = observerInfo;
+        }
+    };
+}
+
+/** Load lifecycle events (decoupled from Resource/Progress to avoid barrel import cycles). */
+var LOAD_EVENT;
+(function (LOAD_EVENT) {
+    LOAD_EVENT["START"] = "start";
+    LOAD_EVENT["PROGRESS"] = "progress";
+    LOAD_EVENT["LOADED"] = "loaded";
+    LOAD_EVENT["COMPLETE"] = "complete";
+    LOAD_EVENT["ERROR"] = "error";
+})(LOAD_EVENT || (LOAD_EVENT = {}));
+
+class Progress extends EventEmitter {
+    constructor({ resource, resourceTotal }) {
+        super();
+        this.progress = 0;
+        this.resourceTotal = 0;
+        this.resourceLoadedCount = 0;
+        this.resource = resource;
+        this.resourceTotal = resourceTotal;
+        if (resourceTotal === 0) {
+            this.resource.emit(LOAD_EVENT.COMPLETE, this);
+        }
+    }
+    onStart() {
+        this.resource.emit(LOAD_EVENT.START, this);
+    }
+    onProgress(param) {
+        this.resourceLoadedCount++;
+        this.progress = Math.floor((this.resourceLoadedCount / this.resourceTotal) * 100) / 100;
+        if (param.success) {
+            this.resource.emit(LOAD_EVENT.LOADED, this, param);
+        }
+        else {
+            this.resource.emit(LOAD_EVENT.ERROR, this, param);
+        }
+        this.resource.emit(LOAD_EVENT.PROGRESS, this, param);
+        if (this.resourceLoadedCount === this.resourceTotal) {
+            this.resource.emit(LOAD_EVENT.COMPLETE, this);
+        }
+    }
+}
+
+const resourceLoader = {
+    AbstractLoadStrategy,
+    AudioLoadStrategy,
+    ImageLoadStrategy,
+    XhrResponseType,
+    MediaElementLoadStrategy,
+    VideoLoadStrategy,
+    XhrLoadStrategy,
+    Loader,
+    Resource: Resource$1,
+    ResourceType,
+    ResourceState
+};
+
+/** Resource type */
+var RESOURCE_TYPE;
+(function (RESOURCE_TYPE) {
+    RESOURCE_TYPE["IMAGE"] = "IMAGE";
+    RESOURCE_TYPE["SPRITE"] = "SPRITE";
+    RESOURCE_TYPE["SPRITE_ANIMATION"] = "SPRITE_ANIMATION";
+    RESOURCE_TYPE["AUDIO"] = "AUDIO";
+    RESOURCE_TYPE["VIDEO"] = "VIDEO";
+})(RESOURCE_TYPE || (RESOURCE_TYPE = {}));
+XhrLoadStrategy.setExtensionXhrType('json', XhrResponseType.Json);
+XhrLoadStrategy.setExtensionXhrType('tex', XhrResponseType.Json);
+XhrLoadStrategy.setExtensionXhrType('ske', XhrResponseType.Json);
+XhrLoadStrategy.setExtensionXhrType('mp3', XhrResponseType.Buffer);
+XhrLoadStrategy.setExtensionXhrType('wav', XhrResponseType.Buffer);
+XhrLoadStrategy.setExtensionXhrType('aac', XhrResponseType.Buffer);
+XhrLoadStrategy.setExtensionXhrType('ogg', XhrResponseType.Buffer);
+const RESOURCE_TYPE_STRATEGY = {
+    png: ImageLoadStrategy,
+    jpg: ImageLoadStrategy,
+    jpeg: ImageLoadStrategy,
+    webp: ImageLoadStrategy,
+    json: XhrLoadStrategy,
+    tex: XhrLoadStrategy,
+    ske: XhrLoadStrategy,
+    audio: XhrLoadStrategy,
+    video: VideoLoadStrategy,
+};
+/**
+ * Resource manager
+ * @public
+ */
+class Resource extends EventEmitter {
+    constructor(options) {
+        super();
+        // TODO: specify timeout in config to overwrite it
+        /** load resource timeout */
+        this.timeout = 6000;
+        this.preProcessResourceHandlers = [];
+        /** Resource cache  */
+        this.resourcesMap = {};
+        /** Collection of make resource instance function */
+        this.makeInstanceFunctions = {};
+        /** Collection of destroy resource instance function */
+        this.destroyInstanceFunctions = {};
+        /** Resource load promise */
+        this.promiseMap = {};
+        this.loaders = [];
+        if (options && typeof options.timeout === 'number') {
+            this.timeout = options.timeout;
+        }
+    }
+    /** Add resource configs and then preload */
+    loadConfig(resources) {
+        this.addResource(resources);
+        this.preload();
+    }
+    /** Add single resource config and then preload */
+    loadSingle(resource) {
+        this.addResource([resource]);
+        return this.getResource(resource.name);
+    }
+    /** Add resource configs */
+    addResource(resources) {
+        if (!resources || resources.length < 1) {
+            console.warn('no resources');
+            return;
+        }
+        for (const res of resources) {
+            if (this.resourcesMap[res.name]) {
+                console.warn(res.name + ' was already added');
+                continue;
+            }
+            this.resourcesMap[res.name] = res;
+            this.resourcesMap[res.name].data = {};
+        }
+    }
+    /** dd resource preprocesser*/
+    addPreProcessResourceHandler(handler) {
+        this.preProcessResourceHandlers.push(handler);
+    }
+    removePreProcessResourceHandler(handler) {
+        this.preProcessResourceHandlers.splice(this.preProcessResourceHandlers.indexOf(handler), 1);
+    }
+    /** Start preload */
+    preload() {
+        const names = [];
+        for (const key in this.resourcesMap) {
+            const resource = this.resourcesMap[key];
+            if (resource.preload && !resource.complete && !this.promiseMap[key]) {
+                names.push(resource.name);
+            }
+        }
+        this.progress = new Progress({
+            resource: this,
+            resourceTotal: names.length,
+        });
+        this.loadResource({ names, preload: true });
+    }
+    /** Get resource by name */
+    async getResource(name) {
+        this.loadResource({ names: [name] });
+        return this.promiseMap[name] || Promise.resolve({});
+    }
+    /** Make resource instance by resource type */
+    async instance(name) {
+        const res = this.resourcesMap[name];
+        return this.makeInstanceFunctions[res.type] && (await this.makeInstanceFunctions[res.type](res));
+    }
+    /** destory this resource manager */
+    async destroy(name) {
+        await this._destroy(name);
+    }
+    async _destroy(name, loadError = false) {
+        const resource = this.resourcesMap[name];
+        if (!resource)
+            return;
+        if (!loadError) {
+            try {
+                if (this.destroyInstanceFunctions[resource.type]) {
+                    await this.destroyInstanceFunctions[resource.type](resource);
+                }
+            }
+            catch (e) {
+                console.warn(`destroy resource ${resource.name} error with '${e.message}'`);
+            }
+        }
+        delete this.promiseMap[name];
+        resource.data = {};
+        resource.complete = false;
+        resource.instance = undefined;
+    }
+    /**
+     * Register a custom resource type string on {@link RESOURCE_TYPE}.
+     * For TypeScript, extend `RESOURCE_TYPE` via `declare module "@combos-fun/engine"` in your app’s ambient `.d.ts`.
+     * Call this before {@link registerInstance} / {@link registerDestroy} for that type.
+     */
+    registerResourceType(type, value = type) {
+        if (RESOURCE_TYPE[type]) {
+            throw new Error(`The type ${type} already exists in RESOURCE_TYPE`);
+        }
+        RESOURCE_TYPE[type] = value;
+    }
+    /** Add resource instance function */
+    registerInstance(type, callback) {
+        this.makeInstanceFunctions[type] = callback;
+    }
+    /** Add resource destroy function */
+    registerDestroy(type, callback) {
+        this.destroyInstanceFunctions[type] = callback;
+    }
+    loadResource({ names = [], preload = false }) {
+        const unLoadNames = names.filter(name => !this.promiseMap[name] && this.resourcesMap[name]);
+        if (!unLoadNames.length)
+            return;
+        const resolves = {};
+        const loader = this.getLoader(preload);
+        unLoadNames.forEach(name => {
+            this.promiseMap[name] = new Promise(r => (resolves[name] = r));
+            const res = this.resourcesMap[name];
+            for (const handler of this.preProcessResourceHandlers) {
+                handler(res);
+            }
+            for (const key in res.src) {
+                const resourceType = res.src[key].type;
+                if (resourceType === 'data') {
+                    res.data[key] = res.src[key].data;
+                    this.doComplete(name, resolves[name], preload);
+                }
+                else {
+                    loader.add({
+                        url: res.src[key].url,
+                        name: `${res.name}_${key}`,
+                        strategy: RESOURCE_TYPE_STRATEGY[resourceType],
+                        metadata: {
+                            key,
+                            name: res.name,
+                            resolves,
+                        },
+                    });
+                }
+            }
+        });
+        loader.load();
+    }
+    async doComplete(name, resolve, preload = false) {
+        const res = this.resourcesMap[name];
+        const param = {
+            name,
+            resource: this.resourcesMap[name],
+            success: true,
+        };
+        if (this.checkAllLoaded(name)) {
+            try {
+                res.instance = await this.instance(name);
+                res.complete = true;
+                if (preload) {
+                    this.progress.onProgress(param);
+                }
+                resolve(res);
+            }
+            catch (err) {
+                console.error(err);
+                res.complete = false;
+                if (preload) {
+                    param.errMsg = err.message;
+                    param.success = false;
+                    this.progress.onProgress(param);
+                }
+                resolve({});
+            }
+        }
+    }
+    checkAllLoaded(name) {
+        const res = this.resourcesMap[name];
+        return Array.from(Object.keys(res.src)).every(resourceKey => res.data[resourceKey]);
+    }
+    getLoader(preload = false) {
+        let loader = this.loaders.find(({ loading }) => !loading);
+        if (!loader) {
+            loader = new Loader();
+            this.loaders.push(loader);
+        }
+        if (preload) {
+            loader.onStart.once(() => {
+                this.progress.onStart();
+            });
+        }
+        loader.onLoad.add((_, resource) => {
+            this.onLoad({ preload, resource });
+        });
+        loader.onError.add((errMsg, _loader, resource) => {
+            this.onError({ errMsg, resource, preload });
+        });
+        loader.onComplete.once(() => {
+            loader.onLoad.detachAll();
+            loader.onError.detachAll();
+            loader.reset();
+        });
+        return loader;
+    }
+    async onLoad({ preload = false, resource }) {
+        const { metadata: { key, name, resolves }, data, } = resource;
+        const res = this.resourcesMap[name];
+        res.data[key] = data;
+        this.doComplete(name, resolves[name], preload);
+    }
+    async onError({ errMsg, preload = false, resource }) {
+        const { metadata: { name, resolves }, } = resource;
+        this._destroy(name, true);
+        resolves[name]({});
+        if (preload) {
+            const param = {
+                name,
+                resource: this.resourcesMap[name],
+                success: false,
+                errMsg,
+            };
+            this.progress.onProgress(param);
+        }
+    }
+}
+/** Resource manager single instance */
+const resource = new Resource();
+
+/** Decorators util */
+const decorators = {
+    IDEProp,
+    componentObserver,
+};
+const version = '__VERSION__';
+console.log(`@combos-fun/engine version: ${version}`);
+
+export { Component, Game, GameObject, IDEProp, LOAD_EVENT, LOAD_SCENE_MODE, ObserverType as OBSERVER_TYPE, RESOURCE_TYPE, RESOURCE_TYPE_STRATEGY, Scene, System, Transform, componentObserver, decorators, resource, resourceLoader, version };
+//# sourceMappingURL=engine.esm.js.map