ErrorNoInternet/ErrorNoWatcher
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'update' into main

Browse Source
This commit is contained in:
Ryan
2026-04-13 16:21:05 -04:00
parent 2cf4265732 57397d3718
commit 9a362630a2
29 changed files with 2916 additions and 1941 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.envrc Normal file
View File

@@ -0,0 +1,2 @@
eval "$(devenv direnvrc)"
use devenv

11
.gitignore vendored
View File

@@ -1,2 +1,13 @@
.luarc.json
target
# Devenv
.devenv*
devenv.local.nix
devenv.local.yaml
# direnv
.direnv
# pre-commit
.pre-commit-config.yaml

3895
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

8
Cargo.toml
View File

@@ -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"
@@ -42,10 +43,13 @@ parking_lot = "0"
serde = "1"
serde_json = "1"
tokio = { version = "1", features = ["full"] }
zip = { version = "2", default-features = false, features = ["flate2"] }
zip = { version = "8", default-features = false, features = [
"deflate",
], optional = true }
[features]
console-subscriber = ["dep:console-subscriber"]
default = ["matrix"]
default = []
matrix = ["dep:dirs", "dep:matrix-sdk"]
mimalloc = ["dep:mimalloc"]
replay = ["dep:zip"]

86
devenv.lock Normal file
View File

@@ -0,0 +1,86 @@
{
"nodes": {
"devenv": {
"locked": {
"dir": "src/modules",
"lastModified": 1775928269,
"narHash": "sha256-kolsui5s7citDkwz2RL4Au8/BUdH9/TYbfMthLrarrc=",
"owner": "cachix",
"repo": "devenv",
"rev": "b908ac3d4b59f28cb32e7294c621b1c7325002c7",
"type": "github"
},
"original": {
"dir": "src/modules",
"owner": "cachix",
"repo": "devenv",
"type": "github"
}
},
"nixpkgs": {
"inputs": {
"nixpkgs-src": "nixpkgs-src"
},
"locked": {
"lastModified": 1774287239,
"narHash": "sha256-W3krsWcDwYuA3gPWsFA24YAXxOFUL6iIlT6IknAoNSE=",
"owner": "cachix",
"repo": "devenv-nixpkgs",
"rev": "fa7125ea7f1ae5430010a6e071f68375a39bd24c",
"type": "github"
},
"original": {
"owner": "cachix",
"ref": "rolling",
"repo": "devenv-nixpkgs",
"type": "github"
}
},
"nixpkgs-src": {
"flake": false,
"locked": {
"lastModified": 1773840656,
"narHash": "sha256-9tpvMGFteZnd3gRQZFlRCohVpqooygFuy9yjuyRL2C0=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "9cf7092bdd603554bd8b63c216e8943cf9b12512",
"type": "github"
},
"original": {
"owner": "NixOS",
"ref": "nixpkgs-unstable",
"repo": "nixpkgs",
"type": "github"
}
},
"root": {
"inputs": {
"devenv": "devenv",
"nixpkgs": "nixpkgs",
"rust-overlay": "rust-overlay"
}
},
"rust-overlay": {
"inputs": {
"nixpkgs": [
"nixpkgs"
]
},
"locked": {
"lastModified": 1775877051,
"narHash": "sha256-wpSQm2PD/w4uRo2wb8utk0b5hOBkkg/CZ1xICY+qB7M=",
"owner": "oxalica",
"repo": "rust-overlay",
"rev": "08b4f3633471874c8894632ade1b78d75dbda002",
"type": "github"
},
"original": {
"owner": "oxalica",
"repo": "rust-overlay",
"type": "github"
}
}
},
"root": "root",
"version": 7
}

19
devenv.nix Normal file
View File

@@ -0,0 +1,19 @@
{
pkgs,
...
}:
{
packages = with pkgs; [
git
jujutsu
luajit
openssl
];
languages.rust = {
enable = true;
channel = "nightly";
};
}

8
devenv.yaml Normal file
View File

@@ -0,0 +1,8 @@
inputs:
nixpkgs:
url: github:cachix/devenv-nixpkgs/rolling
rust-overlay:
url: github:oxalica/rust-overlay
inputs:
nixpkgs:
follows: nixpkgs

