PyGame – créer des jeux facilement avec Python

PyGame est une bibliothèque Python conviviale et facile à comprendre qui vous permet de développer des jeux 2D. PyGame a été créé en utilisant la bibliothèque du langage C, Simple DirectMedia Layer (SDL). En fait SDK simplifie la portabilité des jeux d’une plateforme à une autre.

La bibliothèque PyGame se compose de nombreux composants Python, y compris de nombreux modules. En fait, ces modules permettent d’accéder aux matériels du jeu et du système.

Afin de pouvoir suivre cette série de tutoriels Pygame, il faut que vous soyez à l’aise avec les bases du langage Python.

Il faut également savoir que ces tutoriels sont destinés aux débutants qui veulent approfondir leurs connaissances en Python. Nous n’allons pas créer des jeux 3D professionnels, mais vous allez apprendre la logique derrière la création des jeux. Ce qui représentera un grand pas vers d’autres horizons. De plus, vous serez capable de créer un jeu simple et essayer de faire des choses amusantes.

Bref, vous allez apprendre tout en s’amusant !

Installer la bibliothèque PyGame

Je suppose que vous savez comment créer un environnement virtuel. Si vous utilisez Pycharm (que j’utilise également), il sera créé automatiquement avec chaque projet. Ouvrez l’invite de commande ou le terminal et tapez la commande ci-dessous. En fait, Pycharm vous permet de travailler avec le terminal, tout en bas, cliquez sur la fenêtré terminal (sous linux). Sinon utilisez la méthode habituelle pour installer un module dans Pycharm.

pip install pygame

Exécutez le code suivant pour confirmer l’installation.

python3 -m pygame.examples.aliens

Le package PyGame dispose de plusieurs modules qui peuvent être utilisés indépendamment. Il existe un module pour chaque instrument que vous pouvez utiliser dans un jeu, ainsi que d’autres pour faciliter la création de jeux.
Nous accédons à ces modules via l’espace de noms PyGame, par exemple, pygame.display fait référence au module d’affichage.

Certains modules sont nécessaires pour chaque jeu. Vous aurez toujours besoin d’un affichage, donc vous utiliserez le module display. De plus, vous aurez certainement besoin d’une sorte d’entrée, que ce soit un clavier ou une souris. D’autres modules sont moins utilisés, mais combinés, ils vous offrent des outils puissants pour créer des jeux.

Créer une fenêtre de jeu avec PyGame

La première chose à faire est d’importer la bibliothèque PyGame et de créer une fenêtre de jeu.

import pygame

pygame.init()
screen = pygame.display.set_mode((640, 455))

run = True
while run:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                run = False

        pygame.display.update()

pygame.quit()
quit()

Une fois que vous exécutez le code ci-dessus, vous obtiendrez votre fenêtre de jeu. Expliquons le code ci dessus.

pygame.init(): initialise les sous-modules du package PyGame. En l’appelant, nous avons toute la puissance de PyGame à notre disposition.
screen = pygame.display.set_mode((640, 455)): renvoie un objet de la classe Surface représentant la fenêtre.
Puis, nous définissons la résolution de notre jeu, d’une largeur de 640 px et d’une hauteur de 455 px.
pygame.event.get() : puisque le jeu sera une série d’événements, cette syntaxe vous aidera à vider la file d’attente.
pygame.QUIT : l’événement qui déclenche la sortie du programme.
pygame.display.update () : pour rendre visible les mises à jour du jeu à l’écran.

En fait, la boucle while sert à contrôler la fin du programme. De plus, la boucle for analysent et gèrent les événements à l’intérieur de la boucle du jeu while. Notre événement ici est pygame.QUIT, lorsque l’utilisateur clique sur le bouton de fermeture de la fenêtre.

pygame.quit() : quitter Pygame, c’est en quelque sorte l’opposé de la fonction pygame.init().
quit() : quitter Python.

Ajouter un titre et une image d’arrière plan

Voici le code pour ajouter un titre.

pygame.display.set_caption("Créer un jeu avec PyGame")

La variable background_image stockera l’image d’arrière plan « ciel.jpg ».

background = pygame.image.load(background_image).convert() : la fonction pygame.image.load télécharge l’image d’arrière plan à partir de notre disque. Quant à la fonction convert(), qui est membre de l’objet Surface, elle convertit l’image au même format que notre affichage.
La méthode background.blit() dessine l’image avec des coordonnées initiales.

PyGame

Maintenant, nous allons dessiner un petit cercle avec une position (140, 60), une couleur RGB (250, 250, 0) pour le jaune et un rayon de 30. Ce qui correspond à la ligne de code pygame.draw.circle(background, (250, 250, 0), (140, 60), 30).

background_image = "ciel.jpg"

import pygame

pygame.init()
screen = pygame.display.set_mode((640, 455))

pygame.display.set_caption("Créer un jeu avec PyGame")
background = pygame.image.load(background_image).convert()

