Struct Player 

pub struct Player {

    pub steamid: String,
    pub name: String,
    pub clan: String,
    pub observer_slot: Option<u8>,
    pub xp_overload_level: Option<u32>,
    pub team: PlayerTeam,
    pub activity: PlayerActivity,
    pub state: PlayerState,
    pub match_stats: MatchStats,
    pub weapons: BTreeMap<String, Weapon>,
    pub spectarget: String,
    pub position: String,
    pub forward: String,
}

A single player snapshot.

Fields

steamid: String

64-bit SteamID. Empty for bots.

name: String

In-game display name.

clan: String

Clan tag, may be empty.

observer_slot: Option<u8>

Observer slot number (0..=9 in standard 5v5).

xp_overload_level: Option<u32>

XP overload level (CS2 progression).

team: PlayerTeam

Side the player belongs to.

activity: PlayerActivity

Activity (menu / playing / textinput).

state: PlayerState

Volatile per-tick state (health, armor, money, …).

match_stats: MatchStats

Per-match aggregate statistics.

weapons: BTreeMap<String, Weapon>

Inventory keyed by weapon slot id (e.g. "weapon_0").

spectarget: String

SteamID of the player currently being spectated (when activity = playing is false).

position: String

World position vector, formatted by CS2 as "x, y, z".

forward: String

Forward look direction vector, formatted by CS2 as "x, y, z".

Trait Implementations

impl Clone for Player

fn clone(&self) -> Player

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Player

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

Formats the value using the given formatter.

impl Default for Player

fn default() -> Player

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Player

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Player

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Player

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Player