Пример #1
0
  /** getReady: Initialize the game */
  private void getReady() {

    // Make up the bricks
    double brickPerWidth =
        (getWidth() - DIST_BRICK_WALL * 2 - DIST_BRICK_BRICK * (NUM_BRICK_ROW - 1)) / NUM_BRICK_ROW;
    double brickPerHeight = BRICK_HEIGHT;
    double x_start = DIST_BRICK_WALL;
    double y_start;
    for (int i = 1; i <= NUM_BRICK_ROW; i++) {
      for (int j = 1; j <= NUM_BRICK_COL; j++) {
        y_start = 50 + (j - 1) * (DIST_BRICK_BRICK + brickPerHeight);
        GRect tmpbrick = new GRect(brickPerWidth, brickPerHeight);
        tmpbrick.setFilled(true);
        add(tmpbrick, x_start, y_start);
      }
      x_start += DIST_BRICK_BRICK + brickPerWidth;
    }

    // Make up the board
    board = new GRect(BOARD_WIDTH, BOARD_HEIGHT);
    board.setFilled(true);
    add(board, (getWidth() - BOARD_WIDTH) / 2, (getHeight() - 30));

    // Place the ball
    ball = new GOval(BALL_RADIUS * 2, BALL_RADIUS * 2);
    ball.setFilled(true);
    ball.setColor(Color.RED);
    add(ball, (getWidth() - BALL_RADIUS * 2) / 2, (getHeight() - 30 - BALL_RADIUS * 2));

    // Set up random generator
    rgen = RandomGenerator.getInstance();

    // Add Listeners
    addMouseListeners();
  }
public class RandomCircles extends GraphicsProgram {

  /** Number of circles */
  private static final int NCIRCLES = 10;

  /** Minimum radius */
  private static final double MIN_RADIUS = 5;

  /** Maximum radius */
  private static final double MAX_RADIUS = 50;

  public void run() {
    for (int i = 0; i < NCIRCLES; i++) {
      double r = rgen.nextDouble(MIN_RADIUS, MAX_RADIUS);
      double x = rgen.nextDouble(0, getWidth() - 2 * r);
      double y = rgen.nextDouble(0, getHeight() - 2 * r);
      GOval circle = new GOval(x, y, 2 * r, 2 * r);
      circle.setFilled(true);
      circle.setColor(rgen.nextColor());
      add(circle);
    }
  }

  /* Private instance variable */
  private RandomGenerator rgen = RandomGenerator.getInstance();
}
  public void run() {

    /* Initialising variables. */
    int counter = 0;
    int currentMoney = 1;
    int totalMoneyInGame = 0;

    /* The main iteration for the St.Peterburg's game.
    If total money is > than 20 - ends the game. */
    while (totalMoneyInGame < 20) {

      /* Randoms flip boolean value for each stage of iteration */
      RandomGenerator r = RandomGenerator.getInstance();
      boolean flip = r.nextBoolean();

      /* Condition for the heads flip, if it's true - double current money */
      if (flip == true) {
        currentMoney *= 2;

        /* Condition for the streak of heads. If total money is >= 20 and current money is >=20,
        prints phrases and adds 1 to counter.
         */
        if (totalMoneyInGame >= 20 && currentMoney >= 20) {
          println("This game you earned $" + currentMoney);
          println("Your total is $" + totalMoneyInGame);
          counter++;
        }
        /* Condition for the tails. Prints current money phrase.
        Prints total money phrase and adds 1 to the counter.
        In the end initialize current money to the start bid.
         */
      } else {
        println("This game you earned $" + currentMoney);
        /* If current money >=1 adds them to the total money. */
        if (currentMoney >= 1) totalMoneyInGame = totalMoneyInGame + currentMoney;
        println("Your total is $" + totalMoneyInGame);
        counter++;
        currentMoney = 1;
      }
    }
    /* In the end of the game prints counter phrase */
    println("It took " + counter + " games to earn $20");
  }
Пример #4
0
public class Craps extends ConsoleProgram {

  public void run() {
    // rgen.setSeed(23423);
    int total = rollTwoDice();
    if (total == 7 || total == 11) {
      println("That's a natural. You win");
    } else if (total == 2 || total == 3 || total == 12) {
      println("That's craps. You lose.");
    } else {
      int point = total;
      println("You point is " + point + ".");
      while (true) {
        total = rollTwoDice();
        if (total == point) {
          println("You made your point. You win.");
          break;
        } else if (total == 7) {
          println("That's a 7. You lose.");
          break;
        }
      }
    }
  }

  /* Rolls two dice and returns their sum. */
  private int rollTwoDice() {
    int d1 = rgen.nextInt(1, 6);
    int d2 = rgen.nextInt(1, 6);
    int total = d1 + d2;
    println("Rolling dice: " + d1 + " + " + d2 + " = " + total);
    return total;
  }
  /* Create an instance variable for the random number generator */
  private RandomGenerator rgen = RandomGenerator.getInstance();
}
Пример #5
0
public class Breakout extends GraphicsProgram {

