Pygame fournit plusieurs fonctions intégrées pour détecter les collisions entre les objets du jeu. Ces fonctions sont précieuses car déterminer exactement quand et comment des objets en mouvement se chevauchent peut être une tâche compliquée.
Apprenez à ajouter une physique de base et des collisions dans votre jeu à l’aide du module pygame.
Fonctions intégrées de détection des collisions de Pygame
La fonction de détection de collision intégrée la plus basique est spritecollide. Elle prend un sprite, un groupe de sprites, et une valeur booléenne indiquant si les sprites doivent ou non « mourir » (être supprimés) lorsqu’ils entrent en collision. Cette fonction renvoie une liste de sprites qui sont entrés en collision. Voici un exemple d’utilisation de cette fonction :
collided_sprites = pygame.sprite.spritecollide(sprite1, sprite_group, True) Une autre fonction utile de détection de collision est groupcollide, qui prend deux groupes de sprites et une valeur booléenne. Cette fonction retourne un dictionnaire avec les sprites entrés en collision comme clés et les sprites avec lesquels ils sont entrés en collision comme valeurs. Voici un exemple d’utilisation :
collision_dict = pygame.sprite.groupcollide(group1, group2, True, True) Création d’un jeu de plateforme basique à l’aide de la fonction spritecollide
Pour créer un jeu de plateforme de base à l’aide de Pygame, vous devez créer un sprite de joueur que l’utilisateur peut contrôler et un sprite de plateforme sur lequel le joueur peut se tenir. Vous pouvez utiliser la fonction spritecollide pour détecter le moment où le sprite du joueur entre en collision avec le sprite de la plate-forme et empêcher le joueur de tomber à travers la plate-forme.
Pour commencer, installez le module pygame à l’aide de pip :
pip install pygame Après cela, créez des classes simples pour le joueur et la plate-forme, qui doivent toutes deux hériter de la classe Sprite de Pygame. La classe Player doit avoir une méthode de mise à jour pour gérer la position du joueur en fonction de sa vélocité. Elle doit également posséder une variable y_velocity pour appliquer l’effet de gravité. La classe Platform doit avoir une méthode __init__ qui prend les coordonnées de la plate-forme et crée une surface de cette taille.
Classe de joueur
Vous pouvez créer une classe Player en utilisant le module pygame.sprite.Sprite. Cette classe va initialiser le joueur avec des coordonnées x et y données. Ensuite, la méthode update mettra à jour la position du joueur en incrémentant la valeur y_velocity.
import pygame
class Player(pygame.sprite.Sprite):
def __init__(self, x, y):
super().__init__()
self.image = pygame.Surface((32, 32))
self.rect = self.image.get_rect(topleft=(x, y))
self.y_velocity = 0
def update(self):
self.rect.y += self.y_velocity Classe de plateforme
La classe Platform utilise également le module pygame.sprite.Sprite. Cette classe va initialiser la plate-forme avec des coordonnées x et y données, ainsi qu’une largeur et une hauteur.
class Platform(pygame.sprite.Sprite):
def __init__(self, x, y, width, height):
super().__init__()
self.image = pygame.Surface((width, height))
self.rect = self.image.get_rect(topleft=(x, y)) La boucle du jeu
La boucle de jeu vous permet de créer une fenêtre d’une taille de 640×480. Ensuite, elle exécutera une boucle qui vérifiera tout événement, comme une commande de sortie. Elle vérifiera également s’il y a des collisions entre le joueur et la plate-forme. Enfin, il remplit l’écran d’une couleur blanche, dessine le joueur et la plate-forme, puis retourne l’affichage.
player = Player(100, 300)
player_group = pygame.sprite.Group()
player_group.add(player)
platform = Platform(50, 400, 100, 20)
platform_group = pygame.sprite.Group()
platform_group.add(platform)
# Initialize pygame and create window
pygame.init()
screen = pygame.display.set_mode((640, 480))
# Main game loop
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
player_group.update()
collided = pygame.sprite.spritecollide(player, platform_group, False)
if collided:
player.y_velocity = 0
screen.fill((255, 255, 255))
player_group.draw(screen)
platform_group.draw(screen)
pygame.display.flip()
pygame.quit() Voici le résultat :
Implémentation de la gravité et du comportement de saut
Pour implémenter la gravité et le saut dans votre jeu de plateforme, vous devrez ajouter une vélocité y à votre sprite de joueur et mettre à jour sa position y à chaque image. Pour ce faire, vous pouvez utiliser la méthode update de la classe Player et ajouter le bout de code suivant :
class Player(pygame.sprite.Sprite):
def __init__(self, x, y):
super().__init__()
self.image = pygame.Surface((32, 32))
self.rect = self.image.get_rect(topleft=(x, y))
self.y_velocity = 0
def update(self):
self.rect.y += self.y_velocity
self.y_velocity += GRAVITY # Apply gravity to y velocity Maintenant, à chaque fois que vous appelez la méthode update, la position du joueur sera mise à jour en fonction de sa vélocité et de sa gravité.
Pour faire sauter le sprite du joueur, vous pouvez lier l’action de saut à une touche ou un bouton spécifique et mettre à jour la vitesse du joueur avec une valeur négative. L’extrait de code suivant est un exemple de saut lorsqu’un joueur appuie sur la barre d’espace.
JUMP_VELOCITY = -10
# inside the game loop
if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
player.y_velocity = JUMP_VELOCITY Notez que vous devrez vérifier l’event.type pour vous assurer que l’événement est un événement KEYDOWN avant de vérifier la valeur de la touche.
Ajout de la physique de base comme la friction et l’accélération
Pour ajouter des éléments physiques de base tels que la friction et l’accélération à votre jeu de plateforme, vous devrez mettre à jour la vitesse x de votre sprite joueur à chaque image. Vous pouvez ajouter la vélocité x à la classe du joueur et la mettre à jour de la même façon que la vélocité y. Pour implémenter la friction, vous pouvez diminuer la vitesse x du sprite du joueur d’une petite quantité à chaque image. Par exemple, vous pouvez ajouter le bout de code suivant dans la méthode de mise à jour de la classe Player :
FRICTION = 0.9
class Player(pygame.sprite.Sprite):
def __init__(self, x, y):
super().__init__()
self.image = pygame.Surface((32, 32))
self.rect = self.image.get_rect(topleft=(x, y))
self.y_velocity = 0
self.x_velocity = 0
def update(self):
self.rect.y += self.y_velocity
self.rect.x += self.x_velocity
self.y_velocity += GRAVITY # Apply gravity to y velocity
self.x_velocity *= FRICTION # Apply friction to x velocity Pour mettre en œuvre l’accélération, vous pouvez définir une variable, player_movement, pour le mouvement horizontal, et mettre à jour la vitesse x du sprite du joueur en fonction de la valeur de player_movement. Pour ce faire, vous pouvez lier le mouvement à des touches ou des boutons spécifiques et mettre à jour la vitesse x du joueur dans la boucle d’événements, par exemple :
ACCELERATION = 0.5
player_movement = 0
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
player_movement = -1
elif event.key == pygame.K_RIGHT:
player_movement = 1
elif event.type == pygame.KEYUP:
if event.key in (pygame.K_LEFT, pygame.K_RIGHT):
player_movement = 0
player.x_velocity += player_movement * ACCELERATION En utilisant ces techniques, vous pouvez créer un jeu de plateforme simple mais amusant en utilisant les fonctions de détection de collision intégrées de Pygame et la physique de base. Avec un peu de créativité et d’expérimentation, vous pouvez utiliser ces techniques pour créer une variété de jeux et de mécanismes de jeu différents.
Vous pouvez trouver le code complet dans le dépôt GitHub.
Voici le résultat :
Améliorer l’engagement des utilisateurs grâce aux collisions
De nombreux jeux nécessitent une certaine forme de détection des collisions. Vous pouvez utiliser les collisions pour créer un large éventail de mécanismes de jeu, des simples plate-formes aux simulations complexes basées sur la physique.
L’implémentation de la physique de base, comme la gravité, la friction et l’accélération, peut également améliorer considérablement l’engagement de l’utilisateur, en ajoutant du réalisme et une sensation de poids aux objets du jeu.
