Return to Answer

Minor grammar fixes, markdown formatting

Source Link

edited Jul 1, 2022 at 8:38

5.5k
6
27
38

After a bunchlot of testing, I discovered there were some unnoticed errors when calculating the normal linevector angle and when repositioning the ball off the block. I'm going to take the upper-left corner to explain how I got to the solution.

//conditions for left side collisions if(ballX+ballWidth >= blockX && ballY+(ballHeight/2) >= blockY && ballY+(ballHeight/2) <= blockY+blockHeight && Math.abs((ballY+ballHeight)-blockY) >= Math.abs(ballX+ballWidth)-blockX) && Math.abs((blockY+blockHeight)-ballY) >= Math.abs((ballX+ballWidth)-blockX)) {not relevant here}

//conditions for upper side collisions else if(ballY+ballHeight >= blockY && ballX+(ballWidth/2) >= blockX && ballX+(ballWidth/2) <= blockX+blockWidth && Math.abs((ballX+ballWidth)-blockX) > Math.abs((ballY+ballHeight)-blockY) && Math.abs((blockX+blockWidth)-ballX) > Math.abs((ballY+ballHeight)-blockY)) {not relevant here}

//conditions for upper-left corner collisions else if(ball.contains(blockX, blockY) && ballY+(ballHeight/2) < blockY && ballX+(ballWidth/2) < blockX) {code}

//conditions for left side collisions
if(ballX+ballWidth >= blockX &&
ballY+(ballHeight/2) >= blockY &&
ballY+(ballHeight/2) <= blockY+blockHeight &&
Math.abs((ballY+ballHeight)-blockY) >= Math.abs(ballX+ballWidth)-blockX) && 
Math.abs((blockY+blockHeight)-ballY) >= Math.abs((ballX+ballWidth)-blockX)) 
{not relevant here}

//conditions for upper side collisions
else if(ballY+ballHeight >= blockY &&
ballX+(ballWidth/2) >= blockX &&
ballX+(ballWidth/2) <= blockX+blockWidth &&
Math.abs((ballX+ballWidth)-blockX) > Math.abs((ballY+ballHeight)-blockY) && Math.abs((blockX+blockWidth)-ballX) > Math.abs((ballY+ballHeight)-blockY)) 
{not relevant here}

//conditions for upper-left corner collisions
else if(ball.contains(blockX, blockY) && ballY+(ballHeight/2) < blockY && ballX+(ballWidth/2) < blockX) {code}

    else if(e1Mask.contains(e2Mask.getX(), e2Mask.getY()) &&
        e1Mask.getY()+((e1Mask.getHeight()-1)/2) < e2Mask.getY() && 
        e1Mask.getX()+((e1Mask.getWidth()-1)/2) < e2Mask.getX()) {
      prevX = newX; //previous ball position x (center point)
      prevY = newY; //previous ball position y (center point)
      newX = getX()+getRadius()-0.5; //new ball position x (center point)
      newY = getY()+getRadius()-0.5; //new ball position y (center point)
      double normal = Math.atan2(newY-e2Mask.getY(), newX-e2Mask.getX()); //normal line angle
      double inX = (getRadius()-0.5)*Math.cos(normal+Math.PI); //x coordinate from circle point that is inside the block
      double inY = (getRadius()-0.5)*Math.sin(normal+Math.PI); //y coordinate from circle point that is inside the block
      x -= (getX()+getRadius()+inX)-e2Mask.getX()-1; //ball repositioning x. Ball radius was added in order to get the correct coordinate result.
      y -= (getY()+getRadius()+inY)-e2Mask.getY()-1; //ball repositioning y. Ball radius was added in order to get the correct coordinate result.
      newX = getX()+getRadius()-0.5; //updated newX to calculate ball incoming angle
      newY = getY()+getRadius()-0.5; //updated newY to calculate ball incoming angle
      //Alternative way to repositioning the ball
      /*double inX = (getRadius()-0.5)*Math.cos(normal+Math.PI);
      double inY = (getRadius()-0.5)*Math.sin(normal+Math.PI);
      x = Game.bloco.getX()-(getRadius()-0.5+inX)-1;
      y = Game.bloco.getY()-(getRadius()-0.5+inY)-1;
      newX = getX()+getRadius()-0.5;
      newY = getY()+getRadius()-0.5;*/
      //
      //Didn't use these variables, but they helped me understand the logic
      /*double slopeNormal = Math.tan(normal); 
      double slopeRefLine = -1/slopeNormal;
      double refLine = normal + (Math.PI/2);*/
      //
      double prevAngle = Math.atan2(prevY-newY, prevX-newX); //ball incoming angle
      double incAngle = prevAngle - normal; //inciding angle
      double refAngle = normal - incAngle; //reflection angle
      spdX = Math.cos(refAngle); //new speedX value
      spdY = Math.sin(refAngle); //new speedY value
    }

After a bunch of testing, I discovered there were some unnoticed errors when calculating the normal line angle and when repositioning the ball off the block. I'm going to take the upper-left corner to explain how I got to the solution.

