Keycode translation because GLFW was designed with two brain cells

Author: Avanatiker

common/src/main/java/com/lambda/mixin/input/KeyboardMixin.java

@@ -14,6 +14,6 @@ public class KeyboardMixin {
     void onKey(long window, int key, int scancode, int action, int modifiers, CallbackInfo ci) {
         if (key <= 0) return;
         if (action != 1) return;
-        EventFlow.post(new KeyPressEvent(key));
+        EventFlow.post(new KeyPressEvent(key, scancode, action, modifiers));
     }
 }

common/src/main/kotlin/com/lambda/config/serializer/KeyCodeSerializer.kt

@@ -19,5 +19,5 @@ object KeyCodeSerializer : JsonSerializer<KeyCode>, JsonDeserializer<KeyCode> {
         typeOfT: Type?,
         context: JsonDeserializationContext?,
     ): KeyCode =
-        json?.asString?.let(KeyCode::fromNameOrNull) ?: throw JsonParseException("Invalid key code format")
+        json?.asString?.let(KeyCode::fromKeyName) ?: throw JsonParseException("Invalid key code format")
 }

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

@@ -3,13 +3,25 @@ package com.lambda.event.events
 import com.lambda.event.EventFlow
 import com.lambda.event.callback.Cancellable
 import com.lambda.event.callback.ICancellable
+import com.lambda.util.KeyCode
 
 /**
  * A class representing a [KeyPressEvent] in the event system ([EventFlow]).
  *
  * A [KeyPressEvent] is a type of event that is triggered when a key is pressed.
  * It implements [ICancellable] interface, which means the event can be cancelled.
  *
- * @property key The key code of the key that was pressed.
+ * @property keyCode The key code of the key that was pressed.
+ * @property scanCode The scan code of the key that was pressed.
+ * @property action The action that was performed on the key.
+ * @property modifiers The modifiers that were active when the key was pressed.
  */
-class KeyPressEvent(val key: Int) : ICancellable by Cancellable()
+data class KeyPressEvent(
+    val keyCode: Int,
+    val scanCode: Int,
+    val action: Int,
+    val modifiers: Int,
+) : ICancellable by Cancellable() {
+    val translated: KeyCode
+        get() = KeyCode.fromUS(keyCode, scanCode)
+}

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

