jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

31 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `4347977b8192`

tarball

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

8 files changed+213-22

game: HOLD paces the band and gains multiply at the top of the red

EQ above the band used to be pure risk, so no run had a reason to leave it. Gains now multiply by 1.5 over 70 EQ and by 2 over 85, and leaving the band in order carries a +1 bonus into the first jelq of the next floor. The new HOLD method is the deliberate way back down, trading a floor turn for -15 EQ and +1 stamina, with one HOLD in twelve becoming a moment of self-reflection that empties EQ entirely.

Modified file: src/game/balance.rs+5 additions@@ -60,6 +60,11 @@ pub const RING_PRIAPISM: u32 = 10;
 pub const SUPPLEMENT_WORKS: u32 = 5;
 pub const MEDITATION_ODDS: u32 = 2;
 pub const MEDITATION_EQ: i32 = 10;
+pub const HOLD_EQ: i32 = 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 OBSERVED: u32 = 6;
 pub const CAT_TAKES_TOWEL: u32 = 5;
 pub const FRIEND: u32 = 10;

Modified file: src/game/floors.rs+13 additions−4 deletions@@ -4,8 +4,8 @@ use serde_json::{Value, json};
 use super::{
     Cause, Elder, Floor, FloorState, Item, Outcome, Run,
     balance::{
-        FLOOR_ALLOWANCE, FLOOR_TURNS, KEY_IN_DRAWER, RULER_IN_DRAWER, STARTING_EQ, SUSPICION_LIMIT,
-        ZIP,
+        EQ_BAND, FLOOR_ALLOWANCE, FLOOR_TURNS, KEY_IN_DRAWER, RULER_IN_DRAWER, STARTING_EQ,
+        SUSPICION_LIMIT, ZIP,
     },
     round2,
 };
