Fixed various bugs.

lib/assetsGeneration/assembly/opcodes.schema.json

@@ -96,8 +96,8 @@
             "enum": [
                 "any",
                 "byte",
-                "word",
+                "short",
-                "dword",
+                "int",
                 "float",
                 "label",
                 "instruction_label",

lib/build.gradle.kts

@@ -151,8 +151,8 @@ fun paramsToCode(params: List<Map<String, Any>>, indent: Int): String {
         val type = when (param["type"]) {
             "any" -> "AnyType()"
             "byte" -> "ByteType"
-            "word" -> "WordType"
+            "short" -> "ShortType"
-            "dword" -> "DWordType"
+            "int" -> "IntType"
             "float" -> "FloatType"
             "label" -> "LabelType()"
             "instruction_label" -> "ILabelType"

lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/Assembly.kt

@@ -435,7 +435,7 @@ private class Assembler(private val assembly: List<String>, private val manualSt
                                 )
                             }
 
-                            is WordType,
+                            is ShortType,
                             is LabelType,
                             is ILabelType,
                             is DLabelType,
@@ -451,7 +451,7 @@ private class Assembler(private val assembly: List<String>, private val manualSt
                                 )
                             }
 
-                            is DWordType -> {
+                            is IntType -> {
                                 addInstruction(
                                     OP_ARG_PUSHL,
                                     listOf(arg),
@@ -554,7 +554,7 @@ private class Assembler(private val assembly: List<String>, private val manualSt
                                 match = true
                                 parseInt(1, token, argAndTokens)
                             }
-                            is WordType,
+                            is ShortType,
                             is LabelType,
                             is ILabelType,
                             is DLabelType,
@@ -564,7 +564,7 @@ private class Assembler(private val assembly: List<String>, private val manualSt
                                 match = true
                                 parseInt(2, token, argAndTokens)
                             }
-                            is DWordType -> {
+                            is IntType -> {
                                 match = true
                                 parseInt(4, token, argAndTokens)
                             }
@@ -613,8 +613,8 @@ private class Assembler(private val assembly: List<String>, private val manualSt
 
                     val typeStr: String? = when (param.type) {
                         is ByteType -> "an 8-bit integer"
-                        is WordType -> "a 16-bit integer"
+                        is ShortType -> "a 16-bit integer"
-                        is DWordType -> "a 32-bit integer"
+                        is IntType -> "a 32-bit integer"
                         is FloatType -> "a float"
                         is LabelType -> "a label"
 

lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/Instructions.kt

@@ -58,14 +58,14 @@ fun instructionSize(instruction: Instruction, dcGcFormat: Boolean): Int {
             is RegTupRefType,
             -> 1
 
-            is WordType,
+            is ShortType,
             is LabelType,
             is ILabelType,
             is DLabelType,
             is SLabelType,
             -> 2
 
-            is DWordType,
+            is IntType,
             is FloatType,
             -> 4
 

lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/Opcode.kt

@@ -29,12 +29,12 @@ object ByteType : ValueType()
 /**
  * 16-Bit integer.
  */
-object WordType : ValueType()
+object ShortType : ValueType()
 
 /**
  * 32-Bit integer.
  */
-object DWordType : ValueType()
+object IntType : ValueType()
 
 /**
  * 32-Bit floating point number.
@@ -61,16 +61,16 @@ object DLabelType : LabelType()
  */
 object SLabelType : LabelType()
 
-/**
- * String of arbitrary size.
- */
-object StringType : LabelType()
-
 /**
  * Arbitrary amount of instruction labels.
  */
 object ILabelVarType : LabelType()
 
+/**
+ * String of arbitrary size.
+ */
+object StringType : ValueType()
+
 /**
  * Purely abstract super type of all reference types.
  */
@@ -97,13 +97,6 @@ object RegRefVarType : RefType()
  */
 object PointerType : AnyType()
 
-const val MIN_SIGNED_DWORD_VALUE = Int.MIN_VALUE
-const val MAX_SIGNED_DWORD_VALUE = Int.MAX_VALUE
-const val MIN_UNSIGNED_DWORD_VALUE = UInt.MIN_VALUE
-const val MAX_UNSIGNED_DWORD_VALUE = UInt.MAX_VALUE
-const val MIN_DWORD_VALUE = MIN_SIGNED_DWORD_VALUE
-const val MAX_DWORD_VALUE = MAX_UNSIGNED_DWORD_VALUE
-
 enum class ParamAccess {
     Read,
     Write,

lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/dataFlowAnalysis/GetRegisterValue.kt

@@ -26,7 +26,7 @@ fun getRegisterValue(cfg: ControlFlowGraph, instruction: Instruction, register:
 }
 
 private class RegisterValueFinder {
-    var iterations = 0
+    private var iterations = 0
 
     fun find(
         path: MutableSet<BasicBlock>,

lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/dataFlowAnalysis/GetStackValue.kt

@@ -22,7 +22,7 @@ fun getStackValue(cfg: ControlFlowGraph, instruction: Instruction, position: Int
 }
 
 private class StackValueFinder {
-    var iterations = 0
+    private var iterations = 0
 
     fun find(
         path: MutableSet<BasicBlock>,
@@ -54,7 +54,6 @@ private class StackValueFinder {
                         return getRegisterValue(cfg, instruction, args[0].value as Int)
                     } else {
                         pos--
-                        break
                     }
                 }
 
@@ -66,7 +65,6 @@ private class StackValueFinder {
                         return ValueSet.of(args[0].value as Int)
                     } else {
                         pos--
-                        break
                     }
                 }
 
@@ -78,11 +76,8 @@ private class StackValueFinder {
                         return ValueSet.all()
                     } else {
                         pos--
-                        break
                     }
                 }
-
-                else -> break
             }
         }
 

lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/AbstractWritableCursor.kt

@@ -112,6 +112,17 @@ protected constructor(protected val offset: Int) : WritableCursor {
         return this
     }
 
+    override fun writeByteArray(array: ByteArray): WritableCursor {
+        val len = array.size
+        requireSize(len)
+
+        for (i in 0 until len) {
+            writeByte(array[i])
+        }
+
+        return this
+    }
+
     override fun writeIntArray(array: IntArray): WritableCursor {
         val len = array.size
         requireSize(4 * len)

lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/BufferCursor.kt

@@ -125,6 +125,19 @@ class BufferCursor(
         return array
     }
 
+    override fun byteArray(n: Int): ByteArray {
+        requireSize(n)
+
+        val array = ByteArray(n)
+
+        for (i in 0 until n) {
+            array[i] = buffer.getByte(absolutePosition)
+            position++
+        }
+
+        return array
+    }
+
     override fun intArray(n: Int): IntArray {
         requireSize(4 * n)
 
@@ -214,6 +227,11 @@ class BufferCursor(
         return super.writeUIntArray(array)
     }
 
+    override fun writeByteArray(array: ByteArray): WritableCursor {
+        ensureSpace(array.size)
+        return super.writeByteArray(array)
+    }
+
     override fun writeIntArray(array: IntArray): WritableCursor {
         ensureSpace(4 * array.size)
         return super.writeIntArray(array)

lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/Cursor.kt

@@ -95,6 +95,11 @@ interface Cursor {
      */
     fun uIntArray(n: Int): UIntArray
 
+    /**
+     * Reads [n] signed 8-bit integers and increments position by [n].
+     */
+    fun byteArray(n: Int): ByteArray
+
     /**
      * Reads [n] signed 32-bit integers and increments position by 4[n].
      */

lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/WritableCursor.kt

@@ -64,6 +64,11 @@ interface WritableCursor : Cursor {
      */
     fun writeUIntArray(array: UIntArray): WritableCursor
 
+    /**
+     * Writes an array of signed 8-bit integers and increments position by the array's length.
+     */
+    fun writeByteArray(array: ByteArray): WritableCursor
+
     /**
      * Writes an array of signed 32-bit integers and increments position by four times the array's
      * length.

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

@@ -490,15 +490,23 @@ private fun parseInstructionArguments(
                 is ByteType ->
                     args.add(Arg(cursor.uByte().toInt()))
 
-                is WordType ->
+                is ShortType ->
                     args.add(Arg(cursor.uShort().toInt()))
 
-                is DWordType ->
+                is IntType ->
                     args.add(Arg(cursor.int()))
 
                 is FloatType ->
                     args.add(Arg(cursor.float()))
 
+                // Ensure this case is before the LabelType case because ILabelVarType extends
+                // LabelType.
+                is ILabelVarType -> {
+                    varargCount++
+                    val argSize = cursor.uByte()
+                    args.addAll(cursor.uShortArray(argSize.toInt()).map { Arg(it.toInt()) })
+                }
+
                 is LabelType,
                 is ILabelType,
                 is DLabelType,
@@ -526,12 +534,6 @@ private fun parseInstructionArguments(
                     ))
                 }
 
-                is ILabelVarType -> {
-                    varargCount++
-                    val argSize = cursor.uByte()
-                    args.addAll(cursor.uShortArray(argSize.toInt()).map { Arg(it.toInt()) })
-                }
-
                 is RegRefType,
                 is RegTupRefType,
                 -> {

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

@@ -27,31 +27,31 @@ class DatEntity(
 )
 
 class DatEvent(
-    var id: UInt,
+    var id: Int,
-    var sectionId: UShort,
+    var sectionId: Short,
-    var wave: UShort,
+    var wave: Short,
-    var delay: UShort,
+    var delay: Short,
     val actions: MutableList<DatEventAction>,
     val areaId: Int,
-    val unknown: UShort,
+    val unknown: Short,
 )
 
 sealed class DatEventAction {
     class SpawnNpcs(
-        val sectionId: UShort,
+        val sectionId: Short,
-        val appearFlag: UShort,
+        val appearFlag: Short,
     ) : DatEventAction()
 
     class Unlock(
-        val doorId: UShort,
+        val doorId: Short,
     ) : DatEventAction()
 
     class Lock(
-        val doorId: UShort,
+        val doorId: Short,
     ) : DatEventAction()
 
     class TriggerEvent(
-        val eventId: UInt,
+        val eventId: Int,
     ) : DatEventAction()
 }
 
@@ -60,7 +60,7 @@ class DatUnknown(
     val totalSize: Int,
     val areaId: Int,
     val entitiesSize: Int,
-    val data: UByteArray,
+    val data: ByteArray,
 )
 
 fun parseDat(cursor: Cursor): DatFile {
@@ -95,7 +95,7 @@ fun parseDat(cursor: Cursor): DatFile {
                         totalSize,
                         areaId,
                         entitiesSize,
-                        data = cursor.uByteArray(entitiesSize),
+                        data = cursor.byteArray(entitiesSize),
                     ))
                 }
             }
@@ -139,7 +139,7 @@ private fun parseEvents(cursor: Cursor, areaId: Int, events: MutableList<DatEven
     cursor.seek(3) // Always 0
     val eventType = cursor.byte()
 
-    require(eventType != (0x32).toByte()) {
+    require(eventType.toInt() != 0x32) {
         "Can't parse challenge mode quests yet."
     }
 
@@ -148,12 +148,12 @@ private fun parseEvents(cursor: Cursor, areaId: Int, events: MutableList<DatEven
     cursor.seekStart(16)
 
     repeat(eventCount) {
-        val id = cursor.uInt()
+        val id = cursor.int()
         cursor.seek(4) // Always 0x100
-        val sectionId = cursor.uShort()
+        val sectionId = cursor.short()
-        val wave = cursor.uShort()
+        val wave = cursor.short()
-        val delay = cursor.uShort()
+        val delay = cursor.short()
-        val unknown = cursor.uShort() // "wavesetting"?
+        val unknown = cursor.short() // "wavesetting"?
         val eventActionsOffset = cursor.int()
 
         val actions: MutableList<DatEventAction> =
@@ -182,17 +182,17 @@ private fun parseEvents(cursor: Cursor, areaId: Int, events: MutableList<DatEven
         }
     }
 
-    var lastUByte: UByte = 0xffu
+    var lastByte: Byte = -1
 
     while (actionsCursor.hasBytesLeft()) {
-        lastUByte = actionsCursor.uByte()
+        lastByte = actionsCursor.byte()
 
-        if (lastUByte != (0xffu).toUByte()) {
+        if (lastByte.toInt() != -1) {
             break
         }
     }
 
-    if (lastUByte != (0xffu).toUByte()) {
+    if (lastByte.toInt() != -1) {
         actionsCursor.seek(-1)
     }
 
@@ -209,23 +209,23 @@ private fun parseEventActions(cursor: Cursor): MutableList<DatEventAction> {
 
             EVENT_ACTION_SPAWN_NPCS ->
                 actions.add(DatEventAction.SpawnNpcs(
-                    sectionId = cursor.uShort(),
+                    sectionId = cursor.short(),
-                    appearFlag = cursor.uShort(),
+                    appearFlag = cursor.short(),
                 ))
 
             EVENT_ACTION_UNLOCK ->
                 actions.add(DatEventAction.Unlock(
-                    doorId = cursor.uShort(),
+                    doorId = cursor.short(),
                 ))
 
             EVENT_ACTION_LOCK ->
                 actions.add(DatEventAction.Lock(
-                    doorId = cursor.uShort(),
+                    doorId = cursor.short(),
                 ))
 
             EVENT_ACTION_TRIGGER_EVENT ->
                 actions.add(DatEventAction.TriggerEvent(
-                    eventId = cursor.uInt(),
+                    eventId = cursor.int(),
                 ))
 
             else -> {

lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/CursorTests.kt

@@ -178,6 +178,17 @@ abstract class CursorTests {
         testIntegerArrayRead(4, read, Endianness.Big)
     }
 
+    @Test
+    fun byteArray() {
+        val read: Cursor.(Int) -> IntArray = { n ->
+            val arr = byteArray(n)
+            IntArray(n) { arr[it].toInt() }
+        }
+
+        testIntegerArrayRead(1, read, Endianness.Little)
+        testIntegerArrayRead(1, read, Endianness.Big)
+    }
+
     @Test
     fun intArray() {
         val read: Cursor.(Int) -> IntArray = { n ->
@@ -194,38 +205,29 @@ abstract class CursorTests {
         read: Cursor.(Int) -> IntArray,
         endianness: Endianness,
     ) {
-        // Generate array of the form 1, 2, 0xFF, 4, 5, 6, 7, 8.
+        // Generate array of the form 1, 2, 3, 4, 5, 6, 7, 8.
         val bytes = ByteArray(8 * byteCount)
 
         for (i in 0 until 8) {
-            if (i == 2) {
+            if (endianness == Endianness.Little) {
-                for (j in 0 until byteCount) {
+                bytes[i * byteCount] = (i + 1).toByte()
-                    bytes[i * byteCount + j] = (0xff).toByte()
-                }
             } else {
-                if (endianness == Endianness.Little) {
+                bytes[i * byteCount + byteCount - 1] = (i + 1).toByte()
-                    bytes[i * byteCount] = (i + 1).toByte()
-                } else {
-                    bytes[i * byteCount + byteCount - 1] = (i + 1).toByte()
-                }
             }
         }
 
-        var allOnes = 0
-        repeat(byteCount) { allOnes = ((allOnes shl 8) or 0xff) }
-
         // Test cursor.
         val cursor = createCursor(bytes, endianness)
 
         val array1 = cursor.read(3)
         assertEquals(1, array1[0])
         assertEquals(2, array1[1])
-        assertEquals(allOnes, array1[2])
+        assertEquals(3, array1[2])
         assertEquals(3 * byteCount, cursor.position)
 
         cursor.seekStart(2 * byteCount)
         val array2 = cursor.read(4)
-        assertEquals(allOnes, array2[0])
+        assertEquals(3, array2[0])
         assertEquals(4, array2[1])
         assertEquals(5, array2[2])
         assertEquals(6, array2[3])

lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/WritableCursorTests.kt

@@ -161,6 +161,20 @@ abstract class WritableCursorTests : CursorTests() {
         testIntegerArrayWrite(4, read, write, Endianness.Big)
     }
 
+    @Test
+    fun writeByteArray() {
+        val read: Cursor.(Int) -> IntArray = { n ->
+            val arr = byteArray(n)
+            IntArray(n) { arr[it].toInt() }
+        }
+        val write: WritableCursor.(IntArray) -> Unit = { a ->
+            writeByteArray(ByteArray(a.size) { a[it].toByte() })
+        }
+
+        testIntegerArrayWrite(1, read, write, Endianness.Little)
+        testIntegerArrayWrite(1, read, write, Endianness.Big)
+    }
+
     @Test
     fun writeIntArray() {
         val read: Cursor.(Int) -> IntArray = { n ->

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

@@ -9,7 +9,7 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
-class ByteCode {
+class ByteCodeTests {
     @Test
     fun minimal() {
         val buffer = Buffer.fromByteArray(ubyteArrayOf(

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

@@ -0,0 +1,16 @@
+package world.phantasmal.lib.fileFormats.quest
+
+import world.phantasmal.lib.test.asyncTest
+import world.phantasmal.lib.test.readFile
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class DatTests {
+    @Test
+    fun parse_quest_towards_the_future() = asyncTest {
+        val dat = parseDat(readFile("/quest118_e_decompressed.dat"))
+
+        assertEquals(277, dat.objs.size)
+        assertEquals(216, dat.npcs.size)
+    }
+}

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

@@ -1,6 +1,7 @@
 package world.phantasmal.lib.fileFormats.quest
 
 import world.phantasmal.core.Success
+import world.phantasmal.lib.assembly.*
 import world.phantasmal.lib.test.asyncTest
 import world.phantasmal.lib.test.readFile
 import kotlin.test.Test
@@ -12,7 +13,7 @@ class QuestTests {
     fun parseBinDatToQuest_with_towards_the_future() = asyncTest {
         val result = parseBinDatToQuest(readFile("/quest118_e.bin"), readFile("/quest118_e.dat"))
 
-        assertTrue (result is Success)
+        assertTrue(result is Success)
         assertTrue(result.problems.isEmpty())
 
         val quest = result.value
@@ -40,5 +41,33 @@ class QuestTests {
         assertEquals(4, quest.mapDesignations[8])
         assertEquals(4, quest.mapDesignations[10])
         assertEquals(0, quest.mapDesignations[14])
+
+        val seg1 = quest.byteCodeIr[0]
+        assertTrue(seg1 is InstructionSegment)
+        assertTrue(0 in seg1.labels)
+        assertEquals(OP_SET_EPISODE, seg1.instructions[0].opcode)
+        assertEquals(0, seg1.instructions[0].args[0].value)
+        assertEquals(OP_ARG_PUSHL, seg1.instructions[1].opcode)
+        assertEquals(0, seg1.instructions[1].args[0].value)
+        assertEquals(OP_ARG_PUSHW, seg1.instructions[2].opcode)
+        assertEquals(150, seg1.instructions[2].args[0].value)
+        assertEquals(OP_SET_FLOOR_HANDLER, seg1.instructions[3].opcode)
+
+        val seg2 = quest.byteCodeIr[1]
+        assertTrue(seg2 is InstructionSegment)
+        assertTrue(1 in seg2.labels)
+
+        val seg3 = quest.byteCodeIr[2]
+        assertTrue(seg3 is InstructionSegment)
+        assertTrue(10 in seg3.labels)
+
+        val seg4 = quest.byteCodeIr[3]
+        assertTrue(seg4 is InstructionSegment)
+        assertTrue(150 in seg4.labels)
+        assertEquals(1, seg4.instructions.size)
+        assertEquals(OP_SWITCH_JMP, seg4.instructions[0].opcode)
+        assertEquals(0, seg4.instructions[0].args[0].value)
+        assertEquals(200, seg4.instructions[0].args[1].value)
+        assertEquals(201, seg4.instructions[0].args[2].value)
     }
 }

lib/src/jsMain/kotlin/world/phantasmal/lib/cursor/ArrayBufferCursor.kt

@@ -123,6 +123,19 @@ class ArrayBufferCursor(
         return array
     }
 
+    override fun byteArray(n: Int): ByteArray {
+        requireSize(n)
+
+        val array = ByteArray(n)
+
+        for (i in 0 until n) {
+            array[i] = dv.getInt8(absolutePosition)
+            position++
+        }
+
+        return array
+    }
+
     override fun intArray(n: Int): IntArray {
         requireSize(4 * n)