blocks fall now. Oh boyyyyyy

Author: scottnm

Cargo.lock

@@ -7,3 +7,4 @@ edition = "2018"
 [dependencies]
 pancurses = "0.16"
 rand = "0.7.0"
+arrayvec = "0.4.10"

Cargo.toml

@@ -26,9 +26,10 @@
 
 ### Steps
 
-- [X] Get a tetromino to render
+- [X] Get a tetromino to render: 76babe55
 ![Image of text-tetrominoes rendering](demo/1-render.gif)
-- [ ] Get a tetromino to fall
+- [X] Get a tetromino to fall: <insert hash here>
+![Image of text-tetrominoes falling](demo/2-fall.gif)
 - [ ] Get a tetromino to stick
 - [ ] Get two tetrominos to stack
 - [ ] Allow clearing lines

demo/2-fall.gif

@@ -27,7 +27,7 @@ impl BlockType {
         BLOCKTYPES[rng.gen_range(0, BLOCKTYPES.len())]
     }
 
-    pub fn to_char(&self) -> char {
+    pub fn block_char(&self) -> char {
         match *self {
             BlockType::I => 'O',
             BlockType::O => 'X',
@@ -39,8 +39,8 @@ impl BlockType {
         }
     }
 
-    #[rustfmt::skip]
-    pub fn to_block_array(&self) -> [(i32, i32); 4] {
+    #[rustfmt::skip] // skip rust formatting so that my block declarations can look pleasant
+    pub fn block_cells(&self) -> [(i32, i32); 4] {
         match *self {
             BlockType::I =>
                 [

readme.md

@@ -1,9 +1,11 @@
 mod block;
 use crate::block::*;
 
+extern crate arrayvec;
 extern crate pancurses;
 extern crate rand;
 
+use arrayvec::ArrayVec;
 use pancurses::{endwin, initscr, Window};
 use rand::{thread_rng, Rng};
 use std::{thread, time};
@@ -12,30 +14,73 @@ 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 render_block(window: &Window, (row, col): (i32, i32), block_type: BlockType) {
+    let block_char = block_type.block_char();
+    let block_cells = block_type.block_cells();
+    for cell in block_cells.iter() {
+        if in_bounds(window, cell.0, cell.1) {
+            window.mvaddch(cell.0 + row, cell.1 + col, block_char);
         }
     }
 }
 
 fn main() {
+    const BLOCK_GENERATION_PERIOD: time::Duration = time::Duration::from_millis(500); // generate a new block once a second
+    const BLOCK_MOVE_PERIOD: time::Duration = time::Duration::from_millis(250);
+    const MAX_BLOCKS: usize = 20;
+    const RUN_TIME: time::Duration = time::Duration::from_secs(10); // run long enough to generate all blocks
+    const RENDER_REFRESH_PERIOD: time::Duration = time::Duration::from_millis(16); // 60 fps
+
     let window = initscr();
     let mut rng = thread_rng();
-    for _dashgroup in 0..10 {
+
+    let start_time = time::Instant::now();
+    let mut last_block_generation_timestamp = time::Instant::now();
+    let mut last_move_timestamp = time::Instant::now();
+
+    let mut block_types = ArrayVec::<[BlockType; MAX_BLOCKS]>::new();
+    let mut block_positions = ArrayVec::<[(i32, i32); MAX_BLOCKS]>::new();
+
+    while start_time.elapsed() < RUN_TIME {
+        //
+        // Game logic:
+        // - generate a new block periodically
+        // - move every block periodically
+        //
+        if last_block_generation_timestamp.elapsed() >= BLOCK_GENERATION_PERIOD {
+            assert!(!block_types.is_full());
+            assert!(!block_positions.is_full());
+
+            let new_block_type = BlockType::random(&mut rng);
+            let start_row: i32 = rng.gen_range(0, window.get_max_y());
+            let start_col: i32 = rng.gen_range(0, window.get_max_x());
+
+            block_types.push(new_block_type);
+            block_positions.push((start_row, start_col));
+
+            last_block_generation_timestamp = time::Instant::now();
+        }
+
+        if last_move_timestamp.elapsed() >= BLOCK_MOVE_PERIOD {
+            for pos in &mut block_positions {
+                pos.0 += 1;
+            }
+            last_move_timestamp = time::Instant::now();
+        }
+
+        //
+        // Render the frame
+        //
         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();
+        assert_eq!(block_types.len(), block_positions.len());
+        for block_id in 0..block_types.len() {
+            render_block(&window, block_positions[block_id], block_types[block_id]);
         }
+
+        window.refresh();
+        thread::sleep(RENDER_REFRESH_PERIOD);
     }
-    window.getch();
+
     endwin();
 }