In this project, you
will create a graphical simulation of an aerial dogfight game. As a minimum, your completed project shall
a movable friendly
fighter aircraft which shall defend itself against a squadron of enemy fighters
using weapons which can be fired by the user using the keyboard.
a number of enemy
fighters which shall attempt to destroy your friendly fighter. Enemy fighters shall destroy your friendly
fighter by either crashing into it or optionally firing projectiles to hit it.
The user is the
person playing the game and will be playing the role of the friendly fighter.
The simulation will continue until all of the enemy aircraft have been
destroyed, your friendly aircraft has been destroyed, or the user decides to
quit. The user will
"communicate" with the friendly fighter by entering commands via the
keyboard. These commands will move the
defender up and down on the display and fire the projectiles. When fired, the projectiles shall provide a
display of the projectile’s path traveled and shall destroy any target they
hit. The user will determine the number
of enemy fighters via a dialog box.
You will use the
StdDraw package introduced below to provide the graphical elements of your
simulation. This software is courtesy of Robert Sedgewick and Kevin Wayne from
Princeton University’s Computer Science Department. See the following
description for details on its use, or you can find information on the
Princeton Intro to CS website.
StdDraw is used to
produce graphical output. In order to
use the class you must first add it to your project. The easiest way to do this is to download
StdDraw.java and save it to the src directory of your project.
StdDraw is similar to
the Math class in that you can’t create a StdDraw object. Everything you need is accessed via static
methods and static variables. Documentation for the class can be found here, or
at http://www.cs.princeton.edu/introcs/15inout/ under the Standard Drawing
heading along with multiple examples.
Some of the methods you’ll use in this project are:
x0, x1) - used to set the dimensions for the display area. For example setXscale(-20, 20) creates a
display area where x ranges from -20 to 20.
y0, y1) – same as above, except it sets the y dimensions.
c) – set the color that will be drawn.
The colors can be accessed as static variables in StdDraw. Ex: setPenColor(StdDraw.BLUE).
x, double y, double r) – draws a solid circle with the center at position x, y
and a radius of r.
void show(int t) –
shows the drawing and pauses for t milliseconds.
from the StdDraw package may be needed and can be discovered by reading the
Your project must
include the following classes which are derived from class AerialObject (which
you also shall provide): an EnemyAircraft class, a FriendlyAircraft class, a
Projectile class. In addition, should
you choose to add any moveable GroundObjects to your project (for extra
credit), you should include an additional DogfightObject class from which
classes AerialObject and GroundObject inherit.
In addition, your project shall include a class Pos to define the
coordinates of your objects in the x-y coordinate space, as well as a class
BattleSpace to hold all of the objects in your BattleSpace (EnemyAircraft,
FriendlyAircraft, Projectile). It shall
also include an execution class AerialDogfight used to control the execution of
your simulation. You will need to import the StdDraw.java code into your
project so you will actually have at least nine classes (see me if you have an
alternate architecture in mind) in your project.
Figure 1 below
provides a partial UML Class Diagram for the above recommended
architecture. You should provide
additional classes as well as addition attributes and methods for the existing
classes as you feel necessary to meet the project specifications.
Figure 1: Project 1
“TopGun” UML Class Diagra
is a top-level class to contain all of the attributes and methods which are
common to the other entity classes in the simulation. It will contain commonly used constants as
well as attributes and methods common to both aerial and ground objects used in
Class AerialObject is
an abstract class used as the base class for creating classes EnemyAircraft,
FriendlyAircraft, and Projectile. It
will also be used for creating a reference object that will be used to invoke
polymorphic behavior of these classes when drawing an instance of these classes
in the window.
We’re going to add a
FriendlyAircraft to our dogfight to use in holding off the enemy (or to at
least zap a few of them in the process!)
Our FriendlyAircraft will be a located along the left edge of the screen
and shall be controlled using the “U” and “N” keys, indicating up and down
respectfully, to move it along the left side of the window and the ‘F’ key to
fire its Projectiles. Use StdDraw to
draw it using an appropriately sized icon.
Movement will be simulated by the right-to-left movement of the enemy
aircraft across the screen. Each time
the fire key is pressed, your FriendlyAircraft shall fire its Projectile
leaving a trail that shall travel directly to the right from its position,
disappearing when it reaches the right side of the window (hopefully hitting an
EnemyAircraft in the process!
This class should be
developed using the Figure 1 UML diagram as a basis. As a minimum, you shall display your
EnemyAircraft using an appropriately sized icon. The y location shall be
randomly generated before the EnemyAircraft object is instantiated and the x
location shall be set to the right of the display. All three of these values should be passed to
the constructor. Use StdDraw to draw
appropriately sized icons. EnemyAircraft
shall be removed from the display if hit by our FriendlyAircraft’s
Projectiles. Your life will be easier if
you use class Pos to represent the position of the objects in your BattleSpace
and make all your x and y's that designate the location doubles rather than
ints. Your toString method should return
the location of the EnemyAircraft and obviously all EnemyAircraft should be
instantiated as alive. Your
EnemyAircraft should start at the right side of the Window and move in a
semi-random direction while moving from the right to the left side of your
screen- changing direction each time it reaches the top and bottom boundaries
of the BattleSpace (or otherwise decides it’s bored with the current direction
it’s heading!). Your directions are
either directly left, diagonally down-left, or up-left. Optionally, the EnemyAircraft may fire their
own missiles at the FriendlyAircraft, destroying it and terminating the game if
the FriendlyAircraft is hit. The
FriendlyAircraft may also be destroyed if an EnemyAircraft runs into it.
The Projectile class
shall be used to create the track of projectiles fired from the
FriendlyAircraft’s weapons each time the fire key is pressed. Projectiles shall originate at the
FriendlyAircraft’s position and travel to the right until they either hit an
invading EnemyAircraft (thereby destroying it) or travel beyond the limits of
the viewer’s window. Optionally,
Projectiles may also be fired from the Enemy aircraft, either automatically or
by the designer’s choice of key depression or mouse click. If the Enemy aircraft fires a projectile, it
shall travel in the same direction as the EnemyAircraft’s heading and it shall
destroy any object (friend or foe) to which it contacts.
I also defined a class
BattleSpace to hold all of the various components for my simulation
(EnemyAircraft, FriendlyAircraft, Projectile).
It includes methods for adding EnemyAircraft and a FriendlyAircraft to
the simulation as well for firing Projectiles when the user hits the “f”
key. A draw( ) method is also provided
to display these items in the window. To
keep track whether we’re winning the battle against the invading horde, we'll
want to keep a count of and display the number of EnemyAircraft we’ve
Finally, you’ll want
to create an execution class that controls the whole simulation. Class AerialDogfight contains the methods
used to control the simulation operation.
Remember, the main method of your execution class should be very short
(2-3 lines maximum); it will basically rely on the run() method and its helpers
to control the execution.
The project will be
graded using the following guidelines
All source files, except StdDraw.java, must be documented using JavaDoc. You
must submit completed UML diagrams for all three classes.
You are expected to use what we've learned with respect to proper use of the
public and private access modifier to control access to the data members and
hide the underlying implementation as much as possible. You must also use
accessor/get and mutator/set methods to access the private data.
Style Guide (5%):Make
sure you are familiar with the style guide in terms of formatting your code and
proper use of variable and class names. See the course web page for a link to
Specifications (75%):Your project should meet the requirements as laid out in
this project description and expanded on below.
1. Project must use inheritance.
2. Project must use polymorphism.
3. Project must use Abstract classes.
4. Project must use ArrayLists to contain AerialObject
and Ground objects.
5. Project must iterate through elements
contained in ArrayListcontainer using for each loops.
6. Other requirement as called out in the
above Project specifications.
(+1 pt.) Put a counter
in the loop in the simulate method and when all targets have been destroyed
give the user his score via a JOptionPane dialog box. The score should be the number of targets the
(+3 pts.) Stop the
targets from ever overlapping each other.
(+5 pts.) Allow the
EnemyAircraft to fire their own Projectiles, ending the simulation when one of
their own Projectiles destroys the FriendlyAircraft. The Projectile’s direction of motion shall be
determined by the aircraft’s heading at the time the Projectile is fired.
(+3 pts.) In
conjunction with 3 above, EnemyAircraft Projectiles shall destroy any
EnemyAircraft or FriendlyAircraft they hit.
(+5 pts.) Allow the
FriendlyAircraft movement to be controlled in a left-to-right or right-to-left
direction as well as an up-down movement giving it full range across the entire
battlefield. When fired, the
FriendlyAircraft’s Projectiles direction of motion shall be determined by the
aircraft’s heading at the time the Projectile is fired.
(+3 pts.) Add scenery
to the Battlefield (rocks, shrubs, trees, etc.), providing an overhead
perspective of the Battlefield.
(+5 pts.) Add one or
more AirArtillery positions to the simulation.
The AirArtillery battery shall fire Projectiles in a direction that is
either controlled by the user via keyboard selection or simulated automatically
using a random number generator to fire the projectile and determine direction.
should consist of:
Paper Submission: A
printout of all files containing any source code that you either create or
modify, the complete UML diagrams for all classes, and a screen capture of the
execution. Source code shall be properly
annotated using appropriate JavaDoc notations. It is not necessary to turn in a
hard-copy of any provided source files that you did not modify.
Submission: All source code, including files provided for your use (in other
words everything we'll need to compile and run your program). These files shall
be submitted to your instructor via BlackBoard by the deadline. You do NOT need to submit StdDraw.java.