Spieleprogrammierung: Satzraten für Java-Einsteiger

[Terep]

Hat man sich die Grundkenntnisse angeeignet und will von der Konsole zur Windowsanwendung wechseln, wird man von der Fülle unterschiedlicher Programmieraspekte fast erschlagen, ganz besonders in C++.
Daher habe ich bei C++ eine Pause eingelegt und teste jetzt Java.
Mein erster Eindruck. Seinen persönlichen Level erreicht man relativ schnell.
Kann ich mich in Java ableveln, wird die Rückkehr nach C++ nicht so schwer sein.
Wichtiger ist es für mich, endlich einmal Grafikspiele zu entwickeln.

Als Spielthema habe ich mir etwas Einfaches ausgesucht. Sätze raten.
In der ersten Version wird der Quellcode nur das Wesentlichste haben.
Hier kann man die Codezeilen noch gut zählen.

Für mich ist es bei diesem Thread wichtig, darauf hinzuweisen:
dass ich als Hobbyist für Einsteiger schreibe und
die Hoffnung habe, dass die Profis hier Impulse setzen können, damit ich auch etwas davon habe.

Es geht los. Geschrieben habe ich es auf Eclipse unter Java 7.0.

Der eigentliche Quelltext ist in der Klasse SaetzeRaten. Mit der StartMain wird das Spiel nur gestartet. So besteht die Möglichkeit, dass Spiel einfach in eine Spielsammlung zu integrieren.

Code: Alles auswählen

public class StartMain {
	public static void main(String[] args) {
		// Kontrollmeldung auf der Konsole
		System.out.println("Sätze raten; Start");
		
		// mit new wird immer ein Objekt erzeugt.
		// Eine Referenzvariable brauchen wir nicht
		// Kommen wir nach main zurück, ist das Spiel zu Ende
		new Satzraten();
		
		// Kontrollmeldung auf der Konsole
		System.out.println ("Sätze raten; Ende");
	}
} 

Da wir keine Konsolenanwendung schreiben, benötigen wir ein Fenster.
Dies stellt Java standardmäßig zur Verfügung. Dafür müssen wir swing importieren und daraus aus der Klasse JFrame ableiten. Da wir alles geerbt haben, müssen nur noch einige Paramter gesetzt werden:

Code: Alles auswählen

import javax.swing.*;
public class Satzraten extends JFrame {
	// Konstruktor, der Einstiegspunkt dieser Klasse
	public Satzraten () {
		super("Rate den Satz");
		setSize(600, 400);
		setLocation(200, 200);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setVisible(true);
	}
}

Aus meiner Sicht ist es sinnvoll, so zu proggen, dass man nach jeden Step eine lauffähige Version hat. Reduziert das elendige Suchen nach Fehlern erheblich.
Also copy / paste und dann starten.

Ein leeres Fenster erscheint. Mit „super“ wird der Konstruktor der abgeleiteten Klasse aufgerufen und gleichzeitig der Text hinterlegt. Dies muss immer der erste Aufruf im Konstruktor sein. Wir hätten es hier auch weglassen können und stattdessen setTitle („Rate den Satz“); setzen können.
Danach wird die Größe des Fensters festgelegt.
Lokalisiert wird das Fenster in Pixel vom Bildschirm obenlinks.
Das weiße Kreuz auf rotem Rechteck schließt in der Regel das Window. Das passiert bei unserem Fenster nur, wenn wir die Close-Methode mit dem Merkmal EXIT_ON_CLOSE aufrufen. Ansonsten lässt sich das Fenster nur mit Ctrl C schließen oder Eclipse muss geschlossen werden.
Zuletzt wird das Fenster auf „sichtbar“ gestellt.

Als nächstes werden wir einige Labels und Buttons placieren. Wobei das Plazieren ein Thema für sich ist. In Java gibt es verschiedene Layout-Manager, die alle mehr oder weniger steuerbar sind. Das heißt, man gibt je nach Verwendung vor, nach welchem Stil die Komponenten auf das Fenster gelegt werden.
Ein Layout wird nicht direkt ins Fenster gesetzt, sondern man benutzt Container. In unserem Fall werden wir aus swing das „JPanel“ benutzen.
Ein JPanel kann beliebig viele verschiedene Komponenten aufnehmen und auch geschachtelt werden. Daher lege ich erst einmal Hauptpanel an, in der die anderen Panels eingebunden werden.
Mit new wird das Panelobjekt erzeugt. Damit es sichtbar ist, muss es zu unserem Fenster hinzugefügt werden. Da wir im Konstruktor sind, wird mit this auf dieses Fenster verwiesen und mit add zugefügt. Diese Vorgehensart gilt für alle Komponenten.

Code: Alles auswählen

	JPanel hauptPanel = new JPanel ();
	this.add(hauptPanel);

Wenn wir das im Code zugefügt haben, sehen wir nach dem Start keine Veränderung, weil noch die Komponenten fehlen.
Der Konstruktor ist für die Erzeugung des Objektes zuständig. Damit es übersichtlich bleibt, lagern wir den Code für die Komponenten aus. Anstatt

JPanel topPanel = new JPanel ();

Schreiben wir:

Code: Alles auswählen

	topPanel = initTopPanel();
	hauptPanel.add(topPanel);

Natürlich müssen wir jetzt als nächstes die Methode initTopPanel erzeugen, damit das Programm wieder lauffähig wird.

Code: Alles auswählen

	private JPanel initTopPanel () {
		JPanel panel = new JPanel ();
		GridLayout gridLayout = new GridLayout(3,1,10,10);
		panel.setLayout(gridLayout);
		
		lblTitel = new JLabel ("Rate den Satz");
		panel.add(lblTitel);
		
		lblSatztafel = new JLabel (satzKodiert);
		panel.add(lblSatztafel);
	
		return panel;
	}

Hier sind jetzt einige Dinge erwähnenswert. In einer Methode legen wir nur lokale Variblen an. Bei einigen Komponenten ist das ok, wenn sich zum Beispiel der Text in einem Label nie ändern soll. Brauchen wir jedoch den Zugriff in Form einer Referenz müssen wir Instanzvariable anlegen. Also direkt am Klassenanfang deklarieren wir die Sachen, auf die wir Zugriff haben wollen.

Code: Alles auswählen

// Instanzvariable
	JPanel topPanel;
		
	JLabel lblTitel;
	JLabel lblSatztafel;
	
	String satzKodiert = " ";	

In der ersten Methodenzeile erzeugen wir ein JPanel. Da wir die Referenz an den Aufrufer zurückgeben, hat die Methode den Rückgabetyp JPanel. Bevor es zurückgeht, legen wir ein GridLayout an. In den Klammern stehen 4 Parameter, mit denen man das Plazieren der Komponenten steuern kann. Anzahl der Zeilen, Anzahl der Spalten, Abstand vertikal und horizontal. Natürlich muss das Layout dem panel zugefügt werden. Dazu gibt es die Methode setLayout(). Zum Schluss werden 2 Labels erzeugt und mittels add dem panel zugefügt.
Mit return geht es zum Konstruktor zurück. Die Referenz wird der Variablen topPanel übergeben und das hauptpanel übernimmt es mit add.

Wenn wir jetzt erneut das Programm starten, sehen wir die erste Komponente.

Weiter geht’s mit dem nächsten panel:

Code: Alles auswählen

Im Konstruktor fügen wir wie gehabt hinzu.
		spielPanel = initspielPanel();
		hauptPanel.add(spielPanel);

Die Methode wird erfasst

Code: Alles auswählen

