def __init__(self, game_name: str, grayscale: bool=True, frameskip: int=0):
        """
        Construct a new Toybox state/game wrapper. Use this in a with block!

        Parameters:
            game_name: One of "breakout", "space_invaders", "amidar", etc.
            grayscale: Toybox can render directly to grayscale, saving time.
            frameskip: When an action is submitted, for how many extra frames should it be applied?
        """
        self.game_name = game_name
        self.frames_per_action = frameskip+1
        self.rsimulator = Simulator(game_name)
        self.rstate = self.rsimulator.new_game()
        self.grayscale = grayscale
        self.deleted = False
        self.new_game()

    def apply_action(self, action_input_obj: Input):
        """Takes an [ctoybox.Input][] action and applies it - unlike the ALE actions (which allow some permutations) this allows for fine-grained button pressing.

        This applies the action *k* times, where *k* based on the frameskip passed to the Toybox constructor.

        Parameters:
            action_input_obj: An instance of the [ctoybox.Input][] class.
        """
        # implement frameskip(k) by sending the action (k+1) times every time we have an action.
        js = json_str(action_input_obj).encode('UTF-8')
        js_cstr = ffi.new("char []", js)
        for _ in range(self.frames_per_action):
            lib.state_apply_action(self.rstate.get_state(), js_cstr)

    def apply_ale_action(self, action_int: int):
        """Takes an integer corresponding to an action, as specified in ALE.

        This applies the action *k* times, where *k* based on the frameskip passed to the Toybox constructor.

        ```python
        ALE_INPUT_MAPPING = {
            0 : "NOOP",
            1 : "FIRE",
            2 : "UP",
            3 : "RIGHT",
            4 : "LEFT",
            5 : "DOWN",
            6 : "UPRIGHT",
            7 : "UPLEFT",
            8 : "DOWNRIGHT",
            9 : "DOWNLEFT",
            10 : "UPFIRE",
            11 : "RIGHTFIRE",
            12 : "LEFTFIRE",
            13 : "DOWNFIRE",
            14 : "UPRIGHTFIRE",
            15 : "UPLEFTFIRE",
            16 : "DOWNRIGHTFIRE",
            17 : "DOWNLEFTFIRE"
        }
        ```

        Parameters:
            action_int: A number from 0 to 17 inclusive.
        """      
        # implement frameskip(k) by sending the action (k+1) times every time we have an action.
        for _ in range(self.frames_per_action):
            if not lib.state_apply_ale_action(self.rstate.get_state(), action_int):
                raise ValueError("Expected to apply action, but failed: {0}".format(action_int))

    def config_to_json(self) -> Dict[str, Any]:
        """Get the state's JSON representation as a python dict."""
        return self.rsimulator.to_json()

    def game_over(self) -> bool:
        """
        Check for game over condition.

        Returns:
            ``True`` if the player has run out of lives in the current state.
        """
        return self.rstate.game_over()

    def get_height(self) -> int:
        """Get the height of the rendered game in pixels."""
        return self.rsimulator.get_frame_height()

    def get_legal_action_set(self) -> List[int]:
        """Get the set of actions consumed by this game: they are ALE numbered."""
        sim = self.rsimulator.get_simulator()
        txt = rust_str(lib.simulator_actions(sim))
        try:
            out = json.loads(txt)
        except:
            raise ValueError(txt)
        return out

    def get_level(self) -> int:
        """
        Access the number of levels.

        Returns:
            The number of levels completed in the current state."""
        return self.rstate.level()

    def get_lives(self) -> int:
        """Access the number of lives.

        Returns:
            The number of lives remaining in the current state."""
        return self.rstate.lives()

    def get_rgb_frame(self) -> np.array:
        """Get the RGB frame as a numpy array."""
        return self.rstate.render_frame_rgb(self.rsimulator)

    def get_score(self) -> int:
        """Access the current score.

        Returns:
            The number of points earned in the current state."""
        return self.rstate.score()

    def get_state(self) -> np.array:
        """This state here actually refers to the graphical, RGBA or grayscale representation of the current state."""
        return self.rstate.render_frame(self.rsimulator, self.grayscale)

    def get_width(self) -> int:
        """Get the width of the rendered game in pixels."""
        return self.rsimulator.get_frame_width()

    def new_game(self):
        """
        Modify this Toybox wrapper to have a new_game state.

        Important:
            This discards the old state!
        """
        old_state = self.rstate
        del old_state
        self.rstate = self.rsimulator.new_game()

    def query_state_json(self, query: str, args: Union[Dict[str, Any], str]="null") -> Dict[str, Any]: 
        """Submit a query to the game's query system -- faster than accessing the whole JSON for quick introspection.

        Parameters:
            query: the query string to send to the game.
            args: a JSON argument to attach to the query string.
        """
        return self.rstate.query_json(query, args)

    def save_frame_image(self, path: str, grayscale: bool =False):
        """Save the current frame image to a PNG file.

        Parameters:
            path: the filename to save to.
            grayscale: whether images should be saved in color or black & white.
        """
        img = None
        if grayscale:
            img = Image.fromarray(self.rstate.render_frame_grayscale(self.rsimulator), 'L') 
        else:
            img = Image.fromarray(self.rstate.render_frame_color(self.rsimulator), 'RGBA')
        img.save(path, format='png')

    def schema_for_config(self) -> Dict[str, Any]:
        """Get the JSON Schema for the Config object."""
        return self.rsimulator.schema_for_config()

    def schema_for_state(self) -> Dict[str,Any]:
        """Get the JSON Schema for the frame State object."""
        return self.rsimulator.schema_for_state()

    def set_seed(self, seed: int):
        """Control the random number generator of the config -- only affects a new_game.

        Parameters:
            seed: a parameter to reset the built-in random number generator.
        """
        self.rsimulator.set_seed(seed)

    def state_to_json(self) -> Dict[str, Any]:
        """Get the state's JSON representation as a python object."""
        return self.rstate.to_json()

    def to_state_json(self) -> Dict[str, Any]:
        """Get the state's JSON representation as a python dict.

        Important:
            This method is deprecated; please use ``state_to_json`` instead!
        """
        return self.state_to_json()

    def write_config_json(self, config_js: Dict[str, Any]):
        """Overwrite the config's JSON representation from a python dict. 

        It is likely that some changes will be seen until you call new_game()

        Parameters:
            config_js: the python representation of the config JSON
        """
        # from_json replaces simulator!
        self.rsimulator.from_json(config_js)
        # new_game replaces state!
        self.new_game()

    def write_state_json(self, js: Dict[str, Any]):
        """Overwrite the state's JSON representation from a python dict.

        Parameters:
            js: the python representation of the JSON state.
        """
        old_state = self.rstate
        del old_state
        self.rstate = self.rsimulator.state_from_json(js)