CSCI 1321 (Principles of Algorithm Design II), Fall 2007:
Homework 7

Credit

Design 20 points; code 40 points.

Overview

By now your game should be playable, with all the major functionality implemented. This homework is something of a tangent; the goal is to write a second, more efficient priority queue and compare its performance with your first version. The needed code breaks down into two categories:

First, you are to write a second priority queue class that uses a heap (as discussed briefly in class, and also in the textbook, using an array or Vector to store elements) rather than a sorted linked list.

Second, you are to add code to your game that will allow you to compare the performance of the two implementations as the number of game entities in the queue varies. To do this, you need to do several things: create a ``dummy'' game entity class so you can put arbitrarily many entities in the priority queue, change your main class to accept two command-line arguments that specify which implementation to use and how many of these dummy entities to add, and change your player class to print out some information that will allow you to see how performance varies based on the choice of priority queue implementation and the number of dummy entities.

Once you do these two things, you can run your game with different values of the two command-line arguments and see how performance changes. The final part of this assignment is to do this and plot the results.

Design and Code

You need to do the following:

• Write a second priority queue class. Like your earlier priority queue, it should implement the framework's PriorityQueue interface. You could call it HeapBasedQueue, or something else that distinguishes it from the previous class.

• Write a ``dummy'' game entity class you can use to put lots of entries in the priority queue. It will need all the methods of the GameEntity interface, but the only ones that have to do anything are update (store the time passed in) and getUpdateTime (return the time previously passed to update plus something nonzero). To fully test your priority queue, the time between updates should not be the same for all dummy entities. A simple way to make this happen is for each entity to have a timeBetweenUpdates variable, passed in via a constructor; its getUpdateTime method then returns the time of the last update plus timeBetweenUpdates.

• Add code to your main class so that it accepts two command line arguments. The first selects which of your priority queue classes and should be either ``list'' or ``heap''. The second specifies how many dummy entities to add to the queue.

• Add code to your game setup class that does the right thing with these arguments: creates either an instance of your linked-list priority queue or an instance of your heap priority queue and then adds to it the specified number of dummy entities. You can generate values for the entities' timeBetweenUpdates using a random number generator (e.g., using nextInt(maximumValue) in Java library class Random, where maximumValue is some sensible maximum time between updates, say 10). Notice that the dummy entities need to be added only to the priority queue, not to any screens.

  Probably the right place to add this code is in the constructor for the class. There are various options for passing in the two command-line arguments. One is to make them parameters to the class's constructor, write a method makeInstance that takes two parameters and uses them to create the class's one instance, and call makeInstance from your game's main class. Or you may think of a better approach.

• Add code to your player class's update method that prints out timing information, specifically how much time it takes for every 100 calls to the method. System.currentTimeMillis() returns a long with the current time in milliseconds. Every 100-th call to update (when time % 100 is 0), you can call this method to get the current time, subtract the previous current time, and print the resulting difference.

Once you have written and tested the above code, I want you to collect and plot timing information that shows how, for each version of the priority, performance (time for 100 calls to player's update method) changes as the number of dummy entities increases. You will have to experiment a little to see what number of entities is needed to get meaningful results. Start with a small number (say 10), and then increase it by factors of 2 or 10 until you see performance differences. What you should see is that for $n$ entities the time for the linked-list version is roughly proportional to $n^2$ , while for the heap version time is roughly proportional to $n \log n$ .

Step-by-step instructions

• As with previous assignments, you should probably start by creating a new Eclipse project, then creating a package within the project, and then copying over all your code from previous assignments. You can use the same package name as in previous assignments.

• Create your two new classes (priority queue and dummy entity) and add code to existing classes. Revise and debug until you're happy with how your code compiles and executes.

• Generate HTML documentation for your project as described in the Project Description. Check that the generated documentation is okay; point a browser at http://www.cs.trinity.edu/~yourusername/CSCI1321/HW7/Final and check that all your classes and documentation comments show up.

• Turn in your code by sending me mail with all of the files I need to compile and run your game as attachments. This includes all (.java files), any file(s) created using the screen editor, and any file(s) containing images. All of these files will probably be in the same directory containing your Eclipse project (same name as the project, in your Eclipse workspace directory), unless you put them somewhere else. You don't need to send me .class files or the JAR file, but if it's simplest for you just to send me all the files in the directory for your Eclipse project, do that. It's better to send a bit too much than not enough!

  The ``General requirements'' section of the Project description has more suggestions about how to send me the needed files.

  Please use a subject line such as ``csci 1321 code 7''.

• Turn in your two plots either in hardcopy form in my mailbox (outside my office door) or by e-mail. If you choose the latter option, non-proprietary formats are preferred (e.g., PDF or GIF rather than Microsoft Excel).

Files and links

• The JAR file for this assignment, PAD2S08Assn7.jar. (This JAR file is essentially the same as the one for Homework 5, included again here for completeness.)

• Project Description.

• Project API (Lewis game framework).

• Java library API.