Trait Entity 

pub trait Entity:
    EntityEventSource
    + ErasedType
    + Send
    + Sync
    + 'static {
    // Required methods
    fn base(&self) -> &EntityBase;
    fn entity_type(&self) -> EntityTypeRef;

    // Provided methods
    fn is_always_ticking(&self) -> bool { ... }
    fn broadcast_to_player(&self, _player: &Player) -> bool { ... }
    fn id(&self) -> i32 { ... }
    fn uuid(&self) -> Uuid { ... }
    fn scoreboard_name(&self) -> String { ... }
    fn name(&self) -> TextComponent { ... }
    fn display_name(&self) -> TextComponent { ... }
    fn plain_text_name(&self) -> String { ... }
    fn nbt_for_data_compare(&self) -> NbtCompound { ... }
    fn nbt_for_passenger_save(&self) -> Option<NbtCompound> { ... }
    fn position(&self) -> DVec3 { ... }
    fn spawn_position(&self) -> DVec3 { ... }
    fn block_position(&self) -> BlockPos { ... }
    fn in_block_state(&self, world: &World) -> BlockStateId { ... }
    fn old_position(&self) -> DVec3 { ... }
    fn bounding_box(&self) -> WorldAabb { ... }
    fn is_free(&self, delta: DVec3) -> bool { ... }
    fn blocks_building(&self) -> bool { ... }
    fn is_pickable(&self) -> bool { ... }
    fn attackable(&self) -> bool { ... }
    fn skip_attack_interaction(&self, _source: &dyn Entity) -> bool { ... }
    fn is_pushable(&self) -> bool { ... }
    fn is_pushed_by_fluid(&self) -> bool { ... }
    fn on_above_bubble_column(&self, drag_down: bool, _pos: BlockPos) { ... }
    fn on_inside_bubble_column(&self, drag_down: bool) { ... }
    fn is_spectator(&self) -> bool { ... }
    fn is_ignoring_block_triggers(&self) -> bool { ... }
    fn piston_push_reaction(&self) -> PushReaction { ... }
    fn is_supported_by(&self, pos: BlockPos) -> bool { ... }
    fn can_interact_with_level(&self) -> bool { ... }
    fn is_invisible(&self) -> bool { ... }
    fn is_discrete(&self) -> bool { ... }
    fn is_allied_to(&self, _other: &dyn Entity) -> bool { ... }
    fn is_marker_armor_stand(&self) -> bool { ... }
    fn is_tame_owned_by(&self, _owner: &dyn LivingEntity) -> bool { ... }
    fn projectile_owner_uuid(&self) -> Option<Uuid> { ... }
    fn projectile_owner(&self) -> Option<SharedEntity> { ... }
    fn is_flying_player(&self) -> bool { ... }
    fn can_be_collided_with(&self, _other: Option<&dyn Entity>) -> bool { ... }
    fn can_be_hit_by_projectile(&self) -> bool { ... }
    fn deflection(&self, _projectile: &dyn Projectile) -> ProjectileDeflection { ... }
    fn vehicle(&self) -> Option<SharedEntity> { ... }
    fn controlled_vehicle(&self) -> Option<SharedEntity> { ... }
    fn is_passenger(&self) -> bool { ... }
    fn can_ride(&self, _vehicle: &dyn Entity) -> bool { ... }
    fn stop_riding(&self) { ... }
    fn start_riding(&self, entity_to_ride: &SharedEntity) -> bool { ... }
    fn passengers(&self) -> Vec<SharedEntity>  { ... }
    fn count_player_passengers(&self) -> usize { ... }
    fn has_exactly_one_player_passenger(&self) -> bool { ... }
    fn first_passenger(&self) -> Option<SharedEntity> { ... }
    fn controlling_passenger(&self) -> Option<SharedEntity> { ... }
    fn can_control_vehicle(&self) -> bool { ... }
    fn has_controlling_passenger(&self) -> bool { ... }
    fn is_vehicle(&self) -> bool { ... }
    fn dismounts_underwater(&self) -> bool { ... }
    fn has_passenger(&self, passenger: &dyn Entity) -> bool { ... }
    fn can_add_passenger(&self, _passenger: &dyn Entity) -> bool { ... }
    fn could_accept_passenger(&self) -> bool { ... }
    fn passenger_index(&self, passenger: &dyn Entity) -> Option<usize> { ... }
    fn vehicle_attachment_point(&self, _vehicle: &dyn Entity) -> DVec3 { ... }
    fn passenger_attachment_point(&self, passenger: &dyn Entity) -> DVec3 { ... }
    fn passenger_riding_position(&self, passenger: &dyn Entity) -> DVec3 { ... }
    fn position_rider(&self, passenger: &dyn Entity) { ... }
    fn root_vehicle_id(&self) -> i32 { ... }
    fn root_vehicle(&self) -> Option<SharedEntity> { ... }
    fn is_passenger_of_same_vehicle(&self, other: &dyn Entity) -> bool { ... }
    fn has_indirect_passenger(&self, entity: &dyn Entity) -> bool { ... }
    fn can_collide_with(&self, other: &dyn Entity) -> bool { ... }
    fn push_impulse(&self, impulse: DVec3) { ... }
    fn push_entity(&self, entity: &dyn Entity) { ... }
    fn make_bounding_box_at(&self, position: DVec3) -> WorldAabb { ... }
    fn get_relative_portal_position(
        &self,
        axis: Axis,
        portal_area: FoundRectangle,
    ) -> DVec3 { ... }
    fn default_tick(&self) { ... }
    fn tick(&self) { ... }
    fn ride_tick(&self) { ... }
    fn base_tick(&self) { ... }
    fn handle_portal(&self) { ... }
    fn entity_base_tick(&self) { ... }
    fn check_below_world(&self) { ... }
    fn on_below_world(&self) { ... }
    fn check_despawn(&self) { ... }
    fn apply_inside_block_effect(&self, effect_type: InsideBlockEffectType) { ... }
    fn level(&self) -> Option<Arc<World>> { ... }
    fn pack_dirty_entity_data(&self) -> Option<Vec<DataValue>> { ... }
    fn pack_all_entity_data(&self) -> Vec<DataValue> { ... }
    fn synced_data(&self) -> Option<&dyn EntitySyncedData> { ... }
    fn update_data_before_sync(&self) { ... }
    fn is_removed(&self) -> bool { ... }
    fn is_alive(&self) -> bool { ... }
    fn begin_pending_world_change(&self) -> Option<PendingWorldChangeToken> { ... }
    fn finish_pending_world_change(
        &self,
        token: PendingWorldChangeToken,
    ) -> bool { ... }
    fn is_world_change_pending(&self) -> bool { ... }
    fn is_world_change_token_pending(
        &self,
        token: PendingWorldChangeToken,
    ) -> bool { ... }
    fn can_use_portal(&self, ignore_passenger: bool) -> bool { ... }
    fn dimension_changing_delay(&self) -> i32 { ... }
    fn removal_reason(&self) -> Option<RemovalReason> { ... }
    fn set_removed(&self, reason: RemovalReason) { ... }
    fn game_event(&self, event: GameEventRef) { ... }
    fn kill(&self, world: &World) { ... }
    fn restore_owner_reference(&self, _owner: &SharedEntity) { ... }
    fn set_level_callback(&self, callback: Arc<dyn EntityLevelCallback>) { ... }
    fn notify_leash_holder(&self, _leashable: &dyn Entity) { ... }
    fn notify_leashee_removed(&self, _leashable: &dyn Entity) { ... }
    fn player_touch(self: Arc<Self>, _player: &Arc<Player>) { ... }
    fn leashables_leashed_to(&self) -> Vec<SharedEntity>  { ... }
    fn leashables_leashed_to_holder_in_area(
        &self,
        holder: &dyn Entity,
    ) -> Vec<SharedEntity>  { ... }
    fn transfer_leashables_from_holder(&self, old_holder: &dyn Entity) -> bool { ... }
    fn drop_all_leash_connections(&self, player: Option<&Player>) -> bool { ... }
    fn shear_off_all_leash_connections(&self, player: Option<&Player>) -> bool { ... }
    fn attempt_to_shear_equipment(
        &self,
        player: &Player,
        hand: InteractionHand,
    ) -> bool { ... }
    fn interact(
        &self,
        player: &Player,
        hand: InteractionHand,
        location: DVec3,
    ) -> InteractionResult { ... }
    fn interact_entity(
        &self,
        player: &Player,
        hand: InteractionHand,
        _location: DVec3,
    ) -> InteractionResult { ... }
    fn is_living_entity(&self) -> bool { ... }
    fn is_abstract_arrow(&self) -> bool { ... }
    fn as_projectile(&self) -> Option<&dyn Projectile> { ... }
    fn as_living_entity(&self) -> Option<&dyn LivingEntity> { ... }
    fn as_item_frame(&self) -> Option<&dyn ItemFrame> { ... }
    fn as_player(&self) -> Option<&Player> { ... }
    fn with_weapon_item(&self, visitor: &mut dyn FnMut(Option<&ItemStack>)) { ... }
    fn is_pathfinder_mob(&self) -> bool { ... }
    fn as_pathfinder_mob(&self) -> Option<&dyn PathfinderMob> { ... }
    fn is_mob(&self) -> bool { ... }
    fn as_mob(&self) -> Option<&dyn Mob> { ... }
    fn is_animal(&self) -> bool { ... }
    fn as_animal(&self) -> Option<&dyn Animal> { ... }
    fn is_ageable_mob(&self) -> bool { ... }
    fn as_ageable_mob(&self) -> Option<&dyn AgeableMob> { ... }
    fn is_item_steerable(&self) -> bool { ... }
    fn as_item_steerable(&self) -> Option<&dyn ItemSteerable> { ... }
    fn forces_fall_flying_velocity_sync(&self) -> bool { ... }
    fn uses_client_movement_packets(&self) -> bool { ... }
    fn is_server_driven_movement(&self) -> bool { ... }
    fn can_simulate_movement(&self) -> bool { ... }
    fn is_effective_ai(&self) -> bool { ... }
    fn is_suppressing_bounce(&self) -> bool { ... }
    fn is_stepping_carefully(&self) -> bool { ... }
    fn is_descending(&self) -> bool { ... }
    fn set_shared_shift_key_down(&self, shift_key_down: bool) { ... }
    fn set_shared_swimming(&self, swimming: bool) { ... }
    fn update_swimming(&self) { ... }
    fn default_update_swimming(&self) { ... }
    fn set_shared_sprinting(&self, sprinting: bool) { ... }
    fn set_shared_fall_flying(&self, fall_flying: bool) { ... }
    fn is_flying_vehicle(&self) -> bool { ... }
    fn on_climbable(&self) -> bool { ... }
    fn known_movement(&self) -> DVec3 { ... }
    fn known_speed(&self) -> DVec3 { ... }
    fn tick_count(&self) -> i32 { ... }
    fn advance_tick_count(&self) { ... }
    fn fall_sounds(&self) -> (SoundEventRef, SoundEventRef) { ... }
    fn rotation(&self) -> (f32, f32) { ... }
    fn set_rotation(&self, rotation: (f32, f32)) { ... }
    fn direction_yaw(&self) -> Direction { ... }
    fn look_at(&self, from_anchor: EntityAnchor, target: DVec3) { ... }
    fn look_at_entity(
        &self,
        from_anchor: EntityAnchor,
        target: &dyn Entity,
        target_anchor: EntityAnchor,
    ) { ... }
    fn head_yaw(&self) -> f32 { ... }
    fn spawn_data(&self) -> i32 { ... }
    fn get_eye_height(&self) -> f64 { ... }
    fn get_fluid_jump_threshold(&self) -> f64 { ... }
    fn get_eye_y(&self) -> f64 { ... }
    fn is_in_wall(&self) -> bool { ... }
    fn calculate_view_vector(
        &self,
        pitch_degrees: f32,
        yaw_degrees: f32,
    ) -> DVec3 { ... }
    fn look_angle(&self) -> DVec3 { ... }
    fn hand_holding_item_angle(&self, item: ItemRef) -> DVec3 { ... }
    fn velocity(&self) -> DVec3 { ... }
    fn set_velocity(&self, velocity: DVec3) { ... }
    fn needs_velocity_sync(&self) -> bool { ... }
    fn mark_velocity_sync(&self) { ... }
    fn clear_velocity_sync(&self) { ... }
    fn hurt_marked(&self) -> bool { ... }
    fn mark_hurt(&self) { ... }
    fn clear_hurt_mark(&self) { ... }
    fn fall_distance(&self) -> f64 { ... }
    fn is_in_powder_snow(&self) -> bool { ... }
    fn was_in_powder_snow(&self) -> bool { ... }
    fn set_fall_distance(&self, fall_distance: f64) { ... }
    fn reset_fall_distance(&self) { ... }
    fn check_fall_distance_accumulation(&self) { ... }
    fn fire_freeze_state(&self) -> EntityFireFreezeState { ... }
    fn remaining_fire_ticks(&self) -> i32 { ... }
    fn set_remaining_fire_ticks(&self, remaining_fire_ticks: i32) { ... }
    fn ticks_frozen(&self) -> i32 { ... }
    fn set_ticks_frozen(&self, ticks_frozen: i32) { ... }
    fn fire_immune(&self) -> bool { ... }
    fn fire_immune_ticks(&self) -> i32 { ... }
    fn should_play_lava_hurt_sound(&self) -> bool { ... }
    fn lava_hurt(&self) { ... }
    fn remaining_fire_ticks_cap(&self) -> Option<i32> { ... }
    fn fire_ignite_extra_ticks(&self) -> i32 { ... }
    fn is_on_fire(&self) -> bool { ... }
    fn has_visual_fire(&self) -> bool { ... }
    fn is_freezing(&self) -> bool { ... }
    fn default_can_freeze(&self) -> bool { ... }
    fn can_freeze(&self) -> bool { ... }
    fn ticks_required_to_freeze(&self) -> i32 { ... }
    fn is_fully_frozen(&self) -> bool { ... }
    fn percent_frozen(&self) -> f32 { ... }
    fn clear_freeze(&self) { ... }
    fn clear_fire(&self) { ... }
    fn ignite_for_ticks(&self, number_of_ticks: i32) { ... }
    fn sync_base_fire_freeze_entity_data(&self) { ... }
    fn sync_base_entity_data(&self) { ... }
    fn is_in_water(&self) -> bool { ... }
    fn is_in_lava(&self) -> bool { ... }
    fn is_eye_in_water(&self) -> bool { ... }
    fn is_eye_in_lava(&self) -> bool { ... }
    fn is_under_water(&self) -> bool { ... }
    fn fluid_contact(&self) -> EntityFluidContact { ... }
    fn refresh_fluid_contact(&self) -> EntityFluidContact { ... }
    fn refresh_fluid_contact_for_base_tick(&self) -> EntityFluidContact { ... }
    fn scan_and_store_fluid_contact(
        &self,
        advance_eye_water_history: bool,
    ) -> EntityFluidContact { ... }
    fn apply_fluid_current_for_base_tick(
        &self,
        world: &Arc<World>,
        contact: EntityFluidContact,
    ) { ... }
    fn apply_fluid_current_impulse(&self, impulse: DVec3) { ... }
    fn is_fall_damage_immune(&self) -> bool { ... }
    fn propagate_fall_to_passengers(
        &self,
        fall_distance: f64,
        damage_modifier: f32,
        source: &DamageSource,
    ) { ... }
    fn cause_fall_damage(
        &self,
        fall_distance: f64,
        damage_modifier: f32,
        source: &DamageSource,
    ) -> bool { ... }
    fn on_ground(&self) -> bool { ... }
    fn horizontal_collision(&self) -> bool { ... }
    fn vertical_collision(&self) -> bool { ... }
    fn vertical_collision_below(&self) -> bool { ... }
    fn no_physics(&self) -> bool { ... }
    fn is_affected_by_blocks(&self) -> bool { ... }
    fn set_no_physics(&self, no_physics: bool) { ... }
    fn update_no_physics_from_current_collision(&self) { ... }
    fn move_towards_closest_space(&self, x: f64, y: f64, z: f64) { ... }
    fn default_make_stuck_in_block(
        &self,
        _state: BlockStateId,
        speed_multiplier: DVec3,
    ) { ... }
    fn make_stuck_in_block(&self, state: BlockStateId, speed_multiplier: DVec3) { ... }
    fn apply_effects_from_blocks(&self) { ... }
    fn apply_effects_from_blocks_between(&self, from: DVec3, to: DVec3) { ... }
    fn apply_effects_from_blocks_for_last_movements(&self) { ... }
    fn set_on_ground(&self, on_ground: bool) { ... }
    fn set_on_ground_with_movement(
        &self,
        on_ground: bool,
        horizontal_collision: bool,
        movement: DVec3,
    ) { ... }
    fn default_apply_accepted_client_movement(
        &self,
        world: &Arc<World>,
        accepted: AcceptedClientMovement,
    ) -> Result<AcceptedClientMovementOutcome, EntityMoveError> { ... }
    fn apply_accepted_client_movement(
        &self,
        world: &Arc<World>,
        accepted: AcceptedClientMovement,
    ) -> Result<AcceptedClientMovementOutcome, EntityMoveError> { ... }
    fn apply_accepted_client_vehicle_movement(
        &self,
        world: &Arc<World>,
        accepted: AcceptedClientMovement,
    ) -> Result<AcceptedClientMovementOutcome, EntityMoveError> { ... }
    fn try_set_position(&self, pos: DVec3) -> Result<(), EntityMoveError> { ... }
    fn set_old_position_to_current(&self) { ... }
    fn set_old_position(&self, old_position: DVec3) { ... }
    fn remove_latest_movement_recording(&self) { ... }
    fn on_pos(&self, offset: f32) -> Option<BlockPos> { ... }
    fn block_pos_below_that_affects_movement(&self) -> Option<BlockPos> { ... }
    fn on_pos_legacy(&self) -> Option<BlockPos> { ... }
    fn block_speed_factor(&self) -> f32 { ... }
    fn block_jump_factor(&self) -> f32 { ... }
    fn pose(&self) -> EntityPose { ... }
    fn dimensions_for_pose(&self, _pose: EntityPose) -> EntityDimensions { ... }
    fn refresh_dimensions(&self) { ... }
    fn set_pose(&self, pose: EntityPose) { ... }
    fn is_crouching(&self) -> bool { ... }
    fn is_swimming(&self) -> bool { ... }
    fn is_on_rails(&self) -> bool { ... }
    fn is_state_climbable(&self, state: BlockStateId) -> bool { ... }
    fn movement_emission(&self) -> EntityMovementEmission { ... }
    fn may_interact(&self, _world: &World, _pos: BlockPos) -> bool { ... }
    fn air_supply(&self) -> i32 { ... }
    fn set_air_supply(&self, air_supply: i32) { ... }
    fn max_air_supply(&self) -> i32 { ... }
    fn portal_cooldown(&self) -> i32 { ... }
    fn set_portal_cooldown(&self, portal_cooldown: i32) { ... }
    fn is_on_portal_cooldown(&self) -> bool { ... }
    fn reset_portal_cooldown(&self) { ... }
    fn set_as_inside_portal(&self, portal: PortalKind, entry_position: BlockPos) { ... }
    fn custom_name(&self) -> Option<TextComponent> { ... }
    fn set_custom_name(&self, custom_name: Option<TextComponent>) { ... }
    fn is_custom_name_visible(&self) -> bool { ... }
    fn set_custom_name_visible(&self, visible: bool) { ... }
    fn has_glowing_tag(&self) -> bool { ... }
    fn set_glowing_tag(&self, glowing: bool) { ... }
    fn tags(&self) -> Vec<String> { ... }
    fn add_tag(&self, tag: String) -> bool { ... }
    fn remove_tag(&self, tag: &str) -> bool { ... }
    fn custom_data(&self) -> NbtCompound { ... }
    fn set_custom_data(&self, custom_data: NbtCompound) { ... }
    fn sound_source(&self) -> SoundSource { ... }
    fn swim_sound(&self) -> SoundEventRef { ... }
    fn is_silent(&self) -> bool { ... }
    fn set_silent(&self, silent: bool) { ... }
    fn broadcast_entity_event(&self, event: EntityStatus) { ... }
    fn play_sound(&self, sound: SoundEventRef, volume: f32, pitch: f32) { ... }
    fn play_entity_on_fire_extinguished_sound(&self) { ... }
    fn play_step_sound(&self, _pos: BlockPos, block_state: BlockStateId) { ... }
    fn play_block_step_sound(&self, block_state: BlockStateId) { ... }
    fn play_muffled_step_sound(&self, block_state: BlockStateId) { ... }
    fn play_combination_step_sounds(
        &self,
        primary_step_sound: BlockStateId,
        secondary_step_sound: BlockStateId,
    ) { ... }
    fn walking_step_sound(&self, pos: BlockPos, block_state: BlockStateId) { ... }
    fn play_amethyst_step_sound(&self) { ... }
    fn water_swim_sound(&self) { ... }
    fn play_swim_sound(&self, volume: f32) { ... }
    fn is_flapping(&self) -> bool { ... }
    fn on_flap(&self) { ... }
    fn process_flapping_movement(&self) { ... }
    fn next_step(&self) -> f32 { ... }
    fn apply_movement_emission_and_play_sound(
        &self,
        emission: EntityMovementEmission,
        clipped_movement: DVec3,
        effect_pos: BlockPos,
        effect_state: BlockStateId,
    ) { ... }
    fn apply_movement_side_effects_after_move(
        &self,
        world: &World,
        actual_movement: DVec3,
    ) { ... }
    fn vibration_and_sound_effects_from_block(
        &self,
        pos: BlockPos,
        block_state: BlockStateId,
        should_sound: bool,
        should_vibrate: bool,
        clipped_movement: DVec3,
    ) -> bool { ... }
    fn max_up_step(&self) -> f32 { ... }
    fn backs_off_from_edge(&self) -> bool { ... }
    fn get_default_gravity(&self) -> f64 { ... }
    fn is_no_gravity(&self) -> bool { ... }
    fn set_no_gravity(&self, no_gravity: bool) { ... }
    fn is_invulnerable(&self) -> bool { ... }
    fn set_invulnerable(&self, invulnerable: bool) { ... }
    fn get_gravity(&self) -> f64 { ... }
    fn apply_gravity(&self) { ... }
    fn move_relative(&self, speed: f32, input: DVec3) { ... }
    fn move_without_physics(&self, delta: DVec3) -> Option<MoveResult> { ... }
    fn move_entity(
        &self,
        mover_type: MoverType,
        delta: DVec3,
    ) -> Option<MoveResult> { ... }
    fn apply_fall_damage_after_move(
        &self,
        result: &MoveResult,
        world: &Arc<World>,
    ) -> bool { ... }
    fn reset_fall_distance_on_resetting_clip(
        &self,
        world: &Arc<World>,
        movement: DVec3,
    ) { ... }
    fn do_check_fall_damage(
        &self,
        movement: DVec3,
        on_ground: bool,
        world: &Arc<World>,
    ) -> bool { ... }
    fn refresh_supporting_block_for_fall_damage(
        &self,
        movement: DVec3,
        on_ground: bool,
    ) { ... }
    fn check_fall_damage(
        &self,
        vertical_movement: f64,
        on_ground: bool,
        on_state: BlockStateId,
        pos: BlockPos,
        world: &Arc<World>,
    ) { ... }
    fn ground_contact_after_movement(
        &self,
        on_ground: bool,
        movement: Option<DVec3>,
    ) -> EntityGroundContact { ... }
    fn check_supporting_block(
        &self,
        on_ground: bool,
        movement: Option<DVec3>,
        world: &Arc<World>,
    ) -> EntityGroundContact { ... }
    fn spawn_at_location(
        &self,
        item: ItemStack,
        y_offset: f64,
    ) -> Option<Arc<ItemEntity>> { ... }
    fn spawn_at_location_with_offset(
        &self,
        item: ItemStack,
        offset: DVec3,
    ) -> Option<Arc<ItemEntity>> { ... }
    fn save_additional(&self, _nbt: &mut NbtCompound) { ... }
    fn load_additional(&self, _nbt: BorrowedNbtCompoundView<'_, '_>) { ... }
    fn hurt(&self, world: &World, source: &DamageSource, amount: f32) -> bool { ... }
}

