There seem to be some problems after the merge with #48, the iterators need to be corrected

A refactoring of the tests classes is needed, I'm gonna start by moving the providers to appropriate Providers classes

Follow Managing a branch protection rule

Add the following rules:

1. Require a pull request before merging
2. Require approvals

Is your feature request related to a problem? Please describe.
Implement the last move dialog

I realized that a board can have other sizes, not only 8x8 or 10x10 (see README description).

At the moment the starting position is (1,1). Would it be better with (0,0)?

We have to start to use more Streams (we can start by replacing some for statements).

1. it.units.sdm.project.game.terminal.FreedomGame
2. it.units.sdm.project.game.terminal.TextInput

We should have a StoneProvider or Stonefactory class to generate new Stone instances

Where applicable, MapBoard references should be refactored to Board references

I get error when I have to do the last move

Is your feature request related to a problem? Please describe.
Improve the main menu appearance

1. Is there a more relevant toString() method than the original one?
2. equals(): why is the board field considered when evaluating if two FreedomLines are equal?

Improve tests by checking the following:

1. There should be a test for each class method
2. For each method, test:
   1. One correct input
   2. One wrong input
   3. Every border case
   4. Test for exceptions thrown

These two classes may actually be useful only for the internal implementation of Board and Game classes respectively

As "first working implementation" I think that we have to create a terminal version of the game. So we need to decide how to read user inputs (in #31 I created a UserInput interface)

Describe the bug
Board columns appear as ASCII characters other than letters

To Reproduce
Steps to reproduce the behavior:

1. run the terminal:run gradle task with a board size parameter of 90

Expected behavior
Board size should be limited to the number of letters in the english alphabet

Screenshots
If applicable, add screenshots to help explain your problem.

Environment:

• terminal module
• gradle launch configuration

Add cosmetics for the terminal game version, for example some ASCII art.

The Board's iterator should probably be removed and replaced by a getPositions() method entirely. Also, the Cell interface is never used outside of MapBoard: we might as well refactor it into a private abstract class inside of MapBoard, replacing MapBoardCell

Where possible, tests should be added to check the behavior of the new methods in the mentioned classes.

A first software architecture design: define interfaces, classes, relationships and so on.

We have to make the class Game more general. We can create an abstract class Game and a class that extends the Game class named FreedomGame. The FreedomGame would have a field UserInput userInput which is initialized in the constructor as follows (for example):

    public enum TypeOfGame {TERMINAL, GUI, CLIENT_SERVER}

    private UserInput userInput;

    public FreedomGame(@NotNull Board board, @NotNull Player whitePlayer, @NotNull Player blackPlayer, @NotNull TypeOfGame typeOfGame) {
        super(board, whitePlayer, blackPlayer);
        switch (typeOfGame) {
            case TERMINAL:
                this.userInput = new TextInput();
            case GUI:
                // TODO
                break;
            case CLIENT_SERVER:
                // TODO
        }
    }

This is just an idea, we can do it another way, for example creating three different classes for the three versions of the game. Let me know what you think.

Logging to a local file using the provided class should be added

It has to be generalized (e.g. Line class) and there must be a check in the add method (and also in the constructor) to prevent "no-line" shapes

I think that we need a separate class file where to place the color enum, because it will be used in different classes.

I think that we need a class Logger for logging on the standard output.

The Position class should have an ordering to iterate the Board properly

Found bug

When picking a free cell on row 8, on the next iteration the system wrongly suggests cells that are out of board bounds

How to reproduce

Start a game. Keep picking positions until you reach row 8. On the next iteration, positions outside the board will be wrongly suggested. Thankfully, if a position out of bounds gets picked, the system refuses it. However, even if the next picked position is correct, the system will crash.

I think that the putStone method is not strictly related to the Board class. So, instead, we can create a class Play which will contain the method putStone and other actions that a Player can do.

Add artifact storing for release builds and test results storing

Add Freedom rules and images

Describe the bug
When the desktop:run gradle task is executed, a RuntimeException is thrown

To Reproduce
Steps to reproduce the behavior:

1. Run ./gradlew desktop:run
2. Click on an empty tile

Expected behavior
An image asset should be loaded on the empty tile

Environment:

• Project module: desktop
• Launch configuration used: gradle launch configuration

Implementation of the class Game

Instead of using a new Position instance every time we call a method, create a new instance inside the method (or perhaps some other solution might work as well)

If the board is larger than 9x9, the user is unable to insert row indexes larger than 9, because the used regex prevents it.
The following condition needs to be corrected:

if (input.matches("[A-Z][0-9]")) {
// etc
}