CS242 Program 6

CS242: Advanced Programming Concepts in JAVA

Fall 2010

Program 6

Due: 2:00 PM, Monday, 10/18/10

This assignment is to implement a simple command line interface. That is, it allows the user to enter a series of commands to control execution of a program and shows the user the results of each command.

This program should still follow the structure of Program 5: it should have classes TestCheckers, Game, Checkers, Board, and BadRowOrColumnNumberException and interface Moves that satisfy the design requirements (class structure, methods, and packaging) specified in Program 5.

The program should have a class named TestCheckers which contains the main method. This time the main() method needs to manage only a single game. The main() method should accept commands from the command line, one command per line. Commands are of the form
command parameter1 parameter2 ....
All commands are free-format, i.e., variable spacing before and after commands and parameters, and not case-sensitive. That means the command can be typed in upper or lower case characters, or a mixture of both.

As each command is read, it is echoed to the screen. That is, it is printed on the screen exactly as it was entered. Then it is reprinted in a standard format described below.

The commands are:

start
A new game begins, with the pieces placed as they should be at the start of a game.
remove row col
row and col must be nonnegative integers. Removes the piece at (row,col)
place piece row col
piece, row, and col must be nonnegative integers. Puts a piece on (row,col). The parameter "piece" is an integer that indicates what kind of piece it is
move fromrow fromcol torow tocol
fromrow, fromcol, torow, and tocol must be nonnegative integers. Moves the piece from (fromrow,fromcol) to (torow,tocol).
show row col
row and col must be nonnegative integers. Prints the contents of (row,col) to the screen.
display
Displays the board on the screen.
quit
The program terminates.

The program should prompt the user for a command. You can decide how to do this. After the user enters a command, the program will echo it to the screen, and then check that it was a valid command. If it isn't, then an error message is displayed. If it is, then the command is printed out again, but using the following formatting:

The command should be written entirely in upper case, starting in column 1 of the output.
Then the parameters should appear. Parameters should be written starting in column 10, right justified in fields of width 5. That is, if the first parameter is the number 23, then the string "23" will be written in columns 13 and 14 padded on the left with three blanks. The next parameter, if any, goes in columns 15-19, and so on.

After this, the program should repeat the entire process, until a quit command is entered. After processing the quit command, the program terminates. Here is an example. The ">" is the prompt to the user.

>         start
         start
START
>  Move 5  1     7 4
  move 5  1     7 4
MOVE         5   1   7    4
>  moove 34 14
  moove 34 14
Illegal command
>   placE  4  2  6
   placE  4  2  6
PLACE        4   2   6
>  place  5   -8  2
  place  5   -8  2
Illegal parameter: -8
>quit
quit
QUIT

It is not necessary to use additional exception handling in this program, but you may want to. All exceptions should be detected and thrown in the method where they occur, and caught in main(). This will include I/O exceptions and exceptions caused by bad parameter values. You don't need to consider illegal checkers moves (unless you want to). All exception classes that you define should contain variables and methods that enable main() to extract important information about the exception, so that main() can respond appropriately to each exception.

Your grade will be based on how well you design and implement the code, how thorough your error handling is, on good programming practices, and on thorough testing. Coding guidelines for Java programs are posted here.

Add comment documentation to your program and use javadoc to extract the documentation into an HTML file. Include a javadoc comment for each class and each method. The class comment should include your name and the date (use the @author tag). Method comments should briefly describe the purpose of the method, its arguments, and what, if anything, it returns (using @param and @return as appropriate).

The physical location of the javadoc comments is critical. A class comment must immediately precede the line containing the keyword class, and method comments must immediately precede the method.

When you have commented your source files, run javadoc to create the .html files and view them in a browser of your choice.

What to submit:

Turn in a hardcopy printout of your java source files TestCheckers.java, Game.java, Board.java, Checkers.java, Moves.java, BadRowOrColumnNumberException.java, and any other java source files you wrote, and a printout of your test run. Do not give me a copy of the javadoc.html files.

All Java programs will be submitted by copying (or ftping) them to a specially designated directory in AFS. Each person in the class has a subdirectory which has the same name as your login in /afs/cu/class/cs242/fa10
Within this individual directory, create a subdirectory named p6. Copy only the source files into this directory, not class files or javadoc files. So, for example, if your login name was smithjd then the files TestCheckers.java, Game.java, Board.java, Checkers.java, Moves.java, BadRowOrColumnNumberException.java, and any other java source files you wrote should be copied to /afs/cu/class/cs242/fa10/smithjd/p6. These directories have permissions set so that no one other than yourself and Prof. Lynch can read the files. You may, of course, use whatever operating system and compiler you wish to develop your code, but the version you turn in, both hardcopy and the files submitted to AFS, must compile and run under JDK installed in the Clarkson ITL (our lab room).

Your grade on the program will be based on:

Correct execution. The program must follow all the specifications above. The hardcopy of your program's execution should clearly demonstrate that it does.
Correct implementation. The program must follow all the design requirements above.
Error checking. You have to figure out what kinds of errors your program should check for, and how it should handle them. It's up to you to figure out what kinds of errors there are. The hardcopy of your execution should include examples of some of the program's error handling capabilities. If your program has extensive error handling capabililities, then it will not be necessary or practical to demonstrate all of them in your test run, but it should convince a reader that the program handles errors well.
Readability of the code: commented and well-structured, so that it is clear what the code is doing. Use an accepted programming style. The style of the text is fine, or you can follow the Code Conventions. Whatever you do, be consistent.
Appearance of the output. Since we've covered formatted output, you should make sure it looks good, and any error messages should be well-formatted and easy to read.
Timely submission of your program. All hardcopy must be turned in by the deadline. Late programs will not be accepted. Printouts submitted electronically will be ignored.