jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

32 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `0a0bfee8329e`

tarball

atagen <boss@atagen.co>2026-10-11 05:25 UTC

14 files changed+445-13

game: the kitchen feeds the run until you are told twice

Raids cost the floor turn and pass through the household settle, so the fridge is never a free action. Lube units are spent only after the technique rules pass, so a refused jelq stays free. The watermelon is a 300 choice above the rupture line, and one supplement bottle in five works too well, resetting stamina into a priapism.

Modified file: src/game/balance.rs+9 additions@@ -65,6 +65,15 @@ pub const REFLECTION: u32 = 12;
 pub const ARRIVAL_BONUS: i32 = 1;
 pub const GREED_WARM: f64 = 1.5;
 pub const GREED_HOT: f64 = 2.0;
+pub const COCONUT_ODDS: u32 = 3;
+pub const ENERGY_ODDS: u32 = 5;
+pub const KITCHEN_ICE_ODDS: u32 = 8;
+pub const KITCHEN_TOLD: u32 = 4;
+pub const KITCHEN_TELLINGS: u8 = 2;
+pub const WATERMELON: (u32, u32) = (2, 5);
+pub const CAUGHT_MELONED: u32 = 3;
+pub const MELON_SHAME: u32 = 5;
+pub const ENERGY_STAMINA: i32 = 3;
 pub const OBSERVED: u32 = 6;
 pub const CAT_TAKES_TOWEL: u32 = 5;
 pub const FRIEND: u32 = 10;

Modified file: src/game/items.rs+52 additions−3 deletions@@ -17,9 +17,14 @@ pub enum Item {
     CageKey,
     Spreadsheet,
     TeapotSpout,
+    BabyOil,
+    CoconutOil,
+    Lotion,
+    Vaseline,
+    EnergyDrink,
 }
 
-pub const SHOP: [Item; 11] = [
+pub const SHOP: [Item; 15] = [
     Item::Pump,
     Item::PumpPro,
     Item::Extender,
@@ -31,10 +36,14 @@ pub const SHOP: [Item; 11] = [
     Item::Ruler,
     Item::IcePack,
     Item::CageKey,
+    Item::BabyOil,
+    Item::CoconutOil,
+    Item::Lotion,
+    Item::Vaseline,
 ];
 
 impl Item {
-    const ALL: [Self; 15] = [
+    const ALL: [Self; 20] = [
         Self::WarmTowel,
         Self::IcePack,
         Self::Ruler,
@@ -50,6 +59,11 @@ impl Item {
         Self::CageKey,
         Self::Spreadsheet,
         Self::TeapotSpout,
+        Self::BabyOil,
+        Self::CoconutOil,
+        Self::Lotion,
+        Self::Vaseline,
+        Self::EnergyDrink,
     ];
 
     pub fn slug(self) -> &'static str {
@@ -69,6 +83,11 @@ impl Item {
             Self::CageKey => "cage-key",
             Self::Spreadsheet => "spreadsheet",
             Self::TeapotSpout => "teapot-spout",
+            Self::BabyOil => "baby-oil",
+            Self::CoconutOil => "coconut-oil",
+            Self::Lotion => "lotion",
+            Self::Vaseline => "vaseline",
+            Self::EnergyDrink => "energy-drink",
         }
     }
 
@@ -97,6 +116,11 @@ impl Item {
             Self::CageKey => "Pump-Bro does not ask.",
             Self::Spreadsheet => "Charts your progress. Every line is flat.",
             Self::TeapotSpout => "Does nothing. Cannot be dropped.",
+            Self::BabyOil => "Smooth. +1. One unit per jelq.",
+            Self::CoconutOil => "+3. Solid until it matters. Suspicious at Nan's.",
+            Self::Lotion => "Handy. +0, and it chafes, so each jelq costs an extra stamina.",
+            Self::Vaseline => "+2. Raises suspicion everywhere.",
+            Self::EnergyDrink => "technique=energy. +3 stamina. Tastes like a battery.",
         }
     }
 
@@ -122,8 +146,13 @@ impl Item {
             Self::Supplement | Self::DoorLock | Self::DndSign | Self::Blinds | Self::Ruler => {
                 Some(5)
             }
+            Self::BabyOil | Self::CoconutOil | Self::Lotion | Self::Vaseline => Some(4),
             Self::IcePack => Some(3),
-            Self::WarmTowel | Self::Cage | Self::Spreadsheet | Self::TeapotSpout => None,
+            Self::WarmTowel
+            | Self::Cage
+            | Self::Spreadsheet
+            | Self::TeapotSpout
+            | Self::EnergyDrink => None,
         }
     }
 }
@@ -141,6 +170,11 @@ pub struct Items {
     pub cage: bool,
     pub spreadsheet: bool,
     pub teapot_spout: bool,
+    pub baby_oil: u32,
+    pub coconut_oil: u32,
+    pub lotion: u32,
+    pub vaseline: u32,
+    pub energy_drinks: u32,
 }
 
 impl Default for Items {
@@ -158,6 +192,11 @@ impl Default for Items {
             cage: false,
             spreadsheet: false,
             teapot_spout: false,
+            baby_oil: 1,
+            coconut_oil: 0,
+            lotion: 1,
+            vaseline: 0,
+            energy_drinks: 0,
         }
     }
 }
