Qu'une collision accorde une mise sous tension ou mène à la fin du jeu, vous devez être capable de la détecter. Voici comment procéder avec la bibliothèque d'arcade de Python.

Les collisions sont un aspect fondamental du gameplay dans de nombreux genres de jeux vidéo. Ils ajoutent une couche de défi et d'excitation aux jeux, obligeant les joueurs à franchir des obstacles, à esquiver des ennemis et à collecter des récompenses.

La mise en œuvre de la détection et de la gestion des collisions dans vos jeux est cruciale pour créer des mécanismes de jeu réalistes et dynamiques qui maintiennent les joueurs engagés et divertis. Vous pouvez facilement détecter les collisions avec la bibliothèque d'arcade, en utilisant ses fonctions intégrées.

Créer un jeu simple

Avant de commencer, assurez-vous d'avoir pip installé sur votre appareil. Utilisez cette commande pour installer la bibliothèque d'arcade :

pip installer arcade

Après cela, créez un jeu où le joueur peut se déplacer à gauche et à droite pour éviter d'entrer en collision avec un rectangle ennemi. Vous pouvez utiliser la fonction de dessin intégrée pour les sprites.

instagram viewer

Vous pouvez retrouver l'intégralité code dans ce référentiel GitHub.

Voici le code du jeu :

importer arcade
SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
MOUVEMENT_SPEED = 5


classeMon jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
 super().__init__(largeur, hauteur, "Mon jeu")
 arcade.set_background_color (arcade.color. BLANC)
 self.player = arcade. SpriteSolidColor(50, 50, arcade.color. BLEU)
 self.player.center_x = SCREEN_WIDTH // 3
 self.player.center_y = 50
 self.enemy = arcade. SpriteSolidColor(50, 50, arcade.color. ROUGE)
 self.enemy.center_x = SCREEN_WIDTH // 2
 self.enemy.center_y = 50


définitivementon_draw(soi):
 arcade.start_render()
 self.player.draw()
 self.enemy.draw()


définitivementon_key_press(soi, clé, modificateurs):
si clé == arcade.clé. GAUCHE:
 self.player.center_x -= MOVEMENT_SPEED
elif clé == arcade.clé. DROITE:
 self.player.center_x += MOVEMENT_SPEED


définitivementmise à jour(soi, delta_time):
si arcade.check_for_collision (self.player, self.enemy):
 imprimer("Jeu terminé")


définitivementprincipal():
 jeu = MonJeu (SCREEN_WIDTH, SCREEN_HEIGHT)
 arcade.run()
si __nom__ == "__principal__":
 principal()

Fonctionnalités de détection de collision d'Arcade

La bibliothèque Arcade fournit un moyen simple de détecter les collisions entre les sprites. Le check_for_collision La fonction prend deux sprites comme arguments et renvoie une valeur booléenne indiquant si les sprites sont entrés en collision. Vous pouvez utiliser cette fonction pour détecter les collisions entre le joueur et les sprites ennemis dans votre jeu.

Vous pouvez changer le mise à jour méthode pour vérifier les collisions entre le joueur et les sprites ennemis. Si la bibliothèque détecte une collision, vous pouvez imprimer Jeu terminé à la console.

Voici le code mis à jour :

définitivementmise à jour(soi, delta_time):
si arcade.check_for_collision (self.player, self.enemy):
 imprimer("Jeu terminé")
autre:
 self.player.update()

Avec ce changement, votre jeu détectera les collisions et imprimera Jeu terminé texte si le joueur entre en collision avec l'ennemi.

Ajouter plus de fonctionnalités

Pour rendre votre jeu plus attrayant, vous pouvez ajouter des fonctionnalités supplémentaires telles que le score, les bonus et plusieurs ennemis.

Par exemple, vous pouvez créer une liste d'ennemis et mettre à jour le jeu pour faire apparaître de nouveaux ennemis à des positions aléatoires après chaque collision. Tu peux déplacer le joueur gauche et droite pour éviter l'ennemi et marquer un point. Voici un exemple de la façon dont vous pouvez implémenter ces fonctionnalités :

importer aléatoire
classeMon jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
 super().__init__(largeur, hauteur, "Mon jeu")
 arcade.set_background_color (arcade.color. BLANC)
 self.player = arcade. SpriteSolidColor(50, 50, arcade.color. BLEU)
 self.player.center_x = SCREEN_WIDTH // 2
 self.player.center_y = 50
 self.enemies = arcade. SpriteListe()
 auto.score = 0
pour je dans gamme(3):
 ennemi = arcade. SpriteSolidColor(50, 50, arcade.color. ROUGE)
 ennemi.center_x = random.randint(0, SCREEN_WIDTH)
 ennemi.center_y = random.randint (SCREEN_HEIGHT // 2, SCREEN_HEIGHT)
 self.enemies.append (ennemi)
définitivementon_draw(soi):
 arcade.start_render()
 self.player.draw()
 self.enemies.draw()
 arcade.draw_text(f"Score: {self.score}", 10, SCREEN_HEIGHT - 30, arcade.color. NOIR, 16)
définitivementmise à jour(soi, delta_time):
si arcade.check_for_collision_with_list (self.player, self.enemies):
 imprimer("Jeu terminé")
 arcade.close_window()
autre:
 self.player.update()
pour ennemi dans soi.ennemis :
 ennemi.center_y -= VITESSE_DEMOUVEMENT / 2
si ennemi.center_y < 0:
 ennemi.center_x = random.randint(0, SCREEN_WIDTH)
 ennemi.center_y = random.randint (SCREEN_HEIGHT // 2, SCREEN_HEIGHT)
 auto.score += 1

Avec ces changements, votre jeu a maintenant plusieurs ennemis qui apparaissent à des positions aléatoires et se déplacent vers le bas. Le joueur gagne un point pour chaque ennemi évité avec succès, et le jeu se termine si le joueur entre en collision avec un ennemi.

Améliorez l'engagement des utilisateurs avec les collisions

En ajoutant des fonctionnalités de détection et de gestion des collisions à vos jeux, vous pouvez créer des expériences de jeu plus immersives et stimulantes pour les joueurs. Des simples jeux d'évitement et de collecte aux jeux de plateforme et de tir plus complexes, les collisions jouent un rôle crucial dans la création de mécanismes de jeu attrayants et satisfaisants.

Donc, si vous souhaitez créer des jeux plus attrayants et immersifs qui incitent les joueurs à revenir, envisagez d'intégrer des fonctionnalités de détection de collision dans vos mécanismes de jeu.