Add benchmarking functionality

src/main/kotlin/ArrayBackedPathfinder.kt

@@ -4,6 +4,7 @@ import technology.zim.data.Directions
 import technology.zim.data.Tile
 import technology.zim.data.TileHeap
 import technology.zim.data.TileNavigatedArray
+import kotlin.Int
 import kotlin.math.abs
 
 //A* pathfinder backed by an array to improve efficiency
@@ -12,7 +13,7 @@ import kotlin.math.abs
 //and https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Comparator.html
 
 object ArrayBackedPathfinder {
-    val gVals = TileNavigatedArray<Int>(World.sizeX, World.sizeY, false)
+    var gVals = TileNavigatedArray<Int>(World.sizeX, World.sizeY, false)
     //work along the path, marking tiles with VISITED along the way
     //if marking with visited is too expensive, just make the path and finalize it
     fun generatePath(start: Tile, end: Tile) {
@@ -25,7 +26,7 @@ object ArrayBackedPathfinder {
             println("Ouroboros detected")
             return
         }
-
+        gVals = TileNavigatedArray<Int>(World.sizeX, World.sizeY, false)
         val frontier = TileHeap(end, this::fValue)
 
         //Prime the things
@@ -55,7 +56,7 @@ object ArrayBackedPathfinder {
 
         //At this point, a path is found
         markPath(start, end)
-        println("Path found!")
+        //println("Path found!")
     }
 
     fun markPath(start: Tile, end:Tile) {

src/main/kotlin/Main.kt

@@ -1,6 +1,7 @@
 package technology.zim
 
 import technology.zim.data.Tile
+import java.io.File
 import java.text.NumberFormat
 import java.util.Locale
 import kotlin.time.measureTime
@@ -20,27 +21,22 @@ class HierarchicalPathfinding {
     companion object {
         @JvmStatic
         fun main(args: Array<String>) {
-            val n = 1000
-            println("Building maze")
-            val buildMazeTime = measureTime {
-                buildMaze(n)
-            }
-
-            println("Pathfinding")
+            val benchmarking = false
+            val ns = arrayListOf(50, 100, 250, 500, 750, 1000)
+            val iterations = 10
+            val file = File("performance.csv")
+            file.writeText("n, build, bfs, astar-array, astar-hashmap\n")
 
-            val bfsPathfinderTime = measureTime {
-                BFSPathfinder.generatePath(Tile(0, 0), Tile(n-1, n-1))
+            if(benchmarking) {
+                for (n in ns) {
+                    for (i in 0 until iterations) {
+                        doTheThing(n, file)
                     }
-
-
-            val arrayBackedPathfinderTime = measureTime {
-                ArrayBackedPathfinder.generatePath(Tile(0, 0), Tile(n - 1, (n - 1)))
                 }
-
-            val mapBackedPathfinderTime = measureTime {
-                MapBackedPathfinder.generatePath(Tile(0, 0), Tile(n - 1, (n - 1)))
             }
-
+            else
+                doTheThing(500, file)
+            /*
             val numberFormat = NumberFormat.getInstance(Locale.US)
             println(World.toString())
             println(numberFormat.format(n*n))
@@ -48,13 +44,37 @@ class HierarchicalPathfinding {
             println("BFS Pathfinder time: ${numberFormat.format(bfsPathfinderTime.inWholeMilliseconds)}ms")
             println("Array-Backed Pathfinder time: ${numberFormat.format(arrayBackedPathfinderTime.inWholeMilliseconds)}ms")
             println("HashMap-Backed Pathfinder time: ${numberFormat.format(mapBackedPathfinderTime.inWholeMilliseconds)}ms")
+            */
+        }
+
+        fun doTheThing(n:Int, file:File) {
+            World.clear()
+
+            var buildMazeTime = measureTime {
+                buildMaze(n)
+            }
+
+            var bfsPathfinderTime = measureTime {
+                BFSPathfinder.generatePath(Tile(0, 0), Tile(n - 1, n - 1))
+            }
+
+
+            var arrayBackedPathfinderTime = measureTime {
+                ArrayBackedPathfinder.generatePath(Tile(0, 0), Tile(n - 1, n - 1))
+            }
+
+            var mapBackedPathfinderTime = measureTime {
+                MapBackedPathfinder.generatePath(Tile(0, 0), Tile(n - 1, n - 1))
+            }
+            file.appendText("${n},${buildMazeTime.inWholeMilliseconds},${bfsPathfinderTime.inWholeMilliseconds},${arrayBackedPathfinderTime.inWholeMilliseconds},${mapBackedPathfinderTime.inWholeMilliseconds}\n")
+
         }
 
         fun buildMaze(n: Int) {
 
-            println("Building world")
+            //println("Building world")
             World.setSize(n, n)
-            println("Start")
+            //println("Start")
 
             try {
                 MazeFinder.primsAlgorithm()

src/main/kotlin/MapBackedPathfinder.kt

@@ -23,7 +23,7 @@ object MapBackedPathfinder {
             println("Ouroboros detected")
             return
         }
-
+        gVals.clear()
         val frontier = TileHeap(end, this::fValue)
 
         //Prime the things
@@ -52,7 +52,7 @@ object MapBackedPathfinder {
         } while( current != end)
 
         //At this point, a path is found
-        println("Path found!")
+        //println("Path found!")
         markPath(start, end)
     }
 

src/main/kotlin/MazeFinder.kt

@@ -26,6 +26,7 @@ object MazeFinder {
     }
 
     fun primsAlgorithm() {
+        frontier.clear()
         //Prime the graph with the first connection, which marks the first visited Tiles
         val startingTile = World.getRandomLocation()
         val connectorTile = startingTile.getAdjacentTiles(false).random()
@@ -62,7 +63,7 @@ object MazeFinder {
             //println("--------------------------------------------")
 
         }
-        println("prim")
+        //println("prim")
     }
 
     private fun addToManifest(current: Tile) {

src/main/kotlin/World.kt

@@ -20,7 +20,7 @@ import technology.zim.data.TileNavigatedArray
 @Suppress("unused")
 object World {
     //Default size should be 10
-    val tiles = TileNavigatedArray<TileProperties>()
+    var tiles = TileNavigatedArray<TileProperties>()
     var sizeX = 10 //Default size
     var sizeY = 10
     const val ANSI_RESET = "\u001B[0m"
@@ -54,6 +54,15 @@ object World {
         sizeX = x
         sizeY = y
         tiles.resize(x, y)
+        tiles.forEachIndexed {
+            i, t ->
+            tiles.set(i, TileProperties(0))
+        }
+    }
+
+    fun clear() {
+        tiles = TileNavigatedArray<TileProperties>()
+        setSize(sizeX, sizeY)
     }
 
     override fun toString(): String {