Trait Projectile 

pub trait Projectile: Entity + ProjectileEventSource {
    // Required method
    fn projectile_base(&self) -> &ProjectileBase;

    // Provided methods
    fn calculate_horizontal_hurt_knockback_direction(
        &self,
        _hurt_entity: &dyn LivingEntity,
        _damage_source: &DamageSource,
    ) -> (f64, f64) { ... }
    fn on_above_bubble_column_projectile(&self, drag_down: bool, pos: BlockPos) { ... }
    fn on_inside_bubble_column_projectile(&self, drag_down: bool) { ... }
    fn set_owner_uuid(&self, owner: Option<Uuid>) { ... }
    fn set_owner_entity(&self, owner: Option<&SharedEntity>) { ... }
    fn cache_owner_entity(&self, owner: &SharedEntity) { ... }
    fn owner_uuid(&self) -> Option<Uuid> { ... }
    fn get_owner(&self) -> Option<SharedEntity> { ... }
    fn projectile_may_interact(&self, world: &World, pos: BlockPos) -> bool { ... }
    fn may_break(&self, world: &World) -> bool { ... }
    fn owned_by(&self, entity: &dyn Entity) -> bool { ... }
    fn has_been_shot(&self) -> bool { ... }
    fn set_has_been_shot(&self, value: bool) { ... }
    fn left_owner(&self) -> bool { ... }
    fn check_left_owner(&self) { ... }
    fn reset_left_owner_checked(&self) { ... }
    fn is_outside_owner_collision_range(&self) -> bool { ... }
    fn can_hit_entity(&self, entity: &dyn Entity) -> bool { ... }
    fn base_can_hit_entity(&self, entity: &dyn Entity) -> bool { ... }
    fn get_movement_to_shoot(
        &self,
        direction: DVec3,
        power: f32,
        uncertainty: f32,
    ) -> DVec3 { ... }
    fn shoot(&self, direction: DVec3, power: f32, uncertainty: f32) { ... }
    fn shoot_from_rotation(
        &self,
        source: &dyn Entity,
        x_rot: f32,
        y_rot: f32,
        y_offset: f32,
        power: f32,
        uncertainty: f32,
    ) { ... }
    fn update_rotation(&self) { ... }
    fn deflect(
        &self,
        deflection: ProjectileDeflection,
        deflecting_entity: Option<&dyn Entity>,
        new_owner: Option<EntityReference>,
        by_attack: bool,
    ) -> bool { ... }
    fn on_deflection(&self, _by_attack: bool) { ... }
    fn should_bounce_on_world_border(&self) -> bool { ... }
    fn get_hit_result_on_move_vector(&self) -> Option<ProjectileHit> { ... }
    fn hit_target_or_deflect_self(
        self: Arc<Self>,
        hit: &ProjectileHit,
    ) -> ProjectileDeflection { ... }
    fn on_hit(self: Arc<Self>, hit: &ProjectileHit) { ... }
    fn projectile_on_hit(self: Arc<Self>, hit: &ProjectileHit) { ... }
    fn on_hit_entity(self: Arc<Self>, _entity: &SharedEntity, _location: DVec3) { ... }
    fn on_hit_block(self: Arc<Self>, hit: &ClipHitResult) { ... }
    fn projectile_on_hit_block(&self, hit: &ClipHitResult) { ... }
    fn hurt(&self, _world: &World, source: &DamageSource, _amount: f32) -> bool { ... }
    fn projectile_base_tick(&self) { ... }
    fn save_projectile(&self, nbt: &mut NbtCompound) { ... }
    fn load_projectile(&self, nbt: BorrowedNbtCompoundView<'_, '_>) { ... }
}

Vanilla-shaped behavior shared by entities that extend Projectile.

Required Methods

fn projectile_base(&self) -> &ProjectileBase

Returns shared projectile runtime state.

Provided Methods

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

Dyn Compatibility

This trait is dyn compatible.

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

Implementors

impl Projectile for EnderPearlEntity

impl Projectile for FireworkRocketEntity

impl Projectile for FishingHookEntity

impl Projectile for LingeringPotionEntity

impl Projectile for SnowballEntity

impl Projectile for SplashPotionEntity

impl Projectile for ThrownEggEntity