@@ -178,6 +217,11 @@ impl Items {
             Item::Cage => self.cage,
             Item::Spreadsheet => self.spreadsheet,
             Item::TeapotSpout => self.teapot_spout,
+            Item::BabyOil => self.baby_oil > 0,
+            Item::CoconutOil => self.coconut_oil > 0,
+            Item::Lotion => self.lotion > 0,
+            Item::Vaseline => self.vaseline > 0,
+            Item::EnergyDrink => self.energy_drinks > 0,
             Item::Pump | Item::CageKey => false,
         }
     }
@@ -204,6 +248,11 @@ impl Items {
             Item::CageKey => self.cage = false,
             Item::Spreadsheet => self.spreadsheet = true,
             Item::TeapotSpout => self.teapot_spout = true,
+            Item::BabyOil => self.baby_oil += 1,
+            Item::CoconutOil => self.coconut_oil += 1,
+            Item::Lotion => self.lotion += 1,
+            Item::Vaseline => self.vaseline += 1,
+            Item::EnergyDrink => self.energy_drinks += 1,
             Item::WarmTowel | Item::Pump => {}
         }
     }

Added file: src/game/kitchen.rs+127 additions@@ -0,0 +1,127 @@
+use axum::http::{StatusCode, header};
+use serde_json::json;
+
+use super::{
+    Cause, Floor, Item, Outcome, Run, Story,
+    balance::{
+        CAUGHT_MELONED, COCONUT_ODDS, ENERGY_ODDS, KITCHEN_ICE_ODDS, KITCHEN_TELLINGS,
+        KITCHEN_TOLD, MELON_SHAME, RUPTURE_LINE, SUSPICION_LIMIT, WATERMELON,
+    },
+};
+use crate::problem::Problem;
+use rand::Rng;
+
+impl Run {
+    /// Raid the fridge. It costs the floor turn like anything else, and the household keeps count.
+    pub fn raid_kitchen(&mut self) -> Result<Outcome, Problem> {
+        if !self.floor.has_kitchen() {
+            return Err(Problem::new(
+                StatusCode::NOT_FOUND,
+                "no-kitchen",
+                "There is no kitchen on this floor.",
+            ));
+        }
+        if self.kitchen_tellings >= KITCHEN_TELLINGS {
+            return Err(Problem::new(
+                StatusCode::GONE,
+                "kitchen-off-limits",
+                "The kitchen is off limits. You have been told twice.",
+            ));
+        }
+        if self.story == Story::Pending {
+            return Ok(self.branch_offer());
+        }
+        self.touch();
+        self.turn += 1;
+        self.here.turns += 1;
+        self.realise();
+        let was_below = self.suspicion < SUSPICION_LIMIT;
+        let outcome = if self.eq > RUPTURE_LINE && self.rng.random_ratio(WATERMELON.0, WATERMELON.1)
+        {
+            self.here.melon_offered = true;
+            self.melon_offer()
+        } else if self.chance(COCONUT_ODDS) {
+            self.items.grant(Item::CoconutOil);
+            Ok(Outcome::json(
+                StatusCode::OK,
+                json!({ "detail": "A jar of coconut oil, half of it already gone." }),
+            ))
+        } else if self.chance(ENERGY_ODDS) {
+            self.items.grant(Item::EnergyDrink);
+            Ok(Outcome::json(
+                StatusCode::OK,
+                json!({ "detail": "An energy drink, cold and faintly alarming." }),
+            ))
+        } else if self.chance(KITCHEN_ICE_ODDS) {
+            self.items.grant(Item::IcePack);
+            Ok(Outcome::json(
+                StatusCode::OK,
+                json!({ "detail": "An ice pack, buried under the peas." }),
+            ))
+        } else {
+            Ok(Outcome::empty(StatusCode::NO_CONTENT))
+        };
+        self.settle(was_below);
+        let outcome = outcome?;
+        if self.chance(KITCHEN_TOLD) {
+            self.kitchen_tellings += 1;
+            if self.kitchen_tellings >= KITCHEN_TELLINGS {
+                return Err(Problem::new(
+                    StatusCode::GONE,
+                    "kitchen-off-limits",
+                    "The kitchen is off limits. You have been told twice.",
+                ));
+            }
+            self.notices.push(if self.floor == Floor::Nans {
+                "Stop raiding the fridge."
+            } else {
+                "Stop raiding the kitchen."
+            });
+        }
+        Ok(outcome)
+    }
+
+    fn melon_offer(&self) -> Result<Outcome, Problem> {
+        let commit = self.path("/kitchen/watermelon");
+        Ok(Outcome::json(
+            StatusCode::MULTIPLE_CHOICES,
+            json!({
+                "detail": "The fridge holds a watermelon. It is exactly the right shape.",
+                "choices": [
+                    { "href": commit, "method": "POST", "title": "Commit to the watermelon" },
+                    { "href": self.path(""), "method": "GET", "title": "Close the fridge" },
+                ],
+            }),
+        )
+        .header(
+            header::LINK,
+            format!(
+                "<{commit}>; rel=\"alternate\"; title=\"Commit to the watermelon\"; allow=\"POST\""
+            ),
+        ))
+    }
+
+    /// The watermelon. It empties EQ, keeps the gains, costs shame, and the household may notice.
+    pub fn commit_melon(&mut self) -> Result<Outcome, Problem> {
+        if !self.here.melon_offered {
+            return Err(Problem::new(
+                StatusCode::CONFLICT,
+                "no-melon-on-offer",
+                "There is no watermelon on offer.",
+            ));
+        }
+        self.here.melon_offered = false;
+        self.eq = 0;
+        self.shame += MELON_SHAME;
+        self.touch();
+        if self.chance(CAUGHT_MELONED) {
+            return Err(self.end(Cause::Meloned));
+        }
+        Ok(Outcome::json(
+            StatusCode::OK,
+            json!({
+                "detail": "The watermelon did not survive, and neither did the mood. EQ is gone, the gains are kept, and the shame is considerable.",
+            }),
+        ))
+    }
+}

