Cet article va te guider dans le passage des rectangles simples à des images de pièces d’or dans un jeu PyGame. Il explique les modifications nécessaires pour continuer à détecter les collisions, tout en utilisant des visuels plus réalistes.

Remplacer les carrés par des images (pièces d’or)

Jusqu’à présent, tu as appris à dessiner des pièces avec des rectangles simples (pygame.draw.rect). C’est très pratique pour apprendre, mais pour rendre ton jeu plus attrayant, tu peux les remplacer par de vraies images de pièces (par exemple un fichier piece.png).

🎯 Objectif

• Afficher des images de pièces à la place des rectangles
• Garder la détection de collision fonctionnelle
• Bien comprendre comment gérer les collisions avec des objets dessinés à partir d’images

📦 Étape 1 : Préparer l’image

• Ajoute une image dans ton dossier de projet, par exemple : piece.png
• Cette image doit être carrée ou de petite taille (ex. : 20×20 pixels)

🧱 Étape 2 : Charger l’image

piece_image = pygame.image.load("piece.png")
taille_carre = piece_image.get_width()

🎯 Étape 3 : Dessiner les images

Dans la boucle de jeu, on affiche chaque pièce à l’aide de :

for piece in liste_pieces:
    screen.blit(piece_image, (piece["x"], piece["y"]))

💡 Étape 4 : Détecter les collisions avec l’image du joueur

Comme la version de la détection des collisions que nous utilisons nécessite des rectangles, nous allons créer à nouveau un rectangle invisible autour de chaque pièce d'or.

Le joueur étant aussi une image, on continue d’utiliser un rectangle invisible pour vérifier les collisions :

player_rect = pygame.Rect(player_x, player_y, joueur_image.get_width(), joueur_image.get_height())

for x, y in liste_pieces:
    piece_rect = pygame.Rect(x, y, taille_piece, taille_piece)

    if player_rect.colliderect(piece_rect):
        print("Collision avec une pièce !")

Puis :

for piece in liste_pieces:
    if player_rect.colliderect(piece["rect"]):
        print("Le joueur a touché une pièce !")

🧪 Exemple complet avec images

import pygame
import random
import sys

pygame.init()

# Fenêtre
largeur_ecran = 800
hauteur_ecran = 600
screen = pygame.display.set_mode((largeur_ecran, hauteur_ecran))
pygame.display.set_caption("Collisions avec images")

# Joueur
joueur_image = pygame.image.load("joueur.png")
player_x = 100
player_y = 100
vitesse = 5
player_largeur = joueur_image.get_width()
player_hauteur = joueur_image.get_height()

# Pièce (image)
piece_image = pygame.image.load("piece.png")
taille_carre = piece_image.get_width()

# Génération des pièces
liste_pieces = []
for _ in range(5):
    x = random.randint(0, largeur_ecran - taille_carre)
    y = random.randint(0, hauteur_ecran - taille_carre)
    liste_pieces.append((x, y))

# Boucle de jeu
clock = pygame.time.Clock()
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    # Déplacements
    touches = pygame.key.get_pressed()
    if touches[pygame.K_LEFT]:
        player_x -= vitesse
    if touches[pygame.K_RIGHT]:
        player_x += vitesse
    if touches[pygame.K_UP]:
        player_y -= vitesse
    if touches[pygame.K_DOWN]:
        player_y += vitesse

    # Créer le rectangle invisible du joueur
    player_rect = pygame.Rect(player_x, player_y, player_largeur, player_hauteur)

    # Vérification des collisions
    for x, y in liste_positions_pieces:
        piece_rect = pygame.Rect(x, y, taille_piece, taille_piece)
        if player_rect.colliderect(piece_rect):
            print("Collision avec une pièce !")

    ############## Affichage ################
    screen.fill((0, 0, 0))  # fond noir

    # Afficher les pièces (images)
    for x, y in liste_positions_pieces:
        screen.blit(piece_image, (x, y))

    # Afficher le joueur
    screen.blit(joueur_image, (player_x, player_y))

    pygame.display.flip()
    clock.tick(60)

pygame.quit()
sys.exit()

✅ Ce qu’il faut retenir

🔜 Prochaine étape

Tu peux maintenant :

• faire disparaître les pièces touchées
• ajouter un score
• jouer un son lors d'une collision