Cargo.lock

@@ -593,6 +593,14 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "azalea-hax"
+version = "0.1.0"
+source = "git+https://github.com/azalea-rs/azalea-hax#2af9e0759aded7df01770b717f207b3c1083f942"
+dependencies = [
+ "azalea",
+]
+
 [[package]]
 name = "azalea-inventory"
 version = "0.11.0+mc1.21.4"
@@ -1741,6 +1749,7 @@ version = "0.2.0"
 dependencies = [
  "anyhow",
  "azalea",
+ "azalea-hax",
  "bevy_app",
  "bevy_ecs",
  "bevy_log",
@@ -2962,7 +2971,6 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e27119e566a60f5681eb8d05f51ef10862dd9af611ac6c6e0dc9aa9bf3bcc493"
 dependencies = [
- "anyhow",
  "anymap2",
  "aquamarine",
  "as_variant",

Cargo.toml

@@ -21,6 +21,7 @@ built = { git = "https://github.com/lukaslueg/built", features = ["git2"] }
 [dependencies]
 anyhow = "1"
 azalea = { git = "https://github.com/azalea-rs/azalea" }
+azalea-hax = { git = "https://github.com/azalea-rs/azalea-hax" }
 bevy_app = "0"
 bevy_ecs = "0"
 bevy_log = "0"
@@ -34,7 +35,7 @@ http-body-util = "0"
 hyper = { version = "1", features = ["server"] }
 hyper-util = "0"
 log = { version = "0" }
-matrix-sdk = { version = "0", features = ["anyhow"], optional = true }
+matrix-sdk = { version = "0", optional = true }
 mimalloc = { version = "0", optional = true }
 mlua = { version = "0", features = ["async", "luajit", "send"] }
 ncr = { version = "0", features = ["cfb8", "ecb", "gcm"] }

src/events.rs

@@ -304,7 +304,7 @@ where
             let data = data.clone();
             tokio::spawn(async move {
                 if let Err(error) = callback.call_async::<()>(data).await {
-                    error!("failed to call lua event listener {id} for {event_type}: {error}");
+                    error!("failed to call lua event listener {id} for {event_type}: {error:?}");
                 }
             });
         }

src/hacks/anti_knockback.rs

@@ -1,20 +0,0 @@
-use azalea::{
-    Vec3,
-    movement::{KnockbackEvent, KnockbackType},
-    prelude::Component,
-};
-use bevy_ecs::{event::EventMutator, query::With, system::Query};
-
-#[derive(Component)]
-pub struct AntiKnockback;
-
-pub fn anti_knockback(
-    mut events: EventMutator<KnockbackEvent>,
-    entity_query: Query<(), With<AntiKnockback>>,
-) {
-    for event in events.read() {
-        if entity_query.get(event.entity).is_ok() {
-            event.knockback = KnockbackType::Add(Vec3::default());
-        }
-    }
-}

src/hacks/mod.rs

@@ -1,21 +0,0 @@
-#![allow(clippy::needless_pass_by_value)]
-
-pub mod anti_knockback;
-
-use anti_knockback::anti_knockback;
-use azalea::{movement::handle_knockback, packet_handling::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(
-            PreUpdate,
-            anti_knockback
-                .after(process_packet_events)
-                .before(handle_knockback),
-        );
-    }
-}

src/http.rs

