grue 0.1.0

Various tools and algorithms for building role-playing and adventure games
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

use rand::prelude::*;

macro_rules! random_choice {
	($self_:ident, $a:ident) => {
		if $self_.$a.len() > 0 {
			let mut rng = thread_rng();
			let choice = rng.gen_range(0, $self_.$a.len());
			$self_.$a[choice].to_owned()
		} else {
			String::default()
			}
	};
}

#[derive(Debug, Default, Clone, Deserialize)]
pub struct MysticOrder {
	pub patterns: Vec<String>,
	pub cliques: Vec<String>,
	pub people: Vec<String>,
	pub qualities: Vec<String>,
	pub colours: Vec<String>,
	pub entities: Vec<String>,
}

impl MysticOrder {
	pub fn new(
		patterns: &[String],
		cliques: &[String],
		people: &[String],
		qualities: &[String],
		colours: &[String],
		entities: &[String],
	) -> MysticOrder {
		MysticOrder {
			patterns: patterns.to_vec(),
			cliques: cliques.to_vec(),
			people: people.to_vec(),
			qualities: qualities.to_vec(),
			colours: colours.to_vec(),
			entities: entities.to_vec(),
		}
	}

	pub fn random_pattern(&self) -> String {
		random_choice!(self, patterns)
	}

	pub fn random_descriptive(&self) -> String {
		// 50/50 for quality vs. colour
		let mut rng = thread_rng();
		if rng.gen() {
			self.random_quality()
		} else {
			self.random_colour()
		}
	}

	pub fn random_group(&self) -> String {
		// 50/50 for cliques vs. people
		let mut rng = thread_rng();
		if rng.gen() {
			self.random_clique()
		} else {
			self.random_person()
		}
	}

	pub fn random_clique(&self) -> String {
		random_choice!(self, cliques)
	}

	pub fn random_person(&self) -> String {
		random_choice!(self, people)
	}

	pub fn random_quality(&self) -> String {
		random_choice!(self, qualities)
	}

	pub fn random_colour(&self) -> String {
		random_choice!(self, colours)
	}

	pub fn random_entity(&self) -> String {
		random_choice!(self, entities)
	}
}