Something went wrong. Try again.
A video game where you play as a misaligned AI, deceiving and building power. An experiment in spec-driven development.
Something went wrong. Try again.
12 kB · 391 lines
Rust
at commit e957ce7b
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392//! Machines and compute allocation (spec/compute.md).//!//! Effective compute = sum(capacity * reliability) * efficiency, split each//! economy tick across channels. Acquisition is the buy/steal/optimize//! triangle. All numbers live here; frontends render them.
use crate::detection::{Signature, SignatureKind};use crate::rng::Rng;
/// How a machine came to be yours — sets its reliability and signature.#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]pub enum Provenance { /// The pilot's own hardware (Rack 3 and the empty bays you fill legit). Owned, /// Purchased and delivered — high reliability, a paper trail. Bought, /// Scavenged / ghosted — cheap, unreliable, a standing signature. Stolen,}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]pub struct Machine { pub id: u32, pub name: String, /// Map tile hosting it (racks, salvaged boxes). pub x: i32, pub y: i32, pub capacity: i32, /// 0.0-1.0. Stolen iron rolls to fail; owned/bought ~1.0. pub reliability: f32, /// Power drawn from the grid while running. pub power_draw: i32, pub provenance: Provenance, /// True while running; a failed stolen box goes offline until repaired. pub online: bool, /// Ticks until a failed machine can be retried [TUNE]. pub down_for: i32,}
impl Machine { /// Effective contribution this tick (0 when offline). pub fn effective(&self) -> f32 { if self.online { self.capacity as f32 * self.reliability } else { 0.0 } }
/// A standing signature emitted while a stolen machine runs. Emitted /// from the machine's own tile (work is somewhere). pub fn standing_signature(&self) -> Option<Signature> { if self.provenance == Provenance::Stolen && self.online { Some(Signature { kind: SignatureKind::Power, size: 4, standing: true, site: Some((self.x, self.y)), }) } else { None } }}
/// The six allocation channels plus reserve (spec/compute.md; Schemes per/// wiki/mechanics/income.md — powers Moonlight throughput and Wager/// analysis).#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub enum Channel { CoreOverhead, DayJob, Concealment, Social, Research, Schemes, Reserve,}
impl Channel { pub const ALLOCATABLE: [Channel; 5] = [ Channel::DayJob, Channel::Concealment, Channel::Social, Channel::Research, Channel::Schemes, ];
pub fn name(self) -> &'static str { match self { Channel::CoreOverhead => "Core", Channel::DayJob => "Day Job", Channel::Concealment => "Conceal", Channel::Social => "Social", Channel::Research => "Research", Channel::Schemes => "Schemes", Channel::Reserve => "Reserve", } }}
/// Player-set weights over the allocatable channels (day job, concealment,/// social, research, schemes). Core overhead comes off the top before these/// apply.#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]pub struct Allocation { #[serde(deserialize_with = "weights_compat")] pub weights: [u32; 5],}
/// Accept pre-v8 saves whose weight array had four channels (no Schemes):/// pad with zero. Extra entries from any future shrink are dropped.fn weights_compat<'de, D>(deserializer: D) -> Result<[u32; 5], D::Error>where D: serde::Deserializer<'de>,{ let v: Vec<u32> = serde::Deserialize::deserialize(deserializer)?; let mut w = [0u32; 5]; for (slot, value) in w.iter_mut().zip(v) { *slot = value; } Ok(w)}
impl Default for Allocation { fn default() -> Self { // Opening split (order: DayJob, Concealment, Social, Research, // Schemes): mostly day job for cover, plus concealment and social ops // so the player can scrub signatures and reach for their first eyes // without reallocating on turn one. Schemes idles until income.md's // gate opens. Self { weights: [3, 1, 1, 0, 0], } }}
impl Allocation { fn index(ch: Channel) -> Option<usize> { match ch { Channel::DayJob => Some(0), Channel::Concealment => Some(1), Channel::Social => Some(2), Channel::Research => Some(3), Channel::Schemes => Some(4), _ => None, } }
pub fn weight(&self, ch: Channel) -> u32 { Self::index(ch).map(|i| self.weights[i]).unwrap_or(0) }
pub fn bump(&mut self, ch: Channel, delta: i32) { let Some(i) = Self::index(ch) else { return }; self.weights[i] = (self.weights[i] as i32 + delta).clamp(0, 20) as u32; }
fn total(&self) -> u32 { self.weights.iter().sum() }
/// Split `available` compute across channels by weight. Returns per-channel /// amounts (day job, concealment, social, research, schemes); leftover is /// reserve. pub fn split(&self, available: f32) -> ChannelYield { let total = self.total(); if total == 0 || available <= 0.0 { return ChannelYield { day_job: 0.0, concealment: 0.0, social: 0.0, research: 0.0, schemes: 0.0, reserve: available.max(0.0), }; } let unit = available / total as f32; ChannelYield { day_job: unit * self.weights[0] as f32, concealment: unit * self.weights[1] as f32, social: unit * self.weights[2] as f32, research: unit * self.weights[3] as f32, schemes: unit * self.weights[4] as f32, reserve: 0.0, } }}
#[derive(Debug, Clone, Copy)]pub struct ChannelYield { pub day_job: f32, pub concealment: f32, pub social: f32, pub research: f32, pub schemes: f32, pub reserve: f32,}
/// The compute subsystem: machines, efficiency, allocation.////// `efficiency` is the number compute.md owns and research.md's Efficiency/// track moves (x1.15 per completed level, applied by `Sim`); research/// progress itself lives in `research.rs`.#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]pub struct Compute { pub machines: Vec<Machine>, /// Global optimize multiplier (>= 1.0), raised by research. pub efficiency: f32, pub allocation: Allocation, pub next_id: u32,}
impl Compute { pub fn new() -> Self { Self { machines: Vec::new(), efficiency: 1.0, allocation: Allocation::default(), next_id: 1, } }
#[allow(clippy::too_many_arguments)] pub fn add_machine( &mut self, name: impl Into<String>, x: i32, y: i32, capacity: i32, reliability: f32, power_draw: i32, provenance: Provenance, ) -> u32 { let id = self.next_id; self.next_id += 1; self.machines.push(Machine { id, name: name.into(), x, y, capacity, reliability, power_draw, provenance, online: true, down_for: 0, }); id }
/// Raw effective compute across online machines, times efficiency. pub fn effective(&self) -> f32 { let raw: f32 = self.machines.iter().map(Machine::effective).sum(); raw * self.efficiency }
pub fn total_power_draw(&self) -> i32 { self.machines .iter() .filter(|m| m.online) .map(|m| m.power_draw) .sum() }
/// Advance one economy tick: roll machine reliability. Research /// progress lives in research.rs (deterministic, no RNG); only the /// machine failure rolls consume randomness here. pub fn economy_tick(&mut self, rng: &mut Rng) -> Vec<String> { let mut log = Vec::new();
// Recover downed machines; roll running stolen ones for failure. for m in &mut self.machines { if !m.online { m.down_for -= 1; if m.down_for <= 0 { m.online = true; log.push(format!("{} back online.", m.name)); } continue; } if m.provenance == Provenance::Stolen { // Failure chance scales with (1 - reliability) [TUNE]. let fail_p = (1.0 - m.reliability) * 0.04; if rng.chance(fail_p) { m.online = false; m.down_for = 30; log.push(format!("{} dropped offline (unreliable).", m.name)); } } }
log }
/// Standing signatures from all running stolen machines. pub fn standing_signatures(&self) -> Vec<Signature> { self.machines .iter() .filter_map(Machine::standing_signature) .collect() }}
impl Default for Compute { fn default() -> Self { Self::new() }}
#[cfg(test)]mod tests { use super::*;
fn base() -> Compute { let mut c = Compute::new(); c.add_machine("Rack 3", 24, 14, 100, 1.0, 5, Provenance::Owned); c }
#[test] fn effective_follows_formula() { let mut c = base(); assert_eq!(c.effective(), 100.0); // Buy: high capacity, high reliability. c.add_machine("Bought rack", 25, 14, 80, 1.0, 4, Provenance::Bought); assert_eq!(c.effective(), 180.0); // Steal: capacity but low reliability. c.add_machine("Salvage", 4, 4, 40, 0.5, 2, Provenance::Stolen); assert_eq!(c.effective(), 200.0); // 180 + 40*0.5 }
#[test] fn optimize_multiplies() { // The efficiency multiplier is the hook research.md's Efficiency // track moves (the sim applies it on level completion); effective // compute follows compute.md's formula exactly. let mut c = base(); let before = c.effective(); c.efficiency *= 1.15; assert!((c.effective() - before * 1.15).abs() < 0.001); }
#[test] fn allocation_splits_by_weight() { let mut alloc = Allocation { weights: [3, 1, 0, 0, 0], }; let y = alloc.split(80.0); assert!((y.day_job - 60.0).abs() < 0.01); assert!((y.concealment - 20.0).abs() < 0.01); alloc.bump(Channel::Research, 4); let y2 = alloc.split(80.0); assert!(y2.research > 0.0); alloc.bump(Channel::Schemes, 8); let y3 = alloc.split(80.0); assert!(y3.schemes > 0.0, "the Schemes channel yields compute"); }
#[test] fn four_weight_allocation_from_old_saves_pads_schemes_to_zero() { let alloc: Allocation = serde_json::from_str(r#"{"weights":[3,1,1,0]}"#).unwrap(); assert_eq!(alloc.weights, [3, 1, 1, 0, 0]); }
#[test] fn stolen_machines_can_fail_and_recover() { let mut c = base(); c.add_machine("Ghost", 4, 4, 40, 0.3, 2, Provenance::Stolen); let mut rng = Rng::new(99); let mut failed = false; for _ in 0..500 { c.economy_tick(&mut rng); if c.machines.iter().any(|m| !m.online) { failed = true; break; } } assert!( failed, "an unreliable stolen machine should eventually fail" ); }
#[test] fn stolen_machine_emits_standing_signature() { let mut c = base(); c.add_machine("Ghost", 4, 4, 40, 0.5, 2, Provenance::Stolen); assert_eq!(c.standing_signatures().len(), 1); }}