VHPD Blog

Ein Java 2D Spiel entwickeln mit der GTGE

Um ein 2D-Spiel in Java entwickeln zu können, benötigen wir die gesamten GTGE libarys. Diese können wir sogar in Eclipse mittels SVN (Subclipse Plug-In) einfach einrichten.

In einem neuen VHPD Videotutorial erklären wir Schritt für Schritt, wie man Eclipse so konfiguriert, damit man die GTGE herunterladen kann.

Verwendete Links

SVN -- Subclipse: http://subclipse.tigris.org/update_1.6.x

GTGE Source -- SVN: http://gtge.googlecode.com/svn/trunk

GTGE

Der Sourcecode von der GTGE ist unter der GPL-Lizens veröffentlicht und kann auch über der GTGE direkt heruntergeladen werden.

Zu der GTGE-Homepage ->

2D Spiele in Java selber programmieren

Wir vom VHPD-Team sind schon seit geraumer Zeit auf der Suche, nach der ultimativen Java 2D Engine und wir haben nun unseren eindeutigen Sieger ermittelt:

Golden T Game Engine (GTGE)

Dieses Powerpacket beinhaltet eine voll funktionierende 2D Engine die sogar mittels OpenGL rendern kann und auch problemlos in Browser eingebunden werden kann. Auch in den Testreihen wurden auf Windows Systemen und Linux (Ubuntu) getestet, ob die Engine auch wirklich überall läuft.

Unser Ergebnis

Von der 2D Ausgabe bis hin zum Netzwerktest lief die GTGE-Engine problemlos unter allen Systemen und das programmieren macht richtig Spaß. GTGE ist durch ihren einfachen Aufbau und anhand der gelungenen Tutorials ein toller Begleiter, wenn es um die Entwicklung von 2D Spielen geht.

Lizenz

Der Source Code von GTGE wurde unter der GPL veröffentlicht und frei verfügbar über eine SVN Schnittstelle.

Danksagung

Durch Swen Schreiter’s Testunterstützung, konnten die Linux (Ubuntu) Tests erfolgreich durchgeführt werden. Zu seinem 3G-Phoneblog ->

Mittels Maximilan Häge’s Unterstützung, konnten wir die Engines untereinander austesten und besser vergleichen. Zu seinem IT’s Real Blog ->

Vielen Dank auch an allen anderen, die während des Laufzeittests uns unterstützt haben.

Wie geht’s weiter?

In den kommenden Wochen wird ein 2D Ping Ping Tutorial mit Eclipse und der GTGE auf dem VHPD-Blog für alle veröffentlicht, sodass jeder sehen kann, wie einfach es ist, ein 2D Spiel zu programmieren.

Java wurde auf 3D Basis stark erweitert

Überall 3D, von Spielen bis hin zur Office-Anwendung -- Heutzutage ist 3D fast ein fester Bestandteil der Entwicklung.

Durch was kann man 3D in Java benutzen?

Mittels JavaFX wurde zuerst direkt von SUN ein pseudo 3D-Libary vorbereitet für Anwendungen. Natürlich ist diese zu OpenGL und DirectX fast nichts, aber die ersten Schritte in Richtung 3D wurden gebaut.

Auf der anderen Seite aber, gibt es ein Team von Programmierern, die es sich zur Aufgabe gemacht haben, ein gut funktionierendes 3D Libary für Java zu entwickeln. JMonkey Engine (JME) ist das Zauberwort. Diese Libary erweitert Java auf viele OpenGL Funktionen die sogar dann mit OpenGL oder DirectX (nur Windows) gerendert werden.

jME -- Java Monkey Engine

Jeder kann problemlos mit Eclipse diese 3D Engine verwenden und kann leicht 3D in Java einbinden.

- Zur offiziellen Websiete von jME (englisch) ->

Tutorial zur Installation von jME mit Physik Engine

This Tutorial shows, how to install Subclise and setup jMonkeyEngine and jMEPhyscs in a fresh Eclipse 3.5.

Used URLs:

subclipse:http://subclipse.tigris.org/update_1.6.x

jMonkeyEngine:http://jmonkeyengine.googlecode.com/svn/trunk

