Игра в виселицу на Python

# Простейший скелет игры "Виселица"
word_to_guess = "программирование"
guessed_letters = []
attempts = 6
 
while attempts > 0:
    # Логика игры...
    pass

import random
 
word_list = [
    "программирование", "разработка", "питон", "алгоритм", 
    "интерфейс", "функция", "переменная", "список", "словарь"
]

def choose_word(words):
    return random.choice(words)
 
secret_word = choose_word(word_list)

max_attempts = 6  # Классическое количество попыток в "Виселице"
attempts_left = max_attempts
guessed_letters = []
game_over = False

def display_word(word, guessed):
    displayed = ""
    for letter in word:
        if letter in guessed:
            displayed += letter + " "
        else:
            displayed += "_ "
    return displayed.strip()

hangman_stages = [
    """
    -----
    |   |
        |
        |
        |
        |
    ------
    """,
    # Другие стадии виселицы...
]
 
def display_hangman(attempts):
    return hangman_stages[max_attempts - attempts]

while not game_over:
    # Выводим текущее состояние
    print(display_hangman(attempts_left))
    print(display_word(secret_word, guessed_letters))
    print(f"Угаданные буквы: {', '.join(guessed_letters)}")
    print(f"Осталось попыток: {attempts_left}")
    
    # Запрашиваем ввод пользователя
    guess = input("Введите букву: ").lower()
    
    # Проверяем введенную букву
    if len(guess) != 1 or not guess.isalpha():
        print("Пожалуйста, введите одну букву!")
        continue
    
    if guess in guessed_letters:
        print("Вы уже угадывали эту букву!")
        continue
    
    # Добавляем букву к угаданным
    guessed_letters.append(guess)
    
    # Проверяем, есть ли буква в слове
    if guess in secret_word:
        print("Верно! Такая буква есть в слове.")
        
        # Проверяем, не угадано ли все слово
        if all(letter in guessed_letters for letter in secret_word):
            print(f"Поздравляем! Вы угадали слово: {secret_word}")
            game_over = True
    else:
        print("Увы, такой буквы нет в слове.")
        attempts_left -= 1
        
        # Проверяем, не закончились ли попытки
        if attempts_left == 0:
            print(display_hangman(attempts_left))
            print(f"Игра окончена! Загаданное слово: {secret_word}")
            game_over = True

if all(letter in guessed_letters for letter in secret_word):

def choose_word(difficulty="medium"):
    word_categories = {
        "easy": ["кот", "дом", "мяч", "лес", "сон"],
        "medium": ["питон", "облако", "программа", "телефон"],
        "hard": ["архитектура", "интеграция", "абстракция", "полиморфизм"]
    }
    
    return random.choice(word_categories[difficulty])

def load_words_from_file(filename):
    with open(filename, 'r', encoding='utf-8') as file:
        return [word.strip() for word in file if word.strip()]
        
def get_word_from_api():
    import requests
    response = requests.get('https://api.wordnik.com/v4/words.json/randomWord')
    return response.json()['word']

def update_word_state(secret_word, guessed_letters):
    return ''.join([letter if letter in guessed_letters else '_' for letter in secret_word])

def is_word_guessed(secret_word, guessed_letters):
    secret_letters = set(secret_word)
    return secret_letters.issubset(guessed_letters)

def get_valid_input():
    while True:
        guess = input("Введите букву: ").lower().strip()
        
        # Проверка на пустой ввод
        if not guess:
            print("Вы ничего не ввели. Попробуйте снова.")
            continue
            
        # Проверка на длину ввода
        if len(guess) > 1:
            print("Пожалуйста, введите только одну букву.")
            continue
            
        # Проверка что введена буква, а не другой символ
        if not guess.isalpha():
            print("Пожалуйста, введите букву, а не цифру или спецсимвол.")
            continue
            
        return guess

def is_russian_letter(char):
    return 'а' <= char <= 'я' or char == 'ё'
 
