Question

So, I am creating the game breakout in processing (programming language) but can’t quite figure out a function to check for collision against the bat.

So far the section I have written for collision against the bat only collides the ball against the base and returns it in the opposite direction. For now, the game is a never ending phenomenon where the ball just collides with the walls. What I am trying to do is, collide the ball against the bat.

Oh this is my homework, so just please point me in the right direction instead of doing it for me.

Here’s the code:

// Basic Breakout game
// Code from Matthre Yee-King

// brick position
float brickX;
float brickY;

// brick width and height
float brickH;
float brickW;

// ball position
float ballX;
float ballY;

// ball diameter
float ballD;

// ball direction
float ballDx;
float ballDy;

// bat position
float batX;

//bat width
float batW;
float batH;

//bat colour
float batB;

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

  // set sizes of game items
  brickW = 100;
  brickH = 50;
  batW = 100;
  batH = 25;
  ballD = 25;
  batB = 255;

  // random brick position
  brickX = random(0, width - brickW);
  brickY = random (0, height / 2);

  // bat in the centre
  batX = (width/2) - (batW/2);

  // ball atop bat
  ballX = batX + (batW/2);
  ballY = height - batH - (ballD/2);

  // ball movement
  ballDx = random(-5, 5);
  ballDy = -5;
  rectMode(CORNER);
  ellipseMode(CENTER);
}

void draw() {
  // check for ball collision
  // with top or sides of bat
  checkBallAgainstBat();

  // check for ball collision with
  // left right and top walls
  // and bounce
  checkBallAgainstWalls();

  // check ball against brick
  checkBallAgainstBrick();

  // move the ball
  ballX += ballDx;
  ballY += ballDy;
  background(0);

  // draw the bat
  fill(0, 255, 0);
  rect(batX, height - batH, batW, batH);

  // draw the brick
  fill(0, 0, batB);
  batB = (batB + 10) % 255;
  rect(brickX, brickY, brickW, brickH);

  // draw the ball
  fill(255, 0, 0);
  ellipse(ballX, ballY, ballD, ballD);

  if (keyCode == 37) { // left cursor key
    batX -= 10;

    // keep it on the screen
    if (batX < 0) {
      batX = 0;
    }
  }

  if (keyCode == 39) {
    batX += 10;
    if (batX > (width - batW)) {
      batX = width - batW;
    }
  }
}

// when they let go of the key, reset the keyCode
void keyReleased() {
  keyCode = -1;
}

// this function checks if the ball has hit the top or sides of the bat and
// updates its direction as appropriate so the ball bouncs off the bat
void checkBallAgainstBat() {
  if (ballY + ballD > height - batH) {
    ballDy *= -1;
  }
}

// this function checks if the ball has hit the brick. It should bounce off
// the brick and return true if so
boolean checkBallAgainstBrick() {
  return false;
}

// this function checks if the ball has hit the top, left or right
// walls and update its
// direction as appropriate so the ball bounces off the walls
void checkBallAgainstWalls() {
  if (ballX + ballD > width) {
    ballDx *= -1;
  }
  if (ballX - ballD < 0) {
    ballDx *= -1;
  }
  if (ballY - ballD < 0) {
    ballDy *= -1;
  }
}

Answer 1

Since the bat in breakout is a fixed width, your collision detection can be quite simple (in pseudo-code):

if (lower_edge(ball) > top_edge(bat)) { 
   // the ball has entered territory where it might have collided
   if ((left_edge(ball) <= right_edge(bat)) && (right_edge(ball) >= left_edge(bat))) {
      // the ball's within the horizontal bounds of the bat, so it's a "hit"
      ... calculate deflection ...
   } else {
      // oops, ball's gone past the bat and wasn't hit
      strike_out();
} else {
  // ball's still above the bat somewhere. do nothing
}

In english: If the ball’s lower edge has gone past where the top edge of the bat is, we’ve POSSIBLY got a collision. This is only checking the vertical axis of the play field. You then check if the left or right edges of the ball fall within the horizontal location of the bat. If neither side of the ball overlaps the bat, then you’ve lost. Otherwise you’ve collided and you do the collision detection.