Task 1 - Game design

Step 1

1. By clicking on the application link you will be taken to GitLab to sign in and authorize the GitLab Classroom application created for you by Manager.
2. By authorizing the application, you will be redirected to the page for creating the project, where you select the study group you attend according to your study timetable. (Foreign students with the study programme in English should select group 07-Streda 09.10 Šťastná.)
3. Write down tha name of the game that was assigned to you into the text field (e.g. Minesweeper).
4. By clicking on the button for creating the project, a new empty repository will be created for you in GitLab. You will gradually add you solution of exercises into the repository.

Step 2

When designing the architecture of your game, you will get the inspiration from the game Minesweeper. It is a computer game designed for one player. The goal of the game is to clear the game field without detonating any mines.

More detailed information about the game can be found e.g. on the Wikipedia and you can play it online on http://minesweeperonline.com/.

When creating a conceptual model, the method of analysing objects and actions is used. The method applies in two directions: from objects (entities) to actions and from actions to objects.

1. First, the fundamental objects of the designed system (in our case game) are identified. After that, all actions which can be performed with these objects are identified.
2. When there is no new action left, then all already identifed actions are gradually considered and checked whether some new object may arise as a consequence of executing those actions.

You can repeat this procedure in several iterations. Also, you can identify the most important properties of objects and relations between objects.

One of the representations of a conceptual model is a class diagram.

Classes are derived from objects, methods result from their actions and private fields result from the properties. Relations in the class diagram (inheritance, association, aggregation, composition) arise from the relations between objects.

The following figure represents an example of a simple class diagram for the game Minesweeper.

When designing tile-based games we recommend to use packages for structuring the code - the main package named after the implementd game, e.g. minesweeper, and inside it a package core for the game core implementation, and a package consoleui for the console user interface of the game.

The basic structure of the project for the game Minesweeper may look like this:

• minesweeper - the root package, contains the main classes of the application.
  • Minesweeper - the main class with the main method.
• minesweeper.core - a package contains classes that define the logic of the game field, independently from the user interface.
  • Field - a class representing the game field and its functionality. The game field contains tiles.
  • Tile - a class representing one tile of the game field. Tiles are of two types: a mine Mine and a hint when looking for mines Clue.
  • Mine - a class representing a tile of type mine.
  • Clue - a class representing a tile of type hint when looking for mines.
  • TileState - an enumeration type representing the state of a tile.
  • GameState - an enumeration type representing the state of the game.
• minesweeper.consoleui - a package that contains classes defining user interaction.
  • ConsoleUI - a class that defines user interaction with the game field.

Step 3

For example, a tile in the Minesweeper game can be in states: uncovered - OPEN, closed - CLOSED, or marked by a flag - MARKED.

The basic game states are usually very similar among various tile-based games. The game can be running (state PLAYING), successfully finished (state SOLVED), or unsuccessfully finished (state FAILED).

Your game might have more or less than three states. For example, in the game Bejeweled, there may be the state NO_POSSIBLE_MOVES, which can occur after any move. In this state a possible action to continue would be to randomly shuffle the tiles.

Step 4

In the Minesweeper game, during the game field generation it is necessary to:

1. Randomly generate a specified number of mines (mineCount) in the game field.
   1. In a loop, on randomly selected row and column a new mine is inserted - a new instance of the Mine class.
   2. To ensure that no other mine will be inserted on a place where there already is a mine, check if the randomly generated position is empty (contains null).
   3. The loop ends when mineCount mines were inserted into the game field.
2. The remaining empty places in the field are filled by hint tiles of type Clue.
   • The value of the hint tile is specified by the number of mines that are in neighbouring tiles, which can be implemented in a separate method, named e.g. countAdjacentMines().

After each player's move in the game Minesweeper we check whether the game is failed or solved.

1. If the player opens a tile of type Mine, the game state transitions to FAILED and the game ends.
2. The game is considered solved, if the number of all tiles minus number of open tiles equals number of mines.
3. If the game was not solved nor failed, it continues with the next move of the player.

The player's move consists of selecting the type of an action:

• opening a tile on selected coordinates if the tile is in the state CLOSED, which can be implemented in a method openTile(int row, int column),
• marking or un-marking a tile on selected coordinates - if the tile is in the state CLOSED it will go to the state MARKED, and vice-versa. This can be implemented in a method markTile(int row, int column).

Step 5