Session 1 : Catch the Stars

Dans cette session, tu construis un mini-jeu : une étoile tombe et toi, tu l’attrapes avec un panier. À la fin de la session, tout bouge, le jeu compte combien d’étoiles tu attrapes et tu as ton premier jeu à toi.

Ce que tu vas apprendre aujourd’hui

• Utiliser des variables pour placer des objets
• La fonction draw() : ce que tu dessines à chaque frame
• La fonction update() : ce qui change à chaque frame
• Les entrées clavier : bouger avec les flèches

Étape 0 : Installation

1. Ouvre Thonny.
2. Télécharge le starter via ce lien, décompresse le ZIP et ouvre main.py dans Thonny.
3. Clique sur le bouton vert Run. Tu vois une fenêtre bleu foncé avec un panier en bas et une étoile en haut, mais rien ne bouge encore.
4. Des problèmes ? Va voir Installer Thonny.

Étape 1 : Laisse tomber l’étoile

La fonction update() tourne 60 fois par seconde. Tout ce que tu y mets est donc exécuté 60 fois par seconde. C’est comme ça que le mouvement fonctionne dans un jeu.

Pour l’instant, il n’y a que pass dans update(). Ça veut dire « ne fais rien ». Supprime pass et ajoute ceci :

def update():
    star.y = star.y + 3

Clique sur Run. L’étoile tombe maintenant du haut vers le bas. Quand elle sort de l’écran, elle disparaît. On va régler ça.

Que se passe-t-il ici ? star.y est la position verticale de l’étoile. Plus y est grand, plus l’étoile est bas sur l’écran. En ajoutant + 3 à chaque frame, l’étoile descend petit à petit.

Le système de coordonnées : (0, 0) se trouve en haut à gauche, pas en bas à gauche comme en maths. x va vers la droite, y va vers le bas. L’étoile commence à y = 30 (presque tout en haut), le panier est à y = 370 (presque tout en bas).

Bouge ta souris sur l’écran ci-dessous pour voir les coordonnées :

Tu veux en savoir plus sur le fonctionnement de l’écran ? → Les coordonnées expliquées

Bouge les curseurs et regarde comment actor.x et actor.y changent quand l’actor se déplace :

Étape 2 : ✅ Basic : fais bouger le panier

C’est le moment de piloter le panier. Pygame Zero a une variable pratique, keyboard, qui garde la trace des touches pressées.

Ajoute ceci dans update(), après la ligne de l’étoile :

def update():
    star.y = star.y + 3

    if keyboard.left:
        basket.x = basket.x - 5
    if keyboard.right:
        basket.x = basket.x + 5

Clique sur Run et utilise les flèches. Le panier bouge avec toi !

Astuce (facultatif, compte comme Stretch) : Si tu pousses le panier trop à gauche ou trop à droite, il disparaît de l’écran. Tu peux ajouter un test qui évite ça ? Indice : utilise WIDTH et compare avec basket.x.

Étape 3 : ⭐ Stretch : attrape l’étoile

Maintenant, tu veux que quelque chose se passe quand le panier touche l’étoile. Pour ça, tu utilises colliderect. Il vérifie si deux rectangles se chevauchent.

Ajoute ceci dans update() :

    if star.colliderect(basket):
        star.y = 0

L’étoile remonte quand tu l’attrapes. Mais et si tu la rates ? Ajoute aussi ceci :

    if star.y > HEIGHT:
        star.y = 0

Bonus : Fais réapparaître l’étoile à un endroit au hasard chaque fois. Ajoute en haut du fichier :

import random

Remplace ensuite star.y = 0 (aux deux endroits) par :

        star.x = random.randint(20, WIDTH - 20)
        star.y = 0

Maintenant, l’étoile tombe chaque fois à un autre endroit. Bien plus difficile à attraper !

Étape 4 : 🔥 Expert : ajoute un score

Un vrai jeu garde la trace de ton score. Pour ça, tu as besoin d’une variable qui vit en dehors des fonctions : une variable globale.

Clique sur le bouton ci-dessous pour voir comment score change chaque fois que tu attrapes une étoile :

Ajoute ceci tout en haut, en dehors de toutes les fonctions (après les lignes de basket et star) :

score = 0

Dans draw(), ajoute :

    screen.draw.text(f"Score: {score}", topleft=(10, 10), color="white")

Dans update(), adapte le code de l’attrape pour que le score monte :

    if star.colliderect(basket):
        global score
        score = score + 1
        star.x = random.randint(20, WIDTH - 20)
        star.y = 0

global score dit à Python : « je parle du score d’en dehors de cette fonction, pas d’une nouvelle variable locale. » Sans cette ligne, tu obtiens une erreur.

Clique sur Run. Le score est en haut à gauche et augmente chaque fois que tu attrapes une étoile !

Showcase

Montre ton jeu à un coach et à un buddy. Raconte ce que tu as fait : ce qui marche et ce que tu as ajouté en plus.

À la prochaine !

« La prochaine fois : des trucs qui RÉPLIQUENT. Et ça fait BOUM, avec un vrai son. »

À emporter chez toi

Essaie une de ces extensions à la maison. Chacune a un indice de code pour te lancer.

1. Limite les vies — Ajoute levens = 3. En cas de raté (star.y > HEIGHT) : levens -= 1. Arrête le jeu quand levens == 0 avec game_over = True et affiche « Game Over » dans draw().

2. Couleur d’étoile aléatoire — À chaque attrape : donne une nouvelle couleur à l’étoile avec random.randint(50, 255) pour le rouge, le vert et le bleu. Commence à 50, pas à 0 — sinon l’étoile est parfois noire et invisible.

3. Arrière-plan — Dessine des étoiles fixes en arrière-plan dans draw(), avant le score. Utilise screen.draw.filled_circle(x, y, 2, "white") à 20 positions au hasard. Fais random.seed(42) pour qu’elles ne clignotent pas.

4. Deuxième étoile — Fais sterren = [star, Actor("star")]. Donne à chaque étoile son propre x. Mets-les à jour toutes les deux dans update() et dessine-les dans draw().

5. Meilleur score — Garde high_score. Si score > high_score : high_score = score. Affiche f"Meilleur : {high_score}" à côté du score.

6. Panier plus petit — Tous les 5 points : basket.width = max(30, basket.width - 5). Remets basket.width à sa valeur au redémarrage.

7. Bombe — Ajoute un cercle rouge qui tombe de temps en temps. Utilise un timer bom_timer et random.randint pour décider quand il apparaît. Si le panier touche la bombe : score -= 2.

8. Niveau de difficulté — Tous les 5 étoiles : augmente la vitesse de chute de 1. Prévois un maximum : max(3, star_snelheid).

