From d5fa5e32b37754b3b5c136e58821e48cd3b7c2ff Mon Sep 17 00:00:00 2001 From: mat <27899617+mat-1@users.noreply.github.com> Date: Tue, 13 Jan 2026 10:51:30 -0600 Subject: Rename Instance to World (#304) --- azalea-client/src/plugins/packet/config/mod.rs | 10 +- azalea-client/src/plugins/packet/game/events.rs | 17 +- azalea-client/src/plugins/packet/game/mod.rs | 217 ++++++++++++------------ azalea-client/src/plugins/packet/mod.rs | 2 +- 4 files changed, 119 insertions(+), 127 deletions(-) (limited to 'azalea-client/src/plugins/packet') diff --git a/azalea-client/src/plugins/packet/config/mod.rs b/azalea-client/src/plugins/packet/config/mod.rs index 27dae837..f59b8c23 100644 --- a/azalea-client/src/plugins/packet/config/mod.rs +++ b/azalea-client/src/plugins/packet/config/mod.rs @@ -17,7 +17,7 @@ use crate::{ connection::RawConnection, cookies::{RequestCookieEvent, StoreCookieEvent}, disconnect::DisconnectEvent, - local_player::InstanceHolder, + local_player::WorldHolder, packet::game::{KeepAliveEvent, ResourcePackEvent}, }; @@ -69,12 +69,12 @@ pub struct ConfigPacketHandler<'a> { } impl ConfigPacketHandler<'_> { pub fn registry_data(&mut self, p: &ClientboundRegistryData) { - as_system::>(self.ecs, |mut query| { - let instance_holder = query.get_mut(self.player).unwrap(); - let mut instance = instance_holder.instance.write(); + as_system::>(self.ecs, |mut query| { + let world_holder = query.get_mut(self.player).unwrap(); + let mut world = world_holder.shared.write(); // add the new registry data - instance + world .registries .append(p.registry_id.clone(), p.entries.clone()); }); diff --git a/azalea-client/src/plugins/packet/game/events.rs b/azalea-client/src/plugins/packet/game/events.rs index 535bd519..bc070ec8 100644 --- a/azalea-client/src/plugins/packet/game/events.rs +++ b/azalea-client/src/plugins/packet/game/events.rs @@ -5,8 +5,7 @@ use azalea_protocol::packets::{ Packet, game::{ClientboundGamePacket, ClientboundPlayerCombatKill, ServerboundGamePacket}, }; -use azalea_registry::identifier::Identifier; -use azalea_world::Instance; +use azalea_world::{World, WorldName}; use bevy_ecs::prelude::*; use parking_lot::RwLock; use tracing::{error, trace}; @@ -138,16 +137,18 @@ pub struct ResourcePackEvent { pub prompt: Option, } -/// An instance (aka world, dimension) was loaded by a client. +/// A world instance (aka dimension) was loaded by a client. /// -/// Since the instance is given to you as a weak reference, it won't be able to -/// be `upgrade`d if all local players leave it. +/// Since the world is given to you as a weak reference, it won't be able to be +/// `upgrade`d if all local players unload it. #[derive(Clone, Debug, Message)] -pub struct InstanceLoadedEvent { +pub struct WorldLoadedEvent { pub entity: Entity, - pub name: Identifier, - pub instance: Weak>, + pub name: WorldName, + pub world: Weak>, } +#[deprecated = "renamed to `WorldLoadedEvent`."] +pub type InstanceLoadedEvent = WorldLoadedEvent; /// A Bevy trigger that's sent when our client receives a [`ClientboundPing`] /// packet in the game state. diff --git a/azalea-client/src/plugins/packet/game/mod.rs b/azalea-client/src/plugins/packet/game/mod.rs index f93a02ea..6489c899 100644 --- a/azalea-client/src/plugins/packet/game/mod.rs +++ b/azalea-client/src/plugins/packet/game/mod.rs @@ -19,7 +19,7 @@ use azalea_protocol::{ packets::{ConnectionProtocol, game::*}, }; use azalea_registry::builtin::EntityKind; -use azalea_world::{InstanceContainer, InstanceName, PartialInstance}; +use azalea_world::{PartialWorld, WorldName, Worlds}; use bevy_ecs::{prelude::*, system::SystemState}; pub use events::*; use tracing::{debug, error, trace, warn}; @@ -34,7 +34,7 @@ use crate::{ disconnect::DisconnectEvent, interact::BlockStatePredictionHandler, inventory::{ClientsideCloseContainerEvent, MenuOpenedEvent, SetContainerContentEvent}, - local_player::{Hunger, InstanceHolder, LocalGameMode, TabList}, + local_player::{Hunger, LocalGameMode, TabList, WorldHolder}, movement::{KnockbackData, KnockbackEvent}, packet::{as_system, declare_packet_handlers}, player::{GameProfileComponent, PlayerInfo}, @@ -207,15 +207,15 @@ impl GamePacketHandler<'_> { ( &GameProfileComponent, &ClientInformation, - Option<&mut InstanceName>, + Option<&mut WorldName>, Option<&mut LoadedBy>, &mut EntityIdIndex, - &mut InstanceHolder, + &mut WorldHolder, ), With, >, - MessageWriter, - ResMut, + MessageWriter, + ResMut, ResMut, Query<&mut LoadedBy, Without>, )>( @@ -223,33 +223,31 @@ impl GamePacketHandler<'_> { |( mut commands, mut query, - mut instance_loaded_events, - mut instance_container, + mut world_loaded_events, + mut worlds, mut entity_uuid_index, mut loaded_by_query, )| { let ( game_profile, client_information, - instance_name, + world_name, loaded_by, mut entity_id_index, - mut instance_holder, + mut world_holder, ) = query.get_mut(self.player).unwrap(); - let new_instance_name = p.common.dimension.clone(); + let new_world_name = WorldName(p.common.dimension.clone()); - if let Some(mut instance_name) = instance_name { - **instance_name = new_instance_name.clone(); + if let Some(mut world_name) = world_name { + *world_name = new_world_name.clone(); } else { - commands - .entity(self.player) - .insert(InstanceName(new_instance_name.clone())); + commands.entity(self.player).insert(new_world_name.clone()); } - let weak_instance; + let weak_world; { - let client_registries = &instance_holder.instance.read().registries; + let client_registries = &world_holder.shared.read().registries; let Some((_dimension_type, dimension_data)) = p.common.dimension_type(client_registries) @@ -257,46 +255,44 @@ impl GamePacketHandler<'_> { return; }; - // add this world to the instance_container (or don't if it's already - // there) - weak_instance = instance_container.get_or_insert( - new_instance_name.clone(), + // add this world to the `worlds` (or don't, if it's already there) + weak_world = worlds.get_or_insert( + new_world_name.clone(), dimension_data.height, dimension_data.min_y, client_registries, ); - instance_loaded_events.write(InstanceLoadedEvent { + world_loaded_events.write(WorldLoadedEvent { entity: self.player, - name: new_instance_name.clone(), - instance: Arc::downgrade(&weak_instance), + name: new_world_name.clone(), + world: Arc::downgrade(&weak_world), }); } - // set the partial_world to an empty world - // (when we add chunks or entities those will be in the - // instance_container) + // set the partial world to an empty world (when we add chunks or entities those + // will be in the `worlds`) - *instance_holder.partial_instance.write() = PartialInstance::new( + *world_holder.partial.write() = PartialWorld::new( azalea_world::chunk_storage::calculate_chunk_storage_range( client_information.view_distance.into(), ), - // this argument makes it so other clients don't update this player entity - // in a shared instance + // this argument makes it so other clients don't update this player entity in a + // shared world Some(self.player), ); { - let client_registries = instance_holder.instance.read().registries.clone(); - let shared_registries = &mut weak_instance.write().registries; - // add the registries from this instance to the weak instance + let client_registries = world_holder.shared.read().registries.clone(); + let shared_registries = &mut weak_world.write().registries; + // add the registries from this world to the weak world shared_registries.extend(client_registries); } - instance_holder.instance = weak_instance; + world_holder.shared = weak_world; let entity_bundle = EntityBundle::new( game_profile.uuid, Vec3::ZERO, EntityKind::Player, - new_instance_name, + new_world_name, ); let entity_id = p.player_id; // insert our components into the ecs :) @@ -316,7 +312,7 @@ impl GamePacketHandler<'_> { Some(game_profile.uuid), &mut entity_id_index, &mut entity_uuid_index, - &mut instance_holder.instance.write(), + &mut world_holder.shared.write(), ); // every entity is now unloaded by this player @@ -532,9 +528,9 @@ impl GamePacketHandler<'_> { pub fn set_chunk_cache_center(&mut self, p: &ClientboundSetChunkCacheCenter) { debug!("Got chunk cache center packet {p:?}"); - as_system::>(self.ecs, |mut query| { - let instance_holder = query.get_mut(self.player).unwrap(); - let mut partial_world = instance_holder.partial_instance.write(); + as_system::>(self.ecs, |mut query| { + let world_holder = query.get_mut(self.player).unwrap(); + let mut partial_world = world_holder.partial.write(); partial_world .chunks @@ -564,10 +560,10 @@ impl GamePacketHandler<'_> { as_system::<( Commands, - Query<(&mut EntityIdIndex, Option<&InstanceName>, Option<&TabList>)>, + Query<(&mut EntityIdIndex, Option<&WorldName>, Option<&TabList>)>, Query<&mut LoadedBy>, Query, - Res, + Res, ResMut, )>( self.ecs, @@ -576,22 +572,22 @@ impl GamePacketHandler<'_> { mut query, mut loaded_by_query, entity_query, - instance_container, + worlds, mut entity_uuid_index, )| { - let (mut entity_id_index, instance_name, tab_list) = + let (mut entity_id_index, world_name, tab_list) = query.get_mut(self.player).unwrap(); let entity_id = p.id; - let Some(instance_name) = instance_name else { + let Some(world_name) = world_name else { warn!("got add player packet but we haven't gotten a login packet yet"); return; }; // check if the entity already exists, and if it does then only add to LoadedBy - let instance = instance_container.get(instance_name).unwrap(); - if let Some(&ecs_entity) = instance.read().entity_by_id.get(&entity_id) { + let world = worlds.get(world_name).unwrap(); + if let Some(&ecs_entity) = world.read().entity_by_id.get(&entity_id) { // entity already exists let Ok(mut loaded_by) = loaded_by_query.get_mut(ecs_entity) else { // LoadedBy for this entity isn't in the ecs! figure out what went wrong @@ -621,7 +617,7 @@ impl GamePacketHandler<'_> { // entity doesn't exist in the global index! - let bundle = p.as_entity_bundle((**instance_name).clone()); + let bundle = p.as_entity_bundle(world_name.to_owned()); let mut spawned = commands.spawn((entity_id, LoadedBy(HashSet::from([self.player])), bundle)); let ecs_entity: Entity = spawned.id(); @@ -636,7 +632,7 @@ impl GamePacketHandler<'_> { Some(p.uuid), &mut entity_id_index, &mut entity_uuid_index, - &mut instance.write(), + &mut world.write(), ); // add the GameProfileComponent if the uuid is in the tab list @@ -659,12 +655,12 @@ impl GamePacketHandler<'_> { pub fn set_entity_data(&mut self, p: &ClientboundSetEntityData) { as_system::<( Commands, - Query<(&EntityIdIndex, &InstanceHolder)>, + Query<(&EntityIdIndex, &WorldHolder)>, // this is a separate query since it's applied on the entity id that's being updated // instead of the player that received the packet Query<&EntityKindComponent>, )>(self.ecs, |(mut commands, query, entity_kind_query)| { - let (entity_id_index, instance_holder) = query.get(self.player).unwrap(); + let (entity_id_index, world_holder) = query.get(self.player).unwrap(); let entity = entity_id_index.get_by_minecraft_entity(p.id); @@ -693,7 +689,7 @@ impl GamePacketHandler<'_> { // we use RelativeEntityUpdate because it makes sure changes aren't made // multiple times commands.entity(entity).queue(RelativeEntityUpdate::new( - instance_holder.partial_instance.clone(), + world_holder.partial.clone(), move |entity| { let entity_id = entity.id(); entity.world_scope(|world| { @@ -720,10 +716,10 @@ impl GamePacketHandler<'_> { // vanilla servers use this packet for knockback, but note that the Explode // packet is also sometimes used by servers for knockback - as_system::<(Commands, Query<(&EntityIdIndex, &InstanceHolder)>)>( + as_system::<(Commands, Query<(&EntityIdIndex, &WorldHolder)>)>( self.ecs, |(mut commands, query)| { - let (entity_id_index, instance_holder) = query.get(self.player).unwrap(); + let (entity_id_index, world_holder) = query.get(self.player).unwrap(); let Some(entity) = entity_id_index.get_by_minecraft_entity(p.id) else { // note that this log (and some other ones like the one in RemoveEntities) @@ -742,7 +738,7 @@ impl GamePacketHandler<'_> { let data = KnockbackData::Set(p.delta.to_vec3()); commands.entity(entity).queue(RelativeEntityUpdate::new( - instance_holder.partial_instance.clone(), + world_holder.partial.clone(), move |entity_mut| { entity_mut .world_scope(|world| world.trigger(KnockbackEvent { entity, data })); @@ -790,10 +786,10 @@ impl GamePacketHandler<'_> { pub fn teleport_entity(&mut self, p: &ClientboundTeleportEntity) { debug!("Got teleport entity packet {p:?}"); - as_system::<(Commands, Query<(&EntityIdIndex, &InstanceHolder)>)>( + as_system::<(Commands, Query<(&EntityIdIndex, &WorldHolder)>)>( self.ecs, |(mut commands, mut query)| { - let (entity_id_index, instance_holder) = query.get_mut(self.player).unwrap(); + let (entity_id_index, world_holder) = query.get_mut(self.player).unwrap(); let Some(entity) = entity_id_index.get_by_minecraft_entity(p.id) else { warn!("Got teleport entity packet for unknown entity id {}", p.id); @@ -804,7 +800,7 @@ impl GamePacketHandler<'_> { let change = p.change.clone(); commands.entity(entity).queue(RelativeEntityUpdate::new( - instance_holder.partial_instance.clone(), + world_holder.partial.clone(), move |entity| { let entity_id = entity.id(); entity.world_scope(move |world| { @@ -835,10 +831,10 @@ impl GamePacketHandler<'_> { pub fn rotate_head(&mut self, _p: &ClientboundRotateHead) {} pub fn move_entity_pos(&mut self, p: &ClientboundMoveEntityPos) { - as_system::<(Commands, Query<(&EntityIdIndex, &InstanceHolder)>)>( + as_system::<(Commands, Query<(&EntityIdIndex, &WorldHolder)>)>( self.ecs, |(mut commands, mut query)| { - let (entity_id_index, instance_holder) = query.get_mut(self.player).unwrap(); + let (entity_id_index, world_holder) = query.get_mut(self.player).unwrap(); debug!("Got move entity pos packet {p:?}"); @@ -851,7 +847,7 @@ impl GamePacketHandler<'_> { let new_delta = p.delta.clone(); let new_on_ground = p.on_ground; commands.entity(entity).queue(RelativeEntityUpdate::new( - instance_holder.partial_instance.clone(), + world_holder.partial.clone(), move |entity_mut| { let mut physics = entity_mut.get_mut::().unwrap(); let new_pos = physics.vec_delta_codec.decode(&new_delta); @@ -874,10 +870,10 @@ impl GamePacketHandler<'_> { } pub fn move_entity_pos_rot(&mut self, p: &ClientboundMoveEntityPosRot) { - as_system::<(Commands, Query<(&EntityIdIndex, &InstanceHolder)>)>( + as_system::<(Commands, Query<(&EntityIdIndex, &WorldHolder)>)>( self.ecs, |(mut commands, mut query)| { - let (entity_id_index, instance_holder) = query.get_mut(self.player).unwrap(); + let (entity_id_index, world_holder) = query.get_mut(self.player).unwrap(); debug!("Got move entity pos rot packet {p:?}"); @@ -901,7 +897,7 @@ impl GamePacketHandler<'_> { let new_on_ground = p.on_ground; commands.entity(entity).queue(RelativeEntityUpdate::new( - instance_holder.partial_instance.clone(), + world_holder.partial.clone(), move |entity_mut| { let mut physics = entity_mut.get_mut::().unwrap(); let new_position = physics.vec_delta_codec.decode(&new_delta); @@ -924,10 +920,10 @@ impl GamePacketHandler<'_> { } pub fn move_entity_rot(&mut self, p: &ClientboundMoveEntityRot) { - as_system::<(Commands, Query<(&EntityIdIndex, &InstanceHolder)>)>( + as_system::<(Commands, Query<(&EntityIdIndex, &WorldHolder)>)>( self.ecs, |(mut commands, mut query)| { - let (entity_id_index, instance_holder) = query.get_mut(self.player).unwrap(); + let (entity_id_index, world_holder) = query.get_mut(self.player).unwrap(); let entity = entity_id_index.get_by_minecraft_entity(p.entity_id); if let Some(entity) = entity { @@ -938,7 +934,7 @@ impl GamePacketHandler<'_> { let new_on_ground = p.on_ground; commands.entity(entity).queue(RelativeEntityUpdate::new( - instance_holder.partial_instance.clone(), + world_holder.partial.clone(), move |entity_mut| { let mut physics = entity_mut.get_mut::().unwrap(); physics.set_on_ground(new_on_ground); @@ -1113,10 +1109,10 @@ impl GamePacketHandler<'_> { let mob_effect = p.mob_effect; let effect_data = &p.data; - as_system::<(Commands, Query<(&EntityIdIndex, &InstanceHolder)>)>( + as_system::<(Commands, Query<(&EntityIdIndex, &WorldHolder)>)>( self.ecs, |(mut commands, query)| { - let (entity_id_index, instance_holder) = query.get(self.player).unwrap(); + let (entity_id_index, world_holder) = query.get(self.player).unwrap(); let Some(entity) = entity_id_index.get_by_minecraft_entity(p.entity_id) else { debug!( @@ -1126,10 +1122,10 @@ impl GamePacketHandler<'_> { return; }; - let partial_instance = instance_holder.partial_instance.clone(); + let partial_world = world_holder.partial.clone(); let effect_data = effect_data.clone(); commands.entity(entity).queue(RelativeEntityUpdate::new( - partial_instance, + partial_world, move |entity| { if let Some(mut active_effects) = entity.get_mut::() { active_effects.insert(mob_effect, effect_data.clone()); @@ -1147,11 +1143,11 @@ impl GamePacketHandler<'_> { pub fn award_stats(&mut self, _p: &ClientboundAwardStats) {} pub fn block_changed_ack(&mut self, p: &ClientboundBlockChangedAck) { - as_system::>( + as_system::>( self.ecs, |mut query| { let (local_player, mut prediction_handler) = query.get_mut(self.player).unwrap(); - let world = local_player.instance.read(); + let world = local_player.shared.read(); prediction_handler.end_prediction_up_to(p.seq, &world); }, ); @@ -1277,12 +1273,12 @@ impl GamePacketHandler<'_> { pub fn forget_level_chunk(&mut self, p: &ClientboundForgetLevelChunk) { debug!("Got forget level chunk packet {p:?}"); - as_system::>(self.ecs, |mut query| { + as_system::>(self.ecs, |mut query| { let local_player = query.get_mut(self.player).unwrap(); - let mut partial_instance = local_player.partial_instance.write(); + let mut partial_world = local_player.partial.write(); - partial_instance.chunks.limited_set(&p.pos, None); + partial_world.chunks.limited_set(&p.pos, None); }); } @@ -1355,10 +1351,10 @@ impl GamePacketHandler<'_> { let mob_effect = p.effect; - as_system::<(Commands, Query<(&EntityIdIndex, &InstanceHolder)>)>( + as_system::<(Commands, Query<(&EntityIdIndex, &WorldHolder)>)>( self.ecs, |(mut commands, query)| { - let (entity_id_index, instance_holder) = query.get(self.player).unwrap(); + let (entity_id_index, world_holder) = query.get(self.player).unwrap(); let Some(entity) = entity_id_index.get_by_minecraft_entity(p.entity_id) else { debug!( @@ -1368,9 +1364,9 @@ impl GamePacketHandler<'_> { return; }; - let partial_instance = instance_holder.partial_instance.clone(); + let partial_world = world_holder.partial.clone(); commands.entity(entity).queue(RelativeEntityUpdate::new( - partial_instance, + partial_world, move |entity| { if let Some(mut active_effects) = entity.get_mut::() { active_effects.remove(mob_effect); @@ -1405,71 +1401,67 @@ impl GamePacketHandler<'_> { Commands, Query< ( - &mut InstanceHolder, + &mut WorldHolder, &GameProfileComponent, &ClientInformation, - Option<&mut InstanceName>, + Option<&mut WorldName>, ), With, >, MessageWriter<_>, - ResMut, + ResMut, Query<&mut LoadedBy, Without>, )>( self.ecs, - |(mut commands, mut query, mut events, mut instance_container, mut loaded_by_query)| { - let Ok((mut instance_holder, game_profile, client_information, instance_name)) = + |(mut commands, mut query, mut events, mut worlds, mut loaded_by_query)| { + let Ok((mut world_holder, game_profile, client_information, world_name)) = query.get_mut(self.player) else { warn!("Got respawn packet but player doesn't have the required components"); return; }; - let new_instance_name = p.common.dimension.clone(); + let new_world_name = WorldName(p.common.dimension.clone()); - if let Some(mut instance_name) = instance_name { - **instance_name = new_instance_name.clone(); + if let Some(mut world_name) = world_name { + *world_name = new_world_name.clone(); } else { - commands - .entity(self.player) - .insert(InstanceName(new_instance_name.clone())); + commands.entity(self.player).insert(new_world_name.clone()); } - let weak_instance; + let weak_world; { - let client_registries = &instance_holder.instance.read().registries; + let client_registries = &world_holder.shared.read().registries; let Some((_dimension_type, dimension_data)) = p.common.dimension_type(client_registries) else { return; }; - // add this world to the instance_container (or don't if it's already - // there) - weak_instance = instance_container.get_or_insert( - new_instance_name.clone(), + // add this world to the `worlds` (or don't if it's already there) + weak_world = worlds.get_or_insert( + new_world_name.clone(), dimension_data.height, dimension_data.min_y, client_registries, ); - events.write(InstanceLoadedEvent { + events.write(WorldLoadedEvent { entity: self.player, - name: new_instance_name.clone(), - instance: Arc::downgrade(&weak_instance), + name: new_world_name.clone(), + world: Arc::downgrade(&weak_world), }); } - // set the partial_world to an empty world - // (when we add chunks or entities those will be in the - // instance_container) + // set the partial world to an empty world (when we add chunks or entities, + // those will be in the `worlds`) - *instance_holder.partial_instance.write() = PartialInstance::new( + *world_holder.partial.write() = PartialWorld::new( azalea_world::chunk_storage::calculate_chunk_storage_range( client_information.view_distance.into(), ), Some(self.player), ); - instance_holder.instance = weak_instance; + world_holder.shared = weak_world; // every entity is now unloaded by this player for mut loaded_by in &mut loaded_by_query.iter_mut() { @@ -1481,7 +1473,7 @@ impl GamePacketHandler<'_> { game_profile.uuid, Vec3::ZERO, EntityKind::Player, - new_instance_name, + new_world_name, ); // update the local gamemode and metadata things commands.entity(self.player).insert(( @@ -1502,11 +1494,10 @@ impl GamePacketHandler<'_> { pub fn start_configuration(&mut self, _p: &ClientboundStartConfiguration) { debug!("Got start configuration packet"); - as_system::<(Commands, Query<(&mut RawConnection, &mut InstanceHolder)>)>( + as_system::<(Commands, Query<(&mut RawConnection, &mut WorldHolder)>)>( self.ecs, |(mut commands, mut query)| { - let Some((mut raw_conn, mut instance_holder)) = query.get_mut(self.player).ok() - else { + let Some((mut raw_conn, mut world_holder)) = query.get_mut(self.player).ok() else { warn!("Got start configuration packet but player doesn't have a RawConnection"); return; }; @@ -1523,16 +1514,16 @@ impl GamePacketHandler<'_> { .remove::() .remove::(); - instance_holder.reset(); + world_holder.reset(); }, ); } pub fn entity_position_sync(&mut self, p: &ClientboundEntityPositionSync) { - as_system::<(Commands, Query<(&EntityIdIndex, &InstanceHolder)>)>( + as_system::<(Commands, Query<(&EntityIdIndex, &WorldHolder)>)>( self.ecs, |(mut commands, mut query)| { - let (entity_id_index, instance_holder) = query.get_mut(self.player).unwrap(); + let (entity_id_index, world_holder) = query.get_mut(self.player).unwrap(); let Some(entity) = entity_id_index.get_by_minecraft_entity(p.id) else { debug!("Got teleport entity packet for unknown entity id {}", p.id); @@ -1544,7 +1535,7 @@ impl GamePacketHandler<'_> { let new_look_direction = p.values.look_direction; commands.entity(entity).queue(RelativeEntityUpdate::new( - instance_holder.partial_instance.clone(), + world_holder.partial.clone(), move |entity_mut| { let is_local_entity = entity_mut.get::().is_some(); let mut physics = entity_mut.get_mut::().unwrap(); diff --git a/azalea-client/src/plugins/packet/mod.rs b/azalea-client/src/plugins/packet/mod.rs index 9d842dc6..63a94ee0 100644 --- a/azalea-client/src/plugins/packet/mod.rs +++ b/azalea-client/src/plugins/packet/mod.rs @@ -45,7 +45,7 @@ impl Plugin for PacketPlugin { .add_message::() .add_message::() .add_message::() - .add_message::() + .add_message::() .add_message::(); } } -- cgit v1.2.3