jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

41 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `058650ec79d6`

tarball

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

11 files changed+222-26

game: give length, girth and foreskin their own consequences

EQ drove every decision while the stats it grows only fed the
leaderboard, so each now bites somewhere of its own. Foreskin glides
unlubed strokes, girth earns respect from the gym staff and forum mods
at 5 and chafes and outgrows the underhand grip past 5.5, and length
decides whether the changing room counts your suspicion twice. The
clinic reports all three, and the leaderboard ranks by volume.

Added file: .cade+1

@@ -0,0 +1 @@

1+load flake

Modified file: src/game/balance.rs+5 additions@@ -39,6 +39,11 @@ pub const MM_PER_INCH: f64 = 25.4;
 pub const HONEST_TOLERANCE: f64 = 0.06;
 pub const EXAGGERATION: f64 = 1.0;
 pub const STORAGE_GIRTH: f64 = 5.0;
+pub const GIRTH_RESPECTED: f64 = 5.0;
+pub const GIRTH_THICK: f64 = 5.5;
+pub const FORESKIN_GLIDE: f64 = 1.0;
+pub const LOCKER_ROOM_BAR: f64 = 8.0;
+pub const LOCKER_ROOM_SHAME: u32 = 3;
 pub const PUT_GAIN: f64 = 0.01;
 pub const PUMP_GAIN: f64 = 0.5;
 pub const EXTENDER_GAIN: f64 = 0.004;

Modified file: src/game/body.rs+33 additions−2 deletions@@ -4,7 +4,7 @@ use serde_json::{Value, json};
 
 use super::{
     Grip, Outcome, Run,
-    balance::{EXAGGERATION, PUT_GAIN},
+    balance::{EXAGGERATION, GIRTH_RESPECTED, GIRTH_THICK, LOCKER_ROOM_BAR, PUT_GAIN},
     etag_matches, honest,
 };
 use crate::problem::Problem;
@@ -114,8 +114,39 @@ impl Run {
         Ok(Outcome::empty(StatusCode::NO_CONTENT))
     }
 
-    pub fn set_grip(&mut self, grip: Grip) {
+    pub fn set_grip(&mut self, grip: Grip) -> Result<(), Problem> {
+        self.grip_closes(grip)?;
         self.grip = grip;
         self.touch();
+        Ok(())
+    }
+
+    pub(super) fn grip_closes(&self, grip: Grip) -> Result<(), Problem> {
+        if grip == Grip::Underhand && self.girth > GIRTH_THICK {
+            return Err(Problem::new(
+                StatusCode::PAYLOAD_TOO_LARGE,
+                "grip-too-small",
+                format!(
+                    "The underhand grip no longer closes around {:.2} inches of girth.",
+                    self.girth
+                ),
+            )
+            .with("maximum", GIRTH_THICK));
+        }
+        Ok(())
+    }
+
+    /// Everyone in the changing room self-reports, so the comparison is self-report against self-report.
+    pub fn holds_own_in_the_locker_room(&self) -> bool {
+        self.self_reported() >= LOCKER_ROOM_BAR
+    }
+
+    pub fn girth_respected(&self) -> bool {
+        self.girth >= GIRTH_RESPECTED
+    }
+
+    /// A cylinder whose circumference is the girth.
+    pub fn volume(&self, length: f64) -> f64 {
+        self.girth * self.girth * length / (4.0 * std::f64::consts::PI)
     }
 }

Modified file: src/game/clinic.rs+14 additions−2 deletions@@ -2,7 +2,10 @@ use axum::http::{StatusCode, header};
 use serde_json::json;
 
 use super::{Floor, Outcome, Run, etag_matches, parse_credentials, round2};
-use crate::{headers::X_DIAGNOSIS, problem::Problem};
+use crate::{
+    headers::{SERVER_TIMING, X_DIAGNOSIS},
+    problem::Problem,
+};
 
 const INTAKE: [&str; 3] = [
     "The clinic does not accept excuses.",
@@ -60,14 +63,23 @@ impl Run {
                 self.shame += 15;
             }
         }
+        let volume = self.volume(self.length);
+        let foreskin = self.foreskin.unwrap_or(0.0);
+        let timing = format!(
+            "length;dur={:.2}, girth;dur={:.2}, foreskin;dur={foreskin:.2}, volume;desc=\"cubic inches\";dur={volume:.2}",
+            self.length, self.girth
+        );
         Ok(Outcome::json(
             StatusCode::OK,
             json!({
                 "diagnosis": "within normal range",
                 "measured_length": round2(self.length),
+                "measured_girth": round2(self.girth),
+                "volume": round2(volume),
                 "prescription": "Please stop.",
             }),
         )
-        .header(header::ETAG, etag))
+        .header(header::ETAG, etag)
+        .header(SERVER_TIMING, timing))
     }
 }

Modified file: src/game/floors.rs+8 additions−1 deletions@@ -5,7 +5,8 @@ use super::{
     Cause, Elder, Floor, FloorState, Item, Outcome, Run,
     balance::{
         DRAWER_JAMS, EQ_BAND, FLOOR_ALLOWANCE, FLOOR_TURNS, FRICTION_FLOOR, GREGS_LOCKER,
-        KEY_IN_DRAWER, RULER_IN_DRAWER, STARTING_EQ, SUSPICION_LIMIT, ZIP,
+        KEY_IN_DRAWER, LOCKER_ROOM_BAR, LOCKER_ROOM_SHAME, RULER_IN_DRAWER, STARTING_EQ,
+        SUSPICION_LIMIT, ZIP,
     },
     round2,
 };
@@ -27,6 +28,11 @@ impl Run {
         self.suspicion = 0;
         self.shed(FRICTION_FLOOR);
         self.mum = None;
+        if self.floor == Floor::ChangingRoom && !self.holds_own_in_the_locker_room() {
+            self.shame += LOCKER_ROOM_SHAME;
+            self.notices
+                .push("Kev is 8 inches, he says. Nobody asked you, which is worse.");
+        }
         if paid {
             self.cash += FLOOR_ALLOWANCE;
         }
@@ -106,6 +112,7 @@ impl Run {
                     { "name": "Greg", "self_reported_length": 9.5 },
                     { "name": "Dmitri", "self_reported_length": 8.75 },
                     { "name": "a man in a towel", "self_reported_length": 11.0 },
+                    { "name": "Kev", "self_reported_length": LOCKER_ROOM_BAR },
                 ]);
             }
             Floor::Hotel => view["portal"] = json!(self.path("/portal")),

Modified file: src/game/forum.rs+8 additions−1 deletions@@ -195,7 +195,14 @@ impl Run {
         }
         if !honest(claimed, actual) {
             self.shame += 1;
-            return Err(self.elder_strike(verification("Verification failed. The forum can tell.")));
+            let failed = verification("Verification failed. The forum can tell.");
+            if self.girth_respected() {
+                return Err(failed.header(
+                    X_FORUM_NOTE,
+                    "The mods have let this one go. Girth is also a dimension.",
+                ));
+            }
+            return Err(self.elder_strike(failed));
         }
         self.elder = Elder::Verified;
         self.touch();

