Quel est l'intérêt d'un match sans score? Certains peuvent s'en passer, mais la plupart des jeux que vous créerez devront dire au joueur à quel point ils s'en sortent.

Les scores font partie intégrante de nombreux jeux car ils fournissent une mesure des progrès et des réalisations des joueurs.

En Python, la bibliothèque Arcade offre un moyen simple et efficace de gérer les scores dans les jeux. En gérant efficacement les scores, vous pouvez améliorer l'engagement des utilisateurs et offrir une expérience de jeu plus immersive.

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

Maintenant, créez un jeu simple en utilisant la bibliothèque Arcade de Python.

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

Dans ce jeu, le joueur peut se déplacer à gauche et à droite à l'aide des touches fléchées, tandis qu'un obstacle est placé sur le même axe y.

importer arcade
# Configurer les dimensions de la fenêtre
SCREEN_WIDTH = 800
SCREEN_HEIGHT = 600


classeMon jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
 super().__init__(largeur, hauteur)
 self.player_x = largeur // 3
 auto.score = 0


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


définitivementmise à jour(soi, delta_time):
# Mettre à jour la logique du jeu ici
passer


définitivementon_draw(soi):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, 50, 20, arcade.color. BLEU)
 arcade.draw_rectangle_filled(400, 50, 100, 50, arcade.color. ROUGE)


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

Suivi et calcul des scores

Pour suivre le score dans votre jeu, vous pouvez créer un mécanisme pour augmenter le score chaque fois qu'une condition spécifique est remplie. Par exemple, le score augmente chaque fois que le joueur se déplace dans votre jeu et touche avec succès l'obstacle. Vous pouvez changer le mise à jour méthode pour inclure la logique de calcul du score :

classeMon jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
 super().__init__(largeur, hauteur)
 self.player_x = largeur // 3
 auto.score = 0
définitivementon_key_press(soi, clé, modificateurs):
si clé == arcade.clé. GAUCHE:
 self.player_x -= 10
elif clé == arcade.clé. DROITE:
 self.player_x += 10
définitivementmise à jour(soi, delta_time):
si self.player_x > 330et self.player_x < 470:
 auto.score += 1

Affichage du score

Pour afficher le score au joueur, modifiez le on_draw méthode pour inclure un rendu de texte :

classeMon jeu(arcade. Fenêtre):
# ...
définitivementon_draw(soi):
 arcade.start_render()
 arcade.draw_circle_filled (self.player_x, 50, 20, arcade.color. BLEU)
 arcade.draw_rectangle_filled(400, 300, 100, 50, arcade.color. ROUGE)
 score_text = f"Score: {self.score}"
 arcade.draw_text (texte_partition, 10, 10, arcade.color. BLANC, 14)

En ajoutant le code ci-dessus, vous pouvez afficher le score dans le coin inférieur gauche de la fenêtre du jeu.

Stockage du meilleur score

Pour donner un sentiment d'accomplissement et de compétition aux joueurs, il est essentiel de stocker et d'afficher le meilleur score. Vous pouvez utiliser une approche simple basée sur des fichiers pour cela.

Utilisez le load_high_score méthode pour lire le meilleur score à partir d'un fichier appelé high_score.txt et retournez-le. Après cela, vous pouvez enregistrer le nouveau meilleur score dans le fichier à l'aide de la save_high_score méthode.

classeMon jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
 super().__init__(largeur, hauteur)
 self.player_x = largeur // 3
 auto.score = 0
 self.high_score = self.load_high_score()
définitivementload_high_score(soi):
essayer:
avec ouvrir("high_score.txt", "r") comme déposer:
retour entier (fichier.read())
sauf FileNotFoundError :
retour0


définitivementsave_high_score(soi):
avec ouvrir("high_score.txt", "w") comme déposer:
 fichier.write (str (self.high_score))


définitivementmise à jour(soi, delta_time):
# ...
si self.score > self.high_score :
 self.high_score = self.score
 self.save_high_score()

Affichage du meilleur score

Semblable à l'affichage du score actuel, vous pouvez ajouter un rendu de texte pour afficher le meilleur score :

classeMon jeu(arcade. Fenêtre):
# ...
définitivementon_draw(soi):
# ...
 high_score_text = f"Score élevé: {self.high_score}"
 arcade.draw_text (high_score_text, 10, 30, arcade.color. BLANC, 14)

En incluant le code ci-dessus dans le on_draw méthode, vous pouvez afficher le meilleur score juste au-dessus du score actuel.

Inclure des fonctionnalités supplémentaires

La gestion des scores dans les jeux implique souvent l'intégration de fonctionnalités supplémentaires pour rendre le gameplay plus attrayant et dynamique. Explorons quelques exemples de la façon dont vous pouvez introduire des fonctionnalités supplémentaires en plus de la gestion des scores dans votre jeu.

Mises sous tension

Les power-ups sont des objets spéciaux qui accordent aux joueurs des avantages temporaires ou des points bonus. Créé un activer_power_up méthode qui déclenche l'activation de la mise sous tension, en définissant la power_up_active drapeau sur Vrai.

