CHAPITRE 2

---

Créer une fenêtre graphique

Choisir et installer sa bibliothèque graphique

Notre objet Jeu n'a pas trop d'intérêt pour l'instant. Afficher un message à l'écran, même si ça peut s'avérer utile, ça ne va pas constituer la finalité d'un jeu passionnant.

Ce que nous souhaitons, c'est réaliser une application graphique. Nous voulons donc une méthode start qui, une fois lancée nous crée une fenêtre graphique.

Il nous faut une interface graphique. En général, ces interfaces mettent en place tout un ensemble d'objets, de méthodes qui ne font pas partie de l'interprète Python de base. Nous devons importer ce qu'on appelle un module ; on parle aussi de bibliothèque (attention à ne pas dire librairie qui vient d'une mauvaise traduction du terme anglais pour bibliothèque : library).

L'interface que nous allons utiliser dans le cadre de cette initiation est pygame. Le site officiel pygame.org renseigne sur la procédure à suivre pour l'installation du module. Si vous avez installé un interprète récent, vous devriez pouvoir installer très simplement via l'outil pip. La commande à taper devrait être (éventuellement en remplaçant pip3 par pip) :

pip3 install pygame

Ensuite, nous devons commencer notre programme par :

import pygame

Documentation

Le site offre une documentation, on en trouve une autre, mieux faite ici : devdocs.io/pygame/. Pour une documentation en français (mais il est bon de pratiquer l'anglais si on souhaite persévérer en Informatique et en programmation en particulier) il existe une version numérique payante aux éditions ENI

Un des objets Pygame est la Surface, nous l'étudirons plus en détail. Pour l'instant, nous allons créer une surface particulière, une sorte de fond qui servira de support à notre Jeu. Cette surface est créée par :

pygame.display.set_mode((une_largeur, une_hauteur))

Travailler avec des constantes

Les constantes sont des variables comme les autres, si ce n'est que les valeurs associées ne seront jamais modifiées. Afin de structurer son programme il peut être utile de regrouper l'ensemble de ses constantes dans un fichier à part, nommé par exemple constantes.py.

À faire vous-même

Créer un fichier constantes.py et mettez-y vos deux premières constantes :

LARGEUR = 600
HAUTEUR = 450

Si vous avez lu des cours parlant nommage et convention, vous savez que les identifiants des constantes sont en majuscules. Rappelons aussi :

• en MAJUSCULES, les constantes
• en snake_case le nom des fonctions et des méthodes : def ma_fonction_utile(...) (tout en minuscule, les différents mots séparés par des soulignés, underscore en anglais)
• en CamelCase pour le nom des classes : class MonSuperJeu: (chaque nouveau mot qui constitue le nom commence par une majuscule)

Nous utiliserons alors l'instruction suivante dans notre programme pour avoir accès à l'ensemble des constantes :

from constantes import *

Une première fenêtre

Nous allons complètement revoir notre objet Jeu. Il va devenir un vrai jeu.

Dans un premier temps, cet objet va embarquer une propriété ecran pour référencer notre fenêtre graphique et nous initialiserons l'ensemble des modules de la bibliothèque pygame (oui pygame est plus qu'un module) dans une méthode start.

À faire vous-même

ÉnoncéSolution

Dans un fichier snake_03.py,

1. Importer le module pygame ainsi que votre fichier de constantes

2. Définir une classe Jeu qui possède :

   • un initialiseur pour définir une proprité ecran référençant une surface display de pygame
   • une méthode start qui initiatilise tous les sous modules de pygame par un pygame.init()

3. Ajouter un programme principal qui crée une instance du jeu et lance la méthode start

import pygame
from constantes import *

class Jeu:

    def __init__(self):
        self.ecran = pygame.display.set_mode((LARGEUR, HAUTEUR))

    def start(self):
        pygame.init()

mon_jeu = Jeu()
mon_jeu.start()

Lorsque vous exécutez ce programme, tout est ok, si :

1. vous avez brièvement vu s'ouvrir et se refermer une fenêtre toute noire
2. ce message (aux valeurs de version près) est affiché sur votre console ou terminal :

   pygame 2.0.1 (SDL 2.0.14, Python 3.9.2)
   Hello from the pygame community. https://www.pygame.org/contribute.html

Garder cette fenêtre ouverte

Il serait intéressant de pouvoir garder cette fenêtre ouverte plus de 1s. Ce qui se passe pour le moment, c'est que le programme se lance, crée notre instance de Jeu, lance la méthode start de notre jeu ce qui crée la fenêtre graphique. Puis, comme on n'y fait rien de spécial, le programme se termine et détruit la fenêtre.

Pour garder la fenêtre ouverte, il faut empêcher le programme de se terminer si vite. Nous allons ajouter une méthode à notre Jeu. Son rôle : créer une boucle qui ne s'arrête que... si la partie est terminée. Tant que cette boucle s'exécute, la fenêtre reste ouverte (puisque le programme n'est pas fini). Quand on le décide, on met fin au programme et le module pygame détruit tous ses objets par l'instruction : pygame.quit().

Pour cela nous rajoutons une méthode loop à notre classe Jeu. Cette méthode va demander à l'utilisateur d'entrer une valeur (attention l'interaction va se dérouler dans une console texte qui n'a rien à voir avec la fenêtre graphique) :

class Jeu:
    ...
    def loop(self):
        fini = False
        while not fini:
            reponse = input('Tapez ce que vous voulez, puis entrée pour terminer')
            fini = True
        pygame.quit()

Mini quiz

ÉnoncéRéponses

À la ligne 4 que code ci-dessus, nous avons à faire à :

• Une équation
• Une instruction
• Une expression
• Une affectation

• Une équation (Ça c'est en maths )
• Une instruction
• Une expression (Non, une expression calcule une valeur : 2 + 3 ou x > 0)
• Une affectation

Les concepts

1. L'objet booléen
2. La notion de boucle non bornée while et aussi autre page qui pointe les difficultés didactiques de la boucle while
3. Les entrées / sorties, interactions (pages à faire ou trouver)

À faire vous-même

ÉnoncéSolution

Regroupez tout ce qu'on vient de voir dans un fichier snake_04.py. Sauvez et exécutez.

import pygame
from constantes import *

class Jeu:

    def __init__(self):
        self.ecran = pygame.display.set_mode((LARGEUR, HAUTEUR))

    def loop(self):
        fini = False
        while not fini:
            reponse = input('Tapez ce que vous voulez, puis entrée pour terminer')
            fini = True
        pygame.quit()

    def start(self):
        pygame.init()
        self.loop()

mon_jeu = Jeu()
mon_jeu.start()

Et nous avons notre première fenêtre graphique stable :

En général, dans une vraie application graphique, le programme est lancé et ensuite est à l'écoute des interactions de l'utilisateur : utilisation du clavier, clic ou mouvement de la souris, fermeture de la fenêtre en cliquant sur la petite croix rouge....

Toutes ces actions sont des événements (event en anglais) et le module pygame offre la possibilité de les gérer. C'est ce que nous allons voir dans le chapitre suivant.