GameOverScene.java

import java.awt.*;
import java.awt.geom.*;
import javax.swing.*;
import java.io.File;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
import java.awt.event.*;
import java.util.ArrayList;
import java.util.Scanner;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.BufferedWriter;

/**
The game over scene - shows the score, high score, title, 
and play again button
@author Jack Humphries
@version 4/15/2014
*/

public class GameOverScene extends JComponent implements MouseListener
{  
   /** the amount of space in pixels between the score title
   and the score numbers */
   public static final int SCORE_SPACE = 60;
   
   /** the amount of space in pixels between the score title
   and the high score title */
   public static final int SCORE_TITLE_SPACE = 10;
   
   /** the amount of time in milliseconds that the timer waits before
   moving each object on screen (changing this number will speed up
   or slow down the animation) */
   public static final int MOVEMENT_TIME = 5;
   
   /** the amount of time in milliseconds that the timer waits before 
   redrawing all of the objects on the screen */
   public static final int ANIMATION_TIME = 20;
   
   /** the bottom possible y coordinate of the top of clouds */
   public static final int BOTTOM_CLOUD_Y = 30;
   
   /** the amount of red in the color of the background (RGB) */
   public static final double BACKGROUND_COLOR_R = 0;
   
   /** the amount of green in the color of the background (RGB) */
   public static final double BACKGROUND_COLOR_G = 198.0;

   /** the amount of blue in the color of the background (RGB) */
   public static final double BACKGROUND_COLOR_B = 255.0;
   
   /** the timer that coordinates when objects will be moved on screen */
   private Timer movementTimer;
   
   /** the timer that coordinates when objects will be redrawn on screen */
   private Timer animationTimer;
   
   /** the path to the file where the high score is stored */
   private String highScoreFilePath = "high_score.txt";

   /** the width of the scene */
   private int width;
   
   /** the height of the scene */
   private int height;
   
   /** the user's score from the last play */
   private int score;
   
   /** the user's high score */
   private int highScore;
   
   /** the background of the scene */
   private Rectangle background;
   
   /** the game over title image (Game Over) */
   private BufferedImage gameOverImage;
   
   /** the x coordinate of the game over title */
   private int gameOverX;
   
   /** the y coordinate of the game over title */
   private int gameOverY;
   
   /** the score title image (Score) */
   private BufferedImage scoreTitleImage;
   
   /** the high score title image (High Score) */
   private BufferedImage highScoreTitleImage;
   
   /** the x coordinate of the score title image */
   private int scoreTitleX;
   
   /** the y coordinate of the score title image */
   private int scoreTitleY;
   
   /** the x coordinate of the high score title image */
   private int highScoreTitleX;
   
   /** the y coordinate of the high score title image */
   private int highScoreTitleY;
   
   /** the score display */
   private ScoreDisplay scoreDisplay;
   
   /** the high score display */
   private ScoreDisplay highScoreDisplay;
   
   /** the replay button image (Replay) */
   private BufferedImage replayButtonImage;
   
   /** the x coordinate of the replay button */
   private int replayButtonX;
   
   /** the y coordinate of the replay button */
   private int replayButtonY;
   
   /** the clouds in the scene */
   private Clouds clouds;
   
   /** the main class */
   private Main mainClass;
   
   /**
   draws the scene
   @param g the graphics object
   */
   public void paintComponent(Graphics g)
   {
      super.paintComponent(g);
   
      Graphics2D g2 = (Graphics2D)g;
      
      float backgroundRed = (float)(BACKGROUND_COLOR_R/255.0);
      float backgroundGreen = (float)(BACKGROUND_COLOR_G/255.0);
      float backgroundBlue = (float)(BACKGROUND_COLOR_B/255.0);
      Color backgroundColor = new Color(backgroundRed,
         backgroundGreen, backgroundBlue);
      g2.setColor(backgroundColor);
      g2.fill(background);
      
      clouds.redrawClouds(g2);
         
      g2.drawImage(gameOverImage, gameOverX, gameOverY, null);
      
      g2.drawImage(scoreTitleImage, scoreTitleX, scoreTitleY, null);
      int digitSpace = scoreTitleImage.getWidth() + SCORE_SPACE;
      scoreDisplay.drawScore(g2, scoreTitleX + digitSpace, scoreTitleY);
      
      g2.drawImage(highScoreTitleImage, highScoreTitleX, highScoreTitleY, 
         null);
      int highScoreDigitSpace = highScoreTitleImage.getWidth() + SCORE_SPACE;
      highScoreDisplay.drawScore(g2, highScoreTitleX + highScoreDigitSpace, 
         highScoreTitleY);
      
      g2.drawImage(replayButtonImage, replayButtonX, replayButtonY, null);
   }
   
   /**
   moves/updates the objects on screen
   */
   private void moveAndUpdateObjects()
   {
      clouds.moveClouds();
   }
   
   /**
   starts animating the game over scene
   */
   private void animate() 
   {
      Thread movementThread = new Thread(
            new Runnable()
            {
               public void run()
               {
                  startMovingObjects();
               }
               
            });
   
      Thread animationThread = new Thread(
            new Runnable()
            {
               public void run()
               {
                  startAnimating();
               }
               
            });
            
      movementThread.start();
      animationThread.start();
   }
   
   /**
   responsible for moving objects every MOVEMENT_TIME milliseconds
   */
   private void startMovingObjects()
   {
      movementTimer = new Timer(MOVEMENT_TIME, 
            new ActionListener()                                       
            {
               public void actionPerformed(ActionEvent e) 
               {
                  moveAndUpdateObjects();
               }
            });
            
      movementTimer.start();
   }
   
   /**
   responsible for calling the repaint method 
   every ANIMATION_TIME milliseconds
   */
   private void startAnimating()
   {
      animationTimer = new Timer(ANIMATION_TIME, 
            new ActionListener()                                       
            {
               public void actionPerformed(ActionEvent e) 
               {
                  repaint();
               }
            });
            
      animationTimer.start();
   }
   
   /**
   generates the background of the scene
   */
   private void generateBackground()
   {
      background = new Rectangle(0, 0, width, height);
   }
   
   /**
   generates the game over title
   */
   private void generateGameOverTitle()
   {
      File gameOverPath = new File("images/game_over.png");
   
      try
      {
         gameOverImage = ImageIO.read(gameOverPath);
      }
      catch (Exception exception)
      {
      
      }
      
      int gameOverWidth = gameOverImage.getWidth();
      int gameOverHeight = gameOverImage.getHeight();
      
      //center the game over title horizontally
      gameOverX = (width / 2) - (gameOverWidth / 2);
      
      //position the game over title one fifth of the way down the scene
      gameOverY = ((height / 5) * 1) - (gameOverHeight / 2);
   }
   
   /**
   generates the score title and the score digits
   */
   private void generateScore()
   {   
      File scoreTitlePath = new File("images/score_title.png");
   
      try
      {
         scoreTitleImage = ImageIO.read(scoreTitlePath);
      }
      catch (Exception exception)
      {
      
      }
      
      int totalScoreWidth = scoreTitleImage.getWidth();
      
      scoreDisplay = new ScoreDisplay(score);
      
      //there will be a space of SCORE_SPACE pixels between the score
      //title and the score numbers
      totalScoreWidth += SCORE_SPACE;
      
      totalScoreWidth += scoreDisplay.getWidth();
      
      scoreTitleX = (width / 2) - (totalScoreWidth / 2);
      scoreTitleY = (height / 2) - (scoreTitleImage.getHeight() / 2);
   }
   
   /**
   generates the high score title and the score digits
   */
   private void generateHighScore()
   {   
      File highScoreTitlePath = new File("images/high_score_title.png");
   
      try
      {
         highScoreTitleImage = ImageIO.read(highScoreTitlePath);
      }
      catch (Exception exception)
      {
      
      }
      
      int totalScoreWidth = highScoreTitleImage.getWidth();
      
      getHighScore();
      
      highScoreDisplay = new ScoreDisplay(highScore);
      
      //there will be a space of SCORE_SPACE pixels between the high score
      //title and the score numbers
      totalScoreWidth += SCORE_SPACE;
      
      totalScoreWidth += highScoreDisplay.getWidth();
      
      highScoreTitleX = (width / 2) - (totalScoreWidth / 2);
      highScoreTitleY = scoreTitleY + scoreTitleImage.getHeight()
         + SCORE_TITLE_SPACE;
   }
   
