Enum ChatPacket 

pub enum ChatPacket {
    System(Arc<ClientboundSystemChat>),
    Player(Arc<ClientboundPlayerChat>),
    Disguised(Arc<ClientboundDisguisedChat>),
}

A chat packet, either a system message or a chat message.

Variants

System(Arc<ClientboundSystemChat>)

Player(Arc<ClientboundPlayerChat>)

Disguised(Arc<ClientboundDisguisedChat>)

Implementations

impl ChatPacket

pub fn message(&self) -> FormattedText

Get the message shown in chat for this packet.

See Self::split_sender_and_content for more details about how this works.

Examples found in repository

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

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(())
}
async fn swarm_handle(_swarm: Swarm, event: SwarmEvent, _state: SwarmState) -> eyre::Result<()> {
    match &event {
        SwarmEvent::Disconnect(account, _join_opts) => {
            println!("bot got kicked! {}", account.username());
        }
        SwarmEvent::Chat(chat) => {
            if chat.message().to_string() == "The particle was not visible for anybody" {
                return Ok(());
            }
            println!("{}", chat.message().to_ansi());
        }
        _ => {}
    }

    Ok(())
}

pub fn split_sender_and_content(&self) -> (Option<String>, String)

A convenience function to determine the username of the sender and the content of a chat message.

This does not preserve formatting codes.

This function uses a few checks to attempt to split the chat message, and is intended to work on most servers. It won’t work for every server though, so in certain cases you may have to reimplement this yourself.

If it’s not a player-sent chat message or the sender couldn’t be determined, the username part will be None.

Also see Self::sender and Self::content if you only need one of the parts.

Examples found in repository

azalea/examples/echo.rs (line 21)

async fn handle(bot: Client, event: Event, _state: State) -> eyre::Result<()> {
    if let Event::Chat(m) = event
        && let (Some(sender), content) = m.split_sender_and_content()
    {
        if sender == bot.username() {
            // ignore our own messages
            return Ok(());
        }
        bot.chat(content);
    }

    Ok(())
}

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

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

pub fn sender(&self) -> Option<String>

Get the username of the sender of the message.

If it’s not a player-sent chat message or the sender couldn’t be determined, this will be None.

See Self::split_sender_and_content for more details about how this works.

Examples found in repository

azalea/examples/steal.rs (line 29)

async fn handle(bot: Client, event: Event, state: State) -> eyre::Result<()> {
    if let Event::Chat(m) = event {
        if m.sender() == Some(bot.username()) {
            return Ok(());
        };
        if m.content() != "go" {
            return Ok(());
        }

        steal(bot, state).await?;
    }

    Ok(())
}

azalea/examples/testbot/commands.rs (line 28)

    pub fn reply(&self, message: impl Into<String>) {
        let message = message.into();
        if self.chat.is_whisper() {
            // /msg instead of /w for compat with custom servers
            self.bot
                .chat(format!("/msg {} {message}", self.chat.sender().unwrap()));
        } else {
            self.bot.chat(message);
        }
    }

    pub fn entity(&self) -> Option<azalea::EntityRef> {
        let username = self.chat.sender()?;
        self.bot
            .any_entity_by::<&GameProfileComponent, With<Player>>(
                |profile: &GameProfileComponent| profile.name == username,
            )
    }

pub fn sender_uuid(&self) -> Option<Uuid>

Get the UUID of the sender of the message.

If it’s not a player-sent chat message, this will be None (this is sometimes the case when a server uses a plugin to modify chat messages).

pub fn content(&self) -> String

Get the content part of the message as a string.

This does not preserve formatting codes. If it’s not a player-sent chat message or the sender couldn’t be determined, this will contain the entire message.

Examples found in repository

azalea/examples/steal.rs (line 32)

async fn handle(bot: Client, event: Event, state: State) -> eyre::Result<()> {
    if let Event::Chat(m) = event {
        if m.sender() == Some(bot.username()) {
            return Ok(());
        };
        if m.content() != "go" {
            return Ok(());
        }

        steal(bot, state).await?;
    }

    Ok(())
}

pub fn new(message: &str) -> ChatPacket

Create a new ChatPacket from a string. This is meant to be used as a convenience function for testing.

pub fn is_whisper(&self) -> bool

Whether this message is an incoming whisper message (i.e. someone else messaged the bot with /msg).

This is not guaranteed to work correctly on custom servers.

Examples found in repository

azalea/examples/testbot/commands.rs (line 25)

    pub fn reply(&self, message: impl Into<String>) {
        let message = message.into();
        if self.chat.is_whisper() {
            // /msg instead of /w for compat with custom servers
            self.bot
                .chat(format!("/msg {} {message}", self.chat.sender().unwrap()));
        } else {
            self.bot.chat(message);
        }
    }

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

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 ChatPacket

fn clone(&self) -> ChatPacket

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ChatPacket

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

Formats the value using the given formatter.

impl PartialEq for ChatPacket

fn eq(&self, other: &ChatPacket) -> 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 StructuralPartialEq for ChatPacket