kingslayer 0.5.5

A text adventure dungeon crawler game written in Rust
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

use rayon::prelude::*;

use serde::{Deserialize, Serialize};

use super::{Closeable, DoorLock, Durability, Entity, Lockable, Opening};
use crate::{
    dice_roll,
    types::{Action, CmdResult},
};

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Pathway {
    directions: Vec<String>,
    target: String,
    #[serde(default)]
    desc: String,
    #[serde(default)]
    inspect: String,
    opening: Option<Opening>,
    lock: Option<DoorLock>,
    #[serde(default)]
    durability: Durability,
}

impl Pathway {
    pub fn long_desc(&self) -> String {
        if let Some(opening) = self.opening {
            match opening {
                Opening::Open => format!("{} The way is open.", self.desc),
                Opening::Closed => format!("{} The way is shut.", self.desc),
            }
        } else {
            self.desc.to_owned()
        }
    }

    pub fn any_direction(&self, dir_name: &str) -> bool {
        if cfg!(target_arch = "wasm32") {
            self.directions
                .iter()
                .map(|direction| direction.split_whitespace().collect())
                .any(|direction: Vec<&str>| {
                    dir_name
                        .par_split_whitespace()
                        .all(|ref word| direction.contains(word))
                })
        } else {
            self.directions
                .par_iter()
                .map(|direction| direction.par_split_whitespace().collect())
                .any(|direction: Vec<&str>| {
                    dir_name
                        .par_split_whitespace()
                        .all(|ref word| direction.contains(word))
                })
        }
    }
}

impl Entity for Pathway {
    fn name(&self) -> &str {
        &self.target
    }

    fn desc(&self) -> &str {
        &self.desc
    }

    fn inspect(&self) -> &str {
        &self.inspect
    }
}

impl Closeable for Pathway {
    fn open(&mut self) -> CmdResult {
        if let Some(opening) = self.opening {
            if opening.is_closed() {
                self.opening = Some(Opening::Open);
                CmdResult::new(Action::Active, "Opened.")
            } else {
                CmdResult::new(Action::Passive, String::from("The way is already open."))
            }
        } else {
            CmdResult::new(Action::Passive, String::from("The way is already open."))
        }
    }

    fn close(&mut self) -> CmdResult {
        if let Some(opening) = self.opening {
            if opening.is_open() {
                self.opening = Some(Opening::Closed);
                CmdResult::new(Action::Active, "Closed.")
            } else {
                CmdResult::new(Action::Passive, String::from("The way cannot be closed."))
            }
        } else {
            CmdResult::new(Action::Passive, String::from("The way cannot be closed."))
        }
    }

    fn is_closed(&self) -> bool {
        if let Some(opening) = self.opening {
            opening.is_closed()
        } else {
            false
        }
    }
}

impl Lockable for Pathway {
    fn unlock(&mut self) -> CmdResult {
        if let Some(lock) = &self.lock {
            if lock.is_locked() {
                if dice_roll(1, 20) > 10 {
                    self.lock = Some(DoorLock::Unlocked);
                    CmdResult::new(Action::Active, "Unlocked.")
                } else {
                    CmdResult::new(
                        Action::Active,
                        "You failed to pick the lock. This is harder than it looks.",
                    )
                }
            } else {
                CmdResult::new(
                    Action::Passive,
                    String::from("The way is already unlocked."),
                )
            }
        } else {
            CmdResult::new(
                Action::Passive,
                String::from("The way is already unlocked."),
            )
        }
    }

    fn lock(&mut self) -> CmdResult {
        CmdResult::new(Action::Passive, "TODO: lock it")
    }

    fn is_locked(&self) -> bool {
        if let Some(lock) = &self.lock {
            lock.is_locked()
        } else {
            false
        }
    }
}