12
lib/automation.lua
View File

@@ -30,7 +30,7 @@ function auto_fish()
sleep(3000)
end
hold_fishing_rod()
client:use_item()
client:start_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:use_item()
client:start_use_item()
end
end
end, "auto-fish")
@@ -54,11 +54,11 @@ function auto_fish()
if os.time() - FishLastCaught >= 60 then
hold_fishing_rod()
client:use_item()
client:start_use_item()
end
end, "auto-fish_watchdog")
client:use_item()
client:start_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:use_item()
client:start_use_item()
end
end
@@ -131,6 +131,6 @@ function check_food(hunger)
sleep(1000)
LastEaten = current_time
end
client:use_item()
client:start_use_item()
end
end

2
src/commands.rs
View File

@@ -1,4 +1,4 @@
use azalea::{brigadier::prelude::*, chat::ChatPacket, prelude::*};
use azalea::{brigadier::prelude::*, client_chat::ChatPacket, prelude::*};
use futures::lock::Mutex;
use mlua::{Error, Result, Table, UserDataRef};
use ncr::{

51
src/events.rs
View File

@@ -1,18 +1,19 @@
use std::{net::SocketAddr, process::exit};
use std::net::SocketAddr;
use anyhow::{Context, Result};
use anyhow::Result;
use azalea::{
brigadier::exceptions::BuiltInExceptions::DispatcherUnknownCommand, prelude::*,
protocol::packets::game::ClientboundGamePacket,
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::{Error, Function, IntoLuaMulti, Table};
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,
@@ -20,7 +21,6 @@ use crate::{
http::serve,
lua::{client, direction::Direction, player::Player, vec3::Vec3},
particle,
replay::recorder::Recorder,
};
#[allow(clippy::cognitive_complexity, clippy::too_many_lines)]
@@ -35,6 +35,7 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
let uuid = message.sender_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}");
@@ -70,7 +71,7 @@ pub async fn handle_event(client: Client, event: Event, state: State) -> Result<
}
.into(),
)
&& error.type_ != DispatcherUnknownCommand
&& *error.kind() != BuiltInError::DispatcherUnknownCommand
{
CommandSource {
client,
@@ -86,6 +87,7 @@ 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)?;
@@ -95,12 +97,16 @@ 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)?;
@@ -117,6 +123,7 @@ 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
@@ -125,7 +132,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::Login => call_listeners(&state, "login", || Ok(())).await,
Event::ReceiveChunk(_) => Ok(()),
Event::RemovePlayer(player_info) => {
call_listeners(&state, "remove_player", || Ok(Player::from(player_info))).await
}
@@ -183,8 +190,11 @@ 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)?;
table.set("vehicle", *packet.vehicle)?;
table.set(
"passengers",
packet.passengers.iter().map(|id| id.0).collect::<Vec<_>>(),
)?;
Ok(table)
})
.await
@@ -192,28 +202,32 @@ 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.lock()
ecs.write()
.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?;
@@ -262,11 +276,13 @@ 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.lock()
ecs.write()
.remove_resource::<Recorder>()
.context("recording not active")
.map_err(Error::external)?
@@ -274,6 +290,7 @@ 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
}

20
src/hacks/anti_knockback.rs
View File

@@ -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());
}
}
}

21
src/hacks/mod.rs
View File

@@ -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::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),
);
}
}

14
src/lua/block.rs
View File