Modified file: src/game/mod.rs+3 additions@@ -6,6 +6,7 @@ mod forum;
 mod hazards;
 mod household;
 mod items;
+mod kitchen;
 mod outcome;
 mod shop;
 mod state;
@@ -64,6 +65,7 @@ pub struct Run {
     pub put_applied: bool,
     pub story: Story,
     pub meditation_taught: bool,
+    pub kitchen_tellings: u8,
     pub mum: Option<MumVisit>,
     pub heard: Vec<String>,
     pub elder: Elder,
@@ -150,6 +152,7 @@ impl Run {
             put_applied: false,
             story: Story::Unopened,
             meditation_taught: false,
+            kitchen_tellings: 0,
             mum: None,
             heard: Vec::new(),
             notices: Vec::new(),

Modified file: src/game/state.rs+11 additions@@ -82,6 +82,10 @@ impl Floor {
         matches!(self, Self::ChangingRoom | Self::Hotel)
     }
 
+    pub fn has_kitchen(self) -> bool {
+        matches!(self, Self::Bedroom | Self::Nans)
+    }
+
     pub fn timed(self) -> bool {
         !matches!(self, Self::Forum | Self::Clinic)
     }
@@ -139,6 +143,7 @@ pub struct FloorState {
     pub brother_told: bool,
     pub shopping: bool,
     pub meditated: bool,
+    pub melon_offered: bool,
     pub warm_arrival: bool,
     pub wifi_accepted: bool,
 }
@@ -187,6 +192,7 @@ pub enum Cause {
     Banned,
     Degloved,
     Zip,
+    Meloned,
     Abandoned,
 }
 
@@ -199,6 +205,7 @@ impl Cause {
             Self::Banned => "banned",
             Self::Degloved => "degloved",
             Self::Zip => "zip",
+            Self::Meloned => "watermelon",
             Self::Abandoned => "abandoned",
         }
     }
@@ -224,6 +231,9 @@ impl Cause {
             Self::Zip => {
                 "The request conflicts with the current state of the zip. The run has ended."
             }
+            Self::Meloned => {
+                "You have been caught with the watermelon. Nobody will mention it at dinner. The run has ended."
+            }
             Self::Abandoned => "The run was abandoned.",
         }
     }
