@woosh/meep-engine/src/engine/ecs/dynamic_actions/DynamicActorSystem.d.ts

Pure JavaScript game engine. Fully featured and production ready.

export class DynamicActorSystem extends AbstractContextSystem<any> {
    /**
     *
     * @param {Engine} engine
     */
    constructor(engine: Engine);
    dependencies: (typeof DynamicActor)[];
    components_used: ResourceAccessSpecification<typeof Blackboard>[];
    /**
     *
     * @type {DynamicRuleDescriptionTable}
     */
    database: DynamicRuleDescriptionTable;
    /**
     * Scope used for dispatching actions
     * @type {DataScope}
     */
    scope: DataScope;
    /**
     * When precisely each rule was last used
     * @type {HashMap<DynamicRuleDescription, number>}
     * @private
     */
    private __global_last_used_times;
    /**
     * Time when a group with an ID will be cooled down
     * @type {Map<string, number>}
     * @private
     */
    private __global_cooldown_ready;
    /**
     *
     * @type {MultiPredicateEvaluator}
     */
    evaluator: MultiPredicateEvaluator;
    /**
     *
     * @type {number}
     * @private
     */
    private __current_time;
    /**
     * Print debug output into console
     * @type {boolean}
     * @private
     */
    private __debug;
    /**
     *
     * @type {Engine}
     */
    engine: Engine;
    /**
     *
     * @return {number}
     */
    getCurrentTime(): number;
    /**
     *
     * @param {number} entity
     * @param {DynamicRuleDescription} rule
     * @param {*} context
     */
    attemptRuleExecution(entity: number, rule: DynamicRuleDescription, context: any): boolean;
    /**
     *
     * @param {number} entity
     */
    terminateActiveExecution(entity: number): void;
    /**
     *
     * @param {number} entity
     * @param {DynamicRuleDescription} rule
     * @param {*} context
     */
    executeRule(entity: number, rule: DynamicRuleDescription, context: any): void;
    /**
     *
     * @param {number} entity
     * @param {DataScope} scope
     */
    populateEntityScope(entity: number, scope: DataScope): void;
    /**
     *
     * @param {Object} context
     * @return {DynamicRuleDescription|undefined}
     */
    matchRule(context: any): DynamicRuleDescription | undefined;
    /**
     * Given a context, returns N actors that match that context best, filter is used to restrict search and reject certain actors entirely
     * Useful for picking an actor for a response action
     *
     * @param {Object} context
     * @param {function(entity:number,dataset:EntityComponentDataset):} [filter]
     * @param {*} [filterContext]
     * @param {number} [count]
     * @returns {{entity:number,rule:DynamicRuleDescription, scope: DataScope}[]}
     */
    requestBestActors(context: any, filter?: typeof returnTrue, filterContext?: any, count?: number): {
        entity: number;
        rule: DynamicRuleDescription;
        scope: DataScope;
    }[];
    /**
     *
     * @param {number} entity
     * @param {string} event
     * @param {Object} context
     * @returns {DynamicRuleDescription|undefined}
     */
    match(entity: number, event: string, context: any): DynamicRuleDescription | undefined;
    startup(entityManager: any): Promise<void>;
    /**
     *
     * @param {DynamicActor} actor
     * @param {number} entity
     * @private
     */
    private __update_visitDynamicActor;
    update(timeDelta: any): void;
}
import { AbstractContextSystem } from "../system/AbstractContextSystem.js";
import { DynamicActor } from "./DynamicActor.js";
import { Blackboard } from "../../intelligence/blackboard/Blackboard.js";
import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
import { DataScope } from "./DataScope.js";
import { returnTrue } from "../../../core/function/returnTrue.js";
//# sourceMappingURL=DynamicActorSystem.d.ts.map