Merge branch '1.21.5' into feature/manager-loggers

beanbag44 · beanbag44 · commit fb96e627b4ef · 2025-08-24T14:00:31.000+01:00
diff --git a/src/main/java/com/lambda/mixin/items/BarrierBlockMixin.java b/src/main/java/com/lambda/mixin/items/BarrierBlockMixin.java
@@ -21,6 +21,7 @@
 import net.minecraft.block.BarrierBlock;
 import net.minecraft.block.BlockRenderType;
 import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -33,10 +34,9 @@ public class BarrierBlockMixin {
      */
     @Inject(method = "getRenderType", at = @At("RETURN"), cancellable = true)
     private void getRenderType(BlockState state, CallbackInfoReturnable<BlockRenderType> cir) {
-        // FixMe: This mixins fucks up the loading process by calling the configurations too early and doesn't load the settings
-        /*if (BlockESP.INSTANCE.isEnabled()
+        if (BlockESP.INSTANCE.isEnabled()
                 && BlockESP.getBarrier()
                 && state.getBlock() == Blocks.BARRIER
-        ) cir.setReturnValue(BlockRenderType.MODEL);*/
+        ) cir.setReturnValue(BlockRenderType.MODEL);
     }
 }
diff --git a/src/main/java/com/lambda/mixin/network/ClientConnectionMixin.java b/src/main/java/com/lambda/mixin/network/ClientConnectionMixin.java
@@ -34,6 +34,7 @@
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@@ -62,7 +63,7 @@ private void sendingPacketPost(Packet<?> packet, final CallbackInfo callbackInfo
         EventFlow.post(new PacketEvent.Send.Post((Packet<? extends ServerPlayPacketListener>) packet));
     }
 
-    @SuppressWarnings("all")
+    @SuppressWarnings("unchecked")
     @Inject(method = "channelRead0(Lio/netty/channel/ChannelHandlerContext;Lnet/minecraft/network/packet/Packet;)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/network/ClientConnection;handlePacket(Lnet/minecraft/network/packet/Packet;Lnet/minecraft/network/listener/PacketListener;)V", shift = At.Shift.BEFORE), cancellable = true, require = 1)
     private void receivingPacket(
             ChannelHandlerContext channelHandlerContext,
diff --git a/src/main/java/com/lambda/mixin/render/BackgroundRendererMixin.java b/src/main/java/com/lambda/mixin/render/BackgroundRendererMixin.java
@@ -20,6 +20,7 @@
 import com.lambda.module.modules.render.WorldColors;
 import net.minecraft.client.render.BackgroundRenderer;
 import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.biome.Biome;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Redirect;
@@ -40,16 +41,22 @@
 public class BackgroundRendererMixin {
     @Redirect(method = "getFogColor", at = @At(value = "INVOKE", target = "Lnet/minecraft/util/math/Vec3d;getX()D"))
     private static double redirectRed(Vec3d baseColor) {
-        return WorldColors.backgroundColor(baseColor).getX();
+        return WorldColors.fogOfWarColor(baseColor).getX();
     }
 
     @Redirect(method = "getFogColor", at = @At(value = "INVOKE", target = "Lnet/minecraft/util/math/Vec3d;getY()D"))
     private static double redirectGreen(Vec3d baseColor) {
-        return WorldColors.backgroundColor(baseColor).getY();
+        return WorldColors.fogOfWarColor(baseColor).getY();
     }
 
     @Redirect(method = "getFogColor", at = @At(value = "INVOKE", target = "Lnet/minecraft/util/math/Vec3d;getZ()D"))
     private static double redirectBlue(Vec3d baseColor) {
-        return WorldColors.backgroundColor(baseColor).getZ();
+        return WorldColors.fogOfWarColor(baseColor).getZ();
     }
+
+    @Redirect(method = "getFogColor", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/biome/Biome;getWaterFogColor()I"))
+    private static int redirectWaterFogColor(Biome biome) {
+        return WorldColors.waterFogColor(biome.getWaterFogColor());
+    }
+
 }
diff --git a/src/main/java/com/lambda/mixin/render/LivingEntityRendererMixin.java b/src/main/java/com/lambda/mixin/render/LivingEntityRendererMixin.java
@@ -17,9 +17,12 @@
 
 package com.lambda.mixin.render;
 
+import com.lambda.Lambda;
 import com.lambda.interaction.request.rotating.RotationManager;
-import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import net.minecraft.client.render.entity.LivingEntityRenderer;
+import net.minecraft.entity.LivingEntity;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 
@@ -44,8 +47,10 @@ public class LivingEntityRendererMixin {
      * }
      * }</pre>
      */
-    @ModifyExpressionValue(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 injectRotationPitch(float original) {
-        return Objects.requireNonNullElse(RotationManager.getHeadPitch(), original);
+    @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);
     }
 }
