Struct SplashPotionEntity 

pub struct SplashPotionEntity {
    base: EntityBase,
    entity_type: EntityTypeRef,
    entity_data: SyncMutex<SplashPotionEntityData>,
    projectile_base: ProjectileBase,
}

A thrown splash potion.

Fields

base: EntityBase

Common entity fields (id, uuid, position, etc.).

entity_type: EntityTypeRef

Vanilla entity type registered for this implementation.

entity_data: SyncMutex<SplashPotionEntityData>

Synced data carrying the rendered item stack.

projectile_base: ProjectileBase

Shared Projectile state (owner / left-owner / has-been-shot).

Implementations

impl SplashPotionEntity

pub fn new( entity_type: EntityTypeRef, id: i32, position: DVec3, world: Weak<World>, ) -> Self

Creates a new thrown splash potion with no owner and the default rendered item.

pub fn from_saved(entity_type: EntityTypeRef, load: EntityBaseLoad) -> Self

Creates a thrown splash potion from saved base data.

fn apply_effect( self: &Arc<Self>, world: &World, living: &dyn LivingEntity, effect: &RegistryMobEffectInstance, scale: f64, duration_scale: f32, owner: Option<&SharedEntity>, )

Applies one effect with distance falloff and duration scaling

Trait Implementations

impl AbstractThrownPotion for SplashPotionEntity

fn on_hit_as_potion( self: &Arc<Self>, world: &Arc<World>, potion_item: &ItemStack, hit: &ProjectileHit, )

The effect-specific area-of-effect (splash) or cloud-spawning (lingering) behavior.

fn thrown_potion_default_gravity(&self) -> f64

Returns the gravity of thrown potions (default is 0.05)

fn thrown_potion_knockback_direction( &self, hurt_entity: &dyn LivingEntity, ) -> (f64, f64)

Returns the horizontal direction from the potion to the hurt entity

fn thrown_potion_on_hit(self: Arc<Self>, hit: &ProjectileHit)

where Self: Sized + 'static,

Handles impact effects emits the break event and discards the potion

fn affect_entities_around( self: &Arc<Self>, world: &Arc<World>, contents: &PotionContents, )

where Self: Sized + 'static,

Hurts water-sensitive entities in range and extinguishes burning ones, as allowed by the potion’s tags.

fn thrown_potion_on_hit_block(&self, hit: &ClipHitResult)

Handles block impact and douses nearby fire for DOUSES_FIRE potions.

fn douse_fire(&self, world: &Arc<World>, pos: BlockPos)

Puts out fire, lit campfires and lit candles at pos.

impl DowncastType for SplashPotionEntity

const TYPE_KEY: DowncastTypeKey

The process-wide key for this concrete type.

impl Entity for SplashPotionEntity

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 tick(self: Arc<Self>)

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

fn get_default_gravity(&self) -> f64

Gets the default gravity for this entity type.

fn sound_source(&self) -> SoundSource

Returns this entity’s vanilla sound source category.

fn spawn_data(&self) -> i32

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

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 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 synced_data(&self) -> Option<&dyn EntitySyncedData>

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

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

Returns whether this entity ignores chunk ticking visibility.

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

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

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 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 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 the block state this entity’s origin currently overlaps.

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 whether the bounding box shifted by delta is free of block collisions and liquids.

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

Returns whether this entity can be attacked.

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

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

fn is_pushable(&self) -> bool

Returns whether this entity participates in vanilla push separation.

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 bubble-column surface push velocity, dispatching to the projectile override when this entity is a projectile.

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 bubble-column push velocity while submerged in the column, dispatching to the projectile override when this entity is a projectile.

fn default_on_inside_bubble_column(&self, drag_down: bool)

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

fn is_spectator(&self) -> bool

Returns whether this entity is invisible to normal entity selectors.

fn is_ignoring_block_triggers(&self) -> bool

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

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

Returns the living entity credited as this explosion’s indirect source.

fn explosion_damage_origin(&self) -> DVec3

Returns the point used to calculate this entity’s explosion direction.

fn ignore_explosion(&self, _explosion: &dyn Explosion) -> bool

Returns whether this entity is wholly ignored by an explosion.

fn block_explosion_resistance( &self, explosion: &dyn Explosion, world: &World, pos: BlockPos, state: BlockStateId, fluid: FluidState, resistance: f32, ) -> f32

