Jeu du Panier

Tu adores les pommes ? Récolte un maximum de pommes en codant un jeu ! 🛒🍎

Maintenant que tu as appris à utiliser des micro:bit, il est temps de passer aux choses sérieuses avec un petit projet guidé. Le but de ce projet est de faire un jeu du panier :

Jeu du panier

Principe du jeu

Le principe général est de ramasser des pommes qui tombent du ciel à l’aide d’un panier.

Le panier

Le panier se trouve sur le sol. Il peut se déplacer sur tout l’axe horizontal (axe X), mais pas sur l’axe vertical (axe Y). Il sert à ramasser les pommes qui tombent du ciel.

Les pommes

Les pommes tombent une par une du ciel, depuis une position aléatoire. Il faut réussir à en attraper le plus possible pendant la partie.

Fin de la partie

La partie se finit lorsqu’une pomme touche le sol. Dans ce cas, nous afficherons le score du joueur.

Petit récapitulatif

Avant de coder quoi que ce soit il faut être sûr d’avoir une idée concrète de ce que tu vas faire.

Si on reprend globalement ce que l’on va faire on peut décomposer le jeu en trois étapes :

Étape 1 : créer le panier, celui-ci ne pourra faire qu’aller vers la gauche ou la droite, en restant bloqué sur la ligne du bas.
Étape 2 : créer une pomme, celle-ci apparaîtra sur la ligne du haut et sur une colonne aléatoire. Elle descendra tous les “x” temps.
Étape 3 : si on n’attrape pas la pomme, il faut afficher un message de fin de partie et arrêter le jeu.

Partie I : Le panier

Attention, pense à bien importer la bibliothèque microbit avant de commencer.

1

from microbit import *

Dans cette partie, nous allons simplement nous occuper du panier. Le panier fait 1 pixel de large. Comme dit précédemment, le panier restera sur la 4e ligne, donc pas besoin de s’occuper de l’axe Y. Cependant il n’aura pas toujours la même position sur l’axe X (horizontal).

Commençons donc par créer une variable pos_panier qui représentera sa position sur cet axe X. Au début de la partie, le panier sera au milieu de l’écran, soit en position 2 comme sur l’image ci-dessous.

Maintenant que cette variable est créée, nous allons vouloir déplacer notre panier. Pour cela, tant que le joueur n’a pas perdu, il pourra bouger le panier. Tu peux utiliser une variable booléenne.

Rappel : les variables booléennes

Une variable booléenne représente deux valeurs : True ou False.
Les valeurs True et False représentent respectivement les états Vrai et Faux. Nous sommes à l’état Vrai lorsque l’affirmation que l’on teste est vérifiée.

Appuie sur le bouton Run pour exécuter le code python ci-dessous

# On teste l'inégalité 1 < 2
print(1 < 2)

Le résultat :

Ce test nous renvoie le mot clé True donc l’affirmation 1 < 2 est vraie

Une variable booléenne peut stocker le résultat de ce test ou simplement être initialisée à True ou False.

Appuie sur le bouton Run pour exécuter le code python ci-dessous

# On initialise notre variable avec le résultat de notre test
v_bool = 1 < 2
print(v_bool)

# On définit maintenant notre variable avec la valeur `False`
v_bool = False
print(v_bool)

Le résultat :

Attention

Il y a une différence entre = et == en Python. Le = est utilisé pour de l’assignation de valeur, alors que le == est utilisé pour de la comparaison.

Appuie sur le bouton Run pour exécuter le code python ci-dessous

# Assignation, v prend la valeur de 1
v = 1
print(v)

# Comparaison, v_bool prend la valeur de la comparaison 1 == 1
v_bool = 1 == 1
print(v_bool)

Le résultat :

Rappel : les boucles

Une variable booléenne peut donc être utilisée dans une condition (if) ou comme condition d’arrêt d’une boucle (while). Pour une utilisation dans une boucle, il faudra penser à actualiser la valeur de notre variable à l’intérieur de notre boucle.

Appuie sur le bouton Run pour exécuter le code python ci-dessous

# On définit notre variable booléenne à `True` à l'état initial
v_bool = True

if v_bool:
    # Si la variable est à vrai alors le programme évalue
    # les expressions à l'intérieur de la condition
    print("Condition réalisée")

Le résultat :

Appuie sur le bouton Run pour exécuter le code python ci-dessous

# On initialise la variable `en_cours` à `True`
en_cours = True
x = 0

while en_cours:
    # Tant que la variable reste à `True`, on évalue les
    # expressions dans la boucle

     # Si x est égale à 5
    if x == 5:
        # Alors on met la variable `en_cours` à `False`
        en_cours = False
        # `en_cours` étant à `False` on sort de la boucle

     # Sinon on ajoute 1 à x
    else:
          x = x + 1