  /** Width and height of application window in pixels */
  public static final int APPLICATION_WIDTH = 400;

  public static final int APPLICATION_HEIGHT = 600;

  /** Dimensions of game board (usually the same) */
  private static final int WIDTH = APPLICATION_WIDTH;

  private static final int HEIGHT = APPLICATION_HEIGHT;

  /** Dimensions of the paddle */
  private static final int PADDLE_WIDTH = 60;

  private static final int PADDLE_HEIGHT = 10;

  /** Offset of the paddle up from the bottom */
  private static final int PADDLE_Y_OFFSET = 30;

  /** Number of bricks per row */
  private static final int NBRICKS_PER_ROW = 10;

  /** Number of rows of bricks */
  private static final int NBRICK_ROWS = 10;

  /** Separation between bricks */
  private static final int BRICK_SEP = 4;

  /** Width of a brick */
  private static final int BRICK_WIDTH =
      (WIDTH - (NBRICKS_PER_ROW - 1) * BRICK_SEP) / NBRICKS_PER_ROW;

  /** Height of a brick */
  private static final int BRICK_HEIGHT = 8;

  /** Radius of the ball in pixels */
  private static final int BALL_RADIUS = 10;

  /** Offset of the top brick row from the top */
  private static final int BRICK_Y_OFFSET = 70;

  /** Number of turns */
  private int endtrying = 0;

  /* Method: init() */
  /** Sets up the Breakout program. */
  public void init() {
    addMouseListeners();
  }

  /* Method: run() */
  /** Runs the Breakout program. */
  public void run() {

    buildBricks();
    paddle();
    ball();
    startApp();
  }
  // Creating bricks as requested in colors and separators
  private void buildBricks() {
    for (int x = 0; x < NBRICK_ROWS; x++) {
      for (int j = 0; j < NBRICKS_PER_ROW; j++) {
        reak = new GRect(BRICK_WIDTH, BRICK_HEIGHT);
        reak.setFilled(true);
        reakCounter++;
        // adding bricks from the start of the line and increasing by j the width and separator
        add(reak, +(BRICK_SEP + BRICK_WIDTH) * j, BRICK_Y_OFFSET + (BRICK_SEP + BRICK_HEIGHT) * x);

        // Setting color to the bricks depending on brick row number
        switch (x) {
          case 0:
          case 1:
            reak.setColor(Color.red);
            break;
          case 2:
          case 3:
            reak.setColor(Color.orange);
            break;
          case 4:
          case 5:
            reak.setColor(Color.yellow);
            break;
          case 6:
          case 7:
            reak.setColor(Color.green);
            break;
          case 8:
          case 9:
            reak.setColor(Color.cyan);
            break;
        }
      }
    }
  }
  // Creating Paddle
  private void paddle() {
    // declaring variables for more clarity and to be used in other method
    baddleY = getHeight() - PADDLE_Y_OFFSET - PADDLE_HEIGHT;
    baddleX = (WIDTH - PADDLE_WIDTH) / 2;
    // creating the paddle
    baddle = new GRect(PADDLE_WIDTH, PADDLE_HEIGHT);
    baddle.setFilled(true);
    add(baddle, baddleX, baddleY);
  }

  public void mouseMoved(MouseEvent e) {
    // tracking the mouse inside the window and ignoring it if it's out of
    // window perspective, which is requested in assignment handout.
    // mouse is almost in the middle of the paddle.
    // height remains the same all time

    if ((e.getX() < WIDTH - PADDLE_WIDTH / 2) && (e.getX() > PADDLE_WIDTH / 2)) {
      baddle.setLocation(e.getX() - PADDLE_WIDTH / 2, baddleY);
    }
  }
  // Creating the ball above the paddle :D
  private void ball() {
    ballY = (HEIGHT - BALL_RADIUS) / 2;
    ball = new GOval(BALL_RADIUS, BALL_RADIUS);
    ball.setFilled(true);
    add(ball, (WIDTH - BALL_RADIUS) / 2, ballY);
  }

  public void startApp() {
    waitForClick();
    getVelocity();
    while (true) {
      moveBall();
      // delay time, reduced as the player is about to end the game to increases it's difficult
      pause(delay + reakCounter / 25);
      if (reakCounter == 0) {
        GLabel win = new GLabel("YOU WIN!!");
        add(win, (getWidth() - win.getWidth()) / 2, HEIGHT / 2);
      }
    }
  }

