feat(citygen): flavor pack and theme table

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

crates/citygen/src/flavor.rs

@@ -0,0 +1,158 @@
+//! Flavor pack: names and signage glyphs, loaded from RON.
+
+use crate::params::GenError;
+use crate::world::{BuildingKind, Theme};
+use rand::Rng;
+use rand::seq::IndexedRandom;
+use serde::{Deserialize, Serialize};
+
+const DEFAULT_PACK: &str = include_str!("../../../flavor/names.ron");
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct NameParts {
+    pub prefixes: Vec<String>,
+    pub suffixes: Vec<String>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct CorpParts {
+    pub first: Vec<String>,
+    pub second: Vec<String>,
+    pub suffix: Vec<String>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct FlavorPack {
+    pub city: NameParts,
+    pub districts: Vec<(Theme, NameParts)>,
+    pub corp: CorpParts,
+    pub shops: Vec<(BuildingKind, Vec<String>)>,
+    pub landmarks: Vec<String>,
+    pub signage: Vec<char>,
+}
+
+fn pick<'a>(rng: &mut impl Rng, items: &'a [String]) -> &'a str {
+    items.choose(rng).map(String::as_str).unwrap_or("")
+}
+
+fn capitalize(s: &str) -> String {
+    let mut chars = s.chars();
+    match chars.next() {
+        Some(c) => c.to_uppercase().chain(chars).collect(),
+        None => String::new(),
+    }
+}
+
+impl FlavorPack {
+    /// Loads a named pack. Only `default` is built in.
+    pub fn load(name: &str) -> Result<FlavorPack, GenError> {
+        match name {
+            "default" => FlavorPack::parse(DEFAULT_PACK),
+            other => Err(GenError::Flavor(format!("unknown flavor pack `{other}`"))),
+        }
+    }
+
+    pub fn parse(text: &str) -> Result<FlavorPack, GenError> {
+        let pack: FlavorPack = ron::from_str(text).map_err(|e| GenError::Flavor(e.to_string()))?;
+        if pack.signage.is_empty() || pack.city.prefixes.is_empty() || pack.city.suffixes.is_empty()
+        {
+            return Err(GenError::Flavor(
+                "flavor pack is missing required lists".into(),
+            ));
+        }
+        Ok(pack)
+    }
+
+    pub fn city_name(&self, rng: &mut impl Rng) -> String {
+        format!(
+            "{}{}",
+            pick(rng, &self.city.prefixes),
+            pick(rng, &self.city.suffixes)
+        )
+    }
+
+    pub fn district_name(&self, theme: Theme, rng: &mut impl Rng) -> String {
+        match self.districts.iter().find(|(t, _)| *t == theme) {
+            Some((_, parts)) => format!(
+                "{}{}",
+                pick(rng, &parts.prefixes),
+                pick(rng, &parts.suffixes)
+            ),
+            None => format!("{} {}", theme.label(), rng.random_range(1..100)),
+        }
+    }
+
+    pub fn corp_name(&self, rng: &mut impl Rng) -> String {
+        let stem = format!(
+            "{}{}",
+            pick(rng, &self.corp.first),
+            pick(rng, &self.corp.second)
+        );
+        format!("{}{}", capitalize(&stem), pick(rng, &self.corp.suffix))
+    }
+
+    /// A two-syllable made-up word for shop names.
+    fn syllable_word(&self, rng: &mut impl Rng) -> String {
+        let stem = format!(
+            "{}{}",
+            pick(rng, &self.corp.first).to_lowercase(),
+            pick(rng, &self.corp.second)
+        );
+        capitalize(&stem)
+    }
+
+    pub fn shop_name(&self, kind: BuildingKind, rng: &mut impl Rng) -> Option<String> {
+        let (_, templates) = self.shops.iter().find(|(k, _)| *k == kind)?;
+        let template = pick(rng, templates);
+        let word = self.syllable_word(rng);
+        Some(template.replace("{syl}", &word))
+    }
+
+    pub fn landmark_name(&self, corp: &str, district: &str, rng: &mut impl Rng) -> String {
+        pick(rng, &self.landmarks)
+            .replace("{corp}", corp)
+            .replace("{district}", district)
+    }
+
+    pub fn sign_glyph(&self, rng: &mut impl Rng) -> char {
+        *self.signage.choose(rng).unwrap_or(&'#')
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::rng::stage_rng;
+    use crate::world::{BuildingKind, Theme};
+
+    fn unicode_single_width(c: char) -> bool {
+        let u = c as u32;
+        u >= 0x20
+            && !(0x1100..=0x115F).contains(&u)
+            && !(0x2E80..=0xA4CF).contains(&u)
+            && !(0xAC00..=0xD7A3).contains(&u)
+            && !(0xF900..=0xFAFF).contains(&u)
+            && !(0xFE30..=0xFE4F).contains(&u)
+            && !(0xFF00..=0xFF60).contains(&u)
+            && !(0xFFE0..=0xFFE6).contains(&u)
+    }
+
+    #[test]
+    fn default_flavor_loads_and_names_are_deterministic() {
+        let f = FlavorPack::load("default").unwrap();
+        assert!(FlavorPack::load("nope").is_err());
+        let mut a = stage_rng(7, 9);
+        let mut b = stage_rng(7, 9);
+        assert_eq!(f.city_name(&mut a), f.city_name(&mut b));
+        for t in Theme::ALL {
+            assert!(!f.district_name(t, &mut a).is_empty());
+        }
+        assert!(f.shop_name(BuildingKind::NoodleBar, &mut a).is_some());
+        assert!(f.shop_name(BuildingKind::CorpTower, &mut a).is_none());
+        assert!(!f.corp_name(&mut a).is_empty());
+        assert!(f.landmark_name("Kirotek", "Apex Plaza", &mut a).len() > 5);
+        assert!(f.signage.iter().all(|c| unicode_single_width(*c)));
+        assert!(f.signage.len() >= 40);
+        let _ = f.sign_glyph(&mut a);
+    }
+}