Struct ObserverGame 

#[repr(C, packed(1))]
pub struct ObserverGame {
    pub in_game: bool,
    pub clock_ms: u32,
    pub active_player_count: u8,
    pub game_name: PaddedString<MAX_GAME_NAME_LENGTH>,
    pub map_name: PaddedString<MAX_MAP_NAME_LENGTH>,
}

Game-wide state exposed by the Warcraft III Stats Observer API.

Fields

in_game: bool

true while a game is in progress.

clock_ms: u32

Elapsed game time in milliseconds. Use Self::time for a strongly-typed Duration.

active_player_count: u8

Number of valid entries in crate::ObserverData::players.

game_name: PaddedString<MAX_GAME_NAME_LENGTH>

Name of the current game / lobby.

map_name: PaddedString<MAX_MAP_NAME_LENGTH>

Name of the map currently being played.

Implementations

impl ObserverGame

pub fn time(&self) -> Duration

Returns the elapsed game time as a Duration.

Examples found in repository

examples/stats.rs (line 22)

fn main() {
    let od = match ObserverHandle::new() {
        Ok(od) => od,
        Err(e) => {
            eprintln!("Error opening observer API. Is Warcraft3 running? Error: {e:?}");
            return;
        }
    };

    println!("version: {}", { od.version });
    println!("refresh rate: {}", { od.refresh_rate });

    let game = &od.game;

    println!("in game: {:?}", game.in_game);
    println!(
        "time: {:02}:{:02}",
        game.time().as_secs() / 60,
        game.time().as_secs() % 60
    );
    println!("active player count: {:?}", game.active_player_count);
    println!("game name: {}", game.game_name);
    println!("map name: {}", game.map_name);

    loop {
        for player in od.players.iter().take(od.game.active_player_count as usize) {
            println!("{} has {} gold {} lumber", player.name, { player.gold }, {
                player.lumber
            });
        }
        println!();
        std::thread::sleep(Duration::from_millis(od.refresh_rate as u64));
    }
}