chore(deps): update azalea

refactor!(matrix): move options into a table
refactor: expand a few variable names
2025-03-20 18:32:07 -04:00 · 2025-03-20 18:32:06 -04:00 · 2025-03-20 18:32:03 -04:00
51 changed files with 2006 additions and 3528 deletions
--- a/.envrc
+++ b/.envrc
@@ -1 +0,0 @@
-use flake
--- a/.github/dependabot.yaml
+++ b/.github/dependabot.yaml
@@ -1,17 +0,0 @@
-version: 2
-
-updates:
-    - package-ecosystem: "cargo"
-      directory: "/"
-      schedule:
-          interval: "monthly"
-
-    - package-ecosystem: "nix"
-      directory: "/"
-      schedule:
-          interval: "monthly"
-
-    - package-ecosystem: "github-actions"
-      directory: ".github/workflows"
-      schedule:
-          interval: "monthly"
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -24,13 +24,13 @@ jobs:

        steps:
            - name: Clone repository
-              uses: actions/checkout@v6
+              uses: actions/checkout@v4

            - name: Install build dependencies
              run: sudo apt install -y libluajit-5.1-dev mold

            - name: Set up build cache
-              uses: actions/cache@v5
+              uses: actions/cache@v4
              with:
                  path: |
                      ~/.cargo/bin/
@@ -46,7 +46,7 @@ jobs:
            - run: cargo build --release ${{ matrix.feature.flags }}

            - name: Upload build artifacts
-              uses: actions/upload-artifact@v7
+              uses: actions/upload-artifact@v4
              with:
                  name: errornowatcher_${{ matrix.feature.name }}_${{ matrix.os }}
                  path: target/release/errornowatcher
--- a/.github/workflows/lint.yaml
+++ b/.github/workflows/lint.yaml
@@ -15,7 +15,7 @@ jobs:

        steps:
            - name: Clone repository
-              uses: actions/checkout@v6
+              uses: actions/checkout@v4

            - name: Install taplo
              uses: uncenter/setup-taplo@v1
@@ -47,13 +47,13 @@ jobs:

        steps:
            - name: Clone repository
-              uses: actions/checkout@v6
+              uses: actions/checkout@v4

            - name: Install build dependencies
              run: sudo apt install -y libluajit-5.1-dev mold

            - name: Set up build cache
-              uses: actions/cache@v5
+              uses: actions/cache@v4
              with:
                  path: |
                      ~/.cargo/bin/
@@ -69,7 +69,7 @@ jobs:
            - name: Install components
              run: rustup component add clippy rustfmt

-            - run: cargo clippy ${{ matrix.feature.flags }} -- -D clippy::pedantic
+            - run: cargo clippy ${{ matrix.feature.flags }} -- -D warnings -D clippy::pedantic

            - if: always()
              run: cargo fmt --check
--- a/.gitignore
+++ b/.gitignore
@@ -1,13 +1,2 @@
 .luarc.json
 target
-
-# Devenv
-.devenv*
-devenv.local.nix
-devenv.local.yaml
-
-# direnv
-.direnv
-
-# pre-commit
-.pre-commit-config.yaml
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,48 +15,37 @@ codegen-units = 1
 lto = true
 strip = true

-[profile.release-no-lto]
-inherits = "release"
-lto = false
-
-[profile.small]
-inherits = "release"
-opt-level = "z"
-
 [build-dependencies]
-built = { version = "0", features = ["git2"] }
+built = { git = "https://github.com/lukaslueg/built", features = ["git2"] }

 [dependencies]
 anyhow = "1"
-azalea = "0"
+azalea = { git = "https://github.com/azalea-rs/azalea" }
 bevy_app = "0"
 bevy_ecs = "0"
 bevy_log = "0"
 clap = { version = "4", features = ["derive", "string"] }
 console-subscriber = { version = "0", optional = true }
-ctrlc = "3"
+ctrlc = { version = "3", features = ["termination"] }
 dirs = { version = "6", optional = true }
 futures = "0"
 futures-locks = "0"
 http-body-util = "0"
 hyper = { version = "1", features = ["server"] }
 hyper-util = "0"
-log = "0"
+log = { version = "0" }
 matrix-sdk = { version = "0", features = ["anyhow"], optional = true }
 mimalloc = { version = "0", optional = true }
 mlua = { version = "0", features = ["async", "luajit", "send"] }
 ncr = { version = "0", features = ["cfb8", "ecb", "gcm"] }
 parking_lot = "0"
-serde = "1"
+serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-tokio = { version = "1", features = ["full"] }
-zip = { version = "8", default-features = false, features = [
-  "deflate",
-], optional = true }
+tokio = { version = "1", features = ["macros"] }
+zip = { version = "2", default-features = false, features = ["flate2"] }

 [features]
 console-subscriber = ["dep:console-subscriber"]
-default = []
+default = ["matrix"]
 matrix = ["dep:dirs", "dep:matrix-sdk"]
 mimalloc = ["dep:mimalloc"]