print(x)
# Tu peux constater qu'à la fin de cette boucle
# la variable x a une nouvelle valeur : 5

Le résultat :

Bien évidemment si tu as une quelconque question, ou que tu veux qu’on te réexplique quelque chose, n’hésite pas à demander à un organisateur de l’aide.

Pour déplacer le panier, nous allons utiliser les boutons du micro:bit. Le bouton A permettra de déplacer le panier à gauche, tandis que le bouton B déplacera le panier à droite. Il faut alors calculer sa nouvelle position et ensuite redessiner le panier à l’écran. Pour cela, tu peux utiliser la variable pos_panier pour déterminer la nouvelle position du panier en fonction des boutons pressés.

Rappel : les boutons sur le micro:bit

Pour utiliser les boutons, tu peux utiliser les fonctions suivantes :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


button_a.is_pressed()   # Ces fonctions renvoient True ou False si le
button_b.is_pressed()   # bouton est appuyé quand la ligne est exécutée
                        # par le micro:bit

button_a.was_pressed()  # Ces fonctions renvoient True ou False si le bouton
button_b.was_pressed()  # a été appuyé depuis la dernière fois qu'elles ont
                        # été appelées

button_a.get_presses()  # Ces fonctions renvoient le nombre d'appuis effectués
button_b.get_presses()  # sur le bouton depuis la dernière fois qu'elles ont
                        # été appelées

Cependant, il ne faut pas oublier de rajouter un délai entre chaque tour de boucle pour éviter que les pixels clignotent. Pour cela tu peux utiliser la fonction sleep(150).

Attention : ne pas dépasser les limites

Il faut faire en sorte que le panier ne sorte pas de l’écran, sinon cela causera une erreur.
Pour cela, n’oublie pas de vérifier, à l’aide de conditions, les cas suivants :

si le panier dépasse vers la droite, que faire ?
si le panier dépasse vers la gauche, que faire ?

Avant de passer à la partie suivante, assure-toi d’avoir un panier pouvant bouger à droite et à gauche sur toute la ligne grâce aux boutons.

Partie II : Les pommes

Dans cette partie nous allons nous occuper de l’ajout des pommes.

Pour créer notre pomme nous allons utiliser deux variables pomme_x et pomme_y. L’utilisation de ces deux variables va nous permettre de conserver la position des pommes, la position horizontale en x et la position verticale en y, dans deux variables (ou boîte).

1
2
3
4
5
6


# Ici les variables contiennent les nombres 1 et 2.
pomme_x = 1
pomme_y = 2

# Pour afficher la pomme, qui est en 2e colonne, 3e ligne
display.set_pixel(pomme_x, pomme_y, 9)

En cas de besoin, n’hésite pas à demander de l’aide aux organisateurs qui sont là pour t’aider.

Rappel : générer des nombres aléatoires

Appuie sur le bouton Run pour exécuter le code python ci-dessous

# Importer la fonction permettant de générer un nombre aléatoire
# Cette ligne doit apparaître tout en haut de ton fichier !
from random import randint

# Générer un nombre entier `a` entre 0 et 4 inclus
# et l'affiche
a = randint(0, 4)
print(a)

Le résultat :

Pour ce qui est des valeurs de ces variables, la pomme apparaîtra sur la ligne 0 et sur une colonne aléatoire du micro:bit. Tu as ci-dessus l’explication de comment créer un nombre aléatoire.

Tu peux maintenant faire apparaître une pomme de manière aléatoire sur l’axe x.

Il va falloir maintenant faire descendre la pomme de l’écran. Cependant, on veut que les pommes tombent moins vite que la vitesse de déplacement du panier. Si on fait tomber les pommes à chaque fois que l’on peut déplacer le panier, les pommes vont descendre trop vite. Sur ce principe, on va alors faire descendre les pommes tous les X tours de boucle, ce qui permettra de ralentir les pommes.

Pour cela, nous allons créer deux variables :

tour : le nombre de tours de boucle que l’on a fait depuis la dernière fois qu’une pomme est descendue (est à 0 au début)
tour_max : le nombre de tours de boucle que l’on doit attendre pour faire descendre une pomme que l’on mettra à 10

En utilisant les conditions et les variables que l’on vient de créer on va vérifier les conditions suivantes :

Si tour est égal à tour_max, on va faire descendre la pomme en modifiant la variable pomme_y et remettre à 0 la variable tour.
Sinon, ça veut dire que tour est inférieur à tour_max. Ainsi, on doit rajouter 1 à tour vu que l’on a fait un tour de boucle en plus.

