Pumpkin/crates/pumpkin/src/command/args/position_block.rs
2026-08-26 19:21:27 +02:00

194 lines
5.8 KiB
Rust

use pumpkin_protocol::java::client::play::{ArgumentType, SuggestionProviders};
use pumpkin_util::math::position::BlockPos;
use pumpkin_util::math::vector3::Vector3;
use pumpkin_util::text::TextComponent;
use crate::command::CommandSender;
use crate::command::args::ConsumeResult;
use crate::command::dispatcher::CommandError;
use crate::command::tree::RawArgs;
use crate::server::Server;
use crate::world::World;
use super::super::args::ArgumentConsumer;
use super::coordinate::MaybeRelativeBlockCoordinate;
use super::{Arg, DefaultNameArgConsumer, FindArg, GetClientSideArgParser};
/// x, y and z coordinates
pub struct BlockPosArgumentConsumer;
impl GetClientSideArgParser for BlockPosArgumentConsumer {
fn get_client_side_parser(&self) -> ArgumentType {
ArgumentType::BlockPos
}
fn get_client_side_suggestion_type_override(&self) -> Option<SuggestionProviders> {
None
}
}
impl ArgumentConsumer for BlockPosArgumentConsumer {
fn consume<'a>(
&'a self,
sender: &'a CommandSender,
_server: &'a Server,
args: &mut RawArgs<'a>,
) -> ConsumeResult<'a> {
let x_str = args.pop()?.value;
let y_str = args.pop()?.value;
let z_str = args.pop()?.value;
MaybeRelativeBlockPos::try_new(x_str, y_str, z_str)
.and_then(|pos| pos.try_to_absolute(sender))
.map(Arg::BlockPos)
}
}
enum MaybeRelativeBlockPos {
World(
MaybeRelativeBlockCoordinate<false>,
MaybeRelativeBlockCoordinate<true>,
MaybeRelativeBlockCoordinate<false>,
),
Local(f64, f64, f64),
}
impl MaybeRelativeBlockPos {
fn try_new(x: &str, y: &str, z: &str) -> Option<Self> {
if x.starts_with('^') || y.starts_with('^') || z.starts_with('^') {
Some(Self::Local(
parse_local_coordinate(x)?,
parse_local_coordinate(y)?,
parse_local_coordinate(z)?,
))
} else {
Some(Self::World(
x.try_into().ok()?,
y.try_into().ok()?,
z.try_into().ok()?,
))
}
}
fn try_to_absolute(self, sender: &CommandSender) -> Option<BlockPos> {
match self {
Self::World(x, y, z) => {
let origin = sender.position();
Some(BlockPos(Vector3::new(
x.into_absolute(origin.map(|o| o.x))?,
y.into_absolute(origin.map(|o| o.y))?,
z.into_absolute(origin.map(|o| o.z))?,
)))
}
Self::Local(left, up, forwards) => {
let origin = sender.position()?;
let rotation = sender.rotation()?;
let offset = apply_local_coordinates(rotation, Vector3::new(left, up, forwards));
Some(BlockPos::floored_v(origin.add(&offset)))
}
}
}
}
fn parse_local_coordinate(s: &str) -> Option<f64> {
let value = s.strip_prefix('^')?;
if value.is_empty() {
Some(0.0)
} else {
value.parse().ok()
}
}
fn apply_local_coordinates(rotation: (f32, f32), direction: Vector3<f64>) -> Vector3<f64> {
let (yaw, pitch) = rotation;
let yaw = f64::from(yaw);
let pitch = f64::from(pitch);
let y_cos = (yaw + 90.0).to_radians().cos();
let y_sin = (yaw + 90.0).to_radians().sin();
let x_cos = (-pitch).to_radians().cos();
let x_sin = (-pitch).to_radians().sin();
let x_cos_up = (-pitch + 90.0).to_radians().cos();
let x_sin_up = (-pitch + 90.0).to_radians().sin();
let forwards = Vector3::new(y_cos * x_cos, x_sin, y_sin * x_cos);
let up = Vector3::new(y_cos * x_cos_up, x_sin_up, y_sin * x_cos_up);
let left = Vector3::new(
forwards.y * up.z - forwards.z * up.y,
forwards.z * up.x - forwards.x * up.z,
forwards.x * up.y - forwards.y * up.x,
) * -1.0;
Vector3::new(
forwards.x * direction.z + up.x * direction.y + left.x * direction.x,
forwards.y * direction.z + up.y * direction.y + left.y * direction.x,
forwards.z * direction.z + up.z * direction.y + left.z * direction.x,
)
}
impl DefaultNameArgConsumer for BlockPosArgumentConsumer {
fn default_name(&self) -> &'static str {
"block_pos"
}
}
impl<'a> FindArg<'a> for BlockPosArgumentConsumer {
type Data = BlockPos;
fn find_arg(args: &'a super::ConsumedArgs, name: &str) -> Result<Self::Data, CommandError> {
match args.get(name) {
Some(Arg::BlockPos(data)) => Ok(*data),
_ => Err(CommandError::InvalidConsumption(Some(name.to_string()))),
}
}
}
impl BlockPosArgumentConsumer {
pub fn find_loaded_arg(
args: &super::ConsumedArgs,
name: &str,
world: &World,
) -> Result<BlockPos, CommandError> {
let pos = Self::find_arg(args, name)?;
if world
.level
.read_chunk_sync(&pos.chunk_position(), |_| ())
.is_none()
{
return Err(CommandError::CommandFailed(TextComponent::translate_cross(
"argument.pos.unloaded",
"argument.pos.unloaded",
[],
)));
}
if !world.is_in_build_limit(pos) {
return Err(CommandError::CommandFailed(TextComponent::translate_cross(
"argument.pos.outofworld",
"argument.pos.outofworld",
[],
)));
}
Ok(pos)
}
pub fn find_spawnable_arg(
args: &super::ConsumedArgs,
name: &str,
) -> Result<BlockPos, CommandError> {
let pos = Self::find_arg(args, name)?;
if !World::is_valid(pos) {
return Err(CommandError::CommandFailed(TextComponent::translate_cross(
"argument.pos.outofbounds",
"argument.pos.outofbounds",
[],
)));
}
Ok(pos)
}
}