Frogger Game

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;

import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Frogger {

    static JFrame frame;
    JButton newGame;
    JButton loadGame;
    startMenuActionListener actionListener = new startMenuActionListener();

    public Frogger(){
        JPanel panel = new JPanel();
        panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));

        newGame = new JButton("New Game");
        newGame.addActionListener(actionListener);
        panel.add(newGame);
        panel.add(Box.createVerticalGlue());

        loadGame = new JButton("Load Game");
        loadGame.addActionListener(actionListener);
        panel.add(loadGame);
        panel.add(Box.createVerticalGlue());
    }

    private void newGame(){

    }

    private void loadGame(){

    }

    public static void main(String[]args) throws IOException
    {
        frame = new JFrame("CS125 Frogger");
        Frogger startPanel = new Frogger();
        FroggerPanel panel = new FroggerPanel();

        frame.addKeyListener(panel);
        frame.setFocusable(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.getContentPane().add(panel);
        frame.pack();
        frame.setVisible(true);
    }

    private class startMenuActionListener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            Object source = e.getSource();
            if(source == newGame){
                newGame();
            }else if(source == loadGame){
                loadGame();
            }

        }

    }
}

import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;
import java.awt.image.ImageProducer;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.*;
import java.util.ArrayList;
import java.util.Random;

/**
 * Display panel for the Frogger game
 *
 * @author cs125
 */
public class FroggerDisplayPanel extends JPanel {

    /**
     *
     */
    private static final long serialVersionUID = 1L;
    private ArrayList<ArrayList<Rectangle>> cars = new ArrayList<ArrayList<Rectangle>>();
    private int car_size;
    private Color carColor;

    private int fx;
    private int fy;
    BufferedImage img;
    Random r = new Random();
    /*
     * Constructor is told some general information
     * about the drawing characteristics required
     */
    public FroggerDisplayPanel(int dims)
    {
        setBackground(Color.black);
        setPreferredSize(new Dimension(dims,dims));
        //try {
            //img =  ImageIO.read(new File("C:/examples/bot2.png"));
        //} catch (IOException e) {
            // TODO Auto-generated catch block
        //  e.printStackTrace();
        //}
    }

    /*
     * (non-Javadoc)
     * @see javax.swing.JComponent#paintComponent(java.awt.Graphics)
     */
    public void paintComponent(Graphics page)
    {
        super.paintComponent(page);
        int lanes = cars.size(); //to get even spacing between boxes
        car_size = this.getHeight() / lanes; //boxes and empty lanes will have the same vertical dimension
        for (int i = 0; i < cars.size(); i++) {
            switch(i){
            case 0: carColor = Color.red;break;
            case 1: carColor = Color.orange;break;
            case 2: carColor = Color.yellow;break;
            case 3: carColor = Color.pink;break;
            case 4: carColor = Color.green;break;
            case 5: carColor = Color.blue;break;
            }
            for(int j = 0; j < cars.get(i).size(); j++){
                //page.drawImage(img, cars.get(i).get(j).x, cars.get(i).get(j).y, car_size, car_size, this);
                page.setColor(carColor);
                page.drawRect(cars.get(i).get(j).x, cars.get(i).get(j).y, car_size, car_size);
            }
        }
        page.setColor(Color.green);
        page.fillRect(fx, fy, car_size, car_size); //draws frog
    }

    /*
     * Update the game elements and redraw
     */
    public void setLocations(ArrayList<ArrayList<Rectangle>> cars1, Rectangle Frog) {
        this.cars = cars1; //makes this copy, so Points can't be modified elsewhere
        fx = Frog.x; //sets frog location
        fy = Frog.y;
        repaint();
    }


}

import java.awt.BorderLayout;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;

import javax.imageio.ImageIO;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ButtonGroup;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.Timer;

/*
 * @author cs125
 *
 * The Frogger Panel is responsible for constructing the game elements,
 * managing the layouts and events and running the game.
 *
 * The FroggerDisplayPanel is responsible for drawing the game
 */
public class FroggerPanel extends JPanel implements KeyListener
{
    private static final long serialVersionUID = 1L;
    // constants
    private final int MAX_LANEGROUPS = 4;
    private final int TIMER_DELAY = 50;
    private final int DISPLAY_DIM = 500;
    private int X_STEP_SIZE = 2;

    // JStuff
    private JRadioButton[] boption;
    private JButton startPause;
    private JButton upArrow;
    private JButton downArrow;
    private JButton leftArrow;
    private JButton rightArrow;
    private JLabel ticker;

