diff --git a/build.gradle.kts b/build.gradle.kts index 987f2742..4523be52 100644 --- a/build.gradle.kts +++ b/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() diff --git a/lib/build.gradle.kts b/lib/build.gradle.kts index 43a7ea18..184c15c6 100644 --- a/lib/build.gradle.kts +++ b/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") } } } diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/Constants.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/Constants.kt index ab5786b0..cafbcc02 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/Constants.kt +++ b/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 diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/Opcode.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/Opcode.kt index 72da7b9f..b1753a90 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/Opcode.kt +++ b/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) : RefType() +class RegTupRefType(val registerTuple: List) : RefType() /** * Arbitrary amount of register references. diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/dataFlowAnalysis/GetRegisterValue.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/dataFlowAnalysis/GetRegisterValue.kt index 107c689d..d284c2c1 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/dataFlowAnalysis/GetRegisterValue.kt +++ b/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 - // has its initial value of 0. + // If values is empty at this point, we know nothing ever sets the register's value and it + // still has its initial value of 0. if (values.isEmpty()) { values.setValue(0) } diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/compression/prs/PrsCompress.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/compression/prs/PrsCompress.kt index 9e33fa79..98211b06 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/compression/prs/PrsCompress.kt +++ b/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 { - val compressor = PrsCompressor(cursor.size, cursor.endianness) - val comparisonCursor = cursor.take(cursor.size) - cursor.seekStart(0) +// This code uses signed types for better KJS performance. In KJS unsigned types are always boxed. - while (cursor.hasBytesLeft()) { - // Find the longest match. - var bestOffset = 0 - var bestSize = 0 - val startPos = cursor.position - val minOffset = max(0, startPos - min(0x800, cursor.bytesLeft)) +fun prsCompress(cursor: Cursor): Cursor = + PrsCompressor(cursor).compress() - for (i in startPos - 255 downTo minOffset) { - comparisonCursor.seekStart(i) - 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 class PrsCompressor(private val src: Cursor) { + private val dst: WritableCursor = Buffer.withCapacity(src.size, src.endianness).cursor() private var flags = 0 private var flagBitsLeft = 0 private var flagOffset = 0 - fun addUByte(value: UByte) { - writeControlBit(1) - writeUByte(value) - } + fun compress(): Cursor { + val cmp = src.take(src.size) + src.seekStart(0) - fun copy(offset: Int, size: Int) { - if (offset > -256 && size <= 5) { - shortCopy(offset, size) - } else { - longCopy(offset, size) + while (src.hasBytesLeft()) { + // Find the longest match. + var bestOffset = 0 + var bestSize = 0 + 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 - output.seekStart(flagOffset).writeUByte(flags.toUByte()).seekStart(pos) + val pos = dst.position + dst.seekStart(flagOffset).writeByte(flags.toByte()).seekStart(pos) - writeUByte(0u) - writeUByte(0u) - return output.seekStart(0) + writeByte(0) + writeByte(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 - output.seekStart(flagOffset) - output.writeUByte(flags.toUByte()) - output.seekStart(pos) - output.writeUByte(0u) // Placeholder for the next flags byte. + val pos = dst.position + dst.seekStart(flagOffset) + dst.writeByte(flags.toByte()) + dst.seekStart(pos) + 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) { - output.writeUByte(data) + private fun addByte(value: Byte) { + writeControlBit(1) + dst.writeByte(value) } - private fun writeUByte(data: Int) { - output.writeUByte(data.toUByte()) + private fun copy(offset: Int, size: Int) { + 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)) - writeUByte((offset ushr 5) and 0xFF) + writeByte(((offset shl 3) and 0xF8) or ((size - 2) and 0b111)) + writeByte((offset ushr 5)) } else { - writeUByte((offset shl 3) and 0xF8) - writeUByte((offset ushr 5) and 0xFF) - writeUByte(size - 1) + writeByte((offset shl 3) and 0xF8) + writeByte((offset ushr 5)) + writeByte(size - 1) } } + + private fun writeByte(data: Int) { + dst.writeByte(data.toByte()) + } } diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/compression/prs/PrsDecompress.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/compression/prs/PrsDecompress.kt index cc5cd32d..72348915 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/compression/prs/PrsDecompress.kt +++ b/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 { - try { - val decompressor = PrsDecompressor(cursor) - var i = 0 +// This code uses signed types for better KJS performance. In KJS unsigned types are always boxed. - while (true) { - if (decompressor.readFlagBit() == 1) { - // Single byte copy. - decompressor.copyU8() - } else { - // Multi byte copy. - var length: Int - var offset: Int +fun prsDecompress(cursor: Cursor): PwResult = + PrsDecompressor(cursor).decompress() - if (decompressor.readFlagBit() == 0) { - // Short copy. - length = (decompressor.readFlagBit() shl 1) or decompressor.readFlagBit() - 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(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 class PrsDecompressor(private val src: Cursor) { + private val dst: WritableCursor = + Buffer.withCapacity(6 * src.size, src.endianness).cursor() private var flags = 0 private var flagBitsLeft = 0 - fun readFlagBit(): Int { + fun decompress(): PwResult { + 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(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() { - dst.writeUByte(readU8()) + private fun copyByte() { + 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) { - "length was ${length}, should be between 1 and 256." + require(size in 1..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 - // times. - val bufSize = min(-offset, length) + // Size can be larger than -offset, in that case we copy -offset bytes size/-offset times. + val bufSize = min(-offset, size) 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)) } } diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/AbstractWritableCursor.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/AbstractWritableCursor.kt index 0d22e360..cd33ca13 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/AbstractWritableCursor.kt +++ b/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 world.phantasmal.lib.ZERO_U8 +import kotlin.experimental.and 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()) } diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/BufferCursor.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/BufferCursor.kt index 87b385a0..42c2d890 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/BufferCursor.kt +++ b/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." } } diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/Cursor.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/Cursor.kt index fa251960..3df6282c 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/Cursor.kt +++ b/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 } diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Bin.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Bin.kt index 7007ba99..9ec1e87d 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Bin.kt +++ b/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 language: UInt, + val questId: Int, + 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 language: UInt + val questId: Int + val language: Int val questName: String val shortDescription: String val longDescription: String if (format == BinFormat.DC_GC) { cursor.seek(1) - language = cursor.uByte().toUInt() - questId = cursor.uShort().toUInt() + language = cursor.byte().toInt() + 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() - language = cursor.uInt() + if (format == BinFormat.PC) { + 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) diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Dat.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Dat.kt index 72b7c3d9..eb4953d6 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Dat.kt +++ b/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 { - // Never on the stack. - var firstRegister: ValueSet? = null - - for (j in param.type.registerTuples.indices) { - val regTup = param.type.registerTuples[j] + for (j in param.type.registerTuple.indices) { + val regTup = param.type.registerTuple[j] + // Never on the stack. if (regTup.type is ILabelType) { - if (firstRegister == null) { - firstRegister = getStackValue(cfg, instruction, i) - } + val firstRegister = instruction.args[0].value as Int + val labelValues = getRegisterValue( + cfg, + instruction, + firstRegister + j, + ) - for (reg in firstRegister) { - val labelValues = getRegisterValue( - cfg, - instruction, - reg + j, - ) - - if (labelValues.size <= 10) { - for (label in labelValues) { - newLabels[label] = SegmentType.Instructions - } + if (labelValues.size <= 10) { + for (label in labelValues) { + newLabels[label] = SegmentType.Instructions } } } diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Quest.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Quest.kt index 18c5d51c..be95c9fa 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Quest.kt +++ b/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(), - language = bin.language.toInt(), + id = bin.questId, + language = bin.language, name = bin.questName, shortDescription = bin.shortDescription, longDescription = bin.longDescription, diff --git a/lib/src/commonTest/kotlin/world/phantasmal/lib/buffer/BufferTests.kt b/lib/src/commonTest/kotlin/world/phantasmal/lib/buffer/BufferTests.kt index fc205a49..c525c484 100644 --- a/lib/src/commonTest/kotlin/world/phantasmal/lib/buffer/BufferTests.kt +++ b/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)) } } } diff --git a/lib/src/commonTest/kotlin/world/phantasmal/lib/compression/prs/PrsCompressTests.kt b/lib/src/commonTest/kotlin/world/phantasmal/lib/compression/prs/PrsCompressTests.kt index 117b4782..e271793a 100644 --- a/lib/src/commonTest/kotlin/world/phantasmal/lib/compression/prs/PrsCompressTests.kt +++ b/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()) diff --git a/lib/src/commonTest/kotlin/world/phantasmal/lib/compression/prs/PrsDecompressTests.kt b/lib/src/commonTest/kotlin/world/phantasmal/lib/compression/prs/PrsDecompressTests.kt index ccae502d..ea570dfa 100644 --- a/lib/src/commonTest/kotlin/world/phantasmal/lib/compression/prs/PrsDecompressTests.kt +++ b/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) - - 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}." - ) - } - } + assertCursorEquals(cursor, decompressedCursor) } @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()) { - val expected = orig.byte() - val actual = test.byte() + private fun assertCursorEquals(expected: Cursor, actual: Cursor) { + while (expected.hasBytesLeft() && actual.hasBytesLeft()) { + val expectedByte = expected.byte() + val actualByte = actual.byte() - if (expected != actual) { + if (expectedByte != actualByte) { // Assert after check for performance. assertEquals( - expected, - actual, - "Got $actual, expected $expected at ${orig.position - 1}." + expectedByte, + actualByte, + "Got $actualByte, expected $expectedByte at ${expected.position - 1}." ) } } + + assertEquals(expected.size, actual.size) } } diff --git a/lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/BufferCursorTests.kt b/lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/BufferCursorTests.kt index d0d32ed5..93d57587 100644 --- a/lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/BufferCursorTests.kt +++ b/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) } diff --git a/lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/CursorTests.kt b/lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/CursorTests.kt index fa5617f5..a3cc80f2 100644 --- a/lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/CursorTests.kt +++ b/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() { - f32(Endianness.Little) - f32(Endianness.Big) + fun float() { + float(Endianness.Little) + 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] } diff --git a/lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/WritableCursorTests.kt b/lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/WritableCursorTests.kt index f59c1da6..674c9ee7 100644 --- a/lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/WritableCursorTests.kt +++ b/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() { - writeF32(Endianness.Little) - writeF32(Endianness.Big) + fun writeFloat() { + writeFloat(Endianness.Little) + 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) } diff --git a/lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/BinTests.kt b/lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/BinTests.kt new file mode 100644 index 00000000..d90f724e --- /dev/null +++ b/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 + ) + } +} diff --git a/lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/QuestTests.kt b/lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/QuestTests.kt new file mode 100644 index 00000000..031a9938 --- /dev/null +++ b/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]) + } +} diff --git a/lib/src/commonTest/resources/lost_heat_sword_gc.qst b/lib/src/commonTest/resources/lost_heat_sword_gc.qst new file mode 100644 index 00000000..6d338ea7 Binary files /dev/null and b/lib/src/commonTest/resources/lost_heat_sword_gc.qst differ diff --git a/lib/src/commonTest/resources/quest118_e.dat b/lib/src/commonTest/resources/quest118_e.dat new file mode 100644 index 00000000..c831c5b8 Binary files /dev/null and b/lib/src/commonTest/resources/quest118_e.dat differ diff --git a/lib/src/commonTest/resources/quest118_e_decompressed.bin b/lib/src/commonTest/resources/quest118_e_decompressed.bin index 2b560cce..7614fc45 100644 Binary files a/lib/src/commonTest/resources/quest118_e_decompressed.bin and b/lib/src/commonTest/resources/quest118_e_decompressed.bin differ diff --git a/lib/src/jsMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt b/lib/src/jsMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt index e112917e..67dde0db 100644 --- a/lib/src/jsMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt +++ b/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) } } diff --git a/lib/src/jvmMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt b/lib/src/jvmMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt index e99ae46d..a6026e4c 100644 --- a/lib/src/jvmMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt +++ b/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 }