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

Version imprimable

Voir 40 message(s) de cette discussion en une page

A vrai dire, ma bien aimée m'a donné une idée pour mon projet :

Réaliser un Menu de Jeu, ou je déplace un carré dans un mini labyrinthe.

Il y a trois sorties disponibles, et si je vais dans la première, le labyrinthe de niveau Facile s'ouvre.
Si dans la seconde , c'est le labyrinthe de niveau moyen etc....

J'ai fais 2 labyrinthes pour le moment.

Je veux qu'au final le menu reste ouvert, lorsque je joue à un niveau du jeu, et quand je quitte le niveau ou quand je le fini, le niveau se ferme mais le Menu reste ouvert.

Voici mon code du Menu ( J'ai repris vos codes :D ) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#Menu
 
from tkinter import *
 
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 - 20
    # déplacement vers le bas
    # touche 's' ou flèche du clavier
    elif touche in ("s", "Down"):
        dy = posY + 20
    # déplacement vers la droite
    # touche 'd' ou flèche du clavier
    elif touche in ("d", "Right"):
        dx = posX + 20
    # déplacement vers la gauche
    # touche 'q' ou flèche du clavier
    elif touche in ("q", "Left"):
        dx = posX - 20
    # end if
    # y a-t-il un mur à la nouvelle position ?
    if canvas.find_overlapping(dx, dy, dx, dy):
        # pour faire joli : vraiment pas indispensable
        print("mur détecté en ({x}, {y})".format(x=dx, y=dy))
    # pas de mur, on peut se déplacer vers là
    else:
        # màj position
        posX, posY = (dx, dy)
        # Repositionnement du pion
        canvas.coords(pion, posX-10, posY-9, posX+10, posY+10)
    # end if
# end def
 
 
def dessiner_decor (chemin_fichier):
    """ dessin du labyrinthe """
    global taille_bloc
    # init taille bloc
    taille_bloc = 10
    with open(chemin_fichier) as fichier:
        data = fichier.readlines()
        lignes = len(data)
        for ligne in range(lignes):
            ligne_data = data[ligne].strip("\r\n ")
            colonnes = len(ligne_data)
            for colonne in range(colonnes):
                if ligne_data[colonne] == "B":
                    x = colonne * taille_bloc
                    y = ligne * taille_bloc
                    canvas.create_rectangle(
                        x, y, x+taille_bloc, y+taille_bloc,
                        fill="black", outline="black",
                    )
                # end if - data "B"
                if ligne_data[colonne] == "F":
                    x = colonne * taille_bloc
                    y = ligne * taille_bloc
                    canvas.create_rectangle(
                        x, y, x+taille_bloc, y+taille_bloc,
                        fill="green",
                    )
                 # end if - data "F"
                if ligne_data[colonne] == "D":
                    x = colonne * taille_bloc
                    y = ligne * taille_bloc
                    canvas.create_rectangle(
                        x, y, x+taille_bloc, y+taille_bloc,
                        fill="red",
                    )
                # end if - data "D"
                if ligne_data[colonne] == "N":
                    x = colonne * taille_bloc
                    y = ligne * taille_bloc
                    canvas.create_rectangle(
                        x, y, x+taille_bloc, y+taille_bloc,
                        fill="Yellow",
                    )
                # end if - data "N"
            # end for - colonne
        # end for - ligne
    # end with - fichier
# end def
 
# Création de la fenêtre
 
fenetre = Tk()
fenetre.geometry("1000x400")
L=Label(fenetre,text=" Bienvenue dans DarkLab ! ",font=12)
L.place(x=400,y=200)
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=220)
N=Label(fenetre,text="Le niveau vert est facile, le jaune moyen et le rouge est difficile , à vous de choisir ! ",font=12)
N.place(x=225,y=240)
O=Label(fenetre,text="Si vous en avez marre de jouer, le bouton quitter est à votre disposition ! ",font=12)
O.place(x=250,y=260)
# Création d'un widget Canvas
 
canvas = Canvas(fenetre, width=300, height=150, highlightthickness=0, bg="white")
 
canvas.pack(padx=5, pady=5)
 
dessiner_decor("Menu.txt")
 
