Struct showdown::message::Challenge

pub struct Challenge<'a>(_);

Login challenge.

Implementations

impl<'a> Challenge<'a>

pub async fn login(
    self,
    sender: &'a mut Sender,
    login: &'a str
) -> Result<Option<PasswordRequired<'a>>>

Logs in an user.

Examples

use futures::prelude::*;
use rand::prelude::*;
use showdown::message::{Kind, NoInit, NoInitKind};
use showdown::{connect, Result, RoomId};

#[tokio::main]
async fn main() -> Result<()> {
    let (mut sender, mut receiver) = connect("showdown").await?;
    sender.send_global_command("join bot dev").await?;
    let mut received;
    // Get the challenge first
    let challenge = loop {
        received = receiver.receive().await?;
        if let Kind::Challenge(ch) = received.kind() {
            break ch;
        }
    };
    // It's not possible to join a hidden room without being logged in.
    loop {
        if let Kind::NoInit(NoInit {
            kind: NoInitKind::NameRequired,
            ..
        }) = receiver.receive().await?.kind()
        {
            break;
        }
    }
    let name = random_username();
    challenge.login(&mut sender, &name).await?;
    sender.send_global_command("join bot dev").await?;
    loop {
        if let Kind::RoomInit(_) = receiver.receive().await?.kind() {
            return Ok(());
        }
    }
}

fn random_username() -> String {
    let chars: Vec<_> = (b'a'..b'z').chain(b'0'..b'9').map(char::from).collect();
    (0..16)
        .map(|_| chars.choose(&mut thread_rng()).unwrap())
        .collect()
}

pub async fn login_with_password<'_, '_, '_>(
    self,
    sender: &'_ mut Sender,
    login: &'_ str,
    password: &'_ str
) -> Result<()>

Trait Implementations

impl<'a> Clone for Challenge<'a>

fn clone(&self) -> Challenge<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for Challenge<'a>

impl<'a> Debug for Challenge<'a>

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

Formats the value using the given formatter.