diff --git a/src/main/java/com/lambda/mixin/render/RenderSystemMixin.java b/src/main/java/com/lambda/mixin/render/RenderSystemMixin.java
diff --git a/src/main/java/com/lambda/mixin/world/ClientWorldMixin.java b/src/main/java/com/lambda/mixin/world/ClientWorldMixin.java
@@ -48,19 +48,22 @@ private void onRemoveEntity(int entityId, Entity.RemovalReason removalReason, Ca
     }
 
     @Inject(method = "getCloudsColor", at = @At("HEAD"), cancellable = true)
-    private void getCloudsColorInject(float tickDelta, CallbackInfoReturnable<Vec3d> cir) {
+    private void getCloudsColorInject(float tickDelta, CallbackInfoReturnable<Integer> cir) {
         if (WorldColors.INSTANCE.isEnabled() && WorldColors.getCustomClouds()) {
-            cir.setReturnValue(ColorKt.getVec3d(WorldColors.getCloudColor()));
+            int rgb = WorldColors.getCloudColor().getRGB() & 0xFFFFFF;
+            cir.setReturnValue(rgb);
         }
     }
 
     @Inject(method = "getSkyColor", at = @At("HEAD"), cancellable = true)
-    private void getSkyColorInject(Vec3d cameraPos, float tickDelta, CallbackInfoReturnable<Vec3d> cir) {
+    private void getSkyColorInject(Vec3d cameraPos, float tickDelta, CallbackInfoReturnable<Integer> cir) {
         if (WorldColors.INSTANCE.isEnabled() && WorldColors.getCustomSky()) {
-            cir.setReturnValue(ColorKt.getVec3d(WorldColors.getSkyColor()));
+            int rgb = WorldColors.getSkyColor().getRGB() & 0xFFFFFF;
+            cir.setReturnValue(rgb);
         }
     }
 
+
     @Inject(method = "handleBlockUpdate", at = @At("HEAD"), cancellable = true)
     private void handleBlockUpdateInject(BlockPos pos, BlockState newState, int flags, CallbackInfo ci) {
         if (EventFlow.post(new WorldEvent.BlockUpdate.Server(pos, newState)).isCanceled()) ci.cancel();
diff --git a/src/main/kotlin/com/lambda/config/Configuration.kt b/src/main/kotlin/com/lambda/config/Configuration.kt
@@ -63,26 +63,6 @@ abstract class Configuration : Jsonable {
         get() = File("${primary.parent}/${primary.nameWithoutExtension}-backup.${primary.extension}")
 
     init {
-        // We need to implement a dependency graph of loadables and add functions to run before
-        // and/or after a given Loadable children class is initialized
-        //
-        // class Load1(
-        //     override val priority = 1000,
-        //     override val before = Load2,
-        // ) : Loadable {}
-        //
-        // class Load2(
-        //     override val priority = 1000,
-        // ) : Loadable {}
-        //
-        // class Load3(
-        //     override val priority = 1000,
-        //     override val after = Load2,
-        // ) : Loadable {}
-        //
-        // clientLifecycle<Load2>(shift = Pre) { event -> } // Will run before Load2
-        // clientLifecycle<Load2>(shift = Post) { event -> } // Will run after Load2
-        listenUnsafe<ClientEvent.Startup> { tryLoad() }
         listenUnsafe<ClientEvent.Shutdown>(Int.MIN_VALUE) { trySave() }
 
         register()
diff --git a/src/main/kotlin/com/lambda/config/configurations/ConfigLoader.kt b/src/main/kotlin/com/lambda/config/configurations/ConfigLoader.kt
@@ -18,10 +18,13 @@
 package com.lambda.config.configurations
 
 import com.lambda.config.Configuration
-import com.lambda.util.FolderRegister
-import java.io.File
+import com.lambda.core.Loadable
 
-object UserConfig : Configuration() {
-    override val configName get() = "preferences"
-    override val primary: File = FolderRegister.config.resolve("$configName.json").toFile()
-}
+object ConfigLoader: Loadable {
+    override fun load(): String {
+        Configuration.configurations.forEach {
+            it.tryLoad()
+        }
+        return "Loading ${Configuration.configurations.size} configurations"
+    }
+}
diff --git a/src/main/kotlin/com/lambda/interaction/request/breaking/SwapInfo.kt b/src/main/kotlin/com/lambda/interaction/request/breaking/SwapInfo.kt
@@ -66,7 +66,7 @@ data class SwapInfo(
             val minKeepTicks = run {
                 if (type == Primary) {
                     val swapTickProgress = breakDelta * (breakTicks + breakConfig.serverSwapTicks - 1)
-                    if (swapTickProgress >= threshold) 1
+                    if (swapTickProgress >= threshold && swapStack.heldTicks < breakConfig.serverSwapTicks) 1
                     else 0
                 } else {
                     val serverSwapTicks = breakConfig.serverSwapTicks.coerceAtLeast(3)
diff --git a/src/main/kotlin/com/lambda/module/modules/player/Freecam.kt b/src/main/kotlin/com/lambda/module/modules/player/Freecam.kt
@@ -64,7 +64,10 @@ object Freecam : Module(
     private var prevPosition: Vec3d = Vec3d.ZERO
     private var position: Vec3d = Vec3d.ZERO
     private val lerpPos: Vec3d
-        get() = prevPosition.interpolate(mc.partialTicks, position)
+        get() {
+            val tickProgress = mc.gameRenderer.camera.lastTickProgress
+            return prevPosition.interpolate(tickProgress, position)
+        }
 
     private var rotation: Rotation = Rotation.ZERO
     private var velocity: Vec3d = Vec3d.ZERO
diff --git a/src/main/kotlin/com/lambda/module/modules/render/BlockESP.kt b/src/main/kotlin/com/lambda/module/modules/render/BlockESP.kt
@@ -43,20 +43,21 @@ object BlockESP : Module(
     description = "Render block ESP",
     tag = ModuleTag.RENDER,
 ) {
-    private var drawFaces: Boolean by setting("Draw Faces", true, "Draw faces of blocks").onValueSet(::rebuildMesh).onValueSet { _, to -> if (!to) drawOutlines = true }
-    private var drawOutlines: Boolean by setting("Draw Outlines", true, "Draw outlines of blocks").onValueSet(::rebuildMesh).onValueSet { _, to -> if (!to) drawFaces = true }
-    private val mesh by setting("Mesh", true, "Connect similar adjacent blocks").onValueSet(::rebuildMesh)
+    // ToDo: Toggle searching, solve memory leak
+    private val searchBlocks by setting("Search Blocks", true, "Search for blocks around the player")
+    private val blocks by setting("Blocks", setOf(Blocks.BEDROCK), setOf(Blocks.BEDROCK), "Render blocks") { searchBlocks }.onValueSet(::rebuildMesh)
+    private var drawFaces: Boolean by setting("Draw Faces", true, "Draw faces of blocks") { searchBlocks }.onValueSet(::rebuildMesh).onValueSet { _, to -> if (!to) drawOutlines = true }
+    private var drawOutlines: Boolean by setting("Draw Outlines", true, "Draw outlines of blocks") { searchBlocks }.onValueSet(::rebuildMesh).onValueSet { _, to -> if (!to) drawFaces = true }
+    private val mesh by setting("Mesh", true, "Connect similar adjacent blocks") { searchBlocks }.onValueSet(::rebuildMesh)
 
-    private val useBlockColor by setting("Use Block Color", false, "Use the color of the block instead").onValueSet(::rebuildMesh)
-    private val faceColor by setting("Face Color", Color(100, 150, 255, 51), "Color of the surfaces") { drawFaces && !useBlockColor }.onValueSet(::rebuildMesh)
-    private val outlineColor by setting("Outline Color", Color(100, 150, 255, 128), "Color of the outlines") { drawOutlines && !useBlockColor }.onValueSet(::rebuildMesh)
+    private val useBlockColor by setting("Use Block Color", false, "Use the color of the block instead") { searchBlocks }.onValueSet(::rebuildMesh)
+    private val faceColor by setting("Face Color", Color(100, 150, 255, 51), "Color of the surfaces") { searchBlocks && drawFaces && !useBlockColor }.onValueSet(::rebuildMesh)
+    private val outlineColor by setting("Outline Color", Color(100, 150, 255, 128), "Color of the outlines") { searchBlocks && drawOutlines && !useBlockColor }.onValueSet(::rebuildMesh)
 
-    private val outlineMode by setting("Outline Mode", DirectionMask.OutlineMode.AND, "Outline mode").onValueSet(::rebuildMesh)
-
-    private val blocks by setting("Blocks", setOf(Blocks.BEDROCK), setOf(Blocks.BEDROCK), "Render blocks").onValueSet(::rebuildMesh)
+    private val outlineMode by setting("Outline Mode", DirectionMask.OutlineMode.AND, "Outline mode") { searchBlocks }.onValueSet(::rebuildMesh)
 
     @JvmStatic
-    val barrier by setting("Solid Barrier Block", true, "Render barrier blocks")
+    val barrier by setting("Solid Barrier Block", true, "Render barrier blocks").onValueChange { _, _ -> mc.worldRenderer.reload() }
 
     // ToDo: I wanted to render this as a transparent / translucent block with a red tint.
     //  Like the red stained glass block without the texture sprite.
diff --git a/src/main/kotlin/com/lambda/module/modules/render/WorldColors.kt b/src/main/kotlin/com/lambda/module/modules/render/WorldColors.kt
@@ -25,7 +25,7 @@ import java.awt.Color
 
 object WorldColors : Module(
     name = "WorldColors",
-    description = "Changes the color of the sky",
+    description = "Changes the color of the sky, clouds and fog",
     tag = ModuleTag.RENDER,
 ) {
     @JvmStatic
@@ -35,10 +35,10 @@ object WorldColors : Module(
     val skyColor by setting("Sky Color", Color(255, 24, 75), "The color of your sky") { customSky }
 
     @JvmStatic
-    val customFog by setting("Custom Fog", false)
+    val customFogOfWar by setting("Custom Fog of War", false)
 
     @JvmStatic
-    val fogColor by setting("Fog Color", Color(255, 24, 75, 255), "The color of your fog") { customFog }
+    val fogOfWarColor by setting("Fog of War Color", Color(255, 24, 75, 255), "The color of your fog") { customFogOfWar }
 
     @JvmStatic
     val customClouds by setting("Custom Clouds", false)
@@ -47,6 +47,16 @@ object WorldColors : Module(
     val cloudColor by setting("Cloud Color", Color(255, 24, 75)) { customClouds }
 
     @JvmStatic
-    fun backgroundColor(base: Vec3d) =
-        if (customFog && isEnabled) fogColor.vec3d else base
+    val customWaterFog by setting("Custom Water Fog", true)
+
+    @JvmStatic
+    val waterFogColor by setting("Water Fog Color", Color(255, 24, 75, 255), "The color of your water fog") { customWaterFog }
+
+    @JvmStatic
+    fun fogOfWarColor(base: Vec3d) =
+        if (customFogOfWar && isEnabled) fogOfWarColor.vec3d else base
+
+    @JvmStatic
+    fun waterFogColor(base: Int): Int =
+        if (customWaterFog && isEnabled) this.waterFogColor.rgb else base
 }
diff --git a/src/main/kotlin/com/lambda/network/NetworkManager.kt b/src/main/kotlin/com/lambda/network/NetworkManager.kt
@@ -19,15 +19,15 @@ package com.lambda.network
 
 import com.lambda.Lambda.mc
 import com.lambda.config.Configurable
-import com.lambda.config.configurations.UserConfig
+import com.lambda.config.configurations.LambdaConfig
 import com.lambda.core.Loadable
 import com.lambda.network.api.v1.models.Authentication
 import com.lambda.network.api.v1.models.Authentication.Data
 import com.lambda.util.StringUtils.base64UrlDecode
 import com.lambda.util.StringUtils.json
 import com.lambda.util.collections.updatableLazy
 
-object NetworkManager : Configurable(UserConfig), Loadable {
+object NetworkManager : Configurable(LambdaConfig), Loadable {
     override val name = "network"
 
     var accessToken by setting("access_token", ""); private set
diff --git a/src/main/resources/lambda.mixins.common.json b/src/main/resources/lambda.mixins.common.json
@@ -46,7 +46,6 @@
     "render.LivingEntityRendererMixin",
     "render.PlayerListHudMixin",
     "render.RenderLayersMixin",
-    "render.RenderSystemMixin",
     "render.ScreenHandlerMixin",
     "render.SplashOverlayMixin",
     "render.SplashOverlayMixin$LogoTextureMixin",

Original file line number	Diff line number	Diff line change
`@@ -48,19 +48,22 @@ private void onRemoveEntity(int entityId, Entity.RemovalReason removalReason, Ca`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`@Inject(method = "getCloudsColor", at = @At("HEAD"), cancellable = true)`
`51`		`- private void getCloudsColorInject(float tickDelta, CallbackInfoReturnable<Vec3d> cir) {`
	`51`	`+ private void getCloudsColorInject(float tickDelta, CallbackInfoReturnable<Integer> cir) {`
`52`	`52`	`if (WorldColors.INSTANCE.isEnabled() && WorldColors.getCustomClouds()) {`
`53`		`- cir.setReturnValue(ColorKt.getVec3d(WorldColors.getCloudColor()));`
	`53`	`+ int rgb = WorldColors.getCloudColor().getRGB() & 0xFFFFFF;`
	`54`	`+ cir.setReturnValue(rgb);`
`54`	`55`	`}`
`55`	`56`	`}`
`56`	`57`
`57`	`58`	`@Inject(method = "getSkyColor", at = @At("HEAD"), cancellable = true)`
`58`		`- private void getSkyColorInject(Vec3d cameraPos, float tickDelta, CallbackInfoReturnable<Vec3d> cir) {`
	`59`	`+ private void getSkyColorInject(Vec3d cameraPos, float tickDelta, CallbackInfoReturnable<Integer> cir) {`
`59`	`60`	`if (WorldColors.INSTANCE.isEnabled() && WorldColors.getCustomSky()) {`
`60`		`- cir.setReturnValue(ColorKt.getVec3d(WorldColors.getSkyColor()));`
	`61`	`+ int rgb = WorldColors.getSkyColor().getRGB() & 0xFFFFFF;`
	`62`	`+ cir.setReturnValue(rgb);`
`61`	`63`	`}`
`62`	`64`	`}`
`63`	`65`
	`66`	`+`
`64`	`67`	`@Inject(method = "handleBlockUpdate", at = @At("HEAD"), cancellable = true)`
`65`	`68`	`private void handleBlockUpdateInject(BlockPos pos, BlockState newState, int flags, CallbackInfo ci) {`
`66`	`69`	`if (EventFlow.post(new WorldEvent.BlockUpdate.Server(pos, newState)).isCanceled()) ci.cancel();`