Lets an entity source modify effective block or fluid resistance.

fn should_block_explode( &self, explosion: &dyn Explosion, world: &World, pos: BlockPos, state: BlockStateId, power: f32, ) -> bool

Lets an entity source veto one affected block position.

fn on_explosion_hit(&self, _explosion_source: Option<&dyn Entity>)

Called after this entity is processed by an explosion.

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 whether this entity is invisible, per its synced entity data.

fn is_discrete(&self) -> bool

Returns whether this entity is sneaking (shift key down), per its synced entity data.

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

fn is_hard_collision_relevant(&self) -> bool

Whether movement queries must consider this entity for hard collisions.

fn can_be_hit_by_projectile(&self) -> bool

Returns whether projectile collision may interact 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 stop_riding(&self)

Stops riding the current vehicle, if any.

fn eject_passengers(&self)

Dismounts every passenger from this entity.

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

Starts riding entity_to_ride if vanilla boarding rules allow it.

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 whether this entity’s passengers are forced to dismount when it goes underwater, per the dismounts_underwater entity type tag.

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 default_passenger_attachment_point(&self, passenger: &dyn Entity) -> DVec3

Returns this vehicle’s passenger attachment point for this entity’s dimensions and seat index, rotated by the vehicle’s yaw.

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

Returns the vehicle-relative position where this passenger attaches to.

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 as_default_entity_push(&self) -> Option<&dyn DefaultEntityPush>

Opts this entity into the DefaultEntityPush fast path. It is read under the entity manager lock, so it must give the same answer for the entity’s whole lifetime and have no side effects.

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 this entity’s position relative to the portal, in portal-local space; living entities have their forward-axis offset reset to zero.

fn default_tick(&self)

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

fn ride_tick(self: Arc<Self>)

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

fn default_ride_tick(self: Arc<Self>)

The default implementation of Entity.rideTick when not overridden.

fn base_tick(&self)

Runs vanilla Entity.baseTick pieces Steel currently implements.

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

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

Updates synchronized entity data just before tracker sync.

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.

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

Called after a teleport completes successfully.

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

Shears the first shearable equipped item on this mob, spawning it as a dropped item and playing its shearing sound; returns whether anything was sheared.

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

Shared right-click interaction for mobs: leashing/unleashing, cutting leash connections, or shearing equipment with shears.

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 as_abstract_minecart(&self) -> Option<&dyn AbstractMinecart>

Returns this entity as an AbstractMinecart if it has AbstractMinecart 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_monster(&self) -> bool

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

fn as_monster(&self) -> Option<&dyn Monster>

Returns the Monster capability, equivalent to vanilla’s instanceof Monster.

fn is_enemy(&self) -> bool

Whether this entity implements the Enemy marker.

fn as_enemy(&self) -> Option<&dyn Enemy>

Returns the Enemy marker, equivalent to vanilla’s instanceof Enemy.

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 whether this entity’s velocity should sync every tick because it’s currently fall-flying with an elytra.

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.

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

Returns vanilla’s base known movement before entity-specific adjustments.

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 the number of ticks this entity has existed for.

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 this entity’s tick counter by one.

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.

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

Returns the horizontal direction used for movement-dependent behavior.

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 this entity’s head yaw; 0.0 for non-living entities.

fn get_eye_height(&self) -> f64

Gets the eye height for this entity.

fn get_fluid_jump_threshold(&self) -> f64

Returns the fluid-surface height threshold used for fluid-jump physics: 0.0 for entities with eye height under 0.4, otherwise 0.4.

fn get_eye_y(&self) -> f64

Gets the Y coordinate of the entity’s eyes.

fn is_in_wall(&self) -> bool

Returns whether the entity is currently suffocating inside a solid block.

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

Computes a unit look-direction vector from the given pitch and yaw in degrees.

fn look_angle(&self) -> DVec3

Returns this entity’s current unit look-direction vector.

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 whether this entity’s velocity has changed enough to need syncing to clients.

fn mark_velocity_sync(&self)

Marks this entity’s velocity as needing to be synced to clients.

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)

Caps the accumulated fall distance at 1 once the entity is no longer falling faster than 0.5 blocks per tick.

