Example #1
0
 private void PrecisionPaddle() {
   if (ball.getY()
       > HEIGHT
           - PADDLE_Y_OFFSET
           - PADDLE_HEIGHT
           - BALL_RADIUS * 2) { // check if the ball drops below the paddle
     double diff = ball.getY() - (HEIGHT - PADDLE_Y_OFFSET - PADDLE_HEIGHT - BALL_RADIUS * 2);
     ball.move(0, -2 * diff); // move ball an amount equal to the amount it drops below the paddle
   }
 }
 /**
  * Makes the ball bounce from the top wall and paddle When you hit the upper wall and a paddle
  * changes direction along the y-coordinate.
  */
 private double checkTheTopWallAndPaddle(double vy) {
   if (ball.getY() + 1 <= 0) { // Checks upper wall
     vy = -vy;
   } else if (getElementAt(ball.getX() + BALL_RADIUS * 2, ball.getY() + BALL_RADIUS * 2) == paddle
       || getElementAt(ball.getX(), ball.getY() + BALL_RADIUS * 2) == paddle) { // Checks paddle
     if (vy > -2.0) {
       vy = -vy - 0.1; // Makes the the acceleration of the ball at every touch the paddle
     }
   }
   return vy;
 }
  private void checkForCollision() {
    // check if ball has hit floor. If so, bounce it upwards.
    if (ball.getY() > getHeight() - DIAM_BALL) {
      bounceClip.play();
      yVel = -yVel * BOUNCE_REDUCE; // bounces back almost to BOUNCE_REDUCE * starting height

      // moves ball back above the floor the same distance it would have dropped below the floor in
      // same time
      double diff = ball.getY() - (getHeight() - DIAM_BALL);
      ball.move(0, -2 * diff);
    }
  }
Example #4
0
 private void checkWall() {
   boolean checkLeftWall = ball.getX() <= 0;
   boolean checkRightWall = ball.getX() + BALL_RADIUS * 2 >= WIDTH;
   boolean checkTop = ball.getY() <= 0;
   if ((checkLeftWall) || (checkRightWall)) {
     vx = -vx;
   }
   if (checkTop) {
     vy = -vy;
   }
 }
  /**
   * Creates a point at the ball 4 check and verifies the presence of an object near it. Returns
   * null or the name of the object, if it is present
   */
  private GObject getCollidingObject() {
    GObject colliding;

    colliding =
        getElementAt(ball.getX(), ball.getY()); // Creates the upper left point of check ball
    if (colliding != null) {
      Color color = colliding.getColor();
      count(color);
      return colliding;
    }
    colliding =
        getElementAt(
            ball.getX() + BALL_RADIUS * 2,
            ball.getY()); // Creates the top right point of check ball
    if (colliding != null) {
      Color color = colliding.getColor();
      count(color);
      return colliding;
    }
    colliding =
        getElementAt(
            ball.getX(),
            ball.getY() + BALL_RADIUS * 2); // Creates the lower left point of check ball
    if (colliding != null) {
      Color color = colliding.getColor();
      count(color);
      return colliding;
    }
    colliding =
        getElementAt(
            ball.getX() + BALL_RADIUS * 2,
            ball.getY() + BALL_RADIUS * 2); // Creates a check point of the lower right on the ball
    if (colliding != null) {
      Color color = colliding.getColor();
      count(color);
      return colliding;
    }

    return null;
  }
Example #6
0
  /** Check for collision */
  private void checkRebounce() {

    // check for left/right/top wall
    if (ball.getX() < 0) {
      vx *= -1;
      ball.move(vx, 0);
      return;
    } else if ((ball.getX() + 2 * BALL_RADIUS) > getWidth()) {
      vx *= -1;
      ball.move(vx, 0);
      return;
    } else if (ball.getY() < 0) {
      ball.setLocation(ball.getX(), -ball.getY());
      vy *= -1;
      return;
    }

    // check for collision with bricks: from the four vertexs
    lefttop = getElementAt(ball.getX(), ball.getY());
    righttop = getElementAt(ball.getX() + 2 * BALL_RADIUS, ball.getY());
    leftbottom = getElementAt(ball.getX(), ball.getY() + 2 * BALL_RADIUS);
    rightbottom = getElementAt(ball.getX() + 2 * BALL_RADIUS, ball.getY() + 2 * BALL_RADIUS);
    if ((lefttop != null) && (righttop != null) && (lefttop != board) && (lefttop != mylabel)) {
      remove(lefttop);
      num_brick_left--;
      vy *= -1;
    } else if ((righttop != null)
        && (rightbottom != null)
        && (righttop != board)
        && (righttop != mylabel)) {
      remove(righttop);
      num_brick_left--;
      vx *= -1;
    } else if ((rightbottom != null)
        && (leftbottom != null)
        && (rightbottom != board)
        && (rightbottom != mylabel)) {
      remove(rightbottom);
      num_brick_left--;
      vy *= -1;
    } else if ((leftbottom != null)
        && (lefttop != null)
        && (leftbottom != board)
        && (leftbottom != mylabel)) {
      remove(leftbottom);
      num_brick_left--;
      vx *= -1;
    }

    // check for collision with board
    if (getElementAt(ball.getX(), (ball.getY() + BALL_RADIUS / 2)) == board) {
      vy *= -1;
      ball.move(0, vy);
    }
  }
