diff --git a/core/src/commonMain/kotlin/world/phantasmal/core/StandardExtensions.kt b/core/src/commonMain/kotlin/world/phantasmal/core/StandardExtensions.kt new file mode 100644 index 00000000..78b5df19 --- /dev/null +++ b/core/src/commonMain/kotlin/world/phantasmal/core/StandardExtensions.kt @@ -0,0 +1,29 @@ +package world.phantasmal.core + +fun MutableList.replaceAll(elements: Collection): Boolean { + clear() + return addAll(elements) +} + +fun MutableList.replaceAll(elements: Iterable): Boolean { + clear() + return addAll(elements) +} + +fun MutableList.replaceAll(elements: Sequence): Boolean { + clear() + return addAll(elements) +} + +/** + * Replace [amount] elements at [startIndex] with [elements]. + */ +fun MutableList.splice(startIndex: Int, amount: Int, elements: Iterable) { + repeat(amount) { removeAt(startIndex) } + + var i = startIndex + + for (element in elements) { + add(i++, element) + } +} diff --git a/core/src/jsMain/kotlin/world/phantasmal/core/Js.kt b/core/src/jsMain/kotlin/world/phantasmal/core/Js.kt index 79608501..ad3a1f8c 100644 --- a/core/src/jsMain/kotlin/world/phantasmal/core/Js.kt +++ b/core/src/jsMain/kotlin/world/phantasmal/core/Js.kt @@ -1,8 +1,33 @@ +@file:Suppress("NOTHING_TO_INLINE") + package world.phantasmal.core -@Suppress("NOTHING_TO_INLINE") +external interface JsArray { + val length: Int + + fun push(vararg elements: T): Int + + fun slice(start: Int = definedExternally): JsArray + fun slice(start: Int, end: Int = definedExternally): JsArray + + fun splice(start: Int, deleteCount: Int = definedExternally): JsArray + fun splice(start: Int, deleteCount: Int, vararg items: T): JsArray +} + +inline operator fun JsArray.get(index: Int): T = asDynamic()[index].unsafeCast() + +inline operator fun JsArray.set(index: Int, value: T) { + asDynamic()[index] = value +} + inline fun jsArrayOf(vararg elements: T): JsArray = elements.unsafeCast>() inline fun JsArray.asArray(): Array = unsafeCast>() + +inline fun Array.asJsArray(): JsArray = + unsafeCast>() + +inline fun List.toJsArray(): JsArray = + toTypedArray().asJsArray() diff --git a/core/src/jsMain/kotlin/world/phantasmal/core/JsExternals.kt b/core/src/jsMain/kotlin/world/phantasmal/core/JsExternals.kt deleted file mode 100644 index b57485f0..00000000 --- a/core/src/jsMain/kotlin/world/phantasmal/core/JsExternals.kt +++ /dev/null @@ -1,5 +0,0 @@ -package world.phantasmal.core - -external interface JsArray { - fun push(vararg elements: T): Int -} diff --git a/observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/DependentListVal.kt b/observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/DependentListVal.kt index 32970567..b28df7e2 100644 --- a/observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/DependentListVal.kt +++ b/observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/DependentListVal.kt @@ -2,6 +2,7 @@ package world.phantasmal.observable.value.list import world.phantasmal.core.disposable.Disposable import world.phantasmal.core.disposable.disposable +import world.phantasmal.core.replaceAll import world.phantasmal.observable.Observer import world.phantasmal.observable.value.AbstractVal import world.phantasmal.observable.value.Val @@ -61,8 +62,7 @@ class DependentListVal( } private fun recompute() { - elements.clear() - elements.addAll(computeElements()) + elements.replaceAll(computeElements()) } private fun initDependencyObservers() { diff --git a/observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/SimpleListVal.kt b/observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/SimpleListVal.kt index 86804f83..ede10b5c 100644 --- a/observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/SimpleListVal.kt +++ b/observable/src/commonMain/kotlin/world/phantasmal/observable/value/list/SimpleListVal.kt @@ -1,5 +1,6 @@ package world.phantasmal.observable.value.list +import world.phantasmal.core.replaceAll import world.phantasmal.observable.Observable import world.phantasmal.observable.value.MutableVal import world.phantasmal.observable.value.Val @@ -64,15 +65,13 @@ class SimpleListVal( override fun replaceAll(elements: Iterable) { val removed = ArrayList(this.elements) - this.elements.clear() - this.elements.addAll(elements) + this.elements.replaceAll(elements) finalizeUpdate(ListValChangeEvent.Change(0, removed, this.elements)) } override fun replaceAll(elements: Sequence) { val removed = ArrayList(this.elements) - this.elements.clear() - this.elements.addAll(elements) + this.elements.replaceAll(elements) finalizeUpdate(ListValChangeEvent.Change(0, removed, this.elements)) } diff --git a/web/src/main/kotlin/world/phantasmal/web/questEditor/asm/AsmAnalyser.kt b/web/src/main/kotlin/world/phantasmal/web/questEditor/asm/AsmAnalyser.kt index 2de084dd..983e0ada 100644 --- a/web/src/main/kotlin/world/phantasmal/web/questEditor/asm/AsmAnalyser.kt +++ b/web/src/main/kotlin/world/phantasmal/web/questEditor/asm/AsmAnalyser.kt @@ -1,6 +1,6 @@ package world.phantasmal.web.questEditor.asm -import world.phantasmal.core.Success +import world.phantasmal.core.* import world.phantasmal.lib.asm.* import world.phantasmal.lib.asm.dataFlowAnalysis.getMapDesignations import world.phantasmal.observable.value.Val @@ -46,7 +46,7 @@ object AsmAnalyser { } private var inlineStackArgs: Boolean = true - private var asm: List = emptyList() + private val asm: JsArray = jsArrayOf() private var _bytecodeIr = mutableVal(BytecodeIr(emptyList())) private var _mapDesignations = mutableVal>(emptyMap()) private val _problems = mutableListVal() @@ -57,13 +57,111 @@ object AsmAnalyser { suspend fun setAsm(asm: List, inlineStackArgs: Boolean) { this.inlineStackArgs = inlineStackArgs - this.asm = asm + this.asm.splice(0, this.asm.length, *asm.toTypedArray()) processAsm() } + suspend fun updateAssembly(changes: List) { + for (change in changes) { + val (startLineNo, startCol, endLineNo, endCol) = change.range + val linesChanged = endLineNo - startLineNo + 1 + val newLines = change.newAsm.split("\n").toJsArray() + + when { + linesChanged == 1 -> { + replaceLinePart(startLineNo, startCol, endCol, newLines) + } + + newLines.length == 1 -> { + replaceLinesAndMergeLineParts( + startLineNo, + endLineNo, + startCol, + endCol, + newLines[0], + ) + } + + else -> { + // Keep the left part of the first changed line. + replaceLinePartRight(startLineNo, startCol, newLines[0]) + + // Keep the right part of the last changed line. + replaceLinePartLeft(endLineNo, endCol, newLines[newLines.length - 1]) + + // Replace all the lines in between. + // It's important that we do this last. + replaceLines( + startLineNo + 1, + endLineNo - 1, + newLines.slice(1, newLines.length - 1), + ) + } + } + } + + processAsm() + } + + private fun replaceLinePart( + lineNo: Int, + startCol: Int, + endCol: Int, + newLineParts: JsArray, + ) { + val line = asm[lineNo - 1] + // We keep the parts of the line that weren't affected by the edit. + val lineStart = line.substring(0, startCol - 1) + val lineEnd = line.substring(endCol - 1) + + if (newLineParts.length == 1) { + asm[lineNo - 1] = lineStart + newLineParts[0] + lineEnd + } else { + asm.splice( + lineNo - 1, + 1, + lineStart + newLineParts[0], + *newLineParts.slice(1, newLineParts.length - 1).asArray(), + newLineParts[newLineParts.length - 1] + lineEnd, + ) + } + } + + private fun replaceLinePartLeft(lineNo: Int, endCol: Int, newLinePart: String) { + asm[lineNo - 1] = newLinePart + asm[lineNo - 1].substring(endCol - 1) + } + + private fun replaceLinePartRight(lineNo: Int, startCol: Int, newLinePart: String) { + asm[lineNo - 1] = asm[lineNo - 1].substring(0, startCol - 1) + newLinePart + } + + private fun replaceLines(startLineNo: Int, endLineNo: Int, newLines: JsArray) { + asm.splice(startLineNo - 1, endLineNo - startLineNo + 1, *newLines.asArray()) + } + + private fun replaceLinesAndMergeLineParts( + startLineNo: Int, + endLineNo: Int, + startCol: Int, + endCol: Int, + newLinePart: String, + ) { + val startLine = asm[startLineNo - 1] + val endLine = asm[endLineNo - 1] + // We keep the parts of the lines that weren't affected by the edit. + val startLineStart = startLine.substring(0, startCol - 1) + val endLineEnd = endLine.substring(endCol - 1) + + asm.splice( + startLineNo - 1, + endLineNo - startLineNo + 1, + startLineStart + newLinePart + endLineEnd, + ) + } + private fun processAsm() { - val assemblyResult = assemble(asm, inlineStackArgs) + val assemblyResult = assemble(asm.asArray().toList(), inlineStackArgs) @Suppress("UNCHECKED_CAST") _problems.value = assemblyResult.problems as List @@ -220,7 +318,7 @@ object AsmAnalyser { return Hover(contents) } - suspend fun getDefinition(lineNo: Int, col: Int): List { + suspend fun getDefinition(lineNo: Int, col: Int): List { getInstruction(lineNo, col)?.let { inst -> for ((paramIdx, param) in inst.opcode.params.withIndex()) { if (param.type is LabelType) { @@ -290,14 +388,14 @@ object AsmAnalyser { return null } - private fun getLabelDefinitions(label: Int): List = + private fun getLabelDefinitions(label: Int): List = bytecodeIr.value.segments.asSequence() .filter { label in it.labels } .mapNotNull { segment -> val labelIdx = segment.labels.indexOf(label) segment.srcLoc.labels.getOrNull(labelIdx)?.let { labelSrcLoc -> - TextRange( + AsmRange( startLineNo = labelSrcLoc.lineNo, startCol = labelSrcLoc.col, endLineNo = labelSrcLoc.lineNo, @@ -314,5 +412,6 @@ object AsmAnalyser { lineNo == srcLoc.lineNo && col >= srcLoc.col && col <= srcLoc.col + srcLoc.len } - private fun getLine(lineNo: Int): String? = asm.getOrNull(lineNo - 1) + @Suppress("RedundantNullableReturnType") // Can return undefined. + private fun getLine(lineNo: Int): String? = asm[lineNo - 1] } diff --git a/web/src/main/kotlin/world/phantasmal/web/questEditor/asm/Types.kt b/web/src/main/kotlin/world/phantasmal/web/questEditor/asm/Types.kt index bd1f3ab1..0257c645 100644 --- a/web/src/main/kotlin/world/phantasmal/web/questEditor/asm/Types.kt +++ b/web/src/main/kotlin/world/phantasmal/web/questEditor/asm/Types.kt @@ -1,10 +1,10 @@ package world.phantasmal.web.questEditor.asm -class TextRange( - var startLineNo: Int, - var startCol: Int, - var endLineNo: Int, - var endCol: Int, +data class AsmRange( + val startLineNo: Int, + val startCol: Int, + val endLineNo: Int, + val endCol: Int, ) enum class CompletionItemType { @@ -35,3 +35,8 @@ class Hover( */ val contents: List, ) + +class AsmChange( + val range: AsmRange, + val newAsm: String, +) diff --git a/web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/AsmController.kt b/web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/AsmController.kt index 92d5ed77..c7f471d1 100644 --- a/web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/AsmController.kt +++ b/web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/AsmController.kt @@ -1,7 +1,10 @@ package world.phantasmal.web.questEditor.controllers import world.phantasmal.observable.Observable -import world.phantasmal.observable.value.* +import world.phantasmal.observable.value.Val +import world.phantasmal.observable.value.not +import world.phantasmal.observable.value.or +import world.phantasmal.observable.value.orElse import world.phantasmal.web.externals.monacoEditor.ITextModel import world.phantasmal.web.externals.monacoEditor.createModel import world.phantasmal.web.questEditor.stores.AsmStore @@ -17,19 +20,24 @@ class AsmController(private val store: AsmStore) : Controller() { val didRedo: Observable = store.didRedo val inlineStackArgs: Val = store.inlineStackArgs - val inlineStackArgsEnabled: Val = falseVal() // TODO + val inlineStackArgsEnabled: Val = store.problems.map { it.isEmpty() } + val inlineStackArgsTooltip: Val = + inlineStackArgsEnabled.map { enabled -> + buildString { + append("Transform arg_push* opcodes to be inline with the opcode the arguments are given to.") - // TODO: Notify user when disabled because of issues with the ASM. - val inlineStackArgsTooltip: Val = value( - "Transform arg_push* opcodes to be inline with the opcode the arguments are given to." - ) + if (!enabled) { + append("\nThis mode cannot be toggled because there are issues in the script.") + } + } + } fun makeUndoCurrent() { store.makeUndoCurrent() } - fun setInlineStackArgs(value: Boolean) { - TODO() + fun setInlineStackArgs(inline: Boolean) { + store.setInlineStackArgs(inline) } companion object { diff --git a/web/src/main/kotlin/world/phantasmal/web/questEditor/stores/AsmStore.kt b/web/src/main/kotlin/world/phantasmal/web/questEditor/stores/AsmStore.kt index 19ead2ce..dc5f3ce8 100644 --- a/web/src/main/kotlin/world/phantasmal/web/questEditor/stores/AsmStore.kt +++ b/web/src/main/kotlin/world/phantasmal/web/questEditor/stores/AsmStore.kt @@ -1,13 +1,16 @@ package world.phantasmal.web.questEditor.stores import kotlinx.coroutines.launch +import world.phantasmal.core.disposable.Disposer +import world.phantasmal.core.disposable.disposable +import world.phantasmal.lib.asm.AssemblyProblem import world.phantasmal.lib.asm.disassemble import world.phantasmal.observable.ChangeEvent import world.phantasmal.observable.Observable import world.phantasmal.observable.emitter import world.phantasmal.observable.value.Val +import world.phantasmal.observable.value.list.ListVal import world.phantasmal.observable.value.mutableVal -import world.phantasmal.observable.value.trueVal import world.phantasmal.web.core.undo.SimpleUndo import world.phantasmal.web.core.undo.UndoManager import world.phantasmal.web.externals.monacoEditor.* @@ -19,8 +22,15 @@ class AsmStore( questEditorStore: QuestEditorStore, private val undoManager: UndoManager, ) : Store() { + private val _inlineStackArgs = mutableVal(true) private var _textModel = mutableVal(null) + /** + * Contains all model-related disposables. All contained disposables are disposed whenever a new + * model is created. + */ + private val modelDisposer = addDisposable(Disposer()) + private val _didUndo = emitter() private val _didRedo = emitter() private val undo = SimpleUndo( @@ -30,7 +40,7 @@ class AsmStore( { _didRedo.emit(ChangeEvent(Unit)) }, ) - val inlineStackArgs: Val = trueVal() + val inlineStackArgs: Val = _inlineStackArgs val textModel: Val = _textModel @@ -39,17 +49,38 @@ class AsmStore( val didUndo: Observable = _didUndo val didRedo: Observable = _didRedo + val problems: ListVal = AsmAnalyser.problems + init { observe(questEditorStore.currentQuest, inlineStackArgs) { quest, inlineStackArgs -> - _textModel.value?.dispose() + modelDisposer.disposeAll() quest?.let { val asm = disassemble(quest.bytecodeIr, inlineStackArgs) scope.launch { AsmAnalyser.setAsm(asm, inlineStackArgs) } - _textModel.value = - createModel(asm.joinToString("\n"), ASM_LANG_ID) - .also(::addModelChangeListener) + _textModel.value = createModel(asm.joinToString("\n"), ASM_LANG_ID).also { model -> + modelDisposer.add(disposable { model.dispose() }) + + setupUndoRedo(model) + + model.onDidChangeContent { e -> + scope.launch { + AsmAnalyser.updateAssembly(e.changes.map { + AsmChange( + AsmRange( + it.range.startLineNumber, + it.range.startColumn, + it.range.endLineNumber, + it.range.endColumn, + ), + it.text, + ) + }) + } + // TODO: Update breakpoints. + } + } } } @@ -66,10 +97,11 @@ class AsmStore( undoManager.setCurrent(undo) } - /** - * Sets up undo/redo, code analysis and breakpoint updates on model change. - */ - private fun addModelChangeListener(model: ITextModel) { + fun setInlineStackArgs(inline: Boolean) { + _inlineStackArgs.value = inline + } + + private fun setupUndoRedo(model: ITextModel) { val initialVersion = model.getAlternativeVersionId() var currentVersion = initialVersion var lastVersion = initialVersion @@ -102,8 +134,6 @@ class AsmStore( } currentVersion = version - - // TODO: Code analysis and breakpoint update. } }