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

//! Dialogue graphs.
//!
//! A dialogue is a small graph of nodes (with narrative text and entry
//! effects) connected by labelled options. The engine tracks an active
//! dialogue in `RuntimeState.active_dialogue` and offers its current node's
//! options as the turn's choices until an option ends the dialogue.

use crate::interactive_fiction::data::condition::Condition;
use crate::interactive_fiction::data::effect::Effect;
use crate::interactive_fiction::data::ids::NodeId;
use crate::interactive_fiction::data::text::Text;
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;

/// A complete conversation graph.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Dialogue {
    /// The node the dialogue begins at.
    pub start: NodeId,
    /// All nodes in the graph keyed by id. Nodes point at each other via the
    /// `goto` field on their options.
    pub nodes: BTreeMap<NodeId, DialogueNode>,
}

impl Dialogue {
    /// Start a new dialogue whose first node is `start`.
    pub fn new(start: NodeId) -> Self {
        Self {
            start,
            nodes: BTreeMap::new(),
        }
    }

    /// Insert a node into the dialogue graph keyed by its id.
    pub fn with_node(mut self, id: NodeId, node: DialogueNode) -> Self {
        self.nodes.insert(id, node);
        self
    }
}

/// A single beat of conversation.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DialogueNode {
    /// The NPC's line at this point.
    pub text: Text,
    /// Effects run when the engine first enters this node.
    pub on_enter: Vec<Effect>,
    /// Player responses.
    pub options: Vec<DialogueOption>,
}

impl DialogueNode {
    pub fn new(text: Text) -> Self {
        Self {
            text,
            on_enter: Vec::new(),
            options: Vec::new(),
        }
    }

    pub fn with_on_enter(mut self, effects: Vec<Effect>) -> Self {
        self.on_enter = effects;
        self
    }

    pub fn with_option(mut self, option: DialogueOption) -> Self {
        self.options.push(option);
        self
    }
}

/// A choice the player can pick inside a dialogue node.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DialogueOption {
    /// Player-facing label.
    pub label: Text,
    /// If present, the option is only selectable when the condition holds.
    pub condition: Option<Condition>,
    /// If true, the option is shown greyed out with `locked_reason` when its
    /// condition does not hold; otherwise it is omitted from the menu.
    pub visible_when_locked: bool,
    /// Message shown next to a greyed-out option.
    pub locked_reason: Option<Text>,
    /// Effects to run when the player picks this option.
    pub effects: Vec<Effect>,
    /// If `Some`, the dialogue jumps to that node after running effects.
    /// If `None`, the dialogue ends.
    pub goto: Option<NodeId>,
}

impl DialogueOption {
    pub fn new(label: Text) -> Self {
        Self {
            label,
            condition: None,
            visible_when_locked: false,
            locked_reason: None,
            effects: Vec::new(),
            goto: None,
        }
    }

    pub fn with_condition(mut self, condition: Condition) -> Self {
        self.condition = Some(condition);
        self
    }

    pub fn visible_when_locked(mut self, reason: Text) -> Self {
        self.visible_when_locked = true;
        self.locked_reason = Some(reason);
        self
    }

    pub fn with_effects(mut self, effects: Vec<Effect>) -> Self {
        self.effects = effects;
        self
    }

    pub fn goto(mut self, node: NodeId) -> Self {
        self.goto = Some(node);
        self
    }
}