jMEPhysics: http://jmephysics.googlecode.com/svn/trunk

Mittels diesem Video ist das Installieren kein Problem mehr.

Probleme mit Java und der 3D-Welt

Java ist bei weitem keine 100% geeignete Spielesprache, ihr nicht direkter Hardwarezugriff sorgt für Performanceschwäche und somit wären solche Spiele wie FarCry2 und GTA4 niemals möglich.

Jedoch für kleine Spielereien und Minigames ist dieses Paket Gold wert.

Mit Java in Eclipse ein Adressbuch programmieren

Vorwort

In diesem Tutorial werden wir ein Adressbuch programmieren, dass mit Hilfe eines Arrays von einem benutzerdefinierten Datentyp, die Kontakte Speichert. Daraus sollte man die Verwendung des 3. Schichten Modells besser verstehen können.

Profil

Um dieses Tutorial mitmachen zu können, sollte man die Grundkenntnisse von Java beherrschen und wissen, wie man mit Arrays umgeht. Dazu wird als Formgestalltungsprogramm Jigloo verwendet. Jigloo ist für nicht-kommerzielle Software kostenlos.

Einführung in das 3 Schichten Modell

Das ist die Grundlage des Tutorials, das 3 Schichten Modell. Wie man gut Heraushören kann, war es mal wieder ein langer Tag und dazu noch leicht erkältet .

Struktogramme und UML

Alle Struktogramme wurden von der Gewerblichen Schule Göppingen im Unterricht bereitgestellt und das UML stellen wir nun bereit.

[Zeigen als Slideshow]

[Mit PicLens anzeigen]

Der Start

Erstellen eines neuen Javaprojektes mit dem Titel “P_AdressBuch”. Danach legen wir unsere StartKlasse mit static void main() an.

Erstellen des EingabeForms

Nun kommen wir schon zur GUI, die GUI sollte uns die Möglichkeit geben, alle Inhalte anzeigen und bearbeiten zu lassen. Wir müssen daher zwingend Textfields nehmen. Bitte beachtet die Einstellung: Set Layout > AbsoluteLayout und optional Set look and feel > System. Die Oberfläche sollte danach so aussehen:

Fehlende Klassen erstellen

Danach sollte man die fehlenden Klassen erstellen, die Steuerungsklasse und Datensatz. Mithilfe der gegebenen Stuktogramme und UML sollte jeder problemlos wissen, was er nun zu machen hat. Noch eine Kurze Erklärung wie: Zuerst UML anschauen, danach feststellen welche Methoden, die als Struktogramme gegeben wurden, in welche Klasse gehören.

Die Klasse Datensatz.java sollte nun erstellt werden mit folgendem Inhalt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public class Datensatz {
 
	//Globale Attribute der Klasse
	public String vorname, nachname, adresse, plz, email, ort, telnr;
 
	//Konstruktor - 2 Versionen für vorhandene Daten und ohne
 
	//Konstruktor mit Daten füllen
	public Datensatz(String p_vorname, String p_nachname, 
			String p_adresse, String p_plz, String p_email, 
			String p_ort, String p_telnr){
		vorname = p_vorname;
		nachname = p_nachname;
		adresse = p_adresse;
		plz = p_plz;
		ort = p_ort;
		email = p_email;
		telnr = p_telnr;
	}
 
	//Konstruktor ohne Daten
	public Datensatz(){
		vorname = null;
		nachname = null;
		adresse = null;
		plz = null;
		ort = null;
		email = null;
		telnr = null;
	}
}

Hier kann man gut erkennen, wie man 2 Konstruktoren für verschiedene Fälle anwendet. Einfach einen weiteren Konstruktor anlegen mit anderen Parametern und schon entscheidet Java, welcher Konstruktor verwendet wird.
Durch das null Setzen der Attribute, kann es nicht zu einem Fehler führen, wenn man auf ein Attribut zugreift

Nun kommt der Inhalt der Steuerungsklasse.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

public class Steuerungsklasse {
 
	//Atribute
	private int feldGröße = 100;
	public int derZeiger = 0;
	private EingabeFrame fenster = null;
	private Datensatz[] dieDaten = new Datensatz[feldGröße+1];
 