fn fire_freeze_state(&self) -> EntityFireFreezeState

Returns the current vanilla fire/freeze state.

fn remaining_fire_ticks(&self) -> i32

Returns the ticks remaining before this entity stops burning.

fn set_remaining_fire_ticks(&self, remaining_fire_ticks: i32)

Sets the ticks remaining before this entity stops burning, clamped to this entity’s fire-ticks cap if any.

fn ticks_frozen(&self) -> i32

Returns ticks this entity has spent freezing in powder snow.

fn set_ticks_frozen(&self, ticks_frozen: i32)

Sets ticks this entity has spent freezing in powder snow, syncing the change to clients.

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

Ignites this entity in lava.

fn lava_hurt(&self)

Applies vanilla lava-contact damage after lava ignition effects.

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

Maximum ticks this entity’s remaining-fire timer can hold; None means unlimited.

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 whether this entity currently renders as visually on fire.

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 the ticks of powder-snow exposure required before this entity starts taking freeze damage.

fn is_fully_frozen(&self) -> bool

Returns whether this entity has reached full-freeze duration.

fn percent_frozen(&self) -> f32

Returns how frozen this entity is, from 0.0 to 1.0, based on ticks frozen versus ticks required.

fn clear_freeze(&self)

Clears accumulated freezing.

fn clear_fire(&self)

Clears fire without resetting the vanilla fire immunity cooldown.

fn extinguish_fire(&self)

Plays the extinguish sound when currently on fire, then clears fire.

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

Returns true if rain falls at this entity’s feet or at the top of its bounding box.

fn is_in_water_or_rain(&self) -> bool

Returns true if this entity is touching water or standing in rain.

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

Runs vanilla Entity.updateFluidInteraction: refreshes cached contact, emits the water-entry splash on transition, resets fall distance in water, and applies fluid currents.

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_impulses( &self, world: &Arc<World>, contact: EntityFluidContact, )

Applies vanilla water/lava current impulses from a fluid interaction update.

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: Arc<Self>, fall_distance: f64, damage_modifier: f32, source: &DamageSource, ) -> bool

Applies vanilla fall damage.

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.

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

What vanilla’s /teleport does once an entity has moved: unless it is gliding, it ends up on the ground without vertical motion.

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: Arc<Self>, world: &Arc<World>, accepted: AcceptedClientMovement, ) -> Result<AcceptedClientMovementOutcome, EntityMoveError>

Default final state application for accepted client-authored movement.

fn apply_accepted_client_movement( self: Arc<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: Arc<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 try_set_position_base(&self, pos: DVec3) -> Result<(), EntityMoveError>

The base method to set the entity’s position through world lifecycle validation.

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

Moves this entity to pos, keeping its current rotation.

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

Returns the vanilla block speed factor applied after movement.

fn block_speed_factor(&self) -> f32

Returns the block speed factor applied after movement.

fn block_jump_factor(&self) -> f32

Returns the jump-height multiplier from the block at this entity’s position, falling back to the block below when the current one doesn’t modify jumps.

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 fudge_position_after_size_change( &self, previous_dimensions: EntityDimensions, ) -> bool

Moves the entity to the closest free position for its new dimensions within the previous dimensions’ footprint, returning whether a valid position was found. Vanilla runs this after growing in a confined space; Steel’s ThrownEgg hatchlings also use it to fit a newborn chick at the egg’s impact point.

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.

fn air_supply(&self) -> i32

Returns this entity’s current air supply in ticks, synced to clients.

fn set_air_supply(&self, air_supply: i32)

Sets this entity’s air supply in ticks, syncing the change to clients.

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

Returns the sound played when this entity enters water at low speed.

fn swim_high_speed_splash_sound(&self) -> SoundEventRef

Returns the sound played when this entity enters water at high speed.

fn do_water_splash_effect(&self)

Plays the vanilla water-entry splash sound and emits SPLASH.

fn default_do_water_splash_effect(&self)

The default implementation of Entity.doWaterSplashEffect when not overridden.

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

Returns true if gravity is disabled for this entity.

fn set_no_gravity(&self, no_gravity: bool)

Sets whether this entity ignores gravity, syncing the change to clients.

fn is_invulnerable(&self) -> bool

Returns whether this entity is invulnerable to non-bypassing damage.

fn set_invulnerable(&self, invulnerable: bool)

Sets whether this entity is invulnerable to non-bypassing damage.

fn get_gravity(&self) -> f64

Gets the current gravity value.

fn get_air_drag(&self) -> f64

get the air drag value of the entity

fn apply_gravity(&self)

Applies gravity to the entity’s velocity.

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

Adds input scaled by speed, rotated to face this entity’s current yaw, to its velocity.

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

Moves the entity without collision physics.

fn default_move_entity( self: Arc<Self>, mover_type: MoverType, delta: DVec3, ) -> Option<MoveResult>

Moves the entity with collision detection.

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

Moves the entity with collision detection.

fn apply_fall_damage_after_move( self: Arc<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: Arc<Self>, movement: DVec3, on_ground: bool, world: &Arc<World>, ) -> bool

Applies fall damage from the block fallen on, then returns whether the entity was removed (e.g. killed) as a result.

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

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

fn send_landing_particles( &self, world: &World, on_state: BlockStateId, pos: BlockPos, )

Sends the vanilla landing burst for living entities with enough fall power.

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

Accumulates fall distance, applies landing damage from the block fallen on, and resets it.

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

Determines the supporting block state and position underneath the entity while grounded.

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 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<'_, '_>)

