Die Spielsteuerung

Großartig! Jetzt fehlt eigentlich nur noch die Spielsteuerung – dann ist das Spiel grundlegend fertig.

Was muss die Spielsteuerung leisten?

Vor allem muss sie erkennen, wann alle Blöcke gelöscht worden sind. Dann ist das Spiel gewonnen. Wenn der Ball verlorengeht, ist das Spiel ja ohnehin schon beendet – dieser Teil ist bereits programmiert. Aber du könntest das auch noch erweitern, indem du mehrere Leben ermöglichst, in diesem Fall mehrere Bälle.

Erst einmal muss das Spiel aber gewinnbar sein. Du musst also ermitteln, ob das Spiel gewonnen wurde. Dazu brauchst du die Anzahl der noch vorhandenen Blöcke. Wenn die Anzahl 0 ist, ist das Spiel gewonnen.

Die Anzahl der vorhandenen Blöcke ermittelst du mit:

feld.getNumberOfActors(Block)

Wo wird denn nun geprüft, ob das Spiel zu Ende ist – also ob »feld.getNumberOfActors(Block)« gleich 0 ist?

Das kann an zahlreichen Stellen geschehen. Es ist eine Frage des Geschmacks und der Übersichtlichkeit.

Irgendwo muss einfach diese Abfrage hin:

if feld.getNumberOfActors(Block) == 0:
    feld.doPause()
    msgDlg("Das Spiel ist gewonnen!")

Sie könnte sogar im Hauptprogramm stehen – also außerhalb der Objekte. Dann müsste aber dort noch eine Endlosschleife kommen, die ständig den Wert prüft.

Einfacher ist es vielleicht, die Abfrage direkt nach der Kollision einzubauen – also in die collide-Funktion im Block-Objekt. Damit wird der Sieg sofort nach dem Löschen des letzten Blocks ermittelt.

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

So! Jetzt sind alle Elemente, die dieses Spiel braucht, vorhanden. Man kann es spielen, verlieren oder gewinnen!

Die Basisversion von BREAKBALL ist fertig!

Jetzt kann man endlich richtig spielen! Auch wenn dieses Spiel weiterhin noch Finetuning gebrauchen kann.

Abbildung 19.9    Jetzt kann man endlich richtig spielen! Auch wenn dieses Spiel weiterhin noch Finetuning gebrauchen kann.

Hier kommt noch einmal der gesamte Code für das Spiel, damit du wieder den Überblick hast (denk dran: Du findest den kompletten Code aller Programme aus diesem Buch auch in der html-Datei auf der DVD oder auf der Buch-Webseite: www.letscode-python.de)

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

Man sieht und spürt, dass das Spiel so schon richtig Spaß machen kann. Jetzt fehlt nur noch etwas Feinschliff. Den kannst du selbst nach Belieben hinzufügen. Hast du Ideen, wie man das Spiel noch verbessern kann?

Sound

Natürlich kann dieses Spiel, wie jedes Spiel, auch noch Klänge gebrauchen. Wenn das Löschen eines Blocks klingelt oder ploppt, wenn der Ball explodiert, wenn er den unteren Rand berührt, wenn eine schöne Melodie den Sieg verkündet, dann fühlt sich das ganze Spiel viel besser an!

Um Sound hinzuzufügen, musst du am Anfang

from soundsystem import *

einfügen, klar. Und dann kannst du, wie im Krebsspiel auch schon, entweder enthaltene Klänge abspielen (click.wav, explode.wav) oder deine eigenen Klänge aufnehmen oder besorgen und in den wav-Ordner zu deinen Skripten tun. Du kannst ebenfalls kleine Melodien (bei Sieg oder Verlieren) einfügen, dann wird das Spiel viel lebendiger!

Feeling

Du kannst am Feeling des Spiels herumschrauben – zum Beispiel die Geschwindigkeit des Balls ändern, oder an der Geschwindigkeit, mit der das Brett hin- und hergeschoben wird. Jedes Mal gibt es ein anderes Feeling dabei. Auch den Gesamttakt des Spiels

feld.setSimulationPeriod(20)

kann man natürlich ändern. Je nach Geschwindigkeit des Rechners ist da vieles möglich.

Variationen

Du kannst die Anzahl der Blöcke ändern, auch ihre Anordnung – und natürlich auch ihr Aussehen, indem du ganz andere Grafiken für sie verwendest. Wenn du die Möglichkeit hast, kannst du eigene Grafiken erstellen, sowohl für die Blöcke als auch für das Brett oder den Ball. Alles kann selbst gestaltet werden. Auch kannst du bei Spielende eine eigene Grafik einblenden, anstatt nur das Mitteilungsfenster zu öffnen.

Regeln

Du kannst Regeln hinzufügen, indem du eine Variable leben einfügst, die am Anfang auf 3 steht und bei Fehlern heruntergezählt wird, sodass das Spiel erst bei leben == 0 zu Ende ist. Wenn du schon fortgeschritten bist, kannst du auch versuchen, mehrere Level einzuführen, bei denen der Ball zum Beispiel immer schneller wird.

Probiere herum, und entwickle das Ballspiel immer weiter! Daran lernst du am meisten! Wenn du dich sicher fühlst und alles verstanden hast, kann es an das nächste Projekt gehen.