Bloqué ? Demande au dojo suivant à un coach, ou essaie simplement autre chose. Programmer, c’est faire.

Regarde le cheatsheet de cette session

Session 2 : Dodge Meteors

Ton vaisseau flotte dans l’espace sombre pendant que des météores arrivent du haut vers le bas. Évite-les, ou perds une vie. Plus tu survis longtemps, plus ils vont vite. Et cette fois, tu construis aussi Dojo Defender : le plus grand projet qui grandit à chaque session.

Ce que tu vas apprendre aujourd’hui

• Utiliser des listes pour garder plusieurs objets
• Spawner des objets (les créer) et les supprimer
• Tenir les vies à jour et afficher un écran de game over
• Dojo Defender : ajouter ton propre vaisseau au plus grand projet

Étape 0 : Installation

1. Ouvre Thonny.
2. Télécharge le starter via ce lien, décompresse le ZIP et ouvre main.py.
3. Clique sur Run. Tu vois ton vaisseau en bas, mais aucun météore ne tombe encore.
4. Des problèmes ? Va voir Installer Thonny.

Étape 1 : Fais apparaître des météores

Complète la fonction spawn_meteor(). Un météore est un Actor qui commence en haut de l’écran à une position x au hasard :

import random

def spawn_meteor():
    rock = Actor('meteor')
    rock.x = 0
    rock.y = random.randint(30, WIDTH - 30)
    meteors.append(rock)

Appelle la fonction dans update(), mais pas à chaque frame, sinon l’écran se remplit d’un coup. La fonction update() tourne 60 fois par seconde. Utilise ça pour tenir un compteur :

Regarde ci-dessous à quelle vitesse un météore se déplace selon la vitesse, et combien de pixels ça fait par seconde :

Utilise un compteur :

# en haut, en dehors des fonctions :
timer = 0

def update():
    global timer
    timer += 1
    if timer % 60 == 0:   # chaque seconde (60 frames)
        spawn_meteor()

Clique sur Run. Après une seconde, le premier météore apparaît, mais il ne bouge pas encore.

Étape 2 : ✅ Basic : faire tomber les météores et les faire disparaître

Fais descendre tous les météores de la liste, et supprime-les quand ils sortent de l’écran :

def update():
    global timer
    timer += 1
    if timer % 60 == 0:
        spawn_meteor()

    for rock in meteors[:]:      # [:] = une copie pour pouvoir supprimer sans risque
        rock.y += 4
        if rock.y > HEIGHT + 30:
            meteors.remove(rock)

Détecter une collision : Si un météore touche le vaisseau, tu perds une vie. Ajoute ceci dans la boucle :

        if rock.colliderect(ship):
            meteors.remove(rock)
            global lives
            lives -= 1
            if lives <= 0:
                # TODO : game over (étape 3)
                pass

Étape 3 : ⭐ Stretch : game over et vitesse qui augmente

Game over : Ajoute une variable game_over = False en haut. Si lives == 0, mets game_over = True. Dans draw(), affiche un texte quand game_over vaut True :

    if game_over:
        screen.draw.text(
            "GAME OVER",
            center=(WIDTH / 2, HEIGHT / 2),
            color="red",
            fontsize=60,
        )

Arrête le mouvement dans update() quand game_over vaut True :

def update():
    if game_over:
        return
    ...

Augmenter la vitesse : Fais aller les météores plus vite à mesure que le score monte :

snelheid = 3 + score // 5   # tous les 5 points, +1 de vitesse
rock.y += snelheid

Étape 4 : 🔥 Expert : score et plusieurs tailles de météores

Score : Chaque seconde que tu survis, +1 point. Ajoute global score et augmente dans update() :

    if timer % 60 == 0:
        global score
        score += 1
        spawn_meteor()

Plusieurs tailles : Fais des petits, des moyens et des grands météores. Utilise une variable schaal et adapte la hitbox :

def spawn_meteor():
    rock = Actor('meteor')
    rock.x = random.randint(30, WIDTH - 30)
    rock.y = 0
    rock.schaal = random.choice([0.5, 1.0, 1.5])
    meteors.append(rock)

Les petits météores vont plus vite ; les grands sont plus difficiles à éviter mais rapportent plus de points.

Dojo Defender

Télécharge le starter Dojo Defender d’aujourd’hui. C’est la base du projet qui grandit à chaque session. Ajoute aujourd’hui ton vaisseau et fais-le bouger avec les flèches.

Tu n’étais pas là la dernière fois ? Pas de problème — télécharge la solution de la dernière fois et tu peux suivre tout de suite.

La fiche de travail complète de Dojo Defender se trouve sur la page Dojo Defender.

Showcase

Montre ton jeu à un coach et à un buddy. Combien de temps tu survis ? Qui fait le meilleur score ?

À la prochaine !

« La prochaine fois : ton propre vaisseau RÉPLIQUE. Des ennemis en formation, et c’est toi qui les exploses. »

À emporter chez toi

1. Facile : change la couleur d’arrière-plan en violet foncé ou vert foncé.
2. Moyen : ajoute un son quand un météore touche le vaisseau (sounds/hit.wav).
3. Difficile : fais aller les météores plus vite à mesure qu’il y en a plus à l’écran (pas seulement le score).
4. Très difficile : ajoute des power-ups : une étoile dorée qui te donne une vie de plus quand tu la touches.

Regarde le cheatsheet de cette session

Session 3 : Space Blaster

Les ennemis sont en formation en haut de l’écran. Toi, tu es en bas avec un vaisseau et un seul objectif : les éliminer tous avant qu’ils atteignent le fond. Appuie sur ESPACE pour tirer, et ne rate pas.

Ce que tu vas apprendre aujourd’hui

• Garder les projectiles dans une liste
• Créer un projectile quand tu appuies sur ESPACE
• La collision entre les projectiles et les ennemis
• Game over quand un ennemi atteint le fond

Étape 0 : Installation

1. Ouvre Thonny.
2. Télécharge le starter via ce lien, décompresse le ZIP et ouvre main.py.
3. Clique sur Run. Tu vois le vaisseau en bas et 12 ennemis dans une grille, mais rien ne bouge et tu ne sais pas encore tirer.

Étape 1 : Fais bouger le vaisseau

Le vaisseau bouge déjà avec les flèches. Vérifie le code dans update(). Fais en sorte que le vaisseau ne sorte pas de l’écran :

if keyboard.left and ship.x > 30:
    ship.x -= 5
if keyboard.right and ship.x < WIDTH - 30:
    ship.x += 5

Étape 2 : ✅ Basic : tirer avec ESPACE

Complète la fonction shoot(). Un projectile est un Actor qui commence à la position du vaisseau :

def shoot():
    kogel = Actor('bullet')
    kogel.x = ship.x
    kogel.y = ship.y - 20
    bullets.append(kogel)

