jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

36 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `b85a0d4536c3`

tarball

atagen <boss@atagen.co>2026-10-11 09:12 UTC

11 files changed+190-103

game: every turn rolls, and the thread teaches uli on the grind

The kitchen raid rolls the hazard table and HOLD rolls a flat 1 in 250 whatever the EQ, so a turn never passes without the vessels being consulted and the pacing tool stays 99.6% safe per use. Meditation needs no teaching now, which frees the turn-10 branch to be about shame rather than knowledge. uli is taught by POST /runs/{id}/re-read, a turn-costing grind that answers 304 Not Modified until TheElder's reply surfaces at 1 in 4, so a run that closed the tab is no longer locked out of it.

Modified file: src/game/balance.rs+2 additions−1 deletions@@ -58,7 +58,8 @@ pub const PULLED_MUSCLE: u32 = 12;
 pub const PULLED_MUSCLE_INTENSITY: i32 = 9;
 pub const RING_PRIAPISM: u32 = 10;
 pub const SUPPLEMENT_WORKS: u32 = 5;
-pub const MEDITATION_ODDS: u32 = 2;
+pub const RUPTURE_HOLD: u32 = 250;
+pub const ULI_ODDS: u32 = 4;
 pub const MEDITATION_EQ: i32 = 10;
 pub const HOLD_EQ: i32 = 15;
 pub const REFLECTION: u32 = 12;

Modified file: src/game/forum.rs+31 additions−8 deletions@@ -3,7 +3,7 @@ use serde_json::{Value, json};
 
 use super::{
     Cause, Elder, Floor, Outcome, Run, Story,
-    balance::{EXAGGERATION, MEDITATION_ODDS, PATIENCE},
+    balance::{EXAGGERATION, PATIENCE, SUSPICION_LIMIT, ULI_ODDS},
     body::exaggeration,
     honest, parse_credentials,
 };
