HUD & many cgui refactorings

Author: bladekt

common/src/main/kotlin/com/lambda/config/serializer/gui/TagWindowSerializer.kt

@@ -3,6 +3,7 @@ package com.lambda.config.serializer.gui
 import com.google.gson.*
 import com.lambda.gui.impl.clickgui.LambdaClickGui
 import com.lambda.gui.impl.clickgui.windows.tag.TagWindow
+import com.lambda.gui.impl.hudgui.LambdaHudGui
 import com.lambda.module.tag.ModuleTag
 import com.lambda.util.math.Vec2d
 import java.lang.reflect.Type
@@ -30,7 +31,15 @@ object TagWindowSerializer : JsonSerializer<TagWindow>, JsonDeserializer<TagWind
         typeOfT: Type?,
         context: JsonDeserializationContext?,
     )  = json?.asJsonObject?.let {
-        TagWindow(ModuleTag(it["tag"].asString), LambdaClickGui).apply {
+        val tag = ModuleTag(it["tag"].asString)
+
+        val gui = when (tag) {
+            in ModuleTag.defaults -> LambdaClickGui
+            in ModuleTag.hudDefaults -> LambdaHudGui
+            else -> return@let null
+        }
+
+        TagWindow(tag, gui).apply {
             width = it["width"].asDouble
             height = it["height"].asDouble
             isOpen = it["isOpen"].asBoolean

common/src/main/kotlin/com/lambda/config/settings/collections/ListSetting.kt

@@ -21,7 +21,6 @@ class ListSetting<T : Any>(
     }
 
     override fun toJson(): JsonElement {
-        value = defaultValue // Hack the Delegates.observable
         return gson.toJsonTree(value)
     }
 }

common/src/main/kotlin/com/lambda/core/Loader.kt

@@ -7,6 +7,7 @@ import com.lambda.friend.FriendRegistry
 import com.lambda.graphics.renderer.gui.font.LambdaFont
 import com.lambda.graphics.renderer.gui.font.LambdaMoji
 import com.lambda.gui.GuiConfigurable
+import com.lambda.gui.HudGuiConfigurable
 import com.lambda.interaction.PlayerPacketManager
 import com.lambda.interaction.RotationManager
 import com.lambda.module.ModuleRegistry
@@ -23,6 +24,7 @@ object Loader {
         LambdaFont.Loader,
         LambdaMoji.Loader,
         GuiConfigurable,
+        HudGuiConfigurable,
         FriendRegistry,
         SoundRegistry,
     )

common/src/main/kotlin/com/lambda/event/events/RenderEvent.kt

@@ -40,6 +40,8 @@ abstract class RenderEvent : Event {
     }
 
     abstract class GUI(val scale: Double) : RenderEvent() {
+        class HUD(scaleFactor: Double) : GUI(scaleFactor)
+
         class Scaled(scaleFactor: Double) : GUI(scaleFactor)
         class Fixed : GUI(1.0)
 

common/src/main/kotlin/com/lambda/graphics/RenderMain.kt

@@ -25,11 +25,12 @@ object RenderMain {
         translate(0.0, 0.0, -3000.0)
 
         setupGL {
-            rescale(GuiSettings.scale)
-            RenderEvent.GUI.Scaled(GuiSettings.scale).post()
-
             rescale(1.0)
             RenderEvent.GUI.Fixed().post()
+
+            rescale(GuiSettings.scale)
+            RenderEvent.GUI.HUD(GuiSettings.scale).post()
+            RenderEvent.GUI.Scaled(GuiSettings.scale).post()
         }
     }
 

common/src/main/kotlin/com/lambda/gui/AbstractGuiConfigurable.kt

@@ -0,0 +1,27 @@
+package com.lambda.gui
+
+import com.lambda.config.Configurable
+import com.lambda.config.configurations.GuiConfig
+import com.lambda.core.Loadable
+import com.lambda.gui.impl.AbstractClickGui
+import com.lambda.gui.impl.clickgui.windows.tag.CustomModuleWindow
+import com.lambda.gui.impl.clickgui.windows.tag.TagWindow
+import com.lambda.module.tag.ModuleTag
+import com.lambda.util.math.Vec2d
+
+abstract class AbstractGuiConfigurable(
+    private val ownerGui: AbstractClickGui,
+    private val tags: Set<ModuleTag>,
+    override val name: String
+) : Configurable(GuiConfig), Loadable {
+    var mainWindows by setting("windows", defaultWindows)
+    open var customWindows = mutableListOf<CustomModuleWindow>()
+
+    private val defaultWindows get() =
+        tags.mapIndexed { index, tag ->
+            TagWindow(tag, ownerGui).apply {
+                val step = 5.0
+                position = Vec2d((width + step) * index, 0.0) + step
+            }
+        }
+}

common/src/main/kotlin/com/lambda/gui/GuiConfigurable.kt

@@ -1,35 +1,11 @@
 package com.lambda.gui
 
-import com.lambda.config.Configurable
-import com.lambda.config.configurations.GuiConfig
-import com.lambda.core.Loadable
 import com.lambda.gui.impl.clickgui.LambdaClickGui
 import com.lambda.gui.impl.clickgui.windows.tag.CustomModuleWindow
-import com.lambda.gui.impl.clickgui.windows.tag.TagWindow
 import com.lambda.module.tag.ModuleTag
-import com.lambda.util.math.Vec2d
 
-object GuiConfigurable : Configurable(GuiConfig), Loadable {
-    override val name = "gui"
-    private val ownerGui = LambdaClickGui
-
-    val mainWindows by setting("windows", defaultWindows).apply {
-        onValueChange { _, _ ->
-            ownerGui.updateWindows()
-        }
-    }
-
-    val customWindows by setting("custom windows", listOf<CustomModuleWindow>()).apply {
-        onValueChange { _, _ ->
-            ownerGui.updateWindows()
-        }
-    }
-
-    private val defaultWindows get() =
-        ModuleTag.defaults.mapIndexed { index, tag ->
-            TagWindow(tag, ownerGui).apply {
-                val step = 5.0
-                position = Vec2d((width + step) * index, 0.0) + step
-            }
-        }
+object GuiConfigurable : AbstractGuiConfigurable(
+    LambdaClickGui, ModuleTag.defaults, "gui"
+) {
+    override var customWindows by setting("custom windows", listOf<CustomModuleWindow>())
 }

common/src/main/kotlin/com/lambda/gui/HudGuiConfigurable.kt

@@ -0,0 +1,8 @@
+package com.lambda.gui
+
+import com.lambda.gui.impl.hudgui.LambdaHudGui
+import com.lambda.module.tag.ModuleTag
+
+object HudGuiConfigurable : AbstractGuiConfigurable(
+    LambdaHudGui, ModuleTag.hudDefaults, "hudgui"
+)

common/src/main/kotlin/com/lambda/gui/api/LambdaGui.kt

@@ -1,12 +1,13 @@
 package com.lambda.gui.api
 
 import com.lambda.Lambda.mc
-import com.lambda.event.EventFlow.syncListeners
+import com.lambda.event.Muteable
 import com.lambda.event.events.RenderEvent
 import com.lambda.event.events.TickEvent
-import com.lambda.event.listener.UnsafeListener
+import com.lambda.event.listener.SafeListener.Companion.listener
 import com.lambda.graphics.animation.AnimationTicker
 import com.lambda.gui.api.component.core.IComponent
+import com.lambda.gui.impl.AbstractClickGui
 import com.lambda.module.Module
 import com.lambda.util.KeyCode
 import com.lambda.util.Mouse
@@ -18,27 +19,29 @@ import net.minecraft.client.gui.DrawContext
 import net.minecraft.client.gui.screen.Screen
 import net.minecraft.text.Text
 
-@Suppress("LeakingThis")
 abstract class LambdaGui(
     override val name: String,
     private val owner: Module? = null
-) : Screen(Text.of(name)), IComponent, Nameable {
-    private var screenSize = Vec2d.ZERO
+) : Screen(Text.of(name)), IComponent, Nameable, Muteable {
+    protected var screenSize = Vec2d.ZERO
     override val rect get() = Rect(Vec2d.ZERO, screenSize)
 
     val isOpen get() = mc.currentScreen == this
+    override val isMuted: Boolean get() = !isOpen
+    private var closingAction: (() -> Unit)? = null
 
     val animation = AnimationTicker()
 
-    private val renderListener = UnsafeListener(0, this, false) { event ->
-        event as RenderEvent.GUI.Scaled
-        screenSize = event.screenSize
-        onEvent(GuiEvent.Render())
-    }
+    init {
+        listener<RenderEvent.GUI.Scaled> { event ->
+            screenSize = event.screenSize
+            onEvent(GuiEvent.Render())
+        }
 
-    private val tickListener = UnsafeListener(0, this, false) {
-        animation.tick()
-        onEvent(GuiEvent.Tick())
+        listener<TickEvent.Pre> {
+            animation.tick()
+            onEvent(GuiEvent.Tick())
+        }
     }
 
     /**
@@ -47,37 +50,50 @@ abstract class LambdaGui(
      * No safe context required (TODO: let user open clickgui via main menu)
      */
     fun show() {
+        owner?.enable()
         if (isOpen) return
-        mc.currentScreen?.close()
 
-        recordRenderCall { // wait for the previous screen to be closed
-            mc.setScreen(this)
+        when (val screen = mc.currentScreen) {
+            is AbstractClickGui -> {
+                screen.close()
+
+                screen.setCloseTask {
+                    mc.setScreen(this)
+                }
+            }
+
+            else -> {
+                screen?.close()
+
+                recordRenderCall {
+                    mc.setScreen(this)
+                }
+            }
         }
     }
 
     final override fun onDisplayed() {
         onEvent(GuiEvent.Show())
-
-        with(syncListeners) {
-            subscribe<RenderEvent.GUI.Scaled>(renderListener)
-            subscribe<TickEvent.Pre>(tickListener)
-        }
     }
 
-    final override fun removed() {
+    override fun removed() {
         onEvent(GuiEvent.Hide())
 
         // quick crashfix (is there any other way to prevent gui being closed twice?)
         mc.currentScreen = null
         owner?.disable()
         mc.currentScreen = this
 
-        with(syncListeners) {
-            unsubscribe(renderListener)
-            unsubscribe(tickListener)
+        closingAction?.let {
+            recordRenderCall(it)
+            closingAction = null
         }
     }
 
+    fun setCloseTask(block: () -> Unit) {
+        closingAction = block
+    }
+
     final override fun render(context: DrawContext?, mouseX: Int, mouseY: Int, delta: Float) {
         // Let's remove background tint
     }
@@ -93,7 +109,6 @@ abstract class LambdaGui(
         return true
     }
 
-
     final override fun charTyped(chr: Char, modifiers: Int): Boolean {
         onEvent(GuiEvent.CharTyped(chr))
         return true

common/src/main/kotlin/com/lambda/gui/api/component/ListWindow.kt

@@ -2,7 +2,7 @@ package com.lambda.gui.api.component
 
 import com.lambda.gui.api.GuiEvent
 import com.lambda.gui.api.component.button.ListButton
-import com.lambda.gui.impl.clickgui.AbstractClickGui
+import com.lambda.gui.impl.AbstractClickGui
 
 abstract class ListWindow <T : ListButton> (
     owner: AbstractClickGui