steel_core/player/advancement/

progress.rs

//! represent the different struct related to the progress of an advancement
use rustc_hash::FxHashMap;
use serde::{Deserialize, Serialize};
use std::borrow::Cow;
use std::time::SystemTime;
use steel_registry::advancement::AdvancementRequirement;
use steel_registry::advancement::registry::AdvancementRef;

/// represent a map of all progress made for advancement of a specific player
#[derive(Debug, Default, Clone)]
pub struct AdvancementProgressMap {
    /// A map of all advancement progress for the player.
    map: FxHashMap<AdvancementRef, usize>,
    order: Vec<(AdvancementRef, AdvancementProgress)>,
}

impl AdvancementProgressMap {
    /// Gets a mutable reference to the current progress for a given advancement. Creates the state entry if missing.
    #[must_use]
    pub fn get_mut_or_start_progress(
        &mut self,
        advancement: AdvancementRef,
    ) -> &mut AdvancementProgress {
        let idx = self.map.entry(advancement).or_insert_with(|| {
            let mut progress = AdvancementProgress::default();
            progress.update(advancement.requirements());
            self.order.push((advancement, progress));
            self.order.len() - 1
        });
        if let Some(progress) = self.order.get_mut(*idx) {
            &mut progress.1
        } else {
            unreachable!("Index {} not found in order vector", idx);
        }
    }

    /// Replaces the progress of an advancement with persisted state.
    pub fn start_progress(
        &mut self,
        advancement: AdvancementRef,
        mut progress: AdvancementProgress,
    ) {
        progress.update(advancement.requirements());
        if let Some(&idx) = self.map.get(&advancement) {
            self.order[idx].1 = progress;
        } else {
            let idx = self.order.len();
            self.order.push((advancement, progress));
            self.map.insert(advancement, idx);
        }
    }

    /// clear all the progress made
    #[inline]
    pub fn clear(&mut self) {
        self.map.clear();
        self.order.clear();
    }

    /// insert a new advancement to the progress map
    #[inline]
    pub fn insert(&mut self, advancement: AdvancementRef, progress: AdvancementProgress) {
        self.order.push((advancement, progress));
        self.map.insert(advancement, self.order.len() - 1);
    }

    /// return the len of the map
    #[must_use]
    #[inline]
    pub fn len(&self) -> usize {
        self.map.len()
    }

    /// return `true` if empty
    #[must_use]
    #[inline]
    pub fn is_empty(&self) -> bool {
        self.map.is_empty()
    }

    /// return whether the advancement has a progress instance
    #[must_use]
    #[inline]
    pub fn has_progress(&self, advancement: AdvancementRef) -> bool {
        self.map.contains_key(&advancement)
    }

    /// return the progress of a specific advancement
    #[must_use]
    #[inline]
    pub fn get_progress(&self, advancement: AdvancementRef) -> Option<&AdvancementProgress> {
        self.map.get(&advancement).map(|&i| &self.order[i].1)
    }

    /// return an iterator over all the progress made using the order of insertion
    pub fn iter(&self) -> impl Iterator<Item = &(AdvancementRef, AdvancementProgress)> {
        self.order.iter()
    }
}

/// Represents the progress of a given advancement for a player.
///
/// Tracks whether the advancement has been fully completed. In the future,
/// this will also track specific criteria progress.
#[derive(Debug, Clone, Default)]
pub struct AdvancementProgress {
    /// Indicates the different progress of all criteria currently only a boolean
    criteria: FxHashMap<Cow<'static, str>, CriterionProgress>,
    /// The Requirement for the Advancement to be mark as complete
    requirements: AdvancementRequirement,
}

impl AdvancementProgress {
    /// Creates a new `AdvancementProgress` with the given criteria.
    /// need to call `update` to set the requirements for the advancement
    #[must_use]
    pub fn new(criteria: FxHashMap<Cow<'static, str>, CriterionProgress>) -> AdvancementProgress {
        Self {
            criteria,
            requirements: AdvancementRequirement::default(),
        }
    }

    /// Returns a reference to the criteria map.
    #[must_use]
    pub const fn criteria(&self) -> &FxHashMap<Cow<'static, str>, CriterionProgress> {
        &self.criteria
    }

    /// Returns `true` if the advancement is done.
    #[must_use]
    pub fn is_done(&self) -> bool {
        self.requirements.test(|s| self.is_criterion_done(s))
    }

    /// Check if a criterion his mark has complete
    fn is_criterion_done(&self, criterion: &str) -> bool {
        self.criteria
            .get(criterion)
            .is_some_and(CriterionProgress::is_done)
    }

    /// Returns `true` if the advancement has any progress.
    #[must_use]
    pub fn has_progress(&self) -> bool {
        for value in self.criteria.values() {
            if value.is_done() {
                return true;
            }
        }
        false
    }

    /// grant a specific criterion
    pub fn grant_progress(&mut self, name: &str) -> bool {
        if let Some(value) = self.criteria.get_mut(name)
            && !value.is_done()
        {
            value.grant();
            true
        } else {
            false
        }
    }

    /// revoke a specific criterion
    pub fn revoke_progress(&mut self, name: &str) -> bool {
        if let Some(value) = self.criteria.get_mut(name)
            && value.is_done()
        {
            value.revoke();
            true
        } else {
            false
        }
    }

    /// update the progress to match a new `AdvancementRequirement` list
    pub fn update(&mut self, requirements: &AdvancementRequirement) {
        let names = requirements.names();
        self.criteria.retain(|key, _criterion| names.contains(key));
        for name in names {
            self.criteria.entry(name).or_default();
        }
        self.requirements = requirements.clone();
    }

    /// return the remaining criteria
    #[inline]
    pub(crate) fn get_remaining_criteria(&self) -> impl Iterator<Item = &str> {
        self.criteria
            .iter()
            .filter(|&(_id, criterion)| !criterion.is_done())
            .map(|(id, _criterion)| &**id)
    }

    /// get the completed criteria
    #[inline]
    pub(crate) fn get_completed_criteria(&self) -> impl Iterator<Item = &str> {
        self.criteria
            .iter()
            .filter(|&(_id, criterion)| criterion.is_done())
            .map(|(id, _criterion)| &**id)
    }
}
/// represent a timestamp to when the criterion has been completed or None if it still un completed
#[derive(Clone, Serialize, Deserialize, Debug, Default)]
pub struct CriterionProgress(pub Option<SystemTime>);

impl CriterionProgress {
    /// grant the progress
    pub fn grant(&mut self) {
        self.0 = Some(SystemTime::now());
    }

    /// revoke the progress
    pub const fn revoke(&mut self) {
        self.0 = None;
    }

    /// return whether the criterion has been completed
    #[must_use]
    pub const fn is_done(&self) -> bool {
        self.0.is_some()
    }
}