refactor: code review on dismantle systems (#33)

Author: ssouthcity

src/gameplay/logistics/path.rs

@@ -2,8 +2,10 @@ use bevy::{platform::collections::HashSet, prelude::*};
 
 use crate::gameplay::{
     FactorySystems,
-    structure::Structure,
-    world::terrain::{Terrain, Worldly},
+    world::{
+        demolition::Demolishable,
+        terrain::{Terrain, Worldly},
+    },
     y_sort::YSort,
 };
 
@@ -151,7 +153,7 @@ fn build_paths(
                 ..default()
             },
             YSort(0.5),
-            Structure,
+            Demolishable,
             Pickable::default(),
         ));
 
@@ -183,7 +185,7 @@ fn spawn_intersection(
             Pathable::walkable(),
             Pickable::default(),
             YSort::default(),
-            Structure,
+            Demolishable,
         ));
 
         paths_updated_events.write(PathsUpdated);

src/gameplay/mod.rs

@@ -19,7 +19,7 @@ pub fn plugin(app: &mut App) {
             FactorySystems::Power,
             FactorySystems::Logistics,
             FactorySystems::Work,
-            FactorySystems::Dismantle,
+            FactorySystems::Demolish,
             FactorySystems::UI,
         )
             .chain()
@@ -44,6 +44,6 @@ pub enum FactorySystems {
     Power,
     Logistics,
     Work,
-    Dismantle,
+    Demolish,
     UI,
 }

src/gameplay/structure/dismantle.rs

@@ -1,12 +1,6 @@
 use bevy::{picking::hover::PickingInteraction, prelude::*};
 
-use crate::gameplay::{
-    structure::{
-        Structure,
-        dismantle::{DismantleTimer, Selection},
-    },
-    world::terrain::Terrain,
-};
+use crate::gameplay::{FactorySystems, world::terrain::Terrain};
 
 const HIGHLIGHT_COLOR: Color = Color::hsl(60.0, 1.0, 0.5);
 
@@ -15,10 +9,7 @@ pub fn plugin(app: &mut App) {
 
     app.init_resource::<HighlightColor>();
 
-    app.add_systems(
-        Update,
-        (highlight_pickable, calculate_dismantle_color, highlight).chain(),
-    );
+    app.add_systems(Update, highlight_pickable.before(FactorySystems::Demolish));
 }
 
 #[derive(Resource, Reflect)]
@@ -40,30 +31,3 @@ fn highlight_pickable(query: Query<(&mut Sprite, &PickingInteraction), Without<T
         }
     }
 }
-
-fn highlight(
-    building_sprites: Query<(Entity, &mut Sprite), With<Structure>>,
-    highlight_color: Res<HighlightColor>,
-    selection: Res<Selection>,
-) {
-    for (building, mut sprite) in building_sprites {
-        let color = if selection.contains(&building) {
-            highlight_color.0
-        } else {
-            Default::default()
-        };
-
-        sprite.color = color;
-    }
-}
-
-fn calculate_dismantle_color(
-    timer: Res<DismantleTimer>,
-    mut highlight_color: ResMut<HighlightColor>,
-) {
-    let inverse_fraction = 1.0 - timer.fraction();
-
-    let hue = 60.0 * inverse_fraction;
-
-    highlight_color.0.set_hue(hue);
-}

src/gameplay/structure/highlight.rs

@@ -2,11 +2,13 @@ use std::time::Duration;
 
 use bevy::prelude::*;
 
-use crate::gameplay::logistics::{path::Pathable, porter::PorterSpawnTimer};
+use crate::gameplay::{
+    logistics::{path::Pathable, porter::PorterSpawnTimer},
+    world::demolition::Demolishable,
+};
 
 pub mod assets;
 pub mod build;
-pub mod dismantle;
 pub mod highlight;
 pub mod interactable;
 
@@ -16,7 +18,6 @@ pub fn plugin(app: &mut App) {
     app.add_plugins((
         assets::plugin,
         build::plugin,
-        dismantle::plugin,
         highlight::plugin,
         interactable::plugin,
     ));
@@ -26,6 +27,7 @@ pub fn plugin(app: &mut App) {
 #[reflect(Component)]
 #[require(
     Pathable,
-    PorterSpawnTimer(Timer::new(Duration::from_secs(1), TimerMode::Repeating))
+    PorterSpawnTimer(Timer::new(Duration::from_secs(1), TimerMode::Repeating)),
+    Demolishable
 )]
 pub struct Structure;

