docs: def compute_fov(
      transparency: np.array,
      x: int,
      y: int,
      radius: int = 0,
      light_walls: bool = True,
      algorithm: int = tcod.constants.FOV_RESTRICTIVE,
  ) -> np.array:
      """Return the visible area of a field-of-view computation.
  
      `transparency` is a 2 dimensional array where all non-zero values are
      considered transparent.  The returned array will match the shape of this
      array.
  
      `x` and `y` are the 1st and 2nd coordinates of the origin point.  Areas
      are visible when they can be seen from this point-of-view.
  
      `radius` is the maximum view distance from `x`/`y`.  If this is zero then
      the maximum distance is used.
  
      If `light_walls` is True then visible obstacles will be returned, otherwise
      only transparent areas will be.
  
      `algorithm` is the field-of-view algorithm to run.  The default value is
      `tcod.FOV_RESTRICTIVE`.
      The options are:
  
      * `tcod.FOV_BASIC`:
        Simple ray-cast implementation.
      * `tcod.FOV_DIAMOND`
      * `tcod.FOV_SHADOW`:
        Recursive shadow caster.
      * `tcod.FOV_PERMISSIVE(n)`:
        `n` starts at 0 (most restrictive) and goes up to 8 (most permissive.)
      * `tcod.FOV_RESTRICTIVE`
  
      .. versionadded:: 9.3
  
      Example::
  
          >>> explored = np.zeros((3, 5), dtype=bool, order="F")
          >>> transparency = np.ones((3, 5), dtype=bool, order="F")
          >>> transparency[:2, 2] = False
          >>> transparency  # Transparent area.
          array([[ True,  True, False,  True,  True],
                 [ True,  True, False,  True,  True],
                 [ True,  True,  True,  True,  True]]...)
          >>> visible = tcod.map.compute_fov(transparency, 0, 0)
          >>> visible  # Visible area.
          array([[ True,  True,  True, False, False],
                 [ True,  True,  True, False, False],
                 [ True,  True,  True,  True, False]]...)
          >>> explored |= visible  # Keep track of an explored area.
      """
      if len(transparency.shape) != 2:
          raise TypeError(
              "transparency must be an array of 2 dimensions"
              " (shape is %r)" % transparency.shape
          )
      map_ = Map(transparency.shape[1], transparency.shape[0])
      map_.transparent[...] = transparency
      map_.compute_fov(x, y, radius, light_walls, algorithm)
      return map_.fov