Button(fenetre, text="Quitter", command=fenetre.destroy).pack(padx=5, pady=5)
 
# Position du pion au départ
posX, posY = (150, 119)
 
pion = canvas.create_rectangle(posX-10, posY-9, posX+10, posY+10, width=1, outline="black", fill="medium purple")
 
# événements clavier
fenetre.bind_all("<Key>", clavier)
 
# boucle principale
fenetre.mainloop()

18/05/2014, 00h20
Invité
Citation:

Envoyé par Clemj0057

A vrai dire, ma bien aimée m'a donné une idée pour mon projet :

Réaliser un Menu de Jeu, ou je déplace un carré dans un mini labyrinthe.

Il y a trois sorties disponibles, et si je vais dans la première, le labyrinthe de niveau Facile s'ouvre.
Si dans la seconde , c'est le labyrinthe de niveau moyen etc....

J'ai fais 2 labyrinthes pour le moment.

Je veux qu'au final le menu reste ouvert, lorsque je joue à un niveau du jeu, et quand je quitte le niveau ou quand je le fini, le niveau se ferme mais le Menu reste ouvert.

Voici mon code du Menu ( J'ai repris vos codes :D ) :

(snip)(snip)

OK, j'ai bien compris le principe. ;)

toutefois, ouvrir plusieurs fenêtres risque de provoquer de la confusion chez les utilisateurs de votre jeu, d'autant plus que pendant qu'ils jouent, le "menu" occupe de la place à l'écran pour rien.

et que se passerait-il si un joueur décidait d'ouvrir un labyrinthe, commencer à jouer, puis de retourner au menu pour s'ouvrir encore un autre labyrinthe et ainsi de suite ?

ce serait très vite le bazar et dur dur pour gérer tout ça. :roll:

dans les interfaces graphiques, on essaie de ne pas noyer l'utilisateur dans le nombre de fenêtres ouvertes : moins il y en a, mieux c'est.

je vous suggérerais donc l'algorithme suivant :
```
ETAPE 0:
  initialiser (menuX, menuY) = (departX, departY)
  aller à D

ETAPE A:
  effacer canevas
  charger décor fichier_niveau
SI
  fichier_niveau contient caractère "P"
ALORS
  initialiser (carreX, carreY) à position de "P"
FIN SI
  placer carré joueur en (carreX, carreY)
  aller à B

ETAPE B:
  utiliser boucle programme déplacement dans labyrinthe
SI
  bouton "Menu" cliqué
ALORS
  aller à D
FIN SI
SI
  sortie 1 atteinte
ALORS
  fichier_niveau = "fichier_niveau1.txt"
  aller à C
SINON SI
  sortie 2 atteinte
ALORS
  fichier_niveau = "fichier_niveau2.txt"
  aller à C
SINON SI
  sortie 3 atteinte
ALORS
  fichier_niveau = "fichier_niveau3.txt"
  aller à C
etc...
SINON
  aller à B
FIN SI

ETAPE C:
SI
  mode_menu == True
ALORS
  sauvegarder (menuX, menuY) = (carreX, carreY)
  mode_menu = False
FIN SI
  afficher bouton "Menu"
  aller à A

ETAPE D:
  initialiser variable fichier_niveau = "menu.txt"
  initialiser mode_menu = True
  restaurer (carreX, carreY) = (menuX, menuY)
  masquer bouton "Menu"
  aller à A
```
en utilisant cet algorithme :

* vous n'avez besoin que d'un seul script pour le jeu tout entier, menu y compris (pas d'appel à des scripts externes)
* vous implémentez une seule boucle programme, une seule boucle de déplacement générique dans un labyrinthe
* vous pouvez même placer le caractère correspondant à sortie 2 dans le fichier labyrinthe niveau1.txt, la transition se fera automatiquement
* vous pouvez même placer le caractère correspondant à sortie 3 dans le fichier labyrinthe niveau2.txt, la transition se fera automatiquement
* vous permettez au joueur d'appeler le menu à tout moment du jeu grâce à un bouton cliquable (sauf évidemment quand le joueur est déjà dans le menu)
* le menu mémorisera la dernière position du carré joueur avant basculement dans un niveau de jeu puis restaurera cette position le moment venu

comme quoi, en s'organisant bien, on n'a pas besoin de partir dans tous les sens. :mouarf:

bon courage. ;)

Coucou !

Désolé pour cette nuit de n'avoir pas pu vous répondre,

Merci pour les conseils j'ai réalisé l'algorithme que vous m'avez conseillé.

En dehors de ce que je ne sais pas coder , pour l'instant j'ai çà :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#Etape O
  posX, posY = (150, 119)
  aller à D  ( Je ne comprend pas cette ligne,cest la position du carré dans le menu ?) 
 
#Etape A
  canvas = Canvas.delete(all)
  def dessiner_decor (chemin_fichier):
    """ dessin du labyrinthe """
    global taille_bloc
    # init taille bloc
    taille_bloc = 10
    with open(chemin_fichier) as fichier:
        data = fichier.readlines()
        lignes = len(data)
        for ligne in range(lignes):
            ligne_data = data[ligne].strip("\r\n ")
            colonnes = len(ligne_data)
            for colonne in range(colonnes):
                if ligne_data[colonne] == "B":
                    x = colonne * taille_bloc
                    y = ligne * taille_bloc
                    canvas.create_rectangle(
                        x, y, x+taille_bloc, y+taille_bloc,
                        fill="black", outline="black",
                    )
                # end if - data "B"
                if ligne_data[colonne] == "F":
                    x = colonne * taille_bloc
                    y = ligne * taille_bloc
                    canvas.create_rectangle(
                        x, y, x+taille_bloc, y+taille_bloc,
                        fill="green",
                    )
                 # end if - data "F"
                if ligne_data[colonne] == "D":
                    x = colonne * taille_bloc
                    y = ligne * taille_bloc
                    canvas.create_rectangle(
                        x, y, x+taille_bloc, y+taille_bloc,
                        fill="red",
                    )
                # end if - data "D"
                if ligne_data[colonne] == "N":
                    x = colonne * taille_bloc
                    y = ligne * taille_bloc
                    canvas.create_rectangle(
                        x, y, x+taille_bloc, y+taille_bloc,
                        fill="Yellow",
                    )
                # end if - data "N"
            # end for - colonne
        # end for - ligne
    # end with - fichier
# end def
 
  if ligne_data[colonne] == "P":
                    x = colonne * taille_bloc
                    y = ligne * taille_bloc
                    canvas.create_rectangle(
                        x, y, x+taille_bloc, y+taille_bloc,
                        fill="Yellow",
                    )
   # end if - data "N"
  posX, posY =(carreX, carreY)
  aller à B ( Comprend toujours pas ) Est-ce un code pour vous ^^ ? 
 
#ETAPE B : 
 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 - 20
    # déplacement vers le bas
    # touche 's' ou flèche du clavier
    elif touche in ("s", "Down"):
        dy = posY + 20
    # déplacement vers la droite
    # touche 'd' ou flèche du clavier
    elif touche in ("d", "Right"):
        dx = posX + 20
    # déplacement vers la gauche
    # touche 'q' ou flèche du clavier
    elif touche in ("q", "Left"):
        dx = posX - 20
    # end if
    # y a-t-il un mur à la nouvelle position ?
    if canvas.find_overlapping(dx, dy, dx, dy):
        # pour faire joli : vraiment pas indispensable
        print("mur détecté en ({x}, {y})".format(x=dx, y=dy))
    # pas de mur, on peut se déplacer vers là
    else:
        # màj position
 
        # Repositionnement du pion
        canvas.coords(pion, posX-10, posY-9, posX+10, posY+10)
    # end if
# end def
 if Button(fenetre, text="Quitter", command=fenetre.destroy)
   posX, posY = (dx, dy) 
  #aller à D 
 # end if
if posX, posY = (sortie1x, sortie1y)
       dessiner_decor("Niveau1.txt")
       posX, posY = (Niveau1x, Niveau1y)
elif posX, posY = (sortie2x, sortie2y)
        dessiner_decor("Niveau2.txt")
        posX, posY = (Niveau2x, Niveau2y)
elif posX, posY = (sortie3x, sortie3y)
        dessiner_decor("Niveau3.txt")
        posX, posY = (Niveau3x, Niveau3y)
# end if
 
#Etape C 
if
  mode_menu == True
  save.(menuX, menuY) = (carreX, carreY)
  mode_menu = False
# end if 
  Button(fenetre, text="Menu") command=fenetre.open)
  posX, posY = (dx, dy)
 