Vous pouvez programmer le désactiver_power_up méthode à exécuter après une certaine durée (par exemple, 10 secondes) à l'aide de la arcade.horaire fonction. Pendant la période active de la mise sous tension, vous pouvez utiliser le apply_power_up_effects méthode pour implémenter des améliorations de gameplay spécifiques.

Voici un exemple d'implémentation d'une fonctionnalité de mise sous tension dans votre jeu.

classeMon jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
 super().__init__(largeur, hauteur)
 self.player_x = largeur // 3
 auto.score = 0
 self.power_up_active = FAUX
définitivementmise à jour(soi, delta_time):
si self.power_up_active :
# Appliquer des effets de mise sous tension pendant le jeu
 self.apply_power_up_effects()
 auto.score += 10


définitivementapply_power_up_effects(soi):
# Ajoutez ici une logique spécifique à la mise sous tension
passer


définitivementactiver_power_up(soi):
 self.power_up_active = Vrai
# Définir une minuterie ou une durée pour l'effet de mise sous tension
 arcade.schedule (self.deactivate_power_up, 10.0)
définitivementdésactiver_power_up(soi, delta_time):
 self.power_up_active = FAUX

Système combiné

Un système de combo récompense les joueurs pour avoir réalisé des actions réussies consécutives ou des multiplicateurs de score. Créé un augmenter_combo_counter méthode qui incrémente le compteur de combo et augmente le score en fonction du niveau de combo actuel.

Vous pouvez appeler le reset_combo_counter méthode et remettre le compteur combo à zéro à chaque fois qu'une action infructueuse se produit. Voici une implémentation simple d'un système combo :

classeMon jeu(arcade. Fenêtre):
définitivement__init__(soi, largeur, hauteur):
 super().__init__(largeur, hauteur)
 self.player_x = largeur // 3
 auto.score = 0
 self.combo_counter = 0
définitivementmise à jour(soi, delta_time):
# Vérifier les actions réussies
si self.check_successful_action() :
 self.increase_combo_counter()
autre:
 self.reset_combo_counter()


définitivementaugmenter_combo_counter(soi):
 self.combo_counter += 1
 self.score += self.combo_counter
définitivementreset_combo_counter(soi):
 self.combo_counter = 0

En incorporant des fonctionnalités supplémentaires telles que des power-ups et des systèmes de combo, vous pouvez ajouter de la profondeur et de l'excitation à votre jeu, offrir aux joueurs des incitations supplémentaires pour améliorer leurs performances, élaborer des stratégies pour leurs actions et atteindre des objectifs plus élevés scores.

Meilleures pratiques pour la gestion des scores

Lorsqu'il s'agit de gérer les scores dans les jeux, suivre les meilleures pratiques peut aider à créer une expérience plus agréable et engageante pour les joueurs. Voici quelques pratiques clés à considérer :

Mécanismes de notation significatifs

Concevez des mécanismes de notation qui s'alignent sur les objectifs du jeu et fournissent des commentaires significatifs aux joueurs. Le système de notation doit refléter les progrès, les compétences et les réalisations du joueur dans le jeu.

Envisagez d'attribuer différentes valeurs de points à différentes actions ou événements en fonction de leur difficulté ou de leur importance pour le gameplay.

Rétroaction visuelle

Fournissez un retour visuel aux joueurs lorsque le score change. Vous pouvez y parvenir grâce à des notifications à l'écran, des animations ou des effets de particules. Les repères visuels créent un sentiment d'accomplissement et renforcent les actions du joueur, augmentant son engagement dans le jeu.

Effets sonores et animations

Intégrer effets sonores dans votre jeu liés aux mises à jour des scores pour rendre l'expérience plus immersive. Par exemple, jouez un effet sonore de fête ou affichez une rafale de confettis lorsque le joueur atteint une étape importante. Ces éléments audiovisuels ajoutent de l'excitation et renforcent la boucle de rétroaction positive pour les joueurs.

Équilibrer la difficulté et l'échelle des scores

Assurer une relation équilibrée entre la difficulté et l'échelle des scores. Au fur et à mesure que les joueurs progressent dans le jeu ou rencontrent des obstacles plus difficiles, ajustez le système de notation en conséquence. La mise à l'échelle du score en fonction de la courbe de difficulté du jeu permet de maintenir une expérience équitable et enrichissante pour les joueurs.

En adhérant à ces meilleures pratiques, vous pouvez gérer efficacement les scores de votre jeu, fournir aux joueurs des commentaires significatifs et créer une expérience enrichissante et engageante.

Améliorez l'engagement dans le jeu avec le suivi des scores

En implémentant le suivi des scores dans votre jeu, vous pouvez considérablement améliorer l'engagement des joueurs. Les scores donnent un sentiment d'accomplissement, encouragent la rejouabilité et favorisent la compétition entre les joueurs.

Affichez les scores en évidence et récompensez les réalisations élevées - vous motiverez les joueurs à s'efforcer d'obtenir de meilleures performances et à améliorer leurs compétences.