def get_valid_input(language='any'):
    while True:
        guess = input("Введите букву: ").lower().strip()
        
        if not guess:
            print("Вы ничего не ввели.")
            continue
            
        if len(guess) > 1:
            print("Введите только одну букву.")
            continue
            
        if language == 'russian' and not is_russian_letter(guess):
            print("Пожалуйста, введите букву русского алфавита.")
            continue
            
        if language == 'english' and not (ord('a') <= ord(guess) <= ord('z')):
            print("Пожалуйста, введите букву английского алфавита.")
            continue
            
        if language == 'any' and not guess.isalpha():
            print("Пожалуйста, введите букву, а не другой символ.")
            continue
            
        return guess

ALPHABETS = {
    'russian': 'абвгдеёжзийклмнопрстуфхцчшщъыьэюя',
    'english': 'abcdefghijklmnopqrstuvwxyz',
    'digits': '0123456789'
}
 
def is_valid_char(char, allowed_types):
    """Проверяет, что символ входит в разрешенные типы."""
    return any(char in ALPHABETS[alphabet] for alphabet in allowed_types if alphabet in ALPHABETS)

if guess in guessed_letters:
    print("Вы уже угадывали эту букву!")
    continue

def provide_hint(guess, guessed_letters, secret_word):
    if guess in guessed_letters:
        similar_letters = [letter for letter in secret_word if letter in guessed_letters]
        if similar_letters:
            return f"Вы уже вводили букву '{guess}'. Попробуйте что-то похожее на '{random.choice(similar_letters)}'."
        else:
            return f"Вы уже вводили букву '{guess}'. Попробуйте что-то новое."
    return None

import re
 
def sanitize_input(user_input):
    # Удаляем все, кроме букв и цифр
    return re.sub(r'[^a-zA-Zа-яА-ЯёЁ0-9]', '', user_input)
 
# Использование
user_guess = sanitize_input(input("Введите букву: "))

def safe_input(prompt):
    try:
        return input(prompt)
    except (KeyboardInterrupt, EOFError):
        print("\nИгра прервана пользователем.")
        exit(0)
    except Exception as e:
        print(f"\nПроизошла ошибка: {e}")
        return ""

class Word:
    def __init__(self, word_list=None, word=None):
        self.word_list = word_list or ["программирование", "алгоритм", "разработка"]
        self._word = word or random.choice(self.word_list)
        self.guessed_letters = []
        
    @property
    def word(self):
        return self._word
        
    def display_current_state(self):
        """Возвращает текущее состояние слова с угаданными буквами."""
        return " ".join(letter if letter in self.guessed_letters else "_" for letter in self.word)
        
    def guess(self, letter):
        """Проверяет, есть ли буква в слове и обновляет статус."""
        self.guessed_letters.append(letter)
        return letter in self.word
        
    def is_word_guessed(self):
        """Проверяет, угадано ли всё слово."""
        return all(letter in self.guessed_letters for letter in self.word)

class Player:
    def __init__(self, max_attempts=6):
        self.max_attempts = max_attempts
        self.attempts_left = max_attempts
        self.guessed_letters = []
        
    def make_guess(self, letter):
        """Игрок делает предположение."""
        if letter not in self.guessed_letters:
            self.guessed_letters.append(letter)
            return True
        return False
        
    def reduce_attempt(self):
        """Уменьшает количество оставшихся попыток."""
        self.attempts_left -= 1
        
    def has_attempts_left(self):
        """Проверяет, остались ли у игрока попытки."""
        return self.attempts_left > 0

class Display:
    def __init__(self):
        self.hangman_stages = [
            # ASCII-art различных стадий виселицы
        ]
    
    def show_hangman(self, attempts_left, max_attempts):
        """Отображает текущее состояние виселицы."""
        stage = max_attempts - attempts_left
        print(self.hangman_stages[stage])
        
    def show_game_status(self, word_state, guessed_letters, attempts_left):
        """Отображает текущий статус игры."""
        print(f"Текущее слово: {word_state}")
        print(f"Угаданные буквы: {', '.join(guessed_letters)}")
        print(f"Осталось попыток: {attempts_left}")
        
    def show_win_message(self, word):
        """Отображает сообщение о победе."""
        print(f"Поздравляем! Вы угадали слово: {word}")
        
    def show_lose_message(self, word):
        """Отображает сообщение о проигрыше."""
        print(f"Игра окончена! Загаданное слово было: {word}")

