0.16.0 - Update to 1.21.11

Author: ShayBox

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "shaysbot"
-version = "0.15.22"
+version = "0.16.0"
 authors = ["Shayne Hartford <shaybox@shaybox.com>"]
 edition = "2024"
 description = "My personal Minecraft bot using Azalea"
@@ -20,7 +20,7 @@ ncr = { git = "https://github.com/Shays-Forks/ncr-rs", rev = "4004292" }
 
 [dependencies]
 anyhow = "1"
-azalea = { git = "https://github.com/azalea-rs/azalea", default-features = false, features = ["packet-event", "serde"] }
+azalea = { git = "https://github.com/azalea-rs/azalea", default-features = false, features = ["packet-event", "serde", "online-mode"] }
 azalea-viaversion = { git = "https://github.com/azalea-rs/azalea-viaversion", optional = true }
 #azalea-viaversion = { path = "../azalea-viaversion", optional = true }
 base64 = "0.22"

Cargo.toml

@@ -24,21 +24,21 @@ pub mod trackers;
 
 use std::{collections::HashMap, sync::Arc, time::Duration};
 
-use anyhow::{Result, bail};
+use anyhow::{bail, Result};
 use azalea::{
-    DefaultPlugins,
-    app::{AppExit, PluginGroup, PluginGroupBuilder},
+    app::{PluginGroup, PluginGroupBuilder},
     bot::DefaultBotPlugins,
     ecs::prelude::*,
     pong::PongPlugin,
     prelude::*,
-    swarm::{DefaultSwarmPlugins, prelude::*},
+    swarm::{prelude::*, DefaultSwarmPlugins},
+    DefaultPlugins,
 };
 #[cfg(feature = "via")]
 use azalea_viaversion::ViaVersionPlugin;
-use bevy_discord::DiscordBotPlugin;
 #[cfg(feature = "bot")]
 use bevy_discord::config::DiscordBotConfig;
+use bevy_discord::DiscordBotPlugin;
 use parking_lot::RwLock;
 use semver::Version;
 #[cfg(feature = "bot")]
@@ -135,10 +135,9 @@ pub async fn start() -> Result<()> {
         client = client.add_plugins(ViaVersionPlugin::start(&global_settings.server_version).await);
     }
 
-    if let AppExit::Error(error) = client.start(global_settings.server_address).await? {
-        bail!(error)
-    }
-
+    client
+        .start(global_settings.server_address.to_string())
+        .await;
     Ok(())
 }
 
@@ -178,13 +177,7 @@ pub async fn swarm_handler(swarm: Swarm, event: SwarmEvent, state: SwarmState) -
             }
 
             info!("AutoReconnecting on {}", account.username);
-            if let Err(reason) = swarm.add_with_opts(account, state.clone(), join_opts).await {
-                warn!("[{bot_name}] Failed to AutoReconnect: {reason}");
-                info!("[{bot_name}] AutoReconnecting in 30s...");
-
-                state.auto_reconnect.write().entry(bot_name).or_default().1 = 30;
-                continue;
-            }
+            swarm.add_with_opts(account, state.clone(), join_opts).await;
 
             break;
         },

src/lib.rs

@@ -3,24 +3,23 @@ use std::{cmp::Ordering, collections::HashMap, sync::LazyLock};
 use azalea::{
     app::{App, Plugin},
     ecs::prelude::*,
-    entity::{LocalEntity, LookDirection, metadata::Player},
+    entity::{inventory::Inventory, metadata::Player, LocalEntity, LookDirection},
     inventory::{
+        operations::{ClickOperation, SwapClick},
         ContainerClickEvent,
-        Inventory,
         InventorySystems,
-        operations::{ClickOperation, SwapClick},
     },
     local_player::Hunger,
     mining::continue_mining_block,
-    packet::game::{SendGamePacketEvent, handle_outgoing_packets_observer},
+    packet::game::{handle_outgoing_packets_observer, SendGamePacketEvent},
     physics::PhysicsSystems,
     prelude::*,
     protocol::packets::game::{
+        s_interact::InteractionHand,
         ServerboundGamePacket,
         ServerboundUseItem,
-        s_interact::InteractionHand,
     },
-    registry::Item,
+    registry::builtin::ItemKind,
 };
 
 use crate::prelude::*;
