Files
horizon-airdef/crates/horizon-client/src/pose.rs
T
2026-10-26 22:46:36 +01:00

159 lines
5.3 KiB
Rust

//! Resident player pose, native dimension arithmetic and dry pose-fit selection.
//! Full synchronized entity schemas, sleeping and fluid/flight lifecycles remain
//! separate from these stored movement fields.
use crate::{
Result,
motion::{MotionWorld, PlayerMotion},
};
use horizon_core::geometry::{Aabb, Vec3};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Pose {
#[default]
Standing,
Crouching,
Swimming,
FallFlying,
SpinAttack,
Sleeping,
}
impl Pose {
/// `Pose` by its network id (`Pose.id`); the poses a player never takes
/// are standing.
pub fn from_id(id: i32) -> Self {
match id {
1 => Self::FallFlying,
2 => Self::Sleeping,
3 => Self::Swimming,
4 => Self::SpinAttack,
5 => Self::Crouching,
_ => Self::Standing,
}
}
pub fn name(self) -> &'static str {
match self {
Self::Standing => "STANDING",
Self::Crouching => "CROUCHING",
Self::Swimming => "SWIMMING",
Self::FallFlying => "FALL_FLYING",
Self::SpinAttack => "SPIN_ATTACK",
Self::Sleeping => "SLEEPING",
}
}
/// `Avatar.POSES` (and `LivingEntity.SLEEPING_DIMENSIONS`): the box of a
/// player or mannequin in this pose; sleeping ignores the scale.
pub fn dimensions(self, scale: f32) -> Dimensions {
let (width, height, eye_height) = match self {
Self::Standing => (0.6 * scale, 1.8 * scale, 1.62 * scale),
Self::Crouching => (0.6 * scale, 1.5 * scale, 1.27 * scale),
Self::Swimming | Self::FallFlying | Self::SpinAttack => {
(0.6 * scale, 0.6 * scale, 0.4 * scale)
}
Self::Sleeping => (0.2, 0.2, 0.2),
};
Dimensions {
width,
height,
eye_height,
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct Dimensions {
pub width: f32,
pub height: f32,
pub eye_height: f32,
}
impl Dimensions {
pub fn bounds(self, position: Vec3) -> Aabb {
let half = f64::from(self.width / 2.0);
Aabb::new(
Vec3::new(position.x - half, position.y, position.z - half),
Vec3::new(
position.x + half,
position.y + f64::from(self.height),
position.z + half,
),
)
}
}
impl PlayerMotion {
pub fn dimensions_for_pose(&mut self, pose: Pose) -> Result<Dimensions> {
Ok(pose.dimensions(self.attribute("minecraft:scale")? as f32))
}
pub fn refresh_dimensions(&mut self) -> Result<()> {
self.dimensions = self.dimensions_for_pose(self.pose)?;
Ok(())
}
pub fn set_pose(&mut self, pose: Pose) -> Result<()> {
if self.pose != pose {
self.pose = pose;
self.refresh_dimensions()?;
}
Ok(())
}
/// `LivingEntity.startSleeping` and `stopSleeping` set the pose at once
/// (the 0.2 box in the bed, standing again after).
pub fn set_sleeping(&mut self, sleeping: bool) -> Result<()> {
if self.sleeping != sleeping {
self.sleeping = sleeping;
self.set_pose(if sleeping {
Pose::Sleeping
} else {
Pose::Standing
})?;
}
Ok(())
}
pub fn moving_slowly(&self) -> bool {
self.local_crouching || (self.pose == Pose::Swimming && !self.fluids.was_touching_water)
}
}
impl MotionWorld<'_, '_, '_> {
pub fn can_fit_pose(&mut self, pose: Pose) -> Result<bool> {
let bounds = self
.player
.dimensions_for_pose(pose)?
.bounds(self.player.position);
self.no_player_collision(bounds.deflate(Vec3::new(1.0e-7, 1.0e-7, 1.0e-7)))
}
/// LocalPlayer.aiStep computes crouching BEFORE KeyboardInput.tick, using
/// the old shift input. This is distinct from Entity's current pose.
pub fn update_local_crouching(&mut self) -> Result<()> {
self.player.local_crouching = !self.player.flying
&& !self.player.swimming
&& self.can_fit_pose(Pose::Crouching)?
&& (self.player.shift_key_down || !self.can_fit_pose(Pose::Standing)?);
Ok(())
}
/// Dry Player.updatePlayerPose after movement: crawl when neither standing
/// nor crouching fits; leave the current pose if even crawling cannot fit.
pub fn update_player_pose(&mut self) -> Result<()> {
if !self.can_fit_pose(Pose::Swimming)? {
return Ok(());
}
// Player.getDesiredPose: sleeping, swimming, gliding, Riptide's spin.
let desired = if self.player.sleeping {
Pose::Sleeping
} else if self.player.swimming {
Pose::Swimming
} else if self.player.fall_flying {
Pose::FallFlying
} else if self.player.auto_spin_attack_ticks > 0 {
Pose::SpinAttack
} else if self.player.shift_key_down && !self.player.flying {
Pose::Crouching
} else {
Pose::Standing
};
let pose = if self.player.spectator || self.can_fit_pose(desired)? {
desired
} else if self.can_fit_pose(Pose::Crouching)? {
Pose::Crouching
} else {
Pose::Swimming
};
self.player.set_pose(pose)
}
}