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

use crossterm::event::{poll, read, Event, KeyCode};
use crossterm::terminal::{
    disable_raw_mode, enable_raw_mode, size, Clear, ClearType, EnterAlternateScreen,
    LeaveAlternateScreen,
};
use crossterm::{cursor, execute, Command};
use gridit::Grid;
use std::fmt;
use std::io::stdout;
use std::time::Duration;

#[derive(Clone, PartialEq)]
enum Cell {
    Dead,
    Alive,
}

#[derive(Clone, PartialEq)]
struct PodCell {
    pub current: Cell,
    pub future: Cell,
}

impl PodCell {
    fn new(c: Cell) -> Self {
        PodCell {
            current: c.clone(),
            future: c,
        }
    }

    fn update(&mut self) {
        self.current = self.future.clone();
    }
}

impl Cell {
    fn to_char(&self) -> char {
        match *self {
            Cell::Dead => ' ',
            Cell::Alive => '█',
        }
    }
}

fn main() -> crossterm::Result<()> {
    enable_raw_mode()?;
    execute!(stdout(), cursor::Hide)?;
    execute!(stdout(), EnterAlternateScreen)?;
    execute!(stdout(), Clear(ClearType::All))?;

    let (rows, cols) = size()?;
    let (row_size, col_size) = (rows as usize, cols as usize);
    //let (row_size, col_size) = (10, 10);
    let (mid_x, mid_y) = ((row_size - 1) / 2, (col_size - 1) / 2);

    let mut grid: Grid<PodCell> = Grid::new(row_size, col_size, PodCell::new(Cell::Dead));
    grid.set_unchecked((mid_x, mid_y - 1), PodCell::new(Cell::Alive));
    grid.set_unchecked((mid_x, mid_y), PodCell::new(Cell::Alive));
    grid.set_unchecked((mid_x, mid_y + 1), PodCell::new(Cell::Alive));

    loop {
        if poll(Duration::from_millis(500))? {
            let event = read()?;
            if event == Event::Key(KeyCode::Esc.into()) {
                break;
            }

            if let Event::Resize(c, r) = event {
                println!("Rezize to {} {}", r, c);
            }
        }

        for position in grid.positions() {
            let neighbor_count = grid
                .neighbors(position)
                .filter(|c| c.current == Cell::Alive)
                .count();
            let current = grid.get_unchecked(position).current.clone();
            let mut cell = grid.get_mut_unchecked(position);

            match (&current, neighbor_count) {
                (Cell::Alive, 1) => cell.future = Cell::Dead,
                (Cell::Alive, 2..=3) => cell.future = Cell::Alive,
                (Cell::Dead, 3) => cell.future = Cell::Alive,
                (Cell::Alive, 4..=9) => cell.future = Cell::Dead,
                _ => (),
            }
        }
        grid.iter_mut().for_each(|pod| pod.update());

        let grid_string: String = grid.iter().map(|c| c.current.to_char()).collect();
        execute!(stdout(), GridPrinter(&grid_string))?;
    }

    execute!(stdout(), LeaveAlternateScreen)?;
    execute!(stdout(), cursor::Show)?;
    disable_raw_mode()?;
    Ok(())
}

struct GridPrinter<'a>(&'a str);

impl<'a> Command for GridPrinter<'a> {
    fn write_ansi(&self, f: &mut impl fmt::Write) -> fmt::Result {
        execute!(stdout(), cursor::MoveTo(0, 0)).expect("Could not move cursor to 0,0");
        f.write_str(&self.0)
    }
}