edward/tetris
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Compare commits

base: edward:765b2655a3c4133d24a88e41a2283ad39eb2e494
Branches Tags
edward:master
..
compare: edward:ab74480bfd6be0701295c1e9940daa2b22a81572
Branches Tags
edward:master

No commits in common. "765b2655a3c4133d24a88e41a2283ad39eb2e494" and "ab74480bfd6be0701295c1e9940daa2b22a81572" have entirely different histories.
765b2655a3 ... ab74480bfd

8 changed files with 207 additions and 505 deletions
Show stats Expand all files Collapse all files

9
.vscode/settings.json vendored
View file

@ -1,9 +0,0 @@
{
"cSpell.words": [
"Mino",
"PLAYFIELD",
"Renderable",
"Tickable",
"tetromino"
]
}

98
src/game.rs
View file

@ -19,8 +19,8 @@ pub struct Game {
playfield: PlayField,
rotation_system: SRS,
level: u8,
score: u32,
tick: u64,
points: u32,
pub tick: u64,
next_gravity_tick: u64,
next_lock_tick: u64,
next_spawn_tick: u64,
@ -29,7 +29,7 @@ pub struct Game {
impl fmt::Debug for Game {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
writeln!(f, "level: {}, points: {}", self.level, self.score)?;
writeln!(f, "level: {}, points: {}", self.level, self.points)?;
writeln!(f, "tick: {}", self.tick)?;
write!(f, "{:?}", self.playfield)
}
@ -41,7 +41,7 @@ impl Default for Game {
playfield: PlayField::new(),
rotation_system: SRS::default(),
level: 1,
score: 0,
points: 0,
tick: 0,
next_gravity_tick: 60,
next_lock_tick: 0,
@ -65,7 +65,17 @@ impl Tickable for Game {
match self.tick {
t if t == self.next_spawn_tick => self.spawn_tetromino(),
t if t == self.next_lock_tick => {
self.try_lock_tetromino();
// It's possible that the player moved the piece in the meantime.
if !self.playfield.can_active_piece_move_down() {
let positions = self.playfield.lock_active_piece();
self.is_game_over =
self.is_game_over || positions.iter().all(|Position { x: _, y }| *y < 20);
if self.clear_lines() {
self.next_spawn_tick = self.tick + LINE_CLEAR_DELAY;
} else {
self.spawn_tetromino();
}
}
}
t if t == self.next_gravity_tick => {
self.playfield.tick_gravity();
@ -85,7 +95,7 @@ impl Game {
}
fn update_gravity_tick(&mut self) {
self.next_gravity_tick = (-1 as i64) as u64; //self.tick + TICKS_PER_SECOND as u64;
self.next_gravity_tick = self.tick + TICKS_PER_SECOND as u64;
}
fn update_lock_tick(&mut self) {
@ -103,23 +113,6 @@ impl Game {
// todo: award points based on how lines were cleared
return false;
}
fn try_lock_tetromino(&mut self) -> bool {
// It's possible that the player moved the piece in the meantime.
if !self.playfield.can_active_piece_move_down() {
let positions = self.playfield.lock_active_piece();
self.is_game_over =
self.is_game_over || positions.iter().all(|Position { x: _, y }| *y < 20);
if self.clear_lines() {
self.next_spawn_tick = self.tick + LINE_CLEAR_DELAY;
} else {
self.spawn_tetromino();
}
true
} else {
false
}
}
}
impl Renderable for Game {
@ -128,8 +121,9 @@ impl Renderable for Game {
}
}
pub trait Controllable {
trait Controllable {
fn move_left(&mut self);
fn move_up(&mut self);
fn move_right(&mut self);
fn move_down(&mut self);
fn rotate_left(&mut self);
@ -139,55 +133,13 @@ pub trait Controllable {
}
impl Controllable for Game {
fn move_left(&mut self) {
self.playfield.move_offset(-1, 0);
self.update_lock_tick();
}
fn move_right(&mut self) {
self.playfield.move_offset(1, 0);
self.update_lock_tick();
}
fn move_down(&mut self) {
if self.playfield.move_offset(0, 1) {
self.score += 1;
self.update_gravity_tick();
self.update_lock_tick();
}
}
fn rotate_left(&mut self) {
match self.rotation_system.rotate_left(&self.playfield) {
Ok(Position { x, y }) => {
let mut active_piece = self.playfield.active_piece.unwrap().clone();
active_piece.position = active_piece.position.offset(x, y);
active_piece.rotate_left();
self.playfield.active_piece = Some(active_piece);
self.update_lock_tick();
}
Err(_) => (),
}
}
fn rotate_right(&mut self) {
match self.rotation_system.rotate_right(&self.playfield) {
Ok(Position { x, y }) => {
let mut active_piece = self.playfield.active_piece.unwrap().clone();
active_piece.position = active_piece.position.offset(x, y);
active_piece.rotate_right();
self.playfield.active_piece = Some(active_piece);
self.update_lock_tick();
}
Err(_) => (),
}
}
fn hard_drop(&mut self) {
while self.playfield.can_active_piece_move_down() {
self.score += 2;
self.playfield.move_offset(0, 1);
}
if !self.try_lock_tetromino() {
println!("couldn't lock tetromino despite hard dropping!");
}
}
fn move_left(&mut self) {}
fn move_up(&mut self) {}
fn move_right(&mut self) {}
fn move_down(&mut self) {}
fn rotate_left(&mut self) {}
fn rotate_right(&mut self) {}
fn hard_drop(&mut self) {}
fn hold(&mut self) {
// if self.can_swap_hold {

2
src/graphics.rs
View file

@ -1,8 +1,6 @@
use sdl2::pixels::Color;
pub const CELL_SIZE: u32 = 32;
pub const BORDER_RADIUS: u32 = 1;
pub static COLOR_BACKGROUND: Color = Color::RGB(60, 60, 60);
pub static COLOR_CYAN: Color = Color::RGB(0, 255, 255);
pub static COLOR_YELLOW: Color = Color::RGB(255, 255, 0);

40
src/main.rs
View file

@ -1,4 +1,4 @@
use game::{Controllable, Game, Tickable};
use game::{Game, Tickable};
use graphics::COLOR_BACKGROUND;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
@ -30,7 +30,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut canvas = window.into_canvas().build()?;
let mut event_pump = sdl_context.event_pump()?;
let mut game = Game::default();
let mut interval = interval(Duration::from_millis(1000 / TICKS_PER_SECOND as u64));
let mut interval = interval(Duration::from_millis(60 / TICKS_PER_SECOND as u64));
'running: while !game.is_game_over() {
for event in event_pump.poll_iter() {
@ -40,40 +40,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
keycode: Some(Keycode::Escape),
..
} => break 'running,
Event::KeyDown {
keycode: Some(Keycode::Left),
..
} => {
game.move_left();
}
Event::KeyDown {
keycode: Some(Keycode::Right),
..
} => game.move_right(),
Event::KeyDown {
keycode: Some(Keycode::Down),
..
} => game.move_down(),
Event::KeyDown {
keycode: Some(Keycode::Z),
..
} => game.rotate_left(),
Event::KeyDown {
keycode: Some(Keycode::X),
..
} => game.rotate_right(),
Event::KeyDown {
keycode: Some(Keycode::Space),
..
}
| Event::KeyDown {
keycode: Some(Keycode::Up),
..
} => game.hard_drop(),
Event::KeyDown {
keycode: Some(Keycode::LShift),
..
} => game.hold(),
_ => {}
}
}
@ -85,6 +51,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
interval.tick().await;
}
println!("Game over! Final game state:");
dbg!(game);
Ok(())
}

80
src/playfield.rs
View file

@ -1,6 +1,7 @@
use crate::graphics::{BORDER_RADIUS, CELL_SIZE, COLOR_BACKGROUND};
use crate::graphics::{CELL_SIZE, COLOR_BACKGROUND};
use crate::random::RandomSystem;
use crate::tetromino::{MinoColor, Position, Tetromino, TetrominoType};
use crate::tetromino::Position;
use crate::tetromino::{MinoColor, Tetromino, TetrominoType};
use crate::Renderable;
use sdl2::{pixels::Color, rect::Rect, render::Canvas, video::Window};
use std::collections::VecDeque;
@ -21,7 +22,7 @@ pub struct PlayField {
can_swap_hold: bool,
hold_piece: Option<TetrominoType>,
field: Matrix,
pub active_piece: Option<Tetromino>,
active_piece: Option<Tetromino>,
bag: RandomSystem,
next_pieces: VecDeque<TetrominoType>,
last_movement: Movement,
@ -52,7 +53,7 @@ impl fmt::Debug for PlayField {
('a' as usize - PLAYFIELD_HEIGHT + y) as u8 as char
)?;
for x in 0..PLAYFIELD_WIDTH {
if occupied_spaces.contains(&Position::new(x as isize, y as isize)) {
if occupied_spaces.contains(&Position::new(x, y)) {
write!(f, "#")?;
} else {
match self.field[y][x] {
@ -79,10 +80,10 @@ impl fmt::Debug for PlayField {
impl PlayField {
pub fn new() -> Self {
let mut bag = RandomSystem::new();
let active_piece = Tetromino::from(bag.get_tetromino());
let active_piece = Tetromino::from(bag.get_tetrino());
let mut next_pieces = VecDeque::with_capacity(3);
for _ in 0..next_pieces.capacity() {
next_pieces.push_back(bag.get_tetromino());
next_pieces.push_back(bag.get_tetrino());
}
PlayField {
@ -96,43 +97,13 @@ impl PlayField {
}
}
pub fn move_offset(&mut self, x: isize, y: isize) -> bool {
if self.can_move_offset(x, y) {
match self.active_piece {
Some(mut piece) => {
piece.position.x += x;
piece.position.y += y;
self.active_piece = Some(piece);
true
}
None => panic!("Active piece missing!"),
}
} else {
false
}
}
fn can_move_offset(&self, x: isize, y: isize) -> bool {
match self.active_piece {
Some(piece) => piece
.get_occupied_spaces(piece.position.offset(x, y))
.iter()
.fold(true, |acc, pos| {
acc && (pos.y as usize) < self.field.len()
&& (pos.x as usize) < PLAYFIELD_WIDTH
&& self.field[pos.y as usize][pos.x as usize].is_none()
}),
None => false,
}
}
pub fn spawn_tetromino(&mut self) {
self.active_piece = Some(Tetromino::from(
self.next_pieces
.pop_front()
.expect("visible queue to be populated"),
));
self.next_pieces.push_back(self.bag.get_tetromino());
self.next_pieces.push_back(self.bag.get_tetrino());
self.can_swap_hold = true;
}
@ -149,14 +120,10 @@ impl PlayField {
pub fn can_active_piece_move_down(&self) -> bool {
self.active_piece
.and_then(|p| {
Some(
p.get_falling_occupied_spaces()
.iter()
.fold(true, |acc, pos| {
acc && (pos.y as usize) < self.field.len()
Some(p.get_next_occupied_spaces().iter().fold(true, |acc, pos| {
acc && pos.y < self.field.len()
&& self.field[pos.y as usize][pos.x as usize].is_none()
}),
)
}))
})
.unwrap_or_else(|| false)
}
@ -167,7 +134,7 @@ impl PlayField {
let active_color = active_piece.get_color();
let new_pieces = active_piece.get_cur_occupied_spaces();
for Position { x, y } in &new_pieces {
self.field[*y as usize][*x as usize] = Some(active_color);
self.field[*y][*x] = Some(active_color);
}
self.active_piece = None;
@ -179,23 +146,10 @@ impl PlayField {
pub fn is_active_piece_in_valid_position(&self) -> bool {
match self.active_piece {
Some(active_piece) => {
self.can_piece_be_at_position(&active_piece)
},
Some(active_piece) => active_piece.get_cur_occupied_spaces().iter().all(|Position {x, y}| self.field[*y][*x].is_none()),
None => panic!("Tried checking if active piece is in a valid position but active piece doesn't exist")
}
}
pub fn can_piece_be_at_position(&self, tetromino: &Tetromino) -> bool {
tetromino
.get_cur_occupied_spaces()
.iter()
.all(|Position { x, y }| {
(*y as usize) < self.field.len()
&& (*x as usize) < PLAYFIELD_WIDTH
&& self.field[*y as usize][*x as usize].is_none()
})
}
}
impl Renderable for PlayField {
@ -215,10 +169,10 @@ impl Renderable for PlayField {
None => canvas.set_draw_color(COLOR_BACKGROUND),
}
canvas.fill_rect(Rect::new(
CELL_SIZE as i32 * x as i32 + BORDER_RADIUS as i32,
CELL_SIZE as i32 * y as i32 + BORDER_RADIUS as i32,
CELL_SIZE - 2 * BORDER_RADIUS,
CELL_SIZE - 2 * BORDER_RADIUS,
CELL_SIZE as i32 * x as i32 + 2,
CELL_SIZE as i32 * y as i32 + 2,
28,
28,
))?;
}
}

2
src/random.rs
View file

@ -17,7 +17,7 @@ impl RandomSystem {
}
}
pub fn get_tetromino(&mut self) -> TetrominoType {
pub fn get_tetrino(&mut self) -> TetrominoType {
if self.cur_pos == 0 {
self.refresh_bag();
}

239
src/srs.rs
View file

@ -1,158 +1,123 @@
use crate::playfield::{Matrix, PlayField};
use crate::tetromino::{Position, RotationState, Tetromino, TetrominoType};
use std::collections::HashMap;
use crate::playfield::PlayField;
use crate::tetromino::{Position, TetrominoType};
#[derive(Copy, Clone)]
pub struct Offset {
x: i8,
y: i8,
}
pub enum RotationDirection {
Clockwise,
AntiClockwise,
}
pub trait RotationSystem {
fn default() -> Self;
fn rotate_left(&self, playfield: &PlayField) -> Result<Position, ()>;
fn rotate_right(&self, playfield: &PlayField) -> Result<Position, ()>;
fn get_rotation_offset(
piece: &TetrominoType,
center: &Position,
direction: RotationDirection,
playfield: &PlayField,
) -> Option<Offset>;
}
pub struct SRS {
jlstz_offset_data: HashMap<RotationState, Vec<Position>>,
i_offset_data: HashMap<RotationState, Vec<Position>>,
o_offset_data: HashMap<RotationState, Vec<Position>>,
}
enum RotationDirection {
Left,
Right,
}
pub struct SRS {}
impl SRS {
fn rotate_common(
&self,
playfield: &PlayField,
rotation: RotationDirection,
) -> Result<Position, ()> {
let active_piece = match playfield.active_piece {
Some(piece) => piece,
None => return Err(()),
};
let offset_data = match active_piece.piece_type {
TetrominoType::I => &self.i_offset_data,
TetrominoType::O => &self.o_offset_data,
_ => &self.jlstz_offset_data,
};
let prev_offsets = offset_data.get(&active_piece.rotation_state).unwrap();
let mut test_tetromino = active_piece.clone();
match rotation {
RotationDirection::Left => test_tetromino.rotate_left(),
RotationDirection::Right => test_tetromino.rotate_right(),
}
let cur_offsets = offset_data.get(&test_tetromino.rotation_state).unwrap();
let mut offsets = Vec::with_capacity(cur_offsets.len());
for i in 0..cur_offsets.len() {
offsets.push(prev_offsets[i] - cur_offsets[i]);
}
for offset in offsets {
let x = offset.x;
let y = offset.y;
let test_position = active_piece.position.offset(x, y);
test_tetromino.position = test_position;
if playfield.can_piece_be_at_position(&test_tetromino) {
return Ok(offset);
}
}
Err(())
pub fn new() -> Self {
Self {}
}
}
impl RotationSystem for SRS {
fn default() -> Self {
let mut jlstz_offset_data = HashMap::with_capacity(4);
let mut i_offset_data = HashMap::with_capacity(4);
let mut o_offset_data = HashMap::with_capacity(4);
SRS::new()
}
jlstz_offset_data.insert(RotationState::O, vec![Position { x: 0, y: 0 }].repeat(5));
jlstz_offset_data.insert(
RotationState::R,
vec![
Position { x: 0, y: 0 },
Position { x: 1, y: 0 },
Position { x: 1, y: 1 },
Position { x: 0, y: -2 },
Position { x: 1, y: -2 },
],
);
jlstz_offset_data.insert(RotationState::U, vec![Position { x: 0, y: 0 }].repeat(5));
jlstz_offset_data.insert(
RotationState::L,
vec![
Position { x: 0, y: 0 },
Position { x: -1, y: 0 },
Position { x: -1, y: 1 },
Position { x: 0, y: -2 },
Position { x: -1, y: -2 },
],
);
i_offset_data.insert(
RotationState::O,
vec![
Position { x: 0, y: 0 },
Position { x: -1, y: 0 },
Position { x: 2, y: 0 },
Position { x: -1, y: 0 },
Position { x: 2, y: 0 },
],
);
i_offset_data.insert(
RotationState::R,
vec![
Position { x: -1, y: 0 },
Position { x: 0, y: 0 },
Position { x: 0, y: 0 },
Position { x: 0, y: -1 },
Position { x: 0, y: 2 },
],
);
i_offset_data.insert(
RotationState::U,
vec![
Position { x: -1, y: -1 },
Position { x: 1, y: -1 },
Position { x: -2, y: -1 },
Position { x: 1, y: 0 },
Position { x: -2, y: 0 },
],
);
i_offset_data.insert(
RotationState::L,
vec![
Position { x: 0, y: -1 },
Position { x: 0, y: -1 },
Position { x: 0, y: -1 },
Position { x: 0, y: 1 },
Position { x: 0, y: -2 },
],
);
o_offset_data.insert(RotationState::O, vec![Position { x: 0, y: 0 }]);
o_offset_data.insert(RotationState::R, vec![Position { x: 0, y: 1 }]);
o_offset_data.insert(RotationState::U, vec![Position { x: -1, y: 1 }]);
o_offset_data.insert(RotationState::L, vec![Position { x: -1, y: 0 }]);
SRS {
jlstz_offset_data,
i_offset_data,
o_offset_data,
fn get_rotation_offset(
piece: &TetrominoType,
center: &Position,
direction: RotationDirection,
playfield: &PlayField,
) -> Option<Offset> {
None
}
}
fn rotate_left(&self, playfield: &PlayField) -> Result<Position, ()> {
self.rotate_common(playfield, RotationDirection::Left)
#[derive(PartialEq, Eq, Hash)]
enum Rotation {
O, // Spawn state
R, // Right rotation: clockwise rotation from spawn state
U, // Upside-down rotation: rotation after 2 left or right rotations from spawn state
L, // Left rotation: counterclockwise rotation from spawn state
}
fn rotate_right(&self, playfield: &PlayField) -> Result<Position, ()> {
self.rotate_common(playfield, RotationDirection::Right)
struct OffsetData {
// O: &[Offset],
// R: &[Offset],
// U: &[Offset],
// L: &[Offset],
}
impl OffsetData {
pub fn apply_right_rotation() {}
}
// static JLSTZOffsetData: OffsetData = OffsetData {
// O: vec![Offset { x: 0, y: 0 }],
// R: vec![
// Offset { x: 0, y: 0 },
// Offset { x: 1, y: 0 },
// Offset { x: 1, y: -1 },
// Offset { x: 0, y: 2 },
// Offset { x: 1, y: 2 },
// ],
// U: vec![Offset { x: 0, y: 0 }],
// L: vec![
// Offset { x: 0, y: 0 },
// Offset { x: -1, y: 0 },
// Offset { x: -1, y: -1 },
// Offset { x: 0, y: 2 },
// Offset { x: -1, y: 2 },
// ],
// };
// static IOffsetData: OffsetData = OffsetData {
// O: vec![
// Offset { x: 0, y: 0 },
// Offset { x: -1, y: 0 },
// Offset { x: 2, y: 0 },
// Offset { x: -1, y: 0 },
// Offset { x: 2, y: 0 },
// ],
// R: vec![
// Offset { x: -1, y: 0 },
// Offset { x: 0, y: 0 },
// Offset { x: 0, y: 0 },
// Offset { x: 0, y: 1 },
// Offset { x: 0, y: -2 },
// ],
// U: vec![
// Offset { x: -1, y: 1 },
// Offset { x: 1, y: 1 },
// Offset { x: -2, y: 1 },
// Offset { x: 1, y: 0 },
// Offset { x: -2, y: 0 },
// ],
// L: vec![
// Offset { x: 0, y: 1 },
// Offset { x: 0, y: 1 },
// Offset { x: 0, y: 1 },
// Offset { x: 0, y: -1 },
// Offset { x: 0, y: 2 },
// ],
// };
// static OOffsetData: OffsetData = OffsetData {
// O: vec![Offset { x: 0, y: 0 }],
// R: vec![Offset { x: 0, y: -1 }],
// U: vec![Offset { x: -1, y: -1 }],
// L: vec![Offset { x: -1, y: 0 }],
// };

232
src/tetromino.rs
View file

@ -63,22 +63,22 @@ pub enum TetrominoType {
L,
}
impl Into<MinoColor> for TetrominoType {
fn into(self) -> MinoColor {
impl Into<Color> for TetrominoType {
fn into(self) -> Color {
match self {
Self::I => MinoColor::Cyan,
Self::O => MinoColor::Yellow,
Self::T => MinoColor::Purple,
Self::S => MinoColor::Green,
Self::Z => MinoColor::Red,
Self::J => MinoColor::Blue,
Self::L => MinoColor::Orange,
Self::I => COLOR_CYAN,
Self::O => COLOR_YELLOW,
Self::T => COLOR_PURPLE,
Self::S => COLOR_GREEN,
Self::Z => COLOR_RED,
Self::J => COLOR_BLUE,
Self::L => COLOR_ORANGE,
}
}
}
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum RotationState {
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
enum RotationState {
O, // initial state
R, // clockwise rotation
L, // counter-clockwise rotation
@ -93,42 +93,22 @@ impl Default for RotationState {
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct Position {
pub x: isize,
pub y: isize,
pub x: usize,
pub y: usize,
}
impl Position {
pub fn new(x: isize, y: isize) -> Position {
pub fn new(x: usize, y: usize) -> Position {
Self {
x: x as isize,
y: y as isize,
x: x as usize,
y: y as usize,
}
}
pub fn offset(&self, x: isize, y: isize) -> Position {
fn offset(&self, x: isize, y: isize) -> Position {
Self {
x: x + self.x,
y: y + self.y,
}
}
}
impl std::ops::Add for Position {
type Output = Self;
fn add(self, other: Self) -> Self {
Self {
x: self.x + other.x,
y: self.y + other.y,
}
}
}
impl std::ops::Sub for Position {
type Output = Self;
fn sub(self, other: Self) -> Self {
Self {
x: self.x - other.x,
y: self.y - other.y,
x: (x + self.x as isize) as usize,
y: (y + self.y as isize) as usize,
}
}
}
@ -137,7 +117,7 @@ impl std::ops::Sub for Position {
pub struct Tetromino {
pub position: Position,
pub piece_type: TetrominoType,
pub rotation_state: RotationState,
rotation_state: RotationState,
}
impl Tetromino {
@ -149,6 +129,14 @@ impl Tetromino {
}
}
pub fn get_next_occupied_spaces(&self) -> Vec<Position> {
self.get_occupied_spaces(self.position.offset(0, 1))
}
pub fn get_cur_occupied_spaces(&self) -> Vec<Position> {
self.get_occupied_spaces(self.position)
}
pub fn get_color(&self) -> MinoColor {
match self.piece_type {
TetrominoType::I => MinoColor::Cyan,
@ -163,24 +151,13 @@ impl Tetromino {
fn get_start_position(tetromino_type: TetrominoType) -> Position {
if tetromino_type == TetrominoType::I {
Position::new(
PLAYFIELD_WIDTH as isize / 2 - 1,
PLAYFIELD_HEIGHT as isize - 1,
)
Position::new(PLAYFIELD_WIDTH / 2 - 1, PLAYFIELD_HEIGHT - 1)
} else {
Position::new(PLAYFIELD_WIDTH as isize / 2 - 1, PLAYFIELD_HEIGHT as isize)
Position::new(PLAYFIELD_WIDTH / 2 - 1, PLAYFIELD_HEIGHT)
}
}
pub fn get_falling_occupied_spaces(&self) -> Vec<Position> {
self.get_occupied_spaces(self.position.offset(0, 1))
}
pub fn get_cur_occupied_spaces(&self) -> Vec<Position> {
self.get_occupied_spaces(self.position)
}
pub fn get_occupied_spaces(&self, center: Position) -> Vec<Position> {
fn get_occupied_spaces(&self, center: Position) -> Vec<Position> {
let mut spaces = vec![center];
match self.piece_type {
TetrominoType::I => match self.rotation_state {
@ -194,16 +171,8 @@ impl Tetromino {
center.offset(0, 1),
center.offset(0, 2),
]),
RotationState::U => spaces.extend_from_slice(&[
center.offset(-2, 0),
center.offset(-1, 0),
center.offset(1, 0),
]),
RotationState::L => spaces.extend_from_slice(&[
center.offset(0, -2),
center.offset(0, -1),
center.offset(0, 1),
]),
RotationState::L => todo!(),
RotationState::U => todo!(),
},
TetrominoType::J => match self.rotation_state {
RotationState::O => spaces.extend_from_slice(&[
@ -211,21 +180,9 @@ impl Tetromino {
center.offset(-1, 0),
center.offset(1, 0),
]),
RotationState::R => spaces.extend_from_slice(&[
center.offset(0, -1),
center.offset(1, -1),
center.offset(0, 1),
]),
RotationState::U => spaces.extend_from_slice(&[
center.offset(-1, 0),
center.offset(1, 0),
center.offset(1, 1),
]),
RotationState::L => spaces.extend_from_slice(&[
center.offset(0, -1),
center.offset(-1, 1),
center.offset(0, 1),
]),
RotationState::R => todo!(),
RotationState::L => todo!(),
RotationState::U => todo!(),
},
TetrominoType::L => match self.rotation_state {
RotationState::O => spaces.extend_from_slice(&[
@ -233,21 +190,9 @@ impl Tetromino {
center.offset(-1, 0),
center.offset(1, 0),
]),
RotationState::R => spaces.extend_from_slice(&[
center.offset(0, -1),
center.offset(0, 1),
center.offset(1, 1),
]),
RotationState::U => spaces.extend_from_slice(&[
center.offset(-1, 0),
center.offset(1, 0),
center.offset(-1, 1),
]),
RotationState::L => spaces.extend_from_slice(&[
center.offset(-1, -1),
center.offset(0, -1),
center.offset(0, 1),
]),
RotationState::R => todo!(),
RotationState::L => todo!(),
RotationState::U => todo!(),
},
TetrominoType::O => match self.rotation_state {
RotationState::O => spaces.extend_from_slice(&[
@ -255,21 +200,9 @@ impl Tetromino {
center.offset(1, -1),
center.offset(1, 0),
]),
RotationState::R => spaces.extend_from_slice(&[
center.offset(1, 0),
center.offset(0, 1),
center.offset(1, 1),
]),
RotationState::U => spaces.extend_from_slice(&[
center.offset(-1, 0),
center.offset(-1, 1),
center.offset(0, 1),
]),
RotationState::L => spaces.extend_from_slice(&[
center.offset(-1, -1),
center.offset(0, -1),
center.offset(-1, 0),
]),
RotationState::R => todo!(),
RotationState::L => todo!(),
RotationState::U => todo!(),
},
TetrominoType::S => match self.rotation_state {
RotationState::O => spaces.extend_from_slice(&[
@ -277,21 +210,9 @@ impl Tetromino {
center.offset(1, -1),
center.offset(-1, 0),
]),
RotationState::R => spaces.extend_from_slice(&[
center.offset(0, -1),
center.offset(1, 0),
center.offset(1, 1),
]),
RotationState::U => spaces.extend_from_slice(&[
center.offset(0, 1),
center.offset(1, 0),
center.offset(-1, 1),
]),
RotationState::L => spaces.extend_from_slice(&[
center.offset(-1, -1),
center.offset(-1, 0),
center.offset(0, 1),
]),
RotationState::R => todo!(),
RotationState::L => todo!(),
RotationState::U => todo!(),
},
TetrominoType::T => match self.rotation_state {
RotationState::O => spaces.extend_from_slice(&[
@ -299,21 +220,9 @@ impl Tetromino {
center.offset(-1, 0),
center.offset(1, 0),
]),
RotationState::R => spaces.extend_from_slice(&[
center.offset(0, -1),
center.offset(0, 1),
center.offset(1, 0),
]),
RotationState::U => spaces.extend_from_slice(&[
center.offset(0, 1),
center.offset(-1, 0),
center.offset(1, 0),
]),
RotationState::L => spaces.extend_from_slice(&[
center.offset(0, -1),
center.offset(-1, 0),
center.offset(0, 1),
]),
RotationState::R => todo!(),
RotationState::L => todo!(),
RotationState::U => todo!(),
},
TetrominoType::Z => match self.rotation_state {
RotationState::O => spaces.extend_from_slice(&[
@ -321,44 +230,14 @@ impl Tetromino {
center.offset(0, -1),
center.offset(1, 0),
]),
RotationState::R => spaces.extend_from_slice(&[
center.offset(1, -1),
center.offset(1, 0),
center.offset(0, 1),
]),
RotationState::U => spaces.extend_from_slice(&[
center.offset(-1, 0),
center.offset(0, 1),
center.offset(1, 1),
]),
RotationState::L => spaces.extend_from_slice(&[
center.offset(0, -1),
center.offset(-1, 0),
center.offset(-1, 1),
]),
RotationState::R => todo!(),
RotationState::L => todo!(),
RotationState::U => todo!(),
},
}
spaces
}
pub fn rotate_left(&mut self) {
self.rotation_state = match self.rotation_state {
RotationState::O => RotationState::L,
RotationState::L => RotationState::U,
RotationState::U => RotationState::R,
RotationState::R => RotationState::O,
}
}
pub fn rotate_right(&mut self) {
self.rotation_state = match self.rotation_state {
RotationState::O => RotationState::R,
RotationState::R => RotationState::U,
RotationState::U => RotationState::L,
RotationState::L => RotationState::O,
}
}
}
impl From<TetrominoType> for Tetromino {
@ -370,14 +249,9 @@ impl From<TetrominoType> for Tetromino {
impl Renderable for Tetromino {
fn render(&self, canvas: &mut Canvas<Window>) -> Result<(), String> {
for Position { x, y } in self.get_cur_occupied_spaces() {
canvas.set_draw_color::<MinoColor>(self.piece_type.into());
canvas.set_draw_color(self.piece_type);
let height = y as isize - PLAYFIELD_HEIGHT as isize;
canvas.fill_rect(Rect::new(
CELL_SIZE as i32 * x as i32 + BORDER_RADIUS as i32,
CELL_SIZE as i32 * height as i32 + BORDER_RADIUS as i32,
CELL_SIZE - 2 * BORDER_RADIUS,
CELL_SIZE - 2 * BORDER_RADIUS,
))?;
canvas.fill_rect(Rect::new(32 * x as i32 + 2, 32 * height as i32 + 2, 28, 28))?;
}
Ok(())
}