@@ -232,6 +242,7 @@ impl Cause {
         match self {
             Self::Ruptured { .. } => StatusCode::INTERNAL_SERVER_ERROR,
             Self::Caught | Self::Opened | Self::Degloved | Self::Abandoned => StatusCode::GONE,
+            Self::Meloned => StatusCode::GONE,
             Self::Banned => StatusCode::FORBIDDEN,
             Self::Zip => StatusCode::CONFLICT,
         }

Modified file: src/game/techniques.rs+5 additions−1 deletions@@ -78,6 +78,7 @@ pub enum Utility {
     Pump,
     Supplement,
     Meditate,
+    Energy,
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
@@ -170,6 +171,7 @@ impl Utility {
             Self::Pump => "pump",
             Self::Supplement => "supplement",
             Self::Meditate => "meditate",
+            Self::Energy => "energy",
         }
     }
 
@@ -181,18 +183,20 @@ impl Utility {
             Self::Pump => "Large gains, all temporary. Requires a pump.",
             Self::Supplement => "Consumes a supplement.",
             Self::Meditate => "EQ -10. Taught by the forum. Once per floor, no stamina.",
+            Self::Energy => "+3 stamina. Consumes an energy drink. Tastes like a battery.",
         }
     }
 }
 
 impl Technique {
-    pub const ALL: [Self; 10] = [
+    pub const ALL: [Self; 11] = [
         Self::Utility(Utility::Warmup),
         Self::Utility(Utility::Ice),
         Self::Utility(Utility::Edge),
         Self::Utility(Utility::Pump),
         Self::Utility(Utility::Supplement),
         Self::Utility(Utility::Meditate),
+        Self::Utility(Utility::Energy),
         Self::Training(Training::Wet),
         Self::Training(Training::Dry),
         Self::Training(Training::Stretch),

Modified file: src/game/turn.rs+25 additions−1 deletions@@ -75,6 +75,7 @@ impl Run {
             Utility::Ice => return self.ice(),
             Utility::Supplement => return self.supplement(),
             Utility::Meditate => return self.meditate(),
+            Utility::Energy => return self.energy(),
             Utility::Edge | Utility::Pump => {}
         }
         if utility == Utility::Pump {
@@ -98,6 +99,7 @@ impl Run {
     ) -> Result<Outcome, Problem> {
         self.here.edges = 0;
         self.ready(Technique::Training(training), lube)?;
+        self.take_lube(lube)?;
         self.check_storage()?;
         self.floor_enemy()?;
         self.commit(intensity, lube, now, 1);
@@ -129,6 +131,7 @@ impl Run {
         self.here.edges = 0;
         self.ready(Technique::Training(a), lube)?;
         self.ready(Technique::Training(b), lube)?;
+        self.take_lube(lube)?;
         self.check_storage()?;
         self.floor_enemy()?;
         self.commit(intensity, lube, now, 2);
@@ -250,6 +253,26 @@ impl Run {
         }
     }
 
+    /// One unit of whatever was declared. Spit is free and the tap is always on.
+    fn take_lube(&mut self, lube: Option<Lube>) -> Result<(), Problem> {
+        let (held, name) = match lube {
+            None | Some(Lube::Spit) => return Ok(()),
+            Some(Lube::BabyOil) => (&mut self.items.baby_oil, "baby-oil"),
+            Some(Lube::CoconutOil) => (&mut self.items.coconut_oil, "coconut-oil"),
+            Some(Lube::Lotion) => (&mut self.items.lotion, "lotion"),
+            Some(Lube::Vaseline) => (&mut self.items.vaseline, "vaseline"),
+        };
+        if *held == 0 {
+            return Err(Problem::new(
+                StatusCode::PRECONDITION_FAILED,
+                "lubricant-exhausted",
+                format!("{name} was declared, but the bottle is empty."),
+            ));
+        }
+        *held -= 1;
+        Ok(())
+    }
+
     /// The techniques a JELQ could use right now without being refused before the roll.
     pub fn techniques_now(&self, now: Instant) -> Vec<Technique> {
         let blocked = !self.floor.timed()
@@ -267,6 +290,7 @@ impl Run {
                 Technique::Utility(Utility::Meditate) => {
                     self.meditation_taught && !self.here.meditated
                 }
+                Technique::Utility(Utility::Energy) => self.items.energy_drinks > 0,
                 _ => self.access(technique).is_ok() && self.check_storage().is_ok(),
             })
             .collect()
@@ -362,7 +386,7 @@ impl Run {
     }
 
     /// The part of a turn the house takes part in, whatever the action was.
-    fn settle(&mut self, was_below: bool) {
+    pub(super) fn settle(&mut self, was_below: bool) {
         self.maybe_summon_mum(was_below);
         if let Some(observer) = self.floor.observer()
             && self.chance(OBSERVED)

Modified file: src/game/utility.rs+21 additions−3 deletions@@ -9,8 +9,8 @@ use serde_json::json;
 use super::{
     Floor, Outcome, Run,
     balance::{
-        EDGE_EQ, EDGE_GIRTH, EDGE_LOOP, HOTEL_STRESS, ICE_EQ, PRIAPISM_EQ, PRIAPISM_TURNS,
-        PUMP_GAIN, SHOWER_EQ, SUPPLEMENT_WORKS, TOWELLESS_EQ, WARMUP_EQ,
+        EDGE_EQ, EDGE_GIRTH, EDGE_LOOP, ENERGY_STAMINA, HOTEL_STRESS, ICE_EQ, PRIAPISM_EQ,
+        PRIAPISM_TURNS, PUMP_GAIN, SHOWER_EQ, SUPPLEMENT_WORKS, TOWELLESS_EQ, WARMUP_EQ,
     },
 };
 use crate::problem::Problem;
@@ -69,6 +69,23 @@ impl Run {
         ))
     }
 
+    pub(super) fn energy(&mut self) -> Result<Outcome, Problem> {
+        if self.items.energy_drinks == 0 {
+            return Err(Problem::new(
+                StatusCode::FAILED_DEPENDENCY,
+                "no-energy-drink",
+                "The energy technique depends on an energy drink.",
+            ));
+        }
+        self.items.energy_drinks -= 1;
+        self.stamina = (self.stamina + ENERGY_STAMINA).min(self.max_stamina());
+        self.touch();
+        Ok(Outcome::json(
+            StatusCode::OK,
+            json!({ "detail": "The energy arrives before the regret. Stamina +3." }),
+        ))
+    }
+
     pub(super) fn supplement(&mut self) -> Result<Outcome, Problem> {
         if self.items.supplements == 0 {
             return Err(Problem::new(
@@ -80,11 +97,12 @@ impl Run {
         self.items.supplements -= 1;
         self.touch();
         if self.chance(SUPPLEMENT_WORKS) {
+            self.stamina = self.max_stamina();
             self.conditions.priapism_turns = PRIAPISM_TURNS;
             self.eq = self.eq.max(PRIAPISM_EQ);
             return Ok(Outcome::json(
                 StatusCode::OK,
-                json!({ "detail": "The upstream returned a valid response. It is still returning it." }),
+                json!({ "detail": "The upstream returned a valid response. It is still returning it. Stamina is fully restored." }),
             ));
         }
         Err(Problem::new(

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

@@ -99,6 +99,8 @@ fn api(state: Shared) -> Router {

9999 .route("/runs/{id}/techniques", scoped(&runs::TECHNIQUES))

100100 .route("/runs/{id}/drawer", scoped(&runs::DRAWER))

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

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

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

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

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

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

Modified file: src/http/run.rs+5 additions−2 deletions@@ -13,7 +13,7 @@ use super::{AppState, ctx::Ctx, meta, middleware::Compress, resource::Resource, 
 use crate::{
     game::{
         Elder, FORUM_THREAD, Floor, Run, SHOP, Story,
-        balance::{BRANCH_TURN, SUSPICION_LIMIT},
+        balance::{BRANCH_TURN, KITCHEN_TELLINGS, SUSPICION_LIMIT},
     },
     headers::{
         X_CASH, X_EQ, X_FLOOR, X_FORESKIN, X_GIRTH, X_LENGTH, X_OBSERVED_BY,
@@ -97,7 +97,7 @@ 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); 13] = [
+    let linked: [(&str, &RunResource, bool); 14] = [
         ("", &runs::RUN, true),
         ("floor", &runs::FLOOR, true),
         ("length", &runs::LENGTH, true),
@@ -105,6 +105,9 @@ fn links(run: &Run, now: Instant) -> String {
         ("inventory", &runs::INVENTORY, true),
         ("techniques", &runs::TECHNIQUES, true),
         ("drawer", &runs::DRAWER, run.drawer_worth_searching()),
+        ("kitchen", &runs::KITCHEN, {
+            run.floor.has_kitchen() && run.kitchen_tellings < KITCHEN_TELLINGS
+        }),
         ("grip", &runs::GRIP, true),
         ("shop", &runs::SHOP, run.floor.shop_open()),
         (

Modified file: src/http/runs.rs+10 additions@@ -82,6 +82,8 @@ pub static ITEM: RunResource =
 pub static TECHNIQUES: RunResource = home(&[Verb::new("GET", get_techniques)]);
 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 FLOOR: RunResource =
     home(&[Verb::new("GET", get_floor), Verb::new("POST", leave_floor)]);
 pub static SHOP: RunResource = home(&[Verb::new("GET", get_shop)]);
@@ -469,6 +471,14 @@ fn buy(run: &mut Run, ctx: &Ctx) -> Response {
     respond(run.buy(ctx.param("item")))
 }
 
+fn raid_kitchen(run: &mut Run, _: &Ctx) -> Response {
+    respond(run.raid_kitchen())
+}
+
+fn commit_melon(run: &mut Run, _: &Ctx) -> Response {
+    respond(run.commit_melon())
+}
+
 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/locale.rs+1

@@ -12,6 +12,7 @@ pub enum Locale {

1212

1313 /// Ordered so that longer phrases are rewritten before the words inside them.

1414 const EN_US: &[(&str, &str)] = &[

15+ ("Stop raiding the kitchen.", "Stop raiding the fridge."),

1516 (

1617 "Nan's house at Christmas",

1718 "Grandma's house for Thanksgiving",

Modified file: src/tests.rs+160 additions@@ -955,6 +955,7 @@ async fn the_thread_announces_itself_at_the_branch() {
     let app = seeded_with(Floor::Bathroom, |run| {
         run.turn = 8;
         run.warmed_up = true;
+        run.items.baby_oil = 9;
     });
     send(
         &app,
@@ -1085,6 +1086,7 @@ async fn leaving_the_band_warms_the_next_floor() {
         run.eq = 60;
         run.warmed_up = true;
         run.here.turns = 6;
+        run.items.baby_oil = 9;
     });
     let left = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
     assert_eq!(left.status(), StatusCode::SEE_OTHER);
@@ -1132,3 +1134,161 @@ async fn greed_multiplies_gains_above_the_band() {
     }
     panic!("no seed in 60 produced two clean rolls to compare");
 }
+
+#[tokio::test]
+async fn the_kitchen_is_only_on_the_home_floors() {
+    let absent = seeded_with(Floor::Bathroom, |_| {});
+    let no_kitchen = send(&absent, "POST", "/runs/cafebabe/kitchen", &[], "").await;
+    assert_eq!(no_kitchen.status(), StatusCode::NOT_FOUND);
+    let view = send(&absent, "GET", "/runs/cafebabe", &[], "").await;
+    assert!(!header(&view, "link").contains("/kitchen"));
+
+    let app = seeded_with(Floor::Bedroom, |_| {});
+    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert!(header(&view, "link").contains("/kitchen"));
+    let raid = send(&app, "POST", "/runs/cafebabe/kitchen", &[], "").await;
+    assert_ne!(raid.status(), StatusCode::NOT_FOUND);
+}
+
+#[tokio::test]
+async fn raids_cost_the_turn_and_the_fridge_pays_out_sometimes() {
+    let mut bounties = std::collections::BTreeSet::new();
+    let mut told = 0;
+    for seed in 0..80u64 {
+        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
+        let Ok(outcome) = run.raid_kitchen() else {
+            panic!("the first raid should never fail");
+        };
+        assert_eq!(run.turn, 1, "a raid costs the floor turn");
+        assert!(!run.here.melon_offered, "no melon at starting EQ");
+        if outcome.status == StatusCode::NO_CONTENT {
+            bounties.insert("empty");
+        } else {
+            bounties.insert("loot");
+        }
+        told += u32::from(run.kitchen_tellings);
+    }
+    assert!(bounties.contains("loot") && bounties.contains("empty"));
+    assert!(
+        (0..80).any(|seed| {
+            let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
+            run.raid_kitchen().is_ok() && run.kitchen_tellings == 0
+        }),
+        "most raids go unremarked"
+    );
+    assert!(told > 0, "someone should have been told across 80 raids");
+}
+
+#[tokio::test]
+async fn the_watermelon_offers_itself_above_ninety() {
+    let mut offered = 0;
+    let mut caught = 0;
+    let mut survived = 0;
+    for seed in 0..120u64 {
+        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
+        run.eq = 95;
+        let Ok(outcome) = run.raid_kitchen() else {
+            continue;
+        };
+        if outcome.status != StatusCode::MULTIPLE_CHOICES {
+            continue;
+        }
+        offered += 1;
+        let gains = run.length;
+        let disgrace = run.shame;
+        if run.commit_melon().is_err() {
+            caught += 1;
+            assert_eq!(run.ended.as_ref().unwrap().cause.slug(), "watermelon");
+        } else {
+            survived += 1;
+            assert_eq!(run.eq, 0);
+            assert_eq!(run.shame, disgrace + 5);
+            assert_eq!(run.length, gains, "the gains are kept");
+        }
+    }
+    assert!(
+        offered > 20,
+        "the melon should appear in two fifths of raids"
+    );
+    assert!(caught > 0 && survived > 0, "caught is one in three");
+}
+
+#[tokio::test]
+async fn the_kitchen_closes_after_two_tellings() {
+    let mut closed = None;
+    for seed in 0..300u64 {
+        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
+        let first = run.raid_kitchen();
+        let second = run.raid_kitchen();
+        if second.is_err() && first.is_ok() {
+            assert_eq!(run.kitchen_tellings, 2);
+            let Err(third) = run.raid_kitchen() else {
+                panic!("the kitchen should be gone");
+            };
+            assert_eq!(third.status(), StatusCode::GONE);
+            closed = Some(seed);
+            break;
+        }
+    }
+    assert!(
+        closed.is_some(),
+        "two tellings should occur within 300 seeds"
+    );
+}
+
+#[tokio::test]
+async fn lubes_run_out_but_spit_never_does() {
+    let app = seeded_with(Floor::Bedroom, |run| {
+        run.warmed_up = true;
+        run.items.baby_oil = 1;
+    });
+    let lube = [("content-type", "application/baby-oil")];
+    let first = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
+    assert_ne!(first.status(), StatusCode::PRECONDITION_FAILED);
+    let second = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
+    assert_eq!(second.status(), StatusCode::PRECONDITION_FAILED);
+
+    let spit = [("content-type", "text/plain; charset=spit")];
+    for _ in 0..3 {
+        let wet = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &spit, "").await;
+        assert_ne!(wet.status(), StatusCode::PRECONDITION_FAILED);
+    }
+}
+
+#[tokio::test]
+async fn energy_drinks_add_three_stamina() {
+    let app = seeded_with(Floor::Bedroom, |run| {
+        run.stamina = 2;
+        run.items.energy_drinks = 1;
+    });
+    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert!(header(&view, "link").contains("technique=energy"));
+    let drink = send(&app, "JELQ", "/runs/cafebabe?technique=energy", &[], "").await;
+    assert_eq!(drink.status(), StatusCode::OK);
+    let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert_eq!(header(&view, "x-stamina"), "5/10");
+    let again = send(&app, "JELQ", "/runs/cafebabe?technique=energy", &[], "").await;
+    assert_eq!(again.status(), StatusCode::FAILED_DEPENDENCY);
+}
+
+#[tokio::test]
+async fn the_working_supplement_resets_stamina() {
+    let mut worked = 0;
+    let mut bunk = 0;
+    for seed in 0..60u64 {
+        let app = app_with(Floor::Bedroom, seed, |run| {
+            run.stamina = 1;
+            run.items.supplements = 1;
+        });
+        let taken = send(&app, "JELQ", "/runs/cafebabe?technique=supplement", &[], "").await;
+        if taken.status() == StatusCode::OK {
+            worked += 1;
+            let view = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+            assert_eq!(header(&view, "x-stamina"), "10/10");
+        } else {
+            assert_eq!(taken.status(), StatusCode::BAD_GATEWAY);
+            bunk += 1;
+        }
+    }
+    assert!(worked > 0 && bunk > 0, "one in five should work too well");
+}

Modified file: src/ui.html+14 additions−3 deletions@@ -57,8 +57,9 @@ Language <select id="locale"><option>en-GB</option><option>en-US</option><option
 <script>
 const REL = "https://jelq.dev/rels/";
 const METHODS = ["JELQ", "HOLD", "GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "TRACE"];
-const LUBES = ["", "application/baby-oil", "application/coconut-oil", "application/lotion", "application/vaseline", "text/plain; charset=spit", "image/jpeg"];
-const DEATHS = ["vascular-event", "caught", "opened", "banned", "degloved", "zip", "run-ended"];
+const ALL_LUBES = ["", "application/baby-oil", "application/coconut-oil", "application/lotion", "application/vaseline", "text/plain; charset=spit", "image/jpeg"];
+const DEATHS = ["vascular-event", "caught", "opened", "banned", "degloved", "zip", "watermelon", "run-ended"];
+let stocked = null;
 const STATS = [
   ["x-floor", "Floor"],
   ["x-self-reported-length", "Self-reported length"],
@@ -159,7 +160,10 @@ function options(name) {
     const partners = techniques.filter(t => t.lubricant && t.name !== first.name && !clashes(first, t));
     return [""].concat(partners.map(t => t.name));
   }
-  if (name === "lube") return lubeRule() === "required" ? LUBES.filter(Boolean) : LUBES;
+  if (name === "lube") {
+    const lubes = stocked === null ? ALL_LUBES : ALL_LUBES.filter(l => l === "" || l.includes("/") && !l.startsWith("application/") || stocked.includes(l.replace("application/", "")));
+    return lubeRule() === "required" ? lubes.filter(Boolean) : lubes;
+  }
   return FIELDS[name].options || null;
 }
 
@@ -389,6 +393,13 @@ function absorb(r, sentMethod, sentPath) {
     challenged = r.status === 401 || "via" in headers;
   }
   if (headers.link) [linked, techniques] = parseLinks(headers.link);
+  if (run) {
+    fetch("/ui/send", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ method: "GET", path: run + "/inventory", headers: [], body: "" }) })
+      .then(r => r.json())
+      .then(r => {
+        try { stocked = (JSON.parse(r.body).items || []).map(i => i.name); render(); } catch (e) {}
+      });
+  }
   offered = body ? hrefs(body, []) : [];
   if (headers.location && !started) {
     offered.unshift({ key: "offered", group: "said", name: short(headers.location).split("/").pop() + " (Location)", path: headers.location, methods: ["GET"] });

jelq

Commit 0a0bfee8329e

Commit `0a0bfee8329e`