A trait for entities.

This trait provides the core functionality for entities. It’s based on Minecraft’s Entity class. Concrete implementations must also claim a unique steel_utils::DowncastTypeKey through steel_utils::DowncastType.

Using EntityBase

Entities expose EntityBase to get default implementations for common methods like id(), uuid(), position(), etc.

impl Entity for MyEntity {
    fn base(&self) -> &EntityBase { &self.base }
    fn entity_type(&self) -> EntityTypeRef { vanilla_entities::MY_ENTITY }
    fn bounding_box(&self) -> WorldAabb { /* ... */ }
    // All other common methods use defaults from EntityBase!
}

Required Methods

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.

Provided Methods

fn is_always_ticking(&self) -> bool

Returns whether this entity ignores chunk ticking visibility.

Mirrors vanilla Entity.isAlwaysTicking.

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

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

Mirrors vanilla Entity.broadcastToPlayer. Most entities are always broadcastable; players override this for spectator visibility rules.

fn id(&self) -> i32

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

fn uuid(&self) -> Uuid

Gets the UUID of the entity (persistent identifier).

fn scoreboard_name(&self) -> String

Returns this entity’s vanilla scoreboard holder name.

Non-player entities use their UUID string. Players override this with their game profile 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.

Custom names are resolved as text components; otherwise entities use their translated type description. Players override this with their game profile name.

