jelq

public

an http based roguelike rpg about jelqing

Star0

Fork 0

Watch0

91 commits 1 branch 0 tags 0 releases1.3 MiB

Commit `53bce0d93000`

tarball

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

5 files changed+58-15

game: judge ruptures by the cooler of the turn's start and its end

EQ moves mid-turn before the rupture checks, so one hard stroke could carry a run from Ideal past a line and rupture it there, and X-EQ never got to warn. The new tier now has to survive one response before it can rupture anything.

Modified file: src/game/body.rs+3 additions@@ -13,6 +13,8 @@ pub struct Body {
     pub(crate) foreskin: Option<f64>,
     pub(crate) inflation: f64,
     pub(crate) eq: i32,
+    /// `heat` as the current turn began, so no rupture is judged hotter than the turn started.
+    pub(crate) heat_at_turn_start: i32,
     pub(crate) stamina: i32,
     pub(crate) friction: i32,
     pub(crate) grip: Grip,
@@ -34,6 +36,7 @@ impl Body {
             foreskin: Some(foreskin),
             inflation,
             eq: STARTING_EQ,
+            heat_at_turn_start: STARTING_EQ,
             stamina: MAX_STAMINA,
             friction: 0,
             grip: Grip::Overhand,

Modified file: src/game/hazards.rs+24 additions−12 deletions@@ -20,21 +20,31 @@ use crate::problem::Problem;
 type Interruption = Result<ControlFlow<Outcome>, Problem>;
 
 impl Run {
-    /// Whether EQ is past `line`, with a friction burn dragging every line down.
-    pub(super) fn hotter_than(&self, line: i32) -> bool {
+    /// EQ with a friction burn dragging every line down.
+    pub(super) fn heat(&self) -> i32 {
         let burn = if self.body.conditions.friction_burn {
             BURN_RUPTURE
         } else {
             0
         };
-        self.body.eq > line - burn
+        self.body.eq + burn
+    }
+
+    pub(super) fn hotter_than(&self, line: i32) -> bool {
+        self.heat() > line
+    }
+
+    /// Ruptures go by the cooler of now and the turn's start, so a line crossed this turn cannot rupture
+    /// before `X-EQ` has had a chance to name it.
+    pub(super) fn risked(&self, line: i32) -> bool {
+        self.heat().min(self.body.heat_at_turn_start) > line
     }
 
     /// The rupture tier for any turn that is not a jelq, so never the premature band's 1 in 3.
     pub(super) fn rupture_odds(&self) -> u32 {
-        if !self.hotter_than(DANGER_EQ) {
+        if !self.risked(DANGER_EQ) {
             RUPTURE_IN_BAND
-        } else if !self.hotter_than(HOT_EQ) {
+        } else if !self.risked(HOT_EQ) {
             RUPTURE_WARM
         } else {
             RUPTURE_HOT
@@ -183,13 +193,15 @@ impl Run {
             .header(header::CONNECTION, "close"));
         }
         if self.hotter_than(PREMATURE_EQ) {
-            if self.chance(
-                self.decision(
-                    "rupture",
-                    "Right at the edge of finishing, does it rupture instead?",
-                ),
-                RUPTURE_PREMATURE,
-            ) {
+            if self.risked(PREMATURE_EQ)
+                && self.chance(
+                    self.decision(
+                        "rupture",
+                        "Right at the edge of finishing, does it rupture instead?",
+                    ),
+                    RUPTURE_PREMATURE,
+                )
+            {
                 return Err(self.rupture());
             }
             self.standing.shame += 5;

Modified file: src/game/roll.rs+3 additions−3 deletions@@ -49,10 +49,10 @@ impl Run {
             return Err(timed(self.critical_failure(training, &profile)));
         }
         self.here.warm_arrival = false;
-        if natural == 2 && self.hotter_than(DANGER_EQ) {
+        if natural == 2 && self.risked(DANGER_EQ) {
             return Err(timed(self.rupture()));
         }
-        if self.hotter_than(rupture_line) && total < dc {
+        if self.risked(rupture_line) && total < dc {
             return Err(timed(self.rupture()));
         }
         if natural == 20 {
@@ -178,7 +178,7 @@ impl Run {
             .with("foreskin", -round3(lost))
             .header(header::CONTENT_LOCATION, self.path("/foreskin"));
         }
-        if self.hotter_than(DANGER_EQ) {
+        if self.risked(DANGER_EQ) {
             return self.rupture();
         }
         if training == Training::Stretch && !self.here.teapot {

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

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

163163 self.here.turns += 1;

164164 self.body.torn = 0.0;

165165 self.standing.at_turn_start = self.standing.suspicion;

166+ self.body.heat_at_turn_start = self.heat();

166167 self.realise(false);

167168 if self.floor.timed() && self.here.turns + 2 == FLOOR_LIMIT {

168169 self.notices.push(Notice::RunningLong(self.floor));

Modified file: src/tests/rolls.rs+27 additions@@ -227,3 +227,30 @@ async fn degloving_takes_one_cold_stroke_in_twenty() {
         "{degloved} degloved in 1200 cold strokes, about 60 expected"
     );
 }
+
+#[tokio::test]
+async fn a_turn_cannot_rupture_for_heat_it_only_just_reached() {
+    let mut ruptured = 0;
+    for seed in 0..300u64 {
+        let app = app_with(Floor::Bedroom, seed, |run| run.body.eq = 70);
+        let turn = send(
+            &app,
+            "JELQ",
+            "/runs/cafebabe?technique=stretch&intensity=10",
+            &[],
+            "",
+        )
+        .await;
+        if turn
+            .headers()
+            .get("x-run-over")
+            .is_some_and(|v| v == "ruptured")
+        {
+            ruptured += 1;
+        }
+    }
+    assert!(
+        ruptured <= 6,
+        "Ideal at the start of the turn kept the in-band 1 in 250, but {ruptured} of 300 ruptured"
+    );
+}

jelq

Commit 53bce0d93000

Commit `53bce0d93000`