Coder en Python

Le code nécessaire à la réalisation du projet Go Fast a été écrit en micropython. Vous trouverez ci-dessous :

Le code, étape par étape

Initialisation du programme

  1. Incluons la bibliothèque Micro:bit et la bibliothèque random pour générer de l’aléa :

    from microbit import *
import random

  2. Il y a dans ce jeu différents états. Initialement, le programme commence à l’état 0.

    Note

    L’utilisation de la variable etat permet de naviguer entre différent moment du programme.

    • etat =  0 : le jeu est en attente d’une partie. On quitte cet état en pressant le bouton A ou B
    • etat = 1 : le compte à rebours se lance. 3 secondes plus tard, on passe automatiquement à l’état 2.
    • etat = 2 : la partie est en cours. Une pression sur le bouton A ou B permet de passer à l’état 3.
    • etat = 3 : l’écran indique le bouton gagnant puis passe automatiquement à l’état 0.
    etat = 0

  3. La variable victoire stocke le nom du bouton gagnant. Cette variable est un texte qui peut valoir "A" ou "B". En début de partie, nous l’initialisons à un texte vide :

    victoire = ""

    Astuce

    Pour faire une pause d’une certaine durée, il n’est parfois pas recommandé d’utiliser la commande sleep.

    En effet, sleep empêche l’exécution de toutes les autres directives du programme durant cette pause.

    Il est préférable de déterminer une durée depuis un temps de référence et de tester, à chaque boucle d’itération la durée écoulée.

    Pour cela, il faudra utiliser la commande runing_time().

  4. Dans ce programme, il faut parvenir à déterminer une durée. Pour cela, nous allons utiliser la commande running_time() qui retourne la durée depuis laquelle le Micro:bit est sous tension.

    Après avoir initialisé notre temps de référence t0 (au démarrage du micro:bit ou en appuyant sur un bouton), nous calculerons la différence running_time() - t0 qui déterminera la durée.

    Initialisons t0

    t0 = running_time()

  5. Pour déterminer une durée, définissons la fonction chrono().

    La durée écoulée entre le temps de référence t0 et le moment de l’appel de la fonction.

    def chrono(t0):
    t1 = running_time()
    duree = t1-t0
    return duree

  6. Enfin, affichons à l’écran une image pour indiquer le programme est en attente.

    display.show(Image.HEART_SMALL)

Boucle

Avertissement

Lorsqu’un objet connecté est mis sous tension, le programme s’exécute après une brève phase d’initialisation.

S’il n’y a pas de boucle, le programme ne s’exécute qu’une seule fois puis… plus rien!

En fait, un objet connecté est en permanence en train d’attendre que quelque chose se passe : un bouton pressé, un geste, une certaine température, luminosité ou autres.

Un peu comme votre clavier qui attend en permanence que vous appuyiez sur une touche.

