3 Dimensionales Array durchlaufen - Algorithmus

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.
 
Ja ich weiß wie man ein Array durchläuft:

Java: 
	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]);
	}

Java: 
	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.
 
Zuletzt bearbeitet:
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
 
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
 
Zuletzt bearbeitet:
Und gerade nach Vorne?
Am besten du zeichnest dir ne Grafik. Dann Sieht man es deutlicher. Gilt übrigens für alle Projekte.
 
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 ^^
 
Zuletzt bearbeitet:
So damit funktioniert es jetzt:

Java: 
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]);
	}

Java: 
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
 
Zuletzt bearbeitet:
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?
 
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.
 
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.
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück