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

Quests can be saved again.

Browse Source
This commit is contained in:
Daan Vanden Bosch 2020-12-22 23:05:11 +01:00
parent 0d07749705
commit 71669642ae
22 changed files with 1139 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
lib/karma.config.d/karma.config.js Normal file
View File

@ -0,0 +1,7 @@
config.set({
client: {
mocha: {
timeout: 10_000
}
}
});

34
lib/src/commonMain/kotlin/world/phantasmal/lib/asm/BytecodeIr.kt
View File

@ -10,6 +10,9 @@ class BytecodeIr(
) {
fun instructionSegments(): List<InstructionSegment> =
segments.filterIsInstance<InstructionSegment>()
fun copy(): BytecodeIr =
BytecodeIr(segments.map { it.copy() })
}
enum class SegmentType {
@ -27,25 +30,40 @@ sealed class Segment(
val type: SegmentType,
val labels: MutableList<Int>,
val srcLoc: SegmentSrcLoc,
)
) {
abstract fun copy(): Segment
}
class InstructionSegment(
labels: MutableList<Int>,
val instructions: MutableList<Instruction>,
srcLoc: SegmentSrcLoc = SegmentSrcLoc(mutableListOf()),
) : Segment(SegmentType.Instructions, labels, srcLoc)
) : Segment(SegmentType.Instructions, labels, srcLoc) {
override fun copy(): InstructionSegment =
InstructionSegment(
ArrayList(labels),
instructions.mapTo(mutableListOf()) { it.copy() },
srcLoc.copy(),
)
}
class DataSegment(
labels: MutableList<Int>,
val data: Buffer,
srcLoc: SegmentSrcLoc = SegmentSrcLoc(mutableListOf()),
) : Segment(SegmentType.Data, labels, srcLoc)
) : Segment(SegmentType.Data, labels, srcLoc) {
override fun copy(): DataSegment =
DataSegment(ArrayList(labels), data.copy(), srcLoc.copy())
}
class StringSegment(
labels: MutableList<Int>,
var value: String,
srcLoc: SegmentSrcLoc = SegmentSrcLoc(mutableListOf()),
) : Segment(SegmentType.String, labels, srcLoc)
) : Segment(SegmentType.String, labels, srcLoc) {
override fun copy(): StringSegment =
StringSegment(ArrayList(labels), value, srcLoc.copy())
}
/**
* Opcode invocation.
@ -179,6 +197,9 @@ class Instruction(
return size
}
fun copy(): Instruction =
Instruction(opcode, args, srcLoc)
}
/**
@ -207,4 +228,7 @@ class InstructionSrcLoc(
/**
* Locations of a segment's labels in the source assembly code.
*/
class SegmentSrcLoc(val labels: MutableList<SrcLoc> = mutableListOf())
class SegmentSrcLoc(val labels: MutableList<SrcLoc> = mutableListOf()) {
fun copy(): SegmentSrcLoc =
SegmentSrcLoc(ArrayList(labels))
}

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

