# Imports
from pyrat import Game, PlayerSkin
from players.random2 import Random2
from players.random3 import Random3

# Run the script
if __name__ == "__main__":

    # First, let's create a game with custom arguments
    game = Game(mud_percentage=20.0, wall_percentage=60.0, maze_width=13, maze_height=10, nb_cheese=1)

    # Instantiate players with different skins, and add them to the game in distinct teams
    player_1 = Random2(skin=PlayerSkin.RAT)
    player_2 = Random3(skin=PlayerSkin.PYTHON)
    game.add_player(player_1, team="Team Ratz")
    game.add_player(player_2, team="Team Pythonz")

    # Start the game
    stats = game.start()

class Random3 (Player):

    """
    *(This class inherits from* ``Player`` *).*

    This player is an improvement of the ``Random2`` player.
    Here, we add elements that help us explore better the maze.
    More precisely, we keep a set of cells that have already been visited in the game.
    Then, at each turn, we choose in priority a random move among those that lead us to an unvisited cell.
    If no such move exists, we move randomly.
    """

# Instantiate a variable of type Random3
p = Random3(name="Mon super joueur", skin=PlayerSkin.MARIO)

def __init__ ( self,
               *args:    object,
               **kwargs: object
             ) ->        None:

    """
    Initializes a new instance of the class.
    Here, the constructor is only used to initialize a set that will keep track of visited cells.
    This set can later be updated at each turn of the game to avoid going back to cells that have already been visited.

    Args:
        args:   Arguments to pass to the parent constructor.
        kwargs: Keyword arguments to pass to the parent constructor.
    """

    # Inherit from parent class
    super().__init__(*args, **kwargs)

    # We create an attribute to keep track of visited cells
    # We will initialize it in the ``preprocessing()`` method to allow the game to be reset
    # Otherwise, the set would keep the cells visited in previous games
    self.visited_cells = None

def preprocessing ( self,
                    maze:       Maze,
                    game_state: GameState,
                  ) ->          None:
    
    """
    *(This method redefines the method of the parent class with the same name).*

    This method is called once at the beginning of the game.
    Here, we just initialize the set of visited cells.

    Args:
        maze:       An object representing the maze in which the player plays.
        game_state: An object representing the state of the game.
    """

    # Initialize visited cells
    self.visited_cells = set()

def turn ( self,
           maze:       Maze,
           game_state: GameState,
         ) ->          Action:

    """
    *(This method redefines the method of the parent class with the same name).*

    It is called at each turn of the game.
    It returns an action to perform among the possible actions, defined in the ``Action`` enumeration.
    We also update the set of visited cells at each turn.

    Args:
        maze:       An object representing the maze in which the player plays.
        game_state: An object representing the state of the game.
    
    Returns:
        One of the possible actions.
    """

    # Mark current cell as visited
    my_location = game_state.player_locations[self.get_name()]
    if my_location not in self.visited_cells:
        self.visited_cells.add(my_location)

    # Return an action
    action = self.find_next_action(maze, game_state)
    return action