From 57827d53713e9bdf65a0bcc34fe670cfe8b356dd Mon Sep 17 00:00:00 2001 From: Silas Bartha Date: Thu, 21 Nov 2024 12:17:08 -0500 Subject: Thu Nov 21 12:17:08 PM EST 2024 --- src/components.rs | 27 +++++++++++++++++++++++---- src/lib.rs | 37 +++++++++++++++++++++++++++++-------- 2 files changed, 52 insertions(+), 12 deletions(-) diff --git a/src/components.rs b/src/components.rs index 1be2f2c..c2b2547 100644 --- a/src/components.rs +++ b/src/components.rs @@ -6,7 +6,7 @@ use bevy::{prelude::*, utils::HashSet}; /// /// An entity with an `Interactor` component can be passed to an `InteractorFiredEvent` in order to /// start an interaction with any nearby `Interactable` entities. -#[derive(Component, Default)] +#[derive(Component, Default, Debug)] pub struct Interactor { /// All `Interactable` targets in-range of this interactor. pub targets: HashSet, @@ -18,10 +18,19 @@ pub struct Interactor { /// /// An entity with an `Interactable` component might get passed to an `InteractionEvent` when an /// `Interactor` requests an interaction, if the interactable is in range. -#[derive(Component)] +#[derive(Component, Clone, Debug)] pub struct Interactable { + /// An optional name for this interactable + pub name: Option, + /// An optional description of the action + pub description: Option, + /// Predicate to check to see if interaction is possible + pub predicate: Option bool>, pub(crate) exclusive: bool, pub(crate) max_distance_squared: f32, + pub(crate) possible: bool, + /// Whether this pickup is enabled + pub enabled: bool, } impl Interactable { @@ -30,17 +39,27 @@ impl Interactable { /// If exclusive, this interactable will only be interacted with if it's the closest one to the /// interactor, and the interaction will *not* be processed for any other in-range /// interactables. - pub fn new(max_distance: f32, exclusive: bool) -> Self { + pub fn new(max_distance: f32, exclusive: bool, name: Option, description: Option, predicate: Option bool>) -> Self { Self { + name, + description, + predicate, exclusive, max_distance_squared: max_distance * max_distance, + possible: true, + enabled: true, } } + + /// Gets whether this interaction is currently possible. Set this value using predicate. + pub fn possible(&self) -> bool { + self.possible + } } impl Default for Interactable { fn default() -> Self { - Self::new(1.0, false) + Self::new(1.0, false, None, None, None) } } diff --git a/src/lib.rs b/src/lib.rs index 2e3fc60..de42adf 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -26,9 +26,12 @@ pub struct InteractionPlugin; impl Plugin for InteractionPlugin { fn build(&self, app: &mut App) { - app.add_systems(Update, (handle_interactor_events, update_interactor_targets)) - .add_event::() - .add_event::(); + app.add_systems( + Update, + (handle_interactor_events, update_interactor_targets, update_interactable_predicates), + ) + .add_event::() + .add_event::(); } } @@ -43,7 +46,7 @@ fn handle_interactor_events( if let Some(interactable_entity) = interactor.closest { let interactable = interactable_query.get(interactable_entity).unwrap(); - if interactable.exclusive { + if interactable.exclusive && interactable.possible { event_writer.send(InteractionEvent { interactor: *interactor_entity, interactable: interactable_entity, @@ -52,7 +55,7 @@ fn handle_interactor_events( } else { for interactable_entity in &interactor.targets { let interactable = interactable_query.get(*interactable_entity).unwrap(); - if !interactable.exclusive { + if !interactable.exclusive && interactable.possible { event_writer.send(InteractionEvent { interactor: *interactor_entity, interactable: *interactable_entity, @@ -73,7 +76,11 @@ fn update_interactor_targets( let interactor_transform = transform_query.get(interactor_entity).unwrap(); let mut closest_active_interactable: Option<(f32, Entity)> = None; + interactor.targets.clear(); for (interactable_entity, interactable) in interactable_query.iter_mut() { + if !interactable.enabled { + continue; + } let interactable_transform = transform_query.get(interactable_entity).unwrap(); let interactable_distance_squared = interactable_transform .translation() @@ -85,7 +92,7 @@ fn update_interactor_targets( ), ); if interactable_distance_squared < interactable.max_distance_squared - && interactable_arccosine < PI / 8.0 + && interactable_arccosine < PI / 4.0 { interactor.targets.insert(interactable_entity); if let Some((arccosine, _)) = closest_active_interactable { @@ -97,8 +104,6 @@ fn update_interactor_targets( closest_active_interactable = Some((interactable_arccosine, interactable_entity)); } - } else { - interactor.targets.remove(&interactable_entity); } } interactor.closest = if let Some((_, interactable_entity)) = closest_active_interactable { @@ -108,3 +113,19 @@ fn update_interactor_targets( } } } + +fn update_interactable_predicates(world: &mut World) { + let mut interactable_query = world.query::<(Entity, &mut Interactable)>(); + let mut interactables = vec![]; + for (interactable_entity, interactable) in interactable_query.iter(world) { + interactables.push((interactable_entity, (*interactable).clone())); + } + for (interactable_entity, interactable) in interactables.iter_mut() { + if let Some(predicate) = &interactable.predicate { + interactable.possible = predicate(*interactable_entity, world); + } + } + for ((_, mut interactable), (_, temp)) in interactable_query.iter_mut(world).zip(interactables.into_iter()) { + *interactable = temp; + } +} -- cgit v1.2.3