problème d'affichage dune image avec Tkinter

Version imprimable

28/03/2014, 09h50
destroy51

problème d'affichage dune image avec Tkinter

Bonjour,
Je suis en train de programmer le jeu du cavalier en Python avec le module Tkinter.
Il marche très bien mais je voudrais remplacer les ronds par des images gif et je n'y arrive pas... A l'aide !!!

J'ai remplacé ma ligne :
can.create_oval(x-r, y-r, x+r, y+r, fill='red')

par

photo=PhotoImage(file= "toto.gif")
can.create_image(400,400,image=photo)

mon fichier toto.gif étant dans le même répertoire que mon programme.
Je n'ai pas de message d'erreur mais rien ne s'affiche, pourquoi?
merci de votre aide.
28/03/2014, 11h41
psyphi

Merci d'utiliser la balise code quand tu postes du code dans le forum.
Essaye avec "./toto.gif". Némaoins tu devrais faire un test de l'existence du fichier image avant d'essayer de l'ouvrir.
28/03/2014, 12h38
destroy51

Désolé pour la balise, je suis nouveau sur le forum.
Merci pour ta réponse, mais comment je peux faire un test de l'existence du fichier image?
28/03/2014, 13h14
psyphi
Code:

1 2 3 import os.path os.path.isfile(fname)
28/03/2014, 15h29
destroy51

Je viens de rajouter les 2 lignes de codes.
J'ai une erreur : argument should be string, bytes or integer, not PhotoImage
mais oh surprise, mon image est sur l'échiquier.
Si ma déduction est bonne, cela voudrait dire qu'il l'affiche bien mais qu'elle disparait aussitôt...
Que dois-je faire pour qu'elle ne disparaisse pas ?
28/03/2014, 15h44
wiztricks
Salut,

Citation:

Envoyé par destroy51

Que dois-je faire pour qu'elle ne disparaisse pas ?

Si vous ne montrez pas plus de code que:
Code:

1 2 photo=PhotoImage(file= "toto.gif") can.create_image(400,400,image=photo)
On peut juste penser que photo est variable locale d'une fonction.
Un truc comme:
Code:

1 2 can._photo = photo=PhotoImage(file= "toto.gif") can.create_image(400,400,image=photo)
devrait "mieux" fonctionner.

Le truc est que photo (instance de PhotoImage) étant détruite a la sortie de la fonction, il n'y aura plus d'image a afficher.
- W
28/03/2014, 15h54
destroy51

Super,
ça marche !!!
Encore merci pour toutes les infos...
28/03/2014, 20h14
destroy51

J'ai un nouveau problème...
Lorsque mon cheval se déplace sur l'échiquier, il laisse une bouse dans la case précédemment occupée...
ça marche pour le premier déplacement mais pour le second déplacement la 1ère bouse disparait, et ainsi de suite...
Alors que je voudrais que toutes les bouses restent sur l'échiquier.
Voici la partie du code correspondante qui se trouve dans une fonction :

Code:

photo2=PhotoImage(file="bouse.gif")

Code:

dic['photo2']=photo2

Code:

can.create_image(cx,cy,image=photo2)

Code:

photo1=PhotoImage(file="cheval.gif")

Code:

dic['photo1']=photo1

Code:

can.create_image(x,y,image=photo1)

Pourquoi mes bouses disparaissent au fur et à mesure?
28/03/2014, 20h16
destroy51
Désolé pour la MEP, je viens juste de piger l'utilisation de la balise... Ce sera mieux comme ça :
J'ai un nouveau problème...
Lorsque mon cheval se déplace sur l'échiquier, il laisse une bouse dans la case précédemment occupée...
ça marche pour le premier déplacement mais pour le second déplacement la 1ère bouse disparait, et ainsi de suite...
Alors que je voudrais que toutes les bouses restent sur l'échiquier.
Voici la partie du code correspondante qui se trouve dans une fonction :
Code:

1 2 3 4 5 6 photo2=PhotoImage(file="bouse.gif") dic['photo2']=photo2 can.create_image(cx,cy,image=photo2) photo1=PhotoImage(file="cheval.gif") dic['photo1']=photo1 can.create_image(x,y,image=photo1)
Pourquoi mes bouses disparaissent au fur et à mesure?
28/03/2014, 20h47
wiztricks

