Apprenez à mesurer le temps et à l'utiliser pour contrôler divers aspects de votre jeu.
Dans le développement de jeux, l'ajout d'événements basés sur le temps peut grandement améliorer les mécanismes de jeu et rendre les jeux plus attrayants pour les joueurs. En incorporant des minuteries, vous pouvez introduire des défis, créer des objectifs limités dans le temps ou ajouter un sentiment d'urgence à certains éléments du jeu.
Créer un jeu simple
Commencez par créer un jeu simple pour comprendre les bases. Construisez un jeu où le joueur peut se déplacer à gauche et à droite, et il y aura une seule plate-forme. Créer un nouveau fichier nommé jeu-simple.py et importer le module arcade, qui fournit les fonctionnalités nécessaires à la création du jeu.
Le code utilisé dans cet article est disponible dans ce Référentiel GitHub et est libre d'utilisation sous la licence MIT.
Ensuite, définissez le Fenêtre de jeu classe, qui est une sous-classe de arcade. Fenêtre. Dans la classe GameWindow, définissez la
__init__ méthode, qui initialise la fenêtre avec la largeur, la hauteur et le titre spécifiés.Le on_key_press méthode détecte les appuis sur les touches fléchées gauche ou droite. Appuyer à gauche diminue joueur_x de 10 unités tout en appuyant à droite l'augmente de 10 unités. Ce permet au joueur de se déplacer horizontalement dans la fenêtre de jeu.
Pour exécuter le jeu, définissez la fonction principale, créez une instance de GameWindow, appelez la méthode de configuration pour configurer la fenêtre de jeu, et enfin, démarrez la boucle de jeu en utilisant arcade.run().
Conception de la structure de la classe Timer
Pour implémenter des minuteries dans votre jeu, vous pouvez créer une classe Timer avec les attributs et méthodes nécessaires. Cette classe fournira des fonctionnalités pour démarrer le chronomètre, l'arrêter, récupérer le temps écoulé et vérifier si le chronomètre a expiré. Voici la structure de base de la classe Timer :
importer tempsclasseMinuteur:
définitivement__init__(soi, durée):
self.duration = durée
self.start_time = 0
self.is_running = FAUXdéfinitivementcommencer(soi):
self.start_time = time.time()
self.is_running = Vraidéfinitivementarrêt(soi):
self.is_running = FAUXdéfinitivementget_elapsed_time(soi):
si self.is_running :
retour time.time() - self.start_time
retour0
définitivementest expiré(soi):
retour self.get_elapsed_time() >= self.duration
La classe Timer prend un durée paramètre en secondes lors de l'initialisation. La classe contient des attributs tels que Heure de début pour mémoriser l'heure à laquelle la minuterie a démarré, et est en cours d'exécution pour suivre l'état de la minuterie.
Le commencer() La méthode définit le start_time à l'heure actuelle en utilisant temps temps() et définit is_running sur Vrai. Le arrêt() méthode définit simplement is_running sur FAUX. Le get_elapsed_time() calcule le temps écoulé en soustrayant start_time de l'heure actuelle.
Si la minuterie est en cours d'exécution, elle renvoie le temps écoulé; sinon, il renvoie 0. Le est expiré() La méthode vérifie si le temps écoulé est supérieur ou égal à la durée, indiquant que la minuterie a expiré.
Mise en œuvre des comptes à rebours
Pour démontrer un compte à rebours dans votre jeu, vous pouvez démarrer le chronomètre lorsque le joueur appuie sur une touche spécifique, telle que la barre d'espace. Imprimez le compte à rebours sur la console à l'aide de la commande print de Python. Créer un nouveau fichier nommé timer.py et ajoutez le code avec ces mises à jour :
importer tempsclasseFenêtre de jeu(arcade. Fenêtre):
définitivement__init__(soi):
super().__init__(LARGEUR, HAUTEUR, "Jeu facile")
self.player_x = LARGEUR // 2
self.player_y = HAUTEUR // 2
self.timer = Minuterie(10)définitivementon_key_press(soi, clé, modificateurs):
si clé == arcade.clé. ESPACE:
self.timer.start()
définitivementon_draw(soi):
# Code existant
si self.timer.is_running :
temps_elapsed = self.timer.get_elapsed_time()
r_time = self.timer.duration - elapsed_time
temps_restant = max (temps_r, 0)
imprimer(f"Compte à rebours: {temps restant:.1F} secondes")
Assurez-vous que vous pouvez voir la fenêtre du terminal et la fenêtre du jeu en même temps. Appuyez ensuite sur espace et vous verrez le compte à rebours :
Gestion des événements de minuterie et déclenchement d'actions
Vous pouvez également déclencher une fonction qui dessine un rectangle lorsque le compte à rebours expire. Créer un nouveau fichier nommé handle-event.py et ajoutez le code avec les mises à jour ci-dessous :
définitivementon_draw(soi):
# Code existant
si self.timer.is_expired() :
self.draw_rectangle()
définitivementdessiner_rectangle(soi):
arcade.draw_rectangle_filled (LARGEUR // 2, HAUTEUR // 2, 100, 100, rouge)
Ci-dessous la sortie :
Pause, réinitialisation et reprise de la minuterie
Pour ajouter une fonctionnalité de pause, de réinitialisation et de reprise de la minuterie, vous pouvez étendre la Minuteur classe avec les méthodes appropriées. Voici un exemple :
classeMinuteur:
# Code existantdéfinitivementpause(soi):
self.duration -= self.get_elapsed_time()
self.is_running = FAUXdéfinitivementréinitialiser(soi):
self.start_time = 0
self.is_running = FAUX
définitivementCV(soi):
self.start_time = time.time()
self.is_running = Vrai
Ajout d'un retour visuel au minuteur
Pour fournir un retour visuel au chronomètre, vous pouvez incorporer du texte ou des éléments graphiques sur l'écran de jeu. Créer un nouveau fichier nommé visuel.py et ajoutez le code avec les mises à jour ci-dessous :
définitivementon_draw(soi):
# Code existant
si self.timer.is_running :
texte = f"Compte à rebours: {temps restant:.1F} secondes"
arcade.draw_text (texte, 10, 10, noir, 18)Vous verrez maintenant le chronomètre directement dans la fenêtre du jeu au lieu de la console :
Inclure des fonctionnalités supplémentaires
Pour améliorer encore les événements basés sur le temps, vous pouvez envisager d'implémenter les fonctionnalités supplémentaires suivantes dans vos jeux.
Power-ups ou bonus basés sur le temps
Introduisez des power-ups ou des bonus qui apparaissent périodiquement tout au long du jeu. Ces bonus pourraient fournir des capacités temporaires, des points supplémentaires, une vitesse accrue ou des armes améliorées.
En les rendant limités dans le temps, les joueurs doivent les collecter stratégiquement dans un laps de temps spécifique pour obtenir un avantage. Cela ajoute de l'excitation et récompense la réflexion rapide.
Défis à durée limitée
Créez des défis limités dans le temps où les joueurs doivent accomplir une tâche dans un certain laps de temps. Par exemple, une section de casse-tête ou de plate-forme qui nécessite d'être résolue dans un délai donné.
Cela met les joueurs au défi de penser et d'agir rapidement, ajoutant un sentiment d'urgence passionnant au gameplay. La réussite de ces défis peut débloquer des récompenses ou faire progresser l'histoire.
Obstacles chronométrés ou ennemis
Mettez en place des obstacles chronométrés ou des ennemis qui constituent une menace pour le joueur. Par exemple, des plates-formes mobiles qui apparaissent et disparaissent à intervalles réguliers, ou des ennemis qui deviennent invincibles pendant un temps limité.
Les joueurs doivent chronométrer correctement leurs actions et leurs mouvements pour franchir ces obstacles ou vaincre les ennemis avant la fin du temps imparti. Cela ajoute une couche de stratégie et de coordination au gameplay.
Meilleures pratiques pour les événements basés sur le temps
Lors de la mise en œuvre d'événements basés sur le temps dans vos jeux, il est essentiel de suivre ces bonnes pratiques.
Tester et équilibrer
Testez soigneusement vos événements basés sur le temps pour vous assurer qu'ils sont justes et équilibrés. Ajustez la durée, la difficulté et les récompenses pour créer des expériences de jeu agréables.
Commentaires des utilisateurs
Fournissez des commentaires clairs et intuitifs aux joueurs concernant l'état du chronomètre et tout événement basé sur le temps. Ajout d'effets sonores, des indicateurs visuels ou des indices textuels peuvent aider les joueurs à comprendre les contraintes de temps et les conséquences de leurs actions.
Mesure du temps cohérente
Utilisez un système de mesure du temps cohérent tout au long de votre partie. Par exemple, utilisez les secondes comme unité pour toutes les minuteries et les calculs liés au temps. Cela garantit la cohérence et la facilité de compréhension pour les joueurs et les développeurs.
Gérer les étuis Edge
Envisagez des scénarios dans lesquels le jeu peut être mis en pause, réduit ou exécuté en arrière-plan. Gérez ces situations avec élégance pour maintenir un timing précis et éviter tout comportement involontaire lorsque le jeu reprend.
En suivant ces meilleures pratiques, vous pouvez créer des événements basés sur le temps qui améliorent le gameplay, défient les joueurs et offrent une expérience équilibrée et agréable.
Rendre les jeux plus amusants avec des événements basés sur le temps
En incorporant des événements basés sur le temps dans vos jeux, vous pouvez créer une expérience dynamique et attrayante pour les joueurs. Les défis limités dans le temps ajoutent de l'excitation et de l'urgence, tandis que des bonus ou des obstacles chronométrés peuvent créer des opportunités de prise de décision stratégique.
Expérimentez avec différents mécanismes basés sur le temps pour trouver le bon équilibre pour votre jeu, et n'oubliez pas de tester et d'itérer pour maximiser le plaisir et le plaisir.