Public Access
Games: Pong, Snake and Tetris as seeded state machines, and a tune
The rules of the three Games (issue #101), with no screen and no keyboard in them: time and keys go in, the new state and what happened come out, and a seed decides the dice. With a player for a tune a note at a time, and Korobeiniki's notes. Host-tested. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_0162FokPdvY2KsS4NBfwyWPk
This commit is contained in:
Claude Opus 5.5
@@ -0,0 +1,698 @@
|
||||
#include <unity.h>
|
||||
|
||||
#include <cmath>
|
||||
#include <set>
|
||||
|
||||
#include "pong.h"
|
||||
#include "snake.h"
|
||||
#include "tetris.h"
|
||||
#include "tune.h"
|
||||
|
||||
using namespace roro::games;
|
||||
|
||||
void setUp() {}
|
||||
void tearDown() {}
|
||||
|
||||
// ---- Pong ----
|
||||
|
||||
namespace {
|
||||
// Plays until the phase or an event says so; the player follows the ball if `follow`.
|
||||
uint8_t playPong(Pong& p, bool follow, uint8_t until, int maxSteps = 200000) {
|
||||
for (int i = 0; i < maxSteps; i++) {
|
||||
int move = !follow ? 0 : p.ballY() < p.playerY() - 2 ? -1 : p.ballY() > p.playerY() + 2 ? 1 : 0;
|
||||
uint8_t e = p.step(0.01f, move);
|
||||
if (e & until) return e;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
void test_pong_starts_with_a_serve_from_the_middle() {
|
||||
Pong p(1);
|
||||
TEST_ASSERT_TRUE(p.phase() == Pong::Phase::Serve);
|
||||
TEST_ASSERT_FLOAT_WITHIN(0.01, Pong::kWidth / 2, p.ballX());
|
||||
p.step(Pong::kServePause / 2, 0);
|
||||
TEST_ASSERT_FLOAT_WITHIN(0.01, Pong::kWidth / 2, p.ballX()); // it waits
|
||||
for (int i = 0; i < 100; i++) p.step(0.01f, 0);
|
||||
TEST_ASSERT_TRUE(p.phase() == Pong::Phase::Play);
|
||||
p.step(0.1f, 0);
|
||||
TEST_ASSERT_TRUE(std::fabs(p.ballX() - Pong::kWidth / 2) > 5);
|
||||
}
|
||||
|
||||
void test_pong_the_same_seed_is_the_same_game() {
|
||||
Pong a(42), b(42), c(43);
|
||||
for (int i = 0; i < 500; i++) {
|
||||
a.step(0.01f, i % 3 - 1);
|
||||
b.step(0.01f, i % 3 - 1);
|
||||
c.step(0.01f, i % 3 - 1);
|
||||
}
|
||||
TEST_ASSERT_EQUAL_FLOAT(a.ballX(), b.ballX());
|
||||
TEST_ASSERT_EQUAL_FLOAT(a.ballY(), b.ballY());
|
||||
TEST_ASSERT_TRUE(a.ballY() != c.ballY() || a.ballX() != c.ballX());
|
||||
}
|
||||
|
||||
void test_pong_the_ball_stays_between_the_walls() {
|
||||
Pong p(7);
|
||||
bool wall = false;
|
||||
for (int i = 0; i < 20000; i++) {
|
||||
uint8_t e = p.step(0.01f, p.ballY() < p.playerY() ? -1 : 1);
|
||||
wall |= (e & Pong::Wall) != 0;
|
||||
TEST_ASSERT_TRUE(p.ballY() >= 0 && p.ballY() <= Pong::kHeight);
|
||||
if (p.phase() == Pong::Phase::Over) p.start();
|
||||
}
|
||||
TEST_ASSERT_TRUE(wall);
|
||||
}
|
||||
|
||||
void test_pong_a_paddle_stays_on_the_field() {
|
||||
Pong p(3);
|
||||
for (int i = 0; i < 300; i++) p.step(0.01f, -1);
|
||||
TEST_ASSERT_FLOAT_WITHIN(0.01, Pong::kPaddleH / 2, p.playerY());
|
||||
for (int i = 0; i < 300; i++) p.step(0.01f, 1);
|
||||
TEST_ASSERT_FLOAT_WITHIN(0.01, Pong::kHeight - Pong::kPaddleH / 2, p.playerY());
|
||||
}
|
||||
|
||||
void test_pong_a_return_counts_and_speeds_the_ball_up() {
|
||||
Pong p(5);
|
||||
float served = Pong::kServeSpeed;
|
||||
// Follow the ball until the player returns it once.
|
||||
int before = p.rally();
|
||||
for (int i = 0; i < 100000 && p.rally() == before; i++) {
|
||||
int move = p.ballY() < p.playerY() - 2 ? -1 : p.ballY() > p.playerY() + 2 ? 1 : 0;
|
||||
p.step(0.01f, move);
|
||||
}
|
||||
TEST_ASSERT_EQUAL(1, p.rally());
|
||||
TEST_ASSERT_EQUAL(1, p.longestRally());
|
||||
TEST_ASSERT_TRUE(p.speed() > served);
|
||||
TEST_ASSERT_TRUE(p.speed() <= Pong::kMaxSpeed);
|
||||
}
|
||||
|
||||
void test_pong_a_miss_is_a_point_for_the_other_side() {
|
||||
Pong p(9);
|
||||
// The player never moves from the top corner: sooner or later the ball gets past.
|
||||
for (int i = 0; i < 300; i++) p.step(0.01f, -1);
|
||||
while (p.deviceScore() == 0 && p.phase() != Pong::Phase::Over) p.step(0.01f, -1);
|
||||
TEST_ASSERT_EQUAL(1, p.deviceScore());
|
||||
TEST_ASSERT_TRUE(p.phase() == Pong::Phase::Serve); // served again, from the middle
|
||||
TEST_ASSERT_FLOAT_WITHIN(0.01, Pong::kWidth / 2, p.ballX());
|
||||
TEST_ASSERT_EQUAL(0, p.rally());
|
||||
}
|
||||
|
||||
void test_pong_ends_at_seven() {
|
||||
Pong p(11);
|
||||
uint8_t e = playPong(p, false, Pong::Over); // a player who does nothing loses
|
||||
TEST_ASSERT_TRUE(e & Pong::Over);
|
||||
TEST_ASSERT_TRUE(p.phase() == Pong::Phase::Over);
|
||||
TEST_ASSERT_EQUAL(Pong::kWinScore, std::max(p.playerScore(), p.deviceScore()));
|
||||
TEST_ASSERT_EQUAL(0, p.step(1.0f, 1)); // nothing moves once it is over
|
||||
p.start();
|
||||
TEST_ASSERT_EQUAL(0, p.deviceScore());
|
||||
TEST_ASSERT_TRUE(p.phase() == Pong::Phase::Serve);
|
||||
}
|
||||
|
||||
void test_pong_the_device_can_be_beaten() {
|
||||
// A player who always meets the ball: the device, slower than a steep fast ball, must lose
|
||||
// points over a few games.
|
||||
int playerPoints = 0;
|
||||
for (uint32_t seed = 1; seed <= 5; seed++) {
|
||||
Pong p(seed);
|
||||
playPong(p, true, Pong::Over, 2000000);
|
||||
playerPoints += p.playerScore();
|
||||
}
|
||||
TEST_ASSERT_TRUE(playerPoints > 0);
|
||||
}
|
||||
|
||||
void test_pong_the_device_paddle_has_a_top_speed() {
|
||||
Pong p(13);
|
||||
float before = p.deviceY();
|
||||
for (int i = 0; i < 1000; i++) {
|
||||
p.step(0.01f, 0);
|
||||
TEST_ASSERT_TRUE(std::fabs(p.deviceY() - before) <= Pong::kDeviceSpeed * 0.01f + 0.01f);
|
||||
before = p.deviceY();
|
||||
if (p.phase() == Pong::Phase::Over) p.start();
|
||||
}
|
||||
}
|
||||
|
||||
// ---- Snake ----
|
||||
|
||||
namespace {
|
||||
void moves(Snake& s, int n) {
|
||||
for (int i = 0; i < n && s.alive(); i++) s.step(s.intervalMs());
|
||||
}
|
||||
} // namespace
|
||||
|
||||
void test_snake_starts_in_the_middle_three_long() {
|
||||
Snake s(1);
|
||||
TEST_ASSERT_TRUE(s.alive());
|
||||
TEST_ASSERT_EQUAL(3, s.body().size());
|
||||
TEST_ASSERT_EQUAL(Snake::kCols / 2, s.body().front().col);
|
||||
TEST_ASSERT_EQUAL(Snake::kRows / 2, s.body().front().row);
|
||||
TEST_ASSERT_TRUE(s.heading() == Snake::Dir::Right);
|
||||
for (auto& c : s.body()) TEST_ASSERT_FALSE(c == s.food());
|
||||
}
|
||||
|
||||
void test_snake_moves_at_its_pace() {
|
||||
Snake s(1);
|
||||
s.putFood({0, 0});
|
||||
TEST_ASSERT_EQUAL(0, s.step(Snake::kSlowestMs - 1));
|
||||
TEST_ASSERT_EQUAL(Snake::Moved, s.step(1));
|
||||
TEST_ASSERT_EQUAL(Snake::kCols / 2 + 1, s.body().front().col);
|
||||
TEST_ASSERT_EQUAL(3, s.body().size());
|
||||
}
|
||||
|
||||
void test_snake_turns_but_not_back_on_itself() {
|
||||
Snake s(1);
|
||||
s.putFood({0, 0});
|
||||
s.turn(Snake::Dir::Left); // straight back: not a turn
|
||||
moves(s, 1);
|
||||
TEST_ASSERT_TRUE(s.heading() == Snake::Dir::Right);
|
||||
s.turn(Snake::Dir::Up);
|
||||
moves(s, 1);
|
||||
TEST_ASSERT_TRUE(s.heading() == Snake::Dir::Up);
|
||||
TEST_ASSERT_EQUAL(Snake::kRows / 2 - 1, s.body().front().row);
|
||||
}
|
||||
|
||||
void test_snake_remembers_a_quick_corner() {
|
||||
Snake s(1);
|
||||
s.putFood({0, 0});
|
||||
s.turn(Snake::Dir::Up); // both before the next move
|
||||
s.turn(Snake::Dir::Left); // would be "back" for a snake heading right, but not after the first
|
||||
s.turn(Snake::Dir::Down); // a third is not remembered
|
||||
moves(s, 1);
|
||||
TEST_ASSERT_TRUE(s.heading() == Snake::Dir::Up);
|
||||
moves(s, 1);
|
||||
TEST_ASSERT_TRUE(s.heading() == Snake::Dir::Left);
|
||||
moves(s, 1);
|
||||
TEST_ASSERT_TRUE(s.heading() == Snake::Dir::Left);
|
||||
TEST_ASSERT_TRUE(s.alive());
|
||||
}
|
||||
|
||||
void test_snake_eats_grows_and_gets_new_food() {
|
||||
Snake s(1);
|
||||
Snake::Cell head = s.body().front();
|
||||
s.putFood({static_cast<int8_t>(head.col + 1), head.row});
|
||||
uint8_t e = s.step(s.intervalMs());
|
||||
TEST_ASSERT_TRUE(e & Snake::Ate);
|
||||
TEST_ASSERT_EQUAL(1, s.score());
|
||||
TEST_ASSERT_EQUAL(4, s.body().size());
|
||||
for (auto& c : s.body()) TEST_ASSERT_FALSE(c == s.food());
|
||||
TEST_ASSERT_TRUE(s.food().col >= 0 && s.food().col < Snake::kCols && s.food().row >= 0 && s.food().row < Snake::kRows);
|
||||
}
|
||||
|
||||
void test_snake_dies_at_a_wall() {
|
||||
Snake s(1);
|
||||
s.putFood({0, 0});
|
||||
uint8_t last = 0;
|
||||
for (int i = 0; i < Snake::kCols && s.alive(); i++) last = s.step(s.intervalMs());
|
||||
TEST_ASSERT_FALSE(s.alive());
|
||||
TEST_ASSERT_TRUE(last & Snake::Died);
|
||||
TEST_ASSERT_EQUAL(Snake::kCols - 1, s.body().front().col); // it stopped at the edge
|
||||
TEST_ASSERT_EQUAL(3, s.body().size()); // whole
|
||||
TEST_ASSERT_EQUAL(0, s.step(1000));
|
||||
}
|
||||
|
||||
void test_snake_dies_on_itself() {
|
||||
Snake s(1);
|
||||
// Fed four times in a row, it is long enough to bite itself in a tight turn.
|
||||
for (int i = 0; i < 4; i++) {
|
||||
Snake::Cell head = s.body().front();
|
||||
s.putFood({static_cast<int8_t>(head.col + 1), head.row});
|
||||
s.step(s.intervalMs());
|
||||
}
|
||||
s.putFood({0, 0});
|
||||
TEST_ASSERT_EQUAL(7, s.body().size());
|
||||
s.turn(Snake::Dir::Down);
|
||||
moves(s, 1);
|
||||
s.turn(Snake::Dir::Left);
|
||||
moves(s, 1);
|
||||
s.turn(Snake::Dir::Up);
|
||||
moves(s, 1);
|
||||
TEST_ASSERT_FALSE(s.alive());
|
||||
}
|
||||
|
||||
void test_snake_may_follow_its_own_tail() {
|
||||
Snake s(1);
|
||||
Snake::Cell head = s.body().front();
|
||||
s.putFood({static_cast<int8_t>(head.col + 1), head.row});
|
||||
s.step(s.intervalMs()); // four long: a square of 2 x 2 is its own tail chased
|
||||
s.putFood({0, 0});
|
||||
for (auto d : {Snake::Dir::Down, Snake::Dir::Left, Snake::Dir::Up, Snake::Dir::Right, Snake::Dir::Down}) {
|
||||
s.turn(d);
|
||||
moves(s, 1);
|
||||
}
|
||||
TEST_ASSERT_TRUE(s.alive());
|
||||
}
|
||||
|
||||
void test_snake_gets_faster_as_it_eats() {
|
||||
Snake s(1);
|
||||
uint32_t start = s.intervalMs();
|
||||
TEST_ASSERT_EQUAL(Snake::kSlowestMs, start);
|
||||
for (int i = 0; i < Snake::kFoodsAStep; i++) {
|
||||
Snake::Cell head = s.body().front();
|
||||
s.putFood({static_cast<int8_t>(head.col + 1), head.row});
|
||||
s.step(s.intervalMs());
|
||||
}
|
||||
TEST_ASSERT_EQUAL(start - Snake::kFasterMs, s.intervalMs());
|
||||
}
|
||||
|
||||
void test_snake_the_same_seed_puts_the_food_in_the_same_places() {
|
||||
Snake a(77), b(77), c(78);
|
||||
TEST_ASSERT_TRUE(a.food() == b.food());
|
||||
bool differs = !(a.food() == c.food());
|
||||
for (int i = 0; i < 3; i++) {
|
||||
for (Snake* s : {&a, &b, &c}) {
|
||||
Snake::Cell head = s->body().front();
|
||||
s->putFood({static_cast<int8_t>(head.col + 1), head.row});
|
||||
s->step(s->intervalMs());
|
||||
}
|
||||
TEST_ASSERT_TRUE(a.food() == b.food());
|
||||
differs |= !(a.food() == c.food());
|
||||
}
|
||||
TEST_ASSERT_TRUE(differs);
|
||||
}
|
||||
|
||||
// ---- Tetris ----
|
||||
|
||||
namespace {
|
||||
const TetrisInput kNothing;
|
||||
TetrisInput press(bool TetrisInput::*key) {
|
||||
TetrisInput in;
|
||||
in.*key = true;
|
||||
return in;
|
||||
}
|
||||
int filled(const Tetris& t) {
|
||||
int n = 0;
|
||||
for (int r = 0; r < Tetris::kRows; r++)
|
||||
for (int c = 0; c < Tetris::kCols; c++) n += t.cell(c, r) != 0;
|
||||
return n;
|
||||
}
|
||||
// A row filled but for one column.
|
||||
void fillRow(Tetris& t, int row, int gap) {
|
||||
for (int c = 0; c < Tetris::kCols; c++)
|
||||
if (c != gap) t.put(c, row, 7);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
void test_tetris_deals_each_piece_once_in_seven() {
|
||||
Tetris t(5);
|
||||
for (int bag = 0; bag < 4; bag++) {
|
||||
std::set<int> seen;
|
||||
for (int i = 0; i < 7; i++) {
|
||||
seen.insert(t.piece().kind);
|
||||
t.step(0, press(&TetrisInput::hardDrop));
|
||||
if (t.over()) t.start(), i = -1, seen.clear(); // start over on a full well
|
||||
}
|
||||
TEST_ASSERT_EQUAL(7, seen.size());
|
||||
t.start();
|
||||
}
|
||||
}
|
||||
|
||||
void test_tetris_shows_the_piece_that_comes_next() {
|
||||
Tetris t(9);
|
||||
uint8_t next = t.next();
|
||||
t.step(0, press(&TetrisInput::hardDrop));
|
||||
TEST_ASSERT_EQUAL(next, t.piece().kind);
|
||||
}
|
||||
|
||||
void test_tetris_a_piece_falls_at_the_levels_pace() {
|
||||
Tetris t(1);
|
||||
t.give(3); // a T
|
||||
int row = t.piece().row;
|
||||
TEST_ASSERT_EQUAL(0, t.step(Tetris::kSlowestMs - 1, kNothing));
|
||||
TEST_ASSERT_EQUAL(row, t.piece().row);
|
||||
TEST_ASSERT_EQUAL(Tetris::Moved, t.step(1, kNothing));
|
||||
TEST_ASSERT_EQUAL(row + 1, t.piece().row);
|
||||
}
|
||||
|
||||
void test_tetris_a_soft_drop_is_faster_and_scores() {
|
||||
Tetris t(1);
|
||||
t.give(3);
|
||||
int row = t.piece().row;
|
||||
t.step(Tetris::kSoftMs * 3, press(&TetrisInput::soft));
|
||||
TEST_ASSERT_EQUAL(row + 3, t.piece().row);
|
||||
TEST_ASSERT_EQUAL(3, t.score());
|
||||
}
|
||||
|
||||
void test_tetris_a_held_soft_drop_stops_with_its_piece() {
|
||||
Tetris t(1);
|
||||
t.give(2);
|
||||
TetrisInput soft = press(&TetrisInput::soft);
|
||||
uint8_t all = 0;
|
||||
for (int i = 0; i < 40 && !(all & Tetris::Locked); i++) all |= t.step(Tetris::kSoftMs, soft);
|
||||
TEST_ASSERT_TRUE(all & Tetris::Locked);
|
||||
// The key is still down: the next piece falls at the level's pace, not the fast one.
|
||||
int row = t.piece().row, score = t.score();
|
||||
t.step(Tetris::kSoftMs * 4, soft);
|
||||
TEST_ASSERT_EQUAL(row, t.piece().row);
|
||||
TEST_ASSERT_EQUAL(score, t.score());
|
||||
t.step(0, kNothing); // let go, and pressed again: it works
|
||||
t.step(Tetris::kSoftMs * 2, soft);
|
||||
TEST_ASSERT_TRUE(t.piece().row > row);
|
||||
}
|
||||
|
||||
void test_tetris_moves_stop_at_the_walls() {
|
||||
Tetris t(1);
|
||||
t.give(2); // an O: two wide
|
||||
for (int i = 0; i < 20; i++) {
|
||||
t.step(0, press(&TetrisInput::left));
|
||||
t.step(0, kNothing); // released: the next press is a press
|
||||
}
|
||||
int leftmost = Tetris::kCols;
|
||||
for (auto& c : Tetris::cells(t.piece())) leftmost = std::min<int>(leftmost, c.col);
|
||||
TEST_ASSERT_EQUAL(0, leftmost);
|
||||
for (int i = 0; i < 20; i++) {
|
||||
t.step(0, press(&TetrisInput::right));
|
||||
t.step(0, kNothing);
|
||||
}
|
||||
int rightmost = 0;
|
||||
for (auto& c : Tetris::cells(t.piece())) rightmost = std::max<int>(rightmost, c.col);
|
||||
TEST_ASSERT_EQUAL(Tetris::kCols - 1, rightmost);
|
||||
}
|
||||
|
||||
void test_tetris_a_held_key_repeats() {
|
||||
Tetris t(1);
|
||||
t.give(2);
|
||||
int col = t.piece().col;
|
||||
TetrisInput left = press(&TetrisInput::left);
|
||||
t.step(0, left); // the press: one step at once
|
||||
TEST_ASSERT_EQUAL(col - 1, t.piece().col);
|
||||
t.step(Tetris::kRepeatAfterMs - 1, left);
|
||||
TEST_ASSERT_EQUAL(col - 1, t.piece().col); // not yet
|
||||
t.step(1, left);
|
||||
TEST_ASSERT_EQUAL(col - 2, t.piece().col);
|
||||
t.step(Tetris::kRepeatEveryMs, left);
|
||||
TEST_ASSERT_EQUAL(col - 3, t.piece().col);
|
||||
TetrisInput both = left;
|
||||
both.right = true; // both held: neither
|
||||
t.step(Tetris::kRepeatEveryMs * 3, both);
|
||||
TEST_ASSERT_EQUAL(col - 3, t.piece().col);
|
||||
}
|
||||
|
||||
void test_tetris_turns_and_turns_back() {
|
||||
Tetris t(1);
|
||||
t.give(3);
|
||||
auto before = Tetris::cells(t.piece());
|
||||
TEST_ASSERT_EQUAL(Tetris::Turned, t.step(0, press(&TetrisInput::rotate)));
|
||||
TEST_ASSERT_EQUAL(1, t.piece().turn);
|
||||
t.step(0, press(&TetrisInput::rotateBack));
|
||||
TEST_ASSERT_EQUAL(0, t.piece().turn);
|
||||
auto after = Tetris::cells(t.piece());
|
||||
for (int i = 0; i < 4; i++) {
|
||||
TEST_ASSERT_EQUAL(before[i].col, after[i].col);
|
||||
TEST_ASSERT_EQUAL(before[i].row, after[i].row);
|
||||
}
|
||||
for (int i = 0; i < 4; i++) t.step(0, press(&TetrisInput::rotate));
|
||||
TEST_ASSERT_EQUAL(0, t.piece().turn); // four quarter turns: as it was
|
||||
}
|
||||
|
||||
void test_tetris_a_turn_against_a_wall_shifts_the_piece() {
|
||||
Tetris t(1);
|
||||
t.give(1); // the long one
|
||||
t.step(0, press(&TetrisInput::rotate)); // upright
|
||||
for (int i = 0; i < 10; i++) {
|
||||
t.step(0, press(&TetrisInput::right));
|
||||
t.step(0, kNothing);
|
||||
}
|
||||
for (auto& c : Tetris::cells(t.piece())) TEST_ASSERT_EQUAL(Tetris::kCols - 1, c.col); // against the right wall
|
||||
TEST_ASSERT_EQUAL(Tetris::Turned, t.step(0, press(&TetrisInput::rotate))); // flat again: it needs four columns
|
||||
for (auto& c : Tetris::cells(t.piece())) TEST_ASSERT_TRUE(c.col >= Tetris::kCols - 4 && c.col < Tetris::kCols);
|
||||
}
|
||||
|
||||
void test_tetris_a_turn_with_no_room_does_not_happen() {
|
||||
Tetris t(1);
|
||||
t.give(1);
|
||||
t.step(0, press(&TetrisInput::rotate));
|
||||
// Walled in on both sides, a column wide.
|
||||
int col = Tetris::cells(t.piece())[0].col;
|
||||
for (int r = 0; r < Tetris::kRows; r++)
|
||||
for (int c = 0; c < Tetris::kCols; c++)
|
||||
if (c != col) t.put(c, r, 7);
|
||||
TEST_ASSERT_EQUAL(0, t.step(0, press(&TetrisInput::rotate)));
|
||||
TEST_ASSERT_EQUAL(1, t.piece().turn);
|
||||
}
|
||||
|
||||
void test_tetris_a_hard_drop_lands_locks_and_scores() {
|
||||
Tetris t(1);
|
||||
t.give(2); // an O
|
||||
int from = t.piece().row;
|
||||
uint8_t e = t.step(0, press(&TetrisInput::hardDrop));
|
||||
TEST_ASSERT_TRUE(e & Tetris::Locked);
|
||||
TEST_ASSERT_EQUAL(4, filled(t));
|
||||
TEST_ASSERT_NOT_EQUAL(0, t.cell(4, Tetris::kRows - 1));
|
||||
TEST_ASSERT_NOT_EQUAL(0, t.cell(5, Tetris::kRows - 2));
|
||||
TEST_ASSERT_EQUAL(2 * (Tetris::kRows - 2 - from), t.score()); // two a row fallen
|
||||
TEST_ASSERT_EQUAL(0, t.lastCleared());
|
||||
}
|
||||
|
||||
void test_tetris_a_piece_locks_when_it_can_fall_no_more() {
|
||||
Tetris t(1);
|
||||
t.give(2);
|
||||
uint8_t all = 0;
|
||||
for (int i = 0; i < Tetris::kRows + 2 && !(all & Tetris::Locked); i++) all |= t.step(Tetris::kSlowestMs, kNothing);
|
||||
TEST_ASSERT_TRUE(all & Tetris::Locked);
|
||||
TEST_ASSERT_EQUAL(4, filled(t));
|
||||
}
|
||||
|
||||
void test_tetris_a_full_row_goes_and_the_rest_comes_down() {
|
||||
Tetris t(1);
|
||||
fillRow(t, Tetris::kRows - 1, 4); // the gap where the O will not fit: use the long one upright
|
||||
t.put(0, Tetris::kRows - 2, 5); // something above, to see it come down
|
||||
t.give(1);
|
||||
t.step(0, press(&TetrisInput::rotate)); // upright, in column 5
|
||||
t.step(0, press(&TetrisInput::left)); // column 4
|
||||
uint8_t e = t.step(0, press(&TetrisInput::hardDrop));
|
||||
TEST_ASSERT_TRUE(e & Tetris::Lines);
|
||||
TEST_ASSERT_EQUAL(1, t.lastCleared());
|
||||
TEST_ASSERT_EQUAL(1, t.lines());
|
||||
TEST_ASSERT_EQUAL(5, t.cell(0, Tetris::kRows - 1)); // what was above
|
||||
TEST_ASSERT_EQUAL(1, t.cell(4, Tetris::kRows - 1)); // and the rest of the long piece
|
||||
TEST_ASSERT_EQUAL(0, t.cell(1, Tetris::kRows - 1));
|
||||
TEST_ASSERT_EQUAL(1 + 3, filled(t));
|
||||
}
|
||||
|
||||
void test_tetris_four_rows_at_once_score_most() {
|
||||
Tetris t(1);
|
||||
for (int r = Tetris::kRows - 4; r < Tetris::kRows; r++) fillRow(t, r, 9);
|
||||
t.give(1);
|
||||
t.step(0, press(&TetrisInput::rotate));
|
||||
for (int i = 0; i < 10; i++) {
|
||||
t.step(0, press(&TetrisInput::right));
|
||||
t.step(0, kNothing);
|
||||
}
|
||||
int before = t.score();
|
||||
uint8_t e = t.step(0, press(&TetrisInput::hardDrop));
|
||||
TEST_ASSERT_TRUE(e & Tetris::Lines);
|
||||
TEST_ASSERT_EQUAL(4, t.lastCleared());
|
||||
TEST_ASSERT_EQUAL(0, filled(t));
|
||||
int dropped = (t.score() - before) - 800;
|
||||
TEST_ASSERT_TRUE(dropped > 0 && dropped <= 2 * Tetris::kRows); // 800 for the four, and the drop
|
||||
}
|
||||
|
||||
void test_tetris_ten_lines_are_a_level_and_a_faster_fall() {
|
||||
Tetris t(1);
|
||||
TEST_ASSERT_EQUAL(0, t.level());
|
||||
TEST_ASSERT_EQUAL(Tetris::kSlowestMs, t.fallMs());
|
||||
uint8_t all = 0;
|
||||
for (int i = 0; i < 3; i++) { // 4 + 4 + 4
|
||||
for (int r = Tetris::kRows - 4; r < Tetris::kRows; r++) fillRow(t, r, 9);
|
||||
t.give(1);
|
||||
t.step(0, press(&TetrisInput::rotate));
|
||||
for (int k = 0; k < 10; k++) {
|
||||
t.step(0, press(&TetrisInput::right));
|
||||
t.step(0, kNothing);
|
||||
}
|
||||
all |= t.step(0, press(&TetrisInput::hardDrop));
|
||||
}
|
||||
TEST_ASSERT_EQUAL(12, t.lines());
|
||||
TEST_ASSERT_EQUAL(1, t.level());
|
||||
TEST_ASSERT_TRUE(all & Tetris::LevelUp);
|
||||
TEST_ASSERT_EQUAL(Tetris::kSlowestMs * 85 / 100, t.fallMs());
|
||||
}
|
||||
|
||||
void test_tetris_the_fall_never_gets_faster_than_its_limit() {
|
||||
Tetris t(1);
|
||||
for (int i = 0; i < 80; i++) {
|
||||
for (int r = Tetris::kRows - 4; r < Tetris::kRows; r++) fillRow(t, r, 9);
|
||||
t.give(1);
|
||||
t.step(0, press(&TetrisInput::rotate));
|
||||
for (int k = 0; k < 10; k++) {
|
||||
t.step(0, press(&TetrisInput::right));
|
||||
t.step(0, kNothing);
|
||||
}
|
||||
t.step(0, press(&TetrisInput::hardDrop));
|
||||
}
|
||||
TEST_ASSERT_TRUE(t.level() >= 30);
|
||||
TEST_ASSERT_EQUAL(Tetris::kFastestMs, t.fallMs());
|
||||
}
|
||||
|
||||
void test_tetris_is_over_when_a_piece_has_no_room() {
|
||||
Tetris t(3);
|
||||
uint8_t last = 0;
|
||||
for (int i = 0; i < 40 && !t.over(); i++) last = t.step(0, press(&TetrisInput::hardDrop)); // all in the middle
|
||||
TEST_ASSERT_TRUE(t.over());
|
||||
TEST_ASSERT_TRUE(last & Tetris::Over);
|
||||
TEST_ASSERT_EQUAL(0, t.step(1000, press(&TetrisInput::hardDrop)));
|
||||
t.start();
|
||||
TEST_ASSERT_FALSE(t.over());
|
||||
TEST_ASSERT_EQUAL(0, filled(t));
|
||||
TEST_ASSERT_EQUAL(0, t.score());
|
||||
}
|
||||
|
||||
void test_tetris_the_same_seed_deals_the_same_pieces() {
|
||||
Tetris a(21), b(21), c(22);
|
||||
bool differs = false;
|
||||
for (int i = 0; i < 14; i++) {
|
||||
TEST_ASSERT_EQUAL(a.piece().kind, b.piece().kind);
|
||||
differs |= a.piece().kind != c.piece().kind;
|
||||
for (Tetris* t : {&a, &b, &c}) {
|
||||
t->step(0, press(&TetrisInput::hardDrop));
|
||||
if (t->over()) t->start();
|
||||
}
|
||||
}
|
||||
TEST_ASSERT_TRUE(differs);
|
||||
}
|
||||
|
||||
void test_tetris_every_piece_in_every_turn_has_four_cells_in_its_box() {
|
||||
for (uint8_t kind = 1; kind <= 7; kind++)
|
||||
for (uint8_t turn = 0; turn < 4; turn++) {
|
||||
Tetris::Piece p{kind, turn, 0, 0};
|
||||
std::set<int> where;
|
||||
for (auto& c : Tetris::cells(p)) {
|
||||
TEST_ASSERT_TRUE(c.col >= 0 && c.col < 4 && c.row >= 0 && c.row < 4);
|
||||
where.insert(c.row * 4 + c.col);
|
||||
}
|
||||
TEST_ASSERT_EQUAL(4, where.size());
|
||||
}
|
||||
}
|
||||
|
||||
// ---- The tune ----
|
||||
|
||||
void test_a_tune_gives_its_notes_in_time() {
|
||||
static const Note kThree[] = {{440, 2}, {0, 1}, {880, 1}};
|
||||
TunePlayer p([](size_t i) { return kThree[i]; }, 3, 100);
|
||||
Note n{};
|
||||
uint32_t ms = 0;
|
||||
TEST_ASSERT_TRUE(p.step(0, n, ms)); // the first note at once
|
||||
TEST_ASSERT_EQUAL(440, n.hz);
|
||||
TEST_ASSERT_EQUAL(200, ms);
|
||||
TEST_ASSERT_FALSE(p.step(199, n, ms));
|
||||
TEST_ASSERT_TRUE(p.step(1, n, ms)); // a rest is a note too: the caller plays nothing
|
||||
TEST_ASSERT_EQUAL(0, n.hz);
|
||||
TEST_ASSERT_EQUAL(100, ms);
|
||||
TEST_ASSERT_TRUE(p.step(100, n, ms));
|
||||
TEST_ASSERT_EQUAL(880, n.hz);
|
||||
TEST_ASSERT_TRUE(p.step(100, n, ms)); // and round again
|
||||
TEST_ASSERT_EQUAL(440, n.hz);
|
||||
TEST_ASSERT_EQUAL(0, p.position());
|
||||
}
|
||||
|
||||
void test_a_tune_keeps_time_over_uneven_steps() {
|
||||
static const Note kTwo[] = {{440, 1}, {880, 1}};
|
||||
TunePlayer p([](size_t i) { return kTwo[i]; }, 2, 100);
|
||||
Note n{};
|
||||
uint32_t ms = 0;
|
||||
p.step(0, n, ms);
|
||||
int notes = 1;
|
||||
for (int i = 0; i < 300; i++) notes += p.step(33, n, ms); // 9.9 seconds in steps of 33 ms
|
||||
TEST_ASSERT_EQUAL(100, notes); // one every 100 ms: the 33s do not add up to a drift
|
||||
}
|
||||
|
||||
void test_a_tune_skips_what_a_long_gap_missed() {
|
||||
static const Note kFour[] = {{100, 1}, {200, 1}, {300, 1}, {400, 1}};
|
||||
TunePlayer p([](size_t i) { return kFour[i]; }, 4, 100);
|
||||
Note n{};
|
||||
uint32_t ms = 0;
|
||||
p.step(0, n, ms);
|
||||
TEST_ASSERT_TRUE(p.step(250, n, ms)); // 200 and half of 300 went by
|
||||
TEST_ASSERT_EQUAL(300, n.hz);
|
||||
TEST_ASSERT_FALSE(p.step(49, n, ms));
|
||||
TEST_ASSERT_TRUE(p.step(1, n, ms));
|
||||
TEST_ASSERT_EQUAL(400, n.hz);
|
||||
p.restart();
|
||||
TEST_ASSERT_TRUE(p.step(0, n, ms));
|
||||
TEST_ASSERT_EQUAL(100, n.hz);
|
||||
}
|
||||
|
||||
void test_korobeiniki_is_whole_bars() {
|
||||
// Each part is eight bars of eight eighths, and it begins on its famous E.
|
||||
int first = 0, second = 0;
|
||||
for (size_t i = 0; i < korobeiniki::kFirstCount; i++) first += korobeiniki::kFirst[i].eighths;
|
||||
for (size_t i = 0; i < korobeiniki::kSecondCount; i++) second += korobeiniki::kSecond[i].eighths;
|
||||
TEST_ASSERT_EQUAL(64, first);
|
||||
TEST_ASSERT_EQUAL(64, second);
|
||||
TEST_ASSERT_EQUAL(659, korobeiniki::at(0).hz);
|
||||
TEST_ASSERT_EQUAL(659, korobeiniki::at(korobeiniki::kFirstCount).hz); // the tune again
|
||||
TEST_ASSERT_EQUAL(659, korobeiniki::at(2 * korobeiniki::kFirstCount).hz); // then the slow part
|
||||
TEST_ASSERT_EQUAL(4, korobeiniki::at(2 * korobeiniki::kFirstCount).eighths);
|
||||
TEST_ASSERT_EQUAL(0, korobeiniki::at(korobeiniki::kCount - 1).hz); // and a breath before it starts over
|
||||
}
|
||||
|
||||
void test_the_tune_hurries_with_the_level() {
|
||||
TEST_ASSERT_EQUAL(200, korobeiniki::eighthMsAt(0));
|
||||
TEST_ASSERT_EQUAL(192, korobeiniki::eighthMsAt(1));
|
||||
TEST_ASSERT_EQUAL(160, korobeiniki::eighthMsAt(5));
|
||||
TEST_ASSERT_EQUAL(korobeiniki::kFastestEighthMs, korobeiniki::eighthMsAt(12));
|
||||
TEST_ASSERT_EQUAL(korobeiniki::kFastestEighthMs, korobeiniki::eighthMsAt(99));
|
||||
for (int level = 0; level < 20; level++) TEST_ASSERT_TRUE(korobeiniki::eighthMsAt(level + 1) <= korobeiniki::eighthMsAt(level));
|
||||
}
|
||||
|
||||
void test_a_new_pace_starts_at_the_next_note() {
|
||||
static const Note kTwo[] = {{440, 1}, {880, 1}};
|
||||
TunePlayer p([](size_t i) { return kTwo[i]; }, 2, 100);
|
||||
Note n{};
|
||||
uint32_t ms = 0;
|
||||
p.step(0, n, ms);
|
||||
p.setEighthMs(50);
|
||||
TEST_ASSERT_FALSE(p.step(99, n, ms)); // the note that had begun keeps its length
|
||||
TEST_ASSERT_TRUE(p.step(1, n, ms));
|
||||
TEST_ASSERT_EQUAL(50, ms);
|
||||
TEST_ASSERT_TRUE(p.step(50, n, ms));
|
||||
}
|
||||
|
||||
int main() {
|
||||
UNITY_BEGIN();
|
||||
RUN_TEST(test_pong_starts_with_a_serve_from_the_middle);
|
||||
RUN_TEST(test_pong_the_same_seed_is_the_same_game);
|
||||
RUN_TEST(test_pong_the_ball_stays_between_the_walls);
|
||||
RUN_TEST(test_pong_a_paddle_stays_on_the_field);
|
||||
RUN_TEST(test_pong_a_return_counts_and_speeds_the_ball_up);
|
||||
RUN_TEST(test_pong_a_miss_is_a_point_for_the_other_side);
|
||||
RUN_TEST(test_pong_ends_at_seven);
|
||||
RUN_TEST(test_pong_the_device_can_be_beaten);
|
||||
RUN_TEST(test_pong_the_device_paddle_has_a_top_speed);
|
||||
RUN_TEST(test_snake_starts_in_the_middle_three_long);
|
||||
RUN_TEST(test_snake_moves_at_its_pace);
|
||||
RUN_TEST(test_snake_turns_but_not_back_on_itself);
|
||||
RUN_TEST(test_snake_remembers_a_quick_corner);
|
||||
RUN_TEST(test_snake_eats_grows_and_gets_new_food);
|
||||
RUN_TEST(test_snake_dies_at_a_wall);
|
||||
RUN_TEST(test_snake_dies_on_itself);
|
||||
RUN_TEST(test_snake_may_follow_its_own_tail);
|
||||
RUN_TEST(test_snake_gets_faster_as_it_eats);
|
||||
RUN_TEST(test_snake_the_same_seed_puts_the_food_in_the_same_places);
|
||||
RUN_TEST(test_tetris_deals_each_piece_once_in_seven);
|
||||
RUN_TEST(test_tetris_shows_the_piece_that_comes_next);
|
||||
RUN_TEST(test_tetris_a_piece_falls_at_the_levels_pace);
|
||||
RUN_TEST(test_tetris_a_soft_drop_is_faster_and_scores);
|
||||
RUN_TEST(test_tetris_a_held_soft_drop_stops_with_its_piece);
|
||||
RUN_TEST(test_tetris_moves_stop_at_the_walls);
|
||||
RUN_TEST(test_tetris_a_held_key_repeats);
|
||||
RUN_TEST(test_tetris_turns_and_turns_back);
|
||||
RUN_TEST(test_tetris_a_turn_against_a_wall_shifts_the_piece);
|
||||
RUN_TEST(test_tetris_a_turn_with_no_room_does_not_happen);
|
||||
RUN_TEST(test_tetris_a_hard_drop_lands_locks_and_scores);
|
||||
RUN_TEST(test_tetris_a_piece_locks_when_it_can_fall_no_more);
|
||||
RUN_TEST(test_tetris_a_full_row_goes_and_the_rest_comes_down);
|
||||
RUN_TEST(test_tetris_four_rows_at_once_score_most);
|
||||
RUN_TEST(test_tetris_ten_lines_are_a_level_and_a_faster_fall);
|
||||
RUN_TEST(test_tetris_the_fall_never_gets_faster_than_its_limit);
|
||||
RUN_TEST(test_tetris_is_over_when_a_piece_has_no_room);
|
||||
RUN_TEST(test_tetris_the_same_seed_deals_the_same_pieces);
|
||||
RUN_TEST(test_tetris_every_piece_in_every_turn_has_four_cells_in_its_box);
|
||||
RUN_TEST(test_a_tune_gives_its_notes_in_time);
|
||||
RUN_TEST(test_a_tune_keeps_time_over_uneven_steps);
|
||||
RUN_TEST(test_a_tune_skips_what_a_long_gap_missed);
|
||||
RUN_TEST(test_korobeiniki_is_whole_bars);
|
||||
RUN_TEST(test_the_tune_hurries_with_the_level);
|
||||
RUN_TEST(test_a_new_pace_starts_at_the_next_note);
|
||||
return UNITY_END();
|
||||
}
|
||||
Reference in New Issue
Block a user