ESTR1002代做、代写C/C++设计编程

日期：2024-11-25 09:08

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 “47” 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 1-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.

*

* University Guideline on Academic Honesty:

* http://www.cuhk.edu.hk/policy/academichonesty/

*

* Student Name : xxx <fill in yourself>

* Student ID : xxx <fill in yourself>

* Date : xxx <fill in yourself>

*/

-- END --