Création de formes

Nous reprenons notre script précédent.

Nous allons ajouter une forme (rectangulaire) qui sera notre personnage (Player). Comme nous sommes partis sur de la programmation orientée objet, nous allons définir notre forme / personnage sous la forme d'une classe :

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
ETAPE 4 : 
Maintien du programme avec des classes

Quoi de neuf ? :
    - Créer un sprite (une forme / un personnage)  (pour l'instant un carré)
    - Créer un groupe de sprites et ajout du personnage à ce groupe

@author: YF

"""

import pygame

# Taille et titre de la fenêtre / Frames par seconde 
SCREENSIZE = (800, 600)
TITLE = "Tuto Pygame"
FPS = 60
# Taille des sprites en pixels
TILESIZE = 32

# Définition des couleurs et de la couleur de fond
LIGHTGREY = (110,110,110)
YELLOW = (255,255,0)
BGCOLOR = LIGHTGREY

class Player(pygame.sprite.Sprite):
    """
    Classe Player qui permet de dessiner un personnage à l'écran
    Pour l'instant, ce personnage a une forme de carré
    """  

    # constructeur de la classe
    def __init__(self, x, y):
        # initialisation de la classe Sprite du module pygame.sprite
        super().__init__()
        # notre personnage est une Surface qui a pour dimensions TILESIZE x TILESIZE
        self.image = pygame.Surface((TILESIZE,TILESIZE))
        self.image.fill(YELLOW)
        # récupère les dimensions du rectangle entourant l'image (x,y,largeur,hauteur)
        self.rect = self.image.get_rect()
        # on place l'image en x,y passés en paramètres au constructeur
        self.rect.x = x
        self.rect.y = y

class Game(object):

    # Constructeur de la classe  
    def __init__(self):
        pygame.init()
        self.screen = pygame.display.set_mode(SCREENSIZE)
        pygame.display.set_caption(TITLE)
        self.clock = pygame.time.Clock()
        self.running = True

    # méthode permettant de fermer la fenêtre
    def closeWindow(self):
        if self.playing:
            self.playing = False
        self.running = False

    # méthode de gestion de la saisie au clavier (pour l'instant seulement fin du jeu)
    def events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:         # croix de la fenêtre
                self.closeWindow()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:  # touche Echap  
                    self.closeWindow()

    # méthode qui met à jour tous les sprites du groupe
    def update(self):
        # mise à jour de tous les sprites du groupe all_sprites
        self.all_sprites.update()

    # méthode qui contient tout ce qui doit apparaître dans la fenêtre et la rafraîchit
    def draw(self):
        # couleur de fond d'écran
        self.screen.fill(BGCOLOR)
        # on dessine tous les sprites du groupe all_sprites dans la fenêtre
        self.all_sprites.draw(self.screen)
        pygame.display.update()

    # méthode qui regroupe tous les évènements de la boucle de jeu ou d'animation
    def run(self):
        self.playing = True
        while self.playing:
            self.events()
            self.update()
            self.draw()
            self.clock.tick(FPS)

    def new(self):
        # on crée un groupe de sprites
        self.all_sprites = pygame.sprite.Group()
        # instanciation pour créer un personnage à partir de la classe Player
        # positionné au milieu de l'écran
        # SCREENSIZE[0] = largeur / SCREENSIZE[1] = hauteur
        self.player = Player(SCREENSIZE[0] / 2, SCREENSIZE[1] / 2)
        # on ajoute notre objet player au groupe de sprites all_sprites
        self.all_sprites.add(self.player)

# programme principal
game = Game()
game.new()
while game.running:
    game.run()
pygame.quit()

Comprendre le programme :

Pour générer des objets dans notre fenêtre, nous allons utilisé le module pygame.sprite

Ce module comporte plusieurs classes qui vont nous faciliter la tâche. Les deux que nous utiliserons sont la classe Sprite et la classe Group.

classe Sprite

• class Player(pygame.sprite.Sprite) : notre modèle Player est une classe du module pygame.sprite.
• on initialise cette classe dans le constructeur (pygame.sprite.Sprite.__init__())
• toujours dans le constructeur, on crée une image qui est une Surface, un carré de dimensions TILESIZE x TILESIZE qu'on remplit avec du jaune
• get_rect() : permet de récupérer le rectangle entourant notre image. self_rect vaut alors (x,y,largeur,hauteur) où (x,y) est la position de l’objet et largeur et hauteur sont les dimensions du rectangle qui entoure l’image. Cela permet, par exemple, de gérer la position de l'objet, les collisions de cet objet avec ce qui est autour.

On crée un nouvel objet player en instanciant la classe Player.

classe Group

Elle permet de créer un objet groupe (all_sprites dans notre script) dans lequel nous mettrons tous nos objets images (le player dans un premier temps).

Quel intérêt de créer un groupe ?

Les objets groupes de pygame.sprite ont des méthodes qui permettent d'appliquer une action à tous les sprites d'un coup.

En particulier nous utiliserons draw (all_sprites.draw(screen)) qui dessinent tous les sprites du groupe et update (all_sprites.update()) qui met à jour tous les sprites du groupe.

Pour ajouter un sprite au groupe on utilise la méthode add : self.all_sprites.add(self.player)