120 lines
4.4 KiB
Markdown
120 lines
4.4 KiB
Markdown
IA: jeu de Reversi
|
|
------------------
|
|
|
|
Le but de ce projet est d'implémenter plusieurs mécanisme de jeu (humain et
|
|
intelligence artificielle) pour le jeu de Reversi
|
|
|
|
## Installation
|
|
|
|
Le programme utilise des outils standard de Python installé de base : `random`,
|
|
`math`, `argpase` et `logging`. Le project est fourni avec un shell *Nix* dans
|
|
le répertoire `src`
|
|
|
|
## Utilisation
|
|
|
|
le programme propose un emsemble d'options en ligne de commande afin de définir
|
|
les options du jeu comme le choix des implementations de jeu (aléatoine, MinMax
|
|
etc.) ou encore les paramètres (profondeur de recherche). Une aide est intégrée
|
|
au programme via la commande `./game.py -h`. Voici quelques exemple de
|
|
lancement:
|
|
|
|
```shell
|
|
# Lancement de base: les deux joueurs jouent avec le moteur aléatoire et les
|
|
options de base:
|
|
./game.py
|
|
|
|
# joueur noir humain et joueur blanc MinMax avec une profondeur de 5
|
|
./game.py -be human -we minmax --white-depth-exploration 5
|
|
```
|
|
Voici la liste des options :
|
|
|
|
* `-be` | `--black-player-engine`: moteur utilisé par le joueur avec les pions
|
|
noirs
|
|
* `-we` | `--white-player-engine`: moteur utilisé par le joueur avec les pions
|
|
blancs
|
|
* `-bd` | `--black-depth-exploration`: niveau d'eploration de l'arbre de jeu
|
|
pour le joueur au pions noirs, valable pour les moteurs `minmax` et
|
|
`alphabeta`
|
|
* `-wd` | `--white-depth-exploration`: niveau d'eploration de l'arbre de jeu
|
|
pour le joueur au pions noirs, valable pour les moteurs `minmax` et
|
|
`alphabeta`
|
|
* `-bh` | `--black-heuristic-engine`: moteur heuristique utilisé pour
|
|
l'exploration de l'arbre de jeu du joueur noir (valable pour les moteur de
|
|
jeu `minmax` et `alphabeta`)
|
|
* `-wh` | `--black-heuristic-engine`: moteur heuristique utilisé pour
|
|
l'exploration de l'arbre de jeu du joueur blanc (valable pour les moteur de
|
|
jeu `minmax` et `alphabeta`)
|
|
* `--weight`: scores utilisés pour le calcul des heuristiques pour les moteurs
|
|
`weight` et `full`.
|
|
|
|
L'affichage verbeux est activé avec `-V` et les informations de débogage sont
|
|
affichée avec l'option `-d`.
|
|
|
|
## Choix d'implémentation
|
|
|
|
J'ai avant tout privilégié la personnalisation des différentes paramètres des
|
|
différents moteurs composant le jeu.
|
|
|
|
### Classes PlayerEngine
|
|
|
|
Définies dans le fichier `./src/classes/Engines.py`, les classes utilisées
|
|
héritent de la classe de base `PlayerEngines` :
|
|
|
|
```python
|
|
class PlayerEngine(Object):
|
|
def __init__(self, logger, options):
|
|
def get_move(self, board):
|
|
|
|
class MinmaxPlayerEngine(PlayerEngine):
|
|
def get_move(board):
|
|
|
|
class RandomPlayerEngine(PlayerEngine):
|
|
def get_move(board):
|
|
|
|
# [...]
|
|
```
|
|
|
|
Quatre moteur "joueurs" sont implémentés :
|
|
|
|
* `Human` pour gérer des joueurs humain, une saisir utilisateur est demandée
|
|
sous la forme `<pos_x><pos_y>`. Il est aussi possible d'afficher le plateau
|
|
avec la commande `print` ou les coups possibles avec `help`;
|
|
* `Ramdom` va choisir aléatoirement le coup à jouer en fonction des coups;
|
|
possibles;
|
|
* `Minmax` utilise *MinMax* pour déterminer le coup à jouer avec une profondeur
|
|
maximale définie;
|
|
* `AphaBeta` utilise *AlphaBeta* pour déterminer le coup à jouer avec une
|
|
profondeur maximale définie;
|
|
* `IterativeDeepeningMinmax` utilise Minmax avec un temps maximum autorisé
|
|
|
|
Le choix de ces moteur se fait en ligne de commande avec
|
|
|
|
### Classes HeuristicsEngine
|
|
|
|
Plusieurs classes impémentent plusieurs méthodes pour le calcul de
|
|
l'heuristique. Comme nous l'avons vu, les moteurs peuvent être choisis en ligne
|
|
de commande et de façon indépendante pour les joueurs blanc et noir.
|
|
|
|
Trois implementation sond disponibles:
|
|
|
|
1. `ScoreHeuristicEngine`: l'heuristique se sert du score (comptage des pièces
|
|
sur le tableau) via la méthode `Board.heuristique`;
|
|
2. `WeightHeuristicEngine`: ici on se sert de la place des pièces sur le
|
|
tableau. Chaque emplacement vaut un nombre de points;
|
|
3. `FullHeuristicEngine`: c'est la somme de `Board.heuristique()` et du calcul
|
|
des poids.
|
|
|
|
#### Retour sur le calcul des poids.
|
|
|
|
Afin de définir le poids, je me suis servi de la page *Stratégie et bases de
|
|
Reversi* sur le site Cool Math Games ([lien][reversi]). Voici les poids par
|
|
ordre d'importance :
|
|
|
|
1. Les coins représentent les parties les plus importantes;
|
|
2. Ensuite vient les bords;
|
|
3. Et enfin les coins.
|
|
|
|
Les poids affectés sont personnalisable via l'options `--weight`, par défaut
|
|
nous avons 2, 10 et 25.
|
|
|
|
[reversi]:https://www.coolmathgames.com/blog/how-to-play-reversi-basics-and-best-strategies
|