no_std_tetris 0.1.1

A flexible Tetris implementation for no_std and standard environments
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

# no_std_tetris

A minimalist, flexible Tetris implementation in Rust that works in both `no_std` and standard environments. This crate provides a core Tetris game engine that can be used on embedded systems, in terminal applications, or in any Rust project needing Tetris gameplay.

[![Crates.io](https://img.shields.io/crates/v/no_std_tetris.svg)](https://crates.io/crates/no_std_tetris)
[![Documentation](https://docs.rs/no_std_tetris/badge.svg)](https://docs.rs/no_std_tetris)
[![License: MIT OR Apache-2.0](https://img.shields.io/badge/License-MIT%20OR%20Apache--2.0-blue.svg)](LICENSE)

## Features

- Works in `no_std` environments, perfect for embedded systems
- Generic over random number generation, allowing for platform-specific implementations
- Simple API for game control (move, rotate, etc.)
- Customizable rendering through a generic drawing function
- Complete terminal example using crossterm

## Usage

Add this to your `Cargo.toml`:

```toml
[dependencies]
no_std_tetris = "0.1.0"
```

## API Overview

### Core Types
  * `Tetris<R>`: The main game state, generic over a random number generator
  * `RandomGenerator`: Trait for providing random numbers to select new pieces
  * `Color`: Enum for piece colors
  * `Tetromino`: Struct representing a tetromino pieces

### Game Controls
```rust
// Create a new game with a random number generator
let mut game = Tetris::new(rng);

// Game controls
game.move_left();
game.move_right();
game.move_down();
game.rotate();

// Check game status
if game.is_game_over() {
    println!("Game Over! Score: {}", game.score);
}
```

### Rendering
The library provides a default text-based renderer, but you usually will implement your own. The example implementation is:
```rust
pub fn draw_on_screen<R: RandomGenerator>(
    tetris: &Tetris<R>,
    f: &mut impl fmt::Write,
) -> fmt::Result {
    for y in 0..BOARD_HEIGHT {
        write!(f, "|")?;
        for x in 0..BOARD_WIDTH {
            let mut occupied = tetris.board[y][x].is_some();
            if !tetris.game_over {
                for &(dx, dy) in &tetris.current_piece.shape {
                    if (tetris.piece_pos.0 + dx as i8) as usize == x
                        && (tetris.piece_pos.1 + dy as i8) as usize == y
                    {
                        occupied = true;
                    }
                }
            }
            write!(f, "{}", if occupied { "#" } else { " " })?;
        }
        writeln!(f, "|")?;
    }
    if tetris.game_over {
        writeln!(f, "GAME OVER - Score: {}", tetris.score)
    } else {
        writeln!(f, "Score: {}", tetris.score)
    }
}
```

## Project structure
```
no_std_tetris/
├── crate_project           # the crate and terminal example
├── esp32_c3_example        # example implementation on esp32-c3
├── LICENSE
└── README.md
```