Mis à jour le lundi 20 juillet 2015
  • Facile

Ce cours est visible gratuitement en ligne.

Vous pouvez être accompagné et mentoré par un professeur particulier par visioconférence sur ce cours.

J'ai tout compris !

TP - DK Labyrinthe !

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Vous avez durement travaillé durant toute cette partie, alors maintenant c'est détente, on va se faire une petite partie de DK Labyrinthe ! :p

Voilà le genre de jeu que vous obtiendrez à la fin de ce TP :

Image utilisateur

Commençons tout de suite par définir ce jeu et toutes ses fonctionnalités ! :)

Précisions sur le jeu

Image utilisateur

Comme partout, nous ne pouvons nous lancer tête baissée dans un projet sans connaître le cahier des charges, la liste des fonctionnalités que devra posséder ce jeu ! :)
Quelques petites précisions sont donc nécessaires avant de commencer à coder !

But du jeu

Vous l'aurez compris, le but de ce jeu est de guider Donkey Kong de la ligne de départ jusqu'à la fin du labyrinthe, et comme c'est un singe, la fin du labyrinthe est un régime de bananes ! :lol:

Le singe doit partir d'en haut à gauche pour arriver en bas à droite de l'écran, en ayant au moins un chemin possible. Les murs délimitent les chemins, DK peut donc seulement marcher sur le sol, même s'il est un singe... :-°

Le déroulement du programme

Lors du lancement, le jeu devra se dérouler en plusieurs étapes.

  • Tout d'abord, la fenêtre devra afficher un écran d'accueil, qui invitera le joueur à choisir un niveau.

  • Lorsque le choix sera fait, le jeu devra ensuite être lancé, avec la possibilité de revenir à l'écran d'accueil.

  • Lorsque le labyrinthe sera terminé, on devra retrouver l'écran d'accueil, et pouvoir choisir un autre niveau.

Les fonctionnalités du programme
  • L'utilisateur choisira le niveau en tapant sur une touche, par exemple F1, F2...

  • La structure du niveau (départ, emplacement des murs, arrivée), devra être enregistrée dans un fichier n1, n2... pour les créer et modifier facilement.

  • Le singe sera contrôlé par les touches directionnelles du clavier.

  • La fenêtre sera un carré pouvant afficher 15 sprites sur la longueur.

  • Le singe devra donc se déplacer de case en case, avec 15 cases sur la longueur de la fenêtre !

  • L'utilisateur pourra à tout moment revenir au menu principal pour choisir un autre niveau.

  • Le labyrinthe sera terminé lorsque le singe atteindra les bananes.

Vous n'avez peut-être pas compris mon histoire de cases et de 15 sprites sur la longueur :-°
Pour cela, voici une image !

Image utilisateur

Ici, Donkey Kong pourra se déplacer de carré en carré, uniquement horizontalement et verticalement, sans intermédiaire entre les carrés ! Comme ceci (ouaah :D ) :

Image utilisateur
Les fichiers nécessaires au programme

Puisque nous codons un jeu en mode graphique, nous avons besoin d'image pour le rendre un temps soit peu réaliste. :p
Je vous mets à disposition ici tous les sprites (images) nécessaires au jeu :

Tout d'abord, voilà l'image qui devra s'afficher en accueil :

Image utilisateur

Venons en maintenant aux différentes positions de DK. En effet, quand on le déplacera vers le haut, il faudra voir son dos, vers le bas, son visage, et les deux différents côtes... Vous comprendrez mieux en image :

Image

Position

Image utilisateur

DK en déplacement vers le bas.

Image utilisateur

DK en déplacement vers le haut.

Image utilisateur

DK en déplacement vers la gauche.

Image utilisateur

DK en déplacement vers la droite.

C'est compris ? L'image de DK devra donc changer lors d'un changement de direction ! :)

Voilà maintenant les sprites pour le départ, l'arrivée et les murs :

Image

Fonction

Image utilisateur

Devra se trouver en haut à gauche pour annoncer le départ.

Image utilisateur

Le but ultime de DK, l'arrivée, en bas à droite de l'écran.

Image utilisateur

L'ennemi de DK, le mur ! :diable:

Et enfin, le fond du jeu, qui se trouvera derrière le singe et tous les autres sprites !

Image utilisateur

Enregistrez toutes ces images sur votre disque, dans le répertoire de votre script ! Et vous disposerez de toutes les images nécessaires au jeu attendu !

Structure des différents fichiers

Pour programmer ce jeu, je vous conseille de créer trois fichiers de script :

  • dklabyrinthe.py : il contiendra la structure principale de votre programme.

  • classes.py : il contiendra les classes que vous aurez créées pour le jeu.

  • constantes.py : il contiendra les constantes de votre jeu (taille de la fenêtre, adresse des images...) pour des futures modifications plus rapides...

  • Facultatif : fonctions.py, je n'en ai pas créé, mais il se peut que vous créiez des fonctions si vous ne passez pas par les méthodes de classes... :)

dklabyrinthe.py : structure principale

Nous allons voir ensemble ce que devra contenir ce fichier. :)

Tout d'abord, il contiendra une petite description de votre programme : son nom, votre nom si vous le voulez, le jeu, et les fichiers nécessaires au fonctionnement :

"""
Jeu Donkey Kong Labyrinthe
Jeu dans lequel on doit déplacer DK jusqu'aux bananes à travers un labyrinthe.

Script Python
Fichiers : dklabyrinthe.py, classes.py, constantes.py, n1, n2 + images
"""

Ensuite, il devra contenir l'initialisation de Pygame, ainsi que l'ouverture d'une fenêtre, que l'on peut nommer. Vous pouvez aussi ajouter une icone ainsi :

pygame.init()

#Ouverture de la fenêtre Pygame (carré : largeur = hauteur)
fenetre = pygame.display.set_mode((cote_fenetre, cote_fenetre))
#Icone
icone = pygame.image.load(image_icone)
pygame.display.set_icon(icone)
#Titre
pygame.display.set_caption(titre_fenetre)

Les variables sont contenues dans le fichier constantes.py ;)
N'oubliez pas aussi d'importer tous les fichiers nécessaires ! (pygame, pygame.locals, classes, constantes)

Vous pouvez ensuite lancer la boucle principale ! :D
Nous avons vu que le programme devait afficher le menu, puis le jeu, puis encore le menu, puis encore le jeu, etc...
Le meilleur moyen de faire cela est de placer les boucles dans les boucles ! :D

Exemple :

BOUCLE PRINCIPALE:
     BOUCLE DE MENU:
          fin de la boucle de menu
     BOUCLE DE JEU:
          fin de la boucle de jeu

C'est compris ? :) Tant qu'on est au menu, on y reste, puis on file vers le jeu. Quand on a fini le jeu, on revient au menu ! :D Ca ne devrait pas être trop compliquer à coder !

Je vous conseille de limiter la vitesse de vos boucles, c'est à dire le nombre de fois qu'elles sont effectuées par seconde, pour ne pas surcharger votre processeur, grâce à cette fonction :

#Limitation de vitesse de la boucle
#30 frames par secondes suffisent
pygame.time.Clock().tick(30)

Vous n'avez qu'à la placer à la première ligne vos boucles d'accueil et de jeu pour limiter leur vitesse ! :) Nous verrons les moyens de gérer le temps avec Pygame dans la prochaine partie, pour l'instant faites moi confiance ! :)

classes.py

Ce fichier sera différent selon votre inspiration, mais sachez que j'ai créé deux classes dans celui-ci :

  • Niveau : avec deux méthodes, une qui génère un niveau à partir d'un fichier dans un attribut structure, l'autre qui l'affiche à l'écran.

  • Perso : qui créé un personnage, avec une position, une image pour chaque coté, une image actuelle (direction actuelle), une position en case, une position en pixels...
    Elle contient une seule méthode, celle de déplacement.
    Elle récupère aussi la structure du niveau, pour connaître le type de chaque case, et empêcher le déplacement si c'est un mur.

Avant la boucle de jeu, vous devez générer le niveau à partir d'un fichier.
Vous pouvez créer des fichiers de niveau de n'importe quelle forme, tant que vous arriver à les lire avec votre code.
Moi j'ai choisi de représenter chaque sprite par un caractère, et de les ranger par lignes.

Je vous laisse voir un de mes fichier de niveau pour que vous compreniez mieux :)

d00mmmmm0m00mmm
0m00000m0mm0m00
00mm0m000m0000m
m000mmmm000mmmm
000m00000mmm00m
mm0mmmm0mm000mm
000mmm0000mmmmm
0m000mm0m0mm00m
0mm0m000m000mmm
mmm00mmmm0mmmmm
mmm0mm0m00mm00m
m000m00m0mm00mm
00mm00m00000mmm
mmmmm0mm0mm0mmm
m0000mmm00m000a

