# Table of Contents / Table des Matières

## 🇬🇧 English
1. [Documentation](#documentation)
2. [How to Compile and Run the Game](#how-to-compile-and-run-the-game)
3. [Command-Line Options for the Gomoku Game](#command-line-options-for-the-gomoku-game)
4. [Example Usage](#example-usage)
5. [Notes](#notes)
6. [Structure](#structure)

## 🇫🇷 Français
1. [La documentation](#la-documentation)
2. [Comment compiler et lancer le jeu ?](#comment-compiler-et-lancer-le-jeu-)
3. [Options de Commande pour le Jeu Gomoku](#options-de-commande-pour-le-jeu-gomoku)
4. [Exemple d'utilisation](#exemple-dutilisation)
5. [Remarques](#remarques)
6. [Structure](#structure-1)


# 🇬🇧 Gomoku

## Documentation

> docs/index.html

## How to Compile and Run the Game

```bash
javac -d build src/*java
java -cp build GomokuGame
```

## Command-Line Options for the Gomoku Game

Here are the different command-line options available to configure and launch the Gomoku game:

* `--save <path>`: Loads a saved game from the specified path.

  * Example: `--save path/to/game`

* `--pvp`: Enables player versus player (PvP) mode.

  * Example: `--pvp`

* `--size <width> <height>`: Sets the game board size.

  * Example: `--size 15 15`

* `--nbToken <number>`: Sets the number of tokens available for each player.

  * Example: `--nbToken 50`

* `--difficulty <level>`: Sets the AI difficulty level (1, 2, or 3).

  * Example: `--difficulty 2`

* `--nbTokenToWin <number>`: Sets the number of tokens in a row needed to win.

  * Example: `--nbTokenToWin 5`

## Example Usage

```bash
java -cp build GomokuGame --pvp --size 15 15 --nbToken 50 --difficulty 2 --nbTokenToWin 5
```

## Notes

* If an option is used incorrectly or parameters are invalid, default values will be applied.
* The minimum board size is 3x3. If a smaller size is specified, the game will not start.

## Structure

![UML](UML.png)

To begin, we created two enumerations: one for colors, named `Color`, and another for the cardinal directions, named `Cardinal`. Colors are used for the tokens placed on the board. The directions help us navigate the grid of cells, which are linked in all eight cardinal directions.

We have an abstract class representing the player, called `Player`, which has two subclasses:

* `Human`, which asks the user to play their turn,
* `GomokuAI`, which represents a computer-controlled player.

For the game area, we have a `GomokuCell` class that represents a cell with all its neighbors in the eight directions, as well as the color of the token placed in that cell. Another class, `GomokuBoard`, contains the top-left cell of the board. From this cell, we traverse the entire board. This class generates the board, board extensions, etc.

To run the game, we have the `GomokuGame` class, which has a `main` method and accepts parameters if the user wants. It creates the game and the game loop, and contains:

* Both players,
* The board,
* The number of aligned cells required to win,
* The current player,
* The renderer.

For rendering, we have an abstract class `GomokuRenderer` that is implemented by `ConsoleRenderer`, allowing the board to be displayed in the terminal. The abstract class exists to facilitate replacing the renderer in the future if needed.


# 🇫🇷 Gomoku

## La documentation
> docs/index.html

## Comment compiler et lancer le jeu ?
```bash
javac -d build src/*java
java -cp build GomokuGame
```
## Options de Commande pour le Jeu Gomoku

Voici les différentes options de commande disponibles pour configurer et lancer le jeu Gomoku :

- `--save <chemin>` : Charge une partie sauvegardée à partir du chemin spécifié.
  - Exemple : `--save chemin/vers/la/partie`

- `--pvp` : Active le mode joueur contre joueur (PvP).
  - Exemple : `--pvp`

- `--size <largeur> <hauteur>` : Définit la taille du plateau de jeu.
  - Exemple : `--size 15 15`

- `--nbToken <nombre>` : Définit le nombre de jetons disponibles pour chaque joueur.
  - Exemple : `--nbToken 50`

- `--difficulty <niveau>` : Définit le niveau de difficulté de l'IA (1, 2, ou 3).
  - Exemple : `--difficulty 2`

- `--nbTokenToWin <nombre>` : Définit le nombre de jetons à aligner pour gagner.
  - Exemple : `--nbTokenToWin 5`

### Exemple d'utilisation :
```bash
java -cp build GomokuGame --pvp --size 15 15 --nbToken 50 --difficulty 2 --nbTokenToWin 5
```

### Remarques :
- Si une option est mal utilisée ou si les paramètres sont invalides, les valeurs par défaut seront appliquées.
- La taille minimale du plateau est de 3x3. Si une taille inférieure est spécifiée, le jeu ne démarrera pas.

## Structure 
![UML](UML.png)

Pour commencer, nous avons créé deux énumérations : une pour les couleurs, nommée `Color`, 
et une autre pour les directions cardinales, nommée `Cardinal`. Les couleurs sont utilisées
pour les jetons placés sur le plateau. Les directions nous permettent de naviguer dans la grille
de cellules, qui est liée dans les huit directions cardinales.

Nous avons une classe abstraite représentant le joueur, nommée `Player`, qui se décline en deux classes :
- `Human`, qui sollicite l'utilisateur pour jouer son tour,
- `GomokuAI`, qui représente un joueur contrôlé par l'ordinateur.

Pour la zone de jeu, nous avons une classe `GomokuCell` qui représente une case possédant tous
ses voisins dans les huit directions ainsi que la couleur du jeton placé sur cette case. 
Une autre classe, `GomokuBoard`, contient la cellule située en haut à gauche du plateau. 
C'est à partir de cette cellule que nous parcourons l'ensemble du jeu. Cette classe génère le plateau, les extensions du plateau, etc.

Pour lancer le jeu, nous avons la classe `GomokuGame` qui possède une méthode `main` et accepte
des paramètres si l'utilisateur le souhaite. Elle crée la partie et la boucle de jeu, et contient :
- Les deux joueurs,
- Le plateau,
- Le nombre de cellules alignées nécessaires pour gagner,
- Le joueur actuel,
- Le renderer

Pour le rendu, nous avons une classe abstraite `GomokuRenderer` qui se décline en `ConsoleRenderer`,
permettant l'affichage du plateau dans le terminal. La classe abstraite existe pour faciliter le remplacement
du renderer si nécessaire à l'avenir.