Upload stratego\env\backup\edited_env\Stratego\env.py with huggingface_hub

stratego//env//backup//edited_env//Stratego//env.py

@@ -0,0 +1,612 @@
+import re, random
+from typing import Optional, Dict, Tuple, List, Any
+
+import textarena as ta
+
+class StrategoEnv(ta.Env):
+    """ A two-player implementation of the board game Stratego """
+    def __init__(self):
+        """
+        Initialize the environment.
+        """
+        ## set up the board items
+        self.piece_counts = {
+            'Flag': 1, 'Bomb': 6, 'Spy': 1, 'Scout': 8, 'Miner': 5,
+            'Sergeant': 4, 'Lieutenant': 4, 'Captain': 4, 'Major': 3,
+            'Colonel': 2, 'General': 1, 'Marshal': 1
+        }
+        self.piece_ranks = {
+            'Flag': 0, 'Bomb': 11, 'Spy': 1, 'Scout': 2, 'Miner': 3,
+            'Sergeant': 4, 'Lieutenant': 5, 'Captain': 6, 'Major': 7,
+            'Colonel': 8, 'General': 9, 'Marshal': 10
+        }
+        self.lakes = [(4, 2), (4, 3), (5, 2), (5, 3), (4, 6), (4, 7), (5, 6), (5, 7)]
+        self.player_pieces = {0: [], 1: []}
+        self.board = [[None for _ in range(10)] for _ in range(10)]
+        #(13 Nov 2025) New Comment : to initializes a turn counter, which can be used, when declaring a draw if the game goes on for too long without a winner.
+        self.turn_count = 0
+
+    @property
+    def terminal_render_keys(self):
+        return ["rendered_board"]
+
+    def reset(self, num_players: int, seed: Optional[int]=None):
+        """ Reset the environment to start a new game """
+        self.state = ta.TwoPlayerState(num_players=num_players, seed=seed)
+        # (13 Nov 2025) New Comment : reset the turn counter at the start of a new game.
+        self.turn_count = 0
+        
+        ## populate the board
+        self.board = self._populate_board()
+
+        ## initialise the game state
+        rendered_board = self._render_board(player_id=None, full_board=True)
+        game_state={"board": self.board, "player_pieces": self.player_pieces, "rendered_board": rendered_board}
+        self.state.reset(game_state=game_state, player_prompt_function=self._generate_player_prompt)
+        self._observe_current_state()
+    
+    def _generate_player_prompt(self, player_id: int, game_state: Dict[str, Any]):
+        """
+        Generates the player prompt for the current player.
+
+        Args:
+            player_id (int): The ID of the current player.
+            game_state (Dict[str, Any]): The current game state.
+        """
+        prompt = (
+            f"You are Player {player_id} in Stratego.\n"
+            "Your goal is to capture your opponent's Flag or eliminate all of their movable pieces.\n"
+            "Your army has been placed for you on the board, including your Flag, Bombs, and other pieces of varying ranks.\n"
+            "\n"
+            "### Gameplay Instructions\n"
+            "1. **Movement Rules:**\n"
+            "   - On your turn, you can move one piece by one step to an adjacent square (up, down, left, or right) that is already occupied with your pieces.\n"
+            "   - Example: A piece can move from A1 to B1 or A1 to A2 if B1 and A2 are not placed with the player's own pieces.\n"
+            "   - If the selected piece is a Bomb or a Flag, it cannot be moved.\n"
+            # "   - **Scout Movement:** Scouts, on the other hand, can move multiple steps in a straight line (horizontally or vertically), but strictly only on one condition.\n"
+            # "       - The condition is that Scouts cannot jump over any piece (your own or your opponent's).\n"
+            # "       - Example: If there is a piece between the Scout and its destination, the Scout cannot move to the destination.\n"
+            # "       - This will be indicated as an invalid move which makes you lose the game.\n"
+            "2. **Battles:**\n"
+            "   - If you move onto a square occupied by an opponent's piece, then a battle will occur:\n"
+            "     - The piece with the higher rank wins and eliminates the opponent's piece.\n"
+            "     - If the ranks are equal, both pieces are removed from the board.\n"
+            "     - **Special Cases:**\n"
+            "       - Bombs eliminate most attacking pieces except Miners, which defuse Bombs.\n"
+            "       - Spies can defeat the Marshal if the Spy attacks first but lose to all other pieces.\n"
+            "3. **Strategic Goals:**\n"
+            "   - Identify your opponent's pieces through their movements and battles.\n"
+            "   - Protect your Flag while attempting to capture your opponent's Flag.\n"
+            "   - Use Scouts strategically to gain information about your opponent's pieces and attack weak ones.\n"
+            "\n"
+            "### How to Make a Move:\n"
+            "1. Specify the coordinates of the piece you want to move and its destination.\n"
+            "2. Use the format: [A0 B0], where A0 is the source position, and B0 is the destination.\n"
+            "   - Example: To move a piece from row 0, column 0 to row 1, column 0, input [A0 B0].\n"
+            "3. Ensure the destination is valid according to the movement rules above.\n"
+            "\n"
+            "### Important Notes:\n"
+            "- The board will show your pieces and their positions, e.g. MN, MS.\n"
+            "- The board will also show known positions of your opponent's pieces without revealing their ranks, e.g. ?.\n"
+            "- Grids with ~ are lakes and cannot be moved onto.\n"
+            "- As a suggestion, start your game by moving your pieces that are on the front lines to gain information about your opponent's pieces. Player 0 and player 1's frontlines are row D and G respectively.\n"
+            "\n"
+            "Here is the current board state:\n"
+        )
+        return prompt
+
+    def _observe_current_state(self):
+        """
+        Observe the current state of the game and update the state with the rendered board
+        and gives the available moves for the current player.
+        """
+        player_id = self.state.current_player_id
+        available_moves = []
+
+        for row in range(10):
+            for col in range(10):
+                piece = self.board[row][col]
+                if isinstance(piece, dict) and piece['player'] == player_id:
+                    # Skip immovable pieces
+                    if piece['rank'].lower() in ['bomb', 'flag']:
+                        continue
+
+                    # Check if this is a scout (can move multiple squares)
+                    is_scout = piece['rank'].lower() == 'scout'
+                    
+                    # Check all four directions
+                    for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
+                        if is_scout:
+                            # Scout can move multiple squares in this direction
+                            distance = 1
+                            while True:
+                                new_row = row + (dr * distance)
+                                new_col = col + (dc * distance)
+                                
+                                # Check if still within board bounds
+                                if not (0 <= new_row < 10 and 0 <= new_col < 10):
+                                    break
+                                
+                                target = self.board[new_row][new_col]
+                                
+                                if target is None:
+                                    # Empty square - scout can move here and continue
+                                    available_moves.append(f"[{chr(row + 65)}{col} {chr(new_row + 65)}{new_col}]")
+                                    distance += 1
+                                elif isinstance(target, dict) and target['player'] != player_id:
+                                    # Enemy piece - scout can attack but cannot continue past
+                                    available_moves.append(f"[{chr(row + 65)}{col} {chr(new_row + 65)}{new_col}]")
+                                    break
+                                else:
+                                    # Own piece or other obstacle - scout cannot move here or past
+                                    break
+                        else:
+                            # Regular piece - can only move one square
+                            new_row, new_col = row + dr, col + dc
+                            if 0 <= new_row < 10 and 0 <= new_col < 10:
+                                target = self.board[new_row][new_col]
+                                if (target is None or
+                                    (isinstance(target, dict) and target['player'] != player_id)):
+                                    available_moves.append(f"[{chr(row + 65)}{col} {chr(new_row + 65)}{new_col}]")
+
+
+        # new comment(13 Nov 2025) Store the number of available moves in the game state.
+        # This is critical for detecting a "no moves remaining" loss or a stalemate/draw.
+        num_available_moves = len(available_moves)
+        self.state.game_state[f'available_moves_p{player_id}'] = num_available_moves
+
+        #Previous code lines for the observation message
+        self.state.add_observation(
+            message=f"Current Board:\n\n{self._render_board(player_id=player_id, full_board=False)}\nAvailable Moves: " + ", ".join(available_moves),
+            observation_type=ta.ObservationType.GAME_BOARD
+        )
+    
+    def _populate_board(self):
+        """
+        Populates the board with pieces for each player strategically.
+        """
+        for player in range(2):
+            # Define rows for each player
+            back_rows = range(0, 2) if player == 0 else range(8, 10)
+            front_rows = range(2, 4) if player == 0 else range(7, 9)
+            all_rows = range(0, 4) if player == 0 else range(6, 10)
+
+            # Place the Flag strategically
+            while True:
+                row = random.choice(back_rows)
+                col = random.randint(0, 9)
+                if (row, col) not in self.lakes and self.board[row][col] is None:
+                    self.board[row][col] = {'rank': 'Flag', 'player': player}
+                    self.player_pieces[player].append((row, col))
+                    flag_position = (row, col)
+                    break
+
+            # Place Bombs around the Flag if possible
+            bombs_to_place = self.piece_counts['Bomb']
+            bomb_positions = [
+                (flag_position[0] + dr, flag_position[1] + dc)
+                for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)]  # Adjacent cells
+                if 0 <= flag_position[0] + dr < 10 and 0 <= flag_position[1] + dc < 10
+            ]
+
+            for pos in bomb_positions:
+                if bombs_to_place > 0 and self.board[pos[0]][pos[1]] is None and pos not in self.lakes:
+                    self.board[pos[0]][pos[1]] = {'rank': 'Bomb', 'player': player}
+                    self.player_pieces[player].append(pos)
+                    bombs_to_place -= 1
+
+            # Place remaining Bombs at the frontline
+            for _ in range(bombs_to_place):
+                while True:
+                    row = random.choice(front_rows)
+                    col = random.randint(0, 9)
+                    if self.board[row][col] is None and (row, col) not in self.lakes:
+                        self.board[row][col] = {'rank': 'Bomb', 'player': player}
+                        self.player_pieces[player].append((row, col))
+                        break
+
+            # Place other pieces randomly
+            for piece, count in self.piece_counts.items():
+                if piece in ['Flag', 'Bomb']:
+                    continue  # Skip already placed pieces
+                for _ in range(count):
+                    while True:
+                        row = random.choice(all_rows)
+                        col = random.randint(0, 9)
+                        if self.board[row][col] is None and (row, col) not in self.lakes:
+                            self.board[row][col] = {'rank': piece, 'player': player}
+                            self.player_pieces[player].append((row, col))
+                            break
+
+        # Place the lakes
+        for row, col in self.lakes:
+            self.board[row][col] = "~"
+
+        return self.board
+
+
+    
+    def _render_board(self, player_id, full_board: bool = False):
+        """
+        Renders the board state with fixed-width formatting for uniform alignment.
+
+        Args:
+            player_id (int): The player viewing the board.
+            full_board (bool): Whether to render the full board or just the visible pieces.
+        """
+        # Define abbreviations for each piece
+        piece_abbreviations = {
+            'Flag': 'FL', 'Bomb': 'BM', 'Spy': 'SP', 'Scout': 'SC', 'Miner': 'MN',
+            'Sergeant': 'SG', 'Lieutenant': 'LT', 'Captain': 'CP', 'Major': 'MJ',
+            'Colonel': 'CL', 'General': 'GN', 'Marshal': 'MS'
+        }
+
+        res = []
+        column_headers = "   " + " ".join([f"{i:>3}" for i in range(10)])  # Align column numbers
+        res.append(column_headers + "\n")
+
+        for row in range(10):
+            row_label = chr(row + 65)  # Convert row index to a letter (A, B, C, ...)
+            row_render = [f"{row_label:<3}"]  # Add row label with fixed width
+            for col in range(10):
+                if (row, col) in self.lakes:
+                    cell = "  ~ "  # Lakes
+                elif self.board[row][col] is None:
+                    cell = "  . "  # Empty space
+                else:
+                    piece = self.board[row][col]
+                    abbreviation = piece_abbreviations[piece['rank']]
+                    if full_board:
+                        cell = f" {abbreviation.lower() if piece['player'] == 0 else abbreviation.upper()} "  # Full board view
+                    elif piece['player'] == player_id:
+                        displayed_piece = abbreviation.upper()
+                        cell = f" {displayed_piece} "
+                    else:
+                        cell = "  ? "  # Hidden opponent piece
+                row_render.append(cell)
+
+            res.append("".join(row_render) + "\n")
+
+        return "".join(res)
+
+
+
+    def step(self, action: str) -> Tuple[bool, ta.Info]:
+        # new comment(13 Nov 2025) Increment turn counter
+        self.turn_count += 1
+        player_id = self.state.current_player_id
+
+        # new comment(13 Nov 2025) This block fixes Bug #3 (No Moves Remaining).
+        # We check if the player has 0 moves *before* parsing their action.
+        # This prevents an 'Invalid action' penalty when they have no valid moves.
+        num_moves = self.state.game_state.get(f'available_moves_p{player_id}', 1) # Default to 1 to avoid error
+        if num_moves == 0:
+            # The current player cannot move. Check if the *other* player can.
+            if self._has_movable_pieces(1 - player_id):
+                # Opponent still has pieces, so current player loses.
+                reason = f"Player {player_id} has no valid moves remaining. Player {1 - player_id} wins!"
+                self.state.set_winner(player_id=(1 - player_id), reason=reason)
+            else:
+                # Neither player can move. This is a stalemate (draw).
+                reason = "Stalemate: Neither player has any valid moves remaining. The game is a draw."
+                self.state.set_winner(player_id=-1, reason=reason) # -1 means draw
+            
+            # Immediately end the game
+            return self.state.step()
+        
+        # previous code for executing the action
+
+        """ Execute an action in the environment """
+        player_id = self.state.current_player_id
+
+        ## update the observation
+        self.state.add_observation(from_id=player_id, to_id=player_id, message=action, observation_type=ta.ObservationType.PLAYER_ACTION)
+
+        ## action search pattern
+        action_search_pattern = re.compile(r"\[([A-J])([0-9]) ([A-J])([0-9])\]", re.IGNORECASE)
+        match = action_search_pattern.search(action)
+
+        if match is None:
+            reason=f"Invalid action format. Player {player_id} did not input a move in the format [A0 B0]."
+            self.state.set_invalid_move(reason=reason)
+            try:
+                self.state.game_info[player_id]["invalid_move"] = True
+            except Exception:
+                pass
+            self.state.set_winner(player_id=(1 - player_id), reason=reason)
+            return self.state.step()
+        
+        else:
+            src_row, src_col, dest_row, dest_col = match.groups()
+            src_row, dest_row = src_row.upper(), dest_row.upper()
+            source = f"{src_row}{src_col}"
+            dest = f"{dest_row}{dest_col}"
+            src_row, src_col = ord(src_row) - 65, int(src_col)
+            dest_row, dest_col = ord(dest_row) - 65, int(dest_col)
+             
+
+            ## check if the source and destination are valid
+            if self._validate_move(player_id=player_id, src_row=src_row, src_col=src_col, dest_row=dest_row, dest_col=dest_col):
+
+                attacking_piece = self.board[src_row][src_col]
+                target_piece = self.board[dest_row][dest_col]
+
+                if target_piece is None:
+                    ## move to an empty square
+                    self.board[dest_row][dest_col] = attacking_piece
+                    self.board[src_row][src_col] = None
+                    self.player_pieces[player_id].remove((src_row, src_col))
+                    self.player_pieces[player_id].append((dest_row, dest_col))
+                    
+                    ## add the observation to both players separately
+                    message=f"You have moved your piece from {source} to {dest}."
+                    self.state.add_observation(from_id=-1, to_id=player_id, message=message, observation_type=ta.ObservationType.GAME_ACTION_DESCRIPTION)
+
+                    message=f"Player {player_id} has moved a piece from {source} to {dest}."
+                    self.state.add_observation(from_id=-1, to_id=1-player_id, message=message, observation_type=ta.ObservationType.GAME_ACTION_DESCRIPTION)
+
+                else:
+                    ## battle
+                    attacking_rank = self.piece_ranks[attacking_piece['rank']]
+                    target_rank = self.piece_ranks[target_piece['rank']]
+                    if attacking_rank == target_rank:
+                        ## both pieces are removed
+                        self.board[src_row][src_col] = None
+                        self.board[dest_row][dest_col] = None
+                        self.player_pieces[player_id].remove((src_row, src_col))
+                        self.player_pieces[1 - player_id].remove((dest_row, dest_col))
+
+                        ## add the observation to both players separately
+                        message=f"You have moved your piece from {source} to {dest}. The attacking piece was {attacking_piece['rank']} and the destination piece was {target_piece['rank']}. As the ranks are the same, both pieces lost."
+                        self.state.add_observation(from_id=-1, to_id=player_id, message=message, observation_type=ta.ObservationType.GAME_ACTION_DESCRIPTION)
+
+                        message=f"Player {player_id} has moved a piece from {source} to {dest}. The attacking piece was {attacking_piece['rank']} and the destination piece was {target_piece['rank']}. As the ranks are the same, both pieces lost."
+                        self.state.add_observation(from_id=-1, to_id=1 - player_id, message=message, observation_type=ta.ObservationType.GAME_ACTION_DESCRIPTION)
+
+                    elif target_piece['rank'] == 'Bomb':
+                        if attacking_piece['rank'] == 'Miner':
+                            ## Miner defuses the bomb
+                            self.board[dest_row][dest_col] = attacking_piece
+                            self.board[src_row][src_col] = None
+                            self.player_pieces[player_id].remove((src_row, src_col))
+                            self.player_pieces[player_id].append((dest_row, dest_col))
+
+                            # (12 Nov 2025)👇 ADD THIS LINE: Remove the Bomb's coordinate from the defender's list
+                            self.player_pieces[1 - player_id].remove((dest_row, dest_col))
+
+                            ## add the observation to both players separately
+                            message=f"You have moved your piece from {source} to {dest}. The attacking piece was {attacking_piece['rank']} and the destination piece was {target_piece['rank']}. As miners can defuse bombs, you won the battle."
+                            self.state.add_observation(from_id=-1, to_id=player_id, message=message, observation_type=ta.ObservationType.GAME_ACTION_DESCRIPTION)
+
+                            message=f"Player {player_id} has moved a piece from {source} to {dest}. The attacking piece was {attacking_piece['rank']} and the destination piece was {target_piece['rank']}. As miners can defuse bombs, you lost the battle."
+                            self.state.add_observation(from_id=-1, to_id=1-player_id, message=message, observation_type=ta.ObservationType.GAME_ACTION_DESCRIPTION)
+
+                        else:
+                            ## attacking piece is destroyed
+                            self.board[src_row][src_col] = None
+                            self.player_pieces[player_id].remove((src_row, src_col))
+
+                            ## add the observation to both players separately
+                            message=f"You have moved your piece from {source} to {dest}. The attacking piece was {attacking_piece['rank']} and the destination piece was {target_piece['rank']}. As the attacker is not a miner, you lost the battle."
+                            self.state.add_observation(from_id=-1, to_id=player_id, message=message, observation_type=ta.ObservationType.GAME_ACTION_DESCRIPTION)
+
+                            message=f"Player {player_id} has moved a piece from {source} to {dest}. The attacking piece was {attacking_piece['rank']} and the destination piece was {target_piece['rank']}. As the attacker is not a miner, you won the battle."
+                            self.state.add_observation(from_id=-1, to_id=1-player_id, message=message, observation_type=ta.ObservationType.GAME_ACTION_DESCRIPTION)
+
+                    elif target_piece['rank'] == 'Flag':
+                        self.board[dest_row][dest_col] = attacking_piece
+                        self.board[src_row][src_col] = None
+                        self.player_pieces[player_id].remove((src_row, src_col))
+                        self.player_pieces[player_id].append((dest_row, dest_col))
+                        self.player_pieces[1 - player_id].remove((dest_row, dest_col))
+                        ## game over
+
+                        # Changes below: for the Winner setting(12 Nov 2025)
+                        reason=f"Player {player_id} has captured the opponent's flag!"
+                        self.state.set_winner(player_id=player_id,reason=reason)
+
+                        # Immediately end the game and return the final state
+                        return self.state.step()
+
+
+                    elif attacking_piece['rank'] == 'Spy' and target_piece['rank'] == 'Marshal':
+                        ## Spy beats Marshal only if spy attacks first
+                        self.board[dest_row][dest_col] = attacking_piece
+                        self.board[src_row][src_col] = None
+                        self.player_pieces[player_id].remove((src_row, src_col))
+                        self.player_pieces[player_id].append((dest_row, dest_col))
+                        self.player_pieces[1 - player_id].remove((dest_row, dest_col))
+
+                        ## add the observation to both players separately
+                        message=f"You have moved your piece from {source} to {dest}. The attacking piece was {attacking_piece['rank']} and the destination piece was {target_piece['rank']}. As the attacker is a spy and the destination is a marshall, you won the battle."
+                        self.state.add_observation(from_id=-1, to_id=player_id, message=message, observation_type=ta.ObservationType.GAME_ACTION_DESCRIPTION)
+
+                        message=f"Player {player_id} has moved a piece from {source} to {dest}. The attacking piece was {attacking_piece['rank']} and the destination piece was {target_piece['rank']}. As the attacker is a spy and the destination is a marshall, you lost the battle."
+                        self.state.add_observation(from_id=-1, to_id=1-player_id, message=message, observation_type=ta.ObservationType.GAME_ACTION_DESCRIPTION)
+
+                    elif attacking_rank > target_rank:
+                        ## attacker wins
+                        self.board[dest_row][dest_col] = attacking_piece
+                        self.board[src_row][src_col] = None
+                        self.player_pieces[player_id].remove((src_row, src_col))
+                        self.player_pieces[player_id].append((dest_row, dest_col))
+                        self.player_pieces[1 - player_id].remove((dest_row, dest_col))
+
+                        ## add the observation to both players separately
+                        message=f"You have moved your piece from {source} to {dest}. The attacking piece was {attacking_piece['rank']} and the destination piece was {target_piece['rank']}. As the attacker is a higher rank than the destination, you won the battle."
+                        self.state.add_observation(from_id=-1, to_id=player_id, message=message, observation_type=ta.ObservationType.GAME_ACTION_DESCRIPTION)
+
+                        message=f"Player {player_id} has moved a piece from {source} to {dest}. The attacking piece was {attacking_piece['rank']} and the destination piece was {target_piece['rank']}. As the attacker is a higher rank than the destination, you lost the battle."
+                        self.state.add_observation(from_id=-1, to_id=1-player_id, message=message, observation_type=ta.ObservationType.GAME_ACTION_DESCRIPTION)
+
+                    else:
+                        ## defender wins
+                        self.board[src_row][src_col] = None
+                        self.player_pieces[player_id].remove((src_row, src_col))
+
+                        ## add the observation to both players separately
+                        message=f"You have moved your piece from {source} to {dest}. The attacking piece was {attacking_piece['rank']} and the destination piece was {target_piece['rank']}. As the attacker is a lower rank than the destination, you lost the battle."
+                        self.state.add_observation(from_id=-1, to_id=player_id, message=message, observation_type=ta.ObservationType.GAME_ACTION_DESCRIPTION)
+
+                        message=f"Player {player_id} has moved a piece from {source} to {dest}. The attacking piece was {attacking_piece['rank']} and the destination piece was {target_piece['rank']}. As the attacker is a lower rank than the destination, you won the battle."
+                        self.state.add_observation(from_id=-1, to_id=1-player_id, message=message, observation_type=ta.ObservationType.GAME_ACTION_DESCRIPTION)
+            else:
+                # invalid move -> immediate loss
+                try:
+                    self.state.game_info[player_id]["invalid_move"] = True
+                except Exception:
+                    pass
+                self.state.set_winner(player_id=(1 - player_id), reason="Illegal move.")
+                return self.state.step()
+        # new comment(13 Nov 2025) This block checks for win/draw conditions
+        # *after* a move has been successfully made.
+
+        # 1. Check for Elimination Win (opponent has no movable pieces left)
+        winner = self._check_winner()
+        if winner is not None:
+            reason=f"Player {winner} wins! Player {1 - winner} has no more movable pieces."
+            self.state.set_winner(player_id=winner, reason=reason)
+
+        # 2. Check for Stalemate (Draw)
+        elif self._check_stalemate():
+            reason = "Stalemate: Neither player has any valid moves remaining. The game is a draw."
+            self.state.set_winner(player_id=-1, reason=reason) # -1 means draw
+        
+        # 3. Check for Turn Limit (Draw) - This fixes Bug #2
+        elif self.turn_count > 1000: # You can adjust this number
+            reason = f"Game ended in a draw (turn limit of {self.turn_count} moves exceeded)."
+            self.state.set_winner(player_id=-1, reason=reason)
+
+        ## update the rendered board
+        self.state.game_state["rendered_board"] = self._render_board(player_id=player_id, full_board=True)
+
+        result = self.state.step()
+        
+        # We must observe the *next* player's state *before* returning
+        if not result[0]: # If game is not done
+             self._observe_current_state()
+             
+        return result
+    
+    def _validate_move(self, player_id, src_row, src_col, dest_row, dest_col):
+        """
+        Validates the move based on the game rules.
+
+        Args:
+            player_id (int): The ID of the player making the move.
+            src_row (int): The row of the source position.
+            src_col (int): The column of the source position.
+            dest_row (int): The row of the destination position.
+            dest_col (int): The column of the destination position.
+        """
+        if not (0 <= src_row < 10 and 0 <= src_col < 10 and 0 <= dest_row < 10 and 0 <= dest_col < 10):
+            reason=f"Invalid action format. Player {player_id} did not input valid coordinates."
+            self.state.set_invalid_move(reason=reason)
+            return False
+        
+        if self.board[src_row][src_col] is None or self.board[src_row][src_col]['player'] != player_id:
+            reason=f"Invalid action format. Player {player_id} must move one of their own pieces."
+            self.state.set_invalid_move(reason=reason)
+            return False
+        
+        if abs(src_row - dest_row) + abs(src_col - dest_col) != 1 and self.board[src_row][src_col]['rank'].lower() == 'scout':
+            ## check if there's a piece in between the source and destination
+            if src_row == dest_row:
+                for col in range(min(src_col, dest_col) + 1, max(src_col, dest_col)):
+                    if self.board[src_row][col] is not None:
+                        reason=f"Invalid action format. Player {player_id} cannot move a scout through other pieces."
+                        self.state.set_invalid_move(reason=reason)
+                        return False
+            elif src_col == dest_col:
+                for row in range(min(src_row, dest_row) + 1, max(src_row, dest_row)):
+                    if self.board[row][src_col] is not None:
+                        reason=f"Invalid action format. Player {player_id} cannot move a scout through other pieces."
+                        self.state.set_invalid_move(reason=reason)
+                        return False
+            else:
+                reason=f"Invalid action format. Player {player_id} cannot move a scout diagonally."
+                self.state.set_invalid_move(reason=reason)
+                return False
+            
+        if abs(src_row - dest_row) + abs(src_col - dest_col) != 1 and self.board[src_row][src_col]['rank'].lower() != 'scout':
+            ## !  - by right, only scouts can move more than one square at a time but we are not implementing that yet
+            reason=f"Invalid action format. Pieces, apart from scouts, can only move one square at a time."
+            self.state.set_invalid_move(reason=reason)
+            return False
+        
+        if self.board[dest_row][dest_col] is not None:
+            if (dest_row, dest_col) in self.lakes:
+                reason=f"Invalid action format. Player {player_id} cannot move into the lake."
+                self.state.set_invalid_move(reason=reason)
+                return False
+            
+            elif self.board[dest_row][dest_col]['player'] == player_id:
+                reason=f"Invalid action format. Player {player_id} cannot move onto their own piece."
+                self.state.set_invalid_move(reason=reason)
+                return False
+        
+        if self.board[src_row][src_col]['rank'].lower() in ['bomb','flag']:
+            reason=f"Invalid action format. Player {player_id} cannot move a bomb or flag."
+            self.state.set_invalid_move(reason=reason)
+            return False
+        
+        return True
+    
+    #Working on below for new code to deal with Non Type error
+    # def _check_winner(self):
+    #     """
+    #     determine which player has no more pieces that are not bombs or flags.
+    #     """
+    #     for player in range(2):
+    #         if all([self.board[row][col]['rank'] in ['Bomb', 'Flag'] for row, col in self.player_pieces[player]]):
+    #             return 1 - player
+    #     return None
+
+    def _check_winner(self):
+        """
+        Determine which player has no more pieces that are not bombs or flags.
+        FIX: Skips coordinates that are empty on the board (already removed).
+        """
+        for player in range(2):
+            # NEW LOGIC: Filter out None/empty squares before checking rank
+            movable_pieces_remain = any([
+                self.board[row][col] is not None and self.board[row][col]['rank'] not in ['Bomb', 'Flag'] 
+                for row, col in self.player_pieces[player]
+            ])
+            
+            # Original logic: If NO movable pieces remain, the opponent (1 - player) wins.
+            if not movable_pieces_remain:
+                return 1 - player
+        return None
+    
+    # new comment(13 Nov 2025) These are new helper methods for win/draw checking.
+
+    def _has_movable_pieces(self, player_id: int) -> bool:
+        """Helper function to check if a player has any movable pieces left."""
+        # This uses the same logic as your _check_winner, just isolated
+        return any([
+            self.board[row][col] is not None and self.board[row][col]['rank'] not in ['Bomb', 'Flag'] 
+            for row, col in self.player_pieces[player_id]
+        ])
+
+    def _check_stalemate(self) -> bool:
+        """
+        Checks for two types of stalemate (draw):
+        1. Neither player has any movable pieces left.
+        2. Both players have 0 available moves (e.g., all pieces are blocked).
+        """
+        # 1. Check if both players are eliminated (e.g., last two pieces trade)
+        p0_has_movable = self._has_movable_pieces(0)
+        p1_has_movable = self._has_movable_pieces(1)
+        if not p0_has_movable and not p1_has_movable:
+            return True # Both players lost all pieces
+
+        # 2. Check if both players are blocked (0 moves)
+        # This relies on _observe_current_state being called
+        p0_move_count = self.state.game_state.get('available_moves_p0', 1) # Default to 1
+        p1_move_count = self.state.game_state.get('available_moves_p1', 1)
+        
+        if p0_move_count == 0 and p1_move_count == 0:
+            return True # Both players are blocked
+            
+        return False