Fertig!!!!

Es ist geschafft! Nach drei - fast vier - Monaten voller Höhen und Tiefen, Rückschlägen, Aha-Momenten, Kaffee- und Tee-Pausen und Urlaub zwischendrin, haben wir unser Projekt fertig gestellt.

Im Folgenden haben wir unser Pflichtenheft (Stand Mitte Juli) hervorgeholt und unsere damaligen Wünsche / Spielanforderungen mit dem Ergebnis verglichen. Die grün markierten Spiegelstriche stellen die erfüllten, die rot markierten die nicht erfüllten Projektpunkte dar. Die ursprünglich geplanten Hindernisse - die zufällig auf dem Spielfeld erscheinen sollten - haben wir zur Spielfeldbegrenzung (um-)deklariert. Die blau markierten Spiegelstriche sind Funktionen, die wir bei der Projektplanung nicht bedacht hatten, aber zusätzlich eingefügt haben, um das "Spielerlebnis" noch besser zu gestalten.

Die Schlange 

• soll über das Spielfeld gesteuert werden,
• bewegt sich automatisch fort,
• wird über Pfeiltasten gesteuert,
• sammelt Objekte ein und je mehr Objekte einsammelt werden, desto länger wird diese und
• desto mehr Punkte erhält der Spieler.
• berührt ein Hindernis oder sich selbst, dann endet das Spiel mit „Game Over“ und
• nach dem Spielende wird der Spielstand in die Highscore-Liste eingetragen
• kann mit der Leertaste gestoppt und mit der Eingabe-Taste weitergeführt werden.
• startet erst, wenn die Spielerin / der Spieler im Menü "Neues Spiel" auswählt.
• besitzt eine Farbe. Auch das Futter wird farblich dargestellt.

Auf dem Spielfeld 

• befinden sich Hindernisse, die von der Schlange nicht berührt werden dürfen
• erscheinen zufällig Objekte, die von der Schlange eingesammelt werden müssen
• erscheinende Objekte bringen Punkte ein und sollen in einer bestimmten Farbe/Form erscheinen
• erscheinende Objekte enthalten enthalten Fragen, die sich auf die Programmierung mit Java beziehen

Der Spielerin / Dem Spieler

• soll zu Beginn des Spiels oder bei Auswahl „Neues Spiel“ die Möglichkeit gegeben werden, ein Pseudonym oder Namen anzugeben.  
• soll der Schwierigkeitsgrad angezeigt,
• die Spielzeit sowie Punktestand und
• der (Nick-)Name angezeigt werden.

Das Spiel-Menü stellt folgende Operationen zur Verfügung:

• Neues Spiel 
• Spiel beenden 
• Schwierigkeitsgrad „Einfach“, „Mittel“ und „Schwer“ – die Schlange bewegt sich je nach gewähltem Schwierigkeitsgrad langsamer oder schneller 
• Hilfe und About 
• Highscore 

Neben dem Spielfeld wird

• der Schwierigkeitsgrad angezeigt.
• die Spielzeit sowie Punktestand angezeigt.
• der Name der Spielerin / des Spielers angezeigt.
• ein Informationsbereich mit Angaben zu Steuerung und Spielregeln angezeigt.

Wünschenswerte Funktionen und Erweiterungen:

• Bei Auswahl  “Neues Spiel“ werden Hindernisse neu auf dem Spielfeld angeordnet 
• Musik im Hintergrund 
• Frage-Objekte bewegen sich auf dem Spielfeld 
• Option: Schlange wird während des Spiels schneller

Geplanter Aufbau der Gui (Juli 2012) vs. tatsächliche Gui (Oktober 2012):

Resümee:

