Struct MenuBehavior 

pub struct MenuBehavior {

    slots: Vec<Box<dyn Slot>>,
    remote_slots: Vec<RemoteSlot>,
    carried: ItemStack,
    remote_carried: RemoteSlot,
    container_id: u8,
    state_id: u32,
    menu_type: Option<MenuTypeRef>,
    suppress_remote_updates: bool,
    quickcraft: Option<DragKind>,
    quickcraft_slots: Vec<usize>,
    data_slots: Vec<i16>,
    remote_data_slots: Vec<i16>,
    container_refs: Vec<ContainerRef>,
    instance: MenuInstanceId,
}

Shared behavior and state for all menu types.

Fields

slots: Vec<Box<dyn Slot>>

The slots in this menu.

remote_slots: Vec<RemoteSlot>

The client’s perception of the itemstacks.

carried: ItemStack

The item being carried by the cursor.

remote_carried: RemoteSlot

The client’s perception of the carried item.

container_id: u8

The container ID (0 for player inventory).

state_id: u32

Incremented on every server/client mismatch.

menu_type: Option<MenuTypeRef>

None for the player inventory.

suppress_remote_updates: bool

Suppresses remote updates during click handling.

quickcraft: Option<DragKind>

The kind of drag in progress, or None when idle.

quickcraft_slots: Vec<usize>

Slots involved in the current quickcraft operation.

data_slots: Vec<i16>

Data slots for furnace progress, enchanting levels and the like.

remote_data_slots: Vec<i16>

The client’s perception of the data slot values.

container_refs: Vec<ContainerRef>

instance: MenuInstanceId

Identity stamp tying Section and DataSlot handles to this menu.

Implementations

impl MenuBehavior

pub(crate) fn new( instance: MenuInstanceId, slots: Vec<Box<dyn Slot>>, container_id: u8, menu_type: Option<MenuTypeRef>, container_refs: Vec<ContainerRef>, ) -> Self

Creates a menu behavior with the given slots.

pub fn lock_all_containers(&self) -> ContainerLockGuard

Locks all containers referenced by slots in this menu.

pub(crate) fn lock_all_containers_with( &self, additional: ContainerRef, ) -> ContainerLockGuard

Locks the menu containers together with one additional container.

pub fn slots(&self) -> &[Box<dyn Slot>]

The slots of this menu, fixed at build time.

pub const fn carried(&self) -> &ItemStack

The item carried by the cursor.

pub const fn carried_mut(&mut self) -> &mut ItemStack

The item carried by the cursor.

pub const fn container_id(&self) -> u8

The container ID (0 for the player inventory).

pub const fn menu_type(&self) -> Option<MenuTypeRef>

The menu type, or None for the player’s own inventory.

pub const fn state_id(&self) -> u32

The current state ID.

pub const fn quickcraft(&self) -> Option<DragKind>

The kind of drag in progress, or None when idle.

pub(crate) const fn instance(&self) -> MenuInstanceId

The identity stamp of the menu this behavior belongs to.

pub(crate) fn add_data_slot(&mut self, initial_value: i16) -> usize

Adds a data slot with an initial value, returning its index.

pub(crate) fn get_data(&self, index: usize) -> Option<i16>

Gets the value of a data slot.

pub(crate) fn set_data(&mut self, index: usize, value: i16)

Sets the value of a data slot.

pub(crate) fn reset_quick_craft(&mut self)

Resets the quickcraft state.

pub(crate) fn update_quick_move_source( &self, guard: &mut ContainerLockGuard, slot_index: usize, remaining: &ItemStack, previous: &ItemStack, )

Writes a quick-move remainder back to its source slot. Fake slots are recomputed, so only their change notification fires.

pub fn move_item_stack_to( &self, guard: &mut ContainerLockGuard, source_slot: usize, item_stack: &mut ItemStack, start_slot: usize, end_slot: usize, direction: FillDirection, ) -> bool

Moves items from source_slot into slots [start_slot, end_slot), walking the range in direction. Aliases of the source’s physical storage are skipped. Returns true if anything moved.

pub(crate) const fn suppress_remote_updates(&mut self)

Suppresses remote updates during click handling.

pub(crate) const fn resume_remote_updates(&mut self)

Resumes remote updates after click handling.

pub(crate) fn transfer_state(&mut self, other: &MenuBehavior)

Copies another menu’s remote slot state, matched by (container_id, container_slot), so closing a menu doesn’t resync shared inventory slots.

pub const fn slot_count(&self) -> usize

The number of slots in this menu.

const fn increment_state_id(&mut self) -> u32

Increments and returns the new state ID.

fn send_packet<P: ClientPacket>(connection: &Arc<PlayerConnection>, packet: P)

Encodes and sends a packet through the connection.

pub(crate) fn send_all_data_to_remote( &mut self, connection: &Arc<PlayerConnection>, )

Sends every slot, the carried item and all data slots to the client and marks them synced.

pub fn broadcast_changes(&mut self, connection: &Arc<PlayerConnection>)

Syncs only the changed slots, carried item and data slots to the client, once per tick.

fn synchronize_data_slot_to_remote( &mut self, index: usize, connection: &Arc<PlayerConnection>, )

Sends a data slot update to the client if it changed.

fn synchronize_slot_to_remote( &mut self, slot: usize, item: ItemStack, connection: &Arc<PlayerConnection>, )

Sends a single slot update and records the sent stack as the client’s perception.

fn synchronize_carried_to_remote(&mut self, connection: &Arc<PlayerConnection>)

Sends the carried item (cursor) to the client.

pub(crate) fn set_remote_slot_known(&mut self, slot: usize, item: &ItemStack)

Sets a remote slot to a known ItemStack when we know exactly what the client has.

pub(crate) fn mark_remote_slot_unknown(&mut self, slot: usize)

Forgets what the client has in slot, forcing a resync on the next broadcast.

pub(crate) fn set_remote_slot(&mut self, slot: usize, hash: HashedStack)

Records the client’s reported perception of a slot.

pub(crate) fn set_remote_carried(&mut self, hash: HashedStack)

Records the client’s reported carried item.

pub(crate) fn do_quick_craft( &mut self, action: QuickCraft, has_infinite_materials: bool, player: &Player, can_drag_to: &impl Fn(usize) -> bool, )

Handles one phase of a quickcraft (drag) operation. can_drag_to is the kind’s per-slot veto.

fn finish_quick_craft( &mut self, player: &Player, can_drag_to: &impl Fn(usize) -> bool, )

Distributes the carried items over the dragged slots and resets the drag state (the End phase of MenuBehavior::do_quick_craft).

pub(crate) fn drop_carried(&mut self, button: MouseButton, player: &Player)

Drops the carried stack when the player clicks outside the window. Left drops all, right drops one.

pub(crate) fn do_pickup( &mut self, slot_index: usize, button: MouseButton, player: &Player, )

Handles a pickup click (left/right click to pick up or place items).

pub(crate) fn do_clone( &mut self, slot_index: usize, has_infinite_materials: bool, )

Handles clone (middle-click in creative).

pub(crate) fn do_throw( &mut self, slot_index: usize, whole_stack: bool, player: &Player, )

Handles throw (drop key). Q drops one item, Ctrl+Q (whole_stack) drops the whole stack, repeating while the slot refills with the same item.

Trait Implementations

impl Debug for MenuBehavior

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.