capability-stripped-string-skeleton 0.1.0

Provides a streamlined representation of a skill tree structure, focusing on a lightweight, stripped-down version that retains essential hierarchical relationships without the full complexity of the original structure.
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

// ---------------- [ File: capability-stripped-string-skeleton/src/display.rs ]
crate::ix!();

impl fmt::Display for StrippedStringSkeleton {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        // We simply iterate over each node in the order they appear in `items()`
        // and print a block for that node.

        let mut items = self.items().clone();
        items.sort_by(|a,b| a.kind().cmp(b.kind()));

        for node in items {
            // 1) Print:  <Name> => <Kind> node with ...
            write!(f, "{} => ", node.name())?;

            match node.kind() {
                SkillTreeNodeKind::Dispatch => {
                    // e.g. "SanskritYoga => Dispatch node with branches: {"
                    writeln!(f, "Dispatch node with branches: {{")?;

                    // Then each child is:
                    //   // branch_selection_probability = X%
                    //   ChildName,
                    if let Some(children) = node.children() {
                        for child_spec in children {
                            // comment line
                            writeln!(
                                f,
                                "    // branch_selection_probability = {}%",
                                child_spec.probability()
                            )?;
                            // the child itself
                            writeln!(f, "    {},", child_spec.name())?;
                        }
                    }

                    writeln!(f, "}}")?;
                }

                SkillTreeNodeKind::Aggregate => {
                    // e.g. "PronunciationAndPhonetics => Aggregate node with components: ["
                    writeln!(f, "Aggregate node with components: [")?;

                    // Each child line:
                    //   ChildName, // mandatory
                    // or
                    //   ChildName, // optional, psome=XX%
                    if let Some(children) = node.children() {
                        for child_spec in children {
                            let nm = child_spec.name();
                            if *child_spec.optional() {
                                // optional => show probability
                                writeln!(
                                    f,
                                    "    {}, // optional, psome={}%",
                                    nm,
                                    child_spec.probability()
                                )?;
                            } else {
                                // mandatory
                                writeln!(f, "    {}, // mandatory", nm)?;
                            }
                        }
                    }

                    writeln!(f, "]")?;
                }

                SkillTreeNodeKind::LeafHolder => {
                    // e.g. "MantraConvergence => LeafHolder node with 10 leaves [capstone]"
                    write!(f, "LeafHolder node")?;
                    if let Some(n) = node.n_leaves() {
                        write!(f, " with {} leaves", n)?;
                    }
                    if let Some(true) = node.capstone() {
                        write!(f, " [capstone]")?;
                    }
                    writeln!(f)?;
                }
            }

            // Add a blank line between nodes for readability
            writeln!(f)?;
        }

        Ok(())
    }
}