BUT3-IA-Jeux-PUBLIC

Dépôt pour ressource cours IA sur les jeux de BUT3. Formellement MATH 5.1 et DEV 5.5

évaluation. MATH 5.1 examen sur table 100% DEV 5.5 TPs filés et éventuel mini projet final. soutenance probable. note différenciée par groupe possible

Des ressources de l'an dernier sont disponibles dans le répertoire 2023-24.

Notes de cours.

Premier cours (5/9/2024)

Au tableau. Réflexion sur la nature d'un jeu. Classification de divers jeux. Focus sur les jeux à 2 joueurs, tour par tour, à information complète, et déterministe. Stratégie gagnante, états, graphe des états, arbre de jeu.

Illustration de méthodes possibles en math débranché avec un cahier (exemple illustratif du jeu de Nim).

Méthode explorant l'arbre de jeu : Minimax, pseudo code avec deux méthodes exploremax et exploremin pour le jeu de Nim.

Exo à faire : reprendre le pseudo code pour permettre de choisir un coup optimal pour la position donnée en paramètre tout au début.

Second cours (en salle TP, le 12/9/2024)

Première chose à faire : implantation de ExploreMax et ExploreMin pour le jeu de Nim. (temps estimé 15 minutes à 60 minutes)

Règles du jeux :

• Tout doit être sur un repo git mis à jour régulièrement dont le nom est exactement BUT3Jeu partagé avec moi.
• utiliser un langage objet (à terme il s'agira de refactoriser le code pour permettre de traiter d'autres jeux)
• Méthode prend en entrée le nombre d'allumettes. En sortie -1 (perdu), 0 (match nul) ou +1 pour victoire.
• extension possible choix du premier coup optimal.

Il convient de tester de manière extensive avec des exemples qu'on connaît. Les tests ne sont pas forcément des tests unitaires rejouables mais il faut garder une trace.

Seconde chose à faire. Une fonction qui joue le même rôle que la fonction du premier point ci-dessus mais qui met en oeuvre "la méthode du cahier", i.e. l'approche qui stocke les états en mettant à jour si ils sont gagnants ou perdants. (temps estimé : 30 minutes à 120 minutes).

Troisième chose à faire.

• Reprendre le code pour le clarifier si nécessaire.
• Le documenter (javadoc si java).
• Ajout d'un readme expliquant le rôle de chaque fichier.

Troisième cours (en salle TP, le 17/9/2024)

On revisite notre algorithme pour minimax pour le jeu de Nim pour l'optimiser.

améliorer Minimax un peu

• idée 0 : dans la boucle dans exploremax, si je trouve un coup après lequel je gagne (exploremin m'indique que je gagne) alors ce n'est pas la peine de chercher un autre coup gagnant, je peux arrêter de chercher.
• idée 0bis : même chose pour une défaite dans exploremin.

Indication. changez votre code pour fabriquer une version optimisée tenant compte de cette idée.

Comparaison avec la version précédente. changez votre code pour compter le nombre d'état du jeu visité (il faut un compteur qui s'incrémente de 1 à chaque appel de exploremax ou exploremin).

• idée 1 : il peut arriver qu'on descende récursivement dans l'arbre de jeu, alors que au coup suivant je peux gagner.

Indication. changez votre code pour fabriquer une version optimisée qui commence par tester si je peux gagner tout de suite au prochain coup. Si je peux, ceci évite de descendre dans l'arbre. Si je ne peux pas, je descends dans l'arbre.

• idée 2 : on se rend compte que l'ordre des coups à une influence importante. On pourrait énumérer les coups dans un ordre différent (par exemple au hasard) et étudier si ceci peut avoir un impact.

Indication. changez votre code pour permettre que la boucle qui teste les coups le fasse dans un ordre aléatoire. Testez si ceci améliore l'efficacité du code.

compter les noeuds visités de l'arbre de jeu

Il faut absolument pour pouvoir faire votre travail correctement, compter le nombre de noeuds visités.