class HangmanGame:
    def __init__(self, word_list=None):
        self.word = Word(word_list)
        self.player = Player()
        self.display = Display()
        self.game_over = False
        
    def start(self):
        """Запускает игровой цикл."""
        while not self.game_over:
            self._play_turn()
            
    def _play_turn(self):
        """Обрабатывает один игровой ход."""
        # Отображение текущего состояния
        self.display.show_hangman(self.player.attempts_left, self.player.max_attempts)
        self.display.show_game_status(
            self.word.display_current_state(),
            self.player.guessed_letters,
            self.player.attempts_left
        )
        
        # Получение ввода пользователя
        guess = self._get_valid_input()
        
        # Обработка хода
        if self.player.make_guess(guess):
            if self.word.guess(guess):
                print("Верно! Такая буква есть в слове.")
                
                # Проверка на победу
                if self.word.is_word_guessed():
                    self.display.show_win_message(self.word.word)
                    self.game_over = True
            else:
                print("Увы, такой буквы нет в слове.")
                self.player.reduce_attempt()
                
                # Проверка на проигрыш
                if not self.player.has_attempts_left():
                    self.display.show_hangman(0, self.player.max_attempts)
                    self.display.show_lose_message(self.word.word)
                    self.game_over = True
        else:
            print("Вы уже угадывали эту букву!")
            
    def _get_valid_input(self):
        """Получает и валидирует ввод пользователя."""
        while True:
            guess = input("Введите букву: ").lower().strip()
            
            if not guess:
                print("Вы ничего не ввели. Попробуйте снова.")
                continue
                
            if len(guess) > 1:
                print("Пожалуйста, введите только одну букву.")
                continue
                
            if not guess.isalpha():
                print("Пожалуйста, введите букву, а не другой символ.")
                continue
                
            return guess

if __name__ == "__main__":
    game = HangmanGame()
    game.start()

# Model - модель данных
class HangmanModel:
    def __init__(self, word_list=None):
        self.word = Word(word_list)
        self.player = Player()
        self.observers = []
        
    def register_observer(self, observer):
        self.observers.append(observer)
        
    def notify_observers(self, event_type, data=None):
        for observer in self.observers:
            observer.update(event_type, data)
            
    def make_guess(self, letter):
        # Логика обработки хода
        result = {}
        
        if letter in self.player.guessed_letters:
            result["status"] = "repeat"
            self.notify_observers("repeat_guess", letter)
            return result
            
        self.player.guessed_letters.append(letter)
        
        if letter in self.word.word:
            result["status"] = "correct"
            self.word.guessed_letters.append(letter)
            self.notify_observers("correct_guess", letter)
            
            if self.is_word_guessed():
                result["game_over"] = True
                result["win"] = True
                self.notify_observers("game_won", self.word.word)
        else:
            result["status"] = "wrong"
            self.player.reduce_attempt()
            self.notify_observers("wrong_guess", letter)
            
            if not self.player.has_attempts_left():
                result["game_over"] = True
                result["win"] = False
                self.notify_observers("game_lost", self.word.word)
                
        return result
        
    def is_word_guessed(self):
        return all(letter in self.word.guessed_letters for letter in self.word.word)
        
    def get_game_state(self):
        return {
            "word_state": self.word.display_current_state(),
            "attempts_left": self.player.attempts_left,
            "max_attempts": self.player.max_attempts,
            "guessed_letters": self.player.guessed_letters
        }

