blockstorm 0.5.0

A Tetris CLI game with TUI
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 blockstorm::{
    draw_game, draw_game_over, Event, Game, MinoesError, OutOfBoundsError, OverlappingMinoesError,
    DOWN,
};
use std::{
    io,
    time::{Duration, Instant},
};
use termion::raw::IntoRawMode;
use tui::{backend::TermionBackend, Terminal};

const LOCK_DELAY: Duration = Duration::from_millis(500);

fn main() {
    let mut game = Game::default();
    let mut game_ended = false;

    let stdout = io::stdout().into_raw_mode().unwrap();
    let backend = TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend).unwrap();
    terminal.clear().unwrap();
    let mut last_piece_move = Instant::now();
    let mut game_paused = false;

    loop {
        let event = game.event_receiver.recv().unwrap();
        match event {
            Event::TimePassed => {
                if !game_ended && !game_paused {
                    match game.move_moving_piece(DOWN) {
                        Ok(_) => (),
                        Err(OutOfBoundsError) => {
                            let delay_passed = Instant::now() - last_piece_move > LOCK_DELAY;
                            if delay_passed {
                                last_piece_move = Instant::now();
                                match game.hard_drop_moving_piece() {
                                    Ok(_) => (),
                                    Err(MinoesError::OverlappingMinoes(OverlappingMinoesError)) => {
                                        draw_game_over(&mut terminal, &mut game).unwrap();
                                        game_ended = true;
                                    }
                                    Err(_) => panic!("Unexpected error"),
                                }
                            }
                        }
                    };
                }
            }
            Event::Quit => {
                terminal.clear().unwrap();
                break;
            }
            Event::MovePiece(direction) => {
                if !game_ended {
                    match direction {
                        blockstorm::TetrisDirection::Down => {}
                        _ => {
                            last_piece_move = Instant::now();
                        }
                    }
                    match game.move_moving_piece(direction) {
                        Ok(_) => (),
                        Err(_) => (),
                    };
                }
            }
            Event::RotatePiece(rotation) => {
                if !game_ended {
                    last_piece_move = Instant::now();
                    match game.rotate_moving_piece(&rotation) {
                        Ok(_) => (),
                        Err(_) => (),
                    };
                }
            }
            Event::HardDropPiece => {
                if !game_ended {
                    last_piece_move = Instant::now();
                    match game.hard_drop_moving_piece() {
                        Ok(_) => (),
                        Err(MinoesError::OverlappingMinoes(OverlappingMinoesError)) => {
                            draw_game_over(&mut terminal, &mut game).unwrap();
                            game_ended = true;
                        }
                        Err(_) => panic!("Unexpected error"),
                    };
                }
            }
            Event::HoldPiece => {
                last_piece_move = Instant::now();
                if !game_ended {
                    if !game.hold_used {
                        match game.hold_moving_piece() {
                            Ok(_) => (),
                            Err(_) => (),
                        };
                    }
                }
            }
            Event::TogglePause => {
                game_paused = !game_paused;
            }
        }
        if !game_ended {
            draw_game(&mut terminal, &mut game).unwrap();
        }
    }
    terminal.show_cursor().unwrap();
}