Spawn-item data is merged into the entity’s current save state before it is loaded. Keeping that merge at the entity boundary preserves defaults and entity-specific state when the component only overrides one field.

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

Returns whether this entity is immune to damage from source: already removed, or invulnerable and the source doesn’t bypass invulnerability.

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

Applies damage to this entity.

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.

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.

impl Projectile for SplashPotionEntity

fn projectile_base(&self) -> &ProjectileBase

Returns shared projectile runtime state.

fn calculate_horizontal_hurt_knockback_direction( &self, hurt_entity: &dyn LivingEntity, _damage_source: &DamageSource, ) -> (f64, f64)

Returns the horizontal hurt-knockback vector used for this projectile.

fn on_hit(self: Arc<Self>, hit: &ProjectileHit)

Vanilla Projectile.onHit. Subclasses override this and call Projectile::projectile_on_hit for the base dispatch (super.onHit()).

fn on_hit_block(self: Arc<Self>, hit: &ClipHitResult)

Default block-hit hook; concrete projectiles override this and call Projectile::projectile_on_hit_block to preserve the base dispatch.

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

Applies bubble-column surface acceleration without clamping velocity.

fn on_inside_bubble_column_projectile(&self, drag_down: bool)

Applies inside-bubble-column acceleration without clamping velocity.

fn set_owner_uuid(&self, owner: Option<Uuid>)

Sets the persisted owner UUID and clears the live owner cache.

fn set_owner_entity(&self, owner: Option<&SharedEntity>)

Sets the owning entity and caches its live reference.

fn cache_owner_entity(&self, owner: &SharedEntity)

Caches a live owner reference when it matches the saved owner UUID.

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

Returns the owner UUID, if any.

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

Resolves the cached owner, then looks up its UUID in the current domain.

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

Returns whether this projectile may interact with the block at pos: defers to the owning player’s build permission, or the mobGriefing rule for a non-player owner.

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

Returns whether this projectile type is allowed to break the blocks it hits, per the mobGriefing-gated projectilesCanBreakBlocks game rule.

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

Returns whether entity is this projectile’s owner.

fn has_been_shot(&self) -> bool

Returns whether this projectile has been shot, as opposed to just spawned.

fn set_has_been_shot(&self, value: bool)

Marks whether this projectile has been shot.

fn left_owner(&self) -> bool

Returns whether this projectile has moved outside its owner’s collision range.

fn check_left_owner(&self)

Updates whether this projectile has left its owner’s collision range, but only the first time it’s called each tick.

fn reset_left_owner_checked(&self)

Resets the per-tick left-owner check flag (vanilla clears it after tick).

fn is_outside_owner_collision_range(&self) -> bool

Returns whether this projectile’s expanded bounding box no longer overlaps its owner or any entity riding the same vehicle tree.

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

Returns vanilla Projectile.canHitEntity. Use this if you don’t need to override.

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

