The "Event ID" field in the Entity view now has a "Go to event" button.

2025-04-04 22:58:29 +08:00 · 2021-06-19 15:05:32 +02:00 · 2021-06-19 15:05:32 +02:00 · 88421d894c
commit 88421d894c
parent 403e03b0ee
7 changed files with 221 additions and 88 deletions
--- a/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/ListCell.kt
+++ b/observable/src/commonMain/kotlin/world/phantasmal/observable/cell/list/ListCell.kt
@ -21,6 +21,10 @@ interface ListCell<out E> : Cell<List<E>> {

    fun observeList(callNow: Boolean = false, observer: ListObserver<E>): Disposable

+    // TODO: Optimize this.
+    fun <R> listMap(transform: (E) -> R): ListCell<R> =
+        DependentListCell(this) { value.map(transform) }
+
    fun <R> fold(initialValue: R, operation: (R, E) -> R): Cell<R> =
        DependentCell(this) { value.fold(initialValue, operation) }

--- a/web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/EntityInfoController.kt
+++ b/web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/EntityInfoController.kt
@ -2,9 +2,12 @@ package world.phantasmal.web.questEditor.controllers

 import world.phantasmal.core.math.degToRad
 import world.phantasmal.core.math.radToDeg
+import world.phantasmal.lib.fileFormats.quest.EntityPropType
 import world.phantasmal.observable.cell.Cell
 import world.phantasmal.observable.cell.cell
+import world.phantasmal.observable.cell.list.ListCell
 import world.phantasmal.observable.cell.list.emptyListCell
+import world.phantasmal.observable.cell.list.flatMapToList
 import world.phantasmal.observable.cell.zeroIntCell
 import world.phantasmal.web.core.euler
 import world.phantasmal.web.externals.three.Euler
@ -17,6 +20,66 @@ import world.phantasmal.web.questEditor.stores.AreaStore
 import world.phantasmal.web.questEditor.stores.QuestEditorStore
 import world.phantasmal.webui.controllers.Controller

+sealed class EntityInfoPropModel(
+    protected val store: QuestEditorStore,
+    protected val prop: QuestEntityPropModel,
+) {
+    val label = prop.name + ":"
+
+    protected fun setPropValue(prop: QuestEntityPropModel, value: Any) {
+        store.selectedEntity.value?.let { entity ->
+            store.executeAction(
+                EditEntityPropAction(
+                    setSelectedEntity = store::setSelectedEntity,
+                    entity,
+                    prop,
+                    value,
+                    prop.value.value,
+                )
+            )
+        }
+    }
+
+    class I32(store: QuestEditorStore, prop: QuestEntityPropModel) :
+        EntityInfoPropModel(store, prop) {
+
+        @Suppress("UNCHECKED_CAST")
+        val value: Cell<Int> = prop.value as Cell<Int>
+
+        val showGoToEvent: Boolean = prop.name == "Event ID"
+
+        val canGoToEvent: Cell<Boolean> = store.canGoToEvent(value)
+
+        fun setValue(value: Int) {
+            setPropValue(prop, value)
+        }
+
+        fun goToEvent() {
+            store.goToEvent(value.value)
+        }
+    }
+
+    class F32(store: QuestEditorStore, prop: QuestEntityPropModel) :
+        EntityInfoPropModel(store, prop) {
+
+        val value: Cell<Double> = prop.value.map { (it as Float).toDouble() }
+
+        fun setValue(value: Double) {
+            setPropValue(prop, value.toFloat())
+        }
+    }
+
+    class Angle(store: QuestEditorStore, prop: QuestEntityPropModel) :
+        EntityInfoPropModel(store, prop) {
+
+        val value: Cell<Double> = prop.value.map { radToDeg((it as Float).toDouble()) }
+
+        fun setValue(value: Double) {
+            setPropValue(prop, degToRad(value).toFloat())
+        }
+    }
+}
+
 class EntityInfoController(
    private val areaStore: AreaStore,
    private val questEditorStore: QuestEditorStore,
@ -56,8 +119,16 @@ class EntityInfoController(
    val rotY: Cell<Double> = rot.map { radToDeg(it.y) }
    val rotZ: Cell<Double> = rot.map { radToDeg(it.z) }

-    val props: Cell<List<QuestEntityPropModel>> =
-        questEditorStore.selectedEntity.flatMap { it?.properties ?: emptyListCell() }
+    val props: ListCell<EntityInfoPropModel> =
+        questEditorStore.selectedEntity.flatMapToList { entity ->
+            entity?.properties?.listMap { prop ->
+                when (prop.type) {
+                    EntityPropType.I32 -> EntityInfoPropModel.I32(questEditorStore, prop)
+                    EntityPropType.F32 -> EntityInfoPropModel.F32(questEditorStore, prop)
+                    EntityPropType.Angle -> EntityInfoPropModel.Angle(questEditorStore, prop)
+                }
+            } ?: emptyListCell()
+        }

    fun focused() {
        questEditorStore.makeMainUndoCurrent()
@ -121,7 +192,8 @@ class EntityInfoController(
    private fun setPos(entity: QuestEntityModel<*, *>, x: Double, y: Double, z: Double) {
        if (!enabled.value) return

-        questEditorStore.executeAction(TranslateEntityAction(
+        questEditorStore.executeAction(
+            TranslateEntityAction(
                setSelectedEntity = questEditorStore::setSelectedEntity,
                setEntitySection = { /* Won't be called. */ },
                entity,
@ -129,7 +201,8 @@ class EntityInfoController(
                oldSection = null,
                newPosition = Vector3(x, y, z),
                oldPosition = entity.position.value,
-        ))
+            )
+        )
    }

    fun setRotX(x: Double) {
@ -156,25 +229,15 @@ class EntityInfoController(
    private fun setRot(entity: QuestEntityModel<*, *>, x: Double, y: Double, z: Double) {
        if (!enabled.value) return

-        questEditorStore.executeAction(RotateEntityAction(
+        questEditorStore.executeAction(
+            RotateEntityAction(
                setSelectedEntity = questEditorStore::setSelectedEntity,
                entity,
                euler(x, y, z),
                entity.rotation.value,
                false,
-        ))
-    }
-
-    fun setPropValue(prop: QuestEntityPropModel, value: Any) {
-        questEditorStore.selectedEntity.value?.let { entity ->
-            questEditorStore.executeAction(EditEntityPropAction(
-                setSelectedEntity = questEditorStore::setSelectedEntity,
-                entity,
-                prop,
-                value,
-                prop.value.value,
-            ))
-        }
+            )
+        )
    }

    companion object {
--- a/web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/EventsController.kt
+++ b/web/src/main/kotlin/world/phantasmal/web/questEditor/controllers/EventsController.kt
@ -4,10 +4,7 @@ import world.phantasmal.observable.cell.Cell
 import world.phantasmal.observable.cell.and
 import world.phantasmal.observable.cell.eq
 import world.phantasmal.observable.cell.list.ListCell
-import world.phantasmal.observable.cell.list.emptyListCell
-import world.phantasmal.observable.cell.list.flatMapToList
 import world.phantasmal.observable.cell.list.listCell
-import world.phantasmal.observable.cell.map
 import world.phantasmal.web.questEditor.actions.*
 import world.phantasmal.web.questEditor.models.QuestEventActionModel
 import world.phantasmal.web.questEditor.models.QuestEventModel
@ -18,15 +15,7 @@ class EventsController(private val store: QuestEditorStore) : Controller() {
    val unavailable: Cell<Boolean> = store.currentQuest.isNull()
    val enabled: Cell<Boolean> = store.questEditingEnabled
    val removeEventEnabled: Cell<Boolean> = enabled and store.selectedEvent.isNotNull()
-
-    val events: ListCell<QuestEventModel> =
-        flatMapToList(store.currentQuest, store.currentArea) { quest, area ->
-            if (quest != null && area != null) {
-                quest.events.filtered { it.areaId == area.id }
-            } else {
-                emptyListCell()
-            }
-        }
+    val events: ListCell<QuestEventModel> = store.currentAreaEvents

    val eventActionTypes: ListCell<String> = listCell(
        QuestEventActionModel.SpawnNpcs.SHORT_NAME,
@ -166,15 +155,10 @@ class EventsController(private val store: QuestEditorStore) : Controller() {
        store.executeAction(DeleteEventActionAction(::selectEvent, event, index, action))
    }

-    fun canGoToEvent(eventId: Cell<Int>): Cell<Boolean> =
-        map(enabled, events, eventId) { en, evts, id ->
-            en && evts.any { it.id.value == id }
-        }
+    fun canGoToEvent(eventId: Cell<Int>): Cell<Boolean> = store.canGoToEvent(eventId)

    fun goToEvent(eventId: Int) {
-        events.value.find { it.id.value == eventId }?.let { event ->
-            store.setSelectedEvent(event)
-        }
+        store.goToEvent(eventId)
    }

    fun setActionSectionId(
--- a/web/src/main/kotlin/world/phantasmal/web/questEditor/stores/QuestEditorStore.kt
+++ b/web/src/main/kotlin/world/phantasmal/web/questEditor/stores/QuestEditorStore.kt
@ -4,7 +4,9 @@ import kotlinx.coroutines.launch
 import mu.KotlinLogging
 import world.phantasmal.lib.Episode
 import world.phantasmal.observable.cell.*
+import world.phantasmal.observable.cell.list.ListCell
 import world.phantasmal.observable.cell.list.emptyListCell
+import world.phantasmal.observable.cell.list.flatMapToList
 import world.phantasmal.web.core.PwToolType
 import world.phantasmal.web.core.actions.Action
 import world.phantasmal.web.core.stores.UiStore
@ -46,6 +48,16 @@ class QuestEditorStore(
                null
            }
        }
+
+    val currentAreaEvents: ListCell<QuestEventModel> =
+        flatMapToList(currentQuest, currentArea) { quest, area ->
+            if (quest != null && area != null) {
+                quest.events.filtered { it.areaId == area.id }
+            } else {
+                emptyListCell()
+            }
+        }
+
    val selectedEvent: Cell<QuestEventModel?> = _selectedEvent

    /**
@ -248,6 +260,20 @@ class QuestEditorStore(
        undoManager.savePoint()
    }

+    /**
+     * True if the event exists in the current area and quest editing is enabled.
+     */
+    fun canGoToEvent(eventId: Cell<Int>): Cell<Boolean> =
+        map(questEditingEnabled, currentAreaEvents, eventId) { en, evts, id ->
+            en && evts.any { it.id.value == id }
+        }
+
+    fun goToEvent(eventId: Int) {
+        currentAreaEvents.value.find { it.id.value == eventId }?.let { event ->
+            setSelectedEvent(event)
+        }
+    }
+
    private suspend fun updateQuestEntitySections(quest: QuestModel) {
        quest.areaVariants.value.forEach { variant ->
            val sections = areaStore.getSections(quest.episode, variant)
--- a/web/src/main/kotlin/world/phantasmal/web/questEditor/widgets/EntityInfoWidget.kt
+++ b/web/src/main/kotlin/world/phantasmal/web/questEditor/widgets/EntityInfoWidget.kt
@ -5,15 +5,14 @@ import kotlinx.coroutines.launch
 import org.w3c.dom.Node
 import world.phantasmal.core.disposable.Disposable
 import world.phantasmal.core.disposable.Disposer
-import world.phantasmal.core.math.degToRad
-import world.phantasmal.core.math.radToDeg
-import world.phantasmal.lib.fileFormats.quest.EntityPropType
 import world.phantasmal.observable.cell.Cell
+import world.phantasmal.observable.cell.cell
 import world.phantasmal.observable.cell.mutableCell
 import world.phantasmal.web.core.widgets.UnavailableWidget
 import world.phantasmal.web.questEditor.controllers.EntityInfoController
-import world.phantasmal.web.questEditor.models.QuestEntityPropModel
+import world.phantasmal.web.questEditor.controllers.EntityInfoPropModel
 import world.phantasmal.webui.dom.*
+import world.phantasmal.webui.widgets.Button
 import world.phantasmal.webui.widgets.DoubleInput
 import world.phantasmal.webui.widgets.IntInput
 import world.phantasmal.webui.widgets.Widget
@ -82,10 +81,12 @@ class EntityInfoWidget(private val ctrl: EntityInfoController) : Widget(enabled

                bindDisposableChildrenTo(ctrl.props) { prop, _ -> createPropRow(prop) }
            }
-            addChild(UnavailableWidget(
+            addChild(
+                UnavailableWidget(
                    visible = ctrl.unavailable,
                    message = "No entity selected.",
-            ))
+                )
+            )
        }

    private fun Node.createCoordRow(
@ -124,34 +125,36 @@ class EntityInfoWidget(private val ctrl: EntityInfoController) : Widget(enabled
        }
    }

-    private fun Node.createPropRow(prop: QuestEntityPropModel): Pair<Node, Disposable> {
+    private fun Node.createPropRow(prop: EntityInfoPropModel): Pair<Node, Disposable> {
        val disposer = Disposer()

-        val input = disposer.add(when (prop.type) {
-            EntityPropType.I32 -> IntInput(
+        val input = disposer.add(
+            when (prop) {
+                is EntityInfoPropModel.I32 -> IntInput(
                    enabled = ctrl.enabled,
-                label = prop.name + ":",
+                    label = prop.label,
                    min = Int.MIN_VALUE,
                    max = Int.MAX_VALUE,
                    step = 1,
-                value = prop.value.map { it as Int },
-                onChange = { ctrl.setPropValue(prop, it) },
+                    value = prop.value,
+                    onChange = prop::setValue,
                )
-            EntityPropType.F32 -> DoubleInput(
+                is EntityInfoPropModel.F32 -> DoubleInput(
                    enabled = ctrl.enabled,
-                label = prop.name + ":",
+                    label = prop.label,
                    roundTo = 3,
-                value = prop.value.map { (it as Float).toDouble() },
-                onChange = { ctrl.setPropValue(prop, it.toFloat()) },
+                    value = prop.value,
+                    onChange = prop::setValue,
                )
-            EntityPropType.Angle -> DoubleInput(
+                is EntityInfoPropModel.Angle -> DoubleInput(
                    enabled = ctrl.enabled,
-                label = prop.name + ":",
+                    label = prop.label,
                    roundTo = 1,
-                value = prop.value.map { radToDeg((it as Float).toDouble()) },
-                onChange = { ctrl.setPropValue(prop, degToRad(it).toFloat()) },
+                    value = prop.value,
+                    onChange = prop::setValue,
+                )
+            }
        )
-        })

        val node = tr {
            th {
@ -160,6 +163,23 @@ class EntityInfoWidget(private val ctrl: EntityInfoController) : Widget(enabled
            td {
                addWidget(input, addToDisposer = false)
            }
+
+            if (prop is EntityInfoPropModel.I32 && prop.showGoToEvent) {
+                td {
+                    addWidget(
+                        disposer.add(Button(
+                            enabled = prop.canGoToEvent,
+                            tooltip = cell("Go to event"),
+                            iconLeft = Icon.ArrowRight,
+                            onClick = { e ->
+                                e.stopPropagation()
+                                prop.goToEvent()
+                            }
+                        )),
+                        addToDisposer = false,
+                    )
+                }
+            }
        }

        return Pair(node, disposer)
@ -172,7 +192,8 @@ class EntityInfoWidget(private val ctrl: EntityInfoController) : Widget(enabled
        init {
            @Suppress("CssUnusedSymbol")
            // language=css
-            style("""
+            style(
+                """
                .pw-quest-editor-entity-info {
                    outline: none;
                    box-sizing: border-box;
@ -181,13 +202,13 @@ class EntityInfoWidget(private val ctrl: EntityInfoController) : Widget(enabled
                }

                .pw-quest-editor-entity-info table {
-                    table-layout: fixed;
                    width: 100%;
                    margin: 0 auto;
                }

                .pw-quest-editor-entity-info th {
                    text-align: left;
+                    width: 50%;
                }

                .pw-quest-editor-entity-info .$COORD_CLASS th {
@ -206,7 +227,8 @@ class EntityInfoWidget(private val ctrl: EntityInfoController) : Widget(enabled
                .pw-quest-editor-entity-info-specific-props .pw-number-input {
                    width: 100%;
                }
-            """.trimIndent())
+            """.trimIndent()
+            )
        }
    }
 }
--- a/web/src/test/kotlin/world/phantasmal/web/questEditor/controllers/EntityInfoControllerTests.kt
+++ b/web/src/test/kotlin/world/phantasmal/web/questEditor/controllers/EntityInfoControllerTests.kt
@ -3,17 +3,17 @@ package world.phantasmal.web.questEditor.controllers
 import world.phantasmal.lib.Episode
 import world.phantasmal.lib.fileFormats.Vec3
 import world.phantasmal.lib.fileFormats.quest.NpcType
+import world.phantasmal.lib.fileFormats.quest.ObjectType
 import world.phantasmal.lib.fileFormats.quest.QuestNpc
 import world.phantasmal.testUtils.assertCloseTo
+import world.phantasmal.web.questEditor.models.QuestEventModel
 import world.phantasmal.web.questEditor.models.QuestNpcModel
 import world.phantasmal.web.test.WebTestSuite
 import world.phantasmal.web.test.createQuestModel
 import world.phantasmal.web.test.createQuestNpcModel
+import world.phantasmal.web.test.createQuestObjectModel
 import kotlin.math.PI
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertFalse
-import kotlin.test.assertTrue
+import kotlin.test.*

 class EntityInfoControllerTests : WebTestSuite {
    @Test
@ -138,4 +138,33 @@ class EntityInfoControllerTests : WebTestSuite {

        assertTrue(store.canUndo.value)
    }
+
+    @Test
+    fun go_to_event() = testAsync {
+        val store = components.questEditorStore
+        val ctrl = disposer.add(EntityInfoController(components.areaStore, store))
+
+        val obj = createQuestObjectModel(ObjectType.EventCollision)
+        val event = QuestEventModel(id = 100, 0, 0, 0, 0, 0, mutableListOf())
+        store.setCurrentQuest(createQuestModel(objects = listOf(obj), events = listOf(event)))
+        store.setSelectedEntity(obj)
+
+        // The EventCollision object has an "Event ID" property.
+        val eventProp = ctrl.props.value
+            .filterIsInstance<EntityInfoPropModel.I32>()
+            .find { it.showGoToEvent }
+
+        assertNotNull(eventProp)
+
+        // Since the default value is 0 and there's no event 0, "Go to event" should be disabled.
+        assertFalse(eventProp.canGoToEvent.value)
+        eventProp.goToEvent()
+        assertNull(store.selectedEvent.value)
+
+        // Set the value to 100 to enable.
+        eventProp.setValue(100)
+        assertTrue(eventProp.canGoToEvent.value)
+        eventProp.goToEvent()
+        assertEquals(event, store.selectedEvent.value)
+    }
 }
--- a/web/src/test/kotlin/world/phantasmal/web/test/TestModels.kt
+++ b/web/src/test/kotlin/world/phantasmal/web/test/TestModels.kt
@ -3,7 +3,9 @@ package world.phantasmal.web.test
 import world.phantasmal.lib.Episode
 import world.phantasmal.lib.asm.BytecodeIr
 import world.phantasmal.lib.fileFormats.quest.NpcType
+import world.phantasmal.lib.fileFormats.quest.ObjectType
 import world.phantasmal.lib.fileFormats.quest.QuestNpc
+import world.phantasmal.lib.fileFormats.quest.QuestObject
 import world.phantasmal.web.questEditor.models.QuestEventModel
 import world.phantasmal.web.questEditor.models.QuestModel
 import world.phantasmal.web.questEditor.models.QuestNpcModel
@ -43,3 +45,6 @@ fun createQuestNpcModel(type: NpcType, episode: Episode): QuestNpcModel =
        QuestNpc(type, episode, areaId = 0, wave = 0),
        waveId = 0,
    )
+
+fun createQuestObjectModel(type: ObjectType): QuestObjectModel =
+    QuestObjectModel(QuestObject(type, areaId = 0))