NEEDED TO BE DONE: PAWN PROMOTION (ALMOST DONE), CHECK and CHECKMATE SYSTEM (DIFFICULTIES)

Author: DylanSnyder31

Board.py

@@ -89,6 +89,31 @@ def on_touch_up(self, touch):
                 position_dic[str(chess_position_numerical)] = 'None'
                 position_dic[str(pos_chess)] = str(piece_that_moved)
 
+            elif valid_or_not == "Castle":
+                #Move the piece to the location
+                self.ids[piece_that_moved].pos = (conversion.to_number()[pos_chess][0], conversion.to_number()[pos_chess][1])
+                if str(pos_chess) == 'g1':
+                    self.ids['Right White Rook'].pos = (conversion.to_number()['f1'][0], conversion.to_number()['f1'][1])
+                    position_dic['h1'] = 'None'
+                    position_dic['f1'] = 'Right White Rook'
+                if str(pos_chess) == 'c1':
+                    self.ids['Left White Rook'].pos = (conversion.to_number()['d1'][0], conversion.to_number()['d1'][1])
+                    position_dic['a1'] = 'None'
+                    position_dic['d1'] = 'Left White Rook'
+                if str(pos_chess) == 'g8':
+                    self.ids['Right Black Rook'].pos = (conversion.to_number()['f8'][0], conversion.to_number()['f8'][1])
+                    position_dic['h8'] = 'None'
+                    position_dic['f8'] = 'Right Black Rook'
+                if str(pos_chess) == 'c8':
+                    self.ids['Left Black Rook'].pos = (conversion.to_number()['d8'][0], conversion.to_number()['d8'][1])
+                    position_dic['a8'] = 'None'
+                    position_dic['d8'] = 'Left Black Rook'
+                #Updates the Dictionary of all the piece locations
+                position_dic[str(chess_position_numerical)] = 'None'
+                position_dic[str(pos_chess)] = str(piece_that_moved)
+
+            elif valid_or_not == "New_Piece":
+                pass
             else:
                 #If the move was not valid
 

Checking_for_valid_move/checking_for_blocked_path.py

@@ -27,7 +27,7 @@ def __init__(self, position_piece, pos_chess):
             self.letter_number_of_end =  dictionar_of_letters_to_numbers[str(position_piece)[0]]
 
             self.letter_that_stayed_the_same = str(pos_chess)[0]
-            self.number_of_start = str(pos_chess)[1]
+            self.number_of_start = int(str(pos_chess)[1])
             self.number_of_end =  int(str(position_piece)[1])
 
             self.blocked = "No"
@@ -104,7 +104,7 @@ def letter_same(self, position_piece, pos_chess):
 
                 self.number_of_start += 1
                 #Iterates through the squares
-                while str(self.number_of_start) != str(number_of_end):
+                while str(self.number_of_start) != str(self.number_of_end):
 
                     #Assignes new_number to a square the rook went past
                     new_number = self.number_of_start

Checking_for_valid_move/king.py

@@ -1,5 +1,5 @@
 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:
@@ -11,6 +11,9 @@ def King(position_piece, pos_chess):
     2. Check if the numeric value of the letter moved up or down by one
                                         if so, Check if the number stayed the same
         A. This is to check if the King moved left or right only by one
