table_de_jeu.py

#auteur : Théo

from pieces import Piece, Montagne, Animal, Elephant, Rhinoceros
from joueur import Joueur, Theo, Pauline,IA

"""
Ce module contient la définition de la classe principale servant à gérer le jeu
"""

class Plateau(list):
    """
        Classe gérant le déroulement du jeu.
        Classe décrivant le tableau de jeu, qui est une liste contentant les différentes pièces
        """

    def __init__(self, xmax=5, ymax=5, nb_montagne=3, joueur1=Theo, joueur2=Pauline):
        """
                    On crée un tableau de jeu aux dimensions désirées, avec un nombre de montagne choisi.
                    Les règles de Siam imposent que xmax et ymax soient égaux à 5

                    Paramètres
                        ----------
                    xmax, ymax: int
                        Largeur et longueur du plateau, normalement tout les deux égaux à 5
                        xmax=ymax car le plateau est carré

                    nb_montagne: int
                        nomalement initié à 3 montagnes sur le plateau en début de jeu


                    joueur1,  joueur2: joueurs importés de 'joueur'
                    Joueurs disponibles: 'Theo' qui doit jouer les Elephants,'Pauline' qui doit jouer les Rhinoceros,
                                            'IA' qui doit jouer les Rhinoceros

                    Par ailleurs,
                    self.ele, self.mont et self.rhino sont des listes qui stockeront l'état des pièces avant de les afficher
                    sur le plateau de jeu avec la méthode unTour


        """

        self.xmax = xmax
        self.ymax = ymax
        self.nb_montagne = nb_montagne
        self.ele = []
        self.mont=[]
        self.rhino = []
        self.joueur1=joueur1
        self.joueur2=joueur2
        self.partie_finie=False   # permet de savoir si la partie est finie ou non. Il devient True si une montagne sort

        f = open("historique des parties.txt", mode="w") #on ouvre le fichier de sauvegarde en mode write pour écraser la partie d'avant
        f.write('NOUVELLE PARTIE \n \n')
        f.close()



    def __str__(self):

        """
        Affiche le plateau de jeu en mode texte suivant les caractères définis
        dans les sous classes de ''Piece''.

        Paramètres
        ----------
        Aucun

        Renvoie
        -------
        s: string
            La chaîne de caractères qui sera affichée via ''print'', représentant le plateau de jeu


        """
        pos = {}
        for piece in self:
            pos[piece.coords[0],piece.coords[1]] = (piece.nom+piece.orientation) #une piece est représentée par son nom et son orientation
        s = ""
        for j in range(self.ymax):
            for i in range(-2,7):
                if (i, j) in pos:
                    s += pos[(i, j)]+'  '
                else:
                    s += ".    " #les cases vides sont représentées par des points
            s += "\n"
        return s




    def initialiserPlateau(self):
        """
        initialisation du plateau : toutes les cases sont vides sauf 3 au centre, où se trouvent les montagnes.
        On crée également les 5 Elephants et les 5 Rhinoceros que l'on disposera à l'extérieur du plateau, dans leurs
        positions et orientations initiales


        Comme dit précédemment, on crée ces Pieces dans les listes self.ele, self.rhino et self.mont, puis on les
        affichera sur le plateau avec la méthode 'unTour'

        """


        midx, midy=self.xmax//2, self.ymax//2  # indices de la case correspondant au centre du plateau
        for k in range(self.nb_montagne):  # place les montagnes un à un, en colonne, au milieu du plateau
            self.mont.append( Montagne (  midx,midy+k-self.nb_montagne//2,'0 ',self)) #la montagne n'a pas d'orientation particulière


        for k in range(5):
            self.ele.append(Elephant(6, k, 'g', self)) #on crée les 5 elephants que l'on oriente vers la gauche et que l'on
                                                        #place à droite du plateau

            self.rhino.append(Rhinoceros(-2, k, 'd', self))#on crée les 5 rhinoceros que l'on oriente vers la droite et que l'on
                                                            #   place à gauche du plateau




    def unTour(self):
        """
        Permet de mettre à jour les pieces sur le plateau
        On commence par supprimer toutes les pièces du plateau, avant de remettre les pièces à jour, qui se trouvent
        dans les listes self.ele, sekf.rhino et self. mont"""


        for i in (self): # on efface tout le plateau  pour mettre à jour
            del(i)
        for i in (self.mont):
            self.append(i)
        for i in (self.ele):
            self.append(i)
        for i in (self.rhino):
            self.append(i)

    def vainqueur(self):
        """
        Méthode permettant de savoir s'il y a un vainqueur ou non
        on regarde d'abord si les montagnes sont sorties du plateau
        si c'est la cas, alors ono distingue 4 cas: sortie vers le hait, le bas, la gauche ou la droite du plateau
        Enfin, on détermine le vainqueur qui est le joueur qui est le plus proche du rocher et dans le même sens de poussée

        """
        bool=False
        for m in self.mont: #on passe en revue toutes les montagnes

            if m.coords[0]==-1: #la montagne est sortie du plateau, à gauche
                while bool==False: # tant qu'on n'a pas trouvé le vainqueur
                    for i in range (1,5):
                        for piece in self:
                            if piece.coords[0]==m.coords[0]+i and piece.coords[1]==m.coords[1] and piece.orientation=='g':
                                #on commence par étudier la piece à droite de la montagne: si les conditions sont vérifiées pour
                                #gagner, alors on a trouvé le gagnant. Sinon on prend la piece encore à droite et on
                                #cherche à vérifier les conditions, etc
                                winner=piece    #c'est la piece gagnante
                                bool=True
                                self.partie_finie=True
                                break

            if m.coords[0]==5: #la montagne est sortie du plateau, à droite
                while bool==False: #tant qu'on n'a pas trouvé le vainqueur
                    for i in range (1,5):
                        for piece in self:
                            if piece.coords[0]==m.coords[0]-i and piece.coords[1]==m.coords[1] and piece.orientation=='d':
                                #de même, le vainqueur se trouve dans les pieces situées à gauche de la montagne
                                winner=piece
                                bool=True
                                self.partie_finie = True
                                break

            if m.coords[1]==-1: #la montagne est sortie du plateau,en haut
                while bool==False: #tant qu'on n'a pas trouvé le vainqueur
                    for i in range (1,5):
                        for piece in self:
                            if piece.coords[1]==m.coords[1]+i and piece.coords[0]==m.coords[0] and piece.orientation=='h':
                                # de même, le vainqueur se trouve dans les pieces situées en bas de la montagne
                                winner=piece
                                bool=True
                                self.partie_finie = True

                                break

            if m.coords[1]==5: #la montagne est sortie du plateau, en bas
                while bool==False: #tant qu'on n'a pas trouvé le vainqueur
                    for i in range (1,5):
                        for piece in self:
                            if piece.coords[1]==m.coords[1]-i and piece.coords[0]==m.coords[0] and piece.orientation=='b':
                                # de même, le vainqueur se trouve dans les pieces situées en haut de la montagne
                                winner=piece
                                bool=True
                                self.partie_finie = True
                                break # pour arréter dans le for





            if bool==True and winner.car()=='R': #si la piece gagnante est un rhinoceros
                print('la partie est finie, le vainqueur est', self.joueur2(self).nom) #alors elle appartient au joueur 2, qui gagne la partie
                f = open("historique des parties.txt", mode="a") #on note cela dans le fichier
                f.write('la partie est finie, le vainqueur est {0} \n \n \n \n'.format( self.joueur2(self).nom))
                f.close()



            if bool== True and winner.car()=='E' : #de même si la pièce est un elephant
                print ('partie finie, le vainqueur est', self.joueur1(self).nom)
                f = open("historique des parties.txt", mode="a")
                f.write('la partie est finie, le vainqueur est {0} \n \n \n \n '.format(self.joueur1(self).nom))
                f.close()


    def jouer(self):
        """
        c'est cette fonction qui lance vraiment le jeu
        On initialise d'abord le plateau
        Puis tant qu'il n'y a pas de joueur, on fait jouer le joueur 1 puis le joueur2, en vérifiant à chaque fois
        s'il n'y a pas un gagnant, et en affichant le plateau de jeu


        """

        self.initialiserPlateau()

        bool=True #bool ne devient jamais False: le programme tourne à l'infini à priori. En réalité, le jeu s'arrête
                    # s'il y a un gagnant, grâce à un break

        while bool:
            self.unTour() # remet le plateau a jour
            print(self) # on affiche le plateau

            print('c est au tour du joueur',self.joueur1(self).description)
            self.joueur1(self).a_son_tour() # le joueur 1 indique le coup qu'il veut faire et la piece à déplacer

            self.unTour()#remet à jour le plateau
            self.vainqueur() # on vérifie si partie finie
            if self.partie_finie: #devient true si une montagne est sortie
                break  # le jeu s'arrete
            print(self)





            print('c est au tour du joueur', self.joueur2(self).description) #même principe, mais cette fois c'est au tour du joueur 2
            self.joueur2(self).a_son_tour()
            self.unTour()
            self.vainqueur()
            if self.partie_finie:
                break




if __name__ == "__main__":
    plateau = Plateau(xmax=5, ymax=5, nb_montagne=3, joueur1=Theo, joueur2=IA)  # c'est ici qu'on  choisit les joueurs
    Plateau.jouer(plateau)