	//Konstruktor
	public Steuerungsklasse(EingabeFrame p_fenster){
		fenster = p_fenster;
	}
 
	//Funktionen von Struktogramm siehe UML
 
	public Datensatz erstesElement(){
		derZeiger = 0;
		if (dieDaten[derZeiger]== null){
			return new Datensatz();
		} else {
			return dieDaten[derZeiger];
		}
	}
 
	public Datensatz letztesElement(){
		if (dieDaten[derZeiger]==null){
			return new Datensatz();
		} else {
			while (dieDaten[derZeiger +1]!=null){
				derZeiger++;
			}
			return dieDaten[derZeiger];
		}
	}
 
	public Datensatz links(){
		if (derZeiger > 0){
			derZeiger--;
		}
		if (dieDaten[derZeiger]==null){
			return new Datensatz();
		} else {
			return dieDaten[derZeiger];
		}
	}
 
	public Datensatz rechts(){
		if (dieDaten[derZeiger]== null){
			return new Datensatz();
		} else {
			if (dieDaten[derZeiger +1]!= null){
				derZeiger++;
			}
			return dieDaten[derZeiger];
		}
	}
 
	public Datensatz refresh(){
		if (dieDaten[derZeiger] == null){
			return new Datensatz();
		} else {
			return dieDaten[derZeiger];
		}
	}
 
	public boolean insert(Datensatz d){
		if (dieDaten[derZeiger]== null){
			dieDaten[derZeiger] = new Datensatz();
			dieDaten[derZeiger] = d;
			return true;
		} else {
			if (dieDaten [feldGröße - 1] == null){
				int derZeiger2 = feldGröße -1;
				while (derZeiger2 > derZeiger){
					dieDaten[derZeiger2] = dieDaten[derZeiger2-1];
					derZeiger2--;
				}
				dieDaten[derZeiger] = d;
				return true;
			} else return false;
		}
	}
 
	public boolean delete(){
		int derZeiger2 = derZeiger;
		while(dieDaten[derZeiger2]!= null){
			dieDaten[derZeiger2] = dieDaten[derZeiger2+1];
			derZeiger2++;
		}
		return true;
	}
 
	public boolean modify(Datensatz d){
		if (dieDaten[derZeiger] != null){
			dieDaten[derZeiger] = d;
			return true;
		} else {
			return false;
		}
	}
 
}

Die erstellten Methoden wurden aufgrund der Struktogramme der Gewerblichen Schule angefertigt, jedoch sollte man dazu sagen, dass Variablennamen sich unterscheiden. z. B. bei dem VHPD Adressbuch dieDaten und im Struktogramm dasDatenfeld.
Profis werden die Assoziation fenster nicht verstehen, natürlich ich diese in diesem Fall mehr als unnütz, jedoch hier sollte es die gegenseitige Verbindung wie im UML darstellen. In der fenster-Variable wird nur die Adresse zu dem echten Fenster gespeichert.

Nun kommen wir zu dem schweren Teil, das erweitern von dem EingabeFrame. Als Erstes sollte man alle Buttons, außer New, auf disabled stellen. Danach erstellen wir eine weitere Methode in der EingabeFrame Klasse.

1
2
3
4
5
6
7
8
9

	private void clearAll(){
		tfVorname.setText("");
		tfNachname.setText("");
		tfAdresse.setText("");
		tfPLZ.setText("");
		tfOrt.setText("");
		tfTelNr.setText("");
		tfEMail.setText("");
	}

Diese Erweiterung erspart uns viel Tipparbeit. Sollte sich jetzt jemand Fragen, wie man eine Methode einfügt in eine Klasse, dann sollte dieser Hinweis reichen: Zwischen zwei bereits vorhandenen Methoden aber nicht nach der Abschließenden Klassenklammer }.
Danach erstellt man die Buttons nach der Reihe, davor sollte man aber wissen, wie das Programm jetzt eigentlich genau funktioniert:

