Afficher et mettre à jour un score de jeu dans Pygame

Dans ce didacticiel, vous apprendrez à afficher et à mettre à jour les scores de jeu dans Pygame, une bibliothèque Python populaire pour le développement de jeux. À la fin, vous pourrez créer un simple jeu de sauts et afficher le score du joueur à l'écran au fur et à mesure de sa progression. Le jeu suit la saisie au clavier afin que vous puissiez déplacer le joueur de gauche à droite à l'aide des touches fléchées.

Créer un jeu simple

Avant de pouvoir afficher et mettre à jour les scores dans Pygame, vous devez d'abord créer un jeu avec lequel travailler. Dans ce didacticiel, vous allez créer un jeu simple dans lequel un joueur peut se déplacer à gauche ou à droite. Mais avant cela, vous devriez avoir pip installé sur votre appareil. Après avoir installé pip, exécutez la commande ci-dessous pour installer le module pygame :

pépin installer pygame

Pour commencer, importez les modules nécessaires et configurez la structure de base du jeu :

importer pygame, système
pygame.init()
# Configurer la fenêtre
écran = pygame.display.set_mode((750, 450))
# Configurer l'horloge de jeu
horloge = pygame.heure. Horloge()
# Configurer le personnage du joueur
joueur = pygame. Rect(100, 200, 50, 50)
# Mettre en place l'obstacle
obstacle = pygame. Rect(200, 200, 50, 50)
# Configurer la boucle de jeu
alors queVrai:
# Gérer les événements
pour événement dans pygame.event.get() :
si événement.type == pygame. ARRÊTER:
 pygame.quit()
 sys.exit()
si événement.type == pygame. TOUCHE BAS:
si event.key == pygame. K_GAUCHE :
 joueur.x -= 10
elif event.key == pygame. K_DROITE :
 joueur.x += 10

# Mettre à jour l'état du jeu
# Dessinez le jeu
 screen.fill((0, 0, 0))
 pygame.draw.rect (écran, (255, 0, 0), joueur)
 pygame.draw.rect (écran, (0, 255, 0), obstacle)

# Mettre à jour l'affichage
 pygame.display.flip()

# Limiter la fréquence d'images
 horloge.tick(60)

Avec ce code squelette, votre jeu de base est jouable. Appuyez à gauche ou à droite pour déplacer le personnage du joueur, représenté par le carré rouge.

Affichage et mise à jour du score du jeu

Maintenant que vous avez configuré un jeu de base, ajoutez un système de notation et affichez le score à l'écran.

Configuration de Pygame pour le rendu de texte

Pour afficher du texte dans Pygame, nous devons d'abord importer les modules nécessaires et initialiser le module de police. Pour ce faire, utilisez le code suivant en haut de votre script :

importer pygame
importer système
importer os
pygame.init()
pygame.font.init()

Le module pygame.font vous permet d'utiliser les capacités de rendu de texte de Pygame, et la fonction pygame.init() initialise le module de police.

Création d'un système de notation de base

Ensuite, créez un système de notation de base pour votre jeu. Pour cela, déclarez et initialisez deux variables: score et score_increment. La variable score gardera une trace du score actuel du joueur, et la variable score_increment spécifiera de combien le score devrait augmenter chaque fois que le joueur touche un obstacle.

Ajoutez le code suivant en haut de votre script, sous les importations :

note = 0
score_incrément = 10

Ensuite, mettez à jour le score au fur et à mesure que le jeu progresse. Dans la boucle de jeu, vous pouvez vérifier si le personnage du joueur entre en collision avec l'obstacle. Si tel est le cas, incrémentez le score du montant spécifié dans la variable score_increment.

Mettez à jour la boucle de jeu pour inclure le code suivant :

# Mettre à jour l'état du jeu
si player.colliderect (obstacle):
 score += score_incrément

Ce code vérifie si le personnage du joueur entre en collision avec l'obstacle. Si tel est le cas, il incrémente le score du montant spécifié.

Afficher la partition à l'écran avec le module Police

Maintenant que nous avons mis en place un système de notation de base, affichons le score à l'écran à l'aide du module de police.

Tout d'abord, configurons l'objet font en ajoutant le code suivant en haut de la boucle du jeu :

# Configurer l'objet police
police = pygame.font. Police de caractère(Aucun, 36)

Ce code crée un objet de police avec une taille de 36 pixels et aucune famille de polices spécifiée. Vous pouvez personnaliser la police et la taille de police en spécifiant un fichier de police et une taille différents dans la fonction Font().

Ensuite, dessinons la partition à l'écran. Ajoutez le code suivant à la boucle de jeu, après avoir mis à jour l'état du jeu et rempli l'écran :

