Enhance game logic, UI, and puzzle generation

- Updated `README.md` to document new features and enhancements.
- Incremented version to `0.1.11` in `__init__.py`.
- Added deterministic puzzle generation with `puzzle_id` or `seed`.
- Introduced `spacer` parameter to enforce word spacing rules.
- Enhanced `generate_puzzle` for retries, spacing, and validation.
- Added `spacer` and `uid` attributes to `Puzzle` class.
- Updated `GameState` to track game duration with `start_time` and `end_time`.
- Improved `ui.py` with grid ticks, radar caching, and better layouts.
- Refined CSS for readability, mobile responsiveness, and styling.
- Fixed bugs in wordlist persistence and grid tooltips.
- Improved performance by caching radar GIFs and optimizing rendering.

README.md

@@ -104,7 +104,16 @@ docker run -p 8501:8501 battlewords
 4. **The game ends when all six words are found or all word letters are revealed. Your score tier is displayed.**
 
 ## Changelog
-
+- 0.1.11
+  - Added game-ending condition: the game now ends when all six words are guessed or all word letters are revealed.
+  - implemented word spacing logic to prevent adjacent partial words and allow for future enhancements like overlaps.
+  - implement loading html overlay and hide grid until ready.
+  - Update to Game Summary table: shows words, base points, bonus points, total score; styled with Streamlit's `st.table`.
+  - Show Grid Ticks and Space between words are now in settings.
+  - Increase default font size for better readability.
+  - Game end now modifies the grid display to show all words and disables further interaction. 
+  - Update to model for future enhancements
+  
 - 0.1.10
   - Sidebar Game Mode selector: `standard` (allows guess chaining after correct guesses) and `too easy` (no chaining; score panel reveals words list).
   - Replaced Hit/Miss with Correct/Try Again status indicator for guesses.
@@ -112,6 +121,7 @@ docker run -p 8501:8501 battlewords
   - Footer shows version info (commit, Python, Streamlit).
   - Word list handling: defaults to `classic.txt` when present; selection persists across new games; sort action rewrites the file and restarts after 5s notice.
   - Documentation updated.
+  - fixed wordlist selection persistence bug
 
 - 0.1.9
   - Background naming cleanup and consistency.

battlewords/__init__.py

@@ -1,2 +1,2 @@
-__version__ = "0.1.10"
+__version__ = "0.1.11"
 __all__ = ["models", "generator", "logic", "ui"]

battlewords/generator.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 import random
-from typing import Dict, List, Optional
-
+import hashlib  # NEW
+from typing import Dict, List, Optional, Union  # UPDATED
 from .word_loader import load_word_list
 from .models import Coord, Word, Puzzle
 
@@ -21,18 +21,56 @@ def _build_cells(start: Coord, length: int, direction: str) -> List[Coord]:
         return [Coord(start.x + i, start.y) for i in range(length)]
 
 
+def _chebyshev_distance(a: Coord, b: Coord) -> int:
+    return max(abs(a.x - b.x), abs(a.y - b.y))
+
+
+def _seed_from_id(puzzle_id: str) -> int:
+    """Derive a deterministic 64-bit seed from a string id."""
+    h = hashlib.sha256(puzzle_id.encode("utf-8")).digest()
+    return int.from_bytes(h[:8], "big", signed=False)
+
+
 def generate_puzzle(
     grid_size: int = 12,
     words_by_len: Optional[Dict[int, List[str]]] = None,
-    seed: Optional[int] = None,
+    seed: Optional[Union[int, str]] = None,
     max_attempts: int = 5000,
+    spacer: int = 1,
+    puzzle_id: Optional[str] = None,  # NEW
+    _retry: int = 0,  # NEW internal for deterministic retries
 ) -> Puzzle:
     """
     Place exactly six words: 2x4, 2x5, 2x6, horizontal or vertical,
     no cell overlaps. Radar pulses are last-letter cells.
     Ensures the same word text is not selected more than once.
+
+    Parameters
+    - grid_size: grid dimension (default 12)
+    - words_by_len: preloaded word pools by length
+    - seed: optional RNG seed
+    - max_attempts: cap for placement attempts before restarting
+    - spacer: separation constraint between different words (0–2 supported)
+      - 0: words may touch
+      - 1: at least 1 blank tile between words (default)
+      - 2: at least 2 blank tiles between words
+
+    Determinism:
+    - If puzzle_id is provided, it's used to derive the RNG seed. Retries use f"{puzzle_id}:{_retry}".
+    - Else if seed is provided (int or str), it's used (retries offset deterministically).
+    - Else RNG is non-deterministic as before.
     """
