Project Pinball - all classes v0.7b

=== Game.java ===
package Game;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Window;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.util.LinkedList;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.Timer;

public class Game implements KeyListener, MouseMotionListener
{

    //Declaration of the variables
    //<editor-fold defaultstate="collapsed" desc=" Variables ">

    //<editor-fold defaultstate="collapsed" desc=" Player Variables ">
    /** @param    player_lives     Frame size of X */
    private int player_lives = 3;
    //</editor-fold>

    //<editor-fold defaultstate="collapsed" desc=" Scale Variables ">
    /** @param    frame_getX     Frame size of X */
    private double frame_getX = -1;

    /** @param    frame_getY     Frame size of Y */
    private double frame_getY = -1;
    //</editor-fold>

    //<editor-fold defaultstate="collapsed" desc=" Movement Variables">
    /** @param    ball_deltaX   Ball accellaration to X-Coordinate */
    private int ball_deltaX = 1;

    /** @param    ball_deltaY   Ball accellaration to Y-Coordinate */
    private int ball_deltaY = 1;
    //</editor-fold>

    //<editor-fold defaultstate="collapsed" desc=" Ball Variables">
    /** @param    ball_posX     Ball position on X-Coordinate */
    private double ball_posX = -1.0;

    /** @param    ball_posY     Ball position on Y-Coordinate */
    private double ball_posY = -1.0;

    /** @return   ball_radius   Ball radius */
    private final int ball_radius = 10;
    //</editor-fold>

    //<editor-fold defaultstate="collapsed" desc=" Paddle Variables">
    /** @param    paddle_posX     Paddle position on X-Coordinate */
    private double paddle_posX = -1.0;

    /** @param    paddle_posY     Paddle position on Y-Coordinate */
    private double paddle_posY = -1.0;

    /** @param    paddle_width     Paddle scale (width) */
    private int paddle_width = 100;

    /** @param    paddle_height     Paddle scale (height) */
    private int paddle_height = 10;
    //</editor-fold>

    //<editor-fold defaultstate="collapsed" desc=" Brick Variables">
    LinkedList level_bricklist = new LinkedList();

    /** @param    brick_positionX   Postition of Brick on the X-Coordinate */
    private int brick_positionX = -1;

    /** @param    brick_positionY   Postition of Brick on the Y-Coordinate */
    private int brick_positionY = -1;

    /** @param    brick_lenght   Lenght of the Brick */
    private int brick_lenght = -1;

    /** @param    brick_height   Height of the Brick */
    private int brick_height = -1;

    /** @param    brick_isVisible   Returns visibility */
    private boolean brick_isVisible = true;

    /** @param    level_counter   Returns the actual level */
    private int level_counter = 0;

    //</editor-fold>

    //Create new GUI and Panel
    /** @param    game     JFrame, the Frame of the Game. */
    final JFrame game = new JFrame();

    /** @param    canvas     JPanel, where the Magic happens. */
    JPanel canvas = new paintObjects();

    //Creates a menubar for a JFrame
    /** @param    menuBar     JManu, contains all statistics.
     *                    <br>Available menus:
     *                      <ul><b>returnToMenu</ul>
     *                      <ul><b>pointCounter</ul>
     *                      <ul><b>liveCounter</ul>
     *                      <ul><b>levelCounter</ul>
     */
    JMenuBar menuBar = new JMenuBar();

    //</editor-fold>



