rust俄罗斯方块

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

use crossterm::{QueueableCommand, Result, cursor::{self, MoveTo, MoveToNextLine, RestorePosition, SavePosition}, event::{Event, KeyCode, KeyEvent, poll, read}, execute, style::{Attribute, Color, PrintStyledContent, Stylize}, terminal::{ EnterAlternateScreen, LeaveAlternateScreen, SetSize, SetTitle, disable_raw_mode, enable_raw_mode, size}};
use rand::Rng;


// 方块形状定义 7种方块 4个方向, 采用4x4的方阵 二进制01存储
const SHAPES: [[u16;4];7] = [
                                [15,8738, 15,8738], // 长条
                                [23,1570,116,1094], // L
                                [71,550,113,1604], // 』
                                [39,610,114,1124], // ┴
                                [54,1122, 54,1122], // ▞
                                [99,612, 99,612], // ▚
                                [102,102, 102,102] // 田
                            ];

const LINES: usize = 23;
const COLS: usize = 12;

const VALUE_EMPTY: u8 = 0;
const VALUE_FILL: u8 = 1;
const VALUE_FIXED: u8 = 2;
const VALUE_CLEAR: u8 = 3;

struct Tetris {
    map: [[u8; COLS]; LINES],
    shapes: [[[bool; 16]; 4]; SHAPES.len()],
    cur_shape: (usize, usize),
    cur_position: (i32, i32),
    next_shape: (usize, usize),
    status: Status,
    remove: usize,
}

enum ShapeOpt {
    CLEAR,  // 清除方块
    FILL,   // 填充方块
    FIXED,  // 固定方块
    COLLISION(i32, i32), // 碰撞检测(line位移, cell位移)
}

impl Tetris {
    fn new() -> Tetris{
        // 地图
        let map = [[VALUE_EMPTY;COLS];LINES];

        // 图形展开
        let mut shapes = [[[false;16];4];SHAPES.len()];
        for (i, ele) in shapes.iter_mut().enumerate() {
            for (j, arr) in ele.iter_mut().enumerate() {
                for (k, v) in arr.iter_mut().enumerate() {
                   *v = 1 << (15 - k) & SHAPES[i][j] != 0;
                }
            }
        }
        Tetris { 
            map,  
            shapes, 
            cur_shape: Tetris::rnd(), 
            cur_position: Tetris::init_position(), 
            next_shape: Tetris::rnd(), 
            status: Status::GameRunning, 
            remove: 0}
    }

    // 速度
    fn speed(&self) -> f64 {
        5.0_f64.min(1.0 + 0.1 * (self.remove as f64))
    }

    // 绘图
    fn draw(&self) -> Result<()> {
        let mut stdout = stdout();
        stdout.queue(MoveTo(0, 0))?
              .queue(cursor::Hide)?
              .queue(PrintStyledContent("按'Esc / Q': 退出; 's': 暂停/启动/重启".red()))?
        ;
        // 绘制地图
        for line in &self.map {
            stdout.queue(MoveToNextLine(0))?;
            for cell in line {
                stdout.queue(PrintStyledContent(
                    match *cell {
                        VALUE_FILL => "■".green(),
                        VALUE_FIXED => "■".grey(),
                        VALUE_CLEAR => "■".red(),
                        _ => "□".blue(),
                    }
                ))?;
            }
        }

        // 绘制下一方块 
        let (nx, ny) = ((COLS * 2 + 4) as u16, ((LINES - 10)/ 2)  as u16);
        stdout.queue(MoveToNextLine(0))?
              .queue(SavePosition)?
              .queue(MoveTo(nx, ny))?
              .queue(PrintStyledContent("下一形状: ".green()))?
              .queue(MoveTo(nx + 1, ny + 1))?
        ;
        let next = &self.shapes[self.next_shape.0][self.next_shape.1];
        for (i, block) in next.iter().enumerate() {

            if i % 4 == 0 {
                stdout.queue(MoveTo(nx + 1, ny + 1 + i as u16 / 4))?;
            }
            stdout.queue(PrintStyledContent( 
                if *block {
                    if let Status::GameOver = self.status {
                        "■".grey() 
                    } else {
                        "■".green() 
                    }
                }else {
                    "□".blue()
                }
            ))?;
        }

        stdout
        .queue(MoveTo(nx, ny + 5))?
        .queue(PrintStyledContent(format!("Remove: {}", self.remove).red()))?
        .queue(MoveTo(nx, ny + 6))?
        .queue(PrintStyledContent(format!("Speed: {:.1}", self.speed()).green()))?
        ;


        if let Status::GameOver = self.status {
            stdout.queue(MoveToNextLine(0))?
            .queue(MoveTo(0, (LINES as u16 - 3) / 2))?
            .queue(PrintStyledContent(format!("{:40}\r\n{:^40}\r\n{:40}", "", "Game Over! (Press 's' Restart)", "")
                                    .with(Color::Yellow)
                                    .on(Color::Red)
                                    .attribute(Attribute::Bold)))?
            ;
        }

        stdout.queue(RestorePosition)?;
        stdout.flush()?;

        Ok(())
    }

    // 操作: 简单的碰撞检测, 填充, 清空
    fn opt(&mut self, opt: ShapeOpt) -> bool
    {
        let (x, y) = if let ShapeOpt::COLLISION(x, y) = opt {
            (x, y)
        }else {
            (0, 0)
        };
        let cur = &self.shapes[self.cur_shape.0][self.cur_shape.1];
        for (i, &v) in cur.iter().enumerate() {
            if !v { continue; }
            let line = self.cur_position.0 + x  + ((i >> 2) as i32 );
            let cell = self.cur_position.1 + y +  ((i & 3) as i32);
            if line < 0 { continue; } // 未进入地图不用检测
            if cell < 0 {return false; } // 左不能超出地图
            let (line, cell) = (line as usize, cell as usize);
            if cell >= self.map[0].len()  || line >= self.map.len(){ return false; } // 右/下 不能超出地图
            
            match opt {
                ShapeOpt::CLEAR => self.map[line][cell] = VALUE_EMPTY, // clear
                ShapeOpt::FIXED => self.map[line][cell] = VALUE_FIXED, // 固定
                ShapeOpt::FILL => self.map[line][cell] = VALUE_FILL, // 填充
                ShapeOpt::COLLISION(_, _) => {  // 碰撞
                    if self.map[line][cell] != VALUE_EMPTY {
                        return false;
                    }
                },
            }
        }
        
        if let ShapeOpt::FIXED = opt { // 检测整行
            let mut wholes = vec![];
            let mut empty = 0;
            // 从下到上检测整行, 直到空行
            for (i, ele) in self.map.iter_mut().enumerate().rev() {
                if ele.iter().all(|x| *x == VALUE_FIXED) {    // 整行
                    ele.iter_mut().for_each(|x| *x = VALUE_CLEAR);
                    wholes.push(i);
                }else if ele.iter().all(|x| *x == VALUE_EMPTY) { // 空行
                    empty = i;
                    break;
                }
            }
            if wholes.len() > 0 {
                self.remove += wholes.len();
                // 消除动画
                thread::sleep(Duration::from_millis(150));
                self.draw().unwrap();
                thread::sleep(Duration::from_millis(150));
                for i in 0..wholes.len() {
                    self.map[i].iter_mut().for_each(|x| {
                        if *x == VALUE_CLEAR { *x = VALUE_EMPTY }
                    });
                }
                self.draw().unwrap();
                thread::sleep(Duration::from_millis(80));
                // 位移
                let mut cursor = wholes[0];
                for i in 0..wholes.len() {
                    let index1 = wholes[i];
                    let index2 = if i + 1 == wholes.len() { empty } else { wholes[i + 1] } + 1;
                    // (index1 ~ index2], index1本身为整行 不需要移动, 中间的都需要依次位移到cursor
                    for j in (index2..index1).rev() {
                        self.map[cursor] = self.map[j];
                        self.map[j] = [0; COLS]; // 加这句就不用上部清空
                        cursor -= 1;
                        self.draw().unwrap();
                        thread::sleep(Duration::from_millis(80));
                    }
                }
                // 上部清空
                // for i in empty..=cursor {
                //     self.map[i] = [0; COLS];
                // }
                self.draw().unwrap();
            }
        }

        true
    }



    // 移动
    fn move_step(&mut self, step: (i32, i32)) -> bool {
        self.opt(ShapeOpt::CLEAR);
        if self.opt(ShapeOpt::COLLISION(step.0, step.1)) { // 碰撞检测
            self.cur_position = (self.cur_position.0 + step.0 as i32, self.cur_position.1 + step.1);
            self.opt(ShapeOpt::FILL);
            return true
        }
        self.opt(ShapeOpt::CLEAR);
        self.opt(ShapeOpt::FILL);
        false
    }

