verticopolis_engine/

events.rs

//! Emergencies and the choices they put to the player.
//!
//! When a fire breaks out or a bomb threat arrives, the engine sets
//! [`EventSystem::pending`] on [`Simulation::events`] and writes the offer to
//! the log; the frame's header flags it too. The game keeps running. A host
//! shows the offer and sends the player's answer with
//! [`Simulation::resolve_choice`].

use indexmap::IndexSet;
use serde_json::{json, Value};

use crate::facilities::Kind;
use crate::gameplay::{EmergencyDecision, EmergencyKind, EmergencySource, GameplayEvent};
use crate::rng::Rng;
use crate::services::with_thousands;
use crate::sim::{LogKind, Simulation, ThiefFx};
use crate::tower::UnitState;

#[path = "events_fire.rs"]
mod fire;

#[path = "events_bomb.rs"]
#[doc(hidden)]
pub mod bomb;
/// Why [`Simulation::change_film`] refused, kept here beside the other
/// cinema command, [`Simulation::set_film_policy`].
pub use crate::economy::films::FilmRefusal;
#[doc(hidden)]
pub use bomb::{BombSearch, Guard};

/// An offer waiting for the player's answer.
#[derive(Clone, Debug)]
pub struct PendingChoice {
    /// `fireRescue` (pay to stop a fire spreading) or `bombThreat` (pay the
    /// ransom, or let the search for the bomb begin).
    pub kind: &'static str,
    /// What accepting costs, in dollars.
    pub cost: f64,
    /// The offer, ready to show a player.
    pub message: String,
}

/// The tower's emergencies. A host reads [`pending`](EventSystem::pending);
/// the rest is the engine's own state.
pub struct EventSystem {
    #[doc(hidden)]
    /// Units currently ablaze, in insertion order.
    pub active: IndexSet<i64>,
    #[doc(hidden)]
    /// `counts`: emergency tallies for this tower instance (read by the
    /// shell; never saved). A spreading blaze is the same fire, so only the
    /// ignition counts; bomb losses are not fire losses.
    pub fires_started: i64,
    #[doc(hidden)]
    pub fires_gut_rooms: i64,
    #[doc(hidden)]
    pub bombs_detonated: i64,
    #[doc(hidden)]
    /// The seasonal and visitor stream, separate from the main one.
    pub extra: Rng,
    #[doc(hidden)]
    /// The year Santa last came, as the save carries it (a forged save may
    /// hold a fraction, which then never equals a year).
    pub last_santa_year: f64,
    /// The offer waiting for the player's answer, if any.
    pub pending: Option<PendingChoice>,
    #[doc(hidden)]
    /// Classic's bomb search while one runs (`events_bomb.rs`).
    pub bomb: Option<BombSearch>,
}

const SECURITY_RADIUS: i64 = 8;
const MEDICAL_RADIUS: i64 = 12;
const THIEF_DAILY_CHANCE: f64 = 0.025;

impl EventSystem {
    #[doc(hidden)]
    pub fn new(seed: u32) -> EventSystem {
        EventSystem {
            active: IndexSet::new(),
            fires_started: 0,
            fires_gut_rooms: 0,
            bombs_detonated: 0,
            extra: Rng::new(seed ^ 0x5a17a),
            last_santa_year: -1.0,
            pending: None,
            bomb: None,
        }
    }

    #[doc(hidden)]
    /// `saveState()`: `pending` is a literal null when there is no choice.
    /// `sim_save.rs` writes this object itself too (#1242), with the pending
    /// choice's message from the borrow; its tests hold the two to the same
    /// text.
    pub fn save_state(&self) -> Value {
        let pending = match &self.pending {
            Some(p) => json!({ "kind": p.kind, "cost": p.cost, "message": p.message }),
            None => Value::Null,
        };
        let mut state = json!({ "lastSantaYear": self.last_santa_year, "rngState": self.extra.seed(), "pending": pending });
        if let Some(b) = &self.bomb {
            state["bomb"] = b.save_state();
        }
        state
    }

    #[doc(hidden)]
    pub fn count(&self) -> usize {
        self.active.len()
    }
}

