appli1.py 69.1 KB
Newer Older
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1
# auteur : Pauline
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

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

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_IA = QPushButton("IA", self)
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
49
        button_IA.setGeometry(720, 70, 100, 50)
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
        button_IA.clicked.connect(self.IA)

        #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, 220, 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
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
251
252
253
        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

254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
        #pour l'ia:
        self.qui = 'humain'
        self.coup_possible = ["déplacer", "tourner", "entrer", "sortir","pousser", "entrer en poussant", ]
        self.ori_possible = ['droite', 'gauche', 'demi-tour', 'rien']
        self.abs, self.ord = 0,0  # nouvelles coords du pion
        self.coup = '' #permet dans tourner de savoir si l'ia tourne une pièce au hasard ou si elle tourne la même que celle chois
        #dans un autre coup qui appelerai tourner
        self.a_toune = True #permet à l'ia de ne tourner qu'une fois quand tourne() est appelée dans une autre finction


        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). Si vous choisissez de jouer contre l'IA, vous êtes le "'\n'
                                       "joueur 1. 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.qui = 'humain'
        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)
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
303

304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321

    def IA(self):
        """
        de la même façon, mais pour le cas ou le joueur est l'IA, il joue les rhinocéros
        """
        self.zone_txt.clear()
        self.joueur_qg = self.liste_rh_qg
        self.joueur = self.rh
        self.prochain = self.ele
        self.qui = 'ia'
        self.txt = self.ori_possible[randint(0,4)]
        self.abs, self.ord = randint(0, 5), randint(0, 5)
        self.texte= QGraphicsTextItem("c'est au tour de l'IA: les rhinocéros" '\n'
                                           )
        self.zone_txt.addItem(self.texte)
        self.texte.setPos(0,0)

        self.a_toune = False #à l'appel d'une fonction, la pièce n'a pas encore tourné
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
322
323
324
        self.coup=self.coup_possible[randint(0,6)]

        self.dernier_bouton = str(self.coup)
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
        self.ok()



    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':
            if self.qui == 'ia' :
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
341

342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
                self.pion_select_num = randint(1,6)
                self.pion_select = self.joueur_qg[self.pion_select_num-1]
                abs0, ord0 = self.joueur[self.pion_select_num-1].coords #anciennes coords avant de se déplace

            # 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
            if self.qui == 'humain':
                x, y = self.pion_select.x() - x0, self.pion_select.y()- y0 # mouvement effectué par rapport à la dernière case
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
368

369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
            else :
                self.joueur[self.pion_select_num-1].coords = [self.abs, self.ord]
                x1, y1 = 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   #calcul de la distance
                #entre la position initiale est la nouvelle pos, semblable à .x() et .y()
                x, y = x1-x0, y1-y0
            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


            if self.qui == 'humain':
                [a0, b0] = self.joueur[int(self.pion_select_num - 1)].coords #ancienne position, pour y retourner si le mouvement
                                                                             # est non valide
                [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
            else :
                self.joueur[self.pion_select_num-1].coords = [self.abs, self.ord]

Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
405

406
407
408
409
410
411
412
            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
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
413
414
415
416
417
                    if self.qui == 'humain' : #on souhaite afficher les commentaires uniquement pour l'humain, puisque
                                              #l'ia fait de nombreux essais avant d'arriver à un coup valide
                        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)
418
419
420
421
422
423


            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
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
424
425
426
427
                    if self.qui == 'humain':
                        self.texte = QGraphicsTextItem("Vous êtes hors du plateau")
                        self.zone_txt.addItem(self.texte)
                        self.texte.setPos(0,160)
428
429
430
431
                    bool3 = False
                else :
                    bool3 = True # toujour sur le plateau
            else :
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
432
433
434
435
436
437
                if self.qui == 'humain':
                    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)
438
439
                bool2 = False

Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
440

441
            if not (bool1 and bool2 and bool3):
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
442
443
444
445
                if self.qui == 'humain':
                    self.texte = QGraphicsTextItem("Votre déplacement n'est pas valide: veuillez rejouer")
                    self.zone_txt.addItem(self.texte)
                    self.texte.setPos(0, 230)
