Relax cost ordering

Author: eelstork

Runtime/Details/NodeSet.cs

@@ -4,15 +4,20 @@
 namespace Activ.GOAP{
 public class NodeSet<T> : Base{
 
-    internal bool sorted;
-    int capacity;
+    float          precision = 0;
+    internal bool  sorted;
+    int            capacity;
     Func<T, float> h;
     HashSet<T>     states = new HashSet<T>();
     List<Node<T>>  list   = new List<Node<T>>();
 
     public NodeSet(T x, Func<T, float> h, bool sorted  = true,
-                                          int  capacity = 128){
-        this.h = h; this.sorted = sorted; this.capacity = capacity;
+                                          int  capacity = 128,
+                                          float precision = 0){
+        this.h = h;
+        this.sorted    = sorted;
+        this.capacity  = capacity;
+        this.precision = precision;
         states.Add(Assert(x, "Initial state"));
         list.Add(new Node<T>(Solver<T>.INIT, x));
     }
@@ -28,6 +33,7 @@ public void Insert(Node<T> n){
         if(!states.Add(n.state)) return;
         if(sorted){
             n.value = n.cost + (h != null ? h(n.state) : 0);
+            if(precision > 0) n.value = (int)(n.value / precision);
             // NOTE: In actual use, tested 4x faster than SortedSet;
             //  Likely bottleneck with SortedSet is the API, not the
             // algorithm; SortedSet needs total, ordering:
@@ -39,7 +45,7 @@ public void Insert(Node<T> n){
             // Also getting Min/Max item is cheap, but there's no way
             // to combine this with a 'pop'
             for(int i = list.Count-1; i >= 0; i--){
-                if(n.value < list[i].value){
+                if(n.value <= list[i].value){
                     list.Insert(i + 1, n);
                     return;
                 }

Runtime/GameAI.cs

@@ -44,8 +44,9 @@ public virtual void Update(){
         var model = Model();
         if(model == null) return;
         solver = solver ?? new Solver<T>();
-        solver.maxNodes = config.maxNodes;
-        solver.maxIter  = config.maxIter;
+        solver.maxNodes  = config.maxNodes;
+        solver.maxIter   = config.maxIter;
+        solver.tolerance = config.tolerance;
         if(handler is ActionMap m) m.verbose = verbose;
         handler.Effect( solver.isRunning
             ? solver.Iterate(config.frameBudget)?.Head()

Runtime/Solver.cs

@@ -11,9 +11,10 @@ public class Solver<T> : SolverStats{
     const string ZERO_COST_ERR = "Zero cost op is not allowed",
                  NO_INIT       = "Init state is null";
     //
-    public int  maxNodes = 1000,
-                maxIter  = 1000;
-    public bool brfs     = false;
+    public int   maxNodes  = 1000,
+                 maxIter   = 1000;
+    public float tolerance = 0f;
+    public bool  brfs      = false;
     public PlanningState state { get; private set; }
     public int  fxMaxNodes     { get; private set; }
     public int  I              { get; private set; }
@@ -28,7 +29,7 @@ public Node<T> Next(T s, in Goal<T> g, int iter=-1){
         if(s == null) throw new NullRef(NO_INIT);
         initialState = s;
         goal         = g;
-        avail        = new NodeSet<T>(s, g.h, !brfs, maxNodes);
+        avail        = new NodeSet<T>(s, g.h, !brfs, maxNodes, tolerance);
         I            = 0;
         return Iterate(iter);
     }

Runtime/SolverParams.cs

@@ -1,8 +1,9 @@
 namespace Activ.GOAP{
 [System.Serializable] public class SolverParams{
 
-    public int frameBudget = 25;
-    public int maxNodes = 1000;
-    public int maxIter  = 1000;
+    public int   frameBudget = 25;
+    public int   maxNodes    = 1000;
+    public int   maxIter     = 1000;
+    public float tolerance   = 0;
 
 }}