impl Simulation {
    /// Sets the film cinema `id` books again once its film is spent (Modern):
    /// `auto` or `feature` (a feature), `revival`, `blockbuster`, or `off`.
    /// Returns the policy set, or `None` when `id` is not a cinema or
    /// `policy` is none of the five.
    pub fn set_film_policy(&mut self, id: i64, policy: &str) -> Option<&'static str> {
        let policy: &'static str = match policy {
            "auto" => "auto",
            "feature" => "feature",
            "blockbuster" => "blockbuster",
            "revival" => "revival",
            "off" => "off",
            _ => return None,
        };
        let u = self.tower.get_unit_mut(id)?;
        if u.kind != Kind::Cinema {
            return None;
        }
        u.extras_mut().film_policy = Some(policy);
        Some(policy)
    }

    #[doc(hidden)]
    /// `maybeRandomEvent`: the daily roll.
    pub fn maybe_random_event(&mut self) {
        if self.events.pending.is_some() {
            self.resolve_choice_from(false, EmergencySource::Timeout);
        }
        self.process_fires();
        self.maybe_santa();
        self.maybe_thief();
        if self.star < 2 {
            return;
        }
        let roll = self.rng.next();
        let fire_chance = self.fire_chance();
        if self.events.active.is_empty() && roll < fire_chance {
            self.start_fire();
            if !self.events.active.is_empty() {
                self.offer_fire_rescue();
            }
            return;
        }
        let ransom_allowed = self.events.bomb.is_none()
            && (!self.mode.ransom_needs_security() || self.has_any(Kind::Security));
        if self.star >= 4 && roll < fire_chance + 0.05 && ransom_allowed {
            let message = "💣 A caller demands a $300,000 ransom or a bomb detonates. Pay, or have Security search the tower.".to_string();
            self.events.pending = Some(PendingChoice {
                kind: "bombThreat",
                cost: 300_000.0,
                message: message.clone(),
            });
            self.emit(&message, LogKind::Bad);
            return;
        }
        if self.rng.chance(0.15) {
            if self.rng.chance(0.5) {
                self.emit(
                    "A local newspaper praised your tower's design.",
                    LogKind::Good,
                );
            } else {
                self.emit("Tenants are happy with the tower today.", LogKind::Info);
            }
        }
    }

    /// Answers the [pending choice](EventSystem::pending): `true` pays, `false`
    /// declines. Accepting without the money to pay counts as declining. Does
    /// nothing when no choice is pending. A declined fire spreads until it
    /// burns out; a declined bomb threat starts the search for the bomb.
    pub fn resolve_choice(&mut self, accept: bool) {
        self.outside_the_gesture(|s| s.resolve_choice_from(accept, EmergencySource::Player));
    }

    #[doc(hidden)]
    /// `EventSystem.resolveChoice(option, source)`: the daily roll's
    /// auto-decline comes through here as a timeout.
    pub fn resolve_choice_from(&mut self, accept: bool, source: EmergencySource) {
        let Some(p) = self.events.pending.take() else {
            return;
        };
        // What takes effect: an accept the tower cannot afford is a decline.
        // One test drives both the event and the branches below.
        let paid = accept && self.money >= p.cost;
        // Anything but a fire rescue is answered as a bomb threat, as the
        // branches below (and the TypeScript) treat it.
        let kind = EmergencyKind::parse(p.kind).unwrap_or(EmergencyKind::BombThreat);
        self.gameplay.push(GameplayEvent::EmergencyResolved {
            kind,
            decision: if paid {
                EmergencyDecision::Accept
            } else {
                EmergencyDecision::Decline
            },
            source,
        });
        if kind == EmergencyKind::FireRescue {
            if paid {
                self.money -= p.cost;
                self.extinguish_all();
                self.emit(&format!("🚒 Fire-rescue crews saved the tower for ${}. The rooms that were ablaze are gutted. Bulldoze and rebuild them.", with_thousands(p.cost)), LogKind::Money);
            }
            return;
        }
        if paid {
            self.money -= p.cost;
            self.emit(
                &format!(
                    "💣 You paid the ${} ransom; the threat passed quietly.",
                    with_thousands(p.cost)
                ),
                LogKind::Money,
            );
        } else {
            self.start_bomb_search();
        }
    }

    fn gut(&mut self, i: usize) {
        let (u, at) = self.tower.marked(i);
        u.set_state(at, UnitState::Gutted);
        u.set_occupants(at, 0);
        u.ever_occupied = false;
        u.set_residents(at, None);
        // A gutted venue reopens as a new one and counts no visitors (#1500).
        u.set_visitors_yest(at, None);
        u.satisfaction = 0.0;
        u.pending_income = 0.0;
        {
            let mut extras = u.extras_mut();
            extras.patronage_today = None;
            extras.patronage_yest = None;
            extras.profit_today = None;
            extras.profit_yest = None;
            extras.dirty_days = None;
            // A rebuilt theatre opens with a new film.
            extras.film_days = None;
            extras.film_classic = false;
            extras.film_blockbuster = false;
        }
        let name = u.kind.facility().name;
        self.tower.set_unit_label_at(i, name.to_string());
    }

    fn extinguish_all(&mut self) {
        let ids: Vec<i64> = self.events.active.iter().copied().collect();
        let mut gutted = 0;
        for id in ids {
            if let Some(idx) = self.tower.units.iter().position(|u| u.id == id) {
                if self.tower.units[idx].state == UnitState::Fire {
                    self.gut(idx);
                    self.events.fires_gut_rooms += 1;
                    gutted += 1;
                }
            }
        }
        self.events.active.clear();
        self.note_gutted(gutted);
    }

    /// `fire_gutted` for one step that gutted `rooms` (none for zero).
    fn note_gutted(&mut self, rooms: i64) {
        if rooms > 0 {
            self.gameplay.push(GameplayEvent::FireGutted { rooms });
        }
    }

    #[doc(hidden)]
    pub fn fire_chance(&self) -> f64 {
        let mut chance = 0.025;
        if self.has_operational(Kind::Security) {
            chance *= 0.45;
        }
        if self.has_operational(Kind::Medical) {
            chance *= 0.5;
        }
        chance
    }

    fn fire_rescue_cost(&self) -> f64 {
        (150_000.0 + ((self.star - 2).max(0) as f64) * 120_000.0).min(500_000.0)
    }

    /// `flammableUnits`: indices of real, finished, unburned rooms.
    fn flammable_units(&self) -> Vec<usize> {
        (0..self.tower.units.len())
            .filter(|&i| {
                let u = &self.tower.units[i];
                !u.kind.is_structural()
                    && u.state != UnitState::Construction
                    && u.state != UnitState::Fire
                    && u.state != UnitState::Gutted
            })
            .collect()
    }

    #[doc(hidden)]
    /// `startFire`.
    pub fn start_fire(&mut self) {
        let candidates = self.flammable_units();
        if candidates.is_empty() {
            return;
        }
        let i = *self.rng.pick(&candidates);
        self.ignite(i);
    }

    fn service_within(&self, kind: Kind, floor: i64, radius: i64) -> bool {
        self.tower
            .units
            .iter()
            .any(|u| u.kind == kind && u.is_operational() && (u.floor - floor).abs() <= radius)
    }

    #[doc(hidden)]
    pub fn control_chance(&self, floor: i64) -> f64 {
        let sec = self.service_within(Kind::Security, floor, SECURITY_RADIUS);
        let med = self.service_within(Kind::Medical, floor, MEDICAL_RADIUS);
        0.5 + (if sec { 0.2 } else { 0.0 }) + (if med { 0.3 } else { 0.0 })
    }

    fn spread_fire_to(&mut self, target: Option<i64>) {
        let Some(tid) = target else { return };
        let Some(idx) = self.tower.units.iter().position(|u| u.id == tid) else {
            return;
        };
        if !self.tower.units[idx].is_operational() {
            return;
        }
        let kind = self.tower.units[idx].kind;
        let mut ops = 0;
        for x in &self.tower.units {
            if x.kind == kind && x.is_operational() {
                ops += 1;
                if ops > 1 {
                    break;
                }
            }
        }
        if ops <= 1 {
            return;
        }
        let (u, at) = self.tower.marked(idx);
        u.set_state(at, UnitState::Fire);
        u.set_occupants(at, 0);
        let (id, name, floor) = (u.id, kind.facility().name, u.floor);
        self.events.active.insert(id);
        let msg = format!(
            "The fire spread to {} on {}!",
            name,
            self.floor_label(floor)
        );
        self.emit(&msg, LogKind::Bad);
    }

    fn process_fires(&mut self) {
        if self.events.active.is_empty() {
            return;
        }
        let ids: Vec<i64> = self.events.active.iter().copied().collect();
        let mut gutted = 0;
        for id in ids {
            let Some(idx) = self.tower.units.iter().position(|u| u.id == id) else {
                self.events.active.shift_remove(&id);
                continue;
            };
            if self.tower.units[idx].state != UnitState::Fire {
                self.events.active.shift_remove(&id);
                continue;
            }
            let (floor, x, width, name) = {
                let u = &self.tower.units[idx];
                (u.floor, u.x, u.width, u.kind.facility().name)
            };
            let control = self.control_chance(floor);
            if self.rng.chance(control) {
                self.gut(idx);
                self.events.fires_gut_rooms += 1;
                gutted += 1;
                self.events.active.shift_remove(&id);
                let msg = format!("🔥 The {} on {} burned down. Only a gutted shell remains. Bulldoze the rubble and rebuild.", name, self.floor_label(floor));
                self.emit(&msg, LogKind::Bad);
            } else {
                let adjacent = self
                    .tower
                    .room_at(floor, x - 1)
                    .or_else(|| self.tower.room_at(floor, x + width))
                    .map(|u| u.id);
                self.spread_fire_to(adjacent);
                let above = self.tower.room_at(floor + 1, x).map(|u| u.id);
                self.spread_fire_to(above);
            }
        }
        self.note_gutted(gutted);
        if !self.events.active.is_empty() {
            for u in self.tower.units.iter_mut() {
                if u.is_tenanted() || u.state == UnitState::Asleep {
                    u.satisfaction = (u.satisfaction - 0.05).max(0.0);
                }
            }
        }
    }

    fn maybe_santa(&mut self) {
        let cal = self.clock.calendar;
        let year = self.clock.year();
        let day_of_year = ((self.clock.day() % cal.year_days) + cal.year_days) % cal.year_days;
        let holiday_start = cal.year_days
            - (crate::jsmath::round((cal.year_days as f64 * 20.0) / 360.0) as i64).max(1);
        if day_of_year < holiday_start
            || self.star < 3
            || year as f64 == self.events.last_santa_year
        {
            return;
        }
        if !self.events.extra.chance(0.4) {
            return;
        }
        self.events.last_santa_year = year as f64;
        self.emit(
            "🎅 Santa was spotted crossing the sky above your tower for the holidays!",
            LogKind::Good,
        );
        self.fx.santa_seq += 1;
    }

    fn maybe_thief(&mut self) {
        if self.star < 2 {
            return;
        }
        if !self.events.extra.chance(THIEF_DAILY_CHANCE) {
            return;
        }
        // The floor places the cosmetic (`triggerThief`); the draw also keeps
        // the event stream in step with the TypeScript.
        let floor = self.thief_floor();
        if self.has_any(Kind::Security) {
            self.emit(
                "🕵️ Security caught a thief prowling the tower. Nothing was taken.",
                LogKind::Good,
            );
            self.fx.thief = ThiefFx {
                caught: true,
                floor,
                seq: self.fx.thief.seq + 1,
            };
            return;
        }
        self.fx.thief = ThiefFx {
            caught: false,
            floor,
            seq: self.fx.thief.seq + 1,
        };
        let loss = 5_000.0 + self.events.extra.int(0, 20_000) as f64;
        self.money -= loss;
        self.emit(
            &format!(
                "🕵️ A thief slipped through the tower and made off with ${}. Build Security.",
                with_thousands(loss)
            ),
            LogKind::Bad,
        );
    }

    fn thief_floor(&mut self) -> i64 {
        let mut floors: IndexSet<i64> = IndexSet::new();
        for u in &self.tower.units {
            if u.is_present() {
                floors.insert(u.floor);
            }
        }
        if floors.is_empty() {
            return 1;
        }
        let v: Vec<i64> = floors.into_iter().collect();
        *self.events.extra.pick(&v)
    }
}