fn nbt_for_data_compare(&self) -> NbtCompound

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

Mirrors NbtPredicate.getEntityTagToCompare: base and type-specific Entity.saveWithoutId data, passengers, and a player’s selected item.

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.

Mirrors vanilla Entity.getAddEntityPacket() overloads. Most entities spawn at their current position; block-attached entities can override this with the backing block position used by the vanilla 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 blocks_building(&self) -> bool

Returns whether this entity obstructs block placement.

Mirrors vanilla Entity.blocksBuilding. Base entities do not obstruct placement unless a concrete entity type opts in.

fn is_pickable(&self) -> bool

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

Mirrors vanilla Entity.isPickable. Base entities are not pickable unless a concrete entity type opts in.

fn attackable(&self) -> bool

Returns whether this entity can be attacked.

Mirrors vanilla Entity.isAttackable. Concrete entities that override vanilla to reject player attacks should override this method.

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

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

Mirrors vanilla Entity.skipAttackInteraction.

fn is_pushable(&self) -> bool

Returns whether this entity participates in vanilla push separation.

Mirrors vanilla Entity.isPushable. Base entities are not pushable unless a concrete entity type opts in.

fn is_pushed_by_fluid(&self) -> bool

Returns whether vanilla fluid currents can push this entity.

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

Applies vanilla Entity.onAboveBubbleColumn.

