Пример #1
0
class Partie:
    """
    Classe modélisant une partie du jeu Tic-Tac-Toe utilisant
    un plateau et deux joueurs (deux personnes ou une personne et un ordinateur).

    Attributes:
        plateau (Plateau): Le plateau du jeu contenant les 9 cases.
        joueurs (Joueur list): La liste des deux joueurs (initialement une liste vide).
        joueur_courant (Joueur): Le joueur courant (initialisé à une valeur nulle: None)
        nb_parties_nulles (int): Le nombre de parties nulles (aucun joueur n'a gagné).
    """

    def __init__(self):
        """
        Méthode spéciale initialisant une nouvelle partie du jeu Tic-Tac-Toe.
        """

        self.plateau = Plateau()    # Le plateau du jeu contenant les 9 cases.
        self.joueurs = []       # La liste des deux joueurs (initialement une liste vide).
                                # Au début du jeu, il faut ajouter les deux joueurs à cette liste.
        self.joueur_courant = None  # Le joueur courant (initialisé à une valeur nulle: None)
                                    # Pendant le jeu et à chaque tour d'un joueur,
                                    # il faut affecter à cet attribut ce joueur courant.
        self.nb_parties_nulles = 0  # Le nombre de parties nulles (aucun joueur n'a gagné).


    def jouer(self):
        """
        Permet de démarrer la partie en commençant par l'affichage de ce texte:

        Bienvenue au jeu Tic Tac Toe.
        ---------------Menu---------------
        1- Jouer avec l'ordinateur.
        2- Jouter avec une autre personne.
        0- Quitter.
        -----------------------------------
        Entrez s.v.p. un nombre entre 0 et 2:?

        Cette méthode doit donc utiliser la méthode saisir_nombre().
        Elle doit par la suite demander à l'utilisateur les noms des joueurs.
        Veuillez utiliser 'Colosse' comme nom pour l'ordinateur.
        Il faut créer des instances de la classe Joueur et les ajouter à la liste joueurs.
        Il faut utiliser entre autres ces méthodes:
            *- demander_forme_pion(): pour demander au premier joueur la forme de son pion (X ou O).
              (Pas besoin de demander à l'autre joueur ou à l'ordinateur cela, car on peut le déduire).
            *- plateau.non_plein(): afin d'arrêter le jeu si le plateau est plein (partie nulle).
            *- tour(): afin d'exécuter le tour du joueur courant.
            *- plateau.est_gagnant(): afin de savoir si un joueur a gagné et donc arrêter le jeu.
        Il faut alterner entre le premier joueur et le deuxième joueur à chaque appel de tour()
        en utilisant l'attribut joueur_courant.
        Après la fin de chaque partie, il faut afficher les statistiques sur le jeu.
        Voici un exemple:

        Partie terminée! Le joueur gagnant est: Colosse
        Parties gagnées par Mondher : 2
        Parties gagnées par Colosse : 1
        Parties nulles: 1
        Voulez-vous recommencer (O,N)?

        Il ne faut pas oublier d'initialiser le plateau avant de recommencer le jeu.
        Si l'utilisateur ne veut plus recommencer, il faut afficher ce message:
        ***Merci et au revoir !***
        """
        
        
        print("Bienvenue au jeu Tic Tac Toe.")
        print("---------------Menu---------------")
        print("1- Jouer avec l'ordinateur.")
        print("2- Jouter avec une autre personne.")
        print("0- Quitter.")
        print("-----------------------------------")
        n=self.saisir_nombre(0,2)
        if int(n)==0 :
            print("***Merci et au revoir !***")
            exit(0)
        if (int(n)==1) :
            nomj1=input("Entrer S.V.P. votre nom :? ")
            pionj1=self.demander_forme_pion()
            j1=Joueur(nomj1,'Personne',pionj1)
            if(j1.pion=='X'):
                pionj2='O'
            else:
                pionj2='X'
            j2=Joueur('colosse','Ordinateur',pionj2)
            
        if (int(n)==2):
            nomj1=input("Entrer S.V.P. votre nom :? ")
            pionj1=self.demander_forme_pion()
            j1=Joueur(nomj1,'Personne',pionj1)
            nomj2=input("Entrer S.V.P. le nom de l'autre joueur :? ")
            if(j1.pion=='X'):
                pionj2='O'
            else:
                pionj2='X'
            j2=Joueur(nomj2,'Personne',pionj2)
        self.joueurs.append(j1)
        self.joueurs.append(j2)
        print(self.plateau)

        self.joueur_courant=self.joueurs[0]
        p=self.plateau.non_plein()
        while(p==True):
            self.tour(int(n))
            p = self.plateau.non_plein()

        print('********* partie terminée ***************')
        self.nb_parties_nulles=self.nb_parties_nulles+1
        print("partie terminée ! aucun joueur n'a gagné")
        print("partie gagnée par :", self.joueurs[0].nom, " : ", self.joueurs[0].nb_parties_gagnees)
        print("partie gagnée par :", self.joueurs[1].nom, " : ", self.joueurs[1].nb_parties_gagnees)
        print("partie nulles :", self.nb_parties_nulles)

        n = input("vouulez vous rejouer (O,N)")
        if (n.upper() == "O"):
            self.plateau.initialiser()

            partie.jouer()
        elif (n.upper() == "N"):
            print("merci au revoir")
            exit(0)





        
        

            
            
        

    def saisir_nombre(self, nb_min, nb_max):
        """
        Permet de demander à l'utilisateur un nombre et doit le valider.
        Ce nombre doit être une valeur entre nb_min et nb_max.
        Vous devez utiliser la méthode isnumeric() afin de vous assurer que l'utilisateur entre
        une valeur numérique et non pas une chaîne de caractères.
        Veuillez consulter l'exemple d'exécution du jeu mentionné dans l'énoncé du TP
        afin de savoir quoi afficher à l'utilisateur.

        Args:
            nb_min (int): Un entier représentant le minimum du nombre à entrer.
            nb_max (int): Un entier représentant le maximum du nombre à entrer.

        Returns:
            int: Le nombre saisi par l'utilisateur après validation.
        """
         
        
        assert isinstance(nb_min, int), "Partie: nb_min doit être un entier."
        assert isinstance(nb_max, int), "Partie: nb_max doit être un entier."
        
        x = input("Entrer S.V.P. un nombre entre 0 et 2:? ")
        while x.isnumeric()==False or int(x)>nb_max or int(x)<nb_min  :
            print("***Valeur incorrect!***")
            x = input("Entrer S.V.P. un nombre entre 0 et 2:? ")
            x.isnumeric()
            
        
        
            
                
        return x

        pass

    def demander_forme_pion(self):
        """
        Permet de demander à l'utilisateur un caractère et doit le valider.
        Ce caractère doit être soit 'O' soit 'X'.
        Veuillez consulter l'exemple d'exécution du jeu mentionné dans l'énoncé du TP
        afin de savoir quoi afficher à l'utilisateur.

        Returns:
            string: Le catactère saisi par l'utilisateur après validation.
        """
        forme=input("Sélectionnez S.V.P. la forme de votre pion (X,O):? ").upper()

      
        while not (forme == "X" or forme == "O") :
            print('valeur incorrect')
            forme=input("Sélectionnez S.V.P. la forme de votre pion (X,O):? ").upper()
        if (forme == "X") :
            return "X"
        else :
            return "O"

        pass

    def tour(self, choix):
        """
        Permet d'exécuter le tour d'un joueur (une personne ou un ordinateur).
        Cette méthode doit afficher le plateau (voir la méthode __str__() de la classe Plateau).
        Si le joueur courant est un ordinateur, il faut calculer la position de la prochaine
        case à jouer par cet ordinateur en utilisant la méthode choisir_prochaine_case().
        Si le joueur courant est une personne, il faut lui demander la position de la prochaine
        case qu'il veut jouer en utilisant la méthode demander_postion().
        Finalement, il faut utiliser la méthode selectionner_case() pour modifier le contenu
        de la case choisie soit par l'ordinateur soit par la personne.

        Args:
            choix (int): Un entier représentant le choix de l'utilisateur dans le menu du jeu (1 ou 2).
        """

        assert isinstance(choix, int), "Partie: choix doit être un entier."
        assert choix in [1, 2], "Partie: choix doit être 1 ou 2."

        p=self.joueur_courant.pion
        if (choix==1):
            (ligne1,colonne1)=self.demander_postion()
            self.plateau.selectionner_case(ligne1,colonne1,p)
            print(self.plateau)

            if (self.plateau.est_gagnant(self.joueurs[0].pion)):
                self.joueurs[0].nb_parties_gagnees=self.joueurs[0].nb_parties_gagnees+1
                print('********* partie terminée ***************')
                print("partie terminée ! le joueur gagnant est", self.joueurs[0].nom)
                print("partie gagnée par :", self.joueurs[0].nom," : ",self.joueurs[0].nb_parties_gagnees)
                print("partie gagnée par :", self.joueurs[1].nom," : ",self.joueurs[1].nb_parties_gagnees)
                print("partie nulles :", self.nb_parties_nulles)

                n = input("vouulez vous rejouer (O,N)")
                if(n.upper()=="O"):
                    self.plateau.initialiser()
                    self.joueurs=[]
                    self.joueur_courant = None
                    partie.jouer()


                elif (n.upper() == "N"):
                    print("merci au revoir")
                    exit(0)
            if (self.plateau.non_plein()):

                print("C'est le tour maintenant de l'ordinateur Colosse!" )
                (ligne2,colonne2)=self.plateau.choisir_prochaine_case(self.joueurs[1].pion)
                self.plateau.selectionner_case(ligne2,colonne2,self.joueurs[1].pion)
                print(self.plateau)


            if (self.plateau.est_gagnant(self.joueurs[1].pion)):
                self.joueurs[1].nb_parties_gagnees=self.joueurs[1].nb_parties_gagnees+1
                print("partie terminée ! le joueur gagnant est", self.joueurs[1].nom)
                print('********* partie terminée ***************')
                print("partie terminée ! le joueur gagnant est", self.joueurs[0].nom)
                print("partie gagnée par :", self.joueurs[0].nom, " : ", self.joueurs[0].nb_parties_gagnees)
                print("partie gagnée par :", self.joueurs[1].nom, " : ", self.joueurs[1].nb_parties_gagnees)
                print("partie nulles :", self.nb_parties_nulles)

                n = input("vouulez vous rejouer (O,N)")
                if (n.upper() == "O"):
                    self.plateau.initialiser()
                    self.joueurs=[]
                    self.joueur_courant = None
                    partie.jouer()


                elif (n.upper() == "N"):
                    print("merci au revoir")
                    exit(0)



        if (choix==2):
            (ligne1,colonne1)=self.demander_postion()
            self.plateau.selectionner_case(ligne1,colonne1,p)
            print(self.plateau)

            if (self.plateau.est_gagnant(self.joueurs[0].pion)):
                self.joueurs[0].nb_parties_gagnees = self.joueurs[0].nb_parties_gagnees + 1
                print('********* partie terminée ***************')
                print("partie terminée ! le joueur gagnant est", self.joueurs[0].nom)
                print("partie gagnée par :", self.joueurs[0].nom, " : ", self.joueurs[0].nb_parties_gagnees)
                print("partie gagnée par :", self.joueurs[1].nom, " : ", self.joueurs[1].nb_parties_gagnees)
                print("partie nulles :", self.nb_parties_nulles)

                n = input("vouulez vous rejouer (O,N)")
                if (n.upper() == "N"):
                    print("merci au revoir")
                exit(0)
            if(self.plateau.non_plein()):


                self.joueur_courant=self.joueurs[1]
                (ligne2, colonne2) = self.demander_postion()
                self.plateau.selectionner_case(ligne2,colonne2,self.joueur_courant.pion)
                self.joueur_courant=self.joueurs[0]
                print(self.plateau)

            if (self.plateau.est_gagnant(self.joueurs[1].pion)):
                self.joueurs[1].nb_parties_gagnees = self.joueurs[1].nb_parties_gagnees + 1
                print("partie terminée ! le joueur gagnant est", self.joueurs[1].nom)
                print('********* partie terminée ***************')
                print("partie terminée ! le joueur gagnant est", self.joueurs[0].nom)
                print("partie gagnée par :", self.joueurs[0].nom, " : ", self.joueurs[0].nb_parties_gagnees)
                print("partie gagnée par :", self.joueurs[1].nom, " : ", self.joueurs[1].nb_parties_gagnees)
                print("partie nulles :", self.nb_parties_nulles)
                n = input("vouulez vous rejouer (O,N)")
                if (n.upper() == "N"):
                    print("merci au revoir")
                exit(0)




            
        

        pass

    def demander_postion(self):
        """
        Permet de demander à l'utilisateur les coordonnées de la case qu'il veut jouer.
        Cette méthode doit valider ces coordonnées (ligne,colonne).
        Voici un exemple de ce qu'il faut afficher afin de demander cette position:

        Mond her : Entrez s.v.p. les coordonnées de la case à utiliser:
        Numéro de la ligne:Entrez s.v.p. un nombre entre 0 et 2:? 0
        Numéro de la colonne:Entrez s.v.p. un nombre entre 0 et 2:? 0

        Il faut utiliser la méthode saisir_nombre() et position_valide().

        Returns:
            (int,int):  Une paire d'entiers représentant les
                        coordonnées (ligne, colonne) de la case choisie.
        """
        print(self.joueur_courant.nom," : Entrer S.V.P. les cordonnées de la case à utiliser:")
        print ( "Numéro de la ligne :",end=" ")
        numLigne = int(partie.saisir_nombre(0,2))
        print ( "Numéro de la colonne:",end=" ")
        numColonne = int(partie.saisir_nombre(0,2))
        while(self.plateau.position_valide(numLigne,numColonne)==False):
             print(" case non valide")
             print ( "Numéro de la ligne :",end=" ")
             numLigne = int(partie.saisir_nombre(0,2))
             print ( "Numéro de la colonne: ",end=" ")
             numColonne = int(partie.saisir_nombre(0,2))
             
        return numLigne, numColonne

        pass
