feat: rework porters to be a task of people (#90)

Author: ssouthcity

src/gameplay/logistics/mod.rs

@@ -4,7 +4,6 @@ use crate::screens::Screen;
 
 pub mod hud;
 pub mod item;
-pub mod logistics;
 pub mod people;
 pub mod player;
 pub mod random;
@@ -30,7 +29,6 @@ pub fn plugin(app: &mut App) {
     app.add_plugins((
         hud::plugin,
         item::plugin,
-        logistics::plugin,
         people::plugin,
         player::plugin,
         random::plugin,

src/gameplay/mod.rs

@@ -1,9 +1,18 @@
 use bevy::prelude::*;
 
+use crate::gameplay::world::construction::StructureConstructed;
+
 pub mod naming;
+pub mod pathfinding;
+pub mod porting;
 
 pub(super) fn plugin(app: &mut App) {
-    app.add_plugins((naming::plugin,));
+    app.add_plugins((naming::plugin, pathfinding::plugin, porting::plugin));
+
+    app.add_systems(
+        FixedUpdate,
+        add_housed_people_to_new_structures.run_if(on_message::<StructureConstructed>),
+    );
 }
 
 #[derive(Component, Reflect, Debug, Default)]
@@ -19,3 +28,14 @@ pub struct Houses(Vec<Entity>);
 #[reflect(Component)]
 #[relationship(relationship_target = Houses)]
 pub struct HousedIn(pub Entity);
+
+fn add_housed_people_to_new_structures(
+    mut structures_constructed: MessageReader<StructureConstructed>,
+    mut commands: Commands,
+) {
+    for StructureConstructed(structure) in structures_constructed.read() {
+        for _ in 0..3 {
+            commands.spawn((Name::new("Person"), Person, HousedIn(*structure)));
+        }
+    }
+}

src/gameplay/people/mod.rs

@@ -7,26 +7,25 @@ use bevy::{
 
 use crate::gameplay::{
     FactorySystems,
-    logistics::{
-        path::Pathable,
-        porter::{PorterArrival, PorterLost},
-    },
+    people::porting::{PorterArrival, PorterLost, Porting},
     recipe::{
         assets::Recipe,
         select::{RecipeChanged, SelectedRecipe},
     },
     world::{
         construction::{Constructions, StructureConstructed},
+        demolition::Demolished,
         tilemap::coord::Coord,
     },
 };
 
 pub(super) fn plugin(app: &mut App) {
     app.add_systems(
         FixedUpdate,
-        pathfind
-            .in_set(FactorySystems::Logistics)
-            .run_if(on_message::<RecipeChanged>.or(on_message::<StructureConstructed>)),
+        pathfind.in_set(FactorySystems::Logistics).run_if(
+            on_message::<RecipeChanged>
+                .or(on_message::<StructureConstructed>.or(on_message::<Demolished>)),
+        ),
     );
 
     app.add_systems(
@@ -35,9 +34,17 @@ pub(super) fn plugin(app: &mut App) {
     );
 }
 
-#[derive(Component, Reflect)]
+#[derive(Component, Reflect, Default)]
 #[reflect(Component)]
-pub struct WalkPath(pub Vec<Entity>);
+pub struct Pathable {
+    pub walkable: bool,
+}
+
+impl Pathable {
+    pub fn walkable() -> Self {
+        Self { walkable: true }
+    }
+}
 
 fn pathfind(
     structures: Query<(Entity, &SelectedRecipe)>,
@@ -120,17 +127,17 @@ fn pathfind(
 pub struct PorterPaths(pub VecDeque<(Entity, Vec<Entity>)>);
 
 fn walk_along_path(
-    query: Query<(Entity, &mut Transform, &mut WalkPath, &mut Sprite)>,
-    transforms: Query<&Transform, Without<WalkPath>>,
+    porters: Query<(Entity, &mut Transform, &mut Porting, &mut Sprite)>,
+    transforms: Query<&Transform, Without<Porting>>,
     time: Res<Time>,
     mut porter_arrivals: MessageWriter<PorterArrival>,
     mut porter_losses: MessageWriter<PorterLost>,
 ) {
     const SPEED: f32 = 64.0;
     const ARRIVAL_THRESHHOLD: f32 = 16.0;
 
-    for (entity, mut transform, mut walk_path, mut sprite) in query {
-        let Some(goal) = walk_path.0.last() else {
+    for (entity, mut transform, mut porting, mut sprite) in porters {
+        let Some(goal) = porting.path.last() else {
             continue;
         };
 
@@ -146,9 +153,9 @@ fn walk_along_path(
             .move_towards(goal_transform.translation, SPEED * time.delta_secs());
 
         if transform.translation.distance(goal_transform.translation) <= ARRIVAL_THRESHHOLD {
-            walk_path.0.pop();
+            porting.path.pop();
 
-            if walk_path.0.is_empty() {
+            if porting.path.is_empty() {
                 porter_arrivals.write(PorterArrival(entity));
             }
         }

src/gameplay/logistics/pathfinding.rs src/gameplay/people/pathfinding.rssrc/gameplay/logistics/pathfinding.rs renamed to src/gameplay/people/pathfinding.rs

@@ -7,7 +7,8 @@ use crate::gameplay::{
         assets::{ItemDef, Transport},
         inventory::Inventory,
     },
-    logistics::pathfinding::{PorterPaths, WalkPath},
+    people::pathfinding::PorterPaths,
+    people::{Houses, Person},
     recipe::{assets::Recipe, select::SelectedRecipe},
     sprite_sort::{YSortSprite, ZIndexSprite},
 };
@@ -25,46 +26,39 @@ pub(super) fn plugin(app: &mut App) {
 #[derive(Component, Reflect, Deref, DerefMut)]
 #[reflect(Component)]
 #[require(PorterSpawnOutputIndex)]
-pub struct PorterSpawnTimer(pub Timer);
+pub struct PorterCooldown(pub Timer);
 
 #[derive(Component, Reflect, Deref, DerefMut, Default)]
 #[reflect(Component)]
 struct PorterSpawnOutputIndex(usize);
 
-#[derive(Component, Reflect)]
-#[reflect(Component)]
-#[relationship_target(relationship = PorterOf)]
-pub struct Porters(Vec<Entity>);
-
-#[derive(Component, Reflect)]
-#[reflect(Component)]
-#[relationship(relationship_target = Porters)]
-pub struct PorterOf(pub Entity);
-
-#[derive(Component, Reflect)]
-#[reflect(Component)]
-pub struct PorterTo(pub Entity);
-
-#[derive(Component, Reflect)]
-#[reflect(Component)]
-pub struct PortingItem(pub AssetId<ItemDef>);
-
 #[derive(Message, Reflect, Debug)]
 pub struct PorterArrival(pub Entity);
 
 #[derive(Message, Reflect, Debug)]
 pub struct PorterLost(pub Entity);
 
+#[derive(Component, Reflect, Debug)]
+#[reflect(Component)]
+pub struct Porting {
+    pub item: AssetId<ItemDef>,
+    pub source: Entity,
+    pub destination: Entity,
+    pub path: Vec<Entity>,
+}
+
 fn spawn_porter(
     structure_query: Query<(
         Entity,
         &Transform,
-        &mut PorterSpawnTimer,
+        &mut PorterCooldown,
         &mut PorterSpawnOutputIndex,
         &SelectedRecipe,
         &mut Inventory,
         &mut PorterPaths,
+        &Houses,
     )>,
+    person_query: Query<(), (With<Person>, Without<Porting>)>,
     mut commands: Commands,
     item_defs: Res<Assets<ItemDef>>,
     recipes: Res<Assets<Recipe>>,
@@ -79,12 +73,17 @@ fn spawn_porter(
         selected_recipe,
         mut inventory,
         mut porter_paths,
+        houses,
     ) in structure_query
     {
         if !timer.tick(time.delta()).is_finished() {
             continue;
         }
 
+        let Some(person) = houses.iter().find(|e| person_query.contains(*e)) else {
+            continue;
+        };
+
         let Some(recipe) = recipes.get(&selected_recipe.0) else {
             continue;
         };
@@ -101,16 +100,15 @@ fn spawn_porter(
             continue;
         }
 
-        let Some((input, path)) = porter_paths.0.front() else {
+        let Some((destination, path)) = porter_paths.0.front() else {
             continue;
         };
 
         let Some(item_def) = item_defs.get(*item_id) else {
             continue;
         };
 
-        commands.spawn((
-            Name::new("Porter"),
+        commands.entity(person).insert((
             *transform,
             Sprite::default(),
             Anchor(Vec2::new(0.0, -0.25)),
@@ -121,13 +119,14 @@ fn spawn_porter(
                     Transport::Bag => Animation::tag("walk_bag"),
                 },
             },
-            Inventory::with_single(*item_id, 1),
             YSortSprite,
             ZIndexSprite(10),
-            PorterOf(structure),
-            PorterTo(*input),
-            PortingItem(*item_id),
-            WalkPath(path.clone()),
+            Porting {
+                item: *item_id,
+                source: structure,
+                destination: *destination,
+                path: path.clone(),
+            },
         ));
 
         *quantity -= 1;
@@ -139,25 +138,27 @@ fn spawn_porter(
 
 fn despawn_lost_porters(mut porter_losses: MessageReader<PorterLost>, mut commands: Commands) {
     for PorterLost(entity) in porter_losses.read() {
-        commands.entity(*entity).despawn();
+        commands.entity(*entity).remove::<(Sprite, Porting)>();
     }
 }
 
 fn drop_of_items(
     mut poter_arrivals: MessageReader<PorterArrival>,
-    porters: Query<(&PortingItem, &PorterTo)>,
+    porters: Query<&Porting>,
     mut structures: Query<&mut Inventory>,
     mut commands: Commands,
 ) {
     for PorterArrival(porter) in poter_arrivals.read() {
-        commands.entity(*porter).despawn();
+        commands.entity(*porter).remove::<(Sprite, Porting)>();
 
-        let (PortingItem(item_id), PorterTo(structure)) = porters.get(*porter).unwrap();
+        let Ok(porting) = porters.get(*porter) else {
+            continue;
+        };
 
-        if let Ok(mut inventory) = structures.get_mut(*structure) {
+        if let Ok(mut inventory) = structures.get_mut(porting.destination) {
             inventory
                 .items
-                .entry(*item_id)
+                .entry(porting.item)
                 .and_modify(|q| *q += 1)
                 .or_insert(1);
         }

src/gameplay/logistics/porter.rs src/gameplay/people/porting.rssrc/gameplay/logistics/porter.rs renamed to src/gameplay/people/porting.rs

@@ -21,8 +21,7 @@ pub fn plugin(app: &mut App) {
     app.add_systems(
         FixedUpdate,
         (
-            (add_people_to_harvester, assign_harvester_taxonomy)
-                .run_if(on_message::<StructureConstructed>),
+            assign_harvester_taxonomy.run_if(on_message::<StructureConstructed>),
             sync_harvester_range,
             assign_harvester_deposit,
             harvest_deposit,
@@ -52,22 +51,6 @@ pub struct Harvests(pub Entity);
 #[reflect(Component)]
 pub struct HarvestTimer(pub Timer);
 
-fn add_people_to_harvester(
-    mut structures_constructed: MessageReader<StructureConstructed>,
-    harvester_query: Query<Entity, With<Harvester>>,
-    mut commands: Commands,
-) {
-    for StructureConstructed(structure) in structures_constructed.read() {
-        if !harvester_query.contains(*structure) {
-            continue;
-        }
-
-        for _ in 0..3 {
-            commands.spawn((Name::new("Person"), Person, HousedIn(*structure)));
-        }
-    }
-}
-
 fn assign_harvester_taxonomy(
     mut structures_constructed: MessageReader<StructureConstructed>,
     mut harvester_query: Query<(&Coord, &Range, &mut AseAnimation), With<Harvester>>,

src/gameplay/structure/harvest.rs

@@ -3,7 +3,7 @@ use std::time::Duration;
 use bevy::prelude::*;
 
 use crate::gameplay::{
-    logistics::porter::PorterSpawnTimer, structure::assets::StructureDef,
+    people::porting::PorterCooldown, structure::assets::StructureDef,
     world::demolition::Demolishable,
 };
 
@@ -12,6 +12,7 @@ pub mod default_recipe;
 pub mod harvest;
 pub mod highlight;
 pub mod interactable;
+pub mod path;
 pub mod range;
 
 pub fn plugin(app: &mut App) {
@@ -21,13 +22,14 @@ pub fn plugin(app: &mut App) {
         harvest::plugin,
         highlight::plugin,
         interactable::plugin,
+        path::plugin,
     ));
 }
 
 #[derive(Component, Reflect)]
 #[reflect(Component)]
 #[require(
-    PorterSpawnTimer(Timer::new(Duration::from_secs(5), TimerMode::Repeating)),
+    PorterCooldown(Timer::new(Duration::from_secs(5), TimerMode::Once)),
     Demolishable
 )]
 pub struct Structure(pub Handle<StructureDef>);