C’est pour cela qu’il est nécessaire d’exécuter une boucle infinie qui met le microcontrôleur en état d’attente.

  1. La phase de configuration est terminée. Passons maintenant à la boucle qui… tourne en boucle.

    while True:

  2. Configurons l’état 0 du programme qui attend que l’un des joueurs presse son bouton.

    Lorsqu’un bouton est pressé, il faut initialiser le temps de référence t0 puis changer d’état. La pause sleep(250) permet d’éviter un double-clic du bouton qui entraînerait la fin prématurée de la partie.

        if etat == 0:
        if button_a.is_pressed() or button_b.is_pressed():
            # remise à zéro de la durée de la partie
            t0 = running_time()
            etat = 1
            sleep(250)

  3. Il est temps de relever la durée écoulée depuis le temps de référence.

        duree = chrono(t0)

  4. L’état 1 affiche le compte à rebours.

        if etat == 1:

    Mais attention, si un joueur presse un bouton dans cet état, la partie est immédiatement perdue (et on passe alors à l’état 3 sans passer par la case Départ).

            if button_a.is_pressed():
            victoire = "B"
            etat = 3
        if button_b.is_pressed():
            victoire = "A"
            etat = 3

    Affichons le compte à rebours (sans oublier que les durées sont en millisecondes).

            if duree < 1000:
            display.show("3")
        elif duree < 2000:
            display.show("2")
        elif duree < 3000:
            display.show("1")
        else:

    Puis après les 3 secondes, on va effacer l’écran, déterminer une durée d’attente au hasard, choisir une image au hasard et enfin passer à l’état 2.

            else:
            display.clear()
            attente = duree + random.randint(500, 5000)
            imageAuHasard = random.choice(Image.ALL_CLOCKS)
            etat = 2

  5. L’état 2 est le jeu à proprement dit. Le plus rapide des joueur à presser son bouton sera enfin déclaré vainqueur.

        if etat == 2:

    Mais attention, si un joueur clique avant la durée d’attente alors son adversaire gagne immédiatement (et on passe alors à l’état 3).

            if duree < attente:
            if button_a.is_pressed():
                victoire = "B"
                etat = 3
            if button_b.is_pressed():
                victoire = "A"
                etat = 3

    Une fois que la durée a dépassée l’attente souhaitée, alors là le plus rapide gagne.

            if duree > attente:
            display.show(imageAuHasard)
            if button_a.is_pressed():
                victoire = "A"
                etat = 3
            if button_b.is_pressed():
                victoire = "B"
                etat = 3

  6. L’état 3 permet d’indiquer le vainqueur.

        if etat == 3:

    D’abord une petite animation pour le suspens.

            for i in range(5):
            display.show(Image.HEART_SMALL)
            sleep(100)
            display.show(Image.HEART)
            sleep(100)

    Puis enfin le vainqueur. Nous allons utiliser une flèche pointant vers le bouton en question. La flêche Ouest qui pointe le bouton de gauche (A) et la flêche Est qui pointe le bouton B de droite.

            if victoire == "A":
            display.show(Image.ARROW_W)
        if victoire == "B":
            display.show(Image.ARROW_E)
        etat = 0

    Pour finir, une pause qui ne fait pas de mal (peut être même que ça économise les piles…).

        sleep(100)

Le code final

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
# -*- coding: utf-8-*-# Encoding cookie added by Mu Editor
# code utilisé pour l'atelier colloque C2i collège
# auteur : groupe InEFLP IREM de Marseille

from microbit import *
import random

# différente ETAT du jeu
# si etat == 0 : attente du début de partie (A ou B)
# si etat == 1 : compte à rebours
# si etat == 2 : en cours de partie
# si etat == 3 : affichage du gagnant
etat = 0

# victoire == "A" : bouton A gagne
# victoire == "B" : bouton B gagne
# victoire == "" : personne
victoire = ""

# fonction CHRONO qui sert de chronomètre
# retourne la durée écoulée depuis
# l'instant t0
t0 = running_time()

def chrono(t0):
    t1 = running_time()
    duree = t1-t0
    return duree

display.show(Image.HEART_SMALL)

while True:
    
    if etat == 0:
        if button_a.is_pressed() or button_b.is_pressed():
            # remise à zéro de la durée de la partie
            t0 = running_time()
            etat = 1
            sleep(250)

    # duree de la partie
    duree = chrono(t0)
    
    if etat == 1:        
        # si les joueurs sont trop pressés, ils perdent…
        if button_a.is_pressed():
            victoire = "B"
            etat = 3
        if button_b.is_pressed():
            victoire = "A"
            etat = 3
        
        # affichage du compte à rebours
        if duree < 1000:
            display.show("3")
        elif duree < 2000:
            display.show("2")
        elif duree < 3000:
            display.show("1")
        else:
            # initialisation d'une partie
            #
            # effacer écran
            display.clear()
            # attente et image aléatoire
            attente = duree + random.randint(500, 5000)
            imageAuHasard = random.choice(Image.ALL_CLOCKS)
            etat = 2
    
    if etat == 2:        
        # si les joueurs sont trop pressés, ils perdent…
        if duree < attente:
            if button_a.is_pressed():
                victoire = "B"
                etat = 3
            if button_b.is_pressed():
                victoire = "A"
                etat = 3
        
        # détermination du plus rapide des 2 joueurs
        if duree > attente:
            display.show(imageAuHasard)
            if button_a.is_pressed():
                victoire = "A"
                etat = 3
            if button_b.is_pressed():
                victoire = "B"
                etat = 3
    
    if etat == 3:
        # petite animation pour le suspens
        for i in range(5):
            display.show(Image.HEART_SMALL)
            sleep(100)
            display.show(Image.HEART)
            sleep(100)
        # affichage du gagnant
        if victoire == "A":
            display.show(Image.ARROW_W)
        if victoire == "B":
            display.show(Image.ARROW_E)
        etat = 0
    
    sleep(100)