Merge branch '1.21.5' into feature/mouse-button-binds

# Conflicts:
#	src/main/kotlin/com/lambda/module/Module.kt

Author: beanbag44

src/main/java/com/lambda/mixin/entity/EntityMixin.java

@@ -22,9 +22,12 @@
 import com.lambda.event.events.EntityEvent;
 import com.lambda.event.events.PlayerEvent;
 import com.lambda.interaction.request.rotating.RotationManager;
+import com.lambda.interaction.request.rotating.RotationMode;
+import com.lambda.module.modules.player.RotationLock;
 import com.lambda.module.modules.render.NoRender;
 import com.lambda.util.math.Vec2d;
 import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import com.llamalad7.mixinextras.injector.v2.WrapWithCondition;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.MovementType;
 import net.minecraft.entity.data.TrackedData;
@@ -142,4 +145,20 @@ private boolean modifyGetFlagInvisible(boolean original) {
     private boolean modifyGetFlagGlowing(boolean original) {
         return (NoRender.INSTANCE.isDisabled() || !NoRender.getNoGlow()) && original;
     }
+
+    @WrapWithCondition(method = "changeLookDirection", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/Entity;setYaw(F)V"))
+    private boolean wrapSetYaw(Entity instance, float yaw) {
+        return (instance != Lambda.getMc().player ||
+                RotationLock.INSTANCE.isDisabled() ||
+                RotationLock.getRotationSettings().getRotationMode() != RotationMode.Lock ||
+                RotationLock.getYawMode() == RotationLock.RotationMode.None);
+    }
+
+    @WrapWithCondition(method = "changeLookDirection", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/Entity;setPitch(F)V"))
+    private boolean wrapSetPitch(Entity instance, float yaw) {
+        return (instance != Lambda.getMc().player ||
+                RotationLock.INSTANCE.isDisabled() ||
+                RotationLock.getRotationSettings().getRotationMode() != RotationMode.Lock ||
+                RotationLock.getPitchMode() == RotationLock.RotationMode.None);
+    }
 }

src/main/java/com/lambda/mixin/input/MouseMixin.java

@@ -19,12 +19,16 @@
 
 import com.lambda.event.EventFlow;
 import com.lambda.event.events.MouseEvent;
+import com.lambda.module.modules.render.Zoom;
 import com.lambda.util.math.Vec2d;
 import net.minecraft.client.Mouse;
+import net.minecraft.client.option.GameOptions;
+import net.minecraft.client.option.SimpleOption;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(Mouse.class)
@@ -61,4 +65,17 @@ private void onCursorPos(long window, double x, double y, CallbackInfo ci) {
             ci.cancel();
         }
     }
+
+    @Redirect(method = "updateMouse", at = @At(value = "FIELD", target = "Lnet/minecraft/client/option/GameOptions;smoothCameraEnabled:Z"))
+    private boolean redirectSmoothCameraEnabled(GameOptions instance) {
+        if (Zoom.INSTANCE.isEnabled() && Zoom.getSmoothMovement()) return true;
+        else return instance.smoothCameraEnabled;
+    }
+
+    @SuppressWarnings("rawtypes")
+    @Redirect(method = "updateMouse", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/option/SimpleOption;getValue()Ljava/lang/Object;", ordinal = 0))
+    private Object redirectGetValue(SimpleOption instance) {
+        if (Zoom.INSTANCE.isEnabled()) return ((Double) instance.getValue()) / Zoom.getTargetZoom();
+        else return instance.getValue();
+    }
 }

src/main/java/com/lambda/mixin/render/GameRendererMixin.java

@@ -21,7 +21,9 @@
 import com.lambda.event.events.RenderEvent;
 import com.lambda.graphics.RenderMain;
 import com.lambda.module.modules.render.NoRender;
+import com.lambda.module.modules.render.Zoom;
 import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import com.llamalad7.mixinextras.injector.ModifyReturnValue;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import net.minecraft.client.render.Camera;
@@ -73,4 +75,9 @@ private float modifyMax(float original) {
     private void injectShowFloatingItem(ItemStack floatingItem, CallbackInfo ci) {
         if (NoRender.INSTANCE.isEnabled() && NoRender.getNoFloatingItemAnimation()) ci.cancel();
     }
+
+    @ModifyReturnValue(method = "getFov", at = @At("RETURN"))
+    private float modifyGetFov(float original) {
+        return original / Zoom.getCurrentZoom();
+    }
 }

src/main/kotlin/com/lambda/gui/components/SettingsWidget.kt

@@ -32,6 +32,7 @@ object SettingsWidget {
         group {
             if (config is Module) {
                 with(config.keybindSetting) { buildLayout() }
+                with(config.disableOnReleaseSetting) { buildLayout() }
             }
             sameLine()
             smallButton("Reset") {
@@ -40,7 +41,7 @@ object SettingsWidget {
             lambdaTooltip("Resets all settings for this module to their default values")
         }
         separator()
-        val toIgnoreSettings = if (config is Module) setOf(config.keybindSetting) else emptySet()
+        val toIgnoreSettings = if (config is Module) setOf(config.keybindSetting, config.disableOnReleaseSetting) else emptySet()
         val visibleSettings = config.settings.filter { it.visibility() } - toIgnoreSettings
         val (grouped, ungrouped) = visibleSettings.partition { it.groups.isNotEmpty() }
         ungrouped.forEach { with(it) { buildLayout() } }

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

@@ -18,6 +18,7 @@
 package com.lambda.module
 
 import com.lambda.Lambda.mc
+import com.lambda.Lambda
 import com.lambda.command.LambdaCommand
 import com.lambda.config.AbstractSetting
 import com.lambda.config.Configurable
@@ -40,6 +41,7 @@ import com.lambda.sound.SoundManager.play
 import com.lambda.util.KeyCode
 import com.lambda.util.Mouse
 import com.lambda.util.Nameable
+import javax.swing.ActionMap
 
 /**
  * A [Module] is a feature or tool for the utility mod.
@@ -120,26 +122,28 @@ abstract class Module(
 ) : Nameable, Muteable, Configurable(ModuleConfig) {
     private val isEnabledSetting = setting("Enabled", enabledByDefault) { false }
     val keybindSetting = setting("Keybind", defaultKeybind) { false }
+    val disableOnReleaseSetting = setting("Disable On Release", false) { false }
 
     open val isVisible: Boolean = true
 
     var isEnabled by isEnabledSetting
     val isDisabled get() = !isEnabled
 
-    var keybind by keybindSetting
+    val keybind by keybindSetting
+    val disableOnRelease by disableOnReleaseSetting
 
     override val isMuted: Boolean
         get() = !isEnabled && !alwaysListening
 
     init {
         listen<KeyboardEvent.Press>(alwaysListen = true) { event ->
-            if (event.isPressed)
-                onButtonPress(event.keyCode)
+            onButtonPress(event.keyCode, event.isPressed, event.isReleased)
         }
 
         listen<MouseEvent.Click>(alwaysListen = true) { event ->
-            if (event.action == Mouse.Action.Click.ordinal)
-                onButtonPress(event.button)
+            val pressed = event.action == Mouse.Action.Click.ordinal
+            val released = event.action == Mouse.Action.Release.ordinal
+            onButtonPress(event.button, pressed, released, mouseButton = true)
         }
 
         onEnable { LambdaSound.MODULE_ON.play() }
@@ -153,7 +157,7 @@ abstract class Module(
         listen<ConnectionEvent.Disconnect> { if (autoDisable) disable() }
     }
 
-    private fun onButtonPress(code: Int, mouseButton: Boolean = false) {
+    private fun onButtonPress(code: Int, pressed: Boolean, released: Boolean, mouseButton: Boolean = false) {
         if (mc.options.commandKey.isPressed) return
         if (mc.currentScreen != null) return
         if (keybind.code == KeyCode.UNBOUND.code) return

src/main/kotlin/com/lambda/module/modules/player/RotationLock.kt

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lambda.module.modules.player
+
+import com.lambda.config.groups.RotationSettings
+import com.lambda.event.events.TickEvent
+import com.lambda.event.listener.SafeListener.Companion.listen
+import com.lambda.interaction.request.rotating.Rotation
+import com.lambda.interaction.request.rotating.RotationRequest
+import com.lambda.interaction.request.rotating.visibilty.lookAt
+import com.lambda.module.Module
+import com.lambda.module.tag.ModuleTag
+import com.lambda.util.NamedEnum
+import kotlin.math.roundToInt
+
+object RotationLock : Module(
+    name = "RotationLock",
+    description = "Locks the player rotation to the given configuration",
+    tag = ModuleTag.PLAYER,
+) {
+    private enum class Group(override val displayName: String) : NamedEnum {
+        General("General"),
+        Rotation("Rotation")
+    }
+
+    @JvmStatic val yawMode by setting("Yaw Mode", RotationMode.Snap).group(Group.General)
+    private val yawStep by setting("Yaw Step", 45.0, 1.0..180.0, 1.0) { yawMode == RotationMode.Snap }.group(Group.General)
+    private val customYaw by setting("Custom Yaw", 0.0, -179.0..180.0, 1.0) { yawMode == RotationMode.Custom }.group(Group.General)
+    @JvmStatic val pitchMode by setting("Pitch Mode", RotationMode.Custom).group(Group.General)
+    private val pitchStep by setting("Pitch Step", 45.0, 1.0..90.0, 1.0) { pitchMode == RotationMode.Snap }.group(Group.General)
+    private val customPitch by setting("Custom Pitch", 0.0, -90.0..90.0, 1.0) { pitchMode == RotationMode.Custom }.group(Group.General)
+
+    @JvmStatic val rotationSettings = RotationSettings(this, Group.Rotation)
+    private var rotationRequest: RotationRequest? = null
+
+    init {
+        listen<TickEvent.Pre> {
+            val yaw = when (yawMode) {
+                RotationMode.Custom -> customYaw
+                RotationMode.Snap -> {
+                    val normalizedYaw = (player.yaw % 360.0 + 360.0) % 360.0
+                    (normalizedYaw / yawStep).roundToInt() * yawStep
+                }
+                RotationMode.None -> player.yaw.toDouble()
+            }
+            val pitch = when (pitchMode) {
+                RotationMode.Custom -> customPitch
+                RotationMode.Snap -> {
+                    val clampedPitch = player.pitch.coerceIn(-90f, 90f)
+                    (clampedPitch / pitchStep).roundToInt() * pitchStep
+                }
+                RotationMode.None -> player.pitch.toDouble()
+            }
+
+            RotationRequest(lookAt(Rotation(yaw, pitch), 0.001), rotationSettings).submit()
+        }
+    }
+
+    enum class RotationMode {
+        Snap,
+        Custom,
+        None
+    }
+}

src/main/kotlin/com/lambda/module/modules/render/Zoom.kt

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lambda.module.modules.render
+
+import com.lambda.event.events.MouseEvent
+import com.lambda.event.events.RenderEvent
+import com.lambda.event.listener.SafeListener.Companion.listen
+import com.lambda.module.Module
+import com.lambda.module.tag.ModuleTag
+import com.lambda.util.NamedEnum
+import java.lang.Math.clamp
+
+object Zoom : Module(
+    name = "Zoom",
+    description = "Zooms the current view",
+    tag = ModuleTag.RENDER,
+) {
+    private var zoom by setting("Zoom", 2f, 1f..10f, 0.1f)
+    private val style by setting("Style", ZoomStyle.EaseOut)
+    private val animationDuration by setting("Animation Duration", 1f, 0.1f..10f, 0.1f) { style != ZoomStyle.Instant }
+    private val scroll by setting("Scroll", true)
+    private val persistentScroll by setting("Persistent Scroll", false) { scroll }
+    private val sensitivity by setting("Sensitivity", 0.2f, 0.1f..1f, 0.1f) { scroll }
+    @JvmStatic val smoothMovement by setting("Smooth Movement", false)
+
+    private var extraZoom = 0f
+        set(value) {
+            field = value.coerceAtLeast(-zoom + 1)
+        }
+    @JvmStatic val targetZoom: Float
+        get() = zoom + extraZoom
+
+    @JvmStatic var currentZoom = 1f; private set
+    private var lastZoomTime = 1L
+    private val zoomProgress
+        get() = clamp((System.currentTimeMillis() - lastZoomTime) / (animationDuration * 1000).toDouble(), 0.0, 1.0).toFloat()
+
+    init {
+        listen<MouseEvent.Scroll> { event ->
+            val yDelta = event.delta.y.toFloat()
+            val delta = (yDelta * sensitivity) + (((zoom + extraZoom) * sensitivity) * yDelta)
+            if (persistentScroll) zoom += delta
+            else extraZoom += delta
+            updateZoomTime()
+            event.cancel()
+        }
+
+        listen<RenderEvent.Render>(alwaysListen = true) {
+            updateCurrentZoom()
+        }
+
+        onEnable {
+            updateZoomTime()
+        }
+
+        onDisable {
+            extraZoom = 0f
+            updateZoomTime()
+        }
+    }
+
+    private fun updateZoomTime() {
+        lastZoomTime = System.currentTimeMillis()
+    }
+
+    @JvmStatic
+    fun updateCurrentZoom() {
+        val target = if (isEnabled) targetZoom else 1f
+        currentZoom = style.apply(currentZoom, target, zoomProgress)
+    }
+
+    private enum class ZoomStyle(
+        override val displayName: String,
+        val apply: (Float, Float, Float) -> Float,
+    ) : NamedEnum {
+        Instant("Instant", { _, v, _ -> v }),
+        EaseOut("Ease Out", { start, end, progress -> start + ((end - start) * (1f - ((1f - progress) * (1f - progress)))) }),
+        EaseIn("Ease In", { start, end, progress -> start + ((end - start) * (progress * progress)) })
+    }
+}