added some functions to ms_game.c

ms_game.c

@@ -10,11 +10,460 @@
  * ----------------------------------------------------------
  */
 
+#include <stdlib.h>
+#include "ms_game.h"
+#include "ms_board.h"
+#include "ms_cell.h"
+#include "ms_ui_utils.h"
 
 /** Encapsulate a cell and its board coordinates */
+struct MsCellCoord {
+    MsCell cell;
+    ColAddr col;
+    RowAddr row;
+};
 
 /** The only instance of cell data */
+static struct MsCellCoord cell_coords[MAX_BOARD_SIZE * MAX_BOARD_SIZE] = {0};
 
 /** The struct holding the data of the game */
+struct MsGameData {
+    MsBoard board;
+    GameState state;
+};
 
 /** The instance of the game */
+static MsGame the_game = 0;
+
+/**
+ * Starts a new game using the given mode. If a mode with a
+ * predefined configuration is used, this function shall actually start
+ * the game with that configuration using function `msg_start_game`.
+ * Otherwise, the user shall be prompted for required attributes 
+ * (board size, mines) and the game is started afterwards.
+ * 
+ * @param mode The configuration mode of the game to start.
+ * @return The game if if could be started with a predefined configuration,
+ * or 0 if it was not started because a custom configuration is required.
+ */
+MsGame msg_start_configured_game(GameMode mode) {
+    if (the_game != 0) {
+        the_game->state = INVALID;
+    }
+
+    Count cols = 0;
+    Count rows = 0;
+    Count mines = 0;
+
+    switch (mode) {
+        case BEGINNER:
+            cols = 9;
+            rows = 9;
+            mines = 10;
+            break;
+        case ADVANCED:
+            cols = 16;
+            rows = 16;
+            mines = 40;
+            break;
+        case EXPERT:
+            cols = 30;
+            rows = 16;
+            mines = 99;
+            break;
+        case CUSTOM:
+        default:
+            return 0;
+    }
+
+    return msg_start_game(cols, rows, mines);
+}
+
+/**
+ * Starts a new game, regardless of the state of the current game.
+ * Therefore, completed games or games in progress are aborted 
+ * and a new game is 'restarted'.
+ * 
+ * Note: Mines are distributed when the first cell is uncovered
+ * to ensure to uncover an empty cell.
+ * 
+ * @param column_count The number of columns to use on the game board.
+ * @param row_count The number of rows to use on the game board.
+ * @param mine_count The number of mines distributed on the board.
+ *                    It must be greater than 0;
+ * @return The started game or 0 in case errors.
+ */
+MsGame msg_start_game(Count column_count, Count row_count, Count mine_count) {
+    if (the_game != 0) {
+        the_game->state = INVALID;
+    }
+
+    if (column_count == 0 || row_count == 0 || mine_count == 0 || column_count * row_count < mine_count + 9) {
+        return 0;
+    }
+
+    the_game = (MsGame)calloc(1, sizeof(struct MsGameData));
+    the_game->board = msb_get_board();
+    msb_init_board(the_game->board, column_count, row_count);
+    the_game->state = IN_PROGRESS;
+
+    for (CellIdx row = 0; row < row_count; row++) {
+        for (CellIdx col = 0; col < column_count; col++) {
+            cell_coords[row * column_count + col].cell = msb_get_cell(the_game->board, col, row);
+            cell_coords[row * column_count + col].col = msu_idx_to_col_address(col);
+            cell_coords[row * column_count + col].row = msu_idx_to_row_address(row);
+        }
+    }
+
+    return the_game;
+}
+
+/**
+ * Determines whether or not the given game is valid.
+ * A game is NOT valid, if:
+ *      + it is 0 
+ *      + or if it has an invalid board
+ *      + or if it has no mines
+ *      + or if it has less than 10 cells
+ *      + or if it has more mines than cells - 9.
+ * 
+ * @param game The game instance in focus.
+ * @return True if the given game is valid, false otherwise.
+ */
+bool msg_is_valid(MsGame game) {
+    if (game == 0 || !msb_is_valid(game->board)) {
+        return false;
+    }
+
+    Count cols = msb_get_column_count(game->board);
+    Count rows = msb_get_row_count(game->board);
+    Count mines = 0;
+
+    bool any_uncovered = false;
+    for (CellIdx row = 0; row < rows && !any_uncovered; row++) {
+        for (CellIdx col = 0; col < cols && !any_uncovered; col++) {
+            MsCell cell = msb_get_cell(game->board, col, row);
+            if (!msc_is_covered(cell)) {
+                any_uncovered = true;
+            }
+        }
+    }
+
+    if (any_uncovered) {
+        Count mines = 0;
+        for (CellIdx row = 0; row < rows; row++) {
+            for (CellIdx col = 0; col < cols; col++) {
+                if (msc_has_mine(msb_get_cell(game->board, col, row))) {
+                    mines++;
+                }
+            }
+        }
+        return cols * rows >= 10 && mines > 0 && mines < cols * rows - 9;
+    }
+
+    return cols * rows >= 10;
+}
+
+/**
+ * Selects the addressed cell without performing any action on that cell. Only 
+ * covered cells can be selected. The function clears any previous selection
+ * and selects the addressed cell. Therefore invalid addresses or already uncovered cells
+ * has only the effect of clearing a previous selection.
+ * 
+ * To avoid uncovering unwanted cells due to wrong user inputs, the cell to uncover
+ * is selected in the first step. Only the selected cell can be uncovered.
+ * 
+ * @param game The game instance in focus.
+ * @param column The column of the cell to select in the format used on the UI (e.g. 'A', 'B').
+ * @param row The row of the cell to select in the format used on the UI (e.g. 1, 2).
+ * @return True if the addressed cell is selected, false otherwise.
+ */
+bool msg_select_cell(MsGame game, ColAddr column, RowAddr row) {
+    if (!msg_is_valid(game)) {
+        return false;
+    }
+
+    Count cols = msb_get_column_count(game->board);
+    Count rows = msb_get_row_count(game->board);
+    CellIdx col_idx = msu_col_address_to_index(column);
+    CellIdx row_idx = msu_row_address_to_index(row);
+
+    if (col_idx >= cols || row_idx >= rows) {
+        return false;
+    }
+
+    MsCell cell = msb_get_cell(game->board, col_idx, row_idx);
+    if (!msc_is_covered(cell)) {
+        return false;
+    }
+
+    for (CellIdx r = 0; r < rows; r++) {
+        for (CellIdx c = 0; c < cols; c++) {
+            cell_coords[r * cols + c].cell = 0;
+            cell_coords[r * cols + c].col = 0;
+            cell_coords[r * cols + c].row = 0;
+        }
+    }
+
+    cell_coords[row_idx * cols + col_idx].cell = cell;
+    cell_coords[row_idx * cols + col_idx].col = column;  
+    cell_coords[row_idx * cols + col_idx].row = row;
+
+
+    return true;
+}
+
+/** 
+ * Provides the currently selected cell.
+ * 
+ * @return The currently selected cell or 0,
+ * if no cell is selected.
+ */
+MsCell msg_get_selected_cell(MsGame game) {
+    if (!msg_is_valid(game)) {
+        return 0;
+    }
+
+    Count cols = msb_get_column_count(game->board);
+    Count rows = msb_get_row_count(game->board);
+
+    for (CellIdx r = 0; r < rows; r++) {
+        for (CellIdx c = 0; c < cols; c++) {
+            if (cell_coords[r * cols + c].cell != 0) {
+                return cell_coords[r * cols + c].cell;
+            }
+        }
+    }
+
+    return 0;
+}
+
+/**
+ * Uncovers the currently selected cell.
+ * To avoid uncovering unwanted cells due to wrong user inputs, the cell to uncover
+ * must be selected in the first step via function ´msg_select_cell´. 
+ * 
+ * Only the selected cell can be uncovered, otherwise the invocation is ignored.
+ * No cell is selected afterwards.
+ * 
+ * Mines are randomly distributed on the board when the first cell of a game is uncovered.
+ * Mines shall be distributed in a way that keeps the first uncovered cell empty.
+ * Depending on the size of the board and the number of mines, the randomized mine distribution
+ * may take long to find a proper cell for all mines. Therefore mine distribution shall be
+ * aborted after 10 X mine-count trials. The number of mines on the board need to be updated
+ * accordingly, if not all mines could be dropped. 
+ * 
+ * @param game The game instance in focus.
+ */
+void msg_uncover_selected_cell(MsGame game) {
+    if (!msg_is_valid(game)) {
+        return;
+    }
+
+    MsCell cell = msg_get_selected_cell(game);
+    if (cell == 0) {
+        return;
+    }
+
+    if (!msc_uncover(cell)) {
+        return;
+    }
+
+    Count cols = msb_get_column_count(game->board);
+    Count rows = msb_get_row_count(game->board);
+    Count mines = 0;
+
+    for (CellIdx r = 0; r < rows; r++) {
+        for (CellIdx c = 0; c < cols; c++) {
+            if (msc_has_mine(msb_get_cell(game->board, c, r))) {
+                mines++;
+            }
+        }
+    }
+
+    if (mines == 0) {
+        return;
+    }
+
+    for (CellIdx r = 0; r < rows; r++) {
+        for (CellIdx c = 0; c < cols; c++) {
+            MsCell current = msb_get_cell(game->board, c, r);
+            if (msc_has_mine(current)) {
+                msc_drop_mine(current);
+            }
+        }
+    }
+}
+
+/**
+ * Sets the marker on the addressed cell. To clear the marker, the marker ´NONE´ is used.
+ * The cell to mark must be selected in the first step via function ´msg_select_cell´. 
+ * Only the selected cell can be marked, otherwise the invocation is ignored.
+ * No cell is selected afterwards.
+ * 
+ * Note: The number of set mine-detected markers must NOT be larger than the number
+ * of mines on the board.
+ * 
+ * @param game The game instance in focus.
+ * @param marker The marker to apply.
+ */
+void msg_mark_selected_cell(MsGame game, CellMarker marker) {
+    if (!msg_is_valid(game)) {
+        return;
+    }
+
+    MsCell cell = msg_get_selected_cell(game);
+    if (cell == 0) {
+        return;
+    }
+
+    if (marker == MINE_DETECTED) {
+        Count mines = msg_get_mines_left_count(game);
+        if (mines == 0) {
+            return;
+        }
+    }
+
+    msc_set_marker(cell, marker);
+}
+
+/**
+ * Determines the state of the current game.
+ * 
+ * @param game The game instance in focus.
+ * @return The state of the current game.
+ */
+GameState msg_get_state(MsGame game) {
+    if (!msg_is_valid(game)) {
+        return INVALID;
+    }
+
+    Count cols = msb_get_column_count(game->board);
+    Count rows = msb_get_row_count(game->board);
+    Count mines = 0;
+    Count uncovered = 0;
+
+    for (CellIdx r = 0; r < rows; r++) {
+        for (CellIdx c = 0; c < cols; c++) {
+            MsCell cell = msb_get_cell(game->board, c, r);
+            if (msc_has_mine(cell) && msc_get_marker(cell) == MINE_DETECTED) {
+                mines++;
+            }
+            if (!msc_is_covered(cell)) {
+                uncovered++;
+            }
+        }
+    }
+
+    if (uncovered == cols * rows) {
+        return SOLVED;
+    }
+
+    if (mines > 0) {
+        return FAILED;
+    }
+
+    return IN_PROGRESS;
+}
+
+/**
+ * Provides the number of mines that are detected. 
+ * This is the difference of total number of mines the board carries
+ * minus the number of cells being marked as 'detected'.
+ * Cells marked as 'suspected' does not contribute to this value.
+ * 
+ * @param game The game instance in focus.
+ * @return The number of undetected mines
+ *         or 0, if the game is not valid.
+ */
+Count msg_get_mines_left_count(MsGame game) {
+    if (!msg_is_valid(game)) {
+        return 0;
+    }
+
+    Count cols = msb_get_column_count(game->board);
+    Count rows = msb_get_row_count(game->board);
+    Count mines = 0;
+
+    for (CellIdx r = 0; r < rows; r++) {
+        for (CellIdx c = 0; c < cols; c++) {
+            MsCell cell = msb_get_cell(game->board, c, r);
+            if (msc_has_mine(cell) && msc_get_marker(cell) == MINE_DETECTED) {
+                mines++;
+            }
+        }
+    }
+
+    return mines;
+}
+
+/**
+ * Provides the number of cells that are suspected carrying mines.
+ * 
+ * @param game The game instance in focus.
+ * @return The number of suspected mines
+ *         or 0, if the game is not valid.
+ */
+Count msg_get_mines_suspected_count(MsGame game) {
+    if (!msg_is_valid(game)) {
+        return 0;
+    }
+
+    Count cols = msb_get_column_count(game->board);
+    Count rows = msb_get_row_count(game->board);
+    Count mines = 0;
+
+    for (CellIdx r = 0; r < rows; r++) {
+        for (CellIdx c = 0; c < cols; c++) {
+            MsCell cell = msb_get_cell(game->board, c, r);
+            if (msc_has_mine(cell) && msc_get_marker(cell) == MINE_SUSPECTED) {
+                mines++;
+            }
+        }
+    }
+
+    return mines;
+}
+
+/**
+ * Provides the number of times a cell was actively uncovered by the user.
+ * Note: This is not (necessarily) equal to the number of uncovered cells,
+ * because uncovering empty cells uncovers more than one cell. Such an
+ * activity is counted as 'one action' only.
+ * 
+ * @param game The game instance in focus.
+ * @return The number of times the used uncovered a cell
+ *         or 0, if the game is not valid.
+ */
+Count msg_get_uncover_action_count(MsGame game) {
+    if (!msg_is_valid(game)) {
+        return 0;
+    }
+
+    Count cols = msb_get_column_count(game->board);
+    Count rows = msb_get_row_count(game->board);
+    Count actions = 0;
+
+    for (CellIdx r = 0; r < rows; r++) {
+        for (CellIdx c = 0; c < cols; c++) {
+            MsCell cell = msb_get_cell(game->board, c, r);
+            if (!msc_is_covered(cell)) {
+                actions++;
+            }
+        }
+    }
+
+    return actions;
+}
+
+/**
+ * Provides access to the underlying game board. This function is intended
+ * for being used by game visualizer but should not be needed by the game 
+ * application.
+ * 
+ * @param game The game instance in focus.
+ * @return The board used by the game instance or 0, if the game is invalid.
+ */
+MsBoard msg_get_board(MsGame game) {
+    return msg_is_valid(game) ? game->board : 0;
+}