tet-ris 0.6.4

A play a quick game of 1984-ish Tetris right in the terminal!
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

// Tetris

mod args;
mod bag;
mod gamescore;
mod gamestate;
mod tetlib;
mod tetrominoe;

use std::{
    io::{stdout, Write},
    thread::sleep,
    time::Duration,
};

use crossterm::{
    cursor::Show,
    execute,
    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
};

use clap::Parser;

use gamestate::GameState;
use tetlib::*;

pub const WIDTH: usize = 10;
pub const HEIGHT: usize = 20;

fn main() {
    let mut args = args::Args::parse();

    if args.og {
        args.no_colors = true;
        args.chars = "[]".to_string();
    }

    const MAX_LEVEL: usize = 20;
    const GRAV_TICK: usize = 40;
    const LEVEL_MULT: f64 = 0.85;

    let mut stdout = stdout();
    execute!(stdout, EnterAlternateScreen).unwrap();
    enable_raw_mode().unwrap();
    let mut gs = if let Some(path) = &args.save {
        if path_exists(path) {
            GameState::deserial(path.clone(), WIDTH, HEIGHT)
        } else {
            GameState::new(WIDTH, HEIGHT)
        }
    } else {
        GameState::new(WIDTH, HEIGHT)
    };

    if gs.is_game_over {
        gs.gamescore.stop_timer();
    }

    if args.sirtet {
        sirtet_borders(WIDTH, HEIGHT);
    }

    // loop for new game
    loop {
        // game loop
        loop {
            let prev_display = gs.display.clone();

            // handle input
            let key = get_input();

            // quit
            if key == 'q' {
                break;
            }

            if key == 'p' {
                let mut key = get_input();
                put_text(WIDTH as u16, HEIGHT as u16, "P A U S E D");
                stdout.flush().unwrap();
                while key != 'p' && key != 'q' {
                    key = get_input();
                    sleep(Duration::from_millis(10));
                }
            }

            // gravity
            if gs.counter
                >= (GRAV_TICK as f64 * LEVEL_MULT.powf(gs.gamescore.level as f64)) as usize
            {
                if gravity(&mut gs) {
                    gs.is_game_over = true;
                    break;
                }
                gs.counter = if gs.gamescore.level < MAX_LEVEL {
                    0
                } else {
                    100
                };
            }

            // handle input
            handle_input(&mut gs, key);

            // hold piece
            if key == 'c' && !args.hold {
                hold(&mut gs);
            }

            // full line
            full_line(&mut gs);

            // ghost piece
            if !args.ghost {
                ghost_piece(&mut gs);
            }

            // check if gs.display was changed
            let is_updated = gs.display != prev_display || gs.is_game_over;

            // render
            render(
                &mut gs,
                is_updated,
                &args.chars,
                &args.no_colors,
                &args.sirtet,
            );
            sleep(Duration::from_millis(args.gravity));
            stdout.flush().unwrap();
            gs.counter += 1;
        }

        // put_text(WIDTH as u16, HEIGHT as u16, "G A M E  O V E R");
        if !gs.serial() {
            break;
        }
        gs = GameState::new(WIDTH, HEIGHT);
    }
    disable_raw_mode().unwrap();
    execute!(stdout, LeaveAlternateScreen).unwrap();
    execute!(stdout, Show).unwrap();
}

fn path_exists(path: &String) -> bool {
    std::path::Path::new(path).exists()
}