def __init__(self, sim: Simulator, state=None):
        """
        Construct a new State instance wrapper.

        Parameters:
            sim: The simulator responsible for this state.
            state: Optional pointer to a state to use (otherwise it will create one). 
        """
        self.__state = state or lib.state_alloc(sim.get_simulator())
        self.game_name = sim.game_name
        self.deleted = False

    def game_over(self):
        """Determine whether the game has ended; i.e., the player has run out of lives.

        >>> assert self.lives() < 0 == self.game_over()
        """
        return self.lives() < 0

    def get_state(self):
        """Get the raw state pointer."""
        assert(self.__state is not None)
        return self.__state

    def level(self) -> int:
        """How many levels have been completed in the current state?"""
        return lib.state_level(self.__state)

    def lives(self) -> int:
        """How many lives are remaining in the current state?"""
        return lib.state_lives(self.__state)

    def query_json(self, query: str, args: Union[Dict[str, Any], str]="null") -> Dict[str, Any]:
        """
        Ask a question of the Rust state; queries are currently implemented manually.

        Parameters:
            query: the message to send to the rust state.
            args: the arguments to send to the rust state, defaults to "null".

        Returns:
            response: A JSON response loaded to python objects.

        Raises:
            ValueError: if anything goes wrong with the query

        ```python
        with Toybox("breakout") as tb:
          tb.query_json("bricks_remaining")
        ```
        """
        txt = rust_str(lib.state_query_json(self.__state, json_str(query).encode('utf-8'), json_str(args).encode('utf-8')))
        try:
            out = json.loads(txt)
        except:
            raise ValueError(txt)
        return out

    def render_frame(self, sim: Simulator, grayscale: bool =True) -> np.array:
        """Generate an image from the current frame state object.

        Parameters:
            sim: the simulator to use; this tells us the width/height necessary.
            grayscale: True if we want to render in grayscale rather than in color (RGBA).
        """
        if grayscale:
            return self.render_frame_grayscale(sim)
        else:
            return self.render_frame_color(sim)

    def render_frame_color(self, sim: Simulator) -> np.array:
        """Generate an RGBA image from the current frame state object.

        Parameters:
            sim: the simulator to use; this tells us the width/height necessary.
        """
        h = sim.get_frame_height()
        w = sim.get_frame_width()
        rgba = 4
        size = h * w  * rgba
        frame = np.zeros(size, dtype='uint8')
        frame_ptr = ffi.cast("uint8_t *", frame.ctypes.data)
        lib.render_current_frame(frame_ptr, size, False, sim.get_simulator(), self.__state)
        return np.reshape(frame, (h,w,rgba))

    def render_frame_grayscale(self, sim: Simulator) -> np.array:
        """Generate a grayscale image from the current frame state object.

        Parameters:
            sim: the simulator to use; this tells us the width/height necessary.
        """
        h = sim.get_frame_height()
        w = sim.get_frame_width()
        size = h * w 
        frame = np.zeros(size, dtype='uint8')
        frame_ptr = ffi.cast("uint8_t *", frame.ctypes.data)
        lib.render_current_frame(frame_ptr, size, True, sim.get_simulator(), self.__state)
        return np.reshape(frame, (h,w,1))

    def render_frame_rgb(self, sim: Simulator) -> np.array:
        """Generate an RGB image from the current frame state object.

        Parameters:
            sim: the simulator to use; this tells us the width/height necessary.
        """
        rgba_frame = self.render_frame_color(sim)
        return rgba_frame[:,:,:3]

    def score(self) -> int:
        """How many points have been earned in the current state?"""
        return lib.state_score(self.__state)

    def to_json(self) -> Dict[str, Any]:
        """Get a JSON representation of the state."""
        json_str = rust_str(lib.state_to_json(self.__state))
        return json.loads(str(json_str))