make it so plugins can send and receive packets during the login state

Author: mat-1

Cargo.lock

@@ -25,7 +25,8 @@ serde = { version = "1.0.192", features = ["derive"] }
 serde_json = "1.0.108"
 thiserror = "1.0.50"
 tokio = { version = "1.34.0", features = ["fs"] }
-uuid = { version = "1.5.0", features = ["serde"] }
+uuid = { version = "1.5.0", features = ["serde", "v3"] }
+md-5 = "0.10.6"
 
 [dev-dependencies]
 env_logger = "0.10.1"

azalea-auth/Cargo.toml

@@ -4,6 +4,7 @@ mod auth;
 pub mod cache;
 pub mod certs;
 pub mod game_profile;
+pub mod offline;
 pub mod sessionserver;
 
 pub use auth::*;

azalea-auth/src/lib.rs

@@ -0,0 +1,17 @@
+use md5::{Digest, Md5};
+use uuid::Uuid;
+
+pub fn generate_uuid(username: &str) -> Uuid {
+    uuid::Builder::from_md5_bytes(hash(format!("OfflinePlayer:{username}").as_bytes())).into_uuid()
+}
+
+fn hash(data: &[u8]) -> [u8; 16] {
+    let mut hasher = Md5::new();
+
+    hasher.update(data);
+
+    let mut bytes = [0; 16];
+    bytes.copy_from_slice(&hasher.finalize()[..16]);
+
+    bytes
+}

azalea-auth/src/offline.rs

@@ -200,6 +200,13 @@ impl Account {
             }
         }
     }
+
+    /// Get the UUID of this account. This will generate an offline-mode UUID
+    /// by making a hash with the username if the `uuid` field is None.
+    pub fn uuid_or_offline(&self) -> Uuid {
+        self.uuid
+            .unwrap_or_else(|| azalea_auth::offline::generate_uuid(&self.username))
+    }
 }
 
 #[derive(Error, Debug)]
@@ -226,3 +233,5 @@ impl Account {
         Ok(())
     }
 }
+
+fn uuid_from_username() {}

azalea-client/src/account.rs

@@ -13,11 +13,8 @@ use bevy_ecs::prelude::*;
 use derive_more::{Deref, DerefMut};
 
 use crate::{
-    interact::SwingArmEvent,
-    local_player::{LocalGameMode, SendPacketEvent},
-    movement::MoveEventsSet,
-    respawn::perform_respawn,
-    Client,
+    interact::SwingArmEvent, local_player::LocalGameMode, movement::MoveEventsSet,
+    packet_handling::game::SendPacketEvent, respawn::perform_respawn, Client,
 };
 
 pub struct AttackPlugin;

azalea-client/src/attack.rs

@@ -22,7 +22,7 @@ use uuid::Uuid;
 
 use crate::{
     client::Client,
-    local_player::{handle_send_packet_event, SendPacketEvent},
+    packet_handling::game::{handle_send_packet_event, SendPacketEvent},
 };
 
 /// A chat packet, either a system message or a chat message.

azalea-client/src/chat.rs

@@ -21,7 +21,7 @@ use tracing::{error, trace};
 use crate::{
     interact::handle_block_interact_event,
     inventory::InventorySet,
-    local_player::{handle_send_packet_event, SendPacketEvent},
+    packet_handling::game::{handle_send_packet_event, SendPacketEvent},
     respawn::perform_respawn,
     InstanceHolder,
 };

azalea-client/src/chunks.rs

