Eckerd College
CS 221N – Data Structures
Final Project
Task: Your final project for the semester will involve a real-world application of the data structures you
have learned in the course. You will develop a computer game using Java, external packages, and your
knowledge of data structures, and must demonstrate that your software design made the proper
decisions regarding data structures and algorithms. You will also need to do some independent study,
as outlined below.
This project was intended to be a group project, but as there are only three students in the course you
will all work together. Each person should be contributing roughly equal amounts of work. Collectively,
you will make a choice on the game you would like to implement. Things to keep in mind:
1. The most important thing to remember are the tasks your game must perform and the data that
needs to be stored. Given these guidelines that you create, you will need to make decisions on which
data structures and algorithms you will use.
2. The game must include some form of graphical user interface (GUI). Although we did not study
methods for implementing Java GUIs, external libraries such as Swing facilitate this process and many
Java manuals use them throughout their concept descriptions. You should be able to find help either at
the library or online; or I have a couple of Java manuals which you can borrow. The GUI is not the most
important part and need not be excessively complex and sophisticated, but sufficient for your game.
3. Remember that computer games cannot crash upon illegal keystrokes (or other forms of user errors).
Rather, Java provides exception handling capabilities which can detect incorrect behavior at runtime
and either exit gracefully or produce a message. Once again, we did not cover this – however you
should be able to read about these capabilities and use them accordingly.
Deadlines to remember:
Proposal (Fri, 11/7): This should include the following: Proposed title and description of your game, a
rough sketch of how you propose to implement your game (including data structures, class names,
member functions/variables), purposes of each data structure, and a timeline. The relationship
between data structures/algorithms and game functionality should be clear.
Progress Report (Fri 11/21): Please prepare a short writeup of progress in the first two weeks since the
proposal, including milestones achieved and remaining tasks. We will discuss progress in class as well.
Final Report and Demo (Fri 12/5): The demo will take place on the last day of class and you will prepare
a final report which is due the same day. Although documentation for a computer game typically
consists of a game manual, as this is a data structures course you will take a slightly different approach,
and express the documentation in terms of solving problems and applying your knowledge of data
structures and algorithms. Thus your writeup will consist of the following:
Abstract: Separate from the rest of the paper, the abstract should describe the problem and your
contribution. In this case the problem will consist of the tasks your game must accomplish, and the
contribution will be your applications of whichever data structures and algorithms you select to
accomplishing the tasks of the game.
Keywords: The main concepts explored in the paper.
Introduction: Describe the problem being addressed and your general solution strategy.
Main Body: Describe your game in a bottom up fashion. This section should thus read as follows:
1. A description of each data structure (including code snippets), and how they solve each task.
In their description, you should also include potential alternatives, and an explanation of why your
approach is the best solution. Please cite references to literature (the textbook, websites, any other
papers you may read). This applies throughout the paper, but probably mostly to this section. If you
quote literally, make sure to use double quotes (“) and provide the source.
2. A control flow description, indicating what happens from the point where the user starts your
application to the point of exit. You may use diagrams and code snippets as you see fit. This section
should also illustrate relationships and dependencies between data structures (for example, if you use a
stack – does it store data in an array or a linked list? Does it invoke some function of a separate queue
class? Which other structures invoke member functions of your stack?)
3. Finally, a discussion of how to play the game. This section should be something a user can
simply jump to, read and understand how the game works. Please use screenshots as necessary.
Conclusions: Following from the introduction and main body, demonstrate in 1-2 paragraphs how your
implementation addresses the concerns outlined in your introduction. Although you may be
summarizing the main body a bit, a reader should be able to look at your abstract, introduction and
conclusion and understand your contribution. Also if there is any speculation, please provide this here
as future work.
References: Any sources you use should be cited.