@ -107,6 +107,11 @@ expect class Buffer {
fun toBase64(): String
/**
* Returns a copy of this buffer of the same size. The copy's capacity will equal its size.
*/
fun copy(): Buffer
companion object {
/**
* Returns a new buffer the given initial capacity and size 0.

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

@ -2,9 +2,9 @@ package world.phantasmal.lib.fileFormats
import world.phantasmal.lib.cursor.Cursor
class Vec2(val x: Float, val y: Float)
data class Vec2(val x: Float, val y: Float)
class Vec3(val x: Float, val y: Float, val z: Float)
data class Vec3(val x: Float, val y: Float, val z: Float)
fun Cursor.vec2Float(): Vec2 = Vec2(float(), float())

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

@ -3,6 +3,7 @@ package world.phantasmal.lib.fileFormats.quest
import mu.KotlinLogging
import world.phantasmal.lib.buffer.Buffer
import world.phantasmal.lib.cursor.Cursor
import world.phantasmal.lib.cursor.cursor
private val logger = KotlinLogging.logger {}
@ -116,3 +117,80 @@ fun parseBin(cursor: Cursor): BinFile {
shopItems,
)
}
fun writeBin(bin: BinFile): Buffer {
require(bin.questName.length <= 32) {
"questName can't be longer than 32 characters, was ${bin.questName.length}"
}
require(bin.shortDescription.length <= 127) {
"shortDescription can't be longer than 127 characters, was ${bin.shortDescription.length}"
}
require(bin.longDescription.length <= 287) {
"longDescription can't be longer than 287 characters, was ${bin.longDescription.length}"
}
require(bin.shopItems.isEmpty() || bin.format == BinFormat.BB) {
"shopItems is only supported in BlueBurst quests."
}
require(bin.shopItems.size <= 932) {
"shopItems can't be larger than 932, was ${bin.shopItems.size}."
}
val bytecodeOffset = when (bin.format) {
BinFormat.DC_GC -> DC_GC_OBJECT_CODE_OFFSET
BinFormat.PC -> PC_OBJECT_CODE_OFFSET
BinFormat.BB -> BB_OBJECT_CODE_OFFSET
}
val fileSize = bytecodeOffset + bin.bytecode.size + 4 * bin.labelOffsets.size
val buffer = Buffer.withCapacity(fileSize)
val cursor = buffer.cursor()
cursor.writeInt(bytecodeOffset)
cursor.writeInt(bytecodeOffset + bin.bytecode.size) // Label table offset.
cursor.writeInt(fileSize)
cursor.writeInt(-1)
if (bin.format == BinFormat.DC_GC) {
cursor.writeByte(0)
cursor.writeByte(bin.language.toByte())
cursor.writeShort(bin.questId.toShort())
cursor.writeStringAscii(bin.questName, 32)
cursor.writeStringAscii(bin.shortDescription, 128)
cursor.writeStringAscii(bin.longDescription, 288)
} else {
if (bin.format == BinFormat.PC) {
cursor.writeShort(bin.language.toShort())
cursor.writeShort(bin.questId.toShort())
} else {
cursor.writeInt(bin.questId)
cursor.writeInt(bin.language)
}
cursor.writeStringUtf16(bin.questName, 64)
cursor.writeStringUtf16(bin.shortDescription, 256)
cursor.writeStringUtf16(bin.longDescription, 576)
}
if (bin.format == BinFormat.BB) {
cursor.writeInt(0)
cursor.writeUIntArray(bin.shopItems)
repeat(932 - bin.shopItems.size) {
cursor.writeUInt(0u)
}
}
check(cursor.position == bytecodeOffset) {
"Expected to write $bytecodeOffset bytes before bytecode, but wrote ${cursor.position}."
}
cursor.writeCursor(bin.bytecode.cursor())
cursor.writeIntArray(bin.labelOffsets)
check(cursor.position == fileSize) {
"Expected to write $fileSize bytes, but wrote ${cursor.position}."
}
return buffer
}

107
lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Bytecode.kt
View File

@ -3,6 +3,7 @@ package world.phantasmal.lib.fileFormats.quest
import mu.KotlinLogging
import world.phantasmal.core.PwResult
import world.phantasmal.core.Severity
import world.phantasmal.lib.Endianness
import world.phantasmal.lib.asm.*
import world.phantasmal.lib.asm.dataFlowAnalysis.ControlFlowGraph
import world.phantasmal.lib.asm.dataFlowAnalysis.getRegisterValue
@ -10,6 +11,7 @@ import world.phantasmal.lib.asm.dataFlowAnalysis.getStackValue
import world.phantasmal.lib.buffer.Buffer
import world.phantasmal.lib.cursor.BufferCursor
import world.phantasmal.lib.cursor.Cursor
import world.phantasmal.lib.cursor.cursor
import kotlin.math.ceil
import kotlin.math.min
@ -118,7 +120,13 @@ fun parseBytecode(
is DataSegment -> segment.data.size
// String segments should be multiples of 4 bytes.
is StringSegment -> 4 * ceil((segment.value.length + 1) / 2.0).toInt()
is StringSegment -> {
if (dcGcFormat) {
4 * ceil((segment.value.length + 1) / 4.0).toInt()
} else {
4 * ceil((segment.value.length + 1) / 2.0).toInt()
}
}
}
}
@ -558,6 +566,103 @@ private fun parseInstructionArguments(
return args
}
fun writeBytecode(bytecodeIr: BytecodeIr, dcGcFormat: Boolean): BytecodeAndLabelOffsets {
val buffer = Buffer.withCapacity(100 * bytecodeIr.segments.size, Endianness.Little)
val cursor = buffer.cursor()
// Keep track of label offsets.
val largestLabel = bytecodeIr.segments.asSequence().flatMap { it.labels }.maxOrNull() ?: -1
val labelOffsets = IntArray(largestLabel + 1) { -1 }
for (segment in bytecodeIr.segments) {
for (label in segment.labels) {
labelOffsets[label] = cursor.position
}
when (segment) {
is InstructionSegment -> {
for (instruction in segment.instructions) {
val opcode = instruction.opcode
if (opcode.size == 2) {
cursor.writeByte((opcode.code ushr 8).toByte())
}
cursor.writeByte(opcode.code.toByte())
if (opcode.stack != StackInteraction.Pop) {
for (i in opcode.params.indices) {
val param = opcode.params[i]
val args = instruction.getArgs(i)
val arg = args.first()
when (param.type) {
ByteType -> cursor.writeByte((arg.value as Int).toByte())
ShortType -> cursor.writeShort((arg.value as Int).toShort())
IntType -> cursor.writeInt(arg.value as Int)
FloatType -> cursor.writeFloat(arg.value as Float)
// Ensure this case is before the LabelType case because
// ILabelVarType extends LabelType.
ILabelVarType -> {
cursor.writeByte(args.size.toByte())
for (a in args) {
cursor.writeShort((a.value as Int).toShort())
}
}
is LabelType -> cursor.writeShort((arg.value as Int).toShort())
StringType -> {
val str = arg.value as String
if (dcGcFormat) cursor.writeStringAscii(str, str.length + 1)
else cursor.writeStringUtf16(str, 2 * str.length + 2)
}
RegRefType, is RegTupRefType -> {
cursor.writeByte((arg.value as Int).toByte())
}
RegRefVarType -> {
cursor.writeByte(args.size.toByte())
for (a in args) {
cursor.writeByte((a.value as Int).toByte())
}
}
else -> error(
"Parameter type ${param.type::class.simpleName} not supported."
)
}
}
}
}
}
is StringSegment -> {
// String segments should be multiples of 4 bytes.
if (dcGcFormat) {
val byteLength = 4 * ceil((segment.value.length + 1) / 4.0).toInt()
cursor.writeStringAscii(segment.value, byteLength)
} else {
val byteLength = 4 * ceil((segment.value.length + 1) / 2.0).toInt()
cursor.writeStringUtf16(segment.value, byteLength)
}
}
is DataSegment -> {
cursor.writeCursor(segment.data.cursor())
}
}
}
return BytecodeAndLabelOffsets(buffer, labelOffsets)
}
class BytecodeAndLabelOffsets(
val bytecode: Buffer,
val labelOffsets: IntArray,
) {
operator fun component1(): Buffer = bytecode
operator fun component2(): IntArray = labelOffsets
}
private data class LabelAndOffset(val label: Int, val offset: Int)
private data class OffsetAndIndex(val offset: Int, val index: Int)
private class LabelInfo(val offset: Int, val next: LabelAndOffset?)

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

@ -1,15 +1,19 @@
package world.phantasmal.lib.fileFormats.quest
import mu.KotlinLogging
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.max
private val logger = KotlinLogging.logger {}
private const val EVENT_ACTION_SPAWN_NPCS = 0x8
private const val EVENT_ACTION_UNLOCK = 0xA
private const val EVENT_ACTION_LOCK = 0xB
private const val EVENT_ACTION_TRIGGER_EVENT = 0xC
private const val EVENT_ACTION_SPAWN_NPCS: Byte = 0x8
private const val EVENT_ACTION_UNLOCK: Byte = 0xA
private const val EVENT_ACTION_LOCK: Byte = 0xB
private const val EVENT_ACTION_TRIGGER_EVENT: Byte = 0xC
const val OBJECT_BYTE_SIZE = 68
const val NPC_BYTE_SIZE = 72
@ -31,7 +35,7 @@ class DatEvent(
var sectionId: Short,
var wave: Short,
var delay: Short,
val actions: MutableList<DatEventAction>,
val actions: List<DatEventAction>,
val areaId: Int,
val unknown: Short,
)
@ -156,13 +160,13 @@ private fun parseEvents(cursor: Cursor, areaId: Int, events: MutableList<DatEven
val unknown = cursor.short() // "wavesetting"?
val eventActionsOffset = cursor.int()
val actions: MutableList<DatEventAction> =
val actions: List<DatEventAction> =
if (eventActionsOffset < actionsCursor.size) {
actionsCursor.seekStart(eventActionsOffset)
parseEventActions(actionsCursor)
} else {
logger.warn { "Invalid event actions offset $eventActionsOffset for event ${id}." }
mutableListOf()
emptyList()
}
events.add(DatEvent(
@ -200,12 +204,12 @@ private fun parseEvents(cursor: Cursor, areaId: Int, events: MutableList<DatEven
cursor.seekStart(actionsOffset + actionsCursor.position)
}
private fun parseEventActions(cursor: Cursor): MutableList<DatEventAction> {
private fun parseEventActions(cursor: Cursor): List<DatEventAction> {
val actions = mutableListOf<DatEventAction>()
outer@ while (cursor.hasBytesLeft()) {
when (val type = cursor.uByte().toInt()) {
1 -> break@outer
when (val type = cursor.byte()) {
(1).toByte() -> break@outer
EVENT_ACTION_SPAWN_NPCS ->
actions.add(DatEventAction.SpawnNpcs(
@ -237,3 +241,154 @@ private fun parseEventActions(cursor: Cursor): MutableList<DatEventAction> {
return actions
}
fun writeDat(dat: DatFile): Buffer {
val buffer = Buffer.withCapacity(
dat.objs.size * (16 + OBJECT_BYTE_SIZE) +
dat.npcs.size * (16 + NPC_BYTE_SIZE) +
dat.unknowns.sumBy { it.totalSize },
endianness = Endianness.Little,
)
val cursor = buffer.cursor()
writeEntities(cursor, dat.objs, 1, OBJECT_BYTE_SIZE)
writeEntities(cursor, dat.npcs, 2, NPC_BYTE_SIZE)
writeEvents(cursor, dat.events)
for (unknown in dat.unknowns) {
cursor.writeInt(unknown.entityType)
cursor.writeInt(unknown.totalSize)
cursor.writeInt(unknown.areaId)
cursor.writeInt(unknown.entitiesSize)
cursor.writeByteArray(unknown.data)
}
// Final header.
cursor.writeInt(0)
cursor.writeInt(0)
cursor.writeInt(0)
cursor.writeInt(0)
return buffer
}
private fun writeEntities(
cursor: WritableCursor,
entities: List<DatEntity>,
entityType: Int,
entitySize: Int,
) {
val groupedEntities = entities.groupBy { it.areaId }
for ((areaId, areaEntities) in groupedEntities.entries.sortedBy { it.key }) {
val entitiesSize = areaEntities.size * entitySize
cursor.writeInt(entityType)
cursor.writeInt(16 + entitiesSize)
cursor.writeInt(areaId)
cursor.writeInt(entitiesSize)
val startPos = cursor.position
for (entity in areaEntities) {
require(entity.data.size == entitySize) {
"Malformed entity in area $areaId, data buffer was of size ${
entity.data.size
} instead of expected $entitySize."
}
cursor.writeCursor(entity.data.cursor())
}
check(cursor.position == startPos + entitiesSize) {
"Wrote ${
cursor.position - startPos
} bytes of entity data instead of expected $entitiesSize bytes for area $areaId."
}
}
}
private fun writeEvents(cursor: WritableCursor, events: List<DatEvent>) {
val groupedEvents = events.groupBy { it.areaId }
for ((areaId, areaEvents) in groupedEvents.entries.sortedBy { it.key }) {
// Standard header.
cursor.writeInt(3) // Entity type
val totalSizeOffset = cursor.position
cursor.writeInt(0) // Placeholder for the total size.
cursor.writeInt(areaId)
val entitiesSizeOffset = cursor.position
cursor.writeInt(0) // Placeholder for the entities size.
// Event header.
val startPos = cursor.position
// TODO: actual event size is dependent on the event type (challenge mode).
// Absolute offset.
val actionsOffset = startPos + 16 + 20 * areaEvents.size
cursor.size = max(actionsOffset, cursor.size)
cursor.writeInt(actionsOffset - startPos)
cursor.writeInt(0x10)
cursor.writeInt(areaEvents.size)
cursor.writeInt(0) // TODO: write event type (challenge mode).
// Relative offset.
var eventActionsOffset = 0
for (event in areaEvents) {
cursor.writeInt(event.id)
cursor.writeInt(0x10000)
cursor.writeShort(event.sectionId)
cursor.writeShort(event.wave)
cursor.writeShort(event.delay)
cursor.writeShort(event.unknown)
cursor.writeInt(eventActionsOffset)
val nextEventPos = cursor.position
cursor.seekStart(actionsOffset + eventActionsOffset)
for (action in event.actions) {
when (action) {
is DatEventAction.SpawnNpcs -> {
cursor.writeByte(EVENT_ACTION_SPAWN_NPCS)
cursor.writeShort(action.sectionId)
cursor.writeShort(action.appearFlag)
}
is DatEventAction.Unlock -> {
cursor.writeByte(EVENT_ACTION_UNLOCK)
cursor.writeShort(action.doorId)
}
is DatEventAction.Lock -> {
cursor.writeByte(EVENT_ACTION_LOCK)
cursor.writeShort(action.doorId)
}
is DatEventAction.TriggerEvent -> {
cursor.writeByte(EVENT_ACTION_TRIGGER_EVENT)
cursor.writeInt(action.eventId)
}
}
}
// End of event actions.
cursor.writeByte(1)
eventActionsOffset = cursor.position - actionsOffset
cursor.seekStart(nextEventPos)
}
cursor.seekStart(actionsOffset + eventActionsOffset)
while ((cursor.position - actionsOffset) % 4 != 0) {
cursor.writeByte(-1)
}
val endPos = cursor.position
cursor.seekStart(totalSizeOffset)
cursor.writeInt(16 + endPos - startPos)
cursor.seekStart(entitiesSizeOffset)
cursor.writeInt(endPos - startPos)
cursor.seekStart(endPos)
}
}

217
lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Qst.kt
View File

@ -12,6 +12,7 @@ import world.phantasmal.lib.cursor.WritableCursor
import world.phantasmal.lib.cursor.cursor
import kotlin.math.ceil
import kotlin.math.max
import kotlin.math.min
private val logger = KotlinLogging.logger {}
@ -134,7 +135,8 @@ private fun parseHeaders(cursor: Cursor): List<QstHeader> {
var prevQuestId: Int? = null
var prevFilename: String? = null
// .qst files should have two headers, some malformed files have more.
// .qst files should have two headers. Some malformed files have more, so we tried to detect at
// most 4 headers.
repeat(4) {
// Detect version and whether it's an online or download quest.
val version: Version
@ -407,3 +409,216 @@ private fun parseFiles(
}
)
}
fun writeQst(qst: QstContent): Buffer {
val fileHeaderSize: Int
val chunkSize: Int
when (qst.version) {
Version.DC, Version.GC, Version.PC -> {
fileHeaderSize = DC_GC_PC_HEADER_SIZE
chunkSize = DC_GC_PC_CHUNK_SIZE
}
Version.BB -> {
fileHeaderSize = BB_HEADER_SIZE
chunkSize = BB_CHUNK_SIZE
}
}
val totalSize = qst.files.sumOf {
fileHeaderSize + ceil(it.data.size.toDouble() / CHUNK_BODY_SIZE).toInt() * chunkSize
}
val buffer = Buffer.withCapacity(totalSize)
val cursor = buffer.cursor()
writeFileHeaders(cursor, qst.files, qst.version, qst.online, fileHeaderSize)
writeFileChunks(cursor, qst.files, qst.version)
check(cursor.position == totalSize) {
"Expected a final file size of $totalSize, but got ${cursor.position}."
}
return buffer
}
private fun writeFileHeaders(
cursor: WritableCursor,
files: List<QstContainedFile>,
version: Version,
online: Boolean,
headerSize: Int,
) {
val maxId: Int
val maxQuestNameLength: Int
if (version == Version.BB) {
maxId = 0xffff
maxQuestNameLength = 23
} else {
maxId = 0xff
maxQuestNameLength = 31
}
for (file in files) {
require(file.id == null || (file.id in 0..maxId)) {
"Quest ID should be between 0 and $maxId, inclusive."
}
require(file.questName == null || file.questName.length <= maxQuestNameLength) {
"File ${file.filename} has a quest name longer than $maxQuestNameLength characters (${file.questName})."
}
require(file.filename.length <= 15) {
"File ${file.filename} has a filename longer than 15 characters."
}
when (version) {
Version.DC -> {
cursor.writeUByte((if (online) ONLINE_QUEST else DOWNLOAD_QUEST).toUByte())
cursor.writeUByte(file.id?.toUByte() ?: 0u)
cursor.writeUShort(headerSize.toUShort())
cursor.writeStringAscii(file.questName ?: file.filename, 32)
cursor.writeByte(0)
cursor.writeByte(0)
cursor.writeByte(0)
cursor.writeStringAscii(file.filename, 16)
cursor.writeByte(0)
cursor.writeInt(file.data.size)
}
Version.GC -> {
cursor.writeUByte((if (online) ONLINE_QUEST else DOWNLOAD_QUEST).toUByte())
cursor.writeUByte(file.id?.toUByte() ?: 0u)
cursor.writeUShort(headerSize.toUShort())
cursor.writeStringAscii(file.questName ?: file.filename, 32)
cursor.writeInt(0)
cursor.writeStringAscii(file.filename, 16)
cursor.writeInt(file.data.size)
}
Version.PC -> {
cursor.writeUShort(headerSize.toUShort())
cursor.writeUByte((if (online) ONLINE_QUEST else DOWNLOAD_QUEST).toUByte())
cursor.writeUByte(file.id?.toUByte() ?: 0u)
cursor.writeStringAscii(file.questName ?: file.filename, 32)
cursor.writeInt(0)
cursor.writeStringAscii(file.filename, 16)
cursor.writeInt(file.data.size)
}
Version.BB -> {
cursor.writeUShort(headerSize.toUShort())
cursor.writeUShort((if (online) ONLINE_QUEST else DOWNLOAD_QUEST).toUShort())
cursor.writeUShort(file.id?.toUShort() ?: 0u)
repeat(38) { cursor.writeByte(0) }
cursor.writeStringAscii(file.filename, 16)
cursor.writeInt(file.data.size)
cursor.writeStringAscii(file.questName ?: file.filename, 24)
}
}
}
}
private class FileToChunk(
var no: Int,
val data: Cursor,
val name: String,
)
private fun writeFileChunks(
cursor: WritableCursor,
files: List<QstContainedFile>,
version: Version,
) {
// Files are interleaved in chunks. Each chunk has a header, fixed-size data segment and a
// trailer.
val filesToChunk = files.map { file ->
FileToChunk(
no = 0,
data = file.data.cursor(),
name = file.filename,
)
}
var done = 0
while (done < filesToChunk.size) {
for (fileToChunk in filesToChunk) {
if (fileToChunk.data.hasBytesLeft()) {
if (
!writeFileChunk(
cursor,
fileToChunk.data,
fileToChunk.no++,
fileToChunk.name,
version,
)
) {
done++
}
}
}
}
for (fileToChunk in filesToChunk) {
val expectedChunks = ceil(fileToChunk.data.size.toDouble() / CHUNK_BODY_SIZE).toInt()
check(fileToChunk.no == expectedChunks) {
"""Expected to write $expectedChunks chunks for file "${
fileToChunk.name
}" but ${fileToChunk.no} where written."""
}
}
}
/**
* Returns true if there are bytes left to write in [data], false otherwise.
*/
private fun writeFileChunk(
cursor: WritableCursor,
data: Cursor,
chunkNo: Int,
name: String,
version: Version,
): Boolean {
when (version) {
Version.DC,
Version.GC,
-> {
cursor.writeByte(0)
cursor.writeUByte(chunkNo.toUByte())
cursor.writeShort(0)
}
Version.PC -> {
cursor.writeByte(0)
cursor.writeByte(0)
cursor.writeByte(0)
cursor.writeUByte(chunkNo.toUByte())
}
Version.BB -> {
cursor.writeByte(28)
cursor.writeByte(4)
cursor.writeByte(19)
cursor.writeByte(0)
cursor.writeInt(chunkNo)
}
}
cursor.writeStringAscii(name, 16)
val size = min(CHUNK_BODY_SIZE, data.bytesLeft)
cursor.writeCursor(data.take(size))
// Padding.
repeat(CHUNK_BODY_SIZE - size) {
cursor.writeByte(0)
}
cursor.writeInt(size)
if (version == Version.BB) {
cursor.writeInt(0)
}
return data.hasBytesLeft()
}

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

@ -1,16 +1,15 @@
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.core.Success
import world.phantasmal.core.*
import world.phantasmal.lib.Episode
import world.phantasmal.lib.asm.BytecodeIr
import world.phantasmal.lib.asm.InstructionSegment
import world.phantasmal.lib.asm.OP_SET_EPISODE
import world.phantasmal.lib.asm.dataFlowAnalysis.ControlFlowGraph
import world.phantasmal.lib.asm.dataFlowAnalysis.getMapDesignations
import world.phantasmal.lib.buffer.Buffer
import world.phantasmal.lib.compression.prs.prsCompress
import world.phantasmal.lib.compression.prs.prsDecompress
import world.phantasmal.lib.cursor.Cursor
import world.phantasmal.lib.cursor.cursor
@ -233,3 +232,56 @@ private fun extractScriptEntryPoints(
return entryPoints
}
/**
* Creates a .qst file from [quest].
*/
fun writeQuestToQst(quest: Quest, filename: String, version: Version, online: Boolean): Buffer {
val dat = writeDat(DatFile(
objs = quest.objects.map { DatEntity(it.areaId, it.data) },
npcs = quest.npcs.map { DatEntity(it.areaId, it.data) },
events = quest.events,
unknowns = quest.datUnknowns,
))
val binFormat = when (version) {
Version.DC, Version.GC -> BinFormat.DC_GC
Version.PC -> BinFormat.PC
Version.BB -> BinFormat.BB
}
val (bytecode, labelOffsets) = writeBytecode(quest.bytecodeIr, binFormat == BinFormat.DC_GC)
val bin = writeBin(BinFile(
binFormat,
quest.id,
quest.language,
quest.name,
quest.shortDescription,
quest.longDescription,
bytecode,
labelOffsets,
quest.shopItems,
))
val baseFilename = (filenameBase(filename) ?: filename).take(11)
return writeQst(QstContent(
version,
online,
files = listOf(
QstContainedFile(
id = quest.id,
filename = "$baseFilename.dat",
questName = quest.name,
data = prsCompress(dat.cursor()).buffer(),
),
QstContainedFile(
id = quest.id,
filename = "$baseFilename.bin",
questName = quest.name,
data = prsCompress(bin.cursor()).buffer(),
),
),
))
}

16
lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/BinTests.kt
View File

@ -1,6 +1,8 @@
package world.phantasmal.lib.fileFormats.quest
import world.phantasmal.lib.cursor.cursor
import world.phantasmal.lib.test.LibTestSuite
import world.phantasmal.lib.test.assertDeepEquals
import world.phantasmal.lib.test.readFile
import kotlin.test.Test
import kotlin.test.assertEquals
@ -20,4 +22,18 @@ class BinTests : LibTestSuite() {
bin.longDescription
)
}
@Test
fun parse_and_write_towards_the_future() = parseAndWriteQuest("/quest118_e_decompressed.bin")
@Test
fun parse_and_write_seat_of_the_heart() = parseAndWriteQuest("/quest27_e_decompressed.bin")
private fun parseAndWriteQuest(file: String) = asyncTest {
val origBin = readFile(file)
val newBin = writeBin(parseBin(origBin)).cursor()
origBin.seekStart(0)
assertDeepEquals(origBin, newBin)
}
}