    // game elements
    private FroggerDisplayPanel display;
    private Random r = new Random();
    private Timer timer;
    private int currentLevel = 0;

    //Frog stuff
    public Rectangle Frog;
    private int frogStartX;
    private int frogStartY;

    //Traffic stuff
    private ArrayList<ArrayList<Rectangle>> cars = new ArrayList<ArrayList<Rectangle>>();
    private int laneAmt;
    public int rUnit;

    public FroggerPanel() throws IOException
    {
        // our listener
        FroggerActionListener actionListener = new FroggerActionListener();

        // our option panel
        JPanel bpanel = new JPanel();
        bpanel.setLayout(new BoxLayout(bpanel, BoxLayout.Y_AXIS));
        ButtonGroup bgroup = new ButtonGroup();
        boption = new JRadioButton[MAX_LANEGROUPS-1];
        bpanel.add(Box.createVerticalGlue());
        for (int i = 0; i < MAX_LANEGROUPS-1; i++) {
            boption[i] = new JRadioButton(String.valueOf(i + 2), i + 2 == MAX_LANEGROUPS);
            bgroup.add(boption[i]);
            bpanel.add(boption[i]);
            boption[i].addActionListener(actionListener);
        }
        boption[0].setSelected(true);
        bpanel.add(Box.createVerticalGlue());

        // control panel
        JPanel cpanel = new JPanel();
        cpanel.setLayout(new BoxLayout(cpanel, BoxLayout.X_AXIS));

        startPause = new JButton("Start");
        cpanel.add(startPause);
        startPause.addActionListener(actionListener);

        //BufferedImage up = ImageIO.read(new File("C:/examples/arrowUp.gif"));
        upArrow = new JButton("^");
        //upArrow = new JButton(new ImageIcon(up));
        cpanel.add(upArrow);
        upArrow.addActionListener(actionListener);

        //BufferedImage down = ImageIO.read(new File("C:/examples/arrowDown.gif"));
        downArrow = new JButton("v");
        //downArrow = new JButton(new ImageIcon(down));
        cpanel.add(downArrow);
        downArrow.addActionListener(actionListener);

        //BufferedImage left = ImageIO.read(new File("C:/examples/arrowLeft.gif"));
        leftArrow = new JButton("<");
        //leftArrow = new JButton(new ImageIcon(left));
        cpanel.add(leftArrow);
        leftArrow.addActionListener(actionListener);

        //BufferedImage right = ImageIO.read(new File("C:/examples/arrowRight.gif"));
        rightArrow = new JButton(">");
        //rightArrow = new JButton(new ImageIcon(right));
        cpanel.add(rightArrow);
        rightArrow.addActionListener(actionListener);


        JPanel cpanelWrapper = new JPanel(); //to center buttons
        cpanelWrapper.add(cpanel);

        // header
        ticker = new JLabel("Paused");
        JPanel tickerWrapper = new JPanel(); //to center label
        tickerWrapper.add(ticker);

        // display panel
        display = new FroggerDisplayPanel(DISPLAY_DIM);
        // Create a timer to step the game
        timer = new Timer(TIMER_DELAY, actionListener);

        // primary panel layout
        setLayout(new BorderLayout());
        add(bpanel, BorderLayout.WEST);
        add(cpanelWrapper, BorderLayout.SOUTH);
        add(tickerWrapper, BorderLayout.NORTH);
        add(display, BorderLayout.CENTER);

        // configure game elements
        reconfigGame();
    }

    private int currentXPos;
    private int currentYPos;
    private int carSpace;
    private void reconfigGame() {
        cars.clear();
        for(int i = 0; i < boption.length; i++){
            if(boption[i].isSelected()){
                switch(i){
                case 0: laneAmt = 10; break;
                case 1: laneAmt = 16; break;
                case 2: laneAmt = 23; break;
                }
            }
        }
        currentXPos = 0;
        currentYPos = 0;
        rUnit = DISPLAY_DIM / (laneAmt);
        carSpace = rUnit*2 + rUnit;
        for(int j = 0; j < laneAmt; j++){
            cars.add(new ArrayList<Rectangle>());
        }
        for (int lane = laneAmt-1; lane > 0; lane--){
            currentXPos = 0;
            if(lane == 4 || lane == 9 || lane == 15 || lane == 22){
                currentYPos +=rUnit;
                lane--;
            }
            while(currentXPos <= DISPLAY_DIM){
                int x = r.nextInt(3);
                switch(x){
                case 0: cars.get(lane).add(new Rectangle(currentXPos, currentYPos, rUnit, rUnit)); currentXPos += carSpace;break;
                case 1: cars.get(lane).add(new Rectangle(currentXPos, currentYPos, rUnit, rUnit)); currentXPos += rUnit;
                        cars.get(lane).add(new Rectangle(currentXPos, currentYPos, rUnit, rUnit)); currentXPos += carSpace;break;
                case 2: currentXPos += carSpace; break;
                }
            }
            currentYPos += rUnit;
        }
        frogStartX = DISPLAY_DIM/2;
        frogStartY = currentYPos;
        Frog = new Rectangle(frogStartX, frogStartY, rUnit, rUnit);
        display.setLocations(cars, Frog);
    }

