textris 0.2.0

Tetris on terminal!
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
144
145
146
147
148
149

use std::ops::{Add, AddAssign};

#[derive(Debug, Clone, Copy)]
pub struct Coord(pub i8, pub i8);

impl Coord {
    pub fn new(x: i8, y: i8) -> Self {
        Coord(x, y)
    }

    pub fn x(&self) -> i8 {
        self.0
    }

    pub fn y(&self) -> i8 {
        self.1
    }
}

impl Add for Coord {
    type Output = Self;
    fn add(self, rhs: Self) -> Self::Output {
        Coord(self.0 + rhs.0, self.1 + rhs.1)
    }
}

impl AddAssign for Coord {
    fn add_assign(&mut self, rhs: Self) {
        self.0 += rhs.0;
        self.1 += rhs.1;
    }
}

impl Default for Coord {
    fn default() -> Self {
        Coord(0, 0)
    }
}

pub type Dirs = [Dir; 4];

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Dir {
    Up,
    Right,
    Down,
    Left,
}

impl Dir {
    pub fn all() -> Dirs {
        [Dir::Up, Dir::Right, Dir::Down, Dir::Left]
    }

    pub fn to_coord(&self) -> Coord {
        match self {
            Dir::Up => Coord(0, -1),
            Dir::Right => Coord(1, 0),
            Dir::Down => Coord(0, 1),
            Dir::Left => Coord(-1, 0),
        }
    }

    pub fn next_dir(&self) -> Dir {
        match self {
            Dir::Up => Dir::Right,
            Dir::Right => Dir::Down,
            Dir::Down => Dir::Left,
            Dir::Left => Dir::Up,
        }
    }

    pub fn opponent(&self) -> Dir {
        match self {
            Dir::Up => Dir::Down,
            Dir::Right => Dir::Left,
            Dir::Down => Dir::Up,
            Dir::Left => Dir::Right,
        }
    }
}

impl Default for Dir {
    fn default() -> Self {
        Dir::Up
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum RotateDir {
    Clockwise,
    AntiClockwise,
}

impl RotateDir {
    pub fn rotate(&self, dir: Dir) -> Dir {
        let dir = dir.next_dir();
        match self {
            RotateDir::Clockwise => dir,
            RotateDir::AntiClockwise => dir.opponent(),
        }
    }
}

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

    #[test]
    fn rotate_dir_rotate() {
        struct Case<'a> {
            title: &'a str,
            rd: RotateDir,
            dirs: (Dir, Dir),
        }
        let cases = [
            Case {
                title: "clockwise: Right -> Down",
                rd: RotateDir::Clockwise,
                dirs: (Right, Down),
            },
            Case {
                title: "clockwise: Left -> Up",
                rd: RotateDir::Clockwise,
                dirs: (Left, Up),
            },
            Case {
                title: "anti: Right -> Up",
                rd: RotateDir::AntiClockwise,
                dirs: (Right, Up),
            },
            Case {
                title: "anti: Left -> Down",
                rd: RotateDir::AntiClockwise,
                dirs: (Left, Down),
            },
        ];

        for Case {
            title,
            rd,
            dirs: (from, to),
        } in cases.iter()
        {
            assert_eq!(rd.rotate(*from), *to, "{}", title);
        }
    }
}