steel_core/player/

stats_counter.rs

//! This module provides the [`StatsCounter`], which keeps track of stats with their counters, and
//! implements some stat-related functions for the player.

use crate::player::Player;
use rustc_hash::FxHashMap;
use steel_protocol::packets::game::CAwardStats;
use steel_registry::RegistryExt;
use steel_registry::stat::custom::CustomStatRef;
use steel_registry::stat::{Stat, StatTypeRef, vanilla_stat_types};

/// This enum is used to decide if a stat is dirty or not, and whether it should be serialized or not.
///
/// This is done so that during a domain transfer, stats reset to zero from a previous domain
/// to update the client are not serialized to the next.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub(crate) enum StatState {
    /// The stat is clean (not dirty), so no update will be sent from this stat until the counter
    /// changes value.
    /// The stat will be persisted.
    Clean,

    /// This stat is dirty, so the next time stats are queried by the
    /// client, its update will get sent to the client.
    /// The stat will be persisted.
    Dirty,

    /// This stat was reset upon transferring domains, so its update will get sent to the client.
    /// The stat will not be persisted.
    Reset,
}

/// Manages the counters for every statistic for a particular player.
/// Analogous to Vanilla's `ServerStatsCounter.java`.
pub struct StatsCounter {
    /// The map of each stat currently being tracked to its value and state.
    // Vanilla uses a map and set separately for the counters and dirty flag respectively,
    // but it is faster to just use one map to store both the count and state in the same map.
    pub(super) stats: FxHashMap<Stat, (i32, StatState)>,
}

impl StatsCounter {
    /// Creates a new, empty [`StatsCounter`].
    #[must_use]
    pub fn new() -> Self {
        Self {
            stats: FxHashMap::default(),
        }
    }

    /// Gets the value of the counter corresponding to the given stat.
    /// If this counter is not currently being tracked, `0` is returned instead.
    #[must_use]
    pub fn get(&self, stat: &Stat) -> i32 {
        self.stats.get(stat).map_or_default(|(count, _)| *count)
    }

    /// Sets the value of the counter corresponding to the given stat to a given value.
    pub fn set(&mut self, stat: Stat, count: i32) {
        self.stats.insert(stat, (count, StatState::Dirty));
    }

    /// Increments the value of the counter corresponding to the given stat by a given value.
    pub fn increment(&mut self, stat: Stat, count: i32) {
        let entry = self.stats.entry(stat).or_insert((0, StatState::Dirty));
        let sum = (i64::from(entry.0) + i64::from(count)).min(i64::from(i32::MAX));
        *entry = (sum as i32, StatState::Dirty);
    }

    /// Marks all the stat counters of this player to be dirty. This means that the next time
    /// statistics are requested, all tracked stat counters will be sent to the client.
    pub fn mark_all_dirty(&mut self) {
        for (_, dirty_flag) in self.stats.values_mut() {
            if *dirty_flag == StatState::Clean {
                *dirty_flag = StatState::Dirty;
            }
        }
    }

    /// Gets all the counters of stats that are marked dirty and clears their dirty flag as
    /// well.
    pub(crate) fn get_dirty_and_clear(&mut self) -> Vec<(Stat, i32)> {
        let mut dirty_stats = Vec::new();
        let mut stats_to_remove = Vec::new();
        for (&stat, (count, state)) in &mut self.stats {
            match *state {
                StatState::Dirty => {
                    dirty_stats.push((stat, *count));
                    *state = StatState::Clean;
                }
                StatState::Reset => {
                    dirty_stats.push((stat, *count));
                    stats_to_remove.push(stat);
                }
                StatState::Clean => {}
            }
        }
        for stat in stats_to_remove {
            self.stats.remove(&stat);
        }
        dirty_stats
    }

    /// Sets the counters of all stats in this counter to zero,
    /// and marks them as reset. The stats will not be persisted, but will be sent to the client
    /// the next time they are queried.
    pub fn reset(&mut self) {
        for tuple in self.stats.values_mut() {
            *tuple = (0, StatState::Reset);
        }
    }

    /// Returns the number of stats currently being tracked for this player.
    #[must_use]
    pub fn len(&self) -> usize {
        self.stats
            .iter()
            .filter(|(_, (_, state))| *state != StatState::Reset)
            .count()
    }

