"SuperBall"

Projekt

Das Projekt wurde im Rahmen der Praxisphase entwickelt. Die Praxisphase vom 20. Juli bis 27. September 2009 widmete sich der Entwicklung einer objektorientierten Anwendung auf einer Mikrocontrollerlösung.

Als erstes werden die erforderlichen Hintergrundinformationen, die notwendig sind, um die Aufgabe zu lösen, näher erläutert. Anschließend wird der Lösungsweg mit seinen verschiedenen Phasen dargestellt. Danach wird die Spielanleitung vorgestellt und das Spiel näher beschrieben. Anhand von Klassen- und Sequenzdiagrammen wird die Realisierung des Spiels verdeutlicht. Zum Schluss wird gezeigt, wie das Programm mittels der Software auf den Mikrocontroller gebrannt wird.

Gliederung der Projektarbeit:

Theoretische Grundlagen

UML - Unified Modeling Language
Objektorientierung
Mikrocontroller

Analyse und Entwurf

Systemanalyse
Entwurf der Systemstruktur
Entwurf des Systemverhaltens

Realisierung

Umsetzung der Systemstruktur
Umsetzung des Systemverhaltens
Programmieren und Testen

Zusammenfassung

Spielbeschreibung:
In der unteren Abbildung sehen Sie wie das Spiel aufgebaut ist. Der Ball bewegt sich ohne Steuerung des Spielers zick-zack-förmig ab einer definierten Startposition. Berührt er den linken, oberen und rechten Rand des Spielfeldes, wird er ebenfalls zick-zack-förmig abgestoßen. Am unteren Bildrand bewegt sich der Schläger in horizontaler Richtung. Mit diesem versucht der Spieler zu verhindern, dass der Ball das Spielfeld am unteren Ende verlässt. Der Ball bewegt sich mit konstanter Geschwindigkeit. Der Schläger dagegen bewegt sich schneller als der Ball. Bei jedem Zusammentreffen des Schlägers mit dem Ball werden die Punkte jeweils um eins erhöht. Bewegt sich der Ball durch die untere Begrenzung des Spielfeldes wird die Punktzahl auf dem LC-Display angezeigt und das Spiel wird beendet. Durch betätigen der Reset-Taste wird der Punktestand auf Null zurückgesetzt und das Spiel neu gestartet.

Quelltext:

Klasse Controller
class Controller
{
// eingebundene Klassen
private:
Ball ball;
Schlaeger schlaeger;
Rand rand;
// Attribute
public:
GraficLcd lcd;
PushButton btnRight;
PushButton btnLeft;
// Methoden
public void main()
{
// diese Operation als Start-Operation für main angeben
// hier Initialisierungen durchführen
// Jumper auf "LCD on Port C+A" stecken auf dem Board
lcd.configLcd(PORTA, PORTC);
// Rechtsbewegung des Joysticks
// Angabe des zuständigen Ports und des entsprechenden Bits
btnRight.config(PORTK, BIT6);
// Linksbewegung des Joysticks
// Angabe des zuständigen Ports und des entsprechenden Bits
btnLeft.config(PORTK, BIT4);
// mainloop starten
run();
}

public void run()
{
do
{
// bewege den Ball
ball.bewege();
// zeichne den Ball
ball.zeichne();
// warte 10 ms bis nächster Punkt gezeichnet wird, es wird
// darüber auch der Schläger mitgesteuert, ohne diese
// Zeile ist der Ball gar nicht zu sehen
waitMs(10);
// löscht den Inhalt auf dem LCD-Bildschirm
// daraus folgt, dass ständig ein neuer Punkt gezeichnet
// wird und der andere Punkt gelöscht wird
lcd.clear();
// der Schläger soll sich bewegen,
// wenn der Joystick oder Button nach links gedrückt wird
if (btnLeft.isPressed())
{
// ..., dann bewege den Schläger nach links, also -1
// (da x verringert wird)
schlaeger.bewege(-1);
}
// rechter Rand
if(schlaeger.pos_x2 == 127 || schlaeger.pos_x2 > 127)

{
schlaeger.bewege(-1);
}
// wenn der Joystick oder Button nach rechts gedrückt wird
if (btnRight.isPressed())
{
// ..., dann bewege den Schläger nach rechts, also
// +1 (da x ständig erhöht wird)
schlaeger.bewege(+1);
}
// linker rand
if(schlaeger.pos_x1 == 0 || schlaeger.pos_x1 < 0)
{
schlaeger.bewege(+1);
}
// zeichne den Schläger
schlaeger.zeichne();
// Kollisionsprüfung, wenn der Schläger ein "true" an den
// Ball zurücksendet, dann entscheidet der Ball selber was
// er macht, wird angewiesen die Richtung von sich selbst
// zu ändern
if (schlaeger.hittest(ball))
{
// wenn der Ball den Schläger getroffen hat, dann
// ändere die Y-Richtung des Balls auf -1 (Ball geht
// nach oben)
ball.riY *= -1;
// bei jedem Zusammenstoß Punkte zählen, immer
// um eins nach oben zählen
schlaeger.punkt = schlaeger.punkt + 1;
}

// wenn der Ball im unteren Rand verschwindet, ...
if (rand.verloren(ball))
{
// ... zeige die erreichten Punkte auf dem LCD an
schlaeger.punkte_anzeigen(ball);
// warte 500ms
waitMs(500);
}

} while (true);
}
}

