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 Échecs#
Ce projet est un peu plus difficile que les autres : il demande d'organiser son code avec soin, car beaucoup de conditions s'imbriquent. Le but n'est pas de programmer toutes les règles des échecs, mais un plateau sur lequel deux joueurs peuvent déplacer leurs pièces chacun leur tour et capturer les pièces adverses. Les règles de déplacement de chaque pièce sont des bonus des parties 2 et 3.
Le plateau est composé de 8x8 cases de 70x70 pixels. Il est décalé de 20 pixels vers la droite et de 40 pixels vers le bas, afin de laisser de la place en haut de l'écran pour un texte.
Créons le plateau de jeu. Chaque case est un acteur, et toutes les cases sont stockées dans une liste.
Avant la boucle de jeu, créez une liste vide
cases = [].Puis, copiez/collez le code suivant :
for ligne in range(8):
for colonne in range(8):
if (ligne + colonne) % 2 == 0:
case = Actor("case_claire.png", 55 + colonne * 70, 75 + ligne * 70)
else:
case = Actor("case_foncee.png", 55 + colonne * 70, 75 + ligne * 70)
cases.append(case)
Dans la boucle de jeu, dessinez toutes les cases avec une boucle
for.
L'opérateur % donne le reste d'une division : (ligne + colonne) % 2 == 0 signifie que ligne + colonne est un nombre pair. C'est ce qui permet d'alterner les cases claires et foncées. Vous devriez voir un damier de 8x8 cases.
Plaçons les pions. Les pièces de chaque joueur sont stockées dans leur propre liste.
Avant la boucle de jeu, créez deux listes vides
pieces_blanchesetpieces_noires.Avec une boucle
for colonne in range(8):, créez pour chaque colonne :un acteur
pion_blanc.pngà la position55 + colonne * 70, 495et ajoutez-le àpieces_blanches;un acteur
pion_noir.pngà la position55 + colonne * 70, 145et ajoutez-le àpieces_noires.
Dans la boucle de jeu, dessinez toutes les pièces des deux listes. Attention : les pièces doivent être dessinées après les cases, sinon elles seront cachées par le plateau.
Vous devriez voir une rangée de pions blancs en bas et une rangée de pions noirs en haut.
Plaçons les autres pièces. Cette fois, chaque pièce est créée « à la main », l'une après l'autre.
Avant la boucle de jeu, créez chaque pièce dans sa propre variable, puis ajoutez-la à sa liste avec
append(). Par exemple, pour la première tour blanche :
tour_blanche_1 = Actor("tour_blanc.png", 55, 565)
pieces_blanches.append(tour_blanche_1)
Les pièces blanches sont sur la rangée du bas (
y = 565) et les pièces noires sur la rangée du haut (y = 75). Leur position horizontale dépend de la colonne :
Colonne |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
|---|---|---|---|---|---|---|---|---|
Pièce |
tour |
cavalier |
fou |
dame |
roi |
fou |
cavalier |
tour |
|
55 |
125 |
195 |
265 |
335 |
405 |
475 |
545 |
Les images ont toujours la forme
piece_couleur.png:tour_blanc.png,cavalier_noir.png,dame_blanc.png, etc.Chaque pièce doit avoir un nom de variable différent (
tour_blanche_1,tour_blanche_2, ...). Nommez les deux roisroi_blancetroi_noir: ces variables seront utiles à l'étape 10.
Vous devriez maintenant voir la position de départ d'une partie d'échecs.
Pour savoir sur quelle pièce ou quelle case le joueur clique, nous allons utiliser un acteur minuscule (un point de 2 pixels) qui suit la souris. Il suffira ensuite de tester ses collisions avec les pièces et les cases.
Avant la boucle de jeu, créez un acteur
curseuravec l'imagecurseur.png, à n'importe quelle position.Dans la boucle de jeu, placez le curseur à la position de la souris :
curseur.set_position(get_mouse_x(), get_mouse_y())Dessinez le curseur en tout dernier.
Vous devriez voir un petit point rouge sous la flèche de la souris lorsqu'elle survole le jeu.
Le joueur doit pouvoir sélectionner une pièce en cliquant dessus. Pour l'instant, seules les pièces blanches peuvent être sélectionnées.
Avant la boucle de jeu, créez une variable
piece_selectionnee = None. En Python,Noneest une valeur spéciale qui signifie « rien » : aucune pièce n'est sélectionnée.Dans la boucle de jeu, récupérez les touches nouvellement pressées :
nouvelles_touches = get_new_keys(). Avecget_new_keys()(et nonget_pressed_keys()), un clic n'est compté qu'une seule fois, même si le bouton reste enfoncé plusieurs images.Si
"MOUSE_1"est dansnouvelles_toucheset quepiece_selectionnee == None:pour chaque pièce de
pieces_blanches, si le curseur est en collision avec cette pièce, alorspiece_selectionneeprend la valeur de cette pièce.
Pour montrer la pièce sélectionnée, créez avant la boucle de jeu un acteur
cadreavec l'imageselection.png. Dans la boucle de jeu, sipiece_selectionnee != None, placez le cadre à la position de la pièce sélectionnée (get_x()etget_y()) et dessinez-le, après les cases mais avant les pièces.
En cliquant sur une pièce blanche, sa case devrait devenir verte.
Une fois une pièce sélectionnée, un deuxième clic doit la déplacer sur la case cliquée. Modifiez la condition de l'étape 5 de sorte à obtenir la structure suivante :
Si le joueur clique :
Si aucune pièce n'est sélectionnée :
(code de l'étape 5)
Sinon :
Pour chaque case de la liste des cases :
Si le curseur est en collision avec la case :
Placer la pièce sélectionnée au centre de la case
piece_selectionnee = None
Pour placer la pièce au centre de la case, utilisez
piece_selectionnee.set_position(case.get_x(), case.get_y()).Il est important d'utiliser un
if/else: sinon, le même clic sélectionnerait la pièce et la déplacerait immédiatement.
Vous pouvez maintenant déplacer les pièces blanches où vous voulez. Si vous cliquez en dehors du plateau, la pièce est simplement désélectionnée.
Les joueurs doivent maintenant jouer chacun leur tour.
Avant la boucle de jeu, créez une variable
tour = "blanc"et un textetxt_tour = Text("Aux blancs de jouer", 300, 20, (255, 255, 255)). Dessinez ce texte dans la boucle de jeu.Au début de la boucle de jeu, ajoutez le code suivant. Il permet d'utiliser
mes_piecespour désigner la liste des pièces du joueur dont c'est le tour, etpieces_adversespour celle de son adversaire :
if tour == "blanc":
mes_pieces = pieces_blanches
pieces_adverses = pieces_noires
else:
mes_pieces = pieces_noires
pieces_adverses = pieces_blanches
À l'étape 5, remplacez
pieces_blanchesparmes_pieces.À l'étape 6, juste après avoir placé la pièce sur sa case (donc dans le
ifde la collision avec la case), changez de joueur : sitourvaut"blanc", il devient"noir", sinon il devient"blanc". Mettez aussi à jour le texte avectxt_tour.set_text(...).
Les blancs et les noirs jouent maintenant chacun leur tour. Cliquer en dehors du plateau ne fait pas changer de joueur.
Gérons la capture des pièces adverses.
À l'étape 6, juste après avoir placé la pièce sur sa case, parcourez la liste
pieces_adversesavec une bouclefor.Si la pièce sélectionnée est en collision avec une pièce adverse, détruisez la pièce adverse avec
kill().
Une pièce killed n'est plus dessinée et n'entre plus en collision : elle ne peut donc plus être sélectionnée ni capturée une deuxième fois. Vous pouvez maintenant capturer les pièces de votre adversaire !
Pour l'instant, un joueur peut déplacer une pièce sur l'une de ses propres pièces. Corrigeons cela : si le joueur clique sur une de ses pièces alors qu'une pièce est déjà sélectionnée, la sélection doit simplement changer.
Au début du
elsede l'étape 6, créez une variablecase_occupee = False.Parcourez
mes_pieces: si le curseur est en collision avec l'une d'elles, cette pièce devient lapiece_selectionneeetcase_occupeedevientTrue.Le déplacement de l'étape 6 (la boucle sur les cases et le
piece_selectionnee = None) ne doit maintenant avoir lieu que sicase_occupee == False.
Vous pouvez maintenant changer d'avis en cliquant sur une autre de vos pièces, et il est impossible de capturer ses propres pièces.
La partie se termine lorsqu'un roi est capturé.
Avant la boucle de jeu, créez une variable
gameover = Falseet un textetxt_finvide, par exempleText("", 300, 300, (0, 0, 0), (255, 255, 255), 60).Dans la boucle de jeu, si le roi noir (la variable
roi_noircréée à l'étape 3) est capturé (roi_noir.is_killed()),gameoverdevientTrueet le texte devient"Les blancs ont gagné !". Faites de même pour le roi blanc.Les clics ne doivent plus être pris en compte si
gameovervautTrue, ettxt_findoit être dessiné.
Bravo, vous avez un jeu d'échecs jouable à deux !
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.
Aide pour les règles de déplacement
Pour vérifier qu'un déplacement respecte les règles, calculez avant de déplacer la pièce de combien de cases elle se déplacerait (dans la boucle sur les cases, quand le curseur touche la case) :
dx = (case.get_x() - piece_selectionnee.get_x()) / 70
dy = (case.get_y() - piece_selectionnee.get_y()) / 70
dx vaut par exemple 2 si la pièce se déplace de 2 cases vers la droite, et -1 si elle se déplace d'une case vers la gauche. De même pour dy (positif = vers le bas). La fonction abs() donne la valeur absolue d'un nombre : abs(-2) vaut 2.
Pour savoir de quelle pièce il s'agit, utilisez piece_selectionnee.image_path, qui contient le nom de son image (par exemple "cavalier_blanc.png").
Si le déplacement n'est pas autorisé, la pièce ne bouge pas, et le joueur doit rejouer.
(1 pt) Appuyer sur Échap (
"ESCAPE") annule la sélection.(2 pts) La case survolée par la souris est mise en évidence avec l'image
survol.png.(2 pts) Un son est joué lors d'un déplacement, et un autre lors d'une capture.
(2 pts) Le nombre de pièces capturées par chaque joueur est affiché en haut de l'écran.
(3 pts) Le roi ne peut se déplacer que d'une case, dans n'importe quelle direction.
(3 pts) Le cavalier se déplace en « L » : 2 cases dans une direction et 1 case dans l'autre.
(3 pts) Le pion avance d'une case (vers le haut pour les blancs, vers le bas pour les noirs), ou de deux cases s'il est encore sur sa ligne de départ. +1 pt s'il ne peut capturer qu'en diagonale.
(2 pts) La tour se déplace en ligne droite, horizontalement ou verticalement, sans tenir compte des pièces sur son chemin.
(2 pts) Le fou se déplace en diagonale, sans tenir compte des pièces sur son chemin.
(1 pt) La dame se déplace comme une tour ou comme un fou (nécessite les deux points précédents).
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 la partie lorsqu'on appuie sur la touche
R.(5 pts) La tour, le fou et la dame ne peuvent plus passer par-dessus d'autres pièces.
(3 pts) Promotion : un pion qui atteint la dernière rangée devient une dame.
(4 pts) Pendule : chaque joueur dispose de 5 minutes pour toute la partie, affichées à l'écran. Seul le temps du joueur dont c'est le tour s'écoule, et un joueur qui n'a plus de temps perd la partie. Indice : un
Timerne peut pas être mis en pause, mais vous pouvez mémoriser le temps restant avecget_time_left()et recréer un nouveauTimeravec ce temps quand c'est à nouveau le tour du joueur.(3 pts) Lorsqu'une pièce est sélectionnée, toutes les cases sur lesquelles elle peut se déplacer sont mises en évidence avec
survol.png(nécessite les règles de déplacement de la partie 2).(5 pts) Le roque.
(4 pts) Appuyer sur U annule le dernier coup joué.
1while True:
2 refresh((50, 50, 50))
Solution (étapes 1 à 10)
# Étape 1 : le plateau
cases = []
for ligne in range(8):
for colonne in range(8):
if (ligne + colonne) % 2 == 0:
case = Actor("case_claire.png", 55 + colonne * 70, 75 + ligne * 70)
else:
case = Actor("case_foncee.png", 55 + colonne * 70, 75 + ligne * 70)
cases.append(case)
# Étape 2 : les pions
pieces_blanches = []
pieces_noires = []
for colonne in range(8):
pieces_blanches.append(Actor("pion_blanc.png", 55 + colonne * 70, 495))
pieces_noires.append(Actor("pion_noir.png", 55 + colonne * 70, 145))
# Étape 3 : les autres pièces, à la main
tour_blanche_1 = Actor("tour_blanc.png", 55, 565)
cavalier_blanc_1 = Actor("cavalier_blanc.png", 125, 565)
fou_blanc_1 = Actor("fou_blanc.png", 195, 565)
dame_blanche = Actor("dame_blanc.png", 265, 565)
roi_blanc = Actor("roi_blanc.png", 335, 565)
fou_blanc_2 = Actor("fou_blanc.png", 405, 565)
cavalier_blanc_2 = Actor("cavalier_blanc.png", 475, 565)
tour_blanche_2 = Actor("tour_blanc.png", 545, 565)
pieces_blanches.append(tour_blanche_1)
pieces_blanches.append(cavalier_blanc_1)
pieces_blanches.append(fou_blanc_1)
pieces_blanches.append(dame_blanche)
pieces_blanches.append(roi_blanc)
pieces_blanches.append(fou_blanc_2)
pieces_blanches.append(cavalier_blanc_2)
pieces_blanches.append(tour_blanche_2)
tour_noire_1 = Actor("tour_noir.png", 55, 75)
cavalier_noir_1 = Actor("cavalier_noir.png", 125, 75)
fou_noir_1 = Actor("fou_noir.png", 195, 75)
dame_noire = Actor("dame_noir.png", 265, 75)
roi_noir = Actor("roi_noir.png", 335, 75)
fou_noir_2 = Actor("fou_noir.png", 405, 75)
cavalier_noir_2 = Actor("cavalier_noir.png", 475, 75)
tour_noire_2 = Actor("tour_noir.png", 545, 75)
pieces_noires.append(tour_noire_1)
pieces_noires.append(cavalier_noir_1)
pieces_noires.append(fou_noir_1)
pieces_noires.append(dame_noire)
pieces_noires.append(roi_noir)
pieces_noires.append(fou_noir_2)
pieces_noires.append(cavalier_noir_2)
pieces_noires.append(tour_noire_2)
# Étape 4 : le curseur
curseur = Actor("curseur.png", 0, 0)
# Étape 5 : la sélection
piece_selectionnee = None
cadre = Actor("selection.png", 0, 0)
# Étape 7 : chacun son tour
tour = "blanc"
txt_tour = Text("Aux blancs de jouer", 300, 20, (255, 255, 255))
# Étape 10 : fin de partie
gameover = False
txt_fin = Text("", 300, 300, (0, 0, 0), (255, 255, 255), 60)
while True:
refresh((50, 50, 50))
curseur.set_position(get_mouse_x(), get_mouse_y())
if tour == "blanc":
mes_pieces = pieces_blanches
pieces_adverses = pieces_noires
else:
mes_pieces = pieces_noires
pieces_adverses = pieces_blanches
if "MOUSE_1" in get_new_keys() and gameover == False:
if piece_selectionnee == None:
# Étape 5 : sélectionner une de ses pièces
for piece in mes_pieces:
if curseur.collide(piece):
piece_selectionnee = piece
else:
# Étape 9 : cliquer sur une de ses pièces change la sélection
case_occupee = False
for piece in mes_pieces:
if curseur.collide(piece):
piece_selectionnee = piece
case_occupee = True
if case_occupee == False:
# Étape 6 : déplacer la pièce sur la case cliquée
for case in cases:
if curseur.collide(case):
piece_selectionnee.set_position(case.get_x(), case.get_y())
# Étape 8 : capture
for adversaire in pieces_adverses:
if piece_selectionnee.collide(adversaire):
adversaire.kill()
# Étape 7 : changement de joueur
if tour == "blanc":
tour = "noir"
txt_tour.set_text("Aux noirs de jouer")
else:
tour = "blanc"
txt_tour.set_text("Aux blancs de jouer")
piece_selectionnee = None
# Étape 10 : fin de partie
if roi_noir.is_killed():
gameover = True
txt_fin.set_text("Les blancs ont gagné !")
if roi_blanc.is_killed():
gameover = True
txt_fin.set_text("Les noirs ont gagné !")
# Dessin
for case in cases:
case.draw()
if piece_selectionnee != None:
cadre.set_position(piece_selectionnee.get_x(), piece_selectionnee.get_y())
cadre.draw()
for piece in pieces_blanches:
piece.draw()
for piece in pieces_noires:
piece.draw()
txt_tour.draw()
if gameover:
txt_fin.draw()
curseur.draw()