Followed pep 8

Author: MonliH

.gitignore

@@ -99,3 +99,6 @@ ENV/
 
 # mypy
 .mypy_cache/
+
+# pycharm files
+.idea/

AI_Reversi/AI.py

@@ -11,13 +11,16 @@
 previousGeneration = 1271
 mutationAmount = 0.05
 
+
 # sigmoid function
 def sigmoid(x):
-  return 1 / (1 + math.exp(-x))
+    return 1 / (1 + math.exp(-x))
+
 
 # negative function
 def negative(x):
-  return -x
+    return -x
+
 
 # evaluate the neural network
 def evaluate(board, structure, weights, turn):
@@ -32,6 +35,7 @@ def evaluate(board, structure, weights, turn):
         layer = sigmoidForArray(layer) # apply sigmoid function
     return layer
 
+
 # choose the best move
 def chooseMove(board, sturcture, weights, turn):
     results = evaluate(board, structure, weights, turn) # results of the nerual network
@@ -45,14 +49,16 @@ def chooseMove(board, sturcture, weights, turn):
             bestMove = coordinates
     return bestMove
 
+
 # generate random neural network
 def generateNetwork(structure):    
     weights = []
     for i in range(len(structure) - 1):
         weights.append(np.array([[random.uniform(-1, 1) for _ in range(structure[i] + 1)] for _ in range(structure[i + 1])]))
     return weights
 
- # function for loading neural networks
+
+# function for loading neural networks
 def loadNetworks(structure, previousGeneration):
     with open("gen" + str(previousGeneration), "r") as file:
         lines = file.read().splitlines()
@@ -78,6 +84,7 @@ def loadNetworks(structure, previousGeneration):
 
         return networks      
 
+
 # function for saving neural networks
 def saveNetworks(networks, sortedNetworksTuples, previousGeneration):
     file = open("gen" + str(previousGeneration), "w")

AI_Reversi/reversi.py

@@ -8,12 +8,15 @@
 w = -1 # white tile ID
 b = 1 # black tile ID
 
+
 def playerASCII(): # defining tile ID
     return white if turn == w else black
 
+
 def countChess(board, turn): # count how many pieces are on the board
     return sum(board[i].count(turn) for i in range(n))
 
+
 def printBoard(board): # print the board
     print()
     print("  ", end = "")
@@ -30,6 +33,7 @@ def printBoard(board): # print the board
     print(white + ":" + str(countChess(w)), end = "")
     print()
 
