Struct RadiusGoal 

pub struct RadiusGoal {
    pub pos: Vec3,
    pub radius: f32,
}

Get within the given radius of the given position.

Fields

pos: Vec3

radius: f32

Implementations

impl RadiusGoal

pub fn new(pos: Vec3, radius: f32) -> Self

Examples found in repository

azalea/examples/steal.rs (line 69)

async fn steal(bot: Client, state: State) -> eyre::Result<()> {
    {
        let mut is_stealing = state.is_stealing.lock();
        if *is_stealing {
            bot.chat("Already stealing");
            return Ok(());
        }
        *is_stealing = true;
    }

    state.checked_chests.lock().clear();

    loop {
        let chest_block = bot
            .world()
            .read()
            .find_blocks(bot.position(), &BlockKind::Chest.into())
            .find(
                // find the closest chest that hasn't been checked
                |block_pos| !state.checked_chests.lock().contains(block_pos),
            );
        let Some(chest_block) = chest_block else {
            break;
        };

        state.checked_chests.lock().push(chest_block);

        bot.goto(RadiusGoal::new(chest_block.center(), 3.)).await;

        let Some(chest) = bot.open_container_at(chest_block).await else {
            println!("Couldn't open chest at {chest_block:?}");
            continue;
        };

        println!("Getting contents of chest at {chest_block:?}");
        for (index, slot) in chest.contents().unwrap_or_default().iter().enumerate() {
            println!("Checking slot {index}: {slot:?}");
            let ItemStack::Present(item) = slot else {
                continue;
            };
            if item.kind == ItemKind::Diamond {
                println!("clicking slot ^");
                chest.left_click(index);
            }
        }
    }

    bot.chat("Done");

    *state.is_stealing.lock() = false;

    Ok(())
}

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

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(_) => {}
                    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 RadiusGoal

fn clone(&self) -> RadiusGoal

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RadiusGoal

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

Formats the value using the given formatter.

impl Default for RadiusGoal

fn default() -> RadiusGoal

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RadiusGoal

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Goal for RadiusGoal

fn heuristic(&self, n: BlockPos) -> f32

fn success(&self, n: BlockPos) -> bool

impl PartialEq for RadiusGoal

fn eq(&self, other: &RadiusGoal) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RadiusGoal

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for RadiusGoal

impl StructuralPartialEq for RadiusGoal