hangman-words 0.1.0__tar.gz

hangman_words-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hangman Words Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hangman_words-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md LICENSE
+recursive-include src/hangman/data *.json

hangman_words-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: hangman-words
+Version: 0.1.0
+Summary: A dependency-free Hangman game with a built-in word and meaning bank.
+Author: Hangman Words Contributors
+License-Expression: MIT
+Keywords: hangman,word-game,vocabulary,education
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Games/Entertainment
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Hangman Words
+
+A small, dependency-free Python package for playing Hangman with a prebuilt vocabulary and learner-friendly word meanings.
+
+## Install
+
+```bash
+python -m pip install hangman-words
+```
+
+## Python API
+
+```python
+from hangman import HangmanGame, default_word_bank
+
+bank = default_word_bank()
+entry = bank.random(category="science")
+game = HangmanGame(entry)
+
+result = game.guess("a")
+print(result.masked_word)
+print(entry.meaning)
+```
+
+The bundled word bank includes technology, science, travel, and vocabulary categories. `WordBank` also accepts your own `WordEntry` objects for custom games.
+
+## Command line
+
+```bash
+hangman
+hangman --category vocabulary --attempts 8
+```
+
+## Build and publish
+
+Build both a wheel and source distribution with:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+```
+
+Upload to TestPyPI first, then PyPI:
+
+```bash
+python -m twine upload --repository testpypi dist/*
+python -m twine upload dist/*
+```
+
+Do not commit API tokens. Configure Twine credentials through its supported keyring or environment-variable workflow.
+
+## License
+
+MIT

hangman_words-0.1.0/README.md

@@ -0,0 +1,55 @@
+# Hangman Words
+
+A small, dependency-free Python package for playing Hangman with a prebuilt vocabulary and learner-friendly word meanings.
+
+## Install
+
+```bash
+python -m pip install hangman-words
+```
+
+## Python API
+
+```python
+from hangman import HangmanGame, default_word_bank
+
+bank = default_word_bank()
+entry = bank.random(category="science")
+game = HangmanGame(entry)
+
+result = game.guess("a")
+print(result.masked_word)
+print(entry.meaning)
+```
+
+The bundled word bank includes technology, science, travel, and vocabulary categories. `WordBank` also accepts your own `WordEntry` objects for custom games.
+
+## Command line
+
+```bash
+hangman
+hangman --category vocabulary --attempts 8
+```
+
+## Build and publish
+
+Build both a wheel and source distribution with:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+```
+
+Upload to TestPyPI first, then PyPI:
+
+```bash
+python -m twine upload --repository testpypi dist/*
+python -m twine upload dist/*
+```
+
+Do not commit API tokens. Configure Twine credentials through its supported keyring or environment-variable workflow.
+
+## License
+
+MIT

hangman_words-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hangman-words"
+version = "0.1.0"
+description = "A dependency-free Hangman game with a built-in word and meaning bank."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+    { name = "Hangman Words Contributors" },
+]
+keywords = ["hangman", "word-game", "vocabulary", "education"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Education",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Games/Entertainment",
+]
+dependencies = []
+
+[project.scripts]
+hangman = "hangman.__main__:main"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+hangman = ["data/*.json"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"

hangman_words-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

hangman_words-0.1.0/src/hangman/__init__.py

@@ -0,0 +1,15 @@
+"""A small, dependency-free Hangman game with built-in vocabulary."""
+
+from .game import GameStatus, GuessResult, HangmanGame, WordEntry
+from .words import WordBank, default_word_bank
+
+__all__ = [
+    "GameStatus",
+    "GuessResult",
+    "HangmanGame",
+    "WordBank",
+    "WordEntry",
+    "default_word_bank",
+]
+
+__version__ = "0.1.0"

hangman_words-0.1.0/src/hangman/__main__.py

@@ -0,0 +1,47 @@
+"""Command-line interface for Hangman."""
+
+from __future__ import annotations
+
+import argparse
+
+from .game import GameStatus, HangmanGame
+from .words import default_word_bank
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Play a vocabulary-building game of Hangman.")
+    parser.add_argument("--category", help="limit the word to a category")
+    parser.add_argument("--attempts", type=int, default=6, help="number of incorrect guesses allowed")
+    args = parser.parse_args()
+
+    bank = default_word_bank()
+    try:
+        game = HangmanGame(bank.random(args.category), max_attempts=args.attempts)
+    except (LookupError, ValueError) as error:
+        parser.error(str(error))
+
+    print("Hangman - type 'quit' to exit")
+    while game.status is GameStatus.PLAYING:
+        print(f"\nWord: {game.masked_word}   Attempts left: {game.remaining_attempts}")
+        guess = input("Guess a letter: ").strip()
+        if guess.lower() == "quit":
+            print(f"The word was {game.entry.word}: {game.entry.meaning}")
+            return
+        try:
+            result = game.guess(guess)
+        except ValueError as error:
+            print(error)
+            continue
+        if result.repeated:
+            print("You already guessed that letter.")
+        elif not result.correct:
+            print("Not in the word.")
+
+    if game.status is GameStatus.WON:
+        print(f"\nYou won! {game.entry.word}: {game.entry.meaning}")
+    else:
+        print(f"\nOut of attempts. The word was {game.entry.word}: {game.entry.meaning}")
+
+
+if __name__ == "__main__":
+    main()

hangman_words-0.1.0/src/hangman/data/words.json

@@ -0,0 +1,79 @@
+[
+  {"word": "algorithm", "meaning": "A step-by-step method for solving a problem.", "category": "technology"},
+  {"word": "browser", "meaning": "Software used to view and navigate websites.", "category": "technology"},
+  {"word": "compiler", "meaning": "A program that translates source code into machine code.", "category": "technology"},
+  {"word": "database", "meaning": "An organized collection of information.", "category": "technology"},
+  {"word": "encryption", "meaning": "The process of protecting information by converting it into a code.", "category": "technology"},
+  {"word": "firewall", "meaning": "A security system that controls network traffic.", "category": "technology"},
+  {"word": "hardware", "meaning": "The physical parts of a computer or electronic system.", "category": "technology"},
+  {"word": "internet", "meaning": "A worldwide network connecting computers and devices.", "category": "technology"},
+  {"word": "keyboard", "meaning": "A set of keys used to enter text or commands.", "category": "technology"},
+  {"word": "pixel", "meaning": "The smallest unit of a digital image.", "category": "technology"},
+  {"word": "robotics", "meaning": "The study and design of machines that can perform tasks.", "category": "technology"},
+  {"word": "software", "meaning": "Programs and instructions that run on a computer.", "category": "technology"},
+  {"word": "galaxy", "meaning": "A huge system of stars, gas, and dust held together by gravity.", "category": "science"},
+  {"word": "gravity", "meaning": "The force that attracts objects toward one another.", "category": "science"},
+  {"word": "molecule", "meaning": "A group of atoms bonded together.", "category": "science"},
+  {"word": "volcano", "meaning": "An opening in Earth's crust through which lava can erupt.", "category": "science"},
+  {"word": "atom", "meaning": "The smallest unit of an element that keeps its properties.", "category": "science"},
+  {"word": "bacteria", "meaning": "Tiny living organisms made of a single cell.", "category": "science"},
+  {"word": "climate", "meaning": "The usual weather conditions of a place over time.", "category": "science"},
+  {"word": "ecosystem", "meaning": "A community of living things and their environment.", "category": "science"},
+  {"word": "fossil", "meaning": "The preserved remains or traces of ancient life.", "category": "science"},
+  {"word": "habitat", "meaning": "The natural home of a plant or animal.", "category": "science"},
+  {"word": "orbit", "meaning": "The curved path of an object around a planet or star.", "category": "science"},
+  {"word": "telescope", "meaning": "An instrument used to observe distant objects in space.", "category": "science"},
+  {"word": "compass", "meaning": "An instrument used to find direction.", "category": "travel"},
+  {"word": "journey", "meaning": "An act of traveling from one place to another.", "category": "travel"},
+  {"word": "lantern", "meaning": "A portable light protected by a transparent covering.", "category": "travel"},
+  {"word": "suitcase", "meaning": "A case used for carrying clothes and belongings while traveling.", "category": "travel"},
+  {"word": "airport", "meaning": "A place where aircraft take off and land.", "category": "travel"},
+  {"word": "backpack", "meaning": "A bag carried on the back with shoulder straps.", "category": "travel"},
+  {"word": "boarding", "meaning": "The act of getting onto a ship, train, or aircraft.", "category": "travel"},
+  {"word": "destination", "meaning": "The place to which someone or something is going.", "category": "travel"},
+  {"word": "itinerary", "meaning": "A planned route or schedule for a journey.", "category": "travel"},
+  {"word": "passport", "meaning": "An official document used to identify a traveler internationally.", "category": "travel"},
+  {"word": "souvenir", "meaning": "An object kept as a reminder of a place or event.", "category": "travel"},
+  {"word": "curious", "meaning": "Eager to learn or know something.", "category": "vocabulary"},
+  {"word": "diligent", "meaning": "Showing careful and persistent effort.", "category": "vocabulary"},
+  {"word": "elegant", "meaning": "Graceful and stylish in appearance or manner.", "category": "vocabulary"},
+  {"word": "resilient", "meaning": "Able to recover quickly from difficulty.", "category": "vocabulary"},
+  {"word": "abundant", "meaning": "Existing in large quantities; plentiful.", "category": "vocabulary"},
+  {"word": "brilliant", "meaning": "Very bright, impressive, or exceptionally clever.", "category": "vocabulary"},
+  {"word": "concise", "meaning": "Expressing something clearly in few words.", "category": "vocabulary"},
+  {"word": "generous", "meaning": "Willing to give or share freely.", "category": "vocabulary"},
+  {"word": "humble", "meaning": "Having a modest view of one's importance.", "category": "vocabulary"},
+  {"word": "precise", "meaning": "Exact and accurate.", "category": "vocabulary"},
+  {"word": "vivid", "meaning": "Producing strong, clear images in the mind.", "category": "vocabulary"},
+  {"word": "waterfall", "meaning": "Water falling over a steep edge in a stream or river.", "category": "nature"},
+  {"word": "meadow", "meaning": "A field of grass and wildflowers.", "category": "nature"},
+  {"word": "mountain", "meaning": "A large natural elevation of Earth's surface.", "category": "nature"},
+  {"word": "rainbow", "meaning": "An arc of colors formed when light passes through water drops.", "category": "nature"},
+  {"word": "sunflower", "meaning": "A tall plant with a large yellow flower.", "category": "nature"},
+  {"word": "thunder", "meaning": "The loud sound caused by lightning.", "category": "nature"},
+  {"word": "woodland", "meaning": "Land covered mainly by trees.", "category": "nature"},
+  {"word": "canvas", "meaning": "A strong cloth surface used for painting.", "category": "arts"},
+  {"word": "melody", "meaning": "A sequence of musical notes forming a recognizable tune.", "category": "arts"},
+  {"word": "palette", "meaning": "A range of colors used by an artist.", "category": "arts"},
+  {"word": "portrait", "meaning": "An artwork depicting a particular person.", "category": "arts"},
+  {"word": "sculpture", "meaning": "A three-dimensional work of art.", "category": "arts"},
+  {"word": "theater", "meaning": "A place where plays and performances are presented.", "category": "arts"},
+  {"word": "poetry", "meaning": "Literature that uses concentrated language and artistic rhythm.", "category": "arts"},
+  {"word": "rhythm", "meaning": "A regular pattern of beats or movements.", "category": "arts"},
+  {"word": "ancient", "meaning": "Belonging to a very distant time in history.", "category": "history"},
+  {"word": "empire", "meaning": "A group of territories ruled by one authority.", "category": "history"},
+  {"word": "heritage", "meaning": "Traditions, achievements, and objects passed down through generations.", "category": "history"},
+  {"word": "medieval", "meaning": "Relating to the period of European history between ancient and modern times.", "category": "history"},
+  {"word": "monument", "meaning": "A structure built to remember a person or event.", "category": "history"},
+  {"word": "pioneer", "meaning": "A person who is among the first to explore or develop something.", "category": "history"},
+  {"word": "revolution", "meaning": "A major and often sudden change in government or society.", "category": "history"},
+  {"word": "timeline", "meaning": "A display of events arranged in the order they happened.", "category": "history"},
+  {"word": "biscuit", "meaning": "A small baked food that is often crisp or lightly sweet.", "category": "food"},
+  {"word": "cinnamon", "meaning": "A fragrant spice made from tree bark.", "category": "food"},
+  {"word": "ingredient", "meaning": "One of the foods used to make a dish.", "category": "food"},
+  {"word": "noodle", "meaning": "A thin strip of dough cooked as food.", "category": "food"},
+  {"word": "pancake", "meaning": "A thin, flat cake cooked in a pan.", "category": "food"},
+  {"word": "sandwich", "meaning": "Food made by placing a filling between slices of bread.", "category": "food"},
+  {"word": "seasoning", "meaning": "An ingredient added to improve the flavor of food.", "category": "food"},
+  {"word": "vegetable", "meaning": "A plant or part of a plant eaten as food.", "category": "food"}
+]

hangman_words-0.1.0/src/hangman/game.py

@@ -0,0 +1,113 @@
+"""Core Hangman game state and rules."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+class GameStatus(str, Enum):
+    """Possible states of a Hangman game."""
+
+    PLAYING = "playing"
+    WON = "won"
+    LOST = "lost"
+
+
+@dataclass(frozen=True, slots=True)
+class WordEntry:
+    """A playable word and its learner-friendly meaning."""
+
+    word: str
+    meaning: str
+    category: str = "general"
+
+    def __post_init__(self) -> None:
+        normalized = self.word.strip().lower()
+        if not normalized.isalpha():
+            raise ValueError("word must contain letters only")
+        if not self.meaning.strip():
+            raise ValueError("meaning cannot be empty")
+        object.__setattr__(self, "word", normalized)
+        object.__setattr__(self, "meaning", self.meaning.strip())
+        object.__setattr__(self, "category", self.category.strip().lower() or "general")
+
+
+@dataclass(frozen=True, slots=True)
+class GuessResult:
+    """The outcome of a guess submitted to a game."""
+
+    letter: str
+    correct: bool
+    repeated: bool
+    status: GameStatus
+    masked_word: str
+    remaining_attempts: int
+
+
+class HangmanGame:
+    """Play one Hangman round.
+
+    The game accepts one letter at a time, ignores letter case, and allows
+    repeated guesses without charging an additional attempt.
+    """
+
+    def __init__(self, entry: WordEntry, max_attempts: int = 6) -> None:
+        if max_attempts < 1:
+            raise ValueError("max_attempts must be at least 1")
+        self.entry = entry
+        self.max_attempts = max_attempts
+        self._guessed_letters: set[str] = set()
+        self._incorrect_letters: set[str] = set()
+        self._status = GameStatus.PLAYING
+
+    @property
+    def guessed_letters(self) -> frozenset[str]:
+        return frozenset(self._guessed_letters)
+
+    @property
+    def incorrect_letters(self) -> frozenset[str]:
+        return frozenset(self._incorrect_letters)
+
+    @property
+    def remaining_attempts(self) -> int:
+        return self.max_attempts - len(self._incorrect_letters)
+
+    @property
+    def status(self) -> GameStatus:
+        return self._status
+
+    @property
+    def masked_word(self) -> str:
+        return " ".join(
+            letter if letter in self._guessed_letters else "_"
+            for letter in self.entry.word
+        )
+
+    def guess(self, letter: str) -> GuessResult:
+        """Submit a single alphabetic letter and return the result."""
+        normalized = letter.strip().lower()
+        if len(normalized) != 1 or not normalized.isalpha():
+            raise ValueError("guess must be a single letter")
+        if self._status is not GameStatus.PLAYING:
+            raise RuntimeError("the game is already over")
+
+        repeated = normalized in self._guessed_letters
+        if not repeated:
+            self._guessed_letters.add(normalized)
+            if normalized not in self.entry.word:
+                self._incorrect_letters.add(normalized)
+
+        if all(character in self._guessed_letters for character in self.entry.word):
+            self._status = GameStatus.WON
+        elif self.remaining_attempts == 0:
+            self._status = GameStatus.LOST
+
+        return GuessResult(
+            letter=normalized,
+            correct=normalized in self.entry.word,
+            repeated=repeated,
+            status=self._status,
+            masked_word=self.masked_word,
+            remaining_attempts=self.remaining_attempts,
+        )

hangman_words-0.1.0/src/hangman/words.py

@@ -0,0 +1,50 @@
+"""Load and query the built-in Hangman vocabulary."""
+
+from __future__ import annotations
+
+import json
+import random
+from importlib.resources import files
+from typing import Iterable
+
+from .game import WordEntry
+
+
+class WordBank:
+    """An immutable collection of playable words."""
+
+    def __init__(self, entries: Iterable[WordEntry]) -> None:
+        self._entries = tuple(entries)
+        if not self._entries:
+            raise ValueError("word bank cannot be empty")
+
+    def __len__(self) -> int:
+        return len(self._entries)
+
+    def __iter__(self):
+        return iter(self._entries)
+
+    @property
+    def entries(self) -> tuple[WordEntry, ...]:
+        return self._entries
+
+    def categories(self) -> tuple[str, ...]:
+        return tuple(sorted({entry.category for entry in self._entries}))
+
+    def by_category(self, category: str) -> tuple[WordEntry, ...]:
+        normalized = category.strip().lower()
+        return tuple(entry for entry in self._entries if entry.category == normalized)
+
+    def random(self, category: str | None = None, rng: random.Random | None = None) -> WordEntry:
+        """Choose a random entry, optionally limited to one category."""
+        choices = self.by_category(category) if category else self._entries
+        if not choices:
+            raise LookupError(f"no words found for category: {category}")
+        return (rng or random).choice(choices)
+
+
+def default_word_bank() -> WordBank:
+    """Return the vocabulary distributed with the package."""
+    resource = files("hangman").joinpath("data/words.json")
+    records = json.loads(resource.read_text(encoding="utf-8"))
+    return WordBank(WordEntry(**record) for record in records)

hangman_words-0.1.0/src/hangman_words.egg-info/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: hangman-words
+Version: 0.1.0
+Summary: A dependency-free Hangman game with a built-in word and meaning bank.
+Author: Hangman Words Contributors
+License-Expression: MIT
+Keywords: hangman,word-game,vocabulary,education
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Games/Entertainment
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Hangman Words
+
+A small, dependency-free Python package for playing Hangman with a prebuilt vocabulary and learner-friendly word meanings.
+
+## Install
+
+```bash
+python -m pip install hangman-words
+```
+
+## Python API
+
+```python
+from hangman import HangmanGame, default_word_bank
+
+bank = default_word_bank()
+entry = bank.random(category="science")
+game = HangmanGame(entry)
+
+result = game.guess("a")
+print(result.masked_word)
+print(entry.meaning)
+```
+
+The bundled word bank includes technology, science, travel, and vocabulary categories. `WordBank` also accepts your own `WordEntry` objects for custom games.
+
+## Command line
+
+```bash
+hangman
+hangman --category vocabulary --attempts 8
+```
+
+## Build and publish
+
+Build both a wheel and source distribution with:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/*
+```
+
+Upload to TestPyPI first, then PyPI:
+
+```bash
+python -m twine upload --repository testpypi dist/*
+python -m twine upload dist/*
+```
+
+Do not commit API tokens. Configure Twine credentials through its supported keyring or environment-variable workflow.
+
+## License
+
+MIT

hangman_words-0.1.0/src/hangman_words.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+src/hangman/__init__.py
+src/hangman/__main__.py
+src/hangman/game.py
+src/hangman/words.py
+src/hangman/data/words.json
+src/hangman_words.egg-info/PKG-INFO
+src/hangman_words.egg-info/SOURCES.txt
+src/hangman_words.egg-info/dependency_links.txt
+src/hangman_words.egg-info/entry_points.txt
+src/hangman_words.egg-info/top_level.txt
+tests/test_game.py

hangman_words-0.1.0/src/hangman_words.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hangman_words-0.1.0/src/hangman_words.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hangman = hangman.__main__:main

hangman_words-0.1.0/src/hangman_words.egg-info/top_level.txt

@@ -0,0 +1 @@
+hangman

hangman_words-0.1.0/tests/test_game.py

@@ -0,0 +1,41 @@
+from hangman import GameStatus, HangmanGame, WordEntry, default_word_bank
+
+
+def test_default_bank_contains_words_and_categories():
+    bank = default_word_bank()
+
+    assert len(bank) >= 16
+    assert {"science", "technology"}.issubset(bank.categories())
+    assert bank.by_category("SCIENCE")
+
+
+def test_game_wins_and_reveals_meaning():
+    game = HangmanGame(WordEntry("cat", "A small domesticated mammal."))
+
+    for letter in "cat":
+        result = game.guess(letter)
+
+    assert result.status is GameStatus.WON
+    assert result.masked_word == "c a t"
+    assert game.remaining_attempts == 6
+
+
+def test_repeated_guess_does_not_cost_attempt():
+    game = HangmanGame(WordEntry("book", "A written work."), max_attempts=2)
+
+    first = game.guess("x")
+    second = game.guess("x")
+
+    assert not first.correct
+    assert second.repeated
+    assert game.remaining_attempts == 1
+
+
+def test_game_loses_after_incorrect_guesses():
+    game = HangmanGame(WordEntry("sun", "The star at the center of our solar system."), max_attempts=2)
+
+    game.guess("x")
+    result = game.guess("y")
+
+    assert result.status is GameStatus.LOST
+    assert game.masked_word == "_ _ _"