Pyglet 'Hello World' : Votre Première Fenêtre de Jeu Python

Avant de saupoudrer la magie de Pyglet, assurons-nous que les fondations sont solides. Vous aurez besoin de Python 3.7 ou plus récent — la plupart des systèmes l'auront, mais cela vaut toujours la peine de vérifier rapidement. Ouvrez votre terminal ou votre invite de commandes et demandez à Python ce qu'il a fait :

python --version

Si vous ne voyez pas Python 3.x.x, un rapide passage sur python.org vous aidera. Une fois que Python est confirmé, créons un espace de travail agréable et propre avec un environnement virtuel :

# Naviguez jusqu'à votre dossier de projet, puis créez-le :
python -m venv .venv

Et ensuite, comme par magie, activez-le. L'invite de votre terminal devrait arborer un petit préfixe (.venv), une subtile indication que vous êtes maintenant dans votre environnement isolé :

# Sur macOS/Linux
source .venv/bin/activate

# Sur Windows (utilisez l'invite de commandes)
.venv\Scripts\activate

Avec votre environnement virtuel en marche, ajouter Pyglet à votre projet est aussi simple que, eh bien, d'installer un package. Une seule commande, et pip s'occupe du reste, téléchargeant Pyglet depuis le Python Package Index et le plaçant proprement dans votre espace de projet isolé.

Tapez ceci dans votre terminal *activé* :

pip install pyglet

Vous verrez une cascade de texte pendant que Pyglet et ses sous-dépendances nécessaires sont téléchargés et installés. Une fois que tout s'est calmé, vous êtes officiellement prêt à commencer à faire apparaître des fenêtres ! C'est un peu comme installer un chevalet et préparer vos peintures pour le premier coup de pinceau.

Chaque grande application visuelle commence par une toile, et dans Pyglet, c'est une fenêtre. C'est l'élément le plus basique, et pourtant il ouvre un monde de possibilités. Créons un nouveau fichier, disons main.py, et donnons-lui l'incantation la plus simple pour créer une fenêtre.

Copiez et collez ce snippet dans votre fichier main.py :

import pyglet

# Créer une fenêtre
window = pyglet.window.Window(width=800, height=600, caption='Hello Pyglet!')

# Lancer l'application
pyglet.app.run()

Maintenant, enregistrez ce fichier et lancez-le depuis votre terminal *activé* :

python main.py

Vous devriez voir apparaître une fenêtre assez simple et vide avec "Hello Pyglet!" dans sa barre de titre. Un début modeste, peut-être, mais une sacrée réalisation !

Ce petit morceau de code de l'étape précédente a fait beaucoup, en fait. Tirons le rideau sur ces deux lignes qui ont donné vie à votre fenêtre.

• import pyglet : Cette ligne est notre point d'entrée, disant simplement à Python que nous avons l'intention d'utiliser la bibliothèque Pyglet. Pensez-y comme à ouvrir votre boîte à outils.
• window = pyglet.window.Window(...) : Ici, nous créons une instance de la classe Window de Pyglet. Nous lui avons passé quelques arguments :
  • width et height : Ils définissent les dimensions de votre fenêtre en pixels.
  • caption : C'est le texte qui apparaît dans la barre de titre de la fenêtre, agissant comme son nom.
  Vous pouvez aller plus loin avec d'autres options, comme `resizable=True` ou `fullscreen=True`, mais pour un "Hello World", celles-ci suffisent.
• pyglet.app.run() : C'est le grand chef d'orchestre. Il démarre la boucle d'événements principale de Pyglet. Essentiellement, il met votre application en attente, écoutant des choses comme les clics de souris, les frappes de touches, ou même le système d'exploitation qui dit : "Hé, redessine cette fenêtre !" Sans cette ligne, votre fenêtre apparaîtrait et disparaîtrait plus vite que vous ne pouvez dire "Pyglet".

C'est un schéma fondamental pour presque toutes les applications Pyglet — installez votre scène, puis dites au spectacle de commencer à se dérouler.

Une fenêtre vide est un peu comme une scène vide — fonctionnelle, mais manquant de caractère. Ajoutons du texte pour vraiment déclarer notre présence. Pyglet fournit une classe Label pratique à cet effet, rendant l'affichage du texte étonnamment facile.

Mettez à jour votre main.py pour qu'il ressemble à ceci :

import pyglet

window = pyglet.window.Window(800, 600, caption='Hello Pyglet!')

# Créer un objet Label
hello_label = pyglet.text.Label(
    'Hello World!',
    font_name='Times New Roman',
    font_size=36,
    x=window.width//2, y=window.height//2,
    anchor_x='center', anchor_y='center',
    color=(255, 255, 255, 255) # RGBA : blanc, opaque
)

# Ceci est un décorateur pour enregistrer une fonction comme gestionnaire d'événements
@window.event
def on_draw():
    window.clear() # Effacer la fenêtre d'abord
    hello_label.draw() # Puis dessiner notre label

pyglet.app.run()

Lancez cette nouvelle version de main.py. Maintenant, juste au milieu de votre fenêtre, vous devriez voir "Hello World!" dans toute sa splendeur. C'est un peu comme ajouter le titre à votre chef-d'œuvre.

Vous venez de voir @window.event et on_draw() — ce sont des éléments cruciaux pour tout ce qui est visuel dans Pyglet. La boucle d'événements que nous avons mentionnée précédemment n'est pas seulement pour les entrées utilisateur ; elle dicte également quand votre fenêtre doit se redessiner. C'est là qu'intervient on_draw.

• @window.event : Ce décorateur Python est la manière dont Pyglet dit : "Hé, chaque fois que l'objet `window` doit gérer un 'événement' appelé `on_draw`, cette fonction est celle à appeler." C'est comme dire au régisseur qui gère l'événement de "rappel".
• def on_draw(): : Cette fonction contient toutes les instructions sur ce qui doit être visible sur votre fenêtre *à ce moment-là*. Elle est appelée automatiquement chaque fois que la fenêtre a besoin de rafraîchir son affichage — que ce soit après avoir été minimisée, redimensionnée, ou simplement parce qu'il est temps pour la prochaine image d'animation.
• window.clear() : Avant de dessiner quoi que ce soit de nouveau, il est bon d'effacer l'ardoise. Cela efface toute la fenêtre, empêchant les anciens dessins de persister comme des vestiges fantomatiques.
• hello_label.draw() : Enfin, nous demandons à notre objet `hello_label` de se dessiner sur la fenêtre effacée. L'ordre de dessin est important, donc tout ce que vous dessinez en dernier apparaîtra par-dessus.

Comprendre on_draw est essentiel. C'est le centre de toutes les opérations de rendu. Chaque élément graphique, du texte aux images en passant par les modèles 3D complexes, passera éventuellement par cette fonction pour être affiché. Considérez-la comme le cœur battant de la sortie visuelle de votre application.

Une image statique est agréable, mais les expériences interactives sont là où le plaisir commence vraiment. Pyglet, étant un framework événementiel, rend la gestion des entrées utilisateur un jeu d'enfant. Ajoutons un gestionnaire de clavier simple pour que notre fenêtre réagisse à une pression de touche — disons, fermer la fenêtre lorsque vous appuyez sur Échap.

Ajoutez ce nouveau gestionnaire d'événements à votre main.py, juste en dessous de votre fonction on_draw :

# ... (code précédent pour la fenêtre et le label) ...

@window.event
def on_draw():
    window.clear()
    hello_label.draw()

# Importer le module keys pour vérifier les pressions de touche
import pyglet.window.key as key

@window.event
def on_key_press(symbol, modifiers):
    if symbol == key.ESCAPE:
        pyglet.app.exit() # Fermer l'application

pyglet.app.run()

Relancez le script, et essayez d'appuyer sur la touche `Échap`. Pschitt ! Votre fenêtre devrait disparaître. La fonction on_key_press est un autre gestionnaire d'événements spécial, qui écoute ces moments où les doigts d'un utilisateur dansent sur le clavier. C'est comme avoir un petit assistant dans les coulisses, prêt à exécuter une action lorsqu'une indication spécifique est donnée.

Les claviers sont excellents, mais parfois un bon vieux clic est ce qu'il faut. Pyglet nous offre un gestionnaire d'événements similaire pour les entrées souris. Faisons en sorte que notre label "Hello World!" change de message chaque fois que vous cliquez sur le bouton de la souris.

Ajoutez la fonction on_mouse_press suivante à votre main.py :

# ... (code précédent) ...

# Garder une trace du nombre de clics
click_count = 0

