belote-cli 2.9.0__tar.gz → 2.9.2__tar.gz

{belote_cli-2.9.0 → belote_cli-2.9.2}/CHANGELOG.md

@@ -5,6 +5,44 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.9.2] - 2026-05-07
+
+Render-pipeline fix for Konsole (KDE/Kubuntu) and other strict ANSI terminals where UI elements visibly stacked on top of each other — the top HUD repeating ~6 times, "Theme: Sepia Vintage" duplicating in the right column, "Partner" doubling, the bid prompt repainting below itself, and bid history accumulating between frames. The bug existed in the code on every terminal but VTE-based emulators (LXTerminal, GNOME Terminal, xterm) auto-blanked the leaking cells, masking it. Konsole's Vt102Emulation does not, so the leakage was visible.
+
+### Fixed
+
+- **`src/belote/ui/render.py::render`** — the bidding selector (Round 1 inline highlighted Take/Pass; Round 2 boxed grid; optional `partner_bid_tendency_text` line) is now painted inside the main render frame via the new `bid_selection: int | None` parameter on `render()` and `display()`. Previously `prompt_bid` paid display() and then wrote 8+ extra `\r\n` lines, which scrolled the alt-screen on the bottom row and left stale rows that the next frame's blank padding never repainted.
+- **`src/belote/ui/render.py::render`** — every line in the rendered frame now ends with `clear_to_eol()` (`\x1b[K`), including blank vertical-centering padding rows. The previous `line + clear_to_eol() if line else line` branch skipped the escape on padding rows, betting the previous frame's content area had already cleared them — but that bet broke whenever an external write (announcement, prompt artifact) deposited debris on a padding row. Cost is one 3-byte escape per row; benefit is correct rendering on any ANSI-compliant terminal regardless of strictness.
+- **`src/belote/ui/prompts.py::prompt_bid`** — gutted of all post-`display()` `sys.stdout.write` calls. Each loop iteration is now a single `display(state, None, bid_selection=sel)` + `reader.read()`. Removed unused `REVERSE` and `black_fg` imports (the box-rendering code that consumed them moved to `render.py::_build_bid_prompt_lines`).
+- **`src/belote/ui/announce.py::announce`** — replaced the `\r\n`-bracketed banner with absolute cursor positioning (`move(term_h - 1, 1) + clear_line()`) so the banner can never trigger a scroll, even when the cursor is parked on the bottom row of the alt-screen.
+
+### Added
+
+- **`src/belote/ui/render.py::_build_bid_prompt_lines`** — pure helper that returns the in-frame bidding selector lines. Encapsulates the Round 1 inline form, the Round 2 60-column boxed form, and the optional partner-tendency line so the main render loop reads as one coherent paint.
+
+### Notes
+
+No gameplay, scoring, or AI changes. 435/435 tests pass. The fix is observable when running under Konsole — start a Belote round, force a Round 2 bid (pass on the up-card), and arrow-navigate the selector: previously the box stacked between iterations; now it repaints in place.
+
+## [2.9.1] - 2026-05-06
+
+UI polish patch on top of 2.9.0. Two pieces of menu art had drifted; this release fixes both and tightens the menu plumbing so the cup walls hold for every label combination.
+
+### Fixed
+
+- **`src/belote/ui/menu.py::get_cards_art`** — the croissant Braille had a corrupted line 8 (`⠘⢿⡿⠋⣠⣾⣿⣿⣿⠟⠁⣿⣿⣿⣿⣿⠟⢁⣀`, 21 cells) that broke the right curl, and was missing the 13th-line `⠉⠉⠉` crumb under the tip entirely. Restored to the canonical 13-line, 25-cell-wide reference. Each line now uses U+2800 Braille blanks for its leading indent (uniform 25-cell width) rather than mixed ASCII spaces, so callers don't have to re-pad.
+- **`src/belote/ui/menu.py::CUP_TEMPLATE`** — body inner width was 47 chars (29-char opt + 16 trailing dead space + 2 gutter), much wider than the 23-char lid and saucer. Now 29 chars flush so menu options sit between the cup walls with no padding. Steam line 2 now correctly shows the two-puff frame (`)     (`) — previously the template's leading-indent disagreement with `STEAMS[..][1]` pushed the second puff out of view.
+- **`src/belote/ui/menu.py::_render_main_menu_art`** — selected-row markers tightened from ` > {label} < ` (6-char overhead) to `> {label} <` (4-char overhead) so the selected row uses the same width budget as unselected (`  {label}  `, also 4-char overhead). Without this, a selected `Theme: < Sepia Vintage >` would bust the right cup wall.
+- **`src/belote/ui/menu.py::show_main_menu`** — settings labels shortened to fit the new 25-char usable label width: `AI Config:` → `AI:`, `Target Score:` → `Target:`. `Speed:` and `Theme:` keep their names with tightened spacing. All four `<` markers still column-align.
+
+### Changed
+
+- **`src/belote/ui/menu.py::_render_main_menu_art`** — opt-slot loop and assertion bound dropped from 12 → 9 to match the new template. The error message ("add opt slots to CUP_TEMPLATE") still points at the right fix if the menu ever grows past 9 entries.
+
+### Notes
+
+No gameplay or scoring changes; classic and BelAtro behavior is bit-for-bit identical. 435/435 tests pass; ruff and mypy clean on `src/`. Pre-existing lint/type debt in `tests/` and `scripts/benchmark.py` (18 ruff, 69 mypy strict-mode annotations) is untouched and tracked separately.
+
 ## [2.9.0] - 2026-05-06
 
 Audit-driven sweep on top of 2.8.0: four engine bugs fixed and the long-deferred Tout Atout / Sans Atout bidding affordance shipped end-to-end. The README's "future work" line for those contracts is gone — both contracts are now bidable in classic Belote and BelAtro, and the two jokers / two unlock counters that had been waiting on the affordance now fire in real play. Plan: `plans/bug-hunt-code-performance-elegant-starlight.md`.