    /// Returns whether there are no stats are currently being tracked or not.
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.stats
            .iter()
            .all(|(_, (_, state))| *state == StatState::Reset)
    }
}

impl Default for StatsCounter {
    fn default() -> Self {
        Self::new()
    }
}

impl Player {
    /// Awards one count of a particular stat to this player.
    pub fn award_stat<R: RegistryExt>(&self, stat_type: StatTypeRef<R>, value: &'static R::Entry)
    where
        R::Entry: Send + Sync,
    {
        self.award_erased_stat(stat_type.get(value));
    }

    /// Awards a given amount of a particular stat to this player.
    pub fn award_stat_with_count<R: RegistryExt>(
        &self,
        stat_type: StatTypeRef<R>,
        value: &'static R::Entry,
        count: i32,
    ) where
        R::Entry: Send + Sync,
    {
        self.award_erased_stat_with_count(stat_type.get(value), count);
    }

    /// Awards a given amount of a custom stat to this player.
    pub fn award_custom_stat(&self, stat: CustomStatRef) {
        self.award_stat(&vanilla_stat_types::CUSTOM, stat);
    }

    /// Awards a given amount of a custom stat to this player.
    pub fn award_custom_stat_with_count(&self, stat: CustomStatRef, count: i32) {
        self.award_stat_with_count(&vanilla_stat_types::CUSTOM, stat, count);
    }

    /// Awards one count of a particular stat to this player.
    pub(crate) fn award_erased_stat(&self, stat: Stat) {
        self.award_erased_stat_with_count(stat, 1);
    }

    /// Awards a given amount of a particular stat to this player.
    pub(crate) fn award_erased_stat_with_count(&self, stat: Stat, count: i32) {
        self.stats.lock().increment(stat, count);
        // TODO: Add score to the objectives having the criterion of this stat for the player.
    }

    /// Resets the counter of a stat from this player to zero.
    pub fn reset_stat(&self, stat: Stat) {
        self.stats.lock().set(stat, 0);
        // TODO: Reset score of the objectives having the criterion of this stat for the player.
    }

    /// Resets the counter of a custom stat from this player to zero.
    pub fn reset_custom_stat(&self, stat: CustomStatRef) {
        self.reset_stat(vanilla_stat_types::CUSTOM.get(stat));
    }

    /// Marks all the stat counters of this player to be dirty. This means that the next time
    /// statistics are requested, all tracked stat counters will be sent to the client.
    pub fn mark_all_stats_dirty(&self) {
        self.stats.lock().mark_all_dirty();
    }

    /// Sends all the dirty stats of this player to their client, and removes
    /// the dirty flag from all of them.
    pub fn send_stats(&self) {
        let stats = self.stats.lock().get_dirty_and_clear();
        self.send_packet(CAwardStats { stats });
    }

    /// Returns the player's currently tracked stats and their counters.
    /// This excludes stats marked as reset (from transferring domains).
    #[must_use]
    pub fn stats(&self) -> Vec<(Stat, i32)> {
        self.stats
            .lock()
            .stats
            .iter()
            .filter(|(_, (_, state))| *state != StatState::Reset)
            .map(|(&stat, &(count, _))| (stat, count))
            .collect()
    }
}

#[cfg(test)]
mod tests {
    use crate::player::stats_counter::StatsCounter;
    use steel_registry::stat::{Stat, vanilla_stat_types};
    use steel_registry::{init_vanilla_registry, vanilla_custom_stats};

    fn deterministic_dirty_and_clear(counter: &mut StatsCounter) -> Vec<(Stat, i32)> {
        let mut dirty = counter.get_dirty_and_clear();
        dirty.sort_by_key(|(stat, _)| stat.stat_value_key().clone());

        dirty
    }

