# Snake - Spiel



## xyss (5. Aug 2014)

Hallo,

Ich versuche mich wieder an einem weiteren kleinen Projekt, damit ich meine Java-Kenntnisse hinsichtlich GUI etc. ein wenig aufbessern kann. Diesmal geht es um den Klassiker Snake.

Ich habe einen Spielebildschirm erstellt, indem ich eine eigene Unterklasse von JPanel erstellt habe:


```
public class GameScreen extends JPanel implements Runnable {
...
}
```

Nun will ich aber natürlich ein wenig mehr drum herum einbauen (Buttons, Label für Highscore etc), also war meine Idee, dass ich in mein Frame ein großes JPanel packe, und auf dieses große JPanel den GameScreen, so dass ich drum herum freie Fläche für Buttons etc. habe. 

Zur Initialisierung des Frames habe ich folgendes:

```
GameScreen gs = new GameScreen();
		JPanel p = new JPanel();
		
		p.setPreferredSize(new Dimension(1000, 1000));
		JButton btnTest = new JButton("Test");
		btnTest.setBounds(0,0,50,20);
		p.add(btnTest);
		JButton btnTest2 = new JButton("Test");
		btnTest2.setBounds(0,100,50,20);
		p.add(btnTest2);
		
		p.add(gs);
		
		add(p);
		pack();
		setVisible(true);
		setLocationRelativeTo(null);
```

Was mich nun irritiert ist, dass die Buttons sich immer an gleicher Stelle befinden, egal, wie ich die Bounds setze.  Siehe hier:


----------



## Joose (5. Aug 2014)

Du gibst deinem JPanel kein spezifisches Layout. Hier kannst du nachlesen was dabei passiert 

Und eine Klasse die von JPanel erbt und Runnable implementiert ist sehr sehr komisch.
Ein JPanel ist eine Fläche zum Anzeigen von etwas! Dein Runnable Implementierung würde ich einfach in eigene Klasse auslagern.


----------



## xyss (5. Aug 2014)

Okay, also liegt's am Layout.
Ich bin trotzdem noch immer ein wenig verwirrt.
Muss ich beim frame selbst auch ein Layout festlegen?

Und irgendwie funktioniert das nicht so ganz:

Wenn ich "p.setLayout(null);" benutze, sind die Buttons zwar nachher richtig positioniert, aber der GameScreen (der Teil mit dem blauen Hintergrund, auf dem Screenshot bei dem 1. Post) ist nicht mehr sichtbar, also es ist einfach alles weiß.

lg


----------



## Joose (5. Aug 2014)

xyss hat gesagt.:


> Okay, also liegt's am Layout.
> Ich bin trotzdem noch immer ein wenig verwirrt.
> Muss ich beim frame selbst auch ein Layout festlegen?



Nein, aber dein JPanel 
	
	
	
	





```
p
```
 hat keines gesetzt bekommen. Daher war Default das FlowLayout aktiv -> alles von links nach rechts nebeneinander



xyss hat gesagt.:


> Und irgendwie funktioniert das nicht so ganz:
> 
> Wenn ich "p.setLayout(null);" benutze, sind die Buttons zwar nachher richtig positioniert,



Jap, aber "null"-Layout ist generell nicht zu empfehlen! 
Da sich so deine Controls nicht anpassen wenn sich die Fenstergröße ändert. -> nicht Userfreundlich 
Für kleine Sachen reicht es vielleicht usw, aber am besten gleichen mit richtigen LayoutManager dann muss man sich später nicht damit rumschlagen!



xyss hat gesagt.:


> aber der GameScreen (der Teil mit dem blauen Hintergrund, auf dem Screenshot bei dem 1. Post) ist nicht mehr sichtbar, also es ist einfach alles weiß.



Wo soll denn GameScreen angezeigt werden? Du erstellst zwar ein Objekt und fügst es auch dem JPanel 
	
	
	
	





```
p
```
 als Komponente hinzu. Aber wo legst du denn die Position fest wo es angezeigt werden soll? -> Da hast du schon ein Problem des "null"-Layouts


----------



## xyss (5. Aug 2014)

Welches Layout wäre dann zu empfehlen? Wenn ich ehrlich bin, hatte ich bisher immer Eclipse WindowBuilder benutzt, und dort "AbsoluteLayout" benutzt, was scheinbar eben das Null-Layout ist.
Die Layouts sehen irgendwie alle gewöhnungsbedürftig aus :autsch:

Ich hatte beim p-Panel tatsächlich keine Größe festgelegt, deswegen wurde es nicht angezeigt


----------



## xyss (5. Aug 2014)

Das Ganze ist wie gesagt aufgebaut aus dem P-Panel(Screen) (das Große, auf welchem auch die Buttons sind), und aus dem GameScreen (den Teil mit dem blauen Hintergrund). Mein Problem ist nun, dass, sobald ich auf einen Bereich des P-Panels klicke, sei es nun ein Button oder einfach eine weiße Fläche, verliere ich den Focus auf den GameScreen. Also funktionieren die Keypress-Events nicht mehr... wie kann ich das lösen?

So sieht die initialisierung des Frame aus:

```
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setTitle("Snake");
		setResizable(false);
		Screen p = new Screen();
		GameScreen gs = new GameScreen();
		
		gs.add(p);
		add(gs);
		pack();

		setLocationRelativeTo(null);
		setVisible(true);
```

So sieht die Initialisierung des Panel "Screen" aus

```
setPreferredSize(new Dimension(600+OFFSET, 600+OFFSET));
		
		JButton btnPause = new JButton("Pause (P)");
		btnPause.setBounds(0,0,50,20);
		add(btnPause);
		
		JButton btnLeer2 = new JButton("Test");
		btnLeer2.setBounds(0,500,50,20);
		add(btnLeer2);
```

Init des Panel "GameScreen":

```
setFocusable(true);
		requestFocusInWindow();
		addKeyListener(new Key()); //Die Klasse Key implementiert Key-Listener und überprüft, welche Taste gedrückt wurde
                setPreferredSize(new Dimension(WIDTH, HEIGHT));
		setBounds(0,0,WIDTH,HEIGHT);
		

		this.food = new ArrayList<food>();
		this.s = new Snake(2,TSIZE,1,MIN_Y);
		this.appleCount = 10;
		g = new Game(this);
		isPaused = false;
		g.start();
```


----------



## Joose (6. Aug 2014)

xyss hat gesagt.:


> Welches Layout wäre dann zu empfehlen? Wenn ich ehrlich bin, hatte ich bisher immer Eclipse WindowBuilder benutzt, und dort "AbsoluteLayout" benutzt, was scheinbar eben das Null-Layout ist.
> Die Layouts sehen irgendwie alle gewöhnungsbedürftig aus :autsch:



Aus diesem Grund finde ich es für "Anfänger" (was GUI Programmierung angeht) falsch mit WindowBuilder anzufangen. Da es nur einfaches "klicki-klacki" ist und der WB (oder auch andere) zeigen es vl richtig an, aber den Code dahinter verstehen dann die wenigstens 

Aber besser jetzt einarbeiten als später wo man wahrscheinlich viel weniger Lust dazu haben wird.
Jedes hat seine Tücken aber eben auch seine Vorteile! Wenn man es richtig einsetzt kann man wunderbare UIs zaubern 



xyss hat gesagt.:


> Das Ganze ist wie gesagt aufgebaut aus dem P-Panel(Screen) (das Große, auf welchem auch die Buttons sind), und aus dem GameScreen (den Teil mit dem blauen Hintergrund). Mein Problem ist nun, dass, sobald ich auf einen Bereich des P-Panels klicke, sei es nun ein Button oder einfach eine weiße Fläche, verliere ich den Focus auf den GameScreen. Also funktionieren die Keypress-Events nicht mehr... wie kann ich das lösen?



Einerseits glaube ich kann man Komponenten als Default-Focus festlegen, andererseits kannst du nach dem Button Event doch den Focus wieder per Code auf deinen GameScreen legen.


----------



## xyss (6. Aug 2014)

Ich kenn nur die Methode requestFocus() bzw requestFocusInWindow(), und bei denen hat sich nichts getan 


Dass es falsch war mit dem WindowBuilder anzufangen, habe ich ziemlich schnell gemerkt, ich glaube, ich habe 2 Programme mit dem Teil gemacht und mich dann lieber selbst befasst... 

Ein paar kleine Fragen am Rande:

Braucht man beim Frame setBounds() ? An sich reicht doch setPreferredSize(), oder nicht? 

Ich hab bei meinem Panel eine gewisse Größe:

```
setPreferredSize(new Dimension(WIDTH, HEIGHT));
```

Wenn ich nun meinem Frame die gleiche Größe gebe, und dann das Panel per add() draufpacke, ist das Panel nicht vollständig sichtbar, also ein Teil ist abgeschnitten. Das liegt denke ich mal daran, dass das Frame ja das Fenster ist, und dementsprechend eine Umrandung hat. Kann ich diese irgendwie mit einbinden? Ich hätte gerne, dass von der Höhe her das Panel exakt angezeigt wird. 


lg


----------



## xyss (6. Aug 2014)

Bin gerade dabei, ein 2. Frame für Einstellungen zu realisieren.

Ich habe an einer Stelle das hier:


```
JSlider sliderFoodCount = new JSlider(JSlider.HORIZONTAL, 1, 500, 1);
		sliderFoodCount.setMajorTickSpacing(499);
		sliderFoodCount.setBounds(20, 20, 200, 26);
		sliderFoodCount.setPaintTicks(true);
		sliderFoodCount.setPaintLabels(true);
```

Auf dem Frame zu sehen ist: nichts. Wenn ich die Zeile mit setPaintLabels entferne, ist der Slider zu sehen. Wieso?


----------



## Androbin (6. Aug 2014)

Zum "Focus-Lost"-Problem:
Hast du es bereits mit der Methode "JComponent#setFocusable( boolean )" versucht?

Zum "Frame-Umrandung"-Problem:
Hast du es bereits mit der Methode "JFrame#setUndecorated( boolean )" versucht?


----------



## xyss (6. Aug 2014)

Das mit setUndecorated hat geholfen, danke 

Ich hab das Focus-Problem mittlerweile umgangen, indem ich den Focus nicht auf ein Panel, sondern auf den Frame gelegt , und den Key-Listener ebenfalls im Frame eingebaut habe.


----------



## xyss (6. Aug 2014)

Folgendes Problem nun:

Mein Spiel hat eine restart()-Funktion, welche durch Drücken der Leertaste aktiviert wird. Dies Funktioniert auch. Wenn ich die restart()-Funktion jedoch aufrufe, nachdem das Spiel vorbei ist, tut sich nichts mehr (so als würde es irgendwo in einer Dauerschleife festhängen)

Konkret:

start():

```
public void start() {
		isRunning = true;
		thread = new Thread(this, "Snake");
		thread.start();
	}
```


stop():

```
isRunning = false;
		try {
			thread.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
```



```
public void run() {
		while(isRunning) {
			g.game(); //Game Methoden, wie z.B. Bewegungen etc.
			updateMenu(); //Updated die Label welche die Punktzahl anzeigen, also unwichtig
			if (g.getSnake().isCollided()){ //Überprüft ob die Schlange sich selbst erwischt hat
				restart();
			}
			box.repaint(); //box ist das Panel auf welchem die Label sind
			s.repaint(); //s ist das Panel auf welchem das Spiel läuft
			try {
				thread.sleep(g.getSleepTime());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
```



```
public void restart(){
		stop();
		
		int snakeSize = settings.getSnakeSize();
		int foodCount = settings.getFoodCount();
		double gameSpeed = settings.getGameSpeed();
		int foodToLevelUP = settings.getFoodToLevelUP();
		
		g = new Game(foodCount,snakeSize,gameSpeed,1,foodToLevelUP);
		s = new Screen(g);
		
		box = new Box();
		add(box);
		add(s);
		pack();
		
		setVisible(true);
		start();
	}
```

Wie gesagt, wenn ich durch Drücken der Taste "Leertaste" einfach nur restart() aufrufe, funktioniert es. Wenn ich es ohne if-Anweisung in der run() Methode aufrufe (also einfach die If-Anweisung drum herum entferne) funktioniert es ebenso (jedenfalls hing es am Anfangszustand fest, was ja die Folge von dauerhaftem Restart ist)

Bitte helft mir, ich bin verwirrt :bloed:


----------



## Androbin (6. Aug 2014)

Schick' uns doch bitte mal den Konstruktor der Klasse "Game"!


----------



## xyss (6. Aug 2014)

