Struct Player 

pub struct Player {

    pub gameprofile: GameProfile,
    pub connection: Arc<PlayerConnection>,
    pub(crate) session: Arc<PlayerSession>,
    pub world: ArcSwap<World>,
    pub(crate) server: Weak<Server>,
    pub(crate) config: Arc<RuntimeConfig>,
    base: EntityBase,
    lifecycle: SyncMutex<PlayerLifecycleState>,
    pub(crate) movement: SyncMutex<MovementState>,
    entity_data: SyncMutex<PlayerEntityData>,
    pub last_chunk_pos: SyncMutex<ChunkPos>,
    pub last_tracking_view: SyncMutex<Option<PlayerChunkView>>,
    client_information: SyncMutex<ClientInformation>,
    game_modes: SyncMutex<PlayerGameModeState>,
    pub inventory: Shared<PlayerInventory>,
    inventory_sync: SyncMutex<PlayerInventorySyncState>,
    pub ender_chest_inventory: SyncPlayerEnderChest,
    last_item_in_main_hand: SyncMutex<ItemStack>,
    inventory_menu: SyncMutex<Menu>,
    open_menu: SyncMutex<OpenMenuState>,
    container_counter: SyncMutex<ContainerCounter>,
    teleport_state: SyncMutex<TeleportState>,
    item_cooldowns: SyncMutex<ItemCooldowns>,
    tick_state: SyncMutex<PlayerTickState>,
    sleep_state: SyncMutex<PlayerSleepState>,
    respawn_config: SyncMutex<Option<PlayerRespawnConfig>>,
    pub abilities: SyncMutex<Abilities>,
    pub block_breaking: SyncMutex<BlockBreakingManager>,
    living_base: LivingEntityBase,
    pub food_data: SyncMutex<FoodData>,
    health_sync: SyncMutex<HealthSyncState>,
    pub experience: SyncMutex<Experience>,
    permissions: SyncMutex<PlayerPermissionState>,
    seen_credits: SyncMutex<bool>,
    won_game: SyncMutex<bool>,
    pub chunk_send_epoch: SyncMutex<u32>,
    residence: SyncMutex<PlayerResidenceState>,
    ender_pearls: SyncMutex<Vec<Weak<dyn Entity>>>,
    pub(crate) fishing: SyncMutex<Option<Weak<FishingHookEntity>>>,
    stats: SyncMutex<StatsCounter>,
    last_action_time: SyncMutex<Instant>,
}

A struct representing a player.

Fields

gameprofile: GameProfile

The player’s game profile.

connection: Arc<PlayerConnection>

The player’s connection (abstracted for testing).

session: Arc<PlayerSession>

Stable connection session shared by every incarnation of this player.

world: ArcSwap<World>

The world the player is in.

server: Weak<Server>

Reference to the server (for entity ID generation, etc.).

config: Arc<RuntimeConfig>

Runtime configuration shared with the server.

base: EntityBase

Common entity fields (id, uuid, position, rotation, removal, callback).

lifecycle: SyncMutex<PlayerLifecycleState>

Client lifecycle flags.

movement: SyncMutex<MovementState>

Movement tracking state

entity_data: SyncMutex<PlayerEntityData>

Synchronized entity data (health, pose, flags, etc.) for network sync.

last_chunk_pos: SyncMutex<ChunkPos>

The last chunk position of the player.

last_tracking_view: SyncMutex<Option<PlayerChunkView>>

The last chunk tracking view of the player.

client_information: SyncMutex<ClientInformation>

The client’s settings/information (language, view distance, chat visibility, etc.). Updated when the client sends SClientInformation during config or play phase.

game_modes: SyncMutex<PlayerGameModeState>

Current and previous game mode.

inventory: Shared<PlayerInventory>

The player’s inventory container (shared with inventory_menu).

inventory_sync: SyncMutex<PlayerInventorySyncState>

Logical inventory slots that must be resent directly to this player’s client.

ender_chest_inventory: SyncPlayerEnderChest

The player’s ender chest inventory.

last_item_in_main_hand: SyncMutex<ItemStack>

Last main-hand stack used for vanilla attack-strength reset checks.

inventory_menu: SyncMutex<Menu>

The player’s inventory menu (always open, even when container_id is 0).

open_menu: SyncMutex<OpenMenuState>

The currently open menu (None if player inventory is open). This is separate from inventory_menu which is always present.

container_counter: SyncMutex<ContainerCounter>

Counter for generating container IDs (1-100, wraps around).

teleport_state: SyncMutex<TeleportState>

Pending server-initiated teleport state (ID, position, timeout).

item_cooldowns: SyncMutex<ItemCooldowns>

Vanilla item use cooldown groups.

tick_state: SyncMutex<PlayerTickState>

Local tick and once-per-tick packet state.

sleep_state: SyncMutex<PlayerSleepState>

Vanilla sleep/wake animation counter.

respawn_config: SyncMutex<Option<PlayerRespawnConfig>>

Persisted personal bed or respawn-anchor target.

abilities: SyncMutex<Abilities>

Player abilities (flight, invulnerability, build permissions, speeds, etc.)

block_breaking: SyncMutex<BlockBreakingManager>

Block breaking state machine.

living_base: LivingEntityBase

Shared living-entity runtime fields (attributes, speed, damage/death state). Vanilla: LivingEntity (L230-232) + Entity.invulnerableTime (L256).

food_data: SyncMutex<FoodData>

Player food/hunger state (food level, saturation, exhaustion).

health_sync: SyncMutex<HealthSyncState>

Delta-tracking state for CSetHealth deduplication.

experience: SyncMutex<Experience>

The Player’s Experience

permissions: SyncMutex<PlayerPermissionState>

Assigned groups, direct overrides, and the effective permission set.

seen_credits: SyncMutex<bool>

Whether the player has completed the vanilla End credits flow.

won_game: SyncMutex<bool>

Vanilla ServerPlayer.wonGame; transient while the End credits screen is open.

chunk_send_epoch: SyncMutex<u32>

Monotonic counter bumped on world teleport/reset. The chunk sending tick snapshots this before encoding and compares after to detect stale batches.

residence: SyncMutex<PlayerResidenceState>

Domain-residence identity and persisted entities awaiting restoration.

ender_pearls: SyncMutex<Vec<Weak<dyn Entity>>>

In-flight ender pearls thrown by this player, kept weakly so they persist with the player and re-spawn on login (vanilla ServerPlayer.enderPearls).

fishing: SyncMutex<Option<Weak<FishingHookEntity>>>

Active fishing hook, kept weakly because the world owns live entities.

stats: SyncMutex<StatsCounter>

The counter keeping track of this player’s statistics.

last_action_time: SyncMutex<Instant>

The last action time of this player.

Implementations

impl Player

pub fn send_abilities(&self)

Sends the player abilities packet to the client. This tells the client about flight, invulnerability, speeds, etc.

pub fn is_flying(&self) -> bool

Returns true if the player is flying (creative/spectator flight).

pub fn set_flying(&self, flying: bool)

Sets the player’s flying state.

pub fn get_flying_speed(&self) -> f32

Returns the player’s flying speed.

pub fn set_flying_speed(&self, speed: f32)

Sets the player’s flying speed.

pub fn get_abilities(&self) -> Abilities

Returns a copy of the player’s abilities.

pub fn prevents_block_drops(&self) -> bool

Whether this player’s own block-breaking should skip normal item drops (creative-mode instant-build).

pub fn handle_player_abilities(&self, packet: SPlayerAbilities)

Handles the player abilities packet from the client. This is sent when the player starts or stops flying.

impl Player

pub fn tick_throttlers(&self)

Decays the throttlers of the player once per server tick.

const fn should_disconnect_for_rate_spam( throttler: &mut TickThrottler, is_operator: bool, ) -> bool

pub fn detect_command_rate_spam(&self)

Applies Vanilla command spam accounting after a command is handled

fn detect_chat_rate_spam(&self)

pub fn get_and_increment_messages_received(&self) -> i32

Gets the next messages_received counter and increments it

fn verify_chat_signature( &self, packet: &SChat, ) -> Result<(SignedMessageLink, LastSeen), String>

pub fn handle_chat(&self, packet: SChat, player: Arc<Player>)

Handles a chat message from the player.

pub fn send_message(&self, text: &TextComponent)

Sends a system message to the player.

pub fn send_overlay_message(&self, text: &TextComponent)

Sends an overlay system message to the player

pub(crate) fn send_build_limit_too_high_message(&self, limit: i32)

Sends vanilla’s red upper build-height limit overlay.

pub fn set_chat_session(&self, session: RemoteChatSession)

Updates the player’s chat session and initializes the message chain.

This should be called when receiving a ChatSessionUpdate packet from the client.

pub fn chat_session(&self) -> Option<RemoteChatSession>

Gets a reference to the player’s chat session if present

pub fn has_chat_session(&self) -> bool

Checks if the player has a valid chat session

pub fn handle_chat_session_update(&self, packet: SChatSessionUpdate)

Handles a chat session update packet from the client.

This validates the player’s profile key and initializes signed chat if valid.

pub fn handle_chat_ack(&self, packet: SChatAck)

Handles a chat acknowledgment packet from the client.

impl Player

pub fn send_packet<P: ClientPacket>(&self, packet: P)

Sends a packet to the player’s connection.

This is a generic helper that encodes the packet and delegates to the connection’s send_encoded method, enabling object-safe packet sending.

Panics

Panics if the packet fails to encode.

pub fn send_bundle<F>(&self, f: F)

where F: FnOnce(&mut BundleBuilder),

Sends multiple packets as an atomic bundle.

The closure receives a BundleBuilder to add packets to. All packets are encoded, then sent wrapped in bundle delimiters so the client processes them together in a single game tick.

pub fn disconnect(&self, reason: impl Into<TextComponent>)

Disconnects the player with a reason message.

pub fn close_connection(&self)

Marks the player’s connection as closed without sending a disconnect packet.

Used during shutdown so that container-close logic treats the player as disconnected — dropping open-menu contents into the world instead of the saved inventory, matching vanilla’s removal-on-shutdown behavior.

pub fn handle_client_information(&self, packet: SClientInformation)

Handles client information updates during play phase.

pub fn client_information(&self) -> ClientInformation

Returns the player’s client information settings.

pub fn set_client_information(&self, info: ClientInformation)

Updates the player’s client information settings.

pub fn view_distance(&self) -> u8

Returns the effective view distance for this player.

This is the minimum of the client’s requested view distance and the server’s configured maximum view distance.

impl Player

pub(super) const fn dimensions_for_pose(pose: EntityPose) -> EntityDimensions

Returns vanilla Avatar.POSES dimensions for a player pose.

fn bounding_box_for_pose(&self, pose: EntityPose) -> WorldAabb

fn can_player_fit_within_blocks_and_entities_when( &self, pose: EntityPose, ) -> bool

pub(super) fn reset_entity_state(&self)

pub fn is_crouching(&self) -> bool

Returns true if the player is shifting (sneaking).

pub fn wants_to_stop_riding(&self) -> bool

Returns true if the player wants to stop riding (is holding the shift key)

pub fn set_crouching(&self, crouching: bool)

Sets whether the player is shifting (sneaking).

pub fn is_swimming(&self) -> bool

Returns true if vanilla player rules consider the player swimming.

pub fn is_fall_flying(&self) -> bool

Returns true if the player is currently fall flying (elytra).

pub(super) fn on_climbable(&self) -> bool

Returns true if vanilla rules consider this player to be on a climbable block.

pub fn set_fall_flying(&self, fall_flying: bool)

Sets the player’s fall flying state.

pub(super) fn get_desired_pose(&self) -> EntityPose

Determines the desired pose based on current player state. Priority: Sleeping > Swimming > FallFlying > Sneaking > Standing

pub(super) fn update_pose(&self)

Updates the player’s pose in entity data based on current state.

impl Player

pub fn score(&self) -> i32

Returns the player’s vanilla death-screen score.

pub fn set_score(&self, score: i32)

Sets the player’s vanilla death-screen score.

fn increase_score(&self, amount: i32)

pub(crate) fn give_experience_points(&self, points: i32)

Gives raw experience points to this player.

pub(crate) fn give_experience_levels(&self, levels: i32)

Gives experience levels to this player.

fn play_experience_level_up_sound(&self, level: i32)

pub(super) fn advance_tick(&self)

Advances this player’s local server tick count.

impl Player

pub(super) fn tick_regeneration(&self)

Ticks food/hunger regeneration and starvation.

pub fn cause_food_exhaustion(&self, amount: f32)

Adds food exhaustion, gated by invulnerability.

pub fn is_hurt(&self) -> bool

Returns true if the player is alive but below max health.

impl Player

pub(crate) fn may_use_item_at( &self, pos: BlockPos, direction: Direction, item_stack: &ItemStack, ) -> bool

Mirrors vanilla Player.mayUseItemAt for adventure-mode item use.

pub(super) fn block_action_restricted( &self, world: &World, pos: BlockPos, ) -> bool

Mirrors vanilla Player.blockActionRestricted for block breaking.

fn matches_adventure_mode_predicate( predicate: &AdventureModePredicate, world: &World, pos: BlockPos, ) -> bool

impl Player

fn send_block_updates(&self, pos: BlockPos, direction: Direction)

Sends block update packets for a position and its neighbor. Optionally also sends an update for an additional placement position (useful for items like buckets that place blocks at different positions).

pub fn swing(&self, hand: InteractionHand, update_self: bool)

Triggers arm swing animation and broadcasts it to tracking players.

pub fn handle_use_item_on(&self, packet: SUseItemOn)

Handles the use of an item on a block.

Implements the logic from Java’s ServerGamePacketListenerImpl.handleUseItemOn().

pub fn handle_player_action(&self, packet: SPlayerAction)

Handles a player action packet (block breaking, item dropping, etc.).

pub fn handle_pick_item_from_block(&self, packet: SPickItemFromBlock)

Handles the pick block action (middle click on a block).

Panics

Panics if the behavior registry has not been initialized.

pub fn handle_sign_update(&self, packet: SSignUpdate)

Handles a sign update packet from the client.

pub fn open_sign_editor(&self, pos: BlockPos, is_front_text: bool)

Opens the sign editor for the player.

Arguments

• pos - Position of the sign block
• is_front_text - Whether to edit front (true) or back (false) text

impl Player

fn invalid_entity_attacked_message() -> TextComponent

fn eye_position(&self) -> DVec3