    // 开启新一轮方块
    fn round(&mut self){
        self.cur_position = Tetris::init_position();
        self.cur_shape =  self.next_shape;
        self.next_shape = Tetris::rnd();
    }

    // 初始位置
    fn init_position() -> (i32, i32) {
        (-4, (COLS as i32 - 4) / 2)
    }

    // 随机方块
    fn rnd() -> (usize, usize) {
        (rand::thread_rng().gen_range(0..SHAPES.len()), rand::thread_rng().gen_range(0..4))
    }

    // 调整方块方向
    fn direction(&mut self){
        self.opt(ShapeOpt::CLEAR);
        let old = self.cur_shape.1;
        self.cur_shape.1 = (self.cur_shape.1 + 1) % 4;
        if !self.opt(ShapeOpt::COLLISION(0, 0)) { // 碰撞检测
            self.cur_shape.1 = old;
        }
        self.opt(ShapeOpt::FILL);
    }

    // 调整下一方块朝向
    fn next_direction(&mut self){
        self.next_shape.1 = (self.next_shape.1 + 1) % 4;
    }
    // 调整下一方块
    fn next_plus(&mut self){
        self.next_shape = ((self.next_shape.0 + 1) % self.shapes.len(), 0);
    }

    // 降落
    fn fall(&mut self) {
        if let Status::GameRunning = self.status  {
            if !self.move_step((1, 0)) {
                if self.cur_position.0 == -4 {
                    self.status = Status::GameOver;  
                    return ()
                }
                self.opt(ShapeOpt::FIXED);
                self.round();
            }
        }
    }
}

enum Status {
    GameStop,
    GameRunning,
    GameOver,
}

fn main()  -> Result<()> {
    let mut tetris = Tetris::new();    
    let terminal_size = size()?; // 保存原始大小, 之后恢复
    // 设置终端窗口
    enable_raw_mode()?;
    execute!(stdout(), 
                        // Clear(ClearType::Purge),
                        EnterAlternateScreen,
                        // DisableMouseCapture,
                        SetSize(60, 35),
                        SetTitle("俄罗斯方块")    
                    )?;
     
    let (default_interval, event_interval) = (1000, 100); // 一秒   
    'outter: loop {
        
        // 事件、速度处理
        let interval = ((default_interval as f64) / tetris.speed()) as u64;
        let event_count = interval / event_interval;
        for _ in 0..event_count {
            let now = SystemTime::now();
            // 非阻塞read事件, 这里的时间是事件的超时时间
            if poll(Duration::from_millis(event_interval))? {
                // It's guaranteed that `read` wont block, because `poll` returned
                // `Ok(true)`.
                let event = read()?;
                if let Event::Key(KeyEvent { code, modifiers: _ }) = event {
                    let running = if let Status::GameRunning = tetris.status { true } else { false};
                    match code {
                        KeyCode::Up if running => tetris.direction(),
                        KeyCode::Left if running => { tetris.move_step((0, -1)); () },
                        KeyCode::Right if running => { tetris.move_step((0, 1)); () },
                        KeyCode::Down if running => tetris.fall(),
                        KeyCode::Esc | KeyCode::Char('q') | KeyCode::Char('Q') => break 'outter,
                        KeyCode::Char('n')  => tetris.next_direction(),
                        KeyCode::Char('m')  => tetris.next_plus(),
                        KeyCode::Char('s') => tetris.status = 
                                if running { Status::GameStop } 
                                else if let Status::GameOver = tetris.status { 
                                    tetris = Tetris::new();    
                                    Status::GameRunning
                                } 
                                else { Status::GameRunning},
                        _ => (),
                    }
                    tetris.draw()?;
                }
            }
            
            let use_time = now.elapsed().unwrap_or(Duration::from_millis(0)).subsec_millis() as u64;
            if event_interval > use_time {
                thread::sleep(Duration::from_millis(event_interval - use_time));
            }
        }
        // 自由落体
        if let Status::GameRunning = tetris.status {
            tetris.fall();
        }
        tetris.draw()?;
    }
    // 恢复窗口
    execute!(stdout(),  LeaveAlternateScreen, SetSize(terminal_size.0, terminal_size.1))?;
    disable_raw_mode()?;
    Ok(())
}

 

尽然不支持rust高亮语法, 晕死.

crossterm支持终端高级命令(移动光标, 高亮颜色, 清理等等)

rand 随机数用到的

Cargo.toml

[dependencies]
crossterm = "0.22.1"
rand = "0.8.4"

 

终端显示如果不正确, 要设置一下字体