-    rng = random.Random(seed)
+    # Compute deterministic seed if requested
+    if puzzle_id is not None:
+        seed_val = _seed_from_id(f"{puzzle_id}:{_retry}")
+    elif isinstance(seed, str):
+        seed_val = _seed_from_id(f"{seed}:{_retry}")
+    elif isinstance(seed, int):
+        seed_val = seed + _retry
+    else:
+        seed_val = None
+
+    rng = random.Random(seed_val) if seed_val is not None else random.Random()
     words_by_len = words_by_len or load_word_list()
     target_lengths = [4, 4, 5, 5, 6, 6]
 
@@ -41,10 +79,8 @@ def generate_puzzle(
     placed: List[Word] = []
 
     # Pre-shuffle the word pools for variety but deterministic with seed.
-    # Also de-duplicate within each length pool while preserving order.
     pools: Dict[int, List[str]] = {}
     for L in (4, 5, 6):
-        # Preserve order and dedupe
         unique_words = list(dict.fromkeys(words_by_len.get(L, [])))
         rng.shuffle(unique_words)
         pools[L] = unique_words
@@ -56,7 +92,6 @@ def generate_puzzle(
         if not pool:
             raise RuntimeError(f"No words available for length {L}")
 
-        # Try different source words and positions
         word_try_order = pool[:]  # copy
         rng.shuffle(word_try_order)
 
@@ -65,11 +100,9 @@ def generate_puzzle(
                 break
             attempts += 1
 
-            # Skip words already used to avoid duplicates across placements
             if cand_text in used_texts:
                 continue
 
-            # Try a variety of starts/orientations for this word
             for _ in range(50):
                 direction = rng.choice(["H", "V"])
                 if direction == "H":
@@ -85,7 +118,6 @@ def generate_puzzle(
                     placed.append(w)
                     used.update(cells)
                     used_texts.add(cand_text)
-                    # Remove from pool so it can't be picked again later
                     try:
                         pool.remove(cand_text)
                     except ValueError:
@@ -100,10 +132,30 @@ def generate_puzzle(
             # Hard reset and retry whole generation if we hit a wall
             if attempts >= max_attempts:
                 raise RuntimeError("Puzzle generation failed: max attempts reached")
-            return generate_puzzle(grid_size=grid_size, words_by_len=words_by_len, seed=rng.randrange(1 << 30))
-
-    puzzle = Puzzle(words=placed)
-    validate_puzzle(puzzle, grid_size=grid_size)
+            return generate_puzzle(
+                grid_size=grid_size,
+                words_by_len=words_by_len,
+                seed=rng.randrange(1 << 30),
+                max_attempts=max_attempts,
+                spacer=spacer,
+            )
+
+    puzzle = Puzzle(words=placed, spacer=spacer)
+    try:
+        validate_puzzle(puzzle, grid_size=grid_size)
+    except AssertionError:
+        # Deterministic retry on validation failure
+
+        # Regenerate on validation failure (e.g., spacer rule violation)
+        return generate_puzzle(
+            grid_size=grid_size,
+            words_by_len=words_by_len,
+            seed=seed,
+            max_attempts=max_attempts,
+            spacer=spacer,
+            puzzle_id=puzzle_id,
+            _retry=_retry + 1,
+        )
     return puzzle
 
 
@@ -128,6 +180,16 @@ def validate_puzzle(puzzle: Puzzle, grid_size: int = 12) -> None:
     if counts[4] != 2 or counts[5] != 2 or counts[6] != 2:
         raise AssertionError("Incorrect counts of word lengths")
 
+    # Enforce spacer rule (supports 0–2). Default spacer is 1 (from models.Puzzle).
+    spacer_val = getattr(puzzle, "spacer", 1)
+    if spacer_val in (1, 2):
+        word_cells = [set(w.cells) for w in puzzle.words]
+        for i in range(len(word_cells)):
+            for j in range(i + 1, len(word_cells)):
+                for c1 in word_cells[i]:
+                    for c2 in word_cells[j]:
+                        if _chebyshev_distance(c1, c2) <= spacer_val:
+                            raise AssertionError(f"Spacing violation (spacer={spacer_val}): {c1} vs {c2}")
 
 def sort_word_file(filepath: str) -> List[str]:
     """

battlewords/logic.py

@@ -5,11 +5,59 @@ from typing import Dict, Tuple
 from .models import Coord, Puzzle, GameState, Word
 
 
+def _chebyshev_distance(a: Coord, b: Coord) -> int:
+    """8-neighborhood distance (max norm)."""
+    return max(abs(a.x - b.x), abs(a.y - b.y))
+
+
 def build_letter_map(puzzle: Puzzle) -> Dict[Coord, str]:
+    """Build a coordinate->letter map for the given puzzle.
+
+    Spacer support (0–2):
+    - spacer = 0: words may touch (no separation enforced).
+    - spacer = 1: words must be separated by at least 1 blank tile
+      (no two letters from different words at Chebyshev distance <= 1).
+    - spacer = 2: at least 2 blank tiles between words
+      (no two letters from different words at Chebyshev distance <= 2).
+
+    Overlaps are not handled here (negative spacer not supported in this function).
+    This function raises ValueError if the configured spacing is violated.
+    """
     mapping: Dict[Coord, str] = {}
+
+    spacer = getattr(puzzle, "spacer", 1)
+
+    # Build mapping normally (no overlap merging beyond first-come-wins semantics)
     for w in puzzle.words:
         for idx, c in enumerate(w.cells):
-            mapping[c] = w.text[idx]
+            ch = w.text[idx]
+            if c not in mapping:
+                mapping[c] = ch
+            else:
+                # If an explicit overlap occurs, we don't support it here.
+                # Keep the first-seen letter and continue.
+                pass
+
+    # Enforce spacer in the range 0–2
+    if spacer in (1, 2):
+        # Prepare sets of cells per word
+        word_cells = [set(w.cells) for w in puzzle.words]
+        for i in range(len(word_cells)):
+            for j in range(i + 1, len(word_cells)):
+                cells_i = word_cells[i]
+                cells_j = word_cells[j]
+                # If any pair is too close, it's a violation
+                for c1 in cells_i:
+                    # Early exit by scanning a small neighborhood around c1
+                    # since Chebyshev distance <= spacer
+                    for c2 in cells_j:
+                        if _chebyshev_distance(c1, c2) <= spacer:
+                            raise ValueError(
+                                f"Words too close (spacer={spacer}): {c1} and {c2}"
+                            )
+
+    # spacer == 0 -> no checks; other values are ignored here intentionally
+
     return mapping
 
 

battlewords/models.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Literal, List, Set, Dict
+from typing import Literal, List, Set, Dict, Optional
+from datetime import datetime
+import uuid
 
 
 Direction = Literal["H", "V"]
@@ -50,8 +52,27 @@ class Word:
 
 @dataclass
 class Puzzle:
+    """Puzzle configuration and metadata.
+    Fields
+    - words: The list of placed words.
+    - radar: Points used to render the UI radar (defaults to each word's last cell).
+    - may_overlap: If True, words may overlap on shared letters (e.g., a crossword-style junction).
+    - spacer: (2 to -3) Controls proximity and overlap rules between distinct words:
+        * spacer = 0    -> words may be directly adjacent (touching next to each other).
+        * spacer = 1    -> at least 1 blank cell must separate words (no immediate adjacency).
+        * spacer > 1    -> enforce that many blank cells of separation.
+        * spacer < 0    -> allow overlaps on a common letter; abs(spacer) is the maximum
+                            number of trailing letters each word may extend beyond the
+                            shared letter (e.g., -3 allows up to 3 letters past the overlap).
+
+    Note: These are configuration hints for the generator/logic. Enforcement is not implemented here.
+    """
     words: List[Word]
     radar: List[Coord] = field(default_factory=list)
+    may_overlap: bool = False
+    spacer: int = 1
+    # Unique identifier for this puzzle instance (used for deterministic regen and per-session assets)
+    uid: str = field(default_factory=lambda: uuid.uuid4().hex)  # NEW
 
     def __post_init__(self):
         pulses = [w.last_cell for w in self.words]
@@ -68,4 +89,6 @@ class GameState:
     last_action: str
     can_guess: bool
     game_mode: Literal["standard", "too easy"] = "standard"
-    points_by_word: Dict[str, int] = field(default_factory=dict)
+    points_by_word: Dict[str, int] = field(default_factory=dict)
+    start_time: Optional[datetime] = None
+    end_time: Optional[datetime] = None

battlewords/ui.py

@@ -102,10 +102,12 @@ def inject_styles() -> None:
             max-width: 1100px;
            }
           /* Base grid cell visuals */
-          .bw-row { display: flex; gap: 0.1rem; flex-wrap: nowrap; }
+          .bw-row { display: flex; gap: 0.1rem; flex-wrap: nowrap; min-height: 48px;}
           .bw-cell {
             width: 100%;
+            gap: 0.1rem;
             aspect-ratio: 1 / 1;
+            line-height: 1.6;
             display: flex;
             align-items: center;
             justify-content: center;
@@ -114,6 +116,7 @@ def inject_styles() -> None:
             font-weight: 700;
             user-select: none;
             padding: 0.25rem 0.75rem;
+            font-size: 1.4rem;
             min-height: 2.5rem;
             transition: background 0.2s ease, color 0.2s ease, border-color 0.2s ease;
             background: #1d64c8;   /* Base cell color */
@@ -122,7 +125,7 @@ def inject_styles() -> None:
           /* Found letter cells */
           .bw-cell.letter { background: #d7faff; color: #050057; }
           /* Optional empty state if ever used */
-          .bw-cell.empty  { background: #3a3a3a; color: #ffffff; }
+          .bw-cell.empty  { background: #3a3a3a; color: #ffffff;}
           /* Completed word cells */
           .bw-cell.bw-cell-complete { background: #050057 !important; color: #d7faff !important; }
 
@@ -164,6 +167,7 @@ def inject_styles() -> None:
           }
           .st-emotion-cache-1permvm, .st-emotion-cache-1n6tfoc {
             gap:0.1rem !important;
+            min-height: 2.5rem;
           }
 
           /* Ensure grid rows generated via st.columns do not wrap and can scroll horizontally. */
@@ -192,6 +196,13 @@ def inject_styles() -> None:
             border-radius: 10px;            
             margin: 5px; /* Border thickness */
           }
+          .st-key-guess_input, .st-key-guess_submit {
+            flex-direction: row;
+            display: flex;
+            flex-wrap: wrap;
+            justify-content: flex-start;
+            align-items: flex-end;
+          }
 
           /* Mobile styles */
           @media (max-width: 640px) {
@@ -254,8 +265,8 @@ def inject_styles() -> None:
         }
 
         /* Hit/Miss radio indicators - circular group */
-        .bw-radio-group { display:flex; align-items:center; gap: 10px; flex-flow: column;}
-        .bw-radio-item { display:flex; flex-direction:column; align-items:center; gap:6px; }
+        .bw-radio-group { display:flex; align-items:flex-start; gap: 10px; flex-flow: row;}
+        .bw-radio-item { display:flex; flex-direction:column; align-items:center; gap:6px; text-align:center;}
         .bw-radio-circle {
           width: 46px; height: 46px; border-radius: 50%;
           border: 4px solid; /* border-image: linear-gradient(45deg, #a1a1a1, #ffffff, #a1a1a1, #666666) 1; */
@@ -307,12 +318,17 @@ def _init_session() -> None:
 def _new_game() -> None:
     selected = st.session_state.get("selected_wordlist")
     mode = st.session_state.get("game_mode")
+    show_grid_ticks = st.session_state.get("show_grid_ticks", False)
+    spacer = st.session_state.get("spacer", 1)
     st.session_state.clear()
     if selected:
         st.session_state.selected_wordlist = selected
     if mode:
         st.session_state.game_mode = mode
+    st.session_state.show_grid_ticks = show_grid_ticks
+    st.session_state.spacer = spacer
     st.session_state.radar_gif_path = None  # Reset radar GIF path
+    st.session_state.radar_gif_signature = None  # Reset signature
     _init_session()
 
 
@@ -342,12 +358,12 @@ def _sync_back(state: GameState) -> None:
 def _render_header():
     st.title(f"Battlewords v{version}")
     st.subheader("Reveal cells, then guess the hidden words.")
-    st.markdown(
-        "- Grid is 12×12 with 6 words (two 4-letter, two 5-letter, two 6-letter).\n"
-        "- After each reveal, you may submit one word guess below.\n"
-        "- Scoring: length + unrevealed letters of that word at guess time.\n"
-        "- Score Board: radar of last letter of word, score and status.\n"
-        "- Words do not overlap, but may be touching.")
+    # st.markdown(
+    #     "- Grid is 12×12 with 6 words (two 4-letter, two 5-letter, two 6-letter).\n"
+    #     "- After each reveal, you may submit one word guess below.\n"
+    #     "- Scoring: length + unrevealed letters of that word at guess time.\n"
+    #     "- Score Board: radar of last letter of word, score and status.\n"
+    #     "- Words do not overlap, but may be touching.")
     inject_styles()
 
 
@@ -392,10 +408,31 @@ def _render_sidebar():
                 _sort_wordlist(st.session_state.selected_wordlist)
         else:
             st.info("No word lists found in words/ directory. Using built-in fallback.")
+        
+        # Add Show Grid ticks option
+        if "show_grid_ticks" not in st.session_state:
+            st.session_state.show_grid_ticks = False
+        st.checkbox("Show Grid ticks", value=st.session_state.show_grid_ticks, key="show_grid_ticks")
+        
+        # Add Spacer option
+        spacer_options = [0, 1, 2]
+        if "spacer" not in st.session_state:
+            st.session_state.spacer = 1
+        st.selectbox(
+            "Spacer (space between words)",
+            options=spacer_options,
+            index=spacer_options.index(st.session_state.spacer),
+            key="spacer"
+        )
+        
         st.markdown(versions_html(), unsafe_allow_html=True)
 
-def get_scope_image(size=4, bgcolor="none", scope_color="green", img_name="scope.gif"):
-    scope_path = os.path.join(os.path.dirname(__file__), img_name)
+def get_scope_image(uid: str, size=4, bgcolor="none", scope_color="green"):
+    """Return a per-puzzle pre-rendered scope image by UID."""
+    # Use a temp directory so multiple tabs/users don't clash and avoid package writes.
+    base_dir = os.path.join(tempfile.gettempdir(), "battlewords_scopes")
+    os.makedirs(base_dir, exist_ok=True)
+    scope_path = os.path.join(base_dir, f"scope_{uid}.png")
     if not os.path.exists(scope_path):
         fig, ax = _create_radar_scope(size=size, bgcolor=bgcolor, scope_color=scope_color)
         imgscope = fig_to_pil_rgba(fig)
@@ -443,7 +480,7 @@ def _create_radar_scope(size=4, bgcolor="none", scope_color="green"):
     
     return fig, ax
 
-def _render_radar(puzzle: Puzzle, size: int, r_max: float = 0.85, max_frames: int = 30, sinusoid_expand: bool = True, stagger_radar: bool = False):
+def _render_radar(puzzle: Puzzle, size: int, r_max: float = 0.85, max_frames: int = 30, sinusoid_expand: bool = True, stagger_radar: bool = False, show_ticks: bool = True):
     import numpy as np
     import matplotlib.pyplot as plt
     from matplotlib.animation import FuncAnimation, PillowWriter
@@ -465,14 +502,28 @@ def _render_radar(puzzle: Puzzle, size: int, r_max: float = 0.85, max_frames: in
     scope_size=3
     scope_color="#ffffff"
 
-    imgscope = get_scope_image(size=scope_size, bgcolor=bgcolor, scope_color=scope_color, img_name="scope_blue.png")
+    # Determine which rings correspond to already-guessed words (hide them)
+    guessed_words = set(st.session_state.get("guessed", set()))
+    guessed_by_index = [w.text in guessed_words for w in puzzle.words]
+
+    # GIF cache signature: puzzle uid + guessed words snapshot
+    gif_signature = (getattr(puzzle, "uid", None), tuple(sorted(guessed_words)))
+
+    # Use per-puzzle scope image keyed by puzzle.uid
+    imgscope = get_scope_image(uid=puzzle.uid, size=scope_size, bgcolor=bgcolor, scope_color=scope_color)
     fig, ax = plt.subplots(figsize=(scope_size, scope_size))    
     ax.set_xlim(0.2, size)
     ax.set_ylim(size, 0.2)
-    ax.set_xticks(range(1, size + 1))
-    ax.set_yticks(range(1, size + 1))
-    ax.tick_params(axis="both", which="both", labelcolor=rgba_labels)
-    ax.tick_params(axis="both", which="both", colors=rgba_ticks)
+
+    if show_ticks:
+        ax.set_xticks(range(1, size + 1))
+        ax.set_yticks(range(1, size + 1))
+        ax.tick_params(axis="both", which="both", labelcolor=rgba_labels)
+        ax.tick_params(axis="both", which="both", colors=rgba_ticks)
+    else:
+        ax.set_xticks([])
+        ax.set_yticks([])
+
     ax.set_aspect('equal', adjustable='box')
 
     def _make_linear_gradient(width: int, height: int, angle_deg: float,
@@ -525,17 +576,23 @@ def _render_radar(puzzle: Puzzle, size: int, r_max: float = 0.85, max_frames: in
         rings.append(ring)
 
     def update(frame):
+        # Hide rings for guessed words
+        for idx, ring in enumerate(rings):
+            ring.set_visible(not guessed_by_index[idx])
         if sinusoid_expand:
             phase = 2 * np.pi * frame / max_frames
             r = r_min + (r_max - r_min) * (0.5 + 0.5 * np.sin(phase))
             alpha = 0.5 + 0.5 * np.cos(phase)
-            for ring in rings:
-                ring.set_radius(r)
-                ring.set_alpha(alpha)
+            for idx, ring in enumerate(rings):
+                if not guessed_by_index[idx]:
+                    ring.set_radius(r)
+                    ring.set_alpha(alpha)
         else:
             base_t = (frame % max_frames) / max_frames
             offset = max(1, max_frames // max(1, n_points)) if stagger_radar else 0
             for idx, ring in enumerate(rings):
+                if guessed_by_index[idx]:
+                    continue
                 t_i = ((frame + idx * offset) % max_frames) / max_frames if stagger_radar else base_t
                 r_i = r_min + (r_max - r_min) * t_i
                 alpha_i = 1.0 - t_i
@@ -543,10 +600,11 @@ def _render_radar(puzzle: Puzzle, size: int, r_max: float = 0.85, max_frames: in
                 ring.set_alpha(alpha_i)
         return rings
 
-    # Use persistent GIF if available
-    gif_path = st.session_state.get("radar_gif_path")
-    if gif_path and os.path.exists(gif_path):
-        with open(gif_path, "rb") as f:
+    # Use persistent GIF if available and matches current signature
+    cached_path = st.session_state.get("radar_gif_path")
+    cached_sig = st.session_state.get("radar_gif_signature")
+    if cached_path and os.path.exists(cached_path) and cached_sig == gif_signature:
+        with open(cached_path, "rb") as f:
             gif_bytes = f.read()
         st.image(gif_bytes, width='content', output_format="auto")
         plt.close(fig)
@@ -560,12 +618,16 @@ def _render_radar(puzzle: Puzzle, size: int, r_max: float = 0.85, max_frames: in
         tmpfile.seek(0)
         gif_bytes = tmpfile.read()
         st.session_state.radar_gif_path = tmpfile.name  # Save path for reuse
+        st.session_state.radar_gif_signature = gif_signature  # Save signature to detect changes
     st.image(gif_bytes, width='content', output_format="auto")
 
-def _render_grid(state: GameState, letter_map):
+def _render_grid(state: GameState, letter_map, show_grid_ticks: bool = True):
     size = state.grid_size
     clicked: Optional[Coord] = None
 
+    # Determine if the game is over to reveal all remaining tiles as blanks
+    game_over = is_game_over(state)
+
     # Inject CSS for grid lines
     st.markdown(
         """
@@ -585,7 +647,7 @@ def _render_grid(state: GameState, letter_map):
             background: #1d64c8 !important;
             color: #ffffff !important;
             font-weight: bold;
-            font-size: 1rem;
+            font-size: 1.4rem;
         }
         /* Further tighten vertical spacing between rows inside the grid container */
         .bw-grid-row-anchor + div[data-testid="stHorizontalBlock"] {
@@ -626,7 +688,8 @@ def _render_grid(state: GameState, letter_map):
             cols = st.columns(size, gap="small")
             for c in range(size):
                 coord = Coord(r, c)
-                revealed = coord in state.revealed
+                # Treat all cells as revealed once the game is over
+                revealed = (coord in state.revealed) or game_over
                 label = letter_map.get(coord, " ") if revealed else " "
 
                 is_completed_cell = False
@@ -637,29 +700,43 @@ def _render_grid(state: GameState, letter_map):
                             break
 
                 key = f"cell_{r}_{c}"
-                tooltip = f"({r+1},{c+1})"
+                tooltip = f"({r+1},{c+1})" if show_grid_ticks else ""
 
                 if is_completed_cell:
-                    # Render a styled non-button cell for a completed word with native browser tooltip
                     safe_label = (label or " ")
-                    cols[c].markdown(
-                        f'<div class="bw-cell bw-cell-complete" title="{tooltip}">{safe_label}</div>',
-                        unsafe_allow_html=True,
-                    )
+                    if show_grid_ticks:
+                        cols[c].markdown(
+                            f'<div class="bw-cell bw-cell-complete" title="{tooltip}">{safe_label}</div>',
+                            unsafe_allow_html=True,
+                        )
+                    else:
+                        cols[c].markdown(
+                            f'<div class="bw-cell bw-cell-complete">{safe_label}</div>',
+                            unsafe_allow_html=True,
+                        )
                 elif revealed:
-                    # Use 'letter' when a letter exists, otherwise 'empty'
                     safe_label = (label or " ")
                     has_letter = safe_label.strip() != ""
                     cell_class = "letter" if has_letter else "empty"
                     display = safe_label if has_letter else "&nbsp;"
-                    cols[c].markdown(
-                        f'<div class="bw-cell {cell_class}" title="{tooltip}">{display}</div>',
-                        unsafe_allow_html=True,
-                    )
+                    if show_grid_ticks:
+                        cols[c].markdown(
+                            f'<div class="bw-cell {cell_class}" title="{tooltip}">{display}</div>',
+                            unsafe_allow_html=True,
+                        )
+                    else:
+                        cols[c].markdown(
+                            f'<div class="bw-cell {cell_class}">{display}</div>',
+                            unsafe_allow_html=True,
+                        )
                 else:
                     # Unrevealed: render a button to allow click/reveal with tooltip
-                    if cols[c].button(" ", key=key, help=tooltip):
-                        clicked = coord
+                    if show_grid_ticks:
+                        if cols[c].button(" ", key=key, help=tooltip):
+                            clicked = coord
+                    else:
+                        if cols[c].button(" ", key=key):
+                            clicked = coord
         
     if clicked is not None:
         reveal_cell(state, letter_map, clicked)
@@ -732,22 +809,29 @@ def _render_correct_try_again(state: GameState):
     )
 
 
-def _render_guess_form(state: GameState):
-    with st.form("guess_form"):
-        guess_text = st.text_input("Your guess", value="", max_chars=12)
-        submitted = st.form_submit_button("OK", disabled=not state.can_guess, width="stretch")
+def _render_guess_form(state: GameState):    
+    with st.form("guess_form",width=300,clear_on_submit=False):
+        col1, col2 = st.columns([2, 1], vertical_alignment="bottom")
+        with col1:
+            guess_text = st.text_input("Your Guess", value="", max_chars=10, width=200, key="guess_input")
+        with col2:
+            submitted = st.form_submit_button("OK", disabled=not state.can_guess, width=100,key="guess_submit")
         if submitted:
             correct, _ = guess_word(state, guess_text)
             _sync_back(state)            
-            st.rerun()  # Immediately rerun to reflect guess result in UI
+            # Invalidate radar GIF cache if guess changed the set of guessed words
+            if correct:
+                st.session_state.radar_gif_path = None
+                st.session_state.radar_gif_signature = None
+            st.rerun()
 
 
 def _render_score_panel(state: GameState):
-    col1, col2 = st.columns([1, 3])
-    with col1:
-        st.metric("Score", state.score)
-    with col2:
-        st.markdown(f"Last action: {state.last_action}")
+    # col1, col2 = st.columns([1, 3])
+    # with col1:
+    #     st.metric("Score", state.score)
+    # with col2:
+    #     st.markdown(f"Last action: {state.last_action}")
     if is_game_over(state):
         _render_game_over(state)
     else:
@@ -832,12 +916,12 @@ def run_app():
     st.markdown('<div id="bw-main-anchor"></div>', unsafe_allow_html=True)
     left, right = st.columns([2, 2], gap="medium")
     with left:
-        _render_grid(state, st.session_state.letter_map)
+        _render_grid(state, st.session_state.letter_map, show_grid_ticks=st.session_state.get("show_grid_ticks", True))
         st.button("New Game", width=125, on_click=_new_game, key="new_game_btn")
 
     with right:
-        _render_radar(state.puzzle, size=state.grid_size, r_max=1.6, max_frames=60, sinusoid_expand=False, stagger_radar=True)    
-        one, two = st.columns([1, 5], gap="medium")
+        _render_radar(state.puzzle, size=state.grid_size, r_max=0.8, max_frames=25, sinusoid_expand=True, stagger_radar=False, show_ticks=st.session_state.get("show_grid_ticks", False))    
+        one, two = st.columns([1, 3], gap="medium")
         with one:
             _render_correct_try_again(state)
             #_render_hit_miss(state)
@@ -850,5 +934,4 @@ def run_app():
     # End condition
     state = _to_state()
     if is_game_over(state):
-        _render_game_over(state)  
-    
+        _render_game_over(state)