@ankhzet/goap 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @ankhzet/goap
 
+## 1.2.0
+
+### Minor Changes
+
+- Fix release
+
+### Patch Changes
+
+- Updated dependencies
+  - @ankhzet/eventual@1.2.0
+  - @ankhzet/gcl@1.2.0
+
 ## 1.1.0
 
 ### Minor Changes

package/dist/index.d.ts

@@ -0,0 +1,289 @@
+import { Class } from '@ankhzet/gcl';
+import { DGCInterface } from '@ankhzet/gcl';
+import { IEventHandler } from '@ankhzet/eventual';
+
+/** @public */
+export declare abstract class Action<E extends WithActionSlots, D = any> implements ActionInterface<E, D> {
+    readonly cost: number;
+    provides: StateInterface<E>;
+    requires: StateInterface<E>;
+    toggles?: StateInterface<E>;
+    consumes?: StateBitInterface<E>[];
+    abstract process(enactor: E, delta: number): ActionProcessingResult;
+    get name(): string;
+    get type(): string;
+    prepare(enactor: E): void;
+    exit(_enactor: E, _result: ActionCompletionResult): void;
+    getAssociatedData(enactor: E): D;
+    describe(): string;
+    toString(): string;
+}
+
+/** @public */
+export declare type ActionCompletionResult = Exclude<ActionProcessingResult, ActionProcessingResult.Executing>;
+
+/** @public */
+export declare interface ActionCostMapper {
+    getActionCost(action: ActionInterface<any>): number;
+    setActionCost(action: ActionInterface<any>, cost: number): void;
+    slideActionCost(delta: number): void;
+}
+
+/** @public */
+export declare function ActionEnactor<Base extends Class<WithState<any> & DGCInterface, any>, T>(Base: Base): Class<InstanceType<Base> & ActionEnactorInterface<T>, ConstructorParameters<Base>>;
+
+/** @public */
+export declare interface ActionEnactorInterface<T = any> extends ActionCostMapper, WithState<T> {
+    readonly actions: Set<ActionInterface<T>>;
+    readonly top: ActionInterface<T> | undefined;
+    sequence?: ActionInterface<any>[];
+    changeActions(actions: Set<ActionInterface<T>>, added: boolean): boolean;
+    deriveGoal(): StateInterface<T>;
+    getGoalBit(bit: StateBitInterface<T>): boolean;
+    setGoalBit(bit: StateBitInterface<T>, value: boolean): void;
+    nextAction(): boolean;
+    dropSequence(): void;
+    acceptSequence(sequence: ActionInterface<T>[]): boolean;
+}
+
+/** @public */
+export declare interface ActionInterface<Enactor, Data = any> {
+    readonly type: string;
+    readonly cost: number;
+    readonly requires: StateInterface<Enactor>;
+    readonly provides: StateInterface<Enactor>;
+    readonly toggles?: StateInterface<Enactor>;
+    readonly consumes?: StateBitInterface<Enactor>[];
+    prepare(enactor: Enactor): void;
+    exit(enactor: Enactor, result: ActionCompletionResult): void;
+    getAssociatedData(enactor: Enactor): Data;
+    process(enactor: Enactor, delta: number): ActionProcessingResult;
+    describe(): string;
+}
+
+/** @public */
+export declare class ActionNode<Enactor> {
+    readonly action: ActionInterface<Enactor>;
+    readonly state: StateInterface<Enactor>;
+    readonly cost: number;
+    readonly next: ActionNode<Enactor> | null | undefined;
+    constructor(action: ActionInterface<Enactor>, state: StateInterface<Enactor>, cost?: number, next?: ActionNode<Enactor> | null | undefined);
+    cumulativeCost(): number;
+}
+
+/** @public */
+export declare enum ActionProcessingResult {
+    Executing = 0,
+    Finished = 1,
+    Aborted = 2
+}
+
+/** @public */
+export declare abstract class ActionWithTarget<E extends WithActionSlots & WithMover<T>, D = any, T = any> extends Action<E, D> implements ActionWithTargetInterface<E, D, T> {
+    /* Excluded from this release type: targetTag */
+    readonly targetBit: any;
+    /* Excluded from this release type: prepare */
+    /* Excluded from this release type: exit */
+    getAssignedTarget(enactor: E): T | undefined;
+    getMoveTarget(enactor: E): T | undefined;
+    setMoveTarget(enactor: E, target?: T): void;
+    clearMoveTarget(enactor: E): void;
+    moveToTarget(enactor: E, delta: number): boolean;
+}
+
+/** @public */
+export declare interface ActionWithTargetInterface<Enactor extends WithMover<Target>, Data = any, Target = any> extends ActionInterface<Enactor, Data> {
+    readonly targetBit?: any;
+    getAssignedTarget(enactor: Enactor): Target | undefined;
+    setMoveTarget(enactor: Enactor, target?: Target): void;
+    getMoveTarget(enactor: Enactor): Target | undefined;
+    moveToTarget(enactor: Enactor, delta: number): boolean;
+    clearMoveTarget(enactor: Enactor): void;
+}
+
+/** @public */
+export declare type BitArg<Enactor> = StateBitInterface<Enactor> | StateBitTuple<Enactor>;
+
+/** @public */
+export declare class DebuggedGoalActionPlanner<Enactor extends ActionEnactorInterface> extends GoalActionPlanner<Enactor> {
+    /* Excluded from this release type: planGoal */
+    /* Excluded from this release type: planNode */
+}
+
+/** @public */
+export declare type DynamicStateBit<Enactor = unknown> = StateBitInterface<Enactor> & {
+    isFulfilledBy: (actor: Enactor) => boolean;
+};
+
+/** @public */
+export declare class EnactorState<Enactor> extends Map<StateBitInterface<Enactor>, boolean> implements MutableStateInterface<Enactor> {
+    #private;
+    constructor(bits?: null | Iterable<StateBitInterface<Enactor> | StateBitTuple<Enactor>>);
+    get bits(): StateBits<Enactor>;
+    get dynamicBits(): Iterable<DynamicStateBit<Enactor>>;
+    isEmpty(): boolean;
+    set(key: StateBitInterface<Enactor>, value: boolean): this;
+    delete(key: StateBitInterface<Enactor>): boolean;
+    setAll(bits: StateBitTuples<Enactor>): this;
+    unsetAll(bits: StateBits<Enactor>): this;
+    isAdvancedBy(state: StateBitTuples<Enactor>): StateAdvancement;
+    isFulfilledBy(state: StateBitTuples<Enactor>): boolean;
+    merge(other: StateBitTuples<Enactor>): StateInterface<Enactor>;
+    subtract(other: StateInterface<Enactor>): StateInterface<Enactor>;
+    withoutMatching(other: StateInterface<Enactor>): StateInterface<Enactor>;
+    getDynamic(enactor: Enactor, skip: StateInterface<Enactor>): StateInterface<Enactor> | undefined;
+    map<R>(mapper: (bit: StateBitInterface<Enactor>, state: boolean, index: number) => R): R[];
+    toString(): string;
+}
+
+/** @public */
+export declare class GoalActionExecutor<A extends ActionEnactorInterface> implements GoalActionExecutorInterface<A> {
+    abortMultiplier: number;
+    constructor(abortMultiplier?: number);
+    process(enactor: A, delta: number): boolean;
+    protected handleCurrent(enactor: A, action: ActionInterface<A>, delta: number): ActionProcessingResult;
+    protected handleResult(enactor: A, action: ActionInterface<A>, status: ActionCompletionResult): void;
+}
+
+/** @public */
+export declare interface GoalActionExecutorInterface<Enactor> {
+    process(enactor: Enactor, delta: number): boolean;
+}
+
+/** @public */
+export declare class GoalActionPlanner<Enactor extends ActionEnactorInterface> implements GoalActionPlannerInterface<Enactor> {
+    plan(enactor: Enactor, goal: StateInterface<Enactor>, state: StateInterface<Enactor>): ActionInterface<Enactor>[] | undefined;
+    simplifyGoal(base: StateInterface<Enactor>, state: StateInterface<Enactor>): EnactorState<Enactor> | undefined;
+    traverseGoal(enactor: Enactor, goal: StateInterface<Enactor>, state: StateInterface<Enactor>): ActionInterface<Enactor>[] | undefined;
+    planGoal<Ctx extends PlannerContext<Enactor>>(context: Ctx, goal: StateInterface<Enactor>): ActionInterface<Enactor>[] | undefined;
+    pickActions(paths: ActionNode<Enactor>[]): ActionInterface<Enactor>[] | undefined;
+    planNode<Ctx extends PlannerContext<Enactor>>(context: Ctx, actions: Set<ActionInterface<Enactor>>, goal: StateInterface<Enactor>, next?: ActionNode<Enactor> | null): ActionNode<Enactor>[];
+}
+
+/** @public */
+export declare interface GoalActionPlannerInterface<Enactor> {
+    plan(enactor: Enactor, goal: StateInterface<Enactor>, state: StateInterface<Enactor>): ActionInterface<Enactor>[] | undefined;
+}
+
+/** @public */
+export declare const isActionWithTarget: (action: any) => action is ActionWithTargetInterface<any>;
+
+/** @public */
+export declare interface MutableStateInterface<Enactor = unknown> extends StateInterface<Enactor> {
+    set(bit: StateBitInterface<Enactor>, value: boolean): this;
+    delete(bit: StateBitInterface<Enactor>): boolean;
+    setAll(other: StateBitTuples<Enactor>): this;
+    unsetAll(other: Iterable<StateBitInterface<Enactor>>): this;
+}
+
+/** @public */
+export declare class PlanDebugger {
+    goal: StateInterface<any>;
+    state: StateInterface<any>;
+    action?: ActionInterface<any> | undefined;
+    data: PlanNodeData;
+    noMoreActions: boolean;
+    dead: boolean;
+    children: PlanDebugger[];
+    constructor(goal: StateInterface<any>, state: StateInterface<any>, action?: ActionInterface<any> | undefined, data?: PlanNodeData);
+    nest(action: ActionInterface<any>, goal: StateInterface<any>, state: StateInterface<any>, data: PlanNodeData): PlanDebugger;
+    map<U>(mapper: (node: PlanDebugger) => U): U[];
+    describe(depth?: number): string[];
+}
+
+/** @public */
+export declare type PlannerContext<Enactor, T = {}> = T & {
+    enactor: Enactor;
+    state: MutableStateInterface<Enactor>;
+    dynamicCache: StateInterface<Enactor>;
+};
+
+/** @public */
+export declare type PlanNodeData = Partial<{
+    advancement: any;
+    isAdvancing: any;
+    isFulfilling: any;
+    isLeaf: any;
+    dynamic: any;
+}>;
+
+/** @public */
+export declare const reconstructSequenceFromNodes: <E>(node: ActionNode<E> | null | undefined) => ActionInterface<E>[];
+
+/** @public */
+export declare enum StateAdvancement {
+    None = 0,
+    Advance = 1,
+    Detract = 2,
+    Fulfill = 3
+}
+
+/** @public */
+export declare interface StateBitInterface<Enactor = unknown> {
+    name: string;
+    isolated?: boolean;
+    isFulfilledBy?: (actor: Enactor) => boolean;
+}
+
+/** @public */
+export declare type StateBits<Enactor = unknown> = Iterable<StateBitInterface<Enactor>>;
+
+/** @public */
+export declare type StateBitTuple<Enactor = unknown> = [bit: StateBitInterface<Enactor>, value: boolean];
+
+/** @public */
+export declare type StateBitTuples<Enactor = unknown> = Iterable<StateBitTuple<Enactor>>;
+
+/** @public */
+export declare type StateChangeEvent<Actor = any> = {
+    state: StateInterface<Actor>;
+    bits: Set<StateBitInterface<Actor>>;
+};
+
+/** @public */
+export declare interface StateInterface<Enactor = unknown> extends Iterable<[StateBitInterface<Enactor>, boolean]> {
+    readonly bits: StateBits<Enactor>;
+    readonly dynamicBits: Iterable<DynamicStateBit<Enactor>>;
+    size: number;
+    has(bit: StateBitInterface<Enactor>): boolean;
+    get(bit: StateBitInterface<Enactor>): boolean | undefined;
+    withoutMatching(other: StateInterface<Enactor>): StateInterface<Enactor>;
+    merge(other: StateBitTuples<Enactor>): StateInterface<Enactor>;
+    subtract(other: StateInterface<Enactor>): StateInterface<Enactor>;
+    getDynamic(enactor: Enactor, skip: StateInterface<Enactor>): StateInterface<Enactor> | undefined;
+    map<R>(mapper: (bit: StateBitInterface<Enactor>, state: boolean, index: number) => R): R[];
+    isEmpty(): boolean;
+    isAdvancedBy(state: StateBitTuples<Enactor>): StateAdvancement;
+    isFulfilledBy(state: StateBitTuples<Enactor>): boolean;
+}
+
+/** @public */
+export declare const toIterableBits: <Enactor>(bits: Iterable<BitArg<Enactor>> | BitArg<Enactor>[]) => (readonly [StateBitInterface<Enactor>, boolean])[] | undefined;
+
+/** @public */
+export declare interface WithActionSlots {
+    slots: Map<any, any>;
+    getDataInSlot<T>(slot: any): T | undefined;
+    getDataInSlot<T>(slot: any, factory: (actor: this) => T): T;
+    getDataInSlot<T>(slot: any, factory?: (actor: this) => T | undefined): T | undefined;
+    putDataInSlot<T>(slot: any, value: T): T;
+    clearSlot(slot: any): void;
+}
+
+/** @public */
+export declare interface WithMover<Target = any> {
+    moveToTarget(target: Target, delta: number): boolean;
+}
+
+/** @public */
+export declare interface WithState<Enactor> {
+    getCurrentState(): MutableStateInterface<Enactor>;
+    getStateBit(bit: StateBitInterface<Enactor>): boolean;
+    setStateBit(bit: StateBitInterface<Enactor>, value: boolean): boolean;
+    unsetStateBit(bit: StateBitInterface<Enactor>): void;
+    setStateBits(all: StateInterface<Enactor>): void;
+    unsetStateBits(all: Iterable<StateBitInterface<Enactor>>): void;
+    onStateChange(handler: IEventHandler<StateChangeEvent<Enactor>>): () => void;
+}
+
+export { }

