epkard 0.1.1

A generalized framework for creating branching narratives
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

use epkard::*;

#[derive(Serialize, Deserialize)]
struct State {
    has_key: bool,
}

#[derive(Clone, Serialize, Deserialize)]
enum Room {
    Start,
    Side,
    Exit,
}

impl Node for Room {
    type State = State;
    fn next<F>(self, rt: &mut Runtime<Self, F>) -> Control<Self>
    where
        F: Frontend,
    {
        rt.clear();
        match self {
            Room::Start => {
                rt.println("You are in a room.");
                rt.wait()?;
                let next_room = rt.multiple_choice_named(
                    "Where do you want to go?",
                    vec![
                        ("The door with light behind it", Room::Exit),
                        ("The door with no light behind it", Room::Side),
                    ],
                )?;
                next(next_room)
            }
            Room::Side => {
                rt.println(if rt.has_key {
                    "There is nothing here."
                } else {
                    "There is a key on the floor."
                });
                rt.wait()?;
                let pick_up_key = rt.multiple_choice_named(
                    "What do you want to do?",
                    Some(("Pick up the key", true))
                        .filter(|_| !rt.has_key)
                        .into_iter()
                        .chain(Some(("Go back through the door", false))),
                )?;
                if pick_up_key {
                    rt.has_key = true;
                    next(Room::Side)
                } else {
                    next(Room::Start)
                }
            }
            Room::Exit => {
                rt.println("There is another door with a bright light behind it.");
                rt.wait()?;
                let try_to_leave = rt.multiple_choice_named(
                    "Where do you want to go?",
                    vec![
                        ("Through the door ahead", true),
                        ("Back through the door you came in", false),
                    ],
                )?;
                if try_to_leave {
                    if rt.has_key {
                        rt.println("The door is locked. You unlock the door with your key.");
                        rt.wait()?;
                        rt.println("You escaped! You win!");
                        rt.wait()?;
                        exit()
                    } else {
                        rt.println("The door is locked.");
                        rt.wait()?;
                        next(Room::Exit)
                    }
                } else {
                    next(Room::Start)
                }
            }
        }
    }
}

#[derive(Clone)]
struct Inventory;

impl Node for Inventory {
    type State = State;
    fn next<F>(self, rt: &mut Runtime<Self, F>) -> Control<Self>
    where
        F: Frontend,
    {
        if rt.has_key {
            rt.println("You have a key");
        } else {
            rt.println("You have nothing");
        }
        exit()
    }
}

fn main() {
    run(
        Room::Start,
        &mut State { has_key: false },
        &mut CliFrontend::new(),
    )
    .command("save", |rt| {
        match rt.save("rooms.yaml") {
            Ok(_) => rt.println("Save complete"),
            Err(e) => rt.println(format!("Error: {}", e)),
        }
        Continue
    })
    .command("load", |rt| {
        match rt.load("rooms.yaml") {
            Ok(_) => rt.println("Load complete"),
            Err(e) => rt.println(format!("Error: {}", e)),
        }
        Skip
    })
    .command("inv, inventory", |rt| rt.push_node(Inventory));
}