Erreur python missing 1 required positional argument: 'event'

Bonjour Antoine451833,

missing 1 required positional argument: 'event'.

en français:

il manque un argument requis : 'event'

Ca doit être dans scene2(event), non ?

Il faut voir comment tu appelles cette fonction, un indice sur les fonctions et leurs arguments :

#definition de test
def test(toto):
    print(toto)

#Appel de test
test(toto)

Salut Phil, je te retrouve ici :). Merci a vous deux, donc ça doit être comme ça:

def scene():
    global touches,joueur1,joueur2
    joueur1=[rut,Rpoint,Rpoint2]
    joueur2=[bob,Bpoint,Bpied]
    touches = ["A","M"]
    can1.focus_set()
    can1.bind("<KeyPress>",pressed)
    can1.bind("<KeyRelease>",released)
    scene2(event)

def scene2(event):
    global joueur1,joueur2,touches
    t = event.keysym.upper()

    if t=="A" and t in touches:
        can1.create_image(100,100,image=joueur1[0])
        toucheA="A"
    if t=="M" and t in touches:
        can1.create_image(200,100,image=joueur2[0])
        toucheB="M"

    if toucheA=="A" and toucheB=="M" :
        score1=score1+1
    if toucheA=="A" and toucheB=="P" :
        score2=score2+1
    #bouton
    bou7 =Button(windows, text="pause", width =10,borderwidth=0, command=pause)
    bou7.place(x=100,y=720)
    can1.after(100,scene2)

def pressed(event):
    #on rajoute la touche pressée dans la liste touches si elle n’y est pas déjà
    global touches
    t = event.keysym.upper()
    if not t in touches:
        touches.append(t)


def released(event):
    #on enlève la touche relachée de la liste touches
    global touches
    t = event.keysym.upper()
    if t in touches:
        touches.remove(t)

Mais maintenant il ne reconnait plus event: NameError: name 'event' is not defined Donc j'ai remplacé def scene() par def scene(event) cependant apres ca il remanque un argument "event". J'imagine que c’était pas ce qu'il fallait faire parce que la ça tourne en cercle vicieux.

scene2 s'appelle elle-même aussi à la fin:

can1.after(100,scene2)

Il faut contrôler tous les appels ...

oui c'est le but, rappel toi il faut que ma fonction enregistre les touches et affecte en fonction le score toutes les 3s (ici c'est plus rapide mais c'est l’idée). Donc pour ça il faut bien qu'elle se rappelle.

je ne te dis pas le contraire

je te dis juste qu'il faut modifier tous les appels de scene2, et pas seulement dans scene() !

