Comment créer un menu Démarrer et un écran Game Over avec PyGame

PyGame est une bibliothèque populaire pour la création de projets avec Python, et elle fournit un ensemble puissant d’outils pour le développement de jeux. Dans cet article, vous apprendrez à créer un menu de démarrage et un écran de jeu pour un jeu simple à l’aide de PyGame. ​​​​​​

Créer un jeu simple

Avant de créer le menu de démarrage et l’écran de jeu, créons d’abord un jeu simple. Dans ce jeu, vous contrôlerez un personnage avec les touches fléchées et tenterez d’éviter les obstacles. Pour garder les choses simples, essayez de ne pas utiliser d’images.

Pour commencer, vous devez importer les modules nécessaires. Vous utiliserez le module pygame pour accéder aux fonctions de PyGame. Pour installer le module, vous pouvez utiliser le gestionnaire de packages pip :

pip install pygame

Maintenant que notre module est prêt à l’emploi, créons un jeu simple avec un joueur qui peut se déplacer à gauche ou à droite à l’aide des touches fléchées et d’un obstacle. Si vous heurtez l’obstacle, le jeu se terminera. Voici le code pour le même :

import pygame
pygame.init()


screen_width = 750
screen_height = 450
screen = pygame.display.set_mode((screen_width, screen_height))

    screen.fill((0, 0, 0))
    pygame.draw.rect(screen, (255, 0, 0), (obstacle_x, obstacle_y, obstacle_width, obstacle_height))
    pygame.draw.rect(screen, (0, 255, 0), (player_x, player_y, player_width, player_height))
    pygame.display.update()

Dans le code ci-dessus, vous configurez la fenêtre de jeu et déclarez les variables de jeu. Vous avez également géré les entrées de l’utilisateur et dessiné les éléments à l’écran.

Création du menu Démarrer

Maintenant que vous avez un jeu de base, créons un menu de démarrage. Pour ce faire, vous devrez déclarer une variable globale pour l’état du jeu. Cette variable gardera une trace de l’état actuel du jeu, par exemple si le menu de démarrage est actif ou si le jeu est en cours d’exécution. Vous devez ajouter cette variable au début de votre code de jeu :

game_state = "start_menu"

Ensuite, vous ajouterez une fonction pour dessiner le menu de démarrage à l’écran. Vous pouvez utiliser les fonctions PyGame pour dessiner le texte, les boutons et d’autres éléments à l’écran.

def draw_start_menu():
    screen.fill((0, 0, 0))
    font = pygame.font.SysFont('arial', 40)
    title = font.render('My Game', True, (255, 255, 255))
    start_button = font.render('Start', True, (255, 255, 255))
    screen.blit(title, (screen_width/2 - title.get_width()/2, screen_height/2 - title.get_height()/2))
    screen.blit(start_button, (screen_width/2 - start_button.get_width()/2, screen_height/2 + start_button.get_height()/2))
    pygame.display.update()


Vous pouvez ensuite ajouter la fonction draw_start_menu() à la boucle de jeu principale.

while True:


   for event in pygame.event.get():
       if event.type == pygame.QUIT:
           pygame.quit()
           quit()

   if game_state == "game":
       keys = pygame.key.get_pressed()
       # rest of the code


Maintenant, le menu de démarrage sera dessiné à l’écran. La dernière étape consiste à gérer l’entrée de l’utilisateur. Vous pouvez ajouter une instruction if à la boucle principale du jeu pour vérifier si l’utilisateur a appuyé sur le bouton de démarrage.

if game_state == "start_menu":
    keys = pygame.key.get_pressed()
    if keys[pygame.K_SPACE]:
        player_x = 200
        player_y = 400
        game_state = "game"
        game_over = False

Avec ce code, le jeu démarre lorsque l’utilisateur appuie sur le bouton de démarrage.

Mise en œuvre de l’écran Game Over

Maintenant que vous avez le menu de démarrage, créons l’écran de jeu sur. Cette fonction devrait afficher le score final et un message de fin de partie.