src/gameplay/structure/mod.rs

@@ -0,0 +1,130 @@
+use std::collections::HashSet;
+
+use bevy::{input::common_conditions::input_just_pressed, prelude::*};
+
+use crate::gameplay::FactorySystems;
+
+pub const DEMOLISH_BUTTON: KeyCode = KeyCode::KeyF;
+pub const DEMOLISH_CANCEL_BUTTON: KeyCode = KeyCode::Escape;
+pub const DEMOLISH_DURATION_SECS: f32 = 1.0;
+
+pub(super) fn plugin(app: &mut App) {
+    app.register_type::<Demolishable>();
+
+    app.register_type::<DemolishSelection>();
+    app.init_resource::<DemolishSelection>();
+
+    app.register_type::<DemolishTimer>();
+    app.init_resource::<DemolishTimer>();
+
+    app.add_systems(
+        Update,
+        (
+            add_to_selection.run_if(on_event::<Pointer<Over>>),
+            remove_from_selection.run_if(on_event::<Pointer<Out>>),
+            clear_selection.run_if(input_just_pressed(DEMOLISH_CANCEL_BUTTON)),
+        )
+            .in_set(FactorySystems::Demolish),
+    );
+
+    app.add_systems(
+        Update,
+        (
+            tick_demolish_timer,
+            highlight_demolition,
+            demolish_selection.run_if(demolish_timer_finished),
+        )
+            .chain()
+            .in_set(FactorySystems::Demolish),
+    );
+}
+
+#[derive(Component, Reflect, Debug, Default)]
+#[reflect(Component)]
+pub struct Demolishable;
+
+#[derive(Resource, Reflect, Debug, Default, Deref, DerefMut)]
+#[reflect(Resource)]
+pub struct DemolishSelection(HashSet<Entity>);
+
+#[derive(Resource, Reflect, Debug, Deref, DerefMut)]
+#[reflect(Resource)]
+pub struct DemolishTimer(Timer);
+
+impl Default for DemolishTimer {
+    fn default() -> Self {
+        Self(Timer::from_seconds(DEMOLISH_DURATION_SECS, TimerMode::Once))
+    }
+}
+
+fn tick_demolish_timer(
+    mut timer: ResMut<DemolishTimer>,
+    keys: Res<ButtonInput<KeyCode>>,
+    time: Res<Time>,
+) {
+    if keys.just_released(DEMOLISH_BUTTON) {
+        timer.reset();
+    }
+
+    if keys.pressed(DEMOLISH_BUTTON) {
+        timer.tick(time.delta());
+    }
+}
+
+fn demolish_timer_finished(timer: Res<DemolishTimer>) -> bool {
+    timer.just_finished()
+}
+
+fn add_to_selection(
+    mut events: EventReader<Pointer<Over>>,
+    mut selection: ResMut<DemolishSelection>,
+    demolishables: Query<Entity, With<Demolishable>>,
+) {
+    for event in events.read() {
+        if !demolishables.contains(event.target) {
+            continue;
+        }
+
+        selection.insert(event.target);
+    }
+}
+
+fn remove_from_selection(
+    mut events: EventReader<Pointer<Out>>,
+    mut selection: ResMut<DemolishSelection>,
+    keys: Res<ButtonInput<KeyCode>>,
+) {
+    for event in events.read() {
+        if keys.pressed(KeyCode::ShiftLeft) {
+            continue;
+        }
+
+        selection.remove(&event.target);
+    }
+}
+
+fn clear_selection(mut selection: ResMut<DemolishSelection>) {
+    selection.clear();
+}
+
+fn highlight_demolition(
+    timer: Res<DemolishTimer>,
+    selection: Res<DemolishSelection>,
+    mut sprites: Query<&mut Sprite, With<Demolishable>>,
+) {
+    let inverse_fraction = 1.0 - timer.fraction();
+
+    let hue = 60.0 * inverse_fraction;
+
+    for entity in selection.iter() {
+        if let Ok(mut sprite) = sprites.get_mut(*entity) {
+            sprite.color = Color::hsl(hue, 1.0, 0.5);
+        }
+    }
+}
+
+fn demolish_selection(mut selection: ResMut<DemolishSelection>, mut commands: Commands) {
+    for demolishable in selection.drain() {
+        commands.entity(demolishable).despawn();
+    }
+}