Fix up most of the remaining event handlers

[no changelog]

2 files changed, 208 insertions, 213 deletions

diff --git a/src/main/kotlin/moe/nea/firmament/features/world/FairySouls.kt b/src/main/kotlin/moe/nea/firmament/features/world/FairySouls.kt
index 462325e..2cce041 100644
--- a/src/main/kotlin/moe/nea/firmament/features/world/FairySouls.kt
+++ b/src/main/kotlin/moe/nea/firmament/features/world/FairySouls.kt
@@ -9,15 +9,10 @@ package moe.nea.firmament.features.world
 import io.github.moulberry.repo.data.Coordinate
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.serializer
-import net.minecraft.client.render.RenderLayer
-import net.minecraft.client.render.RenderLayer.ALWAYS_DEPTH_TEST
-import net.minecraft.client.render.RenderLayer.MultiPhaseParameters
-import net.minecraft.client.render.RenderPhase
-import net.minecraft.client.render.VertexFormat
-import net.minecraft.client.render.VertexFormats
 import net.minecraft.text.Text
 import net.minecraft.util.math.Vec3d
-import moe.nea.firmament.events.AllowChatEvent
+import moe.nea.firmament.annotations.Subscribe
+import moe.nea.firmament.events.ProcessChatEvent
 import moe.nea.firmament.events.SkyblockServerUpdateEvent
 import moe.nea.firmament.events.WorldRenderLastEvent
 import moe.nea.firmament.features.FirmamentFeature
@@ -102,53 +97,43 @@ object FairySouls : FirmamentFeature {
         updateMissingSouls()
     }
 