Salut,
Si vous ne postez pas un peu de code qui permette de reproduire le problème, je ne sais pas.
Ceci dit, si "dic" est local, c'est pas la peine de chercher non plus.

- W

Voici mon programme :

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
175
176
177
178
179
 
from tkinter import *  # pour utiliser des graphiques
from random import *  # pour générer des nombres aléatoires
 
 
dic={}
 
 
# Fonction qui permet de calculer les coordonnées des sommets opposés d'une ligne en partant du point de coordonnées(0;y) #
def sommets(y):
    x=0
    liste=[]
    while x<1120:
        liste.append([x,y,x+70,y+70])
        x=x+70
    return liste
 
 
# Fonction qui permet de dessiner l'échiquier #
def recommencer():
    # Dessiner le damier
    global x,y,cx,cy,damier,listoccup,compteur
 
    # Initialisation des variables
    x=0
    y=0
    compteur=1   # variable qui compte le nombre de coups effectués
    listoccup=[0]*64  # liste qui gère l'occupation d'une case
    # Effacer le dessin précédent:
    can.delete(ALL)
 
 
    # Definition de la matrice du damier
    damier=[]
    while y<560:
        damier.append(sommets(y)) # on remplit avec les coordonnées des sommets des cases de la ligne
        y=y+70
    a=0
    while a<8: # on trace la premiere partie du damier
 
        al=damier[a]
        b=0
        while b<8:
            al1=al[b]
            can.create_rectangle(al1[0],al1[+1],al1[2],al1[3],fill='black')  # dessine un carré noir
            b=b+2   
        a=a+2
    a=1
    while a<8: # on recommence avec un décalage de 1 en abcsisses et de 1 en ordonnées pour la deuxieme partie du damier
 
        al=damier[a]
        b=1
        while b<8:
            al1=al[b]
            can.create_rectangle(al1[0],al1[+1],al1[2],al1[3],fill='black')  # dessine un carré noir
            b=b+2   
        a=a+2
 
    # Affichage du contour de l'échiquier
    can.create_line(0,3,560,3,width=3,fill='brown')
    can.create_line(3,0,3,560,width=3,fill='brown')
    can.create_line(0,560,560,560,width=3,fill='brown')
    can.create_line(560,3,560,560,width=3,fill='brown')
 
    # Placer le cavalier de départ de manière aléatoire
    aleax=randrange(8) # on sélectionne une position au hasard sur la matrice
    aleay=randrange(8)
    ligne=damier[aleax] # on prend les coordonnées aléatoires
    case=ligne[aleay]
    x=case[0]+35 # on centre le pion
    y=case[1]+35
    photo1=PhotoImage(file="cheval.gif")  # on dessine le cheval
    dic['photo']=photo1
    can.create_image(x,y,image=photo1)
 
    cx=x
    cy=y
    listoccup[int((x-35)/70)+8*int((y-35)/70)]=1  # on indique que la case est devenu occupée
    etiquette.configure(text="Nombre de cases restantes : "+str(64-compteur)) # affichage du compteur   
 
 
 
 
 
 
 
# Fonction qui teste si le déplacement est possible à partir de la position (x;y) #
def tester(x,y):
        caselibre=False
        if x>=105 and y>=175 and listoccup[int((x-105)/70)+8*int((y-175)/70)]==0:     # teste si le déplacement (-1;-2) reste dans l'échiquier et si la case cible est vide
            caselibre=True
        if x<=455 and y>=175 and listoccup[int((x+35)/70)+8*int((y-175)/70)]==0:      # teste si le déplacement (+1;-2) reste dans l'échiquier puis si la case cible est vide
            caselibre=True
        if x<=385 and y>=105 and listoccup[int((x+105)/70)+8*int((y-105)/70)]==0:     # teste si le déplacement (+2;-1) reste dans l'échiquier puis si la case cible est vide
            caselibre=True
        if x<=385 and y<=455 and listoccup[int((x+105)/70)+8*int((y+35)/70)]==0:      # teste si le déplacement (+2;+1) reste dans l'échiquier puis si la case cible est vide
            caselibre=True
        if x<=455 and y<=385 and listoccup[int((x+35)/70)+8*int((y+105)/70)]==0:      # teste si le déplacement (+1;+2) reste dans l'échiquier puis si la case cible est vide
            caselibre=True
        if x>=105 and y<=385 and listoccup[int((x-105)/70)+8*int((y+105)/70)]==0:     # teste si le déplacement (-1;+2) reste dans l'échiquier puis si la case cible est vide 
            caselibre=True
        if x>=175 and y<=455 and listoccup[int((x-175)/70)+8*int((y+35)/70)]==0:      # teste si le déplacement (-2;+1) reste dans l'échiquier puis si la case cible est vide   
            caselibre=True
        if x>=175 and y>=105 and listoccup[int((x-175)/70)+8*int((y-105)/70)]==0:     # teste si le déplacement (-2;-1) reste dans l'échiquier puis si la case cible est vide
            caselibre=True
        if caselibre==False :
            if compteur==64 :
                can.create_text(300,250,font=('Ravie',50),text="BRAVO !!!",fill='blue')
            else :
                can.create_text(300,250,font=('Ravie',50),text="PERDU !!!",fill='blue')
 
 
 
# Fonction qui dessine un pion rouge dans la case ou clique l'utilisateur si le coup est possible bien entendu...#
def pointeur(event):
    global cx,cy,listoccup,compteur,caselibre
    x=event.x%70
    x=(event.x-x)+35   # x est l'abscisse du centre de la case ou clique l'utilisateur
    y=event.y%70
    y=(event.y-y)+35   # y est l'ordonnée du centre de la case ou clique l'utilisateur
 
    if abs(cx-x)==140 and abs(cy-y)==70 and listoccup[int((x-35)/70)+8*int((y-35)/70)]==0  :   # teste si le déplacement est correct et si la case cible est vide
        photo2=PhotoImage(file="bouse.gif")
        dic['photo2']=photo2
        can.create_image(cx,cy,image=photo2)
        photo1=PhotoImage(file="cheval.gif")
        dic['photo1']=photo1
        can.create_image(x,y,image=photo1)
        cx=x
        cy=y
        compteur+=1
        listoccup[int((x-35)/70)+8*int((y-35)/70)]=1   # on indique que la case est devenu occupée
        etiquette.configure(text="Nombre de cases restantes : "+str(64-compteur)) # affichage du compteur
        tester(x,y) # test fin de partie
 
 
 
    if abs(cx-x)==70 and abs(cy-y)==140 and listoccup[int((x-35)/70)+8*int((y-35)/70)]==0 :   # teste si le déplacement est correct et si la case cible est vide
        photo2=PhotoImage(file="bouse.gif")
        dic['photo2']=photo2
        can.create_image(cx,cy,image=photo2)
        photo1=PhotoImage(file="cheval.gif")
        dic['photo1']=photo1
        can.create_image(x,y,image=photo1)
        cx=x
        cy=y
        compteur+=1
        listoccup[int((x-35)/70)+8*int((y-35)/70)]=1   # on indique que la case est devenu occupée
        etiquette.configure(text="Nombre de cases restantes : "+str(64-compteur)) # affichage du compteur
        tester(x,y)  # test fin de partie
 
 
 
# Programme principal : #
global damier
 
# creation d'une fenetre
fenetre = Tk()
fenetre.title('jeu du cavalier par Jean-Luc Bosser')
can = Canvas(fenetre, width =560, height =560, bg ='white')
can.bind("<Button-1>", pointeur)
can.pack()
 
# creation d'un bouton
b1 = Button(fenetre, text ='recommencer', command =recommencer)
b1.pack(side =LEFT, padx =3, pady =3)
 
# creation d'une variable Tkinter
calcul=StringVar()
 
# creation d'une etiquette
etiquette=Label(fenetre)
etiquette.pack()
 
# lancer la procédure
recommencer()
 
# attente des evenements
fenetre.mainloop()