Пример #2
0
class Partie:
    """
    Classe modélisant une partie du jeu Tic-Tac-Toe utilisant
    un plateau et deux joueurs (deux personnes ou une personne et un ordinateur).

    Attributes:
        plateau (Plateau): Le plateau du jeu contenant les 9 cases.
        joueurs (Joueur list): La liste des deux joueurs (initialement une liste vide).
        joueur_courant (Joueur): Le joueur courant (initialisé à une valeur nulle: None)
        nb_parties_nulles (int): Le nombre de parties nulles (aucun joueur n'a gagné).
    """
    def __init__(self):
        """
        Méthode spéciale initialisant une nouvelle partie du jeu Tic-Tac-Toe.
        """
        self.plateau = Plateau()  # Le plateau du jeu contenant les 9 cases.
        self.joueurs = [
        ]  # La liste des deux joueurs (initialement une liste vide).
        # Au début du jeu, il faut ajouter les deux joueurs à cette liste.
        self.joueur_courant = None  # Le joueur courant (initialisé à une valeur nulle: None)
        # Pendant le jeu et à chaque tour d'un joueur,
        # il faut affecter à cet attribut ce joueur courant.
        self.nb_parties_nulles = 0  # Le nombre de parties nulles (aucun joueur n'a gagné).

    def jouer(self):
        """
        Permet de démarrer la partie en commençant par l'affichage de ce texte:

        Bienvenue au jeu Tic Tac Toe.
        ---------------Menu---------------
        1- Jouer avec l'ordinateur.
        2- Jouter avec une autre personne.
        0- Quitter.
        -----------------------------------
        Entrez s.v.p. un nombre entre 0 et 2:?



        Cette méthode doit donc utiliser la méthode saisir_nombre().

        Elle doit par la suite demander à l'utilisateur les noms des joueurs.

        Veuillez utiliser 'Colosse' comme nom pour l'ordinateur.

        Il faut créer des instances de la classe Joueur et les ajouter à la liste joueurs.

        Il faut utiliser entre autres ces méthodes:

            *- demander_forme_pion(): pour demander au premier joueur la forme de son pion (X ou O).
              (Pas besoin de demander à l'autre joueur ou à l'ordinateur cela, car on peut le déduire).

            *- plateau.non_plein(): afin d'arrêter le jeu si le plateau est plein (partie nulle).

            *- tour(): afin d'exécuter le tour du joueur courant.

            *- plateau.est_gagnant(): afin de savoir si un joueur a gagné et donc arrêter le jeu.

        Il faut alterner entre le premier joueur et le deuxième joueur à chaque appel de tour()
        en utilisant l'attribut joueur_courant. DANS LA LISTE DES JOUEURS

        Après la fin de chaque partie, il faut afficher les statistiques sur le jeu.
        Voici un exemple:

        Partie terminée! Le joueur gagnant est: Colosse
        Parties gagnées par Mondher : 2
        Parties gagnées par Colosse : 1
        Parties nulles: 1
        Voulez-vous recommencer (O,N)?

        Il ne faut pas oublier d'initialiser le plateau avant de recommencer le jeu.
        Si l'utilisateur ne veut plus recommencer, il faut afficher ce message:
        ***Merci et au revoir !***
        """

        # pass*********************************************************************************************************
        print(
            "Bienvenue au jeu Tic Tac Toe.\n ---------------Menu--------------- \n 1- Jouer avec l'ordinateur.\n 2- Jouer avec une autre personne.\n 0- Quitter."
        )
        print(
            "-----------------------------------\n Entrez s.v.p. un nombre entre 0 et 2: "
        )
        f = False
        q = True
        n = self.saisir_nombre(0, 2)
        if n == 1:
            jr = input("Entrez votre nom S.V.P: ")
            p = self.demander_forme_pion()
            j1 = Joueur(jr, "Personne", p)
            if p == "X":
                po = "O"
            else:
                po = "X"
            ord = Joueur("Colosse", "Ordinateur", po)
            self.joueurs.append(j1)
            self.joueurs.append(ord)
            self.joueur_courant = self.joueurs[randrange(1)]

        elif n == 2:
            nj1 = input("Le joueur Numero 1 Entrez votre nom S.V.P: ")
            h = self.demander_forme_pion()
            nj2 = input("Le joueur Numero 2 Entrez votre nom S.V.P: ")
            j1 = Joueur(nj1, "Personne", h)
            if h == "X":
                po = "O"
            else:
                po = "X"
            j2 = Joueur(nj2, "Personne", po)
            self.joueurs.append(j1)
            self.joueurs.append(j2)
            self.joueur_courant = self.joueurs[randrange(1)]
        else:
            print("-----------------------------------------------------")
            print("*** Merci et au revoir ***")
            exit()
        while q:
            self.plateau.initialiser()
            f = False
            print(self.plateau)
            print('\n')
            while self.plateau.non_plein() and not f:

                self.tour(n)

                if self.plateau.est_gagnant(self.joueur_courant.pion):
                    f = True
                    self.joueur_courant.nb_parties_gagnees += 1
                if not f:
                    if self.joueur_courant == self.joueurs[0]:
                        self.joueur_courant = self.joueurs[1]
                    else:
                        self.joueur_courant = self.joueurs[0]

            if not self.plateau.non_plein():
                print("-----------------------------------------------------")
                print("Partie terminée! Aucun joueur n'a gangné ")
                if not f:
                    self.nb_parties_nulles += 1

            if f:
                print("-----------------------------------------------------")
                print("Partie terminée! Le joueur gagnant est: ",
                      self.joueur_courant.nom)
                if self.joueur_courant == self.joueurs[0]:
                    self.joueur_courant = self.joueurs[1]
                else:
                    self.joueur_courant = self.joueurs[0]
            print("Parties gagnées par", self.joueurs[0].nom, ": ",
                  self.joueurs[0].nb_parties_gagnees)
            print("Parties gagnées par", self.joueurs[1].nom, ": ",
                  self.joueurs[1].nb_parties_gagnees)
            print("Parties nulles:", self.nb_parties_nulles, "\n")
            print("Voulez-vous recommencer (O,N)?")
            r = input()
            if r == "O" or r == "o":
                q = True
            else:
                q = False
                print("-----------------------------------------------------")
                print("*** Merci et au revoir ! ***")

    def saisir_nombre(self, nb_min, nb_max):
        """
        Permet de demander à l'utilisateur un nombre et doit le valider.
        Ce nombre doit être une valeur entre nb_min et nb_max.
        Vous devez utiliser la méthode isnumeric() afin de vous assurer que l'utilisateur entre
        une valeur numérique et non pas une chaîne de caractères.
        Veuillez consulter l'exemple d'exécution du jeu mentionné dans l'énoncé du TP
        afin de savoir quoi afficher à l'utilisateur.

        Args:
            nb_min (int): Un entier représentant le minimum du nombre à entrer.
            nb_max (int): Un entier représentant le maximum du nombre à entrer.

        Returns:
            int: Le nombre saisi par l'utilisateur après validation.
        """
        assert isinstance(nb_min, int), "Partie: nb_min doit être un entier."
        assert isinstance(nb_max, int), "Partie: nb_max doit être un entier."

        # pass************************************************************************************************
        n = input()
        while not n.isnumeric() or not (int(n) >= nb_min and int(n) <= nb_max):
            if not n.isnumeric():
                print("La valeur à entrer doit étre numreique! ")
                print(" Entrez s.v.p. un nombre entre {} et {}:".format(
                    nb_min, nb_max))
                n = input()
            else:
                print("le nombre à entrer doit étre  entre {} et {} !".format(
                    nb_min, nb_max))
                print(" Entrez s.v.p. un nombre entre {} et {}:".format(
                    nb_min, nb_max))
                n = input()

        return int(n)

    def demander_forme_pion(self):
        """
        Permet de demander à l'utilisateur un caractère et doit le valider.
        Ce caractère doit être soit 'O' soit 'X'.
        Veuillez consulter l'exemple d'exécution du jeu mentionné dans l'énoncé du TP
        afin de savoir quoi afficher à l'utilisateur.

        Returns:
            string: Le catactère saisi par l'utilisateur après validation.
        """

        # pass*****************************************************************************************************

        p = input("Selectionnez S.V.P la forme de votre pion(X,O): ")
        while not (p in ["O", "X"]):
            print(" le Pion  doit être soit 'O' soit 'X'! ")
            p = input("Selectionnez S.V.P la forme de votre pion(X,O): ")
        return p

    def tour(self, choix):
        """
        Permet d'exécuter le tour d'un joueur (une personne ou un ordinateur).
        Cette méthode doit afficher le plateau (voir la méthode __str__() de la classe Plateau).
        Si le joueur courant est un ordinateur, il faut calculer la position de la prochaine
        case à jouer par cet ordinateur en utilisant la méthode choisir_prochaine_case().


        Si le joueur courant est une personne, il faut lui demander la position de la prochaine
        case qu'il veut jouer en utilisant la méthode demander_postion().
        Finalement, il faut utiliser la méthode selectionner_case() pour modifier le contenu
        de la case choisie soit par l'ordinateur soit par la personne.

        Args:
            choix (int): Un entier représentant le choix de l'utilisateur dans le menu du jeu (1 ou 2).
        """

        assert isinstance(choix, int), "Partie: choix doit être un entier."
        assert choix in [1, 2], "Partie: choix doit être 1 ou 2."

        # pass***************************************************************************************************

        if choix == 1:
            if self.joueur_courant.type == "Ordinateur":
                print("C'est maintenant le tour de ", self.joueur_courant.nom,
                      '!')

                if self.joueur_courant.pion == "X":
                    p = "O"
                else:
                    p = "X"
                l, c = self.plateau.choisir_prochaine_case(p)
                self.plateau.selectionner_case(l, c, self.joueur_courant.pion)
            else:
                l, c = self.demander_postion()

                self.plateau.selectionner_case(l, c, self.joueur_courant.pion)
        else:
            l, c = self.demander_postion()
            self.plateau.selectionner_case(l, c, self.joueur_courant.pion)
        print(self.plateau)

    def demander_postion(self):
        """
        Permet de demander à l'utilisateur les coordonnées de la case qu'il veut jouer.
        Cette méthode doit valider ces coordonnées (ligne,colonne).
        Voici un exemple de ce qu'il faut afficher afin de demander cette position:

        Mondher : Entrez s.v.p. les coordonnées de la case à utiliser:
        Numéro de la ligne:Entrez s.v.p. un nombre entre 0 et 2:? 0
        Numéro de la colonne:Entrez s.v.p. un nombre entre 0 et 2:? 0

        Il faut utiliser la méthode saisir_nombre() et position_valide().

        Returns:
            (int,int):  Une paire d'entiers représentant les
                        coordonnées (ligne, colonne) de la case choisie.
        """
        # pass********************************************************************************************************

        print(self.joueur_courant.nom,
              ": Entrez s.v.p. les coordonnées de la case à utiliser:")
        print("Numéro de la ligne:Entrez s.v.p. un nombre entre 0 et 2:")
        l = self.saisir_nombre(0, 2)
        print("Numéro de la colonne:Entrez s.v.p. un nombre entre 0 et 2:")
        c = self.saisir_nombre(0, 2)
        while not self.plateau.position_valide(l, c):
            print("Position invalide, choissisez une autre case! ")
            print("Numéro de la ligne:Entrez s.v.p. un nombre entre 0 et 2:")
            l = self.saisir_nombre(0, 2)
            print("Numéro de la colonne:Entrez s.v.p. un nombre entre 0 et 2:")
            c = self.saisir_nombre(0, 2)
        return l, c