Modified file: src/game/hazards.rs+6 additions−1 deletions@@ -176,8 +176,13 @@ impl Run {
             }
             Floor::ChangingRoom => {
                 self.suspicion = 0;
-                self.shame += 5;
                 self.touch();
+                if self.girth_respected() {
+                    self.notices
+                        .push("the gym staff have seen worse, and they leave it there");
+                    return Ok(());
+                }
+                self.shame += 5;
                 Err(Problem::new(
                     StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS,
                     "gym-staff",

Modified file: src/game/turn.rs+18 additions−7 deletions@@ -7,11 +7,11 @@ use super::{
     Floor, Grip, LUBRICANTS, Lube, Outcome, Payload, Run, Story, Technique,
     balance::{
         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,
+        EQ_BAND, EQ_WOBBLE, EXTENDER_GAIN, FORESKIN_GLIDE, FRICTION_BURN, FRICTION_BURN_AT,
+        FRICTION_DRY, FRICTION_GRIP, FRICTION_HOLD, FRICTION_MAX, FRICTION_MEDITATE, FRICTION_SPIT,
+        GIRTH_THICK, 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},
@@ -194,6 +194,9 @@ impl Run {
             )
             .with("technique", Utility::Warmup.name()));
         }
+        if matches!(technique, Technique::Training(_)) {
+            self.grip_closes(self.grip)?;
+        }
         match technique {
             Technique::Utility(Utility::Pump) if !self.items.pump_pro => Err(Problem::new(
                 StatusCode::FAILED_DEPENDENCY,
@@ -342,7 +345,10 @@ impl Run {
             6..=8 => 1,
             _ => 2,
         };
-        let mut friction = (base + vigour - slip).max(0);
+        let unlubed = matches!(lube, None | Some(Lube::Spit));
+        let thick = i32::from(unlubed && self.girth > GIRTH_THICK);
+        let glide = i32::from(unlubed && self.foreskin.is_some_and(|f| f >= FORESKIN_GLIDE));
+        let mut friction = (base + vigour + thick - slip - glide).max(0);
         if friction > 0 && self.jelq_grip.is_some_and(|grip| grip != self.grip) {
             friction -= FRICTION_GRIP;
         }
@@ -391,7 +397,12 @@ impl Run {
         self.eq = (self.eq + intensity * 2 - 6 - chill + wobble).clamp(0, 100);
 
         let mut suspicion = intensity / 5 + i32::from(lube == Some(Lube::Vaseline));
-        if matches!(self.floor, Floor::ChangingRoom | Floor::Nans) {
+        let doubled = match self.floor {
+            Floor::Nans => true,
+            Floor::ChangingRoom => !self.holds_own_in_the_locker_room(),
+            _ => false,
+        };
+        if doubled {
             suspicion *= 2;
         }
         if self.floor == Floor::Nans && lube == Some(Lube::CoconutOil) {

Modified file: src/http/meta.rs+23 additions−11 deletions@@ -162,11 +162,22 @@ fn graveyard(state: &mut Shared, _: &Ctx) -> Response {
     Json(json!({ "runs": dead })).into_response()
 }
 
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Sort {
+    SelfReported,
+    ContentLength,
+    /// Self-reported length against real girth, the only metric the forum respects.
+    Volume,
+}
+
 fn leaderboard(state: &mut Shared, ctx: &Ctx) -> Response {
-    let truthful = match ctx.query("sort") {
-        None | Some("self-reported-length") => false,
+    let sort = match ctx.query("sort") {
+        None | Some("self-reported-length") => Sort::SelfReported,
+        Some("volume") => Sort::Volume,
         Some("content-length") => match ctx.cookie("ruler") {
-            Some(ruler) if state.config.secret.verify("ruler", ruler) == Some("1") => true,
+            Some(ruler) if state.config.secret.verify("ruler", ruler) == Some("1") => {
+                Sort::ContentLength
+            }
             Some(_) => {
                 return Problem::new(
                     StatusCode::BAD_REQUEST,
@@ -189,7 +200,7 @@ fn leaderboard(state: &mut Shared, ctx: &Ctx) -> Response {
             return Problem::new(
                 StatusCode::BAD_REQUEST,
                 "unknown-sort",
-                "The leaderboard sorts by self-reported-length or content-length.",
+                "The leaderboard sorts by self-reported-length, volume or content-length.",
             )
             .into_response();
         }
@@ -200,12 +211,10 @@ fn leaderboard(state: &mut Shared, ctx: &Ctx) -> Response {
         .values()
         .filter(|run| include_seeded || !run.seeded)
         .collect();
-    let key = |run: &Run| {
-        if truthful {
-            run.current_length()
-        } else {
-            run.self_reported()
-        }
+    let key = |run: &Run| match sort {
+        Sort::SelfReported => run.self_reported(),
+        Sort::ContentLength => run.current_length(),
+        Sort::Volume => run.volume(run.self_reported()),
     };
     entries.sort_by(|a, b| key(b).total_cmp(&key(a)));
     let entries: Vec<Value> = entries
@@ -219,7 +228,10 @@ fn leaderboard(state: &mut Shared, ctx: &Ctx) -> Response {
                 "ranked": !run.seeded,
                 "viral": run.filmed_at.is_some(),
             });
-            if truthful {
+            if sort == Sort::Volume {
+                entry["volume"] = json!((run.volume(run.self_reported()) * 100.0).round() / 100.0);
+            }
+            if sort == Sort::ContentLength {
                 entry["content_length"] = json!((run.current_length() * MM_PER_INCH).round());
             }
             entry

Modified file: src/http/runs.rs+3 additions−1 deletions@@ -513,7 +513,9 @@ fn requested_grip(ctx: &Ctx) -> Option<Grip> {
 
 fn get_grip(run: &mut Run, ctx: &Ctx) -> Response {
     if let Some(grip) = requested_grip(ctx) {
-        run.set_grip(grip);
+        if let Err(problem) = run.set_grip(grip) {
+            return problem.into_response();
+        }
         let mut response = (
             StatusCode::SWITCHING_PROTOCOLS,
             [

Modified file: src/tests.rs+103 additions@@ -1421,6 +1421,7 @@ async fn the_working_supplement_resets_stamina() {
 async fn dry_jelqs_build_friction_and_real_lube_does_not() {
     let app = seeded_with(Floor::Bedroom, |run| {
         run.warmed_up = true;
+        run.foreskin = Some(0.9);
     });
     let dry = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
     assert_eq!(header(&dry, "x-friction"), "2/10");
@@ -1450,6 +1451,7 @@ async fn dry_jelqs_build_friction_and_real_lube_does_not() {
 async fn switching_grips_makes_the_friction_cheaper() {
     let app = seeded_with(Floor::Bedroom, |run| {
         run.warmed_up = true;
+        run.foreskin = Some(0.9);
     });
     let dry = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
     assert_eq!(header(&dry, "x-friction"), "2/10");
@@ -1936,6 +1938,7 @@ async fn friction_rises_with_vigour_and_edging_chafes() {
             run.here.wifi_accepted = true;
             run.warmed_up = true;
             run.eq = 55;
+            run.foreskin = Some(0.5);
         });
         let uri = format!("/runs/cafebabe?technique=wet&intensity={intensity}");
         let jelq = send(&app, "JELQ", &uri, &spit, "").await;
@@ -1949,7 +1952,107 @@ async fn friction_rises_with_vigour_and_edging_chafes() {
         run.here.wifi_accepted = true;
         run.warmed_up = true;
         run.eq = 55;
+        run.foreskin = Some(0.5);
     });
     let edge = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
     assert_eq!(header(&edge, "x-friction"), "2/10");
 }
+
+#[tokio::test]
+async fn the_body_changes_how_the_skin_takes_it() {
+    let spit = [("content-type", "text/plain; charset=spit")];
+    for (foreskin, girth, friction) in [(0.5, 4.5, "1/10"), (1.2, 4.5, "0/10"), (0.5, 5.8, "2/10")]
+    {
+        let app = seeded_with(Floor::Hotel, |run| {
+            run.here.wifi_accepted = true;
+            run.warmed_up = true;
+            run.eq = 55;
+            run.foreskin = Some(foreskin);
+            run.girth = girth;
+        });
+        let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=wet", &spit, "").await;
+        assert_eq!(header(&jelq, "x-friction"), friction, "{foreskin} {girth}");
+    }
+}
+
+#[tokio::test]
+async fn a_thick_girth_outgrows_the_underhand_grip() {
+    let app = seeded_with(Floor::Bedroom, |run| run.girth = 5.8);
+    let grip = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/grip",
+        &[("upgrade", "underhand"), ("connection", "upgrade")],
+        "",
+    )
+    .await;
+    assert_eq!(grip.status(), StatusCode::PAYLOAD_TOO_LARGE);
+}
+
+#[tokio::test]
+async fn respectable_girth_waves_off_the_gym_staff() {
+    for (girth, status) in [
+        (4.5, StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS),
+        (5.2, StatusCode::OK),
+    ] {
+        let app = seeded_with(Floor::ChangingRoom, |run| {
+            run.warmed_up = true;
+            run.eq = 45;
+            run.girth = girth;
+            run.suspicion = SUSPICION_LIMIT;
+        });
+        let edge = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
+        if girth > 5.0 {
+            assert_ne!(edge.status(), StatusCode::UNAVAILABLE_FOR_LEGAL_REASONS);
+            assert!(header(&edge, "warning").contains("gym staff"));
+        } else {
+            assert_eq!(edge.status(), status);
+        }
+    }
+}
+
+#[tokio::test]
+async fn kev_is_the_bar_in_the_changing_room() {
+    for (length, shamed) in [(5.0, true), (7.0, false)] {
+        let app = seeded_with(Floor::Bathroom, |run| {
+            run.length = length;
+            run.here.turns = 6;
+        });
+        let left = send(&app, "POST", "/runs/cafebabe/floor", &[], "").await;
+        assert_eq!(header(&left, "x-floor"), "3");
+        let warning = left
+            .headers()
+            .get("warning")
+            .map(|w| w.to_str().unwrap().to_owned());
+        assert_eq!(
+            warning.is_some_and(|w| w.contains("Kev")),
+            shamed,
+            "length {length}"
+        );
+    }
+}
+
+#[tokio::test]
+async fn the_forum_respects_volume() {
+    let state = Arc::new(AppState::default());
+    for (id, length, girth) in [("slim", 7.0, 4.0), ("stout", 5.0, 5.5)] {
+        let mut run = Run::new(id.into(), id.into(), 1);
+        run.length = length;
+        run.girth = girth;
+        state.insert(run);
+    }
+    let app = router(state);
+    let board = json(
+        send(
+            &app,
+            "GET",
+            "/leaderboard?sort=volume&seeded=include",
+            &[],
+            "",
+        )
+        .await,
+    )
+    .await;
+    assert_eq!(board["entries"][0]["public_id"], "stout");
+    assert!(board["entries"][0]["volume"].as_f64().unwrap() > 0.0);
+}

jelq

Commit 058650ec79d6

Commit `058650ec79d6`