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
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

//! Conversion utility functions.

/// Converts a hex char to a u8.
pub fn hex_char_to_int(ch: char) -> Option<u8> {
    ch.to_digit(16).map(|i| i as u8)
}

/// Converts a hex string to a u32.
/// The string can optionally start with '#'.
pub fn hex_str_to_int(s: &str) -> Option<u32> {
    let mut chars = s.chars();

    let res = match chars.next() {
        Some('#') => match chars.next() {
            Some(ch) => hex_char_to_int(ch)?,
            _ => return None,
        },
        Some(ch) => hex_char_to_int(ch)?,
        _ => return None,
    };
    let mut res = u32::from(res);
    let mut c = 1;

    loop {
        if c >= 8 {
            return None;
        }

        res = res * 16
            + match chars.next() {
                Some(ch) => u32::from(hex_char_to_int(ch)?),
                None => return Some(res),
            };
        c += 1;
    }
}

/// Converts a 6-digit hex color code to a (r, g, b) tuple of u8's.
/// The string can optionally start with '#'.
pub fn color_code_to_rgb(s: &str) -> Option<(u8, u8, u8)> {
    let mut chars = s.chars();

    let mut r = match chars.next() {
        Some('#') => match chars.next() {
            Some(ch) => hex_char_to_int(ch)?,
            _ => return None,
        },
        Some(ch) => hex_char_to_int(ch)?,
        _ => return None,
    };

    r = r * 16
        + match chars.next() {
            Some(ch) => hex_char_to_int(ch)?,
            _ => return None,
        };

    let mut g = match chars.next() {
        Some(ch) => hex_char_to_int(ch)?,
        _ => return None,
    };
    g = g * 16
        + match chars.next() {
            Some(ch) => hex_char_to_int(ch)?,
            _ => return None,
        };

    let mut b = match chars.next() {
        Some(ch) => hex_char_to_int(ch)?,
        _ => return None,
    };
    b = b * 16
        + match chars.next() {
            Some(ch) => hex_char_to_int(ch)?,
            _ => return None,
        };

    if chars.next().is_some() {
        return None;
    }

    Some((r, g, b))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_hex_char_to_int() {
        assert_eq!(hex_char_to_int('0'), Some(0));
        assert_eq!(hex_char_to_int('a'), Some(10));
        assert_eq!(hex_char_to_int('F'), Some(15));
        assert_eq!(hex_char_to_int('G'), None);
        assert_eq!(hex_char_to_int('#'), None);
    }

    #[test]
    fn test_hex_str_to_int() {
        assert_eq!(hex_str_to_int("#FF"), Some(255));
        assert_eq!(hex_str_to_int("FF"), Some(255));
        assert_eq!(hex_str_to_int("#0"), Some(0));
        assert_eq!(hex_str_to_int("0"), Some(0));

        assert_eq!(hex_str_to_int("G"), None);
        assert_eq!(hex_str_to_int("#"), None);
    }

    #[test]
    fn test_color_code_to_rgb() {
        let (r, g, b) = color_code_to_rgb("#ff00ff").unwrap();
        assert_eq!(r, 255);
        assert_eq!(g, 0);
        assert_eq!(b, 255);

        let (r, g, b) = color_code_to_rgb("0f0f00").unwrap();
        assert_eq!(r, 15);
        assert_eq!(g, 15);
        assert_eq!(b, 0);

        assert_eq!(color_code_to_rgb("#FF00"), None);
        assert_eq!(color_code_to_rgb("FF00FFF"), None);
        assert_eq!(color_code_to_rgb("FF00GG"), None);
    }
}