#ETAPE D 
  initialiser variable fichier_niveau = "menu.txt"
  initialiser mode_menu = True
  restaurer (carreX, carreY) = (menuX, menuY)
  masquer bouton "Menu"
  posX, posY = (dx, dy)

Tout ceci correspond à votre code ;)

1 pièce(s) jointe(s)

Citation:

Envoyé par Clemj0057

Code:

1
2
3
#Etape O
  posX, posY = (150, 119)
  aller à D  ( Je ne comprend pas cette ligne,cest la position du carré dans le menu ?)

Bonjour,

Non, c'est "aller à l'étape D de l'algorithme". :)

un algorithme, c'est grosso modo une façon codifiée d'organiser ses idées.

un algorithme est donc sujet à INTERPRÉTATION et à RÉADAPTATION en fonction du langage utilisé et de ses contraintes propres.

en effet, s'il suffisait de transposer brut de décoffrage un algorithme en code, alors à quoi bon écrire d'abord un algorithme ? autant coder directement. :D

l'algorithme est là pour vous guider dans le flux du programme, dans le déroulement des actions et des événements, mais cela ne signifie pas qu'il faut l'appliquer aveuglément.

Pour la fonction dessiner_decor(), je vois que vous répétez beaucoup des morceaux de code qui se ressemblent (redondances).

