German Chapter 4 done

README.md

@@ -92,9 +92,13 @@ Special Thanks
 
 Here is an inevitably incomplete list of MUCH-APPRECIATED CONTRIBUTORS -- people who have submitted patches, reported bugs, added translations, helped answer newbie questions, and generally made Invent Your Own Computer Games with Python that much better:
 
+**Dutch Translation:**
+
+- Marjo Hanh
+
 **Simplified Chinese Translation:**
 
-- Bitex Kuang https://github.com/7bitex
+- Beta Kuang https://github.com/beta
 
 **French Translation:**
 

src/AISim3.py

@@ -248,7 +248,7 @@ def getRandomMove(board, tile):
 
 
 def isOnSide(x, y):
-    return x == 0 or x == 7 or y == 0 or y ==7
+    return x == 0 or x == 7 or y == 0 or y == 7
 
 
 def getCornerSideBestMove(board, tile):

text/chapter10.txt

@@ -685,7 +685,7 @@ True or <<<anything>>> always evaluates to True
 
 So Python stops checking the rest of the expression and doesn’t even bother evaluating the not isSpaceFree(board, int(move)) part. This means the int() and the isSpaceFree() functions are never called as long as move not in '1 2 3 4 5 6 7 8 9'.split() is True.
 
-This works out well for the program, because if the right side is True then move isn’t a string in number form. That would cause int() to give us an error. The only times move not in '1 2 3 4 5 6 7 8 9'.split() evaluates to False are when move isn’t a single-digit string. In that case, the call to int() would not give us an error.
+This works out well for the program, because if the left side is True then move isn’t a string in number form. That would cause int() to give us an error. The only times move not in '1 2 3 4 5 6 7 8 9'.split() evaluates to False are when move isn’t a single-digit string. In that case, the call to int() would not give us an error.
 
 An Example of Short-Circuit Evaluation
 

text/chapter14.txt

@@ -242,7 +242,7 @@ The getMode() function will let the user type in if they want encryption or decr
 
 This list is ['encrypt', 'e', 'decrypt', 'd'], but it is easier for the programmer to type 'encrypt e decrypt d'.split() and not type in all those quotes and commas. Use whichever is easiest for you; they both evaluate to the same list value.
 
-This function will return the first character in mode as long as mode is equal to 'encrypt', 'e', 'decrypt', or 'd'. Therefore, getMode() will return the string 'e' or the string 'd' (but the user can type in either “e”, “encrypt”, “d”, or “decrypt”.)
+This function will return the string in mode as long as mode is equal to 'encrypt', 'e', 'decrypt', or 'd'. Therefore, getMode() will return the string 'e' or the string 'd' (but the user can type in either “e”, “encrypt”, “d”, or “decrypt”.)
 
 Getting the Message from the Player
 
@@ -368,7 +368,7 @@ In decrypting mode, then key would be negative. The special case would be where
 
 Line 47 concatenates the encrypted/decrypted character to the translated string.
 
-If the symbol was not an uppercase or lowercase letter, then line 48 concatenates the original symbol to the translated string. Therefore, spaces, numbers, punctuation marks, and other characters won’t be encrypted or decrypted.
+If the symbol was not an uppercase or lowercase letter, then line 49 concatenates the original symbol to the translated string. Therefore, spaces, numbers, punctuation marks, and other characters won’t be encrypted or decrypted.
 
 50.     return translated
 
@@ -430,7 +430,7 @@ This code will let the user select “brute force” as a mode. Modify and add t
 
 These changes ask the user for a key if they are not in “brute force” mode. The original getTranslatedMessage() call is made and the translated string is printed.
 
-However, if the user is in “brute force” mode then getTranslatedMessage() loop that iterates from 1 all the way up to MAX_KEY_SIZE (which is 26). Remember that when the range() function returns a list of integers up to, but not including, the second parameter, which is why you have + 1. This program will print every possible translation of the message (including the key number used in the translation). Here is a sample run of this modified program:
+However, if the user is in “brute force” mode then getTranslatedMessage() is executed in a loop that iterates from 1 all the way up to MAX_KEY_SIZE (which is 26). Remember that the range() function returns a list of integers up to, but not including, the second parameter, which is why you have + 1. This program will print every possible translation of the message (including the key number used in the translation). Here is a sample run of this modified program:
 
 Do you wish to encrypt or decrypt or brute force a message?
 brute

text/chapter15.txt

@@ -512,8 +512,8 @@ This character can either be a ' ' space character (to represent a blank space),
 Importing Other Modules
 
   1. # Reversi
