Move login state to the ECS (#213)

* use packet handlers code for login custom_query

* initial broken implementation for ecs-only login

* fixes

* run Update schedule 60 times per second and delete code related to run_schedule_sender

* fix tests

* fix online-mode

* reply to query packets in a separate system and make it easier for plugins to disable individual replies

* remove unused imports

1 files changed, 0 insertions, 114 deletions

diff --git a/azalea-client/src/plugins/packet/login.rs b/azalea-client/src/plugins/packet/login.rs
deleted file mode 100644
index 1bb07266..00000000
--- a/azalea-client/src/plugins/packet/login.rs
+++ /dev/null
@@ -1,114 +0,0 @@
-// login packets aren't actually handled here because compression/encryption
-// would make packet handling a lot messier
-
-use std::{collections::HashSet, sync::Arc};
-
-use azalea_protocol::packets::{
-    Packet,
-    login::{
-        ClientboundLoginPacket, ServerboundLoginPacket,
-        s_custom_query_answer::ServerboundCustomQueryAnswer,
-    },
-};
-use bevy_ecs::{prelude::*, system::SystemState};
-use derive_more::{Deref, DerefMut};
-use tokio::sync::mpsc;
-use tracing::error;
-
-// this struct is defined here anyways though so it's consistent with the other
-// ones
-
-/// An event that's sent when we receive a login packet from the server. Note
-/// that if you want to handle this in a system, you must add
-/// `.before(azalea::packet::login::process_packet_events)` to it
-/// because that system clears the events.
-#[derive(Event, Debug, Clone)]
-pub struct LoginPacketEvent {
-    /// The client entity that received the packet.
-    pub entity: Entity,
-    /// The packet that was actually received.
-    pub packet: Arc<ClientboundLoginPacket>,
-}
-
-/// Event for sending a login packet to the server.
-#[derive(Event)]
-pub struct SendLoginPacketEvent {
-    pub entity: Entity,
-    pub packet: ServerboundLoginPacket,
-}
-impl SendLoginPacketEvent {
-    pub fn new(entity: Entity, packet: impl Packet<ServerboundLoginPacket>) -> Self {
-        let packet = packet.into_variant();
-        Self { entity, packet }
-    }
-}
-
-#[derive(Component)]
-pub struct LoginSendPacketQueue {
-    pub tx: mpsc::UnboundedSender<ServerboundLoginPacket>,
-}
-
-/// A marker component for local players that are currently in the
-/// `login` state.
-#[derive(Component, Clone, Debug)]
-pub struct InLoginState;
-
-pub fn handle_send_packet_event(
-    mut send_packet_events: EventReader<SendLoginPacketEvent>,
-    mut query: Query<&mut LoginSendPacketQueue>,
-) {
-    for event in send_packet_events.read() {
-        if let Ok(queue) = query.get_mut(event.entity) {
-            let _ = queue.tx.send(event.packet.clone());
-        } else {
-            error!("Sent SendPacketEvent for entity that doesn't have a LoginSendPacketQueue");
-        }
-    }
-}
-
-/// Plugins can add to this set if they want to handle a custom query packet
-/// themselves. This component removed after the login state ends.
-#[derive(Component, Default, Debug, Deref, DerefMut)]
-pub struct IgnoreQueryIds(HashSet<u32>);
-
-pub fn process_packet_events(ecs: &mut World) {
-    let mut events_owned = Vec::new();
-    let mut system_state: SystemState<ResMut<Events<LoginPacketEvent>>> = SystemState::new(ecs);
-    let mut events = system_state.get_mut(ecs);
-    for LoginPacketEvent {
-        entity: player_entity,
-        packet,
-    } in events.drain()
-    {
-        // we do this so `ecs` isn't borrowed for the whole loop
-        events_owned.push((player_entity, packet));
-    }
-    for (player_entity, packet) in events_owned {
-        #[allow(clippy::single_match)]
-        match packet.as_ref() {
-            ClientboundLoginPacket::CustomQuery(p) => {
-                let mut system_state: SystemState<(
-                    EventWriter<SendLoginPacketEvent>,
-                    Query<&IgnoreQueryIds>,
-                )> = SystemState::new(ecs);
-                let (mut send_packet_events, query) = system_state.get_mut(ecs);
-
-                let ignore_query_ids = query.get(player_entity).ok().map(|x| x.0.clone());
-                if let Some(ignore_query_ids) = ignore_query_ids {
-                    if ignore_query_ids.contains(&p.transaction_id) {
-                        continue;
-                    }
-                }
-
-                send_packet_events.send(SendLoginPacketEvent::new(
-                    player_entity,
-                    ServerboundCustomQueryAnswer {
-                        transaction_id: p.transaction_id,
-                        data: None,
-                    },
-                ));
-            }
-            _ => {}
-        }
-    }
-}