La plupart des jeux de plate-forme utilisent un certain type de saut, avec des variantes telles que le double saut et le saut à hauteur variable. Découvrez les techniques derrière ces mouvements.

Les mécanismes de saut jouent un rôle crucial dans l'amélioration de l'expérience de jeu d'un jeu de plateforme. En implémentant divers mécanismes de saut avec Python's Arcade Library, vous pouvez ajouter de la profondeur et de l'excitation à vos jeux.

La bibliothèque Arcade fournit un cadre intuitif et facile à utiliser pour créer des jeux, ce qui en fait un choix idéal pour créer votre plateforme.

Créer un jeu simple

Avant de commencer, installer pip sur votre appareil et utilisez cette commande pour installer le arcade module:

pip installer arcade

Pour explorer le fonctionnement des mécanismes de saut, commencez par créer un jeu simple dans lequel le joueur peut se déplacer de gauche à droite avec la gravité et une plate-forme statique.

Le code utilisé dans cet article est disponible dans ce Référentiel GitHub et est libre d'utilisation sous la licence MIT.

instagram viewer

Dans le jeu, le joueur entrera en collision avec la plate-forme et se tiendra dessus. Créer un nouveau fichier nommé jeu-simple.py et ajoutez le code ci-dessous :

importer arcade
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600
PLAYER_RADIUS = 20
PLATFORM_WIDTH = 200
PLATFORM_HEIGHT = 20
GRAVITÉ = 0.5
bleu = arcade.color. BLEU
vert = arcade.color. VERT


classeFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mécanique de saut")
 self.player_x = SCREEN_WIDTH // 2
 self.player_y = SCREEN_HEIGHT // 2
 self.player_dy = 0
 self.platform_x = SCREEN_WIDTH // 2
 self.platform_y = SCREEN_HEIGHT // 4


définitivementon_draw(soi):
 arcade.start_render()


 arcade.draw_circle_filled (self.player_x, self.player_y, 
 PLAYER_RADIUS, bleu)


 arcade.draw_rectangle_filled (self.platform_x, self.platform_y, 
 PLATFORM_WIDTH, PLATFORM_HEIGHT, vert)


définitivementon_update(soi, delta_time):
 self.player_dy -= GRAVITÉ
 self.player_y += self.player_dy
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


si self.player_y < dist :
 self.player_y = dist
 self.player_dy = 0
jeu = GameWindow()
arcade.run()

Lorsque vous exécutez le programme, vous verrez l'objet joueur tomber rapidement sur la plate-forme, puis rester au repos dessus.

Ajout d'une fonction de saut simple

Maintenant, ajoutez une fonction de saut simple au jeu. Vérifiez la collision entre le joueur et la plate-forme et déclencher l'action de saut lorsque le joueur appuie sur la touche fléchée vers le haut. Pour ce faire, créez un nouveau fichier nommé saut.py et le code avec les mises à jour ci-dessous :

classeFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi):
# ...
définitivementon_key_press(soi, clé, modificateurs):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


si clé == arcade.clé. EN HAUT et self.player_y == on_ground :
 self.player_dy = 10

définitivementon_update(soi, delta_time):
 self.player_dy -= GRAVITÉ
 self.player_y += self.player_dy
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2
si self.player_y < dist :
 self.player_y = dist
 self.player_dy = 0
 self.jump_count = 0

Ajout d'une fonctionnalité de double saut

Pour ajouter une fonctionnalité de double saut, étendez la logique de saut existante. Lorsque le joueur est sur la plate-forme et appuie pour la première fois sur la touche fléchée vers le haut, il effectuera un saut normal. Cependant, s'il appuie à nouveau sur la touche fléchée vers le haut alors qu'il est en l'air, le joueur exécutera un double saut.

Créer un nouveau fichier nommé double-jump.py et le code avec les mises à jour ci-dessous :

classeFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi):
 self.jump_count = 0# Suivre le nombre de sauts
définitivementon_key_press(soi, clé, modificateurs):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2
si clé == arcade.clé. EN HAUT:
si self.player_y == on_ground ou self.jump_count < 2:
 self.player_dy = 10
 self.jump_count += 1

Inclure des fonctionnalités supplémentaires

Outre les sauts simples et doubles, vous pouvez ajouter de nombreuses fonctionnalités pour améliorer les mécanismes de saut de votre jeu.

Implémentation d'une hauteur de saut variable

Permettre au joueur de contrôler la hauteur de ses sauts en fonction de la durée pendant laquelle il maintient le bouton de saut peut ajouter plus de contrôle et de stratégie au gameplay. Voici un exemple de la façon dont vous pouvez implémenter une hauteur de saut variable. Créer un nouveau fichier nommé variable-jump.py et le code avec les mises à jour ci-dessous :

GRAVITÉ = 0.5
JUMP_POWER_INCREMENT = 0.2
MAX_JUMP_POWER = 100
classeFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mécanique de saut")
 self.jump_pressed = FAUX
 self.jump_power = 0


définitivementon_key_press(soi, clé, modificateurs):
 on_ground = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


