Partage
  • Partager sur Facebook
  • Partager sur Twitter

[Exercice][Pygame] Mon beau menu

Venez vous entraîner !

    16 juillet 2012 à 23:03:00

    Bonjour à tous et à toutes !
    Bienvenu dans ce premier exercice des vacances d'été pour vous faire les dents avec Python et bien entendu sa librairie graphique de création de jeu 2D, que j'ai nommé Pygame.

    Dans ce premier exercice nous allons concevoir, notre tout premier menu de jeu qui réagira au pointeur de notre souris. Voici les Prérequis et les notions abordées:

    PREREQUIS
    • Python3 ou antérieur
    • Pygame 1.9

    NOTIONS ABORDEES
    • Listes, dictionnaires, Classes, héritage.
    • Légères notions sur Pygame: pygame.Font, pygame.draw_rect.

    Image utilisateur
    Voir l'image

    ---------------------------------------------------

    Déroulement du programme


    • Il faut à tout prie que ce soit un menu à la vertical, c'est à dire que les cellules composants le menu s'ajouteront les unes au dessous des autres.
    • Le menu doit réagir au clic gauche de la souris en exécutant une méthode passée en paramètre. (Si je clique sur telle cellule, telle méthode sera appelée)
    • Le menu doit réagir au pointeur de la souris lorsque celui-ci passe au dessus de l'une des cellules en la mettant en surbrillance. Pourquoi ne pas grossir la cellule tant que le pointeur de la souris est dessus d'elle ?


    Exemple: Soit le menu suivant:
    Jouer
    Pause
    Quitter


    Le pointeur de ma souris est dessus "Jouer", il est plus gros que les autres, si je clique dessus, la méthode correspondante associée à "Jouer" s'exécute.


    Restrictions:


    Pour rendre cet exercice plus sympathique il est formellement interdit d'utiliser une ou plusieurs images.

    Indications


    Vous n'êtes pas obligé de suivre ce qui suit, cependant je vous le recommande. Si votre programme est bien fait, vous pourrez le réutiliser dans vos jeux en 2D !
    L'utilisation de la POO est indispensable. Il faut créer deux classes, une classe <Conteneur> et une classe <Contenu>.
    La classe <Conteneur> aura pour rôle de gérer les objets <Contenu> en les ajoutant/supprimant et dessinant.
    La classe <Contenu> aura pour rôle de savoir quand le pointeur de la souris est dessus de lui ou vient de cliquer sur lui. Elle met régulièrement à jour ses attributs, comme les coordonnées de son pygame.Rect, son texte, la couleur du texte.

    Pensez a utiliser les pygame.Rect, utiles pour savoir si le pointeur entre en collision avec la cellule grâce à: Rect.collidepoint()

    Ressources


    Documentation de Pygame
    Documentation de Python
    Le tutoriel sur Python


    P.S: Mon code-source est déjà prêt. Volontairement je ne le poste pas tout de suite.
    • Partager sur Facebook
    • Partager sur Twitter
      16 juillet 2012 à 23:54:42

      j'ai quelque chose dans ce genre, mais ça répond pas exactement aux critères de l'exo ...

      http://www.pygame.org/project-slidemenu-1429-3938.html
      • Partager sur Facebook
      • Partager sur Twitter

      "il vaut mieux vivre en France qu'en Italie, la France a de plus jolies prisons"

        17 juillet 2012 à 12:21:39

        Un petit exemple d'utilisation de mon menu:

        from sys import exit
        from dico import *
        import pygame
        from pygame.locals import *
        
        TAILLE_BLOC = 20
        NB_BLOC_MAX = 30
        DIMENSION_ECRAN = TAILLE_BLOC * NB_BLOC_MAX
        
        
        def dire_bonjour():
            print("\n\nJe suis la fonction dire bonjour, donc bonjour")
        #-------------------------------------------------------------------------------
        #Initialisation de pygame
        #-------------------------------------------------------------------------------
        pygame.init()
        pygame.font.init()
        ecran = pygame.display.set_mode((DIMENSION_ECRAN, DIMENSION_ECRAN))
        pygame.display.set_caption("Un petit menu avec Pygame !")
        #-------------------------------------------------------------------------------
        #Variables
        #-------------------------------------------------------------------------------
        var_1, var_2, var_3, var_4 = "Menu", "Pause", "Quitter", "Autre"
        #-------------------------------------------------------------------------------
        #Importation et gestion des classes <Conteneur> <Contenu>
        #-------------------------------------------------------------------------------
        conteneur_1 = Conteneur(5) #On créer un menu avec 5 cellules au maximum
        conteneur_1.ajouter_contenu(var_1) 
        conteneur_1.ajouter_contenu(var_2)
        conteneur_1.ajouter_contenu(var_3)
        conteneur_1.ajouter_contenu(var_4)
        conteneur_1.supprimer_contenu(var_4)
        #
        conteneur_1[var_1].set_nom_methode_a_executer(dire_bonjour)
        conteneur_1[var_1].set_couleur((0,0,255)) 
        #On boucle chaque contenu pour draw le rect respectif en couleur + contour 
        conteneur_1.dessiner(ecran, DIMENSION_ECRAN//2, DIMENSION_ECRAN//2)  
        pygame.display.flip()  
        #-------------------------------------------------------------------------------
        #Boucle principale
        #-------------------------------------------------------------------------------
        continuer = True
        while continuer:
            event            = pygame.event.wait()
            mouse_x, mouse_y = pygame.mouse.get_pos()
            if event.type == pygame.QUIT:
                continuer = False
                break
        #-------------------------------------------------------------------------------
        #Suite de la boucle
        #-------------------------------------------------------------------------------
            #La méthode evenement_souris(mouse_x, mouse_y, event) permet de savoir
            #si chaque le pointeur de notre souris est ou clique sur une cellule.
            for i in conteneur_1.values(): #On donne l'évènement à nos contenus
                i.evenement_souris(mouse_x, mouse_y, event) 
        #-------------------------------------------------------------------------------
        #On redessine l'ecran
        #-------------------------------------------------------------------------------
            ecran.fill(0)
            conteneur_1.dessiner(ecran, DIMENSION_ECRAN//2, DIMENSION_ECRAN//2)
            pygame.display.flip()
        #-------------------------------------------------------------------------------
        #Que faire si l'on sort de la boucle
        #-------------------------------------------------------------------------------
        print("\nAu revoir, vous quittez le programme...")
        pygame.quit()
        exit(0)
        



        N'hésitez pas à poser vos questions ici, tant sur le plan technique que théorique.
        Enjoy !

        P.S: Josmiley, pourquoi ne pas recréer un menu suivant la norme de l'exercice :) ?
        • Partager sur Facebook
        • Partager sur Twitter
          17 juillet 2012 à 22:51:15

          ce type de fonctionnement je n'appelle pas ça "menu", mais plutôt "boutons".
          je pense qu'un menu ne devrait pas exécuter quelque chose mais plutôt retourner un choix ... non? Ce qui le rendrait plus facilement "imbricable".



          d'ailleur ...
          for i in conteneur_1.values(): #On donne l'évènement à nos contenus
                  i.evenement_souris(mouse_x, mouse_y, event)
          

          montre bien qu'on update des boutons et non un menu; du coup, où est l'intérêt d'avoir un conteneur?
          passer en argument la position de la souris ne me parait pas simple pour l'user; je pense que c'est au bouton lui-même qu'il revient d'aller chercher cette info. Avec un simple conteneur_1.update(event) où l'objet conteneur distribue lui-même l'event aux boutons qu'il contient.

          conteneur.evenement_souris() devrait retourner quelque chose, comme True, s'il se passe quelque chose, car en l'état actuel du code, l'écran est redessiné même s'il ne se passe rien et l'optimisation voudrait qu'il le soit seulement s'il se passe quelque chose ...

          while True:
              ev = event.wait()
              if ev.type == QUIT: break
              elif conteneur_1.update(ev): redessiner_ecran()
          



          • Partager sur Facebook
          • Partager sur Twitter

          "il vaut mieux vivre en France qu'en Italie, la France a de plus jolies prisons"

          Anonyme
            18 juillet 2012 à 10:06:16

            J'ai pas compris ces phrases

            Citation : realmagma

            L'utilisation de la POO est indispensable. Il faut créer deux classes, une classe <Conteneur> et une classe <Contenu>.
            La classe <Conteneur> aura pour rôle de gérer les objets <Contenu> en les ajoutant/supprimant et dessinant.
            La classe <Contenu> aura pour rôle de savoir quand le pointeur de la souris est dessus de lui ou vient de cliquer sur lui. Elle met régulièrement à jour ses attributs, comme les coordonnées de son pygame.Rect, son texte, la couleur du texte.



            Pourquoi faire 2 classes, c'est compliqué.

            Mon menu, je peux le créer à l'aide d'une classe Menu, dont les arguments sont les noms Jouer, Pause et Quitter.

            class Menu():
                def __init__(self, *args):
                    # Suite du code
            
            mon_menu = Menu("Jouer", "Pause", "Quitter")
            


            • Partager sur Facebook
            • Partager sur Twitter
              18 juillet 2012 à 11:27:28

              Citation : fred1599

              J'ai pas compris ces phrases

              Citation : realmagma

              L'utilisation de la POO est indispensable. Il faut créer deux classes, une classe <Conteneur> et une classe <Contenu>.
              La classe <Conteneur> aura pour rôle de gérer les objets <Contenu> en les ajoutant/supprimant et dessinant.
              La classe <Contenu> aura pour rôle de savoir quand le pointeur de la souris est dessus de lui ou vient de cliquer sur lui. Elle met régulièrement à jour ses attributs, comme les coordonnées de son pygame.Rect, son texte, la couleur du texte.



              Pourquoi faire 2 classes, c'est compliqué.

              Mon menu, je peux le créer à l'aide d'une classe Menu, dont les arguments sont les noms Jouer, Pause et Quitter.

              class Menu():
                  def __init__(self, *args):
                      # Suite du code
              
              mon_menu = Menu("Jouer", "Pause", "Quitter")
              






              disons que la class Button devrait être transparente pour l'user:

              class Menu():
              
                  class Button():
                      def __init__(self,*args):
                          # stuff
              
                  def __init__(self,*args):
                      # creation des boutons
              
              
              mon_menu = Menu("Jouer", "Pause", "Quitter")
              
              • Partager sur Facebook
              • Partager sur Twitter

              "il vaut mieux vivre en France qu'en Italie, la France a de plus jolies prisons"

                18 juillet 2012 à 12:49:58

                Bonjour, tout d'abord merci pour vos réponses. Le but de cet exercice est de s'entraîner, cela vaut aussi pour moi !

                josmiley: Les remarques de ton post d'hier sont pertinentes. En effet, je me suis rapidement rendu compte qu'utiliser la fonction (citée juste en dessous) ... n'était pas très pratique pour l'user.
                Je vais essayer de corriger tout ça.

                for i in conteneur_1.values(): #On donne l'évènement à nos contenus
                        i.evenement_souris(mouse_x, mouse_y, event)
                

                Il est vrai que le code n'est pas optimisé, d'où le présent exercice ; pour arriver à un résultat correct. (Cela vaut aussi pour ceux qui veulent s'y mettre, c'est un bon entraînement !)

                Fred1599: Je me suis beaucoup inspiré de PyQt, tu sais le QGridLayout.

                En fait <Conteneur> est un objet conteneur ( :p ) qui gère ses objets <Contenu>. C'est à dire que l'on ne peut pas par exemple faire n'importe quoi avec les objets de <Contenu>
                Cela instaure une sorte d'abstraction qui facilite la mise en place des contenus via l'objet <Conteneur>.
                ... En tout cas c'est comme ça que je vois les choses. Il est possible que j'ai tort.

                D'après vous, est-ce une solution viable ?
                Dans quelle mesure ?


                Josmiley: Effectivement, c'est également une question de transparence.


                Voila où j'en étais: Attention je n'ai pas encore pris en compte vos remarques, je n'ai pas touché au code-source.
                Il y a quelques fonctionnalités qui ne sont pas encore implémentées, d'autres qui sont là pour certains testes.
                #!/usr/bin/python3.2
                # -*- coding: utf-8 -*-
                
                #===============================================================================
                #Titre      u        : 
                #Nom  fichier        : 
                #Auteur              : realmagma
                #Dernière mise à jour: 16/07/2012
                #-------------------------------------------------------------------------------
                #
                #-------------------------------------------------------------------------------
                #Rôle du fichier: Un menu mêlant pygame_draw_rect et pygame_ttf.
                #
                #===============================================================================
                
                from sys import exit
                from dico import *
                import pygame
                from pygame.locals import *
                
                TAILLE_BLOC = 20
                NB_BLOC_MAX = 30
                DIMENSION_ECRAN = TAILLE_BLOC * NB_BLOC_MAX
                
                
                #-------------------------------------------------------------------------------
                #Pour essai. Supprimer la fonction dire_bonjour()
                #-------------------------------------------------------------------------------
                def dire_bonjour():
                    print("\n\nJe suis la fonction direbonjour, donc bonjour")
                #-------------------------------------------------------------------------------
                #Fin essai
                #-------------------------------------------------------------------------------
                
                class Conteneur(DictionnaireOrdonne):
                    """- Un conteneur de type DictionnaireOrdonne pour des <Contenu>."""
                    def __init__(self, nombre_max_contenus):
                        DictionnaireOrdonne.__init__(self)
                        self.nombre_max_contenus = nombre_max_contenus
                        self.nombre_contenus     = 0
                        self.myFont  = pygame.font.Font(None, 40) 
                        
                    def __del__(self):
                        """On supprime à la chaîne tous les <Contenu> de notre objet dico"""
                        for i in self:
                            del(i)
                               
                    def ajouter_contenu(self, titre = "Vide", couleur = (255,0,0)):
                        """
                        - Instancie un objet de la classe <Contenu> et l'ajoute en tant que val-
                        eur à notre DictionnaireOrdonne.
                        """
                        self[titre] = Contenu(self, titre, couleur)
                        self.nombre_contenus += 1
                        
                    def supprimer_contenu(self, titre):
                        """
                        - Supprime un objet de la classe <Contenu> suivant sa valeur (qui est 
                        sous forme de chaîne de caratctères).
                        """
                        try:
                            self.pop(titre)
                        except IndexError:
                            print("\nImpossible de supprimer l'élément contenu dans <Conteur>"
                                  "Le nom (sous forme de chaîne) de la clef est inconnu")
                        else:
                            self.nombre_contenus -= 1
                            continuer = False
                            
                    def dessiner(self, ecran, x, y):
                        """
                        - Dessine en bouclant tous les contenus (valeurs du dictionnaire) par 
                        des pygame.draw.rect sur la surface donnée en paramètre. La position
                        du centre du premier rect est passée en paramètre. Les autres la suive.
                        """
                        for n, i in enumerate(self.values()):
                            i.rect.center = x, (y + n*(i.rect[3]))
                            #pygame.draw.rect(ecran, i.couleur, i.rect)
                            #pygame.draw.rect(ecran, (255,255,255), i.rect, 2)
                            ecran.blit(i.surface_font, i.rect)
                            
                        
                        
                class Contenu():
                    """
                    - Un contenu instancié uniquement par son parent, la classe <Conteneur>.
                    """
                    def __init__(self, parent, titre, couleur):
                        self.parent  = parent
                        self.titre   = titre
                        self.couleur = couleur
                        
                        self.nom_methode_a_executer = None
                        self.rect                   = pygame.Rect(0, 0, 200, 30)
                        self.surface_font = self.parent.myFont.render(self.titre, 2, (0,255,0))
                        
                    def evenement_souris(self, mouse_x, mouse_y, event = None):
                        """
                        - Traite uniquement les évènements avec la souris: (clique, contact...)
                        """
                        if event != None:
                            #Deplacement de la souris SUR le conteneur: Le met en surbrillance
                            if event.type == pygame.MOUSEMOTION:
                                if self.rect.collidepoint(mouse_x, mouse_y):
                                    #On créer un autre objet pygame.font pour récupérer
                                    #sa surface dans self.surface.font
                                    f = pygame.font.Font(None, 50)
                                    self.surface_font = f.render(self.titre, 2, (0,255,0))
                                    print("Collision souris et rect {0}".format(self.titre))
                                else:
                                    #Si il n'y a aucune collision souris/rect on laisse la
                                    #taille de self.surface.font comme au départ dans son parent
                                    self.surface_font = self.parent.myFont.render(self.titre,\
                                                                                  2, (0,255,0))
                            #Clique de la souris SUR le conteneur: Exécute la méthode action()
                            elif event.type == pygame.MOUSEBUTTONDOWN:
                                if self.rect.collidepoint(mouse_x, mouse_y):
                                    self.action()
                    
                    def action(self):
                        """- Exécute la méthode de la variable self.nom_methode_a_executer."""
                        try:
                            self.nom_methode_a_executer()
                        except TypeError:
                            print("\nVeuillez utiliser la méthode set_nom_methode_a_executer() "
                                  "pour associer une méthode à action()")
                    
                    def set_nom_methode_a_executer(self, nom_methode):
                        """
                        - Permet d'attribuer une méthode à la variable 
                        self.nom_methode_a_executer. 
                        """
                        self.nom_methode_a_executer = nom_methode
                    
                    def set_couleur(self, couleur):
                        """Définit une nouvelle couleur de fond en RGB"""
                        self.couleur = couleur
                


                Bonne fin de journée,
                Realmagma.
                • Partager sur Facebook
                • Partager sur Twitter
                Anonyme
                  18 juillet 2012 à 13:54:46

                  Je comprend pas trop l'histoire des boutons, sans doute par manque d'intérêt sur cette lib (pygame), mais bon pour m'amuser j'ai tenter de sortir un code à l'aide de la doc.

                  Il me manque la détection de la position de la souris sur un objet Font

                  Voilà un début de code.

                  # -*- coding:utf8 -*-
                  
                  import pygame
                  import sys
                  from pygame.locals import *
                  from pygame.font import Font
                  
                  class Menu():
                  
                      def __init__(self, ttf, color, *args):
                          self.color = color
                          self.ttf = ttf
                          SIZE = (600, 400)
                          FONT = Font(self.ttf, 32)
                          self.font_text = [FONT.render(chaine, True, self.color) for chaine in args]
                          self.screen = pygame.display.set_mode(SIZE)
                          pygame.display.set_caption('Menu de fred1599')
                          self.fill((250, 250, 250))
                          self.display()
                          self.blit()
                          
                      def fill(self, color):
                          self.background = pygame.Surface(self.screen.get_size())
                          self.background = self.background.convert()
                          self.background.fill(color)
                  
                      def display(self):
                          y = 50
                          for text in self.font_text:
                              x=self.background.get_width()/2
                              y += 50
                              textpos = text.get_rect(centerx=x, centery=y)
                              self.background.blit(text, textpos)
                  
                      def blit(self):
                          self.screen.blit(self.background, (0, 0))
                          pygame.display.flip()
                      
                      def detect(self):
                          """Fonction permettant de détecter la position de la souris
                          et modifiera la taille de l'objet Font"""
                          # à compléter
                          
                  
                  pygame.init()
                  pygame.font.init()
                  
                  while 1:
                      for event in pygame.event.get():
                          if event.type == pygame.QUIT:
                              sys.exit()
                      mon_menu = Menu(None, (145, 200, 150), "Menu", "Quitter", "Jouer")
                  
                  • Partager sur Facebook
                  • Partager sur Twitter
                    19 juillet 2012 à 8:19:10

                    @fred1599:
                    un bouton c'est un objet graphique cliquable en général; en fait c'est moi qui n'a pas été clair car pour le code de realmagma je désigne par "bouton" les objets graphiques cliquables qui appellent une fonction.

                    dans ton code, l'initialisation de la fenêtre ne devrait pas être incluse dans la class ...

                    @realmagma:
                    le menu doit-il forcement être non-bloquant? je ne parviens pas à situer quel genre de menu tu attends ...
                    soit c'est bloquant et on attend une réponse de l'user, au quel cas menu devrait être une simple fonction amha
                    soit c'est non-bloquant et en général c'est inclus dans l'interface, genre le menubar(fichier édition affichage etc ...), plus difficile à gérer, surtout si le background change, la menu devra être géré comme un sprite.

                    sinon, ton code n'est pas réutilisable car "ecran" n'est pas une variable de la class Conteneur.
                    • Partager sur Facebook
                    • Partager sur Twitter

                    "il vaut mieux vivre en France qu'en Italie, la France a de plus jolies prisons"

                      20 juillet 2012 à 12:29:40

                      Josmiley: Pour l'instant c'est un menu bloquant (Pour le menu non bloquant on y reviendra un peu plus tard :) )
                      En faite, j'ai développé mon code-source dans l'optique dans faire une bibliothèque de menu pour Pygame. C'est à dire un code assez générique (pas trop lourd non plus) pour l'adapté dans n'importe quel jeu vidéo que l'on créera par la suite.


                      Citation : josmiley

                      soit c'est bloquant et on attend une réponse de l'user, au quel cas menu devrait être une simple fonction


                      Non parce que l'on sort de notre objectif, une bibliothèque. Le menu doit pouvoir changé suivant ce que souhaite l'user, par des options modifiables (changement de la couleur du texte, son emplacement, ...) .
                      Une vulgaire fonction ne serait pas suffisante et pas très élégante. Dans ce cas là, la POO est super appropriée.


                      Citation : josmiley

                      sinon, ton code n'est pas réutilisable car "ecran" n'est pas une variable de la classe Conteneur.


                      Je ne vois pas en quoi mon code n'est pas réutilisable :o .
                      La variable ecran est envoyé par l'user. <Conteneur> reçoit cette surface et fait ce qu'il a faire dessus.


                      J'ai modifié quelques méthodes, malheureusement mon code est devenu un peu dégueulasse...
                      Dans ma classe <Conteneur> j'ai ajouté cette méthode:
                      def update(self, event):
                              """
                              Gère les évènements reçus et retourne True ou False en conséquence.
                              ENTREE
                              - event: Evènement Pygame
                              SORTIE
                              - True si un évènement doit modifier l'écran sinon False
                              """
                              for i in self.values():
                                  if i.evenement_souris(event):
                                      return True
                              return False
                      


                      Voici ma classe <Contenu> que j'ai modifié:
                      class Contenu():
                          """
                          - Un contenu instancié uniquement par son parent, la classe <Conteneur>.
                          """
                          def __init__(self, parent, titre, couleur):
                              self.parent  = parent
                              self.titre   = titre
                              self.couleur = couleur
                              
                              self.nom_methode_a_executer = None
                              self.rect                   = pygame.Rect(0, 0, 200, 30)
                              self.surface_font = self.parent.myFont.render(self.titre, 2,\
                                                                            self.couleur)
                              self.curseur_in = False
                              
                          def evenement_souris(self, event = None):
                              """
                              - Traite uniquement les évènements avec la souris: (clique, contact...)
                              """
                              mouse_x, mouse_y = pygame.mouse.get_pos()
                              if event != None:
                                  #Deplacement de la souris SUR le conteneur: Le met en surbrillance
                                  if event.type == pygame.MOUSEMOTION:
                                      if self.rect.collidepoint(mouse_x, mouse_y):
                                          self.set_surbrillance(True)
                                          self.curseur_in = True
                                          print("Collision souris et rect {0}".format(self.titre))
                                          return True
                                      else:
                                          if self.curseur_in:
                                              self.set_surbrillance(False)
                                              self.curseur_in = False
                                              return True
                                          return False
                                  #Clique de la souris SUR le conteneur: Exécute la méthode action()
                                  elif event.type == pygame.MOUSEBUTTONDOWN:
                                      if self.rect.collidepoint(mouse_x, mouse_y):
                                          self.action()
                                          return True
                                      else:
                                          return False
                                  return False
                          
                          def set_surbrillance(self, booleen):
                              """
                              Met en surbrillance le texte suivant le paramètre en entrée.
                              ENTREE
                              - booleen: True ou False.
                              """
                              if booleen:
                                  f = pygame.font.Font(None, 50)
                                  self.surface_font = f.render(self.titre, 2, self.couleur)
                              else:
                                  self.surface_font = self.parent.myFont.render(self.titre,\
                                                                                2, self.couleur)
                              
                          def action(self):
                              """- Exécute la méthode de la variable self.nom_methode_a_executer."""
                              try:
                                  self.nom_methode_a_executer()
                              except TypeError:
                                  print("\nVeuillez utiliser la méthode set_nom_methode_a_executer() "
                                        "pour associer une méthode à action()")
                          
                          def set_nom_methode_a_executer(self, nom_methode):
                              """
                              - Permet d'attribuer une méthode à la variable 
                              self.nom_methode_a_executer. 
                              """
                              self.nom_methode_a_executer = nom_methode
                      



                      Bonne journée,
                      Realmagma.
                      • Partager sur Facebook
                      • Partager sur Twitter
                        20 juillet 2012 à 12:58:39

                        Citation : realmagma


                        Citation : josmiley

                        soit c'est bloquant et on attend une réponse de l'user, au quel cas menu devrait être une simple fonction


                        Non parce que l'on sort de notre objectif, une bibliothèque. Le menu doit pouvoir changé suivant ce que souhaite l'user, par des options modifiables (changement de la couleur du texte, son emplacement, ...) .
                        Une vulgaire fonction ne serait pas suffisante et pas très élégante. Dans ce cas là, la POO est super appropriée.



                        oké je vois, en fait tu nous emmènes à faire un menu contextuel ...
                        un peu dans ce style: http://www.pygame.org/project-MenuSystem-2031-.html


                        Citation : realmagma


                        Citation : josmiley

                        sinon, ton code n'est pas réutilisable car "ecran" n'est pas une variable de la classe Conteneur.


                        Je ne vois pas en quoi mon code n'est pas réutilisable :o .
                        La variable ecran est envoyé par l'user. <Conteneur> reçoit cette surface et fait ce qu'il a faire dessus.



                        effectivement j'avais mal lu, autant pour moi ...
                        • Partager sur Facebook
                        • Partager sur Twitter

                        "il vaut mieux vivre en France qu'en Italie, la France a de plus jolies prisons"

                          24 juillet 2012 à 23:36:35

                          realmagma:
                          j'ai modifier un code que j'avais fait il y à quelques temps.
                          ça correspond pas exactement à ce que tu demandes, cliquer un bouton ne déclenche pas d'action, mais si tu regardes l'exemple MonBeauMenu.py, tu y verras l'histoire de conteneur/contenu ...

                          http://joel-murielle.perso.sfr.fr/MenuSystem.zip
                          • Partager sur Facebook
                          • Partager sur Twitter

                          "il vaut mieux vivre en France qu'en Italie, la France a de plus jolies prisons"

                          [Exercice][Pygame] Mon beau menu

                          × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                          × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                          • Editeur
                          • Markdown