Boti: pauza pred vedenim kopky, spravne poradie broadcastov po tahu

Bot doteraz vedel zahodit prvu kartu novej kopky uz po BOT_MOVE_DELAY_SECONDS
(0.8s), zatial co frontend zmetaciu animaciu predoslej kopky prehraval
1650ms -- karta tak "vyletela" uprostred zmetania. _run_bot_turns teraz pri
vedeni novej kopky caka TRICK_SWEEP_SECONDS (1.7s), zhodne s SETTLE_MS+
COLLECT_MS v GameTable.tsx.

_run_bot_turns tiez posielal player_cards PRED game_status (opacne ako
human play_card handler) -- pri prechode do noveho kola tak klient dostal
novu ruku skor, nez vedel, ze zacalo nove kolo, a fixne ju hned zobrazil.
Poradie broadcastov je teraz zhodne s human handlerom.

GameTable/Hand: ruka noveho kola sa zobrazi az po dobehnuti zmetacej
animacie poslednej kopky predchadzajuceho kola (displayedHand + freeze
efekt), a Hand.tsx rezervuje fixny priestor pre karty aj ked je ruka
docasne prazdna, aby layout neposkakoval.

tests/test_bots.py: nulovanie TRICK_SWEEP_SECONDS v setUpClass, aby testy
zostali rychle.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

frontend/src/components/Hand.tsx

@@ -26,7 +26,6 @@ interface Props {
 
 export default function Hand({ hand, myTurn, isPlayPhase, playableKeys, desktop = false }: Props) {
   const groups = groupedByColor(hand);
-  if (groups.length === 0) return null;
 
   const canPlay = isPlayPhase && myTurn;
 
@@ -52,20 +51,25 @@ export default function Hand({ hand, myTurn, isPlayPhase, playableKeys, desktop
         <div className="h-px flex-1 max-w-[80px] bg-gradient-to-l from-transparent to-gold/20" />
       </div>
 
-      {desktop ? (
-        // Desktop has room — keep cards grouped by suit, wrap if needed.
-        <div className="flex flex-wrap gap-3 justify-center items-end">
-          {groups.map(({ color, keys }) => (
-            <div key={color} className="flex gap-1 items-end">
-              {keys.map((key) => (
-                <CardView key={key} size="xl" {...cardProps(key)} />
-              ))}
-            </div>
-          ))}
-        </div>
-      ) : (
-        <MobileHand groups={groups} cardProps={cardProps} />
-      )}
+      {/* Fixed height reserves the card row even when the hand is briefly
+          empty (last card of a round just played, next deal not in yet) --
+          otherwise this whole area collapses and the layout jumps. */}
+      <div className="flex items-end justify-center" style={{ minHeight: desktop ? 100 : 84 }}>
+        {desktop ? (
+          // Desktop has room — keep cards grouped by suit, wrap if needed.
+          <div className="flex flex-wrap gap-3 justify-center items-end">
+            {groups.map(({ color, keys }) => (
+              <div key={color} className="flex gap-1 items-end">
+                {keys.map((key) => (
+                  <CardView key={key} size="xl" {...cardProps(key)} />
+                ))}
+              </div>
+            ))}
+          </div>
+        ) : (
+          <MobileHand groups={groups} cardProps={cardProps} />
+        )}
+      </div>
     </div>
   );
 }

frontend/src/pages/GameTable.tsx

@@ -15,7 +15,7 @@ import Standings from '../components/Standings';
 import PlayerCircle from '../components/PlayerCircle';
 import FaceDownCards from '../components/FaceDownCards';
 import GameOver from './GameOver';
-import type { PlayerInfo, StashData } from '../types';
+import type { Hand as HandCards, PlayerInfo, StashData } from '../types';
 
 // A completed trick stays face-up for SETTLE_MS (so the last card visibly joins
 // the pile), then is swept towards the winner over COLLECT_MS.
@@ -72,6 +72,37 @@ export default function GameTable() {
     };
   }, [previousStashKey]);
 
