Shulou(Shulou.com)06/02 Report--

I'm not an expert in programming teaching, but when I want to master something better, I try to find ways to enjoy it. For example, when I wanted to go a step further in shell programming, I decided to write a minesweeper game in Bash to practice.

I'm not an expert in programming teaching, but when I want to master something better, I try to find ways to enjoy it. For example, when I wanted to go a step further in shell programming, I decided to write a minesweeper game in Bash to practice.

If you are an experienced Bash programmer and want to improve your skills and enjoy it at the same time, please follow me to write a minesweeping game that runs on the terminal. The complete code can be found in this GitHub repository.

Get ready.

Before I write any code, I list a few parts that are necessary for the game:

Show minefield

Create game logic

Create logic to determine whether a cell is optional

Record the number of available and identified (demined) cells

Create game end logic

Show minefield

In minesweeping, the game interface is an opaque square made up of 2D arrays (columns and rows). There may be mines in every grid. The player's task is to find those squares that do not contain mines, and in the process, do not point mines. This Bash version of minesweeper uses 10x10's matrix, and the actual logic is done by a simple Bash array.

First of all, my husband has become some random numbers. This will be the location of the mine in the minefield. It's easier to control the number of mines before you start writing code. The logic to do this could be better, but I did it to keep the game implementation simple and have room for improvement. I wrote this game for fun, but I'd be happy to make it better. )

The following variables are constant throughout the process, and they are declared to randomly generate numbers. Like the following a-g variables, they are used to calculate the value of mines that can be removed:

# variable score=0 # will be used to store game scores # the following variables The actual value a = "1 10-10-1" b = "- 101" c = "01" d = "- 101-2-3" e = "1 2 20 21 100-10-20-20-23-2-1" f = "1 23 35 30 20 22 100-10-20-25-35-3-1" g = "1 46 9 10 15 20 25 30-30-24 11-10-9-8-7" g # # declare declare-a room # declare a room array It is used to represent each grid of a minefield.