foodCount legt fest, wieviele "Futter"-Items gleichzeitig auf der Map sein sollen.
snakeSize bestimmt die Anfangsgröße der Schlange, mit der sie gespawnt wird.
gameSpeed legt die Geschwindigkeit der Schlange fest.
Direction bestimmt die Anfangsrichtung (1 ist äquivalent zu "rechts").
foodToLevelUP legt fest, nach wieviel Futter das Level um 1 erhöht wird (und damit der gameSpeed um 0.1)

setFoods() fügt in die ArrayList soviele Futter-Items wie von foodCount vorgegeben, mit zufälliger x und y Position im Feld.

Die 2 Game-Konstruktoren:


```
public Game(){
		foodCount = 3;
		snakeSize = 5;
		gameSpeed = 1.0;
		direction = 1;
		foodToLevelUP = 15;
		snake = new Snake (snakeSize, Screen.TILESIZE, 1,1);
		foods = new ArrayList<Food>();
		setFoods();
	}
	
	public Game(int foodCount, int snakeSize, double gameSpeed, byte initialDirection, int foodToLevelUP){
		if (foodCount < 1)
			foodCount = 1;
		this.foodCount = foodCount;
		this.snakeSize = snakeSize;
		this.foodToLevelUP = foodToLevelUP;
		this.gameSpeed = gameSpeed;
		this.direction = initialDirection;
		snake = new Snake (snakeSize, Screen.TILESIZE, 1,1);
		foods = new ArrayList<Food>();
		
		setFoods();
	}
```


setFoods():

```
public void setFoods(){
		while (foods.size() < foodCount){
			int x = random.nextInt(MAX_X-1);
			int y = random.nextInt(MAX_Y-1);
			
			food = new Food(x, y, Screen.TILESIZE);
			foods.add(food);
		}
	}
```


Snake-Konstruktor:

```
public Snake(int val, int tileSize, int startX, int startY){
		if(val < 2)
			val = 2;
		this.tileSize = tileSize;
		this.body = new ArrayList<SnakePart>(); //Restliche Elemente
		head = new SnakePart(startX,startY,tileSize); //1. Element der Schlange
		
		for (int i = 1; i < val; i++){
			grow = true;
			move(1); //Bewege die Schlange nach rechts und lasse sie wachsen(Die Schlange bewegt sich ja nicht wirklich, eigentlich verschiebt sich nur das erste Element, und das letzte wird entfernt."grow = true" legt fest, dass die Schlange gewachsen ist -> letztes element wird nicht entfernt.
		}
```

Food-Konstruktor:

```
public Food(int x, int y, int size){
		this.x = x;
		this.y = y;
		this.size = size;
	}
```


----------



## AndiE (6. Aug 2014)

Hi,

Threads sind für mich immer noch ein Buch mit "sechs Siegeln" (Eines ist schon ab). Darum frage ich, worauf wartet die "join"-Anweisung? Das kann ich nicht so nachvollziehen. Gibt es nicht nur einen aktiven Thread?


----------



## xyss (6. Aug 2014)

Beschreibung von join() durch die Java Doc:
"Waits for this thread to die."

Ich bin selbst auch noch schwach im Umgang mit Threads, und bei thread.wait() kommt bei mir immer eine Fehlermeldung, daher mach ich es einfach so, dass ich den Thread "kille" und neustarte für einen Restart.


----------



## Joose (7. Aug 2014)

xyss hat gesagt.:


> Beschreibung von join() durch die Java Doc:
> "Waits for this thread to die."



Die Frage zielte eher darauf ab, ob du weißt auf was sie bei dir im Code wartet?
Wäre es möglich das gewartetet wird während der entsprechende Thread einfach nicht enden kann?


----------



## xyss (7. Aug 2014)

Wenn ich aus der restart() Methode start() und stop() entferne, funktioniert es. Dann wird halt einfach nur ein neues Game und ein neuer Screen gesetzt, ohne dass der Thread neugestartet wird. Also liegt es auf jeden Fall am Thread.

@Joose, was für ein Grund kann es denn haben, dass der Thread nicht enden kann? Ich dachte join sorgt einfach dafür, dass der Thread endet... Das hier ist mein erstes Programm mit Threads 


Muss ich eigentlich, wenn ich eine Tasten-Funktion zum Beenden einbaue (z.B. Escape) den Thread manuell beenden, bevor ich das Programm beende? Das Beenden mach' ich mit "System.exit(0);"


----------



## Joose (7. Aug 2014)

