C++设计程序讲解、program编程语言辅导

- 首页 >> Matlab编程
Tic-tac-toe game in C.
Read the following task carefully before working on it. The tasks are
placed in such a way that they represent an obvious processing sequence. But you don't have to
keep the order, but some tasks can only be meaningfully processed after others.
At the end of the C part, a file should be created with which you can continue working in the Matlab
part
should. If you cannot create this file, you will find an example file for lateral entry
statistics.txt are provided, which you should work with in this case.
Requirements
• Apart from the struct, do not use any global variables.
• Adding your own functions is allowed and can be very helpful.
• The code should be structured and clear. Adhere to the standards you learned in the course.
• In places where errors can be expected, you should deal with them appropriately in your program.
C:
Task 1 (1 point)
Create a .c file and define a global constant TEXT_LENGTH with the value 776. You will need this
later for the rules of the game. In addition, the following libraries are needed which must be
integrated:

Also add the following sub-function to clear the input buffer.
void p u f f e r l e e r e n ( )
{
char nummer ;
do
{
nummer= getcha r ( ) ;
}
while ( nummer!= 1 0 ) ;
}
Task 2 (2 points)
Create a struct with the name account and the following variables as content:
• A string name. The name of the player is recorded in it, e.g. "Michael"
• An integer won_games. This records the number of games won by a user.
• An integer lost_games. This records the number of games a user has lost.
• An integer level. The level of the user is recorded in it.
Now create a field of size 10 of this struct as a global variable.
Task 3 (5 points)
Now write a sub-function
void read_instructions (char instructions [TEXT_LENGTH]).
This receives a string into which the text is to be read from the file. Now open in the sub-function
the file Instructions.txt and read the content in the string. Make sure that the program behaves
reliably in the event of an error.
Task 4 (3 points)
Now write a sub-function
int menu (int * accounts_amount, char instructions [TEXT_LENGTH], char game_table [9]).
The sub function must contain the pointer to the current number of accounts, the string which
contains the instructions and the character field of the playing field. In the sub-function you now
write a menu with nine points, in which you break down(分类,分段落) the functionality of the
program:
1. Show instructions: Output of the rules of the game read from the file.
2. Show accounts: All existing user accounts are displayed in a table.
3. Create account: A new account will be created.
4. Delete account: A desired account is deleted.
5. 1 Player (easy): A game against the computer is started (game mode: easy).
6. 1 Player (hard): A game against the computer is started (game mode: hard).
7. The statistics are carried out.
8. The program is closed and the accounts are saved.
Make sure that the program returns to the menu after each point and that any nonsensical entries are
intercepted.
Over time you will fill the individual menu items with your function calls.
Task 5 (1 point)
Now write a sub-function
void print_instructions (char instructions [TEXT_LENGTH])
The sub function takes a string contrary, which contains the rules of the game. Now output the rules
of the game on the console. Additionally you should still output the structure of the playing field
once. Use the following line of code for this:
p r i n t f ( " 0 | 1 | 2 \ n− − −\ n3 | 4 | 5 \ n− − −\ n6 | 7 | 8 \ n " ) ;
Task 6 (2 points)
Now write a sub-function
void create_account (int * accounts_amount)
This receives the pointer to the current number of accounts. Here the user should
enter his name. All other variables should be initialized with 0.
Task 7 (1 point)
Now write a sub-function
void print_accounts (int accounts_amount)
This receives the pointer to the current number of accounts. Now output all information of the
existing accounts in tabular form. The following should be present: Number, Name, Wins, Losses
and Level. When outputting, make sure that Number starts with 1 and not with 0.
Task 8 (3 points)
Now write a sub-function
void delete_account (int * accounts_amount)
This receives the pointer to the current number of accounts. Here the user should be asked which
account should be deleted. This should then be deleted.
Make sure that there are no gaps. In addition, any nonsensical inputs should be intercepted again.
Task 9 (7 points)
So that the account data is not lost after the program has ended, it should be saved at the end and
read in at the beginning of the program.
Use a binary file for this.
Write down two sub-functions read_accounts (int * accounts_amount) and save_accounts (int *
accounts_amount).
Both sub-functions receive the pointer to the current number of accounts. Make sure that the
program behaves reliably in the event of an error.
Note: It is better not only to save your struct in the binary file, but also the number of accounts
currently available. So you can also at the restart read in the number of accounts and then you know
exactly how many entries you have to read.
Task 10 (1 point)
Now create a function void show_game_table (char game_table [9]).
This receives the entries from the gaming table as a char-field and outputs them as a clear tic-tac-toe
field with dividing lines in the console.
Task 11 (1 point)
Now create a function void clear_table (char game_table [9]).
This receives the entries from the gaming table as a char-field and sets all entries from the last game
back to an empty space as an entry.
Task 12 (5 points)
Now create a function char check_win (char game_table [9]).
This receives the entries from the gaming table as a char-field and checks whether a winner can
already be determined with the previous entries or not. The function returns the winner's game
symbol (’x’ or ’o’). If neither player has won, a space is returned.
Task 13 (1 point)
Now create a function int random_v (long int * start_value).
This is given a start value as a pointer, which is initialized with the help of the time.h library. It
generated as return value a random value between 0 and 8, representing the 9 possible tic-tac-toe
fields.
Task14 (5 points)
There are several places in the program where a player or a bot should make a move.
Therefore encapsulate the moves in functions and always use them when a move is to be made.
• void player_move (char game_table [9], char sign)
This function includes reading in the desired position and intercepting faulty ones
Entering and writing the final, legal position on the board. To hand over
become the game board (game_table) and the player's sign, x or o (sign).
• void bot_move (char game_table [9], char sign, int hard, long int * start_value)
This function includes selecting the next legal position and writing it on the board. The game board
(game_table), the symbol of the bot, is handed over
(sign), an int (hard), which is either 1, if the bot is set to 'hard', or 0 if it is set to 'easy', as well as the
start value for the random function (start_value).
How exactly this move selection takes place in the two modes is explained in the following
exercises and therefore only gives points in the later exercises.
Task 15 (15 points)
Now create a function
void play_easy (int * accounts_amount, char game_table [9])
In this function, a game against a bot playing with the difficulty level ’easy’ is to be simulated in
single player mode. At the beginning of the function, all existing player accounts should be
displayed.
Then the single player can choose a player account which he would like to use to play the tic-tac-toe
game.
During the course of the game, the player (with the function player_move) and the bot (with the
function bot_move) take turns. For an overview of the playing field, this should be given once at the
beginning and then once after each move.
This output is not intended to be included in player_move or bot_move
After each move, the char check_win (char game_table [9]) function should be used to check
whether a winner has already been determined. If so, the game should be ended and the information
about who won the game should be displayed on the screen. In addition, the information whether
the single player has won or lost, are stored in their account. Finally the playing field should be reset
to an empty playing field with the help of the function:
void clear_table (char game_table [9]) can be reset to an empty playing field.
Note 1: The function int random_v (long int * start_value) only returns one playing field position. It
neither checks whether this position is still free nor does the function set the associated one
Game symbol ('x' or 'o') in the field.
Note 2: Make sure that all nonsensical entries and invalid entries on the field are intercepted.
Task 16 (16 points)
Now create a function
int policy (char game_table [9], char sign)
The function should use the transferring playing field and the transferring character (’x’ or ’o’) to
recognize whether another move can result in a winning situation on the playing field or not.
If a victory is possible by another move, the function returns the field position of the playing field
where the symbol leading to victory is to be placed as a return value. Can't handle a win situation
The function returns a negative value.
Task 17 (5 points)
Now create a function
void play_hard (int * accounts_amount, char game_table [9])
In this function, a game against a computer playing with the difficulty level ’hard’ is to be simulated
in single player mode. The function is identical to play_easy except for the transfer of the ’hard’
parameter to the bot_move function.
In contrast to the ’easy’ mode of the bot, this function checks in the ’hard’ mode with the help of the
int policy function whether your own victory is possible. If this is the case, the bot chooses this
move and the game is over. If the bot cannot win, it then checks whether the single player can win,
if yes, it prevents it. If neither a victory for the bot nor a victory for the single player is possible, the
bot randomly places its game symbol in a free space as before in the ’easy’ mode. This logic should
be completely encapsulated in the bot_move function.
Task18 (11 points)
With the functions have been written so far, you can play in single player mode ’easy’ and ’hard’, as
well as in two-player mode. A practical question now,
however, is: In which starting value give the best ways to win?
For this purpose, a sub-function void statistics (char game_table [9]) should be written, which
determines for each starting field firs_turn through 100 attempts whether a win was made with this
starting field.
Two computers should play against each other in the ’hard’ player mode. A victory is represented
with the value 1, a defeat with the value 0. The value pairs firs_turn and the
The result of the game should be for
first_turn = 0, 1, 2, ..., 8
can be output to a results file statistics.txt.
Please only write the numbers in the file, no text. Otherwise there will be problems with the
graphical representation of the values in Matlab.
Note 1: Create a field with 2 columns and 900 lines, whereby the value of the start field is always
saved in the first column and the result (0 or 1) is saved in the second column.
Note 2: If you always get the same results, you have probably done something wrong with the
transfer of the starting value.
Additional task (3 points)
As you have probably already noticed, our struct contains a variable called level, which has not
really been used up to this point. So now write a sub-function that classifies a level according to a
scheme and checks after each completed game whether a player has moved up or down a level.
There should be a total of 10 levels.
The ascent of a level should become more difficult as the level increases. This means that if moving
up from level 1 to level 2 requires 2 wins, for example, moving up from level 2 to 3 should
require at least 3 wins.
Matlab:
Task 19 (10 points)
Dependency: Task 18 or lateral entry with specifications
Read the text file you created in Exercise 18 into Matlab.
Make sure that you read the file in such a way that you can continue working with its content
accordingly.
Now plot the profit distribution as a bar chart in a plot window. Add a heading and axis names to
this. In addition, the x-axis of the plot should contain the numbers from 0-8, i.e. the starting field, as
distances and labels.
In addition, it should be determined which starting field is the best and this should be marked in the
plot.