private JPanel initspielPanel () {
		JPanel panel = new JPanel ();
		GridLayout gridLayout = new GridLayout(3,10,10,10);
		panel.setLayout(gridLayout);
		
		azbutton = new JButton [26];
		char c;
		for (int i = 0; i < 26; i++) {
			
			c = (char) (i+65);
			System.out.println(i + "  " + c);
					
			azbutton[i] = new JButton(String.valueOf(c) );
			azbutton[i].addActionListener(lauscher);
			
			panel.add(azbutton[i]);
		}

Instanzvariable werden angelegt:

Code: Alles auswählen

JPanel spielPanel;
JButton [] azbutton;
char [] arrKodiert;    // brauchen wir etwas später
char [] arrKlar;	    // brauchen wir etwas später

Jetzt ist es wichtig, die Funktionalität panel mit Komponenten anlegen, verstanden wurde.
Denn hier kommen noch einige Sachen neu hinzu.
Ein char-Array für die 26 Buchstaben wird erzeugt. Da char-Zeichen im ASCII in Form von Integerzahlen hinterlegt sind (A = 65 … Z =91) habe ich in der for-Schleife pro Schleifengang die entsprechende ASCII-Codierung erzeugt und durch das char in Klammern in ein char-Zeichen gewandelt.
Als Test lasse ich es in der Konsole ausgeben.
Die nächste Zeile füllt das Array. Da JButton kein char als Text akzeptiert, nach String geparst.

Testen ist angesagt. Kommentiere die Zeile
// azbutton.addActionListener(lauscher);
zwecks Test aus. Dann sollte das Programm laufen. Danach die Kommentierung wieder entfernen.

Jetzt kommt der interessante Teil: der Lauscher. Will man, dass bei Tastendruck der A-Z Schalter etwas passiert, müssen Rahmenbedingungen gesetzt werden.
Die Komponente wie zum Beispiel unser button muss die Lauscherfähigkeit haben,
Jeder einzelne button muss ein Lauscher haben, dies geschieht durch den ActionListener.
Das Gehörte muss verarbeitet werden. Das passiert mit Hilfe des ActionEvent
ActionEvent und ActionListener müssen importiert werden.

Code: Alles auswählen

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener; 

Da die Lauschaktionen alle in der Spielklasse laufen, bietet sich eine interne Klasse an.

Code: Alles auswählen

	
	// Innere Klasse
		private final class SchalterLauscher implements ActionListener {
			
			public void actionPerformed (ActionEvent e) {
				String s;
				s = e.getActionCommand();
				
				char ch =	s.charAt(0);
				System.out.println("s String:   " + s);
				System.out.println("ch Zeichen:   " + ch);
					
				entkodieren(ch);
				System.out.println("ch Zeichen:   " + ch);
				System.out.println("ch+26 Zeichen:   " + (ch+32));
					
			}
					
			private void entkodieren(char c) {
				for ( int i = 0; i < arrKodiert.length; i++) {
					if ( (arrKlar[i] == c) || (arrKlar[i] == (c+32) ) )   {
						arrKodiert[i] = arrKlar[i];
					}
				}
				satzKodiert = "";
				for ( int i = 0; i < arrKodiert.length; i++) {
					satzKodiert = satzKodiert + arrKodiert [i];
				}
			
				System.out.println("satzKodiert: " + satzKodiert);
				lblSatztafel.setText(satzKodiert);
			}
		}  // Ende innere Klasse

Zuerst erzeugen wir ein Objekt der inneren Klasse, siehe bei den Instanzvariablen
Wir müssen bei der inneren Klasse den ActionListener implementieren und zwingend die Methode actionPerformed erstellen, sonst gibt es Fehlermeldungen.

Wenn wir jetzt das Programm starten, läuft es, bis wir eine Taste drücken. Es passiert was.
Leider nichts gutes, nur Fehlermeldungen. Es fehlen Programmteile, also abwarten.

Zurück zur Methode actionPerformed.
Die Methode stellt Infos über das button-klicken zur Verfügung. In dem String s lasse ich mir angeben, welche Taste gedrückt wurde.
Da es immer nur ein Zeichen ist, habe ich es als char mit der nächsten Zeile ausgelesen.
Es kommen Kontrollprints auf der Konsole.

Mit der Buchstabentaste wurde konkret ein Buchstabe gedrückt. Dieser Buchstabe wird als char-Zeichen der Methode entkodieren(ch) übergeben. Es gibt noch einmal einen Kontrollausdruck und die Methode actionPerformed ist abgearbeitet.

Jetzt zur Methode entkodieren()
Wir durchlaufen mittels for-Schleife den kodierten Array. Kodiert bedeutet, alle Buchstaben wurden durch ein Stern ersetzt. Die anderen Zeichen wie Punkt, Komma usw. bleiben wie sie sind. Jedesmal, wenn der gedrückte Buchstabe im Satz vorkommt, wird in if verzweigt. Aus dem Klarsatz wird der entsprechende Groß- oder Kleinbuchstabe entnommen und bei dem kodierten Satz gegen das Sternchen ausgetauscht.

Wir sind schon ganz schön weit. Viel fehlt nicht mehr.
Im Konstruktor fehlt uns nur noch eine Zeile:

Code: Alles auswählen

spielschleife();

Es ist ein Methodenaufruf ohne Wiederkehr

Code: Alles auswählen

	private void spielschleife() {
		System.out.println("Start der Spielschleife");
		
		kodiereSatz();
		lblSatztafel.setText(satzKodiert);

Der Printbefehl ist nur zur Kontrolle da. Alle Printbefehle können bei Funktionsfähigkeit gelöscht werden.

Die Methode kodiereSatz wird aufgerufen.

Code: Alles auswählen

private void kodiereSatz() {
		arrKlar    = new char[satzKlar.length()];
		arrKodiert = new char[satzKlar.length()];
		
		//aus String den Array erzeugen
		for ( int i = 0; i < satzKlar.length(); i++) {
			arrKlar[i] = satzKlar.charAt(i);
		}
	
		// Die Kodierung durchführen
		for ( int i = 0; i < satzKlar.length(); i++) {
			if ( ( (arrKlar[i] < 91 ) && (arrKlar[i] > 64) ) ||
				 ( (arrKlar[i] < 123) && (arrKlar[i] > 96) )  )   {
				arrKodiert[i] = '*';
			}
			else {
				arrKodiert[i] = arrKlar[i];
			}
		}
		// kodierten String erzeugen
		satzKodiert = "";
		for ( int i = 0; i < arrKodiert.length; i++) {
			satzKodiert = satzKodiert + arrKodiert [i];
		}
		System.out.println("satzKodiert: " + satzKodiert);
		lblSatztafel.setText("satzKodiert");
	}

Die beiden arrays werden erzeugt. Die Länge kommt aus dem String satzklar. Hier ist der Ratesatz hinterlegt. In der ersten for-Schleife wird Buchstabe für Buchstabe als char-Zeichen in den arrKlar-array hinterlegt.
Mit der zweiten for-Schleife wird im kodierten Array mit einer if-Verzweigung jeder Buchstabe in ein Sternchen gewandelt.

Jetzt sind wir mit der Basisversion fertig. Aus meiner Sicht haben wir ein ablauffähiges Programm. Wenn man jetzt einen anderen Ratesatz will, muss man den neuen Satz im String satzklar hinterlegen.

Im ersten Durchgang wollte ich nur die Spiellogik darlegen. Mit 160 Codezeilen ist das Wesentliche realisiert. Wir haben eine Grafikanwendung mit Nachrichtenaustausch.

Um es als Spiel zu bezeichnen, fehlt noch der zu schaffende Spielreiz und Service wie ein Satzarchiv und viel Kosmetik.

Wenn alles umgesetzt werden soll, wird sich das Codevolumen um einiges steigern.

Zum Schluss möchte ich noch einmal darauf hinweisen, dass ich es als Hobby betreibe und es als Anregung für Einsteiger gedacht ist.

Wenn sich jemand die Zeit nimmt, es durchzugehen, würde ich mich um eine ehrliche Antwort freuen (es sei denn, es kommt knüppeldick).

Wenn Profis sich die Zeit nehmen, Verbesserungen am bestehenden Code zu formulieren, wäre es Klasse.
Daher noch einmal der Code komplett:

Code: Alles auswählen

import java.awt.GridLayout;
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;


public class Satzraten extends JFrame{

	// Instanzvariable
	JPanel topPanel;
	JPanel spielPanel;
	
		
	JLabel lblTitel;
	JLabel lblSatztafel;
	
	String satzKlar = "Du interessierst dich fuer Spieleentwicklung? Besuche ZFX developia!";
	String satzKodiert = " ";	

	char [] arrKodiert;
	char [] arrKlar;
	
	JButton [] azbutton;
	
	// Ein Objekt der inneren Klasse erzeugen
	SchalterLauscher lauscher = new SchalterLauscher();

	
	
	// Konstruktor, der Einstiegspunkt dieser Klasse
	public Satzraten () {
		
		super("Die Basisversion, Funktionalität ist gegeben");
		setSize(600, 400);
		setLocation(200, 200);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setVisible(true);
		JPanel hauptPanel = new JPanel ();
		this.add(hauptPanel);

		topPanel = initTopPanel();
		hauptPanel.add(topPanel);
	
		spielPanel = initspielPanel();
		hauptPanel.add(spielPanel);

		spielschleife();	
	}


	private JPanel initTopPanel () {
		JPanel panel = new JPanel ();
		GridLayout gridLayout = new GridLayout(3,1,10,10);
		panel.setLayout(gridLayout);
		
		lblTitel = new JLabel ("Rate den Satz");
		panel.add(lblTitel);
		
		lblSatztafel = new JLabel (satzKodiert);
		panel.add(lblSatztafel);
	
		return panel;
	}

	private JPanel initspielPanel () {
		JPanel panel = new JPanel ();
		GridLayout gridLayout = new GridLayout(3,10,10,10);
		panel.setLayout(gridLayout);
		
		azbutton = new JButton [26];
		char c;
		for (int i = 0; i < 26; i++) {
			
			c = (char) (i+65);
			System.out.println(i + "  " + c);
					
			azbutton[i] = new JButton(String.valueOf(c) );
			azbutton[i].addActionListener(lauscher);
			
			panel.add(azbutton[i]);
		}
		return panel;
	}


	private void spielschleife() {
		System.out.println("Start der Spielschleife");
		
		kodiereSatz();
		lblSatztafel.setText(satzKodiert);
	}
	
	private void kodiereSatz() {
		arrKlar    = new char[satzKlar.length()];
		arrKodiert = new char[satzKlar.length()];
		
		//aus String den Array erzeugen
		for ( int i = 0; i < satzKlar.length(); i++) {
			arrKlar[i] = satzKlar.charAt(i);
		}
	
		// Die Kodierung durchführen
		for ( int i = 0; i < satzKlar.length(); i++) {
			if ( ( (arrKlar[i] < 91 ) && (arrKlar[i] > 64) ) ||
				 ( (arrKlar[i] < 123) && (arrKlar[i] > 96) )  )   {
				arrKodiert[i] = '*';
			}
			else {
				arrKodiert[i] = arrKlar[i];
			}
		
		}
	
		// kodierten String erzeugen
		satzKodiert = "";
		for ( int i = 0; i < arrKodiert.length; i++) {
			satzKodiert = satzKodiert + arrKodiert [i];
		}
		
	
		System.out.println("satzKodiert: " + satzKodiert);
		lblSatztafel.setText("satzKodiert");
	}
	
	// Innere Klasse
		private final class SchalterLauscher implements ActionListener {
			
			public void actionPerformed (ActionEvent e) {
				String s;
				s = e.getActionCommand();
				
				char ch =	s.charAt(0);
				System.out.println("s String:   " + s);
				System.out.println("ch Zeichen:   " + ch);
					
				entkodieren(ch);
				System.out.println("ch Zeichen:   " + ch);
				System.out.println("ch+26 Zeichen:   " + (ch+32));
					
			}
					
			private void entkodieren(char c) {
				for ( int i = 0; i < arrKodiert.length; i++) {
					if ( (arrKlar[i] == c) || (arrKlar[i] == (c+32) ) )   {
						arrKodiert[i] = arrKlar[i];
					}
				}
				satzKodiert = "";
				for ( int i = 0; i < arrKodiert.length; i++) {
					satzKodiert = satzKodiert + arrKodiert [i];
				}
			
				System.out.println("satzKodiert: " + satzKodiert);
				lblSatztafel.setText(satzKodiert);
			}
		}  // Ende innere Klasse
	
}

public class StartMain {
	public static void main(String[] args) {
		// Kontrollmeldung auf der Konsole
		System.out.println("Sätze raten; Start");
		
		// mit new wird immer ein Objekt erzeugt.
		// Eine Referenzvariable brauchen wir nicht
		// Kommen wir nach main zurück, ist das Spiel zu Ende
		new Satzraten();
		
		// Kontrollmeldung auf der Konsole
		System.out.println ("Sätze raten; Ende");
	}
}

Ob ich den Zeitaufwand betreiben soll, wird von den Reaktionen abhängen.


Terep

[Niki]

Hallo Terep,

zwar kann ich das Programm jetzt hier nicht so einfach ausprobieren (ich benutze hier kein Java), aber ich habe mir den Code angesehen und kann mir vorstellen wie die Anwendung aussieht und was sie tut. Die Tatsache das ich das in wenigen Minuten konnte ist schon mal ein Anzeichen dafür das der Code an sich in Ordnung ist. Das größte Problem hatte ich persönlich mit den deutschsprachigen Variablennamen, aber das ist Geschmackssache und für viele deutschsprachige eventuell sogar einfacher. Daran gibt es also auch nicht wirklich was auszusetzen :)
Gefunden habe ich einen Fehler in der letzten Zeile von kodiereSatz(). Da hast du aus Versehen lblSatztafel.setText("satzKodiert"); geschrieben (beachte die Gänsefußchen um die Variable satzKodiert).

Soweit zur guten Nachricht, aber es gibt auch eine andere Nachricht. Diese ist nicht unbedingt schlecht, sondern weist eher ein wenig in eine andere Richtung.
Du bezeichnest dein Spiel nun als Grafikspiel. Es ist natürlich schon so, dass die grafische Benutzeroberfläche von Java mit Grafik dargestellt wird. Deine Buttons, Labels, und Panels sind also schon Grafik. Es heißt ja nicht umsonst Graphical User Interface (GUI). Aber diese Art der Grafik ist nicht dieselbe wie sie normalerweise in Spielen benutzt wird.

Ich versuche jetzt gerade krampfhaft ein Beispiel zu finden, mit dem man erklären kann was der Unterschied zwischen Grafik und Grafik ist. Ich stehe da grad ein wenig auf dem Schlauch. Stell dir vor, dass du ein JFrame hast, aber keine anderen Java-Benutzeroberflächenelemente, wie Buttons oder Labels. Stattdessen hast du durch irgendwelche Systemfunktionen wie zeichneBild(...), zeichneLinie(...), zeichneText(...) etc. Diese Befehle sind alle wesentlich schlichter als JButtons, JLabels, und JPanels. Und dennoch kann man mit den schlichteren Befehlen seine eigenen Button-, Label-, und Panel-Klassen bauen ohne die von Java zu benutzen.
Was nun bei einem Grafikspiel passiert ist, dass jedes Frame ein neues Bild mit den schlichten Befehlen gemalt wird. Wenn das Bild fertig ist dann wird es angezeigt, während im Hintergrund das nächste Bild gemalt wird (wieder angefangen mit einer leeren Leinwand). Ist das neue Bild fertig, dann wird es angezeigt. Dieser Vorgang wird nun für die gesamte Dauer des Spiels wiederholt, so das wenn möglich 60 oder mehr Bilder pro Sekunde angezeigt werden. Durch Variationen in den einzelnen Bildern entstehen dann Animationen. Man kann das vielleicht ein wenig mit einem Daumenkino vergleichen.

Jetzt habe ich hier ständig von schlichten Befehlen geredet, aber das Wort "schlicht" trifft nicht wirklich zu. Die Grafikbefehle heutzutage sind sehr mächtig. Diese Grafikbefehle kommen in der Regel aus irgendwelchen Bibliotheken, zum Beispiel OpenGL oder Direct3D. Ich gehe nun mal davon aus, dass Java OpenGL irgendwie unterstützt, und vielleicht solltest du darüber ein paar Informationen sammeln (oder halt OpenGL oder Direct3D in C++, oder Direct3D in C#). Anfänglich ist es vielleicht gut ein Tutorial zu studieren welches einfach nur ein Dreieck auf den Bildschirm zeichnet und dieses eventuell durch Drehung animiert.

An diesem Punkt ist das der beste Tipp den ich dir geben kann, denn du wirst schnell feststellen das das Prinzip sehr anders ist.

EDIT: Meine Ausführungen gehen natürlich davon aus, dass du irgendwann diese Art von Grafikspielen entwickeln möchtest. Das ist also nur eine Anregung und keine Kritik, denn man muss ja schon eingestehen, dass die Java-Benutzeroberfläche für dein angestrebtes Ziel ausgereicht hat.

[hill 2]

Ich habe den Code mal kurz überflogen und finde ihn bis jetzt auch gut, also ohne ihn auszuprobieren. Falls ich das richtig verstanden habe, ist das im Prinzip Galgenmännchen.

Was die Grafikprogrammierung angeht, will ich Niki mal kurz ergänzen. Wenn du eine Möglichkeit suchst, mit Java Grafik zu programmieren, dann kann ich dir Slick2D wärmstens empfehlen. Es gibt soweit ich weiß keinen einfacheren Weg 2D Spiele mit Java zu erstellen.
Allerdings solltest du die englische Sprache einigermaßen beherschen, weil es nicht viele Tutorials auf Deutsch gibt. So habe ich das jedenfalls in Erinnerung.

Hier ist der Link zur Homepage: http://www.slick2d.org/

Und zu Slick2D Wiki: http://www.slick2d.org/wiki/index.php/Main_Page. Die Tutorials findest du unter "Others".

Man kann in Java natürlich auch das hauseigene Swing benutzen, aber das eignet sich für Spieleprogrammierung nicht wirklich. Wenn du C++ benutzen willst, dann ist SDL eine gute Wahl, aber darüber schreibe ich jetzt nichts, weil es dazu genug im Netz gibt.

Übrigens, wenn du erstmal bei der GUI-Programmierung bleiben willst, dann wäre ein Textadventure eine gute Idee. Dieses Genre wurde von den meisten schon vergessen, aber es ist leicht zu programmieren und kann viel Spaß machen, wenn die Story gut ist. Außerdem kann man es ja noch mit Bildern aufpeppen.

[Niki]

Übrigens, wenn du erstmal bei der GUI-Programmierung bleiben willst, dann wäre ein Textadventure eine gute Idee.

Das ist sogar eine ganz vorzügliche Idee, wenn man erst mal bei Swing bleiben möchte. In einem Textadventure kann man viele Dinge lernen die für Spiele wichtig sind, aber von der Grafik unabhängig sind.

[Terep]

Hallo Niki, hallo hill 2

Ihr habt den Finger auf meine Wunde gelegt.
Im ersten Abschnitt habe ich geschrieben: „Wichtiger ist es für mich, endlich einmal Grafikspiele zu entwickeln.“
Ich hatte mich eine Zeitlang programmiermäßig zurückgelehnt.
Mit dem Satzraten-Projekt aktualisiere ich mir mein Wissen, um anschließend endlich die Hürde zu richtigen Grafikgames zu überwinden. Das werde ich aber in einem anderen Thread thematisieren. Dann hoffe ich auf Eure Antworten.

Zurzeit habe ich dieses Satzraten als vorbereitendes Projekt. Geplant sind mehrere Stufen.
Auf jeden Fall werde ich in der nächsten Version auf englische Variabeln umstellen.
Wenn Ihr es als Spiel testen wollt, wartet bitte. Es macht noch nicht wirklich Spaß.

Danke für Eure Kommentare

Terep

[hill 2]

Keiner will seine Finger auf deine Wunde legen ;). Abgesehen davon stellt die Grafikprogrammierung keine so große Hürde da. Die Grundlagen hast du ja offensichtlich schon drauf, also mach dir keinen Kopf darum.
Ich werde das Spiel auf jeden Fall testen, sobald es fertig ist.