Added sequence, selector, and condition tree building commands

Author: ashblue

Assets/FluidBehaviorTree/Scripts/BehaviorTree/BehaviorTreeBuilder.cs

@@ -22,14 +22,26 @@ public BehaviorTreeBuilder (GameObject owner) {
             _tree = new BehaviorTree(owner);
             _pointer.Add(_tree.Root);
         }
-        
-        public BehaviorTreeBuilder Sequence (string name) {
-            var sequence = new Sequence { Name = name };
-            _tree.AddNode(Pointer, sequence);
-            _pointer.Add(sequence);
+
+        private BehaviorTreeBuilder ParentTask<T> (string name) where T : ITaskParent, new() {
+            var parent = new T { Name = name };
+            _tree.AddNode(Pointer, parent);
+            _pointer.Add(parent);
 
             return this;
         }
+        
+        public BehaviorTreeBuilder Sequence (string name = "sequence") {
+            return ParentTask<Sequence>(name);
+        }
+
+        public BehaviorTreeBuilder Selector (string name = "selector") {
+            return ParentTask<Selector>(name);
+        }
+        
+        public BehaviorTreeBuilder Parallel (string name = "parallel") {
+            return ParentTask<Parallel>(name);
+        }
 
         public BehaviorTreeBuilder Do (string name, Func<TaskStatus> action) {
             _tree.AddNode(Pointer, new ActionGeneric {
@@ -39,6 +51,23 @@ public BehaviorTreeBuilder Do (string name, Func<TaskStatus> action) {
 
             return this;
         }
+        
+        public BehaviorTreeBuilder Do (Func<TaskStatus> action) {
+            return Do("action", action);
+        }
+
+        public BehaviorTreeBuilder Condition (string name, Func<bool> action) {
+            _tree.AddNode(Pointer, new ConditionGeneric {
+                Name = name,
+                updateLogic = action
+            });
+
+            return this;
+        }
+        
+        public BehaviorTreeBuilder Condition (Func<bool> action) {
+            return Condition("condition", action);
+        }
 
         public BehaviorTreeBuilder End () {
             _pointer.RemoveAt(_pointer.Count - 1);

Assets/FluidBehaviorTree/Scripts/BehaviorTree/Editor/BehaviorTreeBuilderTest.cs

@@ -1,23 +1,24 @@
 using Adnc.FluidBT.TaskParents.Composites;
 using Adnc.FluidBT.Tasks;
+using Adnc.FluidBT.Tasks.Actions;
 using NUnit.Framework;
 
 namespace Adnc.FluidBT.Trees.Testing {
     public class BehaviorTreeBuilderTest {
-        public class SequenceMethod {
-            private int _invokeCount;
-            private BehaviorTreeBuilder _builder;
-            
-            [SetUp]
-            public void BeforeEach () {
-                _invokeCount = 0;
-                _builder = new BehaviorTreeBuilder(null);
-            }
+        private int _invokeCount;
+        private BehaviorTreeBuilder _builder;
 
+        [SetUp]
+        public void BeforeEach () {
+            _invokeCount = 0;
+            _builder = new BehaviorTreeBuilder(null);
+        }
+        
+        public class SequenceMethod : BehaviorTreeBuilderTest {
             [Test]
             public void Create_a_sequence () {
                 var tree = _builder
-                    .Sequence("sequence")
+                    .Sequence()
                         .Do("action", () => {
                             _invokeCount++;
                             return TaskStatus.Success;
@@ -115,5 +116,128 @@ public void Create_two_nested_sequences_with_actions () {
                 Assert.AreEqual(2, _invokeCount);
             }
         }
+
+        public class SelectorMethod : BehaviorTreeBuilderTest {
+            [Test]
+            public void Create_a_selector () {
+                var tree = _builder
+                    .Selector("selector")
+                        .Do("action", () => {
+                            _invokeCount++;
+                            return TaskStatus.Failure;
+                        })
+                        .Do("action", () => {
+                            _invokeCount++;
+                            return TaskStatus.Success;
+                        })
+                    .Build();
+    
+                var selector = tree.Root.Children[0] as Selector;
+                
+                Assert.AreEqual(tree.Root.Children.Count, 1);
+                Assert.AreEqual(selector.Children.Count, 2);
+                Assert.AreEqual(TaskStatus.Success, tree.Tick());
+                Assert.AreEqual(2, _invokeCount);
+            }
+        }
+
+        public class ParallelMethod : BehaviorTreeBuilderTest {
+            [Test]
+            public void Create_a_selector () {
+                var tree = _builder
+                    .Parallel()
+                        .Do("action", () => {
+                            _invokeCount++;
+                            return TaskStatus.Success;
+                        })
+                        .Do("action", () => {
+                            _invokeCount++;
+                            return TaskStatus.Success;
+                        })
+                    .Build();
+    
+                var parallel = tree.Root.Children[0] as Parallel;
+                
+                Assert.AreEqual(tree.Root.Children.Count, 1);
+                Assert.AreEqual(parallel.Children.Count, 2);
+                Assert.AreEqual(TaskStatus.Success, tree.Tick());
+                Assert.AreEqual(2, _invokeCount);
+            }
+        }
+
+        public class ConditionMethod : BehaviorTreeBuilderTest {
+            [Test]
+            public void It_should_add_a_condition () {
+                var tree = _builder
+                    .Sequence()
+                        .Condition("condition", () => {
+                            _invokeCount++;
+                            return true;
+                        })
+                        .Do("action", () => {
+                            _invokeCount++;
+                            return TaskStatus.Success;
+                        })
+                    .Build();
+    
+                var sequence = tree.Root.Children[0] as Sequence;
+                var condition = sequence.Children[0] as ConditionGeneric;
+
+                Assert.AreEqual(sequence.Children.Count, 2);
+                Assert.IsNotNull(condition);
+                Assert.AreEqual(TaskStatus.Success, tree.Tick());
+                Assert.AreEqual(2, _invokeCount);
+            }
+            
+            [Test]
+            public void It_should_add_a_condition_without_a_name () {
+                var tree = _builder
+                    .Condition(() => {
+                        _invokeCount++;
+                        return true;
+                    })
+                    .Build();
+    
+                var condition = tree.Root.Children[0] as ConditionGeneric;
+
+                Assert.IsNotNull(condition);
+                Assert.AreEqual(TaskStatus.Success, tree.Tick());
+                Assert.AreEqual(1, _invokeCount);
+            }
+        }
+        
+        public class DoMethod : BehaviorTreeBuilderTest {
+            [Test]
+            public void It_should_add_an_action () {
+                var tree = _builder
+                    .Do("action", () => {
+                        _invokeCount++;
+                        return TaskStatus.Success;
+                    })
+                    .Build();
+    
+                var action = tree.Root.Children[0] as ActionGeneric;
+
+                Assert.IsNotNull(action);
+                Assert.AreEqual(TaskStatus.Success, tree.Tick());
+                Assert.AreEqual(1, _invokeCount);
+            }
+            
+            [Test]
+            public void It_should_add_an_action_without_a_name () {
+                var tree = _builder
+                    .Do(() => {
+                        _invokeCount++;
+                        return TaskStatus.Success;
+                    })
+                    .Build();
+    
+                var action = tree.Root.Children[0] as ActionGeneric;
+
+                Assert.IsNotNull(action);
+                Assert.AreEqual(TaskStatus.Success, tree.Tick());
+                Assert.AreEqual(1, _invokeCount);
+            }
+        }
     }
 }