# Customize the game elements
CONFIG = {"maze_width": 10, "maze_height": 10, "nb_cheese": 1}

# Instantiate a game with specified arguments
game = Game(**CONFIG)

# Instantiate a player and add it to the game
player = Random1()
game.add_player(player)

# Start the game
stats = game.start()

class ExamplePlayer (Player):

    """
        This is an example player, meant to illustrate how to create a player.
        Here, it is named "ExamplePlayer" you can customize this.
        We will see in the next slides how to specify a few things.
    """

# Instantiate a variable of type ExamplePlayer
p = ExamplePlayer(name="My example player")

class ExamplePlayer (Player):

    ...

    def __init__ (self, *args, **kwargs):

        """
            This function is the constructor of the class.
            When an object is instantiated, this method is called to initialize the object.
            This is where you should define the attributes of the object and set their initial values.
            Arguments *args and **kwargs are used to pass arguments to the parent constructor.
            This is useful not to declare again all the parent's attributes in the child class.
            In:
                * self:   Reference to the current object.
                * args:   Arguments to pass to the parent constructor.
                * kwargs: Keyword arguments to pass to the parent constructor.
            Out:
                * A new instance of the class.
        """

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

        # Here, you can initialize attributes, e.g.,
        self.preprocessing_results = None

class ExamplePlayer (Player):

    ...

    def preprocessing (self, maze, game_state):
        
        """
            This method is called once at the beginning of the game.
            It is optional to define it.
            In:
                * self:       Reference to the current object.
                * maze:       An object representing the maze in which the player plays.
                * game_state: An object representing the state of the game.
            Out:
                * None.
        """
        
        # This is where you describe what to do at the beginning of the game
        # To make these results accessible to the turns, store them as class attributes, e.g.
        self.preprocessing_results = some_computation(maze, game_state)

class ExamplePlayer (Player):

    ...

    def turn (self, maze, game_state):

        """
            This method is called at each turn of the game.
            It returns an action to perform among the possible actions, defined in the Action enumeration.
            In:
                * self:       Reference to the current object.
                * maze:       An object representing the maze in which the player plays.
                * game_state: An object representing the state of the game.
            Out:
                * action: One of the possible actions.
        """

        # This is where you describe what to do at each turn of the game
        # Don't forget to return an action, e.g.,
        return Action.NOTHING

class ExamplePlayer (Player):

    ...

    def postprocessing (self, maze, game_state, stats):

        """
            This method is called once at the end of the game.
            It is optional to define it.
            In:
                * self:       Reference to the current object.
                * maze:       An object representing the maze in which the player plays.
                * game_state: An object representing the state of the game.
                * stats:      Statistics about the game.
            Out:
                * None.
        """

        # This is where you write the code that will be executed once the game is over
        # Typically, this can be organized for cleaning temporary files, etc.