Example #7
0
 private void checkObject() {
   // x and y parameters for the different corners
   double leftX = ball.getX();
   double rightX = ball.getX() + (2 * BALL_RADIUS);
   double upperY = ball.getY();
   double lowerY = ball.getY() + (2 * BALL_RADIUS);
   // check the corners for object
   GObject upperLeft = checkCorner(leftX, upperY); // check upper-left corner
   if (upperLeft == null) {
     GObject upperRight = checkCorner(rightX, upperY); // check upper-right corner
   }
   GObject lowerLeft = checkCorner(leftX, lowerY); // //check lower-left corner
   if (lowerLeft == null) {
     GObject lowerRight = checkCorner(rightX, lowerY); // check lower-right corner
     if ((lowerLeft == paddle)
         && (lowerRight == paddle)) { // When both lower corners hit paddle, change direction.
       vy = -vy;
     }
   }
 }
  /**
   * The method which controls the movement the ball, check all the objects with which the ball is
   * faced and performs the appropriate actions to them
   */
  private boolean runBall() {
    double vx;
    double vy = SPEED_Y;
    boolean res = false;
    vx = rgen.nextDouble(1.0, 3.0); // randomly sets horizontal speed
    if (rgen.nextBoolean(
        0.5)) // with a 50 percent chance change the direction of movement of the ball
    vx = -vx;

    while (allDelBricks
        < NBRICK_ROWS * NBRICKS_PER_ROW) { // The game will not end until all the bricks
      GObject collider = getCollidingObject(); // The variable gets test result object
      vx = checkTheLeftAndRightWall(vx); // Check the collision of the ball on the side walls
      vy =
          checkTheTopWallAndPaddle(vy); // Check the collision of the ball on the ceiling and paddle
      vx =
          checkLeftAndRightWallOfPaddle(
              vx); // Check the collision of the ball with the side part of the paddle

      if (collider != null) { // If checkpoints are returned brick, it is then removed
        if (collider != paddle) {
          remove(collider);
          vy = -vy;
          allDelBricks++;
        }
      }
      ball.move(vx, vy);
      pause(TIME_PAUSE);
      if (ball.getY()
          > HEIGHT
              - (PADDLE_Y_OFFSET / 3)
              - BALL_RADIUS * 2) { // The game stops when the ball falls below the window
        res = false;
        return res;
      }
      res = true;
    }
    return res;
  }
Example #9
0
 private void gaming() {
   boolean loseOneTurn;
   boolean win = false;
   boolean stillAlive = true;
   for (int i = NTURNS; i > 0; i--) { // loops for the number of turns.
     GLabel life = showLifeCount(i);
     waitForClick();
     add(life);
     while (stillAlive) { // the ball moves and bounces until the user loses or wins the turn.
       moveBall();
       loseOneTurn =
           (ball.getY() >= HEIGHT); // user loses one turn when the ball falls under the paddle.
       win = (brickCount == 0); // user wins when there is no brick left.
       stillAlive = !(loseOneTurn || win);
     }
     if (win) break; // breaks from the loop if the user wins in one turn.
     remove(ball);
     createBall(); // a new ball appears on the center of the screen after one turn
     stillAlive = true;
     remove(life);
   }
 }
Example #10
0
 /** Check whether the game is over */
 private boolean gameover() {
   return (ball.getY() > (getHeight() - 2 * BALL_RADIUS)) || (num_brick_left == 0);
 }