446
447
448
449
450
451
452
453
454

        # le coup n'était pas valide : le pion reprends sa place (quil avait juste avant le coup)
        # on doit réenregistrer les anciennes coordonnées dans la liste self.joueur et changer la position du widget sur le plateau

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

                else:
                    self.joueur[int(self.pion_select_num - 1)].coords = [abs0, ord0]

Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
455

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

Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
458
459
460
                # if self.qui == 'ia':
                #
                #     self.IA() #le tour n'a pas marché, l'ia doit rejouer
461
462
463
            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é
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
464
465
466
                # if self.a_toune == True:
                #     if self.qui == 'ia':
                #         self.joueur1()
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493


            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
            if self.qui == 'ia':
                self.pion_select_num = randint(1, 6)
                self.pion_select = self.joueur_qg[self.pion_select_num-1]

#position précédente, avant déffectuer l'action:
            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
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
494
            [a0, b0] = self.joueur[int(self.pion_select_num - 1)].coords # coordonnées avant d'avoir joué
495
496
            if self.qui == 'humain':
                x, y = self.pion_select.x() - x0, self.pion_select.y() - y0
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
497

498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
                [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]
            else:
                self.joueur[int(self.pion_select_num - 1)].coords = [self.abs, self.ord]

            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):
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
523

524
525
526
527
528
529
                    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):
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
530

531
532
533
534
535
                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
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
536

537
538
539
540
                if self.a_toune == True:  #vérifie que la pièce a tourné une fois
                    if self.qui == 'ia':
                        l= -2 #car l'ia joue les rhinos
                        x1,y1 =  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
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
541

542
543
                        self.pion_select.setPos(x1, y1) #le tour marche, donc on peut bouger la pièce

Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
544
545
546
547
548
549
550
                        #self.joueur1() #l'ia a joué, au tour du joueur 1
            else: # mouvement non valide
                if self.qui == 'humain':
                    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)
551
552
553
554

                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

Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
555
556
557
                # if self.qui == 'ia':
                #     self.IA()  # le tour n'a pas marché, l'ia doit rejouer

558
559
560
561
562
563
564
565
566
567
568



        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

            if self.qui == 'ia':
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
569

570
571
572
573
574
575
576
577
578
                self.pion_select_num = randint(0, 5) +1
                self.pion_select = self.joueur_qg[self.pion_select_num-1]

            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
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
579
580
581
582
583
584
585
586

                if self.qui == 'humain':
                    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)
                # if self.qui == 'ia':
                #     self.joueur1()
587
588

            else :
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
589
590
591
592
593
594
595
                if self.qui == 'humain':
                    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.qui == 'ia':
                #     self.IA() #le tour n'a pas marché, l'ia doit rejouer
596
597
598
599
600
601
602
603


        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

            if self.qui == 'ia':
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
604

605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
                self.pion_select_num = randint(0, 5) +1
                self.pion_select = self.joueur_qg[self.pion_select_num-1]


            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
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
642
            if orientation == 'g' and i in [0,1,2,3,4] and j in [0,1,2,3,4]:
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
                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
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
684
685
686
687
688
689
690
691
                    if self.qui == 'humain':
                        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)
                    # if self.qui == 'ia':
                    #     self.joueur1()
                    self.pousse = True
692
693
694


                else: #la force de poussée n'était pas suffisante
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
695
696
697
698
699
700
701
702
703
704
                    if self.qui == 'humain':
                        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)
                    # if self.qui == 'ia':
                    #     self.IA()
                    self.pousse = False
705
706

#on réitère pour les trois autres orientations
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
707
            if orientation == 'd' and i in [0,1,2,3,4] and j in [0,1,2,3,4]:
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
                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()
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
748
749
750
751
752
753
754
755
                    if self.qui == 'humain':
                        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)
                    # if self.qui == 'ia':
                    #     self.joueur1()
                    self.pousse = True
