FICHE DE TRAVAIL 1: PYTHON CITY

Cette fiche présente un scénario réaliste du domaine de l’informatique : tu es employé dans une entreprise en tant que programmeur et tu dois poursuivre un projet commencé par ton prédécesseur. On te fournit un programme complexe et fonctionnel comme modèle. Ta tâche consiste à comprendre ce programme et à effectuer certaines modifications.

Le programme génère l’image d’une ville. Comme le code contient des éléments aléatoires, la ville sera différente à chaque exécution.

if random() < 0.4: meineFarbe = [0, 0, 0]

FICHE DE TRAVAIL 2: MONDRIAN

Le programme divise la fenêtre GPanel aléatoirement en rectangles verticaux et horizontaux colorés. Les couleurs sont choisies aléatoirement dans la liste colors.

Les graphiques rappellent les œuvres du peintre Piet Mondrian.

Programme:  [► WebTigerPython]   [► WebTigerJython]

# Mondrian.py
from gpanel import *
from random import *

def between(a, b):
    return a + (0.2 + 0.3 * random()) * (b - a)

def randomColor():
    while True:
        result = choice(colors)
        return result
    
def rect(xMin, yMin, xMax, yMax):
    for aColor in ('black', randomColor()):
        setColor(aColor)        
        fillRectangle(xMin, yMin, xMax, yMax)           
        xMin += delta
        yMin += delta
        xMax -= delta
        yMax -= delta
    
def maybe(bias = None):
    return choice([False,True,bias,bias] if bias!=None else [False,True])   

def draw(xMin = 0, yMin = 0, xMax = 500, yMax = 500):
    if xMax - xMin > threshold and yMax - yMin > threshold:
        if maybe(xMax - xMin > yMax - yMin):
            xMid = between(xMin, xMax)
            if maybe():
                draw(xMin, yMin, xMid, yMax)
                rect(xMid, yMin, xMax, yMax)
            else:
                rect(xMin, yMin, xMid, yMax)
                draw(xMid, yMin, xMax, yMax)
        else:
            yMid = between(yMin, yMax)
            if maybe():
                draw(xMin, yMin, xMax, yMid)
                rect(xMin, yMid, xMax, yMax)
            else:
                rect(xMin, yMin, xMax, yMid)
                draw(xMin, yMid, xMax, yMax)
    else:
        rect(xMin, yMin, xMax, yMax)

makeGPanel(0, 500, 0, 500)
colors = ['gray', 'lime', 'red', 'white', 'blue', 'yellow']
delta = 6
threshold = 100
setColor ('black')
draw()

FICHE DE TRAVAIL 3: BRAIN GAME

Description du jeu:
Le terrain de jeu contient une lampe pouvant s’allumer en rouge, jaune, vert ou bleu. Lorsqu’elle est éteinte, elle est blanche.

Il y a également 4 boutons circulaires de couleur rouge, jaune, vert et bleu. La lampe affiche des séquences de plus en plus longues de couleurs aléatoires : d’abord une couleur, puis deux, etc. Le joueur doit reproduire la séquence en appuyant sur les boutons. S’il réussit, la séquence s’allonge de 1. S’il se trompe, la partie se termine. Le but est d’obtenir la plus longue séquence possible. Le problème est résolu en 6 étapes:

Étape 1: Affichage du terrain de jeu
Utilise le squelette de programme suivant :

Programme:  [► WebTigerPython] [► WebTigerJython]

# BrainGame0.py
from gpanel import *

def showLamp(col):
    pass

def showButton(number):
    pass

def setup():
    for i in range(4):
        showButton(i)
    showLamp(-1)
  
makeGPanel(-200, 200, -200, 200)
setColor("black")
fillRectangle(400, 400)
addStatusBar(30)
setup()

Écris les fonctions selon la documentation suivante:

Étape 2: Interaction souris
Lorsque l’on clique sur un bouton, la lampe s’allume dans la même couleur. Lors du relâchement, elle redevient blanche. Utilise les callbacks onMousePressed(x, y) et onMouseReleased(x, y) enregistrés dans makeGPanel().

Utilise pour cela une variable buttonIndex dans l’intervalle 0...3 pour les clics sur les boutons, ainsi que -1 et -2 pour les clics sur les surfaces blanches et noires.

def onMousePressed(x,y):    
    if getPixelColorStr(x, y) == "red":
        buttonIndex = 0
    elif ...

    elif getPixelColorStr(x, y) == "white":
        buttonIndex = -1
    else:
        buttonIndex = -2    
    if buttonIndex >= 0:
        showLamp(buttonIndex)

