Encapsulate model state reuse

Author: eelstork

Runtime/Details/Dish.cs

@@ -0,0 +1,49 @@
+using Ex = System.Exception;
+using System;
+
+// Containers for reusable planning states
+namespace Activ.GOAP{
+internal abstract class Dish<T> where T : class{
+
+    protected T proto, state;
+
+    public abstract void Init(T prototype);
+    public abstract T    Avail();
+
+    public virtual void Invalidate (){}
+    public void Consume    () => state = null;
+
+}
+
+// Dirty dish assumes failing actions do not mutate model state
+// Faster because no 'cleaning the dish' after a failed action.
+internal class DirtyDish<T> : Dish<T> where T : class{
+
+    bool dirty; Clonable<T> clonable;
+
+    override public void Init(T prototype){
+        clonable = (Clonable<T>) prototype;
+        proto = prototype; dirty = true;
+    }
+
+    override public T Avail()
+    { if(dirty) state = Clone(); dirty = false; return state; }
+
+    override public void Invalidate() => dirty = true;
+
+    T Clone() => clonable.Clone(state ?? clonable.Allocate());
+
+}
+
+// Cleans after every action; supports serial clones
+internal class PolyDish<T> : Dish<T> where T : class{
+
+    override public void Init(T prototype) { proto = prototype; }
+
+    override public T Avail() { state = Clone(); return state; }
+
+    T Clone() => (proto is Clonable<T> src)
+        ? src.Clone(state ?? src.Allocate())
+        : CloneUtil.DeepClone(proto);
+
+}}

Runtime/Details/Dish.cs.meta

