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.

It can safely be cloned, so there should be no need to wrap them in a Mutex.

Swarms are created from SwarmBuilder.

Clients can be added to the swarm later via Swarm::add, and can be removed with Client::disconnect.

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(flavor = "current_thread")]
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::Chat(m) => {
            println!("{}", m.message().to_ansi());
        }
        _ => {}
    }
    Ok(())
}

pub async fn add<S: Component + Clone>( &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 error if the server’s address could not be resolved.

pub async fn add_with_opts<S: Component + Clone>( &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 error if the server’s address could not be resolved.

pub fn client_entities(&self) -> Box<[Entity]>

Get an array of ECS [Entity]s for all LocalEntitys in our world. This will include clients that were disconnected without being removed from the ECS.

Trait Implementations

impl Clone for Swarm

fn clone(&self) -> Swarm

Returns a duplicate 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,