xyss hat gesagt.:


> @Joose, was für ein Grund kann es denn haben, dass der Thread nicht enden kann? Ich dachte join sorgt einfach dafür, dass der Thread endet... Das hier ist mein erstes Programm mit Threads



Nein 
	
	
	
	





```
join()
```
 sorgt dafür das der Thread der diese Methode aufruft, solange wartet bis der entsprechende Thread beendet ist!

Erklräung:
Jedes Program hat von Haus aus einen Thread in dem es läuft. Nennen wir diesen Thread mal "M".
Jetzt startest du aus deinem Programm einen neuen Thread "T". Wenn du von "M" aus "T.join()" aufrufst wartet "M" solange bis "T" beendet wurde. (Wie dieser Thread beendet wird ist egal).



xyss hat gesagt.:


> Muss ich eigentlich, wenn ich eine Tasten-Funktion zum Beenden einbaue (z.B. Escape) den Thread manuell beenden, bevor ich das Programm beende? Das Beenden mach' ich mit "System.exit(0);"



Schön wäre es wenn du selbst alles beendest was du auch gestartet hast. Müssen tust du es nicht, aber es zeugt nicht von guter Programmierung.


----------



## xyss (7. Aug 2014)

Das heißt also, direkt beendet wird der Thread durch den join() Befehl nicht. Reicht es dann trotzdem, wenn man nur den join() Befehl benutzt oder muss ich den Thread manuell beenden? Wenn ja, wie? Thread.stop() oder Thread.destroy() soll man ja nicht mehr benutzen..

Desweiteren eine kleine Frage zu einem Filewriter, welcher die Highscores abspeichern soll in einer Txt:


```
writer = new FileWriter(file ,false);
     String sep = System.getProperty("line.separator");
     
     for (int i = 0; i < highscore.length; i++){
    	 writer.write(highscore[i]);
    	 writer.write(sep);
     }
     writer.flush();
     writer.close();
```

Wieso funktioniert das nicht? Wenn ich mir die Datei anschaue, ist sie leer. Liegt es daran, dass highscore_ vom Typ int sind? Jedenfalls funktioniert es, wenn ich highscore+"" schreibe._


----------



## Joose (7. Aug 2014)

Nein der 
	
	
	
	





```
join()
```
 Aufruf sorgt nur dafür das ein Thread auf einen anderen wartet solange bis dieser beendet ist.

Einen Thread sollte immer entsprechende Abbruchbedingungen definiert haben!
Daher sind Konstrukte wie

```
while(true) {
}
```
nicht sehr schön und in diesem Fall auch sehr hinderlich.

Zu dem FileWriter Problem:
:rtfm: 
Java Dokumentation - FileWriter


----------



## xyss (7. Aug 2014)

Naja, Abbruchbedingungen habe ich ja eigentlich...

run() wird nur ausgeführt, solange running gilt. und bei stop wird running auf false gesetzt, bzw bei start auf true. Oder bin ich jetzt komplett im falschen Film? :autsch:


----------



## Joose (7. Aug 2014)

xyss hat gesagt.:


> start():
> 
> ```
> public void start() {
> ...



Das ist dein Code den du gepostet hast.
Meiner Meinung nach (sofern ich den Code richtig interpretieren kann, leider sind die Methoden etwas aus dem Zusammenhang gerissen): In der 
	
	
	
	





```
run
```
Methode rufst du bei einer Kollision deiner Schlange 
	
	
	
	





```
restart
```
auf.
In 
	
	
	
	





```
restart
```
rufst du direkt 
	
	
	
	





```
stop
```
auf. In 
	
	
	
	





```
stop
```
wiederrum setzt du die Variable 
	
	
	
	





```
isRunning
```
auf false. Somit würde deine Schleife in run nicht weiterlaufen. Dann wartest du bis sich ein Thread beendet hat -> Welcher Thread soll sich denn beenden und wo setzt du die Abbruchbedingung von diesem Thread?

Es wäre hilfreicher die gesamten Klassen zuhaben und nicht nur Bruchstücke. Sollten sie sehr lange sein kürze den Code soweit wie möglich -> KSKB


----------



## xyss (7. Aug 2014)

Stimmt, das ist tatsächlich ein wenig komisch umgesetzt...

Eine Abbruchbedingung für den Thread lege ich ja in run() fest, oder? Dementsprechend wäre meine "Abbruchbedingung" aktuell der boolesche Wert isRunning, und sobald isRunning auf false gesetzt ist, ist die Abbruchbedingung erreicht und der Thread wird beendet, oder nicht?
Und wenn ich statt

```
try {
				thread.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
```


```
thread.stop()
```
 benutze?

Tut mir Leid, Threads liegen mir wirklich nicht 

Ich werde bei Gelegenheit den gesamten Code posten.

lg


----------



## Joose (7. Aug 2014)

xyss hat gesagt.:


> Eine Abbruchbedingung für den Thread lege ich ja in run() fest, oder? Dementsprechend wäre meine "Abbruchbedingung" aktuell der boolesche Wert isRunning, und sobald isRunning auf false gesetzt ist, ist die Abbruchbedingung erreicht und der Thread wird beendet, oder nicht?



Ja der Thread wird beendet wenn das nächste Mal die Bedingung in der while-Schleife geprüft wird und diese Schleife "beendet/verlassen" wird. Da du aber mit dem 
	
	
	
	





```
join()
```
 Aufruf den Thread wartend stellst, kann die Schleife in 
	
	
	
	





```
run
```
 nicht weiterarbeiten. Erst wenn der Thread 
	
	
	
	





```
thread
```
 (was auch immer das für ein Objekt ist) beendet ist.



xyss hat gesagt.:


> Tut mir Leid, Threads liegen mir wirklich nicht


Da man Multithreading für Spiele braucht ist es natürlich hilfreich davor sich mit Threads zu spielen.

Mache ein Testprojekt in welchem du dich mit 2 und mehrere Threads spielst
Das wären ein paar "Aufgaben" die man probieren sollte

2 threads parallel laufen lassen
2 threads abwechselnd laufen lassen
"hauptprogramm" soll warten bis X threads ihre arbeit verrichtet haben
thread pausieren und weiterlaufen lassen
thread pausieren und weiterlaufenlassen (wiederholen)


----------



## xyss (7. Aug 2014)

Gibt es neben der Java Documentation denn noch andere Quellen, die für Threads hilfreich sein könnten?

Ich habe jetzt mal die Methoden verändert:

start() wird nur durchgeführt, wenn running nicht gilt, und stop wird nur durchgeführt, wenn running gilt. Die while-Schleife bei run() kann so fertig durchlaufen.. ist das.. sagen wir mal "weniger falsch"? 
Eigentlich brauch ich doch immer nur einen einzigen Thread der am laufen ist, oder nicht? 

```
public void start() {
		if (!running){
			running = true;
			thread = new Thread(this, "Game");
			thread.start();
		}
	}
```



```
public void stop() {
		if (running){
			running = false;
}
}
```



```
public void run() {
		boolean coll = false;
		while(running) {
			g.game();
			updateMenu();
			if (g.getSnake().isCollided() || g.isMapCollision()){
				coll = true;
				stop();
			}
			box.repaint();
			s.repaint();
			
			try {
				thread.sleep(g.getSleepTime());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		if (coll)
			gameOver();
	}
```


```
public void restart(){
                stop();
		int snakeSize = settings.getSnakeSize();
		int foodCount = settings.getFoodCount();
		double gameSpeed = settings.getGameSpeed();
		int foodToLevelUP = settings.getFoodToLevelUP();
		int MapID = settings.getMapID();

		g = new Game(foodCount,snakeSize,gameSpeed,(byte)1,foodToLevelUP, IDtoMap(MapID));
		 
		
		s = new Screen(g);
		box = new Box();
		add(box);
		add(s);
		pack();
		
		setLocationRelativeTo(null);
		setVisible(true);
		start();
	}
```


----------



## Joose (7. Aug 2014)

Ja schaut schon besser aus, aber wie gesagt so aus dem Kontext gerissen kann man es nicht wirklich beantworten.

Wenn es jetzt aber "nur mehr" um Multithreading geht dann bitte mach ein neues Thema im Bereich "Spieleprogrammierung" auf, da es nichts mehr mit GUI zu tun hat


----------



## xyss (7. Aug 2014)

Alles klar, das werde ich dann demnächst machen. 

Hier markiere ich dann mal als "erledigt", da bis auf das Thread-Zeug alles sauber funktioniert. 

Ich bedanke mich für die Hilfe


----------

