Des lecteurs comme vous aident à soutenir MUO. Lorsque vous effectuez un achat en utilisant des liens sur notre site, nous pouvons gagner une commission d'affiliation. En savoir plus.

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 pygame module pour accéder aux fonctions de PyGame. Pour installer le module, vous pouvez utiliser le gestionnaire de paquets pip:

pépin installer 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 :

instagram viewer 

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


obstacle_x = 400
obstacle_y = 400
largeur_obstacle = 40
hauteur_obstacle = 40
joueur_x = 200
joueur_y = 400
player_width = 20
hauteur_joueur = 20


alors queVrai:

pourévénementdanspygame.événement.obtenir():

 si event.type == pygame. ARRÊTER:
pygame.arrêter()
 arrêter()



 clés = pygame.key.get_pressed()
siclés[pygame. K_LEFT]:
 joueur_x -= 5
siclés[pygame. K_RIGHT]:
 joueur_x += 5



 si player_x + player_width > obstacle_x et player_x < obstacle_x + largeur_obstacleetjoueur_y + hauteur_joueur > obstacle_y et joueur_y < obstacle_y + hauteur_obstacle :
 game_over = Vrai

filtrer.remplir((0, 0, 0))
pygame.dessiner.rect(filtrer, (255, 0, 0), (obstacle_x, obstacle_y, largeur_obstacle, hauteur_obstacle))
pygame.dessiner.rect(filtrer, (0, 255, 0), (joueur_x, joueur_y, player_width, hauteur_joueur))
pygame.afficher.mise à jour()

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 = "le menu Démarrer"

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.

définitivementdraw_start_menu():
filtrer.remplir((0, 0, 0))
 police = pygame.font. SysPolice('arial', 40)
 titre = police. rendu('Mon jeu', Vrai, (255, 255, 255))
 start_button = font.render('Commencer', Vrai, (255, 255, 255))
 screen.blit (titre, (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.afficher.mise à jour()

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

alors queVrai: 
pourévénementdanspygame.événement.obtenir(): 
 si event.type == pygame. ARRÊTER:
pygame.arrêter()
 arrêter()
si état_jeu == "le menu Démarrer":
 draw_start_menu()

si état_jeu == "jeu":
 clés = pygame.key.get_pressed()
# reste du code

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

si état_jeu == "le menu Démarrer":
 clés = pygame.key.get_pressed()
siclés[pygame. K_ESPACE]:
 joueur_x = 200
 joueur_y = 400
 game_state = "jeu"
 game_over = FAUX

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.

définitivementdraw_game_over_screen():
filtrer.remplir((0, 0, 0))
 police = pygame.font. SysPolice('arial', 40)
 titre = police. rendu('Jeu terminé', Vrai, (255, 255, 255))
 bouton_redémarrage = font.render('R - Redémarrer', Vrai, (255, 255, 255))
 quit_button = font.render('Q - Quitter', Vrai, (255, 255, 255))
 screen.blit (titre, (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.afficher.mise à jour()

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

si état_jeu == "le menu Démarrer":
 draw_start_menu()
si état_jeu == "jeu terminé":
 draw_game_over_screen()

si état_jeu == "jeu":
 clés = pygame.key.get_pressed()
siclés[pygame. K_LEFT]:
 joueur_x -= 5
siclés[pygame. K_RIGHT]:
 joueur_x += 5

si player_x + player_width > obstacle_x et player_x < obstacle_x + largeur_obstacleetjoueur_y + hauteur_joueur > obstacle_y et joueur_y < obstacle_y + hauteur_obstacle :
 game_over = Vrai
 game_state = "jeu terminé"

Enfin, vous devez gérer les entrées 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.

si état_jeu == "le menu Démarrer":
 clés = pygame.key.get_pressed()
siclés[pygame. K_ESPACE]:
 game_state = "jeu"
 joueur_x = 200
 joueur_y = 400
 game_state = "jeu"
 game_over = FAUX
si état_jeu == "jeu terminé":
 clés = pygame.key.get_pressed()
siclés[pygame. K_r]:
 game_state = "le menu Démarrer"
siclés[pygame. K_q]:
pygame.arrêter()
 arrêter()

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 :

importer pygame
pygame.init()
screen_width = 750
screen_height = 450
screen = pygame.display.set_mode((screen_width, screen_height))
obstacle_x = 400
obstacle_y = 400
largeur_obstacle = 40
hauteur_obstacle = 40
joueur_x = 200
joueur_y = 400
player_width = 20
hauteur_joueur = 20
game_state = "le menu Démarrer"


définitivementdraw_start_menu():
filtrer.remplir((0, 0, 0))
 police = pygame.font. SysPolice('arial', 40)
 titre = police. rendu('Mon jeu', Vrai, (255, 255, 255))
 start_button = font.render('Commencer', Vrai, (255, 255, 255))
 screen.blit (titre, (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.afficher.mise à jour()


définitivementdraw_game_over_screen():
filtrer.remplir((0, 0, 0))
 police = pygame.font. SysPolice('arial', 40)
 titre = police. rendu('Jeu terminé', Vrai, (255, 255, 255))
 bouton_redémarrage = font.render('R - Redémarrer', Vrai, (255, 255, 255))
 quit_button = font.render('Q - Quitter', Vrai, (255, 255, 255))
 screen.blit (titre, (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.afficher.mise à jour()
alors queVrai:
pourévénementdanspygame.événement.obtenir():
 si event.type == pygame. ARRÊTER:
pygame.arrêter()
 arrêter()
si état_jeu == "le menu Démarrer":
 draw_start_menu()
 clés = pygame.key.get_pressed()
siclés[pygame. K_ESPACE]:
 joueur_x = 200
 joueur_y = 400
 game_state = "jeu"
 game_over = FAUX
elif état_jeu == "jeu terminé":
 draw_game_over_screen()
 clés = pygame.key.get_pressed()
siclés[pygame. K_r]:
 game_state = "le menu Démarrer"
siclés[pygame. K_q]:
pygame.arrêter()
 arrêter()

elif état_jeu == "jeu":
 clés = pygame.key.get_pressed()
siclés[pygame. K_LEFT]:
 joueur_x -= 5
siclés[pygame. K_RIGHT]:
 joueur_x += 5

 si player_x + player_width > obstacle_x et player_x < obstacle_x + largeur_obstacleetjoueur_y + hauteur_joueur > obstacle_y et joueur_y < obstacle_y + hauteur_obstacle :
 game_over = Vrai
 game_state = "jeu terminé"

filtrer.remplir((0, 0, 0))
pygame.dessiner.rect(filtrer, (255, 0, 0), (obstacle_x, obstacle_y, largeur_obstacle, hauteur_obstacle))
pygame.dessiner.rect(filtrer, (0, 255, 0), (joueur_x, joueur_y, player_width, hauteur_joueur))
pygame.afficher.mise à jour()

elif jeu terminé:
 game_state = "jeu terminé"
 game_over = FAUX

Le code commence par importer le pygame module 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 le menu Démarrer, le menu de démarrage s'affiche à l'écran. Si l'état du jeu est jeu terminé, l'écran de fin de partie est dessiné sur 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. S'il y a une collision, le jeu définit le jeu terminé signaler à Vrai et définit l'état du jeu sur jeu terminé.

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

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 graphiques 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.