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 00000000..b259a074 Binary files /dev/null and b/lib/src/commonTest/resources/quest118_e.bin differ diff --git a/lib/src/commonTest/resources/quest118_e_decompressed.bin b/lib/src/commonTest/resources/quest118_e_decompressed.bin new file mode 100644 index 00000000..2b560cce Binary files /dev/null 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 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()) } }