# Tetris Rotation?



## raven (3. Mrz 2009)

Hallo,
ich habe ein boolean 2d Array 10x20. true entspricht Stein, false halt keinen.
Dann habe ich eine Klasse Block mit ein boolean 2d Array 4x4 mit bekannten Tetris Figuren.
1111
0000
0000
0000

1000
1000
1100
0000

usw....

Meine Frage mit welchen Algorithmus drehe ich die verschiedenen Stein, ich habe bereits im Internet geguckt, aber nichts passendes gefunden. Mir ist auch klar das ich die verschiedenen Figuren vor abspeichern könnte, das ich nicht mehr drehen brauch, sondern nur noch die passende Figur aufrufen muss, aber das möchte ich nicht. Ich möchte ein möglichen Algorithmus der möglichst unabhängig von der jeweiligen Figur ist.

wäre schön, wenn einer von euch ein e Idee hätte...
mfg raven


----------



## hdi (3. Mrz 2009)

> Ich möchte ein möglichen Algorithmus der möglichst unabhängig von der jeweiligen Figur ist.



Tetris-Steine sind individuelle Gebilde, und es gibt keine gemeinsamen Regeln.
Es gibt ja noch nicht mal eine richtige Gemeinsamkeit bei den einzelnen Drehungen.
Entweder du legst dir also die verschiedenen Ausrichtungen zurecht, oder du berechnest
sie jedes mal neu beim drehen. Dafür kannst du zwar einen Algo schreiben, aber der ist 
länger und komplizierter als die paar Steinchen direkt rumzuschieben. Mit Unabhängigkeit
oder Abstraktion brauchst du hier nicht anfangen, das ist hier wie ich finde einfach fehl am Platz.
Tetris ist Tetris. Das ist ein spezielles Spiel. Irgendwo muss man nun mal dem Programm sagen,
was Sache ist.

Mach's dir also nich so umständlich: Leg dir für jeden Stein 1 bis 4 statische 2-d Arrays zurecht (je nach Stein),
und tausch die einfach über ein switch-Konstrukt aus:

[HIGHLIGHT="Java"]switch(ausrichtung){
      case linksgedreht : 2darray = SteinStatics.2darrayHochgedreht;
                                     ausrichtung = hochgedreht;
                                     break;
      // usw
}[/HIGHLIGHT]


----------



## raven (3. Mrz 2009)

ok danke! dann werd ich es wohl auch so machen... dachte nur vllt das so ein algo exestiert.... aber wenn ich mir das somit nur komplizierter mache, dann speichere ich mir sie wohl fest ein... danke!

mfg raven


----------



## hdi (3. Mrz 2009)

Du kannst dir vllt noch Maps machen, wenn du das unbedingt so ausdesignen willst:

[HIGHLIGHT="Java"]// irgendwo initialisieren, dann einfach public static zur Verfügung stellen:
Map<Integer,boolean[][]> stangeDirections = new HashMap<Integer,boolean[][]>();
stangeDirections.put(Params.STANGE_HORIZONTAL , {hier das passende 2darray};
//usw[/HIGHLIGHT]

So ne Map also für jeden Stein, dann wird die rotate Methode nicer:

[HIGHLIGHT="Java"]public void rotate(){
       // direction festlegen:
       direction = (direction == Params.STANGE_VERTIKAL ? Params.STANGE_HORIZONTAL : Params.STANGE_VERTIKAL)
       2darray = stangeDirections.get(direction);
}[/HIGHLIGHT]

oder so. Naja ob das wirklich so viel besser is, wahrscheinlich eher nicht


----------



## 0x7F800000 (3. Mrz 2009)

hdi hat gesagt.:


> Tetris-Steine sind individuelle Gebilde, und es gibt keine gemeinsamen Regeln.


Äääh? Werden die nicht einfach gedreht?

Ein rechteck um 90° drehen, das kriegt man ja wohl grad noch so hin^^ 
[HIGHLIGHT="Java"]

public class TetrisStoneRotation {

	private static boolean[][] rotateLeft(boolean[][] square){
		boolean[][] result=new boolean[square.length][square.length];
		for(int x=0; x<square.length; x++){
		for(int y=0; y<square.length; y++){
			result[x][y]=square[y][square.length-1-x];
		}
		}
		return result;
	}

	private static boolean[][] rotateRight(boolean[][] square){
		boolean[][] result=new boolean[square.length][square.length];
		for(int x=0; x<square.length; x++){
		for(int y=0; y<square.length; y++){
			result[x][y]=square[square.length-1-y][x];
		}
		}
		return result;
	}

	private static String stoneToString(boolean[][] square){
		String result="";
		for(int x=0; x<square.length; x++){
		for(int y=0; y<square.length; y++){
			result+=square[x][y]?'#':'X';
		}
		result+="\n";
		}
		return result;			
	}

	public static void main(String[] args){
		boolean[][] stone={{false,true,false,false},
							{false,true,true,false},
							{false,true,false,false},
							{false,false,false,false}};

		System.out.println(stoneToString(stone));
		System.out.println("\n"+stoneToString(rotateLeft(stone)));
		System.out.println("\n"+stoneToString(rotateRight(stone)));
	}
}

[/HIGHLIGHT]


----------



## hdi (3. Mrz 2009)

> Äääh? Werden die nicht einfach gedreht?



Wenn mich nicht alles irrt, liegen die Tetris-Steine nicht in einem Rechteck wie gegeben,
oder irgendeinem anderen Rechteck.
Die Tetris-Steine haben jeder für sich ne eigene Art, sich zu drehen. 
Wie gesagt: Ich leg jetz nich meine Hand ins Feuer dafür, aber ich glaube die durch
deinen Algo errechneten Drehungen sind nicht die Original Tetris-Drehungen.


----------



## 0x7F800000 (3. Mrz 2009)

Naja, es sind drehungen um 90° für beliebige quadrate... Wie sollen sich denn die tetris steine großartig anders drehen, außer an der Drehachse kann man hier doch gar nichts mehr ändern, und die Drehachse kann man beliebig auf Kästchengrenzen oder Zentren von Kästchen setzen.


----------



## hdi (3. Mrz 2009)

Ja aber diese Drehachse ist eben bei jedem Stein anders, und ich glaube sogar
je nach Ausrichtung anders. Diese L-Formen zB drehen sich nich so krass um einen
Mittelpunkt, sondern verschieben sich immer. Das macht es fairer weil man sonst 
schwer abschätzen kann wo das Teil landet wenn man's dreht.

Und wenn man wieder an der Stelle ist, dass man einen eigenen Algo für nahezu
jede Drehung braucht, kann man's gleich lassen


----------

