Files
horizon-airdef/crates/horizon-client/src/motion.rs
T
Ludovic Marie 4c348837e4 Merge pull request #2335 from kacpherek/fix/frost-walker
🤖 Agent: Merged by Ludovic's AI agent (Claude, contrib-gate-19) after the contribution gate. Checked against vanilla 26.3 and proven in union/cg19-r2 (all round-2 PRs together: clippy, 1722 tests, 135 harnesses, lan_e2e in-frame and on the server thread) and union/cg19-r3 (the same PRs merged with today's main: 96/96 harnesses). Thanks @kacpherek.
2026-10-27 17:32:25 +01:00

4331 lines
170 KiB
Rust

//! Stored movement state for the resident scene. This binds the validated air,
//! jump, collision, support, restitution and stored health bindings, and
//! powder snow's block-inside effects and freezing. Entity lifecycle, other
//! block-inside effects and audiovisual event consumers remain separate work.
use crate::{Result, assets::Assets, collisions::SceneCollisions, world::World};
use horizon_core::{
geometry::{Aabb, Axis, Direction, Vec3, VoxelShape, traverse_blocks},
position::BlockPos,
random::RandomSource,
};
use horizon_world::{
attribute_map::ValueKind,
attributes::{Modifier, Operation, entity::Catalog, live::LiveAttributes},
block_collision::BlockCollisionRegistry,
block_landing::BlockLandingRegistry,
collision_context::{CollisionContext, CollisionEntity, CollisionItem},
edge_backoff::{self, EdgeBackoffInput, EdgeBackoffWorld},
entity_move::{self, CollisionFlags, EntityMoveWorld, MovementHistory, MoverType},
entity_obstruction::EntityIdentity,
ground_support::{GroundState, find_supporting_block},
living_air::{self, LivingAirWorld},
living_fall::ImpulseContext,
living_motion::{self, LivingMotionWorld},
movement_emission::{
self as emission, MovementDistances, MovementEmission, MovementEmissionWorld, MovementEvent,
},
movement_properties::{
BoundMovementProperties, MovementBlockProvider, MovementProperties, MovementTags,
RegistryMovementWorld,
},
movement_restitution::{self, RestitutionInput, RestitutionWorld},
movement_statistics::{self, MovementStat, MovementStatisticsWorld},
movement_support::{self, MovementLocation},
registry::{BlockStateId, BlockTableFile},
world_movement::{self, MovementRequest},
worldgen::tags::TagDefinitions,
};
use std::{
collections::{BTreeMap, BTreeSet},
fs, io,
path::Path,
sync::Arc,
};
pub(crate) mod environment;
mod fluids;
pub use fluids::{FluidResources, FluidTags, LAVA, PlayerFluids, WATER, bubble_column_push};
pub struct MotionResources {
pub attributes: Arc<Catalog>,
pub blocks: BoundMovementProperties,
pub climbable: BTreeSet<String>,
/// `BlockTags.CAN_GLIDE_THROUGH`: climbable blocks a gliding player passes.
pub glide_through: BTreeSet<String>,
/// `BlockTags.SOUL_SPEED_BLOCKS`: what Soul Speed's effects look for.
pub soul_speed_blocks: BTreeSet<String>,
pub fall_reset: BTreeSet<String>,
/// `BlockTags.INSIDE_STEP_SOUND_BLOCKS`.
pub inside_step_sound: BTreeSet<String>,
/// `BlockTags.COMBINATION_STEP_SOUND_BLOCKS`.
pub combination_step_sound: BTreeSet<String>,
/// `BlockTags.CRYSTAL_SOUND_BLOCKS`: blocks that chime under footsteps.
pub crystal_sound: BTreeSet<String>,
pub landing: BlockLandingRegistry,
pub health: crate::health::HealthResources,
pub fluids: FluidResources,
}
impl MotionResources {
/// [`Self::load_with_facts`] with the block facts decoded here.
pub fn load(root: &Path, assets: &Assets) -> Result<Self> {
Self::load_with_facts(
root,
assets,
&crate::blocks::BlockFacts::load(root, assets.registry)?,
)
}
/// The motion tables, with the block facts the game already decoded
/// (decoding `gameplay-facts.json` again costs a second or more and, with
/// a big modpack, hundreds of megabytes while it runs).
pub fn load_with_facts(
root: &Path,
assets: &Assets,
facts: &crate::blocks::BlockFacts,
) -> Result<Self> {
let attributes = Arc::new(Catalog::from_json(&serde_json::from_slice(&fs::read(
root.join("attributes.json"),
)?)?)?);
let file = BlockTableFile::open(&root.join("movement-properties.nbt"), assets.registry)?;
let properties = MovementProperties::from_table(file.table("movement")?)?;
let bundle: BTreeMap<String, String> =
serde_json::from_slice(&fs::read(root.join("block-tags.json"))?)?;
let mut definitions = TagDefinitions::default();
for (name, text) in bundle {
definitions.apply_json(&name, "vanilla", &text)?;
}
let built = definitions
.build(|name, _| assets.registry.default_state(name).map(|_| name.to_owned()))?;
if !built.missing.is_empty() {
return Err("unresolved motion block tags".into());
}
let tag = |name: &str| -> Result<BTreeSet<String>> {
Ok(built
.tags
.get(name)
.ok_or_else(|| format!("missing motion tag {name}"))?
.iter()
.cloned()
.collect())
};
Ok(Self {
landing: crate::landing::load(root, &properties)?,
health: crate::health::HealthResources::load(root)?,
fluids: FluidResources::new(assets, facts)?,
attributes,
blocks: properties.bind(&MovementTags {
fences: tag("minecraft:fences")?,
walls: tag("minecraft:walls")?,
suppresses_bounce: tag("minecraft:suppresses_bounce")?,
})?,
climbable: tag("minecraft:climbable")?,
glide_through: tag("minecraft:can_glide_through")?,
soul_speed_blocks: tag("minecraft:soul_speed_blocks")?,
fall_reset: tag("minecraft:fall_damage_resetting")?,
inside_step_sound: tag("minecraft:inside_step_sound_blocks")?,
combination_step_sound: tag("minecraft:combination_step_sound_blocks")?,
crystal_sound: tag("minecraft:crystal_sound_blocks")?,
})
}
}
/// What the `location_changed` enchantment effects (Soul Speed) need to know
/// between ticks.
#[derive(Clone, Debug, Default)]
pub struct LocationEffects {
/// `MovementAffectedByPredicate`: the block under the player
/// (`getBlockPosBelowThatAffectsMyMovement`) is in `#minecraft:soul_speed_blocks`.
pub on_soul_speed_block: bool,
/// `LivingEntity.lastPos`: the block the player was in last tick.
pub block: Option<BlockPos>,
/// A landing ran `onChangedBlock` (`LivingEntity.checkFallDamage`).
pub landed: bool,
/// The Soul Speed level of the boots seen last tick (0: none).
pub boots_level: u32,
/// The Soul Speed level whose attribute modifiers are on the player (0: none).
pub applied_level: u32,
}
/// Ordered requests and phase records for world/audio/network consumers. Landing
/// hurt dispatch updates stored health synchronously before these are drained.
#[derive(Clone, Copy, Debug)]
pub enum MotionEvent {
Waypoint {
receiver: bool,
enabled: bool,
},
Health(crate::health::HealthEvent),
/// `LivingEntity.handleDamageEvent`: the hurt sound the player hears.
HurtSound(&'static str),
Fall(crate::landing::FallEvent),
Recorded {
mover: MoverType,
movement: Vec3,
},
Landing {
dy: f64,
grounded: bool,
state: BlockStateId,
position: BlockPos,
},
/// `Entity.walkingStepSound` on this block: `Player.playStepSound`
/// mutes it (`playMuffledStepSound`) under a swim sound in water or
/// under a combination block's own step.
Emission {
position: BlockPos,
state: BlockStateId,
muffled: bool,
},
/// `Entity.playAmethystStepSound`: `block.amethyst_block.chime`.
Chime {
volume: f32,
pitch: f32,
},
/// `Entity.waterSwimSound`: `entity.player.swim`.
Swim {
volume: f32,
pitch: f32,
},
Bounce {
position: BlockPos,
state: BlockStateId,
fall_distance: f64,
},
/// `PowderSnowBlock.entityInside`'s server particle: one snowflake at
/// `position` with `velocity` (`RandomizationType.ALTERNATIVE`).
Snowflake {
position: Vec3,
velocity: Vec3,
},
/// `ServerPlayer.onInsideBlock`: the enter_block criterion trigger.
EnterBlock {
state: BlockStateId,
},
/// `NetherPortalBlock.entityInside`: the player's box swept through a
/// nether portal block.
InsidePortal {
pos: BlockPos,
},
/// `LayeredCauldronBlock.handleEntityOnFireInside`: a burning player in
/// a water or powder snow cauldron; the server lowers its fill level.
CauldronExtinguish {
pos: BlockPos,
},
/// `WitherRoseBlock.entityInside`: the player's box swept through a
/// wither rose; the server adds its Wither unless peaceful.
InsideWitherRose,
/// `ServerPlayer.checkFallDamage` after a mace smash: block particles
/// from the landing block, more the further the fall.
SmashLanding {
state: BlockStateId,
position: BlockPos,
fall_distance: f64,
},
/// `Entity.doWaterSplashEffect`: the player's splash (or high-speed
/// splash) sound at its position...
Splash {
high_speed: bool,
volume: f32,
pitch: f32,
},
/// ...its BUBBLE (else SPLASH) particles...
SplashParticle {
bubble: bool,
position: Vec3,
velocity: Vec3,
},
/// ...and the SPLASH game event.
SplashEvent,
/// `Entity.sendBubbleColumnParticles`: a SPLASH (or BUBBLE) particle
/// over the top of a bubble column the player rides.
BubbleColumnParticle {
bubble: bool,
position: Vec3,
},
/// `HoneyBlock.maybeDoSlideEffects` for a player sliding down the side of
/// the honey block at `pos`: its slide sound, and the server's entity
/// event 53 (the five block particles at the player).
HoneySlide {
pos: BlockPos,
sound: bool,
particles: bool,
},
/// Entity event 67 (`LivingEntity.makeDrownParticles`): eight bubbles
/// around a drowning player.
Drown,
}
pub struct PlayerMotion {
pub swimming: bool,
pub fire_ticks: i32,
pub air: i32,
pub respiration: i32,
pub position: Vec3,
pub velocity: Vec3,
pub ground: GroundState,
pub collision: CollisionFlags,
pub history: MovementHistory,
pub fall_distance: f64,
pub stuck_multiplier: Vec3,
/// `Entity.pistonDeltas` and `pistonDeltasGameTime`: how far a moving
/// block has pushed this entity this tick (0.51 at most on any axis).
pub piston: horizon_world::piston_movement::PistonMovement,
pub yaw: f32,
pub head_yaw: f32,
pub jumping: bool,
pub no_jump_delay: i32,
pub jump_trigger_time: i32,
/// Abilities.mayfly / flying (creative flight).
pub may_fly: bool,
/// Abilities.invulnerable (creative): only damage bypassing invulnerability hurts.
pub invulnerable: bool,
/// Spectator mode: no physics, always flying (`Player.tick`).
pub spectator: bool,
pub flying: bool,
/// Client-side `Abilities.flyingSpeed`, adjusted by the spectator scroll wheel.
pub flying_speed: f32,
/// The jump key last tick (LocalPlayer.aiStep's wasJumping).
pub was_jumping: bool,
/// `LocalPlayer.autoJumpEnabled` (the Auto-Jump option) and
/// `autoJumpTime`; `was_auto_jump` is this tick's `wasAutoJump`.
pub auto_jump_enabled: bool,
pub auto_jump_time: i32,
pub was_auto_jump: bool,
/// `input.getMoveVector()` this tick (before `modifyInput`).
pub move_vector: [f32; 2],
/// A usable glider (elytra) is worn; the game sets it each tick.
pub glider: bool,
/// The view pitch (xRot), for gliding.
pub pitch: f32,
/// Gliding (shared flag 7) and LivingEntity.fallFlyTicks.
pub fall_flying: bool,
/// Asleep in a bed (`LivingEntity.isSleeping`): the sleeping pose.
pub sleeping: bool,
pub fall_fly_ticks: i32,
/// The server saw the glide end last tick (`updateFallFlying`'s `canGlide`
/// failed): the cleared flag reaches the client at its next tick.
pub glide_ending: bool,
/// Glider durability to take this tick (updateFallFlying).
pub glider_wear: u32,
/// Soul Speed's `location_changed` bookkeeping.
pub location_effects: LocationEffects,
/// `LivingEntity.autoSpinAttackTicks` and `autoSpinAttackDmg`: Riptide's
/// spin. The damage stays until the game has dealt the hit.
pub auto_spin_attack_ticks: i32,
pub auto_spin_attack_dmg: f32,
/// The living entities the game put near a spinning player (id, box).
pub spin_targets: Vec<(u32, Aabb)>,
/// The entity the spin touched this tick (`doAutoAttackOnTouch`).
pub spin_hit: Option<u32>,
pub sprinting: bool,
pub sprint_input: crate::sprint::SprintState,
pub shift_key_down: bool,
pub local_crouching: bool,
pub pose: crate::pose::Pose,
pub dimensions: crate::pose::Dimensions,
pub speed: f32,
/// `LocalPlayer.itemUseSpeedMultiplier` while using an item (not riding).
pub item_use_speed: Option<f32>,
pub last_climbable: Option<BlockPos>,
/// `Entity.moveDist`, `flyDist` and `nextStep`: footsteps come once per
/// metre walked, not once per move.
pub steps: MovementDistances,
/// `Entity.crystalSoundIntensity` and `lastCrystalSoundPlayTick`: the
/// amethyst chime grows with steps taken close together.
pub crystal_sound_intensity: f32,
pub last_crystal_sound_play_tick: i32,
pub needs_sync: bool,
pub sync_position: bool,
/// Moved by an ender pearl (`ServerPlayer.teleport`): a server sends the
/// position packet even when the player lands where they stood. The
/// server takes it at the end of a guest's turn.
pub teleported: bool,
pub events: Vec<MotionEvent>,
pub attributes: LiveAttributes<Box<dyn FnMut() -> i32>>,
pub impulse: ImpulseContext,
/// `ServerPlayer.spawnExtraParticlesOnFall`: a mace smash on a grounded
/// target makes the next landing throw up the block below.
pub spawn_extra_particles_on_fall: bool,
pub health: crate::health::PlayerHealth,
/// Status effects and armor protection seen by movement and damage.
pub status: crate::effects::StatusFlags,
/// Water and lava around the player (`Entity.fluidInteraction`).
pub fluids: PlayerFluids,
/// `Entity.isInPowderSnow` / `wasInPowderSnow`.
pub in_powder_snow: bool,
pub was_in_powder_snow: bool,
/// `Entity.DATA_TICKS_FROZEN`.
pub ticks_frozen: i32,
/// Leather boots on the feet (`PowderSnowBlock.canEntityWalkOnPowderSnow`).
pub leather_boots: bool,
/// An armor piece in `#freeze_immune_wearables` (`LivingEntity.canFreeze`).
pub freeze_immune: bool,
/// A worn enchantment's `damage_immunity` to `#burn_from_stepping` (frost walker).
pub burn_from_stepping_immune: bool,
/// `Entity.oldPosition`: where this tick started.
pub old_position: Vec3,
/// The server's copy of a player another client moves (a LAN guest), while
/// it travels on the server: `isLocalInstanceAuthoritative` is false, so
/// its moves check no fall damage.
pub server_copy: bool,
/// The span of `events` a wall hit on the server's copy pushed (sound and
/// damage): `server_travel` keeps them while it drops the simulated moves.
pub wall_hit_events: Option<std::ops::Range<usize>>,
/// A client's copy of its own player (`Level.isClientSide`): only the
/// server hurts it (`Entity.hurt` does nothing on a client) and ticks its
/// food (`ServerPlayer.tick`). Its hurt animation comes from the server.
pub client_side: bool,
/// `Entity.applyEffectsFromBlocks` runs after travel (always in the game;
/// differential fixtures turn it off where their reference does).
pub block_effects: bool,
/// The powder snow blocks this tick's movement went into: the game
/// destroys them if the player is burning, then puts the fire out.
pub powder_snow_entered: Vec<BlockPos>,
/// The last hurts taken (`hurt_blocking`), newest last, for tests and
/// the control socket's `hurtlog`.
pub hurt_log: Vec<crate::health::HurtRecord>,
/// The last melee attacks made on mobs, newest last.
pub attack_log: Vec<crate::health::AttackRecord>,
/// The level's world border, whose walls stop the player's movement
/// from inside (the game keeps it current; None: no border).
pub border: Option<horizon_core::geometry::border::BorderGeometry>,
}
fn attribute_error(error: impl std::fmt::Debug) -> io::Error {
io::Error::other(format!("movement attribute: {error:?}"))
}
impl PlayerMotion {
/// `Player.isSweepAttack`, using the resident player's known horizontal velocity.
pub fn is_sweep_attack(&self, strength: f32, critical: bool, sword: bool) -> bool {
let movement = self.velocity;
let limit = f64::from(self.speed) * 2.5;
strength > 0.9
&& !critical
&& !self.sprinting
&& self.ground.on_ground
&& movement.x * movement.x + movement.z * movement.z < limit * limit
&& sword
}
/// Restore login state once; a later respawn starts with fresh health and food.
pub fn load_saved_state_once(
&mut self,
pending: &mut bool,
level: &crate::save::Level,
) -> Result<()> {
if std::mem::take(pending) {
let extra = level.player_extra.as_ref();
self.fire_ticks = extra
.and_then(|t| crate::save::number(t.get("Fire")))
.unwrap_or(-20) as i32;
self.air = extra
.and_then(|t| crate::save::number(t.get("Air")))
.unwrap_or(300) as i32;
self.fall_distance = level.fall_distance;
self.set_health(level.health, false)?;
// LivingEntity.readAdditionalSaveData: internalSetAbsorptionAmount.
self.internal_set_absorption(level.absorption)?;
self.health.food.food = level.food;
self.health.food.saturation = level.saturation;
self.flying = level.flying;
}
Ok(())
}
pub fn set_remaining_fire_ticks(&mut self, ticks: i32) {
self.fire_ticks = if self.invulnerable {
ticks.min(1)
} else {
ticks
};
}
pub fn ignite_for_ticks(&mut self, ticks: i32) -> Result<()> {
let scaled = (f64::from(ticks) * self.attribute("minecraft:burning_time")?).ceil() as i32;
self.set_remaining_fire_ticks(self.fire_ticks.max(scaled));
self.ticks_frozen = 0;
Ok(())
}
pub fn new(resources: &MotionResources, position: Vec3) -> Result<Self> {
// Process-owned identities determine native collection callback order.
// Differential fixtures can replay a reference process's identities.
let hashes: Vec<_> = resources
.attributes
.attributes()
.enumerate()
.map(|(i, _)| i as i32)
.collect();
let mut identity = 0i32;
let next: Box<dyn FnMut() -> i32> = Box::new(move || {
identity = identity.wrapping_add(1);
identity
});
Self::with_attribute_identities(resources, position, &hashes, next)
}
/// Explicit identity allocation for deterministic reference replay.
pub fn with_attribute_identities(
resources: &MotionResources,
position: Vec3,
hashes: &[i32],
next: Box<dyn FnMut() -> i32>,
) -> Result<Self> {
let mut attributes = LiveAttributes::new(
resources.attributes.clone(),
"minecraft:player",
hashes,
next,
)
.map_err(attribute_error)?;
Ok(Self {
health: crate::health::PlayerHealth::new(&resources.health, &mut attributes)?,
status: crate::effects::StatusFlags::default(),
impulse: ImpulseContext::default(),
spawn_extra_particles_on_fall: false,
position,
velocity: Vec3::ZERO,
ground: GroundState::default(),
collision: CollisionFlags::default(),
history: MovementHistory::default(),
fall_distance: 0.0,
stuck_multiplier: Vec3::ZERO,
piston: Default::default(),
yaw: 0.0,
head_yaw: 0.0,
jumping: false,
no_jump_delay: 0,
jump_trigger_time: 0,
may_fly: false,
invulnerable: false,
spectator: false,
flying: false,
flying_speed: 0.05,
was_jumping: false,
auto_jump_enabled: false,
auto_jump_time: 0,
was_auto_jump: false,
move_vector: [0.0, 0.0],
glider: false,
pitch: 0.0,
fall_flying: false,
sleeping: false,
fall_fly_ticks: 0,
glide_ending: false,
glider_wear: 0,
location_effects: LocationEffects::default(),
auto_spin_attack_ticks: 0,
auto_spin_attack_dmg: 0.0,
spin_targets: Vec::new(),
spin_hit: None,
sprinting: false,
sprint_input: crate::sprint::SprintState::default(),
shift_key_down: false,
local_crouching: false,
pose: crate::pose::Pose::Standing,
dimensions: crate::pose::Pose::Standing.dimensions(1.0),
swimming: false,
fire_ticks: -20,
air: 300,
respiration: 0,
speed: 0.0,
item_use_speed: None,
last_climbable: None,
steps: MovementDistances {
next_step: 1.0,
..MovementDistances::default()
},
crystal_sound_intensity: 0.0,
last_crystal_sound_play_tick: 0,
needs_sync: false,
sync_position: false,
teleported: false,
events: Vec::new(),
attributes,
fluids: PlayerFluids::default(),
in_powder_snow: false,
was_in_powder_snow: false,
ticks_frozen: 0,
leather_boots: false,
freeze_immune: false,
burn_from_stepping_immune: false,
old_position: position,
server_copy: false,
wall_hit_events: None,
client_side: false,
block_effects: true,
powder_snow_entered: Vec::new(),
hurt_log: Vec::new(),
attack_log: Vec::new(),
border: None,
})
}
/// LivingEntity.aiStep: speeds too small to matter stop.
fn drop_tiny_velocity(&mut self) {
let v = &mut self.velocity;
if v.x * v.x + v.z * v.z < 9.0e-6 {
(v.x, v.z) = (0.0, 0.0);
}
if v.y.abs() < 0.003 {
v.y = 0.0;
}
}
/// `Entity.getTicksRequiredToFreeze`.
pub const TICKS_REQUIRED_TO_FREEZE: i32 = 140;
/// `Entity.getPercentFrozen`.
pub fn percent_frozen(&self) -> f32 {
self.ticks_frozen.min(Self::TICKS_REQUIRED_TO_FREEZE) as f32
/ Self::TICKS_REQUIRED_TO_FREEZE as f32
}
/// `Entity.isFullyFrozen`.
pub fn is_fully_frozen(&self) -> bool {
self.ticks_frozen >= Self::TICKS_REQUIRED_TO_FREEZE
}
/// `LivingEntity.canFreeze`: not a spectator, no freeze-immune armor.
pub fn can_freeze(&self) -> bool {
!self.spectator && !self.freeze_immune
}
/// What powder snow's contextual collision asks of the player.
pub fn powder_snow_subject(&self) -> crate::collisions::PowderSnowSubject {
crate::collisions::PowderSnowSubject {
fall_distance: self.fall_distance,
falling_block: false,
leather_boots: self.leather_boots,
walkable_type: false,
lava_walker: false,
}
}
/// `LivingEntity.tryAddFrost`: the frozen slowdown, on anything but air.
fn try_add_frost(&mut self, on_air: bool) -> Result<()> {
if on_air || self.ticks_frozen <= 0 {
return Ok(());
}
let Some(key) = self.attributes.key("minecraft:movement_speed") else {
return Ok(());
};
let Some(handle) = self
.attributes
.get_instance(Some(key))
.map_err(attribute_error)?
else {
return Ok(());
};
let slow = -0.05f32 * self.percent_frozen();
let modifier = Modifier::new(
"minecraft:powder_snow",
f64::from(slow),
Operation::AddValue,
)?;
self.attributes
.edit(&handle, |value, observer| {
value.add_transient(modifier, observer)
})
.map_err(attribute_error)?;
Ok(())
}
pub fn bounds(&self) -> Aabb {
self.dimensions.bounds(self.position)
}
pub fn attribute(&mut self, name: &str) -> Result<f64> {
let key = self
.attributes
.key(name)
.ok_or_else(|| format!("missing movement attribute {name}"))?;
Ok(self
.attributes
.value(Some(key), ValueKind::Computed)
.map_err(attribute_error)?)
}
/// Add (or remove) a transient attribute modifier, e.g. from equipment
/// (`LivingEntity.collectEquipmentChanges` applying item modifiers).
pub fn set_modifier(
&mut self,
attribute: &str,
id: &str,
amount: f64,
operation: &str,
present: bool,
) -> Result<()> {
let Some(key) = self.attributes.key(attribute) else {
return Ok(());
};
let Some(handle) = self
.attributes
.get_instance(Some(key))
.map_err(attribute_error)?
else {
return Ok(());
};
let operation = match operation {
"add_multiplied_base" => Operation::AddMultipliedBase,
"add_multiplied_total" => Operation::AddMultipliedTotal,
_ => Operation::AddValue,
};
let modifier = Modifier::new(id, amount, operation)?;
self.attributes
.edit(&handle, |value, observer| {
value.remove(modifier.id(), observer)?;
if present {
value.add_transient(modifier, observer)?;
}
Ok(())
})
.map_err(attribute_error)?;
Ok(())
}
pub fn set_sprinting(&mut self, sprinting: bool) -> Result<()> {
self.sprinting = sprinting;
let key = self
.attributes
.key("minecraft:movement_speed")
.ok_or("missing movement speed")?;
let handle = self
.attributes
.get_instance(Some(key))
.map_err(attribute_error)?
.ok_or("player has no movement speed")?;
let modifier = Modifier::new(
"minecraft:sprinting",
f64::from(0.3_f32),
Operation::AddMultipliedTotal,
)?;
self.attributes
.edit(&handle, |value, observer| {
value.remove(modifier.id(), observer)?;
if sprinting {
value.add_transient(modifier, observer)?;
}
Ok(())
})
.map_err(attribute_error)?;
Ok(())
}
/// Local input sprint phase (`LocalPlayer.aiStep`'s sprint decisions).
/// Vehicle, item-use and effect bindings remain separate; hunger, flight,
/// water and collision conditions use this actor's actual state.
pub fn sprint_input_tick(&mut self, keys: crate::sprint::Keys) -> Result<()> {
let conditions = crate::sprint::Conditions {
sprinting: self.sprinting,
enough_food: self.health.food.has_enough_food(),
may_fly: self.may_fly,
flying: self.flying,
// Entity.isInShallowWater.
shallow_water: self.fluids.was_touching_water && !self.is_under_water(),
fall_flying: self.fall_flying,
on_ground: self.ground.on_ground,
horizontal_collision: self.collision.horizontal,
minor_horizontal_collision: self.collision.minor,
moving_slowly: self.moving_slowly(),
in_water: self.fluids.was_touching_water,
under_water: self.is_under_water(),
swimming: self.swimming,
..Default::default()
};
// The sprint setter edits attributes and flags, independent of local
// keyboard history. Retain the input prefix even if that setter fails.
let mut state = self.sprint_input;
let result = state.tick(keys, conditions, 7, |value| self.set_sprinting(value));
self.sprint_input = state;
result
}
fn remove_frost(&mut self) -> Result<()> {
let key = self
.attributes
.key("minecraft:movement_speed")
.ok_or("missing movement speed")?;
// Native removeFrost obtains the instance even when no modifier exists.
// Pure value lookup would miss lazy creation and its pending updates.
if let Some(handle) = self
.attributes
.get_instance(Some(key))
.map_err(attribute_error)?
{
self.attributes
.edit(&handle, |value, observer| {
value.remove("minecraft:powder_snow", observer)
})
.map_err(attribute_error)?;
}
Ok(())
}
}
pub struct MotionWorld<'p, 'w, 'r> {
/// Entity boxes selected by the host for this player's collision queries.
pub entities: &'w [Aabb],
pub player: &'p mut PlayerMotion,
pub scene: &'w mut World,
pub assets: &'r Assets,
pub collision_binding: &'w BlockCollisionRegistry<'r>,
pub resources: &'w MotionResources,
}
enum TickInput {
Living([f32; 3]),
PreparedLocal { direction: [f32; 2], jumping: bool },
}
impl MotionWorld<'_, '_, '_> {
fn context(&self) -> CollisionContext<'static> {
CollisionContext::for_entity(
CollisionEntity {
identity: EntityIdentity(0),
y: self.player.position.y,
descending: self.player.shift_key_down,
main_hand: Some(CollisionItem::EMPTY),
},
false,
)
}
fn collisions(&self) -> SceneCollisions<'_, '_> {
SceneCollisions {
world: self.scene,
binding: self.collision_binding,
subject: Some(self.player.powder_snow_subject()),
}
}
fn movement_collisions(
&self,
) -> crate::collisions::EntityCollisions<'_, SceneCollisions<'_, '_>> {
let at = [self.player.position.x, self.player.position.z];
crate::collisions::EntityCollisions {
blocks: self.collisions(),
entities: self.entities,
border: self.player.border.as_ref().map(|b| (b, at)),
}
}
/// `Level.noCollision(player, bounds)`: blocks and the host's entity boxes.
pub fn no_player_collision(&mut self, bounds: Aabb) -> Result<bool> {
let context = self.context();
Ok(world_movement::no_world_collision(
&mut self.movement_collisions(),
world_movement::CollisionCheckRequest {
entity: EntityIdentity(0),
context,
bounds,
candidate_budget: 1_000_000,
},
)?)
}
fn block(&self, p: BlockPos) -> BlockStateId {
self.scene.block(p.x, p.y, p.z)
}
fn support(&mut self, offset: f32) -> Result<BlockPos> {
let position = self.player.position;
let support = self.player.ground.supporting_block;
Ok(movement_support::support_position(
&mut RegistryMovementWorld {
properties: &self.resources.blocks,
world: self,
},
position,
support,
offset,
)?)
}
fn location(&self) -> MovementLocation {
MovementLocation {
position: self.player.position,
block_position: BlockPos::containing(self.player.position),
supporting_block: self.player.ground.supporting_block,
}
}
/// `LivingEntity.onClimbable` at the player's feet (it remembers the block).
pub fn climbable(&mut self) -> Result<bool> {
if self.player.spectator {
return Ok(false);
}
let p = BlockPos::containing(self.player.position);
let name = &self
.assets
.registry
.state(self.block(p))
.ok_or("missing scene state")?
.name;
// A gliding player passes through vines (`CAN_GLIDE_THROUGH`).
if self.player.fall_flying && self.resources.glide_through.contains(name) {
return Ok(false);
}
let climbable = self.resources.climbable.contains(name);
if climbable {
self.player.last_climbable = Some(p);
}
Ok(climbable)
}
pub fn travel_in_air(&mut self, input: Vec3) -> Result<()> {
living_air::travel_in_air(self, input)
}
/// Dry, standing movement phases of LivingEntity.aiStep, including powder
/// snow's block-inside effects and server freezing (thawing, the frost
/// modifier, freeze damage). Equipment, interpolation, effects and other
/// world/entity effects remain unbound. Inputs are the native
/// float xxa/yya/zza fields, before LivingEntity.applyInput damping.
pub fn movement_tick(&mut self, input: [f32; 3]) -> Result<()> {
self.dry_tick(TickInput::Living(input))
}
/// Dry Player.aiStep movement with a prepared local input vector. The
/// caller applies LocalPlayer input preparation once. Empty inventory,
/// equipment and nearby-entity sets are the current scene domain.
pub fn player_movement_tick(&mut self, direction: [f32; 2], jumping: bool) -> Result<()> {
self.fluid_base_tick()?;
self.player_movement_tick_with_fluids(direction, jumping)
}
fn player_movement_tick_with_fluids(
&mut self,
direction: [f32; 2],
jumping: bool,
) -> Result<()> {
// Entity.baseTick
self.player.was_in_powder_snow = self.player.in_powder_snow;
self.player.in_powder_snow = false;
self.player.old_position = self.player.position;
if self.player.jump_trigger_time > 0 {
self.player.jump_trigger_time -= 1;
}
self.player.peaceful_regeneration(self.scene.health_rules)?;
// LocalPlayer.aiStep: double-tap jump toggles creative flight.
let was_jumping = std::mem::replace(&mut self.player.was_jumping, jumping);
let flying_before = self.player.flying;
if self.player.spectator {
self.player.flying = true;
self.player.ground.on_ground = false;
} else if !self.player.may_fly {
self.player.flying = false;
} else if !was_jumping && jumping && !self.player.was_auto_jump {
if self.player.jump_trigger_time == 0 {
self.player.jump_trigger_time = 7;
} else if !self.player.swimming {
self.player.flying = !self.player.flying;
if self.player.flying && self.player.ground.on_ground {
self.jump_from_ground()?;
}
self.player.jump_trigger_time = 0;
}
}
let toggled = flying_before != self.player.flying;
// The server clears the glide flag from the position the client sent
// last tick, and the client applies it a tick later, before aiStep: a
// landing glide lasts one more tick on the ground, with no ground
// friction, so a jump then keeps the speed (the elytra hop).
if std::mem::take(&mut self.player.glide_ending) {
self.player.fall_flying = false;
}
// Player.tryToStartFallFlying (canGlide: airborne, not flying, a glider;
// never from inside a liquid).
let can_glide = self.player.glider
&& !self.player.ground.on_ground
&& !self.player.flying
&& self.player.status.levitation.is_none()
&& !self.player.fluids.was_touching_water
&& !self.player.is_in_lava();
// LocalPlayer.aiStep: `!onClimbable()` before tryToStartFallFlying.
if jumping
&& !toggled
&& !was_jumping
&& !self.climbable()?
&& !self.player.fall_flying
&& can_glide
{
self.player.fall_flying = true;
}
// LivingEntity.tick fallFlyTicks, then updateFallFlying.
if self.player.fall_flying {
// Entity.checkFallDistanceAccumulation: a glide that isn't diving
// (falling slower than 0.5 a tick) keeps the fall distance at 1, so
// landing from it hurts no more than a one-block drop.
if self.player.velocity.y > -0.5 && self.player.fall_distance > 1.0 {
self.player.fall_distance = 1.0;
}
self.player.fall_fly_ticks += 1;
// canGlide alone: water and lava don't end a glide, levitation does.
let still = self.player.glider
&& !self.player.ground.on_ground
&& !self.player.flying
&& self.player.status.levitation.is_none();
if !still {
self.player.glide_ending = true;
} else if (self.player.fall_fly_ticks + 1) % 10 == 0
&& ((self.player.fall_fly_ticks + 1) / 10) % 2 == 0
{
self.player.glider_wear += 1;
}
} else {
self.player.fall_fly_ticks = 0;
}
// LocalPlayer.goDownInWater, before LivingEntity.aiStep's velocity cleanup.
if self.player.fluids.was_touching_water
&& self.player.shift_key_down
&& !self.player.flying
{
self.player.velocity.y += f64::from(-0.04f32);
}
if self.player.flying {
// Vertical flight: jump up, shift down, three times the flying speed.
let ya = i32::from(jumping) - i32::from(self.player.shift_key_down);
if ya != 0 {
self.player.velocity.y += f64::from(ya as f32 * self.player.flying_speed * 3.0);
}
}
self.dry_tick(TickInput::PreparedLocal {
direction,
jumping: jumping && !self.player.flying,
})?;
if self.player.spectator {
self.player.ground.on_ground = false;
}
if self.player.flying {
self.player.fall_distance = 0.0;
if self.player.ground.on_ground && !self.player.spectator {
self.player.flying = false;
}
}
self.player.head_yaw = self.player.yaw;
// Player.aiStep refreshes speed after movement, not before travel.
self.player.speed = self.player.attribute("minecraft:movement_speed")? as f32;
Ok(())
}
/// Resident simulation phases in native order. Enclosing entity/world tick
/// services are still incomplete; this composes clocks, movement and hunger.
pub fn simulation_tick(&mut self, direction: [f32; 2], jumping: bool) -> Result<()> {
self.player.health.advance_clock();
self.fluid_base_tick()?;
self.simulation_tick_with_fluids(direction, jumping)
}
fn simulation_tick_with_fluids(&mut self, direction: [f32; 2], jumping: bool) -> Result<()> {
self.tick_environment_damage()?;
let previous = self.player.position;
self.player_movement_tick_with_fluids(direction, jumping)?;
self.apply_fire_contact()?;
self.player.refresh_attributes()?;
self.update_player_pose()?;
// The resident scene accepts the resolved local movement directly.
// Vanilla dispatches this separately from travel, on packet acceptance.
self.check_movement_statistics(previous.vector_to(self.player.position))?;
self.player
.food_tick(&self.resources.health, self.scene.health_rules)
}
pub fn controlled_simulation_tick(&mut self, keys: crate::sprint::Keys) -> Result<()> {
// The base tick (fluids, swimming) precedes LocalPlayer.aiStep.
self.player.health.advance_clock();
self.fluid_base_tick()?;
self.update_local_crouching()?;
let mut keys = keys;
// LocalPlayer.aiStep: a pending auto-jump presses jump for this tick
// (input.makeJump) and keeps the jump from toggling flight.
self.player.was_auto_jump = self.player.auto_jump_time > 0;
if self.player.was_auto_jump {
self.player.auto_jump_time -= 1;
keys.jump = true;
}
self.player.sprint_input_tick(keys)?;
self.player.shift_key_down = keys.shift;
let direction = keys.direction();
self.player.move_vector = direction;
let sneak = if direction[0] * direction[0] + direction[1] * direction[1] != 0.0
&& self.player.moving_slowly()
{
Some(self.player.attribute("minecraft:sneaking_speed")? as f32)
} else {
None
};
self.simulation_tick_with_fluids(
crate::input::modify_input(direction, self.player.item_use_speed, sneak),
keys.jump,
)
}
pub fn check_movement_statistics(&mut self, delta: Vec3) -> Result<()> {
movement_statistics::check(self, delta)
}
fn dry_tick(&mut self, input: TickInput) -> Result<()> {
if self.player.no_jump_delay > 0 {
self.player.no_jump_delay -= 1;
}
self.player.drop_tiny_velocity();
let mut input = match input {
TickInput::Living(v) => Vec3::new(
f64::from(v[0] * 0.98),
f64::from(v[1]),
f64::from(v[2] * 0.98),
),
TickInput::PreparedLocal { direction, jumping } => {
self.player.jumping = jumping;
Vec3::new(f64::from(direction[0]), 0.0, f64::from(direction[1]))
}
};
if self.player.health.dead_or_dying() {
self.player.jumping = false;
input.x = 0.0;
input.z = 0.0;
}
self.jump_phase()?;
let before_travel = self.player.bounds();
self.player_travel(input)?;
if self.player.block_effects {
self.apply_effects_from_blocks()?;
}
// LivingEntity.aiStep "freezing" (server).
if !self.player.in_powder_snow || !self.player.can_freeze() {
self.player.ticks_frozen = (self.player.ticks_frozen - 2).max(0);
}
self.player.remove_frost()?;
let on = self.support(movement_support::LEGACY_SUPPORT_OFFSET)?;
let on_air = self.assets.registry.state(self.block(on)).is_none_or(|s| {
matches!(
s.name.as_str(),
"minecraft:air" | "minecraft:cave_air" | "minecraft:void_air"
)
});
self.player.try_add_frost(on_air)?;
self.update_soul_speed_block()?;
if self.player.health.tick_count % 40 == 0
&& self.player.is_fully_frozen()
&& self.player.can_freeze()
{
self.freeze_damage()?;
}
if self.player.auto_spin_attack_ticks > 0 {
self.player.auto_spin_attack_ticks -= 1;
self.check_auto_spin_attack(before_travel);
}
Ok(())
}
/// Refresh whether the player stands on a soul speed block, for the
/// `location_changed` enchantment effects (a server's player too, whose
/// client does the walking).
pub fn update_soul_speed_block(&mut self) -> Result<()> {
self.player.location_effects.on_soul_speed_block = self.on_soul_speed_block()?;
Ok(())
}
/// `MovementAffectedByPredicate` for `#minecraft:soul_speed_blocks`.
fn on_soul_speed_block(&mut self) -> Result<bool> {
let on = self.support(movement_support::MOVEMENT_SUPPORT_OFFSET)?;
Ok(self
.assets
.registry
.state(self.block(on))
.is_some_and(|s| self.resources.soul_speed_blocks.contains(&s.name)))
}
/// Player.travel: swim steering, then LivingEntity.travel (fluids first,
/// then gliding, then air), keeping 0.6 of the vertical speed while flying.
fn player_travel(&mut self, input: Vec3) -> Result<()> {
if self.player.swimming {
let look_y =
horizon_world::view_direction::view_vector(self.player.pitch, self.player.yaw).y;
let near_surface = BlockPos::containing(Vec3::new(
self.player.position.x,
self.player.position.y + 1.0 - 0.1,
self.player.position.z,
));
if look_y <= 0.0
|| self.player.jumping
|| self.fluid_at(near_surface).kind() != horizon_world::fluid::FluidKind::Empty
{
let blend = if look_y < -0.2 { 0.085 } else { 0.06 };
self.player.velocity.y += (look_y - self.player.velocity.y) * blend;
}
}
let flying_y = self.player.flying.then_some(self.player.velocity.y);
if !self.player.flying
&& (self.player.fluids.was_touching_water || self.player.is_in_lava())
{
horizon_world::living_fluid::travel_in_fluid(self, input)?;
} else if self.player.fall_flying {
// LivingEntity.travelFallFlying: on a climbable the glide ends and
// the player moves like in the air.
if self.climbable()? {
self.travel_in_air(input)?;
self.player.fall_flying = false;
} else {
self.travel_fall_flying()?;
}
} else {
self.travel_in_air(input)?;
}
if let Some(y) = flying_y {
self.player.velocity.y = y * 0.6;
}
Ok(())
}
/// ServerPlayer's own travel: the server simulates a player too
/// (`MoveSimulationType.AUTHORITATIVE_SIDE_AND_SERVER`), with no input
/// (it never sets xxa/zza). Only the delta movement it leaves stays: it
/// is what a hurt sends the player (`ServerEntity.sendChanges`), and
/// what the next knockback starts from; the client's next move places
/// the player.
pub fn server_travel(&mut self) -> Result<()> {
let p = &mut *self.player;
let (position, ground, collision) = (p.position, p.ground, p.collision);
let (history, fall_distance, steps) = (p.history.clone(), p.fall_distance, p.steps);
let events = p.events.len();
p.drop_tiny_velocity();
p.server_copy = true;
let travelled = self.player_travel(Vec3::ZERO);
let p = &mut *self.player;
p.server_copy = false;
(p.position, p.ground, p.collision) = (position, ground, collision);
(p.history, p.fall_distance, p.steps) = (history, fall_distance, steps);
// The wall hit is the server's own: its sound and damage events stay.
let kept: Vec<_> = p
.wall_hit_events
.take()
.map(|span| p.events.drain(span).collect())
.unwrap_or_default();
p.events.truncate(events);
p.events.extend(kept);
travelled
}
/// `LivingEntity.checkAutoSpinAttack`: the first living entity in the
/// box swept this tick takes the hit and ends the spin, bouncing the
/// player back at a fifth of its speed; a wall ends it too.
fn check_auto_spin_attack(&mut self, before: Aabb) {
let swept = before.union_bounds(self.player.bounds());
let p = &mut self.player;
if let Some(&(id, _)) = p.spin_targets.iter().find(|(_, b)| b.intersects(swept)) {
p.spin_hit = Some(id);
p.auto_spin_attack_ticks = 0;
p.velocity = p.velocity.scale(-0.2);
} else if p.collision.horizontal {
p.auto_spin_attack_ticks = 0;
}
}
/// `hurtServer(damageSources().freeze(), 1)` for a fully frozen player.
fn freeze_damage(&mut self) -> Result<()> {
let id = self
.resources
.health
.damage
.id("minecraft:freeze")
.ok_or("missing freeze damage type")?;
self.player.events.push(MotionEvent::Health(
crate::health::HealthEvent::FreezeDamage(1.0),
));
let rules = self.scene.health_rules;
self.player.hurt(&self.resources.health, rules, id, 1.0)?;
Ok(())
}
/// `Entity.applyEffectsFromBlocks` for the blocks Horizon's player reacts
/// to inside its movement path: powder snow (`PowderSnowBlock.entityInside`
/// and the FREEZE / EXTINGUISH effects), cobwebs, sweet berry bushes,
/// cactus and lit campfires, and the magma and slime blocks it stands on
/// (`stepOn`). Pressure plates, tripwires and rails are the world tick's
/// scan.
pub fn apply_effects_from_blocks(&mut self) -> Result<()> {
self.effects_from_blocks(false)
}
/// What `applyEffectsFromBlocks` does to a server's player along the
/// moves its client sent since `from` (in its history): the damage of
/// magma, cactus, lit campfires and grown sweet berry bushes, and powder
/// snow's FREEZE, then `LivingEntity.aiStep`'s freezing and its damage.
/// Its client moves it, so the slowing and the rest are the client's.
pub fn server_block_damage(&mut self, from: Vec3) -> Result<()> {
self.player.old_position = from;
// Entity.baseTick
self.player.was_in_powder_snow = self.player.in_powder_snow;
self.player.in_powder_snow = false;
self.effects_from_blocks(true)?;
// LivingEntity.aiStep "freezing" (server).
if !self.player.in_powder_snow || !self.player.can_freeze() {
self.player.ticks_frozen = (self.player.ticks_frozen - 2).max(0);
}
if self.player.health.tick_count % 40 == 0
&& self.player.is_fully_frozen()
&& self.player.can_freeze()
{
self.freeze_damage()?;
}
Ok(())
}
fn effects_from_blocks(&mut self, damage_only: bool) -> Result<()> {
use horizon_world::entity_move::MovementRecord;
let mut movements: Vec<MovementRecord> =
self.player.history.records().iter().copied().collect();
self.player.history.clear();
let position = self.player.position;
match movements.last() {
None => movements.push(MovementRecord {
from: self.player.old_position,
to: position,
original: None,
}),
Some(last) if last.to.distance_squared(position) > f64::from(9.999_999_4e-11_f32) => {
movements.push(MovementRecord {
from: last.to,
to: position,
original: None,
})
}
_ => {}
}
// isAffectedByBlocks: no physics for spectators.
if self.player.spectator {
return Ok(());
}
// Block.stepOn for the block under an entity on the ground:
// MagmaBlock's hot floor hurts unless it steps carefully (sneaks).
if self.player.ground.on_ground {
let on = self.legacy_on_position()?;
let under = self.assets.registry.state(self.block(on));
let magma = under.is_some_and(|s| s.name == "minecraft:magma_block");
let slime = under.is_some_and(|s| s.name == "minecraft:slime_block");
if magma && !self.player.shift_key_down {
self.environment_hurt("minecraft:hot_floor", 1.0)?;
}
// SlimeBlock.stepOn: a slow walk on slime drags the horizontal
// speed (the client moves its own player, so not the server's copy).
if slime && !damage_only && !self.player.shift_key_down {
let abs_delta_y = self.player.velocity.y.abs();
if abs_delta_y < 0.1 {
let scale = 0.4 + abs_delta_y * 0.2;
self.player.velocity.x *= scale;
self.player.velocity.z *= scale;
}
}
}
let mut visited = std::collections::HashSet::new();
let mut entered = Vec::new();
for movement in &movements {
let mut from = movement.from;
let delta = movement.to.subtract(movement.from);
let mut budget = 16;
match movement.original {
Some(original) if delta.length_squared() > 0.0 => {
for axis in Axis::step_order(original) {
let step = delta.component(axis);
if step != 0.0 {
let to = from.relative(
match axis {
Axis::X => Direction::East,
Axis::Y => Direction::Up,
Axis::Z => Direction::South,
},
step,
);
budget -= self.check_inside_blocks(
from,
to,
&mut visited,
&mut entered,
budget,
damage_only,
)?;
from = to;
}
}
}
_ => {
budget -= self.check_inside_blocks(
movement.from,
movement.to,
&mut visited,
&mut entered,
16,
damage_only,
)?;
}
}
if budget <= 0 {
self.check_inside_blocks(
movement.to,
movement.to,
&mut visited,
&mut entered,
1,
damage_only,
)?;
}
}
// InsideBlockEffectApplier.StepBasedCollector: the blocks entered
// at one step (a sweep iteration differing from the last) form a
// group whose EXTINGUISH callbacks (the game destroys those blocks if
// the player burns), FREEZE and EXTINGUISH apply once, in order.
let mut last_step = -1;
let mut groups = 0;
for (index, &(step, p)) in entered.iter().enumerate() {
if index == 0 || step != last_step {
groups += 1;
last_step = step;
}
if groups == 1 && !damage_only {
// A later group finds the fire already out.
self.player.powder_snow_entered.push(p);
}
}
for _ in 0..groups {
if self.player.health.dead_or_dying() {
break;
}
self.player.in_powder_snow = true;
if self.player.can_freeze() {
self.player.ticks_frozen =
(self.player.ticks_frozen + 1).min(PlayerMotion::TICKS_REQUIRED_TO_FREEZE);
}
}
Ok(())
}
/// `Entity.checkInsideBlocks(from, to, ...)`: the blocks the box at `to`
/// sweeps through from `from`; returns the iterations used plus one.
fn check_inside_blocks(
&mut self,
from: Vec3,
to: Vec3,
visited: &mut std::collections::HashSet<i64>,
entered: &mut Vec<(i32, BlockPos)>,
max_iterations: i32,
damage_only: bool,
) -> Result<i32> {
let deflated = self.player.dimensions.bounds(to).deflate(Vec3::new(
f64::from(1.0e-5_f32),
f64::from(1.0e-5_f32),
f64::from(1.0e-5_f32),
));
// Mth.square(0.9999900000002526): a long move counts every block it
// crosses as precise.
let far = 0.999_990_000_000_252_6_f64;
let moved_far = from.distance_squared(to) > far * far;
let mut hits = Vec::new();
let mut iterations = 0;
let alive = !self.player.health.dead_or_dying();
horizon_core::geometry::sweep_intersected_blocks(
from,
to,
deflated,
1_000_000,
|p, iteration| {
if !alive || iteration >= max_iterations {
return false;
}
iterations = iteration;
hits.push((iteration, p));
true
},
)
.map_err(|e| format!("block sweep: {e:?}"))?;
for (step, p) in hits {
let state = self.block(p);
let Some(definition) = self.assets.registry.state(state) else {
continue;
};
let name = definition.name.as_str();
if matches!(
name,
"minecraft:air" | "minecraft:cave_air" | "minecraft:void_air"
) {
continue;
}
let powder_snow = name == "minecraft:powder_snow";
// A filled cauldron's content top in blocks: the lava's 15/16
// (LavaCauldronBlock.FILLED_SHAPE), or a layered cauldron's
// getPixelContentHeight, 6 + 3 per level (FILLED_SHAPES).
let content_top = match name {
"minecraft:lava_cauldron" => Some(15.0 / 16.0),
"minecraft:water_cauldron" | "minecraft:powder_snow_cauldron" => {
let level = self
.assets
.registry
.state(state)
.and_then(|s| s.properties.get("level"))
.and_then(|l| l.parse::<u8>().ok())
.unwrap_or(1);
Some((6.0 + 3.0 * f64::from(level)) / 16.0)
}
_ => None,
};
// getEntityInsideCollisionShape is the whole block but for powder
// snow (its collision shape, the whole block when it is empty),
// filled cauldrons, end portals and tripwires; Horizon doesn't
// follow the player into those last two.
if matches!(name, "minecraft:end_portal" | "minecraft:tripwire") {
continue;
}
let inside = !(powder_snow || content_top.is_some()) || {
let context = self.context();
let binding = self.collision_binding;
let shape = binding.collision_shape_with_context(
&mut self.collisions(),
state,
p,
&context,
)?;
powder_snow && (shape.is_empty() || shape.boxes() == VoxelShape::block().boxes())
|| {
let offset = Vec3::new(f64::from(p.x), f64::from(p.y), f64::from(p.z));
let mut boxes: Vec<_> = shape.moved(offset).boxes().to_vec();
if let Some(top) = content_top {
// The cauldron's shape or its content,
// Block.column(12, 4, top).
boxes.push(Aabb::new(
Vec3::new(2.0 / 16.0, 4.0 / 16.0, 2.0 / 16.0).add_vector(offset),
Vec3::new(14.0 / 16.0, top, 14.0 / 16.0).add_vector(offset),
));
}
self.player
.dimensions
.bounds(from)
.collided_along_vector(to.subtract(from), &boxes)
}
};
if inside && visited.insert(p.pack()) {
// CactusBlock, CampfireBlock and the cauldrons' entityInside
// (`entity.hurt`, the fire and the fill level), and
// WitherRoseBlock's server-side effect.
match name {
"minecraft:cactus" => self.environment_hurt("minecraft:cactus", 1.0)?,
"minecraft:lava_cauldron" => self.lava_cauldron_inside()?,
"minecraft:water_cauldron" | "minecraft:powder_snow_cauldron" => {
self.layered_cauldron_inside(p);
}
"minecraft:wither_rose" => {
self.player.events.push(MotionEvent::InsideWitherRose);
}
"minecraft:campfire" | "minecraft:soul_campfire" => {
let lit = self
.assets
.registry
.state(state)
.and_then(|s| s.properties.get("lit"))
.is_some_and(|v| v == "true");
let damage = if name == "minecraft:campfire" {
1.0
} else {
2.0
};
if lit {
self.environment_hurt("minecraft:campfire", damage)?;
}
}
"minecraft:sweet_berry_bush" if damage_only => {
self.sweet_berry_bush_damage(state)?;
}
// HoneyBlock.entityInside: a server's player slides too, so
// its fall distance resets (its client moves it).
"minecraft:honey_block" => self.honey_block_inside(p)?,
// PowderSnowBlock.entityInside's FREEZE.
"minecraft:powder_snow" if damage_only => entered.push((step, p)),
_ => {}
}
if damage_only {
continue;
}
match name {
"minecraft:powder_snow" => {
self.powder_snow_inside(p)?;
entered.push((step, p));
}
"minecraft:cobweb" => self.web_inside(),
"minecraft:sweet_berry_bush" => self.sweet_berry_bush_inside(state)?,
"minecraft:bubble_column" => {
let precise = moved_far || deflated.intersects(Aabb::block(p));
self.bubble_column_inside(state, p, precise)?
}
"minecraft:nether_portal" => self
.player
.events
.push(MotionEvent::InsidePortal { pos: p }),
_ => {}
}
// ServerPlayer.onInsideBlock
self.player.events.push(MotionEvent::EnterBlock { state });
}
}
Ok(iterations + 1)
}
/// `HoneyBlock.entityInside`: a falling player touching a side of the block
/// slides down it (`isSlidingDown`, `doSlideMovement`, `maybeDoSlideEffects`).
fn honey_block_inside(&mut self, pos: BlockPos) -> Result<()> {
let old_delta_y = |dy: f64| dy / f64::from(0.98_f32) + 0.08;
let new_delta_y = |dy: f64| (dy - 0.08) * f64::from(0.98_f32);
let position = self.player.position;
let velocity = self.player.velocity;
if self.player.ground.on_ground
|| position.y > f64::from(pos.y) + 0.9375 - 1.0e-7
|| old_delta_y(velocity.y) >= -0.08
{
return Ok(());
}
let dx = (f64::from(pos.x) + 0.5 - position.x).abs();
let dz = (f64::from(pos.z) + 0.5 - position.z).abs();
let overlap = 0.4375 + f64::from(self.player.dimensions.width / 2.0);
if !(dx + 1.0e-7 > overlap || dz + 1.0e-7 > overlap) {
return Ok(());
}
// doSlideMovement
let old = old_delta_y(velocity.y);
if old < -0.13 {
let factor = -0.05 / old;
self.player.velocity =
Vec3::new(velocity.x * factor, new_delta_y(-0.05), velocity.z * factor);
} else {
self.player.velocity = Vec3::new(velocity.x, new_delta_y(-0.05), velocity.z);
}
self.player.fall_distance = 0.0;
// maybeDoSlideEffects: the sound, then the server's event 53.
let random = &mut self.scene.random;
let sound = random.next_int_bound(5).map_err(|e| format!("{e:?}"))? == 0;
// Only the server broadcasts event 53 (`!level.isClientSide()`).
let particles = !self.player.client_side
&& random.next_int_bound(5).map_err(|e| format!("{e:?}"))? == 0;
if sound || particles {
self.player.events.push(MotionEvent::HoneySlide {
pos,
sound,
particles,
});
}
Ok(())
}
/// `Player.makeStuckInBlock`: the next move is scaled by `multiplier`
/// (and the fall forgotten) unless flying; the impulse context resets
/// either way.
fn make_stuck_in_block(&mut self, multiplier: Vec3) {
if !self.player.flying {
self.player.fall_distance = 0.0;
self.player.stuck_multiplier = multiplier;
}
self.player.impulse.try_reset();
}
/// `LavaCauldronBlock.entityInside`: CLEAR_FREEZE, LAVA_IGNITE
/// (`Entity.lavaIgnite`, 15 seconds) and then `Entity.lavaHurt` (lava,
/// 4), as ordinary lava does to the player.
fn lava_cauldron_inside(&mut self) -> Result<()> {
self.player.ticks_frozen = 0;
self.player.ignite_for_ticks(300)?;
self.environment_hurt("minecraft:lava", 4.0)
}
/// `LayeredCauldronBlock.entityInside`: on a server, a burning player
/// asks for the cauldron's `handleEntityOnFireInside` (runBefore
/// EXTINGUISH, so while still burning), then EXTINGUISH
/// (`Entity.clearFire`) puts the fire out.
fn layered_cauldron_inside(&mut self, pos: BlockPos) {
if self.player.fire_ticks > 0 && !self.player.spectator {
self.player
.events
.push(MotionEvent::CauldronExtinguish { pos });
}
self.player.fire_ticks = self.player.fire_ticks.min(0);
}
/// `WebBlock.entityInside`: stuck at a quarter of the speed, half with
/// the Weaving effect.
fn web_inside(&mut self) {
let multiplier = if self.player.status.weaving {
Vec3::new(0.5, 0.25, 0.5)
} else {
Vec3::new(0.25, f64::from(0.05_f32), 0.25)
};
self.make_stuck_in_block(multiplier);
}
/// `SweetBerryBushBlock.entityInside` for the player: slowed, and pricked
/// (`sweetBerryBush` damage, 1) by a grown bush while its known movement
/// is at least 0.003 on X or Z.
fn sweet_berry_bush_inside(&mut self, state: BlockStateId) -> Result<()> {
self.make_stuck_in_block(Vec3::new(f64::from(0.8_f32), 0.75, f64::from(0.8_f32)));
self.sweet_berry_bush_damage(state)
}
/// The server's half of `SweetBerryBushBlock.entityInside`: the prick.
fn sweet_berry_bush_damage(&mut self, state: BlockStateId) -> Result<()> {
let age = self
.assets
.registry
.state(state)
.and_then(|s| s.properties.get("age"))
.map_or("0", |a| a.as_str());
if age == "0" {
return Ok(());
}
// Player.isClientAuthoritative: ServerPlayer.getKnownMovement, this
// tick's movement.
let known = self.player.position.subtract(self.player.old_position);
if known.x * known.x + known.z * known.z > 0.0
&& (known.x.abs() >= f64::from(0.003_f32) || known.z.abs() >= f64::from(0.003_f32))
{
let id = self
.resources
.health
.damage
.id("minecraft:sweet_berry_bush")
.ok_or("missing sweet_berry_bush damage type")?;
self.player.events.push(MotionEvent::Health(
crate::health::HealthEvent::SweetBerryBushDamage(1.0),
));
let rules = self.scene.health_rules;
self.player.hurt(&self.resources.health, rules, id, 1.0)?;
}
Ok(())
}
/// `PowderSnowBlock.entityInside` for the player: stuck while the block
/// at its feet is powder snow, with a snowflake now and then (server).
fn powder_snow_inside(&mut self, p: BlockPos) -> Result<()> {
let feet = BlockPos::containing(self.player.position);
let in_block = self
.assets
.registry
.state(self.block(feet))
.is_some_and(|s| s.name == "minecraft:powder_snow");
if !in_block {
return Ok(());
}
self.make_stuck_in_block(Vec3::new(f64::from(0.9_f32), 1.5, f64::from(0.9_f32)));
// ServerPlayer.getKnownMovement: this tick's movement.
let known = self.player.position.subtract(self.player.old_position);
let random = &mut self.scene.random;
if (known.x != 0.0 || known.z != 0.0) && random.next_boolean() {
// Mth.randomBetween(random, -1, 1) * (1 / 12)
let xa = (random.next_float() * 2.0 - 1.0) * 0.083_333_336_f32;
let za = (random.next_float() * 2.0 - 1.0) * 0.083_333_336_f32;
self.player.events.push(MotionEvent::Snowflake {
position: Vec3::new(
self.player.position.x,
f64::from(p.y + 1),
self.player.position.z,
),
velocity: Vec3::new(f64::from(xa), f64::from(0.05_f32), f64::from(za)),
});
}
Ok(())
}
pub fn jump_from_ground(&mut self) -> Result<()> {
living_motion::jump_from_ground(self)?;
self.player
.events
.push(MotionEvent::Health(crate::health::HealthEvent::Statistic {
name: "jump",
amount: 1,
}));
self.player
.cause_food_exhaustion(if self.player.sprinting { 0.2 } else { 0.05 });
Ok(())
}
/// LivingEntity.travelFallFlying with updateFallFlyingMovement.
fn travel_fall_flying(&mut self) -> Result<()> {
let v = self.player.velocity;
let (yaw, pitch) = (self.player.yaw.to_radians(), self.player.pitch.to_radians());
let look = Vec3::new(
f64::from(-yaw.sin() * pitch.cos()),
f64::from(-pitch.sin()),
f64::from(yaw.cos() * pitch.cos()),
);
let lean = pitch;
let look_h = (look.x * look.x + look.z * look.z).sqrt();
let move_h = (v.x * v.x + v.z * v.z).sqrt();
let gravity = living_motion::effective_gravity(self)?;
let lift = f64::from(lean.cos()).powi(2);
let mut m = Vec3::new(v.x, v.y + gravity * (-1.0 + lift * 0.75), v.z);
if m.y < 0.0 && look_h > 0.0 {
let convert = m.y * -0.1 * lift;
m = Vec3::new(
m.x + look.x * convert / look_h,
m.y + convert,
m.z + look.z * convert / look_h,
);
}
if lean < 0.0 && look_h > 0.0 {
let convert = move_h * f64::from(-lean.sin()) * 0.04;
m = Vec3::new(
m.x - look.x * convert / look_h,
m.y + convert * 3.2,
m.z - look.z * convert / look_h,
);
}
if look_h > 0.0 {
m = Vec3::new(
m.x + (look.x / look_h * move_h - m.x) * 0.1,
m.y,
m.z + (look.z / look_h * move_h - m.z) * 0.1,
);
}
self.player.velocity = Vec3::new(m.x * 0.99, m.y * 0.98, m.z * 0.99);
let movement = self.player.velocity;
self.move_self(movement)?;
// LivingEntity.handleFallFlyingCollisions: only the server hurts.
if !self.player.client_side && self.player.collision.horizontal {
let new_h = {
let v = self.player.velocity;
(v.x * v.x + v.z * v.z).sqrt()
};
let dmg = ((move_h - new_h) * 10.0 - 3.0) as f32;
if dmg > 0.0 {
let first = self.player.events.len();
// getFallDamageSound((int) dmg)
let sound = if dmg as i32 > 4 {
crate::landing::SceneSound::BigFall
} else {
crate::landing::SceneSound::SmallFall
};
self.player
.events
.push(MotionEvent::Fall(crate::landing::FallEvent::Sound {
sound,
position: None,
volume: 1.0,
pitch: 1.0,
}));
let id = self
.resources
.health
.damage
.id("minecraft:fly_into_wall")
.ok_or("missing fly_into_wall damage type")?;
let rules = self.scene.health_rules;
self.player.hurt(&self.resources.health, rules, id, dmg)?;
if self.player.server_copy {
self.player.wall_hit_events = Some(first..self.player.events.len());
}
}
}
Ok(())
}
/// `LocalPlayer.move`: the move, then `updateAutoJump` with the float
/// horizontal displacement.
pub fn move_self(&mut self, movement: Vec3) -> Result<()> {
let before = self.player.position;
entity_move::move_entity(self, MoverType::SelfMovement, movement)?;
let dx = (self.player.position.x - before.x) as f32;
let dz = (self.player.position.z - before.z) as f32;
self.update_auto_jump(dx, dz)
}
/// `LocalPlayer.updateAutoJump` behind `canAutoJump`.
pub fn update_auto_jump(&mut self, xa: f32, za: f32) -> Result<()> {
let p = &*self.player;
// canAutoJump; MotionWorld drives an unmounted player (not a passenger).
let ready = crate::auto_jump::can_auto_jump(
p.auto_jump_enabled,
p.auto_jump_time,
p.ground.on_ground,
p.shift_key_down,
false,
p.move_vector,
1.0,
);
if !ready || f64::from(self.block_jump_factor()?) < 1.0 {
return Ok(());
}
// Player.getSpeed: the movement speed attribute as it is now.
let speed = self.player.attribute("minecraft:movement_speed")? as f32;
let p = &*self.player;
let jumper = crate::auto_jump::AutoJumper {
position: p.position,
max_y: p.bounds().max_position().y,
x_rot: p.pitch,
y_rot: p.yaw,
speed,
move_vector: p.move_vector,
width: p.dimensions.width,
height: p.dimensions.height,
jump_boost: p.status.jump_boost,
};
if crate::auto_jump::update_auto_jump(self, &jumper, xa, za)? {
self.player.auto_jump_time = 1;
}
Ok(())
}
}
impl crate::auto_jump::AutoJumpWorld for MotionWorld<'_, '_, '_> {
type Error = Box<dyn std::error::Error>;
fn collision_shape(&mut self, p: BlockPos) -> Result<horizon_core::geometry::VoxelShape> {
let context = self.context();
let state = self.block(p);
let binding = self.collision_binding;
Ok(binding.collision_shape_with_context(&mut self.collisions(), state, p, &context)?)
}
fn collision_boxes(&mut self, bounds: Aabb) -> Result<Vec<Aabb>> {
let context = self.context();
let mut scene = self.collisions();
let mut boxes = Vec::new();
for hit in horizon_world::block_collision_scan::BlockCollisionScan::new(
&mut scene, context, bounds, false, 1_000_000,
)? {
boxes.extend_from_slice(hit?.shape.boxes());
}
Ok(boxes)
}
}
// Current resident movement domain: dry, standing, no vehicles or gliding.
// The shared kernel also handles swimming/crouching/flight when those states
// are supplied by their eventual runtime bindings.
impl MovementStatisticsWorld for MotionWorld<'_, '_, '_> {
type Error = Box<dyn std::error::Error>;
fn passenger(&mut self) -> Result<bool> {
Ok(false)
}
fn swimming(&mut self) -> Result<bool> {
Ok(self.player.swimming)
}
fn eyes_in_water(&mut self) -> Result<bool> {
Ok(self.player.is_eye_in_fluid(WATER))
}
fn in_water(&mut self) -> Result<bool> {
Ok(self.player.fluids.was_touching_water)
}
fn on_climbable(&mut self) -> Result<bool> {
self.climbable()
}
fn on_ground(&mut self) -> Result<bool> {
Ok(self.player.ground.on_ground)
}
fn sprinting(&mut self) -> Result<bool> {
Ok(self.player.sprinting)
}
fn crouching(&mut self) -> Result<bool> {
Ok(self.player.pose == crate::pose::Pose::Crouching)
}
fn fall_flying(&mut self) -> Result<bool> {
Ok(false)
}
fn award(&mut self, stat: MovementStat, amount: i32) -> Result<()> {
self.player
.events
.push(MotionEvent::Health(crate::health::HealthEvent::Statistic {
name: stat.name(),
amount,
}));
Ok(())
}
fn exhaust(&mut self, amount: f32) -> Result<()> {
self.player.cause_food_exhaustion(amount);
Ok(())
}
}
impl MovementBlockProvider for MotionWorld<'_, '_, '_> {
type Error = io::Error;
fn movement_block_state(&mut self, p: BlockPos) -> io::Result<BlockStateId> {
Ok(self.block(p))
}
}
impl EdgeBackoffWorld for MotionWorld<'_, '_, '_> {
type Error = Box<dyn std::error::Error>;
fn max_up_step(&mut self) -> Result<f32> {
Ok(self.player.attribute("minecraft:step_height")? as f32)
}
fn staying_on_ground_surface(&mut self) -> Result<bool> {
Ok(self.player.shift_key_down)
}
fn on_ground(&mut self) -> Result<bool> {
Ok(self.player.ground.on_ground)
}
fn no_collision(&mut self, bounds: Aabb) -> Result<bool> {
self.no_player_collision(bounds)
}
}
impl EntityMoveWorld for MotionWorld<'_, '_, '_> {
type Error = Box<dyn std::error::Error>;
fn no_physics(&self) -> bool {
self.player.spectator
}
fn position(&self) -> Vec3 {
self.player.position
}
fn set_position(&mut self, p: Vec3) -> Result<()> {
self.player.position = p;
Ok(())
}
fn record_movement(&mut self, mover: MoverType, movement: Vec3) -> Result<()> {
self.player
.events
.push(MotionEvent::Recorded { mover, movement });
Ok(())
}
fn collision_flags(&self) -> CollisionFlags {
self.player.collision
}
fn set_collision_flags(&mut self, value: CollisionFlags) {
self.player.collision = value;
}
/// `Entity.limitPistonMovement`: the per-tick 0.51-block budget shared by
/// every move on an axis. A failed game-time read leaves the accumulator
/// as it was, as native does.
fn limit_piston_movement(&mut self, movement: Vec3) -> Result<Vec3> {
let time = self.scene.game_time;
self.player
.piston
.limit(movement, || Ok::<i64, Box<dyn std::error::Error>>(time))
}
fn stuck_multiplier(&self) -> Vec3 {
self.player.stuck_multiplier
}
fn set_stuck_multiplier(&mut self, value: Vec3) {
self.player.stuck_multiplier = value;
}
fn velocity(&mut self) -> Result<Vec3> {
Ok(self.player.velocity)
}
fn set_velocity(&mut self, value: Vec3) -> Result<()> {
self.player.velocity = value;
Ok(())
}
fn back_off_edge(&mut self, movement: Vec3, mover: MoverType) -> Result<Vec3> {
let input = EdgeBackoffInput {
movement,
bounds: self.player.bounds(),
// Player.maybeBackOffFromEdge: not while flying.
flying: self.player.flying,
self_or_player: matches!(mover, MoverType::SelfMovement | MoverType::Player),
fall_distance: self.player.fall_distance,
query_budget: 1_000_000,
};
edge_backoff::back_off_from_edge(self, input)
.map_err(|e| io::Error::other(e.to_string()).into())
}
fn collide(&mut self, movement: Vec3) -> Result<Vec3> {
let max_step = self.player.attribute("minecraft:step_height")? as f32;
Ok(world_movement::resolve_world_movement(
&mut self.movement_collisions(),
MovementRequest {
entity: EntityIdentity(0),
context: self.context(),
bounds: self.player.bounds(),
movement,
max_step,
on_ground: self.player.ground.on_ground,
candidate_budget: 1_000_000,
},
)?)
}
fn fall_distance(&self) -> f64 {
self.player.fall_distance
}
fn fall_reset_clip(&mut self, from: Vec3, to: Vec3) -> Result<bool> {
// ClipContext.Block.FALLDAMAGE_RESETTING: tagged reset blocks are a full
// block, not their collider; ClipContext.Fluid.WATER: the water's shape.
// Both shapes are queried for every visited block (the water's first
// query fixes its cached shape), either one hitting ends the ray.
let hit = traverse_blocks(from, to, 1_000_000, |p| {
let water = match self.water_clip(from, to, p) {
Ok(hit) => hit,
Err(e) => return Some(Err(e)),
};
let name = &self.assets.registry.state(self.block(p)).unwrap().name;
let reset = self.resources.fall_reset.contains(name)
&& VoxelShape::block().clip(from, to, p).is_some();
(water || reset).then_some(Ok(()))
})?;
hit.transpose().map(|h| h.is_some())
}
fn reset_fall_distance(&mut self) -> Result<()> {
self.player.fall_distance = 0.0;
Ok(())
}
fn movement_history(&mut self) -> &mut MovementHistory {
&mut self.player.history
}
fn locally_authoritative(&mut self) -> Result<bool> {
Ok(!self.player.server_copy)
}
fn set_on_ground_with_movement(
&mut self,
below: bool,
horizontal: bool,
movement: Vec3,
) -> Result<()> {
let position = self.player.position;
let bounds = self.player.bounds();
let context = self.context();
let mut collisions = SceneCollisions {
world: self.scene,
binding: self.collision_binding,
subject: Some(self.player.powder_snow_subject()),
};
self.player.ground.set_with_movement(
below,
horizontal,
bounds,
Some(movement),
|bounds| find_supporting_block(&mut collisions, context, position, bounds, 1_000_000),
)?;
Ok(())
}
fn minor_horizontal_collision(&mut self, _: Vec3) -> Result<bool> {
Ok(false)
}
fn legacy_on_position(&mut self) -> Result<BlockPos> {
self.support(movement_support::LEGACY_SUPPORT_OFFSET)
}
fn block_state(&mut self, p: BlockPos) -> Result<BlockStateId> {
Ok(self.block(p))
}
fn on_ground(&mut self) -> Result<bool> {
Ok(self.player.ground.on_ground)
}
fn check_fall_damage(
&mut self,
dy: f64,
grounded: bool,
state: BlockStateId,
position: BlockPos,
) -> Result<()> {
// LivingEntity.aiStep: Slow Falling and Levitation reset the fall
// distance every tick, so landing under either does not hurt.
if self.player.status.slow_falling || self.player.status.levitation.is_some() {
self.player.fall_distance = 0.0;
}
// LivingEntity.checkFallDamage: a landing runs onChangedBlock.
if grounded && self.player.fall_distance > 0.0 {
self.player.location_effects.landed = true;
}
if self.player.spawn_extra_particles_on_fall && grounded && self.player.fall_distance > 0.0
{
self.player.events.push(MotionEvent::SmashLanding {
state,
position,
fall_distance: self.player.fall_distance,
});
self.player.spawn_extra_particles_on_fall = false;
}
self.player.events.push(MotionEvent::Landing {
dy,
grounded,
state,
position,
});
horizon_world::living_landing::check_living_fall_damage(self, dy, grounded, state, position)
}
fn removed(&mut self) -> Result<bool> {
Ok(false)
}
fn can_simulate(&mut self) -> Result<bool> {
Ok(true)
}
fn restitute(&mut self, state: BlockStateId, x: bool, z: bool, resolved: Vec3) -> Result<()> {
let input = RestitutionInput {
block: state,
collided_x: x,
collided_z: z,
vertical_collision: self.player.collision.vertical,
collision_below: self.player.collision.below,
living: true,
resolved_movement: resolved,
fall_distance: self.player.fall_distance,
};
movement_restitution::restitute_movement(self, input)
}
fn client_side(&mut self) -> Result<bool> {
Ok(false)
}
fn movement_emission(&mut self) -> Result<MovementEmission> {
<Self as MovementEmissionWorld>::movement_emission(self)
}
fn passenger(&mut self) -> Result<bool> {
Ok(false)
}
/// `Entity.applyMovementEmissionAndPlaySound`: a footstep (`Emission`)
/// only once the walked distance passes `nextStep`. Emitting on every
/// move played a step sound each tick, even standing still on the
/// ground (gravity moves the player every tick), as an endless loop.
fn apply_movement_emission(
&mut self,
kind: MovementEmission,
movement: Vec3,
position: BlockPos,
state: BlockStateId,
) -> Result<()> {
emission::apply_movement_emission(self, kind, movement, position, state)
}
fn block_speed_factor(&mut self) -> Result<f32> {
let efficiency = self.player.attribute("minecraft:movement_efficiency")? as f32;
let location = self.location();
let block = movement_support::block_speed_factor(
&mut RegistryMovementWorld {
properties: &self.resources.blocks,
world: self,
},
location,
)?;
Ok(block + efficiency * (1.0 - block))
}
}
// The player's footsteps and swim sounds. Flapping and the step game event
// are not bound here (the sculk listeners track the player's steps themselves).
impl MovementEmissionWorld for MotionWorld<'_, '_, '_> {
type Error = Box<dyn std::error::Error>;
type State = BlockStateId;
fn distances(&self) -> MovementDistances {
self.player.steps
}
fn set_movement_distance(&mut self, value: f32) {
self.player.steps.movement = value;
}
fn set_flight_distance(&mut self, value: f32) {
self.player.steps.flight = value;
}
fn set_next_step(&mut self, value: f32) {
self.player.steps.next_step = value;
}
fn on_position(&mut self) -> Result<BlockPos> {
self.support(movement_support::ON_SUPPORT_OFFSET)
}
fn block_state(&mut self, p: BlockPos) -> Result<BlockStateId> {
Ok(self.block(p))
}
fn is_air(&mut self, s: BlockStateId) -> Result<bool> {
let name = &self
.assets
.registry
.state(s)
.ok_or("missing scene state")?
.name;
Ok(matches!(
name.as_str(),
"minecraft:air" | "minecraft:cave_air" | "minecraft:void_air"
))
}
fn climbable_tag(&mut self, s: BlockStateId) -> Result<bool> {
let name = &self
.assets
.registry
.state(s)
.ok_or("missing scene state")?
.name;
Ok(self.resources.climbable.contains(name))
}
fn is_powder_snow(&mut self, s: BlockStateId) -> Result<bool> {
let name = &self
.assets
.registry
.state(s)
.ok_or("missing scene state")?
.name;
Ok(name == "minecraft:powder_snow")
}
fn on_ground(&mut self) -> Result<bool> {
Ok(self.player.ground.on_ground)
}
fn crouching(&mut self) -> Result<bool> {
Ok(self.player.pose == crate::pose::Pose::Crouching)
}
fn on_rails(&mut self) -> Result<bool> {
Ok(false)
}
fn swimming(&mut self) -> Result<bool> {
Ok(self.player.swimming)
}
fn in_water(&mut self) -> Result<bool> {
Ok(self.player.fluids.was_touching_water)
}
/// `Player.playStepSound`: in water a swim sound, then the step muffled;
/// on land the step of an inside-sound block above the floor, or of a
/// combination block above it with the floor's step muffled.
fn walking_step_sound(&mut self, position: BlockPos, state: BlockStateId) -> Result<()> {
let muffled = self.player.fluids.was_touching_water;
let mut stepped = false;
if muffled {
self.water_swim_sound()?;
} else {
// Entity.getPrimaryStepSoundBlockPos.
let above = BlockPos {
y: position.y + 1,
..position
};
let above_state = self.block(above);
let name = &self
.assets
.registry
.state(above_state)
.ok_or("missing scene state")?
.name;
let combination = self.resources.combination_step_sound.contains(name);
if combination || self.resources.inside_step_sound.contains(name) {
self.player.events.push(MotionEvent::Emission {
position: above,
state: above_state,
muffled: false,
});
if combination {
// Entity.playCombinationStepSounds.
self.player.events.push(MotionEvent::Emission {
position,
state,
muffled: true,
});
}
stepped = true;
}
}
if !stepped {
self.player.events.push(MotionEvent::Emission {
position,
state,
muffled,
});
}
// Entity.walkingStepSound: the amethyst chime after the step, by the
// floor's state even when the step sound was the block above's.
let name = &self
.assets
.registry
.state(state)
.ok_or("missing scene state")?
.name;
let tick = self.player.health.tick_count;
if self.resources.crystal_sound.contains(name)
&& tick >= self.player.last_crystal_sound_play_tick + 20
{
// Entity.playAmethystStepSound (the level random stands in for
// the entity's).
let elapsed = f64::from(tick - self.player.last_crystal_sound_play_tick);
let decayed = self.player.crystal_sound_intensity * 0.997_f64.powf(elapsed) as f32;
let intensity = 1.0_f32.min(decayed + 0.07);
self.player.crystal_sound_intensity = intensity;
let pitch = 0.5 + intensity * self.scene.random.next_float() * 1.2;
let volume = 0.1 + intensity * 1.2;
self.player
.events
.push(MotionEvent::Chime { volume, pitch });
self.player.last_crystal_sound_play_tick = tick;
}
Ok(())
}
fn step_event(&mut self, _: BlockStateId) -> Result<()> {
Ok(())
}
fn next_step(&mut self) -> Result<f32> {
Ok(self.player.steps.next_step())
}
/// `Entity.waterSwimSound` and `playSwimSound` (the level random stands
/// in for the entity's, as for the splash).
fn water_swim_sound(&mut self) -> Result<()> {
let v = self.player.velocity;
let volume = 1.0_f32.min(
(v.x * v.x * f64::from(0.2_f32) + v.y * v.y + v.z * v.z * f64::from(0.2_f32)).sqrt()
as f32
* 0.35,
);
let random = &mut self.scene.random;
let pitch = 1.0 + (random.next_float() - random.next_float()) * 0.4;
self.player.events.push(MotionEvent::Swim { volume, pitch });
Ok(())
}
fn entity_event(&mut self, _: MovementEvent) -> Result<()> {
Ok(())
}
fn flapping(&mut self) -> Result<bool> {
Ok(false)
}
fn on_flap(&mut self) -> Result<()> {
Ok(())
}
/// `Player.getMovementEmission`: nothing while flying or sneaking on
/// the ground.
fn movement_emission(&mut self) -> Result<MovementEmission> {
let discreet = self.player.ground.on_ground && self.player.shift_key_down;
Ok(if self.player.flying || discreet {
MovementEmission::None
} else {
MovementEmission::All
})
}
}
impl RestitutionWorld for MotionWorld<'_, '_, '_> {
type Error = Box<dyn std::error::Error>;
fn suppressing_bounce(&mut self) -> Result<bool> {
Ok(self.player.shift_key_down)
}
fn entity_bounciness(&mut self) -> Result<f64> {
self.player.attribute("minecraft:bounciness")
}
fn velocity(&mut self) -> Result<Vec3> {
Ok(self.player.velocity)
}
fn effective_gravity(&mut self) -> Result<f64> {
living_motion::effective_gravity(self)
}
fn block_suppresses_bounce(&mut self, state: BlockStateId) -> Result<bool> {
Ok(self.resources.blocks.get(state)?.suppresses_bounce)
}
fn block_bounce_restitution(&mut self, state: BlockStateId) -> Result<f32> {
Ok(self
.resources
.blocks
.get(state)?
.coefficients
.bounce_restitution)
}
fn air_drag(&mut self) -> Result<f32> {
living_motion::air_drag(self)
}
fn movement_support_position(&mut self) -> Result<BlockPos> {
self.support(movement_support::MOVEMENT_SUPPORT_OFFSET)
}
fn bounce_on(
&mut self,
state: BlockStateId,
position: BlockPos,
fall_distance: f64,
) -> Result<()> {
self.player.events.push(MotionEvent::Bounce {
state,
position,
fall_distance,
});
self.resources
.landing
.bounce_on(
self,
state,
position,
horizon_world::block_landing::LandingEntityKind::Player,
)
.map_err(|e| e.to_string().into())
}
fn bounce_event(&mut self) -> Result<()> {
Ok(())
}
fn mark_position_for_sync(&mut self) {
self.player.sync_position = true;
}
fn set_velocity(&mut self, value: Vec3) -> Result<()> {
self.player.velocity = value;
Ok(())
}
}
impl LivingAirWorld for MotionWorld<'_, '_, '_> {
type Error = Box<dyn std::error::Error>;
fn movement_support_position(&mut self) -> Result<BlockPos> {
self.support(movement_support::MOVEMENT_SUPPORT_OFFSET)
}
fn on_ground(&mut self) -> Result<bool> {
Ok(self.player.ground.on_ground)
}
fn block_friction(&mut self, p: BlockPos) -> Result<f32> {
Ok(self
.resources
.blocks
.get(self.block(p))?
.coefficients
.friction)
}
fn friction_modifier(&mut self) -> Result<f64> {
self.player.attribute("minecraft:friction_modifier")
}
fn speed(&mut self) -> Result<f32> {
Ok(self.player.attribute("minecraft:movement_speed")? as f32)
}
fn flying_speed(&mut self) -> Result<f32> {
if self.player.flying {
// Player.getFlyingSpeed: abilities speed, doubled when sprinting.
return Ok(self.player.flying_speed * if self.player.sprinting { 2.0 } else { 1.0 });
}
Ok(if self.player.sprinting {
0.025999999
} else {
0.02
})
}
fn yaw(&mut self) -> Result<f32> {
Ok(self.player.yaw)
}
fn velocity(&self) -> Vec3 {
self.player.velocity
}
fn set_velocity(&mut self, v: Vec3) -> Result<()> {
self.player.velocity = v;
Ok(())
}
fn on_climbable(&mut self) -> Result<bool> {
self.climbable()
}
fn reset_fall_distance(&mut self) -> Result<()> {
self.player.fall_distance = 0.0;
Ok(())
}
fn in_scaffolding(&mut self) -> Result<bool> {
Ok(self
.assets
.registry
.state(self.block(BlockPos::containing(self.player.position)))
.unwrap()
.name
== "minecraft:scaffolding")
}
fn suppressing_ladder_slide(&mut self) -> Result<bool> {
Ok(self.player.shift_key_down)
}
fn is_player_class(&self) -> bool {
true
}
fn move_self(&mut self, v: Vec3) -> Result<()> {
MotionWorld::move_self(self, v)
}
fn horizontal_collision(&self) -> bool {
self.player.collision.horizontal
}
fn jumping(&self) -> bool {
self.player.jumping
}
fn was_in_powder_snow(&self) -> bool {
self.player.was_in_powder_snow
}
fn can_walk_powder_snow(&mut self) -> Result<bool> {
Ok(self.player.leather_boots)
}
fn levitation_amplifier(&mut self) -> Result<Option<i32>> {
Ok(self.player.status.levitation)
}
fn is_client_side(&mut self) -> Result<bool> {
Ok(false)
}
fn has_chunk_at(&mut self, p: BlockPos) -> Result<bool> {
Ok(self.scene.chunks.contains_key(&(p.x >> 4, p.z >> 4)))
}
fn effective_gravity(&mut self) -> Result<f64> {
living_motion::effective_gravity(self)
}
fn y(&self) -> f64 {
self.player.position.y
}
fn minimum_y(&mut self) -> Result<i32> {
Ok(0)
}
fn discard_friction(&mut self) -> Result<bool> {
Ok(false)
}
fn air_drag_modifier(&mut self) -> Result<f64> {
self.player.attribute("minecraft:air_drag_modifier")
}
fn omnidirectional_air_mover(&mut self) -> Result<bool> {
Ok(false)
}
}
impl LivingMotionWorld for MotionWorld<'_, '_, '_> {
type Error = Box<dyn std::error::Error>;
fn velocity(&self) -> Vec3 {
self.player.velocity
}
fn set_velocity(&mut self, v: Vec3) -> Result<()> {
self.player.velocity = v;
Ok(())
}
fn jump_strength(&mut self) -> Result<f64> {
self.player.attribute("minecraft:jump_strength")
}
fn block_jump_factor(&mut self) -> Result<f32> {
let location = self.location();
Ok(movement_support::block_jump_factor(
&mut RegistryMovementWorld {
properties: &self.resources.blocks,
world: self,
},
location,
)?)
}
fn has_jump_boost(&mut self) -> Result<bool> {
Ok(self.player.status.jump_boost.is_some())
}
fn jump_boost_amplifier(&mut self) -> Result<i32> {
self.player
.status
.jump_boost
.ok_or_else(|| "absent jump boost".into())
}
fn sprinting(&mut self) -> Result<bool> {
Ok(self.player.sprinting)
}
fn yaw(&mut self) -> Result<f32> {
Ok(self.player.yaw)
}
fn mark_needs_sync(&mut self) {
self.player.needs_sync = true;
}
fn no_gravity(&mut self) -> Result<bool> {
Ok(false)
}
fn gravity_attribute(&mut self) -> Result<f64> {
self.player.attribute("minecraft:gravity")
}
fn has_slow_falling(&mut self) -> Result<bool> {
Ok(self.player.status.slow_falling)
}
fn controlling_passenger_is_player(&mut self) -> Result<bool> {
Ok(false)
}
fn speed(&mut self) -> Result<f32> {
Ok(self.player.attribute("minecraft:movement_speed")? as f32)
}
fn omnidirectional_air_mover(&mut self) -> Result<bool> {
Ok(false)
}
fn air_drag_modifier(&mut self) -> Result<f64> {
self.player.attribute("minecraft:air_drag_modifier")
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn sword_sweep_requires_charge_ground_and_slow_horizontal_movement() {
let root = std::env::var_os("HORIZON_TEST_RESOURCES")
.map(std::path::PathBuf::from)
.unwrap_or_else(|| {
Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION)
});
if !root.join("movement-properties.nbt").exists() {
eprintln!("skipped sword sweep regression: prepared resources unavailable");
return;
}
let assets = Assets::load(&root).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut p = PlayerMotion::new(&resources, Vec3::ZERO).unwrap();
p.ground.on_ground = true;
p.speed = 0.1;
assert!(p.is_sweep_attack(1.0, false, true));
assert!(!p.is_sweep_attack(0.9, false, true));
assert!(!p.is_sweep_attack(1.0, true, true));
assert!(!p.is_sweep_attack(1.0, false, false));
p.sprinting = true;
assert!(!p.is_sweep_attack(1.0, false, true));
p.sprinting = false;
p.ground.on_ground = false;
assert!(!p.is_sweep_attack(1.0, false, true));
p.ground.on_ground = true;
p.velocity = Vec3::new(0.2, 10.0, 0.0);
assert!(p.is_sweep_attack(1.0, false, true));
p.velocity.z = 0.2;
assert!(!p.is_sweep_attack(1.0, false, true));
p.velocity = Vec3::new(f64::from(p.speed) * 2.5, 0.0, 0.0);
assert!(!p.is_sweep_attack(1.0, false, true));
}
#[test]
fn player_stands_walks_sneaks_and_jumps_on_ghast() {
let root = std::env::var_os("HORIZON_TEST_RESOURCES")
.map(std::path::PathBuf::from)
.unwrap_or_else(|| {
Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION)
});
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, &render, 1).unwrap();
let entities = [Aabb::new(
Vec3::new(10.0, 80.0, 10.0),
Vec3::new(14.0, 84.0, 14.0),
)];
let mut player = PlayerMotion::new(&resources, Vec3::new(12.0, 84.0, 12.0)).unwrap();
let mut tick = |player: &mut PlayerMotion, keys| {
MotionWorld {
entities: &entities,
player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
}
.controlled_simulation_tick(keys)
.unwrap()
};
for _ in 0..20 {
tick(&mut player, Default::default());
}
assert_eq!(player.position.y, 84.0);
assert!(player.ground.on_ground);
let forward = crate::sprint::Keys {
forward: true,
..Default::default()
};
for _ in 0..5 {
tick(&mut player, forward);
}
assert!(player.position.z > 12.0);
assert_eq!(player.position.y, 84.0);
tick(
&mut player,
crate::sprint::Keys {
jump: true,
..Default::default()
},
);
assert!(player.position.y > 84.0);
for _ in 0..30 {
tick(&mut player, Default::default());
}
assert_eq!(player.position.y, 84.0);
for _ in 0..80 {
tick(
&mut player,
crate::sprint::Keys {
shift: true,
..forward
},
);
}
assert_eq!(player.position.y, 84.0);
assert!(player.position.z < 14.3);
for _ in 0..30 {
tick(&mut player, forward);
}
assert!(player.position.y < 84.0);
}
/// `MovingPistonBlock.getCollisionShape`: a block halfway through a push
/// up is solid at its moving position, so a player lands on it.
#[test]
fn a_player_lands_on_a_block_a_piston_is_moving() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, &render, 1).unwrap();
let registry = assets.registry;
let moving = registry.default_state("minecraft:moving_piston").unwrap();
let stone = registry.default_state("minecraft:stone").unwrap();
scene.set(20, 4, 20, moving).unwrap();
scene.moving_pistons.push((
[20, 4, 20],
horizon_world::piston_shape::MovingPistonState {
moved_state: stone,
direction: horizon_core::geometry::Direction::Up,
extending: true,
source: false,
progress: 0.5,
previous_progress: 0.0,
},
));
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 6.0, 20.5)).unwrap();
for _ in 0..30 {
MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
}
.controlled_simulation_tick(Default::default())
.unwrap();
}
assert!(player.ground.on_ground);
assert_eq!(player.position.y, 4.5);
// Once the block entity is gone, the moving_piston block has no shape.
scene.moving_pistons.clear();
for _ in 0..10 {
MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
}
.controlled_simulation_tick(Default::default())
.unwrap();
}
assert_eq!(player.position.y, 4.0);
}
#[test]
fn a_lava_cauldron_burns_the_player_inside_it() {
let root = std::env::var_os("HORIZON_TEST_RESOURCES")
.map(std::path::PathBuf::from)
.unwrap_or_else(|| {
Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION)
});
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, &render, 1).unwrap();
let cauldron = assets
.registry
.default_state("minecraft:lava_cauldron")
.unwrap();
scene.set(20, 4, 20, cauldron).unwrap();
let mut tick = |player: &mut PlayerMotion| {
MotionWorld {
entities: &[],
player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
}
.controlled_simulation_tick(Default::default())
.unwrap();
};
// Standing on the cauldron's floor, in its lava.
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.25, 20.5)).unwrap();
player.ticks_frozen = 40;
tick(&mut player);
assert!(player.health.health() < 20.0, "the lava must hurt");
assert!(player.fire_ticks > 0, "the lava must ignite");
assert_eq!(player.ticks_frozen, 0);
// Beside it, nothing.
let mut away = PlayerMotion::new(&resources, Vec3::new(22.5, 4.0, 20.5)).unwrap();
tick(&mut away);
assert_eq!(away.health.health(), 20.0);
assert!(away.fire_ticks <= 0);
}
#[test]
fn a_water_cauldron_puts_out_a_burning_player() {
let root = std::env::var_os("HORIZON_TEST_RESOURCES")
.map(std::path::PathBuf::from)
.unwrap_or_else(|| {
Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION)
});
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, &render, 1).unwrap();
let water = assets
.registry
.resolve(&horizon_world::chunk::BlockState {
name: "minecraft:water_cauldron".into(),
properties: [("level".to_owned(), "3".to_owned())].into(),
})
.unwrap();
scene.set(20, 4, 20, water).unwrap();
let mut tick = |player: &mut PlayerMotion| {
MotionWorld {
entities: &[],
player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
}
.controlled_simulation_tick(Default::default())
.unwrap();
};
let asks = |player: &PlayerMotion| {
player
.events
.iter()
.filter(|e| matches!(e, MotionEvent::CauldronExtinguish { .. }))
.count()
};
// Burning, on the cauldron's floor in its water: put out, and the
// server is asked to lower the water.
let mut burning = PlayerMotion::new(&resources, Vec3::new(20.5, 4.25, 20.5)).unwrap();
burning.fire_ticks = 100;
tick(&mut burning);
assert!(burning.fire_ticks <= 0, "the water must put the fire out");
assert_eq!(asks(&burning), 1);
// Not burning: nothing to lower.
let mut dry = PlayerMotion::new(&resources, Vec3::new(20.5, 4.25, 20.5)).unwrap();
tick(&mut dry);
assert_eq!(asks(&dry), 0);
}
#[test]
fn standing_in_a_wither_rose_asks_for_its_effect() {
let root = std::env::var_os("HORIZON_TEST_RESOURCES")
.map(std::path::PathBuf::from)
.unwrap_or_else(|| {
Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION)
});
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, &render, 1).unwrap();
let rose = assets
.registry
.default_state("minecraft:wither_rose")
.unwrap();
scene.set(20, 4, 20, rose).unwrap();
let roses = |player: &PlayerMotion| {
player
.events
.iter()
.filter(|e| matches!(e, MotionEvent::InsideWitherRose))
.count()
};
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
}
.controlled_simulation_tick(Default::default())
.unwrap();
assert_eq!(roses(&player), 1);
// A server's player: its client moved it, the server applies the effect.
player.events.clear();
let from = player.position;
MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
}
.server_block_damage(from)
.unwrap();
assert_eq!(roses(&player), 1);
// Two blocks away, nothing.
let mut away = PlayerMotion::new(&resources, Vec3::new(22.5, 4.0, 20.5)).unwrap();
MotionWorld {
entities: &[],
player: &mut away,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
}
.controlled_simulation_tick(Default::default())
.unwrap();
assert_eq!(roses(&away), 0);
}
#[test]
fn server_travel_moves_only_the_velocity() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, &render, 1).unwrap();
let at = Vec3::new(20.5, 4.0, 20.5);
let mut player = PlayerMotion::new(&resources, at).unwrap();
let mut travel = |player: &mut PlayerMotion| {
MotionWorld {
entities: &[],
player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
}
.server_travel()
.unwrap()
};
// A knockback on the ground (vanilla's server sends 0.21840 0.27516
// after a zombie's hit): ground friction, then gravity and drag.
player.ground.on_ground = true;
player.velocity = Vec3::new(-0.4, 0.3608, 0.0);
travel(&mut player);
assert!(
(player.velocity.x + 0.2184).abs() < 1e-6,
"{:?}",
player.velocity
);
assert!(
(player.velocity.y - 0.275184).abs() < 1e-6,
"{:?}",
player.velocity
);
assert_eq!(player.position, at);
assert!(player.ground.on_ground);
// Falling onto the ground hurts no one on the server's copy, and leaves
// the fall to the client's moves.
let health = player.health.health();
player.position = Vec3::new(20.5, 4.5, 20.5);
player.ground.on_ground = false;
player.fall_distance = 10.0;
player.velocity = Vec3::new(0.0, -1.0, 0.0);
travel(&mut player);
assert_eq!(player.velocity.y, -0.0784000015258789);
assert_eq!(player.health.health(), health);
assert_eq!(player.fall_distance, 10.0);
assert!(player.events.is_empty());
}
#[test]
fn spectator_scroll_speed_controls_horizontal_and_vertical_flight() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let run = |steps| {
let mut scene = World::test_scene(&assets, &render, 2).unwrap();
let start = Vec3::new(20.5, 12.0, 20.5);
let mut player = PlayerMotion::new(&resources, start).unwrap();
player.spectator = true;
player.flying_speed = crate::mouse::spectator_flying_speed(player.flying_speed, steps);
MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
}
.controlled_simulation_tick(crate::sprint::Keys {
forward: true,
jump: true,
..Default::default()
})
.unwrap();
player.position.subtract(start)
};
let stopped = run(-100);
assert_eq!(stopped, Vec3::ZERO);
let normal = run(0);
let fast = run(10);
assert!(normal.y > 0.0 && normal.z > 0.0);
assert!((fast.y - normal.y * 2.0).abs() < 1e-6);
assert!((fast.z - normal.z * 2.0).abs() < 1e-6);
}
#[test]
fn resident_spectator_flight_ignores_solid_and_climbable_blocks() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let run = |name: &str, spectator: bool| {
let mut scene = World::test_scene(&assets, &render, 2).unwrap();
let state = assets.registry.default_state(name).unwrap();
for x in 19..=23 {
for y in 10..=17 {
for z in 19..=23 {
scene.set(x, y, z, state).unwrap();
}
}
}
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 12.0, 20.5)).unwrap();
player.spectator = spectator;
player.flying = spectator;
player.velocity = Vec3::new(0.4, 0.1, 0.4);
let keys = crate::sprint::Keys {
forward: true,
jump: true,
..Default::default()
};
let mut trajectory = Vec::new();
for _ in 0..4 {
MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
}
.controlled_simulation_tick(keys)
.unwrap();
trajectory.push((player.position, player.velocity));
}
trajectory
};
let air = run("minecraft:air", true);
for name in [
"minecraft:stone",
"minecraft:ladder",
"minecraft:vine",
"minecraft:scaffolding",
] {
assert_eq!(run(name, true), air, "spectator flight in {name}");
}
let air = run("minecraft:air", false);
let ladder = run("minecraft:ladder", false);
assert!(air.last().unwrap().1.y < 0.0);
assert!(ladder.last().unwrap().1.y > 0.0);
}
#[test]
fn creative_and_spectator_preserve_hunger_when_switching_from_survival() {
let root = std::env::var_os("HORIZON_TEST_RESOURCES")
.map(std::path::PathBuf::from)
.unwrap_or_else(|| {
Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION)
});
if !root.join("movement-properties.nbt").exists() {
eprintln!("skipped hunger regression: prepared resources unavailable");
return;
}
let assets = Assets::load(&root).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
// Both abilities are set by creative/spectator mode changes for the
// resident player and for LAN/dedicated guests.
for spectator in [false, true] {
for food in [0, 1, 20] {
let mut player = PlayerMotion::new(&resources, Vec3::ZERO).unwrap();
player.health.food.food = food;
player.health.food.saturation = 0.0;
player.health.food.exhaustion = 0.0;
player.health.food.timer = 79;
player.invulnerable = true;
player.spectator = spectator;
for _ in 0..160 {
player.cause_food_exhaustion(0.2);
player
.food_tick(&resources.health, Default::default())
.unwrap();
}
assert_eq!(player.health.food.food, food);
assert_eq!(player.health.food.saturation, 0.0);
assert_eq!(player.health.food.exhaustion, 0.0);
assert_eq!(player.health.health(), 20.0);
assert!(!player.health.dead_or_dying());
assert!(player.events.is_empty());
// Pending exhaustion from survival is still processed, but an
// empty food bar cannot hurt the now-invulnerable player.
player.health.food.exhaustion = 5.0;
player.health.food.timer = 79;
player
.food_tick(&resources.health, Default::default())
.unwrap();
assert_eq!(player.health.food.food, (food - 1).max(0));
assert_eq!(player.health.food.exhaustion, 1.0);
assert_eq!(player.health.health(), 20.0);
assert!(player.events.is_empty());
// Returning to survival resumes exhaustion and starvation.
player.health.food.food = food;
player.health.food.exhaustion = 0.0;
player.invulnerable = false;
player.spectator = false;
player.cause_food_exhaustion(0.2);
assert_eq!(player.health.food.exhaustion, 0.2);
player.health.food.exhaustion = 5.0;
player.health.food.timer = 79;
player
.food_tick(&resources.health, Default::default())
.unwrap();
assert_eq!(player.health.food.food, (food - 1).max(0));
assert_eq!(player.health.health(), if food <= 1 { 19.0 } else { 20.0 });
}
}
}
#[test]
fn player_fire_damage_queues_hurt_sound_only_for_fresh_hits() {
let root = std::env::var_os("HORIZON_TEST_RESOURCES")
.map(std::path::PathBuf::from)
.unwrap_or_else(|| {
Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION)
});
if !root.join("movement-properties.nbt").exists() {
eprintln!("skipped damage regression: prepared resources unavailable");
return;
}
let assets = Assets::load(&root).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
for name in ["on_fire", "in_fire", "lava"] {
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
let source = resources
.health
.damage
.id(&format!("minecraft:{name}"))
.unwrap();
assert!(
player
.hurt(&resources.health, Default::default(), source, 1.0)
.unwrap()
);
assert_eq!(
player
.events
.iter()
.filter(|e| matches!(
e,
MotionEvent::HurtSound("minecraft:entity.player.hurt_on_fire")
))
.count(),
1
);
assert_eq!(player.health.hurt_animation_time, 10);
player.health.advance_clock();
player.events.clear();
assert!(
!player
.hurt(&resources.health, Default::default(), source, 1.0)
.unwrap()
);
assert!(
!player
.events
.iter()
.any(|e| matches!(e, MotionEvent::HurtSound(_)))
);
assert_eq!(
player.health.hurt_animation_time, 9,
"cooldown hit must not restart animation"
);
for _ in 0..20 {
player.health.advance_clock();
}
assert_eq!(player.health.hurt_animation_time, 0);
player.invulnerable = true;
player.events.clear();
assert!(
!player
.hurt(&resources.health, Default::default(), source, 1.0)
.unwrap()
);
assert!(
!player
.events
.iter()
.any(|e| matches!(e, MotionEvent::HurtSound(_)))
);
}
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
let source = resources.health.damage.id("minecraft:mob_attack").unwrap();
assert!(
player
.hurt_blocking(&resources.health, Default::default(), source, 2.0, None)
.unwrap()
.hurt
);
assert_eq!(
player
.events
.iter()
.filter(|e| matches!(e, MotionEvent::HurtSound("minecraft:entity.player.hurt")))
.count(),
1
);
// A shield that takes the whole arrow: onBlocked's sound, no damage
// event, so the player hears no hurt sound.
use horizon_world::blocking_rules::{BlockingRules, DamageReduction, ItemDamageFunction};
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
let source = resources.health.damage.id("minecraft:arrow").unwrap();
let shield = crate::health::Blocking {
rules: BlockingRules {
delay_seconds: 0.25,
disable_scale: 1.0,
reductions: vec![DamageReduction {
horizontal_angle: 90.0,
types: None,
base: 0.0,
factor: 1.0,
}],
item_damage: ItemDamageFunction {
threshold: 3.0,
base: 1.0,
factor: 1.0,
},
},
bypassed: false,
pierce: false,
angle: 0.0,
};
let outcome = player
.hurt_blocking(
&resources.health,
Default::default(),
source,
4.0,
Some(shield.clone()),
)
.unwrap();
assert!(!outcome.hurt && outcome.sound && outcome.blocked == 4.0);
assert_eq!(
player.health.hurt.hurt_time, 10,
"preserve server damage bookkeeping"
);
assert_eq!(
player.health.hurt_animation_time, 0,
"a fully blocked arrow must not animate hurt"
);
assert!(
!player
.events
.iter()
.any(|e| matches!(e, MotionEvent::HurtSound(_)))
);
// An unblocked hit after the shield block must still animate normally.
for _ in 0..20 {
player.health.advance_clock();
}
assert!(
player
.hurt(&resources.health, Default::default(), source, 4.0)
.unwrap()
);
assert_eq!(player.health.hurt_animation_time, 10);
player.health.advance_clock();
assert!(
!player
.hurt_blocking(
&resources.health,
Default::default(),
source,
4.0,
Some(shield)
)
.unwrap()
.hurt
);
assert_eq!(
player.health.hurt_animation_time, 9,
"blocking must not erase or restart an existing animation"
);
let mut starving = PlayerMotion::new(&resources, Vec3::ZERO).unwrap();
starving.health.food.food = 0;
starving.health.food.timer = 79;
starving
.food_tick(&resources.health, Default::default())
.unwrap();
assert_eq!(starving.health.health(), 19.0);
assert_eq!(
starving.health.hurt_animation_time, 10,
"starvation must still animate hurt"
);
}
#[test]
fn a_glide_that_is_not_diving_keeps_the_fall_distance_at_one() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
// Entity.checkFallDistanceAccumulation: capped above -0.5 a tick, not below.
for (dy, capped) in [(-0.3, true), (-0.49, true), (-0.8, false)] {
let mut scene = World::test_scene(&assets, &render, 2).unwrap();
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 20.0, 20.5)).unwrap();
player.glider = true;
player.fall_flying = true;
player.velocity = Vec3::new(0.0, dy, 0.6);
player.fall_distance = 30.0;
let mut w = MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
};
w.player_movement_tick([0.0, 0.0], false).unwrap();
assert!(w.player.fall_flying);
if capped {
assert!(
w.player.fall_distance < 2.0,
"{dy}: {}",
w.player.fall_distance
);
} else {
assert!(
w.player.fall_distance > 30.0,
"{dy}: {}",
w.player.fall_distance
);
}
}
}
/// Footsteps on the prepared vanilla resources, when they are present:
/// none while standing (gravity still moves the player every tick), one
/// per `nextStep` metre while walking.
#[test]
fn resident_water_landing_cancels_a_preset_fall() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
for wet in [false, true] {
let mut scene = World::test_scene(&assets, &render, 2).unwrap();
if wet {
let water = assets.registry.default_state("minecraft:water").unwrap();
for x in 19..=21 {
for z in 19..=21 {
scene.set(x, 3, z, water).unwrap();
}
}
}
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 20.0, 20.5)).unwrap();
player.fall_distance = 30.0;
let mut w = MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
};
w.move_self(Vec3::new(0.0, -30.0, 0.0)).unwrap();
assert!(w.player.ground.on_ground);
assert_eq!(w.player.fluids.was_touching_water, wet);
if wet {
assert_eq!(w.player.health.health(), 20.0);
assert_eq!(w.player.fall_distance, 0.0);
} else {
assert!(w.player.health.health() < 20.0);
}
}
}
/// A client's own fall (multiplayer, a LAN guest, single player on its
/// server thread) plays its landing but never hurts it: only the server
/// does (`Entity.hurt` on a client), so a server that cancels fall damage
/// leaves the screen still.
#[test]
fn a_clients_own_fall_does_not_hurt_it() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
for client_side in [false, true] {
let mut scene = World::test_scene(&assets, &render, 2).unwrap();
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 20.0, 20.5)).unwrap();
player.client_side = client_side;
player.fall_distance = 30.0;
let mut w = MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
};
w.move_self(Vec3::new(0.0, -30.0, 0.0)).unwrap();
assert!(w.player.ground.on_ground);
assert_eq!(w.player.fall_distance, 0.0);
// LivingEntity.causeFallDamage's sounds play on both sides.
assert!(w.player.events.iter().any(|e| matches!(
e,
MotionEvent::Fall(crate::landing::FallEvent::Sound {
sound: crate::landing::SceneSound::BigFall,
..
})
)));
let hurt = w.player.health.health() < 20.0;
assert_eq!(hurt, !client_side);
assert_eq!(w.player.health.hurt_animation_time > 0, !client_side);
// The server's health then starts the client's hurt animation.
if client_side {
w.player.health.flash_health_change(20.0);
assert_eq!(w.player.health.hurt_animation_time, 0);
assert_eq!(w.player.health.hurt.cooldown, 0);
w.player.health.flash_health_change(12.0);
assert_eq!(w.player.health.hurt_animation_time, 10);
// LocalPlayer.hurtTo's damageCooldownTime: the HUD's hearts blink.
assert_eq!(w.player.health.hurt.cooldown, 20);
w.player.health.flash_health_change(25.0);
assert_eq!(w.player.health.hurt.cooldown, 10);
}
}
}
#[test]
fn slow_falling_clears_the_fall_distance_so_landing_does_not_hurt() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
for slow_falling in [false, true] {
let mut scene = World::test_scene(&assets, &render, 2).unwrap();
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 9.0, 20.5)).unwrap();
player.fall_distance = 30.0;
player.status.slow_falling = slow_falling;
let mut w = MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
};
for _ in 0..200 {
if w.player.ground.on_ground {
break;
}
w.player_movement_tick([0.0, 0.0], false).unwrap();
}
assert!(w.player.ground.on_ground);
if slow_falling {
assert_eq!(w.player.health.health(), 20.0);
assert_eq!(w.player.fall_distance, 0.0);
} else {
assert!(w.player.health.health() < 20.0);
}
}
}
#[test]
fn a_riptide_spin_lies_flat_and_ends_on_the_first_entity_it_touches() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, &render, 2).unwrap();
let ahead = Aabb::new(Vec3::new(20.2, 9.0, 21.5), Vec3::new(20.8, 11.0, 22.1));
for target in [None, Some(ahead)] {
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 10.0, 20.5)).unwrap();
player.auto_spin_attack_ticks = 20;
player.auto_spin_attack_dmg = 8.0;
player.velocity = Vec3::new(0.0, 0.0, 1.0);
player.spin_targets = target.map(|b| (7, b)).into_iter().collect();
let mut w = MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
};
w.simulation_tick([0.0, 0.0], false).unwrap();
if target.is_some() {
// Touched: the hit, no more spin, bounced back at a fifth.
assert_eq!(w.player.spin_hit, Some(7));
assert_eq!(w.player.auto_spin_attack_ticks, 0);
assert!(w.player.velocity.z < 0.0, "{:?}", w.player.velocity);
assert_eq!(w.player.pose, crate::pose::Pose::Standing);
} else {
assert_eq!(w.player.spin_hit, None);
assert_eq!(w.player.auto_spin_attack_ticks, 19);
assert_eq!(w.player.pose, crate::pose::Pose::SpinAttack);
assert_eq!(w.player.dimensions.height, 0.6);
}
}
}
#[test]
fn a_landing_glide_lasts_a_tick_so_a_jump_keeps_its_speed() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, &render, 2).unwrap();
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.2, 20.5)).unwrap();
let mut w = MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
};
w.move_self(Vec3::new(0.0, -1.0, 0.0)).unwrap();
assert!(w.player.ground.on_ground);
w.player.set_sprinting(true).unwrap();
w.player.glider = true;
w.player.fall_flying = true;
w.player.velocity = Vec3::new(0.0, 0.0, 1.5);
// The landed glide's extra tick: the jump's sprint boost, no ground friction.
w.player_movement_tick([0.0, 1.0], true).unwrap();
assert!(w.player.fall_flying);
assert!(w.player.velocity.y > 0.3, "jumped: {:?}", w.player.velocity);
assert!(
w.player.velocity.z > 1.5,
"kept its speed: {:?}",
w.player.velocity
);
// Then the server's cleared flag arrives.
w.player_movement_tick([0.0, 1.0], true).unwrap();
assert!(!w.player.fall_flying);
}
#[test]
fn resident_water_and_lava_are_not_treated_as_air() {
let root = std::env::var_os("HORIZON_TEST_RESOURCES")
.map(std::path::PathBuf::from)
.unwrap_or_else(|| {
Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION)
});
if !root.join("movement-properties.nbt").exists() {
eprintln!("skipping resident water/lava test: prepared resources unavailable");
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, &render, 3).unwrap();
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
let water = assets.registry.default_state("minecraft:water").unwrap();
for x in 19..=21 {
for y in 3..=7 {
for z in 19..=21 {
scene.set(x, y, z, water).unwrap();
}
}
}
let mut w = MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
};
w.controlled_simulation_tick(Default::default()).unwrap();
assert!(
MovementStatisticsWorld::in_water(&mut w).unwrap(),
"resident water must reach the player movement adapter"
);
assert!(MovementStatisticsWorld::eyes_in_water(&mut w).unwrap());
assert!(
!w.player.fluids.was_eye_in_water,
"the first controlled tick must run only one fluid base phase"
);
assert!(
(w.player.velocity.y + 0.005).abs() < 1e-5,
"water drag/gravity must replace air travel: {:?}",
w.player.velocity
);
let lava = assets.registry.default_state("minecraft:lava").unwrap();
for x in 19..=21 {
for y in 3..=7 {
for z in 19..=21 {
w.scene.set(x, y, z, lava).unwrap();
}
}
}
w.controlled_simulation_tick(Default::default()).unwrap();
assert!(
w.player.health.health() < 20.0,
"lava must damage a survival player"
);
// Water extinguishes, swimming is a real pose, and deep water consumes air.
for x in 19..=21 {
for y in 3..=7 {
for z in 19..=21 {
w.scene.set(x, y, z, water).unwrap();
}
}
}
w.player.fire_ticks = 160;
w.controlled_simulation_tick(Default::default()).unwrap();
assert!(w.player.fire_ticks <= 0);
w.player.air = -19;
w.player.health.hurt.cooldown = 0;
let hp = w.player.health.health();
w.controlled_simulation_tick(Default::default()).unwrap();
assert_eq!(w.player.air, 0);
assert!(w.player.health.health() < hp, "drowning must hurt");
w.player.invulnerable = true;
let hp = w.player.health.health();
w.player.air = -19;
w.controlled_simulation_tick(Default::default()).unwrap();
assert_eq!(w.player.health.health(), hp);
w.player.invulnerable = false;
w.player.air = 300;
w.controlled_simulation_tick(crate::sprint::Keys {
forward: true,
sprint: true,
..Default::default()
})
.unwrap();
assert!(w.player.sprinting);
assert!(
!w.player.swimming,
"sprint input follows the swimming phase"
);
w.controlled_simulation_tick(crate::sprint::Keys {
forward: true,
sprint: true,
..Default::default()
})
.unwrap();
assert!(w.player.swimming);
assert_eq!(w.player.pose, crate::pose::Pose::Swimming);
// Direct fire contact ignites; resistance prevents damage but does not hide flames.
let fire = assets.registry.default_state("minecraft:fire").unwrap();
for x in 19..=21 {
for y in 3..=7 {
for z in 19..=21 {
w.scene.set(x, y, z, fire).unwrap();
}
}
}
w.player.position = Vec3::new(20.5, 4.0, 20.5);
w.player.velocity = Vec3::ZERO;
w.player.fire_ticks = -20;
w.player.health.hurt.cooldown = 0;
w.player.ticks_frozen = 140;
let hp = w.player.health.health();
w.controlled_simulation_tick(Default::default()).unwrap();
assert!(
w.player.fire_ticks < 0,
"direct fire hurts during the immunity delay"
);
assert_eq!(
w.player.ticks_frozen, 0,
"fire contact clears freeze during the delay"
);
assert!(w.player.health.health() < hp);
w.player.status.fire_resistance = true;
w.player.health.hurt.cooldown = 0;
let hp = w.player.health.health();
w.controlled_simulation_tick(Default::default()).unwrap();
assert_eq!(w.player.health.health(), hp);
w.player.invulnerable = true;
w.player.fire_ticks = -20;
w.player.ticks_frozen = 140;
w.controlled_simulation_tick(Default::default()).unwrap();
assert_eq!(w.player.ticks_frozen, 0);
assert_eq!(
w.player.fire_ticks, -19,
"creative preserves the fire-contact delay"
);
for _ in 0..18 {
w.apply_fire_contact().unwrap();
}
assert_eq!(w.player.fire_ticks, -1);
w.apply_fire_contact().unwrap();
assert_eq!(
w.player.fire_ticks, 1,
"creative clamps only after ignition"
);
w.player.ticks_frozen = 140;
w.player.ignite_for_ticks(160).unwrap();
assert_eq!(w.player.ticks_frozen, 0);
assert_eq!(w.player.fire_ticks, 1);
w.player.invulnerable = false;
// Sprint swimming must keep full input, not the dry crawl/sneak multiplier.
for x in 19..=21 {
for y in 2..=7 {
for z in 19..=30 {
w.scene.set(x, y, z, water).unwrap();
}
}
}
w.player.position = Vec3::new(20.5, 4.0, 20.5);
w.player.velocity = Vec3::ZERO;
w.player.local_crouching = false;
w.player.swimming = true;
w.player.sprinting = true;
w.player.set_pose(crate::pose::Pose::Swimming).unwrap();
for _ in 0..30 {
w.controlled_simulation_tick(crate::sprint::Keys {
forward: true,
sprint: true,
..Default::default()
})
.unwrap();
}
assert!(
w.player.velocity.z > 0.165,
"native sprint swim speed must not receive crawl slowdown: {:?}",
w.player.velocity
);
assert!(!w.player.moving_slowly());
w.player.position = Vec3::new(20.5, 4.0, 20.5);
w.player.velocity = Vec3::ZERO;
w.player.pitch = 45.0;
w.controlled_simulation_tick(crate::sprint::Keys {
forward: true,
sprint: true,
..Default::default()
})
.unwrap();
assert!(
w.player.velocity.y < -0.04,
"look down must steer a swimming player downward"
);
w.player.position = Vec3::new(20.5, 4.0, 20.5);
w.player.velocity = Vec3::ZERO;
w.player.pitch = -45.0;
w.controlled_simulation_tick(crate::sprint::Keys {
forward: true,
sprint: true,
..Default::default()
})
.unwrap();
assert!(
w.player.velocity.y > 0.02,
"look up must steer a submerged swimmer upward"
);
let extra = horizon_world::nbt::Tag::compound([
("Fire", horizon_world::nbt::Tag::Short(160)),
("Air", horizon_world::nbt::Tag::Short(8)),
]);
let mut level = crate::save::Level {
health: 13.0,
food: 11,
saturation: 2.25,
player_extra: Some(extra),
flying: true,
..Default::default()
};
let mut pending = true;
w.player
.load_saved_state_once(&mut pending, &level)
.unwrap();
assert_eq!((w.player.fire_ticks, w.player.air), (160, 8));
assert!(w.player.flying);
assert_eq!(
(
w.player.health.health(),
w.player.health.food.food,
w.player.health.food.saturation
),
(13.0, 11, 2.25)
);
let mut respawn = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
respawn.load_saved_state_once(&mut pending, &level).unwrap();
assert_eq!((respawn.fire_ticks, respawn.air), (-20, 300));
assert!(!respawn.flying);
assert_eq!(
(respawn.health.health(), respawn.health.food.food),
(20.0, 20)
);
// Reopening another world restores its state, including a saved death.
pending = true;
level.health = 0.0;
w.player
.load_saved_state_once(&mut pending, &level)
.unwrap();
assert!(w.player.health.dead_or_dying());
assert!(!pending);
w.player.fluids.was_touching_water = false;
assert!(
w.player.moving_slowly(),
"dry crawling must still slow input"
);
}
#[test]
fn resident_swimming_uses_previous_eyes_and_requires_water_at_the_feet() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, &render, 3).unwrap();
let water = assets.registry.default_state("minecraft:water").unwrap();
for y in 4..=6 {
scene.set(20, y, 20, water).unwrap();
}
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
let mut w = MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
};
w.player.local_crouching = true;
let sprint = crate::sprint::Keys {
forward: true,
sprint: true,
..Default::default()
};
w.fluid_base_tick().unwrap();
assert!(w.player.is_eye_in_fluid(WATER));
assert!(!w.player.is_under_water());
w.player.sprint_input_tick(sprint).unwrap();
assert!(
!w.player.sprinting,
"new eye immersion cannot bypass crouching"
);
w.fluid_base_tick().unwrap();
assert!(w.player.is_under_water());
w.player.sprint_input_tick(sprint).unwrap();
assert!(w.player.sprinting);
assert!(!w.player.swimming, "sprint starts after the base tick");
w.fluid_base_tick().unwrap();
assert!(w.player.swimming);
let air = assets.registry.default_state("minecraft:air").unwrap();
w.scene.set(20, 4, 20, air).unwrap();
w.player.swimming = false;
w.fluid_base_tick().unwrap();
assert!(w.player.is_under_water());
assert!(
!w.player.swimming,
"starting a swim requires water in the feet cell"
);
w.player.swimming = true;
w.fluid_base_tick().unwrap();
assert!(
w.player.swimming,
"an existing swim only requires touching water"
);
w.player.flying = true;
w.fluid_base_tick().unwrap();
assert!(!w.player.swimming);
w.player.flying = false;
w.player.spectator = true;
w.scene.set(20, 4, 20, water).unwrap();
w.fluid_base_tick().unwrap();
assert!(
w.player.swimming,
"spectator flight is applied later in aiStep"
);
}
#[test]
fn resident_fire_precedes_first_tick_lava_and_water_extinguishing() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
for name in ["minecraft:lava", "minecraft:water"] {
let mut scene = World::test_scene(&assets, &render, 3).unwrap();
let fluid = assets.registry.default_state(name).unwrap();
scene.set(20, 4, 20, fluid).unwrap();
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
player.fire_ticks = 160;
player.fall_distance = 8.0;
let mut w = MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
};
w.fluid_base_tick().unwrap();
assert_eq!(
w.player.health.health(),
19.0,
"base on-fire damage: {name}"
);
if name == "minecraft:lava" {
assert_eq!(w.player.fire_ticks, 159);
assert_eq!(w.player.fall_distance, 8.0, "first tick excludes lava");
w.fluid_base_tick().unwrap();
assert_eq!(
w.player.fall_distance, 4.0,
"later ticks halve exactly once"
);
} else {
assert_eq!(w.player.fire_ticks, 0, "water extinguishes after the hurt");
assert_eq!(w.player.fall_distance, 0.0);
w.player.fire_ticks = -7;
w.fluid_base_tick().unwrap();
assert_eq!(
w.player.fire_ticks, -7,
"clearing fire retains negative delay"
);
}
}
}
#[test]
fn resident_bubble_columns_and_nautilus_preserve_their_air_rules() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, &render, 3).unwrap();
let water = assets.registry.default_state("minecraft:water").unwrap();
scene.set(20, 4, 20, water).unwrap();
scene.set(20, 5, 20, water).unwrap();
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
let mut w = MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
};
for (extra_effect, expected_air) in [
(None, -19),
(Some("water_breathing"), -15),
(Some("conduit_power"), -15),
] {
let mut effects = crate::effects::PlayerEffects::default();
effects.add(crate::effects::EffectInstance::new(
"breath_of_the_nautilus",
200,
0,
));
if let Some(id) = extra_effect {
effects.add(crate::effects::EffectInstance::new(id, 200, 0));
}
w.player.status = effects.status();
assert!(w.player.status.breath_of_the_nautilus);
w.player.air = -19;
w.fluid_base_tick().unwrap();
w.tick_environment_damage().unwrap();
assert_eq!(w.player.air, expected_air);
assert_eq!(w.player.health.health(), 20.0);
}
w.player.status.water_breathing = false;
for (name, nautilus) in [
("minecraft:bubble_column", false),
("minecraft:bubble_column", true),
("minecraft:air", true),
] {
w.scene
.set(20, 5, 20, assets.registry.default_state(name).unwrap())
.unwrap();
w.player.status.breath_of_the_nautilus = nautilus;
w.player.air = -19;
w.fluid_base_tick().unwrap();
w.tick_environment_damage().unwrap();
assert_eq!(w.player.air, -15, "{name}, nautilus={nautilus}");
assert_eq!(w.player.health.health(), 20.0);
}
w.scene.set(20, 5, 20, water).unwrap();
w.player.status.breath_of_the_nautilus = false;
w.player.air = -19;
w.fluid_base_tick().unwrap();
w.tick_environment_damage().unwrap();
assert_eq!(w.player.air, 0);
assert_eq!(w.player.health.health(), 18.0);
}
#[test]
fn resident_mixed_fluids_use_lava_height_for_ground_jumps() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
for (water_level, lava_level, ground_jump) in [(0, 6, true), (6, 0, false)] {
let mut scene = World::test_scene(&assets, &render, 3).unwrap();
for (name, level, x) in [
("minecraft:water", water_level, 20),
("minecraft:lava", lava_level, 21),
] {
let mut state = assets
.registry
.state(assets.registry.default_state(name).unwrap())
.unwrap()
.clone();
state.properties.insert("level".into(), level.to_string());
scene
.set(x, 4, 20, assets.registry.id(&state).unwrap())
.unwrap();
}
let mut player = PlayerMotion::new(&resources, Vec3::new(21.0, 4.0, 20.5)).unwrap();
player.ground.on_ground = true;
let mut w = MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
};
w.fluid_base_tick().unwrap();
assert!(w.player.fluids.was_touching_water && w.player.is_in_lava());
assert_eq!(w.player.fluid_height(LAVA) <= 0.4, ground_jump);
assert_eq!(w.player.fluid_height(WATER) > 0.4, ground_jump);
w.dry_tick(TickInput::PreparedLocal {
direction: [0.0; 2],
jumping: true,
})
.unwrap();
assert_eq!(w.player.no_jump_delay == 10, ground_jump);
}
}
#[test]
fn footsteps_follow_the_walked_distance_not_the_tick() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let mut scene = World::test_scene(&assets, &render, 3).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
let mut steps = |player: &mut PlayerMotion, keys: crate::sprint::Keys, ticks: usize| {
let mut count = 0;
for _ in 0..ticks {
MotionWorld {
entities: &[],
player: &mut *player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
}
.controlled_simulation_tick(keys)
.unwrap();
count += std::mem::take(&mut player.events)
.iter()
.filter(|e| matches!(e, MotionEvent::Emission { .. }))
.count();
}
count
};
// Settle onto the floor, then stand still.
steps(&mut player, Default::default(), 20);
assert!(player.ground.on_ground);
assert_eq!(steps(&mut player, Default::default(), 100), 0);
let start = player.position;
let forward = crate::sprint::Keys {
forward: true,
..Default::default()
};
let walked = steps(&mut player, forward, 100);
let metres = player.position.subtract(start).length() * 0.6;
assert!(metres > 5.0, "walked {metres}");
assert!(
(walked as f64 - metres).abs() <= 1.5,
"{walked} steps over {metres} step-metres"
);
}
/// Vanilla sprint is a state, not a held key: `LocalPlayer.aiStep` starts
/// it with the sprint key and stops it only on a vanilla stop condition.
/// Releasing the key while swimming keeps the sprint and its swim speed.
#[test]
fn a_sprint_survives_the_sprint_key_coming_up_while_swimming() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let water = assets.registry.default_state("minecraft:water").unwrap();
let forward = crate::sprint::Keys {
forward: true,
..Default::default()
};
let sprinting = crate::sprint::Keys {
sprint: true,
..forward
};
// The same swim with the sprint key held, and with the key released
// once the sprint has started: the speed must not change.
let mut swims = Vec::new();
for release in [false, true] {
let mut scene = World::test_scene(&assets, &render, 3).unwrap();
for x in 19..=21 {
for y in 4..=8 {
for z in 19..=31 {
scene.set(x, y, z, water).unwrap();
}
}
}
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
let mut w = MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
};
let mut speed = Vec::new();
for tick in 0..12 {
// The key comes up on the fourth tick, after the sprint has
// started and the player swims.
let keys = if release && tick >= 4 {
forward
} else {
sprinting
};
w.controlled_simulation_tick(keys).unwrap();
speed.push(w.player.velocity.z);
}
assert!(
w.player.sprinting,
"the sprint state survives the sprint key in water"
);
assert!(w.player.swimming, "a sprinting player in water swims");
swims.push(speed);
}
assert_eq!(
swims[0], swims[1],
"the swim speed must not drop when the sprint key comes up"
);
}
/// Vanilla: `LivingEntity.jumpFromGround` adds its 0.2 forward impulse
/// while the sprint state holds, so a jump taken after the sprint key
/// comes up is still a sprint jump.
#[test]
fn a_sprint_jump_keeps_its_impulse_when_the_sprint_key_comes_up() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, &render, 3).unwrap();
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 4.0, 20.5)).unwrap();
let mut w = MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
};
let forward = crate::sprint::Keys {
forward: true,
..Default::default()
};
let sprinting = crate::sprint::Keys {
sprint: true,
..forward
};
for _ in 0..20 {
w.controlled_simulation_tick(sprinting).unwrap();
}
assert!(w.player.ground.on_ground, "the player settles on the floor");
assert!(w.player.sprinting, "the sprint key starts the sprint");
let running = w.player.velocity.z;
// The sprint key comes up and the player jumps.
w.controlled_simulation_tick(crate::sprint::Keys {
jump: true,
..forward
})
.unwrap();
assert!(
w.player.sprinting,
"the sprint state survives the sprint key in the air"
);
assert!(
w.player.velocity.z > running + 0.05,
"the sprint jump keeps its forward impulse: {:?} vs {running}",
w.player.velocity
);
}
/// Vanilla `Player.getFlyingSpeed`: a flying player moves at the ability
/// speed, doubled while the sprint state holds. The sprint key starts the
/// state; releasing it does not change the speed.
#[test]
fn the_flight_speed_follows_the_sprint_state_not_the_sprint_key() {
let root = Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../.local/horizon-client")
.join(horizon_core::VANILLA_VERSION);
if !root.join("movement-properties.nbt").exists() {
return;
}
let assets = Assets::load(&root).unwrap();
let render = assets.reload(&root).unwrap();
let binding = crate::collisions::load(&root, assets.registry).unwrap();
let resources = MotionResources::load(&root, &assets).unwrap();
let mut scene = World::test_scene(&assets, &render, 3).unwrap();
let mut player = PlayerMotion::new(&resources, Vec3::new(20.5, 10.0, 20.5)).unwrap();
let mut w = MotionWorld {
entities: &[],
player: &mut player,
scene: &mut scene,
assets: &assets,
collision_binding: &binding,
resources: &resources,
};
w.player.may_fly = true;
w.player.flying = true;
let forward = crate::sprint::Keys {
forward: true,
..Default::default()
};
let sprinting = crate::sprint::Keys {
sprint: true,
..forward
};
assert_eq!(
w.flying_speed().unwrap(),
0.05,
"a flying player without a sprint moves at the ability speed"
);
// The sprint key starts the sprint, and the state doubles the speed.
w.controlled_simulation_tick(sprinting).unwrap();
assert!(w.player.sprinting, "the sprint key starts the sprint");
assert_eq!(
w.flying_speed().unwrap(),
0.1,
"a sprinting player flies at twice the ability speed"
);
// Releasing the sprint key keeps the state, so the speed stays.
w.controlled_simulation_tick(forward).unwrap();
assert!(
w.player.sprinting,
"the sprint state survives the sprint key in the air"
);
assert_eq!(
w.flying_speed().unwrap(),
0.1,
"the flight speed follows the sprint state, not the sprint key"
);
}
}