Lab 1: Checkers Pieces

SWE 2410 Lab 1: Checkers Pieces

In this lab, you will explore a maintenance task that does not take advantage of patterns. While we will study design patterns that are useful to this maintenance task later in this course, do NOT apply design patterns while working this lab. The goals of this lab include refreshing skills with Java and JavaFX and to encounter coding challenges that are addressed by introducing design patterns.

This is an individual lab. Consult with your instructor, not other students while working on the lab. In addition, follow your instructor’s directions on the version of Java and JavaFX to be used in this lab. If your instructor provides a starting version of the project (such as with GitHub Classroom), be sure to check that the project uses the correct verisons of Java and JavaFX. This may require you to visit the project’s structure and the run configuration. If your instructor does not have alternative instructions, follow the directions at tayorial.com to create a new Java project. Create a subdirectory checkers under src and download and unpack the files in checkers.zip to this folder.

Build the project to see a six by six checkers board as shown in this image. This version of the game allows you to move pieces towards the other side of the board and to capture pieces by jumping them. It does not support multi-capture moves. It also does not support pieces being “kinged” - more on this below.

In checkers, pieces move diagonally, staying on the same color squares. Each move is to an empty square. When that square is adjacent, the piece moves just one square. If an adjacent square is occupied by an opponent’s piece and the square past that (in a straight line) is unoccupied, the piece can capture the opponent’s piece by jumping it. At the start of the game, all pieces are regular pieces, meaning they can only move towards the opponent’s side. For full rules of checkers and to get experience playing the game, you might check out cardgames.io/checkers/.

In this lab you will add support for kings. Once a piece reaches the opponent’s side of the board, the piece is “kinged” by placing a second checker on it. Kings can then move both forwards and backwards. This is the only difference; they must stay on the same color squares (moving diagonally) and can only move to an adjacent square or jump one opponent piece.

Detailed steps

The following steps add king pieces to the game. All changes in this lab should be to the file Piece.java. If you feel you need to change other files, talk to your instructor to identify an alternative approach.

An example of a king is shown in this image – it is the piece with two ellipses.

Identify the place in the code where the type of a piece is defined.
Add a boolean at that place to track whether a piece is a “king”.
Add an optional parameter to the Piece constructor that allows clients to create pieces as kings from the start. By default, pieces are not kings. As you do this, keep the DRY principle in mind!
Identify the place in the code where it determines that a black piece has reached the last row of the board.
Modify this code to identify when a red piece has reached the last row as it moves in the opposite direction across the board.
When a piece reaches one of these positions, update the piece’s state to indicate it now represents a king.
Identify the place in the code which creates the ellipse and places it on the screen. (See also step 9.)
Modify this code to draw two ellipses instead of one for kings. Place the second ellipse (known as the “crown”) ten pixels above the first ellipse. To implement this, note the createEllipse method can be called twice. Alternatively, you might find it useful to introduce a Pane object to treat the pair of ellipses as a single item. One trick you might find useful is to create graphics objects but set them “invisible” so they do not show when drawn, then setting them “visible” later. No matter how you implement your solution, both ellipses must be selectable and both must be highlighted when selected. Be careful to match details. For example, the lower ellipse must be partially occluded by the upper and there needs to be an appropriate separation between the ellipses.
Identify the code which places the ellipse at the correct location on the screen.
Modify the code to place the “crown” piece in the correct place on the screen.
Identify the place in the code where it determines if an ordinary move is valid.
Update this code to work for kings; that is, so that kings can move diagonally towards either side.
Identify the place in the code where it determines if a capture move is valid.
Update this code to work for kings. As for regular pieces, a king must jump a piece (on the diagonal) to capture it, but the jump can be towards either side of the board. In real checkers, the piece must have the opposite color, but this is not enforced in this version of the game.
Identify the place in the code where a piece is visually removed from the board.
Update this code to work for kings; both ellipses need to be removed when a king is captured.

The intent is that you would leave the general structure of Piece.java in place. However, you can rename methods and variables, introduce new methods and variables, split long methods, and add comments that help you understand the code.

A major portion of this lab is determining where to edit the code. Consult with your instructor if you are not confident about where to edit.

Submission instructions

If you are using a Git repository (for example, GitHub Classroom), be sure you have pushed a working version of your solution.

If you are using Git from within IntelliJ, go to the Commit tab and ensure all changes have been committed and pushed. If you are using command line Git, type git status inside the repository folder to check everything has been pushed.
Now that your local repository matches that on the Git server, build, run, and test your solution to make sure it is completely working. Fix any issues and go back to step 1.
Test your solution thoroughly, including that both regular and king pieces can move appropriately and that the game does not allow illegal moves. There are a surprising number of elements in this code, and it is very easy to add code that breaks existing functionality.

See Canvas for additional directions on submitting solutions.