Projet 2 : Jeu de morpion

1. Représentation mémoire

Représentation de la Grille en Mémoire

La grille de jeu est représentée par une liste de listes (3 × 3) où chaque élément peut être une chaîne de caractères 'X', 'O' ou '' (espace vide).

Exemple 1Exemple 2

Exemple de grille

Représentation en Python : grille = [['O', ' ', 'X'], ['X', 'O', ' '], [' ', 'X', ' ']]

Exemple de grille

Représentation en Python : grille = [['O', ' ', 'O'], ['O', ' ', ' '], [' ', 'X', 'X']]

Représentation du Joueur en Mémoire

Chaque joueur est représenté par la chaîne de caractères correspondant à son symbole quand c'est à son tour de jouer.

2. Fonctions

Fonction	Description	Paramètres	Retour
afficher_plateau(plateau)	Affiche le plateau de jeu en console en parcourant chaque ligne et chaque case de la ligne, en les affichant séparés par des barres verticales. Après chaque ligne, affiche une ligne de tirets pour séparer visuellement les lignes du plateau.	plateau (liste de listes)	Aucun (affiche le plateau en console)
verifier_victoire(plateau, joueur)	Vérifie si le joueur a gagné en vérifiant les lignes, colonnes et diagonales du plateau pour voir si le joueur a aligné trois symboles identiques. Utilise des boucles pour vérifier chaque ligne, chaque colonne et les deux diagonales.	plateau (liste de listes), joueur (chaîne de caractères 'X' ou 'O')	True si le joueur a gagné, False sinon
verifier_match_nul(plateau)	Vérifie si le match est nul en parcourant chaque case du plateau pour vérifier si toutes les cases sont occupées, c'est-à-dire si elles ne sont pas vides.	plateau (liste de listes)	True si le match est nul, False sinon
jouer_coup(plateau, joueur, position)	Joue un coup sur le plateau si la case est libre. Vérifie si la case à la position spécifiée est libre et place le symbole du joueur dans cette case si elle est libre.	plateau (liste de listes), joueur (chaîne de caractères 'X' ou 'O'), position (tuple (ligne, col))	True si le coup a été joué, False sinon
obtenir_position()	Demande à l'utilisateur d'entrer la ligne et la colonne. Vérifie que les entrées sont des nombres valides et dans les limites du plateau. Si les entrées sont valides, retourne les coordonnées sous forme de tuple. Sinon, affiche un message d'erreur et redemande les coordonnées.	Aucun	position (tuple (ligne, col))
jeu_morpion()	Gère la boucle principale du jeu, alternant entre les joueurs et vérifiant les conditions de victoire et de match nul (voir algorithme général plus bas).	Aucun	Aucun (gère la boucle principale du jeu)

3. Découpage du travail (conseillé)

• Élève 1 : Implémenter les fonctions afficher_plateau et verifier_victoire.
• Élève 2 : Implémenter les fonctions verifier_match_nul et jouer_coup.
• Élève 3 : Implémenter la fonction obtenir_position.
• Groupe entier : Pour la fonction jeu_morpion qui implémente l'algorithme général.

4. Algorithme général

Initialiser le jeu :

1. Initialiser le plateau de jeu : le plateau de jeu est initialisé avec des cases vides.
2. Initialiser le joueur actuel à 'X' : le joueur actuel est défini comme 'X'.
3. Initialiser la variable de fin de jeu : une variable fin_de_jeu est initialisée à False (car le jeu ne fait que commencer).

Boucle principale :

• Tant que le jeu n'est pas fini (donc que la variable de fin de jeu est fausse) :
• Afficher le plateau de jeu.
• Obtenir la position du joueur actuel dans une variable bien nommée.
• Jouer le coup et stocker le résultat dans une variable bien nommée.
• Si le coup est jouable (la fonction renvoie True car la case choisie est libre) alors :
  • Si le joueur actuel a gagné (verifier_victoire est vrai) alors :
  • La variable de fin de jeu devient vraie.
  • On affiche "Joueur X ou O a gagné".
  • Sinon si la partie est nulle (verifier_match_nul est vrai) alors :
  • La variable de fin de jeu devient vraie.
  • On affiche "Match nul".
  • Sinon :
  • Si le joueur actuel est 'X' alors il devient 'O' et si le joueur actuel est 'O' alors il devient 'X'.
• Sinon (si le coup n'est pas jouable) alors afficher un message pour indiquer que la case est occupée et qu'il faut réessayer.

5. Pistes d'Amélioration lorsque votre projet fonctionne

1. Interface Graphique:

   • Utiliser une bibliothèque comme tkinter pour créer une interface graphique.
   • Permettre aux utilisateurs de cliquer sur des boutons pour choisir la table de multiplication et entrer leurs réponses.

2. Mode Multijoueur:

   • Ajouter un mode multijoueur où deux utilisateurs peuvent s'affronter en répondant aux questions de multiplication.
   • Afficher les scores des deux joueurs à la fin.

3. Niveaux de Difficulté:

   • Ajouter différents niveaux de difficulté en ajustant la plage des nombres utilisés dans les questions.
   • Permettre aux utilisateurs de choisir le niveau de difficulté au début du jeu.

4. Suivi des Progrès:

   • Ajouter une fonctionnalité pour suivre les progrès de l'utilisateur au fil du temps.
   • Afficher des statistiques comme le nombre de sans-fautes, le temps moyen par question, etc.

5. Amélioration de l'Interface Utilisateur:

   • Ajouter des messages plus clairs et des instructions pour les utilisateurs.
   • Permettre aux utilisateurs de choisir leurs préférences (comme le nombre de questions par session).

Barème

• Fonctionnalités (8 points)

  • Palier 1 (0~3/8) : Le programme correspond à peu près aux spécifications demandées.
  • Palier 2 (3~5/8) : Le programme correspond aux spécifications demandées.
  • Palier 3 (5~8/8) : Le programme ne présente aucun bug et correspond aux spécifications demandées.
  • Palier 4 (Bonus) : Des fonctionnalités supplémentaires ont été ajoutées (des suggestions sont données sur la fiche de chaque projet).

• Algorithmes et code (6 points)

  • Utilisation pertinente de structures conditionnelles, de boucles, de variables, de fonctions, etc.
  • Utilisation correcte des différents types de valeurs et des fonctions de conversion quand nécessaire.
  • Éviter la répétition de code en faisant des boucles ou en découpant le code en fonctions pertinentes.
  • Il est interdit d'utiliser des instructions non vues en classe sauf exception (à demander au professeur).

• Qualité du code (3 points)

  • Respect des règles de style vues en cours.
  • Utilisation de noms pertinents pour les variables et les fonctions.
  • Documentation pertinente des fonctions grâce à des docstrings.
  • Utilisation pertinente des commentaires.
  • Tests des fonctions implémentées.

• Interface utilisateur (3 points)

  • Bonne organisation visuelle de l'interface.
  • Cohérence de l'interface.
  • Communication d'informations à l'utilisateur efficace et compréhensible.
  • Adaptation à l'utilisateur et gestion des erreurs de saisie.