Il faudrait peut-être d'abord optimiser votre code avant de vous pencher sur l'algorithme (code de démo) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
from tkinter import *
 
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(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:
        # appeler une fonction ici (?)
        # faire un traitement, peut-être (?)
        id_bloc = sortie.pop()
        tag_bloc = canvas.itemcget(id_bloc, "tag")
        print(
            "sortie id={bid} tag='{btag}' détectée en ({x}, {y})"
            .format(bid=id_bloc, btag=tag_bloc, x=dx, y=dy)
        )
    # end if - sortie
# end def
 
 
def dessiner_decor (chemin_fichier):
    """ dessin du labyrinthe """
    global taille_bloc, demi_bloc, sorties, posX, posY
    # init taille bloc
    taille_bloc = 10
    # 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",
    }
    # 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)
        # 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()
                # 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
    # end with - fichier
# end def
 
 
# Création de la fenêtre
fenetre = Tk()
 
# Création d'un widget Canvas
canvas = Canvas(fenetre, width=520, height=200, highlightthickness=0, bg="white")
 
canvas.pack(padx=5, pady=5)
 
# Position du pion au départ
posX, posY = (15, 185)
 
dessiner_decor("Laby.txt")
 
pion = canvas.create_rectangle(
    posX-demi_bloc, posY-demi_bloc,
    posX+demi_bloc, posY+demi_bloc,
    width=1, outline="black", fill="medium purple",
)
 
# on met le pion au premier plan d'affichage
canvas.tag_raise(pion, ALL)
 
Button(fenetre, text="Quitter", command=fenetre.destroy).pack(padx=5, pady=5)
 
# événements clavier
fenetre.bind_all("<Key>", clavier)
 
# boucle principale
fenetre.mainloop()

comme je n'avais pas la structure interne de vos fichiers "niveau_x.txt", j'ai recyclé votre ancien fichier : Pièce jointe 146183

pour l'algorithme, essayez de voir comment vous pouvez incruster les différents éléments de l'algorithme dans votre code, n'essayez pas de tordre votre code pour qu'il ressemble à l'algorithme.

c'est l'algorithme qui s'intègre à votre code comme un guide, pas le contraire.

PS: le code ici présent intègre déjà quelques lignes de l'algorithme, regardez comment j'ai procédé et comparez à ce qui est mentionné dans l'algorithme pour bien comprendre comment on fusionne des directives avec du vrai code.

@+.

18/05/2014, 15h03
Clemj0057

Houaw,

