S428/S528

Assignment 3 - Part 1 (Group Assignment)

Due Sunday, Feb27, 2005 before midnight

The Battleship game

In this assignment, you will need to implement a simple object-oriented version of the Battleship game. Hopefully you have all played it sometime, if you haven't you may want to take a look at the game before attempting to write the classes. The following description should give you a rough idea about what the game is about. Since this is a group assignment, I am going to give it in two parts - the first part, due right after the midterm, would be based on standard object-oriented design, and the second part (details TBA) would extend the first part using inheritance.

Description

Battleship is usually a 2 player game. Each player has a two dimensional board, with sections (like a chess game) that represent different portions of a see where a naval battle is taking place. Each player has a fleet containing a number of different types of ships, which are placed in his/her board. Each player only sees his/her board, and tries to guess where the other player's ships are.

The game is played in turns, where the player with the current turn shoots 3 shots at different parts of the opponent's sea. If any of the opponent's ships are hit, they are damaged, and the player earns points. The objective of the game is to win the war by destroying all of your opponent's ships before your opponent destroys yours. The game ends when either your or your opponent's ships are all destroyed. It is possible to end the game earlier after each round as wwell, by asking the player whether the game should continue.

We are going to start with a simple version of this game, but continue through the semester to progressively make it more and more complex. You will do a design for the complete game, but initially our requirements would be simple.

For the assignment, you will assume that there are 4 types of ships (Airplane carrier - A, Destroyer - D, Submarine - S, and Warship - W). To keep things simple, each ship only occupies one cell of the board. Also, to keep things simple, we will assume that one hit on any ship will destroy that ship. However, points are earned differently by distroying different types of ships - 50 points for a destroyer, 75 for submarine, 100 for a warship and 125 for airplane carriers.

You will take turns (play with another team - its more fun!) where you will take your opponent's shots and create your own.

You will need to write the code for Battleship.java, which will be the main class for your program (and will have the public static void main, and run methods). You may create as many classes as you need, and submit all the java files that you have created, but none of the class files that are provided.

Please follow the convention that only class names start with a upper case letter. Points will be deducted if you do not follow the convention.

As a good programmer, you should DOCUMENT your program (i.e. with meaningful variable names, comments, etc.)! Points will be deducted if you do not document your program. Please use the commenting and coding conventions discussed in class as much as possible.

What to submit: You will need to create a word document called Battleship.doc with the class diagram for your assignment. You only need to have the class diagram, and not any sequence diagrams. However, the class diagram must be complete, it should have all the classes, and their attributes and methods, and the associations between them. This will count for 25% of your points, and even if your code does not work, a good class diagram will make you elligible for partial credit.

Remember that since this assignment is a group assignment, and the basics of the assignment are fairly simple, I would require a thorough job in the design and implementation. Every team member must participate as equally as possible. At least one class (or a significant number of methods of a class) must be developed by each member, without extensive assistance from other members. Members who feel somewhat lagging in programming skills can help in documentation and testing of the code. Please make only one submission per group. Submission requirements are as follows:

• UML Design - Each submission must have a complete UML of your design, including the classes, their attributes and methods, and the links between the classes with proper arity. Your UML should show the data types of the attributes and the methd return types and parameters.
• Code Documentation - Your code must be extensively documented, with Javadoc-style comments for every class, and ever method. You must indicate what each method does, and justify why you need this method. For information on Javadoc-style commenting, please see http://java.sun.com/j2se/javadoc/writingdoccomments/. Every class and method should indicate who the author is and when it was created and last updated.
• Testing - You must extensively test each class you write, by placing a main method in the class, that creates one or more instances of the class, and calling and testing each of the methods defined in the class. Tr out strange inputs that might potentially break your code. If any test fails, fix the problem or indicate why it could not be fixed in this implementation. Its okay for some test cases to fail as long as you know what they are.
• Strategies - You are welcome to implement any strategy for firing that you see fit for the game. A random strategy is fine, as long as you ensure that you are not firing at the same place that you have already fired. And no, cheating is not a valid strategy. You should show your board state each time after your opponent fires.
• Starting move - you should set your game up to start either with you moving first or opponent moving first, configurable as a command line parameter. If no parameter is specified, you can default to one that you pick (whether you go first or opponent goes first), or provide a usage message.
• Error checking - Any error conditions must be checked (number out of range is the most common). In this assignment you do not need to worry about checking if your opponent is cheating, since we are going to use the honor method and assume that nobody cheats. We are going to have a one round round robin league in class, and the team that wins will receive a 10% bonus on the assignment.
• README File - Each submission must be accompanied with a README file that lists all the team members and their responsibilities, and a judgment of what percent of each of the classes coding/testing/documentation was performed by each member.