si clé == arcade.clé. EN HAUT et self.player_y == on_ground :
 self.jump_pressed = Vrai


définitivementon_key_release(soi, clé, modificateurs):
si clé == arcade.clé. EN HAUT:
 self.jump_pressed = FAUX


définitivementmise à jour_jump_power(soi):
# Augmentez la puissance de saut pendant que le bouton de saut est maintenu
si self.jump_pressed :
 self.jump_power += JUMP_POWER_INCREMENT


si self.jump_power > MAX_JUMP_POWER :
 self.jump_power = MAX_JUMP_POWER
autre:
si self.jump_power > 0:
 self.jump_power -= 1


définitivementon_update(soi, delta_time):
 self.player_dy -= GRAVITÉ
 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


si self.player_y == dist et self.jump_power > 0:
 self.player_dy = self.jump_power
 self.player_y += self.player_dy
 self.update_jump_power()

Mise en œuvre de la fonctionnalité Air Dash

L'ajout d'un mécanisme de tiret aérien peut donner au joueur des options de mobilité supplémentaires lorsqu'il est en l'air. Créer un nouveau fichier nommé air-dash.py et le code avec les mises à jour ci-dessous :

AIR_DASH_DISTANCE = 100
MAX_AIR_DASHES = 2
classeFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi):
 super().__init__(SCREEN_WIDTH, SCREEN_HEIGHT, "Mécanique de saut")
 self.on_ground = FAUX
 self.air_dash = 0
 self.can_air_dash = Vrai


définitivementon_key_press(soi, clé, modificateurs):
si clé == arcade.clé. EN HAUT et self.on_ground :
 self.player_dy = 10
elif clé == arcade.clé. EN HAUT et \
 self.air_dashes < MAX_AIR_DASHES et \
 self.can_air_dash :
 self.player_dx = AIR_DASH_DISTANCE 
 self.air_dash += 1
 self.can_air_dash = FAUX


définitivementon_update(soi, delta_time):
 self.player_dy -= GRAVITÉ
 self.player_y += self.player_dy


 dist = PLAYER_RADIUS + self.platform_y + PLATFORM_HEIGHT / 2


si self.player_y <= dist :
 self.player_y = dist
 self.player_dy = 0
 self.on_ground = Vrai
autre:
 self.on_ground = FAUX


 self.player_x += self.player_dx


si self.player_x < PLAYER_RADIUS :
 self.player_x = PLAYER_RADIUS
 self.player_dx = 0
elif self.player_x > SCREEN_WIDTH - PLAYER_RADIUS :
 self.player_x = SCREEN_WIDTH - PLAYER_RADIUS
 self.player_dx = 0
si self.on_ground :
 self.air_dash = 0
 self.can_air_dash = Vrai

Lorsque vous effectuez le tiret aérien, votre personnage joueur s'éloignera de la plate-forme :

Meilleures pratiques pour la mécanique de saut

La mise en œuvre de mécanismes de saut dans un jeu nécessite une attention particulière pour garantir une expérience de jeu fluide et agréable. Voici quelques bonnes pratiques à garder à l'esprit :

Équilibrer la hauteur et la durée du saut

Pour maintenir un sentiment de réalisme et de difficulté de jeu, il est important d'équilibrer la hauteur et la durée du saut. Un saut trop haut ou trop court peut avoir un impact négatif sur le gameplay. Expérimentez avec différentes hauteurs et durées de saut pour trouver le bon équilibre pour votre jeu.

Tenez compte de la physique du jeu, des capacités des personnages et de la conception globale des niveaux lors de la détermination des mécanismes de saut appropriés.

Fournir des commentaires visuels et audio

Le retour visuel et audio est crucial pour que les sauts soient réactifs et satisfaisants. Utilisez des animations ou des effets de particules pour représenter le mouvement de saut et l'atterrissage du joueur.

De plus, considérez ajouter des effets sonores ou une musique de fond qui améliore l'expérience de saut. Ces repères visuels et sonores contribuent à l'immersion et à l'engagement des joueurs.

Détection précise des collisions

Une détection précise des collisions entre le joueur et les plates-formes est essentielle pour une mécanique de saut précise et fiable. Assurez-vous que l'algorithme de détection de collision est robuste et gère correctement divers scénarios, tels que l'atterrissage sur une plate-forme, la collision avec des obstacles ou la glissade le long des murs.

Testez et réitérez votre code de détection de collision pour éliminer tout problème ou incohérence pouvant affecter la mécanique de saut.

Rendez les jeux plus amusants avec les mécanismes de saut

L'ajout de mécanismes de saut peut grandement améliorer l'engagement et le plaisir d'un jeu. Il ouvre de nouvelles possibilités pour la conception de niveaux, les énigmes et les obstacles difficiles. En implémentant différents mécanismes de saut dans la bibliothèque de jeux d'arcade de Python, vous pouvez créer des jeux de plateforme captivants qui divertiront les joueurs pendant des heures.

N'oubliez pas que l'expérimentation de différents mécanismes de saut et l'intégration de fonctionnalités uniques peuvent différencier votre jeu et en faire une expérience immersive et mémorable pour les joueurs.