Changed how cheating works. Need to test if Jose's new arduino code works

board_detector.py

@@ -274,33 +274,33 @@ def warp_board(img, corners_sorted, intersection):
 
     return warped_img, sorted_warped_points
 
-prev_warped_img = None
-prev_hsv_img = None
-prev_hsv_mask_sat = None
-prev_hsv_mask_bright = None
-prev_hsv_mask = None
-prev_hsv_after = None
-prev_bgr_after = None
-prev_gray_after = None
+# prev_warped_img = None
+# prev_hsv_img = None
+# prev_hsv_mask_sat = None
+# prev_hsv_mask_bright = None
+# prev_hsv_mask = None
+# prev_hsv_after = None
+# prev_bgr_after = None
+# prev_gray_after = None
 prev_filled_contour_mask = None
-prev_masked_hsv_after = None
-# prev_contours = None
-prev_largest_contour = None
-# prev_bounding_box_array = None
-
-def find_pieces(warped_img, sorted_warped_points, reader, img_idx):
-    global prev_warped_img
-    global prev_hsv_img
-    global prev_hsv_mask_sat
-    global prev_hsv_mask_bright
-    global prev_hsv_mask
-    global prev_hsv_after
-    global prev_bgr_after
-    global prev_gray_after
+# prev_masked_hsv_after = None
+# # prev_contours = None
+# prev_largest_contour = None
+# # prev_bounding_box_array = None
+
+def find_pieces(warped_img, prev_warped_img, sorted_warped_points, reader, img_idx):
+    # global prev_warped_img
+    # global prev_hsv_img
+    # global prev_hsv_mask_sat
+    # global prev_hsv_mask_bright
+    # global prev_hsv_mask
+    # global prev_hsv_after
+    # global prev_bgr_after
+    # global prev_gray_after
     global prev_filled_contour_mask
-    global prev_masked_hsv_after
-    # global prev_contours
-    global prev_largest_contour
+    # global prev_masked_hsv_after
+    # # global prev_contours
+    # global prev_largest_contour
     # global prev_bounding_box_array
     # save warped img
     # img_path = os.path.join('game_images', 'warped' + str(img_idx) + '.jpg')
@@ -312,8 +312,8 @@ def find_pieces(warped_img, sorted_warped_points, reader, img_idx):
     hsv_img = cv2.cvtColor(warped_img, cv2.COLOR_BGR2HSV)
     gray_img = cv2.cvtColor(warped_img, cv2.COLOR_BGR2GRAY)
 
-    # if compare_prev_warped:
-    #     prev_hsv_img = cv2.cvtColor(prev_warped_img, cv2.COLOR_BGR2HSV)
+    if compare_prev_warped:
+        prev_hsv_img = cv2.cvtColor(prev_warped_img, cv2.COLOR_BGR2HSV)
 
     # threshold to find strongest colors in image
     saturation_thresh = 60
@@ -322,15 +322,20 @@ def find_pieces(warped_img, sorted_warped_points, reader, img_idx):
     hsv_mask_bright = cv2.inRange(hsv_img[:,:,2], brightness_thresh, 255) # brightness mask
     hsv_mask = cv2.bitwise_and(hsv_mask_sat, hsv_mask_bright)
 
-    # if compare_prev_warped:
-    #     prev_hsv_mask_sat = cv2.inRange(prev_hsv_img[:,:,1], saturation_thresh, 255) # saturation mask
-    #     prev_hsv_mask_bright = cv2.inRange(prev_hsv_img[:,:,2], brightness_thresh, 255) # brightness mask
-    #     prev_hsv_mask = cv2.bitwise_and(prev_hsv_mask_sat, prev_hsv_mask_bright)
+    if compare_prev_warped:
+        prev_hsv_mask_sat = cv2.inRange(prev_hsv_img[:,:,1], saturation_thresh, 255) # saturation mask
+        prev_hsv_mask_bright = cv2.inRange(prev_hsv_img[:,:,2], brightness_thresh, 255) # brightness mask
+        prev_hsv_mask = cv2.bitwise_and(prev_hsv_mask_sat, prev_hsv_mask_bright)
 
     hsv_after = cv2.bitwise_and(hsv_img, hsv_img, mask=hsv_mask)
     bgr_after = cv2.cvtColor(hsv_after, cv2.COLOR_HSV2BGR)
     gray_after = cv2.cvtColor(bgr_after, cv2.COLOR_BGR2GRAY)
 
