- table_no_cell.rs:1714 — self.bet = self.forced.big_blind → self.bet = actual

- table.rs:516 — self.bet.set(self.forced.big_blind) → self.bet.set(actual)
- Updated 4 existing tests that encoded the old incorrect semantics (assertions changed from 100 to 30)
- Added 1 new regression test table_no_cell_to_call_capped_at_short_stack_bb

Author: folkengine

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "pkcore"
 description = "Prototype core poker library."
-version = "0.0.47"
+version = "0.0.48"
 rust-version = "1.94.1"
 edition = "2024"
 authors = ["electronicpanopticon <gaoler@electronicpanopticon.com>"]

src/casino/table.rs

@@ -513,7 +513,7 @@ impl TableCelled {
     pub fn act_forced_bet_big_blind(&self) -> Result<(), PKError> {
         let bb_seat_num = self.determine_big_blind();
         let actual = self.act_forced_bet(bb_seat_num, self.forced.big_blind)?;
-        self.bet.set(self.forced.big_blind);
+        self.bet.set(actual);
         self.log_info(TableAction::ForcedBetBigBlind(bb_seat_num, actual));
         self.action_to_next();
 
@@ -2472,7 +2472,8 @@ mod casino__table_tests {
 
     #[test]
     fn forced_bets_short_bb_to_call_full_amount() {
-        // BB (seat 2) has only 30 chips; UTG (seat 0) must still call the full 100 BB.
+        // BB (seat 2) has only 30 chips; UTG (seat 0) calls only what BB posted (30),
+        // not the configured blind (100).
         let table = three_player_table_with_short_bb(30);
         table.act_forced_bets().unwrap();
 
@@ -2481,16 +2482,16 @@ mod casino__table_tests {
         assert_eq!(30, bb_seat.player.bet.count());
         drop(bb_seat);
 
-        assert_eq!(100, table.to_call(0));
+        assert_eq!(30, table.to_call(0));
     }
 
     #[test]
     fn act_call_after_short_blind() {
         let table = three_player_table_with_short_bb(30);
         table.act_forced_bets().unwrap();
-        // UTG (seat 0) calls — should commit 100 chips.
+        // UTG (seat 0) calls — commits only what BB actually posted (30).
         table.act_call(0).unwrap();
         let utg = table.seats.get_seat(0).unwrap();
-        assert_eq!(100, utg.player.bet.count());
+        assert_eq!(30, utg.player.bet.count());
     }
 }

src/casino/table_no_cell.rs

@@ -1711,7 +1711,7 @@ impl TableNoCell {
     pub fn act_forced_bet_big_blind(&mut self) -> Result<(), PKError> {
         let bb = self.determine_big_blind();
         let actual = self.seats.act_forced_bet(bb, self.forced.big_blind)?;
-        self.bet = self.forced.big_blind;
+        self.bet = actual;
         self.log(TableAction::ForcedBetBigBlind(bb, actual));
         self.log(TableAction::ActionTo(self.next_to_act()));
         Ok(())
@@ -3258,6 +3258,23 @@ mod tests {
         );
     }
 
+    // Regression: when BB is short-stacked, other players should only need to call
+    // what the BB actually posted, not the configured blind amount.
+    #[test]
+    fn table_no_cell_to_call_capped_at_short_stack_bb() {
+        // button=0: seat 0 = UTG/button, seat 1 = SB, seat 2 = BB (short-stacked)
+        let seats = SeatsNoCell::new(vec![
+            SeatNoCell::new(PlayerNoCell::new_with_chips("UTG".to_string(), 5_000)),
+            SeatNoCell::new(PlayerNoCell::new_with_chips("SB".to_string(), 5_000)),
+            SeatNoCell::new(PlayerNoCell::new_with_chips("BB".to_string(), 60)), // short-stacked
+        ]);
+        let mut table = TableNoCell::nlh_from_seats(seats, ForcedBets::new(50, 100));
+        table.act_forced_bets().unwrap();
+        let utg = table.determine_utg();
+        // UTG should call 60 (what BB actually posted), not 100 (the configured blind).
+        assert_eq!(60, table.to_call(utg));
+    }
+
     #[test]
     fn table_no_cell_bet_is_zero_before_blinds() {
         let table = make_two_player_table();
@@ -3287,7 +3304,8 @@ mod tests {
 
     #[test]
     fn table_no_cell_forced_bets_short_bb_to_call_full_amount() {
-        // BB (seat 2) has only 30 chips — posts all-in; UTG (seat 0) must still call 100.
+        // BB (seat 2) has only 30 chips — posts all-in; UTG (seat 0) needs to call
+        // only what BB actually posted (30), not the configured blind (100).
         let seats = SeatsNoCell::new(vec![
             SeatNoCell::new(PlayerNoCell::new_with_chips("UTG".to_string(), 5_000)),
             SeatNoCell::new(PlayerNoCell::new_with_chips("SB".to_string(), 5_000)),
@@ -3303,12 +3321,12 @@ mod tests {
         let _ = bb;
 
         let utg = table.determine_utg();
-        assert_eq!(100, table.to_call(utg));
+        assert_eq!(30, table.to_call(utg));
     }
 
     #[test]
     fn table_no_cell_act_call_after_short_blind() {
-        // BB (seat 2) short-stack; UTG (seat 0) calls — commits 100.
+        // BB (seat 2) short-stack; UTG (seat 0) calls — commits only what BB posted (30).
         let seats = SeatsNoCell::new(vec![
             SeatNoCell::new(PlayerNoCell::new_with_chips("UTG".to_string(), 5_000)),
             SeatNoCell::new(PlayerNoCell::new_with_chips("SB".to_string(), 5_000)),
@@ -3322,7 +3340,7 @@ mod tests {
         table.act_call(utg).unwrap();
 
         let utg_seat = table.seats.get_seat(utg).unwrap();
-        assert_eq!(100, utg_seat.player.bet);
+        assert_eq!(30, utg_seat.player.bet);
     }
 
     // ── Chip audit ────────────────────────────────────────────────────────────