# View - представление (интерфейс пользователя)
class ConsoleView:
    def __init__(self):
        self.hangman_stages = [
            # ASCII-art для разных стадий виселицы
        ]
        
    def update(self, event_type, data=None):
        if event_type == "game_start":
            print("Добро пожаловать в игру Виселица!")
        elif event_type == "repeat_guess":
            print(f"Вы уже угадывали букву '{data}'!")
        elif event_type == "correct_guess":
            print(f"Верно! Буква '{data}' есть в слове.")
        elif event_type == "wrong_guess":
            print(f"Увы, буквы '{data}' нет в слове.")
        elif event_type == "game_won":
            print(f"Поздравляем! Вы угадали слово: {data}")
        elif event_type == "game_lost":
            print(f"Игра окончена! Загаданное слово было: {data}")
        
    def display_game_state(self, state):
        self.show_hangman(state["attempts_left"], state["max_attempts"])
        print(f"Текущее слово: {state['word_state']}")
        print(f"Угаданные буквы: {', '.join(state['guessed_letters'])}")
        print(f"Осталось попыток: {state['attempts_left']}")
        
    def show_hangman(self, attempts_left, max_attempts):
        stage = max_attempts - attempts_left
        print(self.hangman_stages[stage])
        
    def get_input(self):
        return input("Введите букву: ").lower().strip()

# Controller - контроллер
class HangmanController:
    def __init__(self, model, view):
        self.model = model
        self.view = view
        self.model.register_observer(self.view)
        
    def start_game(self):
        self.model.notify_observers("game_start")
        game_over = False
        
        while not game_over:
            # Отображение текущего состояния
            state = self.model.get_game_state()
            self.view.display_game_state(state)
            
            # Получение ввода
            guess = self._get_valid_input()
            
            # Обработка хода
            result = self.model.make_guess(guess)
            if "game_over" in result:
                game_over = result["game_over"]
                
    def _get_valid_input(self):
        while True:
            guess = self.view.get_input()
            
            if not guess:
                print("Вы ничего не ввели. Попробуйте снова.")
                continue
                
            if len(guess) > 1:
                print("Пожалуйста, введите только одну букву.")
                continue
                
            if not guess.isalpha():
                print("Пожалуйста, введите букву, а не другой символ.")
                continue
                
            return guess

if __name__ == "__main__":
    model = HangmanModel()
    view = ConsoleView()
    controller = HangmanController(model, view)
    controller.start_game()

# Интерфейс стратегии сложности
class DifficultyStrategy:
    def get_max_attempts(self):
        pass
        
    def get_word_list(self):
        pass
        
# Конкретные стратегии
class EasyStrategy(DifficultyStrategy):
    def get_max_attempts(self):
        return 8
        
    def get_word_list(self):
        return ["кот", "дом", "мир", "лес", "стол"]
        
class MediumStrategy(DifficultyStrategy):
    def get_max_attempts(self):
        return 6
        
    def get_word_list(self):
        return ["программа", "алгоритм", "функция", "массив"]
        
class HardStrategy(DifficultyStrategy):
    def get_max_attempts(self):
        return 4
        
    def get_word_list(self):
        return ["асинхронность", "полиморфизм", "интерполяция", "сериализация"]

class HangmanModel:
    def __init__(self, difficulty_strategy=None):
        self.difficulty = difficulty_strategy or MediumStrategy()
        self.word = Word(self.difficulty.get_word_list())
        self.player = Player(self.difficulty.get_max_attempts())
        self.observers = []
        
    def change_difficulty(self, new_strategy):
        """Динамическое изменение сложности."""
        self.difficulty = new_strategy
        # Перезапуск игры с новыми параметрами

# Базовый класс команды
class Command:
    def execute(self):
        pass
        
    def undo(self):
        pass
        
# Команда для угадывания буквы
class GuessCommand(Command):
    def __init__(self, model, letter):
        self.model = model
        self.letter = letter
        self.previous_state = None
        
    def execute(self):
        # Сохраняем текущее состояние для возможности отмены
        self.previous_state = {
            "guessed_letters": self.model.player.guessed_letters.copy(),
            "attempts_left": self.model.player.attempts_left,
            "word_guessed_letters": self.model.word.guessed_letters.copy()
        }
        # Выполняем ход
        return self.model.make_guess(self.letter)
        
    def undo(self):
        # Восстанавливаем предыдущее состояние
        self.model.player.guessed_letters = self.previous_state["guessed_letters"]
        self.model.player.attempts_left = self.previous_state["attempts_left"]
        self.model.word.guessed_letters = self.previous_state["word_guessed_letters"]
        self.model.notify_observers("move_undone")

