# 3 Dimensionales Array durchlaufen - Algorithmus



## Dark Ranger (16. Januar 2008)

Guten Tag,

Ich habe ein 3 Dimensionales Array, dies stellt mein Spielfeld dar (Höhe, Breite und mehrere Ebenen).

Nun kann der User Steine setzen, egal auf welchen Punkt und auf welche Ebene, hauptsache ist nur dort ist kein anderer Punkt.

Nun will ich überprüfen, ob in die Breite in der Höhe oder in der Tiefe 4 Steine (horizontal,vertikal oder diagonal) hintereinander gesetzt sind.
Sollte dies der Fall sein, bekommt der Spieler einen Punkt und das Spiel geht weiter, allerdings werden diese Steine beim nächsten mal nicht mehr mitgezählt, also sollten wieder 4 Steine beieinander sein, aber ein Stein gehört schon zu einem Punkt, dann wird das nicht mehr als Punkt gezählt.

Nun suche ich nach einer Möglichkeit, dass ganze möglichst Effizent durchzulaufen. Nur fällt mir im moment nichts ein wie ich es am besten lösen könnte.

Könnt ihr mir da vielleicht weiterhelfen?


----------



## Matze (16. Januar 2008)

Ähh...
kann es sein, dass du dieses Thema doppelt angelegt hast?


----------



## lernen.2007 (16. Januar 2008)

Hallo,

3 dimensionale Array bedeutet für mich gleich 3- Wiederholungsschleifen(for, while, do-while) besser for. Weil du musst ja auf einzelne Array Felder zugreifen.

Gruß
lernen.2007


----------



## Dark Ranger (16. Januar 2008)

Ohh wollte ich nicht doppelt anlegen -.-

Alle Werte durchlaufen kann ich auch, aber ich brauche eher eine Idee wie ich es mache, dass ich erkenne wann der User einen Punkt bekommt.


----------



## zeja (16. Januar 2008)

Du legst dir ein temporäres Array an, welches genauso gross ist wie dein eigentliches Array.
Im temporären Array sind bestehen alle Felder aus einem Objekt mit Richtungsangaben (horizontal, vertikal, diagonal etc, alles ints und initial 0).

Dann läufst du mit 3 for-Schleifen über das richtige Array und schaust ob ein Feld gesetzt ist. Ist dies der Fall so erhöhst du im temporären Array jeder Feld welches in einer Entfernung von bis zu 3 Feldern in jeder Richtung (das sind wieder 3 for-schleifen) liegt für die entsprechende Richtung aus der du kommst um 1. Setzt du ein Feld auf 4 so hast du entsprechend 4 Steine in einer Reihe gehabt. In einem weiteren Array kannst du so markieren dass 4 Steine in diesem Feld nicht mehr beachtet werden sollen. Das temporäre Array kannst du sogar immer fortlaufend pflegen: Immer wenn ein Zug gemacht wurde erhöhst du die Punktzahl der umliegenden Felder.


----------



## Dark Ranger (16. Januar 2008)

Mhhh das verstehe ich nicht so ganz ist schwer zu lesen das ganze


----------



## lernen.2007 (16. Januar 2008)

Hallo,

an deiner Stelle werde ich in erstes Feld einen Wert anlegen, womit du prüfen kannst ob du dann die ganzen anderen Felder prüfen sollst oder nicht.

Gruß
lernen.2007


----------



## Dark Ranger (16. Januar 2008)

ein Feld muss ich ja mindestens prüfen!

Also mein Spielfeld ist so aufgebaut, dass ein Feld 3 Werte besitzen kann:
0 für Spieler 1
1 für Spieler 2
2 für nichts

@lernen.2007: Irgendwie werde ich aus deinen Kommentaren nicht schlauer, könntest du etwas genauer werden?

@zeja: Auch bei dir habe ich es selsbt nach mehrmaligem lesen nicht verstanden was du meintest


----------



## Matze (17. Januar 2008)

