Lab 8: A chess game

The goal of this assignment is to practice writing classes that implement interfaces.

If this lab runs long, you should be sure to commit what you have and hand it in at the end of today's lab period.

1. Introduction

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. Clone the repository from the class directory to get started:

$ cd csci235
$ hg clone /cslab/class/csci235/lab8
$ cd lab8

Open Piece.java in xemacs. The Piece interface is a 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 red is slightly easier 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 righthand 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. The board also keeps a count of the number of moves that have been completed.

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 kings are implemented, and that incorrectly):

$ javac *.java
$ java Chess &

Next open Chess.java in xemacs (if you haven't already); most of it is GUI stuff you can ignore. Note that the constructor sets up the board by calling the populate() method in class ChessLib. If you look at ChessLib.java, you'll find that it places the kings in appropriate places. As you implement other kinds of pieces, you will need to update populate() to place them on the board.

Very important: You will have no reason to modify Chess, ChessBoard or Piece.

Your task is to fix the implementation of the classes for the various kinds of pieces, starting with King.

2. King

The King class that has been provided has the rather serious defect that its method canMoveTo() always returns true. You should fix this so that it returns true only for legal moves: one space in any direction (including diagonal) into a square that is not occupied by a piece of the same color. (Don't worry about the rule that kings can't move into check; our program will not determine if a king is in check.)

Commit the changes to your repository when you have completed the class.

3. Rook

Now write a new class Rook that also implements the interface Piece. The rook should be able to move to any square in the same row or column, but it cannot move through another piece and it cannot move onto a square occupied by a piece of the same color. A rook should display as the letter R (instead of the king's K).

If you'd like to make your Rook from the King, you can start by copying it using Mercurial:

$ hg copy King.java Rook.java

$ hg add Rook.java

After changing the letter displayed, your work will be to write canMoveTo correctly. You may want to write this in several stages. For example, you might want to first figure out if the destination would be legal. Then you might add code to check that the path is open. If you do this in stages, it makes sense to hg commit after each step.

Before writing lots of almost-the-same code, think carefully about whether there is a way to describe the cases arithmetically. As a hint, recall that there are useful methods in classes Math and Integer.

Don't forget to add the placement of the rooks (in the four corner squares) to ChessLib.populate(). And remember to commit when you've finished with each new kind of piece.

4. Bishop, queen

Now complete classes Bishop (display as B) and Queen (display as Q). A bishop can move any number of spaces diagonally; a queen can move either diagonally or within a row or column. As with the rook, they can not move through an occupied square, and they should not move onto a space occupied by a piece of the same color.

Think carefully about how to write this code. If you find that you want to have a static method that can be called from more than one class, you can put it in class ChessLib. (See above about using either hg copy or hg add to tell Mercurial about your new files.)

Add the new pieces to populate (see the Wikipedia page if you aren't sure where to put them), and commit your code to your repository.

5. Knight

The Knight will have to display as N (because the king has K). A knight can move three spaces in an L-shape (two vertically and one horizontally, or vice versa). The knight is unique in that it can move through other pieces.

6. Pawn

Pawns are the most difficult. They must obey the following rules:

• If not capturing another piece, a pawn can move one space vertically ahead (i.e., towards the opponent's side).
• If capturing another piece, a pawn can move one space diagonally left or right (still towards the opponent's side).
• If this is that particular pawn's first move, then in addition to the previous two options, if not capturing another piece, it may move two spaces vertically ahead (ie, towards the opponent's side).
• If this pawn has made it all the way to the other side, from then on it can move as a queen.

Before a pawn becomes a queen, it should print out "P", but afterwards, it should print out "Q". (Hint)

Don't forget to update populate().

7. Extra credit

If you have time and would like to earn some extra credit, you may implement one or both of the following features:

• Allow for castling.
• Allow for the en passant rule.

8. Turn in

In the directory where you have your files, run the command

/cslab/class/csci235/bin/handin lab8 .

Note the dot: that means to turn in everything in the current directory.

You should turn in whatever you have done at the end of lab time. If you want to keep working, you may do so and turn that in later as lab8b. Here is a reminder about how to copy your repository to your account.