TOC

Comment installer pygame et créer un modèle pour le développement de jeux dans Python 3

introduction

La bibliothèque pygame est un module à code source ouvert pour le langage de programmation Python, spécialement conçu pour vous aider à créer des jeux et d’autres applications multimédias. Construit sur la bibliothèque de développement hautement portable SDL (Simple DirectMedia Layer), pygame peut fonctionner sur de nombreuses plates-formes et systèmes d’exploitation.

En utilisant le module pygame, vous pouvez contrôler la logique et les graphiques de vos jeux sans vous soucier de la complexité du back-end nécessaire pour travailler avec la vidéo et l’audio.

Ce didacticiel commence par l’installation de pygame dans votre environnement de programmation Python, puis vous explique comment créer un modèle pour développer des jeux avec pygame et Python 3.

Conditions préalables

Pour pouvoir utiliser ce didacticiel, assurez-vous que Python 3 et un environnement de programmation sont déjà installés sur votre https://www.digitalocean.com/community/tutorial_series/how-to-install-and-set-up-a- local-programming-environment-for-python-3 [ordinateur local] ou https://www.digitalocean.com/community/tutorials/how-to-install-python-3-and-set-up-a-programming- environment-on-an-ubuntu-16-04-server [serveur].

Vous devez également connaître les concepts de programmation Python suivants:

Avec un environnement de programmation configuré et une familiarité avec Python programming, vous êtes prêt à commencer à utiliser pygame.

Installation de pygame

Commençons par activer notre environnement de programmation Python 3:

. /bin/activate

Avec cette option activée, vous pouvez installer pygame avec pip:

pip install pygame

Une fois que vous avez exécuté cette commande, le résultat devrait ressembler à celui-ci:

OutputCollecting pygame
 Using cached pygame-1.9.3-cp35-cp35m-manylinux1_x86_64.whl
Installing collected packages: pygame
Successfully installed pygame-1.9.3

Si vous avez installé pygame sur un système avec vidéo et audio disponibles, vous pouvez vérifier votre installation en exécutant la commande suivante, qui exécutera un simulacre de jeu montrant ce que pygame peut faire avec les graphiques et le son:

python -m pygame.examples.aliens

Si vous préférez ne pas ouvrir l’échantillon ou si votre configuration ne comporte pas de matériel audiovisuel, vous pouvez également accéder à la console interactive Python pour pouvoir importer le module pygame. Tout d’abord, tapez la commande + python pour démarrer la console:

python

Ensuite, dans la console, vous pouvez importer le module:

import pygame

Si vous ne recevez aucune erreur lorsque vous appuyez sur la touche + ENTER + après la commande, vous saurez que pygame a été installé avec succès. Vous pouvez quitter la console interactive Python avec la commande + quit () +.

Si vous rencontrez des problèmes d’installation sur la ligne de commande, vous pouvez consulter le GettingStarted wiki de pygame.

Dans les étapes suivantes, nous supposerons l’utilisation d’un moniteur pour afficher l’interface utilisateur graphique dans le cadre de ce didacticiel afin de vérifier notre code.

Importer un pygame

Pour vous familiariser avec pygame, créons un fichier nommé + our_game.py +, que nous pouvons créer avec l’éditeur de texte nano, par exemple:

nano our_game.py

Lorsque vous commencez un projet dans pygame, vous commencez par l’instruction + import + utilisée pour les importing , que vous pouvez ajouter en haut de votre fichier:

notre_jeu.py

import pygame

Nous pouvons également éventuellement ajouter une autre instruction d’importation au-dessous de la première ligne pour ajouter certaines des constantes et fonctions de pygame dans la page https://www.digitalocean.com/community/tutorials/how-to-import-modules-in-python- 3 # using-from - importer [espace de noms global] de votre fichier:

notre_jeu.py

import pygame

Avec pygame importé dans notre fichier programme, nous sommes prêts à l’utiliser pour créer un modèle de jeu.

Initialisation de pygame

À partir de là, nous allons initialiser les fonctionnalités de pygame avec la fonction + init () +, qui est l’abréviation de 'initialize.'

notre_jeu.py

import pygame
from pygame.locals import *

La fonction + init () + lancera automatiquement tous les modules pygame dont vous avez besoin d’être initialisés.