   /**
   gets the current high score and replaces it with the user's last score
   if the last score is higher
   */
   private void getHighScore()
   {
      File scoreFile = new File(highScoreFilePath);
      
      try
      {
         Scanner input = new Scanner(scoreFile);
         
         while (input.hasNextInt())
         {
            highScore = input.nextInt();
         }
         
         if (score > highScore)
         {
            highScore = score;
            setHighScore(score);
         }
      }
      catch (Exception exception)
      {
         highScore = score;
         setHighScore(score);
      }
   }
   
   /**
   saves the new high score
   @param newHighScore the new high score to save
   */
   private void setHighScore(int newHighScore)
   {
      File scoreFile = new File(highScoreFilePath);
      String scoreOutput = Integer.toString(newHighScore);
      BufferedWriter scoreWriter = null;
            
      try
      {
         FileWriter scoreFileWriter = new FileWriter(scoreFile);
         scoreWriter = new BufferedWriter(scoreFileWriter);
      
         scoreWriter.write(scoreOutput);
      }
      catch (Exception exception)
      {
      
      }
      finally
      {
         try
         {
            scoreWriter.close();
         }
         catch (Exception exception)
         {
            
         }
      }
   }
   
   /**
   generates the replay button
   */
   private void generateReplayButton()
   {
      File playButtonPath = new File("images/replay_button.png");
   
      try
      {
         replayButtonImage = ImageIO.read(playButtonPath);
      }
      catch (Exception exception)
      {
      
      }
      
      //center the replay button horizontally
      replayButtonX = (width / 2) - (replayButtonImage.getWidth() / 2);
      
      //position the replay button seven eighths of the way down the scene
      replayButtonY = ((height / 8) * 7)
         - (replayButtonImage.getHeight() / 2);
   }
   
   /**
   generates the clouds 
   */
   private void generateClouds()
   {
      int topCloudY = height - BOTTOM_CLOUD_Y - Clouds.MAXIMUM_CLOUD_HEIGHT;
      
      clouds = new Clouds(width, topCloudY, BOTTOM_CLOUD_Y);
   }
   
   /**
   called when the user clicks the mouse,
   if the user clicks the region of the replay button, the game restarts
   */
   public void mouseClicked(MouseEvent mouseEvent)
   {
      Point clicked = mouseEvent.getPoint();
      Rectangle bounds = new Rectangle(replayButtonX, replayButtonY,
         replayButtonImage.getWidth(), replayButtonImage.getHeight());
      
      if (bounds.contains(clicked))
      {
         removeMouseListener(this);
         movementTimer.stop();
         animationTimer.stop();
         mainClass.displayGameScene();
      }
   }
   
   /**
   this method is not used - it is part of the MouseListener interface
   @param mouseEvent the mouse event
   */
   public void mouseEntered(MouseEvent mouseEvent)
   {
   
   }
   
   /**
   this method is not used - it is part of the MouseListener interface
   @param mouseEvent the mouse event
   */
   public void mouseExited(MouseEvent mouseEvent)
   {
   
   }
   
   /**
   this method is not used - it is part of the MouseListener interface
   @param mouseEvent the mouse event
   */
   public void mouseReleased(MouseEvent mouseEvent)
   {
   
   }
   
   /**
   this method is not used - it is part of the MouseListener interface
   @param mouseEvent the mouse event
   */
   public void mousePressed(MouseEvent mouseEvent)
   {
   
   }

   public GameOverScene(int theWidth, int theHeight, int theScore, 
      Main theMainClass)
   {
      width = theWidth;
      height = theHeight;
      score = theScore;
      mainClass = theMainClass;
      
      generateBackground();
      generateGameOverTitle();
      generateScore();
      generateHighScore();
      generateReplayButton();
      generateClouds();
      
      addMouseListener(this);
      
      animate();
   }
}