nelet/DEV_IA-Learning
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

coucou

Browse Source
This commit is contained in:
Jean-Luc NELET 2024-10-23 19:06:31 +02:00
parent 8a9bb79119
commit 5e54410555
1 changed files with 251 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

498
app.py
View File

@ -1,247 +1,251 @@
import heapq import heapq
import csv import csv
from datetime import datetime from datetime import datetime
# Exercice 1 : Affichage de l'état du jeu # Exercice 1 : Affichage de l'état du jeu
def afficher_etat(etat_jeu): def afficher_etat(etat_jeu):
print("État actuel du jeu :") print("État actuel du jeu :")
for i, tas in enumerate(etat_jeu): for i, tas in enumerate(etat_jeu):
print(f"Tas {i+1}: {tas} objets") print(f"Tas {i+1}: {tas} objets")
print() print()
# Exercice 2 : Génération des mouvements légaux avec un maximum de 3 objets retirés # Exercice 2 : Génération des mouvements légaux avec un maximum de 3 objets retirés
def generer_mouvements(etat_jeu): def generer_mouvements(etat_jeu):
mouvements = [] mouvements = []
for i, tas in enumerate(etat_jeu): for i, tas in enumerate(etat_jeu):
# Limiter à un maximum de 3 objets retirés # Limiter à un maximum de 3 objets retirés
for j in range(1, min(4, tas + 1)): # max 3 objets peuvent être retirés for j in range(1, min(4, tas + 1)): # max 3 objets peuvent être retirés
nouvel_etat = etat_jeu.copy() nouvel_etat = etat_jeu.copy()
nouvel_etat[i] -= j nouvel_etat[i] -= j
mouvements.append(nouvel_etat) mouvements.append(nouvel_etat)
return mouvements return mouvements
# Exercice 3 : Appliquer un mouvement # Exercice 3 : Appliquer un mouvement
def appliquer_mouvement(etat_jeu, tas_index, nb_objets): def appliquer_mouvement(etat_jeu, tas_index, nb_objets):
if 0 <= tas_index < len(etat_jeu) and 1 <= nb_objets <= etat_jeu[tas_index] and nb_objets <= 3: if 0 <= tas_index < len(etat_jeu) and 1 <= nb_objets <= etat_jeu[tas_index] and nb_objets <= 3:
nouvel_etat = etat_jeu.copy() nouvel_etat = etat_jeu.copy()
nouvel_etat[tas_index] -= nb_objets nouvel_etat[tas_index] -= nb_objets
return nouvel_etat return nouvel_etat
else: else:
print("Mouvement invalide") print("Mouvement invalide")
return None return None
# Exercice 4 : Fonction heuristique # Exercice 4 : Fonction heuristique
def heuristique(etat_jeu): def heuristique(etat_jeu):
return sum(etat_jeu) return sum(etat_jeu)
# Exercice 5 : Définir l'état final et le coût # Exercice 5 : Définir l'état final et le coût
def est_etat_final(etat_jeu): def est_etat_final(etat_jeu):
return all(tas == 0 for tas in etat_jeu) return all(tas == 0 for tas in etat_jeu)
def cout_mouvement(etat_precedent, etat_suivant): def cout_mouvement(etat_precedent, etat_suivant):
return 1 # Chaque mouvement a un coût de 1 return 1 # Chaque mouvement a un coût de 1
# Exercice 6 : Classe Noeud et algorithme A* # Exercice 6 : Classe Noeud et algorithme A*
class Noeud: class Noeud:
def __init__(self, etat, parent=None, g=0, h=0): def __init__(self, etat, parent=None, g=0, h=0):
self.etat = etat self.etat = etat
self.parent = parent self.parent = parent
self.g = g # Coût du chemin depuis le départ self.g = g # Coût du chemin depuis le départ
self.h = h # Heuristique self.h = h # Heuristique
self.f = g + h # Coût total (g + h) self.f = g + h # Coût total (g + h)
def __lt__(self, autre): def __lt__(self, autre):
return self.f < autre.f return self.f < autre.f
def algorithme_a_star(etat_initial): def algorithme_a_star(etat_initial):
file_priorite = [] file_priorite = []
etat_initial_heuristique = heuristique(etat_initial) etat_initial_heuristique = heuristique(etat_initial)
noeud_initial = Noeud(etat_initial, g=0, h=etat_initial_heuristique) noeud_initial = Noeud(etat_initial, g=0, h=etat_initial_heuristique)
heapq.heappush(file_priorite, noeud_initial) heapq.heappush(file_priorite, noeud_initial)
visites = set() visites = set()
while file_priorite: while file_priorite:
noeud_courant = heapq.heappop(file_priorite) noeud_courant = heapq.heappop(file_priorite)
if est_etat_final(noeud_courant.etat): if est_etat_final(noeud_courant.etat):
return reconstruire_chemin(noeud_courant) return reconstruire_chemin(noeud_courant)
visites.add(tuple(noeud_courant.etat)) visites.add(tuple(noeud_courant.etat))
for successeur in generer_mouvements(noeud_courant.etat): for successeur in generer_mouvements(noeud_courant.etat):
if tuple(successeur) in visites: if tuple(successeur) in visites:
continue continue
g_successeur = noeud_courant.g + cout_mouvement(noeud_courant.etat, successeur) g_successeur = noeud_courant.g + cout_mouvement(noeud_courant.etat, successeur)
h_successeur = heuristique(successeur) h_successeur = heuristique(successeur)
noeud_successeur = Noeud(successeur, parent=noeud_courant, g=g_successeur, h=h_successeur) noeud_successeur = Noeud(successeur, parent=noeud_courant, g=g_successeur, h=h_successeur)
heapq.heappush(file_priorite, noeud_successeur) heapq.heappush(file_priorite, noeud_successeur)
return None # Aucun chemin trouvé return None # Aucun chemin trouvé
# Exercice 8 : Reconstruction du chemin # Exercice 8 : Reconstruction du chemin
def reconstruire_chemin(noeud_final): def reconstruire_chemin(noeud_final):
chemin = [] chemin = []
noeud_courant = noeud_final noeud_courant = noeud_final
while noeud_courant: while noeud_courant:
chemin.append(noeud_courant.etat) chemin.append(noeud_courant.etat)
noeud_courant = noeud_courant.parent noeud_courant = noeud_courant.parent
return chemin[::-1] return chemin[::-1]
# Fonction pour calculer le XOR de tous les tas # Fonction pour calculer le XOR de tous les tas
def calculer_xor(etat_jeu): def calculer_xor(etat_jeu):
xor_total = 0 xor_total = 0
for tas in etat_jeu: for tas in etat_jeu:
xor_total ^= tas xor_total ^= tas
return xor_total return xor_total
# Stratégie gagnante pour l'IA # Stratégie gagnante pour l'IA (corrigée)
def strategie_gagnante(etat_jeu): def strategie_gagnante(etat_jeu):
xor_total = calculer_xor(etat_jeu) xor_total = calculer_xor(etat_jeu)
if xor_total == 0: if xor_total == 0:
# Pas de stratégie gagnante, faire un mouvement quelconque # Pas de stratégie gagnante, faire un mouvement quelconque
for i, tas in enumerate(etat_jeu): for i, tas in enumerate(etat_jeu):
if tas > 0: if tas > 0:
return appliquer_mouvement(etat_jeu, i, min(3, tas)), i + 1, min(3, tas) # Retire le maximum autorisé return appliquer_mouvement(etat_jeu, i, min(3, tas)), i + 1, min(3, tas) # Retire le maximum autorisé
else: else:
# Stratégie gagnante : trouver le tas à modifier # Stratégie gagnante : trouver le tas à modifier
for i, tas in enumerate(etat_jeu): for i, tas in enumerate(etat_jeu):
target = tas ^ xor_total # Calculer ce qu'il reste si on change ce tas pour atteindre un XOR de 0
if target < tas: target = tas ^ xor_total
return appliquer_mouvement(etat_jeu, i, tas - target), i + 1, tas - target if target < tas:
nb_a_retirer = tas - target
return None, None, None # Aucun mouvement possible if nb_a_retirer > 0 and nb_a_retirer <= 3: # Vérifier qu'on retire entre 1 et 3 objets
return appliquer_mouvement(etat_jeu, i, nb_a_retirer), i + 1, nb_a_retirer
# Fonction pour sauvegarder l'historique dans un fichier CSV, format sur une seule ligne
def sauvegarder_historique(date_partie, vainqueur, historique, fichier="historique_parties.csv"): # Si aucun mouvement n'est possible (ce qui ne devrait jamais arriver), renvoyer None
# Construire la séquence des coups return None, None, None
coups = []
for tas, nb_objets, joueur in historique: # Fonction pour sauvegarder l'historique dans un fichier CSV, format sur une seule ligne
coups.append(f"{joueur}({tas},{nb_objets})") def sauvegarder_historique(date_partie, vainqueur, historique, fichier="historique_parties.csv"):
# Construire la séquence des coups
with open(fichier, mode='a', newline='') as file: coups = []
writer = csv.writer(file) for tas, nb_objets, joueur in historique:
# Une seule ligne avec la date, le vainqueur et tous les coups coups.append(f"{joueur}({tas},{nb_objets})")
writer.writerow([date_partie, vainqueur] + coups)
with open(fichier, mode='a', newline='') as file:
# Exercice 9 : Interface utilisateur et IA writer = csv.writer(file)
def jouer_nim(): # Une seule ligne avec la date, le vainqueur et tous les coups
# Initialiser l'état du jeu writer.writerow([date_partie, vainqueur] + coups)
etat_jeu = [3, 4, 5]
historique = [] # Historique des coups (tas, nb_objets, joueur) # Exercice 9 : Interface utilisateur et IA
def jouer_nim():
while True: # Initialiser l'état du jeu
# Afficher l'état actuel du jeu etat_jeu = [3, 4, 5]
afficher_etat(etat_jeu) historique = [] # Historique des coups (tas, nb_objets, joueur)
# Vérifier si l'état actuel est une victoire while True:
if est_etat_final(etat_jeu): # Afficher l'état actuel du jeu
print("Le jeu est terminé !") afficher_etat(etat_jeu)
break
# Vérifier si l'état actuel est une victoire
# Tour de l'utilisateur if est_etat_final(etat_jeu):
print("C'est à votre tour !") print("Le jeu est terminé !")
tas_index = int(input("Choisissez le tas (1, 2, 3) : ")) - 1 break
nb_objets = int(input(f"Combien d'objets retirer du tas {tas_index + 1} (max 3) ? "))
# Tour de l'utilisateur
nouvel_etat = appliquer_mouvement(etat_jeu, tas_index, nb_objets) print("C'est à votre tour !")
if nouvel_etat: tas_index = int(input("Choisissez le tas (1, 2, 3) : ")) - 1
historique.append((tas_index + 1, nb_objets, "Joueur")) nb_objets = int(input(f"Combien d'objets retirer du tas {tas_index + 1} (max 3) ? "))
etat_jeu = nouvel_etat
else: nouvel_etat = appliquer_mouvement(etat_jeu, tas_index, nb_objets)
continue # Demande de nouveau si le mouvement est invalide if nouvel_etat:
historique.append((tas_index + 1, nb_objets, "Joueur"))
# Vérifier si l'état actuel est une victoire etat_jeu = nouvel_etat
if est_etat_final(etat_jeu): else:
afficher_etat(etat_jeu) continue # Demande de nouveau si le mouvement est invalide
print("Vous avez gagné !")
date_partie = datetime.now().strftime("%Y-%m-%d %H:%M:%S") # Vérifier si l'état actuel est une victoire
sauvegarder_historique(date_partie, "Joueur", historique) if est_etat_final(etat_jeu):
break afficher_etat(etat_jeu)
print("Vous avez gagné !")
# Tour de l'IA avec la stratégie gagnante date_partie = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
print("C'est au tour de l'IA...") sauvegarder_historique(date_partie, "Joueur", historique)
nouvel_etat, tas_ia, nb_objets_ia = strategie_gagnante(etat_jeu) break
# Gérer les mouvements invalides pour l'IA # Tour de l'IA avec la stratégie gagnante
if nouvel_etat is None: print("C'est au tour de l'IA...")
print("IA n'a pas trouvé de mouvement valide.") nouvel_etat, tas_ia, nb_objets_ia = strategie_gagnante(etat_jeu)
continue
# Gérer les mouvements invalides pour l'IA
historique.append((tas_ia, nb_objets_ia, "IA")) if nouvel_etat is None:
etat_jeu = nouvel_etat print("IA n'a pas trouvé de mouvement valide.")
continue
# Vérifier si l'IA a gagné
if est_etat_final(etat_jeu): historique.append((tas_ia, nb_objets_ia, "IA"))
afficher_etat(etat_jeu) etat_jeu = nouvel_etat
print("L'IA a gagné !")
date_partie = datetime.now().strftime("%Y-%m-%d %H:%M:%S") # Vérifier si l'IA a gagné
sauvegarder_historique(date_partie, "IA", historique) if est_etat_final(etat_jeu):
break afficher_etat(etat_jeu)
print("L'IA a gagné !")
# Lancer le jeu date_partie = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
jouer_nim() sauvegarder_historique(date_partie, "IA", historique)
break
import unittest # Lancer le jeu
jouer_nim()
class TestJeuNim(unittest.TestCase):
# Test pour l'affichage de l'état du jeu (Exercice 1) import unittest
def test_afficher_etat(self):
etat_jeu = [3, 4, 5] class TestJeuNim(unittest.TestCase):
# Ici on ne peut pas tester directement la sortie console, mais on peut vérifier si la fonction retourne les bons tas
self.assertEqual(afficher_etat(etat_jeu), None) # Il n'y a pas de retour attendu, juste un affichage # Test pour l'affichage de l'état du jeu (Exercice 1)
def test_afficher_etat(self):
# Test pour la génération des mouvements légaux (Exercice 2) etat_jeu = [3, 4, 5]
def test_generer_mouvements(self): # Ici on ne peut pas tester directement la sortie console, mais on peut vérifier si la fonction retourne les bons tas
etat_jeu = [1, 2] self.assertEqual(afficher_etat(etat_jeu), None) # Il n'y a pas de retour attendu, juste un affichage
mouvements_attendus = [[0, 2], [1, 1], [1, 0]] # Il y a 3 mouvements possibles
self.assertEqual(generer_mouvements(etat_jeu), mouvements_attendus) # Test pour la génération des mouvements légaux (Exercice 2)
def test_generer_mouvements(self):
# Test pour appliquer un mouvement valide (Exercice 3) etat_jeu = [1, 2]
def test_appliquer_mouvement_valide(self): mouvements_attendus = [[0, 2], [1, 1], [1, 0]] # Il y a 3 mouvements possibles
etat_jeu = [3, 4, 5] self.assertEqual(generer_mouvements(etat_jeu), mouvements_attendus)
nouvel_etat = appliquer_mouvement(etat_jeu, 1, 3)
self.assertEqual(nouvel_etat, [3, 1, 5]) # Test pour appliquer un mouvement valide (Exercice 3)
def test_appliquer_mouvement_valide(self):
# Test pour appliquer un mouvement invalide (Exercice 3) etat_jeu = [3, 4, 5]
def test_appliquer_mouvement_invalide(self): nouvel_etat = appliquer_mouvement(etat_jeu, 1, 3)
etat_jeu = [3, 4, 5] self.assertEqual(nouvel_etat, [3, 1, 5])
nouvel_etat = appliquer_mouvement(etat_jeu, 1, 5) # Trop d'objets retirés
self.assertIsNone(nouvel_etat) # Test pour appliquer un mouvement invalide (Exercice 3)
def test_appliquer_mouvement_invalide(self):
# Test pour l'heuristique (Exercice 4) etat_jeu = [3, 4, 5]
def test_heuristique(self): nouvel_etat = appliquer_mouvement(etat_jeu, 1, 5) # Trop d'objets retirés
etat_jeu = [3, 4, 5] self.assertIsNone(nouvel_etat)
self.assertEqual(heuristique(etat_jeu), 12)
# Test pour l'heuristique (Exercice 4)
# Test pour la vérification de l'état final (Exercice 5) def test_heuristique(self):
def test_est_etat_final(self): etat_jeu = [3, 4, 5]
self.assertTrue(est_etat_final([0, 0, 0])) self.assertEqual(heuristique(etat_jeu), 12)
self.assertFalse(est_etat_final([0, 1, 0]))
# Test pour la vérification de l'état final (Exercice 5)
# Test pour le coût des mouvements (Exercice 5) def test_est_etat_final(self):
def test_cout_mouvement(self): self.assertTrue(est_etat_final([0, 0, 0]))
self.assertEqual(cout_mouvement([3, 4, 5], [3, 4, 4]), 1) self.assertFalse(est_etat_final([0, 1, 0]))
# Test pour l'algorithme A* (Exercice 6) avec validation de l'état final seulement # Test pour le coût des mouvements (Exercice 5)
def test_algorithme_a_star(self): def test_cout_mouvement(self):
etat_initial = [1, 2] self.assertEqual(cout_mouvement([3, 4, 5], [3, 4, 4]), 1)
chemin_trouve = algorithme_a_star(etat_initial)
etat_final_attendu = [0, 0] # Test pour l'algorithme A* (Exercice 6) avec validation de l'état final seulement
# Vérifier que le chemin atteint bien l'état final attendu def test_algorithme_a_star(self):
self.assertEqual(chemin_trouve[-1], etat_final_attendu) etat_initial = [1, 2]
chemin_trouve = algorithme_a_star(etat_initial)
# Test pour la reconstruction du chemin (Exercice 8) etat_final_attendu = [0, 0]
def test_reconstruire_chemin(self): # Vérifier que le chemin atteint bien l'état final attendu
etat_initial = [3, 4, 5] self.assertEqual(chemin_trouve[-1], etat_final_attendu)
noeud_initial = Noeud(etat_initial)
noeud_final = Noeud([0, 0, 0], parent=noeud_initial) # Test pour la reconstruction du chemin (Exercice 8)
chemin_attendu = [[3, 4, 5], [0, 0, 0]] def test_reconstruire_chemin(self):
self.assertEqual(reconstruire_chemin(noeud_final), chemin_attendu) etat_initial = [3, 4, 5]
noeud_initial = Noeud(etat_initial)
if __name__ == '__main__': noeud_final = Noeud([0, 0, 0], parent=noeud_initial)
unittest.main() chemin_attendu = [[3, 4, 5], [0, 0, 0]]
self.assertEqual(reconstruire_chemin(noeud_final), chemin_attendu)
if __name__ == '__main__':
unittest.main()