ClientBuilder::new_without_plugins

Cargo.lock

@@ -177,6 +177,7 @@ dependencies = [
  "azalea-world",
  "bevy_app",
  "bevy_ecs",
+ "bevy_log",
  "bevy_tasks",
  "derive_more",
  "futures",

azalea-client/src/client.rs

@@ -221,7 +221,10 @@ impl Client {
 
         // An event that causes the schedule to run. This is only used internally.
         let (run_schedule_sender, run_schedule_receiver) = mpsc::unbounded_channel();
-        let app = init_ecs_app();
+
+        let mut app = App::new();
+        app.add_plugins(DefaultPlugins);
+
         let ecs_lock = start_ecs(app, run_schedule_receiver, run_schedule_sender.clone());
 
         Self::start_client(
@@ -583,35 +586,10 @@ impl Plugin for AzaleaPlugin {
     }
 }
 
-/// Create the [`App`]. This won't actually run anything yet.
+/// Start running the ECS loop!
 ///
-/// Note that you usually only need this if you're creating a client manually,
-/// otherwise use [`Client::join`].
-///
-/// Use [`start_ecs`] to actually start running the app and then
-/// [`Client::start_client`] to add a client to the ECS and make it join a
-/// server.
-#[doc(hidden)]
-pub fn init_ecs_app() -> App {
-    // if you get an error right here that means you're doing something with locks
-    // wrong read the error to see where the issue is
-    // you might be able to just drop the lock or put it in its own scope to fix
-
-    let mut app = App::new();
-
-    app.edit_schedule(CoreSchedule::Main, |schedule| {
-        schedule.set_build_settings(ScheduleBuildSettings {
-            ambiguity_detection: LogLevel::Warn,
-            ..Default::default()
-        });
-    });
-
-    app.add_plugins(DefaultPlugins);
-    app
-}
-
-/// Start running the ECS loop! You must create your `App` from [`init_ecs_app`]
-/// first.
+/// You can create your app with `App::new()`, but don't forget to add
+/// [`DefaultPlugins`].
 #[doc(hidden)]
 pub fn start_ecs(
     mut app: App,
@@ -698,6 +676,18 @@ impl Plugin for TickBroadcastPlugin {
     }
 }
 
+pub struct AmbiguityLoggerPlugin;
+impl Plugin for AmbiguityLoggerPlugin {
+    fn build(&self, app: &mut App) {
+        app.edit_schedule(CoreSchedule::Main, |schedule| {
+            schedule.set_build_settings(ScheduleBuildSettings {
+                ambiguity_detection: LogLevel::Warn,
+                ..Default::default()
+            });
+        });
+    }
+}
+
 /// This plugin group will add all the default plugins necessary for Azalea to
 /// work.
 pub struct DefaultPlugins;
@@ -706,6 +696,7 @@ impl PluginGroup for DefaultPlugins {
     fn build(self) -> PluginGroupBuilder {
         PluginGroupBuilder::start::<Self>()
             .add(LogPlugin::default())
+            .add(AmbiguityLoggerPlugin)
             .add(TimePlugin::default())
             .add(PacketHandlerPlugin)
             .add(AzaleaPlugin)

azalea-client/src/interact.rs

@@ -73,7 +73,7 @@ pub struct CurrentSequenceNumber(u32);
 #[derive(Component, Clone, Debug, Deref, DerefMut)]
 pub struct HitResultComponent(BlockHitResult);
 
-fn handle_block_interact_event(
+pub fn handle_block_interact_event(
     mut events: EventReader<BlockInteractEvent>,
     mut query: Query<(
         &LocalPlayer,

azalea-client/src/inventory.rs

@@ -628,7 +628,7 @@ fn handle_container_close_event(
 pub struct ClientSideCloseContainerEvent {
     pub entity: Entity,
 }
-fn handle_client_side_close_container_event(
+pub fn handle_client_side_close_container_event(
     mut events: EventReader<ClientSideCloseContainerEvent>,
     mut query: Query<&mut InventoryComponent>,
 ) {
@@ -645,7 +645,7 @@ pub struct ContainerClickEvent {
     pub window_id: u8,
     pub operation: ClickOperation,
 }
-fn handle_container_click_event(
+pub fn handle_container_click_event(
     mut events: EventReader<ContainerClickEvent>,
     mut query: Query<(&mut InventoryComponent, &LocalPlayer)>,
 ) {

azalea-client/src/lib.rs

@@ -30,7 +30,7 @@ pub mod task_pool;
 
 pub use account::{Account, AccountOpts};
 pub use client::{
-    init_ecs_app, start_ecs, Client, ClientInformation, JoinError, JoinedClientBundle, TabList,
+    start_ecs, Client, ClientInformation, DefaultPlugins, JoinError, JoinedClientBundle, TabList,
     TickBroadcast,
 };
 pub use events::Event;

azalea-client/src/respawn.rs

@@ -4,7 +4,7 @@ use azalea_protocol::packets::game::serverbound_client_command_packet::{
 use bevy_app::{App, Plugin};
 use bevy_ecs::prelude::*;
 
-use crate::LocalPlayer;
+use crate::local_player::{handle_send_packet_event, SendPacketEvent};
 
 /// Tell the server that we're respawning.
 #[derive(Debug, Clone)]
@@ -17,22 +17,21 @@ pub struct RespawnPlugin;
 impl Plugin for RespawnPlugin {
     fn build(&self, app: &mut App) {
         app.add_event::<PerformRespawnEvent>()
-            .add_system(perform_respawn);
+            .add_system(perform_respawn.before(handle_send_packet_event));
     }
 }
 
 pub fn perform_respawn(
     mut events: EventReader<PerformRespawnEvent>,
-    mut query: Query<&mut LocalPlayer>,
+    mut send_packets: EventWriter<SendPacketEvent>,
 ) {
     for event in events.iter() {
-        if let Ok(local_player) = query.get_mut(event.entity) {
-            local_player.write_packet(
-                ServerboundClientCommandPacket {
-                    action: serverbound_client_command_packet::Action::PerformRespawn,
-                }
-                .get(),
-            );
-        }
+        send_packets.send(SendPacketEvent {
+            entity: event.entity,
+            packet: ServerboundClientCommandPacket {
+                action: serverbound_client_command_packet::Action::PerformRespawn,
+            }
+            .get(),
+        });
     }
 }

azalea/Cargo.toml

@@ -39,3 +39,4 @@ priority-queue = "1.3.0"
 thiserror = "^1.0.37"
 tokio = "^1.24.2"
 uuid = "1.2.2"
+bevy_log = "0.10.1"

azalea/src/lib.rs

@@ -20,7 +20,7 @@ pub use azalea_core::{BlockPos, Vec3};
 pub use azalea_protocol as protocol;
 pub use azalea_registry::{Block, EntityKind, Item};
 pub use azalea_world::{entity, Instance};
-use bot::DefaultBotPlugins;
+pub use bot::DefaultBotPlugins;
 use ecs::component::Component;
 use futures::Future;
 use protocol::{
@@ -81,16 +81,42 @@ where
     /// Start building a client that can join the world.
     #[must_use]
     pub fn new() -> Self {
+        Self::new_without_plugins()
+            .add_plugins(DefaultPlugins)
+            .add_plugins(DefaultBotPlugins)
+    }
+
+    /// [`Self::new`] but without adding the plugins by default. This is useful
+    /// if you want to disable a default plugin.
+    ///
+    /// You **must** add [`DefaultPlugins`] and [`DefaultBotPlugins`] to this.
+    ///
+    /// ```
+    /// # use azalea::prelude::*;
+    /// use azalea::{app::PluginGroup, DefaultBotPlugins, DefaultPlugins};
+    /// use bevy_log::LogPlugin;
+    ///
+    /// let client = ClientBuilder::new_without_plugins()
+    ///     .add_plugins(DefaultPlugins.build().disable::<LogPlugin>())
+    ///     .add_plugins(DefaultBotPlugins);
+    /// # client.set_handler(handle);
+    /// # #[derive(Component, Clone, Default)]
+    /// # pub struct State;
+    /// # async fn handle(mut bot: Client, event: Event, state: State) -> anyhow::Result<()> {
+    /// #     Ok(())
+    /// # }
+    /// ```
+    #[must_use]
+    pub fn new_without_plugins() -> Self {
         Self {
             // we create the app here so plugins can add onto it.
             // the schedules won't run until [`Self::start`] is called.
-            app: init_ecs_app(),
-
+            app: App::new(),
             handler: None,
             state: S::default(),
         }
-        .add_plugins(DefaultBotPlugins)
     }
+
     /// Set the function that's called every time a bot receives an [`Event`].
     /// This is the way to handle normal per-bot events.
     ///

azalea/src/pathfinder/moves.rs

@@ -15,7 +15,8 @@ fn is_block_passable(pos: &BlockPos, world: &Instance) -> bool {
 /// whether this block has a solid hitbox (i.e. we can stand on it)
 fn is_block_solid(pos: &BlockPos, world: &Instance) -> bool {
     if let Some(block) = world.chunks.get_block_state(pos) {
-        block.shape() == &collision::block_shape()
+        // block.shape() == &collision::block_shape()
+        block.shape() != &collision::empty_shape()
     } else {
         false
     }

azalea/src/swarm/mod.rs

@@ -5,7 +5,9 @@ mod events;
 pub mod prelude;
 
 use crate::{bot::DefaultBotPlugins, HandleFn};
-use azalea_client::{chat::ChatPacket, init_ecs_app, start_ecs, Account, Client, Event, JoinError};
+use azalea_client::{
+    chat::ChatPacket, start_ecs, Account, Client, DefaultPlugins, Event, JoinError,
+};
 use azalea_protocol::{
     connect::ConnectionError,
     resolver::{self, ResolverError},
@@ -83,10 +85,43 @@ where
     /// Start creating the swarm.
     #[must_use]
     pub fn new() -> Self {
+        Self::new_without_plugins()
+            .add_plugins(DefaultPlugins)
+            .add_plugins(DefaultBotPlugins)
+            .add_plugins(DefaultSwarmPlugins)
+    }
+
+    /// [`Self::new`] but without adding the plugins by default. This is useful
+    /// if you want to disable a default plugin.
+    ///
+    /// You **must** add [`DefaultPlugins`], [`DefaultBotPlugins`], and
+    /// [`DefaultSwarmPlugins`] to this.
+    ///
+    /// ```
+    /// # use azalea::{prelude::*, swarm::prelude::*};
+    /// use azalea::{app::PluginGroup, DefaultBotPlugins, DefaultPlugins, swarm::{DefaultSwarmPlugins}};
+    /// use bevy_log::LogPlugin;
+    ///
+    /// let client = SwarmBuilder::new_without_plugins()
+    ///     .add_plugins(DefaultPlugins.build().disable::<LogPlugin>())
+    ///     .add_plugins(DefaultBotPlugins)
+    ///     .add_plugins(DefaultSwarmPlugins);
+    /// # client.set_handler(handle).set_swarm_handler(swarm_handle);
+    /// # #[derive(Component, Resource, Clone, Default)]
+    /// # pub struct State;
+    /// # async fn handle(mut bot: Client, event: Event, state: State) -> anyhow::Result<()> {
+    /// #     Ok(())
+    /// # }
+    /// # async fn swarm_handle(swarm: Swarm, event: SwarmEvent, state: State) -> anyhow::Result<()> {
+    /// #     Ok(())
+    /// # }
+    /// ```
+    #[must_use]
+    pub fn new_without_plugins() -> Self {
         Self {
             // we create the app here so plugins can add onto it.
             // the schedules won't run until [`Self::start`] is called.
-            app: init_ecs_app(),
+            app: App::new(),
 
             accounts: Vec::new(),
             states: Vec::new(),
@@ -95,8 +130,6 @@ where
             swarm_handler: None,
             join_delay: None,
         }
-        .add_plugins(DefaultSwarmPlugins)
-        .add_plugins(DefaultBotPlugins)
     }
 
     /// Add a vec of [`Account`]s to the swarm.