greg/tetres
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: greg:6a780efa4a3ac02529baaee9a69899a38c624456
Branches Tags
greg:master
..
compare: greg:773d7d2cc562c11c742b673d6d21494a4c341bd0
Branches Tags
greg:master

No commits in common. "6a780efa4a3ac02529baaee9a69899a38c624456" and "773d7d2cc562c11c742b673d6d21494a4c341bd0" have entirely different histories.
6a780efa4a ... 773d7d2cc5

1 changed files with 23 additions and 126 deletions
Show Stats Expand all files Collapse all files

149
iced-tetris/src/main.rs
View File

@ -6,9 +6,6 @@ use iced::{
use iced_native::{event, subscription, Event};
use rand::distributions::{Distribution, Standard};
const START_LOCATION: (u8, u8) = (5, 1);
type PieceBlocks = [(i8, i8); 4];
fn main() -> iced::Result {
Tetris::run(Settings::default())
}
@ -18,7 +15,6 @@ struct Tetris {
blocks: BlockGrid,
ticks: usize,
paused: bool,
lines_removed: u32,
}
impl Tetris {
@ -28,7 +24,6 @@ impl Tetris {
blocks: BlockGrid::new(),
ticks: 0,
paused: false,
lines_removed: 0,
}
}
}
@ -54,9 +49,7 @@ impl Application for Tetris {
self.ticks += 1
}
}
Message::Up => {
self.blocks.rotate_active_piece();
}
Message::Up => (),
Message::Down => {
self.blocks.move_active_piece(MoveDirection::HardDrop);
}
@ -79,9 +72,6 @@ impl Application for Tetris {
}
}
};
let lines_removed = self.blocks.clear_pieces();
self.lines_removed += lines_removed;
Command::none()
}
@ -174,7 +164,6 @@ struct BlockGrid {
struct ActivePiece {
location: (u8, u8),
tetromino: Tetromino,
orientation: Orientation,
}
impl ActivePiece {
@ -183,7 +172,6 @@ impl ActivePiece {
let (cur_x, cur_y) = self.location;
ActivePiece {
tetromino: self.tetromino,
orientation: self.orientation,
location: match direction {
Left => (cur_x.checked_sub(1).unwrap_or(0), cur_y),
Right => (cur_x + 1, cur_y),
@ -192,19 +180,6 @@ impl ActivePiece {
},
}
}
fn rotate_piece(&self) -> ActivePiece {
ActivePiece {
tetromino: self.tetromino,
location: self.location,
orientation: match self.orientation {
Orientation::A => Orientation::B,
Orientation::B => Orientation::C,
Orientation::C => Orientation::D,
Orientation::D => Orientation::A,
},
}
}
}
impl BlockGrid {
@ -220,12 +195,11 @@ impl BlockGrid {
fn drop_piece(&mut self, tetromino: Tetromino) -> bool {
if let None = self.active_piece {
let piece = ActivePiece {
location: START_LOCATION,
location: (4, 0),
tetromino,
orientation: Orientation::A,
};
let piece_blocks = Self::piece_blocks(&piece);
if self.piece_blocks_in_bounds(piece_blocks) {
if self.piece_blocks_in_bounds(&piece_blocks) {
self.active_piece = Some(piece);
true
} else {
@ -236,11 +210,11 @@ impl BlockGrid {
}
}
fn piece_blocks_in_bounds(&self, piece_blocks: PieceBlocks) -> bool {
fn piece_blocks_in_bounds(&self, piece_blocks: &[(u8, u8); 4]) -> bool {
piece_blocks.iter().all(|(x, y)| {
let x = *x;
let y = *y;
x >= 0 && y >= 0 && x < 10 && y < 20 && self.state[x as usize][y as usize].is_none()
x < 10 && y < 20 && self.state[x as usize][y as usize].is_none()
})
}
@ -253,7 +227,7 @@ impl BlockGrid {
(Some(piece), MoveDirection::Left | MoveDirection::Right) => {
let new_piece = piece.move_piece(&direction);
let new_blocks = Self::piece_blocks(&new_piece);
if self.piece_blocks_in_bounds(new_blocks) {
if self.piece_blocks_in_bounds(&new_blocks) {
self.active_piece = Some(new_piece);
true
} else {
@ -265,7 +239,7 @@ impl BlockGrid {
loop {
let p = new_piece.move_piece(&MoveDirection::SoftDrop);
let new_blocks = Self::piece_blocks(&p);
if self.piece_blocks_in_bounds(new_blocks) {
if self.piece_blocks_in_bounds(&new_blocks) {
new_piece = p;
} else {
break;
@ -279,7 +253,7 @@ impl BlockGrid {
(Some(ref piece), MoveDirection::SoftDrop) => {
let new_piece = piece.move_piece(&MoveDirection::SoftDrop);
let new_blocks = Self::piece_blocks(&new_piece);
if self.piece_blocks_in_bounds(new_blocks) {
if self.piece_blocks_in_bounds(&new_blocks) {
self.active_piece = Some(new_piece);
true
} else {
@ -290,22 +264,6 @@ impl BlockGrid {
}
}
fn rotate_active_piece(&mut self) -> bool {
let active = self.active_piece;
if let Some(piece) = active {
let new_piece = piece.rotate_piece();
let new_blocks = Self::piece_blocks(&new_piece);
if self.piece_blocks_in_bounds(new_blocks) {
self.active_piece = Some(new_piece);
true
} else {
false
}
} else {
false
}
}
/// Remove the currently active piece and place its blocks onto the board.
fn place_active_piece(&mut self) {
if let Some(piece) = self.active_piece {
@ -319,82 +277,29 @@ impl BlockGrid {
}
}
fn piece_blocks(piece: &ActivePiece) -> PieceBlocks {
use Orientation::*;
fn piece_blocks(piece: &ActivePiece) -> [(u8, u8); 4] {
use Tetromino::*;
let (x, y) = piece.location;
let (x, y) = (x as i8, y as i8);
// These use the "Original Rotation System" cf. Tetris wiki
match (piece.tetromino, piece.orientation) {
(I, A | C) => [(x - 2, y), (x - 1, y), (x, y), (x + 1, y)],
(I, B | D) => [(x, y - 1), (x, y), (x, y + 1), (x, y + 2)],
(J, A) => [(x - 1, y), (x, y), (x + 1, y), (x + 1, y + 1)],
(J, B) => [(x, y), (x + 1, y), (x, y + 1), (x, y + 2)],
(J, C) => [(x - 1, y), (x - 1, y + 1), (x, y + 1), (x + 1, y + 1)],
(J, D) => [(x, y), (x, y + 1), (x, y + 2), (x - 1, y + 2)],
(L, A) => [(x - 1, y + 1), (x - 1, y), (x, y), (x + 1, y)],
(L, B) => [(x, y), (x, y + 1), (x, y + 2), (x + 1, y + 2)],
(L, C) => [(x - 1, y + 1), (x, y + 1), (x + 1, y + 1), (x + 1, y)],
(L, D) => [(x - 1, y), (x, y), (x, y + 1), (x, y + 2)],
(O, _) => [(x, y), (x, y + 1), (x - 1, y), (x - 1, y + 1)],
(S, A | C) => [(x - 1, y + 1), (x, y + 1), (x, y), (x + 1, y)],
(S, B | D) => [(x, y), (x, y + 1), (x + 1, y + 1), (x + 1, y + 2)],
(T, A) => [(x - 1, y), (x, y), (x + 1, y), (x, y + 1)],
(T, B) => [(x, y), (x, y + 1), (x + 1, y + 1), (x, y + 2)],
(T, C) => [(x, y), (x - 1, y + 1), (x, y + 1), (x + 1, y + 1)],
(T, D) => [(x - 1, y + 1), (x, y), (x, y + 1), (x, y + 2)],
(Z, A | C) => [(x - 1, y + 1), (x, y + 1), (x, y + 2), (x + 1, y + 2)],
(Z, B | D) => [(x, y), (x, y + 1), (x + 1, y), (x + 1, y - 1)],
match piece.tetromino {
I => [(x, y), (x, y + 1), (x, y + 2), (x, y + 3)],
J => [(x, y), (x, y + 1), (x, y + 2), (x - 1, y + 2)],
L => [(x, y), (x, y + 1), (x, y + 2), (x + 1, y + 2)],
O => [(x, y), (x + 1, y), (x, y + 1), (x + 1, y + 1)],
S => [(x, y + 1), (x + 1, y + 1), (x + 1, y), (x + 2, y)],
T => [(x, y), (x + 1, y), (x + 2, y), (x + 1, y + 1)],
Z => [(x, y), (x + 1, y), (x + 1, y + 1), (x + 2, y + 1)],
}
}
/// Returns number of lines removed
fn clear_pieces(&mut self) -> u32 {
let mut new_state = [[None; 20]; 10];
let mut offset = 0;
for row in (0..=19).rev() {
let mut all_filled = true;
let mut all_empty = true;
for col in 0..10 {
if self.state[col][row].is_none() {
all_filled = false;
}
if self.state[col][row].is_some() {
all_empty = false;
}
}
if all_filled && !all_empty {
offset += 1;
} else {
if offset != 0 {
println!("Offset {} row {}", offset, row);
}
for col in 0..10 {
new_state[col][row+offset] = self.state[col][row];
}
}
}
self.state = new_state;
println!("OFFSET: {}", offset);
offset as u32
fn active_piece_blocks(&self) -> Option<(Tetromino, [(u8, u8); 4])> {
self.active_piece
.as_ref()
.map(|piece| (piece.tetromino, Self::piece_blocks(&piece)))
}
fn iter<'a>(&'a self) -> BlockGridIter<'a> {
let active_piece_blocks = self.active_piece.as_ref().map(|piece| {
let b = Self::piece_blocks(piece);
let blocks = [
(b[0].0 as u8, b[0].1 as u8),
(b[1].0 as u8, b[1].1 as u8),
(b[2].0 as u8, b[2].1 as u8),
(b[3].0 as u8, b[3].1 as u8),
];
(piece.tetromino, blocks)
});
BlockGridIter::new(&self.state, active_piece_blocks)
BlockGridIter::new(&self.state, self.active_piece_blocks())
}
}
@ -450,7 +355,7 @@ struct Block {
source: Tetromino,
}
#[derive(Debug, Copy, Clone)]
#[derive(Debug, Copy, Clone, PartialEq)]
enum MoveDirection {
Left,
Right,
@ -458,14 +363,6 @@ enum MoveDirection {
SoftDrop,
}
#[derive(Debug, Copy, Clone)]
enum Orientation {
A,
B,
C,
D,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
enum Tetromino {
I,