Implémentation de la physique de base et de la détection de collision dans Pygame

2023/01/23

Pygame fournit plusieurs fonctions intégrées pour détecter les collisions entre les objets du jeu. Celles-ci sont inestimables car déterminer exactement quand et comment les objets en mouvement se chevauchent peut être une tâche compliquée.

Apprenez à ajouter la physique de base et les collisions dans votre jeu à l’aide du module pygame.

Fonctions de détection de collision intégrées de Pygame

La fonction de détection de collision intégrée la plus basique est spritecollide. Il prend en compte 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 :

collided_sprites = pygame.sprite.spritecollide(sprite1, sprite_group, True)

Une autre fonction de détection de collision utile est groupcollide, qui prend également en compte deux groupes de sprites et une valeur booléenne. Cette fonction renvoie un dictionnaire avec les sprites 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 de base à l’aide de la fonction spritecollide

Pour créer un jeu de plateforme de base à l’aide de Pygame, vous devrez créer un sprite de joueur que l’utilisateur peut contrôler et un sprite de plate-forme sur lequel le joueur peut se tenir. Vous pouvez utiliser la fonction spritecollide pour détecter quand 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 en utilisant pip :

pip install pygame

Après cela, créez des classes simples pour le lecteur 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 la vitesse. De plus, il devrait avoir 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 à l’aide du module pygame.sprite.Sprite. Cette classe initialisera le lecteur avec des coordonnées x et y données. Ensuite, la méthode de mise à jour 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 plate-forme

La classe Platform utilise également le module pygame.sprite.Sprite. Cette classe initialisera 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 de jeu

La boucle de jeu vous permettra de créer une fenêtre d’une taille de 640×480. Ensuite, il exécutera une boucle qui vérifiera tous les événements, tels qu’une commande de sortie. Il vérifiera également les éventuelles collisions entre le joueur et la plate-forme. Enfin, il remplira l’écran d’une couleur blanche, dessinera le joueur et la plate-forme, puis retournera 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()

Ci-dessous la sortie :

jeu de plateforme simple utilisant pygame

Mise en œuvre de la gravité et du comportement de saut

Pour implémenter la gravité et le comportement de saut dans votre jeu de plateforme, vous devrez ajouter une vitesse ay à votre sprite de joueur et mettre à jour sa position y dans chaque image. Pour ce faire, vous pouvez utiliser la méthode update dans la classe Player et ajouter l’extrait 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

Désormais, chaque fois que vous appelez la méthode de mise à jour, elle met à jour la position du joueur en fonction de sa vitesse 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 y du joueur avec une valeur négative. L’extrait de code suivant est un exemple de la façon de sauter 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 event.type pour vous assurer que l’événement est un événement KEYDOWN avant de vérifier la valeur de la clé.

Ajout de la physique de base telle que la friction et l’accélération

Pour ajouter une physique de base telle que la friction et l’accélération à votre jeu de plateforme, vous devrez mettre à jour la vitesse x de votre sprite de joueur dans chaque image. Vous pouvez ajouter la vitesse x à la classe de joueur et la mettre à jour de la même manière que la vitesse y. Pour implémenter la friction, vous pouvez diminuer la vitesse x du sprite du joueur d’une petite quantité dans chaque image. Par exemple, vous pouvez ajouter l’extrait de code suivant dans la méthode update 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 implémenter 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 player_movement. Vous pouvez le faire en liant le mouvement à des touches ou des boutons spécifiques et en mettant à 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 et la physique de base de Pygame. 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 référentiel GitHub.

Ci-dessous la sortie :

jeu de plateforme simple avec gravité et accélération

Améliorez l’engagement des utilisateurs avec les collisions

De nombreux jeux nécessitent une certaine forme de détection de collision. Vous pouvez utiliser les collisions pour créer un large éventail de mécanismes de jeu, des simples plateformes aux simulations complexes basées sur la physique.

La mise en œuvre de la physique de base telle que 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.