nightshade 0.13.2

A cross-platform data-oriented game engine.
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

//! Text resolution: `Text` -> `String`.
//!
//! Pure function of `World + RuntimeState` (except for `OneOf`, which consumes
//! a random number from the RNG and therefore takes `&mut RuntimeState`).
//!
//! The public [`resolve`] entry point takes an immutable state to stay cheap
//! for view-layer use; it resolves `OneOf` by always picking the first
//! branch. When the engine resolves text during effect execution, it uses
//! [`resolve_mut`] so `OneOf` is actually randomized.

use crate::interactive_fiction::data::{FlagKey, RuntimeState, StatKey, Text, TextId, Value};
use crate::interactive_fiction::engine::{Engine, eval};

/// Immutable resolver: `OneOf` picks its first variant.
pub fn resolve(engine: &Engine, state: &RuntimeState, text: &Text) -> String {
    resolve_inner(engine, state, text, None)
}

/// Mutable resolver: `OneOf` consumes RNG for random selection.
pub fn resolve_mut(engine: &Engine, state: &mut RuntimeState, text: &Text) -> String {
    let mut output = String::new();
    resolve_with_rng(engine, state, text, &mut output);
    output
}

fn resolve_inner(
    engine: &Engine,
    state: &RuntimeState,
    text: &Text,
    rng_override: Option<&mut RuntimeState>,
) -> String {
    match text {
        Text::Literal(value) => value.clone(),
        Text::Ref(id) => resolve_ref(engine, state, id, rng_override),
        Text::Flag(key) => flag_display(state, key),
        Text::Stat(key) => stat_display(state, key),
        Text::Conditional {
            when,
            then,
            otherwise,
        } => {
            let branch = if eval::evaluate(engine, state, when) {
                then
            } else {
                otherwise
            };
            resolve_inner(engine, state, branch, rng_override)
        }
        Text::OneOf(variants) => {
            if variants.is_empty() {
                String::new()
            } else {
                resolve_inner(engine, state, &variants[0], rng_override)
            }
        }
        Text::Sequence(parts) => {
            let mut out = String::new();
            for part in parts {
                out.push_str(&resolve_inner(engine, state, part, None));
            }
            out
        }
    }
}

fn resolve_ref(
    engine: &Engine,
    state: &RuntimeState,
    id: &TextId,
    rng_override: Option<&mut RuntimeState>,
) -> String {
    match engine.world().texts.get(id) {
        Some(inner) => resolve_inner(engine, state, inner, rng_override),
        None => format!("<missing text {id}>"),
    }
}

fn flag_display(state: &RuntimeState, key: &FlagKey) -> String {
    match state.flags.get(key) {
        Some(Value::Bool(value)) => if *value { "true" } else { "false" }.to_string(),
        Some(Value::Int(value)) => value.to_string(),
        Some(Value::Text(value)) => value.clone(),
        None => String::new(),
    }
}

fn stat_display(state: &RuntimeState, key: &StatKey) -> String {
    state.stats.get(key).copied().unwrap_or(0).to_string()
}

fn resolve_with_rng(engine: &Engine, state: &mut RuntimeState, text: &Text, out: &mut String) {
    match text {
        Text::Literal(value) => out.push_str(value),
        Text::Ref(id) => {
            if let Some(inner) = engine.world().texts.get(id).cloned() {
                resolve_with_rng(engine, state, &inner, out);
            } else {
                out.push_str("<missing text ");
                out.push_str(id.as_str());
                out.push('>');
            }
        }
        Text::Flag(key) => out.push_str(&flag_display(state, key)),
        Text::Stat(key) => out.push_str(&stat_display(state, key)),
        Text::Conditional {
            when,
            then,
            otherwise,
        } => {
            let branch = if eval::evaluate(engine, state, when) {
                then.as_ref()
            } else {
                otherwise.as_ref()
            };
            let owned = branch.clone();
            resolve_with_rng(engine, state, &owned, out);
        }
        Text::OneOf(variants) => {
            if !variants.is_empty() {
                let pick = state.random_index(variants.len());
                let chosen = variants[pick].clone();
                resolve_with_rng(engine, state, &chosen, out);
            }
        }
        Text::Sequence(parts) => {
            for part in parts {
                resolve_with_rng(engine, state, part, out);
            }
        }
    }
}