class HangmanController:
    def __init__(self, model, view):
        # ... предыдущий код ...
        self.command_history = []
        
    def start_game(self):
        # ... предыдущий код ...
        
    def make_move(self, letter):
        command = GuessCommand(self.model, letter)
        result = command.execute()
        self.command_history.append(command)
        return result
        
    def undo_last_move(self):
        if self.command_history:
            command = self.command_history.pop()
            command.undo()
            return True
        return False

class GameFactory:
    @staticmethod
    def create_game(game_type, **kwargs):
        if game_type == "standard":
            return HangmanController(
                HangmanModel(MediumStrategy()),
                ConsoleView()
            )
        elif game_type == "educational":
            model = HangmanModel(EasyStrategy())
            view = EducationalView()  # Специальный вид с подсказками
            return HangmanController(model, view)
        elif game_type == "multiplayer":
            return MultiplayerHangmanController(
                MultiplayerHangmanModel(),
                MultiplayerView()
            )
        else:
            raise ValueError(f"Неизвестный тип игры: {game_type}")

if __name__ == "__main__":
    # Создаем игру выбранного типа
    game = GameFactory.create_game("standard")
    # Или с дополнительными параметрами
    educational_game = GameFactory.create_game(
        "educational",
        difficulty="easy",
        hints_enabled=True
    )
    game.start_game()

class WordCategorizer:
    def __init__(self):
        self.categories = {
            "программирование": ["питон", "алгоритм", "функция", "класс", "объект"],
            "животные": ["собака", "кошка", "жираф", "крокодил", "бегемот"],
            "страны": ["россия", "франция", "германия", "япония", "бразилия"]
        }
        
    def get_categories(self):
        """Возвращает список доступных категорий."""
        return list(self.categories.keys())
        
    def get_word_from_category(self, category):
        """Возвращает случайное слово из выбранной категории."""
        if category in self.categories:
            return random.choice(self.categories[category])
        raise ValueError(f"Категория '{category}' не найдена")
        
    def add_word_to_category(self, category, word):
        """Добавляет новое слово в категорию."""
        if category not in self.categories:
            self.categories[category] = []
        if word not in self.categories[category]:
            self.categories[category].append(word)

import requests
 
class WordFetcher:
    def __init__(self, api_key=None):
        self.api_key = api_key
        self.base_url = "https://api.wordnik.com/v4/words.json/randomWord"
        
    def fetch_random_word(self, min_length=4, max_length=10):
        """Получает случайное слово из API."""
        params = {
            "minLength": min_length,
            "maxLength": max_length,
            "api_key": self.api_key
        }
        
        try:
            response = requests.get(self.base_url, params=params)
            response.raise_for_status()
            data = response.json()
            return data.get("word", "").lower()
        except requests.RequestException as e:
            print(f"Ошибка при получении слова: {e}")
            return None
            
    def fetch_words_by_topic(self, topic, count=10):
        """Получает слова по определенной теме."""
        # Реализация запроса к API для получения слов по теме
        pass

class CachedWordFetcher:
    def __init__(self, base_fetcher, cache_size=1000):
        self.fetcher = base_fetcher
        self.cache = {}
        self.cache_size = cache_size
        
    def fetch_random_word(self, min_length=4, max_length=10):
        """Получает случайное слово с использованием кэша."""
        cache_key = f"random_{min_length}_{max_length}"
        
        if cache_key not in self.cache or not self.cache[cache_key]:
            # Кэш пуст, загружаем новую порцию слов
            words = []
            for _ in range(50):  # Загружаем пакетом для эффективности
                word = self.fetcher.fetch_random_word(min_length, max_length)
                if word:
                    words.append(word)
            
            self.cache[cache_key] = words
            
            # Очистка кэша, если он слишком большой
            if len(self.cache) > self.cache_size:
                # Удаляем самый старый ключ
                oldest_key = next(iter(self.cache))
                del self.cache[oldest_key]
                
        # Берем слово из кэша
        if self.cache[cache_key]:
            return self.cache[cache_key].pop()
        return None