+    if compare_prev_warped:
+        prev_hsv_after = cv2.bitwise_and(prev_hsv_img, prev_hsv_img, mask=prev_hsv_mask)
+        prev_bgr_after = cv2.cvtColor(prev_hsv_after, cv2.COLOR_HSV2BGR)
+        prev_gray_after = cv2.cvtColor(prev_bgr_after, cv2.COLOR_BGR2GRAY)
+
     diff_mask_contours = np.zeros_like(gray_after)
     drawn_warped_img = deepcopy(warped_img)
     if compare_prev_warped:
@@ -359,11 +364,6 @@ def find_pieces(warped_img, sorted_warped_points, reader, img_idx):
             display_img([prev_bgr_after, bgr_after])
             display_img([diff_mask, diff_mask_contours])
 
-    # if compare_prev_warped:
-    #     prev_hsv_after = cv2.bitwise_and(prev_hsv_img, prev_hsv_img, mask=prev_hsv_mask)
-    #     prev_bgr_after = cv2.cvtColor(prev_hsv_after, cv2.COLOR_HSV2BGR)
-    #     prev_gray_after = cv2.cvtColor(prev_bgr_after, cv2.COLOR_BGR2GRAY)
-
     # define color thresholds to use to classify colors later on
     hue_thresh_dict = {'Red': (170,190), 'Orange':(4,24), 'Yellow': (24,44), 'Green': (50,70), 'Purple': (121,140), 
                        'Teal': (80,99), 'Pink': (140,170), 'Blue': (100,120)} # CHANGE
@@ -409,8 +409,8 @@ def find_pieces(warped_img, sorted_warped_points, reader, img_idx):
 
             # get contours inside square mask
             masked_hsv_after = cv2.bitwise_and(gray_after, gray_after, mask=rect_mask)
