evtclib 0.7.3

An evtc parsing library
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! This module contains helper methods that are used in different analyzers.
use std::collections::HashMap;

use crate::{AgentKind, EventKind, Log};

/// Check if the log was rewarded, and if yes, return `Outcome::Success` early.
macro_rules! check_reward {
    ($log:expr) => {
        let log: &Log = $log;
        if log.was_rewarded() {
            return Some(crate::analyzers::Outcome::Success);
        }
    };
}

/// Returns the maximum health of the boss agent.
///
/// If the health cannot be determined, this function returns `None`.
///
/// The boss agent is determined by using [`Log::is_boss`][Log::is_boss].
pub fn boss_health(log: &Log) -> Option<u64> {
    let mut health: Option<u64> = None;
    for event in log.events() {
        if let EventKind::MaxHealthUpdate {
            agent_addr,
            max_health,
        } = *event.kind()
        {
            if log.is_boss(agent_addr) {
                health = health.map(|h| h.max(max_health)).or(Some(max_health));
            }
        }
    }
    health
}

/// Checks if any of the boss NPCs have died.
///
/// Death is determined by checking for the [`EventKind::ChangeDead`][EventKind::ChangeDead] event,
/// and whether a NPC is a boss is determined by the [`Log::is_boss`][Log::is_boss] method.
pub fn boss_is_dead(log: &Log) -> bool {
    log.events().iter().any(
        |ev| matches!(ev.kind(), EventKind::ChangeDead { agent_addr } if log.is_boss(*agent_addr)),
    )
}

/// Checks whether the players exit combat after the boss.
///
/// This is useful to determine the success state of some fights.
pub fn players_exit_after_boss(log: &Log) -> bool {
    let mut player_exit = 0u64;
    let mut boss_exit = 0u64;

    for event in log.events() {
        if let EventKind::ExitCombat { agent_addr } = event.kind() {
            let agent = if let Some(a) = log.agent_by_addr(*agent_addr) {
                a
            } else {
                continue;
            };

            match agent.kind() {
                AgentKind::Player(_) if event.time() >= player_exit => {
                    player_exit = event.time();
                }
                AgentKind::Character(_)
                    if event.time() >= boss_exit && log.is_boss(*agent_addr) =>
                {
                    boss_exit = event.time();
                }
                _ => (),
            }
        }
    }
    // Safety margin
    boss_exit != 0 && player_exit > boss_exit + 1000
}

/// Checks if the given buff is present in the log.
pub fn buff_present(log: &Log, wanted_buff_id: u32) -> bool {
    for event in log.events() {
        if let EventKind::BuffApplication { buff_id, .. } = *event.kind() {
            if buff_id == wanted_buff_id {
                return true;
            }
        }
    }
    false
}

/// Returns the (minimum) time between applications of the given buff in milliseconds.
pub fn time_between_buffs(log: &Log, wanted_buff_id: u32) -> u64 {
    let mut time_maps: HashMap<u64, Vec<u64>> = HashMap::new();
    for event in log.events() {
        if let EventKind::BuffApplication {
            destination_agent_addr,
            buff_id,
            ..
        } = event.kind()
        {
            if *buff_id == wanted_buff_id {
                time_maps
                    .entry(*destination_agent_addr)
                    .or_default()
                    .push(event.time());
            }
        }
    }
    let timestamps = if let Some(ts) = time_maps.values().max_by_key(|v| v.len()) {
        ts
    } else {
        return 0;
    };
    timestamps
        .iter()
        .zip(timestamps.iter().skip(1))
        .map(|(a, b)| b - a)
        // Arbitrary limit to filter out duplicated buff application events
        .filter(|x| *x > 50)
        .min()
        .unwrap_or(0)
}