# Kollision funktioniert nicht richtig bei zu schneller Geschwindigkeit des Spielers



## AgentP (7. Okt 2020)

Hallo, ich bin grade dabei ein kleines Jump and Run zu Programmieren. ich beschäftige mich gerade mit der Kollision zwischen der Spielfigur (noch ein Rechteck) und einem Wandblock (ebenfalls ein Rechteck) von allen Seiten. Wenn der Spieler an die jeweilige Seite der Wand kollidiert, soll er an dieser Seite gehalten werden. Also er soll nicht durch die Wand durch kommen. Das funktioniert soweit auch gut, solange die Geschwindigkeit des Spielers nicht allzu hoch ist.
Sobald die Geschwindigkeit des Spieler zu hoch wird, also der Spieler z.B immer 6 Pixel pro Update in die jeweilige Richtung gesetzt wird, funktioniert die Kollision nicht mehr. Die Pixel, die der Spieler dann immer in die jeweilige Richtung gesetzt wird, sind größer, als die Pixel der Rechtecke für die Kollision.  Deswegen sind dann minimal 2 Kollisionsabfragen gleichzeitig (oder leicht versetzt) true, und der Spieler wird falsch zurückgesetzt. 
Wenn ich die Rechtecke für die Kollision noch größer mache, also der grüne Bereich auf dem Bild, würden die Ecken des Spieler immer mehr kein Teil mehr der Kollision sein, was ja irgendwie auch doof ist.  Ich weiß nicht, wie ich das Problem losen soll.

die Grünen Stellen auf dem Bild die die Rechtecke,  fürs Kollidieren.
Rot ist die Spielfigur alle anderen sollen Wände darstellen.



Hier werden die Rechtecke für die Wände erstellt (für die Kollisionsabfrage):


```
public Rectangle getBounds() {
        return new Rectangle(getX(), getY(), width, height);
    }
```



Hier werden die Rechtecke für den Spieler erstellt (für die Kollisionsabfrage):


```
public Rectangle getBoundsTop() {
        return new Rectangle(getX()+10, getY(), width-20, 5);
    }
    
    public Rectangle getBoundsBottom() {
        return new Rectangle(getX()+10, getY() + height-5, width-20, 5);
    }
    
    public Rectangle getBoundsLeft() {
        return new Rectangle(getX(), getY()+10, 5, height-20);
    }
    
    public Rectangle getBoundsRight() {
        return new Rectangle(getX()+width-5, getY()+10, 5, height-20);
    }
```


Hier die Kollisionsabfrage (wird in einer Schleife aufgerufen, die alle 20ms geupdatet wird) :


```
private void collide() {

        for (Blocks b : Handler.block) {

            if (!b.collide)
                break;

            if (b.getType() == EntityType.WALL) {

                if (getBoundsTop().intersects(b.getBounds())) {

                    setVelY(0);
                    y = b.getY() + b.height;
                }

                if (getBoundsBottom().intersects(b.getBounds())) {

                    setVelY(0);
                    y = b.getY() - b.height;
                }

                if (getBoundsLeft().intersects(b.getBounds())) {

                    setVelY(0);
                    x = b.getX() + b.width;
                }

                if (getBoundsRight().intersects(b.getBounds())) {
                    setVelY(0);
                    x = b.getX() - b.width;
                }
            }
        }
    }
```


----------

