private void getVelocity() { vy = 3.0; vx = rgen.nextDouble(1.0, 3.0); if (rgen.nextBoolean(0.5)) { vx = -vx; } }
/** When mouse pressed: begin our fantastic game */ public void mousePressed(MouseEvent e) { if (vx == 0) { vx = rgen.nextDouble(0.5, 1); vy = -1; if (rgen.nextBoolean() == true) { vx *= -1; } } }
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(); }
/** 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 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; } }