brawl-rs 0.1.0

A Rust wrapper for the Brawl Stars API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

// Example: Fetch Battle Log
// To run: cargo run --example battle_log

use brawl_rs::prelude::*;
use std::env::var;

#[tokio::main]
#[cfg(feature = "battle_log")]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = BrawlClient::new(var("BRAWL_TOKEN")?);

    // ==========================================
    // FETCH BATTLE LOG
    // ==========================================

    println!("=== Battle Log ===\n");
    match BattleLog::get(&client, "20YY0G9L0").await {
        Ok(battle_log) => {
            println!("Found {} battles:\n", battle_log.items.len());

            for (i, battle) in battle_log.items.iter().enumerate().take(3) {
                println!("=== Battle #{} ===", i + 1);

                // Battle time
                println!("Battle Time: {}", battle.battle_time);

                // Event information
                println!("Event ID: {}", battle.event.id);
                println!("Event Mode ID: {}", battle.event.mode_id);
                if let Some(map) = &battle.event.map {
                    println!("Event Map: {}", map);
                }

                // Battle information
                println!("Battle Mode: {}", battle.battle.mode);
                println!("Battle Type: {}", battle.battle.kind);

                if let Some(result) = &battle.battle.result {
                    println!("Result: {}", result);
                }

                if let Some(rank) = battle.battle.rank {
                    println!("Rank: {}", rank);
                }

                if let Some(trophy_change) = battle.battle.trophy_change {
                    println!("Trophy Change: {}", trophy_change);
                }

                // Star player
                if let Some(star_player) = &battle.battle.star_player {
                    println!("Star Player:");
                    println!("  Tag: {}", star_player.tag);
                    println!("  Name: {}", star_player.name);
                    println!("  Brawler ID: {}", star_player.brawler.id);
                    println!("  Brawler Name: {}", star_player.brawler.name);
                    println!("  Brawler Power: {}", star_player.brawler.power);
                    println!("  Brawler Trophies: {}", star_player.brawler.trophies);
                }

                // Players
                println!("Players ({}):", battle.battle.players.len());
                for (j, player) in battle.battle.players.iter().enumerate() {
                    println!("  Player {}:", j + 1);
                    println!("    Tag: {}", player.tag);
                    println!("    Name: {}", player.name);
                    println!("    Brawler ID: {}", player.brawler.id);
                    println!("    Brawler Name: {}", player.brawler.name);
                    println!("    Brawler Power: {}", player.brawler.power);
                    println!("    Brawler Trophies: {}", player.brawler.trophies);
                }

                // Teams (if available)
                if let Some(teams) = &battle.battle.teams {
                    println!("Teams ({} teams):", teams.len());
                    for (team_idx, team) in teams.iter().enumerate() {
                        println!("  Team {} ({} players):", team_idx + 1, team.len());
                        for (player_idx, player) in team.iter().enumerate() {
                            println!(
                                "    Player {}: {} ({})",
                                player_idx + 1,
                                player.name,
                                player.brawler.name
                            );
                        }
                    }
                }

                println!("\n");
            }
        }
        Err(e) => eprintln!("Error fetching battle log: {}", e),
    }

    Ok(())
}