def update_fov(self) -> None:
if self.effect:
if self.effect.type == "blindness":
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=1,
)
#do not add visible tiles to explored
elif self.effect.type == "clarity":
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=1000,
)
else:
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=8,
)
else:
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=8,
)
self.game_map.explored |= self.game_map.visible #visible tiles get added to explore
def update_fov(self) -> None:
""" Recompute the visible area based on the player's point of view. """
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"], (self.player.x, self.player.y),
radius=8)
# If a tile is 'visible' it should be added to 'explored'
self.game_map.explored |= self.game_map.visible
def update_fov(self) -> None:
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=8,
)
self.game_map.explored |= self.game_map.visible
def update_fov(self) -> None:
"""Recompute the visible area based on the player POV"""
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=PLAYER_FOV_RADIUS,
)
self.game_map.explored |= self.game_map.visible
def update_fov(self) -> None:
"""Recompute the visible area based on the player's field of view."""
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=8,
)
self.game_map.explored |= self.game_map.visible
def update_fov(self) -> None:
"""Recompute the visible area based on the players point of view."""
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"], (self.player.x, self.player.y),
radius=8,
algorithm=FOV_BASIC)
# If a tile is "visible" it should be added to "explored".
self.game_map.explored |= self.game_map.visible
def update_fov(self) -> None:
# Recomputer visible area based on player's point of view
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=8,
)
# If a tile is visible, it should be considered explored
self.game_map.explored |= self.game_map.visible
def update_fov(self) -> None:
""" Recompute visible area based on player's point of view. """
self.game_map.visible[:] = compute_fov(
transparency=self.game_map.tiles["transparent"],
pov=(self.player.x, self.player.y),
radius=8,
)
# If a tile is visible, it should be marked as explored.
self.game_map.explored |= self.game_map.visible
def recompute_fov(fov_map, player, temporary_vision, light_walls=True, algorithm=0):
x, y = player.position.x, player.position.y
radius = player.fighter.fov_range
# TODO: Enable FOV for an open or closed door
for _x, _y in temporary_vision:
fov_map.transparent[_y][_x] = True
return compute_fov(fov_map.transparent.T, (x, y), radius, light_walls, algorithm)
def update_fov(self) -> None:
"""Recompute the visible area based on where the player is"""
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=8,
)
# if a tile is visible it should be added to the explored array
self.game_map.explored |= self.game_map.visible
def update_fov(self) -> None:
""" Recompute visible area based on player FOV """
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=8,
)
# if a tile is "visible", add to "explored"
self.game_map.explored |= self.game_map.visible
def update_fov(self) -> None:
"""recompute the visible area based on player pov"""
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=8,
)
"""if a tile is visible it should be added to explored"""
self.game_map.explored |= self.game_map.visible
def update_fov(self) -> None:
# renders visible area
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=8
)
# If a tile is "visible" it should be added to "explored".
self.game_map.explored |= self.game_map.visible
def update_fov(self) -> None:
# Recompute the visible area based on the players POV
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=8,
)
# If a tile is "visible" it should be added to "explored"
self.game_map.explored |= self.game_map.visible
def update_fov(self):
""" Opdater `game_map` baseret på spillerens FOV"""
self.game_map.visible[:] = compute_fov(
self.game_map.tiles['transparent'],
(self.player.x, self.player.y),
radius=8,
)
# Hvis en `tile` er synlig, sæt den til `explored`
self.game_map.explored |= self.game_map.visible
def update_fov(self) -> None:
'''Recmompute the visible area based on the players point of view.'''
self.game_map.visible[:] = compute_fov(
self.game_map.tiles['transparent'],
(self.player.x, self.player.y),
radius=8,
)
# If a tile is "visible" it should be added to "explored".
self.game_map.explored |= self.game_map.visible
def update_fov(self) -> None:
"""Recompute the visible area based on the player's point of view."""
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=8, # how far the FOV extends
)
# If a tile is "visible", it should be added to "explored".
self.game_map.explored |= self.game_map.visible
def update_fov(self) -> None:
"""Recompute the visible area based on the players point of view."""
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=8,
)
#if a tile is "visible" it should be added to "explored" by setting anything in the explored array to include everything
#in the "visible" array
self.game_map.explored |= self.game_map.visible
def update_fov(self) -> None:
"""Пересчитывает видимую область на основе местонахождения героя."""
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=
8, # радиус отвечает за то, насколько обширным будет поле зрения
)
# Если плитка - "visible", она должны быть добавлена к "explored".
self.game_map.explored |= self.game_map.visible # добавляет увиденные плитки к исследованным
def update_fov(self) -> None:
"""Recompute the visible area based on the player's point of view."""
# TODO: Magic numbers!
self.GAMEMAP.visible[:] = compute_fov(
self.GAMEMAP.tiles["transparent"],
self.PLAYER.position,
radius=CONFIG.Game.get("fov_radius"))
# if a tile is visible it should be added to explored
self.GAMEMAP.explored |= self.GAMEMAP.visible
def update_fov(self) -> None:
"""
Recompute the visible area based on the players point of view
"""
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"],
(self.player.x, self.player.y),
radius=8,
)
#if a tile is "visible it shoudl be added to the "explored"
self.game_map.explored |= self.game_map.visible
def update_fov(self) -> None:
'''
* Sets visibility of a tile based on tcod library's 'map.compute_fov()' method
- "transparency"- uses a 2D numpy array where any non-zero values are considered transparent.
- "player.x, player.y" - the player's x/y point (character's POV)
- "radius" - how far the FOV extends (in tiled spaces)
> (https://python-tcod.readthedocs.io/en/latest/tcod/map.html#tcod.map.compute_fov)
'''
self.game_map.visible[:] = compute_fov(
self.game_map.tiles["transparent"], (self.player.x, self.player.y),
radius=8)
# If a tile is "visible", it must have been "explored" (so add the 'visible' array to the 'explored' array)
self.game_map.explored |= self.game_map.visible
def ai(self):
if not self.dead:
super().ai()
fov = compute_fov(self.map.transparent, (self.x, self.y), self.fov,
True, tcod.constants.FOV_BASIC)
player = self.level.get_visible_player(fov)
if player:
path = tcod.path_new_using_map(self.map, 0)
tcod.path_compute(path, self.x, self.y, player.x, player.y)
if tcod.path_size(path) == 1:
self.attack(player)
elif not tcod.path_is_empty(path):
px, py = tcod.path_walk(path, True)
self.move(px - self.x, py - self.y)
def calculate_fov(self, entity):
"""Returns the visible area for a particular entity"""
# Get a map the size of the level
visible = np.full((self.width, self.height),
fill_value=False,
order="F")
# Compute field of view from the entity's location
visible[:] = compute_fov(self.tiles["transparent"],
(entity.x, entity.y),
radius=entity.body.view_radius,
algorithm=tcod.FOV_SHADOW)
# Return the visible map
return visible
def update_fov(self) -> None:
"""Recompute the visible area based on the players point of view."""
temp_vision = copy.copy(self.game_map.tiles["transparent"])
for entity in self.game_map.entities:
if entity.blocks_sight:
temp_vision[entity.x, entity.y] = False
self.game_map.visible[:] = compute_fov(
temp_vision,
(self.player.x, self.player.y),
radius=self.player.status.changed_status["eyesight"],
)
# If a tile is "visible" it should be added to "explored".
self.game_map.explored |= self.game_map.visible
def enemy_recompute_fov(transparency_map, pov, radius, light_walls=True, algorithm=tcod.FOV_BASIC):
return compute_fov(transparency_map, pov, radius, light_walls, algorithm)