    private int current_x_step = 0;
    private int lane_bounds = 0;
    private int new_pos = 0;
    private void stepGame() {

        for (int i = 0; i < laneAmt; i++) {
            if(i == 0 || i % 2 == 0){
                current_x_step = X_STEP_SIZE;
                lane_bounds = display.getWidth()+rUnit;
                new_pos = -rUnit;
            }else if((i-1) == 0 || (i-1) % 2 == 0){
                current_x_step = -X_STEP_SIZE;
                lane_bounds = -rUnit;
                new_pos = DISPLAY_DIM + rUnit;
            }

            for(int j = 0; j < cars.get(i).size(); j++){
                cars.get(i).get(j).x += current_x_step;
                if (cars.get(i).get(j).x == lane_bounds) {
                    cars.get(i).get(j).x = new_pos;
                }
                if(cars.get(i).get(j).intersects(Frog)){
                    timer.stop();
                    startPause.setText("Retry?");
                    break;
                }
            }
        }
        display.setLocations(cars, Frog);
        if(Frog.y == 0){
            stepLevel();
        }
    }

    public void stepLevel(){
        currentLevel++;
        switch(currentLevel){
        case 1: X_STEP_SIZE++;
        case 2: X_STEP_SIZE++;
        case 3: X_STEP_SIZE++;
        case 4: X_STEP_SIZE++;
        case 5: X_STEP_SIZE=1; boption[1].setSelected(true);

        case 6: X_STEP_SIZE++;
        case 7: X_STEP_SIZE++;
        case 8: X_STEP_SIZE++;
        case 9: X_STEP_SIZE++;
        case 10: X_STEP_SIZE=1; boption[2].setSelected(true);
        }
        timer.stop();
        ticker.setText("Level Completed");
        startPause.setText("Next Level");
    }

    public void keyPressed(KeyEvent e) {
        switch(e.getKeyCode()){
        case KeyEvent.VK_W: upArrow.doClick(); System.out.print("w"); break;
        case KeyEvent.VK_S: downArrow.doClick(); break;
        case KeyEvent.VK_A: leftArrow.doClick(); break;
        case KeyEvent.VK_D: rightArrow.doClick(); break;
        }
        display.setLocations(cars, Frog);
    }

    @Override
    public void keyReleased(KeyEvent e) {

    }

    @Override
    public void keyTyped(KeyEvent e) {
        switch(e.getKeyCode()){
        case KeyEvent.VK_W: upArrow.doClick(); break;
        case KeyEvent.VK_S: downArrow.doClick(); break;
        case KeyEvent.VK_A: leftArrow.doClick(); break;
        case KeyEvent.VK_D: rightArrow.doClick(); break;
        }
        display.setLocations(cars, Frog);
    }

    /*
     * Action listener listening for the controls in the various panels
     */
    private class FroggerActionListener implements ActionListener {

        public void actionPerformed(ActionEvent e) {
            Object source = e.getSource();
            if (source == timer) {
                stepGame();
            } else if (source == startPause) {
                if(startPause.getText().equals("Start") ){
                    startPause.setText("Pause");
                    timer.start();
                    ticker.setText("Running");
                } else if(startPause.getText().equals("Retry?")){
                    startPause.setText("Pause");
                    reconfigGame();
                    timer.start();
                    ticker.setText("Running");
                } else if(startPause.getText().equals("Pause")){
                    startPause.setText("Start");
                    timer.stop();
                    ticker.setText("Paused");
                } else if(startPause.getText().equals("Next Level")){
                    startPause.setText("Pause");
                    reconfigGame();
                    timer.start();
                    currentLevel++;
                    boption[currentLevel].setSelected(true);
                }
            }
            else if(source == upArrow) {
                Frog.y -= rUnit;
                }
            else if(source == downArrow) {
                Frog.y += rUnit;
                }
            else if(source == leftArrow) {
                Frog.x -= rUnit;
                }
            else if(source == rightArrow) {
                Frog.x += rUnit;
                }
            else { reconfigGame();
            }
        }
    }
}