Accueil Technologie

Création de personnages de jeux basés sur des sprites en Pygame

Si vous êtes un développeur de jeux utilisant la bibliothèque Pygame, vous avez probablement rencontré la classe Sprite. La classe Sprite est un outil puissant pour créer des personnages de jeu que vous pouvez facilement déplacer, faire pivoter et mettre à l’échelle sur l’écran.


Avec un simple programme Python, vous pouvez apprendre le processus de création de personnages de jeu basés sur des sprites dans Pygame. Découvrez comment créer une classe Sprite de base, puis ajoutez des attributs et des méthodes pour contrôler le comportement.

Introduction à la classe Sprite de Pygame

La classe Sprite de Pygame est une classe conteneur qui contient tous les attributs et comportements d’un personnage de jeu. Elle dérive de la classe Surface de Pygame, qui représente une image avec une largeur et une hauteur fixes.

Pour travailler avec cette classe, vous devez créer une nouvelle classe qui hérite de la classe Sprite, et définir tous les attributs et méthodes que vous voulez que votre personnage de jeu possède.

Création d’une classe Sprite de base pour un personnage de jeu

Tout d’abord, installez le module pygame à l’aide de pip. Faites-le avec cette commande :

 pip install pygame 

Pour créer un sprite de base, vous devez importer la classe Sprite de Pygame et créer une nouvelle classe qui en hérite. Ensuite, vous pouvez définir tous les attributs et méthodes que vous souhaitez pour votre personnage de jeu.

Par exemple, vous pourriez vouloir créer une classe Sprite pour un personnage de joueur qui peut se déplacer de gauche à droite à travers l’écran. Pour ce faire, vous pouvez définir les attributs suivants :

  • position : Un tuple qui contient les coordonnées x et y du sprite sur l’écran.
  • vélocité : Un tuple qui contient la vitesse à laquelle le sprite se déplace horizontalement et verticalement.
Lire  Comment diffuser des jeux PC en streaming sur votre Shield TV NVIDIA via Steam Link

Et les méthodes suivantes :

  • update() : Une méthode qui met à jour la position du sprite en fonction de sa vélocité.
  • draw() : Une méthode qui dessine le sprite à l’écran.

Voici un exemple d’une classe Sprite de base qui implémente ces attributs et méthodes :

 import pygame

class Player(pygame.sprite.Sprite):
    def __init__(self, x, y, velocity_x, velocity_y):
        super().__init__()
        self.position = (x, y)
        self.velocity = (velocity_x, velocity_y)
    
    def update(self):
        self.position = (self.position[] + self.velocity[], self.position[1] + self.velocity[1])
    
    def draw(self, surface):
        pygame.draw.circle(surface, (255, 0, 0), self.position, 10)

La méthode __init__ est une méthode spéciale des classes Python qui s’exécute lorsque vous créez une instance de la classe. Vous pouvez l’utiliser pour initialiser les attributs de l’instance.

Dans ce code, la méthode __init__ de la classe Player prend quatre arguments : x, y, velocity_x, et velocity_y. Ces arguments définissent la position et la vitesse initiales du sprite du joueur.

La méthode __init__ appelle également la méthode super().__init__(), qui est la méthode __init__ de la classe Sprite parente. Ceci est nécessaire car la classe Player est une sous-classe de la classe Sprite, et la méthode __init__ de la classe Sprite définit certains attributs dont tous les sprites ont besoin.

Ajout d’attributs et de méthodes pour contrôler le comportement

Maintenant que vous avez une classe Sprite de base, vous pouvez ajouter des attributs et des méthodes pour contrôler le comportement de votre personnage de jeu. Cela peut inclure des choses comme le mouvement, l’attaque, le saut, et plus encore.

Lire  Chromecast ou Roku : Lequel est le meilleur pour vous ?

Pour ajouter ces attributs et méthodes, vous devrez réfléchir aux actions que vous voulez que votre personnage de jeu puisse effectuer, et définir les attributs et méthodes correspondants dans votre classe Sprite.