28/03/2014, 23h54
wiztricks
Ah ouais.... Une succession d'appels qui execute:
Code:

1 2 photo2=PhotoImage(file="bouse.gif") dic['photo2']=photo2
est plutôt osé.

D’après vous, si la case dic['photo2'] stocke une référence a une instance de PhotoImage(file="bouse.gif").
Que deviendra cette référence lorsque vous aller y stocker l'instance suivante?

"bougez" ces instructions juste après:
Code:

1 2 # creation d'une fenêtre fenetre = Tk()
Dans le callback "pointeur(event)", les appels a .create_image pourront avoir image=dic['photo2X'].
Pourquoi prendre la peine de stocker vos PhotoImage dans un dict "global" si c'est pour devoir les recréer a chaque fois?

- W
29/03/2014, 07h07
destroy51

Magnifique, tout fonctionne à merveille...
Vous êtes super fort en programmation !!!
Encore merci pour tous vos conseils.
Voici mon code final :

from tkinter import * # pour utiliser des graphiques
from random import * # pour générer des nombres aléatoires

dic={}

# Fonction qui permet de calculer les coordonnées des sommets opposés d'une ligne en partant du point de coordonnées(0;y) #
def sommets(y):
x=0
liste=[]
while x<1120:
liste.append([x,y,x+70,y+70])
x=x+70
return liste

# Fonction qui permet de dessiner l'échiquier #
def recommencer():
# Dessiner le damier
global x,y,cx,cy,damier,listoccup,compteur,cheval

# Initialisation des variables
x=0
y=0
compteur=1 # variable qui compte le nombre de coups effectués
listoccup=[0]*64 # liste qui gère l'occupation d'une case
# Effacer le dessin précédent:
can.delete(ALL)

# Definition de la matrice du damier
damier=[]
while y<560:
damier.append(sommets(y)) # on remplit avec les coordonnées des sommets des cases de la ligne
y=y+70
a=0
while a<8: # on trace la premiere partie du damier

al=damier[a]
b=0
while b<8:
al1=al[b]
can.create_rectangle(al1[0],al1[+1],al1[2],al1[3],fill='black') # dessine un carré noir
b=b+2
a=a+2
a=1
while a<8: # on recommence avec un décalage de 1 en abcsisse et de 1 en ordonnée pour la deuxieme partie du damier

al=damier[a]
b=1
while b<8:
al1=al[b]
can.create_rectangle(al1[0],al1[+1],al1[2],al1[3],fill='black') # dessine un carré noir
b=b+2
a=a+2

# Affichage du contour de l'échiquier
can.create_line(0,3,560,3,width=3,fill='brown')
can.create_line(3,0,3,560,width=3,fill='brown')
can.create_line(0,560,560,560,width=3,fill='brown')
can.create_line(560,3,560,560,width=3,fill='brown')

# Placer le cavalier de départ de manière aléatoire
aleax=randrange(8) # on sélectionne une position au hasard sur la matrice
aleay=randrange(8)
ligne=damier[aleax] # on prend les coordonnées aléatoires
case=ligne[aleay]
x=case[0]+35 # on calcule l'abscisse du centre de la case
y=case[1]+35 # on calcule l'ordonnée du centre de la case
cheval=can.create_image(x,y,image=photo1) # on dessine le cheval
cx=x
cy=y
listoccup[int((x-35)/70)+8*int((y-35)/70)]=1 # on indique que la case est devenu occupée
etiquette.configure(text="Nombre de cases restantes : "+str(64-compteur)) # affichage du compteur

