FreitagsrundenWiki - Benutzerbeiträge [de]

TechGI 4 (Bachelor)/Gedächtnisprotokoll Klausur SoSe 2009

2011-07-19T17:12:12Z

130.149.17.34: ICH GLAUB MICH TRIFFT DER SCHLAG

=== Klausur im SS2009 ===

# ''' Transparenzen ''' Was bedeutet Transparenz im Bezug auf verteilte Systeme? Nenne vier Transparenzen und beschreibe sie kurz
# '''TCP/UDP ''' Grenze beides voneinander ab
# ''' RPC '''
## nenne drei Möglichkeiten die ein Client hat, wenn er auf eine Anfrage keine Antwort kriegt
## Was bedeutet Idempotenz?
# '''Berkeley-Socket API''' Was bedeutet der "Accept"-Befehl?
# ''' UDDI ''' Fülle das Schema aus (1-6 + Nummerierung)
# ''' Netzwerkkommunikationsverzögerung ''' (gegeben: Größe des Pakets, Länge der Leitung, Geschwindigkeit, Bandbreite)
## Wie lange braucht der Sender zum verschicken?
## Wann kommt das erste Bit an, wann das letzte?
## In Zeitverlaufsschema eintragen
## Berechne das Ganze für neue Werte
# ''' Berkeley-Algorithmus '''
## Was sendet der Server?
## Was senden die Clients?
## Berechne die neue Zeit, die vom Server versendet wird (alte Zeiten gegeben)
# ''' Webservice ''' Zuerst Implementierung der Kernfunktionalität oder Erstellung der WSDL-Datei? Warum? Welchen Vorteil hätte die andere Variante?
# ''' DNS '''
## Erkläre kurz DNS
## Kann man von einer '' Gefährdung des Internets '' ([[http://www.heise.de/security/Massives-DNS-Sicherheitsproblem-gefaehrdet-das-Internet--/news/meldung/110641| Artikel war genannt]]) sprechen? + Erklärung
# ''' Multicast '''
## Skizziere FIFO ohne Atomic
## Skizziere Atomic ohne FIFO
## Wie nennt man beides zusammen?
# ''' Synchronisation von Datenbanken ''' Anforderung an ein Commit-Protokoll (?)
# ''' Netzwerk Multicast ''' Erläutere kurz '' Multicast via Unicast'' und '' Network Multicast ''. Nenne jeweils ein Vorteil
# ''' Weighted Voting '''
## Nenne die Bedeutung von w,v und r in den zwei Formeln (gegeben)
## Nenne die Bedeutung der Formeln
# ''' Fehlerwahrscheinlichkeit '''
## Wie groß ist die Wahrscheinlichkeit, dass ein Paket der Größe n Fehlerhaft ist ?(Fehlerwahrscheinlichkeit pro bit p gegeben)
## Welche Annahme wurde bei 1. getroffen? Ist diese realistisch? Begründe!
# ''' GoBackN '''
## Wie groß ist der Puffer auf Sender- und Empfängerseite?
## Bei einer sehr sehr fehlerbehafteten Übertragungsleitung macht es Sinn, nur einzelne Pakete nochmal zu schicken. Welchen Nachteil hat das?
# ''' Lamport ''' Kann man in einem System, bei dem die Uhren mit dem Lamport-Algorithmus gestellt werden, absolute Zeitverzögerungen(?) messen? Begründe!
# '''Internet '''
## Wir viele Adressen sind mit IPv4 maximal möglich (ohne Beachtung von irgendwas)
## Erkläre NAT
# '''Statistische Demultiplexing ''' Gegeben 2 Kanäle mit Bitrate C(?)
# ''' Routing ''' Nenne drei Fehler, die in einem Netzwerk auftreten können, in dem nur das Best-Effort-Prinzip verwendet wird, und jeweils die Lösung dazu.

Javakurs/Übungsaufgaben/Doom

2011-03-22T10:17:24Z

130.149.17.34:

'''ASCII-DOOM'''