Vous pouvez également initialiser chacun des modules de pygame individuellement, comme dans:

pygame.font.init()

La fonction + init () + vous renverra un tuple si vous le souhaitez. Ce tuple indiquera l’initialisation réussie et non réussie. Nous pouvons faire cela à la fois pour l’appel général + init () + et pour l’initialisation de modules spécifiques (qui nous indiqueront si ces modules sont disponibles):

i = pygame.init()
print(i)

f = pygame.font.init()
print(f)

Si nous exécutons le code ci-dessus, nous recevrons une sortie similaire à celle-ci:

Output(6, 0)
None

Dans ce cas, les + i + variable ont renvoyé le tuple + (6, 0) + `, qui montre qu’il y a eu 6 initialisations pygame réussies et 0 échecs. La variable `+ f + a renvoyé + None +, indiquant que le module n’est pas disponible dans cet environnement particulier.

Configuration de la surface d’affichage

À partir de là, nous devons configurer notre surface d’affichage du jeu. Nous allons utiliser + pygame.display.set_mode () + pour initialiser une fenêtre ou un écran en vue de son affichage et le transmettre à une variable. Dans la fonction, nous allons passer un argument pour la résolution d’affichage qui est une paire de nombres représentant la largeur et la hauteur dans un tuple. Ajoutons cette fonction à notre programme:

notre_jeu.py

import pygame
from pygame.locals import *


pygame.init()

Nous avons passé le tuple + (800, 600) + en tant qu’argument de la fonction + set_mode () +, représentant la résolution de la largeur (800 px) et de la hauteur (600 px). Notez que le tuple est contenu dans les parenthèses de la fonction, il y a donc des doubles parenthèses dans la fonction ci-dessus.

Vous utiliserez probablement le intgers& pour la résolution de votre jeu, vous voudrez donc probablement attribuer ces nombres à des variables plutôt que d’utiliser les nombres encore et encore. Cela peut faciliter la tâche lorsque vous devez modifier votre programme car il vous suffira de modifier ce qui est passé aux variables.

Nous allons utiliser la variable + display_width pour la largeur de l’affichage de votre jeu et` + display height` pour la hauteur, et passer ces variables à la fonction + set_mode () +:

notre_jeu.py

import pygame
from pygame.locals import *


pygame.init()




game_display = pygame.display.set_mode((, ))

A ce stade, la surface d’affichage du jeu est configurée avec une résolution pour sa largeur et sa hauteur.

Mise à jour de l’affichage

Ensuite, nous devrons utiliser l’une des deux fonctions disponibles pour mettre à jour l’affichage de la surface de jeu.

Les animations sont généralement des changements entre différentes images au fil du temps. Vous pouvez penser à un flip book lorsque vous pensez aux animations, car elles consistent en une série d’images qui varient progressivement d’une page à la page suivante. Ces pages donnent la simulation du mouvement quand ils sont tournés rapidement, car le contenu de la page semble être en mouvement. Dans les jeux informatiques, les cadres sont utilisés plutôt que les pages.

En raison du concept de retournement de pages ou de cadres, l’une des fonctions utilisables pour mettre à jour l’affichage de la surface de jeu est appelée + flip () +, et peut être appelée dans notre fichier ci-dessus de la manière suivante:

pygame.display.flip()

La fonction + flip () + met à jour la totalité de la surface d’affichage à l’écran.

Plus fréquemment, la fonction + update () + est utilisée à la place de la fonction + flip () + car elle ne mettra à jour que des parties de l’écran, plutôt que la totalité de la zone, en économisant de la mémoire.

Ajoutons la fonction + update () + au bas du fichier + our_game.py +:

notre_jeu.py

import pygame
from pygame.locals import *


pygame.init()

display_width = 800
display_height = 600

game_display = pygame.display.set_mode((display_width, display_height))

À ce stade, vous pouvez exécuter le programme sans erreur, mais la surface d’affichage s’ouvrira et se fermera rapidement.

Créer la boucle du jeu

Avec pygame importé et initialisé, l’écran d’affichage et la surface de jeu mise à jour, nous pouvons commencer à travailler sur notre boucle de jeu principale.