# Dessinez le score à l'écran
score_text = font.render(f'Score: {score}', Vrai, (255, 255, 255))
screen.blit (texte_score, (10, 10))

Ce code utilise la méthode render() de l'objet font pour créer une surface de texte contenant la partition, puis blit (dessine) la surface de texte à l'écran à la position (10, 10).

Personnalisation de l'apparence du texte de la partition

Enfin, personnalisez l'apparence du texte de la partition en choisissant une police et une taille de police et en modifiant la couleur du texte.

Pour choisir une police et une taille de police spécifiques, transmettez le fichier de police et la taille comme arguments à la fonction Font() :

police = pygame.font. Police de caractère('arial.ttf', 48)

Vous pouvez facilement télécharger différents fichiers de polices à partir d'Internet. Après le téléchargement, placez simplement le fichier de police à la racine de votre répertoire de travail.

Pour changer la couleur du texte, passez un tuple de couleur comme troisième argument à la méthode render() :

score_text = font.render(f'Score: {score}', Vrai, (0, 255, 0))

Et c'est tout! Avec ces modifications, vous devriez maintenant disposer d'un système de score de jeu entièrement fonctionnel qui affiche le score à l'écran et le met à jour au fur et à mesure que le joueur progresse dans le jeu. Vous pouvez personnaliser davantage l'apparence du texte de la partition en expérimentant différentes familles, tailles et couleurs de polices.

Suivi des scores dans le jeu

Vous trouverez ci-dessous le code de travail complet, vous pouvez également trouver le code sur ce GitHub dépôt.

importer pygame
importer os
pygame.init()
pygame.font.init()
note = 0
score_incrément = 10
# Configurer la fenêtre
écran = pygame.display.set_mode((750, 450))
# Configurer l'horloge de jeu
horloge = pygame.heure. Horloge()
# Configurer le personnage du joueur
joueur = pygame. Rect(100, 200, 50, 50)
# Mettre en place l'obstacle
obstacle = pygame. Rect(200, 200, 50, 50)
# Configurer la boucle de jeu
alors queVrai:
 police = pygame.font. Police de caractère(Aucun, 36)
# Gérer les événements
pour événement dans pygame.event.get() :
si événement.type == pygame. ARRÊTER:
 pygame.quit()
 sys.exit()
si événement.type == pygame. TOUCHE BAS:
si event.key == pygame. K_GAUCHE :
 joueur.x -= 10
elif event.key == pygame. K_DROITE :
 joueur.x += 10

# Mettre à jour l'état du jeu
si player.colliderect (obstacle):
 score += score_incrément

# Dessinez le jeu
 screen.fill((0, 0, 0))
 pygame.draw.rect (écran, (255, 0, 0), joueur)
 pygame.draw.rect (écran, (0, 255, 0), obstacle)
# Dessinez le score à l'écran
 score_text = font.render(f'Score: {score}', Vrai, (255, 255, 255))
 screen.blit (texte_score, (10, 10))

# Mettre à jour l'affichage
 pygame.display.flip()

# Limiter la fréquence d'images
 horloge.tick(60)

Ce code crée une fenêtre d'une taille de 750x450 pixels, un personnage joueur et un obstacle. Il utilise une boucle de jeu pour gérer les événements, mettre à jour l'état et dessiner le jeu à l'écran. Il comprend également un système de notation qui incrémente le score de dix points à chaque fois que le personnage du joueur entre en collision avec l'obstacle, et un objet de police et un code de rendu de texte pour afficher le score à l'écran.

Dans la section de gestion des événements, le code inclut également une fonctionnalité permettant de déplacer le personnage du joueur vers la gauche et vers la droite à l'aide des touches fléchées.

La boucle de jeu comprend du code pour mettre à jour l'affichage et limiter la fréquence d'images à 60 FPS, garantissant ainsi le bon déroulement du jeu.

Dans l'ensemble, ce code fournit un exemple de base de la façon d'afficher et de mettre à jour les scores de jeu dans Pygame, et peut être davantage personnalisé et développé pour créer des jeux plus complexes et attrayants.

Créer différents jeux avec Pygame

Pygame est une bibliothèque puissante et facile à utiliser pour créer des jeux en Python. Grâce à son riche ensemble de fonctionnalités et de capacités, vous pouvez créer une large gamme de jeux, des simples cavaliers et plates-formes aux jeux plus complexes et immersifs.

Que vous soyez un débutant ou un développeur de jeux expérimenté, Pygame est un excellent choix pour créer des jeux attrayants et amusants.