Wenn man auf Neu klickt, dann werden die Buttons Neu, Ändern, Löschen deaktiviert und im Gegenzug Sichern und Abbrechen aktiviert. Nach dem Umstellen der Schalter wird ein Leerer Datensatz eingefügt. Als Letztes verwenden wir unsere clearAll() Methode, um die Textfelder zu leeren. Dass sieht im Java Code so aus:

1
2
3
4
5
6
7

	private void bNeuActionPerformed(ActionEvent evt) {
		bAbbrechen.setEnabled(true);
		bSichern.setEnabled(true);
		bNeu.setEnabled(false);
		clearAll();
		dieSteuerung.insert(new Datensatz());		
	}

Nun schauen wir uns Sichern an, wenn wir auf Sichern klicken, dann wird ein Datensatz mit dem Formularinhalt erstellt und dann wird mit Hilfe von modify der Steuerungsklasse, der vorher neu erstellte Eintrag geändert, mit dem Inhalt des Formulars. Im Java Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

	private void bSichernActionPerformed(ActionEvent evt) {
		Datensatz d = new Datensatz(tfVorname.getText(),
				tfNachname.getText(), tfAdresse.getText(),
				tfPLZ.getText(), tfEMail.getText(),
				tfOrt.getText(), tfTelNr.getText());
 
		if (dieSteuerung.modify(d)!= true){
			System.out.println("Kontne nicht Gesichert werden");
		}
		bNeu.setEnabled(true);
		bLöschen.setEnabled(true);
		bÄndern.setEnabled(true);
		bAbbrechen.setEnabled(false);
		bSichern.setEnabled(false);
	}

Mit einem Klick auf Löschen erstellen wir einen leeren Datensatz, um die Daten des nachfolgenden Elementes anzeigen zu können. Damit keine Lücken im Array der Datensätze entstehen, müssen wir alle Einträge dann immer aufschieben. Danach benutzen wir die void Methode delete() von derSteuerung und zum Schluss laden wir in unseren leeren Datensatz d, die Informationen vom Aufgerutschten Element. Die Inhalte von d werden dann mit der setText() Methode der Textfelder angezeigt. Das sieht in Java so aus:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

	private void bLöschenActionPerformed(ActionEvent evt) {
		Datensatz d = new Datensatz();
 
		dieSteuerung.delete();
 
		d = dieSteuerung.refresh();
		tfVorname.setText(d.vorname);
		tfNachname.setText(d.nachname);
		tfAdresse.setText(d.adresse);
		tfPLZ.setText(d.plz);
		tfOrt.setText(d.ort);
		tfTelNr.setText(d.telnr);
		tfEMail.setText(d.email);
	}

Nun gibt es noch Ändern, wenn man darauf klickt, wird ein Datensatz mit den Inhalten des Fensters erstellt und mit der Methode modify von derSteuerung übertragen an dieDaten. Im Java Code:

1
2
3
4
5
6
7
8
9

	private void bÄndernActionPerformed(ActionEvent evt) {
		Datensatz d = new Datensatz(tfVorname.getText(),
				tfNachname.getText(), tfAdresse.getText(),
				tfPLZ.getText(), tfEMail.getText(),
				tfOrt.getText(), tfTelNr.getText());
		if (dieSteuerung.modify(d) != true){
			System.out.println("Konnte nicht Geändert werden");
		}
	}

Nun gibt es noch Abbrechen, wenn man darauf klickt, wird Neu, Ändern, Löschen aktiviert und Abbrechen und Sichern deaktiviert. Danach werden die Textfelder mit clearAll() geleert und wir benutzen die refresh() Methode der Steuerungsklasse, um die Orginaldaten wiederherzustellen. Natürlich müssen wir wie davor, einen leeren Datensatz d erstellen, den wir mit refresh() füllen und dann auslesen um die Textfelder mit dem richtigen Inhalt voll stopfen zu können. In Java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

	private void bAbbrechenActionPerformed(ActionEvent evt) {
		clearAll();
		bAbbrechen.setEnabled(false);
		bSichern.setEnabled(false);
		bNeu.setEnabled(true);
		bLöschen.setEnabled(true);
		bÄndern.setEnabled(true);
 
		Datensatz d = new Datensatz();
		d = dieSteuerung.refresh();
		tfVorname.setText(d.vorname);
		tfNachname.setText(d.nachname);
		tfAdresse.setText(d.adresse);
		tfPLZ.setText(d.plz);
		tfOrt.setText(d.ort);
		tfTelNr.setText(d.telnr);
		tfEMail.setText(d.email);
	}