  private void moveBall() {
    ball.move(vx, vy);
    /*
     * top side reflection
     */
    if (ball.getY() - ball.getHeight() / 2 < 0) {
      vy = -vy;

    }
    /*
     * sides reflect
     */
    else if (ball.getX() > WIDTH - ball.getHeight() || ball.getX() - ball.getHeight() / 2 < 0) {
      vx = -vx;

    }
    /*
     * ending game if ball goes beyond the paddle, with 3 tries
     *  and restarting it b4 the 3 tries
     */
    else if (ball.getY() > HEIGHT) {
      endtrying++;
      if (endtrying >= 3) {
        removeAll();
        GLabel end = new GLabel("YOU LOST!!");
        add(end, (getWidth() - end.getWidth()) / 2, getHeight() / 2);
      }
      // restart part
      else {
        removeAll();
        run();
      }
    }
    // getting what's on sides of the ball, and starting to handle it
    GObject row = collectSides();

    if (row == baddle) {
      /*
       * to test Y coordinates for ball and paddle
       * println( baddle.getY()+ "|" +  ball.getY());
       * turned out to be that there's 19 pixel between ball.y and paddle.y; fixing that with if
       */

      if (ball.getY() > baddle.getY() - BALL_RADIUS) {
        vy = -vy;
        bounceClip.play();
        /*
         * glue issue fix, move the ball above the paddle, so that it doesn't reverse again
         */
        if (row == baddle) {
          ball.move(0, -PADDLE_HEIGHT);
        }
      }

    }
    /* here removing object which is brick, then subtracting the counter, also checking if
     * bricks ended so it display final message "YOY WIN"
     */
    else if (row != null) {
      remove(row);
      reakCounter--;

      vy = -vy;
    }
  }
  // setting speed and randomness, though i'm not satisfied with it's randomness
  // but it's doing the job for now
  private void getVelocity() {
    vy = 3.0;
    vx = rgen.nextDouble(1.0, 3.0);
    if (rgen.nextBoolean(0.5)) {
      vx = -vx;
    }
  }
  /* getting what's on the sides of our ball
   * changing x, y because we've a ball, not the midpoint.
   */
  private GObject collectSides() {

    GObject obj = getElementAt(ball.getX(), ball.getY());
    GObject obj2 = getElementAt(ball.getX() + 2 * BALL_RADIUS, ball.getY());
    GObject obj3 = getElementAt(ball.getX(), ball.getY() + 2 * BALL_RADIUS);
    GObject obj4 = getElementAt(ball.getX() + 2 * BALL_RADIUS, ball.getY() + 2 * BALL_RADIUS);
    if (obj != null) {
      return obj;
    } else if (obj2 != null) {
      return obj2;
    } else if (obj3 != null) {
      return obj3;
    } else if (obj4 != null) {
      return obj4;
    } else {
      return null;
    }
  }

  // private instances

  private static int reakCounter = 0;
  private static double delay = 7.5;
  // Velocity
  private static double vx, vy;

  private static GRect reak;
  private static GRect baddle;
  private static GOval ball;
  private static double ballY;
  private static double baddleY;
  private static double baddleX;

  // creating random instance
  private RandomGenerator rgen = RandomGenerator.getInstance();

  // adding sound
  AudioClip bounceClip = MediaTools.loadAudioClip("bounce.au");
}
Пример #6
0
/**
 * Get or Avoid Game is modeled on the starter game from the SIGSE nifty labs Generic Scrolling Game
 * 2011
 *
 * <p>The objective is for the students to modify this starting point to develop a more significant
 * game.
 *
 * <p>Goals:
 *
 * <p>use an array to store multiple things of one type use JButton, JTextField and JLabel and
 * ActionEvents
 *
 * @author J. Smith
 * @version February 2015
 */
public class LetterGame extends GraphicsProgram {
  private static final int WINDOW_WIDTH = 600;
  private static final int WINDOW_HEIGHT = 400;
  private static final int SCOREAREA_HEIGHT = 75;
  private static final int INDENT = 10;

  private int screenDivisions = 5;
  private double speed = 2.0;
  private double playerspeed = 10.0;
  private int gameSpeed = 25;
  private GLabel[] letters;
  private RandomGenerator randgen = RandomGenerator.getInstance();
  private JLabel scoreLabel;
  private int score;
  private GLabel player;

  @Override
  public void init() {
    randgen = new RandomGenerator();
    setSize(WINDOW_WIDTH, WINDOW_HEIGHT);
    setTitle("Get or Avoid!");
    setBackground(Color.gray);
    score = 0;
    scoreLabel = new JLabel("Score: " + score);
    scoreLabel.setFont(new Font("Cambria", Font.BOLD, 18));
    add(scoreLabel, NORTH);

    letters = new GLabel[10];

    for (int i = 0; i < 10; i++) {
      letters[i] = makeLetterLabel(screenDivisions); // 5 initial divisions
      add(letters[i]);
    }

    player = new GLabel("P", INDENT, 3 * getHeight() / screenDivisions);
    player.setFont(new Font("Cambria", Font.BOLD, 24));
    player.setColor(Color.blue);
    add(player);
    addKeyListeners();
  }

