Здравствуй дружище! А ты знаешь про настольную игр...

Ниже приведён пример полного и многофункционального кода на Python с использованием библиотеки pyTelegramBotAPI, который старается максимально покрыть все перечисленные пункты. Код довольно объёмный, поэтому читайте внимательно комментарии и при необходимости адаптируйте под свои нужды.

ВАЖНО:

1. Вставьте свой токен бота, где указано YOUR_BOT_TOKEN.
2. Пакет pyTelegramBotAPI должен быть установлен. Установите его командой:

   bash
   pip install pyTelegramBotAPI

3. Код написан в одном файле (как вы просили), однако для реального проекта будет удобнее разбить логику по модулям.
4. В примере используется примитивная реализация, где все данные хранятся в JSON-файлах. В production-среде чаще используют БД (например, SQLite, PostgreSQL, Redis и т.д.).
5. Учитывая масштаб требований, код может потребовать дальнейших доработок и оптимизаций, но как стартовый шаблон он продемонстрирует большую часть логики.
6. Чтобы не «спамить» сообщениями, в коде применяются механизмы «message editing» там, где указано в требованиях.
7. Пример логики ночных фаз, голосований, чата, распределения ролей и т.д. — упрощён, но демонстрирует подход.
8. В коде достаточно много комментариев, чтобы вы могли разобраться в механизмах.
9. Везде, где уместно, добавлены смайлики для красоты.

python
# -*- coding: utf-8 -*-
import telebot
import json
import os
import random
import time

from telebot import types

# ВСТАВЬТЕ СЮДА СВОЙ ТОКЕН
BOT_TOKEN = "YOUR_BOT_TOKEN"

bot = telebot.TeleBot(BOT_TOKEN, parse_mode="HTML")

# -------------- ПУТИ К JSON-ФАЙЛАМ --------------
USERS_DATA_FILE = "users_data.json"
ROOMS_DATA_FILE = "rooms_data.json"

# -------------- ГЛОБАЛЬНЫЕ СТРУКТУРЫ В ПАМЯТИ --------------
# user_data: {
#   user_id(str/int): {
#       "nickname": str,
#       "stats": {
#           "wins_as_mafia": int,
#           "kills_as_mafia": int,
#           "wins_as_doctor": int,
#           "heals_as_doctor": int,
#           "wins_as_sheriff": int,
#           "reveals_as_sheriff": int,
#           "wins_as_civil": int,
#           "games_played": int,
#           ... можно добавить любые поля ...
#       },
#       "observing": False,  # наблюдатель
#       "in_room": None  # текущая комната, куда зашёл (или None если нет)
#   }
# }
user_data = {}

# rooms_data: {
#   room_pin(str): {
#       "creator_id": user_id,
#       "members": [user_id1, user_id2, ...],
#       "member_usernames": [nickname1, nickname2, ...], # Для информационной доски
#       "state": "waiting" / "playing" / "finished",
#       "mafia_count": 1,
#       "doctor_count": 1,
#       "sheriff_count": 1,
#       "civils_count": 0,
#       "info_message_id": None,  # id сообщения "инфо-доски"
#       "chat_message_id": None,  # id сообщения "общего чата"
#       "vote_message_id": None,  # id сообщения доски голосования
#       "lead_id": None,          # человек-ведущий (если кто-то добровольно стал)
#       "phase": "day"/"night"/"discussion"/...,
#       "roles": {user_id: "mafia"/"doctor"/"sheriff"/"civil"},
#       "alive": [user_id1, user_id2, ...],
#       ...
#   }
# }
rooms_data = {}

# -------------- ЗАГРУЗКА/СОХРАНЕНИЕ ДАННЫХ --------------

def load_data():
    global user_data, rooms_data
    if os.path.exists(USERS_DATA_FILE):
        with open(USERS_DATA_FILE, "r", encoding="utf-8") as f:
            user_data = json.load(f)
    else:
        user_data = {}

    if os.path.exists(ROOMS_DATA_FILE):
        with open(ROOMS_DATA_FILE, "r", encoding="utf-8") as f:
            rooms_data = json.load(f)
    else:
        rooms_data = {}

def save_data():
    with open(USERS_DATA_FILE, "w", encoding="utf-8") as f:
        json.dump(user_data, f, indent=4, ensure_ascii=False)
    with open(ROOMS_DATA_FILE, "w", encoding="utf-8") as f:
        json.dump(rooms_data, f, indent=4, ensure_ascii=False)

# -------------- ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ --------------

def is_nickname_taken(nickname):
    """Проверяет, занят ли указанный ник у кого-то из пользователей."""
    for uid, data in user_data.items():
        if data["nickname"].lower() == nickname.lower():
            return True
    return False

def generate_pin_code():
    """Генерация уникального 6-значного пин-кода."""
    while True:
        code = str(random.randint(100000, 999999))
        if code not in rooms_data:
            return code

def create_default_stats():
    """Создаёт заготовку статистики для нового пользователя."""
    return {
        "wins_as_mafia": 0,
        "kills_as_mafia": 0,
        "wins_as_doctor": 0,
        "heals_as_doctor": 0,
        "wins_as_sheriff": 0,
        "reveals_as_sheriff": 0,
        "wins_as_civil": 0,
        "games_played": 0
    }

def check_user_registered(message):
    """Проверяет, есть ли у пользователя никнейм в user_data. 
       Если нет – запрещаем пользоваться функционалом и просим ввести ник."""
    user_id = str(message.from_user.id)
    if user_id not in user_data or not user_data[user_id]["nickname"]:
        # Если нет ника, сообщим и прервём выполнение
        bot.send_message(message.chat.id, 
            "У вас ещё нет никнейма. Пожалуйста, введите его, чтобы продолжить \u2753")
        return False
    return True

def go_to_main_menu(chat_id, text="Главное меню \uD83C\uDF10"):
    """Показывает главное меню (ReplyKeyboardMarkup)."""
    markup = types.ReplyKeyboardMarkup(row_width=2, resize_keyboard=True)
    btn_create = types.KeyboardButton("Создать комнату \uD83D\uDDC2")
    btn_join = types.KeyboardButton("Присоединиться по пин коду \uD83D\uDD10")
    btn_change_nick = types.KeyboardButton("Сменить никнейм \uD83D\uDCDD")
    btn_stats = types.KeyboardButton("Моя статистика \uD83D\uDCCA")
    btn_leaderboard = types.KeyboardButton("Таблица лидеров \uD83C\uDFC6")
    btn_rules = types.KeyboardButton("Правила игры \u2754")
    markup.add(btn_create, btn_join)
    markup.add(btn_change_nick, btn_stats)
    markup.add(btn_leaderboard, btn_rules)
    bot.send_message(chat_id, text, reply_markup=markup)

def update_room_info_message(room_pin):
    """Редактирует информационное сообщение о том, кто в комнате, сколько человек и т.д."""
    room = rooms_data[room_pin]
    if room["info_message_id"] is None:
        return  # нет сообщения для обновления
    
    chat_id = room["info_message_id"]["chat_id"]
    message_id = room["info_message_id"]["message_id"]

    # Формируем текст
    members_text = ""
    for idx, uid in enumerate(room["members"], start=1):
        nickname = user_data[str(uid)]["nickname"]
        members_text += f"{idx}. {nickname}\n"
    text = f"Комната <b>{room_pin}</b>\n" \
           f"Игроков в комнате: <b>{len(room['members'])}</b>\n\n" \
           f"<b>Список игроков:</b>\n{members_text}"

    # Прикрепим информацию о текущих ролях (в режиме ожидания)
    if room["state"] == "waiting":
        text += f"\n<b>Роли в игре</b> \u2694\n" \
                f"Мафии: {room['mafia_count']}\n" \
                f"Докторов: {room['doctor_count']}\n" \
                f"Шерифов: {room['sheriff_count']}\n" \
                f"Мирных: {room['civils_count'] if 'civils_count' in room else 0}\n"

    try:
        bot.edit_message_text(text, chat_id, message_id)
    except:
        pass  # могут быть ситуации, когда сообщение уже удалено и т.д.

def update_room_chat_message(room_pin, new_line, sender_id=None, receiver_id=None):
    """Редактируем общее чат-сообщение. Добавляем новую строку. 
       Если sender_id = None, значит это системное сообщение от бота."""
    room = rooms_data[room_pin]
    if room["chat_message_id"] is None:
        return
    
    chat_id = room["chat_message_id"]["chat_id"]
    message_id = room["chat_message_id"]["message_id"]

    text = ""
    try:
        original_msg = bot.edit_message_text("", chat_id, message_id).text
        # Если получилось достать текст, можно сохранить. Но pyTelegramBotAPI 
        # не всегда даёт достать исходный text при редактировании. 
        # Пойдём другим путём: будем хранить локально room["chat_text"] к примеру.
    except:
        pass

    # Создадим хранилище текста чата в room, если его нет
    if "chat_text" not in room:
        room["chat_text"] = ""

    # Определим отправителя (ник)
    if sender_id is not None:
        sender_nick = user_data[str(sender_id)]["nickname"]
        if receiver_id is not None:
            receiver_nick = user_data[str(receiver_id)]["nickname"]
            # (имя отправителя) обращается к (имя получателя): ...
            line_to_add = f"<b>{sender_nick}</b> \u27A1 <i>{receiver_nick}</i>: {new_line}"
        else:
            line_to_add = f"<b>{sender_nick}:</b> {new_line}"
    else:
        # сообщение от бота
        line_to_add = f"<i>{new_line}</i>"

    # Обновляем текст
    room["chat_text"] += line_to_add + "\n"

    try:
        bot.edit_message_text(room["chat_text"], chat_id, message_id)
    except:
        pass

def update_vote_message(room_pin):
    """Обновляет доску голосования (кто за кого проголосовал)."""
    room = rooms_data[room_pin]
    if room["vote_message_id"] is None:
        return
    chat_id = room["vote_message_id"]["chat_id"]
    message_id = room["vote_message_id"]["message_id"]
    
    # Предположим, что в room есть словарь vote_results: {uid_voter: uid_target, ...}
    # А также есть alive: список живых. 
    # Сформируем таблицу голосов
    vote_text = "Доска голосования \uD83D\uDDF3\n\n"
    if "vote_results" not in room:
        room["vote_results"] = {}
    
    # Считаем, сколько голосов у каждого
    votes_count = {}
    for voter, target in room["vote_results"].items():
        if target not in votes_count:
            votes_count[target] = 0
        votes_count[target] += 1

    # Генерируем список
    for uid in room["alive"]:
        # Количество голосов за этого
        count = votes_count.get(uid, 0)
        nickname = user_data[str(uid)]["nickname"]
        vote_text += f"{nickname} - {count} голос(ов)\n"
    vote_text += "\n\n"

    # Дополнительно можно отобразить, кто за кого проголосовал
    vote_text += "<b>Кто за кого голосует:</b>\n"
    for voter, target in room["vote_results"].items():
        v_nick = user_data[str(voter)]["nickname"]
        t_nick = user_data[str(target)]["nickname"]
        vote_text += f"{v_nick} \u27A1 {t_nick}\n"

    try:
        bot.edit_message_text(vote_text, chat_id, message_id)
    except:
        pass

def assign_roles(room_pin):
    """Случайно распределяем роли среди участников."""
    room = rooms_data[room_pin]
    member_ids = room["members"].copy()
    random.shuffle(member_ids)

    total_players = len(member_ids)
    # Подсчитаем, сколько осталось на мирных
    total_roles = room["mafia_count"] + room["doctor_count"] + room["sheriff_count"]
    civils = total_players - total_roles
    if civils < 0:
        civils = 0
    room["civils_count"] = civils

    # Заполним массив ролей
    roles_list = ["mafia"] * room["mafia_count"] \
               + ["doctor"] * room["doctor_count"] \
               + ["sheriff"] * room["sheriff_count"] \
               + ["civil"] * civils
    random.shuffle(roles_list)

    room["roles"] = {}
    room["alive"] = []
    for i, uid in enumerate(member_ids):
        role = roles_list[i]
        room["roles"][uid] = role
        room["alive"].append(uid)

# -------------- ФУНКЦИИ ЛОГИКИ ИГРЫ (УПРОЩЁННО) --------------
def start_game(room_pin):
    """Запускаем игру в комнате."""
    room = rooms_data[room_pin]
    room["state"] = "playing"

    # Распределяем роли
    assign_roles(room_pin)
    # Уведомляем всех о начале
    for uid in room["members"]:
        # Отправим ЛС с ролью
        role = room["roles"][uid]
        role_emoji = "😈" if role == "mafia" else ("⚕️" if role == "doctor" else ("🔎" if role == "sheriff" else "🙂"))
        text = f"Игра началась! Ваша роль: <b>{role.upper()}</b> {role_emoji}"
        bot.send_message(uid, text)

    # Системное сообщение в чат
    update_room_chat_message(room_pin, 
        "Игра началась! \u26A1 Роли розданы. Желаем удачи!", sender_id=None)

    # Начинаем цикл: ночь, день и т.д. (очень упрощённо для примера)
    night_phase(room_pin)

def night_phase(room_pin):
    room = rooms_data[room_pin]
    room["phase"] = "night"
    update_room_chat_message(room_pin, 
        "\n\uD83C\uDF19 <b>Ночь наступает...</b> Все игроки засыпают...\n", sender_id=None)
    time.sleep(0.5)

    # 1. Мафия просыпается
    for uid in room["members"]:
        if uid in room["alive"] and room["roles"][uid] == "mafia":
            bot.send_message(uid, 
                "Наступила ночь. Вы (Мафия) проснулись. Выберите, кого убить.",
            )
            # Здесь можно прислать inline-кнопки для выбора жертвы из alive

    # Отправим всем остальным оповещение, что мафия не завершила действия
    for uid in room["members"]:
        if uid in room["alive"] and room["roles"][uid] != "mafia":
            bot.send_message(uid, 
                "Мафия делает свой выбор... \uD83D\uDD2B",
            )
    # Допустим мы ждём 10 секунд для примера (реально надо делать callback-кнопки)
    time.sleep(2)
    update_room_chat_message(room_pin, "Мафия засыпает... 💤", sender_id=None)
    time.sleep(0.5)

    # 2. Доктор просыпается
    for uid in room["members"]:
        if uid in room["alive"] and room["roles"][uid] == "doctor":
            bot.send_message(uid, 
                "Вы проснулись (Доктор). Выберите, кого лечить. 🩺",
            )
    for uid in room["members"]:
        if uid in room["alive"] and room["roles"][uid] != "doctor":
            bot.send_message(uid, 
                "Доктор делает свой выбор... 🏥",
            )
    time.sleep(2)
    update_room_chat_message(room_pin, "Доктор засыпает...", sender_id=None)
    time.sleep(0.5)

    # 3. Шериф просыпается
    for uid in room["members"]:
        if uid in room["alive"] and room["roles"][uid] == "sheriff":
            bot.send_message(uid,
                "Вы проснулись (Шериф). Выберите, кого проверить! 🔎",
            )
    for uid in room["members"]:
        if uid in room["alive"] and room["roles"][uid] != "sheriff":
            bot.send_message(uid, 
                "Шериф делает свой выбор... \uD83D\uDD0E",
            )
    time.sleep(2)
    update_room_chat_message(room_pin, "Шериф засыпает...", sender_id=None)
    time.sleep(0.5)

    # Подсчитаем результаты (упрощённо)
    # Здесь логика убийства, лечения, проверки и т.д.

    # Утро
    day_phase(room_pin)

def day_phase(room_pin):
    room = rooms_data[room_pin]
    room["phase"] = "day"
    update_room_chat_message(room_pin, "\n\u2600\uFE0F <b>Наступило утро!</b>", sender_id=None)
    # Объявим, что произошло ночью (убили кого-то, спасли кого-то и т.д.)

    # Начинается обсуждение. Запрос голосов.
    time.sleep(1)
    discussion_phase(room_pin)

def discussion_phase(room_pin):
    room = rooms_data[room_pin]
    room["phase"] = "discussion"
    update_room_chat_message(room_pin, 
        "\nПришло время обсудить и проголосовать, кто подозрительный \u2753", 
        sender_id=None)
    # Тут можно включить логику чата, кнопки "Отдать голос" и пр.

    # Упростим: через 5 секунд завершим обсуждение:
    time.sleep(5)
    voting_phase(room_pin)

def voting_phase(room_pin):
    room = rooms_data[room_pin]
    room["phase"] = "voting"
    update_room_chat_message(room_pin, "Начинается голосование! \uD83D\uDDF3", sender_id=None)
    # Здесь присылаем inline-кнопки и т.д. — см. update_vote_message()

    # Упростим: Через несколько секунд завершим
    time.sleep(5)
    # Определим, кто набрал больше всего голосов. Упростим — убираем рандомно одного
    if room["alive"]:
        random_victim = random.choice(room["alive"])
        room["alive"].remove(random_victim)
        v_nick = user_data[str(random_victim)]["nickname"]
        # Раскрываем роль убитого
        dead_role = room["roles"][random_victim]
        update_room_chat_message(room_pin, 
            f"Игрок <b>{v_nick}</b> ({dead_role.upper()}) выбыл из игры!", 
            sender_id=None)

    # Проверим условия победы (упрощённо)
    check_win_conditions(room_pin)

def check_win_conditions(room_pin):
    room = rooms_data[room_pin]
    # Примитивная проверка: если мафии нет или если нет мирных
    mafia_alive = any(room["roles"][uid] == "mafia" for uid in room["alive"])
    civils_alive = any(room["roles"][uid] != "mafia" for uid in room["alive"])
    if not mafia_alive:
        # Мирные победили
        end_game(room_pin, "civils")
    elif not civils_alive:
        # Мафия победила
        end_game(room_pin, "mafia")
    else:
        # Иначе новая ночь
        night_phase(room_pin)

def end_game(room_pin, winner_side):
    room = rooms_data[room_pin]
    room["state"] = "finished"
    # Объявим победителя
    if winner_side == "mafia":
        text = "\uD83D\uDC79 <b>Мафия победила!</b>"
    else:
        text = "\uD83D\uDE4C <b>Мирные победили!</b>"

    update_room_chat_message(room_pin, text, sender_id=None)
    # Показываем роли всех игроков
    reveal_text = "\n<b>Роли всех игроков:</b>\n"
    for uid, role in room["roles"].items():
        nickname = user_data[str(uid)]["nickname"]
        reveal_text += f"{nickname} – {role.upper()}\n"
    update_room_chat_message(room_pin, reveal_text, sender_id=None)

    # Здесь можно обновить статистику
    for uid in room["members"]:
        user_data[str(uid)]["stats"]["games_played"] += 1
        r = room["roles"][uid]
        if (winner_side == "mafia" and r == "mafia"):
            user_data[str(uid)]["stats"]["wins_as_mafia"] += 1
        elif (winner_side == "civils" and r == "doctor"):
            user_data[str(uid)]["stats"]["wins_as_doctor"] += 1
        elif (winner_side == "civils" and r == "sheriff"):
            user_data[str(uid)]["stats"]["wins_as_sheriff"] += 1
        elif (winner_side == "civils" and r == "civil"):
            user_data[str(uid)]["stats"]["wins_as_civil"] += 1
    
    save_data()

    # Предложим сыграть заново
    for uid in room["members"]:
        # Инлайн кнопки "Да, хочу" / "Нет, не хочу"
        markup = types.InlineKeyboardMarkup()
        btn_yes = types.InlineKeyboardButton("Да, хочу \u2B55", callback_data=f"play_again_yes_{room_pin}")
        btn_no  = types.InlineKeyboardButton("Нет, не хочу \u274C", callback_data=f"play_again_no_{room_pin}")
        markup.add(btn_yes, btn_no)
        bot.send_message(uid, "Хотите сыграть заново?", reply_markup=markup)

# -------------- ОБРАБОТЧИКИ --------------

@bot.message_handler(commands=["start"])
def cmd_start(message):
    load_data()
    user_id = str(message.from_user.id)

    # Если юзер новый — предложим ввести ник
    if user_id not in user_data:
        user_data[user_id] = {
            "nickname": "",
            "stats": create_default_stats(),
            "observing": False,
            "in_room": None
        }
        save_data()

    if not user_data[user_id]["nickname"]:
        bot.send_message(
            message.chat.id,
            "Приветствую! \u270B Введите свой уникальный никнейм, чтобы продолжить игру:"
        )
    else:
        # Юзер уже с ником
        bot.send_message(message.chat.id, 
            f"Рады видеть вас снова, <b>{user_data[user_id]['nickname']}</b>! \uD83D\uDC4B")
        go_to_main_menu(message.chat.id)

