Updates to TileNavigatedArray and updated tests

src/main/kotlin/data/TileNavigatedArray.kt

@@ -4,23 +4,29 @@ package technology.zim.data
 //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,
+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 {
+                            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)
+
+    constructor(col:Int, row:Int,major:Boolean) : this(colSize = col, rowSize = row,colMajor = major) {
+    }
 
     //Accept a tile, use its coordinates to pull the requested data
-    fun get(tile: Tile):T {
+    fun get(tile: Tile):T? {
         return data[rowOffset(tile) + colOffset(tile)]
     }
 
-    fun add(tile: Tile, value: T) {
+    fun add(tile: Tile, value: T?) {
         data.add(rowOffset(tile)+colOffset(tile), value)
     }
 
+    fun set(tile: Tile, value: T?) {
+        data.set(rowOffset(tile) + colOffset(tile), value)
+    }
+
     //Give it the row
     fun rowOffset(tile: Tile):Int {
-        assert(false) //Fix the return value
         return when (colMajor) {
             //If column major, jump by column size * x
             true -> colSize * tile.x()
@@ -30,7 +36,6 @@ class TileNavigatedArray<T>(val data: ArrayList<T> = ArrayList<T>(), var colSize
     }
 
     fun colOffset(tile: Tile):Int {
-        assert(false) //Fix the return value
         return when (colMajor) {
             //If column major, return the y value
             true -> tile.y()

src/test/kotlin/TileHeapTest.kt

@@ -7,11 +7,12 @@ import kotlin.test.BeforeTest
 
 class TileHeapTest {
     companion object {
-        var heap = TileHeap(Tile(20, 20))
+        var gVals = HashMap<Tile, Int>()
+        var heap = TileHeap(Tile(20, 20), gVals)
     }
     @BeforeTest
     fun setUp() {
-        heap = TileHeap(Tile(20, 20))
+        heap = TileHeap(Tile(20, 20), gVals)
         arrayOf(Tile(0, 0), Tile(1, 1), Tile(5, 5), Tile(4, 4), Tile(19, 19), Tile(2, 2)).forEach { item ->
             heap.insert(item)
         }

src/test/kotlin/TileNavigatedArrayTest.kt

@@ -1,16 +1,32 @@
+import technology.zim.data.Tile
+import technology.zim.data.TileNavigatedArray
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 
 class TileNavigatedArrayTest {
-
+    var arr:TileNavigatedArray<Int> = TileNavigatedArray()
     @BeforeTest
     fun setUp() {
-
+        arr = TileNavigatedArray<Int>(10, 10, false)
+        arr.addAll(0..(10*10))
     }
 
 
     @Test
     fun addAndAccessTest() {
-
+        arr.apply {
+            set(Tile(0,0), -1)
+            set(Tile(0,1), -2)
+            set(Tile(1, 0), -3)
+            set(Tile(1, 1), -4)
+            set(Tile(2, 1), -5)
+            set(Tile(2, 2), -6)
+        }
+        assert(arr.get(Tile(0, 0)) == -1)
+        assert(arr.get(Tile(0, 1)) == -2)
+        assert(arr.get(Tile(1, 0)) == -3)
+        assert(arr.get(Tile(1, 1)) == -4)
+        assert(arr.get(Tile(2, 1)) == -5)
+        assert(arr.get(Tile(2, 2)) == -6)
     }
 }