Wie währs, wenn du nicht alle Felder überprüfst, sondern du merkst dir wo der letzte Stein gesetzt wurde und von diesem aus schaust du mit den schon genannten Algoritmen 3 Felder in jede mögliche Richtung. Ist auch perfomrmanter als immer alles zu checken.


----------



## Dark Ranger (17. Januar 2008)

Joar kann ich auhc machen, trotzdem habe ich noch keine Ahnung wie ich das genau anstellen soll, da stehe ich noch nen bisschen aufm Schlauch.

An der Umsetzung hapert es ein wenig


----------



## Matze (17. Januar 2008)

Geh mal ganz langsam vor:
Du weißt doch sicher, wie man ein Array in einer for-Schleife durchläuft.
Dann machst du dass ganze mal mit einem 2D-Array und wenn das geht in einem 3D.


----------



## Dark Ranger (17. Januar 2008)

Ja ich weiß wie man ein Array durchläuft:


```
public void countPoints() {
		/*playerPoints[0]=0;
		playerPoints[1]=0;
		checked.clear();*/
		int tmp;
		for (int z1=0;z1<this.firstD;z1++) {
			for(int x=0;x<this.secondD;x++) {
				for(int y=0;y<this.thirdD;y++) {
					tmp = field[z1][x][y];
					if(tmp !=2) {
						if(testVertikal(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
						else if(testHorizontal(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
						else if(testDiagonalDown(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
						else if(testDiagonalUp(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
					}
				}
			}
		}
		print();
		output.setText("Spieler 1: "+playerPoints[0]+" Player 2: "+playerPoints[1]);
	}
```


```
public boolean testVertikal(int z1, int x, int y, int user) {
		boolean found=false;
		boolean contin=true;
		int counter=1;
		while((y+1)<this.thirdD && found==false && contin==true) {
			if(!checked.contains(z1+"-"+x+"-"+y)) {
				y++;
				if(field[z1][x][y]==user && !checked.contains(z1+"-"+x+"-"+y)) {
					counter++;
					if(counter==4) {
						checked.add(z1+"-"+x+"-"+y);
						checked.add(z1+"-"+x+"-"+(y-1));
						checked.add(z1+"-"+x+"-"+(y-2));
						checked.add(z1+"-"+x+"-"+(y-3));
						return true;
					}
				}
				else {
					counter=1;
					contin=false;
				}
			}
			else {
				contin=false;
			}
		}
		
		return found;
	}
```

Naja und der Rest sieht eigentlich genauso aus, nur halt zählt da dann y hoch oder x oder beides oder eins hoch eins runter usw.


----------



## Matze (17. Januar 2008)

Ok, dann schau jetzt mal, ob du ein 4x4 Felder großes Array so durchlaufen kannst, dass es alle nach deinen Vorstellungen (4 Gewinnt oder) Möglichkeiten überprüft und zwar nur diese. Wenn dass klappt versuchst du es mit einem 4x4x4 Felder großen Array


----------



## Dark Ranger (17. Januar 2008)

Joar klappt alles schon ganz gut, muss nur mal schauen was ich alles durchgehen muss!

Also in einer Ebene:
vertikal                                 --> funktioniert
horizontal                             --> funktioniert
diagonal-unten                      --> funktioniert
diagonal-oben                       --> funktioniert

gerade nach hinten               -->funktioniert
diagonal hinten rechts           --> funktioniert
diagonal hinten links             --> funktioniert
diagonal hinten oben             --> funktioniert
diagonal hinten unten            --> funktioniert
diagonal hinten rechts unten   --> funktioniert
diagonal hinten links unten     --> funktioniert
diagonal hinten rechts oben    --> funktioniert
diagonal hinten links oben      --> funktioniert


So ich glaube das sind dann alle


----------



## Matze (17. Januar 2008)

Und gerade nach Vorne?
Am besten du zeichnest dir ne Grafik. Dann Sieht man es deutlicher. Gilt übrigens für alle Projekte.


----------



## Dark Ranger (17. Januar 2008)