fn damage_source_for_attack_type( &self, damage_type: &'static DamageType, ) -> DamageSource

fn attack_damage_source(&self, attacking_item: &ItemStack) -> DamageSource

pub(in player) fn tick_attack_strength( &self, )

Ticks vanilla attack-strength recovery and resets it on main-hand item changes.

fn reset_attack_strength_ticker(&self)

fn current_item_attack_strength_delay(&self) -> f32

fn attack_strength_delay_from_speed(attack_speed: f64) -> f32

pub fn attack_strength_scale(&self, partial_tick: f32) -> f32

Returns vanilla Player.getAttackStrengthScale.

fn attack_strength_scale_for_delay( &self, partial_tick: f32, attack_strength_delay: f32, ) -> f32

fn base_damage_scale_factor(attack_strength_scale: f32) -> f32

fn get_knockback( attack_knockback: f64, weapon: &ItemStack, enchantment_context: &EnchantmentDamageContext<'_>, ) -> f64

fn cause_extra_knockback( &self, entity: &dyn Entity, knockback_amount: f64, old_movement: DVec3, )

fn entity_interaction_range(&self) -> f64

pub fn is_within_attack_range_with_buffer( &self, item_stack: &ItemStack, aabb: WorldAabb, buffer: f64, ) -> bool

Returns true if the target box is within the player’s attack range for item_stack.

pub fn is_within_entity_interaction_range_with_buffer( &self, aabb: WorldAabb, buffer: f64, ) -> bool

Returns true if the target box is within the player’s entity interaction range.

fn attack_range_for_item(&self, item_stack: &ItemStack) -> (f64, f64, f64)

fn piercing_hit_entities( &self, item_stack: &ItemStack, world: &World, ) -> Vec<SharedEntity>

fn can_piercing_hit_entity(&self, target: &dyn Entity) -> bool

pub(super) fn piercing_attack( &self, item_stack: &ItemStack, piercing_weapon: &PiercingWeapon, )

fn stab_attack( &self, target: &SharedEntity, base_damage: f32, deals_damage: bool, deals_knockback: bool, dismounts: bool, ) -> bool

fn play_sound_holder(&self, holder: Option<&SoundEventHolder>)

fn cannot_attack(&self, entity: &dyn Entity) -> bool

pub fn attack(&self, target: &SharedEntity) -> bool

Attacks an entity with the player’s main-hand base damage.

Returns true if the target accepted damage.

fn item_attack_interaction( &self, entity: &dyn Entity, damage_source: &DamageSource, apply_to_target: bool, )

pub fn interact_on( &self, entity: &dyn Entity, hand: InteractionHand, location: DVec3, ) -> InteractionResult

Interacts with an entity using the held item.

pub fn handle_attack(&self, packet: SAttack)

Handles a client request to attack an entity.

pub(super) fn cannot_attack_with_item( &self, item_stack: &ItemStack, tolerance: i32, ) -> bool

pub(super) fn is_invalid_attack_target( player_id: i32, target_id: i32, target_type: EntityTypeRef, ) -> bool

pub fn handle_interact(&self, packet: SInteract)

Handles a client request to interact with an entity.

pub fn damage_stats_and_hearts( &self, entity: &dyn Entity, old_entity_living_health: f32, )

Awards stats and sends particles when an entity gets attacked by this player.

impl Player

pub fn handle_use_item(&self, packet: SUseItem)

Handles the use of an item.

impl Player

pub const DEFAULT_BLOCK_INTERACTION_RANGE: f64 = 4.5

Vanilla Player.DEFAULT_BLOCK_INTERACTION_RANGE.

pub const DEFAULT_ENTITY_INTERACTION_RANGE: f64 = 3.0

Vanilla Player.DEFAULT_ENTITY_INTERACTION_RANGE.

pub fn set_game_mode(&self, gamemode: GameType) -> bool

Sets the player’s game mode and notifies the client.

Returns true if the game mode was changed, false if the player was already in the requested game mode.

fn update_game_mode_invisibility(&self)

fn is_in_range_of_ground_for_flight_disable(&self) -> bool

pub fn send_difficulty(&self)

Sends the current world difficulty to the client.

pub fn handle_change_difficulty(&self, difficulty: Difficulty)

Handles a client request to change the world difficulty.

pub(in player) fn update_player_attributes( &self, )

Updates interaction range attribute modifiers based on game mode.

Vanilla: ServerPlayer.updatePlayerAttributes() — applies creative-mode range modifiers every tick.

pub fn has_infinite_materials(&self) -> bool

Returns true if player has infinite materials (Creative mode).

pub fn ack_block_changes_up_to(&self, sequence: i32)

Acknowledges block changes up to the given sequence number.

The ack is batched and sent once per tick (in tick_ack_block_changes), matching vanilla behavior.

pub(in player) fn tick_ack_block_changes( &self, )

Sends pending block change ack if any. Called once per tick.

pub fn is_within_block_interaction_range(&self, pos: BlockPos) -> bool

Returns true if player is within block interaction range.

Uses eye position and AABB distance (nearest point on block surface), matching vanilla’s Player.isWithinBlockInteractionRange(pos, 1.0).

pub fn block_interaction_range(&self) -> f64

Vanilla player.blockInteractionRange()

pub fn is_within_block_interaction_range_with_buffer( &self, pos: BlockPos, buffer: f64, ) -> bool

Returns true if player is within block interaction range plus a vanilla buffer.

pub fn is_within_entity_interaction_range( &self, aabb: WorldAabb, buffer: f64, ) -> bool

Returns true if the player’s eye position is within entity interaction range.

pub fn handle_spectator_action(&self, packet: SSpectatorAction)

Handles spectator camera selection.

pub fn is_secondary_use_active(&self) -> bool

Returns true if player is sneaking (secondary use active).

pub fn handle_animate(&self, packet: SSwing)

Handles a player swing packet.

impl Player

pub fn reset_sent_info(&self)

Invalidates the delta-tracking state so that the next tick() will send CSetHealth to the client (vanilla: resetSentInfo).

impl Player

pub fn is_item_on_cooldown(&self, stack: &ItemStack) -> bool

Returns whether the stack’s vanilla cooldown group is currently active.

pub fn apply_item_use_cooldown(&self, stack: &ItemStack)

Starts the stack’s vanilla use_cooldown, if it has one.

pub(super) fn tick_item_cooldowns(&self)

impl Player

fn begin_respawn_request(&self) -> Option<PendingWorldChangeToken>

fn finish_respawn_request(&self, token: PendingWorldChangeToken)

pub fn respawn(&self)

Schedules a vanilla death respawn for this player.

fn personal_respawn( &self, server: &Server, source_world: &World, ) -> Option<(Arc<World>, PlayerRespawnConfig)>

fn finish_respawn_replacement( self: &Arc<Self>, source_world: &Arc<World>, target_world: &Arc<World>, spawn: DeathRespawnSpawn, pending_token: PendingWorldChangeToken, kind: RespawnRequestKind, ) -> RespawnFinish

fn handle_missing_respawn_block(&self, missing_respawn_block: bool)

fn detach_relationships_for_respawn(&self)

pub fn handle_client_command(self: &Arc<Self>, action: ClientCommandAction)

Handles client commands, requestStats and RequestGameRuleValues are still todo

pub(in player) const fn should_process_respawn( health: f32, ) -> bool

Vanilla accepts a client respawn request only when player health is dead-or-dying. Steel’s death-processed guard is not respawn authority.

pub fn has_seen_credits(&self) -> bool

Returns vanilla ServerPlayer.seenCredits.

pub fn set_seen_credits(&self, seen_credits: bool)

Sets vanilla ServerPlayer.seenCredits.

pub(crate) fn has_won_game(&self) -> bool

Returns vanilla ServerPlayer.wonGame.

fn set_won_game(&self, won_game: bool)

pub(crate) fn show_end_credits(&self)

Starts the vanilla End credits flow.

fn respawn_after_end_credits(self: &Arc<Self>)

impl Player

pub(crate) fn new_respawn_replacement( self: &Arc<Self>, target_world: Arc<World>, restore_all: bool, transfer_inventory: bool, spawn_block_valid: bool, ) -> Arc<Self>

Constructs the detached player entity used by vanilla respawn replacement.

The caller remains responsible for replacing the session binding and world membership. Chat continuity belongs to super::super::PlayerSession and is therefore shared by both incarnations. For a death replacement, transfer_inventory must be keepInventory || old spectator.

fn restore_respawn_state_from( &self, old_player: &Self, restore_all: bool, transfer_inventory: bool, spawn_block_valid: bool, )

fn restore_all_respawn_state_from(&self, old_player: &Self)

fn restore_inventory_experience_and_score_from(&self, old_player: &Self)

fn copy_respawn_scoreboard_tags_from(&self, old_player: &Self)

impl Player

pub(crate) fn reset( self: &Arc<Self>, new_world: Arc<World>, reason: ResetReason, )

Resets the player’s transient state and prepares them for a new world.

This is the shared “clean slate” path used by initial join and world changes that preserve the player incarnation. If the player is currently in a different world, they are removed from the old world first.

pub(crate) fn reset_after_detached_domain_restore<F>( self: &Arc<Self>, new_world: Arc<World>, restore_state: F, )

where F: FnOnce(),

Resets a player already detached from its source domain and restores target-domain state.

fn reset_inner_after<F>( self: &Arc<Self>, new_world: Arc<World>, reason: ResetReason, source_world_detached: bool, restore_state: F, )

where F: FnOnce(),

pub(crate) fn prepare_respawn_replacement(&self, reason: ResetReason)

Prepares a newly allocated player for a death or End-credits respawn.

fn send_respawn_packet(&self, world: &World, reason: ResetReason)

pub(crate) fn spawn( self: &Arc<Self>, position: DVec3, rotation: (f32, f32), reason: ResetReason, ) -> bool

Spawns the player into their current world at the given position.

This is the shared “enter world” path used by initial join, respawn, and world change. Sends position sync, abilities, inventory, time, weather, and adds the player to the world as appropriate for the given reason.

Panics

Panics if the advance_time gamerule is not a bool.

pub(crate) fn spawn_with_velocity( self: &Arc<Self>, position: DVec3, rotation: (f32, f32), velocity: DVec3, reason: ResetReason, ) -> bool

pub(crate) fn spawn_with_velocity_packet( self: &Arc<Self>, position: DVec3, rotation: (f32, f32), velocity: DVec3, reason: ResetReason, packet_position: DVec3, packet_rotation: (f32, f32), packet_velocity: DVec3, relatives: RelativeMovement, ) -> bool

pub(crate) fn synchronize_respawn_replacement( self: &Arc<Self>, position: DVec3, rotation: (f32, f32), )

Sends the spawn synchronization for a fresh respawn replacement without inserting it into world indexes. The replacement transaction owns that step.

fn synchronize_spawn_with_velocity_packet( self: &Arc<Self>, position: DVec3, velocity: DVec3, rotation: (f32, f32), packet_position: DVec3, packet_velocity: DVec3, packet_rotation: (f32, f32), relatives: RelativeMovement, resend_player_context: bool, ) -> Arc<World>

fn send_spawn_state_packets(&self, world: &World)

fn send_time_sync(&self, world: &World)

fn send_default_spawn_position(&self, world: &World)

fn send_weather_sync(&self, world: &World)

pub(in player) fn passenger_ids_for_packet( entity: &dyn Entity, ) -> Vec<i32>

pub(in player) fn send_mob_effect_sync_packet( &self, packet: MobEffectSyncPacket, )

fn send_active_effects_for_self(&self)

pub(in player) fn send_active_effects_for_vehicle( &self, vehicle: &dyn Entity, )

pub(crate) fn send_restored_vehicle_mount_sync(&self, vehicle: &dyn Entity)

pub(in player) fn remove_active_effects_for_vehicle( &self, vehicle: &dyn Entity, )

impl Player

fn apply_post_teleport_transition( &self, post_transition: &TeleportPostTransition, )

pub(crate) fn change_world_within_domain( self: &Arc<Self>, teleport_transition: &TeleportTransition, ) -> bool

Applies an ordinary player transition that has already passed server world-change checks. Cross-domain player state is restored only by the domain-switch workflow.

impl Player

pub(crate) fn set_world(&self, world: Arc<World>)

Sets the world the player is in.

This is used when the correct world isn’t known at construction time (e.g., when loading saved player data determines the actual world).

pub(crate) fn begin_domain_switch(&self, token: PendingWorldChangeToken) -> bool

Marks the player as switching domains if they are not already in a transition.

pub(crate) fn is_domain_switch_queued( &self, token: PendingWorldChangeToken, ) -> bool

Returns whether the queued domain switch still owns this token.

pub(crate) fn is_domain_switch_detached( &self, token: PendingWorldChangeToken, ) -> bool

Returns whether the detached domain switch still owns this token.

pub(crate) fn mark_domain_switch_detached( &self, token: PendingWorldChangeToken, ) -> bool

Marks the token-owned domain switch as detached from its source world.

pub(crate) fn mark_domain_switch_target_handshake( &self, token: PendingWorldChangeToken, ) -> bool

Opens only target-world acknowledgement packets before target insertion completes.

pub(crate) fn mark_domain_switch_live( &self, token: PendingWorldChangeToken, ) -> bool

Marks the token-owned domain switch as live in its target world.

pub(crate) fn finish_domain_switch( &self, token: PendingWorldChangeToken, ) -> bool

Clears a domain switch only if the caller still owns it.

pub(crate) fn begin_respawn_transition( &self, token: PendingWorldChangeToken, ) -> bool

Marks a token as owning respawn preparation if no player transition is active.

pub(crate) fn is_respawn_transition_pending( &self, token: PendingWorldChangeToken, ) -> bool

Returns whether respawn preparation still owns this token.

pub(crate) fn finish_respawn_transition( &self, token: PendingWorldChangeToken, ) -> bool

Clears respawn preparation only if the caller still owns it.

pub(crate) fn finish_player_transition( &self, token: PendingWorldChangeToken, ) -> bool

Clears either player transition kind only if the caller owns its token.

pub(crate) fn defer_death_respawn(&self)

pub(crate) fn retry_deferred_death_respawn(&self)

pub fn is_domain_switching(&self) -> bool

Returns whether this player is currently switching domains.

pub(crate) fn domain_switch_blocks_gameplay(&self) -> bool

Returns whether the current domain-switch phase blocks gameplay work.

pub(crate) fn gate_domain_switch_packet( &self, handshake_packet: bool, perform_respawn: bool, ) -> bool

Gates a packet against the current domain phase.

A dead player’s one-shot respawn request is retained while a queued or detached switch blocks normal gameplay packets.

pub fn has_joined_world(&self) -> bool

Returns whether the server has inserted this player into a world.

pub(crate) fn mark_joined_world(&self) -> bool

Marks this player as inserted into a world.

Returns true when a client-loaded acknowledgement arrived before world admission and was applied by this call.

pub fn has_client_loaded(&self) -> bool

Returns whether the client has sent its play-loaded signal.

pub fn set_client_loaded(&self, client_loaded: bool)

Marks whether the client has loaded into play.

pub fn mark_client_loaded_from_network(&self) -> bool

Applies or buffers the client’s play-loaded acknowledgement.

Returns true when the acknowledgement can run gameplay side effects now.

pub(super) fn tick_client_load_timeout(&self)

impl Player

const fn is_invalid_position( x: f64, y: f64, z: f64, rot_x: f32, rot_y: f32, ) -> bool

fn move_vehicle_packet_from_entity(entity: &dyn Entity) -> CMoveVehicle

fn update_awaiting_teleport(&self) -> bool

Checks if we’re awaiting a teleport confirmation and handles timeout/resend.

Returns true if awaiting teleport (movement should be rejected), false if normal movement processing should continue.

pub fn apply_post_impulse_grace_time(&self, ticks: i32)

Applies vanilla post-impulse movement validation grace.

pub(super) fn reset_vehicle_movement_for_tick(&self)

Resets per-tick vanilla movement validation bases for the controlled root vehicle.

fn should_validate_movement(world: &World, is_fall_flying: bool) -> bool

Checks if movement validation should be performed for this player.

Matches vanilla’s ServerGamePacketListenerImpl.shouldValidateMovement(). Uses the playerMovementCheck and elytraMovementCheck gamerules.

Returns true if movement should be validated, false to skip validation.

pub fn handle_move_player(&self, packet: SMovePlayer)

Handles a move player packet.

Matches vanilla ServerGamePacketListenerImpl.handleMovePlayer().

Panics

Panics if the server cannot restore the player to the last accepted position after rejecting invalid movement. That indicates world entity state refused an authoritative correction.

pub fn handle_move_vehicle(&self, packet: SMoveVehicle)

Handles a controlled-vehicle movement packet.

Matches vanilla ServerGamePacketListenerImpl.handleMoveVehicle().

fn handle_player_known_movement(&self, client_delta: DVec3)

fn record_client_floating( &self, world: &World, y_dist: f64, player_stands_on_something: bool, is_spectator: bool, is_fall_flying: bool, )

fn record_client_vehicle_floating( &self, world: &World, vehicle: &dyn Entity, y_dist: f64, vehicle_rests_on_something: bool, )

fn no_blocks_around_entity(world: &World, entity: &dyn Entity) -> bool

pub(super) fn maximum_flying_ticks(&self) -> i32

Returns how long vanilla permits unsupported floating for this player’s gravity.

fn maximum_flying_ticks_for_gravity(gravity: f64) -> i32

Returns how long vanilla permits unsupported floating for an entity gravity value.

pub(super) fn disconnect_if_floating_too_long(&self) -> bool

Advances vanilla’s floating violation tracker and disconnects when exceeded.

pub(super) fn disconnect_if_vehicle_floating_too_long(&self) -> bool

Advances vanilla’s controlled-vehicle floating tracker and disconnects when exceeded.

pub fn is_awaiting_teleport(&self) -> bool

Returns true if we’re waiting for a teleport confirmation.

pub fn teleport( &self, pos: DVec3, yaw: f32, pitch: f32, ) -> Result<(), EntityMoveError>

Teleports the player to a new position.

Sends a CPlayerPosition packet and waits for client acknowledgment. Until acknowledged, movement packets from the client will be rejected.

Matches vanilla ServerGamePacketListenerImpl.teleport().

pub(crate) fn teleport_with_velocity( &self, pos: DVec3, velocity: DVec3, yaw: f32, pitch: f32, ) -> Result<(), EntityMoveError>

Sends a CPlayerPosition packet with explicit delta movement for vanilla ServerPlayer.teleport(TeleportTransition) paths.

pub(crate) fn teleport_with_velocity_packet( &self, pos: DVec3, velocity: DVec3, rotation: (f32, f32), packet_pos: DVec3, packet_velocity: DVec3, packet_rotation: (f32, f32), relatives: RelativeMovement, ) -> Result<(), EntityMoveError>

Commits resolved server state while sending vanilla packet-relative values.

pub(crate) fn reset_flying_ticks(&self)

Resets vanilla floating violation counters after a successful high-level teleport.

pub fn handle_accept_teleportation(&self, packet: SAcceptTeleportation)

Handles a teleport acknowledgment from the client.

Matches vanilla ServerGamePacketListenerImpl.handleAcceptTeleportPacket().

pub fn last_client_input(&self) -> PlayerInput

Returns the latest vanilla client input snapshot.

pub fn handle_player_input(&self, packet: SPlayerInput)

Handles a player input packet (movement keys, sneaking, sprinting).

pub fn handle_player_command(&self, packet: SPlayerCommand)

Handles a player command packet (sprinting, elytra, leaving bed, etc).

pub fn check_movement_statistics(&self, delta_movement: DVec3)

Checks new player non-riding movement provided to award stats for it, and also causes food exhaustion in some cases.

Mirrors Vanilla’s ServerPlayer.checkMovementStatistics.

pub fn check_riding_statistics(&self, delta_movement: DVec3)

Checks new player riding movement provided to award stats for it, and also causes food exhaustion in some cases.

Mirrors Vanilla’s ServerPlayer.checkRidingStatistics.

fn award_3d_distance_stat( &self, stat: CustomStatRef, delta_movement: DVec3, exhaust_multiplier: f32, )

fn award_horizontal_distance_stat( &self, stat: CustomStatRef, delta_movement: DVec3, exhaust_multiplier: f32, )

fn award_horizontal_distance_stat_with_lower_bound( &self, stat: CustomStatRef, delta_movement: DVec3, exhaust_multiplier: f32, lower_bound: i32, )

impl Player

pub fn set_permission_state( &self, groups: Vec<String>, overrides: PermissionSet, metadata_overrides: PermissionMetadataSet, effective: PermissionSet, effective_metadata: PermissionMetadataSet, ) -> u64

Replaces assigned groups, direct overrides, metadata, and effective state.

pub fn permissions(&self) -> PermissionSet

Returns a snapshot of effective permissions.

pub fn permission_groups(&self) -> Vec<String>

Returns assigned permission groups.

pub(crate) fn is_operator(&self) -> bool

Returns whether the latest published subject state assigns the operator group.

pub fn permission_overrides(&self) -> PermissionSet

Returns direct permission overrides.

pub fn permission_metadata_overrides(&self) -> PermissionMetadataSet

Returns direct permission metadata overrides.

pub fn permission_state_version(&self) -> u64

Returns the current permission snapshot version.

pub fn has_permission(&self, permission: &PermissionExpr) -> bool

Returns whether the player satisfies an expression in their current world.

pub fn has_permission_in( &self, permission: &PermissionExpr, context: &PermissionContext, ) -> bool

Returns whether the player satisfies an expression in an explicit context.

pub fn permission_state( &self, permission: &PermissionExpr, ) -> Option<PermissionState>

Resolves an expression in the player’s current world.

pub fn permission_state_in( &self, permission: &PermissionExpr, context: &PermissionContext, ) -> Option<PermissionState>

Resolves an expression in an explicit context.

pub fn permission_metadata( &self, key: &Identifier, ) -> Option<PermissionMetadataValue>

Resolves one permission metadata value in the player’s current world.

pub fn permission_metadata_in( &self, key: &Identifier, context: &PermissionContext, ) -> Option<PermissionMetadataValue>

Resolves one permission metadata value in an explicit context.

impl Player

pub(crate) fn reset_domain_data_for_first_visit(&self)

Resets domain-scoped gameplay data to the defaults used for a new player.

impl Player

fn take_open_menu_for_callback( &self, expected_container_id: Option<i32>, ) -> Result<Menu, OpenMenuUnavailable>

fn finish_open_menu_callback(&self, menu: Menu)

fn finish_open_menu_removal(&self)

fn run_deferred_menu_actions(&self, actions: Vec<DeferredMenuAction>)

fn queue_deferred_menus( terminal_removal: &mut TerminalMenuRemoval, actions: Vec<DeferredMenuAction>, )

fn begin_menu_open_operation(&self) -> bool

fn finish_menu_open_operation(&self)

pub(in player) fn touch_nearby_items( &self, )

Attempts to pick up nearby item entities.

Mirrors vanilla’s Player.aiStep() item pickup logic:

• Calculates pickup area as bounding box inflated by (1.0, 0.5, 1.0)
• Calls playerTouch() on each entity in range

pub(super) fn resolve_beacon_effect( id: Option<i32>, ) -> Result<Option<MobEffectRef>, ()>

Resolves an optional beacon effect ID, rejecting IDs vanilla’s packet codec would reject.

pub fn handle_set_beacon_packet(&self, packet: SSetBeacon)

Handles a beacon effect selection from the set-beacon packet.

pub fn handle_container_button_click(&self, packet: SContainerButtonClick)

Handles a container button click packet (e.g., enchanting table buttons).

pub fn handle_container_click(&self, packet: SContainerClick)

Handles a container click packet (slot interaction).

fn process_container_click(&self, menu: &mut Menu, packet: SContainerClick)

Processes a container click on any menu implementing the Menu trait.

This is the common implementation shared between inventory menu and external menus (crafting table, chest, etc.).

pub fn handle_container_close(&self, packet: SContainerClose)

Handles a container close packet.

Based on Java’s ServerGamePacketListenerImpl::handleContainerClose.

pub fn handle_rename_item(self: &Arc<Self>, packet: SRenameItem)

Handles an anvil rename packet.

pub fn handle_container_slot_state_changed( &self, packet: SContainerSlotStateChanged, )

Handles a container slot state changed packet (e.g., crafter slot toggle).

pub fn handle_set_creative_mode_slot(&self, packet: SSetCreativeModeSlot)

Handles a creative mode slot set packet.

pub fn handle_set_carried_item(&self, packet: SSetCarriedItem)

Sets selected slot

pub fn send_inventory_to_remote(&self)

Sends all inventory slots to the client (full sync). This should be called when the player first joins.

fn next_container_counter(&self) -> u8

Generates the next container ID (1-100, wrapping around).

Based on Java’s ServerPlayer::nextContainerCounter.

pub fn open_menu( &self, title: impl Into<TextComponent>, create: impl for<'a> FnOnce(MenuOpenContext<'a>) -> Menu + Send + 'static, )

Opens a menu for this player.

Based on Java’s ServerPlayer::openMenu.

Arguments

• title - The display title shown in the open-screen packet.
• create - Factory invoked with the allocated container id, player, and current world. If called by a menu hook, the factory runs after that hook releases its container locks.

Panics

Panics if the created menu uses a different container id than the one allocated for it, or has no menu type (i.e. the player’s own inventory menu, which must never be opened via open_menu).

fn open_menu_inner(&self, pending: PendingMenuOpen)

fn execute_menu_open(&self, pending: PendingMenuOpen)

fn open_prepared_menu(&self, title: TextComponent, menu: Menu)

pub fn crafting_container(&self) -> Shared<CraftingContainer>

A shared handle to the 2x2 crafting grid of the always-open inventory menu.

pub(crate) fn inventory_crafting_handler(&self) -> CraftingHandler

A shared handler for the 2x2 crafting grid of the always-open inventory menu and its result.

pub fn close_container(&self)

Closes the currently open container and returns to the inventory menu.

Based on Java’s ServerPlayer::closeContainer. This sends a close packet to the client.

pub fn do_close_container(&self)

Internal close container logic without sending a packet.

Based on Java’s ServerPlayer::doCloseContainer. Called when the client sends a close packet or when opening a new menu.

pub fn remove_all_menus(&self) -> MenuRemovalStatus

Removes both the base inventory menu and any external menu.

This mirrors Player::remove: base crafting and carried items are handled before the external menu, and menu hooks cannot install a replacement while removal is in progress. The inventory menu remains reusable because Steel keeps one Player across world changes.

pub(in player) fn remove_all_menus_with_disposition( &self, disposition: MenuItemDisposition, ) -> MenuRemovalStatus

fn finish_terminal_menu_main_cleanup(&self, menu: Option<Menu>)

fn try_finish_terminal_menu_removal(&self)

fn close_open_menu(&self, send_packet: bool)

fn remove_open_menu(&self, menu: &mut Menu)

pub fn has_container_open(&self) -> bool

Returns true if the player has an external menu open (not the inventory).

pub fn tick_open_menu(&self)

Runs the open menu’s per-tick hook, if an external menu is open.

Scoped to the opened menu; the base inventory menu is not ticked. Called once per player tick, before syncing inventory changes to the client.

pub fn broadcast_inventory_changes(&self)

Broadcasts inventory changes to the client (incremental sync). This is called every tick to sync only changed slots.

pub(crate) fn request_inventory_resync( &self, slots: impl IntoIterator<Item = usize>, )

Requests direct synchronization of logical player-inventory slots.

pub(in player) fn flush_inventory_resync( &self, )

Sends the latest values for requested logical inventory slots.

pub(crate) fn clear_or_count_matching_items( &self, predicate: &dyn Fn(&ItemStack) -> bool, amount_to_remove: i32, ) -> i32

Removes or counts matching stacks across every location used by vanilla /clear.

pub fn drop_from_selected(&self, all: bool)

Drops an item from the player’s selected hotbar slot.

Based on Java’s ServerPlayer.drop(boolean all).

• all: If true, drops the entire stack (Ctrl+Q). If false, drops one item (Q).

pub fn drop_item( &self, item: ItemStack, throw_randomly: bool, thrown_from_hand: bool, ) -> Option<Arc<ItemEntity>>

Drops an item into the world.

Based on Java’s LivingEntity.drop(ItemStack, boolean randomly, boolean thrownFromHand).

• throw_randomly: If true, the item is thrown in a random direction. If false, it’s thrown in the direction the player is facing.
• thrown_from_hand: If true, sets the thrower and uses a longer pickup delay.

pub fn can_drop_items(&self) -> bool

Returns true if the player can drop items.

Based on Java’s Player.canDropItems(). Returns false if the player is dead, removed, or has a flag preventing item drops.

pub fn returns_menu_items_to_inventory(&self) -> bool

Returns whether items from a closing menu (crafting grid, anvil inputs, cursor) should be placed back into the inventory instead of dropped into the world.

Matches vanilla’s AbstractContainerMenu.dropOrPlaceInInventory: a disconnected player or one removed for any reason except a world change drops the items.

fn default_menu_item_disposition(&self) -> MenuItemDisposition

pub fn add_item_or_drop(&self, item: ItemStack)

Tries to add an item to the player’s inventory, dropping it if it doesn’t fit.

Based on Java’s Inventory.placeItemBackInInventory.

pub fn add_item_or_drop_with_guard( &self, guard: &mut ContainerLockGuard, item: ItemStack, )

Tries to add an item to the player’s inventory using an existing lock guard, dropping it if it doesn’t fit.

Use this variant when you already hold a ContainerLockGuard that includes the player’s inventory to avoid deadlocks.

impl Player

pub(super) fn bed_rule_value_allows_in_world( world: &World, value: BedRuleValue, ) -> bool

pub(super) fn bed_rule_value_allows(&self, value: BedRuleValue) -> bool

fn bed_rule_problem_message(&self) -> Option<TextComponent>

fn bed_sleep_problem(&self) -> BedSleepingProblem

fn is_reachable_bed_block_from_position( player_pos: DVec3, bed_block_pos: BlockPos, ) -> bool

fn bed_in_range(&self, pos: BlockPos, direction: Direction) -> bool

fn bed_in_range_from_position( player_pos: DVec3, pos: BlockPos, direction: Direction, ) -> bool

fn bed_blocked(&self, pos: BlockPos, direction: Direction) -> bool

fn bed_blocked_with_free_at( pos: BlockPos, direction: Direction, free_at: impl FnMut(BlockPos) -> bool, ) -> bool

fn free_at(&self, pos: BlockPos) -> bool

pub(crate) fn stop_sleep_in_bed( &self, forceful_wakeup: bool, update_level_list: bool, )

pub(crate) fn start_sleep_in_bed( &self, pos: BlockPos, ) -> Result<(), BedSleepingProblem>

pub fn respawn_config(&self) -> Option<PlayerRespawnConfig>

Returns the player’s current vanilla respawn configuration.

pub fn set_respawn_position( &self, respawn_config: Option<PlayerRespawnConfig>, show_message: bool, )

Sets the player’s vanilla bed or respawn-anchor target.

pub fn sleep_counter(&self) -> i32

Returns vanilla Player.sleepCounter.

pub fn is_sleeping_long_enough(&self) -> bool

Returns whether this player has slept long enough for vanilla night skip.

fn set_sleep_counter(&self, sleep_counter: i32)

pub(super) fn tick_sleep_counter(&self)

impl Player

pub fn award_stat<R: RegistryExt>( &self, stat_type: StatTypeRef<R>, value: &'static R::Entry, )

where R::Entry: Send + Sync,

Awards one count of a particular stat to this player.

pub fn award_stat_with_count<R: RegistryExt>( &self, stat_type: StatTypeRef<R>, value: &'static R::Entry, count: i32, )

where R::Entry: Send + Sync,

Awards a given amount of a particular stat to this player.

pub fn award_custom_stat(&self, stat: CustomStatRef)

Awards a given amount of a custom stat to this player.

pub fn award_custom_stat_with_count(&self, stat: CustomStatRef, count: i32)

Awards a given amount of a custom stat to this player.

pub(crate) fn award_erased_stat(&self, stat: Stat)

Awards one count of a particular stat to this player.

pub(crate) fn award_erased_stat_with_count(&self, stat: Stat, count: i32)

Awards a given amount of a particular stat to this player.

pub fn reset_stat(&self, stat: Stat)

Resets the counter of a stat from this player to zero.

pub fn reset_custom_stat(&self, stat: CustomStatRef)

Resets the counter of a custom stat from this player to zero.

pub fn mark_all_stats_dirty(&self)

Marks all the stat counters of this player to be dirty. This means that the next time statistics are requested, all tracked stat counters will be sent to the client.

pub fn send_stats(&self)

Sends all the dirty stats of this player to their client, and removes the dirty flag from all of them.

pub fn stats(&self) -> Vec<(Stat, i32)>

Returns the player’s currently tracked stats and their counters. This excludes stats marked as reset (from transferring domains).

impl Player

pub fn send_title(&self, text: impl Into<TextComponent>)

Sends title text to the player.

pub fn send_subtitle(&self, text: impl Into<TextComponent>)

Sends subtitle text to the player.

pub fn send_action_bar(&self, text: impl Into<TextComponent>)

Sends action-bar text to the player.

pub fn send_title_times(&self, fade_in: i32, stay: i32, fade_out: i32)

Sets title animation durations in client ticks.

pub fn clear_titles(&self)

Clears the player’s current title display while preserving its timings.

pub fn reset_titles(&self)

Clears the player’s current title display and resets its timings.

impl Player

const USING_ITEM_FLAG: i8 = 1

const OFF_HAND_ACTIVE_ITEM_FLAG: i8

pub(crate) fn chunk_sender(&self) -> &SyncMutex<ChunkSender>

Returns the chunk sender owned by this player’s connection session.

pub(crate) fn chat(&self) -> &SyncMutex<ChatState>

Returns chat protocol state owned by this connection session.

pub fn active_item_use_hand(&self) -> Option<InteractionHand>

Returns the hand currently driving active item use.

pub fn start_using_item(&self, hand: InteractionHand)

Starts using the item currently held in hand.

fn stop_using_item(&self)

pub fn release_using_item(&self)

Releases the currently used item and invokes its release hook.

fn release_using_item_with_behavior( &self, behavior: &dyn ItemBehavior, active: ActiveItemUseState, )

fn tick_active_item_use(&self)

fn tick_active_item_use_with_behavior( &self, behavior: &dyn ItemBehavior, active: ActiveItemUseState, )

pub fn main_arm(&self) -> HumanoidArm

Returns the player’s configured main arm.

pub(crate) fn shows_hat(&self) -> bool

fn apply_client_information_to_entity_data( data: &mut PlayerEntityData, client_information: &ClientInformation, )

pub fn get_ray_endpoints(&self) -> (DVec3, DVec3)

Computes the start (eye position) and end positions for a raytrace.

pub fn game_mode(&self) -> GameType

Returns the player’s current game mode.

pub fn previous_game_mode(&self) -> Option<GameType>

Returns the player’s previous game mode.

pub(crate) fn restore_game_modes( &self, current: GameType, previous: Option<GameType>, )

Restores current and previous game mode from persistent player data.

fn change_game_mode_state(&self, game_mode: GameType) -> bool

Changes the current game mode and records the old current mode as previous.

pub fn new( gameprofile: GameProfile, connection: Arc<PlayerConnection>, session: Arc<PlayerSession>, world: Arc<World>, server: Weak<Server>, config: Arc<RuntimeConfig>, entity_id: i32, client_information: ClientInformation, ) -> Self

Creates a new player.

pub fn fishing_hook(&self) -> Option<Arc<FishingHookEntity>>

Returns the active fishing hook, clearing a stale reference after removal.

pub fn set_fishing_hook(&self, hook: &Arc<FishingHookEntity>)

Records the hook currently owned by this player.

pub fn clear_fishing_hook(&self, hook: &FishingHookEntity)

Clears hook if it is still this player’s active fishing hook.

pub fn tick(&self)

Ticks the player.

Panics

Panics if the player position cannot be restored after ai_step. Vanilla treats the pre-tick position as authoritative here, so a rejection indicates corrupted entity state.

fn send_experience_packet_if_dirty(&self)

fn tick_death(&self)

Ticks the death animation timer. Vanilla: LivingEntity.tickDeath() (not overridden by ServerPlayer).

fn tick_stats(&self)

Ticks to award stats that are awarded based on ticks.

fn sync_entity_data(&self)

Immediately flushes dirty player entity data to tracking players and self.

fn update_dirty_mob_effect_entity_data(&self)

pub fn handle_custom_payload(&self, _packet: SCustomPayload)

Handles a custom payload packet.

pub fn handle_client_tick_end(&self)

Handles the end of a client tick.

pub fn hurt(&self, world: &World, source: &DamageSource, amount: f32) -> bool

Main entry point for dealing damage. Returns true if damage was applied.

world is vanilla’s explicit ServerLevel argument and controls difficulty scaling and damage gamerules.

fn disabled_damage_game_rule(source: &DamageSource) -> Option<GameRuleRef<bool>>

fn actually_hurt(&self, world: &World, source: &DamageSource, amount: f32)

Applies vanilla player damage reductions and health loss.

fn die(&self, source: &DamageSource)

Vanilla: ServerPlayer.die() (does NOT call super.die()).

pub fn can_eat(&self, can_always_eat: bool) -> bool

Returns whether the Player can eat

pub const fn cleanup(&self)

Cleans up player resources.

pub fn get_world(&self) -> Arc<World>

Returns the world the player is currently in.

pub(crate) fn server(&self) -> Arc<Server>

Returns the server this player belongs to.

pub(crate) fn domain_residence_token(&self) -> DomainResidenceToken

Returns the identity of the player’s current continuous domain stay.

pub(crate) fn advance_domain_residence(&self) -> DomainResidenceToken

Starts a new continuous domain stay and invalidates old restore work.

pub(crate) fn is_domain_residence_current( &self, token: DomainResidenceToken, ) -> bool

Returns whether delayed work still belongs to the current domain stay.

pub(crate) fn install_pending_domain_restores( &self, token: DomainResidenceToken, world: &World, root_vehicle: Option<PersistentRootVehicle>, ender_pearls: Vec<PersistentEnderPearl>, ) -> bool

Installs both persisted restore payloads for a token-owned domain stay.

pub(crate) fn pending_root_vehicle_for_current_world( &self, ) -> Option<PersistentRootVehicle>

pub(crate) fn take_matching_pending_root_vehicle( &self, token: DomainResidenceToken, world: &World, attach: [u8; 16], root_uuid: [u8; 16], ) -> Option<PersistentRootVehicle>

pub(crate) fn pending_ender_pearls(&self) -> Vec<PersistentEnderPearl>

pub(crate) fn remove_pending_ender_pearl(&self, uuid: Uuid)

pub(crate) fn discard_pending_ender_pearl( &self, token: DomainResidenceToken, uuid: Uuid, ) -> bool

pub(crate) fn take_matching_pending_ender_pearl( &self, token: DomainResidenceToken, world: &World, uuid: Uuid, ) -> Option<PersistentEnderPearl>

pub fn register_ender_pearl(&self, pearl: &SharedEntity)

Registers a thrown ender pearl so it persists with this player and re-spawns on login (vanilla ServerPlayer.registerEnderPearl).

pub fn deregister_ender_pearl(&self, uuid: Uuid)

Deregisters a thrown ender pearl once it hits, teleports, or is discarded (vanilla ServerPlayer.deregisterEnderPearl).

pub fn ender_pearls(&self) -> Vec<SharedEntity>

Returns this player’s live, in-flight ender pearls, pruning dead entries.

pub(crate) fn rebind_ender_pearls_to(&self, replacement: &Arc<Self>)

Rebinds live pearls to a fresh respawn incarnation with the same player UUID.

pub(crate) fn save_command_nbt(&self, nbt: &mut NbtCompound)

Appends vanilla-shaped player state used by command NBT predicates.

pub fn store_ender_pearls_with_player(&self)

Marks live ender pearls as stored with this player so chunk saves remove them from world storage and player data remains the sole owner.

pub fn tick_count(&self) -> i32

Returns this player’s local server tick count.

pub(crate) fn take_xp_delay(&self) -> i32

Returns vanilla Player.takeXpDelay.

pub(crate) fn set_take_xp_delay(&self, delay: i32)

Sets vanilla Player.takeXpDelay.

fn primary_step_sound_block_pos(&self, affecting_pos: BlockPos) -> BlockPos

pub fn reset_last_action_time(&self)

Resets the last action time of the player (to the current time).

fn check_idle_timeout(&self)

Trait Implementations

impl DowncastType for Player

const TYPE_KEY: DowncastTypeKey

The process-wide key for this concrete type.

impl Entity for Player

fn play_sound(&self, sound: SoundEventRef, volume: f32, pitch: f32)

Matches vanilla Player.playSound, which excludes the source player.

fn base(&self) -> &EntityBase

Returns a reference to the entity’s shared vanilla base fields.

fn entity_type(&self) -> EntityTypeRef

Gets the entity type containing tracking range, dimensions, etc.

fn base_tick(&self)

Runs vanilla Entity.baseTick pieces Steel currently implements.

fn scoreboard_name(&self) -> String

Returns this entity’s vanilla scoreboard holder name.

fn name(&self) -> TextComponent

Returns this entity’s vanilla name component before team decoration.

fn display_name(&self) -> TextComponent

Returns this entity’s vanilla display name.

fn plain_text_name(&self) -> String

Returns this entity’s plain vanilla name.

fn look_at(&self, from_anchor: EntityAnchor, target: DVec3)

Rotates this entity to face a fixed position.

fn look_at_entity( &self, from_anchor: EntityAnchor, target: &dyn Entity, target_anchor: EntityAnchor, )

Rotates this entity to follow an anchored point on another entity.

fn is_always_ticking(&self) -> bool

Returns whether this entity ignores chunk ticking visibility.

fn update_swimming(&self)

Updates the vanilla swimming shared flag.

fn ride_tick(&self)

Called every game tick while this entity is riding another entity.

fn stop_riding(&self)

Stops riding the current vehicle, if any.

fn teleport_to(&self, pos: DVec3) -> Result<(), EntityMoveError>

Moves this entity to pos, keeping its current rotation. Mirrors vanilla Entity.teleportTo(x, y, z)

fn start_riding(&self, entity_to_ride: &SharedEntity) -> bool

Starts riding entity_to_ride if vanilla boarding rules allow it.

fn broadcast_to_player(&self, player: &Player) -> bool

Returns whether this entity should be broadcast to the given player.

fn fall_sounds(&self) -> (SoundEventRef, SoundEventRef)

Returns vanilla small and big fall sounds for this entity.

fn is_alive(&self) -> bool

Returns whether this entity is alive for vanilla generic entity checks.

fn blocks_building(&self) -> bool

Returns whether this entity obstructs block placement.

fn is_pickable(&self) -> bool

Returns whether this entity can be targeted by picking and interaction raycasts.

fn is_pushable(&self) -> bool

Returns whether this entity participates in vanilla push separation.

fn on_climbable(&self) -> bool

Returns true if vanilla rules consider this entity to be on a climbable block.

fn is_spectator(&self) -> bool

Returns whether this entity is invisible to normal entity selectors.

fn is_flying_player(&self) -> bool

Returns true for vanilla players whose abilities have flying set.

fn fire_immune_ticks(&self) -> i32

Returns vanilla fire immunity cooldown ticks after not being ignited.

fn remaining_fire_ticks_cap(&self) -> Option<i32>

Maximum vanilla remainingFireTicks this entity can store.

fn get_default_gravity(&self) -> f64

Gets the default gravity for this entity type.

fn fire_ignite_extra_ticks(&self) -> i32

Returns extra ticks added by fire-block ignition before 8-second ignition.

fn can_freeze(&self) -> bool

Returns whether this entity may accumulate frozen ticks.

fn make_stuck_in_block(&self, state: BlockStateId, speed_multiplier: DVec3)

Applies vanilla stuck-in-block movement for the next movement pass.

fn can_be_hit_by_projectile(&self) -> bool

Returns whether projectile collision may interact with this entity.

fn uses_client_movement_packets(&self) -> bool

Returns true when movement is driven by serverbound movement packets.

fn can_simulate_movement(&self) -> bool

Returns true when vanilla allows this side to apply movement simulation side effects.

fn is_effective_ai(&self) -> bool

Returns true when vanilla allows this side to run entity AI/travel logic.

fn known_movement(&self) -> DVec3

Returns the movement vector vanilla exposes for block-contact logic.

fn known_speed(&self) -> DVec3

Returns the base-tick displacement vanilla exposes as getKnownSpeed.

fn is_suppressing_bounce(&self) -> bool

Returns true when vanilla landing bounce should be suppressed.

fn cause_fall_damage( &self, fall_distance: f64, damage_modifier: f32, source: &DamageSource, ) -> bool

Applies vanilla fall damage.

fn synced_data(&self) -> Option<&dyn EntitySyncedData>

Returns the synchronized entity-data container for entities with vanilla data accessors.

fn update_data_before_sync(&self)

Updates synchronized entity data just before tracker sync.

fn max_up_step(&self) -> f32

Maximum height this entity can step up during normal movement.

fn backs_off_from_edge(&self) -> bool

Whether movement should apply player-style sneak edge prevention.

fn is_pushed_by_fluid(&self) -> bool

Returns whether vanilla fluid currents can push this entity.

fn is_crouching(&self) -> bool

Returns whether vanilla currently considers this entity crouching.

fn may_interact(&self, world: &World, pos: BlockPos) -> bool

Returns whether this entity may modify the world at a position.

fn is_swimming(&self) -> bool

Returns whether vanilla currently considers this entity swimming.

fn sound_source(&self) -> SoundSource

Returns this entity’s vanilla sound source category.

fn swim_sound(&self) -> SoundEventRef

Returns this entity’s vanilla swim sound.

fn play_step_sound(&self, on_pos: BlockPos, on_state: BlockStateId)

Plays the base vanilla step sound for a block.

fn movement_emission(&self) -> EntityMovementEmission

Returns vanilla movement side effects emitted by this entity.

fn on_below_world(&self)

Runs entity-specific behavior after falling below the world.

fn dimensions_for_pose(&self, pose: EntityPose) -> EntityDimensions

Returns vanilla dimensions for a physical pose.

fn hurt(&self, world: &World, source: &DamageSource, amount: f32) -> bool

Applies damage to this entity.

fn killed_entity( &self, _world: &World, entity: &dyn LivingEntity, _source: &DamageSource, ) -> bool

Runs when this entity causes another entity to die. The entity provided is the entity who was killed.

fn award_kill_score(&self, victim: &dyn Entity, _killing_blow: &DamageSource)

Runs when this entity kills another entity.

fn id(&self) -> i32

Gets the entity’s unique network ID (session-local).

fn generation(&self) -> EntityGeneration

Gets the generation counter of this runtime construction of the entity.

fn uuid(&self) -> Uuid

Gets the UUID of the entity (persistent identifier).

fn nbt_for_data_compare(&self) -> NbtCompound

Returns the vanilla-shaped entity NBT used by command predicates.

fn nbt_for_passenger_save(&self) -> Option<NbtCompound>

Returns passenger-save NBT including the entity type id.

fn position(&self) -> DVec3

Gets the entity’s current position.

fn spawn_position(&self) -> DVec3

Gets the position to send in this entity’s add-entity packet.

fn block_position(&self) -> BlockPos

Gets the entity’s current block position.

fn in_block_state(&self, world: &World) -> BlockStateId

Returns vanilla Entity.getInBlockState.

fn old_position(&self) -> DVec3

Gets the entity position used by vanilla movement traces.

fn bounding_box(&self) -> WorldAabb

Gets the entity’s bounding box for collision queries.

fn is_free(&self, delta: DVec3) -> bool

Returns vanilla Entity.isFree() for the current bounding box shifted by delta.

fn attackable(&self) -> bool

Returns whether this entity can be attacked.

fn skip_attack_interaction(&self, _source: &dyn Entity) -> bool

Returns whether this entity handles and consumes an attack before normal damage.

fn on_above_bubble_column(&self, drag_down: bool, pos: BlockPos)

Applies vanilla Entity.onAboveBubbleColumn.

fn default_on_above_bubble_column(&self, drag_down: bool, pos: BlockPos)

Applies the base entity’s clamped bubble-column surface movement.

fn on_inside_bubble_column(&self, drag_down: bool)

Applies vanilla Entity.onInsideBubbleColumn.

fn default_on_inside_bubble_column(&self, drag_down: bool)

Applies the base entity’s clamped movement inside a bubble-column.

fn is_ignoring_block_triggers(&self) -> bool

Returns whether this entity is excluded from pressure plates and tripwires.

fn piston_push_reaction(&self) -> PushReaction

Returns how vanilla lets this entity respond to piston movement.

fn is_supported_by(&self, pos: BlockPos) -> bool

Returns whether this entity’s main supporting block is pos.

fn can_interact_with_level(&self) -> bool

Returns whether vanilla lets this entity interact with its loaded level.

fn is_invisible(&self) -> bool

Returns vanilla Entity.isInvisible().

fn is_discrete(&self) -> bool

Returns vanilla Entity.isDiscrete().

fn is_allied_to(&self, _other: &dyn Entity) -> bool

Returns whether this entity is allied to other.

fn is_marker_armor_stand(&self) -> bool

Returns whether this entity is a marker armor stand.

fn is_tame_owned_by(&self, _owner: &dyn LivingEntity) -> bool

Returns whether this entity is a tameable animal owned by owner.

fn projectile_owner_uuid(&self) -> Option<Uuid>

Returns the vanilla Projectile owner UUID when this entity exposes one.

fn projectile_owner(&self) -> Option<SharedEntity>

Returns the live vanilla Projectile owner when this entity exposes one.

fn can_be_collided_with(&self, _other: Option<&dyn Entity>) -> bool

Returns whether other can collide with this entity.

fn deflection(&self, _projectile: &dyn Projectile) -> ProjectileDeflection

Returns this entity’s Vanilla projectile deflection behavior.

fn vehicle(&self) -> Option<SharedEntity>

Gets the vehicle this entity is riding, if present.

fn controlled_vehicle(&self) -> Option<SharedEntity>

Returns the vehicle this entity directly controls, if any.

fn is_passenger(&self) -> bool

Returns whether this entity is riding another entity.

fn can_ride(&self, _vehicle: &dyn Entity) -> bool

Returns whether vanilla allows this entity to start riding vehicle.

fn passengers(&self) -> Vec<SharedEntity>

Gets this entity’s direct passengers.

fn count_player_passengers(&self) -> usize

Counts indirect player passengers.

fn has_exactly_one_player_passenger(&self) -> bool

Returns whether this entity has exactly one indirect player passenger.

fn first_passenger(&self) -> Option<SharedEntity>

Gets this entity’s first direct passenger.

fn controlling_passenger(&self) -> Option<SharedEntity>

Returns the living passenger currently controlling this entity, if any.

fn can_control_vehicle(&self) -> bool

Returns whether this entity can control a vehicle it is riding.

fn has_controlling_passenger(&self) -> bool

Returns whether this entity currently has a controlling passenger.

fn is_vehicle(&self) -> bool

Returns whether this entity has any direct passengers.

fn dismounts_underwater(&self) -> bool

Returns vanilla Entity.dismountsUnderwater.

fn has_passenger(&self, passenger: &dyn Entity) -> bool

Returns whether passenger is a direct passenger of this entity.

fn can_add_passenger(&self, _passenger: &dyn Entity) -> bool

Returns whether this entity can accept passenger as a direct passenger.

fn could_accept_passenger(&self) -> bool

Returns whether this entity can accept any passenger.

fn passenger_index(&self, passenger: &dyn Entity) -> Option<usize>

Returns the current direct passenger index for attachment lookup.

fn vehicle_attachment_point(&self, _vehicle: &dyn Entity) -> DVec3

Returns this passenger’s vehicle attachment point.

fn passenger_attachment_point(&self, passenger: &dyn Entity) -> DVec3

Returns this vehicle’s passenger attachment point.

fn passenger_riding_position(&self, passenger: &dyn Entity) -> DVec3

Returns the world position where passenger should ride this vehicle.

fn position_rider(&self, passenger: &dyn Entity)

Repositions a direct passenger from this vehicle’s attachment point.

fn root_vehicle_id(&self) -> i32

Returns this entity’s root vehicle ID, or this entity’s ID when it is not riding.

fn root_vehicle(&self) -> Option<SharedEntity>

Returns this entity’s root vehicle, if this entity is riding one.

fn is_passenger_of_same_vehicle(&self, other: &dyn Entity) -> bool

Returns whether this entity and other share the same root vehicle.

fn has_indirect_passenger(&self, entity: &dyn Entity) -> bool

Returns whether entity is an indirect passenger of this entity.

fn can_collide_with(&self, other: &dyn Entity) -> bool

Returns whether this entity can collide with other.

fn push_impulse(&self, impulse: DVec3)

Adds an impulse to this entity’s velocity and marks velocity for sync.

fn push_entity(&self, entity: &dyn Entity)

Applies vanilla entity-to-entity push separation.

fn make_bounding_box_at(&self, position: DVec3) -> WorldAabb

Builds this entity’s default bounding box at position.

fn get_relative_portal_position( &self, axis: Axis, portal_area: FoundRectangle, ) -> DVec3

Returns vanilla Entity.getRelativePortalPosition.

fn default_tick(&self)

Default vanilla Entity.tick() behavior.

fn tick(&self)

Called every game tick when the entity is in a ticked chunk.

fn default_ride_tick(&self)

The default implementation of Entity.rideTick when not overridden.

fn handle_portal(&self)

Runs vanilla Entity.handlePortal behavior currently implemented by Steel.

fn entity_base_tick(&self)

Runs only vanilla Entity.baseTick behavior.

fn check_below_world(&self)

Applies vanilla below-world handling.

fn check_despawn(&self)

Runs vanilla pre-tick despawn checks.

fn apply_inside_block_effect(&self, effect_type: InsideBlockEffectType)

Applies an inside-block effect queued by vanilla’s step-based collector.

fn level(&self) -> Option<Arc<World>>

Gets the world this entity is in.

fn pack_dirty_entity_data(&self) -> Option<Vec<DataValue>>

Packs dirty entity data for network synchronization.

fn pack_all_entity_data(&self) -> Vec<DataValue>

Packs all non-default entity data for initial spawn.

fn is_removed(&self) -> bool

Returns true if the entity has been marked for removal.

fn begin_pending_world_change(&self) -> Option<PendingWorldChangeToken>

Marks this entity as waiting for a prepared world change.

fn finish_pending_world_change(&self, token: PendingWorldChangeToken) -> bool

Clears a pending world change if it still matches the provided token.

fn is_world_change_pending(&self) -> bool

Returns true while this entity is waiting for a prepared world change.

fn is_world_change_token_pending(&self, token: PendingWorldChangeToken) -> bool

Returns true if the given world-change token is still pending.

fn can_use_portal(&self, ignore_passenger: bool) -> bool

Returns whether this entity may enter a portal.

fn dimension_changing_delay(&self) -> i32

Returns vanilla’s dimension-changing portal cooldown delay in ticks.

fn removal_reason(&self) -> Option<RemovalReason>

Returns why this entity was removed, if it has been removed.

fn set_removed(&self, reason: RemovalReason)

Marks the entity as removed with the given reason.

fn game_event_with_source_entity( &self, event: GameEventRef, source_entity: Option<&dyn Entity>, )

Emits a vanilla game event from this entity’s exact position with an explicit source entity.

fn game_event(&self, event: GameEventRef)

Emits a vanilla game event from this entity’s exact position.

fn kill(&self, world: &World)

Kills this entity using vanilla’s living/non-living class split.

fn restore_owner_reference(&self, _owner: &SharedEntity)

Caches a live owner reference after restoring persisted owner-linked entities. Most entities do not store owner references.

fn set_level_callback(&self, callback: Arc<dyn EntityLevelCallback>)

Sets the level callback for lifecycle events (movement, removal).

fn notify_leash_holder(&self, _leashable: &dyn Entity)

Called by leashables while this entity is their live leash holder.

fn notify_leashee_removed(&self, _leashable: &dyn Entity)

Called when a leashable stops using this entity as its live leash holder.

fn player_touch(self: Arc<Self>, _player: &Arc<Player>)

Called when a player touches this entity during nearby pickup processing.

fn leashables_leashed_to(&self) -> Vec<SharedEntity>

Finds leashable mobs in vanilla’s nearby leash scan whose holder is this entity.

fn leashables_leashed_to_holder_in_area( &self, holder: &dyn Entity, ) -> Vec<SharedEntity>

Finds leashable mobs in this entity’s nearby leash scan whose holder is holder.

fn transfer_leashables_from_holder(&self, old_holder: &dyn Entity) -> bool

Transfers leashables currently held by old_holder to this entity.

fn drop_all_leash_connections(&self, player: Option<&Player>) -> bool

Drops this entity’s leash and all leashables attached to it.

fn shear_off_all_leash_connections(&self, player: Option<&Player>) -> bool

Shears off all leash connections reachable from this entity.

fn attempt_to_shear_equipment( &self, player: &Player, hand: InteractionHand, ) -> bool

Runs vanilla Entity.attemptToShearEquipment.

fn interact( &self, player: &Player, hand: InteractionHand, location: DVec3, ) -> InteractionResult

Handles vanilla entity right-click interaction.

fn interact_entity( &self, player: &Player, hand: InteractionHand, _location: DVec3, ) -> InteractionResult

Handles shared vanilla Entity.interact behavior.

fn is_living_entity(&self) -> bool

Returns true for entities that implement vanilla living-entity behavior.

fn is_abstract_arrow(&self) -> bool

Returns whether this entity belongs to vanilla’s AbstractArrow hierarchy.

fn as_projectile(&self) -> Option<&dyn Projectile>

Returns this entity as a projectile when it has projectile behavior.

fn as_living_entity(&self) -> Option<&dyn LivingEntity>

Returns this entity as a living entity when it has living behavior.

fn as_item_frame(&self) -> Option<&dyn ItemFrame>

Returns this entity as an item frame when it has item-frame behavior.

fn as_player(&self) -> Option<&Player>

Returns this entity as a player when it is the concrete server player.

fn with_weapon_item(&self, visitor: &mut dyn FnMut(Option<&ItemStack>))

Visits vanilla Entity.getWeaponItem without copying inventory state.

fn is_pathfinder_mob(&self) -> bool

Returns true for mobs with pathfinding navigation.

fn as_pathfinder_mob(&self) -> Option<&dyn PathfinderMob>

Returns this entity as a pathfinder mob when it has pathfinding behavior.

fn is_mob(&self) -> bool

Returns true for entities that implement vanilla mob behavior.

fn as_mob(&self) -> Option<&dyn Mob>

Returns this entity as a mob when it has mob behavior.

fn as_leashable(&self) -> Option<&dyn Leashable>

Returns this entity as a Leashable if it has Leashable behavior.

fn is_animal(&self) -> bool

Returns true for entities that implement vanilla animal behavior.

fn as_animal(&self) -> Option<&dyn Animal>

Returns this entity as an animal when it has animal behavior.

fn is_ageable_mob(&self) -> bool

Returns true for entities that implement vanilla ageable-mob behavior.

fn as_ageable_mob(&self) -> Option<&dyn AgeableMob>

Returns this entity as an ageable mob when it has ageable behavior.

fn is_item_steerable(&self) -> bool

Returns true for entities that implement vanilla item-steered boosts.

fn as_item_steerable(&self) -> Option<&dyn ItemSteerable>

Returns this entity as item steerable when it has item-steering behavior.

fn forces_fall_flying_velocity_sync(&self) -> bool

Returns true when vanilla ServerEntity should force velocity sync for fall flying.

fn is_server_driven_movement(&self) -> bool

Returns true when normal server ticks drive this entity’s movement.

fn is_stepping_carefully(&self) -> bool

Returns true when vanilla block step-on hooks should treat this entity as careful.

fn is_descending(&self) -> bool

Returns true when vanilla collision context should treat the entity as descending.

fn set_shared_shift_key_down(&self, shift_key_down: bool)

Sets the vanilla shift-key-down shared flag.

fn set_shared_swimming(&self, swimming: bool)

Sets the vanilla swimming shared flag.

fn default_update_swimming(&self)

Shared body of vanilla Entity.updateSwimming for player overrides.

fn set_shared_sprinting(&self, sprinting: bool)

Sets the vanilla sprinting shared flag.

fn set_shared_fall_flying(&self, fall_flying: bool)

Sets the vanilla fall-flying shared flag.

fn is_flying_vehicle(&self) -> bool

Returns whether vanilla excludes this vehicle from floating kicks.

fn tick_count(&self) -> i32

Returns vanilla Entity.tickCount.

fn is_first_tick(&self) -> bool

Returns whether this entity has not completed its first tick.

fn set_first_tick(&self, first_tick: bool)

Sets whether this entity has not completed its first tick.

fn advance_tick_count(&self)

Advances vanilla Entity.tickCount.

fn rotation(&self) -> (f32, f32)

Gets the entity’s rotation as (yaw, pitch) in degrees.

fn set_rotation(&self, rotation: (f32, f32))

Sets the entity’s rotation as (yaw, pitch) in degrees.

fn direction_yaw(&self) -> Direction

Gets the nearest horizontal direction to the entity’s yaw (horizontal rotation).

fn head_yaw(&self) -> f32

Returns vanilla Entity.getYHeadRot.

fn spawn_data(&self) -> i32

Extra spawn-packet data used by vanilla for entity-specific construction.

fn get_eye_height(&self) -> f64

Gets the eye height for this entity.

fn get_fluid_jump_threshold(&self) -> f64

Returns vanilla Entity.getFluidJumpThreshold().

fn get_eye_y(&self) -> f64

Gets the Y coordinate of the entity’s eyes.

fn is_in_wall(&self) -> bool

Mirrors vanilla Entity.isInWall.

fn calculate_view_vector(&self, pitch_degrees: f32, yaw_degrees: f32) -> DVec3

Calculates vanilla Entity.calculateViewVector().

fn look_angle(&self) -> DVec3

Returns vanilla Entity.getLookAngle().

fn hand_holding_item_angle(&self, item: ItemRef) -> DVec3

Returns the vanilla offset for the hand holding item.

fn velocity(&self) -> DVec3

Gets the entity’s velocity in blocks per tick.

fn set_velocity(&self, velocity: DVec3)

Sets the entity’s velocity.

fn needs_velocity_sync(&self) -> bool

Returns true when vanilla ServerEntity should consider sending velocity.

fn mark_velocity_sync(&self)

Marks velocity for vanilla ServerEntity synchronization.

fn clear_velocity_sync(&self)

Clears the vanilla velocity sync marker after send processing.

fn hurt_marked(&self) -> bool

Returns true when vanilla hurt-marked velocity sync is pending.

fn mark_hurt(&self)

Marks this entity as hurt for vanilla self-inclusive motion sync.

fn clear_hurt_mark(&self)

Clears the vanilla hurt-marked motion sync flag.

fn fall_distance(&self) -> f64

Returns accumulated vanilla fall distance.

fn is_in_powder_snow(&self) -> bool

Returns whether this entity is currently inside powder snow.

fn was_in_powder_snow(&self) -> bool

Returns whether this entity was inside powder snow during the previous base tick.

fn set_fall_distance(&self, fall_distance: f64)

Sets accumulated vanilla fall distance.

fn reset_fall_distance(&self)

Resets accumulated vanilla fall distance.

fn check_fall_distance_accumulation(&self)

Mirrors vanilla Entity.checkFallDistanceAccumulation().

fn fire_freeze_state(&self) -> EntityFireFreezeState

Returns the current vanilla fire/freeze state.

fn remaining_fire_ticks(&self) -> i32

Returns vanilla remainingFireTicks.

fn set_remaining_fire_ticks(&self, remaining_fire_ticks: i32)

Sets vanilla remainingFireTicks.

fn ticks_frozen(&self) -> i32

Returns synchronized vanilla TicksFrozen.

fn set_ticks_frozen(&self, ticks_frozen: i32)

Sets synchronized vanilla TicksFrozen.

fn fire_immune(&self) -> bool

Returns whether this entity is immune to fire effects and fire damage.

fn should_play_lava_hurt_sound(&self) -> bool

Returns whether vanilla should play this entity’s lava hurt sound.

fn lava_hurt(&self)

Applies vanilla lava-contact damage after lava ignition effects.

fn is_on_fire(&self) -> bool

Returns whether the entity is on fire on the server.

fn has_visual_fire(&self) -> bool

Returns vanilla hasVisualFire.

fn is_freezing(&self) -> bool

Returns whether the entity has any frozen ticks.

fn default_can_freeze(&self) -> bool

Returns vanilla Entity.canFreeze() without living-equipment overrides.

fn ticks_required_to_freeze(&self) -> i32

Returns vanilla getTicksRequiredToFreeze.

fn is_fully_frozen(&self) -> bool

Returns whether this entity has reached full-freeze duration.

fn percent_frozen(&self) -> f32

Returns vanilla Entity.getPercentFrozen.

fn clear_freeze(&self)

Clears accumulated freezing.

fn clear_fire(&self)

Clears fire without resetting the vanilla fire immunity cooldown.

fn ignite_for_ticks(&self, number_of_ticks: i32)

Ignites this entity for a vanilla tick duration.

fn sync_base_fire_freeze_entity_data(&self)

Projects base fire/freeze state into generated synced entity data.

fn sync_base_entity_data(&self)

Projects all base-owned synchronized fields into generated entity data.

fn is_in_water(&self) -> bool

Returns true if this entity is currently touching water.

fn is_in_lava(&self) -> bool

Returns true if this entity is currently touching lava.

fn is_eye_in_water(&self) -> bool

Returns true if this entity’s eyes are currently inside water.

fn is_eye_in_lava(&self) -> bool

Returns true if this entity’s eyes are currently inside lava.

fn is_under_water(&self) -> bool

Returns vanilla underwater state.

fn fluid_contact(&self) -> EntityFluidContact

Returns cached fluid contact from the last entity fluid refresh.

fn refresh_fluid_contact(&self) -> EntityFluidContact

Refreshes cached fluid contact from this entity’s current bounding box.

fn refresh_fluid_contact_for_base_tick(&self) -> EntityFluidContact

Refreshes cached fluid contact with vanilla base-tick eye-water history.

fn scan_and_store_fluid_contact( &self, advance_eye_water_history: bool, ) -> EntityFluidContact

Scans current fluid contact and stores it on the entity base.

fn apply_fluid_current_for_base_tick( &self, world: &Arc<World>, contact: EntityFluidContact, )

Applies vanilla water/lava current impulses from the base-tick fluid scan.

fn apply_fluid_current_impulse(&self, impulse: DVec3)

Applies a non-zero fluid current impulse and marks velocity sync.

fn is_fall_damage_immune(&self) -> bool

Returns true if this entity type ignores vanilla fall damage.

fn propagate_fall_to_passengers( &self, fall_distance: f64, damage_modifier: f32, source: &DamageSource, )

Propagates vanilla fall-damage handling to passengers.

fn on_ground(&self) -> bool

Returns true if the entity is on the ground.

fn horizontal_collision(&self) -> bool

Returns true if the last movement was clipped horizontally.

fn vertical_collision(&self) -> bool

Returns true if the last movement was clipped vertically.

fn vertical_collision_below(&self) -> bool

Returns true if the last vertical collision was below the entity.

fn no_physics(&self) -> bool

Returns true when movement bypasses collision physics.

fn is_affected_by_blocks(&self) -> bool

Returns true when vanilla block-contact effects may run for this entity.

fn set_no_physics(&self, no_physics: bool)

Sets whether this entity bypasses collision physics.

fn update_no_physics_from_current_collision(&self)

Updates item-style noPhysics from the entity’s current collision state.

fn move_towards_closest_space(&self, x: f64, y: f64, z: f64)

Nudges velocity toward the closest non-full collision block.

fn default_make_stuck_in_block( &self, _state: BlockStateId, speed_multiplier: DVec3, )

Default vanilla stuck-in-block movement for the next movement pass.

fn apply_effects_from_blocks(&self)

Applies current block-contact effects to this entity.

fn apply_effects_from_blocks_between(&self, from: DVec3, to: DVec3)

Applies block-contact effects for one explicit movement segment.

fn apply_effects_from_blocks_for_last_movements(&self)

Replays the last finalized block-contact movement list.

fn set_on_ground(&self, on_ground: bool)

Sets whether the entity is on the ground.

fn set_on_ground_with_movement( &self, on_ground: bool, horizontal_collision: bool, movement: DVec3, )

Sets ground and horizontal collision flags from accepted movement.

fn default_apply_accepted_client_movement( &self, world: &Arc<World>, accepted: AcceptedClientMovement, ) -> Result<AcceptedClientMovementOutcome, EntityMoveError>

Default final state application for accepted client-authored movement.

fn apply_accepted_client_movement( &self, world: &Arc<World>, accepted: AcceptedClientMovement, ) -> Result<AcceptedClientMovementOutcome, EntityMoveError>

Applies final state accepted from a client-authored movement packet.

fn apply_accepted_client_vehicle_movement( &self, world: &Arc<World>, accepted: AcceptedClientMovement, ) -> Result<AcceptedClientMovementOutcome, EntityMoveError>

Applies final state accepted from a controlled-vehicle movement packet.

fn try_set_position(&self, pos: DVec3) -> Result<(), EntityMoveError>

Attempts to set the entity’s position through world lifecycle validation.

fn set_old_position_to_current(&self)

Sets the vanilla movement-trace old position to the current position.

fn set_old_position(&self, old_position: DVec3)

Sets the vanilla movement-trace old position explicitly.

fn remove_latest_movement_recording(&self)

Removes the latest movement segment recorded this tick.

fn on_pos(&self, offset: f32) -> Option<BlockPos>

Returns the block position this entity is standing on.

fn block_pos_below_that_affects_movement(&self) -> Option<BlockPos>

Returns the block position used for movement-affecting block properties.

fn on_pos_legacy(&self) -> Option<BlockPos>

Returns vanilla getOnPosLegacy(), used by fall/step block hooks.

fn block_speed_factor(&self) -> f32

Returns the vanilla block speed factor applied after movement.

fn block_jump_factor(&self) -> f32

Returns vanilla Entity.getBlockJumpFactor().

fn pose(&self) -> EntityPose

Returns this entity’s physical pose.

fn refresh_dimensions(&self)

Refreshes dimensions for the current physical pose.

fn fudge_position_after_size_change( &self, previous_dimensions: EntityDimensions, ) -> bool

Vanilla Entity.fudgePositionAfterSizeChange.

fn set_pose(&self, pose: EntityPose)

Sets the physical pose and synchronized pose metadata.

fn is_on_rails(&self) -> bool

Returns whether this entity is on rails.

fn is_state_climbable(&self, state: BlockStateId) -> bool

Returns whether a block state is climbable for base movement effects.

fn air_supply(&self) -> i32

Returns the synchronized vanilla Air value.

fn set_air_supply(&self, air_supply: i32)

Sets the synchronized vanilla Air value.

fn max_air_supply(&self) -> i32

Returns this entity’s maximum vanilla air supply.

fn portal_cooldown(&self) -> i32

Returns the vanilla portal cooldown in ticks.

fn set_portal_cooldown(&self, portal_cooldown: i32)

Sets the vanilla portal cooldown in ticks.

fn is_on_portal_cooldown(&self) -> bool

Returns whether the entity is on vanilla portal cooldown.

fn reset_portal_cooldown(&self)

Resets vanilla portal cooldown to this entity’s dimension-changing delay.

fn set_as_inside_portal(&self, portal: PortalKind, entry_position: BlockPos)

Marks this entity as inside a vanilla portal during the current tick.

fn custom_name(&self) -> Option<TextComponent>

Returns this entity’s optional vanilla custom name.

fn set_custom_name(&self, custom_name: Option<TextComponent>)

Sets this entity’s optional vanilla custom name.

fn is_custom_name_visible(&self) -> bool

Returns whether vanilla renders this entity’s custom name.

fn set_custom_name_visible(&self, visible: bool)

Sets whether vanilla renders this entity’s custom name.

fn has_glowing_tag(&self) -> bool

Returns whether this entity has the server-owned vanilla glowing tag.

fn set_glowing_tag(&self, glowing: bool)

Sets this entity’s server-owned vanilla glowing tag.

fn tags(&self) -> Vec<String>

Returns a snapshot of this entity’s vanilla scoreboard tags.

fn add_tag(&self, tag: String) -> bool

Adds a vanilla scoreboard tag.

fn remove_tag(&self, tag: &str) -> bool

Removes a vanilla scoreboard tag.

fn custom_data(&self) -> NbtCompound

Returns a snapshot of this entity’s vanilla custom data.

fn set_custom_data(&self, custom_data: NbtCompound)

Replaces this entity’s vanilla custom data.

fn is_silent(&self) -> bool

Returns whether sounds from this entity are suppressed.

fn set_silent(&self, silent: bool)

Sets whether sounds from this entity are suppressed.

fn broadcast_entity_event(&self, event: EntityStatus)

Broadcasts a vanilla entity event/status packet near this entity.

fn play_entity_on_fire_extinguished_sound(&self)

Plays vanilla’s extinguished-on-fire entity sound.

fn play_block_step_sound(&self, block_state: BlockStateId)

Plays a vanilla block step sound at this entity’s current position.

fn play_muffled_step_sound(&self, block_state: BlockStateId)

Plays vanilla’s muffled secondary step sound.

fn play_combination_step_sounds( &self, primary_step_sound: BlockStateId, secondary_step_sound: BlockStateId, )

Plays vanilla’s combination primary and secondary step sounds.

fn walking_step_sound(&self, pos: BlockPos, block_state: BlockStateId)

Plays vanilla walking step sounds, including amethyst chimes.

fn play_amethyst_step_sound(&self)

Plays vanilla amethyst step chime when its cooldown permits it.

fn water_swim_sound(&self)

Plays vanilla swim sound from movement emission.

fn play_swim_sound(&self, volume: f32)

Plays this entity’s swim sound at the given volume.

fn is_flapping(&self) -> bool

Returns whether the entity is currently flapping.

fn on_flap(&self)

Runs entity-specific flap side effects.

fn process_flapping_movement(&self)

Processes vanilla flap movement side effects.

fn next_step(&self) -> f32

Returns the next step threshold after movement side effects are produced.

fn apply_movement_emission_and_play_sound( &self, emission: EntityMovementEmission, clipped_movement: DVec3, effect_pos: BlockPos, effect_state: BlockStateId, )

Applies vanilla movement sounds and game events after a completed move.

fn apply_movement_side_effects_after_move( &self, world: &World, actual_movement: DVec3, )

Applies movement side effects after vanilla collision and landing updates.

fn vibration_and_sound_effects_from_block( &self, pos: BlockPos, block_state: BlockStateId, should_sound: bool, should_vibrate: bool, clipped_movement: DVec3, ) -> bool

Emits step side effects from a candidate movement-effect block.

fn is_no_gravity(&self) -> bool

Returns true if gravity is disabled for this entity.

fn set_no_gravity(&self, no_gravity: bool)

Sets the shared vanilla NoGravity flag.

fn is_invulnerable(&self) -> bool

Returns the shared vanilla Invulnerable flag.

fn set_invulnerable(&self, invulnerable: bool)

Sets the shared vanilla Invulnerable flag.

fn get_gravity(&self) -> f64

Gets the current gravity value.

fn apply_gravity(&self)

Applies gravity to the entity’s velocity.

fn move_relative(&self, speed: f32, input: DVec3)

Applies vanilla Entity.moveRelative().

fn move_without_physics(&self, delta: DVec3) -> Option<MoveResult>

Moves the entity without collision physics.

fn move_entity(&self, mover_type: MoverType, delta: DVec3) -> Option<MoveResult>

Moves the entity with collision detection.

fn apply_fall_damage_after_move( &self, result: &MoveResult, world: &Arc<World>, ) -> bool

Applies vanilla fall-distance bookkeeping after accepted movement.

fn reset_fall_distance_on_resetting_clip( &self, world: &Arc<World>, movement: DVec3, )

Resets fall distance when vanilla’s fall-damage-resetting clip hits.

fn do_check_fall_damage( &self, movement: DVec3, on_ground: bool, world: &Arc<World>, ) -> bool

Mirrors vanilla Entity.doCheckFallDamage.

fn refresh_supporting_block_for_fall_damage( &self, movement: DVec3, on_ground: bool, )

Refreshes vanilla supporting-block state before fall-damage side effects.

fn check_fall_damage( &self, vertical_movement: f64, on_ground: bool, on_state: BlockStateId, pos: BlockPos, world: &Arc<World>, )

Mirrors vanilla Entity.checkFallDamage.

fn ground_contact_after_movement( &self, on_ground: bool, movement: Option<DVec3>, ) -> EntityGroundContact

Computes vanilla support state for an on-ground update.

fn check_supporting_block( &self, on_ground: bool, movement: Option<DVec3>, world: &Arc<World>, ) -> EntityGroundContact

Mirrors vanilla Entity.checkSupportingBlock.

fn spawn_at_location( &self, item: ItemStack, y_offset: f64, ) -> Option<Arc<ItemEntity>>

Spawns an item at this entity’s location.

fn spawn_at_location_with_offset( &self, item: ItemStack, offset: DVec3, ) -> Option<Arc<ItemEntity>>

Spawns an item at this entity’s location plus a vanilla attachment offset.

fn save_additional(&self, _nbt: &mut NbtCompound)

Saves type-specific entity data to NBT.

fn load_additional(&self, _nbt: BorrowedNbtCompoundView<'_, '_>)

Loads type-specific entity data from NBT.

fn apply_implicit_item_components(&self, _item_stack: &ItemStack)

Applies entity-specific implicit components carried by an item stack.

fn apply_spawn_data(&self, nbt: BorrowedNbtCompoundView<'_, '_>)

Applies the merged entity data used by vanilla TypedEntityData.loadInto.

fn is_invulnerable_to_base(&self, source: &DamageSource) -> bool

Returns vanilla Entity.isInvulnerableToBase.

fn source_is_creative_player(&self, source: &DamageSource) -> bool

Returns vanilla DamageSource.isCreativePlayer: whether the damage’s causing entity is a player with infinite materials.

fn distance_to_sqr(&self, pos: DVec3) -> f64

Calculates the squared Euclidean distance from this entity’s position to the given position.

fn snap_to(&self, position: DVec3, yaw: f32, pitch: f32)

Sets position and rotation, matching vanilla Entity.snapTo.

impl LivingEntity for Player

fn living_synced_data(&self) -> Option<&dyn LivingEntitySyncedData>

Returns synchronized data declared by vanilla LivingEntity.

fn tick_living_entity(&self)

Runs vanilla LivingEntity.tick.

fn get_health(&self) -> f32

Gets the current health of the entity.

fn set_health(&self, health: f32)

Sets the health of the entity, clamped between 0 and max health.

fn living_base(&self) -> &LivingEntityBase

Returns a reference to the shared LivingEntityBase that holds living runtime state such as attributes, cached movement speed, damage cooldown, and death animation counters.

fn is_using_item(&self) -> bool

Checks if the entity is currently using an item.

fn get_luck(&self) -> f32

Vanilla LivingEntity.getLuck - non-players contribute no luck to loot.

fn can_be_seen_as_enemy(&self) -> bool

Returns vanilla LivingEntity.canBeSeenAsEnemy().

fn is_invulnerable_to(&self, world: &World, source: &DamageSource) -> bool

Returns whether this living entity ignores a damage source.

fn hurt_armor(&self, source: &DamageSource, damage: f32)

Damages equipment that participates in vanilla armor absorption.

fn actually_hurt(&self, world: &World, source: &DamageSource, amount: f32)

Applies damage after vanilla reductions.

fn hurt_broadcast_chunk(&self) -> ChunkPos

Returns the chunk used for vanilla nearby hurt broadcasts.

fn die(&self, source: &DamageSource)

Processes vanilla living death side effects.

fn with_equipment_slot( &self, slot: EquipmentSlot, visitor: &mut dyn FnMut(&ItemStack), )

Visits the item in a vanilla living-entity equipment slot.

fn with_equipment_slot_mut( &self, slot: EquipmentSlot, visitor: &mut dyn FnMut(&mut ItemStack), )

Mutates the item in a vanilla living-entity equipment slot.

fn interact_living_entity_with_equippable( &self, player: &Player, hand: InteractionHand, ) -> InteractionResult

Runs vanilla’s equippable ItemStack.interactLivingEntity branch.

fn has_infinite_materials(&self) -> bool

Returns whether equipment durability should be skipped for this entity.

fn handle_extra_items_created_on_use(&self, extra: ItemStack)

Mirrors vanilla LivingEntity.handleExtraItemsCreatedOnUse, which is a no-op for non-player mobs.

fn get_absorption_amount(&self) -> f32

Gets the absorption amount (extra health from effects like absorption).

fn set_absorption_amount(&self, amount: f32)

Sets the absorption amount.

fn is_affected_by_fluids(&self) -> bool

Returns vanilla LivingEntity.isAffectedByFluids().

fn can_glide(&self) -> bool

Mirrors vanilla LivingEntity.canGlide().

fn is_immobile(&self) -> bool

Returns vanilla LivingEntity.isImmobile().

fn stop_sleeping(&self)

Stops the entity from sleeping.

fn jump_from_ground(&self)

Mirrors vanilla LivingEntity.jumpFromGround().

fn ai_step(&self) -> Option<MoveResult>

Mirrors vanilla LivingEntity.aiStep().

fn travel(&self, input: DVec3) -> Option<MoveResult>

Mirrors vanilla LivingEntity.travel().

fn get_flying_speed(&self) -> f32

Returns vanilla LivingEntity.getFlyingSpeed().

fn on_equipped_item_broken(&self, item: ItemRef, slot: EquipmentSlot)

Called after an equipped item breaks.

fn living_rotation_state(&self) -> LivingRotationState

Returns vanilla living body/head rotation state.

fn y_body_rot(&self) -> f32

Returns vanilla LivingEntity.yBodyRot.

fn set_y_body_rot(&self, y_body_rot: f32)

Sets vanilla LivingEntity.yBodyRot.

fn y_head_rot(&self) -> f32

Returns vanilla LivingEntity.yHeadRot.

fn set_y_head_rot(&self, y_head_rot: f32)

Sets vanilla LivingEntity.yHeadRot.

fn advance_living_rotation_for_base_tick(&self)

Copies current living body/head rotations to vanilla old-rotation state.

fn advance_attack_animation_for_base_tick(&self)

Copies current attack animation to vanilla old attack-animation state.

fn base_tick_living_entity(&self)

Runs vanilla LivingEntity.baseTick.

fn living_swing_state(&self) -> LivingSwingState

Returns vanilla arm-swing animation state.

fn current_swing_duration(&self) -> i32

Returns vanilla LivingEntity.getCurrentSwingDuration.

fn swing(&self, hand: InteractionHand, update_self: bool)

Runs vanilla LivingEntity.swing.

fn update_swing_time(&self)

Runs vanilla LivingEntity.updateSwingTime.

fn attributes(&self) -> &SyncMutex<AttributeMap>

Returns a reference to this entity’s attribute map.

fn pack_syncable_attributes(&self) -> Vec<AttributeSnapshot>

Packs syncable attributes for initial spawn pairing.

fn drain_dirty_syncable_attributes(&self) -> Vec<AttributeSnapshot>

Drains syncable dirty attributes for per-tick tracking updates.

fn drain_dirty_mob_effects(&self) -> Vec<MobEffectSyncChange>

Drains dirty mob-effect packet changes for vanilla recipients.

fn pack_all_equipment(&self) -> Vec<EquipmentSlotItem>

Packs non-empty equipment slots for initial spawn pairing.

fn drain_dirty_equipment(&self) -> Vec<EquipmentSlotItem>

Drains equipment slots that changed since the last tracker sync.

fn save_equipment(&self, nbt: &mut NbtCompound)

Saves equipment slots to NBT.

fn load_equipment(&self, nbt: BorrowedNbtCompoundView<'_, '_>)

Loads equipment slots from NBT.

fn save_command_nbt(&self, nbt: &mut NbtCompound)

Appends vanilla-shaped living state used by command NBT predicates.

fn get_max_health(&self) -> f32

Gets the maximum health from the attribute system.

fn no_action_time(&self) -> i32

Returns vanilla LivingEntity.noActionTime.

fn set_no_action_time(&self, no_action_time: i32)

Sets vanilla LivingEntity.noActionTime.

fn increment_no_action_time(&self)

Increments vanilla LivingEntity.noActionTime.

fn heal(&self, amount: f32)

Heals the entity by the specified amount.

fn is_dead_or_dying(&self) -> bool

Returns true if the entity is dead or dying (health <= 0).

fn is_baby(&self) -> bool

Returns vanilla LivingEntity.isBaby().

fn sheep_loot_state(&self) -> Option<(DyeColor, bool)>

Returns the vanilla sheep loot predicate state (minecraft:components.sheep/color together with minecraft:type_specific/sheep.sheared), when this entity is a sheep.

fn chicken_loot_variant(&self) -> Option<&Identifier>

Returns this entity’s minecraft:components.chicken/variant key for the entity loot context, when it is a chicken.

fn sound_volume(&self) -> f32

Returns vanilla LivingEntity.getSoundVolume.

fn voice_pitch(&self) -> f32

Returns vanilla LivingEntity.getVoicePitch.

fn hurt_sound(&self, _source: &DamageSource) -> Option<SoundEventRef>

Returns vanilla LivingEntity.getHurtSound.

fn death_sound(&self) -> Option<SoundEventRef>

Returns vanilla LivingEntity.getDeathSound.

fn make_sound(&self, sound: Option<SoundEventRef>)

Runs vanilla LivingEntity.makeSound.

fn play_hurt_sound(&self, source: &DamageSource)

Runs vanilla LivingEntity.playHurtSound.

fn play_death_sound(&self)

Plays vanilla’s death sound for this living entity.

fn get_age_scale(&self) -> f32

Returns vanilla LivingEntity.getAgeScale().

fn get_scale(&self) -> f32

Returns vanilla LivingEntity.getScale().

fn is_alive(&self) -> bool

Returns true if the entity is alive (health > 0).

fn get_armor_cover_percentage(&self) -> f32

Returns vanilla LivingEntity.getArmorCoverPercentage().

fn get_visibility_percent(&self, targeting_entity: Option<&dyn Entity>) -> f64

Returns vanilla LivingEntity.getVisibilityPercent().

fn disguise_head_matches_targeting_entity( &self, targeting_entity: Option<&dyn Entity>, ) -> bool

Returns whether the equipped head item reduces visibility to targeting_entity.

fn can_be_seen_by_anyone(&self) -> bool

Returns vanilla LivingEntity.canBeSeenByAnyone().

fn can_attack(&self, target: &dyn LivingEntity) -> bool

Returns vanilla LivingEntity.canAttack().

fn last_damage_source(&self) -> Option<DamageSource>

Returns vanilla LivingEntity.getLastDamageSource().

fn set_last_hurt_by_player(&self, player_uuid: Uuid, time_to_remember: i32)

Sets vanilla LivingEntity.lastHurtByPlayer.

fn last_hurt_by_player_memory_time(&self) -> i32

Returns vanilla LivingEntity.lastHurtByPlayerMemoryTime.

fn last_hurt_by_player_uuid(&self) -> Option<Uuid>

Returns vanilla LivingEntity.lastHurtByPlayer, if still remembered.

fn last_hurt_by_mob(&self) -> Option<SharedEntity>

Returns vanilla LivingEntity.lastHurtByMob.

fn last_hurt_by_mob_timestamp(&self) -> i32

Returns vanilla LivingEntity.lastHurtByMobTimestamp.

fn set_last_hurt_by_mob(&self, target: Option<&SharedEntity>)

Sets vanilla LivingEntity.lastHurtByMob.

fn last_hurt_mob(&self) -> Option<SharedEntity>

Returns vanilla LivingEntity.lastHurtMob.

fn last_hurt_mob_timestamp(&self) -> i32

Returns vanilla LivingEntity.lastHurtMobTimestamp.

fn set_last_hurt_mob(&self, target: Option<&SharedEntity>)

Sets vanilla LivingEntity.lastHurtMob.

fn resolve_mob_responsible_for_damage( &self, world: &World, source: &DamageSource, )

Resolves vanilla LivingEntity.resolveMobResponsibleForDamage.

fn resolve_player_responsible_for_damage( &self, world: &World, source: &DamageSource, )

Resolves vanilla LivingEntity.resolvePlayerResponsibleForDamage.

fn has_line_of_sight(&self, target: &dyn Entity) -> bool

Returns vanilla LivingEntity.hasLineOfSight().

fn has_line_of_sight_with( &self, target: &dyn Entity, block_shape: ClipBlockShape, fluid: ClipFluid, target_eye_y: f64, ) -> bool

Returns vanilla line-of-sight with explicit clip options.

fn default_is_invulnerable_to(&self, source: &DamageSource) -> bool

Returns vanilla base living-entity invulnerability.

fn hurt_server(&self, world: &World, source: &DamageSource, amount: f32) -> bool

Main vanilla living-entity damage entry point.

fn before_actually_hurt(&self, _source: &DamageSource, _amount: f32)

Hook before applying damage after vanilla reductions.

fn do_hurt_equipment( &self, source: &DamageSource, damage: f32, slots: &[EquipmentSlot], )

Mirrors vanilla LivingEntity.doHurtEquipment.

fn get_damage_after_armor_absorb( &self, source: &DamageSource, damage: f32, ) -> f32

Mirrors vanilla LivingEntity.getDamageAfterArmorAbsorb.

fn get_damage_after_magic_absorb( &self, source: &DamageSource, damage: f32, ) -> f32

Mirrors vanilla LivingEntity.getDamageAfterMagicAbsorb.

fn apply_damage_knockback(&self, source: &DamageSource)

Applies vanilla hurt knockback for a damage source.

fn damage_knockback_direction(&self, source: &DamageSource) -> (f64, f64)

Returns the horizontal direction used by vanilla damage knockback.

fn knockback(&self, power: f64, xd: f64, zd: f64)

Applies vanilla LivingEntity.knockback.

fn knockback_resistance(&self) -> f64

Returns vanilla knockback resistance.

fn indicate_damage(&self, _xd: f64, _zd: f64)

Mirrors vanilla LivingEntity.indicateDamage.

fn broadcast_damage_event(&self, world: &World, source: &DamageSource)

Broadcasts vanilla damage-event metadata near this entity.

fn broadcast_hurt_animation(&self, world: &World)

Broadcasts vanilla hurt animation near this entity.

fn should_drop_loot(&self, world: &World) -> bool

Returns vanilla LivingEntity.shouldDropLoot.

fn should_drop_experience(&self) -> bool

Returns vanilla LivingEntity.shouldDropExperience.

fn is_always_experience_dropper(&self) -> bool

Returns vanilla LivingEntity.isAlwaysExperienceDropper.

fn skip_drop_experience(&self)

Runs vanilla LivingEntity.skipDropExperience.

fn was_experience_consumed(&self) -> bool

Returns vanilla LivingEntity.wasExperienceConsumed.

fn base_experience_reward(&self) -> i32

Returns vanilla LivingEntity.getBaseExperienceReward.

fn experience_reward( &self, _world: &World, _killer_entity_id: Option<i32>, ) -> i32

Returns vanilla LivingEntity.getExperienceReward.

fn drop_all_death_loot(&self, source: &DamageSource)

Runs the currently implemented subset of vanilla LivingEntity.dropAllDeathLoot.

fn drop_experience(&self, world: &Arc<World>, killer_entity_id: Option<i32>)

Runs vanilla LivingEntity.dropExperience.

fn death_loot_table(&self) -> Option<LootTableRef>

Resolves the loot table used by vanilla LivingEntity.dropFromLootTable.

fn death_loot_table_seed(&self) -> i64

Returns vanilla Entity.getLootTableSeed for death loot.

fn drop_from_loot_table(&self, source: &DamageSource, killed_by_player: bool)

Runs vanilla LivingEntity.dropFromLootTable.

fn drop_custom_death_loot( &self, _source: &DamageSource, _killed_by_player: bool, )

Hook for non-mob custom death loot.

fn tick_death(&self)

Ticks the vanilla living death animation and removes the entity at completion.

fn fall_damage_sound(&self, damage: i32) -> SoundEventRef

Returns vanilla LivingEntity.getFallDamageSound().

fn play_block_fall_sound(&self)

Plays vanilla LivingEntity.playBlockFallSound().

fn cause_living_fall_damage( &self, fall_distance: f64, damage_modifier: f32, source: &DamageSource, ) -> bool

Mirrors vanilla LivingEntity.causeFallDamage.

fn get_armor_value(&self) -> i32

Gets the entity’s armor value from the attribute system.

fn get_attribute_gravity(&self) -> f64

Gets the gravity value from the attribute system.

fn get_effective_gravity(&self) -> f64

Returns vanilla LivingEntity.getEffectiveGravity().

fn is_affected_by_potions(&self) -> bool

Checks if the entity can be affected by potions.

fn is_inverted_heal_and_harm(&self) -> bool

Returns vanilla LivingEntity.isInvertedHealAndHarm().

fn default_can_be_affected(&self, effect: &MobEffectInstance) -> bool

Returns vanilla base LivingEntity.canBeAffected eligibility.

fn can_be_affected(&self, effect: &MobEffectInstance) -> bool

Returns whether this entity accepts a mob-effect instance.

fn has_mob_effect(&self, effect: MobEffectRef) -> bool

Returns vanilla LivingEntity.hasEffect().

fn mob_effect(&self, effect: MobEffectRef) -> Option<ActiveMobEffect>

Returns vanilla LivingEntity.getEffect().

fn active_mob_effects(&self) -> Vec<ActiveMobEffect>

Returns all active vanilla mob effects.

fn set_mob_effect(&self, effect: MobEffectRef, amplifier: i32)

Sets active vanilla mob-effect state.

fn add_mob_effect(&self, effect: MobEffectInstance) -> bool

Adds or updates active vanilla mob-effect state.

fn set_mob_effect_active(&self, effect: MobEffectRef, active: bool)

Sets the presence of a vanilla mob effect.

fn remove_mob_effect(&self, effect: MobEffectRef) -> bool

Removes active vanilla mob-effect state.

fn tick_mob_effects(&self)

Ticks vanilla server-side mob-effect behavior and durations.

fn has_water_breathing(&self) -> bool

Returns whether vanilla effects keep this entity from drowning.

fn should_effects_refill_air_supply(&self) -> bool

Returns whether active vanilla effects refill this entity’s air supply.

fn can_breathe_underwater(&self) -> bool

Returns vanilla LivingEntity.canBreatheUnderwater.

fn can_drown_in_water(&self) -> bool

Returns whether this entity can lose air and take drowning damage.

fn is_eye_in_bubble_column(&self) -> bool

Returns whether the entity’s eye block is a bubble column.

fn decrease_air_supply(&self, current_supply: i32) -> i32

Mirrors vanilla LivingEntity.decreaseAirSupply.

fn increase_air_supply(&self, current_supply: i32) -> i32

Mirrors vanilla LivingEntity.increaseAirSupply.

fn should_take_drowning_damage(&self) -> bool

Mirrors vanilla LivingEntity.shouldTakeDrowningDamage.

fn tick_living_air_supply(&self)

Ticks vanilla living air-supply and drowning behavior from baseTick.

fn is_in_wall(&self) -> bool

Mirrors vanilla LivingEntity.isInWall.

fn tick_in_wall_damage(&self)

Applies vanilla living in-wall damage from baseTick.

fn tick_living_environmental_damage(&self)

Applies vanilla living environmental damage in LivingEntity.baseTick order.

fn can_stand_on_fluid(&self, _fluid_state: FluidState) -> bool

Returns vanilla LivingEntity.canStandOnFluid().

fn is_blocking(&self) -> bool

Checks if the entity is blocking with a shield or similar item.

fn is_fall_flying(&self) -> bool

Checks if the entity is fall flying (using elytra).

fn set_fall_flying(&self, fall_flying: bool)

Sets whether this entity is fall flying.

fn fall_flying_ticks(&self) -> i32

Returns vanilla LivingEntity.getFallFlyingTicks().

fn is_holding(&self, predicate: &mut dyn FnMut(&ItemStack) -> bool) -> bool

Returns vanilla LivingEntity.isHolding.

fn has_item_in_slot(&self, slot: EquipmentSlot) -> bool

Returns whether this entity currently has an item in slot.

fn can_use_slot(&self, _slot: EquipmentSlot) -> bool

Returns whether vanilla allows this entity to use slot.

fn can_dispenser_equip_into_slot(&self, _slot: EquipmentSlot) -> bool

Returns the effective vanilla dispenser slot gate for living entities and mobs.

fn can_equip_with_dispenser(&self, item_stack: &ItemStack) -> bool

Returns vanilla LivingEntity.canEquipWithDispenser.

fn is_equippable_in_slot( &self, item_stack: &ItemStack, slot: EquipmentSlot, ) -> bool

Returns vanilla LivingEntity.isEquippableInSlot.

fn equip_sound( &self, slot: EquipmentSlot, stack: &ItemStack, ) -> Option<SoundEventRef>

Returns the equip sound Steel can currently resolve for this entity.

fn refresh_equipment_attribute_modifiers(&self, slot: EquipmentSlot)

Refreshes transient item attribute modifiers for one equipment slot.

fn detect_equipment_updates(&self)

Detects and applies Vanilla living-equipment changes once per tick.

fn pack_living_equipment(&self) -> Vec<EquipmentSlotItem>

Packs non-empty living equipment slots for initial spawn pairing.

fn drain_dirty_living_equipment(&self) -> Vec<EquipmentSlotItem>

Drains dirty living equipment slots for tracker sync.

fn default_living_can_freeze(&self) -> bool

Returns vanilla LivingEntity.canFreeze() after concrete entity exemptions.

fn is_on_non_air_block_for_frost(&self) -> bool

Returns whether vanilla tryAddFrost sees a non-air block below.

fn remove_frost(&self)

Mirrors vanilla LivingEntity.removeFrost.

fn try_add_frost(&self)

Mirrors vanilla LivingEntity.tryAddFrost.

fn tick_freezing(&self)

Ticks vanilla LivingEntity.aiStep freezing effects.

fn tick_living_state(&self)

Ticks living-entity counters after movement.

fn can_glide_using(&self, item_stack: &ItemStack, slot: EquipmentSlot) -> bool

Mirrors vanilla LivingEntity.canGlideUsing().

fn can_glide_using_equipment_slot(&self, slot: EquipmentSlot) -> bool

Returns whether the item in slot can be used for vanilla gliding.

fn damage_random_glider(&self)

Damages one random equipped glider like vanilla LivingEntity.updateFallFlying().

fn default_can_glide(&self) -> bool

Default vanilla LivingEntity.canGlide() implementation for overrides.

fn start_fall_flying(&self)

Mirrors vanilla Player.startFallFlying().

fn try_to_start_fall_flying(&self) -> bool

Mirrors vanilla Player.tryToStartFallFlying().

fn last_climbable_pos(&self) -> Option<BlockPos>

Returns the last climbable block position this living entity touched.

fn set_last_climbable_pos(&self, pos: BlockPos)

Records the last climbable block position this living entity touched.

fn default_living_on_climbable(&self) -> bool

Returns vanilla LivingEntity.onClimbable() behavior.

fn should_discard_friction(&self) -> bool

Returns whether vanilla living travel should skip friction damping.

fn set_discard_friction(&self, discard_friction: bool)

Sets whether vanilla living travel should skip friction damping.

fn is_jumping(&self) -> bool

Returns whether this living entity is currently applying jump input.

fn set_jumping(&self, jumping: bool)

Sets whether this living entity is currently applying jump input.

fn travel_input(&self) -> LivingTravelInput

Returns vanilla living travel input.

fn set_travel_input(&self, input: LivingTravelInput)

Sets vanilla living travel input.

fn apply_input(&self)

Applies vanilla LivingEntity.applyInput() damping.

fn no_jump_delay(&self) -> i32

Returns vanilla jump cooldown ticks.

fn set_no_jump_delay(&self, ticks: i32)

Sets vanilla jump cooldown ticks.

fn tick_no_jump_delay(&self)

Decrements vanilla jump cooldown once per living AI step.

fn default_is_immobile(&self) -> bool

Returns vanilla LivingEntity.isImmobile().

fn apply_living_velocity_thresholds(&self)

Applies vanilla LivingEntity.aiStep() velocity thresholds.

fn server_ai_step(&self)

Server AI hook called from vanilla LivingEntity.aiStep().

fn get_jump_boost_power(&self) -> f32

Returns vanilla LivingEntity.getJumpBoostPower().

fn get_jump_power_with_multiplier(&self, multiplier: f32) -> f32

Returns vanilla LivingEntity.getJumpPower(float).

fn get_jump_power(&self) -> f32

Returns vanilla LivingEntity.getJumpPower().

fn default_jump_from_ground(&self)

Default vanilla LivingEntity.jumpFromGround() implementation for overrides.

fn go_down_in_water(&self)

Mirrors vanilla LivingEntity.goDownInWater().

fn jump_in_liquid(&self, _fluid_tag: &Identifier)

Mirrors vanilla LivingEntity.jumpInLiquid().

fn handle_living_jump(&self)

Applies vanilla LivingEntity.aiStep() jump handling.

fn tick_ridden(&self, _controller: &Player, _ridden_input: DVec3)

Mirrors vanilla LivingEntity.tickRidden().

fn ridden_input(&self, _controller: &Player, self_input: DVec3) -> DVec3

Mirrors vanilla LivingEntity.getRiddenInput().

fn ridden_speed(&self, _controller: &Player) -> f32

Mirrors vanilla LivingEntity.getRiddenSpeed().

fn travel_ridden( &self, controller: &Player, self_input: DVec3, ) -> Option<MoveResult>

Mirrors vanilla LivingEntity.travelRidden().

fn default_ai_step(&self) -> Option<MoveResult>

Default vanilla-shaped LivingEntity.aiStep() movement foundation for overrides.

fn push_entities(&self)

Mirrors vanilla LivingEntity.pushEntities().

fn apply_entity_cramming_damage( &self, world: &World, pushable_entities: &[SharedEntity], )

Applies vanilla max entity cramming damage from LivingEntity.pushEntities().

fn is_suppressing_sliding_down_ladder(&self) -> bool

Returns vanilla LivingEntity.isSuppressingSlidingDownLadder().

fn levitation_travel_y_delta(&self, movement_y: f64) -> Option<f64>

Returns a levitation velocity adjustment for travelInAir.

fn should_travel_in_fluid(&self, fluid_state: FluidState) -> bool

Returns whether vanilla LivingEntity.travel() should use fluid movement.

fn get_water_slow_down(&self) -> f32

Returns vanilla LivingEntity.getWaterSlowDown().

fn water_movement_efficiency(&self) -> f32

Returns the water movement efficiency attribute used by fluid travel.

fn has_dolphins_grace(&self) -> bool

Returns whether dolphin’s grace should apply to water travel.

fn get_friction_influenced_speed(&self, block_friction: f32) -> f32

Returns vanilla LivingEntity.getFrictionInfluencedSpeed().

fn air_travel_vertical_friction(&self, _horizontal_friction: f32) -> f32

Returns the vertical friction used by travelInAir.

fn handle_on_climbable(&self, movement: DVec3) -> DVec3

Applies vanilla LivingEntity.handleOnClimbable().

fn apply_living_travel_gravity(&self)

Applies gravity using vanilla living-entity effective gravity.

fn handle_relative_friction_and_calculate_movement( &self, input: DVec3, block_friction: f32, ) -> Option<(DVec3, MoveResult)>

Mirrors vanilla LivingEntity.handleRelativeFrictionAndCalculateMovement().

fn travel_in_air(&self, input: DVec3) -> Option<MoveResult>

Mirrors vanilla LivingEntity.travelInAir().

fn get_fluid_falling_adjusted_movement( &self, base_gravity: f64, is_falling: bool, movement: DVec3, ) -> DVec3

Mirrors vanilla LivingEntity.getFluidFallingAdjustedMovement().

fn jump_out_of_fluid(&self, old_y: f64)

Mirrors vanilla LivingEntity.jumpOutOfFluid().

fn float_in_water_while_ridden(&self)

Mirrors vanilla LivingEntity.floatInWaterWhileRidden().

fn travel_in_water( &self, input: DVec3, base_gravity: f64, is_falling: bool, old_y: f64, ) -> Option<MoveResult>

Mirrors vanilla LivingEntity.travelInWater().

fn travel_in_lava( &self, input: DVec3, base_gravity: f64, is_falling: bool, old_y: f64, ) -> Option<MoveResult>

Mirrors vanilla LivingEntity.travelInLava().

fn travel_in_fluid(&self, input: DVec3) -> Option<MoveResult>

Mirrors vanilla LivingEntity.travelInFluid().

fn update_fall_flying(&self)

Mirrors the validation part of vanilla LivingEntity.updateFallFlying().

fn update_fall_flying_movement(&self, movement: DVec3) -> DVec3

Mirrors vanilla LivingEntity.updateFallFlyingMovement().

fn stop_fall_flying(&self)

Mirrors vanilla LivingEntity.stopFallFlying().

fn handle_fall_flying_collisions( &self, previous_horizontal_speed: f64, new_horizontal_speed: f64, )

Mirrors vanilla LivingEntity.handleFallFlyingCollisions().

fn travel_fall_flying(&self, input: DVec3) -> Option<MoveResult>

Mirrors vanilla LivingEntity.travelFallFlying().

fn default_travel(&self, input: DVec3) -> Option<MoveResult>

Default vanilla LivingEntity.travel() implementation for overrides.

fn sleeping_pos(&self) -> Option<BlockPos>

Returns the bed position that makes this living entity sleeping.

fn set_sleeping_pos(&self, bed_position: BlockPos)

Sets the vanilla living-entity sleeping position.

fn clear_sleeping_pos(&self)

Clears the vanilla living-entity sleeping position.

fn is_sleeping(&self) -> bool

Checks if the entity is sleeping.

fn start_sleeping(&self, bed_position: BlockPos) -> Result<(), EntityMoveError>

Starts sleeping at the given bed position.

fn default_stop_sleeping(&self)

Shared body for overrides that need vanilla super.stopSleeping().

fn is_sprinting(&self) -> bool

Checks if the entity is sprinting.

fn set_sprinting(&self, sprinting: bool)

Sets whether the entity is sprinting.

fn get_speed(&self) -> f32

Gets the entity’s cached movement speed.

fn set_speed(&self, speed: f32)

Sets the entity’s cached movement speed.

fn apply_post_impulse_grace_time(&self, ticks: i32)

Applies vanilla post-impulse movement validation grace.

fn set_ignore_fall_damage_from_current_impulse( &self, ignore_fall_damage: bool, new_impulse_impact_pos: DVec3, )

Mirrors vanilla LivingEntity.setIgnoreFallDamageFromCurrentImpulse.

fn is_ignoring_fall_damage_from_current_impulse(&self) -> bool

Returns vanilla LivingEntity.isIgnoringFallDamageFromCurrentImpulse.

fn current_impulse_impact_pos(&self) -> Option<DVec3>

Returns vanilla LivingEntity.currentImpulseImpactPos.

fn try_reset_current_impulse_context(&self)

Mirrors vanilla LivingEntity.tryResetCurrentImpulseContext.

fn reset_current_impulse_context(&self)

Mirrors vanilla LivingEntity.resetCurrentImpulseContext.

fn is_in_post_impulse_grace_time(&self) -> bool

Returns whether movement validation is inside post-impulse grace.

fn tick_post_impulse_grace_time(&self)

Decrements post-impulse grace once per living-entity tick.

fn refresh_dirty_attributes(&self)

Drains dirty attributes and applies server-side effects.

fn random_teleport( &self, world: &Arc<World>, x: f64, y: f64, z: f64, broadcast: bool, ) -> bool

Mirrors vanilla Entity.randomTeleport. Returns true and commits the move on success, or false and leaves the entity untouched on failure.

impl TextResolutor for Player

fn resolve_content(&self, _resolvable: &Resolvable) -> TextComponent

fn resolve_custom(&self, _data: &CustomData) -> Option<TextComponent>

fn translate(&self, _key: &str) -> Option<String>

fn resolve_other(&self, content: &Content) -> TextComponent

fn split_translation(&self, text: String) -> Vec<(String, usize)>