@woosh/meep-engine 2.46.22 → 2.46.24

package/build/meep.cjs

@@ -125808,7 +125808,765 @@ EngineHarness.getSingleton = function () {
     return singleton;
 };
 
+/**
+ * Will try every child behaviour in order until one succeeds or if all fail - the selector behavior will fail too
+ */
+class SelectorBehavior extends CompositeBehavior {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {Behavior}
+         * @private
+         */
+        this.__currentBehaviour = null;
+
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__currentBehaviourIndex = -1;
+    }
+
+    /**
+     *
+     * @param {Behavior[]} children
+     * @returns {SelectorBehavior}
+     */
+    static from(children) {
+        assert.isArray(children, 'children');
+
+        const r = new SelectorBehavior();
+
+        children.forEach(r.addChild, r);
+
+        return r;
+    }
+
+    tick(timeDelta) {
+        if (this.__children.length < 1) {
+            // no options, nothing chosen
+            return BehaviorStatus.Failed;
+        }
+
+        //keep going until a child behavior says it's running
+        for (; ;) {
+            const s = this.__currentBehaviour.tick(timeDelta);
+
+            //if child succeeds or keeps running, do the same
+            if (s !== BehaviorStatus.Failed) {
+                return s;
+            }
+
+            this.__currentBehaviour.finalize();
+
+            //Continue search for a fallback until the last child
+            const children = this.__children;
+
+            this.__currentBehaviourIndex++;
+
+            if (this.__currentBehaviourIndex >= children.length) {
+                this.__currentBehaviour = null;
+
+                return BehaviorStatus.Failed;
+            }
+
+            this.__currentBehaviour = children[this.__currentBehaviourIndex];
+
+            this.__currentBehaviour.initialize(this.context);
+        }
+    }
+
+    finalize() {
+        if (this.__currentBehaviour !== null) {
+            this.__currentBehaviour.finalize();
+            this.__currentBehaviour = null;
+        }
+    }
+
+    initialize(context) {
+        super.initialize(context);
+
+        const children = this.__children;
+
+        if (children.length > 0) {
+
+            this.__currentBehaviourIndex = 0;
+            this.__currentBehaviour = children[0];
+
+            this.__currentBehaviour.initialize();
+
+        } else {
+            // no children
+
+            this.__currentBehaviourIndex = -1;
+            this.__currentBehaviour = null;
+
+        }
+    }
+}
+
+/**
+ *
+ * @enum {number}
+ */
+const ParallelBehaviorPolicy = {
+    RequireOne: 0,
+    RequireAll: 1
+};
+
+class ParallelBehavior extends CompositeBehavior {
+    /**
+     *
+     * @param {ParallelBehaviorPolicy} successPolicy
+     * @param {ParallelBehaviorPolicy} failurePolicy
+     */
+    constructor(successPolicy, failurePolicy) {
+        super();
+
+        /**
+         * @private
+         * @type {ParallelBehaviorPolicy}
+         */
+        this.successPolicy = successPolicy;
+
+        /**
+         * @private
+         * @type {ParallelBehaviorPolicy}
+         */
+        this.failurePolicy = failurePolicy;
+
+        /**
+         * @private
+         * @type {BitSet}
+         */
+        this.activeSet = new BitSet();
+
+        /**
+         * @private
+         * @type {number}
+         */
+        this.successCount = 0;
+        /**
+         * @private
+         * @type {number}
+         */
+        this.failureCount = 0;
+    }
+
+    /**
+     *
+     * @return {ParallelBehaviorPolicy}
+     */
+    getSuccessPolicy() {
+        return this.successPolicy;
+    }
+
+    /**
+     *
+     * @param {ParallelBehaviorPolicy|number} v
+     */
+    setSuccessPolicy(v) {
+        this.successPolicy = v;
+    }
+
+    /**
+     *
+     * @return {ParallelBehaviorPolicy}
+     */
+    getFailurePolicy() {
+        return this.failurePolicy;
+    }
+
+    /**
+     *
+     * @param {ParallelBehaviorPolicy|number} v
+     */
+    setFailurePolicy(v) {
+        this.failurePolicy = v;
+    }
+
+    /**
+     *
+     * @param {number} timeDelta
+     * @returns {BehaviorStatus|number}
+     */
+    tick(timeDelta) {
+
+        const activeSet = this.activeSet;
+
+        /**
+         *
+         * @type {Behavior[]}
+         */
+        const children = this.__children;
+
+        const numChildren = children.length;
+
+        let i;
+
+        for (i = 0; i < numChildren; i++) {
+            if (!activeSet.get(i)) {
+                continue;
+            }
+
+            const child = children[i];
+
+            const status = child.tick(timeDelta);
+
+            if (status === BehaviorStatus.Succeeded) {
+                activeSet.set(i, false);
+
+                this.successCount++;
+
+                child.finalize();
+
+                if (this.successPolicy === ParallelBehaviorPolicy.RequireOne) {
+
+                    this.__finalizeActiveChildren();
+
+                    return BehaviorStatus.Succeeded;
+
+                }
+
+            } else if (status === BehaviorStatus.Failed) {
+                activeSet.set(i, false);
+
+                this.failureCount++;
+
+                child.finalize();
+
+                if (this.failurePolicy === ParallelBehaviorPolicy.RequireOne) {
+
+                    this.__finalizeActiveChildren();
+
+                    return BehaviorStatus.Failed;
+
+                } else if (this.successPolicy === ParallelBehaviorPolicy.RequireAll) {
+
+                    this.__finalizeActiveChildren();
+
+                    return BehaviorStatus.Failed;
+
+                }
+
+            }
+        }
+
+        if (this.successCount === numChildren && this.successPolicy === ParallelBehaviorPolicy.RequireAll) {
+
+            return BehaviorStatus.Succeeded;
+
+        } else if (this.failureCount === numChildren && this.failurePolicy === ParallelBehaviorPolicy.RequireAll) {
+
+            return BehaviorStatus.Failed;
+
+        } else if ((this.failureCount + this.successCount) === numChildren) {
+
+            return BehaviorStatus.Failed;
+
+        } else {
+
+            return BehaviorStatus.Running;
+
+        }
+    }
+
+    initialize(context) {
+        this.successCount = 0;
+        this.failureCount = 0;
+
+        const children = this.__children;
+        const numChildren = children.length;
+
+        for (let i = 0; i < numChildren; i++) {
+            const behavior = children[i];
+
+            behavior.initialize(context);
+
+            this.activeSet.set(i, true);
+        }
+
+        super.initialize(context);
+    }
+
+    /**
+     *
+     * @private
+     */
+    __finalizeActiveChildren() {
+        const children = this.__children;
+
+        const activeSet = this.activeSet;
+
+        for (let i = activeSet.nextSetBit(0); i !== -1; i = activeSet.nextSetBit(i + 1)) {
+            const behavior = children[i];
+
+            behavior.finalize();
+        }
+
+    }
+
+
+    finalize() {
+        //finalize remaining active behaviours
+
+        this.__finalizeActiveChildren();
+    }
+
+    /**
+     *
+     * @param {Behavior[]} elements
+     * @param {ParallelBehaviorPolicy} success
+     * @param {ParallelBehaviorPolicy} failure
+     * @returns {ParallelBehavior}
+     */
+    static from(elements, success = ParallelBehaviorPolicy.RequireAll, failure = ParallelBehaviorPolicy.RequireOne) {
+        const r = new ParallelBehavior(success, failure);
+
+        elements.forEach(e => r.addChild(e));
+
+        return r;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+ParallelBehavior.prototype.isParallelBehavior = true;
+
+/**
+ * @readonly
+ * @type {string}
+ */
+ParallelBehavior.typeName = "ParallelBehavior";
+
+/**
+ *
+ * @param {DataType} type
+ * @returns {Vector1|ObservedBoolean}
+ */
+function createValueByType(type) {
+
+    let value;
+
+    switch (type) {
+        case DataType.Number:
+            value = new Vector1(0);
+            break;
+        case DataType.Boolean:
+            value = new ObservedBoolean(false);
+            break;
+        case DataType.String:
+            value = new ObservedString("");
+            break;
+        default:
+            throw new TypeError(`Unsupported data type '${type}'`);
+    }
+
+    return value;
+}
+
+class BlackboardValue {
+    /**
+     *
+     * @param {DataType} type
+     */
+    constructor(type) {
+        /**
+         *
+         * @type {number}
+         */
+        this.referenceCount = 0;
+        /**
+         *
+         * @type {DataType}
+         */
+        this.type = type;
+        this.value = createValueByType(type);
+    }
+}
+
+class AbstractBlackboard {
+
+    /**
+     * Checks is the blackboard contains a certain value or not by name/type combination
+     * @param {string} name
+     * @param {DataType} type
+     * @returns {boolean}
+     */
+    contains(name, type) {
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Produces a list of all held keys
+     * @returns {string[]}
+     */
+    getKeys() {
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * @template T
+     * @param {string} name
+     * @param {DataType} type
+     * @param {string|number|boolean} [initialValue]
+     * @returns {T}
+     */
+    acquire(name, type, initialValue) {
+        throw new Error('Not implemented');
+    }
+
+    /**
+     * Release reference to a value
+     * @param {string} name
+     * @returns {void}
+     */
+    release(name) {
+        throw new Error('Not implemented');
+    }
+
+    /**
+     *
+     * @param {string} name
+     * @param {boolean} [initialValue=false]
+     * @returns {ObservedBoolean}
+     */
+    acquireBoolean(name, initialValue = false) {
+        assert.typeOf(initialValue, 'boolean', 'initialValue');
+
+        return this.acquire(name, DataType.Boolean, initialValue);
+    }
+
+    /**
+     *
+     * @param {string} name
+     * @param {number} [initialValue=0]
+     * @returns {Vector1}
+     */
+    acquireNumber(name, initialValue = 0) {
+        assert.isNumber(initialValue, 'initialValue');
+
+        return this.acquire(name, DataType.Number, initialValue);
+    }
+
+    /**
+     *
+     * @param {string} name
+     * @param {number} [value=1]
+     * @returns {void}
+     */
+    incrementNumber(name, value = 1) {
+        const vector1 = this.acquireNumber(name);
+
+        vector1._add(value);
+
+        this.release(name);
+    }
+
+    /**
+     *
+     * @param {string} name
+     * @param {string} [initialValue]
+     * @returns {ObservedString}
+     */
+    acquireString(name, initialValue = '') {
+        assert.typeOf(initialValue, 'string', 'initialValue');
+
+        return this.acquire(name, DataType.String, initialValue);
+    }
+}
+
+/**
+ * @template T
+ * @param {T} value
+ * @return {DataType}
+ */
+function computeDataTypeFromValue(value) {
+    const t = typeof value;
+
+    switch (t) {
+        case "number":
+            return DataType.Number;
+        case "string":
+            return DataType.String;
+        case "boolean":
+            return DataType.Boolean;
+        default:
+            if (Array.isArray(value)) {
+                return DataType.Array;
+            }
+
+            throw new Error(`Unsupported value type for value '${value}'`);
+    }
+}
+
+/**
+ * Given a blackboard, returns a Proxy instance, exposing blackboard attributes as plain JSON
+ * Useful for connecting blackboard to systems that are not explicitly designed to work with a blackboard
+ * @param {AbstractBlackboard} blackboard
+ * @returns {Proxy}
+ */
+function make_blackboard_proxy(blackboard) {
+    return new Proxy(blackboard, {
+        /**
+         *
+         * @param target
+         * @param {string} p
+         * @param receiver
+         * @returns {*}
+         */
+        get(target, p, receiver) {
+
+            if (!target.contains(p, DataType.Any)) {
+                // property not found
+                return undefined;
+            }
+
+            const value_container = target.acquire(p, DataType.Any);
+
+            return value_container.getValue();
+        },
+        set(target, p, value, receiver) {
+
+            const dataType = computeDataTypeFromValue(value);
+
+            const value_container = target.acquire(p, dataType, value);
+
+            value_container.set(value);
+
+            // succeeded
+            return true;
+        },
+        ownKeys(target) {
+
+            return target.getKeys();
+
+        }
+    })
+}
+
+class Blackboard extends AbstractBlackboard {
+    constructor() {
+        super();
+
+        this.on = {
+            /**
+             * Property added
+             * @type {Signal}
+             */
+            added: new Signal()
+        };
+
+        /**
+         *
+         * @type {Object<BlackboardValue>}
+         */
+        this.data = {};
+
+        /**
+         * @private
+         */
+        this.proxy = make_blackboard_proxy(this);
+    }
+
+    getKeys() {
+        return Reflect.ownKeys(this.data);
+    }
+
+    /**
+     *
+     * @returns {Object}
+     */
+    getValueProxy() {
+        return this.proxy;
+    }
+
+    /**
+     *
+     * @param {string} name
+     * @param {DataType} type
+     * @return {boolean} true only if entry exists and matches type, or if supplied parameter type is set to "Any"
+     */
+    contains(name, type) {
+        assert.isString(name, 'name');
+        assert.enum(type, DataType, 'type');
+
+        const datum = this.data[name];
+
+        if (datum === undefined) {
+            return false;
+        }
+
+        if (type !== DataType.Any && datum.type !== type) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     *
+     * @param {function(name:string, value:*, type: DataType)} visitor
+     * @param {*} [thisArg]
+     */
+    traverse(visitor, thisArg) {
+        assert.typeOf(visitor, 'function', 'visitor');
+
+        for (let name in this.data) {
+            if (!this.data.hasOwnProperty(name)) {
+                continue;
+            }
+
+            const blackboardValue = this.data[name];
+
+            visitor.call(thisArg, name, blackboardValue.value, blackboardValue.type);
+        }
+    }
+
+    /**
+     *
+     * @param {function(name:string, value:*, type: DataType)} visitor
+     * @param {RegExp} pattern
+     */
+    traverseWithPattern(pattern, visitor) {
+        assert.defined(pattern, 'pattern');
+        assert.ok(pattern instanceof RegExp, 'pattern is not a RegExp');
+
+        this.traverse(function (name, value, type) {
+            if (pattern.test(name)) {
+                visitor(name, value, type);
+            }
+        });
+    }
+
+    /**
+     * @template T
+     * @param {string} name
+     * @param {DataType} type
+     * @param {number|boolean} [initialValue]
+     * @returns {T}
+     */
+    acquire(name, type, initialValue) {
+        assert.isString(name, 'name');
+
+        let datum;
+
+        if (this.data.hasOwnProperty(name)) {
+            // property exists
+            datum = this.data[name];
+
+            if (type !== DataType.Any && datum.type !== type) {
+                throw new TypeError(`Value '${name}' exists, but is type(='${datum.type}'), expected type '${type}'`);
+            }
+
+        } else {
+            //doesn't exist - create it
+            datum = new BlackboardValue(type);
+
+            const concrete_value = datum.value;
+
+            if (initialValue !== undefined) {
+                concrete_value.set(initialValue);
+            }
+
+            this.data[name] = datum;
+
+            this.on.added.send4(name, concrete_value.getValue(), type, this);
+        }
+
+        datum.referenceCount++;
+
+        return datum.value;
+    }
+
+    /**
+     *
+     * @param {string} name
+     */
+    release(name) {
+        assert.typeOf(name, 'string', 'name');
+        assert.ok(this.data.hasOwnProperty(name), `Attempting to release a value '${name}' that doesn't exist`);
+
+        const datum = this.data[name];
+
+        datum.referenceCount--;
+
+        //todo cleanup value from blackboard if no one is using it
+    }
+
+    /**
+     * Drop all values
+     */
+    reset() {
+        this.data = {};
+    }
+
+    /**
+     *
+     * @param {Blackboard} other
+     */
+    copy(other) {
+        this.reset();
+
+        other.traverse((name, value, type) => {
+            this.acquire(name, type, value.getValue());
+        });
+    }
+
+    /**
+     *
+     * @returns {Blackboard}
+     */
+    clone() {
+        const r = new Blackboard();
+
+        r.copy(this);
+
+        return r;
+    }
+
+
+    toJSON() {
+        const result = {};
+
+        this.traverse((name, value, type) => {
+            result[name] = value.toJSON();
+        });
+
+        return result;
+    }
+
+    fromJSON(json) {
+        this.reset();
+
+        for (let propName in json) {
+            const value = json[propName];
+
+            const value_type = typeof value;
+
+            if (value_type === 'number') {
+                this.acquireNumber(propName, value).set(value);
+            } else if (value_type === 'boolean') {
+                this.acquireBoolean(propName, value).set(value);
+            } else if (value_type === 'string') {
+                this.acquireString(propName, value).set(value);
+            }
+
+        }
+    }
+}
+
+Blackboard.typeName = 'Blackboard';
+
 exports.AmbientOcclusionPostProcessEffect = AmbientOcclusionPostProcessEffect;
+exports.Behavior = Behavior;
+exports.BehaviorStatus = BehaviorStatus;
+exports.Blackboard = Blackboard;
 exports.Cache = Cache;
 exports.EngineConfiguration = EngineConfiguration;
 exports.EngineHarness = EngineHarness;
@@ -125816,11 +126574,16 @@ exports.EntityBuilderFlags = EntityBuilderFlags;
 exports.ForwardPlusRenderingPlugin = ForwardPlusRenderingPlugin;
 exports.HashMap = HashMap;
 exports.Light = Light;
+exports.ParallelBehavior = ParallelBehavior;
+exports.ParallelBehaviorPolicy = ParallelBehaviorPolicy;
 exports.SGMesh = SGMesh;
 exports.SGMeshSystem = SGMeshSystem;
+exports.SelectorBehavior = SelectorBehavior;
+exports.SequenceBehavior = SequenceBehavior;
 exports.ShadedGeometry = ShadedGeometry;
 exports.ShadedGeometrySystem = ShadedGeometrySystem;
 exports.Signal = Signal;
+exports.SignalBinding = SignalBinding;
 exports.Transform = Transform;
 exports.dispatchViaProxy = dispatchViaProxy;
 exports.findSignalHandlerIndexByHandle = findSignalHandlerIndexByHandle;