Un jeu de dé en POO et Tkinter

Bonjour,

Je me suis lancé il y a peu dans un petit jeu de plateau : les petits chevaux.
Et durant la partie des jets de dés, je suis tombé sur une curiosité que je n'explique pas.

Je n'en suis qu'au tout début. Pour l'instant, j'ai créé la classe Plateau(Canvas) et la classe Joueur.
Un bouton lance la méthode jetDes de la classe Joueur qui simulent le lancer de trois dés et rentre la valeur des dés dans l'attribut des de la classe Joueur.
changeDes est une méthode de la classe Plateau qui gère l'affichage. :

Code:

1
2
3
4
5
6
7
8
9
    def jetDes(self):
        self.des[0]=randrange(8)+1
        self.plat.changeDes(0,self.des[0])
        time.sleep(1)
        self.des[1]=randrange(8)+1
        self.plat.changeDes(1,self.des[1])
        time.sleep(1)
        self.des[2]=randrange(8)+1
        self.plat.changeDes(2,self.des[2])

J'ai ajouté un time.sleep entre chaque dés pour laisser un temps entre l'affichage de chaque dé.
Mais le truc bizarre c'est que les 3 dés s'affiche quand même en même temps.

Au début je croyait que l'erreur pouvait venir de la commande sleep, alors je l'ai remplacé par un for i in range(1000): print(i), mais la même erreur se produisait :
Les entiers de 0 à 999 s'affichaient (2 fois), puis les trois dés d'un coup.

Ce n'est pas gênant pour la suite mais je suis quand même curieux de savoir pourquoi cela fait ça.
J'utilise Python 2.7.6.

Voici le code complet pour ceux qui voudrait essayer, mais vu que je code pour moi, je commente très peu.
Merci pour votre aide.

Code:

1
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
49
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
# -*- coding: cp1252 -*-
 
# import
from Tkinter import *
from random import randrange
import time
 
def cercle(can,x,y,r,coul="white",bord="black"):
    return can.create_oval(x-r,y-r,x+r,y+r, fill=coul, outline=bord)
 
def rectangle(can, x,y,lx,ly,coul="white",bord="black"):
    return can.create_polygon(x-lx/2,y-ly/2, x-lx/2,y+ly/2, x+lx/2,y+ly/2, x+lx/2,y-ly/2,
                              fill=coul, outline=bord)
 
##### CLASS #####
 
class Plateau(Canvas):
    "Canvas du plateau de jeu des petits chevaux"
    def __init__(self, boss=None, r=10):
        "Constructeur du plateau de jeu des petits chevaux"
        # parametres
        self.boss=boss
        self.rayon=r
        self.couleurPlat='light goldenrod'
        #self.couleur=['red', 'blue', 'green', 'purple']
        self.couleurFond=['coral', 'light blue', 'light green', 'MediumPurple1']
 
        # construction du widget parent
        Canvas.__init__(self)
        n=47*r
        self.configure(width=n,height=n, bg=self.couleurPlat)
        self.grid(row=1, column=1, rowspan=10)
 
        # dessin du plateau
            # chemin
        caseX=[20*r,20*r,20*r,20*r,20*r,20*r,20*r,17*r,14*r,11*r,8*r,5*r,2*r,2*r,
               2*r,5*r,8*r,11*r,14*r,17*r,20*r,20*r,20*r,20*r,20*r,20*r,20*r,24*r,
               28*r,28*r,28*r,28*r,28*r,28*r,28*r,31*r,34*r,37*r,40*r,43*r,46*r,46*r,
               46*r,43*r,40*r,37*r,34*r,31*r,28*r,28*r,28*r,28*r,28*r,28*r,28*r,24*r]
        caseY=[46*r,43*r,40*r,37*r,34*r,31*r,28*r,28*r,28*r,28*r,28*r,28*r,28*r,24*r,
               20*r,20*r,20*r,20*r,20*r,20*r,20*r,17*r,14*r,11*r,8*r,5*r,2*r,2*r,
               2*r,5*r,8*r,11*r,14*r,17*r,20*r,20*r,20*r,20*r,20*r,20*r,20*r,24*r,
               28*r,28*r,28*r,28*r,28*r,28*r,28*r,31*r,34*r,37*r,40*r,43*r,46*r,46*r]
        caseCoul=[self.couleurFond[0]]*14+[self.couleurFond[1]]*14+[self.couleurFond[2]]*14+[self.couleurFond[3]]*14
        for i in range(14*4):
            cercle(self,caseX[i],caseY[i],r, coul=caseCoul[i], bord='white')
            # maison
        self.create_polygon(0,47*r, 0,30*r, 18*r,30*r, 18*r,47*r, fill=self.couleurFond[0], outline='white')
        self.create_polygon(0,18*r, 0,0, 18*r,0, 18*r,18*r, fill=self.couleurFond[1], outline='white')
        self.create_polygon(30*r,18*r, 30*r,0, 47*r,0, 47*r,18*r, fill=self.couleurFond[2], outline='white')
        self.create_polygon(30*r,47*r, 30*r,30*r, 47*r,30*r, 47*r,47*r, fill=self.couleurFond[3], outline='white')
            # ecurie
        ecuX=[24*r,24*r,24*r,24*r,24*r,24*r,
              5*r,8*r,11*r,14*r,17*r,20*r,
              24*r,24*r,24*r,24*r,24*r,24*r,
              28*r,31*r,34*r,37*r,40*r,43*r]
        ecuY=[43*r,40*r,37*r,34*r,31*r,28*r,
              24*r,24*r,24*r,24*r,24*r,24*r,
              20*r,17*r,14*r,11*r,8*r,5*r,
              24*r,24*r,24*r,24*r,24*r,24*r]
        eculx=[3*r]*6+[2*r]*6+[3*r]*6+[2*r]*6
        eculy=[2*r]*6+[3*r]*6+[2*r]*6+[3*r]*6
        ecuCoul=[self.couleurFond[0]]*6+[self.couleurFond[1]]*6+[self.couleurFond[2]]*6+[self.couleurFond[3]]*6
        for i in range(4*6):
            rectangle(self, ecuX[i], ecuY[i], eculx[i], eculy[i], coul=ecuCoul[i], bord='white')
            # des
        self.des=[Canvas(boss, bg='white', height=70, width=70),
                 Canvas(boss, bg='white', height=70, width=70),
                 Canvas(boss, bg='white', height=70, width=70)]
        self.desPoint=[]
        for i in range(len(self.des)):
            self.des[i].grid(row=i+2, column=2)
            self.desPoint.append([cercle(self.des[i], 15,15,5, coul='white', bord='white'),
                                  cercle(self.des[i], 15,35,5, coul='white', bord='white'),
                                  cercle(self.des[i], 15,55,5, coul='white', bord='white'),
                                  cercle(self.des[i], 55,15,5, coul='white', bord='white'),
                                  cercle(self.des[i], 55,35,5, coul='white', bord='white'),
                                  cercle(self.des[i], 55,55,5, coul='white', bord='white'),
                                  cercle(self.des[i], 35,25,5, coul='white', bord='white'),
                                  cercle(self.des[i], 35,35,5, coul='white', bord='white'),
                                  cercle(self.des[i], 35,45,5, coul='white', bord='white')])
 
 
 
    def changeDes(self, noDe, no):
        point=[[0,0,0,0,0,0,0,0,0],
               [0,0,0,0,0,0,0,1,0],
               [1,0,0,0,0,1,0,0,0],
               [1,0,0,0,0,1,0,1,0],
               [1,0,1,1,0,1,0,0,0],
               [1,0,1,1,0,1,0,1,0],
               [1,1,1,1,1,1,0,0,0],
               [1,1,1,1,1,1,0,1,0],
               [1,1,1,1,1,1,1,0,1]]
        for i in range(9):
            if point[no][i]==0:
                self.des[noDe].itemconfigure(self.desPoint[noDe][i],fill='white')
            else:
                self.des[noDe].itemconfigure(self.desPoint[noDe][i],fill='black')
 
 
 
 
 
 