@@ -1,6 +1,6 @@
use azalea::blocks::{
Block as AzaleaBlock, BlockState,
properties::{ChestType, Facing, LightLevel},
use azalea::block::{
BlockState, BlockTrait,
properties::{ChestKind, 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 AzaleaBlock> = state.into();
let block: Box<dyn BlockTrait> = 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 AzaleaBlock>>::into(block).id()
if block_name == Into::<Box<dyn BlockTrait>>::into(block).id()
&& (if let Some(filter_fn) = &filter_fn {
let table = lua.create_table()?;
table.set("chest_type", block.property::<ChestType>().map(|v| v as u8))?;
table.set("chest_kind", block.property::<ChestKind>().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());
}
}
}

33
src/lua/client/container.rs
View File

@@ -1,20 +1,20 @@
use azalea::{
BlockPos,
inventory::{Inventory, Menu, Player, SlotList},
prelude::ContainerClientExt,
entity::inventory::Inventory,
inventory::{Menu, Player, SlotList},
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<Option<ContainerRef>> {
Ok(client.get_open_container().map(ContainerRef))
pub fn container(_lua: &Lua, client: &Client) -> Result<ContainerRef> {
Ok(ContainerRef(client.get_inventory()))
}
pub fn held_item(_lua: &Lua, client: &Client) -> Result<ItemStack> {
Ok(ItemStack(client.component::<Inventory>().held_item()))
Ok(ItemStack(client.get_held_item()))
}
pub fn held_slot(_lua: &Lua, client: &Client) -> Result<u8> {
@@ -96,9 +96,10 @@ 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,
@@ -117,20 +118,14 @@ pub fn set_held_slot(_lua: &Lua, client: &Client, slot: u8) -> Result<()> {
return Ok(());
}
{
let mut ecs = client.ecs.lock();
let mut inventory = client.query::<&mut Inventory>(&mut ecs);
if inventory.selected_hotbar_slot == slot {
return Ok(());
}
client.query_self::<&mut Inventory, _>(|mut inventory| {
if inventory.selected_hotbar_slot != slot {
inventory.selected_hotbar_slot = slot;
};
if let Err(error) = client.write_packet(ServerboundSetCarriedItem {
slot: u16::from(slot),
}) {
error!("failed to send SetCarriedItem packet: {error:?}");
}
});
client.write_packet(ServerboundSetCarriedItem {
slot: u16::from(slot),
});
Ok(())
}

31
src/lua/client/interaction.rs
View File

@@ -1,15 +1,17 @@
use azalea::{
BlockPos, BotClientExt,
BlockPos,
core::entity_id::MinecraftEntityId,
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<()> {
client.attack(MinecraftEntityId(entity_id));
if let Some(entity) = client.entity_id_by_minecraft_id(MinecraftEntityId(entity_id)) {
client.attack(entity);
}
Ok(())
}
@@ -28,9 +30,10 @@ 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,
@@ -40,8 +43,8 @@ pub async fn mine(_lua: Lua, client: UserDataRef<Client>, position: Vec3) -> Res
Ok(())
}
pub fn set_mining(_lua: &Lua, client: &Client, mining: bool) -> Result<()> {
client.left_click_mine(mining);
pub fn set_mining(_lua: &Lua, client: &Client, state: bool) -> Result<()> {
client.left_click_mine(state);
Ok(())
}
@@ -55,18 +58,16 @@ pub fn start_mining(_lua: &Lua, client: &Client, position: Vec3) -> Result<()> {
Ok(())
}
pub fn use_item(_lua: &Lua, client: &Client, hand: Option<u8>) -> Result<()> {
pub fn start_use_item(_lua: &Lua, client: &Client, hand: Option<u8>) -> Result<()> {
let direction = client.direction();
if let Err(error) = client.write_packet(ServerboundUseItem {
client.write_packet(ServerboundUseItem {
hand: match hand {
Some(1) => InteractionHand::OffHand,
_ => InteractionHand::MainHand,
},
sequence: 0,
yaw: direction.0,
pitch: direction.1,
}) {
error!("failed to send UseItem packet: {error:?}");
}
seq: 0,
x_rot: direction.x_rot(),
y_rot: direction.y_rot(),
});
Ok(())
}

28
src/lua/client/mod.rs
View File

@@ -6,9 +6,9 @@ mod movement;
mod state;
mod world;
use std::ops::{Deref, DerefMut};
use std::ops::Deref;
use azalea::{Client as AzaleaClient, world::MinecraftEntityId};
use azalea::{Client as AzaleaClient, core::entity_id::MinecraftEntityId};
use mlua::{Lua, Result, UserData, UserDataFields, UserDataMethods};
use super::{
@@ -28,18 +28,13 @@ 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);
@@ -52,7 +47,6 @@ 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);
@@ -64,14 +58,11 @@ impl UserData for Client {
m.add_async_method("find_entities", world::find::entities);
m.add_async_method("find_players", world::find::players);
m.add_async_method("go_to", movement::go_to);
m.add_async_method(
"go_to_wait_until_reached",
movement::go_to_wait_until_reached,
);
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);
@@ -92,9 +83,9 @@ impl UserData for Client {
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("use_item", interaction::use_item);
m.add_method("walk", movement::walk);
}
}
@@ -124,3 +115,12 @@ 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
}};
}

128
src/lua/client/movement.rs
View File

@@ -1,18 +1,18 @@
use azalea::{
BlockPos, BotClientExt, SprintDirection, WalkDirection,
BlockPos, Client as AzaleaClient, SprintDirection, WalkDirection,
core::{entity_id::MinecraftEntityId, hit_result::HitResult},
entity::Position,
interact::HitResultComponent,
interact::pick::HitResultComponent,
pathfinder::{
ExecutingPath, GotoEvent, Pathfinder, PathfinderClientExt,
goals::{BlockPosGoal, Goal, InverseGoal, RadiusGoal, ReachBlockPosGoal, XZGoal, YGoal},
ExecutingPath, Pathfinder, PathfinderClientExt, PathfinderOpts,
goals::{BlockPosGoal, Goal, 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>);
@@ -28,7 +28,7 @@ impl Goal for AnyGoal {
}
#[allow(clippy::cast_possible_truncation)]
fn to_goal(lua: &Lua, client: &Client, data: Table, options: &Table, kind: u8) -> Result<AnyGoal> {
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)?;
@@ -38,11 +38,13 @@ fn to_goal(lua: &Lua, client: &Client, data: Table, options: &Table, kind: u8) -
})
}
2 => {
let distance = data.get("distance").unwrap_or(4.5);
let pos = Vec3::from_lua(Value::Table(data), lua)?;
Box::new(ReachBlockPosGoal {
pos: BlockPos::new(pos.x as i32, pos.y as i32, pos.z as i32),
chunk_storage: client.world().read().chunks.clone(),
})
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")?,
@@ -59,22 +61,15 @@ fn to_goal(lua: &Lua, client: &Client, data: Table, options: &Table, kind: u8) -
}
};
Ok(AnyGoal(if options.get("inverse").unwrap_or_default() {
Box::new(InverseGoal(AnyGoal(goal)))
} else {
goal
}))
Ok(AnyGoal(goal))
}
pub fn go_to_reached(_lua: &Lua, client: &Client) -> Result<bool> {
Ok(client.is_goto_target_reached())
}
pub async fn go_to_wait_until_reached(
_lua: Lua,
client: UserDataRef<Client>,
(): (),
) -> Result<()> {
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(())
}
@@ -84,21 +79,23 @@ pub async fn go_to(
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,
&options,
metadata.get("type").unwrap_or_default(),
)?;
if options.get("without_mining").unwrap_or_default() {
client.start_goto_without_mining(goal);
client.wait_until_goto_target_reached().await;
} else {
client.goto(goal).await;
}
client
.goto_with_opts(
goal,
PathfinderOpts::new().allow_mining(options.get("without_mining").unwrap_or_default()),
)
.await;
Ok(())
}
@@ -107,25 +104,21 @@ pub async fn start_go_to(
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,
&options,
metadata.get("type").unwrap_or_default(),
)?;
if options.get("without_mining").unwrap_or_default() {
client.start_goto_without_mining(goal);
} else {
client.start_goto(goal);
}
while client.get_tick_broadcaster().recv().await.is_ok() {
if client.ecs.lock().get::<GotoEvent>(client.entity).is_none() {
break;
}
}
client.start_goto_with_opts(
goal,
PathfinderOpts::new().allow_mining(options.get("without_mining").unwrap_or_default()),
);
let _ = client.get_tick_broadcaster().recv().await;
Ok(())
}
@@ -133,8 +126,8 @@ pub async fn start_go_to(
pub fn direction(_lua: &Lua, client: &Client) -> Result<Direction> {
let direction = client.direction();
Ok(Direction {
y: direction.0,
x: direction.1,
y: direction.y_rot(),
x: direction.x_rot(),
})
}
@@ -148,16 +141,19 @@ pub fn jump(_lua: &Lua, client: &Client, (): ()) -> Result<()> {
}
pub fn looking_at(lua: &Lua, client: &Client) -> Result<Option<Table>> {
let result = client.component::<HitResultComponent>();
Ok(if result.miss {
None
} else {
Ok(
if let HitResult::Block(ref result) = **client.component::<HitResultComponent>() {
let table = lua.create_table()?;
table.set("position", Vec3::from(result.block_pos))?;
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("world_border", result.world_border)?;
Some(table)
})
} else {
None
},
)
}
pub fn look_at(_lua: &Lua, client: &Client, position: Vec3) -> Result<()> {
@@ -179,8 +175,8 @@ pub fn pathfinder(lua: &Lua, client: &Client) -> Result<Table> {
Vec3::from(pathfinder.last_reached_node),
)?;
table.set(
"last_node_reach_elapsed",
pathfinder.last_node_reached_at.elapsed().as_millis(),
"ticks_since_last_node_reached",
pathfinder.ticks_since_last_node_reached,
)?;
table.set("is_path_partial", pathfinder.is_path_partial)?;
true
@@ -192,7 +188,7 @@ 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<()> {
@@ -205,27 +201,17 @@ pub fn set_jumping(_lua: &Lua, client: &Client, jumping: bool) -> Result<()> {
Ok(())
}
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;
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;
});
Ok(())
}
pub fn set_sneaking(_lua: &Lua, client: &Client, sneaking: bool) -> Result<()> {
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:?}");
}
client.set_crouching(sneaking);
Ok(())
}
@@ -244,13 +230,11 @@ pub fn stop_pathfinding(_lua: &Lua, client: &Client, (): ()) -> Result<()> {
}
pub fn stop_sleeping(_lua: &Lua, client: &Client, (): ()) -> Result<()> {
if let Err(error) = client.write_packet(ServerboundPlayerCommand {
id: client.component::<MinecraftEntityId>(),
client.write_packet(ServerboundPlayerCommand {
id: *client.component::<MinecraftEntityId>(),
action: Action::StopSleeping,
data: 0,
}) {
error!("failed to send PlayerCommand packet: {error:?}");
}
});
Ok(())
}

