def __init__(self, game_name, sim=None):
        """
        Construct a new instance.

        Parameters:
            game_name: one of "breakout", "amidar", etc.
            sim: optionally a Rust pointer to an existing simulator.
        """
        if sim is None:
            sim = lib.simulator_alloc(game_name.encode('utf-8'))
        # sim should be a pointer
        self.game_name = game_name
        self.__sim = sim 
        self.deleted = False

    def from_json(self, config_js: Union[Dict[str, Any], str]):
        """Mutably update this simulator/config with the replacement json."""
        old_sim = self.__sim
        self.__sim = lib.simulator_from_json(self.get_simulator(), json_str(config_js).encode('utf-8'))
        del old_sim

    def get_frame_height(self) -> int:
        """Get the height in pixels of the frames this game renders."""
        return lib.simulator_frame_height(self.__sim)

    def get_frame_width(self) -> int:
        """Get the width in pixels of the frames this game renders."""
        return lib.simulator_frame_width(self.__sim)

    def get_simulator(self):
        """Get access to the raw simulator pointer."""
        return self.__sim

    def new_game(self) -> 'State':
        """Start a new game."""
        return State(self)

    def schema_for_config(self):
        """Get the JSON Schema for any config for this game."""
        return json.loads(rust_str(lib.simulator_schema_for_config(self.__sim)))

    def schema_for_state(self) -> Dict[str, Any]:
        """Get the JSON Schema for any state for this game."""
        return json.loads(rust_str(lib.simulator_schema_for_state(self.__sim)))

    def set_seed(self, seed: int):
        """Configure the random number generator that spawns new game states.

        Parameters:
            seed: a parameter to reset the built-in random number generator.
        """
        lib.simulator_seed(self.__sim, seed)

    def state_from_json(self, js: Union[Dict[str, Any], str]) -> 'State':
        """Generate a State from the state json and this configuration.

        Parameters:
            js: a JSON object or string containing a serialized state.
        """
        state = lib.state_from_json(self.get_simulator(), json_str(js).encode('utf-8'))
        return State(self, state=state)

    def to_json(self) -> Dict[str, Any]:
        """Get the configuration of this simulator/config as JSON"""
        json_str = rust_str(lib.simulator_to_json(self.get_simulator()))
        return json.loads(str(json_str))