Je vous ai perdu je crois bien, et si je simplifiais les choses en ne créant que des boutons sur lesquels lorsque j'appuie dessus le niveau demandé s'ouvre ?

Désolé pour la perte de temps que je vous ai occasionné mais je crois qu'on sort de mes capacités ^^
18/05/2014, 15h20
Invité

Citation:

Envoyé par Clemj0057

Houaw,

Je vous ai perdu je crois bien, et si je simplifiais les choses en ne créant que des boutons sur lesquels lorsque j'appuie dessus le niveau demandé s'ouvre ?

Bah quoi ? c'était rigoLOL, non ? :mouarf:

Pourquoi perdu ? ça fonctionne, non ? (avec le fichier Laby.txt que j'ai joint)

Pourquoi des boutons ? vous avez les objets tkinter.Menu() pour gérer des vrais menus => autant les utiliser.

Citation:

Désolé pour la perte de temps que je vous ai occasionné mais je crois qu'on sort de mes capacités ^^

Ce n'est pas une perte de temps : ça m'amuse beaucoup de réviser mes classiques. ^^

Gardez ce code pour plus tard : si vous faites des études sup, vous y reviendrez avec beaucoup d'étonnement (hey ! mais j'ai vu ça et ça en cours !).

Et en plus, ça me permet de me pencher sur des problèmes que je n'avais jamais étudiés auparavant, donc c'est du gagnant-gagnant pour tout le monde. :mrgreen:
18/05/2014, 15h26
Clemj0057

Ah j'avais pas vu que vous avez joint un fichier Txt :roll:...

Je viens de le relancer et c'est vrai que celà fonctionne !

Maintenant je dois faire en sorte que lorsque je vais sur ces cubes , mes fenêtres s'ouvrent si j'ai bien compris, je vais essayer de retranscrire tout çà pour mon menu . Merci ! :)

Je suis moins géné désormais ;) ! :D

J'ai retranscris tout çà pour mon menu,

Citation:

Pourquoi des boutons ? vous avez les objets tkinter.Menu() pour gérer des vrais menus => autant les utiliser.

Je ne connais pas cette commande, mais je ne retrouve plus la ligne où l'on définnissais la taille du mon Carré à déplacer, car dans le Menu il est deux fois plus grand.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
from tkinter import *
 
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(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:
        # appeler une fonction ici (?)
        # faire un traitement, peut-être (?)
        id_bloc = sortie.pop()
        tag_bloc = canvas.itemcget(id_bloc, "tag")
        print(
            "sortie id={bid} tag='{btag}' détectée en ({x}, {y})"
            .format(bid=id_bloc, btag=tag_bloc, x=dx, y=dy)
        )
    # end if - sortie
# end def
 
 
def dessiner_decor (chemin_fichier):
    """ dessin du labyrinthe """
    global taille_bloc, demi_bloc, sorties, posX, posY
    # init taille bloc
    taille_bloc = 10
    # 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",
    }
    # 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)
        # 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()
                # 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
    # end with - fichier
# end def
 
 
# Création de la fenêtre
fenetre = Tk()
 
# Création d'un widget Canvas
canvas = Canvas(fenetre, width=300, height=150, highlightthickness=0, bg="white")
 
canvas.pack(padx=5, pady=5)
 
# Position du pion au départ
posX, posY = (150, 100)
 
dessiner_decor("Menu.txt")
 
pion = canvas.create_rectangle(
    posX-demi_bloc, posY-demi_bloc,
    posX+demi_bloc, posY+demi_bloc,
    width=1, outline="black", fill="medium purple",
)
 
# on met le pion au premier plan d'affichage
canvas.tag_raise(pion, ALL)
 
Button(fenetre, text="Quitter", command=fenetre.destroy).pack(padx=5, pady=5)
 
# événements clavier
fenetre.bind_all("<Key>", clavier)
 
# boucle principale
fenetre.mainloop()

18/05/2014, 15h35
Invité

Citation:

Envoyé par Clemj0057

Ah j'avais pas vu que vous avez joint un fichier Txt :roll:...

Je viens de le relancer et c'est vrai que celà fonctionne !

Maintenant je dois faire en sorte que lorsque je vais sur ces cubes , mes fenêtres s'ouvrent si j'ai bien compris, je vais essayer de retranscrire tout çà pour mon menu . Merci ! :)