@bot.message_handler(func=lambda m: True, content_types=["text"])
def all_text_handler(message):
    load_data()
    user_id = str(message.from_user.id)
    text = message.text.strip()

    # Если у пользователя НЕТ ника, считаем что он сейчас вводит ник
    if user_id in user_data and not user_data[user_id]["nickname"]:
        # Проверим уникальность ника
        if is_nickname_taken(text):
            bot.send_message(message.chat.id, 
                "Этот ник уже занят \u26D4. Попробуйте другой:")
        else:
            user_data[user_id]["nickname"] = text
            save_data()
            bot.send_message(message.chat.id, f"Ник '{text}' успешно сохранён! \u2705")
            go_to_main_menu(message.chat.id)
        return

    # Если пользователь уже имеет ник, проверим кнопки главного меню
    # Но сначала убеждаемся, что ник есть, иначе нельзя взаимодействовать
    if not check_user_registered(message):
        return

    if text.startswith("Создать комнату"):
        # Генерируем пин-код
        pin = generate_pin_code()
        rooms_data[pin] = {
            "creator_id": user_id,
            "members": [int(user_id)],
            "member_usernames": [user_data[user_id]["nickname"]],
            "state": "waiting",
            "mafia_count": 1,
            "doctor_count": 1,
            "sheriff_count": 1,
            "civils_count": 0,
            "info_message_id": None,
            "chat_message_id": None,
            "vote_message_id": None,
            "lead_id": None,
            "phase": None
        }
        user_data[user_id]["in_room"] = pin
        save_data()

        # Отправим сообщение о создании комнаты
        markup = types.InlineKeyboardMarkup()
        btn_del = types.InlineKeyboardButton("Удалить комнату \uD83D\uDDD1", callback_data=f"delete_room_{pin}")
        markup.add(btn_del)

        msg = bot.send_message(
            message.chat.id,
            f"Комната создана! \nPIN-код: <b>{pin}</b> \uD83D\uDD10\n"
            "Можете поделиться этим кодом с друзьями, чтобы они присоединились.",
            reply_markup=markup
        )
        # Создадим "инфо-доску"
        info_msg = bot.send_message(message.chat.id, "Информационная доска...")
        rooms_data[pin]["info_message_id"] = {
            "chat_id": info_msg.chat.id,
            "message_id": info_msg.message_id
        }
        # Создадим "общий чат"
        chat_msg = bot.send_message(message.chat.id, "Общий чат (сообщения будут тут).")
        rooms_data[pin]["chat_message_id"] = {
            "chat_id": chat_msg.chat.id,
            "message_id": chat_msg.message_id
        }
        update_room_info_message(pin)

        # Создателю даём кнопки "Начать игру", "Редактировать роли", "Выйти из комнаты", "Стать ведущим"
        show_room_creator_menu(message.chat.id, pin)

    elif text.startswith("Присоединиться по пин коду"):
        # Попросим ввести пин
        bot.send_message(message.chat.id, "Введите 6-значный PIN-код комнаты:")
        # Переводим бот в состояние, где он ждёт пин (можно использовать FSM, но упростим)
        # Для упрощения - будем считать, что следующий текст от этого пользователя – это PIN.
        # В реальном проекте лучше использовать machine state. 
        # Сделаем флаг user_data[user_id]["entering_pin"] = True
        user_data[user_id]["entering_pin"] = True
        save_data()

    elif text.startswith("Сменить никнейм"):
        bot.send_message(message.chat.id, 
            "Введите новый никнейм \uD83D\uDD0D. Помните, он должен быть уникален!")
        # Сразу сбрасываем текущий ник в "", чтобы ловить ввод ника
        user_data[user_id]["nickname"] = ""
        save_data()

    elif text.startswith("Моя статистика"):
        show_user_stats(message.chat.id, user_id)

    elif text.startswith("Таблица лидеров"):
        show_leaderboard(message.chat.id)

    elif text.startswith("Правила игры"):
        # Показываем 2 inline-кнопки: Казахский, Русский
        markup = types.InlineKeyboardMarkup()
        btn_kz = types.InlineKeyboardButton("Казахский \uD83C\uDDFA\uD83C\uDDFF", callback_data="rules_lang_kz")
        btn_ru = types.InlineKeyboardButton("Русский \uD83C\uDDF7\uD83C\uDDFA", callback_data="rules_lang_ru")
        markup.add(btn_kz, btn_ru)
        bot.send_message(
            message.chat.id, 
            "Выберите язык, чтобы прочитать правила:",
            reply_markup=markup
        )
    else:
        # Проверим, вводит ли сейчас пользователь PIN
        if "entering_pin" in user_data[user_id] and user_data[user_id]["entering_pin"] == True:
            # Обрабатываем введённый пин
            pin_input = text
            user_data[user_id]["entering_pin"] = False
            # Проверим есть ли такая комната
            if pin_input in rooms_data and rooms_data[pin_input]["state"] in ["waiting", "playing"]:
                # Присоединяемся
                rooms_data[pin_input]["members"].append(int(user_id))
                rooms_data[pin_input]["member_usernames"].append(user_data[user_id]["nickname"])
                user_data[user_id]["in_room"] = pin_input
                save_data()

                # Отправляем всем инфо
                for uid in rooms_data[pin_input]["members"]:
                    if str(uid) != user_id:  # не отправляем самому себе
                        bot.send_message(uid, 
                            f"\uD83D\uDCE3 Игрок {user_data[user_id]['nickname']} зашёл в комнату {pin_input}!")
                bot.send_message(message.chat.id, 
                    f"Вы успешно зашли в комнату {pin_input} \u2705")

                # Обновим инфо-доску
                update_room_info_message(pin_input)

                # Покажем меню (зависит, кто создатель)
                if rooms_data[pin_input]["creator_id"] == user_id:
                    show_room_creator_menu(message.chat.id, pin_input)
                else:
                    show_room_member_menu(message.chat.id, pin_input)

            else:
                bot.send_message(message.chat.id, 
                    "Комната с таким пин-кодом не найдена или недоступна \u274C")
            save_data()
        else:
            # Возможно, это чат внутри комнаты?
            in_room_pin = user_data[user_id]["in_room"]
            if in_room_pin and in_room_pin in rooms_data:
                # Отправим сообщение в общий чат комнаты
                # Но если пользователь — убитый или наблюдатель, тоже разрешим видеть чат
                # Требование: "А для того чтобы узнать кто что говорить, нужно высвечивалось имя"
                # Условие, что своё сообщение не приходит самому себе, можно реализовать,
                # но это довольно сложно в обычном режиме, т.к. бот шлёт сообщение 1:1.
                # Упрощённо: фиксируем, что это сообщение для "общего" канала.
                # *Если* человек жив или игра в ожидании.
                room = rooms_data[in_room_pin]
                if room["state"] in ["waiting", "playing"]:
                    # Обновляем чат
                    update_room_chat_message(in_room_pin, text, sender_id=int(user_id))
                else:
                    bot.send_message(message.chat.id, 
                        "Игра в этой комнате уже завершена. \u274C")
            else:
                # Иначе игнорируем
                bot.send_message(message.chat.id, 
                    "Я не совсем понял ваше сообщение... \u2753")

