jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

53 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `a11497af08aa`

tarball

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

11 files changed+72-52

game: fold the re-read into the run's thread and let a drink end exhaustion

Re-reading lived at its own POST because the thread was a global stateless GET, so the run linked a re-read before anything had been read. The run now has one thread, GET /runs/{id}/thread, whose live reads do the teaching. An energy drink was refused with the 429 like everything else, so the refractory HOLD was the only way out even with a drink in hand.

Modified file: src/game/checks.rs+4 additions−1 deletions@@ -89,10 +89,13 @@ impl Run {
     }
 
     pub fn techniques_now(&self) -> impl Iterator<Item = Technique> + '_ {
-        let blocked = !self.floor.timed() || self.items.kit.cage || self.body.exhausted;
+        let blocked = !self.floor.timed() || self.items.kit.cage;
         Technique::ALL
             .into_iter()
             .filter(move |_| !blocked)
+            .filter(|&technique| {
+                !self.body.exhausted || technique == Technique::Utility(Utility::Energy)
+            })
             .filter(|&technique| match technique {
                 Technique::Utility(Utility::Warmup) => {
                     !self.here.towel_warmed || self.here.kitchen.kettle_boiled

Modified file: src/game/dispatch.rs+4 additions−2 deletions@@ -14,7 +14,9 @@ impl Run {
         intensity: i32,
         lube: Option<Lube>,
     ) -> Result<Outcome, Problem> {
-        self.check_exhausted()?;
+        if techniques != [Technique::Utility(Utility::Energy)] {
+            self.check_exhausted()?;
+        }
         if self.online.story == Story::Pending {
             return Ok(self.branch_offer());
         }
@@ -23,7 +25,7 @@ impl Run {
                 StatusCode::SEE_OTHER,
                 json!({ "detail": "Refer to the forum." }),
             )
-            .header(header::LOCATION, super::FORUM_THREAD));
+            .header(header::LOCATION, self.path("/thread")));
         }
         if self.items.kit.cage {
             return Err(Problem::new(

Modified file: src/game/forum.rs+14 additions−7 deletions@@ -26,8 +26,16 @@ date,length,girth,technique,notes,honest?
 2009-06-14,7.50,5.50,wet,progress is slow but real,no
 ";
 
+fn thread(detail: Option<&str>) -> Outcome {
+    let mut body = forum_thread();
+    if let Some(detail) = detail {
+        body["detail"] = json!(detail);
+    }
+    Outcome::json(StatusCode::OK, body).header(header::LAST_MODIFIED, ELDER_LAST_MODIFIED)
+}
+
 fn nothing_new() -> Outcome {
-    Outcome::empty(StatusCode::NOT_MODIFIED).header(
+    thread(None).header(
         header::WARNING,
         r#"199 - "Nothing new has been posted since 2009.""#,
     )
@@ -190,18 +198,18 @@ impl Run {
             return Err(Problem::new(
                 StatusCode::NOT_FOUND,
                 "no-thread",
-                "There is no thread to re-read. Nobody has mentioned a forum yet.",
+                "There is no thread. Nobody has mentioned a forum yet.",
             ));
         }
         self.end_kitchen_visit();
         if self.online.uli_taught {
-            return Ok(Outcome::json(StatusCode::OK, forum_thread()));
+            return Ok(thread(None));
         }
         if self.here.thread_rolls >= THREAD_READS {
             let age = SystemTime::now()
                 .duration_since(*ELDER_POSTED)
                 .map_or(0, |age| age.as_secs());
-            return Ok(Outcome::json(StatusCode::OK, forum_thread())
+            return Ok(thread(None)
                 .header(header::AGE, age.to_string())
                 .header(header::WARNING, r#"112 - "Disconnected operation""#));
         }
@@ -216,7 +224,7 @@ impl Run {
             if !self.chance(
                 self.decision(
                     "teach-uli",
-                    "Does this reread finally surface the 2009 reply that teaches uli?",
+                    "Does this read finally surface the 2009 reply that teaches uli?",
                 ),
                 ULI_ODDS,
             ) {
@@ -225,8 +233,7 @@ impl Run {
             self.online.uli_taught = true;
             "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."
         };
-        Ok(Outcome::json(StatusCode::OK, json!({ "detail": detail }))
-            .header(header::LOCATION, self.path("/techniques")))
+        Ok(thread(Some(detail)))
     }
 
     fn learn_meditation(&mut self) -> bool {

Modified file: src/game/travel.rs+1−1

@@ -121,7 +121,7 @@ impl Run {

121121 }

122122 Floor::Hotel => view["portal"] = json!(self.path("/portal")),

123123 Floor::Forum => {

124- view["thread"] = json!(super::FORUM_THREAD);

124+ view["thread"] = json!(self.path("/thread"));

125125 view["elder"] = json!(self.path("/elder"));

126126 }

127127 Floor::Clinic => view["diagnosis"] = json!(self.path("/diagnosis")),

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

@@ -103,6 +103,7 @@ impl Run {

103103 }

104104 self.items.stores.energy_drinks -= 1;

105105 self.step_away();

106+ self.body.exhausted = false;

106107 self.body.stamina = (self.body.stamina + ENERGY_STAMINA).min(self.max_stamina());

107108 self.touch();

108109 Ok(Outcome::json(

Modified file: src/http/links.rs+3 additions−13 deletions@@ -1,7 +1,7 @@
 use std::fmt::Write as _;
 
-use super::{meta, run::RunResource, runs};
-use crate::game::{Branch, FORUM_THREAD, Run, SHOP};
+use super::{run::RunResource, runs};
+use crate::game::{Branch, Run, SHOP};
 
 pub const REL_BASE: &str = "https://jelq.dev/rels/";
 
@@ -43,7 +43,7 @@ pub fn header(run: &Run) -> String {
         ("techniques", &runs::TECHNIQUES, true),
         ("drawer", &runs::DRAWER, reach.drawer),
         ("kitchen", &runs::KITCHEN, reach.kitchen),
-        ("re-read", &runs::REREAD, reach.thread),
+        ("thread", &runs::THREAD, reach.thread),
         ("grip", &runs::GRIP, true),
         ("shop", &runs::SHOP, reach.shop),
         ("portal", &runs::PORTAL, reach.portal),
@@ -66,16 +66,6 @@ pub fn header(run: &Run) -> String {
         }
         .write(&mut out);
     }
-    if reach.thread {
-        Link {
-            href: FORUM_THREAD,
-            rel: "thread",
-            allow: &meta::THREAD.allow_any(),
-            title: None,
-            lubricant: None,
-        }
-        .write(&mut out);
-    }
     if reach.branch_pending {
         for (branch, title) in [
             (Branch::Forum, "Read the forum"),

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

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

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

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

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

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

149+ .route("/runs/{id}/thread", scoped(&runs::THREAD))

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

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

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

Modified file: src/http/resource.rs−5 deletions@@ -84,11 +84,6 @@ impl<T> Resource<T> {
         Self::listed(self.verbs.iter().filter(|verb| verb.available(target)))
     }
 
-    /// The methods with every guard assumed open, for resources that have none.
-    pub fn allow_any(&self) -> String {
-        Self::listed(self.verbs.iter())
-    }
-
     fn listed<'a>(verbs: impl Iterator<Item = &'a Verb<T>>) -> String {
         let mut methods = Vec::new();
         for verb in verbs {

Modified file: src/http/runs.rs+2 additions−2 deletions@@ -71,7 +71,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 THREAD: RunResource = pockets(&[Verb::new("GET", get_thread)]);
 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)]);
@@ -229,7 +229,7 @@ fn commit_melon(run: &mut Run, _: &Ctx) -> Response {
     respond(run.commit_melon())
 }
 
-fn re_read(run: &mut Run, _: &Ctx) -> Response {
+fn get_thread(run: &mut Run, _: &Ctx) -> Response {
     respond(run.read_thread())
 }
 

Modified file: src/tests/floors.rs+19 additions−20 deletions@@ -169,7 +169,7 @@ async fn the_thread_announces_itself_at_the_branch() {
     )
     .await;
     let ninth = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(!header(&ninth, "link").contains("/forum/threads/2009"));
+    assert!(!header(&ninth, "link").contains("/cafebabe/thread>"));
     let tenth = send(
         &app,
         "JELQ",
@@ -185,13 +185,13 @@ async fn the_thread_announces_itself_at_the_branch() {
             .iter()
             .any(|w| w.to_str().unwrap().contains("a forum thread from 2009"))
     );
-    assert!(header(&tenth, "link").contains("/forum/threads/2009"));
+    assert!(header(&tenth, "link").contains("/cafebabe/thread>"));
     let announced = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(header(&announced, "link").contains("/forum/threads/2009"));
+    assert!(header(&announced, "link").contains("/cafebabe/thread>"));
 }
 
 #[tokio::test]
-async fn rereading_the_thread_teaches_uli() {
+async fn reading_the_thread_teaches_uli() {
     let mut taught_runs = 0;
     for seed in 0..100u64 {
         let app = app_with(Floor::Bedroom, seed, |run| {
@@ -202,18 +202,17 @@ async fn rereading_the_thread_teaches_uli() {
         });
         let mut taught = false;
         for _ in 0..2 {
-            let read = send(&app, "POST", "/runs/cafebabe/re-read", &[], "").await;
-            match read.status() {
-                StatusCode::NOT_MODIFIED => {
-                    assert!(header(&read, "warning").contains("2009"));
-                }
-                StatusCode::OK => {
-                    assert!(header(&read, "location").contains("/techniques"));
-                    taught = true;
-                    break;
-                }
-                other => panic!("seed {seed} read the thread into {other}"),
+            let read = send(&app, "GET", "/runs/cafebabe/thread", &[], "").await;
+            assert_eq!(read.status(), StatusCode::OK, "seed {seed}");
+            let warned = warnings(&read).iter().any(|w| w.contains("2009"));
+            let body = json(read).await;
+            assert!(body["posts"].is_array(), "a read always shows the thread");
+            if body["detail"].is_string() {
+                assert!(!warned);
+                taught = true;
+                break;
             }
+            assert!(warned);
         }
         let state = send(&app, "GET", "/runs/cafebabe", &[], "").await;
         assert_eq!(header(&state, "x-stamina"), "10/10", "reading is free");
@@ -222,7 +221,7 @@ async fn rereading_the_thread_teaches_uli() {
             let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=uli", &[], "").await;
             assert_ne!(jelq.status(), StatusCode::FORBIDDEN);
         } else {
-            let cached = send(&app, "POST", "/runs/cafebabe/re-read", &[], "").await;
+            let cached = send(&app, "GET", "/runs/cafebabe/thread", &[], "").await;
             assert_eq!(cached.status(), StatusCode::OK);
             assert!(header(&cached, "warning").starts_with("112"));
             assert!(header(&cached, "age").parse::<u64>().unwrap() > 0);
@@ -235,12 +234,12 @@ async fn rereading_the_thread_teaches_uli() {
 }
 
 #[tokio::test]
-async fn the_thread_cannot_be_reread_before_anyone_mentions_it() {
+async fn the_thread_cannot_be_read_before_anyone_mentions_it() {
     let app = seeded_with(Floor::Bedroom, |run| run.body.warmed_up = true);
-    let read = send(&app, "POST", "/runs/cafebabe/re-read", &[], "").await;
+    let read = send(&app, "GET", "/runs/cafebabe/thread", &[], "").await;
     assert_eq!(read.status(), StatusCode::NOT_FOUND);
     let after = send(&app, "GET", "/runs/cafebabe", &[], "").await;
-    assert!(!header(&after, "link").contains("/re-read"));
+    assert!(!header(&after, "link").contains("/thread"));
 }
 
 #[tokio::test]
@@ -475,7 +474,7 @@ async fn the_forum_teaches_breathing_before_uli() {
         assert_eq!(meditate["locked"], true);
         send(&app, "POST", "/runs/cafebabe/branches/forum", &[], "").await;
         for _ in 0..2 {
-            send(&app, "POST", "/runs/cafebabe/re-read", &[], "").await;
+            send(&app, "GET", "/runs/cafebabe/thread", &[], "").await;
         }
         let meditated = send(&app, "JELQ", "/runs/cafebabe?technique=meditate", &[], "").await;
         if meditated.status() == StatusCode::OK {

Modified file: src/tests/turns.rs+23 additions@@ -251,3 +251,26 @@ async fn queued_gains_announce_their_arrival() {
     let later = send(&app, "GET", "/runs/cafebabe", &[], "").await;
     assert!(later.headers().get("x-gains-arrived").is_none());
 }
+
+#[tokio::test]
+async fn an_energy_drink_ends_exhaustion_without_the_refractory_period() {
+    let app = seeded_with(Floor::Bedroom, |run| {
+        run.body.warmed_up = true;
+        run.body.eq = 60;
+        run.body.stamina = 0;
+        run.body.exhausted = true;
+        run.items.stores.energy_drinks = 1;
+    });
+    let tired = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert_eq!(advertised(&tired), ["energy"]);
+    let drink = send(&app, "JELQ", "/runs/cafebabe?technique=energy", &[], "").await;
+    assert_eq!(drink.status(), StatusCode::OK);
+    assert_eq!(header(&drink, "x-stamina"), "3/10");
+    assert_eq!(
+        header(&drink, "x-eq"),
+        "60",
+        "still warm, unlike the refractory HOLD"
+    );
+    let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
+    assert_ne!(jelq.status(), StatusCode::TOO_MANY_REQUESTS);
+}

jelq

Commit a11497af08aa

Commit `a11497af08aa`