Returns vanilla Projectile.canHitEntity. We had to split this up, because Rust doesn’t allow for calling super trait fns (without causing unbounded recursion) for overrides, so otherwise vanilla behavior would not be achievable.

fn get_movement_to_shoot( &self, direction: DVec3, power: f32, uncertainty: f32, ) -> DVec3

Returns the velocity vector for shooting toward direction at power, with random spread scaled by uncertainty.

fn shoot(&self, direction: DVec3, power: f32, uncertainty: f32)

Sets this projectile’s velocity and facing rotation toward direction at power, with random spread scaled by uncertainty.

fn shoot_from_rotation( &self, source: &dyn Entity, x_rot: f32, y_rot: f32, y_offset: f32, power: f32, uncertainty: f32, )

Shoots this projectile from source’s rotation (offset by y_offset), adding the source’s own movement on top.

fn update_rotation(&self)

Runs vanilla Projectile.updateRotation (lerped toward the movement vector).

fn deflect( &self, deflection: ProjectileDeflection, deflecting_entity: Option<&dyn Entity>, new_owner: Option<EntityReference>, by_attack: bool, ) -> bool

Applies a Vanilla projectile deflection.

fn on_deflection(&self, _by_attack: bool)

Called after a successful Vanilla projectile deflection.

fn should_bounce_on_world_border(&self) -> bool

Returns whether this projectile bounces from the world border.

fn get_hit_result_on_move_vector(&self) -> Option<ProjectileHit>

Casts the move vector and returns the nearest block/entity hit (vanilla ProjectileUtil.getHitResultOnMoveVector with this::canHitEntity).

fn hit_target_or_deflect_self( self: Arc<Self>, hit: &ProjectileHit, ) -> ProjectileDeflection

Handles a projectile hit, deflecting it off an entity or the world border instead of resolving the hit when deflection applies.

fn projectile_on_hit(self: Arc<Self>, hit: &ProjectileHit)

The base Projectile.onHit dispatch to block/entity handlers. Not meant to be overridden — override Projectile::on_hit and delegate here instead.

fn on_hit_entity(self: Arc<Self>, _entity: &SharedEntity, _location: DVec3)

Vanilla Projectile.onHitEntity (no-op by default).

fn projectile_on_hit_block(&self, hit: &ClipHitResult)

The base Projectile.onHitBlock implementation. Concrete projectiles that override the hook call this to preserve the Java super dispatch.

fn hurt(&self, _world: &World, source: &DamageSource, _amount: f32) -> bool

Vanilla Projectile.hurtServer: marks hurt unless invulnerable to the base checks, but never takes damage.

fn projectile_base_tick(&self)

Vanilla Projectile.tick (the super.tick() reached from subclasses).

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

Saves vanilla Projectile fields (Owner, LeftOwner, HasBeenShot).

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

Loads vanilla Projectile fields (Owner, LeftOwner, HasBeenShot).

impl ThrowableItemProjectile for SplashPotionEntity

fn get_default_item(&self) -> ItemRef

Returns the item stack used when no persisted item can be loaded (e.g. a plain ender pearl, snowball, or egg).

fn set_item(&self, item: ItemStack)

Sets the rendered item stack (vanilla setItem, count clamped to 1).

fn get_item(&self) -> ItemStack

Returns the rendered item stack (vanilla getItem).

fn set_item_clamped(&self, item: ItemStack)

Sets the rendered item stack, clamping its count to 1.

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

Saves the item stack to NBT, omitting the tag entirely when the stack is empty.

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

Loads the item stack, falling back to the default item (vanilla readAdditionalSaveData).

impl ThrowableProjectile for SplashPotionEntity

fn get_air_drag(&self) -> f32

Air drag multiplier applied to velocity each tick while airborne (0.99, i.e. 1% loss).

fn throwable_default_gravity(&self) -> f64

Downward acceleration applied each tick while this projectile is airborne.

fn apply_inertia(&self)

Vanilla ThrowableProjectile.applyInertia (water vs air drag).

fn throwable_projectile_tick(self: Arc<Self>)

Reached from a subclass’s tick as super.tick(). Applies gravity and drag, raycasts the move vector, moves to the hit (or full move), updates rotation, runs the Projectile/Entity base tick, then resolves the hit.

fn handle_first_tick_bubble_column(&self)

Applies bubble-column effects to this projectile on its first tick.