Refined pathfinder notes with concrete concepts

src/main/kotlin/PathFinder.kt

@@ -22,35 +22,19 @@ object PathFinder {
             return
         }
 
-        //Data structure to define the frontier, possibly a heap
+        //Frontier defined by a Tile heap that makes comparisons on calculated hValues
 
-        //Frontier tiles know their current cost: g(n) (number of steps from start to this node)+ calculate own distance from the end h(n)
+        //Frontier tiles are known to have a current cost: g(n) (number of steps from start to this node)+ calculate own distance from the end h(n)
-        //Always grab the lowest value of f(n) = g(n) + h(n) from the frontier, mark it visited, add its unvisited neighbors
         //Probably best to just make an array of integers, where the coordinates store the tile's g(n)
 
+        //Always grab the lowest value of f(n) = g(n) + h(n) from the frontier, mark it visited, mark its g(n), and add its unvisited neighbors
+
         //Need to be able to return a tile to the frontier if a shorter path to it is found
-        //This seems like a thing that should not be possible. Manhattan heuristic
 
         //Data structure to hold the g values
-        //Data structure to mark parents (tree? hashmap?)
+        //Parent is chosen by the lowest g(n) value
-        //Three choices that I see:
-
-        //Don't track parents, track g-values only by mapping them out from the parent to the children as soon as the parent is reached
-        //Parent can be identified by looking for lowest g(x) on neighboring tiles (barring alternate paths? maybe works either way in a perfect maze?)
-        //Might not matter because equal g(x) means that the path back is an equal number of steps either way, so pick one.
-
-        //Dual arrays, one for g-val and one for parent node, take advantage of bitflags in Directions
-
-        //Useless for a maze because we'll only go to a deadend once
-        //or add a flag for DEADEND, use a more dynamic data structure to store tile data (map?)
-        //then prune tiles from the data structure when they're marked as dead ends, backtracking until a fork is available
-
 
-
+        //return a list of steps by starting at the exit, looking at the lowest g(n) neighbor
-
-
-
-        //return a list of steps
     }
 
     //Heuristic value, to estimate the cost of a given tile
@@ -64,4 +48,5 @@ object PathFinder {
 
     }
 
+
 }