+  // A just-completed trick that hasn't been swept away yet always wins the centre
+  // — even once the winner has already led the next trick. The engine reveals that
+  // lead card (and, at a round boundary, the next bidding phase) the instant the
+  // 4th card lands, so without holding the pile here the sweep would be cut off
+  // after every trick. Reading `previousStash` synchronously (rather than a state
+  // set in an effect) also means the pile never blinks to empty on the frame the
+  // 4th card lands — the last card simply joins the three already there, then the
+  // whole pile is collected before the next trick takes over.
+  const finishing = previousStashKey !== null && previousStashKey !== dismissedKey;
+
+  // The new round's dealt hand arrives (via `player_cards`) the instant the last
+  // trick of the previous round is played, but the centre oval is still sweeping
+  // that trick away — hold an empty hand on screen (the previous round's last card
+  // really was just played, the engine just never broadcasts that "0 cards" beat on
+  // its own since it deals the new round in the same step) until the sweep finishes,
+  // so the new cards don't appear before the previous round has visibly wrapped up.
+  // Mid-round plays (round number unchanged) still update instantly, since that's
+  // just the player's own card leaving their hand, not a fresh deal.
+  const [displayedHand, setDisplayedHand] = useState<HandCards>(hand);
+  const lastAppliedRoundRef = useRef<number | null>(gameStatus?.round_number ?? null);
+  useEffect(() => {
+    if (!gameStatus) return;
+    const isNewRound = gameStatus.round_number !== lastAppliedRoundRef.current;
+    if (isNewRound && finishing) {
+      setDisplayedHand({}); // last card of the previous round is gone; new deal waits
+      return;
+    }
+    lastAppliedRoundRef.current = gameStatus.round_number;
+    setDisplayedHand(hand);
+  }, [hand, gameStatus, finishing]);
+
   if (!gameStatus || !myPlayer) {
     return <p className="text-center text-green-dim pt-20 font-serif italic">Načítava sa…</p>;
   }
@@ -95,15 +126,6 @@ export default function GameTable() {
   const myTurnToPlay = isPlayPhase && active_player === myOrder;
 
   const activeCards = active_stash ? Object.keys(active_stash.cards).length : 0;
-  // A just-completed trick that hasn't been swept away yet always wins the centre
-  // — even once the winner has already led the next trick. The engine reveals that
-  // lead card (and, at a round boundary, the next bidding phase) the instant the
-  // 4th card lands, so without holding the pile here the sweep would be cut off
-  // after every trick. Reading `previousStash` synchronously (rather than a state
-  // set in an effect) also means the pile never blinks to empty on the frame the
-  // 4th card lands — the last card simply joins the three already there, then the
-  // whole pile is collected before the next trick takes over.
-  const finishing = previousStashKey !== null && previousStashKey !== dismissedKey;
   const displayedStash: StashData | null = finishing
     ? previousStash
     : activeCards > 0 && active_stash
@@ -121,7 +143,7 @@ export default function GameTable() {
   const canPlayNow = myTurnToPlay && !finishing;
 
   const playableKeys = canPlayNow && active_stash
-    ? computePlayable(hand, active_stash.cards[String(active_stash.first_player)]?.color ?? null)
+    ? computePlayable(displayedHand, active_stash.cards[String(active_stash.first_player)]?.color ?? null)
     : undefined;
 
   const activePlayerName = displayName(players.find((p) => p.order === active_player)?.name);
@@ -244,7 +266,7 @@ export default function GameTable() {
   );
 
   const handArea = (
-    <Hand hand={hand} myTurn={canPlayNow} isPlayPhase={isPlayPhase} playableKeys={playableKeys} desktop={desktop} />
+    <Hand hand={displayedHand} myTurn={canPlayNow} isPlayPhase={isPlayPhase} playableKeys={playableKeys} desktop={desktop} />
   );
 
   // ── DESKTOP LAYOUT ───────────────────────────────────────────────