Struct Swarm

pub struct Swarm {
    pub ecs_lock: Arc<Mutex<World>>,
    pub resolved_address: Arc<RwLock<SocketAddr>>,
    pub address: Arc<RwLock<ServerAddress>>,
    pub instance_container: Arc<RwLock<InstanceContainer>>,
    /* private fields */
}

A swarm is a way to conveniently control many bots at once, while also being able to control bots at an individual level when desired.

Swarms are created from SwarmBuilder.

The S type parameter is the type of the state for individual bots. It’s used to make the Swarm::add function work.

Fields

ecs_lock: Arc<Mutex<World>>

resolved_address: Arc<RwLock<SocketAddr>>

address: Arc<RwLock<ServerAddress>>

instance_container: Arc<RwLock<InstanceContainer>>

Implementations

impl Swarm

Make a bot Swarm.

Examples

use azalea::{prelude::*, swarm::prelude::*};
use std::time::Duration;

#[derive(Default, Clone, Component)]
struct State {}

#[derive(Default, Clone, Resource)]
struct SwarmState {}

#[tokio::main]
async fn main() {
    let mut accounts = Vec::new();
    let mut states = Vec::new();

    for i in 0..10 {
        accounts.push(Account::offline(&format!("bot{i}")));
        states.push(State::default());
    }

    SwarmBuilder::new()
        .add_accounts(accounts.clone())
        .set_handler(handle)
        .set_swarm_handler(swarm_handle)
        .join_delay(Duration::from_millis(1000))
        .start("localhost")
        .await
        .unwrap();
}

async fn handle(bot: Client, event: Event, _state: State) -> anyhow::Result<()> {
    match &event {
        _ => {}
    }
    Ok(())
}

async fn swarm_handle(
    mut swarm: Swarm,
    event: SwarmEvent,
    _state: SwarmState,
) -> anyhow::Result<()> {
    match &event {
        SwarmEvent::Disconnect(account, join_opts) => {
            // automatically reconnect after 5 seconds
            tokio::time::sleep(Duration::from_secs(5)).await;
            swarm.add_with_opts(account, State::default(), join_opts).await?;
        }
        SwarmEvent::Chat(m) => {
            println!("{}", m.message().to_ansi());
        }
        _ => {}
    }
    Ok(())
}

pub async fn add<S: Component + Clone>( &mut self, account: &Account, state: S, ) -> Result<Client, JoinError>

Add a new account to the swarm. You can remove it later by calling Client::disconnect.

Errors

Returns an Err if the bot could not do a handshake successfully.

pub async fn add_with_opts<S: Component + Clone>( &mut self, account: &Account, state: S, join_opts: &JoinOpts, ) -> Result<Client, JoinError>

Add a new account to the swarm, using custom options. This is useful if you want bots in the same swarm to connect to different addresses. Usually you’ll just want Self::add though.

Errors

Returns an Err if the bot could not do a handshake successfully.

pub async fn add_and_retry_forever<S: Component + Clone>( &mut self, account: &Account, state: S, ) -> Client

Add a new account to the swarm, retrying if it couldn’t join. This will run forever until the bot joins or the task is aborted.

This does exponential backoff (though very limited), starting at 5 seconds and doubling up to 15 seconds.

pub async fn add_and_retry_forever_with_opts<S: Component + Clone>( &mut self, account: &Account, state: S, opts: &JoinOpts, ) -> Client

Same as Self::add_and_retry_forever, but allow passing custom join options.

Trait Implementations

impl Clone for Swarm

fn clone(&self) -> Swarm

Returns a copy of the value.

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

Performs copy-assignment from source.

impl IntoIterator for Swarm

fn into_iter(self) -> Self::IntoIter

Iterate over the bots in this swarm.

#[derive(Component, Clone)]
for bot in swarm {
    let state = bot.component::<State>();
    // ...
}

type Item = Client

The type of the elements being iterated over.

type IntoIter = IntoIter<<Swarm as IntoIterator>::Item>

Which kind of iterator are we turning this into?

impl Resource for Swarm

where Self: Send + Sync + 'static,