jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

63 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `f48daa8adf59`

tarball

atagen <boss@atagen.co>2026-10-13 12:53 UTC

4 files changed+62-11

game: make the refractory period give back only part of the stamina

A refractory HOLD refilled stamina to full, which made running dry nearly free. It now returns 4 to 6, with a 1 in 20 second wind that still fills it.

Modified file: src/game/balance/stamina.rs+2

@@ -2,3 +2,5 @@ pub const MAX_STAMINA: i32 = 10;

22 pub const PULLED_STAMINA: i32 = 7;

33 pub const EDGE_LOOP: u8 = 3;

44 pub const ENERGY_STAMINA: i32 = 3;

5+pub const REFRACTORY_STAMINA: (i32, i32) = (4, 6);

6+pub const SECOND_WIND: u32 = 20;

Modified file: src/game/rest.rs+13 additions−5 deletions@@ -33,15 +33,23 @@ impl Run {
             return Err(self.rupture());
         }
         if self.body.exhausted {
-            self.recover();
+            let second_wind = self.recover();
             self.shed(FRICTION_HOLD);
             self.settle();
-            let detail = if self.body.conditions.priapism_turns > 0 {
-                "The count went well past ten. Stamina is back. It went down a little. Maybe. You hope."
+            let back = if second_wind {
+                "The count went well past ten, and something came back that had no business coming back. Stamina is full."
             } else {
-                "The count went well past ten. Stamina is back. Everything else has gone quiet, and you are cold again."
+                "The count went well past ten. Some of the stamina is back."
             };
-            return Ok(Outcome::json(StatusCode::OK, json!({ "detail": detail })));
+            let after = if self.body.conditions.priapism_turns > 0 {
+                "It went down a little. Maybe. You hope."
+            } else {
+                "Everything else has gone quiet, and you are cold again."
+            };
+            return Ok(Outcome::json(
+                StatusCode::OK,
+                json!({ "detail": format!("{back} {after}") }),
+            ));
         }
         if self.chance(
             self.decision(

Modified file: src/game/run.rs+26 additions−5 deletions@@ -10,8 +10,8 @@ use super::{
     Body, Cause, Clinic, Ending, Floor, FloorState, Household, Item, Items, Notice, Observer,
     Online, RunStatus, Standing, Story,
     balance::{
-        BRANCH_TURN, FLOOR_LIMIT, MAX_STAMINA, PRIAPISM_EQ, PULLED_STAMINA, SELF_REPORT_INFLATION,
-        STARTING_BABY_OIL, STARTING_EQ, STARTING_LUBE,
+        BRANCH_TURN, FLOOR_LIMIT, MAX_STAMINA, PRIAPISM_EQ, PULLED_STAMINA, REFRACTORY_STAMINA,
+        SECOND_WIND, SELF_REPORT_INFLATION, STARTING_BABY_OIL, STARTING_EQ, STARTING_LUBE,
     },
     measure::round2,
     oracle::{Oracle, OracleTemplate, Roll},
@@ -334,11 +334,32 @@ impl Run {
         cause.problem().with("turn", self.turn)
     }
 
-    /// The refractory period is the next HOLD. It comes back with full stamina and nothing else.
-    pub(super) fn recover(&mut self) {
+    /// The refractory period is the next HOLD. Returns whether it rolled the second wind that refills stamina outright.
+    pub(super) fn recover(&mut self) -> bool {
         self.body.exhausted = false;
-        self.body.stamina = self.max_stamina();
+        let second_wind = self.chance(
+            self.decision(
+                "second-wind",
+                "Does the refractory period end in a second wind?",
+            ),
+            SECOND_WIND,
+        );
+        self.body.stamina = if second_wind {
+            self.max_stamina()
+        } else {
+            let (lo, hi) = REFRACTORY_STAMINA;
+            let back = self.oracle.span_int(
+                self.decision(
+                    "refractory",
+                    "How much stamina comes back after the refractory period?",
+                ),
+                lo,
+                hi,
+            );
+            back.min(self.max_stamina())
+        };
         self.reset_eq(STARTING_EQ);
+        second_wind
     }
 
     pub(super) fn check_exhausted(&self) -> Result<(), Problem> {

Modified file: src/tests/turns.rs+21 additions−1 deletions@@ -78,7 +78,7 @@ async fn the_refractory_period_is_the_next_hold() {
     assert_eq!(tired.status(), StatusCode::TOO_MANY_REQUESTS);
     let hold = send(&app, "HOLD", "/runs/cafebabe", &[], "").await;
     assert_eq!(hold.status(), StatusCode::OK);
-    assert_eq!(header(&hold, "x-stamina"), "10/10");
+    assert!(["4/10", "5/10", "6/10", "10/10"].contains(&header(&hold, "x-stamina")));
     let towel = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
     assert_eq!(towel.status(), StatusCode::CONFLICT, "the towel stays cold");
 }
@@ -402,3 +402,23 @@ async fn an_overstayed_jelq_spends_no_lube() {
         );
     }
 }
+
+#[tokio::test]
+async fn the_refractory_period_gives_back_some_stamina_and_rarely_all() {
+    let mut full = 0;
+    for seed in 0..400u64 {
+        let mut run = Run::new("cafebabe".into(), "cafe".into(), seed);
+        run.floor = Floor::ChangingRoom;
+        run.body.stamina = 0;
+        run.body.exhausted = true;
+        if run.hold().is_err() {
+            continue;
+        }
+        match run.body.stamina {
+            4..=6 => {}
+            10 => full += 1,
+            other => panic!("seed {seed} recovered {other} stamina"),
+        }
+    }
+    assert!((8..=35).contains(&full), "{full} second winds in 400");
+}

jelq

Commit f48daa8adf59

Commit `f48daa8adf59`