def onMouseReleased(x,y):
    showLamp(-1)                
  
makeGPanel(-200, 200, -200, 200, mousePressed = onMousePressed, 
                                 mouseReleased = onMouseReleased)

Étape 3: Créer des séquences aléatoires avec les couleurs rouge, jaune, vert et bleu
Importe les nombres aléatoires entiers avec from random import randint.

Ajoute dans la partie principale les lignes suivantes, qui créent une liste seq contenant n nombres aléatoires dans l’intervalle 0..3. Pour les tests, le nombre d’éléments de la séquence est fixé à n = 3.

seq = []
n = 3
for i in range(n):
    seq.append(randint(0, 3))
setStatusText("Showing sequence with length " + str(n))    
showSequence()

Écris la fonction showSequence() qui affiche ces séquences.
La durée d’affichage est ici fixée à 1000 millisecondes.

def showSequence():
    for k in seq:
        delay(1000)
        showLamp(k)
        delay(1000)
        showLamp(-1)

Étape 4: Reproduire et vérifier la séquence

Après l’affichage de la séquence de 3 couleurs, l’utilisateur commence à reproduire la séquence en appuyant sur les boutons. S’il fait une erreur, le jeu s’arrête immédiatement avec un message « IsOver ». S’il réussit, un message de succès est affiché. Le test de la bonne séquence s’effectue à chaque relâchement de la souris, donc dans le callback onMouseReleased(x, y). Pour cela, on utilise la variable clickCount pour compter les clics déjà effectués et :

if seq[clickCount] == buttonIndex: 
      clickCounr += 1

pour vérifier si le bon clic a été effectué. Si c’est le cas, on augmente clickCount, sinon on définit un drapeau isOk = False. Pour informer le programme principal lorsque le test est terminé, on utilise un drapeau isUserActive.

global clickCount, isUserActive, isOk
if seq[clickCount] == buttonIndex: 
    setStatusText("Sequence confirmed")
    clickCount += 1
else:
    isOk = False
    setStatusText("Sequence false")
if clickCount == len(seq):
    isUserActive = False
    isOk = True

Lorsque toute la séquence a été vérifiée avec succès, on définit isOk = True. Les variables clickCount, isOk et isUserActive doivent être définies comme global et initialisées dans le programme principal. Dans le programme principal, ajoute une boucle d’attente qui tourne jusqu’à ce que l’action de l’utilisateur soit terminée.

isUserActive = True
isOk = False
while isUserActive:
    delay(10)
if isOk:
    setStatusText("Sequence confirmed")
else:
    setStatusText("Sequence false")    
delay(2000)

Jusqu’ici, tu jouais avec une longueur de séquence fixe de 3. Maintenant, tu dois commencer avec une longueur de séquence de 1 et l’augmenter de 1 si l’utilisateur l’a correctement devinée. Tu continues ainsi jusqu’à ce qu’il fasse une erreur. Tu as si bien préparé le programme que cette extension est facile à implémenter. Après setup() et l’initialisation de n = 1, ajoute le reste du programme dans une boucle infinie while et augmente n lorsque l’utilisateur réussit. S’il fait une erreur, quitte la boucle avec break.

setup()
n = 1
while True:
    clickCount = 0
    setStatusText("Showing sequence with length: " + str(n) + "...")
    delay(2000)
    seq = []
    for i in range(n):
        ....
    
    showSequence()
    setStatusTex("Click tu repeat sequence")
    isUserActice = True
    isOk = False
    if isOk:
        setStatusText("Sequence confirmed")
        delay(2000)
        n += 1
    else:    
        break
setStatusText("sequence failed")

Le jeu peut déjà être joué si l’utilisateur respecte certaines règles et ne clique pas avec la souris au mauvais moment. Tu dois donc encore améliorer le programme afin qu’un clic de souris au mauvais moment ne provoque aucune catastrophe. Pour cela, introduis dans le programme principal un autre drapeau isMouseEnabled. Au début de la boucle while True, cette variable est mise à False et elle ne passe à True que lorsque l’utilisateur est autorisé à utiliser la souris, c’est-à-dire lorsqu’il doit reproduire la séquence. Si isMouseEnabled == False, tu quittes simplement les deux callbacks sans effectuer d’autre action.

 if not isMouseEnabled:
      return