def show_room_creator_menu(chat_id, pin):
    """Показываем меню создателя комнаты (ReplyKeyboardMarkup)."""
    markup = types.ReplyKeyboardMarkup(row_width=2, resize_keyboard=True)
    btn_start_game = types.KeyboardButton("Начать игру \u26A1")
    btn_edit_roles = types.KeyboardButton("Редактировать роли \u2694")
    btn_leave_room = types.KeyboardButton("Выйти из комнаты \u274C")
    btn_be_leader = types.KeyboardButton("Стать ведущим \uD83D\uDCD6")
    markup.add(btn_start_game, btn_edit_roles)
    markup.add(btn_be_leader, btn_leave_room)
    bot.send_message(chat_id, 
        f"Вы являетесь создателем комнаты {pin}. Что будем делать?", 
        reply_markup=markup)

def show_room_member_menu(chat_id, pin):
    """Меню обычного участника комнаты."""
    markup = types.ReplyKeyboardMarkup(row_width=2, resize_keyboard=True)
    btn_leave_room = types.KeyboardButton("Выйти из комнаты \u274C")
    btn_be_leader = types.KeyboardButton("Стать ведущим \uD83D\uDCD6")
    markup.add(btn_be_leader, btn_leave_room)
    bot.send_message(chat_id, 
        f"Вы находитесь в комнате {pin}.", 
        reply_markup=markup)

def show_user_stats(chat_id, user_id):
    """Показываем статистику игрока."""
    stats = user_data[user_id]["stats"]
    text = f"<b>Ваша статистика, {user_data[user_id]['nickname']}</b>\n\n" \
           f"Игр сыграно: {stats['games_played']}\n" \
           f"Побед за мафию: {stats['wins_as_mafia']}\n" \
           f"Побед за доктора: {stats['wins_as_doctor']}\n" \
           f"Побед за шерифа: {stats['wins_as_sheriff']}\n" \
           f"Побед за мирного: {stats['wins_as_civil']}\n"
    # Инлайн-кнопка "Полный разбор" (Message Editing)
    markup = types.InlineKeyboardMarkup()
    btn_details = types.InlineKeyboardButton("Полный разбор \uD83D\uDDD2", 
        callback_data=f"stats_details_{user_id}")
    markup.add(btn_details)
    bot.send_message(chat_id, text, reply_markup=markup)

def show_user_stats_details(call, user_id):
    """Показываем детальную статистику (Message Editing)."""
    stats = user_data[user_id]["stats"]
    text = f"<b>Подробная статистика {user_data[user_id]['nickname']}</b>\n\n" \
           f"• Мафия:\n" \
           f"  - Побед: {stats['wins_as_mafia']}\n" \
           f"  - Убийств: {stats['kills_as_mafia']}\n\n" \
           f"• Доктор:\n" \
           f"  - Побед: {stats['wins_as_doctor']}\n" \
           f"  - Спасений: {stats['heals_as_doctor']}\n\n" \
           f"• Шериф:\n" \
           f"  - Побед: {stats['wins_as_sheriff']}\n" \
           f"  - Проверок: {stats['reveals_as_sheriff']}\n\n" \
           f"• Мирный:\n" \
           f"  - Побед: {stats['wins_as_civil']}\n\n" \
           f"Игр сыграно: {stats['games_played']}\n"
    markup = types.InlineKeyboardMarkup()
    btn_back = types.InlineKeyboardButton("Назад \u2B05", callback_data=f"stats_back_{user_id}")
    markup.add(btn_back)

    bot.edit_message_text(
        text, 
        call.message.chat.id, 
        call.message.message_id, 
        reply_markup=markup
    )