d = sprite de départ
a = sprite d'arrivée
m = sprite de mur
0 = rien :)

Vous pouvez voir que les sprites sont rangés par 15 sur 15 lignes, une ligne de texte par ligne de sprites à l'écran ! :p
On pourrait presque trouver le chemin en mode texte en suivant les 0 :lol:

Bien sur, ce n'est pas la seule possibilité, et on peut sans aucun doute trouver mieux, surtout au niveau de la lisibilité ! :p

Vous pouvez parcourir les lignes d'un fichier avec :

with open(fichier, "r") as fichier:
	for ligne in fichier:

Puis les caractères dans une ligne de la même façon !

Je vous conseille de ranger les caractères dans une liste, qui symbolisera une ligne, et de ranger toutes les lignes (/listes), dans une autre liste, qui symbolisera la structure entière du niveau !
Vous aurez ainsi quelque chose comme ça :

LISTE DE NIVEAU
     LISTE DE LA LIGNE 1
          SPRITE 1 , SPRITE 2 ...
     LISTE DE LA LIGNE 2
          SPRITE 1 , SPRITE 2 ...

Cela permettra d'accéder facilement à une case, et de regarder ce qu'il y a à l'intérieur par exemple !

liste_niveau[0][0] #1er sprite de la première ligne (normalement égal à "d")
liste_niveau[3][4] #5e sprite de la 4e ligne
liste_niveau[14][14] #Dernier sprite de la dernière ligne (normalement égal à "a")

Une fois que vous avez votre liste de structure, il ne vous reste plus qu'à la parcourir pour l'afficher !
Attention, vous devez faire un double parcours ! Vous parcourez la liste globale, qui vous sort les lignes, que vous parcourez elles aussi, pour obtenir chaque sprite !
En indentant deux nombres différents, vous devez pouvoir savoir sur quelle ligne et quelle colonne vous êtes. :)
Et il ne vous reste plus qu'à trouver la position "réelle" (en pixels, pas en cases) de chaque sprite ! :)

position_x = num_case_x * taille sprite
position_y = num_case_y * taille_sprite

C'est compris ? :) Ce système était peut-être le plus compliqué du jeu !

Et une fois que vous pouvez vérifier la nature de chaque case, il est facile d'interdire le déplacement si celle-ci est un mur ! :p

constantes.py

Mon fichier constante contient les adresses des images, pour une modification plus facile, le titre de la fenêtre, son icône, le nombre de sprites sur une largeur, la taille des sprites, et donc la taille de la fenêtre (multiplie les deux dernières constantes).
Vous pouvez arranger le votre comme bon vous semble, je vous donne seulement le mien à titre d'exemple ! :D

C'est parti !

Maintenant, vous devez posséder toutes les clés pour pouvoir créer ce programme ! :D
N'hésitez pas à y passer du temps, j'y ai moi même passé quelques heures ! Bonne chance !

Correction !

Voici donc la correction ! :diable:
Vous pouvez ne pas avoir codé exactement le même programme que moi, l'important, c'est qu'il soit fonctionnel et qu'il respecte le cahier des charges ! :)
Le mien n'est certainement pas le meilleur qui soit, mais j'ai essayé de faire le plus clair possible, pour que vous compreniez une méthode qui marche !

Si vous ne parvenez pas à coder votre programme, ne regardez pas tout de suite la correction, c'est en codant et en réfléchissant (ou l'inverse ? :-° ) que l'on apprend ! Ne l'oubliez pas ! :)

Sachez qu'après le tutoriel sur Python, ainsi que la première partie de celui-ci, vous avez tous les éléments pour créer ce jeu ! N'hésitez donc pas à relire ces tutoriels si vous êtes coincé quelque part ! :)

Allez, voici mes pages :

dklabyrinthe.py
#!/usr/bin/python3
# -*- coding: Utf-8 -*

"""
Jeu Donkey Kong Labyrinthe
Jeu dans lequel on doit déplacer DK jusqu'aux bananes à travers un labyrinthe.

Script Python
Fichiers : dklabyrinthe.py, classes.py, constantes.py, n1, n2 + images
"""

import pygame
from pygame.locals import *

from classes import *
from constantes import *

pygame.init()

