Struct PathfinderOpts 

#[non_exhaustive]
pub struct PathfinderOpts { /* private fields */ }

Configuration options that the pathfinder will use when calculating and executing a path.

This can be passed into Client::goto_with_opts or Client::start_goto_with_opts.

// example config to disallow mining blocks and to not do parkour
let opts = PathfinderOpts::new()
    .allow_mining(false)
    .successors_fn(moves::basic::basic_move);

Implementations

impl PathfinderOpts

pub const fn new() -> Self

Examples found in repository

azalea/examples/testbot/main.rs (line 207)

async fn handle(bot: Client, event: azalea::Event, state: State) -> eyre::Result<()> {
    let swarm = bot.resource::<SwarmState>();

    match event {
        azalea::Event::Init => {
            bot.set_client_information(ClientInformation {
                view_distance: 32,
                ..Default::default()
            })?;
            if swarm.args.pathfinder_debug_particles {
                bot.ecs
                    .write()
                    .entity_mut(bot.entity)
                    .insert(PathfinderDebugParticles);
            }
        }
        azalea::Event::Chat(chat) => {
            let (Some(username), content) = chat.split_sender_and_content() else {
                return Ok(());
            };
            if username != swarm.args.owner_username {
                return Ok(());
            }

            println!("{:?}", chat.message());

            let command = if chat.is_whisper() {
                Some(content)
            } else {
                content.strip_prefix('!').map(|s| s.to_owned())
            };
            if let Some(command) = command {
                match swarm.commands.execute(
                    command,
                    Mutex::new(CommandSource {
                        bot: bot.clone(),
                        chat: chat.clone(),
                        state: state.clone(),
                    }),
                ) {
                    Ok(Ok(_)) => {}
                    Ok(Err(err)) => {
                        eprintln!("azalea error: {err:?}");
                        let command_source = CommandSource {
                            bot,
                            chat: chat.clone(),
                            state: state.clone(),
                        };
                        command_source.reply(format!("azalea error: {err:?}"));
                    }
                    Err(err) => {
                        eprintln!("{err:?}");
                        let command_source = CommandSource {
                            bot,
                            chat: chat.clone(),
                            state: state.clone(),
                        };
                        command_source.reply(format!("{err:?}"));
                    }
                }
            }
        }
        azalea::Event::Tick => {
            killaura::tick(bot.clone(), state.clone())?;

            if bot.ticks_connected().is_multiple_of(5) {
                if let Some(following) = &*state.following_entity.lock()
                    && following.is_alive()
                {
                    let goal = RadiusGoal::new(following.position()?, 3.);
                    if bot.is_calculating_path() {
                        // keep waiting
                    } else if !goal.success(bot.position()?.into()) || bot.is_executing_path() {
                        bot.start_goto_with_opts(
                            goal,
                            PathfinderOpts::new()
                                .retry_on_no_path(false)
                                .max_timeout(Duration::from_secs(1)),
                        );
                    } else {
                        following.look_at()?;
                    }
                }
            }
        }
        azalea::Event::Login => {
            println!("Got login event")
        }
        _ => {}
    }

    Ok(())
}

pub fn successors_fn(self, successors_fn: SuccessorsFn) -> Self

Set the function that’s used for checking what moves are possible.

Defaults to moves::default_move.

pub fn allow_mining(self, allow_mining: bool) -> Self

Set whether the bot is allowed to break blocks while pathfinding.

Defaults to true.

pub fn retry_on_no_path(self, retry_on_no_path: bool) -> Self

Whether we should recalculate the path when the pathfinder timed out and there’s no partial path to try.

Defaults to true.

Examples found in repository

azalea/examples/testbot/main.rs (line 208)

