Projet ISN - Jeu memory

**progmateur** · 26/05/2014, 21h59

Bonsoir,

Je suis un programmeur tres amateur et il faudrait que je présente mon projet d'isn en fin d'année. Mon projet est un jeu memory et j'ai fait la plus grosse partie du travail avec des amis mais je n'arrive pas a poursuivre.
Je voudrai faire 3 choses:
La premiere supprimer les deux cartes selectionnés si elles sont bonnes.
deuxièmement: si les deux cartes sont fausses les reretourner et changer de joueur
troisièmement: recommencer a jouer après avoir gagné sur le tour précédent. voila mon code s'il vous plait aidez moi j'ai grandement besoin d'aide

:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
from tkinter import *
from random import randint
 
# ----- variables globales ---------------------------------------------------
images = []         # liste qui contient les images
cartes = []         #  liste des différentes cartes
cartes_jouees = []  # liste qui contient les cartes jouées
nb_lignes, nb_colonnes = 5, 4
cartes_gagnees, nb_cartes_jouees = 0, 0
joueur_actuel = 1
nb_joueurs = 2
score = [0,0]
 
 
# ----- Création du canvas --------------------------------------------------------
def creer_canevas(fen, col, lig):
    return Canvas(fen, width=(110*col)+10, height=(110*lig)+10, bg='green')
 
# ----- Images ----------------------------------------------------------------
def charger_images():
 
    nb_images = 21  # l'image no 0 est le dos des cartes
 
    for i in range(nb_images):           # importation des images
        nom = 'im' + str(i) + '.gif'
        monimage = PhotoImage(file = nom)
        images.append(monimage)
    return images
 
# ----- Melange des cartes -----------------------------------------------------
 
