Fixed various bugs.

build.gradle.kts

@@ -15,6 +15,7 @@ subprojects {
     project.extra["kotlinLoggingVersion"] = "2.0.2"
     project.extra["ktorVersion"] = "1.4.1"
     project.extra["serializationVersion"] = "1.0.0"
+    project.extra["slf4jVersion"] = "1.7.30"
 
     repositories {
         jcenter()

lib/build.gradle.kts

@@ -15,6 +15,7 @@ buildscript {
 
 val coroutinesVersion: String by project.extra
 val kotlinLoggingVersion: String by project.extra
+val slf4jVersion: String by project.extra
 
 kotlin {
     js {
@@ -59,6 +60,7 @@ kotlin {
         getByName("jvmTest") {
             dependencies {
                 implementation(kotlin("test-junit"))
+                implementation("org.slf4j:slf4j-simple:$slf4jVersion")
             }
         }
     }

lib/src/commonMain/kotlin/world/phantasmal/lib/Constants.kt

@@ -1,4 +1,3 @@
 package world.phantasmal.lib
 
 const val ZERO_U8: UByte = 0u
-const val ZERO_U16: UShort = 0u

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

@@ -82,10 +82,10 @@ sealed class RefType : AnyType()
 object RegRefType : RefType()
 
 /**
- * Reference to a fixed amount of consecutive registers of specific types.
+ * Reference to a fixed tuple of registers of specific types.
  * The only parameterized type.
  */
-class RegTupRefType(val registerTuples: List<Param>) : RefType()
+class RegTupRefType(val registerTuple: List<Param>) : RefType()
 
 /**
  * Arbitrary amount of register references.

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

@@ -11,6 +11,10 @@ private val logger = KotlinLogging.logger {}
  * Computes the possible values of a register right before a specific instruction.
  */
 fun getRegisterValue(cfg: ControlFlowGraph, instruction: Instruction, register: Int): ValueSet {
+    require(register in 0..255) {
+        "register should be between 0 and 255, inclusive but was $register."
+    }
+
     val block = cfg.getBlockForInstruction(instruction)
 
     return RegisterValueFinder().find(
@@ -178,7 +182,7 @@ private class RegisterValueFinder {
                         if (param.type is RegTupRefType) {
                             val regRef = args[j].value as Int
 
-                            for ((k, reg_param) in param.type.registerTuples.withIndex()) {
+                            for ((k, reg_param) in param.type.registerTuple.withIndex()) {
                                 if ((reg_param.access == ParamAccess.Write ||
                                             reg_param.access == ParamAccess.ReadWrite) &&
                                     regRef + k == register
@@ -204,8 +208,8 @@ private class RegisterValueFinder {
             values.union(find(LinkedHashSet(path), from, from.end, register))
         }
 
-        // If values is empty at this point, we know nothing ever sets the register's value and it still
+        // If values is empty at this point, we know nothing ever sets the register's value and it
-        // has its initial value of 0.
+        // still has its initial value of 0.
         if (values.isEmpty()) {
             values.setValue(0)
         }

lib/src/commonMain/kotlin/world/phantasmal/lib/compression/prs/PrsCompress.kt

@@ -1,6 +1,5 @@
 package world.phantasmal.lib.compression.prs
 
-import world.phantasmal.lib.Endianness
 import world.phantasmal.lib.buffer.Buffer
 import world.phantasmal.lib.cursor.Cursor
 import world.phantasmal.lib.cursor.WritableCursor
@@ -8,93 +7,84 @@ import world.phantasmal.lib.cursor.cursor
 import kotlin.math.max
 import kotlin.math.min
 
-fun prsCompress(cursor: Cursor): Cursor {
+// This code uses signed types for better KJS performance. In KJS unsigned types are always boxed.
-    val compressor = PrsCompressor(cursor.size, cursor.endianness)
-    val comparisonCursor = cursor.take(cursor.size)
-    cursor.seekStart(0)
 
-    while (cursor.hasBytesLeft()) {
+fun prsCompress(cursor: Cursor): Cursor =
-        // Find the longest match.
+    PrsCompressor(cursor).compress()
-        var bestOffset = 0
-        var bestSize = 0
-        val startPos = cursor.position
-        val minOffset = max(0, startPos - min(0x800, cursor.bytesLeft))
 
-        for (i in startPos - 255 downTo minOffset) {
+private class PrsCompressor(private val src: Cursor) {
-            comparisonCursor.seekStart(i)
+    private val dst: WritableCursor = Buffer.withCapacity(src.size, src.endianness).cursor()
-            var size = 0
-
-            while (cursor.hasBytesLeft() &&
-                size <= 254 &&
-                cursor.uByte() == comparisonCursor.uByte()
-            ) {
-                size++
-            }
-
-            cursor.seekStart(startPos)
-
-            if (size >= bestSize) {
-                bestOffset = i
-                bestSize = size
-
-                if (size >= 255) {
-                    break
-                }
-            }
-        }
-
-        if (bestSize < 3) {
-            compressor.addUByte(cursor.uByte())
-        } else {
-            compressor.copy(bestOffset - cursor.position, bestSize)
-            cursor.seek(bestSize)
-        }
-    }
-
-    return compressor.finalize()
-}
-
-private class PrsCompressor(capacity: Int, endianness: Endianness) {
-    private val output: WritableCursor = Buffer.withCapacity(capacity, endianness).cursor()
     private var flags = 0
     private var flagBitsLeft = 0
     private var flagOffset = 0
 
-    fun addUByte(value: UByte) {
+    fun compress(): Cursor {
-        writeControlBit(1)
+        val cmp = src.take(src.size)
-        writeUByte(value)
+        src.seekStart(0)
-    }
 
-    fun copy(offset: Int, size: Int) {
+        while (src.hasBytesLeft()) {
-        if (offset > -256 && size <= 5) {
+            // Find the longest match.
-            shortCopy(offset, size)
+            var bestOffset = 0
-        } else {
+            var bestSize = 0
-            longCopy(offset, size)
+            val startPos = src.position
+            val minOffset = max(0, startPos - min(0x800, src.bytesLeft))
+
+            for (i in startPos - 255 downTo minOffset) {
+                cmp.seekStart(i)
+                var size = 0
+
+                while (src.hasBytesLeft() &&
+                    size < 255 &&
+                    src.byte() == cmp.byte()
+                ) {
+                    size++
+                }
+
+                src.seekStart(startPos)
+
+                if (size >= bestSize) {
+                    bestOffset = i
+                    bestSize = size
+
+                    if (size >= 255) {
+                        break
+                    }
+                }
+            }
+
+            if (bestSize < 3) {
+                addByte(src.byte())
+            } else {
+                copy(bestOffset - src.position, bestSize)
+                src.seek(bestSize)
+            }
         }
+
+        return finalize()
     }
 
-    fun finalize(): Cursor {
+    private fun finalize(): Cursor {
         writeControlBit(0)
         writeControlBit(1)
 
         flags = flags ushr flagBitsLeft
-        val pos = output.position
+        val pos = dst.position
-        output.seekStart(flagOffset).writeUByte(flags.toUByte()).seekStart(pos)
+        dst.seekStart(flagOffset).writeByte(flags.toByte()).seekStart(pos)
 
-        writeUByte(0u)
+        writeByte(0)
-        writeUByte(0u)
+        writeByte(0)
-        return output.seekStart(0)
+        return dst.seekStart(0)
     }
 
     private fun writeControlBit(bit: Int) {
         if (flagBitsLeft == 0) {
             // Write out the flags to their position in the file, and store the next flags byte
             // position.
-            val pos = output.position
+            val pos = dst.position
-            output.seekStart(flagOffset)
+            dst.seekStart(flagOffset)
-            output.writeUByte(flags.toUByte())
+            dst.writeByte(flags.toByte())
-            output.seekStart(pos)
+            dst.seekStart(pos)
-            output.writeUByte(0u) // Placeholder for the next flags byte.
+            dst.writeUByte(0u) // Placeholder for the next flags byte.
             flagOffset = pos
             flagBitsLeft = 8
         }
@@ -108,12 +98,17 @@ private class PrsCompressor(capacity: Int, endianness: Endianness) {
         flagBitsLeft--
     }
 
-    private fun writeUByte(data: UByte) {
+    private fun addByte(value: Byte) {
-        output.writeUByte(data)
+        writeControlBit(1)
+        dst.writeByte(value)
     }
 
-    private fun writeUByte(data: Int) {
+    private fun copy(offset: Int, size: Int) {
-        output.writeUByte(data.toUByte())
+        if (offset > -256 && size <= 5) {
+            shortCopy(offset, size)
+        } else {
+            longCopy(offset, size)
+        }
     }
 
     private fun shortCopy(offset: Int, size: Int) {
@@ -122,7 +117,7 @@ private class PrsCompressor(capacity: Int, endianness: Endianness) {
         writeControlBit(0)
         writeControlBit(((s ushr 1) and 1))
         writeControlBit((s and 1))
-        writeUByte(offset and 0xFF)
+        writeByte(offset)
     }
 
     private fun longCopy(offset: Int, size: Int) {
@@ -130,12 +125,16 @@ private class PrsCompressor(capacity: Int, endianness: Endianness) {
         writeControlBit(1)
 
         if (size <= 9) {
-            writeUByte(((offset shl 3) and 0xF8) or ((size - 2) and 0x07))
+            writeByte(((offset shl 3) and 0xF8) or ((size - 2) and 0b111))
-            writeUByte((offset ushr 5) and 0xFF)
+            writeByte((offset ushr 5))
         } else {
-            writeUByte((offset shl 3) and 0xF8)
+            writeByte((offset shl 3) and 0xF8)
-            writeUByte((offset ushr 5) and 0xFF)
+            writeByte((offset ushr 5))
-            writeUByte(size - 1)
+            writeByte(size - 1)
         }
     }
+
+    private fun writeByte(data: Int) {
+        dst.writeByte(data.toByte())
+    }
 }

lib/src/commonMain/kotlin/world/phantasmal/lib/compression/prs/PrsDecompress.kt

@@ -9,79 +9,74 @@ 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.floor
 import kotlin.math.min
 
 private val logger = KotlinLogging.logger {}
 
-fun prsDecompress(cursor: Cursor): PwResult<Cursor> {
+// This code uses signed types for better KJS performance. In KJS unsigned types are always boxed.
-    try {
-        val decompressor = PrsDecompressor(cursor)
-        var i = 0
 
-        while (true) {
+fun prsDecompress(cursor: Cursor): PwResult<Cursor> =
-            if (decompressor.readFlagBit() == 1) {
+    PrsDecompressor(cursor).decompress()
-                // Single byte copy.
-                decompressor.copyU8()
-            } else {
-                // Multi byte copy.
-                var length: Int
-                var offset: Int
 
-                if (decompressor.readFlagBit() == 0) {
+private class PrsDecompressor(private val src: Cursor) {
-                    // Short copy.
+    private val dst: WritableCursor =
-                    length = (decompressor.readFlagBit() shl 1) or decompressor.readFlagBit()
+        Buffer.withCapacity(6 * src.size, src.endianness).cursor()
-                    length += 2
-
-                    offset = decompressor.readU8().toInt() - 256
-                } else {
-                    // Long copy or end of file.
-                    offset = decompressor.readU16().toInt()
-
-                    // Two zero bytes implies that this is the end of the file.
-                    if (offset == 0) {
-                        break
-                    }
-
-                    // Do we need to read a length byte, or is it encoded in what we already have?
-                    length = offset and 0b111
-                    offset = offset ushr 3
-
-                    if (length == 0) {
-                        length = decompressor.readU8().toInt()
-                        length += 1
-                    } else {
-                        length += 2
-                    }
-
-                    offset -= 8192
-                }
-
-                decompressor.offsetCopy(offset, length)
-            }
-
-            i++
-        }
-
-        return Success(decompressor.dst.seekStart(0))
-    } catch (e: Throwable) {
-        return PwResultBuilder<Cursor>(logger)
-            .addProblem(Severity.Error, "PRS-compressed stream is corrupt.", cause = e)
-            .failure()
-    }
-}
-
-private class PrsDecompressor(cursor: Cursor) {
-    private val src: Cursor = cursor
-    val dst: WritableCursor =
-        Buffer.withCapacity(floor(1.5 * cursor.size.toDouble()).toInt(), cursor.endianness).cursor()
     private var flags = 0
     private var flagBitsLeft = 0
 
-    fun readFlagBit(): Int {
+    fun decompress(): PwResult<Cursor> {
+        try {
+            while (true) {
+                if (readFlagBit() == 1) {
+                    // Single byte copy.
+                    copyByte()
+                } else {
+                    // Multi byte copy.
+                    if (readFlagBit() == 0) {
+                        // Short copy.
+                        val size = 2 + ((readFlagBit() shl 1) or readFlagBit())
+                        val offset = readUByte() - 256
+
+                        offsetCopy(offset, size)
+                    } else {
+                        // Long copy or end of file.
+                        var offset = readUShort()
+
+                        // Two zero bytes implies that this is the end of the file.
+                        if (offset == 0) {
+                            break
+                        }
+
+                        // Do we need to read a size byte, or is it encoded in what we already have?
+                        var size = offset and 0b111
+                        offset = offset ushr 3
+
+                        if (size == 0) {
+                            size = readUByte()
+                            size += 1
+                        } else {
+                            size += 2
+                        }
+
+                        offset -= 8192
+
+                        offsetCopy(offset, size)
+                    }
+                }
+            }
+
+            return Success(dst.seekStart(0))
+        } catch (e: Throwable) {
+            return PwResultBuilder<Cursor>(logger)
+                .addProblem(Severity.Error, "PRS-compressed stream is corrupt.", cause = e)
+                .failure()
+        }
+    }
+
+    private fun readFlagBit(): Int {
         // Fetch a new flag byte when the previous byte has been processed.
         if (flagBitsLeft == 0) {
-            flags = readU8().toInt()
+            flags = readUByte()
             flagBitsLeft = 8
         }
 
@@ -91,36 +86,35 @@ private class PrsDecompressor(cursor: Cursor) {
         return bit
     }
 
-    fun copyU8() {
+    private fun copyByte() {
-        dst.writeUByte(readU8())
+        dst.writeByte(src.byte())
     }
 
-    fun readU8(): UByte = src.uByte()
+    private fun readUByte(): Int = src.byte().toInt() and 0xFF
 
-    fun readU16(): UShort = src.uShort()
+    private fun readUShort(): Int = src.short().toInt() and 0xFFFF
 
-    fun offsetCopy(offset: Int, length: Int) {
+    private fun offsetCopy(offset: Int, size: Int) {
         require(offset in -8192..0) {
             "offset was ${offset}, should be between -8192 and 0."
         }
 
-        require(length in 1..256) {
+        require(size in 1..256) {
-            "length was ${length}, should be between 1 and 256."
+            "size was ${size}, should be between 1 and 256."
         }
 
-        // The length can be larger than -offset, in that case we copy -offset bytes size/-offset
+        // Size can be larger than -offset, in that case we copy -offset bytes size/-offset times.
-        // times.
+        val bufSize = min(-offset, size)
-        val bufSize = min(-offset, length)
 
         dst.seek(offset)
         val buf = dst.take(bufSize)
         dst.seek(-offset - bufSize)
 
-        repeat(length / bufSize) {
+        repeat(size / bufSize) {
             dst.writeCursor(buf)
             buf.seekStart(0)
         }
 
-        dst.writeCursor(buf.take(length % bufSize))
+        dst.writeCursor(buf.take(size % bufSize))
     }
 }

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

@@ -1,7 +1,6 @@
 package world.phantasmal.lib.cursor
 
-import world.phantasmal.lib.ZERO_U16
+import kotlin.experimental.and
-import world.phantasmal.lib.ZERO_U8
 import kotlin.math.min
 
 abstract class AbstractWritableCursor
@@ -22,14 +21,14 @@ protected constructor(protected val offset: Int) : WritableCursor {
         seekStart(position + offset)
 
     override fun seekStart(offset: Int): WritableCursor {
-        require(offset >= 0 || offset <= size) { "Offset $offset is out of bounds." }
+        require(offset in 0..size) { "Offset $offset is out of bounds." }
 
         position = offset
         return this
     }
 
     override fun seekEnd(offset: Int): WritableCursor {
-        require(offset >= 0 || offset <= size) { "Offset $offset is out of bounds." }
+        require(offset in 0..size) { "Offset $offset is out of bounds." }
 
         position = size - offset
         return this
@@ -42,9 +41,10 @@ protected constructor(protected val offset: Int) : WritableCursor {
     ): String =
         buildString {
             for (i in 0 until maxByteLength) {
-                val codePoint = uByte()
+                // Use Byte instead of UByte for better KJS perf.
+                val codePoint = (byte().toShort() and 0xFF).toChar()
 
-                if (nullTerminated && codePoint == ZERO_U8) {
+                if (nullTerminated && codePoint == '\u0000') {
                     if (dropRemaining) {
                         seek(maxByteLength - i - 1)
                     }
@@ -52,7 +52,7 @@ protected constructor(protected val offset: Int) : WritableCursor {
                     break
                 }
 
-                append(codePoint.toShort().toChar())
+                append(codePoint)
             }
         }
 
@@ -65,9 +65,9 @@ protected constructor(protected val offset: Int) : WritableCursor {
             val len = maxByteLength / 2
 
             for (i in 0 until len) {
-                val codePoint = uShort()
+                val codePoint = short().toChar()
 
-                if (nullTerminated && codePoint == ZERO_U16) {
+                if (nullTerminated && codePoint == '\u0000') {
                     if (dropRemaining) {
                         seek(maxByteLength - 2 * i - 2)
                     }
@@ -75,7 +75,7 @@ protected constructor(protected val offset: Int) : WritableCursor {
                     break
                 }
 
-                append(codePoint.toShort().toChar())
+                append(codePoint)
             }
         }
 
@@ -126,6 +126,7 @@ protected constructor(protected val offset: Int) : WritableCursor {
     override fun writeCursor(other: Cursor): WritableCursor {
         val size = other.bytesLeft
         requireSize(size)
+
         for (i in 0 until size) {
             writeByte(other.byte())
         }

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

@@ -35,11 +35,11 @@ class BufferCursor(
         }
 
     init {
-        require(offset <= buffer.size) {
+        require(offset in 0..buffer.size) {
             "Offset $offset is out of bounds."
         }
 
-        require(offset + size <= buffer.size) {
+        require(size >= 0 && offset + size <= buffer.size) {
             "Size $size is out of bounds."
         }
     }

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

@@ -129,5 +129,5 @@ interface Cursor {
     /**
      * Returns a buffer with a copy of [size] bytes at [position].
      */
-    fun buffer(size: Int): Buffer
+    fun buffer(size: Int = bytesLeft): Buffer
 }

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

@@ -12,8 +12,8 @@ private const val BB_OBJECT_CODE_OFFSET = 4652
 
 class BinFile(
     val format: BinFormat,
-    val questId: UInt,
+    val questId: Int,
-    val language: UInt,
+    val language: Int,
     val questName: String,
     val shortDescription: String,
     val longDescription: String,
@@ -57,22 +57,28 @@ fun parseBin(cursor: Cursor): BinFile {
         }
     }
 
-    val questId: UInt
+    val questId: Int
-    val language: UInt
+    val language: Int
     val questName: String
     val shortDescription: String
     val longDescription: String
 
     if (format == BinFormat.DC_GC) {
         cursor.seek(1)
-        language = cursor.uByte().toUInt()
+        language = cursor.byte().toInt()
-        questId = cursor.uShort().toUInt()
+        questId = cursor.short().toInt()
         questName = cursor.stringAscii(32, nullTerminated = true, dropRemaining = true)
         shortDescription = cursor.stringAscii(128, nullTerminated = true, dropRemaining = true)
         longDescription = cursor.stringAscii(288, nullTerminated = true, dropRemaining = true)
     } else {
-        questId = cursor.uInt()
+        if (format == BinFormat.PC) {
-        language = cursor.uInt()
+            language = cursor.short().toInt()
+            questId = cursor.short().toInt()
+        } else {
+            questId = cursor.int()
+            language = cursor.int()
+        }
+
         questName = cursor.stringUtf16(64, nullTerminated = true, dropRemaining = true)
         shortDescription = cursor.stringUtf16(256, nullTerminated = true, dropRemaining = true)
         longDescription = cursor.stringUtf16(576, nullTerminated = true, dropRemaining = true)

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

@@ -100,7 +100,7 @@ fun parseDat(cursor: Cursor): DatFile {
                 }
             }
 
-            require(!entitiesCursor.hasBytesLeft()) {
+            if (entitiesCursor.hasBytesLeft()) {
                 logger.warn {
                     "Read ${entitiesCursor.position} bytes instead of expected ${entitiesCursor.size} for entity type ${entityType}."
                 }
@@ -137,9 +137,9 @@ private fun parseEvents(cursor: Cursor, areaId: Int, events: MutableList<DatEven
     cursor.seek(4) // Always 0x10
     val eventCount = cursor.int()
     cursor.seek(3) // Always 0
-    val eventType = cursor.uByte()
+    val eventType = cursor.byte()
 
-    require(eventType != (0x32u).toUByte()) {
+    require(eventType != (0x32).toByte()) {
         "Can't parse challenge mode quests yet."
     }
 
@@ -182,17 +182,17 @@ private fun parseEvents(cursor: Cursor, areaId: Int, events: MutableList<DatEven
         }
     }
 
-    var lastU8: UByte = 0xffu
+    var lastUByte: UByte = 0xffu
 
     while (actionsCursor.hasBytesLeft()) {
-        lastU8 = actionsCursor.uByte()
+        lastUByte = actionsCursor.uByte()
 
-        if (lastU8 != (0xffu).toUByte()) {
+        if (lastUByte != (0xffu).toUByte()) {
             break
         }
     }
 
-    if (lastU8 != (0xffu).toUByte()) {
+    if (lastUByte != (0xffu).toUByte()) {
         actionsCursor.seek(-1)
     }
 

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

@@ -6,7 +6,6 @@ import world.phantasmal.core.PwResultBuilder
 import world.phantasmal.core.Severity
 import world.phantasmal.lib.assembly.*
 import world.phantasmal.lib.assembly.dataFlowAnalysis.ControlFlowGraph
-import world.phantasmal.lib.assembly.dataFlowAnalysis.ValueSet
 import world.phantasmal.lib.assembly.dataFlowAnalysis.getRegisterValue
 import world.phantasmal.lib.assembly.dataFlowAnalysis.getStackValue
 import world.phantasmal.lib.buffer.Buffer
@@ -218,28 +217,21 @@ private fun findAndParseSegments(
                             getArgLabelValues(cfg, newLabels, instruction, i, SegmentType.String)
 
                         is RegTupRefType -> {
-                            // Never on the stack.
+                            for (j in param.type.registerTuple.indices) {
-                            var firstRegister: ValueSet? = null
+                                val regTup = param.type.registerTuple[j]
-
-                            for (j in param.type.registerTuples.indices) {
-                                val regTup = param.type.registerTuples[j]
 
+                                // Never on the stack.
                                 if (regTup.type is ILabelType) {
-                                    if (firstRegister == null) {
+                                    val firstRegister = instruction.args[0].value as Int
-                                        firstRegister = getStackValue(cfg, instruction, i)
+                                    val labelValues = getRegisterValue(
-                                    }
+                                        cfg,
+                                        instruction,
+                                        firstRegister + j,
+                                    )
 
-                                    for (reg in firstRegister) {
+                                    if (labelValues.size <= 10) {
-                                        val labelValues = getRegisterValue(
+                                        for (label in labelValues) {
-                                            cfg,
+                                            newLabels[label] = SegmentType.Instructions
-                                            instruction,
-                                            reg + j,
-                                        )
-
-                                        if (labelValues.size <= 10) {
-                                            for (label in labelValues) {
-                                                newLabels[label] = SegmentType.Instructions
-                                            }
                                         }
                                     }
                                 }

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

@@ -55,9 +55,9 @@ fun parseBinDatToQuest(
     }
 
     val dat = parseDat(datDecompressed.value)
-    val objects = dat.objs.map { QuestObject(it.areaId.toInt(), it.data) }
+    val objects = dat.objs.map { QuestObject(it.areaId, it.data) }
     // Initialize NPCs with random episode and correct it later.
-    val npcs = dat.npcs.map { QuestNpc(Episode.I, it.areaId.toInt(), it.data) }
+    val npcs = dat.npcs.map { QuestNpc(Episode.I, it.areaId, it.data) }
 
     // Extract episode and map designations from object code.
     var episode = Episode.I
@@ -107,8 +107,8 @@ fun parseBinDatToQuest(
     }
 
     return rb.success(Quest(
-        id = bin.questId.toInt(),
+        id = bin.questId,
-        language = bin.language.toInt(),
+        language = bin.language,
         name = bin.questName,
         shortDescription = bin.shortDescription,
         longDescription = bin.longDescription,

lib/src/commonTest/kotlin/world/phantasmal/lib/buffer/BufferTests.kt

@@ -8,27 +8,42 @@ import kotlin.test.assertTrue
 class BufferTests {
     @Test
     fun withCapacity() {
+        withCapacity(Endianness.Little)
+        withCapacity(Endianness.Big)
+    }
+
+    private fun withCapacity(endianness: Endianness) {
         val capacity = 500
-        val buffer = Buffer.withCapacity(capacity)
+        val buffer = Buffer.withCapacity(capacity, endianness)
 
         assertEquals(0, buffer.size)
         assertEquals(capacity, buffer.capacity)
-        assertEquals(Endianness.Little, buffer.endianness)
+        assertEquals(endianness, buffer.endianness)
     }
 
     @Test
     fun withSize() {
+        withSize(Endianness.Little)
+        withSize(Endianness.Big)
+    }
+
+    private fun withSize(endianness: Endianness) {
         val size = 500
-        val buffer = Buffer.withSize(size)
+        val buffer = Buffer.withSize(size, endianness)
 
         assertEquals(size, buffer.size)
         assertEquals(size, buffer.capacity)
-        assertEquals(Endianness.Little, buffer.endianness)
+        assertEquals(endianness, buffer.endianness)
     }
 
     @Test
     fun reallocates_internal_storage_when_necessary() {
-        val buffer = Buffer.withCapacity(100)
+        reallocates_internal_storage_when_necessary(Endianness.Little)
+        reallocates_internal_storage_when_necessary(Endianness.Big)
+    }
+
+    private fun reallocates_internal_storage_when_necessary(endianness: Endianness) {
+        val buffer = Buffer.withCapacity(100, endianness)
 
         assertEquals(0, buffer.size)
         assertEquals(100, buffer.capacity)
@@ -41,6 +56,7 @@ class BufferTests {
         buffer.setUByte(100, (0xABu).toUByte())
 
         assertEquals(0xABu, buffer.getUByte(100).toUInt())
+        assertEquals(endianness, buffer.endianness)
     }
 
     @Test
@@ -50,13 +66,13 @@ class BufferTests {
         buffer.fillByte(100)
 
         for (i in 0 until buffer.size) {
-            assertEquals(100u, buffer.getUByte(i))
+            assertEquals(100, buffer.getByte(i))
         }
 
         buffer.zero()
 
         for (i in 0 until buffer.size) {
-            assertEquals(0u, buffer.getUByte(i))
+            assertEquals(0, buffer.getByte(i))
         }
     }
 }

lib/src/commonTest/kotlin/world/phantasmal/lib/compression/prs/PrsCompressTests.kt

@@ -49,7 +49,7 @@ class PrsCompressTests {
         val buffer = Buffer.withSize(10_000)
 
         for (i in 0 until buffer.size step 4) {
-            buffer.setUInt(i, random.nextUInt())
+            buffer.setInt(i, random.nextInt())
         }
 
         val compressed = prsCompress(buffer.cursor())

lib/src/commonTest/kotlin/world/phantasmal/lib/compression/prs/PrsDecompressTests.kt

@@ -1,6 +1,7 @@
 package world.phantasmal.lib.compression.prs
 
 import world.phantasmal.lib.buffer.Buffer
+import world.phantasmal.lib.cursor.Cursor
 import world.phantasmal.lib.cursor.cursor
 import world.phantasmal.lib.test.asyncTest
 import world.phantasmal.lib.test.readFile
@@ -66,26 +67,15 @@ class PrsDecompressTests {
         val decompressedCursor = prsDecompress(compressedCursor).unwrap()
         cursor.seekStart(0)
 
-        assertEquals(cursor.size, decompressedCursor.size)
+        assertCursorEquals(cursor, decompressedCursor)
-
-        while (cursor.hasBytesLeft()) {
-            val expected = cursor.byte()
-            val actual = decompressedCursor.byte()
-
-            if (expected != actual) {
-                // Assert after check for performance.
-                assertEquals(
-                    expected,
-                    actual,
-                    "Got $actual, expected $expected at ${cursor.position - 1}."
-                )
-            }
-        }
     }
 
     @Test
     fun decompress_towards_the_future() = asyncTest {
-        prsDecompress(readFile("/quest118_e.bin")).unwrap()
+        val orig = readFile("/quest118_e_decompressed.bin")
+        val test = prsDecompress(readFile("/quest118_e.bin")).unwrap()
+
+        assertCursorEquals(orig, test)
     }
 
     @Test
@@ -94,20 +84,24 @@ class PrsDecompressTests {
         val test = prsDecompress(prsCompress(orig)).unwrap()
         orig.seekStart(0)
 
-        assertEquals(orig.size, test.size)
+        assertCursorEquals(orig, test)
+    }
 
-        while (orig.hasBytesLeft()) {
+    private fun assertCursorEquals(expected: Cursor, actual: Cursor) {
-            val expected = orig.byte()
+        while (expected.hasBytesLeft() && actual.hasBytesLeft()) {
-            val actual = test.byte()
+            val expectedByte = expected.byte()
+            val actualByte = actual.byte()
 
-            if (expected != actual) {
+            if (expectedByte != actualByte) {
                 // Assert after check for performance.
                 assertEquals(
-                    expected,
+                    expectedByte,
-                    actual,
+                    actualByte,
-                    "Got $actual, expected $expected at ${orig.position - 1}."
+                    "Got $actualByte, expected $expectedByte at ${expected.position - 1}."
                 )
             }
         }
+
+        assertEquals(expected.size, actual.size)
     }
 }

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

@@ -10,37 +10,37 @@ class BufferCursorTests : WritableCursorTests() {
         BufferCursor(Buffer.fromByteArray(bytes, endianness))
 
     @Test
-    fun writeU8_increases_size_correctly() {
+    fun writeUByte_increases_size_correctly() {
         testIntegerWriteSize(1, { writeUByte(it.toUByte()) }, Endianness.Little)
         testIntegerWriteSize(1, { writeUByte(it.toUByte()) }, Endianness.Big)
     }
 
     @Test
-    fun writeU16_increases_size_correctly() {
+    fun writeUShort_increases_size_correctly() {
         testIntegerWriteSize(2, { writeUShort(it.toUShort()) }, Endianness.Little)
         testIntegerWriteSize(2, { writeUShort(it.toUShort()) }, Endianness.Big)
     }
 
     @Test
-    fun writeU32_increases_size_correctly() {
+    fun writeUInt_increases_size_correctly() {
         testIntegerWriteSize(4, { writeUInt(it.toUInt()) }, Endianness.Little)
         testIntegerWriteSize(4, { writeUInt(it.toUInt()) }, Endianness.Big)
     }
 
     @Test
-    fun writeI8_increases_size_correctly() {
+    fun writeByte_increases_size_correctly() {
         testIntegerWriteSize(1, { writeByte(it.toByte()) }, Endianness.Little)
         testIntegerWriteSize(1, { writeByte(it.toByte()) }, Endianness.Big)
     }
 
     @Test
-    fun writeI16_increases_size_correctly() {
+    fun writeShort_increases_size_correctly() {
         testIntegerWriteSize(2, { writeShort(it.toShort()) }, Endianness.Little)
         testIntegerWriteSize(2, { writeShort(it.toShort()) }, Endianness.Big)
     }
 
     @Test
-    fun writeI32_increases_size_correctly() {
+    fun writeInt_increases_size_correctly() {
         testIntegerWriteSize(4, { writeInt(it) }, Endianness.Little)
         testIntegerWriteSize(4, { writeInt(it) }, Endianness.Big)
     }

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

@@ -53,37 +53,37 @@ abstract class CursorTests {
     }
 
     @Test
-    fun u8() {
+    fun uByte() {
         testIntegerRead(1, { uByte().toInt() }, Endianness.Little)
         testIntegerRead(1, { uByte().toInt() }, Endianness.Big)
     }
 
     @Test
-    fun u16() {
+    fun uShort() {
         testIntegerRead(2, { uShort().toInt() }, Endianness.Little)
         testIntegerRead(2, { uShort().toInt() }, Endianness.Big)
     }
 
     @Test
-    fun u32() {
+    fun uInt() {
         testIntegerRead(4, { uInt().toInt() }, Endianness.Little)
         testIntegerRead(4, { uInt().toInt() }, Endianness.Big)
     }
 
     @Test
-    fun i8() {
+    fun byte() {
         testIntegerRead(1, { byte().toInt() }, Endianness.Little)
         testIntegerRead(1, { byte().toInt() }, Endianness.Big)
     }
 
     @Test
-    fun i16() {
+    fun short() {
         testIntegerRead(2, { short().toInt() }, Endianness.Little)
         testIntegerRead(2, { short().toInt() }, Endianness.Big)
     }
 
     @Test
-    fun i32() {
+    fun int() {
         testIntegerRead(4, { int() }, Endianness.Little)
         testIntegerRead(4, { int() }, Endianness.Big)
     }
@@ -123,12 +123,12 @@ abstract class CursorTests {
     }
 
     @Test
-    fun f32() {
+    fun float() {
-        f32(Endianness.Little)
+        float(Endianness.Little)
-        f32(Endianness.Big)
+        float(Endianness.Big)
     }
 
-    private fun f32(endianness: Endianness) {
+    private fun float(endianness: Endianness) {
         val bytes = byteArrayOf(0x40, 0x20, 0, 0, 0x42, 1, 0, 0)
 
         if (endianness == Endianness.Little) {
@@ -146,7 +146,7 @@ abstract class CursorTests {
     }
 
     @Test
-    fun u8Array() {
+    fun uByteArray() {
         val read: Cursor.(Int) -> IntArray = { n ->
             val arr = uByteArray(n)
             IntArray(n) { arr[it].toInt() }
@@ -157,7 +157,7 @@ abstract class CursorTests {
     }
 
     @Test
-    fun u16Array() {
+    fun uShortArray() {
         val read: Cursor.(Int) -> IntArray = { n ->
             val arr = uShortArray(n)
             IntArray(n) { arr[it].toInt() }
@@ -168,7 +168,7 @@ abstract class CursorTests {
     }
 
     @Test
-    fun u32Array() {
+    fun uIntArray() {
         val read: Cursor.(Int) -> IntArray = { n ->
             val arr = uIntArray(n)
             IntArray(n) { arr[it].toInt() }
@@ -179,7 +179,7 @@ abstract class CursorTests {
     }
 
     @Test
-    fun i32Array() {
+    fun intArray() {
         val read: Cursor.(Int) -> IntArray = { n ->
             val arr = intArray(n)
             IntArray(n) { arr[it] }

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

@@ -32,37 +32,37 @@ abstract class WritableCursorTests : CursorTests() {
     }
 
     @Test
-    fun writeU8() {
+    fun writeUByte() {
         testIntegerWrite(1, { uByte().toInt() }, { writeUByte(it.toUByte()) }, Endianness.Little)
         testIntegerWrite(1, { uByte().toInt() }, { writeUByte(it.toUByte()) }, Endianness.Big)
     }
 
     @Test
-    fun writeU16() {
+    fun writeUShort() {
         testIntegerWrite(2, { uShort().toInt() }, { writeUShort(it.toUShort()) }, Endianness.Little)
         testIntegerWrite(2, { uShort().toInt() }, { writeUShort(it.toUShort()) }, Endianness.Big)
     }
 
     @Test
-    fun writeU32() {
+    fun writeUInt() {
         testIntegerWrite(4, { uInt().toInt() }, { writeUInt(it.toUInt()) }, Endianness.Little)
         testIntegerWrite(4, { uInt().toInt() }, { writeUInt(it.toUInt()) }, Endianness.Big)
     }
 
     @Test
-    fun writeI8() {
+    fun writeByte() {
         testIntegerWrite(1, { byte().toInt() }, { writeByte(it.toByte()) }, Endianness.Little)
         testIntegerWrite(1, { byte().toInt() }, { writeByte(it.toByte()) }, Endianness.Big)
     }
 
     @Test
-    fun writeI16() {
+    fun writeShort() {
         testIntegerWrite(2, { short().toInt() }, { writeShort(it.toShort()) }, Endianness.Little)
         testIntegerWrite(2, { short().toInt() }, { writeShort(it.toShort()) }, Endianness.Big)
     }
 
     @Test
-    fun writeI32() {
+    fun writeInt() {
         testIntegerWrite(4, { int() }, { writeInt(it) }, Endianness.Little)
         testIntegerWrite(4, { int() }, { writeInt(it) }, Endianness.Big)
     }
@@ -93,15 +93,15 @@ abstract class WritableCursorTests : CursorTests() {
     }
 
     @Test
-    fun writeF32() {
+    fun writeFloat() {
-        writeF32(Endianness.Little)
+        writeFloat(Endianness.Little)
-        writeF32(Endianness.Big)
+        writeFloat(Endianness.Big)
     }
 
     /**
      * Writes and reads two floats.
      */
-    private fun writeF32(endianness: Endianness) {
+    private fun writeFloat(endianness: Endianness) {
         val cursor = createCursor(ByteArray(8), endianness)
 
         cursor.writeFloat(1337.9001f)
@@ -120,7 +120,7 @@ abstract class WritableCursorTests : CursorTests() {
     }
 
     @Test
-    fun writeU8Array() {
+    fun writeUByteArray() {
         val read: Cursor.(Int) -> IntArray = { n ->
             val arr = uByteArray(n)
             IntArray(n) { arr[it].toInt() }
@@ -134,7 +134,7 @@ abstract class WritableCursorTests : CursorTests() {
     }
 
     @Test
-    fun writeU16Array() {
+    fun writeUShortArray() {
         val read: Cursor.(Int) -> IntArray = { n ->
             val arr = uShortArray(n)
             IntArray(n) { arr[it].toInt() }
@@ -148,7 +148,7 @@ abstract class WritableCursorTests : CursorTests() {
     }
 
     @Test
-    fun writeU32Array() {
+    fun writeUIntArray() {
         val read: Cursor.(Int) -> IntArray = { n ->
             val arr = uIntArray(n)
             IntArray(n) { arr[it].toInt() }
@@ -162,7 +162,7 @@ abstract class WritableCursorTests : CursorTests() {
     }
 
     @Test
-    fun writeI32Array() {
+    fun writeIntArray() {
         val read: Cursor.(Int) -> IntArray = { n ->
             intArray(n)
         }

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

@@ -0,0 +1,23 @@
+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 BinTests {
+    @Test
+    fun parse_quest_towards_the_future() = asyncTest {
+        val bin = parseBin(readFile("/quest118_e_decompressed.bin"))
+
+        assertEquals(BinFormat.BB, bin.format)
+        assertEquals(118, bin.questId)
+        assertEquals(0, bin.language)
+        assertEquals("Towards the Future", bin.questName)
+        assertEquals("Challenge the\nnew simulator.", bin.shortDescription)
+        assertEquals(
+            "Client: Principal\nQuest: Wishes to have\nhunters challenge the\nnew simulator\nReward: ??? Meseta",
+            bin.longDescription
+        )
+    }
+}

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

@@ -0,0 +1,44 @@
+package world.phantasmal.lib.fileFormats.quest
+
+import world.phantasmal.core.Success
+import world.phantasmal.lib.test.asyncTest
+import world.phantasmal.lib.test.readFile
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class QuestTests {
+    @Test
+    fun parseBinDatToQuest_with_towards_the_future() = asyncTest {
+        val result = parseBinDatToQuest(readFile("/quest118_e.bin"), readFile("/quest118_e.dat"))
+
+        assertTrue (result is Success)
+        assertTrue(result.problems.isEmpty())
+
+        val quest = result.value
+
+        assertEquals("Towards the Future", quest.name)
+        assertEquals("Challenge the\nnew simulator.", quest.shortDescription)
+        assertEquals(
+            "Client: Principal\nQuest: Wishes to have\nhunters challenge the\nnew simulator\nReward: ??? Meseta",
+            quest.longDescription
+        )
+        assertEquals(Episode.I, quest.episode)
+        assertEquals(277, quest.objects.size)
+        // TODO: Test objects.
+//        assertEquals(ObjectType.MenuActivation, quest.objects[0])
+//        assertEquals(ObjectType.PlayerSet, quest.objects[4])
+        assertEquals(216, quest.npcs.size)
+        assertEquals(10, quest.mapDesignations.size)
+        assertEquals(0, quest.mapDesignations[0])
+        assertEquals(0, quest.mapDesignations[2])
+        assertEquals(0, quest.mapDesignations[11])
+        assertEquals(4, quest.mapDesignations[5])
+        assertEquals(0, quest.mapDesignations[12])
+        assertEquals(4, quest.mapDesignations[7])
+        assertEquals(0, quest.mapDesignations[13])
+        assertEquals(4, quest.mapDesignations[8])
+        assertEquals(4, quest.mapDesignations[10])
+        assertEquals(0, quest.mapDesignations[14])
+    }
+}

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

@@ -5,7 +5,6 @@ import org.khronos.webgl.DataView
 import org.khronos.webgl.Int8Array
 import org.khronos.webgl.Uint8Array
 import world.phantasmal.lib.Endianness
-import world.phantasmal.lib.ZERO_U16
 
 actual class Buffer private constructor(
     private var arrayBuffer: ArrayBuffer,
@@ -74,13 +73,13 @@ actual class Buffer private constructor(
             val len = maxByteLength / 2
 
             for (i in 0 until len) {
-                val codePoint = getUShort(offset + i * 2)
+                val codePoint = getShort(offset + i * 2).toChar()
 
-                if (nullTerminated && codePoint == ZERO_U16) {
+                if (nullTerminated && codePoint == '0') {
                     break
                 }
 
-                append(codePoint.toShort().toChar())
+                append(codePoint)
             }
         }
 

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

@@ -166,6 +166,7 @@ actual class Buffer private constructor(
             } while (newSize < minNewSize)
 
             val newBuf = ByteBuffer.allocate(newSize)
+            newBuf.order(buf.order())
             newBuf.put(buf.array())
             buf = newBuf
         }