def compute_fov(
self,
x: int,
y: int,
radius: int = 0,
light_walls: bool = True,
algorithm: int = tcod.constants.FOV_RESTRICTIVE,
) -> None:
"""Compute a field-of-view on the current instance.
Args:
x (int): Point of view, x-coordinate.
y (int): Point of view, y-coordinate.
radius (int): Maximum view distance from the point of view.
A value of `0` will give an infinite distance.
light_walls (bool): Light up walls, or only the floor.
algorithm (int): Defaults to tcod.FOV_RESTRICTIVE
If you already have transparency in a NumPy array then you could use
:any:`tcod.map_compute_fov` instead.
"""
if not (0 <= x < self.width and 0 <= y < self.height):
warnings.warn(
"Index (%r, %r) is outside of this maps shape (%r, %r)."
"\nThis will raise an error in future versions."
% (x, y, self.width, self.height),
RuntimeWarning,
stacklevel=2,
)
lib.TCOD_map_compute_fov(
self.map_c, x, y, radius, light_walls, algorithm
)
def compute_fov(
self,
x: int,
y: int,
radius: int = 0,
light_walls: bool = True,
algorithm: int = tcod.constants.FOV_RESTRICTIVE,
) -> None:
"""Compute a field-of-view on the current instance.
Args:
x (int): Point of view, x-coordinate.
y (int): Point of view, y-coordinate.
radius (int): Maximum view distance from the point of view.
A value of `0` will give an infinite distance.
light_walls (bool): Light up walls, or only the floor.
algorithm (int): Defaults to tcod.FOV_RESTRICTIVE
If you already have transparency in a NumPy array then you could use
:any:`tcod.map_compute_fov` instead.
"""
lib.TCOD_map_compute_fov(
self.map_c, x, y, radius, light_walls, algorithm
)
def compute_fov(self,
x,
y,
radius=0,
light_walls=True,
algorithm=lib.FOV_RESTRICTIVE):
"""Compute a field-of-view on the current instance.
Args:
x (int): Point of view, x-coordinate.
y (int): Point of view, y-coordinate.
radius (int): Maximum view distance from the point of view.
A value of `0` will give an infinite distance.
light_walls (bool): Light up walls, or only the floor.
algorithm (int): Defaults to tcod.FOV_RESTRICTIVE
"""
lib.TCOD_map_compute_fov(self.map_c, x, y, radius, light_walls,
algorithm)
def compute_fov(
transparency: np.ndarray,
pov: Tuple[int, int],
radius: int = 0,
light_walls: bool = True,
algorithm: int = tcod.constants.FOV_RESTRICTIVE,
) -> np.ndarray:
"""Return a boolean mask of the area covered by a field-of-view.
`transparency` is a 2 dimensional array where all non-zero values are
considered transparent. The returned array will match the shape of this
array.
`pov` is the point-of-view origin point. Areas are visible if they can
be seen from this position. `pov` should be a 2D index matching the axes
of the `transparency` array, and must be within the bounds of the
`transparency` array.
`radius` is the maximum view distance from `pov`. 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
.. versionchanged:: 11.0
The parameters `x` and `y` have been changed to `pov`.
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.
.. seealso::
:any:`numpy.nonzero`
:any:`numpy.choose`
:any:`numpy.select`
"""
transparency = np.asarray(transparency)
if len(transparency.shape) != 2:
raise TypeError(
"transparency must be an array of 2 dimensions"
" (shape is %r)" % transparency.shape
)
if isinstance(pov, int):
raise TypeError(
"The tcod.map.compute_fov function has changed. The `x` and `y`"
" parameters should now be given as a single tuple."
)
if not (
0 <= pov[0] < transparency.shape[0]
and 0 <= pov[1] < transparency.shape[1]
):
warnings.warn(
"Given pov index %r is outside the array of shape %r."
"\nThis will raise an error in future versions."
% (pov, transparency.shape),
RuntimeWarning,
stacklevel=2,
)
map_ = Map(transparency.shape[1], transparency.shape[0])
map_.transparent[...] = transparency
lib.TCOD_map_compute_fov(
map_.map_c, pov[1], pov[0], radius, light_walls, algorithm
)
return map_.fov