Alle Programme aus dem Buch

Das aktuelle Tiger-Jython-Entwicklungssystem kannst du dir jederzeit unter www.tigerjython.ch/de/products/download herunterladen!

Hier findest du alle Code-Listings, die im Buch "Let's Code Python" entwickelt und verwendet werden - ab Kapitel 7, wo es mit den richtigen Programmen losgeht. Du kannst sie, wenn du möchtest, direkt per Knopfdruck kopieren und in das Programmfenster von TigerJython einfügen. Das ist sehr praktisch zum Testen, oder wenn du mit dem eigenen Code nicht weiterkommst - oder einfach, um zu sehen, wie das fertige Programm funktionieren soll. Du kannst in der linken Leiste das gewünschte Kapitel aus dem Buch wählen. Die Programmlistings sind dann jeweils in der Reihenfolge des Buchs untereinander aufgeführt.

Trotzdem rate ich allen, die das Programmieren mit Python richtig erlernen wollen, so viel wie möglich selbst einzugeben. Wenn du ein sicherer Programmierer werden willst, dann kommst du am weitesten, indem du versuchst, jedes Programm anhand der Angaben im Buch erst einmal selbst aufzubauen und einzugeben. Mit dem Hinweisen im Buch kannst du es dann immer weiter verfeinern und optimieren. Zum Vergleichen oder Testen kann der Code hier aber sehr hilfreich sein.

Wie kopiere ich den Code in TigerJython?

Es geht ganz einfach: Klicke auf den Button "Code kopieren" direkt unter dem gewünschten Programmlisting. Hierdurch wird der Code markiert und automatisch in die Zwischenablage kopiert. (nur bei älteren oder exotischen Browsern kann es sein, dass der Text nicht automatisch kopiert wird, in dem Fall müsstest Du noch einmal selbst Kopieren wählen, mit Strg-C oder Cmd-C). Anschließend kannst du in TigerJython ein neues Projekt starten, dann in das leere Programmfenster klicken und mit Strg-V (auf dem Mac Cmd-V) den Code einfach einfügen. Fertig. Jetzt kannst du das Programm direkt starten und ausprobieren. Viel Spaß!

Kapitel 7: Programme schreiben

Zahlenzaubertrick

msgDlg("Denke dir eine beliebige Zahl zwischen eins und zehn aus!")
msgDlg("Multipliziere die Zahl mit 5.")
msgDlg("Verdopple die Zahl.")
msgDlg("Teile die Zahl jetzt durch die Zahl, die du Dir am Anfang ausgedacht hast.")
msgDlg("Ziehe 7 von der momentanen Zahl ab.")
msgDlg("Jetzt sage ich dir, welche Zahl du gerade hast. Es ist die...")
msgDlg("DREI!")

Umrechner

laenge_zoll = input("Bitte Länge in Zoll eingeben:")
laenge_cm = laenge_zoll * 2.54
print("Ergebnis:", laenge_cm , "Zentimeter")

Begrüßung

name = input("Wie heißt du?")
print("Freut mich, Dich kennenzulernen, " + name + "!")

Mehrfache Begrüßung

name = input("Wie heißt du?")
anzahl = input("Wie oft soll ich dich begrüßen?")
begruessung = "Hallo "+name+"! "
print(begruessung*anzahl)

Teilen mit Rest

g = input("Wie lautet die Grundzahl?")
t = input("Durch welche Zahl soll sie geteilt werden?")
e = g // t
r = g % t
print("Das Ergebnis ist", e ,"und der Rest ist", r)

Magisches Quadrat 1

a = input("Gib einen Wert für a ein:")
b = input("Gib einen Wert für b ein:")
print("Die Summe aller Reihen, Spalten und Quadrate ist:",a*21+b)
# Magisches Quadrat ausgeben:
print("------------------------------------------------------------")
print(a+b,a,12*a,7*a)
print(11*a,8*a,b,2*a)
print(5*a,10*a,3*a,3*a+b)
print(4*a,2*a+b,6*a,9*a)
print("------------------------------------------------------------")

Magisches Quadrat 2

summe = input("Gib eine Summe (über 21) ein:")
# a und b berechnen:
a = summe // 21
b = summe % 21
# Magisches Quadrat ausgeben:
print("------------------------------------------------------------")
print(a+b,a,12*a,7*a)
print(11*a,8*a,b,2*a)
print(5*a,10*a,3*a,3*a+b)
print(4*a,2*a+b,6*a,9*a)
print("------------------------------------------------------------")

Kapitel 8: Bedingungen

Strecke-Zeit-Berechnung 1 (mit if)

km = input("Wie lang ist die Strecke in km?")
vm = input("Zu Fuß (1) oder Fahrrad (2)?")
if vm == 1:
    # Zu Fuß berechnen:
    stunden = km / 5
if vm == 2:
    # Mit dem Fahrrad berechnen:
    stunden = km / 15
print("Es dauert",stunden,"Stunden.")

Strecke-Zeit-Berechnung 2 (mit if-else)

km = input("Wie lang ist die Strecke in km?")
vm = input("Zu Fuß (1) oder Fahrrad (2)?")
if vm == 1:
    stunden = km / 5
else:
    stunden = km / 15
print("Es dauert",stunden,"Stunden.")

Strecke-Zeit-Berechnung 3 (Abfangen von Fehleingaben)

km = input("Wie lang ist die Strecke in km?")
vm = input("Zu Fuß (1) oder Fahrrad (2)?")

if (vm == 1) or (vm == 2):
    # nur ausführen, wenn 1 oder 2 eingegeben wurde:
    if vm == 1:
        stunden = km / 5
    if vm == 2:
        stunden = km / 15
    print("Es dauert",stunden,"Stunden.")
else:
    # Wenn weder 1 noch 2 eingegeben wurde:
    print("Bitte nur 1 oder 2 eingeben!")

Strecke-Zeit-Berechnung 4 (mit elif)

km = input("Wie lang ist die Strecke in km?")
vm = input("Zu Fuß (1) oder Fahrrad (2)?")

if vm == 1:
    print("Es dauert",km/5,"Stunden.")
elif vm == 2:
    print("Es dauert",km/15,"Stunden.")
else:
    print("Bitte nur 1 oder 2 eingeben!")

Zahl größer als 5

x = input("Gib eine Zahl größer als 5 ein:")
aussage = (x > 5)
if aussage:
    print("Korrekt – die Zahl ist über 5.")
if aussage == False:
    print("Falsche Eingabe")

True oder False

x = input("Gib einen Wert ein:")
if x:   # bedeutet: x ist True, also etwas anderes als 0
    print("Du hast etwas anderes als 0 eingegeben.")
else:   # bedeutet: x ist False, also 0
    print("Du hast den Wert 0 eingegeben.")

Eintrittsprüfung

alter = input("Wie alt bist du?")
fsk = input("Ab wann ist der Film freigegeben?")
erwachsener = input("Ist ein Erwachsener dabei (1)? Oder nicht (0)?")

if (alter >= fsk) or erwachsener:
    print("Du darfst in den Film gehen.")
else:
    print("Du darfst leider nicht in den Film gehen.")

if (alter >= fsk) and erwachsener:
    print("Du brauchst den Erwachsenen nicht mitnehmen.")

if  (not (alter >= fsk)) and erwachsener:
    print("Der Erwachsene muss aber auf jeden Fall mitkommen.")

Kapitel 9: Befehle und Module

import math

import math
x = input()
print(math.sqrt(x))

from math import ...

from math import sqrt
x = input()
print(sqrt(x))

math verwenden

import math
x = input("Gib eine Zahl ein:")
print("Die Wurzel aus",x,"ist:",math.sqrt(x))
print("Der Sinuswert von",x,"ist:",math.sin(x))
print("Der Cosinuswert von",x,"ist:",math.cos(x))
print("Der Tangenswert von",x,"ist:",math.tan(x))
print("Der Absolutwert von",x,"ist:",math.fabs(x))
print("Die nächste Ganzzahl <=",x,"ist:",math.floor(x))
print("Die nächste Ganzzahl >=",x,"ist:",math.ceil(x))

random: Einmal Würfeln

import random
wuerfel = random.randint(1,6)
print("Gewürfelt wurde",wuerfel)

Rouletteziehung

import random
msgDlg("Klicke OK, um die Ziehung zu starten")
zahl = random.randint(0,36)
if zahl == 0:
    print("Die Kugel ist auf die grüne Null gefallen.")
else:
    print("Die Kugel ist auf die Zahl",zahl,"gefallen.")

Entscheidungshilfe

import random
frage = input("Gib Deine Frage ein:")
antwort = random.randint(1,5)
print("Die Antwort lautet:")
if antwort == 1:
    print("Ja!")
elif antwort == 2:
    print("Nein!")
elif antwort == 3:
    print("Eher ja.")
elif antwort == 4:
    print("Eher nein.")
elif antwort == 5:
    print("Tut mir leid, das musst Du selbst entscheiden.")

Kapitel 10: Schleifen und Wiederholungen

Zähler 1 - 100 mit repeat

zaehler = 1
repeat 100:
    print(zaehler)
    zaehler = zaehler + 1

100 x würfeln

import random
repeat 100:
    wuerfel = random.randint(1,6)
    print(wuerfel)

Würfeln mit Durchschnittsberechnung

import random
anzahl = input("Wie oft soll gewürfelt werden?")
summe = 0
repeat anzahl:
    wuerfel = random.randint(1,6)
    print(wuerfel)
    summe = summe + wuerfel
print("Der Durchschnitt ist:" , summe / anzahl)

Verschachteln: 10 x 1000 x Würfeln

import random
repeat 10:
    summe = 0
    repeat 1000:
        wuerfel = random.randint(1,6)
        summe = summe + wuerfel
    print("Der Durchschnitt ist:" , summe / 1000)

while-Schleife 1

x = 0
while x < 10:
    x = input("Gib eine Zahl ein!")
print("Diese Zahl ist nicht kleiner als zehn.")

Würfelpoker

import random
summe = 0
weiter = "j"
wuerfel = 6
while (weiter == "j") and (wuerfel > 1):
    wuerfel = random.randint(1,6)
    if wuerfel > 1:
        summe = summe + wuerfel
    else:
        summe = 0
    print("Du hast eine",wuerfel,"gewürfelt.")
    print("Deine Punktzahl ist",summe)
    if wuerfel > 1:
        weiter = input("Weiterspielen? j/n")

Klassisches Zahlenraten

import random
zufallszahl = random.randint(1,100)
ratezahl = 0
while ratezahl != zufallszahl:
    ratezahl = input("Rate die Zahl:")
    if ratezahl > zufallszahl:
        print(ratezahl,"ist zu groß.")
    elif ratezahl < zufallszahl:
        print(ratezahl,"ist zu klein.")
print("Glückwunsch,",zufallszahl,"ist die richtige Zahl!")

Zahlenraten mit Zählung der Versuche

import random
zufallszahl = random.randint(1,100)
zaehler = 0
ratezahl = 0
while ratezahl != zufallszahl:
    ratezahl = input("Rate die Zahl:")
    zaehler = zaehler + 1
    if ratezahl > zufallszahl:
        print(ratezahl,"ist zu groß.")
    if ratezahl < zufallszahl:
        print(ratezahl,"ist zu klein.")
print("Glückwunsch,",zufallszahl,"ist die richtige Zahl!")
print("Du hast",zaehler,"Versuche gebraucht.")

Einmaleins-Trainer

import random
punkte = 0
fehler = 0
eingabe = 0
while (eingabe != "x"):
    zahl1 = random.randint(3,9)
    zahl2 = random.randint(3,9)
    loesung = zahl1 * zahl2
    print(zahl1,"x",zahl2)
    eingabe = input("Wie lautet die Lösung?")
    if eingabe != "x":
        if eingabe == loesung:
            print("Die Lösung ist richtig!")
            punkte = punkte + 1
        else:
            print("Leider falsch! Richtig wäre",loesung)
            fehler = fehler + 1
print("Ok.",punkte,"Punkte) und",fehler,"Fehler."

Einmaleins-Trainer, erweitert

import random
punkte = 0
fehler = 0
eingabe = 0

while (eingabe != "x"):
    zahl1 = random.randint(3,9)
    zahl2 = random.randint(3,9)
    loesung = zahl1 * zahl2
    aufgabe = str(zahl1) + " x " + str(zahl2) + " = "
    eingabe = input(aufgabe)
    if eingabe != "x":
        if eingabe == loesung:
            antwort = "Richtig! " + aufgabe + str(loesung)
            punkte = punkte + 1
        else:
            antwort = "Leider falsch! " + aufgabe + str(loesung)
            fehler = fehler + 1
        msgDlg(antwort)
auswertung = "Ok. "+str(punkte)+" Punkte und "+str(fehler)+" Fehler."
msgDlg(auswertung)

while mit break

while True:
    x = input("Gib eine Zahl ein, oder 0 für Ende.")
    if x == 0:
        break
    print("Das Doppelte Deiner Zahl ist:",x*2)

while mit continue

x = 0
while x < 21:
    x += 1
    if x == 13:
        continue
    print(x)

Primzahltester

x = input("Gib eine Zahl ein")
teiler = 2
primzahl = True
while (teiler < x) and (primzahl):
    if (x % teiler) == 0:
        primzahl = False
    else:
        teiler = teiler + 1
if primzahl:
    print(x , "ist eine Primzahl.")
else:
    print(x , "ist keine Primzahl. Teiler:" , teiler)

Primzahlenliste

x = 2
repeat 999:
    teiler = 2
    primzahl = True
    maximum = x ** 0.5
    while (teiler <= maximum) and (primzahl):
        if (x % teiler) == 0:
            primzahl = False
        else:
            teiler = teiler +1
    if primzahl:
        print(x)
    x = x + 1

Reiskörner berechnen

menge = 1
summe = 0
repeat 64:
    summe = summe + menge
    menge = menge * 2
print("Anzahl der Reiskörner insgesamt:" , summe)

Zinseszins berechnen

geld = 100
repeat 100:
    geld = geld * 1.05
print("Nach hundert Jahren sind",geld,"Euro angesammelt.")

Kapitel 11: Mit Listen arbeiten

Primzahlenliste

primliste  =  [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
x = input("Gib eine Zahl unter 50 ein")
if x in primliste:
    print(x,"ist eine Primzahl.")
else:
    print(x,"ist keine Prinzahl.")

Gemischte Liste

gemischt = [7,2.55,-25,"Hallo","*",5*3]
gemischt[0] = "Neu"
print(gemischt)

Wochentagsausgabe

import datetime
tage = ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"]
wochentag = datetime.datetime.today().weekday()
print("Heute ist",tage[wochentag])

20 Würfelzahlen als Liste

import random
zahlenliste = []
repeat 20:
    zahl = random.randint(1,6)
    zahlenliste.append(zahl)
print(zahlenliste)

Würfeln mit Auswerten der Liste

import random
zahlenliste = []
repeat 120:
    zahl = random.randint(1,6)
    zahlenliste.append(zahl)
for wzahl in range (1,7):
    print(wzahl, ":" , zahlenliste.count(wzahl))

100.000 Würfe auswerten

import random
anzahlen = [0,0,0,0,0,0]
repeat 100000:
    zahl = random.randint(1,6)
    anzahlen[zahl-1] = anzahlen[zahl-1] + 1
for z in range(6):
    print(z+1,":",anzahlen[z])

Lottotipp Methode 1 (Ziehen und Prüfen)

import random
lottotipp = []
repeat 6:
    zahl = random.randint(1,49)
    while zahl in lottotipp:
        zahl = random.randint(1,49)
    lottotipp.append(zahl)
print(lottotipp)

Lottotipp Methode 2 (Ziehen und Löschen)

import random
gesamtliste = list(range(1,50))
lottotipp = []
repeat 6:
    zahl = random.randint(1,len(gesamtliste))
    lottotipp.append(gesamtliste[zahl-1])
    del(gesamtliste[zahl-1])
print(lottotipp)

Lottotipp Methode 3 (Liste mischen)

import random
gesamtliste = list(range(1,50))
random.shuffle(gesamtliste)
lottotipp = gesamtliste[0:6]
print(lottotipp)

Lottotipp Methode 4 (sample-Funktion verwenden)

import random
lottotipp = random.sample(range(1,50),6)
print(lottotipp)

Sortierter Lottotipp

import random
lottotipp = random.sample(range(1,50),6)
lottotipp.sort()
print(lottotipp)

Lotto: Eigenen Tipp abgeben

import random
meinTipp = []
repeat 6:
    t = input("Gib eine Tippzahl ein:")
    meinTipp.append(t)
allezahlen = range(1,50)
ziehung = random.sample(allezahlen,6)
meinTipp.sort()
ziehung.sort()
print(meinTipp)
print(ziehung)

richtige = 0
for z in meinTipp:
    if z in ziehung:
        richtige = richtige + 1
print("Richtig getippte Zahlen:",richtige)

Lotto: Tippen und 100 Ziehungen

import random
meinTipp = []
repeat 6:
    t = input("Gib eine Tippzahl ein:")
    meinTipp.append(t)
allezahlen = range(1,50)
ziehung = random.sample(allezahlen,6)
meinTipp.sort()
ziehung.sort()
print(meinTipp)
print(ziehung)

richtige = 0
for z in meinTipp:
    if z in ziehung:
        richtige = richtige + 1
print("Richtig getippte Zahlen:",richtige)

Lotto: Simulation mit Gewinnauswertung

import random
meinTipp = []
anz = input("Wie viele Ziehungen möchtest Du?")
gewinne = [0,0,0,0,0,0,0]
repeat 6:
    t = input("Gib eine Tippzahl ein:")
    meinTipp.append(t)
meinTipp.sort()
allezahlen = range(1,50)
repeat anz:
    ziehung = random.sample(allezahlen,6)
    ziehung.sort()
    richtige = 0
    for z in meinTipp:
        if z in ziehung:
            richtige = richtige + 1
    if richtige > 2:
        gewinne[richtige] += 1
print("Auswertung - ",anz,"Ziehungen, Einsatz ",anz,"Euro:")
print("Drei Richtige:",gewinne[3]," Geldgewinn:",gewinne[3]*10,"Euro")
print("Vier Richtige:",gewinne[4]," Geldgewinn:",gewinne[4]*45,"Euro")
print("Fünf Richtige:",gewinne[5]," Geldgewinn:",gewinne[5]*4000,"Euro")
print("Sechs Richtige:",gewinne[6]," Geldgewinn:",gewinne[6]*800000,"Euro")

Simpler Vokabeltrainer - verschachtelte Listen

vokabeln = [["Tisch","table"],["Auto","car"],["Haus","house"]]
for vok in vokabeln:
    eingabe = input("Wie heißt "+vok[0]+" auf Englisch?")
    if eingabe == vok[1]:
        msgDlg ("Richtig!")
    else:
        msgDlg ("Leider falsch!")

Erweiterter Vokabeltrainer

import random
vokabeln = [["Tisch","table"],["Auto","car"],["Haus","house"]]
random.shuffle(vokabeln)
richtig = 0
falsch = 0
for vok in vokabeln:
    eingabe = input("Wie heißt "+vok[0]+" auf Englisch?")
    if eingabe == vok[1]:
        msgDlg("Richtig!")
        richtig = richtig + 1
    else:
        msgDlg("Leider falsch!")
        falsch = falsch + 1
print("Richtige Antworten:",richtig," - falsche Antworten:",falsch)

Kapitel 12: Die Schildkröte

Turtle-Grafik: Erste Linie

from gturtle import *
makeTurtle("gray")
forward(100)

Vorwärts und zurück

from gturtle import *
makeTurtle("gray")
forward(100)
back(100)

Quadrat zeichnen

from gturtle import *
makeTurtle("gray")
forward(100)
right(90)
forward(100)
right(90)
forward(100)
right(90)
forward(100)
right(90)

Quadrat mit repeat-Schleife

from gturtle import *
makeTurtle("gray")
repeat 4:
    forward(100)
    right(90)

Rechteckspirale zeichnen

from gturtle import *
makeTurtle("gray")
weite = 10
repeat 50:
    forward(weite)
    right(90)
    weite = weite + 10

Dreieck zeichnen

from gturtle import *
makeTurtle("gray")
repeat 3:
    forward(200)
    right(120)

Sechseck zeichnen

from gturtle import *
makeTurtle("gray")
repeat 6:
    forward(100)
    right(60)

n-Eck zeichnen

from gturtle import *
makeTurtle("gray")
ecken = input("Wie viele Ecken?")
weite = 600 / ecken
repeat ecken:
    forward(weite)
    right(360 / ecken)

Gestrichelter "Kreis"

from gturtle import *
makeTurtle("gray")
repeat 30:
    penDown()
    forward(10)
    right(6)
    penUp()
    forward(10)
    right(6)

Farbe wechseln

from gturtle import *
makeTurtle("grey")
setLineWidth(3)
setPenColor("red")
right(45)
forward(40)
dot(25)
setPenColor("blue")
forward(40)
dot(25)
setPenColor("green")
forward(40)
dot(25)

Farbwechsel mit Liste

from gturtle import *
farben = ["black", "blue", "red", "yellow", "green", "brown", "pink", "purple", "orange", "gray"]
makeTurtle("gray")
setLineWidth(3)
right(45)
for f in farben:
    setPenColor(f)
    forward(40)
    dot(25)

Koordinatenkreuz mit Positionen zeichnen

from gturtle import *
makeTurtle()
hideTurtle()
setPenColor("black")
setPos(-400,0)
moveTo(400,0)
setPos(0,-300)
moveTo(0,300)

Positionen in Liste

from gturtle import *
makeTurtle("grey")
setPos(-100,-200)
figur = [ [100,0],[-100,0],[100,-200],[-100,-200],[-100,0],[0,150],[100,0],[100,-200] ]
for koord in figur:
    moveTo(koord[0],koord[1])

Sinuskurve zeichnen

from gturtle import *
from math import sin
makeTurtle()
hideTurtle()
# Koordinatenkreuz zeichnen:
setPenColor("black")
setPos(-400,0)
moveTo(400,0)
setPos(0,-300)
moveTo(0,300)
# Sinuskurve zeichnen:
showTurtle()
setPenColor("blue")
setLineWidth(2)
speed(1000)
breite = 50
hoehe = 200
setPos(-400,sin(-400/breite)*hoehe)
for x in range(-400,401):
    moveTo(x,sin(x/breite)*hoehe)

Zufallsverteilung in Bildpunkten

from gturtle import *
from random import randint
makeTurtle()
hideTurtle()
setPenColor("black")
repeat 1000:
    x = randint(-400,400)
    y = randint(-300,300)
    setPos(x,y)
    dot(3)

Zufallsfarben und Kreise

from gturtle import *
from random import randint
farben = ["black", "blue", "red", "yellow", "green", "brown", "pink", "purple", "orange", "gray"]
makeTurtle()
hideTurtle()
repeat 3000:
    setPenColor(farben[randint(0,9)])
    x = randint(-400,400)
    y = randint (-300,300)
    setPos (x,y)
    dot(randint(1,30))

Zufallsmuster mit eingebauten Funktionen

from gturtle import *
makeTurtle()
hideTurtle()
repeat 3000:
    setPenColor(getRandomX11Color())
    setRandomPos(800, 600)
    dot(20)

Kapitel 13: Funktionen selber schreiben

Funktion "verdoppeln"

def verdoppeln(wert):
    doppelwert = wert*2
    return doppelwert

x = input("Bitte Wert eingeben")
msgDlg(verdoppeln(x))

Funktion "summe"

def summe(wert1,wert2):
    zusammen = wert1+wert2
    return zusammen

x = input("Bitte Wert 1 eingeben")
y = input("Bitte Wert 2 eingeben")
msgDlg(summe(x,y))

Warnfunktion

def warnung():
    msgDlg("Achtung, hier ist ein falscher Wert eingegeben worden!")

x = input("Bitte Zahl unter 10 eingeben")
if x<10:
    print "Danke"
else:
    warnung()

Funktion "zahlwort"

def zahlwort(zahl):
    einer = ["null", "ein", "zwei", "drei", "vier", u"fünf", "sechs", "sieben", "acht", "neun", "zehn", "elf", u"zwölf", "dreizehn", "vierzehn", u"fünfzehn", "sechzehn", "siebzehn", "achtzehn", "neunzehn"]
    zehner = ["null", "zehn", "zwanzig", u"dreißig", "vierzig", u"fünfzig", "sechzig", "siebzig", "achtzig", "neunzig", "hundert"]

    if zahl < 20:
        wort = einer[zahl]
        if zahl == 1:
            wort = "eins"
    else:
        z = zahl // 10
        e = zahl % 10
        wort = einer[e]+"und"+zehner[z]
        if e == 0:
            wort = zehner[z]
    return wort

x = input("Zahl:")
msgDlg(str(x)+" ist in Worten: "+zahlwort(x))

Funktion für Turtle-Grafik: Quadrat

def quadrat(laenge):
    repeat 4:
        forward(laenge)
        right(90)
from gturtle import *
makeTurtle()
quadrat(100)

Funktion für Turtle-Grafik: Dreieck

def dreieck(laenge):
    repeat 3:
        forward(laenge)
        right(120)
from gturtle import *
makeTurtle()
dreieck(100)

Turtlegrafik: Vieleckfunktion - zufällige Figuren

from gturtle import *
from random import randint
def vieleck(ecken,laenge):
    winkel = 360/ecken
    repeat ecken:
        forward(laenge)
        right(winkel)
makeTurtle()
hideTurtle()
penWidth(3)
repeat 100:
   setPenColor(getRandomX11Color()) # Zufallsfarbe setzen
   setRandomHeading() # zufällige Startrichtung setzen
   setRandomPos(800, 600) # zufällige Startposition setzen
   laenge = randint(10,100)  # zufällige Kantenlänge setzen
   ecken = randint(3,7)  # zufällige Anzahl Ecken
   vieleck(ecken,laenge)

Rekursive Funktion: Endlosrekursion

def rekursiv(x):
    print(x)
    rekursiv(x+1)
rekursiv(1)

Rekursiver Zähler

def rekursiv(x):
    print(x)
    if x<100:
        rekursiv(x+1)
rekursiv(1)

Rekursive Fakultätsberechnung

def fakultaet(x):
    if x == 1:
        return 1
    else:
        return (x * fakultaet(x-1))
f = input("Zahl eingeben:")
print("Die Fakultät von",f,"ist",fakultaet(f))

Kapitel 14: Sound programmieren

wav-Klang abspielen

from soundsystem import *
openSoundPlayer("wav/bird.wav")
play()

Einfache Tonfolge

playTone("cdefgfedc",200, instrument="harp")

Melodie erzeugen

playTone([("cdeccdecef",300),("g",600),("ef",300),("g",600)], instrument = "harp")

Erweiterte Melodie erzeugen

playTone([("cdeccdecef",300),("g",600),("ef",300),("g",600),("gagf",150),("ec",300),("gagf",150),("ec",300),("cG",300),("c",600),("cG",300),("c",600)], instrument = "harp")

Melodie bei Spielgewinn

print("Du hast gewonnen!")
playTone ("cegc'",100,instrument="harp")

Text-to-Speech verwenden

Achtung: Sollte es bei den folgenden drei Programmen, die Text-To-Speech verwenden, unerwartete Fehlermeldungen geben, schauen Sie bitte auf der Seite letscode-python.de unter Ergänzungen und Korrekturen, um Abhilfe zu schaffen!

from soundsystem import *
initTTS() # Text To Speech starten
selectVoice("german-man") # Stimme wählen
voice = generateVoice("Hallo, ich kann sprechen!")
openSoundPlayer(voice)
play()

Berechnung mit Sprachausgabe

from soundsystem import *
initTTS()
selectVoice("german-man")

x = input("Gib eine Zahl ein:")
y = input("Jetzt die zweite:")
rechnung = str(x)+" plus "+str(y)+" = "+str(x+y)

voice = generateVoice(rechnung)
openSoundPlayer(voice)
play()

Zahlenraten mit Sprachausgabe

import random
from soundsystem import *
initTTS()
selectVoice("german-man")
zufallszahl = random.randint(1,100)
eingabe = 0
while eingabe != zufallszahl:
    eingabe = input("Rate die Zahl:")
    if eingabe > zufallszahl:
        voice = generateVoice(str(eingabe)+" ist zu groß.")
    if eingabe < zufallszahl:
        voice = generateVoice(str(eingabe)+" ist zu klein.")
    openSoundPlayer(voice)
    play()
voice = generateVoice("Glückwunsch, "+str(eingabe)+" ist die richtige Zahl!")
openSoundPlayer(voice)
play()

Kapitel 16: Eigene Objekte definieren

Eigene Klasse "Toaster"

class Toaster:
    def __init__(self,schaechte,farbe):
        self.schaechte = schaechte
        self.farbe = farbe
        self.anzahl_toasts = 0
        self.brot_zustand = 0
        self.toast_zeit = 10


    def toastReintun(self,anzahl):
        if (self.anzahl_toasts + anzahl) > self.schaechte:
            return "Es ist nicht mehr genügend Platz dafür!"
        else:
            self.anzahl_toasts += anzahl
            return (str(anzahl)+" Toasts reingetan.")

    def __str__(self):
        antwort = "Das Objekt ist ein Toaster. "
        antwort += "Die Farbe ist "+self.Farbe+". "
        antwort += "Er hat "+str(self.Schaechte)+" Schächte. "
        antwort += "Im Moment sind "+str(self.anzahl_toasts)+" Toasts drin. "
        return antwort

    def toasten(self):
            if self.anzahl_toasts > 0:
                   zeit = self.toast_zeit
                   if zeit<=15:
                        self.brot_zustand +=1
                   if zeit >15:
                        self.brot_zustand +=2
                   if self.brot_zustand >3:
                        self.brot_zustand = 3
                zustand = ["ungetoastet", "leicht getoastet", "stark getoastet","verbrannt"]
                   return (str(zeit)+" Sekunden vergangen, Toasten erledigt, das Brot ist "+zustand[self.brot_zustand])
            else:
                   return ("Kein Toast im Toaster!")

    def toastAuswerfen(self):
         zustand = ["ungetoastet", "leicht getoastet", "stark getoastet","verbrannt"]
        info = str(self.anzahl_toasts)+" mal Toast ausgeworfen. Zustand: "+self.zustand[self.brot_zustand]
        self.anzahl_toasts = 0
        self.brot_zustand = 0
        return info

Kapitel 17: gamegrid - Spiele bauen mit Objekten

gamegrid: Spielfeld erzeugen

from gamegrid import *
feld = GameGrid(400,400)
feld.show()

Spielfeld mit Eigenschaften

from gamegrid import *
feld = GameGrid(400,400)
feld.setBgColor(255,255,255)
feld.setTitle("Mein Spielfeld")
feld.show()

Spielfeld mit beweglichem Actor (Spielfigur)

from gamegrid import *
feld = GameGrid(600,600,1,None,"sprites/reef.gif",False)
feld.setTitle("Korallenriff")
fisch = Actor("sprites/babelfish.gif")
feld.addActor(fisch,Location(300,300))
feld.show()
repeat:
    fisch.move(1)
    feld.refresh()
    delay(20)
    if fisch.getX() > 630:
        fisch.setX(-30)

Eigene Methode "schwimmen"

from gamegrid import *
feld = GameGrid(600,600,1,None,"sprites/reef.gif",False)
feld.setTitle("Korallenriff")
class Fisch(Actor):
    def schwimmen(self):
         self.move(1)
         if self.getX() > 630:
            self.setX(-30)

fisch = Fisch("sprites/babelfish.gif")
repeat:
    fisch.schwimmen()
    feld.refresh()
    delay(20)

Zwei Fische - eine Methode

from gamegrid import *
feld = GameGrid(600,600,1,None,"sprites/reef.gif",False)
feld.setTitle("Korallenriff")
class Fisch(Actor):
    def schwimmen(self):
         self.move(1)
         if self.getX() > 630:
            self.setX(-30)
fisch = Fisch("sprites/babelfish.gif")
feld.addActor(fisch,Location(200,200))
fisch2 = Fisch("sprites/babelfish.gif")
feld.addActor(fisch2,Location(300,300))
feld.show()
repeat:
    fisch.schwimmen()
    fisch2.schwimmen()
    feld.refresh()
    delay(20)

Bewegung der Objekte durch act()- und doRun()-Methode

from gamegrid import *
class Fisch(Actor):
    def act(self):
         self.move(1)
         if self.getX() > 630:
            self.setX(-30)

feld = GameGrid(600,600,1,None,"sprites/reef.gif",False)
feld.setTitle("Korallenriff")
fisch = Fisch("sprites/babelfish.gif")
feld.addActor(fisch,Location(300,300))
feld.setSimulationPeriod(20)
feld.show()
feld.doRun()

10 Fische bewegen sich im Wasser

from gamegrid import *
class Fisch(Actor):
    def act(self):
         self.move(1)
         if self.getX() > 630:
            self.setX(-30)

feld = GameGrid(600,600,1,None,"sprites/reef.gif",False)
feld.setTitle("Korallenriff")
x = 50
y = 50
repeat 10:
    fisch = Fisch("sprites/babelfish.gif")
    feld.addActor(fisch,Location(x,y))
    x += 50
    y += 50

feld.setSimulationPeriod(20)
feld.show()
feld.doRun()

10 Fische mit unterschiedlichen Geschwindigkeiten

from gamegrid import *
from random import randint

class Fisch(Actor):
    speed = 1
    def act(self):
         self.move(self.speed)
         if self.getX() > 630:
            self.setX(-30)

feld = GameGrid(600,600,1,None,"sprites/reef.gif",False)
feld.setTitle("Korallenriff")

x = 50
y = 50
repeat 10:
    fisch = Fisch("sprites/babelfish.gif")
    fisch.speed = randint(1,5)
    feld.addActor(fisch,Location(x,y))
    x += 50
    y += 50

feld.setSimulationPeriod(20)
feld.show()
feld.doRun()

Kapitel 18: Steuerung und Ereignisse in gamegrid

Krebsspiel: Der Grundaufbau

from gamegrid import *

class Krebs(Actor):
    pass

feld = GameGrid(800,600)
feld.setTitle("Krebsspiel")
feld.setBgColor(255,255,255)
krebs = Krebs("sprites/crab.png")
feld.addActor(krebs,Location(400,550))
feld.show()

Krebsspiel: Tastaturcodes auslesen und anzeigen

from gamegrid import *

class Krebs(Actor):
    pass
def tasteGedrueckt(tastencode):
        print tastencode
feld = GameGrid(800,600)
feld.setTitle("Krebsspiel")
feld.setBgColor(255,255,255)
krebs = Krebs("sprites/crab.png")
feld.addActor(krebs,Location(400,550))
feld.addKeyRepeatListener(tasteGedrueckt)
feld.show()

Krebs mit der Tastatur steuern

from gamegrid import *
class Krebs(Actor):
    pass
def tasteGedrueckt(tastencode):
    xpos = krebs.getX()
    if tastencode == 37:
         krebs.setX(xpos - 5)
    elif tastencode == 39:
          krebs.setX(xpos + 5)
    feld.refresh()

feld = GameGrid(800,600)
feld.setTitle("Krebsspiel")
feld.setBgColor(255,255,255)
krebs = Krebs("sprites/crab.png")
feld.addActor(krebs,Location(400,550))
feld.addKeyRepeatListener(tasteGedrueckt)
feld.show()

Krebs und Luftblase

from gamegrid import *

class Krebs(Actor):
    pass

class Luftblase(Actor):
    def act(self):
        ypos = self.getY()+3
        self.setY(ypos)
        if ypos>600:
            self.setY(-10)

def tasteGedrueckt(tastencode):
        xpos = krebs.getX()
        if tastencode == 37:
            if xpos > 30:
                krebs.setX(xpos - 5)
        elif tastencode == 39:
            if xpos < 770:
                krebs.setX(xpos + 5)

feld = GameGrid(800,600)
feld.setTitle("Krebsspiel")
feld.setBgColor(255,255,255)
krebs = Actor("sprites/crab.png")
feld.addActor(krebs,Location(400,550))
blase = Luftblase("sprites/bubble1.png")
feld.addActor(blase,Location(400,-10))
feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
feld.show()
feld.doRun()

Kollision: Krebs und Luftblase

from gamegrid import *

class Krebs(Actor):
    def collide(self,actor1,actor2):
        feld.removeActor(actor2)
        return 0

class Luftblase(Actor):
    def act(self):
        ypos = self.getY()+3
        self.setY(ypos)
        if ypos>600:
            self.setY(-10)

def tasteGedrueckt(tastencode):
        xpos = krebs.getX()
        if tastencode == 37:
            if xpos > 30:
                krebs.setX(xpos - 5)
        elif tastencode == 39:
            if xpos < 770:
                krebs.setX(xpos + 5)

feld = GameGrid(800,600)
feld.setTitle("Krebsspiel")
feld.setBgColor(255,255,255)
krebs = Krebs("sprites/crab.png")
blase = Luftblase("sprites/bubble1.png")
krebs.addCollisionActor(blase)
feld.addActor(krebs,Location(400,550))
feld.addActor(blase,Location(400,-10))
feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
feld.show()
feld.doRun()

100 Luftblasen und 5 Giftblasen kommen ins Spiel

from gamegrid import *
from random import randint

class Krebs(Actor):
    def collide(self,actor1,actor2):
        feld.removeActor(actor2)
        return 0

class Luftblase(Actor):
    def act(self):
        ypos = self.getY()+3
        self.setY(ypos)
        if ypos>600:
            self.setY(-10)

class Giftblase(Actor):
    speed = 5
    def act(self):
        ypos = self.getY()+self.speed
        xpos = self.getX()+self.speed
        self.setY(ypos)
        self.setX(xpos)
        if ypos>600:
            self.setY(-10)
            self.setX(randint(-400,500))

def tasteGedrueckt(tastencode):
        xpos = krebs.getX()
        if tastencode == 37:
            if xpos > 30:
                krebs.setX(xpos - 5)
        elif tastencode == 39:
            if xpos < 770:
                krebs.setX(xpos + 5)

feld = GameGrid(800,600)
feld.setTitle("Krebsspiel")
feld.setBgColor(255,255,255)
krebs = Krebs("sprites/crab.png")
repeat 100:
    blase = Luftblase("sprites/bubble1.png")
    blase.speed = randint(2,6)
    krebs.addCollisionActor(blase)
    feld.addActor(blase,Location(randint(30,770),randint(-570,-30)))
feld.addActor(krebs,Location(400,550))
repeat 5:
    gblase = Giftblase("sprites/peg_2.png")
    gblase.speed = randint(4,8)
    feld.addActor(gblase,Location(randint(-500,400),randint(-200,-20)))

feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
feld.show()
feld.doRun()

Das Krebsspiel bekommt Sound und Kollisionsereignisse

from gamegrid import *
from random import randint
from soundsystem import *

class Krebs(Actor):
    zaehler = 100
    def collide(self,actor1,actor2):
        if actor2.__class__.__name__ == "Luftblase":
            self.zaehler -= 1
            feld.removeActor(actor2)
            openSoundPlayer("wav/click.wav")
            play()
            if self.zaehler == 0:
                msgDlg("Hurra! Gewonnen! Alle Luftblasen erwischt!")
                feld.doPause()
        elif actor2.__class__.__name__ == "Giftblase":
            actor1.hide()
            feld.refresh()
            openSoundPlayer("wav/explode.wav")
            play()
            feld.doPause()
            msgDlg("Verloren. Blasen übrig: "+str(self.zaehler))
        return 0

class Luftblase(Actor):
    speed = 3
    def act(self):
        ypos = self.getY()+self.speed
        self.setY(ypos)
        if ypos>600:
            self.setY(-10)
            self.speed = randint(2,8)

class Giftblase(Actor):
    speed = 5
    def act(self):
        ypos = self.getY()+self.speed
        xpos = self.getX()+self.speed
        self.setY(ypos)
        self.setX(xpos)
        if ypos>600:
            self.setY(-10)
            self.setX(randint(-400,500))

def tasteGedrueckt(tastencode):
        xpos = krebs.getX()
        if tastencode == 37: # links
            if xpos > 30:
                krebs.setX(xpos - 5)
        elif tastencode == 39: # rechts
            if xpos < 770:
                krebs.setX(xpos + 5)

feld = GameGrid(800,600)
feld.setTitle("Krebsspiel")
feld.setBgColor(255,255,255)
krebs = Krebs("sprites/crab.png")
feld.addActor(krebs,Location(400,550))
repeat 100:
    blase = Luftblase("sprites/bubble1.png")
    blase.speed = randint(2,6)
    krebs.addCollisionActor(blase)
    feld.addActor(blase,Location(randint(30,770),randint(-570,-30)))
repeat 5:
    gblase = Giftblase("sprites/peg_2.png")
    gblase.speed = randint(4,8)
    krebs.addCollisionActor(gblase)
    feld.addActor(gblase,Location(randint(-500,400),randint(-200,-20)))

feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
feld.show()
feld.doRun()

Das Krebsspiel ist fertig (Basisversion)

from gamegrid import *
from random import randint
from soundsystem import *

class Krebs(Actor):
    zaehler = 100
    def collide(self,actor1,actor2):
        if actor2.__class__.__name__ == "Luftblase":
            self.zaehler -= 1
            feld.removeActor(actor2)
            openSoundPlayer("wav/click.wav")
            play()
            if self.zaehler == 0:
                msgDlg("Hurra! Gewonnen! Alle Luftblasen erwischt!")
                feld.doPause()
        elif actor2.__class__.__name__ == "Giftblase":
            actor1.hide()
            feld.refresh()
            openSoundPlayer("wav/explode.wav")
            play()
            feld.doPause()
            msgDlg("Verloren. Blasen übrig: "+str(self.zaehler))
        return 0

class Luftblase(Actor):
    speed = 3
    def act(self):
        ypos = self.getY()+self.speed
        self.setY(ypos)
        if ypos>600:
            self.setY(-10)
            self.speed = randint(2,8)

class Giftblase(Actor):
    speed = 5
    def act(self):
        ypos = self.getY()+self.speed
        xpos = self.getX()+self.speed
        self.setY(ypos)
        self.setX(xpos)
        if ypos>600:
            self.setY(-10)
            self.setX(randint(-400,500))

def tasteGedrueckt(tastencode):
        xpos = krebs.getX()
        if tastencode == 37: # links
            if xpos > 30:
                krebs.setX(xpos - 5)
        elif tastencode == 39: # rechts
            if xpos < 770:
                krebs.setX(xpos + 5)

feld = GameGrid(800,600)
feld.setTitle("Krebsspiel")
feld.setBgColor(255,255,255)
krebs = Krebs("sprites/crab.png")
repeat 100:
    blase = Luftblase("sprites/bubble1.png")
    blase.speed = randint(2,6)
    krebs.addCollisionActor(blase)
    feld.addActor(blase,Location(randint(30,770),randint(-570,-30)))
repeat 5:
    gblase = Giftblase("sprites/peg_2.png")
    gblase.speed = randint(4,8)
    krebs.addCollisionActor(gblase)
    feld.addActor(gblase,Location(randint(-500,400),randint(-200,-20)))
feld.addActor(krebs,Location(400,550))
feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
feld.show()
feld.doRun()

Krebsspiel mit Erweiterungen

from gamegrid import *
from random import randint
from soundsystem import *

class Krebs(Actor):
    zaehler = 100
    def collide(self,actor1,actor2):
        if actor2.__class__.__name__ == "Luftblase":
            self.zaehler -= 1
            feld.removeActor(actor2)
            openSoundPlayer("wav/click.wav")
            play()
            if self.zaehler == 0:
                msgDlg("Hurra! Gewonnen! Alle Luftblasen erwischt!")
                feld.doPause()
        elif actor2.__class__.__name__ == "Giftblase":
            actor1.hide()
            feld.refresh()
            openSoundPlayer("wav/explode.wav")
            play()
            feld.doPause()
            msgDlg("Verloren. Blasen übrig: "+str(self.zaehler))
        return 0

class Luftblase(Actor):
    speed = 3
    def act(self):
        ypos = self.getY()+self.speed
        self.setY(ypos)
        if ypos>600:
            self.setY(-10)
            self.speed = randint(2,8)

class Giftblase(Actor):
    speed = 5
    def act(self):
        ypos = self.getY()+self.speed
        xpos = self.getX()+self.speed
        self.setY(ypos)
        self.setX(xpos)
        if ypos>600:
            self.setY(-10)
            self.setX(randint(-400,500))

def tasteGedrueckt(tastencode):
        xpos = krebs.getX()
        ypos = krebs.getY()
        if tastencode == 37: # links
            if xpos > 30:
                krebs.setX(xpos - 5)
        elif tastencode == 39: # rechts
            if xpos < 770:
                krebs.setX(xpos + 5)
        elif tastencode == 38: # hoch
            if ypos > 30:
                krebs.setY(ypos - 5)
        elif tastencode == 40: # runter
            if ypos < 570:
                krebs.setY(ypos + 5)


feld = GameGrid(800,600)
feld.setTitle("Krebsspiel")
feld.setBgColor(255,255,255)
krebs = Krebs("sprites/crab.png")
repeat 100:
    blase = Luftblase("sprites/bubble1.png")
    blase.speed = randint(2,6)
    krebs.addCollisionActor(blase)
    feld.addActor(blase,Location(randint(30,770),randint(-570,-30)))
repeat 5:
    gblase = Giftblase("sprites/peg_2.png")
    gblase.speed = randint(4,8)
    krebs.addCollisionActor(gblase)
    feld.addActor(gblase,Location(randint(-500,400),randint(-200,-20)))
feld.addActor(krebs,Location(400,550))
feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
feld.show()
feld.doRun()

Kapitel 19: Breakball

Spielfeld mit Ball

from gamegrid import *
class Ball(Actor):
    pass
feld = GameGrid(800, 600)
feld.setTitle("BREAKBALL")
feld.setBgColor(Color.GRAY)
feld.setSimulationPeriod(20)
ball = Ball("sprites/evalpeg_1.png")
feld.addActor(ball, Location(400,300),45)
feld.show()
feld.doRun()

Ball fliegt und prallt an den Rändern ab

from gamegrid import *
class Ball(Actor):
    def act(self):
        richtung = self.getDirection()  # aktuelle Richtung des Balles
        if (self.getX() > 800) or (self.getX() < 20):
            # Richtung des Balls ändern, senkrechte Wand
            neue_richtung = 180-richtung
            self.setDirection(neue_richtung)
            self.move(5) # einen Extra-Schritt bewegen, von der Wand weg

        if (self.getY() > 600) or (self.getY() < 20):
            # Richtung des Balls ändern, waagerechte Wand
            neue_richtung = 360-richtung
            self.setDirection(neue_richtung)
            self.move(5) # Einen Extra-Schritt bewegen

        self.move(5) # die normale Bewegung des Balles in jedem Takt

feld = GameGrid(800, 600)
feld.setTitle("BREAKBALL")
feld.setBgColor(Color.GRAY)
feld.setSimulationPeriod(20)
ball = Ball("sprites/evalpeg_1.png")
feld.addActor(ball, Location(400,300),45)
feld.show()
feld.doRun()

Demo: 100 Bälle fliegen umher

from gamegrid import *
from random import *
class Ball(Actor):
    def act(self):
        richtung = self.getDirection()  # aktuelle Richtung des Balles
        if (self.getX() > 800) or (self.getX() < 20):
            # Richtung des Balls ändern, senkrechte Wand
            neue_richtung = 180-richtung
            self.setDirection(neue_richtung)
            self.move(5) # einen Extra-Schritt bewegen, von der Wand weg

        if (self.getY() > 600) or (self.getY() < 20):
            # Richtung des Balls ändern, waagerechte Wand
            neue_richtung = 360-richtung
            self.setDirection(neue_richtung)
            self.move(5) # Einen Extra-Schritt bewegen

        self.move(5) # die normale Bewegung des Balles in jedem Takt

feld = GameGrid(800, 600)
feld.setTitle("BREAKBALL")
feld.setBgColor(Color.GRAY)
feld.setSimulationPeriod(20)
repeat 100:
    ball = Ball("sprites/evalpeg_1.png")
    feld.addActor(ball, Location(randint(10,790),randint(10,590)),randint(0,359))
feld.show()
feld.doRun()

Ball und Brett, das steuerbar ist

from gamegrid import *
class Ball(Actor):
    def act(self):
        richtung = self.getDirection()  # aktuelle Richtung des Balles
        if (self.getX() > 800) or (self.getX() < 20):
            # Richtung des Balls ändern, senkrechte Wand
            neue_richtung = 180-richtung
            self.setDirection(neue_richtung)
            self.move(5) # einen Extra-Schritt bewegen, von der Wand weg

        if (self.getY() > 600) or (self.getY() < 20):
            # Richtung des Balls ändern, waagerechte Wand
            neue_richtung = 360-richtung
            self.setDirection(neue_richtung)
            self.move(5) # Einen Extra-Schritt bewegen

        self.move(5) # die normale Bewegung des Balles in jedem Takt

class Brett(Actor):
    pass

def tasteGedrueckt(tastencode):
        xpos = brett.getX()
        if tastencode == 37:  # nach links
            if xpos > 30:
                brett.setX(xpos - 5)
        elif tastencode == 39:  # nach rechts
            if xpos < 770:
                brett.setX(xpos + 5)


feld = GameGrid(800, 600)
feld.setTitle("BREAKBALL")
feld.setBgColor(Color.GRAY)
feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
ball = Ball("sprites/evalpeg_1.png")
feld.addActor(ball, Location(150,300),45)
brett = Brett("sprites/stick_1.gif")
feld.addActor(brett, Location(400,580))

feld.show()
feld.doRun()

Der Ball prallt auch vom Brett ab

from gamegrid import *
from random import *
class Ball(Actor):
    def act(self):
        richtung = self.getDirection()  # aktuelle Richtung des Balles
        if (self.getX() > 800) or (self.getX() < 20):
            # Richtung des Balls ändern, senkrechte Wand
            neue_richtung = 180-richtung
            self.setDirection(neue_richtung)
            self.move(5) # einen Extra-Schritt bewegen, von der Wand weg

        if (self.getY() > 600) or (self.getY() < 20):
            # Richtung des Balls ändern, waagerechte Wand
            neue_richtung = 360-richtung
            self.setDirection(neue_richtung)
            self.move(5) # Einen Extra-Schritt bewegen

        self.move(5) # die normale Bewegung des Balles in jedem Takt


class Brett(Actor):
    def collide(self,actor1,actor2):
        richtung = ball.getDirection()
        neue_richtung = 360-richtung+randint(-30,30)
        ball.setDirection(neue_richtung)
        ball.move(5)
        return 0

def tasteGedrueckt(tastencode):
        xpos = brett.getX()
        if tastencode == 37:  # nach links
            if xpos > 30:
                brett.setX(xpos - 5)
        elif tastencode == 39:  # nach rechts
            if xpos < 770:
                brett.setX(xpos + 5)


feld = GameGrid(800, 600)
feld.setTitle("BREAKBALL")
feld.setBgColor(Color.GRAY)
feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
ball = Ball("sprites/evalpeg_1.png")
feld.addActor(ball, Location(150,300),45)
brett = Brett("sprites/stick_1.gif")
brett.setCollisionRectangle(Point(0,20),100,2)
brett.addCollisionActor(ball)
feld.addActor(brett, Location(400,580))

feld.show()
feld.doRun()

Spiel zu Ende, wenn Ball den unteren Rand berührt

from gamegrid import *
from random import *
class Ball(Actor):
    def act(self):
        richtung = self.getDirection()
        if (self.getX() >= 800) or (self.getX() < 20):
            # Richtung des Balls ändern, linke/rechte Wand
            neue_richtung = 180-richtung
            self.setDirection(neue_richtung)
            self.move(5)

        if (self.getY() < 20):
            # Richtung des Balls ändern, obere Wand
            neue_richtung = 360-richtung
            self.setDirection(neue_richtung)
            self.move(5)

        if (self.getY() > 600):
            # Wenn Ball Unterkante berührt
            feld.doPause()
            msgDlg("GAME OVER")
        else:
            self.move(5)

class Brett(Actor):
    def collide(self,actor1,actor2):
        richtung = ball.getDirection()
        neue_richtung = 360-richtung+randint(-30,30)
        ball.setDirection(neue_richtung)
        ball.move(5)
        return 0

def tasteGedrueckt(tastencode):
        xpos = brett.getX()
        if tastencode == 37:  # nach links
            if xpos > 30:
                brett.setX(xpos - 5)
        elif tastencode == 39:  # nach rechts
            if xpos < 770:
                brett.setX(xpos + 5)


feld = GameGrid(800, 600)
feld.setTitle("BREAKBALL")
feld.setBgColor(Color.GRAY)
feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
ball = Ball("sprites/evalpeg_1.png")
feld.addActor(ball, Location(150,300),45)
brett = Brett("sprites/stick_1.gif")
brett.setCollisionRectangle(Point(0,20),100,2)
brett.addCollisionActor(ball)
feld.addActor(brett, Location(400,580))


feld.show()
feld.doRun()

Die Blöcke werden erstellt

from gamegrid import *
from random import *
class Ball(Actor):
    def act(self):
        richtung = self.getDirection()
        if (self.getX() >= 800) or (self.getX() < 20):
            # Richtung des Balls ändern, linke/rechte Wand
            neue_richtung = 180-richtung
            self.setDirection(neue_richtung)
            self.move(5)

        if (self.getY() < 20):
            # Richtung des Balls ändern, obere Wand
            neue_richtung = 360-richtung
            self.setDirection(neue_richtung)
            self.move(5)

        if (self.getY() > 600):
            # Wenn Ball Unterkante berührt
            feld.doPause()
            msgDlg("GAME OVER")
        else:
            self.move(5)

class Brett(Actor):
    def collide(self,actor1,actor2):
        richtung = ball.getDirection()
        neue_richtung = 360-richtung+randint(-30,30)
        ball.setDirection(neue_richtung)
        ball.move(5)
        return 0

class Block(Actor):
    pass


def tasteGedrueckt(tastencode):
        xpos = brett.getX()
        if tastencode == 37:  # nach links
            if xpos > 30:
                brett.setX(xpos - 5)
        elif tastencode == 39:  # nach rechts
            if xpos < 770:
                brett.setX(xpos + 5)


feld = GameGrid(800, 600)
feld.setTitle("BREAKBALL")
feld.setBgColor(Color.GRAY)
feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
ball = Ball("sprites/evalpeg_1.png")
feld.addActor(ball, Location(150,300),45)
brett = Brett("sprites/stick_1.gif")
brett.setCollisionRectangle(Point(0,20),100,2)
brett.addCollisionActor(ball)
feld.addActor(brett, Location(400,580))
for xpos in range(0,17):
    block = Block("sprites/seat_0.gif")
    feld.addActor(block, Location(xpos*42+60,100))
    block = Block("sprites/seat_1.gif")
    feld.addActor(block, Location(xpos*42+60,160))
    block = Block("sprites/seat_2.gif")
    feld.addActor(block, Location(xpos*42+60,220))

feld.show()
feld.doRun()

Die Blöcke verschwinden bei Kollision mit dem Ball

from gamegrid import *
from random import *
class Ball(Actor):
    def act(self):
        richtung = self.getDirection()
        if (self.getX() >= 800) or (self.getX() < 20):
            # Richtung des Balls ändern, linke/rechte Wand
            neue_richtung = 180-richtung
            self.setDirection(neue_richtung)
            self.move(5)

        if (self.getY() < 20):
            # Richtung des Balls ändern, obere Wand
            neue_richtung = 360-richtung
            self.setDirection(neue_richtung)
            self.move(5)

        if (self.getY() > 600):
            # Wenn Ball Unterkante berührt
            feld.doPause()
            msgDlg("GAME OVER")
        else:
            self.move(5)

class Brett(Actor):
    def collide(self,actor1,actor2):
        richtung = ball.getDirection()
        neue_richtung = 360-richtung+randint(-30,30)
        ball.setDirection(neue_richtung)
        ball.move(5)
        return 0

class Block(Actor):
        def __init__(self, path):
            Actor.__init__(self, path)
            self.addCollisionActor(ball)
        def collide(self,actor1,actor2):
            feld.removeActor(self)
            feld.refresh()
            richtung = ball.getDirection()
            neue_richtung = 360-richtung
            ball.setDirection(neue_richtung)
            return 0


def tasteGedrueckt(tastencode):
        xpos = brett.getX()
        if tastencode == 37:  # nach links
            if xpos > 30:
                brett.setX(xpos - 5)
        elif tastencode == 39:  # nach rechts
            if xpos < 770:
                brett.setX(xpos + 5)


feld = GameGrid(800, 600)
feld.setTitle("BREAKBALL")
feld.setBgColor(Color.GRAY)
feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
ball = Ball("sprites/evalpeg_1.png")
feld.addActor(ball, Location(150,300),45)
brett = Brett("sprites/stick_1.gif")
brett.setCollisionRectangle(Point(0,20),100,2)
brett.addCollisionActor(ball)
feld.addActor(brett, Location(400,580))
for xpos in range(0,17):
    block = Block("sprites/seat_0.gif")
    feld.addActor(block, Location(xpos*42+60,100))
    block = Block("sprites/seat_1.gif")
    feld.addActor(block, Location(xpos*42+60,160))
    block = Block("sprites/seat_2.gif")
    feld.addActor(block, Location(xpos*42+60,220))

feld.show()
feld.doRun()

Breakball: Fertiges Spiel (Basisversion)

from gamegrid import *
from random import *

class Ball(Actor):
    def act(self):
        richtung = self.getDirection()
        if (self.getX() >= 800) or (self.getX() < 20):
            # Richtung des Balls ändern
            neue_richtung = 180-richtung
            self.setDirection(neue_richtung)
            self.move(5)

        if (self.getY() < 20):
            #Richtung des Balls ändern
            neue_richtung = 360-richtung
            self.setDirection(neue_richtung)
            self.move(5)

        if (self.getY() > 600):
            feld.doPause()
            msgDlg("GAME OVER")
        else:
            self.move(5)

class Brett(Actor):
    def collide(self,actor1,actor2):
        richtung = ball.getDirection()
        neue_richtung = 360-richtung+randint(-30,30)
        ball.setDirection(neue_richtung)
        ball.move(5)
        return 0

class Block(Actor):
        def __init__(self, path):
            Actor.__init__(self, path)
            self.setCollisionRectangle(Point(10,10),30,30)
            self.addCollisionActor(ball)
        def collide(self,actor1,actor2):
            feld.removeActor(self)
            feld.refresh()
            richtung = ball.getDirection()
            neue_richtung = 360-richtung
            ball.setDirection(neue_richtung)
            if feld.getNumberOfActors(Block) == 0:
                feld.doPause()
                msgDlg("Das Spiel ist gewonnen!")
            return 0

def tasteGedrueckt(tastencode):
        xpos = brett.getX()
        if tastencode == 37:
            if xpos > 30:
                brett.setX(xpos - 5)
        elif tastencode == 39:
            if xpos < 770:
                brett.setX(xpos + 5)

feld = GameGrid(800, 600)
feld.setTitle("BREAKBALL")
feld.setBgColor(Color.GRAY)
feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
ball = Ball("sprites/evalpeg_1.png")
ball.setCollisionCircle(Point(0,0),10)
feld.addActor(ball, Location(150,300),45)

brett = Brett("sprites/stick_1.gif")
brett.setCollisionRectangle(Point(0,20),100,2)
brett.addCollisionActor(ball)
feld.addActor(brett, Location(400,580))

for xpos in range(0,17):
    block = Block("sprites/seat_0.gif")
    feld.addActor(block, Location(xpos*42+60,100))
    block = Block("sprites/seat_1.gif")
    feld.addActor(block, Location(xpos*42+60,160))
    block = Block("sprites/seat_2.gif")
    feld.addActor(block, Location(xpos*42+60,220))

feld.show()
feld.doRun()

Kapitel 20: Space Attack

Das Spielfeld

from gamegrid import *

feld = GameGrid(600,600,1,None,"sprites/town.jpg",False)
feld.setTitle("Space Attack")
feld.setSimulationPeriod(20)
feld.show()
feld.doRun()

Spielfeld mit Raumschiff

from gamegrid import *
class Raumschiff(Actor):
    pass
feld = GameGrid(600,600,1,None,"sprites/town.jpg",False)
feld.setTitle("Space Attack")
raumschiff = Raumschiff("sprites/spaceship.gif")
feld.addActor(raumschiff,Location(300,586))
feld.setSimulationPeriod(20)
feld.show()
feld.doRun()

Das Raumschiff ist steuerbar

from gamegrid import *
class Raumschiff(Actor):
    pass

def tasteGedrueckt(tastencode):
        xpos = raumschiff.getX()
        if tastencode == 37:
            if xpos > 20:
                raumschiff.setX(xpos - 5)
        elif tastencode == 39:
            if xpos < 580:
                raumschiff.setX(xpos + 5)

feld = GameGrid(600,600,1,None,"sprites/town.jpg",False)
feld.setTitle("Space Attack")
raumschiff = Raumschiff("sprites/spaceship.gif")
feld.addActor(raumschiff,Location(300,586))
feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
feld.show()
feld.doRun()

Das Raumschiff kann schießen

from gamegrid import *
class Raumschiff(Actor):
    timer = 0
    def act(self):
        self.timer -= 1

class Geschoss(Actor):
    def act(self):
        ypos = self.getY()
        self.setY(ypos-5)
        if ypos < 0:
            feld.removeActor(self)


def tasteGedrueckt(tastencode):
        xpos = raumschiff.getX()
        if tastencode == 37:
            if xpos > 20:
                raumschiff.setX(xpos - 5)
        elif tastencode == 39:
            if xpos < 580:
                raumschiff.setX(xpos + 5)
        elif tastencode == 32:
            schuss()

def schuss():
    if raumschiff.timer < 0:
        geschoss = Geschoss("sprites/bomb.gif")
        feld.addActor(geschoss,Location(raumschiff.getX(),590))
        raumschiff.timer = 10

feld = GameGrid(600,600,1,None,"sprites/town.jpg",False)
feld.setTitle("Space Attack")
raumschiff = Raumschiff("sprites/spaceship.gif")
feld.addActor(raumschiff,Location(300,586))
feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
feld.show()
feld.doRun()

Aliens kommen ins Spiel

from gamegrid import *
class Raumschiff(Actor):
    timer = 0
    def act(self):
        self.timer -= 1

class Geschoss(Actor):
    def act(self):
        ypos = self.getY()
        self.setY(ypos-5)
        if ypos < 0:
            feld.removeActor(self)

class Alien(Actor):
    ypos = 0
    def act(self):
        self.ypos += 0.1
        self.setY(int(self.ypos))

def tasteGedrueckt(tastencode):
        xpos = raumschiff.getX()
        if tastencode == 37:
            if xpos > 20:
                raumschiff.setX(xpos - 5)
        elif tastencode == 39:
            if xpos < 580:
                raumschiff.setX(xpos + 5)
        elif tastencode == 32:
            schuss()

def schuss():
    if raumschiff.timer < 0:
        geschoss = Geschoss("sprites/bomb.gif")
        feld.addActor(geschoss,Location(raumschiff.getX(),590))
        raumschiff.timer = 10

feld = GameGrid(600,600,1,None,"sprites/town.jpg",False)
feld.setTitle("Space Attack")
raumschiff = Raumschiff("sprites/spaceship.gif")
feld.addActor(raumschiff,Location(300,586))

for reihe in range (50,300,50):
    for spalte in range (40,570,40):
        alien = Alien("sprites/alien.png")
        alien.ypos = reihe
        feld.addActor(alien,Location(spalte,reihe))

feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
feld.show()
feld.doRun()

Aliens lassen sich abschießen

from gamegrid import *
class Raumschiff(Actor):
    timer = 0
    def act(self):
        self.timer -= 1

class Geschoss(Actor):
    def act(self):
        ypos = self.getY()
        self.setY(ypos-5)
        if ypos < 0:
            feld.removeActor(self)
    def collide(self,actor1,actor2):
        feld.removeActor(self)
        feld.removeActor(actor2)
        return 0


class Alien(Actor):
    ypos = 0
    def act(self):
        self.ypos += 0.1
        self.setY(int(self.ypos))

def tasteGedrueckt(tastencode):
        xpos = raumschiff.getX()
        if tastencode == 37:
            if xpos > 20:
                raumschiff.setX(xpos - 5)
        elif tastencode == 39:
            if xpos < 580:
                raumschiff.setX(xpos + 5)
        elif tastencode == 32:
            schuss()

def schuss():
    if raumschiff.timer < 0:
        geschoss = Geschoss("sprites/bomb.gif")
        alien_liste = feld.getActors(Alien)
        for a in alien_liste:
            geschoss.addCollisionActor(a)
        feld.addActor(geschoss,Location(raumschiff.getX(),590))
        raumschiff.timer = 10


feld = GameGrid(600,600,1,None,"sprites/town.jpg",False)
feld.setTitle("Space Attack")
raumschiff = Raumschiff("sprites/spaceship.gif")
feld.addActor(raumschiff,Location(300,586))

for reihe in range (50,300,50):
    for spalte in range (40,570,40):
        alien = Alien("sprites/alien.png")
        alien.ypos = reihe
        feld.addActor(alien,Location(spalte,reihe))

feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
feld.show()
feld.doRun()

Aliens werfen Bomben

from gamegrid import *
from random import *
class Raumschiff(Actor):
    timer = 0
    def act(self):
        self.timer -= 1

class Geschoss(Actor):
    def act(self):
        ypos = self.getY()
        self.setY(ypos-5)
        if ypos < 0:
            feld.removeActor(self)
    def collide(self,actor1,actor2):
        feld.removeActor(self)
        feld.removeActor(actor2)
        return 0


class Alien(Actor):
    ypos = 0
    def act(self):
        self.ypos += 0.1
        self.setY(int(self.ypos))
        if randint(1,1000) == 500:
            bombe = Bombe("sprites/creature_1.gif")
            feld.addActor(bombe, Location(self.getX(),self.getY()+10))


class Bombe(Actor):
    def act(self):
        ypos = self.getY()
        self.setY(ypos+5)
        if ypos>600:
            feld.removeActor(self)

def tasteGedrueckt(tastencode):
        xpos = raumschiff.getX()
        if tastencode == 37:
            if xpos > 20:
                raumschiff.setX(xpos - 5)
        elif tastencode == 39:
            if xpos < 580:
                raumschiff.setX(xpos + 5)
        elif tastencode == 32:
            schuss()

def schuss():
    if raumschiff.timer < 0:
        geschoss = Geschoss("sprites/bomb.gif")
        alien_liste = feld.getActors(Alien)
        for a in alien_liste:
            geschoss.addCollisionActor(a)
        feld.addActor(geschoss,Location(raumschiff.getX(),590))
        raumschiff.timer = 10


feld = GameGrid(600,600,1,None,"sprites/town.jpg",False)
feld.setTitle("Space Attack")
raumschiff = Raumschiff("sprites/spaceship.gif")
feld.addActor(raumschiff,Location(300,586))

for reihe in range (50,300,50):
    for spalte in range (40,570,40):
        alien = Alien("sprites/alien.png")
        alien.ypos = reihe
        feld.addActor(alien,Location(spalte,reihe))

feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
feld.show()
feld.doRun()

Bomben zerstören Raumschiff

from gamegrid import *
from random import *
class Raumschiff(Actor):
    timer = 0
    def act(self):
        self.timer -= 1

class Geschoss(Actor):
    def act(self):
        ypos = self.getY()
        self.setY(ypos-5)
        if ypos < 0:
            feld.removeActor(self)
    def collide(self,actor1,actor2):
        feld.removeActor(self)
        feld.removeActor(actor2)
        return 0


class Alien(Actor):
    ypos = 0
    def act(self):
        self.ypos += 0.1
        self.setY(int(self.ypos))
        if randint(1,1000) == 500:
            bombe = Bombe("sprites/creature_1.gif")
            bombe.addCollisionActor(raumschiff)
            feld.addActor(bombe, Location(self.getX(),self.getY()+10))


class Bombe(Actor):
    def act(self):
        ypos = self.getY()
        self.setY(ypos+5)
        if ypos>600:
            feld.removeActor(self)
    def collide(self,actor1,actor2):
            gameover()
            return 0


def tasteGedrueckt(tastencode):
        xpos = raumschiff.getX()
        if tastencode == 37:
            if xpos > 20:
                raumschiff.setX(xpos - 5)
        elif tastencode == 39:
            if xpos < 580:
                raumschiff.setX(xpos + 5)
        elif tastencode == 32:
            schuss()

def schuss():
    if raumschiff.timer < 0:
        geschoss = Geschoss("sprites/bomb.gif")
        alien_liste = feld.getActors(Alien)
        for a in alien_liste:
            geschoss.addCollisionActor(a)
        feld.addActor(geschoss,Location(raumschiff.getX(),590))
        raumschiff.timer = 10

def gameover():
    feld.doPause()
    msgDlg("GAME OVER")


feld = GameGrid(600,600,1,None,"sprites/town.jpg",False)
feld.setTitle("Space Attack")
raumschiff = Raumschiff("sprites/spaceship.gif")
feld.addActor(raumschiff,Location(300,586))

for reihe in range (50,300,50):
    for spalte in range (40,570,40):
        alien = Alien("sprites/alien.png")
        alien.ypos = reihe
        feld.addActor(alien,Location(spalte,reihe))

feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
feld.show()
feld.doRun()

Space-Attack: Fertiges Basisspiel

from gamegrid import *
from random import *
class Raumschiff(Actor):
    timer = 0
    def act(self):
        self.timer -= 1

class Geschoss(Actor):
    def act(self):
        ypos = self.getY()
        self.setY(ypos-5)
        if ypos < 0:
            feld.removeActor(self)
    def collide(self,actor1,actor2):
        feld.removeActor(self)
        feld.removeActor(actor2)
        if feld.getNumberOfActors(Alien) == 0:
            gewonnen()
        return 0


class Alien(Actor):
    ypos = 0
    def act(self):
        self.ypos += 0.1
        self.setY(int(self.ypos))
        if randint(1,1000) == 500:
            bombe = Bombe("sprites/creature_1.gif")
            bombe.addCollisionActor(raumschiff)
            feld.addActor(bombe, Location(self.getX(),self.getY()+10))


class Bombe(Actor):
    def act(self):
        ypos = self.getY()
        self.setY(ypos+5)
        if ypos>600:
            feld.removeActor(self)
    def collide(self,actor1,actor2):
            gameover()
            return 0


def tasteGedrueckt(tastencode):
        xpos = raumschiff.getX()
        if tastencode == 37:
            if xpos > 20:
                raumschiff.setX(xpos - 5)
        elif tastencode == 39:
            if xpos < 580:
                raumschiff.setX(xpos + 5)
        elif tastencode == 32:
            schuss()

def schuss():
    if raumschiff.timer < 0:
        geschoss = Geschoss("sprites/bomb.gif")
        alien_liste = feld.getActors(Alien)
        for a in alien_liste:
            geschoss.addCollisionActor(a)
        feld.addActor(geschoss,Location(raumschiff.getX(),590))
        raumschiff.timer = 10

def gameover():
    feld.doPause()
    msgDlg("GAME OVER")

def gewonnen():
    feld.refresh()
    feld.doPause()
    msgDlg("GEWONNEN!")


feld = GameGrid(600,600,1,None,"sprites/town.jpg",False)
feld.setTitle("Space Attack")
raumschiff = Raumschiff("sprites/spaceship.gif")
feld.addActor(raumschiff,Location(300,586))

for reihe in range (50,300,50):
    for spalte in range (40,570,40):
        alien = Alien("sprites/alien.png")
        alien.ypos = reihe
        feld.addActor(alien,Location(spalte,reihe))

feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
feld.show()
feld.doRun()

Space-Attack mit Erweiterungen: Explosion, Sound, Gameover-Schriftzug

from gamegrid import *
from random import *
from soundsystem import *
class Raumschiff(Actor):
    timer = 0
    def act(self):
        self.timer -= 1

class Geschoss(Actor):
    def act(self):
        ypos = self.getY()
        self.setY(ypos-5)
        if ypos < 0:
            feld.removeActor(self)
    def collide(self,actor1,actor2):
        xpos = actor2.getX()
        ypos = actor2.getY()
        feld.removeActor(self)
        feld.removeActor(actor2)
        hit = Explosion("sprites/hit.gif")
        feld.addActor(hit,Location(xpos,ypos))
        openSoundPlayer("wav/click.wav")
        play()
        if feld.getNumberOfActors(Alien) == 0:
            gewonnen()
        return 0

class Alien(Actor):
    ypos = 0
    def act(self):
        self.ypos += 0.1
        self.setY(int(self.ypos))
        if randint(1,1000) == 500:
            bombe = Bombe("sprites/creature_1.gif")
            bombe.addCollisionActor(raumschiff)
            feld.addActor(bombe, Location(self.getX(),self.getY()+10))


class Bombe(Actor):
    def act(self):
        ypos = self.getY()
        self.setY(ypos+5)
        if ypos>600:
            feld.removeActor(self)
    def collide(self,actor1,actor2):
            gameover()
            return 0

class Explosion(Actor):
    timer = 5
    def act(self):
        self.timer -= 1
        if self.timer == 0:
            feld.removeActor(self)

def tasteGedrueckt(tastencode):
        xpos = raumschiff.getX()
        if tastencode == 37:
            if xpos > 20:
                raumschiff.setX(xpos - 5)
        elif tastencode == 39:
            if xpos < 580:
                raumschiff.setX(xpos + 5)
        elif tastencode == 32:
            schuss()

def schuss():
    if raumschiff.timer < 0:
        geschoss = Geschoss("sprites/bomb.gif")
        alien_liste = feld.getActors(Alien)
        for a in alien_liste:
            geschoss.addCollisionActor(a)
        feld.addActor(geschoss,Location(raumschiff.getX(),590))
        raumschiff.timer = 10

def gameover():
    openSoundPlayer("wav/explode.wav")
    play()
    explosion = Explosion("sprites/explosion.gif")
    feld.addActor(explosion,Location(raumschiff.getX(),590))
    feld.removeActor(raumschiff)
    spielende = Actor("sprites/gameover.gif")
    feld.addActor(spielende,Location(300,300))
    feld.doPause()

def gewonnen():
    feld.refresh()
    feld.doPause()
    msgDlg("GEWONNEN!")


feld = GameGrid(600,600,1,None,"sprites/town.jpg",False)
feld.setTitle("Space Attack")
raumschiff = Raumschiff("sprites/spaceship.gif")
feld.addActor(raumschiff,Location(300,586))

for reihe in range (50,300,50):
    for spalte in range (40,570,40):
        alien = Alien("sprites/alien.png")
        alien.ypos = reihe
        feld.addActor(alien,Location(spalte,reihe))

feld.setSimulationPeriod(20)
feld.addKeyRepeatListener(tasteGedrueckt)
feld.show()
feld.doRun()

Kapitel 21: Flappy Ball

Flappy Ball: Das Spielfeld

from gamegrid import *
feld = GameGrid(800, 600)
feld.setTitle("Flappy Ball")
feld.setBgColor(Color.WHITE)
feld.setSimulationPeriod(20)
feld.show()
feld.doRun()

Spielfeld mit fallendem Ball

from gamegrid import *

class Ball(Actor):
    speed = 0.5

    def act(self):
        ypos = self.getY()
        ypos += self.speed
        self.setY(int(ypos))
        self.speed += 0.2

feld = GameGrid(800, 600)
feld.setTitle("Flappy Ball")
feld.setBgColor(Color.WHITE)
feld.setSimulationPeriod(20)
ball = Ball("sprites/peg_5.png")
feld.addActor(ball, Location (400,10))

feld.show()
feld.doRun()

Ball kann hochgekickt werden

from gamegrid import *

class Ball(Actor):
    speed = 0.5

    def act(self):
        ypos = self.getY()
        ypos += self.speed
        self.setY(int(ypos))
        self.speed += 0.2
    def hochkicken(self):
        self.speed = -4

def mausKlick(e):
    ball.hochkicken()
    return 0


feld = GameGrid(800, 600)
feld.setTitle("Flappy Ball")
feld.setBgColor(Color.WHITE)
feld.setSimulationPeriod(20)
ball = Ball("sprites/peg_5.png")
feld.addActor(ball, Location (400,10))
feld.addMouseListener(mausKlick,1)

feld.show()
feld.doRun()

Balken kommen ins Spiel

from gamegrid import *

class Ball(Actor):
    speed = 0.5

    def act(self):
        ypos = self.getY()
        ypos += self.speed
        self.setY(int(ypos))
        self.speed += 0.2
    def hochkicken(self):
        self.speed = -4

def mausKlick(e):
    ball.hochkicken()
    return 0


feld = GameGrid(800, 600)
feld.setTitle("Flappy Ball")
feld.setBgColor(Color.WHITE)
feld.setSimulationPeriod(20)
ball = Ball("sprites/peg_5.png")
feld.addActor(ball, Location (400,10))
feld.addMouseListener(mausKlick,1)

feld.show()
feld.doRun()

Flappy Ball: Fertige Basisversion

from gamegrid import *
from random import *

class Ball(Actor):
    speed = 0.5

    def act(self):
        ypos = self.getY()
        ypos += self.speed
        if ypos < 0 or ypos > 600:
            feld.refresh()
            spielEnde()
        self.setY(int(ypos))
        self.speed += 0.2

    def hochkicken(self):
        self.speed = -4

    def collide(self,actor1,actor2):
        spielEnde()
        return 0

class Balken(Actor):
    speed = 2
    def act(self):
        xpos = self.getX()
        self.setX(xpos-self.speed)
        if xpos < -10:
            self.setX(810)
            if randint(0,1) == 0:
                # Balken oben
                self.setY(randint(0,200))
            else:
                # Balken unten
                self.setY(randint(400,600))

def mausKlick(e):
    ball.hochkicken()
    return 0

def spielEnde():
    feld.doPause()
    msgDlg("GAME OVER")

feld = GameGrid(800, 600)
feld.setTitle("Flappy Ball")
feld.setBgColor(Color.WHITE)
feld.setSimulationPeriod(20)
feld.addMouseListener(mausKlick,1)

ball = Ball("sprites/peg_5.png")
ball.setCollisionCircle(Point(0,0),20)
feld.addActor(ball, Location (400,20))

for xpos in [810,1010,1210,1410]:
    balken = Balken("sprites/bar3.gif")
    feld.addActor(balken, Location (xpos,randint(400,500)))
    ball.addCollisionActor(balken)

feld.show()
feld.doRun()

Flappy Ball: Spiel mit Erweiterungen

from gamegrid import *
from random import *
from soundsystem import *

class Ball(Actor):
    speed = 0.5
    def act(self):
        ypos = self.getY()
        ypos += self.speed
        if ypos < 0 or ypos > 600:
            feld.refresh()
            spielEnde()
        self.setY(int(ypos))
        self.speed += 0.2
    def hochkicken(self):
        self.speed = -4
        openSoundPlayer("wav/boing.wav")
        play()
    def collide(self,actor1,actor2):
        spielEnde()
        return 0

class Balken(Actor):
    speed = 2
    def act(self):
        xpos = self.getX()
        self.setX(xpos-self.speed)
        if xpos < -10:
            self.setX(810)
            if randint(0,1) == 0:
                # Balken oben
                self.setY(randint(0,200))
            else:
                # Balken unten
                self.setY(randint(400,600))

def mausKlick(e):
    if feld.isRunning():
        ball.hochkicken()
    else:
        feld.doRun()
    return 0


def spielEnde():
    gameover = Actor("sprites/gameover.gif")
    feld.addActor(gameover,Location(400,300))
    openSoundPlayer("wav/explode.wav")
    play()
    feld.doPause()

feld = GameGrid(800, 600)
feld.setTitle("Flappy Ball")
feld.setBgColor(Color.WHITE)
feld.setSimulationPeriod(20)
feld.addMouseListener(mausKlick,1)

ball = Ball("sprites/peg_5.png")
ball.setCollisionCircle(Point(0,0),20)
feld.addActor(ball, Location (400,20))

for xpos in [810,1010,1210,1410]:
    balken = Balken("sprites/bar3.gif")
    feld.addActor(balken, Location (xpos,randint(400,500)))
    ball.addCollisionActor(balken)

feld.show()
feld.doRun()

Flappy Ball: Spiel mit Erweiterungen

from gamegrid import *
from random import *
from soundsystem import *

class Ball(Actor):
    speed = 0.5
    def act(self):
        ypos = self.getY()
        ypos += self.speed
        if ypos < 0 or ypos > 600:
            feld.refresh()
            spielEnde()
        self.setY(int(ypos))
        self.speed += 0.2
    def hochkicken(self):
        self.speed = -4
        openSoundPlayer("wav/boing.wav")
        play()
    def collide(self,actor1,actor2):
        spielEnde()
        return 0

class Balken(Actor):
    speed = 2
    def act(self):
        xpos = self.getX()
        self.setX(xpos-self.speed)
        if xpos < -10:
            self.setX(810)
            if randint(0,1) == 0:
                # Balken oben
                self.setY(randint(0,200))
            else:
                # Balken unten
                self.setY(randint(400,600))

def mausKlick(e):
    if feld.isRunning():
        ball.hochkicken()
    else:
        feld.doRun()
    return 0


def spielEnde():
    gameover = Actor("sprites/gameover.gif")
    feld.addActor(gameover,Location(400,300))
    openSoundPlayer("wav/explode.wav")
    play()
    feld.doPause()

feld = GameGrid(800, 600)
feld.setTitle("Flappy Ball")
feld.setBgColor(Color.WHITE)
feld.setSimulationPeriod(20)
feld.addMouseListener(mausKlick,1)

ball = Ball("sprites/peg_5.png")
ball.setCollisionCircle(Point(0,0),20)
feld.addActor(ball, Location (400,20))

for xpos in [810,1010,1210,1410]:
    balken = Balken("sprites/bar3.gif")
    feld.addActor(balken, Location (xpos,randint(400,500)))
    ball.addCollisionActor(balken)

feld.show()

Kapitel 22: Tic Tac Toe

Spielfeld mit Raster

from gamegrid import *
feld = GameGrid(3,3,100,Color.BLACK,False)
feld.setTitle("Tic Tac Toe")
feld.setBgColor(Color.WHITE)
feld.show()

Spielfeld mit Figuren

from gamegrid import *
feld = GameGrid(3,3,100,Color.BLACK,False)
feld.setTitle("Tic Tac Toe")
feld.setBgColor(Color.WHITE)
symbol = Actor("sprites/mark_0.gif")
feld.addActor(symbol,Location(1,1))
symbol = Actor("sprites/mark_1.gif")
feld.addActor(symbol,Location(2,2))
feld.show()

Tic Tac Toe - für zwei Spieler

from gamegrid import *

class Spielverwaltung(object):
    spielstand = [0,0,0,0,0,0,0,0,0]
    aktiver_spieler = 1

    def naechsterSpieler(self):
        if self.aktiver_spieler == 1:
            self.aktiver_spieler = 2
        else:
            self.aktiver_spieler = 1

    def zellePruefen(self,x,y):
        listenpos = y*3+x
        return self.spielstand[listenpos]

    def setzen(self,x,y,spielernr):
        symbol = Actor("sprites/mark_"+str(spielernr-1)+".gif")
        feld.addActor(symbol,Location(x,y))
        listenpos = y*3+x
        self.spielstand[listenpos] = spielernr

    def gewonnen(self,sn):
        liste = self.spielstand
        # waagerecht
        if (liste[0:3] == [sn,sn,sn]) or (liste[3:6] == [sn,sn,sn]) or (liste[6:9] == [sn,sn,sn]):
            return True
        # senkrecht
        for x in range(0,3):
            if (liste[x]==sn) and (liste[x+3] == sn) and (liste[x+6] == sn):
                return True
        # diagonal
        if (liste[0]==sn) and (liste[4] == sn) and (liste[8] == sn):
            return True
        if (liste[2]==sn) and (liste[4] == sn) and (liste[6] == sn):
            return True
        return False

    def brettVoll(self):
        return not (0 in self.spielstand)

def mausKlick(ereignis):
    # geklickte Zelle ermitteln:
    zellenPos = feld.toLocationInGrid(ereignis.getX(),ereignis.getY())
    zx = zellenPos.getX()  # gibt die x-Position der Zelle
    zy = zellenPos.getY()  # gibt die y-Position der Zelle
    # Wenn Zelle leer, dann weiter:
    if spiel.zellePruefen(zx,zy) == 0:
        spiel.setzen(zx,zy,spiel.aktiver_spieler)
        if spiel.gewonnen(spiel.aktiver_spieler):
            msgDlg("Spieler "+str(spiel.aktiver_spieler)+" hat gewonnen!")
        elif (spiel.brettVoll()):
            msgDlg("Das Spiel ist beendet: Unentschieden!")
        else:
            spiel.naechsterSpieler()

feld = GameGrid(3,3,100,Color.BLACK,False,mouseReleased=mausKlick)
feld.setTitle("Tic Tac Toe")
feld.setBgColor(Color.WHITE)
feld.show()

spiel = Spielverwaltung()

Tic Tac Toe - Computergegner, Zufallsmethode

from gamegrid import *
from random import *

class Spielverwaltung(object):
    spielstand = [0,0,0,0,0,0,0,0,0]
    aktiver_spieler = 1
    def naechsterSpieler(self):
        if self.aktiver_spieler == 1:
            self.aktiver_spieler = 2
        else:
            self.aktiver_spieler = 1
    def zellePruefen(self,x,y):
        listenpos = y*3+x
        return self.spielstand[listenpos]

    def setzen(self,x,y,spielernr):
        symbol = Actor("sprites/mark_"+str(spielernr-1)+".gif")
        feld.addActor(symbol,Location(x,y))
        listenpos = y*3+x
        self.spielstand[listenpos] = spielernr

    def gewonnen(self,sn):
        liste = self.spielstand
        # waagerecht
        if (liste[0:3] == [sn,sn,sn]) or (liste[3:6] == [sn,sn,sn]) or (liste[6:9] == [sn,sn,sn]):
            return True
        # senkrecht
        for x in range(0,3):
            if (liste[x]==sn) and (liste[x+3] == sn) and (liste[x+6] == sn):
                return True
        # diagonal
        if (liste[0]==sn) and (liste[4] == sn) and (liste[8] == sn):
            return True
        if (liste[2]==sn) and (liste[4] == sn) and (liste[6] == sn):
            return True
        return False
    def brettVoll(self):
        return not (0 in self.spielstand)
    def zufallsZug(self):
        leer = []
        for x in range(0,9):
            if self.spielstand[x] == 0:
                leer.append(x)
        return choice(leer)
    def nrSetzen(self,pos,spieler_nr):
        y = pos // 3
        x = pos % 3
        self.setzen(x,y,spieler_nr)


def mausKlick(ereignis):
    # geklickte Zelle ermitteln:
    zellenPos = feld.toLocationInGrid(ereignis.getX(),ereignis.getY())
    zx = zellenPos.getX()
    zy = zellenPos.getY()
    # Wenn Zelle leer, dann weiter:
    if spiel.zellePruefen(zx,zy) == 0:
        spiel.setzen(zx,zy,spiel.aktiver_spieler)
        if spiel.gewonnen(spiel.aktiver_spieler):
            msgDlg("Spieler "+str(spiel.aktiver_spieler)+" hat gewonnen!")
        elif (spiel.brettVoll()):
            msgDlg("Das Spiel ist beendet: Unentschieden!")
        else:
            spiel.naechsterSpieler()
            spiel.nrSetzen(spiel.zufallsZug(),spiel.aktiver_spieler)
            if spiel.gewonnen(spiel.aktiver_spieler):
                msgDlg("Der Computer hat gewonnen!")
            elif (spiel.brettVoll()):
                msgDlg("Das Spiel ist beendet: Unentschieden!")
            else:
                spiel.naechsterSpieler()


feld = GameGrid(3,3,100,Color.BLACK,False,mouseReleased=mausKlick)
feld.setTitle("Tic Tac Toe")
feld.setBgColor(Color.WHITE)
feld.show()

spiel = Spielverwaltung()

Tic Tac Toe - Computergegner, doppelte Überprüfung

from gamegrid import *
from random import *

class Spielverwaltung(object):
    spielstand = [0,0,0,0,0,0,0,0,0]
    aktiver_spieler = 1

    def naechsterSpieler(self):
        if self.aktiver_spieler == 1:
            self.aktiver_spieler = 2
        else:
            self.aktiver_spieler = 1

    def zellePruefen(self,x,y):
        listenpos = y*3+x
        return self.spielstand[listenpos]

    def setzen (self,x,y,spielernr):
        symbol = Actor("sprites/mark_"+str(spielernr-1)+".gif")
        feld.addActor(symbol,Location(x,y))
        listenpos = y*3+x
        self.spielstand[listenpos] = spielernr

    def gewonnen (self,sn):
        liste = self.spielstand
        g = False
        # waagerecht
        if (liste[0:3] == [sn,sn,sn]) or (liste[3:6] == [sn,sn,sn]) or (liste[6:9] == [sn,sn,sn]):
            g = True
        # senkrecht
        for x in range(0,3):
            if (liste[x]==sn) and (liste[x+3] == sn) and (liste[x+6] == sn):
                g = True
        # diagonal
        if (liste[0]==sn) and (liste[4] == sn) and (liste[8] == sn):
            g = True
        if (liste[2]==sn) and (liste[4] == sn) and (liste[6] == sn):
            g = True
        return g

    def brettVoll(self):
        return not (0 in self.spielstand)

    def zufallsZug(self):
        leer = []
        for x in range(0,9):
            if self.spielstand[x] == 0:
                leer.append(x)
        anzahl = len(leer)
        zufall = randint(0,anzahl-1)
        zelleNr = leer[zufall]
        return zelleNr

    def nrSetzen(self,pos,spielerNr):
        y = pos // 3
        x = pos % 3
        self.setzen(x,y,spielerNr)

    def computerZug(self):
        leer = []
        for x in range(0,9):
            if self.spielstand[x] == 0:
                leer.append(x)
        anzahl = len(leer)
        backup = self.spielstand[:]

        # Gewinnmöglichkeit checken
        for x in range(0,anzahl):
            self.spielstand = backup[:]
            self.spielstand[leer[x]] = 2
            if self.gewonnen(2):
                self.spielstand = backup[:]
                return leer[x]
        # Verliermöglichkeit verhindern
        for x in range(0,anzahl):
            self.spielstand = backup[:]
            self.spielstand[leer[x]] = 1
            if self.gewonnen(1):
                self.spielstand = backup[:]
                return leer[x]
        # Sonst: Zufallszug
        self.spielstand = backup[:]
        return self.zufallsZug()


def mausKlick(ereignis):
    # geklickte Zelle ermitteln:
    zellenPos = feld.toLocationInGrid(ereignis.getX(),ereignis.getY())
    zx = zellenPos.getX()
    zy = zellenPos.getY()
    # Wenn Zelle leer, dann weiter:
    if spiel.zellePruefen(zx,zy) == 0:
        spiel.setzen(zx,zy,spiel.aktiver_spieler)
        if spiel.gewonnen(spiel.aktiver_spieler):
            msgDlg("Der Spieler hat gegen den Computer gewonnen!")
        elif (spiel.brettVoll()):
            msgDlg("Das Spiel ist beendet: Unentschieden!")
        else:
            spiel.aktiver_spieler = 2
            delay(1000)
            spiel.nrSetzen(spiel.computerZug(),2)
            if spiel.gewonnen(spiel.aktiver_spieler):
                msgDlg("Der Computer hat gegen den Spieler gewonnen!")
            elif (spiel.brettVoll()):
                msgDlg("Das Spiel ist beendet: Unentschieden!")
            else:
                spiel.aktiver_spieler = 1


feld = GameGrid(3,3,100,Color.BLACK,False,mouseReleased=mausKlick)
feld.setBgColor(Color.WHITE)
feld.setTitle("Tic Tac Toe")
feld.show()
spiel = Spielverwaltung()