Merge branch 'main' into avian
This commit is contained in:
commit
2f85dcda91
37
Cargo.toml
37
Cargo.toml
|
|
@ -13,10 +13,43 @@ speech_dispatcher_0_9 = ["bevy_tts/speech_dispatcher_0_9"]
|
|||
speech_dispatcher_0_10 = ["bevy_tts/speech_dispatcher_0_10"]
|
||||
speech_dispatcher_0_11 = ["bevy_tts/speech_dispatcher_0_11"]
|
||||
|
||||
[dependencies.bevy]
|
||||
version = "0.14"
|
||||
default-features = false
|
||||
features = [
|
||||
"android_shared_stdcxx",
|
||||
"animation",
|
||||
"bevy_animation",
|
||||
"bevy_asset",
|
||||
"bevy_color",
|
||||
"bevy_core_pipeline",
|
||||
"bevy_gilrs",
|
||||
"bevy_gizmos",
|
||||
"bevy_gltf",
|
||||
"bevy_pbr",
|
||||
"bevy_render",
|
||||
"bevy_scene",
|
||||
"bevy_sprite",
|
||||
"bevy_state",
|
||||
"bevy_text",
|
||||
"bevy_ui",
|
||||
"bevy_winit",
|
||||
"default_font",
|
||||
"hdr",
|
||||
"ktx2",
|
||||
"multi_threaded",
|
||||
"png",
|
||||
"smaa_luts",
|
||||
"sysinfo_plugin",
|
||||
"tonemapping_luts",
|
||||
"webgl2",
|
||||
"x11",
|
||||
"zstd",
|
||||
]
|
||||
|
||||
[dependencies]
|
||||
avian2d = "0.1"
|
||||
bevy = "0.14"
|
||||
bevy_synthizer = "0.7"
|
||||
bevy_synthizer = "0.8"
|
||||
bevy_tts = { version = "0.9", default-features = false, features = ["tolk"] }
|
||||
coord_2d = "0.3"
|
||||
here_be_dragons = { version = "0.3", features = ["serde"] }
|
||||
|
|
|
|||
377
src/core.rs
377
src/core.rs
|
|
@ -2,7 +2,6 @@ use std::{
|
|||
cmp::{max, min},
|
||||
f32::consts::PI,
|
||||
fmt::Display,
|
||||
ops::Sub,
|
||||
sync::RwLock,
|
||||
};
|
||||
|
||||
|
|
@ -13,180 +12,100 @@ use avian2d::{
|
|||
},
|
||||
prelude::*,
|
||||
};
|
||||
use bevy::{app::PluginGroupBuilder, math::FloatOrd, prelude::*};
|
||||
use bevy::{
|
||||
app::PluginGroupBuilder,
|
||||
math::{CompassOctant, CompassQuadrant, FloatOrd},
|
||||
prelude::*,
|
||||
};
|
||||
use once_cell::sync::Lazy;
|
||||
use rand::prelude::*;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Clone, Copy, Debug, Reflect)]
|
||||
pub enum Angle {
|
||||
Degrees(f32),
|
||||
Radians(f32),
|
||||
fn relative_desc(rot: &Rot2) -> String {
|
||||
let mode = RELATIVE_DIRECTION_MODE.read().unwrap();
|
||||
match rot.as_radians() {
|
||||
v if v <= PI / 12. && v > -PI / 12. => "ahead",
|
||||
v if v <= PI / 4. && v > PI / 12. => {
|
||||
if *mode == RelativeDirectionMode::ClockFacing {
|
||||
"11:00"
|
||||
} else {
|
||||
"ahead and left"
|
||||
}
|
||||
}
|
||||
v if v <= 3. * PI / 8. && v > PI / 4. => {
|
||||
if *mode == RelativeDirectionMode::ClockFacing {
|
||||
"10:00"
|
||||
} else {
|
||||
"left and ahead"
|
||||
}
|
||||
}
|
||||
v if v <= 5. * PI / 8. && v > 3. * PI / 8. => "left",
|
||||
v if v <= 3. * PI / 4. && v > 5. * PI / 8. => {
|
||||
if *mode == RelativeDirectionMode::ClockFacing {
|
||||
"8:00"
|
||||
} else {
|
||||
"left and behind"
|
||||
}
|
||||
}
|
||||
v if v <= 11. * PI / 12. && v > 3. * PI / 4. => {
|
||||
if *mode == RelativeDirectionMode::ClockFacing {
|
||||
"7:00"
|
||||
} else {
|
||||
"behind and left"
|
||||
}
|
||||
}
|
||||
v if v <= PI && v > 11. * PI / 12. || v > -PI && v <= -11. * PI / 12. => "behind",
|
||||
v if v <= -3. * PI / 4. && v > -11. * PI / 12. => {
|
||||
if *mode == RelativeDirectionMode::ClockFacing {
|
||||
"5:00"
|
||||
} else {
|
||||
"behind and right"
|
||||
}
|
||||
}
|
||||
v if v <= -5. * PI / 8. && v > -3. * PI / 4. => {
|
||||
if *mode == RelativeDirectionMode::ClockFacing {
|
||||
"4:00"
|
||||
} else {
|
||||
"right and behind"
|
||||
}
|
||||
}
|
||||
v if v <= -3. * PI / 8. && v > -5. * PI / 8. => "right",
|
||||
v if v <= -PI / 4. && v > -3. * PI / 8. => {
|
||||
if *mode == RelativeDirectionMode::ClockFacing {
|
||||
"2:00"
|
||||
} else {
|
||||
"right and ahead"
|
||||
}
|
||||
}
|
||||
v if v <= -PI / 12. && v > -PI / 4. => {
|
||||
if *mode == RelativeDirectionMode::ClockFacing {
|
||||
"1:00"
|
||||
} else {
|
||||
"ahead and right"
|
||||
}
|
||||
}
|
||||
_ => "ahead",
|
||||
}
|
||||
.into()
|
||||
}
|
||||
|
||||
impl Default for Angle {
|
||||
fn default() -> Self {
|
||||
Self::Radians(0.)
|
||||
}
|
||||
}
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq, Deref, DerefMut, Reflect)]
|
||||
pub struct MovementDirection(CompassOctant);
|
||||
|
||||
impl Angle {
|
||||
pub fn degrees(&self) -> f32 {
|
||||
use Angle::*;
|
||||
let mut degrees: f32 = match self {
|
||||
Degrees(v) => *v,
|
||||
Radians(v) => v.to_degrees(),
|
||||
};
|
||||
while degrees < 0. {
|
||||
degrees += 360.;
|
||||
}
|
||||
while degrees >= 360. {
|
||||
degrees %= 360.;
|
||||
}
|
||||
degrees
|
||||
}
|
||||
|
||||
pub fn degrees_u32(&self) -> u32 {
|
||||
self.degrees() as u32
|
||||
}
|
||||
|
||||
pub fn radians(&self) -> f32 {
|
||||
use Angle::*;
|
||||
match self {
|
||||
Degrees(v) => v.to_radians(),
|
||||
Radians(v) => *v,
|
||||
}
|
||||
}
|
||||
|
||||
fn relative_desc(&self) -> String {
|
||||
let mode = RELATIVE_DIRECTION_MODE.read().unwrap();
|
||||
match self.degrees() {
|
||||
v if v <= 15. => "ahead",
|
||||
v if v <= 45. => {
|
||||
if *mode == RelativeDirectionMode::ClockFacing {
|
||||
"11:00"
|
||||
} else {
|
||||
"ahead and left"
|
||||
}
|
||||
}
|
||||
v if v <= 75. => {
|
||||
if *mode == RelativeDirectionMode::ClockFacing {
|
||||
"10:00"
|
||||
} else {
|
||||
"left and ahead"
|
||||
}
|
||||
}
|
||||
v if v <= 105. => "left",
|
||||
v if v <= 135. => {
|
||||
if *mode == RelativeDirectionMode::ClockFacing {
|
||||
"8:00"
|
||||
} else {
|
||||
"left and behind"
|
||||
}
|
||||
}
|
||||
v if v <= 165. => {
|
||||
if *mode == RelativeDirectionMode::ClockFacing {
|
||||
"7:00"
|
||||
} else {
|
||||
"behind and left"
|
||||
}
|
||||
}
|
||||
v if v <= 195. => "behind",
|
||||
v if v <= 225. => {
|
||||
if *mode == RelativeDirectionMode::ClockFacing {
|
||||
"5:00"
|
||||
} else {
|
||||
"behind and right"
|
||||
}
|
||||
}
|
||||
v if v <= 255. => {
|
||||
if *mode == RelativeDirectionMode::ClockFacing {
|
||||
"4:00"
|
||||
} else {
|
||||
"right and behind"
|
||||
}
|
||||
}
|
||||
v if v <= 285. => "right",
|
||||
v if v <= 315. => {
|
||||
if *mode == RelativeDirectionMode::ClockFacing {
|
||||
"2:00"
|
||||
} else {
|
||||
"right and ahead"
|
||||
}
|
||||
}
|
||||
v if v <= 345. => {
|
||||
if *mode == RelativeDirectionMode::ClockFacing {
|
||||
"1:00"
|
||||
} else {
|
||||
"ahead and right"
|
||||
}
|
||||
}
|
||||
_ => "ahead",
|
||||
}
|
||||
.into()
|
||||
}
|
||||
}
|
||||
|
||||
impl Sub for Angle {
|
||||
type Output = Self;
|
||||
|
||||
fn sub(self, rhs: Self) -> Self::Output {
|
||||
match self {
|
||||
Angle::Degrees(v1) => match rhs {
|
||||
Angle::Degrees(v2) => Angle::Degrees(v1 - v2),
|
||||
Angle::Radians(v2) => Angle::Degrees(v1 - v2.to_degrees()),
|
||||
},
|
||||
Angle::Radians(v1) => match rhs {
|
||||
Angle::Degrees(v2) => Angle::Radians(v1 - v2.to_radians()),
|
||||
Angle::Radians(v2) => Angle::Radians(v1 - v2),
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq, Reflect)]
|
||||
pub enum MovementDirection {
|
||||
North,
|
||||
NorthNortheast,
|
||||
Northeast,
|
||||
EastNortheast,
|
||||
East,
|
||||
EastSoutheast,
|
||||
Southeast,
|
||||
SouthSoutheast,
|
||||
South,
|
||||
SouthSouthwest,
|
||||
Southwest,
|
||||
WestSouthwest,
|
||||
West,
|
||||
WestNorthwest,
|
||||
Northwest,
|
||||
NorthNorthwest,
|
||||
}
|
||||
|
||||
impl From<Angle> for MovementDirection {
|
||||
fn from(angle: Angle) -> Self {
|
||||
let heading = angle.degrees();
|
||||
use MovementDirection::*;
|
||||
match heading {
|
||||
h if h < 11.5 => East,
|
||||
h if h < 34.0 => EastNortheast,
|
||||
h if h < 56.5 => Northeast,
|
||||
h if h < 79.0 => NorthNortheast,
|
||||
h if h < 101.5 => North,
|
||||
h if h < 124.0 => NorthNorthwest,
|
||||
h if h < 146.5 => Northwest,
|
||||
h if h < 169.0 => WestNorthwest,
|
||||
h if h < 191.5 => West,
|
||||
h if h < 214.0 => WestSouthwest,
|
||||
h if h < 236.5 => Southwest,
|
||||
h if h < 259.0 => SouthSouthwest,
|
||||
h if h < 281.5 => South,
|
||||
h if h < 304.0 => SouthSoutheast,
|
||||
h if h < 326.5 => Southeast,
|
||||
h if h <= 349.0 => EastSoutheast,
|
||||
_ => East,
|
||||
}
|
||||
impl From<Rot2> for MovementDirection {
|
||||
fn from(rot: Rot2) -> Self {
|
||||
use CompassOctant::*;
|
||||
MovementDirection(match rot.as_radians() {
|
||||
h if h > -PI / 8. && h <= PI / 8. => East,
|
||||
h if h > PI / 8. && h <= 3. * PI / 8. => NorthEast,
|
||||
h if h > 3. * PI / 8. && h <= 5. * PI / 8. => North,
|
||||
h if h > 5. * PI / 8. && h <= 7. * PI / 8. => NorthWest,
|
||||
h if h > 7. * PI / 8. || h <= -7. * PI / 8. => West,
|
||||
h if h > -7. * PI / 8. && h <= -5. * PI / 8. => SouthWest,
|
||||
h if h > -5. * PI / 8. && h <= -3. * PI / 8. => South,
|
||||
h if h > -3. * PI / 8. && h <= -PI / 8. => SouthEast,
|
||||
_ => West,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -194,25 +113,18 @@ impl From<Angle> for MovementDirection {
|
|||
#[allow(clippy::from_over_into)]
|
||||
impl Into<String> for MovementDirection {
|
||||
fn into(self) -> String {
|
||||
use MovementDirection::*;
|
||||
match self {
|
||||
North => "north".to_string(),
|
||||
NorthNortheast => "north northeast".to_string(),
|
||||
Northeast => "northeast".to_string(),
|
||||
EastNortheast => "east northeast".to_string(),
|
||||
East => "east".to_string(),
|
||||
EastSoutheast => "east southeast".to_string(),
|
||||
Southeast => "southeast".to_string(),
|
||||
SouthSoutheast => "south southeast".to_string(),
|
||||
South => "south".to_string(),
|
||||
SouthSouthwest => "south southwest".to_string(),
|
||||
Southwest => "southwest".to_string(),
|
||||
WestSouthwest => "west southwest".to_string(),
|
||||
West => "west".to_string(),
|
||||
WestNorthwest => "west northwest".to_string(),
|
||||
Northwest => "northwest".to_string(),
|
||||
NorthNorthwest => "north northwest".to_string(),
|
||||
use CompassOctant::*;
|
||||
match self.0 {
|
||||
North => "north",
|
||||
NorthEast => "northeast",
|
||||
East => "east",
|
||||
SouthEast => "southeast",
|
||||
South => "south",
|
||||
SouthWest => "southwest",
|
||||
West => "west",
|
||||
NorthWest => "northwest",
|
||||
}
|
||||
.into()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -223,38 +135,36 @@ impl Display for MovementDirection {
|
|||
}
|
||||
}
|
||||
|
||||
#[derive(Component, Clone, Copy, Default, Debug, Eq, PartialEq, Reflect)]
|
||||
#[derive(Component, Clone, Copy, Debug, Eq, PartialEq, Deref, DerefMut, Reflect)]
|
||||
#[reflect(Component)]
|
||||
pub enum CardinalDirection {
|
||||
#[default]
|
||||
North,
|
||||
East,
|
||||
South,
|
||||
West,
|
||||
}
|
||||
pub struct CardinalDirection(pub CompassQuadrant);
|
||||
|
||||
impl From<Angle> for CardinalDirection {
|
||||
fn from(angle: Angle) -> Self {
|
||||
let heading = angle.degrees();
|
||||
use CardinalDirection::*;
|
||||
match heading {
|
||||
h if h <= 45. => East,
|
||||
h if h <= 135. => North,
|
||||
h if h <= 225. => West,
|
||||
h if h <= 315. => South,
|
||||
_ => East,
|
||||
}
|
||||
impl Default for CardinalDirection {
|
||||
fn default() -> Self {
|
||||
Self(CompassQuadrant::East)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<&CardinalDirection> for Angle {
|
||||
impl From<Rot2> for CardinalDirection {
|
||||
fn from(rot: Rot2) -> Self {
|
||||
use CompassQuadrant::*;
|
||||
CardinalDirection(match rot.as_radians() {
|
||||
h if h > -PI / 4. && h <= PI / 4. => East,
|
||||
h if h > PI / 4. && h <= 3. * PI / 4. => North,
|
||||
h if h > 3. * PI / 4. || h <= -3. * PI / 4. => West,
|
||||
_ => South,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl From<&CardinalDirection> for Rot2 {
|
||||
fn from(direction: &CardinalDirection) -> Self {
|
||||
use CardinalDirection::*;
|
||||
match direction {
|
||||
North => Angle::Radians(PI / 2.),
|
||||
East => Angle::Radians(0.),
|
||||
South => Angle::Radians(PI * 1.5),
|
||||
West => Angle::Radians(PI),
|
||||
use CompassQuadrant::*;
|
||||
match direction.0 {
|
||||
North => Rot2::radians(PI / 2.),
|
||||
East => Rot2::radians(0.),
|
||||
South => Rot2::radians(-PI / 2.),
|
||||
West => Rot2::radians(PI),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -263,8 +173,8 @@ impl From<&CardinalDirection> for Angle {
|
|||
#[allow(clippy::from_over_into)]
|
||||
impl Into<String> for CardinalDirection {
|
||||
fn into(self) -> String {
|
||||
use CardinalDirection::*;
|
||||
match self {
|
||||
use CompassQuadrant::*;
|
||||
match self.0 {
|
||||
North => "north".to_string(),
|
||||
East => "east".to_string(),
|
||||
South => "south".to_string(),
|
||||
|
|
@ -344,24 +254,26 @@ pub trait PointLike {
|
|||
self.distance_squared(other).sqrt()
|
||||
}
|
||||
|
||||
fn bearing(&self, other: &dyn PointLike) -> Angle {
|
||||
fn bearing(&self, other: &dyn PointLike) -> Rot2 {
|
||||
let y = other.y() - self.y();
|
||||
let x = other.x() - self.x();
|
||||
Angle::Radians(y.atan2(x))
|
||||
Rot2::radians(y.atan2(x))
|
||||
}
|
||||
|
||||
fn direction(&self, other: &dyn PointLike) -> MovementDirection {
|
||||
self.bearing(other).into()
|
||||
}
|
||||
|
||||
fn direction_and_distance(&self, other: &dyn PointLike, yaw: Option<Angle>) -> String {
|
||||
fn direction_and_distance(&self, other: &dyn PointLike, yaw: Option<Rot2>) -> String {
|
||||
let mut tokens: Vec<String> = vec![];
|
||||
let distance = self.distance(other).round() as i32;
|
||||
if distance > 0 {
|
||||
let tile_or_tiles = if distance == 1 { "tile" } else { "tiles" };
|
||||
let direction: String = if let Some(yaw) = yaw {
|
||||
let bearing = self.bearing(other);
|
||||
(bearing - yaw).relative_desc()
|
||||
let yaw = yaw.as_radians();
|
||||
let bearing = self.bearing(other).as_radians();
|
||||
let rot = Rot2::radians(bearing - yaw);
|
||||
relative_desc(&rot)
|
||||
} else {
|
||||
self.direction(other).into()
|
||||
};
|
||||
|
|
@ -483,18 +395,18 @@ impl From<&dyn PointLike> for (i32, i32) {
|
|||
}
|
||||
|
||||
pub trait TransformExt {
|
||||
fn yaw(&self) -> Angle;
|
||||
fn yaw(&self) -> Rot2;
|
||||
}
|
||||
|
||||
impl TransformExt for Transform {
|
||||
fn yaw(&self) -> Angle {
|
||||
fn yaw(&self) -> Rot2 {
|
||||
let forward = self.right();
|
||||
Angle::Radians(forward.y.atan2(forward.x))
|
||||
Rot2::radians(forward.y.atan2(forward.x))
|
||||
}
|
||||
}
|
||||
|
||||
pub trait GlobalTransformExt {
|
||||
fn yaw(&self) -> Angle;
|
||||
fn yaw(&self) -> Rot2;
|
||||
|
||||
fn closest_points(
|
||||
&self,
|
||||
|
|
@ -512,9 +424,9 @@ pub trait GlobalTransformExt {
|
|||
}
|
||||
|
||||
impl GlobalTransformExt for GlobalTransform {
|
||||
fn yaw(&self) -> Angle {
|
||||
fn yaw(&self) -> Rot2 {
|
||||
let forward = self.right();
|
||||
Angle::Radians(forward.y.atan2(forward.x))
|
||||
Rot2::radians(forward.y.atan2(forward.x))
|
||||
}
|
||||
|
||||
fn closest_points(
|
||||
|
|
@ -526,11 +438,11 @@ impl GlobalTransformExt for GlobalTransform {
|
|||
let scale = PHYSICS_SCALE.read().unwrap();
|
||||
let pos1 = Isometry::new(
|
||||
(self.translation() / *scale).xy().into(),
|
||||
self.yaw().radians(),
|
||||
self.yaw().as_radians(),
|
||||
);
|
||||
let pos2 = Isometry::new(
|
||||
(other.translation() / *scale).xy().into(),
|
||||
other.yaw().radians(),
|
||||
other.yaw().as_radians(),
|
||||
);
|
||||
closest_points(
|
||||
&pos1,
|
||||
|
|
@ -551,11 +463,11 @@ impl GlobalTransformExt for GlobalTransform {
|
|||
let scale = PHYSICS_SCALE.read().unwrap();
|
||||
let pos1 = Isometry::new(
|
||||
(self.translation() / *scale).xy().into(),
|
||||
self.yaw().radians(),
|
||||
self.yaw().as_radians(),
|
||||
);
|
||||
let pos2 = Isometry::new(
|
||||
(other.translation() / *scale).xy().into(),
|
||||
other.yaw().radians(),
|
||||
other.yaw().as_radians(),
|
||||
);
|
||||
let closest = self.closest_points(collider, other, other_collider);
|
||||
let distance = distance(
|
||||
|
|
@ -570,9 +482,10 @@ impl GlobalTransformExt for GlobalTransform {
|
|||
if let ClosestPoints::WithinMargin(p1, p2) = closest {
|
||||
let p1 = (p1.x, p1.y);
|
||||
let p2 = (p2.x, p2.y);
|
||||
let bearing = p1.bearing(&p2);
|
||||
let yaw = self.yaw();
|
||||
let direction = (bearing - yaw).relative_desc();
|
||||
let bearing = p1.bearing(&p2).as_radians();
|
||||
let yaw = self.yaw().as_radians();
|
||||
let rot = Rot2::radians(bearing - yaw);
|
||||
let direction = relative_desc(&rot);
|
||||
format!("{direction} {distance} {tile_or_tiles}")
|
||||
} else {
|
||||
format!("{} {}", distance, tile_or_tiles)
|
||||
|
|
|
|||
|
|
@ -1,4 +1,9 @@
|
|||
use std::{error::Error, fmt::Debug, hash::Hash, marker::PhantomData};
|
||||
use std::{
|
||||
error::Error,
|
||||
fmt::{Debug, Display},
|
||||
hash::Hash,
|
||||
marker::PhantomData,
|
||||
};
|
||||
|
||||
use avian2d::prelude::*;
|
||||
use bevy::prelude::*;
|
||||
|
|
@ -182,7 +187,7 @@ fn exploration_type_changed_announcement<ExplorationType>(
|
|||
>,
|
||||
) -> Result<(), Box<dyn Error>>
|
||||
where
|
||||
ExplorationType: Component + Default + Copy + Into<String>,
|
||||
ExplorationType: Component + Default + Copy + Display,
|
||||
{
|
||||
for (focused, changed) in &focused {
|
||||
if changed.is_added() {
|
||||
|
|
@ -190,8 +195,7 @@ where
|
|||
}
|
||||
match &focused.0 {
|
||||
Some(v) => {
|
||||
let v: String = (*v).into();
|
||||
tts.speak(v, true)?;
|
||||
tts.speak(format!("{v}"), true)?;
|
||||
}
|
||||
None => {
|
||||
tts.speak("Everything", true)?;
|
||||
|
|
@ -284,7 +288,7 @@ fn exploration_changed_announcement<ExplorationType, MapData>(
|
|||
spatial_query: SpatialQuery,
|
||||
) -> Result<(), Box<dyn Error>>
|
||||
where
|
||||
ExplorationType: Component + Copy + Into<String>,
|
||||
ExplorationType: Component + Copy + Display,
|
||||
MapData: 'static + Clone + Default + Send + Sync,
|
||||
{
|
||||
if let Ok((coordinates, exploring, viewshed)) = explorer.get_single() {
|
||||
|
|
@ -319,7 +323,7 @@ where
|
|||
}
|
||||
if tokens.is_empty() {
|
||||
if let Ok(t) = types.get(entity) {
|
||||
tokens.push((*t).into());
|
||||
tokens.push(format!("{t}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -387,7 +391,7 @@ pub struct Exploration;
|
|||
|
||||
impl<ExplorationType, MapData> Plugin for ExplorationPlugin<ExplorationType, MapData>
|
||||
where
|
||||
ExplorationType: 'static + Component + Default + Copy + Ord + PartialEq + Into<String>,
|
||||
ExplorationType: 'static + Component + Default + Copy + Ord + PartialEq + Display,
|
||||
MapData: 'static + Clone + Default + Send + Sync,
|
||||
{
|
||||
fn build(&self, app: &mut App) {
|
||||
|
|
|
|||
|
|
@ -3,12 +3,12 @@
|
|||
use std::{collections::HashMap, error::Error, f32::consts::PI, fmt::Debug, hash::Hash};
|
||||
|
||||
use avian2d::prelude::*;
|
||||
use bevy::prelude::*;
|
||||
use bevy::{math::CompassQuadrant, prelude::*};
|
||||
use bevy_tts::Tts;
|
||||
use leafwing_input_manager::prelude::*;
|
||||
|
||||
use crate::{
|
||||
core::{Angle, CardinalDirection, GlobalTransformExt, Player, TransformExt},
|
||||
core::{CardinalDirection, GlobalTransformExt, Player, TransformExt},
|
||||
error::error_handler,
|
||||
log::Log,
|
||||
map::Zone,
|
||||
|
|
@ -77,7 +77,7 @@ impl Default for StrafeMovementFactor {
|
|||
|
||||
#[derive(Component, Clone, Copy, Default, Debug, Deref, DerefMut, Reflect)]
|
||||
#[reflect(Component)]
|
||||
pub struct RotationSpeed(pub Angle);
|
||||
pub struct RotationSpeed(pub Rot2);
|
||||
|
||||
#[derive(Deref, DerefMut)]
|
||||
struct SnapTimer(Timer);
|
||||
|
|
@ -102,7 +102,6 @@ impl Default for Speed {
|
|||
}
|
||||
|
||||
fn snap(
|
||||
mut tts: ResMut<Tts>,
|
||||
mut snap_timers: ResMut<SnapTimers>,
|
||||
mut query: Query<
|
||||
(
|
||||
|
|
@ -113,37 +112,40 @@ fn snap(
|
|||
),
|
||||
With<Player>,
|
||||
>,
|
||||
) -> Result<(), Box<dyn Error>> {
|
||||
) {
|
||||
for (entity, actions, mut transform, direction) in &mut query {
|
||||
if snap_timers.contains_key(&entity) {
|
||||
continue;
|
||||
} else if actions.just_pressed(&NavigationAction::SnapLeft) {
|
||||
snap_timers.insert(entity, SnapTimer::default());
|
||||
transform.rotation = Quat::from_rotation_z(match direction {
|
||||
CardinalDirection::North => PI,
|
||||
CardinalDirection::East => PI / 2.,
|
||||
CardinalDirection::South => 0.,
|
||||
CardinalDirection::West => -PI / 2.,
|
||||
transform.rotation = Quat::from_rotation_z(match direction.0 {
|
||||
CompassQuadrant::North => PI,
|
||||
CompassQuadrant::East => PI / 2.,
|
||||
CompassQuadrant::South => 0.,
|
||||
CompassQuadrant::West => -PI / 2.,
|
||||
});
|
||||
} else if actions.just_pressed(&NavigationAction::SnapRight) {
|
||||
snap_timers.insert(entity, SnapTimer::default());
|
||||
transform.rotation = Quat::from_rotation_z(match direction {
|
||||
CardinalDirection::North => 0.,
|
||||
CardinalDirection::East => -PI / 2.,
|
||||
CardinalDirection::South => PI,
|
||||
CardinalDirection::West => PI / 2.,
|
||||
transform.rotation = Quat::from_rotation_z(match direction.0 {
|
||||
CompassQuadrant::North => 0.,
|
||||
CompassQuadrant::East => -PI / 2.,
|
||||
CompassQuadrant::South => PI,
|
||||
CompassQuadrant::West => PI / 2.,
|
||||
});
|
||||
} else if actions.just_pressed(&NavigationAction::SnapReverse) {
|
||||
snap_timers.insert(entity, SnapTimer::default());
|
||||
transform.rotate(Quat::from_rotation_z(PI));
|
||||
} else if actions.just_pressed(&NavigationAction::SnapCardinal) {
|
||||
let yaw: Angle = direction.into();
|
||||
let yaw = yaw.radians();
|
||||
transform.rotation = Quat::from_rotation_z(yaw);
|
||||
tts.speak(direction.to_string(), true)?;
|
||||
println!("Direction: {direction:?}");
|
||||
let yaw: Rot2 = direction.into();
|
||||
let yaw = yaw.as_radians();
|
||||
println!("Yaw: {yaw}");
|
||||
let rotation = Quat::from_rotation_z(yaw);
|
||||
if transform.rotation != rotation {
|
||||
transform.rotation = rotation;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn tick_snap_timers(time: Res<Time>, mut snap_timers: ResMut<SnapTimers>) {
|
||||
|
|
@ -226,7 +228,7 @@ fn controls(
|
|||
.cast_shape(
|
||||
collider,
|
||||
transform.translation.truncate(),
|
||||
transform.yaw().radians(),
|
||||
transform.yaw().as_radians(),
|
||||
dir,
|
||||
1.,
|
||||
true,
|
||||
|
|
@ -241,7 +243,7 @@ fn controls(
|
|||
if !snap_timers.contains_key(&entity) {
|
||||
if let Some(rotation_speed) = rotation_speed {
|
||||
let delta =
|
||||
-rotation_speed.radians() * actions.clamped_value(&NavigationAction::Rotate);
|
||||
rotation_speed.as_radians() * actions.clamped_value(&NavigationAction::Rotate);
|
||||
actions.set_value(&NavigationAction::SetAngularVelocity, delta);
|
||||
}
|
||||
}
|
||||
|
|
@ -289,16 +291,11 @@ fn remove_direction(
|
|||
|
||||
fn speak_direction(
|
||||
mut tts: ResMut<Tts>,
|
||||
player: Query<
|
||||
(&CardinalDirection, Ref<CardinalDirection>),
|
||||
(With<Player>, Changed<CardinalDirection>),
|
||||
>,
|
||||
player: Query<&CardinalDirection, (With<Player>, Changed<CardinalDirection>)>,
|
||||
) -> Result<(), Box<dyn Error>> {
|
||||
if let Ok((direction, change)) = player.get_single() {
|
||||
if !change.is_added() {
|
||||
let direction: String = (*direction).into();
|
||||
tts.speak(direction, true)?;
|
||||
}
|
||||
if let Ok(direction) = player.get_single() {
|
||||
let direction: String = (*direction).into();
|
||||
tts.speak(direction, true)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
|
@ -384,12 +381,7 @@ impl Plugin for NavigationPlugin {
|
|||
.register_type::<Speed>()
|
||||
.add_plugins(InputManagerPlugin::<NavigationAction>::default())
|
||||
.add_systems(PreUpdate, (update_direction, add_speed))
|
||||
.add_systems(
|
||||
Update,
|
||||
(snap.pipe(error_handler), controls)
|
||||
.chain()
|
||||
.in_set(Movement),
|
||||
)
|
||||
.add_systems(Update, (snap, controls).chain().in_set(Movement))
|
||||
.add_systems(
|
||||
FixedUpdate,
|
||||
(tick_snap_timers, speak_direction.pipe(error_handler)),
|
||||
|
|
|
|||
|
|
@ -139,7 +139,7 @@ fn calculate_path(
|
|||
.shape_intersections(
|
||||
collider,
|
||||
start.translation.truncate(),
|
||||
start.yaw().radians(),
|
||||
start.yaw().as_radians(),
|
||||
SpatialQueryFilter::default(),
|
||||
)
|
||||
.is_empty()
|
||||
|
|
@ -244,7 +244,7 @@ fn negotiate_path(
|
|||
.cast_shape(
|
||||
collider,
|
||||
start,
|
||||
transform.yaw().radians(),
|
||||
transform.yaw().as_radians(),
|
||||
Dir2::new_unchecked(direction.normalize()),
|
||||
direction.length(),
|
||||
true,
|
||||
|
|
|
|||
|
|
@ -75,42 +75,43 @@ fn update<S>(
|
|||
} else {
|
||||
None
|
||||
};
|
||||
if let Some(entity) = entity {
|
||||
if visible.contains(&entity) {
|
||||
if let Some(interval) = icon.interval.as_mut() {
|
||||
if interval.finished() {
|
||||
interval.reset();
|
||||
continue;
|
||||
} else if interval.fraction() == 0. {
|
||||
sound.generator = None;
|
||||
}
|
||||
interval.tick(time.delta());
|
||||
}
|
||||
if sound.audio != icon.audio {
|
||||
sound.audio = icon.audio.clone();
|
||||
}
|
||||
if sound.gain != icon.gain {
|
||||
sound.gain = icon.gain;
|
||||
}
|
||||
if sound.pitch != icon.pitch {
|
||||
sound.pitch = icon.pitch;
|
||||
}
|
||||
let looping = icon.interval.is_none();
|
||||
if sound.looping != looping {
|
||||
sound.looping = looping;
|
||||
}
|
||||
if sound.paused {
|
||||
sound.paused = false;
|
||||
let Some(entity) = entity else {
|
||||
continue;
|
||||
};
|
||||
if visible.contains(&entity) {
|
||||
if let Some(interval) = icon.interval.as_mut() {
|
||||
if interval.finished() {
|
||||
interval.reset();
|
||||
continue;
|
||||
} else if interval.fraction() == 0. {
|
||||
sound.playback_position = 0.;
|
||||
sound.generator = None;
|
||||
}
|
||||
} else if !sound.paused {
|
||||
sound.paused = true;
|
||||
if let Some(interval) = icon.interval.as_mut() {
|
||||
interval.reset();
|
||||
}
|
||||
interval.tick(time.delta());
|
||||
}
|
||||
if sound.audio != icon.audio {
|
||||
sound.audio = icon.audio.clone();
|
||||
}
|
||||
if sound.gain != icon.gain {
|
||||
sound.gain = icon.gain;
|
||||
}
|
||||
if sound.pitch != icon.pitch {
|
||||
sound.pitch = icon.pitch;
|
||||
}
|
||||
let looping = icon.interval.is_none();
|
||||
if sound.looping != looping {
|
||||
sound.looping = looping;
|
||||
}
|
||||
if sound.paused {
|
||||
sound.paused = false;
|
||||
sound.playback_position = 0.;
|
||||
sound.generator = None;
|
||||
}
|
||||
} else if !sound.paused {
|
||||
sound.paused = true;
|
||||
if let Some(interval) = icon.interval.as_mut() {
|
||||
interval.reset();
|
||||
}
|
||||
} else {
|
||||
panic!("Should not happen");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,31 +9,46 @@ use crate::core::GlobalTransformExt;
|
|||
pub struct Volumetric;
|
||||
|
||||
fn update(
|
||||
mut commands: Commands,
|
||||
listener: Query<(&Collider, &GlobalTransform), With<Listener>>,
|
||||
mut sounds: Query<(&Sound, &Parent, &mut Transform), With<Volumetric>>,
|
||||
mut sounds: Query<(Entity, &Sound, &Parent, Option<&mut Transform>), With<Volumetric>>,
|
||||
colliders: Query<(&Collider, &GlobalTransform)>,
|
||||
) {
|
||||
if let Ok((listener_collider, listener_global_transform)) = listener.get_single() {
|
||||
for (sound, parent, mut sound_transform) in &mut sounds {
|
||||
for (sound_entity, sound, parent, sound_transform) in &mut sounds {
|
||||
if sound.paused {
|
||||
continue;
|
||||
}
|
||||
if let Ok((sound_collider, sound_global_transform)) = colliders.get(**parent) {
|
||||
let closest = listener_global_transform.closest_points(
|
||||
listener_collider,
|
||||
sound_global_transform,
|
||||
sound_collider,
|
||||
);
|
||||
if let ClosestPoints::WithinMargin(_p1, p2) = closest {
|
||||
let p2 = Vec3::new(p2.x, p2.y, 0.);
|
||||
let Ok((sound_collider, sound_global_transform)) = colliders.get(**parent) else {
|
||||
continue;
|
||||
};
|
||||
let closest = listener_global_transform.closest_points(
|
||||
listener_collider,
|
||||
sound_global_transform,
|
||||
sound_collider,
|
||||
);
|
||||
if let ClosestPoints::WithinMargin(_p1, p2) = closest {
|
||||
if let Some(mut sound_transform) = sound_transform {
|
||||
sound_transform.translation.x = p2.x - sound_global_transform.translation().x;
|
||||
sound_transform.translation.y = p2.y - sound_global_transform.translation().y;
|
||||
} else if closest == ClosestPoints::Intersecting {
|
||||
sound_transform.translation.x = listener_global_transform.translation().x
|
||||
- sound_global_transform.translation().x;
|
||||
sound_transform.translation.y = listener_global_transform.translation().y
|
||||
- sound_global_transform.translation().y;
|
||||
} else {
|
||||
let sound_translation = Vec3::new(
|
||||
p2.x - sound_global_transform.translation().x,
|
||||
p2.y - sound_global_transform.translation().y,
|
||||
0.,
|
||||
);
|
||||
commands
|
||||
.entity(sound_entity)
|
||||
.insert(TransformBundle::from_transform(
|
||||
Transform::from_translation(sound_translation),
|
||||
));
|
||||
}
|
||||
} else if closest == ClosestPoints::Intersecting && sound_transform.is_some() {
|
||||
println!("Clearing volumetric");
|
||||
commands
|
||||
.entity(sound_entity)
|
||||
.remove::<Transform>()
|
||||
.remove::<GlobalTransform>();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,4 @@
|
|||
use std::{
|
||||
cell::RefCell,
|
||||
collections::{HashMap, HashSet},
|
||||
marker::PhantomData,
|
||||
};
|
||||
|
|
@ -49,92 +48,17 @@ impl Viewshed {
|
|||
viewer_entity: &Entity,
|
||||
visible_entities: &mut VisibleEntities,
|
||||
start: &Vec2,
|
||||
opacity_map: &OpacityMap,
|
||||
sensors: &Query<&Sensor>,
|
||||
spatial_query: &SpatialQuery,
|
||||
visible_query: &Query<(&Visible, &Collider, &GlobalTransform)>,
|
||||
cache: &mut RefCell<HashMap<(i32, i32), (u8, HashSet<Entity>)>>,
|
||||
) {
|
||||
// println!("Start");
|
||||
let mut boxes = vec![];
|
||||
let shape = Collider::rectangle(self.range as f32, self.range as f32);
|
||||
spatial_query.shape_intersections_callback(&shape, *start, 0., default(), |entity| {
|
||||
if let Ok((_, collider, transform)) = visible_query.get(entity) {
|
||||
boxes.push(collider.aabb(transform.translation().truncate(), 0.));
|
||||
}
|
||||
true
|
||||
});
|
||||
let mut context: Context<u8> = Context::default();
|
||||
let vision_distance = vision_distance::Circle::new(self.range);
|
||||
let shape = Collider::rectangle(0.49, 0.49);
|
||||
let size = (
|
||||
(start.x.abs() + self.range as f32 * 2.) as u32,
|
||||
(start.y.abs() + self.range as f32 * 2.) as u32,
|
||||
);
|
||||
let visibility_grid = VisibilityGrid(
|
||||
size,
|
||||
RefCell::new(Box::new(|coord: Coord| {
|
||||
let shape_pos = Vec2::new(coord.x as f32 + 0.5, coord.y as f32 + 0.5);
|
||||
// println!("Checking {coord:?}: {shape_pos:?}");
|
||||
if start.distance(&shape_pos) > self.range as f32 {
|
||||
// println!("Out of range");
|
||||
return u8::MAX;
|
||||
}
|
||||
let mut coord_entities = HashSet::new();
|
||||
let mut to_insert = None;
|
||||
let opacity = if let Some((opacity, entities)) =
|
||||
cache.borrow().get(&(coord.x, coord.y))
|
||||
{
|
||||
// println!("Cache hit: {opacity:?}: {entities:?}");
|
||||
coord_entities = entities.clone();
|
||||
*opacity
|
||||
} else {
|
||||
let aabb = shape.aabb(shape_pos, 0.);
|
||||
if boxes.iter().any(|b| b.intersects(&aabb)) {
|
||||
// println!("Hit");
|
||||
let mut opacity = 0;
|
||||
spatial_query.shape_intersections_callback(
|
||||
&shape,
|
||||
shape_pos,
|
||||
0.,
|
||||
default(),
|
||||
|entity| {
|
||||
if let Ok((visible, _, _)) = visible_query.get(entity) {
|
||||
// println!(
|
||||
// "{entity:?}: {visible:?}: {:?}",
|
||||
// transform.translation().truncate()
|
||||
// );
|
||||
coord_entities.insert(entity);
|
||||
opacity = opacity.max(**visible);
|
||||
}
|
||||
true
|
||||
},
|
||||
);
|
||||
to_insert = Some(((coord.x, coord.y), (opacity, coord_entities.clone())));
|
||||
// println!("New opacity: {opacity}");
|
||||
opacity
|
||||
} else {
|
||||
// println!("No hits, 0");
|
||||
to_insert = Some(((coord.x, coord.y), default()));
|
||||
0
|
||||
}
|
||||
};
|
||||
if let Some((k, v)) = to_insert {
|
||||
cache.borrow_mut().insert(k, v);
|
||||
}
|
||||
if coord_entities.contains(viewer_entity) {
|
||||
let mut coord_entities = coord_entities.clone();
|
||||
coord_entities.retain(|e| e != viewer_entity);
|
||||
let opacity = coord_entities
|
||||
.iter()
|
||||
.map(|v| visible_query.get(*v).unwrap().0 .0)
|
||||
.max()
|
||||
.unwrap_or(0);
|
||||
// println!("Viewer hit, removing viewer opacity: {opacity}");
|
||||
opacity
|
||||
} else {
|
||||
opacity
|
||||
}
|
||||
})),
|
||||
);
|
||||
let visibility_grid = VisibilityGrid(size, *viewer_entity, opacity_map.clone());
|
||||
let mut new_visible = HashSet::new();
|
||||
let mut new_visible_entities = HashSet::new();
|
||||
// println!("Start: {viewer_entity}");
|
||||
|
|
@ -146,9 +70,36 @@ impl Viewshed {
|
|||
u8::MAX,
|
||||
|coord, _directions, _visibility| {
|
||||
new_visible.insert((coord.x, coord.y));
|
||||
if let Some((_, entities)) = cache.borrow().get(&(coord.x, coord.y)) {
|
||||
let coord = IVec2::new(coord.x, coord.y);
|
||||
// println!("Checking {coord:?}");
|
||||
if let Some((_, entities)) = opacity_map.get(&coord) {
|
||||
for e in entities {
|
||||
new_visible_entities.insert(*e);
|
||||
if entities.len() == 1 || sensors.contains(*e) {
|
||||
new_visible_entities.insert(*e);
|
||||
} else {
|
||||
let should_push = std::cell::RefCell::new(true);
|
||||
let coord = Vec2::new(coord.x as f32 + 0.5, coord.y as f32 + 0.5);
|
||||
let dir = Dir2::new_unchecked((coord - *start).normalize());
|
||||
// println!("Casting from {coord}");
|
||||
spatial_query.cast_ray_predicate(
|
||||
*start,
|
||||
dir,
|
||||
dir.distance(*start),
|
||||
true,
|
||||
default(),
|
||||
&|entity| {
|
||||
if *e != entity && entities.contains(e) {
|
||||
// println!("{entities:?} contains {e} and hits at {:?}", hit.point);
|
||||
// commands.entity(*e).log_components();
|
||||
*should_push.borrow_mut() = false;
|
||||
}
|
||||
true
|
||||
},
|
||||
);
|
||||
if *should_push.borrow() {
|
||||
new_visible_entities.insert(*e);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
|
|
@ -161,8 +112,6 @@ impl Viewshed {
|
|||
commands.trigger_targets(VisibilityChanged::Lost(*lost), *viewer_entity);
|
||||
}
|
||||
for gained in new_visible_entities.difference(visible_entities) {
|
||||
// println!("transition: {:?} gains {:?}", viewer_entity,
|
||||
// gained);
|
||||
commands.trigger_targets(VisibilityChanged::Gained(*gained), *viewer_entity);
|
||||
}
|
||||
**visible_entities = new_visible_entities;
|
||||
|
|
@ -190,6 +139,82 @@ impl Visible {
|
|||
}
|
||||
}
|
||||
|
||||
#[derive(Resource, Clone, Deref, DerefMut, Default)]
|
||||
pub struct OpacityMap(HashMap<IVec2, (u8, HashSet<Entity>)>);
|
||||
|
||||
impl OpacityMap {
|
||||
fn update(
|
||||
&mut self,
|
||||
spatial_query: &SpatialQuery,
|
||||
coordinates: HashSet<IVec2>,
|
||||
visible: &Query<(Entity, &GlobalTransform, &Collider, &Visible)>,
|
||||
) {
|
||||
self.retain(|k, _| !coordinates.contains(k));
|
||||
let shape = Collider::rectangle(0.49, 0.49);
|
||||
for coords in &coordinates {
|
||||
let shape_pos = Vec2::new(coords.x as f32 + 0.5, coords.y as f32 + 0.5);
|
||||
let mut opacity = 0;
|
||||
let mut coord_entities = HashSet::new();
|
||||
spatial_query.shape_intersections_callback(
|
||||
&shape,
|
||||
shape_pos,
|
||||
0.,
|
||||
default(),
|
||||
|entity| {
|
||||
if let Ok((_, _, _, visible)) = visible.get(entity) {
|
||||
coord_entities.insert(entity);
|
||||
opacity = opacity.max(**visible);
|
||||
}
|
||||
true
|
||||
},
|
||||
);
|
||||
self.insert(*coords, (opacity, coord_entities));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn update_opacity_map(
|
||||
mut opacity_map: ResMut<OpacityMap>,
|
||||
spatial_query: SpatialQuery,
|
||||
query: Query<
|
||||
(Entity, &GlobalTransform, &Collider, &Visible),
|
||||
Or<(Changed<GlobalTransform>, Changed<Visible>)>,
|
||||
>,
|
||||
visible: Query<(Entity, &GlobalTransform, &Collider, &Visible)>,
|
||||
) {
|
||||
let mut to_update = HashSet::new();
|
||||
for (entity, transform, collider, _) in &query {
|
||||
// println!(
|
||||
// "Updating {entity} at {:?}",
|
||||
// transform.translation().truncate().as_ivec2()
|
||||
// );
|
||||
let mut prev = HashSet::new();
|
||||
for (k, v) in opacity_map.iter() {
|
||||
if v.1.contains(&entity) {
|
||||
// println!("Also updating {k} because it contained entity");
|
||||
prev.insert(*k);
|
||||
}
|
||||
}
|
||||
let mut current = HashSet::new();
|
||||
current.insert(transform.translation().truncate().as_ivec2());
|
||||
let aabb = collider.aabb(transform.translation().truncate(), transform);
|
||||
for x in aabb.min.x as i32..aabb.max.x as i32 {
|
||||
for y in aabb.min.y as i32..aabb.max.y as i32 {
|
||||
// println!(
|
||||
// "Also updating coordinates at {:?}",
|
||||
// IVec2::new(x as i32, y as i32)
|
||||
// );
|
||||
current.insert(IVec2::new(x, y));
|
||||
}
|
||||
}
|
||||
if prev != current {
|
||||
to_update.extend(prev);
|
||||
to_update.extend(current);
|
||||
}
|
||||
}
|
||||
opacity_map.update(&spatial_query, to_update, &visible);
|
||||
}
|
||||
|
||||
#[derive(Component, Clone, Debug, Default, Deref, DerefMut)]
|
||||
pub struct VisibleEntities(HashSet<Entity>);
|
||||
|
||||
|
|
@ -251,12 +276,9 @@ fn viewshed_removed(
|
|||
}
|
||||
}
|
||||
|
||||
pub struct VisibilityGrid<F>(pub (u32, u32), pub RefCell<Box<F>>);
|
||||
pub struct VisibilityGrid(pub (u32, u32), pub Entity, pub OpacityMap);
|
||||
|
||||
impl<F> InputGrid for VisibilityGrid<F>
|
||||
where
|
||||
F: FnMut(Coord) -> u8,
|
||||
{
|
||||
impl InputGrid for VisibilityGrid {
|
||||
type Grid = (u32, u32);
|
||||
|
||||
type Opacity = u8;
|
||||
|
|
@ -266,31 +288,43 @@ where
|
|||
}
|
||||
|
||||
fn get_opacity(&self, _grid: &Self::Grid, coord: Coord) -> Self::Opacity {
|
||||
(self.1.borrow_mut())(coord)
|
||||
// println!("Checking {coord:?}");
|
||||
if let Some((opacity, entities)) = self.2.get(&IVec2::new(coord.x, coord.y)) {
|
||||
if entities.len() == 1 && entities.contains(&self.1) {
|
||||
// println!("Hit viewer, 0");
|
||||
0
|
||||
} else {
|
||||
// println!("{opacity:?}");
|
||||
*opacity
|
||||
}
|
||||
} else {
|
||||
// println!("Miss, 0");
|
||||
0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn update_viewshed(
|
||||
mut commands: Commands,
|
||||
visible: Query<(&Visible, &Collider, &GlobalTransform)>,
|
||||
mut viewers: Query<(
|
||||
Entity,
|
||||
&mut Viewshed,
|
||||
&mut VisibleEntities,
|
||||
&GlobalTransform,
|
||||
)>,
|
||||
opacity_map: Res<OpacityMap>,
|
||||
sensors: Query<&Sensor>,
|
||||
spatial_query: SpatialQuery,
|
||||
) {
|
||||
let mut cache = default();
|
||||
for (viewer_entity, mut viewshed, mut visible_entities, viewer_transform) in &mut viewers {
|
||||
viewshed.update(
|
||||
&mut commands,
|
||||
&viewer_entity,
|
||||
&mut visible_entities,
|
||||
&viewer_transform.translation().truncate(),
|
||||
&opacity_map,
|
||||
&sensors,
|
||||
&spatial_query,
|
||||
&visible,
|
||||
&mut cache,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
@ -304,11 +338,21 @@ fn remove_visible(
|
|||
&mut VisibleEntities,
|
||||
&GlobalTransform,
|
||||
)>,
|
||||
sensors: Query<&Sensor>,
|
||||
spatial_query: SpatialQuery,
|
||||
visible: Query<(&Visible, &Collider, &GlobalTransform)>,
|
||||
mut opacity_map: ResMut<OpacityMap>,
|
||||
visible: Query<(Entity, &GlobalTransform, &Collider, &Visible)>,
|
||||
) {
|
||||
if !removed.is_empty() {
|
||||
let mut cache = default();
|
||||
let mut to_update = HashSet::new();
|
||||
for e in removed.read() {
|
||||
for (k, v) in opacity_map.iter() {
|
||||
if v.1.contains(&e) {
|
||||
to_update.insert(*k);
|
||||
}
|
||||
}
|
||||
}
|
||||
opacity_map.update(&spatial_query, to_update, &visible);
|
||||
for removed in removed.read() {
|
||||
for (viewer_entity, mut viewshed, mut visible_entities, start) in &mut viewers {
|
||||
if !visible_entities.contains(&removed) {
|
||||
|
|
@ -319,9 +363,9 @@ fn remove_visible(
|
|||
&viewer_entity,
|
||||
&mut visible_entities,
|
||||
&start.translation().truncate(),
|
||||
&opacity_map,
|
||||
&sensors,
|
||||
&spatial_query,
|
||||
&visible,
|
||||
&mut cache,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
@ -357,7 +401,6 @@ fn log_visible(
|
|||
}
|
||||
if let Ok((viewer_transform, viewer_collider)) = viewers.get(trigger.entity()) {
|
||||
if let Ok((name, viewed_transform, viewed_collider)) = visible.get(*entity) {
|
||||
// println!("Gain {name}: {entity}");
|
||||
let location = if let (Some(viewer_collider), Some(viewed_collider)) =
|
||||
(viewer_collider, viewed_collider)
|
||||
{
|
||||
|
|
@ -388,15 +431,17 @@ impl<MapData: 'static + Clone + Default + Send + Sync> Default for VisibilityPlu
|
|||
|
||||
impl<MapData: 'static + Clone + Default + Send + Sync> Plugin for VisibilityPlugin<MapData> {
|
||||
fn build(&self, app: &mut App) {
|
||||
app.add_systems(
|
||||
FixedPreUpdate,
|
||||
(
|
||||
add_visibility_indices::<MapData>,
|
||||
update_viewshed,
|
||||
update_revealed_tiles::<MapData>,
|
||||
),
|
||||
)
|
||||
.add_systems(FixedPostUpdate, (viewshed_removed, remove_visible))
|
||||
.observe(log_visible);
|
||||
app.init_resource::<OpacityMap>()
|
||||
.add_systems(FixedPreUpdate, update_opacity_map.before(update_viewshed))
|
||||
.add_systems(
|
||||
FixedPreUpdate,
|
||||
(
|
||||
add_visibility_indices::<MapData>,
|
||||
update_viewshed,
|
||||
update_revealed_tiles::<MapData>,
|
||||
),
|
||||
)
|
||||
.add_systems(FixedPostUpdate, (viewshed_removed, remove_visible))
|
||||
.observe(log_visible);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user