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

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 "mourir" (être supprimés) ou non 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, Vrai)

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 (groupe1, groupe2, Vrai, Vrai)

Création d'un jeu de plateforme de base à l'aide de la fonction spritecollide

Pour créer un jeu de plate-forme de base à l'aide de Pygame, vous devez 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.

Commencer, installer le module pygame en utilisant pip:

pip installer pygame

Après cela, créer des classes simples pour le lecteur et la plate-forme, qui doivent tous 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 de pygame.sprite. Module Sprites. 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.

importer pygame
classeJoueur(pygame.sprite. Lutin):
définitivement__init__(soi, x, y):
 super().__init__()
 self.image = pygame. Surface((32, 32))
 self.rect = self.image.get_rect (en haut à gauche=(x, y))
 self.y_velocity = 0
définitivementmise à jour(soi):
 self.rect.y += self.y_velocity

Classe de plate-forme

La classe Platform utilise également le pygame.sprite. Module Sprites. Cette classe initialisera la plate-forme avec des coordonnées x et y données, ainsi qu'une largeur et une hauteur.

classePlateforme(pygame.sprite. Lutin):
définitivement__init__(soi, x, y, largeur, hauteur):
 super().__init__()
 self.image = pygame. Surface((largeur, hauteur))
 self.rect = self.image.get_rect (en haut à gauche=(x, y))

La boucle de jeu

La boucle de jeu vous permettra de créer une fenêtre d'une taille de 640x480. 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.

joueur = joueur(100, 300)
player_group = pygame.sprite. Groupe()
player_group.add (joueur)
plate-forme = plate-forme (50, 400, 100, 20)
platform_group = pygame.sprite. Groupe()
platform_group.add (plate-forme)
# Initialiser pygame et créer une fenêtre
pygame.init()
écran = pygame.display.set_mode((640, 480))
# Boucle de jeu principale
courir = Vrai
alors que en cours d'exécution:
pour événement dans pygame.event.get() :
si événement.type == pygame. ARRÊTER:
 courir = FAUX

 player_group.update()
 collided = pygame.sprite.spritecollide (joueur, platform_group, FAUX)
si est entré en collision :
 joueur.y_velocity = 0
 screen.fill((255, 255, 255))
 player_group.draw (écran)
 platform_group.draw (écran)
 pygame.display.flip()
pygame.quit()

Ci-dessous la sortie :

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 y à 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 :

classeJoueur(pygame.sprite. Lutin):
définitivement__init__(soi, x, y):
 super().__init__()
 self.image = pygame. Surface((32, 32))
 self.rect = self.image.get_rect (en haut à gauche=(x, y))
 self.y_velocity = 0
définitivementmise à jour(soi):
 self.rect.y += self.y_velocity
 self.y_velocity += GRAVITÉ # Appliquer la gravité à la vitesse y

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
# dans la boucle du jeu
si événement.type == pygame. TOUCHE BAS et event.key == pygame. K_ESPACE :
 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 :

FROTTEMENT = 0.9
classeJoueur(pygame.sprite. Lutin):
définitivement__init__(soi, x, y):
 super().__init__()
 self.image = pygame. Surface((32, 32))
 self.rect = self.image.get_rect (en haut à gauche=(x, y))
 self.y_velocity = 0
 self.x_velocity = 0
définitivementmise à jour(soi):
 self.rect.y += self.y_velocity
 self.rect.x += self.x_velocity
 self.y_velocity += GRAVITÉ # Appliquer la gravité à la vitesse y
 self.x_velocity *= FROTTEMENT # Appliquer la friction à la vitesse x

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énement, par exemple :

ACCÉLÉRATION = 0.5
player_movement = 0
si événement.type == pygame. TOUCHE BAS:
si event.key == pygame. K_GAUCHE :
 player_movement = -1
elif event.key == pygame. K_DROITE :
 player_movement = 1
elif événement.type == pygame. KEYUP :
si event.key dans (pygame. K_LEFT, pygame. K_DROITE) :
 player_movement = 0

player.x_velocity += player_movement * ACCÉLÉRATION

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 trouverez le code complet dans le Référentiel GitHub.

Ci-dessous la sortie :

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.