Création de personnages de jeu basés sur des sprites dans 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 redimensionner à l'écran.

Avec un programme Python simple, vous pouvez en apprendre davantage sur 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 dans Pygame est une classe conteneur qui contient tous les attributs et comportements d'un personnage de jeu. Il dérive de la classe Surface de Pygame, qui représente une image avec une largeur et une hauteur fixes.

Pour travailler avec, vous devrez créer une nouvelle classe qui hérite de la classe Sprite et définir tous les attributs et méthodes que vous souhaitez que votre personnage de jeu ait.

Création d'une classe de sprite de base pour un personnage de jeu

D'abord, installer le module pygame en utilisant pip. Faites-le avec cette commande :

pépin installer pygame

Pour créer un sprite de base, vous devrez 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 que votre personnage de jeu ait.

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

• position: Un tuple contenant les coordonnées x et y du sprite à l'écran.
• rapidité: Un tuple qui contient la vitesse à laquelle le sprite se déplace horizontalement et verticalement.

Et les méthodes suivantes :

• mise à jour(): Une méthode qui met à jour la position du sprite en fonction de sa vitesse.
• dessiner(): Une méthode qui dessine le sprite à l'écran.

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

importer pygame
classeJoueur(pygame.sprite. Lutin):
définitivement__init__(soi, x, y, vélocité_x, vélocité_y):
super().__init__()
soi.position = (x, y)
soi.velocity = (vitesse_x, vitesse_y)

définitivementmise à jour(soi):
soi.position = (soi.position[0] + soi.rapidité[0], soi.position[1] + soi.rapidité[1])

définitivementdessiner(soi, surface):
pygame.dessiner.cercle(surface, (255, 0, 0), soi.position, 10)

La méthode __init__ est une méthode spéciale méthode dans les 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, vélocité_x et vélocité_y. Ces arguments définissent la position initiale et la vitesse 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 parent. 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, etc.

Pour ajouter ces attributs et méthodes, vous devrez réfléchir aux actions que vous souhaitez que votre jeu caractère à pouvoir jouer, et définissez les attributs et méthodes correspondants dans votre Sprite classe.

Par exemple, vous voudrez peut-être ajouter une méthode pour contrôler le mouvement du sprite, telle qu'une méthode move_left() qui diminue la vitesse du sprite sur l'axe des x.

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

classeJoueur(pygame.sprite. Lutin):
définitivement__init__(soi, x, y, vélocité_x, vélocité_y):
super().__init__()
soi.position = (x, y)
soi.velocity = (vitesse_x, vitesse_y)

définitivementmise à jour(soi):
soi.position = (soi.position[0] + soi.rapidité[0], soi.position[1] + soi.rapidité[1])

définitivementdessiner(soi, surface):
pygame.dessiner.cercle(surface, (255, 0, 0), soi.position, 10)

définitivementse déplacer à gauche(soi):
soi.vitesse = (-1, soi.rapidité[1])

définitivementdéplacer vers la droite(soi):
soi.vitesse = (1, soi.rapidité[1])

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

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

# Initialiser Pygame
pygame.init()
# Définir la taille de la fenêtre
taille_fenêtre = (640, 480)
# Créer une fenêtre
fenêtre = pygame.display.set_mode (taille_fenêtre)
# Créer un sprite de joueur
joueur = joueur(320, 240, 0, 0)

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.

# Boucle de jeu principale
alors queVrai:
# Gérer les événements
pour événement dans pygame.event.get() :
si événement.type == pygame. ARRÊTER:
 pygame.quit()
 sys.exit()
si événement.type == pygame. TOUCHE BAS:
si event.key == pygame. K_GAUCHE :
 player.move_left()
elif event.key == pygame. K_DROITE :
 player.move_right()

# Mettre à jour le sprite du joueur
 joueur. mise à jour ()

# Effacer la fenêtre
 fenêtre.fill((255, 255, 255))

# Dessine le sprite du joueur
 player.draw (fenêtre)

# Mettre à jour l'affichage
 pygame.display.update()

Avec le programme résultant, vous pourrez contrôler le lutin du joueur et l'observer dessiner à l'écran à différentes positions :

Chargement et affichage de graphiques Sprite à 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 souhaiterez probablement ajouter des graphiques à votre sprite. Le module image de Pygame facilite le chargement et l'affichage des images à l'écran.

Pour charger une image, vous devrez utiliser la fonction pygame.image.load(), qui prend un chemin de 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 charger une image et l'affecter à un sprite :

importer pygame
classeJoueur(pygame.sprite. Lutin):
définitivement__init__(soi, x, y, vélocité_x, vélocité_y, chemin_image):
super().__init__()
soi.position = (x, y)
soi.velocity = (vitesse_x, vitesse_y)
soi.image = pygame.image.load (image_path)

définitivementmise à jour(soi):
soi.position = (soi.position[0] + soi.rapidité[0], soi.position[1] + soi.rapidité[1])

définitivementdessiner(soi, surface):
surface.blit(soi.image, soi.position)
définitivementse déplacer à gauche(soi):
soi.vitesse = (-1, soi.rapidité[1])

définitivementdéplacer vers la droite(soi):
soi.vitesse = (1, soi.rapidité[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 image, ainsi que des méthodes pour mettre à jour la position du sprite, dessiner le sprite à l'écran et contrôler mouvement.

Vous pouvez consulter ceci Dépôt GitHub pour le code complet!

Améliorez 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.