47
lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/DatTests.kt
View File

@ -1,6 +1,8 @@
package world.phantasmal.lib.fileFormats.quest
import world.phantasmal.lib.cursor.cursor
import world.phantasmal.lib.test.LibTestSuite
import world.phantasmal.lib.test.assertDeepEquals
import world.phantasmal.lib.test.readFile
import kotlin.test.Test
import kotlin.test.assertEquals
@ -13,4 +15,49 @@ class DatTests : LibTestSuite() {
assertEquals(277, dat.objs.size)
assertEquals(216, dat.npcs.size)
}
/**
* Parse a file, convert the resulting structure to DAT again and check whether the end result
* is byte-for-byte equal to the original.
*/
@Test
fun parse_dat_and_write_dat() = asyncTest {
val origDat = readFile("/quest118_e_decompressed.dat")
val newDat = writeDat(parseDat(origDat)).cursor()
origDat.seekStart(0)
assertDeepEquals(origDat, newDat)
}
/**
* Parse a file, modify the resulting structure, convert it to DAT again and check whether the
* end result is byte-for-byte equal to the original except for the bytes that should be
* changed.
*/
@Test
fun parse_modify_write_dat() = asyncTest {
val origDat = readFile("/quest118_e_decompressed.dat")
val parsedDat = parseDat(origDat)
origDat.seekStart(0)
parsedDat.objs[9].data.setFloat(16, 13f)
parsedDat.objs[9].data.setFloat(20, 17f)
parsedDat.objs[9].data.setFloat(24, 19f)
val newDat = writeDat(parsedDat).cursor()
assertEquals(origDat.size, newDat.size)
while (origDat.hasBytesLeft()) {
if (origDat.position == 16 + 9 * OBJECT_BYTE_SIZE + 16) {
origDat.seek(12)
assertEquals(13f, newDat.float())
assertEquals(17f, newDat.float())
assertEquals(19f, newDat.float())
} else {
assertEquals(origDat.byte(), newDat.byte())
}
}
}
}