//conditions for upper-left corner collisions else if(ball.contains(blockX, blockY) && ballY+(ballHeight/2) < blockY && ballX+(ballWidth/2) < blockX) {code}

else if(e1Mask.contains(e2Mask.getX(), e2Mask.getY()) &&
    e1Mask.getY()+((e1Mask.getHeight()-1)/2) < e2Mask.getY() && 
    e1Mask.getX()+((e1Mask.getWidth()-1)/2) < e2Mask.getX()) {
  prevX = newX; //previous ball position x (center point)
  prevY = newY; //previous ball position y (center point)
  newX = getX()+getRadius()-0.5; //new ball position x (center point)
  newY = getY()+getRadius()-0.5; //new ball position y (center point)
  double normal = Math.atan2(newY-e2Mask.getY(), newX-e2Mask.getX()); //normal line angle
  double inX = (getRadius()-0.5)*Math.cos(normal+Math.PI); //x coordinate from circle point that is inside the block
  double inY = (getRadius()-0.5)*Math.sin(normal+Math.PI); //y coordinate from circle point that is inside the block
  x -= (getX()+getRadius()+inX)-e2Mask.getX()-1; //ball repositioning x. Ball radius was added in order to get the correct coordinate result.
  y -= (getY()+getRadius()+inY)-e2Mask.getY()-1; //ball repositioning y. Ball radius was added in order to get the correct coordinate result.
  newX = getX()+getRadius()-0.5; //updated newX to calculate ball incoming angle
  newY = getY()+getRadius()-0.5; //updated newY to calculate ball incoming angle
  //Alternative way to repositioning the ball
  /*double inX = (getRadius()-0.5)*Math.cos(normal+Math.PI);
  double inY = (getRadius()-0.5)*Math.sin(normal+Math.PI);
  x = Game.bloco.getX()-(getRadius()-0.5+inX)-1;
  y = Game.bloco.getY()-(getRadius()-0.5+inY)-1;
  newX = getX()+getRadius()-0.5;
  newY = getY()+getRadius()-0.5;*/
  //
  //Didn't use these variables, but they helped me understand the logic
  /*double slopeNormal = Math.tan(normal); 
  double slopeRefLine = -1/slopeNormal;
  double refLine = normal + (Math.PI/2);*/
  //
  double prevAngle = Math.atan2(prevY-newY, prevX-newX); //ball incoming angle
  double incAngle = prevAngle - normal; //inciding angle
  double refAngle = normal - incAngle; //reflection angle
  spdX = Math.cos(refAngle); //new speedX value
  spdY = Math.sin(refAngle); //new speedY value
}

After a lot of testing, I discovered there were some unnoticed errors when calculating the normal vector angle and when repositioning the ball off the block. I'm going to take the upper-left corner to explain how I got to the solution.

//conditions for left side collisions
if(ballX+ballWidth >= blockX &&
ballY+(ballHeight/2) >= blockY &&
ballY+(ballHeight/2) <= blockY+blockHeight &&
Math.abs((ballY+ballHeight)-blockY) >= Math.abs(ballX+ballWidth)-blockX) && 
Math.abs((blockY+blockHeight)-ballY) >= Math.abs((ballX+ballWidth)-blockX)) 
{not relevant here}

//conditions for upper side collisions
else if(ballY+ballHeight >= blockY &&
ballX+(ballWidth/2) >= blockX &&
ballX+(ballWidth/2) <= blockX+blockWidth &&
Math.abs((ballX+ballWidth)-blockX) > Math.abs((ballY+ballHeight)-blockY) && Math.abs((blockX+blockWidth)-ballX) > Math.abs((ballY+ballHeight)-blockY)) 
{not relevant here}

//conditions for upper-left corner collisions
else if(ball.contains(blockX, blockY) && ballY+(ballHeight/2) < blockY && ballX+(ballWidth/2) < blockX) {code}

    else if(e1Mask.contains(e2Mask.getX(), e2Mask.getY()) &&
        e1Mask.getY()+((e1Mask.getHeight()-1)/2) < e2Mask.getY() && 
        e1Mask.getX()+((e1Mask.getWidth()-1)/2) < e2Mask.getX()) {
      prevX = newX; //previous ball position x (center point)
      prevY = newY; //previous ball position y (center point)
      newX = getX()+getRadius()-0.5; //new ball position x (center point)
      newY = getY()+getRadius()-0.5; //new ball position y (center point)
      double normal = Math.atan2(newY-e2Mask.getY(), newX-e2Mask.getX()); //normal line angle
      double inX = (getRadius()-0.5)*Math.cos(normal+Math.PI); //x coordinate from circle point that is inside the block
      double inY = (getRadius()-0.5)*Math.sin(normal+Math.PI); //y coordinate from circle point that is inside the block
      x -= (getX()+getRadius()+inX)-e2Mask.getX()-1; //ball repositioning x. Ball radius was added in order to get the correct coordinate result.
      y -= (getY()+getRadius()+inY)-e2Mask.getY()-1; //ball repositioning y. Ball radius was added in order to get the correct coordinate result.
      newX = getX()+getRadius()-0.5; //updated newX to calculate ball incoming angle
      newY = getY()+getRadius()-0.5; //updated newY to calculate ball incoming angle
      //Alternative way to repositioning the ball
      /*double inX = (getRadius()-0.5)*Math.cos(normal+Math.PI);
      double inY = (getRadius()-0.5)*Math.sin(normal+Math.PI);
      x = Game.bloco.getX()-(getRadius()-0.5+inX)-1;
      y = Game.bloco.getY()-(getRadius()-0.5+inY)-1;
      newX = getX()+getRadius()-0.5;
      newY = getY()+getRadius()-0.5;*/
      //
      //Didn't use these variables, but they helped me understand the logic
      /*double slopeNormal = Math.tan(normal); 
      double slopeRefLine = -1/slopeNormal;
      double refLine = normal + (Math.PI/2);*/
      //
      double prevAngle = Math.atan2(prevY-newY, prevX-newX); //ball incoming angle
      double incAngle = prevAngle - normal; //inciding angle
      double refAngle = normal - incAngle; //reflection angle
      spdX = Math.cos(refAngle); //new speedX value
      spdY = Math.sin(refAngle); //new speedY value
    }

