Pieces have functionality; Code cleaning is needed

Author: DylanSnyder31

Board.py

@@ -1,24 +1,80 @@
 from kivy.app import App
-from kivy.uix.floatlayout import FloatLayout
-from kivy.core.window import Window
+from kivy.uix.screenmanager import Screen
 
 from position_of_mouse import find_position
+from position_of_pieces import position_dic
+from chess_coords_to_real_coords import convert_coordinates
+from valid_move import is_valid_move
 
-class Scatter_Text_widget(FloatLayout):
+class Scatter_Text_widget(Screen):
 
+    def __init__(self, **kwargs):
+        super(Scatter_Text_widget, self).__init__(**kwargs)
 
     def on_touch_down(self, touch):
         res = super(Scatter_Text_widget, self).on_touch_down(touch)
+
         if res:
             position = find_position()
+            #Gets the chess coord of where the mouse pressed
             pos_chess = position.chess_position(touch.pos)
-            print(pos_chess)
-        return res
+
+            position_piece = position_dic
+
+            tup = [pos_chess,position_piece[str(pos_chess)]]
+            #Writes the chess coord and the piece that was pressed in a text file
+            with open('test.txt', 'w') as f:
+                f.write(str(tup))
 
     def on_touch_up(self, touch):
-        position = find_position()
-        pos_chess = position.chess_position(touch.pos)
-        print(pos_chess)
+        res = super(Scatter_Text_widget, self).on_touch_up(touch)
+
+        if res:
+            position = find_position()
+            #Gets the position of the mouse, and translates it into a chess corrd
+            pos_chess = position.chess_position(touch.pos)
+
+            position_piece = position_dic
+            conversion = convert_coordinates
+
+            with open('test.txt', 'r') as f:
+                lisr= f.read()
+            f.close()
+            #This is where the mouse was pressed, in a chess coord
+            chess_position_numerical = str(str(lisr[2]) + str(lisr[3]))
+
+            #This gets the piece that was moved, and stores it in string format
+            piece_that_moved = ""
+            index = 8
+            while index != len(lisr) -2:
+                piece_that_moved += str(lisr[index])
+                index += 1
+
+
+
+            #Checks to see if the square is currently occupied
+            st = is_valid_move()
+            yes = st.main(chess_position_numerical, position_piece, pos_chess, piece_that_moved)
+
+            if yes == "True":
+                self.ids[piece_that_moved].pos = (conversion.to_number()[pos_chess][0], conversion.to_number()[pos_chess][1])
+
+
+                position_dic[str(chess_position_numerical)] = 'None'
+                position_dic[str(pos_chess)] = str(piece_that_moved)
+
+            elif yes == "True, Captured":
+                piece_occupied = str(position_piece[pos_chess])
+                self.ids[piece_occupied].pos = (1000,1000)
+                self.ids[piece_that_moved].pos = (conversion.to_number()[pos_chess][0], conversion.to_number()[pos_chess][1])
+
+
+                position_dic[str(chess_position_numerical)] = 'None'
+                position_dic[str(pos_chess)] = str(piece_that_moved)
+            else: #if yes == "FALSE"
+                self.ids[piece_that_moved].pos = (conversion.to_number()[chess_position_numerical][0], conversion.to_number()[chess_position_numerical][1])
+
+
 
 #Builds the App
 class window(App):

chess_coords_to_real_coords.py

@@ -0,0 +1,13 @@
+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),
+                                'a2': (0,100), 'b2': (102.5,100), 'c2': (205,100), 'd2': (307.5,100), 'e2': (410,100), 'f2': (512.5,100), 'g2': (615,100), 'h2': (717.5,100),
+                                'a3': (0,200), 'b3': (102.5,200), 'c3': (205,200), 'd3': (307.5,200), 'e3': (410,200), 'f3': (512.5,200), 'g3': (615,200), 'h3': (717.5,200),
+                                'a4': (0,300), 'b4': (102.5,300), 'c4': (205,300), 'd4': (307.5,300), 'e4': (410,300), 'f4': (512.5,300), 'g4': (615,300), 'h4': (717.5,300),
+                                'a5': (0,400), 'b5': (102.5,400), 'c5': (205,400), 'd5': (307.5,400), 'e5': (410,400), 'f5': (512.5,400), 'g5': (615,400), 'h5': (717.5,400),
+                                'a6': (0,500), 'b6': (102.5,500), 'c6': (205,500), 'd6': (307.5,500), 'e6': (410,500), 'f6': (512.5,500), 'g6': (615,500), 'h6': (717.5,500),
+                                '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

difference_for_letter.py

@@ -0,0 +1,3 @@
+dictionar_of_letters_to_numbers = {
+    'a': 1, 'b': 2, 'c': 3, 'd':4, 'e': 5, 'f': 6, 'g':7, 'h': 8
+}

