Outils pour utilisateurs

Outils du site


ateliers:pygamelab:boucledejeu

La boucle de jeu

Nous allons nous arrêter un moment sur une partie un peu théorique. Dans cette partie nous allons voir de quel manière est constituer la plupart des jeux graphique en deux dimensions.

Un jeu vidéo c'est quoi

Quand on parle d'un jeu vidéo graphique en deux dimensions, il faut d'abord comprendre une chose: Il s'agit de crée un succession d'image à partir de plusieurs petites images séparés. En fonction du contexte de jeu, de l’interaction avec le.a Joueur.euse. Le programme va chercher l'image qui convient à la situation et la positionner au bon endroit sur la fenêtre.

Le but final étant de crée une scène qui soit compréhensible pour le.a joueur.euse.

Un peu de vocabulaire

Comme le vocabulaire existe, autant l'apprendre et l'utiliser.

* frame : Image crée et affiché par le jeu

* framerate : (où image par seconde) Nombre d'image crée et affiché par le jeu en une seconde

* sprite : image importé par le jeu

* feuille de sprite : ficher contenant plusieurs sprites les un a coté des autres dans le but d'obtenir un seul chargement de fichier plutôt que le chargement de plusieurs petits fichier.

Boucle de jeu

Lecture des événements

Dans un premier temps, on lit les événements, c'est à dire que l'on prend les état des touches du clavier ou des manette et on identifie celle qui ont été enfoncés Bref, on essai d'identifier les actions des joueurs.euses.

Actualisation

C'est le temps des calculs. A l'étape précédente nous avons recueilli les interactions des joueurs.euses. Grâce ces informations, nous allons pouvoir calculer les interactions entre les différents objet du jeu. Calculer des collisions, calculer une physique avec un gravité. Tous cela à pour but d'identifier les sprites à utiliser et leur positions dans la fenêtre.

Affichage

Maintenant que nous avons calculé la position des sprites, nous allons pouvoir les afficher. Nous avons crée l'image final qui sera vu par les joueurs.euses.

Framerate

Après avoir fait les calculs et avoir affiché l'image finale. Nous devrions normalement être un poil en avance sur le timing. Le but et de ne faire que 30 images par secondes, (où 60 selon ce que l'on choisi). Donc pour respecter la cadence nous allons devoir mettre le programme en pause pendant quelques centièmes de seconde, avant de recommencer la boucle.

En pratique

Si l'on prend le script que nous avons crée précédemment voila ce que ça donne

  # importation de la librairie pygame
  import pygame
  
  FRAMERATE = 30
  
  # main
  def main():
      # Initilisation de pygame
      pygame.init()
  
      # Définition de la taille de l'écran
      taille_ecran = (800, 600)
      ecran = pygame.display.set_mode(taille_ecran)
  
      # Condition de la boucle de jeu
      jeu_en_cours = True
  
      # Horloge du Framerate
      horloge_framerate = pygame.time.Clock()
  
      #-------Boucle de jeu --------
      while jeu_en_cours :
  
          #--- Lecture des événements ---
          for event in pygame.event.get():
              if event.type == pygame.QUIT:
                  jeu_en_cours = False
  
              if event.type == pygame.KEYDOWN:
                  if event.key == pygame.K_ESCAPE:
                      jeu_en_cours = False
  
          #--- Actualisation du jeu ---
  
          #--- Affichage ---
  
          #--- Framerate ---
          horloge_framerate.tick(FRAMERATE)
          
      pygame.quit()
  
  if __name__ == "__main__":
      main() 
ateliers/pygamelab/boucledejeu.txt · Dernière modification: 2019/01/20 15:30 par izawenn