deepwoken 0.4.12

A library for interacting with Deepwoken data in a more convenient format, with a few added utilities.
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

use std::collections::HashMap;

use serde::{Deserialize, Serialize};

use crate::{
    data::DeepData,
    model::aggregate::{BuildParams, EquipmentSelection},
    util::{aggregate::granted_talents, name_to_identifier, statmap::StatMap},
};

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct FactsParams {
    pub race: String,
    pub origin: Option<String>,
    pub oath: Option<String>,
    pub talents: Vec<String>,
    pub equipment: Vec<EquipmentSelection>,
    pub outfit: Option<String>,
    pub stages: Vec<StatMap>,
}

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct BuildFacts {
    pub picked: Vec<String>,
    pub given: Vec<String>,
    pub granted: Vec<String>,
    pub implicit_stages: HashMap<String, Vec<usize>>,
    pub khan: bool,
}

fn qualify(namespace: &str, name: &str) -> String {
    format!("{namespace}:{}", name_to_identifier(name))
}

#[must_use]
pub fn build_facts(data: &DeepData, params: &FactsParams) -> BuildFacts {
    let mut given = Vec::new();

    if let Some(origin) = params.origin.as_deref().filter(|s| !s.is_empty()) {
        given.push(qualify("origin", origin));
    }
    if !params.race.is_empty() {
        given.push(qualify("aspect", &params.race));
    }
    if let Some(oath) = params.oath.as_deref().filter(|s| !s.is_empty()) {
        given.push(qualify("talent", &format!("Oath: {oath}")));
    }
    if let Some(outfit) = params.outfit.as_deref().filter(|s| !s.is_empty()) {
        given.push(qualify("outfit", outfit));
    }

    let equipment_only = BuildParams {
        race: params.race.clone(),
        equipment: params.equipment.clone(),
        outfit: params.outfit.clone(),
        ..BuildParams::default()
    };

    let granted = granted_talents(data, &equipment_only)
        .iter()
        .map(|name| qualify("talent", name))
        .collect();

    let mut implicit_stages: HashMap<String, Vec<usize>> = HashMap::new();
    for (index, stats) in params.stages.iter().enumerate() {
        for talent in stats.implicit_talents(data) {
            implicit_stages
                .entry(qualify("talent", &talent.name))
                .or_default()
                .push(index);
        }
    }

    BuildFacts {
        picked: params.talents.clone(),
        given,
        granted,
        implicit_stages,
        khan: params.race == "Khan",
    }
}