-  2. import random
-  3. import sys
+  3. import random
+  4. import sys
 
 Line 2 imports the random module for its randint() and choice() functions. Line 3 imports the sys module for its exit() function.
 
@@ -643,12 +643,12 @@ Checking if a Move is Valid
  47.     # If it is a valid move, returns a list of spaces that would become the player's if they made a move here.
  48.     if board[xstart][ystart] != ' ' or not isOnBoard(xstart, ystart):
  49.         return False
- 50.     board[xstart][ystart] = tile # temporarily set the tile on the board.
- 51.     if tile == 'X':
- 52.         otherTile = 'O'
- 53.     else:
- 54.         otherTile = 'X'
- 55.     tilesToFlip = []
+ 51.     board[xstart][ystart] = tile # temporarily set the tile on the board.
+ 53.     if tile == 'X':
+ 54.         otherTile = 'O'
+ 55.     else:
+ 56.         otherTile = 'X'
+ 58.     tilesToFlip = []
 
 Given a board data structure, the player’s tile, and the XY coordinates for player’s move, isValidMove() should return True if the Reversi game rules allow a move to those coordinates and False if they don’t.
 
@@ -956,7 +956,7 @@ Getting the Computer’s Move
 216.     # move and return that move as a [x, y] list.
 217.     possibleMoves = getValidMoves(board, computerTile)
 
-getComputerMove() and is where the AI algorithm is implemented. Normally you use the results from getValidMoves() for hints mode. Hints mode will print '.' period characters on the board to show the player all the potential moves they can make.
+getComputerMove() is where the AI algorithm is implemented. Normally you use the results from getValidMoves() for hints mode. Hints mode will print '.' period characters on the board to show the player all the potential moves they can make.
 
 But if getValidMoves() is called with the computer AI’s tile (in computerTile), it will also find all the possible moves that the computer can make. The AI will select the best move from this list.
 
@@ -991,15 +991,15 @@ Get a List of the Best Scoring Moves
 
 If there are no corner moves, loop through the entire list and find out which move results in the highest score. Line 229’s for loop will set x and y to every move in possibleMoves. bestMove is set to the highest scoring move the code has found so far, and bestScore is set to the best move’s score.
 
-When the code in the loop finds a move that scores higher than bestScore, line 233 to 235 will store that move and score as the new values in bestMove and bestScore.
+When the code in the loop finds a move that scores higher than bestScore, lines 233 to 235 will store that move and score as the new values in bestMove and bestScore.
 
 Simulate All Possible Moves on Duplicate Board Data Structures
 
 Before simulating a move, line 230 makes a duplicate game board data structure by calling getBoardCopy(). You’ll want a copy so you can modify without changing the real game board data structure stored in the board variable.
 
 Then line 231 calls makeMove(), passing the duplicate board (stored in dupeBoard) instead of the real board. This will simulate what would happen on the real board if this move was made. makeMove() will handle placing the computer’s tile and the flipping the player’s tiles on the duplicate board.
 
-Line 232 calls getScoreOfBoard()with the duplicate board, which returns a dictionary where the keys are 'X' and 'O', and the values are the scores.
+Line 232 calls getScoreOfBoard() with the duplicate board, which returns a dictionary where the keys are 'X' and 'O', and the values are the scores.
 
 For example, pretend that getScoreOfBoard() returns the dictionary {'X':22, 'O':8} and computerTile is 'X'. Then getScoreOfBoard(dupeBoard)[computerTile] would evaluate to {'X':22, 'O':8}['X'], which would then evaluate to 22. If 22 is larger than bestScore, bestScore is set to 22 and bestMove is set to the current x and y values.
 
@@ -1078,7 +1078,7 @@ Handling the Quit or Hints Commands
 273.             else:
 274.                 makeMove(mainBoard, playerTile, move[0], move[1])
 
-If the player typed in the string 'quit' for their move, then getPlayerMove() would have returned the string 'quit'. In that case, line 269 calls the sys.exit() to terminate the program.
+If the player typed in the string 'quit' for their move, then getPlayerMove() would have returned the string 'quit'. In that case, line 269 calls sys.exit() to terminate the program.
 
 If the player typed in the string 'hints' for their move, then getPlayerMove() would have returned the string 'hints'. In that case, you want to turn hints mode on (if it was off) or off (if it was on).
 