Par exemple, vous pouvez ajouter une méthode pour contrôler le mouvement du sprite, comme une méthode move_left() qui diminue la vélocité du sprite sur l’axe des x.

Voici un exemple d’une classe Sprite modifiée qui inclut ces attributs et méthodes supplémentaires :

 class Player(pygame.sprite.Sprite):
    def __init__(self, x, y, velocity_x, velocity_y):
        super().__init__()
        self.position = (x, y)
        self.velocity = (velocity_x, velocity_y)
    
    def update(self):
        self.position = (self.position[] + self.velocity[], self.position[1] + self.velocity[1])
    
    def draw(self, surface):
        pygame.draw.circle(surface, (255, 0, 0), self.position, 10)
        
    def move_left(self):
        self.velocity = (-1, self.velocity[1])
    
    def move_right(self):
        self.velocity = (1, self.velocity[1])

Pour utiliser la classe Player dans votre jeu Pygame, vous devrez créer une instance de la classe et appeler ses méthodes si nécessaire.

Commencez par créer une fenêtre et une instance du sprite Player :

 # Initialize Pygame
pygame.init()

# Set the window size
window_size = (640, 480)

# Create a window
window = pygame.display.set_mode(window_size)

# Create a player sprite
player = Player(320, 240, , )

Définissez ensuite une boucle de jeu principale qui gère les événements et les mises à jour du clavier et dessine le sprite. Lorsque vous appuyez sur les touches fléchées gauche ou droite, le sprite se déplace dans la direction correspondante.

 # Main game loop
while True:
    # Handle events
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()

        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                player.move_left()
            elif event.key == pygame.K_RIGHT:
                player.move_right()
    
    # Update the player sprite
    player.update()
    
    # Clear the window
    window.fill((255, 255, 255))
    
    # Draw the player sprite
    player.draw(window)
    
    # Update the display
    pygame.display.update()

Avec le programme résultant, vous serez capable de contrôler le sprite du joueur et de l’observer se dessiner à l’écran à différentes positions :

jeu pygame avec sprite joueur

Chargement et affichage de sprites graphiques à l’aide du module Image

Maintenant que vous avez une classe Sprite de base avec des attributs et des méthodes pour contrôler le comportement, vous voudrez probablement ajouter des graphiques à votre sprite. Le module image de Pygame permet de charger et d’afficher facilement des images à l’écran.

Pour charger une image, vous devez utiliser la fonction pygame.image.load(), qui prend le chemin d’un fichier comme argument et renvoie un objet Surface. Vous pouvez ensuite affecter cet objet Surface à un attribut de sprite, tel que self.image, que vous pouvez utiliser pour dessiner le sprite à l’écran.

Par exemple, voici comment vous pouvez charger une image et l’assigner à un sprite :

 import pygame

class Player(pygame.sprite.Sprite):
    def __init__(self, x, y, velocity_x, velocity_y, image_path):
        super().__init__()
        self.position = (x, y)
        self.velocity = (velocity_x, velocity_y)
        self.image = pygame.image.load(image_path)
    
    def update(self):
        self.position = (self.position[] + self.velocity[], self.position[1] + self.velocity[1])
    
    def draw(self, surface):
        surface.blit(self.image, self.position)

    def move_left(self):
        self.velocity = (-1, self.velocity[1])
    
    def move_right(self):
        self.velocity = (1, self.velocity[1])

Ce code définit une classe Player qui étend la classe Sprite de Pygame et inclut des attributs pour la position, la vitesse et l’image, ainsi que des méthodes pour mettre à jour la position du sprite, dessiner le sprite à l’écran et contrôler le mouvement.

Vous pouvez consulter ce repo GitHub pour le code complet !

jeu pygame avec sprite player et module image

Améliorer la gestion des sprites avec la classe Sprite

La classe Sprite fournit un conteneur pratique pour tous les attributs et comportements d’un personnage de jeu, ce qui facilite la mise à jour, le dessin et le contrôle du sprite à l’écran.

En implémentant une classe Sprite dans votre jeu Pygame, vous pouvez améliorer l’expérience globale de vos joueurs et rationaliser le processus de développement pour vous-même.