BUT3-IA-Jeux-PUBLIC/README.md

# 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 acvec 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 optimisaiton.
* 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 à minuit).
Le document doit être en md ou pdf sur votre git et se nommer RapportNim.md ou RapportNim.pdf

Le rapport diot rappeller 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 raopport 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 mesur objective d'une méthode.