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(
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.where`: For selecting between two arrays using a boolean
array, like the one returned by this function.
:any:`numpy.select`: Select between arrays based on multiple
conditions.
"""
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_buffer = np.empty(
transparency.shape,
dtype=[("transparent", bool), ("walkable", bool), ("fov", bool)],
)
map_cdata = ffi.new(
"struct TCOD_Map*",
(
map_buffer.shape[1],
map_buffer.shape[0],
map_buffer.shape[1] * map_buffer.shape[0],
ffi.from_buffer("struct TCOD_MapCell*", map_buffer),
),
)
map_buffer["transparent"] = transparency
lib.TCOD_map_compute_fov(map_cdata, pov[1], pov[0], radius, light_walls,
algorithm)
return map_buffer["fov"]