feat(action): new wait time node

New wait time node returns continue until the passed duration has expired

Assets/FluidBehaviorTree/Runtime/BehaviorTree/Builder/BehaviorTreeBuilder.cs

@@ -93,6 +93,28 @@ public BehaviorTreeBuilder Do (string name, Func<TaskStatus> action) {
         public BehaviorTreeBuilder Do (Func<TaskStatus> action) {
             return Do("action", action);
         }
+
+        /// <summary>
+        /// Return continue until time has passed
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="time"></param>
+        /// <returns></returns>
+        public BehaviorTreeBuilder WaitTime (string name, float time = 1f) {
+            return AddNode(new WaitTime(new TimeMonitor()) {
+                Name = name,
+                time = time
+            });
+        }
+
+        /// <summary>
+        /// Return continue until time has passed
+        /// </summary>
+        /// <param name="time"></param>
+        /// <returns></returns>
+        public BehaviorTreeBuilder WaitTime (float time = 1f) {
+            return WaitTime("Wait Time", time);
+        }
 
         public BehaviorTreeBuilder Condition (string name, Func<bool> action) {
             return AddNode(new ConditionGeneric {

Assets/FluidBehaviorTree/Runtime/Tasks/Actions/WaitTime/ITimeMonitor.cs

@@ -0,0 +1,5 @@
+namespace CleverCrow.Fluid.BTs.Tasks.Actions {
+    public interface ITimeMonitor {
+        float DeltaTime { get; }
+    }
+}

Assets/FluidBehaviorTree/Runtime/Tasks/Actions/WaitTime/TimeMonitor.cs

@@ -0,0 +1,7 @@
+using UnityEngine;
+
+namespace CleverCrow.Fluid.BTs.Tasks.Actions {
+    public class TimeMonitor : ITimeMonitor {
+        public float DeltaTime => Time.deltaTime;
+    }
+}

Assets/FluidBehaviorTree/Runtime/Tasks/Actions/WaitTime/WaitTime.cs

@@ -0,0 +1,30 @@
+namespace CleverCrow.Fluid.BTs.Tasks.Actions {
+    /// <summary>
+    /// Return continue until the time has passed
+    /// </summary>
+    public class WaitTime : ActionBase {
+        private ITimeMonitor _timeMonitor;
+        private float _timePassed;
+
+        public float time = 1;
+
+
+        public WaitTime (ITimeMonitor timeMonitor) {
+            _timeMonitor = timeMonitor;
+        }
+
+        protected override void OnStart () {
+            _timePassed = 0;
+        }
+
+        protected override TaskStatus OnUpdate () {
+            _timePassed += _timeMonitor.DeltaTime;
+
+            if (_timePassed < time) {
+                return TaskStatus.Continue;                
+            }
+
+            return TaskStatus.Success;
+        }
+    }
+}

Assets/FluidBehaviorTree/Tests/Editor/BehaviorTrees/Builders/BehaviorTreeBuilderTest.cs

@@ -16,6 +16,7 @@ public void BeforeEach () {
         }
 
         public class SelectorRandomMethod : BehaviorTreeBuilderTest {
+            [Test]
             public void It_should_add_a_random_selector () {
                 var tree = _builder
                     .SelectorRandom("random selector")
@@ -427,5 +428,29 @@ public void It_should_add_a_wait_node () {
                 Assert.AreEqual(1, _invokeCount);
             }
         }
+
+        public class WaitTimeMethod : BehaviorTreeBuilderTest {
+            [Test]
+            public void It_should_add_a_WaitTime_action () {
+                var tree = _builder
+                    .WaitTime("Custom")
+                    .Build();
+
+                var waitTime = tree.Root.Children[0] as WaitTime;
+
+                Assert.IsNotNull(waitTime);
+            }
+
+            [Test]
+            public void It_should_set_WaitTime_duration () {
+                var tree = _builder
+                    .WaitTime(2f)
+                    .Build();
+
+                var waitTime = tree.Root.Children[0] as WaitTime;
+
+                Assert.AreEqual(2f, waitTime.time);
+            }
+        }
     }
 }

Assets/FluidBehaviorTree/Tests/Editor/Tasks/Actions/WaitTimeTest.cs

@@ -0,0 +1,42 @@
+using NSubstitute;
+using NUnit.Framework;
+
+namespace CleverCrow.Fluid.BTs.Tasks.Actions.Editors.Tests {
+    public class WaitTimeTest {
+        public class UpdateMethod {
+            [Test]
+            public void It_should_return_continue_if_time_has_not_passed () {
+                var timeMonitor = Substitute.For<ITimeMonitor>();
+                timeMonitor.DeltaTime.Returns(0);
+                var waitTime = new WaitTime(timeMonitor) {time = 1};
+
+                Assert.AreEqual(TaskStatus.Continue, waitTime.Update());
+            }
+
+            [Test]
+            public void It_should_return_success_if_time_has_passed () {
+                var timeMonitor = Substitute.For<ITimeMonitor>();
+                timeMonitor.DeltaTime.Returns(2);
+                var waitTime = new WaitTime(timeMonitor) {time = 1};
+
+                Assert.AreEqual(TaskStatus.Success, waitTime.Update());
+            }
+        }
+
+        public class ResetMethod {
+            [Test]
+            public void It_should_reset_time () {
+                var timeMonitor = Substitute.For<ITimeMonitor>();
+                var waitTime = new WaitTime(timeMonitor) {time = 1};
+
+                timeMonitor.DeltaTime.Returns(2);
+                waitTime.Update();
+                waitTime.Reset();
+                timeMonitor.DeltaTime.Returns(0);
+
+                Assert.AreEqual(TaskStatus.Continue, waitTime.Update());
+
+            }
+        }
+    }
+}