# Breakout



## Polskaplaya123 (2. Jun 2010)

Kann mir vielleicht jemand helfen und dieses spiel noch ein wenig verfeinern wie zum beispiel das der ball nicht so durch die kästchen fliegt und das man mit dem paddle lenken kann wohin der ball abspringen soll und das das stoppt wenn keine kästchen mehr da sind. 
Bin anfänger in diesem bereich deswegen kann ich das noch nicht so gut ;D






```
float f=0;
float geschwindigkeit_x = 5;
float geschwindigkeit_y = 5;
float a=255;
float b=0;
float pos_x=mouseX;
float pos_y=570;
 
 
int[][] level_1 = 

{ 

              {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
};
 
 
 
 
 
 
void setup()
{
size(600,577);
frameRate(40);
}
 
void draw()
{
background(#000000);
noStroke();
fill(255,200,0);
ellipse(pos_x,pos_y,20,20);
rectMode(CENTER);
rect(mouseX,560,120,20);
rectMode(CORNER);
fill(a);
stroke(0);
level();
 
// verändern von x
if (pos_x <= 25) {geschwindigkeit_x = random(6,13);}
if (pos_x >= 570) {geschwindigkeit_x = random(-6,-13);}
pos_x = pos_x + geschwindigkeit_x;
 
if (!kollision())
        {
            // verändern von y
            if (pos_y <= 25)
            {
                geschwindigkeit_y = random(6, 13);
            }
            if (pos_y >= 545 && pos_x <= mouseX + 50 && pos_x >= mouseX - 50)
            {
                geschwindigkeit_y = random(-6, -13);
            }
            pos_y = pos_y + geschwindigkeit_y;
        }
        
        if (pos_y >= 600)
        {
            noLoop();
        }
}
    
        
    boolean kollision()
    {
        for (int zeile = 0; zeile < (level_1.length); zeile++) // Reihe
        {
            for (int spalte = 0; spalte < (level_1[0].length); spalte++)// Spalte
            {
                if (level_1[zeile][spalte] == 3)
                {
                    
                    
                    float x0 = spalte * level_1.length;
                    float y0 = zeile * level_1.length;
                    float w = width / level_1.length;
                    float h = height / level_1.length;
                    float centerX = x0 + w/2;
                    float centerY = y0 + h/2;
                    if (abstand(pos_x, pos_y, centerX, centerY) < 10)
                    {
                        // Bei einer Kollision, lösche den Stein und 
                        // ändere die Bewegungsrichtung
                        level_1[zeile][spalte] = 0;
                        geschwindigkeit_y = random(-6, -13);
                        return true;
                    }
                }
            }
        }
        return false;
        
    }
 
 
 
int level()
{
int anzahl_pillen = 0;
for (int zeile = 0; zeile < (level_1.length); zeile++) // Reihe
{
for (int spalte = 0; spalte < (level_1[0].length); spalte++)// Spalte
{
// Hintergrund zeichnen
if (level_1[zeile][spalte] == 1)
{
fill(#FFFFFF);
rect (spalte*level_1.length,zeile*level_1.length,width/level_1.length,height/level_1.length);
}
if (level_1[zeile][spalte] == 3)
{
fill(#7fff00);
rect (spalte*level_1.length,zeile*level_1.length,width/level_1.length,height/level_1.length);
}
 
 
// Pillen zeichnen
if (level_1[zeile][spalte] == 2)
{
fill(#ffa500);
rect(spalte*level_1.length+level_1.length*0.5,zeile*level_1.length+level_1.length*0.5,5,5);
anzahl_pillen++;
}
}
}
return anzahl_pillen;
}
 
float abstand(float x1,float y1,float x2,float y2)
{return sqrt(sq(x2-x1)+sq(y2-y1));}
 
int gefangen()
{
if (abstand(pos_x, pos_y, pos_x, pos_y) < width/level_1.length)
{return 3;}
else
{return 0;}
}
```


----------



## Landei (3. Jun 2010)

Kann es sein, dass das Java*Script* oder so ist?


----------



## Marco13 (3. Jun 2010)