94
lib/src/commonTest/kotlin/world/phantasmal/lib/fileFormats/quest/QuestTests.kt
View File

@ -3,7 +3,10 @@ package world.phantasmal.lib.fileFormats.quest
import world.phantasmal.core.Success
import world.phantasmal.lib.Episode
import world.phantasmal.lib.asm.*
import world.phantasmal.lib.cursor.Cursor
import world.phantasmal.lib.cursor.cursor
import world.phantasmal.lib.test.LibTestSuite
import world.phantasmal.lib.test.assertDeepEquals
import world.phantasmal.lib.test.readFile
import kotlin.test.Test
import kotlin.test.assertEquals
@ -17,8 +20,23 @@ class QuestTests : LibTestSuite() {
assertTrue(result is Success)
assertTrue(result.problems.isEmpty())
val quest = result.value
testTowardsTheFutureParseResult(result.value)
}
@Test
fun parseQstToQuest_with_towards_the_future() = asyncTest {
val result = parseQstToQuest(readFile("/quest118_e.qst"))
assertTrue(result is Success)
assertTrue(result.problems.isEmpty())
assertEquals(Version.BB, result.value.version)
assertTrue(result.value.online)
testTowardsTheFutureParseResult(result.value.quest)
}
private fun testTowardsTheFutureParseResult(quest: Quest) {
assertEquals("Towards the Future", quest.name)
assertEquals("Challenge the\nnew simulator.", quest.shortDescription)
assertEquals(
@ -27,9 +45,8 @@ class QuestTests : LibTestSuite() {
)
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(ObjectType.MenuActivation, quest.objects[0].type)
assertEquals(ObjectType.PlayerSet, quest.objects[4].type)
assertEquals(216, quest.npcs.size)
assertEquals(10, quest.mapDesignations.size)
assertEquals(0, quest.mapDesignations[0])
@ -71,4 +88,73 @@ class QuestTests : LibTestSuite() {
assertEquals(200, seg4.instructions[0].args[1].value)
assertEquals(201, seg4.instructions[0].args[2].value)
}
@Test
fun round_trip_test_with_towards_the_future() = asyncTest {
val filename = "quest118_e.qst"
roundTripTest(filename, readFile("/$filename"))
}
@Test
fun round_trip_test_with_seat_of_the_heart() = asyncTest {
val filename = "quest27_e.qst"
roundTripTest(filename, readFile("/$filename"))
}
@Test
fun round_trip_test_with_lost_head_sword_gc() = asyncTest {
val filename = "lost_heat_sword_gc.qst"
roundTripTest(filename, readFile("/$filename"))
}
/**
* Round-trip tests.
* Parse a QST file, write the resulting Quest object to QST again, then parse that again.
* Then check whether the two Quest objects are deeply equal.
*/
private fun roundTripTest(filename: String, contents: Cursor) {
val origQuestData = parseQstToQuest(contents).unwrap()
val origQuest = origQuestData.quest
val newQuestData = parseQstToQuest(
writeQuestToQst(
origQuest,
filename,
origQuestData.version,
origQuestData.online,
).cursor()
).unwrap()
val newQuest = newQuestData.quest
assertEquals(origQuestData.version, newQuestData.version)
assertEquals(origQuestData.online, newQuestData.online)
assertEquals(origQuest.name, newQuest.name)
assertEquals(origQuest.shortDescription, newQuest.shortDescription)
assertEquals(origQuest.longDescription, newQuest.longDescription)
assertEquals(origQuest.episode, newQuest.episode)
assertEquals(origQuest.objects.size, newQuest.objects.size)
for (i in origQuest.objects.indices) {
val origObj = origQuest.objects[i]
val newObj = newQuest.objects[i]
assertEquals(origObj.areaId, newObj.areaId)
assertEquals(origObj.sectionId, newObj.sectionId)
assertEquals(origObj.position, newObj.position)
assertEquals(origObj.type, newObj.type)
}
assertEquals(origQuest.npcs.size, newQuest.npcs.size)
for (i in origQuest.npcs.indices) {
val origNpc = origQuest.npcs[i]
val newNpc = newQuest.npcs[i]
assertEquals(origNpc.areaId, newNpc.areaId)
assertEquals(origNpc.sectionId, newNpc.sectionId)
assertEquals(origNpc.position, newNpc.position)
assertEquals(origNpc.type, newNpc.type)
}
assertDeepEquals(origQuest.mapDesignations, newQuest.mapDesignations, ::assertEquals)
assertDeepEquals(origQuest.bytecodeIr, newQuest.bytecodeIr)
}
}

31
lib/src/commonTest/kotlin/world/phantasmal/lib/test/TestUtils.kt
View File

@ -22,17 +22,36 @@ fun toInstructions(assembly: String): List<InstructionSegment> {
fun <T> assertDeepEquals(expected: List<T>, actual: List<T>, assertDeepEquals: (T, T) -> Unit) {
assertEquals(expected.size, actual.size)
for (i in actual.indices) {
for (i in expected.indices) {
assertDeepEquals(expected[i], actual[i])
}
}
fun assertDeepEquals(expected: Buffer, actual: Buffer): Boolean {
if (expected.size != actual.size) return false
fun <K, V> assertDeepEquals(
expected: Map<K, V>,
actual: Map<K, V>,
assertDeepEquals: (V, V) -> Unit,
) {
assertEquals(expected.size, actual.size)
for ((key, value) in expected) {
assertTrue(key in actual)
assertDeepEquals(value, actual[key]!!)
}
}
fun assertDeepEquals(expected: Buffer, actual: Buffer) {
assertEquals(expected.size, actual.size)
for (i in 0 until expected.size) {
if (expected.getByte(i) != actual.getByte(i)) return false
assertEquals(expected.getByte(i), actual.getByte(i))
}
}
fun assertDeepEquals(expected: Cursor, actual: Cursor) {
assertEquals(expected.size, actual.size)
while (expected.hasBytesLeft()) {
assertEquals(expected.byte(), actual.byte())
}
return true
}

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

Binary file not shown.

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

Binary file not shown.

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

@ -157,6 +157,9 @@ actual class Buffer private constructor(
return self.btoa(str)
}
actual fun copy(): Buffer =
Buffer(arrayBuffer.slice(0, size), size, endianness)
/**
* Checks whether we can read [size] bytes at [offset].
*/

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

@ -154,6 +154,9 @@ actual class Buffer private constructor(
return str
}
actual fun copy(): Buffer =
fromByteArray(buf.array().copyOf(), endianness)
/**
* Checks whether we can read [size] bytes at [offset].
*/

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

@ -1,14 +1,16 @@
package world.phantasmal.web.questEditor.controllers
import kotlinx.browser.document
import mu.KotlinLogging
import org.w3c.dom.HTMLAnchorElement
import org.w3c.dom.url.URL
import org.w3c.files.Blob
import org.w3c.files.File
import world.phantasmal.core.*
import world.phantasmal.lib.Endianness
import world.phantasmal.lib.cursor.cursor
import world.phantasmal.lib.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.lib.cursor.cursor
import world.phantasmal.lib.fileFormats.quest.*
import world.phantasmal.observable.value.Val
import world.phantasmal.observable.value.map
import world.phantasmal.observable.value.mutableVal
@ -19,8 +21,10 @@ import world.phantasmal.web.questEditor.loading.QuestLoader
import world.phantasmal.web.questEditor.models.AreaModel
import world.phantasmal.web.questEditor.stores.AreaStore
import world.phantasmal.web.questEditor.stores.QuestEditorStore
import world.phantasmal.web.questEditor.stores.convertQuestFromModel
import world.phantasmal.web.questEditor.stores.convertQuestToModel
import world.phantasmal.webui.controllers.Controller
import world.phantasmal.webui.obj
import world.phantasmal.webui.readFile
import world.phantasmal.webui.selectFiles
@ -36,6 +40,9 @@ class QuestEditorToolbarController(
) : Controller() {
private val _resultDialogVisible = mutableVal(false)
private val _result = mutableVal<PwResult<*>?>(null)
private val _saveAsDialogVisible = mutableVal(false)
private val _filename = mutableVal("")
private val _version = mutableVal(Version.BB)
// Result
@ -44,6 +51,13 @@ class QuestEditorToolbarController(
val openFileAccept = ".bin, .dat, .qst"
// Save as
val saveAsEnabled: Val<Boolean> = questEditorStore.currentQuest.isNotNull()
val saveAsDialogVisible: Val<Boolean> = _saveAsDialogVisible
val filename: Val<String> = _filename
val version: Val<Version> = _version
// Undo
val undoTooltip: Val<String> = questEditorStore.firstUndo.map { action ->
@ -87,6 +101,10 @@ class QuestEditorToolbarController(
openFiles(selectFiles(accept = openFileAccept, multiple = true))
},
uiStore.onGlobalKeyDown(PwToolType.QuestEditor, "Ctrl-Shift-S") {
saveAs()
},
uiStore.onGlobalKeyDown(PwToolType.QuestEditor, "Ctrl-Z") {
undo()
},
@ -102,14 +120,12 @@ class QuestEditorToolbarController(
}
suspend fun createNewQuest(episode: Episode) {
// TODO: Set filename and version.
questEditorStore.setCurrentQuest(
convertQuestToModel(questLoader.loadDefaultQuest(episode), areaStore::getVariant)
)
setFilename("")
setVersion(Version.BB)
setCurrentQuest(questLoader.loadDefaultQuest(episode))
}
suspend fun openFiles(files: List<File>) {
// TODO: Set filename and version.
try {
if (files.isEmpty()) return
@ -120,6 +136,8 @@ class QuestEditorToolbarController(
setResult(parseResult)
if (parseResult is Success) {
setFilename(filenameBase(qst.name) ?: qst.name)
setVersion(parseResult.value.version)
setCurrentQuest(parseResult.value.quest)
}
} else {
@ -141,6 +159,8 @@ class QuestEditorToolbarController(
setResult(parseResult)
if (parseResult is Success) {
setFilename(filenameBase(bin.name) ?: filenameBase(dat.name) ?: bin.name)
setVersion(Version.BB)
setCurrentQuest(parseResult.value)
}
}
@ -153,6 +173,64 @@ class QuestEditorToolbarController(
}
}
fun saveAs() {
if (saveAsEnabled.value) {
_saveAsDialogVisible.value = true
}
}
fun setFilename(filename: String) {
_filename.value = filename
}
fun setVersion(version: Version) {
_version.value = version
}
fun saveAsDialogSave() {
val quest = questEditorStore.currentQuest.value ?: return
var filename = filename.value.trim()
val buffer = writeQuestToQst(
convertQuestFromModel(quest),
filename,
version.value,
online = true,
)
if (!filename.endsWith(".qst")) {
filename += ".qst"
}
val a = document.createElement("a") as HTMLAnchorElement
val url = URL.createObjectURL(
Blob(
arrayOf(buffer.arrayBuffer),
obj { type = "application/octet-stream" },
)
)
try {
a.href = url
a.download = filename
document.body?.appendChild(a)
a.click()
} catch (e: Exception) {
URL.revokeObjectURL(url)
document.body?.removeChild(a)
throw e
}
dismissSaveAsDialog()
}
fun dismissSaveAsDialog() {
_saveAsDialogVisible.value = false
}
fun dismissResultDialog() {
_resultDialogVisible.value = false
}
fun undo() {
questEditorStore.undo()
}

68
web/src/main/kotlin/world/phantasmal/web/questEditor/stores/ModelConversion.kt
View File

@ -1,6 +1,7 @@
package world.phantasmal.web.questEditor.stores
import world.phantasmal.lib.Episode
import world.phantasmal.lib.fileFormats.quest.DatEvent
import world.phantasmal.lib.fileFormats.quest.DatEventAction
import world.phantasmal.lib.fileFormats.quest.Quest
import world.phantasmal.web.questEditor.models.*
@ -8,8 +9,8 @@ import world.phantasmal.web.questEditor.models.*
fun convertQuestToModel(
quest: Quest,
getVariant: (Episode, areaId: Int, variantId: Int) -> AreaVariantModel?,
): QuestModel {
return QuestModel(
): QuestModel =
QuestModel(
quest.id,
quest.language,
quest.name,
@ -27,22 +28,22 @@ fun convertQuestToModel(
event.wave.toInt(),
event.delay.toInt(),
event.unknown.toInt(),
event.actions.mapTo(mutableListOf()) {
when (it) {
event.actions.mapTo(mutableListOf()) { action ->
when (action) {
is DatEventAction.SpawnNpcs ->
QuestEventActionModel.SpawnNpcs(
it.sectionId.toInt(),
it.appearFlag.toInt()
action.sectionId.toInt(),
action.appearFlag.toInt()
)
is DatEventAction.Unlock ->
QuestEventActionModel.Door.Unlock(it.doorId.toInt())
QuestEventActionModel.Door.Unlock(action.doorId.toInt())
is DatEventAction.Lock ->
QuestEventActionModel.Door.Lock(it.doorId.toInt())
QuestEventActionModel.Door.Lock(action.doorId.toInt())
is DatEventAction.TriggerEvent ->
QuestEventActionModel.TriggerEvent(it.eventId)
QuestEventActionModel.TriggerEvent(action.eventId)
}
}
)
@ -52,4 +53,51 @@ fun convertQuestToModel(
quest.shopItems,
getVariant,
)
}
/**
* The returned [Quest] object will reference parts of [quest], so some changes to [quest] will be
* reflected in the returned object.
*/
fun convertQuestFromModel(quest: QuestModel): Quest =
Quest(
quest.id.value,
quest.language.value,
quest.name.value,
quest.shortDescription.value,
quest.longDescription.value,
quest.episode,
quest.objects.value.map { it.entity },
quest.npcs.value.map { it.entity },
quest.events.value.map { event ->
DatEvent(
event.id.value,
event.sectionId.value.toShort(),
event.wave.value.id.toShort(),
event.delay.value.toShort(),
event.actions.value.map { action ->
when (action) {
is QuestEventActionModel.SpawnNpcs ->
DatEventAction.SpawnNpcs(
action.sectionId.value.toShort(),
action.appearFlag.value.toShort(),
)
is QuestEventActionModel.Door.Unlock ->
DatEventAction.Unlock(action.doorId.value.toShort())
is QuestEventActionModel.Door.Lock ->
DatEventAction.Lock(action.doorId.value.toShort())
is QuestEventActionModel.TriggerEvent ->
DatEventAction.TriggerEvent(action.eventId.value)
}
},
event.areaId,
event.unknown.toShort(),
)
},
quest.datUnknowns,
quest.bytecodeIr,
quest.shopItems,
quest.mapDesignations.value,
)

87
web/src/main/kotlin/world/phantasmal/web/questEditor/widgets/QuestEditorToolbarWidget.kt
View File

@ -2,7 +2,9 @@ package world.phantasmal.web.questEditor.widgets
import kotlinx.coroutines.launch
import org.w3c.dom.Node
import org.w3c.dom.events.KeyboardEvent
import world.phantasmal.lib.Episode
import world.phantasmal.lib.fileFormats.quest.Version
import world.phantasmal.observable.value.list.listVal
import world.phantasmal.observable.value.value
import world.phantasmal.web.questEditor.controllers.QuestEditorToolbarController
@ -32,6 +34,13 @@ class QuestEditorToolbarWidget(private val ctrl: QuestEditorToolbarController) :
multiple = true,
filesSelected = { files -> scope.launch { ctrl.openFiles(files) } },
),
Button(
text = "Save as...",
iconLeft = Icon.Save,
enabled = ctrl.saveAsEnabled,
tooltip = value("Save this quest to a new file (Ctrl-Shift-S)"),
onClick = { ctrl.saveAs() },
),
Button(
text = "Undo",
iconLeft = Icon.Undo,
@ -55,5 +64,83 @@ class QuestEditorToolbarWidget(private val ctrl: QuestEditorToolbarController) :
),
)
))
val saveAsDialog = addDisposable(Dialog(
visible = ctrl.saveAsDialogVisible,
title = value("Save As"),
content = {
div {
className = "pw-quest-editor-toolbar-save-as"
val filenameInput = TextInput(
label = "File name:",
value = ctrl.filename,
onChange = ctrl::setFilename,
)
addWidget(filenameInput.label!!)
addWidget(filenameInput)
val versionSelect = Select(
label = "Version:",
items = listVal(Version.GC, Version.BB),
selected = ctrl.version,
itemToString = {
when (it) {
Version.DC -> "Dreamcast"
Version.GC -> "GameCube"
Version.PC -> "PC"
Version.BB -> "BlueBurst"
}
},
onSelect = ctrl::setVersion,
)
addWidget(versionSelect.label!!)
addWidget(versionSelect)
}
},
footer = {
addWidget(Button(
text = "Save",
onClick = { ctrl.saveAsDialogSave() },
))
addWidget(Button(
text = "Cancel",
onClick = { ctrl.dismissSaveAsDialog() },
))
},
onDismiss = ctrl::dismissSaveAsDialog,
))
saveAsDialog.dialogElement.addEventListener("keydown", { e ->
if ((e as KeyboardEvent).key == "Enter") {
ctrl.saveAsDialogSave()
}
})
addDisposable(ResultDialog(
visible = ctrl.resultDialogVisible,
result = ctrl.result,
onDismiss = ctrl::dismissResultDialog,
))
}
companion object {
init {
@Suppress("CssUnusedSymbol")
// language=css
style("""
.pw-quest-editor-toolbar-save-as {
display: grid;
grid-template-columns: 100px max-content;
grid-column-gap: 4px;
grid-row-gap: 4px;
align-items: center;
}
.pw-quest-editor-toolbar-save-as .pw-input {
margin: 1px;
}
""".trimIndent())
}
}
}

38
webui/src/main/kotlin/world/phantasmal/webui/widgets/Dialog.kt
View File

@ -8,6 +8,7 @@ import org.w3c.dom.events.KeyboardEvent
import org.w3c.dom.get
import org.w3c.dom.pointerevents.PointerEvent
import world.phantasmal.observable.value.Val
import world.phantasmal.observable.value.emptyStringVal
import world.phantasmal.observable.value.isEmpty
import world.phantasmal.observable.value.trueVal
import world.phantasmal.webui.dom.div
@ -19,14 +20,24 @@ open class Dialog(
visible: Val<Boolean> = trueVal(),
enabled: Val<Boolean> = trueVal(),
private val title: Val<String>,
private val description: Val<String>,
private val content: Val<Node>,
private val description: Val<String> = emptyStringVal(),
private val content: Node.() -> Unit = {},
private val footer: Node.() -> Unit = {},
protected val onDismiss: () -> Unit = {},
) : Widget(visible, enabled) {
private var x = 0
private var y = 0
private var dialogElement = dom {
private var overlayElement = dom {
div {
className = "pw-dialog-modal-overlay"
tabIndex = -1
addEventListener("focus", { this@Dialog.focus() })
}
}
val dialogElement = dom {
section {
className = "pw-dialog"
tabIndex = 0
@ -51,28 +62,15 @@ open class Dialog(
}
div {
className = "pw-dialog-body"
observe(content) {
textContent = ""
append(it)
}
content()
}
div {
className = "pw-dialog-footer"
addFooterContent(this)
footer()
}
}
}
private var overlayElement = dom {
div {
className = "pw-dialog-modal-overlay"
tabIndex = -1
addEventListener("focus", { this@Dialog.focus() })
}
}
init {
observe(visible) {
if (it) {
@ -98,10 +96,6 @@ open class Dialog(
super.internalDispose()
}
protected open fun addFooterContent(footer: Node) {
// Do nothing.
}
private fun onPointerMove(movedX: Int, movedY: Int, e: PointerEvent): Boolean {
e.preventDefault()
setPosition(this.x + movedX, this.y + movedY)

84
webui/src/main/kotlin/world/phantasmal/webui/widgets/ResultDialog.kt
View File

@ -4,38 +4,64 @@ import org.w3c.dom.Node
import world.phantasmal.core.Failure
import world.phantasmal.core.PwResult
import world.phantasmal.observable.value.Val
import world.phantasmal.observable.value.emptyStringVal
import world.phantasmal.observable.value.trueVal
import world.phantasmal.webui.dom.div
import world.phantasmal.webui.dom.dom
import world.phantasmal.webui.dom.li
import world.phantasmal.webui.dom.ul
/**
* Shows the details of a result if the result failed or succeeded with problems. Shows a "Dismiss"
* button in the footer which triggers [onDismiss].
* button in the footer which triggers onDismiss.
*/
class ResultDialog(
visible: Val<Boolean> = trueVal(),
enabled: Val<Boolean> = trueVal(),
result: Val<PwResult<*>?>,
message: Val<String>,
message: Val<String> = emptyStringVal(),
onDismiss: () -> Unit = {},
) : Dialog(
visible,
enabled,
title = result.map(::resultToTitle),
description = message,
content = result.map(::resultToContent),
onDismiss,
) {
override fun addFooterContent(footer: Node) {
footer.addChild(Button(
) : Widget(visible, enabled) {
private val dialog = addDisposable(
Dialog(
visible,
enabled,
text = "Dismiss",
onClick = { onDismiss() }
))
}
title = result.map { result ->
when {
result is Failure -> "Error"
result?.problems?.isNotEmpty() == true -> "Problems"
else -> ""
}
},
description = message,
content = {
div {
className = "pw-result-dialog-result"
ul {
className = "pw-result-dialog-problems"
hidden(result.isNull())
bindChildrenTo(result.map {
it?.problems ?: emptyList()
}) { problem, _ ->
li { textContent = problem.uiMessage }
}
}
}
},
footer = {
addChild(Button(
visible,
enabled,
text = "Dismiss",
onClick = { onDismiss() }
))
},
onDismiss = onDismiss,
)
)
override fun Node.createElement() = dialog.element
companion object {
init {
@ -53,27 +79,3 @@ class ResultDialog(
}
}
}
private fun resultToTitle(result: PwResult<*>?): String =
when {
result is Failure -> "Error"
result?.problems?.isNotEmpty() == true -> "Problems"
else -> ""
}
private fun resultToContent(result: PwResult<*>?): Node =
dom {
div {
className = "pw-result-dialog-result"
result?.let {
ul {
className = "pw-result-dialog-problems"
result.problems.map {
li { textContent = it.uiMessage }
}
}
}
}
}