Étape 1 : Initialisation de Pygame et définition des couleurs

Nous commençons par importer le module Pygame et initialiser son fonctionnement. Nous définissons également les couleurs que nous allons utiliser dans notre jeu.

import pygame
import random

# Initialisation de Pygame
pygame.init()

# Définition des couleurs
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)

Étape 2 : Définition des dimensions de la fenêtre et des cartes

Nous définissons les dimensions de la fenêtre du jeu ainsi que les dimensions des cartes. Vous pouvez ajuster ces valeurs en fonction de vos préférences.

# Définition des dimensions de la fenêtre du jeu
WINDOW_WIDTH = 800
WINDOW_HEIGHT = 600

# Définition des dimensions des cartes
CARD_WIDTH = 100
CARD_HEIGHT = 100
CARD_GAP = 10
NUM_ROWS = 4
NUM_COLS = 4

Étape 3 : Création de la fenêtre du jeu

Nous créons la fenêtre du jeu en utilisant les dimensions définies précédemment. Nous donnons également un titre à la fenêtre.

# Création de la fenêtre du jeu
window = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
pygame.display.set_caption("Memory Game")

Étape 4 : Création de la police de texte

Nous créons une police de texte que nous utiliserons pour afficher les valeurs des cartes.

# Création de la police de texte
font = pygame.font.Font(None, 36)

Étape 5 : Génération des paires de cartes

Nous générons les paires de cartes en utilisant des valeurs numériques. Chaque paire contient deux cartes ayant la même valeur. Nous mélangeons ensuite les paires pour obtenir un ordre aléatoire.

# Génération des paires de cartes
pairs = [str(i) for i in range((NUM_ROWS * NUM_COLS) // 2)] * 2
random.shuffle(pairs)

Cette ligne de code génère une liste pairs qui contient les valeurs des paires de cartes à associer dans le jeu.

• • La valeur de chaque paire est représentée par une chaîne de caractère correspondant à un nombre.
  • La partie range(NUM_ROWS * NUM_COLS) // 2) génère une séquence de nombres de 0 à (NUM_ROWS * NUM_COLS) // 2) – 1 

• • La partie [str(i) for i in range((NUM_ROWS * NUM_COLS) // 2)]  sur chaque nombre de la séquence générée et le convertit en chaîne de caractère. Ainsi, nous obtenons une liste de chaînes de caractères représentant les valeurs des cartes.

• • En multipliant la liste 2 (* 2), nous appliquons chaque valeur pour créer les paires de cartes.
  • A savoir les 2 // : permet d’obtenir la moitié du nombre 

random.shuffle (pairs) : 

• • Cette ligne de code mélange aléatoirement les valeurs de la liste pairs de sorte que les paires de cartes sont mélangées de manière aléatoire à chaque exécution du jeu.

Étape 6 : Création de la grille de cartes

Nous créons la grille de cartes en utilisant les dimensions et les positions calculées en fonction du nombre de lignes et de colonnes. Chaque carte est représentée par un dictionnaire contenant sa valeur, sa position, son état (retournée ou non), et si elle a été associée à une autre carte.

Étape 7 : Variables de jeu

Nous définissons les variables nécessaires pour suivre l’état du jeu, telles que les cartes retournées et le nombre de paires correspondantes trouvées.

# Variables de jeu
flipped_cards = []
matched_pairs = 0

Étape 8 : Boucle principale du jeu

Nous entrons dans la boucle principale du jeu où nous gérons les événements, tels que les clics de souris, et effectuons les actions appropriées en conséquence. Par exemple, lorsque deux cartes sont retournées, nous vérifions si elles correspondent. Si elles correspondent, nous les marquons comme associées, sinon nous les retournons à nouveau.

Étape 9 : Affichage des cartes

À chaque itération de la boucle principale, nous effaçons l’écran, puis dessinons les cartes à l’écran. Si une carte est retournée, nous affichons sa valeur à l’aide de la police de texte que nous avons créée.

    # Effacer l'écran
    window.fill(BLACK)

    # Dessiner les cartes
    for card in cards:
        if card["flipped"]:
            pygame.draw.rect(window, WHITE, card["rect"])
            text_surface = font.render(card["value"], True, BLACK)
            text_rect = text_surface.get_rect(center=card["rect"].center)
            window.blit(text_surface, text_rect)
        else:
            pygame.draw.rect(window, WHITE, card["rect"])

    # Actualiser la fenêtre
    pygame.display.update()

Étape 10 : Fermeture de Pygame

Une fois que le joueur a quitté le jeu en fermant la fenêtre, nous terminons l’exécution de Pygame.

# Fermeture de Pygame
pygame.quit()

Avec ces étapes, vous devriez être en mesure de créer un jeu de Memory fonctionnel en utilisant Pygame. Amusez-vous bien !