Ajouter une variable globale, ou passez un paramètre permettant de compter le nombre de noeuds visités. Il faut grosso modo incrémenter ce compteur quand vous faites un appel de exploreMax (de même pour exploreMin).

affichage pour Minimax

Vous êtes nombreux à avoir du mal à réconcilier le résultat de votre algorithme avec vos calculs éventuels sur papier. Il est judicieux de se bricoler un petit affichage d'arbre de jeu pour débuger.

Indication.

• Passez en paramètre de exploreMax et exploreMin un entier profondeur (initialement 0).
• codez une méthode prettyPrint(int profondeur, int etat, int eval) qui va afficher profondeur espaces puis le nombre d'allumettes (état) puis l'évaluation (-1 ou +1).
• insérer l'appel prettyPrint juste avant de faire un return dans exploreMax ou exploreMin

Améliorer MiniMax beaucoup

Nous avons entrevue l'idée de alpha beta (voir transparents cours an dernier).

• Implémentez cette optimisation.
• Comptez le nombre de noeuds visités.
• Comparez avec la version Minimax sans cette optimisation.

compte Rendu expérience.

N'oubliez pas d'alimenter votre journal de bord sur git. Il faut écrire où vous en êtes, ce que vous avez fait etc.

rapport Jeu de Nim

Je vais évaluer un premier rapport d'avancement sur le jeu de Nim (deadline vendredi 20/09/2024 dimanche 22/09/2024 à minuit). Le document doit être en md ou pdf sur votre git et se nommer RapportNim.md ou RapportNim.pdf

Le rapport doit rappeler en première page le nom des membres du groupe.

Ce rapport doit décrire le code fait jusqu'à présent (ce qui est fait, pas fait, dans quel fichier) et ce qui fonctionne (ou partiellement ou pas). J'appelle méthode ci-après chaque avatar de la méthode permettant de résoudre le jeu de Nim que vous avez codé. NB. ajouter une optimisation à une méthode existante est considéré comme une nouvelle méthode.

Ce rapport doit mettre en forme de manière synthétique votre compte rendu d'expérience avec des valeurs comparant les différentes méthodes implantées. Typiquement il me faut un tableau ou un graphique avec le nombre de noeuds visités pour chaque méthode implantée. Vous devez a minima m'indiquer les résultats pour le nombre d'allumettes initiales suivantes : 5, 11, 17, 42 et 100.

Vous pouvez tout à fait décrire les éléments additionnels comme des temps de calcul ou autre mesure objective d'une méthode.

Quatrième cours (en salle TP, le 18/9/2024)

Nous avons une première base de code pour fabriquer un bot qui trouvera une stratégie gagnante si elle existe pour le jeu de Nim.

On souhaite pouvoir faire évoluer ce code pour permettre d'en réutiliser un maximum pour d'autres jeux pas trop compliqués à coder (le but étant de travailler sur le bot plutôt que sur les règles du jeux).

Les autres jeux candidats.

• tic tac toe
• puissance 4
• morpion

Si vous avez des jeux dont les règles sont potentiellement simples à coder et qui sont comme ceux ci-dessus (tour par tour, à 2 joueurs, déterministe et à information complète) alors n'hésitez pas.

Diagramme de classe (45 minutes environ).

Proposez un diagramme de classe le plus abstrait possible pour permettre de coder n'importe quel jeu ci-dessus (on codera seulement Nim dans l'immédiat).

Proposez un squelette de code avec pour chaque méthode une documentation javadoc.

Pensez à faire plusieurs itération et à vérifier que votre code Minimax peut utiliser ces méthodes.

NB. staruml permet de générer du code à partir d'un diagramme de classe. L'inverse est également possible.

Indications. Pour ceux qui ont du mal à démarrer, il faut lire votre code de minimax pour le jeu de Nim, et réfléchir à des fonctionalités que vous souhaiter avoir de la paret du jeu. Par exemple, la partie est terminée, si c'est terminé, quel est le résultat de la partie etc. Commencez par lister ce qui va devenir une méthode en décrivant par une ligne en français chaque fonctionalité. Ensuite réfléchissez à ce dont vous avez besoin comme données en entrée et en sortie. Finalement cherchez à organiser les entrées et sorties en ajoutant des types adaptés (des classes).

