500 lines
18 KiB
Rust
500 lines
18 KiB
Rust
use std::{error::Error, fmt::Debug, hash::Hash, marker::PhantomData};
|
|
|
|
use bevy::prelude::*;
|
|
use bevy_input_actionmap::InputMap;
|
|
use bevy_rapier2d::prelude::*;
|
|
use bevy_tts::Tts;
|
|
use derive_more::{Deref, DerefMut};
|
|
use mapgen::Tile;
|
|
|
|
use crate::{
|
|
core::{Coordinates, Player, PointLike},
|
|
error::error_handler,
|
|
map::Map,
|
|
pathfinding::Destination,
|
|
visibility::{RevealedTiles, Viewshed, Visible, VisibleEntities},
|
|
};
|
|
|
|
#[derive(Component, Clone, Copy, Debug, Default, PartialEq, Reflect)]
|
|
#[reflect(Component)]
|
|
pub struct Explorable;
|
|
|
|
#[derive(Component, Clone, Copy, Debug, Default, PartialEq, Reflect)]
|
|
#[reflect(Component)]
|
|
pub struct ExplorationFocused;
|
|
|
|
#[allow(dead_code)]
|
|
#[derive(Component, Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, Reflect)]
|
|
pub enum ExplorationType {
|
|
Portal = 0,
|
|
Item = 1,
|
|
Character = 2,
|
|
Ally = 3,
|
|
Enemy = 4,
|
|
}
|
|
|
|
// Doesn't make sense to create from a `String`.
|
|
#[allow(clippy::from_over_into)]
|
|
impl Into<String> for ExplorationType {
|
|
fn into(self) -> String {
|
|
match self {
|
|
ExplorationType::Portal => "Exit".into(),
|
|
ExplorationType::Item => "Item".into(),
|
|
ExplorationType::Character => "Character".into(),
|
|
ExplorationType::Ally => "Ally".into(),
|
|
ExplorationType::Enemy => "Enemy".into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
// Likewise.
|
|
#[allow(clippy::from_over_into)]
|
|
impl Into<&str> for ExplorationType {
|
|
fn into(self) -> &'static str {
|
|
match self {
|
|
ExplorationType::Portal => "exit",
|
|
ExplorationType::Item => "item",
|
|
ExplorationType::Character => "character",
|
|
ExplorationType::Ally => "ally",
|
|
ExplorationType::Enemy => "enemy",
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Component, Clone, Copy, Debug, Default, Deref, DerefMut, Reflect)]
|
|
#[reflect(Component)]
|
|
pub struct Exploring(pub (f32, f32));
|
|
|
|
impl_pointlike_for_tuple_component!(Exploring);
|
|
|
|
#[derive(Component, Clone, Debug, Default, Deref, DerefMut)]
|
|
pub struct FocusedExplorationType(pub Option<ExplorationType>);
|
|
|
|
#[derive(Component, Clone, Copy, Debug, Default, Reflect)]
|
|
#[reflect(Component)]
|
|
pub struct Mappable;
|
|
|
|
fn exploration_type_change<S, A: 'static>(
|
|
config: Res<ExplorationConfig<S, A>>,
|
|
mut tts: ResMut<Tts>,
|
|
input: Res<InputMap<A>>,
|
|
mut explorers: Query<(&VisibleEntities, &mut FocusedExplorationType)>,
|
|
features: Query<&ExplorationType>,
|
|
) -> Result<(), Box<dyn Error>>
|
|
where
|
|
S: bevy::ecs::component::Component + Clone + Debug + Eq + Hash,
|
|
A: Hash + Eq + Clone + Send + Sync,
|
|
{
|
|
if let (Some(select_next_type), Some(select_prev_type)) = (
|
|
config.action_explore_select_next_type.clone(),
|
|
config.action_explore_select_prev_type.clone(),
|
|
) {
|
|
let changed = input.just_active(select_next_type.clone())
|
|
|| input.just_active(select_prev_type.clone());
|
|
if !changed {
|
|
return Ok(());
|
|
}
|
|
for (visible, mut focused) in explorers.iter_mut() {
|
|
let mut types: Vec<ExplorationType> = vec![];
|
|
for e in visible.iter() {
|
|
if let Ok(t) = features.get(*e) {
|
|
types.push(*t);
|
|
}
|
|
}
|
|
types.sort();
|
|
types.dedup();
|
|
if types.is_empty() {
|
|
tts.speak("Nothing visible.", true)?;
|
|
} else if input.just_active(select_prev_type.clone()) {
|
|
if let Some(t) = &focused.0 {
|
|
if let Some(i) = types.iter().position(|v| *v == *t) {
|
|
if i == 0 {
|
|
focused.0 = None;
|
|
} else {
|
|
let t = &types[i - 1];
|
|
focused.0 = Some(*t);
|
|
}
|
|
} else {
|
|
let t = types.last().unwrap();
|
|
focused.0 = Some(*t);
|
|
}
|
|
} else {
|
|
let t = types.last().unwrap();
|
|
focused.0 = Some(*t);
|
|
}
|
|
} else if input.just_active(select_next_type.clone()) {
|
|
if let Some(t) = &focused.0 {
|
|
if let Some(i) = types.iter().position(|v| *v == *t) {
|
|
if i == types.len() - 1 {
|
|
focused.0 = None;
|
|
} else {
|
|
let t = &types[i + 1];
|
|
focused.0 = Some(*t);
|
|
}
|
|
} else {
|
|
let t = types.first().unwrap();
|
|
focused.0 = Some(*t);
|
|
}
|
|
} else {
|
|
let t = types.first().unwrap();
|
|
focused.0 = Some(*t)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn exploration_type_focus<S, A: 'static>(
|
|
mut commands: Commands,
|
|
config: Res<ExplorationConfig<S, A>>,
|
|
input: Res<InputMap<A>>,
|
|
mut tts: ResMut<Tts>,
|
|
explorers: Query<(
|
|
Entity,
|
|
&VisibleEntities,
|
|
&FocusedExplorationType,
|
|
Option<&Exploring>,
|
|
)>,
|
|
features: Query<(Entity, &Coordinates, &ExplorationType)>,
|
|
) -> Result<(), Box<dyn Error>>
|
|
where
|
|
S: bevy::ecs::component::Component + Clone + Debug + Eq + Hash,
|
|
A: Hash + Eq + Clone + Send + Sync,
|
|
{
|
|
if let (Some(explore_focus_next), Some(explore_focus_prev)) = (
|
|
config.action_explore_focus_next.clone(),
|
|
config.action_explore_focus_prev.clone(),
|
|
) {
|
|
let changed = input.just_active(explore_focus_next.clone())
|
|
|| input.just_active(explore_focus_prev.clone());
|
|
if !changed {
|
|
return Ok(());
|
|
}
|
|
for (entity, visible_entities, focused_type, exploring) in explorers.iter() {
|
|
let mut features = features
|
|
.iter()
|
|
.filter(|v| visible_entities.contains(&v.0))
|
|
.map(|v| (v.1.floor(), v.2))
|
|
.collect::<Vec<((f32, f32), &ExplorationType)>>();
|
|
if features.is_empty() {
|
|
tts.speak("Nothing visible.", true)?;
|
|
return Ok(());
|
|
}
|
|
features.sort_by(|(c1, _), (c2, _)| c1.partial_cmp(c2).unwrap());
|
|
if let Some(focused) = &focused_type.0 {
|
|
features.retain(|(_, t)| **t == *focused);
|
|
}
|
|
let mut target: Option<&((f32, f32), &ExplorationType)> = None;
|
|
if input.just_active(explore_focus_next.clone()) {
|
|
if let Some(exploring) = exploring {
|
|
target = features.iter().find(|(c, _)| *c > **exploring);
|
|
if target.is_none() {
|
|
target = features.first();
|
|
}
|
|
} else {
|
|
target = features.first();
|
|
}
|
|
} else if input.just_active(explore_focus_prev.clone()) {
|
|
if let Some(exploring) = exploring {
|
|
features.reverse();
|
|
target = features.iter().find(|(c, _)| *c < **exploring);
|
|
if target.is_none() {
|
|
target = features.first();
|
|
}
|
|
} else {
|
|
target = features.last();
|
|
}
|
|
}
|
|
if let Some((coordinates, _)) = target {
|
|
commands
|
|
.entity(entity)
|
|
.insert(Exploring(coordinates.floor()));
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn exploration_type_changed_announcement(
|
|
mut tts: ResMut<Tts>,
|
|
focused: Query<
|
|
(
|
|
&FocusedExplorationType,
|
|
ChangeTrackers<FocusedExplorationType>,
|
|
),
|
|
Changed<FocusedExplorationType>,
|
|
>,
|
|
) -> Result<(), Box<dyn Error>> {
|
|
for (focused, changed) in focused.iter() {
|
|
if changed.is_added() {
|
|
return Ok(());
|
|
}
|
|
match &focused.0 {
|
|
Some(v) => {
|
|
let v: String = (*v).into();
|
|
tts.speak(v, true)?;
|
|
}
|
|
None => {
|
|
tts.speak("Everything", true)?;
|
|
}
|
|
};
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn exploration_focus<S, A: 'static>(
|
|
mut commands: Commands,
|
|
config: Res<ExplorationConfig<S, A>>,
|
|
input: Res<InputMap<A>>,
|
|
map: Query<&Map>,
|
|
explorers: Query<(Entity, &Coordinates, Option<&Exploring>), With<Player>>,
|
|
) where
|
|
S: bevy::ecs::component::Component + Clone + Debug + Eq + Hash,
|
|
A: Hash + Eq + Clone + Send + Sync,
|
|
{
|
|
if let (
|
|
Some(explore_forward),
|
|
Some(explore_backward),
|
|
Some(explore_left),
|
|
Some(explore_right),
|
|
) = (
|
|
config.action_explore_forward.clone(),
|
|
config.action_explore_backward.clone(),
|
|
config.action_explore_left.clone(),
|
|
config.action_explore_right.clone(),
|
|
) {
|
|
for map in map.iter() {
|
|
if let (entity, coordinates, exploring) = explorers.single() {
|
|
let coordinates = **coordinates;
|
|
let mut exploring = if let Some(exploring) = exploring {
|
|
**exploring
|
|
} else {
|
|
coordinates.floor()
|
|
};
|
|
let orig = exploring;
|
|
if input.just_active(explore_forward.clone()) {
|
|
exploring.1 += 1.;
|
|
} else if input.just_active(explore_backward.clone()) {
|
|
exploring.1 -= 1.;
|
|
} else if input.just_active(explore_left.clone()) {
|
|
exploring.0 -= 1.;
|
|
} else if input.just_active(explore_right.clone()) {
|
|
exploring.0 += 1.;
|
|
}
|
|
if orig != exploring
|
|
&& exploring.0 >= 0.
|
|
&& exploring.0 < map.width as f32
|
|
&& exploring.1 >= 0.
|
|
&& exploring.1 < map.height as f32
|
|
{
|
|
commands.entity(entity).insert(Exploring(exploring));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn navigate_to_explored<S, A: 'static>(
|
|
mut commands: Commands,
|
|
config: Res<ExplorationConfig<S, A>>,
|
|
input: Res<InputMap<A>>,
|
|
map: Query<(&Map, &RevealedTiles)>,
|
|
explorers: Query<(Entity, &Exploring)>,
|
|
) where
|
|
S: bevy::ecs::component::Component + Clone + Debug + Eq + Hash,
|
|
A: Hash + Eq + Clone + Send + Sync,
|
|
{
|
|
if let Some(navigate_to_explored) = config.action_navigate_to_explored.clone() {
|
|
for (entity, exploring) in explorers.iter() {
|
|
for (map, revealed_tiles) in map.iter() {
|
|
let point = **exploring;
|
|
let idx = point.to_index(map.width);
|
|
let known = revealed_tiles[idx];
|
|
if input.just_active(navigate_to_explored.clone()) && known {
|
|
commands
|
|
.entity(entity)
|
|
.insert(Destination((point.x_i32(), point.y_i32())));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn exploration_changed_announcement(
|
|
mut commands: Commands,
|
|
mut tts: ResMut<Tts>,
|
|
map: Query<(&Map, &RevealedTiles)>,
|
|
explorer: Query<(&Coordinates, &Exploring, &Viewshed), Changed<Exploring>>,
|
|
focused: Query<Entity, With<ExplorationFocused>>,
|
|
explorable: Query<Entity, Or<(With<Visible>, With<Explorable>)>>,
|
|
names: Query<&Name>,
|
|
types: Query<&ExplorationType>,
|
|
mappables: Query<&Mappable>,
|
|
query_pipeline: Res<QueryPipeline>,
|
|
collider_query: QueryPipelineColliderComponentsQuery,
|
|
) -> Result<(), Box<dyn Error>> {
|
|
if let (coordinates, exploring, viewshed) = explorer.single() {
|
|
let collider_set = QueryPipelineColliderComponentsSet(&collider_query);
|
|
let coordinates = coordinates.floor();
|
|
for (map, revealed_tiles) in map.iter() {
|
|
let point = **exploring;
|
|
let idx = point.to_index(map.width);
|
|
let shape = Cuboid::new(Vec2::new(0.49, 0.49).into());
|
|
let known = revealed_tiles[idx];
|
|
let visible = viewshed.is_point_visible(exploring);
|
|
let fog_of_war = known && !visible;
|
|
let description = if known {
|
|
let mut tokens: Vec<&str> = vec![];
|
|
for entity in focused.iter() {
|
|
commands.entity(entity).remove::<ExplorationFocused>();
|
|
}
|
|
let shape_pos = (Vec2::new(exploring.x(), exploring.y()), 0.);
|
|
query_pipeline.intersections_with_shape(
|
|
&collider_set,
|
|
&shape_pos.into(),
|
|
&shape,
|
|
InteractionGroups::all(),
|
|
Some(&|v| explorable.get(v.entity()).is_ok()),
|
|
|handle| {
|
|
let entity = handle.entity();
|
|
commands.entity(entity).insert(ExplorationFocused);
|
|
if visible || mappables.get(entity).is_ok() {
|
|
if let Ok(name) = names.get(entity) {
|
|
tokens.push(name.as_str());
|
|
}
|
|
if tokens.is_empty() {
|
|
if let Ok(t) = types.get(entity) {
|
|
tokens.push((*t).into());
|
|
}
|
|
}
|
|
}
|
|
true
|
|
},
|
|
);
|
|
if tokens.is_empty() {
|
|
let tile = map.tiles[idx];
|
|
if tile.is_blocked() {
|
|
"wall".to_string()
|
|
} else {
|
|
"floor".to_string()
|
|
}
|
|
} else {
|
|
tokens.join(": ")
|
|
}
|
|
} else {
|
|
"Unknown".to_string()
|
|
};
|
|
let mut tokens: Vec<String> = vec![
|
|
description,
|
|
coordinates.direction_and_distance(exploring, None),
|
|
];
|
|
if fog_of_war {
|
|
tokens.push("in the fog of war".into());
|
|
}
|
|
tts.speak(format!("{}", tokens.join(", ")), true)?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn cleanup(
|
|
mut commands: Commands,
|
|
explorers: Query<Entity, With<Exploring>>,
|
|
focus: Query<Entity, With<ExplorationFocused>>,
|
|
) {
|
|
for entity in explorers.iter() {
|
|
commands.entity(entity).remove::<Exploring>();
|
|
}
|
|
for entity in focus.iter() {
|
|
commands.entity(entity).remove::<ExplorationFocused>();
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct ExplorationConfig<S, A> {
|
|
pub exploration_control_states: Vec<S>,
|
|
pub action_explore_forward: Option<A>,
|
|
pub action_explore_backward: Option<A>,
|
|
pub action_explore_left: Option<A>,
|
|
pub action_explore_right: Option<A>,
|
|
pub action_explore_focus_next: Option<A>,
|
|
pub action_explore_focus_prev: Option<A>,
|
|
pub action_explore_select_next_type: Option<A>,
|
|
pub action_explore_select_prev_type: Option<A>,
|
|
pub action_navigate_to_explored: Option<A>,
|
|
}
|
|
|
|
impl<S, A> Default for ExplorationConfig<S, A> {
|
|
fn default() -> Self {
|
|
Self {
|
|
exploration_control_states: vec![],
|
|
action_explore_forward: None,
|
|
action_explore_backward: None,
|
|
action_explore_left: None,
|
|
action_explore_right: None,
|
|
action_explore_focus_next: None,
|
|
action_explore_focus_prev: None,
|
|
action_explore_select_next_type: None,
|
|
action_explore_select_prev_type: None,
|
|
action_navigate_to_explored: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct ExplorationPlugin<'a, S, A>(PhantomData<&'a S>, PhantomData<&'a A>);
|
|
|
|
impl<'a, S, A> Default for ExplorationPlugin<'a, S, A> {
|
|
fn default() -> Self {
|
|
Self(PhantomData, PhantomData)
|
|
}
|
|
}
|
|
|
|
impl<'a, S, A> Plugin for ExplorationPlugin<'a, S, A>
|
|
where
|
|
S: bevy::ecs::component::Component + Clone + Debug + Eq + Hash,
|
|
A: Hash + Eq + Clone + Send + Sync,
|
|
'a: 'static,
|
|
{
|
|
fn build(&self, app: &mut App) {
|
|
if !app.world.contains_resource::<ExplorationConfig<S, A>>() {
|
|
app.insert_resource(ExplorationConfig::<S, A>::default());
|
|
}
|
|
let config = app
|
|
.world
|
|
.get_resource::<ExplorationConfig<S, A>>()
|
|
.unwrap()
|
|
.clone();
|
|
app.register_type::<ExplorationFocused>()
|
|
.register_type::<ExplorationType>()
|
|
.register_type::<Mappable>()
|
|
.add_system_to_stage(
|
|
CoreStage::PostUpdate,
|
|
exploration_changed_announcement.chain(error_handler),
|
|
);
|
|
if config.exploration_control_states.is_empty() {
|
|
app.add_system(exploration_focus::<S, A>)
|
|
.add_system(exploration_type_focus::<S, A>.chain(error_handler))
|
|
.add_system(exploration_type_change::<S, A>.chain(error_handler))
|
|
.add_system(navigate_to_explored::<S, A>)
|
|
.add_system_to_stage(
|
|
CoreStage::PostUpdate,
|
|
exploration_type_changed_announcement.chain(error_handler),
|
|
);
|
|
} else {
|
|
let states = config.exploration_control_states;
|
|
for state in states {
|
|
app.add_system_set(
|
|
SystemSet::on_update(state.clone())
|
|
.with_system(exploration_focus::<S, A>)
|
|
.with_system(exploration_type_focus::<S, A>.chain(error_handler))
|
|
.with_system(exploration_type_change::<S, A>.chain(error_handler))
|
|
.with_system(navigate_to_explored::<S, A>)
|
|
.with_system(exploration_type_changed_announcement.chain(error_handler)),
|
|
)
|
|
.add_system_set(SystemSet::on_exit(state).with_system(cleanup));
|
|
}
|
|
}
|
|
}
|
|
}
|