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

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) }
 

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>> =
+    val props: ListCell<EntityInfoPropModel> =
-        questEditorStore.selectedEntity.flatMap { it?.properties ?: emptyListCell() }
+        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,15 +192,17 @@ class EntityInfoController(
     private fun setPos(entity: QuestEntityModel<*, *>, x: Double, y: Double, z: Double) {
         if (!enabled.value) return
 
-        questEditorStore.executeAction(TranslateEntityAction(
+        questEditorStore.executeAction(
-            setSelectedEntity = questEditorStore::setSelectedEntity,
+            TranslateEntityAction(
-            setEntitySection = { /* Won't be called. */ },
+                setSelectedEntity = questEditorStore::setSelectedEntity,
-            entity,
+                setEntitySection = { /* Won't be called. */ },
-            newSection = null,
+                entity,
-            oldSection = null,
+                newSection = null,
-            newPosition = Vector3(x, y, z),
+                oldSection = null,
-            oldPosition = entity.position.value,
+                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(
-            setSelectedEntity = questEditorStore::setSelectedEntity,
+            RotateEntityAction(
-            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,
+                euler(x, y, z),
-                value,
+                entity.rotation.value,
-                prop.value.value,
+                false,
-            ))
+            )
-        }
+        )
     }
 
     companion object {

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> = store.currentAreaEvents
-    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 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> =
+    fun canGoToEvent(eventId: Cell<Int>): Cell<Boolean> = store.canGoToEvent(eventId)
-        map(enabled, events, eventId) { en, evts, id ->
-            en && evts.any { it.id.value == id }
-        }
 
     fun goToEvent(eventId: Int) {
-        events.value.find { it.id.value == eventId }?.let { event ->
+        store.goToEvent(eventId)
-            store.setSelectedEvent(event)
-        }
     }
 
     fun setActionSectionId(

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)

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(
-                visible = ctrl.unavailable,
+                UnavailableWidget(
-                message = "No entity selected.",
+                    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) {
+        val input = disposer.add(
-            EntityPropType.I32 -> IntInput(
+            when (prop) {
-                enabled = ctrl.enabled,
+                is EntityInfoPropModel.I32 -> IntInput(
-                label = prop.name + ":",
+                    enabled = ctrl.enabled,
-                min = Int.MIN_VALUE,
+                    label = prop.label,
-                max = Int.MAX_VALUE,
+                    min = Int.MIN_VALUE,
-                step = 1,
+                    max = Int.MAX_VALUE,
-                value = prop.value.map { it as Int },
+                    step = 1,
-                onChange = { ctrl.setPropValue(prop, it) },
+                    value = prop.value,
-            )
+                    onChange = prop::setValue,
-            EntityPropType.F32 -> DoubleInput(
+                )
-                enabled = ctrl.enabled,
+                is EntityInfoPropModel.F32 -> DoubleInput(
-                label = prop.name + ":",
+                    enabled = ctrl.enabled,
-                roundTo = 3,
+                    label = prop.label,
-                value = prop.value.map { (it as Float).toDouble() },
+                    roundTo = 3,
-                onChange = { ctrl.setPropValue(prop, it.toFloat()) },
+                    value = prop.value,
-            )
+                    onChange = prop::setValue,
-            EntityPropType.Angle -> DoubleInput(
+                )
-                enabled = ctrl.enabled,
+                is EntityInfoPropModel.Angle -> DoubleInput(
-                label = prop.name + ":",
+                    enabled = ctrl.enabled,
-                roundTo = 1,
+                    label = prop.label,
-                value = prop.value.map { radToDeg((it as Float).toDouble()) },
+                    roundTo = 1,
-                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()
+            )
         }
     }
 }

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.*
-import kotlin.test.assertEquals
-import kotlin.test.assertFalse
-import kotlin.test.assertTrue
 
 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)
+    }
 }

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))