ARBEITSBLATT 1: PYTHON CITY

Das Arbeitsblatt stellt ein realistisches Szenario in der Informatik-Branche dar: Du bist in einer Firma als Programmierer angestellt und solltest ein Projekt deines Vorgängers weiter führen. Als Vorlage erhältst du ein komplexes, lauffähiges Programm. Deine Aufgabe ist es, das Programm zu verstehen und bestimmte Anpassungen vorzunehmen.

Das Programm zeichnet ein Bild einer Stadt. Da der Programmcode zufällige Elemente enthält, wird bei jedem Ausführen des Programms die Stadt anders aussehen.

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

ARBEITSBLATT 2: MONDRIAN

Das Programm teilt das GPanel-Fenster zufällig vertikal und horizontal in farbige Rechtecke. Die Farben werden aus der Liste colors zufällig gewählt.

Die Grafiken erinnern an Kunstwerke des Malers Piet Mondrian.

Programm: [► 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()

ARBEITSBLATT 3: BRAIN GAME

Spielbeschreibung:
Das Spielfeld besteht aus einer Lampe, welche in den Farben rot, gelb, grün und blau leuchten kann, und im ausgeschalteten Zustand weiss ist.

Es gibt zudem 4 kreisförmige Schaltflächen (Buttons), mit den Farben rot, gelb, grün und blau. Die Lampe zeigt immer längere Sequenzen mit zufälligen Farben: Zuerst mit einer Farbe, dann mit zwei Farben, usw. Der Spieler muss nach jeder gezeigten Sequenz durch Drücken der Buttons die gezeigte Sequenz wiederholen. Macht er dies richtig, so wird die Länge der Sequenz um 1 erhöht, macht er einen Fehler, so wird das Spiel beendet. Ziel ist es, eine möglichst lange Sequenz zu erreichen.

Das Problem wird in 6 Schritten gelöst.

Schritt 1: Darstellung des Spielfeldes
Verwende das folgende Programmgerüst:

Programm:  [► 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()

Schreibe die Funktionen gemäss folgender Dokumentation:

Schritt 2: Mit der Maus die Lampe in 4 Farben ein- und ausschalten
Beim Drücken auf die Farbbuttons wird die Lampe mit der gleichen Farbe eingeschaltet. Beim Loslassen wird die Lampe wieder weiss. Verwende die Callbacks: onMousePressed(x, y) und onMouseReleased(x, y), die du bei makeGPanel() registrieren musst. Verwende dazu eine Variable buttonIndex im Bereich 0...3 für Klicks auf Buttons und -1 und -2 für Klicks auf  weisse und schwarze Flächen.

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)

Schritt 3: Zufällige Sequenzen mit Farben rot, gelb, grün und blau erstellen
Importiere die ganzzahligen Zufallszahlen mit from random import randint. Füge im Hauptteil die folgenden Zeilen ein, die eine Liste seq mit n zufälligen Zahlen im Bereich 0..3 erstellt. Die Anzahl der Elemente in der Sequenz wird zum Testen n = 3 gesetzt.

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

Schreibe die Funktion showSequence() , die diese Sequenzen darstellt. Die Anzeigedauer wird hier auf 1000 Millisekunden gesetzt.

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

Schritt 4: Sequenz wiederholen und überprüfen
Nach der Anzeige der Sequenz mit 3 Farben beginnt der Benutzer mit der Wiederholung der Farbsequenz durch Drücken der Buttons. Macht er einen Fehler, so bricht das Spiel sofort mit einer IsOver-Meldung ab, macht er es richtig, so wird eine Erfolgsmeldung ausgeschrieben.

Der Test auf die richtige Sequenz erfolgt bei jedem Loslassen der Maus, also im Callback onMouseReleased(x, y).  Dazu muss man mit der Variablen clickCount die bereits gemachten Mausklicks zählen und  mit

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

überprüfen, ob der richtige Klick gemacht wurde. Ist dies der Fall, so erhöht man clickCount, andernfalls setzt man ein Flag isOk = False. Damit das Hauptprogramm informiert wird, wenn der Test zu Ende ist, verwendet man ein Flag 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

Hat man die ganze Sequenz erfolgreich getestet, so setzt man isOk = True. Die Variablen clickCount, isOk und isUserActive müssen als global definiert und im Hauptprogramm initialisiert werden. Im Hauptprogramm fügst du eine Warteschleife ein, die solange läuft, bis die Benutzeraktion beendet ist.

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

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")

 if not isMouseEnabled:
      return