Si la pomme est sur la dernière ligne, la plus basse, il faut alors gérer les deux cas suivants :

la position est la même que celle du panier alors le joueur a réussi, et il faut faire apparaître une nouvelle pomme sur l’écran.
sinon, c’est que le joueur a perdu. (Tu peux laisser cette partie vide pour l’instant, on y reviendra dans la 3e partie).

Compter les pommes

Par ailleurs, il est nécessaire de compter le nombre de pommes attrapées au cours de la partie. Pour faire cela, tu peux utiliser une variable te servant de compteur. À la fin de la partie, tu peux, à l’aide de ce compteur, afficher le nombre de pommes attrapées. Ce compteur est initialisé à 0 et s’incrémente de 1 à chaque fois qu’une pomme touche le panier. Attention, il ne faut pas comptabiliser une pomme si celle-ci tombe à côté du panier.

À vérifier

Avant de passer à la partie suivante, veille à vérifier ces différents points :

toujours pouvoir bouger le panier dans les deux directions.
avoir toujours au moins une pomme qui tombe sur ton écran.
pouvoir attraper la pomme avec le panier.
avoir un score qui compte le nombre de pommes attrapées.

Si tu as le moindre problème avec ton jeu, n’hésite pas à appeler un organisateur pour lui demander des conseils.

Partie III : Fin de partie

Quand le joueur a perdu, il faut sortir de la boucle. Pour ce faire, il suffit de passer notre condition de boucle à False.

Une fois sorti de la boucle, il faut afficher un message pour indiquer au joueur que ce dernier a perdu.

À vérifier

Vérifie bien que si l'on n'attrape pas la pomme, la partie se termine bien et affiche le score.

Une fois cette partie finie, ton jeu devrait marcher complétement ! Tu peux t’amuser avec, le tester, pour vérifier que tout marche correctement.

Partie IV : Améliorations

Une fois le jeu fini, tu peux ajouter plusieurs améliorations. Note que chaque amélioration est réalisable indépendamment des autres.
Avant de commencer cette partie, vérifie que ton jeu fonctionne correctement. Si ce n’est pas le cas, n’hésite pas à demander de l’aide aux organisateurs !

Accélération de la chute des pommes !

Pour rendre la partie plus difficile et amusante, tu peux augmenter la vitesse de chute des pommes au fur et à mesure de l’avancement de la partie.
Il faut tout de même s’assurer que le jeu reste faisable, en posant par exemple une limite de vitesse de chute.

Rajout d’un son !

À chaque fois que tu collectes une pomme, tu peux rajouter un petit son. Pour ce faire, tu peux utiliser la fonction music.play() comme dans l’exemple ci-dessous !

1
2
3
4
5


# Importe la librairie music
import music

# Joue une note
music.play("F:2")

N’hésite pas à demander à un organisateur de l’aide si tu souhaites changer de note ou même faire une mélodie !

Jouons pour la fin des temps

Cette amélioration va surement pas mal changer ton code, donc n’hésite pas à faire une sauvegarde de ce qui marche avant de modifier quoi que ce soit.

Ton but sera d’ajouter la possibilité qu’à la fin de la partie tu puisses, soit en relancer une autre en appuyant sur le bouton A, soit tout arrêter en appuyant sur le bouton B. Avec cet ajout, tu peux t’amuser à créer une nouvelle variable best_score pour que tu puisses avoir le meilleur score que tu as atteint depuis que tu as lancé ton programme.

Pour finir, avec ce meilleur score tu peux même ajouter la possibilité de l’afficher en appuyant sur le logo.

N’hésite pas à afficher un petit message quand tu bats le précédent best_score. Un peu de challenge voyons !

Un peu d’aide ?

Ce qui serait amusant c’est que tu essayes de le faire toute seul. Avec tes idées, ta façon de penser et ta manière de faire. Tu peux bien évidemment appeler un organisateur si quelque chose te bloque.

Si tu ne sais vraiment pas par où commencer ou que tu veux juste continuer à être quelque peu guidé, voici quelques petites pistes :

Tu vas avoir besoin d’une autre boucle qui englobe tout, et donc une autre variable qui permettra de déterminer si le jeu s’arrête ou pas.
Il te faudra trois conditions qui vérifient si tu appuis sur les différents boutons. Cela te permettra d’effectuer les actions voulues.
Pour finir, à la fin d’une partie, n’oublie pas de mettre à jour le best_score si nécessaire et d’afficher un message selon si tu l’as battu ou pas.

Bravo, te voilà arrivée à la fin de ce projet !
Tu as maintenant un code qui fonctionne. Si tu as des idées d’amélioration, essaye de les mettre en place par toi-même !

Retour au Menu