# Fonction qui teste si le déplacement est possible à partir de la position (x;y) #
def tester(x,y):
caselibre=False
if x>=105 and y>=175 and listoccup[int((x-105)/70)+8*int((y-175)/70)]==0: # teste si le déplacement (-1;-2) reste dans l'échiquier et si la case cible est vide
caselibre=True
if x<=455 and y>=175 and listoccup[int((x+35)/70)+8*int((y-175)/70)]==0: # teste si le déplacement (+1;-2) reste dans l'échiquier puis si la case cible est vide
caselibre=True
if x<=385 and y>=105 and listoccup[int((x+105)/70)+8*int((y-105)/70)]==0: # teste si le déplacement (+2;-1) reste dans l'échiquier puis si la case cible est vide
caselibre=True
if x<=385 and y<=455 and listoccup[int((x+105)/70)+8*int((y+35)/70)]==0: # teste si le déplacement (+2;+1) reste dans l'échiquier puis si la case cible est vide
caselibre=True
if x<=455 and y<=385 and listoccup[int((x+35)/70)+8*int((y+105)/70)]==0: # teste si le déplacement (+1;+2) reste dans l'échiquier puis si la case cible est vide
caselibre=True
if x>=105 and y<=385 and listoccup[int((x-105)/70)+8*int((y+105)/70)]==0: # teste si le déplacement (-1;+2) reste dans l'échiquier puis si la case cible est vide
caselibre=True
if x>=175 and y<=455 and listoccup[int((x-175)/70)+8*int((y+35)/70)]==0: # teste si le déplacement (-2;+1) reste dans l'échiquier puis si la case cible est vide
caselibre=True
if x>=175 and y>=105 and listoccup[int((x-175)/70)+8*int((y-105)/70)]==0: # teste si le déplacement (-2;-1) reste dans l'échiquier puis si la case cible est vide
caselibre=True
if caselibre==False :
if compteur==64 :
can.create_text(300,250,font=('Ravie',50),text="BRAVO !!!",fill='blue')
else :
can.create_text(300,250,font=('Ravie',50),text="PERDU !!!",fill='blue')

# Fonction qui dessine un cheval dans la case ou clique l'utilisateur si le coup est possible bien entendu et laisse une bouse dans la case précédente...#
def pointeur(event):
global cx,cy,listoccup,compteur,caselibre,cheval
x=event.x%70
x=(event.x-x)+35 # x est l'abscisse du centre de la case ou clique l'utilisateur
y=event.y%70
y=(event.y-y)+35 # y est l'ordonnée du centre de la case ou clique l'utilisateur

if abs(cx-x)==140 and abs(cy-y)==70 and listoccup[int((x-35)/70)+8*int((y-35)/70)]==0 : # teste si le déplacement est correct et si la case cible est vide
can.delete(cheval)
can.create_image(cx,cy,image=photo2) # on dessine la bouse
cheval=can.create_image(x,y,image=photo1) # on dessine le cheval
cx=x
cy=y
compteur+=1
listoccup[int((x-35)/70)+8*int((y-35)/70)]=1 # on indique que la case est devenu occupée
etiquette.configure(text="Nombre de cases restantes : "+str(64-compteur)) # affichage du compteur
tester(x,y) # test fin de partie

if abs(cx-x)==70 and abs(cy-y)==140 and listoccup[int((x-35)/70)+8*int((y-35)/70)]==0 : # teste si le déplacement est correct et si la case cible est vide
can.delete(cheval)
can.create_image(cx,cy,image=photo2) # on dessine la bouse
cheval=can.create_image(x,y,image=photo1) # on dessine le cheval
cx=x
cy=y
compteur+=1
listoccup[int((x-35)/70)+8*int((y-35)/70)]=1 # on indique que la case est devenu occupée
etiquette.configure(text="Nombre de cases restantes : "+str(64-compteur)) # affichage du compteur
tester(x,y) # test fin de partie

# Programme principal : #
global damier

# creation d'une fenetre
fenetre = Tk()
photo2=PhotoImage(file="bouse.gif")
dic['photo2']=photo2
photo1=PhotoImage(file="cheval.gif")
dic['photo1']=photo1
fenetre.title('jeu du cavalier par Jean-Luc Bosser')
can = Canvas(fenetre, width =560, height =560, bg ='white')
can.bind("<Button-1>", pointeur)
can.pack()

# creation d'un bouton
b1 = Button(fenetre, text ='recommencer', command =recommencer)
b1.pack(side =LEFT, padx =3, pady =3)

# creation d'une variable Tkinter
calcul=StringVar()

# creation d'une etiquette
etiquette=Label(fenetre)
etiquette.pack()

# lancer la procédure
recommencer()

