From bab01061f061d197ece46d2f467ab2833e7c9daf Mon Sep 17 00:00:00 2001 From: Daan Vanden Bosch Date: Tue, 27 Oct 2020 22:55:05 +0100 Subject: [PATCH] Added JVM support for core and lib. --- core/build.gradle.kts | 16 +- .../kotlin/world/phantasmal/core/FastCast.kt | 3 - .../world/phantasmal/core/UnsafeCast.kt | 3 + .../core/disposable/TrackedDisposableTests.kt | 17 +- .../kotlin/world/phantasmal/core/FastCast.kt | 3 - .../world/phantasmal/core/UnsafeCast.kt | 3 + .../world/phantasmal/core/UnsafeCast.kt | 4 + lib/build.gradle.kts | 16 +- .../world/phantasmal/lib/assembly/Assembly.kt | 2 +- .../world/phantasmal/lib/buffer/Buffer.kt | 30 +-- .../lib/compression/prs/PrsCompress.kt | 45 +++-- .../lib/compression/prs/PrsDecompress.kt | 6 +- .../lib/cursor/AbstractWritableCursor.kt | 30 +-- .../phantasmal/lib/cursor/BufferCursor.kt | 88 ++++---- .../world/phantasmal/lib/cursor/Cursor.kt | 22 +- .../phantasmal/lib/cursor/WritableCursor.kt | 22 +- .../world/phantasmal/lib/fileFormats/Iff.kt | 4 +- .../phantasmal/lib/fileFormats/Vector.kt | 2 +- .../phantasmal/lib/fileFormats/ninja/Ninja.kt | 14 +- .../phantasmal/lib/fileFormats/ninja/Nj.kt | 75 +++---- .../phantasmal/lib/fileFormats/quest/Bin.kt | 18 +- .../phantasmal/lib/fileFormats/quest/Dat.kt | 42 ++-- .../lib/fileFormats/quest/ObjectCode.kt | 24 +-- .../lib/fileFormats/quest/QuestNpc.kt | 8 +- .../phantasmal/lib/buffer/BufferTests.kt | 10 +- .../lib/compression/prs/PrsCompressTests.kt | 8 +- .../lib/compression/prs/PrsDecompressTests.kt | 43 +++- .../lib/cursor/BufferCursorTests.kt | 24 +-- .../phantasmal/lib/cursor/CursorTests.kt | 58 +++--- .../lib/cursor/WritableCursorTests.kt | 72 +++---- lib/src/commonTest/resources/quest118_e.bin | Bin 0 -> 17511 bytes .../resources/quest118_e_decompressed.bin | Bin 0 -> 67383 bytes .../world/phantasmal/lib/buffer/Buffer.kt | 50 ++--- .../lib/cursor/ArrayBufferCursor.kt | 36 ++-- .../world/phantasmal/lib/test/TestUtils.kt | 5 +- .../world/phantasmal/lib/buffer/Buffer.kt | 188 ++++++++++++++++++ .../world/phantasmal/lib/test/TestUtils.kt | 22 ++ .../observable/value/DependentVal.kt | 6 +- .../observable/value/FlatTransformedVal.kt | 6 +- .../observable/value/list/FoldedVal.kt | 6 +- 40 files changed, 639 insertions(+), 392 deletions(-) delete mode 100644 core/src/commonMain/kotlin/world/phantasmal/core/FastCast.kt create mode 100644 core/src/commonMain/kotlin/world/phantasmal/core/UnsafeCast.kt delete mode 100644 core/src/jsMain/kotlin/world/phantasmal/core/FastCast.kt create mode 100644 core/src/jsMain/kotlin/world/phantasmal/core/UnsafeCast.kt create mode 100644 core/src/jvmMain/kotlin/world/phantasmal/core/UnsafeCast.kt create mode 100644 lib/src/commonTest/resources/quest118_e.bin create mode 100644 lib/src/commonTest/resources/quest118_e_decompressed.bin create mode 100644 lib/src/jvmMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt create mode 100644 lib/src/jvmTest/kotlin/world/phantasmal/lib/test/TestUtils.kt diff --git a/core/build.gradle.kts b/core/build.gradle.kts index 89366652..6d26a515 100644 --- a/core/build.gradle.kts +++ b/core/build.gradle.kts @@ -2,7 +2,6 @@ plugins { kotlin("multiplatform") } -val coroutinesVersion: String by project.ext val kotlinLoggingVersion: String by project.extra kotlin { @@ -10,10 +9,11 @@ kotlin { browser {} } + jvm() + sourceSets { commonMain { dependencies { - api("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion") api("io.github.microutils:kotlin-logging:$kotlinLoggingVersion") } } @@ -25,14 +25,16 @@ kotlin { } } - val jsTest by getting { + getByName("jsTest") { dependencies { implementation(kotlin("test-js")) } } + + getByName("jvmTest") { + dependencies { + implementation(kotlin("test-junit")) + } + } } } - -tasks.register("test") { - dependsOn("allTests") -} diff --git a/core/src/commonMain/kotlin/world/phantasmal/core/FastCast.kt b/core/src/commonMain/kotlin/world/phantasmal/core/FastCast.kt deleted file mode 100644 index 1b813a5e..00000000 --- a/core/src/commonMain/kotlin/world/phantasmal/core/FastCast.kt +++ /dev/null @@ -1,3 +0,0 @@ -package world.phantasmal.core - -expect fun Any?.fastCast(): T diff --git a/core/src/commonMain/kotlin/world/phantasmal/core/UnsafeCast.kt b/core/src/commonMain/kotlin/world/phantasmal/core/UnsafeCast.kt new file mode 100644 index 00000000..a8633c86 --- /dev/null +++ b/core/src/commonMain/kotlin/world/phantasmal/core/UnsafeCast.kt @@ -0,0 +1,3 @@ +package world.phantasmal.core + +expect fun T?.unsafeToNonNull(): T diff --git a/core/src/commonTest/kotlin/world/phantasmal/core/disposable/TrackedDisposableTests.kt b/core/src/commonTest/kotlin/world/phantasmal/core/disposable/TrackedDisposableTests.kt index 845ca75f..1b01900a 100644 --- a/core/src/commonTest/kotlin/world/phantasmal/core/disposable/TrackedDisposableTests.kt +++ b/core/src/commonTest/kotlin/world/phantasmal/core/disposable/TrackedDisposableTests.kt @@ -1,6 +1,5 @@ package world.phantasmal.core.disposable -import kotlinx.coroutines.Job import kotlin.test.Test import kotlin.test.assertEquals import kotlin.test.assertFalse @@ -11,7 +10,7 @@ class TrackedDisposableTests { fun count_should_go_up_when_created_and_down_when_disposed() { val initialCount = TrackedDisposable.disposableCount - val disposable = object : TrackedDisposable(DummyScope()) { + val disposable = object : TrackedDisposable() { override fun internalDispose() {} } @@ -26,7 +25,7 @@ class TrackedDisposableTests { fun double_dispose_should_not_increase_count() { val initialCount = TrackedDisposable.disposableCount - val disposable = object : TrackedDisposable(DummyScope()) { + val disposable = object : TrackedDisposable() { override fun internalDispose() {} } @@ -39,7 +38,7 @@ class TrackedDisposableTests { @Test fun disposed_property_should_be_set_correctly() { - val disposable = object : TrackedDisposable(DummyScope()) { + val disposable = object : TrackedDisposable() { override fun internalDispose() {} } @@ -49,14 +48,4 @@ class TrackedDisposableTests { assertTrue(disposable.disposed) } - - private class DummyScope : Scope { - override val coroutineContext = Job() - - override fun add(disposable: Disposable) { - // Do nothing. - } - - override fun scope(): Scope = throw NotImplementedError() - } } diff --git a/core/src/jsMain/kotlin/world/phantasmal/core/FastCast.kt b/core/src/jsMain/kotlin/world/phantasmal/core/FastCast.kt deleted file mode 100644 index 5e5d26b2..00000000 --- a/core/src/jsMain/kotlin/world/phantasmal/core/FastCast.kt +++ /dev/null @@ -1,3 +0,0 @@ -package world.phantasmal.core - -actual fun Any?.fastCast(): T = unsafeCast() diff --git a/core/src/jsMain/kotlin/world/phantasmal/core/UnsafeCast.kt b/core/src/jsMain/kotlin/world/phantasmal/core/UnsafeCast.kt new file mode 100644 index 00000000..d9b58907 --- /dev/null +++ b/core/src/jsMain/kotlin/world/phantasmal/core/UnsafeCast.kt @@ -0,0 +1,3 @@ +package world.phantasmal.core + +actual fun T?.unsafeToNonNull(): T = unsafeCast() diff --git a/core/src/jvmMain/kotlin/world/phantasmal/core/UnsafeCast.kt b/core/src/jvmMain/kotlin/world/phantasmal/core/UnsafeCast.kt new file mode 100644 index 00000000..bc1dbc3b --- /dev/null +++ b/core/src/jvmMain/kotlin/world/phantasmal/core/UnsafeCast.kt @@ -0,0 +1,4 @@ +package world.phantasmal.core + +@Suppress("UNCHECKED_CAST") +actual fun T?.unsafeToNonNull(): T = this as T diff --git a/lib/build.gradle.kts b/lib/build.gradle.kts index b2fc53b7..43a7ea18 100644 --- a/lib/build.gradle.kts +++ b/lib/build.gradle.kts @@ -13,6 +13,7 @@ buildscript { } } +val coroutinesVersion: String by project.extra val kotlinLoggingVersion: String by project.extra kotlin { @@ -26,6 +27,8 @@ kotlin { } } + jvm() + sourceSets { all { languageSettings.useExperimentalAnnotation("kotlin.ExperimentalUnsignedTypes") @@ -35,6 +38,7 @@ kotlin { kotlin.setSrcDirs(kotlin.srcDirs + file("build/generated-src/commonMain/kotlin")) dependencies { api(project(":core")) + api("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesVersion") api("io.github.microutils:kotlin-logging:$kotlinLoggingVersion") } } @@ -46,16 +50,18 @@ kotlin { } } - val jsTest by getting { + getByName("jsTest") { dependencies { implementation(kotlin("test-js")) } } - } -} -tasks.register("test") { - dependsOn("allTests") + getByName("jvmTest") { + dependencies { + implementation(kotlin("test-junit")) + } + } + } } val generateOpcodes = tasks.register("generateOpcodes") { diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/Assembly.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/Assembly.kt index 2312ebd9..9a5d9f6c 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/Assembly.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/Assembly.kt @@ -180,7 +180,7 @@ private class Assembler(private val assembly: List, private val manualSt seg.data.size += bytes.size for (i in bytes.indices) { - seg.data.setI8(i + oldSize, bytes[i]) + seg.data.setByte(i + oldSize, bytes[i]) } } diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt index a7874917..79c73ced 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt @@ -18,37 +18,37 @@ expect class Buffer { /** * Reads an unsigned 8-bit integer at the given offset. */ - fun getU8(offset: Int): UByte + fun getUByte(offset: Int): UByte /** * Reads an unsigned 16-bit integer at the given offset. */ - fun getU16(offset: Int): UShort + fun getUShort(offset: Int): UShort /** * Reads an unsigned 32-bit integer at the given offset. */ - fun getU32(offset: Int): UInt + fun getUInt(offset: Int): UInt /** * Reads a signed 8-bit integer at the given offset. */ - fun getI8(offset: Int): Byte + fun getByte(offset: Int): Byte /** * Reads a signed 16-bit integer at the given offset. */ - fun getI16(offset: Int): Short + fun getShort(offset: Int): Short /** * Reads a signed 32-bit integer at the given offset. */ - fun getI32(offset: Int): Int + fun getInt(offset: Int): Int /** * Reads a 32-bit floating point number at the given offset. */ - fun getF32(offset: Int): Float + fun getFloat(offset: Int): Float /** * Reads a UTF-16-encoded string at the given offset. @@ -63,37 +63,37 @@ expect class Buffer { /** * Writes an unsigned 8-bit integer at the given offset. */ - fun setU8(offset: Int, value: UByte): Buffer + fun setUByte(offset: Int, value: UByte): Buffer /** * Writes an unsigned 16-bit integer at the given offset. */ - fun setU16(offset: Int, value: UShort): Buffer + fun setUShort(offset: Int, value: UShort): Buffer /** * Writes an unsigned 32-bit integer at the given offset. */ - fun setU32(offset: Int, value: UInt): Buffer + fun setUInt(offset: Int, value: UInt): Buffer /** * Writes a signed 8-bit integer at the given offset. */ - fun setI8(offset: Int, value: Byte): Buffer + fun setByte(offset: Int, value: Byte): Buffer /** * Writes a signed 16-bit integer at the given offset. */ - fun setI16(offset: Int, value: Short): Buffer + fun setShort(offset: Int, value: Short): Buffer /** * Writes a signed 32-bit integer at the given offset. */ - fun setI32(offset: Int, value: Int): Buffer + fun setInt(offset: Int, value: Int): Buffer /** * Writes a 32-bit floating point number at the given offset. */ - fun setF32(offset: Int, value: Float): Buffer + fun setFloat(offset: Int, value: Float): Buffer /** * Writes 0 bytes to the entire buffer. @@ -103,7 +103,7 @@ expect class Buffer { /** * Writes [value] to every byte in the buffer. */ - fun fill(value: Byte): Buffer + fun fillByte(value: Byte): Buffer companion object { /** 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 49705a9f..9e33fa79 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 @@ -24,7 +24,10 @@ fun prsCompress(cursor: Cursor): Cursor { comparisonCursor.seekStart(i) var size = 0 - while (cursor.hasBytesLeft() && size <= 254 && cursor.u8() == comparisonCursor.u8()) { + while (cursor.hasBytesLeft() && + size <= 254 && + cursor.uByte() == comparisonCursor.uByte() + ) { size++ } @@ -41,7 +44,7 @@ fun prsCompress(cursor: Cursor): Cursor { } if (bestSize < 3) { - compressor.addU8(cursor.u8()) + compressor.addUByte(cursor.uByte()) } else { compressor.copy(bestOffset - cursor.position, bestSize) cursor.seek(bestSize) @@ -57,9 +60,9 @@ private class PrsCompressor(capacity: Int, endianness: Endianness) { private var flagBitsLeft = 0 private var flagOffset = 0 - fun addU8(value: UByte) { + fun addUByte(value: UByte) { writeControlBit(1) - writeU8(value) + writeUByte(value) } fun copy(offset: Int, size: Int) { @@ -76,10 +79,10 @@ private class PrsCompressor(capacity: Int, endianness: Endianness) { flags = flags ushr flagBitsLeft val pos = output.position - output.seekStart(flagOffset).writeU8(flags.toUByte()).seekStart(pos) + output.seekStart(flagOffset).writeUByte(flags.toUByte()).seekStart(pos) - writeU8(0u) - writeU8(0u) + writeUByte(0u) + writeUByte(0u) return output.seekStart(0) } @@ -89,37 +92,37 @@ private class PrsCompressor(capacity: Int, endianness: Endianness) { // position. val pos = output.position output.seekStart(flagOffset) - output.writeU8(flags.toUByte()) + output.writeUByte(flags.toUByte()) output.seekStart(pos) - output.writeU8(0u) // Placeholder for the next flags byte. + output.writeUByte(0u) // Placeholder for the next flags byte. flagOffset = pos flagBitsLeft = 8 } flags = flags ushr 1 - if (bit!=0) { + if (bit != 0) { flags = flags or 0x80 } flagBitsLeft-- } - private fun writeU8(data: UByte) { - output.writeU8(data) + private fun writeUByte(data: UByte) { + output.writeUByte(data) } - private fun writeU8(data: Int) { - output.writeU8(data.toUByte()) + private fun writeUByte(data: Int) { + output.writeUByte(data.toUByte()) } private fun shortCopy(offset: Int, size: Int) { val s = size - 2 writeControlBit(0) writeControlBit(0) - writeControlBit(((s ushr 1) and 1) ) + writeControlBit(((s ushr 1) and 1)) writeControlBit((s and 1)) - writeU8(offset and 0xFF) + writeUByte(offset and 0xFF) } private fun longCopy(offset: Int, size: Int) { @@ -127,12 +130,12 @@ private class PrsCompressor(capacity: Int, endianness: Endianness) { writeControlBit(1) if (size <= 9) { - writeU8(((offset shl 3) and 0xF8) or ((size - 2) and 0x07)) - writeU8((offset ushr 5) and 0xFF) + writeUByte(((offset shl 3) and 0xF8) or ((size - 2) and 0x07)) + writeUByte((offset ushr 5) and 0xFF) } else { - writeU8((offset shl 3) and 0xF8) - writeU8((offset ushr 5) and 0xFF) - writeU8(size - 1) + writeUByte((offset shl 3) and 0xF8) + writeUByte((offset ushr 5) and 0xFF) + writeUByte(size - 1) } } } 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 6f551a56..cc5cd32d 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 @@ -92,12 +92,12 @@ private class PrsDecompressor(cursor: Cursor) { } fun copyU8() { - dst.writeU8(readU8()) + dst.writeUByte(readU8()) } - fun readU8(): UByte = src.u8() + fun readU8(): UByte = src.uByte() - fun readU16(): UShort = src.u16() + fun readU16(): UShort = src.uShort() fun offsetCopy(offset: Int, length: Int) { require(offset in -8192..0) { 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 a02836df..0d22e360 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/AbstractWritableCursor.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/AbstractWritableCursor.kt @@ -42,7 +42,7 @@ protected constructor(protected val offset: Int) : WritableCursor { ): String = buildString { for (i in 0 until maxByteLength) { - val codePoint = u8() + val codePoint = uByte() if (nullTerminated && codePoint == ZERO_U8) { if (dropRemaining) { @@ -65,7 +65,7 @@ protected constructor(protected val offset: Int) : WritableCursor { val len = maxByteLength / 2 for (i in 0 until len) { - val codePoint = u16() + val codePoint = uShort() if (nullTerminated && codePoint == ZERO_U16) { if (dropRemaining) { @@ -79,45 +79,45 @@ protected constructor(protected val offset: Int) : WritableCursor { } } - override fun writeU8Array(array: UByteArray): WritableCursor { + override fun writeUByteArray(array: UByteArray): WritableCursor { val len = array.size requireSize(len) for (i in 0 until len) { - writeU8(array[i]) + writeUByte(array[i]) } return this } - override fun writeU16Array(array: UShortArray): WritableCursor { + override fun writeUShortArray(array: UShortArray): WritableCursor { val len = array.size requireSize(2 * len) for (i in 0 until len) { - writeU16(array[i]) + writeUShort(array[i]) } return this } - override fun writeU32Array(array: UIntArray): WritableCursor { + override fun writeUIntArray(array: UIntArray): WritableCursor { val len = array.size requireSize(4 * len) for (i in 0 until len) { - writeU32(array[i]) + writeUInt(array[i]) } return this } - override fun writeI32Array(array: IntArray): WritableCursor { + override fun writeIntArray(array: IntArray): WritableCursor { val len = array.size requireSize(4 * len) for (i in 0 until len) { - writeI32(array[i]) + writeInt(array[i]) } return this @@ -127,7 +127,7 @@ protected constructor(protected val offset: Int) : WritableCursor { val size = other.bytesLeft requireSize(size) for (i in 0 until size) { - writeI8(other.i8()) + writeByte(other.byte()) } return this @@ -139,13 +139,13 @@ protected constructor(protected val offset: Int) : WritableCursor { val len = min(byteLength, str.length) for (i in 0 until len) { - writeI8(str[i].toByte()) + writeByte(str[i].toByte()) } val padLen = byteLength - len for (i in 0 until padLen) { - writeI8(0) + writeByte(0) } return this @@ -158,13 +158,13 @@ protected constructor(protected val offset: Int) : WritableCursor { val len = min(maxLen, str.length) for (i in 0 until len) { - writeI16(str[i].toShort()) + writeShort(str[i].toShort()) } val padLen = maxLen - len for (i in 0 until padLen) { - writeI16(0) + writeShort(0) } return this 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 1b75fc9b..87b385a0 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/BufferCursor.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/BufferCursor.kt @@ -44,94 +44,94 @@ class BufferCursor( } } - override fun u8(): UByte { - val r = buffer.getU8(absolutePosition) + override fun uByte(): UByte { + val r = buffer.getUByte(absolutePosition) position++ return r } - override fun u16(): UShort { - val r = buffer.getU16(absolutePosition) + override fun uShort(): UShort { + val r = buffer.getUShort(absolutePosition) position += 2 return r } - override fun u32(): UInt { - val r = buffer.getU32(absolutePosition) + override fun uInt(): UInt { + val r = buffer.getUInt(absolutePosition) position += 4 return r } - override fun i8(): Byte { - val r = buffer.getI8(absolutePosition) + override fun byte(): Byte { + val r = buffer.getByte(absolutePosition) position++ return r } - override fun i16(): Short { - val r = buffer.getI16(absolutePosition) + override fun short(): Short { + val r = buffer.getShort(absolutePosition) position += 2 return r } - override fun i32(): Int { - val r = buffer.getI32(absolutePosition) + override fun int(): Int { + val r = buffer.getInt(absolutePosition) position += 4 return r } - override fun f32(): Float { - val r = buffer.getF32(absolutePosition) + override fun float(): Float { + val r = buffer.getFloat(absolutePosition) position += 4 return r } - override fun u8Array(n: Int): UByteArray { + override fun uByteArray(n: Int): UByteArray { requireSize(n) val array = UByteArray(n) for (i in 0 until n) { - array[i] = buffer.getU8(absolutePosition) + array[i] = buffer.getUByte(absolutePosition) position++ } return array } - override fun u16Array(n: Int): UShortArray { + override fun uShortArray(n: Int): UShortArray { requireSize(2 * n) val array = UShortArray(n) for (i in 0 until n) { - array[i] = buffer.getU16(absolutePosition) + array[i] = buffer.getUShort(absolutePosition) position += 2 } return array } - override fun u32Array(n: Int): UIntArray { + override fun uIntArray(n: Int): UIntArray { requireSize(4 * n) val array = UIntArray(n) for (i in 0 until n) { - array[i] = buffer.getU32(absolutePosition) + array[i] = buffer.getUInt(absolutePosition) position += 4 } return array } - override fun i32Array(n: Int): IntArray { + override fun intArray(n: Int): IntArray { requireSize(4 * n) val array = IntArray(n) for (i in 0 until n) { - array[i] = buffer.getI32(absolutePosition) + array[i] = buffer.getInt(absolutePosition) position += 4 } @@ -150,73 +150,73 @@ class BufferCursor( return wrapper } - override fun writeU8(value: UByte): WritableCursor { + override fun writeUByte(value: UByte): WritableCursor { ensureSpace(1) - buffer.setU8(absolutePosition, value) + buffer.setUByte(absolutePosition, value) position++ return this } - override fun writeU16(value: UShort): WritableCursor { + override fun writeUShort(value: UShort): WritableCursor { ensureSpace(2) - buffer.setU16(absolutePosition, value) + buffer.setUShort(absolutePosition, value) position += 2 return this } - override fun writeU32(value: UInt): WritableCursor { + override fun writeUInt(value: UInt): WritableCursor { ensureSpace(4) - buffer.setU32(absolutePosition, value) + buffer.setUInt(absolutePosition, value) position += 4 return this } - override fun writeI8(value: Byte): WritableCursor { + override fun writeByte(value: Byte): WritableCursor { ensureSpace(1) - buffer.setI8(absolutePosition, value) + buffer.setByte(absolutePosition, value) position++ return this } - override fun writeI16(value: Short): WritableCursor { + override fun writeShort(value: Short): WritableCursor { ensureSpace(2) - buffer.setI16(absolutePosition, value) + buffer.setShort(absolutePosition, value) position += 2 return this } - override fun writeI32(value: Int): WritableCursor { + override fun writeInt(value: Int): WritableCursor { ensureSpace(4) - buffer.setI32(absolutePosition, value) + buffer.setInt(absolutePosition, value) position += 4 return this } - override fun writeF32(value: Float): WritableCursor { + override fun writeFloat(value: Float): WritableCursor { ensureSpace(4) - buffer.setF32(absolutePosition, value) + buffer.setFloat(absolutePosition, value) position += 4 return this } - override fun writeU8Array(array: UByteArray): WritableCursor { + override fun writeUByteArray(array: UByteArray): WritableCursor { ensureSpace(array.size) - return super.writeU8Array(array) + return super.writeUByteArray(array) } - override fun writeU16Array(array: UShortArray): WritableCursor { + override fun writeUShortArray(array: UShortArray): WritableCursor { ensureSpace(2 * array.size) - return super.writeU16Array(array) + return super.writeUShortArray(array) } - override fun writeU32Array(array: UIntArray): WritableCursor { + override fun writeUIntArray(array: UIntArray): WritableCursor { ensureSpace(4 * array.size) - return super.writeU32Array(array) + return super.writeUIntArray(array) } - override fun writeI32Array(array: IntArray): WritableCursor { + override fun writeIntArray(array: IntArray): WritableCursor { ensureSpace(4 * array.size) - return super.writeI32Array(array) + return super.writeIntArray(array) } override fun writeCursor(other: Cursor): WritableCursor { 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 a73a5ca9..fa251960 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/Cursor.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/Cursor.kt @@ -48,57 +48,57 @@ interface Cursor { /** * Reads an unsigned 8-bit integer and increments position by 1. */ - fun u8(): UByte + fun uByte(): UByte /** * Reads an unsigned 16-bit integer and increments position by 2. */ - fun u16(): UShort + fun uShort(): UShort /** * Reads an unsigned 32-bit integer and increments position by 4. */ - fun u32(): UInt + fun uInt(): UInt /** * Reads an signed 8-bit integer and increments position by 1. */ - fun i8(): Byte + fun byte(): Byte /** * Reads a signed 16-bit integer and increments position by 2. */ - fun i16(): Short + fun short(): Short /** * Reads a signed 32-bit integer and increments position by 4. */ - fun i32(): Int + fun int(): Int /** * Reads a 32-bit floating point number and increments position by 4. */ - fun f32(): Float + fun float(): Float /** * Reads [n] unsigned 8-bit integers and increments position by [n]. */ - fun u8Array(n: Int): UByteArray + fun uByteArray(n: Int): UByteArray /** * Reads [n] unsigned 16-bit integers and increments position by 2[n]. */ - fun u16Array(n: Int): UShortArray + fun uShortArray(n: Int): UShortArray /** * Reads [n] unsigned 32-bit integers and increments position by 4[n]. */ - fun u32Array(n: Int): UIntArray + fun uIntArray(n: Int): UIntArray /** * Reads [n] signed 32-bit integers and increments position by 4[n]. */ - fun i32Array(n: Int): IntArray + fun intArray(n: Int): IntArray /** * Consumes a variable number of bytes. diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/WritableCursor.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/WritableCursor.kt index fa8fec6c..32846d1d 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/WritableCursor.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/WritableCursor.kt @@ -15,60 +15,60 @@ interface WritableCursor : Cursor { /** * Writes an unsigned 8-bit integer and increments position by 1. */ - fun writeU8(value: UByte): WritableCursor + fun writeUByte(value: UByte): WritableCursor /** * Writes an unsigned 16-bit integer and increments position by 2. */ - fun writeU16(value: UShort): WritableCursor + fun writeUShort(value: UShort): WritableCursor /** * Writes an unsigned 32-bit integer and increments position by 4. */ - fun writeU32(value: UInt): WritableCursor + fun writeUInt(value: UInt): WritableCursor /** * Writes a signed 8-bit integer and increments position by 1. */ - fun writeI8(value: Byte): WritableCursor + fun writeByte(value: Byte): WritableCursor /** * Writes a signed 16-bit integer and increments position by 2. */ - fun writeI16(value: Short): WritableCursor + fun writeShort(value: Short): WritableCursor /** * Writes a signed 32-bit integer and increments position by 4. */ - fun writeI32(value: Int): WritableCursor + fun writeInt(value: Int): WritableCursor /** * Writes a 32-bit floating point number and increments position by 4. */ - fun writeF32(value: Float): WritableCursor + fun writeFloat(value: Float): WritableCursor /** * Writes an array of unsigned 8-bit integers and increments position by the array's length. */ - fun writeU8Array(array: UByteArray): WritableCursor + fun writeUByteArray(array: UByteArray): WritableCursor /** * Writes an array of unsigned 16-bit integers and increments position by twice the array's * length. */ - fun writeU16Array(array: UShortArray): WritableCursor + fun writeUShortArray(array: UShortArray): WritableCursor /** * Writes an array of unsigned 32-bit integers and increments position by four times the array's * length. */ - fun writeU32Array(array: UIntArray): WritableCursor + fun writeUIntArray(array: UIntArray): WritableCursor /** * Writes an array of signed 32-bit integers and increments position by four times the array's * length. */ - fun writeI32Array(array: IntArray): WritableCursor + fun writeIntArray(array: IntArray): WritableCursor /** * Writes the contents of the given cursor from its position to its end. Increments this diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/Iff.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/Iff.kt index 55a0a60e..3c99bd4e 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/Iff.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/Iff.kt @@ -34,9 +34,9 @@ private fun parse( var corrupted = false while (cursor.bytesLeft >= 8) { - val type = cursor.i32() + val type = cursor.int() val sizePos = cursor.position - val size = cursor.i32() + val size = cursor.int() if (size > cursor.bytesLeft) { corrupted = true diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/Vector.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/Vector.kt index af9a25da..caf90cb0 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/Vector.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/Vector.kt @@ -6,4 +6,4 @@ class Vec2(val x: Float, val y: Float) class Vec3(val x: Float, val y: Float, val z: Float) -fun Cursor.vec3F32(): Vec3 = Vec3(f32(), f32(), f32()) +fun Cursor.vec3F32(): Vec3 = Vec3(float(), float(), float()) diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/ninja/Ninja.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/ninja/Ninja.kt index 3efc154e..c5bf7027 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/ninja/Ninja.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/ninja/Ninja.kt @@ -62,7 +62,7 @@ private fun parseSiblingObjects( parse_model: (cursor: Cursor, context: Context) -> Model, context: Context, ): List> { - val evalFlags = cursor.u32() + val evalFlags = cursor.uInt() val noTranslate = (evalFlags and 0b1u) != 0u val noRotate = (evalFlags and 0b10u) != 0u val noScale = (evalFlags and 0b100u) != 0u @@ -72,16 +72,16 @@ private fun parseSiblingObjects( val skip = (evalFlags and 0b1000000u) != 0u val shapeSkip = (evalFlags and 0b10000000u) != 0u - val modelOffset = cursor.i32() + val modelOffset = cursor.int() val pos = cursor.vec3F32() val rotation = Vec3( - angleToRad(cursor.i32()), - angleToRad(cursor.i32()), - angleToRad(cursor.i32()), + angleToRad(cursor.int()), + angleToRad(cursor.int()), + angleToRad(cursor.int()), ) val scale = cursor.vec3F32() - val childOffset = cursor.i32() - val siblingOffset = cursor.i32() + val childOffset = cursor.int() + val siblingOffset = cursor.int() val model = if (modelOffset == 0) { null diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/ninja/Nj.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/ninja/Nj.kt index 346081cf..106bc98f 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/ninja/Nj.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/ninja/Nj.kt @@ -123,10 +123,10 @@ class NjcmErgb( ) fun parseNjcmModel(cursor: Cursor, cachedChunkOffsets: MutableMap): NjcmModel { - val vlistOffset = cursor.i32() // Vertex list - val plistOffset = cursor.i32() // Triangle strip index list + val vlistOffset = cursor.int() // Vertex list + val plistOffset = cursor.int() // Triangle strip index list val boundingSphereCenter = cursor.vec3F32() - val boundingSphereRadius = cursor.f32() + val boundingSphereRadius = cursor.float() val vertices: MutableList = mutableListOf() val meshes: MutableList = mutableListOf() @@ -156,6 +156,7 @@ fun parseNjcmModel(cursor: Cursor, cachedChunkOffsets: MutableMap): var dstAlpha: UByte? = null for (chunk in parseChunks(cursor, cachedChunkOffsets, false)) { + @Suppress("UNUSED_VALUE") // Ignore useless warning due to compiler bug. when (chunk) { is NjcmChunk.Bits -> { srcAlpha = chunk.srcAlpha @@ -210,8 +211,8 @@ private fun parseChunks( var loop = true while (loop) { - val typeId = cursor.u8() - val flags = cursor.u8() + val typeId = cursor.uByte() + val flags = cursor.uByte() val flagsUInt = flags.toUInt() val chunkStartPosition = cursor.position var size = 0 @@ -254,7 +255,7 @@ private fun parseChunks( } in 8..9 -> { size = 2 - val textureBitsAndId = cursor.u16().toUInt() + val textureBitsAndId = cursor.uShort().toUInt() chunks.add(NjcmChunk.Tiny( typeId, @@ -269,7 +270,7 @@ private fun parseChunks( )) } in 17..31 -> { - size = 2 + 2 * cursor.i16() + size = 2 + 2 * cursor.short() var diffuse: NjcmArgb? = null var ambient: NjcmArgb? = null @@ -277,28 +278,28 @@ private fun parseChunks( if ((flagsUInt and 0b1u) != 0u) { diffuse = NjcmArgb( - b = cursor.u8().toFloat() / 255f, - g = cursor.u8().toFloat() / 255f, - r = cursor.u8().toFloat() / 255f, - a = cursor.u8().toFloat() / 255f, + b = cursor.uByte().toFloat() / 255f, + g = cursor.uByte().toFloat() / 255f, + r = cursor.uByte().toFloat() / 255f, + a = cursor.uByte().toFloat() / 255f, ) } if ((flagsUInt and 0b10u) != 0u) { ambient = NjcmArgb( - b = cursor.u8().toFloat() / 255f, - g = cursor.u8().toFloat() / 255f, - r = cursor.u8().toFloat() / 255f, - a = cursor.u8().toFloat() / 255f, + b = cursor.uByte().toFloat() / 255f, + g = cursor.uByte().toFloat() / 255f, + r = cursor.uByte().toFloat() / 255f, + a = cursor.uByte().toFloat() / 255f, ) } if ((flagsUInt and 0b100u) != 0u) { specular = NjcmErgb( - b = cursor.u8(), - g = cursor.u8(), - r = cursor.u8(), - e = cursor.u8(), + b = cursor.uByte(), + g = cursor.uByte(), + r = cursor.uByte(), + e = cursor.uByte(), ) } @@ -312,20 +313,20 @@ private fun parseChunks( )) } in 32..50 -> { - size = 2 + 4 * cursor.i16() + size = 2 + 4 * cursor.short() chunks.add(NjcmChunk.Vertex( typeId, vertices = parseVertexChunk(cursor, typeId, flags), )) } in 56..58 -> { - size = 2 + 2 * cursor.i16() + size = 2 + 2 * cursor.short() chunks.add(NjcmChunk.Volume( typeId, )) } in 64..75 -> { - size = 2 + 2 * cursor.i16() + size = 2 + 2 * cursor.short() chunks.add(NjcmChunk.Strip( typeId, triangleStrips = parseTriangleStripChunk(cursor, typeId, flags), @@ -337,7 +338,7 @@ private fun parseChunks( loop = false } else -> { - size = 2 + 2 * cursor.i16() + size = 2 + 2 * cursor.short() chunks.add(NjcmChunk.Unknown( typeId, )) @@ -359,8 +360,8 @@ private fun parseVertexChunk( val boneWeightStatus = flags and 0b11u val calcContinue = (flags and 0x80u) != ZERO_U8 - val index = cursor.u16() - val vertexCount = cursor.u16() + val index = cursor.uShort() + val vertexCount = cursor.uShort() val vertices: MutableList = mutableListOf() @@ -385,8 +386,8 @@ private fun parseVertexChunk( if (chunkTypeId == (37u).toUByte()) { // NJDCVNF // NinjaFlags32 - vertexIndex = index + cursor.u16() - boneWeight = cursor.u16().toFloat() / 255f + vertexIndex = index + cursor.uShort() + boneWeight = cursor.uShort().toFloat() / 255f } else { // Skip user flags and material information. cursor.seek(4) @@ -401,8 +402,8 @@ private fun parseVertexChunk( if (chunkTypeId == (44u).toUByte()) { // NJDCVVNNF // NinjaFlags32 - vertexIndex = index + cursor.u16() - boneWeight = cursor.u16().toFloat() / 255f + vertexIndex = index + cursor.uShort() + boneWeight = cursor.uShort().toFloat() / 255f } else { // Skip user flags and material information. cursor.seek(4) @@ -410,7 +411,7 @@ private fun parseVertexChunk( } in 48..50 -> { // 32-Bit vertex normal in format: reserved(2)|x(10)|y(10)|z(10) - val n = cursor.u32() + val n = cursor.uInt() normal = Vec3( ((n shr 20) and 0x3ffu).toFloat() / 0x3ff, ((n shr 10) and 0x3ffu).toFloat() / 0x3ff, @@ -450,7 +451,7 @@ private fun parseTriangleStripChunk( val flatShading = (flags and 0b100000u) != ZERO_U8 val environmentMapping = (flags and 0b1000000u) != ZERO_U8 - val userOffsetAndStripCount = cursor.u16() + val userOffsetAndStripCount = cursor.uShort() val userFlagsSize = (userOffsetAndStripCount.toUInt() shr 14).toInt() val stripCount = userOffsetAndStripCount and 0x3fffu @@ -490,17 +491,17 @@ private fun parseTriangleStripChunk( val strips: MutableList = mutableListOf() repeat(stripCount.toInt()) { - val windingFlagAndIndexCount = cursor.i16() + val windingFlagAndIndexCount = cursor.short() val clockwiseWinding = windingFlagAndIndexCount < 1 val indexCount = abs(windingFlagAndIndexCount.toInt()) val vertices: MutableList = mutableListOf() for (j in 0..indexCount) { - val index = cursor.u16() + val index = cursor.uShort() val texCoords = if (hasTexCoords) { - Vec2(cursor.u16().toFloat() / 255f, cursor.u16().toFloat() / 255f) + Vec2(cursor.uShort().toFloat() / 255f, cursor.uShort().toFloat() / 255f) } else null // Ignore ARGB8888 color. @@ -510,9 +511,9 @@ private fun parseTriangleStripChunk( val normal = if (hasNormal) { Vec3( - cursor.u16().toFloat() / 255f, - cursor.u16().toFloat() / 255f, - cursor.u16().toFloat() / 255f, + cursor.uShort().toFloat() / 255f, + cursor.uShort().toFloat() / 255f, + cursor.uShort().toFloat() / 255f, ) } else null 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 9da37b96..7007ba99 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 @@ -40,9 +40,9 @@ enum class BinFormat { } fun parseBin(cursor: Cursor): BinFile { - val objectCodeOffset = cursor.i32() - val labelOffsetTableOffset = cursor.i32() // Relative offsets - val size = cursor.i32() + val objectCodeOffset = cursor.int() + val labelOffsetTableOffset = cursor.int() // Relative offsets + val size = cursor.int() cursor.seek(4) // Always seems to be 0xFFFFFFFF. val format = when (objectCodeOffset) { @@ -65,14 +65,14 @@ fun parseBin(cursor: Cursor): BinFile { if (format == BinFormat.DC_GC) { cursor.seek(1) - language = cursor.u8().toUInt() - questId = cursor.u16().toUInt() + language = cursor.uByte().toUInt() + questId = cursor.uShort().toUInt() 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.u32() - language = cursor.u32() + questId = cursor.uInt() + language = cursor.uInt() questName = cursor.stringUtf16(64, nullTerminated = true, dropRemaining = true) shortDescription = cursor.stringUtf16(256, nullTerminated = true, dropRemaining = true) longDescription = cursor.stringUtf16(576, nullTerminated = true, dropRemaining = true) @@ -84,7 +84,7 @@ fun parseBin(cursor: Cursor): BinFile { val shopItems = if (format == BinFormat.BB) { cursor.seek(4) // Skip padding. - cursor.u32Array(932) + cursor.uIntArray(932) } else { UIntArray(0) } @@ -92,7 +92,7 @@ fun parseBin(cursor: Cursor): BinFile { val labelOffsetCount = (cursor.size - labelOffsetTableOffset) / 4 val labelOffsets = cursor .seekStart(labelOffsetTableOffset) - .i32Array(labelOffsetCount) + .intArray(labelOffsetCount) val objectCode = cursor .seekStart(objectCodeOffset) 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 67a63db7..72b7c3d9 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 @@ -70,10 +70,10 @@ fun parseDat(cursor: Cursor): DatFile { val unknowns = mutableListOf() while (cursor.hasBytesLeft()) { - val entityType = cursor.i32() - val totalSize = cursor.i32() - val areaId = cursor.i32() - val entitiesSize = cursor.i32() + val entityType = cursor.int() + val totalSize = cursor.int() + val areaId = cursor.int() + val entitiesSize = cursor.int() if (entityType == 0) { break @@ -95,7 +95,7 @@ fun parseDat(cursor: Cursor): DatFile { totalSize, areaId, entitiesSize, - data = cursor.u8Array(entitiesSize), + data = cursor.uByteArray(entitiesSize), )) } } @@ -133,11 +133,11 @@ private fun parseEntities( } private fun parseEvents(cursor: Cursor, areaId: Int, events: MutableList) { - val actionsOffset = cursor.i32() + val actionsOffset = cursor.int() cursor.seek(4) // Always 0x10 - val eventCount = cursor.i32() + val eventCount = cursor.int() cursor.seek(3) // Always 0 - val eventType = cursor.u8() + val eventType = cursor.uByte() require(eventType != (0x32u).toUByte()) { "Can't parse challenge mode quests yet." @@ -148,13 +148,13 @@ private fun parseEvents(cursor: Cursor, areaId: Int, events: MutableList = if (eventActionsOffset < actionsCursor.size) { @@ -185,7 +185,7 @@ private fun parseEvents(cursor: Cursor, areaId: Int, events: MutableList { val actions = mutableListOf() outer@ while (cursor.hasBytesLeft()) { - when (val type = cursor.u8().toInt()) { + when (val type = cursor.uByte().toInt()) { 1 -> break@outer EVENT_ACTION_SPAWN_NPCS -> actions.add(DatEventAction.SpawnNpcs( - sectionId = cursor.u16(), - appearFlag = cursor.u16(), + sectionId = cursor.uShort(), + appearFlag = cursor.uShort(), )) EVENT_ACTION_UNLOCK -> actions.add(DatEventAction.Unlock( - doorId = cursor.u16(), + doorId = cursor.uShort(), )) EVENT_ACTION_LOCK -> actions.add(DatEventAction.Lock( - doorId = cursor.u16(), + doorId = cursor.uShort(), )) EVENT_ACTION_TRIGGER_EVENT -> actions.add(DatEventAction.TriggerEvent( - eventId = cursor.u32(), + eventId = cursor.uInt(), )) else -> { diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/ObjectCode.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/ObjectCode.kt index 962c233f..fea8ecdd 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/ObjectCode.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/ObjectCode.kt @@ -387,10 +387,10 @@ private fun parseInstructionsSegment( while (cursor.position < endOffset) { // Parse the opcode. - val mainOpcode = cursor.u8() + val mainOpcode = cursor.uByte() val fullOpcode = when (mainOpcode.toInt()) { - 0xF8, 0xF9 -> ((mainOpcode.toInt() shl 8) or cursor.u8().toInt()) + 0xF8, 0xF9 -> ((mainOpcode.toInt() shl 8) or cursor.uByte().toInt()) else -> mainOpcode.toInt() } @@ -496,23 +496,23 @@ private fun parseInstructionArguments( for (param in opcode.params) { when (param.type) { is ByteType -> - args.add(Arg(cursor.u8().toInt())) + args.add(Arg(cursor.uByte().toInt())) is WordType -> - args.add(Arg(cursor.u16().toInt())) + args.add(Arg(cursor.uShort().toInt())) is DWordType -> - args.add(Arg(cursor.i32())) + args.add(Arg(cursor.int())) is FloatType -> - args.add(Arg(cursor.f32())) + args.add(Arg(cursor.float())) is LabelType, is ILabelType, is DLabelType, is SLabelType, -> { - args.add(Arg(cursor.u16().toInt())) + args.add(Arg(cursor.uShort().toInt())) } is StringType -> { @@ -536,20 +536,20 @@ private fun parseInstructionArguments( is ILabelVarType -> { varargCount++ - val argSize = cursor.u8() - args.addAll(cursor.u16Array(argSize.toInt()).map { Arg(it.toInt()) }) + val argSize = cursor.uByte() + args.addAll(cursor.uShortArray(argSize.toInt()).map { Arg(it.toInt()) }) } is RegRefType, is RegTupRefType, -> { - args.add(Arg(cursor.u8().toInt())) + args.add(Arg(cursor.uByte().toInt())) } is RegRefVarType -> { varargCount++ - val argSize = cursor.u8() - args.addAll(cursor.u8Array(argSize.toInt()).map { Arg(it.toInt()) }) + val argSize = cursor.uByte() + args.addAll(cursor.uByteArray(argSize.toInt()).map { Arg(it.toInt()) }) } else -> error("Parameter type ${param.type} not implemented.") diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/QuestNpc.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/QuestNpc.kt index ad1e512f..56c9f62e 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/QuestNpc.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/QuestNpc.kt @@ -8,15 +8,15 @@ class QuestNpc(var episode: Episode, var areaId: Int, val data: Buffer) { * Only seems to be valid for non-enemies. */ var scriptLabel: Int - get() = data.getF32(60).roundToInt() + get() = data.getFloat(60).roundToInt() set(value) { - data.setF32(60, value.toFloat()) + data.setFloat(60, value.toFloat()) } var skin: Int - get() = data.getI32(64) + get() = data.getInt(64) set(value) { - data.setI32(64, value) + data.setInt(64, value) } init { 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 8d0fa4ff..fc205a49 100644 --- a/lib/src/commonTest/kotlin/world/phantasmal/lib/buffer/BufferTests.kt +++ b/lib/src/commonTest/kotlin/world/phantasmal/lib/buffer/BufferTests.kt @@ -38,25 +38,25 @@ class BufferTests { assertEquals(101, buffer.size) assertTrue(buffer.capacity >= 101) - buffer.setU8(100, (0xABu).toUByte()) + buffer.setUByte(100, (0xABu).toUByte()) - assertEquals(0xABu, buffer.getU8(100).toUInt()) + assertEquals(0xABu, buffer.getUByte(100).toUInt()) } @Test fun fill_and_zero() { val buffer = Buffer.withSize(100) - buffer.fill(100) + buffer.fillByte(100) for (i in 0 until buffer.size) { - assertEquals(100u, buffer.getU8(i)) + assertEquals(100u, buffer.getUByte(i)) } buffer.zero() for (i in 0 until buffer.size) { - assertEquals(0u, buffer.getU8(i)) + assertEquals(0u, buffer.getUByte(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 c78cdfd3..117b4782 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 @@ -17,7 +17,7 @@ class PrsCompressTests { @Test fun edge_case_1_byte() { - val compressed = prsCompress(Buffer.withSize(1).fill(111).cursor()) + val compressed = prsCompress(Buffer.withSize(1).fillByte(111).cursor()) assertEquals(4, compressed.size) } @@ -38,7 +38,7 @@ class PrsCompressTests { @Test fun best_case() { - val compressed = prsCompress(Buffer.withSize(10_000).fill(127).cursor()) + val compressed = prsCompress(Buffer.withSize(10_000).fillByte(127).cursor()) assertEquals(475, compressed.size) } @@ -49,7 +49,7 @@ class PrsCompressTests { val buffer = Buffer.withSize(10_000) for (i in 0 until buffer.size step 4) { - buffer.setU32(i, random.nextUInt()) + buffer.setUInt(i, random.nextUInt()) } val compressed = prsCompress(buffer.cursor()) @@ -64,7 +64,7 @@ class PrsCompressTests { val buffer = Buffer.withSize(1000 * pattern.size) for (i in 0 until buffer.size) { - buffer.setI8(i, (pattern[i % pattern.size] + random.nextInt(10)).toByte()) + buffer.setByte(i, (pattern[i % pattern.size] + random.nextInt(10)).toByte()) } 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 40b27f51..ccae502d 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 @@ -2,8 +2,9 @@ package world.phantasmal.lib.compression.prs import world.phantasmal.lib.buffer.Buffer import world.phantasmal.lib.cursor.cursor +import world.phantasmal.lib.test.asyncTest +import world.phantasmal.lib.test.readFile import kotlin.random.Random -import kotlin.random.nextUInt import kotlin.test.Test import kotlin.test.assertEquals @@ -15,7 +16,7 @@ class PrsDecompressTests { @Test fun edge_case_1_byte() { - testWithBuffer(Buffer.withSize(1).fill(111)) + testWithBuffer(Buffer.withSize(1).fillByte(111)) } @Test @@ -30,7 +31,7 @@ class PrsDecompressTests { @Test fun best_case() { - testWithBuffer(Buffer.withSize(10_000).fill(127)) + testWithBuffer(Buffer.withSize(10_000).fillByte(127)) } @Test @@ -39,7 +40,7 @@ class PrsDecompressTests { val buffer = Buffer.withSize(10_000) for (i in 0 until buffer.size step 4) { - buffer.setU32(i, random.nextUInt()) + buffer.setInt(i, random.nextInt()) } testWithBuffer(buffer) @@ -52,7 +53,7 @@ class PrsDecompressTests { val buffer = Buffer.withSize(1000 * pattern.size) for (i in 0 until buffer.size) { - buffer.setI8(i, (pattern[i % pattern.size] + random.nextInt(10)).toByte()) + buffer.setByte(i, (pattern[i % pattern.size] + random.nextInt(10)).toByte()) } testWithBuffer(buffer) @@ -68,8 +69,8 @@ class PrsDecompressTests { assertEquals(cursor.size, decompressedCursor.size) while (cursor.hasBytesLeft()) { - val expected = cursor.i8() - val actual = decompressedCursor.i8() + val expected = cursor.byte() + val actual = decompressedCursor.byte() if (expected != actual) { // Assert after check for performance. @@ -81,4 +82,32 @@ class PrsDecompressTests { } } } + + @Test + fun decompress_towards_the_future() = asyncTest { + prsDecompress(readFile("/quest118_e.bin")).unwrap() + } + + @Test + fun compress_and_decompress_towards_the_future() = asyncTest { + val orig = readFile("/quest118_e_decompressed.bin") + val test = prsDecompress(prsCompress(orig)).unwrap() + orig.seekStart(0) + + assertEquals(orig.size, test.size) + + while (orig.hasBytesLeft()) { + val expected = orig.byte() + val actual = test.byte() + + if (expected != actual) { + // Assert after check for performance. + assertEquals( + expected, + actual, + "Got $actual, expected $expected at ${orig.position - 1}." + ) + } + } + } } 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 8dc40df6..d0d32ed5 100644 --- a/lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/BufferCursorTests.kt +++ b/lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/BufferCursorTests.kt @@ -11,38 +11,38 @@ class BufferCursorTests : WritableCursorTests() { @Test fun writeU8_increases_size_correctly() { - testIntegerWriteSize(1, { writeU8(it.toUByte()) }, Endianness.Little) - testIntegerWriteSize(1, { writeU8(it.toUByte()) }, Endianness.Big) + testIntegerWriteSize(1, { writeUByte(it.toUByte()) }, Endianness.Little) + testIntegerWriteSize(1, { writeUByte(it.toUByte()) }, Endianness.Big) } @Test fun writeU16_increases_size_correctly() { - testIntegerWriteSize(2, { writeU16(it.toUShort()) }, Endianness.Little) - testIntegerWriteSize(2, { writeU16(it.toUShort()) }, Endianness.Big) + testIntegerWriteSize(2, { writeUShort(it.toUShort()) }, Endianness.Little) + testIntegerWriteSize(2, { writeUShort(it.toUShort()) }, Endianness.Big) } @Test fun writeU32_increases_size_correctly() { - testIntegerWriteSize(4, { writeU32(it.toUInt()) }, Endianness.Little) - testIntegerWriteSize(4, { writeU32(it.toUInt()) }, Endianness.Big) + testIntegerWriteSize(4, { writeUInt(it.toUInt()) }, Endianness.Little) + testIntegerWriteSize(4, { writeUInt(it.toUInt()) }, Endianness.Big) } @Test fun writeI8_increases_size_correctly() { - testIntegerWriteSize(1, { writeI8(it.toByte()) }, Endianness.Little) - testIntegerWriteSize(1, { writeI8(it.toByte()) }, Endianness.Big) + testIntegerWriteSize(1, { writeByte(it.toByte()) }, Endianness.Little) + testIntegerWriteSize(1, { writeByte(it.toByte()) }, Endianness.Big) } @Test fun writeI16_increases_size_correctly() { - testIntegerWriteSize(2, { writeI16(it.toShort()) }, Endianness.Little) - testIntegerWriteSize(2, { writeI16(it.toShort()) }, Endianness.Big) + testIntegerWriteSize(2, { writeShort(it.toShort()) }, Endianness.Little) + testIntegerWriteSize(2, { writeShort(it.toShort()) }, Endianness.Big) } @Test fun writeI32_increases_size_correctly() { - testIntegerWriteSize(4, { writeI32(it) }, Endianness.Little) - testIntegerWriteSize(4, { writeI32(it) }, Endianness.Big) + testIntegerWriteSize(4, { writeInt(it) }, Endianness.Little) + testIntegerWriteSize(4, { writeInt(it) }, Endianness.Big) } private fun testIntegerWriteSize( 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 8a421645..fa5617f5 100644 --- a/lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/CursorTests.kt +++ b/lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/CursorTests.kt @@ -46,46 +46,46 @@ abstract class CursorTests { val cursor = createCursor(byteArrayOf(1, 2, 3, 4), endianness) if (endianness == Endianness.Little) { - assertEquals(0x04030201u, cursor.u32()) + assertEquals(0x04030201u, cursor.uInt()) } else { - assertEquals(0x01020304u, cursor.u32()) + assertEquals(0x01020304u, cursor.uInt()) } } @Test fun u8() { - testIntegerRead(1, { u8().toInt() }, Endianness.Little) - testIntegerRead(1, { u8().toInt() }, Endianness.Big) + testIntegerRead(1, { uByte().toInt() }, Endianness.Little) + testIntegerRead(1, { uByte().toInt() }, Endianness.Big) } @Test fun u16() { - testIntegerRead(2, { u16().toInt() }, Endianness.Little) - testIntegerRead(2, { u16().toInt() }, Endianness.Big) + testIntegerRead(2, { uShort().toInt() }, Endianness.Little) + testIntegerRead(2, { uShort().toInt() }, Endianness.Big) } @Test fun u32() { - testIntegerRead(4, { u32().toInt() }, Endianness.Little) - testIntegerRead(4, { u32().toInt() }, Endianness.Big) + testIntegerRead(4, { uInt().toInt() }, Endianness.Little) + testIntegerRead(4, { uInt().toInt() }, Endianness.Big) } @Test fun i8() { - testIntegerRead(1, { i8().toInt() }, Endianness.Little) - testIntegerRead(1, { i8().toInt() }, Endianness.Big) + testIntegerRead(1, { byte().toInt() }, Endianness.Little) + testIntegerRead(1, { byte().toInt() }, Endianness.Big) } @Test fun i16() { - testIntegerRead(2, { i16().toInt() }, Endianness.Little) - testIntegerRead(2, { i16().toInt() }, Endianness.Big) + testIntegerRead(2, { short().toInt() }, Endianness.Little) + testIntegerRead(2, { short().toInt() }, Endianness.Big) } @Test fun i32() { - testIntegerRead(4, { i32() }, Endianness.Little) - testIntegerRead(4, { i32() }, Endianness.Big) + testIntegerRead(4, { int() }, Endianness.Little) + testIntegerRead(4, { int() }, Endianness.Big) } /** @@ -138,17 +138,17 @@ abstract class CursorTests { val cursor = createCursor(bytes, endianness) - assertEquals(2.5f, cursor.f32()) + assertEquals(2.5f, cursor.float()) assertEquals(4, cursor.position) - assertEquals(32.25f, cursor.f32()) + assertEquals(32.25f, cursor.float()) assertEquals(8, cursor.position) } @Test fun u8Array() { val read: Cursor.(Int) -> IntArray = { n -> - val arr = u8Array(n) + val arr = uByteArray(n) IntArray(n) { arr[it].toInt() } } @@ -159,7 +159,7 @@ abstract class CursorTests { @Test fun u16Array() { val read: Cursor.(Int) -> IntArray = { n -> - val arr = u16Array(n) + val arr = uShortArray(n) IntArray(n) { arr[it].toInt() } } @@ -170,7 +170,7 @@ abstract class CursorTests { @Test fun u32Array() { val read: Cursor.(Int) -> IntArray = { n -> - val arr = u32Array(n) + val arr = uIntArray(n) IntArray(n) { arr[it].toInt() } } @@ -181,7 +181,7 @@ abstract class CursorTests { @Test fun i32Array() { val read: Cursor.(Int) -> IntArray = { n -> - val arr = i32Array(n) + val arr = intArray(n) IntArray(n) { arr[it] } } @@ -254,10 +254,10 @@ abstract class CursorTests { assertEquals(6, cursor.position) assertEquals(4, newCursor.size) - assertEquals(3u, newCursor.u8()) - assertEquals(4u, newCursor.u8()) - assertEquals(5u, newCursor.u8()) - assertEquals(6u, newCursor.u8()) + assertEquals(3u, newCursor.uByte()) + assertEquals(4u, newCursor.uByte()) + assertEquals(5u, newCursor.uByte()) + assertEquals(6u, newCursor.uByte()) } @Test @@ -284,7 +284,7 @@ abstract class CursorTests { val chars = byteArrayOf(7, 65, 66, 0, (255).toByte(), 13) val bytes = ByteArray(chars.size * byteCount) - for (i in 0..chars.size) { + for (i in chars.indices) { if (endianness == Endianness.Little) { bytes[byteCount * i] = chars[i] } else { @@ -332,9 +332,9 @@ abstract class CursorTests { assertEquals(6, cursor.position) assertEquals(4, buf.size) - assertEquals(3u, buf.getU8(0)) - assertEquals(4u, buf.getU8(1)) - assertEquals(5u, buf.getU8(2)) - assertEquals(6u, buf.getU8(3)) + assertEquals(3u, buf.getUByte(0)) + assertEquals(4u, buf.getUByte(1)) + assertEquals(5u, buf.getUByte(2)) + assertEquals(6u, buf.getUByte(3)) } } 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 497ba234..f59c1da6 100644 --- a/lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/WritableCursorTests.kt +++ b/lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/WritableCursorTests.kt @@ -21,7 +21,7 @@ abstract class WritableCursorTests : CursorTests() { assertEquals(0, cursor.position) - cursor.writeU8(99u).writeU8(99u).writeU8(99u).writeU8(99u) + cursor.writeUByte(99u).writeUByte(99u).writeUByte(99u).writeUByte(99u) cursor.seek(-1) assertEquals(cursor.position + cursor.bytesLeft, cursor.size) @@ -33,38 +33,38 @@ abstract class WritableCursorTests : CursorTests() { @Test fun writeU8() { - testIntegerWrite(1, { u8().toInt() }, { writeU8(it.toUByte()) }, Endianness.Little) - testIntegerWrite(1, { u8().toInt() }, { writeU8(it.toUByte()) }, Endianness.Big) + testIntegerWrite(1, { uByte().toInt() }, { writeUByte(it.toUByte()) }, Endianness.Little) + testIntegerWrite(1, { uByte().toInt() }, { writeUByte(it.toUByte()) }, Endianness.Big) } @Test fun writeU16() { - testIntegerWrite(2, { u16().toInt() }, { writeU16(it.toUShort()) }, Endianness.Little) - testIntegerWrite(2, { u16().toInt() }, { writeU16(it.toUShort()) }, Endianness.Big) + testIntegerWrite(2, { uShort().toInt() }, { writeUShort(it.toUShort()) }, Endianness.Little) + testIntegerWrite(2, { uShort().toInt() }, { writeUShort(it.toUShort()) }, Endianness.Big) } @Test fun writeU32() { - testIntegerWrite(4, { u32().toInt() }, { writeU32(it.toUInt()) }, Endianness.Little) - testIntegerWrite(4, { u32().toInt() }, { writeU32(it.toUInt()) }, Endianness.Big) + testIntegerWrite(4, { uInt().toInt() }, { writeUInt(it.toUInt()) }, Endianness.Little) + testIntegerWrite(4, { uInt().toInt() }, { writeUInt(it.toUInt()) }, Endianness.Big) } @Test fun writeI8() { - testIntegerWrite(1, { i8().toInt() }, { writeI8(it.toByte()) }, Endianness.Little) - testIntegerWrite(1, { i8().toInt() }, { writeI8(it.toByte()) }, Endianness.Big) + testIntegerWrite(1, { byte().toInt() }, { writeByte(it.toByte()) }, Endianness.Little) + testIntegerWrite(1, { byte().toInt() }, { writeByte(it.toByte()) }, Endianness.Big) } @Test fun writeI16() { - testIntegerWrite(2, { i16().toInt() }, { writeI16(it.toShort()) }, Endianness.Little) - testIntegerWrite(2, { i16().toInt() }, { writeI16(it.toShort()) }, Endianness.Big) + testIntegerWrite(2, { short().toInt() }, { writeShort(it.toShort()) }, Endianness.Little) + testIntegerWrite(2, { short().toInt() }, { writeShort(it.toShort()) }, Endianness.Big) } @Test fun writeI32() { - testIntegerWrite(4, { i32() }, { writeI32(it) }, Endianness.Little) - testIntegerWrite(4, { i32() }, { writeI32(it) }, Endianness.Big) + testIntegerWrite(4, { int() }, { writeInt(it) }, Endianness.Little) + testIntegerWrite(4, { int() }, { writeInt(it) }, Endianness.Big) } /** @@ -104,8 +104,8 @@ abstract class WritableCursorTests : CursorTests() { private fun writeF32(endianness: Endianness) { val cursor = createCursor(ByteArray(8), endianness) - cursor.writeF32(1337.9001f) - cursor.writeF32(103.502f) + cursor.writeFloat(1337.9001f) + cursor.writeFloat(103.502f) assertEquals(8, cursor.position) @@ -113,8 +113,8 @@ abstract class WritableCursorTests : CursorTests() { // The read floats won't be exactly the same as the written floats in Kotlin JS, because // they're backed by numbers (64-bit floats). - assertTrue(abs(1337.9001f - cursor.f32()) < 0.001) - assertTrue(abs(103.502f - cursor.f32()) < 0.001) + assertTrue(abs(1337.9001f - cursor.float()) < 0.001) + assertTrue(abs(103.502f - cursor.float()) < 0.001) assertEquals(8, cursor.position) } @@ -122,11 +122,11 @@ abstract class WritableCursorTests : CursorTests() { @Test fun writeU8Array() { val read: Cursor.(Int) -> IntArray = { n -> - val arr = u8Array(n) + val arr = uByteArray(n) IntArray(n) { arr[it].toInt() } } val write: WritableCursor.(IntArray) -> Unit = { a -> - writeU8Array(UByteArray(a.size) { a[it].toUByte() }) + writeUByteArray(UByteArray(a.size) { a[it].toUByte() }) } testIntegerArrayWrite(1, read, write, Endianness.Little) @@ -136,11 +136,11 @@ abstract class WritableCursorTests : CursorTests() { @Test fun writeU16Array() { val read: Cursor.(Int) -> IntArray = { n -> - val arr = u16Array(n) + val arr = uShortArray(n) IntArray(n) { arr[it].toInt() } } val write: WritableCursor.(IntArray) -> Unit = { a -> - writeU16Array(UShortArray(a.size) { a[it].toUShort() }) + writeUShortArray(UShortArray(a.size) { a[it].toUShort() }) } testIntegerArrayWrite(2, read, write, Endianness.Little) @@ -150,11 +150,11 @@ abstract class WritableCursorTests : CursorTests() { @Test fun writeU32Array() { val read: Cursor.(Int) -> IntArray = { n -> - val arr = u32Array(n) + val arr = uIntArray(n) IntArray(n) { arr[it].toInt() } } val write: WritableCursor.(IntArray) -> Unit = { a -> - writeU32Array(UIntArray(a.size) { a[it].toUInt() }) + writeUIntArray(UIntArray(a.size) { a[it].toUInt() }) } testIntegerArrayWrite(4, read, write, Endianness.Little) @@ -164,10 +164,10 @@ abstract class WritableCursorTests : CursorTests() { @Test fun writeI32Array() { val read: Cursor.(Int) -> IntArray = { n -> - i32Array(n) + intArray(n) } val write: WritableCursor.(IntArray) -> Unit = { a -> - writeI32Array(a) + writeIntArray(a) } testIntegerArrayWrite(4, read, write, Endianness.Little) @@ -214,14 +214,14 @@ abstract class WritableCursorTests : CursorTests() { cursor.seekStart(0) - assertEquals(0, cursor.i8()) - assertEquals(0, cursor.i8()) - assertEquals(1, cursor.i8()) - assertEquals(2, cursor.i8()) - assertEquals(3, cursor.i8()) - assertEquals(4, cursor.i8()) - assertEquals(0, cursor.i8()) - assertEquals(0, cursor.i8()) + assertEquals(0, cursor.byte()) + assertEquals(0, cursor.byte()) + assertEquals(1, cursor.byte()) + assertEquals(2, cursor.byte()) + assertEquals(3, cursor.byte()) + assertEquals(4, cursor.byte()) + assertEquals(0, cursor.byte()) + assertEquals(0, cursor.byte()) } @Test @@ -233,14 +233,14 @@ abstract class WritableCursorTests : CursorTests() { private fun write_seek_backwards_then_take(endianness: Endianness) { val cursor = createCursor(ByteArray(16), endianness) - cursor.writeU32(1u).writeU32(2u).writeU32(3u).writeU32(4u) + cursor.writeUInt(1u).writeUInt(2u).writeUInt(3u).writeUInt(4u) cursor.seek(-8) val newCursor = cursor.take(8) assertEquals(16, cursor.position) assertEquals(8, newCursor.size) assertEquals(0, newCursor.position) - assertEquals(3u, newCursor.u32()) - assertEquals(4u, newCursor.u32()) + assertEquals(3u, newCursor.uInt()) + assertEquals(4u, newCursor.uInt()) } } diff --git a/lib/src/commonTest/resources/quest118_e.bin b/lib/src/commonTest/resources/quest118_e.bin new file mode 100644 index 0000000000000000000000000000000000000000..b259a074ee714dc921feb69b9b66dfad5dec36a3 GIT binary patch literal 17511 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 z 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 Vz%T@cA+Wm;m?S@e>*ZJQ{{bbs`@sMJ literal 0 HcmV?d00001 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 69d45d0e..e112917e 100644 --- a/lib/src/jsMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt +++ b/lib/src/jsMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt @@ -30,37 +30,37 @@ actual class Buffer private constructor( actual val capacity: Int get() = arrayBuffer.byteLength - actual fun getU8(offset: Int): UByte { + actual fun getUByte(offset: Int): UByte { checkOffset(offset, 1) return dataView.getUint8(offset).toUByte() } - actual fun getU16(offset: Int): UShort { + actual fun getUShort(offset: Int): UShort { checkOffset(offset, 2) return dataView.getUint16(offset, littleEndian).toUShort() } - actual fun getU32(offset: Int): UInt { + actual fun getUInt(offset: Int): UInt { checkOffset(offset, 4) return dataView.getUint32(offset, littleEndian).toUInt() } - actual fun getI8(offset: Int): Byte { + actual fun getByte(offset: Int): Byte { checkOffset(offset, 1) return dataView.getInt8(offset) } - actual fun getI16(offset: Int): Short { + actual fun getShort(offset: Int): Short { checkOffset(offset, 2) return dataView.getInt16(offset, littleEndian) } - actual fun getI32(offset: Int): Int { + actual fun getInt(offset: Int): Int { checkOffset(offset, 4) return dataView.getInt32(offset, littleEndian) } - actual fun getF32(offset: Int): Float { + actual fun getFloat(offset: Int): Float { checkOffset(offset, 4) return dataView.getFloat32(offset, littleEndian) } @@ -74,7 +74,7 @@ actual class Buffer private constructor( val len = maxByteLength / 2 for (i in 0 until len) { - val codePoint = getU16(offset + i * 2) + val codePoint = getUShort(offset + i * 2) if (nullTerminated && codePoint == ZERO_U16) { break @@ -92,53 +92,53 @@ actual class Buffer private constructor( ) } - actual fun setU8(offset: Int, value: UByte): Buffer { + actual fun setUByte(offset: Int, value: UByte): Buffer { checkOffset(offset, 1) dataView.setUint8(offset, value.toByte()) return this } - actual fun setU16(offset: Int, value: UShort): Buffer { + actual fun setUShort(offset: Int, value: UShort): Buffer { checkOffset(offset, 2) dataView.setUint16(offset, value.toShort(), littleEndian) return this } - actual fun setU32(offset: Int, value: UInt): Buffer { + actual fun setUInt(offset: Int, value: UInt): Buffer { checkOffset(offset, 4) dataView.setUint32(offset, value.toInt(), littleEndian) return this } - actual fun setI8(offset: Int, value: Byte): Buffer { + actual fun setByte(offset: Int, value: Byte): Buffer { checkOffset(offset, 1) dataView.setInt8(offset, value) return this } - actual fun setI16(offset: Int, value: Short): Buffer { + actual fun setShort(offset: Int, value: Short): Buffer { checkOffset(offset, 2) dataView.setInt16(offset, value, littleEndian) return this } - actual fun setI32(offset: Int, value: Int): Buffer { + actual fun setInt(offset: Int, value: Int): Buffer { checkOffset(offset, 4) dataView.setInt32(offset, value, littleEndian) return this } - actual fun setF32(offset: Int, value: Float): Buffer { + actual fun setFloat(offset: Int, value: Float): Buffer { checkOffset(offset, 4) dataView.setFloat32(offset, value, littleEndian) return this } actual fun zero(): Buffer = - fill(0) + fillByte(0) - actual fun fill(value: Byte): Buffer { - (Int8Array(arrayBuffer).asDynamic()).fill(value) + actual fun fillByte(value: Byte): Buffer { + (Int8Array(arrayBuffer, 0, size).asDynamic()).fill(value) return this } @@ -156,16 +156,16 @@ actual class Buffer private constructor( */ private fun ensureCapacity(minNewSize: Int) { if (minNewSize > capacity) { - var newSize = if (capacity == 0) minNewSize else capacity; + var newSize = if (capacity == 0) minNewSize else capacity do { - newSize *= 2; - } while (newSize < minNewSize); + newSize *= 2 + } while (newSize < minNewSize) - val newBuffer = ArrayBuffer(newSize); - Uint8Array(newBuffer).set(Uint8Array(arrayBuffer, 0, size)); - arrayBuffer = newBuffer; - dataView = DataView(arrayBuffer); + val newBuffer = ArrayBuffer(newSize) + Uint8Array(newBuffer).set(Uint8Array(arrayBuffer, 0, size)) + arrayBuffer = newBuffer + dataView = DataView(arrayBuffer) } } diff --git a/lib/src/jsMain/kotlin/world/phantasmal/lib/cursor/ArrayBufferCursor.kt b/lib/src/jsMain/kotlin/world/phantasmal/lib/cursor/ArrayBufferCursor.kt index cb37d332..d6038124 100644 --- a/lib/src/jsMain/kotlin/world/phantasmal/lib/cursor/ArrayBufferCursor.kt +++ b/lib/src/jsMain/kotlin/world/phantasmal/lib/cursor/ArrayBufferCursor.kt @@ -35,56 +35,56 @@ class ArrayBufferCursor( littleEndian = value == Endianness.Little } - override fun u8(): UByte { + override fun uByte(): UByte { requireSize(1) val r = dv.getUint8(absolutePosition) position++ return r.toUByte() } - override fun u16(): UShort { + override fun uShort(): UShort { requireSize(2) val r = dv.getUint16(absolutePosition, littleEndian) position += 2 return r.toUShort() } - override fun u32(): UInt { + override fun uInt(): UInt { requireSize(4) val r = dv.getUint32(absolutePosition, littleEndian) position += 4 return r.toUInt() } - override fun i8(): Byte { + override fun byte(): Byte { requireSize(1) val r = dv.getInt8(absolutePosition) position++ return r } - override fun i16(): Short { + override fun short(): Short { requireSize(2) val r = dv.getInt16(absolutePosition, littleEndian) position += 2 return r } - override fun i32(): Int { + override fun int(): Int { requireSize(4) val r = dv.getInt32(absolutePosition, littleEndian) position += 4 return r } - override fun f32(): Float { + override fun float(): Float { requireSize(4) val r = dv.getFloat32(absolutePosition, littleEndian) position += 4 return r } - override fun u8Array(n: Int): UByteArray { + override fun uByteArray(n: Int): UByteArray { requireSize(n) val array = UByteArray(n) @@ -97,7 +97,7 @@ class ArrayBufferCursor( return array } - override fun u16Array(n: Int): UShortArray { + override fun uShortArray(n: Int): UShortArray { requireSize(2 * n) val array = UShortArray(n) @@ -110,7 +110,7 @@ class ArrayBufferCursor( return array } - override fun u32Array(n: Int): UIntArray { + override fun uIntArray(n: Int): UIntArray { requireSize(4 * n) val array = UIntArray(n) @@ -123,7 +123,7 @@ class ArrayBufferCursor( return array } - override fun i32Array(n: Int): IntArray { + override fun intArray(n: Int): IntArray { requireSize(4 * n) val array = IntArray(n) @@ -153,49 +153,49 @@ class ArrayBufferCursor( return r } - override fun writeU8(value: UByte): WritableCursor { + override fun writeUByte(value: UByte): WritableCursor { requireSize(1) dv.setUint8(absolutePosition, value.toByte()) position++ return this } - override fun writeU16(value: UShort): WritableCursor { + override fun writeUShort(value: UShort): WritableCursor { requireSize(2) dv.setUint16(absolutePosition, value.toShort(), littleEndian) position += 2 return this } - override fun writeU32(value: UInt): WritableCursor { + override fun writeUInt(value: UInt): WritableCursor { requireSize(4) dv.setUint32(absolutePosition, value.toInt(), littleEndian) position += 4 return this } - override fun writeI8(value: Byte): WritableCursor { + override fun writeByte(value: Byte): WritableCursor { requireSize(1) dv.setInt8(absolutePosition, value) position++ return this } - override fun writeI16(value: Short): WritableCursor { + override fun writeShort(value: Short): WritableCursor { requireSize(2) dv.setInt16(absolutePosition, value, littleEndian) position += 2 return this } - override fun writeI32(value: Int): WritableCursor { + override fun writeInt(value: Int): WritableCursor { requireSize(4) dv.setInt32(absolutePosition, value, littleEndian) position += 4 return this } - override fun writeF32(value: Float): WritableCursor { + override fun writeFloat(value: Float): WritableCursor { requireSize(4) dv.setFloat32(absolutePosition, value, littleEndian) position += 4 diff --git a/lib/src/jsTest/kotlin/world/phantasmal/lib/test/TestUtils.kt b/lib/src/jsTest/kotlin/world/phantasmal/lib/test/TestUtils.kt index d89cac6a..98d5c292 100644 --- a/lib/src/jsTest/kotlin/world/phantasmal/lib/test/TestUtils.kt +++ b/lib/src/jsTest/kotlin/world/phantasmal/lib/test/TestUtils.kt @@ -12,7 +12,10 @@ actual fun asyncTest(block: suspend () -> Unit): dynamic = GlobalScope.promise { actual suspend fun readFile(path: String): Cursor { return window.fetch(path) - .then { it.arrayBuffer() } + .then { + require(it.ok) { """Couldn't load resource "$path".""" } + it.arrayBuffer() + } .then { ArrayBufferCursor(it, Endianness.Little) } .await() } diff --git a/lib/src/jvmMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt b/lib/src/jvmMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt new file mode 100644 index 00000000..e99ae46d --- /dev/null +++ b/lib/src/jvmMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt @@ -0,0 +1,188 @@ +package world.phantasmal.lib.buffer + +import world.phantasmal.lib.Endianness +import java.nio.ByteBuffer +import java.nio.ByteOrder + +actual class Buffer private constructor( + private var buf: ByteBuffer, + size: Int, + endianness: Endianness, +) { + actual var size: Int = size + set(value) { + ensureCapacity(value) + field = value + } + + actual var endianness: Endianness + get() = if (buf.order() == ByteOrder.LITTLE_ENDIAN) Endianness.Little else Endianness.Big + set(value) { + buf.order( + if (value == Endianness.Little) ByteOrder.LITTLE_ENDIAN else ByteOrder.BIG_ENDIAN + ) + } + + actual val capacity: Int + get() = buf.capacity() + + init { + this.endianness = endianness + } + + actual fun getUByte(offset: Int): UByte { + checkOffset(offset, 1) + return buf.get(offset).toUByte() + } + + actual fun getUShort(offset: Int): UShort { + checkOffset(offset, 2) + return buf.getShort(offset).toUShort() + } + + actual fun getUInt(offset: Int): UInt { + checkOffset(offset, 4) + return buf.getInt(offset).toUInt() + } + + actual fun getByte(offset: Int): Byte { + checkOffset(offset, 1) + return buf.get(offset) + } + + actual fun getShort(offset: Int): Short { + checkOffset(offset, 2) + return buf.getShort(offset) + } + + actual fun getInt(offset: Int): Int { + checkOffset(offset, 4) + return buf.getInt(offset) + } + + actual fun getFloat(offset: Int): Float { + checkOffset(offset, 4) + return buf.getFloat(offset) + } + + actual fun getStringUtf16( + offset: Int, + maxByteLength: Int, + nullTerminated: Boolean, + ): String = + buildString { + val len = maxByteLength / 2 + + for (i in 0 until len) { + val codePoint = buf.getChar(offset + i * 2) + + if (nullTerminated && codePoint == '0') { + break + } + + append(codePoint) + } + } + + actual fun slice(offset: Int, size: Int): Buffer { + checkOffset(offset, size) + return fromByteArray( + buf.array().copyInto(ByteArray(size), 0, offset, (offset + size)), + endianness + ) + } + + actual fun setUByte(offset: Int, value: UByte): Buffer { + checkOffset(offset, 1) + buf.put(offset, value.toByte()) + return this + } + + actual fun setUShort(offset: Int, value: UShort): Buffer { + checkOffset(offset, 2) + buf.putShort(offset, value.toShort()) + return this + } + + actual fun setUInt(offset: Int, value: UInt): Buffer { + checkOffset(offset, 4) + buf.putInt(offset, value.toInt()) + return this + } + + actual fun setByte(offset: Int, value: Byte): Buffer { + checkOffset(offset, 1) + buf.put(offset, value) + return this + } + + actual fun setShort(offset: Int, value: Short): Buffer { + checkOffset(offset, 2) + buf.putShort(offset, value) + return this + } + + actual fun setInt(offset: Int, value: Int): Buffer { + checkOffset(offset, 4) + buf.putInt(offset, value) + return this + } + + actual fun setFloat(offset: Int, value: Float): Buffer { + checkOffset(offset, 4) + buf.putFloat(offset, value) + return this + } + + actual fun zero(): Buffer = + fillByte(0) + + actual fun fillByte(value: Byte): Buffer { + for (i in 0 until size) { + buf.put(i, value) + } + + return this + } + + /** + * Checks whether we can read [size] bytes at [offset]. + */ + private fun checkOffset(offset: Int, size: Int) { + require(offset >= 0 && offset + size <= this.size) { + "Offset $offset is out of bounds." + } + } + + /** + * Reallocates the underlying ArrayBuffer if necessary. + */ + private fun ensureCapacity(minNewSize: Int) { + if (minNewSize > capacity) { + var newSize = if (capacity == 0) minNewSize else capacity + + do { + newSize *= 2 + } while (newSize < minNewSize) + + val newBuf = ByteBuffer.allocate(newSize) + newBuf.put(buf.array()) + buf = newBuf + } + } + + actual companion object { + actual fun withCapacity( + initialCapacity: Int, + endianness: Endianness, + ): Buffer = + Buffer(ByteBuffer.allocate(initialCapacity), size = 0, endianness) + + actual fun withSize(initialSize: Int, endianness: Endianness): Buffer = + Buffer(ByteBuffer.allocate(initialSize), initialSize, endianness) + + actual fun fromByteArray(array: ByteArray, endianness: Endianness): Buffer { + return Buffer(ByteBuffer.wrap(array), array.size, endianness) + } + } +} diff --git a/lib/src/jvmTest/kotlin/world/phantasmal/lib/test/TestUtils.kt b/lib/src/jvmTest/kotlin/world/phantasmal/lib/test/TestUtils.kt new file mode 100644 index 00000000..b180192e --- /dev/null +++ b/lib/src/jvmTest/kotlin/world/phantasmal/lib/test/TestUtils.kt @@ -0,0 +1,22 @@ +@file:JvmName("TestUtilsJvm") + +package world.phantasmal.lib.test + +import kotlinx.coroutines.runBlocking +import world.phantasmal.lib.buffer.Buffer +import world.phantasmal.lib.cursor.Cursor +import world.phantasmal.lib.cursor.cursor + +actual fun asyncTest(block: suspend () -> Unit) { + runBlocking { block() } +} + +actual suspend fun readFile(path: String): Cursor { + val stream = {}::class.java.getResourceAsStream(path) + ?: error("""Couldn't load resource "$path".""") + + stream.use { + @Suppress("BlockingMethodInNonBlockingContext") + return Buffer.fromByteArray(it.readAllBytes()).cursor() + } +} diff --git a/observable/src/commonMain/kotlin/world/phantasmal/observable/value/DependentVal.kt b/observable/src/commonMain/kotlin/world/phantasmal/observable/value/DependentVal.kt index 26b0fb83..0a14cd56 100644 --- a/observable/src/commonMain/kotlin/world/phantasmal/observable/value/DependentVal.kt +++ b/observable/src/commonMain/kotlin/world/phantasmal/observable/value/DependentVal.kt @@ -2,7 +2,7 @@ package world.phantasmal.observable.value import world.phantasmal.core.disposable.Disposable import world.phantasmal.core.disposable.disposable -import world.phantasmal.core.fastCast +import world.phantasmal.core.unsafeToNonNull /** * Starts observing its dependencies when the first observer on this val is registered. Stops @@ -25,7 +25,7 @@ abstract class DependentVal( _value = computeValue() } - return _value.fastCast() + return _value.unsafeToNonNull() } override fun observe(callNow: Boolean, observer: ValObserver): Disposable { @@ -37,7 +37,7 @@ abstract class DependentVal( _value = computeValue() if (_value != oldValue) { - emit(oldValue.fastCast()) + emit(oldValue.unsafeToNonNull()) } } ) diff --git a/observable/src/commonMain/kotlin/world/phantasmal/observable/value/FlatTransformedVal.kt b/observable/src/commonMain/kotlin/world/phantasmal/observable/value/FlatTransformedVal.kt index 42e37d9a..82f706b9 100644 --- a/observable/src/commonMain/kotlin/world/phantasmal/observable/value/FlatTransformedVal.kt +++ b/observable/src/commonMain/kotlin/world/phantasmal/observable/value/FlatTransformedVal.kt @@ -2,7 +2,7 @@ package world.phantasmal.observable.value import world.phantasmal.core.disposable.Disposable import world.phantasmal.core.disposable.disposable -import world.phantasmal.core.fastCast +import world.phantasmal.core.unsafeToNonNull class FlatTransformedVal( dependencies: Iterable>, @@ -16,7 +16,7 @@ class FlatTransformedVal( return if (hasNoObservers()) { super.value } else { - computedVal.fastCast>().value + computedVal.unsafeToNonNull>().value } } @@ -42,7 +42,7 @@ class FlatTransformedVal( if (hasObservers()) { computedValObserver = computedVal.observe { (value) -> - val oldValue = _value.fastCast() + val oldValue = _value.unsafeToNonNull() _value = value emit(oldValue) } diff --git a/observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/FoldedVal.kt b/observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/FoldedVal.kt index a0d977aa..707707a3 100644 --- a/observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/FoldedVal.kt +++ b/observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/FoldedVal.kt @@ -2,7 +2,7 @@ package world.phantasmal.observable.value.list import world.phantasmal.core.disposable.Disposable import world.phantasmal.core.disposable.disposable -import world.phantasmal.core.fastCast +import world.phantasmal.core.unsafeToNonNull import world.phantasmal.observable.value.AbstractVal import world.phantasmal.observable.value.ValObserver @@ -19,7 +19,7 @@ class FoldedVal( return if (dependencyDisposable == null) { computeValue() } else { - internalValue.fastCast() + internalValue.unsafeToNonNull() } } @@ -32,7 +32,7 @@ class FoldedVal( dependencyDisposable = dependency.observe { val oldValue = internalValue internalValue = computeValue() - emit(oldValue.fastCast()) + emit(oldValue.unsafeToNonNull()) } }