Struct ClientBuilder

pub struct ClientBuilder<S, R>
where
    S: Default + Send + Sync + Clone + Component + 'static,
    R: Send + 'static,
    Self: Send,
{ /* private fields */ }

A builder for creating new Clients. This is the recommended way of making Azalea bots.

ClientBuilder::new()
    .set_handler(handle)
    .start(Account::offline("bot"), "localhost")
    .await;

Implementations

impl ClientBuilder<NoState, ()>

pub fn new() -> Self

Start building a client that can join the world.

pub fn new_without_plugins() -> Self

Self::new but without adding the plugins by default.

This is useful if you want to disable a default plugin. This also exists for swarms, see SwarmBuilder::new_without_plugins.

Note that you can also disable LogPlugin by disabling the log feature.

You must add DefaultPlugins and DefaultBotPlugins to this.

use azalea::app::PluginGroup;

let client_builder = ClientBuilder::new_without_plugins()
    .add_plugins(azalea::DefaultPlugins.build().disable::<azalea::chat_signing::ChatSigningPlugin>())
    .add_plugins(azalea::DefaultBotPlugins);

pub fn set_handler<S, Fut, R>( self, handler: HandleFn<S, Fut>, ) -> ClientBuilder<S, R>

where S: Default + Send + Sync + Clone + Component + 'static, Fut: Future<Output = R> + Send + 'static, R: Send + '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 client handler.

Note that if you’re creating clients directly from the ECS using StartJoinServerEvent and the client wasn’t already in the ECS, then the handler function won’t be called for that client. This shouldn’t be a concern for most bots, though.

client_builder.set_handler(handle);

async fn handle(mut bot: Client, event: Event, state: State) -> anyhow::Result<()> {
    Ok(())
}

impl<S, R> ClientBuilder<S, R>

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

pub fn set_state(self, state: S) -> Self

Set the client state instead of initializing defaults.

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

Add a group of plugins to the client.

See Self::new_without_plugins to learn how to disable default plugins.

pub fn reconnect_after(self, delay: impl Into<Option<Duration>>) -> Self

Configures the auto-reconnection behavior for our bot.

If this is Some, then it’ll set the default reconnection delay for our bot (how long it’ll wait after being kicked before it tries rejoining). if it’s None, then auto-reconnecting will be disabled.

If this function isn’t called, then our client will reconnect after DEFAULT_RECONNECT_DELAY.

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

Build this ClientBuilder into an actual Client and join the given server. If the client can’t join, it’ll keep retrying forever until it can.

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

Errors

This will error if the given address is invalid or couldn’t be resolved to a Minecraft server.

pub async fn start_with_opts( self, account: Account, address: impl TryInto<ServerAddress>, opts: JoinOpts, ) -> Result<!, StartError>

Do the same as Self::start, but allow passing in custom join options.

Trait Implementations

impl Default for ClientBuilder<NoState, ()>

fn default() -> Self

Returns the “default value” for a type.