package/dist/index.js

@@ -0,0 +1,386 @@
+//#region src/interfaces/StateInterface.ts
+var e = /* @__PURE__ */ function(e) {
+	return e[e.None = 0] = "None", e[e.Advance = 1] = "Advance", e[e.Detract = 2] = "Detract", e[e.Fulfill = 3] = "Fulfill", e;
+}({}), t = /* @__PURE__ */ function(e) {
+	return e[e.Executing = 0] = "Executing", e[e.Finished = 1] = "Finished", e[e.Aborted = 2] = "Aborted", e;
+}({}), n = class {
+	cost = 1;
+	get name() {
+		return this.constructor.name;
+	}
+	get type() {
+		return this.name.replace(/Action$/, "");
+	}
+	prepare(e) {
+		e.clearSlot(this);
+	}
+	exit(e, t) {}
+	getAssociatedData(e) {
+		return e.getDataInSlot(this);
+	}
+	describe() {
+		return `${this.name} [${this.requires} => ${this.provides}]`;
+	}
+	toString() {
+		return this.name;
+	}
+}, r = (e) => "targetBit" in e, i = class extends n {
+	targetTag = {};
+	targetBit;
+	prepare(e) {
+		this.targetBit && this.setMoveTarget(e, e.getDataInSlot(this.targetBit)), super.prepare(e);
+	}
+	exit(e) {
+		e.clearSlot(this.targetBit);
+	}
+	getAssignedTarget(e) {
+		return e.getDataInSlot(this.targetBit);
+	}
+	getMoveTarget(e) {
+		return e.getDataInSlot(this.targetTag);
+	}
+	setMoveTarget(e, t) {
+		e.putDataInSlot(this.targetTag, t);
+	}
+	clearMoveTarget(e) {
+		e.clearSlot(this.targetTag);
+	}
+	moveToTarget(e, t) {
+		let n = this.getMoveTarget(e);
+		if (n) if (e.moveToTarget(n, t)) this.clearMoveTarget(e);
+		else return !0;
+		return !1;
+	}
+}, a = class {
+	action;
+	state;
+	cost = 0;
+	next = null;
+	constructor(e, t, n = 0, r = null) {
+		this.next = r, this.cost = n, this.state = t, this.action = e;
+	}
+	cumulativeCost() {
+		return (this.next ? this.next.cumulativeCost() : 0) + this.cost;
+	}
+}, o = (e) => e instanceof d, s = (e) => Array.isArray(e), c = (e) => !!e.isFulfilledBy, l = ([e, t], n) => {
+	let r = String(e.name || n);
+	return t ? "+" + r.toUpperCase() : "-" + r.toLowerCase();
+}, u = (e) => {
+	let t = Array.isArray(e) ? e : [...e];
+	if (t.length) return t.map((e) => s(e) ? e : [e, !0]);
+}, d = class t extends Map {
+	#e;
+	constructor(e) {
+		if (super(), e) {
+			let t = o(e) ? e.size && e : u(e);
+			if (t) for (let [e, n] of t) super.set(e, n);
+		}
+	}
+	get bits() {
+		return this.keys();
+	}
+	get dynamicBits() {
+		return this.#e ||= new Set([...this.bits].filter(c));
+	}
+	isEmpty() {
+		return !this.size;
+	}
+	set(e, t) {
+		return this.#e && c(e) && this.#e.add(e), super.set(e, t);
+	}
+	delete(e) {
+		return this.#e && c(e) && this.#e.delete(e), super.delete(e);
+	}
+	setAll(e) {
+		for (let [t, n] of e) this.set(t, n);
+		return this;
+	}
+	unsetAll(e) {
+		for (let t of e) this.delete(t);
+		return this;
+	}
+	isAdvancedBy(t) {
+		let n = 0;
+		for (let [r, i] of t) {
+			let t = this.get(r);
+			if (t !== void 0) {
+				if (t !== i) return e.Detract;
+				n++;
+			}
+		}
+		return n === this.size ? e.Fulfill : n ? e.Advance : e.None;
+	}
+	isFulfilledBy(t) {
+		return this.size ? this.isAdvancedBy(t) === e.Fulfill : !0;
+	}
+	merge(e) {
+		return new t([...this, ...e]);
+	}
+	subtract(e) {
+		return new t([...this].filter(([t]) => !e.has(t)));
+	}
+	withoutMatching(e) {
+		if (!this.size) return this;
+		let n = [];
+		for (let t of this) e.get(t[0]) !== t[1] && n.push(t);
+		return new t(n);
+	}
+	getDynamic(e, n) {
+		let r = [];
+		for (let t of this.dynamicBits) n.has(t) || r.push([t, t.isFulfilledBy(e)]);
+		if (r.length) return new t(r);
+	}
+	map(e) {
+		let t = Array(this.size), n = 0;
+		for (let [r, i] of this) t[n] = e(r, i, n), n++;
+		return t;
+	}
+	toString() {
+		return this.size ? "{ " + [...this].map(l).join(", ") + " }" : "{}";
+	}
+}, f = (e) => {
+	let t = [];
+	for (; e;) t.push(e.action), e = e.next;
+	return t;
+}, p = class {
+	plan(e, t, n) {
+		if (!e.actions.size || t.isEmpty()) return;
+		let r = this.simplifyGoal(t, n);
+		if (r) return this.traverseGoal(e, r, n);
+	}
+	simplifyGoal(e, t) {
+		let n;
+		for (let [r, i] of e) {
+			let e = t.get(r);
+			e === i || e === void 0 && !i || (n ? n.set(r, i) : n = new d([[r, i]]));
+		}
+		return n;
+	}
+	traverseGoal(e, t, n) {
+		let r = {
+			enactor: e,
+			state: new d(n),
+			dynamicCache: new d()
+		};
+		if (t.size === 1) return this.planGoal(r, t);
+		let i;
+		for (let e of t) if (e[0].isolated) {
+			let t = this.planGoal(r, new d([e]));
+			if (t) return t;
+		} else i ? i.push(e) : i = [e];
+		return i && this.planGoal(r, new d(i));
+	}
+	planGoal(e, t) {
+		let n = this.planNode(e, e.enactor.actions, t);
+		e.enactor.setStateBits(e.state);
+		let r = this.pickActions(n);
+		if (r) {
+			for (let t of r) t.prepare(e.enactor);
+			return r;
+		}
+	}
+	pickActions(e) {
+		let t = e[0];
+		if (e.length > 1) {
+			let n = t.cumulativeCost(), r = 0, i;
+			for (; i = e[++r];) {
+				let e = i.cumulativeCost();
+				e < n && (n = e, t = i);
+			}
+		}
+		if (t) return f(t);
+	}
+	planNode(t, n, r, i) {
+		let { enactor: o, state: s, dynamicCache: c } = t, l = [], u = new Set(n);
+		for (let d of n) {
+			let n = r.isAdvancedBy(d.provides), f = n === e.Advance, p = n === e.Fulfill;
+			if (f || p) {
+				let e = d.requires.getDynamic(o, c);
+				e && s.setAll(e);
+				let n = p && d.requires.isFulfilledBy(s), f = new a(d, s.merge(d.provides), o.getActionCost(d), i);
+				if (n) l.push(f);
+				else if (u.size > 1) {
+					u.delete(d);
+					let e = r.subtract(d.provides).merge(d.requires).withoutMatching(s), n = this.planNode(t, u, e, f);
+					n.length && l.push(...n);
+				}
+			}
+		}
+		return l;
+	}
+}, m = class e {
+	goal;
+	state;
+	action;
+	data = {};
+	noMoreActions = !1;
+	dead = !1;
+	children = [];
+	constructor(e, t, n, r = {}) {
+		this.data = r, this.action = n, this.state = t, this.goal = e;
+	}
+	nest(t, n, r, i) {
+		let a = new e(n, r, t, i);
+		return this.children.push(a), a;
+	}
+	map(e) {
+		return this.children.map(e);
+	}
+	describe(e = 0) {
+		let t = `[${[
+			this.data.isAdvancing ? "A" : " ",
+			this.data.isFulfilling ? "F" : " ",
+			this.data.isLeaf ? "L" : " "
+		].filter(Boolean).join("")}]`, n = this.data.dynamic ? this.state.withoutMatching(this.data.dynamic) : this.state, r = [`${t} : ${this.action ? this.action.describe() : "< root >"}`], i = "".padStart(t.length + 4), a = [`  ? GOAL  => ${this.goal.toString()}`, `  = STATE => ${n.toString()} ${this.data.dynamic ? ` + ${String(this.data.dynamic)}` : ""}`];
+		for (let t of this.children) a.push(" ", ...t.describe(e + 1));
+		return r.push(...[
+			...a,
+			this.dead && "  : DEAD END",
+			this.noMoreActions && "  : NO ACTIONS LEFT"
+		].map((e) => e && i + e)), r.filter((e) => !!e);
+	}
+}, h = class extends p {
+	planGoal(e, t) {
+		let n = new m(new d(t), new d(e.state)), r = this.planNode({
+			...e,
+			logger: n
+		}, e.enactor.actions, t, null);
+		e.enactor.setStateBits(e.state);
+		let i = this.pickActions(r);
+		if (i) for (let t of i) t.prepare(e.enactor);
+		return n && console.log(n.describe().join("\n")), i;
+	}
+	planNode(t, n, r, i) {
+		let o = [], s = new Set(n);
+		for (let c of n) {
+			let n = r.isAdvancedBy(c.provides), l = n === e.Advance, u = n === e.Fulfill;
+			if (l || u) {
+				let e = c.requires.getDynamic(t.enactor, t.dynamicCache);
+				e && t.state.setAll(e);
+				let f = u && c.requires.isFulfilledBy(t.state), p = new a(c, t.state.merge(c.provides), t.enactor.getActionCost(c), i), m = t.logger?.nest(c, r.subtract(c.provides).merge(c.requires).withoutMatching(t.state), new d(t.state), {
+					advancement: n,
+					isAdvancing: l,
+					isFulfilling: u,
+					isLeaf: f,
+					dynamic: e
+				});
+				if (f) o.push(p);
+				else if (s.size > 1) {
+					s.delete(c);
+					let e = r.subtract(c.provides).merge(c.requires).withoutMatching(t.state), n = this.planNode({
+						...t,
+						logger: m
+					}, s, e, p);
+					n.length && o.push(...n);
+				} else m && (m.noMoreActions = !0);
+			}
+		}
+		return t.logger && !o.length && (t.logger.dead = !0), o;
+	}
+};
+//#endregion
+//#region src/ActionEnactor.ts
+function g(e) {
+	return class extends e {
+		#e = new d();
+		#t = /* @__PURE__ */ new Map();
+		#n;
+		#r;
+		#i = 0;
+		actions = /* @__PURE__ */ new Set();
+		changeActions(e, t) {
+			if (t) {
+				for (let t of e) this.actions.add(t);
+				return !1;
+			}
+			let n = !1;
+			for (let t of e) this.actions.delete(t), !n && this.#r?.includes(t) && (n = !0);
+			return n && this.dropSequence(), n;
+		}
+		get top() {
+			return this.#n;
+		}
+		set top(e) {
+			this.#n !== e && (this.#n?.toggles && this.unsetStateBits(this.#n.toggles.bits), this.#n = e, e?.toggles && this.setStateBits(e.toggles));
+		}
+		get sequence() {
+			return this.#r;
+		}
+		set sequence(e) {
+			this.#r = e, this.#i = 0, this.top = e?.[0];
+		}
+		getActionCost(e) {
+			return this.#t.has(e) ? this.#t.get(e) : e.cost;
+		}
+		setActionCost(e, t) {
+			this.#t.set(e, Math.min(t, 500));
+		}
+		update(e) {
+			super.update(e), this.slideActionCost(e);
+		}
+		slideActionCost(e) {
+			if (!this.#t.size) return;
+			let t = [...this.#t];
+			for (let [n, r] of t) {
+				let t = r - e;
+				t <= n.cost ? this.#t.delete(n) : this.#t.set(n, t);
+			}
+		}
+		deriveGoal() {
+			return this.#e;
+		}
+		getGoalBit(e) {
+			return !!this.#e.get(e);
+		}
+		setGoalBit(e, t) {
+			this.#e.set(e, t);
+		}
+		dropSequence() {
+			this.sequence = void 0;
+		}
+		acceptSequence(e) {
+			return this.sequence = e, !0;
+		}
+		nextAction() {
+			if (this.#r) {
+				if (this.#i < this.#r.length - 1) return this.#i++, this.top = this.#r[this.#i], !0;
+				this.sequence = void 0;
+			}
+			return !1;
+		}
+	};
+}
+//#endregion
+//#region src/GoalActionExecutor.ts
+var _ = class {
+	abortMultiplier;
+	constructor(e = 1.01) {
+		this.abortMultiplier = e;
+	}
+	process(e, n) {
+		let r = e.top;
+		if (!r) return !1;
+		let i = r.requires.isFulfilledBy(e.getCurrentState()) ? this.handleCurrent(e, r, n) : t.Aborted;
+		return i === t.Executing ? !0 : (this.handleResult(e, r, i), !1);
+	}
+	handleCurrent(e, n, i) {
+		if (r(n) && n.moveToTarget(e, i)) return t.Executing;
+		let a = n.process(e, i);
+		switch (a) {
+			case t.Finished:
+				e.setStateBits(n.provides), e.nextAction() && n.consumes && e.unsetStateBits(n.consumes);
+				break;
+			case t.Aborted:
+				e.setActionCost(n, n.cost * this.abortMultiplier);
+				break;
+		}
+		return a;
+	}
+	handleResult(e, t, n) {
+		t.exit(e, n), t.consumes && e.unsetStateBits(t.consumes), t.toggles && e.unsetStateBits(t.toggles.bits);
+	}
+};
+//#endregion
+export { n as Action, g as ActionEnactor, a as ActionNode, t as ActionProcessingResult, i as ActionWithTarget, h as DebuggedGoalActionPlanner, d as EnactorState, _ as GoalActionExecutor, p as GoalActionPlanner, m as PlanDebugger, e as StateAdvancement, r as isActionWithTarget, f as reconstructSequenceFromNodes, u as toIterableBits };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["#dynamic","#goal","#costs","#sequence","#top","#sequenceIndex"],"sources":["../src/interfaces/StateInterface.ts","../src/interfaces/ActionInterface.ts","../src/action/Action.ts","../src/action/ActionWithTarget.ts","../src/planner/ActionNode.ts","../src/EnactorState.ts","../src/planner/GoalActionPlanner.ts","../src/planner/PlanDebugger.ts","../src/planner/DebuggedGoalActionPlanner.ts","../src/ActionEnactor.ts","../src/GoalActionExecutor.ts"],"sourcesContent":["/** @public */\nexport enum StateAdvancement {\n    None = 0,\n    Advance = 1,\n    Detract = 2,\n    Fulfill = 3,\n}\n\n/** @public */\nexport interface StateBitInterface<Enactor = unknown> {\n    name: string;\n    isolated?: boolean;\n    isFulfilledBy?: (actor: Enactor) => boolean;\n}\n\n/** @public */\nexport type DynamicStateBit<Enactor = unknown> = StateBitInterface<Enactor> & {\n    isFulfilledBy: (actor: Enactor) => boolean;\n};\n\n/** @public */\nexport type StateBitTuple<Enactor = unknown> = [bit: StateBitInterface<Enactor>, value: boolean];\n\n/** @public */\nexport type StateBitTuples<Enactor = unknown> = Iterable<StateBitTuple<Enactor>>;\n\n/** @public */\nexport type StateBits<Enactor = unknown> = Iterable<StateBitInterface<Enactor>>;\n\n/** @public */\nexport interface StateInterface<Enactor = unknown> extends Iterable<[StateBitInterface<Enactor>, boolean]> {\n    readonly bits: StateBits<Enactor>;\n    readonly dynamicBits: Iterable<DynamicStateBit<Enactor>>;\n\n    size: number;\n    has(bit: StateBitInterface<Enactor>): boolean;\n    get(bit: StateBitInterface<Enactor>): boolean | undefined;\n    withoutMatching(other: StateInterface<Enactor>): StateInterface<Enactor>;\n    merge(other: StateBitTuples<Enactor>): StateInterface<Enactor>;\n    subtract(other: StateInterface<Enactor>): StateInterface<Enactor>;\n    getDynamic(enactor: Enactor, skip: StateInterface<Enactor>): StateInterface<Enactor> | undefined;\n    map<R>(mapper: (bit: StateBitInterface<Enactor>, state: boolean, index: number) => R): R[];\n\n    isEmpty(): boolean;\n    isAdvancedBy(state: StateBitTuples<Enactor>): StateAdvancement;\n    isFulfilledBy(state: StateBitTuples<Enactor>): boolean;\n}\n\n","import type { StateBitInterface, StateInterface } from './StateInterface';\n\n/** @public */\nexport enum ActionProcessingResult {\n    Executing,\n    Finished,\n    Aborted,\n}\n\n/** @public */\nexport type ActionCompletionResult = Exclude<ActionProcessingResult, ActionProcessingResult.Executing>;\n\n/** @public */\nexport interface ActionInterface<Enactor, Data = any> {\n    readonly type: string;\n    readonly cost: number;\n    readonly requires: StateInterface<Enactor>;\n    readonly provides: StateInterface<Enactor>;\n    readonly toggles?: StateInterface<Enactor>;\n    readonly consumes?: StateBitInterface<Enactor>[];\n\n    prepare(enactor: Enactor): void;\n    exit(enactor: Enactor, result: ActionCompletionResult): void;\n    getAssociatedData(enactor: Enactor): Data;\n    process(enactor: Enactor, delta: number): ActionProcessingResult;\n    describe(): string;\n}\n","import type {\n    ActionCompletionResult,\n    ActionInterface,\n    ActionProcessingResult,\n    StateBitInterface,\n    StateInterface,\n    WithActionSlots,\n} from '../interfaces';\n\n/** @public */\nexport abstract class Action<E extends WithActionSlots, D = any>\n    implements ActionInterface<E, D>\n{\n    public readonly cost: number = 1;\n    public declare provides: StateInterface<E>;\n    public declare requires: StateInterface<E>;\n    public declare toggles?: StateInterface<E>;\n    public declare consumes?: StateBitInterface<E>[];\n\n    public abstract process(enactor: E, delta: number): ActionProcessingResult;\n\n    public get name(): string {\n        return this.constructor.name;\n    }\n\n    public get type(): string {\n        return this.name.replace(/Action$/, '');\n    }\n\n    public prepare(enactor: E): void {\n        enactor.clearSlot(this);\n    }\n\n    public exit(_enactor: E, _result: ActionCompletionResult): void {\n    }\n\n    public getAssociatedData(enactor: E): D {\n        return enactor.getDataInSlot<D>(this)!;\n    }\n\n    public describe() {\n        return `${this.name} [${this.requires} => ${this.provides}]`;\n    }\n\n    public toString() {\n        return this.name;\n    }\n}\n","import type { ActionWithTargetInterface, WithActionSlots, WithMover } from '../interfaces';\nimport { Action } from './Action';\n\n/** @public */\nexport const isActionWithTarget = (action: any): action is ActionWithTargetInterface<any> => (\n    'targetBit' in action\n);\n\n/** @public */\nexport abstract class ActionWithTarget<E extends WithActionSlots & WithMover<T>, D = any, T = any>\n    extends Action<E,  D>\n    implements ActionWithTargetInterface<E, D, T>\n{\n    /** @internal */\n    private readonly targetTag = {};\n    public readonly targetBit: any;\n\n    /** @internal */\n    public prepare(enactor: E): void {\n        if (this.targetBit) {\n            this.setMoveTarget(enactor, enactor.getDataInSlot(this.targetBit));\n        }\n\n        super.prepare(enactor);\n    }\n\n    /** @internal */\n    public exit(enactor: E) {\n        enactor.clearSlot(this.targetBit);\n    }\n\n    public getAssignedTarget(enactor: E): T|undefined {\n        return enactor.getDataInSlot(this.targetBit);\n    }\n\n    public getMoveTarget(enactor: E): T|undefined {\n        return enactor.getDataInSlot(this.targetTag);\n    }\n\n    public setMoveTarget(enactor: E, target?: T): void {\n        enactor.putDataInSlot(this.targetTag, target);\n    }\n\n    public clearMoveTarget(enactor: E) {\n        enactor.clearSlot(this.targetTag);\n    }\n\n    public moveToTarget(enactor: E, delta: number): boolean {\n        const target = this.getMoveTarget(enactor);\n\n        if (target) {\n            const arrived = enactor.moveToTarget(target, delta);\n\n            if (arrived) {\n                this.clearMoveTarget(enactor);\n            } else {\n                return true;\n            }\n        }\n\n        return false;\n    }\n}\n","import type { ActionInterface, StateInterface } from '../interfaces';\n\n/** @public */\nexport class ActionNode<Enactor> {\n    public readonly action: ActionInterface<Enactor>;\n    public readonly state: StateInterface<Enactor>;\n    public readonly cost: number = 0;\n    public readonly next: ActionNode<Enactor> | null | undefined = null;\n\n    public constructor(\n        action: ActionInterface<Enactor>,\n        state: StateInterface<Enactor>,\n        cost: number = 0,\n        next: ActionNode<Enactor> | null | undefined = null,\n    ) {\n        this.next = next;\n        this.cost = cost;\n        this.state = state;\n        this.action = action;\n    }\n\n    public cumulativeCost(): number {\n        return (this.next ? this.next.cumulativeCost() : 0) + this.cost;\n    }\n}\n","import type {\n    DynamicStateBit,\n    MutableStateInterface,\n    StateBitInterface,\n    StateBits,\n    StateBitTuple,\n    StateBitTuples,\n    StateInterface,\n} from './interfaces';\nimport { StateAdvancement } from './interfaces';\n\n/** @public */\nexport type BitArg<Enactor> = StateBitInterface<Enactor> | StateBitTuple<Enactor>;\n\nconst isState = <Enactor>(other: any): other is StateInterface<Enactor> => other instanceof EnactorState;\nconst isEntry = <Enactor>(bit: BitArg<Enactor>): bit is StateBitTuple<Enactor> => (\n    Array.isArray(bit)\n);\nconst isDynamic = <Enactor>(bit: StateBitInterface<Enactor>): bit is DynamicStateBit<Enactor> => !!bit.isFulfilledBy;\n\nconst bitToString = ([bit, value]: StateBitTuple<any>, index: number) => {\n    const name = String((bit as any).name || index);\n\n    return value ? ('+' + name.toUpperCase()) : ('-' + name.toLowerCase());\n}\n\n/** @public */\nexport const toIterableBits = <Enactor>(bits: Iterable<BitArg<Enactor>> | BitArg<Enactor>[]) => {\n    const mappable = Array.isArray(bits) ? bits : [...bits];\n\n    if (!mappable.length) {\n        return;\n    }\n\n    return mappable.map((bit) => isEntry(bit) ? bit : ([bit, true as boolean] as const));\n};\n\n/** @public */\nexport class EnactorState<Enactor> extends Map<StateBitInterface<Enactor>, boolean> implements MutableStateInterface<Enactor> {\n    #dynamic?: Set<DynamicStateBit<Enactor>>;\n\n    public constructor(bits?: null | Iterable<StateBitInterface<Enactor> | StateBitTuple<Enactor>>) {\n        super();\n\n        if (bits) {\n            const iterable = isState(bits) ? bits.size && bits : toIterableBits(bits);\n\n            if (iterable) {\n                for (const [bit, value] of iterable) {\n                    super.set(bit, value);\n                }\n            }\n        }\n    }\n\n    public get bits(): StateBits<Enactor> {\n        return this.keys();\n    }\n\n    public get dynamicBits(): Iterable<DynamicStateBit<Enactor>> {\n        return this.#dynamic || (this.#dynamic = new Set([...this.bits].filter(isDynamic)));\n    }\n\n    public isEmpty(): boolean {\n        return !this.size;\n    }\n\n    public set(key: StateBitInterface<Enactor>, value: boolean): this {\n        if (this.#dynamic && isDynamic(key)) {\n            this.#dynamic.add(key);\n        }\n\n        return super.set(key, value) as this;\n    }\n\n    public delete(key: StateBitInterface<Enactor>): boolean {\n        if (this.#dynamic && isDynamic(key)) {\n            this.#dynamic.delete(key);\n        }\n\n        return super.delete(key);\n    }\n\n    public setAll(bits: StateBitTuples<Enactor>): this {\n        for (const [bit, value] of bits) {\n            this.set(bit, value);\n        }\n\n        return this;\n    }\n\n    public unsetAll(bits: StateBits<Enactor>): this {\n        for (const bit of bits) {\n            this.delete(bit);\n        }\n\n        return this;\n    }\n\n    public isAdvancedBy(state: StateBitTuples<Enactor>): StateAdvancement {\n        let advanced = 0;\n\n        for (const [bit, value] of state) {\n            const has = this.get(bit) as boolean | undefined;\n\n            if (has === undefined) {\n                continue;\n            }\n\n            if (has !== value) {\n                return StateAdvancement.Detract;\n            }\n\n            advanced++;\n        }\n\n        if (advanced === this.size) {\n            return StateAdvancement.Fulfill;\n        }\n\n        return advanced ? StateAdvancement.Advance : StateAdvancement.None;\n    }\n\n    public isFulfilledBy(state: StateBitTuples<Enactor>): boolean {\n        if (!this.size) {\n            return true;\n        }\n\n        return this.isAdvancedBy(state) === StateAdvancement.Fulfill;\n    }\n\n    public merge(other: StateBitTuples<Enactor>): StateInterface<Enactor> {\n        return new EnactorState(\n            [...this, ...other],\n        );\n    }\n\n    public subtract(other: StateInterface<Enactor>): StateInterface<Enactor> {\n        return new EnactorState(\n            [...this].filter(([bit]) => !other.has(bit)),\n        );\n    }\n\n    public withoutMatching(other: StateInterface<Enactor>): StateInterface<Enactor> {\n        if (!this.size) {\n            return this;\n        }\n\n        const mismatched = [];\n\n        for (const entry of this) {\n            if (other.get(entry[0]) !== entry[1]) {\n                mismatched.push(entry);\n            }\n        }\n\n        return new EnactorState(mismatched);\n    }\n\n    public getDynamic(enactor: Enactor, skip: StateInterface<Enactor>): StateInterface<Enactor> | undefined {\n        const affected: StateBitTuple<Enactor>[] = [];\n\n        for (const bit of this.dynamicBits) {\n            if (!skip.has(bit)) {\n                affected.push([bit, bit.isFulfilledBy(enactor)]);\n            }\n        }\n\n        if (affected.length) {\n            return new EnactorState(affected);\n        }\n    }\n\n    public map<R>(mapper: (bit: StateBitInterface<Enactor>, state: boolean, index: number) => R): R[] {\n        const result = Array(this.size);\n        let index = 0;\n\n        for (const [bit, state] of this) {\n            result[index] = mapper(bit, state, index);\n            index++;\n        }\n\n        return result;\n    }\n\n    public toString() {\n        if (!this.size) {\n            return '{}';\n        }\n\n        return '{ ' + [...this].map(bitToString).join(', ') + ' }';\n    }\n}\n","import type {\n    ActionEnactorInterface,\n    ActionInterface,\n    GoalActionPlannerInterface,\n    PlannerContext,\n    StateBitTuple,\n    StateInterface,\n} from '../interfaces';\nimport { StateAdvancement } from '../interfaces';\nimport { EnactorState } from '../EnactorState';\nimport { ActionNode } from './ActionNode';\n\n/** @public */\nexport const reconstructSequenceFromNodes = <E>(node: ActionNode<E> | null | undefined): ActionInterface<E>[] => {\n    const reconstructed: ActionInterface<E>[] = [];\n\n    while (node) {\n        reconstructed.push(node.action);\n\n        node = node.next;\n    }\n\n    return reconstructed;\n}\n\n/** @public */\nexport class GoalActionPlanner<Enactor extends ActionEnactorInterface> implements GoalActionPlannerInterface<Enactor> {\n    public plan(\n        enactor: Enactor,\n        goal: StateInterface<Enactor>,\n        state: StateInterface<Enactor>,\n    ): ActionInterface<Enactor>[] | undefined {\n        const actions = enactor.actions;\n\n        if (!actions.size || goal.isEmpty()) {\n            return;\n        }\n\n        const endGoal = this.simplifyGoal(goal, state);\n\n        if (endGoal) {\n            return this.traverseGoal(enactor, endGoal, state);\n        }\n    }\n\n    public simplifyGoal(base: StateInterface<Enactor>, state: StateInterface<Enactor>) {\n        let squashed;\n\n        for (const [bit, value] of base) {\n            const has = state.get(bit);\n\n            if (has === value || (has === undefined && !value)) {\n                continue;\n            }\n\n            if (squashed) {\n                squashed.set(bit, value);\n            } else {\n                squashed = new EnactorState<Enactor>([[bit, value]]);\n            }\n        }\n\n        return squashed;\n    }\n\n    public traverseGoal(\n        enactor: Enactor,\n        goal: StateInterface<Enactor>,\n        state: StateInterface<Enactor>,\n    ): ActionInterface<Enactor>[]|undefined {\n        const context: PlannerContext<Enactor> = {\n            enactor,\n            state: new EnactorState(state),\n            dynamicCache: new EnactorState(),\n        };\n\n        if (goal.size === 1) {\n            return this.planGoal(context, goal);\n        }\n\n        let endGoals: StateBitTuple<Enactor>[] | undefined = undefined;\n\n        for (const entry of goal) {\n            if (entry[0].isolated) {\n                const found = this.planGoal(context, new EnactorState([entry]));\n\n                if (found) {\n                    return found;\n                }\n            } else if (endGoals) {\n                endGoals.push(entry);\n            } else {\n                endGoals = [entry];\n            }\n        }\n\n        return endGoals && this.planGoal(context, new EnactorState(endGoals));\n    }\n\n    public planGoal<Ctx extends PlannerContext<Enactor>>(\n        context: Ctx,\n        goal: StateInterface<Enactor>,\n    ): ActionInterface<Enactor>[]|undefined {\n        const paths = this.planNode(context, context.enactor.actions, goal);\n        context.enactor.setStateBits(context.state);\n\n        const cheapest = this.pickActions(paths);\n\n        if (cheapest) {\n            for (const action of cheapest) {\n                action.prepare(context.enactor);\n            }\n\n            return cheapest;\n        }\n    }\n\n    public pickActions(paths: ActionNode<Enactor>[]): ActionInterface<Enactor>[] | undefined {\n        let cheapest = paths[0];\n\n        if (paths.length > 1) {\n            let min = cheapest!.cumulativeCost();\n            let i = 0;\n            let node;\n\n            while ((node = paths[++i])) {\n                const cost = node.cumulativeCost();\n\n                if (cost < min) {\n                    min = cost;\n                    cheapest = node;\n                }\n            }\n        }\n\n        if (cheapest) {\n            return reconstructSequenceFromNodes(cheapest);\n        }\n    }\n\n    public planNode<Ctx extends PlannerContext<Enactor>>(\n        context: Ctx,\n        actions: Set<ActionInterface<Enactor>>,\n        goal: StateInterface<Enactor>,\n        next?: ActionNode<Enactor> | null,\n    ): ActionNode<Enactor>[] {\n        const { enactor, state, dynamicCache } = context;\n        const tree: ActionNode<Enactor>[] = [];\n        const available = new Set(actions);\n\n        for (const action of actions) {\n            const advancement = goal.isAdvancedBy(action.provides);\n            const isAdvancing = advancement === StateAdvancement.Advance;\n            const isFulfilling = advancement === StateAdvancement.Fulfill;\n\n            if (isAdvancing || isFulfilling) {\n                const dynamic = action.requires.getDynamic(enactor, dynamicCache);\n\n                if (dynamic) {\n                    state.setAll(dynamic);\n                }\n\n                const isLeaf = isFulfilling && action.requires.isFulfilledBy(state);\n                const node = new ActionNode(\n                    action,\n                    state.merge(action.provides),\n                    enactor.getActionCost(action),\n                    next,\n                );\n\n                if (isLeaf) {\n                    // available.delete(action);\n                    tree.push(node);\n                } else if (available.size > 1) {\n                    available.delete(action);\n\n                    const chainGoal = goal.subtract(action.provides).merge(action.requires).withoutMatching(state);\n                    const subtree = this.planNode(context, available, chainGoal, node);\n\n                    if (subtree.length) {\n                        tree.push(...subtree);\n                    }\n                }\n            }\n        }\n\n        return tree;\n    }\n}\n","import type { ActionInterface, StateInterface } from '../interfaces';\n\n/** @public */\nexport type PlanNodeData = Partial<{\n    advancement: any;\n    isAdvancing: any;\n    isFulfilling: any;\n    isLeaf: any;\n    dynamic: any;\n}>;\n\n/** @public */\nexport class PlanDebugger {\n    public goal: StateInterface<any>;\n    public state: StateInterface<any>;\n    public action?: ActionInterface<any> | undefined;\n    public data: PlanNodeData = {};\n\n    public noMoreActions: boolean = false;\n    public dead: boolean = false;\n    public children: PlanDebugger[] = [];\n\n    public constructor(\n        goal: StateInterface<any>,\n        state: StateInterface<any>,\n        action?: ActionInterface<any> | undefined,\n        data: PlanNodeData = {},\n    ) {\n        this.data = data;\n        this.action = action;\n        this.state = state;\n        this.goal = goal;\n    }\n\n    public nest(action: ActionInterface<any>, goal: StateInterface<any>, state: StateInterface<any>, data: PlanNodeData): PlanDebugger {\n        const child = new PlanDebugger(goal, state, action, data);\n        this.children.push(child);\n        return child;\n    }\n\n    public map<U>(mapper: (node: PlanDebugger) => U): U[] {\n        return this.children.map(mapper);\n    }\n\n    public describe(depth: number = 0): string[] {\n        const desc = `[${[\n            this.data.isAdvancing ? 'A' : ' ',\n            this.data.isFulfilling ? 'F' : ' ',\n            this.data.isLeaf ? 'L' : ' ',\n        ].filter(Boolean).join('')}]`;\n        const state = this.data.dynamic ? this.state.withoutMatching(this.data.dynamic) : this.state;\n\n        const lines: (string | boolean)[] = [\n            `${desc} : ${this.action ? this.action.describe() : '< root >'}`,\n        ];\n        const pad = ''.padStart(desc.length + 4);\n        const children = [\n            `  ? GOAL  => ${this.goal.toString()}`,\n            `  = STATE => ${state.toString()} ${this.data.dynamic ? ` + ${String(this.data.dynamic)}` : ''}`,\n        ];\n\n        for (const child of this.children) {\n            children.push(' ', ...child.describe(depth + 1));\n        }\n\n        lines.push(...[\n            ...children,\n            this.dead && `  : DEAD END`,\n            this.noMoreActions && `  : NO ACTIONS LEFT`,\n        ].map((line) => line && pad + line));\n\n        return lines.filter((l): l is string => !!l);\n    }\n}\n","import type { ActionEnactorInterface, ActionInterface, PlannerContext, StateInterface } from '../interfaces';\nimport { StateAdvancement } from '../interfaces';\nimport { EnactorState } from '../EnactorState';\nimport { ActionNode } from './ActionNode';\nimport { GoalActionPlanner } from './GoalActionPlanner';\nimport { PlanDebugger } from './PlanDebugger';\n\n/** @public */\nexport class DebuggedGoalActionPlanner<Enactor extends ActionEnactorInterface> extends GoalActionPlanner<Enactor> {\n    /** @internal */\n    protected planGoal(\n        context: PlannerContext<Enactor>,\n        goal: StateInterface<Enactor>\n    ): ActionInterface<Enactor>[]|undefined {\n        // debugger;\n\n        const logger: PlanDebugger|null = new PlanDebugger(new EnactorState(goal), new EnactorState(context.state));\n\n        const paths = this.planNode(\n            { ...context, logger },\n            context.enactor.actions,\n            goal,\n            null,\n        );\n        context.enactor.setStateBits(context.state);\n\n        const cheapest = this.pickActions(paths);\n\n        if (cheapest) {\n            for (const action of cheapest) {\n                action.prepare(context.enactor);\n            }\n        }\n\n        if (logger) {\n            // @ts-ignore\n            console.log(logger.describe().join('\\n'));\n\n            // debugger;\n        }\n\n        return cheapest;\n    }\n\n    /** @internal */\n    // @ts-ignore\n    public planNode<Ctx extends PlannerContext<Enactor, { logger: PlanDebugger|null }>>(\n        context: Ctx,\n        actions: Set<ActionInterface<Enactor>>,\n        goal: StateInterface<Enactor>,\n        next: ActionNode<Enactor> | null,\n    ): ActionNode<Enactor>[] {\n        const tree: ActionNode<Enactor>[] = [];\n        const available = new Set(actions);\n\n        for (const action of actions) {\n            const advancement = goal.isAdvancedBy(action.provides);\n            const isAdvancing = advancement === StateAdvancement.Advance;\n            const isFulfilling = advancement === StateAdvancement.Fulfill;\n\n            if (isAdvancing || isFulfilling) {\n                const dynamic = action.requires.getDynamic(context.enactor, context.dynamicCache);\n\n                if (dynamic) {\n                    context.state.setAll(dynamic);\n                }\n\n                const isLeaf = isFulfilling && action.requires.isFulfilledBy(context.state);\n                const node = new ActionNode(\n                    action,\n                    context.state.merge(action.provides),\n                    context.enactor.getActionCost(action),\n                    next,\n                );\n\n                const logNode = context.logger?.nest(action, goal.subtract(action.provides).merge(action.requires).withoutMatching(context.state), new EnactorState(context.state), {\n                    advancement,\n                    isAdvancing,\n                    isFulfilling,\n                    isLeaf,\n                    dynamic,\n                });\n\n                if (isLeaf) {\n                    // available.delete(action);\n                    tree.push(node);\n                } else if (available.size > 1) {\n                    available.delete(action);\n\n                    const chainGoal = goal.subtract(action.provides).merge(action.requires).withoutMatching(context.state);\n                    const subtree = this.planNode({ ...context, logger: logNode }, available, chainGoal, node);\n\n                    if (subtree.length) {\n                        tree.push(...subtree);\n                    }\n                } else if (logNode) {\n                    logNode.noMoreActions = true;\n                }\n            }\n        }\n\n        if (context.logger && !tree.length) {\n            context.logger.dead = true;\n        }\n\n        return tree;\n    }\n}\n\n","import type { DGCInterface, Class } from '@ankhzet/gcl';\nimport type {\n    WithState,\n    ActionEnactorInterface,\n    MutableStateInterface,\n    ActionInterface,\n    StateInterface,\n    StateBitInterface,\n} from './interfaces';\nimport { EnactorState } from './EnactorState';\n\n/** @public */\nexport function ActionEnactor<Base extends Class<WithState<any> & DGCInterface, any>, T>(Base: Base):\n    Class<InstanceType<Base> & ActionEnactorInterface<T>, ConstructorParameters<Base>>\n{\n    return class ActionEnactorMixin extends Base implements ActionEnactorInterface<T> {\n        readonly #goal: MutableStateInterface<T> = new EnactorState();\n        readonly #costs = new Map<ActionInterface<any>, number>();\n        #top: ActionInterface<T> | undefined;\n        #sequence: ActionInterface<T>[] | undefined;\n        #sequenceIndex: number = 0;\n\n        public readonly actions: Set<ActionInterface<T>> = new Set();\n\n        public changeActions(actions: Set<ActionInterface<T>>, added: boolean): boolean {\n            if (added) {\n                for (const action of actions) {\n                    this.actions.add(action);\n                }\n\n                return false;\n            }\n\n            let fail = false;\n\n            for (const action of actions) {\n                this.actions.delete(action);\n\n                if (!fail && this.#sequence?.includes(action)) {\n                    fail = true;\n                }\n            }\n\n            if (fail) {\n                this.dropSequence();\n            }\n\n            return fail;\n        }\n\n        public get top(): ActionInterface<T> | undefined {\n            return this.#top;\n        }\n\n        /** @internal */\n        public set top(value: ActionInterface<T> | undefined) {\n            if (this.#top === value) {\n                return;\n            }\n\n            if (this.#top?.toggles) {\n                this.unsetStateBits(this.#top.toggles.bits);\n            }\n\n            this.#top = value;\n\n            if (value?.toggles) {\n                this.setStateBits(value.toggles);\n            }\n        }\n\n        public get sequence(): ActionInterface<T>[] | undefined {\n            return this.#sequence;\n        }\n\n        public set sequence(value: ActionInterface<T>[] | undefined) {\n            this.#sequence = value;\n            this.#sequenceIndex = 0;\n            this.top = value?.[0];\n        }\n\n        public getActionCost(action: ActionInterface<any>): number {\n            if (this.#costs.has(action)) {\n                return this.#costs.get(action)!;\n            }\n\n            return action.cost;\n        }\n\n        public setActionCost(action: ActionInterface<any>, cost: number): void {\n            this.#costs.set(action, Math.min(cost, 500));\n        }\n\n        /** @internal */\n        public update(delta: number): void {\n            super.update(delta);\n            this.slideActionCost(delta);\n        }\n\n        public slideActionCost(delta: number): void {\n            if (!this.#costs.size) {\n                return;\n            }\n\n            const entries = [...this.#costs];\n\n            for (const [action, cost] of entries) {\n                const diffed = cost - delta;\n\n                if (diffed <= action.cost) {\n                    this.#costs.delete(action);\n                } else {\n                    this.#costs.set(action, diffed);\n                }\n            }\n        }\n\n        public deriveGoal(): StateInterface<T> {\n            return this.#goal;\n        }\n\n        public getGoalBit(bit: StateBitInterface<T>): boolean {\n            return !!this.#goal.get(bit);\n        }\n\n        public setGoalBit(bit: StateBitInterface<T>, value: boolean): void {\n            this.#goal.set(bit, value);\n        }\n\n        public dropSequence() {\n            this.sequence = undefined;\n        }\n\n        public acceptSequence(sequence: ActionInterface<T>[]): boolean {\n            this.sequence = sequence;\n\n            return true;\n        }\n\n        public nextAction(): boolean {\n            if (this.#sequence) {\n                if (this.#sequenceIndex < this.#sequence.length - 1) {\n                    this.#sequenceIndex++;\n                    this.top = this.#sequence[this.#sequenceIndex];\n\n                    return true;\n                }\n\n                this.sequence = undefined;\n            }\n\n            return false;\n        }\n    } as any;\n}\n","import type {\n    ActionCompletionResult,\n    ActionEnactorInterface,\n    ActionInterface,\n    GoalActionExecutorInterface,\n} from './interfaces';\nimport { ActionProcessingResult } from './interfaces';\nimport { isActionWithTarget } from './action';\n\n/** @public */\nexport class GoalActionExecutor<A extends ActionEnactorInterface> implements GoalActionExecutorInterface<A> {\n    public abortMultiplier: number;\n\n    public constructor(abortMultiplier = 1.01) {\n        this.abortMultiplier = abortMultiplier;\n    }\n\n    public process(enactor: A, delta: number): boolean {\n        const current = enactor.top;\n\n        if (!current) {\n            return false;\n        }\n\n        const state = (\n            current.requires.isFulfilledBy(enactor.getCurrentState())\n                ? this.handleCurrent(enactor, current, delta)\n                : ActionProcessingResult.Aborted\n        );\n\n        if (state === ActionProcessingResult.Executing) {\n            return true;\n        }\n\n        this.handleResult(enactor, current, state);\n\n        return false;\n    }\n\n    protected handleCurrent(enactor: A, action: ActionInterface<A>, delta: number): ActionProcessingResult {\n        if (isActionWithTarget(action) && action.moveToTarget(enactor, delta)) {\n            return ActionProcessingResult.Executing;\n        }\n\n        const state = action.process(enactor, delta);\n\n        switch (state) {\n            case ActionProcessingResult.Finished: {\n                enactor.setStateBits(action.provides);\n\n                if (enactor.nextAction()) {\n                    if (action.consumes) {\n                        enactor.unsetStateBits(action.consumes);\n                    }\n                }\n\n                break;\n            }\n\n            case ActionProcessingResult.Aborted: {\n                enactor.setActionCost(action, action.cost * this.abortMultiplier);\n                break;\n            }\n        }\n\n        return state;\n    }\n\n    protected handleResult(enactor: A, action: ActionInterface<A>, status: ActionCompletionResult): void {\n        action.exit(enactor, status);\n\n        if (action.consumes) {\n            enactor.unsetStateBits(action.consumes);\n        }\n\n        if (action.toggles) {\n            enactor.unsetStateBits(action.toggles.bits);\n        }\n    }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ankhzet/goap",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "author": "AnkhZet ankhzet@gmail.com",
   "type": "module",
   "main": "./src/index.ts",
@@ -9,7 +9,7 @@
     "package.json",
     "src/**/*.ts",
     "src/**/*.tsx",
-    "build",
+    "dist",
     "*.md"
   ],
   "exports": {
@@ -22,8 +22,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@ankhzet/eventual": "1.1.0",
-    "@ankhzet/gcl": "1.1.0"
+    "@ankhzet/eventual": "1.2.0",
+    "@ankhzet/gcl": "1.2.0"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.58.7",