ob ich nun die ebenen von ebene0 bis ebene4 durchgehe oder von ebene4 bis ebene0, das dürfte doch egal sein!

ne Grafik habe ich schon!
Nur ich verstehe nicht, warum es geht wenn ich nur z hochzähle, also gerade durch die ebenen gehe, wenn ich aber z und y hochzähle, also nach hinten und nach unten, warum es dann nicht mehr geht 

Edit:   ARGH! Es geht jetzt, ist schon blöd wenn man die Funktion dann icht aufruft ^^


----------



## Dark Ranger (17. Januar 2008)

So damit funktioniert es jetzt:


```
public void countPoints() {
		/*playerPoints[0]=0;
		playerPoints[1]=0;
		checked.clear();*/
		int tmp;
		for (int z1=0;z1<this.firstD;z1++) {
			for(int x=0;x<this.secondD;x++) {
				for(int y=0;y<this.thirdD;y++) {
					tmp = field[z1][x][y];
					if(tmp !=2) {
						if(testVertikal(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
						else if(testHorizontal(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
						else if(testDiagonalDown(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
						else if(testDiagonalUp(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
						else if(testDepth(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
						else if(testDepthDown(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
						else if(testDepthUp(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
						else if(testDepthRight(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
						else if(testDepthLeft(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
						else if(testDepthRightUp(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
						else if(testDepthLeftUp(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
						else if(testDepthRightDown(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
						else if(testDepthLeftDown(z1,x,y,tmp)) {
							playerPoints[tmp]++;
						}
					}
				}
			}
		}
		//print();
		output.setText("Spieler 1: "+playerPoints[0]+" Player 2: "+playerPoints[1]);
	}
```


```
public boolean testVertikal(int z1, int x, int y, int user) {
		boolean found=false;
		boolean contin=true;
		int counter=1;
		while((y+1)<this.thirdD && found==false && contin==true) {
			if(!checked.contains(z1+"-"+x+"-"+y)) {
				y++;
				if(field[z1][x][y]==user && !checked.contains(z1+"-"+x+"-"+y)) {
					counter++;
					if(counter==4) {
						checked.add(z1+"-"+x+"-"+y);
						checked.add(z1+"-"+x+"-"+(y-1));
						checked.add(z1+"-"+x+"-"+(y-2));
						checked.add(z1+"-"+x+"-"+(y-3));
						return true;
					}
				}
				else {
					counter=1;
					contin=false;
				}
			}
			else {
				contin=false;
			}
		}
		
		return found;
	}
	
	public boolean testHorizontal(int z1, int x, int y, int user) {
		boolean found=false;
		boolean contin=true;
		int counter=1;
		while((x+1)<this.secondD && found==false && contin==true) {
			if(!checked.contains(z1+"-"+x+"-"+y)) {
				x++;
				//System.out.println(x+1);
				if(field[z1][x][y]==user && !checked.contains(z1+"-"+x+"-"+y)) {
					counter++;
					if(counter==4) {
						checked.add(z1+"-"+x+"-"+y);
						checked.add(z1+"-"+(x-1)+"-"+y);
						checked.add(z1+"-"+(x-2)+"-"+y);
						checked.add(z1+"-"+(x-3)+"-"+y);
						return true;
					}
				}
				else {
					counter=1;
					contin=false;
				}
			}
			else {
				contin=false;
			}
		}
		return found;
	}
	
	public boolean testDiagonalDown(int z1, int x, int y, int user) {
		boolean found=false;
		boolean contin=true;
		int counter=1;
		while((x+1)<this.secondD && (y+1)<this.thirdD && found==false && contin==true) {
			//System.out.println("Punkt: "+z1+"-"+x+"-"+y);
			if(!checked.contains(z1+"-"+x+"-"+y)) {
				x++;
				y++;
				//System.out.println(x+1);
				//System.out.println("Punkt1: "+z1+"-"+x+"-"+y);
				if(field[z1][x][y]==user && !checked.contains(z1+"-"+x+"-"+y)) {
					counter++;
					if(counter==4) {
						checked.add(z1+"-"+x+"-"+y);
						checked.add(z1+"-"+(x-1)+"-"+(y-1));
						checked.add(z1+"-"+(x-2)+"-"+(y-2));
						checked.add(z1+"-"+(x-3)+"-"+(y-3));
						return true;
					}
				}
				else {
					counter=1;
					contin=false;
				}
			}
			else {
				contin=false;
			}
		}
		return found;
	}
	
	public boolean testDiagonalUp(int z1, int x, int y, int user) {
		boolean found=false;
		boolean contin=true;
		int counter=1;
		while((x+1)<this.secondD && (y-1)>=0 && found==false && contin==true) {
			//System.out.println("Punkt: "+z1+"-"+x+"-"+y);
			if(!checked.contains(z1+"-"+x+"-"+y)) {
				x++;
				y--;
				//System.out.println(x+1);
				//System.out.println("Punkt1: "+z1+"-"+x+"-"+y);
				if(field[z1][x][y]==user && !checked.contains(z1+"-"+x+"-"+y)) {
					counter++;
					if(counter==4) {
						checked.add(z1+"-"+x+"-"+y);
						checked.add(z1+"-"+(x+1)+"-"+(y+1));
						checked.add(z1+"-"+(x+2)+"-"+(y+2));
						checked.add(z1+"-"+(x+3)+"-"+(y+3));
						return true;
					}
				}
				else {
					counter=1;
					contin=false;
				}
			}
			else {
				contin=false;
			}
		}
		return found;
	}
	
	public boolean testDepth(int z1, int x, int y, int user) {
		boolean found=false;
		boolean contin=true;
		int counter=1;
		while(found==false && contin==true) {
			//System.out.println("Punkt: "+z1+"-"+x+"-"+y);
			if(!checked.contains(z1+"-"+x+"-"+y)) {
				if((z1+1)==this.firstD) {
					z1=0;
				}
				else {
					z1++;
				}
				//System.out.println(x+1);
				//System.out.println("Punkt1: "+z1+"-"+x+"-"+y);
				if(field[z1][x][y]==user && !checked.contains(z1+"-"+x+"-"+y)) {
					counter++;
					if(counter==4) {
						checked.add(z1+"-"+x+"-"+y);
						checked.add((z1-1)+"-"+x+"-"+y);
						checked.add((z1-2)+"-"+x+"-"+y);
						checked.add((z1-3)+"-"+x+"-"+y);
						return true;
					}
				}
				else {
					counter=1;
					contin=false;
				}
			}
			else {
				contin=false;
			}
		}
		return found;
	}
	
	public boolean testDepthDown(int z1, int x, int y, int user) {
		boolean found=false;
		boolean contin=true;
		int counter=1;
		while((y+1)<this.thirdD && found==false && contin==true) {
			//System.out.println("Punkt: "+z1+"-"+x+"-"+y);
			if(!checked.contains(z1+"-"+x+"-"+y)) {
				if((z1+1)==this.firstD) {
					z1=0;
				}
				else {
					z1++;
				}
				y++;
				//System.out.println(x+1);
				//System.out.println("Punkt1: "+z1+"-"+x+"-"+y);
				if(field[z1][x][y]==user && !checked.contains(z1+"-"+x+"-"+y)) {
					counter++;
					if(counter==4) {
						checked.add(z1+"-"+x+"-"+y);
						checked.add((z1-1)+"-"+x+"-"+(y-1));
						checked.add((z1-2)+"-"+x+"-"+(y-2));
						checked.add((z1-3)+"-"+x+"-"+(y-3));
						return true;
					}
				}
				else {
					counter=1;
					contin=false;
				}
			}
			else {
				contin=false;
			}
		}
		return found;
	}
	
	public boolean testDepthUp(int z1, int x, int y, int user) {
		boolean found=false;
		boolean contin=true;
		int counter=1;
		while((y-1)>=0 && found==false && contin==true) {
			//System.out.println("Punkt: "+z1+"-"+x+"-"+y);
			if(!checked.contains(z1+"-"+x+"-"+y)) {
				if((z1+1)==this.firstD) {
					z1=0;
				}
				else {
					z1++;
				}
				y--;
				//System.out.println(x+1);
				//System.out.println("Punkt1: "+z1+"-"+x+"-"+y);
				if(field[z1][x][y]==user && !checked.contains(z1+"-"+x+"-"+y)) {
					counter++;
					if(counter==4) {
						checked.add(z1+"-"+x+"-"+y);
						checked.add((z1-1)+"-"+x+"-"+(y+1));
						checked.add((z1-2)+"-"+x+"-"+(y+2));
						checked.add((z1-3)+"-"+x+"-"+(y+3));
						return true;
					}
				}
				else {
					counter=1;
					contin=false;
				}
			}
			else {
				contin=false;
			}
		}
		return found;
	}
	
	public boolean testDepthRight(int z1, int x, int y, int user) {
		boolean found=false;
		boolean contin=true;
		int counter=1;
		while((x+1)<this.secondD && found==false && contin==true) {
			//System.out.println("Punkt: "+z1+"-"+x+"-"+y);
			if(!checked.contains(z1+"-"+x+"-"+y)) {
				if((z1+1)==this.firstD) {
					z1=0;
				}
				else {
					z1++;
				}
				x++;
				//System.out.println(x+1);
				//System.out.println("Punkt1: "+z1+"-"+x+"-"+y);
				if(field[z1][x][y]==user && !checked.contains(z1+"-"+x+"-"+y)) {
					counter++;
					if(counter==4) {
						checked.add(z1+"-"+x+"-"+y);
						checked.add((z1-1)+"-"+(x-1)+"-"+y);
						checked.add((z1-2)+"-"+(x-2)+"-"+y);
						checked.add((z1-3)+"-"+(x-3)+"-"+y);
						return true;
					}
				}
				else {
					counter=1;
					contin=false;
				}
			}
			else {
				contin=false;
			}
		}
		return found;
	}
	
	public boolean testDepthLeft(int z1, int x, int y, int user) {
		boolean found=false;
		boolean contin=true;
		int counter=1;
		while((x-1)>=0 && found==false && contin==true) {
			//System.out.println("Punkt: "+z1+"-"+x+"-"+y);
			if(!checked.contains(z1+"-"+x+"-"+y)) {
				if((z1+1)==this.firstD) {
					z1=0;
				}
				else {
					z1++;
				}
				x--;
				//System.out.println(x+1);
				//System.out.println("Punkt1: "+z1+"-"+x+"-"+y);
				if(field[z1][x][y]==user && !checked.contains(z1+"-"+x+"-"+y)) {
					counter++;
					if(counter==4) {
						checked.add(z1+"-"+x+"-"+y);
						checked.add((z1-1)+"-"+(x+1)+"-"+y);
						checked.add((z1-2)+"-"+(x+2)+"-"+y);
						checked.add((z1-3)+"-"+(x+3)+"-"+y);
						return true;
					}
				}
				else {
					counter=1;
					contin=false;
				}
			}
			else {
				contin=false;
			}
		}
		return found;
	}
	
	public boolean testDepthRightDown(int z1, int x, int y, int user) {
		boolean found=false;
		boolean contin=true;
		int counter=1;
		while((x+1)<this.secondD && (y+1)<this.thirdD && found==false && contin==true) {
			//System.out.println("Punkt: "+z1+"-"+x+"-"+y);
			if(!checked.contains(z1+"-"+x+"-"+y)) {
				if((z1+1)==this.firstD) {
					z1=0;
				}
				else {
					z1++;
				}
				x++;
				y++;
				//System.out.println(x+1);
				//System.out.println("Punkt1: "+z1+"-"+x+"-"+y);
				if(field[z1][x][y]==user && !checked.contains(z1+"-"+x+"-"+y)) {
					counter++;
					if(counter==4) {
						checked.add(z1+"-"+x+"-"+y);
						checked.add((z1-1)+"-"+(x-1)+"-"+(y-1));
						checked.add((z1-2)+"-"+(x-2)+"-"+(y-2));
						checked.add((z1-3)+"-"+(x-3)+"-"+(y-3));
						return true;
					}
				}
				else {
					counter=1;
					contin=false;
				}
			}
			else {
				contin=false;
			}
		}
		return found;
	}
	
	public boolean testDepthLeftDown(int z1, int x, int y, int user) {
		boolean found=false;
		boolean contin=true;
		int counter=1;
		while((x-1)>=0 && (y+1)<this.thirdD && found==false && contin==true) {
			//System.out.println("Punkt: "+z1+"-"+x+"-"+y);
			if(!checked.contains(z1+"-"+x+"-"+y)) {
				if((z1+1)==this.firstD) {
					z1=0;
				}
				else {
					z1++;
				}
				x--;
				y++;
				//System.out.println(x+1);
				//System.out.println("Punkt1: "+z1+"-"+x+"-"+y);
				if(field[z1][x][y]==user && !checked.contains(z1+"-"+x+"-"+y)) {
					counter++;
					if(counter==4) {
						checked.add(z1+"-"+x+"-"+y);
						checked.add((z1-1)+"-"+(x+1)+"-"+(y-1));
						checked.add((z1-2)+"-"+(x+2)+"-"+(y-2));
						checked.add((z1-3)+"-"+(x+3)+"-"+(y-3));
						return true;
					}
				}
				else {
					counter=1;
					contin=false;
				}
			}
			else {
				contin=false;
			}
		}
		return found;
	}
	
	public boolean testDepthRightUp(int z1, int x, int y, int user) {
		boolean found=false;
		boolean contin=true;
		int counter=1;
		while((x+1)<this.secondD && (y-1)>=0 && found==false && contin==true) {
			//System.out.println("Punkt: "+z1+"-"+x+"-"+y);
			if(!checked.contains(z1+"-"+x+"-"+y)) {
				if((z1+1)==this.firstD) {
					z1=0;
				}
				else {
					z1++;
				}
				x++;
				y--;
				//System.out.println(x+1);
				//System.out.println("Punkt1: "+z1+"-"+x+"-"+y);
				if(field[z1][x][y]==user && !checked.contains(z1+"-"+x+"-"+y)) {
					counter++;
					if(counter==4) {
						checked.add(z1+"-"+x+"-"+y);
						checked.add((z1-1)+"-"+(x-1)+"-"+(y+1));
						checked.add((z1-2)+"-"+(x-2)+"-"+(y+2));
						checked.add((z1-3)+"-"+(x-3)+"-"+(y+3));
						return true;
					}
				}
				else {
					counter=1;
					contin=false;
				}
			}
			else {
				contin=false;
			}
		}
		return found;
	}
	
	public boolean testDepthLeftUp(int z1, int x, int y, int user) {
		boolean found=false;
		boolean contin=true;
		int counter=1;
		while((x-1)>=0 && (y-1)>=0 && found==false && contin==true) {
			//System.out.println("Punkt: "+z1+"-"+x+"-"+y);
			if(!checked.contains(z1+"-"+x+"-"+y)) {
				if((z1+1)==this.firstD) {
					z1=0;
				}
				else {
					z1++;
				}
				x--;
				y--;
				//System.out.println(x+1);
				//System.out.println("Punkt1: "+z1+"-"+x+"-"+y);
				if(field[z1][x][y]==user && !checked.contains(z1+"-"+x+"-"+y)) {
					counter++;
					if(counter==4) {
						checked.add(z1+"-"+x+"-"+y);
						checked.add((z1-1)+"-"+(x+1)+"-"+(y+1));
						checked.add((z1-2)+"-"+(x+2)+"-"+(y+2));
						checked.add((z1-3)+"-"+(x+3)+"-"+(y+3));
						return true;
					}
				}
				else {
					counter=1;
					contin=false;
				}
			}
			else {
				contin=false;
			}
		}
		return found;
	}
```

Ganz schön viel Code ^^ kann man ja vielleicht noch ein bisschen vereinfachen, da ja viele Sachen überall gleich sind


----------



## Dark Ranger (17. Januar 2008)

*Frames hintereinander darstellen*

So mal etwas anderes:
Im moment ist es so, dass es ein Frame gibt und dort wird die aktuelle Ebene dargestellt, ich wollte es aber jetzt so haben, dass alle Ebenen dargestellt werden, wie auf dem Bidl gekennzeichnet.

Hier klicken für das Bild

Drückt man nun auf einen Knopf, dann soll das erste Frame verschwinden, alle anderen eins vorrücken und das erste Frame wieder hinten dran erscheinen.

Andersrum soll dies natürlich auch möglich sein also das hinten verschwindet, eins nach hinten rückzt alles und vorne das letzte wieder drankommt.

Nun ist die Frage, wie realisiere ich das am besten?

Im moment benutze ich die variable z die die aktuelle Ebene darstellt und berechne dadurch, welchem Button ich welche Farbe geben muss.

Jemand eine Idee?


----------



## Matze (17. Januar 2008)

Hmm, wie hast du vor die Ebenen Darzustellen? Reden wir jezt von "Virituellen" Ebenen oder 4 Frames?

Bitte benutz nur für änderrungen "Ändern"
Wenn du was neues postest wie z.b. Code, dann mach bitte ne neue Antwort, weil dann auch bei mir angezeigt wird, dass du wieder geschreiben hast.