756
                else:
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
757
758
759
760
761
762
763
764
765
766
767
768
                    if self.qui == 'humain':
                        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)
                    # if self.qui == 'ia':
                    #     self.IA()
                    self.pousse =False

            if orientation == 'h' and i in [0,1,2,3,4] and j in [0,1,2,3,4]:
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
                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()
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
809
810
811
812
813
814
815
816
                    if self.qui == 'humain':
                        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)
                    # if self.qui == 'ia':
                    #     self.joueur1()
                    self.pousse = True
817
                else:
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
818
819
820
821
822
823
                    if self.qui == 'humain':
                        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)
824
                    self.texte.setPos(0, 150)
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
825
826
827
                    # if self.qui == 'ia':
                    #     self.IA()
                    self.pousse = False
828

Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
829
            if orientation == 'b' and i in [0,1,2,3,4] and j in [0,1,2,3,4]:
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
                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()
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
870
871
872
873
874
875
876
877
878
                    if self.qui == 'humain':
                        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)
                    # if self.qui == 'ia':
                    #     self.joueur1()
                    self.pousse = True

879
                else:
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
                    if self.qui == 'humain':
                        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)
                    # if self.qui == 'ia':
                    #     self.IA()
                    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
897
898
899
900
901
902
903
904


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

            if self.qui == 'ia' :
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
905

906
907
                self.pion_select_num = randint(1,6)
                self.pion_select = self.joueur_qg[self.pion_select_num-1]
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
908
909
            abs0, ord0 = self.joueur[
                self.pion_select_num - 1].coords  # anciennes coords avant de se déplacer, piur l'ia
910
911
912
913
914
915
916


            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



Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
917
918
919
920
921
922
923
924

            self.tourne() #possibilité de tourner pour se  placer face à la pièce que l'on veut pousser
            if self.qui == 'humain':
                self.texte = QGraphicsTextItem(
                    "cliquez sur ok pour pousser")
                self.zone_txt.addItem(self.texte)
                self.texte.setPos(0, 180)

925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
            if self.qui == 'humain':
                x, y = self.pion_select.x()-x0, self.pion_select.y()-y0 # mouvement par rapport à la dernière case
                                                                  #
                [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]
            else:
                self.joueur[self.pion_select_num - 1].coords = [self.abs, self.ord]



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

            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()
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
953
954
955
                if self.pousse == False:
                    self.pion_select.setPos(0, 0)
                    self.joueur[self.pion_select_num - 1].coords = [l, self.pion_select_num - 1]
956

Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
957
958
959
960
961
                    # if self.qui == 'ia':
                    #     self.IA()
                # else:
                #     if self.qui == 'ia':
                #         self.joueur1()
962

Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
963
964
965
966
967
968
969
970
971
            else:
                if self.qui == 'humain':
                    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)
972
973
                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)
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
974
975
            # if self.qui == 'ia':
            #     self.joueur1()