#Ouverture de la fenêtre Pygame (carré : largeur = hauteur)
fenetre = pygame.display.set_mode((cote_fenetre, cote_fenetre))
#Icone
icone = pygame.image.load(image_icone)
pygame.display.set_icon(icone)
#Titre
pygame.display.set_caption(titre_fenetre)


#BOUCLE PRINCIPALE
continuer = 1
while continuer:	
	#Chargement et affichage de l'écran d'accueil
	accueil = pygame.image.load(image_accueil).convert()
	fenetre.blit(accueil, (0,0))

	#Rafraichissement
	pygame.display.flip()

	#On remet ces variables à 1 à chaque tour de boucle
	continuer_jeu = 1
	continuer_accueil = 1

	#BOUCLE D'ACCUEIL
	while continuer_accueil:
	
		#Limitation de vitesse de la boucle
		pygame.time.Clock().tick(30)
	
		for event in pygame.event.get():
		
			#Si l'utilisateur quitte, on met les variables 
			#de boucle à 0 pour n'en parcourir aucune et fermer
			if event.type == QUIT or event.type == KEYDOWN and event.key == K_ESCAPE:
				continuer_accueil = 0
				continuer_jeu = 0
				continuer = 0
				#Variable de choix du niveau
				choix = 0
				
			elif event.type == KEYDOWN:				
				#Lancement du niveau 1
				if event.key == K_F1:
					continuer_accueil = 0	#On quitte l'accueil
					choix = 'n1'		#On définit le niveau à charger
				#Lancement du niveau 2
				elif event.key == K_F2:
					continuer_accueil = 0
					choix = 'n2'
			
		

	#on vérifie que le joueur a bien fait un choix de niveau
	#pour ne pas charger s'il quitte
	if choix != 0:
		#Chargement du fond
		fond = pygame.image.load(image_fond).convert()

		#Génération d'un niveau à partir d'un fichier
		niveau = Niveau(choix)
		niveau.generer()
		niveau.afficher(fenetre)

		#Création de Donkey Kong
		dk = Perso("images/dk_droite.png", "images/dk_gauche.png", 
		"images/dk_haut.png", "images/dk_bas.png", niveau)

				
	#BOUCLE DE JEU
	while continuer_jeu:
	
		#Limitation de vitesse de la boucle
		pygame.time.Clock().tick(30)
	
		for event in pygame.event.get():
		
			#Si l'utilisateur quitte, on met la variable qui continue le jeu
			#ET la variable générale à 0 pour fermer la fenêtre
			if event.type == QUIT:
				continuer_jeu = 0
				continuer = 0
		
			elif event.type == KEYDOWN:
				#Si l'utilisateur presse Echap ici, on revient seulement au menu
				if event.key == K_ESCAPE:
					continuer_jeu = 0
					
				#Touches de déplacement de Donkey Kong
				elif event.key == K_RIGHT:
					dk.deplacer('droite')
				elif event.key == K_LEFT:
					dk.deplacer('gauche')
				elif event.key == K_UP:
					dk.deplacer('haut')
				elif event.key == K_DOWN:
					dk.deplacer('bas')			
			
		#Affichages aux nouvelles positions
		fenetre.blit(fond, (0,0))
		niveau.afficher(fenetre)
		fenetre.blit(dk.direction, (dk.x, dk.y)) #dk.direction = l'image dans la bonne direction
		pygame.display.flip()

		#Victoire -> Retour à l'accueil
		if niveau.structure[dk.case_y][dk.case_x] == 'a':
			continuer_jeu = 0
classes.py
"""Classes du jeu de Labyrinthe Donkey Kong"""

import pygame
from pygame.locals import * 
from constantes import *