@@ -48,12 +48,13 @@ public virtual void Update(){
         solver.maxNodes  = config.maxNodes;
         solver.maxIter   = config.maxIter;
         solver.tolerance = config.tolerance;
+        solver.cleanActions = config.safeActions;
         if(handler is ActionMap m) m.verbose = verbose;
         handler.Effect( solver.isRunning
             ? solver.Iterate(config.frameBudget)?.Head()
             : solver.Next(model, Goal(), config.frameBudget)?.Head(),
             this);
-        if(policies.OnResult(solver.state, ObjectName())){
+        if(policies.OnResult(solver.status, ObjectName())){
             //ebug.Log($"Clear solver - {solver.state}");
             solver = null;
         }

Runtime/GameAI.cs

@@ -16,47 +16,48 @@ public class Solver<T> : SolverStats where T : class{
     public float tolerance    = 0f;
     public bool  brfs         = false;
     public bool  cleanActions = true;
-    public PlanningState state { get; private set; }
+    public PlanningState status { get; private set; }
     public int  fxMaxNodes     { get; private set; }
     public int  I              { get; private set; }
     //
-    T          storage;
-    T          initialState;
-    Goal<T>    goal;
-    NodeSet<T> avail = null;
+    T           initialState;
+    Dish<T>     dish;
+    Goal<T>     goal;
+    NodeSet<T>  avail = null;
 
-    public bool isRunning => state == S.Running;
+    public bool isRunning => status == S.Running;
 
     public Node<T> Next(T s, in Goal<T> g, int iter=-1){
         if(s == null) throw new NullRef(NO_INIT);
+        if(dish == null) dish = (s is Clonable<T> && cleanActions)
+            ? (Dish<T>)new DirtyDish<T>() : new PolyDish<T>();
         initialState = s;
         goal         = g;
-        avail        = new NodeSet<T>(s, g.h, !brfs, maxNodes, tolerance);
         I            = 0;
+        avail        = new NodeSet<T>(s, g.h, !brfs, maxNodes,
+                                                     tolerance);
         return Iterate(iter);
     }
 
     public Node<T> Iterate(int iter=-1){
         if(initialState == null) throw new InvOp(NO_INIT);
-        if(state == S.MaxIterExceeded) return null;
+        if(status == S.MaxIterExceeded) return null;
         if(iter == -1) iter = maxIter;
         int i = 0;
         while(avail && i++ < iter && I++ < maxIter){
-            //rint($"# {I} (avail: {avail.count}) --------------- ");
             var current = avail.Pop();
             if(goal.match(current.state)){
-                state = S.Done;
+                status = S.Done;
                 return current;
             }
             ExpandActions(current, avail);
             ExpandMethods(current, avail);
             if(avail.count > fxMaxNodes) fxMaxNodes = avail.count;
-            //rint("Avail: " + avail.count);
         }
         if(avail.capacityExceeded){
-            state = S.CapacityExceeded;
+            status = S.CapacityExceeded;
         }else{
-            state = avail
+            status = avail
                 ? (I < maxIter ? S.Running : S.MaxIterExceeded)
                 : S.Failed;
         }
@@ -67,53 +68,42 @@ void ExpandActions(Node<T> x, NodeSet<T> @out){
         if(!(x.state is Agent p)) return;
         var count = p.Actions()?.Length ?? 0;
         if(count == 0) return;
-        // Initially assume a dirty state, which just menans that
-        // the canvas needs to be init'd from x.state.
-        bool dirty = true;
+        dish.Init(x.state);
         T y = null;
         for(int i = 0; i < count; i++){
-            //y = Clone(x.state);
-            if(dirty){ y = Clone(x.state); dirty = false; }
+            y = dish.Avail();
             var q = y as Agent;
             var r = q.Actions()[i]();
             if(r.done){
-                // Since the action succeeded, state is now dirty.
-                dirty = true;
+                dish.Invalidate();
                 if(!brfs && (r.cost <= 0))
                     throw new Ex(ZERO_COST_ERR);
                 var name = p.Actions()[i].Method.Name;
                 if(@out.Insert(new Node<T>(name, y, x, r.cost)))
-                    storage = null;
+                    dish.Consume();
             }
         }
     }
 
     void ExpandMethods(Node<T> x, NodeSet<T> @out){
         if(!(x.state is Parametric p)) return;
-        if(p.Functions() == null) return;
-        for(int i = 0; i < p.Functions().Length; i++){
-            var y = Clone(x.state);
+        var count = p.Functions()?.Length ?? 0;
+        if(count == 0) return;
+        dish.Init(x.state);
+        T y = null;
+        for(int i = 0; i < count; i++){
+            y = dish.Avail();
             var q = y as Parametric;
             var r = q.Functions()[i].action();
             if(r.done){
+                dish.Invalidate();
                 if(!brfs && r.cost <= 0)
                     throw new Ex(ZERO_COST_ERR);
                 var effect = p.Functions()[i].effect;
                 if(@out.Insert(new Node<T>(effect, y, x, r.cost)))
-                    storage = null;
+                    dish.Consume();
             }
         }
     }
 
-    // TODO: strictly call to Clone() is not needed if an action has
-    // failed and did not touch the matching state. So, as an unsafe
-    // optimization, can skip that.
-    internal T Clone(T x){
-        if(x is Clonable<T> c){
-            return c.Clone(storage = storage ?? c.Allocate());
-        }else{
-            return CloneUtil.DeepClone(x);
-        }
-    }
-
 }}

Runtime/Solver.cs

@@ -5,5 +5,6 @@ [System.Serializable] public class SolverParams{
     public int   maxNodes    = 1000;
     public int   maxIter     = 1000;
     public float tolerance   = 0;
+    public bool  safeActions = false;
 
 }}

Runtime/SolverParams.cs

@@ -5,9 +5,9 @@ namespace Activ.GOAP{
 
 public interface SolverStats{
 
-    PlanningState state { get; }
-    int  fxMaxNodes     { get; }
-    int  I              { get; }
+    PlanningState status { get; }
+    int  fxMaxNodes      { get; }
+    int  I               { get; }
 
 }
 

Runtime/SolverStats.cs

@@ -0,0 +1,33 @@
+using NUnit.Framework;
+
+namespace Activ.GOAP{
+public class Bench_Dish{
+
+    T proto = new T();
+    PolyDish<T> x;
+
+    [SetUp] public void Setup() => x = new PolyDish<T>();
+
+    [Test] public void Perf_XDish()
+    => RunTest(new PolyDish<T>());
+
+    [Test] public void Perf_DirtyDish()
+    => RunTest(new DirtyDish<T>());
+
+    void RunTest(Dish<T> x){
+        x.Init(proto);
+        for(int i = 0; i < 1e6; i++){
+            x.Avail();
+            x.Invalidate();
+            x.Avail();
+            x.Consume();
+            x.Avail();
+        }
+    }
+
+    class T : Clonable<T>{
+        public T Allocate() => new T();
+        public T Clone(T t) => t;
+    }
+
+}}

Tests/Editor/Bench_Dish.cs

@@ -0,0 +1,21 @@
+using NUnit.Framework;
+using Activ.GOAP;
+
+namespace Activ.GOAP{
+public class DirtyDishTest{
+
+    T proto = new T();
+    DirtyDish<T> x;
+
+    [SetUp] public void Setup()     => x = new DirtyDish<T>();
+    [Test] public void Init()       => x.Init(proto);
+    [Test] public void Avail()      => x.Avail();
+    [Test] public void Invalidate() => x.Invalidate();
+    [Test] public void Consume()    => x.Consume();
+
+    class T : Clonable<T>{
+        public T Allocate() => new T();
+        public T Clone(T t) => t;
+    }
+
+}}