Développement de jeux avec Pygame

"Le jeu est la façon préférée d'apprendre de notre cerveau" - Diane Ackerman

Le développement de jeux peut être une façon amusante et enrichissante d’appliquer des compétences en programmation. Pygame, une bibliothèque populaire pour Python, fournit un cadre simple mais puissant pour créer des jeux 2D. Dans cet article, nous allons explorer comment créer un jeu de base à l'aide de Pygame. Ce projet vous présentera les concepts clés du développement de jeux, tels que la gestion des entrées utilisateur, la mise à jour de l'état du jeu et le rendu des graphiques.

Configuration de Pygame

Vous pouvez installer Pygame en utilisant pip
pip installer pygame

Construire le code

Nous allons créer un jeu dans lequel le joueur déplace un panier vers la gauche et la droite pour attraper des objets qui tombent. Le jeu gardera une trace du score, l'augmentant à chaque fois qu'un objet est attrapé.

import pygame
import random
import sys

class CatchTheFallingObjectsGame:
    def __init__(self):
        # Initialize Pygame
        pygame.init()

        # Set up display
        self.width, self.height = 800, 600
        self.window = pygame.display.set_mode((self.width, self.height))
        pygame.display.set_caption("Catch the Falling Objects")

        # Define colors
        self.white = (255, 255, 255)
        self.black = (0, 0, 0)
        self.red = (255, 0, 0)

        # Set up player
        self.player_size = 100
        self.player_pos = [self.width // 2, self.height - 50]
        self.player_speed = 10

        # Set up falling objects
        self.object_size = 50
        self.object_pos = [random.randint(0, self.width - self.object_size), 0]
        self.object_speed = 5

        # Set up game variables
        self.score = 0
        self.font = pygame.font.SysFont("monospace", 35)

    def handle_events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()

    def update_player_position(self):
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT] and self.player_pos[0] > 0:
            self.player_pos[0] -= self.player_speed
        if keys[pygame.K_RIGHT] and self.player_pos[0] < self.width - self.player_size:
            self.player_pos[0] += self.player_speed

    def update_object_position(self):
        self.object_pos[1] += self.object_speed
        if self.object_pos[1] > self.height:
            self.object_pos = [random.randint(0, self.width - self.object_size), 0]

    def check_collision(self):
        if (self.player_pos[0] < self.object_pos[0] < self.player_pos[0] + self.player_size or
            self.player_pos[0] < self.object_pos[0] + self.object_size < self.player_pos[0] + self.player_size):
            if self.player_pos[1] < self.object_pos[1] + self.object_size < self.player_pos[1] + self.player_size:
                self.score += 1
                self.object_pos = [random.randint(0, self.width - self.object_size), 0]

    def draw_elements(self):
        self.window.fill(self.black)
        pygame.draw.rect(self.window, self.white, (self.player_pos[0], self.player_pos[1], self.player_size, 20))
        pygame.draw.rect(self.window, self.red, (self.object_pos[0], self.object_pos[1], self.object_size, self.object_size))
        score_text = self.font.render("Score: {}".format(self.score), True, self.white)
        self.window.blit(score_text, (10, 10))
        pygame.display.flip()

    def run(self):
        clock = pygame.time.Clock()
        while True:
            self.handle_events()
            self.update_player_position()
            self.update_object_position()
            self.check_collision()
            self.draw_elements()
            clock.tick(30)

if __name__ == "__main__":
    game = CatchTheFallingObjectsGame()
    game.run()

Structure de classe

Classe CatchTheFallingObjectsGame : Cette classe encapsule toute la logique et l'état du jeu. Il organise le jeu en méthodes qui gèrent différents aspects du jeu, rendant le code modulaire et plus facile à gérer.

Initialisation

Méthode d'initialisation :

• Initialisation de Pygame : appelle pygame.init() pour initialiser tous les modules Pygame.
• Configuration de l'affichage : définit la taille de la fenêtre de jeu sur 800 x 600 pixels et crée la surface d'affichage. Le titre de la fenêtre est défini sur "Attraper les objets qui tombent".
• Définitions des couleurs : définit les tuples de couleurs RVB pour le blanc, le noir et le rouge, qui sont utilisés pour dessiner des éléments à l'écran.
• Configuration du joueur : initialise la taille, la position de départ et la vitesse de déplacement du joueur.
• Configuration de l'objet en chute : définit la taille, la position initiale et la vitesse de l'objet en chute. La position est randomisée le long de l'axe des x.
• Variables du jeu : initialise le score à zéro et configure une police pour le rendu du texte à l'écran.

Méthodes de jeu

handle_events :

• Écoute les événements dans la file d'attente des événements Pygame.
• Vérifie l'événement QUIT pour permettre au joueur de fermer la fenêtre de jeu, en appelant pygame.quit() et sys.exit() pour quitter le jeu proprement

update_player_position :

• Vérifie quelles touches sont actuellement enfoncées à l'aide de pygame.key.get_pressed().
• Déplace le joueur vers la gauche ou la droite en fonction de la saisie de la touche fléchée, en garantissant que le joueur ne quitte pas l'écran.

update_object_position :

• Déplace l'objet qui tombe vers le bas en augmentant sa coordonnée y.
• Réinitialise la position de l'objet en haut de l'écran avec une nouvelle coordonnée x aléatoire s'il tombe du bas.

check_collision :

• Détecte les collisions entre le joueur et l'objet qui tombe.
• Si une collision est détectée (c'est-à-dire que l'objet croise la position du joueur), le score est incrémenté et l'objet est réinitialisé pour retomber du haut.

draw_elements :

• Efface l'écran en le remplissant avec la couleur d'arrière-plan (noir).
• Dessine le joueur sous la forme d'un rectangle blanc et l'objet qui tombe sous la forme d'un rectangle rouge.
• Rend la partition actuelle sous forme de texte et l'affiche dans le coin supérieur gauche.
• Mise à jour l'affichage avec pygame.display.flip() pour afficher la dernière image.

Boucle de jeu

exécuter la méthode :

• Contient la boucle principale du jeu, qui s'exécute en continu jusqu'à la sortie du jeu.
• Appelle chacune des méthodes de jeu dans l'ordre pour gérer les événements, mettre à jour l'état du jeu, vérifier les collisions et restituer le cadre.
• Utilise pygame.time.Clock() pour contrôler la fréquence d'images, garantissant ainsi le bon fonctionnement du jeu à environ 30 images par seconde.

Exécution

Garde principale :
Le bloc if name == "main": garantit que le jeu n'est exécuté que lorsque le script est exécuté directement, une pratique Python courante pour permettre l'importation de code sans exécuter le main boucle de jeu.

Sortir

À emporter

• Résolution de problèmes : le développement de jeux met à l'épreuve votre pensée critique et vos compétences en résolution de problèmes. Vous avez appris à diviser des tâches complexes en étapes plus petites et gérables et à trouver des solutions créatives aux obstacles.
• Créativité : Le développement de jeux est une forme d'art. Vous avez exploré votre créativité en concevant des mécanismes de jeu, en créant des scénarios captivants et en donnant vie à votre vision unique.
• Maîtrise de Python : Vous avez acquis une expérience précieuse en programmation Python, maîtrisant les concepts de base tels que les boucles, les conditions et la programmation orientée objet.

Vous voulez un défi ?

Une fois que vous maîtrisez les bases de la création d'un jeu simple avec Pygame, envisagez de relever des défis supplémentaires pour améliorer vos compétences et rendre votre jeu plus attrayant :

• Ajouter des effets sonores : intégrez des effets sonores pour attraper des objets ou les manquer pour rendre le jeu plus immersif. Pygame fournit des modules de gestion de l'audio, que vous pouvez explorer pour ajouter de la musique de fond ou des effets sonores.
• Augmenter la difficulté : augmentez progressivement la vitesse des objets qui tombent à mesure que le score du joueur augmente. Cela ajoutera une couche de défi et gardera le jeu passionnant.
• Introduire plusieurs types d'objets : ajoutez différents types d'objets qui tombent avec des valeurs de points ou des effets variables. Par exemple, certains objets pourraient diminuer le score ou mettre fin au jeu s'ils sont attrapés.
• Mettre en œuvre un système de notation : créez une fonction de score élevé qui enregistre le meilleur score du joueur entre les sessions. Cela peut motiver les joueurs à améliorer leurs performances.

Ce n'est que le début de votre aventure de développement de jeux en utilisant Python. Continuez à explorer, à expérimenter et à repousser les limites de votre créativité. Le monde de la programmation est vaste et en constante évolution, et il y a toujours quelque chose de nouveau à apprendre et à découvrir. Bon codage !

REMARQUE : ceci a été écrit avec l'aide de l'IA

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!