Appelle shoot() quand la barre d’espace est pressée. Utilise on_key_down (style Pgzero) :

def on_key_down(key):
    if key == keys.SPACE:
        shoot()

Fais monter les projectiles dans update() et supprime-les quand ils sortent de l’écran :

for kogel in bullets[:]:
    kogel.y -= 8
    if kogel.y < -10:
        bullets.remove(kogel)

Étape 3 : ⭐ Stretch : toucher les ennemis

colliderect vérifie si la hitbox rectangulaire de deux actors se chevauche. Bouge ta souris sur l’écran ci-dessous pour voir quand ça arrive :

Vérifie dans update() si un projectile touche un ennemi :

for kogel in bullets[:]:
    kogel.y -= 8
    if kogel.y < -10:
        bullets.remove(kogel)
        continue
    for vijand in enemies[:]:
        if kogel.colliderect(vijand):
            bullets.remove(kogel)
            enemies.remove(vijand)
            global score
            score += 10
            break

Condition de victoire : Si enemies est vide, tu as gagné :

    if not enemies:
        screen.draw.text("TU GAGNES !", center=(WIDTH/2, HEIGHT/2), color="yellow", fontsize=60)

Étape 4 : 🔥 Expert : faire bouger les ennemis et game over

Fais descendre les ennemis lentement. Utilise un timer :

vijand_timer = 0

def update():
    global vijand_timer
    vijand_timer += 1
    if vijand_timer % 90 == 0:   # toutes les 1,5 seconde
        for vijand in enemies:
            vijand.y += 20

Game over quand un ennemi atteint le fond :

        for vijand in enemies:
            if vijand.y > HEIGHT - 30:
                global game_over
                game_over = True

Tirer plus vite : Prévois un cooldown pour que le ninja ne puisse pas tirer à l’infini :

shoot_cooldown = 0

def update():
    global shoot_cooldown
    if shoot_cooldown > 0:
        shoot_cooldown -= 1

def on_key_down(key):
    global shoot_cooldown
    if key == keys.SPACE and shoot_cooldown == 0:
        shoot()
        shoot_cooldown = 15

Showcase

Montre ton jeu à un coach. En combien de temps tu élimines tous les ennemis ? Compare ton score avec un buddy.

À la prochaine !

« La prochaine fois : deux joueurs, une balle : PONG. Et tu apprends le vrai pygame, sans pgzrun. »

À emporter chez toi

1. Facile : change la couleur des projectiles ou des ennemis.
2. Moyen : fais bouger les ennemis à gauche et à droite (une seule direction par pas, demi-tour au bord).
3. Difficile : ajoute une second wave : quand tous les ennemis sont partis, fais apparaître une nouvelle rangée qui descend plus vite.
4. Très difficile : fais aussi tirer les ennemis : envoie un projectile vers le bas au hasard toutes les N frames.

Regarde le cheatsheet de cette session

Dojo Defender

Télécharge le starter Dojo Defender d’aujourd’hui.

Tu n’étais pas là la dernière fois ? Télécharge la solution de la session 1 et commence avec ça.

La fiche de travail complète : Dojo Defender Session 2.

Session 4 : Pong

Deux raquettes, une balle : le Pong classique. Mais il y a une surprise : dans cette session, tu écris le jeu en vrai pygame, sans pgzrun. Tu apprends à installer toi-même la game loop. C’est comme ça que marchent la plupart des vrais jeux.

Ce que tu vas apprendre aujourd’hui

• La game loop pygame : events, update, draw
• pygame.Rect pour les rectangles et les collisions
• Faire rebondir la balle (inverser la vitesse)
• Compter les points pour deux joueurs

Étape 0 : Installation

1. Ouvre Thonny.
2. Télécharge le starter via ce lien, décompresse le ZIP et ouvre main.py.
3. Clique sur Run. Tu vois deux raquettes et une balle jaune au milieu, mais la balle ne bouge pas encore.

Différence avec pgzrun : il n’y a plus de fonctions draw() et update(). Tout est dans une seule boucle while running:.

Étape 1 : Fais bouger la balle

Cherche les lignes :

# bal.x += ball_dx  # active ceci quand tu as fini
# ball.y += ball_dy

Supprime le # devant les deux lignes. Mais règle d’abord une vitesse de départ. Cherche ball_dx, ball_dy = 0, 0 et remplace par :

ball_dx, ball_dy = 4, 4

Clique sur Run. La balle bouge maintenant, mais elle disparaît par le bord. On règle ça à l’étape 2.

Étape 2 : ✅ Basic : la balle rebondit sur les murs et les raquettes

Ajoute ceci après ball.x += ball_dx et ball.y += ball_dy :

# Rebondir sur le bord supérieur et inférieur
if ball.top <= 0 or ball.bottom >= HEIGHT:
    ball_dy = -ball_dy

# Rebondir sur les raquettes
if ball.colliderect(left_paddle) or ball.colliderect(right_paddle):
    ball_dx = -ball_dx

La balle rebondit maintenant à l’infini. Ajoute aussi des limites pour les raquettes pour qu’elles ne sortent pas de l’écran. Regarde le code qui est déjà dans le starter.

Étape 3 : ⭐ Stretch : compter les points

Si la balle sort à gauche, le joueur de droite marque. Si elle sort à droite, c’est celui de gauche :