@@ -81,13 +81,8 @@ impl Run {
         let (story, location, detail) = match choice {
             "forum" => {
                 self.shame += 3;
-                let taught = self.chance(MEDITATION_ODDS);
-                self.meditation_taught |= taught;
-                let detail = if taught {
-                    "The thread is from 2009. A technique called uli is discussed at length. Among the replies, a post teaches a way of breathing that lowers EQ."
-                } else {
-                    "The thread is from 2009. A technique called uli is discussed at length."
-                };
+                let detail =
+                    "The thread is from 2009. A technique called uli is discussed at length.";
                 (Story::ReadForum, self.path("/techniques"), detail)
             }
             "close-tab" => {
@@ -114,6 +109,34 @@ impl Run {
         )
     }
 
+    /// Opening the thread again costs the turn, and each read may finally surface the reply.
+    pub fn read_thread(&mut self) -> Result<Outcome, Problem> {
+        if self.story == Story::Pending {
+            return Ok(self.branch_offer());
+        }
+        self.touch();
+        self.turn += 1;
+        self.here.turns += 1;
+        self.realise();
+        if self.chance(self.rupture_odds()) {
+            return Err(self.rupture());
+        }
+        if self.chance(ULI_ODDS) {
+            self.uli_taught = true;
+            return Ok(Outcome::json(
+                StatusCode::OK,
+                json!({ "detail": "Past the necroposting, a reply from TheElder lays out the technique. Uli. The full routine. You write it down before the tab can lose it." }),
+            )
+            .header(header::LOCATION, self.path("/techniques")));
+        }
+        let was_below = self.suspicion < SUSPICION_LIMIT;
+        self.settle(was_below);
+        Ok(Outcome::empty(StatusCode::NOT_MODIFIED).header(
+            header::WARNING,
+            r#"199 - "Nothing new has been posted since 2009.""#,
+        ))
+    }
+
     fn elder_strike(&mut self, problem: Problem) -> Problem {
         self.touch();
         let Elder::Unverified { strikes } = &mut self.elder else {

Modified file: src/game/hazards.rs+22 additions−15 deletions@@ -18,6 +18,26 @@ use crate::problem::Problem;
 type Interruption = Result<ControlFlow<Outcome>, Problem>;
 
 impl Run {
+    /// How far the friction burn drags the rupture tiers down.
+    pub(super) fn burn(&self) -> i32 {
+        if self.conditions.friction_burn {
+            BURN_RUPTURE
+        } else {
+            0
+        }
+    }
+
+    /// The rupture tier for any turn that is not a jelq, so never the premature band's 1 in 3.
+    pub(super) fn rupture_odds(&self) -> u32 {
+        if self.eq <= DANGER_EQ - self.burn() {
+            RUPTURE_IN_BAND
+        } else if self.eq <= HOT_EQ - self.burn() {
+            RUPTURE_WARM
+        } else {
+            RUPTURE_HOT
+        }
+    }
+
     /// Accidents tied to a specific technique.
     pub(super) fn mishaps(&mut self, training: Training, intensity: i32) -> Interruption {
         if training == Training::Dry && intensity >= DEGLOVING_INTENSITY && self.chance(DEGLOVING) {
@@ -28,21 +48,8 @@ impl Run {
 
     /// Everything that can go wrong on a committed turn before the roll.
     pub(super) fn hazards(&mut self, intensity: i32) -> Interruption {
-        let burn = if self.conditions.friction_burn {
-            BURN_RUPTURE
-        } else {
-            0
-        };
-        let odds = if self.eq > PREMATURE_EQ - burn {
-            None
-        } else if self.eq <= DANGER_EQ - burn {
-            Some(RUPTURE_IN_BAND)
-        } else if self.eq <= HOT_EQ - burn {
-            Some(RUPTURE_WARM)
-        } else {
-            Some(RUPTURE_HOT)
-        };
-        if odds.is_some_and(|odds| self.chance(odds)) {
+        let burn = self.burn();
+        if self.eq <= PREMATURE_EQ - burn && self.chance(self.rupture_odds()) {
             return Err(self.rupture());
         }
         if self.floor.has_window() && !self.items.blinds && self.chance(WINDOW) {

Modified file: src/game/kitchen.rs+3 additions@@ -35,6 +35,9 @@ impl Run {
         self.turn += 1;
         self.here.turns += 1;
         self.realise();
+        if self.chance(self.rupture_odds()) {
+            return Err(self.rupture());
+        }
         let was_below = self.suspicion < SUSPICION_LIMIT;
         // One draw of 120 keeps the marginals at the documented 1 in 3, 1 in 5 and 1 in 8.
         let draw = self.rng.random_range(0..120);

Modified file: src/game/mod.rs+2 additions−2 deletions@@ -66,7 +66,7 @@ pub struct Run {
     pub warmed_up: bool,
     pub put_applied: bool,
     pub story: Story,
-    pub meditation_taught: bool,
+    pub uli_taught: bool,
     pub kitchen_tellings: u8,
     pub mum: Option<MumVisit>,
     pub heard: Vec<String>,
@@ -155,7 +155,7 @@ impl Run {
             warmed_up: false,
             put_applied: false,
             story: Story::Unopened,
-            meditation_taught: false,
+            uli_taught: false,
             kitchen_tellings: 0,
             mum: None,
             heard: Vec::new(),

Modified file: src/game/techniques.rs+2 additions−2 deletions@@ -221,7 +221,7 @@ impl Technique {
         }
     }
 
-    pub fn describe(self, forum_read: bool) -> Value {
+    pub fn describe(self, uli_taught: bool) -> Value {
         let training = match self {
             Self::Utility(utility) => {
                 return json!({ "name": utility.name(), "effect": utility.effect() });
@@ -235,7 +235,7 @@ impl Technique {
             "dc": profile.dc,
             "lubricant": lubricant,
             "foreskin": profile.foreskin.map(|(min, max)| json!({ "min": min, "max": max })),
-            "locked": training == Training::Uli && !forum_read,
+            "locked": training == Training::Uli && !uli_taught,
         })
     }
 }

Modified file: src/game/turn.rs+14 additions−34 deletions@@ -7,12 +7,12 @@ use serde_json::json;
 use super::{
     Floor, Grip, LUBRICANTS, Lube, Outcome, Payload, Run, Story, Technique,
     balance::{
-        ARRIVAL_BONUS, BAND_BONUS, BRANCH_TURN, BURN_RUPTURE, CAT_TAKES_TOWEL, CHANGING_ROOM_CHILL,
-        DANGER_EQ, EQ_BAND, EQ_WOBBLE, EXTENDER_GAIN, FRICTION_BURN, FRICTION_BURN_AT,
-        FRICTION_DRY, FRICTION_GRIP, FRICTION_HOLD, FRICTION_MAX, FRICTION_MEDITATE, FRICTION_SPIT,
-        GREED_HOT, GREED_WARM, HOLD_EQ, HOT_EQ, MEDITATION_EQ, OBSERVED, PRIAPISM_EQ,
-        PRIAPISM_TURNS, PULLED_MUSCLE, PULLED_MUSCLE_INTENSITY, REFLECTION, RING_PRIAPISM,
-        RING_RUPTURE_LINE, RUPTURE_LINE, STORAGE_GIRTH, SUSPICION_LIMIT,
+        ARRIVAL_BONUS, BAND_BONUS, BRANCH_TURN, CAT_TAKES_TOWEL, CHANGING_ROOM_CHILL, DANGER_EQ,
+        EQ_BAND, EQ_WOBBLE, EXTENDER_GAIN, FRICTION_BURN, FRICTION_BURN_AT, FRICTION_DRY,
+        FRICTION_GRIP, FRICTION_HOLD, FRICTION_MAX, FRICTION_MEDITATE, FRICTION_SPIT, GREED_HOT,
+        GREED_WARM, HOLD_EQ, HOT_EQ, MEDITATION_EQ, OBSERVED, PRIAPISM_EQ, PRIAPISM_TURNS,
+        PULLED_MUSCLE, PULLED_MUSCLE_INTENSITY, REFLECTION, RING_PRIAPISM, RING_RUPTURE_LINE,
+        RUPTURE_HOLD, RUPTURE_LINE, STORAGE_GIRTH, SUSPICION_LIMIT,
     },
     not_extended, round3,
     state::{MumVisit, Observer, Pending},
@@ -196,24 +196,13 @@ impl Run {
 
     /// Whether the run could attempt the technique now, ignoring the lubricant.
     fn access(&self, technique: Technique) -> Result<(), Problem> {
-        if technique == Technique::Training(Training::Uli) && !self.forum_read() {
+        if technique == Technique::Training(Training::Uli) && !self.uli_taught {
             return Err(Problem::new(
                 StatusCode::FORBIDDEN,
                 "technique-locked",
-                "uli is discussed on the forum, in a thread from 2009, by a man who never posted again. You have not been to the forum.",
+                "uli is discussed on the forum, in a thread from 2009, by a man who never posted again. You have not found the reply.",
             ));
         }
-        if technique == Technique::Utility(Utility::Meditate) {
-            return if self.meditation_taught {
-                Ok(())
-            } else {
-                Err(Problem::new(
-                    StatusCode::FORBIDDEN,
-                    "technique-locked",
-                    "The breathing technique is described in one of the forum's replies. You have not found it.",
-                ))
-            };
-        }
         if !self.warmed_up {
             return Err(Problem::new(
                 StatusCode::PRECONDITION_FAILED,
@@ -305,9 +294,7 @@ impl Run {
                 Technique::Utility(Utility::Warmup) => true,
                 Technique::Utility(Utility::Ice) => self.items.ice_packs > 0,
                 Technique::Utility(Utility::Supplement) => self.items.supplements > 0,
-                Technique::Utility(Utility::Meditate) => {
-                    self.meditation_taught && !self.here.meditated
-                }
+                Technique::Utility(Utility::Meditate) => !self.here.meditated,
                 Technique::Utility(Utility::Energy) => self.items.energy_drinks > 0,
                 _ => self.access(technique).is_ok() && self.check_storage().is_ok(),
             })
@@ -465,6 +452,9 @@ impl Run {
                 "The cage is locked. The key is not in the box.",
             ));
         }
+        if self.chance(RUPTURE_HOLD) {
+            return Err(self.rupture());
+        }
         self.touch();
         self.turn += 1;
         self.here.turns += 1;
@@ -487,7 +477,6 @@ impl Run {
     /// The breathing technique from the forum's replies. It spends no stamina and the turn is
     /// not the floor's, but each floor allows it once.
     fn meditate(&mut self) -> Result<Outcome, Problem> {
-        self.access(Technique::Utility(Utility::Meditate))?;
         if self.here.meditated {
             return Err(Problem::new(
                 StatusCode::CONFLICT,
@@ -559,11 +548,7 @@ impl Run {
         let timed = |p: Problem| p.header(SERVER_TIMING, &timing);
 
         let (length, girth) = self.scaled_gains(&profile, intensity);
-        let burn = if self.conditions.friction_burn {
-            BURN_RUPTURE
-        } else {
-            0
-        };
+        let burn = self.burn();
         let rupture_line = if self.items.ring {
             RING_RUPTURE_LINE
         } else {
@@ -676,12 +661,7 @@ impl Run {
             )
             .header(header::CONTENT_LOCATION, self.path("/foreskin"));
         }
-        let burn = if self.conditions.friction_burn {
-            BURN_RUPTURE
-        } else {
-            0
-        };
-        if self.eq > DANGER_EQ - burn {
+        if self.eq > DANGER_EQ - self.burn() {
             return self.rupture();
         }
         if training == Training::Stretch && !self.here.teapot {

Modified file: src/http/mod.rs+1

@@ -101,6 +101,7 @@ fn api(state: Shared) -> Router {

101101 .route("/runs/{id}/branches/{choice}", scoped(&runs::BRANCH))

102102 .route("/runs/{id}/kitchen", scoped(&runs::KITCHEN))

103103 .route("/runs/{id}/kitchen/watermelon", scoped(&runs::MELON))

104+ .route("/runs/{id}/re-read", scoped(&runs::REREAD))

104105 .route("/runs/{id}/floor", scoped(&runs::FLOOR))

105106 .route("/runs/{id}/shop", scoped(&runs::SHOP))

106107 .route("/runs/{id}/shop/{item}", scoped(&runs::BUY))

Modified file: src/http/run.rs+5 additions−5 deletions@@ -97,7 +97,9 @@ fn gate(run: &mut Run, ctx: &Ctx, scope: Scope) -> Option<Response> {
 /// Every resource the run can reach right now, then every technique a JELQ could use. The `allow`
 /// and `lubricant` extension attributes (RFC 8288 §3) say what each accepts, so a client never guesses.
 fn links(run: &Run, now: Instant) -> String {
-    let linked: [(&str, &RunResource, bool); 14] = [
+    let thread_reachable =
+        run.turn >= BRANCH_TURN || run.forum_read() || run.floor.number() >= Floor::Forum.number();
+    let linked: [(&str, &RunResource, bool); 15] = [
         ("", &runs::RUN, true),
         ("floor", &runs::FLOOR, true),
         ("length", &runs::LENGTH, true),
@@ -108,6 +110,7 @@ fn links(run: &Run, now: Instant) -> String {
         ("kitchen", &runs::KITCHEN, {
             run.floor.has_kitchen() && run.kitchen_tellings < KITCHEN_TELLINGS
         }),
+        ("re-read", &runs::REREAD, thread_reachable),
         ("grip", &runs::GRIP, true),
         ("shop", &runs::SHOP, run.floor.shop_open()),
         (
@@ -135,10 +138,7 @@ fn links(run: &Run, now: Instant) -> String {
             let allow = target.resource.allow(run);
             format!("<{path}>; rel=\"{REL_BASE}{name}\"; allow=\"{allow}\"")
         })
-        .chain((run.turn >= BRANCH_TURN
-            || run.forum_read()
-            || run.floor.number() >= Floor::Forum.number())
-        .then(|| {
+        .chain(thread_reachable.then(|| {
             format!(
                 "<{FORUM_THREAD}>; rel=\"{REL_BASE}thread\"; allow=\"{}\"",
                 meta::THREAD.allow_any()

Modified file: src/http/runs.rs+6 additions−1 deletions@@ -84,6 +84,7 @@ pub static DRAWER: RunResource = home(&[Verb::new("POST", search_drawer)]);
 pub static BRANCH: RunResource = home(&[Verb::new("POST", choose_branch)]);
 pub static KITCHEN: RunResource = home(&[Verb::new("POST", raid_kitchen)]);
 pub static MELON: RunResource = home(&[Verb::new("POST", commit_melon)]);
+pub static REREAD: RunResource = pockets(&[Verb::new("POST", re_read)]);
 pub static FLOOR: RunResource =
     home(&[Verb::new("GET", get_floor), Verb::new("POST", leave_floor)]);
 pub static SHOP: RunResource = home(&[Verb::new("GET", get_shop)]);
@@ -431,7 +432,7 @@ fn delete_item(run: &mut Run, ctx: &Ctx) -> Response {
 fn get_techniques(run: &mut Run, _: &Ctx) -> Response {
     let listed: Vec<Value> = Technique::ALL
         .into_iter()
-        .map(|t| t.describe(run.forum_read()))
+        .map(|t| t.describe(run.uli_taught))
         .collect();
     Json(json!({
         "usage": format!("JELQ {}?technique=<name>[,<name>]&intensity=<1-10>", run.path("")),
@@ -479,6 +480,10 @@ fn commit_melon(run: &mut Run, _: &Ctx) -> Response {
     respond(run.commit_melon())
 }
 
+fn re_read(run: &mut Run, _: &Ctx) -> Response {
+    respond(run.read_thread())
+}
+
 fn get_portal(run: &mut Run, _: &Ctx) -> Response {
     Json(json!({
         "terms": "By connecting you agree that the hotel is not responsible for anything that happens in this room, and that it does not want to know.",

Modified file: src/tests.rs+102 additions−35 deletions@@ -16,7 +16,7 @@ use crate::{
     AppState, Config,
     game::{
         Floor, MumVisit, Run, Story,
-        balance::{BRANCH_TURN, STORAGE_GIRTH, SUSPICION_LIMIT},
+        balance::{STORAGE_GIRTH, SUSPICION_LIMIT},
     },
     router,
 };
@@ -779,7 +779,7 @@ fn advertised(response: &Response) -> Vec<String> {
 async fn links_offer_only_usable_techniques() {
     let app = seeded_with(Floor::Bedroom, |run| run.foreskin = Some(1.0));
     let cold = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert_eq!(advertised(&cold), ["warmup", "ice"]);
+    assert_eq!(advertised(&cold), ["warmup", "ice", "meditate"]);
     let warm = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
     let usable = advertised(&warm);
     assert!(usable.contains(&"wet".to_owned()) && usable.contains(&"dry".to_owned()));
@@ -991,24 +991,49 @@ async fn the_thread_announces_itself_at_the_branch() {
 }
 
 #[tokio::test]
-async fn reading_the_forum_may_teach_meditation() {
-    let taught = (0..50u64)
-        .filter(|seed| {
-            let mut run = Run::new("cafebabe".into(), "cafe".into(), *seed);
-            run.story = Story::Pending;
-            run.turn = BRANCH_TURN;
-            run.choose("forum").is_ok() && run.meditation_taught
-        })
-        .count();
+async fn rereading_the_thread_teaches_uli() {
+    let mut taught_runs = 0;
+    let mut ruptured = 0;
+    for seed in 0..100u64 {
+        let app = app_with(Floor::Bedroom, seed, |run| {
+            run.warmed_up = true;
+            run.story = Story::ClosedTab;
+        });
+        let mut taught = false;
+        for _ in 0..40 {
+            let read = send(&app, "POST", "/runs/cafebabe/re-read", &[], "").await;
+            match read.status() {
+                StatusCode::NOT_MODIFIED => {
+                    assert!(header(&read, "warning").contains("2009"));
+                }
+                StatusCode::MULTIPLE_CHOICES => {
+                    send(&app, "POST", "/runs/cafebabe/branches/close-tab", &[], "").await;
+                }
+                StatusCode::OK => {
+                    assert!(header(&read, "location").contains("/techniques"));
+                    taught = true;
+                    break;
+                }
+                StatusCode::INTERNAL_SERVER_ERROR => break,
+                other => panic!("seed {seed} read the thread into {other}"),
+            }
+        }
+        if taught {
+            taught_runs += 1;
+            let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=uli", &[], "").await;
+            assert_ne!(jelq.status(), StatusCode::FORBIDDEN);
+        }
+        ruptured += u32::from(!taught);
+    }
     assert!(
-        taught > 0 && taught < 50,
-        "the teach roll should be a coin, it landed {taught}/50"
+        taught_runs >= 85,
+        "{taught_runs}/100 learned uli, {ruptured} ruptured first"
     );
 }
 
 #[tokio::test]
 async fn meditation_is_free_but_only_once_per_floor() {
-    let app = seeded_with(Floor::Bedroom, |run| run.meditation_taught = true);
+    let app = seeded_with(Floor::Bedroom, |_| {});
     let response = send(&app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;
     assert_eq!(response.status(), StatusCode::OK);
     assert_eq!(header(&response, "x-eq"), "10");
@@ -1018,12 +1043,12 @@ async fn meditation_is_free_but_only_once_per_floor() {
 }
 
 #[tokio::test]
-async fn meditation_stays_hidden_until_the_forum_teaches_it() {
+async fn meditation_is_listed_from_the_start() {
     let app = seeded_with(Floor::Bedroom, |_| {});
     let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(!header(&view, "link").contains("technique=meditate"));
+    assert!(header(&view, "link").contains("technique=meditate"));
     let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;
-    assert_eq!(jelq.status(), StatusCode::FORBIDDEN);
+    assert_eq!(jelq.status(), StatusCode::OK);
 }
 
 fn app_with(floor: Floor, seed: u64, setup: impl FnOnce(&mut Run)) -> Router {
@@ -1063,23 +1088,25 @@ async fn hold_is_offered_only_at_the_edges() {
 
 #[tokio::test]
 async fn holding_calms_and_sometimes_reflects() {
-    let calmed = (0..60u64)
-        .filter(|seed| {
-            let mut run = Run::new("cafebabe".into(), "cafe".into(), *seed);
-            run.eq = 75;
-            run.hold(Instant::now()).is_ok() && run.eq == 60
-        })
-        .count();
-    let reflected = (0..60u64)
-        .filter(|seed| {
-            let mut run = Run::new("cafebabe".into(), "cafe".into(), *seed);
-            run.eq = 75;
-            run.hold(Instant::now()).is_ok() && run.eq == 0
-        })
-        .count();
+    let mut calmed = 0;
+    let mut reflected = 0;
+    let mut ruptured = 0;
+    for seed in 0..120u64 {
+        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
+        run.eq = 75;
+        match run.hold(Instant::now()) {
+            Ok(_) if run.eq == 0 => reflected += 1,
+            Ok(_) => calmed += 1,
+            Err(_) => ruptured += 1,
+        }
+    }
     assert!(
-        calmed > 40 && reflected > 0 && calmed + reflected == 60,
-        "one HOLD in twelve should reflect, got {calmed} calm and {reflected} reflective of 60"
+        calmed > 100 && reflected > 0,
+        "one HOLD in twelve should reflect, got {calmed} calm and {reflected} reflective of 120"
+    );
+    assert!(
+        calmed + reflected + ruptured == 120 && ruptured <= 4,
+        "the flat 1 in 250 ruptured {ruptured} of 120 holds"
     );
 }
 
@@ -1358,7 +1385,6 @@ async fn holding_and_meditating_shed_friction() {
     assert_eq!(header(&view, "x-friction"), "3/10");
 
     let taught = seeded_with(Floor::Bedroom, |run| {
-        run.meditation_taught = true;
         run.friction = 5;
     });
     let calmed = send(
@@ -1479,7 +1505,6 @@ async fn the_burn_shifts_the_rupture_tiers() {
 #[tokio::test]
 async fn meditation_respects_the_priapism_floor() {
     let app = seeded_with(Floor::Bedroom, |run| {
-        run.meditation_taught = true;
         run.eq = 80;
         run.conditions.priapism_turns = 3;
     });
@@ -1630,3 +1655,45 @@ async fn priapism_holds_the_floor_through_every_reset() {
     let view = send(&melon, "GET", "/runs/cafebabe", &[], "").await;
     assert_eq!(header(&view, "x-eq"), "75");
 }
+
+#[tokio::test]
+async fn holding_rolls_a_flat_rupture_chance() {
+    async fn ruptures(eq: i32, stamina: i32) -> u32 {
+        let mut gone = 0;
+        for seed in 0..600u64 {
+            let app = app_with(Floor::Bedroom, seed, |run| {
+                run.warmed_up = true;
+                run.eq = eq;
+                run.stamina = stamina;
+            });
+            let held = send(&app, "HOLD", "/runs/cafebabe", &[], "").await;
+            if held.status() == StatusCode::INTERNAL_SERVER_ERROR {
+                gone += 1;
+            }
+        }
+        gone
+    }
+    let high = ruptures(90, 10).await;
+    let low = ruptures(30, 2).await;
+    assert!((0..=9).contains(&high), "high holds ruptured {high}/600");
+    assert!((0..=9).contains(&low), "low holds ruptured {low}/600");
+}
+
+#[tokio::test]
+async fn the_kitchen_rolls_the_normal_tiers() {
+    async fn ruptures(eq: i32) -> u32 {
+        let mut gone = 0;
+        for seed in 0..600u64 {
+            let app = app_with(Floor::Bedroom, seed, |run| run.eq = eq);
+            let raid = send(&app, "POST", "/runs/cafebabe/kitchen", &[], "").await;
+            if raid.status() == StatusCode::INTERNAL_SERVER_ERROR {
+                gone += 1;
+            }
+        }
+        gone
+    }
+    let hot = ruptures(96).await;
+    let cool = ruptures(40).await;
+    assert!((40..=80).contains(&hot), "hot kitchen ruptured {hot}/600");
+    assert!((0..=9).contains(&cool), "cool kitchen ruptured {cool}/600");
+}

jelq

Commit b85a0d4536c3

Commit `b85a0d4536c3`