hex_renderer 0.2.6

Renderer for patterns in hexcasting (a mod for minecraft)
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

use super::Angle;
use std::ops::Add;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Direction {
    NorthEast = 0,
    East = 1,
    SouthEast = 2,
    SouthWest = 3,
    West = 4,
    NorthWest = 5,
}

impl Add<Angle> for Direction {
    type Output = Self;

    fn add(self, rhs: Angle) -> Self::Output {
        ((self as u8 + rhs as u8) % 6).try_into().unwrap()
    }
}

impl TryFrom<(i32, i32)> for Direction {
    type Error = ();

    fn try_from(value: (i32, i32)) -> Result<Self, Self::Error> {
        match value {
            (1, 0) => Ok(Self::East),
            (-1, 0) => Ok(Self::West),

            (1, -1) => Ok(Direction::NorthEast),
            (-1, 1) => Ok(Direction::SouthWest),

            (0, 1) => Ok(Direction::SouthEast),
            (0, -1) => Ok(Direction::NorthWest),

            _ => Err(()),
        }
    }
}

impl Direction {
    #[allow(dead_code)]
    pub fn get_reverse(self) -> Self {
        match self {
            Self::East => Self::West,
            Self::West => Self::East,

            Self::NorthEast => Self::SouthWest,
            Self::SouthWest => Self::NorthEast,

            Self::NorthWest => Self::SouthEast,
            Self::SouthEast => Self::NorthWest,
        }
    }
}
#[derive(Debug)]
pub enum DirectionParseError {
    InvalidNumber(u8),
    InvalidStr(String),
}
impl TryFrom<u8> for Direction {
    type Error = DirectionParseError;

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(Direction::NorthEast),
            1 => Ok(Direction::East),
            2 => Ok(Direction::SouthEast),
            3 => Ok(Direction::SouthWest),
            4 => Ok(Direction::West),
            5 => Ok(Direction::NorthWest),
            _ => Err(Self::Error::InvalidNumber(value)),
        }
    }
}

impl TryFrom<&str> for Direction {
    type Error = DirectionParseError;

    fn try_from(value: &str) -> Result<Self, Self::Error> {
        match &value.to_lowercase()[..] {
            "east" | "e" => Ok(Direction::East),
            "southeast" | "south_east" | "se" => Ok(Direction::SouthEast),
            "southwest" | "south_west" | "sw" => Ok(Direction::SouthWest),
            "west" | "w" => Ok(Direction::West),
            "northwest" | "north_west" | "nw" => Ok(Direction::NorthWest),
            "northeast" | "north_east" | "ne" => Ok(Direction::NorthEast),
            _ => Err(Self::Error::InvalidStr(value.to_string())),
        }
    }
}