# Balle sortie à gauche → la droite marque
if ball.left <= 0:
    score_right += 1
    ball.center = (WIDTH // 2, HEIGHT // 2)
    ball_dx = 4

# Balle sortie à droite → la gauche marque
if ball.right >= WIDTH:
    score_left += 1
    ball.center = (WIDTH // 2, HEIGHT // 2)
    ball_dx = -4

Le score s’affiche déjà dans draw(). Vérifie que les variables sont correctes.

Étape 4 : 🔥 Expert : condition de victoire et vitesse qui augmente

Gagner à 5 points : ajoute une variable won. Quand un joueur atteint 5, arrête le jeu :

if score_left >= 5:
    won = "La gauche gagne !"
if score_right >= 5:
    won = "La droite gagne !"

Affiche le gagnant à l’écran et arrête le mouvement.

Vitesse qui augmente : après chaque échange, la balle devient un peu plus rapide :

if ball.colliderect(left_paddle) or ball.colliderect(right_paddle):
    ball_dx = -ball_dx * 1.05   # 5 % plus rapide
    ball_dy = ball_dy * 1.05

Prévois un maximum : ball_dx = max(-12, min(12, ball_dx)).

Showcase

Joue une partie contre un buddy. Le premier à 5 points gagne. Montre-le à un coach.

À la prochaine !

« La prochaine fois : Breakout. La balle casse des briques. Et il y a du SON. »

À emporter chez toi

1. Facile : change la couleur de la balle ou des raquettes.
2. Moyen : agrandis une raquette au fur et à mesure que ce joueur perd (handicap).
3. Difficile : ajoute un adversaire IA : la raquette de droite suit automatiquement la balle.
4. Très difficile : ajoute des power-ups : un item qui double la balle ou agrandit la raquette.

Dojo Defender

Aujourd’hui, Dojo Defender passe au vrai Pygame ! Télécharge le starter. Tu n’étais pas là ? Télécharge la solution de la session 2. Fiche de travail : Dojo Defender Session 3.

Regarde le cheatsheet de cette session

Session 5 : Breakout

Une balle rebondit dans tous les sens et casse des rangées de briques colorées. Tu contrôles la raquette pour garder la balle en l’air. Et cette fois, tu l’entends aussi : il y a des effets sonores à chaque collision.

Ce que tu vas apprendre aujourd’hui

• Charger et jouer un son avec pygame.mixer
• Les collisions avec plusieurs objets (une liste de briques)
• Faire rebondir la balle dans la bonne direction
• Construire un écran de victoire et de défaite

Étape 0 : Installation

1. Ouvre Thonny.
2. Télécharge le starter via ce lien, décompresse le ZIP et ouvre main.py.
3. Clique sur Run. Tu vois la raquette, la balle et les briques. La balle bouge déjà à l’horizontale mais pas à la verticale. C’est à toi de changer ça.

Étape 1 : Fais bouger la balle à la verticale

Cherche cette ligne dans le starter :

ball_dx, ball_dy = 4, 0
# ball_dy = -4  ← supprime le # pour faire bouger la balle !

Supprime le # devant ball_dy = -4. La balle a maintenant une vitesse verticale. Ajoute le mouvement dans la game loop (cherche la section update) :

ball.x += ball_dx
ball.y += ball_dy

Clique sur Run. La balle bouge en diagonale mais disparaît par les bords.

Étape 2 : ✅ Basic : la balle rebondit sur les murs et la raquette

Ajoute les rebonds :

# Bord supérieur, gauche et droit
if ball.left <= 0 or ball.right >= WIDTH:
    ball_dx = -ball_dx
if ball.top <= 0:
    ball_dy = -ball_dy

# Raquette
if ball.colliderect(paddle):
    ball_dy = -ball_dy
    if snd_hit:
        snd_hit.play()

Vies : si la balle atteint le bas, tu perds une vie :

if ball.top > HEIGHT:
    levens -= 1
    # Remets la balle au-dessus de la raquette
    ball.center = (paddle.centerx, paddle.top - BALL_SIZE)
    ball_dy = -4

Étape 3 : ⭐ Stretch : casser des briques

Vérifie la collision avec chaque brique dans la boucle :

for steen in stenen[:]:
    if ball.colliderect(steen['rect']):
        stenen.remove(steen)
        ball_dy = -ball_dy
        score += 10
        if snd_hit:
            snd_hit.play()
        break  # casser une seule brique par frame

Condition de victoire : si toutes les briques sont parties, le ninja a gagné. Affiche un message :

if not stenen:
    # affiche l'écran de victoire

Étape 4 : 🔥 Expert : vies, son d’explosion et vitesse

Son d’explosion quand une brique casse (utilise snd_explode du starter) :

if snd_explode:
    snd_explode.play()

Game over à 0 vie : affiche un écran et arrête la balle.

Vitesse qui augmente à mesure qu’il reste moins de briques :

snelheid_factor = 1 + (1 - len(stenen) / totaal_stenen) * 0.5
ball_dx_huidig = ball_dx * snelheid_factor

Une nouvelle rangée de briques quand tout est parti : rappelle stenen = maak_stenen() et augmente la difficulté.

Showcase

Qui enlève le plus de briques ? Compare les scores et montre à ton coach ta plus longue série.

À la prochaine !

« La prochaine fois : la gravité. Ton personnage tombe, et c’est à toi de le faire sauter de plateforme en plateforme. »

À emporter chez toi

1. Facile : change les couleurs des briques pour tes couleurs préférées.
2. Moyen : rends certaines briques deux fois plus solides (il faut les toucher deux fois).
3. Difficile : ajoute un power-up qui élargit la raquette pendant un temps.
4. Très difficile : ajoute une deuxième balle qui apparaît quand score > 50.

Regarde le cheatsheet de cette session

Dojo Defender

Dojo Defender reçoit un menu et de nouveaux types d’ennemis ! Télécharge le starter. Tu n’étais pas là ? Télécharge la solution de la session 3. Fiche de travail : Dojo Defender Session 4.

Session 6 : Platformer

Dans cette session, tu construis un micro-platformer. Ton personnage a de la gravité, peut sauter et ramasse des étoiles sur les plateformes. Pour la première fois, tu utilises pygame directement, sans pgzrun, et tu ajoutes des effets sonores avec pygame.mixer.

Ce que tu vas apprendre aujourd’hui

• Simuler la gravité avec une variable vel_y
• Sauter en rendant vel_y négatif
• Détecter les collisions avec les plateformes grâce à pygame.Rect
• Ramasser des items (collision avec les étoiles)
• Jouer des sons avec pygame.mixer

Étape 0 : Installation

1. Ouvre Thonny.
2. Télécharge le starter via ce lien, décompresse le ZIP et ouvre main.py dans Thonny.
3. Clique sur le bouton vert Run. Tu vois une fenêtre avec un personnage, des plateformes et des étoiles, mais le personnage ne tombe pas encore.
4. Des problèmes ? Demande à un coach.

Étape 1 : La gravité

Dans un platformer, le personnage tombe en continu vers le bas, sauf s’il se trouve sur une plateforme. On simule ça avec vel_y : une vitesse verticale qui augmente à chaque frame à cause de la gravité.

Cherche le commentaire # STAP 1 dans main.py et remplace le pass par :

# Appliquer la gravité
vel_y += GRAVITY
player_rect.y += vel_y

# Vérifie si le personnage est sur une plateforme
on_ground = False
for platform in platforms:
    if (player_rect.colliderect(platform) and vel_y > 0):
        player_rect.bottom = platform.top
        vel_y = 0
        on_ground = True

GRAVITY = 0.5 est déjà en haut du fichier. Clique sur Run. Le personnage tombe maintenant sur la plateforme la plus proche et y reste.

Que se passe-t-il ici ? À chaque frame, vel_y augmente un peu (le personnage accélère vers le bas). Si le personnage touche une plateforme en tombant (vel_y > 0), tu places son bas (bottom) pile sur le haut de la plateforme et tu arrêtes la chute (vel_y = 0).

Étape 2 : ✅ Basic : sauter

Un platformer sans saut, c’est à moitié fini. Appuie sur ESPACE pour sauter : ce n’est rien d’autre que rendre vel_y soudainement négatif.

Cherche le commentaire # STAP 2 et ajoute :

keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
    player_rect.x -= SPEED
if keys[pygame.K_RIGHT]:
    player_rect.x += SPEED

# Sauter — seulement si tu es au sol
if keys[pygame.K_SPACE] and on_ground:
    vel_y = -12

Clique sur Run et teste :

• Flèches : bouge à gauche/droite
• ESPACE : saute

Astuce : si le saut te semble trop haut ou trop bas, remplace -12 par -10 (saut plus bas) ou -15 (saut plus haut).

Étape 3 : ⭐ Stretch : ramasser les étoiles

Ajoutons quelque chose à ramasser. Le starter a déjà une liste stars avec des objets pygame.Rect. C’est toi qui écris la détection de collision.

Cherche le commentaire # STAP 3 :

for star in stars[:]:  # [:] pour pouvoir supprimer sans risque pendant la boucle
    if player_rect.colliderect(star):
        stars.remove(star)
        score += 1

Et dans la fonction de dessin (cherche # TEKEN STERREN) :

for star in stars:
    pygame.draw.polygon(screen, YELLOW, star_points(star.centerx, star.centery, 12, 5))

star_points() est déjà défini dans le starter. Il calcule les points d’une étoile à 5 branches.

En haut du jeu, il y a score = 0. Dessine le score à l’écran (cherche # TEKEN SCORE) :

score_surf = font.render(f"Étoiles : {score}", True, WHITE)
screen.blit(score_surf, (10, 10))

Étape 4 : 🔥 Expert : son et écran de victoire

Maintenant, tu ajoutes un son de saut et un écran de victoire quand toutes les étoiles sont ramassées.

Charger le son (c’est déjà prêt dans le starter ; vérifie que jump.wav se trouve dans le dossier sounds/) :

pygame.mixer.init()
jump_snd = pygame.mixer.Sound("sounds/jump.wav")

Jouer le son au saut : ajoute ceci au code du saut :

if keys[pygame.K_SPACE] and on_ground:
    vel_y = -12
    jump_snd.play()

Écran de victoire : ajoute ceci après la boucle des étoiles :

if len(stars) == 0:
    win_surf = font.render("Gagné ! Toutes les étoiles ramassées !", True, YELLOW)
    screen.blit(win_surf, (WIDTH // 2 - win_surf.get_width() // 2, HEIGHT // 2))
    pygame.display.flip()
    pygame.time.wait(3000)
    running = False

Showcase

Montre ton jeu à un coach et à un buddy. Tu arrives à ramasser toutes les étoiles avant la fin du temps ?

Dojo Defender

Le snapshot Dojo Defender d’aujourd’hui continue sur la session 5 :

• Fond étoilé en parallaxe — trois couches d’étoiles avec leur propre vitesse
• Particle effects — gaz d’échappement, débris d’explosion, étincelles
• Astéroïdes destructibles — big → med → small → disparu

Télécharge le starter Dojo Defender ou la solution.

À la prochaine !

« La prochaine fois : clique sur les bugs et ZAPPE-les, avec tes propres classes. »

À emporter chez toi

Essaie une de ces extensions à la maison :

1. Facile : change la couleur du personnage quand il est en l’air.
2. Moyen : ajoute un timer. Le personnage a 30 secondes pour ramasser toutes les étoiles.
3. Difficile : ajoute un ennemi qui marche d’un bout à l’autre d’une plateforme ; si le personnage le touche, le jeu redémarre.
4. Très difficile : fais faire un double saut au personnage (deux fois ESPACE pour un deuxième saut en l’air).

Bloqué ? Demande au dojo suivant à un coach, ou essaie simplement autre chose. Programmer, c’est faire.

Regarde le cheatsheet de cette session

Session 7 : Bug Zapper

Les bugs tombent du haut vers le bas. Toi, tu tires vers le haut pour les toucher. Dans cette session, tu apprends la POO : tu écris ta première classe à toi (Bug), puis deux sous-classes : une qui oscille et une qui plonge sur toi. Les classes sont les briques de presque tous les gros programmes.

Ce que tu vas apprendre aujourd’hui

• Écrire une classe avec __init__ et tes propres méthodes
• L’héritage : une sous-classe qui étend une classe existante
• Garder les projectiles dans une liste
• La détection de collision entre les projectiles et les bugs

Étape 0 : Installation

1. Ouvre Thonny.
2. Télécharge le starter via ce lien, décompresse le ZIP et ouvre main.py dans Thonny.
3. Clique sur Run. Tu vois un écran avec un joueur en bas, mais pas encore de bugs et pas de projectiles.
4. Des problèmes ? Demande à un coach.

Étape 1 : Faire apparaître des bugs et tirer

La classe Bug

Cherche le commentaire # ÉTAPE 1 — CLASSE BUG et écris :

class Bug:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.alive = True

    def update(self):
        self.y += 2  # tombe vers le bas

    def draw(self, screen):
        pygame.draw.circle(screen, GREEN, (int(self.x), int(self.y)), 15)
        # Yeux
        pygame.draw.circle(screen, BLACK, (int(self.x) - 5, int(self.y) - 4), 3)
        pygame.draw.circle(screen, BLACK, (int(self.x) + 5, int(self.y) - 4), 3)

Faire apparaître des bugs : le starter a déjà un timer. Cherche # SPAWN BUG :

bugs.append(Bug(random.randint(30, WIDTH - 30), -20))

Tirer : cherche # TIR (c’est dans la boucle des événements, à K_SPACE) :

bullets.append(pygame.Rect(player_x - 3, player_y - 20, 6, 12))

Mets les projectiles à jour à chaque frame (cherche # MISE À JOUR PROJECTILES) :

for b in bullets[:]:
    b.y -= 10
    if b.y < 0:
        bullets.remove(b)
pygame.draw.rect(screen, YELLOW, b)  # ceci est déjà en place

Étape 2 : ✅ Basic : toucher les bugs

Maintenant tu écris la détection de collision : quand un projectile touche un bug, le bug meurt.

Cherche # ÉTAPE 2 — COLLISION :

for bug in bugs[:]:
    bug.update()
    bug.draw(screen)
    if bug.y > HEIGHT + 20:
        bugs.remove(bug)
        continue
    bug_rect = pygame.Rect(bug.x - 15, bug.y - 15, 30, 30)
    for bullet in bullets[:]:
        if bullet.colliderect(bug_rect):
            bug.alive = False
            bullets.remove(bullet)
            score += 1
            break
    if not bug.alive:
        bugs.remove(bug)

Clique sur Run. Tire sur les bugs : ils disparaissent dès que tu les touches !

Étape 3 : ⭐ Stretch : SlingerBug

Maintenant, tu crées une sous-classe : un Bug qui oscille de gauche à droite.

import math

class SlingerBug(Bug):
    def __init__(self, x, y):
        super().__init__(x, y)
        self.start_x = x
        self.timer = 0

    def update(self):
        self.timer += 0.05
        self.x = self.start_x + math.sin(self.timer) * 60
        self.y += 1.5  # un peu plus lent, mais plus dur à toucher

    def draw(self, screen):
        super().draw(screen)
        # Cercle orange autour, comme repère visuel
        pygame.draw.circle(screen, ORANGE, (int(self.x), int(self.y)), 18, 2)

Faire apparaître des SlingerBugs : ajoute ceci dans le code de spawn (par exemple un bug sur trois) :

if random.random() < 0.3:
    bugs.append(SlingerBug(random.randint(30, WIDTH - 30), -20))
else:
    bugs.append(Bug(random.randint(30, WIDTH - 30), -20))

super().__init__(x, y) appelle le __init__ de la classe parente (Bug), donc tu ne dois pas réécrire self.x, self.y et self.alive.

Étape 4 : 🔥 Expert : DuikBug

Le DuikBug détecte la position du joueur et plonge droit sur lui.

class DuikBug(Bug):
    def __init__(self, x, y, player_x_ref):
        super().__init__(x, y)
        self.player_x_ref = player_x_ref  # fonction qui donne le x actuel du joueur
        self.speed_x = 0
        self.speed_y = 1

    def update(self):
        target_x = self.player_x_ref()
        dx = target_x - self.x
        dist = max(abs(dx), 1)
        self.x += dx / dist * 2
        self.y += 2.5

    def draw(self, screen):
        super().draw(screen)
        pygame.draw.circle(screen, RED, (int(self.x), int(self.y)), 18, 2)

Spawn : utilise un lambda pour passer le x du joueur :

bugs.append(DuikBug(random.randint(30, WIDTH - 30), -20, lambda: player_x))

Bonus : dessine une barre de HP. Commence avec lives = 3 et enlève-en une quand un bug atteint le bas de l’écran.

Showcase

Montre ton jeu à un coach et à un buddy. Combien de bugs arrives-tu à zapper avant de ne plus avoir de vies ?

À la prochaine !

« La prochaine fois : une route infinie dans le ciel, et tout DÉFILE derrière toi. »

À emporter chez toi

Essaie une de ces extensions à la maison :

1. Facile : rends les bugs plus grands ou plus rapides à mesure que le score monte.
2. Moyen : ajoute un système de lives avec 3 vies ; si un bug atteint le bas, tu en perds une.
3. Difficile : écris un PantserbBug qui a besoin de 3 tirs avant de mourir (utilise un attribut hp).
4. Très difficile : ajoute le contrôle à la souris : le joueur suit la position de la souris et tire automatiquement toutes les 0,5 seconde.

Bloqué ? Demande au dojo suivant à un coach, ou essaie simplement autre chose. Programmer, c’est faire.

Dojo Defender : boss final

Dans cette session, tu continues aussi à construire Dojo Defender. Tu ajoutes un boss final qui apparaît toutes les 5 vagues, en 3 phases.

Va voir la session 6 de Dojo Defender pour les instructions.

Le starter et la solution sont prêts.

Regarde le cheatsheet de cette session

Session 8 : Sky Highway

Ton vaisseau vole dans une route aérienne sans fin. L’arrière-plan défile derrière toi, des obstacles rouges arrivent par la droite, et des étoiles rapportent des points. Plus tu survis longtemps, plus ça va vite !

Ce que tu vas apprendre aujourd’hui

• Faire un arrière-plan qui défile avec une variable scroll_x
• Faire apparaître des objets qui vont de droite à gauche
• La détection de collision avec des vies
• L’augmentation de la difficulté : accélérer à mesure que le score monte

Étape 0 : Installation

1. Ouvre Thonny.
2. Télécharge le starter via ce lien, décompresse le ZIP et ouvre main.py dans Thonny.
3. Clique sur Run. Tu vois un écran statique avec un vaisseau et un fond de ciel, mais rien ne bouge encore.
4. Des problèmes ? Demande à un coach.

Étape 1 : Faire défiler l’arrière-plan

Un arrière-plan qui défile donne l’illusion du mouvement. On dessine l’arrière-plan deux fois côte à côte et on décale la position à chaque frame.

Cherche # ÉTAPE 1 et ajoute :

# Décaler l'arrière-plan vers la gauche
scroll_x -= speed
if scroll_x <= -WIDTH:
    scroll_x = 0

# Dessiner l'arrière-plan deux fois
screen.blit(bg_image, (int(scroll_x), 0))
screen.blit(bg_image, (int(scroll_x) + WIDTH, 0))

scroll_x commence à 0 et diminue à chaque frame. Quand il atteint -WIDTH, on revient à 0 : une boucle sans couture.

Clique sur Run. Le ciel défile maintenant derrière ton vaisseau !

Étape 2 : ✅ Basic : obstacles et vies

Les obstacles arrivent par la droite et vont vers la gauche. Si tu les touches, tu perds une vie.

Mettre les obstacles à jour (cherche # ÉTAPE 2) :

for obs in obstacles[:]:
    obs.x -= speed
    if obs.x < -obs.width:
        obstacles.remove(obs)
    pygame.draw.rect(screen, RED, obs)
    # Collision
    if ship_rect.colliderect(obs):
        obstacles.remove(obs)
        lives -= 1
        if lives <= 0:
            running = False

Dessiner les vies :

for i in range(lives):
    pygame.draw.rect(screen, RED, (10 + i * 25, 10, 18, 18))

Faire apparaître des obstacles (dans l’événement du timer de spawn) :

h = random.randint(40, 120)
obstacles.append(pygame.Rect(WIDTH, random.randint(50, HEIGHT - h - 50), 30, h))

Étape 3 : ⭐ Stretch : ramasser les étoiles

Les étoiles rapportent des points et disparaissent quand tu les touches.

Cherche # ÉTAPE 3 :

for star in stars[:]:
    star.x -= speed
    if star.x < -20:
        stars.remove(star)
        continue
    pygame.draw.circle(screen, YELLOW, star.center, 10)
    if ship_rect.colliderect(star):
        stars.remove(star)
        score += 1

# Dessiner le score :
score_surf = font.render(f"Score : {score}", True, WHITE)
screen.blit(score_surf, (WIDTH - 120, 10))

Faire apparaître des étoiles (dans le même timer de spawn, mais moins souvent) :

if random.random() < 0.4:
    stars.append(pygame.Rect(WIDTH, random.randint(40, HEIGHT - 40), 20, 20))

Étape 4 : 🔥 Expert : spawn et vitesse qui augmente

Maintenant tu rends le jeu de plus en plus difficile à mesure que le score monte.

Faire augmenter la vitesse (cherche # ÉTAPE 4) :

speed = BASE_SPEED + score * 0.1

BASE_SPEED = 4 est déjà en haut du fichier. À un score de 20, tout va deux fois plus vite !

Adapter l’intervalle de spawn : plus le score est haut, plus les nouveaux obstacles arrivent souvent :

spawn_interval = max(500, 1800 - score * 30)  # min. 500ms
pygame.time.set_timer(SPAWN_EVENT, spawn_interval)

Écran de game over :

if not running:
    go_surf = font.render("GAME OVER", True, RED)
    screen.blit(go_surf, (WIDTH // 2 - go_surf.get_width() // 2, HEIGHT // 2 - 30))
    sc_surf = font.render(f"Score : {score}", True, WHITE)
    screen.blit(sc_surf, (WIDTH // 2 - sc_surf.get_width() // 2, HEIGHT // 2 + 10))
    pygame.display.flip()
    pygame.time.wait(3000)

Showcase

Montre ton jeu à un coach et à un buddy. Qui fait le meilleur score ?

À la prochaine !

« La prochaine fois : un boss qui se défend, en TROIS phases. »

À emporter chez toi

Essaie une de ces extensions à la maison :

1. Facile : ajoute un deuxième type d’obstacle (par exemple un obstacle bleu qui vole plus haut ou plus bas).
2. Moyen : ajoute des power-ups. Attrape une capsule verte pour un bouclier temporaire (le vaisseau peut être touché 1 fois).
3. Difficile : fais monter et descendre le vaisseau avec les flèches et limite l’écran pour que le vaisseau ne sorte pas.
4. Très difficile : ajoute du parallax scrolling : une deuxième couche d’arrière-plan (des nuages) qui défile plus lentement que la première.

Bloqué ? Demande au dojo suivant à un coach, ou essaie simplement autre chose. Programmer, c’est faire.

Dojo Defender : ta propre version

Aujourd’hui, tu continues aussi à travailler sur Dojo Defender — mais sans instructions pas à pas. C’est toi qui choisis ce que tu construis.

Télécharge le starter Dojo Defender — c’est le jeu complet avec tout dedans (vaisseau, ennemis, astéroïdes, vagues, boss). Choisis une feature dans la liste, planifie-la rapidement avec un coach, et lance-toi.

👉 Tout sur Dojo Defender se trouve sur la page Dojo Defender.

Regarde le cheatsheet de cette session

Session 9 : Boss Battle

Le boss final t’attend. Il va et vient, tire des projectiles et devient de plus en plus dangereux à mesure que ses HP baissent. Toi, tu tires en retour, tu suis ses HP sur une barre, et tu survis à trois phases. C’est la session la plus difficile, et la plus satisfaisante si tu y arrives.

Ce que tu vas apprendre aujourd’hui

• Dessiner une barre de HP à l’écran
• Une state machine : le boss ne se comporte pas pareil selon la phase
• Faire tirer le boss avec un timer de projectiles
• Activer des phases à des seuils de HP

Étape 0 : Installation

1. Ouvre Thonny.
2. Télécharge le starter via ce lien, décompresse le ZIP et ouvre main.py dans Thonny.
3. Clique sur Run. Tu vois le boss en haut, ton vaisseau en bas. Pas encore de mouvement, pas encore de projectiles.
4. Des problèmes ? Demande à un coach.

Étape 1 : Faire bouger le boss

Le boss va et vient sur l’écran. Quand il touche le bord, il repart dans l’autre sens.

Cherche # ÉTAPE 1 et ajoute :

boss_rect.x += boss_speed

# Repartir dans l'autre sens au bord
if boss_rect.right >= WIDTH or boss_rect.left <= 0:
    boss_speed = -boss_speed

boss_speed = 3 est déjà en haut du fichier. Clique sur Run : le boss traverse l’écran de gauche à droite !

Bouger le joueur et tirer (cherche # JOUEUR) :

keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT] and player_rect.left > 0:
    player_rect.x -= PLAYER_SPEED
if keys[pygame.K_RIGHT] and player_rect.right < WIDTH:
    player_rect.x += PLAYER_SPEED

# Tirer (cherche # TIR dans la boucle des événements) :
player_bullets.append(pygame.Rect(player_rect.centerx - 3, player_rect.top - 15, 6, 15))

Étape 2 : ✅ Basic : toucher le boss et la barre de HP

Collision entre le projectile du joueur et le boss :

Cherche # ÉTAPE 2 :

for b in player_bullets[:]:
    b.y -= 8
    if b.y < 0:
        player_bullets.remove(b)
        continue
    pygame.draw.rect(screen, YELLOW, b)
    if b.colliderect(boss_rect):
        player_bullets.remove(b)
        boss_hp -= 1
        if boss_hp <= 0:
            running = False  # le joueur gagne !

Dessiner la barre de HP (cherche # BARRE HP) :

# Fond de la barre
pygame.draw.rect(screen, DARK_RED, (10, 10, 300, 20))
# Partie remplie selon les HP actuels
breedte = int(300 * boss_hp / BOSS_MAX_HP)
pygame.draw.rect(screen, RED, (10, 10, breedte, 20))
# Texte
hp_surf = font.render(f"HP du boss : {boss_hp}", True, WHITE)
screen.blit(hp_surf, (320, 10))

Clique sur Run. Tire sur le boss : la barre de HP diminue !

Étape 3 : ⭐ Stretch : le boss tire en retour

Le boss tire un projectile vers le bas toutes les N frames.

Cherche # ÉTAPE 3 :

boss_shoot_timer += 1
if boss_shoot_timer >= boss_shoot_interval:
    boss_shoot_timer = 0
    boss_bullets.append(pygame.Rect(boss_rect.centerx - 4, boss_rect.bottom, 8, 16))

Mettre à jour les projectiles du boss :

for b in boss_bullets[:]:
    b.y += 6
    if b.y > HEIGHT:
        boss_bullets.remove(b)
        continue
    pygame.draw.rect(screen, ORANGE, b)
    if b.colliderect(player_rect):
        boss_bullets.remove(b)
        player_lives -= 1
        if player_lives <= 0:
            running = False

Dessine player_lives en petits cœurs ou en blocs rouges en bas de l’écran.

Étape 4 : 🔥 Expert : trois phases

Maintenant, le boss réagit à ses HP :

• Phase 1 (HP de 100 à 50) : comportement normal
• Phase 2 (HP de 50 à 25) : se déplace plus vite, tire plus souvent
• Phase 3 (HP < 25) : vitesse maximale, projectiles doubles

Cherche # ÉTAPE 4 :

if boss_hp > 50:
    boss_phase = 1
    boss_speed_abs = 3
    boss_shoot_interval = 60
elif boss_hp > 25:
    boss_phase = 2
    boss_speed_abs = 5
    boss_shoot_interval = 35
else:
    boss_phase = 3
    boss_speed_abs = 7
    boss_shoot_interval = 20

# Adapter la vitesse sans changer la direction :
boss_speed = boss_speed_abs * (1 if boss_speed > 0 else -1)

Phase 3 : projectiles doubles (ajoute ceci dans le code de tir) :

if boss_phase == 3:
    boss_bullets.append(pygame.Rect(boss_rect.left + 10, boss_rect.bottom, 8, 16))
    boss_bullets.append(pygame.Rect(boss_rect.right - 18, boss_rect.bottom, 8, 16))
else:
    boss_bullets.append(pygame.Rect(boss_rect.centerx - 4, boss_rect.bottom, 8, 16))

Écran de victoire quand boss_hp <= 0 :

screen.fill(BLACK)
win = font.render("BOSS VAINCU !", True, YELLOW)
screen.blit(win, (WIDTH // 2 - win.get_width() // 2, HEIGHT // 2))
pygame.display.flip()
pygame.time.wait(3000)

Showcase

Montre ton jeu à un coach et à un buddy. Qui atteint la phase 3 et survit ?

À la prochaine !

« La prochaine fois : ton propre jeu, de zéro, entièrement ton idée. »

À emporter chez toi

Essaie une de ces extensions à la maison :

1. Facile : change la couleur du boss selon la phase (vert → orange → rouge).
2. Moyen : ajoute un score : plus tu bats le boss vite, plus tu marques de points.
3. Difficile : fais aussi tirer le boss en diagonale en phase 2 (en biais à gauche et à droite).
4. Très difficile : ajoute un deuxième joueur qui peut participer avec les touches WASD.

Bloqué ? Demande au dojo suivant à un coach, ou essaie simplement autre chose. Programmer, c’est faire.

Regarde le cheatsheet de cette session

Session 10 : Mon jeu

Cette session est la tienne. Pas d’étapes fixes, pas de mécaniques obligatoires. C’est toi qui décides ce que tu construis, et aujourd’hui tu le fais.

Ton jeu, tes règles

En neuf sessions, tu as appris :

• Les variables, les fonctions et les boucles de jeu
• Le clavier et la souris
• Les sprites, la détection de collision et le score
• Le son et l’animation
• Les classes et l’héritage
• Les arrière-plans qui défilent, le spawn et la difficulté qui augmente
• Les barres de HP, les state machines et l’IA du boss

Toutes ces briques sont prêtes. Aujourd’hui, tu les combines dans ton propre jeu.

Choisis ton concept

Pas encore d’idée ? Voilà quelques genres pour commencer :

Dodge game : esquive des objets qui arrivent de plus en plus vite. Simple mais accrocheur.

Platformer : saute de plateforme en plateforme, ramasse des items, évite les ennemis.

Shooter : descends les ennemis qui arrivent d’en haut ou sur le côté.

Jeu de puzzle : fais glisser des blocs, relie des points, ou résous un motif.

Jeu de course : dessine un parcours et fonce vers l’arrivée le plus vite possible.

Raconte une histoire : pas de score, pas de vies. Laisse le joueur cliquer et faire des choix.

Tu peux aussi combiner : un shooter avec des éléments de puzzle, un platformer avec un boss à la fin. Tout est permis.

Planifie ton jeu

Avant d’écrire du code, réponds à ces trois questions :

1. Que fait le joueur ? (se déplacer, tirer, sauter, cliquer, …)
2. Quel est le but ? (faire un score, battre le boss, atteindre la fin, …)
3. Qu’est-ce qui rend le jeu difficile ? (des ennemis, des obstacles, un timer, …)

Écris tes réponses sur une feuille ou dans un commentaire en haut de ton code. Ça t’aide à rester concentré quand tu bloques.

Animation : changer de sprite à chaque frame

Tu veux une animation en boucle, une explosion ou un objet qui clignote ? Fais une liste de noms d’images et change actor.image toutes les N millisecondes. La démo ci-dessous montre comment ça marche : utilise le curseur pour changer la vitesse et le bouton pour mettre en pause :

En Python, tu utilises alors une liste de noms d’images et un timer :

frames = ['lopen_1', 'lopen_2', 'lopen_3', 'lopen_4']
anim_timer = 0
FRAME_DUUR = 10   # frames (à 60 fps = ~167 ms)

def update():
    global anim_timer
    anim_timer += 1
    speler.image = frames[(anim_timer // FRAME_DUUR) % len(frames)]

À toi de jouer

Télécharge le starter via ce lien. Le starter a :

• Une game loop pygame qui fonctionne
• Une section draw() et update() vide
• Des constantes de couleur et une variable de police prêtes
• Des commentaires qui indiquent où mettre quoi

Ouvre main.py et commence par l’étape 1 de ton propre plan. Le cheatsheet de cette page a tous les patrons des sessions précédentes sous la main.

Bloqué ? Demande à un coach. Décris ce que tu veux obtenir, pas seulement ce qui ne marche pas. Comme ça, on peut chercher ensemble la meilleure approche.

Fini trop vite ? Ajoute du son, fais un écran de démarrage, ou ajoute un deuxième joueur.

Showcase

À la fin de la session, chacun présente son jeu. Tu ne dois pas l’avoir terminé. Montre ce que tu as fait et raconte :

• Quel est le concept de ton jeu ?
• Quelle technique d’une session précédente as-tu utilisée ?
• Qu’est-ce que tu aimerais encore ajouter si tu avais plus de temps ?

Et maintenant ?

CoderDojo s’arrête après dix sessions. Construire toi-même, ça ne s’arrête pas.

Continue à construire. Les petits projets t’apprennent plus que les gros cours. Fais un jeu pour ton frère ou ta sœur, pour ton animal, ou juste pour toi.

Besoin d’inspiration ?

• pygame.org : documentation officielle pygame et exemples
• itch.io : des milliers de jeux gratuits à jouer et qui te font apprendre
• realpython.com : des tutoriels Python gratuits pour tous les niveaux
• open.spotify.com et freesound.org : des effets sonores gratuits pour tes jeux

CoderDojo revient. Toi aussi ?

Continue à construire !

En dix sessions, tu as construit un platformer, un shooter, un boss battle et plus encore. Emporte ce code à la maison, rouvre-le la semaine prochaine et ajoute juste une chose. C’est comme ça que travaillent les programmeurs.

Regarde le cheatsheet de cette session