C代写：COMP2129-Minesweeper

Task description

In this request you will develop a variation of the Minesweeper game in the C programming language. We recommend that you play the game to gain an overall understanding of how it works.

In each game, mines are hidden in a two dimensional mine field and the object of the game is to uncover the empty cells and flag the cells containing mines. To simplify your implementation, regions without mines should not be automatically expanded and players are not allowed to unflag cells once they have been flagged. Each game will contain a total of 10 mines, regardless of the grid size.

You are encouraged to ask questions on Ed using the requests category. As with any request,
make sure that your work is your own, and you do not share your code or solutions with other students.

Working on your request

You can work on this request on your own computer or the lab machines. It is important that you continually back up your request files onto your own machine, external drives, and in the cloud.

You are encouraged to submit your request on Ed while you are in the process of completing it. By submitting you will obtain some feedback of your progress on the sample test cases provided.

Implementation details

Your program must be contained in one file called minesweeper.c and produce no errors when compiled using clang on the lab machines and Ed. Your program will be run from the command line using ./minesweeper and read input from standard input and write output to standard output.

Important – your program will be marked automatically, so make sure that you follow the request specifications carefully. Your program output must match the exact output shown in the examples.

Program input

The program input consists of two sections. The first section defines the mine field and the second section describes the moves of the player. Each line of the input is one instruction. You are also required to check for whether any invalid input is encountered.

1. The first line of the input will be of the form g [width] [height] where width and height are integers in the range [1, 100]. This defines the size of the grid to width cells wide and height cells high. The grid must have at least 10 cells, so this instruction is only valid if width x height > 10
2. The next 10 lines will be of the form b [x] [y] where x and y are integers in the range [0, width) and [0, height) respectively. 3. This places a mine at cell (x, y) in the grid.
   1. The next lines will describe the moves of the player – either u [x] [y] or f [x] [y].
   2. A u instruction means that the player uncovers the cell (x, y)
   3. A f instruction means that the player flags the cell (x, y)

There must be exactly one player instruction for each grid cell. That is, if the grid is of size width x height then there should be exactly width x height u and f instructions in total.

No two instructions should refer to the same grid cell, and no more than 10 flags can be placed.

The input should be processed one line at a time. After reading a line of input your program should immediately act on the line of input as described before proceeding to the next line of input.

Sample input

In the following test case we construct a 4 x 4 mine field and then play the game.

The player successfully flags all of the mines and uncovers the remaining cells in this game.

g 4 4
b 0 0
b 1 0
b 3 0
b 1 1
b 1 2
b 0 2
b 3 2
b 0 3
b 1 3
b 3 3
u 2 3
u 2 0
f 0 3
u 2 1
f 3 0
f 0 2
u 0 1
f 3 2
f 3 3
f 0 0
f 1 1
f 1 0
f 1 2
u 3 1
u 2 2
f 1 3

Program output

1. After reading a g [width] [height] instruction, output the instruction that was inputted.
2. After reading a b [x] [y] instruction, output the instruction that was inputted. In addition, after reading the tenth b [x] [y] line, the state of the grid should be displayed.
3. After reading a correct player instruction, output the same instruction.
   1. If the player uncovers a bomb, output the message lost and immediately exit.
   2. If every mine has been flagged and every other empty cell has been uncovered, then display the final state of the grid, output the message won and then exit.
4. Otherwise, the state of the grid after the instruction should be outputted.
5. If an invalid, out of place, or otherwise incorrect instruction is read at any time, error should be outputted and your program should exit immediately. Make sure that you do not output the instruction or the grid following an erroneous instruction.

Displaying the grid

The grid is represented using 1 character per cell, with a 1 character border. A 4 x 4 grid looks like:

+----+
|****|
|****|
|****|
|****|
+----+

• The border consists of - or | characters, with a + character in each corner.
• The * character represents a covered cell.
• The f character represents a flagged cell.
• An uncovered cell is represented by a number that corresponds to the total number of bombs in the 8 adjacent cells that surround the uncovered cell.

The top left corner of the grid should have coordinates (0, 0) and the bottom right corner of the grid should have coordinates ([width] - 1, [height] - 1). The first coordinate is the x coordinate, and the second is the y coordinate. A 4 x 4 grid where the player has flagged (3, 1) and uncovered (0, 2) with 2 mines in the adjacent cells would look like:

+----+
|****|
|***f|
|2***|
|****|
+----+

Writing your own testcases

We have provided you with some sample testcases but these do not test all the functionality described in the request. It is important that you thoroughly test your code by writing your own testcases.

You should place all of your test cases in a tests/ directory. Ensure that each test case has the .in input file along with a corresponding .out output file. We recommend that the names of your test cases are descriptive so that you know what each is testing, for example: too-many-mines.in