@@ -16,8 +16,12 @@ impl Run {
         let Some(next) = self.floor.next() else {
             return;
         };
+        let warm = EQ_BAND.contains(&self.eq);
         self.floor = next;
-        self.here = FloorState::default();
+        self.here = FloorState {
+            warm_arrival: warm,
+            ..FloorState::default()
+        };
         self.warmed_up = false;
         self.eq = STARTING_EQ;
         self.suspicion = 0;
@@ -63,8 +67,13 @@ impl Run {
         let left = self.floor.name();
         let reverted = self.here.temp_length;
         self.next_floor(true);
+        let warm = if self.here.warm_arrival {
+            ", and the warmth came with you"
+        } else {
+            ""
+        };
         let mut body = json!({
-            "detail": format!("You leave {left}. You have arrived at {}.", self.floor.name()),
+            "detail": format!("You leave {left}. You have arrived at {}{warm}.", self.floor.name()),
             "note": self.floor.note(),
         });
         if reverted > 0.0 {

Modified file: src/game/state.rs+1

@@ -139,6 +139,7 @@ pub struct FloorState {

139139 pub brother_told: bool,

140140 pub shopping: bool,

141141 pub meditated: bool,

142+ pub warm_arrival: bool,

142143 pub wifi_accepted: bool,

143144 }

144145

Modified file: src/game/turn.rs+68 additions−13 deletions@@ -7,10 +7,10 @@ use serde_json::json;
 use super::{
     Floor, Grip, LUBRICANTS, Lube, Outcome, Payload, Run, Story, Technique,
     balance::{
-        BAND_BONUS, BRANCH_TURN, CAT_TAKES_TOWEL, CHANGING_ROOM_CHILL, DANGER_EQ, EQ_BAND,
-        EQ_WOBBLE, EXTENDER_GAIN, HOT_EQ, MEDITATION_EQ, OBSERVED, PRIAPISM_EQ, PRIAPISM_TURNS,
-        PULLED_MUSCLE, PULLED_MUSCLE_INTENSITY, 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, 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,
     },
     not_extended, round3,
     state::{MumVisit, Observer, Pending},
@@ -350,8 +350,20 @@ impl Run {
         self.suspicion =
             u8::try_from((i32::from(self.suspicion) + suspicion).min(i32::from(SUSPICION_LIMIT)))
                 .unwrap_or(SUSPICION_LIMIT);
-        self.maybe_summon_mum(was_below);
 
+        if intensity >= PULLED_MUSCLE_INTENSITY
+            && !self.conditions.pulled_muscle
+            && self.chance(PULLED_MUSCLE)
+        {
+            self.conditions.pulled_muscle = true;
+            self.stamina = self.stamina.min(self.max_stamina());
+        }
+        self.settle(was_below);
+    }
+
+    /// The part of a turn the house takes part in, whatever the action was.
+    fn settle(&mut self, was_below: bool) {
+        self.maybe_summon_mum(was_below);
         if let Some(observer) = self.floor.observer()
             && self.chance(OBSERVED)
         {
@@ -361,13 +373,6 @@ impl Run {
                 self.here.towel_stolen = true;
             }
         }
-        if intensity >= PULLED_MUSCLE_INTENSITY
-            && !self.conditions.pulled_muscle
-            && self.chance(PULLED_MUSCLE)
-        {
-            self.conditions.pulled_muscle = true;
-            self.stamina = self.stamina.min(self.max_stamina());
-        }
         if self.items.ring && self.eq > HOT_EQ && self.chance(RING_PRIAPISM) {
             self.conditions.priapism_turns = PRIAPISM_TURNS;
         }
@@ -382,6 +387,41 @@ impl Run {
         }
     }
 
+    /// HOLD. A pause between strokes, offered when the band has been left or the stamina is gone.
+    pub fn can_hold(&self) -> bool {
+        self.eq > DANGER_EQ || self.stamina <= 2
+    }
+
+    pub fn hold(&mut self, now: Instant) -> Result<Outcome, Problem> {
+        self.check_refractory(now)?;
+        if self.story == Story::Pending {
+            return Ok(self.branch_offer());
+        }
+        if self.items.cage {
+            return Err(Problem::new(
+                StatusCode::LOCKED,
+                "caged",
+                "The cage is locked. The key is not in the box.",
+            ));
+        }
+        self.touch();
+        self.turn += 1;
+        self.here.turns += 1;
+        self.realise();
+        let was_below = self.suspicion < SUSPICION_LIMIT;
+        if self.chance(REFLECTION) {
+            self.eq = 0;
+            self.shame += 1;
+            self.notices
+                .push("the count reached ten, and then the reflection started");
+        } else {
+            self.eq = (self.eq - HOLD_EQ).clamp(0, 100);
+        }
+        self.stamina = (self.stamina + 1).min(self.max_stamina());
+        self.settle(was_below);
+        Ok(Outcome::empty(StatusCode::NO_CONTENT))
+    }
+
     /// 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> {
@@ -443,7 +483,13 @@ impl Run {
             (Grip::Underhand, Training::Wet) => -1,
             _ => 0,
         };
-        let modifier = lube.map_or(0, Lube::modifier) + band + grip;
+        let arrival = if self.here.warm_arrival {
+            self.here.warm_arrival = false;
+            ARRIVAL_BONUS
+        } else {
+            0
+        };
+        let modifier = lube.map_or(0, Lube::modifier) + band + grip + arrival;
         let dc = profile.dc + intensity / 3;
         let total = natural + modifier;
         let timing = format!("roll;desc=\"d20{modifier:+} vs {dc}\";dur={natural}");
@@ -527,6 +573,15 @@ impl Run {
     fn scaled_gains(&self, profile: &Profile, intensity: i32) -> (f64, f64) {
         let scale = f64::from(intensity);
         let (mut length, mut girth) = (profile.length * scale, profile.girth * scale);
+        let greed = if self.eq > HOT_EQ {
+            GREED_HOT
+        } else if self.eq > DANGER_EQ {
+            GREED_WARM
+        } else {
+            1.0
+        };
+        length *= greed;
+        girth *= greed;
         if self.here.teapot {
             length *= 0.5;
             girth *= 1.5;

Modified file: src/http/resource.rs+2 additions−3 deletions@@ -113,9 +113,8 @@ pub fn unsupported(method: &Method, allow: &str) -> Response {
             "The server is a teapot. RFC 2324 is clear on this. It is not yet short and stout.",
         )
         .into_response(),
-        "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "TRACE" | "JELQ" => {
-            method_not_allowed(format!("{method} is not supported here."), allow)
-        }
+        "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "TRACE" | "JELQ"
+        | "HOLD" => method_not_allowed(format!("{method} is not supported here."), allow),
         _ if name.eq_ignore_ascii_case("jelq") => Problem::new(
             StatusCode::NOT_IMPLEMENTED,
             "not-implemented",

Modified file: src/http/runs.rs+8 additions@@ -59,6 +59,10 @@ pub static RUN: RunResource = RunResource {
             Verb::new("GET", get_run),
             Verb::new("JELQ", jelq)
                 .only_when(not_in_clinic, "JELQ is not performed in the clinic."),
+            Verb::new("HOLD", hold_run).only_when(
+                Run::can_hold,
+                "HOLD is only available above 70 EQ or at 2 stamina or less.",
+            ),
             Verb::new("PUT", put_run),
             Verb::new("PATCH", patch_run),
             Verb::new("DELETE", delete_run),
@@ -177,6 +181,10 @@ fn put_run(run: &mut Run, _: &Ctx) -> Response {
     run.put().into_response()
 }
 
+fn hold_run(run: &mut Run, ctx: &Ctx) -> Response {
+    respond(run.hold(ctx.now))
+}
+
 fn patch_run(run: &mut Run, ctx: &Ctx) -> Response {
     let is_patch = ctx
         .header(header::CONTENT_TYPE)

Modified file: src/tests.rs+115 additions−1 deletions@@ -1,4 +1,7 @@
-use std::{sync::Arc, time::Duration};
+use std::{
+    sync::Arc,
+    time::{Duration, Instant},
+};
 
 use axum::{
     Router,
@@ -1018,3 +1021,114 @@ async fn meditation_stays_hidden_until_the_forum_teaches_it() {
     let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;
     assert_eq!(jelq.status(), StatusCode::FORBIDDEN);
 }
+
+fn app_with(floor: Floor, seed: u64, setup: impl FnOnce(&mut Run)) -> Router {
+    let state = Arc::new(AppState::default());
+    let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
+    run.floor = floor;
+    setup(&mut run);
+    state.insert(run);
+    router(state)
+}
+
+#[tokio::test]
+async fn hold_is_offered_only_at_the_edges() {
+    let calm = seeded_with(Floor::Bedroom, |_| {});
+    let refused = send(&calm, "HOLD", "/runs/cafebabe", &[], "").await;
+    assert_eq!(refused.status(), StatusCode::METHOD_NOT_ALLOWED);
+    assert!(!header(&refused, "allow").contains("HOLD"));
+    let view = send(&calm, "GET", "/runs/cafebabe", &[], "").await;
+    assert!(!header(&view, "link").contains("HOLD"));
+    let options = send(&calm, "OPTIONS", "/runs/cafebabe", &[], "").await;
+    assert!(!header(&options, "allow").contains("HOLD"));
+
+    let winded = seeded_with(Floor::Bedroom, |run| run.stamina = 2);
+    let listed = send(&winded, "GET", "/runs/cafebabe", &[], "").await;
+    assert!(header(&listed, "link").contains("HOLD"));
+    let options = send(&winded, "OPTIONS", "/runs/cafebabe", &[], "").await;
+    assert!(header(&options, "allow").contains("HOLD"));
+
+    let hot = seeded_with(Floor::Bedroom, |run| {
+        run.eq = 75;
+        run.warmed_up = true;
+    });
+    let held = send(&hot, "HOLD", "/runs/cafebabe", &[], "").await;
+    assert_eq!(held.status(), StatusCode::NO_CONTENT);
+    assert_eq!(header(&held, "x-stamina"), "10/10");
+}
+
+#[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();
+    assert!(
+        calmed > 40 && reflected > 0 && calmed + reflected == 60,
+        "one HOLD in twelve should reflect, got {calmed} calm and {reflected} reflective of 60"
+    );
+}
+
+#[tokio::test]
+async fn leaving_the_band_warms_the_next_floor() {
+    let app = seeded_with(Floor::Bedroom, |run| {
+        run.eq = 60;
+        run.warmed_up = true;
+        run.here.turns = 6;
+    });
+    let left = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
+    assert_eq!(left.status(), StatusCode::SEE_OTHER);
+    let detail = json(left).await["detail"].as_str().unwrap().to_owned();
+    assert!(detail.contains("the warmth came with you"));
+
+    let lube = [("content-type", "application/baby-oil")];
+    send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
+    // The shower is a +35 warm-up, so EQ lands in the band and the band bonus rides along.
+    // The arrival bonus is the one point the second jelq loses.
+    let first = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
+    assert!(
+        header(&first, "server-timing").contains("d20+4"),
+        "the first jelq of a warm arrival rolls with +1, got {}",
+        header(&first, "server-timing")
+    );
+    let second = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
+    assert!(header(&second, "server-timing").contains("d20+3"));
+}
+
+#[tokio::test]
+async fn greed_multiplies_gains_above_the_band() {
+    let lube = [("content-type", "application/baby-oil")];
+    for seed in 0..60u64 {
+        let app = app_with(Floor::Bedroom, seed, |run| {
+            run.eq = 60;
+            run.warmed_up = true;
+        });
+        let in_band = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
+        let app = app_with(Floor::Bedroom, seed, |run| {
+            run.eq = 75;
+            run.warmed_up = true;
+        });
+        let greedy = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &lube, "").await;
+        if in_band.status() != StatusCode::OK || greedy.status() != StatusCode::OK {
+            continue;
+        }
+        let steady = json(in_band).await["length"].as_f64().unwrap();
+        let eager = json(greedy).await["length"].as_f64().unwrap();
+        assert!(
+            (eager - steady * 1.5).abs() < 1e-9,
+            "seed {seed} gained {eager} above the band against {steady} inside it"
+        );
+        return;
+    }
+    panic!("no seed in 60 produced two clean rolls to compare");
+}

Modified file: src/ui.html+1−1

@@ -56,7 +56,7 @@ Language <select id="locale"><option>en-GB</option><option>en-US</option><option

5656

5757 <script>

5858 const REL = "https://jelq.dev/rels/";

59-const METHODS = ["JELQ", "GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "TRACE"];

59+const METHODS = ["JELQ", "HOLD", "GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "TRACE"];

6060

 const LUBES = ["", "application/baby-oil", "application/coconut-oil", "application/lotion", "application/vaseline", "text/plain; charset=spit", "image/jpeg"];

6161 const DEATHS = ["vascular-event", "caught", "opened", "banned", "degloved", "zip", "run-ended"];

6262 const STATS = [

jelq

Commit 4347977b8192

Commit `4347977b8192`