appli2.py

# auteur : Pauline

from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
import sys
import time
import numpy as np

from pieces import Piece, Montagne, Animal, Elephant, Rhinoceros
from table_de_jeu import Plateau
#from QDialog import InfoDialog
import random


class Window(QMainWindow):
    """
            Classe créant l'IHM. Nous ne nous sommes pas servis de l'application Qt designer, car créer chaque
            widgzt nous même semblait plus simple pour comprendre ce que nous faisions
            Néanmois, en cnséquence le code est très long
            """

    def __init__(self):
        super().__init__()

        """
                        On crée toutes les variables dont nous auront besoin.
                        """

        self.setWindowTitle("Jeu de Siam") #on crée la fenêtre où aura lieu le jeu
        self.setGeometry(0, 0, 1500, 1000) #on choisit sa position et sa taille

        # self.jeux =Plateau(xmax=5, ymax=5, nb_montagne=3, joueur1='Theo', joueur2='Pauline')
        # self.jeux.initialiserPlateau()

        self.txt='' # récupère le texte mis dans la boite de dialogue, il servira pour savoir comment le joueur souhaite orienter sa pièce 


        #création des boutons qu'on associera aux fonctions
        # les boutons joueurs 1/2 permettent d'associer la bonne liste de pions (éléphants ou rhino)
        # à l'appel des fonctions
        button_joueur1 = QPushButton("joueur1", self) # définit le bouton et son nom
        button_joueur1.setGeometry(720, 0, 100, 50) # défini sa position et sa taille
        button_joueur1.clicked.connect(self.joueur1) # lie l'action de cliquer sur le bouton à l'appel de la fonction citée

        button_joueur2 = QPushButton("joueur2", self)
        button_joueur2.setGeometry(720, 70, 100, 50)
        button_joueur2.clicked.connect(self.joueur2)

        #on définit les boutons liés aux fonctions
        button_entrer = QPushButton("entrer", self)
        button_entrer.setGeometry(50, 600, 100, 50)
        button_entrer.clicked.connect(self.entrer)

        button_tourne = QPushButton("tourne", self)
        button_tourne.setGeometry(170, 600, 100, 50)
        button_tourne.clicked.connect(self.tourne)

        button_deplacer = QPushButton("déplacer", self)
        button_deplacer.setGeometry(290, 600, 100, 50)
        button_deplacer.clicked.connect(self.deplacer)

        button_sortir = QPushButton("sortir", self)
        button_sortir.setGeometry(410, 600, 100, 50)
        button_sortir.clicked.connect(self.sortir)

        button_pousser = QPushButton("pousser", self)
        button_pousser.setGeometry(530, 600, 100, 50)
        button_pousser.clicked.connect(self.pousser)

        button_entrerp = QPushButton("entrer en poussant", self)
        button_entrerp.setGeometry(650, 600, 150, 50)
        button_entrerp.clicked.connect(self.entrerp)
        
        # permet de décomposer l'action: en appuyant sur une fonction, on connait quel pion est sélectionné,
        # c'est en appuyant sur ok que l'action se passe (sauf pour tourne)
        button_deplacerok = QPushButton("ok", self)
        button_deplacerok.setGeometry(720, 200, 100, 50)
        button_deplacerok.clicked.connect(self.ok)


        self.scene = QGraphicsScene(self) #création de la scène, ou résidera le plateau et les pions
        self.zone_txt = QGraphicsScene(self) # création de la scène qui contiendra le texte décrivant les instructions pour jouer


        plateau = QPixmap('plateau9x7.PNG') #on importe l'image du plateau
        #il est composé de 7 lignes et 9 colonnes. le plateau ou le jeu a lieux est de 5X5 mais tout le tour
        # nous servira à placer les pions que l'on veut entrer en poussant, et les deux colonnes supplémentaires
        # sur les cotés permettent de stocker les pions qui sont hors du plateau
        # la case en haut à gauche à pour coordonnées (-2, -1)
        label = QLabel(self)
        label.setPixmap(plateau)
        self.p = plateau.scaled(600, 700*2/3, Qt.KeepAspectRatio) # on change sa taille
        self.scene.addPixmap(self.p) # et on la met dans la scène



        rhino = QBrush(Qt.green) # les rhino seront représentés en vert
        elephants = QBrush(Qt.blue) # et les éléphants en vert ( pour les différencier)
        montagne = QBrush(Qt.black) # les montagnes en noir
        blackPen = QPen(Qt.black) # pour dessiner le tour des montagnes
        blackPen.setWidth(5) #épaisseur du tour
        # origine première case en haut à gauche (12, 12)

        # création des pions QT rhinos en vert:
        #on va faire 5 fois la même chose, uniquement en changeant leur nom et leurs position initiale
        # expérimentalement, on trouve que pour se placer dans la case en haut à gauche, il faut donner
        # au coordonnées du point en haut a gauche du pion, les coordonnées 12, 12
        # pour se déplacer d'une case vers la droite ou en bas, il faut ajouter 65,5 aux coordonnées

        self.rh1 = QGraphicsRectItem(12, 77.5, 50, 50) # création du premier rhino, aux coordonnées tel que le pion entre dans la
                                                       # case [-2, 0]
        self.rh1.setBrush(rhino) # on définit la couleur de la pièce
        txt_rh1 = QGraphicsTextItem('R1', parent = self.rh1) # on ajoute un texte sur la pièce afin que le joueur sache quel pièce il joue
        txt_rh1.setPos(self.rh1.mapToScene(self.rh1.rect().center()))
        self.ori_rh1 = QGraphicsRectItem(12+50*9/10, 77.5 + 50*3/10, 20, 20, parent = self.rh1) #définit la tête et donc l'orientation
        # création de "têtes" : ont cré des plus petits carrés qui représenteront les têtes des animaux afin de connaitre leur orientation
        #on lui impose comme parent le grand carré (corps) pour qu'ils soient liés
        # la position de la tête est alors calculée par rapport au carré (origine en haut à gauche du corps)
        self.ori_rh1.setBrush(rhino)
        self.scene.addItem(self.rh1) #on ajoute le pion à la scène
        self.rh1.setFlag(QGraphicsRectItem.ItemIsSelectable) # permet de reconnaitre si le pion est sélectionné
        # on ajoute de 65.5 en y pour baisser d'une case

        self.rh2 = QGraphicsRectItem(12,143, 50, 50)
        self.rh2.setBrush(rhino)
        txt_rh2 = QGraphicsTextItem('R2', parent = self.rh2)
        txt_rh2.setPos(self.rh2.mapToScene(self.rh2.rect().center()))
        self.ori_rh2 = QGraphicsRectItem(12+50*9/10, 143 + 50*3/10, 20, 20, parent = self.rh2)
        self.ori_rh2.setBrush(rhino)
        self.scene.addItem(self.rh2)
        self.rh2.setFlag(QGraphicsRectItem.ItemIsSelectable)

        self.rh3 = QGraphicsRectItem(12,208.5, 50, 50)
        self.rh3.setBrush(rhino)
        txt_rh3 = QGraphicsTextItem('R3', parent = self.rh3)
        txt_rh3.setPos(self.rh3.mapToScene(self.rh3.rect().center()))
        self.ori_rh3 = QGraphicsRectItem(12+50*9/10, 208.5 + 50*3/10, 20, 20, parent = self.rh3)
        self.ori_rh3.setBrush(rhino)
        self.scene.addItem(self.rh3)
        self.rh3.setFlag(QGraphicsRectItem.ItemIsSelectable)

        self.rh4 = QGraphicsRectItem(12, 274, 50, 50)
        self.rh4.setBrush(rhino)
        txt_rh4 = QGraphicsTextItem('R4', parent=self.rh4)
        txt_rh4.setPos(self.rh4.mapToScene(self.rh4.rect().center()))
        self.ori_rh4 = QGraphicsRectItem(12 + 50 * 9 / 10, 274 + 50 * 3 / 10, 20, 20, parent=self.rh4)
        self.ori_rh4.setBrush(rhino)
        self.scene.addItem(self.rh4)
        self.rh4.setFlag(QGraphicsRectItem.ItemIsSelectable)

        self.rh5 = QGraphicsRectItem(12, 339.5, 50, 50)
        self.rh5.setBrush(rhino)
        txt_rh5 = QGraphicsTextItem('R5', parent=self.rh5)
        txt_rh5.setPos(self.rh5.mapToScene(self.rh5.rect().center()))
        self.ori_rh5 = QGraphicsRectItem(12 + 50 * 9 / 10, 339.5 + 50 * 3 / 10, 20, 20, parent=self.rh5)
        self.ori_rh5.setBrush(rhino)
        self.scene.addItem(self.rh5)

        self.rh5.setFlag(QGraphicsRectItem.ItemIsSelectable)
        # le pion est dans la case (i, j) si il est à la position (12 + (i+2)*65.5, 12 + (j+1)*65.5)
        # car on commence en haut à gauche aux coordonnées (-2,-1)

        self.liste_rh_qg = [self.rh1, self.rh2, self.rh3, self.rh4, self.rh5] # liste regroupant les rhinos en ihm : nous servira pour
        #appeler un pion que l'on veut déplacer par exemple

        self.liste_rh_ori_qg = [self.ori_rh1, self.ori_rh2, self.ori_rh3, self.ori_rh4, self.ori_rh5] #liste regroupant les tête des rhinos en ihm
        #servira pour le changement d'orientation : on changera la tête de place pour désigner que le pion a tourné

        # création des éléphants en bleu, ont réitère
        self.el1 = QGraphicsRectItem(536, 77.5, 50, 50) # 12+(6 +2)*65,5 = 536
        self.el1.setBrush(elephants)
        txt_el1= QGraphicsTextItem('E1', parent=self.el1)
        txt_el1.setPos(self.el1.mapToScene(self.el1.rect().center()))
        self.ori_el1 = QGraphicsRectItem(536 - 50*3/10, 77.5 + 50 * 3 / 10, 20, 20, parent=self.el1)
        self.ori_el1.setBrush(elephants)
        self.scene.addItem(self.el1)
        self.el1.setFlag(QGraphicsRectItem.ItemIsSelectable)

        self.el2 = QGraphicsRectItem(536, 143, 50, 50)
        self.el2.setBrush(elephants)
        txt_el2= QGraphicsTextItem('E2', parent=self.el2)
        txt_el2.setPos(self.el2.mapToScene(self.el2.rect().center()))
        self.ori_el2 = QGraphicsRectItem(536 - 50*3/10, 142 + 50 * 3 / 10, 20, 20, parent=self.el2)
        self.ori_el2.setBrush(elephants)
        self.scene.addItem(self.el2)
        self.el2.setFlag(QGraphicsRectItem.ItemIsSelectable)

        self.el3 = QGraphicsRectItem(536, 208.5, 50, 50)
        self.el3.setBrush(elephants)
        txt_el3= QGraphicsTextItem('E3', parent=self.el3)
        txt_el3.setPos(self.el3.mapToScene(self.el3.rect().center()))
        self.ori_el3 = QGraphicsRectItem(536 - 50*3/10, 208.5 + 50 * 3 / 10, 20, 20, parent=self.el3)
        self.ori_el3.setBrush(elephants)
        self.scene.addItem(self.el3)
        self.el3.setFlag(QGraphicsRectItem.ItemIsSelectable)

        self.el4 = QGraphicsRectItem(536, 273, 50, 50)
        self.el4.setBrush(elephants)
        txt_el4= QGraphicsTextItem('E4', parent=self.el4)
        txt_el4.setPos(self.el4.mapToScene(self.el4.rect().center()))
        self.ori_el4 = QGraphicsRectItem(536 - 50*3/10, 273 + 50 * 3 / 10, 20, 20, parent=self.el4)
        self.ori_el4.setBrush(elephants)
        self.scene.addItem(self.el4)
        self.el4.setFlag(QGraphicsRectItem.ItemIsSelectable)

        self.el5 = QGraphicsRectItem(536, 339.5, 50, 50)
        self.el5.setBrush(elephants)
        txt_el5= QGraphicsTextItem('E5', parent=self.el5)
        txt_el5.setPos(self.el5.mapToScene(self.el5.rect().center()))
        self.ori_el5 = QGraphicsRectItem(536 - 50*3/10, 339.5 + 50 * 3 / 10, 20, 20, parent=self.el5)
        self.ori_el5.setBrush(elephants)
        self.scene.addItem(self.el5)
        self.el5.setFlag(QGraphicsRectItem.ItemIsSelectable)

        self.liste_el_qg = [self.el1, self.el2, self.el3, self.el4, self.el5] # de même pour les éléphants
        self.liste_el_ori_qg = [self.ori_el1, self.ori_el2, self.ori_el3, self.ori_el4, self.ori_el5]

        # création des montagnes en noir: juste des carrés car elles n'ont pas d'orientation
        self.m1 = self.scene.addRect(275, 144, 50, 50, blackPen, montagne)
        self.m2 = self.scene.addRect(275, 209.5, 50, 50, blackPen, montagne)
        self.m3 = self.scene.addRect(275, 275, 50, 50, blackPen, montagne)

        self.liste_mont_qg = [self.m1, self.m2, self.m3] #liste qui permettra de connaitre quelle montagne bouger


        #listes regroupants les pions, définis cette fois dans la classe pièce ( pour avoir acces aux coordonnées, orientation et numéro
        self.ele=[]
        self.rh=[]
        self.mont =[]

        for k in range (5):

            self.rh.append(Rhinoceros(-2, k, 'd', self))

            self.ele.append(Elephant(6, k, 'g', self))

        for k in range(3):  # place les rochers un à un, en rangée, au milieu du plateau
            self.mont.append( Montagne ( 2, k + 1, '',self))


        self.pion_select = self.el1 # permet de connaitre quel pion est sélectionné par le joueur
        self.pion_select_num = 1 # le numéro de ce pion qui joue
        self.joueur_qg= self.liste_el_qg # liste des pions en ihm du joueur
        self.joueur= self.ele # liste des pions définis dans la classe pièce, du joueur
        self.prochain = self.rh # liste des pions définis dans la classe pièce, du prohain joueur (l'autre)
        self.dernier_bouton = '' # permet de cconnaitre sur quel bouton le joueur a cliqué en dernier
        self.mont_sorti = self.mont[0]  # permet de reconnaitre la fin du jeux : on connaitra quelle montagne est sorti, et donc sa position
        self.pousse = False # à l'appel de pousser(), nous permet de savoir si entrer en poussant a bien eu lieu
                             # si ce n'est pas le cas, on remt la pièce à sa place initiale

        self.view = QGraphicsView(self.scene, self) # création de la vue contenant le plateau et tout le jeu
        self.view.resize(self.p.width()+100, self.p.height()+100) # on adapte la taille de la vue à celle du plateau

        self.texte = QGraphicsTextItem('Bienvenue dans le Royaume de Siam !''\n'
                                       'Les éléphants et les rhinocéros vont saffronter,''\n'
                                      ' le joueur 1, celui qui commencera, sera les éléphants''\n' 
                                           "(en bleu). Pour jouer, vous devez choisir votre joueur,'\n'"
                                           " puis l'un de vos pions et enfin la fonction que vous   " '\n'
                                              "voulez lui appliquer, et appuyer sur ok")
        # le texte permettra d'expliquer au joueur comment jouer (l'ordre dans lequel il doit cliquer sur les boutons ou pions)
        # ce texte ne s'affiche que lors du démarrage du jeux, chaque appel de fonction en montrera un nouveau
        self.zone_txt.addItem(self.texte) # on ajoutera dans la scène de texte les commentaires qui expliquent au joueurs comment jouer

        self.view2 = QGraphicsView(self.zone_txt, self) # deuxième vue qui permet d'afficher ce texte
        self.view2.setGeometry(820, 300, 400, 400)
        #
        self.texte.setPos(0, 0) # position du texte dans la scène

        self.show() #affiche les vues


    def joueur1(self):
        """
        s'active lorsque le joueur clique sur le bouton 'joueur 1'
        il permet d'enregistrer quelle liste de pions joue
        """
        self.zone_txt.clear() # on efface le texte de la 2eme vue
        self.joueur_qg = self.liste_el_qg # nous permettra de savoir si ce sont les éléphants ou les rhinos qui jouent
                                          # lorsque l'ont veut par exemple bouger un pion sur la scène, on appelle joueur_qg
                                          # et quel que soit le joueur, cet appel appelera la bonne catégorie de pions
        self.joueur = self.ele # de même, mais cette fois pour la liste contenant les caractéristiques de jeux des pions
        self.prochain = self.rh # celui qui ne joue pas
        self.texte = QGraphicsTextItem("c'est au tour du joueur 1: les éléphants" '\n'
                                           "Choisissez un de vos pions avant de choisir la" '\n'
                                            "fonction que vous voulez lui appliquer")
        self.zone_txt.addItem(self.texte)
        self.texte.setPos(0,0)
    def joueur2(self):
        """
        de la même façon, mais pour le cas ou le joueur joue les rhinocéros
        """
        self.zone_txt.clear()
        self.joueur_qg = self.liste_rh_qg
        self.joueur = self.rh
        self.prochain = self.ele
        print('joueur 2')
        self.texte= QGraphicsTextItem("c'est au tour du joueur 2: les rhinocéros" '\n'
                                           "Choisissez un de vos pions avant de choisir la" '\n'
                                            "fonction que vous voulez lui appliquer")
        self.zone_txt.addItem(self.texte)
        self.texte.setPos(0,0)


    def ok(self):
        """
        fonction la plus importante de la classe: définit les mouvements des pièces une fois qu'ils ont été selectionnés
        et que la fonction (bouton entrer, sortir, pousser...) a été défini
        c'est ici que l'on calcul les coordonnées que doivent prendre les widget de la liste (joueur_qg), par rapport aux cordonnées
        de la liste joueur


        """
        if self.dernier_bouton == 'déplacer':

            # voir les commentaires de la fonction changer de position de la classe pièce
            # on reprend cette fonction comme modèle, à laquelle on doit ajouter les caractéristiques liés aux widgets
            # pour leur faire prendre les caractéristiques correspondantes à celles imposées aux pions dans la classe pièces
            l = 6  # coordonnée initiale selon x des éléphants
            if self.joueur == self.rh:
                l = -2  # coordonnée initiale selon x des rhino

            # nous en avaons besoin pour connaitre la position initiale de chaque pièce
            # en effet, le but ici est de connaitre le déplacement des pièces éffectuée par le joueur
            # .x() et .y() permettent de savoir de combien s'est déplacée la pièce ( sachant qu'on se déplace d'une case vers la droite ou
            # le bas lorsque le pion a bougé de 65,5 environ) mais ce déplacement est calculé à partir des positions initiales
            # (définies dans le init). Elles donnent donc le déplacement totale par rapport à la position initiale
            # ce qui nous intéresse est plutôt le déplacement entre le coups d'avant et la fin de l'appel de la fonction

            # on doit prendre en compte les position initiales pour calculer la position avant le changement de position (x0, y0)
            # qu'on calcule à partir des coordonnées du pion (enregistrées dans self.joueur) et aux quelles ont soustrait leu position initiales
            # ( un éléphant a pour position initale (6, numero) et un rhino (-2, numero) avec numero sa place dans les listes

            x0, y0 = 65.5 * (self.joueur[self.pion_select_num - 1].coords[0] - (l)), (
                        self.joueur[self.pion_select_num - 1].coords[1] - (self.pion_select_num - 1)) * 65.5

            x, y = self.pion_select.x() - x0, self.pion_select.y() - y0  # mouvement effectué par rapport à la dernière case

            bool1 = True  # définie pour vérifier que la case choisie est vide
            bool2 = False  # définie pour vérifier que le pion s'est déplacée dans une case dans laquelle il pourrait se rendre
            # (d'une case horizontalement ou verticalement
            bool3 = True  # définie pour vérifier que la pièce ne sorte pas du plateau

            [a0, b0] = self.joueur[int(self.pion_select_num - 1)].coords #on enregistre la position précédente
            [a, b] = self.joueur[int(self.pion_select_num - 1)].coords
            # on va maintenant changer les nouvelles coordonnées du point déplacé dans la liste self. joueur
            # que pour l'humain puique les nouvelles coordonnées de la pièce de l'ia sont enegistrées
            # (celle qui retient les caractéristiques des pions que l'ont voit sur l'interface)

            if x > 0:
                a += (
                            x // 60)  # se déplacer vers la droite équivaut à bouger d'environ 60 son pion par rapport à la position précédente
            else:
                a += -(-x // 60)

            if y > 0:
                b += (y // 60)
            else:
                b += -(-y // 60) + 1

            self.joueur[int(self.pion_select_num - 1)].coords = [a, b]  # on enregistre les nouvelles coordonnées

            for k in range(len(self.joueur)):
                if (self.joueur[self.pion_select_num - 1].coords == self.joueur[
                    k].coords and k != self.pion_select_num - 1) or \
                        (self.joueur[self.pion_select_num - 1].coords == self.prochain[k].coords) \
                        or (k < 3 and self.joueur[self.pion_select_num - 1].coords == self.mont[k].coords):
                    # on vérifie que la nouvelle position ne soit pas occupée par un autre de nos pions, un des pions
                    # du joueur adverse, ou par une montagne
                    bool1 = False
                    self.texte = QGraphicsTextItem("Vous ne pouvez pas vous déplacer sur une case déjà occupée")
                    self.zone_txt.addItem(self.texte)
                    self.texte.setPos(0, 150)

            if ((55 < x < 75 or -75 < x < -55) and -10 < y < 10) or ((55 < y < 75 or -75 < y < -55) and -10 < x < 10):
                bool2 = True  # deplacement autorisé
                if self.joueur[self.pion_select_num - 1].coords[0] in [-2, -1, 5, 6] or \
                        self.joueur[self.pion_select_num - 1].coords[1] in [-1, 5]:
                    # le joueur a placé sa pièce hors du plateau
                    self.texte = QGraphicsTextItem("Vous êtes hors du plateau")
                    self.zone_txt.addItem(self.texte)
                    self.texte.setPos(0, 160)
                    bool3 = False
                else:
                    bool3 = True  # toujour sur le plateau
            else:
                self.texte = QGraphicsTextItem("Vous ne pouvez pas vous déplacer ici:"'\n'
                                               "veuillez vous déplacer d'une case, horizontalement"'\n'
                                               "ou verticalement")
                self.zone_txt.addItem(self.texte)
                self.texte.setPos(0, 170)
                bool2 = False

            if not (bool1 and bool2 and bool3):
                self.texte = QGraphicsTextItem("Votre déplacement n'est pas valide: veuillez rejouer")
                self.zone_txt.addItem(self.texte)
                self.texte.setPos(0, 230)

                self.joueur[int(self.pion_select_num - 1)].coords = [a0, b0]


                self.pion_select.setPos(x0, y0)  # le pion retourne à sa place

            else:
                self.tourne()  # si le changement de position était valide, le joueur peut aussi tourner son pion
                # la fonction tourne indiquera que le tour est terminé


            self.joueur_qg[self.pion_select_num - 1].setFlag(QGraphicsItem.ItemIsMovable, enabled=False)
            # le tour est fini, le pion ne peut plus jouer : soit le coup n'était pas valide et le joueur choisis à nouveau
            # une fonction, soit c'est à l'adversaire

        if self.dernier_bouton == 'entrer':
            l = 6  # coordonnée initiale selon x des éléphants
            if self.joueur == self.rh:
                l = -2  # coordonnée initiale selon x des rhino

            # code similaire à celui de la fonction entrer de la classe pièce mais on change la aussi les pioons de place

            bool = True  # pour vérifier que le pion n'est pas déja entré
            if self.joueur[self.pion_select_num - 1].coords[0] in [0, 1, 2, 3, 4] and \
                    self.joueur[self.pion_select_num - 1].coords[1] in [0, 1, 2, 3, 4]:
                # test sur les positions avant que le joueur n'ai déplacé sa pièce puisqu'on a pas enregistré les
                # nouvelles position liées à ce déplacement
                bool = False

            # on intègre les nouvelles coordonnées:
            x0, y0 = 65.5 * (self.joueur[self.pion_select_num - 1].coords[0] - (l)), (
                    self.joueur[self.pion_select_num - 1].coords[1] - (self.pion_select_num - 1)) * 65.5

            x, y = self.pion_select.x() - x0, self.pion_select.y() - y0
            [a0, b0] = self.joueur[int(self.pion_select_num - 1)].coords
            [a, b] = self.joueur[int(self.pion_select_num - 1)].coords

            if x > 0:
                a += (x // 60)
            else:
                a += -(-x // 60)  # -65//60 = 2

            if y > 0:
                b += (y // 60)
            else:
                b += -(-y // 60)

            self.joueur[int(self.pion_select_num - 1)].coords = [a, b]


            i = self.joueur[self.pion_select_num - 1].coords[0]
            j = self.joueur[self.pion_select_num - 1].coords[1]

            bool1 = True  # pour vérifier que la case visée n'est pas déjà occupée
            for k in range(len(self.joueur)):
                if (self.joueur[self.pion_select_num - 1].coords == self.joueur[
                    k].coords and k != self.pion_select_num - 1) \
                        or (self.joueur[self.pion_select_num - 1].coords == self.prochain[k].coords) or \
                        (k < 3 and self.joueur[self.pion_select_num - 1].coords == self.mont[k].coords):
                    print('deja prise')
                    bool1 = False

            bool2 = False
            # on va vérifier que le joueur entre sur une case du bord du plateau
            if ((i == 0 or i == 4) and -1 < j < 5) or ((j == 4 or j == 0) and -1 < i < 5):

                bool2 = True

            if bool and bool1 and bool2:  # toutes les conditions sont vérifiées pour pouvoir entrer
                self.tourne()  # on ne tourne que si toutes les conditions pour entrer sont valides
                # celle ci affichera que c'est la fin du tour

            else:  # mouvement non valide

                self.texte = QGraphicsTextItem("une pièce ne peut entrer sur le plateau que sur une case extérieure,"
                                               "si elle est déjà sur le plateau ou si la case est déjà prise : Rejouez")
                self.zone_txt.addItem(self.texte)
                self.texte.setPos(0, 170)

                self.pion_select.setPos(x0,
                                        y0)  # le pion retourne à sa position précéddente car le coup n'était pas valide, le joueur doir rejouer
                self.joueur[self.pion_select_num - 1].coords = [a0,b0]  # on réenregistre sa postion (correspondante à celle
                # qu'il a sur le plateau, donc la position initiale


        if self.dernier_bouton == 'sortir':
            #de même, on s'inspire du code de la fonction du même nom définie dans la classe pièce

            l = 6
            if self.joueur == self.rh:
                l = -2
            a, b = self.joueur[self.pion_select_num-1].coords
            if a in [0, 4] or b in [0, 4]: #on vérifie que le pion est situé sur un bord du plateau ( on le définit directement
                                          #avec le reste de la fonction car il n'y a pas d'ia ici et on ne l'appel pas dans d'autres
                                          # fonction (comme entrer en poussant dans le cas de pièces)
                self.joueur[self.pion_select_num-1].coords = [l, self.pion_select_num-1] #coordonnées initiales de la pièce
                self.pion_select.setPos(0, 0) #remet le widget à sa position initiale
                self.texte = QGraphicsTextItem(
                    "Votre pièce est bien sortie du plateau, au tour des {0}".format(self.prochain[0].car()))
                self.zone_txt.addItem(self.texte)
                self.texte.setPos(0, 150)
            else :
                self.texte = QGraphicsTextItem(
                    "vous ne pouvez sortir su plateau que si votre pion est sur une case extérieur, rejouez")
                self.zone_txt.addItem(self.texte)
                self.texte.setPos(0, 150)


        if self.dernier_bouton == 'pousser':

            #la fonction est quasiment la même que celle de pièces, on ajoute seulement le déplacement des pièces
            #lorsqu'elles changent de coordonnées

            dic_forces = {'0': [0, 0],
                          'h': [1, 0],
                          'd': [0, 1],
                          'b': [-1, 0],
                          'g': [0, -1]}

            j, i = self.joueur[self.pion_select_num-1].coords[1], self.joueur[self.pion_select_num-1].coords[0]
            orientation = self.joueur[self.pion_select_num-1].orientation

            f = 0  # la force résultante de la piece en question
            H = []  # les pieces sur la même ligne que notre pièce
            Hab = [self.joueur[self.pion_select_num-1]]  # les pieces a bouger sur la ligne en question
            V = [] #les pièces sur la même colonne
            Vab = [self.joueur[self.pion_select_num-1]] #celle qui suivent la notre, et que l'on doit pousser
            nb_montagnes = 0
            #on ajoute dans H et V les pièces (éléphants, rhinos ou montagnes) qui sont sur la même ligne et la
            #la même colonne que nous
            for piece in self.ele:
                if piece.coords[1] == j:
                    H.append(piece)  # à ce stade on a la liste des éléphants qui sont sur la même ligne que l'animal en question
                if piece.coords[0] == i:
                    V.append(piece) # de même pour la colonne
            for piece in self.rh:
                if piece.coords[1] == j:
                    H.append(piece)  # à ce stade on a la liste des rhinos qui sont sur la même ligne que l'animal en question
                if piece.coords[0] == i:
                    V.append(piece)  #de même pour la colonne
            for piece in self.mont:
                if piece.coords[1] == j:
                    H.append(piece)  # à ce stade on a la liste des montagne qui sont sur la même ligne que l'animal en question
                if piece.coords[0] == i:
                    V.append(piece)  # de même pour la colonne
#on fait maintenant les mêmes cas (selon l'oorientation) que dans la fonction pousser de la classe pièce
            if orientation == 'g'and i in [0,1,2,3,4] and j in [0,1,2,3,4]:
                piece_gauche = self.joueur[self.pion_select_num-1]
                for k in range(len(H)):  # pour etre sur de ne pas louper une piece qui serait à gauche
                    for piece in H:
                        if piece.coords[0] == piece_gauche.coords[0] - 1:
                            Hab.append(piece)
                            piece_gauche = piece

                for piece in Hab:
                    if piece.car() == 'M':
                        nb_montagnes += 1
                        if nb_montagnes == 2:
                            f = f + 1  # il faut rajouter la force des montagnes
                    else:
                        f = f + dic_forces[piece.orientation][1]

                if f < 0:  # la force résultante est vers la droite
                    for piece in Hab:
                        piece.coords = piece.coords[0] - 1, piece.coords[1]
                        num, car = piece.numero, piece.car()
                        #ce qu'on ajoute au code de la classe pièce :
                        if car == 'E':
                            x = 65.5 * (self.ele[num].coords[0] - (6)) # nouvelles absisses quand on a changé les coordonnées
                            y = (self.ele[num].coords[1] - (num )) * 65.5 #même ordonnées car il n'a pas changé
                            self.liste_el_qg[num].setPos(x,y)
                            if piece.coords[0]<0: #la pièce sort par la gauche
                                self.liste_el_qg[num].setPos(0, 0) #elle reprend sa position initiale sur le plateau
                                piece.coords=6, num #et ses coordonnées suivent
                        if car == 'R':
                            x = 65.5 * (self.rh[num].coords[0] - (-2))
                            y = (self.rh[num].coords[1] - (num )) * 65.5
                            self.liste_rh_qg[num].setPos(x,y)
                            if piece.coords[0]<0:
                                self.liste_rh_qg[num].setPos(0, 0)
                                piece.coords=-2, num
                        if car == 'M':
                            x = 65.5 * (self.mont[num].coords[0] - (2))
                            y = (self.mont[num].coords[1] - (num +1)) * 65.5
                            self.liste_mont_qg[num].setPos(x,y)
                            if piece.coords[0]<0: #une montagne est sortie du plateau : le jeu est terminé
                                self.mont_sorti = piece #on enregistre quelle montagne est sorti (pour connaitre sa position)
                                self.vainqueur() #on appelle la fonction qui nous indiquera le gagnant
                    self.texte = QGraphicsTextItem(
                        "Vous avez poussé, au tour des {0}".format(self.prochain[0].car()))
                    self.zone_txt.addItem(self.texte)
                    self.texte.setPos(0, 150)
                    self.pousse = True #on vérifie que la poussée s'est bien faite pour entrer en poussant

                else: #la force de poussée n'était pas suffisante
                    self.texte = QGraphicsTextItem(
                        "vous ne pouvez pas effectuer cette poussée:"'\n'
                        " vous navez pas assez de force de poussée"'\n'
                        "Rejouez")
                    self.zone_txt.addItem(self.texte)
                    self.texte.setPos(0, 150)
                    self.pousse = False # si entrer en poussant n'a pas fonctionné, cette variable permet de le savoir
                                         # pour en déduire si il faudra remettre la pièce à sa place
#on réitère pour les trois autres orientations
            if orientation == 'd'and i in [0,1,2,3,4] and j in [0,1,2,3,4]:
                piece_droite = self.joueur[self.pion_select_num-1]
                for k in range(len(H)):
                    for piece in H:
                        if piece.coords[0] == piece_droite.coords[0] + 1:
                            Hab.append(piece)
                            piece_droite = piece

                for piece in Hab:
                    if piece.car() == 'M':
                        nb_montagnes += 1
                        if nb_montagnes == 2:
                            f = f - 1  # il faut rajouter la force d'une montagne
                    else:
                        f = f + dic_forces[(piece.orientation)][1]

                if f > 0:  # la force résultante est vers la droite
                    for piece in Hab:
                        piece.coords = piece.coords[0] + 1, piece.coords[1]
                        num, car = piece.numero, piece.car()
                        if car == 'E':
                            x = 65.5 * (self.ele[num].coords[0] - (6))
                            y = (self.ele[num].coords[1] - (num)) * 65.5
                            self.liste_el_qg[num].setPos(x,y)
                            if piece.coords[0]>4:
                                self.liste_el_qg[num].setPos(0, 0)
                                piece.coords=6, num
                        if car == 'R':
                            x = 65.5 * (self.rh[num].coords[0] - (-2))
                            y = (self.rh[num].coords[1] - (num )) * 65.5
                            self.liste_rh_qg[num].setPos(x,y)
                            if piece.coords[0]>4:
                                self.liste_rh_qg[num].setPos(0, 0)
                                piece.coords=-2, num
                        if car == 'M':
                            x = 65.5 * (self.mont[num].coords[0] - (2))
                            y = (self.mont[num].coords[1] - (num +1)) * 65.5
                            self.liste_mont_qg[num].setPos(x,y)
                            if piece.coords[0]>4:
                                self.mont_sorti = piece
                                self.vainqueur()
                    self.texte = QGraphicsTextItem(
                        "Vous avez poussé, au tour des {0}".format(self.prochain[0].car()))
                    self.zone_txt.addItem(self.texte)
                    self.texte.setPos(0, 150)
                    self.pousse = True
                else:
                    print('vous ne pouvez pas effectuer cette poussée: vous navez pas assez de force de poussée')
                    self.texte = QGraphicsTextItem(
                        "vous ne pouvez pas effectuer cette poussée:"'\n'
                        " vous navez pas assez de force de poussée"'\n'
                        "Rejouez")
                    self.zone_txt.addItem(self.texte)
                    self.texte.setPos(0, 150)
                    self.pousse =False

            if orientation == 'h'and i in [0,1,2,3,4] and j in [0,1,2,3,4]:
                piece_haut = self.joueur[self.pion_select_num-1]
                for k in range(len(V)):
                    for piece in V:
                        if piece.coords[1] == piece_haut.coords[1] - 1:
                            Vab.append(piece)
                            piece_haut = piece

                for piece in Vab:
                    if piece.car() == 'M':
                        nb_montagnes += 1
                        if nb_montagnes == 2:
                            f = f - 1  # il faut rajouter la force d'une montagne
                    else:
                        f = f + dic_forces[(piece.orientation)][0]

                if f > 0:  # la force résultante est vers la droite
                    for piece in Vab:
                        piece.coords = piece.coords[0], piece.coords[1] - 1
                        num, car = piece.numero, piece.car()
                        if car == 'E':
                            x = 65.5 * (self.ele[num].coords[0] - (6))
                            y = (self.ele[num].coords[1] - (num)) * 65.5
                            self.liste_el_qg[num].setPos(x, y)
                            if piece.coords[1] < 0:
                                self.liste_el_qg[num].setPos(0, 0)
                                piece.coords = 6, num
                        if car == 'R':
                            x = 65.5 * (self.rh[num].coords[0] - (-2))
                            y = (self.rh[num].coords[1] - (num)) * 65.5
                            self.liste_rh_qg[num].setPos(x, y)
                            if piece.coords[1] < 0:
                                self.liste_rh_qg[num].setPos(0, 0)
                                piece.coords = -2, num
                        if car == 'M':
                            x = 65.5 * (self.mont[num].coords[0] - (2))
                            y = (self.mont[num].coords[1] - (num + 1)) * 65.5
                            self.liste_mont_qg[num].setPos(x, y)
                            if piece.coords[1] < 0:
                                self.mont_sorti = piece
                                self.vainqueur()
                    self.texte = QGraphicsTextItem(
                        "Vous avez poussé, au tour des {0}".format(self.prochain[0].car()))
                    self.zone_txt.addItem(self.texte)
                    self.texte.setPos(0, 150)
                    self.pousse = True
                else:
                    print('vous ne pouvez pas effectuer cette poussée: vous navez pas assez de force de poussée')
                    self.texte = QGraphicsTextItem(
                        "vous ne pouvez pas effectuer cette poussée:"'\n'
                        " vous navez pas assez de force de poussée"'\n'
                        "Rejouez")
                    self.zone_txt.addItem(self.texte)
                    self.texte.setPos(0, 150)
                    self.pousse = False

            if orientation == 'b'and i in [0,1,2,3,4] and j in [0,1,2,3,4]:
                piece_haut = self.joueur[self.pion_select_num-1]
                for k in range(len(V)):
                    for piece in V:
                        if piece.coords[1] == piece_haut.coords[1] + 1:
                            Vab.append(piece)
                            piece_haut = piece

                for piece in Vab:
                    if piece.car() == 'M':
                        nb_montagnes += 1
                        if nb_montagnes == 2:
                            f = f + 1  # il faut rajouter la force d'une montagne
                    else:
                        f = f + dic_forces[(piece.orientation)][0]

                if f < 0:  # la force résultante est vers la droite
                    for piece in Vab:
                        piece.coords = piece.coords[0], piece.coords[1] + 1
                        num, car = piece.numero, piece.car()
                        if car == 'E':
                            x = 65.5 * (self.ele[num].coords[0] - (6))
                            y = (self.ele[num].coords[1] - (num)) * 65.5
                            self.liste_el_qg[num].setPos(x, y)
                            if piece.coords[1] > 4:
                                self.liste_el_qg[num].setPos(0, 0)
                                piece.coords = 6, num
                        if car == 'R':
                            x = 65.5 * (self.rh[num].coords[0] - (-2))
                            y = (self.rh[num].coords[1] - (num)) * 65.5
                            self.liste_rh_qg[num].setPos(x, y)
                            if piece.coords[1] > 4:
                                self.liste_rh_qg[num].setPos(0, 0)
                                piece.coords = -2, num
                        if car == 'M':
                            x = 65.5 * (self.mont[num].coords[0] - (2))
                            y = (self.mont[num].coords[1] - (num + 1)) * 65.5
                            self.liste_mont_qg[num].setPos(x, y)
                            if piece.coords[1] > 4:
                                self.mont_sorti = piece
                                self.vainqueur()
                    self.texte = QGraphicsTextItem(
                        "Vous avez poussé, au tour des {0}".format(self.prochain[0].car()))
                    self.zone_txt.addItem(self.texte)
                    self.texte.setPos(0, 150)
                    self.pousse = True
                else:

                    self.texte = QGraphicsTextItem(
                        "vous ne pouvez pas effectuer cette poussée:"'\n'
                        " vous navez pas assez de force de poussée"'\n'
                        "Rejouez")
                    self.zone_txt.addItem(self.texte)
                    self.texte.setPos(0, 150)
                    self.pousse = False
            else :
                self.texte = QGraphicsTextItem(
                    "vous devez être sur le plateau pour pousser"'\n'
                    "Rejouez")
                self.zone_txt.addItem(self.texte)
                self.texte.setPos(0, 150)
                self.pousse = False


        if self.dernier_bouton == 'entrer en poussant':
            l = 6
            if self.joueur == self.rh:
                l = -2

            x0, y0 = 65.5 * (self.joueur[self.pion_select_num - 1].coords[0] - (l)), (
                    self.joueur[self.pion_select_num - 1].coords[1] - (self.pion_select_num - 1)) * 65.5
            if self.joueur[self.pion_select_num-1].coords[0] in [0, 1, 2, 3, 4] and self.joueur[self.pion_select_num-1].coords[1] in [0, 1, 2, 3, 4]:
                #on ne fait rien si la pièce est déjà entrée, on la remet seulement à sa place
                self.texte = QGraphicsTextItem(
                    "vote pion est déjà entré sur le plateau:"'\n'
                    "Rejouez")
                self.zone_txt.addItem(self.texte)
                self.texte.setPos(0, 150)
                self.pion_select.setPos(x0,y0)

            else:

                x, y = self.pion_select.x(), self.pion_select.y() # mouvement par rapport à la dernière case qui est celle
                                                                  # de la position initiale puisqu'on est dans le else
                [a, b] = self.joueur[self.pion_select_num - 1].coords

                if x > 0:
                    a += (x // 60)
                else:
                    a += -(-x // 60)   # -65//60 = 2


                if y > 0:
                    b += (y // 60)
                else:
                    b += -(-y // 60)

                self.joueur[self.pion_select_num - 1].coords = [a, b]

                self.tourne() #possibilité de tourner pour se  placer face à la pièce que l'on veut pousser

                self.texte = QGraphicsTextItem(
                    "cliquez sur ok pour pousser")
                self.zone_txt.addItem(self.texte)
                self.texte.setPos(0, 180)


                i, j = self.joueur[self.pion_select_num-1].coords
                print(i,j)
                if i == -1 or i == 5 or j == -1 or j == 5: #la pièce doit être placée sur une case extérieure, en
                    #face de la pièce à pousser

                    self.pousser()
                    if self.pousse == False:
                        self.pion_select.setPos(0, 0)
                        self.joueur[self.pion_select_num - 1].coords = [l, self.pion_select_num - 1]


                else:

                    self.texte = QGraphicsTextItem(
                        "pour rentrer en poussant, vous devez mettre la piece sur une"'\n'
                        " case extérieure au plateau, la mettre dans la bonne orientation"'\n'
                        "et pousser : Rejouez")
                    self.zone_txt.addItem(self.texte)
                    self.texte.setPos(0, 150)
                    self.pion_select.setPos(0,0)
                    self.joueur[self.pion_select_num-1].coords = [l, self.pion_select_num-1]

            self.joueur_qg[self.pion_select_num - 1].setFlag(QGraphicsItem.ItemIsMovable, enabled=False)

        if self.dernier_bouton == 'tourner':
        # cette partie n'est pas utile car le tour tourner séffectue dès l'appuie sur le bouton tourner
        #on définie quand même un cas pour tourneren appuyant sur ok, pour que indiquer que le tour est fini

            self.texte = QGraphicsTextItem(
                                            "Vous avez tourné votre pièce, au tour des {0}".format(self.prochain[0].car()))
            self.zone_txt.addItem(self.texte)
            self.texte.setPos(0, 200)

                #print("votre pièce %c%i est entrée à la position %s, orientée vers %c" % (self. self.joueur[self.pion_select_num - 1].car(), self. self.joueur[self.pion_select_num - 1].numero, self. self.joueur[self.pion_select_num - 1].coords, self. self.joueur[self.pion_select_num - 1].orientation))

    def deplacer(self):
        """ en cas d'appuie sur le bouton deplacer, on change les variables dont nous auront besoin pour
        identifier le joueur, le pion sélectionné et ses propriétés
        on rend aussi possible le mouvement du pion sélectionné, que le joueur devra déplacer dans la case
        où il souhaite se rendre, avant d'appuyer sur ok
        la partie qui fera effectivement le coup pousser s'activera au moment d'appuyer sur ok"""
        self.dernier_bouton = 'déplacer'   # pour appeler la bonne partie du code quand on appuyera sur ok
        self.zone_txt.clear() #on efface tout le texte lorsque le joueur a choisi son coup
        for i in range(5):
            # on cherche quel pion est sélectionné
            if self.liste_el_qg[i].isSelected():
                self.liste_el_qg[i].setFlag(QGraphicsItem.ItemIsMovable) #on lui donne la possibilité d'être déplacé par le joueur
                self.pion_select = self.liste_el_qg[i] #pour connaitre le pion (widget) est sélectionné
                self.pion_select_num = i + 1 #connaitre son numéro (numéro marqué sur lees pions sur la fenêtre d'ihm,
                                             # mais c'est self.pion_select_num-1 qui correpond à l'emplacement du pion dans les listes

            if self.liste_rh_qg[i].isSelected():
                self.liste_rh_qg[i].setFlag(QGraphicsItem.ItemIsMovable)
                self.pion_select = self.liste_rh_qg[i]
                self.pion_select_num = i + 1

        self.texte = QGraphicsTextItem("Vous avez choisis de déplacer votre pion {0}{1}." '\n'
                                       "Vous pouvez maintenant déplacer votre pièce" '\n'
                                       "Vous pouvez la décaler d'une case horizontalement ou" '\n'
                                       "verticalement."'\n'
                                       "Lorsque vous avez posé votre pion dans la case "'\n'
                                       "souhaitée appuyer sur ok et choisissez l'orientation "'\n'
                                       "de votre pièce".format(self.joueur[self.pion_select_num-1].car(),self.pion_select_num-1))
        self.zone_txt.addItem(self.texte)
        self.texte.setPos(0, 0)

    def pousser(self):
        """ code semblable à celui de déplacer, mais cette ois pas besoin que le pion sélectionné puisse être bougé"""
        self.dernier_bouton = 'pousser'
        self.zone_txt.clear()
        for i in range(5):
            if self.liste_el_qg[i].isSelected():
                self.pion_select = self.liste_el_qg[i]
                self.pion_select_num = i + 1

            if self.liste_rh_qg[i].isSelected():
                self.pion_select = self.liste_rh_qg[i]
                self.pion_select_num = i + 1

        self.texte = QGraphicsTextItem("Vous avez choisis de pousser avec votre pion"'\n'
                                       "{0}{1} orienté selon {2}." '\n'
                                       "Vous pouvez maintenant pousser devant vous. " '\n'
                                       "Appuyer sur ok pour valider votre action".format(self.joueur[self.pion_select_num-1].car(),self.pion_select_num-1,self.joueur[self.pion_select_num-1].orientation))
        self.zone_txt.addItem(self.texte)
        self.texte.setPos(0, 0)



    def tourne(self):
        """ c'est la seule fonction qui se joue avant d'appuyer sur ok
        on définit les mêmes variables que d'habitude, mais on effectue aussi l'action tourner ici
        pour se faire, on utilise le code de la classe pièce, au quel on ajoute le déplacement de le "tête"
        de l'animal pour qu'on reconnaisse l'orientation sur la fenêtre ihm
        une boite de dialogue apparait pour que le joueur entre l'orientation dans laquelle il veut être"""
        self.dernier_bouton = 'tourner'
        #on n'efface pas l'écran zone_txt cette fois ci car la fonction est appeléedans la méthode "ok"
        #( pour déplacer, entrer et entrer en poussant) donc on veut garder le texte avec les instructions
        for i in range(5):
            if self.liste_el_qg[i].isSelected():
                self.pion_select = self.liste_el_qg[i]
                self.pion_select_num = i + 1
                print("l'elephant {}+1".format(i))
            if self.liste_rh_qg[i].isSelected():
                print("le rhino {}+1".format(i))
                self.pion_select = self.liste_rh_qg[i]
                self.pion_select_num = i + 1

        self.showDialog() #affiche la bo^te de dialogue qui demande au joueur dans quelle direction il veut être

        #dictionnaires associant la direction su pion, à la position de la tête
        # les positions sont différentes pour les éléphants et les rhinocéros car encore une fois,
        #on bouge le widget par rapport à sa position initiale sur le corps de l'animal
        pos_el = {'g': [0,0],
                  'b': [30, 30],
                  'd': [60,0],
                  'h': [30, -30]}
        pos_rh = {'d':[0,0],
                  'b': [-30, 30],
                  'g': [-60, 0],
                  'h':[-30, -30]}
        # dictionnaires associant l'ancienne orientation à la nouvelle lorsque le joueur a choisi
        # comment il voulait tourner
        tourner_droite = {'h': 'd',
                          'd': 'b',
                          'b': 'g',
                          'g': 'h'}
        tourner_gauche = {'h': 'g',
                          'g': 'b',
                          'b': 'd',
                          'd': 'h'}
        demi_tour = {'h': 'b',
                     'g': 'd',
                     'b': 'h',
                     'd': 'g'}

        if self.joueur[self.pion_select_num-1].coords[0] not in [-2, 6]:
            if self.txt == 'droite': #on change l'orientation de la pièce dans la liste joueur
                self.joueur[self.pion_select_num-1].orientation = tourner_droite[str(self.joueur[self.pion_select_num-1].orientation)]

            if self.txt == 'gauche':
                self.joueur[self.pion_select_num-1].orientation = tourner_gauche[str(self.joueur[self.pion_select_num-1].orientation)]

            if self.txt == 'demi-tour':
                self.joueur[self.pion_select_num-1].orientation = demi_tour[str(self.joueur[self.pion_select_num-1].orientation)]

            #on trouve les positions que doivent prendre les t^tes en fonction du choix d'orientation
            xe, ye = pos_el[str(self.joueur[self.pion_select_num-1].orientation)]
            xr, yr = pos_rh[str(self.joueur[self.pion_select_num -1].orientation)]
            #les têtes changent de place, montrant au joueur que sa pièce a tournée
            if self.joueur==self.ele:
                self.liste_el_ori_qg[self.pion_select_num-1].setPos(xe, ye)
            if self.joueur==self.rh:
                self.liste_rh_ori_qg[self.pion_select_num-1].setPos(xr, yr)


            self.texte = QGraphicsTextItem("vous avez choisis de changer l'orientation de votre pion"'\n'
                                           "{0}{1}, maintenant orienté vers {2}. Cliquez sur ok pour"'\n'" valider votre coup".format(self.joueur[self.pion_select_num - 1].car(),
                                                                             self.pion_select_num, self.joueur[self.pion_select_num-1].orientation))
            self.zone_txt.addItem(self.texte)
            self.texte.setPos(0, 150)
        else:
            self.texte = QGraphicsTextItem("vous ne pouvez tourner qu'une pièce entrée sur le plateau")

            self.zone_txt.addItem(self.texte)
            self.texte.setPos(0, 150)

    def entrer(self):
        """ semblable aux fonctions déplacer et pousser"""
        self.dernier_bouton = 'entrer'
        self.zone_txt.clear()
        for i in range(5):
            if self.liste_el_qg[i].isSelected():
                self.liste_el_qg[i].setFlag(QGraphicsItem.ItemIsMovable)
                self.pion_select = self.liste_el_qg[i]
                self.pion_select_num = i + 1
                print("l'elephant {}+1".format(i))
            if self.liste_rh_qg[i].isSelected():
                self.liste_rh_qg[i].setFlag(QGraphicsItem.ItemIsMovable)
                print("le rhino {}+1".format(i))
                self.pion_select = self.liste_rh_qg[i]
                self.pion_select_num = i + 1