def draw_game_over_screen():
   screen.fill((0, 0, 0))
   font = pygame.font.SysFont('arial', 40)
   title = font.render('Game Over', True, (255, 255, 255))
   restart_button = font.render('R - Restart', True, (255, 255, 255))
   quit_button = font.render('Q - Quit', True, (255, 255, 255))
   screen.blit(title, (screen_width/2 - title.get_width()/2, screen_height/2 - title.get_height()/3))
   screen.blit(restart_button, (screen_width/2 - restart_button.get_width()/2, screen_height/1.9 + restart_button.get_height()))
   screen.blit(quit_button, (screen_width/2 - quit_button.get_width()/2, screen_height/2 + quit_button.get_height()/2))
   pygame.display.update()


Vous pouvez ensuite ajouter cette fonction à la boucle de jeu principale.

if game_state == "start_menu":
    draw_start_menu()
if game_state == "game_over":
    draw_game_over_screen()


if game_state == "game":
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT]:
        player_x -= 5
    if keys[pygame.K_RIGHT]:
        player_x += 5

Enfin, vous devez gérer l’entrée de l’utilisateur pour gérer le choix de l’utilisateur. Vous pouvez ajouter une instruction if à la boucle principale du jeu pour vérifier si l’utilisateur a appuyé sur le bouton de redémarrage ou de sortie.

if game_state == "start_menu":
    keys = pygame.key.get_pressed()
    if keys[pygame.K_SPACE]:
        game_state = "game"
       player_x = 200
       player_y = 400
       game_state = "game"
       game_over = False


if game_state == "game_over":
    keys = pygame.key.get_pressed()
    if keys[pygame.K_r]:
        game_state = "start_menu"
    if keys[pygame.K_q]:
        pygame.quit()
        quit()

Avec ce code, le jeu redémarrera lorsque l’utilisateur appuie sur le bouton ‘R’ et s’arrêtera lorsque l’utilisateur appuie sur le bouton ‘Q’ du clavier.

Ci-dessous le code complet :

import pygame


pygame.init()
screen_width = 750
screen_height = 450
screen = pygame.display.set_mode((screen_width, screen_height))
obstacle_x = 400
obstacle_y = 400
obstacle_width = 40
obstacle_height = 40
player_x = 200
player_y = 400
player_width = 20
player_height = 20
game_state = "start_menu"

   elif game_over:
       game_state = "game_over"
       game_over = False

Le code commence par importer le module pygame et l’initialiser. Il crée ensuite une fenêtre de jeu et déclare les variables de jeu nécessaires, y compris la position, la dimension et l’état du jeu du joueur et de l’obstacle.

Le code définit deux fonctions, draw_start_menu() et draw_game_over_screen() , pour dessiner le menu de démarrage et le jeu sur l’écran. Ces fonctions utilisent les fonctions PyGame pour dessiner du texte et des boutons à l’écran.

La boucle de jeu principale commence par la gestion des événements et la vérification de l’état du jeu. Si l’état du jeu est start_menu , le menu de démarrage est dessiné à l’écran. Si l’état du jeu est game_over , l’écran de fin de partie est dessiné à l’écran. Si l’état du jeu est autre chose, le jeu se met à jour et attire le joueur et l’obstacle à l’écran.

Le jeu se met à jour en gérant les pressions sur les touches et en vérifiant s’il y a une collision entre le joueur et l’obstacle. En cas de collision, le jeu définit l’ indicateur game_over sur True et définit l’état du jeu sur game_over .

Une fois le jeu mis à jour, le joueur et l’obstacle sont attirés vers l’écran. Enfin, le code vérifie si le drapeau game_over est défini, et si c’est le cas, il réinitialise le drapeau et définit l’état du jeu sur game_over .

Ce processus est répété en continu jusqu’à ce que la fenêtre de jeu soit fermée.

Augmentez l’engagement des utilisateurs avec une interface utilisateur visuellement attrayante

L’utilisation d’une interface utilisateur (UI) bien conçue peut considérablement augmenter l’engagement des utilisateurs dans un jeu PyGame. Une police claire et facile à lire, des graphismes visuellement attrayants, une navigation facile et les commentaires des utilisateurs sont tous des éléments importants à prendre en compte lors de la conception de l’interface utilisateur. En implémentant ces éléments, vous pouvez créer une interface utilisateur qui aide à garder le joueur intéressé et immergé dans le jeu.

N’oubliez pas de tester votre interface utilisateur et de recueillir les commentaires des joueurs pour vous assurer qu’elle est efficace pour augmenter l’engagement. Dans l’ensemble, prendre le temps de créer une interface utilisateur solide peut grandement améliorer l’expérience du joueur et le plaisir de votre jeu.