feat(core): extract game logic into separate modules

Create core module with dedicated files for different aspects of game logic:
- Extract board generation and management to board.py
- Extract phrases loading and processing to phrases.py
- Extract win pattern detection to win_patterns.py

🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <noreply@anthropic.com>

Author: jonathan-irvin

src/core/__init__.py

@@ -0,0 +1 @@
+# Core game logic package initialization

src/core/board.py

@@ -0,0 +1,65 @@
+# Board generation and management
+import random
+import datetime
+from typing import List, Dict, Set, Tuple
+
+from src.config.constants import FREE_SPACE_TEXT, FREE_SPACE_POSITION
+# Avoid import at module level to prevent circular imports
+# We'll import get_phrases inside the function
+
+# Global state
+board = []
+clicked_tiles = set()
+board_iteration = 1
+today_seed = ""
+board_views = {}
+
+def generate_board(seed_val: int) -> None:
+    """Generate a new board using the provided seed value."""
+    global board, today_seed, clicked_tiles
+    
+    # Import here to avoid circular imports
+    from src.core.phrases import get_phrases
+    
+    todays_seed = datetime.date.today().strftime("%Y%m%d")
+    random.seed(seed_val)
+    
+    phrases = get_phrases()
+    shuffled_phrases = random.sample(phrases, 24)
+    shuffled_phrases.insert(12, FREE_SPACE_TEXT)
+    board = [shuffled_phrases[i:i+5] for i in range(0, 25, 5)]
+    
+    clicked_tiles.clear()
+    for r, row in enumerate(board):
+        for c, phrase in enumerate(row):
+            if phrase.upper() == FREE_SPACE_TEXT:
+                clicked_tiles.add((r, c))
+                
+    today_seed = f"{todays_seed}.{seed_val}"
+    return board
+
+def reset_board() -> None:
+    """Clear all clicked tiles except FREE SPACE."""
+    global clicked_tiles
+    clicked_tiles.clear()
+    for r, row in enumerate(board):
+        for c, phrase in enumerate(row):
+            if phrase.upper() == FREE_SPACE_TEXT:
+                clicked_tiles.add((r, c))
+
+def generate_new_board() -> None:
+    """Generate a completely new board with a new seed."""
+    global board_iteration
+    board_iteration += 1
+    return generate_board(board_iteration)
+
+def toggle_tile(row: int, col: int) -> None:
+    """Toggle the clicked state of a tile."""
+    if (row, col) == FREE_SPACE_POSITION:
+        return
+        
+    key = (row, col)
+    if key in clicked_tiles:
+        clicked_tiles.remove(key)
+    else:
+        clicked_tiles.add(key)

src/core/phrases.py

@@ -0,0 +1,69 @@
+# Phrase loading and processing
+import os
+import logging
+from typing import List
+
+# Global variables
+phrases = []
+last_phrases_mtime = 0
+
+def has_too_many_repeats(phrase: str, threshold=0.5) -> bool:
+    """Returns True if too many words in the phrase repeat."""
+    words = phrase.split()
+    if not words:
+        return False
+    unique_count = len(set(words))
+    ratio = unique_count / len(words)
+    if ratio < threshold:
+        logging.debug(f"Discarding phrase '{phrase}' due to repeats: {unique_count}/{len(words)} = {ratio:.2f} < {threshold}")
+        return True
+    return False
+
+def load_phrases() -> List[str]:
+    """Load and process phrases from phrases.txt."""
+    global phrases, last_phrases_mtime
+    
+    try:
+        last_phrases_mtime = os.path.getmtime("phrases.txt")
+        
+        with open("phrases.txt", "r") as f:
+            raw_phrases = [line.strip().upper() for line in f if line.strip()]
+            
+        # Remove duplicates while preserving order
+        unique_phrases = []
+        seen = set()
+        for p in raw_phrases:
+            if p not in seen:
+                seen.add(p)
+                unique_phrases.append(p)
+                
+        # Filter out phrases with too many repeated words
+        phrases = [p for p in unique_phrases if not has_too_many_repeats(p)]
+        return phrases
+        
+    except Exception as e:
+        logging.error(f"Error loading phrases: {e}")
+        return []
+
+def initialize_phrases() -> None:
+    """Initialize phrases during app startup."""
+    load_phrases()
+
+def get_phrases() -> List[str]:
+    """Get the current phrases list."""
+    return phrases
+
+def check_phrases_file_change() -> bool:
+    """Check if phrases.txt has changed and reload if needed."""
+    global last_phrases_mtime
+    
+    try:
+        mtime = os.path.getmtime("phrases.txt")
+        if mtime != last_phrases_mtime:
+            logging.info("phrases.txt changed, reloading phrases.")
+            load_phrases()
+            return True
+    except Exception as e:
+        logging.error(f"Error checking phrases.txt: {e}")
+    
+    return False