Comparaison forces faiblesses par paire de groupes (25 minutes environ)

Présentez vos design respectifs à l'autre groupe.

Tâchez de converger vers une version unique améliorée et consensuelle.

Nominez un porte parole par groupe qui présentera cette version

Retour collectif sur les différents diagrammes de classe (40 minutes environ).

Chaque porte parole présente la version de sa paire de groupes.

Le travail est mis en commun collectivement pour aboutir à une seule version.

Implantation Jeu de Nim selon ce diagramme.

Y'a plus qu'à.

Cinquième cours (en salle TP, le 9/10/2024)

Objectif concret

À terme on souhaitre comparer différents algorithmes génériques sur des jeux différents.

On va pour ceci utiliser (quitte à la faire évoluer légèrement en cas de besoin) l'API pour les jeux fixée lors du dernier cours.

NB. Matthis a la main sur le repo officiel de l'API. https://grond.iut-fbleau.fr/fauvet/API_BUT5.5

Objectif méthodologique

Mettre en oeuvre de manière informelle des méthodes de travail en équipe.

• scrum board physique
• description agile de tâches
• code review

Nous sommes en méthode agile mais attention à bien documenter même briévement ce que vous avez fait.?

à faire.

1. Chaque groupe (30 à 45 minutes). Reprendre votre code pour implanter le jeu de Nim en accord avec l'API.
2. Code review interne puis avec un autre groupe
3. ajustement éventuel de l'API (vous devez vous organiser collectivement)
4. Coder des jeux plus ambitieux que le jeu de Nim. Il faudra mettre en oeuvre 3 groupes de 5 ou 6. Chaque groupe codera un jeu (objectif, le jeu implanté de manière compatible à l'API pour midi).
   • Puissance 4 (en fait paramétrable, en taille et en nombre d'alignement 3 ou 4).
   • TicTacToe puis plus généralement le Gomoku (grille grande, alignement de 5 pions) voir ici (bref jeu paramétrable également, en taille edt en nombre d'alignement)
   • Reversi (paramétrable, taille de la grille).

Les trois groupes sont les suivants

1. Die Ratten

   • Hugo BRANCO-GOMES
   • Yanis DARIUS
   • Tom MOGULJAK
   • Jean-Luc NELET
   • Axel PIETROIS
   • Simon SAYE BABU
   • Côme THURET

2. Les e-Nathantifs

   • Lucas BERGER
   • Nathan BOUZON
   • Gaël DANIEL
   • Dylan LANDRIN
   • Emmanuella Nadou LAWSON-LARTEGO
   • Léo ROCHER
   • Killian SCHIED

3. The others

   • Taha ABDELMOHCINE
   • Hugo DIMITRIJEVIC
   • Matthis FAUVET
   • Florian GÉNIQUE
   • Florian SAMY
   • Guillaume VALLAT

à faire vraiment maintenant tout de suite et individuellement.

1. créer un git individuel BUT39Octobre
2. ajouter les sources de l'API dans un répertoire adapté sur ce git
3. ajouter un répertoire pour un paquet NimJeu qui contiendra des classes implémentant les deux interfaces de cette API
   • Une classe NimPly qui implémente Ply
   • Une classe PlateauNim qui implémente Plateau
   • Un main qui va instancier ces deux classes et jouer quelques coups du jeu de Nim à 5 allumettes Joueur 1 enlève 2 allumettes, Joueur 2 enlève 1 allumette, Joueur 1 enlève 1 allumette, Joueur 2 enlève 1 allumette et gagne.

Sixième cours (en CM puis en salle TP, le 15/10/2024)

• discussion au tableau d'évolutions mineures de l'API : Plateau devient une extension de l'interface Situation (cette dernière ne permet pas de faire de doPly undoPly).
• discussion de la nécessité de pouvoir obtenir une information concrète du jeu (un String décrivant le jeu implanté et ces paramètres). Autrement dit : comment faire des choses concrète à travers une couche d'abstraction.
• discussion architecture générale d'un bot : table d'ouverture en début de partie, puis minimax en milieu de partie.
• discussion comment faire en milieu de partie si arbre de jeu trop profond? il faut couper la recherche et utiliser un évaluateur de position
• discussion modélisation évaluateur dans l'API
• proposition de plusieurs évaluateurs abstrraits pour n'importe quel jeux : évaluateur zero, évaluateur Monte Carlo.
• proposition d'évaluateurs concrets pour les jeux à coder.

Suite de la séance en salle TP pour poursuivre le travail.

Septième cours (en CM puis en salle TP, le 21/10/2024)

• préparez des questions sur minimax et alphabeta qui est au programme de l'examen du mardi 22/10/

Programme du cours : discussion jeu multijoueurs et jeux à deux joueurs avec du hasard.

Examen (le 22/10/2024)

Sur papier. Autorisé. une feuille A4 personnelle par étudiant.

Au programme : les jeux, minimax, alphabeta. Aspect multijoueur, jeux avec du hasard.

Fin du projet BUT3Jeu

Malheureusement le planning de l'alternance, mes disponibilités et vos cours à Sénart ne me permettent pas de planifier d'autres cours sur la partie DEV. Il me semble que vous êtes suffisamment bien lancés pour terminer le projet en autonomie.

J'ai placé 3 créneaux en autonomie à l'edt. L'appel ne sera pas fait sur ces créneaux.

Attendus pour le projet.

Dans un git dont il faudra m'envoyer le nom par mail.

Il me faudra un livrable documenté et déployable avec les fonctionnalités suivantes.

• (Must) implantation du jeu selon la dernière version de l'API
• (Must) implantation d'un bot abstrait qui joue aléatoirement à n'importe quel jeu
• (Must) implantation d'un bot abstrait qui joue à n'importe quel jeu avec Minimax en jouant jusqu'au bout (éternellement si nécessaire).
• (Must) implantation d'un bot abstrait qui joue à n'importe quel jeu avec Minimax ou aléatoirement si plus long qu'un timer fixe paramétrable.
• (Should) implantation d'un bot abstrait qui joue à n'importe quel jeu avec Alpha Beta ou aléatoirement si plus long qu'un timer fixe paramétrable.
• (Should) implantation d'un bot abstrait qui joue à n'importe quel jeu avec Alpha Beta en coupant l'arbre de jeu à profondeur fixe et en évaluant une situation non terminée.
• (Must) implantation d'un évaluateur de position abstrait de n'importe quel jeu qui retourne 0 si la partie n'est pas finie.
• (Should) implantation d'un évaluateur de position abstrait de n'importe quel jeu qui utilise Monte Carlo pour évaluer la position.
• (Could) implantation d'un évaluateur de position concret pour au moins le jeu que vous implantez dans votre groupe.
• (Would) implantation d'un tableau d'ouverture pour jouer des bons coups pendant les 3 premiers coups, mélangeant intelligence humaine et résultat de vos expérimentation avec dse bots.
• (Would) implantation d'un bot qui utilise une tablea d'ouverture en début de partie, puis une stratégie avancée en milieu de partie.

Il me faudra également un rapport de 5 à 10 pages qui indique :

• les membres du groupe sur la première page
• une présentation d'une demie page du sujet
• un synopsis rapide de déploiement permettant de jouer contre votre meilleur bot comme joueur 1
• un synopsis rapide de déploiement permettant de jouer contre votre meilleur bot comme joueur 2
• une présentatio de 2 pages sur l'organisation de travail en groupe
• une présentation de 2 pages de ce qui a été fait / pas fait
• un compte rendu d'expérience sur vos bots avec idéalement des explications sur les choix faits en terme de paramétrage, par exemple en faisant affronter différentes variantes de bots et ou en faisant du profiling de votre code.
• une conclusion individuelle de quelques lignes.