jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

26 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `d46f9d0b953a`

tarball

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

8 files changed+149-15

http: keep story choices reachable and handle inch ranges

Story::Pending hid the JELQ action that exposed the turn 10 choices, leaving the UI without a way forward. Malformed inch ranges must be ignored under RFC 9110, while valid ranges beyond the available length require 416. Door locks and the Do Not Disturb sign previously consumed encounters without telling the player.

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

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

6262 .header(

6363 header::LINK,

6464 format!(

-                "<{forum}>; rel=\"alternate\"; title=\"Read the forum\", <{close}>; rel=\"alternate\"; title=\"Close the tab\""

+                "<{forum}>; rel=\"alternate\"; title=\"Read the forum\"; allow=\"POST\", <{close}>; rel=\"alternate\"; title=\"Close the tab\"; allow=\"POST\""

6666 ),

6767 )

6868 }

Modified file: src/game/hazards.rs+2 additions@@ -109,6 +109,7 @@ impl Run {
                 self.touch();
                 if self.items.door_locks > 0 {
                     self.items.door_locks -= 1;
+                    self.notices.push("the flatmate tried the door");
                     return Ok(());
                 }
                 self.here.flatmate_told = true;
@@ -132,6 +133,7 @@ impl Run {
                 self.suspicion = 0;
                 self.touch();
                 if self.items.dnd_sign {
+                    self.notices.push("housekeeping read the sign");
                     return Ok(());
                 }
                 self.shame += 3;

Modified file: src/game/mod.rs+2 additions@@ -73,6 +73,7 @@ pub struct Run {
     pub refractory: Duration,
     pub refractory_until: Option<Instant>,
     pub pending: Vec<Pending>,
+    pub notices: Vec<&'static str>,
     pub ended: Option<Ending>,
     pub last_seen: Instant,
     rng: StdRng,
@@ -149,6 +150,7 @@ impl Run {
             story: Story::Unopened,
             mum: None,
             heard: Vec::new(),
+            notices: Vec::new(),
             elder: Elder::Unverified { strikes: 0 },
             clinic: Clinic::default(),
             seeded: false,

Modified file: src/game/turn.rs−1

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

241241 pub fn techniques_now(&self, now: Instant) -> Vec<Technique> {

242242 let blocked = !self.floor.timed()

243243 || self.items.cage

244- || self.story == Story::Pending

245244 || self.refractory_until.is_some_and(|until| now < until);

246245 if blocked {

247246 return Vec::new();

Modified file: src/http/run.rs+14 additions−2 deletions@@ -11,7 +11,7 @@ use tokio::io::AsyncWriteExt;
 
 use super::{AppState, ctx::Ctx, meta, middleware::Compress, resource::Resource, runs};
 use crate::{
-    game::{Elder, FORUM_THREAD, Floor, Run, balance::SUSPICION_LIMIT},
+    game::{Elder, FORUM_THREAD, Floor, Run, Story, balance::SUSPICION_LIMIT},
     headers::{
         X_CASH, X_EQ, X_FLOOR, X_FORESKIN, X_GIRTH, X_LENGTH, X_OBSERVED_BY,
         X_SELF_REPORTED_LENGTH, X_SHAME, X_STAMINA, X_SUSPICION,
@@ -137,6 +137,15 @@ fn links(run: &Run, now: Instant) -> String {
                 )
             }),
         )
+        .chain((run.story == Story::Pending).then(|| {
+            let choice = |slug: &str, title: &str| {
+                format!(
+                    "<{}>; rel=\"{REL_BASE}branch\"; title=\"{title}\"; allow=\"POST\"",
+                    run.path(&format!("/branches/{slug}"))
+                )
+            };
+            [choice("forum", "Read the forum"), choice("close-tab", "Close the tab")].join(", ")
+        }))
         .chain(run.techniques_now(now).into_iter().map(|technique| {
             let name = technique.name();
             let lubricant = technique
@@ -172,7 +181,7 @@ pub fn finish(run: &mut Run, ctx: &Ctx, secret: &Secret, mut response: Response)
     let shame = settle_shame(run, ctx, secret);
     let mut stats: Vec<(HeaderName, String)> = vec![
         if run.items.ruler {
-            (X_LENGTH, format!("{:.2}", run.length))
+            (X_LENGTH, format!("{:.2}", run.current_length()))
         } else {
             (
                 X_SELF_REPORTED_LENGTH,
@@ -203,6 +212,9 @@ pub fn finish(run: &mut Run, ctx: &Ctx, secret: &Secret, mut response: Response)
     if run.conditions.pulled_muscle {
         stats.push((header::WARNING, "199 - \"a muscle has been pulled\"".into()));
     }
+    for notice in run.notices.drain(..) {
+        stats.push((header::WARNING, format!("199 - \"{notice}\"")));
+    }
     if run.eq > 70 && run.ended.is_none() {
         stats.push((header::WARNING, "199 - \"it is turning purple\"".into()));
     }

Modified file: src/http/runs.rs+32 additions−9 deletions@@ -229,14 +229,36 @@ fn millimetres(inches: f64) -> usize {
     (inches * MM_PER_INCH).round() as usize
 }
 
-fn parse_inch_range(range: &str, total: f64) -> Option<(f64, f64)> {
+enum InchRange {
+    Satisfiable(f64, f64),
+    Unsatisfiable,
+}
+
+/// `None` means the header is not a valid range, which RFC 9110 §14.2 says to ignore rather than refuse.
+fn parse_inch_range(range: &str, total: f64) -> Option<InchRange> {
     let (start, end) = range.strip_prefix("inches=")?.split_once('-')?;
-    let start: f64 = start.trim().parse().ok()?;
-    let end: f64 = match end.trim() {
-        "" => total,
-        end => end.parse().ok()?,
+    let number = |text: &str| {
+        text.parse::<f64>()
+            .ok()
+            .filter(|n| n.is_finite() && *n >= 0.0)
     };
-    (start >= 0.0 && start < total && start <= end).then_some((start, end.min(total)))
+    let (start, end) = match (start.trim(), end.trim()) {
+        ("", "") => return None,
+        ("", suffix) => ((total - number(suffix)?).max(0.0), total),
+        (start, "") => (number(start)?, total),
+        (start, end) => {
+            let (start, end) = (number(start)?, number(end)?);
+            if start > end {
+                return None;
+            }
+            (start, end)
+        }
+    };
+    Some(if start < total {
+        InchRange::Satisfiable(start, end.min(total))
+    } else {
+        InchRange::Unsatisfiable
+    })
 }
 
 fn get_length(run: &mut Run, ctx: &Ctx) -> Response {
@@ -252,10 +274,11 @@ fn get_length(run: &mut Run, ctx: &Ctx) -> Response {
     );
     let accept_ranges = (header::ACCEPT_RANGES, "inches".to_owned());
 
-    if let Some(range) = ctx.header(header::RANGE)
-        && range.starts_with("inches=")
+    if let Some(range) = ctx
+        .header(header::RANGE)
+        .and_then(|range| parse_inch_range(range, inches))
     {
-        let Some((start, end)) = parse_inch_range(range, inches) else {
+        let InchRange::Satisfiable(start, end) = range else {
             return Problem::new(
                 StatusCode::RANGE_NOT_SATISFIABLE,
                 "range-not-satisfiable",

Modified file: src/tests.rs+97 additions−1 deletions@@ -11,7 +11,7 @@ use tower::ServiceExt;
 
 use crate::{
     AppState, Config,
-    game::{Floor, MumVisit, Run},
+    game::{Floor, MumVisit, Run, Story, balance::SUSPICION_LIMIT},
     router,
 };
 
@@ -248,6 +248,43 @@ async fn length_supports_inch_ranges() {
     )
     .await;
     assert_eq!(absurd.status(), StatusCode::RANGE_NOT_SATISFIABLE);
+    let malformed = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/length",
+        &[("range", "inches=6.17")],
+        "",
+    )
+    .await;
+    assert_eq!(malformed.status(), StatusCode::OK);
+    let suffix = send(
+        &app,
+        "GET",
+        "/runs/cafebabe/length",
+        &[("range", "inches=-1")],
+        "",
+    )
+    .await;
+    assert_eq!(suffix.status(), StatusCode::PARTIAL_CONTENT);
+    assert!(text(suffix).await.ends_with('D'));
+    for (range, status) in [
+        ("inches=1-", StatusCode::PARTIAL_CONTENT),
+        ("inches=40-", StatusCode::RANGE_NOT_SATISFIABLE),
+        ("inches=-0", StatusCode::RANGE_NOT_SATISFIABLE),
+        ("inches=2-1", StatusCode::OK),
+        ("inches=NaN-2", StatusCode::OK),
+        ("inches=0-inf", StatusCode::OK),
+    ] {
+        let response = send(
+            &app,
+            "GET",
+            "/runs/cafebabe/length",
+            &[("range", range)],
+            "",
+        )
+        .await;
+        assert_eq!(response.status(), status, "{range}");
+    }
 }
 
 #[tokio::test]
@@ -837,3 +874,62 @@ async fn the_ruler_replaces_the_self_report() {
     assert!(!after.headers().contains_key("x-self-reported-length"));
     assert!(after.headers().contains_key("x-length"));
 }
+
+#[tokio::test]
+async fn an_open_tab_is_linked_and_jelq_still_answers_with_choices() {
+    let app = seeded_with(Floor::Bathroom, |run| {
+        run.story = Story::Pending;
+        run.warmed_up = true;
+    });
+    let response = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    let links = header(&response, "link");
+    assert!(links.contains("/branches/forum>; rel=\"https://jelq.dev/rels/branch\""));
+    assert!(links.contains("/branches/close-tab>; rel=\"https://jelq.dev/rels/branch\""));
+    assert!(links.contains("?technique=wet>"));
+    let jelq = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
+    assert_eq!(jelq.status(), StatusCode::MULTIPLE_CHOICES);
+}
+
+#[tokio::test]
+async fn either_story_choice_is_reachable_during_cooldown() {
+    for choice in ["forum", "close-tab"] {
+        let app = seeded_with(Floor::Bathroom, |run| {
+            run.turn = 9;
+            run.warmed_up = true;
+            run.stamina = 1;
+            run.items.door_locks = 1;
+        });
+        let tenth = send(&app, "JELQ", "/runs/cafebabe?technique=edge", &[], "").await;
+        assert_eq!(tenth.status(), StatusCode::OK);
+        let response = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+        assert!(!header(&response, "link").contains("?technique="));
+        let path = format!("/runs/cafebabe/branches/{choice}");
+        assert!(
+            header(&response, "link")
+                .contains(&format!("<{path}>; rel=\"https://jelq.dev/rels/branch\""))
+        );
+        let chosen = send(&app, "POST", &path, &[], "").await;
+        assert_eq!(chosen.status(), StatusCode::SEE_OTHER);
+        assert!(!header(&chosen, "link").contains("/branches/"));
+        let repeated = send(&app, "POST", &path, &[], "").await;
+        assert_eq!(repeated.status(), StatusCode::CONFLICT);
+    }
+}
+
+#[tokio::test]
+async fn a_door_lock_says_when_it_was_used() {
+    let app = seeded_with(Floor::Bathroom, |run| {
+        run.items.door_locks = 1;
+        run.suspicion = SUSPICION_LIMIT;
+        run.warmed_up = true;
+    });
+    let response = send(&app, "JELQ", "/runs/cafebabe?technique=dry", &[], "").await;
+    assert_ne!(response.status(), StatusCode::CONFLICT);
+    assert!(
+        response
+            .headers()
+            .get_all("warning")
+            .iter()
+            .any(|w| w.to_str().unwrap().contains("the flatmate tried the door"))
+    );
+}

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

@@ -314,7 +314,7 @@ function parseLinks(header) {

314314 continue;

315315 }

316316 const methods = (params.allow || "GET").split(",").map(s => s.trim());

317- resources.push({ key: name, group: GROUP_OF[name] || "play", name: NAMES[name] || name, path: match[1], methods });

317

+    resources.push({ key: name, group: GROUP_OF[name] || "play", name: NAMES[name] || params.title || name, path: match[1], methods });

318318 }

319319 return [resources, moves];

320320 }

jelq

Commit d46f9d0b953a

Commit `d46f9d0b953a`