@@ -80,17 +80,17 @@ abstract class LambdaGui(
     }
 
     final override fun keyPressed(keyCode: Int, scanCode: Int, modifiers: Int): Boolean {
-        KeyCode.translateKeyCode(keyCode, scanCode).let {
-            onEvent(GuiEvent.KeyPress(it))
-        }
+        val translated = KeyCode.fromUS(keyCode, scanCode)
+        onEvent(GuiEvent.KeyPress(translated))
 
-        if (keyCode == KeyCode.Escape.keyCode) {
+        if (keyCode == KeyCode.ESCAPE.keyCode) {
             close()
         }
 
         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/button/InputBarOverlay.kt

@@ -88,8 +88,8 @@ abstract class InputBarOverlay (renderer: LayerEntry, owner: ChildLayer.Drawable
 
                 if (isKeyBind) {
                     val key = when (e.key) {
-                        KeyCode.Delete, KeyCode.Backspace -> KeyCode.Unbound
-                        KeyCode.Escape -> return
+                        KeyCode.DELETE, KeyCode.BACKSPACE -> KeyCode.UNBOUND
+                        KeyCode.ESCAPE -> return
                         else -> e.key
                     }
 
@@ -99,12 +99,12 @@ abstract class InputBarOverlay (renderer: LayerEntry, owner: ChildLayer.Drawable
                 }
 
                 when (e.key) {
-                    KeyCode.Enter -> {
+                    KeyCode.ENTER -> {
                         setStringValue(field.text)
                         toggle()
                     }
 
-                    KeyCode.Backspace -> {
+                    KeyCode.BACKSPACE -> {
                         field.text = field.text.dropLast(1)
                         typeAnimation = -1.0
                     }

common/src/main/kotlin/com/lambda/gui/impl/clickgui/buttons/setting/BindButton.kt

@@ -9,6 +9,7 @@ import com.lambda.gui.impl.clickgui.buttons.ModuleButton
 import com.lambda.gui.impl.clickgui.buttons.SettingButton
 import com.lambda.util.KeyCode
 import com.lambda.util.math.ColorUtils.multAlpha
+import com.lambda.util.primitives.extension.displayValue
 
 class BindButton(
     setting: KeyBindSetting,
@@ -22,7 +23,7 @@ class BindButton(
         override val showAnimation      get() = this@BindButton.showAnimation
         override val isKeyBind = true
 
-        override fun getText() = value.localizedName
+        override fun getText() = value.displayValue
         override fun setKeyValue(key: KeyCode) { value = key }
     }.apply(layer::addChild)
 

common/src/main/kotlin/com/lambda/module/Module.kt

@@ -15,8 +15,10 @@ import com.lambda.event.listener.SafeListener.Companion.listener
 import com.lambda.event.listener.UnsafeListener
 import com.lambda.gui.impl.clickgui.LambdaClickGui
 import com.lambda.module.tag.ModuleTag
+import com.lambda.util.Communication.info
 import com.lambda.util.KeyCode
 import com.lambda.util.Nameable
+import org.lwjgl.glfw.GLFW
 
 /**
  * A [Module] is a feature or tool for the utility mod.
@@ -33,7 +35,7 @@ import com.lambda.util.Nameable
  * The default [keybind] is the key on which
  * the module will be activated by default.
  * If a module does not need to be activated by a key (like [ClickGUI]),
- * the default [keybind] should not be set (using [KeyCode.Unbound]).
+ * the default [keybind] should not be set (using [KeyCode.UNBOUND]).
  *
  * [Module]s are [Configurable]s with [settings] (see [AbstractSetting] for all setting types).
  * For example, a [BooleanSetting] and a [DoubleSetting] can be defined like this:
@@ -93,7 +95,7 @@ abstract class Module(
     val defaultTags: Set<ModuleTag> = setOf(),
     private val alwaysListening: Boolean = false,
     enabledByDefault: Boolean = false,
-    defaultKeybind: KeyCode = KeyCode.Unbound,
+    defaultKeybind: KeyCode = KeyCode.UNBOUND,
 ) : Nameable, Muteable, Configurable(ModuleConfig) {
     private val isEnabledSetting = setting("Enabled", enabledByDefault, visibility = { false })
     private val keybindSetting = setting("Keybind", defaultKeybind)
@@ -109,7 +111,7 @@ abstract class Module(
     init {
         listener<KeyPressEvent>(alwaysListen = true) { event ->
             val screen = mc.currentScreen
-            if (event.key == keybind.keyCode
+            if (event.translated == keybind
                 && !mc.options.commandKey.isPressed
                 && (screen == null
                 || screen is LambdaClickGui)

common/src/main/kotlin/com/lambda/module/modules/player/Nuker.kt

@@ -12,8 +12,7 @@ import net.minecraft.util.math.Vec3i
 
 object Nuker : Module(
     name = "Nuker",
-    description = "Breaks blocks around you",
-    defaultKeybind = KeyCode.Comma
+    description = "Breaks blocks around you"
 ) {
     private val flatten by setting("Flatten", true)
 

common/src/main/kotlin/com/lambda/module/modules/player/Replay.kt

@@ -98,11 +98,11 @@ object Replay : Module(
         listener<KeyPressEvent> {
             if (mc.currentScreen != null && !mc.options.commandKey.isPressed) return@listener
 
-            when (it.key) {
-                record.keyCode -> handleRecord()
-                play.keyCode -> handlePlay()
-                cycle.keyCode -> handlePlayModeCycle()
-                check.keyCode -> handleCheckpoint()
+            when (it.translated) {
+                record -> handleRecord()
+                play -> handlePlay()
+                cycle -> handlePlayModeCycle()
+                check -> handleCheckpoint()
                 else -> {}
             }
         }

common/src/main/kotlin/com/lambda/task/tasks/TaskTester.kt

@@ -9,7 +9,7 @@ import org.lwjgl.glfw.GLFW
 object TaskTester {
     init {
         listener<KeyPressEvent> {
-            if (it.key != GLFW.GLFW_KEY_Z) {
+            if (it.keyCode != GLFW.GLFW_KEY_Z) {
                 return@listener
             }