jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

85 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `4f54028cba69`

tarball

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

23 files changed+380-276

game: give repeated text and tables a single home on the types they describe

Branch titles were spelled out three times, every 300 hand-wrote its Link header, the kitchen kept its loot text twice by index, and Link headers were formatted by hand in four places beside the one writer. The page's DEATHS list had already drifted from Cause and missed the abandoned and lost endings, so it now trusts X-Run-Over instead.

Modified file: src/game/checks.rs+17 additions−2 deletions@@ -1,5 +1,5 @@
 use super::{
-    LUBRICANTS, Lube, Run, Technique,
+    Lube, Run, Technique,
     balance::STORAGE_BULK,
     lube::LubeRule,
     techniques::{Training, Utility},
@@ -8,7 +8,22 @@ use crate::problem::Problem;
 use axum::http::{StatusCode, header};
 use serde_json::json;
 
+pub(super) fn caged() -> Problem {
+    Problem::new(
+        StatusCode::LOCKED,
+        "caged",
+        "The cage is locked. The key is not in the box.",
+    )
+}
+
 impl Run {
+    pub(super) fn check_cage(&self) -> Result<(), Problem> {
+        if self.items.kit.cage {
+            return Err(caged());
+        }
+        Ok(())
+    }
+
     pub(super) fn ready(&self, technique: Technique, lube: Option<Lube>) -> Result<(), Problem> {
         self.access(technique)?;
         match technique {
@@ -52,7 +67,7 @@ impl Run {
                     training.name()
                 ),
             )
-            .with("lubricants", json!(LUBRICANTS))),
+            .with("lubricants", json!(Lube::content_types()))),
             (LubeRule::Forbidden, Some(_)) => Err(Problem::new(
                 StatusCode::UNSUPPORTED_MEDIA_TYPE,
                 "lubricant-declared",

Modified file: src/game/dispatch.rs+1 additions−7 deletions@@ -27,13 +27,7 @@ impl Run {
             )
             .header(header::LOCATION, self.path("/thread")));
         }
-        if self.items.kit.cage {
-            return Err(Problem::new(
-                StatusCode::LOCKED,
-                "caged",
-                "The cage is locked. The key is not in the box.",
-            ));
-        }
+        self.check_cage()?;
         match *techniques {
             [Technique::Utility(utility)] => self.utility(utility, lube),
             [Technique::Training(training)] => self.single(training, intensity, lube),

Modified file: src/game/drawer.rs+2 additions−4 deletions@@ -14,10 +14,8 @@ fn nothing() -> Result<Outcome, Problem> {
 
 impl Run {
     pub(super) fn found(&self, item: Item, detail: &str) -> Outcome {
-        Outcome::json(StatusCode::FOUND, json!({ "detail": detail })).header(
-            header::LOCATION,
-            self.path(&format!("/inventory/{}", item.slug())),
-        )
+        Outcome::json(StatusCode::FOUND, json!({ "detail": detail }))
+            .header(header::LOCATION, self.item_path(item))
     }
 
     pub fn search_drawer(&mut self) -> Result<Outcome, Problem> {

Modified file: src/game/forum.rs+19 additions−19 deletions@@ -4,7 +4,7 @@ use axum::http::{StatusCode, header};
 use serde_json::{Value, json};
 
 use super::{
-    Cause, Floor, Item, Outcome, Run,
+    Cause, Choice, Floor, Item, Outcome, Run,
     balance::{
         EXAGGERATION, MEDITATION_ODDS, PATIENCE, PRINTABLE_RULER, RULER_SHAME, THREAD_READS,
         ULI_ODDS,
@@ -82,19 +82,28 @@ pub enum Branch {
 }
 
 impl Branch {
+    pub const ALL: [Self; 2] = [Self::Forum, Self::CloseTab];
+
     pub fn slug(self) -> &'static str {
         match self {
             Self::Forum => "forum",
             Self::CloseTab => "close-tab",
         }
     }
+
+    pub fn title(self) -> &'static str {
+        match self {
+            Self::Forum => "read the forum",
+            Self::CloseTab => "close the tab",
+        }
+    }
 }
 
 impl std::str::FromStr for Branch {
     type Err = ();
 
     fn from_str(slug: &str) -> Result<Self, ()> {
-        [Self::Forum, Self::CloseTab]
+        Self::ALL
             .into_iter()
             .find(|branch| branch.slug() == slug)
             .ok_or(())
@@ -131,23 +140,14 @@ impl Default for Online {
 
 impl Run {
     pub(super) fn branch_offer(&self) -> Outcome {
-        let forum = self.path(&format!("/branches/{}", Branch::Forum.slug()));
-        let close = self.path(&format!("/branches/{}", Branch::CloseTab.slug()));
-        Outcome::json(
-            StatusCode::MULTIPLE_CHOICES,
-            json!({
-                "detail": "A browser tab is open. It has been open for some time.",
-                "choices": [
-                    { "href": forum, "method": "POST", "title": "Read the forum" },
-                    { "href": close, "method": "POST", "title": "Close the tab" },
-                ],
-            }),
-        )
-        .header(
-            header::LINK,
-            format!(
-                "<{forum}>; rel=\"alternate\"; title=\"Read the forum\"; allow=\"POST\", <{close}>; rel=\"alternate\"; title=\"Close the tab\"; allow=\"POST\""
-            ),
+        let choices = Branch::ALL.map(|branch| Choice {
+            href: self.branch_path(branch),
+            method: "POST",
+            title: branch.title(),
+        });
+        Outcome::choices(
+            "A browser tab is open. It has been open for some time.",
+            &choices,
         )
     }
 

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

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

178178 .map(|item| {

179179 json!({

180180 "name": item.slug(),

181- "href": self.path(&format!("/inventory/{}", item.slug())),

181+ "href": self.item_path(item),

182182 })

183183 })

184184 .collect();

Modified file: src/game/kitchen.rs+69 additions−53 deletions@@ -1,8 +1,8 @@
-use axum::http::{StatusCode, header};
+use axum::http::StatusCode;
 use serde_json::json;
 
 use super::{
-    Cause, Floor, Item, Notice, Outcome, Run, Story,
+    Cause, Choice, Floor, Item, Notice, Outcome, Run, Story,
     balance::{
         CAUGHT_MELONED, COCONUT_ODDS, ENERGY_ODDS, KETTLE_ODDS, KITCHEN_ICE_ODDS, KITCHEN_TOLD,
         MELON_SHAME, RAID_NOISE, RUPTURE_LINE, WATERMELON,
@@ -10,6 +10,46 @@ use super::{
 };
 use crate::problem::Problem;
 
+#[derive(Clone, Copy)]
+enum Loot {
+    CoconutOil,
+    EnergyDrink,
+    IcePack,
+    Kettle,
+    Nothing,
+}
+
+impl Loot {
+    const ALL: [Self; 5] = [
+        Self::CoconutOil,
+        Self::EnergyDrink,
+        Self::IcePack,
+        Self::Kettle,
+        Self::Nothing,
+    ];
+
+    /// Out of 120, so one draw keeps the marginals at the documented 1 in 3, 1 in 5, 1 in 8 and 1 in 6.
+    fn weight(self) -> u32 {
+        match self {
+            Self::CoconutOil => 120 / COCONUT_ODDS,
+            Self::EnergyDrink => 120 / ENERGY_ODDS,
+            Self::IcePack => 120 / KITCHEN_ICE_ODDS,
+            Self::Kettle => 120 / KETTLE_ODDS,
+            Self::Nothing => 120 - Self::ALL[..4].iter().map(|l| l.weight()).sum::<u32>(),
+        }
+    }
+
+    fn sight(self) -> &'static str {
+        match self {
+            Self::CoconutOil => "A jar of coconut oil, half of it already gone.",
+            Self::EnergyDrink => "An energy drink, cold and faintly alarming.",
+            Self::IcePack => "An ice pack, buried under the peas.",
+            Self::Kettle => "The kettle has just boiled.",
+            Self::Nothing => "Nothing. The fridge is ordinary.",
+        }
+    }
+}
+
 impl Run {
     /// The household keeps count, so every raid makes noise and the noise makes the next telling likelier.
     pub fn raid_kitchen(&mut self) -> Result<Outcome, Problem> {
@@ -34,27 +74,11 @@ impl Run {
             return Err(self.rupture());
         }
         self.make_noise(RAID_NOISE);
-        // One draw of 120 keeps the marginals at the documented 1 in 3, 1 in 5, 1 in 8 and 1 in 6.
-        let loot = self.oracle.pick(
+        let loot = Loot::ALL[self.oracle.pick(
             self.decision("loot", "What does the fridge give up on this raid?"),
-            &[
-                120 / COCONUT_ODDS,
-                120 / ENERGY_ODDS,
-                120 / KITCHEN_ICE_ODDS,
-                120 / KETTLE_ODDS,
-                120 - (120 / COCONUT_ODDS
-                    + 120 / ENERGY_ODDS
-                    + 120 / KITCHEN_ICE_ODDS
-                    + 120 / KETTLE_ODDS),
-            ],
-            &[
-                "A jar of coconut oil, half of it already gone.",
-                "An energy drink, cold and faintly alarming.",
-                "An ice pack, buried under the peas.",
-                "The kettle has just boiled.",
-                "Nothing. The fridge is ordinary.",
-            ],
-        );
+            &Loot::ALL.map(Loot::weight),
+            &Loot::ALL.map(Loot::sight),
+        )];
         let melon = self.body.eq > RUPTURE_LINE
             && self.oracle.ratio(
                 self.decision(
@@ -97,47 +121,39 @@ impl Run {
         )
     }
 
-    fn unpack(&mut self, loot: usize) -> Outcome {
-        let (item, detail) = match loot {
-            0 => (
-                Item::CoconutOil,
-                "A jar of coconut oil, half of it already gone.",
-            ),
-            1 => (
-                Item::EnergyDrink,
-                "An energy drink, cold and faintly alarming.",
-            ),
-            2 => (Item::IcePack, "An ice pack, buried under the peas."),
-            3 => {
+    fn unpack(&mut self, loot: Loot) -> Outcome {
+        let item = match loot {
+            Loot::CoconutOil => Item::CoconutOil,
+            Loot::EnergyDrink => Item::EnergyDrink,
+            Loot::IcePack => Item::IcePack,
+            Loot::Kettle => {
                 self.here.kitchen.kettle_boiled = true;
                 return Outcome::json(
                     StatusCode::OK,
-                    json!({ "detail": "The kettle has just boiled. The towel can be warmed once more." }),
+                    json!({ "detail": format!("{} The towel can be warmed once more.", loot.sight()) }),
                 );
             }
-            _ => return Outcome::empty(StatusCode::NO_CONTENT),
+            Loot::Nothing => return Outcome::empty(StatusCode::NO_CONTENT),
         };
         self.items.grant(item);
-        Outcome::json(StatusCode::OK, json!({ "detail": detail }))
+        Outcome::json(StatusCode::OK, json!({ "detail": loot.sight() }))
     }
 
     fn melon_offer(&self) -> Outcome {
-        let commit = self.path("/kitchen/watermelon");
-        Outcome::json(
-            StatusCode::MULTIPLE_CHOICES,
-            json!({
-                "detail": "The fridge holds a watermelon. It is exactly the right shape.",
-                "choices": [
-                    { "href": commit, "method": "POST", "title": "Commit to the watermelon" },
-                    { "href": self.path(""), "method": "GET", "title": "Close the fridge" },
-                ],
-            }),
-        )
-        .header(
-            header::LINK,
-            format!(
-                "<{commit}>; rel=\"alternate\"; title=\"Commit to the watermelon\"; allow=\"POST\""
-            ),
+        Outcome::choices(
+            "The fridge holds a watermelon. It is exactly the right shape.",
+            &[
+                Choice {
+                    href: self.path("/kitchen/watermelon"),
+                    method: "POST",
+                    title: "Commit to the watermelon",
+                },
+                Choice {
+                    href: self.path(""),
+                    method: "GET",
+                    title: "Close the fridge",
+                },
+            ],
         )
     }
 

Modified file: src/game/lube.rs+26 additions−13 deletions@@ -4,14 +4,6 @@ use serde_json::json;
 use super::Item;
 use crate::problem::Problem;
 
-pub const LUBRICANTS: [&str; 5] = [
-    "application/baby-oil",
-    "application/coconut-oil",
-    "application/lotion",
-    "application/vaseline",
-    "text/plain; charset=spit",
-];
-
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum Lube {
     BabyOil,
@@ -22,6 +14,28 @@ pub enum Lube {
 }
 
 impl Lube {
+    const ALL: [Self; 5] = [
+        Self::BabyOil,
+        Self::CoconutOil,
+        Self::Lotion,
+        Self::Vaseline,
+        Self::Spit,
+    ];
+
+    pub fn content_types() -> [&'static str; 5] {
+        Self::ALL.map(Self::content_type)
+    }
+
+    fn content_type(self) -> &'static str {
+        match self {
+            Self::BabyOil => "application/baby-oil",
+            Self::CoconutOil => "application/coconut-oil",
+            Self::Lotion => "application/lotion",
+            Self::Vaseline => "application/vaseline",
+            Self::Spit => "text/plain; charset=spit",
+        }
+    }
+
     pub fn from_content_type(content_type: Option<&str>) -> Result<Option<Self>, Problem> {
         let Some(raw) = content_type else {
             return Ok(None);
@@ -30,11 +44,10 @@ impl Lube {
         let mut parts = lowered.split(';').map(str::trim);
         let essence = parts.next().unwrap_or_default();
         let spit = parts.any(|p| p.replace(' ', "") == "charset=spit");
+        if let Some(lube) = Self::ALL.into_iter().find(|l| l.content_type() == essence) {
+            return Ok(Some(lube));
+        }
         match essence {
-            "application/baby-oil" => Ok(Some(Self::BabyOil)),
-            "application/coconut-oil" => Ok(Some(Self::CoconutOil)),
-            "application/lotion" => Ok(Some(Self::Lotion)),
-            "application/vaseline" => Ok(Some(Self::Vaseline)),
             "text/plain" if spit => Ok(Some(Self::Spit)),
             e if e.starts_with("image/") || e.starts_with("video/") => Err(Problem::new(
                 StatusCode::UNSUPPORTED_MEDIA_TYPE,
@@ -46,7 +59,7 @@ impl Lube {
                 "unsupported-lubricant",
                 format!("{essence} is not a lubricant."),
             )
-            .with("lubricants", json!(LUBRICANTS))),
+            .with("lubricants", json!(Self::content_types()))),
         }
     }
 

Modified file: src/game/mod.rs+2 additions−2 deletions@@ -46,10 +46,10 @@ pub use household::HEARD_A_NOISE;
 pub use household::{Excuse, Household, MumVisit, vocabulary as excuse_vocabulary};
 pub use inventory::Items;
 pub use items::{Item, SHOP};
-pub use lube::{LUBRICANTS, Lube};
+pub use lube::Lube;
 pub use measure::{shaft, volume};
 pub use notice::Notice;
-pub use outcome::{Outcome, Payload};
+pub use outcome::{Choice, Outcome, Payload};
 pub use run::Run;
 pub use standing::Standing;
 pub use techniques::Technique;

Modified file: src/game/outcome.rs+28 additions−2 deletions@@ -1,5 +1,7 @@
-use axum::http::{HeaderName, StatusCode};
-use serde_json::Value;
+use axum::http::{HeaderName, StatusCode, header};
+use serde_json::{Value, json};
+
+use crate::link::{self, Link};
 
 pub enum Payload {
     Empty,
@@ -7,6 +9,13 @@ pub enum Payload {
     Raw(&'static str, Vec<u8>),
 }
 
+/// One way out of a 300, offered in the body and in `Link` alike.
+pub struct Choice {
+    pub(crate) href: String,
+    pub(crate) method: &'static str,
+    pub(crate) title: &'static str,
+}
+
 /// A successful result of a game action, before it becomes an HTTP response.
 pub struct Outcome {
     status: StatusCode,
@@ -37,6 +46,23 @@ impl Outcome {
         }
     }
 
+    pub fn choices(detail: &str, choices: &[Choice]) -> Self {
+        let listed: Vec<Value> = choices
+            .iter()
+            .map(|c| json!({ "href": c.href, "method": c.method, "title": c.title }))
+            .collect();
+        let links = link::join(choices.iter().map(|c| {
+            Link::registered(&c.href, "alternate")
+                .title(c.title)
+                .allow(c.method)
+        }));
+        Self::json(
+            StatusCode::MULTIPLE_CHOICES,
+            json!({ "detail": detail, "choices": listed }),
+        )
+        .header(header::LINK, links)
+    }
+
     pub fn header(mut self, name: HeaderName, value: impl Into<String>) -> Self {
         self.headers.push((name, value.into()));
         self

Modified file: src/game/rest.rs+1 additions−7 deletions@@ -18,13 +18,7 @@ impl Run {
         if self.online.story == Story::Pending {
             return Ok(self.branch_offer());
         }
-        if self.items.kit.cage {
-            return Err(Problem::new(
-                StatusCode::LOCKED,
-                "caged",
-                "The cage is locked. The key is not in the box.",
-            ));
-        }
+        self.check_cage()?;
         self.begin_turn()?;
         if self.oracle.chance_not(
             self.decision("rupture", "The pause is uneventful"),

Modified file: src/game/run.rs+14 additions−2 deletions@@ -7,8 +7,8 @@ use axum::http::StatusCode;
 use serde_json::{Value, json};
 
 use super::{
-    Body, Cause, Clinic, Ending, Floor, FloorState, Household, Item, Items, Notice, Observer,
-    Online, RunStatus, Standing, Story,
+    Body, Branch, 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, REFRACTORY_STAMINA,
         SECOND_WIND, SELF_REPORT_INFLATION, STARTING_BABY_OIL, STARTING_EQ, STARTING_LUBE,
@@ -258,6 +258,18 @@ impl Run {
         format!("/runs/{}{sub}", self.ident.id)
     }
 
+    pub fn item_path(&self, item: Item) -> String {
+        self.path(&format!("/inventory/{}", item.slug()))
+    }
+
+    pub fn shop_path(&self, item: Item) -> String {
+        self.path(&format!("/shop/{}", item.slug()))
+    }
+
+    pub fn branch_path(&self, branch: Branch) -> String {
+        self.path(&format!("/branches/{}", branch.slug()))
+    }
+
     pub fn current_length(&self) -> f64 {
         self.body.length + self.here.temp_length
     }

Modified file: src/game/shop.rs+5 additions−11 deletions@@ -3,7 +3,7 @@ use std::fmt::Write as _;
 use axum::http::{StatusCode, header};
 use serde_json::{Value, json};
 
-use super::{Item, Outcome, Run, balance::THIN_MARKUP, items::SHOP};
+use super::{Item, Outcome, Run, balance::THIN_MARKUP, checks::caged, items::SHOP};
 use crate::problem::Problem;
 
 fn pump_bro_absent() -> Problem {
@@ -42,7 +42,7 @@ impl Run {
                     "item": item.slug(),
                     "price": self.price(*item)?,
                     "description": item.pitch(),
-                    "href": self.path(&format!("/shop/{}", item.slug())),
+                    "href": self.shop_path(*item),
                     "method": "POST",
                 }))
             })
@@ -109,10 +109,8 @@ impl Run {
             );
         }
         Ok(
-            Outcome::json(StatusCode::CREATED, json!({ "detail": detail })).header(
-                header::LOCATION,
-                self.path(&format!("/inventory/{}", item.slug())),
-            ),
+            Outcome::json(StatusCode::CREATED, json!({ "detail": detail }))
+                .header(header::LOCATION, self.item_path(item)),
         )
     }
 
@@ -121,11 +119,7 @@ impl Run {
             Item::Extender => self.items.kit.extender = false,
             Item::Ring => self.items.kit.ring = false,
             Item::Cage => {
-                return Err(Problem::new(
-                    StatusCode::LOCKED,
-                    "caged",
-                    "The cage is locked.",
-                ));
+                return Err(caged());
             }
             _ => {
                 return Err(Problem::new(

Modified file: src/http/leaderboard.rs+10 additions−4 deletions@@ -7,9 +7,15 @@ use axum::{
 };
 use serde_json::{Value, json};
 
-use super::{Shared, ctx::Ctx, run::records_unavailable};
+use super::{
+    Shared,
+    ctx::Ctx,
+    meta::{GRAVEYARD_PATH, LEADERBOARD_PATH},
+    run::records_unavailable,
+};
 use crate::{
     game::{balance::MM_PER_INCH, volume},
+    link::Link,
     problem::{PROBLEM_BASE, Problem},
     records::{Ranking, Record},
 };
@@ -32,7 +38,7 @@ fn page(ctx: &Ctx) -> Result<usize, Problem> {
 fn paged(body: Value, path: &str, query: &str, page: usize, full: bool) -> Response {
     let link = |page: usize, rel: &str| {
         let separator = if query.is_empty() { "" } else { "&" };
-        format!("<{path}?{query}{separator}page={page}>; rel=\"{rel}\"")
+        Link::registered(&format!("{path}?{query}{separator}page={page}"), rel).to_string()
     };
     let mut links = Vec::new();
     if page > 1 {
@@ -73,7 +79,7 @@ pub fn graveyard(state: &mut Shared, ctx: &Ctx) -> Response {
             }))
         })
         .collect();
-    paged(json!({ "runs": runs }), "/graveyard", "", page, full)
+    paged(json!({ "runs": runs }), GRAVEYARD_PATH, "", page, full)
 }
 
 fn ranking(state: &Shared, ctx: &Ctx) -> Result<Ranking, Problem> {
@@ -175,7 +181,7 @@ pub fn leaderboard(state: &mut Shared, ctx: &Ctx) -> Response {
     }
     paged(
         json!({ "entries": listed }),
-        "/leaderboard",
+        LEADERBOARD_PATH,
         &query.join("&"),
         page,
         full,

Modified file: src/http/links.rs+33 additions−77 deletions@@ -1,43 +1,12 @@
-use std::fmt::Write as _;
-
 use super::{run::RunResource, runs};
-use crate::game::{Branch, Run, SHOP};
-
-pub const REL_BASE: &str = "https://jelq.dev/rels/";
-
-/// One RFC 8288 link. `allow`, `lubricant` and `intensity` are extension attributes (§3), so a client never
-/// has to guess what a target accepts.
-struct Link<'a> {
-    href: &'a str,
-    rel: &'a str,
-    allow: &'a str,
-    title: Option<&'a str>,
-    lubricant: Option<&'a str>,
-    intensity: Option<&'a str>,
-}
-
-impl Link<'_> {
-    fn write(&self, out: &mut String) {
-        if !out.is_empty() {
-            out.push_str(", ");
-        }
-        let _ = write!(out, "<{}>; rel=\"{REL_BASE}{}\"", self.href, self.rel);
-        if let Some(title) = self.title {
-            let _ = write!(out, "; title=\"{title}\"");
-        }
-        let _ = write!(out, "; allow=\"{}\"", self.allow);
-        if let Some(rule) = self.lubricant {
-            let _ = write!(out, "; lubricant=\"{rule}\"");
-        }
-        if let Some(range) = self.intensity {
-            let _ = write!(out, "; intensity=\"{range}\"");
-        }
-    }
-}
+use crate::{
+    game::{Branch, Run, SHOP},
+    link::Link,
+};
 
 pub fn header(run: &Run) -> String {
     let reach = run.reach();
-    let mut out = String::new();
+    let mut links = Vec::new();
     let resources: [(&str, &RunResource, bool); 15] = [
         ("", &runs::RUN, true),
         ("floor", &runs::FLOOR, true),
@@ -61,60 +30,47 @@ pub fn header(run: &Run) -> String {
         } else {
             run.path(&format!("/{rel}"))
         };
-        Link {
-            href: &href,
-            rel: if rel.is_empty() { "run" } else { rel },
-            allow: &target.resource.allow(run),
-            title: None,
-            lubricant: None,
-            intensity: None,
-        }
-        .write(&mut out);
+        let rel = if rel.is_empty() { "run" } else { rel };
+        links.push(
+            Link::jelq(&href, rel)
+                .allow(&target.resource.allow(run))
+                .to_string(),
+        );
     }
     if reach.branch_pending {
-        for (branch, title) in [
-            (Branch::Forum, "Read the forum"),
-            (Branch::CloseTab, "Close the tab"),
-        ] {
-            Link {
-                href: &run.path(&format!("/branches/{}", branch.slug())),
-                rel: "branch",
-                allow: "POST",
-                title: Some(title),
-                lubricant: None,
-                intensity: None,
-            }
-            .write(&mut out);
+        for branch in Branch::ALL {
+            links.push(
+                Link::jelq(&run.branch_path(branch), "branch")
+                    .title(branch.title())
+                    .allow("POST")
+                    .to_string(),
+            );
         }
     }
     let run_path = run.path("");
     for technique in run.techniques_now() {
         let name = technique.name();
-        Link {
-            href: &format!("{run_path}?technique={name}"),
-            rel: "technique",
-            allow: "JELQ",
-            title: Some(name),
-            lubricant: technique.lubricant(),
-            intensity: technique.intensity(),
-        }
-        .write(&mut out);
+        links.push(
+            Link::jelq(&format!("{run_path}?technique={name}"), "technique")
+                .title(name)
+                .allow("JELQ")
+                .lubricant(technique.lubricant())
+                .intensity(technique.intensity())
+                .to_string(),
+        );
     }
     if reach.shopping {
         for item in SHOP {
             let Some(price) = run.price(item) else {
                 continue;
             };
-            Link {
-                href: &run.path(&format!("/shop/{}", item.slug())),
-                rel: "shop-item",
-                allow: "POST",
-                title: Some(&format!("{} for {price}", item.slug())),
-                lubricant: None,
-                intensity: None,
-            }
-            .write(&mut out);
+            links.push(
+                Link::jelq(&run.shop_path(item), "shop-item")
+                    .title(&format!("{} for {price}", item.slug()))
+                    .allow("POST")
+                    .to_string(),
+            );
         }
     }
-    out
+    links.join(", ")
 }

Modified file: src/http/meta.rs+5 additions−2 deletions@@ -24,6 +24,9 @@ use crate::{
 pub static INDEX: Resource<Shared> = Resource::new(&[Verb::new("GET", index)]);
 pub static RUNS: Resource<Shared> = Resource::new(&[Verb::new("POST", create_run)]);
 pub static THREAD: Resource<Shared> = Resource::new(&[Verb::new("GET", thread)]);
+pub const GRAVEYARD_PATH: &str = "/graveyard";
+pub const LEADERBOARD_PATH: &str = "/leaderboard";
+
 pub static GRAVEYARD: Resource<Shared> = Resource::new(&[Verb::new("GET", graveyard)]);
 pub static LEADERBOARD: Resource<Shared> = Resource::new(&[Verb::new("GET", leaderboard)]);
 
@@ -43,8 +46,8 @@ fn index(_: &mut Shared, ctx: &Ctx) -> Response {
         Json(json!({
             "detail": "This is jelqd. It is a roguelike. It is played over HTTP.",
             "start": { "href": "/runs", "method": "POST" },
-            "leaderboard": "/leaderboard",
-            "graveyard": "/graveyard",
+            "leaderboard": LEADERBOARD_PATH,
+            "graveyard": GRAVEYARD_PATH,
             "forum": FORUM_THREAD,
             "ui": "/ui/",
         })),

Modified file: src/http/mod.rs+2 additions−2 deletions@@ -161,8 +161,8 @@ fn api(state: Shared) -> Router {
         .route("/runs/{id}/diagnosis", scoped(&runs::DIAGNOSIS))
         .route("/runs/{id}/footage", scoped(&runs::FOOTAGE))
         .route("/forum/threads/{year}", global(&meta::THREAD))
-        .route("/graveyard", global(&meta::GRAVEYARD))
-        .route("/leaderboard", global(&meta::LEADERBOARD))
+        .route(meta::GRAVEYARD_PATH, global(&meta::GRAVEYARD))
+        .route(meta::LEADERBOARD_PATH, global(&meta::LEADERBOARD))
         .fallback(meta::not_found)
         .layer(axum::middleware::from_fn(middleware::chrome))
         .layer(CatchPanicLayer::custom(middleware::panicked))

Modified file: src/http/parse.rs+5 additions−6 deletions@@ -7,13 +7,13 @@ use crate::{
 };
 
 pub(super) fn parse_techniques(run: &Run, ctx: &Ctx) -> Result<Vec<Technique>, Problem> {
+    let listed = |problem: Problem| problem.with("techniques", run.path("/techniques"));
     let required = || {
-        Problem::new(
+        listed(Problem::new(
             StatusCode::BAD_REQUEST,
             "technique-required",
             "No technique was specified.",
-        )
-        .with("techniques", run.path("/techniques"))
+        ))
     };
     let names = ctx
         .query("technique")
@@ -25,12 +25,11 @@ pub(super) fn parse_techniques(run: &Run, ctx: &Ctx) -> Result<Vec<Technique>, P
         .filter(|n| !n.is_empty())
         .map(|name| {
             Technique::parse(name).ok_or_else(|| {
-                Problem::new(
+                listed(Problem::new(
                     StatusCode::BAD_REQUEST,
                     "unknown-technique",
                     format!("{name} is not a technique."),
-                )
-                .with("techniques", run.path("/techniques"))
+                ))
             })
         })
         .collect()

Modified file: src/http/run.rs+5 additions−6 deletions@@ -8,7 +8,8 @@ use hyper_util::rt::TokioIo;
 use tokio::io::AsyncWriteExt;
 
 use super::{
-    AppState, ctx::Ctx, links, middleware::Compress, registry::Lock, resource::Resource, shame,
+    AppState, ctx::Ctx, links, meta::GRAVEYARD_PATH, middleware::Compress, registry::Lock,
+    resource::Resource, shame,
 };
 use crate::{
     game::{
@@ -20,6 +21,7 @@ use crate::{
         X_GIRTH, X_LENGTH, X_OBSERVED_BY, X_RUN_OVER, X_SELF_REPORTED_LENGTH, X_SHAME, X_STAMINA,
         X_SUSPICION, X_TURN,
     },
+    link::Link,
     locale::Locale,
     problem::{PROBLEM_BASE, Problem},
     records::Record,
@@ -108,7 +110,7 @@ fn gone(cause: &str, turn: u32) -> Response {
     Problem::new(StatusCode::GONE, "run-ended", "This run has ended.")
         .with("cause", format!("{PROBLEM_BASE}{cause}"))
         .with("turn", turn)
-        .with("graveyard", "/graveyard")
+        .with("graveyard", GRAVEYARD_PATH)
         .header(X_RUN_OVER, cause)
         .into_response()
 }
@@ -126,10 +128,7 @@ fn gate(run: &mut Run, ctx: &Ctx, scope: Scope) -> Option<Response> {
                 "The network requires authentication. The hotel would like you to agree to some terms.",
             )
             .with("portal", portal.as_str())
-            .header(
-                header::LINK,
-                format!("<{portal}>; rel=\"{}portal\"", links::REL_BASE),
-            )
+            .header(header::LINK, Link::jelq(&portal, "portal").to_string())
             .into_response(),
         );
     }

Modified file: src/http/runs.rs+2 additions−5 deletions@@ -17,10 +17,7 @@ use super::{
     shaft::{get_foreskin, get_length},
 };
 use crate::{
-    game::{
-        Branch, Cause, Floor, Grip, Item, LUBRICANTS, Lube, Run, Technique,
-        balance::VIEWS_PER_SECOND,
-    },
+    game::{Branch, Cause, Floor, Grip, Item, Lube, Run, Technique, balance::VIEWS_PER_SECOND},
     problem::Problem,
 };
 
@@ -156,7 +153,7 @@ fn get_techniques(run: &mut Run, _: &Ctx) -> Response {
     Json(json!({
         "usage": format!("JELQ {}?technique=<name>[,<name>]&intensity=<1-10>", run.path("")),
         "lubricant": "Declared with Content-Type.",
-        "lubricants": LUBRICANTS,
+        "lubricants": Lube::content_types(),
         "techniques": listed,
     }))
     .into_response()

Modified file: src/http/shaft.rs+8 additions−15 deletions@@ -13,6 +13,8 @@ use crate::{
 };
 
 const SHAFT_CHUNK: usize = 16;
+const SHAFT_TYPE: &str = "text/plain; charset=us-ascii";
+const RANGE_UNIT: &str = "inches";
 
 pub(super) fn millimetres(inches: f64) -> usize {
     (inches * MM_PER_INCH).round() as usize
@@ -72,11 +74,8 @@ pub(super) fn partial_inches(
     (
         StatusCode::PARTIAL_CONTENT,
         [
-            (
-                header::CONTENT_TYPE,
-                "text/plain; charset=us-ascii".to_owned(),
-            ),
-            (header::ACCEPT_RANGES, "inches".to_owned()),
+            (header::CONTENT_TYPE, SHAFT_TYPE.to_owned()),
+            (header::ACCEPT_RANGES, RANGE_UNIT.to_owned()),
             (
                 header::CONTENT_RANGE,
                 format!("inches {start:.2}-{end:.2}/{total:.2}"),
@@ -90,11 +89,8 @@ pub(super) fn partial_inches(
 pub(super) fn get_length(run: &mut Run, ctx: &Ctx) -> Response {
     let inches = run.shown_length();
     let body = shaft(millimetres(inches));
-    let content_type = (
-        header::CONTENT_TYPE,
-        "text/plain; charset=us-ascii".to_owned(),
-    );
-    let accept_ranges = (header::ACCEPT_RANGES, "inches".to_owned());
+    let content_type = (header::CONTENT_TYPE, SHAFT_TYPE.to_owned());
+    let accept_ranges = (header::ACCEPT_RANGES, RANGE_UNIT.to_owned());
 
     if let Some(range) = ctx
         .header(header::RANGE)
@@ -145,11 +141,8 @@ pub(super) fn get_foreskin(run: &mut Run, ctx: &Ctx) -> Response {
         StatusCode::OK,
         [
             (header::ETAG, run.etag()),
-            (
-                header::CONTENT_TYPE,
-                "text/plain; charset=us-ascii".to_owned(),
-            ),
-            (header::ACCEPT_RANGES, "inches".to_owned()),
+            (header::CONTENT_TYPE, SHAFT_TYPE.to_owned()),
+            (header::ACCEPT_RANGES, RANGE_UNIT.to_owned()),
         ],
         body,
     )

Modified file: src/lib.rs+1

@@ -2,6 +2,7 @@ mod config;

22 mod game;

33 mod headers;

44 mod http;

5+mod link;

56 mod locale;

67 mod problem;

78 mod records;

Added file: src/link.rs+94 additions@@ -0,0 +1,94 @@
+use std::fmt;
+
+pub const REL_BASE: &str = "https://jelq.dev/rels/";
+
+enum Rel<'a> {
+    Jelq(&'a str),
+    Registered(&'a str),
+}
+
+/// One RFC 8288 link. `allow`, `lubricant` and `intensity` are extension attributes (§3), so a client never
+/// has to guess what a target accepts.
+pub struct Link<'a> {
+    href: &'a str,
+    rel: Rel<'a>,
+    title: Option<&'a str>,
+    allow: Option<&'a str>,
+    lubricant: Option<&'a str>,
+    intensity: Option<&'a str>,
+}
+
+impl<'a> Link<'a> {
+    fn new(href: &'a str, rel: Rel<'a>) -> Self {
+        Self {
+            href,
+            rel,
+            title: None,
+            allow: None,
+            lubricant: None,
+            intensity: None,
+        }
+    }
+
+    /// A relation of this game's own, named under `REL_BASE`.
+    pub fn jelq(href: &'a str, rel: &'a str) -> Self {
+        Self::new(href, Rel::Jelq(rel))
+    }
+
+    /// A relation from the IANA registry, such as `next` or `alternate`.
+    pub fn registered(href: &'a str, rel: &'a str) -> Self {
+        Self::new(href, Rel::Registered(rel))
+    }
+
+    pub fn title(self, title: &'a str) -> Self {
+        Self {
+            title: Some(title),
+            ..self
+        }
+    }
+
+    pub fn allow(self, allow: &'a str) -> Self {
+        Self {
+            allow: Some(allow),
+            ..self
+        }
+    }
+
+    pub fn lubricant(self, lubricant: Option<&'a str>) -> Self {
+        Self { lubricant, ..self }
+    }
+
+    pub fn intensity(self, intensity: Option<&'a str>) -> Self {
+        Self { intensity, ..self }
+    }
+}
+
+impl fmt::Display for Link<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "<{}>; rel=\"", self.href)?;
+        match self.rel {
+            Rel::Jelq(rel) => write!(f, "{REL_BASE}{rel}\"")?,
+            Rel::Registered(rel) => write!(f, "{rel}\"")?,
+        }
+        for (name, value) in [
+            ("title", self.title),
+            ("allow", self.allow),
+            ("lubricant", self.lubricant),
+            ("intensity", self.intensity),
+        ] {
+            if let Some(value) = value {
+                write!(f, "; {name}=\"{value}\"")?;
+            }
+        }
+        Ok(())
+    }
+}
+
+/// A `Link` header value listing every link in order.
+pub fn join<'a>(links: impl IntoIterator<Item = Link<'a>>) -> String {
+    links
+        .into_iter()
+        .map(|link| link.to_string())
+        .collect::<Vec<_>>()
+        .join(", ")
+}

Modified file: src/ui.html+30 additions−36 deletions@@ -53,32 +53,28 @@ pre, li, p, td, label { overflow-wrap: anywhere; }
 const REL = "https://jelq.dev/rels/";
 const METHODS = ["JELQ", "HOLD", "GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS", "TRACE"];
 const ALL_LUBES = ["", "application/baby-oil", "application/coconut-oil", "application/lotion", "application/vaseline", "text/plain; charset=spit", "image/jpeg"];
-const DEATHS = ["ruptured", "caught", "opened", "banned", "degloved", "zip", "watermelon", "overstayed", "run-ended"];
 let stocked = null;
 let excuses = [];
 let nonce = null;
 let inventorySeq = 0;
 const STATS = [
-  ["x-turn", "Turn"],
-  ["x-floor-turn", "Floor turn"],
-  ["x-floor", "Floor"],
-  ["x-cash", "Cash"],
-  ["x-self-reported-length", "Self-reported length"],
-  ["x-girth", "Girth"],
-  ["x-foreskin", "Foreskin"],
-  ["x-friction", "Friction"],
-  ["x-eq", "EQ"],
-  ["x-stamina", "Stamina"],
-  ["x-suspicion", "Suspicion"],
-  ["x-shame", "Shame"],
+  { header: "x-turn", label: "Turn" },
+  { header: "x-floor-turn", label: "Floor turn" },
+  { header: "x-floor", label: "Floor", better: 1 },
+  { header: "x-cash", label: "Cash", better: 1 },
+  { header: "x-self-reported-length", label: "Self-reported length", better: 1, places: 2, measured: { header: "x-length", label: "Length" } },
+  { header: "x-girth", label: "Girth", better: 1, places: 2 },
+  { header: "x-foreskin", label: "Foreskin", better: 1, places: 2 },
+  { header: "x-friction", label: "Friction", better: -1 },
+  { header: "x-eq", label: "EQ" },
+  { header: "x-stamina", label: "Stamina", better: 1 },
+  { header: "x-suspicion", label: "Suspicion", better: -1 },
+  { header: "x-shame", label: "Shame", better: -1 },
 ];
-const MEASURED = ["x-length", "Length"];
-const GROWTH = new Set(["x-length", "x-self-reported-length", "x-girth", "x-foreskin"]);
-const BETTER = { "x-length": 1, "x-self-reported-length": 1, "x-girth": 1, "x-foreskin": 1, "x-friction": -1, "x-stamina": 1, "x-suspicion": -1, "x-shame": -1, "x-cash": 1, "x-floor": 1 };
 const AROUSAL = ["Flaccid", "Cold", "Warm", "Ideal", "Swollen", "Throbbing", "Straining", "Imminent"];
 const DANGER_COLOURS = { dangerous: "#b8860b", critical: "red" };
 let lastStats = {};
-const QUIET = new Set(["link", "set-cookie", "server", "x-powered-by", "cache-control", "content-length", "content-type", "date"].concat(STATS.map(s => s[0]), MEASURED[0]));
+const QUIET = new Set(["link", "set-cookie", "server", "x-powered-by", "cache-control", "content-length", "content-type", "date"].concat(STATS.flatMap(s => [s.header, s.measured?.header]).filter(Boolean)));
 
 const FIELDS = {
   seed: { label: "seed (unranked)", kind: "text" },
@@ -219,18 +215,17 @@ function renderStats(headers) {
   const table = $("stats");
   table.replaceChildren();
   const dangers = Object.fromEntries((headers && headers["x-danger"] || "").split(",").filter(Boolean).map(d => d.trim().split("=")));
-  const stats = STATS.map(s => s[0] === "x-self-reported-length" && headers && MEASURED[0] in headers ? MEASURED : s);
+  const stats = STATS.map(s => s.measured && headers && s.measured.header in headers ? { ...s, ...s.measured, unmeasured: s.header } : s);
   for (let i = 0; i < stats.length; i += 2) {
     const row = el("tr");
-    for (const [name, label] of stats.slice(i, i + 2)) {
-      const value = headers ? headers[name] : undefined;
+    for (const stat of stats.slice(i, i + 2)) {
+      const value = headers ? headers[stat.header] : undefined;
       const cell = el("td", {}, value === undefined ? "—" : value);
-      const changed = value === undefined ? null : change(name, value);
+      const changed = value === undefined ? null : change(stat, value);
       if (changed) cell.append(" ", changed);
-      const measured = name === MEASURED[0] && "x-self-reported-length" in lastStats;
-      const danger = DANGER_COLOURS[dangers[name.slice(2)]];
-      const colour = danger || (measured ? "green" : "");
-      row.append(el("th", { align: "left", textContent: label, style: colour ? "color: " + colour : "" }), cell);
+      const measured = stat.unmeasured in lastStats;
+      const colour = DANGER_COLOURS[dangers[stat.header.slice(2)]] || (measured ? "green" : "");
+      row.append(el("th", { align: "left", textContent: stat.label, style: colour ? "color: " + colour : "" }), cell);
     }
     table.append(row);
   }
@@ -241,18 +236,19 @@ function fromIdeal(arousal) {
   return arousal === "Priapic" ? AROUSAL.length : Math.abs(AROUSAL.indexOf(arousal) - AROUSAL.indexOf("Ideal"));
 }
 
-function change(name, value) {
-  const before = lastStats[name];
-  if (before === undefined || before === value || !(name in BETTER || name === "x-eq")) return null;
-  if (name === "x-eq") {
+function change(stat, value) {
+  const before = lastStats[stat.header];
+  if (before === undefined || before === value) return null;
+  if (stat.header === "x-eq") {
     const closer = Math.sign(fromIdeal(before) - fromIdeal(value));
     const was = el("b", { textContent: before, style: closer ? "color: " + (closer > 0 ? "green" : "red") : "" });
     return el("small", {}, "(was ", was, ")");
   }
+  if (!stat.better) return null;
   const delta = parseFloat(value) - parseFloat(before);
   if (!(Math.abs(delta) >= 0.005)) return null;
-  const text = (delta > 0 ? "+" : "") + (GROWTH.has(name) ? delta.toFixed(2) : delta);
-  return el("b", { textContent: text, style: "color: " + (Math.sign(delta) === BETTER[name] ? "green" : "red") });
+  const text = (delta > 0 ? "+" : "") + (stat.places ? delta.toFixed(stat.places) : delta);
+  return el("b", { textContent: text, style: "color: " + (Math.sign(delta) === stat.better ? "green" : "red") });
 }
 
 function renderAlerts(list) {
@@ -415,7 +411,7 @@ function describe(r) {
   return lines.join("\n");
 }
 
-function absorb(r, sentMethod, sentPath) {
+function absorb(r, sentPath) {
   const headers = Object.fromEntries(r.headers.map(([n, v]) => [n.toLowerCase(), v]));
   if (headers.etag) etags[sentPath] = headers.etag;
   const digest = (headers["www-authenticate"] || "").match(/nonce="([^"]*)"/);
@@ -423,7 +419,6 @@ function absorb(r, sentMethod, sentPath) {
   renderExcuses();
   let body = null;
   try { body = JSON.parse(r.body); } catch (e) {}
-  const problem = body && typeof body.type === "string" ? body.type.split("/").pop() : null;
   const started = r.status === 201 && (sentPath === "/runs" || sentPath.startsWith("/runs?"));
 
   if (started) {
@@ -457,8 +452,7 @@ function absorb(r, sentMethod, sentPath) {
   if (headers.location && !started) {
     offered.unshift({ key: "offered", group: "said", name: short(headers.location).split("/").pop() + " (Location)", path: headers.location, methods: ["GET"] });
   }
-  const abandoned = sentMethod === "DELETE" && sentPath === run && r.status === 204;
-  if (run && (abandoned || DEATHS.includes(problem))) {
+  if (run && "x-run-over" in headers) {
     log("--- the run has ended ---");
     renderAlerts(null);
     challenged = false;
@@ -522,7 +516,7 @@ async function go(event) {
     return;
   }
   log(sent + "\n" + describe(r));
-  absorb(r, method, path);
+  absorb(r, path);
 }
 
 $("form").onsubmit = go;

jelq

Commit 4f54028cba69

Commit `4f54028cba69`