Der Aufbau einer modernen Spiele-Engine

Jedes Computerspiel baut auf einer Engine auf, immer wieder liest man in Zeitschriften und Magazinen über Speile-Engines doch was ist es wirklich?

Ein Spiel zu programmieren ist ein sehr großer Aufwand, den jede Einzelheit in dem Spiel muss vom Programmierer berücksichtigt werden z. B. was passiert, wenn man auf die “Enter”-Taste drückt. Aber wenn die gesamte Logik und das Spielverhalten entwickelt ist, muss man ja auch noch auf irgendeiner Art und Weiße das Ganze als Grafik ausgeben.

Durch die immer komplexer werdenden Spiele und deren Grafikausgabe, ist eine Spiele-Engine unbedingt erforderlich. Den die Engine beinhaltet Elemente wie die Grafikausgabe, Soundausgabe, Steuerung und sogar die Spielephysik. Sozusagen greift der eigentliche Spieleprogrammierer dann nur auf die jeweiligen Objekte und Methoden zu, welche die Game Engine bereitstellt.

Manche Engines sind sogar Plattformunabhängig, d. H. dass man damit ein Spiel programmiert und diese ohne großen Änderungsaufwand auf einer X-Box und der PS3 läuft. Das Programmieren mit einer Engine nimmt viel Arbeit ab, jedoch muss man sich zuerst zurechtfinden.
Es gibt kein einheitliches Schema für Engines, daher brauchen Engines z. B. andere spezielle Objekte und Laufzeitroutinen, damit alles so klappt, wie man es sich vorgestellt hat.

Die Grafik oben zeigt deutlich, welche Teile zwangsläufig in einer normalen Engine enthalten sein müssen. Es gibt sehr viele kostenlose Spiele-Engines, eine davon ist z. B. die GTGE für JAVA. Aber man sollte auf ein paar Kleinigkeiten achten:

1. Jede Engine ist in einer speziellen Programmiersprache entwickelt und man muss somit Zwangsweise auch in dieser Programmiersprache das Spiel schreiben. Es gibt zwar komplexe Ausnahmen über die Einbindung mittels DDL-Dateien, aber das würde den Rahmen der einfachen Erklärung sprengen.

2. Manche Engine sind für spezielle Spiele entwickelt worden, daher kann es ziemlich schwer oder gar unmöglich werden, mittels einer “Rennspiel-Engine” ein Strategiespiel zu programmieren. Genau so auch die Art, mit einer 2D-Engine wird kein Mensch ein 3D-Spiel programmieren, sowie mittels einer 3D-Engine ein 2D Spiel unnötig kompliziert wäre.

3. Für ein kleines Spiel, brauch mein keine unnötig komplexe und riesige Engine. Denn dadurch wird das Einarbeiten in die Engine nur unnötig komplex und man könnte letztendlich an der Unüberschaubarkeit der Engine scheitern.

4. Damit man mit einer Engine ein Spiel programmieren kann, sollte man schon einiges Programmiert haben und die objektorientierte Programmierung verstanden haben. Alle Pakete und Klassen werden als Objekte eingebunden und mit ihnen wird auch so programmiert. Ausnahme sind prozedurale Spiele-Engines (nicht Empfohlen).

Programmieren in C++ – Teil 2

- zu Programmieren in C++ – Teil 1 ->

Deklaration

Bei einer Deklaration wird eine Variable festgelegt, dabei ist entscheidend welchen Datentyp sie hat und optional kann man einen Startwert angeben.

int meineZahl = 5

<Datentyp> <Variablenname> = <Startwert>

Bedingungen:

Die bekannteste Bedingung, auch Verzweigung genannt, ist die IF-Abfrage:

if ( password == "Hallo" )
{
    //wenn der Fall zutrifft
}else{
   //wenn der Fall NICHT zutrifft
}

Die Switch’n’Case Mehrfachverzeigung

Die Variable „wert“ darf nur int, long, short oder char sein.

swich(wert)
{
    case 1:  // Anweisungen für 1
                break;
    case 2:  //Anweisungen für 2
                break;
    case 3:  //Anweisungen für 3
                break;
    default:  //Anweisung für andern Wert
                break;
}

Schleifen:

Schleifen werden verwendet um oft verwendete Anweisungen bzw. Befehle einfach zu wiederholen, ohne es im Quellcode mehrfach kopieren zu müssen.

Man unterteilt die Schleifen in 3 Arten:

Kopfgesteuerte Schleife:

while( BEDIGNUNG )
{
     //Aktionen
}

