Code Health Update

Author: DylanSnyder31

Board.py

@@ -1,4 +1,3 @@
-
 from Checking_for_valid_move.rook import rook
 from Checking_for_valid_move.bishop import Bishop
 

Checking_for_valid_move/Queen.py

@@ -1,5 +1,6 @@
 from Data_Conversion.difference_for_letter import dictionar_of_letters_to_numbers
 from Data_Conversion.position_of_pieces import position_dic
+
 def King(position_piece, pos_chess):
     '''
     The rules I used to determine the path of the king:

Checking_for_valid_move/king.py

@@ -1,3 +1,8 @@
+'''
+The purpose of this is so when the user places a piece, it goes into the middle of the square, not in the
+exact location where the user places it.
+'''
+
 class convert_coordinates():
     def to_number():
         convert_coordinates = {'a1': (0,0), 'b1': (102.5,0), 'c1': (205,0), 'd1': (307.5,0), 'e1': (410,0), 'f1': (512.5,0), 'g1': (615,0), 'h1': (717.5,0),
@@ -9,5 +14,5 @@ def to_number():
                                 'a7': (0,600), 'b7': (102.5,600), 'c7': (205,600), 'd7': (307.5,600), 'e7': (410,600), 'f7': (512.5,600), 'g7': (615,600), 'h7': (717.5,600),
                                 'a8': (0,700), 'b8': (102.5,700), 'c8': (205,700), 'd8': (307.5,700), 'e8': (410,700), 'f8': (512.5,700), 'g8': (615,700), 'h8': (717.5,700)
         }
-        
+
         return convert_coordinates

Data_Conversion/chess_coords_to_real_coords.py

@@ -1,6 +1,13 @@
+'''
+This is to convert letters to numbers when calculations occur
+'''
+
 dictionar_of_letters_to_numbers = {
     'a': 1, 'b': 2, 'c': 3, 'd':4, 'e': 5, 'f': 6, 'g':7, 'h': 8
 }
 
-
+'''
+This is to save the corrdinates of where the user pressed, in order
+to promote the pawn to the correct piece
+'''
 promotion_piece = []

Data_Conversion/difference_for_letter.py

@@ -1,3 +1,6 @@
+'''
+This is the position of all the pieces, in a dictionary. This data is essential for the gameplay to work
+'''
 position_dic = { 'a1': "Left White Rook", 'b1': "Left White Knight", 'c1': "Left White Bishop", 'd1': "White Queen", 'e1': "White King", 'f1': "Right White Bishop", 'g1': "Right White Knight", 'h1': "Right White Rook",
                         'a2': "White Pawn1", 'b2': "White Pawn2", 'c2': "White Pawn3", 'd2': "White Pawn4", 'e2': "White Pawn5", 'f2': "White Pawn6", 'g2': "White Pawn7", 'h2': "White Pawn8",
                         'a3': "None", 'b3': "None", 'c3': "None", 'd3': "None", 'e3': "None", 'f3': "None", 'g3': "None", 'h3': "None",
@@ -8,4 +11,8 @@
                         'a8': "Left Black Rook", 'b8': "Left Black Knight", 'c8': "Left Black Bishop", 'd8': "Black Queen", 'e8': "Black King", 'f8': "Right Black Bishop", 'g8': "Right Black Knight", 'h8': "Right Black Rook",
                         'a7': "Black Pawn1", 'b7': "Black Pawn2", 'c7': "Black Pawn3", 'd7': "Black Pawn4", 'e7': "Black Pawn5", 'f7': "Black Pawn6", 'g7': "Black Pawn7", 'h7': "Black Pawn8"
 }
+
+'''
+Decalres what team is allowed to move their pieces
+'''
 teams_turn = "W"

Data_Conversion/position_of_pieces.py

@@ -1 +1 @@
-['d7', 'Whire Queen']
+['e8', 'Whire Queen']

Data_Conversion/saved_input.txt

@@ -16,7 +16,7 @@ def setup():
     Config.set('graphics', 'resizable', '0')
     Config.write()
 
-    #Make the top windows bar go away
+    #Make the top Windows bar go away
     Window.borderless = True
 
     #Disable the Multi-Touch

main.py

@@ -1,75 +1,92 @@
 from Data_Conversion.position_of_pieces import teams_turn
 from Data_Conversion.position_of_pieces import position_dic
+
+#Imports each of the pieces' specific files
 from Checking_for_valid_move.bishop import Bishop
-from Checking_for_valid_move.is_square_occupied import is_square_occupied
 from Checking_for_valid_move.king import King
 from Checking_for_valid_move.knight import knight
 from Checking_for_valid_move.pawn import pawn_movement
 from Checking_for_valid_move.Queen import Queen
 from Checking_for_valid_move.rook import rook
 
 from Checking_for_valid_move.turn_based import move_turn
-from Checking_for_valid_move.king_check import end_game
+from Checking_for_valid_move.is_square_occupied import is_square_occupied
 
 class is_valid_move():
-    #Checks to make sure the move was valid, and not breaking any rules of Chess
+    ''''
+    This function is kinda complicated, and I am sure I could have modularized or organized the code in a more beautiful and readable way, but
+    essentially this code is checking all of the edge (and normal) cases that the pieces could have been moved to. It checks what piece has been moved (pawn, Queen, etc.), and then checks
+    against multiple different factors if that move was valid.
+    '''
 
     def valid(self, chess_position_numerical, position_piece, pos_chess, piece_that_moved):
-        pawn = pawn_movement(chess_position_numerical)
+        #The teams_turn variable needed to be global even though I imported it through the file location
         global teams_turn
-        king_check = end_game(teams_turn)
-
 
+        pawn = pawn_movement(chess_position_numerical)
+        result = ""
         piece_only = ""
+
+        #Gets the name of the piece only, discarding color and left/right
+        #Example: "Left Black Rook" would become "Rook"
         index = len(str(piece_that_moved)) - 1
         while str(piece_that_moved)[index] != " ":
             piece_only += str(str(piece_that_moved)[index])
             index -= 1
 
-        result = ""
-
+        #Continues breking up the ID into the piece
         if str(piece_only)[0] == str(1) or str(piece_only)[0] == str(2) or str(piece_only)[0] == str(3) or str(piece_only)[0] == str(4) or str(piece_only)[0] == str(5) or str(piece_only)[0] == str(6) or str(piece_only)[0] == str(7) or str(piece_only)[0] == str(8):
             piece_only = piece_only[1:]
         piece_only = piece_only[::-1]
 
-
+        #analysis of piece based on what piece it was
         if piece_only == "Rook":
             result = rook( chess_position_numerical, pos_chess)
+
         elif piece_only == "Bishop":
             result = Bishop( chess_position_numerical, pos_chess, piece_that_moved)
+
         elif piece_only == "Queen":
             result = Queen( chess_position_numerical, pos_chess, piece_that_moved)
+
         elif piece_only == "King":
             result = King( chess_position_numerical, pos_chess)
+
         elif piece_only == 'Knight':
             result = knight(chess_position_numerical, pos_chess)
 
         if is_square_occupied(chess_position_numerical, position_piece, pos_chess, piece_that_moved) == "True, Captured":
             '''
             This function gets called when the piece that moved is going to capture a piece
             '''
-
             if result == "":
+                #This means the piece MUST be a pawn
+                #THe pawn is isolated from the other pieces because it has different moving rules based on if it is capturing a piece or not
 
                 if str(position_dic[str(chess_position_numerical)])[0] == 'W':
+                    #Since the piece is white, it checks to see if it has 'landed' onto the top row, Where it can be promoted
                     if str(pos_chess) == "a8" or str(pos_chess) == "b8" or str(pos_chess) == "c8" or str(pos_chess) == "d8" or str(pos_chess) == "e8" or str(pos_chess) == "f8" or str(pos_chess) == "g8" or str(pos_chess) == "h8":
+                        #If so, chnage the team that has active play
+                        teams_turn = "B"
+
+                        #Return that the move was valid
                         return "New_Piece"
                 else:
+                    #Since the piece is black it checks the bottom
                     if str(pos_chess) == "a1" or str(pos_chess) == "b1" or str(pos_chess) == "c1" or str(pos_chess) == "d1" or str(pos_chess) == "e1" or str(pos_chess) == "f1" or str(pos_chess) == "g1" or str(pos_chess) == "h1":
                         if move_turn(piece_that_moved, teams_turn) == "True":
-                            #if king_check.in_check() == "True":
 
-                            if teams_turn == "W":
-                                teams_turn = "B"
-                            else:
-                                teams_turn ="W"
+                            #Changes the active play to White
+                            teams_turn ="W"
+
+                            #Returns that the move was valid
                             return "New_Piece"
 
                 result = pawn.pawn_capture(chess_position_numerical, pos_chess)
 
             if str(result) == "True":
                 if move_turn(piece_that_moved, teams_turn) == "True":
-                    #if king_check.in_check() == "True":
+                    #If the move was valid, change the active play and return that the move was valid
                     if teams_turn == "W":
                         teams_turn = "B"
                     else:
@@ -79,55 +96,59 @@ def valid(self, chess_position_numerical, position_piece, pos_chess, piece_that_
 
         elif is_square_occupied(chess_position_numerical, position_piece, pos_chess, piece_that_moved) == "True":
             if result == "":
-
+                #Same as above, the pawn has to go here
                 if str(position_dic[str(chess_position_numerical)])[0] == 'W':
-
-                    print(str(pos_chess))
+                    #Checks to see if the top row is the end location, since the piece was white
                     if str(pos_chess) == "a8" or str(pos_chess) == "b8" or str(pos_chess) == "c8" or str(pos_chess) == "d8" or str(pos_chess) == "e8" or str(pos_chess) == "f8" or str(pos_chess) == "g8" or str(pos_chess) == "h8":
                         if move_turn(piece_that_moved, teams_turn) == "True":
-                            #if king_check.in_check() == "True":
 
-                            if teams_turn == "W":
-                                teams_turn = "B"
-                            else:
-                                teams_turn ="W"
-                                return "New_Piece"
-                else:
+                            #Changes the play
+                            teams_turn = "B"
 
+                            #Returns that the move was Valid
+                            return "New_Piece"
+                else:
+                    #Since the piece is black, the algorithm checks the bottom row
                     if str(pos_chess) == "a1" or str(pos_chess) == "b1" or str(pos_chess) == "c1" or str(pos_chess) == "d1" or str(pos_chess) == "e1" or str(pos_chess) == "f1" or str(pos_chess) == "g1" or str(pos_chess) == "h1":
                         if move_turn(piece_that_moved, teams_turn) == "True":
-                            #if king_check.in_check() == "True":
 
-                            if teams_turn == "W":
-                                teams_turn = "B"
-                            else:
-                                teams_turn ="W"
+                            #Changes the team that can move
+                            teams_turn ="W"
+
+                            #Returns that the move was valid
                             return "New_piece"
 
                 result = pawn.pawn(chess_position_numerical, pos_chess)
 
 
             if str(result) == "True":
                 if move_turn(piece_that_moved, teams_turn) == "True":
-                    #if king_check.in_check() == "True":
-
+                    #If the move was valid, change the play and return that it was valid
                     if teams_turn == "W":
                         teams_turn = "B"
                     else:
                         teams_turn ="W"
+
                     return "True"
 
             elif str(result) == "Castle":
+                '''
+                An Edge-Case for Castling, Done mostly in it's own file '''
 
                 if move_turn(piece_that_moved, teams_turn) == "True":
+                    #Changes the play and returns that the move was valid
                     if teams_turn == "W":
                         teams_turn = "B"
                     else:
                         teams_turn ="W"
 
                     return "Castle"
+
     def main(self, chess_position_numerical, position_piece, pos_chess, piece_that_moved):
         checking = is_valid_move()
+
         #Calls the above function and returns the result to Board.py
+        #Board.py takes the data and runs some more analysis, and if the move passes that, then the piece will move
+        #on the GUI for the user, and the dictionary will update locations of all the pieces
         status = checking.valid(chess_position_numerical, position_piece, pos_chess, piece_that_moved)
         return status