def show_leaderboard(chat_id):
    """Показываем таблицу лидеров. Три вида: Мафия, Доктор, Шериф (и можно ещё)."""
    # Собираем список (user_id, nickname, wins_as_mafia, kills_as_mafia, etc.)
    # Но только те, у кого есть победы (или баллы)
    leaderboard = []
    for uid, data in user_data.items():
        s = data["stats"]
        total_wins = s["wins_as_mafia"] + s["wins_as_doctor"] + s["wins_as_sheriff"] + s["wins_as_civil"]
        if total_wins > 0:
            leaderboard.append((uid, data["nickname"], s))

    # Отсортируем для мафии по kills_as_mafia + wins_as_mafia (пример)
    # Можно отдельно хранить и по доктору, шерифу, и т.д.
    # Упростим: выводим в одном сообщении
    # TOP по мафии
    mafia_sorted = sorted(leaderboard, key=lambda x: x[2]["wins_as_mafia"], reverse=True)
    mafia_text = "Топ по МАФИИ (победы):\n"
    for i, (uid, nick, st) in enumerate(mafia_sorted[:3], start=1):
        medal = "🥇" if i == 1 else ("🥈" if i == 2 else "🥉")
        mafia_text += f"{medal} {nick} – Побед: {st['wins_as_mafia']} / Убийств: {st['kills_as_mafia']}\n"

    # Аналогично по доктору
    doctor_sorted = sorted(leaderboard, key=lambda x: x[2]["wins_as_doctor"], reverse=True)
    doctor_text = "\nТоп по ДОКТОРУ:\n"
    for i, (uid, nick, st) in enumerate(doctor_sorted[:3], start=1):
        medal = "🥇" if i == 1 else ("🥈" if i == 2 else "🥉")
        doctor_text += f"{medal} {nick} – Побед: {st['wins_as_doctor']} / Спасений: {st['heals_as_doctor']}\n"

    # И по шерифу
    sheriff_sorted = sorted(leaderboard, key=lambda x: x[2]["wins_as_sheriff"], reverse=True)
    sheriff_text = "\nТоп по ШЕРИФУ:\n"
    for i, (uid, nick, st) in enumerate(sheriff_sorted[:3], start=1):
        medal = "🥇" if i == 1 else ("🥈" if i == 2 else "🥉")
        sheriff_text += f"{medal} {nick} – Побед: {st['wins_as_sheriff']} / Проверок: {st['reveals_as_sheriff']}\n"

    full_text = mafia_text + doctor_text + sheriff_text

    # Для полного рейтинга выведем всех
    # Можно отдельно оформить, если нужно
    bot.send_message(chat_id, full_text)

# -------------- ОБРАБОТЧИКИ CALLBACK DATA --------------

@bot.callback_query_handler(func=lambda call: True)
def callback_inline(call):
    load_data()
    if call.data.startswith("delete_room_"):
        # Удалить комнату
        pin = call.data.split("_")[2]
        if pin in rooms_data:
            # Проверим, что это делает создатель
            if rooms_data[pin]["creator_id"] == str(call.from_user.id):
                del rooms_data[pin]
                # Сбросим user_data[in_room]
                for uid, d in user_data.items():
                    if d["in_room"] == pin:
                        d["in_room"] = None
                save_data()
                bot.answer_callback_query(call.id, "Комната удалена \u274C", show_alert=True)
                # Удаляем сообщение?
                try:
                    bot.delete_message(call.message.chat.id, call.message.message_id)
                except:
                    pass
                # Возвращаемся в главное меню
                go_to_main_menu(call.message.chat.id)
            else:
                bot.answer_callback_query(call.id, "Только создатель может удалять комнату!", show_alert=True)
    elif call.data.startswith("play_again_yes_"):
        pin = call.data.split("_")[3]
        # Пользователь согласен играть заново
        # Можно отметить где-то согласие
        # Если все согласны, запускаем
        bot.answer_callback_query(call.id, "Ждём ответа остальных игроков \u2705")
        # Упрощённо – сразу перезапустим игру, когда все ответят. Здесь не реализовано.
    elif call.data.startswith("play_again_no_"):
        pin = call.data.split("_")[3]
        # Предложим выйти или наблюдать
        markup = types.InlineKeyboardMarkup()
        btn_leave = types.InlineKeyboardButton("Выйти из комнаты \u274C", callback_data=f"no_play_leave_{pin}")
        btn_watch = types.InlineKeyboardButton("Наблюдать \uD83D\uDCDC", callback_data=f"no_play_watch_{pin}")
        markup.add(btn_leave, btn_watch)
        bot.edit_message_text(
            "Вы выбрали не играть заново. Хотите выйти или стать наблюдателем?",
            call.message.chat.id,
            call.message.message_id,
            reply_markup=markup
        )
    elif call.data.startswith("no_play_leave_"):
        pin = call.data.split("_")[3]
        user_id = str(call.from_user.id)
        # Выходим из комнаты
        if pin in rooms_data:
            if int(user_id) in rooms_data[pin]["members"]:
                rooms_data[pin]["members"].remove(int(user_id))
                if user_id in rooms_data[pin]["roles"]:
                    del rooms_data[pin]["roles"][user_id]
                user_data[user_id]["in_room"] = None
                bot.answer_callback_query(call.id, "Вы вышли из комнаты \u274C", show_alert=True)
                save_data()
                # Удаляем сообщение
                try:
                    bot.delete_message(call.message.chat.id, call.message.message_id)
                except:
                    pass
                go_to_main_menu(call.message.chat.id)
    elif call.data.startswith("no_play_watch_"):
        pin = call.data.split("_")[3]
        user_id = str(call.from_user.id)
        user_data[user_id]["observing"] = True
        save_data()
        bot.answer_callback_query(call.id, "Теперь вы наблюдатель \uD83D\uDCDC", show_alert=True)
        try:
            bot.delete_message(call.message.chat.id, call.message.message_id)
        except:
            pass
    elif call.data.startswith("stats_details_"):
        _, uid = call.data.split("_")[1:]
        show_user_stats_details(call, uid)
    elif call.data.startswith("stats_back_"):
        _, uid = call.data.split("_")[1:]
        # Возвращаем исходную статистику (Message Editing)
        markup = types.InlineKeyboardMarkup()
        btn_details = types.InlineKeyboardButton("Полный разбор \uD83D\uDDD2", 
            callback_data=f"stats_details_{uid}")
        markup.add(btn_details)
        s = user_data[uid]["stats"]
        text = f"<b>Ваша статистика, {user_data[uid]['nickname']}</b>\n\n" \
               f"Игр сыграно: {s['games_played']}\n" \
               f"Побед за мафию: {s['wins_as_mafia']}\n" \
               f"Побед за доктора: {s['wins_as_doctor']}\n" \
               f"Побед за шерифа: {s['wins_as_sheriff']}\n" \
               f"Побед за мирного: {s['wins_as_civil']}\n"
        bot.edit_message_text(
            text, 
            call.message.chat.id,
            call.message.message_id,
            reply_markup=markup
        )
    elif call.data == "rules_lang_kz":
        # Показываем правила на казахском (упрощённо)
        text = "Ережелер (қысқаша) \uD83D\uDCD6\n\n" \
               "Бұл ойын 'Мафия' деп аталады... (здесь ваши правила на казахском)"
        markup = types.InlineKeyboardMarkup()
        btn_roles = types.InlineKeyboardButton("Как играть за роли \u2753", callback_data="how_to_play_roles_kz")
        markup.add(btn_roles)
        bot.edit_message_text(text, call.message.chat.id, call.message.message_id, reply_markup=markup)
    elif call.data == "rules_lang_ru":
        # Показываем правила на русском
        text = "Правила игры \uD83D\uDCD6\n\n" \
               "Это настольная игра 'Мафия', где есть мафия, доктор, шериф и мирные... (добавьте нужный текст)"
        markup = types.InlineKeyboardMarkup()
        btn_roles = types.InlineKeyboardButton("Как играть за роли \u2753", callback_data="how_to_play_roles_ru")
        markup.add(btn_roles)
        bot.edit_message_text(text, call.message.chat.id, call.message.message_id, reply_markup=markup)
    elif call.data.startswith("how_to_play_roles_"):
        # Допустим, один вариант и для русского, и для казахского, просто разный язык
        text = "<b>Как играть за Мафию, Доктора, Шерифа и Мирных:</b>\n\n" \
               "• Мафия: убивайте по ночам и не раскройтесь.\n" \
               "• Доктор: лечите игроков.\n" \
               "• Шериф: проверяйте подозрительных.\n" \
               "• Мирные: найдите мафию и проголосуйте правильно!\n"
        bot.edit_message_text(text, call.message.chat.id, call.message.message_id)

    save_data()

