Qualify safe alloc mode

Author: eelstork

Runtime/Details/Dish.cs

@@ -13,6 +13,10 @@ internal abstract class Dish<T> where T : class{
     public virtual void Invalidate (){}
     public void Consume    () => state = null;
 
+    public static Dish<T> Create(T s, bool safe)
+    => (s is Clonable<T> && !safe) ? (Dish<T>)new DirtyDish<T>()
+                                   : new PolyDish<T>();
+
 }
 
 // Dirty dish assumes failing actions do not mutate model state

Runtime/Details/Strings.cs.meta

@@ -29,15 +29,14 @@ public abstract partial class GameAI<T> : SolverOwner
     // Decide a goal and (optionally) a heuristic
     public abstract Goal<T> Goal();
 
-    // Instantiates or updates the model using relevant world states
+    // Instantiate a model from relevant world states
     public abstract T Model();
 
     // Override if you have a behavior while idle
     virtual public void Idle(){ }
 
-    // This method should return false to indicate that the actor
-    // is available for planning, true while the actor is effecting
-    // game a-ctions
+    // Return false to indicate the actor are available for
+    // planning, true while the actor are effecting game actions
     virtual public bool IsActing() => false;
 
     public virtual void Update(){
@@ -48,14 +47,13 @@ public virtual void Update(){
         solver.maxNodes  = config.maxNodes;
         solver.maxIter   = config.maxIter;
         solver.tolerance = config.tolerance;
-        solver.cleanActions = config.safeActions;
+        solver.safe = config.safe;
         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.status, ObjectName())){
-            //ebug.Log($"Clear solver - {solver.state}");
             solver = null;
         }
     }

Runtime/GameAI.cs

@@ -10,11 +10,11 @@ public class Solver<T> : SolverStats where T : class{
 
     public int   maxNodes = 1000, maxIter = 1000;
     public float tolerance;
-    public bool  brfs, cleanActions = true;
+    public bool  brfs, safe = true;
     public PlanningState status { get; private set; }
+    // TODO terrible name
     public int  fxMaxNodes      { get; private set; }
     public int  I               { get; private set; }
-    //
     T           initialState;
     Dish<T>     dish;
     Goal<T>     goal;
@@ -24,8 +24,7 @@ public class Solver<T> : SolverStats where T : class{
 
     public Node<T> Next(T s, in Goal<T> g, int iter=-1){
         if(s == null) throw new NullRef(NO_INIT_ERR);
-        if(dish == null) dish = (s is Clonable<T> && cleanActions)
-            ? (Dish<T>)new DirtyDish<T>() : new PolyDish<T>();
+        dish = dish ?? Dish<T>.Create(s, safe);
         initialState = s;
         goal         = g;
         I            = 0;

Runtime/Solver.cs

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

Runtime/SolverParams.cs

@@ -0,0 +1,28 @@
+using NUnit.Framework;
+using Activ.GOAP;
+using ArgNull = System.ArgumentNullException;
+
+namespace Activ.GOAP{
+public class DishTest : TestBase{
+
+    T clonable = new T();
+
+    [Test] public void CreateSafeDishWithClonable()
+    => o( Dish<T>.Create(clonable, safe: true) is PolyDish<T> );
+
+    [Test] public void CreateUnsafeDishWithClonable()
+    => o( Dish<T>.Create(clonable, safe: false) is DirtyDish<T> );
+
+    [Test] public void CreateWithSerializable(
+                                   [Values(true, false)] bool safe){
+        o( Dish<U>.Create(new U(), safe) is PolyDish<U> );
+    }
+
+    class T : Clonable<T>{
+        public T Allocate() => new T();
+        public T Clone(T t) => t;
+    }
+
+    [System.Serializable] class U{}
+
+}}

Tests/Editor/DishTest.cs

@@ -18,6 +18,18 @@ [SetUp] public void Setup(){
         x.maxIter = x.maxNodes = 100;
     }
 
+    // Defaults ----------------------------------------------------
+
+    // Important because tolerance > 0 may affect search result
+    [Test] public void ZeroToleranceDefault() => x.tolerance = 0;
+
+    // Unsafe mode should be enabled by user once they figure out
+    // what it means
+    [Test] public void SafeDefault() => x.safe = true;
+
+    // Default to A*, not breadth-first
+    [Test] public void BRFSDefault() => x.brfs = false;
+
     // isRunning ---------------------------------------------------
 
     [Test] public void IsRunning_false_on_construct()