import json
import os
from datetime import datetime
 
class StatisticsManager:
    def __init__(self, username, filename="hangman_stats.json"):
        self.username = username
        self.filename = filename
        self.stats = self._load_stats()
        
    def _load_stats(self):
        """Загружает статистику из файла."""
        if os.path.exists(self.filename):
            try:
                with open(self.filename, 'r', encoding='utf-8') as f:
                    all_stats = json.load(f)
                    return all_stats.get(self.username, self._create_default_stats())
            except (json.JSONDecodeError, IOError):
                return self._create_default_stats()
        return self._create_default_stats()
        
    def _create_default_stats(self):
        """Создает структуру статистики по умолчанию."""
        return {
            "games_played": 0,
            "games_won": 0,
            "games_lost": 0,
            "longest_streak": 0,
            "current_streak": 0,
            "average_attempts": 0,
            "total_attempts": 0,
            "favorite_category": None,
            "most_missed_letters": {},
            "history": []
        }
        
    def record_game(self, won, word, category, attempts_used, missed_letters):
        """Записывает результаты игры в статистику."""
        self.stats["games_played"] += 1
        
        if won:
            self.stats["games_won"] += 1
            self.stats["current_streak"] += 1
        else:
            self.stats["games_lost"] += 1
            self.stats["current_streak"] = 0
            
        self.stats["longest_streak"] = max(self.stats["longest_streak"], self.stats["current_streak"])
        
        self.stats["total_attempts"] += attempts_used
        self.stats["average_attempts"] = self.stats["total_attempts"] / self.stats["games_played"]
        
        # Обновляем статистику по пропущенным буквам
        for letter in missed_letters:
            self.stats["most_missed_letters"][letter] = self.stats["most_missed_letters"].get(letter, 0) + 1
            
        # Добавляем запись в историю
        game_record = {
            "date": datetime.now().isoformat(),
            "word": word,
            "category": category,
            "won": won,
            "attempts_used": attempts_used
        }
        self.stats["history"].append(game_record)
        
        # Определяем любимую категорию
        category_counts = {}
        for record in self.stats["history"]:
            cat = record["category"]
            category_counts[cat] = category_counts.get(cat, 0) + 1
        
        if category_counts:
            self.stats["favorite_category"] = max(category_counts, key=category_counts.get)
            
        self._save_stats()
        
    def _save_stats(self):
        """Сохраняет статистику в файл."""
        all_stats = {}
        if os.path.exists(self.filename):
            try:
                with open(self.filename, 'r', encoding='utf-8') as f:
                    all_stats = json.load(f)
            except (json.JSONDecodeError, IOError):
                pass
                
        all_stats[self.username] = self.stats
        
        with open(self.filename, 'w', encoding='utf-8') as f:
            json.dump(all_stats, f, ensure_ascii=False, indent=2)
            
    def get_summary(self):
        """Возвращает краткую сводку статистики."""
        return {
            "games_played": self.stats["games_played"],
            "win_rate": round(self.stats["games_won"] / max(1, self.stats["games_played"]) * 100, 1),
            "current_streak": self.stats["current_streak"],
            "longest_streak": self.stats["longest_streak"],
            "average_attempts": round(self.stats["average_attempts"], 1),
            "favorite_category": self.stats["favorite_category"]
        }

class AdaptiveDifficultyManager:
    def __init__(self, stats_manager):
        self.stats = stats_manager
        
    def get_appropriate_word(self, words_by_difficulty):
        """Выбирает слово подходящей сложности на основе статистики игрока."""
        summary = self.stats.get_summary()
        win_rate = summary["win_rate"]
        
        if win_rate > 80:
            # Игрок слишком хорош, даем сложное слово
            return random.choice(words_by_difficulty["hard"])
        elif win_rate < 40:
            # Игрок испытывает трудности, даем легкое слово
            return random.choice(words_by_difficulty["easy"])
        else:
            # Средний уровень
            return random.choice(words_by_difficulty["medium"])
            
    def adjust_max_attempts(self):
        """Регулирует количество допустимых ошибок на основе статистики."""
        summary = self.stats.get_summary()
        current_streak = summary["current_streak"]
        
        # Базовое количество попыток - 6
        if current_streak > 5:
            # Серия побед, уменьшаем количество попыток
            return 4
        elif current_streak == 0 and summary["games_played"] > 3:
            # Игрок только что проиграл, даем больше попыток
            return 8
        else:
            return 6

from flask import Flask, request, jsonify
 
app = Flask(__name__)
game_instances = {}  # Хранилище активных игр
 
@app.route('/api/game/new', methods=['POST'])
def create_game():
    data = request.json
    user_id = data.get('user_id')
    difficulty = data.get('difficulty', 'medium')
    category = data.get('category')
    
    # Создаем новую игру
    game = HangmanModel(difficulty_strategies[difficulty])
    if category:
        game.word = Word(word_categorizer.get_word_from_category(category))
    
    game_id = str(uuid.uuid4())
    game_instances[game_id] = {
        'game': game,
        'user_id': user_id,
        'created_at': datetime.now().isoformat()
    }
    
    # Возвращаем начальное состояние
    state = game.get_game_state()
    return jsonify({
        'game_id': game_id,
        'word_state': state['word_state'],
        'attempts_left': state['attempts_left'],
        'max_attempts': state['max_attempts']
    })
 
@app.route('/api/game/<game_id>/guess', methods=['POST'])
def make_guess(game_id):
    if game_id not in game_instances:
        return jsonify({'error': 'Game not found'}), 404
        
    data = request.json
    letter = data.get('letter', '').lower()
    
    game = game_instances[game_id]['game']
    result = game.make_guess(letter)
    
    state = game.get_game_state()
    response = {
        'word_state': state['word_state'],
        'attempts_left': state['attempts_left'],
        'guessed_letters': state['guessed_letters'],
        'status': result.get('status')
    }
    
    if 'game_over' in result and result['game_over']:
        response['game_over'] = True
        response['win'] = result.get('win')
        response['word'] = game.word.word
        
    return jsonify(response)
 
if __name__ == '__main__':
    app.run(debug=True)

@app.route('/api/game/multiplayer/new', methods=['POST'])
def create_multiplayer_game():
    data = request.json
    host_id = data.get('host_id')
    max_players = data.get('max_players', 4)
    
    game_id = str(uuid.uuid4())
    game_instances[game_id] = {
        'game': HangmanModel(),
        'host_id': host_id,
        'players': [host_id],
        'max_players': max_players,
        'turn_index': 0,
        'status': 'waiting',  # 'waiting', 'active', 'finished'
        'created_at': datetime.now().isoformat()
    }
    
    return jsonify({
        'game_id': game_id,
        'status': 'waiting',
        'players': [host_id]
    })
 
@app.route('/api/game/multiplayer/<game_id>/join', methods=['POST'])
def join_multiplayer_game(game_id):
    if game_id not in game_instances:
        return jsonify({'error': 'Game not found'}), 404
        
    game_data = game_instances[game_id]
    if game_data['status'] != 'waiting':
        return jsonify({'error': 'Game already started'}), 400
        
    if len(game_data['players']) >= game_data['max_players']:
        return jsonify({'error': 'Game is full'}), 400
        
    data = request.json
    player_id = data.get('player_id')
    
    if player_id in game_data['players']:
        return jsonify({'error': 'Player already joined'}), 400
        
    game_data['players'].append(player_id)
    
    return jsonify({
        'game_id': game_id,
        'status': 'waiting',
        'players': game_data['players']
    })

# Dockerfile
FROM python:3.9-slim
 
WORKDIR /app
 
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
 
COPY . .
 
ENV FLASK_APP=app.py
ENV FLASK_ENV=production
 
EXPOSE 5000
 
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]