  public GLabel makeLetterLabel(int numDivs) {
    boolean get = randgen.nextBoolean();
    String ga;
    if (get) ga = "G";
    else ga = "A";
    GLabel getOrAvoid = new GLabel(ga);
    getOrAvoid.setFont(new Font("Cambria", Font.BOLD, 24));
    double locx = randgen.nextDouble(INDENT, getWidth() - getOrAvoid.getWidth());
    int whichdiv = randgen.nextInt(1, numDivs);
    double locy = whichdiv * getHeight() / numDivs;
    getOrAvoid.setLocation(locx, locy);
    return getOrAvoid;
  }

  @Override
  public void keyPressed(KeyEvent event) {
    char key = event.getKeyChar();
    if (key == 'k') {
      player.move(0, playerspeed);
    } else if (key == 'i') {
      player.move(0, -playerspeed);
    }
  }

  @Override
  public void run() {
    double reset = getWidth() - letters[0].getWidth();
    while (true) {

      for (int i = 0; i < letters.length; i++) {

        if (letters[i].getBounds().intersects(player.getBounds())) {
          if (letters[i].getLabel().equals("A")) score--; // A for avoid lose a point
          else score++; // G for get earn 1 point
          scoreLabel.setText("Score: " + score);
          // move the letter immediately
          letters[i].setLocation(reset, letters[i].getY());
        } else {
          letters[i].move(-speed, 0);
          // wrap around if past the left edge
          if (letters[i].getX() < 0) letters[i].setLocation(reset, letters[i].getY());
        }
      }
      pause(gameSpeed);
    }
  }
}
Пример #7
0
public class MathQuiz extends ConsoleProgram {

  // Number of questions to ask
  private static final int NUM_QUESTIONS = 5;

  // Number of additional incorrect guesses after the first question before moving on
  private static final int NUM_GUESSES = 2;

  // Minimum integer or difference
  private static final int MIN_VALUE = 0;

  // Maximum integer or sum
  private static final int MAX_VALUE = 20;

  public void run() {
    int studentAnswer;
    String correct = "That's the answer!";
    String incorrect = "That's incorrect - try a different answer: ";
    for (int i = 0; i < NUM_QUESTIONS; i++) {
      int guessNumber = 0;
      String operator = rgen.nextBoolean(0.5) ? "+" : "-";
      int x = rgen.nextInt(MIN_VALUE, MAX_VALUE);
      int y = rgen.nextInt(MIN_VALUE, MAX_VALUE);
      int addAnswer = x + y;
      int subAnswer = x - y;
      if (operator.equals("+")) {
        while (addAnswer > MAX_VALUE) {
          x = rgen.nextInt(MIN_VALUE, MAX_VALUE);
          y = rgen.nextInt(MIN_VALUE, MAX_VALUE);
          addAnswer = x + y;
        }
        studentAnswer = readInt("What is " + x + " + " + y + "? ");
        while (studentAnswer != addAnswer && guessNumber < NUM_GUESSES) {
          guessNumber++;
          studentAnswer = readInt(incorrect);
        }
        if (studentAnswer == addAnswer) {
          println(getAnswer());
        } else {
          println("No, the answer is " + addAnswer);
        }
      } else {
        while (subAnswer < MIN_VALUE) {
          x = rgen.nextInt(MIN_VALUE, MAX_VALUE);
          y = rgen.nextInt(MIN_VALUE, MAX_VALUE);
          subAnswer = x - y;
        }
        studentAnswer = readInt("What is " + x + " - " + y + "? ");
        while (studentAnswer != subAnswer && guessNumber < NUM_GUESSES) {
          guessNumber++;
          studentAnswer = readInt(incorrect);
        }
        if (studentAnswer == subAnswer) {
          println(getAnswer());
        } else {
          println("No, the answer is " + subAnswer);
        }
      }
    }
  }

  private String getAnswer() {
    int response = rgen.nextInt(0, 3);
    switch (response) {
      case 0:
        return "That's correct";
      case 1:
        return "You got it!";
      case 2:
        return "Way to go!";
      case 3:
        return "Correct!";
      default:
        return null;
    }
  }
  // Private instance variables
  private RandomGenerator rgen = RandomGenerator.getInstance();
}
public class BreakoutExt extends WindowProgram {

  // Width and height of application window in pixels
  public static final int APPLICATION_WIDTH = 400;
  public static final int APPLICATION_HEIGHT = 630;

  // Dimensions of game board (usually the same)
  private static final int WIDTH = APPLICATION_WIDTH;
  private static final int HEIGHT =
      APPLICATION_HEIGHT - 25; // Amendment 25px on the menu at the top of the screen

  // Dimensions of the paddle
  private static final int PADDLE_WIDTH = 60;
  private static final int PADDLE_HEIGHT = 10;

  // Offset of the paddle up from the bottom
  private static final int PADDLE_Y_OFFSET = 60;

