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

Ported several things and fixed some bugs.

Browse Source
This commit is contained in:
Daan Vanden Bosch 2020-11-05 17:46:17 +01:00
parent 17ef42fba7
commit bedc7b07a2
31 changed files with 958 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
core/src/commonMain/kotlin/world/phantasmal/core/Strings.kt Normal file
View File

@ -0,0 +1,16 @@
package world.phantasmal.core
/**
* Returns the given filename without the file extension.
*/
fun basename(filename: String): String {
val dotIdx = filename.lastIndexOf(".")
// < 0 means filename doesn't contain any "."
// Also skip index 0 because that would mean the basename is empty.
if (dotIdx > 1) {
return filename.substring(0, dotIdx)
}
return filename
}

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

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

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

@ -3,7 +3,6 @@ package world.phantasmal.lib.assembly
import mu.KotlinLogging
import world.phantasmal.core.Problem
import world.phantasmal.core.PwResult
import world.phantasmal.core.PwResultBuilder
import world.phantasmal.core.Severity
import world.phantasmal.lib.buffer.Buffer
@ -55,7 +54,7 @@ private class Assembler(private val assembly: List<String>, private val manualSt
private var firstSectionMarker = true
private var prevLineHadLabel = false
private val result = PwResultBuilder<List<Segment>>(logger)
private val result = PwResult.build<List<Segment>>(logger)
fun assemble(): PwResult<List<Segment>> {
// Tokenize and assemble line by line.

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

@ -2,7 +2,6 @@ package world.phantasmal.lib.compression.prs
import mu.KotlinLogging
import world.phantasmal.core.PwResult
import world.phantasmal.core.PwResultBuilder
import world.phantasmal.core.Severity
import world.phantasmal.core.Success
import world.phantasmal.lib.buffer.Buffer
@ -67,7 +66,7 @@ private class PrsDecompressor(private val src: Cursor) {
return Success(dst.seekStart(0))
} catch (e: Throwable) {
return PwResultBuilder<Cursor>(logger)
return PwResult.build<Cursor>(logger)
.addProblem(Severity.Error, "PRS-compressed stream is corrupt.", cause = e)
.failure()
}

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

@ -14,8 +14,8 @@ protected constructor(protected val offset: Int) : WritableCursor {
protected val absolutePosition: Int
get() = offset + position
override fun hasBytesLeft(bytes: Int): Boolean =
bytesLeft >= bytes
override fun hasBytesLeft(atLeast: Int): Boolean =
bytesLeft >= atLeast
override fun seek(offset: Int): WritableCursor =
seekStart(position + offset)

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

@ -19,9 +19,13 @@ class BufferCursor(
get() = _size
set(value) {
if (value > _size) {
ensureSpace(value)
ensureSpace(value - _size)
} else {
_size = value
if (position > _size) {
position = _size
}
}
}

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

@ -21,7 +21,7 @@ interface Cursor {
val bytesLeft: Int
fun hasBytesLeft(bytes: Int = 1): Boolean
fun hasBytesLeft(atLeast: Int = 1): Boolean
/**
* Seek forward or backward by a number of bytes.

78
lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/AreaCollisionGeometry.kt Normal file
View File

@ -0,0 +1,78 @@
package world.phantasmal.lib.fileFormats
import world.phantasmal.lib.cursor.Cursor
class CollisionObject(
val meshes: List<CollisionMesh>,
)
class CollisionMesh(
val vertices: List<Vec3>,
val triangles: List<CollisionTriangle>,
)
class CollisionTriangle(
val index1: Int,
val index2: Int,
val index3: Int,
val flags: Int,
val normal: Vec3,
)
fun parseAreaCollisionGeometry(cursor: Cursor): CollisionObject {
val dataOffset = parseRel(cursor, parseIndex = false).dataOffset
cursor.seekStart(dataOffset)
val mainOffsetTableOffset = cursor.int()
cursor.seekStart(mainOffsetTableOffset)
val meshes = mutableListOf<CollisionMesh>()
while (cursor.hasBytesLeft()) {
val startPos = cursor.position
val blockTrailerOffset = cursor.int()
if (blockTrailerOffset == 0) {
break
}
val vertices = mutableListOf<Vec3>()
val triangles = mutableListOf<CollisionTriangle>()
meshes.add(CollisionMesh(vertices, triangles))
cursor.seekStart(blockTrailerOffset)
val vertexCount = cursor.int()
val vertexTableOffset = cursor.int()
val triangleCount = cursor.int()
val triangleTableOffset = cursor.int()
cursor.seekStart(vertexTableOffset)
repeat(vertexCount) {
vertices.add(cursor.vec3Float())
}
cursor.seekStart(triangleTableOffset)
repeat(triangleCount) {
val index1 = cursor.uShort().toInt()
val index2 = cursor.uShort().toInt()
val index3 = cursor.uShort().toInt()
val flags = cursor.uShort().toInt()
val normal = cursor.vec3Float()
cursor.seek(16)
triangles.add(CollisionTriangle(
index1,
index2,
index3,
flags,
normal
))
}
cursor.seekStart(startPos + 24)
}
return CollisionObject(meshes)
}

50
lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/Rel.kt Normal file
View File

@ -0,0 +1,50 @@
package world.phantasmal.lib.fileFormats
import world.phantasmal.lib.cursor.Cursor
class Rel(
/**
* Offset from which to start parsing the file.
*/
val dataOffset: Int,
/**
* List of offsets into the file, presumably used by Sega to fix pointers after loading a file
* directly into memory.
*/
val index: List<RelIndexEntry>,
)
class RelIndexEntry(
val offset: Int,
val size: Int,
)
fun parseRel(cursor: Cursor, parseIndex: Boolean): Rel {
cursor.seekEnd(32)
val indexOffset = cursor.int()
val indexSize = cursor.int()
cursor.seek(8) // Typically 1, 0, 0,...
val dataOffset = cursor.int()
// Typically followed by 12 nul bytes.
cursor.seekStart(indexOffset)
val index = if (parseIndex) parseIndices(cursor, indexSize) else emptyList()
return Rel(dataOffset, index)
}
private fun parseIndices(cursor: Cursor, indexSize: Int): List<RelIndexEntry> {
val compactOffsets = cursor.uShortArray(indexSize)
var expandedOffset = 0
return compactOffsets.map { compactOffset ->
expandedOffset += 4 * compactOffset.toInt()
// Size is not always present.
cursor.seekStart(expandedOffset - 4)
val size = cursor.int()
val offset = cursor.int()
RelIndexEntry(offset, size)
}
}

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(float(), float(), float())
fun Cursor.vec3Float(): Vec3 = Vec3(float(), float(), float())

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

@ -6,7 +6,7 @@ import world.phantasmal.core.Success
import world.phantasmal.lib.cursor.Cursor
import world.phantasmal.lib.fileFormats.Vec3
import world.phantasmal.lib.fileFormats.parseIff
import world.phantasmal.lib.fileFormats.vec3F32
import world.phantasmal.lib.fileFormats.vec3Float
private const val NJCM: Int = 0x4D434A4E
@ -53,13 +53,13 @@ private fun <Model : NinjaModel, Context> parseSiblingObjects(
val shapeSkip = (evalFlags and 0b10000000u) != 0u
val modelOffset = cursor.int()
val pos = cursor.vec3F32()
val pos = cursor.vec3Float()
val rotation = Vec3(
angleToRad(cursor.int()),
angleToRad(cursor.int()),
angleToRad(cursor.int()),
)
val scale = cursor.vec3F32()
val scale = cursor.vec3Float()
val childOffset = cursor.int()
val siblingOffset = cursor.int()

27
lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/ninja/Njcm.kt
View File

@ -1,11 +1,10 @@
package world.phantasmal.lib.fileFormats.ninja
import mu.KotlinLogging
import world.phantasmal.lib.ZERO_U8
import world.phantasmal.lib.cursor.Cursor
import world.phantasmal.lib.fileFormats.Vec2
import world.phantasmal.lib.fileFormats.Vec3
import world.phantasmal.lib.fileFormats.vec3F32
import world.phantasmal.lib.fileFormats.vec3Float
import kotlin.math.abs
// TODO:
@ -14,10 +13,14 @@ import kotlin.math.abs
private val logger = KotlinLogging.logger {}
private const val ZERO_U8: UByte = 0u
// TODO: Simplify parser by not parsing chunks into vertices and meshes. Do the chunk to vertex/mesh
// conversion at a higher level.
fun parseNjcmModel(cursor: Cursor, cachedChunkOffsets: MutableMap<UByte, Int>): NjcmModel {
val vlistOffset = cursor.int() // Vertex list
val plistOffset = cursor.int() // Triangle strip index list
val boundingSphereCenter = cursor.vec3F32()
val boundingSphereCenter = cursor.vec3Float()
val boundingSphereRadius = cursor.float()
val vertices: MutableList<NjcmVertex?> = mutableListOf()
val meshes: MutableList<NjcmTriangleStrip> = mutableListOf()
@ -120,20 +123,18 @@ private fun parseChunks(
))
}
4 -> {
val cacheIndex = flags
val offset = cursor.position
chunks.add(NjcmChunk.CachePolygonList(
cacheIndex,
cacheIndex = flags,
offset,
))
cachedChunkOffsets[cacheIndex] = offset
cachedChunkOffsets[flags] = offset
loop = false
}
5 -> {
val cacheIndex = flags
val cachedOffset = cachedChunkOffsets[cacheIndex]
val cachedOffset = cachedChunkOffsets[flags]
if (cachedOffset != null) {
cursor.seekStart(cachedOffset)
@ -141,7 +142,7 @@ private fun parseChunks(
}
chunks.add(NjcmChunk.DrawPolygonList(
cacheIndex,
cacheIndex = flags,
))
}
in 8..9 -> {
@ -258,7 +259,7 @@ private fun parseVertexChunk(
for (i in (0u).toUShort() until vertexCount) {
var vertexIndex = index + i
val position = cursor.vec3F32()
val position = cursor.vec3Float()
var normal: Vec3? = null
var boneWeight = 1f
@ -270,7 +271,7 @@ private fun parseVertexChunk(
33 -> {
// NJDCVVNSH
cursor.seek(4) // Always 1.0
normal = cursor.vec3F32()
normal = cursor.vec3Float()
cursor.seek(4) // Always 0.0
}
in 35..40 -> {
@ -285,10 +286,10 @@ private fun parseVertexChunk(
}
}
41 -> {
normal = cursor.vec3F32()
normal = cursor.vec3Float()
}
in 42..47 -> {
normal = cursor.vec3F32()
normal = cursor.vec3Float()
if (chunkTypeId == (44u).toUByte()) {
// NJDCVVNNF

3
lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/ByteCode.kt
View File

@ -2,7 +2,6 @@ package world.phantasmal.lib.fileFormats.quest
import mu.KotlinLogging
import world.phantasmal.core.PwResult
import world.phantasmal.core.PwResultBuilder
import world.phantasmal.core.Severity
import world.phantasmal.lib.assembly.*
import world.phantasmal.lib.assembly.dataFlowAnalysis.ControlFlowGraph
@ -53,7 +52,7 @@ fun parseByteCode(
): PwResult<List<Segment>> {
val cursor = BufferCursor(byteCode)
val labelHolder = LabelHolder(labelOffsets)
val result = PwResultBuilder<List<Segment>>(logger)
val result = PwResult.build<List<Segment>>(logger)
val offsetToSegment = mutableMapOf<Int, Segment>()
findAndParseSegments(

409
lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Qst.kt Normal file
View File

@ -0,0 +1,409 @@
package world.phantasmal.lib.fileFormats.quest
import mu.KotlinLogging
import world.phantasmal.core.PwResult
import world.phantasmal.core.Severity
import world.phantasmal.core.Success
import world.phantasmal.core.basename
import world.phantasmal.lib.Endianness
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.ceil
import kotlin.math.max
private val logger = KotlinLogging.logger {}
// .qst format
private const val DC_GC_PC_HEADER_SIZE = 60
private const val BB_HEADER_SIZE = 88
private const val ONLINE_QUEST = 0x44
private const val DOWNLOAD_QUEST = 0xa6
// Chunks
private const val CHUNK_BODY_SIZE = 1024
private const val DC_GC_PC_CHUNK_HEADER_SIZE = 20
private const val DC_GC_PC_CHUNK_TRAILER_SIZE = 4
private const val DC_GC_PC_CHUNK_SIZE =
CHUNK_BODY_SIZE + DC_GC_PC_CHUNK_HEADER_SIZE + DC_GC_PC_CHUNK_TRAILER_SIZE
private const val BB_CHUNK_HEADER_SIZE = 24
private const val BB_CHUNK_TRAILER_SIZE = 8
private const val BB_CHUNK_SIZE = CHUNK_BODY_SIZE + BB_CHUNK_HEADER_SIZE + BB_CHUNK_TRAILER_SIZE
class QstContent(
val version: Version,
val online: Boolean,
val files: List<QstContainedFile>,
)
class QstContainedFile(
val id: Int?,
val filename: String,
val questName: String?,
val data: Buffer,
)
/**
* Low level parsing function for .qst files.
*/
fun parseQst(cursor: Cursor): PwResult<QstContent> {
val result = PwResult.build<QstContent>(logger)
// A .qst file contains two headers that describe the embedded .dat and .bin files.
// Read headers and contained files.
val headers = parseHeaders(cursor)
if (headers.size < 2) {
return result
.addProblem(
Severity.Error,
"This .qst file is corrupt.",
"Corrupt .qst file, expected at least 2 headers but only found ${headers.size}.",
)
.failure()
}
var version: Version? = null
var online: Boolean? = null
for (header in headers) {
if (version != null && header.version != version) {
return result
.addProblem(
Severity.Error,
"This .qst file is corrupt.",
"Corrupt .qst file, header version ${header.version} for file ${
header.filename
} doesn't match the previous header's version ${version}.",
)
.failure()
}
if (online != null && header.online != online) {
return result
.addProblem(
Severity.Error,
"This .qst file is corrupt.",
"Corrupt .qst file, header type ${
if (header.online) "\"online\"" else "\"download\""
} for file ${header.filename} doesn't match the previous header's type ${
if (online) "\"online\"" else "\"download\""
}.",
)
.failure()
}
version = header.version
online = header.online
}
checkNotNull(version)
checkNotNull(online)
val parseFilesResult: PwResult<List<QstContainedFile>> = parseFiles(
cursor,
version,
headers.map { it.filename to it }.toMap()
)
result.addResult(parseFilesResult)
if (parseFilesResult !is Success) {
return result.failure()
}
return result.success(QstContent(
version,
online,
parseFilesResult.value
))
}
private class QstHeader(
val version: Version,
val online: Boolean,
val questId: Int,
val name: String,
val filename: String,
val size: Int,
)
private fun parseHeaders(cursor: Cursor): List<QstHeader> {
val headers = mutableListOf<QstHeader>()
var prevQuestId: Int? = null
var prevFilename: String? = null
// .qst files should have two headers, some malformed files have more.
repeat(4) {
// Detect version and whether it's an online or download quest.
val version: Version
val online: Boolean
val versionA = cursor.uByte().toInt()
cursor.seek(1)
val versionB = cursor.uByte().toInt()
cursor.seek(-3)
if (versionA == BB_HEADER_SIZE && versionB == ONLINE_QUEST) {
version = Version.BB
online = true
} else if (versionA == DC_GC_PC_HEADER_SIZE && versionB == ONLINE_QUEST) {
version = Version.PC
online = true
} else if (versionB == DC_GC_PC_HEADER_SIZE) {
val pos = cursor.position
cursor.seek(35)
version = if (cursor.byte().toInt() == 0) {
Version.GC
} else {
Version.DC
}
cursor.seekStart(pos)
online = when (versionA) {
ONLINE_QUEST -> true
DOWNLOAD_QUEST -> false
else -> return@repeat
}
} else {
return@repeat
}
// Read header.
val headerSize: Int
val questId: Int
val name: String
val filename: String
val size: Int
when (version) {
Version.DC -> {
cursor.seek(1) // Skip online/download.
questId = cursor.uByte().toInt()
headerSize = cursor.uShort().toInt()
name = cursor.stringAscii(32, nullTerminated = true, dropRemaining = true)
cursor.seek(3)
filename = cursor.stringAscii(16, nullTerminated = true, dropRemaining = true)
cursor.seek(1)
size = cursor.int()
}
Version.GC -> {
cursor.seek(1) // Skip online/download.
questId = cursor.uByte().toInt()
headerSize = cursor.uShort().toInt()
name = cursor.stringAscii(32, nullTerminated = true, dropRemaining = true)
cursor.seek(4)
filename = cursor.stringAscii(16, nullTerminated = true, dropRemaining = true)
size = cursor.int()
}
Version.PC -> {
headerSize = cursor.uShort().toInt()
cursor.seek(1) // Skip online/download.
questId = cursor.uByte().toInt()
name = cursor.stringAscii(32, nullTerminated = true, dropRemaining = true)
cursor.seek(4)
filename = cursor.stringAscii(16, nullTerminated = true, dropRemaining = true)
size = cursor.int()
}
Version.BB -> {
headerSize = cursor.uShort().toInt()
cursor.seek(2) // Skip online/download.
questId = cursor.uShort().toInt()
cursor.seek(38)
filename = cursor.stringAscii(16, nullTerminated = true, dropRemaining = true)
size = cursor.int()
name = cursor.stringAscii(24, nullTerminated = true, dropRemaining = true)
}
}
// Use some simple heuristics to figure out whether the file contains more than two headers.
// Some malformed .qst files have extra headers.
if (
prevQuestId != null &&
prevFilename != null &&
(questId != prevQuestId || basename(filename) != basename(prevFilename!!))
) {
cursor.seek(-headerSize)
return@repeat
}
prevQuestId = questId
prevFilename = filename
headers.add(QstHeader(
version,
online,
questId,
name,
filename,
size,
))
}
return headers
}
private class QstFileData(
val name: String,
val expectedSize: Int?,
val cursor: WritableCursor,
var chunkNos: MutableSet<Int>,
)
private fun parseFiles(
cursor: Cursor,
version: Version,
headers: Map<String, QstHeader>,
): PwResult<List<QstContainedFile>> {
val result = PwResult.build<List<QstContainedFile>>(logger)
// Files are interleaved in 1048 or 1056 byte chunks, depending on the version.
// Each chunk has a 20 or 24 byte header, 1024 byte data segment and a 4 or 8 byte trailer.
val files = mutableMapOf<String, QstFileData>()
val chunkSize: Int // Size including padding, header and trailer.
val trailerSize: Int
when (version) {
Version.DC,
Version.GC,
Version.PC,
-> {
chunkSize = DC_GC_PC_CHUNK_SIZE
trailerSize = DC_GC_PC_CHUNK_TRAILER_SIZE
}
Version.BB -> {
chunkSize = BB_CHUNK_SIZE
trailerSize = BB_CHUNK_TRAILER_SIZE
}
}
while (cursor.hasBytesLeft(chunkSize)) {
val startPosition = cursor.position
// Read chunk header.
var chunkNo: Int
when (version) {
Version.DC,
Version.GC,
-> {
cursor.seek(1)
chunkNo = cursor.uByte().toInt()
cursor.seek(2)
}
Version.PC -> {
cursor.seek(3)
chunkNo = cursor.uByte().toInt()
}
Version.BB -> {
cursor.seek(4)
chunkNo = cursor.int()
}
}
val fileName = cursor.stringAscii(16, nullTerminated = true, dropRemaining = true)
val file = files.getOrPut(fileName) {
val header = headers[fileName]
QstFileData(
fileName,
header?.size,
Buffer.withCapacity(
header?.size ?: (10 * CHUNK_BODY_SIZE),
Endianness.Little
).cursor(),
mutableSetOf()
)
}
if (chunkNo in file.chunkNos) {
result.addProblem(
Severity.Warning,
"File chunk Int $chunkNo of file $fileName was already encountered, overwriting previous chunk.",
)
} else {
file.chunkNos.add(chunkNo)
}
// Read file data.
var size = cursor.seek(CHUNK_BODY_SIZE).int()
cursor.seek(-CHUNK_BODY_SIZE - 4)
if (size > CHUNK_BODY_SIZE) {
result.addProblem(
Severity.Warning,
"Data segment size of $size is larger than expected maximum size, reading just $CHUNK_BODY_SIZE bytes.",
)
size = CHUNK_BODY_SIZE
}
val data = cursor.take(size)
val chunkPosition = chunkNo * CHUNK_BODY_SIZE
file.cursor.size = max(chunkPosition + size, file.cursor.size)
file.cursor.seekStart(chunkPosition).writeCursor(data)
// Skip the padding and the trailer.
cursor.seek(CHUNK_BODY_SIZE - data.size + trailerSize)
check(cursor.position == startPosition + chunkSize) {
"Read ${
cursor.position - startPosition
} file chunk message bytes instead of expected ${chunkSize}."
}
}
if (cursor.hasBytesLeft()) {
result.addProblem(Severity.Warning, "${cursor.bytesLeft} Bytes left in file.")
}
for (file in files.values) {
// Clean up file properties.
file.cursor.seekStart(0)
file.chunkNos = file.chunkNos.sorted().toMutableSet()
// Check whether the expected size was correct.
if (file.expectedSize != null && file.cursor.size != file.expectedSize) {
result.addProblem(
Severity.Warning,
"File ${file.name} has an actual size of ${
file.cursor.size
} instead of the expected size ${file.expectedSize}.",
)
}
// Detect missing file chunks.
val actualSize = max(file.cursor.size, file.expectedSize ?: 0)
val expectedChunkCount = ceil(actualSize.toDouble() / CHUNK_BODY_SIZE).toInt()
for (chunkNo in 0 until expectedChunkCount) {
if (chunkNo !in file.chunkNos) {
result.addProblem(
Severity.Warning,
"File ${file.name} is missing chunk ${chunkNo}.",
)
}
}
}
return result.success(
files.values.map { file ->
val header = headers[file.name]
QstContainedFile(
header?.questId,
file.name,
header?.name,
file.cursor.seekStart(0).buffer(),
)
}
)
}

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

@ -11,6 +11,7 @@ import world.phantasmal.lib.assembly.Segment
import world.phantasmal.lib.assembly.dataFlowAnalysis.getMapDesignations
import world.phantasmal.lib.compression.prs.prsDecompress
import world.phantasmal.lib.cursor.Cursor
import world.phantasmal.lib.cursor.cursor
private val logger = KotlinLogging.logger {}
@ -35,23 +36,23 @@ fun parseBinDatToQuest(
datCursor: Cursor,
lenient: Boolean = false,
): PwResult<Quest> {
val rb = PwResultBuilder<Quest>(logger)
val result = PwResult.build<Quest>(logger)
// Decompress and parse files.
val binDecompressed = prsDecompress(binCursor)
rb.addResult(binDecompressed)
result.addResult(binDecompressed)
if (binDecompressed !is Success) {
return rb.failure()
return result.failure()
}
val bin = parseBin(binDecompressed.value)
val datDecompressed = prsDecompress(datCursor)
rb.addResult(datDecompressed)
result.addResult(datDecompressed)
if (datDecompressed !is Success) {
return rb.failure()
return result.failure()
}
val dat = parseDat(datDecompressed.value)
@ -71,16 +72,16 @@ fun parseBinDatToQuest(
lenient,
)
rb.addResult(parseByteCodeResult)
result.addResult(parseByteCodeResult)
if (parseByteCodeResult !is Success) {
return rb.failure()
return result.failure()
}
val byteCodeIr = parseByteCodeResult.value
if (byteCodeIr.isEmpty()) {
rb.addProblem(Severity.Warning, "File contains no instruction labels.")
result.addProblem(Severity.Warning, "File contains no instruction labels.")
} else {
val instructionSegments = byteCodeIr.filterIsInstance<InstructionSegment>()
@ -94,7 +95,7 @@ fun parseBinDatToQuest(
}
if (label0Segment != null) {
episode = getEpisode(rb, label0Segment)
episode = getEpisode(result, label0Segment)
for (npc in npcs) {
npc.episode = episode
@ -102,11 +103,11 @@ fun parseBinDatToQuest(
mapDesignations = getMapDesignations(instructionSegments, label0Segment)
} else {
rb.addProblem(Severity.Warning, "No instruction segment for label 0 found.")
result.addProblem(Severity.Warning, "No instruction segment for label 0 found.")
}
}
return rb.success(Quest(
return result.success(Quest(
id = bin.questId,
language = bin.language,
name = bin.questName,
@ -123,6 +124,65 @@ fun parseBinDatToQuest(
))
}
class QuestData(
val quest: Quest,
val version: Version,
val online: Boolean,
)
fun parseQstToQuest(cursor: Cursor, lenient: Boolean = false): PwResult<QuestData> {
val result = PwResult.build<QuestData>(logger)
// Extract contained .dat and .bin files.
val qstResult = parseQst(cursor)
result.addResult(qstResult)
if (qstResult !is Success) {
return result.failure()
}
val version = qstResult.value.version
val online = qstResult.value.online
val files = qstResult.value.files
var datFile: QstContainedFile? = null
var binFile: QstContainedFile? = null
for (file in files) {
val fileName = file.filename.trim().toLowerCase()
if (fileName.endsWith(".dat")) {
datFile = file
} else if (fileName.endsWith(".bin")) {
binFile = file
}
}
if (datFile == null) {
return result.addProblem(Severity.Error, "File contains no DAT file.").failure()
}
if (binFile == null) {
return result.addProblem(Severity.Error, "File contains no BIN file.").failure()
}
val questResult = parseBinDatToQuest(
binFile.data.cursor(),
datFile.data.cursor(),
lenient,
)
result.addResult(questResult)
if (questResult !is Success) {
return result.failure()
}
return result.success(QuestData(
questResult.value,
version,
online,
))
}
/**
* Defaults to episode I.
*/

23
lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Version.kt Normal file
View File

@ -0,0 +1,23 @@
package world.phantasmal.lib.fileFormats.quest
enum class Version {
/**
* Dreamcast
*/
DC,
/**
* GameCube
*/
GC,
/**
* Desktop
*/
PC,
/**
* BlueBurst
*/
BB,
}

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

@ -6,8 +6,8 @@ import kotlin.test.Test
import kotlin.test.assertEquals
class BufferCursorTests : WritableCursorTests() {
override fun createCursor(bytes: ByteArray, endianness: Endianness) =
BufferCursor(Buffer.fromByteArray(bytes, endianness))
override fun createCursor(bytes: ByteArray, endianness: Endianness, size: Int) =
BufferCursor(Buffer.fromByteArray(bytes, endianness), size = size)
@Test
fun writeUByte_increases_size_correctly() {

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

@ -9,7 +9,11 @@ import kotlin.test.assertEquals
* implementation.
*/
abstract class CursorTests {
abstract fun createCursor(bytes: ByteArray, endianness: Endianness): Cursor
abstract fun createCursor(
bytes: ByteArray,
endianness: Endianness,
size: Int = bytes.size,
): Cursor
@Test
fun simple_cursor_properties_and_invariants() {

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

@ -8,7 +8,11 @@ import kotlin.test.assertEquals
import kotlin.test.assertTrue
abstract class WritableCursorTests : CursorTests() {
abstract override fun createCursor(bytes: ByteArray, endianness: Endianness): WritableCursor
abstract override fun createCursor(
bytes: ByteArray,
endianness: Endianness,
size: Int,
): WritableCursor
@Test
fun simple_WritableCursor_properties_and_invariants() {
@ -31,6 +35,33 @@ abstract class WritableCursorTests : CursorTests() {
assertEquals(endianness, cursor.endianness)
}
@Test
fun size() {
size(Endianness.Little)
size(Endianness.Big)
}
private fun size(endianness: Endianness) {
val cursor = createCursor(ByteArray(20), endianness, size = 0)
assertEquals(0, cursor.size)
cursor.size = 10
cursor.seek(10)
assertEquals(10, cursor.size)
cursor.size = 20
cursor.seek(10)
assertEquals(20, cursor.size)
cursor.size = 5
assertEquals(5, cursor.size)
assertEquals(5, cursor.position)
}
@Test
fun writeUByte() {
testIntegerWrite(1, { uByte().toInt() }, { writeUByte(it.toUByte()) }, Endianness.Little)

25
lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/QstTests.kt Normal file
View File

@ -0,0 +1,25 @@
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
import kotlin.test.assertTrue
class QstTests {
@Test
fun parse_a_GC_quest() = asyncTest{
val cursor = readFile("/lost_heat_sword_gc.qst")
val qst = parseQst(cursor).unwrap()
assertEquals(Version.GC, qst.version)
assertTrue(qst.online)
assertEquals(2, qst.files.size)
assertEquals(58, qst.files[0].id)
assertEquals("quest58.bin", qst.files[0].filename)
assertEquals("PSO/Lost HEAT SWORD", qst.files[0].questName)
assertEquals(58, qst.files[1].id)
assertEquals("quest58.dat", qst.files[1].filename)
assertEquals("PSO/Lost HEAT SWORD", qst.files[1].questName)
}
}

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

@ -27,6 +27,10 @@ class ArrayBufferCursor(
set(value) {
require(size <= backingBuffer.byteLength - offset)
field = value
if (position > size) {
position = size
}
}
override var endianness: Endianness

4
lib/src/jsTest/kotlin/world/phantasmal/lib/cursor/ArrayBufferCursorTests.kt
View File

@ -4,6 +4,6 @@ import org.khronos.webgl.Uint8Array
import world.phantasmal.lib.Endianness
class ArrayBufferCursorTests : WritableCursorTests() {
override fun createCursor(bytes: ByteArray, endianness: Endianness) =
ArrayBufferCursor(Uint8Array(bytes.toTypedArray()).buffer, endianness)
override fun createCursor(bytes: ByteArray, endianness: Endianness, size: Int) =
ArrayBufferCursor(Uint8Array(bytes.toTypedArray()).buffer, endianness, size = size)
}

5
observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/ListValCreation.kt
View File

@ -1,7 +1,12 @@
package world.phantasmal.observable.value.list
private val EMPTY_LIST_VAL = StaticListVal<Nothing>(emptyList())
fun <E> listVal(vararg elements: E): ListVal<E> = StaticListVal(elements.toList())
@Suppress("UNCHECKED_CAST")
fun <E> emptyListVal(): ListVal<E> = EMPTY_LIST_VAL as ListVal<E>
fun <E> mutableListVal(
elements: MutableList<E> = mutableListOf(),
extractObservables: ObservablesExtractor<E>? = null,

14
web/src/main/kotlin/world/phantasmal/web/questEditor/QuestEditor.kt
View File

@ -4,16 +4,15 @@ import kotlinx.coroutines.CoroutineScope
import org.w3c.dom.HTMLCanvasElement
import world.phantasmal.web.core.loading.AssetLoader
import world.phantasmal.web.externals.babylon.Engine
import world.phantasmal.web.questEditor.controllers.NpcCountsController
import world.phantasmal.web.questEditor.controllers.QuestEditorToolbarController
import world.phantasmal.web.questEditor.controllers.QuestInfoController
import world.phantasmal.web.questEditor.loading.EntityAssetLoader
import world.phantasmal.web.questEditor.loading.QuestLoader
import world.phantasmal.web.questEditor.rendering.QuestEditorMeshManager
import world.phantasmal.web.questEditor.rendering.QuestRenderer
import world.phantasmal.web.questEditor.stores.QuestEditorStore
import world.phantasmal.web.questEditor.widgets.QuestEditorRendererWidget
import world.phantasmal.web.questEditor.widgets.QuestEditorToolbar
import world.phantasmal.web.questEditor.widgets.QuestEditorWidget
import world.phantasmal.web.questEditor.widgets.QuestInfoWidget
import world.phantasmal.web.questEditor.widgets.*
import world.phantasmal.webui.DisposableContainer
import world.phantasmal.webui.widgets.Widget
@ -22,19 +21,24 @@ class QuestEditor(
private val assetLoader: AssetLoader,
private val createEngine: (HTMLCanvasElement) -> Engine,
) : DisposableContainer() {
// Asset Loaders
private val questLoader = addDisposable(QuestLoader(scope, assetLoader))
// Stores
private val questEditorStore = addDisposable(QuestEditorStore(scope))
// Controllers
private val toolbarController =
addDisposable(QuestEditorToolbarController(scope, questEditorStore))
addDisposable(QuestEditorToolbarController(scope, questLoader, questEditorStore))
private val questInfoController = addDisposable(QuestInfoController(scope, questEditorStore))
private val npcCountsController = addDisposable(NpcCountsController(scope, questEditorStore))
fun createWidget(): Widget =
QuestEditorWidget(
scope,
QuestEditorToolbar(scope, toolbarController),
{ scope -> QuestInfoWidget(scope, questInfoController) },
{ scope -> NpcCountsWidget(scope, npcCountsController) },
{ scope -> QuestEditorRendererWidget(scope, ::createQuestEditorRenderer) }
)

44
web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/NpcCountsController.kt Normal file
View File

@ -0,0 +1,44 @@
package world.phantasmal.web.questEditor.controllers
import kotlinx.coroutines.CoroutineScope
import world.phantasmal.lib.fileFormats.quest.NpcType
import world.phantasmal.observable.value.Val
import world.phantasmal.observable.value.list.emptyListVal
import world.phantasmal.web.questEditor.models.QuestNpcModel
import world.phantasmal.web.questEditor.stores.QuestEditorStore
import world.phantasmal.webui.controllers.Controller
class NpcCountsController(scope: CoroutineScope, store: QuestEditorStore) : Controller(scope) {
val unavailable: Val<Boolean> = store.currentQuest.map { it == null }
val npcCounts: Val<List<NameWithCount>> = store.currentQuest
.flatMap { it?.npcs ?: emptyListVal() }
.map(::countNpcs)
private fun countNpcs(npcs: List<QuestNpcModel>): List<NameWithCount> {
val npcCounts = mutableMapOf<NpcType, Int>()
var extraCanadines = 0
for (npc in npcs) {
// Don't count Vol Opt twice.
if (npc.type != NpcType.VolOptPart2) {
npcCounts[npc.type] = (npcCounts[npc.type] ?: 0) + 1
// Cananes always come with 8 canadines.
if (npc.type == NpcType.Canane) {
extraCanadines += 8
}
}
}
return npcCounts.entries
// Sort by canonical order.
.sortedBy { (npcType) -> npcType.ordinal }
.map { (npcType, count) ->
val extra = if (npcType == NpcType.Canadine) extraCanadines else 0
NameWithCount(npcType.simpleName, (count + extra).toString())
}
}
data class NameWithCount(val name: String, val count: String)
}

36
web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/QuestEditorToolbarController.kt
View File

@ -1,22 +1,28 @@
package world.phantasmal.web.questEditor.controllers
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
import mu.KotlinLogging
import org.w3c.files.File
import world.phantasmal.core.*
import world.phantasmal.lib.Endianness
import world.phantasmal.lib.cursor.cursor
import world.phantasmal.lib.fileFormats.quest.Episode
import world.phantasmal.lib.fileFormats.quest.Quest
import world.phantasmal.lib.fileFormats.quest.parseBinDatToQuest
import world.phantasmal.lib.fileFormats.quest.parseQstToQuest
import world.phantasmal.observable.value.Val
import world.phantasmal.observable.value.mutableVal
import world.phantasmal.web.questEditor.loading.QuestLoader
import world.phantasmal.web.questEditor.stores.QuestEditorStore
import world.phantasmal.web.questEditor.stores.convertQuestToModel
import world.phantasmal.webui.controllers.Controller
import world.phantasmal.webui.readFile
private val logger = KotlinLogging.logger {}
class QuestEditorToolbarController(
scope: CoroutineScope,
private val questLoader: QuestLoader,
private val questEditorStore: QuestEditorStore,
) : Controller(scope) {
private val _resultDialogVisible = mutableVal(false)
@ -25,15 +31,25 @@ class QuestEditorToolbarController(
val resultDialogVisible: Val<Boolean> = _resultDialogVisible
val result: Val<PwResult<*>?> = _result
fun openFiles(files: List<File>) {
launch {
if (files.isEmpty()) return@launch
suspend fun createNewQuest(episode: Episode) {
questEditorStore.setCurrentQuest(
convertQuestToModel(questLoader.loadDefaultQuest(episode))
)
}
suspend fun openFiles(files: List<File>) {
try {
if (files.isEmpty()) return
val qst = files.find { it.name.endsWith(".qst", ignoreCase = true) }
if (qst != null) {
val buffer = readFile(qst)
// TODO: Parse qst.
val parseResult = parseQstToQuest(readFile(qst).cursor(Endianness.Little))
setResult(parseResult)
if (parseResult is Success) {
setCurrentQuest(parseResult.value.quest)
}
} else {
val bin = files.find { it.name.endsWith(".bin", ignoreCase = true) }
val dat = files.find { it.name.endsWith(".dat", ignoreCase = true) }
@ -43,7 +59,7 @@ class QuestEditorToolbarController(
Severity.Error,
"Please select a .qst file or one .bin and one .dat file."
))))
return@launch
return
}
val parseResult = parseBinDatToQuest(
@ -56,6 +72,12 @@ class QuestEditorToolbarController(
setCurrentQuest(parseResult.value)
}
}
} catch (e: Throwable) {
setResult(
PwResult.build<Nothing>(logger)
.addProblem(Severity.Error, "Couldn't parse file.", cause = e)
.failure()
)
}
}

5
web/src/main/kotlin/world/phantasmal/web/questEditor/loading/EntityAssetLoader.kt
View File

@ -176,7 +176,10 @@ private fun entityTypeToGeometryFormat(type: EntityType): GeomFormat =
when (type) {
is NpcType -> {
when (type) {
NpcType.Dubswitch -> GeomFormat.Xj
NpcType.Dubswitch,
NpcType.Dubswitch2,
-> GeomFormat.Xj
else -> GeomFormat.Nj
}
}

42
web/src/main/kotlin/world/phantasmal/web/questEditor/loading/QuestLoader.kt Normal file
View File

@ -0,0 +1,42 @@
package world.phantasmal.web.questEditor.loading
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.async
import org.khronos.webgl.ArrayBuffer
import world.phantasmal.core.disposable.TrackedDisposable
import world.phantasmal.lib.Endianness
import world.phantasmal.lib.cursor.cursor
import world.phantasmal.lib.fileFormats.quest.Episode
import world.phantasmal.lib.fileFormats.quest.Quest
import world.phantasmal.lib.fileFormats.quest.parseQstToQuest
import world.phantasmal.web.core.loading.AssetLoader
class QuestLoader(
private val scope: CoroutineScope,
private val assetLoader: AssetLoader,
) : TrackedDisposable() {
private val cache = LoadingCache<String, ArrayBuffer>()
override fun internalDispose() {
cache.dispose()
super.internalDispose()
}
suspend fun loadDefaultQuest(episode: Episode): Quest {
require(episode == Episode.I) {
"Episode $episode not yet supported."
}
return loadQuest("/defaults/default_ep_1.qst")
}
private suspend fun loadQuest(path: String): Quest {
val buffer = cache.getOrPut(path) {
scope.async {
assetLoader.loadArrayBuffer("/quests$path")
}
}.await()
return parseQstToQuest(buffer.cursor(Endianness.Little)).unwrap().quest
}
}

65
web/src/main/kotlin/world/phantasmal/web/questEditor/widgets/NpcCountsWidget.kt Normal file
View File

@ -0,0 +1,65 @@
package world.phantasmal.web.questEditor.widgets
import kotlinx.coroutines.CoroutineScope
import org.w3c.dom.Node
import world.phantasmal.observable.value.not
import world.phantasmal.web.core.widgets.UnavailableWidget
import world.phantasmal.web.questEditor.controllers.NpcCountsController
import world.phantasmal.webui.dom.*
import world.phantasmal.webui.widgets.Widget
class NpcCountsWidget(
scope: CoroutineScope,
private val ctrl: NpcCountsController,
) : Widget(scope) {
override fun Node.createElement() =
div {
className = "pw-quest-editor-npc-counts"
table {
hidden(ctrl.unavailable)
bindChildrenTo(ctrl.npcCounts) { (name, count), _ ->
tr {
th { textContent = "$name:" }
td { textContent = count }
}
}
}
addChild(UnavailableWidget(
scope,
hidden = !ctrl.unavailable,
message = "No quest loaded."
))
}
companion object {
init {
@Suppress("CssUnusedSymbol")
// language=css
style("""
.pw-quest-editor-npc-counts {
box-sizing: border-box;
padding: 3px;
overflow: auto;
}
.pw-quest-editor-npc-counts table {
user-select: text;
width: 100%;
max-width: 300px;
margin: 0 auto;
}
.pw-quest-editor-npc-counts th {
cursor: text;
text-align: left;
}
.pw-quest-editor-npc-counts td {
cursor: text;
}
""".trimIndent())
}
}
}

11
web/src/main/kotlin/world/phantasmal/web/questEditor/widgets/QuestEditorToolbar.kt
View File

@ -1,10 +1,13 @@
package world.phantasmal.web.questEditor.widgets
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
import org.w3c.dom.Node
import world.phantasmal.lib.fileFormats.quest.Episode
import world.phantasmal.web.questEditor.controllers.QuestEditorToolbarController
import world.phantasmal.webui.dom.Icon
import world.phantasmal.webui.dom.div
import world.phantasmal.webui.widgets.Button
import world.phantasmal.webui.widgets.FileButton
import world.phantasmal.webui.widgets.Toolbar
import world.phantasmal.webui.widgets.Widget
@ -20,13 +23,19 @@ class QuestEditorToolbar(
addChild(Toolbar(
scope,
children = listOf(
Button(
scope,
text = "New quest",
iconLeft = Icon.NewFile,
onClick = { scope.launch { ctrl.createNewQuest(Episode.I) } }
),
FileButton(
scope,
text = "Open file...",
iconLeft = Icon.File,
accept = ".bin, .dat, .qst",
multiple = true,
filesSelected = ctrl::openFiles
filesSelected = { files -> scope.launch { ctrl.openFiles(files) } }
)
)
))

3
web/src/main/kotlin/world/phantasmal/web/questEditor/widgets/QuestEditorWidget.kt
View File

@ -21,6 +21,7 @@ class QuestEditorWidget(
scope: CoroutineScope,
private val toolbar: Widget,
private val createQuestInfoWidget: (CoroutineScope) -> Widget,
private val createNpcCountsWidget: (CoroutineScope) -> Widget,
private val createQuestRendererWidget: (CoroutineScope) -> Widget,
) : Widget(scope) {
override fun Node.createElement() =
@ -45,7 +46,7 @@ class QuestEditorWidget(
DockedWidget(
title = "NPC Counts",
id = "npc_counts",
createWidget = ::TestWidget
createWidget = createNpcCountsWidget
),
)
),