Пример #3
0
class Partie:
    """
    Classe modélisant une partie du jeu Tic-Tac-Toe utilisant
    un plateau et deux joueurs (deux personnes ou une personne et un ordinateur).

    Attributes:
        plateau (Plateau): Le plateau du jeu contenant les 9 cases.
        joueurs (Joueur list): La liste des deux joueurs (initialement une liste vide).
        joueur_courant (Joueur): Le joueur courant (initialisé à une valeur nulle: None)
        nb_parties_nulles (int): Le nombre de parties nulles (aucun joueur n'a gagné).
    """
    def __init__(self):
        """
        Méthode spéciale initialisant une nouvelle partie du jeu Tic-Tac-Toe.
        """
        self.plateau = Plateau()  # Le plateau du jeu contenant les 9 cases.
        self.joueurs = [
        ]  # La liste des deux joueurs (initialement une liste vide).
        # Au début du jeu, il faut ajouter les deux joueurs à cette liste.
        self.joueur_courant = None  # Le joueur courant (initialisé à une valeur nulle: None)
        # Pendant le jeu et à chaque tour d'un joueur,
        # il faut affecter à cet attribut ce joueur courant.
        self.nb_parties_nulles = 0  # Le nombre de parties nulles (aucun joueur n'a gagné).

    def jouer(self):
        """
        Permet de démarrer la partie en commençant par l'affichage de ce texte:

        Bienvenue au jeu Tic Tac Toe.
        ---------------Menu---------------
        1- Jouer avec l'ordinateur.
        2- Jouter avec une autre personne.
        0- Quitter.
        -----------------------------------
        Entrez s.v.p. un nombre entre 0 et 2:?

        Cette méthode doit donc utiliser la méthode saisir_nombre().
        Elle doit par la suite demander à l'utilisateur les noms des joueurs.
        Veuillez utiliser 'Colosse' comme nom pour l'ordinateur.
        Il faut créer des instances de la classe Joueur et les ajouter à la liste joueurs.
        Il faut utiliser entre autres ces méthodes:
            *- demander_forme_pion(): pour demander au premier joueur la forme de son pion (X ou O).
              (Pas besoin de demander à l'autre joueur ou à l'ordinateur cela, car on peut le déduire).
            *- plateau.non_plein(): afin d'arrêter le jeu si le plateau est plein (partie nulle).
            *- tour(): afin d'exécuter le tour du joueur courant.
            *- plateau.est_gagnant(): afin de savoir si un joueur a gagné et donc arrêter le jeu.
        Il faut alterner entre le premier joueur et le deuxième joueur à chaque appel de tour()
        en utilisant l'attribut joueur_courant.
        Après la fin de chaque partie, il faut afficher les statistiques sur le jeu.
        Voici un exemple:

        Partie terminée! Le joueur gagnant est: Colosse
        Parties gagnées par Mondher : 2
        Parties gagnées par Colosse : 1
        Parties nulles: 1
        Voulez-vous recommencer (O,N)?

        Il ne faut pas oublier d'initialiser le plateau avant de recommencer le jeu.
        Si l'utilisateur ne veut plus recommencer, il faut afficher ce message:
        ***Merci et au revoir !***
        """

        print(
            "Bienvenue au jeu Tic Tac Toe.\n---------------Menu---------------"
        )
        print(
            "1- Jouer avec l'ordinateur.\n2- Jouter avec une autre personne.")
        print("0- Quitter.\n-----------------------------------")

        choix = self.saisir_nombre(0, 2)
        if choix == 1:
            nom = input("Entrez s.v.p votre nom:?")
            type = "Personne"
            pion = self.demander_forme_pion()
            j1 = Joueur(nom, type, pion)
            if j1.pion.upper() == "X":
                pion2 = "O"
            else:
                pion2 = "X"
            self.joueurs.append(j1)
            j2 = Joueur("Colosse", "Ordinateur", pion2)
            self.joueurs.append(j2)
            x = "O"
            while x.upper() == "O":
                self.plateau.initialiser()
                print(self.plateau)
                while self.plateau.non_plein():
                    self.joueur_courant = self.joueurs[0]
                    self.tour(int(choix))
                    if self.plateau.est_gagnant(
                            pion) or not self.plateau.non_plein():
                        break
                    print("c'est le tour maintenant de l'ordinateur colosse!")
                    self.joueur_courant = self.joueurs[1]
                    self.tour(int(choix))
                    if self.plateau.est_gagnant(
                            pion2) or not self.plateau.non_plein():
                        break
                if self.plateau.est_gagnant(pion):
                    self.joueurs[0].nb_parties_gagnees = self.joueurs[
                        0].nb_parties_gagnees + 1
                    print("Partie terminée! Le joueur gagnant est:",
                          self.joueurs[0].nom)
                elif self.plateau.est_gagnant(pion2):
                    self.joueurs[1].nb_parties_gagnees = self.joueurs[
                        1].nb_parties_gagnees + 1
                    print("Partie terminée! Le joueur gagnant est:",
                          self.joueurs[1].nom)
                else:
                    print("Partie terminée! aucun joueur n'a gagne")
                    self.nb_parties_nulles = self.nb_parties_nulles + 1
                print("Parties gagnées par ", self.joueurs[0].nom,
                      self.joueurs[0].nb_parties_gagnees)
                print("Parties gagnées par ", self.joueurs[1].nom,
                      self.joueurs[1].nb_parties_gagnees)
                print("Parties nulles:", self.nb_parties_nulles)
                x = input("voulez vous recommencez (O,N)?")
                assert isinstance(x, str)
                assert x.upper() in ["O", "N"]
            if x.upper() == "N":
                print("***Merci et Au Revoir***")
                return
        elif choix == 2:
            nom = input("Entrez s.v.p votre nom:?")
            type = "Personne"
            pion = self.demander_forme_pion()
            j1 = Joueur(nom, type, pion)
            self.joueurs.append(j1)
            if j1.pion.upper() == "X":
                pion2 = "O"
            else:
                pion2 = "X"
            nom = input("Entrez s.v.p le nom de l'autre joueur:?")
            type = "Personne"
            j2 = Joueur(nom, type, pion2)
            self.joueurs.append(j2)
            x = "O"
            while x.upper() == "O":
                self.plateau.initialiser()
                print(self.plateau)
                while self.plateau.non_plein():
                    self.joueur_courant = self.joueurs[0]
                    self.tour(int(choix))
                    if self.plateau.est_gagnant(
                            self.joueur_courant.pion
                    ) or not self.plateau.non_plein():
                        break
                    print("c'est le tour maintenant du deuxieme joueur!")
                    self.joueur_courant = self.joueurs[1]
                    self.tour(int(choix))
                    if self.plateau.est_gagnant(
                            self.joueur_courant.pion
                    ) or not self.plateau.non_plein():
                        break
                if self.plateau.est_gagnant(self.joueur_courant.pion):
                    if self.joueur_courant.nom == self.joueurs[0].nom:
                        self.joueurs[0].nb_parties_gagnees = self.joueurs[
                            0].nb_parties_gagnees + 1
                        print("Partie terminée! Le joueur gagnant est:",
                              self.joueurs[0].nom)
                    else:
                        self.joueurs[1].nb_parties_gagnees = self.joueurs[
                            1].nb_parties_gagnees + 1
                        print("Partie terminée! Le joueur gagnant est:",
                              self.joueurs[1].nom)
                else:
                    print("Partie terminée! aucun joueur n'a gagne")
                    self.nb_parties_nulles = self.nb_parties_nulles + 1
                print("Parties gagnées par ", self.joueurs[0].nom,
                      self.joueurs[0].nb_parties_gagnees)
                print("Parties gagnées par ", self.joueurs[1].nom,
                      self.joueurs[1].nb_parties_gagnees)
                print("Parties nulles:", self.nb_parties_nulles)
                x = input("voulez vous recommencez (O,N)?")
                assert isinstance(x, str)
                assert x.upper() in ["O", "N"]
            if x.upper() == "N":
                print("***Merci et Au Revoir***")
                return

        elif choix == 0:
            print("***Merci et Au revoire***")
            return

    def saisir_nombre(self, nb_min, nb_max):
        """
        Permet de demander à l'utilisateur un nombre et doit le valider.
        Ce nombre doit être une valeur entre nb_min et nb_max.
        Vous devez utiliser la méthode isnumeric() afin de vous assurer que l'utilisateur entre
        une valeur numérique et non pas une chaîne de caractères.
        Veuillez consulter l'exemple d'exécution du jeu mentionné dans l'énoncé du TP
        afin de savoir quoi afficher à l'utilisateur.

        Args:
            nb_min (int): Un entier représentant le minimum du nombre à entrer.
            nb_max (int): Un entier représentant le maximum du nombre à entrer.

        Returns:
            int: Le nombre saisi par l'utilisateur après validation.
        """
        assert isinstance(nb_min, int), "Partie: nb_min doit être un entier."
        assert isinstance(nb_max, int), "Partie: nb_max doit être un entier."

        test = False
        while test == False:
            print("Entrez s.v.p. un nombre entre ", nb_min, " et ", nb_max,
                  ":?")
            x = input()
            y = int(x)
            if x.isnumeric():
                if y <= nb_max and y >= nb_min:
                    test = True

        return int(x)

    def demander_forme_pion(self):
        """
        Permet de demander à l'utilisateur un caractère et doit le valider.
        Ce caractère doit être soit 'O' soit 'X'.
        Veuillez consulter l'exemple d'exécution du jeu mentionné dans l'énoncé du TP
        afin de savoir quoi afficher à l'utilisateur.

        Returns:
            string: Le catactère saisi par l'utilisateur après validation.
        """
        test = False
        while test == False:
            x = input("Sélectionnez S.V.P la forme du votre pion(x,o):?")
            if x.isalpha():
                if x.upper() == "X" or x.upper() == "O":
                    test = True
        return x.upper()

    def tour(self, choix):
        """
        Permet d'exécuter le tour d'un joueur (une personne ou un ordinateur).
        Cette méthode doit afficher le plateau (voir la méthode __str__() de la classe Plateau).
        Si le joueur courant est un ordinateur, il faut calculer la position de la prochaine
        case à jouer par cet ordinateur en utilisant la méthode choisir_prochaine_case().
        Si le joueur courant est une personne, il faut lui demander la position de la prochaine
        case qu'il veut jouer en utilisant la méthode demander_postion().
        Finalement, il faut utiliser la méthode selectionner_case() pour modifier le contenu
        de la case choisie soit par l'ordinateur soit par la personne.

        Args:
            choix (int): Un entier représentant le choix de l'utilisateur dans le menu du jeu (1 ou 2).
        """

        assert isinstance(choix, int), "Partie: choix doit être un entier."
        assert choix in [1, 2], "Partie: choix doit être 1 ou 2."
        if choix == 1:
            if self.joueur_courant.type == "Ordinateur":
                if self.joueur_courant.pion.upper() == "X":
                    pion2 = "O"
                else:
                    pion2 = "X"
                a, b = self.plateau.choisir_prochaine_case(pion2)
            else:
                a, b = self.demander_postion()
        else:
            a, b = self.demander_postion()
        self.plateau.selectionner_case(a, b, self.joueur_courant.pion)
        print(self.plateau)

    def demander_postion(self):
        """
        Permet de demander à l'utilisateur les coordonnées de la case qu'il veut jouer.
        Cette méthode doit valider ces coordonnées (ligne,colonne).
        Voici un exemple de ce qu'il faut afficher afin de demander cette position:

        Mondher : Entrez s.v.p. les coordonnées de la case à utiliser:
        Numéro de la ligne:Entrez s.v.p. un nombre entre 0 et 2:? 0
        Numéro de la colonne:Entrez s.v.p. un nombre entre 0 et 2:? 0

        Il faut utiliser la méthode saisir_nombre() et position_valide().

        Returns:
            (int,int):  Une paire d'entiers représentant les
                        coordonnées (ligne, colonne) de la case choisie.
        """
        test = False
        while not test:

            print(self.joueur_courant.nom,
                  " : Entrez s.v.p. les coordonnées de la case à utiliser:")
            print("numéro de la ligne:", end=" ")
            l = int(self.saisir_nombre(0, 2))
            print("numéro de la colonne:", end=" ")
            c = int(self.saisir_nombre(0, 2))
            if self.plateau.position_valide(l, c):
                test = True
                return l, c
            else:
                print("***Valeur Incorrecte***")
