Struct Account 

pub struct Account {
    pub username: String,
    pub access_token: Option<Arc<Mutex<String>>>,
    pub uuid: Option<Uuid>,
    pub account_opts: AccountOpts,
    pub certs: Arc<Mutex<Option<Certificates>>>,
}

Something that can join Minecraft servers.

To join a server using this account, use Client::join or azalea::ClientBuilder.

This is also an ECS component that is present on our client entities.

Examples

let account = Account::microsoft("example@example.com").await;
// or Account::offline("example");

Fields

username: String

The Minecraft username of the account.

access_token: Option<Arc<Mutex<String>>>

The access token for authentication. You can obtain one of these manually from azalea-auth.

This is an Arc<Mutex> so it can be modified by Self::refresh.

uuid: Option<Uuid>

Only required for online-mode accounts.

account_opts: AccountOpts

The parameters (i.e. email) that were passed for creating this Account. This is used for automatic reauthentication when we get “Invalid Session” errors. If you don’t need that feature (like in offline mode), then you can set this to AuthOpts::default().

certs: Arc<Mutex<Option<Certificates>>>

The certificates used for chat signing.

This is set when you call Self::request_certs, but you only need to if the servers you’re joining require it.

Implementations

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.

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

This will create an online-mode account by authenticating with Microsoft’s servers. Note that the email given is actually only used as a key for the cache, but it’s recommended to use the real email to avoid confusion.

pub async fn microsoft_with_custom_client_id_and_scope( email: &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.

pub async fn refresh(&self) -> Result<(), AuthError>

Refresh the access_token for this account to be valid again.

This requires the auth_opts field to be set correctly (which is done by default if you used the constructor functions). Note that if the Account is offline-mode then this function won’t do anything.

pub fn uuid_or_offline(&self) -> Uuid

Get the UUID of this account. This will generate an offline-mode UUID by making a hash with the username if the uuid field is None.

impl Account

pub async fn request_certs(&mut self) -> Result<(), RequestCertError>

Request the certificates used for chat signing and set it in Self::certs.

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, components: &mut ComponentsRegistrator<'_>, required_components: &mut RequiredComponents, inheritance_depth: u16, recursion_check_stack: &mut Vec<ComponentId>, )

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 register_component_hooks(hooks: &mut ComponentHooks)

👎Deprecated since 0.16.0: Use the individual hook methods instead (e.g., Component::on_add, etc.)

Called when registering this component, allowing mutable access to its ComponentHooks.

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.