feat(nextgen): SmartEat

src/main/java/net/ccbluex/liquidbounce/injection/mixins/minecraft/network/MixinClientPlayerInteractionManager.java

@@ -22,17 +22,23 @@
 import net.ccbluex.liquidbounce.event.events.AttackEvent;
 import net.ccbluex.liquidbounce.event.events.BlockBreakingProgressEvent;
 import net.ccbluex.liquidbounce.event.events.CancelBlockBreakingEvent;
+import net.ccbluex.liquidbounce.event.events.PlayerInteractedItem;
 import net.ccbluex.liquidbounce.event.events.GameModeChangeEvent;
 import net.ccbluex.liquidbounce.features.module.modules.combat.ModuleAutoBow;
 import net.ccbluex.liquidbounce.features.module.modules.combat.ModuleAutoClicker;
+import net.ccbluex.liquidbounce.features.module.modules.combat.ModuleSmartEat;
 import net.ccbluex.liquidbounce.features.module.modules.player.ModuleReach;
 import net.ccbluex.liquidbounce.utils.aiming.Rotation;
 import net.ccbluex.liquidbounce.utils.aiming.RotationManager;
 import net.ccbluex.liquidbounce.utils.client.SilentHotbar;
+import net.minecraft.client.network.ClientPlayerEntity;
 import net.minecraft.client.network.ClientPlayerInteractionManager;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.entity.player.PlayerInventory;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.Hand;
+import net.minecraft.util.hit.BlockHitResult;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Direction;
 import net.minecraft.world.GameMode;
@@ -123,6 +129,12 @@ private void hookFixRotation(Args args) {
         args.set(4, rotation.getPitch());
     }
 
