Pause and resume

Editor/Tests/_utils/MockTask.cs

@@ -0,0 +1,22 @@
+namespace NPBehave
+{
+    public class MockTask : Task
+    {
+        private bool suceedsOnExplicitStop;
+
+        public MockTask(bool suceedsOnExplicitStop) : base("MockTask")
+        {
+            this.suceedsOnExplicitStop = suceedsOnExplicitStop;
+        }
+
+        protected override void DoStop()
+        {
+            this.Stopped(suceedsOnExplicitStop);
+        }
+
+        public void Finish(bool success)
+        {
+            this.Stopped(success);
+        }
+    }
+}

README.md

@@ -160,6 +160,23 @@ In case your Monster gets killed or you just destroy your GameObject, you should
     // ...
 ```
 
+## Pausing the Tree
+
+The tree can be paused with `Pause()`. When the tree is paused the current executing task is stopped 
+and the tree does not change its state anymore.
+Then the tree can be resumed with `Resume()` again and the previously stopped task is restarted again.
+This is useful for executing behavior tree independent logic while the tree is paused,
+e.g. an enemy should be stunned after he got hurt.
+
+```csharp
+    public IEnumerator StunEnemy() 
+    {
+        behaviorTree.Pause();
+        yield return enemy.Stun();
+        behaviorTree.Resume();
+    }
+```
+
 ## The Debugger
 You can use the `Debugger` component to debug the behavior trees at runtime in the inspector. 
 

Scripts/Composite/Composite.cs

@@ -4,8 +4,6 @@ namespace NPBehave
 {
     public abstract class Composite : Container
     {
-        protected Node[] Children;
-
         public Composite(string name, Node[] children) : base(name)
         {
             this.Children = children;

Scripts/Container.cs

@@ -1,10 +1,16 @@
+using System.Collections.Generic;
+using System.Linq;
 using UnityEngine.Assertions;
 
 namespace NPBehave
 {
     public abstract class Container : Node
     {
+        protected Node[] Children;
+        protected readonly Stack<Node> pausedChildren = new Stack<Node>();
+
         private bool collapse = false;
+
         public bool Collapse
         {
             get
@@ -25,7 +31,47 @@ public void ChildStopped(Node child, bool succeeded)
         {
             // Assert.AreNotEqual(this.currentState, State.INACTIVE, "The Child " + child.Name + " of Container " + this.Name + " was stopped while the container was inactive. PATH: " + GetPath());
             Assert.AreNotEqual(this.currentState, State.INACTIVE, "A Child of a Container was stopped while the container was inactive.");
-            this.DoChildStopped(child, succeeded);
+
+            if (currentState != State.PAUSED)
+            {
+                this.DoChildStopped(child, succeeded);
+            }
+        }
+
+        override public void Pause()
+        {
+            if (!IsActive)
+                return;
+            currentState = State.PAUSED;
+            foreach (Node child in Children)
+            {
+                if (child is Task)
+                {
+                    if (child.IsActive)
+                    {
+                        child.Pause();
+                        this.pausedChildren.Push(child);
+                    }
+                }
+                else
+                {
+                    child.Pause();
+                    if (child.CurrentState == State.PAUSED)
+                    {
+                        this.pausedChildren.Push(child);
+                    }
+                }
+            }
+        }
+
+        override public void Resume()
+        {
+            Assert.AreEqual(this.currentState, State.PAUSED, "Only a paused container can be resumed.");
+            currentState = State.ACTIVE;
+            while (pausedChildren.Any())
+            {
+                pausedChildren.Pop().Resume();
+            }
         }
 
         protected abstract void DoChildStopped(Node child, bool succeeded);

Scripts/Decorator/BlackboardCondition.cs

@@ -46,8 +46,7 @@ public BlackboardCondition(string key, Operator op, Stops stopsOnChange, Node de
             this.key = key;
             this.stopsOnChange = stopsOnChange;
         }
-
-
+
         override protected void StartObserving()
         {
             this.RootNode.Blackboard.AddObserver(key, onValueChanged);

Scripts/Decorator/Decorator.cs

@@ -8,6 +8,7 @@ public abstract class Decorator : Container
         public Decorator(string name, Node decoratee) : base(name)
         {
             this.Decoratee = decoratee;
+            Children = new[] {decoratee};
             this.Decoratee.SetParent(this);
         }
 

Scripts/Decorator/ObservingDecorator.cs

@@ -8,6 +8,7 @@ public abstract class ObservingDecorator : Decorator
     {
         protected Stops stopsOnChange;
         private bool isObserving;
+        private State beforePauseState;
 
         public ObservingDecorator(string name, Stops stopsOnChange, Node decoratee) : base(name, decoratee)
         {
@@ -41,6 +42,47 @@ override protected void DoStop()
             Decoratee.Stop();
         }
 
+        public override void Pause()
+        {
+            beforePauseState = currentState;
+            currentState = State.PAUSED;
+
+            // only propagate Pause() on children when it was active
+            if (beforePauseState != State.ACTIVE)
+            {
+                return;
+            }
+
+            foreach (Node child in Children)
+            {
+                if (child is Task task)
+                {
+                    if (child.IsActive)
+                    {
+                        task.Pause();
+                        this.pausedChildren.Push(child);
+                    }
+                }
+                else
+                {
+                    child.Pause();
+                    if (child.CurrentState == State.PAUSED)
+                    {
+                        this.pausedChildren.Push(child);
+                    }
+                }
+            }
+            StopObserving();
+        }
+
+        public override void Resume()
+        {
+            StartObserving();
+            base.Resume();
+            currentState = beforePauseState;
+            Evaluate();
+        }
+
         protected override void DoChildStopped(Node child, bool result)
         {
             Assert.AreNotEqual(this.CurrentState, State.INACTIVE);
@@ -66,6 +108,10 @@ override protected void DoParentCompositeStopped(Composite parentComposite)
 
         protected void Evaluate()
         {
+            if (ParentNode.CurrentState == State.PAUSED)
+            {
+                return;
+            }
             if (IsActive && !IsConditionMet())
             {
                 if (stopsOnChange == Stops.SELF || stopsOnChange == Stops.BOTH || stopsOnChange == Stops.IMMEDIATE_RESTART)

Scripts/Decorator/Service.cs

@@ -31,6 +31,35 @@ public Service(System.Action service, Node decoratee) : base("Service", decorate
         }
 
         protected override void DoStart()
+        {
+            startService();
+            Decoratee.Start();
+        }
+
+        override protected void DoStop()
+        {
+            Decoratee.Stop();
+        }
+
+        protected override void DoChildStopped(Node child, bool result)
+        {
+            stopService();
+            Stopped(result);
+        }
+
+        public override void Pause()
+        {
+            base.Pause();
+            stopService();
+        }
+
+        public override void Resume()
+        {
+            startService();
+            base.Resume();
+        }
+
+        private void startService()
         {
             if (this.interval <= 0f)
             {
@@ -46,15 +75,9 @@ protected override void DoStart()
             {
                 InvokeServiceMethodWithRandomVariation();
             }
-            Decoratee.Start();
-        }
-
-        override protected void DoStop()
-        {
-            Decoratee.Stop();
         }
 
-        protected override void DoChildStopped(Node child, bool result)
+        private void stopService()
         {
             if (this.interval <= 0f)
             {
@@ -68,9 +91,8 @@ protected override void DoChildStopped(Node child, bool result)
             {
                 this.Clock.RemoveTimer(InvokeServiceMethodWithRandomVariation);
             }
-            Stopped(result);
         }
-
+        
         private void InvokeServiceMethodWithRandomVariation()
         {
             serviceMethod();

Scripts/Decorator/TimeMax.cs

@@ -58,6 +58,18 @@ protected override void DoChildStopped(Node child, bool result)
             }
         }
 
+        public override void Pause()
+        {
+            base.Pause();
+            Clock.RemoveTimer(TimeoutReached);
+        }
+
+        public override void Resume()
+        {
+            base.Resume();
+            Clock.AddTimer(limit, randomVariation, 0, TimeoutReached);
+        }
+
         private void TimeoutReached()
         {
             if (!waitForChildButFailOnLimitReached)

Scripts/Decorator/WaitForCondition.cs

@@ -28,6 +28,23 @@ public WaitForCondition(Func<bool> condition, Node decoratee) : base("WaitForCon
         }
 
         protected override void DoStart()
+        {
+            addTimerOrStartImmediately();
+        }
+
+        public override void Pause()
+        {
+            base.Pause();
+            Clock.RemoveTimer(checkCondition);
+        }
+
+        public override void Resume()
+        {
+            addTimerOrStartImmediately();
+            base.Resume();
+        }
+
+        private void addTimerOrStartImmediately()
         {
             if (!condition.Invoke())
             {

Scripts/Node.cs

@@ -9,6 +9,7 @@ public enum State
             INACTIVE,
             ACTIVE,
             STOP_REQUESTED,
+            PAUSED,
         }
 
         protected State currentState = State.INACTIVE;
@@ -138,6 +139,16 @@ public void Stop()
 #endif
             DoStop();
         }
+
+        public virtual void Pause()
+        {
+
+        }
+
+        public virtual void Resume()
+        {
+
+        }
 
         protected virtual void DoStart()
         {
@@ -148,8 +159,7 @@ protected virtual void DoStop()
         {
 
         }
-
-
+
         /// THIS ABSOLUTLY HAS TO BE THE LAST CALL IN YOUR FUNCTION, NEVER MODIFY
         /// ANY STATE AFTER CALLING Stopped !!!!
         protected virtual void Stopped(bool success)
@@ -198,7 +208,7 @@ protected virtual void DoParentCompositeStopped(Composite composite)
 
         override public string ToString()
         {
-            return !string.IsNullOrEmpty(Label) ? (this.Name + "{"+Label+"}") : this.Name;
+            return !string.IsNullOrEmpty(Label) ? (this.Name + "{" + Label + "}") : this.Name;
         }
 
         protected string GetPath()

Scripts/Root.cs

@@ -96,5 +96,11 @@ override protected void DoChildStopped(Node node, bool success)
                 Stopped(success);
             }
         }
+
+        public override void Pause()
+        {
+            Assert.AreEqual(this.currentState, State.ACTIVE, "Only an active tree can be paused.");
+            base.Pause();
+        }
     }
 }

Scripts/Task/Task.cs

@@ -5,5 +5,15 @@ public abstract class Task : Node
         public Task(string name) : base(name)
         {
         }
+
+        public override void Pause()
+        {
+            Stop();
+        }
+
+        public override void Resume()
+        {
+            Start();
+        }
     }
 }