Merge branch 'master' into feature/packetmine-rewrite

# Conflicts:
#	common/src/main/kotlin/com/lambda/module/modules/combat/KillAura.kt
#	common/src/main/kotlin/com/lambda/util/BlockUtils.kt

Author: beanbag44

common/src/main/kotlin/com/lambda/config/Configuration.kt

@@ -62,7 +62,26 @@ abstract class Configuration : Jsonable {
         get() = File("${primary.parent}/${primary.nameWithoutExtension}-backup.${primary.extension}")
 
     init {
-        tryLoad() // ToDo: This will do at the moment but i'd like to run this at the first first loadable stage
+        // 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()

common/src/main/kotlin/com/lambda/module/modules/combat/AutoDisconnect.kt

@@ -28,14 +28,13 @@ import com.lambda.sound.SoundManager.playSound
 import com.lambda.util.Communication
 import com.lambda.util.Communication.prefix
 import com.lambda.util.Formatting.string
-import com.lambda.util.combat.CombatUtils.explosionDamage
 import com.lambda.util.combat.CombatUtils.hasDeadlyCrystal
+import com.lambda.util.combat.DamageUtils.isFallDeadly
 import com.lambda.util.player.SlotUtils.combined
 import com.lambda.util.text.*
 import com.lambda.util.world.fastEntitySearch
 import net.minecraft.entity.damage.DamageSource
 import net.minecraft.entity.damage.DamageTypes
-import net.minecraft.entity.decoration.EndCrystalEntity
 import net.minecraft.entity.mob.CreeperEntity
 import net.minecraft.entity.player.PlayerEntity
 import net.minecraft.item.Items
@@ -49,7 +48,9 @@ object AutoDisconnect : Module(
     defaultTags = setOf(ModuleTag.COMBAT)
 ) {
     private val health by setting("Health", true, "Disconnect from the server when health is below the set limit.")
-    private val minimumHealth by setting("Min Health", 10, 6..36, 1, description = "Set the minimum health threshold for disconnection.", unit = " hearts") { health }
+    private val minimumHealth by setting("Min Health", 10, 6..36, 1, "Set the minimum health threshold for disconnection.", unit = " half-hearts") { health }
+    private val falls by setting("Falls", false, "Disconnect if the player will die of fall damage")
+    private val fallDistance by setting("Falls Time", 10, 0..30, 1, "Number of blocks fallen before disconnecting for fall damage.", unit = " blocks") { falls }
     private val crystals by setting("Crystals", false, "Disconnect if an End Crystal explosion would be lethal.")
     private val creeper by setting("Creepers", true, "Disconnect when an ignited Creeper is nearby.")
     private val totem by setting("Totem", false, "Disconnect if the number of Totems of Undying is below the required amount.")
@@ -233,11 +234,18 @@ object AutoDisconnect : Module(
             }
         }),
         END_CRYSTAL({ crystals }, {
-            if (hasDeadlyCrystal(1.0))
+            if (hasDeadlyCrystal())
                 buildText {
                     literal("There was an end crystal close to you that would've killed you")
                 }
             else null
-        });
+        }),
+        FALL_DAMAGE({ falls }, {
+            if (isFallDeadly() && player.fallDistance > fallDistance)
+                buildText {
+                    literal("You were about to fall and die")
+                }
+            else null
+        })
     }
 }

common/src/main/kotlin/com/lambda/module/modules/combat/AutoTotem.kt

@@ -0,0 +1,92 @@
+/*
+ * 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.combat
+
+import com.lambda.config.groups.InventorySettings
+import com.lambda.context.SafeContext
+import com.lambda.event.events.TickEvent
+import com.lambda.event.listener.SafeListener.Companion.listen
+import com.lambda.friend.FriendManager
+import com.lambda.interaction.material.StackSelection.Companion.select
+import com.lambda.interaction.material.container.ContainerManager.transfer
+import com.lambda.interaction.material.container.containers.OffHandContainer
+import com.lambda.module.Module
+import com.lambda.module.tag.ModuleTag
+import com.lambda.task.RootTask.run
+import com.lambda.util.Communication.info
+import com.lambda.util.combat.CombatUtils.hasDeadlyCrystal
+import com.lambda.util.combat.DamageUtils.isFallDeadly
+import com.lambda.util.extension.fullHealth
+import com.lambda.util.world.fastEntitySearch
+import net.minecraft.entity.mob.CreeperEntity
+import net.minecraft.entity.player.PlayerEntity
+import net.minecraft.item.Items
+
+object AutoTotem : Module(
+    name = "AutoTotem",
+    description = "Swaps the your off-hand item to a totem",
+    defaultTags = setOf(ModuleTag.COMBAT, ModuleTag.PLAYER),
+) {
+    private val page by setting("Page", Page.General)
+
+    private val log by setting("Log Message", true) { page == Page.General }
+
+    private val minimumHealth by setting("Min Health", 10, 6..36, 1, "Set the minimum health threshold to swap", unit = " half-hearts") { page == Page.General }
+    private val falls by setting("Falls", true, "Swap if the player will die of fall damage") { page == Page.General }
+    private val fallDistance by setting("Falls Time", 10, 0..30, 1, "Number of blocks fallen before swapping", unit = " blocks") { page == Page.General && falls }
+    private val crystals by setting("Crystals", true, "Swap if an End Crystal explosion would be lethal") { page == Page.General }
+    private val creeper by setting("Creepers", true, "Swap when an ignited Creeper is nearby") { page == Page.General }
+    private val players by setting("Players", false, "Swap if a nearby player is detected within the set distance") { page == Page.General }
+    private val minPlayerDistance by setting("Player Distance", 64, 32..128, 4, "Set the distance to detect players to swap") { page == Page.General && players }
+    private val friends by setting("Friends", false, "Exclude friends from triggering player-based swaps") { page == Page.General && players }
+
+    private val inventory = InventorySettings(this) { page == Page.Inventory }
+
+    init {
+        listen<TickEvent.Pre> {
+            if (Reason.entries.none { it.check(this) }) return@listen
+
+            if (!player.isHolding(Items.TOTEM_OF_UNDYING)) {
+                Items.TOTEM_OF_UNDYING.select()
+                    .transfer(OffHandContainer, inventory)
+                    ?.finally { if (log) info("Swapped the off-hand item with a totem") }
+                    ?.run()
+            }
+        }
+    }
+
+    enum class Reason(val check: SafeContext.() -> Boolean) {
+        HEALTH({ player.fullHealth < minimumHealth }),
+        CREEPER({ creeper && fastEntitySearch<CreeperEntity>(15.0).any {
+            it.getClientFuseTime(mc.tickDelta) > 0.0
+                    && it.pos.distanceTo(player.pos) <= 5.0
+        } }),
+        PLAYER({ players && fastEntitySearch<PlayerEntity>(minPlayerDistance.toDouble()).any { otherPlayer ->
+            otherPlayer != player
+                    && player.distanceTo(otherPlayer) <= minPlayerDistance
+                    && (!friends || !FriendManager.isFriend(otherPlayer.uuid))
+        } }),
+        END_CRYSTAL({ crystals && hasDeadlyCrystal() }),
+        FALL_DAMAGE({ falls && isFallDeadly() && player.fallDistance > fallDistance })
+    }
+
+    enum class Page {
+        General,
+        Inventory,
+    }
+}