Add EASY MODE and fix wordlist selections

battlewords/logic.py

@@ -64,7 +64,10 @@ def guess_word(state: GameState, guess_text: str) -> Tuple[bool, int]:
     state.guessed.add(target.text)
 
     state.last_action = f"Correct! +{points} points for {target.text}."
-    state.can_guess = True  # <-- Allow another guess after a correct guess
+    if state.game_mode == "standard":
+        state.can_guess = True  # <-- Allow another guess after a correct guess
+    else:
+        state.can_guess = False
     return True, points
 
 

battlewords/models.py

@@ -67,4 +67,5 @@ class GameState:
     score: int
     last_action: str
     can_guess: bool
+    game_mode: Literal["standard", "easy"] = "standard"
     points_by_word: Dict[str, int] = field(default_factory=dict)

battlewords/ui.py

@@ -221,6 +221,8 @@ def _init_session() -> None:
     files = get_wordlist_files()
     if "selected_wordlist" not in st.session_state and files:
         st.session_state.selected_wordlist = "wordlist.txt"
+    if "game_mode" not in st.session_state:
+        st.session_state.game_mode = "standard"
 
     words = load_word_list(st.session_state.get("selected_wordlist"))
     puzzle = generate_puzzle(grid_size=12, words_by_len=words)
@@ -236,12 +238,19 @@ def _init_session() -> None:
     st.session_state.letter_map = build_letter_map(puzzle)
     st.session_state.initialized = True
     st.session_state.radar_gif_path = None  # Add this line
+    # Ensure game_mode is set
+    if "game_mode" not in st.session_state:
+        st.session_state.game_mode = "standard"
+
 
 def _new_game() -> None:
     selected = st.session_state.get("selected_wordlist")
+    mode = st.session_state.get("game_mode")
     st.session_state.clear()
     if selected:
         st.session_state.selected_wordlist = selected
+    if mode:
+        st.session_state.game_mode = mode
     st.session_state.radar_gif_path = None  # Reset radar GIF path
     _init_session()
 
@@ -255,6 +264,7 @@ def _to_state() -> GameState:
         score=st.session_state.score,
         last_action=st.session_state.last_action,
         can_guess=st.session_state.can_guess,
+        game_mode=st.session_state.get("game_mode", "standard"),
         points_by_word=st.session_state.points_by_word,
     )
 
@@ -288,7 +298,21 @@ def _render_sidebar():
             "- Radar pulses show the last letter position of each hidden word.\n"
             "- After each reveal, you may submit one word guess below.\n"
             "- Scoring: length + unrevealed letters of that word at guess time.")
-        
+
+        st.header("Game Mode")
+        game_modes = ["standard", "easy"]
+        default_mode = "standard"
+        if "game_mode" not in st.session_state:
+            st.session_state.game_mode = default_mode
+        current_mode = st.session_state.game_mode
+        st.selectbox(
+            "Select game mode",
+            options=game_modes,
+            index=game_modes.index(current_mode) if current_mode in game_modes else 0,
+            key="game_mode",
+            on_change=_new_game,
+        )
+
         st.header("Wordlist Controls")
         wordlist_files = get_wordlist_files()
 
@@ -620,7 +644,7 @@ def _render_score_panel(state: GameState):
         with st.expander("Game summary", expanded=True):
             for w in state.puzzle.words:
                 pts = state.points_by_word.get(w.text, 0)
-                if pts > 0:
+                if pts > 0 or state.game_mode=="easy":
                     st.markdown(f"- {w.text} ({len(w.text)}): +{pts} points")
             st.markdown(f"**Total**: {state.score}")
 

battlewords/word_loader.py

@@ -22,6 +22,9 @@ FALLBACK_WORDS: Dict[int, List[str]] = {
     ],
 }
 
+MIN_REQUIRED = 25  # Per specs: require >= 500 per length before using file contents
+
+
 def get_wordlist_files() -> list[str]:
     words_dir = os.path.join(os.path.dirname(__file__), "words")
     if not os.path.isdir(words_dir):
