Rendering a random assortment of blocks

This demonstrates use of the TUI library and helped me regain some basic
rust familiarity

Author: scottnm

.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

Cargo.lock

@@ -5,3 +5,5 @@ authors = ["Scott Munro <scottnmunro@gmail.com>"]
 edition = "2018"
 
 [dependencies]
+pancurses = "0.16"
+rand = "0.7.0"

Cargo.toml

@@ -10,26 +10,28 @@
 ## Goals
 
 - Basic tetris mechanics
-    - tetrimino gravity
-    - rotating tetriminos
-    - dropping tetriminos
+    - tetromino gravity
+    - rotating tetrominos
+    - dropping tetrominos
     - clearing lines
     - score
     - end game when top of screen reached
 
 - Extensions
     - game music
+    - ai/autoplay
+    - ai/competitive
     - multiplayer
     - network multiplayer
 
 ### Steps
 
-- Get a tetrimino to render
-- Get a tetrimino to fall
-- Get a tetrimino to stick
-- Get two tetriminos to stack
-- Allow clearing lines
-- Generate/Preview random blocks
-- Handle game lose state
-- Handle scoring
+- [X] Get a tetromino to render
+- [ ] Get a tetromino to fall
+- [ ] Get a tetromino to stick
+- [ ] Get two tetrominos to stack
+- [ ] Allow clearing lines
+- [ ] Generate/Preview random blocks
+- [ ] Handle game lose state
+- [ ] Handle scoring
 

doc.md

@@ -0,0 +1,92 @@
+extern crate rand;
+use rand::{rngs, Rng};
+
+#[derive(Clone, Copy)]
+pub enum BlockType {
+    I,
+    O,
+    T,
+    S,
+    Z,
+    J,
+    L,
+}
+
+pub static BLOCKTYPES: [BlockType; 7] = [
+    BlockType::I,
+    BlockType::O,
+    BlockType::T,
+    BlockType::S,
+    BlockType::Z,
+    BlockType::J,
+    BlockType::L,
+];
+
+impl BlockType {
+    pub fn random(rng: &mut rngs::ThreadRng) -> BlockType {
+        BLOCKTYPES[rng.gen_range(0, BLOCKTYPES.len())]
+    }
+
+    pub fn to_char(&self) -> char {
+        match *self {
+            BlockType::I => 'O',
+            BlockType::O => 'X',
+            BlockType::T => '+',
+            BlockType::S => '>',
+            BlockType::Z => '<',
+            BlockType::J => '/',
+            BlockType::L => '\\',
+        }
+    }
+
+    #[rustfmt::skip]
+    pub fn to_block_array(&self) -> [(i32, i32); 4] {
+        match *self {
+            BlockType::I =>
+                [
+                    (0, 0),
+                    (1, 0),
+                    (2, 0),
+                    (3, 0),
+                ],
+
+            BlockType::O =>
+                [
+                    (0, 0), (0, 1),
+                    (1, 0), (1, 1),
+                ],
+
+            BlockType::T =>
+                [
+                    (0, 0), (0, 1), (0, 2),
+                            (1, 1),
+                ],
+
+            BlockType::S =>
+                [
+                            (0, 1), (0, 2),
+                    (1, 0), (1, 1),
+                ],
+
+            BlockType::Z =>
+                [
+                    (0, 0), (0, 1),
+                            (1, 1), (1, 2),
+                ],
+
+            BlockType::J =>
+                [
+                            (0, 1),
+                            (1, 1),
+                    (2, 0), (2, 1),
+                ],
+
+            BlockType::L =>
+                [
+                    (0, 0),
+                    (1, 0),
+                    (2, 0), (2, 1),
+                ],
+        }
+    }
+}

src/block.rs

@@ -1,3 +1,41 @@
+mod block;
+use crate::block::*;
+
+extern crate pancurses;
+extern crate rand;
+
+use pancurses::{endwin, initscr, Window};
+use rand::{thread_rng, Rng};
+use std::{thread, time};
+
+fn in_bounds(window: &Window, row: i32, col: i32) -> bool {
+    row >= 0 && row < window.get_max_y() && col >= 0 && col < window.get_max_x()
+}
+
+fn render_block(window: &Window, row: i32, col: i32, b: BlockType) {
+    let block_char = b.to_char();
+    let tetromino_pos = b.to_block_array();
+    for block_pos in tetromino_pos.iter() {
+        if in_bounds(window, block_pos.0, block_pos.1) {
+            window.mvaddch(block_pos.0 + row, block_pos.1 + col, block_char);
+        }
+    }
+}
+
 fn main() {
-    println!("Hello, world!");
+    let window = initscr();
+    let mut rng = thread_rng();
+    for _dashgroup in 0..10 {
+        window.erase();
+        for _dashiter in 0..5 {
+            let x: i32 = rng.gen_range(0, window.get_max_x());
+            let y: i32 = rng.gen_range(0, window.get_max_y());
+            render_block(&window, y, x, BlockType::random(&mut rng));
+
+            thread::sleep(time::Duration::from_millis(200));
+            window.refresh();
+        }
+    }
+    window.getch();
+    endwin();
 }