ESTR1002, 2024-2025 Course Project Page 1 of 13 
ESTR1002 
 
Problem Solving by Programming 
 
2024 – 2025 Term 1 
 
Course Project – Chinese Checker 
  
ESTR1002, 2024-2025 Course Project Page 2 of 13 
Figure 1: the game board of a 
general Chinese checker. Source: 
https://en.wikipedia.org/wiki/Chinese_checkers 
1. Introduction 
Chinese checker is a turn-based board game played by two, 
three, four or even six people. The rules are simple. Each player 
takes turns to move one of their chess pieces, aiming to be the 
first to move all their chess pieces across the game board from 
one’s initial camp to the opposite side of the star corner—using 
single-step moves or multi-jump moves over some other pieces. 
You SHOULD first learn how to play it: 
https://www.coolmathgames.com/0-chinesecheckers 
 
This project is a simplified version of the game. We consider 
only two players seated at the opposing corners of an 8x8 
square board; see Figure 2 below. Each player has six chess 
pieces of his/her own. In general, the game is won by being the 
first to transfer all of one's pieces from his/her camp into the 
opponent’s camp. In each turn, a player can move one of his/her chess pieces by either 
(i) moving one single step to an adjacent empty cell or (ii) jumping through empty cells 
on the game board over some other pieces successively; we will show you some examples 
later in this spec. 
1.1 Project overview 
In this course project, you need to submit (see Section 6 in this spec. for details) 
1) [basic] a C program to provide an interactive gameplay for two human players. 
2) [basic] an embedded computer player to replace one of the two human players. 
3) [bonus] our great tournament: compete with the computer player of your classmates. 
2. Game Rule 
2.1 Game board 
The board consists of an 8x8 grid of 64 cells, see Figure 2. 
• There are two players in this game. 
• Each player has six pieces, e.g., blue or red. 
• Each player's camp consists of six cells on top-left and 
bottom-right corners of the game board; see Figure 2. 
• The game starts with each player's camp filled by pieces 
of his/her own color. 
We store the game board using a one-dimensional integer 
array of length 89. The location of each cell in the board is represented using an integer 
in [11, 88]. For example, location “**” means the fourth row and the seventh column. 
 
• The upper-left corner of the board is 11. 
• The cell on its right is 12. 
• The cell just under 11 is 21. See the cell coordinates below. 
 
Figure 2. The initial game 
board of “Chinese checker” ---
this is the name of the game.  
ESTR1002, 2024-2025 Course Project Page 3 of 13 
 
Figure 3. Encoding of the piece locations. 
Since we use an array of length 89, except for the 64 positions on the board, other 
positions are unused, where chess pieces should not be placed. Also, beware of the “array 
out of bound error” in this project. 
 
The game always starts with the blue player, whose camp is located at the upper-left 
corner. 
2.2 Represent the cells of the board 
• Empty cells: 0. For example, if the value of board [67] is zero, this means that 
there’s no chess piece on the cell at 6th row and 7th column. 
• Positions with blue chess piece: 1. For example, if the value of board [45] is one, 
this means that there’s a blue chess piece at 4th row and 5th column. 
• Positions with red chess piece: 2. For example, if the value of board [45] is two, 
this means that there’s a red chess piece at 4th row and 5th column. 
• All other positions outside the game board: -1. 
2.3 Play sequence 
• The player of the top-left corner always moves first. 
• Pieces may move only in eight possible directions (orthogonally and diagonally). 
• In each turn, a player can have the following possible moves: 
o a single-step move to an adjacent empty cell; see possible moves #1a and #1b in 
Figure 4. Example possible moves for example horizontal and diagonal moves, 
respectively; 
o a single-jump move to an empty cell with one jump over some other pieces (can 
be the player’s own piece or opponent’s piece); see possible moves #2a and #2b 
in Figure 4. Example possible moves for example vertical and diagonal jumps, 
respectively; 
o also, we can have a long distance jump to an empty cell with exactly one single 
piece in the middle between the lifting and landing locations in that jump; see 
possible move #3 in Figure. 4; and 
o a multi-jump move with more than one jumps successively through some empty 
cells, while having only one single piece in the middle between the landing and 
lifting cells for each jump; see example moves #4a, #4b, and #4c in Figure 4. 
11 12 
21 
(7,7) 
22 
 33  
ESTR1002, 2024-2025 Course Project Page 4 of 13 
 
Figure 4. Example possible moves, starting from the current game board shown on the top left corner. 
 