Fußgesteuerte Schleife:

do{
    //Aktionen
}while( BEDINGUNG )

Zählschleife:

for ( int i = 0; i < 70; i++)
{
    //Ausführung die 70 Mal erfolgt
}

Compiler

Das wichtigste Element, bei dem erstellen von Programmen. Denn der Compiler wandelt unseren Quellcode um, in einen Maschinencode. Dieser Maschinencode ist dann auf den jeweiligen Prozessor abgestimmt und kann nur auf der ausgewählten Architektur laufen. Eine Architekturist somit von dem verwendete µControler abhängig.

Der Compiler weist auch auf Fehler im Quelltext hin, die nach verschiedenen Kriterien sortiert werden:

Lexikalische Analyse: Überprüft ob Sonderzeichen im Quellcode verwendet werden, die nicht zugelassen sind, wie z. B. „ä“ , „ö“ , „ü“ und „ß“.

Syntaktische Analyse: Untersucht ob alle Syntaxrichtlinien eingehalten worden sind. Darunter fällt z. B., dass jede geöffnete Klammer „{“ eine geschlossene Klammer „}“ hat.

Semantische Analyse: Vergleicht ob die Inhalte der Bibliotheken, Module und Datentypen richtig verwendet wurden.

Benjamin Salchow

Das neue HTML 5 – Konzept und der Kampf gegen Flash

Und wieder eine Webseite komplett mit Flash programmiert, lange Ladezeiten und dazu eine Aneinanderreihung schräger Töne, die eine Hintergrundmusik ergeben soll.

Ein Anblick auf immer mehr Webseiten, den Flash kämpft sich immer mehr an die Spitze der Webseiten. Aber was ist denn so falsch an Flash?

Flash ist seit mehreren Jahren eine unfreie Skriptsprache, die Vektorgrafiken animieren kann. Dazu beinhaltet es dutzende von Sicherheitslücken und sorgt für instabile Browser. Nun fragen sich die meisten, warum den dann so viele Flash verbauen auf der Webseite?

Die Antwort ist eher mager, genauso wie die Fähigkeiten der Entwickler von Flashseiten. Ein Einfaches hin- und hergeziehe von Elementen, die man dann in Action-Skript, die “Programmiersprache” von Flashanwendungen, bearbeitet und erweitert. Die Folgen sind starke Probleme für Suchmaschinen, langsamere PCs und für schlechte Internetverbindungen.

Aber abgesehen davon, kann man mit Flash problemlos Internetspiele programmieren, die nicht mittels Java direkt auf einer virtuellen Maschine laufen.

Nach vielen Festlegungen der W3C kam man endlich auf die Idee, in HTML selbst einige Flashelemente einzubauen, die dann Suchmaschinen lesen können und vor allem keinen Schaden an dem laufenden System verursachen. Elemente sind:

• 2D Canvas
• Progress
• Video
• Audio
• u.s.w

Praktisch eine Aneignung der Flash Lite Serie, die zur Folge haben kann, dass nun noch mehr Webseiten irgendwelche Musikstücke im Hintergrund laufen lassen und Knöpfe im Menü sich wie ein Schuss einer Pistole anhören.

Einführung

MySQL ist ein DBMS (Datenbank Management System). Darunter kann man sich eine Anwendung vorstellen, die Informationen verwaltet und abgespeichert.

Normaler weiße können wir mit einem PC nur auf eine Datei zugreifen auf der Festplatte. Wenn wir aber nun ein Netzwerklaufwerk benutzen, dann kann nur ein Benutzer die Datei bearbeiten, der andere kann sie nur schreibgeschützt öffnen. Aus diesem Grund hat man sich ein System überlegt, welche die Daten verwaltet.

Ein Programm erhält vollen Zugriff auf die Datei, die auf der Festplatte gespeichert wurde und dieses Programm kann man mit Befehle ansprechen. Diese Befehle können dann den Inhalt ändern und ausgeben. Nun ist es mittels diesem “Serverprogramm” möglich, dass mehrere Benutzer auf die gleichen Daten bzw. Informationen zugreifen kann.

DBMS – Aufbau

Auf diesem Bild kann man nun klar erkennen, dass der Benutzer (CLIENT) nicht direkt auf die Datei (Datenbank – gelber Zylinder) zugreifen kann. Wie wir bereits wissen: Nur 1 Programm kann auf eine Datei zugreifen und sperrt somit den Zugriff von weiteren Benutzer oder Programmen.

Mittels den Anfragen (Query) erarbeitet das DBMS eine Antwort aufgrund der Datenbank, die wir innerhalb kurzer Zeit erhalten.

Das Netzwerk kann Internet, Intranet und ein lokaler Zugriffspunkt sein.

Beispiele

MySQL ist einer der am meist benutzten Datenbank Management Systeme im online Bereich. Die serverseitige interpretierte Skriptsprache PHP kann sehr gut mit MySQL zusammen arbeiten, daher verwenden Webseiten wie Google, e-Bay und yahoo ein DBMS. Selbst auf diesem Server läuft eine MySQL 4 Datenbank, die alle Einträge und Einstellungen darauf beinhaltet.

MySQL – Dort wo es verwendet wird!

Nun hatten wir schon einen kleinen Einblick, was MySQL ist und wie die Befehle in der Datenbank verarbeitet werden. Eine Menge Theorie, aber wofür brauchen wir das Ganze?

MySQL begegnen wir öfters als wir denken

Sei es auf E-Bay oder auf Google.de, überall stecken Datenbanken im Hintergrund, die unsere gewünschten Informationen anzeigen.

Bei E-Bay z. B. werden Datenbanken verwendet, um die alle möglichen Auktionen zu speichern und nur gewählte auf Wunsch anzeigen zu können.

Das Old-School Webseiten entwickeln ist ausgestorben. Statische Seiten gehören mehr oder weniger der Vergangenheit an, selbst diese Seite, auf der Du dich gerade befindest, funktioniert mittels einer MySQL 5.2 Datenbank. Die Datenbank beinhaltet von jedem Artikel den Inhalt mit allen Einstellungen. Im HTML-Bereich wird NUR das grundlegende Design bereitgestellt. Alles andere wird mittels PHP eingefügt aus den Informationen der Datenbank.

Der Vorteil

Mittels einer Änderung in der Datenbank, gilt dies für meine gesamte Webseite.

Durch das Dynamische erzeugen, kann ich somit mit wenigen Schritten, neue Unterseiten bzw. Artikel erstellen, ohne eine neue HTML-Datei anlegen zu müssen.

Anwendungsbereich neben Webseiten

Nicht nur Webseiten nutzen und schätzen die MySQL Datenbank, auch viele Programme verwenden diese.

Normalerweise werden in Programmen Dateien gespeichert, die Deine Informationen beinhaltet, aber oft kann es ja sein, dass diese Datei nicht nur du bearbeiten möchtest.

Wenn also mehrere Benutzer eine Datei bearbeiten wollen, dann gibt es einen Fehler. Durch eine Datenbank können mehrere Benutzer zur gleichen Zeit die Datenbank bearbeiten, solange sie nicht den gleichen Eintrag (ZELLE) bearbeiten.

Wie gehts weiter mit dem Tutorial?

Wir werden uns in den kommenden Tutorials anschauen, wie ein SQL-Befehl aufgebaut ist und wie Du damit dein Abfrageziel erreichen kannst.

Der Standard aller Dateien – XML

Immer mehr verschiedene Datentypen gibt es, immer mehr Programme zum verwenden von Dateien werden benötigt. Seit 2002 gibt es jedoch eine Einigung, dass XML-Format als Grundlage zu verwenden ist.

Durch das einsetzen einer klaren Struktur in Dateien, sodass man sie auch problemlos mit anderen Programmen bearbeitet werden können, ist XML der erste Grundstein.

Beispiel einer XML-Datei:

1
2
3
4
5
6
7
8
9

<?xml version="1.0" encoding="UTF-8"?>
<NAMEROOT>
  <kontakt nr="0">
             <test>das war der Test 1</test>
   </kontakt>
   <kontakt nr="1">
 	    <test>das war der Test 2</test>
   </kontakt>
</NAMEROOT>

Informationen werden wie in HTML gewohnt als TAG gespeichert und können verschiedene Attribute haben. HTML ist der Vorgänger von XML und jeder der sich mit HTML auskennt wird XML sofort verstehen.

Selbst Microsoft hat mit Office sich zum ersten Mal, an einem Dateistandard gehalten, denn mit *.docx, *.xlsx und *.pptx wird auch der XML-Aufbau verwendet. Aber natürlich mit einen MS Algorithmus gepackt, sodass der “Plaintext” auch nicht richtig lesbar ist.

Die Verwendung von XML kann jeder sich aneignen, vor allem auch Plattformunabhängig können XML-Dateien verwendet werden. Der ITs-real Blog hat ein gelungenes Tutorial veröffentlicht, um mit Java und JDom eine XML-Datei zu erstellen.

