//! Implementation of all needed traits for the Entity struct use std::ops::Add; mod from_impl; use std::cmp::{max, min}; use cli_table::format::{Border, HorizontalLine, Separator, VerticalLine}; use cli_table::{Style, WithTitle}; use colored::*; use log::debug; use rand::distr::Distribution; use rand::seq::{IndexedRandom, IteratorRandom}; use uuid::Uuid; // [3] - colored-rs examples use crate::entity::{EffectApplication, EffectBounds, Entity, EntityDuration, EntityIdentifier}; use crate::epoch::EpochInfo; use crate::epoch::epoch_traits::Diffable; use crate::error::EpochError; use crate::stats::{ self, EntityType, FactionId, GenericStat, ListStats, MetaStats, OverallStats, Position, PositionGrid, StatPair, Symbols, }; use crate::utils::RngLevel; use crate::{Displayable, items_table}; // ---------- Implementation ---------- impl Displayable for Entity { // Detailed multi-line view (used e.g. in logs) fn print_full(&self, epoch_info: &EpochInfo) { println!("{}", self.to_pretty_tree(epoch_info),); if let Ok(c) = self.stats_to_table() { println!("{c}"); } } /// One-liner used for auto-generation of `Vec` displays // TODO: URGENT: Change this display fn oneline_display(&self) -> String { let capital = self .metadata .capital .as_ref() .map(|c| format!(" {} ", c.to_symbol()).green()) .unwrap_or_default(); let governor = self .metadata .governor .as_ref() .map(|g| format!("Governor:  {}", g.to_symbol()).blue()) .unwrap_or_default(); let prestige = if *self.metadata.prestige > 0 { format!(" {:2}{}", self.metadata.prestige, " ".yellow()) } else { String::new() }; // ---- build the two lines ---- let line1 = format!( "├──┬─ {} {:23} {} ──────> {} {}", self.id.to_string().split_at(7).0.blue(), self.name.green(), self.entity_type.to_symbol(), self.metadata.position.to_symbol(), self.duration.to_symbol().yellow(), ); let (junction, line3) = if !capital.is_empty() | !governor.is_empty() { ("├", format!("│ └─ {}{}\n", capital, governor,)) } else { ("└", "".to_string()) }; let line2 = format!( "│ {}─ Faction: {} │ Effect: {} {}, Stats: {}{}", junction, self.metadata.faction.to_symbol(), self.effect_nature.to_symbol(), self.effect_bounds.to_symbol(), self.stats.to_symbol(), prestige, ); format!("{}\n{}\n{}│", line1, line2, line3) } } impl Entity { // Display the entity's statistics in a pretty table. /// /// The table contains both the permanent and temporary statistics of the /// entity. The table is formatted with a custom border and separator /// using the `cli_table` crate. /// /// # Returns /// A `Result` containing the table display on success, or an `EpochError` if the /// conversion to a table string fails. pub fn full_stats_to_table(&self) -> Result { let items = if let Some(t) = &self.temp_stats { vec![&self.stats, t] } else { vec![&self.stats] }; self.stat_to_table(items) } /// Display the entity's statistics in a pretty table (same format as /// `full_stats_to_table`). /// /// This method is provided for backward compatibility and forwards all /// work to `full_stats_to_table`. /// /// # Returns /// A `Result` containing the table display on success, or an `EpochError` if the /// conversion to a table string fails. pub fn stats_to_table(&self) -> Result { let items = if let Some(t) = &self.temp_stats { vec![t] } else { vec![&self.stats] }; self.stat_to_table(items) } /// Display the entity's statistics in a pretty table (same format as /// `full_stats_to_table`). /// /// This method is provided for backward compatibility and forwards all /// work to `full_stats_to_table`. /// /// # Returns /// A `Result` containing the table display on success, or an `EpochError` if the /// conversion to a table string fails. /// fn stat_to_table( &self, items: Vec<&OverallStats>, ) -> Result { items_table!(items, self.name.clone(), self.id) } /// Pretty-print the entity as a coloured tree. /// /// The output is a `String` that visualises the entity's metadata, type, /// duration, effect bounds, and any links. Colours are applied using /// `colored::Colorize`. /// /// # Returns /// A `String` containing the formatted tree. // TODO: Deref ids pub fn to_pretty_tree(&self, epoch_info: &EpochInfo) -> String { // Helper that prefixes a line with the correct amount of vertical bars. fn indent(level: usize, line: &str) -> String { let bars = "│ ".repeat(level); format!(" {}{}", bars, line) } let mut out = String::new(); out.push_str(&format!( "[{} {} 󰻾[{}]]\n", self.entity_type.to_symbol().blue().bold(), self.name.cyan().bold(), self.id.to_string().blue().bold() )); // ── Metadata section out.push_str(&indent(0, &format!("├─ {}\n", "metadata".green()))); if let Some(capital) = self.metadata.capital { out.push_str(&indent( 1, &format!( "├─ {}: {}\n", "capital".bright_green(), uuid_to_symbol(*capital, epoch_info, &EntityType::Town) ), )); } if let Some(faction) = self.metadata.faction { out.push_str(&indent( 1, &format!( "├─ {} : {}{}\n", "faction".bright_green(), " ".yellow(), faction.to_string().yellow(), ), )); } if let Some(governor) = self.metadata.governor { out.push_str(&indent( 1, &format!( "├─ {}: {}\n", "governor".bright_green(), uuid_to_symbol(*governor, epoch_info, &EntityType::Character) ), )); } if *self.metadata.prestige > 0 { out.push_str(&indent( 1, &format!( "├─ {}: {}{}\n", "prestige".bright_green(), self.metadata.prestige.to_string().yellow(), " ".yellow() ), )); } out.push_str(&indent( 1, &format!( "└─ {}: {}\n", "position".bright_green(), self.metadata.position.to_symbol() ), )); // ── Optional links if !self.metadata.links.is_empty() { out.push_str(&indent(0, &format!("├─ {}\n", "links".green()))); for (i, link) in self.metadata.links.iter().enumerate() { let last = i == self.metadata.links.len() - 1; let symbol = if last { "└─" } else { "├─" }; out.push_str(&indent( 1, &format!( "{} {}\n", symbol, uuid_to_symbol(**link, epoch_info, &EntityType::Town).yellow() ), )); } } // ── Other top-level fields out.push_str(&indent( 0, &format!( "├─ {}: {}\n", "duration".green(), self.duration.to_symbol().yellow() ), )); out.push_str(&indent( 0, &format!("├─ {}: {:?}\n", "effect_nature".green(), self.effect_nature), )); out.push_str(&indent( 0, &format!( "└─ {}: {}", "effect_bounds".green(), self.effect_bounds.to_symbol() ), )); out } /// Create an entity using a specific RNG level. /// /// The entity is initialised with random statistics, a random position, /// and a random prestige value derived from the supplied `RngLevel`. /// /// # Arguments /// * `e_type` - The type of entity to create. /// * `rng` - The RNG level to use when generating random values. /// /// # Returns /// * `Ok(Self)` - The newly created entity. /// * `Err(EpochError)` - Propagated from any randomisation failure. /// pub fn create_rng(e_type: &EntityType, rng: &RngLevel) -> Result { let mut r = rand::rng(); Ok(Self { id: Uuid::new_v4(), stats: OverallStats::create_rng(rng, &mut r)?, temp_stats: None, metadata: MetaStats { prestige: GenericStat(rng.to_rng()?.sample(&mut r) as isize), position: Position::create_rng(&mut r)?, ..Default::default() }, entity_type: e_type.clone(), ..Default::default() }) } /// Change one of the entity's statistics. /// /// The stat identified by `pair` is replaced with the new value specified in /// the `StatPair`. This is a direct overwrite and does not apply any delta. /// /// # Arguments /// * `pair` - The stat pair containing the key and new value. /// pub fn change_stat_strict(&mut self, pair: StatPair) { overwrite_stat(&mut self.stats, pair); } /// Mutate a statistic in a “fuzzy” way. /// /// This method behaves like `change_stat_strict` for ordinary stats, but /// for *meta-stats* it applies a random modification instead of an /// outright overwrite. /// /// # Parameters /// * `pair` - a `StatPair` that contains the target statistic and the /// value that should be used for the fuzzy change. pub fn change_stat_fuzzy(&mut self, pair: StatPair, delta: bool) { let stats_demo = [ ListStats::Population, ListStats::Growthrate, ListStats::Crime, ListStats::Happiness, ]; let stats_eco = [ ListStats::Food, ListStats::Industry, ListStats::Science, ListStats::Trade, ]; let stats_soc = [ ListStats::Culture, ListStats::Education, ListStats::Tourism, ListStats::Influence, ]; let stats_mil = [ ListStats::Army, ListStats::Strength, ListStats::Fortification, ListStats::Threat, ]; let stats_inf = [ ListStats::Bureaucracy, ListStats::Transportation, ListStats::Sprawl, ListStats::Health, ]; match pair.stat { ListStats::Demographics => self.change_random_stats_by(&stats_demo, pair.value, delta), ListStats::Economy => self.change_random_stats_by(&stats_eco, pair.value, delta), ListStats::Social => self.change_random_stats_by(&stats_soc, pair.value, delta), ListStats::Military => self.change_random_stats_by(&stats_mil, pair.value, delta), ListStats::Infrastructure => self.change_random_stats_by(&stats_inf, pair.value, delta), _ => self.change_stat_strict(pair), } } /// Mutates a statistic in a “fuzzy” manner. /// /// For ordinary statistics this behaves like `change_stat_strict` and /// simply assigns the supplied value. For *meta-stats* the function /// chooses a random subset of the associated sub-statistics and /// distributes the requested change evenly among them. The selection /// is performed using a thread-local RNG. fn change_random_stats_by( &mut self, stats_demo: &[ListStats], amount: GenericStat, delta: bool, ) { let mut r = rand::rng(); let nb = (1..stats_demo.len() + 1).choose(&mut r).unwrap_or(1); let stats = stats_demo.choose_multiple(&mut r, nb); let (a, b) = (*amount / 2, *amount); let (a, b) = (min(a, b), max(a, b)); let mut value = || GenericStat((a..b).choose(&mut r).unwrap_or(1)); stats.for_each(|stat| { if delta { self.delta_stat(StatPair { stat: *stat, value: value(), }); } else { self.change_stat_strict(StatPair { stat: *stat, value: value(), }) } }); } /// Change the entity's duration. /// /// This simply replaces the current `EntityDuration` with the one supplied. /// No validation or transformation is performed; it is a direct overwrite. /// /// # Arguments /// * `duration` - The new `EntityDuration` to assign to the entity. /// pub fn change_duration(&mut self, duration: EntityDuration) { self.duration = duration } /// Change the entity's description. /// /// Replaces the current description string with the new one supplied. /// This method performs a direct overwrite; the previous description is dropped. /// /// # Arguments /// * `descritption` - The new description string for the entity. /// pub fn change_description(&mut self, descritption: String) { self.description = descritption } /// Apply a delta to all of the entity's statistics. /// /// The delta specified by `pair` is added to each of the statistics in /// `self.stats`. Positive values increase the stat, negative values /// decrease it. /// /// # Arguments /// * `pair` - The stat pair representing the change to apply. pub fn delta_stat(&mut self, pair: StatPair) { add_to_stat(&mut self.stats, pair); } /// Replace the entity's duration. /// /// The method simply overwrites the current `duration` field with the /// supplied value. It is primarily intended for use when an entity /// is instantiated from external data that already contains a duration value. pub fn modify_duration(&mut self, duration: EntityDuration) { self.duration = duration } /// Set the way the entity's effects are applied. /// /// The field `effect_nature` determines how the entity's abilities or /// status effects interact with the world. /// This method overwrites the existing value with the supplied `EffectApplication`. pub fn modify_effect_application(&mut self, effect: EffectApplication) { self.effect_nature = effect } /// Update the bounds that govern the entity's effects. /// /// `effect_bounds` controls the maximum/minimum strength, duration or /// other limits that can be applied to the entity's effects. This /// method simply replaces the current bounds with the supplied /// `EffectBounds`. pub fn modify_effect_bounds(&mut self, effect: EffectBounds) { self.effect_bounds = effect } /// Sets the entity's position using a world-space `Position`. /// /// This method updates the internal metadata to the specified /// world coordinates. pub fn modify_position(&mut self, pos: Position) { self.metadata.position = pos; } /// Sets the entity's faction identifier. /// /// This method updates the internal metadata to reflect the provided /// `faction`. A `None` value indicates that the entity is not /// affiliated with any faction. pub fn modify_faction(&mut self, faction: Option) { self.metadata.faction = faction; } /// Sets the entity's reach description. /// /// The `reach` string typically contains information such as the /// distance or area the entity can affect. This method replaces /// the current reach value stored in the entity's metadata. pub fn modify_reach(&mut self, reach: stats::Reach) { self.metadata.reach = reach; } /// Sets the entity's position using a grid-space `PositionGrid`. /// /// The supplied grid coordinates are converted to world space /// before being stored. pub fn modify_position_grid(&mut self, pos: PositionGrid) { self.metadata.position = pos.to_position(); } /// Changes the entity's description text. pub fn modify_description(&mut self, descritption: String) { self.description = descritption; } /// Sets the entity's prestige stat to an absolute value. /// /// The prestige value is stored directly in the entity's metadata /// and overwrites any previous value. pub fn modify_prestige(&mut self, prestige: GenericStat) { self.metadata.prestige = prestige; } /// Adjusts the entity's prestige stat by adding a delta. pub fn modify_prestige_by_delta(&mut self, prestige: GenericStat) { self.metadata.prestige = self.metadata.prestige.add(prestige); } /// Add a governor to the entity if the id exists pub fn change_governor(&mut self, governor: stats::CharacterId) { debug!("Swapping the governor with {}", governor.to_symbol()); self.metadata.governor = Some(governor); } /// Remove the entity's governor and return it pub fn remove_governor(&mut self) -> Option { self.metadata.governor.take() } /// Add a governor to the entity if the id exists pub fn change_capital(&mut self, capital: stats::TownId) { debug!("Swapping the capital with {}", capital.to_symbol()); self.metadata.capital = Some(capital); } /// Remove the entity's governor and return it pub fn remove_capital(&mut self) -> Option { self.metadata.capital.take() } /// Returns a **read-only reference** to the entity's current position. pub fn position(&self) -> &Position { &self.metadata.position } /// Returns whether the entity match an optionnal identifier pub fn match_identifier(&self, entity_identifier: &Option) -> bool { match entity_identifier { Some(EntityIdentifier::Name(name)) => self.name.starts_with(name), Some(EntityIdentifier::Id(id)) => self.id.hyphenated().to_string().starts_with(id), None => false, } } } /// Short utility to make a symbol for an entity from it's Uuid fn uuid_to_symbol(id: Uuid, epoch_info: &EpochInfo, e_type: &EntityType) -> String { epoch_info .find_entity_strict(id, Some(e_type.clone())) .map(|e| e.to_symbol()) .unwrap_or(format!( "{}{} is missing {}", " ".red(), id.to_symbol().red(), e_type.clone().to_shortest().blue() )) } // impl Entity { // /// Create a new Event // fn new_event(name: String, description: String){} // } /// Replace a statistic in `stats` with the value from `pair`. /// /// This function performs a direct overwrite: the existing value is /// discarded and the new value from `pair` is written in its place. fn overwrite_stat(stats: &mut OverallStats, pair: StatPair) { let affected_stat = stats.get_field_mut(&pair.stat); *affected_stat = pair.value; } /// Add a delta to a statistic in `stats`. /// /// The delta in `pair.value` is added to the current statistic value /// using `saturating_add`, so that the result never overflows the /// underlying integer type. fn add_to_stat(stats: &mut OverallStats, pair: StatPair) { let affected_stat = stats.get_field_mut(&pair.stat); let current_value = *affected_stat; *affected_stat = GenericStat(current_value.saturating_add(*pair.value)); } /// Compare a field on `self` with the same field on `other`. /// If they are equal → `None`, otherwise → the value from `other`. macro_rules! diff_fields { // Two arguments: the two objects you want to compare ($self:ident, $other:ident, $( $field:ident ),* $(,)?) => { $( let $field = if $self.$field == $other.$field { None } else { $other.$field.clone() }; )* }; } impl Diffable for Entity { fn delta(&self, other: &Self) -> Self { let name = if self.name == other.name { self.name.clone() } else { format!("{}->{}", self.name, other.name) }; Self { name, stats: self.stats.clone() - other.stats.clone(), temp_stats: self.temp_stats.delta(&other.temp_stats), metadata: self.metadata.delta(&other.metadata), entity_type: other.entity_type.clone(), duration: other.duration.clone(), effect_nature: other.effect_nature.clone(), effect_bounds: other.effect_bounds.clone(), id: Uuid::new_v4(), description: other.description.clone(), } } } impl Diffable for Option { fn delta(&self, other: &Self) -> Self { match (self, other) { (None, None) => None, (None, Some(a)) => Some(a.clone()), (Some(a), None) => Some(a.clone()), (Some(a), Some(b)) => Some(a.clone() - b.clone()), } } } impl Diffable for MetaStats { fn delta(&self, other: &Self) -> Self { diff_fields!(self, other, capital, governor); Self { position: self.position.clone() - other.position.clone(), capital, governor, faction: { match (self.faction.as_ref(), other.faction.as_ref()) { (None, None) => None, (None, Some(b)) => Some(*b), (Some(a), None) => Some(*a), (Some(_), Some(b)) => Some(*b), } }, links: self .links .clone() .into_iter() .filter(|t1| other.links.iter().any(|t2| t1 == t2)) .collect(), prestige: self.prestige - other.prestige, reach: stats::Reach::None, } } } impl Symbols for Entity { fn to_symbol(&self) -> String { format!( "{} {} {}", self.entity_type.to_symbol().blue(), self.id.to_symbol().blue(), self.name ) } } impl Symbols for Uuid { fn to_symbol(&self) -> String { format!("󰻾[{}]", self.to_string().split_at(7).0) } fn to_shortest(&self) -> String { self.to_string().split_at(7).0.to_string() } }