main.py

@@ -30,7 +30,9 @@ def setup():
 TODO LIST
 
 
-MAKE THE BUTTONS have a 'hard landing' IN EACH SQUARE AFTER THEY PLAYED
+MAKE THE DICTIONARY UPDATE
+
+
 MAKE THE LABELS DISSAPEAR WHEN CAPTURED
 
 
@@ -40,8 +42,8 @@ def setup():
 
 
 
-2.5 CODE A TOUCH-BASED SYSTEM
-    2.75 MAKE THE DRAGGING SYSTEM HAVE THE PIECES MOVE A LAYER UP FROM THE BOARD
+
+    2.75 MAKE THE DRAGGING SYSTEM HAVE THE PIECES MOVE A LAYER UP FROM THE BOARD - AND GET IN SYNC WITH MOUSE
 3. CODE ALL OF THE MOVES FOR THE PIECES (HARD; MAKE CODE STILL NEAT)
 4. CREATE A SYSTEM OF TURN-BASED GAMEPLAY (MEDIUM; NEED TO KEEP CODE CLEAN)
 5. CREATE A SYSTEM TO SHOW THE USER WHERE TO PLACE: AND A CHECK-BASED SYSTEM

position_of_pieces.py

@@ -0,0 +1,11 @@
+
+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",
+                        'a4': "None", 'b4': "None", 'c4': "None", 'd4': "None", 'e4': "None", 'f4': "None", 'g4': "None", 'h4': "None",
+                        'a5': "None", 'b5': "None", 'c5': "None", 'd5': "None", 'e5': "None", 'f5': "None", 'g5': "None", 'h5': "None",
+                        'a6': "None", 'b6': "None", 'c6': "None", 'd6': "None", 'e6': "None", 'f6': "None", 'g6': "None", 'h6': "None",
+
+                        '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"
+}

test.txt

@@ -0,0 +1 @@
+['b5', 'Left White Knight']

valid_move.py

