Aide à la création d'un jeu : Le Tower defense

**Clemj0057** · 18/05/2014, 22h49

Bon je pense avoir trouvé, tout est ici n'est-ce pas ?

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
 # on ouvre le fichier passé en paramètre
    with open(chemin_fichier) as fichier:
        # lecture des données
        data = fichier.readlines()
        # comptage lignes
        lignes = len(data)
        # parcours lignes
        for ligne in range(lignes):
            # extraction ligne de données
            ligne_data = data[ligne].strip("\r\n ")
            # comptage colonnes
            colonnes = len(ligne_data)
            # parcours colonnes
            for colonne in range(colonnes):
                # on extrait un caractère (forcé en majuscules)
                char = str(ligne_data[colonne]).upper()

Par contre, si je modifie quelques chose la dedans, tout mes niveaux auront ils une taille différentes ?

Parce que en ce moment, tout les niveaux ont la même taille de canvas ( On a donc un gros blanc c'est génant )
J'aimerais qu'il y en ai le moins possible , donc je dois bidouiller la dedans ?

**Clemj0057** · 18/05/2014, 23h05

Par contre j'ai juste un soucis car je veux ajouter du texte sur le Menu mais lorsque je fais ce code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
fenetre.geometry("1000x510")
L=Label(fenetre,text=" Bienvenue dans DarkLab ! ",font=12)
L.place(x=400,y=260)
M=Label(fenetre,text=" Choississez votre niveau en vous dirigeant vers les carrés de couleur avec les flèches. ! ",font=12)
M.place(x=200,y=280)
N=Label(fenetre,text="Le niveau vert et bleu sont faciles, le jaune moyen et le rouge  et le gris sont difficiles , à vous de choisir ! ",font=12)
N.place(x=225,y=300)
O=Label(fenetre,text="Si vous en avez marre de jouer, le bouton quitter est à votre disposition ! ",font=12)
O.place(x=250,y=320)
P=Label(fenetre,text="Créé par RADICI Clément et BACH Paul-Hugo ! ",font=12)
P.place(x=340,y=340)

Hé bien tout le Programme plante et les niveaux se font dans le Menu à vrai dire, c'est très embêtant.

Invité · 18/05/2014, 23h06

Envoyé par Clemj0057

Bon je pense avoir trouvé, tout est ici n'est-ce pas ?

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
 # on ouvre le fichier passé en paramètre
    with open(chemin_fichier) as fichier:
        # lecture des données
        data = fichier.readlines()
        # comptage lignes
        lignes = len(data)
        # parcours lignes
        for ligne in range(lignes):
            # extraction ligne de données
            ligne_data = data[ligne].strip("\r\n ")
            # comptage colonnes
            colonnes = len(ligne_data)
            # parcours colonnes
            for colonne in range(colonnes):
                # on extrait un caractère (forcé en majuscules)
                char = str(ligne_data[colonne]).upper()

Non, la réponse serait plutôt dans les tous premiers posts de ce fil de discussion (au vraiment tout début).

Mais laissez tomber : lisez ce qui suit.

Par contre, si je modifie quelques chose la dedans, tout mes niveaux auront ils une taille différentes ?

Parce que en ce moment, tout les niveaux ont la même taille de canvas ( On a donc un gros blanc c'est génant )
J'aimerais qu'il y en ai le moins possible , donc je dois bidouiller la dedans ?

Bah, si vous ne voulez pas vous compliquer la vie, vous pouvez garder votre taille_bloc standard et simplement imposer au canevas la taille finale qu'aura pris le labyrinthe :

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
def dessiner_decor (chemin_fichier, bloc=10):
    """ dessin du labyrinthe """
    global taille_bloc, demi_bloc, sorties, posX, posY
    # init taille bloc
    taille_bloc = max(1, abs(int(bloc)))
    # init demi-taille bloc
    demi_bloc = taille_bloc // 2
    # init ensemble des identifiants IDs
    # de canvasItems de sorties
    sorties = set()
    # init liste des codes des sorties
    codes_sorties = list("FDN")
    # init couleurs locales ^^
    couleurs_blocs = {
        "B": "black",
        "F": "light green",
        "D": "red",
        "N": "orange",
    }
    # init largeur canevas
    largeur_canevas = 0
    # on efface d'abord le canevas
    canvas.delete(ALL)
    # on ouvre le fichier passé en paramètre
    with open(chemin_fichier) as fichier:
        # lecture des données
        data = fichier.readlines()
        # comptage lignes
        lignes = len(data)
        # hauteur canevas
        hauteur_canevas = taille_bloc * lignes
        # parcours lignes
        for ligne in range(lignes):
            # extraction ligne de données
            ligne_data = data[ligne].strip("\r\n ")
            # comptage colonnes
            colonnes = len(ligne_data)
            # ajustement largeur canevas
            largeur_canevas = max(largeur_canevas, taille_bloc * colonnes)
            # parcours colonnes
            for colonne in range(colonnes):
                # on extrait un caractère (forcé en majuscules)
                char = str(ligne_data[colonne]).upper()
                # a-t-on un bloc à traiter ?
                if char != " ":
                    # calcul position du bloc actuel
                    x = colonne * taille_bloc
                    y = ligne * taille_bloc
                    # a-t-on un code "P" (position initiale joueur) ?
                    if char == "P":
                        # note : on ne dessine pas la position ici
                        # init nouvelle position joueur
                        posX, posY = (x+demi_bloc, y+demi_bloc)
                    # autres codes ?
                    else:
                        # on extrait une couleur de bloc (si existe)
                        # couleur = None si aucune correspondance trouvée
                        couleur = couleurs_blocs.get(char, None)
                        # a-t-on un bloc coloré ici ?
                        if couleur:
                            # on dessine le bloc coloré
                            # on mémorise son ID de canvasItem
                            id_bloc = canvas.create_rectangle(
                                x, y, x+taille_bloc, y+taille_bloc,
                                fill=couleur, outline=couleur,
                                # on marque les blocs avec un tag,
                                # ça peut servir :
                                tag=char,
                            )
                        # end if - couleur
                        # a-t-on un code de sortie ?
                        if char in codes_sorties:
                            # on ajoute l'ID du bloc
                            # à l'ensemble des sorties
                            # ceci nous servira plus tard pour
                            # la détection des blocs "sorties"
                            # à ne pas confondre avec les murs
                            sorties.add(id_bloc)
                        # end if - char sorties
                    # end if - char "P"
                # end if - char != " "
            # end for - colonne
        # end for - ligne
        # màj taille canevas
        canvas.configure(width=largeur_canevas, height=hauteur_canevas)
    # end with - fichier
# end def

Code complet :

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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
import time
 
from tkinter import *
 
 
def init_menu (departXY=None):
    """ correspond à l'étape D de l'algorithme """
    global menuX, menuY, mode_menu
    # est-ce qu'on a un point de départ imposé ?
    if departXY:
        # init position départ
        menuX, menuY = departXY
    # end if
    # init flag
    mode_menu = True
    # on appelle la construction d'un niveau
    init_niveau("menu")
# end def
 
 
def init_niveau (niveau):
    """
        base de connaissances sur les niveaux de jeu
    """
    global posX, posY, menuX, menuY, mode_menu
    # données niveaux
    niveaux = {
 
        "menu": ("menu.txt", 20),
 
        "niveau 1": ("niveau_1.txt", 10),
 
        "niveau 2": ("niveau_2.txt", 10),
 
        "niveau 3": ("niveau_3.txt", 10),
    }
    # on vérifie que le niveau demandé existe bien
    if niveau in niveaux:
        # sommes-nous dans le menu ?
        if niveau == "menu":
            # récupérer la dernière position enregistrée
            posX, posY = (menuX, menuY)
            # masquer le bouton menu
            btn_menu.grid_remove()
        # autre niveau
        else:
            # afficher le bouton menu
            btn_menu.grid()
            # on change de niveau à partir du menu ?
            if mode_menu:
                # on sauvegarde la dernière position
                menuX, menuY = (posX, posY)
                # RAZ flag
                mode_menu = False
            # end if
        # end if - menu
        # on dessine le décor correspondant au niveau
        dessiner_decor(*niveaux[niveau])
        # on crée le pion joueur à (posX, posY)
        init_pion ()
    # niveau demandé n'existe pas ?
    else:
        # afficher erreur
        print(
            "\n*** ATTENTION ***\n"
            "le niveau '{n}' n'est pas recensé dans la base "
            "de données !"
            .format(n=niveau)
        )
        # on arrête le programme !
        exit(1)
    # end if - niveau existe
# end def
 
 
def init_pion ():
    """ crée et place le pion à (posX, posY)"""
    global id_pion
    # init pion joueur
    id_pion = canvas.create_rectangle(
        posX-demi_bloc, posY-demi_bloc,
        posX+demi_bloc, posY+demi_bloc,
        width=1, outline="black", fill="medium purple",
    )
# end def
 
 
def clavier(event):
    """ Gestion de l'événement Appui sur une touche du clavier """
    global posX, posY
    # init nom de touche clavier
    touche = event.keysym
    # init position par avance
    dx, dy = (posX, posY)
    # déplacement vers le haut
    # touche 'z' ou flèche du clavier
    if touche in ("z", "Up"):
        dy = posY - taille_bloc
    # déplacement vers le bas
    # touche 's' ou flèche du clavier
    elif touche in ("s", "Down"):
        dy = posY + taille_bloc
    # déplacement vers la droite
    # touche 'd' ou flèche du clavier
    elif touche in ("d", "Right"):
        dx = posX + taille_bloc
    # déplacement vers la gauche
    # touche 'q' ou flèche du clavier
    elif touche in ("q", "Left"):
        dx = posX - taille_bloc
    # end if
    # init ensemble des collisions
    collisions = set(canvas.find_overlapping(dx, dy, dx, dy))
    # init singleton
    sortie = collisions.intersection(sorties)
    # pas de mur, on peut se déplacer vers là (y compris sortie)
    if sortie or not collisions:
        # màj position
        posX, posY = (dx, dy)
        # Repositionnement du pion
        canvas.coords(id_pion, posX-demi_bloc, posY-demi_bloc, posX+demi_bloc, posY+demi_bloc)
    # end if - mur
    # y a-t-il un ID de sortie à cet endroit ?
    if sortie:
        # init ID du bloc sortie
        id_bloc = sortie.pop()
        # extraction du tag
        tag_bloc = canvas.itemcget(id_bloc, "tag")
        # table de correspondance
        niveaux = {
            "F": "niveau 1",
            "D": "niveau 2",
            "N": "niveau 3",
        }
        # init nouveau niveau
        niveau = niveaux.get(tag_bloc)
        # afficher nouveau niveau
        afficher_niveau(niveau)
        # on appelle un nouveau niveau
        init_niveau(niveau)
    # end if - sortie
# end def
 
 
def afficher_niveau (niveau):
    """ petite animation de transition """
    # on vérifie quand même
    if niveau:
        # on efface le canvas
        canvas.delete(ALL)
        # fond noir
        canvas.configure(bg="black")
        # text blanc sur fond noir
        canvas.create_text(
            canvas.winfo_reqwidth()//2, canvas.winfo_reqheight()//2,
            text=str(niveau).capitalize(),
            font="sans 36 bold",
            fill="white",
        )
        # màj affichage
        canvas.update_idletasks()
        # pause 1 seconde
        time.sleep(1.0)
        # fond blanc
        canvas.configure(bg="white")
    # end if - niveau
# end def
 
 
def dessiner_decor (chemin_fichier, bloc=10):
    """ dessin du labyrinthe """
    global taille_bloc, demi_bloc, sorties, posX, posY
    # init taille bloc
    taille_bloc = max(1, abs(int(bloc)))
    # init demi-taille bloc
    demi_bloc = taille_bloc // 2
    # init ensemble des identifiants IDs
    # de canvasItems de sorties
    sorties = set()
    # init liste des codes des sorties
    codes_sorties = list("FDN")
    # init couleurs locales ^^
    couleurs_blocs = {
        "B": "black",
        "F": "light green",
        "D": "red",
        "N": "orange",
    }
    # init largeur canevas
    largeur_canevas = 0
    # on efface d'abord le canevas
    canvas.delete(ALL)
    # on ouvre le fichier passé en paramètre
    with open(chemin_fichier) as fichier:
        # lecture des données
        data = fichier.readlines()
        # comptage lignes
        lignes = len(data)
        # hauteur canevas
        hauteur_canevas = taille_bloc * lignes
        # parcours lignes
        for ligne in range(lignes):
            # extraction ligne de données
            ligne_data = data[ligne].strip("\r\n ")
            # comptage colonnes
            colonnes = len(ligne_data)
            # ajustement largeur canevas
            largeur_canevas = max(largeur_canevas, taille_bloc * colonnes)
            # parcours colonnes
            for colonne in range(colonnes):
                # on extrait un caractère (forcé en majuscules)
                char = str(ligne_data[colonne]).upper()
                # a-t-on un bloc à traiter ?
                if char != " ":
                    # calcul position du bloc actuel
                    x = colonne * taille_bloc
                    y = ligne * taille_bloc
                    # a-t-on un code "P" (position initiale joueur) ?
                    if char == "P":
                        # note : on ne dessine pas la position ici
                        # init nouvelle position joueur
                        posX, posY = (x+demi_bloc, y+demi_bloc)
                    # autres codes ?
                    else:
                        # on extrait une couleur de bloc (si existe)
                        # couleur = None si aucune correspondance trouvée
                        couleur = couleurs_blocs.get(char, None)
                        # a-t-on un bloc coloré ici ?
                        if couleur:
                            # on dessine le bloc coloré
                            # on mémorise son ID de canvasItem
                            id_bloc = canvas.create_rectangle(
                                x, y, x+taille_bloc, y+taille_bloc,
                                fill=couleur, outline=couleur,
                                # on marque les blocs avec un tag,
                                # ça peut servir :
                                tag=char,
                            )
                        # end if - couleur
                        # a-t-on un code de sortie ?
                        if char in codes_sorties:
                            # on ajoute l'ID du bloc
                            # à l'ensemble des sorties
                            # ceci nous servira plus tard pour
                            # la détection des blocs "sorties"
                            # à ne pas confondre avec les murs
                            sorties.add(id_bloc)
                        # end if - char sorties
                    # end if - char "P"
                # end if - char != " "
            # end for - colonne
        # end for - ligne
        # màj taille canevas
        canvas.configure(width=largeur_canevas, height=hauteur_canevas)
    # end with - fichier
# end def
 
 
# Création de la fenêtre
fenetre = Tk()
 
# Création d'un widget Canvas
canvas = Canvas(fenetre, highlightthickness=0, bg="white")
 
canvas.grid(row=0, column=0, columnspan=2, padx=5, pady=5)
 
btn_menu = Button(fenetre, text="Menu", command=init_menu)
 
btn_menu.grid(row=1, column=0, padx=5, pady=5)
 
Button(fenetre, text="Quitter", command=fenetre.destroy).grid(row=1, column=1, padx=5, pady=5)
 
fenetre.columnconfigure(0, weight=1)
 
# init position pion de départ
init_menu((210, 170))
 
# événements clavier
fenetre.bind_all("<Key>", clavier)
 
# boucle principale
fenetre.mainloop()

avec ce code, vous pouvez définir vos fichiers niveau_1.txt......niveau_x.txt avec autant de colonnes et de lignes que vous voulez, du moment que vous respectez le même nombre de colonnes à chaque ligne (matrice de n lignes x m colonnes).

idem pour menu.txt mais tenez compte que vos blocs carrés font 20x20 pixels (gros blocs) => le canevas pourrait prendre des proportions énormes, voire dépasser la taille de l'écran.

@+.

Invité · 18/05/2014, 23h17

Envoyé par Clemj0057

Par contre j'ai juste un soucis car je veux ajouter du texte sur le Menu mais lorsque je fais ce code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
fenetre.geometry("1000x510")
L=Label(fenetre,text=" Bienvenue dans DarkLab ! ",font=12)
L.place(x=400,y=260)
M=Label(fenetre,text=" Choississez votre niveau en vous dirigeant vers les carrés de couleur avec les flèches. ! ",font=12)
M.place(x=200,y=280)
N=Label(fenetre,text="Le niveau vert et bleu sont faciles, le jaune moyen et le rouge  et le gris sont difficiles , à vous de choisir ! ",font=12)
N.place(x=225,y=300)
O=Label(fenetre,text="Si vous en avez marre de jouer, le bouton quitter est à votre disposition ! ",font=12)
O.place(x=250,y=320)
P=Label(fenetre,text="Créé par RADICI Clément et BACH Paul-Hugo ! ",font=12)
P.place(x=340,y=340)

Hé bien tout le Programme plante et les niveaux se font dans le Menu à vrai dire, c'est très embêtant.

ne mélangez pas des widget.place() avec des widget.grid() ou des widget.pack() => ça va faire un "freeze" écran.

documentation :

http://effbot.org/tkinterbook/pack.htm lisez l'avertissement dans l'encart gris

http://effbot.org/tkinterbook/grid.htm

http://effbot.org/tkinterbook/place.htm

j'ai utilisé widget.grid() dans mon script (pour de bonnes raisons) - donc, si vous voulez rajouter des widgets, utilisez widget.grid() aussi.

et faites-moi le plaisir d'enlever ce fenetre.geometry() disgrâcieux => pack() et grid() s'occupent d'arranger vos widgets correctement, sans que vous ayiez à vous en préoccuper.

pour finir, vous n'avez pas besoin d'assigner une variable à des objets Label() ou Button() que vous ne modifierez plus par la suite :

Exemple :

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
#fenetre.geometry("1000x510") <-- beurk !
#L=Label(fenetre,text=" Bienvenue dans DarkLab ! ",font=12)
#L.place(x=400,y=260)
 
Label(fenetre, text="Bienvenue dans DarkLab !", font="sans 12 bold").grid(row=0, column=2, padx=5, pady=5)
 
# idem pour tous les autres (après avoir lu la doc sur .grid(), évidemment)
 
#M=Label(fenetre,text=" Choississez votre niveau en vous dirigeant vers les carrés de couleur avec les flèches. ! ",font=12)
#M.place(x=200,y=280)
#N=Label(fenetre,text="Le niveau vert et bleu sont faciles, le jaune moyen et le rouge  et le gris sont difficiles , à vous de choisir ! ",font=12)
#N.place(x=225,y=300)
#O=Label(fenetre,text="Si vous en avez marre de jouer, le bouton quitter est à votre disposition ! ",font=12)
#O.place(x=250,y=320)
#P=Label(fenetre,text="Créé par RADICI Clément et BACH Paul-Hugo ! ",font=12)
#P.place(x=340,y=340)

@+.

**Clemj0057** · 18/05/2014, 23h33

Hé bien grâce à vous mon jeu et désormais terminé !! ( Je n'ai plus qu'à rajouté quelques gadgets par la suite )
Je vous remercie encore une fois !

Mais juste une question,

J'ai défini ceci

Code :

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

1
2
3
4
5
Label(fenetre, text="Bienvenue dans DarkLab !", font="sans 12 bold").grid(row=2, column=1, padx=5, pady=5)
Label(fenetre, text="Choississez votre niveau en vous dirigeant vers les carrés de couleur avec les flèches.", font="sans 12 bold").grid(row=3, column=1, padx=5, pady=5)
Label(fenetre, text="Le niveau vert et bleu sont faciles, le jaune moyen et le rouge et le gris sont difficiles , à vous de choisir !", font="sans 12 bold").grid(row=4, column=1, padx=5, pady=5)
Label(fenetre, text="Si vous en avez marre de jouer, le bouton quitter est à votre disposition !", font="sans 12 bold").grid(row=5, column=1, padx=5, pady=5)
Label(fenetre, text="Créé par RADICI Clément et BACH Paul-Hugo !", font="sans 12 bold").grid(row=6, column=1, padx=5, pady=5)

Mais le problème c'est que ceci revient dans tout les niveaux, c'est extrêmement génant.

J'ai résolu le problème des niveaux s'affichant pas

Invité · 18/05/2014, 23h51

Envoyé par Clemj0057

Hé bien grâce à vous mon jeu et désormais terminé !! ( Je n'ai plus qu'à rajouté quelques gadgets par la suite )
Je vous remercie encore une fois !

Mais juste une question,

J'ai défini ceci

Code :

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

1
2
3
4
5
Label(fenetre, text="Bienvenue dans DarkLab !", font="sans 12 bold").grid(row=2, column=1, padx=5, pady=5)
Label(fenetre, text="Choississez votre niveau en vous dirigeant vers les carrés de couleur avec les flèches.", font="sans 12 bold").grid(row=3, column=1, padx=5, pady=5)
Label(fenetre, text="Le niveau vert et bleu sont faciles, le jaune moyen et le rouge et le gris sont difficiles , à vous de choisir !", font="sans 12 bold").grid(row=4, column=1, padx=5, pady=5)
Label(fenetre, text="Si vous en avez marre de jouer, le bouton quitter est à votre disposition !", font="sans 12 bold").grid(row=5, column=1, padx=5, pady=5)
Label(fenetre, text="Créé par RADICI Clément et BACH Paul-Hugo !", font="sans 12 bold").grid(row=6, column=1, padx=5, pady=5)

Mais le problème c'est que ceci revient dans tout les niveaux, c'est extrêmement génant.

c'est parce qu'il y a plus simple pour ce genre d'infos :

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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
import time
 
from tkinter import *
 
from tkinter import messagebox
 
 
def init_menu (departXY=None):
    """ correspond à l'étape D de l'algorithme """
    global menuX, menuY, mode_menu
    # est-ce qu'on a un point de départ imposé ?
    if departXY:
        # init position départ
        menuX, menuY = departXY
    # end if
    # init flag
    mode_menu = True
    # on appelle la construction d'un niveau
    init_niveau("menu")
# end def
 
 
def init_niveau (niveau):
    """
        base de connaissances sur les niveaux de jeu
    """
    global posX, posY, menuX, menuY, mode_menu
    # données niveaux
    niveaux = {
 
        "menu": ("menu.txt", 20),
 
        "niveau 1": ("niveau_1.txt", 10),
 
        "niveau 2": ("niveau_2.txt", 10),
 
        "niveau 3": ("niveau_3.txt", 10),
    }
    # on vérifie que le niveau demandé existe bien
    if niveau in niveaux:
        # sommes-nous dans le menu ?
        if niveau == "menu":
            # récupérer la dernière position enregistrée
            posX, posY = (menuX, menuY)
            # masquer le bouton menu
            btn_menu.grid_remove()
        # autre niveau
        else:
            # afficher le bouton menu
            btn_menu.grid()
            # on change de niveau à partir du menu ?
            if mode_menu:
                # on sauvegarde la dernière position
                menuX, menuY = (posX, posY)
                # RAZ flag
                mode_menu = False
            # end if
        # end if - menu
        # on dessine le décor correspondant au niveau
        dessiner_decor(*niveaux[niveau])
        # on crée le pion joueur à (posX, posY)
        init_pion ()
    # niveau demandé n'existe pas ?
    else:
        # afficher erreur
        print(
            "\n*** ATTENTION ***\n"
            "le niveau '{n}' n'est pas recensé dans la base "
            "de données !"
            .format(n=niveau)
        )
        # on arrête le programme !
        exit(1)
    # end if - niveau existe
# end def
 
 
def init_pion ():
    """ crée et place le pion à (posX, posY)"""
    global id_pion
    # init pion joueur
    id_pion = canvas.create_rectangle(
        posX-demi_bloc, posY-demi_bloc,
        posX+demi_bloc, posY+demi_bloc,
        width=1, outline="black", fill="medium purple",
    )
# end def
 
 
def clavier(event):
    """ Gestion de l'événement Appui sur une touche du clavier """
    global posX, posY
    # init nom de touche clavier
    touche = event.keysym
    # init position par avance
    dx, dy = (posX, posY)
    # déplacement vers le haut
    # touche 'z' ou flèche du clavier
    if touche in ("z", "Up"):
        dy = posY - taille_bloc
    # déplacement vers le bas
    # touche 's' ou flèche du clavier
    elif touche in ("s", "Down"):
        dy = posY + taille_bloc
    # déplacement vers la droite
    # touche 'd' ou flèche du clavier
    elif touche in ("d", "Right"):
        dx = posX + taille_bloc
    # déplacement vers la gauche
    # touche 'q' ou flèche du clavier
    elif touche in ("q", "Left"):
        dx = posX - taille_bloc
    # end if
    # init ensemble des collisions
    collisions = set(canvas.find_overlapping(dx, dy, dx, dy))
    # init singleton
    sortie = collisions.intersection(sorties)
    # pas de mur, on peut se déplacer vers là (y compris sortie)
    if sortie or not collisions:
        # màj position
        posX, posY = (dx, dy)
        # Repositionnement du pion
        canvas.coords(id_pion, posX-demi_bloc, posY-demi_bloc, posX+demi_bloc, posY+demi_bloc)
    # end if - mur
    # y a-t-il un ID de sortie à cet endroit ?
    if sortie:
        # init ID du bloc sortie
        id_bloc = sortie.pop()
        # extraction du tag
        tag_bloc = canvas.itemcget(id_bloc, "tag")
        # table de correspondance
        niveaux = {
            "F": "niveau 1",
            "D": "niveau 2",
            "N": "niveau 3",
        }
        # init nouveau niveau
        niveau = niveaux.get(tag_bloc)
        # afficher nouveau niveau
        afficher_niveau(niveau)
        # on appelle un nouveau niveau
        init_niveau(niveau)
    # end if - sortie
# end def
 
 
def afficher_niveau (niveau):
    """ petite animation de transition """
    # on vérifie quand même
    if niveau:
        # on efface le canvas
        canvas.delete(ALL)
        # fond noir
        canvas.configure(bg="black")
        # text blanc sur fond noir
        canvas.create_text(
            canvas.winfo_reqwidth()//2, canvas.winfo_reqheight()//2,
            text=str(niveau).capitalize(),
            font="sans 36 bold",
            fill="white",
        )
        # màj affichage
        canvas.update_idletasks()
        # pause 1 seconde
        time.sleep(1.0)
        # fond blanc
        canvas.configure(bg="white")
    # end if - niveau
# end def
 
 
def dessiner_decor (chemin_fichier, bloc=10):
    """ dessin du labyrinthe """
    global taille_bloc, demi_bloc, sorties, posX, posY
    # init taille bloc
    taille_bloc = max(1, abs(int(bloc)))
    # init demi-taille bloc
    demi_bloc = taille_bloc // 2
    # init ensemble des identifiants IDs
    # de canvasItems de sorties
    sorties = set()
    # init liste des codes des sorties
    codes_sorties = list("FDN")
    # init couleurs locales ^^
    couleurs_blocs = {
        "B": "black",
        "F": "light green",
        "D": "red",
        "N": "orange",
    }
    # init largeur canevas
    largeur_canevas = 0
    # on efface d'abord le canevas
    canvas.delete(ALL)
    # on ouvre le fichier passé en paramètre
    with open(chemin_fichier) as fichier:
        # lecture des données
        data = fichier.readlines()
        # comptage lignes
        lignes = len(data)
        # hauteur canevas
        hauteur_canevas = taille_bloc * lignes
        # parcours lignes
        for ligne in range(lignes):
            # extraction ligne de données
            ligne_data = data[ligne].strip("\r\n ")
            # comptage colonnes
            colonnes = len(ligne_data)
            # ajustement largeur canevas
            largeur_canevas = max(largeur_canevas, taille_bloc * colonnes)
            # parcours colonnes
            for colonne in range(colonnes):
                # on extrait un caractère (forcé en majuscules)
                char = str(ligne_data[colonne]).upper()
                # a-t-on un bloc à traiter ?
                if char != " ":
                    # calcul position du bloc actuel
                    x = colonne * taille_bloc
                    y = ligne * taille_bloc
                    # a-t-on un code "P" (position initiale joueur) ?
                    if char == "P":
                        # note : on ne dessine pas la position ici
                        # init nouvelle position joueur
                        posX, posY = (x+demi_bloc, y+demi_bloc)
                    # autres codes ?
                    else:
                        # on extrait une couleur de bloc (si existe)
                        # couleur = None si aucune correspondance trouvée
                        couleur = couleurs_blocs.get(char, None)
                        # a-t-on un bloc coloré ici ?
                        if couleur:
                            # on dessine le bloc coloré
                            # on mémorise son ID de canvasItem
                            id_bloc = canvas.create_rectangle(
                                x, y, x+taille_bloc, y+taille_bloc,
                                fill=couleur, outline=couleur,
                                # on marque les blocs avec un tag,
                                # ça peut servir :
                                tag=char,
                            )
                        # end if - couleur
                        # a-t-on un code de sortie ?
                        if char in codes_sorties:
                            # on ajoute l'ID du bloc
                            # à l'ensemble des sorties
                            # ceci nous servira plus tard pour
                            # la détection des blocs "sorties"
                            # à ne pas confondre avec les murs
                            sorties.add(id_bloc)
                        # end if - char sorties
                    # end if - char "P"
                # end if - char != " "
            # end for - colonne
        # end for - ligne
        # màj taille canevas
        canvas.configure(width=largeur_canevas, height=hauteur_canevas)
    # end with - fichier
# end def
 
 
def afficher_infos ():
    """ affiche une boîte de dialogue d'information """
    # afficher les infos
    messagebox.showinfo(
        "DarkLab",
        "Bienvenue dans DarkLab !\n\n"
        "Choisissez votre niveau en vous dirigeant "
        "vers les carrés de couleur avec les flèches du clavier.\n"
        "Les niveaux vert et bleu sont faciles, le jaune moyen, "
        "le rouge et le gris difficiles, à vous de choisir !\n"
        "Si vous en avez marre de jouer, le bouton quitter "
        "est à votre disposition !\n\n"
        "Créé par RADICI Clément et BACH Paul-Hugo !", # avec (un peu) l'aide de tarball69, non ?
        parent=fenetre,
    )
# end def
 
 
# Création de la fenêtre
fenetre = Tk()
 
# Création d'un widget Canvas
canvas = Canvas(fenetre, highlightthickness=0, bg="white")
 
canvas.grid(row=0, column=0, columnspan=2, padx=5, pady=5)
 
btn_menu = Button(fenetre, text="Menu", command=init_menu)
 
btn_menu.grid(row=1, column=0, padx=5, pady=5)
 
Button(fenetre, text="Quitter", command=fenetre.destroy).grid(row=1, column=1, padx=5, pady=5)
 
fenetre.columnconfigure(0, weight=1)
 
# init position pion de départ
init_menu((210, 170))
 
# événements clavier
fenetre.bind_all("<Key>", clavier)
 
# afficher infos dans qqs ms
fenetre.after(500, afficher_infos)
 
# boucle principale
fenetre.mainloop()

J'ai résolu le problème des niveaux s'affichant pas

Tant mieux !

@+.

**Clemj0057** · 19/05/2014, 00h05

Bon , Mr tarball69, je sais pas si c'est le destin qui m'a fait venir à vous mais j'ai eu de la chance en vous rencontrant.

Je n'aurais jamais fini mon projet sans vous et d'ailleurs j'aurais sûrement abandonné déjà depuis longtemps.

Je sais vraiment pas comment vous remercier, si ce n'est que je tient infiniment que vous sachiez que sans vous mon projet n'aurait été rien.

Merci infiniment ! Je passerais dans le 69 juste pour vous rendre visite

Si çà ne dérange pas les autres, j'aimerais tenir cette conversation comme non résolue car je pense revenir d'ici quelques jours au cas où si j'aurais besoin de quelque chose (qui sait, si cela se trouve dans 10 min je serais là

)

Sur ce, Excellente nuit à vous et à bientôt, encore merci pour tout

Invité · 19/05/2014, 00h05

Quelque chose de plus "réglo" :

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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
import time
 
from tkinter import *
 
from tkinter import messagebox
 
 
def init_menu (departXY=None):
    """ correspond à l'étape D de l'algorithme """
    global menuX, menuY, mode_menu
    # est-ce qu'on a un point de départ imposé ?
    if departXY:
        # init position départ
        menuX, menuY = departXY
    # end if
    # init flag
    mode_menu = True
    # on appelle la construction d'un niveau
    init_niveau("menu")
# end def
 
 
def init_niveau (niveau):
    """
        base de connaissances sur les niveaux de jeu
    """
    global posX, posY, menuX, menuY, mode_menu
    # données niveaux
    niveaux = {
 
        "menu": ("menu.txt", 20),
 
        "niveau 1": ("niveau_1.txt", 10),
 
        "niveau 2": ("niveau_2.txt", 10),
 
        "niveau 3": ("niveau_3.txt", 10),
    }
    # on vérifie que le niveau demandé existe bien
    if niveau in niveaux:
        # sommes-nous dans le menu ?
        if niveau == "menu":
            # récupérer la dernière position enregistrée
            posX, posY = (menuX, menuY)
            # masquer le bouton menu
            btn_menu.grid_remove()
        # autre niveau
        else:
            # afficher le bouton menu
            btn_menu.grid()
            # on change de niveau à partir du menu ?
            if mode_menu:
                # on sauvegarde la dernière position
                menuX, menuY = (posX, posY)
                # RAZ flag
                mode_menu = False
            # end if
        # end if - menu
        # on dessine le décor correspondant au niveau
        dessiner_decor(*niveaux[niveau])
        # on crée le pion joueur à (posX, posY)
        init_pion ()
    # niveau demandé n'existe pas ?
    else:
        # afficher erreur
        print(
            "\n*** ATTENTION ***\n"
            "le niveau '{n}' n'est pas recensé dans la base "
            "de données !"
            .format(n=niveau)
        )
        # on arrête le programme !
        exit(1)
    # end if - niveau existe
# end def
 
 
def init_pion ():
    """ crée et place le pion à (posX, posY)"""
    global id_pion
    # init pion joueur
    id_pion = canvas.create_rectangle(
        posX-demi_bloc, posY-demi_bloc,
        posX+demi_bloc, posY+demi_bloc,
        width=1, outline="black", fill="medium purple",
    )
# end def
 
 
def clavier(event):
    """ Gestion de l'événement Appui sur une touche du clavier """
    global posX, posY
    # init nom de touche clavier
    touche = event.keysym
    # init position par avance
    dx, dy = (posX, posY)
    # déplacement vers le haut
    # touche 'z' ou flèche du clavier
    if touche in ("z", "Up"):
        dy = posY - taille_bloc
    # déplacement vers le bas
    # touche 's' ou flèche du clavier
    elif touche in ("s", "Down"):
        dy = posY + taille_bloc
    # déplacement vers la droite
    # touche 'd' ou flèche du clavier
    elif touche in ("d", "Right"):
        dx = posX + taille_bloc
    # déplacement vers la gauche
    # touche 'q' ou flèche du clavier
    elif touche in ("q", "Left"):
        dx = posX - taille_bloc
    # end if
    # init ensemble des collisions
    collisions = set(canvas.find_overlapping(dx, dy, dx, dy))
    # init singleton
    sortie = collisions.intersection(sorties)
    # pas de mur, on peut se déplacer vers là (y compris sortie)
    if sortie or not collisions:
        # màj position
        posX, posY = (dx, dy)
        # Repositionnement du pion
        canvas.coords(id_pion, posX-demi_bloc, posY-demi_bloc, posX+demi_bloc, posY+demi_bloc)
    # end if - mur
    # y a-t-il un ID de sortie à cet endroit ?
    if sortie:
        # init ID du bloc sortie
        id_bloc = sortie.pop()
        # extraction du tag
        tag_bloc = canvas.itemcget(id_bloc, "tag")
        # table de correspondance
        niveaux = {
            "F": "niveau 1",
            "D": "niveau 2",
            "N": "niveau 3",
        }
        # init nouveau niveau
        niveau = niveaux.get(tag_bloc)
        # afficher nouveau niveau
        afficher_niveau(niveau)
        # on appelle un nouveau niveau
        init_niveau(niveau)
    # end if - sortie
# end def
 
 
def afficher_niveau (niveau):
    """ petite animation de transition """
    # on vérifie quand même
    if niveau:
        # on efface le canvas
        canvas.delete(ALL)
        # fond noir
        canvas.configure(bg="black")
        # text blanc sur fond noir
        canvas.create_text(
            canvas.winfo_reqwidth()//2, canvas.winfo_reqheight()//2,
            text=str(niveau).capitalize(),
            font="sans 36 bold",
            fill="white",
        )
        # màj affichage
        canvas.update_idletasks()
        # pause 1 seconde
        time.sleep(1.0)
        # fond blanc
        canvas.configure(bg="white")
    # end if - niveau
# end def
 
 
def dessiner_decor (chemin_fichier, bloc=10):
    """ dessin du labyrinthe """
    global taille_bloc, demi_bloc, sorties, posX, posY
    # init taille bloc
    taille_bloc = max(1, abs(int(bloc)))
    # init demi-taille bloc
    demi_bloc = taille_bloc // 2
    # init ensemble des identifiants IDs
    # de canvasItems de sorties
    sorties = set()
    # init liste des codes des sorties
    codes_sorties = list("FDN")
    # init couleurs locales ^^
    couleurs_blocs = {
        "B": "black",
        "F": "light green",
        "D": "red",
        "N": "orange",
    }
    # init largeur canevas
    largeur_canevas = 0
    # on efface d'abord le canevas
    canvas.delete(ALL)
    # on ouvre le fichier passé en paramètre
    with open(chemin_fichier) as fichier:
        # lecture des données
        data = fichier.readlines()
        # comptage lignes
        lignes = len(data)
        # hauteur canevas
        hauteur_canevas = taille_bloc * lignes
        # parcours lignes
        for ligne in range(lignes):
            # extraction ligne de données
            ligne_data = data[ligne].strip("\r\n ")
            # comptage colonnes
            colonnes = len(ligne_data)
            # ajustement largeur canevas
            largeur_canevas = max(largeur_canevas, taille_bloc * colonnes)
            # parcours colonnes
            for colonne in range(colonnes):
                # on extrait un caractère (forcé en majuscules)
                char = str(ligne_data[colonne]).upper()
                # a-t-on un bloc à traiter ?
                if char != " ":
                    # calcul position du bloc actuel
                    x = colonne * taille_bloc
                    y = ligne * taille_bloc
                    # a-t-on un code "P" (position initiale joueur) ?
                    if char == "P":
                        # note : on ne dessine pas la position ici
                        # init nouvelle position joueur
                        posX, posY = (x+demi_bloc, y+demi_bloc)
                    # autres codes ?
                    else:
                        # on extrait une couleur de bloc (si existe)
                        # couleur = None si aucune correspondance trouvée
                        couleur = couleurs_blocs.get(char, None)
                        # a-t-on un bloc coloré ici ?
                        if couleur:
                            # on dessine le bloc coloré
                            # on mémorise son ID de canvasItem
                            id_bloc = canvas.create_rectangle(
                                x, y, x+taille_bloc, y+taille_bloc,
                                fill=couleur, outline=couleur,
                                # on marque les blocs avec un tag,
                                # ça peut servir :
                                tag=char,
                            )
                        # end if - couleur
                        # a-t-on un code de sortie ?
                        if char in codes_sorties:
                            # on ajoute l'ID du bloc
                            # à l'ensemble des sorties
                            # ceci nous servira plus tard pour
                            # la détection des blocs "sorties"
                            # à ne pas confondre avec les murs
                            sorties.add(id_bloc)
                        # end if - char sorties
                    # end if - char "P"
                # end if - char != " "
            # end for - colonne
        # end for - ligne
        # màj taille canevas
        canvas.configure(width=largeur_canevas, height=hauteur_canevas)
    # end with - fichier
# end def
 
 
def afficher_infos ():
    """ affiche une boîte de dialogue d'information """
    # afficher les infos
    messagebox.showinfo(
        "DarkLab",
        "Bienvenue dans DarkLab !\n\n"
        "Choisissez votre niveau en vous dirigeant "
        "vers les carrés de couleur avec les flèches du clavier.\n\n"
        "Les niveaux vert et bleu sont faciles, le jaune moyen, "
        "le rouge et le gris difficiles, à vous de choisir !\n\n"
        "Si vous en avez marre de jouer, le bouton quitter "
        "est à votre disposition.\n\n"
        "Créé par Clément RADICI et Paul-Hugo BACH.\n\n"
        "Remerciements au forum developpez.com ainsi "
        "qu'à ses nombreux contributeurs pour leurs "
        "précieux conseils.",
        parent=fenetre,
    )
# end def
 
 
# Création de la fenêtre
fenetre = Tk()
 
fenetre.title("DarkLab")
 
# Création d'un widget Canvas
canvas = Canvas(fenetre, highlightthickness=0, bg="white")
 
canvas.grid(row=0, column=0, columnspan=3, padx=5, pady=5)
 
btn_menu = Button(fenetre, text="Menu", command=init_menu)
 
btn_menu.grid(row=1, column=0, padx=5, pady=5)
 
Button(fenetre, text="Infos jeu", command=afficher_infos).grid(row=1, column=1, padx=5, pady=5)
 
Button(fenetre, text="Quitter", command=fenetre.destroy).grid(row=1, column=2, padx=5, pady=5)
 
fenetre.columnconfigure(0, weight=1)
 
# init position pion de départ
init_menu((210, 170))
 
# événements clavier
fenetre.bind_all("<Key>", clavier)
 
# afficher infos dans qqs ms
fenetre.after(500, afficher_infos)
 
# boucle principale
fenetre.mainloop()

@+.

**Clemj0057** · 19/05/2014, 00h09

Ne vous inquiétez pas, j'ai parlé de vous dans mon dossier à plusieurs reprises

Bonne nuit et merci

Invité · 19/05/2014, 00h17

Envoyé par Clemj0057

Ne vous inquiétez pas, j'ai parlé de vous dans mon dossier à plusieurs reprises

Bonne nuit et merci

ce n'est pas la question : les mentions de crédits (remerciements) sont théoriquement obligatoires - du moins de "bon ton" (fortement recommandées) - à faire figurer en dur dans le code de votre logiciel, surtout quand vous recevez de l'aide extérieure de la part de contributeurs tels que ceux du forum developpez.com.

en plus, c'est bon pour votre CV et votre carrière future de montrer que vous savez bosser en équipe.

sur ces bonnes paroles, je vais dodo.

bonne nuit !

@+.

**Clemj0057** · 19/05/2014, 19h55

Hello ! Comment va ?

J'aurais besoin de vous pour deux éléments que je n'ai pas réussi à modifier

Je retransmet le Code :

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
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
import time
 
from tkinter import *
 
 
def init_menu (departXY=None):
    """ correspond à l'étape D de l'algorithme """
    global menuX, menuY, mode_menu
    # est-ce qu'on a un point de départ imposé ?
    if departXY:
        # init position départ
        menuX, menuY = departXY
    # end if
    # init flag
    mode_menu = True
    # on appelle la construction d'un niveau
    init_niveau("menu")
 
from tkinter import messagebox
 
 
def init_menu (departXY=None):
    """ correspond à l'étape D de l'algorithme """
    global menuX, menuY, mode_menu
    # est-ce qu'on a un point de départ imposé ?
    if departXY:
        # init position départ
        menuX, menuY = departXY
    # end if
    # init flag
    mode_menu = True
    # on appelle la construction d'un niveau
    init_niveau("menu")
# end def
 
 
def init_niveau (niveau):
    """
        base de connaissances sur les niveaux de jeu
    """
    global posX, posY, menuX, menuY, mode_menu
    # données niveaux
    niveaux = {
 
        "menu": ("menu.txt", 20),
 
        "niveau 1": ("niveau_1.txt", 10),
 
        "niveau 2": ("niveau_2.txt", 10),
 
        "niveau 3": ("niveau_3.txt", 10),
 
        "niveau 4": ("niveau_4.txt", 10),
 
        "niveau 5": ("niveau_5.txt", 10),
 
        "niveau 6": ("niveau_6.txt", 10),
 
 
    }
    # on vérifie que le niveau demandé existe bien
    if niveau in niveaux:
        # sommes-nous dans le menu ?
        if niveau == "menu":
            # récupérer la dernière position enregistrée
            posX, posY = (menuX, menuY)
            # masquer le bouton menu
            btn_menu.grid_remove()
        # autre niveau
        else:
            # afficher le bouton menu
            btn_menu.grid()
            # on change de niveau à partir du menu ?
            if mode_menu:
                # on sauvegarde la dernière position
                menuX, menuY = (posX, posY)
                # RAZ flag
                mode_menu = False
            # end if
        # end if - menu
        # on dessine le décor correspondant au niveau
        dessiner_decor(*niveaux[niveau])
        # on crée le pion joueur à (posX, posY)
        init_pion ()
    # niveau demandé n'existe pas ?
    else:
        # afficher erreur
        print(
            "\n*** ATTENTION ***\n"
            "le niveau '{n}' n'est pas recensé dans la base "
            "de données !"
            .format(n=niveau)
        )
        # on arrête le programme !
        exit(1)
    # end if - niveau existe
# end def
 
 
def init_pion ():
    """ crée et place le pion à (posX, posY)"""
    global id_pion
    # init pion joueur
    id_pion = canvas.create_rectangle(
        posX-demi_bloc, posY-demi_bloc,
        posX+demi_bloc, posY+demi_bloc,
        width=1, outline="black", fill="medium purple",
    )
# end def
 
 
def clavier(event):
    """ Gestion de l'événement Appui sur une touche du clavier """
    global posX, posY
    # init nom de touche clavier
    touche = event.keysym
    # init position par avance
    dx, dy = (posX, posY)
    # déplacement vers le haut
    # touche 'z' ou flèche du clavier
    if touche in ("z", "Up"):
        dy = posY - taille_bloc
    # déplacement vers le bas
    # touche 's' ou flèche du clavier
    elif touche in ("s", "Down"):
        dy = posY + taille_bloc
    # déplacement vers la droite
    # touche 'd' ou flèche du clavier
    elif touche in ("d", "Right"):
        dx = posX + taille_bloc
    # déplacement vers la gauche
    # touche 'q' ou flèche du clavier
    elif touche in ("q", "Left"):
        dx = posX - taille_bloc
    # end if
    # init ensemble des collisions
    collisions = set(canvas.find_overlapping(dx, dy, dx, dy))
    # init singleton
    sortie = collisions.intersection(sorties)
    # pas de mur, on peut se déplacer vers là (y compris sortie)
    if sortie or not collisions:
        # màj position
        posX, posY = (dx, dy)
        # Repositionnement du pion
        canvas.coords(id_pion, posX-demi_bloc, posY-demi_bloc, posX+demi_bloc, posY+demi_bloc)
    # end if - mur
    # y a-t-il un ID de sortie à cet endroit ?
    if sortie:
        # init ID du bloc sortie
        id_bloc = sortie.pop()
        # extraction du tag
        tag_bloc = canvas.itemcget(id_bloc, "tag")
        # table de correspondance
        niveaux = {
            "F": "niveau 1",
            "D": "niveau 2",
            "N": "niveau 3",
            "O": "niveau 4",
            "Q": "niveau 5",
            "R": "niveau 6",
        }
        # init nouveau niveau
        niveau = niveaux.get(tag_bloc)
        # afficher nouveau niveau
        afficher_niveau(niveau)
        # on appelle un nouveau niveau
        init_niveau(niveau)
    # end if - sortie
# end def
 
 
def afficher_niveau (niveau):
    """ petite animation de transition """
    # on vérifie quand même
    if niveau:
        # on efface le canvas
        canvas.delete(ALL)
        # fond noir
        canvas.configure(bg="black")
        # text blanc sur fond noir
        canvas.create_text(
            canvas.winfo_reqwidth()//2, canvas.winfo_reqheight()//2,
            text=str(niveau).capitalize(),
            font="sans 36 bold",
            fill="medium purple",
        )
        # màj affichage
        canvas.update_idletasks()
        # pause 1 seconde
        time.sleep(1.0)
        # fond blanc
        canvas.configure(bg="white")
    # end if - niveau
# end def
 
 
def dessiner_decor (chemin_fichier, bloc=10):
    """ dessin du labyrinthe """
    global taille_bloc, demi_bloc, sorties, posX, posY
    # init taille bloc
    taille_bloc = max(1, abs(int(bloc)))
    # init demi-taille bloc
    demi_bloc = taille_bloc // 2
    # init ensemble des identifiants IDs
    # de canvasItems de sorties
    sorties = set()
    # init liste des codes des sorties
    codes_sorties = list("FDNOQR")
    # init couleurs locales ^^
    couleurs_blocs = {
        "B": "black",
        "F": "light green",
        "D": "light blue",
        "N": "yellow",
        "O": "red",
        "Q": "dark blue",
        "R": "dark green",
    }
    # init largeur canevas
    largeur_canevas = 0
    # on efface d'abord le canevas
    canvas.delete(ALL)
    # on ouvre le fichier passé en paramètre
    with open(chemin_fichier) as fichier:
        # lecture des données
        data = fichier.readlines()
        # comptage lignes
        lignes = len(data)
        # hauteur canevas
        hauteur_canevas = taille_bloc * lignes
        # parcours lignes
        for ligne in range(lignes):
            # extraction ligne de données
            ligne_data = data[ligne].strip("\r\n ")
            # comptage colonnes
            colonnes = len(ligne_data)
            # ajustement largeur canevas
            largeur_canevas = max(largeur_canevas, taille_bloc * colonnes)
            # parcours colonnes
            for colonne in range(colonnes):
                # on extrait un caractère (forcé en majuscules)
                char = str(ligne_data[colonne]).upper()
                # a-t-on un bloc à traiter ?
                if char != " ":
                    # calcul position du bloc actuel
                    x = colonne * taille_bloc
                    y = ligne * taille_bloc
                    # a-t-on un code "P" (position initiale joueur) ?
                    if char == "P":
                        # note : on ne dessine pas la position ici
                        # init nouvelle position joueur
                        posX, posY = (x+demi_bloc, y+demi_bloc)
                    # autres codes ?
                    else:
                        # on extrait une couleur de bloc (si existe)
                        # couleur = None si aucune correspondance trouvée
                        couleur = couleurs_blocs.get(char, None)
                        # a-t-on un bloc coloré ici ?
                        if couleur:
                            # on dessine le bloc coloré
                            # on mémorise son ID de canvasItem
                            id_bloc = canvas.create_rectangle(
                                x, y, x+taille_bloc, y+taille_bloc,
                                fill=couleur, outline=couleur,
                                # on marque les blocs avec un tag,
                                # ça peut servir :
                                tag=char,
                            )
                        # end if - couleur
                        # a-t-on un code de sortie ?
                        if char in codes_sorties:
                            # on ajoute l'ID du bloc
                            # à l'ensemble des sorties
                            # ceci nous servira plus tard pour
                            # la détection des blocs "sorties"
                            # à ne pas confondre avec les murs
                            sorties.add(id_bloc)
                        # end if - char sorties
                    # end if - char "P"
                # end if - char != " "
            # end for - colonne
        # end for - ligne
        # màj taille canevas
        canvas.configure(width=largeur_canevas, height=hauteur_canevas)
    # end with - fichier
# end def
 
 
def afficher_infos ():
    """ affiche une boîte de dialogue d'information """
    # afficher les infos
    messagebox.showinfo(
        "DarkLab",
        "Bienvenue dans DarkLab !\n\n"
        "Choisissez votre niveau en vous dirigeant "
        "vers les carrés de couleur avec les flèches du clavier.\n"
        "Les niveaux vert et bleu sont faciles, le jaune moyen, "
        "le rouge et le bleu foncé sont difficiles, à vous de choisir !\n"
        "Si vous en avez marre de jouer, le bouton quitter "
        "est à votre disposition !\n\n"
        "Créé par Clément RADICI et Paul-Hugo BACH.\n\n"
        "Remerciements au forum developpez.com ainsi "
        "qu'à ses nombreux contributeurs pour leurs "
        "précieux conseils.",
        parent=fenetre,
    )
# end def
 
 
# Création de la fenêtre
fenetre = Tk()
fenetre.title('DarkLab 1.0 Béta ')
 
# Création d'un widget Canvas
canvas = Canvas(fenetre, highlightthickness=0, bg="white")
 
canvas.grid(row=0, column=0, columnspan=2, padx=5, pady=5)
 
btn_menu = Button(fenetre, text="Menu", command=init_menu)
btn_menu.grid(row=1, column=2, padx=5, pady=5)
 
Button(fenetre, text="Infos jeu", command=afficher_infos).grid(row=2, column=2, padx=5, pady=5)
 
Button(fenetre, text="Quitter", command=fenetre.destroy).grid(row=3, column=2, padx=5, pady=5)
 
fenetre.columnconfigure(0, weight=1)
 
# init position pion de départ
init_menu((210, 170))
 
# événements clavier
fenetre.bind_all("<Key>", clavier)
 
# afficher infos dans qqs ms
fenetre.after(500, afficher_infos)
 
# boucle principale
fenetre.mainloop()

Voici mes deux soucis :

J'aimerais changer le fond de ma fenêtre ( pas du niveau mais du contour ) , j'ai appris à le faire en créant un Canvas supplémentaire mais j'ai peur de foirer le jeu. Comment résoudre ceci ?

Ensuite, j'ai voulu déplacer les boutons Menu, Infos Jeu et Quitter pour qu'ils s'aperçoivent correctement car le Bouton Menu était caché ( Le vilain ) Mais j'aimerais les mettre soit en bas de la fenêtre sous le labyrinthe l'un à côté de l'autre à gauche ou soit en haut à droite du labyrinthe.

Je vois quelle commande vous utilisez pour les faire bouger et je m'en suis servi pour déjà les déplacer mais désormais je n'arrive pas à aller plus haut. Y aurait t'il une priorité envers le Canvas du Labyrinthe ?

Si vous voulez , je met en pièce jointe mes autres niveaux pour jouer

.

niveau_1.txt niveau_2.txt niveau_3.txt niveau_4.txt Pièce jointe 146313 niveau_5.txt

Invité · 19/05/2014, 21h08

Envoyé par Clemj0057

Hello ! Comment va ?

J'aurais besoin de vous pour deux éléments que je n'ai pas réussi à modifier

Je retransmet le Code :

Code :

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

1
2
3
4
5
6
7
8
9
10
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
(snip)(snip)
 
# afficher infos dans qqs ms
fenetre.after(500, afficher_infos)
 
# boucle principale
fenetre.mainloop()

Voici mes deux soucis :

J'aimerais changer le fond de ma fenêtre ( pas du niveau mais du contour ) , j'ai appris à le faire en créant un Canvas supplémentaire mais j'ai peur de foirer le jeu. Comment résoudre ceci ?

Bonjour,

J'ai même l'impression que vous avez 3 soucis :

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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
import time
 
from tkinter import *
 
 
def init_menu (departXY=None):
    """ correspond à l'étape D de l'algorithme """
    global menuX, menuY, mode_menu
    # est-ce qu'on a un point de départ imposé ?
    if departXY:
        # init position départ
        menuX, menuY = departXY
    # end if
    # init flag
    mode_menu = True
    # on appelle la construction d'un niveau
    init_niveau("menu")
 
from tkinter import messagebox
 
 
def init_menu (departXY=None):
    """ correspond à l'étape D de l'algorithme """
    global menuX, menuY, mode_menu
    # est-ce qu'on a un point de départ imposé ?
    if departXY:
        # init position départ
        menuX, menuY = departXY
    # end if
    # init flag
    mode_menu = True
    # on appelle la construction d'un niveau
    init_niveau("menu")
# end def

y a pas un os, là ?

les mots-clés "import" devraient tous être placés en début de script
vous avez deux définitions de init_menu(), vous ?

Pour une bordure autour du canvas :

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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
from tkinter import *
 
fenetre = Tk()
 
canvas = Canvas(
    fenetre,
    bg="yellow",
    highlightthickness=20,
    highlightbackground="red",
)
 
canvas.pack()
 
Button(fenetre, text="Quitter", command=fenetre.destroy).pack(padx=5, pady=5)
 
fenetre.mainloop()

voir ceci : http://infohost.nmt.edu/tcc/help/pub...eb/canvas.html

Ensuite, j'ai voulu déplacer les boutons Menu, Infos Jeu et Quitter pour qu'ils s'aperçoivent correctement car le Bouton Menu était caché ( Le vilain ) Mais j'aimerais les mettre soit en bas de la fenêtre sous le labyrinthe l'un à côté de l'autre à gauche ou soit en haut à droite du labyrinthe.

Je vois quelle commande vous utilisez pour les faire bouger et je m'en suis servi pour déjà les déplacer mais désormais je n'arrive pas à aller plus haut. Y aurait t'il une priorité envers le Canvas du Labyrinthe ?

Si vous voulez , je met en pièce jointe mes autres niveaux pour jouer

.

niveau_1.txt niveau_2.txt niveau_3.txt niveau_4.txt Pièce jointe 146313 niveau_5.txt

Attention : le bouton Menu est caché quand vous êtes sur le menu, il apparaît quand vous entrez dans un niveau ! (il ne faut pas changer cette logique, à moins de vouloir faire dans l'absurde !)

Pour les boutons, le plus simple resterait de les regrouper dans une boîte à boutons (une tkinter.Frame(), en fait) :

Exemple :

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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
from tkinter import *
 
fenetre = Tk()
 
canvas = Canvas(
    fenetre,
    bg="yellow",
    highlightthickness=20,
    highlightbackground="red",
)
 
canvas.grid(row=0, column=0)
 
# boîte à boutons VERTICALE
 
buttonbox = Frame(fenetre)
 
Button(buttonbox, text="Menu", command=None).pack(side=TOP, fill=X, padx=5, pady=5)
Button(buttonbox, text="Infos jeu", command=None).pack(side=TOP, fill=X, padx=5, pady=5)
Button(buttonbox, text="Quitter", command=fenetre.destroy).pack(side=TOP, fill=X, padx=5, pady=5)
 
buttonbox.grid(row=0, column=1, sticky=N)
 
# boîte à boutons HORIZONTALE
 
buttonbox2 = Frame(fenetre)
 
Button(buttonbox2, text="Menu", command=None).pack(side=LEFT, padx=5, pady=5)
Button(buttonbox2, text="Infos jeu", command=None).pack(side=LEFT, padx=5, pady=5)
Button(buttonbox2, text="Quitter", command=fenetre.destroy).pack(side=LEFT, padx=5, pady=5)
 
buttonbox2.grid(row=1, column=0)
 
fenetre.mainloop()

PS : je ne serais pas trop disponible ce soir, merci d'éviter de me solliciter ou alors demandez à d'autres contributeurs, je ne suis pas tout seul à contribuer sur ce forum.

Bonne soirée.

@+.

**Clemj0057** · 19/05/2014, 21h10

Pas de soucis ! Je comptais pas trop vous gêner

J'ai copié deux fois la même def sans faire attention alors, je suis un peu bête !

Sinon je note ce que vous m'avez envoyer, merci pour tout et bonne soirée !

**mister ikossan** · 23/05/2014, 17h05

Bonjour les internautes. Je sais que ce que je vais dire est hors contexte mais je n'ai pas trouvé de topic approprié

alors pour venir au fait, je dois réaliser un projet qui consiste à créer le jeu parchisi en algorithmique et en langage C, mais il me suffit de trouver une seule version pour la traduire. Alors qui peut m'aider ou bien qui a déjà un modèle pré-conçu qu'il me le passe?
Et merci d'avance

Invité · 23/05/2014, 17h22

Envoyé par mister ikossan

Bonjour les internautes. Je sais que ce que je vais dire est hors contexte mais je n'ai pas trouvé de topic approprié

alors pour venir au fait, je dois réaliser un projet qui consiste à créer le jeu parchisi en algorithmique et en langage C, mais il me suffit de trouver une seule version pour la traduire. Alors qui peut m'aider ou bien qui a déjà un modèle pré-conçu qu'il me le passe?
Et merci d'avance

Bonjour,

si vous ne trouvez pas de topic approprié, merci d'en créer un nouveau.

de plus, je viens de voir que vous voulez programmer en C : vous êtes ici dans un forum dédié au langage Python.

donc tout faux. merci de votre visite.

@+.

**Clemj0057** · 24/05/2014, 09h59

Bonjour Bonjour ! Me revoilà !

Ayant finalisé le projet, le prof a voulu le voir pour voir ce qu'il en pensait. J'ai dû expliquer de nombreuses lignes et j'ai su me débrouiller. Je passe Mardi à l'oral au Bac pour ma présentation.

J'ai juste un petit soucis sur la compréhension de certaines lignes...

Pourriez vous m'éclairer ? Merci !

Voici la liste :

Code :

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

1
2
3
 
    # init flag
    mode_menu = True

Cette commande détecte ou non la présence du menu dans le jeu ? d'où l'apparition et disparition du bouton Menu dans le Menu et les niveaux?

Code :

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

1
2
 # init ensemble des collisions
    collisions = set(canvas.find_overlapping(dx, dy, dx, dy))

Ceci est bien la commande pour matérialiser les murs en objets de Canvas ?

Code :

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

1
2
 # extraction du tag
        tag_bloc = canvas.itemcget(id_bloc, "tag")

Sur celle ci je bloque

Code :

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

char = str(ligne_data[colonne]).upper()

Que signifie cette dernière ?

Code :

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

Button(fenetre, text="Quitter", command=fenetre.destroy).grid(row=1, column=2, padx=5, pady=5)

Et pour terminer, je comprend la dernière ligne qui est celle ci mais je ne comprend pas à quoi servent les "padx=5, pady=5)

Merci d'avance pour m'éclaire

Invité · 24/05/2014, 15h42

Envoyé par Clemj0057

Bonjour Bonjour ! Me revoilà !

Ayant finalisé le projet, le prof a voulu le voir pour voir ce qu'il en pensait. J'ai dû expliquer de nombreuses lignes et j'ai su me débrouiller. Je passe Mardi à l'oral au Bac pour ma présentation.

J'ai juste un petit soucis sur la compréhension de certaines lignes...

Pourriez vous m'éclairer ? Merci !

Bonjour,

Fichtre ! Quelle liste !

Voici la liste :

Code :

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

1
2
3
 
    # init flag
    mode_menu = True

Cette commande détecte ou non la présence du menu dans le jeu ? d'où l'apparition et disparition du bouton Menu dans le Menu et les niveaux?

c'est un drapeau (un indicateur ON/OFF, True/False) qui indique au programme quand sauvegarder la position (menuX, menuY) pour un réaffichage ultérieur : on ne doit faire cette sauvegarde que si l'on vient d'un menu et pas autrement.

Code :

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

1
2
 # init ensemble des collisions
    collisions = set(canvas.find_overlapping(dx, dy, dx, dy))

Ceci est bien la commande pour matérialiser les murs en objets de Canvas ?

En quelque sorte. Si le canevas sert à dessiner des objets graphiques, il ne mémorise et n'accède qu'à des identifiants IDs de ces objets.

Exemple : quand on trace un rectangle sur le canevas, ce dernier ne mémorise que le numéro identifiant du rectangle et on ne peut travailler sur le rectangle qu'avec ce numéro identifiant (ou un tag, le cas échéant).

Ici, canvas.find_overlapping() sert à vérifier si les IDs trouvés à la position (dx, dy) sont des murs ou des blocs "sortie" d'où le nom de variable : collisions.

voir doc : http://infohost.nmt.edu/tcc/help/pub...s-methods.html

Code :

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

1
2
 # extraction du tag
        tag_bloc = canvas.itemcget(id_bloc, "tag")

Sur celle ci je bloque

on récupère tout simplement la valeur de la propriété tag de l'objet désigné par l'ID de canevas id_bloc d'où le nom de variable tag_bloc

c'est pas super propre comme façon de faire, mais bon, ça reste valable dans le contexte de ce logiciel.

voir doc : http://infohost.nmt.edu/tcc/help/pub...s-methods.html

Code :

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

char = str(ligne_data[colonne]).upper()

Que signifie cette dernière ?

on met simplement le caractère char trouvé dans ligne_data[colonne] en majuscules pour s'assurer que les tests qui suivront fonctionneront correctement.

voir doc : https://docs.python.org/3/library/st...html#str.upper

Code :

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

Button(fenetre, text="Quitter", command=fenetre.destroy).grid(row=1, column=2, padx=5, pady=5)

Et pour terminer, je comprend la dernière ligne qui est celle ci mais je ne comprend pas à quoi servent les "padx=5, pady=5)

Merci d'avance pour m'éclaire

padx, pady, c'est un peu du decorum, c'est pour présenter bien : on ajoute des marges en X (padx) de 5 pixels à gauche de l'objet et 5 pixels à droite, des marges en Y (pady) de 5 pixels en haut et 5 pixels en bas de l'objet.

voir doc : http://effbot.org/tkinterbook/grid.h...id.grid-method

note : d'une manière générale, évitez de solliciter les gens lorsqu'un simple

suffit à obtenir des réponses.

n'appelez au secours qu'une fois que toutes vos recherches sont restées infructueuses.

et dites-vous bien que si un intervenant trouve en deux secondes sur gooogle ce que vous aussi auriez pu trouver, vous risquez de vous faire souffler dans les narines.

alors, un petit effort, SVP, c'est vous qui passez le bac, pas nous.

Bon WE.

@+.

**Clemj0057** · 24/05/2014, 16h51

Je suis vraiment désolé, je suis allé trop loin.

J'arrive difficilement à trouver ce que je veux sur google quand je cherche quelque chose sur Python, ou soit je trouve ce que je veux mais sans le comprendre.

Désormais je ne vous embêterais plus, alors je vous dit une dernier un grand Merci pour tout

et à la prochaine , peut être !

Aide à la création d'un jeu : Le Tower defense

Tkinter Python

Discussions similaires

Partager

Partager