run = True
while run:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                run = False

        pygame.draw.circle(background, (250, 250, 0), (140, 60), 30)
        screen.blit(background, (0, 0))

        pygame.display.update()

pygame.quit()
quit()

La boucle principale du programme

Une boucle de jeu (également appelée boucle principale) est une boucle dans laquelle le code fait trois choses :

  • Gère les événements.
  • Met à jour l’état du jeu.
  • Redessine l’écran.

En général, l’état du jeu est mis à jour en réponse à des événements (tels que des clics de souris ou des pressions de clavier) ou le passage du temps. Donc la boucle de jeu vérifie et revérifie constamment plusieurs fois par seconde tout nouvel événement qui s’est produit. Tous les jeux ont une boucle similaire à celle-ci, qui se répète généralement une fois par actualisation de l’écran.

À l’intérieur de la boucle principale, nous avons une autre boucle, la boucle d’événements, qui examine quels événements ont été créés. En fait dans PyGame, cela se fait en appelant la fonction pygame.event.get().

En outre, la boucle principale contient un code qui met à jour l’état du jeu en fonction des événements créés. C’est ce qu’on appelle généralement la gestion des événements.

La fonction get() dans le module pygame.event renvoie tous les événements en attente, que nous parcourons ensuite dans une boucle for.

En réalité, l’événement QUIT est généré lorsque l’utilisateur clique sur le bouton de fermeture de la fenêtre PyGame. Ainsi, si le type d’événement est QUIT, nous sortons du jeu et tous les autres événements seront ignorés.

La fonction blit(), affiche l’image de fond sur l’écran (techniquement parlé, blit signifie copier d’une image à une autre). Donc, la fonction prend une image source (l’arrière-plan) et la met sur la surface existante avec une position de destination (0, 0).
L’arrière-plan couvre toute la fenêtre, donc nous fixons l’image aux coordonnées (0, 0), qui est en haut à gauche de l’écran.

L’instruction pygame.display.update() met à jour l’affichage à l’écran. Sans cet appel, rien n’apparaît dans la fenêtre.

Puis, Pygame.quit() met fin à l’initialisation de la bibliothèque.

Les événements dans Pygame

PyGame crée des événements comme les mouvements de la souris et les pressions sur les touches du clavier.

Comme vous ne pouvez pas réagir aux événements au moment où ils se produisent, PyGame les stocke dans une file d’attente jusqu’à ce que vous soyez prêt à les gérer. À chaque événement, on a une information sur le bouton qui a été utilisé. Donc, nous avons plusieurs événements qui se succèdent et qu’il faut gérer, c’est ce que fait l’instruction pygame.event.get().

Sachez que la file d’attente des événements est limitée en taille et les événements seront perdus en cas de débordement.
D’où la nécessaire à appeler au moins une des fonctions de gestion des événements à intervalles réguliers afin que le programme puisse traiter les événements en interne.

La seule chose commune entre les objets événement est le type, c’est une valeur qui indique le type de l’événement. C’est cette valeur que vous interrogez d’abord afin que vous puissiez décider quoi en faire.

La réaction aux événements est requise pour toutes les applications et les jeux interactifs. Les événements sont les situations qui peuvent se produire dans un programme, telles que :

  • un clic de souris
  • un mouvement de la souris
  • presser une touche clavier

Tableau des événements

Voici un tableau des événements :

ÉvénementParamètres
QUITnone
ACTIVEEVENTgain, state
KEYDOWNkey, mod, unicode, scancode
KEYUPkey, mod
MOUSEMOTION pos, rel, buttons
MOUSEBUTTONUP pos, button
MOUSEBUTTONDOWN pos, button
JOYAXISMOTION joy (obsolète), instance_id, axis, value
JOYBALLMOTION joy (obsolète), instance_id, ball, rel
JOYHATMOTION joy (obsolète), instance_id, hat, value
JOYBUTTONUP joy (obsolète), instance_id, button
JOYBUTTONDOWN joy (obsolète), instance_id, button
VIDEORESIZE size, w, h
VIDEOEXPOSE none
USEREVENT code

Chaque événement du tableau correspond à une manipulation effectuée par l’utilisateur.

Ajoutez cette instruction print(event) après le bloc de code if, puis exécutez votre programme. Déplacez la souris à l’intérieur de la fenêtre ou appuyez sur une touche du clavier pour voir le message qui s’affiche. Appuyez sur les boutons de la souris, utilisez la molette de la souris, chaque action correspond à un événement, qui sera affiché dans la console.

La boucle principale doit surveiller les activités de l’utilisateur (appelées événements) et répondre à ces événements. Par conséquent, le code de gestion des événements sera dans la boucle principale.

Les événements de la souris

Ces événements spécifient la position actuelle de la souris, la distance parcourue par la souris depuis le dernier événement de mouvement et les boutons actuellement enfoncés.

