162 lines
6.1 KiB
Markdown
162 lines
6.1 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`. Utilisé aussi pour définit la profondeur de départ pour
|
|
l'*iterative deepening*
|
|
* `-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`Utilisé aussi pour définit la profondeur de départ pour
|
|
l'*iterative deepening*
|
|
* `-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. Il,e st ainsi plus aisé de tester le
|
|
fonctionnement des différents moteurs.
|
|
|
|
### 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;
|
|
* `MinmaxDeepeningMinmax` utilise Minmax avec un temps maximum autorisé;
|
|
* `AlphaBetaDeepening` utilise AlphaBeta avec un temps maximum autorisé
|
|
|
|
Le choix de ces moteur se fait en ligne de commande avec les options évoquées
|
|
plus haut.
|
|
|
|
### Classes HeuristicsEngine
|
|
|
|
Plusieurs classes impémentent plusieurs méthodes pour le calcul de
|
|
l'heuristique. Toutes les implémentations se trouvent dans le fichier
|
|
`./src/classes/Heuristic.py` 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 le centre.
|
|
|
|
Cependant certaines parties du plateau de jeu sont à éviter :
|
|
|
|
* Les cases autour des coins, car elle laisserai la possibilité au joueur
|
|
adverse de placer un de ses pions dans le coin. La case en diagonale du coin
|
|
est particulièrement sensible.
|
|
* Les lignes juste avant les bords, placer un pion à cet endroit permettrai à
|
|
l'adversaire de placer un pion sur le bord. Ce ion sera alors p[lus
|
|
difficilement *"capturable"*
|
|
|
|
Les poids affectés sont personnalisable via l'options `--weight`, par défaut
|
|
nous avons -5, 2, 10 et 25.
|
|
|
|
Voici le tableau des poinds par défaut, il peut être affiché avec l'option
|
|
`--show-weights-table`:
|
|
|
|
```text
|
|
./game.py --show-weights-table
|
|
Starting PyReverso...
|
|
|
|
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |
|
|
--------------------------------------------
|
|
0 |25 |-5 |10 | 8 | 8 | 8 | 8 |10 |-5 |25 |
|
|
1 |-5 |-7 |-3 |-3 |-3 |-3 |-3 |-3 |-7 |-5 |
|
|
2 |10 |-3 | 0 | 0 | 0 | 0 | 0 | 0 |-3 |10 |
|
|
3 | 8 |-3 | 0 | 2 | 2 | 2 | 2 | 0 |-3 | 8 |
|
|
4 | 8 |-3 | 0 | 2 | 2 | 2 | 2 | 0 |-3 | 8 |
|
|
5 | 8 |-3 | 0 | 2 | 2 | 2 | 2 | 0 |-3 | 8 |
|
|
6 | 8 |-3 | 0 | 2 | 2 | 2 | 2 | 0 |-3 | 8 |
|
|
7 |10 |-3 | 0 | 0 | 0 | 0 | 0 | 0 |-3 |10 |
|
|
8 |-5 |-7 |-3 |-3 |-3 |-3 |-3 |-3 |-7 |-5 |
|
|
9 |25 |-5 |10 | 8 | 8 | 8 | 8 |10 |-5 |25 |
|
|
```
|
|
|
|
|
|
### À savoir:
|
|
|
|
Les pois utilisé pour les heuristiques sont important.
|
|
|
|
[reversi]:https://www.coolmathgames.com/blog/how-to-play-reversi-basics-and-best-strategies
|