IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Tkinter Python Discussion :

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


Sujet :

Tkinter Python

  1. #61
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2014
    Messages
    49
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mai 2014
    Messages : 49
    Par défaut
    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 ) :

    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
     
    #!/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()

  2. #62
    Invité
    Invité(e)
    Par défaut
    Citation Envoyé par Clemj0057 Voir le message
    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 ) :

    (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.

    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.

    bon courage.

  3. #63
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2014
    Messages
    49
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mai 2014
    Messages : 49
    Par défaut
    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 : 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
    #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

  4. #64
    Invité
    Invité(e)
    Par défaut
    Citation Envoyé par Clemj0057 Voir le message
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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.

    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 : 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
    #!/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 : Laby.txt

    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.

    @+.

  5. #65
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2014
    Messages
    49
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mai 2014
    Messages : 49
    Par défaut
    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 ^^

  6. #66
    Invité
    Invité(e)
    Par défaut
    Citation Envoyé par Clemj0057 Voir le message
    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 ?

    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.

    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.

  7. #67
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2014
    Messages
    49
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mai 2014
    Messages : 49
    Par défaut
    Ah j'avais pas vu que vous avez joint un fichier Txt ...

    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 !

  8. #68
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2014
    Messages
    49
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mai 2014
    Messages : 49
    Par défaut
    J'ai retranscris tout çà pour mon menu,

    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 : 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
    #!/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()

  9. #69
    Invité
    Invité(e)
    Par défaut
    Citation Envoyé par Clemj0057 Voir le message
    Ah j'avais pas vu que vous avez joint un fichier Txt ...

    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 !
    bon courage.

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

  10. #70
    Invité
    Invité(e)
    Par défaut
    Citation Envoyé par Clemj0057 Voir le message
    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 : 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
    #!/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 : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    # Position du pion au départ
    posX, posY = (150, 100)
     
    dessiner_decor("Menu.txt", bloc=20)
    puis dans :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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()

  11. #71
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2014
    Messages
    49
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mai 2014
    Messages : 49
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 ?

  12. #72
    Invité
    Invité(e)
    Par défaut
    Citation Envoyé par Clemj0057 Voir le message
    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.

    Puis dans votre code :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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.

  13. #73
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2014
    Messages
    49
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mai 2014
    Messages : 49
    Par défaut
    Je vous envoie le fichier en question !

    Menu.txt

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

    Ce n'est pas possible de faire plus simple ??

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    if PosX=150 and PosY=200
                 execfile("Niveau1.py")

  14. #74
    Invité
    Invité(e)
    Par défaut
    Citation Envoyé par Clemj0057 Voir le message
    Je vous envoie le fichier en question !

    Menu.txt

    Voilà mais je commence vraiment à décrocher, soit je suis en surdose de programmation ou soit je suis débile.
    Je pencherais pour la saturation, en effet.

    Voici un exemple de jeu (presque) 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
    #!/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()
    A utiliser avec les fichiers joints : menu.txt et niveau_1.txt

    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 :

    1. utilisez le caractère "B" pour les blocs de murs ;
    2. utilisez le caractère " " (espace) pour la piste de déplacement ;
    3. ne mettez pas le caractère "P" dans menu.txt : la position du joueur est traitée autrement ;
    4. 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 ;
    5. utilisez les caractères "F", "D" et "N" pour les sorties des niveaux 1, 2 et 3, respectivement (F=>1, D=>2, N=>3) ;
    6. pour l'instant, aucun autre caractère n'est supporté par la fonction dessiner_decor() donc inutile de risquer des bugs pour rien ;
    7. un fichier menu.txt doit se composer d'une grille de caractères de 26 colonnes et 10 lignes ;
    8. 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.

    @+.

  15. #75
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2014
    Messages
    49
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mai 2014
    Messages : 49
    Par défaut
    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 !

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

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

  16. #76
    Invité
    Invité(e)
    Par défaut
    Citation Envoyé par Clemj0057 Voir le message
    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.

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

    Je dois juste maintenant apprendre TOUTES les lignes, çà va être relativement balèze...
    Eh ! Le mieux serait de COMPRENDRE toutes les lignes (les commentaires devraient quand même bien aider).

    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 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.

    @+.

  17. #77
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2014
    Messages
    49
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mai 2014
    Messages : 49
    Par défaut
    Merci ! Je suis en train de regarder tout celà mais juste une question :

    Que signifie cette ligne ?

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    taille_bloc = max(1, abs(int(bloc)))

  18. #78
    Invité
    Invité(e)
    Par défaut
    Citation Envoyé par Clemj0057 Voir le message
    Merci ! Je suis en train de regarder tout celà mais juste une question :

    Que signifie cette ligne ?

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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.

    @+.

  19. #79
    Membre averti
    Homme Profil pro
    Étudiant
    Inscrit en
    Mai 2014
    Messages
    49
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mai 2014
    Messages : 49
    Par défaut
    La variable 'bloc' correspond à la taille du Pion ?
    Je ne vois pas du tout comment changer la taille des labyrinthes !

    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 .

  20. #80
    Invité
    Invité(e)
    Par défaut
    Citation Envoyé par Clemj0057 Voir le message
    La variable 'bloc' correspond à la taille du Pion ?
    Je ne vois pas du tout comment changer la taille des labyrinthes !
    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...

    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 .
    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.

    @+.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Besoin d'aide pour un projet de jeu en ligne
    Par FLEO dans le forum Projets
    Réponses: 1
    Dernier message: 21/10/2005, 08h55
  2. [MySQL] Aide à la création d'une requête
    Par tom06440 dans le forum Requêtes
    Réponses: 6
    Dernier message: 19/10/2005, 22h05
  3. Topic - La création d'un jeu avec opengl.
    Par AsmCode dans le forum OpenGL
    Réponses: 2
    Dernier message: 18/10/2005, 16h19
  4. Réponses: 19
    Dernier message: 15/03/2005, 09h05
  5. aide sur création d'un composant
    Par laetus dans le forum C++Builder
    Réponses: 2
    Dernier message: 14/07/2004, 10h45

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo