Post by Jonathan Heinen[...]
Post by Jochen Theodorouaber man könnte es sich auch ganz einfach machen und alles im Vorraus
abspeichern, als eine Art Sprite. Wenn man einfach ein 4x4-Feld nimmt, mit
einer 1 wo der Stein existiert und einer 0 wo nix ist, dann kann man das
ganze noch in ein byte packen
|Grundstellung | Drehung 1 | Drehung 2 | Drehung 3 |
|------------------------------------------------------
| " # " | " #" | " ## " | " " |
| " # " | " ###" | " # " | " ###" |
| " ## " | " " | " # " | " # " |
| " " | " " | " " | " " |
|------------------------------------------------------
| 4,4,6,0 | 1,7,0,0 | 6,2,2,0 | 0,7,4,0 |
Hihi ... ja genau darum ging es ja =) .. Ich meinte ja ich hätte keine
andere Lösung gefunden um die Steine schön zu drehen =)
So habe ich es dann im enddefekt auch gemacht. Fand es aber nicht gerade die
schönste Lösung!
Das Problem ist folgendes.. nehmen wir an du hast die Koordinaten ax,ay
und drehst um 0,0 dann ergibt sich folgendes:
Grundstellung: x=ax,y=ay
Drehung 1: x=-ay,y=ax
Drehung 2: x=-ax,y=-ay
Drehung 3: x=ay,y=-ax
das heisst rein rechnerisch kommt amn mit Drehung 4 dann auch wieder auf
die Grundstellung, das ist nicht das Problem. Das Problem ist, dass man
bei Spielen oft einen Kompromiss zwischen "gut aussehen" und "korrekt"
eingehen muss.das Problem liegt in dem Fall in der Wahl des
Mittelpunktes wenn du den Stein "####" betrachtest, so besteht er aus 4
Teilen: (-1.5,0),(-.5,0),(.5,0),(1.5,0) und sagen wir -1.5 geht von -2
bis -1, -.5 geht von -1 bis 0, aber was machen wir dann mit der 0? Ok,
sagen wir mal dass die 0 von 0-1 geht, .5 von 0-1 und 1.5 von 1-2, dann
bedeutet dass, das 0 und .5 den selben Bereich bezeichnen, was zu
Problemen führen könnte.. aber gut schauen wir uns dass mal graphisch an:
2112
+2" " " # " " " " # "
+1"####" Drehung-> " # " Drehung-> "####" Drehung-> " # "
-1" " " # " " " " # "
-2" " " # " " " " # "
und es gibt kein Problem
entsprechend gilt für das T: (-.5,0),(0,0),(+.5,0),(0,+0.5), das ist dann:
2112
+2" "
+1" ## "
-1" "
-2" "
und da fehlt plötzlich ein Teil, weil (0,0) und (0,.5) den selben
Bereich bezeichnen. Also neue Koordinaten: (-.5,0),(0,0),(+1.5,0),(0,+1.5):
2112
+2" # " " # " " " " # "
+1" ###" Drehung-> " ##" Drehung-> " ###" Drehung-> "# # "
-1" " " # " " " " # "
-2" " " " " # " " "
und plötzlich hängt der Stein nicht mehr zusammen man könnte die
Koordinaten nochmal ändern (-.5,0.5),(0,0.5),(+1.5,0.5),(0,+1.5):
2112
+2" # " " # " " " " # "
+1" ###" Drehung-> " ##" Drehung-> " " Drehung-> "## "
-1" " " # " " ###" " # "
-2" " " " " # " " "
und schon springt der Stein wieder ein wenig, dann erwarten würde man:
2112
+2" # " " # " " " " # "
+1" ###" Drehung-> " ##" Drehung-> " ###" Drehung-> " ## "
-1" " " # " " # " " # "
-2" " " " " " " "
Das Problem ist also nicht die Formel, oder den Mittelpunkt zu finden.
Das Problem ist, dass man man einen Bereich bezeichnet und dieser sich
optisch schlecht drehen lässt, wenn man gleiche Bereiche hat wie (0,0)
und (0.5,0), (0,.5) oder (.5,.5)
Will man es Graphics2D-mässig machen, so definiert man ein Polygon und
eine affine Transformation und hat dann nix praktisches für den
Kollisionstest.
So gesehen ist die Lösung von mir doch einfach, oder nicht? Und schön...
naja... du kannst dir die Zahlen ja berechnen lassen:
class SpriteStruct {
byte[] rows;
SpriteStruct (String[] rows) {
for (int i=0; i<4; i++) {
int n = 0;
for (int j=0; j<4; <++) {
int val = rows[i].charAt(j)!=' '?1:0;
n = n<<1 +val;
}
}
}
}
SpriteStruct[] stoneT = new SpriteStruct[]{
new SpriteStruct(new String[]{
" # "
" ###"
" "
" "
}),
new SpriteStruct(new String[]{
" # "
" ##"
" # "
" "
}),
new SpriteStruct(new String[]{
" "
" ###"
" # "
" "
}),
new SpriteStruct(new String[]{
" # "
" ## "
" # "
" "
})
};
oder wenn man es nebeneinander haben will:
SpriteStruct[] stoneT = buildStoneSpins(new String[]{
" # ", " # ", " ", " # "
" ###", " ##", " ###", " ## "
" ", " # ", " # ", " # "
" ", " ", " ", " "
});
und die entsprechende Funktion:
SpriteStruct[] buildStoneSpins(String[] parts) {
SpriteStruct[] structs = new SpriteStruct[4];
for (int i=0; i<4; i++) {
structs [i] = new SpriteStruct(new String[]{
parts[i],parts[i+4],parts[i+8],parts[i+16]
});
}
}
immer noch so unschön?
Gruss theo