Struct Account 

pub struct Account(/* private fields */);

Something that can join Minecraft servers.

By default, Azalea only supports either authentication with Microsoft (online-mode), or no authentication at all (offline-mode). If you’d like to do authentication in some other way, consider looking at AccountTrait.

To join a server using this account, you can either use StartJoinServerEvent or azalea::ClientBuilder.

Note that Account is also an ECS component that’s present on our client entities.

Examples

let account = Account::microsoft("[email protected]").await;
// or Account::offline("example");

Implementations

impl Account

pub async fn microsoft(cache_key: &str) -> Result<Self, AuthError>

This will create an online-mode account by authenticating with Microsoft’s servers.

The cache key is used for avoiding having to log in every time. This is typically set to the account email, but it can be any string.

Examples found in repository

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

async fn main() -> AppExit {
    let args = parse_args();

    thread::spawn(deadlock_detection_thread);

    let join_address = args.server.clone();

    let mut builder = SwarmBuilder::new()
        .set_handler(handle)
        .set_swarm_handler(swarm_handle);

    for username_or_email in &args.accounts {
        let account = if username_or_email.contains('@') {
            Account::microsoft(username_or_email).await.unwrap()
        } else {
            Account::offline(username_or_email)
        };

        builder = builder.add_account_with_state(account, State::new());
    }

    let mut commands = CommandDispatcher::new();
    register_commands(&mut commands);

    builder
        .join_delay(Duration::from_millis(100))
        .set_swarm_state(SwarmState {
            args,
            commands: Arc::new(commands),
        })
        .start(join_address)
        .await
}

pub async fn microsoft_with_custom_client_id_and_scope( cache_key: &str, client_id: Option<&str>, scope: Option<&str>, ) -> Result<Self, AuthError>

Similar to Account::microsoft but you can use your own client_id and scope.

Pass None if you want to use default ones.

pub async fn with_microsoft_access_token( msa: ExpiringValue<AccessTokenResponse>, ) -> Result<Self, AuthError>

This will create an online-mode account through azalea_auth::get_minecraft_token so you can have more control over the authentication process (like doing your own caching or displaying the Microsoft user code to the user in a different way).

This will refresh the given token if it’s expired.

let client = reqwest::Client::new();

let res = azalea_auth::get_ms_link_code(&client, None, None).await?;
// Or, `azalea_auth::get_ms_link_code(&client, Some(client_id), None).await?`
// if you want to use your own client_id
println!(
    "Go to {} and enter the code {}",
    res.verification_uri, res.user_code
);
let msa = azalea_auth::get_ms_auth_token(&client, res, None).await?;
Account::with_microsoft_access_token(msa).await?;

pub async fn with_microsoft_access_token_and_custom_client_id_and_scope( msa: ExpiringValue<AccessTokenResponse>, client_id: Option<&str>, scope: Option<&str>, ) -> Result<Self, AuthError>

Similar to Account::with_microsoft_access_token but you can use custom client_id and scope.

impl Account

pub fn offline(username: &str) -> Self

An offline account does not authenticate with Microsoft’s servers, and as such can only join offline mode servers.

This is useful for testing in LAN worlds.

Examples found in repository

azalea/examples/nearest_entity.rs (line 23)

async fn main() -> AppExit {
    let account = Account::offline("bot");

    ClientBuilder::new()
        .add_plugins(LookAtStuffPlugin)
        .start(account, "localhost")
        .await
}

azalea/examples/steal.rs (line 12)

async fn main() -> AppExit {
    let account = Account::offline("bot");
    // or let bot = Account::microsoft("email").await.unwrap();

    ClientBuilder::new()
        .set_handler(handle)
        .start(account, "localhost")
        .await
}

azalea/examples/echo.rs (line 7)

async fn main() -> AppExit {
    let account = Account::offline("bot");
    // or let account = Account::microsoft("email").await.unwrap();

    ClientBuilder::new()
        .set_handler(handle)
        .start(account, "localhost")
        .await
}

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

async fn main() -> AppExit {
    let args = parse_args();

    thread::spawn(deadlock_detection_thread);

    let join_address = args.server.clone();

    let mut builder = SwarmBuilder::new()
        .set_handler(handle)
        .set_swarm_handler(swarm_handle);

    for username_or_email in &args.accounts {
        let account = if username_or_email.contains('@') {
            Account::microsoft(username_or_email).await.unwrap()
        } else {
            Account::offline(username_or_email)
        };

        builder = builder.add_account_with_state(account, State::new());
    }

    let mut commands = CommandDispatcher::new();
    register_commands(&mut commands);

    builder
        .join_delay(Duration::from_millis(100))
        .set_swarm_state(SwarmState {
            args,
            commands: Arc::new(commands),
        })
        .start(join_address)
        .await
}

impl Account

pub fn uuid_or_offline(&self) -> Uuid

👎Deprecated: moved to uuid().

Trait Implementations

impl Clone for Account

fn clone(&self) -> Account

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for Account

where Self: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have [Component<Mutability = Mutable>], while immutable components will instead have [Component<Mutability = Immutable>].

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add [ComponentHook] for this [Component] if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert [ComponentHook] for this [Component] if one is defined.

fn on_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_replace [ComponentHook] for this [Component] if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove [ComponentHook] for this [Component] if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn [ComponentHook] for this [Component] if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given [EntityMapper]. This is used to remap entities in contexts like scenes and entity cloning. When deriving [Component], this is populated by annotating fields containing entities with #[entities]

impl Debug for Account

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

Formats the value using the given formatter.

impl Deref for Account

type Target = dyn AccountTrait

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: AccountTrait + 'static> From<T> for Account

fn from(value: T) -> Self

Converts to this type from the input type.