Пример #4
0
class Partie:
    """
    Classe modélisant une partie du jeu Tic-Tac-Toe utilisant
    un plateau et deux joueurs (deux personnes ou une personne et un ordinateur).

    Attributes:
        plateau (Plateau): Le plateau du jeu contenant les 9 cases.
        joueurs (Joueur list): La liste des deux joueurs (initialement une liste vide).
        joueur_courant (Joueur): Le joueur courant (initialisé à une valeur nulle: None)
        nb_parties_nulles (int): Le nombre de parties nulles (aucun joueur n'a gagné).
    """
    def __init__(self):
        """
        Méthode spéciale initialisant une nouvelle partie du jeu Tic-Tac-Toe.
        """
        self.plateau = Plateau()  # Le plateau du jeu contenant les 9 cases.
        self.joueurs = [
        ]  # La liste des deux joueurs (initialement une liste vide).
        # Au début du jeu, il faut ajouter les deux joueurs à cette liste.
        self.joueur_courant = None  # Le joueur courant (initialisé à une valeur nulle: None)
        # Pendant le jeu et à chaque tour d'un joueur,
        # il faut affecter à cet attribut ce joueur courant.
        self.nb_parties_nulles = 0  # Le nombre de parties nulles (aucun joueur n'a gagné).

    def saisir_nombre(self, nb_min, nb_max):
        """Args:
                  nb_min (int): Un entier représentant le minimum du nombre à entrer.
                  nb_max (int): Un entier représentant le maximum du nombre à entrer.

              Returns:
                  int: Le nombre saisi par l'utilisateur après validation.
              """
        assert isinstance(nb_min, int), "Partie: nb_min doit être un entier."
        assert isinstance(nb_max, int), "Partie: nb_max doit être un entier."
        nbre = input("Entrez s.v.p. un nombre entre " + str(nb_min) + " et " +
                     str(nb_max) + ":? ")
        while (not nbre.isnumeric()
               or int(nbre) not in range(nb_min, nb_max + 1)):
            print("***Valeur incorrecte!***")
            nbre = input("Entrez s.v.p. un nombre entre " + str(nb_min) +
                         " et " + str(nb_max) + ":? ")
        return int(nbre)

    def demander_forme_pion(self):
        """
        Permet de demander à l'utilisateur un caractère et doit le valider.
        Ce caractère doit être soit 'O' soit 'X'.
        Returns:
            string: Le catactère saisi par l'utilisateur après validation.
        """
        pionStr = input("Selectionnez s.v.p. la forme de votre pion (X,O):?")
        while (pionStr not in ["O", "X"]):
            print("***Valeur incorrecte!***")
            pionStr = input(
                "Selectionnez s.v.p. la forme de votre pion (X,O):?")
        return pionStr

    def demander_postion(self):
        """
        Permet de demander à l'utilisateur les coordonnées de la case qu'il veut jouer.
        Cette méthode doit valider ces coordonnées (ligne,colonne).
        Voici un exemple de ce qu'il faut afficher afin de demander cette position:

        Mondher : Entrez s.v.p. les coordonnées de la case à utiliser:
        Numéro de la ligne:Entrez s.v.p. un nombre entre 0 et 2:? 0
        Numéro de la colonne:Entrez s.v.p. un nombre entre 0 et 2:? 0

        Il faut utiliser la méthode saisir_nombre() et position_valide().

        Returns:
            (int,int):  Une paire d'entiers représentant les
                        coordonnées (ligne, colonne) de la case choisie.
        """
        print(self.joueur_courant.nom,
              " : Entrez s.v.p. les coordonnees de la case a utiliser:\n")
        print("Numéro de la ligne:")
        ligne = self.saisir_nombre(0, 2)
        print("Numéro de la colonne:")
        col = self.saisir_nombre(0, 2)
        while (not self.plateau.position_valide(ligne, col)):
            print("***position n'est pas valide***\n")
            print(self.joueur_courant.nom,
                  " : Entrez s.v.p. les coordonnees de la case a utiliser:\n")
            print("Numéro de la ligne:")
            ligne = self.saisir_nombre(0, 2)
            print("Numéro de la colonne:")
            col = self.saisir_nombre(0, 2)
        return ligne, col

    def tour(self, choix):
        """
        Permet d'exécuter le tour d'un joueur (une personne ou un ordinateur).
        Cette méthode doit afficher le plateau (voir la méthode __str__() de la classe Plateau).
        Si le joueur courant est un ordinateur, il faut calculer la position de la prochaine
        case à jouer par cet ordinateur en utilisant la méthode choisir_prochaine_case().
        Si le joueur courant est une personne, il faut lui demander la position de la prochaine
        case qu'il veut jouer en utilisant la méthode demander_postion().
        Finalement, il faut utiliser la méthode selectionner_case() pour modifier le contenu
        de la case choisie soit par l'ordinateur soit par la personne.

        Args:
            choix (int): Un entier représentant le choix de l'utilisateur dans le menu du jeu (1 ou 2).
        """

        assert isinstance(choix, int), "Partie: choix doit être un entier."
        assert choix in [1, 2], "Partie: choix doit être 1 ou 2."

        print(self.plateau.__str__())
        if self.joueur_courant.type == "Ordinateur":
            ligne, col = self.plateau.choisir_prochaine_case(
                self.joueur_courant.pion)
        else:
            ligne, col = self.demander_postion()

        self.plateau.selectionner_case(ligne, col, self.joueur_courant.pion)

    def jouer(self):
        print("Bienvenue au jeu Tic Tac Toe. \n")
        print("---------------Menu---------------\n")
        print("1- Jouer avec l'ordinateur.\n")
        print("2- Jouer avec une autre personne.\n")
        print("0- Quitter.\n")
        print("----------------------------------\n")

        # choix du mode de jeux

        mode = self.saisir_nombre(0, 2)
        # initialisation des joueurs
        if mode == 0:
            print("***Merci et au revoir !***")
            return 0
        else:
            nom = input("Entrez s.v.p. votre nom:? ")
            pion = self.demander_forme_pion()
            player1 = Joueur(nom, "Personne", pion)

            # deduction du pion du joueur 2
            if player1.pion == "X":
                pion = "O"
            else:
                pion = "X"

            #creation du joueur 2 selon le mode choisit
            if mode == 1:
                player2 = Joueur("Colosse", "Ordinateur", pion)
            if (mode == 2):
                nom = input("Entrez s.v.p. votre nom:? ")
                player2 = Joueur(nom, "Personne", pion)
            self.joueurs = [player1, player2]

            #si partie n'est pas finie, les joueur 1 et 2 joue a tour de role
            replay = "O"
            while replay == "O":
                partie.plateau.initialiser()
                while (self.plateau.non_plein() == True
                       and self.plateau.est_gagnant(player1.pion) == False
                       and self.plateau.est_gagnant(player2.pion) == False):
                    self.joueur_courant = player1
                    print("c'est le tour maintenant de " +
                          str(self.joueur_courant.type) + " " +
                          self.joueur_courant.nom + "! \n")
                    self.tour(mode)
                    if self.plateau.est_gagnant(
                            player1.pion) or self.plateau.non_plein() == False:
                        break
                    self.joueur_courant = player2
                    print("c'est le tour maintenant de " +
                          str(self.joueur_courant.type) + " " +
                          self.joueur_courant.nom + "! \n")
                    self.tour(mode)
                    if self.plateau.est_gagnant(
                            player2.pion) or self.plateau.non_plein() == False:
                        break
                if (self.plateau.non_plein() == False):
                    self.nb_parties_nulles += 1
                    print("Partie terminée! La partie est nulle \n ")
                    print("Partie gangner par " + player1.nom + ": " +
                          str(player1.nb_parties_gagnees))
                    print("Partie gangner par " + player2.nom + ": " +
                          str(player2.nb_parties_gagnees))
                    print("Partie nulle : " + str(self.nb_parties_nulles) +
                          " \n")

                if self.plateau.est_gagnant(player1.pion) == True:
                    player1.nb_parties_gagnees += 1
                    print("Partie terminée! Le joueur gagnant est : " +
                          player1.nom + " \n ")
                    print("Partie gangner par " + player1.nom + ": " +
                          str(player1.nb_parties_gagnees) + " \n")
                    print("Partie gangner par " + player2.nom + ": " +
                          str(player2.nb_parties_gagnees) + " \n")
                    print("Partie nulle : " + str(self.nb_parties_nulles) +
                          " \n")

                if (self.plateau.est_gagnant(player2.pion) == True):
                    player2.nb_parties_gagnees += 1
                    print("Partie terminée! Le joueur gagnant est : " +
                          player2.nom + " \n")
                    print("Partie gangner par " + player1.nom + ": " +
                          str(player1.nb_parties_gagnees) + " \n")
                    print("Partie gangner par " + player2.nom + ": " +
                          str(player2.nb_parties_gagnees) + " \n")
                    print("Partie nulle : " + str(self.nb_parties_nulles) +
                          " \n")
                replay = input("Voulez-vous recommencer (O,N)?")
                if replay == "N":
                    print("***Merci et au revoir !***")
            """Il faut créer des instances de la classe Joueur et les ajouter à la liste joueurs.
Пример #5
0
class Partie:
    """
    Classe modélisant une partie du jeu Tic-Tac-Toe utilisant
    un plateau et deux joueurs (deux personnes ou une personne et un ordinateur).

    Attributes:
        plateau (Plateau): Le plateau du jeu contenant les 9 cases.
        joueurs (Joueur list): La liste des deux joueurs (initialement une liste vide).
        joueur_courant (Joueur): Le joueur courant (initialisé à une valeur nulle: None)
        nb_parties_nulles (int): Le nombre de parties nulles (aucun joueur n'a gagné).
    """

    def __init__(self):
        """
        Méthode spéciale initialisant une nouvelle partie du jeu Tic-Tac-Toe.
        """
        self.plateau = Plateau()    # Le plateau du jeu contenant les 9 cases.
        self.joueurs = []       # La liste des deux joueurs (initialement une liste vide).
                                # Au début du jeu, il faut ajouter les deux joueurs à cette liste.
        self.joueur_courant = None  # Le joueur courant (initialisé à une valeur nulle: None)
                                    # Pendant le jeu et à chaque tour d'un joueur,
                                    # il faut affecter à cet attribut ce joueur courant.
        self.nb_parties_nulles = 0  # Le nombre de parties nulles (aucun joueur n'a gagné).

    def jouer(self):
        """
        Permet de démarrer la partie en commençant par l'affichage de ce texte:

        Bienvenue au jeu Tic Tac Toe.
        ---------------Menu---------------
        1- Jouer avec l'ordinateur.
        2- Jouter avec une autre personne.
        0- Quitter.
        -----------------------------------
        Entrez s.v.p. un nombre entre 0 et 2:?

        Cette méthode doit donc utiliser la méthode saisir_nombre().
        Elle doit par la suite demander à l'utilisateur les noms des joueurs.
        Veuillez utiliser 'Colosse' comme nom pour l'ordinateur.
        Il faut créer des instances de la classe Joueur et les ajouter à la liste joueurs.
        Il faut utiliser entre autres ces méthodes:
            *- demander_forme_pion(): pour demander au premier joueur la forme de son pion (X ou O).
              (Pas besoin de demander à l'autre joueur ou à l'ordinateur cela, car on peut le déduire).
            *- plateau.non_plein(): afin d'arrêter le jeu si le plateau est plein (partie nulle).
            *- tour(): afin d'exécuter le tour du joueur courant.
            *- plateau.est_gagnant(): afin de savoir si un joueur a gagné et donc arrêter le jeu.
        Il faut alterner entre le premier joueur et le deuxième joueur à chaque appel de tour()
        en utilisant l'attribut joueur_courant.
        Après la fin de chaque partie, il faut afficher les statistiques sur le jeu.
        Voici un exemple:

        Partie terminée! Le joueur gagnant est: Colosse
        Parties gagnées par Mondher : 2
        Parties gagnées par Colosse : 1
        Parties nulles: 1
        Voulez-vous recommencer (O,N)?

        Il ne faut pas oublier d'initialiser le plateau avant de recommencer le jeu.
        Si l'utilisateur ne veut plus recommencer, il faut afficher ce message:
        ***Merci et au revoir !***
        """
        print("Bienvenue au jeu Tic Tac Toe.")
        print("---------------Menu---------------")
        print("1- Jouer avec l'ordinateur.")
        print("2- Jouter avec une autre personne.")
        print("0- Quitter.")
        print("-----------------------------------")
        choix = self.saisir_nombre(0, 2)
        if choix == 0:
            print("***Merci et au revoir !***")
            exit()
        elif choix == 1:# contre ordinateur
            pion1 = self.demander_forme_pion()
            if pion1 == 'X': pion2 = 'O'
            else: pion2 = 'X'
            joueur1 = Joueur("Mondher", "Personne", pion1)
            joueur2 = Joueur("Colosse", "Ordinateur", pion2)
            self.joueurs.append([joueur1, joueur2])
        else: # choix == 2 (contre personne)
            pion1 = self.demander_forme_pion()
            if pion1 == 'X': pion2 = 'O'
            else: pion2 = 'X'
            joueur1 = Joueur("Mondher", "Personne", pion1)
            joueur2 = Joueur("Siwar", "Personne", pion2)
            self.joueurs.append([joueur1, joueur2])

        # premier joueur a commencer
        if self.joueur_courant == None:
            premier_joueur = self.joueur_courant = joueur1
        while True:
            while self.plateau.non_plein():
                self.tour(1)
                if self.plateau.est_gagnant(self.joueur_courant.pion): break
            
                # selection de joueur suivant
                if self.joueur_courant == joueur1: self.joueur_courant = joueur2
                else: self.joueur_courant = joueur1

            if self.plateau.est_gagnant(self.joueur_courant.pion):
                print("Partie terminée! Le joueur gagnant est: ", self.joueur_courant.nom)
                self.joueur_courant.nb_parties_gagnees = self.joueur_courant.nb_parties_gagnees + 1
            else:
                print("Partie nulle")
                self.nb_parties_nulles = self.nb_parties_nulles + 1
            print("Parties gagnées par ",  joueur1.nom,  " : ", joueur1.nb_parties_gagnees)
            print("Parties gagnées par ",  joueur2.nom,  " : ", joueur2.nb_parties_gagnees)
            print("Parties nulles: ", self.nb_parties_nulles)
            if input("Voulez-vous recommencer (O,N)?").upper() == 'N': break
            # reinitialisation de plateau
            self.plateau.initialiser()
            # joueur suivant
            if premier_joueur == joueur1: premier_joueur = joueur2
            else: premier_joueur = joueur1
            self.joueur_courant = premier_joueur
            

    def saisir_nombre(self, nb_min, nb_max):
        """
        Permet de demander à l'utilisateur un nombre et doit le valider.
        Ce nombre doit être une valeur entre nb_min et nb_max.
        Vous devez utiliser la méthode isnumeric() afin de vous assurer que l'utilisateur entre
        une valeur numérique et non pas une chaîne de caractères.
        Veuillez consulter l'exemple d'exécution du jeu mentionné dans l'énoncé du TP
        afin de savoir quoi afficher à l'utilisateur.

        Args:
            nb_min (int): Un entier représentant le minimum du nombre à entrer.
            nb_max (int): Un entier représentant le maximum du nombre à entrer.

        Returns:
            int: Le nombre saisi par l'utilisateur après validation.
        """
        assert isinstance(nb_min, int), "Partie: nb_min doit être un entier."
        assert isinstance(nb_max, int), "Partie: nb_max doit être un entier."

        while True:
            x = input('Entrer s.v.p un nombre entre {} et {}: ?'.format(nb_min, nb_max))
            if x.isnumeric() and int(x) in range(nb_min, nb_max+1): break
            print('***Valeur incorrecte!***.')
        return int(x)

    def demander_forme_pion(self):
        """
        Permet de demander à l'utilisateur un caractère et doit le valider.
        Ce caractère doit être soit 'O' soit 'X'.
        Veuillez consulter l'exemple d'exécution du jeu mentionné dans l'énoncé du TP
        afin de savoir quoi afficher à l'utilisateur.

        Returns:
            string: Le catactère saisi par l'utilisateur après validation.
        """
        while True:
            ch = input('Sélectionner s.v.p la forme de votre pion (X, O):? ')
            if ch.upper() in ('O', 'X'): return ch.upper()


    def demander_postion(self):
        """
        Permet de demander à l'utilisateur les coordonnées de la case qu'il veut jouer.
        Cette méthode doit valider ces coordonnées (ligne,colonne).
        Voici un exemple de ce qu'il faut afficher afin de demander cette position:

        Mondher : Entrez s.v.p. les coordonnées de la case à utiliser:
        Numéro de la ligne:Entrez s.v.p. un nombre entre 0 et 2:? 0
        Numéro de la colonne:Entrez s.v.p. un nombre entre 0 et 2:? 0

        Il faut utiliser la méthode saisir_nombre() et position_valide().

        Returns:
            (int,int):  Une paire d'entiers représentant les
                        coordonnées (ligne, colonne) de la case choisie.
        """
        while True:
            print(self.joueur_courant.nom, "Entrer s.v.p les coordonnées de la case à utiliser:")
            print("Numéro de la ligne:")
            ligne = self.saisir_nombre(0, 2)
            print("Numéro de la colonne:")
            colonne = self.saisir_nombre(0, 2)
            if self.plateau.position_valide(ligne, colonne): break
        return ligne, colonne
    
    def tour(self, choix):
        """
        Permet d'exécuter le tour d'un joueur (une personne ou un ordinateur).
        Cette méthode doit afficher le plateau (voir la méthode __str__() de la classe Plateau).
        Si le joueur courant est un ordinateur, il faut calculer la position de la prochaine
        case à jouer par cet ordinateur en utilisant la méthode choisir_prochaine_case().
        Si le joueur courant est une personne, il faut lui demander la position de la prochaine
        case qu'il veut jouer en utilisant la méthode demander_postion().
        Finalement, il faut utiliser la méthode selectionner_case() pour modifier le contenu
        de la case choisie soit par l'ordinateur soit par la personne.

        Args:
            choix (int): Un entier représentant le choix de l'utilisateur dans le menu du jeu (1 ou 2).
        """

        assert isinstance(choix, int), "Partie: choix doit être un entier."
        assert choix in [1, 2], "Partie: choix doit être 1 ou 2."
        # choix !!??

        print(self.plateau)
        if self.joueur_courant.type == 'Ordinateur':
            ligne, colonne = self.plateau.choisir_prochaine_case(self.joueur_courant.pion)
        else:
            ligne, colonne = self.demander_postion()

        self.plateau.selectionner_case(ligne, colonne, self.joueur_courant.pion)
Пример #6
0
class Partie:
    """
    Classe modélisant une partie du jeu Tic-Tac-Toe utilisant
    un plateau et deux joueurs (deux personnes ou une personne et un ordinateur).

    Attributes:
        plateau (Plateau): Le plateau du jeu contenant les 9 cases.
        joueurs (Joueur list): La liste des deux joueurs (initialement une liste vide).
        joueur_courant (Joueur): Le joueur courant (initialisé à une valeur nulle: None)
        nb_parties_nulles (int): Le nombre de parties nulles (aucun joueur n'a gagné).
    """
    def __init__(self):
        """
        Méthode spéciale initialisant une nouvelle partie du jeu Tic-Tac-Toe.
        """
        self.plateau = Plateau()  # Le plateau du jeu contenant les 9 cases.
        self.joueurs = [
        ]  # La liste des deux joueurs (initialement une liste vide).
        # Au début du jeu, il faut ajouter les deux joueurs à cette liste.
        self.joueur_courant = None  # Le joueur courant (initialisé à une valeur nulle: None)
        # Pendant le jeu et à chaque tour d'un joueur,
        # il faut affecter à cet attribut ce joueur courant.
        self.nb_parties_nulles = 0  # Le nombre de parties nulles (aucun joueur n'a gagné).

    def jouer(self):
        """
        Permet de démarrer la partie en commençant par l'affichage de ce texte:

        Bienvenue au jeu Tic Tac Toe.
        ---------------Menu---------------
        1- Jouer avec l'ordinateur.
        2- Jouter avec une autre personne.
        0- Quitter.
        -----------------------------------
        Entrez s.v.p. un nombre entre 0 et 2:?

        Cette méthode doit donc utiliser la méthode saisir_nombre().
        Elle doit par la suite demander à l'utilisateur les noms des joueurs.
        Veuillez utiliser 'Colosse' comme nom pour l'ordinateur.
        Il faut créer des instances de la classe Joueur et les ajouter à la liste joueurs.
        Il faut utiliser entre autres ces méthodes:
            *- demander_forme_pion(): pour demander au premier joueur la forme de son pion (X ou O).
              (Pas besoin de demander à l'autre joueur ou à l'ordinateur cela, car on peut le déduire).
            *- plateau.non_plein(): afin d'arrêter le jeu si le plateau est plein (partie nulle).
            *- tour(): afin d'exécuter le tour du joueur courant.
            *- plateau.est_gagnant(): afin de savoir si un joueur a gagné et donc arrêter le jeu.
        Il faut alterner entre le premier joueur et le deuxième joueur à chaque appel de tour()
        en utilisant l'attribut joueur_courant.
        Après la fin de chaque partie, il faut afficher les statistiques sur le jeu.
        Voici un exemple:

        Partie terminée! Le joueur gagnant est: Colosse
        Parties gagnées par Mondher : 2
        Parties gagnées par Colosse : 1
        Parties nulles: 1
        Voulez-vous recommencer (O,N)?

        Il ne faut pas oublier d'initialiser le plateau avant de recommencer le jeu.
        Si l'utilisateur ne veut plus recommencer, il faut afficher ce message:
        ***Merci et au revoir !***
        """

        print("Bienvenue au jeu Tic Tac Toe.")
        print("---------------Menu---------------")
        print("1- Jouer avec l'ordinateur.")
        print("2- Jouter avec une autre personne.")
        print("0- Quitter.")
        print("-----------------------------------")

        print("svp entrez votre choix")
        choix = self.saisir_nombre(0, 3)

        if (choix == 1):
            print("SVP entrer votre nom : ")
            nom = input()
            print(nom, " SVP entrer votre pion : ")
            pion = self.demander_forme_pion()
            joueur1 = Joueur(nom, "Personne", pion)
            self.joueurs.append(joueur1)

            if (joueur1.pion == "X"):
                joueur2 = Joueur("Colosse", "Ordinateur", "O")
                self.joueurs.append(joueur2)
            else:
                joueur2 = Joueur("Colosse", "Ordinateur", "X")
                self.joueurs.append(joueur2)

            self.joueur_courant = self.joueurs[0]
            rep = ""

            while (rep.upper() != "N"):
                self.plateau = Plateau()
                print(self.plateau.__str__())
                while (self.plateau.non_plein()):
                    self.tour(choix)
                    print(self.plateau.__str__())
                    print("*******************************************")
                    ok1 = self.plateau.est_gagnant(self.joueurs[0].pion)
                    ok2 = self.plateau.est_gagnant(self.joueurs[1].pion)
                    if ((ok1 == True) or (ok2 == True)):
                        break

                if ((ok1 == True) and (ok2 == False)):
                    self.joueurs[0].nb_parties_gagnees += 1
                    print("Partie terminée! Le joueur gagnant est: ",
                          self.joueurs[0].nom)
                    print("Parties gagnées par ", self.joueurs[0].nom, " : ",
                          self.joueurs[0].nb_parties_gagnees)
                    print("Parties gagnées par ", self.joueurs[1].nom, " : ",
                          self.joueurs[1].nb_parties_gagnees)
                    print("Parties nulles: ", self.nb_parties_nulles)
                    rep = input("Voulez-vous recommencer (O,N)? ")
                    while (rep.upper() not in ["O", "N"]):
                        print("Valeur Incorrect")
                        rep = input("Voulez-vous recommencer (O,N)? ")

                if ((ok1 == False) and (ok2 == True)):
                    self.joueurs[1].nb_parties_gagnees += 1
                    print("Partie terminée! Le joueur gagnant est: ",
                          self.joueurs[1].nom)
                    print("Parties gagnées par ", self.joueurs[0].nom, " : ",
                          self.joueurs[0].nb_parties_gagnees)
                    print("Parties gagnées par ", self.joueurs[1].nom, " : ",
                          self.joueurs[1].nb_parties_gagnees)
                    print("Parties nulles: ", self.nb_parties_nulles)
                    rep = input("Voulez-vous recommencer (O,N)? ")
                    while (rep.upper() not in ["O", "N"]):
                        print("Valeur Incorrect")
                        rep = input("Voulez-vous recommencer (O,N)? ")

                if ((ok1 == False) and (ok2 == False)):
                    self.nb_parties_nulles += 1
                    print("Partie terminée! Partie est nulle")
                    print("Parties gagnées par ", self.joueurs[0].nom, " : ",
                          self.joueurs[0].nb_parties_gagnees)
                    print("Parties gagnées par ", self.joueurs[1].nom, " : ",
                          self.joueurs[1].nb_parties_gagnees)
                    print("Parties nulles: ", self.nb_parties_nulles)
                    rep = input("Voulez-vous recommencer (O,N)? ")
                    while (rep.upper() not in ["O", "N"]):
                        print("Valeur Incorrect")
                        rep = input("Voulez-vous recommencer (O,N)? ")

        if (choix == 2):
            print("SVP entrer votre nom : ")
            nom = input()
            print(nom, " SVP entrer votre pion : ")
            pion = self.demander_forme_pion()
            joueur1 = Joueur(nom, "Personne", pion)
            self.joueurs.append(joueur1)
            print("Saisir nom de l'autre joueur ")
            nom2 = input()

            if (joueur1.pion == "X"):
                joueur2 = Joueur(nom2, "Personne", "O")
                self.joueurs.append(joueur2)
            else:
                joueur2 = Joueur(nom2, "Personne", "X")
                self.joueurs.append(joueur2)

            self.joueur_courant = self.joueurs[0]
            rep = ""
            while (rep.upper() != "N"):
                self.plateau = Plateau()
                print(self.plateau.__str__())
                while (self.plateau.non_plein()):
                    self.tour(choix)
                    print(self.plateau.__str__())
                    print("*******************************************")
                    ok1 = self.plateau.est_gagnant(self.joueurs[0].pion)
                    ok2 = self.plateau.est_gagnant(self.joueurs[1].pion)
                    if ((ok1 == True) or (ok2 == True)):
                        break

                if ((ok1 == True) and (ok2 == False)):
                    self.joueurs[0].nb_parties_gagnees += 1
                    print("Partie terminée! Le joueur gagnant est: ",
                          self.joueurs[0].nom)
                    print("Parties gagnées par ", self.joueurs[0].nom, " : ",
                          self.joueurs[0].nb_parties_gagnees)
                    print("Parties gagnées par ", self.joueurs[1].nom, " : ",
                          self.joueurs[1].nb_parties_gagnees)
                    print("Parties nulles: ", self.nb_parties_nulles)
                    rep = input("Voulez-vous recommencer (O,N)? ")
                    while (rep.upper() not in ["O", "N"]):
                        print("Valeur Incorrect")
                        rep = input("Voulez-vous recommencer (O,N)? ")

                if ((ok1 == False) and (ok2 == True)):
                    self.joueurs[1].nb_parties_gagnees += 1
                    print("Partie terminée! Le joueur gagnant est: ",
                          self.joueurs[0].nom)
                    print("Parties gagnées par ", self.joueurs[0].nom, " : ",
                          self.joueurs[0].nb_parties_gagnees)
                    print("Parties gagnées par ", self.joueurs[1].nom, " : ",
                          self.joueurs[1].nb_parties_gagnees)
                    print("Parties nulles: ", self.nb_parties_nulles)
                    rep = input("Voulez-vous recommencer (O,N)? ")
                    while (rep.upper() not in ["O", "N"]):
                        print("Valeur Incorrect")
                        rep = input("Voulez-vous recommencer (O,N)? ")

                if ((ok1 == False) and (ok2 == False)):
                    self.nb_parties_nulles += 1
                    print("Partie terminée! Partie est Nulle")
                    print("Parties gagnées par ", self.joueurs[0].nom, " : ",
                          self.joueurs[0].nb_parties_gagnees)
                    print("Parties gagnées par ", self.joueurs[1].nom, " : ",
                          self.joueurs[1].nb_parties_gagnees)
                    print("Parties nulles: ", self.nb_parties_nulles)
                    rep = input("Voulez-vous recommencer (O,N)? ")
                    while (rep.upper() not in ["O", "N"]):
                        print("Valeur Incorrect")
                        rep = input("Voulez-vous recommencer (O,N)? ")

        else:

            print("Merci Au revoir")

    def saisir_nombre(self, nb_min, nb_max):
        """
        Permet de demander à l'utilisateur un nombre et doit le valider.
        Ce nombre doit être une valeur entre nb_min et nb_max.
        Vous devez utiliser la méthode isnumeric() afin de vous assurer que l'utilisateur entre
        une valeur numérique et non pas une chaîne de caractères.
        Veuillez consulter l'exemple d'exécution du jeu mentionné dans l'énoncé du TP
        afin de savoir quoi afficher à l'utilisateur.

        Args:
            nb_min (int): Un entier représentant le minimum du nombre à entrer.
            nb_max (int): Un entier représentant le maximum du nombre à entrer.

        Returns:
            int: Le nombre saisi par l'utilisateur après validation.
        """
        assert isinstance(nb_min, int), "Partie: nb_min doit être un entier."
        assert isinstance(nb_max, int), "Partie: nb_max doit être un entier."

        nb = input()

        while ((nb.isnumeric() == False)
               or (int(nb) not in range(nb_min, nb_max))):
            print("******Valeur Incorrecte********")
            nb = input()

        return int(nb)

    def demander_forme_pion(self):
        """
        Permet de demander à l'utilisateur un caractère et doit le valider.
        Ce caractère doit être soit 'O' soit 'X'.
        Veuillez consulter l'exemple d'exécution du jeu mentionné dans l'énoncé du TP
        afin de savoir quoi afficher à l'utilisateur.

        Returns:
            string: Le catactère saisi par l'utilisateur après validation.
        """

        pion = input()

        while (pion.upper() not in ["O", "X"]):
            print("******Valeur Incorrecte********")
            pion = input()

        return pion.upper()

    def tour(self, choix):
        """
        Permet d'exécuter le tour d'un joueur (une personne ou un ordinateur).
        Cette méthode doit afficher le plateau (voir la méthode __str__() de la classe Plateau).
        Si le joueur courant est un ordinateur, il faut calculer la position de la prochaine
        case à jouer par cet ordinateur en utilisant la méthode choisir_prochaine_case().
        Si le joueur courant est une personne, il faut lui demander la position de la prochaine
        case qu'il veut jouer en utilisant la méthode demander_postion().
        Finalement, il faut utiliser la méthode selectionner_case() pour modifier le contenu
        de la case choisie soit par l'ordinateur soit par la personne.

        Args:
            choix (int): Un entier représentant le choix de l'utilisateur dans le menu du jeu (1 ou 2).
        """

        assert isinstance(choix, int), "Partie: choix doit être un entier."
        assert choix in [1, 2], "Partie: choix doit être 1 ou 2."

        if (int(choix) == 1):
            if (self.joueur_courant == self.joueurs[0]):
                print(
                    self.joueur_courant.nom,
                    " : Entrez s.v.p. les coordonnées de la case à utiliser: ")
                ligne, colonne = self.demander_position()
                self.plateau.selectionner_case(ligne, colonne,
                                               self.joueur_courant.pion)
                self.joueur_courant = self.joueurs[1]
            else:
                ligne, colonne = self.plateau.choisir_prochaine_case(
                    self.joueur_courant.pion)
                self.plateau.selectionner_case(ligne, colonne,
                                               self.joueur_courant.pion)
                self.joueur_courant = self.joueurs[0]

        else:
            if (self.joueur_courant == self.joueurs[0]):
                print(
                    self.joueur_courant.nom,
                    " : Entrez s.v.p. les coordonnées de la case à utiliser: ")
                ligne, colonne = self.demander_position()
                self.plateau.selectionner_case(ligne, colonne,
                                               self.joueur_courant.pion)
                self.joueur_courant = self.joueurs[1]
            else:

                print(
                    self.joueur_courant.nom,
                    " : Entrez s.v.p. les coordonnées de la case à utiliser: ")
                ligne, colonne = self.demander_position()
                self.plateau.selectionner_case(ligne, colonne,
                                               self.joueur_courant.pion)
                self.joueur_courant = self.joueurs[0]

    def demander_position(self):
        """
        Permet de demander à l'utilisateur les coordonnées de la case qu'il veut jouer.
        Cette méthode doit valider ces coordonnées (ligne,colonne).
        Voici un exemple de ce qu'il faut afficher afin de demander cette position:

        Mondher : Entrez s.v.p. les coordonnées de la case à utiliser:
        Numéro de la ligne:Entrez s.v.p. un nombre entre 0 et 2:? 0
        Numéro de la colonne:Entrez s.v.p. un nombre entre 0 et 2:? 0

        Il faut utiliser la méthode saisir_nombre() et position_valide().

        Returns:
            (int,int):  Une paire d'entiers représentant les
                        coordonnées (ligne, colonne) de la case choisie.
        """
        print("Numéro de la ligne:Entrez s.v.p. un nombre entre 0 et 2:? ")
        ligne = self.saisir_nombre(0, 3)
        print("Numéro de la colonne:Entrez s.v.p. un nombre entre 0 et 2:? ")
        colonne = self.saisir_nombre(0, 3)

        while (self.plateau.position_valide(int(ligne),
                                            int(colonne)) == False):
            print("Position Occupé")
            print("Numéro de la ligne:Entrez s.v.p. un nombre entre 0 et 2:? ")
            ligne = self.saisir_nombre(0, 3)
            print(
                "Numéro de la colonne:Entrez s.v.p. un nombre entre 0 et 2:? ")
            colonne = self.saisir_nombre(0, 3)

        return (int(ligne), int(colonne))
class Partie:
    """
    Classe modélisant une partie du jeu Tic-Tac-Toe utilisant
    un plateau et deux joueurs (deux personnes ou une personne et un ordinateur).

    Attributes:
        plateau (Plateau): Le plateau du jeu contenant les 9 cases.
        joueurs (Joueur list): La liste des deux joueurs (initialement une liste vide).
        joueur_courant (Joueur): Le joueur courant (initialisé à une valeur nulle: None)
        nb_parties_nulles (int): Le nombre de parties nulles (aucun joueur n'a gagné).
    """

    def __init__(self):
        """
        Méthode spéciale initialisant une nouvelle partie du jeu Tic-Tac-Toe.
        """
        self.plateau = Plateau()    # Le plateau du jeu contenant les 9 cases.
        self.joueurs = []       # La liste des deux joueurs (initialement une liste vide).
                                # Au début du jeu, il faut ajouter les deux joueurs à cette liste.
        self.joueur_courant = None  # Le joueur courant (initialisé à une valeur nulle: None)
                                    # Pendant le jeu et à chaque tour d'un joueur,
                                    # il faut affecter à cet attribut ce joueur courant.
        self.nb_parties_nulles = 0  # Le nombre de parties nulles (aucun joueur n'a gagné).

    def jouer(self):
        """
        Permet de démarrer la partie en commençant par l'affichage de ce texte:

        Bienvenue au jeu Tic Tac Toe.
        ---------------Menu---------------
        1- Jouer avec l'ordinateur.
        2- Jouer avec une autre personne.
        0- Quitter.
        -----------------------------------
        Entrez s.v.p. un nombre entre 0 et 2:?

        Cette méthode doit donc utiliser la méthode saisir_nombre().
        Elle doit par la suite demander à l'utilisateur les noms des joueurs.
        Veuillez utiliser 'Colosse' comme nom pour l'ordinateur.
        Il faut créer des instances de la classe Joueur et les ajouter à la liste joueurs.
        Il faut utiliser entre autres ces méthodes:
            *- demander_forme_pion(): pour demander au premier joueur la forme de son pion (X ou O).
              (Pas besoin de demander à l'autre joueur ou à l'ordinateur cela, car on peut le déduire).
            *- plateau.non_plein(): afin d'arrêter le jeu si le plateau est plein (partie nulle).
            *- tour(): afin d'exécuter le tour du joueur courant.
            *- plateau.est_gagnant(): afin de savoir si un joueur a gagné et donc arrêter le jeu.
        Il faut alterner entre le premier joueur et le deuxième joueur à chaque appel de tour()
        en utilisant l'attribut joueur_courant.
        Après la fin de chaque partie, il faut afficher les statistiques sur le jeu.
        Voici un exemple:

        Partie terminée! Le joueur gagnant est: Colosse
        Parties gagnées par Mondher : 2
        Parties gagnées par Colosse : 1
        Parties nulles: 1
        Voulez-vous recommencer (O,N)?

        Il ne faut pas oublier d'initialiser le plateau avant de recommencer le jeu.
        Si l'utilisateur ne veut plus recommencer, il faut afficher ce message:
        ***Merci et au revoir !***
        """
        print("Bienvenue au jeu Tic Tac Toe.")
        print("---------------Menu---------------")
        print("1- Jouer avec l'ordinateur.")
        print("2- Jouer avec une autre personne.")
        print("0- Quitter.")
        print("-----------------------------------")
        
        valeur=self.saisir_nombre(0,2)  
        # print(valeur)
        if valeur==0:
            print(end=' ')
        elif(valeur==1):
            nom=input("Entrez s.v.p votre Nom:?")
            pion=self.demander_forme_pion()
            self.joueurs.append(Joueur(nom,'Personne',pion))
            if pion=='O':
                self.joueurs.append(Joueur('Colosse','Ordinateur','X'))
            else:
                self.joueurs.append(Joueur('Colosse','Ordinateur','O'))
        elif(valeur==2):
            nom=input("Entrez s.v.p votre Nom:? ")
            pion=self.demander_forme_pion()
            self.joueurs.append(Joueur(nom,'Personne',pion))
            nom2=input("Entrez s.v.p le Nom de l'autre Joueur:? ")
            if pion=='O':
                self.joueurs.append(Joueur(nom2,'Personne','X'))
            else:
                self.joueurs.append(Joueur(nom2,'Personne','O'))
        recommencer='O'
        while(recommencer=='O' and valeur!=0):
            while(self.plateau.non_plein()==True and self.plateau.est_gagnant('O')==False and self.plateau.est_gagnant('X')==False):
                self.joueur_courant=self.joueurs[0]
                self.tour(valeur)
                if self.plateau.non_plein()==True and self.plateau.est_gagnant(self.joueurs[0].pion)==False :
                    self.joueur_courant=self.joueurs[1]
                    self.tour(valeur)
            print(self.plateau)
            if self.plateau.non_plein()==False:
                self.nb_parties_nulles+=1
                print("Partie Terminée! Aucun joueur n'a gagné!!")
            elif self.plateau.est_gagnant(self.joueurs[0].pion)==True:
                self.joueurs[0].nb_parties_gagnees+=1
                print("Partie Terminée! le joueur gagnant est:",self.joueurs[0].nom)
            elif self.plateau.est_gagnant(self.joueurs[1].pion)==True:
                self.joueurs[1].nb_parties_gagnees+=1
                print("Partie Terminée! le joueur gagnant est:",self.joueurs[1].nom)
            print("Partie gagnée par",self.joueurs[1].nom,":",self.joueurs[1].nb_parties_gagnees)
            print("Partie gagnée par",self.joueurs[0].nom,":",self.joueurs[0].nb_parties_gagnees)
            print("Parties nulles",self.nb_parties_nulles)
            recommencer=input("Voulez-vous recommencer (O,N)")
            while(recommencer != 'O' and recommencer != 'N'):
                recommencer=input("Tapez O si Voulez-vous recommencer, Sinon Tapez N: ")
            if(recommencer=='O'):
                self.plateau.initialiser()
        print("***merci et au revoir!*** ")   

    def saisir_nombre(self, nb_min, nb_max):
        """
        Permet de demander à l'utilisateur un nombre et doit le valider.
        Ce nombre doit être une valeur entre nb_min et nb_max.
        Vous devez utiliser la méthode isnumeric() afin de vous assurer que l'utilisateur entre
        une valeur numérique et non pas une chaîne de caractères.
        Veuillez consulter l'exemple d'exécution du jeu mentionné dans l'énoncé du TP
        afin de savoir quoi afficher à l'utilisateur.

        Args:
            nb_min (int): Un entier représentant le minimum du nombre à entrer.
            nb_max (int): Un entier représentant le maximum du nombre à entrer.

        Returns:
            int: Le nombre saisi par l'utilisateur après validation.
        """
        assert isinstance(nb_min, int), "Partie: nb_min doit être un entier."
        assert isinstance(nb_max, int), "Partie: nb_max doit être un entier."
        x=input("Entrez s.v.p un nombre entre 0 et 2:? ")
        while(x.isnumeric()==False or int(x)<0 or int(x)>2  ):
           print("***valeur incorrecte!*** ")
           x=input("Entrez s.v.p un nombre entre 0 et 2:? ")
        return(int(x))

        #pass

    def demander_forme_pion(self):
        """
        Permet de demander à l'utilisateur un caractère et doit le valider.
        Ce caractère doit être soit 'O' soit 'X'.
        Veuillez consulter l'exemple d'exécution du jeu mentionné dans l'énoncé du TP
        afin de savoir quoi afficher à l'utilisateur.

        Returns:
            string: Le catactère saisi par l'utilisateur après validation.
        """
        forme=input("Sélectionner s.v.p la forme de votre pion (X,O):?")
        while(forme!='X' and forme!='O'):
            forme=input("Sélectionner s.v.p la forme de votre pion (X,O):?")
        return(forme)
        # pass

    def tour(self, choix):
        """
        Permet d'exécuter le tour d'un joueur (une personne ou un ordinateur).
        Cette méthode doit afficher le plateau (voir la méthode __str__() de la classe Plateau).
        Si le joueur courant est un ordinateur, il faut calculer la position de la prochaine
        case à jouer par cet ordinateur en utilisant la méthode choisir_prochaine_case().
        Si le joueur courant est une personne, il faut lui demander la position de la prochaine
        case qu'il veut jouer en utilisant la méthode demander_postion().
        Finalement, il faut utiliser la méthode selectionner_case() pour modifier le contenu
        de la case choisie soit par l'ordinateur soit par la personne.

        Args:
            choix (int): Un entier représentant le choix de l'utilisateur dans le menu du jeu (1 ou 2).
        """

        assert isinstance(choix, int), "Partie: choix doit être un entier."
        assert choix in [1, 2], "Partie: choix doit être 1 ou 2."
        print(self.plateau)
        if choix==1:
            if self.joueur_courant.type=="Personne":
                pos=self.demander_postion()
                self.plateau.selectionner_case(pos[0],pos[1],self.joueurs[0].pion)
                #print(self.plateau)
            elif self.joueur_courant.type=="Ordinateur":
                print("C'est le Tour maintenant de l'ordinateur Colosse!")
                prochaine=self.plateau.choisir_prochaine_case(self.joueurs[1].pion)
                self.plateau.selectionner_case(prochaine[0],prochaine[1],self.joueurs[1].pion)
                #print(self.plateau)
        else:
            pos=self.demander_postion()
            self.plateau.selectionner_case(pos[0],pos[1],self.joueur_courant.pion)

            

        #pass

    def demander_postion(self):
        """
        Permet de demander à l'utilisateur les coordonnées de la case qu'il veut jouer.
        Cette méthode doit valider ces coordonnées (ligne,colonne).
        Voici un exemple de ce qu'il faut afficher afin de demander cette position:

        Mondher : Entrez s.v.p. les coordonnées de la case à utiliser:
        Numéro de la ligne:Entrez s.v.p. un nombre entre 0 et 2:? 0
        Numéro de la colonne:Entrez s.v.p. un nombre entre 0 et 2:? 0

        Il faut utiliser la méthode saisir_nombre() et position_valide().

        Returns:
            (int,int):  Une paire d'entiers représentant les
                        coordonnées (ligne, colonne) de la case choisie.
        """
        
        print(self.joueur_courant.nom,": Entrez s.v.p. les coordonnées de la case à utiliser:")
        print("Numéro de la ligne:",end=' ')
        i=self.saisir_nombre(0,2)
        print("Numéro de la Colonne:",end=' ')
        j=self.saisir_nombre(0,2)
        while(self.plateau.position_valide(i,j)==False):
            print(self.joueur_courant.nom,":cette position est occuper Entrez s.v.p. d'autre coordonnées:")
            print("Numéro de la ligne:",end=' ')
            i=self.saisir_nombre(0,2)
            print("Numéro de la Colonne:",end=' ')
            j=self.saisir_nombre(0,2)   
        l=[i,j]
        return(l)