LiquidBounce/net.ccbluex.liquidbounce.utils.inventory

Package-level declarations

Types

class AnchoredHotbarSwapController(owner: EventListener, inventoryConstraints: InventoryConstraints, swapDelayProvider: () -> Int, anchorHotbarSlotResolver: () -> HotbarItemSlot = { Slots.Hotbar.findSlot { it.isEmpty } ?: Slots.Hotbar[SilentHotbar.serversideSlot] }) : EventListener

Reusable anchored hotbar swap state machine:

ArmorItemSlot

class ArmorItemSlot(equipmentSlot: EquipmentSlot) : ItemSlot

CheckScreenHandlerTypeValueGroup

class CheckScreenHandlerTypeValueGroup(parent: EventListener) : ToggleableValueGroup

CheckScreenTitleValueGroup

class CheckScreenTitleValueGroup(parent: EventListener) : ToggleableValueGroup

ContainerItemSlot

class ContainerItemSlot(val slotInContainer: Int) : ItemSlot

EnderChestInventoryTracker

object EnderChestInventoryTracker : MinecraftShortcuts, EventListener

EquipmentSlotChoice

enum EquipmentSlotChoice : Tagged, Enum<EquipmentSlotChoice>

HotbarItemSlot

open class HotbarItemSlot(val hotbarSlot: Int) : ItemSlot

InventoryAction

sealed interface InventoryAction

InventoryConstraints

open class InventoryConstraints : ValueGroup

Constraints for inventory actions. This can be used to ensure that the player is not moving or rotating while interacting with the inventory. It Also allows setting delays for opening, clicking and closing the inventory.

InventoryItemSlot

class InventoryItemSlot(inventorySlot: Int) : ItemSlot

InventoryManager

object InventoryManager : EventListener

Manages the inventory state and timings and schedules inventory actions

InventoryRequirements

enum InventoryRequirements : Tagged, Predicate<InventoryAction> , Enum<InventoryRequirements>

ItemSlot

sealed interface ItemSlot : ItemStackHolder

Represents an inventory slot (e.g. Hotbar Slot 0, OffHand, Chestslot 5, etc.)

OffHandSlot

data object OffHandSlot : HotbarItemSlot

PlayerInventoryConstraints

class PlayerInventoryConstraints : InventoryConstraints

Additional constraints for the player inventory. This should be used when interacting with the player inventory instead of a generic container.

SingleItemStackPickMode

sealed class SingleItemStackPickMode : Mode, Predicate<ItemStack>

SlotGroup

class SlotGroup<T : ItemSlot>(val slots: List<T>) : List<T>

Slots

object Slots

ViewedInventoryScreen

class ViewedInventoryScreen(player: () -> Player?) : Screen

VirtualItemSlot

class VirtualItemSlot(val itemStack: ItemStack, val slotType: ItemSlot.Type, val id: Int) : ItemSlot

Properties

canCloseMainInventory

val canCloseMainInventory: Boolean

isInContainerScreen

val isInContainerScreen: Boolean

isInInventoryScreen

val isInInventoryScreen: Boolean

isPlayerInventory

val AbstractContainerMenu.isPlayerInventory: Boolean

syncId

val AbstractContainerScreen<*>?.syncId: Int

typeOrNull

val AbstractContainerMenu.typeOrNull: MenuType<*>?

Functions

findBestToolToMineBlock

fun <T : ItemSlot> Iterable<T>.findBestToolToMineBlock(blockState: BlockState, ignoreDurability: Boolean = true, predicate: BiPredicate<ItemStack, BlockState> = BiPredicate { _, _ -> true }): T?

Finds the best slot in this iterable for mining blockState using mc.player as baseline.

findClosestSlot

inline fun <T : HotbarItemSlot> SlotGroup<T>.findClosestSlot(predicate: (ItemStack) -> Boolean): T?

fun <T : HotbarItemSlot> SlotGroup<T>.findClosestSlot(items: Collection<Item>): T?

fun <T : HotbarItemSlot> SlotGroup<T>.findClosestSlot(item: Item): T?

fun <T : HotbarItemSlot> SlotGroup<T>.findClosestSlot(vararg items: Item): T?

findEmptyStorageSlotsInInventory

fun findEmptyStorageSlotsInInventory(): List<ItemSlot>

findItemsInContainer

fun AbstractContainerScreen<*>.findItemsInContainer(): List<ContainerItemSlot>

findNonEmptySlotsInInventory

fun findNonEmptySlotsInInventory(): List<ItemSlot>

findNonEmptyStorageSlotsInInventory

fun findNonEmptyStorageSlotsInInventory(): List<ItemSlot>

getSlotsInContainer

fun AbstractContainerScreen<*>.getSlotsInContainer(): List<ContainerItemSlot>

hasInventorySpace

fun hasInventorySpace(): Boolean

hasItem

fun SlotGroup<*>.hasItem(item: Item): Boolean

useHotbarSlotOrOffhand

@JvmOverloads

context(requester: EventListener)
fun useHotbarSlotOrOffhand(slot: HotbarItemSlot, ticksUntilReset: Int = 1, yRot: Float = RotationManager.currentRotation?.yRot ?: player.yRot, xRot: Float = RotationManager.currentRotation?.xRot ?: player.xRot, swingMode: SwingMode = SwingMode.DO_NOT_HIDE): InteractionResult