Quests can be saved again.

lib/karma.config.d/karma.config.js

@@ -0,0 +1,7 @@
+config.set({
+    client: {
+        mocha: {
+            timeout: 10_000
+        }
+    }
+});

lib/src/commonMain/kotlin/world/phantasmal/lib/asm/BytecodeIr.kt

@@ -10,6 +10,9 @@ class BytecodeIr(
 ) {
     fun instructionSegments(): List<InstructionSegment> =
         segments.filterIsInstance<InstructionSegment>()
+
+    fun copy(): BytecodeIr =
+        BytecodeIr(segments.map { it.copy() })
 }
 
 enum class SegmentType {
@@ -27,25 +30,40 @@ sealed class Segment(
     val type: SegmentType,
     val labels: MutableList<Int>,
     val srcLoc: SegmentSrcLoc,
-)
+) {
+    abstract fun copy(): Segment
+}
 
 class InstructionSegment(
     labels: MutableList<Int>,
     val instructions: MutableList<Instruction>,
     srcLoc: SegmentSrcLoc = SegmentSrcLoc(mutableListOf()),
-) : Segment(SegmentType.Instructions, labels, srcLoc)
+) : Segment(SegmentType.Instructions, labels, srcLoc) {
+    override fun copy(): InstructionSegment =
+        InstructionSegment(
+            ArrayList(labels),
+            instructions.mapTo(mutableListOf()) { it.copy() },
+            srcLoc.copy(),
+        )
+}
 
 class DataSegment(
     labels: MutableList<Int>,
     val data: Buffer,
     srcLoc: SegmentSrcLoc = SegmentSrcLoc(mutableListOf()),
-) : Segment(SegmentType.Data, labels, srcLoc)
+) : Segment(SegmentType.Data, labels, srcLoc) {
+    override fun copy(): DataSegment =
+        DataSegment(ArrayList(labels), data.copy(), srcLoc.copy())
+}
 
 class StringSegment(
     labels: MutableList<Int>,
     var value: String,
     srcLoc: SegmentSrcLoc = SegmentSrcLoc(mutableListOf()),
-) : Segment(SegmentType.String, labels, srcLoc)
+) : Segment(SegmentType.String, labels, srcLoc) {
+    override fun copy(): StringSegment =
+        StringSegment(ArrayList(labels), value, srcLoc.copy())
+}
 
 /**
  * Opcode invocation.
@@ -179,6 +197,9 @@ class Instruction(
 
         return size
     }
+
+    fun copy(): Instruction =
+        Instruction(opcode, args, srcLoc)
 }
 
 /**
@@ -207,4 +228,7 @@ class InstructionSrcLoc(
 /**
  * Locations of a segment's labels in the source assembly code.
  */
-class SegmentSrcLoc(val labels: MutableList<SrcLoc> = mutableListOf())
+class SegmentSrcLoc(val labels: MutableList<SrcLoc> = mutableListOf()) {
+    fun copy(): SegmentSrcLoc =
+        SegmentSrcLoc(ArrayList(labels))
+}

lib/src/commonMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt

@@ -107,6 +107,11 @@ expect class Buffer {
 
     fun toBase64(): String
 
+    /**
+     * Returns a copy of this buffer of the same size. The copy's capacity will equal its size.
+     */
+    fun copy(): Buffer
+
     companion object {
         /**
          * Returns a new buffer the given initial capacity and size 0.

lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/Vector.kt

@@ -2,9 +2,9 @@ package world.phantasmal.lib.fileFormats
 
 import world.phantasmal.lib.cursor.Cursor
 
-class Vec2(val x: Float, val y: Float)
+data class Vec2(val x: Float, val y: Float)
 
-class Vec3(val x: Float, val y: Float, val z: Float)
+data class Vec3(val x: Float, val y: Float, val z: Float)
 
 fun Cursor.vec2Float(): Vec2 = Vec2(float(), float())
 

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

@@ -3,6 +3,7 @@ package world.phantasmal.lib.fileFormats.quest
 import mu.KotlinLogging
 import world.phantasmal.lib.buffer.Buffer
 import world.phantasmal.lib.cursor.Cursor
+import world.phantasmal.lib.cursor.cursor
 
 private val logger = KotlinLogging.logger {}
 
@@ -116,3 +117,80 @@ fun parseBin(cursor: Cursor): BinFile {
         shopItems,
     )
 }
+
+fun writeBin(bin: BinFile): Buffer {
+    require(bin.questName.length <= 32) {
+        "questName can't be longer than 32 characters, was ${bin.questName.length}"
+    }
+    require(bin.shortDescription.length <= 127) {
+        "shortDescription can't be longer than 127 characters, was ${bin.shortDescription.length}"
+    }
+    require(bin.longDescription.length <= 287) {
+        "longDescription can't be longer than 287 characters, was ${bin.longDescription.length}"
+    }
+    require(bin.shopItems.isEmpty() || bin.format == BinFormat.BB) {
+        "shopItems is only supported in BlueBurst quests."
+    }
+    require(bin.shopItems.size <= 932) {
+        "shopItems can't be larger than 932, was ${bin.shopItems.size}."
+    }
+
+    val bytecodeOffset = when (bin.format) {
+        BinFormat.DC_GC -> DC_GC_OBJECT_CODE_OFFSET
+        BinFormat.PC -> PC_OBJECT_CODE_OFFSET
+        BinFormat.BB -> BB_OBJECT_CODE_OFFSET
+    }
+
+    val fileSize = bytecodeOffset + bin.bytecode.size + 4 * bin.labelOffsets.size
+    val buffer = Buffer.withCapacity(fileSize)
+    val cursor = buffer.cursor()
+
+    cursor.writeInt(bytecodeOffset)
+    cursor.writeInt(bytecodeOffset + bin.bytecode.size) // Label table offset.
+    cursor.writeInt(fileSize)
+    cursor.writeInt(-1)
+
+    if (bin.format == BinFormat.DC_GC) {
+        cursor.writeByte(0)
+        cursor.writeByte(bin.language.toByte())
+        cursor.writeShort(bin.questId.toShort())
+        cursor.writeStringAscii(bin.questName, 32)
+        cursor.writeStringAscii(bin.shortDescription, 128)
+        cursor.writeStringAscii(bin.longDescription, 288)
+    } else {
+        if (bin.format == BinFormat.PC) {
+            cursor.writeShort(bin.language.toShort())
+            cursor.writeShort(bin.questId.toShort())
+        } else {
+            cursor.writeInt(bin.questId)
+            cursor.writeInt(bin.language)
+        }
+
+        cursor.writeStringUtf16(bin.questName, 64)
+        cursor.writeStringUtf16(bin.shortDescription, 256)
+        cursor.writeStringUtf16(bin.longDescription, 576)
+    }
+
+    if (bin.format == BinFormat.BB) {
+        cursor.writeInt(0)
+        cursor.writeUIntArray(bin.shopItems)
+
+        repeat(932 - bin.shopItems.size) {
+            cursor.writeUInt(0u)
+        }
+    }
+
+    check(cursor.position == bytecodeOffset) {
+        "Expected to write $bytecodeOffset bytes before bytecode, but wrote ${cursor.position}."
+    }
+
+    cursor.writeCursor(bin.bytecode.cursor())
+
+    cursor.writeIntArray(bin.labelOffsets)
+
+    check(cursor.position == fileSize) {
+        "Expected to write $fileSize bytes, but wrote ${cursor.position}."
+    }
+
+    return buffer
+}

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

@@ -3,6 +3,7 @@ package world.phantasmal.lib.fileFormats.quest
 import mu.KotlinLogging
 import world.phantasmal.core.PwResult
 import world.phantasmal.core.Severity
+import world.phantasmal.lib.Endianness
 import world.phantasmal.lib.asm.*
 import world.phantasmal.lib.asm.dataFlowAnalysis.ControlFlowGraph
 import world.phantasmal.lib.asm.dataFlowAnalysis.getRegisterValue
@@ -10,6 +11,7 @@ import world.phantasmal.lib.asm.dataFlowAnalysis.getStackValue
 import world.phantasmal.lib.buffer.Buffer
 import world.phantasmal.lib.cursor.BufferCursor
 import world.phantasmal.lib.cursor.Cursor
+import world.phantasmal.lib.cursor.cursor
 import kotlin.math.ceil
 import kotlin.math.min
 
@@ -118,7 +120,13 @@ fun parseBytecode(
             is DataSegment -> segment.data.size
 
             // String segments should be multiples of 4 bytes.
-            is StringSegment -> 4 * ceil((segment.value.length + 1) / 2.0).toInt()
+            is StringSegment -> {
+                if (dcGcFormat) {
+                    4 * ceil((segment.value.length + 1) / 4.0).toInt()
+                } else {
+                    4 * ceil((segment.value.length + 1) / 2.0).toInt()
+                }
+            }
         }
     }
 
@@ -558,6 +566,103 @@ private fun parseInstructionArguments(
     return args
 }
 
+fun writeBytecode(bytecodeIr: BytecodeIr, dcGcFormat: Boolean): BytecodeAndLabelOffsets {
+    val buffer = Buffer.withCapacity(100 * bytecodeIr.segments.size, Endianness.Little)
+    val cursor = buffer.cursor()
+    // Keep track of label offsets.
+    val largestLabel = bytecodeIr.segments.asSequence().flatMap { it.labels }.maxOrNull() ?: -1
+    val labelOffsets = IntArray(largestLabel + 1) { -1 }
+
+    for (segment in bytecodeIr.segments) {
+        for (label in segment.labels) {
+            labelOffsets[label] = cursor.position
+        }
+
+        when (segment) {
+            is InstructionSegment -> {
+                for (instruction in segment.instructions) {
+                    val opcode = instruction.opcode
+
+                    if (opcode.size == 2) {
+                        cursor.writeByte((opcode.code ushr 8).toByte())
+                    }
+
+                    cursor.writeByte(opcode.code.toByte())
+
+                    if (opcode.stack != StackInteraction.Pop) {
+                        for (i in opcode.params.indices) {
+                            val param = opcode.params[i]
+                            val args = instruction.getArgs(i)
+                            val arg = args.first()
+
+                            when (param.type) {
+                                ByteType -> cursor.writeByte((arg.value as Int).toByte())
+                                ShortType -> cursor.writeShort((arg.value as Int).toShort())
+                                IntType -> cursor.writeInt(arg.value as Int)
+                                FloatType -> cursor.writeFloat(arg.value as Float)
+                                // Ensure this case is before the LabelType case because
+                                // ILabelVarType extends LabelType.
+                                ILabelVarType -> {
+                                    cursor.writeByte(args.size.toByte())
+
+                                    for (a in args) {
+                                        cursor.writeShort((a.value as Int).toShort())
+                                    }
+                                }
+                                is LabelType -> cursor.writeShort((arg.value as Int).toShort())
+                                StringType -> {
+                                    val str = arg.value as String
+
+                                    if (dcGcFormat) cursor.writeStringAscii(str, str.length + 1)
+                                    else cursor.writeStringUtf16(str, 2 * str.length + 2)
+                                }
+                                RegRefType, is RegTupRefType -> {
+                                    cursor.writeByte((arg.value as Int).toByte())
+                                }
+                                RegRefVarType -> {
+                                    cursor.writeByte(args.size.toByte())
+
+                                    for (a in args) {
+                                        cursor.writeByte((a.value as Int).toByte())
+                                    }
+                                }
+                                else -> error(
+                                    "Parameter type ${param.type::class.simpleName} not supported."
+                                )
+                            }
+                        }
+                    }
+                }
+            }
+
+            is StringSegment -> {
+                // String segments should be multiples of 4 bytes.
+                if (dcGcFormat) {
+                    val byteLength = 4 * ceil((segment.value.length + 1) / 4.0).toInt()
+                    cursor.writeStringAscii(segment.value, byteLength)
+                } else {
+                    val byteLength = 4 * ceil((segment.value.length + 1) / 2.0).toInt()
+                    cursor.writeStringUtf16(segment.value, byteLength)
+                }
+            }
+
+            is DataSegment -> {
+                cursor.writeCursor(segment.data.cursor())
+            }
+        }
+    }
+
+    return BytecodeAndLabelOffsets(buffer, labelOffsets)
+}
+
+class BytecodeAndLabelOffsets(
+    val bytecode: Buffer,
+    val labelOffsets: IntArray,
+) {
+    operator fun component1(): Buffer = bytecode
+    operator fun component2(): IntArray = labelOffsets
+}
+
 private data class LabelAndOffset(val label: Int, val offset: Int)
 private data class OffsetAndIndex(val offset: Int, val index: Int)
 private class LabelInfo(val offset: Int, val next: LabelAndOffset?)

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

@@ -1,15 +1,19 @@
 package world.phantasmal.lib.fileFormats.quest
 
 import mu.KotlinLogging
+import world.phantasmal.lib.Endianness
 import world.phantasmal.lib.buffer.Buffer
 import world.phantasmal.lib.cursor.Cursor
+import world.phantasmal.lib.cursor.WritableCursor
+import world.phantasmal.lib.cursor.cursor
+import kotlin.math.max
 
 private val logger = KotlinLogging.logger {}
 
-private const val EVENT_ACTION_SPAWN_NPCS = 0x8
+private const val EVENT_ACTION_SPAWN_NPCS: Byte = 0x8
-private const val EVENT_ACTION_UNLOCK = 0xA
+private const val EVENT_ACTION_UNLOCK: Byte = 0xA
-private const val EVENT_ACTION_LOCK = 0xB
+private const val EVENT_ACTION_LOCK: Byte = 0xB
-private const val EVENT_ACTION_TRIGGER_EVENT = 0xC
+private const val EVENT_ACTION_TRIGGER_EVENT: Byte = 0xC
 
 const val OBJECT_BYTE_SIZE = 68
 const val NPC_BYTE_SIZE = 72
@@ -31,7 +35,7 @@ class DatEvent(
     var sectionId: Short,
     var wave: Short,
     var delay: Short,
-    val actions: MutableList<DatEventAction>,
+    val actions: List<DatEventAction>,
     val areaId: Int,
     val unknown: Short,
 )
@@ -156,13 +160,13 @@ private fun parseEvents(cursor: Cursor, areaId: Int, events: MutableList<DatEven
         val unknown = cursor.short() // "wavesetting"?
         val eventActionsOffset = cursor.int()
 
-        val actions: MutableList<DatEventAction> =
+        val actions: List<DatEventAction> =
             if (eventActionsOffset < actionsCursor.size) {
                 actionsCursor.seekStart(eventActionsOffset)
                 parseEventActions(actionsCursor)
             } else {
                 logger.warn { "Invalid event actions offset $eventActionsOffset for event ${id}." }
-                mutableListOf()
+                emptyList()
             }
 
         events.add(DatEvent(
@@ -200,12 +204,12 @@ private fun parseEvents(cursor: Cursor, areaId: Int, events: MutableList<DatEven
     cursor.seekStart(actionsOffset + actionsCursor.position)
 }
 
-private fun parseEventActions(cursor: Cursor): MutableList<DatEventAction> {
+private fun parseEventActions(cursor: Cursor): List<DatEventAction> {
     val actions = mutableListOf<DatEventAction>()
 
     outer@ while (cursor.hasBytesLeft()) {
-        when (val type = cursor.uByte().toInt()) {
+        when (val type = cursor.byte()) {
-            1 -> break@outer
+            (1).toByte() -> break@outer
 
             EVENT_ACTION_SPAWN_NPCS ->
                 actions.add(DatEventAction.SpawnNpcs(
@@ -237,3 +241,154 @@ private fun parseEventActions(cursor: Cursor): MutableList<DatEventAction> {
 
     return actions
 }
+
+fun writeDat(dat: DatFile): Buffer {
+    val buffer = Buffer.withCapacity(
+        dat.objs.size * (16 + OBJECT_BYTE_SIZE) +
+                dat.npcs.size * (16 + NPC_BYTE_SIZE) +
+                dat.unknowns.sumBy { it.totalSize },
+        endianness = Endianness.Little,
+    )
+    val cursor = buffer.cursor()
+
+    writeEntities(cursor, dat.objs, 1, OBJECT_BYTE_SIZE)
+    writeEntities(cursor, dat.npcs, 2, NPC_BYTE_SIZE)
+    writeEvents(cursor, dat.events)
+
+    for (unknown in dat.unknowns) {
+        cursor.writeInt(unknown.entityType)
+        cursor.writeInt(unknown.totalSize)
+        cursor.writeInt(unknown.areaId)
+        cursor.writeInt(unknown.entitiesSize)
+        cursor.writeByteArray(unknown.data)
+    }
+
+    // Final header.
+    cursor.writeInt(0)
+    cursor.writeInt(0)
+    cursor.writeInt(0)
+    cursor.writeInt(0)
+
+    return buffer
+}
+
+private fun writeEntities(
+    cursor: WritableCursor,
+    entities: List<DatEntity>,
+    entityType: Int,
+    entitySize: Int,
+) {
+    val groupedEntities = entities.groupBy { it.areaId }
+
+    for ((areaId, areaEntities) in groupedEntities.entries.sortedBy { it.key }) {
+        val entitiesSize = areaEntities.size * entitySize
+        cursor.writeInt(entityType)
+        cursor.writeInt(16 + entitiesSize)
+        cursor.writeInt(areaId)
+        cursor.writeInt(entitiesSize)
+        val startPos = cursor.position
+
+        for (entity in areaEntities) {
+            require(entity.data.size == entitySize) {
+                "Malformed entity in area $areaId, data buffer was of size ${
+                    entity.data.size
+                } instead of expected $entitySize."
+            }
+
+            cursor.writeCursor(entity.data.cursor())
+        }
+
+        check(cursor.position == startPos + entitiesSize) {
+            "Wrote ${
+                cursor.position - startPos
+            } bytes of entity data instead of expected $entitiesSize bytes for area $areaId."
+        }
+    }
+}
+
+private fun writeEvents(cursor: WritableCursor, events: List<DatEvent>) {
+    val groupedEvents = events.groupBy { it.areaId }
+
+    for ((areaId, areaEvents) in groupedEvents.entries.sortedBy { it.key }) {
+        // Standard header.
+        cursor.writeInt(3) // Entity type
+        val totalSizeOffset = cursor.position
+        cursor.writeInt(0) // Placeholder for the total size.
+        cursor.writeInt(areaId)
+        val entitiesSizeOffset = cursor.position
+        cursor.writeInt(0) // Placeholder for the entities size.
+
+        // Event header.
+        val startPos = cursor.position
+        // TODO: actual event size is dependent on the event type (challenge mode).
+        // Absolute offset.
+        val actionsOffset = startPos + 16 + 20 * areaEvents.size
+        cursor.size = max(actionsOffset, cursor.size)
+
+        cursor.writeInt(actionsOffset - startPos)
+        cursor.writeInt(0x10)
+        cursor.writeInt(areaEvents.size)
+        cursor.writeInt(0) // TODO: write event type (challenge mode).
+
+        // Relative offset.
+        var eventActionsOffset = 0
+
+        for (event in areaEvents) {
+            cursor.writeInt(event.id)
+            cursor.writeInt(0x10000)
+            cursor.writeShort(event.sectionId)
+            cursor.writeShort(event.wave)
+            cursor.writeShort(event.delay)
+            cursor.writeShort(event.unknown)
+            cursor.writeInt(eventActionsOffset)
+            val nextEventPos = cursor.position
+
+            cursor.seekStart(actionsOffset + eventActionsOffset)
+
+            for (action in event.actions) {
+                when (action) {
+                    is DatEventAction.SpawnNpcs -> {
+                        cursor.writeByte(EVENT_ACTION_SPAWN_NPCS)
+                        cursor.writeShort(action.sectionId)
+                        cursor.writeShort(action.appearFlag)
+                    }
+                    is DatEventAction.Unlock -> {
+                        cursor.writeByte(EVENT_ACTION_UNLOCK)
+                        cursor.writeShort(action.doorId)
+                    }
+                    is DatEventAction.Lock -> {
+                        cursor.writeByte(EVENT_ACTION_LOCK)
+                        cursor.writeShort(action.doorId)
+                    }
+                    is DatEventAction.TriggerEvent -> {
+                        cursor.writeByte(EVENT_ACTION_TRIGGER_EVENT)
+                        cursor.writeInt(action.eventId)
+                    }
+                }
+            }
+
+            // End of event actions.
+            cursor.writeByte(1)
+
+            eventActionsOffset = cursor.position - actionsOffset
+
+            cursor.seekStart(nextEventPos)
+        }
+
+        cursor.seekStart(actionsOffset + eventActionsOffset)
+
+        while ((cursor.position - actionsOffset) % 4 != 0) {
+            cursor.writeByte(-1)
+        }
+
+        val endPos = cursor.position
+
+        cursor.seekStart(totalSizeOffset)
+        cursor.writeInt(16 + endPos - startPos)
+
+        cursor.seekStart(entitiesSizeOffset)
+        cursor.writeInt(endPos - startPos)
+
+        cursor.seekStart(endPos)
+    }
+}

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

@@ -12,6 +12,7 @@ import world.phantasmal.lib.cursor.WritableCursor
 import world.phantasmal.lib.cursor.cursor
 import kotlin.math.ceil
 import kotlin.math.max
+import kotlin.math.min
 
 private val logger = KotlinLogging.logger {}
 
@@ -134,7 +135,8 @@ private fun parseHeaders(cursor: Cursor): List<QstHeader> {
     var prevQuestId: Int? = null
     var prevFilename: String? = null
 
-    // .qst files should have two headers, some malformed files have more.
+    // .qst files should have two headers. Some malformed files have more, so we tried to detect at
+    // most 4 headers.
     repeat(4) {
         // Detect version and whether it's an online or download quest.
         val version: Version
@@ -407,3 +409,216 @@ private fun parseFiles(
         }
     )
 }
+
+fun writeQst(qst: QstContent): Buffer {
+    val fileHeaderSize: Int
+    val chunkSize: Int
+
+    when (qst.version) {
+        Version.DC, Version.GC, Version.PC -> {
+            fileHeaderSize = DC_GC_PC_HEADER_SIZE
+            chunkSize = DC_GC_PC_CHUNK_SIZE
+        }
+        Version.BB -> {
+            fileHeaderSize = BB_HEADER_SIZE
+            chunkSize = BB_CHUNK_SIZE
+        }
+    }
+
+    val totalSize = qst.files.sumOf {
+        fileHeaderSize + ceil(it.data.size.toDouble() / CHUNK_BODY_SIZE).toInt() * chunkSize
+    }
+
+    val buffer = Buffer.withCapacity(totalSize)
+    val cursor = buffer.cursor()
+
+    writeFileHeaders(cursor, qst.files, qst.version, qst.online, fileHeaderSize)
+    writeFileChunks(cursor, qst.files, qst.version)
+
+    check(cursor.position == totalSize) {
+        "Expected a final file size of $totalSize, but got ${cursor.position}."
+    }
+
+    return buffer
+}
+
+private fun writeFileHeaders(
+    cursor: WritableCursor,
+    files: List<QstContainedFile>,
+    version: Version,
+    online: Boolean,
+    headerSize: Int,
+) {
+    val maxId: Int
+    val maxQuestNameLength: Int
+
+    if (version == Version.BB) {
+        maxId = 0xffff
+        maxQuestNameLength = 23
+    } else {
+        maxId = 0xff
+        maxQuestNameLength = 31
+    }
+
+    for (file in files) {
+        require(file.id == null || (file.id in 0..maxId)) {
+            "Quest ID should be between 0 and $maxId, inclusive."
+        }
+        require(file.questName == null || file.questName.length <= maxQuestNameLength) {
+            "File ${file.filename} has a quest name longer than $maxQuestNameLength characters (${file.questName})."
+        }
+        require(file.filename.length <= 15) {
+            "File ${file.filename} has a filename longer than 15 characters."
+        }
+
+        when (version) {
+            Version.DC -> {
+                cursor.writeUByte((if (online) ONLINE_QUEST else DOWNLOAD_QUEST).toUByte())
+                cursor.writeUByte(file.id?.toUByte() ?: 0u)
+                cursor.writeUShort(headerSize.toUShort())
+                cursor.writeStringAscii(file.questName ?: file.filename, 32)
+                cursor.writeByte(0)
+                cursor.writeByte(0)
+                cursor.writeByte(0)
+                cursor.writeStringAscii(file.filename, 16)
+                cursor.writeByte(0)
+                cursor.writeInt(file.data.size)
+            }
+
+            Version.GC -> {
+                cursor.writeUByte((if (online) ONLINE_QUEST else DOWNLOAD_QUEST).toUByte())
+                cursor.writeUByte(file.id?.toUByte() ?: 0u)
+                cursor.writeUShort(headerSize.toUShort())
+                cursor.writeStringAscii(file.questName ?: file.filename, 32)
+                cursor.writeInt(0)
+                cursor.writeStringAscii(file.filename, 16)
+                cursor.writeInt(file.data.size)
+            }
+
+            Version.PC -> {
+                cursor.writeUShort(headerSize.toUShort())
+                cursor.writeUByte((if (online) ONLINE_QUEST else DOWNLOAD_QUEST).toUByte())
+                cursor.writeUByte(file.id?.toUByte() ?: 0u)
+                cursor.writeStringAscii(file.questName ?: file.filename, 32)
+                cursor.writeInt(0)
+                cursor.writeStringAscii(file.filename, 16)
+                cursor.writeInt(file.data.size)
+            }
+
+            Version.BB -> {
+                cursor.writeUShort(headerSize.toUShort())
+                cursor.writeUShort((if (online) ONLINE_QUEST else DOWNLOAD_QUEST).toUShort())
+                cursor.writeUShort(file.id?.toUShort() ?: 0u)
+                repeat(38) { cursor.writeByte(0) }
+                cursor.writeStringAscii(file.filename, 16)
+                cursor.writeInt(file.data.size)
+                cursor.writeStringAscii(file.questName ?: file.filename, 24)
+            }
+        }
+    }
+}
+
+private class FileToChunk(
+    var no: Int,
+    val data: Cursor,
+    val name: String,
+)
+
+private fun writeFileChunks(
+    cursor: WritableCursor,
+    files: List<QstContainedFile>,
+    version: Version,
+) {
+    // Files are interleaved in chunks. Each chunk has a header, fixed-size data segment and a
+    // trailer.
+    val filesToChunk = files.map { file ->
+        FileToChunk(
+            no = 0,
+            data = file.data.cursor(),
+            name = file.filename,
+        )
+    }
+    var done = 0
+
+    while (done < filesToChunk.size) {
+        for (fileToChunk in filesToChunk) {
+            if (fileToChunk.data.hasBytesLeft()) {
+                if (
+                    !writeFileChunk(
+                        cursor,
+                        fileToChunk.data,
+                        fileToChunk.no++,
+                        fileToChunk.name,
+                        version,
+                    )
+                ) {
+                    done++
+                }
+            }
+        }
+    }
+
+    for (fileToChunk in filesToChunk) {
+        val expectedChunks = ceil(fileToChunk.data.size.toDouble() / CHUNK_BODY_SIZE).toInt()
+
+        check(fileToChunk.no == expectedChunks) {
+            """Expected to write $expectedChunks chunks for file "${
+                fileToChunk.name
+            }" but ${fileToChunk.no} where written."""
+        }
+    }
+}
+
+/**
+ * Returns true if there are bytes left to write in [data], false otherwise.
+ */
+private fun writeFileChunk(
+    cursor: WritableCursor,
+    data: Cursor,
+    chunkNo: Int,
+    name: String,
+    version: Version,
+): Boolean {
+    when (version) {
+        Version.DC,
+        Version.GC,
+        -> {
+            cursor.writeByte(0)
+            cursor.writeUByte(chunkNo.toUByte())
+            cursor.writeShort(0)
+        }
+
+        Version.PC -> {
+            cursor.writeByte(0)
+            cursor.writeByte(0)
+            cursor.writeByte(0)
+            cursor.writeUByte(chunkNo.toUByte())
+        }
+
+        Version.BB -> {
+            cursor.writeByte(28)
+            cursor.writeByte(4)
+            cursor.writeByte(19)
+            cursor.writeByte(0)
+            cursor.writeInt(chunkNo)
+        }
+    }
+
+    cursor.writeStringAscii(name, 16)
+
+    val size = min(CHUNK_BODY_SIZE, data.bytesLeft)
+    cursor.writeCursor(data.take(size))
+
+    // Padding.
+    repeat(CHUNK_BODY_SIZE - size) {
+        cursor.writeByte(0)
+    }
+
+    cursor.writeInt(size)
+
+    if (version == Version.BB) {
+        cursor.writeInt(0)
+    }
+
+    return data.hasBytesLeft()
+}

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

@@ -1,16 +1,15 @@
 package world.phantasmal.lib.fileFormats.quest
 
 import mu.KotlinLogging
-import world.phantasmal.core.PwResult
+import world.phantasmal.core.*
-import world.phantasmal.core.PwResultBuilder
-import world.phantasmal.core.Severity
-import world.phantasmal.core.Success
 import world.phantasmal.lib.Episode
 import world.phantasmal.lib.asm.BytecodeIr
 import world.phantasmal.lib.asm.InstructionSegment
 import world.phantasmal.lib.asm.OP_SET_EPISODE
 import world.phantasmal.lib.asm.dataFlowAnalysis.ControlFlowGraph
 import world.phantasmal.lib.asm.dataFlowAnalysis.getMapDesignations
+import world.phantasmal.lib.buffer.Buffer
+import world.phantasmal.lib.compression.prs.prsCompress
 import world.phantasmal.lib.compression.prs.prsDecompress
 import world.phantasmal.lib.cursor.Cursor
 import world.phantasmal.lib.cursor.cursor
@@ -233,3 +232,56 @@ private fun extractScriptEntryPoints(
 
     return entryPoints
 }
+
+/**
+ * Creates a .qst file from [quest].
+ */
+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) },
+        events = quest.events,
+        unknowns = quest.datUnknowns,
+    ))
+
+    val binFormat = when (version) {
+        Version.DC, Version.GC -> BinFormat.DC_GC
+        Version.PC -> BinFormat.PC
+        Version.BB -> BinFormat.BB
+    }
+
+    val (bytecode, labelOffsets) = writeBytecode(quest.bytecodeIr, binFormat == BinFormat.DC_GC)
+
+    val bin = writeBin(BinFile(
+        binFormat,
+        quest.id,
+        quest.language,
+        quest.name,
+        quest.shortDescription,
+        quest.longDescription,
+        bytecode,
+        labelOffsets,
+        quest.shopItems,
+    ))
+
+    val baseFilename = (filenameBase(filename) ?: filename).take(11)
+
+    return writeQst(QstContent(
+        version,
+        online,
+        files = listOf(
+            QstContainedFile(
+                id = quest.id,
+                filename = "$baseFilename.dat",
+                questName = quest.name,
+                data = prsCompress(dat.cursor()).buffer(),
+            ),
+            QstContainedFile(
+                id = quest.id,
+                filename = "$baseFilename.bin",
+                questName = quest.name,
+                data = prsCompress(bin.cursor()).buffer(),
+            ),
+        ),
+    ))
+}

lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/BinTests.kt

@@ -1,6 +1,8 @@
 package world.phantasmal.lib.fileFormats.quest
 
+import world.phantasmal.lib.cursor.cursor
 import world.phantasmal.lib.test.LibTestSuite
+import world.phantasmal.lib.test.assertDeepEquals
 import world.phantasmal.lib.test.readFile
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -20,4 +22,18 @@ class BinTests : LibTestSuite() {
             bin.longDescription
         )
     }
+
+    @Test
+    fun parse_and_write_towards_the_future() = parseAndWriteQuest("/quest118_e_decompressed.bin")
+
+    @Test
+    fun parse_and_write_seat_of_the_heart() = parseAndWriteQuest("/quest27_e_decompressed.bin")
+
+    private fun parseAndWriteQuest(file: String) = asyncTest {
+        val origBin = readFile(file)
+        val newBin = writeBin(parseBin(origBin)).cursor()
+        origBin.seekStart(0)
+
+        assertDeepEquals(origBin, newBin)
+    }
 }

lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/DatTests.kt

@@ -1,6 +1,8 @@
 package world.phantasmal.lib.fileFormats.quest
 
+import world.phantasmal.lib.cursor.cursor
 import world.phantasmal.lib.test.LibTestSuite
+import world.phantasmal.lib.test.assertDeepEquals
 import world.phantasmal.lib.test.readFile
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -13,4 +15,49 @@ class DatTests : LibTestSuite() {
         assertEquals(277, dat.objs.size)
         assertEquals(216, dat.npcs.size)
     }
