jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

18 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `58e1fb3943e6`

tarball

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

5 files changed+229-83

ui: offer only the moves the run can make right now

The page offered every technique and greyed out refused methods, so players tried things the server would only refuse. The server now advertises each usable technique as its own Link entry with its lubricant rule, and the page drops everything else instead of disabling it.

Modified file: src/game/techniques.rs+18 additions−5 deletions@@ -92,6 +92,16 @@ pub enum LubeRule {
     Optional,
 }
 
+impl LubeRule {
+    fn name(self) -> &'static str {
+        match self {
+            Self::Required => "required",
+            Self::Forbidden => "forbidden",
+            Self::Optional => "optional",
+        }
+    }
+}
+
 pub struct Profile {
     pub dc: i32,
     pub length: f64,
@@ -196,6 +206,13 @@ impl Technique {
         Self::ALL.into_iter().find(|t| t.name() == name)
     }
 
+    pub fn lubricant(self) -> Option<&'static str> {
+        match self {
+            Self::Training(training) => Some(training.profile().lube.name()),
+            Self::Utility(_) => None,
+        }
+    }
+
     pub fn describe(self, forum_read: bool) -> Value {
         let training = match self {
             Self::Utility(utility) => {
@@ -204,11 +221,7 @@ impl Technique {
             Self::Training(training) => training,
         };
         let profile = training.profile();
-        let lubricant = match profile.lube {
-            LubeRule::Required => "required",
-            LubeRule::Forbidden => "forbidden",
-            LubeRule::Optional => "optional",
-        };
+        let lubricant = profile.lube.name();
         json!({
             "name": training.name(),
             "dc": profile.dc,

Modified file: src/game/turn.rs+64 additions−38 deletions@@ -176,6 +176,15 @@ impl Run {
     }
 
     fn ready(&self, technique: Technique, lube: Option<Lube>) -> Result<(), Problem> {
+        self.access(technique)?;
+        match technique {
+            Technique::Training(training) => Self::check_lube(training, lube),
+            Technique::Utility(_) => Ok(()),
+        }
+    }
+
+    /// Whether the run could attempt the technique now, ignoring the lubricant.
+    fn access(&self, technique: Technique) -> Result<(), Problem> {
         if technique == Technique::Training(Training::Uli) && !self.forum_read() {
             return Err(Problem::new(
                 StatusCode::FORBIDDEN,
@@ -191,48 +200,65 @@ impl Run {
             )
             .with("technique", Utility::Warmup.name()));
         }
-        let training = match technique {
-            Technique::Utility(Utility::Pump) if !self.items.pump_pro => {
-                return Err(Problem::new(
-                    StatusCode::FAILED_DEPENDENCY,
-                    "no-pump",
-                    "The pump technique depends on a pump.",
-                ));
-            }
-            Technique::Utility(_) => return Ok(()),
-            Technique::Training(training) => training,
-        };
-        let profile = training.profile();
-        match (profile.lube, lube) {
-            (LubeRule::Required, None) => {
-                return Err(Problem::new(
-                    StatusCode::UNSUPPORTED_MEDIA_TYPE,
-                    "lubricant-required",
-                    format!(
-                        "The {} technique requires a lubricant. None was declared.",
-                        training.name()
-                    ),
-                )
-                .with("lubricants", json!(LUBRICANTS)));
-            }
-            (LubeRule::Forbidden, Some(_)) => {
-                return Err(Problem::new(
-                    StatusCode::UNSUPPORTED_MEDIA_TYPE,
-                    "lubricant-declared",
-                    format!(
-                        "The {} technique was requested. A lubricant was declared.",
-                        training.name()
-                    ),
-                ));
-            }
-            _ => {}
+        match technique {
+            Technique::Utility(Utility::Pump) if !self.items.pump_pro => Err(Problem::new(
+                StatusCode::FAILED_DEPENDENCY,
+                "no-pump",
+                "The pump technique depends on a pump.",
+            )),
+            Technique::Utility(_) => Ok(()),
+            Technique::Training(training) => match training.profile().foreskin {
+                Some((min, max)) => self.check_foreskin(min, max),
+                None => Ok(()),
+            },
         }
-        match profile.foreskin {
-            Some((min, max)) => self.check_foreskin(min, max),
-            None => Ok(()),
+    }
+
+    fn check_lube(training: Training, lube: Option<Lube>) -> Result<(), Problem> {
+        match (training.profile().lube, lube) {
+            (LubeRule::Required, None) => Err(Problem::new(
+                StatusCode::UNSUPPORTED_MEDIA_TYPE,
+                "lubricant-required",
+                format!(
+                    "The {} technique requires a lubricant. None was declared.",
+                    training.name()
+                ),
+            )
+            .with("lubricants", json!(LUBRICANTS))),
+            (LubeRule::Forbidden, Some(_)) => Err(Problem::new(
+                StatusCode::UNSUPPORTED_MEDIA_TYPE,
+                "lubricant-declared",
+                format!(
+                    "The {} technique was requested. A lubricant was declared.",
+                    training.name()
+                ),
+            )),
+            _ => Ok(()),
         }
     }
 
+    /// The techniques a JELQ could use right now without being refused before the roll.
+    pub fn techniques_now(&self, now: Instant) -> Vec<Technique> {
+        let blocked = !self.floor.timed()
+            || self.items.cage
+            || self.story == Story::Pending
+            || self.refractory_until.is_some_and(|until| now < until);
+        if blocked {
+            return Vec::new();
+        }
+        let rested = self.refractory_until.is_some();
+        Technique::ALL
+            .into_iter()
+            .filter(|&technique| match technique {
+                Technique::Utility(Utility::Warmup) => true,
+                Technique::Utility(Utility::Ice) => self.items.ice_packs > 0,
+                Technique::Utility(Utility::Supplement) => self.items.supplements > 0,
+                _ if rested => false,
+                _ => self.access(technique).is_ok() && self.check_storage().is_ok(),
+            })
+            .collect()
+    }
+
     fn check_foreskin(&self, min: f64, max: f64) -> Result<(), Problem> {
         let Some(f) = self.foreskin else {
             if min <= 0.0 {

Modified file: src/http/run.rs+16 additions−4 deletions@@ -1,5 +1,7 @@
 //! Plumbing shared by every resource under `/runs/{id}`.
 
+use std::time::Instant;
+
 use axum::{
     http::{HeaderName, HeaderValue, StatusCode, header},
     response::{IntoResponse, Response},
@@ -88,9 +90,9 @@ fn gate(run: &mut Run, ctx: &Ctx, scope: Scope) -> Option<Response> {
         .map(IntoResponse::into_response)
 }
 
-/// Every resource the run can reach right now. The `allow` extension attribute (RFC 8288 §3)
-/// carries the methods each one accepts, so a client never has to guess.
-fn links(run: &Run) -> String {
+/// Every resource the run can reach right now, then every technique a JELQ could use. The `allow`
+/// and `lubricant` extension attributes (RFC 8288 §3) say what each accepts, so a client never guesses.
+fn links(run: &Run, now: Instant) -> String {
     let linked: [(&str, &RunResource, bool); 13] = [
         ("", &runs::RUN, true),
         ("floor", &runs::FLOOR, true),
@@ -118,6 +120,16 @@ fn links(run: &Run) -> String {
             let allow = target.resource.allow(run);
             format!("<{path}>; rel=\"{REL_BASE}{name}\"; allow=\"{allow}\"")
         })
+        .chain(run.techniques_now(now).into_iter().map(|technique| {
+            let name = technique.name();
+            let lubricant = technique
+                .lubricant()
+                .map_or(String::new(), |rule| format!("; lubricant=\"{rule}\""));
+            format!(
+                "<{}?technique={name}>; rel=\"{REL_BASE}technique\"; title=\"{name}\"; allow=\"JELQ\"{lubricant}",
+                run.path("")
+            )
+        }))
         .collect::<Vec<_>>()
         .join(", ")
 }
@@ -157,7 +169,7 @@ pub fn finish(run: &mut Run, ctx: &Ctx, secret: &Secret, mut response: Response)
         (X_SHAME, shame.to_string()),
         (X_CASH, run.cash.to_string()),
         (X_FLOOR, run.floor.number().to_string()),
-        (header::LINK, links(run)),
+        (header::LINK, links(run, ctx.now)),
     ];
     if let Some(observer) = run.observed {
         stats.push((X_OBSERVED_BY, observer.name().into()));

Modified file: src/tests.rs+34 additions@@ -715,3 +715,37 @@ async fn the_default_locale_is_british() {
     assert!(header(&floor, "vary").contains("Accept-Language"));
     assert_eq!(json(floor).await["name"], "Nan's house at Christmas");
 }
+
+fn advertised(response: &Response) -> Vec<String> {
+    header(response, "link")
+        .split(", <")
+        .filter(|entry| entry.contains("rels/technique"))
+        .filter_map(|entry| {
+            entry
+                .split("title=\"")
+                .nth(1)?
+                .split('"')
+                .next()
+                .map(str::to_owned)
+        })
+        .collect()
+}
+
+#[tokio::test]
+async fn links_offer_only_usable_techniques() {
+    let app = seeded_with(Floor::Bedroom, |run| run.foreskin = Some(1.0));
+    let cold = send(&app, "GET", "/runs/cafebabe", &[], "").await;
+    assert_eq!(advertised(&cold), ["warmup", "ice"]);
+    let warm = send(&app, "JELQ", "/runs/cafebabe?technique=warmup", &[], "").await;
+    let usable = advertised(&warm);
+    assert!(usable.contains(&"wet".to_owned()) && usable.contains(&"dry".to_owned()));
+    assert!(!usable.contains(&"uli".to_owned()), "uli needs the forum");
+    assert!(!usable.contains(&"pump".to_owned()), "pump needs a pump");
+    assert!(
+        header(&warm, "link").contains("title=\"wet\"; allow=\"JELQ\"; lubricant=\"required\"")
+    );
+
+    let (forum, _) = seeded(Floor::Forum);
+    let response = send(&forum, "GET", "/runs/cafebabe", &[], "").await;
+    assert!(advertised(&response).is_empty());
+}

Modified file: src/ui.html+97 additions−36 deletions@@ -50,7 +50,7 @@ Language <select id="locale"><option>en-GB</option><option>en-US</option><option
 <script>
 const REL = "https://jelq.dev/rels/";
 const METHODS = ["JELQ", "GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "TRACE"];
-const TECHNIQUES = ["warmup", "wet", "dry", "stretch", "uli", "edge", "pump", "ice", "supplement"];
+const LUBES = ["", "application/baby-oil", "application/coconut-oil", "application/lotion", "application/vaseline", "text/plain; charset=spit", "image/jpeg"];
 const DEATHS = ["vascular-event", "caught", "banned", "degloved", "zip", "run-ended"];
 const STATS = [
   ["x-floor", "Floor"],
@@ -67,12 +67,11 @@ const QUIET = new Set(["link", "set-cookie", "server", "x-powered-by", "cache-co
 
 const FIELDS = {
   seed: { label: "seed (unranked)", kind: "text" },
-  technique: { label: "technique", kind: "select", options: TECHNIQUES },
-  also: { label: "combo with", kind: "select", options: ["", "wet", "dry", "stretch", "uli"] },
+  technique: { label: "technique", kind: "select" },
+  also: { label: "combo with", kind: "select" },
   intensity: { label: "intensity, 1 to 10", kind: "number", value: "5" },
-  lube: { label: "Content-Type", header: "Content-Type", kind: "select", options: ["", "application/baby-oil", "application/coconut-oil", "application/lotion", "application/vaseline", "text/plain; charset=spit", "image/jpeg"] },
+  lube: { label: "Content-Type", header: "Content-Type", kind: "select" },
   patch: { label: "body", kind: "textarea", value: '[{"op": "test", "path": "/length", "value": 6}]' },
-  accept: { label: "Accept", header: "Accept", kind: "text" },
   range: { label: "Range", header: "Range", kind: "text", placeholder: "inches=0-2" },
   ifMatch: { label: "If-Match", header: "If-Match", kind: "text" },
   ifNoneMatch: { label: "If-None-Match", header: "If-None-Match", kind: "text" },
@@ -84,7 +83,6 @@ const FIELDS = {
 };
 const BY_TARGET = {
   "runs POST": ["seed"],
-  "run JELQ": ["technique", "also", "intensity", "lube"],
   "run PATCH": ["patch"],
   "length GET": ["range"],
   "length HEAD": ["range"],
@@ -102,6 +100,7 @@ const GLOBALS = [
 
 let run = null;
 let linked = [];
+let techniques = [];
 let offered = [];
 let challenged = false;
 let target = "/runs";
@@ -109,7 +108,6 @@ let method = "POST";
 const values = {};
 
 const $ = id => document.getElementById(id);
-const fieldValue = name => values[name] ?? FIELDS[name].value ?? (FIELDS[name].options ? FIELDS[name].options[0] : "");
 
 function short(path) {
   return path.replace(/[0-9a-f]{32}/, id => id.slice(0, 6) + "…");
@@ -121,6 +119,56 @@ function el(tag, props, ...children) {
   return node;
 }
 
+function titled(text) {
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
+function technique(name) {
+  return techniques.find(t => t.name === name);
+}
+
+function clashes(a, b) {
+  const rules = [a.lubricant, b.lubricant];
+  return rules.includes("required") && rules.includes("forbidden");
+}
+
+// The options a field can take right now, or null for free text.
+function options(name) {
+  if (name === "technique") return techniques.map(t => t.name);
+  if (name === "also") {
+    const first = technique(fieldValue("technique"));
+    if (!first || !first.lubricant) return [""];
+    const partners = techniques.filter(t => t.lubricant && t.name !== first.name && !clashes(first, t));
+    return [""].concat(partners.map(t => t.name));
+  }
+  if (name === "lube") return lubeRule() === "required" ? LUBES.filter(Boolean) : LUBES;
+  return FIELDS[name].options || null;
+}
+
+function raw(name) {
+  return values[name] ?? FIELDS[name].value ?? "";
+}
+
+function fieldValue(name) {
+  const allowed = options(name);
+  const value = raw(name);
+  if (allowed && !allowed.includes(value)) return allowed[0] ?? "";
+  return value;
+}
+
+function lubeRule() {
+  const picked = [technique(fieldValue("technique")), technique(fieldValue("also"))].filter(Boolean);
+  if (!picked.length || !picked[0].lubricant) return "none";
+  for (const rule of ["forbidden", "required"]) {
+    if (picked.some(t => t.lubricant === rule)) return rule;
+  }
+  return "optional";
+}
+
+function allowedMethods(t) {
+  return t.key === "run" && !techniques.length ? t.methods.filter(m => m !== "JELQ") : t.methods;
+}
+
 function targets() {
   return (run ? linked : []).concat(offered, GLOBALS);
 }
@@ -130,8 +178,9 @@ function current() {
 }
 
 function chooseTarget(t) {
+  const allowed = allowedMethods(t);
   target = t.path;
-  method = t.methods.includes("JELQ") ? "JELQ" : t.methods.find(m => m !== "HEAD" && m !== "OPTIONS") || t.methods[0];
+  method = allowed.includes("JELQ") ? "JELQ" : allowed.find(m => m !== "HEAD" && m !== "OPTIONS") || allowed[0];
   render();
 }
 
@@ -148,10 +197,6 @@ function renderStats(headers) {
   }
 }
 
-function titled(text) {
-  return text.charAt(0).toUpperCase() + text.slice(1);
-}
-
 function renderAlerts(list) {
   const box = $("alerts");
   box.replaceChildren();
@@ -179,9 +224,9 @@ function renderTargets() {
 function renderMethods() {
   const box = $("methods");
   box.replaceChildren();
-  const allowed = current().methods;
-  for (const m of METHODS) {
-    const radio = el("input", { type: "radio", name: "method", disabled: !allowed.includes(m), checked: m === method, onchange: () => { method = m; render(); } });
+  const allowed = allowedMethods(current());
+  for (const m of METHODS.filter(m => allowed.includes(m))) {
+    const radio = el("input", { type: "radio", name: "method", checked: m === method, onchange: () => { method = m; render(); } });
     const label = el("label", {}, radio, " ");
     label.append(m === "JELQ" ? el("big", {}, el("b", { textContent: "JELQ" })) : m);
     box.append(label, " ");
@@ -190,7 +235,15 @@ function renderMethods() {
 
 function fieldNames() {
   const t = current();
-  const names = BY_TARGET[t.key + " " + method] || [];
+  const key = t.key + " " + method;
+  let names = BY_TARGET[key] || [];
+  if (key === "run JELQ") {
+    const chosen = technique(fieldValue("technique"));
+    names = ["technique"];
+    if (options("also").length > 1) names.push("also");
+    if (chosen && chosen.lubricant) names.push("intensity");
+    if (["required", "optional"].includes(lubeRule())) names.push("lube");
+  }
   const scoped = run && !["runs", "global"].includes(t.key);
   const asked = challenged && scoped && !names.includes("authorization");
   return (asked ? ["authorization"] : []).concat(names);
@@ -202,18 +255,20 @@ function renderFields() {
   for (const name of fieldNames()) {
     const f = FIELDS[name];
     const value = fieldValue(name);
+    const choices = options(name);
     let input;
-    if (f.kind === "select") {
-      input = el("select", {}, ...f.options.map(o => el("option", { value: o, textContent: o || "(none)", selected: o === value })));
+    if (choices) {
+      input = el("select", {}, ...choices.map(o => el("option", { value: o, textContent: o || "(none)", selected: o === value })));
     } else if (f.kind === "textarea") {
       input = el("textarea", { rows: 3, cols: 40, value, placeholder: f.placeholder || "" });
     } else {
       input = el("input", { type: f.kind, value, placeholder: f.placeholder || "", size: 30 });
     }
-    input.oninput = input.onchange = () => { values[name] = input.value; };
+    input.oninput = () => { values[name] = input.value; };
+    input.onchange = () => { values[name] = input.value; if (choices) renderFields(); };
     table.append(el("tr", {}, el("td", { align: "right", valign: "top", textContent: f.label }), el("td", {}, input)));
   }
-  const extra = el("textarea", { rows: 3, cols: 40, value: fieldValue("extra"), placeholder: FIELDS.extra.placeholder });
+  const extra = el("textarea", { rows: 3, cols: 40, value: raw("extra"), placeholder: FIELDS.extra.placeholder });
   extra.oninput = () => { values.extra = extra.value; };
   const more = el("details", { open: Boolean(values.extra) }, el("summary", { textContent: "more headers" }), extra);
   table.append(el("tr", {}, el("td"), el("td", {}, more)));
@@ -221,21 +276,26 @@ function renderFields() {
 }
 
 function render() {
-  if (!current().methods.includes(method)) return chooseTarget(current());
+  if (!allowedMethods(current()).includes(method)) return chooseTarget(current());
   renderTargets();
   renderMethods();
   renderFields();
 }
 
 function parseLinks(header) {
-  const found = [];
+  const resources = [];
+  const moves = [];
   for (const match of header.matchAll(/<([^>]*)>((?:\s*;\s*[a-z-]+="[^"]*")*)/g)) {
     const params = Object.fromEntries([...match[2].matchAll(/([a-z-]+)="([^"]*)"/g)].map(p => [p[1], p[2]]));
     const name = (params.rel || "").replace(REL, "");
+    if (name === "technique") {
+      moves.push({ name: params.title, lubricant: params.lubricant || null });
+      continue;
+    }
     const methods = (params.allow || "GET").split(",").map(s => s.trim());
-    found.push({ key: name, name: name === "run" ? "the run" : name, path: match[1], methods });
+    resources.push({ key: name, name: name === "run" ? "the run" : name, path: match[1], methods });
   }
-  return found;
+  return [resources, moves];
 }
 
 function hrefs(value, found) {
@@ -277,21 +337,20 @@ function absorb(r, sentMethod, sentPath) {
   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 (sentPath.startsWith("/runs?") || sentPath === "/runs") {
-    if (r.status === 201) {
-      run = headers.location;
-      log("--- a new run has started at " + short(run) + " ---");
-    }
+  if (started) {
+    run = headers.location;
+    log("--- a new run has started at " + short(run) + " ---");
   }
   if ("x-eq" in headers) {
     renderStats(headers);
     renderAlerts(r.headers);
     challenged = r.status === 401 || "via" in headers;
   }
-  if (headers.link) linked = parseLinks(headers.link);
+  if (headers.link) [linked, techniques] = parseLinks(headers.link);
   offered = body ? hrefs(body, []) : [];
-  if (headers.location && !(sentPath === "/runs" || sentPath.startsWith("/runs?"))) {
+  if (headers.location && !started) {
     offered.unshift({ key: "offered", name: "Location", path: headers.location, methods: ["GET"] });
   }
   const abandoned = sentMethod === "DELETE" && sentPath === run && r.status === 204;
@@ -301,11 +360,11 @@ function absorb(r, sentMethod, sentPath) {
     challenged = false;
     run = null;
     linked = [];
+    techniques = [];
   }
-  const started = r.status === 201 && (sentPath === "/runs" || sentPath.startsWith("/runs?"));
   if (started || !targets().some(t => t.path === target)) {
     const home = linked.find(t => t.key === "run");
-    if (home) chooseTarget(home); else chooseTarget(GLOBALS[0]);
+    chooseTarget(home || GLOBALS[0]);
   } else {
     render();
   }
@@ -324,13 +383,15 @@ async function go(event) {
     if (f.header && value(name)) headers.push([f.header, value(name)]);
   }
   if (fieldNames().includes("upgrade") && value("upgrade")) headers.push(["Connection", "upgrade"]);
-  for (const line of value("extra").split("\n")) {
+  for (const line of raw("extra").split("\n")) {
     const at = line.indexOf(":");
     if (at > 0) headers.push([line.slice(0, at).trim(), line.slice(at + 1).trim()]);
   }
   if (key === "run JELQ") {
-    const techniques = value("also") ? value("technique") + "," + value("also") : value("technique");
-    path += "?technique=" + encodeURIComponent(techniques) + "&intensity=" + encodeURIComponent(value("intensity"));
+    const names = fieldNames();
+    const chosen = [value("technique")].concat(names.includes("also") && value("also") ? [value("also")] : []);
+    path += "?technique=" + encodeURIComponent(chosen.join(","));
+    if (names.includes("intensity")) path += "&intensity=" + encodeURIComponent(value("intensity"));
   }
   if (key === "runs POST" && value("seed")) path += "?seed=" + encodeURIComponent(value("seed"));
   if (method === "PATCH") {

jelq

Commit 58e1fb3943e6

Commit `58e1fb3943e6`