Sancaros/phantasmal-world
1
0
Fork 0
mirror of https://github.com/DaanVandenBosch/phantasmal-world.git synced 2025-04-04 22:58:29 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Added JVM support for core and lib.

Browse Source
This commit is contained in:
Daan Vanden Bosch 2020-10-27 22:55:05 +01:00
parent 0d05714730
commit bab01061f0
40 changed files with 639 additions and 392 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
core/build.gradle.kts
View File

@ -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"))
}
}
}
}
tasks.register("test") {
dependsOn("allTests")
getByName("jvmTest") {
dependencies {
implementation(kotlin("test-junit"))
}
}
}
}

3
core/src/commonMain/kotlin/world/phantasmal/core/FastCast.kt
View File

@ -1,3 +0,0 @@
package world.phantasmal.core
expect fun <T> Any?.fastCast(): T

3
core/src/commonMain/kotlin/world/phantasmal/core/UnsafeCast.kt Normal file
View File

@ -0,0 +1,3 @@
package world.phantasmal.core
expect fun <T> T?.unsafeToNonNull(): T

17
core/src/commonTest/kotlin/world/phantasmal/core/disposable/TrackedDisposableTests.kt
View File

@ -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()
}
}

3
core/src/jsMain/kotlin/world/phantasmal/core/FastCast.kt
View File

@ -1,3 +0,0 @@
package world.phantasmal.core
actual fun <T> Any?.fastCast(): T = unsafeCast<T>()

3
core/src/jsMain/kotlin/world/phantasmal/core/UnsafeCast.kt Normal file
View File

@ -0,0 +1,3 @@
package world.phantasmal.core
actual fun <T> T?.unsafeToNonNull(): T = unsafeCast<T>()

4
core/src/jvmMain/kotlin/world/phantasmal/core/UnsafeCast.kt Normal file
View File

@ -0,0 +1,4 @@
package world.phantasmal.core
@Suppress("UNCHECKED_CAST")
actual fun <T> T?.unsafeToNonNull(): T = this as T

16
lib/build.gradle.kts
View File

@ -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") {

2
lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/Assembly.kt
View File

@ -180,7 +180,7 @@ private class Assembler(private val assembly: List<String>, 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])
}
}

30
lib/src/commonMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt
View File

