gridit 0.1.0

2D grid library utilizing the fun of iterators
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

use super::{BoardPiece, PColor, Piece};
use ggez::graphics;
use gridit::pattern::{DirectionPattern, Repeat};
use gridit::{Grid, Position, PositionsEnumerator};

pub struct Queen {
    img: graphics::Image,
    pcolor: PColor,
}

impl Queen {
    pub fn new(pcolor: PColor, img: graphics::Image) -> Self {
        Self { pcolor, img }
    }
}

impl Piece for Queen {
    fn image(&self) -> &graphics::Image {
        &self.img
    }

    fn possible_moves(&self, grid: &Grid<BoardPiece>, pos: Position) -> Vec<Position> {
        let patterns = [
            DirectionPattern::new((0, 1), Repeat::TillEnd),
            DirectionPattern::new((0, -1), Repeat::TillEnd),
            DirectionPattern::new((1, 0), Repeat::TillEnd),
            DirectionPattern::new((-1, 0), Repeat::TillEnd),
            DirectionPattern::new((1, 1), Repeat::TillEnd),
            DirectionPattern::new((-1, -1), Repeat::TillEnd),
            DirectionPattern::new((1, -1), Repeat::TillEnd),
            DirectionPattern::new((-1, 1), Repeat::TillEnd),
        ];

        patterns
            .iter()
            .map(|pattern| {
                let mut prev: &Option<Box<dyn Piece + 'static>> = &None;
                grid.pattern(pos, *pattern)
                    .grid_positions()
                    .take_while(|(_, o)| {
                        if matches!(prev, Some(p) if p.pcolor() != self.pcolor) {
                            return false;
                        }
                        if self.same_pcolor(o) {
                            return false;
                        }
                        prev = &o;
                        true
                    })
                    .map(|(p, _)| p)
                    .collect::<Vec<Position>>()
            })
            .flatten()
            .collect()
    }

    fn pcolor(&self) -> PColor {
        self.pcolor
    }
}