976
977
978
979

        if self.dernier_bouton == 'tourner':
            if self.qui == 'ia':
                self.tourne()
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
980
981
982
983
984
            if self.qui == 'humain':
                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)
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
                #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

Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
        if self.qui == 'humain':
            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))
            self.zone_txt.addItem(self.texte)
            self.texte.setPos(0, 0)
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030

    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
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1031
1032
1033
1034
1035
1036
1037
        if self.qui == 'humain':
            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)
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048



    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
        C'est aussi la seule fonction hors ok() qui sera utilisée par l'ia"""
        self.dernier_bouton = 'tourner'
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1049
        go = True
1050
1051
1052
        #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
        if self.qui == 'humain':
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1053

1054
1055
1056
1057
1058
            for i in range(5):
                #self.dernier_bouton = 'tourner'
                if self.liste_el_qg[i].isSelected():
                    self.pion_select = self.liste_el_qg[i]
                    self.pion_select_num = i + 1
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1059

1060
                if self.liste_rh_qg[i].isSelected():
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1061

1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
                    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 du 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'}
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1094
        print(self.coup, self.qui)
1095
1096
1097
1098
        if self.qui == 'ia':
            if self.coup == 'tourner':  # si c'est un autre coup qui appele tourner, on connait déjà le pion
                self.pion_select_num = randint(1, 6)
                self.pion_select = self.joueur_qg[self.pion_select_num - 1]
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1099
1100
1101
            print(self.joueur[self.pion_select_num-1].coords)
            if (self.joueur[self.pion_select_num-1].coords[0] == -2):
                go = False
1102

Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1103
        if self.joueur[self.pion_select_num - 1].coords[0] not in [-2, 6] and go==True:
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
            #le pion est sur le plateau ou devant (pour entrer en poussant)

            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)
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1126
1127
1128
1129
1130
1131
1132
            if self.qui == 'humain':
                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)
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142

            # 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)
            # self.a_toune = True
            # if self.qui == 'ia':
            #     self.joueur1()
        else:
            self.a_tourne = False
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1143
1144
1145
1146
1147
1148
            # 0 # le tour n'a pas marché, l'ia doit rejouer
            if self.qui == 'humain':
                self.texte = QGraphicsTextItem(
                    "Vous ne pouvez tourner que si vous êtes déjà sur le plateau")
                self.zone_txt.addItem(self.texte)
                self.texte.setPos(0, 200)
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160


    def entrer(self):
        """ semblable aux fonctions déplacer et pousser"""
        self.dernier_bouton = 'entrer'
        self.zone_txt.clear()
        if self.qui == 'humain':
            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
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1161

1162
1163
                if self.liste_rh_qg[i].isSelected():
                    self.liste_rh_qg[i].setFlag(QGraphicsItem.ItemIsMovable)
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1164

1165
1166
1167
                    self.pion_select = self.liste_rh_qg[i]
                    self.pion_select_num = i + 1

Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
        if self.qui == 'humain':
            self.texte = QGraphicsTextItem("Vous avez choisis d'entrer votre pion"'\n'
                                           "{0}{1}, initialement orientée selon {2}."'\n'
                                           "Déplacez votre pion sur la case du plateau où vous"'\n'
                                           "souhaitez entrer. Attention vous ne pouvez  entrer que"'\n'
                                           "sur une case extérieure du plateau." '\n'
                                           "Appuyez sur ok et entrer l'orientation" '\n'
                                           "souhaitée".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, 0)
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189

    def sortir(self):
        """ toujour semblables aux fonctions précédente, mais le joueur n'a pas besoin de bouger sa pièce"""
        self.dernier_bouton = 'sortir'
        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
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1190

1191
1192
1193
1194
            if self.liste_rh_qg[i].isSelected():

                self.pion_select = self.liste_rh_qg[i]
                self.pion_select_num = i + 1
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1195
1196
1197
1198
1199
1200
1201
1202
1203
        if self.qui == 'humain':
            self.texte = QGraphicsTextItem("Vous avez choisis de sortir votre pion"'\n'
                                           "{0}{1}. Attention vous ne pouvez sortir votre pion"'\n'
                                           "que si la pièce est sur une case extérieure du plateau." '\n'
                                           "Appuyez sur ok pour valider votre action".format(
                self.joueur[self.pion_select_num - 1].car(),
                self.pion_select_num))
            self.zone_txt.addItem(self.texte)
            self.texte.setPos(0, 0)
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213

    def entrerp(self):
        """ toujours semblable aux autres"""
        self.dernier_bouton = 'entrer en poussant'
        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
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1214

1215
1216
            if self.liste_rh_qg[i].isSelected():
                self.liste_rh_qg[i].setFlag(QGraphicsItem.ItemIsMovable)
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1217

1218
1219
                self.pion_select = self.liste_rh_qg[i]
                self.pion_select_num = i + 1
