the-world-engine/dist/esm/engine/hierarchy_object/ComponentEventContainer.js

three.js based, unity like game engine for browser

import { ComponentEvent } from "./ComponentEvent";

import { ComponentEventState } from "./ComponentEventState";

function isAwakeableComponent(t) {
    return t.awake !== undefined;
}

function isOnEnableableComponent(t) {
    return t.onEnable !== undefined;
}

function isOnDisableableComponent(t) {
    return t.onDisable !== undefined;
}

function isOnDestroyableComponent(t) {
    return t.onDestroy !== undefined;
}

function isOnCollisionEnter2DableComponent(t) {
    return t.onCollisionEnter2D !== undefined;
}

function isOnCollisionStay2DableComponent(t) {
    return t.onCollisionStay2D !== undefined;
}

function isOnCollisionExit2DableComponent(t) {
    return t.onCollisionExit2D !== undefined;
}

function isOnTriggerEnter2DableComponent(t) {
    return t.onTriggerEnter2D !== undefined;
}

function isOnTriggerStay2DableComponent(t) {
    return t.onTriggerStay2D !== undefined;
}

function isOnTriggerExit2DableComponent(t) {
    return t.onTriggerExit2D !== undefined;
}

function isStartableComponent(t) {
    return t.start !== undefined;
}

function isUpdatableComponent(t) {
    return t.update !== undefined;
}

export class ComponentEventContainer {
    ot;
    v;
    h;
    Ut;
    Rt=null;
    At=null;
    qt=null;
    zt=null;
    Bt=null;
    Gt=null;
    Ht=null;
    Jt=null;
    Kt=null;
    Lt=null;
    constructor(t) {
        this.ot = t;
        this.v = t.engine.sceneProcessor;
        this.h = t.engine.instantiater;
        this.Ut = new ComponentEventState;
        if (isAwakeableComponent(t)) {
            this.Rt = ComponentEvent.createAwakeEvent(this.h, t.awake.bind(t));
        }
        if (isOnDestroyableComponent(t)) {
            this.At = ComponentEvent.createOnDestroyEvent(this.h, t.onDestroy.bind(t), t.executionOrder);
        }
        {
            if (isOnCollisionEnter2DableComponent(t)) {
                this.qt = ComponentEvent.createOnCollisionEnter2DEvent(this.h, (n => t.onCollisionEnter2D(n)), t.executionOrder);
            }
            if (isOnCollisionStay2DableComponent(t)) {
                this.zt = ComponentEvent.createOnCollisionStay2DEvent(this.h, (n => t.onCollisionStay2D(n)), t.executionOrder);
            }
            if (isOnCollisionExit2DableComponent(t)) {
                this.Bt = ComponentEvent.createOnCollisionExit2DEvent(this.h, (n => t.onCollisionExit2D(n)), t.executionOrder);
            }
            if (isOnTriggerEnter2DableComponent(t)) {
                this.Gt = ComponentEvent.createOnTriggerEnter2DEvent(this.h, (n => t.onTriggerEnter2D(n)), t.executionOrder);
            }
            if (isOnTriggerStay2DableComponent(t)) {
                this.Ht = ComponentEvent.createOnTriggerStay2DEvent(this.h, (n => t.onTriggerStay2D(n)), t.executionOrder);
            }
            if (isOnTriggerExit2DableComponent(t)) {
                this.Jt = ComponentEvent.createOnTriggerExit2DEvent(this.h, (n => t.onTriggerExit2D(n)), t.executionOrder);
            }
        }
        if (isStartableComponent(t)) {
            this.Kt = ComponentEvent.createStartEvent(this.h, (() => {
                this.Ut.startCalled = true;
                t.start();
                if (this.Ut.startRegistered) {
                    this.v.removeEventFromNonSyncedCollection(this.Kt);
                }
            }), t.executionOrder);
        }
        if (isUpdatableComponent(t)) {
            this.Lt = ComponentEvent.createUpdateEvent(this.h, t.update.bind(t), t.executionOrder);
        }
    }
    tryCallAwake() {
        if (this.Ut.awakeCalled) return;
        this.Ut.awakeCalled = true;
        this.Rt?.invoke();
    }
    tryRegisterOnEnable() {
        if (this.ot._engine_internal_destroyed) return;
        if (this.Ut.enabled) return;
        this.Ut.enabled = true;
        if (!isOnEnableableComponent(this.ot)) return;
        const t = ComponentEvent.createOnEnableEvent(this.h, this.ot.onEnable.bind(this.ot), this.ot.executionOrder);
        this.v.addEventToSyncedCollection(t);
    }
    tryRegisterOnDisable() {
        if (this.ot._engine_internal_destroyed) return;
        if (!this.Ut.enabled) return;
        this.Ut.enabled = false;
        if (!isOnDisableableComponent(this.ot)) return;
        const t = ComponentEvent.createOnDisableEvent(this.h, this.ot.onDisable.bind(this.ot), this.ot.executionOrder);
        this.v.addEventToSyncedCollection(t);
    }
    tryRegisterOnDestroy() {
        if (!this.At) return;
        this.v.addEventToSyncedCollection(this.At);
    }
    tryRegisterStart() {
        if (!this.Kt) return;
        if (this.ot._engine_internal_destroyed) return;
        if (this.Ut.startCalled) return;
        if (this.Ut.startRegistered) return;
        this.Ut.startRegistered = true;
        this.v.addEventToNonSyncedCollection(this.Kt);
    }
    tryUnregisterStart() {
        if (!this.Kt) return;
        if (!this.Ut.startRegistered || this.Ut.startCalled) return;
        this.Ut.startRegistered = false;
        this.v.removeEventFromNonSyncedCollection(this.Kt);
    }
    tryRegisterUpdate() {
        if (!this.Lt) return;
        if (this.ot._engine_internal_destroyed) return;
        if (this.Ut.updateRegistered) return;
        this.Ut.updateRegistered = true;
        this.v.addEventToNonSyncedCollection(this.Lt);
    }
    tryUnregisterUpdate() {
        if (!this.Lt) return;
        if (!this.Ut.updateRegistered) return;
        this.Ut.updateRegistered = false;
        this.v.removeEventFromNonSyncedCollection(this.Lt);
    }
    get onCollisionEnter2D() {
        return this.qt;
    }
    get onCollisionStay2D() {
        return this.zt;
    }
    get onCollisionExit2D() {
        return this.Bt;
    }
    get onTriggerEnter2D() {
        return this.Gt;
    }
    get onTriggerStay2D() {
        return this.Ht;
    }
    get onTriggerExit2D() {
        return this.Jt;
    }
}