Breakout

P

Polskaplaya123

Mitglied
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





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;
                    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;}
}
 
Zuletzt bearbeitet:
M

Marco13

Top Contributor
Nee, ist "Processing" (Siehe http://www.java-forum.org/softwareentwicklung/101184-frage-processing.html ). Da solche Funktionen wie
Java: 
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
Code: 
if (pos_y >= 600)
{
    noLoop();
}
if (arrayEnthältKeineSteineMehr())
{
    noLoop();
}
Die Methode wäre dann z.B. so
Code: 
    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...
 
M

Marco13

Top Contributor
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
Code: 
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..
 
P

Polskaplaya123

Mitglied
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 ;)
 
M

Marco13

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

Java: 
    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;
        
    }
 
M

Marco13

Top Contributor
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
Code: 
...
und da ist dies-und-das passiert, und dann habe ich dies-und-das versucht
Code: 
...
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.
 
P

Polskaplaya123

Mitglied
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?
 
M

Marco13

Top Contributor
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
Code: 
                   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

Landei

Top Contributor
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.
 
M

Marco13

Top Contributor
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 :oops: ) aber... an den übrigen Punkten ändert das nichts.
 
P

Polskaplaya123

Mitglied
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 ;)
 
M

Marco13

Top Contributor
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...
 
P

Polskaplaya123

Mitglied
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]
 
M

Marco13

Top Contributor
Java: 
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));
    }
    
    
}
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
S Probleme bei Breakout - Brick kollision Spiele- und Multimedia-Programmierung 2
V Basisprinzipien Breakout-Spiel Spiele- und Multimedia-Programmierung 8
G Breakout-Klon (Applet!) Spiele- und Multimedia-Programmierung 18
L Abprallbedingung bei Breakout Spiele- und Multimedia-Programmierung 6

Ähnliche Java Themen

Aktuelle Jobs

Neue Themen


Oben