class SafeWordFetcher:
    def __init__(self, base_fetcher, timeout=5):
        self.fetcher = base_fetcher
        self.timeout = timeout
        
    def fetch_random_word(self, min_length=4, max_length=10):
        try:
            with ThreadPoolExecutor() as executor:
                future = executor.submit(self.fetcher.fetch_random_word, min_length, max_length)
                return future.result(timeout=self.timeout)
        except TimeoutError:
            print("API request timed out, using fallback word")
            return random.choice(["python", "программа", "игра", "виселица"])
        except Exception as e:
            print(f"Error fetching word: {e}")
            return None

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
 
class WordDifficultyPredictor:
    def __init__(self):
        self.vectorizer = CountVectorizer(analyzer='char', ngram_range=(1, 3))
        self.model = MultinomialNB()
        self.trained = False
        
    def train(self, words_with_difficulty):
        """
        Обучает модель на парах (слово, сложность).
        words_with_difficulty: список кортежей (слово, сложность),
        где сложность - это 'easy', 'medium' или 'hard'
        """
        words = [word for word, _ in words_with_difficulty]
        difficulties = [diff for _, diff in words_with_difficulty]
        
        X = self.vectorizer.fit_transform(words)
        self.model.fit(X, difficulties)
        self.trained = True
        
    def predict_difficulty(self, word):
        """Предсказывает сложность слова."""
        if not self.trained:
            return "medium"  # По умолчанию
            
        X = self.vectorizer.transform([word])
        return self.model.predict(X)[0]
        
    def batch_categorize(self, words):
        """Категоризирует список слов по сложности."""
        result = {'easy': [], 'medium': [], 'hard': []}
        
        for word in words:
            difficulty = self.predict_difficulty(word)
            result[difficulty].append(word)
            
        return result

import redis
 
redis_client = redis.Redis(host='localhost', port=6379, db=0)
 
def save_game_state(game_id, state):
    """Сохраняет состояние игры в Redis."""
    redis_client.setex(f"game:{game_id}", 3600, json.dumps(state))  # TTL 1 час
    
def get_game_state(game_id):
    """Получает состояние игры из Redis."""
    data = redis_client.get(f"game:{game_id}")
    if data:
        return json.loads(data)
    return None

class GameMetrics:
    def __init__(self):
        self.game_starts = 0
        self.correct_guesses = 0
        self.wrong_guesses = 0
        self.wins = 0
        self.losses = 0
        self.average_word_length = 0
        self.word_count = 0
        
    def record_game_start(self, word):
        self.game_starts += 1
        self.word_count += 1
        self.average_word_length = ((self.average_word_length * (self.word_count - 1)) + len(word)) / self.word_count
        
    def record_guess(self, letter, is_correct):
        if is_correct:
            self.correct_guesses += 1
        else:
            self.wrong_guesses += 1
            
    def record_game_end(self, won):
        if won:
            self.wins += 1
        else:
            self.losses += 1
            
    def get_stats(self):
        return {
            "game_starts": self.game_starts,
            "correct_guesses": self.correct_guesses,
            "wrong_guesses": self.wrong_guesses,
            "wins": self.wins,
            "losses": self.losses,
            "win_rate": self.wins / max(1, self.wins + self.losses),
            "average_word_length": self.average_word_length
        }

def get_input():
    user_input = input("Введите букву: ").strip().lower()
    if not user_input:  # Проверка на пустой ввод
        return get_input()  # Рекурсивный вызов для повторного запроса
    return user_input[0]  # Берём только первый символ

def display_hangman(wrong_attempts):
    stages = [
        "  +---+\n  |   |\n      |\n      |\n      |\n      |\n=========",
        "  +---+\n  |   |\n  O   |\n      |\n      |\n      |\n=========",
        # и так далее...
    ]
    return stages[min(wrong_attempts, len(stages) - 1)]

game_state = {
    "word": "программирование",
    "guessed_letters": [],
    "attempts_left": 6,
    "max_attempts": 6,
    "game_over": False
}

def is_word_guessed(word, guessed_letters):
    """
    Проверяет, угадано ли слово полностью.
    
    Args:
        word (str): Загаданное слово
        guessed_letters (list): Список угаданных букв
        
    Returns:
        bool: True, если все буквы слова угаданы, иначе False
    """
    return all(letter in guessed_letters for letter in word)