Je suis moins géné désormais ;) ! :D

bon courage. :mrgreen:

pour la suite de votre jeu, c'est du tout cuit, maintenant. :pastaper:

Citation:

Envoyé par Clemj0057

J'ai retranscris tout çà pour mon menu,

Je ne connais pas cette commande, mais je ne retrouve plus la ligne où l'on définnissais la taille du mon Carré à déplacer, car dans le Menu il est deux fois plus grand.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
from tkinter import *
 
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(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:
        # appeler une fonction ici (?)
        # faire un traitement, peut-être (?)
        id_bloc = sortie.pop()
        tag_bloc = canvas.itemcget(id_bloc, "tag")
        print(
            "sortie id={bid} tag='{btag}' détectée en ({x}, {y})"
            .format(bid=id_bloc, btag=tag_bloc, x=dx, y=dy)
        )
    # end if - sortie
# end def
 
 
def dessiner_decor (chemin_fichier):
    """ dessin du labyrinthe """
    global taille_bloc, demi_bloc, sorties, posX, posY
    # init taille bloc
    taille_bloc = 10
    # 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",
    }
    # 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)
        # 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()
                # 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
    # end with - fichier
# end def
 
 
# Création de la fenêtre
fenetre = Tk()
 
# Création d'un widget Canvas
canvas = Canvas(fenetre, width=300, height=150, highlightthickness=0, bg="white")
 
canvas.pack(padx=5, pady=5)
 
# Position du pion au départ
posX, posY = (150, 100)
 
dessiner_decor("Menu.txt")
 
pion = canvas.create_rectangle(
    posX-demi_bloc, posY-demi_bloc,
    posX+demi_bloc, posY+demi_bloc,
    width=1, outline="black", fill="medium purple",
)
 
# on met le pion au premier plan d'affichage
canvas.tag_raise(pion, ALL)
 
Button(fenetre, text="Quitter", command=fenetre.destroy).pack(padx=5, pady=5)
 
# événements clavier
fenetre.bind_all("<Key>", clavier)
 
# boucle principale
fenetre.mainloop()

ben utilisez les paramètres et les arguments de fonctions.

un truc du genre :

Code:

1
2
3
4
5
 
# Position du pion au départ
posX, posY = (150, 100)
 
dessiner_decor("Menu.txt", bloc=20)

puis dans :

Code:

1
2
3
4
5
6
7
8
9
10
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))) # si on omet le paramètre bloc, il vaudra 10 par défaut e.g. dessiner_decor("niveau1.txt") => bloc=10
    # init demi-taille bloc
    demi_bloc = taille_bloc // 2
    # init ensemble des identifiants IDs
    # de canvasItems de sorties
    sorties = set()

J'ai juste un petit problème, j'ai modifié mon Menu mais mon Pion je bouge plus !
Il doit y avoir un problème avec les variables dx , dy , posX et posY.

Pas moyen de le refaire bouger ...

Puis dans votre code :
Code:

1 2 3 4 5 6 7 8 9 10 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))) # si on omet le paramètre bloc, il vaudra 10 par défaut e.g. dessiner_decor("niveau1.txt") => bloc=10 # init demi-taille bloc demi_bloc = taille_bloc // 2 # init ensemble des identifiants IDs # de canvasItems de sorties sorties = set()
Je ne comprend pas comment avec ce code je peux ouvrir mon niveau ,

N'existe t'il pas une commande du style

tkinter.open(Niveau 1.txt) tout bêtement ? Je pourrais la placer en fin de votre code non ?

Citation:

Envoyé par Clemj0057

J'ai juste un petit problème, j'ai modifié mon Menu mais mon Pion je bouge plus !
Il doit y avoir un problème avec les variables dx , dy , posX et posY.

Pas moyen de le refaire bouger ...

Votre dernier code en date (publier ici) ? Fichier Menu.txt joint ?

Je ne peux pas tester en aveugle, ce n'est pas possible. :mouarf:
Citation:
Puis dans votre code :
Code:

1 2 3 4 5 6 7 8 9 10 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))) # si on omet le paramètre bloc, il vaudra 10 par défaut e.g. dessiner_decor("niveau1.txt") => bloc=10 # init demi-taille bloc demi_bloc = taille_bloc // 2 # init ensemble des identifiants IDs # de canvasItems de sorties sorties = set()
Je ne comprend pas comment avec ce code je peux ouvrir mon niveau ,

N'existe t'il pas une commande du style

tkinter.open(Niveau 1.txt) tout bêtement ? Je pourrais la placer en fin de votre code non ?
c'était juste une mise à jour de la fonction dessiner_decor() que vous avez déjà.

il faut bien relire attentivement :
Code:

1 2 3 4 5 def dessiner_decor (chemin_fichier, bloc=10): # <= modification ici, on ajoute bloc=10 en argument de fonction """ dessin du labyrinthe """ global taille_bloc, demi_bloc, sorties, posX, posY # init taille bloc taille_bloc = max(1, abs(int(bloc))) # <= modification ici aussi
il y avait juste deux modifs à faire dans cette fonction, puis à utiliser la fonction comme je vous l'avais indiqué :
Code:

1 2 3 4 5 6 7 # Position du pion au départ posX, posY = (150, 100) dessiner_decor("Menu.txt", bloc=20) # pour le menu #dessiner_decor("niveau_x.txt") # pour les autres (voir algorithme)
et non, il n'y a pas de tkinter.open(Niveau 1.txt) : tout bêtement parce que tkinter ne sait pas ce que vous voulez faire avec vos programmes. :mouarf:

18/05/2014, 16h23
Clemj0057

1 pièce(s) jointe(s)
Je vous envoie le fichier en question !

Pièce jointe 146187

Voilà mais je commence vraiment à décrocher, soit je suis en surdose de programmation :mouarf: ou soit je suis débile. :oops:

Ce n'est pas possible de faire plus simple ?? :weird:
Code:

1 2 if PosX=150 and PosY=200 execfile("Niveau1.py")

2 pièce(s) jointe(s)

Citation:

Envoyé par Clemj0057

Je vous envoie le fichier en question !

Pièce jointe 146187

Voilà mais je commence vraiment à décrocher, soit je suis en surdose de programmation :mouarf: ou soit je suis débile. :oops:

Je pencherais pour la saturation, en effet. :mrgreen:

Voici un exemple de jeu (presque) complet :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
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
#!/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",
    }
    # 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)
        # 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()
                # 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
    # end with - fichier
# end def
 
 
# Création de la fenêtre
fenetre = Tk()
 
