mazer 0.0.13

Library for generating and solving mazes of various maze algorithms and grid types
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

use serde::{Serialize, Deserialize};
use std::fmt;
use std::convert::TryFrom;
use crate::cell::MazeType;

#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum Direction {
    // Orthogonal & intercardinal
    Up, Right, Down, Left,
    UpperRight, LowerRight, LowerLeft, UpperLeft,
}

impl fmt::Display for Direction {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let s = match self {
            Direction::Up               => "Up",
            Direction::Right            => "Right",
            Direction::Down             => "Down",
            Direction::Left             => "Left",
            Direction::UpperRight       => "UpperRight",
            Direction::LowerRight       => "LowerRight",
            Direction::LowerLeft        => "LowerLeft",
            Direction::UpperLeft        => "UpperLeft",
        };
        write!(f, "{}", s)
    }
}

impl TryFrom<&str> for Direction {
    type Error = crate::Error;
    fn try_from(s: &str) -> Result<Self, Self::Error> {
        Ok(match s {
            "Up"               => Direction::Up,
            "Right"            => Direction::Right,
            "Down"             => Direction::Down,
            "Left"             => Direction::Left,
            "UpperRight"       => Direction::UpperRight,
            "LowerRight"       => Direction::LowerRight,
            "LowerLeft"        => Direction::LowerLeft,
            "UpperLeft"        => Direction::UpperLeft,
            other =>
                return Err(crate::Error::InvalidDirection { direction: other.to_string() }),
        })
    }
}

impl TryFrom<u32> for Direction {
    type Error = crate::Error;
    fn try_from(code: u32) -> Result<Self, Self::Error> {
        use Direction::*;
        Ok(match code {
            0  => Up,
            1  => Right,
            2  => Down,
            3  => Left,
            4  => UpperRight,
            5  => LowerRight,
            6  => LowerLeft,
            7  => UpperLeft,
            _  => return Err(crate::Error::InvalidDirection { direction: code.to_string() }),
        })
    }
}

impl Direction {
    /// “Which of these variants are legal for a given MazeType?”
    pub fn valid_for(&self, maze_type: MazeType) -> bool {
        use Direction::*;
        match maze_type {
            MazeType::Orthogonal => matches!(self, Up | Right | Down | Left),
            MazeType::Sigma      => matches!(self, Up | Right | Down | Left | UpperRight | LowerRight | LowerLeft | UpperLeft),
            MazeType::Delta      => matches!(self, Up | Down | UpperLeft | UpperRight | LowerLeft | LowerRight),
            MazeType::Upsilon    => matches!(self, Up | Right | Down | Left | UpperRight | LowerRight | LowerLeft | UpperLeft),
            MazeType::Rhombic  => matches!(self, UpperRight | LowerRight | LowerLeft | UpperLeft),
        }
    }

    pub fn all() -> &'static [Direction] {
        use Direction::*;
        &[
            Up, Right, Down, Left,
            UpperRight, LowerRight, LowerLeft, UpperLeft,
        ]
    }

    /// Only the six flat-top neighbors for a Sigma (hex) maze.
    pub fn sigma_neighbors() -> &'static [Direction] {
        use Direction::*;
        &[ Up, UpperRight, LowerRight, Down, LowerLeft, UpperLeft ]
    }

    /// For flat-top hexes in odd-q layout, returns (dq, dr).
    /// Only valid for the six hex directions; others map to (0,0).
    pub fn offset_delta(&self, is_odd_column: bool) -> (isize, isize) {
        match self {
            Direction::Up           => ( 0, -1),
            Direction::Down         => ( 0,  1),
            Direction::UpperRight   => {
                if is_odd_column { (1, 0) } else { (1, -1) }
            }
            Direction::LowerRight   => {
                if is_odd_column { (1, 1) } else { (1,  0) }
            }
            Direction::UpperLeft    => {
                if is_odd_column { (-1, 0) } else { (-1, -1) }
            }
            Direction::LowerLeft    => {
                if is_odd_column { (-1, 1) } else { (-1,  0) }
            }
            _ => (0, 0),
        }
    }

    /// The opposite direction.
    pub fn opposite(&self) -> Direction {
        match self {
            Direction::Up               => Direction::Down,
            Direction::Down             => Direction::Up,
            Direction::UpperRight       => Direction::LowerLeft,
            Direction::LowerLeft        => Direction::UpperRight,
            Direction::LowerRight       => Direction::UpperLeft,
            Direction::UpperLeft        => Direction::LowerRight,
            Direction::Right            => Direction::Left,
            Direction::Left             => Direction::Right,
        }
    }

    /// Which two flat-top unit-point indices form the wall edge
    /// for this direction (0..5 indexing your unitPoints array).
    pub fn vertex_indices(&self) -> (usize, usize) {
        match self {
            Direction::Up           => (0, 1),
            Direction::UpperRight   => (1, 2),
            Direction::LowerRight   => (2, 3),
            Direction::Down         => (3, 4),
            Direction::LowerLeft    => (4, 5),
            Direction::UpperLeft    => (5, 0),
            _ => (0, 0),
        }
    }

}