{belote_cli-2.9.0 → belote_cli-2.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: belote-cli
-Version: 2.9.0
+Version: 2.9.2
 Summary: A 4-player terminal card game
 Project-URL: Homepage, https://github.com/ElysiumDisc/belote
 Project-URL: Repository, https://github.com/ElysiumDisc/belote
@@ -88,18 +88,19 @@ belatro
 
 ### Main Menu
 ```text
-      ⢠⣴⣶⣶⣶⣄
-      ⣿⣿⣿⣿⣿⣿⣦
-     ⢰⣿⣿⣿⣿⡿⠟⠁⣠⣴⣶⣦⠄
-     ⢸⣿⣿⠟⠉⣠⣴⣿⣿⣿⠟⠁⣠⣾⣿⣦⡀
-      ⠉⣀⣴⣾⣿⣿⣿⠟⢁⣤⣾⣿⣿⣿⣿⣿⡆
-    ⢀⣤⣾⣿⣿⣿⡿⠛⢁⣴⣿⣿⣿⡿⠛⢁⣴⣿⣿⣿⣿⣿⣿⣿⠟⠁⡀
-    ⢼⣿⣿⣿⡿⠋⣀⣴⣿⣿⣿⣿⣿⣿⣿⡿⠉⣠⣾⣿⡆
-    ⠘⢿⡿⠋⣠⣾⣿⣿⣿⠟⠁⣿⣿⣿⣿⣿⠟⢁⣀
-      ⣠⣾⣿⣿⣿⣿⣿⣿⣿⣿⠏⢀⣴⣿⣿⣿⠋⢠⣾⣿⣷⣦⡀
-      ⢻⣿⣿⣿⣿⣿⣿⣿⠟⢁⣴⣿⣿⣿⡿⠁⣰⣿⣿⣿⣿⣿⣿
-       ⠹⢿⣿⣿⣿⡿⠋⣠⣾⣿⣿⣿⠟⢀⣼⣿⣿⣿⣿⣿⣿⡟
-         ⠉⠉⠉⠀⢾⣿⣿⣿⣿⠋⠀⠚⠛⠛⠛⠛⠛⠛⠁
+  ⢠⣴⣶⣶⣶⣄
+  ⣿⣿⣿⣿⣿⣿⣦
+ ⢰⣿⣿⣿⣿⡿⠟⠁⣠⣴⣶⣦⠄
+ ⢸⣿⣿⠟⠉⣠⣴⣿⣿⣿⠟⠁⣠⣾⣿⣦⡀
+  ⠉⣀⣴⣾⣿⣿⣿⠟⢁⣤⣾⣿⣿⣿⣿⣿⡆
+⢀⣤⣾⣿⣿⣿⡿⠛⢁⣴⣿⣿⣿⣿⣿⣿⣿⠟⠁⡀
+⢼⣿⣿⣿⡿⠋⣀⣴⣿⣿⣿⣿⣿⣿⣿⡿⠉⣠⣾⣿⡆
+⠘⢿⡿⠋⣠⣾⣿⣿⣿⣿⣿⣿⣿⡿⠋⢀⣾⣿⣿⠟⢁⣀
+  ⣠⣾⣿⣿⣿⣿⣿⣿⣿⣿⠏⢀⣴⣿⣿⣿⠋⢠⣾⣿⣷⣦⡀
+  ⢻⣿⣿⣿⣿⣿⣿⣿⠟⢁⣴⣿⣿⣿⡿⠁⣰⣿⣿⣿⣿⣿⣿
+   ⠹⢿⣿⣿⣿⡿⠋⣠⣾⣿⣿⣿⠟⢀⣼⣿⣿⣿⣿⣿⣿⡟
+     ⠉⠉⠉ ⢾⣿⣿⣿⣿⠋ ⠚⠛⠛⠛⠛⠛⠛⠁
+          ⠉⠉⠉
 
                        (
                         )     (
@@ -107,12 +108,17 @@ belatro
              .-''       )    (          ''-.
        .-'``'|-._             )         _.-|
       /  .--.|   `''---...........---''`   |
-     /  /    |       > Start Game <        |
-     |  |    |     Difficulty: Medium      |
-      \  \   |    Target Score: 1000       |
-       `\ `\ |       Speed: Normal         |
-         `\ `|      Rules & History        |
-         _/ /\           Quit              /
+     /  /    |           BelAtro           |
+     |  |    |       > Start Game <        |
+     |  |    |      AI:     < Hard >       |
+     |  |    |      Target: < 1000 >       |
+     |  |    |     Speed:  < Normal >      |
+     |  |    |  Theme:  < Classic Green >  |
+     |  |    |       Rules & History       |
+      \  \   |         Statistics          |
+       `\ `\ |            Quit             |
+         `\ `|                             |
+         _/ /\                             /
         (__/  \                           /
      _..---''` \                         /`''---.._
   .-'           \                       /          '-.
@@ -289,3 +295,5 @@ This will wipe all global statistics and reset your discovered item Almanac in B
 ## Terminal Hygiene
 
 Signal handlers (SIGINT, SIGTERM) and atexit hooks ensure the terminal is always restored — cursor visible, colors reset, alt-screen off — even after Ctrl+C or crashes.
+
+Every rendered row ends with `\x1b[K` (clear-to-end-of-line) and every interactive prompt (bid selector, card selector, full-screen overlays) repaints in a single in-frame pass — no `\r\n`-bracketed writes outside the render. This keeps the game free of stale-cell artifacts on strict ANSI emulators like Konsole (KDE), in addition to the more lenient VTE-based terminals (GNOME Terminal, LXTerminal, xterm).

{belote_cli-2.9.0 → belote_cli-2.9.2}/README.md

@@ -45,18 +45,19 @@ belatro
 
 ### Main Menu
 ```text
-      ⢠⣴⣶⣶⣶⣄
-      ⣿⣿⣿⣿⣿⣿⣦
-     ⢰⣿⣿⣿⣿⡿⠟⠁⣠⣴⣶⣦⠄
-     ⢸⣿⣿⠟⠉⣠⣴⣿⣿⣿⠟⠁⣠⣾⣿⣦⡀
-      ⠉⣀⣴⣾⣿⣿⣿⠟⢁⣤⣾⣿⣿⣿⣿⣿⡆
-    ⢀⣤⣾⣿⣿⣿⡿⠛⢁⣴⣿⣿⣿⡿⠛⢁⣴⣿⣿⣿⣿⣿⣿⣿⠟⠁⡀
-    ⢼⣿⣿⣿⡿⠋⣀⣴⣿⣿⣿⣿⣿⣿⣿⡿⠉⣠⣾⣿⡆
-    ⠘⢿⡿⠋⣠⣾⣿⣿⣿⠟⠁⣿⣿⣿⣿⣿⠟⢁⣀
-      ⣠⣾⣿⣿⣿⣿⣿⣿⣿⣿⠏⢀⣴⣿⣿⣿⠋⢠⣾⣿⣷⣦⡀
-      ⢻⣿⣿⣿⣿⣿⣿⣿⠟⢁⣴⣿⣿⣿⡿⠁⣰⣿⣿⣿⣿⣿⣿
-       ⠹⢿⣿⣿⣿⡿⠋⣠⣾⣿⣿⣿⠟⢀⣼⣿⣿⣿⣿⣿⣿⡟
-         ⠉⠉⠉⠀⢾⣿⣿⣿⣿⠋⠀⠚⠛⠛⠛⠛⠛⠛⠁
+  ⢠⣴⣶⣶⣶⣄
+  ⣿⣿⣿⣿⣿⣿⣦
+ ⢰⣿⣿⣿⣿⡿⠟⠁⣠⣴⣶⣦⠄
+ ⢸⣿⣿⠟⠉⣠⣴⣿⣿⣿⠟⠁⣠⣾⣿⣦⡀
+  ⠉⣀⣴⣾⣿⣿⣿⠟⢁⣤⣾⣿⣿⣿⣿⣿⡆
+⢀⣤⣾⣿⣿⣿⡿⠛⢁⣴⣿⣿⣿⣿⣿⣿⣿⠟⠁⡀
+⢼⣿⣿⣿⡿⠋⣀⣴⣿⣿⣿⣿⣿⣿⣿⡿⠉⣠⣾⣿⡆
+⠘⢿⡿⠋⣠⣾⣿⣿⣿⣿⣿⣿⣿⡿⠋⢀⣾⣿⣿⠟⢁⣀
+  ⣠⣾⣿⣿⣿⣿⣿⣿⣿⣿⠏⢀⣴⣿⣿⣿⠋⢠⣾⣿⣷⣦⡀
+  ⢻⣿⣿⣿⣿⣿⣿⣿⠟⢁⣴⣿⣿⣿⡿⠁⣰⣿⣿⣿⣿⣿⣿
+   ⠹⢿⣿⣿⣿⡿⠋⣠⣾⣿⣿⣿⠟⢀⣼⣿⣿⣿⣿⣿⣿⡟
+     ⠉⠉⠉ ⢾⣿⣿⣿⣿⠋ ⠚⠛⠛⠛⠛⠛⠛⠁
+          ⠉⠉⠉
 
                        (
                         )     (
@@ -64,12 +65,17 @@ belatro
              .-''       )    (          ''-.
        .-'``'|-._             )         _.-|
       /  .--.|   `''---...........---''`   |
-     /  /    |       > Start Game <        |
-     |  |    |     Difficulty: Medium      |
-      \  \   |    Target Score: 1000       |
-       `\ `\ |       Speed: Normal         |
-         `\ `|      Rules & History        |
-         _/ /\           Quit              /
+     /  /    |           BelAtro           |
+     |  |    |       > Start Game <        |
+     |  |    |      AI:     < Hard >       |
+     |  |    |      Target: < 1000 >       |
+     |  |    |     Speed:  < Normal >      |
+     |  |    |  Theme:  < Classic Green >  |
+     |  |    |       Rules & History       |
+      \  \   |         Statistics          |
+       `\ `\ |            Quit             |
+         `\ `|                             |
+         _/ /\                             /
         (__/  \                           /
      _..---''` \                         /`''---.._
   .-'           \                       /          '-.
@@ -246,3 +252,5 @@ This will wipe all global statistics and reset your discovered item Almanac in B
 ## Terminal Hygiene
 
 Signal handlers (SIGINT, SIGTERM) and atexit hooks ensure the terminal is always restored — cursor visible, colors reset, alt-screen off — even after Ctrl+C or crashes.
+
+Every rendered row ends with `\x1b[K` (clear-to-end-of-line) and every interactive prompt (bid selector, card selector, full-screen overlays) repaints in a single in-frame pass — no `\r\n`-bracketed writes outside the render. This keeps the game free of stale-cell artifacts on strict ANSI emulators like Konsole (KDE), in addition to the more lenient VTE-based terminals (GNOME Terminal, LXTerminal, xterm).

{belote_cli-2.9.0 → belote_cli-2.9.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "belote-cli"
-version = "2.9.0"
+version = "2.9.2"
 description = "A 4-player terminal card game"
 readme = "README.md"
 requires-python = ">=3.10"

{belote_cli-2.9.0 → belote_cli-2.9.2}/src/belote/__init__.py

@@ -1,3 +1,3 @@
-__version__ = "2.8.0"
+__version__ = "2.9.2"
 
 __all__ = ["__version__"]

{belote_cli-2.9.0 → belote_cli-2.9.2}/src/belote/ui/announce.py

@@ -12,9 +12,11 @@ from ..ansi import (
     ansi_center,
     banner_bg,
     banner_fg,
+    clear_line,
     clear_screen,
     gold_fg,
     hide_cursor,
+    move,
     white_fg,
 )
 from ..context import AUDIO
@@ -33,8 +35,19 @@ def toggle_mute() -> bool:
 
 
 def announce(message: str, duration: float = 2.0, reader: KeyReader | None = None) -> None:
-    """Display a transient announcement banner."""
-    sys.stdout.write(f"\r\n{banner_bg()}{banner_fg()}  {BOLD} {message} {RESET}\r\n")
+    """Display a transient announcement banner.
+
+    Painted with absolute cursor positioning + clear_line so it never triggers
+    a scroll, even when the cursor is parked on the bottom row of the alt
+    screen. Writing \\r\\n at the bottom row scrolls the alt-screen on Konsole
+    and other strict emulators, which leaks the previous frame onto rows the
+    next render's blank padding doesn't repaint.
+    """
+    term_w, term_h = get_term_size()
+    banner = ansi_center(
+        f"{banner_bg()}{banner_fg()}  {BOLD} {message} {RESET}", term_w
+    )
+    sys.stdout.write(move(max(1, term_h - 1), 1) + clear_line() + banner)
     sys.stdout.flush()
     if reader and duration > 0:
         interruptible_sleep(duration, reader)

{belote_cli-2.9.0 → belote_cli-2.9.2}/src/belote/ui/menu.py

@@ -25,43 +25,48 @@ from .render import get_term_size
 
 
 def get_cards_art() -> list[str]:
-    """Return the cards logo art with current theme colors."""
+    """Return the croissant art with current theme colors.
+
+    Each line is 25 Braille cells wide (including U+2800 blanks for indent),
+    so callers can rely on uniform width without ASCII padding.
+    """
     c = menu_art_fg()
     return [
-        f"      {c}⢠⣴⣶⣶⣶⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀{RESET}",
-        f"      {c}⣿⣿⣿⣿⣿⣿⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀{RESET}",
-        f"     {c}⢰⣿⣿⣿⣿⡿⠟⠁⣠⣴⣶⣦⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀{RESET}",
-        f"     {c}⢸⣿⣿⠟⠉⣠⣴⣿⣿⣿⠟⠁⣠⣾⣿⣦⡀⠀⠀⠀⠀⠀⠀⠀{RESET}",
-        f"      {c}⠉⣀⣴⣾⣿⣿⣿⠟⢁⣤⣾⣿⣿⣿⣿⣿⡆⠀⠀⠀⠀⠀⠀{RESET}",
-        f"    {c}⢀⣤⣾⣿⣿⣿⡿⠛⢁⣴⣿⣿⣿⣿⣿⣿⣿⠟⠁⡀⠀⠀⠀⠀⠀{RESET}",
-        f"    {c}⢼⣿⣿⣿⡿⠋⣀⣴⣿⣿⣿⣿⣿⣿⣿⡿⠉⣠⣾⣿⡆⠀⠀⠀⠀{RESET}",
-        f"    {c}⠘⢿⡿⠋⣠⣾⣿⣿⣿⠟⠁⣿⣿⣿⣿⣿⠟⢁⣀⠀⠀⠀{RESET}",
-        f"      {c}⣠⣾⣿⣿⣿⣿⣿⣿⣿⣿⠏⢀⣴⣿⣿⣿⠋⢠⣾⣿⣷⣦⡀{RESET}",
-        f"      {c}⢻⣿⣿⣿⣿⣿⣿⣿⠟⢁⣴⣿⣿⣿⡿⠁⣰⣿⣿⣿⣿⣿⣿{RESET}",
-        f"       {c}⠹⢿⣿⣿⣿⡿⠋⣠⣾⣿⣿⣿⠟⢀⣼⣿⣿⣿⣿⣿⣿⡟{RESET}",
-        f"         {c}⠉⠉⠉⠀⢾⣿⣿⣿⣿⠋⠀⠚⠛⠛⠛⠛⠛⠛⠁⠀{RESET}",
+        f"{c}⠀⠀⢠⣴⣶⣶⣶⣄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀{RESET}",
+        f"{c}⠀⠀⣿⣿⣿⣿⣿⣿⣦⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀{RESET}",
+        f"{c}⠀⢰⣿⣿⣿⣿⡿⠟⠁⣠⣴⣶⣦⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀{RESET}",
+        f"{c}⠀⢸⣿⣿⠟⠉⣠⣴⣿⣿⣿⠟⠁⣠⣾⣿⣦⡀⠀⠀⠀⠀⠀⠀⠀{RESET}",
+        f"{c}⠀⠀⠉⣀⣴⣾⣿⣿⣿⠟⢁⣤⣾⣿⣿⣿⣿⣿⡆⠀⠀⠀⠀⠀⠀{RESET}",
+        f"{c}⢀⣤⣾⣿⣿⣿⡿⠛⢁⣴⣿⣿⣿⣿⣿⣿⣿⠟⠁⡀⠀⠀⠀⠀⠀{RESET}",
+        f"{c}⢼⣿⣿⣿⡿⠋⣀⣴⣿⣿⣿⣿⣿⣿⣿⡿⠉⣠⣾⣿⡆⠀⠀⠀⠀{RESET}",
+        f"{c}⠘⢿⡿⠋⣠⣾⣿⣿⣿⣿⣿⣿⣿⡿⠋⢀⣾⣿⣿⠟⢁⣀⠀⠀⠀{RESET}",
+        f"{c}⠀⠀⣠⣾⣿⣿⣿⣿⣿⣿⣿⣿⠏⢀⣴⣿⣿⣿⠋⢠⣾⣿⣷⣦⡀{RESET}",
+        f"{c}⠀⠀⢻⣿⣿⣿⣿⣿⣿⣿⠟⢁⣴⣿⣿⣿⡿⠁⣰⣿⣿⣿⣿⣿⣿{RESET}",
+        f"{c}⠀⠀⠀⠹⢿⣿⣿⣿⡿⠋⣠⣾⣿⣿⣿⠟⢀⣼⣿⣿⣿⣿⣿⣿⡟{RESET}",
+        f"{c}⠀⠀⠀⠀⠀⠉⠉⠉⠀⢾⣿⣿⣿⣿⠋⠀⠚⠛⠛⠛⠛⠛⠛⠁⠀{RESET}",
+        f"{c}⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀{RESET}",
     ]
 
 
 CUP_TEMPLATE = [
-    "                       {steam0}",
-    "                        {steam1}",
+    "                 {steam0}",
+    "                 {steam1}",
     "                 {gold}___...(-------)-....___{reset}",
     "             {gold}.-''       )    (          ''-.{reset}",
     "       {gold}.-'``'|-._             )         _.-|{reset}",
     "      {gold}/  .--.|   `''---...........---''`   |{reset}",
-    "     {gold}/  /    |  {opt0}                |{reset}",
-    "     {gold}|  |    |  {opt1}                |{reset}",
-    "     {gold}|  |    |  {opt2}                |{reset}",
-    "     {gold}|  |    |  {opt3}                |{reset}",
-    "     {gold}|  |    |  {opt4}                |{reset}",
-    "     {gold}|  |    |  {opt5}                |{reset}",
-    "     {gold}|  |    |  {opt6}                |{reset}",
-    "      {gold}\\  \\   |  {opt7}                |{reset}",
-    "       {gold}`\\ `\\ |  {opt8}                |{reset}",
-    "         {gold}`\\ `|  {opt9}                |{reset}",
-    "         {gold}_/ /\\  {opt10}               /{reset}",
-    "        {gold}(__/  \\ {opt11}               /{reset}",
+    "     {gold}/  /    |{opt0}|{reset}",
+    "     {gold}|  |    |{opt1}|{reset}",
+    "     {gold}|  |    |{opt2}|{reset}",
+    "     {gold}|  |    |{opt3}|{reset}",
+    "     {gold}|  |    |{opt4}|{reset}",
+    "     {gold}|  |    |{opt5}|{reset}",
+    "     {gold}|  |    |{opt6}|{reset}",
+    "      {gold}\\  \\   |{opt7}|{reset}",
+    "       {gold}`\\ `\\ |{opt8}|{reset}",
+    "         {gold}`\\ `|                             |{reset}",
+    "         {gold}_/ /\\                             /{reset}",
+    "        {gold}(__/  \\                           /{reset}",
     "     {gold}_..---''` \\                         /`''---.._{reset}",
     "  {gold}.-'           \\                       /          '-.{reset}",
     " {gold}:               `-.__             __.-'              :{reset}",
@@ -88,12 +93,12 @@ def _render_main_menu_art(sel: int, options: list[str], frame: int, term_h: int)
 
     # Process placeholders
     opts = {}
-    assert len(options) <= 12, (
+    assert len(options) <= 9, (
         f"Too many menu options ({len(options)}); add opt slots to CUP_TEMPLATE"
     )
-    for i in range(12):
+    for i in range(9):
         label = options[i] if i < len(options) else ""
-        text = f"{REVERSE} > {label} < {RESET}" if i == sel else f"  {label}  "
+        text = f"{REVERSE}> {label} <{RESET}" if i == sel else f"  {label}  "
         opts[f"opt{i}"] = ansi_center(text, 29)
 
     final_cup = []
@@ -231,10 +236,10 @@ def show_main_menu(
         options_labels = [
             "BelAtro",
             "Start Game",
-            f"AI Config:     < {diff_display} >",
-            f"Target Score: < {curr_target} >",
-            f"Speed:        < {curr_speed.capitalize()} >",
-            f"Theme:        < {theme_manager.get_current().name} >",
+            f"AI:     < {diff_display} >",
+            f"Target: < {curr_target} >",
+            f"Speed:  < {curr_speed.capitalize()} >",
+            f"Theme:  < {theme_manager.get_current().name} >",
             "Rules & History",
             "Statistics",
             "Quit",

{belote_cli-2.9.0 → belote_cli-2.9.2}/src/belote/ui/prompts.py

@@ -7,9 +7,7 @@ from ..ansi import (
     BOLD,
     DIM,
     RESET,
-    REVERSE,
     ansi_center,
-    black_fg,
     clear_screen,
     gold_fg,
     green_fg,
@@ -123,81 +121,25 @@ def prompt_bid(state: GameState, reader: KeyReader) -> Suit | str | None:
     Round 2 offers Tout Atout (TA) and Sans Atout (SA) in addition to the
     three remaining card suits. Per FFBelote rules, round 1 is "take the
     up-card suit at the standard contract" only — TA/SA aren't offered there.
+
+    The selector UI is painted by render() (via display(..., bid_selection=sel))
+    so each frame is a single in-place repaint. Writing additional lines after
+    display() would scroll the alt-screen on stricter terminals (Konsole) and
+    leak previous frames onto blank padding rows.
     """
     from ..game import SANS_ATOUT_BID
 
     if state.bidding_round == 1:
-        # Round 1: Take (up_card suit) or Pass
         options: list[Suit | str | None] = [state.up_card.suit, None]  # type: ignore[union-attr]
-        labels = [f"Take {state.up_card.suit.symbol}", "Pass"]  # type: ignore[union-attr]
     else:
-        # Round 2: Any classic suit except up_card's, plus Tout Atout (every
-        # suit acts as trump) and Sans Atout (no trump). All round-2 specials
-        # gate to round 2 in `place_bid` — calling them in round 1 raises.
         all_suits = [Suit.SPADES, Suit.HEARTS, Suit.DIAMONDS, Suit.CLUBS]
         other_suits = [s for s in all_suits if s != state.up_card.suit]  # type: ignore[union-attr]
         options = [*other_suits, Suit.TOUT_ATOUT, SANS_ATOUT_BID, None]
-        labels = (
-            [s.symbol for s in other_suits]
-            + ["TA", "SA", "Pass"]
-        )
 
     sel = 0
 
     while True:
-        display(state, None)
-        term_w, _ = get_term_size()
-
-        # L'Encyclopédie voucher: surface partner bidding tendency before each bid.
-        tendency = state._joker_state.get("partner_bid_tendency_text")
-        if isinstance(tendency, str) and tendency:
-            sys.stdout.write(
-                "\r\n" + ansi_center(f"{DIM}{tendency}{RESET}", term_w) + "\r\n"
-            )
-
-        if state.bidding_round == 2:
-            # Nice boxed UI for round 2. Widened to fit 7 options (♠/♥/♦/♣
-            # minus up-card suit + TA + SA + Pass) on one row.
-            inner_w = 60
-            box_lines = [
-                f"┌{'─' * inner_w}┐",
-                f"│{f'ROUND {state.bidding_round} BID'.center(inner_w)}│",
-                f"├{'─' * inner_w}┤",
-                f"│{' ' * inner_w}│",
-            ]
-
-            # Options row
-            opt_str = ""
-            for i, opt in enumerate(options):
-                lbl = labels[i]
-                prefix = f"{BOLD}{gold_fg()}" if i == sel else ""
-
-                # Add color to suit symbols
-                color = ""
-                if isinstance(opt, Suit):
-                    color = red_fg() if opt.is_red else black_fg()
-
-                entry = f"{prefix}({i + 1}) {color}{lbl}{RESET}{prefix}"
-                entry = f"{REVERSE} {entry} {RESET}" if i == sel else f" {entry} "
-                opt_str += entry + "  "
-
-            box_lines.append(f"│{ansi_center(opt_str.strip(), inner_w)}│")
-            box_lines.append(f"│{' ' * inner_w}│")
-            box_lines.append(f"└{'─' * inner_w}┘")
-
-            for bl in box_lines:
-                sys.stdout.write("\r\n" + ansi_center(bl, term_w))
-            sys.stdout.write("\r\n")
-        else:
-            # Round 1 simple prompt
-            parts = [
-                f"{BOLD}{gold_fg()}({i + 1}){lbl}{RESET}" if i == sel else f"({i + 1}){lbl}"
-                for i, lbl in enumerate(labels)
-            ]
-            prompt = f"{BOLD}{white_fg()}Round {state.bidding_round} Bid: {'  '.join(parts)}{RESET}"
-            sys.stdout.write("\r\n" + ansi_center(prompt, term_w) + "\r\n")
-
-        sys.stdout.flush()
+        display(state, None, bid_selection=sel)
 
         event = reader.read()
         match event.key:

{belote_cli-2.9.0 → belote_cli-2.9.2}/src/belote/ui/render.py

@@ -9,6 +9,7 @@ from ..ansi import (
     BOLD,
     DIM,
     RESET,
+    REVERSE,
     UNDERLINE,
     ansi_center,
     ansi_ljust,
@@ -35,8 +36,9 @@ from ..ansi import (
     clear_screen as _clear_screen,
 )
 from ..context import TERMINAL
-from ..deck import Card, Rank
+from ..deck import Card, Rank, Suit
 from ..game import (
+    SANS_ATOUT_BID,
     GameState,
     Phase,
     Seat,
@@ -562,13 +564,88 @@ def _build_hud(state: GameState, term_w: int, layout: LayoutPreset = STANDARD) -
     return bar + " " * pad + theme_label
 
 
-def render(state: GameState, selection: int | None = None, show_north_hand: bool = False) -> str:
+def _build_bid_prompt_lines(state: GameState, term_w: int, bid_selection: int) -> list[str]:
+    """Build the in-frame bidding prompt: optional tendency line, then the
+    selector (Round 1: inline highlighted Take/Pass; Round 2: boxed grid).
+
+    Painted as part of the main render so no writes happen after `display()` —
+    that's what was causing the Konsole UI to stack (post-render \\r\\n's
+    scrolled the alt-screen, leaving stale content on rows the next frame's
+    blank padding doesn't repaint).
+    """
+    if state.bidding_round == 1:
+        up_card = state.up_card
+        assert up_card is not None  # guaranteed by Phase.BIDDING + round 1
+        labels = [f"Take {up_card.suit.symbol}", "Pass"]
+    else:
+        all_suits = [Suit.SPADES, Suit.HEARTS, Suit.DIAMONDS, Suit.CLUBS]
+        up_card = state.up_card
+        assert up_card is not None
+        other_suits = [s for s in all_suits if s != up_card.suit]
+        labels = [s.symbol for s in other_suits] + ["TA", "SA", "Pass"]
+        round2_suits: list[Suit | str | None] = [
+            *other_suits,
+            Suit.TOUT_ATOUT,
+            SANS_ATOUT_BID,
+            None,
+        ]
+
+    lines: list[str] = []
+
+    tendency = state._joker_state.get("partner_bid_tendency_text")
+    if isinstance(tendency, str) and tendency:
+        lines.append(ansi_center(f"{DIM}{tendency}{RESET}", term_w))
+
+    if state.bidding_round == 2:
+        inner_w = 60
+        opt_str = ""
+        for i, lbl in enumerate(labels):
+            prefix = f"{BOLD}{gold_fg()}" if i == bid_selection else ""
+            color = ""
+            opt = round2_suits[i]
+            if isinstance(opt, Suit):
+                color = red_fg() if opt.is_red else black_fg()
+            entry = f"{prefix}({i + 1}) {color}{lbl}{RESET}{prefix}"
+            entry = f"{REVERSE} {entry} {RESET}" if i == bid_selection else f" {entry} "
+            opt_str += entry + "  "
+
+        box = [
+            f"┌{'─' * inner_w}┐",
+            f"│{f'ROUND {state.bidding_round} BID'.center(inner_w)}│",
+            f"├{'─' * inner_w}┤",
+            f"│{' ' * inner_w}│",
+            f"│{ansi_center(opt_str.strip(), inner_w)}│",
+            f"│{' ' * inner_w}│",
+            f"└{'─' * inner_w}┘",
+        ]
+        lines.extend(ansi_center(bl, term_w) for bl in box)
+    else:
+        parts = [
+            f"{BOLD}{gold_fg()}({i + 1}){lbl}{RESET}" if i == bid_selection else f"({i + 1}){lbl}"
+            for i, lbl in enumerate(labels)
+        ]
+        prompt = f"{BOLD}{white_fg()}Round {state.bidding_round} Bid: {'  '.join(parts)}{RESET}"
+        lines.append(ansi_center(prompt, term_w))
+
+    return lines
+
+
+def render(
+    state: GameState,
+    selection: int | None = None,
+    show_north_hand: bool = False,
+    bid_selection: int | None = None,
+) -> str:
     """Pure: returns a full-screen ANSI-formatted string. No I/O.
 
     Terminal width is queried fresh on every call so resizing works correctly.
     The layout preset (compact / standard / spacious) is also picked fresh from
     the current dimensions, so resizing the terminal mid-game adapts on the
     next render.
+
+    `bid_selection` paints the bidding selector with the highlighted option
+    inside the frame. Pass `None` for non-interactive renders (the simple
+    static "Bid: [P]ass [1]♠..." hint shows instead).
     """
     term_w, term_h = get_term_size()
     layout = choose_layout(term_w, term_h)
@@ -657,8 +734,11 @@ def render(state: GameState, selection: int | None = None, show_north_hand: bool
     if state.phase == Phase.BIDDING and state.turn == Seat.SOUTH:
         if term_h > 40:
             lines.append("")
-        prompt = f"{BOLD}{gold_fg()}Bid: [P]ass  [1]♠  [2]♥  [3]♦  [4]♣{RESET}"
-        lines.append(ansi_center(prompt, term_w))
+        if bid_selection is not None:
+            lines.extend(_build_bid_prompt_lines(state, term_w, bid_selection))
+        else:
+            prompt = f"{BOLD}{gold_fg()}Bid: [P]ass  [1]♠  [2]♥  [3]♦  [4]♣{RESET}"
+            lines.append(ansi_center(prompt, term_w))
 
     # ── Vertical centering ──────────────────────────────────────────────────
     # If the terminal is taller than the rendered content, pad top + bottom so
@@ -670,12 +750,11 @@ def render(state: GameState, selection: int | None = None, show_north_hand: bool
         bottom_pad = slack - top_pad
         lines = [""] * top_pad + lines + [""] * bottom_pad
 
-    # Only emit clear_to_eol on lines that actually have content; pure-padding
-    # blank lines don't need it (we already cleared the screen on layout
-    # changes and the previous render's content area was clear-to-eol'd).
-    rendered_lines = [
-        line + clear_to_eol() if line else line for line in lines[:term_h]
-    ]
+    # Always emit clear_to_eol on every row, including blank padding. Konsole
+    # (and other strict emulators) don't auto-blank cells when an empty string
+    # passes through, so any debris from external writes (announcements, etc.)
+    # would remain visible. The cost is one extra 3-byte escape per row.
+    rendered_lines = [line + clear_to_eol() for line in lines[:term_h]]
     return "".join([out, "\r\n".join(rendered_lines), show_cursor()])
 
 
@@ -687,8 +766,13 @@ def display_hud(state: GameState) -> None:
     sys.stdout.flush()
 
 
-def display(state: GameState, selection: int | None = None, show_north_hand: bool = False) -> None:
-    sys.stdout.write(render(state, selection, show_north_hand))
+def display(
+    state: GameState,
+    selection: int | None = None,
+    show_north_hand: bool = False,
+    bid_selection: int | None = None,
+) -> None:
+    sys.stdout.write(render(state, selection, show_north_hand, bid_selection=bid_selection))
     sys.stdout.flush()