@@ -1122,7 +1122,7 @@ Finally, pass x and y, along with the game board data structure and the computer
 
 Lines 289 to 292 are similar to lines 276 to 279. After the computer has made its move, line 289 checks if there exist any valid moves the human player can make. If getValidMoves() returns an empty list, then there are no valid moves. That means the game is over, and line 290 breaks out of the while loop.
 
-Otherwise, there’s at least one possible move the player should make. The turn variable is to 'player'. There is no more code in the while-block after line 292, so execution loops back to the while statement on line 257.
+Otherwise, there’s at least one possible move the player should make. The turn variable is set to 'player'. There is no more code in the while-block after line 292, so execution loops back to the while statement on line 257.
 
 Drawing Everything on the Screen
 

text/chapter16.txt

@@ -12,7 +12,7 @@ Topics Covered In This Chapter:
 
 The Reversi AI algorithm was simple, but it beats me almost every time I play it. This is because the computer can process instructions fast, so checking each possible position on the board and selecting the highest scoring move is easy for the computer. It would take a long time for me to find the best move this way.
 
-The Reversi program in Chapter 14 had two functions, getPlayerMove() and getComputerMove() which both returned the move selected as a two-item list like [x, y]. The both also had the same parameters, the game board data structure and which tile they were. getPlayerMove() decided which [x, y] move to return by letting the player type in the coordinates. getComputerMove() decided which [x, y] move to return by running the Reversi AI algorithm.
+The Reversi program in Chapter 14 had two functions, getPlayerMove() and getComputerMove() which both returned the move selected as a two-item list like [x, y]. They both also had the same parameters, the game board data structure and which tile they were. getPlayerMove() decided which [x, y] move to return by letting the player type in the coordinates. getComputerMove() decided which [x, y] move to return by running the Reversi AI algorithm.
 
 What happens when we replace the call to getPlayerMove() with a call to getComputerMove()? Then the player never types in a move, it is decided for them! The computer is playing against itself!
 
@@ -26,7 +26,7 @@ You can either type these changes in yourself, or download them from the book’
 
 Making the Computer Play Against Itself
 
-Save the old reversi.py file as AISim1.py by clicking on File ► Save As, and then entering AISim1.py for the file name and clicking Ok. This will create a copy of our Reversi source code as a new file that you can make changes to, while leaving the original Reversi game the same (you may want to play it again). Change the following code in AISim1.py:
+Save the old reversi.py file as AISim1.py by clicking on File ► Save As, and then entering AISim1.py for the file name and clicking Save. This will create a copy of our Reversi source code as a new file that you can make changes to, while leaving the original Reversi game the same (you may want to play it again). Change the following code in AISim1.py:
 
 266. move = getPlayerMove(mainBoard, playerTile)
 
@@ -235,7 +235,7 @@ Displaying the Statistics
 294. tiepercent = round(((ties / numGames) * 100), 2)
 295. print('X wins %s games (%s%%), O wins %s games (%s%%), ties for %s games (%s%%) of %s games total.' % (xwins, xpercent, owins, opercent, ties, tiepercent, numGames))
 
-The code at the bottom of the program will show the user how many wins X and O had, how many ties there were, and how what percentages these make up. Statistically, the more games you run, the more accurate your percentages will be for finding the best AI algorithm. If you only ran ten games, and X won three of them, then it would seem that X’s algorithm only wins 30% of the time. However, if you run a hundred, or even a thousand games, then you may find that X’s algorithm wins closer to 50% (that is, half) of the games.
+The code at the bottom of the program will show the user how many wins X and O had, how many ties there were, and what percentages these make up. Statistically, the more games you run, the more accurate your percentages will be for finding the best AI algorithm. If you only ran ten games, and X won three of them, then it would seem that X’s algorithm only wins 30% of the time. However, if you run a hundred, or even a thousand games, then you may find that X’s algorithm wins closer to 50% (that is, half) of the games.
 
 To find the percentages, divide the number of wins or ties by the total number of games. Then multiply the result by 100. However, you may end up with a number like 66.66666666666667. So pass this number to the round() function with the second parameter of 2 to limit the precision to two decimal places, so it will return a float like 66.67 instead (which is much more readable).
 
@@ -274,7 +274,7 @@ AISim3.py
 248.
 249.
 250. def isOnSide(x, y):
-251.     return x == 0 or x == 7 or y == 0 or y ==7
+251.     return x == 0 or x == 7 or y == 0 or y == 7
 252.
 253.
 254. def getCornerSideBestMove(board, tile):
