feat: add people and naming logic (#79)

Author: ssouthcity

assets/names.toml

@@ -0,0 +1,102 @@
+neutral_names = [
+  "William",
+  "Robert",
+  "Richard",
+  "John",
+  "Geoffrey",
+  "Henry",
+  "Thomas",
+  "Edmund",
+  "Edward",
+  "Roger",
+  "Ralph",
+  "Walter",
+  "Hugh",
+  "Baldwin",
+  "Gilbert",
+  "Simon",
+  "Peter",
+  "Philip",
+  "Stephen",
+  "Reynold",
+  "Alan",
+  "Nicholas",
+  "Martin",
+  "Andrew",
+  "Michael",
+  "Bernard",
+  "Godfrey",
+  "Humphrey",
+  "Oswald",
+  "Anselm",
+  "Cedric",
+  "Alaric",
+  "Percival",
+  "Tristan",
+  "Gawain",
+  "Benedict",
+  "Frederick",
+  "Conrad",
+  "Otto",
+  "Ludwig",
+  "Klaus",
+  "Bruno",
+  "Gunther",
+  "Dietrich",
+  "Albrecht",
+  "Reinhard",
+  "Matthias",
+  "Gregor",
+  "Casimir",
+  "Thibault",
+  "Eleanor",
+  "Margaret",
+  "Isabella",
+  "Catherine",
+  "Joan",
+  "Alice",
+  "Agnes",
+  "Matilda",
+  "Emma",
+  "Beatrice",
+  "Cecilia",
+  "Constance",
+  "Edith",
+  "Maud",
+  "Rose",
+  "Anne",
+  "Elizabeth",
+  "Mary",
+  "Jane",
+  "Philippa",
+  "Eleanor",
+  "Blanche",
+  "Isabeau",
+  "Alienor",
+  "Giselle",
+  "Hildegard",
+  "Brunhilde",
+  "Gertrude",
+  "Adelaide",
+  "Clothilde",
+  "Griselda",
+  "Rowena",
+  "Guinevere",
+  "Vivienne",
+  "Morgana",
+  "Yseult",
+  "Mathilde",
+  "Bertha",
+  "Ingrid",
+  "Astrid",
+  "Freya",
+  "Signy",
+  "Helga",
+  "Ursula",
+  "Brigitte",
+  "Greta",
+  "Katarina",
+  "Lenore",
+  "Rosamund",
+  "Sybil",
+]

src/gameplay/hud/tome/tab_people.rs

@@ -1,16 +1,90 @@
 use bevy::prelude::*;
 
-use crate::gameplay::hud::tome::{TomeTab, UITomeLeftPageRoot, widgets};
+use crate::gameplay::{
+    hud::tome::{TomeTab, UIEntryList, UITomeLeftPageRoot, widgets},
+    people::Person,
+    player::Player,
+    storage::{Storage, StoredBy},
+};
 
 pub(super) fn plugin(app: &mut App) {
     app.add_systems(OnEnter(TomeTab::People), spawn_people_grid);
+
+    app.add_systems(
+        Update,
+        (backfill_people_grid, refresh_person_badges).run_if(in_state(TomeTab::People)),
+    );
+}
+
+#[derive(Component, Reflect, Debug)]
+#[reflect(Component)]
+pub struct PersonBadge(pub Entity);
+
+#[derive(Component, Reflect, Debug)]
+#[reflect(Component)]
+pub struct PersonName;
+
+fn person_badge(person: Entity) -> impl Bundle {
+    (
+        PersonBadge(person),
+        Node::default(),
+        children![(Text::default(), PersonName,)],
+    )
+}
+
+fn refresh_person_badges(
+    badges: Query<(Entity, &PersonBadge)>,
+    children: Query<&Children>,
+    people: Query<&Name, With<Person>>,
+    mut components: ParamSet<(Query<&mut Text, With<PersonName>>,)>,
+) {
+    for (badge, PersonBadge(person)) in badges {
+        let Ok(name) = people.get(*person) else {
+            continue;
+        };
+
+        for child in children.iter_descendants(badge) {
+            if let Ok(mut text) = components.p0().get_mut(child) {
+                text.0 = name.to_string();
+            }
+        }
+    }
+}
+
+fn spawn_people_grid(
+    mut commands: Commands,
+    left_page: Single<Entity, With<UITomeLeftPageRoot>>,
+    player: Single<Entity, With<Player>>,
+    storage: Query<&Storage>,
+    people: Query<Entity, With<Person>>,
+) {
+    let people_grid = commands
+        .spawn((
+            widgets::list_page(),
+            ChildOf(*left_page),
+            DespawnOnExit(TomeTab::People),
+        ))
+        .id();
+
+    for person in storage
+        .iter_descendants(*player)
+        .filter(|s| people.contains(*s))
+    {
+        commands.spawn((person_badge(person), ChildOf(people_grid)));
+    }
 }
 
-fn spawn_people_grid(mut commands: Commands, left_page: Single<Entity, With<UITomeLeftPageRoot>>) {
-    commands.spawn((
-        widgets::list_page(),
-        ChildOf(*left_page),
-        DespawnOnExit(TomeTab::People),
-        children![Text::new("People")],
-    ));
+fn backfill_people_grid(
+    mut commands: Commands,
+    people_grid: Single<Entity, With<UIEntryList>>,
+    player: Single<Entity, With<Player>>,
+    new_people: Query<(Entity, &StoredBy), (With<Person>, Added<StoredBy>)>,
+) {
+    for (person, stored_by) in new_people {
+        if stored_by.0 != *player {
+            continue;
+        }
+
+        commands.spawn((person_badge(person), ChildOf(*people_grid)));
+    }
 }

src/gameplay/mod.rs

@@ -5,7 +5,9 @@ use crate::screens::Screen;
 pub mod hud;
 pub mod item;
 pub mod logistics;
+pub mod people;
 pub mod player;
+pub mod random;
 pub mod recipe;
 pub mod sprite_sort;
 pub mod storage;
@@ -30,7 +32,9 @@ pub fn plugin(app: &mut App) {
         hud::plugin,
         item::plugin,
         logistics::plugin,
+        people::plugin,
         player::plugin,
+        random::plugin,
         recipe::plugin,
         sprite_sort::plugin,
         structure::plugin,

src/gameplay/people/mod.rs

@@ -0,0 +1,11 @@
+use bevy::prelude::*;
+
+pub mod naming;
+
+pub(super) fn plugin(app: &mut App) {
+    app.add_plugins((naming::plugin,));
+}
+
+#[derive(Component, Reflect, Debug, Default)]
+#[reflect(Component)]
+pub struct Person;

src/gameplay/people/naming.rs

@@ -0,0 +1,79 @@
+use bevy::prelude::*;
+use rand::seq::SliceRandom;
+use serde::Deserialize;
+
+use crate::{
+    assets::{loaders::toml::TomlAssetPlugin, tracking::LoadResource},
+    gameplay::random::Seed,
+    screens::Screen,
+};
+
+const REFILL_THRESHOLD: usize = 50;
+
+pub(super) fn plugin(app: &mut App) {
+    app.add_plugins(TomlAssetPlugin::<Names>::extensions(&["toml"]));
+
+    app.init_asset::<Names>();
+
+    app.load_resource::<NameAssets>();
+
+    app.init_resource::<NameManager>();
+
+    app.add_systems(
+        Update,
+        load_names.run_if(in_state(Screen::Gameplay).and(name_queue_low)),
+    );
+}
+
+#[derive(Asset, Reflect, Deserialize)]
+pub struct Names {
+    pub neutral_names: Vec<String>,
+}
+
+#[derive(Asset, Resource, Reflect, Debug, Clone)]
+#[reflect(Resource)]
+pub struct NameAssets {
+    names: Handle<Names>,
+}
+
+impl FromWorld for NameAssets {
+    fn from_world(world: &mut World) -> Self {
+        let asset_server = world.resource::<AssetServer>();
+        Self {
+            names: asset_server.load("names.toml"),
+        }
+    }
+}
+
+#[derive(Resource, Reflect, Debug, Default)]
+#[reflect(Resource)]
+pub struct NameManager {
+    name_queue: Vec<String>,
+}
+
+impl NameManager {
+    const DEFAULT_NAME: &'static str = "Unknown";
+
+    pub fn next(&mut self) -> String {
+        self.name_queue
+            .pop()
+            .unwrap_or(String::from(Self::DEFAULT_NAME))
+    }
+}
+
+fn name_queue_low(name_manager: Res<NameManager>) -> bool {
+    name_manager.name_queue.len() <= REFILL_THRESHOLD
+}
+
+fn load_names(
+    mut name_manager: ResMut<NameManager>,
+    name_assets: Res<NameAssets>,
+    names: Res<Assets<Names>>,
+    mut seed: ResMut<Seed>,
+) {
+    if let Some(name_collections) = names.get(&name_assets.names) {
+        let mut shuffled = name_collections.neutral_names.clone();
+        shuffled.shuffle(&mut seed);
+        name_manager.name_queue.append(&mut shuffled);
+    }
+}

src/gameplay/player.rs

@@ -1,15 +1,24 @@
-use bevy::prelude::*;
+use std::time::Duration;
+
+use bevy::{prelude::*, time::common_conditions::on_timer};
 
 use crate::{
     gameplay::{
         item::{assets::ItemDef, stack::Stack},
+        people::{Person, naming::NameManager},
         storage::StoredBy,
     },
     screens::Screen,
 };
 
 pub(super) fn plugin(app: &mut App) {
     app.add_systems(OnEnter(Screen::Gameplay), spawn_player);
+
+    app.add_systems(
+        Update,
+        give_player_a_person
+            .run_if(in_state(Screen::Gameplay).and(on_timer(Duration::from_secs(5)))),
+    );
 }
 
 #[derive(Component, Reflect, Debug, Default)]
@@ -34,3 +43,18 @@ fn spawn_player(
         ));
     }
 }
+
+fn give_player_a_person(
+    player: Single<Entity, With<Player>>,
+    mut commands: Commands,
+    mut name_manager: ResMut<NameManager>,
+) {
+    let name = name_manager.next();
+
+    commands.spawn((
+        Name::new(name.clone()),
+        Person,
+        StoredBy(*player),
+        ChildOf(*player),
+    ));
+}

src/gameplay/random.rs

@@ -0,0 +1,15 @@
+use bevy::prelude::*;
+use rand::{SeedableRng, rngs::StdRng};
+
+pub fn plugin(app: &mut App) {
+    app.init_resource::<Seed>();
+}
+
+#[derive(Resource, Debug, Deref, DerefMut)]
+pub struct Seed(pub StdRng);
+
+impl Default for Seed {
+    fn default() -> Self {
+        Self(StdRng::from_os_rng())
+    }
+}