Nous allons créer une https://www.digitalocean.com/community/tutorials/how-to-construct-while-loops-in-python-3 [+ while +] pour exécuter le jeu. La boucle appellera la valeur Boolean de + True +, ce qui signifie que la boucle sera bouclée indéfiniment sauf si elle est perturbé.

Dans cette boucle principale de notre programme, nous construirons une https://www.digitalocean.com/community/tutorials/how-to-construct-for-loops-in-python-3 [boucle ` + pour + `] à parcourir les événements utilisateur dans la file d’événements, qui seront appelés par la fonction `+ pygame.event.get () +.

À ce stade, nous n’avons rien dans la boucle + for, mais nous pouvons ajouter une instruction` + print () + pour montrer que le code se comporte comme prévu. Nous allons passer les événements de l’itération dans l’instruction sous la forme `+ print (event) +.

Ajoutons ces deux boucles et l’instruction + print () + dans notre fichier programme:

notre_jeu.py

import pygame
from pygame.locals import *


pygame.init()

display_width = 800
display_height = 600

game_display = pygame.display.set_mode((display_width, display_height))

pygame.display.update()

Pour vous assurer que notre code fonctionne, exécutons le programme:

python our_game.py

Lorsque nous exécutons le fichier, une fenêtre 800x600 s’affiche. Pour tester les événements, vous pouvez passer la souris sur la fenêtre, cliquer dans la fenêtre et appuyer sur les touches de votre clavier. Ces événements seront imprimés sur la fenêtre de votre console.

La sortie que vous recevrez ressemblera à ceci:

Output<Event(4-MouseMotion {'rel': (616, 355), 'buttons': (0, 0, 0), 'pos': (616, 355)})>
<Event(5-MouseButtonDown {'button': 1, 'pos': (616, 355)})>
<Event(6-MouseButtonUp {'button': 1, 'pos': (616, 355)})>
<Event(2-KeyDown {'scancode': 3, 'key': 102, 'unicode': 'f', 'mod': 0})>
<Event(3-KeyUp {'scancode': 3, 'key': 102, 'mod': 0})>
...

Cette sortie affiche les événements utilisateur en cours. Ce sont ces événements qui vont contrôler le jeu car ils sont générés par l’utilisateur. Chaque fois que vous exécutez la fonction + pygame.event.get () +, votre code prendra ces événements.

Arrêtez l’exécution du programme en appuyant sur les touches + CTRL + + + C + dans la fenêtre du terminal.

À ce stade, vous pouvez supprimer ou comment out l’instruction + print () + en tant que n’aura pas besoin de toutes les sorties de ce terminal.

À partir de là, nous pouvons travailler à la finition de notre modèle en apprenant à quitter un jeu.

En quittant

Pour quitter un programme pygame, nous pouvons d’abord désinitialiser les modules pertinents, puis quitter Python comme d’habitude.

La fonction + pygame.quit () + désinitialise tous les modules pygame, et la fonction Python + quit () + va quitter le programme.

Etant donné que les utilisateurs contrôlent les fonctionnalités et les événements du jeu, nous devons également savoir que + pygame.QUIT + est envoyé à la file d’attente des événements lorsque l’utilisateur a demandé l’arrêt du programme en cliquant sur le «X» dans la partie supérieure de la fenêtre du jeu. Coin.

Commençons par contrôler le déroulement du programme avec une conditional + if + dans le gestion des événements + pour + boucle:

notre_jeu.py

import pygame
from pygame.locals import *


pygame.init()

display_width = 800
display_height = 600

game_display = pygame.display.set_mode((display_width, display_height))

pygame.display.update()

while True:
   for event in pygame.event.get():

Dans le code ci-dessus, nous disons que si l’utilisateur a demandé la fermeture du programme, il devrait désinitialiser les modules pygame avec + pygame.quit () + et quitter le programme avec + quit () +.

Depuis que nous avons importé + pygame.locals +, nous pouvons évoquer + event.type + et + QUIT + en l’état (plutôt qu’avec + pygame. + Devant ceux-ci).

Bien que les utilisateurs sachent qu’il faut cliquer sur le «X» dans le coin supérieur de la fenêtre de jeu, nous pouvons souhaiter que certains autres événements utilisateur déclenchent la demande de quitter le programme. Nous pouvons le faire avec le type d’événement + KEYDOWN + et une ou plusieurs clés.