Nun muss man noch Blättern können, mit einem klick auf das erste Element wird, wie bereits schon 4 mal geschrieben, ein leerer Datensatz d erstellt, der mit den Inhalt von dem ersten Element in der Steuerungsklasse, gefüllt wird. Danach wird der Inhalt wieder im Fenster angezeigt. Java:

1
2
3
4
5
6
7
8
9
10
11
12
13

	private void bErstesElementActionPerformed(ActionEvent evt) {
		Datensatz d = new Datensatz();
 
		d = dieSteuerung.erstesElement();
 
		tfVorname.setText(d.vorname);
		tfNachname.setText(d.nachname);
		tfAdresse.setText(d.adresse);
		tfPLZ.setText(d.plz);
		tfOrt.setText(d.ort);
		tfTelNr.setText(d.telnr);
		tfEMail.setText(d.email);
	}

Um jetzt nach links, rechts oder zum letzten Element zu kommen, muss man nur die 4. Zeile anpassen und anstelle von erstesElement, die gewünschte Methode aufrufen.

Nun ist das Grundgerüst einwandfrei fertig und alles läuft so, wie es sollte. Um die Anzeige noch besser machen zu können, kann man den Zeiger anzeigen lassen. Dazu sollte man auf dem Form ein Label mit dem Namen lZeiger erstellen und den folgenden Baustein zu jeder Button-Methode einfügen:

1

lZeiger.setText(Integer.toString(dieSteuerung.derZeiger));

Wenn alles Geklappt hat, sollte das Fertige Programm so aussehen:

Hier noch die Source zum Download, jedoch wurde der EingabeFrame entfernt, denn sollte man mindestens noch selber hinbekommen . Download Source.

Entwicklung für mobile Geräte

Für jeden, der sich mit der Entwicklung für mobile Geräte befasst hat, kennt die Problematik: Für jeden Typ brauch man spezielle SDKs, Entwicklungsumgebungen sind meist bescheiden und vor allem Typ abhängig.

Das Pulsar (Eclipse) packt alles unter ein Dach, sodass die Entwicklung einfach ist. Pulsar war zuerst ein kleines Eclipse Plug-In mit dem es möglich war, mit SDKs von Drittanbietern unter Eclipse zu programmieren. Heute gibt es Pulsar auf der Eclipse Webseite zum Download als eigenständiges Programm, natürlich auf Eclipse basierend und erleichtert die mobile Entwicklung.

SDKs können schnell und unkompliziert über Pulsar (Eclipse) heruntergeladen werden und somit können unerfahrene Benutzer, ohne großartig zu Suchen, schnell die SDKs verwenden für volle Komplexität.

Optisch unterscheiden sich Eclipse und Pulsar nur sehr gering, somit fällt die Umstellung von Eclipse auf Pulsar überhaupt nicht schwer. Zusätzlich können eigene Konfigurationen zum erstellen von den Java-Programmen geschrieben werden, um das Programm für das jeweilige Gerät 100 prozentig anpassen zu können.

Eclipse 3.5 m6 ist zum Download bereit

Die neue Eclipse Version wird unter den Namen Galileo entwickelt und bietet eine stabile Entwicklungsplattform.

Im Vergleich zum Vorgänger bietet die Eclipse Version 3.5 grafisch nur sehr geringe Änderungen, aber dahinter hat sich einiges getan:

• Flex und Silverlight soll unterstützt werden
• Das User-Interface soll bis zur endgültigen Veröffentlichung überarbeitet werden
• Ermöglich die Entwicklung von Plug-Ins neben Java

Es handelt sich um die Beta von Eclipse 3.5 SDK Milestone 6, die sich in Entwicklung befindet.

kostenloser Download Eclipse 3.5 m6

Der sechste Milestone wurde bereits veröffentlicht und zur Zeit wird an m7 gearbeitet, diese Version ist jedoch noch nicht zum Download freigegeben.