+
+    3. Check if the player is trying to Castle, I hard-coded this in because of the little amount of checks needed
+
 '''
 
     #Step 1 : Check if the number differs by no more or less than one
@@ -31,3 +34,32 @@ def King(position_piece, pos_chess):
         #Checks to make sure the numbers are the same
         if str(position_piece)[1] == str(pos_chess)[1]:
             return True
+
+    #Step 3: Checking for a Castle
+    elif int(dictionar_of_letters_to_numbers[str(position_piece)[0]]) + 2 == int(dictionar_of_letters_to_numbers[str(pos_chess)[0]]) or int(dictionar_of_letters_to_numbers[str(position_piece)[0]]) - 2 == int(dictionar_of_letters_to_numbers[str(pos_chess)[0]]):
+            #If the piece is a white king
+            if str(position_piece) == 'e1':
+                #Checking to see what direction (Right)
+                if str(pos_chess) == 'g1':
+                    if position_dic['h1'] == "Right White Rook":
+                        if position_dic['f1'] == "None":
+                            return "Castle"
+                else:
+                    #Checking the swaures, to make sure they are empty
+                    if position_dic['a1'] == "Left White Rook":
+                        if position_dic['d1'] == "None":
+                            if position_dic['b1'] == "None":
+                                return "Castle"
+
+            #If the piece is a black King
+            elif str(position_piece) == 'e8':
+                if str(pos_chess) == 'g8':
+                    if str(pos_chess) == 'g8':
+                        if position_dic['h8'] == "Right Black Rook":
+                            if position_dic['f8'] == "None":
+                                return "Castle"
+                    else:
+                        if position_dic['a8'] == "Left Black Rook":
+                            if position_dic['d8'] == "None":
+                                if position_dic['b8'] == "None":
+                                    return "Castle"

Checking_for_valid_move/king_check.py

@@ -0,0 +1,187 @@
+from Data_Conversion.position_of_pieces import position_dic
+from Data_Conversion.difference_for_letter import dictionar_of_letters_to_numbers
+
+'''
+Check to see if the king is currently in check
+
+
+
+	if yes, at the end of every move check again
+		if still in check, return FALSE and repeat loop
+
+		if not in check, end loop and return TRUE
+
+
+
+
+How to check if in check:
+
+ROOK:
+
+Check to the left/right
+Check up/down
+
+BISHOP:
+
+Check up/down/left/right
+
+KNIGHT:
+
+    CHECK THE FOUR SPOTS IT COULD BE
+
+QUEEN:
+CHECK FoR A BISHOP AND A rook
+
+
+
+the King is the origin POint
+    CHECK each squre for each peice:
+        if another piece 'pops up' before the direction, end the
+            process becausre that means it is blocked
+
+
+'''
+
+class end_game():
+
+    def __init__(self, turn):
+        '''
+        Gets the Position of the King
+        '''
+        #Checks to see what player's turn it is, and decides the king's ID based on that Data
+        if turn == "W":
+            king_ID = "White King"
+            #What way the pawns are deadly to the king
+            self.check_for_pawns = "Up"
+        else:
+            king_ID = "Black King"
+            #What way the pawns are deadly to the king
+            self.check_for_pawns = "Down"
+
+        #Iterates through the board to determine where the king is
+        for key, value in position_dic.items():
+            if str(value) == king_ID:
+
+                #Assigns this variabel to the square where the king is present
+                self.king_position = str(key)
+
+        self.number_positive = int(self.king_position[1]) + 1
+        self.number_negative = int(self.king_position[1]) - 1
+        self.player_turn = turn
+        self.numeric_value_positive = str(int(dictionar_of_letters_to_numbers[self.king_position[0]]) + 1)
+        self.numeric_value_negative = str(int(dictionar_of_letters_to_numbers[self.king_position[0]]) - 1)
+
+        self.number = self.king_position[1]
+        self.letter = self.king_position[0]
+
+    def rook(self):
+        '''
+        CHck if to the left/right wall
+        check if to the top/bottom wall
+        '''
+        numberic = int(self.numeric_value_negative)
+        if self.numeric_value_negative != '0':
+            endpoint = 'a' + str(self.number)
+            for key, value in dictionar_of_letters_to_numbers.items():
+                if int(value) == numberic:
+                    letter = str(key)
+            while position_dic[str(letter) + str(self.number) ] == 'None' or str(letter) + str(self.number) == endpoint:
+                numberic -= 1
+                for key, value in dictionar_of_letters_to_numbers.items():
+                    if str(value) == numberic:
+                        letter = str(key)
+            if self.player_turn == 'W':
+                print("HERE")
+                if position_dic[str(letter) + str(self.number) ][0] == "L":
+                    if position_dic[str(letter) + str(self.number) ][5] == "B":
+                        if position_dic[str(letter) + str(self.number) ][11] == 'R':
+                            return "False"
+                        else:
+                            pass
+                    else:
+                        pass
+
+                elif position_dic[str(letter) + str(self.number) ][0] =="R":
+                    if position_dic[str(letter) + str(self.number) ][6] == "B":
+                        if position_dic[str(letter) + str(self.number) ][12] == 'R':
+                            return "False"
+
+            else:
+
+                if position_dic[str(letter) + str(self.number) ][0] == "L":
+                    if position_dic[str(letter) + str(self.number) ][5] == "W":
+                        if position_dic[str(letter) + str(self.number) ][11] == 'R':
+                            return "False"
+                elif position_dic[str(letter) + str(self.number) ][0] =="R":
+                    if position_dic[str(letter) + str(self.number) ][6] == "W":
+                        if position_dic[str(letter) + str(self.number) ][12] == 'R':
+
+                            return "False"
+
+                            
+        if self.numeric_value_positive != '9':
+            '''
+            CHECK to thE RIGHt
+            '''
+            pass
+        if self.number_positive != 9:
+            '''
+            CHeck going DOWN
+            '''
+            pass
+        if self.number_negative != 0:
+            '''
+            Check going up
+            '''
+            pass
+
+    def pawn(self):
+
+        if self.check_for_pawns == "Up":
+            '''
+            If White
+            '''
+            if self.numeric_value_negative != '0':
+                for key, value in dictionar_of_letters_to_numbers.items():
+                    if str(value) == self.numeric_value_negative:
+                        letter = str(key)
+                square = str(letter) + str(self.number_positive)
+
+            if self.numeric_value_positive != '9':
+                for key, value in dictionar_of_letters_to_numbers.items():
+                    if str(value) == self.numeric_value_positive:
+                        letter = str(key)
+                square = str(letter) + str(self.number_positive)
+
+            if str(position_dic[square][0]) == "B" and str(position_dic[square][6]) == 'P':
+                #A Pawn is in that location
+                return "False"
+
+
+        if self.check_for_pawns == "Down":
+            '''
+            If black
+            '''
+            if self.numeric_value_negative != '0':
+                for key, value in dictionar_of_letters_to_numbers.items():
+                    if str(value) == self.numeric_value_negative:
+                        letter = str(key)
+                square = str(letter) + str(self.number_negative)
+
+            if self.numeric_value_positive != '9':
+                for key, value in dictionar_of_letters_to_numbers.items():
+                    if str(value) == self.numeric_value_positive:
+                        letter = str(key)
+                square = str(letter) + str(self.number_negative)
+
+            if str(position_dic[square][0]) == "W" and str(position_dic[square][6]) == 'P':
+                #A Pawn is in that location
+                return "False"
+
+
+
+    def in_check(self):
+        check = end_game
+        if check.pawn(self) != "False":
+            if check.rook(self) !="False":
+                return "True"

Checking_for_valid_move/pawn.py

@@ -1,6 +1,7 @@
 from Data_Conversion.difference_for_letter import dictionar_of_letters_to_numbers
 from Data_Conversion.position_of_pieces import position_dic
 
+
 '''
 Since the rules of the pawn movement and the movement of capturing is so different, I
 decided to make two different functions that get called depending if a capturing is happeing
@@ -31,6 +32,7 @@ def negative(self, position_piece, pos_chess):
                 return "Capture"
 
     def pawn(self, position_piece, pos_chess):
+        
         '''
         The rules I used to determine the movement of the pawn, when regular are as follows:
 

Data_Conversion/saved_input.txt

@@ -1 +1 @@
-['f4', 'Black Pawn5']
+['a7', 'Black Pawn1']

pawn_new_piece.kv

@@ -0,0 +1,15 @@
+# File name: pawn.py
+
+<new_piece>
+
+    FloatLayout:
+
+        Label:
+            pos, 0,0
+            size_hint: None, None
+            size: 100,100
+            text: "YESMAN"
+            canvas.before:
+                Rectangle:
+                    pos: self.pos
+                    size: self.size