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

Fixed various bugs.

Browse Source
This commit is contained in:
Daan Vanden Bosch 2020-10-29 00:09:22 +01:00
parent bab01061f0
commit 924b084db4
27 changed files with 354 additions and 279 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
build.gradle.kts
View File

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

2
lib/build.gradle.kts
View File

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

1
lib/src/commonMain/kotlin/world/phantasmal/lib/Constants.kt
View File

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

4
lib/src/commonMain/kotlin/world/phantasmal/lib/assembly/Opcode.kt
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

23
lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/BinTests.kt Normal file
View File

@ -0,0 +1,23 @@
package world.phantasmal.lib.fileFormats.quest
import world.phantasmal.lib.test.asyncTest
import world.phantasmal.lib.test.readFile
import kotlin.test.Test
import kotlin.test.assertEquals
class BinTests {
@Test
fun parse_quest_towards_the_future() = asyncTest {
val bin = parseBin(readFile("/quest118_e_decompressed.bin"))
assertEquals(BinFormat.BB, bin.format)
assertEquals(118, bin.questId)
assertEquals(0, bin.language)
assertEquals("Towards the Future", bin.questName)
assertEquals("Challenge the\nnew simulator.", bin.shortDescription)
assertEquals(
"Client: Principal\nQuest: Wishes to have\nhunters challenge the\nnew simulator\nReward: ??? Meseta",
bin.longDescription
)
}
}

44
lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/QuestTests.kt Normal file
View File

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

BIN
lib/src/commonTest/resources/lost_heat_sword_gc.qst Normal file
View File

Binary file not shown.

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

Binary file not shown.

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

Binary file not shown.

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

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

1
lib/src/jvmMain/kotlin/world/phantasmal/lib/buffer/Buffer.kt
View File

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