src/core/win_patterns.py

@@ -0,0 +1,100 @@
+# Win condition detection
+from typing import List, Set, Tuple
+from nicegui import ui
+
+# Global state
+bingo_patterns = set()
+
+def check_winner(clicked_tiles: Set[Tuple[int, int]]) -> List[str]:
+    """Check for winning patterns and return newly found ones."""
+    global bingo_patterns
+    new_patterns = []
+    
+    # Check rows and columns
+    for i in range(5):
+        if all((i, j) in clicked_tiles for j in range(5)):
+            if f"row{i}" not in bingo_patterns:
+                new_patterns.append(f"row{i}")
+        if all((j, i) in clicked_tiles for j in range(5)):
+            if f"col{i}" not in bingo_patterns:
+                new_patterns.append(f"col{i}")
+    
+    # Check main diagonal
+    if all((i, i) in clicked_tiles for i in range(5)):
+        if "diag_main" not in bingo_patterns:
+            new_patterns.append("diag_main")
+    
+    # Check anti-diagonal
+    if all((i, 4-i) in clicked_tiles for i in range(5)):
+        if "diag_anti" not in bingo_patterns:
+            new_patterns.append("diag_anti")
+    
+    # Special patterns
+    
+    # Blackout: every cell is clicked
+    if all((r, c) in clicked_tiles for r in range(5) for c in range(5)):
+        if "blackout" not in bingo_patterns:
+            new_patterns.append("blackout")
+    
+    # 4 Corners
+    if all(pos in clicked_tiles for pos in [(0,0), (0,4), (4,0), (4,4)]):
+        if "four_corners" not in bingo_patterns:
+            new_patterns.append("four_corners")
+    
+    # Plus shape
+    plus_cells = {(2, c) for c in range(5)} | {(r, 2) for r in range(5)}
+    if all(cell in clicked_tiles for cell in plus_cells):
+        if "plus" not in bingo_patterns:
+            new_patterns.append("plus")
+    
+    # X shape
+    if all((i, i) in clicked_tiles for i in range(5)) and all((i, 4-i) in clicked_tiles for i in range(5)):
+        if "x_shape" not in bingo_patterns:
+            new_patterns.append("x_shape")
+    
+    # Perimeter
+    perimeter_cells = {(0, c) for c in range(5)} | {(4, c) for c in range(5)} | {(r, 0) for r in range(5)} | {(r, 4) for r in range(5)}
+    if all(cell in clicked_tiles for cell in perimeter_cells):
+        if "perimeter" not in bingo_patterns:
+            new_patterns.append("perimeter")
+    
+    return new_patterns
+
+def process_win_notifications(new_patterns: List[str]) -> None:
+    """Process new win patterns and show appropriate notifications."""
+    global bingo_patterns
+    
+    if not new_patterns:
+        return
+        
+    # Separate new win patterns into standard and special ones
+    special_set = {"blackout", "four_corners", "plus", "x_shape", "perimeter"}
+    standard_new = [p for p in new_patterns if p not in special_set]
+    special_new = [p for p in new_patterns if p in special_set]
+    
+    # Process standard win conditions
+    if standard_new:
+        for pattern in standard_new:
+            bingo_patterns.add(pattern)
+        standard_total = sum(1 for p in bingo_patterns if p not in special_set)
+        
+        if standard_total == 1:
+            message = "BINGO!"
+        elif standard_total == 2:
+            message = "DOUBLE BINGO!"
+        elif standard_total == 3:
+            message = "TRIPLE BINGO!"
+        elif standard_total == 4:
+            message = "QUADRUPLE BINGO!"
+        elif standard_total == 5:
+            message = "QUINTUPLE BINGO!"
+        else:
+            message = f"{standard_total}-WAY BINGO!"
+            
+        ui.notify(message, color="green", duration=5)
+    
+    # Process special win conditions
+    for sp in special_new:
+        bingo_patterns.add(sp)
+        sp_message = sp.replace("_", " ").title() + " Bingo!"
+        ui.notify(sp_message, color="blue", duration=5)