Zusammenfassend können wir also feststellen, dass wir ausgehend von der Projektplanung viele Ideen umsetzen konnten und einige auch verwerfen mussten (wie beispielsweise das Einblenden von Frage-Objekten statt "Futter" sowie Hindernisse auf dem Spielfeld). Wenn wir unsere ersten bildlichen Entwürfe zur Javakonda betrachten, können wir feststellen: Viel schön geworden, als zunächst gedacht!!! Das Einfügen eines Bildes als Informationsbereich (anstelle von Angaben zu Name, Highscore etc.) hat uns einiges an Arbeit abgenommen, denn während unserer Arbeit am Projekt haben wir festgestellt, dass unsere anfänglichen Ideen ein wenig zu ambitioniert gewesen sind. So hat uns allein das Einfügen einer Schlange, die sich allein fortbewegt und durch Futterelemente an Größe gewinnt, fast zweieinhalb Monate Arbeit gekostet. Auch das Menü sowie die Aufteilung des JFrames in Panels sowie die grafische Arbeit waren zeitaufwändig. Zusätzliche Funktionen wie Fragen, Musik und Eingabe-Fenster (für Name etc.) wurden deshalb relativ früh im Arbeitsprozess verworfen.

Unsere Javakonda basiert auf Swing. Was uns anfänglich als leichte Projektgrundlage erschien, wurde durch eine Mail seitens des Dozenten etwas gedämpft. Darin hatten wir erfahren, dass JavaFX als Design-Grundlage gewünscht wurde - was wir leider nicht wussten und deshalb froh und munter in Swing programmiert haben. Nach langem Überlegen hatten wir dann doch die Entscheidung getroffen, unserem alten Konzept treu zu bleiben und weiterhin in Swing zu programmieren. Zum einen war diese Entscheidung dem Umstand geschuldet, dass wir schon sehr weit im Arbeitsprozess fortgeschritten waren, und zum anderen hatten wir uns stark mit Swing auseinandergesetzt, sodass ein Wechsel beziehungsweise die Umprogrammierung eines erheblichen Teils unserer Gui viel zu zeitaufwändig geworden wäre.

Alles in allem können wir nun ein fertiges Projekt vorweisen, auf das wir sehr stolz sind!

Spielfeldhintergrund und Infobereich

Für die Javakondaspielfläche wurden jeweils für den Hintergrund für den Infokasten (auf der rechten Seite) zwei Bilder in Photoshop kreiert. Diese wurden dann jeweils in den Infobereich.java- und JavakondaSpielfeld.java-Quellcode eingefügt.

Im folgenden Beispiel ist die Implementierung (für Infobereich.java) dargestellt:

Zunächst wurde ein neues Image-Icon namens legende erstellt - hier wurde auch auf den Ordner, der das Bild enthalten soll, verwiesen. Das infobild wird als neues JLabel angelegt und durch add(this.infobild) zum infobereich hinzugefügt.

Reanimation der Javakonda und etliche Neuerungen

Die letzten Wochen waren in Bezug auf unser Java-Projekt geprägt von ständigen Hochs und Tiefs, mal standen wir am Rande der Verzweiflung, als wir Tagelang nicht voran kamen, mal brachten uns kleinere (und auch größere) Erfolgserlebnisse den nötigen Elan, um weiter zu machen.

Aber jetzt ist ein großer Schritt in unserem Projekt getan: Die eigentliche Programmierung des Quellcodes, welcher unsere Javakonda erscheinen und auf dem Spielfeld hin- und her kriechen lässt! 
Auch haben wir unser Projekt in Hinblick auf die (hoffentlich) korrekte Objektorientierung entscheidend auf Vordermann bringen können.  Jetzt haben wir jeweils eine Klasse für die Schlangensegmente (Segment.java), eine für die Schlange selbst (Schlange.java), eine für die Futterelemente (Futter.java) und natürlich unsere ursprünglichen Klassen Start.java, JavakondaControl.java, JavakondaGui.java und JavakondaSpielfeld.java. So bleibt alles übersichtlich und es ist auch leichter für uns, sich zu orientieren und die Abläufe nachzuvollziehen.

Nun zur kurzen Beschreibung der drei neu hinzu gekommenen Klassen: 

Segment.java: Hier sind alle nötigen Elemente zu finden, welche die Segmente ausmachen. So wird hier zum Beispiel die Größe und Farbe jedes Segmentes bestimmt und definiert und wohin sich die einzelnen Segmente bewegen sollen, wenn eine bestimmte Richtung gegeben ist. Die abschließende Programmierung für die Richtungssteuerung durch die/den Benutzer_in findet sich allerdings in der Klasse JavakondaSpielfeld.java. 

