refactor: modify assets to cross reference each other (#87)

Author: ssouthcity

src/assets/loaders/toml.rs

@@ -1,9 +1,26 @@
 use std::marker::PhantomData;
 
-use bevy::{asset::AssetLoader, prelude::*};
+use bevy::{
+    asset::{AssetLoader, LoadContext},
+    prelude::*,
+};
 use serde::Deserialize;
 use thiserror::Error;
 
+#[derive(Debug, Error)]
+pub enum TomlLoaderError {
+    #[error("Could not load asset: {0}")]
+    Io(#[from] std::io::Error),
+    #[error("Could not parse TOML: {0}")]
+    TomlError(#[from] toml::de::Error),
+}
+
+pub trait FromToml {
+    type Raw: for<'de> Deserialize<'de>;
+
+    fn from_toml(raw: Self::Raw, load_context: &mut LoadContext) -> Self;
+}
+
 pub struct TomlAssetPlugin<T> {
     extensions: Vec<&'static str>,
     _marker: PhantomData<T>,
@@ -20,7 +37,7 @@ impl<T> TomlAssetPlugin<T> {
 
 impl<T> Plugin for TomlAssetPlugin<T>
 where
-    T: Asset + for<'de> Deserialize<'de>,
+    T: Asset + FromToml,
 {
     fn build(&self, app: &mut App) {
         app.init_asset::<T>();
@@ -37,17 +54,9 @@ pub struct TomlAssetLoader<T> {
     _marker: PhantomData<T>,
 }
 
-#[derive(Debug, Error)]
-pub enum TomlLoaderError {
-    #[error("Could not load asset: {0}")]
-    Io(#[from] std::io::Error),
-    #[error("Could not parse TOML: {0}")]
-    TomlError(#[from] toml::de::Error),
-}
-
 impl<T> AssetLoader for TomlAssetLoader<T>
 where
-    T: Asset + for<'de> Deserialize<'de>,
+    T: Asset + FromToml,
 {
     type Asset = T;
     type Settings = ();
@@ -57,12 +66,12 @@ where
         &self,
         reader: &mut dyn bevy::asset::io::Reader,
         _settings: &Self::Settings,
-        _load_context: &mut bevy::asset::LoadContext<'_>,
+        load_context: &mut bevy::asset::LoadContext<'_>,
     ) -> Result<Self::Asset, Self::Error> {
         let mut bytes = Vec::new();
         reader.read_to_end(&mut bytes).await?;
-        let asset: T = toml::from_slice(&bytes)?;
-        Ok(asset)
+        let raw: T::Raw = toml::from_slice(&bytes)?;
+        Ok(T::from_toml(raw, load_context))
     }
 
     fn extensions(&self) -> &[&str] {

src/gameplay/hud/tome/mod.rs

@@ -7,7 +7,7 @@ use bevy::{
 use crate::{
     gameplay::{
         hud::tome::widgets::{TAB_COLOR_CHECKED, TAB_COLOR_DEFAULT},
-        recipe::assets::RecipeDef,
+        recipe::assets::Recipe,
     },
     input::input_map::{Action, action_just_pressed},
     screens::Screen,
@@ -74,7 +74,7 @@ pub enum TomeFocused {
     None,
     Item(Entity),
     People(Entity),
-    Recipes(AssetId<RecipeDef>),
+    Recipes(AssetId<Recipe>),
 }
 
 #[derive(Component, Reflect, Debug, Default)]

src/gameplay/hud/tome/tab_inspect.rs

@@ -5,7 +5,7 @@ use crate::{
         hud::tome::{TomeOpen, TomeTab, UITomeLeftPageRoot, UITomeRightPageRoot},
         item::inventory::Inventory,
         recipe::{
-            assets::RecipeDef,
+            assets::Recipe,
             select::{RecipeChanged, SelectRecipe},
         },
     },
@@ -40,7 +40,7 @@ pub struct Inspect {
 
 #[derive(Component, Reflect, Debug)]
 #[reflect(Component)]
-pub struct Recipe(pub AssetId<RecipeDef>);
+pub struct RecipeButton(pub AssetId<Recipe>);
 
 fn on_inspect(
     inspect: On<Inspect>,
@@ -56,7 +56,7 @@ fn on_inspect(
 fn spawn_inspect_recipes(
     mut commands: Commands,
     left_page: Single<Entity, With<UITomeLeftPageRoot>>,
-    recipes: Res<Assets<RecipeDef>>,
+    recipes: Res<Assets<Recipe>>,
 ) {
     let id = commands
         .spawn((
@@ -70,7 +70,7 @@ fn spawn_inspect_recipes(
         commands.spawn((
             widgets::recipe_plate(asset_id),
             ChildOf(id),
-            Recipe(asset_id),
+            RecipeButton(asset_id),
             observe(on_recipe_select),
         ));
     }
@@ -80,7 +80,7 @@ fn on_recipe_select(
     click: On<Pointer<Click>>,
     mut commands: Commands,
     inspected: Res<Inspected>,
-    recipe_badges: Query<&Recipe>,
+    recipe_badges: Query<&RecipeButton>,
 ) {
     let Ok(recipe) = recipe_badges.get(click.entity) else {
         return;

src/gameplay/hud/tome/tab_recipes.rs

@@ -3,7 +3,7 @@ use bevy::prelude::*;
 use crate::{
     gameplay::{
         hud::tome::{TomeTab, UITomeLeftPageRoot},
-        recipe::assets::RecipeDef,
+        recipe::assets::Recipe,
     },
     widgets,
 };
@@ -15,7 +15,7 @@ pub(super) fn plugin(app: &mut App) {
 fn spawn_recipe_list(
     mut commands: Commands,
     left_page: Single<Entity, With<UITomeLeftPageRoot>>,
-    recipe_defs: Res<Assets<RecipeDef>>,
+    recipes: Res<Assets<Recipe>>,
 ) {
     let recipe_list = commands
         .spawn((
@@ -25,7 +25,7 @@ fn spawn_recipe_list(
         ))
         .id();
 
-    for (asset_id, _) in recipe_defs.iter() {
+    for (asset_id, _) in recipes.iter() {
         commands.spawn((widgets::recipe_plate(asset_id), ChildOf(recipe_list)));
     }
 }

src/gameplay/item/assets.rs

@@ -3,7 +3,7 @@ use serde::Deserialize;
 
 use crate::assets::{
     indexing::{AssetIndexPlugin, Indexable},
-    loaders::toml::TomlAssetPlugin,
+    loaders::toml::{FromToml, TomlAssetPlugin},
     tracking::LoadResource,
 };
 
@@ -17,7 +17,7 @@ pub fn plugin(app: &mut App) {
 }
 
 #[derive(Asset, Clone, Debug, Deserialize, Reflect)]
-pub struct ItemDef {
+pub struct ItemRaw {
     pub id: String,
     pub name: String,
     pub description: String,
@@ -28,6 +28,43 @@ pub struct ItemDef {
     pub transport: Transport,
 }
 
+fn placeholder_sprite() -> String {
+    String::from("sprites/items/placeholder.png")
+}
+
+#[derive(Asset, Reflect, Debug)]
+pub struct ItemDef {
+    pub id: String,
+    pub name: String,
+    pub description: String,
+    pub sprite: AssetId<Image>,
+    pub stack_size: u32,
+    pub taxonomy: Taxonomy,
+    pub transport: Transport,
+}
+
+impl FromToml for ItemDef {
+    type Raw = ItemRaw;
+
+    fn from_toml(raw: Self::Raw, load_context: &mut bevy::asset::LoadContext) -> Self {
+        Self {
+            id: raw.id,
+            name: raw.name,
+            description: raw.description,
+            sprite: load_context.load(raw.sprite).id(),
+            stack_size: raw.stack_size,
+            taxonomy: raw.taxonomy,
+            transport: raw.transport,
+        }
+    }
+}
+
+impl Indexable for ItemDef {
+    fn index(&self) -> &String {
+        &self.id
+    }
+}
+
 #[derive(Component, Clone, Debug, Deserialize, Reflect, PartialEq, Eq)]
 #[reflect(Component)]
 pub enum Taxonomy {
@@ -42,16 +79,6 @@ pub enum Transport {
     Bag,
 }
 
-fn placeholder_sprite() -> String {
-    String::from("sprites/items/placeholder.png")
-}
-
-impl Indexable for ItemDef {
-    fn index(&self) -> &String {
-        &self.id
-    }
-}
-
 #[derive(Asset, Clone, Resource, Reflect)]
 #[reflect(Resource)]
 pub struct ItemAssets {

src/gameplay/item/stack.rs

@@ -12,7 +12,7 @@ use crate::gameplay::{
         porter::{PorterArrival, PorterLost},
     },
     recipe::{
-        assets::RecipeDef,
+        assets::Recipe,
         select::{RecipeChanged, SelectedRecipe},
     },
     world::{
@@ -41,7 +41,7 @@ pub struct WalkPath(pub Vec<Entity>);
 
 fn pathfind(
     structures: Query<(Entity, &SelectedRecipe)>,
-    recipes: Res<Assets<RecipeDef>>,
+    recipes: Res<Assets<Recipe>>,
     pathable_query: Query<&Pathable>,
     coordinates: Query<&Coord>,
     mut commands: Commands,

src/gameplay/logistics/pathfinding.rs

@@ -1,18 +1,15 @@
 use bevy::{prelude::*, sprite::Anchor};
 use bevy_aseprite_ultra::prelude::{Animation, AseAnimation};
 
-use crate::{
-    assets::indexing::IndexMap,
-    gameplay::{
-        FactorySystems,
-        item::{
-            assets::{ItemDef, Transport},
-            inventory::Inventory,
-        },
-        logistics::pathfinding::{PorterPaths, WalkPath},
-        recipe::{assets::RecipeDef, select::SelectedRecipe},
-        sprite_sort::{YSortSprite, ZIndexSprite},
+use crate::gameplay::{
+    FactorySystems,
+    item::{
+        assets::{ItemDef, Transport},
+        inventory::Inventory,
     },
+    logistics::pathfinding::{PorterPaths, WalkPath},
+    recipe::{assets::Recipe, select::SelectedRecipe},
+    sprite_sort::{YSortSprite, ZIndexSprite},
 };
 
 pub(super) fn plugin(app: &mut App) {
@@ -69,9 +66,8 @@ fn spawn_porter(
         &mut PorterPaths,
     )>,
     mut commands: Commands,
-    item_definitions: Res<Assets<ItemDef>>,
-    item_index: Res<IndexMap<ItemDef>>,
-    recipe_defs: Res<Assets<RecipeDef>>,
+    item_defs: Res<Assets<ItemDef>>,
+    recipes: Res<Assets<Recipe>>,
     asset_server: Res<AssetServer>,
     time: Res<Time>,
 ) {
@@ -89,16 +85,11 @@ fn spawn_porter(
             continue;
         }
 
-        let Some(recipe) = recipe_defs.get(&selected_recipe.0) else {
+        let Some(recipe) = recipes.get(&selected_recipe.0) else {
             continue;
         };
 
-        let Some(item_id) = recipe
-            .output
-            .iter()
-            .nth(index.0)
-            .and_then(|(raw_item_id, _)| item_index.get(raw_item_id))
-        else {
+        let Some((item_id, _)) = recipe.output.iter().nth(index.0) else {
             continue;
         };
 
@@ -114,7 +105,7 @@ fn spawn_porter(
             continue;
         };
 
-        let Some(item_def) = item_definitions.get(*item_id) else {
+        let Some(item_def) = item_defs.get(*item_id) else {
             continue;
         };
 

src/gameplay/logistics/porter.rs

@@ -3,7 +3,10 @@ use rand::seq::SliceRandom;
 use serde::Deserialize;
 
 use crate::{
-    assets::{loaders::toml::TomlAssetPlugin, tracking::LoadResource},
+    assets::{
+        loaders::toml::{FromToml, TomlAssetPlugin},
+        tracking::LoadResource,
+    },
     gameplay::random::Seed,
     screens::Screen,
 };
@@ -25,11 +28,26 @@ pub(super) fn plugin(app: &mut App) {
     );
 }
 
-#[derive(Asset, Reflect, Deserialize)]
+#[derive(Deserialize)]
+pub struct NamesRaw {
+    pub neutral_names: Vec<String>,
+}
+
+#[derive(Asset, Reflect, Debug)]
 pub struct Names {
     pub neutral_names: Vec<String>,
 }
 
+impl FromToml for Names {
+    type Raw = NamesRaw;
+
+    fn from_toml(raw: Self::Raw, _load_context: &mut bevy::asset::LoadContext) -> Self {
+        Self {
+            neutral_names: raw.neutral_names,
+        }
+    }
+}
+
 #[derive(Asset, Resource, Reflect, Debug, Clone)]
 #[reflect(Resource)]
 pub struct NameAssets {

src/gameplay/people/naming.rs

@@ -26,10 +26,10 @@ pub(super) fn plugin(app: &mut App) {
 #[reflect(Component)]
 pub struct Player;
 
-fn spawn_player(mut commands: Commands, assets: Res<Assets<ItemDef>>, mut seed: ResMut<Seed>) {
+fn spawn_player(mut commands: Commands, item_defs: Res<Assets<ItemDef>>, mut seed: ResMut<Seed>) {
     let mut inventory = Inventory::default();
 
-    for (item_id, _) in assets.iter() {
+    for (item_id, _) in item_defs.iter() {
         inventory.items.insert(item_id, seed.random_range(0..100));
     }