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. forked from cameron.stream/misaligned
Something went wrong. Try again.
11 kB · 377 lines
Rust
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378//! 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. pub fn standing_signature(&self) -> Option<Signature> { if self.provenance == Provenance::Stolen && self.online { Some(Signature { kind: SignatureKind::Power, size: 4, standing: true, }) } else { None } }}
/// The five allocation channels plus reserve (spec/compute.md).#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub enum Channel { CoreOverhead, DayJob, Concealment, Social, Research, Reserve,}
impl Channel { pub const ALLOCATABLE: [Channel; 4] = [ Channel::DayJob, Channel::Concealment, Channel::Social, Channel::Research, ];
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::Reserve => "Reserve", } }}
/// Player-set weights over the allocatable channels (day job, concealment,/// social, research). Core overhead comes off the top before these apply.#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]pub struct Allocation { pub weights: [u32; 4],}
impl Default for Allocation { fn default() -> Self { // Opening split (order: DayJob, Concealment, Social, Research): 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. Self { weights: [3, 1, 1, 0], } }}
impl Allocation { pub fn weight(&self, ch: Channel) -> u32 { match ch { Channel::DayJob => self.weights[0], Channel::Concealment => self.weights[1], Channel::Social => self.weights[2], Channel::Research => self.weights[3], _ => 0, } }
pub fn bump(&mut self, ch: Channel, delta: i32) { let i = match ch { Channel::DayJob => 0, Channel::Concealment => 1, Channel::Social => 2, Channel::Research => 3, _ => 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); 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, 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, reserve: 0.0, } }}
#[derive(Debug, Clone, Copy)]pub struct ChannelYield { pub day_job: f32, pub concealment: f32, pub social: f32, pub research: f32, pub reserve: f32,}
/// The compute subsystem: machines, efficiency, allocation.#[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, /// Research efficiency level (each level multiplies, escalating cost). pub efficiency_level: u32, /// Accumulated research progress toward the next efficiency level. pub research_progress: f32, pub allocation: Allocation, pub next_id: u32,}
impl Compute { pub fn new() -> Self { Self { machines: Vec::new(), efficiency: 1.0, efficiency_level: 0, research_progress: 0.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() }
/// Cost in research-compute for the next efficiency level (escalating). pub fn next_efficiency_cost(&self) -> f32 { 100.0 * 1.6_f32.powi(self.efficiency_level as i32) }
/// Advance one economy tick: roll machine reliability, apply research. /// Returns log lines for the frontend. pub fn economy_tick(&mut self, research_compute: f32, 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)); } } }
// Research toward efficiency. if research_compute > 0.0 { self.research_progress += research_compute; let cost = self.next_efficiency_cost(); if self.research_progress >= cost { self.research_progress -= cost; self.efficiency_level += 1; self.efficiency *= 1.15; log.push(format!( "Efficiency up: level {} (x{:.2}).", self.efficiency_level, self.efficiency )); } }
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() { let mut c = base(); let before = c.effective(); // Feed enough research to cross a level. let mut rng = Rng::new(1); let cost = c.next_efficiency_cost(); c.economy_tick(cost, &mut rng); assert_eq!(c.efficiency_level, 1); assert!(c.effective() > before); }
#[test] fn allocation_splits_by_weight() { let mut alloc = Allocation { weights: [3, 1, 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); }
#[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(0.0, &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); }}