Added builder return success, return failure, and inverter

Author: ashblue

Assets/FluidBehaviorTree/Scripts/BehaviorTree/BehaviorTreeBuilder.cs

@@ -47,6 +47,18 @@ public BehaviorTreeBuilder Decorator (string name, Func<ITask, TaskStatus> logic
         public BehaviorTreeBuilder Decorator (Func<ITask, TaskStatus> logic) {
             return Decorator("decorator", logic);
         }
+
+        public BehaviorTreeBuilder Inverter (string name = "inverter") {
+            return ParentTask<Inverter>(name);
+        }
+        
+        public BehaviorTreeBuilder ReturnSuccess (string name = "return success") {
+            return ParentTask<ReturnSuccess>(name);
+        }
+        
+        public BehaviorTreeBuilder ReturnFailure (string name = "return failure") {
+            return ParentTask<ReturnFailure>(name);
+        }
 
         public BehaviorTreeBuilder Sequence (string name = "sequence") {
             return ParentTask<Sequence>(name);

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

@@ -3,7 +3,6 @@
 using Adnc.FluidBT.Tasks;
 using Adnc.FluidBT.Tasks.Actions;
 using NUnit.Framework;
-using UnityEngine;
 
 namespace Adnc.FluidBT.Trees.Testing {
     public class BehaviorTreeBuilderTest {
@@ -313,5 +312,62 @@ public void It_should_move_to_the_next_node_on_End () {
                 Assert.AreEqual(3, _invokeCount);
             }
         }
+
+        public class InverterMethod : BehaviorTreeBuilderTest {
+            [Test]
+            public void It_should_create_an_inverter () {
+                var tree = _builder
+                    .Inverter("inverter")
+                        .Do("action", () => {
+                            _invokeCount++;
+                            return TaskStatus.Success;
+                        })
+                    .Build();
+
+                var decorator = tree.Root.Children[0] as Inverter;
+                
+                Assert.IsNotNull(decorator);
+                Assert.AreEqual(TaskStatus.Failure, tree.Tick());
+                Assert.AreEqual(1, _invokeCount);
+            }
+        }
+        
+        public class ReturnSuccessMethod : BehaviorTreeBuilderTest {
+            [Test]
+            public void It_should_create_a_ReturnSuccess () {
+                var tree = _builder
+                    .ReturnSuccess("return success")
+                        .Do("action", () => {
+                            _invokeCount++;
+                            return TaskStatus.Failure;
+                        })
+                    .Build();
+
+                var decorator = tree.Root.Children[0] as ReturnSuccess;
+                
+                Assert.IsNotNull(decorator);
+                Assert.AreEqual(TaskStatus.Success, tree.Tick());
+                Assert.AreEqual(1, _invokeCount);
+            }
+        }
+        
+        public class ReturnFailureMethod : BehaviorTreeBuilderTest {
+            [Test]
+            public void It_should_create_a_ReturnFailure () {
+                var tree = _builder
+                    .ReturnFailure("return failure")
+                        .Do("action", () => {
+                            _invokeCount++;
+                            return TaskStatus.Success;
+                        })
+                    .Build();
+
+                var decorator = tree.Root.Children[0] as ReturnFailure;
+                
+                Assert.IsNotNull(decorator);
+                Assert.AreEqual(TaskStatus.Failure, tree.Tick());
+                Assert.AreEqual(1, _invokeCount);
+            }
+        }
     }
 }