Nee, ist "Processing" (Siehe http://www.java-forum.org/softwareentwicklung/101184-frage-processing.html ). Da solche Funktionen wie

```
background(#000000);
noStroke();
fill(255,200,0);
```
usw. aber für die eigentliche Fragestellung nicht relevant sind, hatte ich empfohlen, die Frage nochmal hier reinzustellen (man hätte vielleicht den anderen Thread verlinken können). Die eigentlichen Berechnungen für Kollision & Co sind dabei (soweit ich das bisher gesehen habe) wie in "ganz normalem" Java.

Das Spiel zu Stoppen wenn keine Kästchen mehr da sind könnte man (wenn ich die jetzt-doch-nicht-Java-Methode "noLoop()" richtig interpretiere  ) ganz "brute force" so erreichen, dass man in jedem Schritt den ganzen Array durchläuft, und schaut, ob er noch Steine enthält

```
if (pos_y >= 600)
{
    noLoop();
}
if (arrayEnthältKeineSteineMehr())
{
    noLoop();
}
```
Die Methode wäre dann z.B. so

```
boolean arrayEnthältKeineSteineMehr()
    {
        for (int zeile = 0; zeile < (level_1.length); zeile++) // Reihe
        {
            for (int spalte = 0; spalte < (level_1[0].length); spalte++)// Spalte
            {
                if (level_1[zeile][spalte] == 3) // Oder welche werte Steine so haben können...
                {
                    return false; // Da war noch ein Stein!
                }
            }
        }
        return true;
    }
```

Das wäre relativ ineffizient, aber erstmal die einfachste Lösung. (Effizienter wäre, zu zählen, wie viele Steine es am Anfang gibt, und wie viele schon getroffen und aufgelöst wurden, aber das kann man vermutlich auch später noch einbauen)


Die eigentliche Frage: So eine Kollisionserkennung kann ein bißchen Fummeliger sein, es gibt da eine Menge Information dazu wenn man nach sowas wie collision OR intersection circle rectangle java sucht (vielleicht kann man sogar noch spezifischer werden, und das Wort "Breakout" dazunehmen  ). 

Es wäre wohl nicht schlecht, wenn man sehen würde, was du diesbezüglich bisher schon versucht hast (und was über das aus dem anderen Thread hinausgeht) ... Aber vielleicht postet ja noch jemand eine konkretere Antwort... Ein sehr ähnliches Thema wird nämlich auch gerade im Thread http://www.java-forum.org/spiele-mu...g/101266-ping-pong-ball-abprallen-lassen.html bespochen...


----------



## Polskaplaya123 (3. Jun 2010)

Okay alles gut jetzt brauche ich aber nur noch das der ball vernünftig abspringt von den kästchen der fliegt da immer durch


----------



## Marco13 (3. Jun 2010)

Hast du die Links mal angesehen? Wie machst du die Kollisionserkennung denn im Moment?


----------



## Polskaplaya123 (3. Jun 2010)

So wie du sie mir gezeigt hast


----------



## Marco13 (4. Jun 2010)

Ja, und darüber hinaus? Es gibt da 1000 mögliche Ansätze. Versuch' z.B. mal eine Methode zu schreiben, die zu einen gegebenen Punkt (x,y) und einer gegebenen Linie (x0,y0)-(x1,y1) den Punkt auf der Linie bestimmt, der dem gegebenen Punkt am nächsten ist

```
float closestPoint(float x0, float y0, float x1, float y1, float x, float y)
{
}
```
Die Methode könnte z.B. einen Wert zwischen 0 und 1 liefern (0=anfang der Linie, 0.5=mitte, 1.0=ende).

Es gäbe auch weniger "mathematische" Ansätze. Ein paar if-Abfragen würden vermutlich schon reichen, um ein "vernünftig erscheinendes" Abprallen hinzukriegen..


----------



## Polskaplaya123 (4. Jun 2010)

Okay ich kriegs jetzt nicht wirklich hin das mit dem abprallen das ist jetzt aber nicht soo wichtig viel wichtiger ist für mich das der ball nicht durch die kästchen durchläuft sondern richtig abprallt du hast das glaube ich gemacht das die mitte des balls und die mitte des kästchens verglichen werden.
Aber dann läuft der ball durch 
Das ist das einzige was ich jetzt noch hinbekommen möchte 
Dann bin ich im ansatz zufrieden


----------



## Marco13 (4. Jun 2010)

Ja, hier ist mal ein Wikipedia-Link der dir vielleicht weiterhelfen wird.


```
boolean kollision()
    {
        for (int zeile = 0; zeile < (level_1.length); zeile++) // Reihe
        {
            for (int spalte = 0; spalte < (level_1[0].length); spalte++)// Spalte
            {
                if (level_1[zeile][spalte] == 3)
                {
                    float x0 = spalte * level_1.length;
                    float y0 = zeile * level_1.length;
                    float w = width / level_1.length;
                    float h = height / level_1.length;

                    if (pos_y > y0 && pos_y < y0+h)
                    {
                        if (pos_x > x0 && pos_x < x0+w)
                        {
                            // Ball ist im Kästchen, pralle ab...

                            Hier musst du selbst was schreiben

                            level_1[zeile][spalte] = 0;
                            return true;
                        }
                    }
                }
            }
        }
        return false;
        
    }
```


----------



## Polskaplaya123 (4. Jun 2010)

Aha und wobei soll der link mir genau helfen ??


----------



## Marco13 (4. Jun 2010)

Es ist IMHO klar, dass das eine Hausaufgabe ist. Und Fragen wie "Wie geht das? Was muss ich eintippen? Kann ich ein Beispiel haben?" werden weniger wahrscheinlich zu einer ... ambitionierten, hilreichen Antwort führen, als Fragen wie 
"Ich habe das hier versucht

```
...
```
und da ist dies-und-das passiert, und dann habe ich dies-und-das versucht

```
...
```
und das hat nicht funktioniert weil dies-und-das passiert ist. Wo liegen die Fehler? Wie kann man das besser machen?"

Überleg' dir, wie man das Abprallen umsetzen könnte (da geht es nicht um Java oder Processing, sondern darum, dass du dir überlegst, wie man eine 2D-Kugel (einen Kreis) von einem Block (einem Rechteck) abprallen lassen kann), und versuch' dann, das was du dir überlegt hast, zu implementieren. Und wenn dabei Schwierigkeiten auftreten, werden dir die Leute hier im Forum sicher gerne helfen. Aber wenn du die ersten beiden Schritte (wie es IMHO offensichtlich ist) ausläßt, und NUR eine Lösung willst, wird's schwierig.


----------



## Polskaplaya123 (5. Jun 2010)

Das ist ja echt hilfreich ich arbeite mit dem programm und mit java und so dem allen vllt seit 3 wochen und dann wird man doch wohl fragen stellen dürfen wenn ich es nciht kann ich kann doch noch nicht einmal alle Befehle und so.
dann ist es doch normal das ich nachfrage wie ich das hinbekomme oder nicht?


----------



## Marco13 (5. Jun 2010)

Ja, es ist normal, und es ist OK nachzufragen, dafür ist so ein Forum da. Aber offenbar hältst du es nicht mal für nötig, zu posten, was du auf Zeilen wie

```
if (pos_y > y0 && pos_y < y0+h)
                    {
                        if (pos_x > x0 && pos_x < x0+w)
                        {
  ...
```
aufbauend oder als komplett eigene Ideen bisher gemacht oder dir zumindest überlegt hast. Wie schon gesagt: Es geht nicht um Java oder sonstwas, sondern darum, dass du zur Lösung dieses Problems bisher anscheinend NICHTS gemacht, aber auf jeden Fall (und auch auf mehrfache Nachfrage hin) bisher NICHTS gepostet hast. Wenn du andere Threads liest, wirst du sehen, dass viele hier (und nicht zletzt auch ich) sehr ausführlich und gedudig zu helfen bereit sind. (Wegen dieser Frage habe ich immerhin mal Processing installiert, das ganze compiliert, gestartet, ansatzweise nachvollzogen und dir auch schon einen Ansatz gezeigt, auf dem due hättest aufbauen können). Aber das ganze eben nicht wenn vom Fragesteller nur die dreiste Aufforderung kommt, man möge ihm doch bitteschön die Lösung präsentieren :noe:


----------



## Landei (5. Jun 2010)

Wie meine Frage gezeigt hat, kenne ich Processing nicht (obwohl ich seit mehr als 10 Jahren Java mache) und anderen wird es auch so gehen, und nur die wenigsten werden sich die Mühe machen, das Ding wie Marco zu installieren und sich reinzufitzen. Du benutzt also ein relativ unbekanntes Framework oder was auch immer, _erwähnst_ das noch nicht mal, zeigt wenig Lust, beim Aufdröseln des ehrlich gesagt ziemlich abschreckenden Codes selbst behilflich zu sein, und dann beschwerst du dich, anstatt mal ein wenig in die Puschen zu kommen und mitzudenken. Ich mach jetzt eine Dose Mitleid auf... Pfffffft.... Oooooooch... und gucke, ob ich vielleicht ein paar anderen Leuten helfen kann.


----------



## Marco13 (5. Jun 2010)

Nuja, Processing ist gar nicht soo unbekannt (war sogar schon ein mini-Tutorial in der c't drüber). Ich wollte es mir schon länger mal näher ansehen (genauso wie Scala  ) aber... an den übrigen Punkten ändert das nichts.


----------



## Polskaplaya123 (6. Jun 2010)

Wie meinst du das das ich nichts selber gemacht habeich habe das ganze spiel versucht zu schreiben und das was ich nicht konnte habe ich nachgefragt das ist doch normal oder nicht ??
Wenn ich das nicht hinkriege wird mir doch wohl jemand helfen können


----------



## Marco13 (6. Jun 2010)

Ja, aber du hast nichts zur Kollisionserkennung oder dem Abprallen gesagt. Ursprünglich hattest du dazu gar nichts, dann habe ich das mit der Abstandsberechnung angedeutet, aber von deiner Seite kam dazu nichts. Und solange da nichts kommt, bin ich hier erstmal raus...


----------



## Polskaplaya123 (6. Jun 2010)

ach komm schon bitte ich kriege das nicht hin ich versuche doch aber das geht nicht


----------



## Polskaplaya123 (6. Jun 2010)

Ich habe das jetzt soweit aber trotzdem springt der ball nicht ab sondern läuft durch

[Java]

float f=0;
float geschwindigkeit_x = 5;
float geschwindigkeit_y = 5;
float a=255;
float b=0;
float pos_x=mouseX;
float pos_y=570;


int[][] level_1 = 

{ 

              {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
              {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1},
};






void setup()
{
size(600,577);
frameRate(40);
}

void draw()
{
background(#000000);
noStroke();
fill(255,200,0);
ellipse(pos_x,pos_y,20,20);
rectMode(CENTER);
rect(mouseX,560,120,20);
rectMode(CORNER);
fill(a);
stroke(0);
level();

// verändern von x
if (pos_x <= 25) {geschwindigkeit_x = random(6,13);}
if (pos_x >= 570) {geschwindigkeit_x = random(-6,-13);}
pos_x = pos_x + geschwindigkeit_x;

if (!kollision())
        {
            // verändern von y
            if (pos_y <= 25)
            {
                geschwindigkeit_y = random(6, 13);
            }
            if (pos_y >= 545 && pos_x <= mouseX + 50 && pos_x >= mouseX - 50)
            {
                geschwindigkeit_y = random(-6, -13);
            }
            pos_y = pos_y + geschwindigkeit_y;
        }

        if (pos_y >= 600)
        {
            noLoop();
        }
}


  boolean kollision()
    {
        for (int zeile = 0; zeile < (level_1.length); zeile++) // Reihe
        {
            for (int spalte = 0; spalte < (level_1[0].length); spalte++)// Spalte
            {
                if (level_1[zeile][spalte] == 3)
                {
                    float x0 = spalte * level_1.length;
                    float y0 = zeile * level_1.length;
                    float w = width / level_1.length;
                    float h = height / level_1.length;

                    if (pos_y+10 > y0 && pos_y-10 < y0+h)
                    {
                        if (pos_x+10 > x0 && pos_x-10 < x0+w)
                        {
                            // Ball ist im Kästchen, pralle ab...

                             geschwindigkeit_y = random(-6, -13);

                            level_1[zeile][spalte] = 0;
                            return true;
                        }
                    }
                }
            }
        }
        return false;

    }



int level()
{
int anzahl_pillen = 0;
for (int zeile = 0; zeile < (level_1.length); zeile++) // Reihe
{
for (int spalte = 0; spalte < (level_1[0].length); spalte++)// Spalte
{
// Hintergrund zeichnen
if (level_1[zeile][spalte] == 1)
{
fill(#FFFFFF);
rect (spalte*level_1.length,zeile*level_1.length,width/level_1.length,height/level_1.length);
}
if (level_1[zeile][spalte] == 3)
{
fill(#7fff00);
rect (spalte*level_1.length,zeile*level_1.length,width/level_1.length,height/level_1.length);
}


// Pillen zeichnen
if (level_1[zeile][spalte] == 2)
{
fill(#ffa500);
rect(spalte*level_1.length+level_1.length*0.5,zeile*level_1.length+level_1.length*0.5,5,5);
anzahl_pillen++;
}
}
}
return anzahl_pillen;
}

float abstand(float x1,float y1,float x2,float y2)
{return sqrt(sq(x2-x1)+sq(y2-y1));}

int gefangen()
{
if (abstand(pos_x, pos_y, pos_x, pos_y) < width/level_1.length)
{return 3;}
else
{return 0;}
}



[/Java]


----------



## Marco13 (6. Jun 2010)

```
import processing.core.*;

public class Breakout extends PApplet
{

    float f = 0;
    float geschwindigkeit_x = 5;
    float geschwindigkeit_y = -5;
    float a = 255;
    float b = 0;
    float pos_x = 250;
    float pos_y = 540;

    int[][] level_1 =

    {

    { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
    { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 }, };

    public void setup()
    {
        size(600, 577);
        frameRate(40);
    }

    public void draw()
    {
        background(0xFFFFFF);
        noStroke();
        fill(255, 200, 0);
        ellipse(pos_x, pos_y, 20, 20);
        rectMode(CENTER);
        rect(mouseX, 560, 120, 20);
        rectMode(CORNER);
        fill(a);
        stroke(0);
        level();

        // verändern von x
        if (pos_x <= 25)
        {
            geschwindigkeit_x = -geschwindigkeit_x;
        }
        if (pos_x >= 570)
        {
            geschwindigkeit_x = -geschwindigkeit_x;
        }
        if (pos_y <= 25)
        {
            geschwindigkeit_y = -geschwindigkeit_y; 
        }
        if (pos_y >= 545)
        {
            if (pos_x >= mouseX - 50 && pos_x <= mouseX + 50)
            {
                geschwindigkeit_y = -geschwindigkeit_y;
                float position = (pos_x - mouseX) / 50;
                geschwindigkeit_x += position * 5;
            }
        }
        checkCollision();

        pos_y = pos_y + geschwindigkeit_y;
        pos_x = pos_x + geschwindigkeit_x;

        if (pos_y >= 600)
        {
            noLoop();
        }
    }

    boolean checkCollision()
    {
        for (int zeile = 0; zeile < (level_1.length); zeile++) // Reihe
        {
            for (int spalte = 0; spalte < (level_1[0].length); spalte++)// Spalte
            {
                if (level_1[zeile][spalte] == 3)
                {
                    float x0 = spalte * level_1.length;
                    float y0 = zeile * level_1.length;
                    float w = width / level_1.length;
                    float h = height / level_1.length;

                    float oldx = pos_x;
                    float oldy = pos_y;
                    float newx = pos_x + geschwindigkeit_x;
                    float newy = pos_y + geschwindigkeit_y;
                    
                    if (intersects(newx, oldy, 10, x0, y0, w, h))
                    {
                        geschwindigkeit_x = -geschwindigkeit_x; 
                        level_1[zeile][spalte] = 0;
                        return true;
                    }
                    if (intersects(oldx, newy, 10, x0, y0, w, h))
                    {
                        geschwindigkeit_y = -geschwindigkeit_y; 
                        level_1[zeile][spalte] = 0;
                        return true;
                    }
                }
            }
        }
        return false;
    }
    

    int level()
    {
        int anzahl_pillen = 0;
        for (int zeile = 0; zeile < (level_1.length); zeile++) // Reihe
        {
            for (int spalte = 0; spalte < (level_1[0].length); spalte++)// Spalte
            {
                // Hintergrund zeichnen
                if (level_1[zeile][spalte] == 1)
                {
                    fill(0x0FFFFF);
                    rect(spalte * level_1.length, zeile * level_1.length, width / level_1.length, height / level_1.length);
                }
                if (level_1[zeile][spalte] == 3)
                {
                    fill(0x0fffff);
                    rect(spalte * level_1.length, zeile * level_1.length, width / level_1.length, height / level_1.length);
                }

                // Pillen zeichnen
                if (level_1[zeile][spalte] == 2)
                {
                    fill(0x0fa500);
                    rect(spalte * level_1.length + level_1.length * 0.5f, zeile * level_1.length + level_1.length * 0.5f, 5, 5);
                    anzahl_pillen++;
                }
            }
        }
        return anzahl_pillen;
    }

    float abstand(float x1, float y1, float x2, float y2)
    {
        return sqrt(sq(x2 - x1) + sq(y2 - y1));
    }

    int gefangen()
    {
        if (abstand(pos_x, pos_y, pos_x, pos_y) < width / level_1.length)
        {
            return 3;
        }
        else
        {
            return 0;
        }
    }
    
    boolean intersects(float circlex, float circley, float circler, float rectx, float recty, float rectwidth, float rectheight)
    {
        float circleDistancex = abs(circlex - rectx - rectwidth/2);
        float circleDistancey = abs(circley - recty - rectheight/2);

        if (circleDistancex > (rectwidth/2 + circler)) { return false; }
        if (circleDistancey > (rectheight/2 + circler)) { return false; }

        if (circleDistancex <= (rectwidth/2)) { return true; } 
        if (circleDistancey <= (rectheight/2)) { return true; }

        float cornerDistance_sq = 
            (circleDistancex - rectwidth/2)*(circleDistancex - rectwidth/2) +
            (circleDistancey - rectheight/2)*(circleDistancey - rectheight/2);

        return (cornerDistance_sq <= (circler*circler));
    }
    
    
}
```


----------