Figure 5. Example invalid moves, starting from the current game board shown on the left. 
2.4 Game End condition: Win or Draw 
There are only two possible “end game” conditions, i.e., one of the two players wins; or 
the game is a draw. The detailed conditions are specified as follows: 
(1) WIN: After a move has been made, a player A wins the game if his/her opponent’s 
camp is filled with pieces, among which at least one belongs to A; and 
(2) DRAW: after each player has moved 100 steps, if there is no winner, then the game 
ends with a draw. 
3. Programming Guidelines 
We describe some key functions as guidelines for you. Please note that we do not use the 
online judge for the project, but still, you should follow some formats for consistent 
grading.  
ESTR1002, 2024-2025 Course Project Page 5 of 13 
3.1 Program Design of “Chinese Checker” 
 
Figure 6. The program flow. 
Note: you may create additional functions (e.g., to check if a chess piece can jump over 
another one) in your program to make your program more modular and easier to debug. 
This is also for you to learn and try the divide-and-conquer concept we discussed in class. 
 
3.2 Requirements 
Though the online judge system is not provided, you have the following set of 
requirements for consistent and fair grading. 
• Your program must read inputs from the keyboard, so that we can test your code 
consistently, i.e., we will input a sequence of four-digit integers and see if your 
program can generate the expected results. 
• Note that we will try some invalid moves and see if your program can find them. 
• Your program must print the results to the terminal / command prompt. 
• During each round of the game, your program must report: 
o the current status of the game board using the above representation; 
o print the next player; and 
o if a player places a chess piece on an illegal position, print out the notification, 
and ask the user to input again. 
• At the end of the game, you must report 
o who is the winner, or a draw. 
3.3 Function #1: Initialize the game board 
In this function, you simply initialize the board array according to the description in 
Sections 2.1.  
ESTR1002, 2024-2025 Course Project Page 6 of 13 
3.4 Function #2: Display user interface 
First, you should write a function to draw the user interface, i.e., to print the game board 
on the terminal/command prompt, given the **D array as the function input. We use 
 
• ‘#’ to represent blue, 
• ‘O’ to represent red, and 
• ‘ . ’ to represent an empty cell. 
 
Figure 7 below shows a sample screenshot of the game board presented Figure 2. 
 
Figure 7. An example of printing the game board. 
3.5 Function #3: Read a move from the user 
Second, you need to write a function to ask and receive the next move from the user. We 
use a four-digit integer to represent a move, where the first and last two digits represent 
the starting (lifting) location and ending (landing) location, respectively. For example, 
2161 means moving the piece on 2nd row 1st column to 6th row 1st column, regardless of 
the intermediate locations. See Figure 8: We use “2161” to represent the move “from (2,1) 
to (6,1) after two jumps”. 
 
Figure 8. We use "2161" to represent the move “from (2,1) to (6,1)”. 
3.6 Function #4: Check if a move is valid 
 
The inputs by a player may not always be correct, e.g., the provided starting location may 
not contain a piece, the piece cannot be moved/jumped to the target location, or the input 
is not a four-digit integer at all! This is the more challenging component in the basic part 
of this project. Hint: use recursion. To check whether a move is valid, your program 
should check if 
(1) each input is a four-digit integer, otherwise, print “Invalid input format, please input 
again:”; 
(2) each input location (both starting and ending) is within the game board range “[1,1] 
to [8,8]”, otherwise, print “Input out of the game board, please input again:”; 
(3) there exists a chess piece from the current player at the provided starting location, 
otherwise, print “Invalid starting location, please input again:”; 
(4) there should not be any chess piece at the ending location, otherwise, print “Invalid 
ending location, please input again:”; and  
ESTR1002, 2024-2025 Course Project Page 7 of 13 
(5) the move from the starting location to ending location should be valid, i.e., following 
the rules specified in Section 2.3 Play sequence, otherwise, print “The move violates 
the game rule, please input again:”. 
3.7 Function #5: Check if the game is over 
Every time a player finishes a move, your program should call a function, which checks if 
the game ends or continues (based on the current player), according to the rules specified 
in Section 2.3 “Game End” condition: Win or Draw. If the game is over, print the winner. 
Also, if both players have finished the maximum allowed number of moves and there are 
no winners, the function should return a value to indicate a “draw” rather than “win” or 
“continue”. 
 
3.8 Test your “human v.s. human” gameplay 
We have provided to you two sample test files on the course webpage (blackboard) for 
you to download and test “human vs. human” gameplay. 
 
Note that since your gameplay should support both “human v.s. human” mode and 
“human v.s. computer” mode, at the very beginning of the game, your program should ask 
the user to choose between the two modes by inputting an integer. Here, “1” means 
“human v.s. human” and “2” should mean “human v.s. computer”. 
 
A typical case is like this: 
  
ESTR1002, 2024-2025 Course Project Page 8 of 13 
4. Computer Player 
After finishing the “human vs. human” part, you will come to the most challenging and 
exciting part of the project, where we replace the function in Section 3.5 Function #3: 
Read a move from the user by a computer player function. 
 
