RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 05:07:45 +00:00
Code Issues Activity Actions

2048: Abstract Board into its own struct

Browse source
This commit is contained in:
Dmitrii Ubskii 2021-06-11 15:26:56 +03:00 • committed by Andreas Kling
parent ec8fe6952f
commit 11158c2400
3 changed files with 56 additions and 46 deletions
Download patch file Download diff file Expand all files Collapse all files

12
Userland/Games/2048/BoardView.cpp
View file

@ -29,7 +29,7 @@ void BoardView::set_board(Game::Board const* board)
return; return;
} }
bool must_resize = !m_board || m_board->size() != board->size(); bool must_resize = !m_board || m_board->tiles.size() != board->tiles.size();
m_board = board; m_board = board;
@ -62,16 +62,16 @@ size_t BoardView::rows() const
{ {
if (!m_board) if (!m_board)
return 0; return 0;
return m_board->size(); return m_board->tiles.size();
} }
size_t BoardView::columns() const size_t BoardView::columns() const
{ {
if (!m_board) if (!m_board)
return 0; return 0;
if (m_board->is_empty()) if (m_board->tiles.is_empty())
return 0; return 0;
return (*m_board)[0].size(); return m_board->tiles[0].size();
} }
void BoardView::resize_event(GUI::ResizeEvent&) void BoardView::resize_event(GUI::ResizeEvent&)
@ -172,7 +172,7 @@ void BoardView::paint_event(GUI::PaintEvent& event)
painter.fill_rect(rect(), background_color); painter.fill_rect(rect(), background_color);
return; return;
} }
auto& board = *m_board; auto& tiles = m_board->tiles;
Gfx::IntRect field_rect { Gfx::IntRect field_rect {
0, 0,
@ -191,7 +191,7 @@ void BoardView::paint_event(GUI::PaintEvent& event)
m_cell_size, m_cell_size,
m_cell_size, m_cell_size,
}; };
auto entry = board[row][column]; auto entry = tiles[row][column];
painter.fill_rect(rect, background_color_for_cell(entry)); painter.fill_rect(rect, background_color_for_cell(entry));
if (entry > 0) if (entry > 0)
painter.draw_text(rect, String::number(entry), font(), Gfx::TextAlignment::Center, text_color_for_cell(entry)); painter.draw_text(rect, String::number(entry), font(), Gfx::TextAlignment::Center, text_color_for_cell(entry));

78
Userland/Games/2048/Game.cpp
View file