# attente des evenements
fenetre.mainloop()Si vous voyez une amélioration possible du code, je suis preneur...

Je me suis un peu loupé dans les balises...dsl

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
 
from tkinter import *  # pour utiliser des graphiques
from random import *  # pour générer des nombres aléatoires
 
 
dic={}
 
 
# Fonction qui permet de calculer les coordonnées des sommets opposés d'une ligne en partant du point de coordonnées(0;y) #
def sommets(y):
    x=0
    liste=[]
    while x<1120:
        liste.append([x,y,x+70,y+70])
        x=x+70
    return liste
 
 
# Fonction qui permet de dessiner l'échiquier #
def recommencer():
    # Dessiner le damier
    global x,y,cx,cy,damier,listoccup,compteur,cheval
 
    # Initialisation des variables
    x=0
    y=0
    compteur=1   # variable qui compte le nombre de coups effectués
    listoccup=[0]*64  # liste qui gère l'occupation d'une case
    # Effacer le dessin précédent:
    can.delete(ALL)
 
 
    # Definition de la matrice du damier
    damier=[]
    while y<560:
        damier.append(sommets(y)) # on remplit avec les coordonnées des sommets des cases de la ligne
        y=y+70
    a=0
    while a<8: # on trace la premiere partie du damier
 
        al=damier[a]
        b=0
        while b<8:
            al1=al[b]
            can.create_rectangle(al1[0],al1[+1],al1[2],al1[3],fill='black')  # dessine un carré noir
            b=b+2   
        a=a+2
    a=1
    while a<8: # on recommence avec un décalage de 1 en abcsisse et de 1 en ordonnée pour la deuxieme partie du damier
 
        al=damier[a]
        b=1
        while b<8:
            al1=al[b]
            can.create_rectangle(al1[0],al1[+1],al1[2],al1[3],fill='black')  # dessine un carré noir
            b=b+2   
        a=a+2
 
    # Affichage du contour de l'échiquier
    can.create_line(0,3,560,3,width=3,fill='brown')
    can.create_line(3,0,3,560,width=3,fill='brown')
    can.create_line(0,560,560,560,width=3,fill='brown')
    can.create_line(560,3,560,560,width=3,fill='brown')
 
    # Placer le cavalier de départ de manière aléatoire
    aleax=randrange(8) # on sélectionne une position au hasard sur la matrice
    aleay=randrange(8)
    ligne=damier[aleax] # on prend les coordonnées aléatoires
    case=ligne[aleay]
    x=case[0]+35  # on calcule l'abscisse du centre de la case
    y=case[1]+35  # on calcule l'ordonnée du centre de la case
    cheval=can.create_image(x,y,image=photo1)  # on dessine le cheval
    cx=x
    cy=y
    listoccup[int((x-35)/70)+8*int((y-35)/70)]=1  # on indique que la case est devenu occupée
    etiquette.configure(text="Nombre de cases restantes : "+str(64-compteur)) # affichage du compteur   
 
 
 
 
 
 
 
# Fonction qui teste si le déplacement est possible à partir de la position (x;y) #
def tester(x,y):
        caselibre=False
        if x>=105 and y>=175 and listoccup[int((x-105)/70)+8*int((y-175)/70)]==0:     # teste si le déplacement (-1;-2) reste dans l'échiquier et si la case cible est vide
            caselibre=True
        if x<=455 and y>=175 and listoccup[int((x+35)/70)+8*int((y-175)/70)]==0:      # teste si le déplacement (+1;-2) reste dans l'échiquier puis si la case cible est vide
            caselibre=True
        if x<=385 and y>=105 and listoccup[int((x+105)/70)+8*int((y-105)/70)]==0:     # teste si le déplacement (+2;-1) reste dans l'échiquier puis si la case cible est vide
            caselibre=True
        if x<=385 and y<=455 and listoccup[int((x+105)/70)+8*int((y+35)/70)]==0:      # teste si le déplacement (+2;+1) reste dans l'échiquier puis si la case cible est vide
            caselibre=True
        if x<=455 and y<=385 and listoccup[int((x+35)/70)+8*int((y+105)/70)]==0:      # teste si le déplacement (+1;+2) reste dans l'échiquier puis si la case cible est vide
            caselibre=True
        if x>=105 and y<=385 and listoccup[int((x-105)/70)+8*int((y+105)/70)]==0:     # teste si le déplacement (-1;+2) reste dans l'échiquier puis si la case cible est vide 
            caselibre=True
        if x>=175 and y<=455 and listoccup[int((x-175)/70)+8*int((y+35)/70)]==0:      # teste si le déplacement (-2;+1) reste dans l'échiquier puis si la case cible est vide   
            caselibre=True
        if x>=175 and y>=105 and listoccup[int((x-175)/70)+8*int((y-105)/70)]==0:     # teste si le déplacement (-2;-1) reste dans l'échiquier puis si la case cible est vide
            caselibre=True
        if caselibre==False :
            if compteur==64 :
                can.create_text(300,250,font=('Ravie',50),text="BRAVO !!!",fill='blue')
            else :
                can.create_text(300,250,font=('Ravie',50),text="PERDU !!!",fill='blue')
 
 
 