47
src/lua/client/state.rs
View File

@@ -1,18 +1,26 @@
use azalea::{
ClientInformation,
entity::metadata::{AirSupply, Score},
pathfinder::PathfinderDebugParticles,
ClientInformation, entity::metadata::AirSupply, pathfinder::debug::PathfinderDebugParticles,
protocol::common::client_information::ModelCustomization,
};
use azalea_hax::AntiKnockback;
use mlua::{Error, Lua, Result, Table, UserDataRef};
use super::Client;
use crate::hacks::anti_knockback::AntiKnockback;
use crate::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())
}
@@ -25,36 +33,33 @@ 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()
})
.await
.map_err(Error::external)
});
Ok(())
}
pub fn set_component(
@@ -64,7 +69,7 @@ pub fn set_component(
) -> Result<()> {
macro_rules! set {
($name:ident) => {{
let mut ecs = client.ecs.lock();
let mut ecs = client.ecs.write();
let mut entity = ecs.entity_mut(client.entity);
if enabled.unwrap_or(true) {
entity.insert($name)

19
src/lua/client/world/find.rs
View File

@@ -1,16 +1,16 @@
use azalea::{
BlockPos,
blocks::{BlockState, BlockStates},
block::{BlockState, BlockStates},
ecs::query::{With, Without},
entity::{
Dead, EntityKind, EntityUuid, LookDirection, Pose, Position as AzaleaPosition,
Dead, EntityKindComponent, 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,
@@ -28,7 +28,10 @@ pub fn blocks(
nearest_to.z as i32,
),
&BlockStates {
set: block_states.iter().map(|&id| BlockState { id }).collect(),
set: block_states
.into_iter()
.flat_map(BlockState::try_from)
.collect(),
},
)
.map(Vec3::from)
@@ -36,6 +39,8 @@ 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)
@@ -62,6 +67,8 @@ 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)
@@ -86,6 +93,8 @@ 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()?;
@@ -105,6 +114,8 @@ 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()?;

21
src/lua/client/world/mod.rs
View File

@@ -2,21 +2,24 @@
mod queries;
pub mod find;
use azalea::{BlockPos, auto_tool::AutoToolClientExt, blocks::BlockState, world::InstanceName};
use mlua::{Lua, Result, Table};
use azalea::{BlockPos, block::BlockState, world::WorldName};
use mlua::{Lua, Result, Table, Value};
use super::{Client, Direction, Vec3};
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 });
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);
let table = lua.create_table()?;
table.set("index", result.index)?;
table.set("percentage_per_tick", result.percentage_per_tick)?;
Ok(table)
Ok(Value::Table(table))
}
pub fn dimension(_lua: &Lua, client: &Client) -> Result<String> {
Ok(client.component::<InstanceName>().to_string())
Ok(client.component::<WorldName>().to_string())
}
pub fn get_block_state(_lua: &Lua, client: &Client, position: Vec3) -> Result<Option<u16>> {
@@ -24,17 +27,17 @@ 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(
let fluid_state = client.world().read().get_fluid_state(BlockPos::new(
position.x as i32,
position.y as i32,
position.z as i32,

27
src/lua/client/world/queries.rs
View File

@@ -1,22 +1,23 @@
#[macro_export]
macro_rules! get_entities {
($client:ident) => {{
let mut ecs = $client.ecs.lock();
ecs.query::<(
let ecs = $client.ecs.read();
if let Some(mut query) = ecs.try_query::<(
&AzaleaPosition,
&CustomName,
&EntityKind,
&EntityKindComponent,
&EntityUuid,
&LookDirection,
&MinecraftEntityId,
Option<&Owneruuid>,
&Pose,
)>()
)>() {
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(),
@@ -28,32 +29,40 @@ macro_rules! get_entities {
},
)
.collect::<Vec<_>>()
} else {
Vec::new()
}
}};
}
#[macro_export]
macro_rules! get_players {
($client:ident) => {{
let mut ecs = $client.ecs.lock();
ecs.query_filtered::<(
let ecs = $client.ecs.read();
if let Some(mut query) = ecs.try_query_filtered::<(
&MinecraftEntityId,
&EntityUuid,
&EntityKind,
&EntityKindComponent,
&AzaleaPosition,
&LookDirection,
&Pose,
), (With<Player>, Without<Dead>)>()
{
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<_>>()
} else {
Vec::new()
}
}};
}

14
src/lua/container/item_stack.rs
View File

@@ -1,5 +1,5 @@
use azalea::inventory::{
self,
self, ItemStackData,
components::{Consumable, CustomName, Damage, Food, MaxDamage},
};
use mlua::{UserData, UserDataFields, UserDataMethods};
@@ -14,8 +14,7 @@ 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.components
.get::<CustomName>()
data.get_component::<CustomName>()
.map(|c| c.name.to_string())
}))
});
@@ -23,13 +22,13 @@ impl UserData for ItemStack {
Ok(this
.0
.as_present()
.map(|data| data.components.get::<Damage>().map(|d| d.amount)))
.map(|data| data.get_component::<Damage>().map(|d| d.amount)))
});
f.add_field_method_get("max_damage", |_, this| {
Ok(this
.0
.as_present()
.map(|data| data.components.get::<MaxDamage>().map(|d| d.amount)))
.map(|data| data.get_component::<MaxDamage>().map(|d| d.amount)))
});
f.add_field_method_get("consumable", |lua, this| {
@@ -37,7 +36,7 @@ impl UserData for ItemStack {
if let Some(consumable) = this
.0
.as_present()
.and_then(|data| data.components.get::<Consumable>())
.and_then(ItemStackData::get_component::<Consumable>)
{
let table = lua.create_table()?;
table.set("animation", consumable.animation as u8)?;
@@ -55,13 +54,12 @@ impl UserData for ItemStack {
if let Some(food) = this
.0
.as_present()
.and_then(|data| data.components.get::<Food>())
.and_then(ItemStackData::get_component::<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

4
src/lua/direction.rs
View File

@@ -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(),
}
}
}

2
src/lua/player.rs
View File

@@ -1,4 +1,4 @@
use azalea::PlayerInfo;
use azalea::player::PlayerInfo;
use mlua::{IntoLua, Lua, Result, Value};
#[derive(Clone)]

4
src/lua/vec3.rs
View File

@@ -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,

55
src/main.rs
View File

@@ -1,4 +1,3 @@
#![feature(if_let_guard, let_chains)]
#![warn(clippy::pedantic, clippy::nursery)]
#![allow(clippy::significant_drop_tightening)]
@@ -6,15 +5,16 @@ mod arguments;
mod build_info;
mod commands;
mod events;
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,
@@ -22,11 +22,12 @@ use std::{
sync::Arc,
};
use anyhow::Context;
use anyhow::{Context, Result, bail};
use arguments::Arguments;
use azalea::{
DefaultBotPlugins, DefaultPlugins, brigadier::prelude::CommandDispatcher, prelude::*,
DefaultPlugins, bot::DefaultBotPlugins, brigadier::prelude::CommandDispatcher, prelude::*,
};
use azalea_hax::HaxPlugin;
use bevy_app::PluginGroup;
use bevy_log::{
LogPlugin,
@@ -36,10 +37,13 @@ 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};
use mlua::{Function, Lua};
#[cfg(feature = "replay")]
use {
mlua::Table,
replay::{plugin::RecordPlugin, recorder::Recorder},
};
#[cfg(feature = "mimalloc")]
#[global_allocator]
@@ -55,7 +59,7 @@ struct State {
}
#[tokio::main]
async fn main() -> anyhow::Result<()> {
async fn main() -> Result<()> {
#[cfg(feature = "console-subscriber")]
console_subscriber::init();
@@ -95,21 +99,25 @@ async fn main() -> anyhow::Result<()> {
DefaultPlugins.set(LogPlugin {
custom_layer: |_| {
env::var("LOG_FILE").ok().map(|path| {
layer()
.with_writer(
OpenOptions::new()
let file = OpenOptions::new()
.append(true)
.create(true)
.open(&path)
.expect(&(path + " should be accessible")),
)
.boxed()
.expect(&(path + " should be accessible"));
layer().with_writer(file).boxed()
})
},
..Default::default()
})
};
let record_plugin = RecordPlugin {
let builder = ClientBuilder::new_without_plugins()
.add_plugins(default_plugins)
.add_plugins(DefaultBotPlugins)
.add_plugins(HaxPlugin);
#[cfg(feature = "replay")]
let builder = builder.add_plugins(RecordPlugin {
recorder: Arc::new(parking_lot::Mutex::new(
if let Ok(options) = globals.get::<Table>("ReplayRecordingOptions")
&& let Ok(path) = options.get::<String>("path")
@@ -125,18 +133,15 @@ async fn main() -> anyhow::Result<()> {
None
},
)),
};
});
let account = if username.contains('@') {
Account::microsoft(&username).await?
} else {
Account::offline(&username)
};
let Err(error) = ClientBuilder::new_without_plugins()
.add_plugins(DefaultBotPlugins)
.add_plugins(HacksPlugin)
.add_plugins(default_plugins)
.add_plugins(record_plugin)
if let AppExit::Error(code) = builder
.set_handler(events::handle_event)
.set_state(State {
lua: Arc::new(lua),
@@ -144,8 +149,10 @@ async fn main() -> anyhow::Result<()> {
commands: Arc::new(commands),
})
.start(account, server)
.await;
eprintln!("{error}");
.await
{
bail!("azalea exited with code {code}")
}
Ok(())
}

143
src/particle.rs
View File

@@ -1,121 +1,124 @@
use azalea::{entity::particle::Particle, registry::ParticleKind};
use azalea::{entity::particle::Particle, registry::builtin::ParticleKind};
#[allow(clippy::too_many_lines)]
pub const 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::FallingLava => ParticleKind::FallingLava,
Particle::LandingLava => ParticleKind::LandingLava,
Particle::DrippingObsidianTear => ParticleKind::DrippingObsidianTear,
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::EnchantedHit => ParticleKind::EnchantedHit,
Particle::ElectricSpark => ParticleKind::ElectricSpark,
Particle::Enchant => ParticleKind::Enchant,
Particle::EnchantedHit => ParticleKind::EnchantedHit,
Particle::EndRod => ParticleKind::EndRod,
Particle::EntityEffect(_) => ParticleKind::EntityEffect,
Particle::ExplosionEmitter => ParticleKind::ExplosionEmitter,
Particle::Explosion => ParticleKind::Explosion,
Particle::Gust => ParticleKind::Gust,
Particle::SonicBoom => ParticleKind::SonicBoom,
Particle::ExplosionEmitter => ParticleKind::ExplosionEmitter,
Particle::FallingDripstoneLava => ParticleKind::FallingDripstoneLava,
Particle::FallingDripstoneWater => ParticleKind::FallingDripstoneWater,
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::TintedLeaves => ParticleKind::TintedLeaves,
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::Vibration(_) => ParticleKind::Vibration,
Particle::ItemCobweb => ParticleKind::ItemCobweb,
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::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::Trail => ParticleKind::Trail,
Particle::TrialOmen => ParticleKind::TrialOmen,
Particle::TrialSpawnerDetection => ParticleKind::TrialSpawnerDetection,
Particle::TrialSpawnerDetectionOminous => ParticleKind::TrialSpawnerDetectionOminous,
Particle::Underwater => ParticleKind::Underwater,
Particle::VaultConnection => ParticleKind::VaultConnection,
Particle::DustPillar => ParticleKind::DustPillar,
Particle::OminousSpawning => ParticleKind::OminousSpawning,
Particle::RaidOmen => ParticleKind::RaidOmen,
Particle::TrialOmen => ParticleKind::TrialOmen,
Particle::Trail => ParticleKind::Trail,
Particle::BlockCrumble => ParticleKind::BlockCrumble,
Particle::Firefly => ParticleKind::Firefly,
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,
}
}

36
src/replay/plugin.rs
View File

@@ -3,17 +3,14 @@
use std::sync::Arc;
use azalea::{
ecs::{event::EventReader, system::Query},
packet::{
config::ReceiveConfigPacketEvent,
game::emit_receive_packet_events,
login::{LoginPacketEvent, process_packet_events},
config::ReceiveConfigPacketEvent, game::ReceiveGamePacketEvent,
login::ReceiveLoginPacketEvent,
},
protocol::packets::login::ClientboundLoginPacket,
raw_connection::RawConnection,
};
use bevy_app::{App, First, Plugin};
use bevy_ecs::{schedule::IntoSystemConfigs, system::ResMut};
use bevy_ecs::{message::MessageReader, system::ResMut};
use log::error;
use parking_lot::Mutex;
@@ -28,19 +25,16 @@ impl Plugin for RecordPlugin {
let recorder = self.recorder.lock().take();
if let Some(recorder) = recorder {
app.insert_resource(recorder)
.add_systems(First, record_login_packets.before(process_packet_events))
.add_systems(First, record_login_packets)
.add_systems(First, record_configuration_packets)
.add_systems(
First,
record_game_packets.before(emit_receive_packet_events),
);
.add_systems(First, record_game_packets);
}
}
}
fn record_login_packets(
recorder: Option<ResMut<Recorder>>,
mut events: EventReader<LoginPacketEvent>,
mut events: MessageReader<ReceiveLoginPacketEvent>,
) {
if let Some(mut recorder) = recorder {
for event in events.read() {
@@ -59,24 +53,24 @@ fn record_login_packets(
fn record_configuration_packets(
recorder: Option<ResMut<Recorder>>,
mut events: EventReader<ReceiveConfigPacketEvent>,
mut events: MessageReader<ReceiveConfigPacketEvent>,
) {
if let Some(mut recorder) = recorder {
for event in events.read() {
if let Err(error) = recorder.save_packet(&event.packet) {
if let Err(error) = recorder.save_packet(event.packet.as_ref()) {
error!("failed to record configuration packet: {error:?}");
}
}
}
}
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) {
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()) {
error!("failed to record game packet: {error:?}");
}
}

2
src/replay/recorder.rs
View File

@@ -6,7 +6,7 @@ use std::{
use anyhow::Result;
use azalea::{
buf::AzaleaWriteVar,
buf::AzBufVar,
prelude::Resource,
protocol::packets::{PROTOCOL_VERSION, ProtocolPacket, VERSION_NAME},
};