----------



## Dark Ranger (17. Januar 2008)

Is mir eigentlich egal wie die Ebenen dargestellt werden, aber am liebsten hätte ich es so wie auf dem Bild zu sehen ist.

Im moment stelle ich das ganze noch in einem Frame da und veränder die Buttons darauf so, wie ich sie gerade für die Ebene brauche.


----------



## Matze (18. Januar 2008)

Dark Ranger hat gesagt.:


> Ganz schön viel Code ^^ kann man ja vielleicht noch ein bisschen vereinfachen, da ja viele Sachen überall gleich sind


-> In Methoden auslagern

Zu deinen Ebenen:
Ich kann mir noch immer net so recht vorstellen, aber wie wärs wenn du eine DesktopPane verwendest und dort 4 JInternalFrames reinpackst?


----------



## Dark Ranger (18. Januar 2008)

Im Moment wird immer nur eine Ebene angezeigt. Und man muss sich durchschalten. Wenn man das tut, dann wird das JFrame neu besetzt mit den Werten aus der nächsten Ebene.


Ich will es nun so haben, dass alle Ebenen schon vorhanden sind und in einem Frame oder InternalFrame oder was auch immer hintereinander ein bisschen versetzt angezeigt werden, so muss ich das Frame nicht immer wieder neu bestücken. Sondern muss nur die nächste Ebene nach vorne holen.

Du musst dir das so vorstellen, dass das ganze nachher eigentlich wie ein Stapel Papier aussieht, wenn du zum nächsten Blatt willst, nimmst du das aktuelle, fügst es hinten an und siehst dann das nächste. Umgekehrt kannst du es natürlich auch machen, du nimmst einfach das letzte Blatt und holst es nach vorne.

Edit: Das mit dem jDesktopPane werde ich mir mal anschauen.


----------



## wsl (18. Januar 2008)

Wenn es nur darum geht, mehrere Panels in einem Frame immer wieder auszutauschen, kannst du dir auch das CardLayout angucken.
So könntest du dir einfach für jede Ebene ein Panel erstellen und die immer wieder "per Name" anzeigen lassen.
http://java.sun.com/docs/books/tutorial/uiswing/layout/card.html

edit: Ahh, grade erst gelesen. Wenn du die Panels alle bissl versetzt hintereinander anzeigen willst, geht das natürlich nicht so : )


----------



## Dark Ranger (18. Januar 2008)

Ja ich wollte sie halt hintereinander und versetzt haben, so wie ein Block ^^


----------