To implement a computer player, you mainly need to finish one function. The prototype 
of the function is defined below: 
 
int ai_player ( int player , const int * board ); 
 
This function needs the following inputs: 
• int player: the chess piece that the current player uses: blue is 1 and red is 2. 
 
• const int *board: this is a one-dimensional array (const means constant, i.e., your 
function should not modify the contents of the input array) that represents the 
current cell conditions in the game board, same at what is defined in Section 2.2: 
o Empty cells: 0. For example, if board [67] = 0, this means that there’s no chess 
piece on the cell at 6th row and 7th column, you may put a chess piece there. 
o Positions with blue chess piece: 1. For example, if board [45] = 1, this means that 
there’s a blue chess piece at 4th row and 5th column. 
o Positions with red chess piece: 2. For example, if board [45] = 2, this means that 
there’s a red chess piece at 4th row and 5th column. 
o Other positions not on the board: -1. 
• The return value (int): this function returns a four-digit integer that represents a 
move; see Section “3.5 Function #3: Read a move from the user” for its meaning. 
 
4.1 “Human v.s. computer” mode 
Since you already have a function from Sec. 3.5 to scan a user input from the human, you 
can simply replace it by the ai_player function you just implemented in your main 
program to support the “human v.s. computer” mode, without implementing other game 
logics twice. At the beginning of your program, if the user chooses mode “2”, your 
program should enter the “human v.s. computer” mode. You may further ask the user to 
choose between “computer plays first” of “human plays first”, or, you may always let the 
computer to play first/second. 
 
4.2 [Bonus] The great tournament!!! 
This bonus part is an extra!!! After evaluating the “human v.s. human” and “human v.s. 
computer” parts of your program, we will evaluate how smart your computer player is 
by creating a tournament for the computer players of all the students in the class to 
compete against one another. 
 
Below is the game rule: 
• For each student’s computer player, it will play two games against the computer 
player of each of the other classmates. 
• In each of these two games (between the same pair of students), each computer 
player takes turns to use the blue chess piece and to start the game first.  
ESTR1002, 2024-2025 Course Project Page 9 of 13 
• You score 2 points for each game you win and 1 point for each draw; you got zero 
points if you lose or your program does not follow any requirements we define in 
this project specification. 
 
 
4.3 Requirements of the computer player (for both “human v.s. computer” 
and the great tournament) 
• You must follow the prototype defined in Section “4. Computer Player” to implement 
your computer player. 
• It should produce valid moves, and it should not modify the input game board. 
• Note that your computer player may play first or play second, meaning that your 
chess pieces may start from the upper-left OR lower-right corner. 
• Your “submitted” computer function shouldn’t contain any print statement, 
otherwise, the tournament system may wrongly judge your results. Note that you 
may have print statements when you debug your code but remember to comment 
them out before submission. 
• For fairness in the competition, your computer player must produce an output 
within a reasonable amount of time, i.e., within 5 seconds on the lab’s computer. 
• You need to carefully test your code to make sure your code won’t damage our 
tournament system, e.g., the “array out of bounds” error!!! 
• No “main() function” in your submitted files for the computer tournament part. 
 
Please note that if your program does not follow any one of the above requirements, you 
may get zero points for the “human v.s. computer” part or the tournament. 
  
ESTR1002, 2024-2025 Course Project Page 10 of 13 
5. Submission 
 
We have created two submission boxes on Blackboard: 
• Basic program: the entire program, including all .c and .h files that supports 
“human vs. human” and “human vs. computer” and 
• Great tournament: your code ONLY for the computer player to attend the 
tournament. 
5.1 Submission format for basic program 
Your submission for the basic program should be a single zip file named as 
 
basic_<studentID>.zip (e.g., basic_1155123456.zip) 
 
which contains and should only contain all .h and .c files in your project. The TA will 
download your submission files from Blackboard and compile them during the project 
demo to form an executable game using gcc, CodeBlocks, or Visual Studio for testing. 
5.2 Submission format for the great tournament 
Your submission for the great tournament should contain only two files: 
• aiplayer_<studentID>.h (e.g., aiplayer_1155123456.h) 
In this file, you must need to define the following function: 
int ai_player_<studentID> ( int player , const int * board ); 
• aiplayer_<studentID>.c (e.g., aiplayer_1155123456.c) 
where <studentID> is your own student ID. In this file, you may have more 
functions for your main computer player function above to call. 
 
In the submitted zip file for computer player, you need to include the above .h file and all 
the necessary functions inside the above .c file for your computer player to work. To 
implement a stronger computer player, you may define additional functions in your .c file. 
However, you must follow the above naming convention (i.e. add your own “_studentID” 
at the end of all your function names), so that your TA can take your .c file and compile it 
with other student’s .c files without having any ambiguity, i.e., same function name from 
different students. We may deduct your project marks, if you fail to follow this convention. 
Also, use .c rather than .cpp and .C as the extension of your source code file. 
 