@@ -119,41 +118,41 @@ impl AutoEatPlugin {
     }
 }
 
-pub static FOOD_ITEMS: LazyLock<HashMap<Item, (i32, f32)>> = LazyLock::new(|| {
+pub static FOOD_ITEMS: LazyLock<HashMap<ItemKind, (i32, f32)>> = LazyLock::new(|| {
     HashMap::from([
-        (Item::Apple, (4, 2.4)),
-        (Item::BakedPotato, (5, 6.0)),
-        (Item::Beef, (3, 1.8)),
-        (Item::Beetroot, (1, 1.2)),
-        (Item::BeetrootSoup, (6, 7.2)),
-        (Item::Bread, (5, 6.0)),
-        (Item::Carrot, (3, 3.6)),
-        (Item::Chicken, (2, 1.2)),
-        (Item::Cod, (2, 0.4)),
-        (Item::CookedBeef, (8, 12.8)),
-        (Item::CookedChicken, (6, 7.2)),
-        (Item::CookedCod, (5, 6.0)),
-        (Item::CookedMutton, (6, 9.6)),
-        (Item::CookedPorkchop, (8, 12.8)),
-        (Item::CookedRabbit, (5, 6.0)),
-        (Item::CookedSalmon, (6, 9.6)),
-        (Item::Cookie, (2, 0.4)),
-        (Item::DriedKelp, (1, 0.6)),
-        (Item::EnchantedGoldenApple, (4, 9.6)),
-        (Item::GlowBerries, (2, 0.4)),
-        (Item::GoldenApple, (4, 9.6)),
-        (Item::GoldenCarrot, (6, 14.4)),
-        (Item::HoneyBottle, (6, 1.2)),
-        (Item::MelonSlice, (2, 1.2)),
-        (Item::MushroomStew, (6, 7.2)),
-        (Item::Mutton, (2, 1.2)),
-        (Item::Porkchop, (3, 1.8)),
-        (Item::Potato, (1, 0.6)),
-        (Item::PumpkinPie, (8, 4.8)),
-        (Item::Rabbit, (3, 1.8)),
-        (Item::RabbitStew, (10, 12.0)),
-        (Item::Salmon, (2, 0.4)),
-        (Item::SweetBerries, (2, 0.4)),
-        (Item::TropicalFish, (1, 0.2)),
+        (ItemKind::Apple, (4, 2.4)),
+        (ItemKind::BakedPotato, (5, 6.0)),
+        (ItemKind::Beef, (3, 1.8)),
+        (ItemKind::Beetroot, (1, 1.2)),
+        (ItemKind::BeetrootSoup, (6, 7.2)),
+        (ItemKind::Bread, (5, 6.0)),
+        (ItemKind::Carrot, (3, 3.6)),
+        (ItemKind::Chicken, (2, 1.2)),
+        (ItemKind::Cod, (2, 0.4)),
+        (ItemKind::CookedBeef, (8, 12.8)),
+        (ItemKind::CookedChicken, (6, 7.2)),
+        (ItemKind::CookedCod, (5, 6.0)),
+        (ItemKind::CookedMutton, (6, 9.6)),
+        (ItemKind::CookedPorkchop, (8, 12.8)),
+        (ItemKind::CookedRabbit, (5, 6.0)),
+        (ItemKind::CookedSalmon, (6, 9.6)),
+        (ItemKind::Cookie, (2, 0.4)),
+        (ItemKind::DriedKelp, (1, 0.6)),
+        (ItemKind::EnchantedGoldenApple, (4, 9.6)),
+        (ItemKind::GlowBerries, (2, 0.4)),
+        (ItemKind::GoldenApple, (4, 9.6)),
+        (ItemKind::GoldenCarrot, (6, 14.4)),
+        (ItemKind::HoneyBottle, (6, 1.2)),
+        (ItemKind::MelonSlice, (2, 1.2)),
+        (ItemKind::MushroomStew, (6, 7.2)),
+        (ItemKind::Mutton, (2, 1.2)),
+        (ItemKind::Porkchop, (3, 1.8)),
+        (ItemKind::Potato, (1, 0.6)),
+        (ItemKind::PumpkinPie, (8, 4.8)),
+        (ItemKind::Rabbit, (3, 1.8)),
+        (ItemKind::RabbitStew, (10, 12.0)),
+        (ItemKind::Salmon, (2, 0.4)),
+        (ItemKind::SweetBerries, (2, 0.4)),
+        (ItemKind::TropicalFish, (1, 0.2)),
     ])
 });

src/modules/auto_eat.rs

@@ -5,17 +5,21 @@ use azalea::{
     attack::AttackEvent,
     bot::LookAtEvent,
     ecs::prelude::*,
-    entity::{Position, dimensions::EntityDimensions, metadata::AbstractMonster},
+    entity::{
+        dimensions::EntityDimensions,
+        inventory::Inventory,
+        metadata::AbstractMonster,
+        Position,
+    },
     inventory::{
-        ContainerClickEvent,
-        Inventory,
         operations::{ClickOperation, SwapClick},
+        ContainerClickEvent,
     },
     nearest_entity::EntityFinder,
     pathfinder::Pathfinder,
     physics::PhysicsSystems,
     prelude::*,
-    registry::Item,
+    registry::builtin::ItemKind,
 };
 
 use crate::prelude::*;
@@ -111,19 +115,19 @@ impl AutoKillPlugin {
     }
 }
 
-pub static WEAPON_ITEMS: LazyLock<HashMap<Item, i32>> = LazyLock::new(|| {
+pub static WEAPON_ITEMS: LazyLock<HashMap<ItemKind, i32>> = LazyLock::new(|| {
     HashMap::from([
-        (Item::DiamondAxe, 9),
-        (Item::DiamondSword, 7),
-        (Item::GoldenAxe, 7),
-        (Item::GoldenSword, 4),
-        (Item::IronAxe, 9),
-        (Item::IronSword, 6),
-        (Item::NetheriteAxe, 10),
-        (Item::NetheriteSword, 8),
-        (Item::StoneAxe, 9),
-        (Item::StoneSword, 5),
-        (Item::WoodenAxe, 7),
-        (Item::WoodenSword, 4),
+        (ItemKind::DiamondAxe, 9),
+        (ItemKind::DiamondSword, 7),
+        (ItemKind::GoldenAxe, 7),
+        (ItemKind::GoldenSword, 4),
+        (ItemKind::IronAxe, 9),
+        (ItemKind::IronSword, 6),
+        (ItemKind::NetheriteAxe, 10),
+        (ItemKind::NetheriteSword, 8),
+        (ItemKind::StoneAxe, 9),
+        (ItemKind::StoneSword, 5),
+        (ItemKind::WoodenAxe, 7),
+        (ItemKind::WoodenSword, 4),
     ])
 });

src/modules/auto_kill.rs

@@ -1,5 +1,4 @@
 use azalea::{
-    FormattedText,
     app::{App, Plugin, Update},
     auto_reconnect::start_rejoin_on_disconnect,
     connection::RawConnection,
@@ -10,7 +9,8 @@ use azalea::{
     packet::game::{GamePingEvent, ReceiveGamePacketEvent, SendGamePacketEvent},
     player::GameProfileComponent,
     protocol::packets::game::{ClientboundGamePacket, ServerboundPong},
-    registry::EntityKind,
+    registry::builtin::EntityKind,
+    FormattedText,
 };
 use itertools::Itertools;
 

src/modules/auto_leave.rs

@@ -1,15 +1,15 @@
 use azalea::{
     app::{App, Plugin},
     ecs::prelude::*,
+    entity::inventory::Inventory,
     inventory::{
-        ContainerClickEvent,
-        Inventory,
-        Menu,
         handle_container_click_event,
         operations::{ClickOperation, SwapClick},
+        ContainerClickEvent,
+        Menu,
     },
     prelude::*,
-    registry::Item,
+    registry::builtin::ItemKind,
 };
 
 use crate::prelude::*;
@@ -43,13 +43,13 @@ impl AutoTotemPlugin {
                 continue;
             };
 
-            if player.offhand.kind() == Item::TotemOfUndying {
+            if player.offhand.kind() == ItemKind::TotemOfUndying {
                 continue;
             }
 
             let Some(index) = inventory.menu().slots()[8..]
                 .iter()
-                .position(|slot| slot.kind() == Item::TotemOfUndying)
+                .position(|slot| slot.kind() == ItemKind::TotemOfUndying)
                 .and_then(|index| u16::try_from(index + 8).ok())
             else {
                 continue;

src/modules/auto_totem.rs

@@ -2,7 +2,7 @@ use azalea::{
     app::{App, Plugin, Update},
     packet::game::ReceiveGamePacketEvent,
     protocol::packets::game::ClientboundGamePacket,
-    registry::EntityKind,
+    registry::builtin::EntityKind,
 };
 
 use crate::prelude::*;

src/modules/auto_whitelist.rs

@@ -1,14 +1,14 @@
 use azalea::{
     app::{App, Plugin, Update},
-    blocks::BlockTrait,
+    block::BlockTrait,
     disconnect::DisconnectEvent,
     ecs::prelude::*,
     local_player::TabList,
     packet::{game::ReceiveGamePacketEvent, login::ReceiveLoginPacketEvent},
     player::GameProfileComponent,
     prelude::*,
     protocol::packets::game::ClientboundGamePacket,
-    registry::EntityKind,
+    registry::builtin::EntityKind,
 };
 use bevy_discord::res::DiscordHttpResource;
 use serenity::{
@@ -371,5 +371,5 @@ pub async fn send_message(content: impl ToString, channel_id: ChannelId, client:
 
     if let Err(error) = client.send_message(channel_id, vec![], &map).await {
         error!("{error}");
-    };
+    }
 }

src/modules/discord_logger.rs

@@ -8,13 +8,11 @@ use std::{
 use anyhow::Result;
 use azalea::{
     app::{App, Plugin, Update},
-    chat::{ChatKind, ChatReceivedEvent, handle_send_chat_event, handler::SendChatKindEvent},
+    chat::{handle_send_chat_event, handler::SendChatKindEvent, ChatKind, ChatReceivedEvent},
     ecs::prelude::*,
     local_player::TabList,
 };
 use ncr::{
-    AesKey,
-    NcrError,
     encoding::{
         Base64Encoding,
         Base64rEncoding,
@@ -25,6 +23,8 @@ use ncr::{
     },
     encryption::{Cfb8Encryption, EcbEncryption, Encryption, GcmEncryption},
     utils::{prepend_header, trim_header},
+    AesKey,
+    NcrError,
 };
 
 use crate::prelude::*;
@@ -152,11 +152,10 @@ impl MinecraftParserPlugin {
             };
 
             info!("Command Response: {}", event.content);
-            if local_settings.anti_spam.enabled {
-                if let Ok(duration) = SystemTime::now().duration_since(UNIX_EPOCH) {
+            if local_settings.anti_spam.enabled
+                && let Ok(duration) = SystemTime::now().duration_since(UNIX_EPOCH) {
                     let _ = write!(event.content, " [{}]", duration.as_secs());
                 }
-            }
 
             try_encrypt(&mut event.content, &settings.chat, type_encryption);
             chat_kind_events.write(SendChatKindEvent {
@@ -252,11 +251,10 @@ pub fn find_encryption(content: &str, key: &AesKey) -> (Option<EncryptionType>,
         ];
 
         for encryptor in encryptors {
-            if let Ok(plaintext) = encryptor.decrypt(content, key) {
-                if let Ok(trimmed) = trim_header(&plaintext) {
+            if let Ok(plaintext) = encryptor.decrypt(content, key)
+                && let Ok(trimmed) = trim_header(&plaintext) {
                     return (Some(encryptor), String::from(trimmed));
                 }
-            }
         }
     }
 
@@ -279,9 +277,9 @@ pub fn try_encrypt(
         if let Ok(ciphertext) = encryption.encrypt(&plaintext, &key) {
             *content = ciphertext;
         }
-    } else if chat_encryption.mode == EncryptionMode::Always {
-        if let Ok(ciphertext) = Cfb8Encryption(NewBase64rEncoding).encrypt(&plaintext, &key) {
-            *content = ciphertext;
-        }
+    } else if chat_encryption.mode == EncryptionMode::Always
+        && let Ok(ciphertext) = Cfb8Encryption(NewBase64rEncoding).encrypt(&plaintext, &key)
+    {
+        *content = ciphertext;
     }
 }