@@ -0,0 +1,221 @@
+from difference_for_letter import dictionar_of_letters_to_numbers
+
+class is_valid_move():
+
+    def is_square_occupied(self, chess_position_numerical, position_piece, pos_chess, piece_that_moved):
+        if position_piece[pos_chess] != 'None':
+            piece_occupied = str(position_piece[pos_chess])
+            if str(piece_occupied)[0] == 'L':
+                color_of_occupied = str(piece_occupied[5])
+            elif str(piece_occupied)[0] == 'R':
+                color_of_occupied = str(piece_occupied[6])
+            else:
+                color_of_occupied = str(piece_occupied[0])
+
+            if str(piece_that_moved)[0] == 'L':
+                color_of_moved = str(piece_that_moved[5])
+            elif str(piece_that_moved)[0] == 'R':
+                color_of_moved = str(piece_that_moved[6])
+            else:
+                color_of_moved = str(piece_that_moved[0])
+
+            if color_of_moved == color_of_occupied:
+                return "False"
+
+            else:
+                piece_only = ""
+                index = len(str(piece_that_moved)) - 1
+                while str(piece_that_moved)[index] != " ":
+                    piece_only += str(str(piece_that_moved)[index])
+                    index -= 1
+
+                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]
+                s = is_valid_move()
+                result = "not"
+                if piece_only == "Rook":
+                    result = s.rook( chess_position_numerical, pos_chess)
+                elif piece_only == "Bishop":
+                    result = s.Bishop( chess_position_numerical, pos_chess)
+                elif piece_only == "Queen":
+                    result = s.Queen( chess_position_numerical, pos_chess)
+                elif piece_only == "King":
+                    result = s.King( chess_position_numerical, pos_chess)
+                elif piece_only == 'Knight':
+                    result = s.knight(chess_position_numerical, pos_chess)
+                elif piece_only == "Pawn":
+                    result = s.pawn_capture(chess_position_numerical, pos_chess)
+
+
+                if str(result) == "True":
+
+                    return "True, Captured"
+                else:
+                    return "False"
+
+        else:
+            piece_only = ""
+            index = len(str(piece_that_moved)) - 1
+            while str(piece_that_moved)[index] != " ":
+                piece_only += str(str(piece_that_moved)[index])
+                index -= 1
+
+            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]
+            s = is_valid_move()
+            result = "not"
+            if piece_only == "Rook":
+                result = s.rook( chess_position_numerical, pos_chess)
+            elif piece_only == "Bishop":
+                result = s.Bishop( chess_position_numerical, pos_chess)
+            elif piece_only == "Queen":
+                result = s.Queen( chess_position_numerical, pos_chess)
+            elif piece_only == "King":
+                result = s.King( chess_position_numerical, pos_chess)
+            elif piece_only == 'Knight':
+                result = s.knight(chess_position_numerical, pos_chess)
+            elif piece_only == "Pawn":
+                result = s.pawn(chess_position_numerical, pos_chess)
+
+            if str(result) == "True":
+
+                return "True"
+            else:
+                return "False"
+
+
+    def rook(self, position_piece, pos_chess):
+        '''
+        NUMBER STAY SAME
+        OR
+        LETTER STAY SAME
+        '''
+
+        if str(position_piece)[0] == str(pos_chess)[0]:
+
+            return True
+        elif str(position_piece)[1] == str(pos_chess)[1]:
+
+            return True
+        else:
+
+            return False
+
+    def knight(self, position_piece, pos_chess):
+        '''
+        want abs(letter_number - letter_number2) + abs(number - number)
+        THen either number or letter has to varry by exactly ONE
+        '''
+        letter_number1 = int(dictionar_of_letters_to_numbers[str(position_piece)[0]])
+        letter_number2 = int(dictionar_of_letters_to_numbers[str(pos_chess)[0]])
+
+        number1 = int(str(position_piece)[1])
+        number2 = int(str(pos_chess)[1])
+
+        difference_between = abs(letter_number1 - letter_number2) + abs(number1 - number2)
+
+        if difference_between == 3:
+            if abs(letter_number1 - letter_number2) == 1:
+                return True
+            elif abs(number1 - number2) == 1:
+                return True
+            else:
+                return False
+
+        else:
+            return False
+
+    def Bishop(self, position_piece, pos_chess):
+        '''
+        NUMBER DID NOT STAY THE SAME
+        GET DIFFerecne
+        CALCULATE DIFFerecne for LETTER
+        CHECK TO SEE IF THAT MAKES SENSE
+        '''
+        if str(position_piece)[1] != str(pos_chess)[1]:
+
+            difference_of_number = int(str(position_piece)[1]) - int(str(pos_chess)[1])
+            first_letter = dictionar_of_letters_to_numbers[str(position_piece)[0]]
+            second_letter = dictionar_of_letters_to_numbers[str(pos_chess)[0]]
+            if abs(first_letter - second_letter) == abs(difference_of_number):
+                return True
+            else:
+
+                return False
+        else:
+
+            return False
+
+
+    def Queen(self, position_piece, pos_chess):
+        '''
+        CHECK Bishop AND Rook
+        IF ONE IS TRUE;
+        THEN QUEEN IS TRUE
+        '''
+        s = is_valid_move()
+        rook_result = s.rook(position_piece, pos_chess)
+        Bishop_result = s.Bishop(position_piece, pos_chess)
+
+        if rook_result == True or Bishop_result == True:
+            return True
+
+        else:
+            return False
+
+    def King(self, position_piece, pos_chess):
+        '''
+        +-1 for number then letter stays same
+        +-1 for letter then number stays same
+        '''
+
+        if int(position_piece[1]) + 1 == int(pos_chess[1]) or int(position_piece[1]) -1 == int(pos_chess[1]):
+            if str(position_piece)[0] == str(pos_chess)[0]:
+                return True
+            else:
+                return False
+
+        elif int(dictionar_of_letters_to_numbers[str(position_piece)[0]]) + 1 == int(dictionar_of_letters_to_numbers[str(pos_chess)[0]]) or int(dictionar_of_letters_to_numbers[str(position_piece)[0]]) -1 == int(dictionar_of_letters_to_numbers[str(pos_chess)[0]]):
+            if str(position_piece)[1] == str(pos_chess)[1]:
+                return True
+            else:
+                return False
+
+        else:
+            return False
+
+    def pawn(self, position_piece, pos_chess):
+        '''
+        HAS to MOVE UP BY ONE
+        UNLESS CAPTURE THEN ADD one to letter and number
+        '''
+        if int(str(position_piece)[1]) + 1 == int(str(pos_chess)[1]):
+            return True
+        else:
+            return False
+
+    def pawn_capture(self, position_piece, pos_chess):
+        '''
+        + 1 for number
+        +- one for letter
+        '''
+        if int(str(position_piece)[1]) + 1 == int(str(pos_chess)[1]):
+            if int(dictionar_of_letters_to_numbers[str(position_piece)[0]]) + 1 == int(dictionar_of_letters_to_numbers[str(pos_chess)[0]]) or int(dictionar_of_letters_to_numbers[str(position_piece)[0]]) - 1 == int(dictionar_of_letters_to_numbers[str(pos_chess)[0]]):
+                return True
+            else:
+                return False
+        else:
+            return False
+
+    def is_path_blocked(self, position_piece, pos_chess):
+        pass
+
+    def special_cases(self, position_piece, pos_chess):
+        pass
+
+    def main(self, chess_position_numerical, position_piece, pos_chess, piece_that_moved):
+        s = is_valid_move()
+        status = s.is_square_occupied(chess_position_numerical, position_piece, pos_chess, piece_that_moved)
+        return status