tetris-io 0.1.1

Terminal-based Tetris game built with Ratatui and Crossterm
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

use super::events::Event;
use super::rules::{RulesConfig, step};
use super::state::GameState;

#[derive(Debug)]
pub struct Arena {
    pub players: Vec<GameState>,
}

impl Arena {
    pub fn new(players: Vec<GameState>) -> Self {
        Self { players }
    }

    pub fn step_player(
        &mut self,
        idx: usize,
        cfg: RulesConfig,
        dt_ms: u64,
        commands: &[super::command::Command],
        soft_drop_active: bool,
    ) -> Vec<Event> {
        let events = step(
            &mut self.players[idx],
            cfg,
            dt_ms,
            commands,
            soft_drop_active,
        );
        let outgoing: Vec<u32> = events
            .iter()
            .filter_map(|e| match e {
                Event::OutgoingGarbage(lines) => Some(*lines),
                _ => None,
            })
            .collect();
        if !outgoing.is_empty()
            && let Some(target) = self.pick_target(idx)
        {
            for lines in outgoing {
                self.players[target].receive_garbage(lines);
            }
        }
        events
    }

    fn pick_target(&self, sender_idx: usize) -> Option<usize> {
        let alive: Vec<usize> = self
            .players
            .iter()
            .enumerate()
            .filter(|(idx, state)| *idx != sender_idx && !state.game_over)
            .map(|(idx, _)| idx)
            .collect();
        alive.into_iter().next()
    }
}