  // Number of bricks per row
  private static final int NBRICKS_PER_ROW = 10;

  // Number of rows of bricks
  private static final int NBRICK_ROWS = 10;

  // Separation between bricks
  private static final int BRICK_SEP = 4;

  // Width of a brick
  private static final int BRICK_WIDTH =
      (WIDTH - (NBRICKS_PER_ROW - 1) * BRICK_SEP) / NBRICKS_PER_ROW;

  // Height of a brick
  private static final int BRICK_HEIGHT = 8;

  // Radius of the ball in pixels
  private static final int BALL_RADIUS = 10;

  // Offset of the top brick row from the top
  private static final int BRICK_Y_OFFSET = 70;

  // The starting speed of the ball
  private static final double SPEED_Y = 3.0;

  // The time delay of motion of the game
  private static final double TIME_PAUSE = 15;

  // The delay of the text on the screen when displaying result game
  private static final double TEXT_PAUSE_TIME = 2500;

  // Number of turns
  private static final int NTURNS = 3;

  // Connecting random generator
  RandomGenerator rgen = RandomGenerator.getInstance();

  // The variables are stored initial state of the game
  private int startGame = 0;

  // The variables that will store the links to the following sites: paddle and ball, respectively
  private GRect paddle;
  private GOval ball;

  // The variable in which to store the number of downed bricks per game
  private int allDelBricks = 0;

  // This variable will store the amount of scores per game
  private int resGame = 0;

  /** The method contains all the methods that control the whole process of the game */
  public void run() {
    addMouseListeners();
    boolean res = false;
    drawBricks(); // Creates bricks
    for (int numberOfGame = 1; numberOfGame <= NTURNS; numberOfGame++) {
      if (res) {
        break;
      }
      startGame = 0;
      paddle = madePaddle(); // Create paddle
      ball = madeBall(); // Create ball
      waitForClick(); // Waiting for a mouse click for further implementation of the program
      startGame = 1;
      res = runBall(); // Starts ball
      if (!res) {
        messageLostAndTryAgain(numberOfGame); // It displays a message in case of loss
      } else {
        removeAll();
        messageWin(); // Displays a message in case of a win
      }
    }
    removeAll();
    createMessage("GAME OVER!");
    createScore("Result of your game: " + resGame + " score");
  }

  /** Text output in the event of winning player */
  private void messageWin() {
    createMessage("Congratulations, you WIN!");
    pause(TEXT_PAUSE_TIME);
  }

  /** Text output in case of loss player */
  private void messageLostAndTryAgain(int numberOfGame) {
    GLabel label = createMessage("You lost, but don't cry.");
    pause(TEXT_PAUSE_TIME);

    remove(label);
    remove(paddle);
    remove(ball);
    if (numberOfGame != NTURNS) {
      label = createMessage("You have " + (NTURNS - numberOfGame) + " Chance. Click to start.");
      waitForClick();
      remove(label);
    }
  }

  /**
   * 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;
  }

  /**
   * If the ball is hit in the fall on the side of the paddle, it will change the direction of the
   * x-coordinate
   */
  private double checkLeftAndRightWallOfPaddle(double vx) {
    if (getElementAt(paddle.getX() - 1, paddle.getY()) == ball
        || getElementAt(paddle.getX() - 1, paddle.getY() + PADDLE_HEIGHT) == ball
        || getElementAt(paddle.getX() + PADDLE_WIDTH + 1, paddle.getY()) == ball
        || getElementAt(paddle.getX() + PADDLE_WIDTH + 1, paddle.getY() + PADDLE_HEIGHT) == ball) {
      vx = -vx;
    }
    return vx;
  }

  /**
   * 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;
  }

  /**
   * Makes the ball bounce from the left and right walls. At blow the side of the wall, changes
   * direction of the x coordinate. Returns the direction of the ball along the x coordinate
   */
  private double checkTheLeftAndRightWall(double vx) {
    if (ball.getX() - 1 <= 0 || ball.getX() + BALL_RADIUS * 2 + 1 >= WIDTH) {
      vx = -vx;
    }
    return vx;
  }

  /**
   * 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;
  }

  /**
   * Sets the sum of the scores depending on the color of brick, and displays the result on the
   * screen
   */
  private void count(Color color) {
    int scores = 0;
    if (color == Color.CYAN) {
      scores = 100;
    } else if (color == Color.GREEN) {
      scores = 200;
    } else if (color == Color.YELLOW) {
      scores = 300;
    } else if (color == Color.ORANGE) {
      scores = 400;
    } else if (color == Color.RED) {
      scores = 500;
    }

    rectangle(
        0,
        HEIGHT - (PADDLE_Y_OFFSET / 4),
        WIDTH,
        PADDLE_Y_OFFSET / 4,
        Color.white,
        Color.white); // Draw a white square to hide the previous result
    resGame = resGame + scores;
    createScore("Score: " + resGame);
  }