-    val NODEPTH: RenderLayer = RenderLayer.of(
-        "firmamentnodepth",
-        VertexFormats.POSITION_COLOR_TEXTURE,
-        VertexFormat.DrawMode.QUADS,
-        256,
-        true,
-        true,
-        MultiPhaseParameters.builder()
-            .program(RenderPhase.COLOR_PROGRAM)
-            .writeMaskState(RenderPhase.COLOR_MASK)
-            .depthTest(ALWAYS_DEPTH_TEST)
-            .cull(RenderPhase.DISABLE_CULLING)
-            .layering(RenderLayer.VIEW_OFFSET_Z_LAYERING)
-            .target(RenderPhase.MAIN_TARGET)
-            .build(true)
-    )
-
-    override fun onLoad() {
-        SkyblockServerUpdateEvent.subscribe {
-            currentLocationName = it.newLocraw?.skyblockLocation
-            updateWorldSouls()
-            updateMissingSouls()
-        }
-        AllowChatEvent.subscribe {
-            when (it.text.unformattedString) {
-                "You have already found that Fairy Soul!" -> {
-                    markNearestSoul()
-                }
-
-                "SOUL! You found a Fairy Soul!" -> {
-                    markNearestSoul()
-                }
+    @Subscribe
+    fun onWorldRender(it: WorldRenderLastEvent) {
+        if (!TConfig.displaySouls) return
+        renderInWorld(it) {
+            text(Vec3d(0.0, 0.0, 0.0),
+                 Text.literal("Test String"),
+                 Text.literal("Short"),
+                 Text.literal("just lik"),
+                 verticalAlign = RenderInWorldContext.VerticalAlign.BOTTOM)
+            color(1F, 1F, 0F, 0.8F)
+            currentMissingSouls.forEach {
+                block(it.blockPos)
+            }
+            color(1f, 0f, 1f, 1f)
+            currentLocationSouls.forEach {
+                wireframeCube(it.blockPos)
             }
         }
-        WorldRenderLastEvent.subscribe {
-            if (!TConfig.displaySouls) return@subscribe
-            renderInWorld(it) {
-                text(Vec3d(0.0, 0.0, 0.0), Text.literal("Test String") , Text.literal("Short"), Text.literal("just lik"), verticalAlign = RenderInWorldContext.VerticalAlign.BOTTOM)
-                color(1F, 1F, 0F, 0.8F)
-                currentMissingSouls.forEach {
-                    block(it.blockPos)
-                }
-                color(1f, 0f, 1f, 1f)
-                currentLocationSouls.forEach {
-                    wireframeCube(it.blockPos)
-                }
+    }
+
+    @Subscribe
+    fun onProcessChat(it: ProcessChatEvent) {
+        when (it.text.unformattedString) {
+            "You have already found that Fairy Soul!" -> {
+                markNearestSoul()
+            }
+
+            "SOUL! You found a Fairy Soul!" -> {
+                markNearestSoul()
             }
         }
     }
+
+    @Subscribe
+    fun onLocationChange(it: SkyblockServerUpdateEvent) {
+        currentLocationName = it.newLocraw?.skyblockLocation
+        updateWorldSouls()
+        updateMissingSouls()
+    }
 }
diff --git a/src/main/kotlin/moe/nea/firmament/features/world/Waypoints.kt b/src/main/kotlin/moe/nea/firmament/features/world/Waypoints.kt
index bad82b0..dcb3014 100644
--- a/src/main/kotlin/moe/nea/firmament/features/world/Waypoints.kt
+++ b/src/main/kotlin/moe/nea/firmament/features/world/Waypoints.kt
@@ -22,6 +22,7 @@ import net.minecraft.text.Text
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Vec3d
 import moe.nea.firmament.Firmament
+import moe.nea.firmament.annotations.Subscribe
 import moe.nea.firmament.commands.get
 import moe.nea.firmament.commands.thenArgument
 import moe.nea.firmament.commands.thenExecute
@@ -73,195 +74,204 @@ object Waypoints : FirmamentFeature {
         val b: Int = 0,
     )
 
-    override fun onLoad() {
-        WorldRenderLastEvent.subscribe { event ->
-            temporaryPlayerWaypointList.entries.removeIf { it.value.postedAt.passedTime() > TConfig.tempWaypointDuration }
-            if (temporaryPlayerWaypointList.isNotEmpty())
-                RenderInWorldContext.renderInWorld(event) {
-                    color(1f, 1f, 0f, 1f)
-                    temporaryPlayerWaypointList.forEach { (player, waypoint) ->
-                        block(waypoint.pos)
-                    }
+    @Subscribe
+    fun onRenderOrderedWaypoints(event: WorldRenderLastEvent) {
+        if (waypoints.isEmpty()) return
+        RenderInWorldContext.renderInWorld(event) {
+            if (!ordered) {
+                waypoints.withIndex().forEach {
+                    color(0f, 0.3f, 0.7f, 0.5f)
+                    block(it.value)
                     color(1f, 1f, 1f, 1f)
-                    temporaryPlayerWaypointList.forEach { (player, waypoint) ->
-                        val skin =
-                            MC.networkHandler?.listedPlayerListEntries?.find { it.profile.name == player }
-                                ?.skinTextures
-                                ?.texture
-                        withFacingThePlayer(waypoint.pos.toCenterPos()) {
-                            waypoint(waypoint.pos, Text.stringifiedTranslatable("firmament.waypoint.temporary", player))
-                            if (skin != null) {
-                                matrixStack.translate(0F, -20F, 0F)
-                                // Head front
-                                texture(
-                                    skin, 16, 16,
-                                    1 / 8f, 1 / 8f,
-                                    2 / 8f, 2 / 8f,
-                                )
-                                // Head overlay
-                                texture(
-                                    skin, 16, 16,
-                                    5 / 8f, 1 / 8f,
-                                    6 / 8f, 2 / 8f,
-                                )
-                            }
+                    if (TConfig.showIndex)
+                        withFacingThePlayer(it.value.toCenterPos()) {
+                            text(Text.literal(it.index.toString()))
                         }
-                    }
                 }
+            } else {
+                orderedIndex %= waypoints.size
+                val firstColor = Color.ofRGBA(0, 200, 40, 180)
+                color(firstColor)
+                tracer(waypoints[orderedIndex].toCenterPos(), lineWidth = 3f)
+                waypoints.withIndex().toList()
+                    .wrappingWindow(orderedIndex, 3)
+                    .zip(
+                        listOf(
+                            firstColor,
+                            Color.ofRGBA(180, 200, 40, 150),
+                            Color.ofRGBA(180, 80, 20, 140),
+                        )
+                    )
+                    .reversed()
+                    .forEach { (waypoint, col) ->
+                        val (index, pos) = waypoint
+                        color(col)
+                        block(pos)
+                        color(1f, 1f, 1f, 1f)
+                        if (TConfig.showIndex)
+                            withFacingThePlayer(pos.toCenterPos()) {
+                                text(Text.literal(index.toString()))
+                            }
+                    }
+            }
         }
-        WorldReadyEvent.subscribe {
-            temporaryPlayerWaypointList.clear()
+    }
+
+    @Subscribe
+    fun onTick(event: TickEvent) {
+        if (waypoints.isEmpty() || !ordered) return
+        orderedIndex %= waypoints.size
+        val p = MC.player?.pos ?: return
+        if (TConfig.skipToNearest) {
+            orderedIndex =
+                (waypoints.withIndex().minBy { it.value.getSquaredDistance(p) }.index + 1) % waypoints.size
+        } else {
+            if (waypoints[orderedIndex].isWithinDistance(p, 3.0)) {
+                orderedIndex = (orderedIndex + 1) % waypoints.size
+            }
         }
-        CommandEvent.SubCommand.subscribe { event ->
-            event.subcommand("waypoint") {
-                thenArgument("pos", BlockPosArgumentType.blockPos()) { pos ->
-                    thenExecute {
-                        val position = pos.get(this).toAbsoluteBlockPos(source.asFakeServer())
-                        waypoints.add(position)
-                        source.sendFeedback(
-                            Text.stringifiedTranslatable(
-                                "firmament.command.waypoint.added",
-                                position.x,
-                                position.y,
-                                position.z
-                            )
+    }
+
+    @Subscribe
+    fun onProcessChat(it: ProcessChatEvent) {
+        val matcher = temporaryPlayerWaypointMatcher.matcher(it.unformattedString)
+        if (it.nameHeuristic != null && TConfig.tempWaypointDuration > 0.seconds && matcher.find()) {
+            temporaryPlayerWaypointList[it.nameHeuristic] = TemporaryWaypoint(
+                BlockPos(
+                    matcher.group(1).toInt(),
+                    matcher.group(2).toInt(),
+                    matcher.group(3).toInt(),
+                ),
+                TimeMark.now()
+            )
+        }
+    }
+
+    @Subscribe
+    fun onCommand(event: CommandEvent.SubCommand) {
+        event.subcommand("waypoint") {
+            thenArgument("pos", BlockPosArgumentType.blockPos()) { pos ->
+                thenExecute {
+                    val position = pos.get(this).toAbsoluteBlockPos(source.asFakeServer())
+                    waypoints.add(position)
+                    source.sendFeedback(
+                        Text.stringifiedTranslatable(
+                            "firmament.command.waypoint.added",
+                            position.x,
+                            position.y,
+                            position.z
                         )
-                    }
+                    )
                 }
             }
-            event.subcommand("waypoints") {
-                thenLiteral("clear") {
-                    thenExecute {
-                        waypoints.clear()
-                        source.sendFeedback(Text.translatable("firmament.command.waypoint.clear"))
-                    }
-                }
-                thenLiteral("toggleordered") {
-                    thenExecute {
-                        ordered = !ordered
-                        if (ordered) {
-                            val p = MC.player?.pos ?: Vec3d.ZERO
-                            orderedIndex =
-                                waypoints.withIndex().minByOrNull { it.value.getSquaredDistance(p) }?.index ?: 0
-                        }
-                        source.sendFeedback(Text.translatable("firmament.command.waypoint.ordered.toggle.$ordered"))
-                    }
+        }
+        event.subcommand("waypoints") {
+            thenLiteral("clear") {
+                thenExecute {
+                    waypoints.clear()
+                    source.sendFeedback(Text.translatable("firmament.command.waypoint.clear"))
                 }
-                thenLiteral("skip") {
-                    thenExecute {
-                        if (ordered && waypoints.isNotEmpty()) {
-                            orderedIndex = (orderedIndex + 1) % waypoints.size
-                            source.sendFeedback(Text.translatable("firmament.command.waypoint.skip"))
-                        } else {
-                            source.sendError(Text.translatable("firmament.command.waypoint.skip.error"))
-                        }
+            }
+            thenLiteral("toggleordered") {
+                thenExecute {
+                    ordered = !ordered
+                    if (ordered) {
+                        val p = MC.player?.pos ?: Vec3d.ZERO
+                        orderedIndex =
+                            waypoints.withIndex().minByOrNull { it.value.getSquaredDistance(p) }?.index ?: 0
                     }
+                    source.sendFeedback(Text.translatable("firmament.command.waypoint.ordered.toggle.$ordered"))
                 }
-                thenLiteral("remove") {
-                    thenArgument("index", IntegerArgumentType.integer(0)) { indexArg ->
-                        thenExecute {
-                            val index = get(indexArg)
-                            if (index in waypoints.indices) {
-                                waypoints.removeAt(index)
-                                source.sendFeedback(Text.stringifiedTranslatable(
-                                    "firmament.command.waypoint.remove",
-                                    index))
-                            } else {
-                                source.sendError(Text.stringifiedTranslatable("firmament.command.waypoint.remove.error"))
-                            }
-                        }
+            }
+            thenLiteral("skip") {
+                thenExecute {
+                    if (ordered && waypoints.isNotEmpty()) {
+                        orderedIndex = (orderedIndex + 1) % waypoints.size
+                        source.sendFeedback(Text.translatable("firmament.command.waypoint.skip"))
+                    } else {
+                        source.sendError(Text.translatable("firmament.command.waypoint.skip.error"))
                     }
                 }
-                thenLiteral("import") {
+            }
+            thenLiteral("remove") {
+                thenArgument("index", IntegerArgumentType.integer(0)) { indexArg ->
                     thenExecute {
-                        val contents = ClipboardUtils.getTextContents()
-                        val data = try {
-                            Firmament.json.decodeFromString<List<ColeWeightWaypoint>>(contents)
-                        } catch (ex: Exception) {
-                            Firmament.logger.error("Could not load waypoints from clipboard", ex)
-                            source.sendError(Text.translatable("firmament.command.waypoint.import.error"))
-                            return@thenExecute
+                        val index = get(indexArg)
+                        if (index in waypoints.indices) {
+                            waypoints.removeAt(index)
+                            source.sendFeedback(Text.stringifiedTranslatable(
+                                "firmament.command.waypoint.remove",
+                                index))
+                        } else {
+                            source.sendError(Text.stringifiedTranslatable("firmament.command.waypoint.remove.error"))
                         }
-                        waypoints.clear()
-                        data.mapTo(waypoints) { BlockPos(it.x, it.y, it.z) }
-                        source.sendFeedback(
-                            Text.stringifiedTranslatable(
-                                "firmament.command.waypoint.import",
-                                data.size
-                            )
-                        )
                     }
                 }
             }
-        }
-        WorldRenderLastEvent.subscribe { event ->
-            if (waypoints.isEmpty()) return@subscribe
-            RenderInWorldContext.renderInWorld(event) {
-                if (!ordered) {
-                    waypoints.withIndex().forEach {
-                        color(0f, 0.3f, 0.7f, 0.5f)
-                        block(it.value)
-                        color(1f, 1f, 1f, 1f)
-                        if (TConfig.showIndex)
-                            withFacingThePlayer(it.value.toCenterPos()) {
-                                text(Text.literal(it.index.toString()))
-                            }
+            thenLiteral("import") {
+                thenExecute {
+                    val contents = ClipboardUtils.getTextContents()
+                    val data = try {
+                        Firmament.json.decodeFromString<List<ColeWeightWaypoint>>(contents)
+                    } catch (ex: Exception) {
+                        Firmament.logger.error("Could not load waypoints from clipboard", ex)
+                        source.sendError(Text.translatable("firmament.command.waypoint.import.error"))
+                        return@thenExecute
                     }
-                } else {
-                    orderedIndex %= waypoints.size
-                    val firstColor = Color.ofRGBA(0, 200, 40, 180)
-                    color(firstColor)
-                    tracer(waypoints[orderedIndex].toCenterPos(), lineWidth = 3f)
-                    waypoints.withIndex().toList()
-                        .wrappingWindow(orderedIndex, 3)
-                        .zip(
-                            listOf(
-                                firstColor,
-                                Color.ofRGBA(180, 200, 40, 150),
-                                Color.ofRGBA(180, 80, 20, 140),
-                            )
+                    waypoints.clear()
+                    data.mapTo(waypoints) { BlockPos(it.x, it.y, it.z) }
+                    source.sendFeedback(
+                        Text.stringifiedTranslatable(
+                            "firmament.command.waypoint.import",
+                            data.size
                         )
-                        .reversed()
-                        .forEach { (waypoint, col) ->
-                            val (index, pos) = waypoint
-                            color(col)
-                            block(pos)
-                            color(1f, 1f, 1f, 1f)
-                            if (TConfig.showIndex)
-                                withFacingThePlayer(pos.toCenterPos()) {
-                                    text(Text.literal(index.toString()))
-                                }
-                        }
+                    )
                 }
             }
         }
-        TickEvent.subscribe {
-            if (waypoints.isEmpty() || !ordered) return@subscribe
-            orderedIndex %= waypoints.size
-            val p = MC.player?.pos ?: return@subscribe
-            if (TConfig.skipToNearest) {
-                orderedIndex =
-                    (waypoints.withIndex().minBy { it.value.getSquaredDistance(p) }.index + 1) % waypoints.size
-            } else {
-                if (waypoints[orderedIndex].isWithinDistance(p, 3.0)) {
-                    orderedIndex = (orderedIndex + 1) % waypoints.size
-                }
+    }
+
+    @Subscribe
+    fun onRenderTemporaryWaypoints(event: WorldRenderLastEvent) {
+        temporaryPlayerWaypointList.entries.removeIf { it.value.postedAt.passedTime() > TConfig.tempWaypointDuration }
+        if (temporaryPlayerWaypointList.isEmpty()) return
+        RenderInWorldContext.renderInWorld(event) {
+            color(1f, 1f, 0f, 1f)
+            temporaryPlayerWaypointList.forEach { (player, waypoint) ->
+                block(waypoint.pos)
             }
-        }
-        ProcessChatEvent.subscribe {
-            val matcher = temporaryPlayerWaypointMatcher.matcher(it.unformattedString)
-            if (it.nameHeuristic != null && TConfig.tempWaypointDuration > 0.seconds && matcher.find()) {
-                temporaryPlayerWaypointList[it.nameHeuristic] = TemporaryWaypoint(
-                    BlockPos(
-                        matcher.group(1).toInt(),
-                        matcher.group(2).toInt(),
-                        matcher.group(3).toInt(),
-                    ),
-                    TimeMark.now()
-                )
+            color(1f, 1f, 1f, 1f)
+            temporaryPlayerWaypointList.forEach { (player, waypoint) ->
+                val skin =
+                    MC.networkHandler?.listedPlayerListEntries?.find { it.profile.name == player }
+                        ?.skinTextures
+                        ?.texture
+                withFacingThePlayer(waypoint.pos.toCenterPos()) {
+                    waypoint(waypoint.pos, Text.stringifiedTranslatable("firmament.waypoint.temporary", player))
+                    if (skin != null) {
+                        matrixStack.translate(0F, -20F, 0F)
+                        // Head front
+                        texture(
+                            skin, 16, 16,
+                            1 / 8f, 1 / 8f,
+                            2 / 8f, 2 / 8f,
+                        )
+                        // Head overlay
+                        texture(
+                            skin, 16, 16,
+                            5 / 8f, 1 / 8f,
+                            6 / 8f, 2 / 8f,
+                        )
+                    }
+                }
             }
         }
     }
+
+    @Subscribe
+    fun onWorldReady(event: WorldReadyEvent) {
+        temporaryPlayerWaypointList.clear()
+    }
 }
 
 fun <E> List<E>.wrappingWindow(startIndex: Int, windowSize: Int): List<E> {