fn on_inside_bubble_column(&self, drag_down: bool)

Applies vanilla Entity.onInsideBubbleColumn.

fn is_spectator(&self) -> bool

Returns whether this entity is invisible to normal entity selectors.

Mirrors vanilla Entity.isSpectator. Base entities are never spectators; players override this from their game mode.

fn is_ignoring_block_triggers(&self) -> bool

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

Mirrors vanilla Entity.isIgnoringBlockTriggers. Display-like entities and marker entities override this capability.

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 is_flying_player(&self) -> bool

Returns true for vanilla players whose abilities have flying set.

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

Returns whether other can collide with this entity.

Mirrors vanilla Entity.canBeCollidedWith. Base entities cannot be collided with unless a concrete entity type opts in.

fn can_be_hit_by_projectile(&self) -> bool

Returns whether projectile collision may interact with this entity.

Mirrors vanilla Entity.canBeHitByProjectile.

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.

Mirrors vanilla Entity.getVehicle.

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

Returns the vehicle this entity directly controls, if any.

Mirrors vanilla Entity.getControlledVehicle.

fn is_passenger(&self) -> bool

Returns whether this entity is riding another entity.

Mirrors vanilla Entity.isPassenger.

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

Returns whether vanilla allows this entity to start riding vehicle.

Mirrors vanilla Entity.canRide.

