Added BT builder with sequences and tasks

Author: ashblue

Assets/FluidBehaviorTree/Scripts/BehaviorTree/BehaviorTree.cs

@@ -15,10 +15,13 @@ public BehaviorTree (GameObject owner) {
             SyncNodes(Root);
         }
 
-        public void Tick () {
-            if (Root.Update() != TaskStatus.Continue) {
+        public TaskStatus Tick () {
+            var status = Root.Update();
+            if (status != TaskStatus.Continue) {
                 TickCount++;
             }
+
+            return status;
         }
 
         public void Reset () {

Assets/FluidBehaviorTree/Scripts/BehaviorTree/BehaviorTreeBuilder.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using Adnc.FluidBT.TaskParents;
+using Adnc.FluidBT.TaskParents.Composites;
+using Adnc.FluidBT.Tasks;
+using Adnc.FluidBT.Tasks.Actions;
+using UnityEngine;
+
+namespace Adnc.FluidBT.Trees {
+    public class BehaviorTreeBuilder {
+        private readonly BehaviorTree _tree;
+        private readonly List<ITaskParent> _pointer = new List<ITaskParent>();
+
+        private ITaskParent Pointer {
+            get {
+                if (_pointer.Count == 0) return null;
+                return _pointer[_pointer.Count - 1];
+            }
+        }
+        
+        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);
+
+            return this;
+        }
+
+        public BehaviorTreeBuilder Do (string name, Func<TaskStatus> action) {
+            _tree.AddNode(Pointer, new ActionGeneric {
+                Name = name,
+                updateLogic = action
+            });
+            
+            return this;
+        }
+
+        public BehaviorTreeBuilder End () {
+            _pointer.RemoveAt(_pointer.Count - 1);
+            
+            return this;
+        }
+
+        public BehaviorTree Build () {
+            return _tree;
+        }
+    }
+}

Assets/FluidBehaviorTree/Scripts/BehaviorTree/BehaviorTreeBuilder.cs.meta

@@ -0,0 +1,119 @@
+using Adnc.FluidBT.TaskParents.Composites;
+using Adnc.FluidBT.Tasks;
+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);
+            }
+            
+            [Test]
+            public void Create_a_sequence () {
+                var tree = _builder
+                    .Sequence("sequence")
+                        .Do("action", () => {
+                            _invokeCount++;
+                            return TaskStatus.Success;
+                        })
+                    .Build();
+    
+                var sequence = tree.Root.Children[0] as Sequence;
+                
+                Assert.AreEqual(tree.Root.Children.Count, 1);
+                Assert.AreEqual(sequence.Children.Count, 1);
+                Assert.AreEqual(TaskStatus.Success, tree.Tick());
+                Assert.AreEqual(1, _invokeCount);
+            }
+            
+            [Test]
+            public void Create_a_nested_sequence () {
+                var tree = _builder
+                    .Sequence("sequence")
+                        .Do("action", () => {
+                            _invokeCount++;
+                            return TaskStatus.Success;
+                        })
+                        .Sequence("nested")
+                            .Do("actionNested", () => {
+                                _invokeCount++;
+                                return TaskStatus.Success;
+                            })
+                    .Build();
+    
+                var sequence = tree.Root.Children[0] as Sequence;
+                Assert.AreEqual(2, sequence.Children.Count);
+                
+                var nested = sequence.Children[1] as Sequence;
+                Assert.AreEqual(nested.Children.Count, 1);
+                Assert.AreEqual(TaskStatus.Success, tree.Tick());
+                Assert.AreEqual(2, _invokeCount);
+            }
+            
+            [Test]
+            public void Create_a_nested_sequence_then_add_an_action_to_the_parent () {
+                var tree = _builder
+                    .Sequence("sequence")
+                        .Do("action", () => {
+                            _invokeCount++;
+                            return TaskStatus.Success;
+                        })
+                        .Sequence("nested")
+                            .Do("actionNested", () => {
+                                _invokeCount++;
+                                return TaskStatus.Success;
+                            })
+                        .End()
+                        .Do("lastAction", () => {
+                        _invokeCount++;
+                            return TaskStatus.Success;
+                        })
+                    .Build();
+    
+                var sequence = tree.Root.Children[0] as Sequence;
+                Assert.AreEqual(3, sequence.Children.Count);
+                
+                var nested = sequence.Children[1] as Sequence;
+                Assert.AreEqual(nested.Children.Count, 1);
+                Assert.AreEqual(TaskStatus.Success, tree.Tick());
+                Assert.AreEqual(3, _invokeCount);
+            }
+    
+            [Test]
+            public void Create_two_nested_sequences_with_actions () {
+                var tree = _builder
+                    .Sequence("sequence")
+                        .Sequence("nested")
+                            .Do("actionNested", () => {
+                                _invokeCount++;
+                                return TaskStatus.Success;
+                            })
+                        .End()
+                        .Sequence("nested")
+                            .Do("actionNested", () => {
+                                _invokeCount++;
+                                return TaskStatus.Success;
+                            })
+                    .Build();
+    
+                var sequence = tree.Root.Children[0] as Sequence;
+                Assert.AreEqual(2, sequence.Children.Count);
+                
+                var nested = sequence.Children[0] as Sequence;
+                Assert.AreEqual(nested.Children.Count, 1);
+                
+                var nestedAlt = sequence.Children[1] as Sequence;
+                Assert.AreEqual(nestedAlt.Children.Count, 1);
+                
+                Assert.AreEqual(TaskStatus.Success, tree.Tick());
+                Assert.AreEqual(2, _invokeCount);
+            }
+        }
+    }
+}

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

@@ -7,6 +7,8 @@ public abstract class DecoratorBase : ITask {
         public ITask child;
 
         private bool _enabled = true;
+        public string Name { get; set; }
+
         public bool Enabled {
             get { return child != null && child.Enabled && _enabled; }
             set { _enabled = value; }

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

@@ -8,6 +8,7 @@ public abstract class TaskParentBase : ITaskParent {
         public BehaviorTree ParentTree { get; set; }
         public TaskStatus LastStatus { get; private set; }
 
+        public string Name { get; set; }
         public bool Enabled { get; set; } = true;
 
         public List<ITask> Children { get; } = new List<ITask>();

Assets/FluidBehaviorTree/Scripts/Decorators/DecoratorBase.cs

@@ -3,6 +3,11 @@
 
 namespace Adnc.FluidBT.Tasks {
     public interface ITask {
+        /// <summary>
+        /// Used for debugging and identification purposes
+        /// </summary>
+        string Name { get; set; }
+        
         /// <summary>
         /// Is this task enabled or not? Disabled tasks are excluded from the runtime
         /// </summary>

Assets/FluidBehaviorTree/Scripts/TaskParents/TaskParentBase.cs

@@ -7,7 +7,8 @@ public abstract class TaskBase : ITask {
         private bool _start;
         private bool _exit;
         private int _lastTickCount;
-        
+
+        public string Name { get; set; }
         public bool Enabled { get; set; } = true;
         public GameObject Owner { get; set; }
         public BehaviorTree ParentTree { get; set; }