En général, pour un curseur de souris, il vous suffit de savoir où est la souris au début de chaque image. Par conséquent, on utilise pygame.mouse.get_pos(). Cette fonction renvoie la position du curseur (x, y) de la souris par rapport au coin supérieur gauche de l’affichage.

Pygame.key.get.pressed() : renvoie une valeur booléenne représentant l’état des boutons de la souris. Une valeur True signifie que le bouton de la souris est enfoncé au moment de l’appel de la fonction.

Pygame.event.wait() : la fonction renvoie l’événement en cours dans la file d’attente. S’il n’y a aucun message en attente dans la file d’attente, celui-ci ne sera renvoyé qu’une fois disponible. Pour obtenir tous les événements de la souris (MOUSEBUTTONDOWN, MOUSEBUTTONUP, MOUSEMOTION), vous devez utiliser la fonction pygame.event.wait().

Les événements du clavier

Lorsque vous importez PyGame, un autre module est importé, c’est le module key. Le module key possède deux types d’événements, KEYUP et KEYDOWN. Ces types d’événements ont un attribut appelé key. Ces attributs de touches correspondent à une constante pour chaque touche du clavier. En fait, ces constantes commencent par un K majuscule, suivi d’un trait de soulignement, suivi du nom de la touche. Voici quelques constantes et les touches clavier correspondantes :

K_LEFT : flèche gauche
K_RIGHT : flèche droite
K_0 : 0
K_a : a

Pygame.key.get_pressed() : cette fonction renvoie l’état de tous les boutons du clavier. La fonction renvoie une valeur booléenne indiquant l’état de chaque touche du clavier. Si une touche est enfoncée, elle renvoie une valeur booléenne de « 1 » ou True. Pour toutes les touches qui ne sont pas enfoncées, elle renvoie une valeur booléenne de ‘0’ ou False.

Voici un code qui vous permet de faire bouger l’image d’arrière plan en utilisant les flèches du clavier.

background_image = "ciel.jpg"

import pygame
from pygame.locals import *

pygame.init()
screen = pygame.display.set_mode((640, 455))

pygame.display.set_caption("Créer un jeu")
background = pygame.image.load(background_image).convert()


x, y = 0, 0
move_x, move_y = 0, 0
run = True
while run:

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            run = False

        if event.type == KEYDOWN:
            if event.key == K_LEFT:
                move_x = -10
            elif event.key == K_RIGHT:
                move_x = +10
            elif event.key == K_UP:
                move_y = -10
            elif event.key == K_DOWN:
                move_y = +10
        elif event.type == KEYUP:
            if event.key == K_LEFT:
                move_x = 0
            elif event.key == K_RIGHT:
                move_x = 0
            elif event.key == K_UP:
                move_y = 0
            elif event.key == K_DOWN:
                move_y = 0
        x += move_x
        y += move_y
        screen.fill((0, 0, 0))
        screen.blit(background, (x, y))
        pygame.display.update()

pygame.quit()
quit()

La boucle d’événement dans ce script gère les événements des touches du clavier KEYDOWN et KEYUP.

Les constantes du clavier

key : représente la touche enfoncée ou relâchée. Les touches alphabétiques sont de K_a à K_z. En outre, nous avons des constantes pour toutes les autres touches, telles que K_SPACE et K_RETURN.
mod : les touches utilisées en combinaison avec d’autres touches, telles que Maj, Alt et Ctrl. Chacune de ces touches de modification est représentée par une constante qui commence par KMOD_, comme KMOD_SHIFT, KMOD_ALT et KMOD_CTRL.
Voir les autres constantes sur le site de pygame.

Dans l’exemple précédent, à l’intérieur du bloc de KEYDOWN, nous vérifions les quatre constantes key.
Si K_LEFT (flèche vers la gauche) est enfoncée : move_x = -10 et si K_RIGHT (flèche vers la droite) est enfoncée : move_x = +10.
De même pour les flèches du haut et du bas de notre clavier elle sont définies dans la variable move_y. En fait, l’image d’arrière plan va se déplacer de 10 pixels. L’image se déplace de (-10) pixels vers la gauche ou vers le haut. Cependant, si elle se déplace de (+10) pixels, elle se dirigera vers la droite ou vers le bat (+10).

Rappelez-vous, x est positif vers la droite et négatif vers la gauche. Par contre, y est positif vers le bas et négatif vers le haut.

Toutefois, le code du bloc KEYUP défini move_x et move_y à zéro pour empêcher l’arrière-plan de se déplacer lorsque vous relâchez les touches. Ensuite, nous ajoutons les valeurs move_x et move_y à x et y (valeurs en pixels), puis nous dessinons l’arrière-plan avec les nouvelles valeurs (x, y).

screen.fill((0, 0, 0)) efface l’affichage en noir (nous expliquerons les couleurs prochainement). Cette ligne est nécessaire pour que l’image occupe l’arrière-plan lorsqu’elle se déplace.

PyGame – créer des jeux facilement avec Python

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.

Retour en haut