• Etape 3 : Le module TIME

     

     

    ETAPE 3

     

    Le module TIME de Pygame

     

     

    Je n’avais pas prévu de parler si tôt de ce module, mais en fait je me suis rendu compte qu’entre mon ordinateur portable et mon ordinateur de bureau, j’avais une grosse différence en terme de vitesse de déplacement de mon personnage. Donc j’imagine que les gros Gamer parmi nous auront un personnage qui se déplacera telle une fusée, et les autres telle une tortue selon leur configuration et la puissance de leur ordinateur.

     

     

    Le module Time de Pygame ok, mais pour faire quoi ?

     

    Calculer le nombre de Frame par seconde (FPS)

    Donner une valeur maximum au FPS

    Ralentir les évènements si ceux-ci s’effectuent trop vite.

    Permettre des temps de pause entre deux actions (le temps de recharge du sort qui tue tout)

     

    A ne pas confondre avec le module Time de Python, dont on va aussi se servir pour afficher une horloge par exemple…

     

    1.    Généralités.

     

     

    Le temps dans Pygame est calculé en millisecondes ( milliseconds en anglais)

     

    Si l’on a besoin d’une échelle de temps pour gérer des événements dans le jeu nous auront besoin d’une horloge. Celle-ci est initialisée par l’appelle de la fonction

     

    pygame.time.Clock()

     

    On déclare en général cette valeur en début de programme ou dans une fonction ou classe. La façon la plus simple étant :

     

    mon_horloge = pygame.time.Clock()

     

    Une fois cette horloge mise en place, nous pouvons utiliser les fonctions suivantes, souvent dans la boucle principale :

     

    pygame.time.delay(milliseconds) : met en pause pour un nombre donné de millisecondes.

     

    pygame.time.set_timer(événement,milliseconds) : effectue une action a chaque fois que le temps définit est écoulé

     

    Clock.tick(Framerate = 0) : cette fonction doit être appelé dans la boucle principale, une fois par Frame, et calcule le temps écoulé en milliseconde depuis le précédent appel.

     

    Clock.get_fps() : calcule le nombre de FPS du jeu. Ce calcul est effectué en faisant la moyenne des derniers appels à Clock.tick 

     

     

    Avec ces quelques éléments nous avons ce dont nous avons besoin pour accélérer, diminuer et surtout réguler le timing de notre jeu.

    Afin de pouvoir tester les différents effets des événements d’horloges, nous allons utiliser notre fichier skeleton.py

     

    2. Calcul et affichage du nombre de Frames Par Seconde (FPS).

     

     

    Jusqu'à présent à l’exécution de notre programme , nous avions dans le titre de notre fenêtre l’icône Pygame et le titre « Pygame window », comme tout programme qui se respecte nous pouvons personnaliser ceci avec la commande

     

    pygame.display.set_caption(ici uniquement une chaîne de caractère).

    Ou encore :

    pygame.display.set_caption ( ‘il était une fois’) 

     

    Que l’on place au début de notre programme. Résultat :

      

    Etape 3 : Le module TIME

     

     Etape 3 : Le module TIME

     

     

     

     

     

     

     

     

     

     

     

     

    Revenons à nos FPS, à la place de ce titre de fenêtre, nous aimerions tout simplement afficher les FPS de notre jeu. Faisable a condition que la valeur soit une chaîne de caractère.

     

    Donc nous déclarons notre horloge dans l’entête de notre programme (au début)

    mon_horloge = pygame.time.Clock()

     

    Puis dans la boucle principale nous créons une variable pour recueillir les FPS grâce a la fonction Clock.get_fps() que nous afficherons, nommons la ‘message’ :

     

    message = mon_horloge.get_fps()

     

    comme nous l’avons décrit dans les généralités au début de cet article, la fonction Clock.get_fps() nécessite l’appel a la fonction Clock.tick() pour faire son calcul, qu’a cela ne tienne, nous créons cette valeur :

     

    mon_horloge.tick(60)  60 est la valeur de référence pour le calcul en sachant que c’est aussi une valeur maximum, le jeu ne dépassera jamais ce nombre de FPS.

     

    Dans notre code cela donne ceci :

     

    import pygame,sys  

    from pygame import * 

     

    pygame.init() 

     

    screen = pygame.display.set_mode((800,600)) 

    background = pygame.image.load('fond.png').convert() 

     

     

    perso = pygame.image.load('boy.png').convert_alpha() 

    x = 150 

    y = 250

     

    mon_horloge = pygame.time.Clock()# On créé l’horloge 

     

    while True:         # Boucle principale du jeu 

                   

        posx,posy = pygame.mouse.get_pos() 

        key=pygame.key.get_pressed()

       

        mon_horloge.tick(30) # 30 frames max a chaque boucle, valeur de

                       # calcul pour le FPS 

        for event in pygame.event.get(): 

            if event.type == QUIT: 

                sys.exit() 

               

        if key[K_LEFT]: 

            x-=1 

        if key[K_RIGHT]: 

            x+=1 

        if key[K_UP]: 

            y-=1 

        if key[K_DOWN]: 

            y+=1 

       

        message = mon_horloge.get_fps()# la fonction qui calcule le FPS 

     

        screen.blit(background,(0,0))  

        screen.blit(perso,(x,y))

     

        pygame.display.set_caption("FPS : %s " % message) # affichage du FPS 

     

        pygame.display.flip()              

         

     

    Lorsque nous exécutons notre programme celui-ci affiche bien le nombre de Frames par secondes dans la barre de titre .Ceci est du à la ligne dans la fin de notre code :

     

    pygame.display.set_caption("FPS : %s " % message)

     

     

     

     Etape 3 : Le module TIME

     

     

     

     

    L’affichage avec toutes ces décimales est sûrement inutile, que faire pour ne garder que deux chiffres après la virgule ? Utiliser une option de formatage :

     

    pygame.display.set_caption("FPS : %.2f " % message)

    Ceci est une option de formatage de Python, il en existe de nombreuses autres, je vous renvois à la page 135 du livre de Gérard Swinner (Gratuit et référence incontournable) « Apprendre à programmer avec Python »

     

     

     Etape 3 : Le module TIME

     

     

     

     

     

     

     

    Désormais notre FPS s’affiche selon notre souhait !

     

     

    3.Limiter le nombre de Frames par seconde.

     

     

    Reprenons notre code de la page précédente, lorsque je déclare

     

    mon_horloge.tick(30) 

     

    si je ne mettrais rien entre les () mon jeu tournera à la vitesse maximale que l’autorise mon ordinateur , et cela reviendrait a ne rien réguler, et à retrouver mon personnage qui se déplace comme une fusée. .

     

    Déclarer une valeur permet donc de réguler la vitesse de notre jeu, en sachant que 25 images par secondes est la vitesse de base de tournage d’un film pour que tout mouvement semble fluide, alors la vitesse de 30 FPS semble une bonne valeur.

     

    Mais je trouve que mon personnage se déplace trop lentement ! Alors je peux soit doubler la valeur de son déplacement : X-=2 par exemple, ou augmenter mon Framerate :  mon_horloge.tick(60) ou plus selon mon envie mais attention aux anciens PC qui tourneront forcement moins vite.

     

     

     

     

        4. Ralentir les évènements si ceux-ci s’effectuent trop vite.

       

     

    Outre la méthode explicitée juste avant , nous pouvons aussi réguler le temps d’une autre manière. En plaçant cette ligne de code dans la boucle principale :

     

     

    pygame.time.delay(valeur)

     

    où valeur est une valeur en millisecondes, qui ralentira le processus de toute la boucle.

      

    Voila pour les grandes lignes de ce modules, que je mettrais surement à jour, car je n'en maitrise pas encore toutes les subtilités.


    Tags Tags : , , , ,
  • Commentaires

    Aucun commentaire pour le moment

    Suivre le flux RSS des commentaires


    Ajouter un commentaire

    Nom / Pseudo :

    E-mail (facultatif) :

    Site Web (facultatif) :

    Commentaire :