fiction.py

from dataclasses import dataclass
from enum import Flag, auto
from typing import NamedTuple, Optional
from typeguard import typechecked
from words import is_word

class LetterResult(Flag):
    NONE    = 0
    IN_WORD = auto()
    CORRECT = auto()
    
class Lie(NamedTuple):
    result  : LetterResult
    index   : int
    
SUPPORTED_WORD_LENGTHS = [5]

@dataclass(init=False)
class GameSettings:
    rounds : int = 10
    checks : int = 3
    wordLength : int = 5
    
    @typechecked
    def __init__(self, rounds : int = 10, checks : int = 3, wordLength : int = 5):
        assert rounds > 0, f'Rounds \'{rounds}\' must be a positive integer'
        assert checks >= 0, f'Check count \'{checks}\' cannot be negative'
        assert wordLength in SUPPORTED_WORD_LENGTHS, f'World Length \'{wordLength}\' not supported. Available lengths are {SUPPORTED_WORD_LENGTHS}'
        self.rounds = rounds
        self.checks = checks
        self.wordLength = wordLength

@dataclass(init=False)
class Guess:
    word    : str
    lie     : Lie
    checkedIndex : int
    
    def __init__(self, word : str):
        self.word = word
        self.lie = None
        self.checkedIndex = -1
    
class GameState(Flag):
    NONE            = 0
    IN_PROGRESS     = auto()
    GUESSER_WON     = auto()
    LIEBRARIAN_WON  = auto()
    ABANDONDED      = auto()

@dataclass(init=False)
class Game:
    winWord     : str
    settings    : GameSettings
    
    firstLetter : str
    guesses     : list[Guess]
    
    state      : GameState
    
    @property
    def lastGuess(self) -> Optional[Guess]: 
        return self.guesses[-1] if len(self.guesses) > 0 else None
    
    @property
    def wordLength(self) -> int:
        return self.settings.wordLength
    
    @property
    def currentRound(self) -> int:
        return len(self.guesses) + 1
    
    @property
    def remaingRounds(self) -> int:
        return self.settings.rounds - len(self.guesses)
    
    @property            
    def checksUsed(self) -> int:
        count = 0
        for guess in self.guesses:
            if self.valid_index(guess.checkedIndex):
                count += 1
        return count
    
    @property
    def checksRemaing(self) -> int:
        return self.settings.checks - self.checksUsed
    
    @property
    def hasWord(self) -> bool:
        return self.winWord is not None and len(self.winWord) > 0
    
    @property
    def checkedFirstLetter(self) -> bool:
        return self.firstLetter is not None and len(self.firstLetter) == 1
    
    @typechecked
    def __init__(self, settings : GameSettings = GameSettings()):
        self.settings = settings
        self.winWord = None
        self.firstLetter = None
        self.guesses = list()
        self.state = GameState.IN_PROGRESS
        
    @typechecked
    def pick_word(self, winWord : str):
        assert not self.hasWord, 'Word has already been selected'
        assert len(winWord) == self.settings.wordLength, f'Word must be {self.settings.wordLength} characters long'
        self.winWord = winWord.upper()
    
    WORD_NOT_PICKED_MSG = 'The target word has not been selected yet'
    
    @typechecked
    def check_first_letter(self, letter : str) -> bool:
        assert self.hasWord, self.WORD_NOT_PICKED_MSG
        assert not self.checkedFirstLetter, f'Cannot check more than one letter. \'{self.firstLetter}\' has already been checked to{(" not" if self.firstLetter not in self.winWord else "")} be in the word'
        assert len(letter) == 1, f'\'{letter}\' must be a single letter'
        assert letter.isalpha(), f'\'{letter}\' must be an english letter'
        
        self.firstLetter = letter.upper()
        return letter in self.winWord
    
    @typechecked
    def make_guess(self, word : str) -> GameState:
        assert self.hasWord, self.WORD_NOT_PICKED_MSG
        assert self.checkedFirstLetter, 'First letter has not been verified yet'
        assert len(word) == len(self.winWord), f'Word must be {len(self.winWord)} characters long'
        assert len(self.guesses) < self.settings.rounds, f'Max guesses have been reached ({self.settings.rounds})'

        word = word.upper()
                
        def used_word() -> bool:
            for guess in self.guesses:
                if guess.word == word:
                    return True
            return False
        
        assert not used_word(), f'Already used word \"{word}\"'
        assert is_word(word), f'"{word}" is not a valid word'
        
        self.guesses.append(Guess(word))
        
        if word == self.winWord:
            self.state = GameState.GUESSER_WON
        elif len(self.guesses) == self.settings.rounds:
            self.state = GameState.LIEBRARIAN_WON
        
        return self.state

    NO_GUESSES_MSG = 'No guesses have been made'

    def can_give_lie(self) -> bool:
        assert self.winWord is not None, self.WORD_NOT_PICKED_MSG
        assert self.lastGuess is not None, self.NO_GUESSES_MSG
        assert self.lastGuess.lie is None, 'Already given a lie'
        return True

    @typechecked
    def give_lie(self, lie : Lie):
        assert self.winWord is not None, self.WORD_NOT_PICKED_MSG
        assert self.lastGuess is not None, self.NO_GUESSES_MSG
        assert self.valid_index(lie.index), f'Lie index \'{lie.index}\' is not within word length of \'{len}'
                
        guess : Guess = self.lastGuess
        assert guess.lie is None, 'Already given a lie'
        assert lie != self.letter_result(guess.word[lie.index], lie.index), 'Not a real lie'
        
        guess.lie = lie
    
    def can_check_lie(self) -> bool:
        assert self.winWord is not None, self.WORD_NOT_PICKED_MSG
        assert self.has_guess(), self.NO_GUESSES_MSG
        assert self.checksUsed < self.settings.checks, f'All checks have been used ({self.settings.checks})'

        guess = self.lastGuess
        
        assert guess.lie is not None, 'Clue has not been given yet'
        assert not self.valid_index(guess.checkedIndex), f'Already checked most recent guess ({guess.word})'
        return True
    
    @typechecked
    def check_is_lie(self, index : int) -> bool:
        if not self.can_check_lie():
            return False
        
        assert self.valid_index(index), f'{index} is not a valid index'
        
        guess = self.lastGuess
        guess.checkedIndex = index
        return guess.lie.index == index
    
    @typechecked
    def letter_result(self, letter : str, index : int) -> LetterResult:
        assert self.winWord is not None, self.WORD_NOT_PICKED_MSG
        assert(self.valid_index(index))
        assert(len(letter) == 1)
        letter = letter.upper()
        
        if self.winWord[index] == letter:
            return LetterResult.CORRECT
        if letter in self.winWord:
            return LetterResult.IN_WORD
        
        return LetterResult.NONE
    
    def has_guess(self) -> bool:
        return len(self.guesses) > 0
    
    @typechecked
    def valid_index(self, index : Optional[int]) -> bool: 
        return index is not None and index >= 0 and index < len(self.winWord)