Make an absent chiamata bidder pass instead of bidding randomly

The auction timeout bid a random legal rank, which could hand the
auction (and the call) to a disconnected player. An absent bidder now
always passes; only the last player standing before any bid cannot
pass, and is made to bid the ace - its suit is picked at random by the
existing call timeout. This keeps a deal from stalling without a caller
while never letting an absent player outbid someone.

The deadline log line now says which of the two happened.

server/packages/tavolo-briscola/README.md

@@ -41,9 +41,11 @@ Three variants share one rules core:
 Timeouts are constructor arguments (`turn_timeout_seconds`,
 `hand_ack_timeout_seconds`), wired from the environment by the
 application composition root. Briscola chiamata uses the turn timeout
-for its auction bids, the called-card choice and the plays; it never
-enters the between-deals acknowledgement phase (a single deal ends the
-match), so the hand-ack timeout is accepted but unused.
+for its auction turns, the called-card choice and the plays: an absent
+bidder passes, the last player standing with no bid is made to bid the
+ace, and an absent winner's call names a random suit of the won rank. It
+never enters the between-deals acknowledgement phase (a single deal ends
+the match), so the hand-ack timeout is accepted but unused.
 
 ## Rules
 

server/packages/tavolo-briscola/src/tavolo/briscola/chiamata.py

@@ -797,12 +797,13 @@ def _end_deal(state: ChiamataState) -> None:
 # -- server-side auto actions ---------------------------------------------------
 
 
-def auto_bid(state: ChiamataState, rng: Optional[random.Random] = None) -> None:
-    """Act for the bidder on turn: bid a random legal rank, else pass.
+def auto_bid(state: ChiamataState) -> None:
+    """Act for the bidder on turn: always pass, unless forced to bid.
 
-    The only player who cannot afford to pass — the last one standing
-    before any bid — always has every rank available, so a bid is always
-    possible there.
+    An absent player never outbids anyone: they leave the auction. Only
+    the last player standing before any bid cannot pass — they are made
+    to bid the ace, whose suit :func:`auto_call` picks at random if the
+    call itself times out too.
     """
     if state.phase != PHASE_AUCTION:
         raise GameNotStarted("the auction is not open")
@@ -810,10 +811,8 @@ def auto_bid(state: ChiamataState, rng: Optional[random.Random] = None) -> None:
     if auction is None:  # pragma: no cover - guarded by phase
         raise GameNotStarted("the auction is not open")
     player = _player_at(state, auction.turn)
-    ranks = legal_bid_ranks(state)
-    if ranks:
-        chooser = rng or _rng
-        bid_rank(state, player.sub, chooser.choice(ranks))
+    if len(auction.active) == 1 and auction.current is None:
+        bid_rank(state, player.sub, 1)
         return
     pass_auction(state, player.sub)
 

server/packages/tavolo-briscola/src/tavolo/briscola/plugin.py

@@ -485,10 +485,18 @@ class BriscolaChiamataEngine(GameEngine):
         state: ChiamataState = session.state
         if kind == "auction":
             seat = state.turn
+            auction = state.auction
+            passed_before = len(auction.passed) if auction is not None else 0
             chiamata.auto_bid(state)
+            action = (
+                "auto-passed"
+                if auction is not None and len(auction.passed) > passed_before
+                else "forced to bid the ace"
+            )
             log.info(
-                "auto-bid for seat %s (auction timeout, deal %d)",
+                "seat %s %s (auction timeout, deal %d)",
                 seat,
+                action,
                 state.hand_number,
             )
         elif kind == "call":

server/packages/tavolo-briscola/tests/test_chiamata.py

@@ -240,18 +240,43 @@ class AuctionTest(unittest.TestCase):
         self.assertEqual(63, view["legal_bids"]["points_min"])
         self.assertEqual(120, view["legal_bids"]["points_max"])
 
-    def test_auto_bid_bids_or_passes(self) -> None:
+    def test_auto_bid_always_passes_when_legal(self) -> None:
         state = started_state()
-        rules.auto_bid(state, random.Random(1))
         assert state.auction is not None
-        self.assertIsNotNone(state.auction.current)
-        # The auction keeps moving and eventually concludes.
-        for _ in range(50):
-            if state.phase != PHASE_AUCTION:
-                break
-            rules.auto_bid(state, random.Random(2))
+        rules.auto_bid(state)
+        # Seat 1 passes: nobody has bid and the turn moves on.
+        self.assertEqual([1], state.auction.passed)
+        self.assertIsNone(state.auction.current)
+        self.assertEqual(2, state.auction.turn)
+        # An absent bidder still passes when there is a standing bid.
+        rules.bid_rank(state, "p2", 10)
+        rules.auto_bid(state)
+        self.assertEqual([1, 3], state.auction.passed)
+        assert state.auction.current is not None
+        self.assertEqual(10, state.auction.current.rank)
+
+    def test_auto_bid_passes_at_the_point_stage(self) -> None:
+        state = started_state()
+        rules.bid_rank(state, "p1", 2)
+        rules.bid_points(state, "p2", 62)
+        rules.auto_bid(state)  # seat 3
+        assert state.auction is not None
+        self.assertIn(3, state.auction.passed)
+        assert state.auction.current is not None
+        self.assertEqual(62, state.auction.current.points)
+
+    def test_auto_bid_forced_to_call_the_ace(self) -> None:
+        state = started_state()
+        for seat in (1, 2, 3, 4):
+            rules.pass_auction(state, f"p{seat}")
+        # Seat 0 is the last one standing and nobody has bid yet: the
+        # forced auto-bid calls the ace.
+        rules.auto_bid(state)
         self.assertEqual(PHASE_CALLING, state.phase)
-        self.assertIsNotNone(state.caller)
+        self.assertEqual(0, state.caller)
+        assert state.auction is not None and state.auction.current is not None
+        self.assertEqual(1, state.auction.current.rank)
+        self.assertEqual(61, state.declared_target)
 
 
 class CallTest(unittest.TestCase):
@@ -543,7 +568,7 @@ class ScoringTest(unittest.TestCase):
         moves = 0
         while state.phase != PHASE_FINISHED and moves < 5000:
             if state.phase == PHASE_AUCTION:
-                rules.auto_bid(state, rng)
+                rules.auto_bid(state)
             elif state.phase == PHASE_CALLING:
                 rules.auto_call(state, rng)
             else: