# Probleme bei Breakout - Brick kollision



## sdx677 (1. Mrz 2016)

Moin,

ich bin gerade dabei Java zu lernen und will BreakOut programmieren (das Spiel, das ungefähr alle Anfänger versuchen).

Ich scheitere gerade total an der Kollisionserkennung von Ball und Steinen, und bin dringend auf der Suche nach Tips.

Meine Vorgehensweise: Ich habe über das Spielfeld ein "Raster" gespannt.Dieses Raster habe ich nun als Array von Nullen und Einsen, wobei Null für "kein Stein" und Eins für "Stein" steht.
Der Nachteil ist, dass ich so nicht von jedem Stein die direkte Position habe und deshalb habe ich kein Plan wie ich die Kollisionserkennung angehen soll.Hat jemand nen Vorschlag für mich?

LG


----------



## InfectedBytes (1. Mrz 2016)

natürlich hast du von jedem Stein direkt die position. Dein Zeilen/Spaltenindex ist deine jeweilige Koordinate. Ggf noch mit einem bestimmten faktor multipliziert.
Umgekehrt, kannst du eben auch aus der position des Balls, die Koordinate in deinem Raster berechnen und somit eben auf Kollision schließen.


----------



## Jardcore (2. Mrz 2016)

Hey sdx677,

um auf InfectedBytes Beitrag etwas genauer einzugehen.

Spielen wir mal ein Szenario durch:

Du hast ein Ball Objekt mit einer X und Y Koordinate (x:10, y:30)
Du hast ein zweidimensionales 4x4 Boolean Array für die Belegung der Steine boolean[4][4] steine;
Dein Spielfeld ist 100 x 100 groß.

Wenn du jetzt wissen möchtest ob dein Ball ein Stein trifft kannst du das mathematisch wie folgt lösen:

Zuerst nimmst du die Koordinate deines Balls und dividierst sie durch die jeweilige Größe deines Spielfelds.
Danach multiplizierst du mit der jeweiligen Achse deines "steine" Arrays.
Anschließend kannst du prüfen ob dein Ball einen Stein getroffen hat.


```
public class Ball {
    private int x;
    private int y;

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }
}
```


```
//pseudocode
private boolean[][] steine = new boolean[4][4];
private static final int SPIELFELD_WIDTH = 100;
private static final int SPIELFELD_HEIGHT = 100;
private Ball ball;

public void collisionDetection() {
    // Ball = x: 10, y: 30;

    int xIndex,yIndex;

    xIndex = (int) (ball.getX() / SPIELFELD_WIDTH * steine.length); //0.4 ==> index 0
    yIndex = (int) (ball.getY() / SPIELFELD_HEIGHT * steine[0].length); //1.2 ==> index 1

    if(steinImWeg(xIndex, yIndex) {
        steine[xIndex][yIndex] = false;
    }
}

private boolean steinImWeg(int x, int y) {
    return steine[x][y];
}
```

Durch einen (int) cast bekommst du dann den x und y Index in dem sich dein Ball derzeit befindet.

Die Überlegung ist gerade vollständig aus meinem Kopf gekommen, deswegen können noch ein paar Fehler vorkommen.
Man muss vor Allem noch die Größe des Balles mit einberechnen.

Beste Grüße,
Jar


----------