fn stop_riding(&self)

Stops riding the current vehicle, if any.

Mirrors vanilla Entity.stopRiding.

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

Starts riding entity_to_ride if vanilla boarding rules allow it.

Mirrors vanilla Entity.startRiding(Entity).

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

Gets this entity’s direct passengers.

Mirrors vanilla Entity.getPassengers.

fn count_player_passengers(&self) -> usize

Counts indirect player passengers.

Mirrors vanilla Entity.countPlayerPassengers.

fn has_exactly_one_player_passenger(&self) -> bool

Returns whether this entity has exactly one indirect player passenger.

Mirrors vanilla Entity.hasExactlyOnePlayerPassenger.

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

Gets this entity’s first direct passenger.

Mirrors vanilla Entity.getFirstPassenger.

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

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

Mirrors vanilla Entity.getControllingPassenger. Base entities have no controller; controllable vehicles override this based on their own rules.

fn can_control_vehicle(&self) -> bool

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

Mirrors vanilla Entity.canControlVehicle.

fn has_controlling_passenger(&self) -> bool

Returns whether this entity currently has a controlling passenger.

Mirrors vanilla Entity.hasControllingPassenger.

fn is_vehicle(&self) -> bool

Returns whether this entity has any direct passengers.

Mirrors vanilla Entity.isVehicle.

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.

Mirrors vanilla Entity.hasPassenger(Entity).

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

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

Mirrors vanilla Entity.canAddPassenger.

fn could_accept_passenger(&self) -> bool

Returns whether this entity can accept any passenger.

Mirrors vanilla Entity.couldAcceptPassenger.

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.

Mirrors vanilla Entity.getVehicleAttachmentPoint.

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

Returns this vehicle’s passenger attachment point.

Mirrors vanilla Entity.getPassengerAttachmentPoint for the base entity class.

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

Returns the world position where passenger should ride this vehicle.

Mirrors vanilla Entity.getPassengerRidingPosition.

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

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

Mirrors vanilla Entity.positionRider.

fn root_vehicle_id(&self) -> i32

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

Mirrors vanilla Entity.getRootVehicle using session IDs for object identity.

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

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

Mirrors vanilla Entity.getRootVehicle.

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

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

Mirrors vanilla Entity.isPassengerOfSameVehicle.

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

Returns whether entity is an indirect passenger of this entity.

Mirrors vanilla Entity.hasIndirectPassenger.

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

Returns whether this entity can collide with other.

Mirrors vanilla Entity.canCollideWith.

fn push_impulse(&self, impulse: DVec3)

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

Mirrors vanilla Entity.push(double, double, double).

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

