Struct FactionEconomy 

pub struct FactionEconomy {
    pub current_tick: u64,
    pub factions: HashMap<FactionId, Faction>,
    pub trade_routes: HashMap<TradeRouteId, TradeRoute>,
    pub tribute_agreements: HashMap<TributeAgreementId, TributeAgreement>,
    pub espionage_ops: HashMap<EspionageOperationId, EspionageOperation>,
    pub espionage_reports: Vec<EspionageReport>,
    pub wealth_ranking: Option<WealthRanking>,
    /* private fields */
}

Manages all factions, their trade routes, tribute, reparations, espionage operations, and wealth rankings.

Fields

current_tick: u64

factions: HashMap<FactionId, Faction>

trade_routes: HashMap<TradeRouteId, TradeRoute>

tribute_agreements: HashMap<TributeAgreementId, TributeAgreement>

espionage_ops: HashMap<EspionageOperationId, EspionageOperation>

espionage_reports: Vec<EspionageReport>

wealth_ranking: Option<WealthRanking>

Implementations

impl FactionEconomy

pub fn new() -> Self

pub fn add_faction(&mut self, name: &str, starting_gold: f64) -> FactionId

pub fn faction(&self, id: FactionId) -> Option<&Faction>

pub fn faction_mut(&mut self, id: FactionId) -> Option<&mut Faction>

pub fn declare_war(&mut self, faction_a: FactionId, faction_b: FactionId)

Declare war between two factions (disables existing trade routes between them).

pub fn end_war(&mut self, faction_a: FactionId, faction_b: FactionId)

End war between two factions.

pub fn add_trade_route( &mut self, from: FactionId, to: FactionId, base_volume: f64, export_share: f64, import_share: f64, ) -> TradeRouteId

pub fn disrupt_route(&mut self, id: TradeRouteId, severity: f64)

pub fn close_route(&mut self, id: TradeRouteId)

pub fn reopen_route(&mut self, id: TradeRouteId)

pub fn invest_infrastructure(&mut self, id: TradeRouteId, amount: f64)

pub fn impose_embargo( &mut self, imposing: FactionId, target: FactionId, extra_tariff: f64, blocks_trade: bool, asset_freeze: bool, reason: &str, )

pub fn lift_embargo(&mut self, imposing: FactionId, target: FactionId)

pub fn impose_reparations( &mut self, payer: FactionId, receiver: FactionId, total: f64, installment: f64, )

pub fn add_tribute( &mut self, payer: FactionId, receiver: FactionId, amount_per_tick: f64, duration: Option<u64>, coercion_level: f64, rebellion_chance: f64, ) -> TributeAgreementId

pub fn launch_espionage( &mut self, instigator: FactionId, target: FactionId, objective: EspionageObjective, success_probability: f64, duration_ticks: u64, ) -> EspionageOperationId

Launch an espionage operation. It completes after duration_ticks.

pub fn compute_wealth_ranking(&mut self)

pub fn tick(&mut self)

Advance the faction economy by one tick.

• Ticks all trade routes and distributes income.
• Processes reparation installments.
• Processes tribute payments.
• Collects trade taxes.
• Decays disinformation penalties.
• Resolves completed espionage operations.
• Recomputes wealth rankings.

pub fn routes_for_faction(&self, faction: FactionId) -> Vec<&TradeRoute>

All trade routes involving a specific faction.

pub fn global_gdp(&self) -> f64

Total GDP proxy across all factions.

pub fn dominant_faction(&self) -> Option<FactionId>

Dominant faction (highest gold).

pub fn active_embargoes(&self, faction: FactionId) -> Vec<&EmbargoPenalty>

Active embargoes imposed by a faction.

pub fn reports_for(&self, faction: FactionId) -> Vec<&EspionageReport>

Espionage reports involving a faction (as instigator or target).

Trait Implementations

impl Default for FactionEconomy

fn default() -> Self

Returns the “default value” for a type.