def melange_les_cartes() :
 
    nb_cartes = nb_colonnes*nb_lignes                              #le nombre de carte est égal au nombre de carte en abscisse multiplié par le nombre de carte en ordonnée
    maliste = list(range(1,nb_cartes//2+1))*2      #on définit les cartes
    for i in range(nb_cartes):                    #pour i allant de 0 à nombre de cartes
        x = randint(0,nb_cartes-1)         #on choisit aléatoirement une carte se trouvant sur l'axe x sur l'intervalle i à nombre de carte
        y = randint(0,nb_cartes-1)         #on choisit aléatoirement une carte se trouvant sur l'axe y sur l'intervalle i à nombre de carte
        maliste[x],maliste[y]=maliste[y],maliste[x]   #inverse la place des cartes en abscisses et celles en ordonnée
    return maliste
 
 
def initialise(nb_colonnes,nb_lignes,images):
    for i in range(nb_colonnes):
 
        for j in range(nb_lignes):
 
            canvas.create_image((110*i)+60, (110*j)+60, image = images[0])
 
 
def coordonnees(pos):
     x=int((pos-1)%4*110)+60
     y=int((pos-1)//4*110)+60
     return (x,y)
#
 
def position(x,y):
    return x//110+1+4*(y//110)
 
 
def Clic(event):
    global compteur,listpos
    compteur=compteur+1
 
 
    X=event.x
    Y=event.y
 
 
 
    #d'apres les coordonnees on repere le numero de l'image a afficher
    numero=position(X,Y)
    #d'apres le numero on repere les coordonnes du coin sup gauche pour afficher l'image a cette place
    (afx,afy)=coordonnees(numero)
 
    #on affiche l'image de numero correspondant a la liste aleatoire cartealea
    if compteur<3:
        listpos.append(numero)
        canvas.create_image(afx,afy, image = images[cartealea[numero-1]])
 
    else:
        if cartealea[listpos[0]-1]==cartealea[listpos[1]-1]:
            print('gagné')
 
        else:
            (afx,afy)=coordonnees(listpos[0])
            canvas.create_image(afx,afy, image = images[0])
            (afx,afy)=coordonnees(listpos[1])
            canvas.create_image(afx,afy, image = images[0])
 
        compteur=0
        listpos=[]
 
# ----- Programme principal ----------------------------------------------------
 
 
 
fenetre = Tk()
 
Largeur = 450
Hauteur = 550
compteur=0
listpos=[]
 
#la liste images contient les 21 images (dos + 2 fois 10 images)
images=charger_images()
canvas = Canvas(fenetre,width = Largeur, height =Hauteur)
 
#cree une liste aléatoire de 20 nombres entre 1 et 10 apparaissant deux fois
cartealea=melange_les_cartes()
 
#affiche le dos des cartes
 
initialise(nb_colonnes,nb_lignes,images)
 
#lorsque l'utilisateur clique on appelle la fonction Clic, il va falloir changer cette fonction Clic, pour que lorsque l'utilisateur clique deux fois le programme
#soit laisse les images dans le cas ou ce sont les mêmes, soit affiche le "dos"
 
 
canvas.bind('<Button-1>',Clic)
 
 
canvas.pack()
 
fenetre.mainloop()

Invité · 27/05/2014, 11h49

Allez va, juste pour le fun :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
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
251
252
253
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
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
import random
 
from tkinter import *
 
 
# ----- zone de définition des fonctions -------------------------------
 
 
def init_jeu ():
    "initialisation données du jeu"
 
    global delai
    global nb_cartes_trouvees, liste_id_cartes, cartes_melangees
 
    # init délai affichage cartes (en ms)
    delai = random.choice([500, 600, 700, 800, 900, 1000, 1200])
 
    # vérification console (debug)
    #~ print("délai choisi:", delai)
 
    # init
    nb_cartes_trouvees = 0
 
    # affiche le dos des cartes
    # crée une liste d'identifiants
    # de cartes sur le canevas
    liste_id_cartes = initialiser_canevas()
 
    # crée une liste aléatoire
    # de 20 nombres entre 1 et 10
    # apparaissant deux fois
    cartes_melangees = melanger_les_cartes()
 
    # pour la gestion des clics souris
    raz_clics_souris()
 
# end def
 
 
def initialiser_canevas ():
    "remplissage du canevas avec des dos de cartes"
 
    # on commence par effacer le canevas
    canvas.delete(ALL)
 
    # init liste des identifiants de cartes
    liste_ids = []
 
    # on parcourt les lignes
    for ligne in range(nb_lignes):
 
        # on parcourt les colonnes
        for colonne in range(nb_colonnes):
 
            # on met en place les dos de cartes
            # on en profite pour "marquer" les cartes (tags)
            liste_ids.append(
                canvas.create_image(
                    110*colonne+10, 110*ligne+10,
                    anchor=NW, image=dos_carte, tags="cartes",
                )
            )
 
        # end for
 
    # end for
 
    return liste_ids
 
# end def
 
 
def charger_images ():
    "mise en mémoire des images des cartes à jouer"
 
    # l'image no 0 est le dos des cartes
    nb_images = 1 + nb_total_cartes // 2
 
    # quitte à faire propre
    # autant le faire jusqu'au bout
    images = []
 
    # on importe les images en mémoire
    for i in range(nb_images):
 
        # on ajoute une nouvelle image à la liste
        images.append(PhotoImage(file="im{}.gif".format(i)))
 
    # end for
 
    return images
 
# end def
 
 
def melanger_les_cartes ():
    "création d'une liste d'indices de cartes mélangés"
 
    # liste des indices de cartes
    liste = list(range(1, nb_total_cartes//2 + 1)) * 2
 
    # vérification console (debug)
    #~ print("indices de cartes:", liste)
 
    # on mélange les indices de cartes
    random.shuffle(liste)
 
    # vérification console (debug)
    #~ print("indices de cartes mélangés:", liste)
 
    return liste
 
# end def
 
 
def masquer_cartes ():
    "on retourne toutes les cartes du canevas"
 
    canvas.itemconfigure("cartes", image=dos_carte)
 
    # RAZ données de clics souris
    raz_clics_souris()
 
# end def
 
 
def supprimer_cartes ():
    "on supprime les cartes qui matchent"
 
    global nb_cartes_trouvees
 
    # suppression cartes 1 et 2
    canvas.delete(id_carte1)
    canvas.delete(id_carte2)
 
    # màj nb de cartes trouvées
    nb_cartes_trouvees += 2
 
    # la partie est-elle terminée ?
    if nb_cartes_trouvees >= nb_total_cartes:
 
        # fin de partie
        bravo()
 
    # non, on continue de jouer
    else:
 
        # RAZ données de clics souris
        raz_clics_souris()
 
    # end if - game over
 
# end def
 
 
def bravo ():
    "la partie est terminée - félicitations"
 
    # on efface d'abord le canevas
    canvas.delete(ALL)
 
    # point central du canevas
    x, y = canvas.winfo_reqwidth()//2, canvas.winfo_reqheight()//2
 
    # on affiche un message sympa
    canvas.create_text(
        x, y-40,
        text="BRAVO !",
        font="sans 32 bold",
        fill="blue"
    )
    canvas.create_text(
        x, y,
        text="Bien joué !",
        font="sans 16 bold",
        fill="dark blue"
    )
 
    # bouton rejouer
    canvas.create_window(
        x, y+40,
        window=Button(canvas, text="Rejouer", command=init_jeu),
    )
 
# end def
 
 
def raz_clics_souris ():
    "remise à zéro (RAZ) des données clics souris"
 
    global id_carte1, id_carte2
 
    id_carte1 = id_carte2 = 0
 
# end def
 
 
def sur_clic_souris (event):
    "gestionnaire événements clics souris"
 
    global id_carte1, id_carte2
 
    # init coordonnées clic souris
    x, y = event.x, event.y
 
    # recherche de carte
    collisions = canvas.find_overlapping(x, y, x, y)
 
    # le joueur a cliqué sur une carte ?
    if collisions and collisions[0] in liste_id_cartes:
 
        # init ID carte
        id_carte = collisions[0]
 
        # première carte à retourner ?
        if id_carte1 == 0:
 
            # init IDs cartes
            id_carte1 = id_carte
            id_carte2 = 0
 
            afficher_carte(id_carte1)
 
        # deuxième carte à retourner ?
        elif id_carte2 == 0 and id_carte != id_carte1:
 
            # init ID carte
            id_carte2 = id_carte
 
            afficher_carte(id_carte2)
 
            # correspondance trouvée ?
            if correspondance(id_carte1, id_carte2):
 
                # supprimer les cartes au bout d'un délai
                fenetre.after(delai, supprimer_cartes)
 
            # pas de correspondance trouvée
            else:
 
                # retourner les cartes au bout d'un délai
                fenetre.after(delai, masquer_cartes)
 
            # end if - correspondance
 
        # end if - cartes à jouer
 
    # end if - collisions
 
# end def
 
 
def afficher_carte (id_carte):
    "affiche la carte correspondant à l'ID de canvasItem"
 
    # affichage carte
    canvas.itemconfigure(id_carte, image=images[valeur_carte(id_carte)])
 
# end def
 
 
def valeur_carte (id_carte):
    "retourne la valeur de la carte correspondant à l'ID de canvasItem"
 
    # init index carte
    index = liste_id_cartes.index(id_carte)
 
    # valeur carte à cet emplacement
    return cartes_melangees[index]
 
# end def
 
 
def correspondance (id1, id2):
    "vérifie la correspondance entre deux valeurs de cartes"
 
    return bool(valeur_carte(id1) == valeur_carte(id2))
 
# end def
 
 
# ----- variables globales ---------------------------------------------
 
# init matrice jeu
nb_lignes, nb_colonnes = 5, 4
nb_total_cartes = nb_lignes * nb_colonnes
 
 
# ----- Programme principal --------------------------------------------
 
# fenêtre principale
fenetre = Tk()
fenetre.title("Jeu de Memory")
fenetre.resizable(width=False, height=False)
 
# la liste images contient
# les 11 images (dos + 10 images)
images = charger_images()
 
# init dos carte
dos_carte = images[0]
 
# init canevas graphique
canvas = Canvas(fenetre, width=450, height=550)
canvas.pack()
 
# init données jeu
init_jeu()
 
# gestionnaire clics souris
canvas.bind('<Button-1>', sur_clic_souris)
 
# bouton quitter
Button(
    fenetre,
    text="Quitter",
    command=fenetre.destroy
).pack(side=RIGHT, padx=5, pady=5)
 
# boucle principale
fenetre.mainloop()

Le jeu complet en archive zip (cliquez pour télécharger) : jeu-de-memory.zip

Amusez-vous bien !

**progmateur** · 27/05/2014, 18h10

merci beaucoup pour votre réponse mais je voudrai faire un truc a partir de mon propre code. Est ce que vous pourriez juste afficher un code qui ira avec le miens qui empeche le clic sur la même carte? Juste ceci devrai suffire et ça serai vraiment génial de votre part!

**wiztricks** · 27/05/2014, 18h17

merci beaucoup pour votre réponse mais je voudrai faire un truc a partir de mon propre code. Est ce que vous pourriez juste afficher un code qui ira avec le miens qui empeche le clic sur la même carte? Juste ceci devrai suffire et ça serai vraiment génial de votre part!

Pourquoi ne pas essayer de comprendre comment marche le code qui vous a été fourni?
Vous pourriez ensuite adapter votre code ou poser des questions sur les constructions que vous ne comprenez pas.

- W

Invité · 27/05/2014, 18h24

désolé, je ne suis pas partisan de mettre la cuiller dans la bouche des débutants.

Le casse-croûte a été confectionné à partir de votre recette et il est maintenant posé sur la table.

En plus, il est richement assaisonné de commentaires : il ne vous reste plus qu'à soulever les feuilles de salade pour trouver réponse à toutes vos questions.

Et vous perdriez moins de temps à plonger dans le code qu'à poser des questions sur un forum, vu le nombre de commentaires laissés dans ce code.

Allez, on sort le bidon d'huile de coude et au boulot, Jamie.

@+.

**progmateur** · 27/05/2014, 18h26

bah justement on a essayé de comprendre mais on y arrive pas et quand on demande a notre prof de nous aider il nous réponds pas voila pourquoi je demande de l'aide sur ce site

**wiztricks** · 27/05/2014, 18h53

Envoyé par progmateur

bah justement on a essayé de comprendre mais on y arrive pas et quand on demande a notre prof de nous aider il nous réponds pas voila pourquoi je demande de l'aide sur ce site

Les trucs que vous ne comprenez pas voilà de bonnes questions à poser.

- W

**progmateur** · 27/05/2014, 19h08

Oui c'est ce qu'on demande on comprends pas la fonction clic mais il nous dit qu'on doit se débrouiller et pas juste une partie mais vraiment toute la fonction clic.
Il me reste moins d'une semaine pour finir le programme et on voit pas du tout comment avancer on est bloqués juste par ce probleme

**wiztricks** · 27/05/2014, 19h19

Envoyé par progmateur

Oui c'est ce qu'on demande on comprends pas la fonction clic mais il nous dit qu'on doit se débrouiller et pas juste une partie mais vraiment toute la fonction clic.
Il me reste moins d'une semaine pour finir le programme et on voit pas du tout comment avancer on est bloqués juste par ce probleme

Il n'y a pas de fonction "clic" dans le code de tarball69, juste une fonction appelée "sur_clic_souris".
Ce que çà fait est largement documenté.
Vous ne devriez avoir de problèmes que sur "comment" çà le fait.

- W

**progmateur** · 27/05/2014, 19h33

J'aimerai justement adapter le sien au miens. J'ai donc cherché a comment empecher le clic deux fois sur une meme zone (d'apres mon programme) et j'ai pas trouvé et pourtant je peux vous assurer avoir fait mon maximum mais je ne vois pas comment le faire dans le miens pourtant j'ai trouvé d'autres exemples sur le memory sur internet et en combinant ces exemples avec mon programme j'arrive pas a faire en sorte de ne pas cliquer deux fois sur la meme zone.

Invité · 27/05/2014, 20h36

Envoyé par progmateur

J'aimerai justement adapter le sien au miens. J'ai donc cherché a comment empecher le clic deux fois sur une meme zone (d'apres mon programme) et j'ai pas trouvé et pourtant je peux vous assurer avoir fait mon maximum mais je ne vois pas comment le faire dans le miens pourtant j'ai trouvé d'autres exemples sur le memory sur internet et en combinant ces exemples avec mon programme j'arrive pas a faire en sorte de ne pas cliquer deux fois sur la meme zone.

Bon, je vous donne quelques indices.

Quand on clique sur un tkinter.Canvas(), on peut récupérer à la position (event.x, event.y) tous les éléments graphiques dessinés sur le canevas (éléments appelés canvasItems) qui ont au moins une intersection avec cette position (event.x, event.y).

On appelle généralement collisions le "choc" entre la flèche de la souris à (event.x, event.y) et les canvasItems se trouvant à cet endroit.

Un objet tkinter.Canvas() gère ses éléments graphiques dessinés en les identifiant avec un ID de canvasItem (ID = nombre entier unique et distinct pour chaque élément créé).

Perso, j'utilise canvas.find_overlapping(x,y,x,y) pour récupérer la liste des identifiants des canvasItems se trouvant à l'intersection de (event.x, event.y).

Voir documentation : http://infohost.nmt.edu/tcc/help/pub...s-methods.html

Extrait :

.find_overlapping(x1, y1, x2, y2)

Like the previous method, but returns a list of the object IDs of all the objects that share at least one point with the given rectangle.

Comme dans ce jeu les seuls canvasItems qui ont été créés sur le tkinter.Canvas() sont des cartes à jouer, il y a de très fortes probabilités pour que le ou les IDs de canvasItems détectés lors d'une collision soient des IDs de cartes à jouer.

Mais algorithmiquement parlant, on se doit de s'en assurer en comparant l'ID en tête de liste de collisions avec la liste liste_id_cartes qui elle contient tous les IDs des cartes à jouer créées durant l'appel de la fonction initialiser_canevas().

D'où le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
    # init coordonnées clic souris
    x, y = event.x, event.y
 
    # recherche de carte
    collisions = canvas.find_overlapping(x, y, x, y)
 
    # le joueur a cliqué sur une carte ?
    if collisions and collisions[0] in liste_id_cartes:
 
        # init ID carte
        id_carte = collisions[0]

La variable collisions est une liste (objet Python list()) d'identifiants e.g. collisions = [1, 125, 2235, 2, 3, 5] et le premier élément listé est toujours l'ID du canvasItem au premier plan d'affichage. Plus vous parcourez cette liste et plus vous descendez dans les plans d'affichage jusqu'à atteindre l'arrière-plan avec le dernier élément de la liste.

Donc, comme on veut l'élément au premier plan (grosso modo, l'élément qui se trouve tout de suite "sous" la souris, si on regarde en 3D l'empilement des canvasItems), on doit extraire le premier élément de la liste collisions donc id_carte = collisions[0].

Documentation sur les listes Python : https://docs.python.org/3/library/st....html#typesseq

Ensuite, on ne tombe pas dans le piège du comptage du nb de clics souris pour détecter si la première carte doit être retournée (ni d'ailleurs pour traiter la seconde carte, évidemment).

En effet, si le joueur clique dans un interstice entre deux cartes à jouer alors la fonction sur_clic_souris() sera quand même appelée et le compteur de nb de clics souris continuera d'augmenter, ce qui faussera le test "première carte à retourner" si on se base sur un compteur de clics.

De même, si le joueur clique plusieurs fois sur la première carte à retourner, comment déterminer le moment où il cliquera enfin sur une seconde carte à retourner, différente de la première carte retournée, si on utilise un compteur de clics souris ?

Non, laissez les clics souris filer comme ils veulent, ce qui nous intéresse, c'est d'identifier les cartes à retourner grâce -justement- à leurs identifiants IDs de canvasItems.

Et c'est justement ce que nous faisons ici :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
        # première carte à retourner ?
        if id_carte1 == 0:
 
            # init IDs cartes
            id_carte1 = id_carte
            id_carte2 = 0
 
            afficher_carte(id_carte1)
 
        # deuxième carte à retourner ?
        elif id_carte2 == 0 and id_carte != id_carte1:
 
            # init ID carte
            id_carte2 = id_carte
 
            afficher_carte(id_carte2)
 
            # correspondance trouvée ?
            if correspondance(id_carte1, id_carte2):
 
                # supprimer les cartes au bout d'un délai
                fenetre.after(delai, supprimer_cartes)
 
            # pas de correspondance trouvée
            else:
 
                # retourner les cartes au bout d'un délai
                fenetre.after(delai, masquer_cartes)
 
            # end if - correspondance
 
        # end if - cartes à jouer

Note : un identifiant ID de canvasItem est toujours un entier strictement positif (ID > 0) donc quand on teste id_carte1 == 0 ou id_carte2 == 0, on indique de id_carte1(ou 2) ne correspond à aucun ID de canvasItem connu.

Pour le reste, on vérifie s'il y a correspondance entre les valeurs des cartes carte1 et carte2 identifiées par leurs IDs de canvasItems id_carte1 et id_carte2 par le biais de la fonction correspondance() et on prend les décisions qui s'imposent en fonction du résultat de ce test.

Pour fenetre.after(), je vous renvoie à la documentation : http://infohost.nmt.edu/tcc/help/pub...universal.html

Extrait :

The methods are defined below on all widgets. In the descriptions, w can be any widget of any type.

w.after(delay_ms, callback=None, *args)

Requests Tkinter to call function callback with arguments args after a delay of at least delay_ms milliseconds. There is no upper limit to how long it will actually take, but your callback won't be called sooner than you request, and it will be called only once.

This method returns an integer “after identifier” that can be passed to the .after_cancel() method if you want to cancel the callback.

If you do not pass a callback argument, this method waits delay_ms milliseconds, as in the .sleep() function of the standard Python time module.

w.after_cancel(id)

Cancels a request for callback set up earlier .after(). The id argument is the result returned by the original .after() call.

C'est juste une façon de reporter à plus tard l'exécution d'une fonction.

Voilà. Vous avez tout pour comprendre et pour réussir maintenant.

@+.

**wiztricks** · 27/05/2014, 20h46

Envoyé par progmateur

J'aimerai justement adapter le sien au miens. J'ai donc cherché a comment empecher le clic deux fois sur une meme zone (d'apres mon programme) et j'ai pas trouvé et pourtant je peux vous assurer avoir fait mon maximum mais je ne vois pas comment le faire dans le miens pourtant j'ai trouvé d'autres exemples sur le memory sur internet et en combinant ces exemples avec mon programme j'arrive pas a faire en sorte de ne pas cliquer deux fois sur la meme zone.

Techniquement, vous ne pouvez pas trop empêcher l'utilisateur de cliquer 2 fois au même endroit.
Par contre, vous pouvez modifier l'interprétation de ce "clic" par votre programme pour:

retourner la carte ou pas (çà dépend de l'état de la carte) ou
ignorer les clics pendant un certain temps.

Le premier point est dans le code de tarball69.
Pour le second, il suffit d'ajouter à la fonction qui attrape les clics une mécanique qui ressemble à ce qui suit:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> import tkinter as tk
>>> import time
>>> canvas = tk.Canvas()
>>> canvas.pack()
>>> ignore_clicks = 0
>>> def on_click(e):
...     global ignore_clicks
...     now = time.time()
...     if now - ignore_clicks > 0.5:
...        print('action')
...        ignore_clicks = time.time()
...     else:
...        print ('ignore')
...
>>> canvas.bind('<1>', on_click)
>>> tk.mainloop()

- W

**progmateur** · 27/05/2014, 21h04

Du coup Est-ce qu'il faut que je change toute ma fonction clic?
Parce que je vois bien qu'il faut utiliser ID pour pouvoir empêcher le clic deux fois sur la même carte mais je vois pas comment l'intégrer
de même pour le code que vous avez envoyé wiztricks

**wiztricks** · 28/05/2014, 00h32

Envoyé par progmateur

Du coup Est-ce qu'il faut que je change toute ma fonction clic?
Parce que je vois bien qu'il faut utiliser ID pour pouvoir empecher le clic deux fois sur la même carte mais je vois pas comment l'intégrer
de meme pour le code que vous avez envoyé wiztricks

Désolé, mais je ne vois pas comment vous aider plus.

- W