character-wizard-cli 0.6.0

Native level-1 SRD character creation CLI
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Unified access to built-in SRD rules and optional validated campaign content.

use crate::{
    character_wizard_domain::{
        Character, DataPackReference, PackBackground, PackClass, PackEquipment, PackSpecies,
        PackSpell, ResolvedCharacter,
    },
    character_wizard_srd_data as srd,
};

/// Immutable rule catalog used by creation, validation, and rendering orchestration.
#[derive(Debug, Clone, Copy)]
pub struct RulesContext<'a> {
    reference: Option<&'a DataPackReference>,
    name: Option<&'a str>,
    classes: &'a [PackClass],
    species: &'a [PackSpecies],
    backgrounds: &'a [PackBackground],
    equipment: &'a [PackEquipment],
    spells: &'a [PackSpell],
}

impl RulesContext<'static> {
    #[must_use]
    pub const fn srd() -> Self {
        Self {
            reference: None,
            name: None,
            classes: &[],
            species: &[],
            backgrounds: &[],
            equipment: &[],
            spells: &[],
        }
    }
}

impl<'a> RulesContext<'a> {
    #[must_use]
    pub const fn with_pack(
        reference: &'a DataPackReference,
        name: &'a str,
        classes: &'a [PackClass],
        species: &'a [PackSpecies],
        backgrounds: &'a [PackBackground],
        equipment: &'a [PackEquipment],
        spells: &'a [PackSpell],
    ) -> Self {
        Self {
            reference: Some(reference),
            name: Some(name),
            classes,
            species,
            backgrounds,
            equipment,
            spells,
        }
    }

    #[must_use]
    pub const fn reference(self) -> Option<&'a DataPackReference> {
        self.reference
    }

    #[must_use]
    pub const fn name(self) -> Option<&'a str> {
        self.name
    }

    #[must_use]
    pub const fn classes(self) -> &'a [PackClass] {
        self.classes
    }

    #[must_use]
    pub const fn species(self) -> &'a [PackSpecies] {
        self.species
    }

    #[must_use]
    pub const fn backgrounds(self) -> &'a [PackBackground] {
        self.backgrounds
    }

    #[must_use]
    pub const fn equipment(self) -> &'a [PackEquipment] {
        self.equipment
    }

    #[must_use]
    pub const fn spells(self) -> &'a [PackSpell] {
        self.spells
    }

    #[must_use]
    pub fn custom_class(self, value: &str) -> Option<&'a PackClass> {
        self.classes.iter().find(|rule| {
            rule.id.eq_ignore_ascii_case(value) || rule.name.eq_ignore_ascii_case(value)
        })
    }

    #[must_use]
    pub fn custom_background(self, value: &str) -> Option<&'a PackBackground> {
        self.backgrounds.iter().find(|rule| {
            rule.id.eq_ignore_ascii_case(value) || rule.name.eq_ignore_ascii_case(value)
        })
    }

    #[must_use]
    pub fn custom_species(self, value: &str) -> Option<&'a PackSpecies> {
        self.species.iter().find(|rule| {
            rule.id.eq_ignore_ascii_case(value) || rule.name.eq_ignore_ascii_case(value)
        })
    }

    /// Attach the exact custom mechanics required by a canonical character.
    ///
    /// # Errors
    ///
    /// Returns an error when provenance differs or referenced content is unavailable.
    pub fn resolve(self, mut character: Character) -> Result<ResolvedCharacter, String> {
        match (&character.data_pack, self.reference) {
            (None, _) => {}
            (Some(required), Some(actual)) if required == actual => {}
            (Some(required), Some(_)) => {
                return Err(format!(
                    "character requires data pack {} version {} (format version {})",
                    required.id, required.version, required.format_version
                ));
            }
            (Some(required), None) => {
                return Err(format!(
                    "character requires data pack {}; pass --data <directory>",
                    required.id
                ));
            }
        }
        character.resolve_pack_class(self.classes)?;
        character.resolve_pack_background(self.backgrounds)?;
        character.resolve_pack_equipment(self.equipment)?;
        character.resolve_pack_spells(self.spells)?;
        character.resolve_pack_species(if srd::species_rule(&character.species).is_some() {
            &[]
        } else {
            self.species
        })?;
        character.validate()?;
        Ok(ResolvedCharacter(character))
    }
}