Applies vanilla entity-to-entity push separation.

Mirrors vanilla Entity.push(Entity).

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.

Concrete entity ticks that mirror vanilla super.tick() should call this rather than calling Self::base_tick directly.

fn tick(&self)

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

Use self.level() to access the world for physics, block queries, etc. The caller handles post-tick dirty data sync.

The default dispatches vanilla living behavior without requiring every living implementation to repeat an Entity::tick forwarding method. Non-living entities with custom tick behavior override this directly.

fn ride_tick(&self)

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

Mirrors vanilla Entity.rideTick.

fn base_tick(&self)

Runs vanilla Entity.baseTick pieces Steel currently implements.

This intentionally stays separate from tick() because several vanilla subclasses override tick without calling super.tick().

fn handle_portal(&self)

Runs vanilla Entity.handlePortal behavior currently implemented by Steel.

fn entity_base_tick(&self)

Runs only vanilla Entity.baseTick behavior.

Subtype base-tick chains call this from their owner trait.

fn check_below_world(&self)

Applies vanilla below-world handling.

fn on_below_world(&self)

Runs entity-specific behavior after falling below the world.

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.

Returns None if the entity is not in a world or the world was dropped. Mirrors vanilla’s Entity.level().

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

Packs dirty entity data for network synchronization.

Returns Some(values) if there are dirty values to sync, None otherwise. Clears the dirty flags after packing.

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

Packs all non-default entity data for initial spawn.

Used when sending entity data to a player who just started tracking this entity.

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.

Mirrors vanilla Entity.updateDataBeforeSync.

fn is_removed(&self) -> bool

Returns true if the entity has been marked for removal.

fn is_alive(&self) -> bool

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

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.

Mirrors vanilla Entity.canUsePortal, including LivingEntity sleeping suppression.

fn dimension_changing_delay(&self) -> i32

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