Source Link

answered Jul 1, 2022 at 2:13

Andre

The normal angle error happened when the ball collided with the block corner and its center point Y was below (greater than) the block corner Y or the center point X was greater than the block corner X. This caused the normal angle to get a positive value (ex. 180 degrees or more) and a value greater than -90 degrees, respectively. The correct normal angles for the upper-left block corner must range between -180 and -90 degrees.

To solve this, I made some adjustments in the conditions to differentiate the collisions on the sides from those on the corners, so that I can always get a normal angle for the upper-left corner from -180 to -90 degrees.

As for the ball repositioning part, I needed to get the X,Y point coordinate on the ball circle corresponding to the normal+PI angle, and then subtract the X,Y values plus the ball radius from the current X,Y ball position values. (Because I wasn't figuring out how to do this before, the ball repositioning was inaccurate, thus causing "multi collisions" issue and wrong reflection angles.)

Below is the pseudo-code on how I got correct reflection angles for the collisions between the ball and the upper-left corner of the block. I will still make slight adjustments for the other corners, but the logic is the same.

//conditions for upper-left corner collisions else if(ball.contains(blockX, blockY) && ballY+(ballHeight/2) < blockY && ballX+(ballWidth/2) < blockX) {code}

Code from upper-left corner collisions resolution made in Java:

else if(e1Mask.contains(e2Mask.getX(), e2Mask.getY()) &&
    e1Mask.getY()+((e1Mask.getHeight()-1)/2) < e2Mask.getY() && 
    e1Mask.getX()+((e1Mask.getWidth()-1)/2) < e2Mask.getX()) {
  prevX = newX; //previous ball position x (center point)
  prevY = newY; //previous ball position y (center point)
  newX = getX()+getRadius()-0.5; //new ball position x (center point)
  newY = getY()+getRadius()-0.5; //new ball position y (center point)
  double normal = Math.atan2(newY-e2Mask.getY(), newX-e2Mask.getX()); //normal line angle
  double inX = (getRadius()-0.5)*Math.cos(normal+Math.PI); //x coordinate from circle point that is inside the block
  double inY = (getRadius()-0.5)*Math.sin(normal+Math.PI); //y coordinate from circle point that is inside the block
  x -= (getX()+getRadius()+inX)-e2Mask.getX()-1; //ball repositioning x. Ball radius was added in order to get the correct coordinate result.
  y -= (getY()+getRadius()+inY)-e2Mask.getY()-1; //ball repositioning y. Ball radius was added in order to get the correct coordinate result.
  newX = getX()+getRadius()-0.5; //updated newX to calculate ball incoming angle
  newY = getY()+getRadius()-0.5; //updated newY to calculate ball incoming angle
  //Alternative way to repositioning the ball
  /*double inX = (getRadius()-0.5)*Math.cos(normal+Math.PI);
  double inY = (getRadius()-0.5)*Math.sin(normal+Math.PI);
  x = Game.bloco.getX()-(getRadius()-0.5+inX)-1;
  y = Game.bloco.getY()-(getRadius()-0.5+inY)-1;
  newX = getX()+getRadius()-0.5;
  newY = getY()+getRadius()-0.5;*/
  //
  //Didn't use these variables, but they helped me understand the logic
  /*double slopeNormal = Math.tan(normal); 
  double slopeRefLine = -1/slopeNormal;
  double refLine = normal + (Math.PI/2);*/
  //
  double prevAngle = Math.atan2(prevY-newY, prevX-newX); //ball incoming angle
  double incAngle = prevAngle - normal; //inciding angle
  double refAngle = normal - incAngle; //reflection angle
  spdX = Math.cos(refAngle); //new speedX value
  spdY = Math.sin(refAngle); //new speedY value
}

Certainly there are other ways to resolve collisions between circles and rectangles vertices, even better ones than mine but, at least, this one has worked for me, and I hope it can help other game developers who are facing the same challenges.

My best wishes to you all!