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 : ### Moteur de jeu Il est possible de définir le moteur de jeu indépedamment pour chaque joueur et ainsi faire des match: * `-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 Le moteur de jeux par défaut est random. ### Profondeur d'exploration Il est aussi possible de définir la profindeur d'exploration de l'arbre de jeu pour chacun des joueurs: * `-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* La profondeur par défaut est 3. ### Heuristique Il est possible de choisir entre les 3 moteur de calcul d'heuristique inclus à savoir *score*, avec *poids*, ou une combinaison *des deux*. Ils ne sont utilisés que pour les moteur de jeu avec exploration de l'arbre de jeu (minmax, alphabeta et leurs pendants avec *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`) Pour l'utilisation des poids, il est possible de les paramétrer : * `--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 AlphabetaPlayerEngine(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 ``. 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. Une étude autour de l'heuristique de l'Othello menée par Vaishnavi Sannidhanam et Muthukaruppan Annamalai de l'université de Washingtown propose d'autre piste pour maéliorer l'heuristique. [télécharger le pdf][etude] 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 [etude]:https://courses.cs.washington.edu/courses/cse573/04au/Project/mini1/RUSSIA/Final_Paper.pdf