src/main/kotlin/ArrayBackedPathfinder.kt

@@ -13,11 +13,10 @@ import kotlin.math.abs
 
 object ArrayBackedPathfinder {
     //TODO: Replace with array for coordinate lookups for speed, do it in a separate pathfinder class to demonstrate the difference
-    val gVals = TileNavigatedArray<Int>(World.sizeX, World.sizeY, false)
+    val gVals = TileNavigatedArray<Int>()
     //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) {
-
         if(!start.isInBounds() || !end.isInBounds()) {
             throw IndexOutOfBoundsException("Cannot generate a path to or from an out of bounds tile")
         }
@@ -55,7 +54,6 @@ object ArrayBackedPathfinder {
         } while( current != end)
 
         //At this point, a path is found
-        markPath(start, end)
         println("Path found!")
     }
 
@@ -79,7 +77,7 @@ object ArrayBackedPathfinder {
     }
 
     private fun fValue(prospect: Tile, end: Tile): Int {
-        return hValue(prospect, end).plus(gVals.get(prospect) ?: 0)
+        return hValue(prospect, end).plus(MapBackedPathfinder.gVals.get(prospect) ?: 0)
     }
 
     private fun hValue(prospect: Tile, end:Tile): Int {

src/main/kotlin/Main.kt

@@ -9,33 +9,19 @@ class HierarchicalPathfinding {
         @JvmStatic
         fun main(args: Array<String>) {
             val n = 1000
-            println("Building maze")
-            var startTime = System.currentTimeMillis()
             buildMaze(n)
-            var endTime = System.currentTimeMillis()
-            val buildMazeTime = endTime - startTime
 
             println("Pathfinding")
-
+            var startTime = System.currentTimeMillis()
-            startTime = System.currentTimeMillis()
             MapBackedPathfinder.generatePath(Tile(0, 0), Tile(n-1, (n-1)))
-            endTime = System.currentTimeMillis()
+            var endTime = System.currentTimeMillis()
-            val MapBackedPathfinderTime = endTime - startTime
+            val aStarMs = endTime - startTime
-
-            World.tiles.scrubDirections(listOf(Directions.FRONTIER, Directions.INPATH, Directions.NOPATH))
-
-            startTime = System.currentTimeMillis()
-            ArrayBackedPathfinder.generatePath(Tile(0, 0), Tile(n-1, (n-1)))
-            endTime = System.currentTimeMillis()
-            val ArrayBackedPathfinderTime = endTime - startTime
 
 
 
             println(World.toString())
             println(n*n)
-            println("Maze build time: ${buildMazeTime} ms")
+            println((endTime - startTime).toString() + "ms")
-            println("HashMap-Backed Pathfinder time: ${MapBackedPathfinderTime}ms")
-            println("Array-Backed Pathfinder time: ${ArrayBackedPathfinderTime} ms")
         }
 
         //Clear the maze of pathfinding markers before running another pathfinding algorithm

src/main/kotlin/data/TileNavigatedArray.kt

@@ -1,31 +1,15 @@
 package technology.zim.data
 
-import java.util.Arrays
-import kotlin.arrayOfNulls
-
 //Generic array that accepts a Tile for item lookups
 //Row-major for improved memory locality.. maybe make it flexible?
 
 //Delegation should allow direct access to functions, with added functions for convenience
 class TileNavigatedArray<T>(val data: ArrayList<T?> = ArrayList<T?>(), var colSize:Int = 10,
                             var rowSize:Int = 10, val colMajor:Boolean = false) : MutableList<T?> by data {
+//TODO: Create initializer that fills array with null values
 
-    constructor(col:Int, row:Int,major:Boolean) : this(colSize = col, rowSize = row,colMajor = major) {
-    }
-    init {
-        for(i in 0..rowSize*colSize){
-            data.add(null)
-        }
-    }
 
-    //TODO: Test resize properly
+    constructor(col:Int, row:Int,major:Boolean) : this(colSize = col, rowSize = row,colMajor = major) {
-    fun resize(colSize:Int, rowSize:Int) {
-        this.colSize = colSize
-        this.rowSize = rowSize
-        for(i in data.size..colSize*rowSize-data.size) {
-            data.add(null)
-        }
-        assert(data.size == this.colSize*this.rowSize)
     }
 
     //Accept a tile, use its coordinates to pull the requested data