Mirrors vanilla getDimensionChangingDelay overrides for players, projectiles, and base entities with a player passenger. Concrete vehicle implementations override this method directly.

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(&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.

world is vanilla’s explicit ServerLevel argument. Living entities use it for damage processing, while death game events use the entity’s attached world.

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.

Mirrors vanilla’s frequent instanceof LivingEntity branches.

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

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

Mirrors vanilla’s instanceof ItemFrame branches.

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.

Mirrors vanilla’s frequent instanceof PathfinderMob branches.

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.

Mirrors vanilla’s frequent instanceof Mob branches.

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.

Mirrors vanilla’s frequent instanceof Animal branches.

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.

Mirrors vanilla’s frequent instanceof AgeableMob branches.

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.

Mirrors vanilla’s instanceof ItemSteerable branches.

fn forces_fall_flying_velocity_sync(&self) -> bool

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

fn uses_client_movement_packets(&self) -> bool

Returns true when movement is driven by serverbound movement packets.

fn is_server_driven_movement(&self) -> bool

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

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 is_suppressing_bounce(&self) -> bool

Returns true when vanilla landing bounce should be suppressed.

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 update_swimming(&self)

Updates the vanilla swimming shared flag.

Mirrors vanilla Entity.updateSwimming.

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 on_climbable(&self) -> bool

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

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 tick_count(&self) -> i32

Returns vanilla Entity.tickCount.

fn advance_tick_count(&self)

Advances vanilla Entity.tickCount.

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

Returns vanilla small and big fall sounds for this entity.

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

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

Yaw is horizontal rotation (0-360), pitch is vertical (-90 to 90).

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

Default implementation returns the eye height from the entity type dimensions. Override for entities with pose-dependent eye heights (e.g., players).

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.

Equivalent to vanilla’s Entity.getEyeY().

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.

Only players have a hand offset. If both hands contain the item, vanilla chooses the main hand; otherwise an offhand-only item uses the opposite arm from the player’s configured main arm.

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 fire_immune_ticks(&self) -> i32

Returns vanilla fire immunity cooldown ticks after not being ignited.

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 remaining_fire_ticks_cap(&self) -> Option<i32>

Maximum vanilla remainingFireTicks this entity can store.

fn fire_ignite_extra_ticks(&self) -> i32

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

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 can_freeze(&self) -> bool

Returns whether this entity may accumulate frozen ticks.

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 cause_fall_damage( &self, fall_distance: f64, damage_modifier: f32, source: &DamageSource, ) -> bool

Applies vanilla fall damage.

Living entities use the shared LivingEntity damage path; base entities only propagate to passengers and return false.

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 make_stuck_in_block(&self, state: BlockStateId, speed_multiplier: DVec3)

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

fn apply_effects_from_blocks(&self)

Applies current block-contact effects to this entity.

Mirrors the shared ownership boundary of vanilla Entity.applyEffectsFromBlocks.

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

Applies block-contact effects for one explicit movement segment.

Mirrors vanilla’s Entity.applyEffectsFromBlocks(Vec3, Vec3) overload, which does not finalize or clear the entity’s normal movement trace.

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.

Mirrors the shared tail of vanilla player and controlled-vehicle movement handling after rollback/collision validation has accepted the target.

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 dimensions_for_pose(&self, _pose: EntityPose) -> EntityDimensions

Returns vanilla dimensions for a physical pose.

fn refresh_dimensions(&self)

Refreshes dimensions for the current physical pose.

fn set_pose(&self, pose: EntityPose)

Sets the physical pose and synchronized pose metadata.

fn is_crouching(&self) -> bool

Returns whether vanilla currently considers this entity crouching.

fn is_swimming(&self) -> bool

Returns whether vanilla currently considers this entity swimming.

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 movement_emission(&self) -> EntityMovementEmission

Returns vanilla movement side effects emitted by this entity.

fn may_interact(&self, _world: &World, _pos: BlockPos) -> bool

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

Vanilla Entity.mayInteract defaults to true; player-like entities can apply world permission checks through overrides.

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.

Mirrors vanilla Entity.setPortalCooldown().

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

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

Mirrors vanilla Entity.setAsInsidePortal.

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 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 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_sound(&self, sound: SoundEventRef, volume: f32, pitch: f32)

Plays an entity sound at the entity’s exact position.

fn play_entity_on_fire_extinguished_sound(&self)

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

fn play_step_sound(&self, _pos: BlockPos, block_state: BlockStateId)

Plays the base vanilla step sound for a block.

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 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 get_default_gravity(&self) -> f64

Gets the default gravity for this entity type.

Override this to specify entity-specific gravity. Vanilla values: ItemEntity = 0.04, LivingEntity = 0.08

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.

Returns 0 if no_gravity is set, otherwise returns get_default_gravity().

fn apply_gravity(&self)

Applies gravity to the entity’s velocity.

Mirrors vanilla’s Entity.applyGravity().

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.

Mirrors vanilla’s Entity.move(MoverType, Vec3). Updates position, on_ground, velocity (on collision), and returns collision info.

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.

Callers update on-ground/supporting-block state before this method.

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.

Mirrors vanilla’s Entity.spawnAtLocation(). The item spawns at the entity’s position with the given Y offset and has a default pickup delay.

Returns None if the item stack is empty or the entity has no world.

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.

Called during chunk serialization. Implementors should save all data needed to restore entity state on load. Base fields (pos, motion, rotation, uuid, on_ground) are handled by the serialization layer.

Mirrors vanilla’s Entity.addAdditionalSaveData().

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

Loads type-specific entity data from NBT.

Called after entity creation during chunk deserialization. Base fields are already restored; this handles type-specific data.

Mirrors vanilla’s Entity.readAdditionalSaveData().

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

Applies damage to this entity.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl Entity for BlockDisplayEntity

impl Entity for ChestMinecartEntity

impl Entity for CowEntity

impl Entity for EndCrystalEntity

impl Entity for EnderPearlEntity

impl Entity for ExperienceOrbEntity

impl Entity for FireworkRocketEntity

impl Entity for ItemEntity

impl Entity for ItemFrameEntity

impl Entity for LeashFenceKnotEntity

impl Entity for PigEntity

impl Entity for Player

impl Entity for RawEntity