  /** Displays the amount of points on the screen in text form */
  private GLabel createScore(String score) {
    GLabel text = new GLabel(score);
    text.setFont("Arial Black-12");
    text.setColor(Color.black);
    double x = (WIDTH - text.getWidth()) / 2;
    double y = HEIGHT - text.getDescent();
    text.setLocation(x, y);
    add(text);
    return text;
  }

  /** Sends information about the state of the mouse */
  public void mouseMoved(MouseEvent e) {
    muvedPaddle(e);
    muvedBall(e);
  }

  /** Bind the ball to the mouse cursor */
  private void muvedBall(MouseEvent e) {
    if (startGame == 0) {
      int y = HEIGHT - PADDLE_HEIGHT - PADDLE_Y_OFFSET - BALL_RADIUS * 2;
      int x;
      if (e.getX()
          > WIDTH
              - PADDLE_WIDTH
                  / 2) { // Makes it impossible to exit the ball over the right part of the window
        x = WIDTH - PADDLE_WIDTH / 2 - BALL_RADIUS;
      } else if (e.getX()
          < PADDLE_WIDTH
              / 2) { // Makes it impossible to exit the ball over the left part of the window
        x = PADDLE_WIDTH / 2 - BALL_RADIUS;
      } else {
        x = e.getX() - BALL_RADIUS; // Bind the ball to the center of the cursor
      }
      ball.setLocation(x, y);
    }
  }

  /** Bind the paddle to the mouse cursor */
  private void muvedPaddle(MouseEvent e) {
    int y = HEIGHT - PADDLE_HEIGHT - PADDLE_Y_OFFSET;
    int x;
    if (e.getX()
        > WIDTH
            - PADDLE_WIDTH
                / 2) { // Makes it impossible to exit the paddle over the right part of the window
      x = WIDTH - PADDLE_WIDTH;
    } else if (e.getX()
        < PADDLE_WIDTH
            / 2) { // Makes it impossible to exit the paddle over the left part of the window
      x = 0;
    } else {
      x = e.getX() - PADDLE_WIDTH / 2; // Bind the paddle to the center of the cursor
    }
    paddle.setLocation(x, y);
  }

  // Created the bricks of different colors
  private void drawBricks() {
    int startPosX =
        (WIDTH - (BRICK_WIDTH * NBRICKS_PER_ROW + BRICK_SEP * (NBRICKS_PER_ROW - 1))) / 2;
    for (int i = 0; i < NBRICK_ROWS; i++) { // Created rows of bricks
      Color color;
      if (i == 0 || i == 1) {
        color = (Color.RED);
      } else if (i == 2 || i == 3) {
        color = (Color.ORANGE);
      } else if (i == 4 || i == 5) {
        color = (Color.YELLOW);
      } else if (i == 6 || i == 7) {
        color = (Color.GREEN);
      } else {
        color = (Color.CYAN);
      }
      int posY = BRICK_Y_OFFSET + ((BRICK_HEIGHT + BRICK_SEP) * i);
      for (int j = 0; j < NBRICKS_PER_ROW; j++) { // Created the bricks in a row
        int posX = startPosX + (BRICK_WIDTH + BRICK_SEP) * j;
        rectangle(posX, posY, BRICK_WIDTH, BRICK_HEIGHT, color, color);
      }
    }
  }

  /** Creates a paddle */
  private GRect madePaddle() {
    int startPosX = (WIDTH - PADDLE_WIDTH) / 2;
    Color color = Color.BLACK;
    int posY = HEIGHT - PADDLE_HEIGHT - PADDLE_Y_OFFSET;
    GRect paddle = rectangle(startPosX, posY, PADDLE_WIDTH, PADDLE_HEIGHT, color, color);
    return paddle;
  }

  /** Creates a red ball */
  private GOval madeBall() {
    int startPosX = (WIDTH - BALL_RADIUS * 2) / 2;
    int startPosY = HEIGHT - PADDLE_Y_OFFSET - PADDLE_HEIGHT - BALL_RADIUS * 2;
    Color color = Color.RED;
    GOval oval = oval(startPosX, startPosY, BALL_RADIUS * 2, BALL_RADIUS * 2, color, color);
    return oval;
  }

  /** The method accepts a string and displays the green text in the center of the screen */
  private GLabel createMessage(String message) {
    GLabel text = new GLabel(message);
    text.setFont("Arial Black-20");
    text.setColor(Color.GREEN);
    double x = (WIDTH - text.getWidth()) / 2;
    double y = (HEIGHT - text.getDescent()) / 2;
    text.setLocation(x, y);
    add(text);
    return text;
  }

  /** The method takes parameters and returns, square shape figure */
  private GRect rectangle(int x, int y, int width, int height, Color colorSetFill, Color colorSet) {
    GRect rectangle = new GRect(x, y, width, height);
    rectangle.setFilled(true);
    rectangle.setFillColor(colorSetFill);
    rectangle.setColor(colorSet);
    add(rectangle);
    return rectangle;
  }

