From 1b9f13bdaeec7d2bb7f9a1eadcb32f63850199ae Mon Sep 17 00:00:00 2001 From: abdalrahmanmamdouh2004-svg Date: Sat, 21 Nov 2026 13:21:37 +0200 Subject: [PATCH] Add files via upload --- apps/tetris/Cargo.toml | 13 + apps/tetris/icon.svg | 29 ++ apps/tetris/shots/over.png | Bin 0 -> 9899 bytes apps/tetris/shots/playing.png | Bin 0 -> 10010 bytes apps/tetris/shots/ready.png | Bin 0 -> 3939 bytes apps/tetris/src/game.rs | 816 ++++++++++++++++++++++++++++++++++ apps/tetris/src/main.rs | 170 +++++++ apps/tetris/src/view.rs | 569 ++++++++++++++++++++++++ apps/tetris/store.md | 13 + apps/tetris/store.toml | 6 + 10 files changed, 1616 insertions(+) create mode 100644 apps/tetris/Cargo.toml create mode 100644 apps/tetris/icon.svg create mode 100644 apps/tetris/shots/over.png create mode 100644 apps/tetris/shots/playing.png create mode 100644 apps/tetris/shots/ready.png create mode 100644 apps/tetris/src/game.rs create mode 100644 apps/tetris/src/main.rs create mode 100644 apps/tetris/src/view.rs create mode 100644 apps/tetris/store.md create mode 100644 apps/tetris/store.toml diff --git a/apps/tetris/Cargo.toml b/apps/tetris/Cargo.toml new file mode 100644 index 0000000..bd20d9f --- /dev/null +++ b/apps/tetris/Cargo.toml @@ -0,0 +1,13 @@ +[package] +name = "tetris" +edition.workspace = true +license.workspace = true +version.workspace = true + +[dependencies] +cmf-wp2-app.workspace = true +cmf-wp2-ui.workspace = true + +[[bin]] +name = "tetris" +bench = false diff --git a/apps/tetris/icon.svg b/apps/tetris/icon.svg new file mode 100644 index 0000000..4444f9d --- /dev/null +++ b/apps/tetris/icon.svg @@ -0,0 +1,29 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/apps/tetris/shots/over.png b/apps/tetris/shots/over.png new file mode 100644 index 0000000000000000000000000000000000000000..f1230b917ea4a77d284087ff43ed93d72f48f9b7 GIT binary patch literal 9899 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 YVDp0*Nl!iRdG07sU8BoI7ai{W4@=l8UjP6A literal 0 HcmV?d00001 diff --git a/apps/tetris/shots/ready.png b/apps/tetris/shots/ready.png new file mode 100644 index 0000000000000000000000000000000000000000..3ecb3ab060d2756b991c35df76f78a2a1ae11ed2 GIT binary patch literal 3939 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 aSCRTjc4>}RGNiX$fG=IWSZR6l(f [(i32, i32); 4] { + let mut c = BASE[kind as usize % KINDS as usize]; + if kind == O { + return c; // a square looks the same from every side + } + let n = if kind == I { 4 } else { 3 }; + for _ in 0..rot % 4 { + for p in c.iter_mut() { + *p = (n - 1 - p.1, p.0); + } + } + c +} + +impl Piece { + /// Where its cells are in the well. + pub fn cells(&self) -> [(i32, i32); 4] { + shape(self.kind, self.rot).map(|(x, y)| (self.x + x, self.y + y)) + } +} + +/// Where a turned piece may go if it does not fit where it is: sideways, then up. +const KICKS: [(i32, i32); 8] = [(0, 0), (-1, 0), (1, 0), (-2, 0), (2, 0), (0, -1), (-1, -1), (1, -1)]; + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub struct Flash { + /// Bit `y` is set for each full row. + pub rows: u32, + pub step: u8, + at: u32, +} + +impl Flash { + /// Rows show white on odd steps. + pub fn lit(&self) -> bool { + self.step % 2 == 1 + } +} + +#[derive(Clone)] +pub struct Game { + pub state: State, + /// 0 = empty, else the kind + 1 of the piece that left it there. + pub board: [[u8; W]; H], + /// The falling piece; `None` while rows blink. + pub cur: Option, + pub next: u8, + pub score: u32, + pub lines: u32, + pub flash: Option, + soft: bool, + drop_at: u32, + lock_at: Option, + resets: u8, + bag: [u8; 7], + bag_at: usize, + rng: u32, +} + +pub fn due(now: u32, at: u32) -> bool { + (now.wrapping_sub(at) as i32) >= 0 +} + +fn until(now: u32, at: u32) -> u32 { + if due(now, at) { 0 } else { at.wrapping_sub(now) } +} + +/// xorshift32: no random source on the watch, the app seeds it from the clock. +fn next(rng: &mut u32) -> u32 { + let mut x = *rng; + x ^= x << 13; + x ^= x >> 17; + x ^= x << 5; + *rng = x; + x +} + +impl Game { + pub fn new(seed: u32) -> Game { + Game { + state: State::Ready, + board: [[0; W]; H], + cur: None, + next: 0, + score: 0, + lines: 0, + flash: None, + soft: false, + drop_at: 0, + lock_at: None, + resets: 0, + bag: [0, 1, 2, 3, 4, 5, 6], + bag_at: 7, + rng: seed | 1, + } + } + + pub fn level(&self) -> u32 { + (self.lines / 10).min(19) + } + + /// Time between two falls of one row now. + pub fn interval(&self) -> u32 { + let g = GRAVITY[self.level() as usize]; + if self.soft { g.min(SOFT_MS) } else { g } + } + + /// The next piece of the bag; every seven draws hold each kind once. + fn draw(&mut self) -> u8 { + if self.bag_at >= 7 { + for i in (1..7).rev() { + let j = (next(&mut self.rng) % (i as u32 + 1)) as usize; + self.bag.swap(i, j); + } + self.bag_at = 0; + } + self.bag_at += 1; + self.bag[self.bag_at - 1] + } + + /// A new game, the first piece falling. + pub fn start(&mut self, now: u32) { + self.board = [[0; W]; H]; + self.score = 0; + self.lines = 0; + self.flash = None; + self.soft = false; + self.state = State::Playing; + self.bag_at = 7; + self.next = self.draw(); + self.spawn(now); + } + + pub fn fits(&self, p: &Piece) -> bool { + p.cells().iter().all(|&(x, y)| x >= 0 && x < W as i32 && y < H as i32 && (y < 0 || self.board[y as usize][x as usize] == 0)) + } + + /// The next piece comes in at the top. `false`: no room, the game is over. + fn spawn(&mut self, now: u32) -> bool { + let kind = self.next; + self.next = self.draw(); + let p = Piece { kind, rot: 0, x: 3, y: if kind == I { -1 } else { 0 } }; + self.cur = Some(p); + self.drop_at = now.wrapping_add(self.interval()); + self.lock_at = None; + self.resets = 0; + if self.fits(&p) { + true + } else { + self.state = State::Over; + false + } + } + + /// The piece can not fall further. + pub fn resting(&self) -> bool { + self.cur.is_some_and(|p| !self.fits(&Piece { y: p.y + 1, ..p })) + } + + fn lock_delay(&self) -> u32 { + if self.soft { SOFT_LOCK_MS } else { LOCK_MS } + } + + /// After the piece moved or turned (`by_hand`) or fell: start, restart or cancel the lock timer. + fn settle(&mut self, now: u32, by_hand: bool) { + let delay = self.lock_delay(); + if !self.resting() { + if self.lock_at.take().is_some() { + self.drop_at = now.wrapping_add(self.interval()); // slid off the edge: it falls on + } + } else if self.lock_at.is_none() { + self.lock_at = Some(now.wrapping_add(delay)); + } else if by_hand && self.resets < MAX_RESETS { + self.resets += 1; + self.lock_at = Some(now.wrapping_add(delay)); + } + } + + /// One column left (-1) or right (+1). + pub fn shift(&mut self, dx: i32, now: u32) -> bool { + let Some(p) = self.cur.filter(|_| self.state == State::Playing && self.flash.is_none()) else { return false }; + let q = Piece { x: p.x + dx, ..p }; + if !self.fits(&q) { + return false; + } + self.cur = Some(q); + self.settle(now, true); + true + } + + /// A quarter turn clockwise, pushed aside or up if the wall or the stack is in the way. + pub fn turn(&mut self, now: u32) -> bool { + let Some(p) = self.cur.filter(|_| self.state == State::Playing && self.flash.is_none()) else { return false }; + if p.kind == O { + return false; + } + for (dx, dy) in KICKS { + let q = Piece { rot: (p.rot + 1) % 4, x: p.x + dx, y: p.y + dy, ..p }; + if self.fits(&q) { + self.cur = Some(q); + self.settle(now, true); + return true; + } + } + false + } + + /// The finger is on (`true`) or off the screen: the piece falls faster while it is on. + pub fn set_soft(&mut self, on: bool, now: u32) { + if on == self.soft { + return; + } + self.soft = on; + if self.state != State::Playing || self.flash.is_some() { + return; + } + if on { + if until(now, self.drop_at) > SOFT_MS { + self.drop_at = now.wrapping_add(SOFT_MS); // the first row comes soon, not after the long wait + } + if let Some(l) = self.lock_at { + self.lock_at = Some(if until(now, l) > SOFT_LOCK_MS { now.wrapping_add(SOFT_LOCK_MS) } else { l }); + } + } else { + self.drop_at = now.wrapping_add(self.interval()); + } + } + + /// Where the piece would land. + pub fn ghost(&self) -> Option { + let mut p = self.cur?; + while self.fits(&Piece { y: p.y + 1, ..p }) { + p.y += 1; + } + Some(p) + } + + /// Milliseconds until `tick` has something to do; `None`: nothing is due, wait for input. + pub fn wake_in(&self, now: u32) -> Option { + if let Some(f) = self.flash { + return Some(until(now, f.at)); + } + if self.state != State::Playing || self.cur.is_none() { + return None; + } + Some(if self.resting() { until(now, self.lock_at.unwrap_or(now)) } else { until(now, self.drop_at) }) + } + + /// After a pause: nothing is overdue, and the finger is off. + pub fn rebase(&mut self, now: u32) { + self.soft = false; + if let Some(f) = &mut self.flash { + f.at = now.wrapping_add(FLASH_MS); + } + if self.lock_at.is_some() { + self.lock_at = Some(now.wrapping_add(LOCK_MS)); + } + self.drop_at = now.wrapping_add(self.interval()); + } + + /// Does what is due at `now`: one fall, the lock, or one blink. + pub fn tick(&mut self, now: u32) -> Step { + if let Some(mut f) = self.flash { + if !due(now, f.at) { + return Step::Nothing; + } + f.step += 1; + f.at = now.wrapping_add(FLASH_MS); + if f.step < FLASH_STEPS { + self.flash = Some(f); + return Step::Nothing; + } + self.flash = None; + self.remove(f.rows); + return if self.spawn(now) { Step::Nothing } else { Step::Crashed }; + } + let Some(p) = self.cur.filter(|_| self.state == State::Playing) else { return Step::Nothing }; + if self.resting() { + let at = *self.lock_at.get_or_insert(now.wrapping_add(self.lock_delay())); + return if due(now, at) { self.lock(now) } else { Step::Nothing }; + } + if due(now, self.drop_at) { + self.cur = Some(Piece { y: p.y + 1, ..p }); + if self.soft { + self.score = (self.score + 1).min(SCORE_MAX); + } + self.drop_at = now.wrapping_add(self.interval()); + self.settle(now, false); + } + Step::Nothing + } + + fn lock(&mut self, now: u32) -> Step { + let Some(p) = self.cur.take() else { return Step::Nothing }; + let mut out = false; + for (x, y) in p.cells() { + if y < 0 { + out = true; // locked above the well + } else { + self.board[y as usize][x as usize] = p.kind + 1; + } + } + if out { + self.state = State::Over; + return Step::Crashed; + } + let rows = (0..H).filter(|&y| self.board[y].iter().all(|&c| c != 0)).fold(0u32, |m, y| m | 1 << y); + let n = rows.count_ones() as usize; + if n == 0 { + return if self.spawn(now) { Step::Locked } else { Step::Crashed }; + } + self.score = (self.score + LINE_POINTS[n] * (self.level() + 1)).min(SCORE_MAX); + self.lines += n as u32; + self.flash = Some(Flash { rows, step: 0, at: now.wrapping_add(FLASH_MS) }); + Step::Cleared(n as u8) + } + + /// Takes the rows in `rows` out; what is above falls down. + fn remove(&mut self, rows: u32) { + let mut to = H; + for from in (0..H).rev() { + if rows >> from & 1 == 0 { + to -= 1; + self.board[to] = self.board[from]; + } + } + for row in &mut self.board[..to] { + *row = [0; W]; + } + } +} + +pub const MAGIC: &[u8; 2] = b"T1"; + +pub fn encode(best: u32) -> [u8; 6] { + let b = best.to_le_bytes(); + [MAGIC[0], MAGIC[1], b[0], b[1], b[2], b[3]] +} + +/// Anything that isn't a blob of ours is no best score yet. +pub fn decode(blob: &[u8]) -> u32 { + match blob { + [b'T', b'1', a, b, c, d] => u32::from_le_bytes([*a, *b, *c, *d]).min(SCORE_MAX), + _ => 0, + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn playing(seed: u32) -> Game { + let mut g = Game::new(seed); + g.start(0); + g + } + + /// Runs the game's clock until `ms` have passed, in 1 ms steps like a worst case of tiny wake-ups. + fn run(g: &mut Game, from: u32, ms: u32) -> (u32, Vec) { + let mut seen = Vec::new(); + for t in from..from + ms { + let s = g.tick(t); + if s != Step::Nothing { + seen.push(s); + } + } + (from + ms, seen) + } + + #[test] + fn every_piece_has_four_cells_in_its_box_and_turns_back_after_four() { + for kind in 0..KINDS { + for rot in 0..4 { + let c = shape(kind, rot); + for (i, a) in c.iter().enumerate() { + assert!(a.0 >= 0 && a.0 < 4 && a.1 >= 0 && a.1 < 4, "kind {kind} rot {rot} {a:?}"); + assert!(!c[i + 1..].contains(a), "kind {kind} rot {rot} repeats {a:?}"); + } + } + assert_eq!(shape(kind, 4), shape(kind, 0)); + } + } + + #[test] + fn turning_keeps_the_pieces_shape() { + // T: three in a row and one on top, whatever the turn: one cell touches the three others + for rot in 0..4 { + let c = shape(2, rot); + let touching = |a: (i32, i32)| c.iter().filter(|b| (a.0 - b.0).abs() + (a.1 - b.1).abs() == 1).count(); + assert_eq!(c.iter().map(|&a| touching(a)).max(), Some(3), "rot {rot}"); + } + // I: a line of four, flat or standing + let flat = shape(0, 0); + assert!(flat.iter().all(|c| c.1 == 1)); + let tall = shape(0, 1); + assert!(tall.iter().all(|c| c.0 == 2)); + } + + #[test] + fn the_bag_holds_each_kind_once_per_seven() { + let mut g = Game::new(99); + for _ in 0..20 { + let mut seen = [0; 7]; + for _ in 0..7 { + seen[g.draw() as usize] += 1; + } + assert_eq!(seen, [1; 7]); + } + } + + #[test] + fn every_kind_spawns_inside_the_well_and_fits() { + for kind in 0..KINDS { + let g = playing(5); + let p = Piece { kind, rot: 0, x: 3, y: if kind == I { -1 } else { 0 } }; + assert!(g.fits(&p), "kind {kind}"); + let top = p.cells().iter().map(|c| c.1).min().unwrap(); + assert_eq!(top, 0, "kind {kind} shows from the first row"); + } + } + + #[test] + fn a_piece_falls_one_row_per_interval() { + let mut g = playing(1); + let y0 = g.cur.unwrap().y; + run(&mut g, 0, 799); + assert_eq!(g.cur.unwrap().y, y0); + run(&mut g, 799, 2); + assert_eq!(g.cur.unwrap().y, y0 + 1); + run(&mut g, 801, 800); + assert_eq!(g.cur.unwrap().y, y0 + 2); + assert_eq!(g.wake_in(1601).map(|w| w <= 800), Some(true)); + } + + #[test] + fn it_lands_waits_half_a_second_and_locks() { + let mut g = playing(3); + // let it fall to the floor + let mut t = 0; + while !g.resting() { + t += 1; + g.tick(t); + assert!(t < 30_000); + } + let landed = t; + let (_, steps) = run(&mut g, landed + 1, LOCK_MS - 2); + assert!(steps.is_empty(), "{steps:?}"); + let (_, steps) = run(&mut g, landed + LOCK_MS - 1, 10); + assert_eq!(steps, vec![Step::Locked]); + assert!(g.board.iter().flatten().filter(|&&c| c != 0).count() == 4); + assert!(g.cur.is_some(), "the next piece is already in"); + } + + #[test] + fn walls_stop_the_piece_and_moves_into_them_say_so() { + let mut g = playing(7); + let mut n = 0; + while g.shift(-1, 0) { + n += 1; + assert!(n < 12); + } + assert!(g.cur.unwrap().cells().iter().any(|c| c.0 == 0)); + assert!(!g.shift(-1, 0)); + let mut m = 0; + while g.shift(1, 0) { + m += 1; + assert!(m < 20); + } + assert!(g.cur.unwrap().cells().iter().any(|c| c.0 == W as i32 - 1)); + assert!(m >= 6); + } + + #[test] + fn a_turn_next_to_the_wall_kicks_the_piece_back_in() { + // a standing I against the right wall turned flat would stick out: it is moved left + let mut g = playing(7); + g.cur = Some(Piece { kind: 0, rot: 1, x: 7, y: 5 }); // cells at x = 9 + assert!(g.fits(&g.cur.unwrap())); + assert!(g.turn(0)); + let p = g.cur.unwrap(); + assert!(g.fits(&p)); + assert_eq!(p.rot, 2); + assert!(p.cells().iter().all(|c| c.0 <= 9)); + // the square does not turn at all + g.cur = Some(Piece { kind: 1, rot: 0, x: 3, y: 5 }); + assert!(!g.turn(0)); + } + + #[test] + fn turning_is_refused_when_it_can_not_fit() { + let mut g = playing(7); + for y in 0..H { + for x in 0..W { + g.board[y][x] = 1; + } + } + // a one-cell-wide shaft, a flat I at the bottom of it + for y in 10..H { + g.board[y][4] = 0; + } + g.cur = Some(Piece { kind: 0, rot: 1, x: 2, y: 10 }); // standing in column 4 + assert!(g.fits(&g.cur.unwrap())); + let before = g.cur; + assert!(!g.turn(0)); + assert_eq!(g.cur, before); + } + + #[test] + fn full_rows_blink_then_go_and_the_rest_falls() { + let mut g = playing(2); + // two full rows with a gap at column 0, and a single block on top of them + for y in H - 2..H { + for x in 1..W { + g.board[y][x] = 3; + } + } + g.board[H - 3][5] = 6; + // a vertical I to fill column 0: x = -2 puts its cells in column 0 + g.cur = Some(Piece { kind: 0, rot: 1, x: -2, y: H as i32 - 4 }); + assert!(g.fits(&g.cur.unwrap())); + let level = g.level(); + let mut t = 0; + let mut got = None; + while got.is_none() && t < 5000 { + t += 1; + let s = g.tick(t); + if matches!(s, Step::Cleared(_)) { + got = Some(s); + } + } + assert_eq!(got, Some(Step::Cleared(2))); + assert_eq!(g.score, 300 * (level + 1)); + assert_eq!(g.lines, 2); + let f = g.flash.unwrap(); + assert_eq!(f.rows, 0b11 << (H - 2)); + assert!(g.cur.is_none()); + assert_eq!(g.wake_in(t), Some(FLASH_MS)); + // the blink runs, the rows go + let mut lit = 0; + for _ in 0..FLASH_STEPS as u32 * FLASH_MS + 5 { + t += 1; + if g.flash.is_some_and(|f| f.lit()) { + lit += 1; + } + g.tick(t); + } + assert!(lit > 100, "the rows blinked white"); + assert!(g.flash.is_none()); + assert!(g.cur.is_some(), "the next piece is in"); + // what was on top fell two rows: the single block and the top of the I piece (column 0) are at the bottom + assert_eq!(g.board[H - 1][5], 6); + assert_eq!(g.board[H - 1][0], 1); + assert_eq!(g.board[H - 2][0], 1); + assert_eq!(g.board[H - 1].iter().filter(|&&c| c != 0).count(), 2); + assert_eq!(g.board[H - 2].iter().filter(|&&c| c != 0).count(), 1); + assert!(g.board[..H - 2].iter().flatten().all(|&c| c == 0)); + } + + #[test] + fn a_tetris_scores_800_and_the_level_follows_the_lines() { + let mut g = playing(2); + for y in H - 4..H { + for x in 1..W { + g.board[y][x] = 2; + } + } + g.cur = Some(Piece { kind: 0, rot: 1, x: -2, y: H as i32 - 4 }); + let mut t = 0; + loop { + t += 1; + if let Step::Cleared(n) = g.tick(t) { + assert_eq!(n, 4); + break; + } + assert!(t < 5000); + } + assert_eq!(g.score, 800); + g.lines = 9; + assert_eq!(g.level(), 0); + g.lines = 10; + assert_eq!(g.level(), 1); + g.lines = 10_000; + assert_eq!(g.level(), 19); + assert!(g.interval() == 33); + } + + #[test] + fn holding_makes_it_fall_fast_and_scores_a_point_per_row() { + let mut g = playing(4); + let y0 = g.cur.unwrap().y; + g.set_soft(true, 10); + // first row after SOFT_MS, then one per SOFT_MS + run(&mut g, 10, SOFT_MS - 2); + assert_eq!(g.cur.unwrap().y, y0); + run(&mut g, 10 + SOFT_MS - 2, 3); + assert_eq!(g.cur.unwrap().y, y0 + 1); + run(&mut g, 10 + SOFT_MS + 1, 4 * SOFT_MS); + assert_eq!(g.cur.unwrap().y, y0 + 5); + assert_eq!(g.score, 5); + // letting go: back to the level's speed + let now = 10 + 5 * SOFT_MS + 1; + g.set_soft(false, now); + let y = g.cur.unwrap().y; + run(&mut g, now, 700); + assert_eq!(g.cur.unwrap().y, y); + run(&mut g, now + 700, 150); + assert_eq!(g.cur.unwrap().y, y + 1); + } + + #[test] + fn a_piece_on_the_floor_can_be_slid_but_not_forever() { + let mut g = playing(3); + let mut t = 0; + while !g.resting() { + t += 1; + g.tick(t); + } + // slide every 400 ms: the timer restarts, up to the cap, then the piece locks anyway + let landed = t; + let mut left = true; + let mut locked_at = None; + for _ in 0..40 { + t += 400; + for k in 0..400 { + if g.tick(t - 400 + k) != Step::Nothing { + locked_at = Some(t - 400 + k); + break; + } + } + if locked_at.is_some() { + break; + } + if !g.shift(if left { -1 } else { 1 }, t) { + left = !left; + g.shift(if left { -1 } else { 1 }, t); + } + if !g.resting() { + break; // slid off the stack: fine for this test + } + } + let n = (locked_at.expect("it locks") - landed) / 400; + assert!(n >= 2 && n <= 2 + MAX_RESETS as u32 + 2, "{n}"); + } + + #[test] + fn a_full_stack_ends_the_game() { + let mut g = playing(8); + for y in 0..H { + for x in 0..W { + g.board[y][x] = if x == 0 { 0 } else { 1 }; + } + } + // the next spawn has no room + g.board[0][0] = 1; + let mut t = 0; + let mut over = false; + while t < 3000 { + t += 1; + if g.tick(t) == Step::Crashed { + over = true; + break; + } + } + assert!(over); + assert_eq!(g.state, State::Over); + assert_eq!(g.wake_in(t), None); + assert!(!g.shift(1, t) && !g.turn(t)); + } + + #[test] + fn the_ghost_is_where_the_piece_lands() { + let mut g = playing(6); + let gh = g.ghost().unwrap(); + assert!(g.fits(&gh)); + assert!(!g.fits(&Piece { y: gh.y + 1, ..gh })); + assert_eq!((gh.kind, gh.rot, gh.x), (g.cur.unwrap().kind, g.cur.unwrap().rot, g.cur.unwrap().x)); + g.board[H - 1] = [1; W]; + let gh2 = g.ghost().unwrap(); + assert_eq!(gh2.y, gh.y - 1); + } + + #[test] + fn pausing_leaves_nothing_overdue() { + let mut g = playing(6); + let y = g.cur.unwrap().y; + g.rebase(1_000_000); + assert_eq!(g.tick(1_000_000), Step::Nothing); + assert_eq!(g.cur.unwrap().y, y); + assert!(g.wake_in(1_000_000).unwrap() > 700); + } + + #[test] + fn the_clock_may_wrap() { + let mut g = Game::new(3); + g.start(u32::MAX - 100); + let y = g.cur.unwrap().y; + let mut t = u32::MAX - 100; + for _ in 0..900 { + t = t.wrapping_add(1); + g.tick(t); + } + assert_eq!(g.cur.unwrap().y, y + 1); + } + + #[test] + fn best_score_blob_round_trips_and_rejects_junk() { + assert_eq!(decode(&encode(12345)), 12345); + assert_eq!(decode(&[]), 0); + assert_eq!(decode(b"SH1\x01\x00\x00\x00"), 0); + assert_eq!(decode(&encode(u32::MAX)), SCORE_MAX); + } + + /// Whatever is pressed, the stack never holds more than the well and every piece stays on the board. + #[test] + fn random_play_keeps_the_rules() { + for seed in 1..40u32 { + let mut g = playing(seed); + let mut r = seed * 7919; + let mut t = 0u32; + for _ in 0..30_000 { + t += 7; + match next(&mut r) % 9 { + 0 => { + g.shift(-1, t); + } + 1 => { + g.shift(1, t); + } + 2 => { + g.turn(t); + } + 3 => g.set_soft(next(&mut r) % 2 == 0, t), + _ => {} + } + g.tick(t); + if let Some(p) = g.cur { + if g.state == State::Playing { + assert!(g.fits(&p), "seed {seed} t {t}"); + } + } + if g.state == State::Over { + g.start(t); + } + } + } + } +} diff --git a/apps/tetris/src/main.rs b/apps/tetris/src/main.rs new file mode 100644 index 0000000..c75593b --- /dev/null +++ b/apps/tetris/src/main.rs @@ -0,0 +1,170 @@ +#![cfg_attr(any(target_os = "none", wp2_sim), no_main, cfg_attr(target_os = "none", no_std))] + +#[cfg_attr(not(any(target_os = "none", wp2_sim)), allow(dead_code))] +mod game; +#[cfg_attr(not(any(target_os = "none", wp2_sim)), allow(dead_code))] +mod view; + +#[cfg(not(any(target_os = "none", wp2_sim)))] +fn main() {} + +#[cfg(any(target_os = "none", wp2_sim))] +mod device { + use crate::game::{Game, State, Step, decode, due, encode}; + use crate::view::{frame, seen}; + use cmf_wp2_app::{Api, BUTTON, CROWN, PAUSE, RESUME, TOUCH_DOWN, TOUCH_UP}; + use cmf_wp2_ui::haptic::{DOUBLE, DONE, Motor, TICK}; + + cmf_wp2_app::entry!(main); + cmf_wp2_app::app_icon!(); + + /// A finger that stays on the glass this long is a hold (the piece drops fast), a shorter one is a tap (it turns). + const HOLD_MS: u32 = 220; + /// Taps right after the game ended don't start a new one: they were meant for the game that just ended. + const RETRY_MS: u32 = 700; + /// Turning the crown clockwise moves the piece right. Flip this if your watch counts the other way. + const CROWN_RIGHT: i16 = 1; + + // true on RESUME, false on BUTTON + fn paused(api: &Api) -> bool { + loop { + match api.event(u32::MAX).map(|e| e.kind) { + Some(RESUME) => return true, + Some(BUTTON) => return false, + _ => {} + } + } + } + + fn seed(api: &Api) -> u32 { + let t = api.time().map_or(0, |t| (t.minute as u32 * 60 + t.second as u32) * 1000 + t.millis as u32); + api.now().wrapping_mul(2_654_435_761) ^ t + } + + /// The finger on the glass: when it came down and what the game was doing then. + #[derive(Clone, Copy)] + struct Finger { + at: u32, + state: State, + holding: bool, + } + + fn main(api: &'static Api) -> i32 { + let mut screen = api; + let mut motor = Motor::new(api); // dropped on return: the motor goes off + let mut blob = [0u8; 16]; + let n = api.load(&mut blob); + let mut best = if n > 0 { decode(&blob[..n as usize]) } else { 0 }; + let mut g = Game::new(seed(api)); + let mut on_screen = Some(frame(&mut screen, &g, best, None)); + api.show(); + let mut finger: Option = None; + let mut over_at = 0u32; + loop { + motor.update(); + let now = api.now(); + // what is due next: the game, the end of a tap (a hold begins), the motor + let mut wait = g.wake_in(now).unwrap_or(u32::MAX); + if let Some(f) = finger.filter(|f| f.state == State::Playing && !f.holding) { + let left = (f.at.wrapping_add(HOLD_MS).wrapping_sub(now) as i32).max(0) as u32; + wait = wait.min(left); + } + if let Some(m) = motor.wait() { + wait = wait.min(m); + } + let mut first = api.event(wait); + let mut redraw_all = false; + let mut quit = false; + // handle this event and everything else already queued, then draw once + for _ in 0..16 { + let Some(e) = first.take().or_else(|| api.event(0)) else { break }; + let now = api.now(); + match e.kind { + BUTTON => quit = true, + PAUSE => { + motor.off(); + g.set_soft(false, now); + if !paused(api) { + quit = true; + } else { + finger = None; + g.rebase(api.now()); + redraw_all = true; + } + } + TOUCH_DOWN => { + finger = Some(Finger { at: now, state: g.state, holding: false }); + } + TOUCH_UP => { + let Some(f) = finger.take() else { continue }; + if f.holding { + g.set_soft(false, now); + } else if f.state != g.state { + // the game changed under the finger: this touch belonged to something else + } else { + match g.state { + State::Playing => { + g.turn(now); + } + State::Ready => g.start(now), + State::Over => { + if due(f.at, over_at.wrapping_add(RETRY_MS)) { + g.start(now); + } + } + } + } + } + CROWN => { + g.shift(if e.delta * CROWN_RIGHT > 0 { 1 } else { -1 }, now); + } + _ => {} + } + if quit { + break; + } + } + if quit { + api.keep_screen_on(false); + return 0; + } + let now = api.now(); + // a finger that stayed down: the piece drops + if let Some(f) = &mut finger { + if f.state == State::Playing && g.state == State::Playing && !f.holding && due(now, f.at.wrapping_add(HOLD_MS)) { + f.holding = true; + g.set_soft(true, now); + } + } + // what is due in the game; at most a few things per wake-up, the rest on the next one + for _ in 0..4 { + if g.wake_in(now) != Some(0) { + break; + } + match g.tick(now) { + Step::Locked => motor.play(TICK), + Step::Cleared(n) => motor.play(if n >= 4 { DONE } else { DOUBLE }), + Step::Crashed => { + motor.play(DONE); + over_at = now; + if g.score > best { + best = g.score; + api.save(&encode(best)); // on change: the app can be ended without notice + } + } + Step::Nothing => {} + } + } + if g.state == State::Over && finger.is_some_and(|f| f.state == State::Playing) { + finger = None; // the hold that ended the game ends with it + } + let before = on_screen; + let now_seen = seen(&g, best); + if redraw_all || before != Some(now_seen) { + on_screen = Some(frame(&mut screen, &g, best, if redraw_all { None } else { before })); + api.show(); + } + api.keep_screen_on(g.state == State::Playing); + } + } +} diff --git a/apps/tetris/src/view.rs b/apps/tetris/src/view.rs new file mode 100644 index 0000000..058102f --- /dev/null +++ b/apps/tetris/src/view.rs @@ -0,0 +1,569 @@ +// Drawing, through cmf-wp2-ui's Surface: the watch draws with `&Api`, the tests with `Fb`. One buffer and no double +// buffering, so a frame repaints only the cells and numbers that changed, and never paints a pixel twice in different +// colours: each cell is its own 20 px square, filled and then drawn on once. + +use crate::game::{Game, H, SCORE_MAX, State, W, shape}; +use cmf_wp2_ui::draw::rrect; +use cmf_wp2_ui::text::{big, big_width, centre, int, width}; +use cmf_wp2_ui::{C, Rgb, Surface}; + +pub const SIZE: i32 = cmf_wp2_ui::SIZE; +/// A cell, and the well's top left corner: 200 x 400 px, centred. Its far corners sit 224 px from the centre, inside +/// the round panel (233). +pub const CELL: i32 = 20; +pub const BX: i32 = C - W as i32 * CELL / 2; +pub const BY: i32 = C - H as i32 * CELL / 2; + +const BLACK: u16 = 0; +const WELL: Rgb = Rgb(9, 10, 14); +const DOT: Rgb = Rgb(30, 33, 44); +const FRAME: Rgb = Rgb(58, 63, 82); +const PANEL: Rgb = Rgb(20, 22, 30); +const WHITE: Rgb = Rgb(255, 255, 255); +const GREY: u16 = 0x8C71; +const TEAL: Rgb = Rgb(94, 230, 168); + +/// I O T S Z J L +pub const COLORS: [Rgb; 7] = [ + Rgb(62, 214, 230), + Rgb(255, 201, 60), + Rgb(160, 108, 240), + Rgb(94, 230, 168), + Rgb(242, 87, 95), + Rgb(60, 130, 240), + Rgb(255, 148, 64), +]; + +/// What a cell shows: 0 empty, 1..=7 a block of that kind, GHOST + kind where the piece would land, FLASH a +/// blinking row. +const GHOST: u8 = 8; +const FLASH: u8 = 15; + +/// The HUD: numbers right-aligned at LEFT_X on the left of the well, the next piece and the best score on the right. +const LEFT_X: i32 = BX - 12; +const RIGHT_X: i32 = BX + W as i32 * CELL + 14; +const FIELD_W: i32 = 96; +const SCORE_Y: i32 = 140; +const LINES_Y: i32 = 206; +const LEVEL_Y: i32 = 272; +const NEXT_Y: i32 = 140; +const BEST_Y: i32 = 272; + +/// What is on screen after a frame. +#[derive(Clone, Copy, PartialEq, Debug)] +pub struct Seen { + cells: [[u8; W]; H], + score: u32, + lines: u32, + level: u32, + next: u8, + best: u32, + state: State, +} + +fn compose(g: &Game) -> [[u8; W]; H] { + if g.state == State::Ready { + return [[0; W]; H]; + } + let mut c = g.board; + if g.state == State::Playing && g.flash.is_none() { + if let Some(gh) = g.ghost() { + for (x, y) in gh.cells() { + if y >= 0 && c[y as usize][x as usize] == 0 { + c[y as usize][x as usize] = GHOST + gh.kind; + } + } + } + } + if let Some(p) = g.cur { + for (x, y) in p.cells() { + if y >= 0 { + c[y as usize][x as usize] = p.kind + 1; + } + } + } + if let Some(f) = g.flash.filter(|f| f.lit()) { + for (y, row) in c.iter_mut().enumerate() { + if f.rows >> y & 1 == 1 { + *row = [FLASH; W]; + } + } + } + c +} + +pub fn seen(g: &Game, best: u32) -> Seen { + Seen { + cells: compose(g), + score: g.score.min(SCORE_MAX), + lines: g.lines.min(9999), + level: g.level() + 1, + next: g.next, + best: best.min(SCORE_MAX), + state: g.state, + } +} + +/// A block of `size` px: a darker rim, a lit face and a small sheen, like the icon. +fn tile(s: &mut impl Surface, x: i32, y: i32, size: i32, c: Rgb, bg: Rgb) { + let r = size / 4; + let dark = c.scale(680); + rrect(s, x + 1, y + 1, size - 2, size - 2, r + 1, dark, bg); + rrect(s, x + 2, y + 2, size - 4, size - 5, r, c, dark); + rrect(s, x + size / 4 + 1, y + size / 5 + 1, size / 2, 2, 1, c.mix(WHITE, 470), c); +} + +/// The outline of where the piece will land. +fn ghost(s: &mut impl Surface, x: i32, y: i32, c: Rgb) { + let dim = c.scale(420); + rrect(s, x + 1, y + 1, CELL - 2, CELL - 2, 5, dim, WELL); + rrect(s, x + 3, y + 3, CELL - 6, CELL - 6, 3, WELL, dim); +} + +fn cell(s: &mut impl Surface, cx: usize, cy: usize, v: u8) { + let (x, y) = (BX + cx as i32 * CELL, BY + cy as i32 * CELL); + s.rect(x, y, CELL, CELL, WELL.rgb565()); + match v { + 0 => s.rect(x + CELL / 2 - 1, y + CELL / 2 - 1, 2, 2, DOT.rgb565()), + 1..=7 => tile(s, x, y, CELL, COLORS[v as usize - 1], WELL), + GHOST..=14 => ghost(s, x, y, COLORS[(v - GHOST) as usize]), + _ => tile(s, x, y, CELL, Rgb(245, 248, 255), WELL), + } +} + +/// A number in a box, right-aligned at `xr`. +fn field(s: &mut impl Surface, xr: i32, y: i32, n: u32, c: u16) { + let mut buf = [0u8; 11]; + let t = int(n as i32, &mut buf); + s.rect(xr - FIELD_W, y, FIELD_W, 16, BLACK); + s.text(xr - width(t), y, t, c); +} + +fn label(s: &mut impl Surface, xr: i32, y: i32, t: &str) { + s.text(xr - width(t), y - 20, t, GREY); +} + +fn next_box(s: &mut impl Surface, kind: u8) { + const BW: i32 = 84; + const BH: i32 = 64; + const T: i32 = 14; + rrect(s, RIGHT_X, NEXT_Y + 2, BW, BH, 14, PANEL, Rgb(0, 0, 0)); + let c = shape(kind, 0); + let (x0, x1) = (c.iter().map(|p| p.0).min().unwrap_or(0), c.iter().map(|p| p.0).max().unwrap_or(0)); + let (y0, y1) = (c.iter().map(|p| p.1).min().unwrap_or(0), c.iter().map(|p| p.1).max().unwrap_or(0)); + let (w, h) = ((x1 - x0 + 1) * T, (y1 - y0 + 1) * T); + let (ox, oy) = (RIGHT_X + (BW - w) / 2, NEXT_Y + 2 + (BH - h) / 2); + for (px, py) in c { + tile(s, ox + (px - x0) * T, oy + (py - y0) * T, T, COLORS[kind as usize % 7], PANEL); + } +} + +fn hud(s: &mut impl Surface, n: &Seen, p: Option<&Seen>) { + let changed = |f: fn(&Seen) -> u32| p.is_none_or(|p| f(p) != f(n)); + if p.is_none() { + label(s, LEFT_X, SCORE_Y, "SCORE"); + label(s, LEFT_X, LINES_Y, "LINES"); + label(s, LEFT_X, LEVEL_Y, "LEVEL"); + s.text(RIGHT_X + 2, NEXT_Y - 20, "NEXT", GREY); + s.text(RIGHT_X + 2, BEST_Y - 20, "BEST", GREY); + } + if changed(|s| s.score) { + field(s, LEFT_X, SCORE_Y, n.score, WHITE.rgb565()); + } + if changed(|s| s.lines) { + field(s, LEFT_X, LINES_Y, n.lines, TEAL.rgb565()); + } + if changed(|s| s.level) { + field(s, LEFT_X, LEVEL_Y, n.level, TEAL.rgb565()); + } + if p.is_none_or(|p| p.next != n.next) { + next_box(s, n.next); + } + if changed(|s| s.best) { + // left-aligned under its label + let mut buf = [0u8; 11]; + let t = int(n.best as i32, &mut buf); + s.rect(RIGHT_X, BEST_Y, FIELD_W, 16, BLACK); + s.text(RIGHT_X + 2, BEST_Y, t, WHITE.rgb565()); + } +} + +fn frame_bars(s: &mut impl Surface) { + let h = H as i32 * CELL; + let w = W as i32 * CELL; + s.rect(BX - 4, BY, 2, h + 4, FRAME.rgb565()); + s.rect(BX + w + 2, BY, 2, h + 4, FRAME.rgb565()); + s.rect(BX - 4, BY + h + 2, w + 8, 2, FRAME.rgb565()); +} + +/// The big title: each letter in the colour of a piece. +fn title(s: &mut impl Surface, y: i32) { + const T: &str = "TETRIS"; + let x = C - big_width(T, 5) / 2; + for (i, ch) in T.char_indices() { + let mut one = [0u8; 4]; + let t = ch.encode_utf8(&mut one); + big(s, x + i as i32 * 40, y, t, 5, COLORS[[2, 4, 1, 0, 3, 5][i]].rgb565()); + } +} + +fn ready(s: &mut impl Surface, best: u32) { + s.rect(0, 0, SIZE, SIZE, BLACK); + title(s, 70); + // a T piece about to drop into the gap in the row under it + const P: i32 = 34; + let (x0, y0) = (C - (3 * P - 2) / 2, 142); + let black = Rgb(0, 0, 0); + for (cx, cy, k, dim) in [(0, 0, 2, false), (1, 0, 2, false), (2, 0, 2, false), (1, 1, 2, false), (0, 2, 5, true), (2, 2, 5, true)] { + let c = COLORS[k]; + tile(s, x0 + cx * P, y0 + cy * P, P - 2, if dim { c.scale(500) } else { c }, black); + } + centre(s, C, 268, "TAP TO PLAY", WHITE.rgb565()); + centre(s, C, 312, "TAP: TURN", GREY); + centre(s, C, 334, "HOLD: DROP", GREY); + centre(s, C, 356, "CROWN: MOVE", GREY); + if best > 0 { + let mut buf = [0u8; 11]; + let mut line = [0u8; 16]; + let n = int(best as i32, &mut buf).as_bytes(); + line[..5].copy_from_slice(b"BEST "); + line[5..5 + n.len()].copy_from_slice(n); + centre(s, C, 396, core::str::from_utf8(&line[..5 + n.len()]).unwrap_or("?"), TEAL.rgb565()); + } +} + +fn over(s: &mut impl Surface, n: &Seen) { + let (w, h) = (192, 176); + let (x, y) = (C - w / 2, 136); + rrect(s, x, y, w, h, 22, PANEL, WELL); + let red = COLORS[4].rgb565(); + big(s, C - big_width("GAME", 3) / 2, y + 14, "GAME", 3, red); + big(s, C - big_width("OVER", 3) / 2, y + 42, "OVER", 3, red); + let mut buf = [0u8; 11]; + centre(s, C, y + 86, int(n.score as i32, &mut buf), WHITE.rgb565()); + let mut line = [0u8; 16]; + let b = int(n.best as i32, &mut buf).as_bytes(); + line[..5].copy_from_slice(b"BEST "); + line[5..5 + b.len()].copy_from_slice(b); + centre(s, C, y + 110, core::str::from_utf8(&line[..5 + b.len()]).unwrap_or("?"), TEAL.rgb565()); + centre(s, C, y + 146, "TAP TO PLAY", GREY); +} + +/// Draws the frame for `g`. `prev`: what is on screen now; `None`, or another state, repaints everything. +pub fn frame(s: &mut impl Surface, g: &Game, best: u32, prev: Option) -> Seen { + let now = seen(g, best); + match prev.filter(|p| p.state == now.state) { + None => { + if now.state == State::Ready { + ready(s, best); + } else { + s.rect(0, 0, SIZE, SIZE, BLACK); + frame_bars(s); + for (y, row) in now.cells.iter().enumerate() { + for (x, &v) in row.iter().enumerate() { + cell(s, x, y, v); + } + } + hud(s, &now, None); + if now.state == State::Over { + over(s, &now); + } + } + } + Some(p) => { + if now.state == State::Playing { + for (y, (a, b)) in p.cells.iter().zip(&now.cells).enumerate() { + for (x, (&u, &v)) in a.iter().zip(b).enumerate() { + if u != v { + cell(s, x, y, v); + } + } + } + hud(s, &now, Some(&p)); + } + } + } + now +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::game::Piece; + use cmf_wp2_ui::{Count, Fb}; + use std::vec; + use std::vec::Vec; + + fn screen() -> Vec { + vec![0u16; (SIZE * SIZE) as usize] + } + + fn full(g: &Game, best: u32) -> Vec { + let mut px = screen(); + frame(&mut Fb::new(&mut px), g, best, None); + px + } + + fn playing(seed: u32) -> Game { + let mut g = Game::new(seed); + g.start(0); + g + } + + fn inside(x: i32, y: i32) -> bool { + (x - C) * (x - C) + (y - C) * (y - C) <= C * C + } + + #[test] + fn the_well_and_its_frame_lie_inside_the_round_panel() { + let (w, h) = (W as i32 * CELL, H as i32 * CELL); + for (x, y) in [(BX - 4, BY), (BX + w + 4, BY), (BX - 4, BY + h + 4), (BX + w + 4, BY + h + 4)] { + assert!(inside(x, y), "({x}, {y}) is off the panel"); + } + assert_eq!((BX, BY), (133, 33)); + } + + #[test] + fn the_hud_lies_inside_the_round_panel() { + // every text and box: its corners (a label is 5 chars, a number up to 6, the next box 84 x 66) + let right = RIGHT_X + FIELD_W; + for (x0, x1, y0, y1) in [ + (LEFT_X - 80, LEFT_X, SCORE_Y - 20, SCORE_Y - 4), + (LEFT_X - FIELD_W, LEFT_X, SCORE_Y, SCORE_Y + 16), + (LEFT_X - 80, LEFT_X, LINES_Y - 20, LINES_Y + 16), + (LEFT_X - 80, LEFT_X, LEVEL_Y - 20, LEVEL_Y + 16), + (RIGHT_X, RIGHT_X + 64, NEXT_Y - 20, NEXT_Y - 4), + (RIGHT_X, RIGHT_X + 84, NEXT_Y + 2, NEXT_Y + 66), + (RIGHT_X, right, BEST_Y - 20, BEST_Y + 16), + ] { + for (x, y) in [(x0, y0), (x1, y0), (x0, y1), (x1, y1)] { + assert!(inside(x, y), "({x}, {y})"); + } + } + } + + #[test] + fn the_title_screens_text_fits_the_panel() { + let wide = |t: &str, y: i32| { + let w = width(t); + assert!(inside(C - w / 2, y) && inside(C + w / 2, y) && inside(C - w / 2, y + 16) && inside(C + w / 2, y + 16), "{t}"); + }; + wide("TAP TO PLAY", 268); + wide("CROWN: MOVE", 356); + wide("BEST 999999", 396); + let tw = big_width("TETRIS", 5); + assert!(inside(C - tw / 2, 70) && inside(C + tw / 2, 110)); + } + + /// Plays on its own for a while and, now and then, compares what the partial frames made with a full repaint. + #[test] + fn partial_frames_match_a_full_repaint() { + for seed in [1u32, 8, 77] { + let mut g = playing(seed); + let mut px = screen(); + let mut prev = None; + let mut r = seed.wrapping_mul(2_654_435_761) | 1; + let mut rnd = move || { + r ^= r << 13; + r ^= r >> 17; + r ^= r << 5; + r + }; + let mut checked = 0; + let mut t = 0u32; + for step in 0..6000u32 { + t += 16; + match rnd() % 11 { + 0 | 1 => { + g.shift(-1, t); + } + 2 | 3 => { + g.shift(1, t); + } + 4 => { + g.turn(t); + } + 5 => g.set_soft(rnd() % 3 != 0, t), + _ => {} + } + g.tick(t); + if g.state == State::Over { + prev = Some(frame(&mut Fb::new(&mut px), &g, 3, prev)); + assert_eq!(px, full(&g, 3), "over, seed {seed}"); + g.start(t); + prev = None; + } + prev = Some(frame(&mut Fb::new(&mut px), &g, 3, prev)); + if step % 9 == 0 { + let want = full(&g, 3); + let bad = px.iter().zip(&want).position(|(a, b)| a != b); + assert_eq!(bad.map(|i| (i as i32 % SIZE, i as i32 / SIZE)), None, "seed {seed} step {step}"); + checked += 1; + } + } + assert!(checked > 100); + } + } + + #[test] + fn a_still_frame_draws_nothing() { + for state in [State::Ready, State::Playing] { + let mut g = Game::new(4); + if state == State::Playing { + g.start(0); + } + let mut px = screen(); + let mut fb = Fb::new(&mut px); + let p = frame(&mut fb, &g, 10, None); + let rects = fb.rects; + assert!(rects > 0); + frame(&mut fb, &g, 10, Some(p)); + assert_eq!(fb.rects, rects, "{state:?}"); + } + } + + #[test] + fn a_move_costs_a_handful_of_cells_not_the_screen() { + let mut g = playing(5); + let mut px = screen(); + let mut fb = Fb::new(&mut px); + let p = frame(&mut fb, &g, 0, None); + let first = fb.rects; + g.shift(1, 10); + fb.rects = 0; + let p = frame(&mut fb, &g, 0, Some(p)); + let move_cost = fb.rects; + // the piece and its guide change cells: at most 16 of them, a few rects each + assert!(move_cost > 0 && move_cost < 700, "{move_cost}"); + assert!(move_cost * 8 < first, "{move_cost} vs a full paint of {first}"); + g.turn(20); + fb.rects = 0; + frame(&mut fb, &g, 0, Some(p)); + assert!(fb.rects < 900, "{}", fb.rects); + // and a full repaint is cheap enough to do at any time + let mut c = Count::default(); + frame(&mut c, &g, 0, None); + assert!(c.rects < 3000, "{}", c.rects); + } + + #[test] + fn cells_stay_inside_their_squares() { + // draw each kind of cell on a marked background and look for pixels outside the 20 px square + for v in 0..=FLASH { + if (9..GHOST).contains(&v) { + continue; + } + let mut px = vec![0xABCDu16; (SIZE * SIZE) as usize]; + cell(&mut Fb::new(&mut px), 3, 4, v); + let (x0, y0) = (BX + 3 * CELL, BY + 4 * CELL); + for y in 0..SIZE { + for x in 0..SIZE { + let inside = x >= x0 && x < x0 + CELL && y >= y0 && y < y0 + CELL; + if !inside { + assert_eq!(px[(y * SIZE + x) as usize], 0xABCD, "value {v} spilled to ({x}, {y})"); + } + } + } + } + } + + #[test] + fn each_kind_has_its_own_colour_on_screen() { + let mut seen = Vec::new(); + for k in 1..=7u8 { + let mut px = screen(); + cell(&mut Fb::new(&mut px), 0, 0, k); + seen.push(px[((BY + 10) * SIZE + BX + 8) as usize]); + } + seen.sort(); + seen.dedup(); + assert_eq!(seen.len(), 7); + } + + #[test] + fn the_ghost_shows_under_the_piece_and_not_over_blocks() { + let mut g = playing(6); + g.cur = Some(Piece { kind: 2, rot: 0, x: 3, y: 0 }); + let c = compose(&g); + let gh = g.ghost().unwrap(); + for (x, y) in gh.cells() { + assert_eq!(c[y as usize][x as usize], GHOST + 2); + } + for (x, y) in g.cur.unwrap().cells() { + assert_eq!(c[y as usize][x as usize], 3); + } + // locked blocks are never overdrawn by the guide + g.board[H - 1] = [4; W]; + let c = compose(&g); + assert!(c[H - 1].iter().all(|&v| v == 4)); + } + + #[test] + fn a_blinking_row_is_white_every_other_step() { + let mut g = playing(2); + for y in H - 1..H { + for x in 1..W { + g.board[y][x] = 2; + } + } + g.cur = Some(Piece { kind: 0, rot: 1, x: -2, y: H as i32 - 4 }); + let mut t = 0; + while g.flash.is_none() { + t += 1; + g.tick(t); + assert!(t < 5000); + } + let mut saw = (false, false); + for _ in 0..600 { + t += 1; + g.tick(t); + if let Some(f) = g.flash { + let c = compose(&g); + if f.lit() { + assert_eq!(c[H - 1], [FLASH; W]); + saw.0 = true; + } else { + assert_ne!(c[H - 1], [FLASH; W]); + saw.1 = true; + } + } + } + assert_eq!(saw, (true, true)); + } + + /// `PREVIEW=/abs/dir cargo test dump_preview`: raw RGB565 frames of the screen, for pictures. + #[test] + fn dump_preview() { + let Ok(dir) = std::env::var("PREVIEW") else { return }; + let save = |name: &str, px: &[u16]| { + let bytes: Vec = px.iter().flat_map(|v| v.to_le_bytes()).collect(); + std::fs::write(format!("{dir}/{name}.raw"), bytes).unwrap(); + }; + let g = Game::new(3); + save("ready", &full(&g, 12400)); + // a game in progress: pile some random blocks, a falling piece, and a few cleared rows + let mut g = playing(11); + let rows: [&str; 8] = ["IIIIZZ.TTT", "OO.JJJ.ZZT", "OOSSJLLLZZ", "TTTSSLJJJZ", "ZZ.OOLJ.SS", ".ZZOOL.SSL", "LLL.TTTSSL", "LJJJ.T.ZZL"]; + for (i, r) in rows.iter().enumerate() { + for (x, ch) in r.chars().enumerate() { + g.board[H - 8 + i][x] = match ch { + 'I' => 1, + 'O' => 2, + 'T' => 3, + 'S' => 4, + 'Z' => 5, + 'J' => 6, + 'L' => 7, + _ => 0, + }; + } + } + g.score = 4350; + g.lines = 23; + g.cur = Some(Piece { kind: 2, rot: 1, x: 4, y: 6 }); + save("playing", &full(&g, 12400)); + let mut g2 = g.clone(); + g2.state = State::Over; + save("over", &full(&g2, 12400)); + } +} diff --git a/apps/tetris/store.md b/apps/tetris/store.md new file mode 100644 index 0000000..a29b5da --- /dev/null +++ b/apps/tetris/store.md @@ -0,0 +1,13 @@ +Falling blocks on your wrist. Pieces drop into a 10 by 20 well: fill a row and it clears. Clear ten rows and the +pieces fall faster. A faint outline shows where the piece will land. Your best score is kept on the watch. + +- **Turn the crown** to move the piece left and right. +- **Tap** the screen to turn it. +- **Hold** your finger on the screen to drop it faster. + +Press the crown or swipe right to leave. + +## Requirements + +The [patched firmware](/firmware) and the [App Loader](/firmware). Open it from the **Apps** row at the end of the +watch's app list (list style, not the waterfall). diff --git a/apps/tetris/store.toml b/apps/tetris/store.toml new file mode 100644 index 0000000..e9ceacd --- /dev/null +++ b/apps/tetris/store.toml @@ -0,0 +1,6 @@ +# The app's listing in the FMC store (README.md, "store.toml"). The page's body is store.md. +name = "Tetris" +summary = "Falling blocks. Crown moves, tap turns, hold drops" +version = "0.1.0" +author = "arunk140" +screenshots = ["shots/ready.png", "shots/playing.png", "shots/over.png"]