I/O Convention: Since the submission system will explicitly test your program, you will have to stick to the general I/O guidelines described here. This means you will have to accept the input in the format described here. You may choose to use your imagination in generating the output, but you cannot change the type of input the program receives. The following is a sample run of the program as I wrote. Feel free to change the prompts any way you like. However, pay special attention to the user inputs (indicated below in red and bold). You must accept input in exactly this format.

C:\>java Battleship
Usage: java Battleship [self|opponent]
C:\>java Battleship opponent
Setting up my board..
My board is:
  01234567
0 S..D....
1 ..W.....
2 ...A.S.A
3 ......AA
4 D.....DS
5 ....S...
6 DWS.A.W.
7 ...D..WW

Opponent's turn. 

Opponent's moves: 
shot 1 (x): 3 
shot 1 (y): 5 
shot 2 (x): 3 
shot 2 (y): 6 
shot 3 (x): 3 
shot 3 (y): 7 

Opponent's hits: A: 2, D: 0, S:0, W: 0.
Opponent's score is 250
My remaining ships: A: 3, D: 5, S: 5, W: 5. 

My board is:
  01234567
0 S..D....
1 ..W.....
2 ...A.S.A
3 ......XX						<--- X denotes a shot
4 D.....DS
5 ....S...
6 DWS.A.W.
7 ...D..WW

Continue playing? yes

My turn.
My moves are: (1,1), (1,3), (1, 5) 

My hits: 
A: 0 
D: 0 
S: 0 
W: 1 

My score is: 100 
Opponent's remaining ships: A: 5, D: 5, S: 5, W: 4. 

Continue playing? yes

Opponent's turn. 
Opponent's moves: 

....

Opponent's remaining ships: A: 0, D: 0, S: 0, W: 0.

Opponent's ships are all destroyed, I win!
My score is: .... Opponent's score is: ....

RandomIntGenerator.class documentation The following are the public properties that you need to know about this class for this assignment.

1. Constructor public RandomIntGenerator(int l, int h)

   This constructor takes in two integers for lower and uppper bounds. All random numbers generated are in this range.

2. Method public int draw()

   This method draws a random number from the range that was constructed, and returns it.

RandomIntGenerator mygenerator = new RandomIntGenerator(5, 20);
int nextnumber = mygenerator.draw();

nextnumber = mygenerator.draw();

Note that, as shown above, you will only need to allocate two instances of this class, and keep drawing from the two instances. DO NOT instantiate more than twice.

Also, only allocate one instance of the Input class.

Submission method You will need to submit your assignment using the online submission system. To submit, use the following steps:

• Point your web browser to https://www.indiana.edu/~s420/handin.html (notice the https instead of http - this indicates your information is sent through a secure server). If your browser asks if you want to display the non-secure items, say Yes.
• Type in your email address (including the @indiana.edu part) and your 10 digitstudent ID without any dashes or spaces in the appropriate boxes.
• Upload the two files for submission in the two fields provided by clicking on the Browse button and selecting the appropriate file. If you are using steel to write your code, you will need to download the java files from steel to the machine where you are using the web browser. Submit only the .java files. No class files. Follow the namig convention as stated in the assignment. If you have created other java files that you need to submit, you can use the third box, or submit them after you submit the first two files. Your submission is cumulative, so you will see all files in the submission so far after your second submission.
• Click on "Submit Assignment", and wait until you get the confirmation page. This may take a couple of minutes - do not click multiple times. The system will display a confirmation page.
• You are not done yet! Check your email for a confirmation email from the submission system. It may take upto 5 minutes for you to receive the confirmation email. Make sure you read and understand the email, including the information that it gives you. Do not assume that your assignment submission was successful until you receive an email with no error message. Look in particular for the file "CompilationErrors". If it says "Empty file!" for this, you are fine. If any compilation errors are shown, you will need to fix them. Your assignment will be severly penalized if you have compilation errors.
• You may submit as many times as you would like - future submissions will overwrite any file submitted with the same name. If you change only one file, you can submit only that file. The confirmation message will include all files submitted so far. Keep a copy of the confirmation message. This will be proof that your submission was successful in the case of a system glitch later.