  /** The method takes parameters and returns, oval shape figure */
  private GOval oval(int x, int y, int width, int height, Color colorSetFill, Color colorSet) {
    GOval oval = new GOval(x, y, width, height);
    oval.setFilled(true);
    oval.setFillColor(colorSetFill);
    oval.setColor(colorSet);
    add(oval);
    return oval;
  }
}
Пример #9
0
public class Breakout_Extension extends GraphicsProgram {

  /**
   * Width and height of application window in pixels. On some platforms these may NOT actually be
   * the dimensions of the graphics canvas.
   */
  public static final int APPLICATION_WIDTH = 400;

  public static final int APPLICATION_HEIGHT = 600;

  /**
   * Dimensions of game board. On some platforms these may NOT actually be the dimensions of the
   * graphics canvas.
   */
  private static final int WIDTH = APPLICATION_WIDTH;

  private static final int HEIGHT = APPLICATION_HEIGHT;

  /** Dimensions of the paddle */
  private static final int PADDLE_WIDTH = 60;

  private static final int PADDLE_HEIGHT = 10;

  /** Offset of the paddle up from the bottom */
  private static final int PADDLE_Y_OFFSET = 30;

  /** Number of bricks per row */
  private static final int NBRICKS_PER_ROW = 10;

  /** Number of rows of bricks */
  private static final int NBRICK_ROWS = 10;

  /** Separation between bricks */
  private static final int BRICK_SEP = 4;

  /** Width of a brick */
  private static final int BRICK_WIDTH =
      (WIDTH - (NBRICKS_PER_ROW - 1) * BRICK_SEP) / NBRICKS_PER_ROW;

  /** Height of a brick */
  private static final int BRICK_HEIGHT = 8;

  /** Radius of the ball in pixels */
  private static final int BALL_RADIUS = 10;

  /** Offset of the top brick row from the top */
  private static final int BRICK_Y_OFFSET = 70;

  /** Number of turns */
  private static final int NTURNS = 3;

  /** Animation delay or pause time between ball moves */
  private static final int DELAY = 20;

  /* Method: run() */
  /** Runs the Breakout program. */

  /*
   * instance variables
   */

  private GRect paddle; // the paddle

  private GOval ball; // the ball
  private double vx, vy; // the x component and y component of velocity of ball
  private GLabel lifeCount; // the prompt to show the life user still has
  private RandomGenerator rgen = RandomGenerator.getInstance(); // create a random number generator
  private int brickCount = NBRICK_ROWS * NBRICKS_PER_ROW; // total number of bricks

  /*
   * first create the items in the game then play.
   */

  public void run() {
    setup();
    showInitialLifeCount();
    play();
  }

  /*
   * set up the items in the game, including bricks, a paddle and a ball.
   */

  private void setup() {
    drawBricks();
    drawPaddle();
    createBall();
  }

  /*
   * Draw all the bricks.
   */

  private void drawBricks() {
    for (int i = 0; i < NBRICK_ROWS; i++) {
      drawRow(i);
    }
  }

  /*
   * draw a row of the brick pile
   */

  private void drawRow(int row) {
    for (int i = 0; i < NBRICKS_PER_ROW; i++) {
      drawOneBrick(row, i);
    }
  }

  /*
   * create one brick.
   */

  private void drawOneBrick(int row, int col) {
    double x0 =
        (WIDTH - NBRICKS_PER_ROW * BRICK_WIDTH - (NBRICKS_PER_ROW - 1) * BRICK_SEP)
            / 2; // the distance of leftmost brick to left border of the world
    double x = x0 + (BRICK_WIDTH + BRICK_SEP) * col;
    double y = BRICK_Y_OFFSET + (BRICK_SEP + BRICK_HEIGHT) * row;
    GRect brick = new GRect(x, y, BRICK_WIDTH, BRICK_HEIGHT);
    brick.setFilled(true);
    colorBrick(row, brick);
    add(brick);
  }

  /*
   * set color for the bricks according to which rows they are in.
   */

  private void colorBrick(int row, GRect brick) {
    if (row < 2) {
      brick.setColor(Color.RED);
    } else if (row < 4) {
      brick.setColor(Color.ORANGE);
    } else if (row < 6) {
      brick.setColor(Color.YELLOW);
    } else if (row < 8) {
      brick.setColor(Color.GREEN);
    } else if (row < 10) {
      brick.setColor(Color.CYAN);
    }
  }

  /*
   * Draw a paddle.
   */

  private void drawPaddle() {
    double x = (WIDTH - PADDLE_WIDTH) / 2;
    double y = HEIGHT - BRICK_Y_OFFSET - PADDLE_HEIGHT;
    paddle = new GRect(x, y, PADDLE_WIDTH, PADDLE_HEIGHT);
    paddle.setFilled(true);
    add(paddle);
    addMouseListeners();
  }

