CIT 591 Assignment 12: Frogger
Fall 2010, David Matuszek

Purposes of this assignment

General idea of the assignment

Some of you may remember the old computer game Frogger!, in which your goal is to get a number of frogs (one at a time) safely across a busy highway. We will be doing a simplified version of that game--no snakes, no river, etc., just a highway.


You will need to set up a display more or less like the following (adjust to taste);

This represents a two-lane highway, with the upper cars going west (left) and the lower cars going east (right). The frog (not to scale) represents a frog.

Frogs appear one at a time at the bottom of the display, and try to cross the highway and escape off the top of the display. When a frog makes it to safety (or gets killed on the highway), the next frog appears.

General plan of attack

The main class, Frogger, extends JFrame and acts as the Controller. It will create the FroggerModel and FroggerView objects. Put a FroggerView object (which is a JPanel) into the display; this is the panel on which the drawing will be done. Attach a KeyListener to the JPanel and have it send a command to the FroggerModel each time an arrow key is pressed.

Class FroggerModel extends Observable and responds to commands from the controller. It handles all the activity of cars and the current frog. It moves the frog, moves the cars, and checks whether the frog has been hit by a car.

Class FroggerView extends JFrame implements Observer. Its job is to update the display (in a public void paint(Graphics g) method). It will need to find out from the model where everything is, then display those things.

Frog, Car, and Highway should be separate classes. Each class should have a method that can be called from the paint method to draw itself on the Graphics (which can be passed in as a parameter). Then all the FroggerView needs to do is to call each of these methods.

All about cars:

Your Car objects should have (at least) an x-y position, a direction, and a color. Cars come off the left side of the screen going right, or they come off the right edge of the screen going left. The best place to create a car is just outside the visible window; as it moves into the window, it will appear in a very natural way.

The FroggerModel class should have an ArrayList<Car> to hold the current set of cars. You can add cars to the list as you create them, and you can remove them from the list when they disappear off the edge of the screen. To move cars, just go through the list and tell each car to move.Things that an individual car can do, such as move and hit frogs, should be in the Car class.

Cars appear at random intervals. Make sure your cars don't overlap (create them a reasonable minimum distance apart), but since they all travel at the same speed, you do not have to worry that cars will collide.

Use a Timer to control the movement of cars, so that the cars move smoothly and constantly. Each time a car moves, it should check to see whether it hit a frog. If it did, the car keeps on going, but the frog is dead. After all, despite appearances, a car is much bigger than a frog, and would not be affected by hitting the frog.

All about highways:

A highway doesn't do much. However, when a frog is killed on the highway, it should leave a little red splotch, splat. Think of it this way: The splotch becomes part of the highway. So you could keep track of these by having a ListArray<Splotch> in the highway object. Hmmm, you may need a small Splotch class...

All about frogs:

Frogs don't move smoothly--they jump. A frog can only jump left, right, up, or down, not at an angle. To make the frog jump, use the arrow keys, ← ↑ → and ↓. If you prefer some other set of keys, such as a s d w, you can use these in addition to the arrow keys, but I like the arrow keys.

After a frog jumps, it should be facing the direction in which it has just jumped. Here are some images you can use: frog-upfrog-upfrog-rightfrog-down. The length of a jump should be half the width of the highway, so that it takes three jumps to get across the road. The first jump puts it in the eastbound lane, the second puts it into the westbound lane, and the third gets it safely off the road. Of course, the frog can also jump back by the same amount, or it can jump left or right.

Frogs should be started in the bottom center of the display, with an initial y position such that it will take an integral number of jumps to put the frog in the middle of a lane--it shouldn't be possible for a frog to ever be partly in a lane and partly not.

Whether a frog hits a car, or a car hits a frog, it's going to be bad for the frog. So when your frog jumps, you need to check if it jumps against a car.


Basic animation using Observer, Observable, Timer, and TimerTask is covered in this set of lecture slides. Recognizing arrow keys is a bit tricky, as is drawing images, so here is some sample code you can look at to find out how it's done. The cars can be simple round rects (rectangles).


This assignment is about animation, so I don't require you to provide a certain number of frog "lives," or keep track of how many frogs have made it to safety, or anything like that. However, these features are fairly easy to add, and would make the program a lot more interesting as a game. Feel free to add them, but get the required features working first.

If you want to make sure the game has an end, all the cars could speed up just slightly each time a frog makes it across the highway. A static variable in the Car class would be perfect for this, since you want it to apply to all cars. Again, this is optional. Other (optional) features might include Start, Pause, and Stop buttons. I am not offering extra credit for extra features, however; it's just something you might like to do to make a better program.


Due date:

Thursday, December 9, before midnight. Zip up your entire Frogger project folder and submit it via Blackboard. Include an executable .jar file.