still nonfunctional

player.py

@@ -29,6 +29,12 @@ class Piece:
         if not myisupper:
             letter = letter.lower()
         return [letter, self.p, self.q]
+    
+    def __repr__(self):
+        return ",".join(map(str, self.get_piece_info(True)+[self.team]))
+    
+    def __str__(self):
+        return self.__repr__()
 
     def validate_jumps(self, board):
         valid_jumps = self.get_valid_jumps(board)
@@ -197,6 +203,8 @@ class Player(Base.Board):
         self.playerName = playerName
         self.myIsUpper = myIsUpper
         self.algorithmName = "just roll the dice, eh?"
+        self.transated_board = dict()
+        self.can_place = lambda: sum([v for v in self.myPieces.values()])
 
     def getAllEmptyCells(self):
         result = []
@@ -250,6 +258,10 @@ class Player(Base.Board):
     @property
     def queen_placed(self):
         return any(isinstance(p, Bee) for p in self.myPieces)
+    
+
+    def random_piece(self, pieces):
+        return random.choice(pieces) if pieces else None
 
     def get_piece_class(self, letter):
         return {"Q": Bee, "B": Beetle, "S": Spider, "G": Grasshopper, "A": Ant}.get(
@@ -291,76 +303,77 @@ class Player(Base.Board):
                         valid_placements.append((p, q))
 
         return valid_placements
+    
+    def mover(self):
+        movable_pieces = [
+            piece
+            for row in self.translated_board.values()
+            for piece in row.values()
+            if piece and piece.team and piece.validate_jumps(self.translated_board)
+        ]
+        print(movable_pieces)
+        input()
+        chosen_piece = self.random_piece(movable_pieces) # -> can be None, usually the cause for an error
+        if chosen_piece:
+            new_p, new_q = random.choice(
+                chosen_piece.validate_jumps(self.translated_board)
+            )
+            return chosen_piece.get_piece_info(self.myIsUpper) + [new_p, new_q]
+    
+    def placer(self):
+        piece_to_place = self.random_piece(self.get_unplaced_pieces())
+        if piece_to_place is None:
+            return self.mover()
+        if piece_to_place:
+            valid_placements = self.get_valid_placements(self.translated_board, piece_to_place)
+            new_p, new_q = random.choice(valid_placements)
+            return piece_to_place.get_piece_info(self.myIsUpper)[:1] + [
+                None,
+                None,
+                new_p,
+                new_q,
+            ]
 
+    def update(self):
+        self.translated_board, total_pieces_count, my_pieces_count = self.translate_board(self.board)
+        return total_pieces_count, my_pieces_count
     def move(self):
-        translated_board, total_pieces_count, _ = self.translate_board(self.board)
+        total_pieces_count, my_pieces_count = self.update()
 
-        def choose_random_piece(pieces):
-            return random.choice(pieces) if pieces else None
-
-        # Check if the queen bee is placed
         bee_unplaced = "q" in [k.lower() for k in self.myPieces.keys()] and {k.lower(): v for k,v in self.myPieces.items()}["q"]!=0
 
-        # Logic for placing the queen bee based on a coin flip or on the 4th turn
         if bee_unplaced and (total_pieces_count > 3 or random.choice([True, False])):
             queen_bee = self.get_piece_class('Q')(None, None, True)
-            valid_placements = self.get_valid_placements(translated_board, queen_bee)
+            valid_placements = self.get_valid_placements(self.translated_board, queen_bee)
             if valid_placements:
                 new_p, new_q = random.choice(valid_placements)
-                return queen_bee.get_piece_info(self.myIsUpper)[0]+ [None, None, new_p, new_q]
+                return queen_bee.get_piece_info(self.myIsUpper)[:1]+ [None, None, new_p, new_q]
 
         if total_pieces_count == 0:
-            piece_to_place = choose_random_piece(self.get_unplaced_pieces())
+            piece_to_place = self.random_piece(self.get_unplaced_pieces())
             return (
                 piece_to_place.get_piece_info(self.myIsUpper)[:1] + [None, None, 3, 6]
-                if piece_to_place
-                else []
             )
 
         elif total_pieces_count == 1:
-            for _, row in translated_board.items():
+            for _, row in self.translated_board.items():
                 for _, piece in row.items():
                     if piece:
                         adjacent_positions = get_neighbors(piece.p, piece.q)
-                        random_position = choose_random_piece(adjacent_positions)
+                        random_position = self.random_piece(adjacent_positions)
-                        piece_to_place = choose_random_piece(self.get_unplaced_pieces())
+                        piece_to_place = self.random_piece(self.get_unplaced_pieces())
                         return (
                             piece_to_place.get_piece_info(self.myIsUpper)[:1]
                             + [None, None, *random_position]
-                            if piece_to_place
-                            else []
                         )
-
+        elif self.myMove <= 4:
+            return self.placer()    
         else:
-            move_or_place = random.choice(["move", "place"])
+            move_or_place = random.choice(["move", "place"]) if self.can_place else "move"
-            if move_or_place == "move":
+            if move_or_place == "place":
-                movable_pieces = [
+                return self.placer()
-                    piece
-                    for row in translated_board.values()
-                    for piece in row.values()
-                    if piece and piece.team and piece.validate_jumps(translated_board)
-                ]
-                chosen_piece = choose_random_piece(movable_pieces)
-                if chosen_piece:
-                    new_p, new_q = random.choice(
-                        chosen_piece.validate_jumps(translated_board)
-                    )
-                    return chosen_piece.get_piece_info(self.myIsUpper) + [new_p, new_q]
             else:
-                piece_to_place = choose_random_piece(self.get_unplaced_pieces())
+                return self.mover()
-                if piece_to_place:
-                    valid_placements = self.get_valid_placements(translated_board, piece_to_place)
-                    new_p, new_q = (
-                        random.choice(valid_placements)
-                        if valid_placements
-                        else (None, None)
-                    )
-                    return piece_to_place.get_piece_info(self.myIsUpper)[:1] + [
-                        None,
-                        None,
-                        new_p,
-                        new_q,
-                    ]
         return []