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

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

  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 = '7013156611:AAEsIm7Vklxl6hHipwmiClgn9KAkgzNWuQg' # Замените на ваш токен бота Telegram bot = Bot(token=API_TOKEN) storage = MemoryStorage() dp = Dispatcher(bot, storage=storage) channel_id = "-1002034494437" 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)), is_found BOOLEAN NOT NULL DEFAULT 0 CHECK (is_found 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()
    
            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"{detectives_list_str}\n{hiders_list_str}\n\nИгра началась!"
            send_message = await bot.send_message(channel_id, text=message_text, reply_markup=keyboard_markup)
            async with aiosqlite.connect(database_path) as db:
                await db.execute("UPDATE games SET message_id = ? WHERE id = ?", (send_message.message_id, game_id))
                await db.commit()
    

    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()
    

    @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)
    

    @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, "Вы отмечены как найденный!")
    else:
        await bot.answer_callback_query(callback_query.id, "Нет активной игры.")
    

    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}"
            send_message = await bot.edit_message_text(chat_id=channel_id, message_id=message_id, text=new_msg_text,
                                        reply_markup=keyboard_markup)
    

    if name == 'main': loop = asyncio.get_event_loop() loop.run_until_complete(create_db()) executor.start_polling(dp, skip_updates=True) мне нужно сделать так, чтобы если не осталось ненайденных игроков, игра автоматически заканчивалась в пользу сыщиков

  2. Assistant

    Для того, чтобы добавить автоматическое завершение игры в пользу сыщиков, когда не остается ненайденных игроков, вам нужно изменить логику в функции player_found, которая отмечает игрока как найденного. После обновления статуса игрока (отмечая его как найденного), вам нужно проверить, остались ли еще ненайденные игроки. Если таких игроков нет, следует автоматически завершить игру в пользу сыщиков.

    Вот пример того, как можно модифицировать функцию 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()
    
            # Проверяем, есть ли активная игра
            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)
    
            # Проверяем, остались ли еще ненайденные игроки
            async with aiosqlite.connect(database_path) as db:
                cursor = await db.execute("SELECT COUNT(*) FROM players WHERE game_id = ? AND is_detective = 0 AND is_found = 0", (game_id,))
                hiders_left = await cursor.fetchone()
    
                if hiders_left[0] == 0:
                    # Ненайденных игроков не осталось, завершаем игру в пользу сыщиков автоматически
                    await finish_game_automatic(db, game_id)
                else:
                    await bot.answer_callback_query(callback_query.id, "Вы отмечены как найденный!")
        else:
            await bot.answer_callback_query(callback_query.id, "Нет активной игры.")
            
    async def finish_game_automatic(db, game_id):
        await db.execute("UPDATE games SET is_active = 0 WHERE id = ?", (game_id,))
        await db.commit()
    
        # Отправляем сообщение о победителях в чат
        announcement_text = "Все прячущиеся найдены. Победила команда Сыщиков!"
        await bot.send_message(channel_id, announcement_text)
    
        # Очищаем или сбрасываем необходимые состояния/данные, если это необходимо
    

    Обратите внимание, что функция finish_game_automatic(db, game_id) принимает параметр db – соединение с базой данных и game_id – идентификатор активной игры. Это позволяет использовать открытое соединение с базой данных для выполнения дополнительных запросов, таких как обновление статуса игры и отправка сообщения о завершении игры в чат.

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