# -------------- СТАРТ БОТА --------------
if __name__ == "__main__":
    load_data()
    print("Bot is running...")
    bot.infinity_polling()

Краткое объяснение структуры кода

1. Глобальные словари user_data и rooms_data – отвечают за хранение данных о пользователях и комнатах.
2. JSON-файлы users_data.json и rooms_data.json используются для сохранения/загрузки этих данных, чтобы при перезапуске бота ничего не терялось.
3. Основные команды:
   • /start – приветствие, проверка/запрос ника.
   • Далее в основном перехватывается обычный текст (all_text_handler) и смотрим, что нажал/ввёл пользователь.
4. Главное меню (ReplyKeyboardMarkup):
   • «Создать комнату» – генерирует PIN, создаёт запись в rooms_data, показывает Inline-кнопку «Удалить комнату» и т.д.
   • «Присоединиться по пин коду» – бот ждёт, что следующий ввод от пользователя будет пин-кодом комнаты.
   • «Сменить никнейм» – очищаем у пользователя nickname, дальше бот ждёт нового ника.
   • «Моя статистика» – показывает статистику, есть кнопка «Полный разбор» (message editing).
   • «Таблица лидеров» – показывает простенький топ-3.
   • «Правила игры» – показывает инлайн-кнопки для выбора языка, затем правила, и кнопку «Как играть за роли».
5. Логика комнаты:
   • После создания комнаты генерируем два служебных сообщения (информационная доска и общий чат), чтобы обновлять их через edit_message_text.
   • Создателю даются кнопки «Начать игру», «Редактировать роли» (показано упрощённо), «Стать ведущим» и «Выйти».
   • Участникам – «Стать ведущим» и «Выйти».
6. Ночная и дневная фазы – реализованы в очень упрощённом виде: тут нет полноценного набора inline-кнопок для выбора жертвы/кого лечить/кого проверять, но показан пример, как это можно делать.
7. Голосование – также упрощённо (рандомно выбирается жертва). Но структура для update_vote_message и логика хранения голосов есть.
8. Наблюдатели, Повтор игры, Передача прав создателя и т.д. – по большей части в этом коде показаны концептуально, для полноты вам нужно будет доработать.
9. Смайлики – добавлены там, где это уместно, чтобы улучшить визуальное восприятие.

Вы можете дорабатывать любую часть (например, более сложную логику ночных действий, корректное распределение ролей, полноценный чат с «Обращаться к …» и т.д.). Но данный пример даёт хороший старт и иллюстрацию, как можно всю эту механику связать в одном боте.

Надеюсь, поможет вам начать! Удачи в разработке! ‍‍‍‍