import tdoc.pygame
setup_canvas()
import asyncio
import os
import sys
import pygame
from random import randint, choice
from pyodide.ffi import run_sync
# Tant que pygame est actif, il capture le clavier de toute la page (on ne peut
# plus écrire dans les éditeurs). Il faut donc toujours appeler pygame.quit()
# à la fin du programme : arrêt avec le bouton « stop » (voir _wait_frame),
# erreur (ci-dessous) ou fin normale (bloc pygame_end).
if not getattr(sys.excepthook, "_pygame_quit", False):
_original_excepthook = sys.excepthook
def _excepthook(exc_type, *args):
pygame.quit()
# Arrêt volontaire (bouton « stop ») : inutile d'afficher un message.
if issubclass(exc_type, asyncio.CancelledError):
return
_original_excepthook(exc_type, *args)
_excepthook._pygame_quit = True
sys.excepthook = _excepthook
pygame.quit() # repart de zéro si l'exécution précédente a été interrompue
pygame.init()
width, height = 600, 600
window = pygame.display.set_mode((width, height))
# ---------------------------------------------------------------------------
# Boucle de jeu
# ---------------------------------------------------------------------------
_FRAME_MS = 1000 / 60 # 60 images par seconde, quel que soit l'écran
_FREEZE_MS = 3000 # délai après lequel on considère que le jeu est bloqué
_next_frame = None
_last_refresh = animation_time()
_keys_now = []
_keys_before = []
class _Done:
"""Permet aux anciens programmes d'écrire « await refresh(...) »."""
def __await__(self):
return iter(())
def _wait_frame():
"""Attend la prochaine image du navigateur, sans async/await."""
t = run_sync(animation_frame())
# Le bouton « stop » annule la tâche, mais du code sans await ne le
# remarquerait jamais : on arrête donc le programme ici.
task = asyncio.current_task()
if task is not None and task.cancelling():
# L'annulation est traitée ici : sinon asyncio l'appliquerait une
# seconde fois à la fin du programme (message « PythonError »).
task.uncancel()
try:
task._must_cancel = False
except AttributeError:
pass
pygame.quit() # rend le clavier à la page
raise asyncio.CancelledError()
return t
def refresh(color):
global _next_frame, _last_refresh, _keys_now, _keys_before
# Sur un écran 120 ou 144 Hz, requestAnimationFrame est appelé plus de 60
# fois par seconde : on saute des images pour garder la même vitesse de jeu
# sur tous les ordinateurs.
t = _wait_frame()
if _next_frame is None:
_next_frame = t
while t < _next_frame - _FRAME_MS / 2:
t = _wait_frame()
_next_frame = max(_next_frame + _FRAME_MS, t)
pygame.display.flip()
window.fill(color)
pygame.event.get() # vide la file d'événements (sinon elle se remplit)
_keys_before = _keys_now
_keys_now = _read_keys()
_last_refresh = animation_time()
return _Done()
def _check_not_frozen():
"""Détecte une boucle de jeu qui ne rend jamais la main au navigateur."""
if animation_time() - _last_refresh > _FREEZE_MS:
raise RuntimeError(
"Le jeu est bloqué : refresh(...) n'a pas été exécuté depuis plus "
"de 3 secondes. Avez-vous oublié refresh(...) au début de la "
"boucle de jeu ? Ou avez-vous écrit une autre boucle while qui ne "
"se termine jamais ?")
# ---------------------------------------------------------------------------
# Entrées utilisateur
# ---------------------------------------------------------------------------
# Touches dont le code est en dehors de 0-511 et qui échappent donc à la
# boucle de _read_keys().
_SPECIAL_KEYS = [
(pygame.K_UP, "UP"), (pygame.K_DOWN, "DOWN"),
(pygame.K_LEFT, "LEFT"), (pygame.K_RIGHT, "RIGHT"),
(pygame.K_LSHIFT, "SHIFT"), (pygame.K_RSHIFT, "SHIFT"),
(pygame.K_LCTRL, "CTRL"), (pygame.K_RCTRL, "CTRL"),
(pygame.K_LALT, "ALT"), (pygame.K_RALT, "ALT"),
(pygame.K_RETURN, "ENTER"), (pygame.K_KP_ENTER, "ENTER"),
(pygame.K_KP0, "0"), (pygame.K_KP1, "1"), (pygame.K_KP2, "2"),
(pygame.K_KP3, "3"), (pygame.K_KP4, "4"), (pygame.K_KP5, "5"),
(pygame.K_KP6, "6"), (pygame.K_KP7, "7"), (pygame.K_KP8, "8"),
(pygame.K_KP9, "9"),
]
def _read_keys():
pressed = []
keys = pygame.key.get_pressed()
# Codes de touches 0-511 : lettres, chiffres, espace, échap, tab, ...
# (les codes de touches suivent la disposition du clavier, QWERTZ compris)
for keycode in range(len(keys)):
if keys[keycode]:
name = pygame.key.name(keycode).upper()
if name and name != "UNKNOWN" and name not in pressed:
pressed.append(name)
for keycode, name in _SPECIAL_KEYS:
if keys[keycode] and name not in pressed:
pressed.append(name)
mouse_buttons = pygame.mouse.get_pressed()
if mouse_buttons[0]: pressed.append("MOUSE_1")
if mouse_buttons[1]: pressed.append("MOUSE_2")
if mouse_buttons[2]: pressed.append("MOUSE_3")
return pressed
def get_pressed_keys():
_check_not_frozen()
return list(_keys_now)
def get_new_keys():
_check_not_frozen()
return [key for key in _keys_now if key not in _keys_before]
def get_mouse_x():
return pygame.mouse.get_pos()[0]
def get_mouse_y():
return pygame.mouse.get_pos()[1]
# ---------------------------------------------------------------------------
# Acteurs et textes
# ---------------------------------------------------------------------------
_images = {}
_IMAGE_EXTENSIONS = (".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp")
def _load_image(image_path):
"""Charge une image une seule fois, puis la réutilise."""
if image_path not in _images:
if not isinstance(image_path, str) or not os.path.isfile(image_path):
available = sorted(f for f in os.listdir()
if f.lower().endswith(_IMAGE_EXTENSIONS))
raise FileNotFoundError(
f"L'image {image_path!r} n'existe pas. Vérifiez l'orthographe "
f"et l'extension (par exemple \"roger.png\"). Images "
f"disponibles sur cette page : {', '.join(available)}")
_images[image_path] = pygame.image.load(image_path).convert_alpha()
return _images[image_path]
class _Element:
"""Fonctionnalités communes à Actor et Text."""
collision_margin = 0
def draw(self):
_check_not_frozen()
if not self._killed:
window.blit(self.image, self.rect)
def get_x(self):
return self.rect.centerx
def get_y(self):
return self.rect.centery
def get_width(self):
return self.rect.width
def get_height(self):
return self.rect.height
def get_left(self):
return self.rect.left
def get_right(self):
return self.rect.right
def get_top(self):
return self.rect.top
def get_bottom(self):
return self.rect.bottom
def move(self, dx, dy):
self.rect.move_ip(dx, dy)
def set_position(self, x, y):
self.rect.center = (x, y)
@property
def collision_rect(self):
"""Rectangle de collision, légèrement plus petit que l'image."""
return self.rect.inflate(-self.rect.width * self.collision_margin,
-self.rect.height * self.collision_margin)
def collide(self, other_actor):
if not isinstance(other_actor, _Element):
if isinstance(other_actor, list):
raise TypeError(
"collide() attend un acteur, pas une liste. Pour tester "
"tous les acteurs d'une liste, utilisez une boucle for.")
raise TypeError(f"collide() attend un acteur (Actor ou Text), "
f"pas {type(other_actor).__name__}.")
if self._killed or other_actor._killed:
return False
return self.collision_rect.colliderect(other_actor.collision_rect)
def kill(self):
self._killed = True
def is_killed(self):
return self._killed
def revive(self):
self._killed = False
class Actor(_Element):
collision_margin = 0.05 # 5% de marge
def __init__(self, image_path, x, y):
self.image_path = image_path
self.original_image = _load_image(image_path)
self.image = self.original_image
self.rect = self.image.get_frect(center=(x, y))
self.factor = 1
self.angle = 0
self.flip_h = False
self.flip_v = False
self._killed = False
def _update_image(self):
"""Reconstruit l'image à partir de l'originale (taille, miroir, angle)."""
image = self.original_image
if self.factor != 1:
new_size = (round(image.get_width() * self.factor),
round(image.get_height() * self.factor))
image = pygame.transform.scale(image, new_size)
if self.flip_h or self.flip_v:
image = pygame.transform.flip(image, self.flip_h, self.flip_v)
if self.angle % 360 != 0:
image = pygame.transform.rotate(image, self.angle)
center = self.rect.center
self.image = image
self.rect = image.get_frect(center=center)
def scale(self, factor):
if factor < 0:
raise ValueError("scale() attend un facteur positif, par exemple "
"2 (2x plus grand) ou 0.5 (2x plus petit).")
self.factor = factor
self._update_image()
def set_angle(self, angle):
self.angle = angle
self._update_image()
def flip(self, horizontal=True, vertical=False):
# Inverse l'image à chaque appel
self.flip_h = self.flip_h != horizontal
self.flip_v = self.flip_v != vertical
self._update_image()
def set_flip(self, horizontal, vertical=False):
# Fixe le sens de l'image : peut être appelé à chaque tour de boucle
self.flip_h = horizontal
self.flip_v = vertical
self._update_image()
_fonts = {}
class Text(_Element):
def __init__(self, text, x, y, *args, size=36):
args = list(args)
# Ancienne forme : Text(texte, x, y, True, couleur, fond)
self.antialias = True
if args and isinstance(args[0], bool):
self.antialias = args.pop(0)
if len(args) > 3:
raise TypeError("Trop de paramètres. Utilisez : Text(texte, x, y, "
"couleur_texte, couleur_fond, taille)")
self.color = args[0] if len(args) >= 1 else (0, 0, 0)
self.background = args[1] if len(args) >= 2 else None
self.size = args[2] if len(args) >= 3 else size
if self.size not in _fonts:
_fonts[self.size] = pygame.font.Font(None, self.size)
self.font = _fonts[self.size]
self._killed = False
self.rect = pygame.FRect(0, 0, 0, 0)
self.rect.center = (x, y)
self.set_text(text)
def set_text(self, text):
self.text = str(text)
center = self.rect.center
self.image = self.font.render(self.text, self.antialias, self.color,
self.background)
self.rect = self.image.get_frect(center=center)
# ---------------------------------------------------------------------------
# Timer
# ---------------------------------------------------------------------------
class Timer:
def __init__(self, time):
self.time = time * 1000
self.started = False
def start(self):
self.started = True
self.start_time = animation_time()
self.end_time = self.start_time + self.time
def is_finished(self):
# Un timer qui n'a jamais été démarré est considéré comme terminé.
if not self.started:
return True
return animation_time() >= self.end_time
def get_time_left(self):
if self.is_finished():
return 0
return (self.end_time - animation_time()) / 1000
def __str__(self):
if not self.started:
return "Pas démarré"
return f"{self.get_time_left():.2f}s"
# ---------------------------------------------------------------------------
# Sons
# ---------------------------------------------------------------------------
_MUSIC_MIN_SIZE = 500_000 # au-delà (en octets), le fichier est lu en streaming
_current_music = None
class Sound:
"""Les petits fichiers (bruitages) sont chargés en mémoire et peuvent être
joués en même temps. Les gros fichiers (musiques) sont lus en streaming,
car les décoder entièrement prendrait plusieurs secondes : une seule
musique peut alors être jouée à la fois."""
def __init__(self, file_path):
if not pygame.mixer.get_init():
pygame.mixer.init()
if not isinstance(file_path, str) or not os.path.isfile(file_path):
raise FileNotFoundError(
f"Le son {file_path!r} n'existe pas. Vérifiez l'orthographe "
f"et l'extension (par exemple \"yoshi.ogg\").")
self.file_path = file_path
self.volume = 1
self.is_music = os.path.getsize(file_path) > _MUSIC_MIN_SIZE
self.sound = None if self.is_music else pygame.mixer.Sound(file_path)
self.channel = None
def _is_current_music(self):
return self.is_music and _current_music is self
def play(self, loops=0):
global _current_music
if self.is_music:
pygame.mixer.music.load(self.file_path)
pygame.mixer.music.set_volume(self.volume)
pygame.mixer.music.play(loops)
_current_music = self
else:
self.channel = self.sound.play(loops)
def pause(self):
if self._is_current_music():
pygame.mixer.music.pause()
elif self.channel is not None:
self.channel.pause()
def unpause(self):
if self._is_current_music():
pygame.mixer.music.unpause()
elif self.channel is not None:
self.channel.unpause()
def stop(self):
if self._is_current_music():
pygame.mixer.music.stop()
elif self.sound is not None:
self.sound.stop()
def set_volume(self, volume):
self.volume = volume
if self._is_current_music():
pygame.mixer.music.set_volume(volume)
elif self.sound is not None:
self.sound.set_volume(volume)
# Anciens programmes écrits dans une fonction « async def main() ».
if "main" in globals():
try:
await main()
finally:
pygame.quit()
# Le programme est terminé : pygame rend le clavier à la page.
pygame.quit()
Projet Grimpeur#
Dans ce jeu, Roger doit grimper le plus haut possible en rebondissant de plateforme en plateforme. Il rebondit automatiquement dès qu'il retombe sur une plateforme : le joueur contrôle seulement sa direction, vers la gauche ou vers la droite. S'il rate une plateforme et tombe en bas de l'écran, la partie est perdue.
Créez et dessinez l'acteur principal roger avec l'image roger.png, à la position 300, 450. Utilisez ensuite la méthode scale() pour le rendre un peu plus petit (par exemple 0.7). Rappel : l'écran fait 600x600 pixels.
Comme pour Flappy Bird, Roger est soumis à la gravité.
Avant la boucle de jeu, créez une variable
vitesse_y = 0et une variableGRAVITE = 0.3.Dans la boucle de jeu, augmentez
vitesse_ydeGRAVITEà chaque tour, puis déplacez Roger verticalement devitesse_yavecmove().
Roger devrait tomber de plus en plus vite et sortir de l'écran par le bas.
Le joueur doit pouvoir diriger Roger.
Avec
get_pressed_keys(), déplacez Roger de 5 pixels vers la gauche avec A et vers la droite avec D.Pour que Roger regarde dans la direction où il va, utilisez
roger.set_flip(True)lorsqu'il va à gauche etroger.set_flip(False)lorsqu'il va à droite.Lorsque Roger sort de l'écran par un côté, il doit réapparaître de l'autre côté : si sa position horizontale (
get_x()) est inférieure à 0, placez-le à600avecset_position()(sans changer sa position verticale). Faites l'inverse s'il dépasse 600.
Créons les plateformes. Elles seront stockées dans une liste.
Avant la boucle de jeu, copiez/collez le code suivant. Il crée une première plateforme juste sous Roger, puis 7 autres plateformes à des positions horizontales aléatoires, espacées de 75 pixels verticalement :
plateformes = [Actor("brick.png", 300, 570)]
for i in range(7):
plateforme = Actor("brick.png", randint(40, 560), 495 - i * 75)
plateformes.append(plateforme)
Juste après, avec une boucle
for, agrandissez chaque plateforme 2 fois avecscale().Dans la boucle de jeu, dessinez toutes les plateformes avec une boucle
for.
Pour l'instant, Roger traverse les plateformes et tombe.
Roger doit rebondir sur les plateformes.
Avant la boucle de jeu, créez une variable
VITESSE_SAUT = -11.Dans la boucle de jeu, pour chaque plateforme, si Roger est en collision avec la plateforme et qu'il est en train de descendre (
vitesse_y > 0), alorsvitesse_yprend la valeurVITESSE_SAUT.
Grâce à la condition vitesse_y > 0, Roger peut traverser une plateforme par le dessous en montant, et ne rebondit que lorsqu'il retombe dessus. Ajustez GRAVITE et VITESSE_SAUT si vous le souhaitez.
Pour l'instant, Roger ne peut pas monter plus haut que le haut de l'écran. Nous allons faire « défiler » le jeu : lorsque Roger monte trop haut, ce n'est plus lui qui monte, mais les plateformes qui descendent.
Dans la boucle de jeu, si la position verticale de Roger (
get_y()) est inférieure à 250 :Calculez de combien il dépasse :
decalage = 250 - roger.get_y()Replacez Roger à la hauteur 250 (sans changer sa position horizontale).
Déplacez toutes les plateformes vers le bas de
decalagepixels.
Roger reste maintenant toujours dans l'écran, et les plateformes défilent vers le bas lorsqu'il monte. Mais au bout de quelques rebonds, il n'y a plus de plateformes...
Plutôt que de créer sans arrêt de nouvelles plateformes, nous allons recycler celles qui sortent de l'écran par le bas.
Dans la boucle de jeu, pour chaque plateforme, si son bord haut (
get_top()) est supérieur à 600, replacez-la tout en haut avecset_position():sa nouvelle position horizontale est aléatoire :
randint(40, 560)sa nouvelle position verticale est
plateforme.get_y() - 600
Comme les 8 plateformes sont espacées de 75 pixels (8 x 75 = 600), remonter une plateforme de 600 pixels la place exactement au-dessus de la plus haute. Roger peut maintenant grimper sans fin !
Affichons la hauteur atteinte par Roger.
Avant la boucle de jeu, créez une variable
hauteur = 0et un textetxt_hauteuren haut de l'écran.À l'étape 6, à chaque défilement, augmentez
hauteurdedecalage.Mettez ensuite à jour le texte :
txt_hauteur.set_text(f"Hauteur : {int(hauteur / 10)} m"). Ici, on considère que 10 pixels valent 1 mètre, etint()permet de supprimer les décimales.
Gérons la défaite.
Avant la boucle de jeu, créez une variable
gameover = False.Si le bord haut de Roger (
get_top()) est supérieur à 600, c'est-à-dire s'il est complètement sorti de l'écran par le bas,gameoverdevientTrue.Modifiez votre code de sorte que tous les mouvements (gravité, déplacements, défilement, recyclage) ne se produisent plus que si
gameoverestFalse.
Lorsque gameover est True, affichez un texte « GAME OVER » au milieu de l'écran. Ajoutez-y la hauteur atteinte, par exemple GAME OVER - 152 m. Pour cela, vous pouvez créer le texte avant la boucle de jeu et le mettre à jour avec set_text() au moment où gameover devient True.
Partie 2 : fonctionnalités intermédiaires
Les fonctionnalités de la partie 2 valent au maximum 10 pts. Vous pouvez donc choisir des éléments de la liste suivante à implémenter et s'additionnant à 10 pts.
(1 pt) Un son est joué à chaque rebond.
(2 pts) Les plateformes ont des couleurs aléatoires (
brick.png,brick_green.pngoubrick_red.png).(2 pts) Augmentez progressivement la difficulté : au-delà d'une certaine hauteur, les plateformes recyclées deviennent plus petites.
(2 pts) Des cadeaux (
gift_blue.png, ...) apparaissent sur certaines plateformes. Les ramasser rapporte des points bonus. Attention, ils doivent défiler avec les plateformes !(3 pts) Une des plateformes se déplace horizontalement et rebondit sur les bords de l'écran.
(3 pts) Plateformes fragiles : certaines plateformes (par exemple les rouges) disparaissent avec
kill()après un rebond. Elles réapparaissent avecrevive()lorsqu'elles sont recyclées.(3 pts) Un fantôme (
blinky.png) traverse régulièrement l'écran. Si Roger le touche, la partie est perdue.(4 pts) Un trampoline (
trampoline.png, à réduire fortement avecscale()) apparaît de temps en temps sur une plateforme. Rebondir dessus fait faire un super saut à Roger.
Partie 3 : fonctionnalités avancées
(2 pts) Afin que le jeu ne commence pas immédiatement lorsqu'on lance le programme, définissez une touche sur laquelle on doit appuyer afin que le jeu démarre.
(3 pts) Ajoutez une fonctionnalité permettant de redémarrer le jeu une fois qu'on a perdu et qu'on appuie sur la touche
R.(3 pts) Le meilleur score de la session (record) est affiché, et un message apparaît lorsqu'il est battu.
(3 pts) La couleur du fond change progressivement avec la hauteur (par exemple du bleu ciel vers le noir de l'espace).
(4 pts) Un bonus (
shield.png) donne un bouclier temporaire : pendant 5 secondes (Timer), Roger ne craint plus les fantômes.(4 pts) Un bonus « fusée » fait monter Roger automatiquement et rapidement pendant 3 secondes.
(4 pts) Roger peut tirer vers le haut avec Espace pour détruire les fantômes.
1while True:
2 refresh((30, 40, 90))
Solution (étapes 1 à 10)
# Étape 1 : Roger
roger = Actor("roger.png", 300, 450)
roger.scale(0.7)
# Étape 2 : gravité
vitesse_y = 0
GRAVITE = 0.3
VITESSE_SAUT = -11
# Étape 4 : les plateformes
plateformes = [Actor("brick.png", 300, 570)]
for i in range(7):
plateforme = Actor("brick.png", randint(40, 560), 495 - i * 75)
plateformes.append(plateforme)
for plateforme in plateformes:
plateforme.scale(2)
# Étape 8 : score
hauteur = 0
txt_hauteur = Text("Hauteur : 0 m", 300, 20, (255, 255, 255))
# Étapes 9 et 10 : fin de partie
gameover = False
txt_gameover = Text("GAME OVER", 300, 300, (255, 255, 255), (200, 0, 0), 60)
while True:
refresh((30, 40, 90))
if gameover == False:
# Étape 2 : gravité
vitesse_y += GRAVITE
roger.move(0, vitesse_y)
# Étape 3 : déplacement gauche/droite et sortie par les côtés
touches = get_pressed_keys()
if "A" in touches:
roger.move(-5, 0)
roger.set_flip(True)
if "D" in touches:
roger.move(5, 0)
roger.set_flip(False)
if roger.get_x() < 0:
roger.set_position(600, roger.get_y())
if roger.get_x() > 600:
roger.set_position(0, roger.get_y())
# Étape 5 : rebond sur les plateformes (seulement en descendant)
for plateforme in plateformes:
if roger.collide(plateforme) and vitesse_y > 0:
vitesse_y = VITESSE_SAUT
# Étape 6 : défilement de l'écran
if roger.get_y() < 250:
decalage = 250 - roger.get_y()
roger.set_position(roger.get_x(), 250)
for plateforme in plateformes:
plateforme.move(0, decalage)
# Étape 8 : score
hauteur += decalage
txt_hauteur.set_text(f"Hauteur : {int(hauteur / 10)} m")
# Étape 7 : recyclage des plateformes sorties en bas
for plateforme in plateformes:
if plateforme.get_top() > 600:
plateforme.set_position(randint(40, 560), plateforme.get_y() - 600)
# Étape 9 : chute
if roger.get_top() > 600:
gameover = True
for plateforme in plateformes:
plateforme.draw()
roger.draw()
txt_hauteur.draw()
# Étape 10
if gameover:
txt_gameover.draw()