class Niveau:
	"""Classe permettant de créer un niveau"""
	def __init__(self, fichier):
		self.fichier = fichier
		self.structure = 0
	
	
	def generer(self):
		"""Méthode permettant de générer le niveau en fonction du fichier.
		On crée une liste générale, contenant une liste par ligne à afficher"""	
		#On ouvre le fichier
		with open(self.fichier, "r") as fichier:
			structure_niveau = []
			#On parcourt les lignes du fichier
			for ligne in fichier:
				ligne_niveau = []
				#On parcourt les sprites (lettres) contenus dans le fichier
				for sprite in ligne:
					#On ignore les "\n" de fin de ligne
					if sprite != '\n':
						#On ajoute le sprite à la liste de la ligne
						ligne_niveau.append(sprite)
				#On ajoute la ligne à la liste du niveau
				structure_niveau.append(ligne_niveau)
			#On sauvegarde cette structure
			self.structure = structure_niveau
	
	
	def afficher(self, fenetre):
		"""Méthode permettant d'afficher le niveau en fonction 
		de la liste de structure renvoyée par generer()"""
		#Chargement des images (seule celle d'arrivée contient de la transparence)
		mur = pygame.image.load(image_mur).convert()
		depart = pygame.image.load(image_depart).convert()
		arrivee = pygame.image.load(image_arrivee).convert_alpha()
		
		#On parcourt la liste du niveau
		num_ligne = 0
		for ligne in self.structure:
			#On parcourt les listes de lignes
			num_case = 0
			for sprite in ligne:
				#On calcule la position réelle en pixels
				x = num_case * taille_sprite
				y = num_ligne * taille_sprite
				if sprite == 'm':		   #m = Mur
					fenetre.blit(mur, (x,y))
				elif sprite == 'd':		   #d = Départ
					fenetre.blit(depart, (x,y))
				elif sprite == 'a':		   #a = Arrivée
					fenetre.blit(arrivee, (x,y))
				num_case += 1
			num_ligne += 1
			
			
			
			
class Perso:
	"""Classe permettant de créer un personnage"""
	def __init__(self, droite, gauche, haut, bas, niveau):
		#Sprites du personnage
		self.droite = pygame.image.load(droite).convert_alpha()
		self.gauche = pygame.image.load(gauche).convert_alpha()
		self.haut = pygame.image.load(haut).convert_alpha()
		self.bas = pygame.image.load(bas).convert_alpha()
		#Position du personnage en cases et en pixels
		self.case_x = 0
		self.case_y = 0
		self.x = 0
		self.y = 0
		#Direction par défaut
		self.direction = self.droite
		#Niveau dans lequel le personnage se trouve 
		self.niveau = niveau
	
	
	def deplacer(self, direction):
		"""Methode permettant de déplacer le personnage"""
		
		#Déplacement vers la droite
		if direction == 'droite':
			#Pour ne pas dépasser l'écran
			if self.case_x < (nombre_sprite_cote - 1):
				#On vérifie que la case de destination n'est pas un mur
				if self.niveau.structure[self.case_y][self.case_x+1] != 'm':
					#Déplacement d'une case
					self.case_x += 1
					#Calcul de la position "réelle" en pixel
					self.x = self.case_x * taille_sprite
			#Image dans la bonne direction
			self.direction = self.droite
		
		#Déplacement vers la gauche
		if direction == 'gauche':
			if self.case_x > 0:
				if self.niveau.structure[self.case_y][self.case_x-1] != 'm':
					self.case_x -= 1
					self.x = self.case_x * taille_sprite
			self.direction = self.gauche
		
		#Déplacement vers le haut
		if direction == 'haut':
			if self.case_y > 0:
				if self.niveau.structure[self.case_y-1][self.case_x] != 'm':
					self.case_y -= 1
					self.y = self.case_y * taille_sprite
			self.direction = self.haut
		
		#Déplacement vers le bas
		if direction == 'bas':
			if self.case_y < (nombre_sprite_cote - 1):
				if self.niveau.structure[self.case_y+1][self.case_x] != 'm':
					self.case_y += 1
					self.y = self.case_y * taille_sprite
			self.direction = self.bas
constantes.py
"""Constantes du jeu de Labyrinthe Donkey Kong"""

#Paramètres de la fenêtre
nombre_sprite_cote = 15
taille_sprite = 30
cote_fenetre = nombre_sprite_cote * taille_sprite

#Personnalisation de la fenêtre
titre_fenetre = "DK Labyrinthe"
image_icone = "images/dk_droite.png"

#Listes des images du jeu
image_accueil = "images/accueil.png"
image_fond = "images/fond.jpg"
image_mur = "images/mur.png"
image_depart = "images/depart.png"
image_arrivee = "images/arrivee.png"

Je vous mets aussi mes deux fichiers de niveau, allez :p :

n1

