Fixed issue where args were not passed to registered funcs properly a…

…nd subtrees couldnt be registered
nikkorn · Mar 1, 2024 · 814c995 · 814c995
1 parent 1aa7712
commit 814c995
Show file tree

Hide file tree

Showing 10 changed files with 41 additions and 37 deletions.
diff --git a/dist/Agent.d.ts b/dist/Agent.d.ts
@@ -9,7 +9,7 @@ export type ExitFunctionArg = {
     succeeded: boolean;
     aborted: boolean;
 };
-export type FunctionArg = number | string | boolean | null | ExitFunctionArg;
+export type FunctionArg = any | ExitFunctionArg;
 export type ActionResult = CompleteState | Promise<CompleteState> | State.RUNNING | void;
 export type AgentFunction = (this: Agent, ...args: FunctionArg[]) => ActionResult | boolean;
 export type GlobalFunction = (agent: Agent, ...args: FunctionArg[]) => ActionResult | boolean;
diff --git a/dist/bundle.js b/dist/bundle.js
diff --git a/dist/bundle.js.map b/dist/bundle.js.map
diff --git a/dist/index.js b/dist/index.js
diff --git a/dist/index.js.map b/dist/index.js.map
diff --git a/src/Agent.ts b/src/Agent.ts
@@ -34,7 +34,7 @@ export type Agent = {
 */
 
 export type ExitFunctionArg = { succeeded: boolean; aborted: boolean };
-export type FunctionArg = number | string | boolean | null | ExitFunctionArg;
+export type FunctionArg = any | ExitFunctionArg;
 export type ActionResult = CompleteState | Promise<CompleteState> | State.RUNNING | void;
 export type AgentFunction = (this: Agent, ...args: FunctionArg[]) => ActionResult | boolean;
 export type GlobalFunction = (agent: Agent, ...args: FunctionArg[]) => ActionResult | boolean;
diff --git a/src/BehaviourTree.ts b/src/BehaviourTree.ts
@@ -198,7 +198,7 @@ export class BehaviourTree {
             }
 
             // This function should only ever be called with a definition containing a single unnamed root node.
-            if (rootNodeDefinitions.length != 1 || rootNodeDefinitions[0].id !== null) {
+            if (rootNodeDefinitions.length != 1 || typeof rootNodeDefinitions[0].id !== "undefined") {
                 throw new Error("error registering definition: expected a single unnamed root node");
             }
 

diff --git a/src/Lookup.ts b/src/Lookup.ts
@@ -52,7 +52,7 @@ export default class Lookup {
         // The agent does not contain the specified function but it may have been registered at some point.
         if (this.registeredFunctions[name] && typeof this.registeredFunctions[name] === "function") {
             const registeredFunction = this.registeredFunctions[name];
-            return (args: any[]) => registeredFunction(agent, ...args.map((arg) => arg.value));
+            return (args: any[]) => registeredFunction(agent, ...args);
         }
 
         // We have no function to invoke.

diff --git a/test/nodes/leaf/Action.spec.ts b/test/nodes/leaf/Action.spec.ts
@@ -1,8 +1,8 @@
 import { assert } from "chai";
+import sinon from "sinon";
 
 import { BehaviourTree, State } from "../../../src/index";
 import { RootNodeDefinition } from "../../../src/BehaviourTreeDefinition";
-import { Agent } from "../../../src/Agent";
 
 import { findNode } from "../../TestUtilities";
 
@@ -41,39 +41,40 @@ describe("An Action node", () => {
             describe("when the referenced function is", () => {
                 describe("a registered function", () => {
                     it("(MDSL)", () => {
-                        const definition = "root { action [doAction] }";
-
-                        BehaviourTree.register("doAction", () => {
-                            return State.SUCCEEDED;
-                        });
+                        const registeredActionFunction = sinon.stub().returns(State.SUCCEEDED);
+                        BehaviourTree.register("doAction", registeredActionFunction);
 
-                        const tree = new BehaviourTree(definition, {});
+                        const definition = `root { action [doAction, "some-argument"] }`;
+                        const agent = { mock: "agent" };
+                        const tree = new BehaviourTree(definition, agent);
 
                         tree.step();
 
                         const node = findNode(tree, "action", "doAction");
                         assert.strictEqual(node.state, State.SUCCEEDED);
+                        assert.isTrue(registeredActionFunction.calledWith(agent, "some-argument"));
                     });
 
                     it("(JSON)", () => {
+                        const registeredActionFunction = sinon.stub().returns(State.SUCCEEDED);
+                        BehaviourTree.register("doAction", registeredActionFunction);
+
                         const definition: RootNodeDefinition = {
                             type: "root",
                             child: {
                                 type: "action",
-                                call: "doAction"
+                                call: "doAction",
+                                args: ["some-argument"]
                             }
                         };
-
-                        BehaviourTree.register("doAction", () => {
-                            return State.SUCCEEDED;
-                        });
-
-                        const tree = new BehaviourTree(definition, {});
+                        const agent = { mock: "agent" };
+                        const tree = new BehaviourTree(definition, agent);
 
                         tree.step();
 
                         const node = findNode(tree, "action", "doAction");
                         assert.strictEqual(node.state, State.SUCCEEDED);
+                        assert.isTrue(registeredActionFunction.calledWith(agent, "some-argument"));
                     });
                 });
 

diff --git a/test/nodes/leaf/Condition.spec.ts b/test/nodes/leaf/Condition.spec.ts
@@ -1,8 +1,8 @@
 import { assert } from "chai";
+import sinon from "sinon";
 
 import { BehaviourTree, State } from "../../../src/index";
 import { RootNodeDefinition } from "../../../src/BehaviourTreeDefinition";
-import { Agent } from "../../../src/Agent";
 
 import { findNode } from "../../TestUtilities";
 
@@ -41,37 +41,40 @@ describe("A Condition node", () => {
             describe("when the referenced function is", () => {
                 describe("a registered function", () => {
                     it("(MDSL)", () => {
-                        BehaviourTree.register("someCondition", () => {
-                            return true;
-                        });
+                        const registeredConditionFunction = sinon.stub().returns(true);
+                        BehaviourTree.register("someCondition", registeredConditionFunction);
 
-                        const definition = "root { condition [someCondition] }";
-                        const tree = new BehaviourTree(definition, {});
+                        const definition = `root { condition [someCondition, "some-argument"] }`;
+                        const agent = { mock: "agent" };
+                        const tree = new BehaviourTree(definition, agent);
 
                         tree.step();
 
                         const node = findNode(tree, "condition", "someCondition");
                         assert.strictEqual(node.state, State.SUCCEEDED);
+                        assert.isTrue(registeredConditionFunction.calledWith(agent, "some-argument"));
                     });
 
                     it("(JSON)", () => {
-                        BehaviourTree.register("someCondition", () => {
-                            return true;
-                        });
+                        const registeredConditionFunction = sinon.stub().returns(true);
+                        BehaviourTree.register("someCondition", registeredConditionFunction);
 
                         const definition: RootNodeDefinition = {
                             type: "root",
                             child: {
                                 type: "condition",
-                                call: "someCondition"
+                                call: "someCondition",
+                                args: ["some-argument"]
                             }
                         };
-                        const tree = new BehaviourTree(definition, {});
+                        const agent = { mock: "agent" };
+                        const tree = new BehaviourTree(definition, agent);
 
                         tree.step();
 
                         const node = findNode(tree, "condition", "someCondition");
                         assert.strictEqual(node.state, State.SUCCEEDED);
+                        assert.isTrue(registeredConditionFunction.calledWith(agent, "some-argument"));
                     });
                 });