Increased Code Quality - Still Needs some work but mostly there

Author: DylanSnyder31

Board.py

@@ -2,34 +2,34 @@
 from kivy.uix.screenmanager import Screen
 
 from Data_Conversion.position_of_mouse import find_position
-from Data_Conversion.position_of_pieces import teams_turn
 from Data_Conversion.position_of_pieces import position_dic
-
 from Data_Conversion.chess_coords_to_real_coords import convert_coordinates
+
 from valid_move import is_valid_move
 
 class Scatter_Text_widget(Screen):
 
+
     def __init__(self, **kwargs):
         #Initializes the class with variables
         super(Scatter_Text_widget, self).__init__(**kwargs)
 
+        self.position = find_position()
+        self.position_piece = position_dic
     def on_touch_down(self, touch):
         #This function gets called when the mouse is pressed
 
         res = super(Scatter_Text_widget, self).on_touch_down(touch)
         #This makes sure the labels keep their Scatter Property and the mouse input can be obtained
 
         if res:
-            position_piece = position_dic
-            position = find_position()
 
             #Gets the chess coord of where the mouse pressed
-            pos_chess = position.chess_position(touch.pos)
+            pos_chess = self.position.chess_position(touch.pos)
 
             #Saves the input to a text file
             #Probably a bad way to do this, especially for security concerns
-            clicked_input = [pos_chess,position_piece[str(pos_chess)]]
+            clicked_input = [pos_chess,self.position_piece[str(pos_chess)]]
 
             #Writes twrites the input into the file
             with open('Data_Conversion\saved_input.txt', 'w') as f:
@@ -41,12 +41,10 @@ def on_touch_up(self, touch):
         res = super(Scatter_Text_widget, self).on_touch_up(touch)
         #Makes sure Scatter properties and touch input work alligned
         if res:
-            position = find_position()
-            position_piece = position_dic
             conversion = convert_coordinates
 
             #Gets the position of the mouse, and translates it into a chess corrd
-            pos_chess = position.chess_position(touch.pos)
+            pos_chess = self.position.chess_position(touch.pos)
 
             #opens the text file, to get the previous data
             with open('Data_Conversion\saved_input.txt', 'r') as f:
@@ -67,7 +65,7 @@ def on_touch_up(self, touch):
             Checks with another python file to see if the move was valid or not, against all rules of Chess
             '''
             st = is_valid_move()
-            valid_or_not = st.main(chess_position_numerical, position_piece, pos_chess, piece_that_moved)
+            valid_or_not = st.main(chess_position_numerical, self.position_piece, pos_chess, piece_that_moved)
 
             #IF THE MOVE WAS VALID
             if valid_or_not == "True":
@@ -80,7 +78,7 @@ def on_touch_up(self, touch):
 
             elif valid_or_not == "True, Captured":
                 #If the move was valid, and a capture occured
-                piece_occupied = str(position_piece[pos_chess])
+                piece_occupied = str(self.position_piece[pos_chess])
 
                 #Deletes the piece that was captured
                 self.ids[piece_occupied].pos = (1000,1000)

Checking_for_valid_move/Queen.py

@@ -1,18 +1,11 @@
 
 from Checking_for_valid_move.rook import rook
 from Checking_for_valid_move.bishop import Bishop
-def Queen(position_piece, pos_chess):
-        '''
-        CHECK Bishop AND Rook
-        IF ONE IS TRUE;
-        THEN QUEEN IS TRUE
-        '''
 
-        rook_result = rook(position_piece, pos_chess)
-        Bishop_result = Bishop(position_piece, pos_chess)
-
-        if rook_result == True or Bishop_result == True:
-            return True
-
-        else:
-            return False
+def Queen(position_piece, pos_chess, piece_that_moved):
+    '''
+    The rules I used to determine the path of the Queen:
+    1. See if the Rook or the Bishop returns a valid move
+    '''
+    if rook(position_piece, pos_chess) == True or Bishop(position_piece, pos_chess, piece_that_moved) == True:
+        return True

Checking_for_valid_move/bishop.py

@@ -1,30 +1,42 @@
 from Data_Conversion.difference_for_letter import dictionar_of_letters_to_numbers
 from Checking_for_valid_move.checking_for_blocked_path import is_path_blocked
 
-def Bishop(position_piece, pos_chess):
+def Bishop(position_piece, pos_chess, piece_that_moved):
     '''
-    NUMBER DID NOT STAY THE SAME
-    GET DIFFerecne
-    CALCULATE DIFFerecne for LETTER
-    CHECK TO SEE IF THAT MAKES SENSE
+    The Rules I used to determine the path of a Bishop:
+
+    1. The number in the chess corrdinates did not stay the same
+        A. This is to make sure the Bishop did not go straight up/ down or to the left/right
+
+    2. Get the difference of the numbers (EXAMPLE: a1 and d4 would have a difference of 3)
+        A. This is to make sure the move was a correct diagonal, not a random move that wasn't
+            straight up or down.
+
+    3. Calculate the difference of the letters (if a = 1, b = 2 and so on), the example above applies here
+        A. This is still to make sure the move was a diagonal
+
+    4. Check the differences, if they are the same then the move was a correct Diagonal
+        A. Just like the example had the same difference, it was a correct diagonal
     '''
+
+    #Step 1: Check if number changed
     if str(position_piece)[1] != str(pos_chess)[1]:
 
+        #Step two: Get the difference of the numbers
         difference_of_number = int(str(position_piece)[1]) - int(str(pos_chess)[1])
+
+        #Step 3: Get numeric representation of the letters (Calculate difference in the if statement)
         first_letter = dictionar_of_letters_to_numbers[str(position_piece)[0]]
         second_letter = dictionar_of_letters_to_numbers[str(pos_chess)[0]]
 
-        bishop_path = is_path_blocked.path_bishop()
+        #Loads in another file, used in the second if statement
+        bishop_path = is_path_blocked.path_bishop(pos_chess, position_piece, piece_that_moved)
 
+        #Step 4: Check the differences
         if abs(first_letter - second_letter) == abs(difference_of_number):
-            if bishop_path.recurse(position_piece, pos_chess, difference_of_number, first_letter, second_letter) == "True":
-
-                return True
-            else:
-                return False
-        else:
 
-            return False
-    else:
+            #If they equal, check to make sure the Bishop's path is clear so it doesn't jump over anything
+            if bishop_path.recurse(difference_of_number, first_letter, second_letter) == "True":
 
-        return False
+                #If the path was clear, return a legal Move
+                return True