Kollisionserkennung bei Verarbeitung

Question

Ich habe ein Space Invaders-Spiel, an dem ich gerade arbeite. Sehr einfach und einfach. Bisher habe ich einen Shooter, der sich bewegt (links und rechts) und schießt. Ich habe auch einen Eindringling, der sich in einem Muster bewegt. Ich möchte, dass die Kugeln den Eindringling verschwinden lassen.

Also meine Frage ist, wie bekomme ich Kollisionserkennung zu arbeiten (nicht Farbkollision)? Wenn mir jemand zeigen kann, wie es gemacht wird, werde ich dankbar sein.

Hinweis: Ich wurde in der Vergangenheit dazu aufgefordert, zu viel Code einzugeben, daher hoffe ich, dass nur die Bullet- und Invader-Klasse der richtige Weg ist.

ArrayList <Bullet> bullets; 

class Bullet 
{ 
    float x; 
    float y; 
    float speed; 
    Bullet(float tx, float ty) 
    { 
    x = tx; 
    y = ty; 
    } 
    void display() 
    { 
    stroke(255, 0, 0); 
    fill(255); 
    ellipse(x,y, 10, 10); 
    } 
    void move() 
    { 
    y -= 5; 

} 
} 
void moveAll() 
{ 
    for(Bullet temp : bullets) 
    { 
    temp.move(); 
    } 
} 
void displayAll() 
{ 
    for(Bullet temp : bullets) 
    { 
    temp.display(); 
    } 
} 

Cell[][] grid; 

float i, j; 

boolean b3=false; 
boolean b4=true; 
boolean b5=false; 

int cols = 5; 
int rows = 2; 
color pixel; 

class Cell { 
    float cX,cY; 


    Cell(float tempX, float tempY, float tempW, float tempH) { 
    cX = tempX; 
    cY = tempY; 
    } 

    void display2() { 
    stroke(255, 0, 0); 
    fill(255, 0, 0); 
    rect(cX+30,cY+100,5,5); 
    rect(cX+35,cY+95,5,5); 
    rect(cX+35,cY+90,5,5); 
    rect(cX+40,cY+85,5,5); 
    rect(cX+45,cY+80,5,5); 
    rect(cX+50,cY+80,5,5); 
    rect(cX+55,cY+75,5,5); 
    rect(cX+60,cY+75,5,5); 
    rect(cX+65,cY+75,5,5); 
    rect(cX+70,cY+75,5,5); 
    rect(cX+75,cY+80,5,5); 
    rect(cX+80,cY+80,5,5); 
    rect(cX+85,cY+85,5,5); 
    rect(cX+90,cY+90,5,5); 
    rect(cX+90,cY+95,5,5); 
    rect(cX+95,cY+100,5,5); 
    rect(cX+95,cY+105,5,5); 
    rect(cX+95,cY+110,5,5); 
    rect(cX+95,cY+115,5,5); 
    rect(cX+90,cY+120,5,5); 
    rect(cX+85,cY+120,5,5); 
    rect(cX+80,cY+120,5,5); 
    rect(cX+75,cY+115,5,5); 
    rect(cX+70,cY+115,5,5); 
    rect(cX+70,cY+120,5,5); 
    rect(cX+70,cY+125,5,5); 
    rect(cX+65,cY+115,5,5); 
    rect(cX+60,cY+115,5,5); 
    rect(cX+55,cY+115,5,5); 
    rect(cX+55,cY+120,5,5); 
    rect(cX+55,cY+125,5,5); 
    rect(cX+50,cY+115,5,5); 
    rect(cX+45,cY+115,5,5); 
    rect(cX+45,cY+120,5,5); 
    rect(cX+40,cY+120,5,5); 
    rect(cX+35,cY+120,5,5); 
    rect(cX+30,cY+115,5,5); 
    rect(cX+30,cY+110,5,5); 
    rect(cX+30,cY+105,5,5); 
    rect(cX+40,cY+125,5,5); 
    rect(cX+40,cY+130,5,5); 
    rect(cX+45,cY+135,5,5); 
    rect(cX+50,cY+140,5,5); 
    rect(cX+55,cY+140,5,5); 
    rect(cX+60,cY+140,5,5); 
    rect(cX+65,cY+140,5,5); 
    rect(cX+70,cY+140,5,5); 
    rect(cX+75,cY+140,5,5); 
    rect(cX+80,cY+135,5,5); 
    rect(cX+85,cY+130,5,5); 
    rect(cX+85,cY+125,5,5); 



    if(b4==true) { //moving right 
     b3 = false; 
     b5 = false; 
     cX += 2; 
    } 
    else if(b5==true) { //moving left 
     b3 = false; 
     b4 = false; 
     cX -= 2; 
    } 

    if((b4 == true && cX >= 780) || (b5 == true && cX <= -1)) 
    { 
     b3 = true; //moving down 
     b4 = false; 
     b5 = false; 
    } 

    if(b3 == true) //moving down 
    { 
     cY += 3; 
     if (cY % 10 == 0) //moving down 10 pixels 
     { 
     b3=false; 
     if (cX >= 780) //if it is on the right edge 
     { 
      b4 = false; 
      b5 = true; 
     } 
     else if (cX <= -1) //if it is on the left edge 
     { 
      b4 = true; 
      b5 = false; 
      cY += 3; 
     } 
     } 
    } 
    } 

