LiquidBounce/net.ccbluex.liquidbounce.utils.inventory

Package-level declarations

Types

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

Reusable anchored hotbar swap state machine:

ArmorItemSlot

enum ArmorItemSlot : ItemSlot, Enum<ArmorItemSlot>

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

enum HotbarItemSlot : ItemSlot, Enum<HotbarItemSlot>

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 : 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.)

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>

Slots

class Slots<T : ItemSlot>(slots: List<T>) : List<T>

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> Iterable<T>.findClosestSlot(predicate: (ItemStack) -> Boolean): T?

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

fun <T : HotbarItemSlot> Iterable<T>.findClosestSlot(itemTag: TagKey<Item>): T?

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

fun <T : HotbarItemSlot> Iterable<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

mergeableCapacityFor

@JvmOverloads

fun Iterable<ItemSlot>.mergeableCapacityFor(itemStack: ItemStack, blacklist: Collection<ItemSlot>? = null): Int

Exact total capacity of this iterable to store itemStack (empty slots count as ItemStack.maxStackSize, mergeable slots as their remaining space). Contract: the slot currently holding itemStack must NOT be part of this iterable, otherwise its own remaining capacity would be double-counted and the result overestimated.

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