Next, I will show the game interface with columns (0-9) and rows (aMuj), and use an 10x10 matrix as a minefield. (M [10] [10] is an array of 100 values with an index from 0 to 99. To learn more about Bash arrays, read what you don't know about Bash in this book: an introduction to Bash arrays.

To create a function called plough, let's first display the title: two blank lines, column headers, and a line-to indicate that there is a game interface:

Printf'\ n\ n'printf'% s'"a b c d e f g h i j" printf'\ n% s\ n'"-"

Then, I initialize a counter variable called r, which is used to record how many rows have been displayed. Note that later in the game code, we will use the same variable r as our array index. In the Bash for loop, increase from 0 to 9 with the seq command. I use the number (d%) to display the line number ($row, defined by seq):

Rang 0 # counter for row in $(seq 0 9); doprintf'd'"$row" # shows the number of lines 0-9

Before we move on, let's see what we've done so far. We first display [akoj] horizontally, and then display the line number of [0-9]. We will use these two ranges to determine the exact location of the user's demining.

Then, in each row, insert the column, so it's time to write a new for loop. This loop manages each column, that is, it actually generates every grid in the game interface. I have added some helper functions, and you can see its full implementation in the source code. For each grid, we need something to make it look like a landmine, so let's initialize the space with a dot (.). To implement this idea, we use a custom function called is_null_field. At the same time, we need an array that stores the specific values of each grid, using the previously defined global array room and using the variable r as the index. As r increases, traverse all cells and randomly deploy mines.

For col in $(seq 0 9) If there is a function here that checks whether the cell is empty and true, then the initial value of the cell is point (.) printf'% s\ e [33m% s\ e [0m'"|" ${room [$r]} "# finally shows the delimiter. Note that the first value of ${room [$r]} is'.', which is equal to its initial value. # end col cycle done

Finally, to keep the game interface neat and good-looking, I end each line with a vertical bar and end the line loop at the end:

Printf'% s\ n' "|" # shows the line separator printf'% s\ n' "-" # ends the line loop doneprintf'\ n\ n'

The complete plough code is as follows:

Plough () {rang 0 printf'\ n\ n 'printf'% s'"a b c d e f gh i j" printf'\ n% s\ n'"-" for row in $(seq 0 9) Do printf'd'"$row" for col in $(seq 0 9) Do ((renders 1)) is_null_field $r printf'% s\ e [33m% s\ e [0m'"|" ${room [$r]} "done printf'% s\ n'" | "printf'% s\ n'"-- "done printf'\ n\ n'}

I spent some time thinking about what the specific function of is_null_field is. Let's see what it can do. In the beginning, we need the game to have a fixed state. You can choose any initial value, which can be a number or any character. I finally decided that the initial value of all cells would be a point (.), because I thought it would make the game interface better. Here is the complete code for this function:

Is_null_field () {local eigenvariables 1 # We have used the loop variable'r' in the array room, this time we use 'e'if [[- z "${room [$e]}]]; thenroom [$r] =". "# here initialize each cell fi} with a dot (.)

Now that I have initialized all the cells, I can now use a very simple function to figure out how many cells are available in the current game:

Get_free_fields () {free_fields=0 # initializes the variable for n in $(seq 1 ${# room [@]}); doif [["${room [$n]}" = ".]]; then # checks whether the current cell is equal to the initial value (.), and the result is true. ((free_fields+=1)) fi done}

This is the game interface shown, with [amurj] as the column and [0-9] as the row.

Minefield

Create player logic

The logic behind the player's operation is to first read the data from the stdin as coordinates, and then find out the actual value contained in the corresponding location. Here we use the parameter extension of Bash to try to get the number of rows and rows. Then the letters representing the number of columns are passed to the branch statement to get the corresponding number of columns. To better understand this process, take a look at the value of the variable o in the following code. For example, the player enters c3, and Bash divides it into two characters: C and 3. For simplicity, I skipped the section on how to handle invalid input.

Colm=$ {opt:0:1} # gets the first character, an alphabet ro=$ {opt:1:1} # gets the second character, an integer case $colm ina) obliterate 1 character; # finally, the corresponding number of columns is obtained by letters. B) otropia 2; c) otropia 3; d) otropia 4; e) otropy 5; f) otropia 6; g) otropy 7; h) otropia 8; I) otrop9; j) otrop10; esac

The following code calculates the actual number of the cell selected by the user, and then stores the result in a variable.

A lot of shuf commands are also used here. Shuf is a Linux command specifically used to generate random sequences. The-I option needs to be followed by a number or range that needs to be disturbed, while the-n option specifies that a maximum of several values should be returned for the output. In Bash, you can do mathematical calculations in two parentheses, which we will use many times.

Still using the previous example, the player entered c3. Then it was converted into ro=3 and oasis 3. Then, through the above branch statement code, convert c to the corresponding integer and bring it into the formula to get the value of the final result I.

(ro*10) + o)) # follows the operation rules and calculates the final value is_free_field $I $(shuf-I 0-5-n 1) # to call a custom function and determine that it points to an empty / selectable cell.

Take a closer look at the calculation process to see how the final result I is calculated:

ITunes $((ro*10) + o) iTunes $((3x 10) + 3)) = $((30x 3)) = 33

The final result is 33. As shown in our game interface, the player's input coordinates point to the 33rd cell, which is in line 3 (starting with 0, otherwise it becomes 4 here), column 3.

Create logic to determine whether a cell is optional

In order to find the mine, after converting the coordinates and finding the actual location, the program checks whether the cell is optional. If not, the program displays a warning message and asks the player to re-enter the coordinates.

In this code, whether the cell is optional or not depends on whether the corresponding value in the array is a dot (.). If optional, reset the value of the cell and update the score. Conversely, because its corresponding value is not a point, the variable not_allowed is set. For simplicity, I will leave it to the readers to explore the source code of the warning message in the game.

Is_free_field () {local frank1 local val=$2 not_allowed=0 if [["${room [$f]}" = "."]]; then room [$f] = $val score=$ ((score+val)) else not_allowed=1 fi}

If the input coordinates are valid, and the corresponding location is a landmine, as shown in the following figure. Players enter H7, and some randomly generated values appear in the game interface. After a landmine is found, these values are added to the user's score.

Extracting mines

Remember the variable a-g that we defined at the beginning? I will use them to determine the specific value of randomly generated mines. So, according to the coordinates entered by the player, the program will generate the values of other surrounding cells based on the randomly generated number in (m) (as shown in the image above). All values are then added to the initial input coordinates, and the final result is placed in I (as shown above).

Please note the X in the following code, which is our only game end flag. We add it to the random list. Under the magic of the shuf command, X can appear in any situation, but if you are lucky enough, it may not appear all the time.

Then $(shuf-e a b c d e f g X-n 1) # adds X to the random list, when masking X, game ends if [["$m"! = "X"]]; then # X will be the trigger flag for our explosive mines (game end) for limit in ${! M} Do #! M represents the value of the m variable field=$ (shuf-I 0-5-n 1) # and then get a random number index=$ ((i+limit)) # add up each value in m and index until the end of the list is_free_field $index $field done

I want all the randomly displayed cells in the game interface to be close to the cells chosen by the player.

Extracting mines

Record the number of selected and available cells

This program needs to record which cells are selectable in the game interface. Otherwise, the program will always let the user enter data, even if all the cells have been selected. To do this, I created a variable called free_fields with an initial value of 0. Use a for loop to record the number of selectable cells in the game interface. If the value corresponding to the cell is a dot (.), free_fields is incremented by one.

Get_free_fields () {free_fields=0 for n in $(seq 1 ${# room [@]}); do if [["${room [$n]}" = ".]]; then ((free_fields+=1)) fi done}

Wait, what if free_fields=0? This means that the player has selected all the cells. If you want to better understand this part, take a look at the source code here.

If [[$free_fields-eq 0]]; then # this means that you have selected all the cells printf'\ n\ n\ t% s:% s% d\ n\ n' "You Win", "you scored"$score" exit 0fi

Create game end logic

For the end of the game, we use some clever techniques here to display the results in the middle of the screen. I leave this part to my readers to explore for themselves.

If [["$m" = "X"]]; theng=0 # in order to use it in the parameter extension room [$I] = X # overwrites the original value at this location and assigns it to Xfor j in {42. 49}; do # in the middle of the game interface, out= "gameover" knight ${out:$g:1} # displays the letter room [$j] = ${k ^ ^} ((gloss1)) donefi in each lattice

Finally, we show the two lines that players are most concerned about.

If [["$m" = "X"]]; then printf'\ n\ n\ t% s:% s% d\ n' "GAMEOVER"you scored"$score" printf'\ n\ n\ t% s\ n\ n\ n'"You were just $free_fields mines away." Exit 0fi

This is the end of the article, friends! If you want to know more, check out my GitHub repository, which has the source code for this minesweeper game, and you can find more games written in Bash. I hope this article will arouse your interest in learning Bash and enjoy it.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.