    #[test]
    fn stat_counter_query_dirty_and_modifications() {
        init_vanilla_registry();

        let mut stats_counter = StatsCounter::new();

        let jump_stat = vanilla_stat_types::CUSTOM.get(&vanilla_custom_stats::JUMP);
        let deaths_stat = vanilla_stat_types::CUSTOM.get(&vanilla_custom_stats::DEATHS);

        stats_counter.increment(jump_stat, 9);
        stats_counter.increment(jump_stat, 4);

        assert_eq!(stats_counter.get(&jump_stat), 13);
        assert_eq!(stats_counter.get(&deaths_stat), 0);

        stats_counter.increment(deaths_stat, 1);
        assert_eq!(
            deterministic_dirty_and_clear(&mut stats_counter),
            vec![(deaths_stat, 1), (jump_stat, 13)]
        );

        stats_counter.increment(deaths_stat, 1);
        assert_eq!(
            deterministic_dirty_and_clear(&mut stats_counter),
            vec![(deaths_stat, 2)]
        );

        stats_counter.mark_all_dirty();
        assert_eq!(
            deterministic_dirty_and_clear(&mut stats_counter),
            vec![(deaths_stat, 2), (jump_stat, 13)]
        );

        assert_eq!(deterministic_dirty_and_clear(&mut stats_counter), vec![]);

        stats_counter.set(deaths_stat, 7);
        assert_eq!(
            deterministic_dirty_and_clear(&mut stats_counter),
            vec![(deaths_stat, 7)]
        );

        assert_eq!(stats_counter.get(&jump_stat), 13);
    }

    #[test]
    fn overflow_cap() {
        init_vanilla_registry();

        let mut stats_counter = StatsCounter::new();
        let jump_stat = vanilla_stat_types::CUSTOM.get(&vanilla_custom_stats::JUMP);

        stats_counter.set(jump_stat, i32::MAX - 1);

        stats_counter.increment(jump_stat, 1);
        assert_eq!(stats_counter.get(&jump_stat), i32::MAX);

        stats_counter.increment(jump_stat, 1);
        assert_eq!(stats_counter.get(&jump_stat), i32::MAX);

        stats_counter.increment(jump_stat, 1000);
        assert_eq!(stats_counter.get(&jump_stat), i32::MAX);

        stats_counter.increment(jump_stat, i32::MAX);
        assert_eq!(stats_counter.get(&jump_stat), i32::MAX);

        stats_counter.increment(jump_stat, i32::MIN + 1);
        assert_eq!(stats_counter.get(&jump_stat), 0);
    }

    #[test]
    fn no_underflow_cap() {
        init_vanilla_registry();

        let mut stats_counter = StatsCounter::new();
        let jump_stat = vanilla_stat_types::CUSTOM.get(&vanilla_custom_stats::JUMP);

        stats_counter.set(jump_stat, i32::MIN + 1);

        stats_counter.increment(jump_stat, -1);
        assert_eq!(stats_counter.get(&jump_stat), i32::MIN);

        stats_counter.increment(jump_stat, -1);
        assert_eq!(stats_counter.get(&jump_stat), i32::MAX);

        stats_counter.increment(jump_stat, i32::MAX);
        assert_eq!(stats_counter.get(&jump_stat), i32::MAX);
    }

    #[test]
    fn reset_stats() {
        let mut stats_counter = StatsCounter::new();

        let jump_stat = vanilla_stat_types::CUSTOM.get(&vanilla_custom_stats::JUMP);
        stats_counter.set(jump_stat, 17);

        // No need to sort because only one stat is used.
        assert_eq!(
            stats_counter.get_dirty_and_clear(),
            [(jump_stat, 17)],
            "stat did not set value"
        );
        assert_eq!(
            stats_counter.get_dirty_and_clear(),
            [],
            "stat should not send the value again after being cleared"
        );

        stats_counter.reset();

        assert_eq!(
            stats_counter.len(),
            0,
            "reset stat entries should not be counted"
        );
        assert!(
            stats_counter.is_empty(),
            "reset stat entries should not be counted"
        );

        assert_eq!(
            stats_counter.get_dirty_and_clear(),
            [(jump_stat, 0)],
            "reset stat should update the client with zero"
        );
        assert_eq!(
            stats_counter.get_dirty_and_clear(),
            [],
            "reset stat should not update the client again with zero after being removed"
        );
        assert!(
            stats_counter.stats.is_empty(),
            "stale stat counter was not removed"
        );

        // Set the stat to 5 before resetting it so that we can verify that an incremented stat
        // after a reset does not get removed.
        stats_counter.set(jump_stat, 5);
        stats_counter.reset();
        stats_counter.increment(jump_stat, 3);
        assert_eq!(
            stats_counter.get_dirty_and_clear(),
            [(jump_stat, 3)],
            "stat counter should have updated with a new value after incrementing from a reset"
        );
        assert!(
            !stats_counter.stats.is_empty(),
            "stat counter should not have been removed after increment"
        );
    }
}