chore: unify inventory to storage component (#76)

Author: ssouthcity

src/gameplay/hud/inspect/info.rs

@@ -4,8 +4,8 @@ use crate::{
     assets::indexing::IndexMap,
     gameplay::{
         hud::inspect::{InspectedEntity, InspectionMenuState},
-        item::inventory::Slots,
         recipe::{Input, Output, assets::RecipeDef, select::SelectedRecipe},
+        storage::Storage,
     },
     widgets::{
         self,
@@ -28,14 +28,14 @@ pub struct HeldRelic(Entity);
 pub fn open_recipe_menu(
     mut commands: Commands,
     inspected_entity: Res<InspectedEntity>,
-    structure_query: Query<(&SelectedRecipe, &Slots)>,
+    structure_query: Query<(&SelectedRecipe, &Storage)>,
     input_query: Query<(), With<Input>>,
     output_query: Query<(), With<Output>>,
     recipes: Res<Assets<RecipeDef>>,
     recipe_index: Res<IndexMap<RecipeDef>>,
     held_relics: Query<&HeldRelic>,
 ) {
-    let Ok((selected_recipe, slots)) = structure_query.get(inspected_entity.0) else {
+    let Ok((selected_recipe, storage)) = structure_query.get(inspected_entity.0) else {
         return;
     };
 
@@ -119,7 +119,7 @@ pub fn open_recipe_menu(
         ))
         .id();
 
-    for input in slots.iter().filter(|s| input_query.contains(*s)) {
+    for input in storage.iter().filter(|s| input_query.contains(*s)) {
         let slot = commands
             .spawn((ChildOf(input_list_id), widgets::slot::slot_container()))
             .id();
@@ -192,7 +192,7 @@ pub fn open_recipe_menu(
         ))
         .id();
 
-    for output in slots.iter().filter(|s| output_query.contains(*s)) {
+    for output in storage.iter().filter(|s| output_query.contains(*s)) {
         let slot = commands
             .spawn((ChildOf(output_list_id), widgets::slot::slot_container()))
             .id();

src/gameplay/hud/inventory/items.rs

@@ -1,8 +1,9 @@
 use bevy::{prelude::*, ui::Checked, ui_widgets::RadioButton};
 
 use crate::gameplay::{
-    hud::inventory::{InInventory, UIEntry, UIEntryDetails, UIEntryList, UIInventoryTab},
+    hud::inventory::{UIEntry, UIEntryDetails, UIEntryList, UIInventoryTab},
     item::{assets::ItemDef, stack::Stack},
+    storage::StoredBy,
 };
 
 pub(super) fn plugin(app: &mut App) {
@@ -31,7 +32,7 @@ fn fill_item_inventory(
     q_tab: Single<&UIInventoryTab, Changed<Checked>>,
     q_entry_list: Single<Entity, With<UIEntryList>>,
     q_entry_details: Single<Entity, With<UIEntryDetails>>,
-    q_items: Query<&Stack, With<InInventory>>,
+    q_items: Query<&Stack, With<StoredBy>>,
     mut commands: Commands,
 ) {
     commands.entity(*q_entry_list).despawn_children();

src/gameplay/hud/inventory/mod.rs

@@ -5,11 +5,6 @@ use bevy::{
     ui_widgets::{RadioButton, RadioGroup, ValueChange, observe},
 };
 
-use crate::{
-    gameplay::item::{assets::ItemDef, stack::Stack},
-    screens::Screen,
-};
-
 pub mod items;
 pub mod people;
 
@@ -27,8 +22,6 @@ pub(super) fn plugin(app: &mut App) {
 
     app.add_systems(Startup, spawn_ui_root);
 
-    app.add_systems(OnEnter(Screen::Gameplay), spawn_inventory);
-
     app.add_systems(
         Update,
         (
@@ -229,27 +222,3 @@ fn entry_details(asset_server: &AssetServer) -> impl Bundle {
         },
     )
 }
-
-#[derive(Component, Reflect, Debug, Default)]
-#[reflect(Component)]
-pub struct InInventory;
-
-fn spawn_inventory(
-    asset_server: Res<AssetServer>,
-    item_defs: Res<Assets<ItemDef>>,
-    mut commands: Commands,
-) {
-    let inventory = commands.spawn(Name::new("Inventory")).id();
-
-    for (item_id, item_def) in item_defs.iter() {
-        commands.spawn((
-            Name::new(item_def.name.clone()),
-            ChildOf(inventory),
-            Stack {
-                item: asset_server.get_id_handle(item_id).unwrap(),
-                quantity: 0,
-            },
-            InInventory,
-        ));
-    }
-}

src/gameplay/item/inventory.rs

@@ -1,13 +1,33 @@
 use bevy::prelude::*;
 
-pub(super) fn plugin(_app: &mut App) {}
+use crate::{
+    gameplay::{
+        item::{assets::ItemDef, stack::Stack},
+        storage::StoredBy,
+    },
+    screens::Screen,
+};
 
-#[derive(Component, Reflect, Debug)]
-#[reflect(Component)]
-#[relationship_target(relationship = SlotOf, linked_spawn)]
-pub struct Slots(Vec<Entity>);
+pub(super) fn plugin(app: &mut App) {
+    app.add_systems(OnEnter(Screen::Gameplay), spawn_inventory);
+}
 
-#[derive(Component, Reflect, Debug)]
-#[reflect(Component)]
-#[relationship(relationship_target = Slots)]
-pub struct SlotOf(pub Entity);
+fn spawn_inventory(
+    asset_server: Res<AssetServer>,
+    item_defs: Res<Assets<ItemDef>>,
+    mut commands: Commands,
+) {
+    let inventory = commands.spawn(Name::new("Inventory")).id();
+
+    for (item_id, item_def) in item_defs.iter() {
+        commands.spawn((
+            Name::new(item_def.name.clone()),
+            Stack {
+                item: asset_server.get_id_handle(item_id).unwrap(),
+                quantity: 0,
+            },
+            StoredBy(inventory),
+            ChildOf(inventory),
+        ));
+    }
+}

src/gameplay/logistics/pathfinding.rs

@@ -7,15 +7,13 @@ use bevy::{
 
 use crate::gameplay::{
     FactorySystems,
-    item::{
-        inventory::{SlotOf, Slots},
-        stack::Stack,
-    },
+    item::stack::Stack,
     logistics::{
         path::Pathable,
         porter::{PorterArrival, PorterLost},
     },
     recipe::{Input, Output, select::RecipeChanged},
+    storage::{Storage, StoredBy},
     world::{
         construction::{Constructions, StructureConstructed},
         tilemap::coord::Coord,
@@ -41,15 +39,15 @@ pub(super) fn plugin(app: &mut App) {
 pub struct WalkPath(pub Vec<Entity>);
 
 fn pathfind(
-    output_query: Query<(Entity, &Stack, &SlotOf), With<Output>>,
-    slots_query: Query<&Slots>,
+    output_query: Query<(Entity, &Stack, &StoredBy), With<Output>>,
+    storage_query: Query<&Storage>,
     input_query: Query<&Stack, With<Input>>,
     pathable_query: Query<&Pathable>,
     coordinates: Query<&Coord>,
     mut commands: Commands,
     constructions: Res<Constructions>,
 ) {
-    for (entity, stack, SlotOf(start)) in output_query {
+    for (entity, stack, StoredBy(start)) in output_query {
         let mut queue = VecDeque::new();
         let mut visited = HashSet::new();
         let mut parent = HashMap::new();
@@ -78,10 +76,10 @@ fn pathfind(
                 visited.insert(*neighbor);
                 parent.insert(neighbor, current);
 
-                let input_entity = slots_query.get(*neighbor).ok().and_then(|slots| {
-                    slots
+                let input_entity = storage_query.get(*neighbor).ok().and_then(|storage| {
+                    storage
                         .iter()
-                        .find(|slot| input_query.get(*slot).is_ok_and(|i| i.item == stack.item))
+                        .find(|stored| input_query.get(*stored).is_ok_and(|i| i.item == stack.item))
                 });
 
                 if let Some(goal) = input_entity {

src/gameplay/logistics/porter.rs

@@ -5,12 +5,12 @@ use crate::gameplay::{
     FactorySystems,
     item::{
         assets::{ItemDef, Transport},
-        inventory::Slots,
         stack::Stack,
     },
     logistics::pathfinding::{PorterPaths, WalkPath},
     recipe::Output,
     sprite_sort::{YSortSprite, ZIndexSprite},
+    storage::Storage,
 };
 
 pub(super) fn plugin(app: &mut App) {
@@ -62,22 +62,22 @@ fn spawn_porter(
         &Transform,
         &mut PorterSpawnTimer,
         &mut PorterSpawnOutputIndex,
-        &Slots,
+        &Storage,
     )>,
     mut output_query: Query<(&mut Stack, &mut PorterPaths), With<Output>>,
     mut commands: Commands,
     item_definitions: Res<Assets<ItemDef>>,
     asset_server: Res<AssetServer>,
     time: Res<Time>,
 ) {
-    for (structure, transform, mut timer, mut index, slots) in structure_query {
+    for (structure, transform, mut timer, mut index, storage) in structure_query {
         if !timer.tick(time.delta()).is_finished() {
             continue;
         }
 
-        let outputs = slots
+        let outputs = storage
             .iter()
-            .filter(|slot| output_query.contains(*slot))
+            .filter(|stored| output_query.contains(*stored))
             .collect::<Vec<Entity>>();
 
         let Some(output) = outputs.get(index.0) else {

src/gameplay/mod.rs

@@ -7,6 +7,7 @@ pub mod item;
 pub mod logistics;
 pub mod recipe;
 pub mod sprite_sort;
+pub mod storage;
 pub mod structure;
 pub mod world;
 

src/gameplay/recipe/process.rs

@@ -4,8 +4,9 @@ use crate::{
     assets::indexing::IndexMap,
     gameplay::{
         FactorySystems,
-        item::{inventory::Slots, stack::Stack},
+        item::stack::Stack,
         recipe::{Input, Output, assets::RecipeDef, select::SelectedRecipe},
+        storage::Storage,
     },
 };
 
@@ -41,26 +42,26 @@ impl ProcessState {
 }
 
 fn consume_input(
-    query: Query<(&mut ProcessState, &Slots, &SelectedRecipe)>,
+    query: Query<(&mut ProcessState, &Storage, &SelectedRecipe)>,
     mut input_query: Query<(&mut Stack, &Input)>,
     recipes: Res<Assets<RecipeDef>>,
     recipe_index: Res<IndexMap<RecipeDef>>,
 ) {
-    for (mut state, slots, selected_recipe) in query {
+    for (mut state, storage, selected_recipe) in query {
         if !matches!(*state, ProcessState::InsufficientInput) {
             continue;
         }
 
-        if !slots
+        if !storage
             .iter()
-            .filter_map(|slot| input_query.get(slot).ok())
+            .filter_map(|stored| input_query.get(stored).ok())
             .all(|(stack, input)| stack.quantity >= input.quantity)
         {
             continue;
         }
 
-        for slot in slots.iter() {
-            if let Ok((mut stack, input)) = input_query.get_mut(slot) {
+        for stored in storage.iter() {
+            if let Ok((mut stack, input)) = input_query.get_mut(stored) {
                 stack.quantity = stack.quantity.saturating_sub(input.quantity);
             }
         }
@@ -91,16 +92,16 @@ fn progress_work(query: Query<&mut ProcessState>, time: Res<Time>) {
 }
 
 fn produce_output(
-    query: Query<(&mut ProcessState, &Slots)>,
+    query: Query<(&mut ProcessState, &Storage)>,
     mut output_query: Query<(&mut Stack, &Output)>,
 ) {
-    for (mut state, slots) in query {
+    for (mut state, storage) in query {
         if !matches!(*state, ProcessState::Completed) {
             continue;
         }
 
-        for output in slots.iter() {
-            let Ok((mut stack, output)) = output_query.get_mut(output) else {
+        for stored in storage.iter() {
+            let Ok((mut stack, output)) = output_query.get_mut(stored) else {
                 continue;
             };
 

src/gameplay/recipe/select.rs

@@ -4,12 +4,9 @@ use super::process::ProcessState;
 use crate::{
     assets::indexing::IndexMap,
     gameplay::{
-        item::{
-            assets::ItemDef,
-            inventory::{SlotOf, Slots},
-            stack::Stack,
-        },
+        item::{assets::ItemDef, stack::Stack},
         recipe::{Input, Output, assets::RecipeDef},
+        storage::{Storage, StoredBy},
     },
 };
 
@@ -49,7 +46,7 @@ fn on_select_recipe(
 
     commands
         .entity(select_recipe.entity)
-        .despawn_related::<Slots>();
+        .despawn_related::<Storage>();
 
     for (item_id, quantity) in recipe_def.input.iter() {
         let item_handle = item_index
@@ -60,7 +57,7 @@ fn on_select_recipe(
         commands.spawn((
             Name::new("Input"),
             ChildOf(select_recipe.entity),
-            SlotOf(select_recipe.entity),
+            StoredBy(select_recipe.entity),
             Stack::empty(item_handle),
             Input {
                 quantity: *quantity,
@@ -77,7 +74,7 @@ fn on_select_recipe(
         commands.spawn((
             Name::new("Output"),
             ChildOf(select_recipe.entity),
-            SlotOf(select_recipe.entity),
+            StoredBy(select_recipe.entity),
             Stack::empty(item_handle),
             Output {
                 quantity: *quantity,

src/gameplay/storage.rs

@@ -0,0 +1,11 @@
+use bevy::prelude::*;
+
+#[derive(Component, Reflect, Debug)]
+#[reflect(Component)]
+#[relationship_target(relationship = StoredBy, linked_spawn)]
+pub struct Storage(Vec<Entity>);
+
+#[derive(Component, Reflect, Debug)]
+#[reflect(Component)]
+#[relationship(relationship_target = Storage)]
+pub struct StoredBy(pub Entity);