  /*
   * change the x location of the paddle according to the movement of user's mouse.
   */

  public void mouseMoved(MouseEvent e) {
    if ((e.getX() > PADDLE_WIDTH / 2) && (e.getX() < WIDTH - PADDLE_WIDTH / 2)) {
      double x = e.getX() - PADDLE_WIDTH / 2;
      double y = HEIGHT - BRICK_Y_OFFSET - PADDLE_HEIGHT;
      paddle.setLocation(x, y);
    }
  }

  /*
   * draw a ball and assign a initial velocity for it
   */

  private void createBall() {
    drawBall();
    getVelocity();
  }

  /*
   * Draw a ball at the center of the world with radius BALL_RADIUS.
   */

  private void drawBall() {
    double x = WIDTH / 2 - BALL_RADIUS;
    double y = HEIGHT / 2 - BALL_RADIUS;
    double d = 2 * BALL_RADIUS;
    ball = new GOval(x, y, d, d);
    ball.setFilled(true);
    add(ball);
  }

  /*
   * The balls gains an initial speed and starts to move.
   * The x component of the initial velocity is 3.0.
   * The y component of the initial velocity is a random number of certain range.
   */

  private void getVelocity() {
    vy = 3.0;
    vx = rgen.nextDouble(1.0, 3.0);
    if (rgen.nextBoolean(0.5)) {
      vx = -vx;
    }
  }

  /*
   * display the turns users have at the beginning of the game
   */

  private void showInitialLifeCount() {
    GLabel lifeCount = prompt("You have " + NTURNS + " lives.");
    add(lifeCount);
    waitForClick();
    remove(lifeCount);
  }

  /*
   * Users start the game with a click. The game does not end until the ball falls off the bottom
   * of the screen or there is no brick left. If you break all the bricks before using up the lives,
   * you win. If the ball falls off the bottom of the screen, you turn to other round until you use
   * up all your lives.
   */

  private void play() {
    gaming();
    showPrompt();
  }

  /*
   * user plays the game. If the user loses in one turn,the game goes on to the next turn.
   * If the user loses NTURNS times, he or she loses the game. If the user wins in one turn,
   * the game does not go on to next turn, but ends.
   */

  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);
    }
  }

  /*
   * Show remaining lives the user has at the upper left corner of the screen.
   */

  private GLabel showLifeCount(int life) {
    GLabel lifeCount = new GLabel("Life Count: " + life);
    lifeCount.setFont("Times-15");
    lifeCount.setLocation(10, lifeCount.getAscent() + 10);
    return lifeCount;
  }

  /*
   * the ball starts to fall, and bounces when hitting the wall or objects.
   */

  private void moveBall() {
    startFall();
    checkWall();
    checkObject();
  }

  /*
   * the ball falls from its original location at the center of the screen.
   */

  private void startFall() {
    ball.move(vx, vy);
    pause(DELAY);
    ball.sendToBack();
  }

  /*
   * checks if the ball hits the left, the right or the top wall. Then change the movement
   * of the ball accordingly.
   */

  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;
    }
  }

  /*
   * Check the four corners of the square inscribing the ball in order.
   * If one of the corner is contained in an object other than paddle, remove the object and then bounce off.
   * If one of the corner is contained in paddle, bounce off without removing the paddle.
   *
   */

  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;
      }
    }
  }

  /*
   * check one corner of the square inscribing the ball in order.
   * If one of the corner is contained in an object other than paddle, remove the object and then bounce off.
   * If one of the corner is contained in paddle, bounce off without removing the paddle.
   */

  private GObject checkCorner(double x, double y) {
    GObject obj = getElementAt(x, y); // check the corner for GObject
    if (obj == paddle) {
      vy = -Math.abs(vy);
      PrecisionPaddle();
    } else if (obj != null && obj != lifeCount) { // check if the ball hits a brick
      remove(obj);
      vy = -1.05 * vy;
      vx = 1.05 * vx;
      brickCount--;
      AudioClip bounceClip = MediaTools.loadAudioClip("bounce.au");
      bounceClip.play();
    }
    return obj;
  }

  /*
   * check if ball gets into the paddle, update location as appropriate
   */

  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
    }
  }

  /*
   * Show the prompt to indicate whether user loses or wins.
   */

  private void showPrompt() {
    if (brickCount == 0) {
      add(prompt("YOU WIN!"));
    } else {
      add(prompt("GAME OVER!"));
    }
  }
  /*
   * prompt at the end of the game to indicate whether the user wins or loses
   */

  private GLabel prompt(String endGame) {
    GLabel prompt = new GLabel(endGame);
    prompt.setFont("Times-Bold-50");
    double x = (WIDTH - prompt.getWidth()) / 2;
    double y = HEIGHT * 4.0 / 5.0;
    prompt.setLocation(x, y);
    return prompt;
  }
}