Submission Note: 
- After preparing your submission files according to the above formats, you need to 
upload the files (see above) to the corresponding submission boxes in blackboard. 
Please see blackboard for the details. 
- You may submit multiple times for each submission box, and we take the last 
submission before the deadline as your submission for grading. 
- Furthermore, we will do plagiarism checks on your submission against others and 
against the Internet. 
 
Submission Deadline: 
- Pre-tournament deadline (optional): Nov 24, 11:59pm 
- Ultimate deadline: Nov 27, 11:59pm 
- Demo day is on Nov 28 in class.  
ESTR1002, 2024-2025 Course Project Page 11 of 13 
6. Grading 
This project has two parts for grading. Note again that the basic part of the project (part 
1 below) takes up 16% of the whole course and the bonus part (part 2 below) is extra. 
Part 1: the basic game program (16%) 
• The basic “human vs. human” part takes up 12% of the whole course. 
• The basic “human vs. computer” part takes up another 4% of the whole course. 
 
During the project demo (on the demo day during the last lecture), the TAs will compile 
your program, and then test your program in the following ways: 
(i) interactively try your game with “human vs. human”; 
(ii) pipe some sample text files in the above format into your game executable and see 
if the results are correct, as expected (you will learn the meaning of “pipe” in class 
later); and 
(iii) try “human vs. computer” in your game to see if the moves selected by your 
computer player are always valid, etc. 
Part 2: The great tournament 
Please read Sec. 4.2 again for the rules of the great tournament. 
 
After all matches are completed, we will sum up the points that each student gained as 
his/her total tournament score. Then, we will rank the students based on the total scores. 
 
Each student may then obtain extra bonus points (beyond the basic scores in the course) 
based on his/her ranking; see the table below. 
 
 
Ranking Bonus Credit (of the 
whole course) 
1 3.0 bonus pts 
2-3 2.2 bonus pts 
4-7 1.4 bonus pts 
8-15 0.6 bonus pts 
 
  
ESTR1002, 2024-2025 Course Project Page 12 of 13 
7. Project Schedule 
 
Week Date Tasks Expected to be done 
9 Oct 28 The project will be released on Blackboard course homepage 
(and will be discussed in class on Oct 28) 
 
Start to write the basic game: 
• Function: Initialize game board 
• Function: Display user interface 
• Start thinking over - Condition: “Location valid?” 
• Start thinking over how to find all squares? 
Etc. 
 
At home: implement the rest of the game. 
 
10 - 11 Nov 11 • Around this date, you should have completed the basic 
game without the computer player, so that you can focus 
on your computer player for remained time. 
 
12-13 Before 
Submission 
Deadline 
 
Finish the basic program, 
finish a working computer player (valid moves ONLY) & 
perfect your computer player (with better strategies). 
13 Pretournament

Nov 24 
11:59pm 
 
• If you submit your computer player before this predeadline,
 we will take your code to compete with others 
in a pre-tournament and will let you know your results 
and also let you know if your code has any problems. 
• The pre-tournament is volunteer-based, and has no 
contributions to the final score. However, it may allow 
you to know your program’s capability and whether it 
has any compilation problem, so that you can work out 
a better program before the deadline. 
 
13 Nov 27 
11:59pm 
Deadline of submitting (1) the basic program & (2) the 
computer player. 
13 Nov 28 
2:30pm4:15pm

DEMO DAY: 
 
1) TA will evaluate the basic program of all the students 
one by one in the lab (must present and wait). 
2) TA will run the great tournament. 
  
ESTR1002, 2024-2025 Course Project Page 13 of 13 
8. Academic Honesty 
 
Every submission will be inspected using plagiarism detection software. The worst 
possible punishment is to have this course failed. For regulations and details, please refer 
to the following URL: 
https://www.cuhk.edu.hk/policy/academichonesty/Eng_htm_files_(2013-14)/p06.htm 
 
Last but not least, please take note of the following declaration that we presume that you 
agree on if you submit your project code. 
 
/** 
 * ESTR 1002 Problem Solving by Programming 
 * 
 * Course Project 
 * 
 * I declare that the assignment here submitted is original 
 * except for source material explicitly acknowledged, 
 * and that the same or closely related material has not been 
 * previously submitted for another course. 
 * I also acknowledge that I am aware of University policy and 
 * regulations on honesty in academic work, and of the disciplinary 
 * guidelines and procedures applicable to breaches of such 
 * policy and regulations, as contained in the website. 
 * 
 
請加QQ：99515681  郵箱：99515681@qq.com   WX：codinghelp