CSE 8B: Introduction to Computer Science: Java (Winter, 2006)

Programming Assignment 8

Overview

The main class will be LunarLanderUI. You'll run it with:

java LunarLanderUI

A sample can be found in ~/../public/P8/LunarLanderUI.jar. Run it with

java -jar ~/../public/P8/LunarLanderUI.jar 

Lunar lander is a game with a spacecraft with a certain amount of fuel trying to land on the moon. The object of the game is to land the craft safely (not exceeding some maximum velocity) without running out of fuel.

In the actual arcade game, you could control both the throttle, as well as rotate the spacecraft so as to move horizontally. In our version of the game, there is no rotation; the only control is the throttle. (See this on-line Lunar Lander game for an idea of what the arcade game looks like).

We give you the physics of the game in a class called LunarLander. It handles keeping track of gravity, fuel remaining, mass of the lander, impulse of the fuel (how much oomph it gives), height and velocity of the lander, and whether or not the lander has landed, or crashed.

However, the LunarLander class is not a model because it doesn't notify observers of changes. Your first task will be to make the LunarLander class a model.

Requirements

• Display the fuel remaining (as either text or graphical readout).
• Graphically show the lander landing (graphics at least as good as the sample:).
• Turn on and off the lunar lander jets using the spacebar.
• Tell the user when the game is over (either the lander landed successfully, or crashed).
• Restart the game by pressing the escape key.
• Zoom in on the display when the lander gets close to land
• Display 3 windows:
  • The graphic window.
  • Another copy of the graphic window (to verify that you can handle multiple views of the model).
  • A text window that shows the current height, velocity, fuel remaining and throttle amount (values in labels, perhaps).

Provided files

There is a sample implementation of this application in a jar file: LunarLanderUI.jar.

The file LunarLander.java contains the class that handles the physics. There's a unit test TestLunarLander.java that tests LunarLander.java. Use it to help see how to use the class (and verify that it works).

Hints

• To read keystrokes, add a new KeyEventDispatcher to the KeyboardFocusManager:

  
     KeyboardFocusManager manager = KeyboardFocusManager.getCurrentKeyboardFocusManager();   
     manager.addKeyEventDispatcher(new MyKeyEventDispatcher());
  

  Your KeyEventDispatcher should ovverride dispatchKeyEvent.
• To get the character from a KeyEvent, e, call e.getKeyChar(). To find out whether it is a key press, a keystroke, or a key release, call e.getID(). It'll return KeyEvent.KEY_PRESSED, KeyEvent.KEY_RELEASED, or KeyEvent.KEY_TYPED.
• You'll need to create a timer that calls timeStep on the LunarLander object every so often. You probably want to call it at least every 1/10 of a second (otherwise, the game will seem laggy).
• The implementation of the sample LunarLanderUI took about 150 lines of code. This is not a large application.
• Good initial values for the lander are 0 velocity and 100 meter height. My 6-year old can land the lander easily with that. Make the height more for a harder game.
• Work in steps. Here's the order I'd approach it:
  1. Turn the LunarLander class into a model by either subclassing from Observable or adding methods to add listeners and remove listeners. If not subclassing Observable, you'll need to store your listeners. An ArrayList would be a good place to do so. Then, make sure to notify the listeners on any change to the model.
  2. Make a LunarLanderUI class that instantiates a LunarLander object and starts a timer going to call timeStep. Eventually, the lander will crash and will print that fact to System.out
  3. Make your text window work. Set it up as a listener and verify that it displays.
  4. Make your graphical window work. Use easy artwork to begin with: draw a white square. Watch it crash.
  5. Add a KeyEventDispatcher to turn on and off the throttle as the spacebar is pressed and released. Set the throttle percentage to 100% if the spacebar is pressed and 0% if not (leave finer-tuned throttle control to some later date/better game).
  6. Verify that the throttle works (by slowing down the lander visually, and in the text window).
  7. Make a second graphic window. It should display the same thing as the first.
  8. Make your graphics better; show the jets when they're on.
  9. Handle zooming in when the lander is closer than some certain amount (25 meters, perhaps). Do this by scaling all the coordinates (height, lander size, etc.).
  10. Make the escape key reset the simulation.
  11. Add bells & whistles.
  12. Refactor so you get full style points!

Turnin

• LunarLanderUI.java
• LunarLander.java

  bundleP8

Grading

The assignment is worth 20 points.

• 8 points: A graphics window with working lunar lander.
• 4 points: A second graphics window showing the same lunar lander.
• 4 points: Working text window.
• 4 points: Style points for your code. Good naming, not repeating yourself, correct indentation, not exceeding 80 characters per line, short methods (not too much code in any one method), etc.

Extra credit points of up to 4 points are available for significant additions to the game. Possibilities include:

• Scoring for each attempted landing (based on some combination of landing velocity and fuel remaining)
• Selection of landing on different planets (with different gravity)
• Fancy graphics
• Lander blowing up on crash
• Sound effects
• Rotating lander and terrain to land on