@@ -12,30 +12,27 @@ pub async fn serve(
     request: Request<Incoming>,
     state: State,
 ) -> Result<Response<BoxBody<Bytes, Error>>, Error> {
+    macro_rules! handle_code {
+        ($handler:ident) => {
+            match std::str::from_utf8(&request.into_body().collect().await?.to_bytes()) {
+                Ok(code) => Response::new(full(format!(
+                    "{:#?}",
+                    $handler(&state.lua, code, None).await
+                ))),
+                Err(error) => status_code_response(
+                    StatusCode::BAD_REQUEST,
+                    full(format!("invalid utf-8 data received: {error:?}")),
+                ),
+            }
+        };
+    }
+
     Ok(match (request.method(), request.uri().path()) {
         (&Method::POST, "/reload") => {
             Response::new(full(format!("{:#?}", reload(&state.lua, None))))
         }
-        (&Method::POST, "/eval") => match eval(
+        (&Method::POST, "/eval") => handle_code!(eval),
-            &state.lua,
+        (&Method::POST, "/exec") => handle_code!(exec),
-            &String::from_utf8_lossy(&request.into_body().collect().await?.to_bytes()),
-            None,
-        )
-        .await
-        {
-            Ok(value) => status_code_response(StatusCode::OK, full(value.to_string())),
-            Err(error) => status_code_response(StatusCode::BAD_REQUEST, full(error.to_string())),
-        },
-        (&Method::POST, "/exec") => match exec(
-            &state.lua,
-            &String::from_utf8_lossy(&request.into_body().collect().await?.to_bytes()),
-            None,
-        )
-        .await
-        {
-            Ok(()) => status_code_response(StatusCode::OK, empty()),
-            Err(error) => status_code_response(StatusCode::BAD_REQUEST, full(error.to_string())),
-        },
         (&Method::GET, "/ping") => Response::new(full("pong!")),
         _ => status_code_response(StatusCode::NOT_FOUND, empty()),
     })

src/lua/client/state.rs

@@ -1,5 +1,3 @@
-use crate::hacks::anti_knockback::AntiKnockback;
-
 use super::Client;
 use azalea::{
     ClientInformation,
@@ -7,6 +5,7 @@ use azalea::{
     pathfinder::PathfinderDebugParticles,
     protocol::common::client_information::ModelCustomization,
 };
+use azalea_hax::AntiKnockback;
 use mlua::{Error, Lua, Result, Table, UserDataRef};
 
 pub fn air_supply(_lua: &Lua, client: &Client) -> Result<i32> {

src/lua/client/world/mod.rs

@@ -8,6 +8,7 @@ use mlua::{Lua, Result, Table};
 
 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)?;

src/lua/mod.rs

@@ -15,12 +15,10 @@ pub mod matrix;
 
 use crate::{ListenerMap, build_info::built};
 use mlua::{Lua, Table};
-use std::{
+use std::io;
-    fmt::{self, Display, Formatter},
-    io,
-};
 
 #[derive(Debug)]
+#[allow(dead_code)]
 pub enum Error {
     CreateEnv(mlua::Error),
     EvalChunk(mlua::Error),
@@ -30,23 +28,6 @@ pub enum Error {
     ReadFile(io::Error),
 }
 
-impl Display for Error {
-    fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
-        write!(
-            formatter,
-            "{}",
-            match self {
-                Error::CreateEnv(error) => format!("failed to create environment: {error}"),
-                Error::EvalChunk(error) => format!("failed to evaluate chunk: {error}"),
-                Error::ExecChunk(error) => format!("failed to execute chunk: {error}"),
-                Error::LoadChunk(error) => format!("failed to load chunk: {error}"),
-                Error::MissingPath(error) => format!("failed to get SCRIPT_PATH global: {error}"),
-                Error::ReadFile(error) => format!("failed to read script file: {error}"),
-            }
-        )
-    }
-}
-
 pub fn register_globals(
     lua: &Lua,
     globals: &Table,

src/main.rs

@@ -4,7 +4,6 @@ mod arguments;
 mod build_info;
 mod commands;
 mod events;
-mod hacks;
 mod http;
 mod lua;
 mod particle;
@@ -18,6 +17,7 @@ use arguments::Arguments;
 use azalea::{
     DefaultBotPlugins, DefaultPlugins, brigadier::prelude::CommandDispatcher, prelude::*,
 };
+use azalea_hax::HaxPlugin;
 use bevy_app::PluginGroup;
 use bevy_log::{
     LogPlugin,
@@ -27,7 +27,6 @@ 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, Table};
 use replay::{plugin::RecordPlugin, recorder::Recorder};
@@ -131,7 +130,7 @@ async fn main() -> anyhow::Result<()> {
 
     let Err(error) = ClientBuilder::new_without_plugins()
         .add_plugins(DefaultBotPlugins)
-        .add_plugins(HacksPlugin)
+        .add_plugins(HaxPlugin)
         .add_plugins(default_plugins)
         .add_plugins(record_plugin)
         .set_handler(events::handle_event)

src/matrix/bot.rs

@@ -1,4 +1,4 @@
-use super::Context;
+use super::MatrixContext;
 use crate::{
     events::call_listeners,
     lua::{self, matrix::room::Room as LuaRoom},
@@ -19,7 +19,7 @@ use tokio::time::sleep;
 pub async fn on_regular_room_message(
     event: OriginalSyncRoomMessageEvent,
     room: Room,
-    ctx: Ctx<Context>,
+    ctx: Ctx<MatrixContext>,
 ) -> Result<()> {
     if room.state() != RoomState::Joined {
         return Ok(());
@@ -49,16 +49,16 @@ pub async fn on_regular_room_message(
         match split.0.unwrap_or(body).to_lowercase().as_str() {
             "reload" => output = Some(format!("{:#?}", lua::reload(&ctx.state.lua, None))),
             "eval" if let Some(code) = code => {
-                output = Some(match lua::eval(&ctx.state.lua, code, None).await {
+                output = Some(format!(
-                    Ok(value) => value.to_string(),
+                    "{:#?}",
-                    Err(error) => error.to_string(),
+                    lua::eval(&ctx.state.lua, code, None).await
-                });
+                ));
             }
             "exec" if let Some(code) = code => {
-                output = Some(match lua::exec(&ctx.state.lua, code, None).await {
+                output = Some(format!(
-                    Ok(()) => String::from("ok"),
+                    "{:#?}",
-                    Err(error) => error.to_string(),
+                    lua::exec(&ctx.state.lua, code, None).await
-                });
+                ));
             }
             "ping" => {
                 room.send(RoomMessageEventContent::text_plain("pong!"))
@@ -90,7 +90,7 @@ pub async fn on_stripped_state_member(
     member: StrippedRoomMemberEvent,
     client: Client,
     room: Room,
-    ctx: Ctx<Context>,
+    ctx: Ctx<MatrixContext>,
 ) -> Result<()> {
     if let Some(user_id) = client.user_id()
         && member.state_key == user_id

src/matrix/mod.rs

@@ -2,7 +2,7 @@ mod bot;
 mod verification;
 
 use crate::{State, lua::matrix::client::Client as LuaClient};
-use anyhow::{Context as _, Result};
+use anyhow::{Context, Result};
 use bot::{on_regular_room_message, on_stripped_state_member};
 use log::{error, warn};
 use matrix_sdk::{
@@ -15,7 +15,7 @@ use tokio::fs;
 use verification::{on_device_key_verification_request, on_room_message_verification_request};
 
 #[derive(Clone)]
-pub struct Context {
+pub struct MatrixContext {
     state: State,
     name: String,
 }
@@ -62,8 +62,8 @@ pub async fn login(
     let client = builder.build().await?;
 
     let mut new_session;
-    let mut sync_settings = SyncSettings::default();
     let session_file = root_dir.join("session.json");
+    let mut sync_settings = SyncSettings::default();
     if let Some(session) = fs::read_to_string(&session_file)
         .await
         .ok()
@@ -88,7 +88,7 @@ pub async fn login(
         fs::write(&session_file, serde_json::to_string(&new_session)?).await?;
     }
 
-    client.add_event_handler_context(Context { state, name });
+    client.add_event_handler_context(MatrixContext { state, name });
     client.add_event_handler(on_stripped_state_member);
     loop {
         match client.sync_once(sync_settings.clone()).await {