delete azalea-ecs

azalea-rs · mat-1 · Mar 7, 2023 · Mar 6, 2023 · Mar 6, 2023 · Mar 7, 2023
commit 60e0feb10eb4a9d4a5067e7f2844860951ff1c73
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -15,7 +15,6 @@ members = [
   "azalea-buf",
   "azalea-physics",
   "azalea-registry",
-  "azalea-ecs",
 ]
 
 [profile.release]

diff --git a/azalea-client/Cargo.toml b/azalea-client/Cargo.toml
@@ -16,11 +16,12 @@ azalea-block = { path = "../azalea-block", version = "0.6.0" }
 azalea-chat = { path = "../azalea-chat", version = "0.6.0" }
 azalea-core = { path = "../azalea-core", version = "0.6.0" }
 azalea-crypto = { path = "../azalea-crypto", version = "0.6.0" }
-azalea-ecs = { path = "../azalea-ecs", version = "0.6.0" }
 azalea-physics = { path = "../azalea-physics", version = "0.6.0" }
 azalea-protocol = { path = "../azalea-protocol", version = "0.6.0" }
 azalea-registry = { path = "../azalea-registry", version = "0.6.0" }
 azalea-world = { path = "../azalea-world", version = "0.6.0" }
+bevy_app = "0.10.0"
+bevy_ecs = "0.10.0"
 bevy_log = "0.10.0"
 bevy_tasks = "0.10.0"
 bevy_time = "0.10.0"

diff --git a/azalea-client/src/chat.rs b/azalea-client/src/chat.rs
@@ -1,18 +1,18 @@
 //! Implementations of chat-related features.
 
 use azalea_chat::FormattedText;
-use azalea_ecs::{
-    app::{App, Plugin},
-    entity::Entity,
-    event::{EventReader, EventWriter},
-    schedule::{IntoSystemConfig, IntoSystemConfigs},
-};
 use azalea_protocol::packets::game::{
     clientbound_player_chat_packet::ClientboundPlayerChatPacket,
     clientbound_system_chat_packet::ClientboundSystemChatPacket,
     serverbound_chat_command_packet::ServerboundChatCommandPacket,
     serverbound_chat_packet::{LastSeenMessagesUpdate, ServerboundChatPacket},
 };
+use bevy_app::{App, Plugin};
+use bevy_ecs::{
+    entity::Entity,
+    event::{EventReader, EventWriter},
+    schedule::{IntoSystemConfig, IntoSystemConfigs},
+};
 use std::{
     sync::Arc,
     time::{SystemTime, UNIX_EPOCH},

diff --git a/azalea-client/src/client.rs b/azalea-client/src/client.rs
@@ -15,18 +15,6 @@ use crate::{
 
 use azalea_auth::{game_profile::GameProfile, sessionserver::ClientSessionServerError};
 use azalea_chat::FormattedText;
-use azalea_ecs::{
-    app::CoreSchedule,
-    ecs::Ecs,
-    schedule::{LogLevel, ScheduleBuildSettings},
-};
-use azalea_ecs::{
-    app::{App, Plugin, PluginGroup, PluginGroupBuilder},
-    bundle::Bundle,
-    component::Component,
-    entity::Entity,
-    schedule::{IntoSystemConfig, ScheduleLabel},
-};
 use azalea_physics::{PhysicsPlugin, PhysicsSet};
 use azalea_protocol::{
     connect::{Connection, ConnectionError},
@@ -50,7 +38,16 @@ use azalea_protocol::{
 };
 use azalea_world::{
     entity::{EntityPlugin, EntityUpdateSet, Local, WorldName},
-    PartialWorld, World, WorldContainer,
+    Instance, PartialWorld, WorldContainer,
+};
+use bevy_app::{App, CoreSchedule, Plugin, PluginGroup, PluginGroupBuilder};
+use bevy_ecs::{
+    bundle::Bundle,
+    component::Component,
+    entity::Entity,
+    schedule::IntoSystemConfig,
+    schedule::{LogLevel, ScheduleBuildSettings, ScheduleLabel},
+    world::World,
 };
 use bevy_log::LogPlugin;
 use bevy_time::{prelude::FixedTime, TimePlugin};
@@ -90,7 +87,7 @@ pub struct Client {
     /// The entity component system. You probably don't need to access this
     /// directly. Note that if you're using a shared world (i.e. a swarm), this
     /// will contain all entities in all worlds.
-    pub ecs: Arc<Mutex<Ecs>>,
+    pub ecs: Arc<Mutex<World>>,
 
     /// Use this to force the client to run the schedule outside of a tick.
     pub run_schedule_sender: mpsc::UnboundedSender<()>,
@@ -124,7 +121,7 @@ impl Client {
     pub fn new(
         profile: GameProfile,
         entity: Entity,
-        ecs: Arc<Mutex<Ecs>>,
+        ecs: Arc<Mutex<World>>,
         run_schedule_sender: mpsc::UnboundedSender<()>,
     ) -> Self {
         Self {
@@ -184,7 +181,7 @@ impl Client {
     /// Create a [`Client`] when you already have the ECS made with
     /// [`start_ecs`]. You'd usually want to use [`Self::join`] instead.
     pub async fn start_client(
-        ecs_lock: Arc<Mutex<Ecs>>,
+        ecs_lock: Arc<Mutex<World>>,
         account: &Account,
         address: &ServerAddress,
         resolved_address: &SocketAddr,
@@ -230,7 +227,7 @@ impl Client {
             packet_writer_sender,
             // default to an empty world, it'll be set correctly later when we
             // get the login packet
-            Arc::new(RwLock::new(World::default())),
+            Arc::new(RwLock::new(Instance::default())),
             read_packets_task,
             write_packets_task,
         );
@@ -386,13 +383,13 @@ impl Client {
         });
     }
 
-    pub fn local_player<'a>(&'a self, ecs: &'a mut Ecs) -> &'a LocalPlayer {
+    pub fn local_player<'a>(&'a self, ecs: &'a mut World) -> &'a LocalPlayer {
         self.query::<&LocalPlayer>(ecs)
     }
     pub fn local_player_mut<'a>(
         &'a self,
-        ecs: &'a mut Ecs,
-    ) -> azalea_ecs::ecs::Mut<'a, LocalPlayer> {
+        ecs: &'a mut World,
+    ) -> bevy_ecs::world::Mut<'a, LocalPlayer> {
         self.query::<&mut LocalPlayer>(ecs)
     }
 
@@ -420,7 +417,7 @@ impl Client {
     /// client, then it'll be the same as the world the client has loaded.
     /// If the client using a shared world, then the shared world will be a
     /// superset of the client's world.
-    pub fn world(&self) -> Arc<RwLock<World>> {
+    pub fn world(&self) -> Arc<RwLock<Instance>> {
         let world_name = self.component::<WorldName>();
         let ecs = self.ecs.lock();
         let world_container = ecs.resource::<WorldContainer>();
@@ -553,7 +550,7 @@ pub fn start_ecs(
     mut app: App,
     run_schedule_receiver: mpsc::UnboundedReceiver<()>,
     run_schedule_sender: mpsc::UnboundedSender<()>,
-) -> Arc<Mutex<Ecs>> {
+) -> Arc<Mutex<World>> {
     app.setup();
 
     // all resources should have been added by now so we can take the ecs from the
@@ -571,7 +568,7 @@ pub fn start_ecs(
 }
 
 async fn run_schedule_loop(
-    ecs: Arc<Mutex<Ecs>>,
+    ecs: Arc<Mutex<World>>,
     outer_schedule_label: Box<dyn ScheduleLabel>,
     mut run_schedule_receiver: mpsc::UnboundedReceiver<()>,
 ) {

diff --git a/azalea-client/src/disconnect.rs b/azalea-client/src/disconnect.rs
@@ -1,7 +1,7 @@
 //! Disconnect a client from the server.
 
-use azalea_ecs::{
-    app::{App, CoreSet, Plugin},
+use bevy_app::{App, Plugin, CoreSet};
+use bevy_ecs::{
     component::Component,
     entity::Entity,
     event::{EventReader, EventWriter},

diff --git a/azalea-client/src/entity_query.rs b/azalea-client/src/entity_query.rs
@@ -1,10 +1,10 @@
 use std::sync::Arc;
 
-use azalea_ecs::{
+use bevy_ecs::{
     component::Component,
-    ecs::Ecs,
     entity::Entity,
     query::{ROQueryItem, ReadOnlyWorldQuery, WorldQuery},
+    world::World,
 };
 use parking_lot::Mutex;
 
@@ -22,7 +22,7 @@ impl Client {
     ///     .is_some();
     /// # }
     /// ```
-    pub fn query<'w, Q: WorldQuery>(&self, ecs: &'w mut Ecs) -> <Q as WorldQuery>::Item<'w> {
+    pub fn query<'w, Q: WorldQuery>(&self, ecs: &'w mut World) -> <Q as WorldQuery>::Item<'w> {
         ecs.query::<Q>()
             .get_mut(ecs, self.entity)
             .expect("Our client is missing a required component.")
@@ -38,7 +38,7 @@ impl Client {
     /// Note that this will very likely change in the future.
     /// ```
     /// use azalea_client::{Client, GameProfileComponent};
-    /// use azalea_ecs::query::With;
+    /// use bevy_ecs::query::With;
     /// use azalea_world::entity::{Position, metadata::Player};
     ///
     /// # fn example(mut bot: Client, sender_name: String) {
@@ -74,15 +74,15 @@ impl Client {
 }
 
 pub trait EntityPredicate<Q: ReadOnlyWorldQuery, Filter: ReadOnlyWorldQuery> {
-    fn find(&self, ecs_lock: Arc<Mutex<Ecs>>) -> Option<Entity>;
+    fn find(&self, ecs_lock: Arc<Mutex<World>>) -> Option<Entity>;
 }
 impl<F, Q, Filter> EntityPredicate<(Q,), Filter> for F
 where
     F: Fn(&ROQueryItem<Q>) -> bool,
     Q: ReadOnlyWorldQuery,
     Filter: ReadOnlyWorldQuery,
 {
-    fn find(&self, ecs_lock: Arc<Mutex<Ecs>>) -> Option<Entity> {
+    fn find(&self, ecs_lock: Arc<Mutex<World>>) -> Option<Entity> {
         let mut ecs = ecs_lock.lock();
         let mut query = ecs.query_filtered::<(Entity, Q), Filter>();
         let entity = query.iter(&ecs).find(|(_, q)| (self)(q)).map(|(e, _)| e);

diff --git a/azalea-client/src/events.rs b/azalea-client/src/events.rs
@@ -3,17 +3,12 @@
 
 use std::sync::Arc;
 
-use azalea_ecs::{
-    app::{App, CoreSchedule, IntoSystemAppConfig, Plugin},
-    component::Component,
-    event::EventReader,
-    query::Added,
-    system::Query,
-};
 use azalea_protocol::packets::game::{
     clientbound_player_combat_kill_packet::ClientboundPlayerCombatKillPacket, ClientboundGamePacket,
 };
 use azalea_world::entity::MinecraftEntityId;
+use bevy_app::{App, CoreSchedule, IntoSystemAppConfig, Plugin};
+use bevy_ecs::{component::Component, event::EventReader, query::Added, system::Query};
 use derive_more::{Deref, DerefMut};
 use tokio::sync::mpsc;
 

diff --git a/azalea-client/src/lib.rs b/azalea-client/src/lib.rs
@@ -26,7 +26,6 @@ mod player;
 pub mod task_pool;
 
 pub use account::Account;
-pub use azalea_ecs as ecs;
 pub use client::{init_ecs_app, start_ecs, Client, ClientInformation, JoinError};
 pub use events::Event;
 pub use local_player::{GameProfileComponent, LocalPlayer};

diff --git a/azalea-client/src/local_player.rs b/azalea-client/src/local_player.rs
@@ -2,14 +2,13 @@ use std::{collections::HashMap, io, sync::Arc};
 
 use azalea_auth::game_profile::GameProfile;
 use azalea_core::ChunkPos;
-use azalea_ecs::component::Component;
-use azalea_ecs::entity::Entity;
-use azalea_ecs::event::EventReader;
-use azalea_ecs::{query::Added, system::Query};
 use azalea_protocol::packets::game::ServerboundGamePacket;
 use azalea_world::{
     entity::{self, Dead},
-    PartialWorld, World,
+    Instance, PartialWorld,
+};
+use bevy_ecs::{
+    component::Component, entity::Entity, event::EventReader, query::Added, system::Query,
 };
 use derive_more::{Deref, DerefMut};
 use parking_lot::RwLock;
@@ -44,7 +43,7 @@ pub struct LocalPlayer {
     pub partial_world: Arc<RwLock<PartialWorld>>,
     /// The world is the combined [`PartialWorld`]s of all clients in the same
     /// world. (Only relevant if you're using a shared world, i.e. a swarm)
-    pub world: Arc<RwLock<World>>,
+    pub world: Arc<RwLock<Instance>>,
 
     /// A task that reads packets from the server. The client is disconnected
     /// when this task ends.
@@ -88,7 +87,7 @@ impl LocalPlayer {
     pub fn new(
         entity: Entity,
         packet_writer: mpsc::UnboundedSender<ServerboundGamePacket>,
-        world: Arc<RwLock<World>>,
+        world: Arc<RwLock<Instance>>,
         read_packets_task: JoinHandle<()>,
         write_packets_task: JoinHandle<()>,
     ) -> Self {
@@ -129,7 +128,7 @@ impl Drop for LocalPlayer {
 
 /// Update the [`LocalPlayerInLoadedChunk`] component for all [`LocalPlayer`]s.
 pub fn update_in_loaded_chunk(
-    mut commands: azalea_ecs::system::Commands,
+    mut commands: bevy_ecs::system::Commands,
     query: Query<(Entity, &LocalPlayer, &entity::Position)>,
 ) {
     for (entity, local_player, position) in &query {