====== Ouverture d'une fenêtre Pygame ======
// par Izawenn //
===== près requis =====
Avant de commencer, assurez vous d'avoir [[ateliers:pygamelab:installation|installer pygame]]
===== Ouvrir une fenêtre =====
Dans un premier temps, je dois importer dans python, la bibliothèque pygame.

     import pygame

Ensuite, complète le reste du code dans le main()

     def main():

A l'intérieur du main(), je vais commencé par initialiser pygame.

    pygame.init()

Ensuite, je défini la longueur et la largeur de la fenêtre dans une variable que je nomme taille_ecran
Et j'affiche un écran de la longueur et de la largeur que je viens de définir précédemment.

    taille_ecran = (800, 600)
    ecran = pygame.display.set_mode(taille_ecran)

Maintenant, je peux quitter pygame.

    pygame.quit()

Et lancer le main()

     if __name__ == "__main__":
         main() 


Voici le code complet de cette première partie:

     import pygame
     
     def main():
         pygame.init()
         
         taille_ecran = (800, 600)
         ecran = pygame.display.set_mode(taille_ecran)
         
         pygame.quit()
         
     if __name__ == "__main__":
         main() 
         
Si je l'exécute j'arrive à ouvrir une fenêtre. Mais seulement pendant environs un dixième de seconde avant la fin du script.

===== Maintenir la fenêtre =====

Pour maintenir la fenêtre, il va falloir que je crée une [[ateliers:initiationpython:boucles|boucle]].
Comme je ne sais exactement à quel moment je jeux va s'arrêter, je vais choisir une boucle "while" 
Seulement voila, lorsque l'on utilise une boucle "while", il doit y avoir une condition pour l'arrêter.
Dans le cas présent, nous allons dire que lorsque je clique sur la croix de la fenêtre(et oui même ça, ça ne ce fait pas tout seul). cela arrête la boucle. Ce qui amène à la fermeture de la fenêtre comme nous l'avons vu tout à l'heure.
Pour cela nous allons crée une variable qui prendra la valeur "True" par défaut, et qui prendra la valeur "False" lorsqu'une condition d'arrêt est rempli.

Pour des raisons de facilité nous allons temporairement programmer la touche "Echap" pour arrêter la boucle. Parfois l'utilisation d'une touche est plus simple lorsque l'on est amener à faire des tests souvent.

C'est parti :

Je déclare la variable qui me permet qui me permet de maintenir la boucle.
     jeu_en_cours = True

Ensuite on crée la boucle while :
     while jeu_en_cours:

Donc tant que la variable jeu_en_cours sera vrai, la boucle maintiendra la fenêtre ouverte.

Maintenant il vaut définir les conditions d'arrêt
     for event in pygame.event.get(): 
            if event.type == pygame.QUIT:
                jeu_en_cours = False
Donc si l'on clique sur la petite croix de la fenêtre, la variable jeu_en_cours devient fausse, et la boucle s'arrête.
     if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    jeu_en_cours = False
Si l'on appuis sur la touche échap, la variable jeu_en_cours devient également fausse, et la fenêtre se ferme de la même façon.

Avec le code complet, voila ce que ça donne :

     import pygame
     
     def main():
         pygame.init()
    
         taille_ecran = (800, 600)
         ecran = pygame.display.set_mode(taille_ecran)
     
         jeu_en_cours = True
     
         while jeu_en_cours :
      
             for event in pygame.event.get():
                  if event.type == pygame.QUIT:
                       jeu_en_cours = False
        
                  if event.type == pygame.KEYDOWN:
                       if event.key == pygame.K_ESCAPE:
                            jeu_en_cours = False
        
         pygame.quit()
     
    if __name__ == "__main__":
         main() 

===== Framerate =====
Bon la nous venons de crée une boucle while qui fait tourner le script "à fond la caisse", c'est à dire autant de fois qu'il le peut.
C'est totalement inutile pour nous, ça gâche des ressources de calcul pour rien. En fait, il nous suffit d'avoir  30 ou 60 boucles par seconde.
Il va donc nous falloir ralentir un peu notre boucle while.

Il existe plusieurs façon de le faire, mais pygame propose une solution toute faite.

D'abord je vais crée une constante qui va contenir le nombre de boucle par seconde que je souhaite. Soit 30, soit 60 boucles par seconde.
     FRAMERATE = 30

Dans le main() avant la boucle while, il faut initialiser le framerate:
     horloge_framerate = pygame.time.Clock()

Vers la fin de la boucle, demande à pygame d'attendre un peu avant la boucle suivante
     horloge_framerate.tick(FRAMERATE)

Voila ce que cela donne avec le code complet
     import pygame
    
     FRAMERATE = 30
    
     def main():
          pygame.init()
     
          taille_ecran = (800, 600)
          ecran = pygame.display.set_mode(taille_ecran)
     
          jeu_en_cours = True
     
          horloge_framerate = pygame.time.Clock()
     
          while jeu_en_cours :
      
             for event in pygame.event.get():
                 if event.type == pygame.QUIT:
                     jeu_en_cours = False
     
                 if event.type == pygame.KEYDOWN:
                     if event.key == pygame.K_ESCAPE:
                         jeu_en_cours = False
     
             horloge_framerate.tick(FRAMERATE)
             
         pygame.quit()
     
     if __name__ == "__main__":
         main()


{{:ateliers:pygamelab:ouverture_fenetre.gif?600}}