next pieces

src/main.rs

@@ -110,28 +110,40 @@ impl Tetrimino {
 }
 
 struct TetriminoGenerator {
-    remaining: VecDeque<TetriminoKind>
+    remaining: VecDeque<Tetrimino>
 }
 
 impl TetriminoGenerator {
     fn new() -> Self {
         Self { remaining: VecDeque::new() }
     }
+    
+    fn reserve(&mut self, n: usize) {
+        use TetriminoKind::*;
+        while self.remaining.len() < n {
+            let mut next_bag = [I, O, T, S, Z, J, L];
+            next_bag.shuffle(&mut rand::thread_rng());
+            self.remaining.extend(next_bag.into_iter().map(|v| Tetrimino {
+                kind: v,
+                rotation: Rotation::Spawn
+            }));
+        }
+    }
+
+    fn remaining(&mut self) -> &[Tetrimino] {
+        self.remaining.make_contiguous();
+        self.remaining.as_slices().0
+    }
 }
 
 impl Iterator for TetriminoGenerator {
     type Item = Tetrimino;
 
     fn next(&mut self) -> Option<Self::Item> {
-        if self.remaining.is_empty() {
-            use TetriminoKind::*;
-            let mut next_bag = [I, O, T, S, Z, J, L];
-            next_bag.shuffle(&mut rand::thread_rng());
-            self.remaining.extend(next_bag);
-        }
+        self.reserve(1);
 
         // kinda useless to unwrap but its better to panic than to run out of tetriminoes
-        Some(Tetrimino { kind: self.remaining.pop_front().unwrap(), rotation: Rotation::Spawn })
+        Some(self.remaining.pop_front().unwrap())
     }
 }
 
@@ -149,8 +161,9 @@ fn init_colors() {
     init_pair(COLOR_WHITE, COLOR_WHITE, -1);
 }
 
-fn write_tetrimino(t: TetriminoData, window: &Window, mut x: i32, mut y: i32) {
-    for row in t {
+fn write_tetrimino(t: Tetrimino, window: &Window, mut x: i32, mut y: i32) {
+    window.color_set(t.color().into_color_pair());
+    for row in t.data() {
         for cell in *row {
             if y >= 0 && *cell {
                 window.mvprintw(y, x, "██");
@@ -243,11 +256,6 @@ fn main() {
 
     window.refresh();
 
-    for y in 0..20 {
-        window.mvprintw(y, 20, "|");
-    }
-    window.mvprintw(20, 0, "--------------------+");
-
     let mut rando = TetriminoGenerator::new();
 
     macro_rules! reset {
@@ -373,11 +381,25 @@ fn main() {
                 ghost_y += 1;
             }
 
+            window.clear();
+            window.color_set(COLOR_WHITE);
+            window.mvprintw(0, 0, include_str!("./outline.txt"));
             print_board(board, &window);
             window.color_set(COLOR_WHITE);
             write_tetrimino_ghost(tetrimino.into(), &window, 2 * x, ghost_y - 20);
-            window.color_set(tetrimino.color().into_color_pair());
-            write_tetrimino(tetrimino.into(), &window, 2 * x, y - 20);
+            
+            write_tetrimino(tetrimino, &window, 2 * x, y - 20);
+
+            rando.reserve(6);
+            
+            write_tetrimino(rando.remaining()[0], &window, 23, 0);
+            write_tetrimino(rando.remaining()[1], &window, 23, 4);
+            write_tetrimino(rando.remaining()[2], &window, 23, 7);
+            write_tetrimino(rando.remaining()[3], &window, 23, 10);
+            write_tetrimino(rando.remaining()[4], &window, 23, 13);
+            write_tetrimino(rando.remaining()[5], &window, 23, 16);
+
+            window.refresh();
         }
 
         thread::sleep(Duration::from_millis(10));

src/outline.txt

@@ -0,0 +1,21 @@
+                    ⎥ ⎥        ⎥
+                    ⎥ ⎝        ⎠
+                    ⎥  ‾‾‾‾‾‾‾‾
+                    ⎥  ________
+                    ⎥ ⎛        ⎞
+                    ⎥ ⎥        ⎥
+                    ⎥ ⎥        ⎥
+                    ⎥ ⎥        ⎥
+                    ⎥ ⎥        ⎥
+                    ⎥ ⎥        ⎥
+                    ⎥ ⎥        ⎥
+                    ⎥ ⎥        ⎥
+                    ⎥ ⎥        ⎥
+                    ⎥ ⎥        ⎥
+                    ⎥ ⎥        ⎥
+                    ⎥ ⎥        ⎥
+                    ⎥ ⎥        ⎥
+                    ⎥ ⎝        ⎠
+                    ⎥  ‾‾‾‾‾‾‾‾
+                    ⎠
+‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