Donc si je comprends bien ça ressemblerai a ça ? Cependant la il ne reconnait plus event scene(event) NameError: name 'event' is not defined Du coup il faudrait rajouter un event un def switch mais si on fait ça ça empire, le jeux ne se lance plus. (j'ai mis la fonction switch parce uniquement parce qu'elle permet d'appeler scene)

def switch():
    global Pchoisi
    reset()
    #song()
    can1.itemconfig(background, image=mes_photos[Pchoisi])
    Pchoisi += 1
    if Pchoisi==5:
        can1.itemconfig(background,image=fond_D)
        scene(event)
    else :
        windows.after(500, switch)

mes_photos = [top3,top2,top1,topF,fond_D]
Pchoisi = 0
#-------------------------------scene de combat---------------------------------
def scene(event):
    global touches,joueur1,joueur2
    joueur1=[rut,Rpoint,Rpoint2]
    joueur2=[bob,Bpoint,Bpied]
    touches = ["A","M"]
    can1.focus_set()
    can1.bind("<KeyPress>",pressed)
    can1.bind("<KeyRelease>",released)
    scene2(event)

def scene2(event):
    global joueur1,joueur2,touches
    t = event.keysym.upper()

    if t=="A" and t in touches:
        can1.create_image(100,100,image=joueur1[0])
        toucheA="A"
    if t=="M" and t in touches:
        can1.create_image(200,100,image=joueur2[0])
        toucheB="M"

    if toucheA=="A" and toucheB=="M" :
        score1=score1+1
    if toucheA=="A" and toucheB=="P" :
        score2=score2+1
    #bouton
    bou7 =Button(windows, text="pause", width =10,borderwidth=0, command=pause)
    bou7.place(x=100,y=720)
    can1.after(100,scene2(event))

Bonjour Antoine,

C'est normal que event soit inconnu dans switch()

Je te refais mon explication sur la portée des variables:

dans switch() tu appelle scene() en lui passant event, mais event, il est défini où dans switch() ?

Ce n'est pas de la magie, il faut bien qu'il sorte de quelque part …

D'ailleurs, je me demande à quoi sert de mettre event partout ?

event c'est un évènement reçu apres appui sur une touche, par exemple,

ca donne ça:

#Lier le canvas can1 à un appui de touche du clavier, et activer la fonction callback pressed
can1.bind("<KeyPress>",pressed)

#la fonction pressed recoit event en argument, event contient la touche appuyee
def pressed(event):
    touche_appuyée = event.keysym

Une fois que l'on connait touche_appuyée, pas besoin de remettre partout event et event.keysym …

Bonjour Phil,

D'accord je vois, donc dans le code precedent il fallait que switch() soit switch(event).

Je ne maitrise mais encore très bien l'événement event , de ce que je sais, corrige moi si je me trompe, c’est la saisi d'un clavier ou clique d'une souris et je sais qu'il est lié a bind, lui va faire une action a l'enregistrement de la saisi ou du clique. Mais malgré ça j'ai toujours un multitudes d'erreurs.

Si j'ai bien compris faire ça suffirait ?

def scene():
    global touches,joueur1,joueur2
    joueur1=[rut,Rpoint,Rpoint2]
    joueur2=[bob,Bpoint,Bpied]
    touches = ["A","M"]
    can1.focus_set()
    can1.bind("<KeyPress>",pressed)
    scene2(event)

def scene2(event):
    global joueur1,joueur2,touches,t
    t = event.keysym.upper()
    if t=="A" and t in touches:
        can1.create_image(100,100,image=joueur1[0])
        toucheA="A"
    if t=="M" and t in touches:
        can1.create_image(200,100,image=joueur2[0])
        toucheB="M"

    if toucheA=="A" and toucheB=="M" :
        score1=score1+1
    if toucheA=="A" and toucheB=="P" :
        score2=score2+1
    #bouton
    bou7 =Button(windows, text="pause", width =10,borderwidth=0, command=pause)
    bou7.place(x=100,y=720)
    can1.after(100,scene2)

def pressed():
    #on rajoute la touche pressée dans la liste touches si elle n’y est pas déjà
    global touches,t
    if not t in touches:
        touches.append(t)


def released():
    #on enlève la touche relachée de la liste touches
    global touches,t
    if t in touches:
        touches.remove(t)

Cependant j'imagine que c'est toujours pas car toujours le même message d'erreur (cette fois je te mets la totalité du message même si je pense qu'uniquement les dernières lignes sont utiles:

Traceback (most recent call last):
  File "C:\Antoine\Scolarité\Terminal\ISN\Logiciel\App\Python\lib\tkinter\__init__.py", line 1702, in __call__
    return self.func(*args)
  File "C:\Antoine\Scolarité\Terminal\ISN\Logiciel\App\Python\lib\tkinter\__init__.py", line 746, in callit
    func(*args)
  File "C:\Antoine\Scolarité\Terminal\ISN\STREET KO\menu V0.py", line 178, in switch
    scene()
  File "C:\Antoine\Scolarité\Terminal\ISN\STREET KO\menu V0.py", line 192, in scene
    scene2(event)
NameError: name 'event' is not defined

"Je ne maitrise mais encore très bien l'événement event ...... "

Ben , je viens de te l'expliquer avec un exemple

Et tu n'as pas lu ou compris ce que j'ai dit:

event pas défini dans scene2 , c'est normal

tu appelles scene2 dans scene en lui passant event, mais dans scene, il est initialisé où event ?

moi je ne vois rien ...

donc erreur : event non défini dans scene2

C'est pas avec un exemple qu'on peut maitrisé quelque chose. Même si tu as été précis dans tes propos ça reste un nouveau terme pour moi.

"Initialiser event dans scene" = scene(event) ?

1_ Mon exemple pour les appuis de touches, au contraire est suffisamment simple pour te faire comprendre la mécanique

2_ je veux dire que dans scene(), on ne défini pas event, event est inconnu
donc comment re passer event à scene2(event), puisqu'on ne le connait pas ?

Je me demande pourquoi tu veux utiliser event, d'ailleurs

On va récapituler tout ça:

Le jeu commence quand on appuie sur le bouton "Commencer", ça appelle la fonction switch
qui affiche des images et qui appelle scene()

Dans scene(), on défini 2 joueurs, une liste de touches (A,M), et on associe à can1 un appui de touche : can1.bind("<KeyPress>",pressed)

pressed est donc une fonction appelée dès qu'on appuie sur une touche
dans pressed on récupère donc l'appui de touche : t = event.keysym.upper() et on le met en majuscules (upper)

t qui est la touche pressée est mis dans une liste nommée touches :
touches.append(t)

Dans scene() on appelle scene2() et on veut récupérer les touches :
t = event.keysym.upper()
A quoi ca sert puisque les touches pressées sont déjà dans la liste touches
De plus, ca ne marche pas: c'est pressed qui récupère event pas scene2()
C'est pressed qui est appelée sur un appui de touches pas scene2()

Dans scene2() tu a mis global touches, dons tes touches sont déjà la-dedans

Je commences à comprendre pourquoi toutes ces fonctions, ces can1.after(100,scene2) pour boucler, etc..

En fait tu n'as pas besoin de faire tout ça, tu n'as pas compris la mécanique des interfaces graphiques

Si tu prends par exemple un programme en mode console, (tu sais un code qu'on lance qui s'affiche dans une fenêtre noire), tout se déroule séquentiellement du début du programme jusqu'à la fin, et à la dernière instruction le programme s'arrête et la fenêtre se ferme

Dans un programme avec interface, widgets, canvas, on est dans un programme géré par les évènements

Tu définis tes fonctions, tu définis ton interface graphique avec ses bouton, boites d'entrées,
canvas, etc...

l'interpréteur Python lit tout ça, affiche la fenêtre, les boutons, etc et tombe sur la dernière instruction du programme: Mafenetre.mainloop()

mainloop(), c'est la méthode qui est une boucle d'attente des évènements
donc le programme ne s'arrête pas là, il entre dans une boucle et il attend que l'on appuie sur un bouton, ou une touche, où bien qu'on clique avec la souris, ou sur la croix en haut pour tout fermer

Donc, encore une fois, c'est plus simple que tu ne le penses: pas besoin de tout ça,
il suffit d'avoir la fonction pressed d'un coté et de l'autre la fonction lancée par le bouton "commencer" qui va afficher tes images, un message pour dire, par exemple, "top appuyez sur une touche" et c'est tout, et là on est automatiquement en attente

Et dès qu'on appuie, la fonction pressed récupère les touches et les passe à une autre fonction qui va exploiter le résultat pour savoir qui à gagné et l'afficher

Merci d'avoir pris le temps d'expliquer ligne par ligne mon code. J'avais déjà compris les grandes lignes mais t'as clarifié les zones d'ombres.

Malgré tout pour moi la fonction released est nécessaire, elle permet d'enlever les touches de la liste et ainsi pouvoir retaper ces mêmes touches. Sinon la touche pressé est dans la liste mais elle n'affectera plus le score si elle est réutilisé.

Ensuite scene2 est la fonction qui va exploiter le résultat et permettre de savoir qui va gagner et elle a besoin de t = event.keysym.upper() sinon elle ne peut pas être exécuté. Le mettre en global n'est pas une solution.

Et une dernière question, je voulais avec t = event.keysym.upper() que la fonction prenne en compte les touches en majuscules et minuscules, donc d’après ce que tu me dis c'est pas du tout ça qu'elle fait.

Encore merci de prendre le temps de m'expliquer.

"Ensuite scene2 est la fonction qui va exploiter le résultat et permettre de savoir qui va gagner et elle a besoin de t = event.keysym.upper() sinon elle ne peut pas être exécuté. Le mettre en global n'est pas une solution. "

non, c'et ce que t'ai expliqué : la touche est dans la liste obtenue par la fonction pressed, il n'y a plus qu'a l'exploiter : la variable touches est en global dans scene2() donc il n'y a plus qu'à en extraire les touches

"que la fonction prenne en compte les touches en majuscules et minuscules"

.upper() met en majuscules, enlève-le et c'est ok : t = event.keysym

Je pense avoir compris, du coup pas besoin de t, mais par contre touches oui. Donc ça donne ça ?

def scene2():
    global joueur1,joueur2,touches
    #t = touche pressée
    if touches=="A":
        can1.create_image(100,100,image=joueur1[0])
        toucheA="A"
    if touches=="M":
        can1.create_image(200,100,image=joueur2[0])
        toucheB="M"

    if toucheA=="A" and toucheB=="M" :
        score1=score1+1
    if toucheA=="A" and toucheB=="P" :
        score2=score2+1
    #bouton
    bou7 =Button(windows, text="pause", width =10,borderwidth=0, command=pause)
    bou7.place(x=100,y=720)
    can1.after(100,scene2)

tu as testé ?

touches est une liste, donc

if touches=="A":

ca ne marche pas, touches ressemble à ça normalement:

touches = ['A','M']

Oui c’était pas fonctionnel, la je suis arrive a quelque chose bien mieux.

Tout s'affiche, les images changes en fonction des touches et le score varie mais le probleme c'est qu'on dirait qu'il est aléatoire, je te mets ce qu'il ma affiché dans la console et tout ça c'est suite a deux trois coups. Et l’inconvénient c'est que en globale je suis blindé mais de ce que je vois c'est plus simple de l’être.

Le nouveau:

def scene():
    global touches,joueur1,joueur2,toucheB,toucheA,image_joueur2,image_joueur1
    joueur1=[rut,Rpoint,Rpoint2]
    joueur2=[bob,Bpoint,Bpied]
    image_joueur1=can1.create_image(300,300,image=joueur1[0])
    image_joueur2=can1.create_image(500,300,image=joueur2[0])
    touches = []
    can1.focus_set()
    can1.bind("<KeyPress>",pressed)
    can1.bind("<KeyRelease>",released)
    toucheA=""
    toucheB=""
    scene2()

def scene2():
    global joueur1,joueur2,touches,score1,score2,toucheA,toucheB,image_joueur2,image_joueur1
    if "A" in touches:
        can1.itemconfig(image_joueur1,image=joueur1[1])
        toucheA="A"
    if "Q" in touches:
        can1.itemconfig(image_joueur1,image=joueur1[2])
    if "M" in touches:
        can1.itemconfig(image_joueur2,image=joueur2[1])
        toucheB="M"
    if "P" in touches:
        can1.itemconfig(image_joueur2,image=joueur2[2])
        toucheB="P"

    if toucheA=="A" and toucheB=="M" :
        score1=score1+1
        print(score1)
    if toucheA=="A" and toucheB=="P" :
        score2=score2+1
        print(score2)
    #bouton
    bou7 =Button(windows, text="pause", width =10,borderwidth=0, command=pause)
    bou7.place(x=100,y=720)
    can1.after(100,scene2)

def pressed(event):
    #on rajoute la touche pressée dans la liste touches si elle n’y est pas déjà
    global touches
    t = event.keysym.upper()
    if not t in touches:
        touches.append(t)


def released(event):
    #on enlève la touche relachée de la liste touches
    global touches
    t = event.keysym.upper()
    if t in touches:
        touches.remove(t)

La console du score:

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
1
2
3
4
5
6
7
8
9
10
37
38
39
40
41
42
43
44
45
46
47
48
11
12
49
50
51
52
53
54
55
56
57
58
59
13
14
15
16
17
18
19
20
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
21
22
23
24
25
26
27
28
29
30
31
77
78
79
80
81
82
83
84
85
32
33
34
35
36
37
38
39
40
41
86
87
88
89
90
91
92
93
94
42
43
44
45
46
47
95
96
97
48
49
98
99
50
51
100
101
52
53
54
55
56
102
103
57
104
105
106
107
108
109
58
59
60
61
110
111
112
62
63
64
65
66
67
68
113
114
69
70
71
72
73
74
75
115
116
76
77
117
118
78
79
80
81
82
83
84
85
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
86
87
88
135
136
137
89
90
138
139
91
92
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
93
94
95
96
97
98
99
168
169
170
100
101
102
103
171
172
104
105
106
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

Bonjour Antoine,

Pas facile à dire comme ça, sans l'ensemble du code ...

Par contre serais-tu d'accord pour faire un test, pour voir ?

Je voudrais être sûr de la façon dont le jeu doit fonctionner, si ça ne t'embête pas :-)

J'ai fait un bout de programme avec ton jeu, sans les belles images, les sons, et les photos de fond de Canvas, bien sur, mais ça, ce n'est que de l'habillage, ça ne change rien à la mécanique du jeu

Récupère le code ci-dessous et exécute-le
J'ai défini les touches a et q comme celles du joueur 1, et p et m comme celles du joueur 2
Pour jouer, appuie sur le bouton "commencer"
tu peux faire les 2 joueurs à toi tout seul: la main gauche appuie sur a ou q et la main droite sur p ou m, donc chaque main appuie sur une des touches en même temps

un message s'affiche en rouge :" joueur 1 gagne" et s'efface au bout d'une seconde, et le nombre de points de vie du perdant en bas de l'écran diminue de 1 (je les ai mis à 5 au départ)

Lorsqu'un des 2 chiffres arrive à 0, un message "game over !!!" s'affiche

On peut alors ré appuyer sur le bouton "commencer" pour refaire une partie

Essaie s'il te plait, et dis moi si c'est comme ça que doit marcher le jeu, dans le principe

# -*- coding:Latin-1 -*-

from tkinter import *

def afficher_regles():
	''' affichage des règles dans une fenetre secondaire '''

	fenetre_secondaire = Toplevel(fenetre_princ)
	fenetre_secondaire.geometry('410x200+450+300')

	can_2 = Canvas(fenetre_secondaire,bg='ivory',height=190,width=400)
	can_2.place(x = 5,y = 5)

	info = '''
Suivant le personnage que vous incarnez, Rut ou Bob, votre objectif
est de terrasser votre adversaire.
Pour ce faire vous devez enchaîner les combinaisons de touches afin de
gagner le combat.
Ainsi il est conseillé de prendre connaissance des commandes
afin d'etablir une stratégie solide.
L'enjeu de ce combat est de déterminer le futur époux de la princesse Sofya
tant convoitée. Donnez tout ce que vous avez pour la séduire !!!!!!!!!
	'''
	can_2.create_text(5,5,text=info, anchor = NW, fill = 'blue')

def afficher_histoire():
	''' affichage de l'histoire dans une fenetre secondaire '''
	fenetre_secondaire = Toplevel(fenetre_princ)
	fenetre_secondaire.geometry('410x200+450+300')

	can_2 = Canvas(fenetre_secondaire,bg='ivory',height=190,width=400)
	can_2.place(x = 5,y = 5)

	info = '''
Il fut un temps où les guerres faisaient rage.
Impactant la galaxie entière des millions de victimes ont été déplorés.
L'objectif était toujours le même le désir ardent d'être le plus puissant.
etc .........
	'''
	can_2.create_text(5,5,text=info,anchor = NW, fill = 'blue')

def go():
	''' Lancement du jeu '''

	global touches, score_affiche, pv1, pv2, encore

	if(encore): init()

	can1.create_text(40,50,text="C'est parti !!",anchor = NW, fill = 'yellow', font = ('helvetica', 15, 'bold'))
	score = 'Points de vie joueur 1 :   {:d}            Points de vie joueur 2 :   {:d}'.format(pv1,pv2)

	if(score_affiche):
		can1.delete('all')
		can1.create_text(10,10,text='Le joueur 1 appuie sur a ou q et le joueur 2 appuie sur p ou m',anchor = NW, fill = 'white', font = ('helvetica', 15, 'bold'))
		can1.create_text(40,50,text="C'est parti !!",anchor = NW, fill = 'yellow', font = ('helvetica', 15, 'bold'))

		score_affiche = False

	can1.create_text(10,300,text= score,anchor = NW, fill = 'yellow', font = ('helvetica', 15, 'bold'))

	if(touches != []):
		if(len(touches) == 2):
			touches_s = (''.join(touches))
	
			error = False
			if (touches_s == 'ap' or touches_s == 'pa' or touches_s == 'am' or touches_s == 'ma'):
				t = 'Joueur 1 gagne !'
				pv2 -=1
			elif(touches_s == 'qp' or touches_s == 'pq' or touches_s == 'qm' or touches_s == 'mq'):
				t = 'Joueur 2 gagne !'
				pv1 -=1
			else:
				error = True
	
			if(not error):
				can1.create_text(10,90,text=t,anchor = NW, fill = 'red', font = ('helvetica', 15, 'bold'))
				score_affiche = True

		touches = []

	if(pv1 == 0 or pv2 == 0):
		can1.delete('all')
		can1.create_text(50,150,text= 'Game over !!!',anchor = NW, fill = 'red', font = ('helvetica', 20, 'bold'))
		score = 'Points de vie joueur 1 :   {:d}            Points de vie joueur 2 :   {:d}'.format(pv1,pv2)
		can1.create_text(10,300,text= score,anchor = NW, fill = 'yellow', font = ('helvetica', 15, 'bold'))
		encore = True
		return

	can1.after(1000, go)

def appui_touches(event):
	global touches

	touches.append(event.keysym)

def init():
	global touches, score_affiche, pv1, pv2, encore

	score_affiche = False
	touches = []
	pv1 = 5
	pv2 = 5
	encore = False
	can1.delete('all')
	can1.create_text(10,10,text='Le joueur 1 appuie sur a ou q et le joueur 2 appuie sur p ou m',anchor = NW, fill = 'white', font = ('helvetica', 15, 'bold'))


#Interface graphique
fenetre_princ=Tk()
fenetre_princ.geometry('700x400+300+100')
fenetre_princ.title("STREET KO le meilleur jeu de bagarre")
fenetre_princ.bind('<Key>', appui_touches)

can1=Canvas(fenetre_princ,bg='sandybrown', height=350, width=700)
can1.place(x=0,y=0)

b1=Button(fenetre_princ,text="Règles",command=afficher_regles)
b1.place(x=75,y=370)

b2=Button(fenetre_princ,text="Commencer", command=go)
b2.place(x=170,y=370)

b3=Button(fenetre_princ,text="Histoire", command=afficher_histoire)
b3.place(x=10,y=370)

init()
fenetre_princ.mainloop()

Salut Phil,

j'ai lancé tout ça et oui, t'as super bien compris le principe, a quelques détails prés. Sinon tout y est.

Une touche doit pouvoir gagner et perdre, dans ton code si le joueur1 joue que la touche A il l'emporte a coup sur, avec des relations de supériorité et d’infériorité ça devrait être plus claire.

Joueus1: Joueurs2:
A>M P>A
Q<P M<Q

Et par la suite j'aimerai bien mettre une touche en plus, voir deux.

Ensuite pas oblige d'afficher "Joueur 1 gagne" ou "Joueur 2 gagne", l’idée c'est de tapoter encore et encore, pour dynamiser le jeux. C'est sur l'interface graphique qu'on verra qui perd le point, je vais créer une barre de vie pleine puis une autre avec un pv en moins, une autre ect ect jusqu'au KO, je mettrais tout ça dans une liste et enverrai la bonne image en fonction du score.

Par exemple: score 5 => barre de vie pleine
score 3 => barre de vie avec 2 pv en moins

Dit moi si il y a encore des choses que tu n'as pas compris.

Hello,

Oui dans mon jeu, le joueur A ne joue a ou q et B ne joue que p ou m
(chacun son coté du clavier)

a > p
a > m
q < p
q < m

Donc si A joue a et B joue p, c'est A qui gagne, et ainsi de suite

Le fait que j'affiche qui gagne à chaque tour n'empêche pas que le jeu est dynamique, on tapote encore et encore, et au fur et a mesure, les pv de A ou B diminuent jusqu'au game over
et c'est bien sur l'interface graphique que l'on voit qui perd : évidemment ce n'est qu'un message, pas un truc graphique, mais le principe est là

Par contre ce qui est intéressant, si tu regarde bien mon code c'est qu'il est assez court:

_ 1 bouton pour lancer le jeu
_ Dans tout le programme, 1 seule ligne fenetre_princ.bind('<Key>', appui_touches) pour capter les appuis de touche
_ Pas besoin de can1.bind("<KeyRelease>",released) ça ne sert à rien car je vide la liste des touches immédiatement après avoir calculé le gagnant et affiché les pv: touches = []
_ 2 fonctions seulement:
appui_touches(event) pour capter les touches
go() qui est la boucle de jeu qui se relance toutes les 1 seconde

Et la mécanique fonctionne !

Et donc, images ou pas, sons ou pas, barre de vie ou pas, j'en suis encore à me demander pourquoi toutes ces fonctions, tous ces Canvas ....

Tu vas me répondre qu'il les faut, mais je pense que si je pouvais tester ton code complet, je pourrais réduire drastiquement sa longueur, mais je n'ai ni Pygame, ni ta collection d'images, donc pas facile ...