Merge branch '1.21.5' into feature/manager-loggers

# Conflicts:
#	src/main/kotlin/com/lambda/gui/components/HudGuiLayout.kt
#	src/main/kotlin/com/lambda/interaction/construction/context/BreakContext.kt
#	src/main/kotlin/com/lambda/interaction/request/breaking/BreakManager.kt
#	src/main/kotlin/com/lambda/interaction/request/placing/PlaceManager.kt

Author: beanbag44

src/main/java/com/lambda/mixin/MinecraftClientMixin.java

@@ -17,13 +17,13 @@
 
 package com.lambda.mixin;
 
-import com.lambda.Lambda;
 import com.lambda.event.EventFlow;
 import com.lambda.event.events.ClientEvent;
 import com.lambda.event.events.InventoryEvent;
 import com.lambda.event.events.TickEvent;
 import com.lambda.gui.DearImGui;
 import com.lambda.module.modules.player.Interact;
+import com.lambda.module.modules.player.InventoryMove;
 import com.lambda.module.modules.player.PacketMine;
 import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
@@ -33,6 +33,7 @@
 import net.minecraft.client.gui.screen.ingame.ScreenHandlerProvider;
 import net.minecraft.client.network.ClientPlayerEntity;
 import net.minecraft.client.network.ClientPlayerInteractionManager;
+import net.minecraft.client.option.KeyBinding;
 import net.minecraft.client.render.WorldRenderer;
 import net.minecraft.client.sound.SoundManager;
 import net.minecraft.util.Hand;