    public void drawFrame(int frame_drawSizeX, int frame_drawSizeY)
    {
        System.out.println("Entering drawFrame();");

        //<editor-fold defaultstate="collapsed" desc=" Declaration and Definition of JFrame ">
        game.setType(Window.Type.UTILITY);
        game.setResizable(false);
        game.setSize(frame_drawSizeX, frame_drawSizeY);
        game.setLocationRelativeTo(null);
        game.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        game.setVisible(true);

        canvas.addMouseMotionListener(this);
        game.addKeyListener(this);
        //</editor-fold>

        //<editor-fold defaultstate="collapsed" desc=" JFrame Dynamic Scaling ">
        frame_getX = frame_drawSizeX;
        frame_getY = frame_drawSizeY;
        scaling();
        //</editor-fold>

        //<editor-fold defaultstate="collapsed" desc=" Declaration and Definition of JMenu ">

        //Add the menubar to the frame
        game.setJMenuBar(menuBar);

        //Define and add dropdown menus to the menubar
        final JMenu returnToMenu = new JMenu("Return to Menu");
        final JMenu pointCounter = new JMenu("Your Points: 0");
        final JMenu liveCounter = new JMenu("Remaining Lives: 0");
        final JMenu levelCounter = new JMenu("Level: 0");

        //Make them visible:
        menuBar.add(returnToMenu);
        menuBar.add(pointCounter);
        menuBar.add(liveCounter);
        menuBar.add(levelCounter);
        //</editor-fold>

        //<editor-fold defaultstate="collapsed" desc=" Objects of class Brick/Levels ">

        Brick brick = new Brick();
        Level level = new Level();

        //</editor-fold>

        game.setPreferredSize(new Dimension(frame_drawSizeX, frame_drawSizeY));
        game.add(canvas);

        int delay = 40; //Milliseconds for delay

        ActionListener taskPerformer = new ActionListener()
        {
            //Run through this with delay
            @Override
            public void actionPerformed(ActionEvent evt)
            {

              liveCounter.setText("Remaining Lives: " + player_lives);

              //Move the ball
              ball_posX += ball_deltaX;
              ball_posY += ball_deltaY;

              //<editor-fold defaultstate="collapsed" desc=" *Brick Variables SOUT ">

              // System.out.format("brick_positionX = %d \nbrick_positionY = %d \nbrick_lenght = %d \nbrick_height = %d \nbrick_isVisible = %b\n\n", brick_positionX, brick_positionY, brick_lenght, brick_height, brick_isVisible);

              //</editor-fold>

              game.repaint();

              //<editor-fold defaultstate="collapsed" desc=" Ball: Frame Collision ">

              //Collision of the ball hitting left border
              if (ball_posX < 0)
              {
                   ball_deltaX *= -1;
              }

              //Collision of the ball hitting right border
              if (ball_posX + (2*ball_radius) >= game.getWidth())
              {
                   ball_deltaX *= -1;
              }

              //Collision of the ball hitting upper border
              if (ball_deltaY < 0)
              {
                  ball_deltaY *= -1;
              }


              //Collision of the ball hitting lower border
              if (ball_posY + ball_radius >= game.getHeight())
              {
                  if(player_lives > 0)
                  {
                    JOptionPane.showMessageDialog(null, "You lost one life.");

                    player_lives -= 1;
                    resetBall();
                  }
                  else
                  {
                    Object[] options =
                    {
                        "Yes.",
                        "No.",
                    };

                    int optionDlg_result = JOptionPane.showOptionDialog(null,
                        " YOU LOST. "
                        + "Do you want to start over again?",
                        "Lost.",
                        JOptionPane.YES_NO_CANCEL_OPTION,
                        JOptionPane.QUESTION_MESSAGE,
                        null,
                        options,
                        options[1]);

                    if(optionDlg_result == 0)
                    {
                        game.dispose();
                        drawFrame(player_lives, player_lives);
                    }
                    else
                    {
                        exitGame();
                    }

                  }
              }



              //</editor-fold>

              //<editor-fold defaultstate="collapsed" desc=" Ball: Paddle Collision ">

              //Collision of the ball hitting left paddle
              if (ball_posX < 0)
              {
                    System.out.println("Collision left");
                    ball_deltaX *= -1;
              }

              //Collision of the ball hitting right paddle
              if (ball_posX + (2*ball_radius) >= game.getWidth())
              {
                  System.out.println("Collision right");
                  ball_deltaX *= -1;
              }

              //Collision of the ball hitting upper paddle
              if ( (ball_posY+ball_radius) >= paddle_posY  && (ball_posY+ball_radius) <= (paddle_posY+paddle_height)  &&  (ball_posX+ball_radius) >= paddle_posX  && (ball_posX+ball_radius) <= (paddle_posX+paddle_width))
              {
                    System.out.println("Collision up");
                    ball_deltaY *= -1;
              }
              //</editor-fold>
            }
        };
        new Timer(delay, taskPerformer).start();
    }

    public void resetBall()
    {
        JOptionPane.showMessageDialog(null, "Remaining lives: " + player_lives);
        ball_posX = paddle_posX + (paddle_width/2); //Centered position
        ball_posY = frame_getY*0.65; //65% of the Screen
        ball_deltaX = 1;
        ball_deltaY = 1;
    }

    public void exitGame()
    {
        game.setVisible(false);
        game.dispose();
        Menu menu = new Menu();
        menu.setVisible(true);
    }

