Struct SwarmBuilder

pub struct SwarmBuilder<S, SS>
where
    S: Send + Sync + Clone + Component + 'static,
    SS: Default + Send + Sync + Clone + Resource + 'static,
{ /* private fields */ }

Create a new Swarm.

Implementations

impl SwarmBuilder<NoState, NoSwarmState>

pub fn new() -> SwarmBuilder<NoState, NoSwarmState>

Start creating the swarm.

pub fn new_without_plugins() -> SwarmBuilder<NoState, NoSwarmState>

Self::new but without adding the plugins by default. This is useful if you want to disable a default plugin.

You must add DefaultPlugins, DefaultBotPlugins, and DefaultSwarmPlugins to this.

use azalea::{app::PluginGroup, DefaultBotPlugins, DefaultPlugins, swarm::{DefaultSwarmPlugins}};
use bevy_log::LogPlugin;

let swarm_builder = SwarmBuilder::new_without_plugins()
    .add_plugins(DefaultPlugins.build().disable::<LogPlugin>())
    .add_plugins(DefaultBotPlugins)
    .add_plugins(DefaultSwarmPlugins);

impl<SS> SwarmBuilder<NoState, SS>

where SS: Default + Send + Sync + Clone + Resource + 'static,

pub fn set_handler<S, Fut>( self, handler: HandleFn<S, Fut>, ) -> SwarmBuilder<S, SS>

where Fut: Future<Output = Result<(), Error>> + Send + 'static, S: Send + Sync + Clone + Component + Default + 'static,

Set the function that’s called every time a bot receives an Event. This is the way to handle normal per-bot events.

Currently you can have up to one handler.

swarm_builder.set_handler(handle);

#[derive(Component, Default, Clone)]
struct State {}
async fn handle(mut bot: Client, event: Event, state: State) -> anyhow::Result<()> {
    Ok(())
}

impl<S> SwarmBuilder<S, NoSwarmState>

where S: Send + Sync + Clone + Component + 'static,

pub fn set_swarm_handler<SS, Fut>( self, handler: SwarmHandleFn<SS, Fut>, ) -> SwarmBuilder<S, SS>

where SS: Default + Send + Sync + Clone + Resource + 'static, Fut: Future<Output = Result<(), Error>> + Send + 'static,

Set the function that’s called every time the swarm receives a SwarmEvent. This is the way to handle global swarm events.

Currently you can have up to one swarm handler.

swarm_builder.set_swarm_handler(swarm_handle);



#[derive(Resource, Default, Clone)]
struct SwarmState {}
async fn swarm_handle(
    mut swarm: Swarm,
    event: SwarmEvent,
    state: SwarmState,
) -> anyhow::Result<()> {
    Ok(())
}

impl<S, SS> SwarmBuilder<S, SS>

where S: Send + Sync + Clone + Component + 'static, SS: Default + Send + Sync + Clone + Resource + 'static,

pub fn add_accounts(self, accounts: Vec<Account>) -> Self

where S: Default,

Add a vec of Accounts to the swarm.

Use Self::add_account to only add one account. If you want the clients to have different default states, add them one at a time with Self::add_account_with_state.

By default every account will join at the same time, you can add a delay with Self::join_delay.

pub fn add_account(self, account: Account) -> Self

where S: Default,

Add a single new Account to the swarm. Use Self::add_accounts to add multiple accounts at a time.

This will make the state for this client be the default, use Self::add_account_with_state to avoid that.

pub fn add_account_with_state(self, account: Account, state: S) -> Self

Add an account with a custom initial state. Use just Self::add_account to use the Default implementation for the state.

pub fn add_account_with_state_and_opts( self, account: Account, state: S, join_opts: JoinOpts, ) -> Self

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

pub fn set_swarm_state(self, swarm_state: SS) -> Self

Set the swarm state instead of initializing defaults.

pub fn add_plugins<M>(self, plugins: impl Plugins<M>) -> Self

Add one or more plugins to this swarm.

pub fn join_delay(self, delay: Duration) -> Self

Set how long we should wait between each bot joining the server.

By default, every bot will connect at the same time. If you set this field, however, the bots will wait for the previous one to have connected and then they’ll wait the given duration.

pub async fn start( self, address: impl TryInto<ServerAddress>, ) -> Result<!, StartError>

Build this SwarmBuilder into an actual Swarm and join the given server.

The address argument can be a &str, ServerAddress, or anything that implements TryInto<ServerAddress>.

pub async fn start_with_default_opts( self, address: impl TryInto<ServerAddress>, default_join_opts: JoinOpts, ) -> Result<!, StartError>

Do the same as Self::start, but allow passing in default join options for the bots.

Trait Implementations

impl Default for SwarmBuilder<NoState, NoSwarmState>

fn default() -> Self

Returns the “default value” for a type.