# Fonction qui dessine un cheval dans la case ou clique l'utilisateur si le coup est possible bien entendu et laisse une bouse dans la case précédente...#
def pointeur(event):
    global cx,cy,listoccup,compteur,caselibre,cheval
    x=event.x%70
    x=(event.x-x)+35   # x est l'abscisse du centre de la case ou clique l'utilisateur
    y=event.y%70
    y=(event.y-y)+35   # y est l'ordonnée du centre de la case ou clique l'utilisateur
 
    if abs(cx-x)==140 and abs(cy-y)==70 and listoccup[int((x-35)/70)+8*int((y-35)/70)]==0  :   # teste si le déplacement est correct et si la case cible est vide    
        can.delete(cheval)
        can.create_image(cx,cy,image=photo2)  # on dessine la bouse
        cheval=can.create_image(x,y,image=photo1)  # on dessine le cheval
        cx=x
        cy=y
        compteur+=1
        listoccup[int((x-35)/70)+8*int((y-35)/70)]=1   # on indique que la case est devenu occupée
        etiquette.configure(text="Nombre de cases restantes : "+str(64-compteur)) # affichage du compteur
        tester(x,y) # test fin de partie
 
 
 
    if abs(cx-x)==70 and abs(cy-y)==140 and listoccup[int((x-35)/70)+8*int((y-35)/70)]==0 :   # teste si le déplacement est correct et si la case cible est vide
        can.delete(cheval)
        can.create_image(cx,cy,image=photo2)  # on dessine la bouse
        cheval=can.create_image(x,y,image=photo1)  # on dessine le cheval
        cx=x
        cy=y
        compteur+=1
        listoccup[int((x-35)/70)+8*int((y-35)/70)]=1   # on indique que la case est devenu occupée
        etiquette.configure(text="Nombre de cases restantes : "+str(64-compteur)) # affichage du compteur
        tester(x,y)  # test fin de partie
 
 
 
# Programme principal : #
global damier
 
# creation d'une fenetre
fenetre = Tk()
photo2=PhotoImage(file="bouse.gif")
dic['photo2']=photo2
photo1=PhotoImage(file="cheval.gif")  
dic['photo1']=photo1
fenetre.title('jeu du cavalier par Jean-Luc Bosser')
can = Canvas(fenetre, width =560, height =560, bg ='white')
can.bind("<Button-1>", pointeur)
can.pack()
 
# creation d'un bouton
b1 = Button(fenetre, text ='recommencer', command =recommencer)
b1.pack(side =LEFT, padx =3, pady =3)
 
# creation d'une variable Tkinter
calcul=StringVar()
 
# creation d'une etiquette
etiquette=Label(fenetre)
etiquette.pack()
 
# lancer la procédure
recommencer()
 
# attente des evenements
fenetre.mainloop()

29/03/2014, 13h40
wiztricks

Salut,
Si vous vous plantez dans l’écriture d'un post, pas la peine de reposter: vous pouvez le modifier - regardez les "boutons" proposes par l'IHM - s'il n'est pas trop vieux (3 jours je crois).
- W