Pauline LEYRIT's avatar
ok    
Pauline LEYRIT committed
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
        if self.qui == 'humain':
            self.texte = QGraphicsTextItem("Vous avez choisis d'entrer en poussant, avec"'\n'
                                           "votre pion {0}{1}. Vous pouvez maintenant le déplacer:"'\n'
                                           " placez le sur une case extérieure au plateau, devant"'\n'
                                           " la pièce que vous souhaitez pousser. "'\n'
                                           "Appuyer ensuite sur ok et choisissez votre orientation."'\n'
                                           "Vous devez être orienté face à la pièce à pousser." '\n'
                                           "Appuyez sur ok pour valider votre action".format(
                self.joueur[self.pion_select_num - 1].car(),
                self.pion_select_num))
            self.zone_txt.addItem(self.texte)
            self.texte.setPos(0, 0)
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338


    def vainqueur(self):
        """ fonction appelée lorsque la fonction pousser aboutit à la sortie du plateau d'une montagne
        cela signifie que le jeu est terminé
        cette fonction (la même que celle du même nom de la classe plateau) permet de connaitre le gagnant
        pour se faire, on connait déjà les coordonnées de la montagne sortie (pour savoir de quelle coté elle est
        sortie et en déduire dans quelle orientation doitêtre positionnée la pièce gagnante)
        on test donc les quatre coté d'où la montagne aurait ou sortir, et on teste quelle pièce est la plus proche,
        tout en étant bien orienté
        on en déduit alors le gagnant"""

        self.zone_txt.clear()
        bool=False
        m = self.mont_sorti

        if m.coords[0]==-1: #la montagne est sortie du plateau par la gauche
            while bool==False: #tant qu'on n'a pas trouvé le vainqueur
                for i in range (1,5): #on teste pour les coordonnées les plus proches d'abord, et lorsque i s'agrandit, on s'éloigne
                                     #on doit rester sur la même ligne car le gagnant a forcément participé à la poussée
                    for piece in self.ele:
                        if piece.coords[0]==m.coords[0]+i and piece.coords[1]==m.coords[1] and piece.orientation=='g':
                            winner=piece
                            bool=True
                            break  #on stop la bouv=cle for quand on a trouvé le gagnant
                    for piece in self.rh:
                        if piece.coords[0]==m.coords[0]+i and piece.coords[1]==m.coords[1] and piece.orientation=='g':
                            winner=piece
                            bool=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.ele:
                        if piece.coords[0]==m.coords[0]-i and piece.coords[1]==m.coords[1] and piece.orientation=='d':
                            winner=piece
                            bool=True
                            break
                    for piece in self.rh:
                        if piece.coords[0]==m.coords[0]-i and piece.coords[1]==m.coords[1] and piece.orientation=='d':
                            winner=piece
                            bool=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.ele:
                        if piece.coords[1]==m.coords[1]+i and piece.coords[0]==m.coords[0] and piece.orientation=='h':
                            winner=piece
                            bool=True
                            break
                    for piece in self.rh:
                        if piece.coords[1]==m.coords[1]+i and piece.coords[0]==m.coords[0] and piece.orientation=='h':
                            winner=piece
                            bool=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.ele:
                        if piece.coords[1]==m.coords[1]-i and piece.coords[0]==m.coords[0] and piece.orientation=='b':
                            winner=piece
                            bool=True
                            break
                    for piece in self.rh:
                        if piece.coords[1]==m.coords[1]+i and piece.coords[0]==m.coords[0] and piece.orientation=='b':
                            winner=piece
                            bool=True
                            break


        if bool==True and winner.car()=='R':  #le gaganant est un rhinocéros
            self.texte = QGraphicsTextItem("La partie est terminée !"'\n'
                                           "Félicitation aux rhinocéros qui ont gagné !"'\n'
                                           "le joueur 2 est donc vainqueur")
            self.zone_txt.addItem(self.texte)
            self.texte.setPos(0, 0)
        if bool== True and winner.car()=='E' : #le gagnant est un éléphant
            self.texte = QGraphicsTextItem("La partie est terminée !"'\n'
                                           "Félicitation aux éléphants qui ont gagné !"'\n'
                                           "le joueur 1 est donc vainqueur")
            self.zone_txt.addItem(self.texte)
            self.texte.setPos(0, 0)




    def showDialog(self): #affiche la boite de dialogue permettant au joueur d'etrer l'orientation choisie
        self.txt, ok = QInputDialog.getText(self, 'input dialog', 'Voulez vous tourner à droite? à gauche? ou faire demi-tour? ou ne rien faire ?')
        if ok: #si on appuie sur ok, ou sur la touche entrer

            return self.txt #on récuère le choix d'orientation du joueur, pour s'en servir dans tourner





if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = Window()
    sys.exit(app.exec_())