    public void scaling()
    {
       // System.out.format("\n\nBefore Scaling:\nball_posX = %f\nball_posY = %f\npaddle_posX = %f\npaddle_posY = %f\n\n", ball_posX, ball_posY, paddle_posX, paddle_posY);
       // System.out.format("X: %f  ...  Y: %f\n", frame_getX, frame_getY);

        //Getting the paddle into a centered position
        paddle_posX = frame_getX /2;

        paddle_posY = frame_getY*0.8; //From 80% of the Screen

        //Getting the ball into a centered position
        ball_posX =  paddle_posX + (paddle_width/2);

        ball_posY = frame_getY*0.65; //From 65% of the Screen



        // System.out.format("\n\nAfter Scaling:\nball_posX = %f\nball_posY = %f\npaddle_posX = %f\npaddle_posY = %f\n\n", ball_posX, ball_posY, paddle_posX, paddle_posY);
        // System.out.format("X: %f  ...  Y: %f\n", frame_getX, frame_getY);
    }


    // Additional abstract Methods
    //<editor-fold defaultstate="collapsed" desc=" All abstract Methods ">

    @Override
    public void keyTyped(KeyEvent ke) {}

    // Keyboard Controlls
    @Override
    public void keyPressed(KeyEvent ke)
    {
        System.out.println("Key Pressed!");
        if(ke.getKeyCode() == KeyEvent.VK_RIGHT)
        {
          paddle_posX += 3;
        }

        if(ke.getKeyCode() == KeyEvent.VK_LEFT)
        {
          paddle_posX -= 3;
        }
    }

    @Override
    public void keyReleased(KeyEvent ke) {}

    //Mouse Controlls
    @Override
    public void mouseDragged(MouseEvent me) {

    }
    //</editor-fold>

    // Movement of the paddle when Mouse is moved
    @Override
    public void mouseMoved(MouseEvent me)
    {
        paddle_posX = me.getX() - paddle_width / 2;

        if (paddle_posX < 0 || me.getX() < 0)
        {
          paddle_posX = 0;
        }

        if (paddle_posX + paddle_width >= canvas.getWidth())
        {
          paddle_posX = canvas.getWidth() - paddle_width;
        }
    }

    // Drawing objects
    class paintObjects extends JPanel
    {

        @Override
        protected void paintComponent(Graphics g)
        {

            super.paintComponent(g);

            g.setColor(Color.BLACK);

            //g draws ball
            g.fillOval( (int) ball_posX, (int) ball_posY, ball_radius*2, ball_radius*2);

            //g draws paddle
            g.fillRect( (int) paddle_posX, (int) paddle_posY, paddle_width, paddle_height);



            //g draws bricks
            //<editor-fold defaultstate="collapsed" desc=" *Brick Variables SOUT ">

            // System.out.format("brick_positionX = %d \nbrick_positionY = %d \nbrick_lenght = %d \nbrick_height = %d \nbrick_isVisible = %b\n\n", brick_positionX, brick_positionY, brick_lenght, brick_height, brick_isVisible);

            //</editor-fold>

            // System.out.println("SIZE: " + (int) level_bricklist.size());

            if(brick_isVisible == true)
            {
                for(int i=0; i<level_bricklist.size(); i+=4)
                {
                    g.drawRect( (int) level_bricklist.get(i), (int) level_bricklist.get(i+1), brick_lenght, brick_height);
                }

            }

        }
    }


}




=== Brick.java ===
package Game;


public class Brick
{
    private int brick_positionX, brick_positionY, brick_lenght, brick_height;
    private boolean isVisible;

    public boolean addBrick(int brick_positionX, int brick_positionY, int brick_lenght, int brick_height, boolean isVisible)
    {
        System.out.println("Brick.addBrick();");
        this.brick_positionX = brick_positionX;
        this.brick_positionY = brick_positionY;
        this.brick_lenght = brick_lenght;
        this.brick_height = brick_height;
        this.isVisible = isVisible;
        return true;
    }

    public int getBrick_positionX()
    {
        return brick_positionX;
    }

    public int getBrick_positionY()
    {
        return brick_positionY;
    }

    public int getBrick_lenght()
    {
        return brick_lenght;
    }

    public int getBrick_height()
    {
        return brick_height;
    }

    public boolean getIsVisible()
    {
        return isVisible;
    }

}





=== Level.java ===
package Game;

import java.util.LinkedList;

public class Level
{
    private int level_counter = 0;

    public void Level()
    {
        System.out.println("Entering the Level();");

        //Creating the LinkedList level_bricklist
        LinkedList level_bricklist = new LinkedList();

        //Creating Object brick
        Brick brick = new Brick();

        switch(level_counter)
        {
            case 0:{
                        System.out.println("Adding Bricks to Level 0...");
                        level_bricklist.add(brick.addBrick(400, 30, 50, 50, true));
                        level_bricklist.add(brick.addBrick(500, 30, 50, 50, true));
                        level_bricklist.add(brick.addBrick(600, 30, 50, 50, true));
                        break;
                   }

        }
    }

    public void setLevel_counter(int level_counter)
    {
        this.level_counter = level_counter;
    }

}