L’événement + KEYDOWN + signifie que l’utilisateur appuie sur une touche de son clavier. Supposons que la touche + Q + (comme dans 'quit') ou la touche + ESC + puisse quitter le programme. Ajoutons le code qui signifie cela dans notre boucle + pour +:

notre_jeu.py

import pygame
from pygame.locals import *


pygame.init()

display_width = 800
display_height = 600

game_display = pygame.display.set_mode((display_width, display_height))

pygame.display.update()

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




           pygame.quit()
           quit()

Nous avons ajouté Boolean opérateurs afin que le programme puisse quitter si l’utilisateur clique sur le «X ”Dans le coin supérieur de la fenêtre de jeu, ou si l’utilisateur appuie sur une touche qui correspond à la touche d’échappement ou à la touche` + Q + `(notez que cela n’est pas sensible à la casse).

À ce stade, si vous exécutez le programme avec la commande + python our_game.py + ', vous pourrez tester les fonctionnalités du jeu en cours d’exécution, puis quitter en quittant la fenêtre avec l’icône «X» ou par l’intermédiaire de en appuyant soit sur la touche + Q + ou + + ESC +.

Améliorations du code et prochaines étapes

Bien que le programme ci-dessus soit entièrement fonctionnel, nous pouvons faire certaines choses pour améliorer le code.

Pour commencer, nous pouvons mettre le code qui se trouve dans la boucle + while + dans une définition de https://www.digitalocean.com/community/tutorials/how-to-define-functions-in-python-3 au lieu:

def event_handler():
   for event in pygame.event.get():
       if event.type == QUIT or (
            event.type == KEYDOWN and (
             event.key == K_ESCAPE or
             event.key == K_q
            )):
           pygame.quit()
           quit()

Cela rendra la boucle + while + un peu plus nette et condensée, d’autant plus que nous ajoutons plus de fonctionnalités à notre jeu.

De plus, pour commencer à peaufiner le jeu, nous pouvons ajouter une légende à la barre de titre de la fenêtre (qui lit actuellement + pygame window +). Nous pouvons le faire avec la ligne suivante:

pygame.display.set_caption('')

Nous pouvons définir la chaîne + 'Notre jeu' + ci-dessus sur tout ce que nous voudrions appeler le jeu.

De plus, nous pouvons déplacer la fonction + pygame.display.update () + dans la boucle de jeu principale.

Maintenant, notre code complet ressemble à ceci:

notre_jeu.py

import pygame
from pygame.locals import *


pygame.init()

display_width = 800
display_height = 600

game_display = pygame.display.set_mode((display_width, display_height))
pygame.display.set_caption('Our Game')


def event_handler():
   for event in pygame.event.get():
       if event.type == QUIT or (
            event.type == KEYDOWN and (
             event.key == K_ESCAPE or
             event.key == K_q
            )):
           pygame.quit()
           quit()

while True:
   event_handler()

   pygame.display.update()

Vous pouvez également envisager différentes manières d’aborder le code ci-dessus, y compris en utilisant un https://www.digitalocean.com/community/tutorials/how-to-use-break-continue- and -pass-statements-when-working-with -loops-in-python-3 # break-statement [instruction break] pour sortir d’une boucle avant de passer à une sortie de jeu.

À partir de là, vous souhaiterez apprendre à afficher des images par le biais de dessins et d’images-objets, à animer des images, à contrôler le taux de trame, etc. Vous pouvez continuer à vous renseigner sur le développement de jeux Pygame en lisant la documentation officielle pygame.

Conclusion

Ce didacticiel vous a expliqué comment installer le module open source pygame dans votre environnement de programmation Python 3 et comment commencer à aborder le développement de jeux en créant un modèle que vous pouvez utiliser pour contrôler la boucle principale d’un jeu Python.

Pour réaliser d’autres projets de programmation utilisant des modules Python, vous pouvez apprendre «https://www.digitalocean.com/community/tutorials/how-to-create-a-twitterbot-with-python-3-and-the- tweepy-library [Comment créer un Twitterbot avec la bibliothèque Tweepy], ”ou“ https://www.digitalocean.com/community/tutorials/how-to-plot-data-in-python-3-using-matplotlib [ Comment tracer des données à l’aide de matplotlib]. ”

Related