-replay = ["dep:zip"]
--- a/README.md
+++ b/README.md
@@ -21,13 +21,7 @@ A Minecraft bot with Lua scripting support, written in Rust with [azalea](https:
 $ git clone https://github.com/ErrorNoInternet/ErrorNoWatcher
 $ cd ErrorNoWatcher
 $ cargo build --release
-$ ./target/release/errornowatcher
-```
-
-#### Nix
-
-```sh
-nix run github:ErrorNoInternet/ErrorNoWatcher
+$ # ./target/release/errornowatcher
 ```

 Make sure the `Server` and `Username` globals are defined in `main.lua` before starting the bot.
--- a/default.nix
+++ b/default.nix
@@ -1,24 +0,0 @@
-{
-  lib,
-  pkgs,
-  rust,
-  self,
-}:
-pkgs.rustPlatform.buildRustPackage {
-  pname = "errornowatcher";
-  version = self.shortRev or self.dirtyShortRev;
-
-  cargoLock.lockFile = ./Cargo.lock;
-  src = lib.cleanSource ./.;
-
-  nativeBuildInputs = with pkgs; [
-    rust
-
-    mold
-    pkg-config
-  ];
-
-  buildInputs = with pkgs; [
-    luajit
-  ];
-}
--- a/flake.lock
+++ b/flake.lock
@@ -1,82 +0,0 @@
-{
-  "nodes": {
-    "flake-parts": {
-      "inputs": {
-        "nixpkgs-lib": "nixpkgs-lib"
-      },
-      "locked": {
-        "lastModified": 1772408722,
-        "narHash": "sha256-rHuJtdcOjK7rAHpHphUb1iCvgkU3GpfvicLMwwnfMT0=",
-        "owner": "hercules-ci",
-        "repo": "flake-parts",
-        "rev": "f20dc5d9b8027381c474144ecabc9034d6a839a3",
-        "type": "github"
-      },
-      "original": {
-        "owner": "hercules-ci",
-        "repo": "flake-parts",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1774709303,
-        "narHash": "sha256-D3Q07BbIA2KnTcSXIqqu9P586uWxN74zNoCH3h2ESHg=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "8110df5ad7abf5d4c0f6fb0f8f978390e77f9685",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "nixpkgs-lib": {
-      "locked": {
-        "lastModified": 1772328832,
-        "narHash": "sha256-e+/T/pmEkLP6BHhYjx6GmwP5ivonQQn0bJdH9YrRB+Q=",
-        "owner": "nix-community",
-        "repo": "nixpkgs.lib",
-        "rev": "c185c7a5e5dd8f9add5b2f8ebeff00888b070742",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-community",
-        "repo": "nixpkgs.lib",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "flake-parts": "flake-parts",
-        "nixpkgs": "nixpkgs",
-        "rust-overlay": "rust-overlay"
-      }
-    },
-    "rust-overlay": {
-      "inputs": {
-        "nixpkgs": [
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1775013181,
-        "narHash": "sha256-zPrt6oNM1r/RO5bWYaZ3hthfG9vzkr6kQdoqDd5x4Qw=",
-        "owner": "oxalica",
-        "repo": "rust-overlay",
-        "rev": "e8046c1d9ccadd497c2344d8fa49dab62f22f7be",
-        "type": "github"
-      },
-      "original": {
-        "owner": "oxalica",
-        "repo": "rust-overlay",
-        "type": "github"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}
--- a/flake.nix
+++ b/flake.nix
@@ -1,66 +0,0 @@
-{
-  inputs = {
-    flake-parts.url = "github:hercules-ci/flake-parts";
-
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
-
-    rust-overlay = {
-      url = "github:oxalica/rust-overlay";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
-  };
-
-  outputs =
-    {
-      flake-parts,
-      nixpkgs,
-      rust-overlay,
-      self,
-      ...
-    }@inputs:
-    flake-parts.lib.mkFlake { inherit inputs; } {
-      systems = [
-        "aarch64-linux"
-        "x86_64-linux"
-      ];
-
-      perSystem =
-        {
-          pkgs,
-          self',
-          system,
-          ...
-        }:
-        let
-          rust = pkgs.rust-bin.nightly.latest.default.override {
-            extensions = [
-              "rust-src"
-              "rust-analyzer-preview"
-            ];
-          };
-        in
-        {
-          _module.args.pkgs = import nixpkgs {
-            inherit system;
-            overlays = [ rust-overlay.overlays.default ];
-          };
-
-          devShells.default = pkgs.mkShell {
-            name = "errornowatcher";
-
-            inputsFrom = [ self'.packages.default ];
-            nativeBuildInputs = [ pkgs.pkg-config ];
-            buildInputs = [ pkgs.taplo ];
-
-            RUST_BACKTRACE = 1;
-          };
-
-          packages = rec {
-            default = errornowatcher;
-            errornowatcher = pkgs.callPackage ./. { inherit rust self; };
-          };
-        };
-    };
-
-  description = "A Minecraft bot with Lua scripting support";
-}
--- a/lib/automation.lua
+++ b/lib/automation.lua
@@ -30,7 +30,7 @@ function auto_fish()
 				sleep(3000)
 			end
 			hold_fishing_rod()
-			client:start_use_item()
+			client:use_item()
 		end
 	end, "auto-fish_watch-bobber")

@@ -41,7 +41,7 @@ function auto_fish()
 			end)[1]
 			if distance(current_bobber.position, particle.position) <= 0.75 then
 				FishLastCaught = os.time()
-				client:start_use_item()
+				client:use_item()
 			end
 		end
 	end, "auto-fish")
@@ -54,11 +54,11 @@ function auto_fish()

 		if os.time() - FishLastCaught >= 60 then
 			hold_fishing_rod()
-			client:start_use_item()
+			client:use_item()
 		end
 	end, "auto-fish_watchdog")

-	client:start_use_item()
+	client:use_item()
 end

 function stop_auto_fish()
@@ -71,7 +71,7 @@ function stop_auto_fish()
 		return e.id == FishingBobber.id
 	end)[1] then
 		FishingBobber = nil
-		client:start_use_item()
+		client:use_item()
 	end
 end

@@ -111,10 +111,6 @@ function attack_entities(target_kind, minimum)
 end

 function check_food(hunger)
-	if not hunger then
-		hunger = client.hunger
-	end
-
 	if hunger.food >= 20 then
 		return
 	end
@@ -131,6 +127,6 @@ function check_food(hunger)
 			sleep(1000)
 			LastEaten = current_time
 		end
-		client:start_use_item()
+		client:use_item()
 	end
 end
--- a/lib/events.lua
+++ b/lib/events.lua
@@ -63,7 +63,7 @@ function update_listeners()
 			end,
 			eat = function()
 				sleep(5000)
-				check_food()
+				check_food(client.hunger)
 			end,
 		},
 		death = {
--- a/lib/inventory.lua
+++ b/lib/inventory.lua
@@ -35,6 +35,9 @@ end
 function steal(item_name)
 	for _, chest_pos in ipairs(client:find_blocks(client.position, get_block_states({ "chest" }))) do
 		client:go_to({ position = chest_pos, radius = 3 }, { type = RADIUS_GOAL })
+		while client.pathfinder.is_calculating or client.pathfinder.is_executing do
+			sleep(500)
+		end
 		client:look_at(chest_pos)

 		local container = client:open_container_at(chest_pos)
--- a/lib/utils.lua
+++ b/lib/utils.lua
@@ -93,6 +93,9 @@ function nether_travel(pos, go_to_opts)

 	info(string.format("currently in nether, going to %.2f %.2f", nether_pos.x, nether_pos.z))
 	client:go_to(nether_pos, { type = XZ_GOAL })
+	while client.pathfinder.is_calculating or client.pathfinder.is_executing do
+		sleep(1000)
+	end

 	info("arrived, looking for nearest portal")
 	local portals_nether = client:find_blocks(client.position, portal_block_states)
@@ -141,6 +144,10 @@ function interact_bed()
 	end

 	client:go_to({ position = bed, radius = 2 }, { type = RADIUS_GOAL, options = { without_mining = true } })
+	while client.pathfinder.is_calculating or client.pathfinder.is_executing do
+		sleep(500)
+	end
+
 	client:look_at(bed)
 	client:block_interact(bed)
 end
--- a/main.lua
+++ b/main.lua
@@ -2,7 +2,7 @@ Server = "localhost"
 Username = "ErrorNoWatcher"
 HttpAddress = "127.0.0.1:8080"
 Owners = { "ErrorNoInternet" }
-MatrixOptions = { owners = { "@errornointernet:envs.net" } }
+Matrix = { Owners = { "@errornointernet:envs.net" } }

 for _, module in ipairs({
 	"lib",
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,2 +0,0 @@
-[toolchain]
-channel = "nightly"
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -1 +0,0 @@
-group_imports = "StdExternalCrate"
--- a/src/arguments.rs
+++ b/src/arguments.rs
@@ -1,8 +1,6 @@
-use std::path::PathBuf;
-
-use clap::Parser;
-
 use crate::build_info;
+use clap::Parser;
+use std::path::PathBuf;

 /// A Minecraft bot with Lua scripting support
 #[derive(Parser)]
--- a/src/commands.rs
+++ b/src/commands.rs
@@ -1,16 +1,11 @@
+use crate::{
+    State,
+    lua::{eval, exec, reload},
+};
 use azalea::{brigadier::prelude::*, chat::ChatPacket, prelude::*};
 use futures::lock::Mutex;
-use mlua::{Error, Result, Table, UserDataRef};
-use ncr::{
-    encoding::{Base64Encoding, Base64rEncoding, NewBase64rEncoding},
-    encryption::{CaesarEncryption, Cfb8Encryption, EcbEncryption, Encryption, GcmEncryption},
-    utils::prepend_header,
-};
-
-use crate::{
-    State, crypt,
-    lua::{eval, exec, nochatreports::key::AesKey, reload},
-};
+use mlua::{Function, Table};
+use ncr::utils::prepend_header;

 pub type Ctx = CommandContext<Mutex<CommandSource>>;

@@ -23,26 +18,21 @@ pub struct CommandSource {

 impl CommandSource {
    pub fn reply(&self, message: &str) {
-        fn encrypt(options: &Table, plaintext: &str) -> Result<String> {
-            Ok(crypt!(encrypt, options, &prepend_header(plaintext)))
-        }
-
        for mut chunk in message
            .chars()
            .collect::<Vec<char>>()
            .chunks(if self.ncr_options.is_some() { 150 } else { 236 })
            .map(|chars| chars.iter().collect::<String>())
        {
-            if let Some(ciphertext) = self
-                .ncr_options
-                .as_ref()
-                .and_then(|options| encrypt(options, &chunk).ok())
+            if let Some(options) = &self.ncr_options
+                && let Ok(encrypt) = self.state.lua.globals().get::<Function>("ncr_encrypt")
+                && let Ok(ciphertext) = encrypt.call::<String>((options, prepend_header(&chunk)))
            {
                chunk = ciphertext;
            }
            self.client.chat(
                &(if self.message.is_whisper()
-                    && let Some(username) = self.message.sender()
+                    && let Some(username) = self.message.username()
                {
                    format!("/w {username} {chunk}")
                } else {
@@ -59,7 +49,7 @@ pub fn register(commands: &mut CommandDispatcher<Mutex<CommandSource>>) {
        tokio::spawn(async move {
            let source = source.lock().await;
            source.reply(
-                &reload(&source.state.lua, source.message.sender())
+                &reload(&source.state.lua, source.message.username())
                    .map_or_else(|error| error.to_string(), |()| String::from("ok")),
            );
        });
@@ -73,7 +63,7 @@ pub fn register(commands: &mut CommandDispatcher<Mutex<CommandSource>>) {
            tokio::spawn(async move {
                let source = source.lock().await;
                source.reply(
-                    &eval(&source.state.lua, &code, source.message.sender())
+                    &eval(&source.state.lua, &code, source.message.username())
                        .await
                        .unwrap_or_else(|error| error.to_string()),
                );
@@ -89,7 +79,7 @@ pub fn register(commands: &mut CommandDispatcher<Mutex<CommandSource>>) {
            tokio::spawn(async move {
                let source = source.lock().await;
                source.reply(
-                    &exec(&source.state.lua, &code, source.message.sender())
+                    &exec(&source.state.lua, &code, source.message.username())
                        .await
                        .map_or_else(|error| error.to_string(), |()| String::from("ok")),
                );
--- a/src/events.rs
+++ b/src/events.rs
@@ -1,29 +1,28 @@
-use std::net::SocketAddr;
-
-use anyhow::Result;
-use azalea::{
-    brigadier::errors::BuiltInError, prelude::*, protocol::packets::game::ClientboundGamePacket,
-};
-use hyper::{server::conn::http1, service::service_fn};
-use hyper_util::rt::TokioIo;
-use log::{debug, error, info, trace};
-use mlua::{Function, IntoLuaMulti, Table};
-use ncr::utils::trim_header;
-use tokio::net::TcpListener;
-#[cfg(feature = "matrix")]
-use {crate::matrix, std::time::Duration, tokio::time::sleep};
-#[cfg(feature = "replay")]
-use {crate::replay::recorder::Recorder, anyhow::Context, mlua::Error, std::process::exit};
-
 use crate::{
    State,
    commands::CommandSource,
    http::serve,
    lua::{client, direction::Direction, player::Player, vec3::Vec3},
    particle,
+    replay::recorder::Recorder,
 };
+use anyhow::{Context, Result};
+use azalea::{
+    brigadier::exceptions::BuiltInExceptions::DispatcherUnknownCommand, prelude::*,
+    protocol::packets::game::ClientboundGamePacket,
+};
+use hyper::{server::conn::http1, service::service_fn};
+use hyper_util::rt::TokioIo;
+use log::{debug, error, info, trace};
+use mlua::{Error, Function, IntoLuaMulti, Table};
+use ncr::utils::trim_header;
+use std::{net::SocketAddr, process::exit};
+use tokio::net::TcpListener;

-#[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
+#[cfg(feature = "matrix")]
+use crate::matrix;
+
+#[allow(clippy::too_many_lines)]
 pub async fn handle_event(client: Client, event: Event, state: State) -> Result<()> {
    match event {
        Event::AddPlayer(player_info) => {
@@ -32,10 +31,9 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
        Event::Chat(message) => {
            let globals = state.lua.globals();
            let (sender, mut content) = message.split_sender_and_content();
-            let uuid = message.sender_uuid().map(|uuid| uuid.to_string());
+            let uuid = message.uuid().map(|uuid| uuid.to_string());
            let is_whisper = message.is_whisper();
            let text = message.message();
-            let html_text = text.to_html();
            let ansi_text = text.to_ansi();
            info!("{ansi_text}");

@@ -71,7 +69,7 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
                        }
                        .into(),
                    )
-                    && *error.kind() != BuiltInError::DispatcherUnknownCommand
+                    && error.type_ != DispatcherUnknownCommand
                {
                    CommandSource {
                        client,
@@ -87,7 +85,6 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
                let table = state.lua.create_table()?;
                table.set("text", text.to_string())?;
                table.set("ansi_text", ansi_text)?;
-                table.set("html_text", html_text)?;
                table.set("sender", sender)?;
                table.set("content", content)?;
                table.set("uuid", uuid)?;
@@ -97,16 +94,12 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
            })
            .await
        }
-        Event::ConnectionFailed(error) => {
-            call_listeners(&state, "connection_failed", || Ok(error.to_string())).await
-        }
        Event::Death(packet) => {
            if let Some(packet) = packet {
                call_listeners(&state, "death", || {
                    let message_table = state.lua.create_table()?;
                    message_table.set("text", packet.message.to_string())?;
                    message_table.set("ansi_text", packet.message.to_ansi())?;
-                    message_table.set("html_text", packet.message.to_html())?;
                    let table = state.lua.create_table()?;
                    table.set("message", message_table)?;
                    table.set("player_id", packet.player_id.0)?;
@@ -123,7 +116,6 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
                    let table = state.lua.create_table()?;
                    table.set("text", message.to_string())?;
                    table.set("ansi_text", message.to_ansi())?;
-                    table.set("html_text", message.to_html())?;
                    Ok(table)
                })
                .await
@@ -132,7 +124,7 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
            }
        }
        Event::KeepAlive(id) => call_listeners(&state, "keep_alive", || Ok(id)).await,
-        Event::ReceiveChunk(_) => Ok(()),
+        Event::Login => call_listeners(&state, "login", || Ok(())).await,
        Event::RemovePlayer(player_info) => {
            call_listeners(&state, "remove_player", || Ok(Player::from(player_info))).await
        }
@@ -190,11 +182,8 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
            ClientboundGamePacket::SetPassengers(packet) => {
                call_listeners(&state, "set_passengers", || {
                    let table = state.lua.create_table()?;
-                    table.set("vehicle", *packet.vehicle)?;
-                    table.set(
-                        "passengers",
-                        packet.passengers.iter().map(|id| id.0).collect::<Vec<_>>(),
-                    )?;
+                    table.set("vehicle", packet.vehicle)?;
+                    table.set("passengers", &*packet.passengers)?;
                    Ok(table)
                })
                .await
@@ -202,32 +191,28 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
            ClientboundGamePacket::SetTime(packet) => {
                call_listeners(&state, "set_time", || {
                    let table = state.lua.create_table()?;
+                    table.set("day_time", packet.day_time)?;
                    table.set("game_time", packet.game_time)?;
+                    table.set("tick_day_time", packet.tick_day_time)?;
                    Ok(table)
                })
                .await
            }
            _ => Ok(()),
        },
-        Event::Login => {
-            #[cfg(feature = "matrix")]
-            matrix_init(&client, state.clone());
-
-            call_listeners(&state, "login", || Ok(())).await
-        }
        Event::Init => {
            debug!("received init event");

-            #[cfg(feature = "replay")]
-            {
            let ecs = client.ecs.clone();
            ctrlc::set_handler(move || {
-                    ecs.write()
+                ecs.lock()
                    .remove_resource::<Recorder>()
                    .map(Recorder::finish);
                exit(0);
            })?;
-            };
+
+            #[cfg(feature = "matrix")]
+            matrix_init(&client, state.clone());

            let globals = state.lua.globals();
            lua_init(client, &state, &globals).await?;
@@ -276,13 +261,11 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
 }

 async fn lua_init(client: Client, state: &State, globals: &Table) -> Result<()> {
-    #[cfg(feature = "replay")]
-    {
    let ecs = client.ecs.clone();
    globals.set(
        "finish_replay_recording",
        state.lua.create_function_mut(move |_, (): ()| {
-                ecs.write()
+            ecs.lock()
                .remove_resource::<Recorder>()
                .context("recording not active")
                .map_err(Error::external)?
@@ -290,7 +273,6 @@ async fn lua_init(client: Client, state: &State, globals: &Table) -> Result<()>
                .map_err(Error::external)
        })?,
    )?;
-    }
    globals.set("client", client::Client(Some(client)))?;
    call_listeners(state, "init", || Ok(())).await
 }
@@ -298,15 +280,11 @@ async fn lua_init(client: Client, state: &State, globals: &Table) -> Result<()>
 #[cfg(feature = "matrix")]
 fn matrix_init(client: &Client, state: State) {
    let globals = state.lua.globals();
-    if let Ok(options) = globals.get::<Table>("MatrixOptions") {
+    if let Ok(matrix_options) = globals.get::<Table>("MatrixOptions") {
        let name = client.username();
        tokio::spawn(async move {
-            loop {
-                let name = name.clone();
-                if let Err(error) = matrix::login(&state, &options, &globals, name).await {
-                    error!("failed to log into matrix: {error:?}");
-                }
-                sleep(Duration::from_secs(10)).await;
+            if let Err(error) = matrix::login(state, matrix_options, globals, name).await {
+                error!("failed to log into matrix account: {error:?}");
            }
        });
    }
--- a/src/hacks/anti_knockback.rs
+++ b/src/hacks/anti_knockback.rs
@@ -1,19 +1,20 @@
 use azalea::{
-    entity::Physics,
-    movement::{KnockbackEvent, handle_knockback},
-    prelude::*,
+    Vec3,
+    movement::{KnockbackEvent, KnockbackType},
+    prelude::Component,
 };
-use bevy_ecs::{observer::On, query::With, system::Query};
+use bevy_ecs::{event::EventMutator, query::With, system::Query};

 #[derive(Component)]
 pub struct AntiKnockback;

 pub fn anti_knockback(
-    knockback: On<KnockbackEvent>,
+    mut events: EventMutator<KnockbackEvent>,
    entity_query: Query<(), With<AntiKnockback>>,
-    handle_knockback_query: Query<&mut Physics>,
 ) {
-    if entity_query.get(knockback.entity).is_err() {
-        handle_knockback(knockback, handle_knockback_query);
+    for event in events.read() {
+        if entity_query.get(event.entity).is_ok() {
+            event.knockback = KnockbackType::Add(Vec3::default());
+        }
    }
 }
--- a/src/hacks/mod.rs
+++ b/src/hacks/mod.rs
@@ -1,28 +1,21 @@
+#![allow(clippy::needless_pass_by_value)]
+
 pub mod anti_knockback;

-use azalea::movement::KnockbackEvent;
-use bevy_app::{App, Plugin, PostStartup};
-use bevy_ecs::world::World;
+use anti_knockback::anti_knockback;
+use azalea::{movement::handle_knockback, packet::game::process_packet_events};
+use bevy_app::{App, Plugin, PreUpdate};
+use bevy_ecs::schedule::IntoSystemConfigs;

 pub struct HacksPlugin;

 impl Plugin for HacksPlugin {
    fn build(&self, app: &mut App) {
-        app.add_systems(PostStartup, init_hacks);
+        app.add_systems(
+            PreUpdate,
+            anti_knockback
+                .after(process_packet_events)
+                .before(handle_knockback),
+        );
    }
 }
-
-fn init_hacks(ecs: &mut World) {
-    let observers = ecs
-        .observers()
-        .try_get_observers(ecs.event_key::<KnockbackEvent>().unwrap());
-    let mut to_despawn = Vec::new();
-    for (observer_entity, _) in observers.unwrap().global_observers() {
-        to_despawn.push(*observer_entity);
-    }
-    for observer_entity in to_despawn {
-        ecs.despawn(observer_entity);
-    }
-
-    ecs.add_observer(anti_knockback::anti_knockback);
-}
--- a/src/http.rs
+++ b/src/http.rs
@@ -1,14 +1,13 @@
+use crate::{
+    State,
+    lua::{eval, exec, reload},
+};
 use http_body_util::{BodyExt, Empty, Full, combinators::BoxBody};
 use hyper::{
    Error, Method, Request, Response, StatusCode,
    body::{Bytes, Incoming},
 };

-use crate::{
-    State,
-    lua::{eval, exec, reload},
-};
-
 pub async fn serve(
    request: Request<Incoming>,
    state: State,
@@ -49,13 +48,13 @@ fn status_code_response(
    response
 }

-fn full<T: Into<Bytes>>(chunk: T) -> BoxBody<Bytes, Error> {
+fn full<T: Into<Bytes>>(chunk: T) -> BoxBody<Bytes, hyper::Error> {
    Full::new(chunk.into())
        .map_err(|never| match never {})
        .boxed()
 }

-fn empty() -> BoxBody<Bytes, Error> {
+fn empty() -> BoxBody<Bytes, hyper::Error> {
    Empty::<Bytes>::new()
        .map_err(|never| match never {})
        .boxed()
--- a/src/lua/block.rs
+++ b/src/lua/block.rs
@@ -1,6 +1,6 @@
-use azalea::block::{
-    BlockState, BlockTrait,
-    properties::{ChestKind, Facing, LightLevel},
+use azalea::blocks::{
+    Block as AzaleaBlock, BlockState,
+    properties::{ChestType, Facing, LightLevel},
 };
 use mlua::{Function, Lua, Result, Table};

@@ -21,7 +21,7 @@ pub fn get_block_from_state(lua: &Lua, state: u32) -> Result<Option<Table>> {
    let Ok(state) = BlockState::try_from(state) else {
        return Ok(None);
    };
-    let block: Box<dyn BlockTrait> = state.into();
+    let block: Box<dyn AzaleaBlock> = state.into();
    let behavior = block.behavior();

    let table = lua.create_table()?;
@@ -46,10 +46,10 @@ pub async fn get_block_states(
        for block in
            (u32::MIN..u32::MAX).map_while(|possible_id| BlockState::try_from(possible_id).ok())
        {
-            if block_name == Into::<Box<dyn BlockTrait>>::into(block).id()
+            if block_name == Into::<Box<dyn AzaleaBlock>>::into(block).id()
                && (if let Some(filter_fn) = &filter_fn {
                    let table = lua.create_table()?;
-                    table.set("chest_kind", block.property::<ChestKind>().map(|v| v as u8))?;
+                    table.set("chest_type", block.property::<ChestType>().map(|v| v as u8))?;
                    table.set("facing", block.property::<Facing>().map(|v| v as u8))?;
                    table.set(
                        "light_level",
@@ -60,7 +60,7 @@ pub async fn get_block_states(
                    true
                })
            {
-                matched.push(block.id());
+                matched.push(block.id);
            }
        }
    }
--- a/src/lua/client/container.rs
+++ b/src/lua/client/container.rs
@@ -1,20 +1,19 @@
+use super::{Client, Container, ContainerRef, ItemStack, Vec3};
 use azalea::{
    BlockPos,
-    entity::inventory::Inventory,
-    inventory::{Menu, Player, SlotList},
+    inventory::{Inventory, Menu, Player, SlotList},
+    prelude::ContainerClientExt,
    protocol::packets::game::ServerboundSetCarriedItem,
 };
+use log::error;
 use mlua::{Lua, Result, UserDataRef, Value};

-use super::{Client, Container, ContainerRef, ItemStack, Vec3};
-use crate::unpack;
-
-pub fn container(_lua: &Lua, client: &Client) -> Result<ContainerRef> {
-    Ok(ContainerRef(client.get_inventory()))
+pub fn container(_lua: &Lua, client: &Client) -> Result<Option<ContainerRef>> {
+    Ok(client.get_open_container().map(ContainerRef))
 }

 pub fn held_item(_lua: &Lua, client: &Client) -> Result<ItemStack> {
-    Ok(ItemStack(client.get_held_item()))
+    Ok(ItemStack(client.component::<Inventory>().held_item()))
 }

 pub fn held_slot(_lua: &Lua, client: &Client) -> Result<u8> {
@@ -96,10 +95,9 @@ pub async fn open_container_at(
    client: UserDataRef<Client>,
    position: Vec3,
 ) -> Result<Option<Container>> {
-    let client = unpack!(client);
-
    #[allow(clippy::cast_possible_truncation)]
    Ok(client
+        .clone()
        .open_container_at(BlockPos::new(
            position.x as i32,
            position.y as i32,
@@ -109,7 +107,7 @@ pub async fn open_container_at(
        .map(Container))
 }

-pub fn open_inventory(_lua: &Lua, client: &Client, (): ()) -> Result<Option<Container>> {
+pub fn open_inventory(_lua: &Lua, client: &mut Client, _: ()) -> Result<Option<Container>> {
    Ok(client.open_inventory().map(Container))
 }

@@ -118,14 +116,20 @@ pub fn set_held_slot(_lua: &Lua, client: &Client, slot: u8) -> Result<()> {
        return Ok(());
    }

-    client.query_self::<&mut Inventory, _>(|mut inventory| {
-        if inventory.selected_hotbar_slot != slot {
-            inventory.selected_hotbar_slot = slot;
+    {
+        let mut ecs = client.ecs.lock();
+        let mut inventory = client.query::<&mut Inventory>(&mut ecs);
+        if inventory.selected_hotbar_slot == slot {
+            return Ok(());
        }
-    });
-    client.write_packet(ServerboundSetCarriedItem {
+        inventory.selected_hotbar_slot = slot;
+    };
+
+    if let Err(error) = client.write_packet(ServerboundSetCarriedItem {
        slot: u16::from(slot),
-    });
+    }) {
+        error!("failed to send SetCarriedItem packet: {error:?}");
+    }

    Ok(())
 }
--- a/src/lua/client/interaction.rs
+++ b/src/lua/client/interaction.rs
@@ -1,21 +1,18 @@
+use super::{Client, Vec3};
 use azalea::{
-    BlockPos,
-    core::entity_id::MinecraftEntityId,
+    BlockPos, BotClientExt,
    protocol::packets::game::{ServerboundUseItem, s_interact::InteractionHand},
+    world::MinecraftEntityId,
 };
+use log::error;
 use mlua::{Lua, Result, UserDataRef};

-use super::{Client, Vec3};
-use crate::unpack;
-
-pub fn attack(_lua: &Lua, client: &Client, entity_id: i32) -> Result<()> {
-    if let Some(entity) = client.entity_id_by_minecraft_id(MinecraftEntityId(entity_id)) {
-        client.attack(entity);
-    }
+pub fn attack(_lua: &Lua, client: &mut Client, entity_id: i32) -> Result<()> {
+    client.attack(MinecraftEntityId(entity_id));
    Ok(())
 }

-pub fn block_interact(_lua: &Lua, client: &Client, position: Vec3) -> Result<()> {
+pub fn block_interact(_lua: &Lua, client: &mut Client, position: Vec3) -> Result<()> {
    #[allow(clippy::cast_possible_truncation)]
    client.block_interact(BlockPos::new(
        position.x as i32,
@@ -30,10 +27,9 @@ pub fn has_attack_cooldown(_lua: &Lua, client: &Client) -> Result<bool> {
 }

 pub async fn mine(_lua: Lua, client: UserDataRef<Client>, position: Vec3) -> Result<()> {
-    let client = unpack!(client);
-
    #[allow(clippy::cast_possible_truncation)]
    client
+        .clone()
        .mine(BlockPos::new(
            position.x as i32,
            position.y as i32,
@@ -43,12 +39,12 @@ pub async fn mine(_lua: Lua, client: UserDataRef<Client>, position: Vec3) -> Res
    Ok(())
 }

-pub fn set_mining(_lua: &Lua, client: &Client, state: bool) -> Result<()> {
-    client.left_click_mine(state);
+pub fn set_mining(_lua: &Lua, client: &Client, mining: bool) -> Result<()> {
+    client.left_click_mine(mining);
    Ok(())
 }

-pub fn start_mining(_lua: &Lua, client: &Client, position: Vec3) -> Result<()> {
+pub fn start_mining(_lua: &Lua, client: &mut Client, position: Vec3) -> Result<()> {
    #[allow(clippy::cast_possible_truncation)]
    client.start_mining(BlockPos::new(
        position.x as i32,
@@ -58,16 +54,18 @@ pub fn start_mining(_lua: &Lua, client: &Client, position: Vec3) -> Result<()> {
    Ok(())
 }

-pub fn start_use_item(_lua: &Lua, client: &Client, hand: Option<u8>) -> Result<()> {
+pub fn use_item(_lua: &Lua, client: &Client, hand: Option<u8>) -> Result<()> {
    let direction = client.direction();
-    client.write_packet(ServerboundUseItem {
+    if let Err(error) = client.write_packet(ServerboundUseItem {
        hand: match hand {
            Some(1) => InteractionHand::OffHand,
            _ => InteractionHand::MainHand,
        },
-        seq: 0,
-        x_rot: direction.x_rot(),
-        y_rot: direction.y_rot(),
-    });
+        sequence: 0,
+        yaw: direction.0,
+        pitch: direction.1,
+    }) {
+        error!("failed to send UseItem packet: {error:?}");
+    }
    Ok(())
 }
--- a/src/lua/client/mod.rs
+++ b/src/lua/client/mod.rs
@@ -6,17 +6,15 @@ mod movement;
 mod state;
 mod world;

-use std::ops::Deref;
-
-use azalea::{Client as AzaleaClient, core::entity_id::MinecraftEntityId};
-use mlua::{Lua, Result, UserData, UserDataFields, UserDataMethods};
-
 use super::{
    container::{Container, ContainerRef, item_stack::ItemStack},
    direction::Direction,
    player::Player,
    vec3::Vec3,
 };
+use azalea::{Client as AzaleaClient, world::MinecraftEntityId};
+use mlua::{Lua, Result, UserData, UserDataFields, UserDataMethods};
+use std::ops::{Deref, DerefMut};

 pub struct Client(pub Option<AzaleaClient>);

@@ -28,15 +26,19 @@ impl Deref for Client {
    }
 }

+impl DerefMut for Client {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.0.as_mut().expect("should have received init event")
+    }
+}
+
 impl UserData for Client {
    fn add_fields<F: UserDataFields<Self>>(f: &mut F) {
        f.add_field_method_get("air_supply", state::air_supply);
        f.add_field_method_get("container", container::container);
        f.add_field_method_get("dimension", world::dimension);
        f.add_field_method_get("direction", movement::direction);
-        f.add_field_method_get("experience", state::experience);
        f.add_field_method_get("eye_position", movement::eye_position);
-        f.add_field_method_get("go_to_reached", movement::go_to_reached);
        f.add_field_method_get("has_attack_cooldown", interaction::has_attack_cooldown);
        f.add_field_method_get("health", state::health);
        f.add_field_method_get("held_item", container::held_item);
@@ -47,6 +49,7 @@ impl UserData for Client {
        f.add_field_method_get("menu", container::menu);
        f.add_field_method_get("pathfinder", movement::pathfinder);
        f.add_field_method_get("position", movement::position);
+        f.add_field_method_get("score", state::score);
        f.add_field_method_get("tab_list", tab_list);
        f.add_field_method_get("username", username);
        f.add_field_method_get("uuid", uuid);
@@ -61,32 +64,30 @@ impl UserData for Client {
        m.add_async_method("mine", interaction::mine);
        m.add_async_method("open_container_at", container::open_container_at);
        m.add_async_method("set_client_information", state::set_client_information);
-        m.add_async_method("start_go_to", movement::start_go_to);
-        m.add_async_method("wait_until_goal_reached", movement::wait_until_goal_reached);
-        m.add_method("attack", interaction::attack);
        m.add_method("best_tool_for_block", world::best_tool_for_block);
-        m.add_method("block_interact", interaction::block_interact);
        m.add_method("chat", chat);
        m.add_method("disconnect", disconnect);
        m.add_method("find_blocks", world::find::blocks);
        m.add_method("get_block_state", world::get_block_state);
        m.add_method("get_fluid_state", world::get_fluid_state);
-        m.add_method("jump", movement::jump);
-        m.add_method("look_at", movement::look_at);
-        m.add_method("open_inventory", container::open_inventory);
        m.add_method("set_component", state::set_component);
-        m.add_method("set_direction", movement::set_direction);
        m.add_method("set_held_slot", container::set_held_slot);
-        m.add_method("set_jumping", movement::set_jumping);
        m.add_method("set_mining", interaction::set_mining);
        m.add_method("set_position", movement::set_position);
        m.add_method("set_sneaking", movement::set_sneaking);
-        m.add_method("sprint", movement::sprint);
-        m.add_method("start_mining", interaction::start_mining);
-        m.add_method("start_use_item", interaction::start_use_item);
        m.add_method("stop_pathfinding", movement::stop_pathfinding);
        m.add_method("stop_sleeping", movement::stop_sleeping);
-        m.add_method("walk", movement::walk);
+        m.add_method("use_item", interaction::use_item);
+        m.add_method_mut("attack", interaction::attack);
+        m.add_method_mut("block_interact", interaction::block_interact);
+        m.add_method_mut("jump", movement::jump);
+        m.add_method_mut("look_at", movement::look_at);
+        m.add_method_mut("open_inventory", container::open_inventory);
+        m.add_method_mut("set_direction", movement::set_direction);
+        m.add_method_mut("set_jumping", movement::set_jumping);
+        m.add_method_mut("sprint", movement::sprint);
+        m.add_method_mut("start_mining", interaction::start_mining);
+        m.add_method_mut("walk", movement::walk);
    }
 }

@@ -95,7 +96,7 @@ fn chat(_lua: &Lua, client: &Client, message: String) -> Result<()> {
    Ok(())
 }

-fn disconnect(_lua: &Lua, client: &Client, (): ()) -> Result<()> {
+fn disconnect(_lua: &Lua, client: &Client, _: ()) -> Result<()> {
    client.disconnect();
    Ok(())
 }
@@ -115,12 +116,3 @@ fn username(_lua: &Lua, client: &Client) -> Result<String> {
 fn uuid(_lua: &Lua, client: &Client) -> Result<String> {
    Ok(client.uuid().to_string())
 }
-
-#[macro_export]
-macro_rules! unpack {
-    ($client:ident) => {{
-        let inner = (**$client).clone();
-        drop($client);
-        inner
-    }};
-}
--- a/src/lua/client/movement.rs
+++ b/src/lua/client/movement.rs
@@ -1,135 +1,23 @@
+use super::{Client, Direction, Vec3};
 use azalea::{
-    BlockPos, Client as AzaleaClient, SprintDirection, WalkDirection,
-    core::{entity_id::MinecraftEntityId, hit_result::HitResult},
+    BlockPos, BotClientExt, SprintDirection, WalkDirection,
    entity::Position,
-    interact::pick::HitResultComponent,
+    interact::HitResultComponent,
    pathfinder::{
-        ExecutingPath, Pathfinder, PathfinderClientExt, PathfinderOpts,
-        goals::{BlockPosGoal, Goal, RadiusGoal, ReachBlockPosGoal, XZGoal, YGoal},
+        ExecutingPath, GotoEvent, Pathfinder, PathfinderClientExt,
+        goals::{BlockPosGoal, Goal, InverseGoal, RadiusGoal, ReachBlockPosGoal, XZGoal, YGoal},
    },
    protocol::packets::game::{ServerboundPlayerCommand, s_player_command::Action},
+    world::MinecraftEntityId,
 };
+use log::error;
 use mlua::{FromLua, Lua, Result, Table, UserDataRef, Value};

-use super::{Client, Direction, Vec3};
-use crate::unpack;
-
-#[derive(Debug)]
-struct AnyGoal(Box<dyn Goal>);
-
-impl Goal for AnyGoal {
-    fn success(&self, n: BlockPos) -> bool {
-        self.0.success(n)
-    }
-
-    fn heuristic(&self, n: BlockPos) -> f32 {
-        self.0.heuristic(n)
-    }
-}
-
-#[allow(clippy::cast_possible_truncation)]
-fn to_goal(lua: &Lua, client: &AzaleaClient, data: Table, kind: u8) -> Result<AnyGoal> {
-    let goal: Box<dyn Goal> = match kind {
-        1 => {
-            let pos = Vec3::from_lua(data.get("position")?, lua)?;
-            Box::new(RadiusGoal {
-                pos: azalea::Vec3::new(pos.x, pos.y, pos.z),
-                radius: data.get("radius")?,
-            })
-        }
-        2 => {
-            let distance = data.get("distance").unwrap_or(4.5);
-            let pos = Vec3::from_lua(Value::Table(data), lua)?;
-            Box::new(ReachBlockPosGoal::new_with_distance(
-                BlockPos::new(pos.x as i32, pos.y as i32, pos.z as i32),
-                distance,
-                client.world().read().chunks.clone(),
-            ))
-        }
-        3 => Box::new(XZGoal {
-            x: data.get("x")?,
-            z: data.get("z")?,
-        }),
-        4 => Box::new(YGoal { y: data.get("y")? }),
-        _ => {
-            let pos = Vec3::from_lua(Value::Table(data), lua)?;
-            Box::new(BlockPosGoal(BlockPos::new(
-                pos.x as i32,
-                pos.y as i32,
-                pos.z as i32,
-            )))
-        }
-    };
-
-    Ok(AnyGoal(goal))
-}
-
-pub fn go_to_reached(_lua: &Lua, client: &Client) -> Result<bool> {
-    Ok(client.is_goto_target_reached())
-}
-
-pub async fn wait_until_goal_reached(_lua: Lua, client: UserDataRef<Client>, (): ()) -> Result<()> {
-    let client = unpack!(client);
-    client.wait_until_goto_target_reached().await;
-    Ok(())
-}
-
-pub async fn go_to(
-    lua: Lua,
-    client: UserDataRef<Client>,
-    (data, metadata): (Table, Option<Table>),
-) -> Result<()> {
-    let client = unpack!(client);
-
-    let metadata = metadata.unwrap_or(lua.create_table()?);
-    let options = metadata.get("options").unwrap_or(lua.create_table()?);
-    let goal = to_goal(
-        &lua,
-        &client,
-        data,
-        metadata.get("type").unwrap_or_default(),
-    )?;
-    client
-        .goto_with_opts(
-            goal,
-            PathfinderOpts::new()
-                .allow_mining(!options.get::<bool>("without_mining").unwrap_or_default()),
-        )
-        .await;
-
-    Ok(())
-}
-
-pub async fn start_go_to(
-    lua: Lua,
-    client: UserDataRef<Client>,
-    (data, metadata): (Table, Option<Table>),
-) -> Result<()> {
-    let client = unpack!(client);
-
-    let metadata = metadata.unwrap_or(lua.create_table()?);
-    let options = metadata.get("options").unwrap_or(lua.create_table()?);
-    let goal = to_goal(
-        &lua,
-        &client,
-        data,
-        metadata.get("type").unwrap_or_default(),
-    )?;
-    client.start_goto_with_opts(
-        goal,
-        PathfinderOpts::new()
-            .allow_mining(!options.get::<bool>("without_mining").unwrap_or_default()),
-    );
-    let _ = client.get_tick_broadcaster().recv().await;
-
-    Ok(())
-}
-
 pub fn direction(_lua: &Lua, client: &Client) -> Result<Direction> {
    let direction = client.direction();
    Ok(Direction {
-        y: direction.y_rot(),
-        x: direction.x_rot(),
+        y: direction.0,
+        x: direction.1,
    })
 }

@@ -137,28 +25,96 @@ pub fn eye_position(_lua: &Lua, client: &Client) -> Result<Vec3> {
    Ok(Vec3::from(client.eye_position()))
 }

-pub fn jump(_lua: &Lua, client: &Client, (): ()) -> Result<()> {
+pub async fn go_to(
+    lua: Lua,
+    client: UserDataRef<Client>,
+    (data, metadata): (Table, Option<Table>),
+) -> Result<()> {
+    fn goto_with_options<G: Goal + Send + Sync + 'static>(
+        client: &Client,
+        options: &Table,
+        goal: G,
+    ) {
+        if options.get("without_mining").unwrap_or_default() {
+            client.goto_without_mining(goal);
+        } else {
+            client.goto(goal);
+        }
+    }
+
+    let table = metadata.unwrap_or(lua.create_table()?);
+    let goal_type = table.get("type").unwrap_or_default();
+    let options = table.get("options").unwrap_or(lua.create_table()?);
+
+    macro_rules! goto {
+        ($goal:expr) => {
+            if options.get("inverse").unwrap_or_default() {
+                goto_with_options(&client, &options, InverseGoal($goal));
+            } else {
+                goto_with_options(&client, &options, $goal);
+            }
+        };
+    }
+
+    #[allow(clippy::cast_possible_truncation)]
+    match goal_type {
+        1 => {
+            let p = Vec3::from_lua(data.get("position")?, &lua)?;
+            goto!(RadiusGoal {
+                pos: azalea::Vec3::new(p.x, p.y, p.z),
+                radius: data.get("radius")?,
+            });
+        }
+        2 => {
+            let p = Vec3::from_lua(Value::Table(data), &lua)?;
+            goto!(ReachBlockPosGoal {
+                pos: BlockPos::new(p.x as i32, p.y as i32, p.z as i32),
+                chunk_storage: client.world().read().chunks.clone(),
+            });
+        }
+        3 => {
+            goto!(XZGoal {
+                x: data.get("x")?,
+                z: data.get("z")?,
+            });
+        }
+        4 => goto!(YGoal { y: data.get("y")? }),
+        _ => {
+            let p = Vec3::from_lua(Value::Table(data), &lua)?;
+            goto!(BlockPosGoal(BlockPos::new(
+                p.x as i32, p.y as i32, p.z as i32
+            )));
+        }
+    }
+
+    while client.get_tick_broadcaster().recv().await.is_ok() {
+        if client.ecs.lock().get::<GotoEvent>(client.entity).is_none() {
+            break;
+        }
+    }
+
+    Ok(())
+}
+
+pub fn jump(_lua: &Lua, client: &mut Client, _: ()) -> Result<()> {
    client.jump();
    Ok(())
 }

 pub fn looking_at(lua: &Lua, client: &Client) -> Result<Option<Table>> {
-    Ok(
-        if let HitResult::Block(ref result) = **client.component::<HitResultComponent>() {
+    let result = client.component::<HitResultComponent>();
+    Ok(if result.miss {
+        None
+    } else {
        let table = lua.create_table()?;
-            table.set("direction", Vec3::from(result.direction.normal()))?;
-            table.set("inside", result.inside)?;
-            table.set("location", Vec3::from(result.location))?;
        table.set("position", Vec3::from(result.block_pos))?;
+        table.set("inside", result.inside)?;
        table.set("world_border", result.world_border)?;
        Some(table)
-        } else {
-            None
-        },
-    )
+    })
 }

-pub fn look_at(_lua: &Lua, client: &Client, position: Vec3) -> Result<()> {
+pub fn look_at(_lua: &Lua, client: &mut Client, position: Vec3) -> Result<()> {
    client.look_at(azalea::Vec3::new(position.x, position.y, position.z));
    Ok(())
 }
@@ -177,8 +133,8 @@ pub fn pathfinder(lua: &Lua, client: &Client) -> Result<Table> {
                Vec3::from(pathfinder.last_reached_node),
            )?;
            table.set(
-                "ticks_since_last_node_reached",
-                pathfinder.ticks_since_last_node_reached,
+                "last_node_reach_elapsed",
+                pathfinder.last_node_reached_at.elapsed().as_millis(),
            )?;
            table.set("is_path_partial", pathfinder.is_path_partial)?;
            true
@@ -190,34 +146,44 @@ pub fn pathfinder(lua: &Lua, client: &Client) -> Result<Table> {
 }

 pub fn position(_lua: &Lua, client: &Client) -> Result<Vec3> {
-    Ok(Vec3::from(*client.component::<Position>()))
+    Ok(Vec3::from(&client.component::<Position>()))
 }

-pub fn set_direction(_lua: &Lua, client: &Client, direction: Direction) -> Result<()> {
+pub fn set_direction(_lua: &Lua, client: &mut Client, direction: Direction) -> Result<()> {
    client.set_direction(direction.y, direction.x);
    Ok(())
 }

-pub fn set_jumping(_lua: &Lua, client: &Client, jumping: bool) -> Result<()> {
+pub fn set_jumping(_lua: &Lua, client: &mut Client, jumping: bool) -> Result<()> {
    client.set_jumping(jumping);
    Ok(())
 }

-pub fn set_position(_lua: &Lua, client: &Client, new_pos: Vec3) -> Result<()> {
-    client.query_self::<&mut Position, _>(|mut pos| {
-        pos.x = new_pos.x;
-        pos.y = new_pos.y;
-        pos.z = new_pos.z;
-    });
+pub fn set_position(_lua: &Lua, client: &Client, new_position: Vec3) -> Result<()> {
+    let mut ecs = client.ecs.lock();
+    let mut position = client.query::<&mut Position>(&mut ecs);
+    position.x = new_position.x;
+    position.y = new_position.y;
+    position.z = new_position.z;
    Ok(())
 }

 pub fn set_sneaking(_lua: &Lua, client: &Client, sneaking: bool) -> Result<()> {
-    client.set_crouching(sneaking);
+    if let Err(error) = client.write_packet(ServerboundPlayerCommand {
+        id: client.component::<MinecraftEntityId>(),
+        action: if sneaking {
+            Action::PressShiftKey
+        } else {
+            Action::ReleaseShiftKey
+        },
+        data: 0,
+    }) {
+        error!("failed to send PlayerCommand packet: {error:?}");
+    }
    Ok(())
 }

-pub fn sprint(_lua: &Lua, client: &Client, direction: u8) -> Result<()> {
+pub fn sprint(_lua: &Lua, client: &mut Client, direction: u8) -> Result<()> {
    client.sprint(match direction {
        5 => SprintDirection::ForwardRight,
        6 => SprintDirection::ForwardLeft,
@@ -226,21 +192,23 @@ pub fn sprint(_lua: &Lua, client: &Client, direction: u8) -> Result<()> {
    Ok(())
 }

-pub fn stop_pathfinding(_lua: &Lua, client: &Client, (): ()) -> Result<()> {
+pub fn stop_pathfinding(_lua: &Lua, client: &Client, _: ()) -> Result<()> {
    client.stop_pathfinding();
    Ok(())
 }

-pub fn stop_sleeping(_lua: &Lua, client: &Client, (): ()) -> Result<()> {
-    client.write_packet(ServerboundPlayerCommand {
-        id: *client.component::<MinecraftEntityId>(),
+pub fn stop_sleeping(_lua: &Lua, client: &Client, _: ()) -> Result<()> {
+    if let Err(error) = client.write_packet(ServerboundPlayerCommand {
+        id: client.component::<MinecraftEntityId>(),
        action: Action::StopSleeping,
        data: 0,
-    });
+    }) {
+        error!("failed to send PlayerCommand packet: {error:?}");
+    }
    Ok(())
 }

-pub fn walk(_lua: &Lua, client: &Client, direction: u8) -> Result<()> {
+pub fn walk(_lua: &Lua, client: &mut Client, direction: u8) -> Result<()> {
    client.walk(match direction {
        1 => WalkDirection::Forward,
        2 => WalkDirection::Backward,
--- a/src/lua/client/state.rs
+++ b/src/lua/client/state.rs
@@ -1,25 +1,18 @@
+use crate::hacks::anti_knockback::AntiKnockback;
+
+use super::Client;
 use azalea::{
-    ClientInformation, entity::metadata::AirSupply, pathfinder::debug::PathfinderDebugParticles,
+    ClientInformation,
+    entity::metadata::{AirSupply, Score},
+    pathfinder::PathfinderDebugParticles,
    protocol::common::client_information::ModelCustomization,
 };
 use mlua::{Error, Lua, Result, Table, UserDataRef};

-use super::Client;
-use crate::{hacks::anti_knockback::AntiKnockback, unpack};
-
 pub fn air_supply(_lua: &Lua, client: &Client) -> Result<i32> {
    Ok(client.component::<AirSupply>().0)
 }

-pub fn experience(lua: &Lua, client: &Client) -> Result<Table> {
-    let experience = client.experience();
-    let table = lua.create_table()?;
-    table.set("progress", experience.progress)?;
-    table.set("total", experience.total)?;
-    table.set("level", experience.level)?;
-    Ok(table)
-}
-
 pub fn health(_lua: &Lua, client: &Client) -> Result<f32> {
    Ok(client.health())
 }
@@ -32,33 +25,36 @@ pub fn hunger(lua: &Lua, client: &Client) -> Result<Table> {
    Ok(table)
 }

+pub fn score(_lua: &Lua, client: &Client) -> Result<i32> {
+    Ok(client.component::<Score>().0)
+}
+
 pub async fn set_client_information(
    _lua: Lua,
    client: UserDataRef<Client>,
    info: Table,
 ) -> Result<()> {
-    let client = unpack!(client);
-
    let get_bool = |table: &Table, name| table.get(name).unwrap_or(true);
-    client.set_client_information(ClientInformation {
+    client
+        .set_client_information(ClientInformation {
            allows_listing: info.get("allows_listing")?,
            model_customization: info
                .get::<Table>("model_customization")
-            .as_ref()
                .map(|t| ModelCustomization {
-                cape: get_bool(t, "cape"),
-                jacket: get_bool(t, "jacket"),
-                left_sleeve: get_bool(t, "left_sleeve"),
-                right_sleeve: get_bool(t, "right_sleeve"),
-                left_pants: get_bool(t, "left_pants"),
-                right_pants: get_bool(t, "right_pants"),
-                hat: get_bool(t, "hat"),
+                    cape: get_bool(&t, "cape"),
+                    jacket: get_bool(&t, "jacket"),
+                    left_sleeve: get_bool(&t, "left_sleeve"),
+                    right_sleeve: get_bool(&t, "right_sleeve"),
+                    left_pants: get_bool(&t, "left_pants"),
+                    right_pants: get_bool(&t, "right_pants"),
+                    hat: get_bool(&t, "hat"),
                })
                .unwrap_or_default(),
            view_distance: info.get("view_distance").unwrap_or(8),
            ..ClientInformation::default()
-    });
-    Ok(())
+        })
+        .await
+        .map_err(Error::external)
 }

 pub fn set_component(
@@ -68,7 +64,7 @@ pub fn set_component(
 ) -> Result<()> {
    macro_rules! set {
        ($name:ident) => {{
-            let mut ecs = client.ecs.write();
+            let mut ecs = client.ecs.lock();
            let mut entity = ecs.entity_mut(client.entity);
            if enabled.unwrap_or(true) {
                entity.insert($name)
--- a/src/lua/client/world/find.rs
+++ b/src/lua/client/world/find.rs
@@ -1,17 +1,16 @@
+use super::{Client, Direction, Vec3};
 use azalea::{
    BlockPos,
-    block::{BlockState, BlockStates},
+    blocks::{BlockState, BlockStates},
    ecs::query::{With, Without},
    entity::{
-        Dead, EntityKindComponent, EntityUuid, LookDirection, Pose, Position as AzaleaPosition,
+        Dead, EntityKind, EntityUuid, LookDirection, Pose, Position as AzaleaPosition,
        metadata::{CustomName, Owneruuid, Player},
    },
+    world::MinecraftEntityId,
 };
 use mlua::{Function, Lua, Result, Table, UserDataRef};

-use super::{Client, Direction, Vec3};
-use crate::{lua::client::MinecraftEntityId, unpack};
-
 pub fn blocks(
    _lua: &Lua,
    client: &Client,
@@ -28,10 +27,7 @@ pub fn blocks(
                nearest_to.z as i32,
            ),
            &BlockStates {
-                set: block_states
-                    .into_iter()
-                    .flat_map(BlockState::try_from)
-                    .collect(),
+                set: block_states.iter().map(|&id| BlockState { id }).collect(),
            },
        )
        .map(Vec3::from)
@@ -39,8 +35,6 @@ pub fn blocks(
 }

 pub async fn all_entities(lua: Lua, client: UserDataRef<Client>, (): ()) -> Result<Vec<Table>> {
-    let client = unpack!(client);
-
    let mut matched = Vec::with_capacity(256);
    for (position, custom_name, kind, uuid, direction, id, owner_uuid, pose) in
        get_entities!(client)
@@ -67,8 +61,6 @@ pub async fn entities(
    client: UserDataRef<Client>,
    filter_fn: Function,
 ) -> Result<Vec<Table>> {
-    let client = unpack!(client);
-
    let mut matched = Vec::new();
    for (position, custom_name, kind, uuid, direction, id, owner_uuid, pose) in
        get_entities!(client)
@@ -93,8 +85,6 @@ pub async fn entities(
 }

 pub async fn all_players(lua: Lua, client: UserDataRef<Client>, (): ()) -> Result<Vec<Table>> {
-    let client = unpack!(client);
-
    let mut matched = Vec::new();
    for (id, uuid, kind, position, direction, pose) in get_players!(client) {
        let table = lua.create_table()?;
@@ -114,8 +104,6 @@ pub async fn players(
    client: UserDataRef<Client>,
    filter_fn: Function,
 ) -> Result<Vec<Table>> {
-    let client = unpack!(client);
-
    let mut matched = Vec::new();
    for (id, uuid, kind, position, direction, pose) in get_players!(client) {
        let table = lua.create_table()?;
--- a/src/lua/client/world/mod.rs
+++ b/src/lua/client/world/mod.rs
@@ -2,24 +2,20 @@
 mod queries;
 pub mod find;

-use azalea::{BlockPos, block::BlockState, world::WorldName};
-use mlua::{Lua, Result, Table, Value};
-
 use super::{Client, Direction, Vec3};
+use azalea::{BlockPos, auto_tool::AutoToolClientExt, blocks::BlockState, world::InstanceName};
+use mlua::{Lua, Result, Table};

-pub fn best_tool_for_block(lua: &Lua, client: &Client, block_state: u16) -> Result<Value> {
-    let Ok(block) = BlockState::try_from(block_state) else {
-        return Ok(Value::Nil);
-    };
-    let result = client.best_tool_in_hotbar_for_block(block);
+pub fn best_tool_for_block(lua: &Lua, client: &Client, block_state: u16) -> Result<Table> {
+    let result = client.best_tool_in_hotbar_for_block(BlockState { id: block_state });
    let table = lua.create_table()?;
    table.set("index", result.index)?;
    table.set("percentage_per_tick", result.percentage_per_tick)?;
-    Ok(Value::Table(table))
+    Ok(table)
 }

 pub fn dimension(_lua: &Lua, client: &Client) -> Result<String> {
-    Ok(client.component::<WorldName>().to_string())
+    Ok(client.component::<InstanceName>().to_string())
 }

 pub fn get_block_state(_lua: &Lua, client: &Client, position: Vec3) -> Result<Option<u16>> {
@@ -27,22 +23,22 @@ pub fn get_block_state(_lua: &Lua, client: &Client, position: Vec3) -> Result<Op
    Ok(client
        .world()
        .read()
-        .get_block_state(BlockPos::new(
+        .get_block_state(&BlockPos::new(
            position.x as i32,
            position.y as i32,
            position.z as i32,
        ))
-        .map(|block| block.id()))
+        .map(|block| block.id))
 }

-#[allow(clippy::cast_possible_truncation)]
 pub fn get_fluid_state(lua: &Lua, client: &Client, position: Vec3) -> Result<Option<Table>> {
-    let fluid_state = client.world().read().get_fluid_state(BlockPos::new(
+    #[allow(clippy::cast_possible_truncation)]
+    Ok(
+        if let Some(state) = client.world().read().get_fluid_state(&BlockPos::new(
            position.x as i32,
            position.y as i32,
            position.z as i32,
-    ));
-    Ok(if let Some(state) = fluid_state {
+        )) {
            let table = lua.create_table()?;
            table.set("kind", state.kind as u8)?;
            table.set("amount", state.amount)?;
@@ -50,5 +46,6 @@ pub fn get_fluid_state(lua: &Lua, client: &Client, position: Vec3) -> Result<Opt
            Some(table)
        } else {
            None
-    })
+        },
+    )
 }
--- a/src/lua/client/world/queries.rs
+++ b/src/lua/client/world/queries.rs
@@ -1,24 +1,22 @@
 #[macro_export]
 macro_rules! get_entities {
    ($client:ident) => {{
-        let ecs = $client.ecs.read();
-        ecs.try_query::<(
+        let mut ecs = $client.ecs.lock();
+        ecs.query::<(
            &AzaleaPosition,
            &CustomName,
-            &EntityKindComponent,
+            &EntityKind,
            &EntityUuid,
            &LookDirection,
            &MinecraftEntityId,
            Option<&Owneruuid>,
            &Pose,
        )>()
-        .map(|mut query| {
-            query
        .iter(&ecs)
        .map(
            |(position, custom_name, kind, uuid, direction, id, owner_uuid, pose)| {
                (
-                            Vec3::from(*position),
+                    Vec3::from(position),
                    custom_name.as_ref().map(ToString::to_string),
                    kind.to_string(),
                    uuid.to_string(),
@@ -30,38 +28,32 @@ macro_rules! get_entities {
            },
        )
        .collect::<Vec<_>>()
-        })
-        .unwrap_or_default()
    }};
 }

 #[macro_export]
 macro_rules! get_players {
    ($client:ident) => {{
-        let ecs = $client.ecs.read();
-        ecs.try_query_filtered::<(
+        let mut ecs = $client.ecs.lock();
+        ecs.query_filtered::<(
            &MinecraftEntityId,
            &EntityUuid,
-            &EntityKindComponent,
+            &EntityKind,
            &AzaleaPosition,
            &LookDirection,
            &Pose,
        ), (With<Player>, Without<Dead>)>()
-            .map(|mut query| {
-                query
            .iter(&ecs)
            .map(|(id, uuid, kind, position, direction, pose)| {
                (
                    id.0,
                    uuid.to_string(),
                    kind.to_string(),
-                            Vec3::from(*position),
+                    Vec3::from(position),
                    Direction::from(direction),
                    *pose as u8,
                )
            })
            .collect::<Vec<_>>()
-            })
-            .unwrap_or_default()
    }};
 }
--- a/src/lua/container/item_stack.rs
+++ b/src/lua/container/item_stack.rs
@@ -1,5 +1,5 @@
 use azalea::inventory::{
-    self, ItemStackData,
+    self,
    components::{Consumable, CustomName, Damage, Food, MaxDamage},
 };
 use mlua::{UserData, UserDataFields, UserDataMethods};
@@ -14,7 +14,8 @@ impl UserData for ItemStack {
        f.add_field_method_get("kind", |_, this| Ok(this.0.kind().to_string()));
        f.add_field_method_get("custom_name", |_, this| {
            Ok(this.0.as_present().map(|data| {
-                data.get_component::<CustomName>()
+                data.components
+                    .get::<CustomName>()
                    .map(|c| c.name.to_string())
            }))
        });
@@ -22,13 +23,13 @@ impl UserData for ItemStack {
            Ok(this
                .0
                .as_present()
-                .map(|data| data.get_component::<Damage>().map(|d| d.amount)))
+                .map(|data| data.components.get::<Damage>().map(|d| d.amount)))
        });
        f.add_field_method_get("max_damage", |_, this| {
            Ok(this
                .0
                .as_present()
-                .map(|data| data.get_component::<MaxDamage>().map(|d| d.amount)))
+                .map(|data| data.components.get::<MaxDamage>().map(|d| d.amount)))
        });

        f.add_field_method_get("consumable", |lua, this| {
@@ -36,7 +37,7 @@ impl UserData for ItemStack {
                if let Some(consumable) = this
                    .0
                    .as_present()
-                    .and_then(ItemStackData::get_component::<Consumable>)
+                    .and_then(|data| data.components.get::<Consumable>())
                {
                    let table = lua.create_table()?;
                    table.set("animation", consumable.animation as u8)?;
@@ -54,12 +55,13 @@ impl UserData for ItemStack {
                if let Some(food) = this
                    .0
                    .as_present()
-                    .and_then(ItemStackData::get_component::<Food>)
+                    .and_then(|data| data.components.get::<Food>())
                {
                    let table = lua.create_table()?;
                    table.set("nutrition", food.nutrition)?;
                    table.set("saturation", food.saturation)?;
                    table.set("can_always_eat", food.can_always_eat)?;
+                    table.set("eat_seconds", food.eat_seconds)?;
                    Some(table)
                } else {
                    None
@@ -69,7 +71,9 @@ impl UserData for ItemStack {
    }

    fn add_methods<M: UserDataMethods<Self>>(m: &mut M) {
-        m.add_method_mut("split", |_, this, count: u32| Ok(Self(this.0.split(count))));
+        m.add_method_mut("split", |_, this, count: u32| {
+            Ok(ItemStack(this.0.split(count)))
+        });
        m.add_method_mut("update_empty", |_, this, (): ()| {
            this.0.update_empty();
            Ok(())
--- a/src/lua/direction.rs
+++ b/src/lua/direction.rs
@@ -10,8 +10,8 @@ pub struct Direction {
 impl From<&LookDirection> for Direction {
    fn from(d: &LookDirection) -> Self {
        Self {
-            y: d.y_rot(),
-            x: d.x_rot(),
+            y: d.y_rot,
+            x: d.x_rot,
        }
    }
 }
--- a/src/lua/events.rs
+++ b/src/lua/events.rs
@@ -1,9 +1,7 @@
-use std::time::{SystemTime, UNIX_EPOCH};
-
+use crate::ListenerMap;
 use futures::executor::block_on;
 use mlua::{Function, Lua, Result, Table};
-
-use crate::ListenerMap;
+use std::time::{SystemTime, UNIX_EPOCH};

 pub fn register_globals(lua: &Lua, globals: &Table, event_listeners: ListenerMap) -> Result<()> {
    let m = event_listeners.clone();
@@ -13,15 +11,13 @@ pub fn register_globals(lua: &Lua, globals: &Table, event_listeners: ListenerMap
            move |_, (event_type, callback, optional_id): (String, Function, Option<String>)| {
                let m = m.clone();
                let id = optional_id.unwrap_or_else(|| {
-                    callback.info().name.unwrap_or_else(|| {
-                        format!(
+                    callback.info().name.unwrap_or(format!(
                        "anonymous @ {}",
                        SystemTime::now()
                            .duration_since(UNIX_EPOCH)
                            .unwrap_or_default()
                            .as_millis()
-                        )
-                    })
+                    ))
                });
                tokio::spawn(async move {
                    m.write()
@@ -42,10 +38,12 @@ pub fn register_globals(lua: &Lua, globals: &Table, event_listeners: ListenerMap
            let m = m.clone();
            tokio::spawn(async move {
                let mut m = m.write().await;
-                let empty = m.get_mut(&event_type).is_some_and(|listeners| {
+                let empty = if let Some(listeners) = m.get_mut(&event_type) {
                    listeners.retain(|(id, _)| target_id != *id);
                    listeners.is_empty()
-                });
+                } else {
+                    false
+                };
                if empty {
                    m.remove(&event_type);
                }
--- a/src/lua/matrix/client.rs
+++ b/src/lua/matrix/client.rs
@@ -1,12 +1,10 @@
-use std::sync::Arc;
-
+use super::room::Room;
 use matrix_sdk::{
    Client as MatrixClient,
    ruma::{RoomId, UserId},
 };
 use mlua::{Error, UserData, UserDataFields, UserDataMethods};
-
-use super::room::Room;
+use std::sync::Arc;

 pub struct Client(pub Arc<MatrixClient>);

--- a/src/lua/matrix/room.rs
+++ b/src/lua/matrix/room.rs
@@ -1,3 +1,4 @@
+use super::member::Member;
 use matrix_sdk::{
    RoomMemberships,
    room::Room as MatrixRoom,
@@ -5,8 +6,6 @@ use matrix_sdk::{
 };
 use mlua::{Error, UserData, UserDataFields, UserDataMethods};

-use super::member::Member;
-
 pub struct Room(pub MatrixRoom);

 impl UserData for Room {
@@ -37,7 +36,12 @@ impl UserData for Room {
                .members(RoomMemberships::all())
                .await
                .map_err(Error::external)
-                .map(|members| members.into_iter().map(Member).collect::<Vec<_>>())
+                .map(|members| {
+                    members
+                        .into_iter()
+                        .map(|member| Member(member.clone()))
+                        .collect::<Vec<_>>()
+                })
        });
        m.add_async_method(
            "kick_user",
@@ -75,15 +79,5 @@ impl UserData for Room {
                .map_err(Error::external)
                .map(|response| response.event_id.to_string())
        });
-        m.add_async_method(
-            "send_html",
-            async |_, this, (body, html_body): (String, String)| {
-                this.0
-                    .send(RoomMessageEventContent::text_html(body, html_body))
-                    .await
-                    .map_err(Error::external)
-                    .map(|response| response.event_id.to_string())
-            },
-        );
    }
 }
--- a/src/lua/mod.rs
+++ b/src/lua/mod.rs
@@ -13,15 +13,13 @@ pub mod vec3;
 #[cfg(feature = "matrix")]
 pub mod matrix;

+use crate::{ListenerMap, build_info::built};
+use mlua::{Lua, Table};
 use std::{
    fmt::{self, Display, Formatter},
    io,
 };

-use mlua::{Lua, Table};
-
-use crate::{ListenerMap, build_info::built};
-
 #[derive(Debug)]
 pub enum Error {
    CreateEnv(mlua::Error),
@@ -38,12 +36,12 @@ impl Display for Error {
            formatter,
            "failed to {}",
            match self {
-                Self::CreateEnv(error) => format!("create environment: {error}"),
-                Self::EvalChunk(error) => format!("evaluate chunk: {error}"),
-                Self::ExecChunk(error) => format!("execute chunk: {error}"),
-                Self::LoadChunk(error) => format!("load chunk: {error}"),
-                Self::MissingPath(error) => format!("get SCRIPT_PATH global: {error}"),
-                Self::ReadFile(error) => format!("read script file: {error}"),
+                Error::CreateEnv(error) => format!("create environment: {error}"),
+                Error::EvalChunk(error) => format!("evaluate chunk: {error}"),
+                Error::ExecChunk(error) => format!("execute chunk: {error}"),
+                Error::LoadChunk(error) => format!("load chunk: {error}"),
+                Error::MissingPath(error) => format!("get SCRIPT_PATH global: {error}"),
+                Error::ReadFile(error) => format!("read script file: {error}"),
            }
        )
    }
--- a/src/lua/nochatreports/crypt.rs
+++ b/src/lua/nochatreports/crypt.rs
@@ -3,8 +3,9 @@ macro_rules! crypt {
    ($op:ident, $options:expr, $text:expr) => {{
        macro_rules! crypt_with {
            ($algo:ident) => {{
+                let encoding = $options.get("encoding").unwrap_or_default();
                let key = &$options.get::<UserDataRef<AesKey>>("key")?.0;
-                match $options.get("encoding").unwrap_or_default() {
+                match encoding {
                    1 => $algo::<Base64Encoding>::$op($text, &key),
                    2 => $algo::<Base64rEncoding>::$op($text, &key),
                    _ => $algo::<NewBase64rEncoding>::$op($text, &key),
--- a/src/lua/player.rs
+++ b/src/lua/player.rs
@@ -1,4 +1,4 @@
-use azalea::player::PlayerInfo;
+use azalea::PlayerInfo;
 use mlua::{IntoLua, Lua, Result, Value};

 #[derive(Clone)]
--- a/src/lua/system.rs
+++ b/src/lua/system.rs
@@ -1,12 +1,11 @@
+use log::error;
+use mlua::{Lua, Result, Table};
 use std::{
    ffi::OsString,
    process::{Command, Stdio},
    thread,
 };

-use log::error;
-use mlua::{Lua, Result, Table};
-
 pub fn register_globals(lua: &Lua, globals: &Table) -> Result<()> {
    globals.set(
        "system",
--- a/src/lua/thread.rs
+++ b/src/lua/thread.rs
@@ -1,6 +1,5 @@
-use std::time::Duration;
-
 use mlua::{Error, Function, Lua, Result, Table};
+use std::time::Duration;
 use tokio::time::{sleep, timeout};

 pub fn register_globals(lua: &Lua, globals: &Table) -> Result<()> {
--- a/src/lua/vec3.rs
+++ b/src/lua/vec3.rs
@@ -28,8 +28,8 @@ impl From<azalea::Vec3> for Vec3 {
    }
 }

-impl From<Position> for Vec3 {
-    fn from(p: Position) -> Self {
+impl From<&Position> for Vec3 {
+    fn from(p: &Position) -> Self {
        Self {
            x: p.x,
            y: p.y,
@@ -40,7 +40,7 @@ impl From<Position> for Vec3 {

 impl From<BlockPos> for Vec3 {
    fn from(p: BlockPos) -> Self {
-        Self {
+        Vec3 {
            x: f64::from(p.x),
            y: f64::from(p.y),
            z: f64::from(p.z),
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,5 +1,4 @@
-#![warn(clippy::pedantic, clippy::nursery)]
-#![allow(clippy::significant_drop_tightening)]
+#![feature(if_let_guard, let_chains)]

 mod arguments;
 mod build_info;
@@ -9,24 +8,15 @@ mod hacks;
 mod http;
 mod lua;
 mod particle;
+mod replay;

 #[cfg(feature = "matrix")]
 mod matrix;

-#[cfg(feature = "replay")]
-mod replay;
-
-use std::{
-    collections::HashMap,
-    env,
-    fs::{OpenOptions, read_to_string},
-    sync::Arc,
-};
-
-use anyhow::{Context, Result, bail};
+use anyhow::Context;
 use arguments::Arguments;
 use azalea::{
-    DefaultPlugins, bot::DefaultBotPlugins, brigadier::prelude::CommandDispatcher, prelude::*,
+    DefaultBotPlugins, DefaultPlugins, brigadier::prelude::CommandDispatcher, prelude::*,
 };
 use bevy_app::PluginGroup;
 use bevy_log::{
@@ -37,16 +27,17 @@ use clap::Parser;
 use commands::{CommandSource, register};
 use futures::lock::Mutex;
 use futures_locks::RwLock;
+use hacks::HacksPlugin;
 use log::debug;
-use mlua::{Function, Lua};
-#[cfg(feature = "replay")]
-use {
-    mlua::Table,
-    replay::{plugin::RecordPlugin, recorder::Recorder},
+use mlua::{Function, Lua, Table};
+use replay::{plugin::RecordPlugin, recorder::Recorder};
+use std::{
+    collections::HashMap,
+    env,
+    fs::{OpenOptions, read_to_string},
+    sync::Arc,
 };

-use crate::hacks::HacksPlugin;
-
 #[cfg(feature = "mimalloc")]
 #[global_allocator]
 static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
@@ -54,14 +45,14 @@ static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 type ListenerMap = Arc<RwLock<HashMap<String, Vec<(String, Function)>>>>;

 #[derive(Default, Clone, Component)]
-struct State {
+pub struct State {
    lua: Arc<Lua>,
    event_listeners: ListenerMap,
    commands: Arc<CommandDispatcher<Mutex<CommandSource>>>,
 }

 #[tokio::main]
-async fn main() -> Result<()> {
+async fn main() -> anyhow::Result<()> {
    #[cfg(feature = "console-subscriber")]
    console_subscriber::init();

@@ -101,25 +92,21 @@ async fn main() -> Result<()> {
        DefaultPlugins.set(LogPlugin {
            custom_layer: |_| {
                env::var("LOG_FILE").ok().map(|path| {
-                    let file = OpenOptions::new()
+                    layer()
+                        .with_writer(
+                            OpenOptions::new()
                                .append(true)
                                .create(true)
                                .open(&path)
-                        .expect(&(path + " should be accessible"));
-                    layer().with_writer(file).boxed()
+                                .expect(&(path + " should be accessible")),
+                        )
+                        .boxed()
                })
            },
            ..Default::default()
        })
    };
-
-    let builder = ClientBuilder::new_without_plugins()
-        .add_plugins(default_plugins)
-        .add_plugins(DefaultBotPlugins)
-        .add_plugins(HacksPlugin);
-
-    #[cfg(feature = "replay")]
-    let builder = builder.add_plugins(RecordPlugin {
+    let record_plugin = RecordPlugin {
        recorder: Arc::new(parking_lot::Mutex::new(
            if let Ok(options) = globals.get::<Table>("ReplayRecordingOptions")
                && let Ok(path) = options.get::<String>("path")
@@ -135,15 +122,18 @@ async fn main() -> Result<()> {
                None
            },
        )),
-    });
-
+    };
    let account = if username.contains('@') {
        Account::microsoft(&username).await?
    } else {
        Account::offline(&username)
    };

-    if let AppExit::Error(code) = builder
+    let Err(error) = ClientBuilder::new_without_plugins()
+        .add_plugins(DefaultBotPlugins)
+        .add_plugins(HacksPlugin)
+        .add_plugins(default_plugins)
+        .add_plugins(record_plugin)
        .set_handler(events::handle_event)
        .set_state(State {
            lua: Arc::new(lua),
@@ -151,10 +141,8 @@ async fn main() -> Result<()> {
            commands: Arc::new(commands),
        })
        .start(account, server)
-        .await
-    {
-        bail!("azalea exited with code {code}")
-    }
+        .await;
+    eprintln!("{error}");

    Ok(())
 }
--- a/src/matrix/bot.rs
+++ b/src/matrix/bot.rs
@@ -1,5 +1,8 @@
-use std::time::Duration;
-
+use super::Context;
+use crate::{
+    events::call_listeners,
+    lua::{eval, exec, matrix::room::Room as LuaRoom, reload},
+};
 use anyhow::Result;
 use log::{debug, error};
 use matrix_sdk::{
@@ -10,14 +13,9 @@ use matrix_sdk::{
        message::{MessageType, OriginalSyncRoomMessageEvent, RoomMessageEventContent},
    },
 };
+use std::time::Duration;
 use tokio::time::sleep;

-use super::Context;
-use crate::{
-    events::call_listeners,
-    lua::{eval, exec, matrix::room::Room as LuaRoom, reload},
-};
-
 pub async fn on_regular_room_message(
    event: OriginalSyncRoomMessageEvent,
    room: Room,
@@ -30,7 +28,7 @@ pub async fn on_regular_room_message(
        return Ok(());
    };

-    if text_content.body.starts_with(&ctx.name) && ctx.is_owner(&event.sender.to_string()) {
+    if ctx.is_owner(&event.sender.to_string()) && text_content.body.starts_with(&ctx.name) {
        let body = text_content.body[ctx.name.len()..]
            .trim_start_matches(':')
            .trim();
@@ -99,7 +97,10 @@ pub async fn on_stripped_state_member(
    {
        debug!("joining room {}", room.room_id());
        while let Err(error) = room.join().await {
-            error!("failed to join room {}: {error:?}", room.room_id());
+            error!(
+                "failed to join room {}: {error:?}, retrying...",
+                room.room_id()
+            );
            sleep(Duration::from_secs(10)).await;
        }
        debug!("successfully joined room {}", room.room_id());
--- a/src/matrix/mod.rs
+++ b/src/matrix/mod.rs
@@ -1,8 +1,7 @@
 mod bot;
 mod verification;

-use std::{path::Path, sync::Arc, time::Duration};
-
+use crate::{State, lua::matrix::client::Client as LuaClient};
 use anyhow::{Context as _, Result};
 use bot::{on_regular_room_message, on_stripped_state_member};
 use log::{error, warn};
@@ -11,13 +10,12 @@ use matrix_sdk::{
 };
 use mlua::Table;
 use serde::{Deserialize, Serialize};
+use std::{path::Path, sync::Arc};
 use tokio::fs;
 use verification::{on_device_key_verification_request, on_room_message_verification_request};

-use crate::{State, events::call_listeners, lua::matrix::client::Client as LuaClient};
-
 #[derive(Clone)]
-struct Context {
+pub struct Context {
    state: State,
    name: String,
 }
@@ -31,7 +29,7 @@ impl Context {
            .ok()
            .and_then(|options| {
                options
-                    .get::<Vec<String>>("owners")
+                    .get::<Vec<String>>("Owners")
                    .ok()
                    .and_then(|owners| owners.contains(name).then_some(()))
            })
@@ -56,13 +54,13 @@ async fn persist_sync_token(
    Ok(())
 }

-pub async fn login(state: &State, options: &Table, globals: &Table, name: String) -> Result<()> {
-    let (homeserver_url, username, password, sync_timeout) = (
-        options.get::<String>("homeserver_url")?,
-        options.get::<String>("username")?,
-        &options.get::<String>("password")?,
-        options.get::<u64>("sync_timeout"),
+pub async fn login(state: State, options: Table, globals: Table, name: String) -> Result<()> {
+    let (homeserver_url, username, password) = (
+        options.get::<String>("HomeserverUrl")?,
+        options.get::<String>("Username")?,
+        &options.get::<String>("Password")?,
    );
+
    let root_dir = dirs::data_dir()
        .context("no data directory")?
        .join("errornowatcher")
@@ -79,12 +77,8 @@ pub async fn login(state: &State, options: &Table, globals: &Table, name: String
    }
    let client = builder.build().await?;

-    let mut sync_settings = SyncSettings::new();
-    if let Ok(seconds) = sync_timeout {
-        sync_settings = sync_settings.timeout(Duration::from_secs(seconds));
-    }
-
    let mut new_session;
+    let mut sync_settings = SyncSettings::default();
    let session_file = root_dir.join("session.json");
    if let Some(session) = fs::read_to_string(&session_file)
        .await
@@ -110,10 +104,7 @@ pub async fn login(state: &State, options: &Table, globals: &Table, name: String
        fs::write(&session_file, serde_json::to_string(&new_session)?).await?;
    }

-    client.add_event_handler_context(Context {
-        state: state.to_owned(),
-        name,
-    });
+    client.add_event_handler_context(Context { state, name });
    client.add_event_handler(on_stripped_state_member);
    loop {
        match client.sync_once(sync_settings.clone()).await {
@@ -134,7 +125,6 @@ pub async fn login(state: &State, options: &Table, globals: &Table, name: String

    let client = Arc::new(client);
    globals.set("matrix", LuaClient(client.clone()))?;
-    call_listeners(state, "matrix_init", || Ok(())).await?;

    client
        .sync_with_result_callback(sync_settings, |sync_result| async {
--- a/src/matrix/verification.rs
+++ b/src/matrix/verification.rs
@@ -1,5 +1,3 @@
-use std::time::Duration;
-
 use anyhow::{Context, Result};
 use futures::StreamExt;
 use log::{error, info, warn};
@@ -17,6 +15,7 @@ use matrix_sdk::{
        },
    },
 };
+use std::time::Duration;
 use tokio::time::sleep;

 async fn confirm_emojis(sas: SasVerification, emoji: [Emoji; 7]) {
--- a/src/particle.rs
+++ b/src/particle.rs
@@ -1,124 +1,119 @@
-use azalea::{entity::particle::Particle, registry::builtin::ParticleKind};
+use azalea::{entity::particle::Particle, registry::ParticleKind};

 #[allow(clippy::too_many_lines)]
-pub const fn to_kind(particle: &Particle) -> ParticleKind {
+pub fn to_kind(particle: &Particle) -> ParticleKind {
    match particle {
        Particle::AngryVillager => ParticleKind::AngryVillager,
-        Particle::Ash => ParticleKind::Ash,
        Particle::Block(_) => ParticleKind::Block,
-        Particle::BlockCrumble => ParticleKind::BlockCrumble,
        Particle::BlockMarker(_) => ParticleKind::BlockMarker,
        Particle::Bubble => ParticleKind::Bubble,
-        Particle::BubbleColumnUp => ParticleKind::BubbleColumnUp,
-        Particle::BubblePop => ParticleKind::BubblePop,
-        Particle::CampfireCosySmoke => ParticleKind::CampfireCosySmoke,
-        Particle::CampfireSignalSmoke => ParticleKind::CampfireSignalSmoke,
-        Particle::CherryLeaves => ParticleKind::CherryLeaves,
        Particle::Cloud => ParticleKind::Cloud,
-        Particle::Composter => ParticleKind::Composter,
-        Particle::CopperFireFlame => ParticleKind::CopperFireFlame,
-        Particle::CrimsonSpore => ParticleKind::CrimsonSpore,
        Particle::Crit => ParticleKind::Crit,
-        Particle::CurrentDown => ParticleKind::CurrentDown,
        Particle::DamageIndicator => ParticleKind::DamageIndicator,
-        Particle::Dolphin => ParticleKind::Dolphin,
        Particle::DragonBreath => ParticleKind::DragonBreath,
-        Particle::DrippingDripstoneLava => ParticleKind::DrippingDripstoneLava,
-        Particle::DrippingDripstoneWater => ParticleKind::DrippingDripstoneWater,
-        Particle::DrippingHoney => ParticleKind::DrippingHoney,
        Particle::DrippingLava => ParticleKind::DrippingLava,
-        Particle::DrippingObsidianTear => ParticleKind::DrippingObsidianTear,
+        Particle::FallingLava => ParticleKind::FallingLava,
+        Particle::LandingLava => ParticleKind::LandingLava,
        Particle::DrippingWater => ParticleKind::DrippingWater,
+        Particle::FallingWater => ParticleKind::FallingWater,
        Particle::Dust(_) => ParticleKind::Dust,
        Particle::DustColorTransition(_) => ParticleKind::DustColorTransition,
-        Particle::DustPillar => ParticleKind::DustPillar,
-        Particle::DustPlume => ParticleKind::DustPlume,
        Particle::Effect => ParticleKind::Effect,
-        Particle::EggCrack => ParticleKind::EggCrack,
        Particle::ElderGuardian => ParticleKind::ElderGuardian,
-        Particle::ElectricSpark => ParticleKind::ElectricSpark,
-        Particle::Enchant => ParticleKind::Enchant,
        Particle::EnchantedHit => ParticleKind::EnchantedHit,
+        Particle::Enchant => ParticleKind::Enchant,
        Particle::EndRod => ParticleKind::EndRod,
        Particle::EntityEffect(_) => ParticleKind::EntityEffect,
-        Particle::Explosion => ParticleKind::Explosion,
        Particle::ExplosionEmitter => ParticleKind::ExplosionEmitter,
-        Particle::FallingDripstoneLava => ParticleKind::FallingDripstoneLava,
-        Particle::FallingDripstoneWater => ParticleKind::FallingDripstoneWater,
+        Particle::Explosion => ParticleKind::Explosion,
+        Particle::Gust => ParticleKind::Gust,
+        Particle::SonicBoom => ParticleKind::SonicBoom,
        Particle::FallingDust(_) => ParticleKind::FallingDust,
-        Particle::FallingHoney => ParticleKind::FallingHoney,
-        Particle::FallingLava => ParticleKind::FallingLava,
-        Particle::FallingNectar => ParticleKind::FallingNectar,
-        Particle::FallingObsidianTear => ParticleKind::FallingObsidianTear,
-        Particle::FallingSporeBlossom => ParticleKind::FallingSporeBlossom,
-        Particle::FallingWater => ParticleKind::FallingWater,
-        Particle::Firefly => ParticleKind::Firefly,
        Particle::Firework => ParticleKind::Firework,
        Particle::Fishing => ParticleKind::Fishing,
        Particle::Flame => ParticleKind::Flame,
+        Particle::CherryLeaves => ParticleKind::CherryLeaves,
+        Particle::PaleOakLeaves => ParticleKind::PaleOakLeaves,
+        Particle::SculkSoul => ParticleKind::SculkSoul,
+        Particle::SculkCharge(_) => ParticleKind::SculkCharge,
+        Particle::SculkChargePop => ParticleKind::SculkChargePop,
+        Particle::SoulFireFlame => ParticleKind::SoulFireFlame,
+        Particle::Soul => ParticleKind::Soul,
        Particle::Flash => ParticleKind::Flash,
-        Particle::Glow => ParticleKind::Glow,
-        Particle::GlowSquidInk => ParticleKind::GlowSquidInk,
-        Particle::Gust => ParticleKind::Gust,
-        Particle::GustEmitterLarge => ParticleKind::GustEmitterLarge,
-        Particle::GustEmitterSmall => ParticleKind::GustEmitterSmall,
        Particle::HappyVillager => ParticleKind::HappyVillager,
+        Particle::Composter => ParticleKind::Composter,
        Particle::Heart => ParticleKind::Heart,
-        Particle::Infested => ParticleKind::Infested,
        Particle::InstantEffect => ParticleKind::InstantEffect,
        Particle::Item(_) => ParticleKind::Item,
-        Particle::ItemCobweb => ParticleKind::ItemCobweb,
+        Particle::Vibration(_) => ParticleKind::Vibration,
        Particle::ItemSlime => ParticleKind::ItemSlime,
        Particle::ItemSnowball => ParticleKind::ItemSnowball,
-        Particle::LandingHoney => ParticleKind::LandingHoney,
-        Particle::LandingLava => ParticleKind::LandingLava,
-        Particle::LandingObsidianTear => ParticleKind::LandingObsidianTear,
        Particle::LargeSmoke => ParticleKind::LargeSmoke,
        Particle::Lava => ParticleKind::Lava,
        Particle::Mycelium => ParticleKind::Mycelium,
-        Particle::Nautilus => ParticleKind::Nautilus,
        Particle::Note => ParticleKind::Note,
-        Particle::OminousSpawning => ParticleKind::OminousSpawning,
-        Particle::PaleOakLeaves => ParticleKind::PaleOakLeaves,
-        Particle::PauseMobGrowth => ParticleKind::PauseMobGrowth,
        Particle::Poof => ParticleKind::Poof,
        Particle::Portal => ParticleKind::Portal,
-        Particle::RaidOmen => ParticleKind::RaidOmen,
        Particle::Rain => ParticleKind::Rain,
-        Particle::ResetMobGrowth => ParticleKind::ResetMobGrowth,
-        Particle::ReversePortal => ParticleKind::ReversePortal,
-        Particle::Scrape => ParticleKind::Scrape,
-        Particle::SculkCharge(_) => ParticleKind::SculkCharge,
-        Particle::SculkChargePop => ParticleKind::SculkChargePop,
-        Particle::SculkSoul => ParticleKind::SculkSoul,
-        Particle::Shriek(_) => ParticleKind::Shriek,
-        Particle::SmallFlame => ParticleKind::SmallFlame,
-        Particle::SmallGust => ParticleKind::SmallGust,
        Particle::Smoke => ParticleKind::Smoke,
+        Particle::WhiteSmoke => ParticleKind::WhiteSmoke,
        Particle::Sneeze => ParticleKind::Sneeze,
-        Particle::Snowflake => ParticleKind::Snowflake,
-        Particle::SonicBoom => ParticleKind::SonicBoom,
-        Particle::Soul => ParticleKind::Soul,
-        Particle::SoulFireFlame => ParticleKind::SoulFireFlame,
        Particle::Spit => ParticleKind::Spit,
-        Particle::Splash => ParticleKind::Splash,
-        Particle::SporeBlossomAir => ParticleKind::SporeBlossomAir,
        Particle::SquidInk => ParticleKind::SquidInk,
        Particle::SweepAttack => ParticleKind::SweepAttack,
-        Particle::TintedLeaves => ParticleKind::TintedLeaves,
        Particle::TotemOfUndying => ParticleKind::TotemOfUndying,
-        Particle::Trail => ParticleKind::Trail,
-        Particle::TrialOmen => ParticleKind::TrialOmen,
+        Particle::Underwater => ParticleKind::Underwater,
+        Particle::Splash => ParticleKind::Splash,
+        Particle::Witch => ParticleKind::Witch,
+        Particle::BubblePop => ParticleKind::BubblePop,
+        Particle::CurrentDown => ParticleKind::CurrentDown,
+        Particle::BubbleColumnUp => ParticleKind::BubbleColumnUp,
+        Particle::Nautilus => ParticleKind::Nautilus,
+        Particle::Dolphin => ParticleKind::Dolphin,
+        Particle::CampfireCosySmoke => ParticleKind::CampfireCosySmoke,
+        Particle::CampfireSignalSmoke => ParticleKind::CampfireSignalSmoke,
+        Particle::DrippingHoney => ParticleKind::DrippingHoney,
+        Particle::FallingHoney => ParticleKind::FallingHoney,
+        Particle::LandingHoney => ParticleKind::LandingHoney,
+        Particle::FallingNectar => ParticleKind::FallingNectar,
+        Particle::FallingSporeBlossom => ParticleKind::FallingSporeBlossom,
+        Particle::Ash => ParticleKind::Ash,
+        Particle::CrimsonSpore => ParticleKind::CrimsonSpore,
+        Particle::WarpedSpore => ParticleKind::WarpedSpore,
+        Particle::SporeBlossomAir => ParticleKind::SporeBlossomAir,
+        Particle::DrippingObsidianTear => ParticleKind::DrippingObsidianTear,
+        Particle::FallingObsidianTear => ParticleKind::FallingObsidianTear,
+        Particle::LandingObsidianTear => ParticleKind::LandingObsidianTear,
+        Particle::ReversePortal => ParticleKind::ReversePortal,
+        Particle::WhiteAsh => ParticleKind::WhiteAsh,
+        Particle::SmallFlame => ParticleKind::SmallFlame,
+        Particle::Snowflake => ParticleKind::Snowflake,
+        Particle::DrippingDripstoneLava => ParticleKind::DrippingDripstoneLava,
+        Particle::FallingDripstoneLava => ParticleKind::FallingDripstoneLava,
+        Particle::DrippingDripstoneWater => ParticleKind::DrippingDripstoneWater,
+        Particle::FallingDripstoneWater => ParticleKind::FallingDripstoneWater,
+        Particle::GlowSquidInk => ParticleKind::GlowSquidInk,
+        Particle::Glow => ParticleKind::Glow,
+        Particle::WaxOn => ParticleKind::WaxOn,
+        Particle::WaxOff => ParticleKind::WaxOff,
+        Particle::ElectricSpark => ParticleKind::ElectricSpark,
+        Particle::Scrape => ParticleKind::Scrape,
+        Particle::Shriek(_) => ParticleKind::Shriek,
+        Particle::EggCrack => ParticleKind::EggCrack,
+        Particle::DustPlume => ParticleKind::DustPlume,
+        Particle::SmallGust => ParticleKind::SmallGust,
+        Particle::GustEmitterLarge => ParticleKind::GustEmitterLarge,
+        Particle::GustEmitterSmall => ParticleKind::GustEmitterSmall,
+        Particle::Infested => ParticleKind::Infested,
+        Particle::ItemCobweb => ParticleKind::ItemCobweb,
        Particle::TrialSpawnerDetection => ParticleKind::TrialSpawnerDetection,
        Particle::TrialSpawnerDetectionOminous => ParticleKind::TrialSpawnerDetectionOminous,
-        Particle::Underwater => ParticleKind::Underwater,
        Particle::VaultConnection => ParticleKind::VaultConnection,
-        Particle::Vibration(_) => ParticleKind::Vibration,
-        Particle::WarpedSpore => ParticleKind::WarpedSpore,
-        Particle::WaxOff => ParticleKind::WaxOff,
-        Particle::WaxOn => ParticleKind::WaxOn,
-        Particle::WhiteAsh => ParticleKind::WhiteAsh,
-        Particle::WhiteSmoke => ParticleKind::WhiteSmoke,
-        Particle::Witch => ParticleKind::Witch,
+        Particle::DustPillar => ParticleKind::DustPillar,
+        Particle::OminousSpawning => ParticleKind::OminousSpawning,
+        Particle::RaidOmen => ParticleKind::RaidOmen,
+        Particle::TrialOmen => ParticleKind::TrialOmen,
+        Particle::Trail => ParticleKind::Trail,
+        Particle::BlockCrumble => ParticleKind::BlockCrumble,
    }
 }
--- a/src/replay/plugin.rs
+++ b/src/replay/plugin.rs
@@ -1,40 +1,43 @@
 #![allow(clippy::needless_pass_by_value)]

-use std::sync::Arc;
-
+use super::recorder::Recorder;
 use azalea::{
+    ecs::{event::EventReader, system::Query},
    packet::{
-        config::ReceiveConfigPacketEvent, game::ReceiveGamePacketEvent,
-        login::ReceiveLoginPacketEvent,
+        config::ReceiveConfigPacketEvent,
+        game::emit_receive_packet_events,
+        login::{LoginPacketEvent, process_packet_events},
    },
    protocol::packets::login::ClientboundLoginPacket,
+    raw_connection::RawConnection,
 };
-use bevy_app::{App, First, Plugin};
-use bevy_ecs::{message::MessageReader, system::ResMut};
+use bevy_app::{First, Plugin};
+use bevy_ecs::{schedule::IntoSystemConfigs, system::ResMut};
 use log::error;
 use parking_lot::Mutex;
-
-use super::recorder::Recorder;
+use std::sync::Arc;

 pub struct RecordPlugin {
    pub recorder: Arc<Mutex<Option<Recorder>>>,
 }

 impl Plugin for RecordPlugin {
-    fn build(&self, app: &mut App) {
-        let recorder = self.recorder.lock().take();
-        if let Some(recorder) = recorder {
+    fn build(&self, app: &mut bevy_app::App) {
+        if let Some(recorder) = self.recorder.lock().take() {
            app.insert_resource(recorder)
-                .add_systems(First, record_login_packets)
+                .add_systems(First, record_login_packets.before(process_packet_events))
                .add_systems(First, record_configuration_packets)
-                .add_systems(First, record_game_packets);
+                .add_systems(
+                    First,
+                    record_game_packets.before(emit_receive_packet_events),
+                );
        }
    }
 }

 fn record_login_packets(
    recorder: Option<ResMut<Recorder>>,
-    mut events: MessageReader<ReceiveLoginPacketEvent>,
+    mut events: EventReader<LoginPacketEvent>,
 ) {
    if let Some(mut recorder) = recorder {
        for event in events.read() {
@@ -53,24 +56,24 @@ fn record_login_packets(

 fn record_configuration_packets(
    recorder: Option<ResMut<Recorder>>,
-    mut events: MessageReader<ReceiveConfigPacketEvent>,
+    mut events: EventReader<ReceiveConfigPacketEvent>,
 ) {
    if let Some(mut recorder) = recorder {
        for event in events.read() {
-            if let Err(error) = recorder.save_packet(event.packet.as_ref()) {
+            if let Err(error) = recorder.save_packet(&event.packet) {
                error!("failed to record configuration packet: {error:?}");
            }
        }
    }
 }

-fn record_game_packets(
-    recorder: Option<ResMut<Recorder>>,
-    mut events: MessageReader<ReceiveGamePacketEvent>,
-) {
-    if let Some(mut recorder) = recorder {
-        for event in events.read() {
-            if let Err(error) = recorder.save_packet(event.packet.as_ref()) {
+fn record_game_packets(recorder: Option<ResMut<Recorder>>, query: Query<&RawConnection>) {
+    if let Some(mut recorder) = recorder
+        && let Ok(raw_conn) = query.get_single()
+    {
+        let queue = raw_conn.incoming_packet_queue();
+        for raw_packet in queue.lock().iter() {
+            if let Err(error) = recorder.save_raw_packet(raw_packet) {
                error!("failed to record game packet: {error:?}");
            }
        }
--- a/src/replay/recorder.rs
+++ b/src/replay/recorder.rs
@@ -1,21 +1,19 @@
-use std::{
-    fs::File,
-    io::{BufWriter, Write},
-    time::{Instant, SystemTime, UNIX_EPOCH},
-};
-
+use crate::build_info;
 use anyhow::Result;
 use azalea::{
-    buf::AzBufVar,
+    buf::AzaleaWriteVar,
    prelude::Resource,
    protocol::packets::{PROTOCOL_VERSION, ProtocolPacket, VERSION_NAME},
 };
 use log::debug;
 use serde_json::json;
+use std::{
+    fs::File,
+    io::{BufWriter, Write},
+    time::{Instant, SystemTime, UNIX_EPOCH},
+};
 use zip::{ZipWriter, write::SimpleFileOptions};

-use crate::build_info;
-
 #[derive(Resource)]
 pub struct Recorder {
    zip_writer: BufWriter<ZipWriter<File>>,
@@ -58,7 +56,7 @@ impl Recorder {
                "fileFormat": "MCPR",
                "fileFormatVersion": 14,
                "protocol": PROTOCOL_VERSION,
-                "generator": format!("ErrorNoWatcher {}", build_info::version_formatted()),
+                "generator": format!("errornowatcher {}", build_info::version_formatted()),
            })
            .to_string()
            .as_bytes(),
Author	SHA1	Message	Date
ErrorNoInternet	e85d02cee2	chore(deps): update azalea	2025-03-20 18:32:07 -04:00
ErrorNoInternet	ab3ff0ab16	refactor!(matrix): move options into a table	2025-03-20 18:32:06 -04:00
ErrorNoInternet	f96ad40276	refactor: expand a few variable names	2025-03-20 18:32:03 -04:00