Skip to content
The Chat Archive
gpt-4-0125-preview· OpenAI WildChat-4.8M (AI2)

Привет! Вот мой код бота: from aiogram import Bot, Dispatcher, types from…

  1. User

    Привет! Вот мой код бота: from aiogram import Bot, Dispatcher, types from aiogram.dispatcher import FSMContext from aiogram.dispatcher.filters.state import State, StatesGroup from aiogram.contrib.fsm_storage.memory import MemoryStorage from aiogram.types import ReplyKeyboardMarkup, KeyboardButton, InlineKeyboardMarkup, InlineKeyboardButton import aiosqlite from random import sample from aiogram.utils import executor import asyncio

    API_TOKEN = '6996318383:AAEcQfdQhzEg3L_6DKQVidJEn46Wb27Sy4g' # Замените на ваш токен бота Telegram bot = Bot(token=API_TOKEN) storage = MemoryStorage() dp = Dispatcher(bot, storage=storage) channel_id = "-1002014105263" database_path = "hide_seek_bot.db" # Путь к вашей базе данных

    async def create_db(): async with aiosqlite.connect(database_path) as db: await db.execute('''CREATE TABLE IF NOT EXISTS games ( id INTEGER PRIMARY KEY, message_id INTEGER, is_active BOOLEAN NOT NULL CHECK (is_active IN (0, 1)), created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)''') await db.execute('''CREATE TABLE IF NOT EXISTS players ( id INTEGER PRIMARY KEY, game_id INTEGER, user_id INTEGER NOT NULL, is_detective BOOLEAN NOT NULL CHECK (is_detective IN (0, 1)), FOREIGN KEY(game_id) REFERENCES games(id))''') await db.commit()

    class Form(StatesGroup): detective_count = State() # Количество сыщиков

    async def is_admin(user_id: int): admin_ids = [989037374, 511205958] return user_id in admin_ids

    @dp.message_handler(commands=['start']) async def send_welcome(message: types.Message): if await is_admin(message.from_user.id): markup = ReplyKeyboardMarkup(resize_keyboard=True, selective=True) markup.add(KeyboardButton("Создать игру")) markup.add(KeyboardButton("Определить сыщиков")) markup.add(KeyboardButton("Завершить игру")) await message.reply("Вы администратор бота. Используйте кнопки.", reply_markup=markup) else: await message.reply("Извините, доступно только администраторам.")

    @dp.callback_query_handler(text="participate") async def participate_in_game(callback_query: types.CallbackQuery): user_id = callback_query.from_user.id async with aiosqlite.connect(database_path) as db: async with db.execute("SELECT id FROM games WHERE is_active = 1") as cursor: game = await cursor.fetchone() if not game: await bot.answer_callback_query(callback_query.id, "В данный момент нет активной игры.") return

        game_id = game[0]
    
        async with db.execute("SELECT id FROM players WHERE game_id = ? AND user_id = ?", (game_id, user_id)) as cursor:
            participant = await cursor.fetchone()
            if participant:
                await bot.answer_callback_query(callback_query.id, "Вы уже участвуете в этой игре.")
                return
    
        await db.execute("INSERT INTO players (game_id, user_id, is_detective) VALUES (?, ?, 0)", (game_id, user_id))
    
        await db.commit()
        async with db.execute("SELECT message_id FROM games WHERE is_active = 1") as cursor:
            game_info = await cursor.fetchone()
            if game_info:
                message_id = game_info[0]
    
        players_list_str = await generate_players_list(db)
        keyboard_markup = types.InlineKeyboardMarkup(row_width=1)
        participation_button = types.InlineKeyboardButton(text="Участвовать", callback_data="participate")
        keyboard_markup.add(participation_button)
        new_msg_text = f"Начинается новая игра! Участники:\n{players_list_str}\nДля участия нажмите кнопку ниже."
        await bot.edit_message_text(chat_id=channel_id, message_id=message_id, text=new_msg_text,
                                    reply_markup=keyboard_markup)
    
    await bot.answer_callback_query(callback_query.id, "Вы успешно присоединились к игре!")
    

    async def generate_players_list(db): players_list_str = "" async with db.execute("SELECT user_id FROM players WHERE game_id = (SELECT id FROM games WHERE is_active = 1)") as cursor: players = await cursor.fetchall() for player in players: user_id = player[0] try: user = await bot.get_chat_member(channel_id, user_id) username = "@" + user.user.username if user.user.username else f"{user_id}" players_list_str += username + "\n" except Exception as e: continue # Пропускаем в случае ошибки return players_list_str

    @dp.message_handler(lambda message: message.text == "Создать игру") async def create_game(message: types.Message): async with aiosqlite.connect(database_path) as db: # Проверяем, есть ли активная игра async with db.execute("SELECT id FROM games WHERE is_active = 1") as cursor: active_game = await cursor.fetchone()

        if active_game:
            await message.reply("Уже существует активная игра. Необходимо сначала её завершить.")
            return
    
        # Создаём новую игру
        cursor = await db.execute("INSERT INTO games (is_active) VALUES (1)")
        game_id = cursor.lastrowid
        await db.commit()
    
        keyboard_markup = types.InlineKeyboardMarkup(row_width=1)
        participation_button = types.InlineKeyboardButton(text="Участвовать", callback_data="participate")
        keyboard_markup.add(participation_button)
    
        msg = await bot.send_message(channel_id, "Начинается новая игра! Для участия нажмите кнопку ниже.",
                                     reply_markup=keyboard_markup)
    
        # Сохраняем message_id игры
        await db.execute("UPDATE games SET message_id = ? WHERE id = ?", (msg.message_id, game_id))
        await db.commit()
    
        await message.reply("Игра создана и объявлена в канале.")
    

    @dp.message_handler(lambda message: message.text == "Определить сыщиков", state=None) async def request_detective_count(message: types.Message): if await is_admin(message.from_user.id): await Form.detective_count.set() await message.reply("Введите количество сыщиков:") else: await message.reply("Извините, доступно только администраторам.")

    @dp.message_handler(state=Form.detective_count) async def handle_set_detective_count(message: types.Message, state: FSMContext): # Тут ваш код обработки 'set_detective_count' await pick_detectives(message, int(message.text)) # Вызов функции pick_detectives с количеством сыщиков await state.finish() # Завершение состояния

    async def pick_detectives(message: types.Message, num_of_detectives: int): async with aiosqlite.connect(database_path) as db: # Получаем ID активной игры async with db.execute("SELECT id FROM games WHERE is_active = 1 LIMIT 1") as cursor: game = await cursor.fetchone() if not game: await message.reply("В данный момент нет активной игры.") return

        game_id = game[0]
    
        # Получаем список ID игроков этой игры
        async with db.execute("SELECT user_id FROM players WHERE game_id = ? AND is_detective = 0",
                              (game_id,)) as cursor:
            players = await cursor.fetchall()
            if len(players) <= num_of_detectives:
                await message.reply("Недостаточно игроков для выбора сыщиков.")
                return
    
            # Рандомно выбираем сыщиков
            detectives_ids = sample([p[0] for p in players], num_of_detectives)
            channel_id = "-1002014105263"
            # Фомируем визуальный список сыщиков для отправки сообщения
            detective_list_info = []
            for user_id in detectives_ids:
                user = await bot.get_chat_member(channel_id, user_id)  # Получаем информацию о пользователе
                username = user.user.username
                if username:
                    detective_list_info.append(f"@{username}")
                else:
                    detective_list_info.append(f"{user_id}")  # Если username отсутствует, используем ID
    
            # Обновляем статус выбранных игроков на сыщиков
            for user_id in detectives_ids:
                await db.execute("UPDATE players SET is_detective = 1 WHERE game_id = ? AND user_id = ?",
                                 (game_id, user_id))
            await db.commit()
    
            detective_list_str = ", ".join(detective_list_info)
            await bot.send_message(channel_id, f"🕵️‍♂️ Сыщики определены:\n\n {detective_list_str}\n\n **Игра началась\!**",parse_mode="MarkdownV2")
            await message.reply("Сыщики успешно определены и объявлены в канале.")
    

    @dp.message_handler(lambda message: message.text == "Завершить игру") async def finish_the_game_request(message: types.Message): if not await is_admin(message.from_user.id): await message.reply("Только администраторы могут завершать игру.") return

    # Предположим, у нас есть две команды: Сыщики и Прячущиеся
    markup = types.InlineKeyboardMarkup()
    markup.add(types.InlineKeyboardButton("Сыщики", callback_data="win_detectives"))
    markup.add(types.InlineKeyboardButton("Прячущиеся", callback_data="win_hiders"))
    
    await message.reply("Какая команда победила?", reply_markup=markup)
    

    @dp.callback_query_handler(lambda c: c.data == "win_detectives" or c.data == "win_hiders") async def announce_winners(callback_query: types.CallbackQuery): await bot.answer_callback_query(callback_query.id)

    winning_team = "Сыщики" if callback_query.data == "win_detectives" else "Прячущиеся"
    async with aiosqlite.connect(database_path) as db:
        # Получаем ID активной игры
        async with db.execute("SELECT id FROM games WHERE is_active = 1 LIMIT 1") as cursor:
            active_game = await cursor.fetchone()
            if not active_game:
                await bot.send_message(callback_query.from_user.id, "Активная игра не найдена.")
                return
            game_id = active_game[0]
    
        # Помечаем игру как завершенную
        await db.execute("UPDATE games SET is_active = 0 WHERE id = ?", (game_id,))
        await db.commit()
    
        # Получаем список участников победившей команды
        role_condition = "1" if callback_query.data == "win_detectives" else "0"
        async with db.execute("SELECT user_id FROM players WHERE game_id = ? AND is_detective = ?",
                              (game_id, role_condition)) as cursor:
            players = await cursor.fetchall()
    
        # Формируем список для публикации
        player_list = []
        for player in players:
            user_id = player[0]
            try:
                # Попытка получить пользователя для взаимодействия
                user = await bot.get_chat_member(channel_id, user_id)  # Получаем информацию о пользователе
                username = user.user.username
                if username:
                    player_list.append(f"@{user.user.username}")
                else:
                    player_list.append(f"ID: {user_id}")
            except:
                # В случае ошибки, используем ID
                player_list.append(f"ID: {user_id}")
    
        winners_text = ", ".join(player_list)
        # Отправляем сообщение о победителях в чат
        announcement_text = f"Победила команда {winning_team}: {winners_text}"
        await bot.send_message(channel_id, announcement_text)
    

    if name == 'main': loop = asyncio.get_event_loop() loop.run_until_complete(create_db()) executor.start_polling(dp, skip_updates=True)

    А вот что ты мне подсказал:

    Шаг 1: Изменение обработчика кнопки “Меня нашли”

    Мы модифицируем обработчик кнопки “Меня нашли” так, чтобы после “нахождения” игрока он удалял его из списка прячущихся в сообщении:

    @dp.callback_query_handler(text=“found_me”) async def player_found(callback_query: types.CallbackQuery): user_id = callback_query.from_user.id game_id = None

    async with aiosqlite.connect(database_path) as db:
        # Устанавливаем is_detective в 1 для обозначения, что игрок найден
        await db.execute(“UPDATE players SET is_detective = 1 WHERE user_id = ? AND is_detective = 0”, (user_id,))
        await db.commit()
    
        # Получаем ID активной игры, чтобы обновить список игроков
        cursor = await db.execute(“SELECT id FROM games WHERE is_active = 1”)
        row = await cursor.fetchone()
        if row:
            game_id = row[0]
    
    if game_id:
        # Обновляем список игроков
        await update_players_list(channel_id, game_id)
    
    await bot.answer_callback_query(callback_query.id, “Вы отмечены как найденный!”)
    

    Шаг 2: Создание функции обновления списка игроков

    Создадим функцию update_players_list, которая будет обновлять сообщение в канале с актуальным списком прячущихся игроков. Эта функция должна получить ID последнего сообщения о игре в канале, сгенерировать новый список прячущихся игроков и обновить соответствующее сообщение:

    async def update_players_list(channel_id, game_id): # Сгенерируем новый список игроков players_list_str = “” async with aiosqlite.connect(database_path) as db: cursor = await db.execute(“SELECT user_id FROM players WHERE game_id = ? AND is_detective = 0”, (game_id,)) players = await cursor.fetchall()

        for player in players:
            user_id = player[0]
            try:
                user = await bot.get_chat_member(channel_id, user_id)
                username = “@” + user.user.username if user.user.username else f"{user_id}“
                players_list_str += username + “\n”
            except Exception:
                continue  # Пропускаем в случае ошибки
    
        # Получаем ID последнего сообщения об игре в канале для его обновления
        cursor = await db.execute(“SELECT message_id FROM games WHERE id = ?”, (game_id,))
        row = await cursor.fetchone()
        if row:
            message_id = row[0]
    
            # Обновляем сообщение в канале
            keyboard_markup = types.InlineKeyboardMarkup()
            found_button = types.InlineKeyboardButton(text=“Меня нашли”, callback_data=“found_me”)
            keyboard_markup.add(found_button)
            new_msg_text = f"Сыщики определены. Осталось прячущихся:\n{players_list_str}”
    
            await bot.edit_message_text(chat_id=channel_id, message_id=message_id, text=new_msg_text, reply_markup=keyboard_markup)
    

    мне нельзя делать так, чтобы у найденных игроков is_detective становилось 1, иначе в случае победы сыщиков они тоже выйдут победителями. Надо как-то иначе это реализовать

  2. Assistant

    Понимаю вашу задачу. Давайте попробуем другой путь для обозначения статуса игрока (найден/не найден) без изменения его роли в игре (детектив/прячущийся). Один из подходов — создать дополнительный столбец в таблице players для отслеживания состояния игрока (например, is_found).

    Шаг 1: Модификация таблицы

    Сначала добавим новый столбец is_found в таблицу players. Вы можете сделать это, добавив следующий код после создания таблиц в вашей функции create_db:

    await db.execute('''ALTER TABLE players ADD COLUMN is_found BOOLEAN NOT NULL DEFAULT 0 CHECK (is_found IN (0, 1))''')
    

    Этот код добавит в таблицу players колонку is_found, указывающую был ли игрок найден. Значение по умолчанию — 0 (не найден).

    Шаг 2: Обработка нахождения игрока

    Ваша новая реализация обработчика player_found теперь будет обновлять is_found вместо is_detective. Примерно так:

    @dp.callback_query_handler(text="found_me")
    async def player_found(callback_query: types.CallbackQuery):
        user_id = callback_query.from_user.id
        game_id = None
    
        async with aiosqlite.connect(database_path) as db:
            await db.execute("UPDATE players SET is_found = 1 WHERE user_id = ? AND is_found = 0", (user_id,))
            await db.commit()
    
            cursor = await db.execute("SELECT id FROM games WHERE is_active = 1")
            row = await cursor.fetchone()
            if row:
                game_id = row[0]
    
        if game_id:
            await update_players_list(channel_id, game_id)
    
        await bot.answer_callback_query(callback_query.id, "Вы отмечены как найденный!")
    

    Шаг 3: Обновление списка игроков

    Метод update_players_list теперь должен исключать тех, кто уже найден:

    async def update_players_list(channel_id, game_id):
        players_list_str = ""
        async with aiosqlite.connect(database_path) as db:
            cursor = await db.execute("SELECT user_id FROM players WHERE game_id = ? AND is_found = 0", (game_id,))
            players = await cursor.fetchall()
            
            for player in players:
                user_id = player[0]
                try:
                    user = await bot.get_chat_member(channel_id, user_id)
                    username = "@" + user.user.username if user.user.username else f"{user_id}"
                    players_list_str += username + "\n"
                except Exception:
                    continue  # Пропускаем в случае ошибки
    
            cursor = await db.execute("SELECT message_id FROM games WHERE id = ?", (game_id,))
            row = await cursor.fetchone()
            if row:
                message_id = row[0]
                keyboard_markup = types.InlineKeyboardMarkup()
                found_button = types.InlineKeyboardButton(text="Меня нашли", callback_data="found_me")
                keyboard_markup.add(found_button)
                new_msg_text = f"Сыщики определены. Осталось ненайденных:\n{players_list_str}"
                await bot.edit_message_text(chat_id=channel_id, message_id=message_id, text=new_msg_text, reply_markup=keyboard_markup)
    

    Это обеспечит корректное отслеживание статуса игроков без вмешательства в логику определения победителя. Убедитесь, что в других частях кода, где вы используете статус "сыщик"(is_detective), не происходит путаницы с новым статусом is_found.

  3. User

    Пропиши, пожалуйста, модификацию БД прямо в create_db, т.к. мы еще можем менять структуру БД. Также в твоей логике изменения сообщения потерялись юзернеймы сыщиков. Исправь, пожалуйста

  4. Assistant

    Конечно, давайте внесем необходимые изменения непосредственно в функцию create_db для создания БД с новой колонкой is_found, и исправим логику обновления сообщения, чтобы отображалось корректно и для сыщиков, и для оставшихся игроков.

    Изменённая функция create_db

    async def create_db():
        async with aiosqlite.connect(database_path) as db:
            await db.execute('''CREATE TABLE IF NOT EXISTS games (
                                id INTEGER PRIMARY KEY,
                                message_id INTEGER,
                                is_active BOOLEAN NOT NULL CHECK (is_active IN (0, 1)),
                                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)''')
            await db.execute('''CREATE TABLE IF NOT EXISTS players (
                                id INTEGER PRIMARY KEY,
                                game_id INTEGER,
                                user_id INTEGER NOT NULL,
                                is_detective BOOLEAN NOT NULL CHECK (is_detective IN (0, 1)),
                                is_found BOOLEAN NOT NULL DEFAULT 0 CHECK (is_found IN (0, 1)),
                                FOREIGN KEY(game_id) REFERENCES games(id))''')
            await db.commit()
    

    Исправления в логике обновления сообщения

    Для исправления потери информации о сыщиках и прячущихся, мы перепишем функцию update_players_list так, чтобы она корректно формировала список игроков на основе их текущего статуса (is_detective и is_found):

    async def update_players_list(channel_id, game_id):
        detectives_str = ""
        hiders_str = ""
        async with aiosqlite.connect(database_path) as db:
            # Получаем список сыщиков
            cursor = await db.execute("SELECT user_id FROM players WHERE game_id = ? AND is_detective = 1", (game_id,))
            detectives = await cursor.fetchall()
            for user_id in [det[0] for det in detectives]:
                try:
                    user = await bot.get_chat_member(channel_id, user_id)
                    username = f"@{user.user.username}" if user.user.username else str(user_id)
                    detectives_str += username + "\n"
                except Exception:
                    continue  # Пропускаем в случае ошибки
    
            # Получаем список оставшихся игроков (прячущихся не найденных)
            cursor = await db.execute("SELECT user_id FROM players WHERE game_id = ? AND is_detective = 0 AND is_found = 0", (game_id,))
            hiders = await cursor.fetchall()
            for user_id in [hid[0] for hid in hiders]:
                try:
                    user = await bot.get_chat_member(channel_id, user_id)
                    username = f"@{user.user.username}" if user.user.username else str(user_id)
                    hiders_str += username + "\n"
                except Exception:
                    continue  # Пропускаем в случае ошибки
    
            cursor = await db.execute("SELECT message_id FROM games WHERE id = ?", (game_id,))
            row = await cursor.fetchone()
            if row:
                message_id = row[0]
    
                keyboard_markup = types.InlineKeyboardMarkup()
                found_button = types.InlineKeyboardButton(text="Меня нашли", callback_data="found_me")
                keyboard_markup.add(found_button)
                
                # Сформированный текст сообщения объединяет информацию о обеих группах игроков
                new_msg_text = f"Сыщики:\n{detectives_str}\nОстальные прячущиеся:\n{hiders_str}"
                await bot.edit_message_text(chat_id=channel_id, message_id=message_id, text=new_msg_text, reply_markup=keyboard_markup)
    

    Этот подход позволит вам эффективно отслеживать и обновлять статус участников игры, помечая игроков как найденных без изменения их основных ролей и обеспечивая правильное отображение информации в сообщениях.

  5. User

    с сообщением "сыщики определены" должна идти кнопка "меня нашли"

  6. Assistant

    Понял вас, давайте корректировать логику так, чтобы после определения сыщиков в сообщении появлялась кнопка "Меня нашли", которая позволит прячущимся игрокам отметить, что их нашли. С этим замечанием, вам будет нужно немного изменить логику в коде, который отправляет сообщения после выбора сыщиков, а также корректно обновлять сообщение в канале на основе текущего статуса игры. Рассмотрим подробно изменения:

    Шаг после выбора сыщиков

    После определения сыщиков вы хотите отправить сообщение, которое уже содержит кнопку "Меня нашли" для тех, кто скрывается. В этом случае, когда сыщики назначены, сообщение в канале должно быть обновлено, чтобы отражать текущих сыщиков и предоставить кнопку для прячущихся игроков:

    Отправка/Обновление сообщения после выбора сыщиков

    async def pick_detectives(message: types.Message, num_of_detectives: int):
        # Предыдущая логика выбора сыщиков...
        # После обновления статуса сыщиков в БД, отправляем/обновляем сообщение с добавлением кнопки "Меня нашли":
        detectives_list_str, hiders_list_str = await generate_players_and_detectives_list(db)
        keyboard_markup = types.InlineKeyboardMarkup()
        found_button = types.InlineKeyboardButton(text="Меня нашли", callback_data="found_me")
        keyboard_markup.add(found_button)
        message_text = f"Сыщики определены:\n{detectives_list_str}\nОставшиеся игроки:\n{hiders_list_str}"
        await bot.send_message(channel_id, text=message_text, reply_markup=keyboard_markup)  # Это если вы создаёте новое сообщение
        # или
        # await bot.edit_message_text(chat_id=channel_id, message_id=сообщениеID, text=message_text, reply_markup=keyboard_markup)  # Это если вы обновляете уже существующее
    

    Таким образом, после определения сыщиков, оставшиеся участники игры будут видеть кнопку "Меня нашли" и смогут сообщить об их нахождении, нажимая на эту кнопку.

    Список игроков и сыщиков

    Функция generate_players_and_detectives_list, упомянутая выше, должна возвращать две строки: одну для списка сыщиков (detectives_list_str), другую для списка оставшихся игроков (hiders_list_str), которые не были найдены. Предлагаем создать эту функцию, если её ещё нет:

    async def generate_players_and_detectives_list(db):
        # Здесь логика для генерации строковых представлений списков сыщиков и прячущихся игроков
        return detectives_list_str, hiders_list_str
    

    Это лишь предложение и примерный план того, как можно подойти к решению вашей задачи. Вам потребуется адаптировать этот пример под вашу текущую структуру и логику кода, а также реализовать или настроить функцию generate_players_and_detectives_list для корректной работы с вашей базой данных.

  7. User

    Пропиши логику async def generate_players_and_detectives_list(db):

  8. Assistant

    Для того чтобы создать функцию generate_players_and_detectives_list, которая будет генерировать списки игроков для текста сообщения, воспользуемся уже имеющейся структурой БД. Данная функция должна вернуть две строки: одну с перечнем сыщиков и вторую с перечнем оставшихся прячущихся, которые ещё не были найдены. Например, так:

    async def generate_players_and_detectives_list(db):
        detectives_list_str = "Сыщики:\n"
        hiders_list_str = "Прячущиеся:\n"
        
        # Запрос на получение сыщиков
        async with db.execute("SELECT user_id FROM players WHERE is_detective = 1") as cursor:
            detectives = await cursor.fetchall()
            for det in detectives:
                user_id = det[0]
                try:
                    user_info = await bot.get_chat_member(channel_id, user_id)
                    user_name = "@" + user_info.user.username if user_info.user.username else "ID: " + str(user_id)
                    detectives_list_str += user_name + "\n"
                except Exception as e: 
                    print(f"Ошибка получения данных о пользователе: {e}")
    
        # Запрос на получение прячущихся, которые еще не найдены
        async with db.execute("SELECT user_id FROM players WHERE is_detective = 0 AND is_found = 0") as cursor:
            hiders = await cursor.fetchall()
            for hid in hiders:
                user_id = hid[0]
                try:
                    user_info = await bot.get_chat_member(channel_id, user_id)
                    user_name = "@" + user_info.user.username if user_info.user.username else "ID: " + str(user_id)
                    hiders_list_str += user_name + "\n"
                except Exception as e:
                    print(f"Ошибка получения данных о пользователе: {e}")
    
        return detectives_list_str.strip(), hiders_list_str.strip()
    

    Функция generate_players_and_detectives_list выполняет два SQL запроса к базе данных: первый для получения списка сыщиков, второй — для получения списка всех прячущихся игроков, которые ещё не были найдены (is_found = 0). Для каждого игрока по его user_id через вызов bot.get_chat_member пытается получить его юзернейм. В случае успеха формирует строку с упоминанием пользователя (@username), а если юзернейм не доступен — использует ID: user_id.

    Примечание: Эта функция рассчитывает на то, что у вас в коде уже определены переменные bot и channel_id. Убедитесь, что данные переменные доступны в контексте, где вы планируете использовать данную функцию. В противном случае, вам нужно будет передать их как дополнительные аргументы в функцию.

    Используйте эту функцию там, где вам необходимо обновить или отправить информацию о состоянии текущей игры после выбора сыщиков или когда требуется обновить список прячущихся после того, как кто-то из них был найден.

  9. User

    Списки выдаются некорректно. Сыщик - @Ih82seeucry Вот сообщение от бота: " Сыщики: @Ih82seeucry @ask357666 @Ih82seeucry @Ih82seeucry Прячущиеся: @gnkitty @ask357666 @gnkitty @gnkitty @ask357666

    Игра началась!"

  10. Assistant

    Похоже, проблема возникает из-за того, что в вашей базе данных одни и те же игроки могут быть повторно добавлены как сыщики или прячущиеся, что приводит к дублированию имён в выводе. Чтобы устранить повторение, можно использовать SQL-запросы, которые выбирают уникальные значения, или же удалить дубликаты на уровне Python, используя структуру данных set. Исправим логику функции generate_players_and_detectives_list, чтобы избежать дублирования информации о пользователях.

    Улучшенная версия функции без дублирования

    async def generate_players_and_detectives_list(db):
        detectives_list_str = "Сыщики:\n"
        hiders_list_str = "Прячущиеся:\n"
        
        detectives_user_ids = set()  # Используем множество для хранения уникальных ID сыщиков
        hiders_user_ids = set()  # Множество для хранения уникальных ID прячущихся
    
        # Запрос на получение сыщиков
        async with db.execute("SELECT DISTINCT user_id FROM players WHERE is_detective = 1") as cursor:
            async for det in cursor:
                detectives_user_ids.add(det[0])
    
        # Запрос на получение прячущихся, которые еще не найдены
        async with db.execute("SELECT DISTINCT user_id FROM players WHERE is_detective = 0 AND is_found = 0") as cursor:
            async for hid in cursor:
                hiders_user_ids.add(hid[0])
    
        # Заполняем строку сыщиков
        for user_id in detectives_user_ids:
            try:
                user_info = await bot.get_chat_member(channel_id, user_id)
                user_name = f"@{user_info.user.username}" if user_info.user.username else f"ID: {user_id}"
                detectives_list_str += user_name + "\n"
            except Exception as e:
                print(f"Ошибка получения данных о пользователе: {e}")
    
        # Заполняем строку прячущихся
        for user_id in hiders_user_ids:
            try:
                user_info = await bot.get_chat_member(channel_id, user_id)
                user_name = f"@{user_info.user.username}" if user_info.user.username else f"ID: {user_id}"
                hiders_list_str += user_name + "\n"
            except Exception as e:
                print(f"Ошибка получения данных о пользователе: {e}")
    
        return detectives_list_str.strip(), hiders_list_str.strip()
    

    Таким образом, использование множества (set) для хранения уникальных user_id избавляет от дублирования в списках сыщиков и прячущихся. В запросах к БД уже используется ключевое слово DISTINCT для выбора уникальных записей, но также важно убедиться, что позже, при обработке этих данных, не произойдет добавления дубликатов, что и обеспечивается использованием множества. Это позволяет эффективно устранить проблему дублирования в генерируемых списках.

  11. User

    Проблема не в дублировании. Проблема в том, что код берет информацию как с текущей игры, так и с предыдущих. Нужно сделать так, чтобы он брал информацию только с текущей

  12. Assistant

    Чтобы убедиться, что информация берется только из текущей игры, вам необходимо добавить фильтрацию по id активной игры в ваши SQL-запросы при выборке игроков. Мы можем достать id текущей игры, где is_active = 1, и использовать его в запросах для получения списков сыщиков и прячущихся. Вот как можно это сделать:

    Модификация функции для работы с текущей игрой

    async def generate_players_and_detectives_list(db):
        detectives_list_str = "Сыщики:\n"
        hiders_list_str = "Прячущиеся:\n"
        current_game_id = None
        
        # Сначала найдем id активной игры
        async with db.execute("SELECT id FROM games WHERE is_active = 1") as cursor:
            game = await cursor.fetchone()
            if game:
                current_game_id = game[0]
            else:
                return "Нет активной игры.", "Нет активной игры."
    
        # После нахождения id игры, используем его для выборки игроков этой игры
        # Запрос на получение сыщиков текущей активной игры
        async with db.execute("SELECT DISTINCT user_id FROM players WHERE game_id = ? AND is_detective = 1", (current_game_id,)) as cursor:
            async for det in cursor:
                try:
                    user_info = await bot.get_chat_member(channel_id, det[0])
                    user_name = f"@{user_info.user.username}" if user_info.user.username else f"ID: {det[0]}"
                    detectives_list_str += user_name + "\n"
                except Exception as e:
                    print(f"Ошибка получения данных о пользователе: {e}")
    
        # Запрос на получение прячущихся текущей активной игры, которые еще не найдены
        async with db.execute("SELECT DISTINCT user_id FROM players WHERE game_id = ? AND is_detective = 0 AND is_found = 0", (current_game_id,)) as cursor:
            async for hid in cursor:
                try:
                    user_info = await bot.get_chat_member(channel_id, hid[0])
                    user_name = f"@{user_info.user.username}" if user_info.user.username else f"ID: {hid[0]}"
                    hiders_list_str += user_name + "\n"
                except Exception as e:
                    print(f"Ошибка получения данных о пользователе: {e}")
    
        return detectives_list_str.strip(), hiders_list_str.strip()
    

    В этой версии функции мы сначала определяем id текущей активной игры (is_active = 1), а затем используем этот id в качестве условия в SQL-запросах, чтобы получить списки игроков только для этой игры. Таким образом, вы гарантируете, что информация о сыщиках и прячущихся будет получена только для текущей активной игры, исключая информацию из предыдущих игр.

  13. User

    Все хорошо, но меняется предыдущее сообщение с набором в игру, а не текущее. Можем ли мы тогда сделать так, чтобы текущее сообщение удалялось после первого отмеченного как найденный?

  14. Assistant

    Конечно, давайте рассмотрим, как можно удалить текущее сообщение с набором в игру после того, как первый игрок будет отмечен как найденный. Для этого вы можете использовать метод delete_message бота. Изменим обработчик player_found, чтобы он проверял, был ли отмечен хотя бы один игрок как найденный, и если это так, удалял сообщение с набором в игру.

    Модификация обработчика player_found

    Допустим, вы хотите удалить сообщение с набором в игру после того, как первый игрок был отмечен как найденный. Вам сначала нужен механизм, чтобы отслеживать состояние - был ли уже кто-то найден в текущей игре. Это можно сделать различными способами, например, добавив новый столбец в таблицу games, который будет указывать, что игра перешла в активную фазу и набор игроков завершён. В рамках нашего текущего подхода, где такого столбца нет, давайте сделаем упрощённое предположение:

    1. После того как первый игрок отмечен как найденный, мы удаляем сообщение с набором.
    2. Чтобы определить, нужно ли удалять сообщение, посчитаем количество найденных игроков. Если это первый найденный игрок, общее количество найденных будет 1, и мы удаляем сообщение.

    Обработчик player_found с удалением сообщения

    @dp.callback_query_handler(text="found_me")
    async def player_found(callback_query: types.CallbackQuery):
        user_id = callback_query.from_user.id
        game_id = None
    
        async with aiosqlite.connect(database_path) as db:
            # Обновляем статус игрока на найденный
            await db.execute("UPDATE players SET is_found = 1 WHERE user_id = ? AND is_found = 0", (user_id,))
            await db.commit()
    
            # Проверяем, является ли этот игрок первым найденным
            async with db.execute("SELECT COUNT(*) FROM players WHERE is_found = 1") as cursor:
                found_count = await cursor.fetchone()
                found_count = found_count[0] if found_count else 0
    
            # Получаем ID и message_id активной игры
            async with db.execute("SELECT id, message_id FROM games WHERE is_active = 1") as cursor:
                game = await cursor.fetchone()
                if game:
                    game_id, message_id = game
    
            # Если это первый найденный игрок, удаляем сообщение с набором
            if found_count == 1 and game_id and message_id:
                try:
                    await bot.delete_message(chat_id=channel_id, message_id=message_id)
                except Exception as e:
                    print(f"Ошибка при удалении сообщения: {e}")
    
        await bot.answer_callback_query(callback_query.id, "Вы отмечены как найденный!")
    

    Обратите внимание, что этот метод будет работать, если сохранение message_id выполняется корректно при создании игры и отправке сообщения с набором в игру. Также важно учитывать, что после удаления сообщения с набором, новый список игроков (или обновлённое сообщение о статусе игры) должен быть отправлен/обновлён отдельно.

    Этот пример ориентирован на удаление именно того сообщения, которое информирует о начале набора в игру. Если в вашей логике предусмотрены другие сценарии или дополнительные сообщения, которые должны быть обновлены или удалены, вам необходимо будет внести соответствующие корректировки в код.