Schlange.java: In dieser Klasse wird auf die Klasse Segment.java verwiesen und die einzelnen Segmente in eine „LinkedList“ gepackt. Wie wir durch ein Java-Tutorium im Internet herausgefunden haben, stehen alle Elemente innerhalb einer LinkedList (oder auch „Verkettete Liste“)  in Verbindung zum jeweiligen Vorgängerelement.  So müssen beim Löschen eines Elementes nur die Verweise auf die Nachbarn geändert werden, was ein großer Vorteil ist, wenn häufiger Daten eingefügt oder gelöscht werden, was bei unserer Schlange ja der Fall ist. (Quelle: http://www.java-tutorial.org/linkedlist.html, Stand 24.09.2012) Des Weiteren stehen in dieser Klasse Befehle, um die Schlange durch Aneinanderreihen der einzelnen Segmente zu erzeugen und anschließend zu zeichnen und eine Richtungsermittlung der Schlange. 
In der abschließenden „prüfen()“-Methode werden verschiedene Dinge überprüft, wie zum Beispiel, ob der Kopf der Schlange ein anderes Körperteil berührt. In der nächsten Zeit sollen hier auch noch andere Überprüfungen entstehen, wie zum Beispiel, ob die Schlange den Spielfeldrand oder ein Futterelement berührt. 

Futter.java: Hier ist die Größe der Futterelemente bestimmt und anschließend ein Befehl für das Zeichnen programmiert worden. Die Futterelemente sind allerdings noch nicht im Spiel verortet, das heißt, bisher werden sie noch nicht angezeigt. 

Natürlich hat sich auch in der Klasse JavakondaSpielfeld.java einiges getan, die Schlange wurde hier verortet, da sie sich ja auf diesem Spielfeld bewegen soll. Dazu wurde zuerst einmal die Methode „Spiel starten()“ angepasst, diese enthält nun die Methoden 
„schlangeErstellen()“ und „losGehts()“.

In der „schlangeErstellen()“-Methode wurde der Befehl „schlange.erzuegen()“ eingefügt, welcher auf die erstellen-Methode in der Klasse schlange.java hinweist und die „losGehts()“-Methode enthält jetzt den Befehl „uhr.neuStarten()“. Dieser verweist auf einen neu eingebauten Thread, welcher am Ende der JavakondaSpielfeld-Klasse steht und welcher einen Timer beinhaltet, der im Hintergrund läuft. So soll die Bewegung der Schlange erzeugt werden, denn dieser Thread ist so programmiert, dass sich das JavakondaSpielfeld immer in einem bestimmten Zeitabstand (hier im Moment alle 100 Millisekunden) aktualisieren soll. Was genau bei dieser Aktualisierung passieren soll, ist wiederum in der JavakondaSpielfeld-Klasse in der „aktualisieren()“-Methode festgelegt. Hier soll sich die Schlange zuerst bewegen und dann soll das Spielfeld neu gezeichnet werden, um zu verhindern, dass die  Schlange an ihrer ursprünglichen Position gezeichnet bleibt. Dann wird die neu positionierte Schlange selbst in der darauffolgenden „paint()“-Methode neu gezeichnet. 

Zu guter Letzt legt die „keyPressed()“-Methode fest, was passieren soll, wenn eine bestimmte Pfeiltaste gedrückt wurde. So ähnlich wurde dies zwar schon in der Klasse Segment.java programmiert, jedoch wurden dort quasi nur die Bezeichnungen (HOCH, RUNTER, LINKS, RECHTS) für die Richtungen festgelegt und in welche Richtung sich die Elemente bewegen sollen, es war aber noch nötig, in der JavakondaSpielfeld-Klasse die offiziellen Bezeichnungen für die Richtungstasten zu verwenden (VK_UP,VK_DOWN, VK_RIGHT, VK_LEFT) und diese dann mit den von uns benannten Richtungen zu verknüpfen.  

Und so sieht unser Spiel bis jetzt aus:

Die Anfangsschlange setzt sich also aus drei Schlangensegmenten zusammen und bewegt sich nach rechts.  Um ein Spiel anzufangen, muss man nun zuerst im Menü auf den Menüpunkt „Neues Spiel“ klicken. So soll verhindert werden, dass die Schlange nach dem Öffnen des Fensters sofort losläuft und die_der Benutzer_in eventuell keine Zeit hat, rechtzeitig zu reagieren, bevor die Schlange die Spielfeldbegrenzung trifft oder ähnliches. 

Zusammengefasst ist nun folgendes entstanden: Die Programmierung und Erzeugung/Zeichnung der Schlange, die Bewegung der Schlange und deren Steuerung durch die_den Benutzer_in sowie das Zurückversetzen in die Anfangsposition bei Klick auf „Neues Spiel“. 

Die nächsten Schritte in unserem Projekt werden nun folgende sein: 

• Begrenzung einrichten (Überprüfung, ob die Schlange den Spielfeldrand berührt und die Programmierung einer Game Over – Anzeige, wenn dies der Fall ist) 
• Schwierigkeitsgrad festlegen 
• Futterelemente integrieren, sodass diese zufällig auf dem Spielfeld erscheinen 

Fortsetzung: Verknüpfung der Menüleiste

Weitere Verknüpfung der Menüpunkte mit der GUI und erste Überlegungen zum Umbau der Klassen

In der letzten Zeit haben wir die Arbeiten an der Menüleiste fortgesetzt.

Im Mittelpunkt stand dabei die Verknüpfung des Menüpunktes „Neues Spiel“. Wir haben, wie auch schon beim Punkt „Spiel beenden“, eine neue Methode (neuesSpiel() ) geschrieben und eine Entscheidungsfrage eingebaut, die den Benutzer nach Klicken auf den „Neues Spiel“-Knopf fragt, ob er das Spiel wirklich neu starten möchte, oder doch lieber das alte Spiel fortsetzen will.

Die Methode zur Programmierung der Entscheidungsfrage gleicht somit der zum Beenden des Spiels. (Siehe Blogeintrag vom 5. August 2012)

Uns ist es gelungen, ebendiese Entscheidungsfrage zu programmieren, allerdings fehlt noch der allerletzte Befehl in der if-Anweisung, damit das alte Spiel gelöscht und ein neues gestartet wird. Wenn man im Moment in der Menüleiste auf „Neues Spiel“ klickt, so erscheint zwar die Entscheidungsfrage, bei Klicken des Knopfes „Nein“ schließt sie sich wieder und das aktuelle Spiel wird – wie gewollt – fortgesetzt, wenn man jedoch den Knopf „Ja“ klickt, so passiert noch nichts. Ziel in der nächsten Zeit wird es somit sein, einen funktionierenden Befehl für die if-Anweisung zu finden, damit das Spiel bei Klicken von „Ja“ auch wirklich neu gestartet wird!

Screenshot des Spiels mit der Entscheidungsfrage:

 

 ________________________________________________________________________________________

Letzte Woche bekamen wir eine Mail von Herrn Kölle, in welcher er uns daran erinnerte, dass wir Javafx-Klassen nicht mit Swing-Klassen vermischen dürfen, etwas, das wir unbewusst getan haben.

Nach dem ersten Schock über die Mail und der Tatsache, dass wir jetzt große Teile unseres Quellcodes umschreiben müssen, haben wir uns dazu entschlossen, dass wir alles auf Javafx umschreiben werden. Dies bedeutet zwar, dass wir fast unsere gesamte GUI und ein paar der darauf programmierten Befehle verändern müssen, aber in Anbetracht der Tatsache, dass wir im Kurs nur Javafx gelernt haben und somit auch unsere gesamten Aufzeichnungen aus der Vorlesung auf Javafx basieren, wird dies bestimmt der bessere und einfachere Weg sein.

Jetzt heißt es also in den nächsten Tagen: Umschreiben, umschreiben, umschreiben! Und hoffen, dass dabei nicht allzu große unerwartete Probleme auftauchen werden, sodass wir uns so bald wie möglich wieder an die weitere Ausprogrammierung unserer Javakonda machen können!

(Anm.d.Projektmenschen: Wir haben uns nach Prüfung des Projekts doch dazu entschieden, Swing beizubehalten und mit Javafx weder zu mischen noch dieses zu verwenden.)