package breakout;
import java.awt.geom.*;
import java.awt.*;
import fang.*;
/**
* This class implements the game of Breakout.
*
* @author Robert C. Duvall
* @author modified by Joseph Farfel (updated for the
* FANG engine, and some other changes)
*/
public class Breakout extends GameLoop
{
// Game objects
/** the walls */
private Sprite[] walls;
/** the blocks */
// Makes an array of blocks
private Sprite[] block;
/** the paddle */
private Sprite paddle;
/** the bouncing ball */
private Sprite ball;
//Integer for score
public static int score = 0;
//Integer for lives
public static int lives = 3;
//StringSprite for score
private StringSprite scoreSprite;
//StringSprite for lives
private StringSprite livesSprite;
/** what makes the ball move */
private ProjectileTracker ballTracker;
// Game resources (sounds, etc.)
// TODO: add variables to store two sounds (Sound)
/**
* This is the Breakout class's constructor method. It is
* called once, when the program starts.
*/
public Breakout()
{
// set the size of the game window (in pixels)
super(new Dimension(500, 500));
// tell the game where its help file is
setHelp("resources/BreakoutHelp.html");
}
/**
* This method is run every time the game is restarted. It
* creates and sets up all Sprites, and initializes all game
* state variables (score, lives, etc.).
*/
public void startGame()
{
// TODO: initialize game state variables and sounds
makeSprites();
addSprites();
}
/**
* One step in the game.
*
* Updates position of paddles based on players and
* handles any collisions with the ball.
*
* @see tipgame.FrameAdvancer#advanceFrame()
*/
public void advanceFrame (double timePassed)
{
if (! this.gameIsOver())
{
handleInput();
handleCollisions();
updateStatus();
}
}
/**
* Creates all of the sprites and sets up their location,
* scale, and color
*/
private void makeSprites ()
{
// make the walls array
walls = new Sprite[4];
// make each individual wall
walls[0] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.1));
walls[1] = new Sprite(new Rectangle2D.Double(0, 0, 0.1, 1));
walls[2] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.1));
walls[3] = new Sprite(new Rectangle2D.Double(0, 0, 0.1, 1));
// set up the walls' color, scale, location
for (Sprite wall : walls)
{
wall.setScale(1);
wall.setColor(new Color(0, 30, 150));
}
walls[0].setLocation(0.5, 0);
walls[1].setLocation(0, 0.5);
walls[2].setLocation(0.5, 1);
walls[3].setLocation(1, 0.5);
// TODO: create and set up lots of blocks
//make the block array
block = new Sprite[15];
// make the blocks
block[0] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.5));
block[1] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.5));
block[2] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.5));
block[3] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.5));
block[4] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.5));
block[5] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.5));
block[6] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.5));
block[7] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.5));
block[8] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.5));
block[9] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.5));
block[10] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.5));
block[11] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.5));
block[12] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.5));
block[13] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.5));
block[14] = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.5));
for(Sprite blocks : block)
{
blocks.setScale(0.15);
blocks.setColor(Color.MAGENTA);
}
// set up the blocks' color, scale, location
block[0].setLocation(0.5, 0.25);
block[1].setLocation(0.33, 0.25);
block[2].setLocation(0.161, 0.25);
block[3].setLocation(0.67, 0.25);
block[4].setLocation(0.84, 0.25);
block[5].setLocation(0.5, 0.15);
block[6].setLocation(0.33, 0.15);
block[7].setLocation(0.161, 0.15);
block[8].setLocation(0.67, 0.15);
block[9].setLocation(0.84, 0.15);
block[10].setLocation(0.5, 0.35);
block[11].setLocation(0.33, 0.35);
block[12].setLocation(0.161, 0.35);
block[13].setLocation(0.67, 0.35);
block[14].setLocation(0.84, 0.35);
// make the paddle
paddle = new Sprite(new Rectangle2D.Double(0, 0, 1, 0.1));
// set up the paddle's color, scale, location
paddle.setColor(Color.GREEN);
paddle.setScale(0.2);
paddle.setLocation(0.5, 0.9);
//Make and Setup the score sprite
scoreSprite = new StringSprite("Blocks left: "+score);
scoreSprite.rightJustify();
scoreSprite.topJustify();
scoreSprite.setHeight(0.05);
scoreSprite.setLocation(1, 0);
scoreSprite.setColor(Color.BLACK);
//Make and Setup the lives sprite
livesSprite = new StringSprite("Lives left: "+lives);
livesSprite.leftJustify();
livesSprite.topJustify();
livesSprite.setHeight(0.05);
livesSprite.setLocation(0, 0);
livesSprite.setColor(Color.BLACK);
// make the ball
ball = new Sprite(new Ellipse2D.Double(0, 0, 1, 1));
// set up the ball's color, scale, location
ball.setColor(Color.RED);
ball.setScale(0.05);
ball.setLocation(0.5, 0.5);
// make the ball's tracker and assign it to the ball
ballTracker = new ProjectileTracker(new Point2D.Double(0.2, 0.36));
ball.setTracker(ballTracker);
}
/**
* Adds all the sprites to the canvas
*/
private void addSprites ()
{
// add the walls (below everything else)
for (Sprite current : walls)
{
canvas.addSprite(current);
}
for(Sprite current : block)
{
canvas.addSprite(current);
}
// TODO: add more blocks
//canvas.addSprite(block);
// Add the game indicators
canvas.addSprite(scoreSprite);
canvas.addSprite(livesSprite);
// add the paddle
canvas.addSprite(paddle);
// add the ball (always on top of everything else)
canvas.addSprite(ball);
}
/**
* Uses the mouse to reposition the paddle. Also, we start a new
* game if the user presses 'n' (or 'N').
*/
private void handleInput ()
{
// move one paddle using this computer's mouse
Point2D.Double mouse = getPlayer().getMouse().getLocation();
paddle.setLocation(mouse.x, paddle.getLocation().y);
// start a new game if the player presses 'n'
if (getPlayer().getKeyboard().keyPressed())
{
char in = getPlayer().getKeyboard().getLastKey();
if (in == 'n' || in == 'N')
{
startOver(); // restarts the entire game
}
}
}
/**
* Checks for collisions between the ball and the four walls, the blocks,
* and the paddle. If there is an intersection, the ball bounces off what
* it hit (with the exception of the bottom wall, where a life is lost and the
* ball's position is reset to the center of the screen). If the ball bounces
* off of a brick, the brick disappears and points are earned.
*/
private void handleCollisions ()
{
// check ball's position against each wall
for (Sprite current : walls)
{
if (current.intersects(ball))
{
ballTracker.bounce(ball, current);
}
}
int i;
for(i = 0; i==2; i++);
{
if(walls[i].intersects(ball))
{
ballTracker.bounce(ball, walls[i]);
}
else
{
}
}
// TODO: check specially for floor intersection and update lives
// check ball's position against the blocks
// TODO: add more blocks and update score
for (Sprite current : block)
{
if (current.isVisible() && current.intersects(ball))
{
ballTracker.bounce(ball, current);
current.setVisible(false);
}
}
// check ball's position against the paddle
if (paddle.intersects(ball))
{
ballTracker.bounce(ball, paddle);
}
}
/**
* Updates the values of the game indicators to show the
* player their score and remaining lives.
*/
private void updateStatus ()
{
// TODO: update game status messages
}
/**
* The start of the program.
*/
public static void main (String[] argv)
{
Breakout game = new Breakout();
game.runAsApplication();
}
}