@@ -29,16 +32,20 @@ def get_wordlist_files() -> list[str]:
     files = [f for f in os.listdir(words_dir) if f.lower().endswith(".txt")]
     return sorted(files)
 
+
 @st.cache_data(show_spinner=False)
 def load_word_list(selected_file: Optional[str] = None) -> Dict[int, List[str]]:
     """
     Load a word list, filter to uppercase A–Z, lengths in {4,5,6}, and dedupe while preserving order.
 
     If `selected_file` is provided, load battlewords/words/<selected_file>.
-    Otherwise, try packaged resource battlewords/words/wordlist.txt.
+    Otherwise, try on-disk default battlewords/words/wordlist.txt; if unavailable, try packaged resource.
 
     If fewer than 500 entries exist for any required length, fall back to built-ins
     for that length (per specs).
+
+    NOTE: To ensure cache updates when the user picks a different file, always pass
+    the `selected_file` argument from the UI/generator.
     """
     words_by_len: Dict[int, List[str]] = {4: [], 5: [], 6: []}
     used_source = "fallback"
@@ -58,15 +65,36 @@ def load_word_list(selected_file: Optional[str] = None) -> Dict[int, List[str]]:
         with open(path, "r", encoding="utf-8") as f:
             return f.read()
 
+    def _read_default_text() -> Optional[str]:
+        # Prefer the on-disk default in the editable repo
+        try:
+            return _read_text_from_disk("wordlist.txt")
+        except Exception:
+            pass
+        # Fallback to packaged data if available
+        try:
+            return resources.files("battlewords.words").joinpath("wordlist.txt").read_text(encoding="utf-8")
+        except Exception:
+            return None
+
     try:
         text: Optional[str] = None
+        source_label = "fallback"
 
         if selected_file:
-            # Prefer explicit selection from words/ directory.
+            # Validate selection against available files to avoid bad paths
+            available = set(get_wordlist_files())
+            if selected_file not in available:
+                raise FileNotFoundError(f"Selected word list '{selected_file}' not found in words/ directory.")
             text = _read_text_from_disk(selected_file)
+            source_label = f"file:{selected_file}"
         else:
-            # Fallback to packaged default wordlist.txt
-            text = resources.files("battlewords.words").joinpath("wordlist.txt").read_text(encoding="utf-8")
+            text = _read_default_text()
+            if text is not None:
+                source_label = "default"
+
+        if text is None:
+            raise FileNotFoundError("No word list file found on disk or in packaged resources.")
 
         seen = {4: set(), 5: set(), 6: set()}
         for raw in text.splitlines():
@@ -84,17 +112,17 @@ def load_word_list(selected_file: Optional[str] = None) -> Dict[int, List[str]]:
                 seen[L].add(word)
 
         counts = {k: len(v) for k, v in words_by_len.items()}
-        if all(counts[k] >= 250 for k in (4, 5, 6)):
-            used_source = "file"
+        if all(counts[k] >= MIN_REQUIRED for k in (4, 5, 6)):
+            used_source = source_label
             return _finalize(words_by_len, used_source)
 
         # Per spec: fallback for any length below threshold
         mixed: Dict[int, List[str]] = {
-            4: words_by_len[4] if counts[4] >= 250 else FALLBACK_WORDS[4],
-            5: words_by_len[5] if counts[5] >= 250 else FALLBACK_WORDS[5],
-            6: words_by_len[6] if counts[6] >= 250 else FALLBACK_WORDS[6],
+            4: words_by_len[4] if counts[4] >= MIN_REQUIRED else FALLBACK_WORDS[4],
+            5: words_by_len[5] if counts[5] >= MIN_REQUIRED else FALLBACK_WORDS[5],
+            6: words_by_len[6] if counts[6] >= MIN_REQUIRED else FALLBACK_WORDS[6],
         }
-        used_source = "file+fallback" if any(counts[k] >= 250 for k in (4, 5, 6)) else "fallback"
+        used_source = f"{source_label}+fallback" if any(counts[k] >= MIN_REQUIRED for k in (4, 5, 6)) else "fallback"
         return _finalize(mixed, used_source)
 
     except Exception: