valence/src/client.rs

1418 lines
52 KiB
Rust
Raw Normal View History

2022-07-15 16:18:20 +10:00
//! Connections to the server after logging in.
2022-07-03 04:22:28 +10:00
use std::collections::{HashSet, VecDeque};
2022-04-29 17:48:41 +10:00
use std::iter::FusedIterator;
2022-08-10 07:44:04 +10:00
use std::mem;
2022-06-30 14:33:42 +10:00
use std::time::Duration;
2022-04-15 07:55:45 +10:00
2022-08-06 05:36:34 +10:00
pub use bitfield_struct::bitfield;
2022-06-25 09:11:15 +10:00
pub use event::*;
2022-04-15 07:55:45 +10:00
use flume::{Receiver, Sender, TrySendError};
2022-04-29 17:48:41 +10:00
use rayon::iter::ParallelIterator;
use uuid::Uuid;
use vek::Vec3;
2022-04-15 07:55:45 +10:00
2022-07-11 22:08:02 +10:00
use crate::biome::Biome;
use crate::block_pos::BlockPos;
use crate::chunk_pos::ChunkPos;
2022-07-16 13:40:39 +10:00
use crate::config::Config;
2022-07-11 22:08:02 +10:00
use crate::dimension::DimensionId;
2022-08-06 05:36:34 +10:00
use crate::entity::data::Player;
2022-07-28 00:10:35 +10:00
use crate::entity::{
2022-08-06 05:36:34 +10:00
velocity_to_packet_units, Entities, EntityEvent, EntityId, EntityKind, StatusOrAnimation,
2022-07-28 00:10:35 +10:00
};
2022-08-10 07:44:04 +10:00
use crate::player_list::{PlayerListId, PlayerLists};
use crate::player_textures::SignedPlayerTextures;
2022-07-29 22:34:29 +10:00
use crate::protocol_inner::packets::c2s::play::{
C2sPlayPacket, DiggingStatus, InteractKind, PlayerCommandId,
2022-07-05 08:51:28 +10:00
};
2022-08-31 11:41:17 +10:00
pub use crate::protocol_inner::packets::s2c::play::TitleFade;
2022-07-29 22:34:29 +10:00
use crate::protocol_inner::packets::s2c::play::{
2022-08-31 11:41:17 +10:00
BiomeRegistry, ChatTypeRegistry, ChunkLoadDistance, ChunkRenderDistanceCenter, ClearTitles,
2022-07-29 22:34:29 +10:00
DimensionTypeRegistry, DimensionTypeRegistryEntry, Disconnect, EntitiesDestroy,
EntityAnimation, EntityAttributes, EntityAttributesProperty, EntityPosition, EntitySetHeadYaw,
EntityStatus, EntityTrackerUpdate, EntityVelocityUpdate, GameJoin, GameMessage,
GameStateChange, GameStateChangeReason, KeepAlive, MoveRelative, PlayerActionResponse,
PlayerPositionLook, PlayerPositionLookFlags, PlayerRespawn, PlayerSpawnPosition, RegistryCodec,
Rotate, RotateAndMoveRelative, S2cPlayPacket, UnloadChunk, UpdateSubtitle, UpdateTitle,
2022-04-15 07:55:45 +10:00
};
2022-08-30 12:28:19 +10:00
use crate::protocol_inner::{BoundedInt, ByteAngle, NbtBridge, RawBytes, VarInt};
2022-08-06 16:10:25 +10:00
use crate::server::{C2sPacketChannels, NewClientData, S2cPlayMessage, SharedServer};
use crate::slab_versioned::{Key, VersionedSlab};
use crate::text::Text;
2022-04-15 07:55:45 +10:00
use crate::util::{chunks_in_view_distance, is_chunk_in_view_distance};
use crate::world::{WorldId, Worlds};
2022-08-06 05:36:34 +10:00
use crate::{ident, LIBRARY_NAMESPACE};
2022-04-15 07:55:45 +10:00
2022-08-06 05:36:34 +10:00
/// Contains the [`ClientEvent`] enum and related data types.
2022-07-28 00:10:35 +10:00
mod event;
2022-07-11 22:08:02 +10:00
/// A container for all [`Client`]s on a [`Server`](crate::server::Server).
///
/// New clients are automatically inserted into this container but
/// are not automatically deleted. It is your responsibility to delete them once
/// they disconnect. This can be checked with [`Client::is_disconnected`].
2022-07-16 13:40:39 +10:00
pub struct Clients<C: Config> {
slab: VersionedSlab<Client<C>>,
2022-04-29 17:48:41 +10:00
}
2022-04-15 07:55:45 +10:00
2022-07-16 13:40:39 +10:00
impl<C: Config> Clients<C> {
2022-04-29 17:48:41 +10:00
pub(crate) fn new() -> Self {
Self {
slab: VersionedSlab::new(),
}
2022-04-15 07:55:45 +10:00
}
2022-07-16 13:40:39 +10:00
pub(crate) fn insert(&mut self, client: Client<C>) -> (ClientId, &mut Client<C>) {
let (k, client) = self.slab.insert(client);
2022-08-06 05:36:34 +10:00
(ClientId(k), client)
2022-04-15 07:55:45 +10:00
}
2022-07-11 22:08:02 +10:00
/// Removes a client from the server.
///
/// If the given client ID is valid, `true` is returned and the client is
/// deleted. Otherwise, `false` is returned and the function has no effect.
pub fn remove(&mut self, client: ClientId) -> Option<C::ClientState> {
self.slab.remove(client.0).map(|c| c.state)
2022-04-29 17:48:41 +10:00
}
2022-08-06 05:36:34 +10:00
/// Deletes all clients from the server for
2022-07-11 22:08:02 +10:00
/// which `f` returns `true`.
///
/// All clients are visited in an unspecified order.
2022-07-16 13:40:39 +10:00
pub fn retain(&mut self, mut f: impl FnMut(ClientId, &mut Client<C>) -> bool) {
self.slab.retain(|k, v| f(ClientId(k), v))
2022-04-29 17:48:41 +10:00
}
2022-07-11 22:08:02 +10:00
/// Returns the number of clients on the server. This includes clients
/// which may be disconnected.
pub fn len(&self) -> usize {
self.slab.len()
2022-04-29 17:48:41 +10:00
}
2022-07-11 22:08:02 +10:00
/// Returns a shared reference to the client with the given ID. If
/// the ID is invalid, then `None` is returned.
2022-07-16 13:40:39 +10:00
pub fn get(&self, client: ClientId) -> Option<&Client<C>> {
self.slab.get(client.0)
2022-04-29 17:48:41 +10:00
}
2022-07-11 22:08:02 +10:00
/// Returns an exclusive reference to the client with the given ID. If the
/// ID is invalid, then `None` is returned.
2022-07-16 13:40:39 +10:00
pub fn get_mut(&mut self, client: ClientId) -> Option<&mut Client<C>> {
self.slab.get_mut(client.0)
2022-04-29 17:48:41 +10:00
}
2022-07-11 22:08:02 +10:00
/// Returns an immutable iterator over all clients on the server in an
/// unspecified order.
pub fn iter(
&self,
) -> impl ExactSizeIterator<Item = (ClientId, &Client<C>)> + FusedIterator + Clone + '_ {
self.slab.iter().map(|(k, v)| (ClientId(k), v))
2022-04-29 17:48:41 +10:00
}
2022-07-11 22:08:02 +10:00
/// Returns a mutable iterator over all clients on the server in an
/// unspecified order.
pub fn iter_mut(
&mut self,
) -> impl ExactSizeIterator<Item = (ClientId, &mut Client<C>)> + FusedIterator + '_ {
self.slab.iter_mut().map(|(k, v)| (ClientId(k), v))
}
2022-07-11 22:08:02 +10:00
/// Returns a parallel immutable iterator over all clients on the server in
/// an unspecified order.
2022-07-16 13:40:39 +10:00
pub fn par_iter(&self) -> impl ParallelIterator<Item = (ClientId, &Client<C>)> + Clone + '_ {
self.slab.par_iter().map(|(k, v)| (ClientId(k), v))
2022-04-15 07:55:45 +10:00
}
2022-07-11 22:08:02 +10:00
/// Returns a parallel mutable iterator over all clients on the server in an
/// unspecified order.
2022-07-16 13:40:39 +10:00
pub fn par_iter_mut(
&mut self,
) -> impl ParallelIterator<Item = (ClientId, &mut Client<C>)> + '_ {
self.slab.par_iter_mut().map(|(k, v)| (ClientId(k), v))
}
}
2022-07-15 16:18:20 +10:00
/// An identifier for a [`Client`] on the server.
2022-07-11 22:08:02 +10:00
///
/// Client IDs are either _valid_ or _invalid_. Valid client IDs point to
/// clients that have not been deleted, while invalid IDs point to those that
/// have. Once an ID becomes invalid, it will never become valid again.
///
/// The [`Ord`] instance on this type is correct but otherwise unspecified. This
/// is useful for storing IDs in containers such as
/// [`BTreeMap`](std::collections::BTreeMap).
2022-07-04 11:02:00 +10:00
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, Debug)]
2022-04-29 17:48:41 +10:00
pub struct ClientId(Key);
2022-07-04 11:02:00 +10:00
impl ClientId {
2022-07-11 22:08:02 +10:00
/// The value of the default client ID which is always invalid.
2022-07-04 11:02:00 +10:00
pub const NULL: Self = Self(Key::NULL);
}
2022-07-11 22:08:02 +10:00
/// Represents a remote connection to a client after successfully logging in.
///
2022-08-06 05:36:34 +10:00
/// Much like an [`Entity`], clients possess a location, rotation, and UUID.
2022-07-15 16:18:20 +10:00
/// However, clients are handled separately from entities and are partially
/// managed by the library.
2022-07-11 22:08:02 +10:00
///
/// By default, clients have no influence over the worlds they reside in. They
/// cannot break blocks, hurt entities, or see other clients. Interactions with
/// the server must be handled explicitly with [`Self::pop_event`].
///
2022-08-06 05:36:34 +10:00
/// Additionally, clients possess [`Player`] entity data which is only visible
/// to themselves. This can be accessed with [`Self::player`] and
2022-07-11 22:08:02 +10:00
/// [`Self::player_mut`].
///
/// # The Difference Between a "Client" and a "Player"
///
/// Normally in Minecraft, players and clients are one and the same. Players are
2022-08-06 05:36:34 +10:00
/// simply a subtype of the entity base class backed by a remote connection.
2022-07-11 22:08:02 +10:00
///
2022-08-06 05:36:34 +10:00
/// In Valence however, clients and players are decoupled. This separation
/// allows for greater flexibility and parallelism.
2022-07-16 13:40:39 +10:00
pub struct Client<C: Config> {
2022-07-28 12:21:11 +10:00
/// Custom state.
pub state: C::ClientState,
2022-04-15 07:55:45 +10:00
/// Setting this to `None` disconnects the client.
2022-07-06 11:08:40 +10:00
send: SendOpt,
2022-06-10 13:26:21 +10:00
recv: Receiver<C2sPlayPacket>,
uuid: Uuid,
username: String,
textures: Option<SignedPlayerTextures>,
2022-07-04 11:45:11 +10:00
world: WorldId,
2022-08-10 07:44:04 +10:00
old_player_list: Option<PlayerListId>,
new_player_list: Option<PlayerListId>,
2022-08-06 05:36:34 +10:00
position: Vec3<f64>,
old_position: Vec3<f64>,
2022-07-18 14:29:44 +10:00
/// Measured in m/s.
velocity: Vec3<f32>,
2022-04-15 07:55:45 +10:00
/// Measured in degrees
yaw: f32,
/// Measured in degrees
pitch: f32,
2022-08-06 05:36:34 +10:00
view_distance: u8,
2022-04-15 07:55:45 +10:00
/// Counts up as teleports are made.
teleport_id_counter: u32,
/// The number of pending client teleports that have yet to receive a
/// confirmation. Inbound client position packets are ignored while this
/// is nonzero.
pending_teleports: u32,
spawn_position: BlockPos,
spawn_position_yaw: f32,
death_location: Option<(DimensionId, BlockPos)>,
2022-08-06 05:36:34 +10:00
events: VecDeque<ClientEvent>,
2022-04-15 07:55:45 +10:00
/// The ID of the last keepalive sent.
last_keepalive_id: i64,
/// Entities that were visible to this client at the end of the last tick.
/// This is used to determine what entity create/destroy packets should be
/// sent.
loaded_entities: HashSet<EntityId>,
loaded_chunks: HashSet<ChunkPos>,
2022-04-15 07:55:45 +10:00
new_game_mode: GameMode,
2022-04-29 17:48:41 +10:00
old_game_mode: GameMode,
2022-04-15 07:55:45 +10:00
settings: Option<Settings>,
2022-06-25 09:11:15 +10:00
dug_blocks: Vec<i32>,
2022-07-13 13:47:53 +10:00
/// Should be sent after login packet.
2022-07-02 12:18:59 +10:00
msgs_to_send: Vec<Text>,
2022-07-13 13:47:53 +10:00
attack_speed: f64,
movement_speed: f64,
2022-08-06 05:36:34 +10:00
bits: ClientBits,
2022-07-06 11:08:40 +10:00
/// The data for the client's own player entity.
player_data: Player,
2022-07-28 00:10:35 +10:00
entity_events: Vec<EntityEvent>,
2022-04-15 07:55:45 +10:00
}
2022-07-06 18:12:05 +10:00
#[bitfield(u16)]
2022-08-06 05:36:34 +10:00
struct ClientBits {
2022-07-05 08:51:28 +10:00
spawn: bool,
flat: bool,
2022-07-05 08:51:28 +10:00
teleported_this_tick: bool,
/// If spawn_position or spawn_position_yaw were modified this tick.
modified_spawn_position: bool,
/// If the last sent keepalive got a response.
got_keepalive: bool,
2022-07-06 18:12:05 +10:00
hardcore: bool,
2022-07-13 13:47:53 +10:00
attack_speed_modified: bool,
movement_speed_modified: bool,
2022-07-18 14:29:44 +10:00
velocity_modified: bool,
2022-08-06 05:36:34 +10:00
created_this_tick: bool,
view_distance_modified: bool,
#[bits(5)]
_pad: u8,
2022-07-05 08:51:28 +10:00
}
2022-07-16 13:40:39 +10:00
impl<C: Config> Client<C> {
2022-04-15 07:55:45 +10:00
pub(crate) fn new(
2022-06-10 13:26:21 +10:00
packet_channels: C2sPacketChannels,
ncd: NewClientData,
2022-08-06 05:36:34 +10:00
state: C::ClientState,
2022-04-15 07:55:45 +10:00
) -> Self {
let (send, recv) = packet_channels;
Self {
2022-08-06 05:36:34 +10:00
state,
2022-04-15 07:55:45 +10:00
send: Some(send),
recv,
uuid: ncd.uuid,
username: ncd.username,
textures: ncd.textures,
2022-07-04 11:45:11 +10:00
world: WorldId::default(),
2022-08-10 07:44:04 +10:00
old_player_list: None,
new_player_list: None,
2022-08-06 05:36:34 +10:00
position: Vec3::default(),
old_position: Vec3::default(),
2022-07-18 14:29:44 +10:00
velocity: Vec3::default(),
2022-04-15 07:55:45 +10:00
yaw: 0.0,
pitch: 0.0,
view_distance: 2,
2022-04-15 07:55:45 +10:00
teleport_id_counter: 0,
pending_teleports: 0,
spawn_position: BlockPos::default(),
spawn_position_yaw: 0.0,
death_location: None,
2022-07-03 04:22:28 +10:00
events: VecDeque::new(),
2022-04-15 07:55:45 +10:00
last_keepalive_id: 0,
loaded_entities: HashSet::new(),
loaded_chunks: HashSet::new(),
2022-04-15 07:55:45 +10:00
new_game_mode: GameMode::Survival,
2022-04-29 17:48:41 +10:00
old_game_mode: GameMode::Survival,
2022-04-15 07:55:45 +10:00
settings: None,
2022-06-25 09:11:15 +10:00
dug_blocks: Vec::new(),
2022-06-30 14:33:42 +10:00
msgs_to_send: Vec::new(),
2022-07-13 13:47:53 +10:00
attack_speed: 4.0,
movement_speed: 0.7,
2022-08-06 05:36:34 +10:00
bits: ClientBits::new()
2022-07-05 08:51:28 +10:00
.with_modified_spawn_position(true)
2022-08-06 05:36:34 +10:00
.with_got_keepalive(true)
.with_created_this_tick(true),
2022-07-06 11:08:40 +10:00
player_data: Player::new(),
2022-07-28 00:10:35 +10:00
entity_events: Vec::new(),
2022-04-15 07:55:45 +10:00
}
}
2022-08-06 05:36:34 +10:00
/// If the client joined the game this tick.
pub fn created_this_tick(&self) -> bool {
self.bits.created_this_tick()
2022-04-15 07:55:45 +10:00
}
2022-07-11 22:08:02 +10:00
/// Gets the client's UUID.
pub fn uuid(&self) -> Uuid {
self.uuid
}
2022-07-11 22:08:02 +10:00
/// Gets the username of this client, which is always valid.
2022-04-15 07:55:45 +10:00
pub fn username(&self) -> &str {
&self.username
}
2022-07-11 22:08:02 +10:00
/// Gets the player textures of this client. If the client does not have
/// a skin, then `None` is returned.
pub fn textures(&self) -> Option<&SignedPlayerTextures> {
self.textures.as_ref()
}
2022-07-11 22:08:02 +10:00
/// Gets the world this client is located in.
2022-07-04 11:02:00 +10:00
pub fn world(&self) -> WorldId {
2022-07-04 11:45:11 +10:00
self.world
}
2022-08-10 07:44:04 +10:00
pub fn player_list(&self) -> Option<&PlayerListId> {
self.new_player_list.as_ref()
}
pub fn set_player_list(&mut self, id: Option<PlayerListId>) -> Option<PlayerListId> {
mem::replace(&mut self.new_player_list, id)
}
/// Sets if this client sees the world as superflat. Superflat worlds have
/// a horizon line lower than normal worlds.
///
/// The player must be spawned for changes to take effect.
pub fn set_flat(&mut self, flat: bool) {
self.bits.set_flat(flat);
}
/// Gets if this client sees the world as superflat. Superflat worlds have
/// a horizon line lower than normal worlds.
pub fn is_flat(&self) -> bool {
self.bits.flat()
}
2022-08-06 05:36:34 +10:00
/// Changes the world this client is located in and respawns the client.
/// This can be used to respawn the client after death.
2022-07-11 22:08:02 +10:00
///
/// The given [`WorldId`] must be valid. Otherwise, the client is
/// disconnected.
2022-07-04 11:45:11 +10:00
pub fn spawn(&mut self, world: WorldId) {
self.world = world;
2022-08-06 05:36:34 +10:00
self.bits.set_spawn(true);
}
2022-07-11 22:08:02 +10:00
/// Sends a system message to the player which is visible in the chat.
2022-07-02 12:18:59 +10:00
pub fn send_message(&mut self, msg: impl Into<Text>) {
// We buffer messages because weird things happen if we send them before the
// login packet.
2022-07-02 12:18:59 +10:00
self.msgs_to_send.push(msg.into());
2022-06-30 14:33:42 +10:00
}
2022-07-11 22:08:02 +10:00
/// Gets the absolute position of this client in the world it is located
/// in.
pub fn position(&self) -> Vec3<f64> {
2022-08-06 05:36:34 +10:00
self.position
2022-04-15 07:55:45 +10:00
}
2022-07-11 22:08:02 +10:00
/// Changes the position and rotation of this client in the world it is
/// located in.
///
/// If you want to change the client's world, use [`Self::spawn`].
pub fn teleport(&mut self, pos: impl Into<Vec3<f64>>, yaw: f32, pitch: f32) {
2022-08-06 05:36:34 +10:00
self.position = pos.into();
self.yaw = yaw;
self.pitch = pitch;
2022-08-06 05:36:34 +10:00
self.bits.set_teleported_this_tick(true);
}
2022-08-06 05:36:34 +10:00
/// Gets the most recently set velocity of this client in m/s.
2022-07-18 14:29:44 +10:00
pub fn velocity(&self) -> Vec3<f32> {
self.velocity
}
/// Sets the client's velocity in m/s.
2022-07-15 21:21:32 +10:00
pub fn set_velocity(&mut self, velocity: impl Into<Vec3<f32>>) {
2022-07-18 14:29:44 +10:00
self.velocity = velocity.into();
2022-08-06 05:36:34 +10:00
self.bits.set_velocity_modified(true);
2022-07-15 21:21:32 +10:00
}
2022-07-11 22:08:02 +10:00
/// Gets this client's yaw.
2022-04-15 07:55:45 +10:00
pub fn yaw(&self) -> f32 {
self.yaw
}
2022-07-11 22:08:02 +10:00
/// Gets this client's pitch.
2022-04-15 07:55:45 +10:00
pub fn pitch(&self) -> f32 {
self.pitch
}
2022-07-11 22:08:02 +10:00
/// Gets the spawn position. The client will see `minecraft:compass` items
/// point at the returned position.
pub fn spawn_position(&self) -> BlockPos {
self.spawn_position
}
2022-07-11 22:08:02 +10:00
/// Sets the spawn position. The client will see `minecraft:compass` items
/// point at the provided position.
pub fn set_spawn_position(&mut self, pos: impl Into<BlockPos>, yaw_degrees: f32) {
let pos = pos.into();
if pos != self.spawn_position || yaw_degrees != self.spawn_position_yaw {
self.spawn_position = pos;
self.spawn_position_yaw = yaw_degrees;
2022-08-06 05:36:34 +10:00
self.bits.set_modified_spawn_position(true);
}
}
2022-07-11 22:08:02 +10:00
/// Gets the last death location of this client. The client will see
/// `minecraft:recovery_compass` items point at the returned position.
2022-08-06 05:36:34 +10:00
///
2022-07-11 22:08:02 +10:00
/// If the client's current dimension differs from the returned
/// dimension or the location is `None` then the compass will spin
/// randomly.
pub fn death_location(&self) -> Option<(DimensionId, BlockPos)> {
self.death_location
}
2022-07-11 22:08:02 +10:00
/// Sets the last death location. The client will see
/// `minecraft:recovery_compass` items point at the provided position.
/// If the client's current dimension differs from the provided
/// dimension or the location is `None` then the compass will spin
/// randomly.
///
/// Changes to the last death location take effect when the client
/// (re)spawns.
pub fn set_death_location(&mut self, location: Option<(DimensionId, BlockPos)>) {
self.death_location = location;
}
2022-07-11 22:08:02 +10:00
/// Gets the client's game mode.
pub fn game_mode(&self) -> GameMode {
self.new_game_mode
}
2022-07-11 22:08:02 +10:00
/// Sets the client's game mode.
pub fn set_game_mode(&mut self, game_mode: GameMode) {
self.new_game_mode = game_mode;
}
2022-07-11 22:08:02 +10:00
/// Sets the title this client sees.
///
/// A title is a large piece of text displayed in the center of the screen
/// which may also include a subtitle underneath it. The title
/// can be configured to fade in and out using the
2022-08-31 11:41:17 +10:00
/// [`TitleFade`] struct.
2022-07-06 17:16:07 +10:00
pub fn set_title(
&mut self,
title: impl Into<Text>,
subtitle: impl Into<Text>,
2022-08-31 11:41:17 +10:00
animation: impl Into<Option<TitleFade>>,
2022-07-06 17:16:07 +10:00
) {
let title = title.into();
let subtitle = subtitle.into();
self.send_packet(UpdateTitle { text: title });
2022-07-06 17:16:07 +10:00
if !subtitle.is_empty() {
self.send_packet(UpdateSubtitle {
2022-07-06 17:16:07 +10:00
subtitle_text: subtitle,
});
}
if let Some(anim) = animation.into() {
self.send_packet(anim);
}
}
2022-07-13 13:47:53 +10:00
/// Gets the attack cooldown speed.
pub fn attack_speed(&self) -> f64 {
self.attack_speed
}
/// Sets the attack cooldown speed.
pub fn set_attack_speed(&mut self, speed: f64) {
if self.attack_speed != speed {
self.attack_speed = speed;
2022-08-06 05:36:34 +10:00
self.bits.set_attack_speed_modified(true);
2022-07-13 13:47:53 +10:00
}
}
/// Gets the speed at which the client can run on the ground.
pub fn movement_speed(&self) -> f64 {
self.movement_speed
}
/// Sets the speed at which the client can run on the ground.
pub fn set_movement_speed(&mut self, speed: f64) {
if self.movement_speed != speed {
self.movement_speed = speed;
2022-08-06 05:36:34 +10:00
self.bits.set_movement_speed_modified(true);
2022-07-13 13:47:53 +10:00
}
}
2022-07-11 22:08:02 +10:00
/// Removes the current title from the client's screen.
2022-07-06 17:16:07 +10:00
pub fn clear_title(&mut self) {
self.send_packet(ClearTitles { reset: true });
}
2022-07-11 22:08:02 +10:00
/// Gets whether or not the client is connected to the server.
///
/// A disconnected client object will never become reconnected. It is your
/// responsibility to remove disconnected clients from the [`Clients`]
/// container.
pub fn is_disconnected(&self) -> bool {
self.send.is_none()
}
2022-08-06 05:36:34 +10:00
pub fn events(
&self,
) -> impl DoubleEndedIterator<Item = &ClientEvent> + ExactSizeIterator + FusedIterator + Clone + '_
{
self.events.iter()
}
2022-07-15 16:18:20 +10:00
/// Removes an [`Event`] from the event queue.
///
/// If there are no remaining events, `None` is returned.
2022-07-11 22:08:02 +10:00
///
2022-07-15 16:18:20 +10:00
/// Any remaining client events are deleted at the end of the
2022-07-11 22:08:02 +10:00
/// current tick.
2022-08-06 05:36:34 +10:00
pub fn pop_event(&mut self) -> Option<ClientEvent> {
2022-07-03 04:22:28 +10:00
self.events.pop_front()
}
2022-08-06 05:36:34 +10:00
pub fn push_entity_event(&mut self, event: EntityEvent) {
2022-07-28 00:10:35 +10:00
self.entity_events.push(event);
}
2022-08-06 05:36:34 +10:00
/// The current view distance of this client measured in chunks. The client
/// will not be able to see chunks and entities past this distance.
2022-07-11 22:08:02 +10:00
///
2022-08-06 05:36:34 +10:00
/// The result is in `2..=32`.
pub fn view_distance(&self) -> u8 {
self.view_distance
}
2022-08-06 05:36:34 +10:00
/// Sets the view distance. The client will not be able to see chunks and
/// entities past this distance.
2022-07-11 22:08:02 +10:00
///
/// The new view distance is measured in chunks and is clamped to `2..=32`.
2022-08-06 05:36:34 +10:00
pub fn set_view_distance(&mut self, dist: u8) {
let dist = dist.clamp(2, 32);
if self.view_distance != dist {
self.view_distance = dist;
self.bits.set_view_distance_modified(true);
}
}
2022-07-11 22:08:02 +10:00
/// Enables hardcore mode. This changes the design of the client's hearts.
///
/// To have any visible effect, this function must be called on the same
/// tick the client joins the server.
2022-07-06 18:12:05 +10:00
pub fn set_hardcore(&mut self, hardcore: bool) {
2022-08-06 05:36:34 +10:00
self.bits.set_hardcore(hardcore);
2022-07-06 18:12:05 +10:00
}
2022-07-11 22:08:02 +10:00
/// Gets if hardcore mode is enabled.
pub fn is_hardcore(&self) -> bool {
2022-08-06 05:36:34 +10:00
self.bits.hardcore()
2022-07-06 18:12:05 +10:00
}
2022-07-11 22:08:02 +10:00
/// Gets the client's current settings.
pub fn settings(&self) -> Option<&Settings> {
self.settings.as_ref()
2022-04-15 07:55:45 +10:00
}
2022-07-11 22:08:02 +10:00
/// Disconnects this client from the server with the provided reason. This
/// has no effect if the client is already disconnected.
///
/// All future calls to [`Self::is_disconnected`] will return `true`.
2022-04-15 07:55:45 +10:00
pub fn disconnect(&mut self, reason: impl Into<Text>) {
if self.send.is_some() {
2022-04-15 07:55:45 +10:00
let txt = reason.into();
log::info!("disconnecting client '{}': \"{txt}\"", self.username);
2022-04-15 07:55:45 +10:00
self.send_packet(Disconnect { reason: txt });
self.send = None;
2022-04-15 07:55:45 +10:00
}
}
2022-07-11 22:08:02 +10:00
/// Like [`Self::disconnect`], but no reason for the disconnect is
/// displayed.
2022-04-15 07:55:45 +10:00
pub fn disconnect_no_reason(&mut self) {
if self.send.is_some() {
log::info!("disconnecting client '{}'", self.username);
self.send = None;
2022-04-15 07:55:45 +10:00
}
}
2022-07-11 22:08:02 +10:00
/// Returns an immutable reference to the client's own [`Player`] data.
pub fn player(&self) -> &Player {
2022-07-06 11:08:40 +10:00
&self.player_data
2022-06-30 06:00:41 +10:00
}
2022-07-11 22:08:02 +10:00
/// Returns a mutable reference to the client's own [`Player`] data.
///
/// Changes made to this data is only visible to this client.
pub fn player_mut(&mut self) -> &mut Player {
2022-07-06 11:08:40 +10:00
&mut self.player_data
2022-06-30 06:00:41 +10:00
}
/// Attempts to enqueue a play packet to be sent to this client. The client
/// is disconnected if the clientbound packet buffer is full.
#[cfg(feature = "protocol")]
pub fn send_packet(&mut self, packet: impl Into<S2cPlayPacket>) {
send_packet(&mut self.send, packet);
}
#[cfg(not(feature = "protocol"))]
pub(crate) fn send_packet(&mut self, packet: impl Into<S2cPlayPacket>) {
send_packet(&mut self.send, packet);
2022-04-29 17:48:41 +10:00
}
2022-07-16 13:40:39 +10:00
pub(crate) fn handle_serverbound_packets(&mut self, entities: &Entities<C>) {
self.events.clear();
2022-06-25 09:11:15 +10:00
for _ in 0..self.recv.len() {
self.handle_serverbound_packet(entities, self.recv.try_recv().unwrap());
}
}
2022-07-16 13:40:39 +10:00
fn handle_serverbound_packet(&mut self, entities: &Entities<C>, pkt: C2sPlayPacket) {
2022-06-25 09:11:15 +10:00
match pkt {
C2sPlayPacket::TeleportConfirm(p) => {
if self.pending_teleports == 0 {
2022-07-03 06:41:45 +10:00
log::warn!("unexpected teleport confirmation from {}", self.username());
self.disconnect_no_reason();
2022-06-25 09:11:15 +10:00
return;
}
let got = p.teleport_id.0 as u32;
let expected = self
2022-06-25 09:11:15 +10:00
.teleport_id_counter
.wrapping_sub(self.pending_teleports);
2022-06-25 09:11:15 +10:00
if got == expected {
self.pending_teleports -= 1;
2022-06-25 09:11:15 +10:00
} else {
2022-07-03 06:41:45 +10:00
log::warn!(
"unexpected teleport ID from {} (expected {expected}, got {got})",
self.username()
);
self.disconnect_no_reason();
2022-06-25 09:11:15 +10:00
}
}
C2sPlayPacket::QueryBlockNbt(_) => {}
C2sPlayPacket::UpdateDifficulty(_) => {}
2022-08-31 11:41:17 +10:00
C2sPlayPacket::MessageAcknowledgment(_) => {}
C2sPlayPacket::CommandExecution(_) => {}
2022-08-06 05:36:34 +10:00
C2sPlayPacket::ChatMessage(p) => self.events.push_back(ClientEvent::ChatMessage {
2022-06-30 14:33:42 +10:00
message: p.message.0,
timestamp: Duration::from_millis(p.timestamp),
}),
C2sPlayPacket::RequestChatPreview(_) => {}
C2sPlayPacket::ClientStatus(_) => {}
C2sPlayPacket::ClientSettings(p) => {
2022-08-06 05:36:34 +10:00
self.events.push_back(ClientEvent::SettingsChanged {
2022-06-25 09:11:15 +10:00
locale: p.locale.0,
view_distance: p.view_distance.0,
chat_mode: p.chat_mode,
chat_colors: p.chat_colors,
main_hand: p.main_hand,
displayed_skin_parts: p.displayed_skin_parts,
allow_server_listings: p.allow_server_listings,
2022-08-06 05:36:34 +10:00
})
2022-06-25 09:11:15 +10:00
}
C2sPlayPacket::RequestCommandCompletion(_) => {}
C2sPlayPacket::ButtonClick(_) => {}
C2sPlayPacket::ClickSlot(_) => {}
C2sPlayPacket::CloseHandledScreen(_) => {}
2022-07-01 07:18:29 +10:00
C2sPlayPacket::CustomPayload(_) => {}
C2sPlayPacket::BookUpdate(_) => {}
C2sPlayPacket::QueryEntityNbt(_) => {}
C2sPlayPacket::PlayerInteractEntity(p) => {
2022-06-25 09:11:15 +10:00
if let Some(id) = entities.get_with_network_id(p.entity_id.0) {
// TODO: verify that the client has line of sight to the targeted entity and
// that the distance is <=4 blocks.
2022-08-06 05:36:34 +10:00
self.events.push_back(ClientEvent::InteractWithEntity {
2022-06-25 09:11:15 +10:00
id,
sneaking: p.sneaking,
kind: match p.kind {
2022-07-11 22:08:02 +10:00
InteractKind::Interact(hand) => InteractWithEntityKind::Interact(hand),
InteractKind::Attack => InteractWithEntityKind::Attack,
InteractKind::InteractAt((target, hand)) => {
2022-07-11 22:08:02 +10:00
InteractWithEntityKind::InteractAt { target, hand }
2022-06-25 09:11:15 +10:00
}
},
});
}
}
2022-07-01 07:18:29 +10:00
C2sPlayPacket::JigsawGenerate(_) => {}
2022-06-25 09:11:15 +10:00
C2sPlayPacket::KeepAlive(p) => {
let last_keepalive_id = self.last_keepalive_id;
2022-08-06 05:36:34 +10:00
if self.bits.got_keepalive() {
log::warn!("unexpected keepalive from player {}", self.username());
self.disconnect_no_reason();
2022-06-25 09:11:15 +10:00
} else if p.id != last_keepalive_id {
log::warn!(
"keepalive ids for player {} don't match (expected {}, got {})",
self.username(),
last_keepalive_id,
p.id
);
self.disconnect_no_reason();
2022-06-25 09:11:15 +10:00
} else {
2022-08-06 05:36:34 +10:00
self.bits.set_got_keepalive(true);
2022-06-25 09:11:15 +10:00
}
}
C2sPlayPacket::UpdateDifficultyLock(_) => {}
2022-07-01 07:18:29 +10:00
C2sPlayPacket::MovePlayerPosition(p) => {
2022-08-06 05:36:34 +10:00
if self.pending_teleports == 0 {
self.position = p.position;
self.events.push_back(ClientEvent::MovePosition {
position: p.position,
on_ground: p.on_ground,
});
}
}
2022-07-01 07:18:29 +10:00
C2sPlayPacket::MovePlayerPositionAndRotation(p) => {
2022-08-06 05:36:34 +10:00
if self.pending_teleports == 0 {
self.position = p.position;
self.yaw = p.yaw;
self.pitch = p.pitch;
self.events.push_back(ClientEvent::MovePositionAndRotation {
position: p.position,
yaw: p.yaw,
pitch: p.pitch,
on_ground: p.on_ground,
});
}
}
2022-07-01 07:18:29 +10:00
C2sPlayPacket::MovePlayerRotation(p) => {
2022-08-06 05:36:34 +10:00
if self.pending_teleports == 0 {
self.yaw = p.yaw;
self.pitch = p.pitch;
self.events.push_back(ClientEvent::MoveRotation {
yaw: p.yaw,
pitch: p.pitch,
on_ground: p.on_ground,
});
}
}
C2sPlayPacket::MovePlayerOnGround(p) => {
if self.pending_teleports == 0 {
self.events.push_back(ClientEvent::MoveOnGround {
on_ground: p.on_ground,
});
}
2022-06-25 09:11:15 +10:00
}
2022-07-01 07:18:29 +10:00
C2sPlayPacket::MoveVehicle(p) => {
2022-08-06 05:36:34 +10:00
if self.pending_teleports == 0 {
self.position = p.position;
self.yaw = p.yaw;
self.pitch = p.pitch;
self.events.push_back(ClientEvent::MoveVehicle {
position: p.position,
yaw: p.yaw,
pitch: p.pitch,
});
}
2022-06-25 09:11:15 +10:00
}
C2sPlayPacket::BoatPaddleState(p) => {
2022-08-06 05:36:34 +10:00
self.events.push_back(ClientEvent::SteerBoat {
2022-06-25 09:11:15 +10:00
left_paddle_turning: p.left_paddle_turning,
right_paddle_turning: p.right_paddle_turning,
});
}
C2sPlayPacket::PickFromInventory(_) => {}
C2sPlayPacket::CraftRequest(_) => {}
C2sPlayPacket::UpdatePlayerAbilities(_) => {}
2022-07-01 07:18:29 +10:00
C2sPlayPacket::PlayerAction(p) => {
2022-06-25 09:11:15 +10:00
// TODO: verify dug block is within the correct distance from the client.
// TODO: verify that the broken block is allowed to be broken?
if p.sequence.0 != 0 {
self.dug_blocks.push(p.sequence.0);
2022-06-25 09:11:15 +10:00
}
2022-07-03 04:22:28 +10:00
self.events.push_back(match p.status {
2022-08-06 05:36:34 +10:00
DiggingStatus::StartedDigging => ClientEvent::Digging {
2022-06-25 09:11:15 +10:00
status: event::DiggingStatus::Start,
position: p.location,
face: p.face,
2022-07-11 22:08:02 +10:00
},
2022-08-06 05:36:34 +10:00
DiggingStatus::CancelledDigging => ClientEvent::Digging {
2022-06-25 09:11:15 +10:00
status: event::DiggingStatus::Cancel,
position: p.location,
face: p.face,
2022-07-11 22:08:02 +10:00
},
2022-08-06 05:36:34 +10:00
DiggingStatus::FinishedDigging => ClientEvent::Digging {
2022-06-25 09:11:15 +10:00
status: event::DiggingStatus::Finish,
position: p.location,
face: p.face,
2022-07-11 22:08:02 +10:00
},
2022-06-25 09:11:15 +10:00
DiggingStatus::DropItemStack => return,
DiggingStatus::DropItem => return,
DiggingStatus::ShootArrowOrFinishEating => return,
DiggingStatus::SwapItemInHand => return,
});
}
2022-08-06 05:36:34 +10:00
C2sPlayPacket::PlayerCommand(c) => {
self.events.push_back(match c.action_id {
PlayerCommandId::StartSneaking => ClientEvent::StartSneaking,
PlayerCommandId::StopSneaking => ClientEvent::StopSneaking,
PlayerCommandId::LeaveBed => ClientEvent::LeaveBed,
PlayerCommandId::StartSprinting => ClientEvent::StartSprinting,
PlayerCommandId::StopSprinting => ClientEvent::StopSprinting,
PlayerCommandId::StartJumpWithHorse => ClientEvent::StartJumpWithHorse {
jump_boost: c.jump_boost.0 .0 as u8,
},
PlayerCommandId::StopJumpWithHorse => ClientEvent::StopJumpWithHorse,
PlayerCommandId::OpenHorseInventory => ClientEvent::OpenHorseInventory,
PlayerCommandId::StartFlyingWithElytra => ClientEvent::StartFlyingWithElytra,
2022-07-05 08:51:28 +10:00
});
}
2022-07-01 07:18:29 +10:00
C2sPlayPacket::PlayerInput(_) => {}
C2sPlayPacket::PlayPong(_) => {}
2022-07-01 07:18:29 +10:00
C2sPlayPacket::RecipeBookChangeSettings(_) => {}
C2sPlayPacket::RecipeBookSeenRecipe(_) => {}
C2sPlayPacket::RenameItem(_) => {}
C2sPlayPacket::ResourcePackStatus(_) => {}
C2sPlayPacket::AdvancementTab(_) => {}
C2sPlayPacket::SelectMerchantTrade(_) => {}
C2sPlayPacket::UpdateBeacon(_) => {}
C2sPlayPacket::UpdateSelectedSlot(_) => {}
C2sPlayPacket::UpdateCommandBlock(_) => {}
C2sPlayPacket::UpdateCommandBlockMinecart(_) => {}
C2sPlayPacket::UpdateCreativeModeSlot(_) => {}
C2sPlayPacket::UpdateJigsaw(_) => {}
C2sPlayPacket::UpdateStructureBlock(_) => {}
C2sPlayPacket::UpdateSign(_) => {}
2022-08-06 05:36:34 +10:00
C2sPlayPacket::HandSwing(p) => self.events.push_back(ClientEvent::ArmSwing(p.hand)),
C2sPlayPacket::SpectatorTeleport(_) => {}
C2sPlayPacket::PlayerInteractBlock(_) => {}
C2sPlayPacket::PlayerInteractItem(_) => {}
2022-06-25 09:11:15 +10:00
}
}
2022-07-16 13:40:39 +10:00
pub(crate) fn update(
&mut self,
shared: &SharedServer<C>,
entities: &Entities<C>,
worlds: &Worlds<C>,
2022-08-10 07:44:04 +10:00
player_lists: &PlayerLists<C>,
2022-07-16 13:40:39 +10:00
) {
2022-04-29 17:48:41 +10:00
// Mark the client as disconnected when appropriate.
if self.recv.is_disconnected() || self.send.as_ref().map_or(true, |s| s.is_disconnected()) {
self.send = None;
2022-04-29 17:48:41 +10:00
return;
2022-04-15 07:55:45 +10:00
}
2022-07-04 11:45:11 +10:00
let world = match worlds.get(self.world) {
Some(world) => world,
None => {
log::warn!(
"client {} is in an invalid world and must be disconnected",
self.username()
);
self.disconnect_no_reason();
return;
}
};
let current_tick = shared.current_tick();
2022-04-15 07:55:45 +10:00
2022-04-29 17:48:41 +10:00
// Send the join game packet and other initial packets. We defer this until now
// so that the user can set the client's initial location, game mode, etc.
2022-08-06 05:36:34 +10:00
if self.created_this_tick() {
self.bits.set_spawn(false);
2022-08-10 07:44:04 +10:00
if let Some(id) = &self.new_player_list {
player_lists
.get(id)
.initial_packets(|p| send_packet(&mut self.send, p));
}
2022-07-04 11:45:11 +10:00
let mut dimension_names: Vec<_> = shared
.dimensions()
.map(|(id, _)| ident!("{LIBRARY_NAMESPACE}:dimension_{}", id.0))
.collect();
dimension_names.push(ident!("{LIBRARY_NAMESPACE}:dummy_dimension"));
self.send_packet(GameJoin {
2022-07-06 18:12:05 +10:00
entity_id: 0, // EntityId 0 is reserved for clients.
2022-08-06 05:36:34 +10:00
is_hardcore: self.bits.hardcore(),
2022-04-15 07:55:45 +10:00
gamemode: self.new_game_mode,
previous_gamemode: self.old_game_mode,
2022-07-04 11:45:11 +10:00
dimension_names,
2022-08-30 12:28:19 +10:00
registry_codec: NbtBridge(make_registry_codec(shared)),
dimension_type_name: ident!(
"{LIBRARY_NAMESPACE}:dimension_type_{}",
world.meta.dimension().0
),
dimension_name: ident!(
"{LIBRARY_NAMESPACE}:dimension_{}",
world.meta.dimension().0
),
2022-04-15 07:55:45 +10:00
hashed_seed: 0,
max_players: VarInt(0),
2022-08-06 05:36:34 +10:00
view_distance: BoundedInt(VarInt(self.view_distance() as i32)),
2022-04-15 07:55:45 +10:00
simulation_distance: VarInt(16),
reduced_debug_info: false,
enable_respawn_screen: false,
2022-06-22 05:26:28 +10:00
is_debug: false,
is_flat: self.bits.flat(),
last_death_location: self
.death_location
.map(|(id, pos)| (ident!("{LIBRARY_NAMESPACE}:dimension_{}", id.0), pos)),
2022-04-15 07:55:45 +10:00
});
self.teleport(self.position(), self.yaw(), self.pitch());
2022-06-28 10:52:23 +10:00
} else {
2022-08-06 05:36:34 +10:00
if self.bits.spawn() {
self.bits.set_spawn(false);
self.loaded_entities.clear();
self.loaded_chunks.clear();
2022-07-04 11:45:11 +10:00
// Client bug workaround: send the client to a dummy dimension first.
2022-08-06 05:36:34 +10:00
// TODO: is there actually a bug?
self.send_packet(PlayerRespawn {
2022-07-04 11:45:11 +10:00
dimension_type_name: ident!("{LIBRARY_NAMESPACE}:dimension_type_0"),
dimension_name: ident!("{LIBRARY_NAMESPACE}:dummy_dimension"),
hashed_seed: 0,
game_mode: self.game_mode(),
previous_game_mode: self.game_mode(),
is_debug: false,
is_flat: self.bits.flat(),
2022-07-04 11:45:11 +10:00
copy_metadata: true,
last_death_location: None,
});
2022-07-04 10:32:05 +10:00
self.send_packet(PlayerRespawn {
2022-07-04 10:32:05 +10:00
dimension_type_name: ident!(
"{LIBRARY_NAMESPACE}:dimension_type_{}",
world.meta.dimension().0
),
dimension_name: ident!(
"{LIBRARY_NAMESPACE}:dimension_{}",
world.meta.dimension().0
),
hashed_seed: 0,
game_mode: self.game_mode(),
previous_game_mode: self.game_mode(),
is_debug: false,
is_flat: self.bits.flat(),
2022-07-04 10:32:05 +10:00
copy_metadata: true,
last_death_location: self
.death_location
.map(|(id, pos)| (ident!("{LIBRARY_NAMESPACE}:dimension_{}", id.0), pos)),
});
self.teleport(self.position(), self.yaw(), self.pitch());
}
2022-08-10 07:44:04 +10:00
// Update game mode
if self.old_game_mode != self.new_game_mode {
self.old_game_mode = self.new_game_mode;
self.send_packet(GameStateChange {
reason: GameStateChangeReason::ChangeGameMode,
value: self.new_game_mode as i32 as f32,
2022-06-28 10:52:23 +10:00
});
}
2022-08-10 07:44:04 +10:00
// If the player list was changed...
if self.old_player_list != self.new_player_list {
// Delete existing entries from old player list.
if let Some(id) = &self.old_player_list {
player_lists
.get(id)
.clear_packets(|p| send_packet(&mut self.send, p));
}
// Get initial packets for new player list.
if let Some(id) = &self.new_player_list {
player_lists
.get(id)
.initial_packets(|p| send_packet(&mut self.send, p));
}
self.old_player_list = self.new_player_list.clone();
} else if let Some(id) = &self.new_player_list {
// Update current player list.
player_lists
.get(id)
.update_packets(|p| send_packet(&mut self.send, p));
}
2022-04-15 07:55:45 +10:00
}
2022-07-13 13:47:53 +10:00
// Set player attributes
2022-08-06 05:36:34 +10:00
if self.bits.attack_speed_modified() {
self.bits.set_attack_speed_modified(false);
2022-07-13 13:47:53 +10:00
self.send_packet(EntityAttributes {
2022-07-13 13:47:53 +10:00
entity_id: VarInt(0),
properties: vec![EntityAttributesProperty {
2022-07-13 13:47:53 +10:00
key: ident!("generic.attack_speed"),
value: self.attack_speed,
modifiers: Vec::new(),
}],
});
}
2022-08-06 05:36:34 +10:00
if self.bits.movement_speed_modified() {
self.bits.set_movement_speed_modified(false);
2022-07-13 13:47:53 +10:00
self.send_packet(EntityAttributes {
2022-07-13 13:47:53 +10:00
entity_id: VarInt(0),
properties: vec![EntityAttributesProperty {
2022-07-13 13:47:53 +10:00
key: ident!("generic.movement_speed"),
value: self.movement_speed,
modifiers: Vec::new(),
}],
});
}
2022-04-29 17:48:41 +10:00
// Update the players spawn position (compass position)
2022-08-06 05:36:34 +10:00
if self.bits.modified_spawn_position() {
self.bits.set_modified_spawn_position(false);
2022-04-15 07:55:45 +10:00
self.send_packet(PlayerSpawnPosition {
2022-04-15 07:55:45 +10:00
location: self.spawn_position,
angle: self.spawn_position_yaw,
})
}
2022-08-06 05:36:34 +10:00
// Update view distance fog on the client.
if self.bits.view_distance_modified() {
self.bits.set_view_distance_modified(false);
if !self.created_this_tick() {
self.send_packet(ChunkLoadDistance {
2022-08-06 05:36:34 +10:00
view_distance: BoundedInt(VarInt(self.view_distance() as i32)),
});
2022-04-15 07:55:45 +10:00
}
}
// Check if it's time to send another keepalive.
if current_tick % (shared.tick_rate() * 8) == 0 {
2022-08-06 05:36:34 +10:00
if self.bits.got_keepalive() {
2022-04-15 07:55:45 +10:00
let id = rand::random();
2022-06-25 09:11:15 +10:00
self.send_packet(KeepAlive { id });
self.last_keepalive_id = id;
2022-08-06 05:36:34 +10:00
self.bits.set_got_keepalive(false);
2022-04-15 07:55:45 +10:00
} else {
log::warn!(
"player {} timed out (no keepalive response)",
self.username()
);
self.disconnect_no_reason();
2022-04-15 07:55:45 +10:00
}
}
2022-08-06 05:36:34 +10:00
let center = ChunkPos::at(self.position.x, self.position.z);
2022-04-15 07:55:45 +10:00
// Send the update view position packet if the client changes the chunk section
// they're in.
{
let old_section = self.old_position.map(|n| (n / 16.0).floor() as i32);
2022-08-06 05:36:34 +10:00
let new_section = self.position.map(|n| (n / 16.0).floor() as i32);
2022-04-15 07:55:45 +10:00
if old_section != new_section {
self.send_packet(ChunkRenderDistanceCenter {
2022-04-15 07:55:45 +10:00
chunk_x: VarInt(new_section.x),
chunk_z: VarInt(new_section.z),
})
}
}
let dimension = shared.dimension(world.meta.dimension());
2022-06-23 01:06:54 +10:00
// Update existing chunks and unload those outside the view distance. Chunks
// that have been overwritten also need to be unloaded.
self.loaded_chunks.retain(|&pos| {
// The cache stops chunk data packets from needing to be sent when a player
// moves to an adjacent chunk and back to the original.
let cache = 2;
if let Some(chunk) = world.chunks.get(pos) {
2022-08-11 13:09:10 +10:00
if is_chunk_in_view_distance(center, pos, self.view_distance + cache)
&& !chunk.created_this_tick()
{
2022-06-23 01:06:54 +10:00
chunk.block_change_packets(pos, dimension.min_y, |pkt| {
send_packet(&mut self.send, pkt)
2022-06-23 01:06:54 +10:00
});
return true;
2022-04-15 07:55:45 +10:00
}
}
send_packet(
&mut self.send,
UnloadChunk {
chunk_x: pos.x,
chunk_z: pos.z,
},
);
false
2022-04-15 07:55:45 +10:00
});
// Load new chunks within the view distance
2022-08-11 13:09:10 +10:00
for pos in chunks_in_view_distance(center, self.view_distance) {
if let Some(chunk) = world.chunks.get(pos) {
if self.loaded_chunks.insert(pos) {
self.send_packet(chunk.chunk_data_packet(pos));
2022-06-23 01:06:54 +10:00
chunk.block_change_packets(pos, dimension.min_y, |pkt| self.send_packet(pkt));
2022-04-15 07:55:45 +10:00
}
}
}
2022-06-25 09:11:15 +10:00
// Acknowledge broken blocks.
for seq in self.dug_blocks.drain(..) {
2022-06-25 09:11:15 +10:00
send_packet(
&mut self.send,
PlayerActionResponse {
2022-06-25 09:11:15 +10:00
sequence: VarInt(seq),
},
)
}
2022-07-15 21:21:32 +10:00
// Teleport the player.
//
2022-04-15 07:55:45 +10:00
// This is done after the chunks are loaded so that the "downloading terrain"
// screen is closed at the appropriate time.
2022-08-06 05:36:34 +10:00
if self.bits.teleported_this_tick() {
self.bits.set_teleported_this_tick(false);
self.send_packet(PlayerPositionLook {
2022-08-06 05:36:34 +10:00
position: self.position,
yaw: self.yaw,
pitch: self.pitch,
flags: PlayerPositionLookFlags::new(false, false, false, false, false),
2022-08-06 05:36:34 +10:00
teleport_id: VarInt(self.teleport_id_counter as i32),
dismount_vehicle: false,
});
2022-08-06 05:36:34 +10:00
self.pending_teleports = self.pending_teleports.wrapping_add(1);
if self.pending_teleports == 0 {
log::warn!("too many pending teleports for {}", self.username());
self.disconnect_no_reason();
return;
}
self.teleport_id_counter = self.teleport_id_counter.wrapping_add(1);
}
2022-07-18 14:29:44 +10:00
// Set velocity. Do this after teleporting since teleporting sets velocity to
// zero.
2022-08-06 05:36:34 +10:00
if self.bits.velocity_modified() {
self.bits.set_velocity_modified(false);
2022-07-18 14:29:44 +10:00
self.send_packet(EntityVelocityUpdate {
2022-07-18 14:29:44 +10:00
entity_id: VarInt(0),
velocity: velocity_to_packet_units(self.velocity),
});
}
2022-07-15 21:21:32 +10:00
// Send chat messages.
2022-07-02 12:18:59 +10:00
for msg in self.msgs_to_send.drain(..) {
send_packet(
&mut self.send,
GameMessage {
2022-07-02 12:18:59 +10:00
chat: msg,
kind: VarInt(0),
2022-07-02 12:18:59 +10:00
},
);
2022-06-30 14:33:42 +10:00
}
let mut entities_to_unload = Vec::new();
// Update all entities that are visible and unload entities that are no
// longer visible.
self.loaded_entities.retain(|&id| {
if let Some(entity) = entities.get(id) {
debug_assert!(entity.kind() != EntityKind::Marker);
2022-08-11 13:09:10 +10:00
if self.position.distance(entity.position()) <= self.view_distance as f64 * 16.0 {
2022-07-28 00:10:35 +10:00
if let Some(meta) = entity.updated_tracked_data_packet(id) {
send_packet(&mut self.send, meta);
2022-05-17 04:53:21 +10:00
}
2022-05-17 19:58:43 +10:00
let position_delta = entity.position() - entity.old_position();
let needs_teleport = position_delta.map(f64::abs).reduce_partial_max() >= 8.0;
2022-08-06 05:36:34 +10:00
let flags = entity.bits();
2022-05-17 19:58:43 +10:00
if entity.position() != entity.old_position()
&& !needs_teleport
&& flags.yaw_or_pitch_modified()
{
send_packet(
&mut self.send,
RotateAndMoveRelative {
2022-05-17 19:58:43 +10:00
entity_id: VarInt(id.to_network_id()),
delta: (position_delta * 4096.0).as_(),
yaw: ByteAngle::from_degrees(entity.yaw()),
pitch: ByteAngle::from_degrees(entity.pitch()),
on_ground: entity.on_ground(),
},
);
} else {
if entity.position() != entity.old_position() && !needs_teleport {
send_packet(
&mut self.send,
MoveRelative {
2022-05-17 19:58:43 +10:00
entity_id: VarInt(id.to_network_id()),
delta: (position_delta * 4096.0).as_(),
on_ground: entity.on_ground(),
},
);
}
if flags.yaw_or_pitch_modified() {
send_packet(
&mut self.send,
Rotate {
2022-05-17 19:58:43 +10:00
entity_id: VarInt(id.to_network_id()),
yaw: ByteAngle::from_degrees(entity.yaw()),
pitch: ByteAngle::from_degrees(entity.pitch()),
on_ground: entity.on_ground(),
},
);
}
}
if needs_teleport {
send_packet(
&mut self.send,
EntityPosition {
2022-05-17 19:58:43 +10:00
entity_id: VarInt(id.to_network_id()),
position: entity.position(),
yaw: ByteAngle::from_degrees(entity.yaw()),
pitch: ByteAngle::from_degrees(entity.pitch()),
on_ground: entity.on_ground(),
},
);
}
if flags.velocity_modified() {
send_packet(
&mut self.send,
EntityVelocityUpdate {
2022-05-17 19:58:43 +10:00
entity_id: VarInt(id.to_network_id()),
velocity: velocity_to_packet_units(entity.velocity()),
},
);
}
if flags.head_yaw_modified() {
send_packet(
&mut self.send,
EntitySetHeadYaw {
2022-05-17 19:58:43 +10:00
entity_id: VarInt(id.to_network_id()),
head_yaw: ByteAngle::from_degrees(entity.head_yaw()),
},
)
}
2022-07-28 00:10:35 +10:00
send_entity_events(&mut self.send, id.to_network_id(), entity.events());
return true;
}
}
entities_to_unload.push(VarInt(id.to_network_id()));
false
});
if !entities_to_unload.is_empty() {
self.send_packet(EntitiesDestroy {
entities: entities_to_unload,
2022-04-15 07:55:45 +10:00
});
}
2022-06-30 06:00:41 +10:00
// Update the client's own player metadata.
2022-06-30 14:33:42 +10:00
let mut data = Vec::new();
2022-07-28 00:10:35 +10:00
self.player_data.updated_tracked_data(&mut data);
2022-06-30 06:00:41 +10:00
2022-06-30 14:33:42 +10:00
if !data.is_empty() {
data.push(0xff);
2022-06-30 06:00:41 +10:00
self.send_packet(EntityTrackerUpdate {
2022-06-30 14:33:42 +10:00
entity_id: VarInt(0),
metadata: RawBytes(data),
});
2022-06-30 06:00:41 +10:00
}
// Spawn new entities within the view distance.
let pos = self.position();
2022-08-11 13:09:10 +10:00
let view_dist = self.view_distance;
world.spatial_index.query::<_, _, ()>(
2022-06-20 01:40:37 +10:00
|bb| bb.projected_point(pos).distance(pos) <= view_dist as f64 * 16.0,
|id, _| {
let entity = entities
.get(id)
2022-07-18 14:29:44 +10:00
.expect("entity IDs in spatial index should be valid at this point");
if entity.kind() != EntityKind::Marker
&& entity.uuid() != self.uuid
&& self.loaded_entities.insert(id)
{
self.send_packet(
entity
.spawn_packet(id)
.expect("should not be a marker entity"),
);
2022-06-20 01:40:37 +10:00
2022-07-28 00:10:35 +10:00
if let Some(meta) = entity.initial_tracked_data_packet(id) {
self.send_packet(meta);
}
2022-07-28 00:10:35 +10:00
send_entity_events(&mut self.send, id.to_network_id(), entity.events());
}
None
},
);
2022-07-28 00:10:35 +10:00
send_entity_events(&mut self.send, 0, &self.entity_events);
self.entity_events.clear();
2022-07-04 16:17:51 +10:00
2022-07-18 14:29:44 +10:00
self.player_data.clear_modifications();
2022-08-06 05:36:34 +10:00
self.old_position = self.position;
self.bits.set_created_this_tick(false);
2022-08-06 16:10:25 +10:00
send_packet(&mut self.send, S2cPlayMessage::Flush);
2022-04-15 07:55:45 +10:00
}
}
2022-08-06 16:10:25 +10:00
type SendOpt = Option<Sender<S2cPlayMessage>>;
2022-07-06 11:08:40 +10:00
2022-08-06 16:10:25 +10:00
fn send_packet(send_opt: &mut SendOpt, pkt: impl Into<S2cPlayMessage>) {
2022-04-15 07:55:45 +10:00
if let Some(send) = send_opt {
match send.try_send(pkt.into()) {
Err(TrySendError::Full(_)) => {
log::warn!("max outbound packet capacity reached for client");
*send_opt = None;
}
Err(TrySendError::Disconnected(_)) => {
*send_opt = None;
}
Ok(_) => {}
}
}
}
2022-07-28 00:10:35 +10:00
fn send_entity_events(send_opt: &mut SendOpt, entity_id: i32, events: &[EntityEvent]) {
for &event in events {
match event.status_or_animation() {
StatusOrAnimation::Status(code) => send_packet(
2022-07-06 11:08:40 +10:00
send_opt,
2022-07-28 00:10:35 +10:00
EntityStatus {
entity_id,
entity_status: code,
2022-07-06 11:08:40 +10:00
},
2022-07-28 00:10:35 +10:00
),
StatusOrAnimation::Animation(code) => send_packet(
2022-07-06 11:08:40 +10:00
send_opt,
EntityAnimation {
2022-07-28 00:10:35 +10:00
entity_id: VarInt(entity_id),
animation: code,
2022-07-06 11:08:40 +10:00
},
2022-07-28 00:10:35 +10:00
),
2022-07-06 11:08:40 +10:00
}
}
}
2022-07-16 13:40:39 +10:00
fn make_registry_codec<C: Config>(shared: &SharedServer<C>) -> RegistryCodec {
2022-04-15 07:55:45 +10:00
let mut dims = Vec::new();
for (id, dim) in shared.dimensions() {
2022-04-15 07:55:45 +10:00
let id = id.0 as i32;
dims.push(DimensionTypeRegistryEntry {
name: ident!("{LIBRARY_NAMESPACE}:dimension_type_{id}"),
id,
2022-07-11 22:08:02 +10:00
element: dim.to_dimension_registry_item(),
2022-04-15 07:55:45 +10:00
})
}
2022-07-11 22:08:02 +10:00
let mut biomes: Vec<_> = shared
.biomes()
.map(|(id, biome)| biome.to_biome_registry_item(id.0 as i32))
.collect();
2022-04-15 07:55:45 +10:00
// The client needs a biome named "minecraft:plains" in the registry to
// connect. This is probably a bug.
//
// If the issue is resolved, just delete this block.
if !biomes.iter().any(|b| b.name == ident!("plains")) {
let biome = Biome::default();
assert_eq!(biome.name, ident!("plains"));
2022-07-11 22:08:02 +10:00
biomes.push(biome.to_biome_registry_item(biomes.len() as i32));
2022-04-15 07:55:45 +10:00
}
2022-07-03 06:41:45 +10:00
RegistryCodec {
2022-04-15 07:55:45 +10:00
dimension_type_registry: DimensionTypeRegistry {
kind: ident!("dimension_type"),
2022-04-15 07:55:45 +10:00
value: dims,
},
biome_registry: BiomeRegistry {
kind: ident!("worldgen/biome"),
2022-04-15 07:55:45 +10:00
value: biomes,
},
chat_type_registry: ChatTypeRegistry {
kind: ident!("chat_type"),
2022-08-31 11:41:17 +10:00
value: Vec::new(),
},
2022-04-15 07:55:45 +10:00
}
}