+
 def generateBoard(): # prepare board
     board = [[0 for _ in range(n)] for _ in range(n)] # the board
     board[n // 2 - 1][n // 2 - 1] = w
@@ -38,14 +42,17 @@ def generateBoard(): # prepare board
     board[n // 2 - 1][n // 2] = b
     return board
 
+
 def outOfBound(x, y): # if is out of board/bounds
     return x < 0 or x >= n or y < 0 or y >= n
 
+
 def neighbourIsOpposite(board, x, y, dx, dy, turn): 
     if outOfBound(x + dx, y + dy):
         return False
     return board[x + dx][y + dy] == opposite(turn)
 
+
 def checkSandwich(board, x, y, dx, dy, turn):
     if dx == 0 and dy == 0:
         return False
@@ -58,9 +65,11 @@ def checkSandwich(board, x, y, dx, dy, turn):
     else: # space is unoccupied
         return False
 
+
 def opposite(turn): # change turn
     return w if turn == b else b
 
+
 def isLegal(board, x, y, turn):
     if outOfBound(x, y): # out of bound
         return False
@@ -73,15 +82,18 @@ def isLegal(board, x, y, turn):
                 return True        
     return False
 
+
 def replaceNeighbours(board, x, y, dx, dy, turn):
     if checkSandwich(board, x, y, dx, dy, turn):
         board[x + dx][y + dy] = turn
         replaceNeighbours(board, x + dx, y + dy, dx, dy, turn)
 
+
 def generateValidMovesList(board, turn):
     return [(i,j) for i in range(n) for j in range(n) \
                       if isLegal(board, i, j, turn)]
 
+
 def makeMove(board, x, y, turn):
     board[x][y] = turn
     for i in range(-1, 2):

AI_Reversi/reversi_play.py

@@ -3,31 +3,33 @@
 import random
 import AI
 
-generation = 861 ## Gerneation to play against
-n = 8 # board size 8,6,4,2(needs to be even)
-white = "☺" # white tile ascii
-black = "☻" # black tile ascii
-bg = "•" # bg tile ascii
+generation = 2500  # Generation to play against
+n = 8  # board size 8,6,4,2(needs to be even)
+white = "☺"  # white tile ascii
+black = "☻"  # black tile ascii
+bg = "•"  # bg tile ascii
 
-w = -1 # white tile ID
-b = 1 # black tile ID
+w = -1  # white tile ID
+b = 1  # black tile ID
 
-board = [[0 for _ in range(n)] for _ in range(n)] # the board
+board = [[0 for _ in range(n)] for _ in range(n)]  # the board
 
 
-def playerASCII(): # defining tile ID
+def playerASCII():  # defining tile ID
     return white if turn == w else black
 
-def countChess(turn): # count how many pieces are on the board
+
+def countChess(turn):  # count how many pieces are on the board
     return sum(board[i].count(turn) for i in range(n))
 
-def printBoard(): # print the board
+
+def printBoard():  # print the board
     print()
     print("  ", end = "")
     for i in range(n):
         print(i, end = " ")
     print()
-    for i in range(n): # making a 2-D array
+    for i in range(n):  # making a 2-D array
         print(i, end = " ")
         for j in range(n):
             print(white if board[j][i] == w else \
@@ -37,51 +39,56 @@ def printBoard(): # print the board
     print(white + ":" + str(countChess(w)), end = "")
     print()
 
-def initBoard(): # prepare board
+
+def initBoard():  # prepare board
     board[n // 2 - 1][n // 2 - 1] = w
     board[n // 2][n // 2] = w
     board[n // 2][n // 2 - 1] = b
     board[n // 2 - 1][n // 2] = b
 
-	## custom board for testing
-	#global board
-    #board = [[b,b,b,b,b,b,b,b],
-    #         [b,b,b,b,b,b,b,b],
-    #         [b,b,b,w,b,b,b,b],
-    #         [b,w,b,b,b,w,b,b],
-    #         [b,b,b,b,w,b,b,b],
-    #         [b,b,b,0,w,b,b,b],
-    #         [b,b,0,0,w,w,0,0],
-    #         [b,0,0,0,w,w,w,0]]
-
-def outOfBound(x, y): # if is out of board/bounds
+# custom board for testing
+#global board
+#board = [[b,b,b,b,b,b,b,b],
+#         [b,b,b,b,b,b,b,b],
+#         [b,b,b,w,b,b,b,b],
+#         [b,w,b,b,b,w,b,b],
+#         [b,b,b,b,w,b,b,b],
+#         [b,b,b,0,w,b,b,b],
+#         [b,b,0,0,w,w,0,0],
+#         [b,0,0,0,w,w,w,0]]
+
+
+def outOfBound(x, y):  # if is out of board/bounds
     return x < 0 or x >= n or y < 0 or y >= n
 
+
 def neighbourIsOpposite(x, y, dx, dy): 
     if outOfBound(x + dx, y + dy):
         return False
     return board[x + dx][y + dy] == opposite(turn)
 
+
 def checkSandwich(x, y, dx, dy, turn):
     if dx == 0 and dy == 0:
         return False
-    if outOfBound(x + dx, y + dy): # out of bound
+    if outOfBound(x + dx, y + dy):  # out of bound
         return False
-    if board[x + dx][y + dy] == turn: # sandwiched
+    if board[x + dx][y + dy] == turn:  # sandwiched
         return True
     elif board[x + dx][y + dy] == opposite(turn):
         return checkSandwich(x + dx, y + dy, dx, dy, turn)
     else: # space is unoccupied
         return False
 
-def opposite(turn): # change turn
+
+def opposite(turn):  # change turn
     return w if turn == b else b
 
 
 def isLegal(x, y, turn):
-    if outOfBound(x, y): # out of bound
+    if outOfBound(x, y):  # out of bound
         return False
-    if board[x][y] != 0: # space is occupied
+    if board[x][y] != 0:  # space is occupied
         return False
     for i in range(-1, 2):
         for j in range(-1, 2):
@@ -90,20 +97,23 @@ def isLegal(x, y, turn):
                 return True        
     return False
 
+
 def replaceNeighbours(x, y, dx, dy, turn):
     if checkSandwich(x, y, dx, dy, turn):
         board[x + dx][y + dy] = turn
         replaceNeighbours(x + dx, y + dy, dx, dy, turn)
 
+
 def generateValidMovesList():
     return [(i,j) for i in range(n) for j in range(n) \
                       if isLegal(i, j, turn)]
 
+
 initBoard()
 
-turn = b # turn indicator b or w(Black Or White), black goes first
-whiteCanPlay = True # if white is not stuck
-blackCanPlay = True # if black is not stuck
+turn = b  # turn indicator b or w(Black Or White), black goes first
+whiteCanPlay = True  # if white is not stuck
+blackCanPlay = True  # if black is not stuck
 
 # legal check
 playerTile = input("Choose your chess color.  Type 'b' for black and white otherwise.  Black goes first: ")
@@ -147,7 +157,7 @@ def generateValidMovesList():
                     print("Invalid Format.  ", end = "")
         else:
             # computer's turn
-            #x, y = random.choice(validMoves)
+            # x, y = random.choice(validMoves)
             x, y = AI.chooseMove(board, AI.structure, bestNetwork, turn)
             print(playerASCII() + " Computer's move:", x, y)