@window.event
def on_mouse_press(x, y, button, modifiers):
    global click_count # Nous devons modifier la variable globale
    click_count += 1
    hello_label.text = f'Vous avez cliqué {click_count} fois !'

# ... (on_key_press et pyglet.app.run() restent les mêmes) ...

Lorsque vous exécutez cela, cliquer n'importe où dans la fenêtre mettra à jour le texte. Notez comment on_mouse_press reçoit des informations sur l'endroit où le clic s'est produit (coordonnées x, y), quel bouton a été pressé, et les touches modificatrices (comme Shift ou Ctrl). C'est un système de surveillance miniature pour votre souris, toujours prêt à rapporter.

Nous avons donc abordé les bases : une fenêtre, du texte, et quelques façons de répondre aux entrées utilisateur. Mettons tout cela ensemble dans un script "Hello World" cohérent qui démontre vraiment l'élégance de Pyglet. Cette version consolidée est ce avec quoi vous commenceriez généralement pour tout nouveau projet interactif Pyglet.

Voici la version complète et polie de main.py :

import pyglet
import pyglet.window.key as key # Pour les événements clavier

# 1. Configuration de la fenêtre
window = pyglet.window.Window(width=800, height=600, caption='Pyglet Interactive Hello World', resizable=True)

# 2. Préparation des éléments visuels
click_count = 0
hello_label = pyglet.text.Label(
    'Hello World!',
    font_name='Arial',
    font_size=28,
    x=window.width//2, y=window.height//2,
    anchor_x='center', anchor_y='center',
    color=(255, 255, 255, 255) # Texte blanc
)

# 3. Définition des gestionnaires d'événements

@window.event
def on_draw():
    window.clear()
    hello_label.draw()

@window.event
def on_key_press(symbol, modifiers):
    if symbol == key.ESCAPE:
        pyglet.app.exit()
    elif symbol == key.SPACE:
        hello_label.text = "Espace pressé ! Bonjour encore !"
    elif symbol == key.BACKSPACE:
        hello_label.text = "Retour aux bases : Hello World !"


@window.event
def on_mouse_press(x, y, button, modifiers):
    global click_count
    click_count += 1
    hello_label.text = f'Souris cliquée {click_count} fois !'

# Mettre à jour la position du label si la fenêtre est redimensionnée
@window.event
def on_resize(width, height):
    hello_label.x = width // 2
    hello_label.y = height // 2
    print(f"Fenêtre redimensionnée à {width}x{height}") # Pour le débogage

# 4. Lancement de l'application
pyglet.app.run()

Maintenant, enregistrez cette version et lancez-la. Essayez de cliquer avec la souris, d'appuyer sur `Espace`, `Retour arrière`, et `Échap`. Vous avez essentiellement construit une petite démo interactive, un exemple petit mais puissant de la façon dont Pyglet vous permet de chorégraphier les actions et les réactions sur votre écran. C'est comme diriger un mini-orchestre, où chaque événement est une note et votre code est la partition.

Vous avez officiellement créé votre toute première application Pyglet "Hello World" ! D'une toile vierge à un affichage interactif, vous avez vu les composants principaux en action : création de fenêtres, affichage de texte et réponse aux entrées utilisateur. Ces bases sont étonnamment robustes pour construire des choses beaucoup plus complexes.

Où allez-vous à partir d'ici ? Le monde — ou du moins le monde Pyglet — est à vous :

• Images et Sprites : Donnez vie à vos jeux en chargeant et en dessinant des images. Pyglet gère facilement divers formats.
• Animation : Déplacez les choses ! Utilisez l'horloge de Pyglet pour des événements chronométrés et créez des animations fluides.
• Audio et Vidéo : Ajoutez des effets sonores, de la musique de fond, ou même intégrez des vidéos directement dans vos applications.
• Boucle de Jeu et Batching : Pour des projets plus complexes, vous approfondirez les techniques de rendu efficaces et la gestion de nombreux objets.
• Périphériques d'Entrée : Au-delà de la souris et du clavier, explorez le support des joysticks et des manettes.

Considérez ce "Hello World" comme la première douce impulsion sur une balançoire. Vous avez maintenant l'élan ; les prochaines étapes consistent à déterminer à quelle hauteur vous voulez aller. Continuez à expérimenter, continuez à explorer, et prenez plaisir à donner vie à vos créations Python avec Pyglet !