    void monster() 
    { 
      display2(); 
     } 
} 

Answer 1

Es gibt eine Reihe von Möglichkeiten, die Kollisionserkennung zu handhaben, die dies eine ziemlich große Frage macht. Aber ich werde auf zwei Ansätze konzentrieren, die wahrscheinlich nützlich wäre:

Ansatz 1: Kreis Kollision

Wenn Sie das Zentrum und die Größe von zwei Objekten kennen, können Sie einfach verwenden, um die dist() Funktion, um herauszufinden, Wie weit sind die beiden Objekte voneinander entfernt? Wenn diese Entfernung kleiner als ihre Größe ist, kollidieren die Objekte.

Hier ist ein kleines Beispiel:

void setup() { 
    size(500, 500); 
    ellipseMode(RADIUS); 
} 

void draw() { 
    background(0); 

    float circleOneX = width/2; 
    float circleOneY = height/2; 
    float circleOneRadius = 50; 

    float circleTwoX = mouseX; 
    float circleTwoY = mouseY; 
    float circleTwoRadius = 100; 

    if (dist(circleOneX, circleOneY, circleTwoX, circleTwoY) < circleOneRadius + circleTwoRadius) { 
    //colliding! 
    fill(255, 0, 0); 
    } else { 
    //not colliding! 
    fill(0, 255, 0); 
    } 

    ellipse(circleOneX, circleOneY, circleOneRadius, circleOneRadius); 
    ellipse(circleTwoX, circleTwoY, circleTwoRadius, circleTwoRadius); 
} 

Ansatz 2: Rechteck Kollision

Alternativ können Sie einen Begrenzungsrahmen um Ihre Objekte definieren. Dann brauchen Sie nur eine Reihe von if-Anweisungen, um zu überprüfen, ob diese Felder sich überhaupt überschneiden. Wenn ja, kollidieren die Objekte.

Hier ist ein kleines Beispiel:

void setup() { 
    size(500, 500); 
} 

void draw() { 
    background(0); 

    float rectOneX = width/2; 
    float rectOneY = height/2; 
    float rectOneWidth = 50; 
    float rectOneHeight = 50; 

    float rectTwoX = mouseX; 
    float rectTwoY = mouseY; 
    float rectTwoWidth = 100; 
    float rectTwoHeight = 100; 

    if (rectOneX < rectTwoX + rectTwoWidth && 
    rectOneX + rectOneWidth > rectTwoX && 
    rectOneY < rectTwoY + rectTwoHeight && 
    rectOneHeight + rectOneY > rectTwoY) { 
    //colliding! 
    fill(255, 0, 0); 
    } else { 
    //not colliding! 
    fill(0, 255, 0); 
    } 

    rect(rectOneX, rectOneY, rectOneWidth, rectOneHeight); 
    rect(rectTwoX, rectTwoY, rectTwoWidth, rectTwoHeight); 
} 

Beide Ansätze werden in the button example eingeführt, die mit Verarbeitung kommt.