taurus 0.1.1

A WIP roguelike game being developed 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

//! Random number utility functions.

use num::rational::Ratio;
use num::{Bounded, Integer};
use rand;
use rand::distributions::range::SampleRange;
use rand::Rng;
use std::fmt::Display;

/// Trait allowing access to random elements and/or indices in implementing containers.
pub trait Choose<T> {
    /// Returns an element picked randomly from `&self`, or `None` if no elements exist.
    fn choose(&self) -> Option<&T>;

    /// Returns a valid index picked randomly from `&self`, or `None` if no index exists.
    fn choose_index(&self) -> Option<usize>;

    /// Returns a valid (value, index) tuple picked randomly, or `None` if none exist.
    fn choose_enumerate(&self) -> Option<(usize, &T)>;
}

impl<T> Choose<T> for Vec<T> {
    fn choose(&self) -> Option<&T> {
        rand::thread_rng().choose(self)
    }

    fn choose_index(&self) -> Option<usize> {
        if !self.is_empty() {
            Some(rand_int(0, self.len() - 1))
        } else {
            None
        }
    }

    fn choose_enumerate(&self) -> Option<(usize, &T)> {
        let i = self.choose_index();
        match i {
            Some(i) => Some((i, &self[i])),
            None => None,
        }
    }
}

/// Returns a random Integer in the range `[x, y]` inclusive.
pub fn rand_int<T>(x: T, y: T) -> T
where
    T: Integer + SampleRange,
{
    rand::thread_rng().gen_range(x, y + T::one())
}

/// Returns a random Ratio in the inclusive range `[x, y]` with the given denominator.
///
/// # Panics
/// This function can result in an overflow - use only for known inputs.
pub fn rand_ratio<T>(x: T, y: T, d: T) -> Ratio<T>
where
    T: Clone + Copy + Integer + SampleRange,
{
    Ratio::new(rand_int(x * d, y * d), d)
}

/// Returns true with `x` in `y` chance.
pub fn dice<T>(x: T, y: T) -> bool
where
    T: Copy + Display + Integer + SampleRange,
{
    debug_assert!(x <= y, format!("Assert failed: dice({}, {})", x, y));
    rand_int(T::one(), y) <= x
}

/// Returns true with `x` chance, where 0 <= `x` <= 1.
pub fn chance<T>(x: Ratio<T>) -> bool
where
    T: Bounded + Clone + Copy + Integer + SampleRange,
{
    let max = T::max_value() - T::one();
    Ratio::new(rand_int(T::min_value(), max), max) <= x
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::util::math::between;

    #[test]
    fn test_rand_int() {
        for _ in 1..100 {
            let (a, b) = (rand_int(0, 1000), rand_int(0, 1000));
            assert!(between(rand_int(a.min(b), a.max(b)), a, b))
        }
    }

    #[test]
    fn test_dice() {
        for _ in 1..100 {
            assert!(!dice(0, rand_int(1, 100)));
        }
    }
}