class Joueur:
    "Joueur de petits chevaux"
    def __init__(self, root, coul="red", nb=4, initX=5,initY=34):
        "Constructeur des joueurs de petits chevaux"
        # parametre
        self.plat=plat
        self.coul=coul
        self.nb=nb
        self.rayon=self.plat.rayon
        self.des=[0,0,0]
        self.initX=[]
        self.initY=[]
        for i in range(self.nb):
            self.initX.append(self.rayon*(initX+i*3))
            self.initY.append(self.rayon*(initY+i*3))
 
        # chevaux
        self.cheval=[]
        for i in range(self.nb):
            self.cheval.append(cercle(self.plat, self.initX[i],self.initY[i], self.rayon,
                                                coul=self.coul, bord="black"))
        self.chevalCoordX=self.initX
        self.chevalCoordY=self.initY
        self.chevalSelec=None
 
    def jetDes(self):
        self.des[0]=randrange(8)+1
        self.plat.changeDes(0,self.des[0])
        time.sleep(1)
        self.des[1]=randrange(8)+1
        self.plat.changeDes(1,self.des[1])
        time.sleep(1)
        self.des[2]=randrange(8)+1
        self.plat.changeDes(2,self.des[2])
 
 
 
 
 
 
 
 
 
 
##### MAIN #####
if __name__=='__main__':
    root=Tk()
    root.title("Petits cheveaux")
    ##### test fonctions
    #can=Canvas(root)
    #can.grid()
    #cercle(can, 50,50,10)
    #cercle(can, 100,20,15, coul='red', bord='green')
    #rectangle(can, 20,30,5,30)
    #rectangle(can,100,50,20,10 ,coul='blue', bord='yellow')
 
    #### test class Plateau
    plat=Plateau(root)
    plat.grid(row=1, column=1, rowspan=10)
    j1=Joueur(plat)
    Button(root, text="Lancer dés", command=j1.jetDes).grid(row=1, column=2)
 
    J1=Joueur(plat)
 
 
 
 
 
    root.mainloop()

Bonjour

Citation:

Envoyé par kirq-geb

Ce n'est pas gênant pour la suite mais je suis quand même curieux de savoir pourquoi cela fait ça.

C'est parce que la fonction "jetDes" n'affiche pas les dés, elle se contente de les créer.
L'affichage est géré automatiquement par Tk. Donc les sleep de ta fonction la font attendre mais ce n'est que quand elle se termine que Tk reprend la main et affiche ses éléments.
Si tu veux temporiser l'affichage, il te faut alors manipuler les outils Tk qui gèrent le raffraichissement et mettre tes tempo à cet endroit.

Accessoirement, les boucles c'est pas fait pour les chiens
Code:

1 2 3 4 5 6 def jetDes(self): for i in xrange(3): self.des[i]=randrange(8)+1 self.plat.changeDes(i,self.des[i]) # for # jetDes()

Merci de ta réponse rapide et claire !
Je vais essayer de modifier ça.

J'avais mis une boucle au début mais je l'ai enlevé pour essayer de trouver ce qui clochait par moi-même avant de venir ici.