In Ascii-Doom geht es darum, ein kleines [http://de.wikipedia.org/wiki/Rogue-like rogue-like] Spiel zu implementieren.

D.h. es wird möglich sein mittels [http://en.wikipedia.org/wiki/ASCII_art ASCII-Art], mit einer Spielfigur auf dem Spielfeld zu laufen, später könnt ihr auch
Items, Waffen und [http://de.wikipedia.org/wiki/Liv_Tyler Liv Tyler] einbauen!

Wir werden Schritt für Schritt das Spiel implementieren. Wenn ihr verloren geht, keine Angst, wir können euch helfen ...

== Die Klasse ''GameMain'' - Der Anfang ==

Die Klasse ''GameMain'' ist die Klasse, die die main Methode enthalten wird und somit ausführbar ist. Sie wird die Schnittstelle zur Außenwelt sein und die Ausgabe auf die Konsole tätigen.

* Erstellt zunächst nur diese Klasse. Sobald ihr Klassen aus den späteren Aufgaben implementiert habt, könnt ihr in der ''main''-Methode ihre Funktionalität testen.

== Positionen für alle Objekte ==

Die Klasse ''Position'' repräsentiert eine Position auf einem 2D-Spielfeld. Also karthesische 2 dimensionale Koordinaten, wie ihr sie von einem kariertem Papier kennt. Des Weiteren enthält Sie private die folgende Attribute: ''x'' und ''y'', gekapselt mit ''Gettern'' und ''Settern''.

* Schreibt diese ''Getter'' und ''Setter''
* Implementiert eine equals-Methode, die 2 Objekte vom Typ ''Position'' vergleicht.
* Testet nun eure ''equals''-Methode in der ''main''. (Tested sie solange bis sie funktioniert)

== Repräsentation eines Gebietes ==

''GameTile'' wird unsere Klasse sein, die ein Tile, also ein Feld, im späteren Spiel repräsentiert. Alle weiteren Felder werden von ihr erben. So wird es später ein ''leeres Feld'' geben, eine ''Mauer'', und Alles was euch noch einfällt.

* Es enthält außerdem eine private Variable vom Typ ''Position'', welche die Position des GameTiles auf dem Feld speichert.

* Implementiert eine ''toString''-Methode, die jedem ''GameTile'' einen ''String'' mit Länge 1 zuordnet.
** Diese Methode wird von allen erbenden Klassen überschrieben werden

* Schreibt nun einige Klassen die von ''GameTile'' erben
** Als Namen bietet sich ''WallTile'' und ''EmptyTile''
** Die ''toString()''-Methoden sollten dann sinvolle Zeichen zurückgeben, wie " " oder "#".

* Testet auch hier euere ''toString''-Methoden, in dem ihr euch einzelne Tiles erzeugt und diese ausgeben last'''

== Das GameField ==
Euer ''GameField'' ist eine zentrale Klasse in diesem Spiel, sie repräsentiert das Spielfeld als Ganzes und besteht aus mehreren ''GameTiles''.

* Enthält eine private Variable für das Level (2D-Array aus GameTiles).

* Über den Konstruktor wird ein String dieser Form übergeben(ebenso wie die Breite des Spielfeldes):
String s = "########" +
"# #" +
"# #" +
"### #" +
"# #" +
"########";
** Es soll mit einer Schleife der String Zeichen für Zeichen ausgelesen werden und aus jedem Zeichen ein neues ''GameTile'' (Wand oder leer) erzeugt werden. Diese ''GameTiles'' werden dann in dem Array gespeichert!
** Wie man Strings Zeichen für Zeichen ausliest, findet ihr in der API (java.lang.String).
** Implementiert ein toString, dieser soll folgenden String liefern:
########
# #
# #
### #
# #
########
** Tipp: "\n" steht in einem String für Zeilenumbruch.
** Es soll also aus dem ''GameField''-Array wieder ein ''String'' generiert werden.
** Die ''toString''-Methode von ''GameField'' soll die ''toString''-Methode der ''GameTile''s verwenden, um diese Ausgabe zu erzeugen.
* '''TESTET euer Programm mit verschiedenen Levels'''

== Eine Welt aus Feldern ==

Die Klasse ''World'' ist die Klasse, die Alles verbinden wird, Spieler, Items, Spielfeld etc.

Bei Java funktioniert es bei grafischen Anwendungen etwa so: Man hat ein Objekt, das eine Leinwand repräsentiert (Canvas), man darf auf diesem Objekt Sachen malen. In einem Spiel wird das Objekt in jedem Frame leer gemacht, danach werden alle beteiligten grafischen Objekte (Spieler, Spielfeld, Gegner) nacheinander auf diese Leinwand gemalt. Letzendlich wird die Leinwand auf dem Bildschirm ausgegeben. Das hat den Vorteil, dass jede Klasse die darauf Zugriff bekommt, irgendetwas malen kann ohne zu wissen, was bereits darauf ist oder noch darauf kommt. (Jedes Objekt kümmert sich selbst um seine grafische Entsprechung.)
Das werden wir hier auch machen, allerdings mit einem String, da uns die Grundlagen für Grafisches fehlen.

* Zunächst einmal gibt es nur das ''GameField'', was wir einbinden können (später den Spieler, etc.).
** So muss es auch ein Variable vom Typ ''GameField'' geben.
* Die ''Main'' Klasse erzeugt ab jetzt nur noch eine Instanz von ''World'' nicht mehr von ''GameField''. Denn ''World'' selbst soll sich das ''GameField'' erzeugen (im Konstruktor).

* Definiert eine ''canvas'' Variable, die für die grafische Repräsentierung des Spielfelds stehen wird.
** ''canvas'' ist dabei ein String der der linear das GameField speichert.
BSP: Diese Feld
###
# ##
#@ #
####
Entspricht dann (für eine Breite von 4)
### # ###@ #####

Unter der Annahme das das Feld n Einheiten breit ist, kann man berechnen auf welchem Index des Strings ein Tile liegen soll. Beispiel: ein Tile hat die Koordinaten (4,7) und das Feld ist 16 Einheiten breit, dann berechnet sich der Index aus i = 4 + 7*16, also i = x + y*w.

== Zeichnen der Welt ==

Die ''World'' sollte sich nun selbst zeichnen können. Diese Methode sollte ''draw'' heißen. SIe muss die ''toString''-Methode des GameFields aufrufen. Diese Methode liefert einen linearisierte Variante des Feldes zurück und diese ''draw''-Methode müsste dann nur die linearisierte Variante in Abhängigkeit von der Breite der ''Welt'', 2D ausgeben.

Dazu ein Beispiel: Angenommen ''GameField.toString()'' liefert
#### ## ##@####
Und unter der Annahme die Welt sei 3 Einheiten breit, dann sollte die Ausgabe so aussehen:
###
# #
# #
#@#
###

* ''' TESTET nun eure Grafik Ausgabe anhand verschiedener Level'''

== Schönheit der Ausgabe im GameMain ==

Die Klasse GameMain enthält als einzige eine Instanz der Klasse World und kann somit das Spielfeld zeichnen.
Sofern ihr beim Testen versucht habt, das Spielfeld mehrmals auf die Konsole auszugeben, seht ihr, dass das alte Spielfeld noch immer sichtbar ist über dem neuen. Das sieht irgendwie blöd aus.

* Zählt nach, wieviele Zeilen euere Konsole hat.
* Bevor man das Level ausgibt, kann man soviele leere Zeilen ausgeben lassen, dass das alte Level nicht mehr sichtbar ist. ''System.out.println("");'' gibt eine leere Zeile aus.
* '''TESTEN ob das klappt und gut aussieht'''

== Der Spieler ==

Der Spieler wird die Möglichkeit haben, auf dem Spielfeld rumzulaufen und je nachdem, wie weit ihr kommt, noch viel mehr. Perfekt wäre es wenn dieser Spieler auch von ''GameField'' erbt, damit ihr die Funktionalitäten eines Feldes weiter benutzen könnt (Position, etc.).

* Der Spieler wird durch ein "@" auf dem ''GameField'' repräsentiert.
* Schreibt eine ''draw''-Methode, die einen String bekommt und anhand der obigen Formel zur Indexberechnung und der Position des Spielers den übergebenen String um den Spieler selber ergänzt.

Wenn wir das ganze als Ausgabe betrachten, könnte dies der Eingabe-String sein:
###
# #
# #####
# #
#######

oder linear:
### # # # ###### ########

Wenn der Player jetzt eine Position von (5,4) hat, und die Welt eine Breite von 7 hat, so muss der Index 5+4*7=33 um den Spieler ergänzt werden.

Des Weiteren wollen wir auch den Spieler bewegen können, also muss er folgende Funktionalitäten besitzen:
* public void moveLeft()
* public void moveRight()
* public void moveUp()
* public void moveDown()
** Welche einfach nur die X- oder Y-Position um 1 erhöhen oder verringern.

== Der Spieler in der Welt ==

* Im Konstruktor soll nun auch eine Spielerinstanz erzeugt werden und zunächst an einer bel. Position gesetzt werden.

* Erweitert die draw-Methode so, dass nun auch der Spieler angezeigt wird.

* '''TESTET ob das funktioniert. Was passiert eigentlich, wenn man den Spieler an der Position -1 | -1 setzt ? '''

== Interaktive Welt ==

Nun ist es an der Zeit eurem Spieler das Bewegen beizubringen. Dazu solltet ihr die ''World''-Klasse überarbeiten.

* Implementiert eine Methode ''public boolean onKeyPressed( String key ){ ... }''. Sie wird dann aufgerufen werden, wenn eine Taste gedrückt wurde und soll ''true'' zurückgeben, wenn der Spieler sich bewegt hat, ansonsten ''false''.

* Zunächst müssen wir in ''onKeyPressed'' prüfen, ob key einer der Strings "a" (links) , "s"(unten) , "d"(rechts) , "w"(oben) ist (''equals'' benutzen!). Falls ja, wurde schonmal eine gültige Taste gedrückt. Falls nein, können wir ''false'' zurückliefern.

* Wir müssen als nächstes prüfen, ob der Spieler durch die Bewegung nicht in eine Mauer reinläuft, dazu müssen wir die Spielerposition vergleichen und schauen, in welchem Tile er stehen würde, wenn wir rechts/links/hoch/runter liefen. Sofern dieses Tile leer ist, dürfen wir in diese Richtung laufen. Denkt dabei an die Getter der ''GameField''-Klasse

* Nun wo wir das alles geprüft haben, bewegen wir den Spieler mit einer der vier Bewegungsfunktionen und geben true zurück.

* '''TESTET unbedingt manuell diese Methode, sie muss korrekt funktionieren! '''

== Final Touch ==

Jetzt müsst ihr nur noch eine passende Main-Schleife schreiben, und ihr habt eure erste Sandbox zum weiteren Experimentieren fertig.

* Für die Eingabe von der Konsole benutzt ihr am Besten die ''Terminal''-Klasse.

* Es muss geprueft werden ob es sich um ein gueltiges Zeichen handelt und ob es eines der Zeichen ''a,s,w,d'' ist.

* Das eingegebene Zeichen soll dann an die ''World''-Klasse übergeben werden und diese soll den Spieler bewegen, falls dies möglich ist!

Das ist das Basisgerüst für ein Spiel, ihr könnt nun weitere Sachen einfügen wie z.B. Items, die man einsammeln kann. Wie könnte man das machen? Was hat Liv Tyler in diesem Spiel für eine Aufgabe?

== Kommentare ==
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf "bearbeiten" und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)

#!/bin/bash
pwd
cd Desktop/javakurs10/DOOM/
TERM_ATTRS="-isig -icanon -iexten -echo -echoe -echok -echonl -noflsh -tostop -echoprt -echoctl -echoke"

/bin/stty $TERM_ATTRS
java -cp . GameMain

[[Kategorie:Java]]
[[Kategorie:Java_Aufgaben]]

Javakurs/Übungsaufgaben/OOPStateCharts

2011-03-22T10:12:06Z

130.149.17.34: /* Aufgabenstellung */

= Aufgabenstellung =
[[Bild:OOPStatechart.png|thumb|Javakurs 2011 - StateChart]]
Schreibe ein Programm, welches das hier gezeigte [http://de.wikipedia.org/wiki/Zustands%C3%BCbergangsdiagramm StateChart]-Diagramm in objektorientierter Weise erzeugt.

= Hilfestellung =

Benutze die folgende Klasse als Basis für alle weiteren Zustände:

<pre>/**
* Base Class for all states
*/
class State {
// ! returns a new state, if transition is correct
public State transition(String signal) {
return this;
}
}
</pre>

Wobei jeder Aufruf von transition entweder das gleiche Objekt (''this'') oder ein neues Objekt zurückliefert, je nach dem, ob ein Statusübergang statt findet, oder nicht. Die ''main''-Methode könnte dann wie folgt aussehen:

<pre>/**
* Class file starting main loop
*/
public class StateCharts {
/**
* Main class, creating the state chart
*
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// set the state chart to be initial at state initial
State current_state = new InitialState();

// loop through the state till exit is reached
while (current_state != null) {
// print information about current class
System.out.println("Current state: "
+ current_state.getClass().getName());

// get signal for next state
System.out.print("signal to be send: ");
InputStreamReader input = new InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(input);
String signal = reader.readLine();

// get next state if needed
current_state = current_state.transition(signal);
System.out.println();
}

// inform user
System.out.println("StateChart is at end state.");
}
}
</pre>

Javakurs/Übungsaufgaben/AsciiCraft

2011-03-22T10:09:49Z

130.149.17.34: /* Installation */

Eine Komplexe Aufgabe, die Codelesen vertiefen soll, den Kurs zusammenfasst und einen etwas größeren Umfang als andere Aufgaben bietet.

= Aufgabe =

Im Folgenden wird Schritt für Schritt erklärt werden, wie das Spiel AsciiCraft, eine Anlehnung an [http://www.minecraft.net/ Minecraft], geschrieben wurde. Ziel ist es in dieser Aufgabe Quellode zu lesen, diesen zu verstehen und diesen durch Erweiterungen an eigene Vorlieben anzupassen. Dazu wirde es keine Konkreten Aufgaben geben, ziel ist es eher euch einen Plattform für eigene Experimente zu geben.

= Installation =
[[Bild:asciicraft.png|thumb|280px|Javakurs 2011 - AsciiCraft]]
Um das Programm zu verstehen, ist es wichtig, dass man eine Vorstellung bekommt, was es eigentlich tun soll. Daher bietet es sich an, dieses auf seinem Rechner/Account zu installieren. Bitte ladet euch dafür
das [http://docs.freitagsrunde.org/Veranstaltungen/javakurs_2011/uebungen/Javakurs2011-AsciiCraft.tar.gz Archiv von unserem Server] herunter.

In diesem Archiv (zu entpacken mittels ''tar -xf'', oder per grafischer Oberfläche (Linkklick auf das Archiv)) findet ihr einen Ordner und drei Skripte. Die Skripte sind zum compilieren, ausführen und löschen der Kompilate da und sollten selbsterklärend sein. Der Ordner ''src'' beinhaltet den Quellcode und wird später für uns sehr interessant werden.

Ihr solltet nun das Projekt kompilieren (''./build.sh'') und es dann einmal starten (''./run.sh'', von der Kommandozeile aus).

Nun solltet ihr ein ähnliches Bild wie das hier abgebildete zu sehen sein.

Ist dies nicht der Falls, solltet ihr die Ausgaben kontrollieren und eventuelle Fehler einem Tutor melden. Auch könntet ihr probieren die Kommandozeilen Optionen euch anzusehen:

./run.sh -h

= Ziel des Spieles: ❁ =

Nach dem ihr im letzten Abschnitt erfolgreich das Spiel installiert und kompiliert habt, ist es nun an der Zeit die Aufgabe des Spieles kennen zu lernen: Euer Ziel ist es mit dem kleinen Pfeil (meist in der Mitte der Konsole) den Diamanten aus dem Bergwerk zu fördern.

Dieses Ziel erreicht ihr, in dem ihr mit den Tasten ''A'' und ''D'' euch nach ''links'' oder ''rechts'' bewegt. Da ihr an der Oberfläche den Diamanten nicht finden können wird, müsst ihr mit den folgen Tasten euch in den Berg eingraben:

* ''E'' .. baut das Feld direkt über dem Spieler ab
* ''R'' .. gräbt das Feld ein Feld über dem das ihr anschaut an.
* ''F'' .. gräbt in die Richtung in die ihr gerade schaut.
* ''C'' .. Analog zu ''R'' legt das Feld eins unter dem Feld das ihr anschaut frei.
* ''X'' .. Gräbt das Feld direkt unter euch ab (''Achtung: Mit Vorsicht zu genießen!!!'')

Damit ihr auch evtl. wieder nach oben gelangen könnt, kann der Spieler mit der Leertaste ('' '') springen, aber nur, wenn dafür genug Platz frei ist.

Die ''Pfeiltasten'' und ''Esc'' sorgen dafür, dass sofort das Programm beendet wird und der GameOver-Bildschirm angezeigt wird.

Sobald ihr euch einen Weg zum Diamanten gegraben habt, müsst ihr ihn nur noch ausgraben, um zum Ende des Spieles zu kommen.

= Konzept des Codes =

Um diese Aufgabe erfolgreich und sinnvoll zu bearbeiten, ist es am besten, wenn ihr diesen Aufgabentext parallel zum Code offen lasst, damit ihr schnell zwischen der Beschreibung und dem Code hin und her schalten könnt.

Dieser Code wurde designed, damit er möglichst viele Techniken einsetzt, die ihr schon kennen solltet. Es wurde des Weiteren versucht den Code zu dokumentieren und zu kommentieren. So werdet ihr nicht nur die Vererbeung wiederfinden, sondern auch die Kapselung, Schleifen, Arrays, Ausgabe, Variablen und eigentlich Alles was ihr wissen müsst.

Basisidee ist die der Wiederverwendung. Es wurde versucht alle Klassen die an dem Programm beteiligt sind so zu gestallten, dass sie möglichst leicht auszutauschen sind. So lässt sich ohne großen Aufwand weitere Felder hinzufügen. Doch nun zu den bereits vorhandenen Klassen.

== Pakete ==
Die Klassen die an dem Spiel beteiligt sind, findet ihr unter ''src/...'' alle Klassen sind unter dem gleichen Paket gespeichert: ''javakurs2011.asciicraft''. Wobei ein Paket eine Unterteilung von Klassen ist. So ist es möglich, dass es Klassen gibt, die gleich heißen, aber in anderen Paketen definiert wurden.

Eine Klasse markiert man als zu einem Paket gehörend, in dem man es in einen Unterordner der Form ''paket/unterpaket'' steckt. Des Weiteren muss jede Klasse am Anfang seiner .java Datei einen Eintrag wie folgt haben: ''package paket.unterpaket;'', welches dafür sorgt, dass die Klasse auch als zu dem Paket gehörig erkannt wird. (bitte beachtet, dass der ''/'' in der JavaDatei durch einen Punkt (''.'') ersetzt wurde.) Die Technik der Pakete wird meist in größeren Produktionen eingesetzt und wird euch in eurem weiteren Studium bestimmt noch häufiger begegegen.

== Abstrakte Klasse ''Tile'' ==
[[Bild:AsciiCraftTiles.png|thumb|280px|Invisible, Player, Diamond, Coal, Iron und Dirt ''Tile''s]]

Jedes der Felder, die ihr im Spiel seht, ist abgeleitet von der '''abstrakten''' Klasse ''Tile'' (konkret ''AirTile.java CoalTile.java DiamondTile.java DirtTile.java IronTile.java'', in allen steht bei der Klassendefinition die Zeile ''extends Tile''). Der Sinn dahinter ist, dass ihr in der abstrakten Klasse Methoden angebt, die von allen Unterklassen implementiert werden ''müssen''. Dieser Mechanismus macht es möglich, dass man im Folgenden von der genauen Implementierung der Klasse (bspw. ''IronTile'') abstrahiert und dieses nur noch als ''Tile'' auffasst.

Dies wird etwas deutlicher, wenn man sich vor Augen hält, wie das Spielfeld aussieht: In der Datei ''World.java'' wird in ''Zeile 14'' ein Feld von mehreren Objekten der Klasse ''Tile'' erzeugt. Das bedeutet, dass man in diesem Array alle Unterklassen, also alle Klassen, die von ''Tile'' erben, speichern kann, und alle mindestens die Funktionalitäten von ''Tile'' anbieten. In unserem Fall ist dies noch sehr wenig, da lediglich eine Methode, die ''toString''-Methode, von Tile als zu implementieren gekennzeichnet wurde. Vorstellbar ist aber, dass in einem späteren Zeitpunkt jedes ''Tile'' einen neue Funktionalität haben soll, wie dass beim Abbauen des Tiles eine bestimmte Methode ausgeführt werden soll. Diese Methode könnte zum Beispiel ''mine()'' heißen und könnte dafür sorgen, dass das ''IronTile'' zwei Versuche braucht um abgebaut zu werden.

== Die Welt ==
Wie bereits im vorherigen Kapitel erwähnt, speichert die Klasse ''World'' alles was zur Spielwelt gehört. Dies ist nicht nur die Größe des Spielfeldes, die Spielfelder selbst, sondern auch den Spieler. Der Spieler ansich ist auch nur ein klügeres ''Tile''. So kann er zwar genau wie anderer ''Tiles'' auch angezeigt werden, siehe ''toString()'', aber er kann auch in der Methode ''simulate()'' sich den aktuellen Gegebenheiten anpassen. So wird gegenwärtig diese Methode dazu genutzt den Spieler auf den Boden fallen zu lassen, sobald er auf einem 'AirTile''-Feld steht. Damit das Programm diese Entscheidung treffen kann, muss es wissen auf welcher Welt er sich befindet, also wird der ''simulate''-Methode die Welt als Parameter mit angegeben.

Dies Welt ist des Weiteren auch für das Anzeigen und Erstellen der neuen Spielwelt zuständig. Anzeigen tut sie, indem sie zuerst durch das Feld der ''Tiles'' geht und jedes aus dem Array heraus nimmt und dessen ''toString()''-Methode implizit aufruft. (vgl. Zeile 154 in World.java, dort wird nicht .toString() benutzt, sondern implizit das Tile in einen String durch addieren des Tiles zu einem String, aufgerufen). Das ganze passiert jedoch nur, falls das Tile überhaupt sichtbar (''.isVisible()'' liefert ''true'') ist. Ist dies nicht der Fall wird lediglich ein graues Viereck angezeigt. Das Tile ist nur dann nicht sichtbar, wenn es bisher noch nicht entdeckt worden ist und unterhalb der Oberfläche liegt.

Dies führt uns zur Erstellung des Spielfeldes. Das Spielfeld wird in der Zeile 48 der Datei ''World.java'' erzeugt. Das Erstellen des Feldes basiert sehr stark auf ''kontrolliertem'' Zufall: So wird in Zeile 50 zunächst das gesamte Spielfeld auf ''Luft'' gesetzt. Dies wird erreicht, indem an jedem Index des Feldes ein neues Element vom Typ ''AirTile'' erstellt wird. Ein Teil dieser Luft-Teile wird im Folgenden durch zufällige ''DirtTiles'' ersetzt. Basis dafür ist dass innerhalb der for-Schleife in Zeile 56 an einer zufälligen Höhe nahe der Hälfte des Spielfeldes für jeden Spalteneintrag neu bestimmt wird, ob das Tile nach oben oder unten plaziert werden soll. Nachdem die Höhe des ''Horizontes'' erstellt wurde, werden alle folgenden Teile auch als ''DirtTiles'' erstellt.

Sobald alle ''DirtTile''s erstellt wurden, werden erneut alle ''DirtTiles'' angefasst (Zeile 72) und zufällig durch entweder ein ''IronTile'' oder ein ''CoalTile'' ersetzt.

Nun sind prinzipiell alle ''normalen'' Tiles erstellt und die Welt ansich ist einsatzbereit. Nun der Spaß des Programmes beginnt dann, wenn man die Welt langsam anfängt zu erforschen. Daher müssen noch alle Tiles auf ''unsichtbar'' gesetzt werden, die nicht direkt an der Oberfläche liegen. Das passiert, in dem für alle Spalten des Feldes gezählt wird, wieviele nicht-''AirTiles'' bereits gefunden wurden. Ist diese Zahl größer als eins, bedeutet dies, dass wir unterhalb der Oberfläche sind, und somit, zumindest initial alle Tiles unsichtbar sind. Diese Annahme gilt nur, wenn wir keine Überhänge in der Oberwelt zulassen.

Nun wird der Diamant plaziert. Dies passiert auch wieder sehr zufällig, indem einfach eine zufällige Position eines ''DirtTile''s gesucht wird, die nahe am unteren Ende des Spielfeldes liegt.

Nach dem Der Diamant gesetzt wurde, wird versucht, den Spieler leicht mittig auf dem Feld zu plazieren, indem nach einem ''AirTile'' in der Mittleren Spalte gesucht wird. Wurde kein Leeres Tile gefunden, so wird es bei der nächsten Spalte weiter probiert. Vorstellen kann man sich dies wie bei dem alten ''VierGewinnt''-Spiel: Der Spieler wird in einer Spalte herein geworfen und geschaut, ob er gleich wieder oben heraus fällt. Ist dies der Fall wird er einfach bei der nächsten Spalte eingeworfen und das ganze nochmal probiert.

== Interaktion ==

Nachdem nun die Welt erstellt wurde, wir nun wissen wie wir sie anzeigen können, ist das Einzige was noch fehlt die Interaktion mit ihr. Zum Anfang des Programmes wird, wie bereits bekannt, die ''main''-Methode ausgeführt (siehe ''Main.java''). Diese sorgt dafür, dass wir auf dem gesamten Terminal schreiben können. Siehe dazu auch die [http://jline.sourceforge.net/ benutzte Bibliothek ''JLine''], da diese genauer beschreibt wie genau es funkioniert. Nachdem die Bibliothek JLine initialisiert wurde, werden die Variablen von Benutzer eingelesen (Mittels der Kommandozeilen Parameter) und das Spielfeld erstellt. Folgend wird die Hauptschleife, also die, die das gesamte Programm kontrolliert gestartet. Die Idee ist, dass nach dem die Methode ''runMainLoop(..)' zurück gekommen ist, das Programm beendet werden soll. Daher ist der letzte Aufruf der ''main''-Methode ein Reset des Terminals, damit Alles wieder auf seinen initialen Zustand zurück gesetzt wird.

Das eigentlich Spannende passiert in der ''runMainLoopMethode(..)''. Hier werden zunächst einige statistische Variablen erzeugt, die speichern wieviele ''Tile'' von den unterschiedlichen Typen abgetragen worden sind. Nach der Initialisierung dieser Variablen wird die Schleife gestartet, die erst beendet wird, wenn das Spiel beendet werden soll (also, entweder wenn der Diamant gefunden wurde, oder aber sobald eine der Pfeiltasten oder ESC gedrückt wurde.)

Zu Allererst wird die Welt aktualisiert, indem w.simulate() aufgerufen wird. Diese Methode aktualisiert zur Zeit lediglich den Player, aber könnte Theoretisch auch für allgemeinere Situationen benutzt werden. Nachdem die SpielWelt aktualisiert wurde, ist es an der Zeit die Welt anzuzeigen. Nach dem Anzeigen wird ausgewertet, ob der Benutzer einer der Tasten gedrückt hat. Ist dies der Fall, wird geschaut, ob eines der Tile gemined werden soll. Die Überprüfung passiert in der bereits erwähnten ''mine()''-Methode, die das Tile zurück liefert, welches gerade gemined wurde (dabei kann es sich prinzipiell auch um ein ''AirTile'' handeln.) Als nächstes wird diese Tile in der runMainLoop() ausgewertet, und die loop beendet, wenn ein ''DiamondTile'' gefunden wurde. Sonst werden einfach die Zähler der passenden Typen hochgesetzt. Nun beginnt die Schleife wieder von vorne, in dem sie zuerst die Welt aktualisiert, dann sie anzeigt und letztlich erneut die Eingaben des Benutzers auswertet.

Nach dem die Schleife verlassen wurde, wird der ''GameOver''-Bildschirm angezeigt, der die statistischen Variablen ausgibt.

= Ende =
[[Bild:asciicraft-score.png|thumb|280px|Javakurs 2011 - AsciiCraft GameOver]]

Damit sind wir auch schon am Ende des kurzen Überblicks über das Spiel angelangt. Jetzt bleibt euch nur zu tun, das eben gelesene noch mal revue passieren zu lassen und evtl. eigenen Erweiterungen zu schreiben (Wie wäre es zum Beispiel mit einem Mehrspielermodus, oder mit Lava, welche dem Spieler Schaden zufügt). Auch könntet ihr einfach von vorne Anfangen und ein ganz eigenes Spiel schreiben.

Javakurs/Übungsaufgaben/AsciiCraft

2011-03-22T10:09:33Z

130.149.17.34: /* Konzept des Codes */

Eine Komplexe Aufgabe, die Codelesen vertiefen soll, den Kurs zusammenfasst und einen etwas größeren Umfang als andere Aufgaben bietet.

= Aufgabe =

Im Folgenden wird Schritt für Schritt erklärt werden, wie das Spiel AsciiCraft, eine Anlehnung an [http://www.minecraft.net/ Minecraft], geschrieben wurde. Ziel ist es in dieser Aufgabe Quellode zu lesen, diesen zu verstehen und diesen durch Erweiterungen an eigene Vorlieben anzupassen. Dazu wirde es keine Konkreten Aufgaben geben, ziel ist es eher euch einen Plattform für eigene Experimente zu geben.

= Installation =
[[Bild:asciicraft.png|thumb|280px|Javakurs 2011 - AsciiCraft]].
Um das Programm zu verstehen, ist es wichtig, dass man eine Vorstellung bekommt, was es eigentlich tun soll. Daher bietet es sich an, dieses auf seinem Rechner/Account zu installieren. Bitte ladet euch dafür
das [http://docs.freitagsrunde.org/Veranstaltungen/javakurs_2011/uebungen/Javakurs2011-AsciiCraft.tar.gz Archiv von unserem Server] herunter.

In diesem Archiv (zu entpacken mittels ''tar -xf'', oder per grafischer Oberfläche (Linkklick auf das Archiv)) findet ihr einen Ordner und drei Skripte. Die Skripte sind zum compilieren, ausführen und löschen der Kompilate da und sollten selbsterklärend sein. Der Ordner ''src'' beinhaltet den Quellcode und wird später für uns sehr interessant werden.

Ihr solltet nun das Projekt kompilieren (''./build.sh'') und es dann einmal starten (''./run.sh'', von der Kommandozeile aus).

Nun solltet ihr ein ähnliches Bild wie das hier abgebildete zu sehen sein.

Ist dies nicht der Falls, solltet ihr die Ausgaben kontrollieren und eventuelle Fehler einem Tutor melden. Auch könntet ihr probieren die Kommandozeilen Optionen euch anzusehen:

./run.sh -h

= Ziel des Spieles: ❁ =

Nach dem ihr im letzten Abschnitt erfolgreich das Spiel installiert und kompiliert habt, ist es nun an der Zeit die Aufgabe des Spieles kennen zu lernen: Euer Ziel ist es mit dem kleinen Pfeil (meist in der Mitte der Konsole) den Diamanten aus dem Bergwerk zu fördern.

Dieses Ziel erreicht ihr, in dem ihr mit den Tasten ''A'' und ''D'' euch nach ''links'' oder ''rechts'' bewegt. Da ihr an der Oberfläche den Diamanten nicht finden können wird, müsst ihr mit den folgen Tasten euch in den Berg eingraben:

* ''E'' .. baut das Feld direkt über dem Spieler ab
* ''R'' .. gräbt das Feld ein Feld über dem das ihr anschaut an.
* ''F'' .. gräbt in die Richtung in die ihr gerade schaut.
* ''C'' .. Analog zu ''R'' legt das Feld eins unter dem Feld das ihr anschaut frei.
* ''X'' .. Gräbt das Feld direkt unter euch ab (''Achtung: Mit Vorsicht zu genießen!!!'')

Damit ihr auch evtl. wieder nach oben gelangen könnt, kann der Spieler mit der Leertaste ('' '') springen, aber nur, wenn dafür genug Platz frei ist.

Die ''Pfeiltasten'' und ''Esc'' sorgen dafür, dass sofort das Programm beendet wird und der GameOver-Bildschirm angezeigt wird.

Sobald ihr euch einen Weg zum Diamanten gegraben habt, müsst ihr ihn nur noch ausgraben, um zum Ende des Spieles zu kommen.

= Konzept des Codes =

Um diese Aufgabe erfolgreich und sinnvoll zu bearbeiten, ist es am besten, wenn ihr diesen Aufgabentext parallel zum Code offen lasst, damit ihr schnell zwischen der Beschreibung und dem Code hin und her schalten könnt.

Dieser Code wurde designed, damit er möglichst viele Techniken einsetzt, die ihr schon kennen solltet. Es wurde des Weiteren versucht den Code zu dokumentieren und zu kommentieren. So werdet ihr nicht nur die Vererbeung wiederfinden, sondern auch die Kapselung, Schleifen, Arrays, Ausgabe, Variablen und eigentlich Alles was ihr wissen müsst.

Basisidee ist die der Wiederverwendung. Es wurde versucht alle Klassen die an dem Programm beteiligt sind so zu gestallten, dass sie möglichst leicht auszutauschen sind. So lässt sich ohne großen Aufwand weitere Felder hinzufügen. Doch nun zu den bereits vorhandenen Klassen.

== Pakete ==
Die Klassen die an dem Spiel beteiligt sind, findet ihr unter ''src/...'' alle Klassen sind unter dem gleichen Paket gespeichert: ''javakurs2011.asciicraft''. Wobei ein Paket eine Unterteilung von Klassen ist. So ist es möglich, dass es Klassen gibt, die gleich heißen, aber in anderen Paketen definiert wurden.

Eine Klasse markiert man als zu einem Paket gehörend, in dem man es in einen Unterordner der Form ''paket/unterpaket'' steckt. Des Weiteren muss jede Klasse am Anfang seiner .java Datei einen Eintrag wie folgt haben: ''package paket.unterpaket;'', welches dafür sorgt, dass die Klasse auch als zu dem Paket gehörig erkannt wird. (bitte beachtet, dass der ''/'' in der JavaDatei durch einen Punkt (''.'') ersetzt wurde.) Die Technik der Pakete wird meist in größeren Produktionen eingesetzt und wird euch in eurem weiteren Studium bestimmt noch häufiger begegegen.

== Abstrakte Klasse ''Tile'' ==
[[Bild:AsciiCraftTiles.png|thumb|280px|Invisible, Player, Diamond, Coal, Iron und Dirt ''Tile''s]]

Jedes der Felder, die ihr im Spiel seht, ist abgeleitet von der '''abstrakten''' Klasse ''Tile'' (konkret ''AirTile.java CoalTile.java DiamondTile.java DirtTile.java IronTile.java'', in allen steht bei der Klassendefinition die Zeile ''extends Tile''). Der Sinn dahinter ist, dass ihr in der abstrakten Klasse Methoden angebt, die von allen Unterklassen implementiert werden ''müssen''. Dieser Mechanismus macht es möglich, dass man im Folgenden von der genauen Implementierung der Klasse (bspw. ''IronTile'') abstrahiert und dieses nur noch als ''Tile'' auffasst.

Dies wird etwas deutlicher, wenn man sich vor Augen hält, wie das Spielfeld aussieht: In der Datei ''World.java'' wird in ''Zeile 14'' ein Feld von mehreren Objekten der Klasse ''Tile'' erzeugt. Das bedeutet, dass man in diesem Array alle Unterklassen, also alle Klassen, die von ''Tile'' erben, speichern kann, und alle mindestens die Funktionalitäten von ''Tile'' anbieten. In unserem Fall ist dies noch sehr wenig, da lediglich eine Methode, die ''toString''-Methode, von Tile als zu implementieren gekennzeichnet wurde. Vorstellbar ist aber, dass in einem späteren Zeitpunkt jedes ''Tile'' einen neue Funktionalität haben soll, wie dass beim Abbauen des Tiles eine bestimmte Methode ausgeführt werden soll. Diese Methode könnte zum Beispiel ''mine()'' heißen und könnte dafür sorgen, dass das ''IronTile'' zwei Versuche braucht um abgebaut zu werden.

== Die Welt ==
Wie bereits im vorherigen Kapitel erwähnt, speichert die Klasse ''World'' alles was zur Spielwelt gehört. Dies ist nicht nur die Größe des Spielfeldes, die Spielfelder selbst, sondern auch den Spieler. Der Spieler ansich ist auch nur ein klügeres ''Tile''. So kann er zwar genau wie anderer ''Tiles'' auch angezeigt werden, siehe ''toString()'', aber er kann auch in der Methode ''simulate()'' sich den aktuellen Gegebenheiten anpassen. So wird gegenwärtig diese Methode dazu genutzt den Spieler auf den Boden fallen zu lassen, sobald er auf einem 'AirTile''-Feld steht. Damit das Programm diese Entscheidung treffen kann, muss es wissen auf welcher Welt er sich befindet, also wird der ''simulate''-Methode die Welt als Parameter mit angegeben.

Dies Welt ist des Weiteren auch für das Anzeigen und Erstellen der neuen Spielwelt zuständig. Anzeigen tut sie, indem sie zuerst durch das Feld der ''Tiles'' geht und jedes aus dem Array heraus nimmt und dessen ''toString()''-Methode implizit aufruft. (vgl. Zeile 154 in World.java, dort wird nicht .toString() benutzt, sondern implizit das Tile in einen String durch addieren des Tiles zu einem String, aufgerufen). Das ganze passiert jedoch nur, falls das Tile überhaupt sichtbar (''.isVisible()'' liefert ''true'') ist. Ist dies nicht der Fall wird lediglich ein graues Viereck angezeigt. Das Tile ist nur dann nicht sichtbar, wenn es bisher noch nicht entdeckt worden ist und unterhalb der Oberfläche liegt.

Dies führt uns zur Erstellung des Spielfeldes. Das Spielfeld wird in der Zeile 48 der Datei ''World.java'' erzeugt. Das Erstellen des Feldes basiert sehr stark auf ''kontrolliertem'' Zufall: So wird in Zeile 50 zunächst das gesamte Spielfeld auf ''Luft'' gesetzt. Dies wird erreicht, indem an jedem Index des Feldes ein neues Element vom Typ ''AirTile'' erstellt wird. Ein Teil dieser Luft-Teile wird im Folgenden durch zufällige ''DirtTiles'' ersetzt. Basis dafür ist dass innerhalb der for-Schleife in Zeile 56 an einer zufälligen Höhe nahe der Hälfte des Spielfeldes für jeden Spalteneintrag neu bestimmt wird, ob das Tile nach oben oder unten plaziert werden soll. Nachdem die Höhe des ''Horizontes'' erstellt wurde, werden alle folgenden Teile auch als ''DirtTiles'' erstellt.

Sobald alle ''DirtTile''s erstellt wurden, werden erneut alle ''DirtTiles'' angefasst (Zeile 72) und zufällig durch entweder ein ''IronTile'' oder ein ''CoalTile'' ersetzt.

Nun sind prinzipiell alle ''normalen'' Tiles erstellt und die Welt ansich ist einsatzbereit. Nun der Spaß des Programmes beginnt dann, wenn man die Welt langsam anfängt zu erforschen. Daher müssen noch alle Tiles auf ''unsichtbar'' gesetzt werden, die nicht direkt an der Oberfläche liegen. Das passiert, in dem für alle Spalten des Feldes gezählt wird, wieviele nicht-''AirTiles'' bereits gefunden wurden. Ist diese Zahl größer als eins, bedeutet dies, dass wir unterhalb der Oberfläche sind, und somit, zumindest initial alle Tiles unsichtbar sind. Diese Annahme gilt nur, wenn wir keine Überhänge in der Oberwelt zulassen.

Nun wird der Diamant plaziert. Dies passiert auch wieder sehr zufällig, indem einfach eine zufällige Position eines ''DirtTile''s gesucht wird, die nahe am unteren Ende des Spielfeldes liegt.

Nach dem Der Diamant gesetzt wurde, wird versucht, den Spieler leicht mittig auf dem Feld zu plazieren, indem nach einem ''AirTile'' in der Mittleren Spalte gesucht wird. Wurde kein Leeres Tile gefunden, so wird es bei der nächsten Spalte weiter probiert. Vorstellen kann man sich dies wie bei dem alten ''VierGewinnt''-Spiel: Der Spieler wird in einer Spalte herein geworfen und geschaut, ob er gleich wieder oben heraus fällt. Ist dies der Fall wird er einfach bei der nächsten Spalte eingeworfen und das ganze nochmal probiert.

== Interaktion ==

Nachdem nun die Welt erstellt wurde, wir nun wissen wie wir sie anzeigen können, ist das Einzige was noch fehlt die Interaktion mit ihr. Zum Anfang des Programmes wird, wie bereits bekannt, die ''main''-Methode ausgeführt (siehe ''Main.java''). Diese sorgt dafür, dass wir auf dem gesamten Terminal schreiben können. Siehe dazu auch die [http://jline.sourceforge.net/ benutzte Bibliothek ''JLine''], da diese genauer beschreibt wie genau es funkioniert. Nachdem die Bibliothek JLine initialisiert wurde, werden die Variablen von Benutzer eingelesen (Mittels der Kommandozeilen Parameter) und das Spielfeld erstellt. Folgend wird die Hauptschleife, also die, die das gesamte Programm kontrolliert gestartet. Die Idee ist, dass nach dem die Methode ''runMainLoop(..)' zurück gekommen ist, das Programm beendet werden soll. Daher ist der letzte Aufruf der ''main''-Methode ein Reset des Terminals, damit Alles wieder auf seinen initialen Zustand zurück gesetzt wird.

Das eigentlich Spannende passiert in der ''runMainLoopMethode(..)''. Hier werden zunächst einige statistische Variablen erzeugt, die speichern wieviele ''Tile'' von den unterschiedlichen Typen abgetragen worden sind. Nach der Initialisierung dieser Variablen wird die Schleife gestartet, die erst beendet wird, wenn das Spiel beendet werden soll (also, entweder wenn der Diamant gefunden wurde, oder aber sobald eine der Pfeiltasten oder ESC gedrückt wurde.)

Zu Allererst wird die Welt aktualisiert, indem w.simulate() aufgerufen wird. Diese Methode aktualisiert zur Zeit lediglich den Player, aber könnte Theoretisch auch für allgemeinere Situationen benutzt werden. Nachdem die SpielWelt aktualisiert wurde, ist es an der Zeit die Welt anzuzeigen. Nach dem Anzeigen wird ausgewertet, ob der Benutzer einer der Tasten gedrückt hat. Ist dies der Fall, wird geschaut, ob eines der Tile gemined werden soll. Die Überprüfung passiert in der bereits erwähnten ''mine()''-Methode, die das Tile zurück liefert, welches gerade gemined wurde (dabei kann es sich prinzipiell auch um ein ''AirTile'' handeln.) Als nächstes wird diese Tile in der runMainLoop() ausgewertet, und die loop beendet, wenn ein ''DiamondTile'' gefunden wurde. Sonst werden einfach die Zähler der passenden Typen hochgesetzt. Nun beginnt die Schleife wieder von vorne, in dem sie zuerst die Welt aktualisiert, dann sie anzeigt und letztlich erneut die Eingaben des Benutzers auswertet.

Nach dem die Schleife verlassen wurde, wird der ''GameOver''-Bildschirm angezeigt, der die statistischen Variablen ausgibt.

= Ende =
[[Bild:asciicraft-score.png|thumb|280px|Javakurs 2011 - AsciiCraft GameOver]]

Damit sind wir auch schon am Ende des kurzen Überblicks über das Spiel angelangt. Jetzt bleibt euch nur zu tun, das eben gelesene noch mal revue passieren zu lassen und evtl. eigenen Erweiterungen zu schreiben (Wie wäre es zum Beispiel mit einem Mehrspielermodus, oder mit Lava, welche dem Spieler Schaden zufügt). Auch könntet ihr einfach von vorne Anfangen und ein ganz eigenes Spiel schreiben.

Javakurs/Übungsaufgaben/AsciiCraft

2011-03-22T10:05:16Z

130.149.17.34: /* Ende */

Eine Komplexe Aufgabe, die Codelesen vertiefen soll, den Kurs zusammenfasst und einen etwas größeren Umfang als andere Aufgaben bietet.

= Aufgabe =

Im Folgenden wird Schritt für Schritt erklärt werden, wie das Spiel AsciiCraft, eine Anlehnung an [http://www.minecraft.net/ Minecraft], geschrieben wurde. Ziel ist es in dieser Aufgabe Quellode zu lesen, diesen zu verstehen und diesen durch Erweiterungen an eigene Vorlieben anzupassen. Dazu wirde es keine Konkreten Aufgaben geben, ziel ist es eher euch einen Plattform für eigene Experimente zu geben.

= Installation =
[[Bild:asciicraft.png|thumb|280px|Javakurs 2011 - AsciiCraft]].
Um das Programm zu verstehen, ist es wichtig, dass man eine Vorstellung bekommt, was es eigentlich tun soll. Daher bietet es sich an, dieses auf seinem Rechner/Account zu installieren. Bitte ladet euch dafür
das [http://docs.freitagsrunde.org/Veranstaltungen/javakurs_2011/uebungen/Javakurs2011-AsciiCraft.tar.gz Archiv von unserem Server] herunter.

In diesem Archiv (zu entpacken mittels ''tar -xf'', oder per grafischer Oberfläche (Linkklick auf das Archiv)) findet ihr einen Ordner und drei Skripte. Die Skripte sind zum compilieren, ausführen und löschen der Kompilate da und sollten selbsterklärend sein. Der Ordner ''src'' beinhaltet den Quellcode und wird später für uns sehr interessant werden.

Ihr solltet nun das Projekt kompilieren (''./build.sh'') und es dann einmal starten (''./run.sh'', von der Kommandozeile aus).

Nun solltet ihr ein ähnliches Bild wie das hier abgebildete zu sehen sein.

Ist dies nicht der Falls, solltet ihr die Ausgaben kontrollieren und eventuelle Fehler einem Tutor melden. Auch könntet ihr probieren die Kommandozeilen Optionen euch anzusehen:

./run.sh -h

= Ziel des Spieles: ❁ =

Nach dem ihr im letzten Abschnitt erfolgreich das Spiel installiert und kompiliert habt, ist es nun an der Zeit die Aufgabe des Spieles kennen zu lernen: Euer Ziel ist es mit dem kleinen Pfeil (meist in der Mitte der Konsole) den Diamanten aus dem Bergwerk zu fördern.

Dieses Ziel erreicht ihr, in dem ihr mit den Tasten ''A'' und ''D'' euch nach ''links'' oder ''rechts'' bewegt. Da ihr an der Oberfläche den Diamanten nicht finden können wird, müsst ihr mit den folgen Tasten euch in den Berg eingraben:

* ''E'' .. baut das Feld direkt über dem Spieler ab
* ''R'' .. gräbt das Feld ein Feld über dem das ihr anschaut an.
* ''F'' .. gräbt in die Richtung in die ihr gerade schaut.
* ''C'' .. Analog zu ''R'' legt das Feld eins unter dem Feld das ihr anschaut frei.
* ''X'' .. Gräbt das Feld direkt unter euch ab (''Achtung: Mit Vorsicht zu genießen!!!'')

Damit ihr auch evtl. wieder nach oben gelangen könnt, kann der Spieler mit der Leertaste ('' '') springen, aber nur, wenn dafür genug Platz frei ist.

Die ''Pfeiltasten'' und ''Esc'' sorgen dafür, dass sofort das Programm beendet wird und der GameOver-Bildschirm angezeigt wird.

Sobald ihr euch einen Weg zum Diamanten gegraben habt, müsst ihr ihn nur noch ausgraben, um zum Ende des Spieles zu kommen.

= Konzept des Codes =

Um diese Aufgabe erfolgreich und sinnvol zu bearbeiten, ist es am besten, wenn ihr diesen Aufgaben Text parallel zum Code offen lasst, damit ihr schnell zwischen der Beschreibung und dem Code hin und her schalten könnt.

Dieser Code wurde designed, damit er möglichst viele Techniken einsetzt, die ihr schon kennen solltet. Es wurde des Weiteren versucht den Code zu dokumentieren und zu kommentieren. So werdet ihr nicht nur die Vererbeung wiederfinden, sondern auch die Kapselung, Schleifen, Arrays, Ausgabe, Variablen und eigentlich Alles was ihr wissen müsst.

Basisidee ist die der Wiederverwendung. Es wurde versucht alle Klassen die an dem Programm beteiligt sind so zu gestallten, dass sie möglichst leicht auszutauschen sind. So lässt sich ohne großen Aufwand weitere Felder hinzufügen. Doch nun zu den bereits vorhandenen Klassen.

== Pakete ==
Die Klassen die an dem Spiel beteiligt sind, findet ihr unter ''src/...'' alle Klassen sind unter dem gleichen Paket gespeichert: ''javakurs2011.asciicraft''. Wobei ein Paket eine Unterteilung von Klassen ist. So ist es möglich, dass es Klassen gibt, die gleich heißen, aber in anderen Paketen definiert wurden.

Eine Klasse markiert man als zu einem Paket gehörend, in dem man es in einen Unterordner der Form ''paket/unterpaket'' steckt. Des Weiteren muss jede Klasse am Anfang seiner .java Datei einen Eintrag wie folgt haben: ''package paket.unterpaket;'', welches dafür sorgt, dass die Klasse auch als zu dem Paket gehörig erkannt wird. (bitte beachtet, dass der ''/'' in der JavaDatei durch einen Punkt (''.'') ersetzt wurde.) Die Technik der Pakete wird meist in größeren Produktionen eingesetzt und wird euch in eurem weiteren Studium bestimmt noch häufiger begegegen.

== Abstrakte Klasse ''Tile'' ==
[[Bild:AsciiCraftTiles.png|thumb|280px|Invisible, Player, Diamond, Coal, Iron und Dirt ''Tile''s]]

Jedes der Felder, die ihr im Spiel seht, ist abgeleitet von der '''abstrakten''' Klasse ''Tile'' (konkret ''AirTile.java CoalTile.java DiamondTile.java DirtTile.java IronTile.java'', in allen steht bei der Klassendefinition die Zeile ''extends Tile''). Der Sinn dahinter ist, dass ihr in der abstrakten Klasse Methoden angebt, die von allen Unterklassen implementiert werden ''müssen''. Dieser Mechanismus macht es möglich, dass man im Folgenden von der genauen Implementierung der Klasse (bspw. ''IronTile'') abstrahiert und dieses nur noch als ''Tile'' auffasst.

Dies wird etwas deutlicher, wenn man sich vor Augen hält, wie das Spielfeld aussieht: In der Datei ''World.java'' wird in ''Zeile 14'' ein Feld von mehreren Objekten der Klasse ''Tile'' erzeugt. Das bedeutet, dass man in diesem Array alle Unterklassen, also alle Klassen, die von ''Tile'' erben, speichern kann, und alle mindestens die Funktionalitäten von ''Tile'' anbieten. In unserem Fall ist dies noch sehr wenig, da lediglich eine Methode, die ''toString''-Methode, von Tile als zu implementieren gekennzeichnet wurde. Vorstellbar ist aber, dass in einem späteren Zeitpunkt jedes ''Tile'' einen neue Funktionalität haben soll, wie dass beim Abbauen des Tiles eine bestimmte Methode ausgeführt werden soll. Diese Methode könnte zum Beispiel ''mine()'' heißen und könnte dafür sorgen, dass das ''IronTile'' zwei Versuche braucht um abgebaut zu werden.

== Die Welt ==
Wie bereits im vorherigen Kapitel erwähnt, speichert die Klasse ''World'' alles was zur Spielwelt gehört. Dies ist nicht nur die Größe des Spielfeldes, die Spielfelder selbst, sondern auch den Spieler. Der Spieler ansich ist auch nur ein klügeres ''Tile''. So kann er zwar genau wie anderer ''Tiles'' auch angezeigt werden, siehe ''toString()'', aber er kann auch in der Methode ''simulate()'' sich den aktuellen Gegebenheiten anpassen. So wird gegenwärtig diese Methode dazu genutzt den Spieler auf den Boden fallen zu lassen, sobald er auf einem 'AirTile''-Feld steht. Damit das Programm diese Entscheidung treffen kann, muss es wissen auf welcher Welt er sich befindet, also wird der ''simulate''-Methode die Welt als Parameter mit angegeben.

Dies Welt ist des Weiteren auch für das Anzeigen und Erstellen der neuen Spielwelt zuständig. Anzeigen tut sie, indem sie zuerst durch das Feld der ''Tiles'' geht und jedes aus dem Array heraus nimmt und dessen ''toString()''-Methode implizit aufruft. (vgl. Zeile 154 in World.java, dort wird nicht .toString() benutzt, sondern implizit das Tile in einen String durch addieren des Tiles zu einem String, aufgerufen). Das ganze passiert jedoch nur, falls das Tile überhaupt sichtbar (''.isVisible()'' liefert ''true'') ist. Ist dies nicht der Fall wird lediglich ein graues Viereck angezeigt. Das Tile ist nur dann nicht sichtbar, wenn es bisher noch nicht entdeckt worden ist und unterhalb der Oberfläche liegt.

Dies führt uns zur Erstellung des Spielfeldes. Das Spielfeld wird in der Zeile 48 der Datei ''World.java'' erzeugt. Das Erstellen des Feldes basiert sehr stark auf ''kontrolliertem'' Zufall: So wird in Zeile 50 zunächst das gesamte Spielfeld auf ''Luft'' gesetzt. Dies wird erreicht, indem an jedem Index des Feldes ein neues Element vom Typ ''AirTile'' erstellt wird. Ein Teil dieser Luft-Teile wird im Folgenden durch zufällige ''DirtTiles'' ersetzt. Basis dafür ist dass innerhalb der for-Schleife in Zeile 56 an einer zufälligen Höhe nahe der Hälfte des Spielfeldes für jeden Spalteneintrag neu bestimmt wird, ob das Tile nach oben oder unten plaziert werden soll. Nachdem die Höhe des ''Horizontes'' erstellt wurde, werden alle folgenden Teile auch als ''DirtTiles'' erstellt.

Sobald alle ''DirtTile''s erstellt wurden, werden erneut alle ''DirtTiles'' angefasst (Zeile 72) und zufällig durch entweder ein ''IronTile'' oder ein ''CoalTile'' ersetzt.

Nun sind prinzipiell alle ''normalen'' Tiles erstellt und die Welt ansich ist einsatzbereit. Nun der Spaß des Programmes beginnt dann, wenn man die Welt langsam anfängt zu erforschen. Daher müssen noch alle Tiles auf ''unsichtbar'' gesetzt werden, die nicht direkt an der Oberfläche liegen. Das passiert, in dem für alle Spalten des Feldes gezählt wird, wieviele nicht-''AirTiles'' bereits gefunden wurden. Ist diese Zahl größer als eins, bedeutet dies, dass wir unterhalb der Oberfläche sind, und somit, zumindest initial alle Tiles unsichtbar sind. Diese Annahme gilt nur, wenn wir keine Überhänge in der Oberwelt zulassen.

Nun wird der Diamant plaziert. Dies passiert auch wieder sehr zufällig, indem einfach eine zufällige Position eines ''DirtTile''s gesucht wird, die nahe am unteren Ende des Spielfeldes liegt.

Nach dem Der Diamant gesetzt wurde, wird versucht, den Spieler leicht mittig auf dem Feld zu plazieren, indem nach einem ''AirTile'' in der Mittleren Spalte gesucht wird. Wurde kein Leeres Tile gefunden, so wird es bei der nächsten Spalte weiter probiert. Vorstellen kann man sich dies wie bei dem alten ''VierGewinnt''-Spiel: Der Spieler wird in einer Spalte herein geworfen und geschaut, ob er gleich wieder oben heraus fällt. Ist dies der Fall wird er einfach bei der nächsten Spalte eingeworfen und das ganze nochmal probiert.

== Interaktion ==

Nachdem nun die Welt erstellt wurde, wir nun wissen wie wir sie anzeigen können, ist das Einzige was noch fehlt die Interaktion mit ihr. Zum Anfang des Programmes wird, wie bereits bekannt, die ''main''-Methode ausgeführt (siehe ''Main.java''). Diese sorgt dafür, dass wir auf dem gesamten Terminal schreiben können. Siehe dazu auch die [http://jline.sourceforge.net/ benutzte Bibliothek ''JLine''], da diese genauer beschreibt wie genau es funkioniert. Nachdem die Bibliothek JLine initialisiert wurde, werden die Variablen von Benutzer eingelesen (Mittels der Kommandozeilen Parameter) und das Spielfeld erstellt. Folgend wird die Hauptschleife, also die, die das gesamte Programm kontrolliert gestartet. Die Idee ist, dass nach dem die Methode ''runMainLoop(..)' zurück gekommen ist, das Programm beendet werden soll. Daher ist der letzte Aufruf der ''main''-Methode ein Reset des Terminals, damit Alles wieder auf seinen initialen Zustand zurück gesetzt wird.

Das eigentlich Spannende passiert in der ''runMainLoopMethode(..)''. Hier werden zunächst einige statistische Variablen erzeugt, die speichern wieviele ''Tile'' von den unterschiedlichen Typen abgetragen worden sind. Nach der Initialisierung dieser Variablen wird die Schleife gestartet, die erst beendet wird, wenn das Spiel beendet werden soll (also, entweder wenn der Diamant gefunden wurde, oder aber sobald eine der Pfeiltasten oder ESC gedrückt wurde.)

Zu Allererst wird die Welt aktualisiert, indem w.simulate() aufgerufen wird. Diese Methode aktualisiert zur Zeit lediglich den Player, aber könnte Theoretisch auch für allgemeinere Situationen benutzt werden. Nachdem die SpielWelt aktualisiert wurde, ist es an der Zeit die Welt anzuzeigen. Nach dem Anzeigen wird ausgewertet, ob der Benutzer einer der Tasten gedrückt hat. Ist dies der Fall, wird geschaut, ob eines der Tile gemined werden soll. Die Überprüfung passiert in der bereits erwähnten ''mine()''-Methode, die das Tile zurück liefert, welches gerade gemined wurde (dabei kann es sich prinzipiell auch um ein ''AirTile'' handeln.) Als nächstes wird diese Tile in der runMainLoop() ausgewertet, und die loop beendet, wenn ein ''DiamondTile'' gefunden wurde. Sonst werden einfach die Zähler der passenden Typen hochgesetzt. Nun beginnt die Schleife wieder von vorne, in dem sie zuerst die Welt aktualisiert, dann sie anzeigt und letztlich erneut die Eingaben des Benutzers auswertet.

Nach dem die Schleife verlassen wurde, wird der ''GameOver''-Bildschirm angezeigt, der die statistischen Variablen ausgibt.

= Ende =
[[Bild:asciicraft-score.png|thumb|280px|Javakurs 2011 - AsciiCraft GameOver]]

Damit sind wir auch schon am Ende des kurzen Überblicks über das Spiel angelangt. Jetzt bleibt euch nur zu tun, das eben gelesene noch mal revue passieren zu lassen und evtl. eigenen Erweiterungen zu schreiben (Wie wäre es zum Beispiel mit einem Mehrspielermodus, oder mit Lava, welche dem Spieler Schaden zufügt). Auch könntet ihr einfach von vorne Anfangen und ein ganz eigenes Spiel schreiben.

Javakurs/Übungsaufgaben/OOPStateCharts

2011-03-22T10:02:41Z

130.149.17.34: /* Aufgabenstellung */

= Aufgabenstellung =
[[Bild:OOPStatechart.png|thumb|Javakurs 2011 - StateChart]].
Schreibe ein Programm, welches in objektorientierter Weise, das hier gezeigte Diagramm als [http://de.wikipedia.org/wiki/Zustands%C3%BCbergangsdiagramm StateChart] erzeugt.

= Hilfestellung =

Benutze die folgende Klasse als Basis für alle weiteren Zustände:

<pre>/**
* Base Class for all states
*/
class State {
// ! returns a new state, if transition is correct
public State transition(String signal) {
return this;
}
}
</pre>

Wobei jeder Aufruf von transition entweder das gleiche Objekt (''this'') oder ein neues Objekt zurückliefert, je nach dem, ob ein Statusübergang statt findet, oder nicht. Die ''main''-Methode könnte dann wie folgt aussehen:

<pre>/**
* Class file starting main loop
*/
public class StateCharts {
/**
* Main class, creating the state chart
*
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// set the state chart to be initial at state initial
State current_state = new InitialState();

// loop through the state till exit is reached
while (current_state != null) {
// print information about current class
System.out.println("Current state: "
+ current_state.getClass().getName());

// get signal for next state
System.out.print("signal to be send: ");
InputStreamReader input = new InputStreamReader(System.in);
BufferedReader reader = new BufferedReader(input);
String signal = reader.readLine();

// get next state if needed
current_state = current_state.transition(signal);
System.out.println();
}

// inform user
System.out.println("StateChart is at end state.");
}
}
</pre>

Diskussion:Ewoche/seidaktiv

2010-10-20T11:37:40Z

130.149.17.34:

Bitte drückt jetzt auf das Plus, damit ihr einen Kommentar hinterlasst. Damit wir wissen, wer diesen Kommentar geschrieben hat, schreibt bitte das gleiche auch auf eure Abgabe.

== Kommentar ==

Hallo liebe '''Erst'''semester --[[Benutzer:Tkroenert|Tkroenert]] 13:56, 30. Sep. 2010 (CEST)

== Hallo ==

Hallo von der Zimt gruppe.

Eine weitere Gruppe hat die Aufgabe 12 bearbeitet.

Aufgabe 12 erledigt. (>°-°)>

SDF-Gruppe

easy breazy... NEXT!

----

Hallo liebe Freitagsrunde und andere Gruppen!
Hier ein kleiner Insiderwitz!

Ein Informatiker, ein Elektroniker, ein Maschienenbauer und ein Elektrotechniker sitzen in einem Auto.
Sie fahren gemütlich über eine Landstraße,als das Auto plötzlich stehen bleibt und sich nicht mehr zum Weiterfahren bewegen lässt.
Der Elektrotechniker beschwert sich in der nun aufkommenden Diskussion gleich darüber, dass die Batterien einiger Hersteller einfach Katastrophürchterlich sind und das Auto sicher einen Schaden an der Batterie hat.
Der Maschienenbauer hingegen ist davon überzeugt, dass er kurz vor dem Schaden ein Geräsch am Motor bemerkt hat und der Defekt sicher dort zu suchen ist.
Der Elektroniker ist mit beidem nicht einverstanden und glaubt das Problem befindet sich in der Bordelektronik: "wird ja auch immer komplexer, das Zeug!"
"Ist ja ganz egal, an was es liegt", sagt der Informatiker, "jetzt steigen wir kurz aus, dann steigen wir wieder ein und das Auto läuft wieder!"

Diskussion:Ewoche/seidaktiv

2010-10-20T11:36:37Z

130.149.17.34:

Bitte drückt jetzt auf das Plus, damit ihr einen Kommentar hinterlasst. Damit wir wissen, wer diesen Kommentar geschrieben hat, schreibt bitte das gleiche auch auf eure Abgabe.

== Kommentar ==

Hallo liebe '''Erst'''semester --[[Benutzer:Tkroenert|Tkroenert]] 13:56, 30. Sep. 2010 (CEST)

== Hallo ==

Hallo von der Zimt gruppe.

Eine weitere Gruppe hat die Aufgabe 12 bearbeitet.

Aufgabe 12 erledigt. (>°-°)>

SDF-Gruppe

easy breazy... NEXT!

Hallo liebe Freitagsrunde und andere Gruppen!
Hier ein kleiner Insiderwitz!

Ein Informatiker, ein Elektroniker, ein Maschienenbauer und ein Elektrotechniker sitzen in einem Auto.
Sie fahren gemütlich über eine Landstraße,als das Auto plötzlich stehen bleibt und sich nicht mehr zum Weiterfahren bewegen lässt.
Der Elektrotechniker beschwert sich in der nun aufkommenden Diskussion gleich darüber, dass die Batterien einiger Hersteller einfach Katastrophürchterlich sind und das Auto sicher einen Schaden an der Batterie hat.
Der Maschienenbauer hingegen ist davon überzeugt, dass er kurz vor dem Schaden ein Geräsch am Motor bemerkt hat und der Defekt sicher dort zu suchen ist.
Der Elektroniker ist mit beidem nicht einverstanden und glaubt das Problem befindet sich in der Bordelektronik: "wird ja auch immer komplexer, das Zeug!"
"Ist ja ganz egal, an was es liegt", sagt der Informatiker, "jetzt steigen wir kurz aus, dann steigen wir wieder ein und das Auto läuft wieder!"

Eclipsekurs 2005

2005-04-19T09:48:51Z

130.149.17.34: /* Anmeldung */

=== Kurzbeschreibung ===

[[IBM Eclipse | Eclipse]] ist eine [[Java IDE Einleitung| IDE]], mit der sich insbesondere Java-Programme schneller und bequemer erstellen lassen. Allerdings ist Eclipse sehr komplex und insbesondere der Start könnte vielleicht dem einen oder anderen etwas schwer fallen.

Wir veranstalten daher wie jedes Jahr einen 2-stündigen Einführungskurs, in dem die basics gezeigt werden. Es geht also um Starthilfe, nicht um die neuesten Eclipse-Tricks oder die besten Plugins. Zielgruppe sind insbesondere Hörer von [[Informatik 2]], aber auch alle anderen Interessenten sind willkommen.

=== Zeit und Ort ===
Datum: '''Donnerstag, 21. April 2005''' 
Zeit: ab 16:15 
Dauer: 90 Minuten (einmalig) 
SWS: keine (studentische Veranstaltung)

=== Themen ===
* Projekte anlegen
* Java-Programme schreiben & ausführen
* Debugging

=== Anmeldung ===
Habt bitte Verständnis, dass schon auf Grund der Raumsituation eine Teilnehmerbeschränkung (35 Personen) einführen müssen. Wir setzen aber wirklich viel daran, dass auch jeder teilnehmen kann, im letzten Jahr haben wir daher zwei Kurse gehalten. Bisher konnte immer jeder Interessent am Kurs teilnehmen!

Um euch für den Kurs anzumelden, tragt euch bitte unten in der Liste ein. Für Leute, die noch nie ein Wiki benutzt haben: Auf 'bearbeiten' klicken (neben der Anmelden-Überschrift), dann im Textfeld die gewünschte Änderung durchführen und anschließend 'Artikel speichern'.

Teilnehmerliste:
* Mein Name (cs-Userid oder emailadresse)
Florian Zeidler(fzeidler@cs.tu-berlin.de)
Thilo Schmidt (dude@cs.tu-berlin.de)
Alexander Oppermann (opix@cs.tu-berlin.de)
Nicolas Poczka (npoczka@cs.tu-berlin.de)
Daniel Giancaterino(italia@cs.tu-berlin.de)