diff options
40 files changed, 1024 insertions, 737 deletions
@@ -166,6 +166,7 @@ dependencies = [ "async-trait", "azalea-auth", "azalea-block", + "azalea-brigadier", "azalea-chat", "azalea-client", "azalea-core", @@ -232,6 +233,7 @@ version = "0.6.0" dependencies = [ "azalea-buf", "azalea-chat", + "parking_lot", ] [[package]] diff --git a/azalea-brigadier/Cargo.toml b/azalea-brigadier/Cargo.toml index 254ccc83..a1f5966b 100644 --- a/azalea-brigadier/Cargo.toml +++ b/azalea-brigadier/Cargo.toml @@ -11,6 +11,7 @@ version = "0.6.0" [dependencies] azalea-buf = {path = "../azalea-buf", version = "^0.6.0", optional = true} azalea-chat = {path = "../azalea-chat", version = "^0.6.0", optional = true} +parking_lot = "0.12.1" [features] azalea-buf = ["dep:azalea-buf", "dep:azalea-chat"] diff --git a/azalea-brigadier/README.md b/azalea-brigadier/README.md index c5aff629..6e573c8b 100755 --- a/azalea-brigadier/README.md +++ b/azalea-brigadier/README.md @@ -4,4 +4,23 @@ A Rust port of Mojang's [Brigadier](https://github.com/Mojang/brigadier) command # Examples -See the [tests](https://github.com/mat-1/azalea/tree/main/azalea-brigadier/tests). +```rust +use azalea_brigadier::prelude::*; +use std::sync::Arc; + +#[derive(Debug, PartialEq)] +struct CommandSource {} + +let mut subject = CommandDispatcher::new(); +subject.register(literal("foo").executes(|_| 42)); + +assert_eq!( + subject + .execute("foo", Arc::new(CommandSource {})) + .unwrap(), + 42 +); +``` + +See the [tests](https://github.com/mat-1/azalea/tree/main/azalea-brigadier/tests) for more. + diff --git a/azalea-brigadier/src/arguments/bool_argument_type.rs b/azalea-brigadier/src/arguments/bool_argument_type.rs new file mode 100644 index 00000000..57fa8a03 --- /dev/null +++ b/azalea-brigadier/src/arguments/bool_argument_type.rs @@ -0,0 +1,21 @@ +use std::{any::Any, rc::Rc}; + +use crate::{ + context::CommandContext, exceptions::CommandSyntaxException, string_reader::StringReader, +}; + +use super::ArgumentType; + +impl ArgumentType for bool { + fn parse(&self, reader: &mut StringReader) -> Result<Rc<dyn Any>, CommandSyntaxException> { + Ok(Rc::new(reader.read_boolean())) + } +} + +pub fn get_bool<S>(context: &CommandContext<S>, name: &str) -> Option<bool> { + context + .argument(name) + .unwrap() + .downcast_ref::<bool>() + .cloned() +} diff --git a/azalea-brigadier/src/arguments/double_argument_type.rs b/azalea-brigadier/src/arguments/double_argument_type.rs new file mode 100644 index 00000000..d83bfb2a --- /dev/null +++ b/azalea-brigadier/src/arguments/double_argument_type.rs @@ -0,0 +1,54 @@ +use std::{any::Any, rc::Rc}; + +use crate::{ + context::CommandContext, + exceptions::{BuiltInExceptions, CommandSyntaxException}, + string_reader::StringReader, +}; + +use super::ArgumentType; + +#[derive(Default)] +struct Double { + pub minimum: Option<f64>, + pub maximum: Option<f64>, +} + +impl ArgumentType for Double { + fn parse(&self, reader: &mut StringReader) -> Result<Rc<dyn Any>, CommandSyntaxException> { + let start = reader.cursor; + let result = reader.read_double()?; + if let Some(minimum) = self.minimum { + if result < minimum { + reader.cursor = start; + return Err(BuiltInExceptions::DoubleTooSmall { + found: result, + min: minimum, + } + .create_with_context(reader)); + } + } + if let Some(maximum) = self.maximum { + if result > maximum { + reader.cursor = start; + return Err(BuiltInExceptions::DoubleTooBig { + found: result, + max: maximum, + } + .create_with_context(reader)); + } + } + Ok(Rc::new(result)) + } +} + +pub fn double() -> impl ArgumentType { + Double::default() +} +pub fn get_double<S>(context: &CommandContext<S>, name: &str) -> Option<f64> { + context + .argument(name) + .unwrap() + .downcast_ref::<f64>() + .copied() +} diff --git a/azalea-brigadier/src/arguments/float_argument_type.rs b/azalea-brigadier/src/arguments/float_argument_type.rs new file mode 100644 index 00000000..0d194efe --- /dev/null +++ b/azalea-brigadier/src/arguments/float_argument_type.rs @@ -0,0 +1,54 @@ +use std::{any::Any, rc::Rc}; + +use crate::{ + context::CommandContext, + exceptions::{BuiltInExceptions, CommandSyntaxException}, + string_reader::StringReader, +}; + +use super::ArgumentType; + +#[derive(Default)] +struct Float { + pub minimum: Option<f32>, + pub maximum: Option<f32>, +} + +impl ArgumentType for Float { + fn parse(&self, reader: &mut StringReader) -> Result<Rc<dyn Any>, CommandSyntaxException> { + let start = reader.cursor; + let result = reader.read_float()?; + if let Some(minimum) = self.minimum { + if result < minimum { + reader.cursor = start; + return Err(BuiltInExceptions::FloatTooSmall { + found: result, + min: minimum, + } + .create_with_context(reader)); + } + } + if let Some(maximum) = self.maximum { + if result > maximum { + reader.cursor = start; + return Err(BuiltInExceptions::FloatTooBig { + found: result, + max: maximum, + } + .create_with_context(reader)); + } + } + Ok(Rc::new(result)) + } +} + +pub fn float() -> impl ArgumentType { + Float::default() +} +pub fn get_float<S>(context: &CommandContext<S>, name: &str) -> Option<f32> { + context + .argument(name) + .unwrap() + .downcast_ref::<f32>() + .copied() +} diff --git a/azalea-brigadier/src/arguments/integer_argument_type.rs b/azalea-brigadier/src/arguments/integer_argument_type.rs index 336046a7..336046a7 100755..100644 --- a/azalea-brigadier/src/arguments/integer_argument_type.rs +++ b/azalea-brigadier/src/arguments/integer_argument_type.rs diff --git a/azalea-brigadier/src/arguments/long_argument_type.rs b/azalea-brigadier/src/arguments/long_argument_type.rs new file mode 100644 index 00000000..9b3469b6 --- /dev/null +++ b/azalea-brigadier/src/arguments/long_argument_type.rs @@ -0,0 +1,54 @@ +use std::{any::Any, rc::Rc}; + +use crate::{ + context::CommandContext, + exceptions::{BuiltInExceptions, CommandSyntaxException}, + string_reader::StringReader, +}; + +use super::ArgumentType; + +#[derive(Default)] +struct Long { + pub minimum: Option<i64>, + pub maximum: Option<i64>, +} + +impl ArgumentType for Long { + fn parse(&self, reader: &mut StringReader) -> Result<Rc<dyn Any>, CommandSyntaxException> { + let start = reader.cursor; + let result = reader.read_long()?; + if let Some(minimum) = self.minimum { + if result < minimum { + reader.cursor = start; + return Err(BuiltInExceptions::LongTooSmall { + found: result, + min: minimum, + } + .create_with_context(reader)); + } + } + if let Some(maximum) = self.maximum { + if result > maximum { + reader.cursor = start; + return Err(BuiltInExceptions::LongTooBig { + found: result, + max: maximum, + } + .create_with_context(reader)); + } + } + Ok(Rc::new(result)) + } +} + +pub fn long() -> impl ArgumentType { + Long::default() +} +pub fn get_long<S>(context: &CommandContext<S>, name: &str) -> Option<i64> { + context + .argument(name) + .unwrap() + .downcast_ref::<i64>() + .copied() +} diff --git a/azalea-brigadier/src/arguments/mod.rs b/azalea-brigadier/src/arguments/mod.rs index dec39297..9d2c2cd0 100755 --- a/azalea-brigadier/src/arguments/mod.rs +++ b/azalea-brigadier/src/arguments/mod.rs @@ -1,4 +1,9 @@ mod argument_type; +pub mod bool_argument_type; +pub mod double_argument_type; +pub mod float_argument_type; pub mod integer_argument_type; +pub mod long_argument_type; +pub mod string_argument_type; pub use argument_type::ArgumentType; diff --git a/azalea-brigadier/src/arguments/string_argument_type.rs b/azalea-brigadier/src/arguments/string_argument_type.rs new file mode 100644 index 00000000..27363bd4 --- /dev/null +++ b/azalea-brigadier/src/arguments/string_argument_type.rs @@ -0,0 +1,53 @@ +use std::{any::Any, rc::Rc}; + +use crate::{ + context::CommandContext, exceptions::CommandSyntaxException, string_reader::StringReader, +}; + +use super::ArgumentType; + +pub enum StringArgument { + /// Match up until the next space. + SingleWord, + /// Same as single word unless the argument is wrapped in quotes, in which + /// case it can contain spaces. + QuotablePhrase, + /// Match the rest of the input. + GreedyPhrase, +} + +impl ArgumentType for StringArgument { + fn parse(&self, reader: &mut StringReader) -> Result<Rc<dyn Any>, CommandSyntaxException> { + let result = match self { + StringArgument::SingleWord => reader.read_unquoted_string().to_string(), + StringArgument::QuotablePhrase => reader.read_string()?, + StringArgument::GreedyPhrase => { + let text = reader.remaining().to_string(); + reader.cursor = reader.total_length(); + text + } + }; + Ok(Rc::new(result)) + } +} + +/// Match up until the next space. +pub fn word() -> impl ArgumentType { + StringArgument::SingleWord +} +/// Same as single word unless the argument is wrapped in quotes, in which case +/// it can contain spaces. +pub fn string() -> impl ArgumentType { + StringArgument::QuotablePhrase +} +/// Match the rest of the input. +pub fn greedy_string() -> impl ArgumentType { + StringArgument::GreedyPhrase +} +pub fn get_string<S>(context: &CommandContext<S>, name: &str) -> Option<String> { + context + .argument(name) + .unwrap() + .downcast_ref::<String>() + .cloned() +} diff --git a/azalea-brigadier/src/builder/argument_builder.rs b/azalea-brigadier/src/builder/argument_builder.rs index 38ccc98c..643a3bd0 100755 --- a/azalea-brigadier/src/builder/argument_builder.rs +++ b/azalea-brigadier/src/builder/argument_builder.rs @@ -1,3 +1,5 @@ +use parking_lot::RwLock; + use crate::{ context::CommandContext, modifier::RedirectModifier, @@ -5,7 +7,7 @@ use crate::{ }; use super::{literal_argument_builder::Literal, required_argument_builder::Argument}; -use std::{cell::RefCell, fmt::Debug, rc::Rc}; +use std::{fmt::Debug, sync::Arc}; #[derive(Debug, Clone)] pub enum ArgumentBuilderType { @@ -18,24 +20,11 @@ pub struct ArgumentBuilder<S> { arguments: CommandNode<S>, command: Command<S>, - requirement: Rc<dyn Fn(Rc<S>) -> bool>, - target: Option<Rc<RefCell<CommandNode<S>>>>, + requirement: Arc<dyn Fn(Arc<S>) -> bool + Send + Sync>, + target: Option<Arc<RwLock<CommandNode<S>>>>, forks: bool, - modifier: Option<Rc<RedirectModifier<S>>>, -} - -impl<S> Clone for ArgumentBuilder<S> { - fn clone(&self) -> Self { - Self { - arguments: self.arguments.clone(), - command: self.command.clone(), - requirement: self.requirement.clone(), - target: self.target.clone(), - forks: self.forks, - modifier: self.modifier.clone(), - } - } + modifier: Option<Arc<RedirectModifier<S>>>, } /// A node that isn't yet built. @@ -47,54 +36,93 @@ impl<S> ArgumentBuilder<S> { ..Default::default() }, command: None, - requirement: Rc::new(|_| true), + requirement: Arc::new(|_| true), forks: false, modifier: None, target: None, } } - pub fn then(&mut self, argument: ArgumentBuilder<S>) -> Self { + /// Continue building this node with a child node. + /// + /// ``` + /// # use azalea_brigadier::prelude::*; + /// # let mut subject = CommandDispatcher::<()>::new(); + /// literal("foo").then( + /// literal("bar").executes(|ctx: &CommandContext<()>| 42) + /// ) + /// # ; + /// ``` + pub fn then(self, argument: ArgumentBuilder<S>) -> Self { self.then_built(argument.build()) } - pub fn then_built(&mut self, argument: CommandNode<S>) -> Self { - self.arguments.add_child(&Rc::new(RefCell::new(argument))); - self.clone() + /// Add an already built child node to this node. + /// + /// You should usually use [`Self::then`] instead. + pub fn then_built(mut self, argument: CommandNode<S>) -> Self { + self.arguments.add_child(&Arc::new(RwLock::new(argument))); + self } - pub fn executes<F>(&mut self, f: F) -> Self + /// Set the command to be executed when this node is reached. If this is not + /// present on a node, it is not a valid command. + /// + /// ``` + /// # use azalea_brigadier::prelude::*; + /// # let mut subject = CommandDispatcher::<()>::new(); + /// # subject.register( + /// literal("foo").executes(|ctx: &CommandContext<()>| 42) + /// # ); + /// ``` + pub fn executes<F>(mut self, f: F) -> Self where - F: Fn(&CommandContext<S>) -> i32 + 'static, + F: Fn(&CommandContext<S>) -> i32 + Send + Sync + 'static, { - self.command = Some(Rc::new(f)); - self.clone() + self.command = Some(Arc::new(f)); + self } - pub fn requires<F>(&mut self, requirement: F) -> Self + /// Set the requirement for this node to be considered. If this is not + /// present on a node, it is considered to always pass. + /// + /// ``` + /// # use azalea_brigadier::prelude::*; + /// # use std::sync::Arc; + /// # pub struct CommandSource { + /// # pub opped: bool, + /// # } + /// # let mut subject = CommandDispatcher::<CommandSource>::new(); + /// # subject.register( + /// literal("foo") + /// .requires(|s: Arc<CommandSource>| s.opped) + /// // ... + /// # .executes(|ctx: &CommandContext<CommandSource>| 42) + /// # ); + pub fn requires<F>(mut self, requirement: F) -> Self where - F: Fn(Rc<S>) -> bool + 'static, + F: Fn(Arc<S>) -> bool + Send + Sync + 'static, { - self.requirement = Rc::new(requirement); - self.clone() + self.requirement = Arc::new(requirement); + self } - pub fn redirect(&mut self, target: Rc<RefCell<CommandNode<S>>>) -> Self { + pub fn redirect(self, target: Arc<RwLock<CommandNode<S>>>) -> Self { self.forward(target, None, false) } pub fn fork( - &mut self, - target: Rc<RefCell<CommandNode<S>>>, - modifier: Rc<RedirectModifier<S>>, + self, + target: Arc<RwLock<CommandNode<S>>>, + modifier: Arc<RedirectModifier<S>>, ) -> Self { self.forward(target, Some(modifier), true) } pub fn forward( - &mut self, - target: Rc<RefCell<CommandNode<S>>>, - modifier: Option<Rc<RedirectModifier<S>>>, + mut self, + target: Arc<RwLock<CommandNode<S>>>, + modifier: Option<Arc<RedirectModifier<S>>>, fork: bool, ) -> Self { if !self.arguments.children.is_empty() { @@ -103,9 +131,11 @@ impl<S> ArgumentBuilder<S> { self.target = Some(target); self.modifier = modifier; self.forks = fork; - self.clone() + self } + /// Manually build this node into a [`CommandNode`]. You probably don't need + /// to do this yourself. pub fn build(self) -> CommandNode<S> { let mut result = CommandNode { value: self.arguments.value, diff --git a/azalea-brigadier/src/builder/required_argument_builder.rs b/azalea-brigadier/src/builder/required_argument_builder.rs index 9d4d9e0a..0363d204 100755 --- a/azalea-brigadier/src/builder/required_argument_builder.rs +++ b/azalea-brigadier/src/builder/required_argument_builder.rs @@ -2,17 +2,17 @@ use super::argument_builder::{ArgumentBuilder, ArgumentBuilderType}; use crate::{ arguments::ArgumentType, exceptions::CommandSyntaxException, string_reader::StringReader, }; -use std::{any::Any, fmt::Debug, rc::Rc}; +use std::{any::Any, fmt::Debug, rc::Rc, sync::Arc}; /// An argument node type. The `T` type parameter is the type of the argument, /// which can be anything. #[derive(Clone)] pub struct Argument { pub name: String, - parser: Rc<dyn ArgumentType>, + parser: Arc<dyn ArgumentType + Send + Sync>, } impl Argument { - pub fn new(name: &str, parser: Rc<dyn ArgumentType>) -> Self { + pub fn new(name: &str, parser: Arc<dyn ArgumentType + Send + Sync>) -> Self { Self { name: name.to_string(), parser, @@ -40,6 +40,9 @@ impl Debug for Argument { } /// Shortcut for creating a new argument builder node. -pub fn argument<S>(name: &str, parser: impl ArgumentType + 'static) -> ArgumentBuilder<S> { - ArgumentBuilder::new(Argument::new(name, Rc::new(parser)).into()) +pub fn argument<S>( + name: &str, + parser: impl ArgumentType + Send + Sync + 'static, +) -> ArgumentBuilder<S> { + ArgumentBuilder::new(Argument::new(name, Arc::new(parser)).into()) } diff --git a/azalea-brigadier/src/command_dispatcher.rs b/azalea-brigadier/src/command_dispatcher.rs index 273b1681..595bc57d 100755 --- a/azalea-brigadier/src/command_dispatcher.rs +++ b/azalea-brigadier/src/command_dispatcher.rs @@ -1,3 +1,5 @@ +use parking_lot::RwLock; + use crate::{ builder::argument_builder::ArgumentBuilder, context::{CommandContext, CommandContextBuilder}, @@ -6,64 +8,72 @@ use crate::{ string_reader::StringReader, tree::CommandNode, }; -use std::{cell::RefCell, cmp::Ordering, collections::HashMap, marker::PhantomData, mem, rc::Rc}; +use std::{cmp::Ordering, collections::HashMap, mem, rc::Rc, sync::Arc}; -#[derive(Default)] -pub struct CommandDispatcher<S> { - pub root: Rc<RefCell<CommandNode<S>>>, - _marker: PhantomData<S>, +/// The root of the command tree. You need to make this to register commands. +/// +/// ``` +/// # use azalea_brigadier::prelude::*; +/// # struct CommandSource; +/// let mut subject = CommandDispatcher::<CommandSource>::new(); +/// ``` +pub struct CommandDispatcher<S> +where + Self: Sync + Send, +{ + pub root: Arc<RwLock<CommandNode<S>>>, } impl<S> CommandDispatcher<S> { pub fn new() -> Self { Self { - root: Rc::new(RefCell::new(CommandNode::default())), - _marker: PhantomData, + root: Arc::new(RwLock::new(CommandNode::default())), } } - pub fn register(&mut self, node: ArgumentBuilder<S>) -> Rc<RefCell<CommandNode<S>>> { - let build = Rc::new(RefCell::new(node.build())); - self.root.borrow_mut().add_child(&build); + /// Add a new node to the root. + /// + /// ``` + /// # use azalea_brigadier::prelude::*; + /// # let mut subject = CommandDispatcher::<()>::new(); + /// subject.register(literal("foo").executes(|_| 42)); + /// ``` + pub fn register(&mut self, node: ArgumentBuilder<S>) -> Arc<RwLock<CommandNode<S>>> { + let build = Arc::new(RwLock::new(node.build())); + self.root.write().add_child(&build); build } - pub fn parse(&self, command: StringReader, source: Rc<S>) -> ParseResults<S> { - let context = CommandContextBuilder::new( - Rc::new(self.clone()), - source, - self.root.clone(), - command.cursor(), - ); + pub fn parse(&self, command: StringReader, source: S) -> ParseResults<S> { + let source = Arc::new(source); + + let context = CommandContextBuilder::new(self, source, self.root.clone(), command.cursor()); self.parse_nodes(&self.root, &command, context).unwrap() } - fn parse_nodes( - &self, - node: &Rc<RefCell<CommandNode<S>>>, + fn parse_nodes<'a>( + &'a self, + node: &Arc<RwLock<CommandNode<S>>>, original_reader: &StringReader, - context_so_far: CommandContextBuilder<S>, - ) -> Result<ParseResults<S>, CommandSyntaxException> { + context_so_far: CommandContextBuilder<'a, S>, + ) -> Result<ParseResults<'a, S>, CommandSyntaxException> { let source = context_so_far.source.clone(); let mut errors = HashMap::<Rc<CommandNode<S>>, CommandSyntaxException>::new(); let mut potentials: Vec<ParseResults<S>> = vec![]; let cursor = original_reader.cursor(); - for child in node - .borrow() - .get_relevant_nodes(&mut original_reader.clone()) - { - if !child.borrow().can_use(source.clone()) { + for child in node.read().get_relevant_nodes(&mut original_reader.clone()) { + if !child.read().can_use(source.clone()) { continue; } let mut context = context_so_far.clone(); let mut reader = original_reader.clone(); let parse_with_context_result = - child.borrow().parse_with_context(&mut reader, &mut context); + child.read().parse_with_context(&mut reader, &mut context); if let Err(ex) = parse_with_context_result { errors.insert( - Rc::new((*child.borrow()).clone()), + Rc::new((*child.read()).clone()), BuiltInExceptions::DispatcherParseException { message: ex.message(), } @@ -74,7 +84,7 @@ impl<S> CommandDispatcher<S> { } if reader.can_read() && reader.peek() != ' ' { errors.insert( - Rc::new((*child.borrow()).clone()), + Rc::new((*child.read()).clone()), BuiltInExceptions::DispatcherExpectedArgumentSeparator .create_with_context(&reader), ); @@ -82,24 +92,20 @@ impl<S> CommandDispatcher<S> { continue; } - context.with_command(&child.borrow().command); - if reader.can_read_length(if child.borrow().redirect.is_none() { + context.with_command(&child.read().command); + if reader.can_read_length(if child.read().redirect.is_none() { 2 } else { 1 }) { reader.skip(); - if let Some(redirect) = &child.borrow().redirect { - let child_context = CommandContextBuilder::new( - Rc::new(self.clone()), - source, - redirect.clone(), - reader.cursor, - ); + if let Some(redirect) = &child.read().redirect { + let child_context = + CommandContextBuilder::new(self, source, redirect.clone(), reader.cursor); let parse = self .parse_nodes(redirect, &reader, child_context) .expect("Parsing nodes failed"); - context.with_child(Rc::new(parse.context)); + context.with_child(Arc::new(parse.context)); return Ok(ParseResults { context, reader: parse.reader, @@ -149,40 +155,46 @@ impl<S> CommandDispatcher<S> { }) } + /// Parse and execute the command using the given input and context. The + /// number returned depends on the command, and may not be of significance. + /// + /// This is a shortcut for `Self::parse` and `Self::execute_parsed`. pub fn execute( &self, - input: StringReader, - source: Rc<S>, + input: impl Into<StringReader>, + source: S, ) -> Result<i32, CommandSyntaxException> { + let input = input.into(); + let parse = self.parse(input, source); Self::execute_parsed(parse) } pub fn add_paths( - node: Rc<RefCell<CommandNode<S>>>, - result: &mut Vec<Vec<Rc<RefCell<CommandNode<S>>>>>, - parents: Vec<Rc<RefCell<CommandNode<S>>>>, + node: Arc<RwLock<CommandNode<S>>>, + result: &mut Vec<Vec<Arc<RwLock<CommandNode<S>>>>>, + parents: Vec<Arc<RwLock<CommandNode<S>>>>, ) { let mut current = parents; current.push(node.clone()); result.push(current.clone()); - for child in node.borrow().children.values() { + for child in node.read().children.values() { Self::add_paths(child.clone(), result, current.clone()); } } pub fn get_path(&self, target: CommandNode<S>) -> Vec<String> { - let rc_target = Rc::new(RefCell::new(target)); - let mut nodes: Vec<Vec<Rc<RefCell<CommandNode<S>>>>> = Vec::new(); + let rc_target = Arc::new(RwLock::new(target)); + let mut nodes: Vec<Vec<Arc<RwLock<CommandNode<S>>>>> = Vec::new(); Self::add_paths(self.root.clone(), &mut nodes, vec![]); for list in nodes { - if *list.last().expect("Nothing in list").borrow() == *rc_target.borrow() { + if *list.last().expect("Nothing in list").read() == *rc_target.read() { let mut result: Vec<String> = Vec::with_capacity(list.len()); for node in list { - if node != self.root { - result.push(node.borrow().name().to_string()); + if !Arc::ptr_eq(&node, &self.root) { + result.push(node.read().name().to_string()); } } return result; @@ -191,10 +203,10 @@ impl<S> CommandDispatcher<S> { vec![] } - pub fn find_node(&self, path: &[&str]) -> Option<Rc<RefCell<CommandNode<S>>>> { + pub fn find_node(&self, path: &[&str]) -> Option<Arc<RwLock<CommandNode<S>>>> { let mut node = self.root.clone(); for name in path { - if let Some(child) = node.clone().borrow().child(name) { + if let Some(child) = node.clone().read().child(name) { node = child; } else { return None; @@ -287,11 +299,8 @@ impl<S> CommandDispatcher<S> { } } -impl<S> Clone for CommandDispatcher<S> { - fn clone(&self) -> Self { - Self { - root: self.root.clone(), - _marker: PhantomData, - } +impl<S> Default for CommandDispatcher<S> { + fn default() -> Self { + Self::new() } } diff --git a/azalea-brigadier/src/context/command_context.rs b/azalea-brigadier/src/context/command_context.rs index 98609a6e..1734bb05 100755 --- a/azalea-brigadier/src/context/command_context.rs +++ b/azalea-brigadier/src/context/command_context.rs @@ -1,21 +1,23 @@ +use parking_lot::RwLock; + use super::{parsed_command_node::ParsedCommandNode, string_range::StringRange, ParsedArgument}; use crate::{ modifier::RedirectModifier, tree::{Command, CommandNode}, }; -use std::{any::Any, cell::RefCell, collections::HashMap, fmt::Debug, rc::Rc}; +use std::{any::Any, collections::HashMap, fmt::Debug, rc::Rc, sync::Arc}; /// A built `CommandContextBuilder`. pub struct CommandContext<S> { - pub source: Rc<S>, + pub source: Arc<S>, pub input: String, pub arguments: HashMap<String, ParsedArgument>, pub command: Command<S>, - pub root_node: Rc<RefCell<CommandNode<S>>>, + pub root_node: Arc<RwLock<CommandNode<S>>>, pub nodes: Vec<ParsedCommandNode<S>>, pub range: StringRange, - pub child: Option<Rc<CommandContext<S>>>, - pub modifier: Option<Rc<RedirectModifier<S>>>, + pub child: Option<Arc<CommandContext<S>>>, + pub modifier: Option<Arc<RedirectModifier<S>>>, pub forks: bool, } @@ -54,8 +56,8 @@ impl<S> Debug for CommandContext<S> { } impl<S> CommandContext<S> { - pub fn copy_for(&self, source: Rc<S>) -> Self { - if Rc::ptr_eq(&source, &self.source) { + pub fn copy_for(&self, source: Arc<S>) -> Self { + if Arc::ptr_eq(&source, &self.source) { return self.clone(); } CommandContext { diff --git a/azalea-brigadier/src/context/command_context_builder.rs b/azalea-brigadier/src/context/command_context_builder.rs index 7516ab9e..78088941 100755 --- a/azalea-brigadier/src/context/command_context_builder.rs +++ b/azalea-brigadier/src/context/command_context_builder.rs @@ -1,3 +1,5 @@ +use parking_lot::RwLock; + use super::{ command_context::CommandContext, parsed_command_node::ParsedCommandNode, string_range::StringRange, ParsedArgument, @@ -7,28 +9,28 @@ use crate::{ modifier::RedirectModifier, tree::{Command, CommandNode}, }; -use std::{cell::RefCell, collections::HashMap, fmt::Debug, rc::Rc}; +use std::{collections::HashMap, fmt::Debug, sync::Arc}; -pub struct CommandContextBuilder<S> { +pub struct CommandContextBuilder<'a, S> { pub arguments: HashMap<String, ParsedArgument>, - pub root: Rc<RefCell<CommandNode<S>>>, + pub root: Arc<RwLock<CommandNode<S>>>, pub nodes: Vec<ParsedCommandNode<S>>, - pub dispatcher: Rc<CommandDispatcher<S>>, - pub source: Rc<S>, + pub dispatcher: &'a CommandDispatcher<S>, + pub source: Arc<S>, pub command: Command<S>, - pub child: Option<Rc<CommandContextBuilder<S>>>, + pub child: Option<Arc<CommandContextBuilder<'a, S>>>, pub range: StringRange, - pub modifier: Option<Rc<RedirectModifier<S>>>, + pub modifier: Option<Arc<RedirectModifier<S>>>, pub forks: bool, } -impl<S> Clone for CommandContextBuilder<S> { +impl<S> Clone for CommandContextBuilder<'_, S> { fn clone(&self) -> Self { Self { arguments: self.arguments.clone(), root: self.root.clone(), nodes: self.nodes.clone(), - dispatcher: self.dispatcher.clone(), + dispatcher: self.dispatcher, source: self.source.clone(), command: self.command.clone(), child: self.child.clone(), @@ -39,11 +41,11 @@ impl<S> Clone for CommandContextBuilder<S> { } } -impl<S> CommandContextBuilder<S> { +impl<'a, S> CommandContextBuilder<'a, S> { pub fn new( - dispatcher: Rc<CommandDispatcher<S>>, - source: Rc<S>, - root_node: Rc<RefCell<CommandNode<S>>>, + dispatcher: &'a CommandDispatcher<S>, + source: Arc<S>, + root_node: Arc<RwLock<CommandNode<S>>>, start: usize, ) -> Self { Self { @@ -64,7 +66,7 @@ impl<S> CommandContextBuilder<S> { self.command = command.clone(); self } - pub fn with_child(&mut self, child: Rc<CommandContextBuilder<S>>) -> &Self { + pub fn with_child(&mut self, child: Arc<CommandContextBuilder<'a, S>>) -> &Self { self.child = Some(child); self } @@ -72,14 +74,14 @@ impl<S> CommandContextBuilder<S> { self.arguments.insert(name.to_string(), argument); self } - pub fn with_node(&mut self, node: Rc<RefCell<CommandNode<S>>>, range: StringRange) -> &Self { + pub fn with_node(&mut self, node: Arc<RwLock<CommandNode<S>>>, range: StringRange) -> &Self { self.nodes.push(ParsedCommandNode { node: node.clone(), range: range.clone(), }); self.range = StringRange::encompassing(&self.range, &range); - self.modifier = node.borrow().modifier.clone(); - self.forks = node.borrow().forks; + self.modifier = node.read().modifier.clone(); + self.forks = node.read().forks; self } @@ -90,7 +92,7 @@ impl<S> CommandContextBuilder<S> { nodes: self.nodes.clone(), source: self.source.clone(), command: self.command.clone(), - child: self.child.clone().map(|c| Rc::new(c.build(input))), + child: self.child.clone().map(|c| Arc::new(c.build(input))), range: self.range.clone(), forks: self.forks, modifier: self.modifier.clone(), @@ -99,7 +101,7 @@ impl<S> CommandContextBuilder<S> { } } -impl<S> Debug for CommandContextBuilder<S> { +impl<S> Debug for CommandContextBuilder<'_, S> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.debug_struct("CommandContextBuilder") // .field("arguments", &self.arguments) diff --git a/azalea-brigadier/src/context/parsed_command_node.rs b/azalea-brigadier/src/context/parsed_command_node.rs index ed49928d..bba5d121 100755 --- a/azalea-brigadier/src/context/parsed_command_node.rs +++ b/azalea-brigadier/src/context/parsed_command_node.rs @@ -1,10 +1,12 @@ +use parking_lot::RwLock; + use super::string_range::StringRange; use crate::tree::CommandNode; -use std::{cell::RefCell, rc::Rc}; +use std::sync::Arc; #[derive(Debug)] pub struct ParsedCommandNode<S> { - pub node: Rc<RefCell<CommandNode<S>>>, + pub node: Arc<RwLock<CommandNode<S>>>, pub range: StringRange, } diff --git a/azalea-brigadier/src/lib.rs b/azalea-brigadier/src/lib.rs index eb670643..161ef83a 100755 --- a/azalea-brigadier/src/lib.rs +++ b/azalea-brigadier/src/lib.rs @@ -10,3 +10,18 @@ pub mod parse_results; pub mod string_reader; pub mod suggestion; pub mod tree; + +pub mod prelude { + pub use crate::{ + arguments::{ + double_argument_type::{double, get_double}, + float_argument_type::{float, get_float}, + integer_argument_type::{get_integer, integer}, + long_argument_type::{get_long, long}, + string_argument_type::{get_string, greedy_string, string, word}, + }, + builder::{literal_argument_builder::literal, required_argument_builder::argument}, + command_dispatcher::CommandDispatcher, + context::CommandContext, + }; +} diff --git a/azalea-brigadier/src/modifier.rs b/azalea-brigadier/src/modifier.rs index d40d59f9..bebdd0cb 100755 --- a/azalea-brigadier/src/modifier.rs +++ b/azalea-brigadier/src/modifier.rs @@ -1,6 +1,6 @@ -use std::rc::Rc; +use std::sync::Arc; use crate::{context::CommandContext, exceptions::CommandSyntaxException}; pub type RedirectModifier<S> = - dyn Fn(&CommandContext<S>) -> Result<Vec<Rc<S>>, CommandSyntaxException>; + dyn Fn(&CommandContext<S>) -> Result<Vec<Arc<S>>, CommandSyntaxException> + Send + Sync; diff --git a/azalea-brigadier/src/parse_results.rs b/azalea-brigadier/src/parse_results.rs index 3698ae82..aa7d79ea 100755 --- a/azalea-brigadier/src/parse_results.rs +++ b/azalea-brigadier/src/parse_results.rs @@ -4,13 +4,13 @@ use crate::{ }; use std::{collections::HashMap, fmt::Debug, rc::Rc}; -pub struct ParseResults<S> { - pub context: CommandContextBuilder<S>, +pub struct ParseResults<'a, S> { + pub context: CommandContextBuilder<'a, S>, pub reader: StringReader, pub exceptions: HashMap<Rc<CommandNode<S>>, CommandSyntaxException>, } -impl<S> Debug for ParseResults<S> { +impl<S> Debug for ParseResults<'_, S> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.debug_struct("ParseResults") .field("context", &self.context) diff --git a/azalea-brigadier/src/tree/mod.rs b/azalea-brigadier/src/tree/mod.rs index bb6af68d..cec972dc 100755 --- a/azalea-brigadier/src/tree/mod.rs +++ b/azalea-brigadier/src/tree/mod.rs @@ -1,3 +1,5 @@ +use parking_lot::RwLock; + use crate::{ builder::{ argument_builder::ArgumentBuilderType, literal_argument_builder::Literal, @@ -8,24 +10,24 @@ use crate::{ modifier::RedirectModifier, string_reader::StringReader, }; -use std::{cell::RefCell, collections::HashMap, fmt::Debug, hash::Hash, ptr, rc::Rc}; +use std::{collections::HashMap, fmt::Debug, hash::Hash, ptr, sync::Arc}; -pub type Command<S> = Option<Rc<dyn Fn(&CommandContext<S>) -> i32>>; +pub type Command<S> = Option<Arc<dyn Fn(&CommandContext<S>) -> i32 + Send + Sync>>; /// An ArgumentBuilder that has been built. #[non_exhaustive] pub struct CommandNode<S> { pub value: ArgumentBuilderType, - pub children: HashMap<String, Rc<RefCell<CommandNode<S>>>>, - pub literals: HashMap<String, Rc<RefCell<CommandNode<S>>>>, - pub arguments: HashMap<String, Rc<RefCell<CommandNode<S>>>>, + pub children: HashMap<String, Arc<RwLock<CommandNode<S>>>>, + pub literals: HashMap<String, Arc<RwLock<CommandNode<S>>>>, + pub arguments: HashMap<String, Arc<RwLock<CommandNode<S>>>>, pub command: Command<S>, - pub requirement: Rc<dyn Fn(Rc<S>) -> bool>, - pub redirect: Option<Rc<RefCell<CommandNode<S>>>>, + pub requirement: Arc<dyn Fn(Arc<S>) -> bool + Send + Sync>, + pub redirect: Option<Arc<RwLock<CommandNode<S>>>>, pub forks: bool, - pub modifier: Option<Rc<RedirectModifier<S>>>, + pub modifier: Option<Arc<RedirectModifier<S>>>, } impl<S> Clone for CommandNode<S> { @@ -62,7 +64,7 @@ impl<S> CommandNode<S> { } } - pub fn get_relevant_nodes(&self, input: &mut StringReader) -> Vec<Rc<RefCell<CommandNode<S>>>> { + pub fn get_relevant_nodes(&self, input: &mut StringReader) -> Vec<Arc<RwLock<CommandNode<S>>>> { let literals = &self.literals; if literals.is_empty() { @@ -88,24 +90,24 @@ impl<S> CommandNode<S> { } } - pub fn can_use(&self, source: Rc<S>) -> bool { + pub fn can_use(&self, source: Arc<S>) -> bool { (self.requirement)(source) } - pub fn add_child(&mut self, node: &Rc<RefCell<CommandNode<S>>>) { - let child = self.children.get(node.borrow().name()); + pub fn add_child(&mut self, node: &Arc<RwLock<CommandNode<S>>>) { + let child = self.children.get(node.read().name()); if let Some(child) = child { // We've found something to merge onto - if let Some(command) = &node.borrow().command { - child.borrow_mut().command = Some(command.clone()); + if let Some(command) = &node.read().command { + child.write().command = Some(command.clone()); } - for grandchild in node.borrow().children.values() { - child.borrow_mut().add_child(grandchild); + for grandchild in node.read().children.values() { + child.write().add_child(grandchild); } } else { self.children - .insert(node.borrow().name().to_string(), node.clone()); - match &node.borrow().value { + .insert(node.read().name().to_string(), node.clone()); + match &node.read().value { ArgumentBuilderType::Literal(literal) => { self.literals.insert(literal.value.clone(), node.clone()); } @@ -123,7 +125,7 @@ impl<S> CommandNode<S> { } } - pub fn child(&self, name: &str) -> Option<Rc<RefCell<CommandNode<S>>>> { + pub fn child(&self, name: &str) -> Option<Arc<RwLock<CommandNode<S>>>> { self.children.get(name).cloned() } @@ -142,7 +144,7 @@ impl<S> CommandNode<S> { }; context_builder.with_argument(&argument.name, parsed.clone()); - context_builder.with_node(Rc::new(RefCell::new(self.clone())), parsed.range); + context_builder.with_node(Arc::new(RwLock::new(self.clone())), parsed.range); Ok(()) } @@ -152,7 +154,7 @@ impl<S> CommandNode<S> { if let Some(end) = end { context_builder.with_node( - Rc::new(RefCell::new(self.clone())), + Arc::new(RwLock::new(self.clone())), StringRange::between(start, end), ); return Ok(()); @@ -219,7 +221,7 @@ impl<S> Default for CommandNode<S> { arguments: HashMap::new(), command: None, - requirement: Rc::new(|_| true), + requirement: Arc::new(|_| true), redirect: None, forks: false, modifier: None, @@ -232,7 +234,7 @@ impl<S> Hash for CommandNode<S> { // hash the children for (k, v) in &self.children { k.hash(state); - v.borrow().hash(state); + v.read().hash(state); } // i hope this works because if doesn't then that'll be a problem ptr::hash(&self.command, state); @@ -241,14 +243,21 @@ impl<S> Hash for CommandNode<S> { impl<S> PartialEq for CommandNode<S> { fn eq(&self, other: &Self) -> bool { - if self.children != other.children { + if self.children.len() != other.children.len() { return false; } + for (k, v) in &self.children { + let other_child = other.children.get(k).unwrap(); + if !Arc::ptr_eq(v, other_child) { + return false; + } + } + if let Some(selfexecutes) = &self.command { // idk how to do this better since we can't compare `dyn Fn`s if let Some(otherexecutes) = &other.command { #[allow(clippy::vtable_address_comparisons)] - if !Rc::ptr_eq(selfexecutes, otherexecutes) { + if !Arc::ptr_eq(selfexecutes, otherexecutes) { return false; } } else { diff --git a/azalea-brigadier/tests/builder/argument_builder_test.rs b/azalea-brigadier/tests/builder/argument_builder_test.rs index e570c988..ee44f5e6 100755 --- a/azalea-brigadier/tests/builder/argument_builder_test.rs +++ b/azalea-brigadier/tests/builder/argument_builder_test.rs @@ -17,13 +17,14 @@ use super::ArgumentBuilder; // @Test // public void testArguments() throws Exception { -// final RequiredArgumentBuilder<Object, ?> argument = argument("bar", integer()); +// final RequiredArgumentBuilder<Object, ?> argument = argument("bar", +// integer()); // builder.then(argument); // assertThat(builder.getArguments(), hasSize(1)); -// assertThat(builder.getArguments(), hasItem((CommandNode<Object>) argument.build())); -// } +// assertThat(builder.getArguments(), hasItem((CommandNode<Object>) +// argument.build())); } #[test] fn test_arguments() { @@ -37,7 +38,7 @@ fn test_arguments() { .arguments .children .values() - .any(|e| *e.borrow() == *built_argument)); + .any(|e| *e.read() == *built_argument)); } // @Test @@ -61,8 +62,8 @@ fn test_arguments() { // builder.then(literal("foo")); // } -// private static class TestableArgumentBuilder<S> extends ArgumentBuilder<S, TestableArgumentBuilder<S>> { -// @Override +// private static class TestableArgumentBuilder<S> extends +// ArgumentBuilder<S, TestableArgumentBuilder<S>> { @Override // protected TestableArgumentBuilder<S> getThis() { // return this; // } diff --git a/azalea-brigadier/tests/command_dispatcher_test.rs b/azalea-brigadier/tests/command_dispatcher_test.rs index e30dd2c1..eecbf668 100755 --- a/azalea-brigadier/tests/command_dispatcher_test.rs +++ b/azalea-brigadier/tests/command_dispatcher_test.rs @@ -1,4 +1,4 @@ -use std::rc::Rc; +use std::sync::Arc; use azalea_brigadier::{ arguments::integer_argument_type::integer, @@ -19,26 +19,13 @@ fn input_with_offset(input: &str, offset: usize) -> StringReader { } #[test] -fn create_and_execute_command() { - let mut subject = CommandDispatcher::new(); - subject.register(literal("foo").executes(|_| 42)); - - assert_eq!( - subject - .execute("foo".into(), Rc::new(CommandSource {})) - .unwrap(), - 42 - ); -} - -#[test] fn create_and_execute_offset_command() { let mut subject = CommandDispatcher::new(); subject.register(literal("foo").executes(|_| 42)); assert_eq!( subject - .execute(input_with_offset("/foo", 1), Rc::new(CommandSource {})) + .execute(input_with_offset("/foo", 1), &CommandSource {}) .unwrap(), 42 ); @@ -50,18 +37,8 @@ fn create_and_merge_commands() { subject.register(literal("base").then(literal("foo").executes(|_| 42))); subject.register(literal("base").then(literal("bar").executes(|_| 42))); - assert_eq!( - subject - .execute("base foo".into(), Rc::new(CommandSource {})) - .unwrap(), - 42 - ); - assert_eq!( - subject - .execute("base bar".into(), Rc::new(CommandSource {})) - .unwrap(), - 42 - ); + assert_eq!(subject.execute("base foo", &CommandSource {}).unwrap(), 42); + assert_eq!(subject.execute("base bar", &CommandSource {}).unwrap(), 42); } #[test] @@ -70,7 +47,7 @@ fn execute_unknown_command() { subject.register(literal("bar")); subject.register(literal("baz")); - let execute_result = subject.execute("foo".into(), Rc::new(CommandSource {})); + let execute_result = subject.execute("foo", &CommandSource {}); let err = execute_result.err().unwrap(); match err.type_ { @@ -85,7 +62,7 @@ fn execute_impermissible_command() { let mut subject = CommandDispatcher::new(); subject.register(literal("foo").requires(|_| false)); - let execute_result = subject.execute("foo".into(), Rc::new(CommandSource {})); + let execute_result = subject.execute("foo", &CommandSource {}); let err = execute_result.err().unwrap(); match err.type_ { @@ -100,7 +77,7 @@ fn execute_empty_command() { let mut subject = CommandDispatcher::new(); subject.register(literal("")); - let execute_result = subject.execute("".into(), Rc::new(CommandSource {})); + let execute_result = subject.execute("", &CommandSource {}); let err = execute_result.err().unwrap(); match err.type_ { @@ -115,7 +92,7 @@ fn execute_unknown_subcommand() { let mut subject = CommandDispatcher::new(); subject.register(literal("foo").executes(|_| 42)); - let execute_result = subject.execute("foo bar".into(), Rc::new(CommandSource {})); + let execute_result = subject.execute("foo bar", &CommandSource {}); let err = execute_result.err().unwrap(); match err.type_ { @@ -130,7 +107,7 @@ fn execute_incorrect_literal() { let mut subject = CommandDispatcher::new(); subject.register(literal("foo").executes(|_| 42).then(literal("bar"))); - let execute_result = subject.execute("foo baz".into(), Rc::new(CommandSource {})); + let execute_result = subject.execute("foo baz", &CommandSource {}); let err = execute_result.err().unwrap(); match err.type_ { @@ -150,7 +127,7 @@ fn execute_ambiguous_incorrect_argument() { .then(literal("baz")), ); - let execute_result = subject.execute("foo unknown".into(), Rc::new(CommandSource {})); + let execute_result = subject.execute("foo unknown", &CommandSource {}); let err = execute_result.err().unwrap(); match err.type_ { @@ -172,12 +149,7 @@ fn execute_subcommand() { .executes(|_| 42), ); - assert_eq!( - subject - .execute("foo =".into(), Rc::new(CommandSource {})) - .unwrap(), - 100 - ); + assert_eq!(subject.execute("foo =", &CommandSource {}).unwrap(), 100); } #[test] @@ -185,7 +157,7 @@ fn parse_incomplete_literal() { let mut subject = CommandDispatcher::new(); subject.register(literal("foo").then(literal("bar").executes(|_| 42))); - let parse = subject.parse("foo ".into(), Rc::new(CommandSource {})); + let parse = subject.parse("foo ".into(), &CommandSource {}); assert_eq!(parse.reader.remaining(), " "); assert_eq!(parse.context.nodes.len(), 1); } @@ -195,7 +167,7 @@ fn parse_incomplete_argument() { let mut subject = CommandDispatcher::new(); subject.register(literal("foo").then(argument("bar", integer()).executes(|_| 42))); - let parse = subject.parse("foo ".into(), Rc::new(CommandSource {})); + let parse = subject.parse("foo ".into(), &CommandSource {}); assert_eq!(parse.reader.remaining(), " "); assert_eq!(parse.context.nodes.len(), 1); } @@ -210,12 +182,7 @@ fn execute_ambiguious_parent_subcommand() { .then(argument("right", integer()).then(argument("sub", integer()).executes(|_| 100))), ); - assert_eq!( - subject - .execute("test 1 2".into(), Rc::new(CommandSource {})) - .unwrap(), - 100 - ); + assert_eq!(subject.execute("test 1 2", &CommandSource {}).unwrap(), 100); } #[test] @@ -231,9 +198,7 @@ fn execute_ambiguious_parent_subcommand_via_redirect() { subject.register(literal("redirect").redirect(real)); assert_eq!( - subject - .execute("redirect 1 2".into(), Rc::new(CommandSource {})) - .unwrap(), + subject.execute("redirect 1 2", &CommandSource {}).unwrap(), 100 ); } @@ -248,34 +213,37 @@ fn execute_redirected_multiple_times() { let input = "redirected redirected actual"; - let parse = subject.parse(input.into(), Rc::new(CommandSource {})); + let parse = subject.parse(input.into(), &CommandSource {}); assert_eq!(parse.context.range.get(input), "redirected"); assert_eq!(parse.context.nodes.len(), 1); - assert_eq!(parse.context.root, root); + assert_eq!(*parse.context.root.read(), *root.read()); assert_eq!(parse.context.nodes[0].range, parse.context.range); - assert_eq!(parse.context.nodes[0].node, redirect_node); + assert_eq!(*parse.context.nodes[0].node.read(), *redirect_node.read()); let child1 = parse.context.child.clone(); assert!(child1.is_some()); assert_eq!(child1.clone().unwrap().range.get(input), "redirected"); assert_eq!(child1.clone().unwrap().nodes.len(), 1); - assert_eq!(child1.clone().unwrap().root, root); + assert_eq!(*child1.clone().unwrap().root.read(), *root.read()); assert_eq!( child1.clone().unwrap().nodes[0].range, child1.clone().unwrap().range ); - assert_eq!(child1.clone().unwrap().nodes[0].node, redirect_node); + assert_eq!( + *child1.clone().unwrap().nodes[0].node.read(), + *redirect_node.read() + ); let child2 = child1.unwrap().child.clone(); assert!(child2.is_some()); assert_eq!(child2.clone().unwrap().range.get(input), "actual"); assert_eq!(child2.clone().unwrap().nodes.len(), 1); - assert_eq!(child2.clone().unwrap().root, root); + assert_eq!(*child2.clone().unwrap().root.read(), *root.read()); assert_eq!( child2.clone().unwrap().nodes[0].range, child2.clone().unwrap().range ); - assert_eq!(child2.unwrap().nodes[0].node, concrete_node); + assert_eq!(*child2.unwrap().nodes[0].node.read(), *concrete_node.read()); assert_eq!(CommandDispatcher::execute_parsed(parse).unwrap(), 42); } @@ -284,34 +252,34 @@ fn execute_redirected_multiple_times() { fn execute_redirected() { let mut subject = CommandDispatcher::new(); - let source1 = Rc::new(CommandSource {}); - let source2 = Rc::new(CommandSource {}); + let source1 = Arc::new(CommandSource {}); + let source2 = Arc::new(CommandSource {}); - let modifier = move |_: &CommandContext<CommandSource>| -> Result<Vec<Rc<CommandSource>>, CommandSyntaxException> { + let modifier = move |_: &CommandContext<CommandSource>| -> Result<Vec<Arc<CommandSource>>, CommandSyntaxException> { Ok(vec![source1.clone(), source2.clone()]) }; let concrete_node = subject.register(literal("actual").executes(|_| 42)); let redirect_node = - subject.register(literal("redirected").fork(subject.root.clone(), Rc::new(modifier))); + subject.register(literal("redirected").fork(subject.root.clone(), Arc::new(modifier))); let input = "redirected actual"; - let parse = subject.parse(input.into(), Rc::new(CommandSource {})); + let parse = subject.parse(input.into(), CommandSource {}); assert_eq!(parse.context.range.get(input), "redirected"); assert_eq!(parse.context.nodes.len(), 1); - assert_eq!(parse.context.root, subject.root); + assert_eq!(*parse.context.root.read(), *subject.root.read()); assert_eq!(parse.context.nodes[0].range, parse.context.range); - assert_eq!(parse.context.nodes[0].node, redirect_node); + assert_eq!(*parse.context.nodes[0].node.read(), *redirect_node.read()); let parent = parse.context.child.clone(); assert!(parent.is_some()); let parent = parent.unwrap(); assert_eq!(parent.range.get(input), "actual"); assert_eq!(parent.nodes.len(), 1); - assert_eq!(parse.context.root, subject.root); + assert_eq!(*parse.context.root.read(), *subject.root.read()); assert_eq!(parent.nodes[0].range, parent.range); - assert_eq!(parent.nodes[0].node, concrete_node); - assert_eq!(parent.source, Rc::new(CommandSource {})); + assert_eq!(*parent.nodes[0].node.read(), *concrete_node.read()); + assert_eq!(*parent.source, CommandSource {}); assert_eq!(CommandDispatcher::execute_parsed(parse).unwrap(), 2); } @@ -326,7 +294,7 @@ fn execute_orphaned_subcommand() { .executes(|_| 42), ); - let result = subject.execute("foo 5".into(), Rc::new(CommandSource {})); + let result = subject.execute("foo 5", &CommandSource {}); assert!(result.is_err()); let result = result.unwrap_err(); assert_eq!( @@ -343,12 +311,7 @@ fn execute_invalid_other() { subject.register(literal("w").executes(|_| panic!("This should not run"))); subject.register(literal("world").executes(|_| 42)); - assert_eq!( - subject - .execute("world".into(), Rc::new(CommandSource {})) - .unwrap(), - 42 - ); + assert_eq!(subject.execute("world", &CommandSource {}).unwrap(), 42); } #[test] @@ -361,7 +324,7 @@ fn parse_no_space_separator() { .executes(|_| 42), ); - let result = subject.execute("foo$".into(), Rc::new(CommandSource {})); + let result = subject.execute("foo$", &CommandSource {}); assert!(result.is_err()); let result = result.unwrap_err(); assert_eq!( @@ -381,7 +344,7 @@ fn execute_invalid_subcommand() { .executes(|_| 42), ); - let result = subject.execute("foo bar".into(), Rc::new(CommandSource {})); + let result = subject.execute("foo bar", &CommandSource {}); assert!(result.is_err()); let result = result.unwrap_err(); // this fails for some reason, i blame mojang @@ -406,5 +369,5 @@ fn get_path() { fn find_node_doesnt_exist() { let subject = CommandDispatcher::<()>::new(); - assert_eq!(subject.find_node(&["foo", "bar"]), None) + assert!(subject.find_node(&["foo", "bar"]).is_none()) } diff --git a/azalea-client/src/client.rs b/azalea-client/src/client.rs index 7a4285e6..f2e91dfa 100644 --- a/azalea-client/src/client.rs +++ b/azalea-client/src/client.rs @@ -11,6 +11,7 @@ use crate::{ movement::{LastSentLookDirection, PlayerMovePlugin}, packet_handling::{self, PacketHandlerPlugin, PacketReceiver}, player::retroactively_add_game_profile_component, + respawn::RespawnPlugin, task_pool::TaskPoolPlugin, Account, PlayerInfo, }; @@ -717,6 +718,7 @@ impl PluginGroup for DefaultPlugins { .add(DisconnectPlugin) .add(PlayerMovePlugin) .add(InteractPlugin) + .add(RespawnPlugin) .add(TickBroadcastPlugin) } } diff --git a/azalea-client/src/interact.rs b/azalea-client/src/interact.rs index ec5ed87b..2da80760 100644 --- a/azalea-client/src/interact.rs +++ b/azalea-client/src/interact.rs @@ -6,7 +6,7 @@ use azalea_protocol::packets::game::{ }; use azalea_world::{ entity::{clamp_look_direction, view_vector, EyeHeight, LookDirection, Position, WorldName}, - InstanceContainer, + Instance, InstanceContainer, }; use bevy_app::{App, Plugin}; use bevy_ecs::{ @@ -153,13 +153,13 @@ fn update_hit_result_component( y: position.y + **eye_height as f64, z: position.z, }; - let hit_result = pick( - look_direction, - &eye_position, - world_name, - &instance_container, - pick_range, - ); + + let Some(instance_lock) = instance_container.get(world_name) else { + continue; + }; + let instance = instance_lock.read(); + + let hit_result = pick(look_direction, &eye_position, &instance, pick_range); if let Some(mut hit_result_ref) = hit_result_ref { **hit_result_ref = hit_result; } else { @@ -178,16 +178,11 @@ fn update_hit_result_component( pub fn pick( look_direction: &LookDirection, eye_position: &Vec3, - world_name: &WorldName, - instance_container: &InstanceContainer, + instance: &Instance, pick_range: f64, ) -> BlockHitResult { let view_vector = view_vector(look_direction); let end_position = eye_position + &(view_vector * pick_range); - let instance_lock = instance_container - .get(world_name) - .expect("entities must always be in a valid world"); - let instance = instance_lock.read(); azalea_physics::clip::clip( &instance.chunks, ClipContext { diff --git a/azalea-client/src/lib.rs b/azalea-client/src/lib.rs index c198ced3..2c08033b 100644 --- a/azalea-client/src/lib.rs +++ b/azalea-client/src/lib.rs @@ -25,6 +25,7 @@ mod movement; pub mod packet_handling; pub mod ping; mod player; +pub mod respawn; pub mod task_pool; pub use account::{Account, AccountOpts}; diff --git a/azalea-client/src/local_player.rs b/azalea-client/src/local_player.rs index 423b4308..691f9ced 100644 --- a/azalea-client/src/local_player.rs +++ b/azalea-client/src/local_player.rs @@ -139,9 +139,10 @@ pub fn update_in_loaded_chunk( ) { for (entity, local_player, position) in &query { let player_chunk_pos = ChunkPos::from(position); - let instance_lock = instance_container - .get(local_player) - .expect("local player should always be in an instance"); + let Some(instance_lock) = instance_container.get(local_player) else { + continue; + }; + let in_loaded_chunk = instance_lock.read().chunks.get(&player_chunk_pos).is_some(); if in_loaded_chunk { commands.entity(entity).insert(LocalPlayerInLoadedChunk); diff --git a/azalea-client/src/packet_handling.rs b/azalea-client/src/packet_handling.rs index 8ffff870..50887096 100644 --- a/azalea-client/src/packet_handling.rs +++ b/azalea-client/src/packet_handling.rs @@ -9,7 +9,9 @@ use azalea_protocol::{ serverbound_custom_payload_packet::ServerboundCustomPayloadPacket, serverbound_keep_alive_packet::ServerboundKeepAlivePacket, serverbound_move_player_pos_rot_packet::ServerboundMovePlayerPosRotPacket, - ClientboundGamePacket, ServerboundGamePacket, + serverbound_pong_packet::ServerboundPongPacket, + serverbound_resource_pack_packet::ServerboundResourcePackPacket, ClientboundGamePacket, + ServerboundGamePacket, }, read::ReadPacketError, }; @@ -995,7 +997,15 @@ fn process_packet_events(ecs: &mut World) { }) } ClientboundGamePacket::OpenSignEditor(_) => {} - ClientboundGamePacket::Ping(_) => {} + ClientboundGamePacket::Ping(p) => { + debug!("Got ping packet {:?}", p); + + let mut system_state: SystemState<Query<&mut LocalPlayer>> = SystemState::new(ecs); + let mut query = system_state.get_mut(ecs); + + let local_player = query.get_mut(player_entity).unwrap(); + local_player.write_packet(ServerboundPongPacket { id: p.id }.get()); + } ClientboundGamePacket::PlaceGhostRecipe(_) => {} ClientboundGamePacket::PlayerCombatEnd(_) => {} ClientboundGamePacket::PlayerCombatEnter(_) => {} @@ -1023,7 +1033,16 @@ fn process_packet_events(ecs: &mut World) { } ClientboundGamePacket::PlayerLookAt(_) => {} ClientboundGamePacket::RemoveMobEffect(_) => {} - ClientboundGamePacket::ResourcePack(_) => {} + ClientboundGamePacket::ResourcePack(p) => { + debug!("Got resource pack packet {:?}", p); + + let mut system_state: SystemState<Query<&mut LocalPlayer>> = SystemState::new(ecs); + let mut query = system_state.get_mut(ecs); + + let local_player = query.get_mut(player_entity).unwrap(); + // always accept resource pack + local_player.write_packet(ServerboundResourcePackPacket { action: azalea_protocol::packets::game::serverbound_resource_pack_packet::Action::Accepted }.get()); + } ClientboundGamePacket::Respawn(p) => { debug!("Got respawn packet {:?}", p); diff --git a/azalea-client/src/respawn.rs b/azalea-client/src/respawn.rs new file mode 100644 index 00000000..4e42157c --- /dev/null +++ b/azalea-client/src/respawn.rs @@ -0,0 +1,38 @@ +use azalea_protocol::packets::game::serverbound_client_command_packet::{ + self, ServerboundClientCommandPacket, +}; +use bevy_app::{App, Plugin}; +use bevy_ecs::prelude::*; + +use crate::LocalPlayer; + +/// Tell the server that we're respawning. +#[derive(Debug, Clone)] +pub struct PerformRespawnEvent { + pub entity: Entity, +} + +/// A plugin that makes [`PerformRespawnEvent`] send the packet to respawn. +pub struct RespawnPlugin; +impl Plugin for RespawnPlugin { + fn build(&self, app: &mut App) { + app.add_event::<PerformRespawnEvent>() + .add_system(perform_respawn); + } +} + +pub fn perform_respawn( + mut events: EventReader<PerformRespawnEvent>, + mut query: Query<&mut LocalPlayer>, +) { + for event in events.iter() { + if let Ok(local_player) = query.get_mut(event.entity) { + local_player.write_packet( + ServerboundClientCommandPacket { + action: serverbound_client_command_packet::Action::PerformRespawn, + } + .get(), + ); + } + } +} diff --git a/azalea-inventory/src/item/mod.rs b/azalea-inventory/src/item/mod.rs index 07e51363..0ad7b2c0 100644 --- a/azalea-inventory/src/item/mod.rs +++ b/azalea-inventory/src/item/mod.rs @@ -3,6 +3,8 @@ pub trait MaxStackSizeExt { /// /// This is a signed integer to be consistent with the `count` field of /// [`ItemSlotData`]. + /// + /// [`ItemSlotData`]: crate::ItemSlotData fn max_stack_size(&self) -> i8; /// Whether this item can be stacked with other items. diff --git a/azalea-nbt/src/serde/mod.rs b/azalea-nbt/src/serde/mod.rs new file mode 100644 index 00000000..21d53a0f --- /dev/null +++ b/azalea-nbt/src/serde/mod.rs @@ -0,0 +1 @@ +mod serializer; diff --git a/azalea-nbt/src/serde/serializer.rs b/azalea-nbt/src/serde/serializer.rs new file mode 100644 index 00000000..945d2b42 --- /dev/null +++ b/azalea-nbt/src/serde/serializer.rs @@ -0,0 +1,205 @@ +use serde::{ser, Serialize}; + +use crate::Nbt; + +use std; +use std::fmt::{self, Display}; + +use serde::de; + +pub type Result<T> = std::result::Result<T, Error>; + +// This is a bare-bones implementation. A real library would provide additional +// information in its error type, for example the line and column at which the +// error occurred, the byte offset into the input, or the current key being +// processed. +#[derive(Debug)] +pub enum Error { + Message(String), +} + +impl Display for Error { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + match self { + Error::Message(msg) => formatter.write_str(msg), + } + } +} + +impl ser::Error for Error { + fn custom<T: Display>(msg: T) -> Self { + Error::Message(msg.to_string()) + } +} + +impl de::Error for Error { + fn custom<T: Display>(msg: T) -> Self { + Error::Message(msg.to_string()) + } +} + +impl std::error::Error for Error {} + +impl<'a> ser::Serializer for &'a mut Nbt { + type Ok = (); + + type Error = Error; + + type SerializeSeq = Self; + + type SerializeTuple = Self; + + type SerializeTupleStruct = Self; + + type SerializeTupleVariant = Self; + + type SerializeMap = Self; + + type SerializeStruct = Self; + + type SerializeStructVariant = Self; + + fn serialize_bool(self, v: bool) -> Result<()> { + todo!() + } + + fn serialize_i8(self, v: i8) -> Result<()> { + todo!() + } + + fn serialize_i16(self, v: i16) -> Result<()> { + todo!() + } + + fn serialize_i32(self, v: i32) -> Result<()> { + todo!() + } + + fn serialize_i64(self, v: i64) -> Result<()> { + todo!() + } + + fn serialize_u8(self, v: u8) -> Result<()> { + todo!() + } + + fn serialize_u16(self, v: u16) -> Result<()> { + todo!() + } + + fn serialize_u32(self, v: u32) -> Result<()> { + todo!() + } + + fn serialize_u64(self, v: u64) -> Result<()> { + todo!() + } + + fn serialize_f32(self, v: f32) -> Result<()> { + todo!() + } + + fn serialize_f64(self, v: f64) -> Result<()> { + todo!() + } + + fn serialize_char(self, v: char) -> Result<()> { + todo!() + } + + fn serialize_str(self, v: &str) -> Result<()> { + todo!() + } + + fn serialize_bytes(self, v: &[u8]) -> Result<()> { + todo!() + } + + fn serialize_none(self) -> Result<()> { + todo!() + } + + fn serialize_some<T: ?Sized>(self, value: &T) -> Result<()> + where + T: Serialize, + { + todo!() + } + + fn serialize_unit(self) -> Result<()> { + todo!() + } + + fn serialize_unit_struct(self, name: &'static str) -> Result<()> { + todo!() + } + + fn serialize_unit_variant( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + ) -> Result<()> { + todo!() + } + + fn serialize_newtype_struct<T: ?Sized>(self, name: &'static str, value: &T) -> Result<()> + where + T: Serialize, + { + todo!() + } + + fn serialize_newtype_variant<T: ?Sized>( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + value: &T, + ) -> Result<()> + where + T: Serialize, + { + todo!() + } + + fn serialize_seq(self, len: Option<usize>) -> Result<()> { + todo!() + } + + fn serialize_tuple(self, len: usize) -> Result<()> { + todo!() + } + + fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<()> { + todo!() + } + + fn serialize_tuple_variant( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + len: usize, + ) -> Result<()> { + todo!() + } + + fn serialize_map(self, len: Option<usize>) -> Result<()> { + todo!() + } + + fn serialize_struct(self, name: &'static str, len: usize) -> Result<()> { + todo!() + } + + fn serialize_struct_variant( + self, + name: &'static str, + variant_index: u32, + variant: &'static str, + len: usize, + ) -> Result<()> { + todo!() + } +} diff --git a/azalea/Cargo.toml b/azalea/Cargo.toml index 5dbc7556..4a7469d3 100644 --- a/azalea/Cargo.toml +++ b/azalea/Cargo.toml @@ -24,6 +24,7 @@ azalea-protocol = { version = "0.6.0", path = "../azalea-protocol" } azalea-registry = { version = "0.6.0", path = "../azalea-registry" } azalea-world = { version = "0.6.0", path = "../azalea-world" } azalea-auth = { version = "0.6.0", path = "../azalea-auth" } +azalea-brigadier = { version = "0.6.0", path = "../azalea-brigadier" } bevy_app = "0.10.0" bevy_ecs = "0.10.0" bevy_tasks = "0.10.0" diff --git a/azalea/examples/testbot.rs b/azalea/examples/testbot.rs index 3fe9253c..1774d005 100644 --- a/azalea/examples/testbot.rs +++ b/azalea/examples/testbot.rs @@ -8,10 +8,9 @@ use azalea::entity::{EyeHeight, Position}; use azalea::interact::HitResultComponent; use azalea::inventory::ItemSlot; use azalea::pathfinder::BlockPosGoal; +use azalea::protocol::packets::game::ClientboundGamePacket; use azalea::{prelude::*, swarm::prelude::*, BlockPos, GameProfileComponent, WalkDirection}; use azalea::{Account, Client, Event}; -use azalea_protocol::packets::game::serverbound_client_command_packet::ServerboundClientCommandPacket; -use azalea_protocol::packets::game::ClientboundGamePacket; use std::time::Duration; #[derive(Default, Clone, Component)] @@ -212,11 +211,6 @@ async fn handle(mut bot: Client, event: Event, _state: State) -> anyhow::Result< } } } - Event::Death(_) => { - bot.write_packet(ServerboundClientCommandPacket { - action: azalea_protocol::packets::game::serverbound_client_command_packet::Action::PerformRespawn, - }.get()); - } Event::Packet(packet) => match *packet { ClientboundGamePacket::Login(_) => { println!("login packet"); diff --git a/azalea/src/auto_respawn.rs b/azalea/src/auto_respawn.rs new file mode 100644 index 00000000..c5dd12a4 --- /dev/null +++ b/azalea/src/auto_respawn.rs @@ -0,0 +1,24 @@ +use crate::app::{App, Plugin}; +use azalea_client::packet_handling::DeathEvent; +use azalea_client::respawn::PerformRespawnEvent; +use bevy_ecs::prelude::*; + +/// A plugin that makes [`DeathEvent`]s send [`PerformRespawnEvent`]s. +#[derive(Clone, Default)] +pub struct AutoRespawnPlugin; +impl Plugin for AutoRespawnPlugin { + fn build(&self, app: &mut App) { + app.add_system(auto_respawn); + } +} + +fn auto_respawn( + mut events: EventReader<DeathEvent>, + mut perform_respawn_events: EventWriter<PerformRespawnEvent>, +) { + for event in events.iter() { + perform_respawn_events.send(PerformRespawnEvent { + entity: event.entity, + }); + } +} diff --git a/azalea/src/bot.rs b/azalea/src/bot.rs index e5ea4c28..13b33bb0 100644 --- a/azalea/src/bot.rs +++ b/azalea/src/bot.rs @@ -1,4 +1,5 @@ use crate::app::{App, CoreSchedule, IntoSystemAppConfig, Plugin, PluginGroup, PluginGroupBuilder}; +use crate::auto_respawn::AutoRespawnPlugin; use crate::container::ContainerPlugin; use crate::ecs::{ component::Component, @@ -135,5 +136,6 @@ impl PluginGroup for DefaultBotPlugins { .add(BotPlugin) .add(PathfinderPlugin) .add(ContainerPlugin) + .add(AutoRespawnPlugin) } } diff --git a/azalea/src/container.rs b/azalea/src/container.rs index 0016caad..fefcf189 100644 --- a/azalea/src/container.rs +++ b/azalea/src/container.rs @@ -21,10 +21,12 @@ impl Plugin for ContainerPlugin { pub trait ContainerClientExt { async fn open_container(&mut self, pos: BlockPos) -> Option<ContainerHandle>; + fn open_inventory(&mut self) -> Option<ContainerHandle>; } impl ContainerClientExt for Client { - /// Open a container in the world, like a chest. + /// Open a container in the world, like a chest. Use + /// [`Client::open_inventory`] to open your own inventory. /// /// ``` /// # use azalea::prelude::*; @@ -72,12 +74,36 @@ impl ContainerClientExt for Client { }) } } + + /// Open the player's inventory. This will return None if another + /// container is open. + /// + /// Note that this will send a packet to the server once it's dropped. Also, + /// due to how it's implemented, you could call this function multiple times + /// while another inventory handle already exists (but you shouldn't). + fn open_inventory(&mut self) -> Option<ContainerHandle> { + let ecs = self.ecs.lock(); + let inventory = ecs + .get::<InventoryComponent>(self.entity) + .expect("no inventory"); + + if inventory.id == 0 { + Some(ContainerHandle { + id: 0, + client: self.clone(), + }) + } else { + None + } + } } /// A handle to the open container. The container will be closed once this is /// dropped. pub struct ContainerHandle { - pub id: u8, + /// The id of the container. If this is 0, that means it's the player's + /// inventory. + id: u8, client: Client, } impl Drop for ContainerHandle { @@ -96,6 +122,13 @@ impl Debug for ContainerHandle { } } impl ContainerHandle { + /// Get the id of the container. If this is 0, that means it's the player's + /// inventory. Otherwise, the number isn't really meaningful since only one + /// container can be open at a time. + pub fn id(&self) -> u8 { + self.id + } + /// Returns the menu of the container. If the container is closed, this /// will return `None`. pub fn menu(&self) -> Option<Menu> { @@ -103,8 +136,14 @@ impl ContainerHandle { let inventory = ecs .get::<InventoryComponent>(self.client.entity) .expect("no inventory"); + + // this also makes sure we can't access the inventory while a container is open if inventory.id == self.id { - Some(inventory.container_menu.clone().unwrap()) + if self.id == 0 { + Some(inventory.inventory_menu.clone()) + } else { + Some(inventory.container_menu.clone().unwrap()) + } } else { None } diff --git a/azalea/src/lib.rs b/azalea/src/lib.rs index 2e8e4fa1..604961f4 100644 --- a/azalea/src/lib.rs +++ b/azalea/src/lib.rs @@ -3,6 +3,7 @@ #![allow(incomplete_features)] #![feature(async_fn_in_trait)] +mod auto_respawn; mod bot; mod container; pub mod pathfinder; @@ -12,6 +13,7 @@ pub mod swarm; use app::{App, Plugin, PluginGroup}; pub use azalea_auth as auth; pub use azalea_block as blocks; +pub use azalea_brigadier as brigadier; pub use azalea_client::*; pub use azalea_core::{BlockPos, Vec3}; pub use azalea_protocol as protocol; diff --git a/azalea/src/pathfinder/astar.rs b/azalea/src/pathfinder/astar.rs new file mode 100644 index 00000000..65caf337 --- /dev/null +++ b/azalea/src/pathfinder/astar.rs @@ -0,0 +1,111 @@ +use std::{cmp::Reverse, collections::HashMap, fmt::Debug, hash::Hash, ops::Add}; + +use priority_queue::PriorityQueue; + +pub fn a_star<N, W, HeuristicFn, SuccessorsFn, SuccessFn>( + start: N, + heuristic: HeuristicFn, + successors: SuccessorsFn, + success: SuccessFn, +) -> Option<Vec<N>> +where + N: Eq + Hash + Copy + Debug, + W: PartialOrd + Default + Copy + num_traits::Bounded + Debug + Add<Output = W>, + HeuristicFn: Fn(&N) -> W, + SuccessorsFn: Fn(&N) -> Vec<Edge<N, W>>, + SuccessFn: Fn(&N) -> bool, +{ + let mut open_set = PriorityQueue::new(); + open_set.push(start, Reverse(Weight(W::default()))); + let mut nodes: HashMap<N, Node<N, W>> = HashMap::new(); + nodes.insert( + start, + Node { + data: start, + came_from: None, + g_score: W::default(), + f_score: W::max_value(), + }, + ); + + while let Some((current_node, _)) = open_set.pop() { + if success(¤t_node) { + return Some(reconstruct_path(&nodes, current_node)); + } + + let current_g_score = nodes + .get(¤t_node) + .map(|n| n.g_score) + .unwrap_or(W::max_value()); + + for neighbor in successors(¤t_node) { + let tentative_g_score = current_g_score + neighbor.cost; + let neighbor_g_score = nodes + .get(&neighbor.target) + .map(|n| n.g_score) + .unwrap_or(W::max_value()); + if tentative_g_score < neighbor_g_score { + let f_score = tentative_g_score + heuristic(&neighbor.target); + nodes.insert( + neighbor.target, + Node { + data: neighbor.target, + came_from: Some(current_node), + g_score: tentative_g_score, + f_score, + }, + ); + open_set.push(neighbor.target, Reverse(Weight(f_score))); + } + } + } + + None +} + +fn reconstruct_path<N, W>(nodes: &HashMap<N, Node<N, W>>, current: N) -> Vec<N> +where + N: Eq + Hash + Copy + Debug, + W: PartialOrd + Default + Copy + num_traits::Bounded + Debug, +{ + let mut path = vec![current]; + let mut current = current; + while let Some(node) = nodes.get(¤t) { + if let Some(came_from) = node.came_from { + path.push(came_from); + current = came_from; + } else { + break; + } + } + path.reverse(); + path +} + +pub struct Node<N, W> { + pub data: N, + pub came_from: Option<N>, + pub g_score: W, + pub f_score: W, +} + +pub struct Edge<N: Eq + Hash + Copy, W: PartialOrd + Copy> { + pub target: N, + pub cost: W, +} + +#[derive(PartialEq)] +pub struct Weight<W: PartialOrd + Debug>(W); +impl<W: PartialOrd + Debug> Ord for Weight<W> { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + self.0 + .partial_cmp(&other.0) + .unwrap_or(std::cmp::Ordering::Equal) + } +} +impl<W: PartialOrd + Debug> Eq for Weight<W> {} +impl<W: PartialOrd + Debug> PartialOrd for Weight<W> { + fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> { + self.0.partial_cmp(&other.0) + } +} diff --git a/azalea/src/pathfinder/mod.rs b/azalea/src/pathfinder/mod.rs index 56c8e0ce..3f978c95 100644 --- a/azalea/src/pathfinder/mod.rs +++ b/azalea/src/pathfinder/mod.rs @@ -1,7 +1,8 @@ +mod astar; mod moves; -mod mtdstarlite; use crate::bot::{JumpEvent, LookAtEvent}; +use crate::pathfinder::astar::a_star; use crate::{SprintDirection, WalkDirection}; use crate::app::{App, CoreSchedule, IntoSystemAppConfig, Plugin}; @@ -13,6 +14,7 @@ use crate::ecs::{ schedule::IntoSystemConfig, system::{Commands, Query, Res}, }; +use astar::Edge; use azalea_client::{StartSprintEvent, StartWalkEvent}; use azalea_core::{BlockPos, CardinalDirection}; use azalea_physics::PhysicsSet; @@ -25,8 +27,6 @@ use azalea_world::{ use bevy_tasks::{AsyncComputeTaskPool, Task}; use futures_lite::future; use log::{debug, error}; -use mtdstarlite::Edge; -pub use mtdstarlite::MTDStarLite; use std::collections::VecDeque; use std::sync::Arc; @@ -152,17 +152,22 @@ fn goto_listener( edges }; - let mut pf = MTDStarLite::new( + // let mut pf = MTDStarLite::new( + // start, + // end, + // |n| goal.heuristic(n), + // successors, + // successors, + // |n| goal.success(n), + // ); + + let start_time = std::time::Instant::now(); + let p = a_star( start, - end, |n| goal.heuristic(n), successors, - successors, |n| goal.success(n), ); - - let start_time = std::time::Instant::now(); - let p = pf.find_path(); let end_time = std::time::Instant::now(); debug!("path: {p:?}"); debug!("time: {:?}", end_time - start_time); diff --git a/azalea/src/pathfinder/mtdstarlite.rs b/azalea/src/pathfinder/mtdstarlite.rs deleted file mode 100644 index ce463279..00000000 --- a/azalea/src/pathfinder/mtdstarlite.rs +++ /dev/null @@ -1,454 +0,0 @@ -//! An implementation of Moving Target D* Lite as described in -//! <http://idm-lab.org/bib/abstracts/papers/aamas10a.pdf> -//! -//! Future optimization attempt ideas: -//! - Use a different priority queue (e.g. fibonacci heap) -//! - Use `FxHash` instead of the default hasher -//! - Have `par` be a raw pointer -//! - Try borrowing vs copying the Node in several places (like `state_mut`) -//! - Store edge costs in their own map - -use priority_queue::DoublePriorityQueue; -use std::{collections::HashMap, fmt::Debug, hash::Hash, ops::Add}; - -/// Nodes are coordinates. -pub struct MTDStarLite< - N: Eq + Hash + Copy + Debug, - W: PartialOrd + Default + Copy + num_traits::Bounded + Debug, - HeuristicFn: Fn(&N) -> W, - SuccessorsFn: Fn(&N) -> Vec<Edge<N, W>>, - PredecessorsFn: Fn(&N) -> Vec<Edge<N, W>>, - SuccessFn: Fn(&N) -> bool, -> { - /// Returns a rough estimate of how close we are to the goal. Lower = - /// closer. - pub heuristic: HeuristicFn, - /// Returns the nodes that can be reached from the given node. - pub successors: SuccessorsFn, - /// Returns the nodes that would direct us to the given node. If the graph - /// isn't directed (i.e. you can always return to the previous node), this - /// can be the same as `successors`. - pub predecessors: PredecessorsFn, - /// Returns true if the given node is at the goal. - /// A simple implementation is to check if the given node is equal to the - /// goal. - pub success: SuccessFn, - - start: N, - goal: N, - - old_start: N, - old_goal: N, - - k_m: W, - open: DoublePriorityQueue<N, Priority<W>>, - node_states: HashMap<N, NodeState<N, W>>, - updated_edge_costs: Vec<ChangedEdge<N, W>>, - - /// This only exists so it can be referenced by `state()` when there's no - /// state. - default_state: NodeState<N, W>, -} - -impl< - N: Eq + Hash + Copy + Debug, - W: PartialOrd + Add<Output = W> + Default + Copy + num_traits::Bounded + Debug, - HeuristicFn: Fn(&N) -> W, - SuccessorsFn: Fn(&N) -> Vec<Edge<N, W>>, - PredecessorsFn: Fn(&N) -> Vec<Edge<N, W>>, - SuccessFn: Fn(&N) -> bool, - > MTDStarLite<N, W, HeuristicFn, SuccessorsFn, PredecessorsFn, SuccessFn> -{ - fn calculate_key(&self, n: &N) -> Priority<W> { - let s = self.state(n); - let min_score = if s.g < s.rhs { s.g } else { s.rhs }; - Priority( - if min_score == W::max_value() { - min_score - } else { - min_score + (self.heuristic)(n) + self.k_m - }, - min_score, - ) - } - - pub fn new( - start: N, - goal: N, - heuristic: HeuristicFn, - successors: SuccessorsFn, - predecessors: PredecessorsFn, - success: SuccessFn, - ) -> Self { - let open = DoublePriorityQueue::default(); - let k_m = W::default(); - - let known_nodes = vec![start, goal]; - - let mut pf = MTDStarLite { - heuristic, - successors, - predecessors, - success, - - start, - goal, - - old_start: start, - old_goal: goal, - - k_m, - open, - node_states: HashMap::new(), - updated_edge_costs: Vec::new(), - - default_state: NodeState::default(), - }; - - for n in &known_nodes { - *pf.state_mut(n) = NodeState::default(); - } - pf.state_mut(&start).rhs = W::default(); - pf.open.push(start, pf.calculate_key(&start)); - - pf - } - - fn update_state(&mut self, n: &N) { - let u = self.state_mut(n); - if u.g != u.rhs { - if self.open.get(n).is_some() { - self.open.change_priority(n, self.calculate_key(n)); - } else { - self.open.push(*n, self.calculate_key(n)); - } - } else if self.open.get(n).is_some() { - self.open.remove(n); - } - } - - fn compute_cost_minimal_path(&mut self) { - while { - if let Some((_, top_key)) = self.open.peek_min() { - (top_key < &self.calculate_key(&self.goal)) || { - let goal_state = self.state(&self.goal); - goal_state.rhs > goal_state.g - } - } else { - false - } - } { - let (u_node, k_old) = self.open.pop_min().unwrap(); - let k_new = self.calculate_key(&u_node); - if k_old < k_new { - self.open.change_priority(&u_node, k_new); - continue; - } - let u = self.state_mut(&u_node); - if u.g > u.rhs { - u.g = u.rhs; - self.open.remove(&u_node); - for edge in (self.successors)(&u_node) { - let s_node = edge.target; - let s = self.state(&s_node); - let u = self.state(&u_node); - if s_node != self.start && (s.rhs > u.g + edge.cost) { - let s_rhs = u.g + edge.cost; - let s = self.state_mut(&s_node); - s.par = Some(u_node); - s.rhs = s_rhs; - self.update_state(&s_node); - } - } - } else { - u.g = W::max_value(); - let u_edge = Edge { - target: u_node, - cost: W::default(), - }; - for edge in (self.successors)(&u_node) - .iter() - .chain([&u_edge].into_iter()) - { - let s_node = edge.target; - let s = self.state(&s_node); - if s_node != self.start && s.par == Some(u_node) { - let mut min_pred = u_node; - let mut min_score = W::max_value(); - - for edge in (self.predecessors)(&s_node) { - let s = self.state(&edge.target); - let score = s.g + edge.cost; - if score < min_score { - min_score = score; - min_pred = edge.target; - } - } - - let s = self.state_mut(&s_node); - s.rhs = min_score; - if s.rhs == W::max_value() { - s.par = None; - } else { - s.par = Some(min_pred); - } - } - self.update_state(&s_node); - } - } - } - } - - pub fn find_path(&mut self) -> Option<Vec<N>> { - if (self.success)(&self.start) { - return None; - } - - // - self.k_m = self.k_m + (self.heuristic)(&self.old_goal); - - if self.old_start != self.start { - self.optimized_deletion(); - } - - while let Some(edge) = self.updated_edge_costs.pop() { - let (u_node, v_node) = (edge.predecessor, edge.successor); - // update the edge cost c(u, v); - if edge.old_cost > edge.cost { - let u_g = self.state(&u_node).g; - if v_node != self.start && self.state(&v_node).rhs > u_g + edge.cost { - let v = self.state_mut(&v_node); - v.par = Some(u_node); - v.rhs = u_g + edge.cost; - } - } else if v_node != self.start && self.state(&v_node).par == Some(u_node) { - let mut min_pred = u_node; - let mut min_score = W::max_value(); - - for edge in (self.predecessors)(&v_node) { - let s = self.state(&edge.target); - let score = s.g + edge.cost; - if score < min_score { - min_score = score; - min_pred = edge.target; - } - } - - let v = self.state_mut(&v_node); - v.rhs = min_score; - if v.rhs == W::max_value() { - v.par = None; - } else { - v.par = Some(min_pred); - } - self.update_state(&v_node); - } - } - // - - self.old_start = self.start; - self.old_goal = self.goal; - - self.compute_cost_minimal_path(); - if self.state(&self.goal).rhs == W::max_value() { - // no path exists - return None; - } - - let mut reverse_path = vec![self.goal]; - - // identify a path from sstart to sgoal using the parent pointers - let mut target = self.state(&self.goal).par; - while !(Some(self.start) == target) { - let Some(this_target) = target else { - break; - }; - // hunter follows path from start to goal; - reverse_path.push(this_target); - target = self.state(&this_target).par; - } - - // if hunter caught target { - // return None; - // } - - let path: Vec<N> = reverse_path.into_iter().rev().collect(); - - Some(path) - } - - fn optimized_deletion(&mut self) { - let start = self.start; - self.state_mut(&start).par = None; - - let mut min_pred = self.old_start; - let mut min_score = W::max_value(); - - for edge in (self.predecessors)(&self.old_start) { - let s = self.state(&edge.target); - let score = s.g + edge.cost; - if score < min_score { - min_score = score; - min_pred = edge.target; - } - } - - let old_start = self.old_start; - let s = self.state_mut(&old_start); - s.rhs = min_score; - if s.rhs == W::max_value() { - s.par = None; - } else { - s.par = Some(min_pred); - } - self.update_state(&old_start); - } - - fn state(&self, n: &N) -> &NodeState<N, W> { - self.node_states.get(n).unwrap_or(&self.default_state) - } - - fn state_mut(&mut self, n: &N) -> &mut NodeState<N, W> { - self.node_states.entry(*n).or_default() - } -} - -#[derive(PartialEq, Debug)] -pub struct Priority<W>(W, W) -where - W: PartialOrd + Debug; - -impl<W: PartialOrd + Debug> PartialOrd for Priority<W> { - fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> { - if self.0 < other.0 { - Some(std::cmp::Ordering::Less) - } else if self.0 > other.0 { - Some(std::cmp::Ordering::Greater) - } else if self.1 < other.1 { - Some(std::cmp::Ordering::Less) - } else if self.1 > other.1 { - Some(std::cmp::Ordering::Greater) - } else { - Some(std::cmp::Ordering::Equal) - } - } -} -impl<W: PartialOrd + Debug> Ord for Priority<W> { - fn cmp(&self, other: &Self) -> std::cmp::Ordering { - self.partial_cmp(other) - .expect("Partial compare should not fail for Priority") - } -} -impl<W: PartialOrd + Debug> Eq for Priority<W> {} - -#[derive(Debug)] -pub struct NodeState<N: Eq + Hash + Copy + Debug, W: Default + num_traits::Bounded + Debug> { - pub g: W, - pub rhs: W, - // future possible optimization: try making this a pointer - pub par: Option<N>, -} - -impl<N: Eq + Hash + Copy + Debug, W: Default + num_traits::Bounded + Debug> Default - for NodeState<N, W> -{ - fn default() -> Self { - NodeState { - g: W::max_value(), - rhs: W::max_value(), - par: None, - } - } -} - -pub struct Edge<N: Eq + Hash + Copy, W: PartialOrd + Copy> { - pub target: N, - pub cost: W, -} - -pub struct ChangedEdge<N: Eq + Hash + Clone, W: PartialOrd + Copy> { - pub predecessor: N, - pub successor: N, - pub old_cost: W, - pub cost: W, -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_mtdstarlite() { - let maze = [ - [0, 1, 0, 0, 0], - [0, 1, 0, 1, 0], - [0, 0, 0, 1, 0], - [0, 1, 0, 1, 0], - [0, 0, 1, 0, 0], - ]; - let width = maze[0].len(); - let height = maze.len(); - - let goal = (4, 4); - - let heuristic = |n: &(usize, usize)| -> usize { - ((n.0 as isize - goal.0 as isize).abs() + (n.1 as isize - goal.1 as isize).abs()) - as usize - }; - let successors = |n: &(usize, usize)| -> Vec<Edge<(usize, usize), usize>> { - let mut successors = Vec::with_capacity(4); - let (x, y) = *n; - - if x > 0 && maze[y][x - 1] == 0 { - successors.push(Edge { - target: ((x - 1, y)), - cost: 1, - }); - } - if x < width - 1 && maze[y][x + 1] == 0 { - successors.push(Edge { - target: ((x + 1, y)), - cost: 1, - }); - } - if y > 0 && maze[y - 1][x] == 0 { - successors.push(Edge { - target: ((x, y - 1)), - cost: 1, - }); - } - if y < height - 1 && maze[y + 1][x] == 0 { - successors.push(Edge { - target: ((x, y + 1)), - cost: 1, - }); - } - - successors - }; - let predecessors = - |n: &(usize, usize)| -> Vec<Edge<(usize, usize), usize>> { successors(n) }; - - let mut pf = MTDStarLite::new((0, 0), goal, heuristic, successors, predecessors, |n| { - n == &goal - }); - let path = pf.find_path().unwrap(); - assert_eq!( - path, - vec![ - (0, 1), - (0, 2), - (1, 2), - (2, 2), - (2, 1), - (2, 0), - (3, 0), - (4, 0), - (4, 1), - (4, 2), - (4, 3), - (4, 4), - ] - ); - } -} |