Dans le module coin.py, chaque fois que l'on crée un objet Coin, on doit accéder au système de fichier pour charger le fichier image. S'il y a 200 Coin dans le niveau, cela peut devenir long. D'autant qu'il faudra faire de même pour les plates-formes et tout le reste.

Il est plus efficace de ne charger qu'une fois. On met donc en place un cache, c'est à dire un système qui garde les chargements en mémoire. À la première demande de dollar.png, on fait le chargement. Mais on garde le résultat de côté de sorte qu'à la prochaine demande, il ne sera plus utile de charger.

À titre d'exemple, je vais ajouter les plates-formes

On crée un dossier images qui contiendra les images de l'archive : images.zip. Ainsi toutes les images seront bien rangées.

On crée ensuite le gestionnaire :

#imageloader.py

import pygame

IMAGES = {
    "dollar":{
        "filename": 'dollar.png',
        "size":(20, 20)
    },
    "upleft":{
        "filename": 'upleft.png',
        "size": (30,30)
    },
    "upright":{
        "filename": 'upright.png',
        "size": (30,30)
    },
    "upcenter":{
        "filename": 'upcenter.png',
        "size": (30,30)
    },
    "left":{
        "filename": 'left.png',
        "size": (30,30)
    },
    "right":{
        "filename": 'right.png',
        "size": (30,30)
    },
    "center":{
        "filename": 'center.png',
        "size": (30,30)
    }
}

FOLDER = "./images/"

loaded = {}


def load(name):
    """
    accède à l'image d'identifiant name.
    si l'image n'est pas déjà dans loaded, l'ajoute.
    renvoie l'image.
    """
    assert name in IMAGES
    if name not in loaded:
        attributes = IMAGES[name]
        image = pygame.image.load(FOLDER + attributes["filename"])
        image = image.convert_alpha()
        image = pygame.transform.scale(image, attributes["size"])
        loaded['name'] = image
    return loaded['name']

Vous voyez que le gestionnaire consiste en une liste d'identifiant qui permettent d'atteindre des noms de fichiers et des attributs de taille.

La variable loaded sert de cache (la mémoire contenant les chargement antérieurs)

La fonction consiste à vérifier si l'image demandée est déjà stockée dans loaded. Si ce n'est pas le cas, la fonction fait le chargement et stocke le résultat dans loaded de sorte qu'à la prochaine demande, le chargement sera inutile.

On peut alors modifier le script coin.py :

# coin.py

import pygame
import imageloader
from abc import abstractmethod

class Coin(pygame.sprite.Sprite):
    TYPES = {
        "dollar":{
            "name": 'dollar',
            "valeur":10
        }
    }
     
    def __init__(self, x, y, coin_type):
        """
        x, y: position du centre de la pièce
        coin_type: type de pièce
        Cette fonction crée une récompense
        """
        super().__init__()
        assert coin_type in Coin.TYPES
        attributes = Coin.TYPES[coin_type]
        self.image = imageloader.load(attributes["name"])
        self.valeur = attributes["valeur"]
        ...

Pour les plates-formes, comme je souhaite que la plateforme type soit constituée d'une image carrée de taille fixe, je défini un nouveau type de sprite, Square au lieu de Rectangle, dont je ne spécifie pas la taille : la taille est fixée dans imageloader (choix discutable).

# square.py

import pygame
import imageloader

class Square(pygame.sprite.Sprite):
    def __init__(self, x, y, png_name:str):
        """
        x, y: position du coin supérieur gauche
        png_name: nom du fichier png à utiliser
        """

        super().__init__()
        self.image = imageloader.load(png_name)
        self.rect = self.image.get_rect()
        self.x = x
        self.y = y

    def adjust(self, camera):
        """
        Ajuste la position de l'objet en accord avec la caméra
        """
        self.rect.left = self.x - camera.x
        self.rect.top = self.y - camera.y

Enfin, levelreader.py s'en trouve un peu changé :

# levelreader.py

import pygame
from square import Square
from coin import Coin

...

            if car == 'P':
                s = Square(x*SIZE, y*SIZE, 'upcenter')
                plateformes.add(s)

...

Vous avez vu que j'ai prévu des images upleft et upright représentant des bords gauche ou droit de plates-formes. On pourrait modifier levelreader.py pour que, détectant les bords gauche ou droit de plates-formes, il emploie l'image adaptée parmi upleft, upcenter, upright.