async fn handle(bot: Client, event: azalea::Event, state: State) -> eyre::Result<()> {
    let swarm = bot.resource::<SwarmState>();

    match event {
        azalea::Event::Init => {
            bot.set_client_information(ClientInformation {
                view_distance: 32,
                ..Default::default()
            })?;
            if swarm.args.pathfinder_debug_particles {
                bot.ecs
                    .write()
                    .entity_mut(bot.entity)
                    .insert(PathfinderDebugParticles);
            }
        }
        azalea::Event::Chat(chat) => {
            let (Some(username), content) = chat.split_sender_and_content() else {
                return Ok(());
            };
            if username != swarm.args.owner_username {
                return Ok(());
            }

            println!("{:?}", chat.message());

            let command = if chat.is_whisper() {
                Some(content)
            } else {
                content.strip_prefix('!').map(|s| s.to_owned())
            };
            if let Some(command) = command {
                match swarm.commands.execute(
                    command,
                    Mutex::new(CommandSource {
                        bot: bot.clone(),
                        chat: chat.clone(),
                        state: state.clone(),
                    }),
                ) {
                    Ok(Ok(_)) => {}
                    Ok(Err(err)) => {
                        eprintln!("azalea error: {err:?}");
                        let command_source = CommandSource {
                            bot,
                            chat: chat.clone(),
                            state: state.clone(),
                        };
                        command_source.reply(format!("azalea error: {err:?}"));
                    }
                    Err(err) => {
                        eprintln!("{err:?}");
                        let command_source = CommandSource {
                            bot,
                            chat: chat.clone(),
                            state: state.clone(),
                        };
                        command_source.reply(format!("{err:?}"));
                    }
                }
            }
        }
        azalea::Event::Tick => {
            killaura::tick(bot.clone(), state.clone())?;

            if bot.ticks_connected().is_multiple_of(5) {
                if let Some(following) = &*state.following_entity.lock()
                    && following.is_alive()
                {
                    let goal = RadiusGoal::new(following.position()?, 3.);
                    if bot.is_calculating_path() {
                        // keep waiting
                    } else if !goal.success(bot.position()?.into()) || bot.is_executing_path() {
                        bot.start_goto_with_opts(
                            goal,
                            PathfinderOpts::new()
                                .retry_on_no_path(false)
                                .max_timeout(Duration::from_secs(1)),
                        );
                    } else {
                        following.look_at()?;
                    }
                }
            }
        }
        azalea::Event::Login => {
            println!("Got login event")
        }
        _ => {}
    }

    Ok(())
}

pub fn min_timeout(self, min_timeout: impl Into<PathfinderTimeout>) -> Self

The minimum amount of time that should pass before the A* pathfinder function can return a timeout if it finds a path that seems good enough. It may take up to Self::max_timeout if it can’t immediately find a usable path.

Defaults to PathfinderTimeout::Time(Duration::from_secs(1)).

Also see PathfinderTimeout::Nodes

pub fn max_timeout(self, max_timeout: impl Into<PathfinderTimeout>) -> Self

The absolute maximum amount of time that the pathfinder function can take to find a path.

If it takes this long, it means no usable path was found (so it might be impossible).

Defaults to PathfinderTimeout::Time(Duration::from_secs(5)).

Examples found in repository

azalea/examples/testbot/main.rs (line 209)

async fn handle(bot: Client, event: azalea::Event, state: State) -> eyre::Result<()> {
    let swarm = bot.resource::<SwarmState>();

    match event {
        azalea::Event::Init => {
            bot.set_client_information(ClientInformation {
                view_distance: 32,
                ..Default::default()
            })?;
            if swarm.args.pathfinder_debug_particles {
                bot.ecs
                    .write()
                    .entity_mut(bot.entity)
                    .insert(PathfinderDebugParticles);
            }
        }
        azalea::Event::Chat(chat) => {
            let (Some(username), content) = chat.split_sender_and_content() else {
                return Ok(());
            };
            if username != swarm.args.owner_username {
                return Ok(());
            }

            println!("{:?}", chat.message());

            let command = if chat.is_whisper() {
                Some(content)
            } else {
                content.strip_prefix('!').map(|s| s.to_owned())
            };
            if let Some(command) = command {
                match swarm.commands.execute(
                    command,
                    Mutex::new(CommandSource {
                        bot: bot.clone(),
                        chat: chat.clone(),
                        state: state.clone(),
                    }),
                ) {
                    Ok(Ok(_)) => {}
                    Ok(Err(err)) => {
                        eprintln!("azalea error: {err:?}");
                        let command_source = CommandSource {
                            bot,
                            chat: chat.clone(),
                            state: state.clone(),
                        };
                        command_source.reply(format!("azalea error: {err:?}"));
                    }
                    Err(err) => {
                        eprintln!("{err:?}");
                        let command_source = CommandSource {
                            bot,
                            chat: chat.clone(),
                            state: state.clone(),
                        };
                        command_source.reply(format!("{err:?}"));
                    }
                }
            }
        }
        azalea::Event::Tick => {
            killaura::tick(bot.clone(), state.clone())?;

            if bot.ticks_connected().is_multiple_of(5) {
                if let Some(following) = &*state.following_entity.lock()
                    && following.is_alive()
                {
                    let goal = RadiusGoal::new(following.position()?, 3.);
                    if bot.is_calculating_path() {
                        // keep waiting
                    } else if !goal.success(bot.position()?.into()) || bot.is_executing_path() {
                        bot.start_goto_with_opts(
                            goal,
                            PathfinderOpts::new()
                                .retry_on_no_path(false)
                                .max_timeout(Duration::from_secs(1)),
                        );
                    } else {
                        following.look_at()?;
                    }
                }
            }
        }
        azalea::Event::Login => {
            println!("Got login event")
        }
        _ => {}
    }

    Ok(())
}

Trait Implementations

impl Clone for PathfinderOpts

fn clone(&self) -> PathfinderOpts

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PathfinderOpts

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PathfinderOpts

fn default() -> Self

Returns the “default value” for a type.