-            # if compare_prev_warped:
-            #     prev_masked_hsv_after = cv2.bitwise_and(prev_gray_after, prev_gray_after, mask=rect_mask)
+            if compare_prev_warped:
+                prev_masked_hsv_after = cv2.bitwise_and(prev_gray_after, prev_gray_after, mask=rect_mask)
             # display_img([masked_hsv_after,prev_masked_hsv_after])
 
             contours, hierarchy = cv2.findContours(masked_hsv_after, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
@@ -602,19 +602,19 @@ def find_pieces(warped_img, sorted_warped_points, reader, img_idx):
                     print("\t\t|", end="")
             print("|")
 
-    prev_warped_img = deepcopy(warped_img)
-    prev_hsv_img = deepcopy(hsv_img)
-    prev_hsv_mask_sat = deepcopy(hsv_mask_sat)
-    prev_hsv_mask_bright = deepcopy(hsv_mask_bright)
-    prev_hsv_mask = deepcopy(hsv_mask)
-    prev_hsv_after = deepcopy(hsv_after)
-    prev_bgr_after = deepcopy(bgr_after)
-    prev_gray_after = deepcopy(gray_after)
+    # prev_warped_img = deepcopy(warped_img)
+    # prev_hsv_img = deepcopy(hsv_img)
+    # prev_hsv_mask_sat = deepcopy(hsv_mask_sat)
+    # prev_hsv_mask_bright = deepcopy(hsv_mask_bright)
+    # prev_hsv_mask = deepcopy(hsv_mask)
+    # prev_hsv_after = deepcopy(hsv_after)
+    # prev_bgr_after = deepcopy(bgr_after)
+    # prev_gray_after = deepcopy(gray_after)
     prev_filled_contour_mask = deepcopy(filled_contour_mask)
-    prev_masked_hsv_after = deepcopy(masked_hsv_after)
-    # prev_contours = deepcopy(contours)
-    prev_largest_contour = deepcopy(largest_contour)
-    # prev_bounding_box_array = cur_bounding_box_array.copy()
+    # prev_masked_hsv_after = deepcopy(masked_hsv_after)
+    # # prev_contours = deepcopy(contours)
+    # prev_largest_contour = deepcopy(largest_contour)
+    # # prev_bounding_box_array = cur_bounding_box_array.copy()
 
     return color_grid, drawn_warped_img
 

breadboard_set_up/breadboard_set_up.ino

@@ -133,6 +133,9 @@ void readData(){
       tempCoords[coordPlace] = inByte;
       coordPlace++;
     }
+    else if(inByte == '@'){
+      // do nothing (stop flashing lights)
+    }
     else{
       int tensPlace = tempCoords[0] - '0';
       int onesPlace = tempCoords[1] - '0';

chess_ai.py

@@ -254,7 +254,7 @@ def chess_AI(FEN_string, FEN_board_state_before, which_alg):
    
     else:
         # # check if there's cheating
-        is_cheating = cheat_check(FEN_string, FEN_board_state_before)
+        # is_cheating = cheat_check(FEN_string, FEN_board_state_before)
         
         # if is_cheating:
         #     print("Illegal move detected, please fix")
@@ -265,7 +265,7 @@ def chess_AI(FEN_string, FEN_board_state_before, which_alg):
         best_move = eval_best_move(FEN_string, which_alg)
 
         # check move for special characteristics
-        best_move_processed = special_move_check(FEN_string, best_move, is_cheating)
+        best_move_processed = special_move_check(FEN_string, best_move, False)
 
         # prepare info for ESP32
         ESP_input = prep_info_to_ESP(FEN_string, best_move_processed)

game.py

@@ -46,6 +46,8 @@ class ChessGame:
         else:
             self.img_idx = 1
 
+        self.player_cheating = False
+
         self.reader = easyocr.Reader(['en'], gpu=False, verbose=False)
 
         # hard-coded borders to crop image
@@ -60,6 +62,8 @@ class ChessGame:
         self.corners_sorted = None
         self.intersection = None
         self.drawn_warped_img = None
+        self.prev_warped_img = None
+        self.warped_img = None
 
         if not skip_camera:
             self.picam2 = Picamera2()
@@ -94,6 +98,7 @@ class ChessGame:
         print("\n--- STARTING BOARD ---")
 
         self.do_cv()
+        self.prev_warped_img = self.warped_img
         # use example fen if not starting from blank game
         if self.test_img in example_fens:
             self.board = chess.Board(example_fens[self.test_img])
@@ -142,24 +147,27 @@ class ChessGame:
         input("[Waiting to submit player move. Replace with physical button]")
         # self.switch_turn()
         self.do_cv()
-
         # handle cheating
-        while cheat_check(self.board.fen(), self.prev_board.fen()):
-            print("CHECKING: ", self.board.fen())
+        while self.player_cheating:
+            # print("CHECKING: ", self.board.fen())
             self.board = self.prev_board.copy()
             print("Player is cheating. Return to the previous state and perform a valid move.")
             self.img_idx -= 1
             # print(self.board)
 
-            ESP_input, best_move = chess_AI(self.board.fen(), self.prev_board.fen(), 0)
+            # ESP_input, _ = chess_AI(self.board.fen(), self.prev_board.fen(), self.player_cheating, 0)
+            # ESP_input = [["_ _","_ _"],[]]
 
             # ----------------------------ADD JOSE LED STUFF
             if (self.mag_arm_enable and not skip_camera):
-                self.mychess.chessExecuteMove(ESP_input) 
+                self.mychess.sendCheating(self.player_cheating)
 
             input("[Waiting to submit player move. Replace with physical button]")
             self.do_cv()
 
+        if not self.player_cheating:
+            self.prev_warped_img = self.warped_img
+
     def ai_turn(self):
         print("\n--- CHESS ROBOT'S TURN ---")
         # print("Board before chess_AI:", self.board.fen())  
@@ -173,6 +181,7 @@ class ChessGame:
             self.mychess.chessExecuteMove(ESP_input)
         # self.switch_turn()
         self.do_cv()
+        self.prev_warped_img = self.warped_img
 
     def do_cv(self):
         while(1): # essentially do_while(self.loop)
@@ -217,14 +226,14 @@ class ChessGame:
         
         # warp the image based on the lines of the board
         # if self.img_idx == 1:
-        warped_img, sorted_warped_points = warp_board(img, self.corners_sorted, self.intersection)
+        self.warped_img, sorted_warped_points = warp_board(img, self.corners_sorted, self.intersection)
 
-        if (warped_img is None):
+        if (self.warped_img is None):
             print("warped_img is None")
             return
         
         # get the pieces based on color thresholding and easyocr
-        color_grid, self.drawn_warped_img = find_pieces(warped_img, sorted_warped_points, self.reader, self.img_idx - 1)
+        color_grid, self.drawn_warped_img = find_pieces(self.warped_img, self.prev_warped_img, sorted_warped_points, self.reader, self.img_idx - 1)
 
         # convert color_grid to board, which we can get fen string from
         if self.color_scheme == 'o/b':
@@ -244,7 +253,6 @@ class ChessGame:
             print(self.board)
             print(self.board.fen())
 
-
     def check_game_over(self):
         if self.board.is_checkmate():
             print("\n----------------------")
@@ -319,6 +327,9 @@ class ChessGame:
 
                 if self.img_idx == 1:
                     temp_board.remove_piece_at(chess.square(j, 7 - i))
+
+        # if temp_board.turn == chess.BLACK: # if the player just went
+        #     cheat_check(temp_boself.prev_board.fen())
         
         # find move with correct fen string (with castling, en passant, half move counter, etc.)
         # Would be more efficient to update the extra fen string parameters myself. Might want to change
@@ -332,14 +343,21 @@ class ChessGame:
                 found_move = True
                 print("Found move!", move)
                 self.board = board_copy.copy()
-                break
+                if self.player_cheating:
+                    self.player_cheating = False
+                    if (self.mag_arm_enable and not skip_camera):
+                        self.mychess.sendCheating(self.player_cheating)
+                return
         
         if not found_move:
-            print("Did NOT find move.")
-            if self.img_idx != 2:
-                print("Detected Board: ")
-                print(board_copy)
-                print("\n")
+            if temp_board.turn == chess.BLACK: # if player just went, they cheated
+                self.player_cheating = True
+            else: # chess robot just went
+                print("Did NOT find chess robot's move.")
+                if self.img_idx != 2:
+                    print("Detected Board: ")
+                    print(board_copy)
+                    print("\n")
 
         # print("PREVIOUS BOARD:")
         # print(self.prev_board)

planning.py

@@ -163,6 +163,12 @@ class Path_planning():
         print(serialMessage)
         return serialMessage
     
+    def sendCheating(self, is_cheating):
+        if is_cheating:
+            self.serialSend('?', 1, 0, 0)
+        else:
+            self.serialSend('@', 1, 0, 0)
+    
     def chessExecuteMove(self, AI_output):
         print(AI_output)
         captureLocation = "a 8"
@@ -176,38 +182,38 @@ class Path_planning():
             print(example_capture)
         else:
             example_capture = ''
-        cheating = AI_output[2][5]
+        # cheating = AI_output[2][5]
         castling = AI_output[2][2]
         capture = AI_output[2][3]
         enPasant = AI_output[2][1]
         promotion = AI_output[2][4]
         capLength = -1
-        if cheating:
-            self.serialSend('?', cheating, promotion, castling)
+        # if cheating:
+        #     self.serialSend('?', cheating, promotion, castling)
+        # else:
+        self.filling_board(example_fen)
+        if(capture or castling or enPasant):
+            capPath = self.A_star_traversal(example_capture, capture)
+            capLength = len(capPath)
+            if(capture):
+                capture = False
+            if(castling):
+                captureString = example_capture[0] + " " + example_capture[1]
+                print(captureString)
+                captureString = captureString.replace(" ", "")
+                print(captureString)
+                temp_board = chess.Board("r3k2K/1b1p1p2/p3p1q1/6p1/2P5/P3P3/1P2B3/R1R1Q3 b q - 7 31")
+                temp_board.push(chess.Move.from_uci(captureString))
+                new_FEN_string = temp_board.fen()
+                self.filling_board(new_FEN_string)
+            piecePath = self.A_star_traversal(example_best_move, capture)
+            capPath.extend(piecePath)
+            self.serialSend(self.pathToSerial(capPath, capLength), cheating, promotion, castling)
+    #         # try to delay motors
+    #         # time.sleep(5)
         else:
-            self.filling_board(example_fen)
-            if(capture or castling or enPasant):
-                capPath = self.A_star_traversal(example_capture, capture)
-                capLength = len(capPath)
-                if(capture):
-                    capture = False
-                if(castling):
-                    captureString = example_capture[0] + " " + example_capture[1]
-                    print(captureString)
-                    captureString = captureString.replace(" ", "")
-                    print(captureString)
-                    temp_board = chess.Board("r3k2K/1b1p1p2/p3p1q1/6p1/2P5/P3P3/1P2B3/R1R1Q3 b q - 7 31")
-                    temp_board.push(chess.Move.from_uci(captureString))
-                    new_FEN_string = temp_board.fen()
-                    self.filling_board(new_FEN_string)
-                piecePath = self.A_star_traversal(example_best_move, capture)
-                capPath.extend(piecePath)
-                self.serialSend(self.pathToSerial(capPath, capLength), cheating, promotion, castling)
-        #         # try to delay motors
-        #         # time.sleep(5)
-            else:
-                piecePath = self.A_star_traversal(example_best_move, capture)
-                self.serialSend(self.pathToSerial(piecePath, capLength), cheating, promotion, castling)
+            piecePath = self.A_star_traversal(example_best_move, capture)
+            self.serialSend(self.pathToSerial(piecePath, capLength), cheating, promotion, castling)