Task 1 - Game design

Step 1

1. By clicking the link above, you will be prompted in GitLab to sign in and authorize the GitLab Classroom application prepared for you by the Manager.
2. After authorizing the application, you will be redirected to the page for creating projects, where you select the group according to the timetable slot you attend in the course.
3. Enter the name of the game you are solving as part of the assignment (e.g. Minesweeper).
4. By clicking the button for creating the project, a repository with a prepared Maven structure of the GameStudio project will be created for you in GitLab. You will use this project throughout the semester.

The basic directory structure of the project is as follows:

text gamestudio // main project directory
├── src
│ ├── main // source files of the project
│ │ └── java
│ │   └── sk
│ │     └── tuke
│ │       └── gamestudio // main package of the GameStudio project
│ │         └── game // package for game implementations
│ │           ├── minesweeper
│ │           └── yourgame - package with the name of your game
│ └── test // source files for tests
│   └── java // your tests go into this directory
├── .gitignore
└── pom.xml // Maven configuration file

The project is managed as a [Maven] project - the pom.xml configuration file contains the basic dependencies (libraries) needed for further work.

Step 2

Use the game Minesweeper as inspiration when designing your own game. Minesweeper is a computer game for a single player. The goal of the game is to clear the game field from mines without detonating them.

More information about this game can be found for example on Wikipedia and you can play it online at http://minesweeperonline.com/.

When creating a conceptual model, the method of object and action analysis is used, proceeding in two directions: from objects (entities) to actions and from actions to objects.

1. First, the basic objects of the designed system (in our case, the game) are identified, and then all actions that can be performed with those objects are identified.
2. When no new action appears, all already identified actions are gradually reviewed to check whether a new object is needed for their execution.

This procedure can be repeated. The most important properties of objects and relations between individual objects are also identified.

One representation of a conceptual model may be a class diagram.

From objects we derive classes, from their actions we derive methods, from their properties we derive class variables, and from relations between objects we derive relations between classes in the class diagram (inheritance, association, aggregation, composition).

The following image shows an example of a simple class diagram for the game Minesweeper.

When designing tile-based games, we recommend using packages to structure the code. Place the source code of your game into the package sk.tuke.gamestudio.game in src/main/java. Inside this package, create a subpackage named after your game, for example sk.tuke.gamestudio.game.minesweeper, and inside it further subpackages for the game core (core) and console interface (consoleui).

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

• sk.tuke.gamestudio.game.minesweeper - the main game package, containing the main application classes.
  • Minesweeper - the main application class with the main method.
• sk.tuke.gamestudio.game.minesweeper.core - package containing classes defining the game field logic, independent of the user interface.
  • Field - class representing the game field and its functionality. The field contains tiles.
  • Tile - class representing one tile of the game field. Tiles are of two types: a mine Mine and a clue Clue.
  • Mine - class representing a tile of type mine.
  • Clue - class representing a tile of type clue.
  • TileState - enumeration type representing a tile state.
  • GameState - enumeration type representing a game state.
• sk.tuke.gamestudio.game.minesweeper.consoleui - package containing classes defining user interaction.
  • ConsoleUI - class defining interaction between the game and the user.

Step 3

For example, a tile in the game Minesweeper can be in state OPEN (revealed), CLOSED (hidden), or MARKED.

The basic game states in simple tile-based games are usually similar: the game can be in progress (state PLAYING), successfully finished (state SOLVED), or unsuccessfully finished (state FAILED).

However, your game may have more states. For example, in the game Bejeweled, there may be a state NO_POSSIBLE_MOVES, which the player can reach after any move. In this state, one possible action is random shuffling of tiles.

Step 4

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

1. Randomly generate the specified number of mines mineCount in the game field.
   • In a loop, a mine - an instance of class Mine - is placed into the tile field (field) at a randomly chosen row and column.
   • To ensure that no mine is placed where a mine already exists, check whether the randomly generated position is empty.
   • The loop ends when the required number of mines (mineCount) has been placed.
2. The remaining empty places in the field are filled with clue tiles of type Clue.
   • The value of a clue tile is determined by counting the mines in adjacent tiles, which can be implemented in a separate method, e.g. countAdjacentMines().

After each move in the game Minesweeper, it is checked whether the game is won or lost.

1. If the player opens a tile of type Mine, the game is marked as lost and ends.
2. The game is considered won if: the number of all tiles minus the number of revealed tiles equals the number of mines.
3. If the game is neither won nor lost, it continues with the next player move.

A player move consists of choosing an action type:

• opening a tile, only if the tile is in state CLOSED, implemented for example by the method openTile(int row, int column),
• marking or unmarking a tile - if the tile is in state CLOSED, it transitions to MARKED and vice versa, implemented for example by the method markTile(int row, int column).

Step 5