Schiffe versenken
Projektdokumentation
Lernfeld 6 Entwickeln und Bereitstellen von Anwendungssystemen
Giesler, Philipp
15.05.2013
Philipp Giesler
LF6
BSFIA 12
Inhaltsverzeichnis
Inhaltsverzeichnis ................................................................................................................................ 1
1. Einleitung ......................................................................................................................................... 2
1.1. Aufgabenstellung...................................................................................................................... 2
1.2. Spielregeln ................................................................................................................................ 2
1.3. Projektumfang .......................................................................................................................... 2
2. Projektbeschreibung ....................................................................................................................... 3
2.1. Projektaufbau ........................................................................................................................... 3
2.2. Spielablauf ................................................................................................................................ 6
2.3. Anforderungen ......................................................................................................................... 6
3. Wichtige Funktion ........................................................................................................................... 7
3.1. gegnerEinfach( )........................................................................................................................ 7
3.2. gegnerSchuss( )......................................................................................................................... 8
3.3. PAPs .......................................................................................................................................... 9
3.4. Kurzbeschreibung der Funktionen ......................................................................................... 11
4. Zeitplan und Ablauf der Projektes ................................................................................................. 12
4.1 Zeitplan .................................................................................................................................... 12
4.2 Ablauf des Projektes ................................................................................................................ 13
5. Schlussbetrachtung ...................................................................................................................... 14
6. Sonstiges ....................................................................................................................................... 15
6.1. Abbildungsverzeichnis ............................................................................................................ 15
6.2. Glossar .................................................................................................................................... 15
6.3. Quellenangaben ..................................................................................................................... 15
15.05.2013
Philipp Giesler
LF6
BSFIA 12
1. Einleitung
1.1. Aufgabenstellung
Im Rahmen des Unterrichts soll eine in Java programmierte Version von Schiffe versenken erstellt
werden. Es soll einen leichten und einen schweren Gegner geben. Der leichte schiet dabei auf
zufllige Positionen des Spielfeldes. Der schwere Gegner soll das Schiff bei Treffer dann auch
versenken.
1.2. Spielregeln
Sowohl Spieler als auch Gegner haben insgesamt sieben Schiffe. Dabei wird zwischen vier Typen
unterschieden:
-
Nachdem die Schiffe gesetzt wurden, wird mit dem Schieen begonnen. Es wird abwechselnd
geschossen. Wenn man an eine Position bereits geschossen hat, kann diese trotzdem noch
beschossen werden. Der Spieler muss wie bei der klassischen Variante des Spiels darauf achten, wo
er bereits hin geschossen hat, allerdings werden ihm seine Schsse angezeigt.
1.3. Projektumfang
Der Umfang des Projektes erstreckt sich von der Programmierung des Spieles, ber das Testen der
Funktionen bis hin zur Dokumentation und Beschreibung des Projektes.
15.05.2013
Philipp Giesler
LF6
BSFIA 12
2. Projektbeschreibung
2.1. Projektaufbau
Spielfeld:
Das Spielfeld setzt sich aus zwei einzelnen Feldern zusammen (eins fr den Computer und eins fr
den Spieler). Ein Spielfeld hat die Gre von 10 x 10 Feldern, auf denen die Schiffe platziert und
anschlieend die Schssen abgefeuert werden.
Abbildung 1 - Spielfeld
15.05.2013
Philipp Giesler
LF6
BSFIA 12
Abfragen:
Schwierigkeitsgrad
Schiff setzen
Schieen
Schsse:
Schsse werden bei einem Treffer mit # markiert. Blindgnger mit einem O.
15.05.2013
Philipp Giesler
LF6
BSFIA 12
Schiffe:
Schiffe werden mit einem X auf dem Spielfeld markiert. Um das Schiff herum wird Wasser (~)
gesetzt, da die Schiffe nicht aneinander gesetzt werden drfen.
Rckgabe:
Treffer
Kein Treffer
Gewonnen
Verloren
15.05.2013
Philipp Giesler
LF6
BSFIA 12
2.2. Spielablauf
1. Als erstes wird gefragt, ob der Spieler gegen den leichten oder gegen den schweren Gegner
spielen mchte.
2. Danach setzt der Gegner seine Schiff, welche man als Spieler logischerweise nicht sieht.
3. Nun kann der Spieler seine Schiffe setzen.
4. Sobald der Spieler seine Schiffe gesetzt hat, wird begonnen zu schieen. Es wird
abwechselnd geschossen. Der Spieler fngt an.
5. Sobald Spieler oder Gegner alle Schiffe versenkt hat, ist das Spiel vorbei.
2.3. Anforderungen
Hardware:
Voraussetzungen die ein PC, welcher die minimalsten Systemvoraussetzungen von Java besitzt:
- RAM: 128 MB; 64 MB fr Windows XP (32-Bit)
- Speicherplatz: 124 MB
Software:
Softwarevoraussetzungen fr Java lt. Hersteller:
- Windows 8 (Desktop)
- Windows 7
- Windows Vista SP 2
- Windows XP SP3 (32-Bit); Windows XP SP2 (64-Bit)
- Windows Server 2008
- Windows Server 2012 (64-Bit)
Folgende zustzliche Software wird bentigt :
- Java IDE: Eclipse (Release 4.2.0)
- Java JRE: Java 6 Update 39 (Version 6.0.390)
- Java JDK: Java SE Development Kit 6 Update 32 (Version 1.6.0.320)
15.05.2013
Philipp Giesler
LF6
BSFIA 12
3. Wichtige Funktion
3.1. gegnerEinfach( )
15.05.2013
Philipp Giesler
LF6
BSFIA 12
3.2. gegnerSchuss( )
do
{
// bestimme random die Schusskoordinaten
ykoordinate
xkoordinate
xkoordinate
ykoordinate
=
=
=
=
(int) (Math.random()*9+1);
(int) (Math.random()*9+1);
xkoordinate -1;
ykoordinate -1;
// wenn das Feld leer ist oder mit ~ makiert ist, dann makiere es mit O
if(spielerfeld[ykoordinate][xkoordinate] == ' ' ||
spielerfeld[ykoordinate][xkoordinate] == '~'){
spielerfeld[ykoordinate][xkoordinate] = 'O';
schuss = 1;
// wenn auf dem Feld ein X ist, dann makiere es mit # und gebe aus, dass der
Gegner eins deiner Schiffe getroffen hat
}else if(spielerfeld[ykoordinate][xkoordinate] == 'x'){
spielerfeld[ykoordinate][xkoordinate] = '#';
System.out.println("Der Gegner hat eins deiner Schiffe getroffen!");
schuss = 1;
// wenn er bereits auf die Koordinate geschossen hat, zhle den Schuss als
ungltig
}else{
schuss = 0;
}
// wenn der Schuss ungltig ist, schiesse erneut
}while(schuss == 0);
// zeige das aktuelle Spielfeld
aktuellesSpielfeld();
}
15.05.2013
Philipp Giesler
LF6
BSFIA 12
3.3. Programmablaufplne
gegnerEinfach:
15.05.2013
Philipp Giesler
LF6
BSFIA 12
gegnerSchuss:
15.05.2013
10
Philipp Giesler
LF6
BSFIA 12
Die Funktion gegnerEinfach( ) wird aufgerufen, wenn der Spieler zu Beginn des Spiels den einfach
Schwierigkeitsgrad auswhlt. Die Funktion setzt zuerst den Spieler und den Gegner auf false, da
noch keiner gewonnen hat. Danach werden die Schiffe vom Gegner gesetzt. Dann wird solange
abwechselnd geschossen (der Spieler fngt immer an), bis Spieler oder Gegner gewonnen hat. Zum
Schluss wird ausgegeben, ob man gewonnen oder verloren hat.
gegnerSchuss:
Bei gegnerSchuss( ) wird dem Gegner ermglicht, auf das Spielfeld zu schieen. Dabei werden die
Koordinaten per Zufall bestimmt. Trifft er ein Schiff, so wird dieses mit einer Raute makiert. Trifft er
jedoch nicht, so wird ein O gesetzt. Wenn der Gegner auf einen bereits beschossenen Punkt schieen
will, werden die Koordinaten neu bestimmt. Der Spieler muss jedoch selber darauf achten, wohin er
bereits geschossen hat.
15.05.2013
11
Philipp Giesler
LF6
BSFIA 12
Aufgabe
Sollzeit
Ist
Grundstruktur
1h
1h
3h
2h
Spielfeld
2.5h
1.5h
Schiffe setzen
ermglichen
2.5h
1h
Gegner einfach
3h
2h
Gegner schwer
6h
12h
Testzeit
4.5h
5h
Zeitpuffer
6.5h
6.5h
Gesamtzeit
29h
31h
15.05.2013
12
Philipp Giesler
LF6
BSFIA 12
Zu Beginn des Projektes legte ich fest, wie ich es am besten aufbaue. Ich entschied mich fr 4
Klassen, Schiffe versenken (Main), Schiffe, Spielzge und Spielfeld.
In Main sollen sich lediglich die Schwierigkeitsabfrage und die Aufrufe der einzelnen Spielzge
befinden.
In der Klasse Schiffe befinden sich nur die Angaben zur Lnge der einzelnen Schiffe. Mit Methoden
zur Rckgabe der Lnge.
Die Klasse Spielzge wurde dann schon grer geplant und umgesetzt. Hierin gibt es Methoden fr
das Setzen der eigenen Schiffe und das der Gegnerischen. Aber auch Methoden fr das eigentliche
Spiel. Die Methoden greifen dabei grtenteils auf Methoden vom Spielfeld zurck.
Die Klasse Spielfeld beinhaltet zwei zweidimensionale Arrays, welche von ihren Methoden
angesprochen werden. Ein Array fr das Spielerfeld und eins fr das Gegnerfeld. Methoden sind dort
zum Beispiel der Schuss des Spielers/Gegners und das Setzen der Schiffe ins Array. Aber auch ein
Feldstatusberprfer befindet sich in der Klasse. Dieser prft ob sich auf den bermittelten
Koordinaten bereits ein Schiff befindet. Die meisten Methoden sind in hnlicher Form einmal fr den
Spieler und einmal fr den Gegner vorhanden.
15.05.2013
13
Philipp Giesler
LF6
BSFIA 12
5. Schlussbetrachtung
15.05.2013
14
Philipp Giesler
LF6
BSFIA 12
6. Sonstiges
6.1. Abbildungsverzeichnis
6.2. Glossar
Eclipse - Eclipse ist
verschiedenster Art.
zur
Entwicklung
von
Software
RAM- ist ein Informations-Speicher, der besonders bei Computern als Arbeitsspeicher Verwendung
findet.
Java - Java ist eine objektorientierte Programmiersprache.
Array - Ein Feld bezeichnet eine Datenstruktur-Variante, mit deren Verwendung viele gleichartig
strukturierte Daten verarbeitet werden sollen.
6.3. Quellenangaben
Systemvoraussetzungen:
http://www.java.com/de/download/help/sysreq.xml
Spielregeln:
http://de.wikipedia.org/wiki/Schiffe_versenken
Glossar:
http://de.wikipedia.org/
15.05.2013
15