@@ -365,7 +365,7 @@ getCornerWorstMove()    Take a corner space, if available. If not, use the getWo
 
 Comparing the Random Algorithm Against the Regular Algorithm
 
-Now the only thing to do is replace one of the getComputerMove() calls in the main part of the program with one of the new functions. Then you can run several games and see how often one algorithm wins over the other. First, let’s replace O’s algorithm with the one in getComputerMove() with getRandomMove() on line 351:
+Now the only thing to do is replace one of the getComputerMove() calls in the main part of the program with one of the new functions. Then you can run several games and see how often one algorithm wins over the other. First, let’s replace O’s algorithm with the one in getRandomMove() on line 351:
 
 351.            x, y = getRandomMove(mainBoard, 'O')
 
@@ -388,7 +388,7 @@ Wow! X won far more often than O did. That means that the algorithm in getComput
 
 Comparing the Random Algorithm Against Itself
 
-What if we changed O’s algorithm to also use the algorithm in getRandomMove()? Let’s find out by changing O’s function call on line 351 from getComputerMove() to getRandomMove() and running the program again.
+What if we changed X’s algorithm to also use the algorithm in getRandomMove()? Let’s find out by changing X’s function call on line 346 from getComputerMove() to getRandomMove() and running the program again.
 
 Welcome to Reversi!
 Enter number of games to run: 100

text/chapter17.txt

@@ -341,7 +341,7 @@ The pygame.draw.ellipse() function is similar to the pygame.draw.circle() functi
 •   The Surface object to draw the ellipse on.
 •   The color of the ellipse.
 •   A tuple of four integers is passed for the left, top, width, and height of the ellipse.
-•   Optionally, an integer for the width. A width of 0 means that the circle will be filled in.
+•   Optionally, an integer for the width. A width of 0 means that the ellipse will be filled in.
 
 Line 42 draws a red ellipse on the Surface object.
 
@@ -375,7 +375,7 @@ The blit() Method for Surface Objects
 52. # draw the text onto the surface
 53. windowSurface.blit(text, textRect)
 
-The blit() method will draw the contents of one Surface object onto another Surface object. Line 54 will draw the “Hello world!” Surface object in text and draws it to the Surface object stored in the windowSurface variable.
+The blit() method will draw the contents of one Surface object onto another Surface object. Line 53 will draw the “Hello world!” Surface object in text and draws it to the Surface object stored in the windowSurface variable.
 
 The second parameter to blit() specifies where on the windowSurface surface the text surface should be drawn. Pass the Rect object you got from calling text.get_rect() on line 23.
 
@@ -567,7 +567,7 @@ Setting Up Constant Variables for Direction
 
 We will use the keys on the number pad of the keyboard to remind us which belongs to which direction. This is similar to the Tic Tac Toe game. 1 is down and left, 3 is down and right, 7 is up and left, and 9 is up and right. However, it may be hard to remember this, so instead use constant variables instead of these integer values.
 
-You could have used any value you wanted for these directions instead of using a constant variable. For example, you could use the string 'downleft' to represent the down and left diagonal direction. However, if you ever mistype the 'downleft' string (for example, as 'fownleft'), Python would not recognize that you meant to type 'downleft' instead of 'downleft'. This bug would cause your program to behave strangely, but the program would not crash.
+You could have used any value you wanted for these directions instead of using a constant variable. For example, you could use the string 'downleft' to represent the down and left diagonal direction. However, if you ever mistype the 'downleft' string (for example, as 'fownleft'), Python would not recognize that you meant to type 'downleft' instead of 'fownleft'. This bug would cause your program to behave strangely, but the program would not crash.
 
 But if you use constant variables, and accidentally type the variable name FOWNLEFT instead of the name DOWNLEFT, Python would notice that there’s no such variable named FOWNLEFT and crash the program with an error. This would still be a pretty bad bug, but at least you would know about it immediately and could fix it.
 
@@ -650,7 +650,7 @@ The new value to set the left and top attributes to depends on the block’s dir
 
 If the direction of the block is DOWNRIGHT or UPRIGHT, you want to increase the left attribute. If the direction is DOWNLEFT or UPLEFT, you want to decrease the left attribute.
 
-Change the value of these attributes by the integer stored in MOVESPEED. MOVESPEED stores how many pixels over blocks move on each iteration of the game loop, and was set on line19.
+Change the value of these attributes by the integer stored in MOVESPEED. MOVESPEED stores how many pixels over blocks move on each iteration of the game loop, and was set on line 19.
 
 Checking if the Block has Bounced