The goal of this assignment is to practice writing classes that implement interfaces.
This project asks you to finish a program that allows two people to play chess on the computer. Most of your work will be in writing code that determines whether or not a move is legal. Most of the necessary information about the game is contained in this project description, but if you're unfamiliar with the rules of chess, you may find a rules of chess reference helpful.
A large portion of the program is already written. After making a directory for this lab, d download the following files from the class directory:
mkdir lab8 cd lab8 cp /homes/tvandrun/Public/cs235/chess/* .
Open Piece.java in xemacs.
The Piece interface is an supertype for classes
that represent the various pieces of chess.
It declares methods to check what color the piece is, tell the piece
what its position on the the board is, make a string representation of it,
and determine whether a move is legal for that piece (more on that last part later...).
Each kind of piece (King, Queen, Rook, etc) will have its own class that implements
Piece.
A piece also has a color, which we will indicate using a boolean value
(true=black, false=red; red is chosen instead of white because I found white
to be difficult to see in the GUI).
ChessBoard is a class that represents a board.
You will not need to make any changes to this file.
In fact, you do not really need to know how it works
(though it would be a helpful exercise for you to read it carefully
and understand it), only what it does.
It is an 8x8 grid that can contain chess pieces.
Positions are indicated by row,column pairs. For example,
the position in the upper lefthand corner is position 0 0, and
the position in the lower lefthand corner is position 7 7.
You can ask it what piece
is at a certain position; you can indicate you want to move a
piece from one position to another; you can place a new piece
on the board; and you can display it to the screen.
Chess has the main method (though most of the
work is in the Chess constructor).
It displays a window to the screen which shows the chess board.
Pieces are marked by letters indicated what kind of piece it is.
When it is a player's turn, he or she can click on a piece he or
she wants to move (at which point the space the piece is currently
on will turn green) and then click on the space to which
the piece should move.
If the program determines that such a move is possible, then
the piece disappears from the original space and appears in the
indicated space.
(If the user changes his or her mind before clicking on the destination,
clicking on the original space a second time unselects that piece.)
Try out the game as it is so far (you'll see that only queens are implemented, and that incorrectly):
javac Chess.java java Chess &
Next open Chess.java in xemacs (if you haven't already);
most of it is GUI stuff you can ignore.
One section in the constructor sets up the board by putting
the two queens in appropriate spaces.
This you will need to update as you implement other kinds
of pieces.
Very important: This is the only part of
Chess that you may modify.
You also will have no reason to change ChessBoard
or Piece.
Your task is to fix the implementation of Queen
and to implement the other classes.
The problem with Queen is that the method canMoveTo
always returns true.
Queens can move any number of spaces vertically, horizontally, and diagonally.
They may not, however, move through other pieces, and
they cannot land on a space occupied by another piece of the
same color (that is, we want to prevent a player from capturing
his or her own piece by accident).
This will be true for other pieces you implement.
Rewrite the method so that it calculates if the indicated position
is a legal one to move the queen based on the piece's current position.
Now write a new class King, also implementing
Piece.
Kings can move one space any direction.
(Don't worry about the rule that kings can't move into check;
our program will not determine if a king is in check.)
Their string representation should be similar to queen, but with "K" instead of "Q".
Modify the Chess To
place the kings in the correct positions in column 4 next to their queens.
Now write classes Bishop, Rook, and
Knight.
Bishops can move any number of spaces diagonally;
rooks can move any number of spaces vertically or horizontally;
knights can move three spaces in L-shapes (for example,
two spaces horizontally, one space vertically).
For knights, output "H" for horse, since "K" already stands for kings.
Knights, unlike other kinds of pieces, can move through
other pieces.
Update Chess.
Each side has two of each of these pieces.
Check the reference mentioned above if you need to know where to
place them.
Pawns are the most difficult. They must obey the following rules:
Before a pawn becomes a queen, it should print out "P", but afterwards, it should print out "Q".
Don't forget to update Chess.
If you have time and would like to earn some extra credit, you may implement one or both of the following features:
Create the script file as before (cat, rm, compile, and run),
showing all the classes that you wrote or modified (so... everything except
ChessBoard.java).
a2ps (the name of the script file)