Klasse Ball
class Ball
{
// Attribute
public:
pos_x = 20;
pos_y = 20;
riX = 1;
riY = -1;
radius = 2;
// Methoden
public void zeichne()
{
// zeichne ein Pixel bei der angegebenen Position x und y
app.lcd.circle(pos_x, pos_y, radius, true, LCD_MODE_SET);
}
public void bewege()
{
// der Ball soll sich automatisch bewegen, das heißt, dass ich auch
// 2 Richtungen benötige, die x- und die y-Richtung
// die Bewegung des Balles ist nur einzelner Schritt, da sich der
// Ball senkrecht nach unten bewegt, ändern sich die x- und y-
// Position des Balls zusammen
// x-Position des Balls entspricht auch der x-Richtung
pos_x += riX;
// y-Position des Balls entspricht auch der y-Richtung
pos_y += riY;
// wenn Ball an Rand stößt, dann Richtung *1 rechnen wechseln
// wenn die x-Position des Balls 0 oder 127 beträgt, ...
if (pos_x == 0 || pos_x == 127)
// ... dann ändere die Richtung des Balls, rechne *(-1) (Ball geht
// nach unten)
riX *= -1;
// wenn y-Position des Balls 0 beträgt, ...
if (pos_y == 0)
// ... dann ändere auch diese Richtung, in dem *(-1) gerechnet wird
// (Ball geht nach oben)
riY *= -1;
}
}

Klasse Schläger
class Schlaeger
{
// Attribute
public:
float pos_x1;
float pos_y1;
Anlage 2 / Blatt 6
float pos_x2;
float pos_y2;
volatile uint16_t punkt;
float step;
// Methoden
public void zeichne()
{
// zeichne ein Rechteck bei der angegebenen Position
app.lcd.rect(pos_x1, pos_y1, pos_x2, pos_y2, false,
LCD_MODE_SET);
}
public void bewege(float ri)
{
// beim Bewegen, bleibt die y-Position gleich, nur die x-Position
// ändert sich, deswegen brauche ich nur eine Richtung, außerdem
// soll der Schläger sich nicht automatisch bewegen
pos_x1 += ri*step;
pos_x2 += ri*step;
}
// Kollision zwischen Ball und Schläger; Parameter: Klassenname, auf
// die zurückgegriffen werden soll Parametername
public bool hittest(Ball ball)
{
// der Schläger gibt Message, ob er vom Ball getroffen wurde,
// entweder "true" oder "false"; muss als Parameter den Ball vom
// Typ Ball übergeben, bevor das passiert, muss eine gerichtete
// Bewegung zwischen "Schläger und Ball" bestehen
// Schlüsselwort "this" ist ein Verweis auf sich selbst
if ((ball.pos_x >= this -> pos_x1) &&
(ball.pos_x <= this -> pos_x2) &&
(ball.pos_y >= this -> pos_y1) &&
(ball.pos_y <= this -> pos_y2))
{
// wenn diese Maße erreicht sind, gib` "true" zurück
return true;
}
}
public void punkte_anzeigen(Ball ball)
{
// erreichte Punkte sollen auf dem LCD-Display angezeigt werden
// lege die Variablen "txt" und "t1" vom Typ String an, damit der
// Datentyp String akzeptiert wird, muss das Paket
// "myAVR_String" hinein und in der Klassendiagramm-
// Eigenschaft, bei "Includes für alle Klassen dieser Anwendung:"
// der Typ "#define String String 16m" hinein
String16m txt,t1;
// die Variable "txt" enthält das Wort "Punkte:"
txt = "Punkte: ";
// die erreichten Punkte werden in der Variable "punkt" gesichert
// dieser Inhalt der Variable wird mit der umgewandelten Zahl
// gefüllt und in die Variable "t1" geschoben vom Datentypen String
t1.fromInt(punkt);
// die beiden Teile werden zusammengefügt
txt += t1;
// füge zum Schluss noch ein Leerzeichen dran
txt += " ";
// gebe die erreichten Punkte auf der Position (00, 32) aus
app.lcd.setPos(00,32);
// gebe auf dem LCD-Display die erreichten Punkte aus, die nun in
// der Variable "txt" stehen
app.lcd.writeTextRam(txt,LCD_MODE_SET);
// Schläger vom LCD-Bildschirm löschen
app.lcd.rect(pos_x1, pos_y1, pos_x2, pos_y2, false,
LCD_MODE_CLR);
// Ball vom LCD-Bildschirm löschen, läuft trotzdem weiter
app.lcd.circle(ball.riX = 0, ball.riY = 0, ball.radius = 0, true,
LCD_MODE_CLR);
}
}

Klasse Rand
class Rand
{
// Attribute
// keine Attribute deklariert, Feld leer

// Methode
public bool verloren(Ball ball)
{
// beim Rand interessiert nur die y-Position nicht die x-Position
// wenn der Ball die y-Position 63 oder höher erreicht hat, ...
if (ball.pos_y >= 63)
{
// ... dann gib ein wahr (true) zurück
return true;
}
}
}