d00mmmmm0m00mmm
0m00000m0mm0m00
00mm0m000m0000m
m000mmmm000mmmm
000m00000mmm00m
mm0mmmm0mm000mm
000mmm0000mmmmm
0m000mm0m0mm00m
0mm0m000m000mmm
mmm00mmmm0mmmmm
mmm0mm0m00mm00m
m000m00m0mm00mm
00mm00m00000mmm
mmmmm0mm0mm0mmm
m0000mmm00m000a

n2

d000m0m0mmm0mmm
0mm000m00000000
00m0mm00mm0m0m0
0m00000mmm0m0m0
00mmmm0mm0m000m
m000mm00m0mmm00
m0m0mmmm00000mm
m0m0m0000mmm0m0
000mm0mm0m000m0
m0mm00000m0mmm0
m000mmmm0m0000m
mmm0m0000mmm000
m000m0mmmmmm00m
m0mmm0m00000000
m00000mmm0mmmma

Et voilà ! :D Vous pouvez télécharger le fichier .zip contenant tous les fichiers du programme ici :

Image utilisateurDK Labyrinthe - Jeu CompletImage utilisateur

Malgré mes commentaires très fréquents, ce script mérite surement quelques explications !

Voyons tout d'abord le fichier dklabyrinthe.py :

  • Documentation sur le programme

  • Importation des fichiers nécessaires au script (pygame + mes propres modules)

  • Initialisation de Pygame et ouverture de la fenêtre

  • Boucle principale : c'est la boucle du programme, tant qu'elle tourne, le programme est en marche.

  • Au début de celle-ci, on affiche l'écran d'accueil.

  • Boucle d'accueil : tant qu'elle tourne, l'écran d'accueil est visible.

  • Quand l'utilisateur passe l'accueil, on ferme la boucle d'accueil.

  • On charge le niveau, le personnage (grâce à des classes) et les images.

  • Boucle de jeu : tant qu'elle tourne, l'utilisateur joue et déplace DK.

  • On met à jour l'écran avec les nouvelles positions à chaque tour de boucle (le niveau est affiché grâce à une méthode de la classe Niveau)

  • A chaque tour de boucle, on vérifie que le joueur n'a pas gagné. Si c'est le cas, on le renvoit à l'écran d'accueil.

Voyons maintenant le fichier classes.py :

  • Documentation sur le fichier.

  • Importation des fichiers nécessaires. (pygame et constantes.py)

  • Classe Niveau. Elle prend en paramètre le chemin vers le fichier de niveau à lire.

  • Cette classe possède deux méthodes. Une qui ouvre le fichier, le lit et enregistre son contenu dans une liste, copiée dans l'attribut structure. L'autre lit cette liste et affiche son contenu à l'écran, elle doit donc être appelée à chaque fois qu'on rafraîchit l'écran ! :)

  • Classe Perso. Elle prend en paramètre les images des 4 positions du personnage, ainsi que la liste de structure du niveau.

  • Cette classe possède une seule méthode, qui s'occupe du déplacement de DK, qu'on appelle donc à chaque déplacement, avec en paramètre la direction de celui-ci. ('droite', 'gauche', 'haut', 'bas')

  • Elle vérifie qu'on ne sort pas de l'écran. (On enlève 1 à la constante nombre_sprite_cote car la case de DK est elle comptée à partir de 0 ;) )

  • Elle vérifie que la case de destination est libre en lisant la liste de structure.

  • Elle déplace DK d'une case et change sa position réelle en pixel. L'attribut de direction prend la valeur de la direction du déplacement.

Ca y est ! Vous pouvez montrer votre premier jeu graphique en Python à toute votre famille ! :lol:

C'en est fini avec les bases de Pygame, dans la suite de ce tutoriel, nous nous attaquerons à une utilisation un peu plus avancée de cette bibliothèque, comme l'utilisation du son, la maîtrise du temps ou encore des transformations d'images !
Autant vous dire que les possibilités de Pygame ne s'arrêtent pas là, même si vous possédez maintenant assez d'informations pour pouvoir coder des jeux sympas ! :)

Alors ? Content ? :p
A la fin de cette partie, vous pouvez dire que vous avez fait un grand pas dans l'utilisation de Pygame, et dans la création de jeux vidéos ! Avec ces bases, vous avez dans vos mains de grandes possibilités, mais il faut savoir que Pygame ne s'arrête pas là !
Dans la prochaine partie vous pourrez découvrir d'autres fonctionnalités de Pygame, et ainsi grandement améliorer vos jeux ! :)

Exemple de certificat de réussite
Exemple de certificat de réussite