Made most classes in lib mutable.

lib/src/commonMain/kotlin/world/phantasmal/lib/asm/dataFlowAnalysis/GetMapDesignations.kt

@@ -11,7 +11,7 @@ private val logger = KotlinLogging.logger {}
 fun getMapDesignations(
     func0Segment: InstructionSegment,
     createCfg: () -> ControlFlowGraph,
-): Map<Int, Int> {
+): MutableMap<Int, Int> {
     val mapDesignations = mutableMapOf<Int, Int>()
     var cfg: ControlFlowGraph? = null
 

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Bin.kt

@@ -12,12 +12,12 @@ private const val PC_OBJECT_CODE_OFFSET = 920
 private const val BB_OBJECT_CODE_OFFSET = 4652
 
 class BinFile(
-    val format: BinFormat,
-    val questId: Int,
-    val language: Int,
-    val questName: String,
-    val shortDescription: String,
-    val longDescription: String,
+    var format: BinFormat,
+    var questId: Int,
+    var language: Int,
+    var questName: String,
+    var shortDescription: String,
+    var longDescription: String,
     val bytecode: Buffer,
     val labelOffsets: IntArray,
     val shopItems: UIntArray,

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Dat.kt

@@ -19,10 +19,10 @@ const val OBJECT_BYTE_SIZE = 68
 const val NPC_BYTE_SIZE = 72
 
 class DatFile(
-    val objs: List<DatEntity>,
-    val npcs: List<DatEntity>,
-    val events: List<DatEvent>,
-    val unknowns: List<DatUnknown>,
+    val objs: MutableList<DatEntity>,
+    val npcs: MutableList<DatEntity>,
+    val events: MutableList<DatEvent>,
+    val unknowns: MutableList<DatUnknown>,
 )
 
 class DatEntity(
@@ -35,35 +35,35 @@ class DatEvent(
     var sectionId: Short,
     var wave: Short,
     var delay: Short,
-    val actions: List<DatEventAction>,
-    val areaId: Int,
-    val unknown: Short,
+    val actions: MutableList<DatEventAction>,
+    var areaId: Int,
+    var unknown: Short,
 )
 
 sealed class DatEventAction {
     class SpawnNpcs(
-        val sectionId: Short,
-        val appearFlag: Short,
+        var sectionId: Short,
+        var appearFlag: Short,
     ) : DatEventAction()
 
     class Unlock(
-        val doorId: Short,
+        var doorId: Short,
     ) : DatEventAction()
 
     class Lock(
-        val doorId: Short,
+        var doorId: Short,
     ) : DatEventAction()
 
     class TriggerEvent(
-        val eventId: Int,
+        var eventId: Int,
     ) : DatEventAction()
 }
 
 class DatUnknown(
-    val entityType: Int,
-    val totalSize: Int,
-    val areaId: Int,
-    val entitiesSize: Int,
+    var entityType: Int,
+    var totalSize: Int,
+    var areaId: Int,
+    var entitiesSize: Int,
     val data: ByteArray,
 )
 
@@ -160,13 +160,13 @@ private fun parseEvents(cursor: Cursor, areaId: Int, events: MutableList<DatEven
         val unknown = cursor.short() // "wavesetting"?
         val eventActionsOffset = cursor.int()
 
-        val actions: List<DatEventAction> =
+        val actions: MutableList<DatEventAction> =
             if (eventActionsOffset < actionsCursor.size) {
                 actionsCursor.seekStart(eventActionsOffset)
                 parseEventActions(actionsCursor)
             } else {
                 logger.warn { "Invalid event actions offset $eventActionsOffset for event ${id}." }
-                emptyList()
+                mutableListOf()
             }
 
         events.add(DatEvent(
@@ -204,7 +204,7 @@ private fun parseEvents(cursor: Cursor, areaId: Int, events: MutableList<DatEven
     cursor.seekStart(actionsOffset + actionsCursor.position)
 }
 
-private fun parseEventActions(cursor: Cursor): List<DatEventAction> {
+private fun parseEventActions(cursor: Cursor): MutableList<DatEventAction> {
     val actions = mutableListOf<DatEventAction>()
 
     outer@ while (cursor.hasBytesLeft()) {

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Quest.kt

@@ -23,16 +23,16 @@ class Quest(
     var shortDescription: String,
     var longDescription: String,
     var episode: Episode,
-    val objects: List<QuestObject>,
-    val npcs: List<QuestNpc>,
-    val events: List<DatEvent>,
+    val objects: MutableList<QuestObject>,
+    val npcs: MutableList<QuestNpc>,
+    val events: MutableList<DatEvent>,
     /**
      * (Partial) raw DAT data that can't be parsed yet by Phantasmal.
      */
-    val datUnknowns: List<DatUnknown>,
-    val bytecodeIr: BytecodeIr,
+    val datUnknowns: MutableList<DatUnknown>,
+    var bytecodeIr: BytecodeIr,
     val shopItems: UIntArray,
-    val mapDesignations: Map<Int, Int>,
+    val mapDesignations: MutableMap<Int, Int>,
 )
 
 fun parseBinDatToQuest(
@@ -60,13 +60,13 @@ fun parseBinDatToQuest(
     }
 
     val dat = parseDat(datDecompressed.value)
-    val objects = dat.objs.map { QuestObject(it.areaId, it.data) }
+    val objects = dat.objs.mapTo(mutableListOf()) { QuestObject(it.areaId, it.data) }
     // Initialize NPCs with random episode and correct it later.
-    val npcs = dat.npcs.map { QuestNpc(Episode.I, it.areaId, it.data) }
+    val npcs = dat.npcs.mapTo(mutableListOf()) { QuestNpc(Episode.I, it.areaId, it.data) }
 
     // Extract episode and map designations from byte code.
     var episode = Episode.I
-    var mapDesignations = emptyMap<Int, Int>()
+    var mapDesignations = mutableMapOf<Int, Int>()
 
     val parseBytecodeResult = parseBytecode(
         bin.bytecode,
@@ -238,8 +238,8 @@ private fun extractScriptEntryPoints(
  */
 fun writeQuestToQst(quest: Quest, filename: String, version: Version, online: Boolean): Buffer {
     val dat = writeDat(DatFile(
-        objs = quest.objects.map { DatEntity(it.areaId, it.data) },
-        npcs = quest.npcs.map { DatEntity(it.areaId, it.data) },
+        objs = quest.objects.mapTo(mutableListOf()) { DatEntity(it.areaId, it.data) },
+        npcs = quest.npcs.mapTo(mutableListOf()) { DatEntity(it.areaId, it.data) },
         events = quest.events,
         unknowns = quest.datUnknowns,
     ))

web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/QuestEditorToolbarController.kt

@@ -209,15 +209,17 @@ class QuestEditorToolbarController(
                 obj { type = "application/octet-stream" },
             )
         )
+
         try {
             a.href = url
             a.download = filename
             document.body?.appendChild(a)
             a.click()
         } catch (e: Exception) {
+            logger.error(e) { """Couldn't save file "$filename".""" }
+        } finally {
             URL.revokeObjectURL(url)
             document.body?.removeChild(a)
-            throw e
         }
 
         dismissSaveAsDialog()

web/src/main/kotlin/world/phantasmal/web/questEditor/stores/ModelConversion.kt

@@ -56,7 +56,7 @@ fun convertQuestToModel(
 
 /**
  * The returned [Quest] object will reference parts of [quest], so some changes to [quest] will be
- * reflected in the returned object.
+ * reflected in the returned object and vice-versa.
  */
 fun convertQuestFromModel(quest: QuestModel): Quest =
     Quest(
@@ -66,15 +66,15 @@ fun convertQuestFromModel(quest: QuestModel): Quest =
         quest.shortDescription.value,
         quest.longDescription.value,
         quest.episode,
-        quest.objects.value.map { it.entity },
-        quest.npcs.value.map { it.entity },
-        quest.events.value.map { event ->
+        quest.objects.value.mapTo(mutableListOf()) { it.entity },
+        quest.npcs.value.mapTo(mutableListOf()) { it.entity },
+        quest.events.value.mapTo(mutableListOf()) { event ->
             DatEvent(
                 event.id.value,
                 event.sectionId.value.toShort(),
                 event.wave.value.id.toShort(),
                 event.delay.value.toShort(),
-                event.actions.value.map { action ->
+                event.actions.value.mapTo(mutableListOf()) { action ->
                     when (action) {
                         is QuestEventActionModel.SpawnNpcs ->
                             DatEventAction.SpawnNpcs(
@@ -96,8 +96,8 @@ fun convertQuestFromModel(quest: QuestModel): Quest =
                 event.unknown.toShort(),
             )
         },
-        quest.datUnknowns,
+        quest.datUnknowns.toMutableList(),
         quest.bytecodeIr,
         quest.shopItems,
-        quest.mapDesignations.value,
+        quest.mapDesignations.value.toMutableMap(),
     )