+
+    /**
+     * Parse a file, convert the resulting structure to DAT again and check whether the end result
+     * is byte-for-byte equal to the original.
+     */
+    @Test
+    fun parse_dat_and_write_dat() = asyncTest {
+        val origDat = readFile("/quest118_e_decompressed.dat")
+        val newDat = writeDat(parseDat(origDat)).cursor()
+        origDat.seekStart(0)
+
+        assertDeepEquals(origDat, newDat)
+    }
+
+    /**
+     * Parse a file, modify the resulting structure, convert it to DAT again and check whether the
+     * end result is byte-for-byte equal to the original except for the bytes that should be
+     * changed.
+     */
+    @Test
+    fun parse_modify_write_dat() = asyncTest {
+        val origDat = readFile("/quest118_e_decompressed.dat")
+        val parsedDat = parseDat(origDat)
+        origDat.seekStart(0)
+
+        parsedDat.objs[9].data.setFloat(16, 13f)
+        parsedDat.objs[9].data.setFloat(20, 17f)
+        parsedDat.objs[9].data.setFloat(24, 19f)
+
+        val newDat = writeDat(parsedDat).cursor()
+
+        assertEquals(origDat.size, newDat.size)
+
+        while (origDat.hasBytesLeft()) {
+            if (origDat.position == 16 + 9 * OBJECT_BYTE_SIZE + 16) {
+                origDat.seek(12)
+
+                assertEquals(13f, newDat.float())
+                assertEquals(17f, newDat.float())
+                assertEquals(19f, newDat.float())
+            } else {
+                assertEquals(origDat.byte(), newDat.byte())
+            }
+        }
+    }
 }

lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/QuestTests.kt

@@ -3,7 +3,10 @@ package world.phantasmal.lib.fileFormats.quest
 import world.phantasmal.core.Success
 import world.phantasmal.lib.Episode
 import world.phantasmal.lib.asm.*
+import world.phantasmal.lib.cursor.Cursor
+import world.phantasmal.lib.cursor.cursor
 import world.phantasmal.lib.test.LibTestSuite
+import world.phantasmal.lib.test.assertDeepEquals
 import world.phantasmal.lib.test.readFile
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -17,8 +20,23 @@ class QuestTests : LibTestSuite() {
         assertTrue(result is Success)
         assertTrue(result.problems.isEmpty())
 
-        val quest = result.value
+        testTowardsTheFutureParseResult(result.value)
+    }
 
+    @Test
+    fun parseQstToQuest_with_towards_the_future() = asyncTest {
+        val result = parseQstToQuest(readFile("/quest118_e.qst"))
+
+        assertTrue(result is Success)
+        assertTrue(result.problems.isEmpty())
+
+        assertEquals(Version.BB, result.value.version)
+        assertTrue(result.value.online)
+
+        testTowardsTheFutureParseResult(result.value.quest)
+    }
+
+    private fun testTowardsTheFutureParseResult(quest: Quest) {
         assertEquals("Towards the Future", quest.name)
         assertEquals("Challenge the\nnew simulator.", quest.shortDescription)
         assertEquals(
@@ -27,9 +45,8 @@ class QuestTests : LibTestSuite() {
         )
         assertEquals(Episode.I, quest.episode)
         assertEquals(277, quest.objects.size)
-        // TODO: Test objects.
+        assertEquals(ObjectType.MenuActivation, quest.objects[0].type)
-//        assertEquals(ObjectType.MenuActivation, quest.objects[0])
+        assertEquals(ObjectType.PlayerSet, quest.objects[4].type)
-//        assertEquals(ObjectType.PlayerSet, quest.objects[4])
         assertEquals(216, quest.npcs.size)
         assertEquals(10, quest.mapDesignations.size)
         assertEquals(0, quest.mapDesignations[0])
@@ -71,4 +88,73 @@ class QuestTests : LibTestSuite() {
         assertEquals(200, seg4.instructions[0].args[1].value)
         assertEquals(201, seg4.instructions[0].args[2].value)
     }
+
+    @Test
+    fun round_trip_test_with_towards_the_future() = asyncTest {
+        val filename = "quest118_e.qst"
+        roundTripTest(filename, readFile("/$filename"))
+    }
+
+    @Test
+    fun round_trip_test_with_seat_of_the_heart() = asyncTest {
+        val filename = "quest27_e.qst"
+        roundTripTest(filename, readFile("/$filename"))
+    }
+
+    @Test
+    fun round_trip_test_with_lost_head_sword_gc() = asyncTest {
+        val filename = "lost_heat_sword_gc.qst"
+        roundTripTest(filename, readFile("/$filename"))
+    }
+
+    /**
+     * Round-trip tests.
+     * Parse a QST file, write the resulting Quest object to QST again, then parse that again.
+     * Then check whether the two Quest objects are deeply equal.
+     */
+    private fun roundTripTest(filename: String, contents: Cursor) {
+        val origQuestData = parseQstToQuest(contents).unwrap()
+        val origQuest = origQuestData.quest
+        val newQuestData = parseQstToQuest(
+            writeQuestToQst(
+                origQuest,
+                filename,
+                origQuestData.version,
+                origQuestData.online,
+            ).cursor()
+        ).unwrap()
+        val newQuest = newQuestData.quest
+
+        assertEquals(origQuestData.version, newQuestData.version)
+        assertEquals(origQuestData.online, newQuestData.online)
+
+        assertEquals(origQuest.name, newQuest.name)
+        assertEquals(origQuest.shortDescription, newQuest.shortDescription)
+        assertEquals(origQuest.longDescription, newQuest.longDescription)
+        assertEquals(origQuest.episode, newQuest.episode)
+        assertEquals(origQuest.objects.size, newQuest.objects.size)
+
+        for (i in origQuest.objects.indices) {
+            val origObj = origQuest.objects[i]
+            val newObj = newQuest.objects[i]
+            assertEquals(origObj.areaId, newObj.areaId)
+            assertEquals(origObj.sectionId, newObj.sectionId)
+            assertEquals(origObj.position, newObj.position)
+            assertEquals(origObj.type, newObj.type)
+        }
+
+        assertEquals(origQuest.npcs.size, newQuest.npcs.size)
+
+        for (i in origQuest.npcs.indices) {
+            val origNpc = origQuest.npcs[i]
+            val newNpc = newQuest.npcs[i]
+            assertEquals(origNpc.areaId, newNpc.areaId)
+            assertEquals(origNpc.sectionId, newNpc.sectionId)
+            assertEquals(origNpc.position, newNpc.position)
+            assertEquals(origNpc.type, newNpc.type)
+        }
+
+        assertDeepEquals(origQuest.mapDesignations, newQuest.mapDesignations, ::assertEquals)
+        assertDeepEquals(origQuest.bytecodeIr, newQuest.bytecodeIr)
+    }
 }

lib/src/commonTest/kotlin/world/phantasmal/lib/test/TestUtils.kt

@@ -22,17 +22,36 @@ fun toInstructions(assembly: String): List<InstructionSegment> {
 fun <T> assertDeepEquals(expected: List<T>, actual: List<T>, assertDeepEquals: (T, T) -> Unit) {
     assertEquals(expected.size, actual.size)
 
-    for (i in actual.indices) {
+    for (i in expected.indices) {
         assertDeepEquals(expected[i], actual[i])
     }
 }
 
-fun assertDeepEquals(expected: Buffer, actual: Buffer): Boolean {
+fun <K, V> assertDeepEquals(
-    if (expected.size != actual.size) return false
+    expected: Map<K, V>,
+    actual: Map<K, V>,
+    assertDeepEquals: (V, V) -> Unit,
+) {
+    assertEquals(expected.size, actual.size)
+
+    for ((key, value) in expected) {
+        assertTrue(key in actual)
+        assertDeepEquals(value, actual[key]!!)
+    }
+}
+
+fun assertDeepEquals(expected: Buffer, actual: Buffer) {
+    assertEquals(expected.size, actual.size)
 
     for (i in 0 until expected.size) {
-        if (expected.getByte(i) != actual.getByte(i)) return false
+        assertEquals(expected.getByte(i), actual.getByte(i))
+    }
+}
+
+fun assertDeepEquals(expected: Cursor, actual: Cursor) {
+    assertEquals(expected.size, actual.size)
+
+    while (expected.hasBytesLeft()) {
+        assertEquals(expected.byte(), actual.byte())
     }
-
-    return true
 }

lib/src/jsMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt

@@ -157,6 +157,9 @@ actual class Buffer private constructor(
         return self.btoa(str)
     }
 
+    actual fun copy(): Buffer =
+        Buffer(arrayBuffer.slice(0, size), size, endianness)
+
     /**
      * Checks whether we can read [size] bytes at [offset].
      */

lib/src/jvmMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt

@@ -154,6 +154,9 @@ actual class Buffer private constructor(
         return str
     }
 
+    actual fun copy(): Buffer =
+        fromByteArray(buf.array().copyOf(), endianness)
+
     /**
      * Checks whether we can read [size] bytes at [offset].
      */

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

@@ -1,14 +1,16 @@
 package world.phantasmal.web.questEditor.controllers
 
+import kotlinx.browser.document
 import mu.KotlinLogging
+import org.w3c.dom.HTMLAnchorElement
+import org.w3c.dom.url.URL
+import org.w3c.files.Blob
 import org.w3c.files.File
 import world.phantasmal.core.*
 import world.phantasmal.lib.Endianness
-import world.phantasmal.lib.cursor.cursor
 import world.phantasmal.lib.Episode
-import world.phantasmal.lib.fileFormats.quest.Quest
+import world.phantasmal.lib.cursor.cursor
-import world.phantasmal.lib.fileFormats.quest.parseBinDatToQuest
+import world.phantasmal.lib.fileFormats.quest.*
-import world.phantasmal.lib.fileFormats.quest.parseQstToQuest
 import world.phantasmal.observable.value.Val
 import world.phantasmal.observable.value.map
 import world.phantasmal.observable.value.mutableVal
@@ -19,8 +21,10 @@ import world.phantasmal.web.questEditor.loading.QuestLoader
 import world.phantasmal.web.questEditor.models.AreaModel
 import world.phantasmal.web.questEditor.stores.AreaStore
 import world.phantasmal.web.questEditor.stores.QuestEditorStore
+import world.phantasmal.web.questEditor.stores.convertQuestFromModel
 import world.phantasmal.web.questEditor.stores.convertQuestToModel
 import world.phantasmal.webui.controllers.Controller
+import world.phantasmal.webui.obj
 import world.phantasmal.webui.readFile
 import world.phantasmal.webui.selectFiles
 
@@ -36,6 +40,9 @@ class QuestEditorToolbarController(
 ) : Controller() {
     private val _resultDialogVisible = mutableVal(false)
     private val _result = mutableVal<PwResult<*>?>(null)
+    private val _saveAsDialogVisible = mutableVal(false)
+    private val _filename = mutableVal("")
+    private val _version = mutableVal(Version.BB)
 
     // Result
 
@@ -44,6 +51,13 @@ class QuestEditorToolbarController(
 
     val openFileAccept = ".bin, .dat, .qst"
 
+    // Save as
+
+    val saveAsEnabled: Val<Boolean> = questEditorStore.currentQuest.isNotNull()
+    val saveAsDialogVisible: Val<Boolean> = _saveAsDialogVisible
+    val filename: Val<String> = _filename
+    val version: Val<Version> = _version
+
     // Undo
 
     val undoTooltip: Val<String> = questEditorStore.firstUndo.map { action ->
@@ -87,6 +101,10 @@ class QuestEditorToolbarController(
                 openFiles(selectFiles(accept = openFileAccept, multiple = true))
             },
 
+            uiStore.onGlobalKeyDown(PwToolType.QuestEditor, "Ctrl-Shift-S") {
+                saveAs()
+            },
+
             uiStore.onGlobalKeyDown(PwToolType.QuestEditor, "Ctrl-Z") {
                 undo()
             },
@@ -102,14 +120,12 @@ class QuestEditorToolbarController(
     }
 
     suspend fun createNewQuest(episode: Episode) {
-        // TODO: Set filename and version.
+        setFilename("")
-        questEditorStore.setCurrentQuest(
+        setVersion(Version.BB)
-            convertQuestToModel(questLoader.loadDefaultQuest(episode), areaStore::getVariant)
+        setCurrentQuest(questLoader.loadDefaultQuest(episode))
-        )
     }
 
     suspend fun openFiles(files: List<File>) {
-        // TODO: Set filename and version.
         try {
             if (files.isEmpty()) return
 
@@ -120,6 +136,8 @@ class QuestEditorToolbarController(
                 setResult(parseResult)
 
                 if (parseResult is Success) {
+                    setFilename(filenameBase(qst.name) ?: qst.name)
+                    setVersion(parseResult.value.version)
                     setCurrentQuest(parseResult.value.quest)
                 }
             } else {
@@ -141,6 +159,8 @@ class QuestEditorToolbarController(
                 setResult(parseResult)
 
                 if (parseResult is Success) {
+                    setFilename(filenameBase(bin.name) ?: filenameBase(dat.name) ?: bin.name)
+                    setVersion(Version.BB)
                     setCurrentQuest(parseResult.value)
                 }
             }
@@ -153,6 +173,64 @@ class QuestEditorToolbarController(
         }
     }
 
+    fun saveAs() {
+        if (saveAsEnabled.value) {
+            _saveAsDialogVisible.value = true
+        }
+    }
+
+    fun setFilename(filename: String) {
+        _filename.value = filename
+    }
+
+    fun setVersion(version: Version) {
+        _version.value = version
+    }
+
+    fun saveAsDialogSave() {
+        val quest = questEditorStore.currentQuest.value ?: return
+        var filename = filename.value.trim()
+
+        val buffer = writeQuestToQst(
+            convertQuestFromModel(quest),
+            filename,
+            version.value,
+            online = true,
+        )
+
+        if (!filename.endsWith(".qst")) {
+            filename += ".qst"
+        }
+
+        val a = document.createElement("a") as HTMLAnchorElement
+        val url = URL.createObjectURL(
+            Blob(
+                arrayOf(buffer.arrayBuffer),
+                obj { type = "application/octet-stream" },
+            )
+        )
+        try {
+            a.href = url
+            a.download = filename
+            document.body?.appendChild(a)
+            a.click()
+        } catch (e: Exception) {
+            URL.revokeObjectURL(url)
+            document.body?.removeChild(a)
+            throw e
+        }
+
+        dismissSaveAsDialog()
+    }
+
+    fun dismissSaveAsDialog() {
+        _saveAsDialogVisible.value = false
+    }
+
+    fun dismissResultDialog() {
+        _resultDialogVisible.value = false
+    }
+
     fun undo() {
         questEditorStore.undo()
     }

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

@@ -1,6 +1,7 @@
 package world.phantasmal.web.questEditor.stores
 
 import world.phantasmal.lib.Episode
+import world.phantasmal.lib.fileFormats.quest.DatEvent
 import world.phantasmal.lib.fileFormats.quest.DatEventAction
 import world.phantasmal.lib.fileFormats.quest.Quest
 import world.phantasmal.web.questEditor.models.*
@@ -8,8 +9,8 @@ import world.phantasmal.web.questEditor.models.*
 fun convertQuestToModel(
     quest: Quest,
     getVariant: (Episode, areaId: Int, variantId: Int) -> AreaVariantModel?,
-): QuestModel {
+): QuestModel =
-    return QuestModel(
+    QuestModel(
         quest.id,
         quest.language,
         quest.name,
@@ -27,22 +28,22 @@ fun convertQuestToModel(
                 event.wave.toInt(),
                 event.delay.toInt(),
                 event.unknown.toInt(),
-                event.actions.mapTo(mutableListOf()) {
+                event.actions.mapTo(mutableListOf()) { action ->
-                    when (it) {
+                    when (action) {
                         is DatEventAction.SpawnNpcs ->
                             QuestEventActionModel.SpawnNpcs(
-                                it.sectionId.toInt(),
+                                action.sectionId.toInt(),
-                                it.appearFlag.toInt()
+                                action.appearFlag.toInt()
                             )
 
                         is DatEventAction.Unlock ->
-                            QuestEventActionModel.Door.Unlock(it.doorId.toInt())
+                            QuestEventActionModel.Door.Unlock(action.doorId.toInt())
 
                         is DatEventAction.Lock ->
-                            QuestEventActionModel.Door.Lock(it.doorId.toInt())
+                            QuestEventActionModel.Door.Lock(action.doorId.toInt())
 
                         is DatEventAction.TriggerEvent ->
-                            QuestEventActionModel.TriggerEvent(it.eventId)
+                            QuestEventActionModel.TriggerEvent(action.eventId)
                     }
                 }
             )
@@ -52,4 +53,51 @@ fun convertQuestToModel(
         quest.shopItems,
         getVariant,
     )
-}
+
+/**
+ * The returned [Quest] object will reference parts of [quest], so some changes to [quest] will be
+ * reflected in the returned object.
+ */
+fun convertQuestFromModel(quest: QuestModel): Quest =
+    Quest(
+        quest.id.value,
+        quest.language.value,
+        quest.name.value,
+        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 ->
+            DatEvent(
+                event.id.value,
+                event.sectionId.value.toShort(),
+                event.wave.value.id.toShort(),
+                event.delay.value.toShort(),
+                event.actions.value.map { action ->
+                    when (action) {
+                        is QuestEventActionModel.SpawnNpcs ->
+                            DatEventAction.SpawnNpcs(
+                                action.sectionId.value.toShort(),
+                                action.appearFlag.value.toShort(),
+                            )
+
+                        is QuestEventActionModel.Door.Unlock ->
+                            DatEventAction.Unlock(action.doorId.value.toShort())
+
+                        is QuestEventActionModel.Door.Lock ->
+                            DatEventAction.Lock(action.doorId.value.toShort())
+
+                        is QuestEventActionModel.TriggerEvent ->
+                            DatEventAction.TriggerEvent(action.eventId.value)
+                    }
+                },
+                event.areaId,
+                event.unknown.toShort(),
+            )
+        },
+        quest.datUnknowns,
+        quest.bytecodeIr,
+        quest.shopItems,
+        quest.mapDesignations.value,
+    )

web/src/main/kotlin/world/phantasmal/web/questEditor/widgets/QuestEditorToolbarWidget.kt

@@ -2,7 +2,9 @@ package world.phantasmal.web.questEditor.widgets
 
 import kotlinx.coroutines.launch
 import org.w3c.dom.Node
+import org.w3c.dom.events.KeyboardEvent
 import world.phantasmal.lib.Episode
+import world.phantasmal.lib.fileFormats.quest.Version
 import world.phantasmal.observable.value.list.listVal
 import world.phantasmal.observable.value.value
 import world.phantasmal.web.questEditor.controllers.QuestEditorToolbarController
@@ -32,6 +34,13 @@ class QuestEditorToolbarWidget(private val ctrl: QuestEditorToolbarController) :
                         multiple = true,
                         filesSelected = { files -> scope.launch { ctrl.openFiles(files) } },
                     ),
+                    Button(
+                        text = "Save as...",
+                        iconLeft = Icon.Save,
+                        enabled = ctrl.saveAsEnabled,
+                        tooltip = value("Save this quest to a new file (Ctrl-Shift-S)"),
+                        onClick = { ctrl.saveAs() },
+                    ),
                     Button(
                         text = "Undo",
                         iconLeft = Icon.Undo,
@@ -55,5 +64,83 @@ class QuestEditorToolbarWidget(private val ctrl: QuestEditorToolbarController) :
                     ),
                 )
             ))
+
+            val saveAsDialog = addDisposable(Dialog(
+                visible = ctrl.saveAsDialogVisible,
+                title = value("Save As"),
+                content = {
+                    div {
+                        className = "pw-quest-editor-toolbar-save-as"
+
+                        val filenameInput = TextInput(
+                            label = "File name:",
+                            value = ctrl.filename,
+                            onChange = ctrl::setFilename,
+                        )
+                        addWidget(filenameInput.label!!)
+                        addWidget(filenameInput)
+
+                        val versionSelect = Select(
+                            label = "Version:",
+                            items = listVal(Version.GC, Version.BB),
+                            selected = ctrl.version,
+                            itemToString = {
+                                when (it) {
+                                    Version.DC -> "Dreamcast"
+                                    Version.GC -> "GameCube"
+                                    Version.PC -> "PC"
+                                    Version.BB -> "BlueBurst"
+                                }
+                            },
+                            onSelect = ctrl::setVersion,
+                        )
+                        addWidget(versionSelect.label!!)
+                        addWidget(versionSelect)
+                    }
+                },
+                footer = {
+                    addWidget(Button(
+                        text = "Save",
+                        onClick = { ctrl.saveAsDialogSave() },
+                    ))
+                    addWidget(Button(
+                        text = "Cancel",
+                        onClick = { ctrl.dismissSaveAsDialog() },
+                    ))
+                },
+                onDismiss = ctrl::dismissSaveAsDialog,
+            ))
+
+            saveAsDialog.dialogElement.addEventListener("keydown", { e ->
+                if ((e as KeyboardEvent).key == "Enter") {
+                    ctrl.saveAsDialogSave()
+                }
+            })
+
+            addDisposable(ResultDialog(
+                visible = ctrl.resultDialogVisible,
+                result = ctrl.result,
+                onDismiss = ctrl::dismissResultDialog,
+            ))
         }
+
+    companion object {
+        init {
+            @Suppress("CssUnusedSymbol")
+            // language=css
+            style("""
+                .pw-quest-editor-toolbar-save-as {
+                    display: grid;
+                    grid-template-columns: 100px max-content;
+                    grid-column-gap: 4px;
+                    grid-row-gap: 4px;
+                    align-items: center;
+                }
+
+                .pw-quest-editor-toolbar-save-as .pw-input {
+                    margin: 1px;
+                }
+            """.trimIndent())
+        }
+    }
 }

webui/src/main/kotlin/world/phantasmal/webui/widgets/Dialog.kt

@@ -8,6 +8,7 @@ import org.w3c.dom.events.KeyboardEvent
 import org.w3c.dom.get
 import org.w3c.dom.pointerevents.PointerEvent
 import world.phantasmal.observable.value.Val
+import world.phantasmal.observable.value.emptyStringVal
 import world.phantasmal.observable.value.isEmpty
 import world.phantasmal.observable.value.trueVal
 import world.phantasmal.webui.dom.div
@@ -19,14 +20,24 @@ open class Dialog(
     visible: Val<Boolean> = trueVal(),
     enabled: Val<Boolean> = trueVal(),
     private val title: Val<String>,
-    private val description: Val<String>,
+    private val description: Val<String> = emptyStringVal(),
-    private val content: Val<Node>,
+    private val content: Node.() -> Unit = {},
+    private val footer: Node.() -> Unit = {},
     protected val onDismiss: () -> Unit = {},
 ) : Widget(visible, enabled) {
     private var x = 0
     private var y = 0
 
-    private var dialogElement = dom {
+    private var overlayElement = dom {
+        div {
+            className = "pw-dialog-modal-overlay"
+            tabIndex = -1
+
+            addEventListener("focus", { this@Dialog.focus() })
+        }
+    }
+
+    val dialogElement = dom {
         section {
             className = "pw-dialog"
             tabIndex = 0
@@ -51,28 +62,15 @@ open class Dialog(
             }
             div {
                 className = "pw-dialog-body"
-
+                content()
-                observe(content) {
-                    textContent = ""
-                    append(it)
-                }
             }
             div {
                 className = "pw-dialog-footer"
-                addFooterContent(this)
+                footer()
             }
         }
     }
 
-    private var overlayElement = dom {
-        div {
-            className = "pw-dialog-modal-overlay"
-            tabIndex = -1
-
-            addEventListener("focus", { this@Dialog.focus() })
-        }
-    }
-
     init {
         observe(visible) {
             if (it) {
@@ -98,10 +96,6 @@ open class Dialog(
         super.internalDispose()
     }
 
-    protected open fun addFooterContent(footer: Node) {
-        // Do nothing.
-    }
-
     private fun onPointerMove(movedX: Int, movedY: Int, e: PointerEvent): Boolean {
         e.preventDefault()
         setPosition(this.x + movedX, this.y + movedY)

webui/src/main/kotlin/world/phantasmal/webui/widgets/ResultDialog.kt

@@ -4,38 +4,64 @@ import org.w3c.dom.Node
 import world.phantasmal.core.Failure
 import world.phantasmal.core.PwResult
 import world.phantasmal.observable.value.Val
+import world.phantasmal.observable.value.emptyStringVal
 import world.phantasmal.observable.value.trueVal
 import world.phantasmal.webui.dom.div
-import world.phantasmal.webui.dom.dom
 import world.phantasmal.webui.dom.li
 import world.phantasmal.webui.dom.ul
 
 /**
  * Shows the details of a result if the result failed or succeeded with problems. Shows a "Dismiss"
- * button in the footer which triggers [onDismiss].
+ * button in the footer which triggers onDismiss.
  */
 class ResultDialog(
     visible: Val<Boolean> = trueVal(),
     enabled: Val<Boolean> = trueVal(),
     result: Val<PwResult<*>?>,
-    message: Val<String>,
+    message: Val<String> = emptyStringVal(),
     onDismiss: () -> Unit = {},
-) : Dialog(
+) : Widget(visible, enabled) {
-    visible,
+    private val dialog = addDisposable(
-    enabled,
+        Dialog(
-    title = result.map(::resultToTitle),
-    description = message,
-    content = result.map(::resultToContent),
-    onDismiss,
-) {
-    override fun addFooterContent(footer: Node) {
-        footer.addChild(Button(
             visible,
             enabled,
-            text = "Dismiss",
+            title = result.map { result ->
-            onClick = { onDismiss() }
+                when {
-        ))
+                    result is Failure -> "Error"
-    }
+                    result?.problems?.isNotEmpty() == true -> "Problems"
+                    else -> ""
+                }
+            },
+            description = message,
+            content = {
+                div {
+                    className = "pw-result-dialog-result"
+
+                    ul {
+                        className = "pw-result-dialog-problems"
+                        hidden(result.isNull())
+
+                        bindChildrenTo(result.map {
+                            it?.problems ?: emptyList()
+                        }) { problem, _ ->
+                            li { textContent = problem.uiMessage }
+                        }
+                    }
+                }
+            },
+            footer = {
+                addChild(Button(
+                    visible,
+                    enabled,
+                    text = "Dismiss",
+                    onClick = { onDismiss() }
+                ))
+            },
+            onDismiss = onDismiss,
+        )
+    )
+
+    override fun Node.createElement() = dialog.element
 
     companion object {
         init {
@@ -53,27 +79,3 @@ class ResultDialog(
         }
     }
 }
-
-private fun resultToTitle(result: PwResult<*>?): String =
-    when {
-        result is Failure -> "Error"
-        result?.problems?.isNotEmpty() == true -> "Problems"
-        else -> ""
-    }
-
-private fun resultToContent(result: PwResult<*>?): Node =
-    dom {
-        div {
-            className = "pw-result-dialog-result"
-
-            result?.let {
-                ul {
-                    className = "pw-result-dialog-problems"
-
-                    result.problems.map {
-                        li { textContent = it.uiMessage }
-                    }
-                }
-            }
-        }
-    }