Files
horizon-airdef/crates/horizon-client/src/motion.rs
T

896 lines
29 KiB
Rust

//! Stored movement state for the resident scene. This binds the validated air,
//! jump, collision, support, restitution and stored health bindings. Entity lifecycle,
//! block-inside effects and audiovisual event consumers remain separate work.
use crate::{Result, assets::Assets, collisions::SceneCollisions, world::TestWorld};
use horizon_core::{
geometry::{Aabb, Vec3, VoxelShape, traverse_blocks},
position::BlockPos,
};
use horizon_world::{
attribute_map::ValueKind,
attributes::{Modifier, Operation, entity::Catalog, live::LiveAttributes},
block_collision::BlockCollisionRegistry,
block_landing::BlockLandingRegistry,
collision_context::{CollisionContext, CollisionEntity, CollisionItem},
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::MovementEmission,
movement_properties::{
BoundMovementProperties, MovementBlockProvider, MovementProperties, MovementTags,
RegistryMovementWorld,
},
movement_restitution::{self, RestitutionInput, RestitutionWorld},
movement_statistics::{self, MovementStat, MovementStatisticsWorld},
movement_support::{self, MovementLocation},
nbt::{self, Limits},
registry::BlockStateId,
world_movement::{self, MovementRequest},
worldgen::tags::TagDefinitions,
};
use std::{
collections::{BTreeMap, BTreeSet},
fs, io,
path::Path,
sync::Arc,
};
pub struct MotionResources {
pub attributes: Arc<Catalog>,
pub blocks: BoundMovementProperties,
pub climbable: BTreeSet<String>,
pub fall_reset: BTreeSet<String>,
pub landing: BlockLandingRegistry,
pub health: crate::health::HealthResources,
}
impl MotionResources {
pub fn load(root: &Path, assets: &Assets) -> Result<Self> {
let attributes = Arc::new(Catalog::from_json(&serde_json::from_slice(&fs::read(
root.join("attributes.json"),
)?)?)?);
let data = nbt::read_named(
&fs::read(root.join("movement-properties.nbt"))?,
Limits::default(),
)?
.0
.tag;
let properties = MovementProperties::from_nbt(&data, &assets.registry)?;
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)?,
attributes,
blocks: properties.bind(&MovementTags {
fences: tag("minecraft:fences")?,
walls: tag("minecraft:walls")?,
suppresses_bounce: tag("minecraft:suppresses_bounce")?,
})?,
climbable: tag("minecraft:climbable")?,
fall_reset: tag("minecraft:fall_damage_resetting")?,
})
}
}
/// 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 {
Health(crate::health::HealthEvent),
Fall(crate::landing::FallEvent),
Recorded {
mover: MoverType,
movement: Vec3,
},
Landing {
dy: f64,
grounded: bool,
state: BlockStateId,
position: BlockPos,
},
Emission {
movement: Vec3,
position: BlockPos,
state: BlockStateId,
},
Bounce {
position: BlockPos,
state: BlockStateId,
fall_distance: f64,
},
}
pub struct PlayerMotion {
pub position: Vec3,
pub velocity: Vec3,
pub ground: GroundState,
pub collision: CollisionFlags,
pub history: MovementHistory,
pub fall_distance: f64,
pub stuck_multiplier: Vec3,
pub yaw: f32,
pub head_yaw: f32,
pub jumping: bool,
pub no_jump_delay: i32,
pub jump_trigger_time: i32,
pub sprinting: bool,
pub speed: f32,
pub last_climbable: Option<BlockPos>,
pub needs_sync: bool,
pub sync_position: bool,
pub events: Vec<MotionEvent>,
pub attributes: LiveAttributes<Box<dyn FnMut() -> i32>>,
pub impulse: ImpulseContext,
pub health: crate::health::PlayerHealth,
}
fn attribute_error(error: impl std::fmt::Debug) -> io::Error {
io::Error::other(format!("movement attribute: {error:?}"))
}
impl PlayerMotion {
pub fn new(resources: &MotionResources, position: Vec3) -> Result<Self> {
// Identity hashes affect map order, not queried movement values. These
// are process-owned identities; no JVM allocation order is assumed.
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
});
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)?,
impulse: ImpulseContext::default(),
position,
velocity: Vec3::ZERO,
ground: GroundState::default(),
collision: CollisionFlags::default(),
history: MovementHistory::default(),
fall_distance: 0.0,
stuck_multiplier: Vec3::ZERO,
yaw: 0.0,
head_yaw: 0.0,
jumping: false,
no_jump_delay: 0,
jump_trigger_time: 0,
sprinting: false,
speed: 0.0,
last_climbable: None,
needs_sync: false,
sync_position: false,
events: Vec::new(),
attributes,
})
}
pub fn bounds(&self) -> Aabb {
let half = f64::from(0.6_f32 / 2.0);
Aabb::new(
Vec3::new(
self.position.x - half,
self.position.y,
self.position.z - half,
),
Vec3::new(
self.position.x + half,
self.position.y + f64::from(1.8_f32),
self.position.z + half,
),
)
}
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)?)
}
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(())
}
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> {
pub player: &'p mut PlayerMotion,
pub scene: &'w mut TestWorld<'r>,
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: false,
main_hand: Some(CollisionItem::EMPTY),
},
false,
)
}
fn collisions(&self) -> SceneCollisions<'_, '_> {
SceneCollisions {
world: self.scene,
binding: self.collision_binding,
}
}
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,
}
}
fn climbable(&mut self) -> Result<bool> {
let p = BlockPos::containing(self.player.position);
let name = &self
.assets
.registry
.state(self.block(p))
.ok_or("missing scene state")?
.name;
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 server
/// frost-modifier cleanup with zero frozen ticks. Equipment, interpolation,
/// effects and 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<()> {
if self.player.jump_trigger_time > 0 {
self.player.jump_trigger_time -= 1;
}
self.player.peaceful_regeneration(self.scene.health_rules)?;
self.dry_tick(TickInput::PreparedLocal { direction, jumping })?;
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();
let previous = self.player.position;
self.player_movement_tick(direction, jumping)?;
// 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 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;
}
let mut velocity = self.player.velocity;
if velocity.x * velocity.x + velocity.z * velocity.z < 9.0e-6 {
velocity.x = 0.0;
velocity.z = 0.0;
}
if velocity.y.abs() < 0.003 {
velocity.y = 0.0;
}
self.player.velocity = 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;
}
if self.player.jumping {
if self.player.ground.on_ground && self.player.no_jump_delay == 0 {
self.jump_from_ground()?;
self.player.no_jump_delay = 10;
}
} else {
self.player.no_jump_delay = 0;
}
self.travel_in_air(input)?;
self.player.remove_frost()
}
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
.health
.food
.add_exhaustion(if self.player.sprinting { 0.2 } else { 0.05 });
Ok(())
}
pub fn move_self(&mut self, movement: Vec3) -> Result<()> {
entity_move::move_entity(self, MoverType::SelfMovement, movement)
}
}
// 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(false)
}
fn eyes_in_water(&mut self) -> Result<bool> {
Ok(false)
}
fn in_water(&mut self) -> Result<bool> {
Ok(false)
}
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(false)
}
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.health.food.add_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 EntityMoveWorld for MotionWorld<'_, '_, '_> {
type Error = Box<dyn std::error::Error>;
fn no_physics(&self) -> bool {
false
}
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;
}
fn limit_piston_movement(&mut self, _: Vec3) -> Result<Vec3> {
Err("piston movement requires a ticking entity runtime".into())
}
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, _: MoverType) -> Result<Vec3> {
Ok(movement)
}
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.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> {
// Every fluid in this controlled scene is empty. Tagged reset blocks use
// a full block in ClipContext.FALLDAMAGE_RESETTING, not their collider.
let hit = traverse_blocks(from, to, 1_000_000, |p| {
let name = &self.assets.registry.state(self.block(p)).unwrap().name;
(self.resources.fall_reset.contains(name)
&& VoxelShape::block().clip(from, to, p).is_some())
.then_some(())
})?;
Ok(hit.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(true)
}
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,
};
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<()> {
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> {
Ok(MovementEmission::All)
}
fn passenger(&mut self) -> Result<bool> {
Ok(false)
}
fn apply_movement_emission(
&mut self,
_: MovementEmission,
movement: Vec3,
position: BlockPos,
state: BlockStateId,
) -> Result<()> {
self.player.events.push(MotionEvent::Emission {
movement,
position,
state,
});
Ok(())
}
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))
}
}
impl RestitutionWorld for MotionWorld<'_, '_, '_> {
type Error = Box<dyn std::error::Error>;
fn suppressing_bounce(&mut self) -> Result<bool> {
Ok(false)
}
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> {
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(false)
}
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 {
false
}
fn can_walk_powder_snow(&mut self) -> Result<bool> {
Ok(false)
}
fn levitation_amplifier(&mut self) -> Result<Option<i32>> {
Ok(None)
}
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(false)
}
fn jump_boost_amplifier(&mut self) -> Result<i32> {
Err("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(false)
}
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")
}
}