@ -21,8 +21,8 @@ Game::Game(size_t grid_size, size_t target_tile, bool evil_ai)
else else
m_target_tile = target_tile; m_target_tile = target_tile;
m_board.resize(grid_size); m_board.tiles.resize(grid_size);
for (auto& row : m_board) { for (auto& row : m_board.tiles) {
row.ensure_capacity(grid_size); row.ensure_capacity(grid_size);
for (size_t i = 0; i < grid_size; i++) for (size_t i = 0; i < grid_size; i++)
row.append(0); row.append(0);
@ -39,44 +39,44 @@ void Game::add_random_tile()
do { do {
row = rand() % m_grid_size; row = rand() % m_grid_size;
column = rand() % m_grid_size; column = rand() % m_grid_size;
} while (m_board[row][column] != 0); } while (m_board.tiles[row][column] != 0);
size_t value = rand() < RAND_MAX * 0.9 ? 2 : 4; size_t value = rand() < RAND_MAX * 0.9 ? 2 : 4;
m_board[row][column] = value; m_board.add_tile(row, column, value);
} }
static Game::Board transpose(Game::Board const& board) static Game::Board::Tiles transpose(Game::Board::Tiles const& tiles)
{ {
Vector<Vector<u32>> new_board; Game::Board::Tiles new_tiles;
auto result_row_count = board[0].size(); auto result_row_count = tiles[0].size();
auto result_column_count = board.size(); auto result_column_count = tiles.size();
new_board.resize(result_row_count); new_tiles.resize(result_row_count);
for (size_t i = 0; i < board.size(); ++i) { for (size_t i = 0; i < tiles.size(); ++i) {
auto& row = new_board[i]; auto& row = new_tiles[i];
row.clear_with_capacity(); row.clear_with_capacity();
row.ensure_capacity(result_column_count); row.ensure_capacity(result_column_count);
for (auto& entry : board) { for (auto& entry : tiles) {
row.append(entry[i]); row.append(entry[i]);
} }
} }
return new_board; return new_tiles;
} }
static Game::Board reverse(Game::Board const& board) static Game::Board::Tiles reverse(Game::Board::Tiles const& tiles)
{ {
auto new_board = board; auto new_tiles = tiles;
for (auto& row : new_board) { for (auto& row : new_tiles) {
for (size_t i = 0; i < row.size() / 2; ++i) for (size_t i = 0; i < row.size() / 2; ++i)
swap(row[i], row[row.size() - i - 1]); swap(row[i], row[row.size() - i - 1]);
} }
return new_board; return new_tiles;
} }
static Vector<u32> slide_row(Vector<u32> const& row, size_t& successful_merge_score) static Game::Board::Row slide_row(Game::Board::Row const& row, size_t& successful_merge_score)
{ {
if (row.size() < 2) if (row.size() < 2)
return row; return row;
@ -114,18 +114,18 @@ static Vector<u32> slide_row(Vector<u32> const& row, size_t& successful_merge_sc
return result; return result;
} }
static Game::Board slide_left(Game::Board const& board, size_t& successful_merge_score) static Game::Board::Tiles slide_left(Game::Board::Tiles const& tiles, size_t& successful_merge_score)
{ {
Vector<Vector<u32>> new_board; Game::Board::Tiles new_tiles;
for (auto& row : board) for (auto& row : tiles)
new_board.append(slide_row(row, successful_merge_score)); new_tiles.append(slide_row(row, successful_merge_score));
return new_board; return new_tiles;
} }
static bool is_complete(Game::Board const& board, size_t target) static bool is_complete(Game::Board const& board, size_t target)
{ {
for (auto& row : board) { for (auto& row : board.tiles) {
if (row.contains_slow(target)) if (row.contains_slow(target))
return true; return true;
} }
@ -153,11 +153,11 @@ static bool is_stalled(Game::Board const& board)
return !row.contains_slow(0) && has_no_neighbors(row.span()); return !row.contains_slow(0) && has_no_neighbors(row.span());
}; };
for (auto& row : board) for (auto& row : board.tiles)
if (!stalled(row)) if (!stalled(row))
return false; return false;
for (auto& row : transpose(board)) for (auto& row : transpose(board.tiles))
if (!stalled(row)) if (!stalled(row))
return false; return false;
@ -167,7 +167,7 @@ static bool is_stalled(Game::Board const& board)
static size_t get_number_of_free_cells(Game::Board const& board) static size_t get_number_of_free_cells(Game::Board const& board)
{ {
size_t accumulator = 0; size_t accumulator = 0;
for (auto& row : board) { for (auto& row : board.tiles) {
for (auto& cell : row) for (auto& cell : row)
accumulator += cell == 0; accumulator += cell == 0;
} }
@ -177,26 +177,26 @@ static size_t get_number_of_free_cells(Game::Board const& board)
bool Game::slide_tiles(Direction direction) bool Game::slide_tiles(Direction direction)
{ {
size_t successful_merge_score = 0; size_t successful_merge_score = 0;
Board new_board; Game::Board::Tiles new_tiles;
switch (direction) { switch (direction) {
case Direction::Left: case Direction::Left:
new_board = slide_left(m_board, successful_merge_score); new_tiles = slide_left(m_board.tiles, successful_merge_score);
break; break;
case Direction::Right: case Direction::Right:
new_board = reverse(slide_left(reverse(m_board), successful_merge_score)); new_tiles = reverse(slide_left(reverse(m_board.tiles), successful_merge_score));
break; break;
case Direction::Up: case Direction::Up:
new_board = transpose(slide_left(transpose(m_board), successful_merge_score)); new_tiles = transpose(slide_left(transpose(m_board.tiles), successful_merge_score));
break; break;
case Direction::Down: case Direction::Down:
new_board = transpose(reverse(slide_left(reverse(transpose(m_board)), successful_merge_score))); new_tiles = transpose(reverse(slide_left(reverse(transpose(m_board.tiles)), successful_merge_score)));
break; break;
} }
bool moved = new_board != m_board; bool moved = new_tiles != m_board.tiles;
if (moved) { if (moved) {
m_board = new_board; m_board.tiles = new_tiles;
m_score += successful_merge_score; m_score += successful_merge_score;
} }
@ -231,14 +231,14 @@ void Game::add_evil_tile()
for (size_t row = 0; row < m_grid_size; row++) { for (size_t row = 0; row < m_grid_size; row++) {
for (size_t column = 0; column < m_grid_size; column++) { for (size_t column = 0; column < m_grid_size; column++) {
if (m_board[row][column] != 0) if (m_board.tiles[row][column] != 0)
continue; continue;
for (u32 value : Array { 2, 4 }) { for (u32 value : Array { 2, 4 }) {
Game saved_state = *this; Game saved_state = *this;
saved_state.m_board[row][column] = value; saved_state.m_board.tiles[row][column] = value;
if (is_stalled(saved_state.m_board)) { if (is_stalled(saved_state.board())) {
// We can stall the board now, instant game over. // We can stall the board now, instant game over.
worst_row = row; worst_row = row;
worst_column = column; worst_column = column;
@ -279,13 +279,13 @@ void Game::add_evil_tile()
} }
} }
found_worst_tile: found_worst_tile:
m_board[worst_row][worst_column] = worst_value; m_board.add_tile(worst_row, worst_column, worst_value);
} }
u32 Game::largest_tile() const u32 Game::largest_tile() const
{ {
u32 tile = 0; u32 tile = 0;
for (auto& row : board()) { for (auto& row : m_board.tiles) {
for (auto& cell : row) for (auto& cell : row)
tile = max(tile, cell); tile = max(tile, cell);
} }

12
Userland/Games/2048/Game.h
View file

@ -35,7 +35,17 @@ public:
u32 target_tile() const { return m_target_tile; } u32 target_tile() const { return m_target_tile; }
u32 largest_tile() const; u32 largest_tile() const;
using Board = Vector<Vector<u32>>; struct Board {
using Row = Vector<u32>;
using Tiles = Vector<Row>;
Tiles tiles;
void add_tile(size_t row, size_t column, u32 value)
{
tiles[row][column] = value;
}
};
Board const& board() const { return m_board; } Board const& board() const { return m_board; }