- Zu dem XML Tutorial ->

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.

SharpDevelop 2.2 macht PocketPC Programmierung zum Kinderspiel

Die Entwicklung auf den immer leistungsfähigeren Windows Mobile Geräten ist alles andere als einfach, nur Visual Studio von MS gibt den Entwicklern die nötige Umgebung um ein effektives Programm zu schreiben, der Nachteil liegt jedoch hier am teuren Preis des Visual Studios.

Wer den Komfort von einer gelungenen IDE haben will und dazu nichts zahlen will, ist mit Sharp Develop sicherlich gut aufgehoben, denn es kann wirklich sehr gut helfen, bei der Entwicklung von Windows Mobile Geräten.

Für eine Reibungslose Entwicklung mit Windows Mobile Compact Framework, benötigt man die SharpDevelop 2.2 Version.

[Zeigen als Slideshow]

[Mit PicLens anzeigen]

Optisch ist Sharp Develop sehr schlicht gehalten, jedoch beinhaltet es alles, was man für eine Compact Framework Entwicklung benötigt.

Quick Start Guide

• .Net Framework 2.0 SDK Downloaden
• Nach dem Installieren mit dem Explorer auf “C:\Programme\Microsoft.NET\SDK\v2.0\CompactFramework” gehen und die Datei “netcfsetupv2.msi” Starten. Diese installiert fehlende CNF Inhalte.
• Danach einfach ShaprDevelop 2.2 Starten und eine “Neue Projektmappe” Anlegen.
• c# -> Compact Framework -> Windows Anwendung

Nun kann man wie gewohnt in c# entwickeln und der Formdesigner hilft dabei, dass alles gut aussieht und erleichtert sehr stark die Arbeit.

Leider entstehen bei der Entwicklung oft Hinweise, dass einige automatisch erzeugten Aufrufe nicht in Compact Framework vorhanden sind, deshalb sollte man einfach diese Zeilen auskommentieren mit “//”.

Fazit: Endlich haben wir vom VHPD-Team eine IDE gefunden, mit der die Entwicklung von Windows Mobile Geräten nahezu problemlos geht und dazu auch noch viele nützliche Tools hat, damit die Entwicklung von Compact Framework Applikationen ohne hohe Anschaffungskosten einer IDE ablaufen kann. Das sorgt für Freeware Anwendungen für unseren Mobilen Begleiter .

Software Entwicklung

Für alle Betriebssysteme programmieren

Welchen Programmierer freut es nicht, wenn sein Programm nicht nur auf einem OS läuft? Aber leider ist nicht alles Gold was glänzt.

Aber warum sollte man auch für mehrere OS programmieren?

Gerade bei den wachsenden Linuxanwendern wird es immer gefragter, für Windows und Linux zu programmieren. Es auch jeden Compiler für Linux, sogar das Microsoft eigene .net kann man mit mono auch in Linux anwenden.

Die bis jetzt größte CrossOver-Sprache ist Java, keine weitere Programmiersprache funktioniert von Handy bis hin zur NextGen-Konsole. Aber jeder der mit Java schon einmal gearbeitet hat, wird auch behaupten, dass ein reines CrossOver ohne Architekturen SDK auch nur ein Traum ist. Das Java JRE beinhaltet zwar unsere gängigen PC OS Architekturen, aber wenn man ein Handyprogramm erstellen möchte, muss man zuvor sich das Nokia SDK, Siemens SDK oder Sony SDK herunterladen.

Wenn man CrossOver programmiert ist der Kern des Programmes eigentlich der gleiche, das Problem bei dem CrossOver sind halt nun mal die verschiedenen Schnittstellen, die halt je OS variieren. Besonders die Oberfläche ist das größte Problem, da man pro Oberfläche (GTK, Windows usw.) erneuert Complimieren muss. Ausnahme ist Java.

Wein weiterer Nachteil ist leider auch die Größe eines CrossOver Programmes, da nunmal alle Bibliotheken mit in die Complimierte Datei muss.

CrossOver wird in der Zukunft sicherlich immer wichtiger, gerade auch für Java, da es mit dem CrossOver stark wird.

Fazit:

CrossOver ist ein wichtiges Thema für jeden Programmierer, der nicht nur für ein Betriebssystem Anwendungen Programmiert. Auch da immer mehr Laptops und Computersysteme mit einer Linuxdistribution verkauft werden, könnte man wage behaupten, dass ein Software Markt für Linuxprogramme auch rentabel werden könnte.