@ -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 {
/**

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

@ -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,9 +92,9 @@ 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
}
@ -105,12 +108,12 @@ private class PrsCompressor(capacity: Int, endianness: Endianness) {
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) {
@ -119,7 +122,7 @@ private class PrsCompressor(capacity: Int, endianness: Endianness) {
writeControlBit(0)
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)
}
}
}

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

@ -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) {

30
lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/AbstractWritableCursor.kt
View File

@ -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

88
lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/BufferCursor.kt
View File

@ -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 {

22
lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/Cursor.kt
View File

@ -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.

22
lib/src/commonMain/kotlin/world/phantasmal/lib/cursor/WritableCursor.kt
View File

@ -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

4
lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/Iff.kt
View File

@ -34,9 +34,9 @@ private fun <T> 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

2
lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/Vector.kt
View File

@ -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())

14
lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/ninja/Ninja.kt
View File

@ -62,7 +62,7 @@ private fun <Model, Context> parseSiblingObjects(
parse_model: (cursor: Cursor, context: Context) -> Model,
context: Context,
): List<NjObject<Model>> {
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 <Model, Context> 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

75
lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/ninja/Nj.kt
View File

@ -123,10 +123,10 @@ class NjcmErgb(
)
fun parseNjcmModel(cursor: Cursor, cachedChunkOffsets: MutableMap<UByte, Int>): 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<NjcmVertex> = mutableListOf()
val meshes: MutableList<NjcmTriangleStrip> = mutableListOf()
@ -156,6 +156,7 @@ fun parseNjcmModel(cursor: Cursor, cachedChunkOffsets: MutableMap<UByte, Int>):
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<NjcmChunkVertex> = 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<NjcmTriangleStrip> = mutableListOf()
repeat(stripCount.toInt()) {
val windingFlagAndIndexCount = cursor.i16()
val windingFlagAndIndexCount = cursor.short()
val clockwiseWinding = windingFlagAndIndexCount < 1
val indexCount = abs(windingFlagAndIndexCount.toInt())
val vertices: MutableList<NjcmMeshVertex> = 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

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

@ -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)

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

@ -70,10 +70,10 @@ fun parseDat(cursor: Cursor): DatFile {
val unknowns = mutableListOf<DatUnknown>()
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<DatEvent>) {
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<DatEven
cursor.seekStart(16)
repeat(eventCount) {
val id = cursor.u32()
val id = cursor.uInt()
cursor.seek(4) // Always 0x100
val sectionId = cursor.u16()
val wave = cursor.u16()
val delay = cursor.u16()
val unknown = cursor.u16() // "wavesetting"?
val eventActionsOffset = cursor.i32()
val sectionId = cursor.uShort()
val wave = cursor.uShort()
val delay = cursor.uShort()
val unknown = cursor.uShort() // "wavesetting"?
val eventActionsOffset = cursor.int()
val actions: MutableList<DatEventAction> =
if (eventActionsOffset < actionsCursor.size) {
@ -185,7 +185,7 @@ private fun parseEvents(cursor: Cursor, areaId: Int, events: MutableList<DatEven
var lastU8: UByte = 0xffu
while (actionsCursor.hasBytesLeft()) {
lastU8 = actionsCursor.u8()
lastU8 = actionsCursor.uByte()
if (lastU8 != (0xffu).toUByte()) {
break
@ -204,28 +204,28 @@ private fun parseEventActions(cursor: Cursor): MutableList<DatEventAction> {
val actions = mutableListOf<DatEventAction>()
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 -> {

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

@ -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.")

8
lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/QuestNpc.kt
View File

@ -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 {

10
lib/src/commonTest/kotlin/world/phantasmal/lib/buffer/BufferTests.kt
View File

@ -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))
}
}
}

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

@ -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())

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

@ -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}."
)
}
}
}
}

24
lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/BufferCursorTests.kt
View File

@ -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(

58
lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/CursorTests.kt
View File

@ -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))
}
}

72
lib/src/commonTest/kotlin/world/phantasmal/lib/cursor/WritableCursorTests.kt
View File

@ -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())
}
}

BIN
lib/src/commonTest/resources/quest118_e.bin Normal file
View File

Binary file not shown.

BIN
lib/src/commonTest/resources/quest118_e_decompressed.bin Normal file
View File

Binary file not shown.

50
lib/src/jsMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt
View File

@ -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)
}
}

36
lib/src/jsMain/kotlin/world/phantasmal/lib/cursor/ArrayBufferCursor.kt
View File

@ -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

5
lib/src/jsTest/kotlin/world/phantasmal/lib/test/TestUtils.kt
View File

@ -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()
}

188
lib/src/jvmMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt Normal file
View File

@ -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)
}
}
}

22
lib/src/jvmTest/kotlin/world/phantasmal/lib/test/TestUtils.kt Normal file
View File

@ -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()
}
}

6
observable/src/commonMain/kotlin/world/phantasmal/observable/value/DependentVal.kt
View File

@ -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<T>(
_value = computeValue()
}
return _value.fastCast()
return _value.unsafeToNonNull()
}
override fun observe(callNow: Boolean, observer: ValObserver<T>): Disposable {
@ -37,7 +37,7 @@ abstract class DependentVal<T>(
_value = computeValue()
if (_value != oldValue) {
emit(oldValue.fastCast())
emit(oldValue.unsafeToNonNull())
}
}
)

6
observable/src/commonMain/kotlin/world/phantasmal/observable/value/FlatTransformedVal.kt
View File

@ -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<T>(
dependencies: Iterable<Val<*>>,
@ -16,7 +16,7 @@ class FlatTransformedVal<T>(
return if (hasNoObservers()) {
super.value
} else {
computedVal.fastCast<Val<T>>().value
computedVal.unsafeToNonNull<Val<T>>().value
}
}
@ -42,7 +42,7 @@ class FlatTransformedVal<T>(
if (hasObservers()) {
computedValObserver = computedVal.observe { (value) ->
val oldValue = _value.fastCast<T>()
val oldValue = _value.unsafeToNonNull<T>()
_value = value
emit(oldValue)
}

6
observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/FoldedVal.kt
View File

@ -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<T, R>(
return if (dependencyDisposable == null) {
computeValue()
} else {
internalValue.fastCast()
internalValue.unsafeToNonNull()
}
}
@ -32,7 +32,7 @@ class FoldedVal<T, R>(
dependencyDisposable = dependency.observe {
val oldValue = internalValue
internalValue = computeValue()
emit(oldValue.fastCast())
emit(oldValue.unsafeToNonNull())
}
}