blackout/src/visibility.rs

420 lines
13 KiB
Rust

use std::{
cell::RefCell,
collections::{HashMap, HashSet},
};
use bevy::{core::FixedTimestep, prelude::*};
use bevy_rapier2d::{na, na::UnitComplex};
use coord_2d::{Coord, Size};
use derive_more::{Deref, DerefMut};
use shadowcast::{vision_distance, Context, InputGrid};
use crate::{
bevy_rapier2d::prelude::*,
core::{Angle, Coordinates, Player, PointLike},
log::Log,
map::{ITileType, Map, MapConfig},
utils::target_and_other,
};
#[derive(Component, Clone, Copy, Debug, Default, Reflect)]
#[reflect(Component)]
pub struct DontLogWhenVisible;
#[derive(Component, Clone, Debug, Default, Deref, DerefMut, Reflect)]
#[reflect(Component)]
pub struct RevealedTiles(pub Vec<bool>);
#[derive(Component, Clone, Debug, Eq, PartialEq)]
pub struct Viewshed {
pub range: u32,
pub visible_points: HashSet<(i32, i32)>,
}
impl Default for Viewshed {
fn default() -> Self {
Self {
range: 15,
visible_points: HashSet::new(),
}
}
}
impl Viewshed {
pub fn is_point_visible(&self, point: &dyn PointLike) -> bool {
self.visible_points.contains(&point.into())
}
fn update(
&mut self,
viewer_entity: &Entity,
visible_entities: &mut VisibleEntities,
start: &dyn PointLike,
query_pipeline: &QueryPipeline,
collider_query: &QueryPipelineColliderComponentsQuery,
map: &Map,
visible_query: &Query<&Visible>,
cache: &mut HashMap<(i32, i32), (HashSet<Entity>, u8)>,
events: &mut EventWriter<VisibilityChanged>,
) {
let mut context: Context<u8> = Context::default();
let vision_distance = vision_distance::Circle::new(self.range);
let shape = ColliderShape::cuboid(0.49, 0.49);
let origin = point!(start.x(), start.y());
let coord = Coord::new(start.x_i32(), start.y_i32());
let collider_set = QueryPipelineColliderComponentsSet(collider_query);
let mut new_visible_entities = HashSet::<Entity>::new();
let visibility_grid = VisibilityGrid(
map,
RefCell::new(Box::new(|coord: Coord| {
if let Some((entities, opacity)) = cache.get(&(coord.x, coord.y)) {
for e in entities {
new_visible_entities.insert(*e);
}
return *opacity;
}
let tile = map.at(coord.x as usize, coord.y as usize);
if tile.blocks_visibility() {
return u8::MAX;
}
let mut entities = HashSet::new();
let shape_pos = (Vec2::new(coord.x as f32 + 0.5, coord.y as f32 + 0.5), 0.);
let dest = point!(coord.x as f32 + 0.5, coord.y as f32 + 0.5);
if na::distance(&origin, &dest) >= self.range as f32 {
return u8::MAX;
}
let mut opacity = 0;
query_pipeline.intersections_with_shape(
&collider_set,
&shape_pos.into(),
&*shape,
InteractionGroups::all(),
Some(&|v| {
v.entity() != *viewer_entity && visible_query.get(v.entity()).is_ok()
}),
|handle| {
let entity = handle.entity();
entities.insert(entity);
if let Ok(visible) = visible_query.get(entity) {
opacity = **visible;
}
true
},
);
for e in &entities {
new_visible_entities.insert(*e);
}
cache.insert((coord.x, coord.y), (entities, opacity));
opacity
})),
);
let mut new_visible = HashSet::new();
context.for_each_visible(
coord,
&visibility_grid,
&visibility_grid,
vision_distance,
255,
|coord, _directions, _visibility| {
new_visible.insert((coord.x, coord.y));
},
);
if self.visible_points != new_visible {
self.visible_points = new_visible;
}
if new_visible_entities != **visible_entities {
for lost in visible_entities.difference(&new_visible_entities) {
events.send(VisibilityChanged::Lost {
viewer: *viewer_entity,
viewed: *lost,
});
}
for gained in new_visible_entities.difference(visible_entities) {
events.send(VisibilityChanged::Gained {
viewer: *viewer_entity,
viewed: *gained,
});
}
**visible_entities = new_visible_entities;
}
}
}
#[derive(Component, Clone, Copy, Debug, Deref, DerefMut, Reflect)]
#[reflect(Component)]
pub struct Visible(pub u8);
impl Default for Visible {
fn default() -> Self {
Self::opaque()
}
}
impl Visible {
pub fn transparent() -> Self {
Self(0)
}
pub fn opaque() -> Self {
Self(u8::MAX)
}
}
#[derive(Component, Clone, Debug, Default, Deref, DerefMut)]
pub struct VisibleEntities(HashSet<Entity>);
#[derive(Bundle, Default)]
pub struct ViewshedBundle {
pub viewshed: Viewshed,
pub visible_entities: VisibleEntities,
}
impl ViewshedBundle {
pub fn new(range: u32) -> Self {
Self {
viewshed: Viewshed {
range,
..Default::default()
},
..Default::default()
}
}
}
pub enum VisibilityChanged {
Gained { viewer: Entity, viewed: Entity },
Lost { viewer: Entity, viewed: Entity },
}
impl PointLike for Coord {
fn x(&self) -> f32 {
self.x as f32
}
fn y(&self) -> f32 {
self.y as f32
}
}
fn add_visibility_indices(
mut commands: Commands,
query: Query<(Entity, &Map), (Added<Map>, Without<RevealedTiles>)>,
map_config: Res<MapConfig>,
) {
for (entity, map) in query.iter() {
let count = map.width * map.height;
commands
.entity(entity)
.insert(RevealedTiles(vec![map_config.start_revealed; count]));
}
}
fn viewshed_removed(
query: RemovedComponents<Viewshed>,
visible_entities: Query<&VisibleEntities>,
mut events: EventWriter<VisibilityChanged>,
) {
for entity in query.iter() {
if let Ok(visible) = visible_entities.get(entity) {
for e in visible.iter() {
events.send(VisibilityChanged::Lost {
viewer: entity,
viewed: *e,
})
}
}
}
}
pub struct VisibilityGrid<'a, F>(pub &'a Map, pub RefCell<Box<F>>);
impl<'a, F> InputGrid for VisibilityGrid<'a, F>
where
F: FnMut(Coord) -> u8,
{
type Grid = VisibilityGrid<'a, F>;
type Opacity = u8;
fn size(&self, grid: &Self::Grid) -> Size {
Size::new(grid.0.width as u32, grid.0.height as u32)
}
fn get_opacity(&self, _grid: &Self::Grid, coord: Coord) -> Self::Opacity {
(self.1.borrow_mut())(coord)
}
}
fn update_viewshed(
config: Res<RapierConfiguration>,
coordinates: Query<(Entity, &Coordinates), Changed<Coordinates>>,
visible: Query<&Visible>,
mut viewers: Query<(Entity, &mut Viewshed, &mut VisibleEntities, &Coordinates)>,
map: Query<&Map>,
query_pipeline: Res<QueryPipeline>,
collider_query: QueryPipelineColliderComponentsQuery,
mut changed: EventWriter<VisibilityChanged>,
) {
if !config.query_pipeline_active {
return;
}
let mut to_update = HashSet::new();
for (entity, coordinates) in coordinates.iter() {
if to_update.contains(&entity) {
continue;
}
if viewers.get_mut(entity).is_ok() {
to_update.insert(entity);
}
if visible.get(entity).is_err() {
continue;
}
for (viewer_entity, viewshed, _, viewer_coordinates) in viewers.iter_mut() {
if viewer_entity != entity
&& viewer_coordinates.distance(&coordinates) <= viewshed.range as f32
{
to_update.insert(viewer_entity);
continue;
}
}
}
for entity in to_update.iter() {
if let Ok((viewer_entity, mut viewshed, mut visible_entities, viewer_coordinates)) =
viewers.get_mut(*entity)
{
let map = map.single();
let mut cache = HashMap::new();
viewshed.update(
&viewer_entity,
&mut visible_entities,
viewer_coordinates,
&*query_pipeline,
&collider_query,
map,
&visible,
&mut cache,
&mut changed,
);
}
}
}
fn remove_visible(
removed: RemovedComponents<Visible>,
mut viewers: Query<(Entity, &mut Viewshed, &mut VisibleEntities, &Coordinates)>,
map: Query<&Map>,
query_pipeline: Res<QueryPipeline>,
collider_query: QueryPipelineColliderComponentsQuery,
visible: Query<&Visible>,
mut changed: EventWriter<VisibilityChanged>,
) {
for removed in removed.iter() {
for (viewer_entity, mut viewshed, mut visible_entities, start) in viewers.iter_mut() {
if !visible_entities.contains(&removed) {
continue;
}
visible_entities.remove(&removed);
let map = map.single();
let mut cache = HashMap::new();
viewshed.update(
&viewer_entity,
&mut visible_entities,
start,
&*query_pipeline,
&collider_query,
map,
&visible,
&mut cache,
&mut changed,
);
}
}
}
fn update_revealed_tiles(
mut map: Query<(&Map, &mut RevealedTiles)>,
viewers: Query<&Viewshed, With<Player>>,
) {
for (map, mut revealed_tiles) in map.iter_mut() {
for viewshed in viewers.iter() {
for v in viewshed.visible_points.iter() {
let idx = v.to_index(map.width);
if idx >= revealed_tiles.len() {
continue;
}
revealed_tiles[idx] = true;
}
}
}
}
fn log_visible(
time: Res<Time>,
mut recently_lost: Local<HashMap<Entity, Timer>>,
mut events: EventReader<VisibilityChanged>,
mut log: Query<&mut Log>,
viewers: Query<(Entity, &Coordinates, &Transform), (With<Player>, With<Viewshed>)>,
visible: Query<
(
&Name,
Option<&RigidBodyPositionComponent>,
Option<&ColliderPositionComponent>,
),
Without<DontLogWhenVisible>,
>,
) {
for timer in recently_lost.values_mut() {
timer.tick(time.delta());
}
recently_lost.retain(|_entity, timer| !timer.finished());
for event in events.iter() {
let viewer = match event {
VisibilityChanged::Gained { viewer, .. } => viewer,
VisibilityChanged::Lost { viewer, .. } => viewer,
};
if let Ok((viewer_entity, viewer_coordinates, viewer_transform)) = viewers.get(*viewer) {
if let VisibilityChanged::Gained { viewed, .. } = event {
if *viewed == viewer_entity || recently_lost.contains_key(viewed) {
continue;
}
if let Ok((name, body_position, collider_position)) = visible.get(*viewed) {
let mut log = log.single_mut();
let viewed_coordinates = if let Some(p) = body_position {
(p.position.translation.x, p.position.translation.y)
} else if let Some(p) = collider_position {
(p.translation.x, p.translation.y)
} else {
(0., 0.)
};
let forward = viewer_transform.local_x();
let yaw = Angle::Radians(forward.y.atan2(forward.x));
let location =
viewer_coordinates.direction_and_distance(&viewed_coordinates, Some(yaw));
log.push(format!("{}: {}", **name, location));
}
} else if let VisibilityChanged::Lost { viewed, .. } = event {
recently_lost.insert(*viewed, Timer::from_seconds(2., false));
}
}
}
}
pub const LOG_VISIBLE_LABEL: &str = "LOG_VISIBLE";
pub struct VisibilityPlugin;
impl Plugin for VisibilityPlugin {
fn build(&self, app: &mut App) {
app.add_event::<VisibilityChanged>()
.add_system(add_visibility_indices)
.add_system_to_stage(CoreStage::PostUpdate, viewshed_removed)
.add_system_set(
SystemSet::new()
.with_run_criteria(FixedTimestep::step(0.1))
.with_system(update_viewshed),
)
.add_system_to_stage(CoreStage::PostUpdate, remove_visible)
.add_system_to_stage(CoreStage::PostUpdate, update_revealed_tiles)
.add_system_to_stage(CoreStage::PostUpdate, log_visible);
}
}