jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

66 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `98432b6057aa`

tarball

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

4 files changed+115-21

game: tell each technique of a combo in full

The 207 kept only each technique's status line, so a successful combo applied gains the player never saw. Each D:response now carries the JSON body that technique would have answered alone, plus its D:location for a 308.

Modified file: src/game/dispatch.rs+55 additions−11 deletions@@ -4,7 +4,7 @@ use super::{
 };
 use crate::problem::Problem;
 use axum::http::{StatusCode, header};
-use serde_json::json;
+use serde_json::{Value, json};
 use std::{fmt::Write as _, ops::ControlFlow};
 
 impl Run {
@@ -133,31 +133,45 @@ impl Run {
             return Ok(interrupted);
         }
 
-        let mut statuses = Vec::new();
+        let mut reports = Vec::new();
         for training in [a, b] {
             let result = self.roll(training, intensity, lube);
             if self.ended.is_some() {
                 return result;
             }
-            let status = match result {
-                Ok(outcome) => self.gossip(outcome).status(),
-                Err(problem) => problem.status(),
-            };
-            statuses.push((training, status));
+            reports.push((
+                training,
+                Report::of(result.map(|outcome| self.gossip(outcome))),
+            ));
         }
 
         let mut xml = String::from(
             "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<D:multistatus xmlns:D=\"DAV:\">\n",
         );
-        for (training, status) in statuses {
+        for (training, report) in reports {
             let _ = write!(
                 xml,
-                "  <D:response>\n    <D:href>{}?technique={}</D:href>\n    <D:status>HTTP/1.1 {} {}</D:status>\n  </D:response>\n",
+                "  <D:response>\n    <D:href>{}?technique={}</D:href>\n    <D:status>HTTP/1.1 {} {}</D:status>\n",
                 self.path(""),
                 training.name(),
-                status.as_u16(),
-                crate::problem::reason(status),
+                report.status.as_u16(),
+                crate::problem::reason(report.status),
             );
+            if let Some(location) = report.location {
+                let _ = writeln!(
+                    xml,
+                    "    <D:location><D:href>{}</D:href></D:location>",
+                    escape(&location)
+                );
+            }
+            if let Some(text) = report.text {
+                let _ = writeln!(
+                    xml,
+                    "    <D:responsedescription>{}</D:responsedescription>",
+                    escape(&text)
+                );
+            }
+            xml.push_str("  </D:response>\n");
         }
         xml.push_str(
             "  <D:responsedescription>Each technique has been reported separately.</D:responsedescription>\n</D:multistatus>\n",
@@ -169,3 +183,33 @@ impl Run {
         ))
     }
 }
+
+/// What one technique of a combo would have answered on its own.
+struct Report {
+    status: StatusCode,
+    location: Option<String>,
+    text: Option<String>,
+}
+
+impl Report {
+    fn of(result: Result<Outcome, Problem>) -> Self {
+        match result {
+            Ok(outcome) => Self {
+                status: outcome.status(),
+                location: outcome.header_value(&header::LOCATION).map(str::to_owned),
+                text: outcome.body().map(Value::to_string),
+            },
+            Err(problem) => Self {
+                status: problem.status(),
+                location: None,
+                text: Some(Value::Object(problem.document()).to_string()),
+            },
+        }
+    }
+}
+
+fn escape(text: &str) -> String {
+    text.replace('&', "&amp;")
+        .replace('<', "&lt;")
+        .replace('>', "&gt;")
+}

Modified file: src/game/outcome.rs+14 additions@@ -46,6 +46,20 @@ impl Outcome {
         self.status
     }
 
+    pub fn body(&self) -> Option<&Value> {
+        match &self.payload {
+            Payload::Json(body) => Some(body),
+            _ => None,
+        }
+    }
+
+    pub fn header_value(&self, name: &HeaderName) -> Option<&str> {
+        self.headers
+            .iter()
+            .find(|(n, _)| n == name)
+            .map(|(_, v)| v.as_str())
+    }
+
     pub(super) fn retold(mut self, status: StatusCode, detail: &str) -> Self {
         self.status = status;
         if let Payload::Json(body) = &mut self.payload {

Modified file: src/problem.rs+15 additions−10 deletions@@ -38,6 +38,20 @@ impl Problem {
         self
     }
 
+    pub fn document(&self) -> Map<String, Value> {
+        let problem = &self.0;
+        let mut body = Map::new();
+        body.insert(
+            "type".into(),
+            json!(format!("{PROBLEM_BASE}{}", problem.slug)),
+        );
+        body.insert("title".into(), json!(reason(problem.status)));
+        body.insert("status".into(), json!(problem.status.as_u16()));
+        body.insert("detail".into(), json!(problem.detail));
+        body.extend(problem.extensions.clone());
+        body
+    }
+
     pub fn header(mut self, name: HeaderName, value: impl AsRef<str>) -> Self {
         if let Ok(value) = HeaderValue::from_str(value.as_ref()) {
             self.0.headers.append(name, value);
@@ -57,17 +71,8 @@ pub fn reason(status: StatusCode) -> &'static str {
 
 impl IntoResponse for Problem {
     fn into_response(self) -> Response {
+        let body = self.document();
         let problem = *self.0;
-        let mut body = Map::new();
-        body.insert(
-            "type".into(),
-            json!(format!("{PROBLEM_BASE}{}", problem.slug)),
-        );
-        body.insert("title".into(), json!(reason(problem.status)));
-        body.insert("status".into(), json!(problem.status.as_u16()));
-        body.insert("detail".into(), json!(problem.detail));
-        body.extend(problem.extensions);
-
         let mut response = (problem.status, Json(body)).into_response();
         let headers = response.headers_mut();
         headers.insert(

Modified file: src/tests/body.rs+31 additions@@ -377,6 +377,37 @@ async fn a_combo_chafes_twice_and_costs_two_stamina() {
     assert_eq!(header(&combo, "x-stamina"), "8/10");
 }
 
+#[tokio::test]
+async fn a_combo_tells_each_technique_in_full() {
+    let mut told = 0;
+    for seed in 0..40 {
+        let app = app_with(Floor::Bedroom, seed, |run| run.body.eq = 60);
+        let lube = [("content-type", "application/baby-oil")];
+        let combo = send(
+            &app,
+            "JELQ",
+            "/runs/cafebabe?technique=wet,stretch",
+            &lube,
+            "",
+        )
+        .await;
+        if combo.status() != StatusCode::MULTI_STATUS {
+            continue;
+        }
+        for report in text(combo).await.split("<D:response>").skip(1) {
+            if report.contains("HTTP/1.1 204") {
+                continue;
+            }
+            assert!(
+                report.contains("<D:responsedescription>{\"") && report.contains("\"detail\""),
+                "{report}"
+            );
+            told += 1;
+        }
+    }
+    assert!(told > 0, "no combo told anything in forty runs");
+}
+
 #[test]
 fn the_drawer_starts_with_at_most_one_bottle() {
     let mut stocked = 0;

jelq

Commit 98432b6057aa

Commit `98432b6057aa`