# Kollision von jeder Seite des Blocks



## Helgon (28. Dez 2011)

Hey, ich hab ein kleines Problemen. Ausprobiert hab ich schon alles was mir in den Sinn kommt.

Ich wollt ne Kollision von nem Block basteln und ich wollt eben, dass die Kollision tatsächlich von jeder Seite korrekt ist, also egal von wo man kommt.



Von der Seite gehts | von oben/unten kommts eben zu diesem "durchschieben"






eine meiner wohl "saubersten" Lösungen war so was in etwa


```
if(this.intersects(s)){

	if(s instanceof Wall){
		System.out.println("Wall");
		this.x = lastX;
		return true;
	}
			
}else{
	lastX = this.x; // ansatz
		}
```

Das Problem ist eben, das es immer nur von 2 Seiten lösen kann.

so müsst ich 
	
	
	
	





```
lastX = (int) this.x
```
 machen um zu runden, damit der "Wiedereinstiegspunkt" nicht wieder in der Wand hängt.

Wenn man dann von Rechts kommt, müsste ich das gleiche machen aber nur aufrunden (und abfragen ob 
	
	
	
	





```
s.x+s.width < this.x
```
 ist und dann z.B. 
	
	
	
	





```
lastX = (int) this.x +1
```
aber das Problem ist dann, dass wen ich das gleiche auch für die Vertikale Achse mache es zu dem Problem kommt, das man auf dem Bild sieht (es schiebt sich zwar an die richtige Position, aber schräg durch den Block hindurch)

Ist grad ein wenig kompliziert das Problem zu erklären, aber ich hoffe das ihr versteht.

Habt ihr vllt nen Ansatz wie man sowas normalerweise löst, weil meine Idee erscheint mir nicht sehr intelligent -.-

Grüße


----------



## Helgon (28. Dez 2011)

Ich hab jetzt ne Lösung, würd nur gern wissen ob sowas "normal" ist, weil die Kollision so kompliziert abzufragen erscheint mir recht aufwendig, oder ist das etwa doch "normal"?

Optimal ist es leider auch nicht, man sieht immer son winziges Ruckeln (durch das zurückspringen)


```
if(s instanceof Wall){
				System.out.println("Wall");
				this.x = lastX;
				this.y = lastY;
				return true;
			}
			
		}else{
			
			if(parent.right && parent.left)
				lastX = (int) this.x + 2;
			else{
				if(parent.left)
					lastX = (int) this.x + 2;
				if(parent.right) 
					lastX = (int) this.x -2;
			}
			if(parent.down)
				lastY = (int) this.y - 2;
			if(parent.up)
				lastY = (int) this.y + 2;
			
		}
```

Grüße


----------



## Fu3L (28. Dez 2011)

Ich hab für mein BlockGame da ewig lange drüber nachgedacht und auch hier ein Topic eröffnet... Es ist tatsächlich nicht einfach. Wenn deine Lösung funktioniert, ist die schon recht kurz^^


----------



## Helgon (28. Dez 2011)

Mich freuts zu hören, dass ich nicht vollkommen behindert dumm bin  

Ich dachte schon "Das ist doch nurn Rechteck, da die Kollision kann doch nicht so schwer sein" xD

Wenn ich dazu komm muss ich mal gucken was passiert wenn man die Kollision bei 1-2K Blöcken berechnet. Da hab ich etwas "angst" vor xD


----------