+    @Inject(method = "interactItem", at = @At("RETURN"))
+    private void hookItemInteract(PlayerEntity player, Hand hand, CallbackInfoReturnable<ActionResult> cir) {
+        final PlayerInteractedItem cancelEvent = new PlayerInteractedItem(player, hand, cir.getReturnValue());
+        EventManager.INSTANCE.callEvent(cancelEvent);
+    }
+
     @Inject(method = "stopUsingItem", at = @At("HEAD"))
     private void stopUsingItem(PlayerEntity player, CallbackInfo callbackInfo) {
         ModuleAutoBow.onStopUsingItem();

src/main/kotlin/net/ccbluex/liquidbounce/event/EventManager.kt

@@ -71,6 +71,7 @@ val ALL_EVENT_CLASSES: Array<KClass<out Event>> = arrayOf(
     PlayerJumpEvent::class,
     PlayerAfterJumpEvent::class,
     PlayerUseMultiplier::class,
+    PlayerInteractedItem::class,
     PlayerVelocityStrafe::class,
     PlayerStrideEvent::class,
     PlayerSafeWalkEvent::class,

src/main/kotlin/net/ccbluex/liquidbounce/event/events/PlayerEvents.kt

@@ -26,6 +26,9 @@ import net.ccbluex.liquidbounce.event.EventState
 import net.ccbluex.liquidbounce.utils.client.Nameable
 import net.ccbluex.liquidbounce.web.socket.protocol.event.WebSocketEvent
 import net.minecraft.entity.MovementType
+import net.minecraft.entity.player.PlayerEntity
+import net.minecraft.util.ActionResult
+import net.minecraft.util.Hand
 import net.minecraft.util.math.Vec3d
 
 // Entity events bound to client-user entity
@@ -66,6 +69,9 @@ class PlayerAfterJumpEvent : Event()
 @Nameable("playerUseMultiplier")
 class PlayerUseMultiplier(var forward: Float, var sideways: Float) : Event()
 
+@Nameable("playerInteractedItem")
+class PlayerInteractedItem(val player: PlayerEntity, val hand: Hand, val actionResult: ActionResult) : Event()
+
 @Nameable("playerStrafe")
 class PlayerVelocityStrafe(val movementInput: Vec3d, val speed: Float, val yaw: Float, var velocity: Vec3d) : Event()
 

src/main/kotlin/net/ccbluex/liquidbounce/features/module/ModuleManager.kt

@@ -48,8 +48,8 @@ import net.ccbluex.liquidbounce.features.module.modules.movement.step.ModuleStep
 import net.ccbluex.liquidbounce.features.module.modules.movement.terrainspeed.ModuleTerrainSpeed
 import net.ccbluex.liquidbounce.features.module.modules.player.*
 import net.ccbluex.liquidbounce.features.module.modules.player.autoplay.ModuleAutoPlay
-import net.ccbluex.liquidbounce.features.module.modules.player.invcleaner.ModuleInventoryCleaner
 import net.ccbluex.liquidbounce.features.module.modules.player.nofall.ModuleNoFall
+import net.ccbluex.liquidbounce.features.module.modules.player.invcleaner.ModuleInventoryCleaner
 import net.ccbluex.liquidbounce.features.module.modules.render.*
 import net.ccbluex.liquidbounce.features.module.modules.render.minimap.ModuleMinimap
 import net.ccbluex.liquidbounce.features.module.modules.render.murdermystery.ModuleMurderMystery
@@ -206,6 +206,7 @@ object ModuleManager : Listenable, Iterable<Module> by modules {
             ModuleRegen,
             ModuleZoot,
             ModuleAutoPlay,
+            ModuleSmartEat,
 
             // Render
             ModuleAnimations,

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/combat/ModuleSmartEat.kt

@@ -0,0 +1,196 @@
+/*
+ * This file is part of LiquidBounce (https://github.com/CCBlueX/LiquidBounce)
+ *
+ * Copyright (c) 2015 - 2023 CCBlueX
+ *
+ * LiquidBounce 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.
+ *
+ * LiquidBounce 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 LiquidBounce. If not, see <https://www.gnu.org/licenses/>.
+ */
+package net.ccbluex.liquidbounce.features.module.modules.combat
+
+import net.ccbluex.liquidbounce.config.ToggleableConfigurable
+import net.ccbluex.liquidbounce.event.events.OverlayRenderEvent
+import net.ccbluex.liquidbounce.event.events.PlayerInteractedItem
+import net.ccbluex.liquidbounce.event.handler
+import net.ccbluex.liquidbounce.event.repeatable
+import net.ccbluex.liquidbounce.features.module.Category
+import net.ccbluex.liquidbounce.features.module.Module
+import net.ccbluex.liquidbounce.render.renderEnvironmentForGUI
+import net.ccbluex.liquidbounce.utils.client.SilentHotbar
+import net.ccbluex.liquidbounce.utils.client.chat
+import net.ccbluex.liquidbounce.utils.item.Hotbar
+import net.minecraft.client.gui.DrawContext
+import net.minecraft.client.option.KeyBinding
+import net.minecraft.entity.effect.StatusEffects
+import net.minecraft.entity.player.PlayerEntity
+import net.minecraft.item.ItemStack
+import net.minecraft.item.Items
+import net.minecraft.potion.PotionUtil
+import net.minecraft.util.ActionResult
+import net.minecraft.util.Hand
+import net.minecraft.util.Identifier
+import net.minecraft.util.UseAction
+import kotlin.math.max
+
+/**
+ * SmartEat module
+ *
+ * Makes it easier to eat
+ */
+
+object ModuleSmartEat : Module("SmartEat", Category.PLAYER) {
+    private val HOTBAR_OFFHAND_LEFT_TEXTURE = Identifier("hud/hotbar_offhand_left")
+
+    private val swapBackDelay by int("SwapBackDelay", 5, 1..20)
+
+    private val preferGappleHealth by float("MaxPreferGappleHealth", 9f, 0f..20f)
+    private val preferNotchAppleHealth by float("MaxPreferNotchAppleHealth", 2f, 0f..20f)
+    private val preferHealthPotHealth by float("MaxPreferHealthPotHealth", 12f, 0f..20f)
+
+    private var prefersGapples = false
+    private var prefersNotchApple = false
+    private var prefersHealthPot = false
+    private val food: Pair<Int, ItemStack>?
+        get() = Hotbar.findBestItem(0) { _, itemStack ->
+            getItemScore(itemStack)
+        }
+    @Suppress("ReturnCount")
+    private fun getItemScore(itemStack: ItemStack): Int {
+        val item = itemStack.item
+
+        if (prefersHealthPot && item == Items.POTION) {
+            val hasHealthEffect =
+                PotionUtil.getPotionEffects(itemStack).any {
+                    it.effectType == StatusEffects.INSTANT_HEALTH
+                }
+
+            if (hasHealthEffect)
+                return 100 - preferHealthPotHealth.toInt()
+        }
+
+        val foodComp = item.foodComponent ?: return -1
+
+        val hasHungerEffect = foodComp.statusEffects.any { it.first.effectType == StatusEffects.HUNGER }
+        if (hasHungerEffect)
+            return 0
+
+        if(prefersGapples && item == Items.GOLDEN_APPLE)
+            return 100 - preferGappleHealth.toInt()
+
+        if (prefersNotchApple && item == Items.ENCHANTED_GOLDEN_APPLE)
+            return 100 - preferNotchAppleHealth.toInt()
+
+        return foodComp.hunger
+    }
+
+    val tickHandler = repeatable {
+        prefersGapples = player.health <= preferGappleHealth
+        prefersNotchApple = player.health <= preferNotchAppleHealth
+        prefersHealthPot = player.health <= preferHealthPotHealth
+    }
+    private object SilentOffhand : ToggleableConfigurable(this, "SilentOffhand", true) {
+        private object RenderSlot : ToggleableConfigurable(this, "RenderSlot", true) {
+            private val offset by int("Offset", 26, 0..40)
+            val renderHandler = handler<OverlayRenderEvent> {
+                renderEnvironmentForGUI {
+                    val currentFood = food ?: return@renderEnvironmentForGUI
+                    val dc = DrawContext(mc, mc.bufferBuilders.entityVertexConsumers)
+                    val scaledWidth = dc.scaledWindowWidth
+                    val scaledHeight = dc.scaledWindowHeight
+                    val i: Int = scaledWidth / 2
+                    val x = i - 91 - 26 - offset
+                    val y = scaledHeight - 16 - 3
+                    dc.drawItemInSlot(mc.textRenderer, currentFood.second, x, y)
+                    dc.drawItem(currentFood.second, x, y)
+                    dc.drawGuiTexture(
+                        HOTBAR_OFFHAND_LEFT_TEXTURE, i - 91 - 29 - offset,
+                        scaledHeight - 23, 29, 24
+                    )
+
+                }
+            }
+        }
+
+        val InteractionHandler = handler<PlayerInteractedItem> { event ->
+            if(!enabled)
+                return@handler
+            if(event.actionResult != ActionResult.PASS)
+                return@handler
+
+            val currentFood = food ?: return@handler
+
+            if(
+                !player.canConsume(false)
+                && currentFood.second.item.foodComponent?.isAlwaysEdible() == false
+                ) {
+                return@handler
+            }
+
+
+            SilentHotbar.selectSlotSilently(this@SilentOffhand, currentFood.first, max(swapBackDelay, 5))
+        }
+
+        val tickHandler = repeatable {
+
+            val useAction = player.activeItem.useAction
+
+            if (useAction != UseAction.EAT && useAction != UseAction.DRINK)
+                return@repeatable
+            if (!SilentHotbar.isSlotModified(this@SilentOffhand))
+                return@repeatable
+            // if we are already eating, we want to keep the silent slot
+            SilentHotbar.selectSlotSilently(this@SilentOffhand, SilentHotbar.serversideSlot, swapBackDelay)
+        }
+
+        init {
+            tree(RenderSlot)
+        }
+    }
+
+    private object AutoEat : ToggleableConfigurable(this, "AutoEat", true) {
+        private val minHunger by int("MinHunger", 15, 0..20)
+
+        private val tickHandler = repeatable {
+
+            if(player.hungerManager.foodLevel < minHunger) {
+
+                waitUntil {
+                    eat()
+                    player.hungerManager.foodLevel > minHunger
+                }
+                KeyBinding.setKeyPressed(mc.options.useKey.boundKey, false)
+
+            }
+        }
+
+        fun eat() {
+            val currentBestFood = food ?: return
+
+            val slot = currentBestFood.first
+
+            SilentHotbar.selectSlotSilently(AutoEat, slot, swapBackDelay)
+
+            KeyBinding.setKeyPressed(mc.options.useKey.boundKey, true)
+
+
+        }
+    }
+
+
+    init {
+        tree(SilentOffhand)
+        tree(AutoEat)
+    }
+
+
+}

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/player/nofall/modes/NoFallMLG.kt

@@ -76,7 +76,7 @@ internal object NoFallMLG : Choice("MLG") {
 
         val options = BlockPlacementTargetFindingOptions(
             listOf(Vec3i(0, 0, 0)),
-            player.inventory.getStack(itemForMLG!!),
+            itemForMLG!!.itemStack,
             CenterTargetPositionFactory,
             BlockPlacementTargetFindingOptions.PRIORITIZE_LEAST_BLOCK_DISTANCE,
             player.pos
@@ -106,7 +106,7 @@ internal object NoFallMLG : Choice("MLG") {
         }
 
         val item = itemForMLG ?: return@repeatable
-        SilentHotbar.selectSlotSilently(this, item, 1)
+        SilentHotbar.selectSlotSilently(this, item.hotbarSlotForServer, 1)
 
         doPlacement(rayTraceResult)
 

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/player/nofall/modes/NoFallRettungsplatform.kt

@@ -65,7 +65,7 @@ internal object NoFallRettungsplatform : Choice("Rettungsplatform") {
                 return@repeatable
             }
 
-            useHotbarSlotOrOffhand(HotbarItemSlot(itemToPlatform))
+            useHotbarSlotOrOffhand(itemToPlatform)
 
             // Wait 5 seconds
             waitTicks(20 * 5)

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/world/ModuleIgnite.kt

@@ -99,7 +99,7 @@ object ModuleIgnite : Module("Ignite", Category.WORLD) {
 
             val options = BlockPlacementTargetFindingOptions(
                 listOf(Vec3i(0, 0, 0)),
-                player.inventory.getStack(slot),
+                slot.itemStack,
                 CenterTargetPositionFactory,
                 BlockPlacementTargetFindingOptions.PRIORITIZE_LEAST_BLOCK_DISTANCE,
                 player.pos
@@ -133,7 +133,7 @@ object ModuleIgnite : Module("Ignite", Category.WORLD) {
 
         CombatManager.pauseCombatForAtLeast(1)
 
-        SilentHotbar.selectSlotSilently(this, slot, 1)
+        SilentHotbar.selectSlotSilently(this, slot.hotbarSlotForServer, 1)
 
         doPlacement(raycast, Hand.MAIN_HAND)
 

src/main/kotlin/net/ccbluex/liquidbounce/features/module/modules/world/autoFarm/ModuleAutoFarm.kt

@@ -178,7 +178,7 @@ object ModuleAutoFarm : Module("AutoFarm", Category.WORLD) {
 
                 item ?: return@repeatable
 
-                SilentHotbar.selectSlotSilently(this, item, AutoPlaceCrops.swapBackDelay.random())
+                SilentHotbar.selectSlotSilently(this, item.hotbarSlotForServer, AutoPlaceCrops.swapBackDelay.random())
                 doPlacement(rayTraceResult)
 
                 waitTicks(interactDelay.random())

src/main/kotlin/net/ccbluex/liquidbounce/utils/client/SilentHotbar.kt

@@ -47,6 +47,11 @@ object SilentHotbar : Listenable {
         }
     }
 
+    /**
+     * Returns if the slot is currently getting modified by a given requester
+     */
+    fun isSlotModified(requester: Any?) = hotbarState?.requester == requester
+
     val tickHandler = handler<GameTickEvent>(priority = 1001) {
         val hotbarState = hotbarState ?: return@handler
 

src/main/kotlin/net/ccbluex/liquidbounce/utils/item/InventoryUtils.kt

@@ -55,10 +55,19 @@ val ALL_SLOTS_IN_INVENTORY: List<ItemSlot> = run {
     return@run hotbarItems + offHandItem + inventoryItems + armorItems
 }
 
+
+
 object Hotbar {
-    fun findClosestItem(items: Array<Item>): Int? {
-        return (0..8).filter { player.inventory.getStack(it).item in items }
-            .minByOrNull { abs(player.inventory.selectedSlot - it) }
+
+    /**
+     * Contains all hotbar slots in inventory.
+     */
+    val slots = run {
+        return@run (0 until 9).map { HotbarItemSlot(it) }
+    }
+    fun findClosestItem(items: Array<Item>): HotbarItemSlot? {
+        return slots.filter { it.itemStack.item in items }
+            .minByOrNull { abs(player.inventory.selectedSlot - it.hotbarSlotForServer) }
     }
 
     val items
@@ -68,15 +77,15 @@ object Hotbar {
         validator: (Int, ItemStack) -> Boolean,
         sort: (Int, ItemStack) -> Int = { slot, _ -> abs(player.inventory.selectedSlot - slot) }
     ) =
-        (0..8)
-            .map {slot -> Pair (slot, player.inventory.getStack(slot)) }
+        slots
+            .map {slot -> Pair (slot.hotbarSlotForServer, slot.itemStack) }
             .filter { (slot, itemStack) -> validator (slot, itemStack) }
             .maxByOrNull { (slot, itemStack) -> sort (slot, itemStack) }
 
 
     fun findBestItem(min: Int, sort: (Int, ItemStack) -> Int) =
-        (0..8)
-            .map {slot -> Pair (slot, player.inventory.getStack(slot)) }
+        slots
+            .map {slot -> Pair (slot.hotbarSlotForServer, slot.itemStack) }
             .maxByOrNull { (slot, itemStack) -> sort(slot, itemStack) }
             ?.takeIf {  (slot, itemStack) -> sort(slot, itemStack) >= min }