use map rather than jagged array

befunge/src/main/kotlin/befide/befunge/b93/state/Funge93.kt

@@ -12,45 +12,55 @@ class Funge93
 
     override fun next(pos: Vec2, delta: Vec2): Vec2 = (pos + delta) mod size
 
-    val contents = Array(size.y) { Array(size.x) { LongData.SPACE } }
+    override fun defaultData(): LongData = LongData.SPACE
+    override fun defaultChar(): Char = '\u2022' // bullet
 
-    override fun get(pos: Vec2): LongData = contents[pos.y][pos.x]
+    val contents = hashMapOf<Vec2, LongData>()
+
+    override fun get(pos: Vec2): LongData = contents[pos] ?: defaultData()
     override fun set(pos: Vec2, data: LongData) {
+        if (pos.x !in 0 until size.x || pos.y !in 0 until size.y)
+            return
+
         val from = this[pos]
-        contents[pos.y][pos.x] = data
+        contents[pos] = data
         onChange(FungeChange(this, pos, from, data))
     }
 
-    override var data: List<List<LongData>>
+    override var data: Map<Vec2, LongData>
         get() {
-            return contents.map(Array<LongData>::toList)
+            return contents.toMap()
         }
         set(data) {
-            for (y in 0 until size.y) for (x in 0 until size.x) {
+            clear()
-                val pos = Vec2(x, y)
+            for ((v, d) in data.entries)
-                val new = data.getOrNull(y)?.getOrNull(x) ?: this[pos]
+                this[v] = d
-                this[pos] = new
-            }
         }
 
     override var src: String
         get() {
-            return contents.map { row ->
+            val lines = mutableListOf<String>()
-                row.dropLastWhile { ch ->
+            for ((y, row) in contents.entries.groupBy { it.key.y }.toSortedMap()) {
-                    ch.char?.isISOControl() ?: false
+                lines += List(y - lines.size) { "" }
-                }.map { ch ->
+
-                    ch.char ?: '\u2022' // bullet
+                val chars = mutableListOf<Char>()
-                }.joinToString("")
+                for ((v, ch) in row.sortedBy { it.key.x }) {
-            }.dropLastWhile { line ->
+                    chars += List(v.x - chars.size) { ' ' }
-                line.isEmpty()
+                    chars += ch.char ?: defaultChar()
-            }.joinToString("\n")
+                }
-        }
+                lines += chars.joinToString("")
-        set(data) {
-            val lines = data.lines()
-            for (y in 0 until size.y) for (x in 0 until size.x) {
-                val pos = Vec2(x, y)
-                val new = lines.getOrNull(y)?.getOrNull(x)?.let(::LongData) ?: this[pos]
-                this[pos] = new
             }
+            return lines.joinToString("\n")
         }
+        set(src) {
+            data = src.lines().mapIndexed { y, line ->
+                line.mapIndexed { x, ch ->
+                    Pair(Vec2(x, y), LongData(ch))
+                }
+            }.flatten().toMap()
+        }
+
+    override fun clear() {
+        contents.clear()
+    }
 }

befunge/src/main/kotlin/befide/befunge/core/state/Funge.kt

@@ -6,9 +6,12 @@ import befide.befunge.core.util.Event
 interface Funge<V, D : Data> {
     val size: V
 
-    val data: List<List<D>>
+    val data: Map<V, D>
     val src: String
 
+    fun defaultData(): D
+    fun defaultChar(): Char
+
     fun next(pos: V, delta: V): V
 
     operator fun get(pos: V): D

befunge/src/main/kotlin/befide/befunge/core/state/MutableFunge.kt

@@ -3,8 +3,10 @@ package befide.befunge.core.state
 interface MutableFunge<V, D : Data>
     : Funge<V, D> {
 
-    override var data: List<List<D>>
+    override var data: Map<V, D>
     override var src: String
 
     operator fun set(pos: V, data: D)
+
+    fun clear()
 }