Struct brawl_api::model::players::battlelog::BattleResultInfo

pub struct BattleResultInfo {
    pub mode: String,
    pub battle_type: Option<String>,
    pub duration: usize,
    pub trophy_change: isize,
    pub rank: Option<u8>,
    pub result: Option<BattleOutcome>,
    pub star_player: Option<BattlePlayer>,
    pub teams: Option<Vec<Vec<BattlePlayer>>>,
    pub players: Option<Vec<BattlePlayer>>,
}

Represents the result of a battle in a Battle object, including details, outcome, players/teams etc.

There are three general models of fields here:

• Team modes (Bounty, Gem Grab, Duo Showdown...): fields mode, battle_type, duration, trophy_change, result, star_player, teams
• Solo modes (Solo Showdown): fields mode, battle_type, duration, trophy_change, rank, players
• Weekend events: Depends on the event. Should always be there: mode, duration.
  • Here, trophy_change is always equal to 0.
  • Boss fight: mode, duration, players
  • Big Brawler: mode, duration, result, star_player, teams (needs testing!)
  • Robo Rumble: mode, duration, players (needs testing!)

Fields

mode: String

The event mode (e.g. "brawlBall", "soloShowdown"...). Should be the same as BattleEvent.mode.

battle_type: Option<String>

The type of battle (e.g. "ranked").

If this is None, then this is likely a weekend event.

duration: usize

The duration of this battle, in seconds.

trophy_change: isize

The difference in trophies applied to the player after the battle. E.g. -4 (lost 4 trophies)

This is always 0 for weekend events and practice.

rank: Option<u8>

If this was a solo mode match, then this is the player's final rank (1-10). Otherwise, None.

result: Option<BattleOutcome>

If this was a match with teams, then this is the outcome for the player (Victory/Defeat/Draw), otherwise None.

star_player: Option<BattlePlayer>

The data indicating who was the Star Player in the match. This is generally from the winning team, unless a draw occurred, in which case it can be from either team. If this was a solo mode or boss fight match, for instance, then there is no star player (None).

teams: Option<Vec<Vec<BattlePlayer>>>

If this was a match with teams, then this is a vector with all teams of players (as vectors) - this can be the teams in a teamed mode such as Bounty, or the pairs in Duo Showdown, for example. Otherwise, None.

players: Option<Vec<BattlePlayer>>

If this was a solo match or a mode without teams, such as Showdown, then this is a vector with all the players in the match. Otherwise, None.

Trait Implementations

impl Clone for BattleResultInfo

fn clone(&self) -> BattleResultInfo

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BattleResultInfo

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

Formats the value using the given formatter.

impl Default for BattleResultInfo

fn default() -> BattleResultInfo

Returns an instance of BattleResultInfo with initial values.

Examples

use brawl_api::BattleResultInfo;

assert_eq!(
    BattleResultInfo::default(),
    BattleResultInfo {
        mode: String::from(""),
        battle_type: Some(String::from("")),
        duration: 0,
        trophy_change: 0,
        rank: None,
        star_player: None,
        result: None,
        teams: None,
        players: None,
    }
);

impl<'de> Deserialize<'de> for BattleResultInfo

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Eq for BattleResultInfo

impl Hash for BattleResultInfo

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl PartialEq<BattleResultInfo> for BattleResultInfo

fn eq(&self, other: &BattleResultInfo) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &BattleResultInfo) -> bool

This method tests for !=.

impl Serialize for BattleResultInfo

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralEq for BattleResultInfo

impl StructuralPartialEq for BattleResultInfo