@@ -7,12 +7,16 @@ use crate::{
     interact::{CurrentSequenceNumber, InteractPlugin},
     inventory::{InventoryComponent, InventoryPlugin},
     local_player::{
-        death_event, handle_send_packet_event, GameProfileComponent, Hunger, InstanceHolder,
-        PermissionLevel, PlayerAbilities, SendPacketEvent, TabList,
+        death_event, GameProfileComponent, Hunger, InstanceHolder, PermissionLevel,
+        PlayerAbilities, TabList,
     },
     mining::{self, MinePlugin},
     movement::{LastSentLookDirection, PhysicsState, PlayerMovePlugin},
-    packet_handling::PacketHandlerPlugin,
+    packet_handling::{
+        game::{handle_send_packet_event, SendPacketEvent},
+        login::{self, LoginSendPacketQueue},
+        PacketHandlerPlugin,
+    },
     player::retroactively_add_game_profile_component,
     raw_connection::RawConnection,
     respawn::RespawnPlugin,
@@ -35,6 +39,7 @@ use azalea_protocol::{
     packets::{
         configuration::{
             serverbound_client_information_packet::ClientInformation,
+            serverbound_custom_payload_packet::ServerboundCustomPayloadPacket,
             ClientboundConfigurationPacket, ServerboundConfigurationPacket,
         },
         game::ServerboundGamePacket,
@@ -208,21 +213,43 @@ impl Client {
         resolved_address: &SocketAddr,
         run_schedule_sender: mpsc::UnboundedSender<()>,
     ) -> Result<(Self, mpsc::UnboundedReceiver<Event>), JoinError> {
+        // check if an entity with our uuid already exists in the ecs and if so then
+        // just use that
+        let entity = {
+            let mut ecs = ecs_lock.lock();
+
+            let entity_uuid_index = ecs.resource::<EntityUuidIndex>();
+            let uuid = account.uuid_or_offline();
+            if let Some(entity) = entity_uuid_index.get(&account.uuid_or_offline()) {
+                debug!("Reusing entity {entity:?} for client");
+                entity
+            } else {
+                let entity = ecs.spawn_empty().id();
+                debug!("Created new entity {entity:?} for client");
+                // add to the uuid index
+                let mut entity_uuid_index = ecs.resource_mut::<EntityUuidIndex>();
+                entity_uuid_index.insert(uuid, entity);
+                entity
+            }
+        };
+
         let conn = Connection::new(resolved_address).await?;
-        let (mut conn, game_profile) = Self::handshake(conn, account, address).await?;
+        let (mut conn, game_profile) =
+            Self::handshake(ecs_lock.clone(), entity, conn, account, address).await?;
 
         {
             // quickly send the brand here
             let mut brand_data = Vec::new();
             // they don't have to know :)
             "vanilla".write_into(&mut brand_data).unwrap();
             conn.write(
-        azalea_protocol::packets::configuration::serverbound_custom_payload_packet::ServerboundCustomPayloadPacket {
+                ServerboundCustomPayloadPacket {
                     identifier: ResourceLocation::new("brand"),
                     data: brand_data.into(),
                 }
                 .get(),
-            ).await?;
+            )
+            .await?;
         }
 
         let (read_conn, write_conn) = conn.into_split();
@@ -234,22 +261,6 @@ impl Client {
 
         let mut ecs = ecs_lock.lock();
 
-        // check if an entity with our uuid already exists in the ecs and if so then
-        // just use that
-        let entity = {
-            let entity_uuid_index = ecs.resource::<EntityUuidIndex>();
-            if let Some(entity) = entity_uuid_index.get(&game_profile.uuid) {
-                debug!("Reusing entity {entity:?} for client");
-                entity
-            } else {
-                let entity = ecs.spawn_empty().id();
-                debug!("Created new entity {entity:?} for client");
-                // add to the uuid index
-                let mut entity_uuid_index = ecs.resource_mut::<EntityUuidIndex>();
-                entity_uuid_index.insert(game_profile.uuid, entity);
-                entity
-            }
-        };
         // we got the ConfigurationConnection, so the client is now connected :)
         let client = Client::new(
             game_profile.clone(),
@@ -284,6 +295,8 @@ impl Client {
     /// This will also automatically refresh the account's access token if
     /// it's expired.
     pub async fn handshake(
+        ecs_lock: Arc<Mutex<World>>,
+        entity: Entity,
         mut conn: Connection<ClientboundHandshakePacket, ServerboundHandshakePacket>,
         account: &Account,
         address: &ServerAddress,
@@ -307,6 +320,14 @@ impl Client {
         .await?;
         let mut conn = conn.login();
 
+        // this makes it so plugins can send an `SendLoginPacketEvent` event to the ecs
+        // and we'll send it to the server
+        let (ecs_packets_tx, mut ecs_packets_rx) = mpsc::unbounded_channel();
+        ecs_lock
+            .lock()
+            .entity_mut(entity)
+            .insert(LoginSendPacketQueue { tx: ecs_packets_tx });
+
         // login
         conn.write(
             ServerboundHelloPacket {
@@ -320,7 +341,20 @@ impl Client {
         .await?;
 
         let (conn, profile) = loop {
-            let packet = conn.read().await?;
+            let packet = tokio::select! {
+                packet = conn.read() => packet?,
+                Some(packet) = ecs_packets_rx.recv() => {
+                    // write this packet to the server
+                    conn.write(packet).await?;
+                    continue;
+                }
+            };
+
+            ecs_lock.lock().send_event(login::LoginPacketEvent {
+                entity,
+                packet: Arc::new(packet.clone()),
+            });
+
             match packet {
                 ClientboundLoginPacket::Hello(p) => {
                     debug!("Got encryption request");
@@ -655,7 +689,7 @@ impl Plugin for AzaleaPlugin {
 /// [`DefaultPlugins`].
 #[doc(hidden)]
 pub fn start_ecs_runner(
-    mut app: App,
+    app: App,
     run_schedule_receiver: mpsc::UnboundedReceiver<()>,
     run_schedule_sender: mpsc::UnboundedSender<()>,
 ) -> Arc<Mutex<World>> {

azalea-client/src/client.rs

@@ -34,10 +34,9 @@ use tracing::warn;
 use crate::{
     attack::handle_attack_event,
     inventory::{InventoryComponent, InventorySet},
-    local_player::{
-        handle_send_packet_event, LocalGameMode, PermissionLevel, PlayerAbilities, SendPacketEvent,
-    },
+    local_player::{LocalGameMode, PermissionLevel, PlayerAbilities},
     movement::MoveEventsSet,
+    packet_handling::game::{handle_send_packet_event, SendPacketEvent},
     respawn::perform_respawn,
     Client,
 };

azalea-client/src/interact.rs

@@ -26,7 +26,8 @@ use bevy_ecs::{
 use tracing::warn;
 
 use crate::{
-    local_player::{handle_send_packet_event, PlayerAbilities, SendPacketEvent},
+    local_player::PlayerAbilities,
+    packet_handling::game::{handle_send_packet_event, SendPacketEvent},
     respawn::perform_respawn,
     Client,
 };

azalea-client/src/inventory.rs

@@ -36,7 +36,7 @@ pub use client::{
     start_ecs_runner, Client, DefaultPlugins, JoinError, JoinedClientBundle, TickBroadcast,
 };
 pub use events::Event;
-pub use local_player::{GameProfileComponent, InstanceHolder, SendPacketEvent, TabList};
+pub use local_player::{GameProfileComponent, InstanceHolder, TabList};
 pub use movement::{
     PhysicsState, SprintDirection, StartSprintEvent, StartWalkEvent, WalkDirection,
 };

azalea-client/src/lib.rs

@@ -160,24 +160,3 @@ impl<T> From<std::sync::PoisonError<T>> for HandlePacketError {
         HandlePacketError::Poison(e.to_string())
     }
 }
-
-/// Event for sending a packet to the server.
-#[derive(Event)]
-pub struct SendPacketEvent {
-    pub entity: Entity,
-    pub packet: ServerboundGamePacket,
-}
-
-pub fn handle_send_packet_event(
-    mut send_packet_events: EventReader<SendPacketEvent>,
-    mut query: Query<&mut RawConnection>,
-) {
-    for event in send_packet_events.read() {
-        if let Ok(raw_connection) = query.get_mut(event.entity) {
-            // debug!("Sending packet: {:?}", event.packet);
-            if let Err(e) = raw_connection.write_packet(event.packet.clone()) {
-                error!("Failed to send packet: {e}");
-            }
-        }
-    }
-}

azalea-client/src/local_player.rs

@@ -17,8 +17,9 @@ use crate::{
         HitResultComponent, SwingArmEvent,
     },
     inventory::{InventoryComponent, InventorySet},
-    local_player::{LocalGameMode, PermissionLevel, PlayerAbilities, SendPacketEvent},
+    local_player::{LocalGameMode, PermissionLevel, PlayerAbilities},
     movement::MoveEventsSet,
+    packet_handling::game::SendPacketEvent,
     Client,
 };
 

azalea-client/src/mining.rs

@@ -1,5 +1,5 @@
 use crate::client::Client;
-use crate::local_player::SendPacketEvent;
+use crate::packet_handling::game::SendPacketEvent;
 use azalea_core::position::Vec3;
 use azalea_entity::{metadata::Sprinting, Attributes, Jumping};
 use azalea_entity::{InLoadedChunk, LastSentPosition, LookDirection, Physics, Position};

azalea-client/src/movement.rs

@@ -22,7 +22,7 @@ use crate::packet_handling::game::KeepAliveEvent;
 use crate::raw_connection::RawConnection;
 
 #[derive(Event, Debug, Clone)]
-pub struct PacketEvent {
+pub struct ConfigurationPacketEvent {
     /// The client entity that received the packet.
     pub entity: Entity,
     /// The packet that was actually received.
@@ -31,7 +31,7 @@ pub struct PacketEvent {
 
 pub fn send_packet_events(
     query: Query<(Entity, &RawConnection), With<InConfigurationState>>,
-    mut packet_events: ResMut<Events<PacketEvent>>,
+    mut packet_events: ResMut<Events<ConfigurationPacketEvent>>,
 ) {
     // we manually clear and send the events at the beginning of each update
     // since otherwise it'd cause issues with events in process_packet_events
@@ -51,7 +51,7 @@ pub fn send_packet_events(
                         continue;
                     }
                 };
-                packet_events.send(PacketEvent {
+                packet_events.send(ConfigurationPacketEvent {
                     entity: player_entity,
                     packet,
                 });
@@ -64,9 +64,10 @@ pub fn send_packet_events(
 
 pub fn process_packet_events(ecs: &mut World) {
     let mut events_owned = Vec::new();
-    let mut system_state: SystemState<EventReader<PacketEvent>> = SystemState::new(ecs);
+    let mut system_state: SystemState<EventReader<ConfigurationPacketEvent>> =
+        SystemState::new(ecs);
     let mut events = system_state.get_mut(ecs);
-    for PacketEvent {
+    for ConfigurationPacketEvent {
         entity: player_entity,
         packet,
     } in events.read()