# Création d'un widget Canvas
canvas = Canvas(fenetre, width=520, height=200, 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()

:pc: A utiliser avec les fichiers joints : Pièce jointe 146205 et Pièce jointe 146207

Je vous laisserai le soin de créer les fichiers "niveau_2.txt" et "niveau_3.txt" (en copiant "niveau_1.txt", par exemple) si vous voulez que le script fonctionne pleinement.

Quelques trucs à savoir pour les fichiers menu.txt et niveau_1.txt...niveau_x.txt :

utilisez le caractère "B" pour les blocs de murs ;
utilisez le caractère " " (espace) pour la piste de déplacement ;
ne mettez pas le caractère "P" dans menu.txt : la position du joueur est traitée autrement ;
utilisez le caractère "P" pour placer le carré joueur dans les fichiers "niveau_1.txt", "niveau_2.txt"...etc..."niveau_x.txt" et semblables ;
utilisez les caractères "F", "D" et "N" pour les sorties des niveaux 1, 2 et 3, respectivement (F=>1, D=>2, N=>3) ;
pour l'instant, aucun autre caractère n'est supporté par la fonction dessiner_decor() donc inutile de risquer des bugs pour rien ;
un fichier menu.txt doit se composer d'une grille de caractères de 26 colonnes et 10 lignes ;
les autres fichiers niveau_1.txt...etc...niveau_x.txt doivent se composer d'une grille de caractères de 52 colonnes et 20 lignes ;

Il vous restera à gérer la fin de partie (e.g. fonction game_over()) plus quelques bidouilles par-ci par-là.

A vous de voir maintenant ce que vous pouvez (voulez ?) en faire.

Bon courage.

@+.

18/05/2014, 19h58
Clemj0057

Je ne sais vraiment pas comment vous remercier vu que vous avez tout fait dans mon programme ( J'ai honte ).

C'est vraiment réussi !!! Vous être un dieu ! :mouarf:

Je dois juste maintenant apprendre TOUTES les lignes, çà va être relativement balèze... :mouarf:

J'ai juste un problème , on ne peux pas changer le faite que les niveaux doivent être obligatoirement de 52x20?
18/05/2014, 20h52
Invité

Citation:

Envoyé par Clemj0057

Je ne sais vraiment pas comment vous remercier vu que vous avez tout fait dans mon programme ( J'ai honte ).

Ah non, justement. J'ai fait le gros de la troupe, mais avec le temps et l'expérience, vous verrez qu'il y a encore beaucoup, beaucoup à remanier dans ce code.

C'est loin d'être parfait. :mrgreen:

Citation:

C'est vraiment réussi !!! Vous être un dieu ! :mouarf:

Je dois juste maintenant apprendre TOUTES les lignes, çà va être relativement balèze... :mouarf:

Eh ! Le mieux serait de COMPRENDRE toutes les lignes (les commentaires devraient quand même bien aider). ;)

Citation:

J'ai juste un problème , on ne peux pas changer le faite que les niveaux doivent être obligatoirement de 52x20?

Bien sûr qu'on peut changer ça :D la programmation, c'est hyper souple.

Je vous avais d'ailleurs fourni une variante de dessiner_decor() au début de ce fil de discussion : relisez et retrouvez comment on fait. :mrgreen:

@+.
18/05/2014, 21h01
Clemj0057

Merci ! Je suis en train de regarder tout celà mais juste une question :

Que signifie cette ligne ?

Code:

taille_bloc = max(1, abs(int(bloc)))
18/05/2014, 21h14
Invité

Citation:

Envoyé par Clemj0057

Merci ! Je suis en train de regarder tout celà mais juste une question :

Que signifie cette ligne ?

Code:

taille_bloc = max(1, abs(int(bloc)))

Littéralement : taille_bloc égale le maximum entre 1 et la valeur absolue de la partie entière du paramètre bloc.

C'est une façon indirecte de s'assurer qu'un paramètre aura une valeur entière > 0, puisqu'on ne voudrait pas que la taille d'un bloc soit nulle ou négative.

Tout simplement. ;)

@+.
18/05/2014, 21h25
Clemj0057

La variable 'bloc' correspond à la taille du Pion ?
Je ne vois pas du tout comment changer la taille des labyrinthes ! :lol:

J'ai une petite question juste, vous m'avez suggéré un système de perte , de Game Over, j'aurais l'idée de mettre un minuteur avec un temps imparti pour que le joueur perde lorsque ce dernier n'aura plus de temps. Je ne ferais çà que si j'aurais encore du temps avec la finalisation . :mrgreen:
18/05/2014, 21h36
Invité

Citation:

Envoyé par Clemj0057

La variable 'bloc' correspond à la taille du Pion ?
Je ne vois pas du tout comment changer la taille des labyrinthes ! :lol:

Le paramètre bloc (défini dans def dessiner_decor(chemin_fichier, bloc=10) ) correspond à la taille standard de TOUS les blocs (pion joueur, murs, blocs sorties).

Ici, on fixe la taille du bloc par avance, mais rien ne nous empêche de calculer la taille du bloc par rapport à la largeur du canevas, par exemple.

Relisez ce fil de discussion depuis le début : tout y est...

Citation:

J'ai une petite question juste, vous m'avez suggéré un système de perte , de Game Over, j'aurais l'idée de mettre un minuteur avec un temps imparti pour que le joueur perde lorsque ce dernier n'aura plus de temps. Je ne ferais çà que si j'aurais encore du temps avec la finalisation . :mrgreen:

La fonction game_over() n'est pas "un système de perte" : c'est juste une fonction qui gère la fin d'une partie.

Bien sûr, en général, on a tendance à faire une fonction bravo() pour la gagne et un game_over() pour la louse, mais ce n'est pas une obligation.

@+.

Voir 40 message(s) de cette discussion en une page