@@ -51,10 +52,14 @@ public class MinecraftClientMixin {
     @Shadow
     @Nullable
     public Screen currentScreen;
+
     @Shadow
     @Nullable
     public HitResult crosshairTarget;
 
+    @Shadow
+    public int itemUseCooldown;
+
     @Inject(method = "close", at = @At("HEAD"))
     void closeImGui(CallbackInfo ci) {
         DearImGui.INSTANCE.destroy();
@@ -131,6 +136,19 @@ private void onScreenRemove(@Nullable Screen screen, CallbackInfo ci) {
         }
     }
 
+    @Redirect(method = "setScreen", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/option/KeyBinding;unpressAll()V"))
+    private void redirectUnPressAll() {
+        if (!InventoryMove.getShouldMove()) {
+            KeyBinding.unpressAll();
+            return;
+        }
+        KeyBinding.KEYS_BY_ID.values().forEach(bind -> {
+            if (!InventoryMove.isKeyMovementRelated(bind.boundKey.getCode())) {
+                bind.reset();
+            }
+        });
+    }
+
     @Redirect(method = "doAttack()Z", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/network/ClientPlayerEntity;swingHand(Lnet/minecraft/util/Hand;)V"))
     private void redirectHandSwing(ClientPlayerEntity instance, Hand hand) {
         if (this.crosshairTarget == null) return;
@@ -151,6 +169,6 @@ boolean redirectMultiActon(ClientPlayerInteractionManager instance) {
     void injectFastPlace(CallbackInfo ci) {
         if (!Interact.INSTANCE.isEnabled()) return;
 
-        Lambda.getMc().itemUseCooldown = Interact.getPlaceDelay();
+        itemUseCooldown = Interact.getPlaceDelay();
     }
 }

src/main/java/com/lambda/mixin/baritone/MixinLookBehavior.java

@@ -36,7 +36,7 @@ void onTargetUpdate(Rotation rotation, boolean blockInteract, CallbackInfo ci) {
         LookBehavior instance = ((LookBehavior) (Object) this);
         if (instance.baritone != BaritoneUtils.getPrimary()) return;
 
-        RotationManager.BaritoneProcessor.handleBaritoneRotation(rotation.getYaw(), rotation.getPitch());
+        RotationManager.handleBaritoneRotation(rotation.getYaw(), rotation.getPitch());
         ci.cancel();
     }
 

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

@@ -37,7 +37,6 @@
 import net.minecraft.client.world.ClientWorld;
 import net.minecraft.entity.MovementType;
 import net.minecraft.util.Hand;
-import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.math.Vec3d;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
@@ -60,80 +59,50 @@ public ClientPlayerEntityMixin(ClientWorld world, GameProfile profile) {
         super(world, profile);
     }
 
-    @Shadow protected abstract void autoJump(float dx, float dz);
-
-    /**
-     * Post movement events and applies the modified player velocity
-     */
-    @Inject(method = "move", at = @At("HEAD"), cancellable = true)
-    void onMove(MovementType movementType, Vec3d movement, CallbackInfo ci) {
-        ClientPlayerEntity self = (ClientPlayerEntity) (Object) this;
-        if (self != Lambda.getMc().player) return;
-
-        ci.cancel();
-
-        float prevX = (float) self.getX();
-        float prevZ = (float) self.getZ();
-
+    @Redirect(method = "move", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/network/AbstractClientPlayerEntity;move(Lnet/minecraft/entity/MovementType;Lnet/minecraft/util/math/Vec3d;)V"))
+    private void emitMovementEvents(AbstractClientPlayerEntity instance, MovementType movementType, Vec3d movement) {
         EventFlow.post(new MovementEvent.Player.Pre(movementType, movement));
         super.move(movementType, movement);
         EventFlow.post(new MovementEvent.Player.Post(movementType, movement));
-
-        float deltaX = (float) self.getX() - prevX;
-        float deltaZ = (float) self.getZ() - prevZ;
-
-        this.autoJump(deltaX, deltaZ);
-        this.distanceMoved = this.distanceMoved + MathHelper.hypot(deltaX, deltaZ) * 0.6F;
     }
 
     @Redirect(method = "tickMovement", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/input/Input;tick()V"))
     void processMovement(Input input) {
         input.tick();
         RotationManager.processRotations();
-        RotationManager.BaritoneProcessor.processPlayerMovement(input);
+        RotationManager.redirectStrafeInputs(input);
         EventFlow.post(new MovementEvent.InputUpdate(input));
     }
 
     /**
-     * Posts the {@link MovementEvent.Sprint} event
-     * <pre>{@code
-     * if (this.isSprinting()) {
-     *     boolean bl8 = !this.input.hasForwardMovement() || !this.canSprint();
-     *     boolean bl9 = bl8 || this.horizontalCollision && !this.collidedSoftly || this.isTouchingWater() && !this.isSubmergedInWater();
-     *     if (this.isSwimming()) {
-     *         if (!this.isOnGround() && !this.input.sneaking && bl8 || !this.isTouchingWater()) {
-     *             this.setSprinting(false);
-     *         }
-     *     } else if (bl9) {
-     *         this.setSprinting(false);
-     *     }
-     * }
-     * }</pre>
+     * Overwrites the movement packet update function to use our code
      */
+    @Inject(method = "sendMovementPackets", at = @At(value = "HEAD"), cancellable = true)
+    void sendLambdaMovement(CallbackInfo ci) {
+        ci.cancel();
+        PlayerPacketManager.sendPlayerPackets();
+        autoJumpEnabled = Lambda.getMc().options.getAutoJump().getValue();
+    }
+
+    @Redirect(method = "tick", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/network/ClientPlayerEntity;sendSneakingPacket()V"))
+    void sendSneakingPacket(ClientPlayerEntity entity) {
+        PlayerPacketManager.sendSneakPackets();
+    }
+
     @Redirect(method = "tickMovement", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/network/ClientPlayerEntity;isSprinting()Z"))
     boolean isSprinting(ClientPlayerEntity entity) {
         return EventFlow.post(new MovementEvent.Sprint(entity.isSprinting())).getSprint();
     }
 
     @Inject(method = "isSneaking", at = @At(value = "HEAD"), cancellable = true)
-    void redirectSneaking(CallbackInfoReturnable<Boolean> cir) {
+    void injectSneakingInput(CallbackInfoReturnable<Boolean> cir) {
         ClientPlayerEntity self = (ClientPlayerEntity) (Object) this;
         if (self != Lambda.getMc().player) return;
 
         if (self.input == null) return;
         cir.setReturnValue(EventFlow.post(new MovementEvent.Sneak(self.input.playerInput.sneak())).getSneak());
     }
 
-    /**
-     * Overwrites the movement packet update function to use our code
-     */
-    @Inject(method = "sendMovementPackets", at = @At(value = "HEAD"), cancellable = true)
-    void sendBegin(CallbackInfo ci) {
-        ci.cancel();
-        PlayerPacketManager.sendPlayerPackets();
-        autoJumpEnabled = Lambda.getMc().options.getAutoJump().getValue();
-    }
-
     @WrapMethod(method = "tick")
     void onTick(Operation<Void> original) {
         EventFlow.post(TickEvent.Player.Pre.INSTANCE);

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

@@ -19,7 +19,10 @@
 
 import com.lambda.event.EventFlow;
 import com.lambda.event.events.KeyboardEvent;
+import com.lambda.module.modules.player.InventoryMove;
 import net.minecraft.client.Keyboard;
+import net.minecraft.client.option.KeyBinding;
+import net.minecraft.client.util.InputUtil;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -32,6 +35,13 @@ private void onKey(long window, int key, int scancode, int action, int modifiers
         EventFlow.post(new KeyboardEvent.Press(key, scancode, action, modifiers));
     }
 
+    @Inject(method = "onKey", at = @At("RETURN"))
+    private void onKeyTail(long window, int key, int scancode, int action, int modifiers, CallbackInfo ci) {
+        if (!InventoryMove.getShouldMove() || !InventoryMove.isKeyMovementRelated(key)) return;
+        InputUtil.Key fromCode = InputUtil.fromKeyCode(key, scancode);
+        KeyBinding.setKeyPressed(fromCode, action != 0);
+    }
+
     @Inject(method = "onChar", at = @At("HEAD"))
     private void onChar(long window, int codePoint, int modifiers, CallbackInfo ci) {
         char[] chars = Character.toChars(codePoint);

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

@@ -23,10 +23,11 @@
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import net.minecraft.client.render.entity.LivingEntityRenderer;
 import net.minecraft.entity.LivingEntity;
+import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 
-import java.util.Objects;
+import static com.lambda.util.math.LinearKt.lerp;
 
 // This mixin's purpose is to set the player's pitch the current render pitch to correctly show the rotation
 // regardless of the camera position
@@ -48,9 +49,12 @@ public class LivingEntityRendererMixin {
      * }</pre>
      */
     @WrapOperation(method = "updateRenderState(Lnet/minecraft/entity/LivingEntity;Lnet/minecraft/client/render/entity/state/LivingEntityRenderState;F)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/LivingEntity;getLerpedPitch(F)F"))
-    private float wrapGetLerpedPitch(LivingEntity instance, float v, Operation<Float> original) {
-        return (instance == Lambda.getMc().player)
-                ? Objects.requireNonNullElse(RotationManager.getHeadPitch(), original.call(instance, v))
-                : original.call(instance, v);
+    private float wrapGetLerpedPitch(LivingEntity livingEntity, float v, Operation<Float> original) {
+        Float headPitch = RotationManager.getHeadPitch();
+        if (livingEntity != Lambda.getMc().player || headPitch == null) {
+            return original.call(livingEntity, v);
+        }
+
+        return lerp(v, RotationManager.getPrevServerRotation().getPitchF(), headPitch);
     }
 }

src/main/kotlin/com/lambda/config/AbstractSetting.kt

@@ -158,6 +158,10 @@ abstract class AbstractSetting<T : Any>(
         groups.add(path.toList())
     }
 
+    fun group(path: NamedEnum?) = apply {
+        path?.let { groups.add(listOf(it)) }
+    }
+
     fun reset(silent: Boolean = false) {
         if (!silent && value == defaultValue) {
             ConfigCommand.info(notChangedMessage())

src/main/kotlin/com/lambda/config/groups/RotationSettings.kt

@@ -30,7 +30,7 @@ import kotlin.random.Random
 
 class RotationSettings(
     c: Configurable,
-    baseGroup: NamedEnum,
+    baseGroup: NamedEnum? = null,
     vis: () -> Boolean = { true }
 ) : RotationConfig {
     override var rotationMode by c.setting("Mode", RotationMode.Sync, "How the player is being rotated on interaction", vis).group(baseGroup)

src/main/kotlin/com/lambda/config/groups/Targeting.kt

@@ -60,33 +60,33 @@ abstract class Targeting(
      * The range within which entities can be targeted. This value is configurable and constrained
      * between 1.0 and [maxRange].
      */
-    override val targetingRange by owner.setting("Targeting Range", defaultRange, 1.0..maxRange, 0.05) { predicate() }
+    override val targetingRange by owner.setting("Targeting Range", defaultRange, 1.0..maxRange, 0.05) { predicate() }.group(baseGroup)
 
     /**
      * Whether players are included in the targeting scope.
      */
-    override val players by owner.setting("Players", true) { predicate() }
+    override val players by owner.setting("Players", true) { predicate() }.group(baseGroup)
 
     /**
      * Whether friends are included in the targeting scope.
      * Requires [players] to be true.
      */
-    override val friends by owner.setting("Friends", false) { predicate() && players }
+    override val friends by owner.setting("Friends", false) { predicate() && players }.group(baseGroup)
 
     /**
      * Whether mobs are included in the targeting scope.
      */
-    private val mobs by owner.setting("Mobs", true) { predicate() }
+    private val mobs by owner.setting("Mobs", true) { predicate() }.group(baseGroup)
 
     /**
      * Whether hostile mobs are included in the targeting scope
      */
-    private val hostilesSetting by owner.setting("Hostiles", true) { predicate() && mobs }
+    private val hostilesSetting by owner.setting("Hostiles", true) { predicate() && mobs }.group(baseGroup)
 
     /**
      * Whether passive animals are included in the targeting scope
      */
-    private val animalsSetting by owner.setting("Animals", true) { predicate() && mobs }
+    private val animalsSetting by owner.setting("Animals", true) { predicate() && mobs }.group(baseGroup)
 
     /**
      * Indicates whether hostile entities are included in the targeting scope.
@@ -101,12 +101,12 @@ abstract class Targeting(
     /**
      * Whether invisible entities are included in the targeting scope.
      */
-    override val invisible by owner.setting("Invisible", true) { predicate() }
+    override val invisible by owner.setting("Invisible", true) { predicate() }.group(baseGroup)
 
     /**
      * Whether dead entities are included in the targeting scope.
      */
-    override val dead by owner.setting("Dead", false) { predicate() }
+    override val dead by owner.setting("Dead", false) { predicate() }.group(baseGroup)
 
     /**
      * Validates whether a given entity is targetable by the player based on current settings.
@@ -144,7 +144,7 @@ abstract class Targeting(
         /**
          * The field of view limit for targeting entities. Configurable between 5 and 180 degrees.
          */
-        val fov by owner.setting("FOV Limit", 180, 5..180, 1) { predicate() }.group(baseGroup)
+        val fov by owner.setting("FOV Limit", 180, 5..180, 1) { predicate() && priority == Priority.FOV }.group(baseGroup)
 
         /**
          * The priority used to determine which entity is targeted. Configurable with default set to [Priority.DISTANCE].

src/main/kotlin/com/lambda/event/events/PlayerPacketEvent.kt

@@ -30,7 +30,6 @@ sealed class PlayerPacketEvent {
         var rotation: Rotation,
         var onGround: Boolean,
         var isSprinting: Boolean,
-        var isSneaking: Boolean,
         var isCollidingHorizontally: Boolean,
     ) : ICancellable by Cancellable()
 

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

@@ -17,22 +17,22 @@
 
 package com.lambda.event.events
 
+import com.lambda.context.SafeContext
 import com.lambda.event.Event
 import com.lambda.event.callback.Cancellable
 import com.lambda.event.callback.ICancellable
-import com.lambda.graphics.renderer.esp.global.DynamicESP
-import com.lambda.graphics.renderer.esp.global.StaticESP
+import com.lambda.event.listener.SafeListener.Companion.listen
+import com.lambda.graphics.renderer.esp.ShapeBuilder
+import com.lambda.graphics.renderer.esp.Treed
 
-sealed class RenderEvent {
-    class World : Event
-
-    class StaticESP : Event {
-        val renderer = StaticESP
-    }
+fun Any.onStaticRender(block: SafeContext.(ShapeBuilder) -> Unit) =
+    listen<RenderEvent.Upload> { block(ShapeBuilder(Treed.Static.faceBuilder, Treed.Static.edgeBuilder)) }
+fun Any.onDynamicRender(block: SafeContext.(ShapeBuilder) -> Unit) =
+    listen<RenderEvent.Upload> { block(ShapeBuilder(Treed.Dynamic.faceBuilder, Treed.Dynamic.edgeBuilder)) }
 
-    class DynamicESP : Event {
-        val renderer = DynamicESP
-    }
+sealed class RenderEvent {
+    object Upload : Event
+    object Render : Event
 
     class UpdateTarget : ICancellable by Cancellable()
 }