Struct ObserverHandle 

pub struct ObserverHandle { /* private fields */ }

Owns the Windows handles from OpenFileMappingW and MapViewOfFile.

Releases them via Drop and dereferences to ObserverData for read and write access to the memory map.

Implementations

impl ObserverHandle

pub fn new() -> Result<Self>

Opens the observer memory map and sets the refresh rate to the default of 500 ms.

Returns an error if Warcraft III is not running, or the stats observer API is otherwise unavailable.

Examples found in repository

examples/stats.rs (line 6)

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));
    }
}

pub fn new_with_refresh_rate(duration: Duration) -> Result<Self>

Opens the observer memory map and writes duration as the refresh rate. A duration of zero disables updates.

Returns an error if Warcraft III is not running, or the stats observer API is otherwise unavailable.

Methods from Deref<Target = ObserverData>

pub fn disable(&mut self)

Disables observer updates by writing a refresh rate of 0.

pub fn set_refresh_rate(&mut self, duration: Duration)

Sets the observer’s refresh rate. Sub-millisecond precision is truncated. A duration of zero disables updates.

Trait Implementations

impl Deref for ObserverHandle

type Target = ObserverData

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for ObserverHandle

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Drop for ObserverHandle

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Send for ObserverHandle

impl Sync for ObserverHandle