Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

import sqlite3 import random import time import asyncio intents =…

  1. User

    import sqlite3 import random import time import asyncio

    intents = discord.Intents.default() intents.members = True

    cards = [ {"name": "Phantom", "type": "Geist", "power": 64, "rarity": "common", "description": "Ein schleichender Geist, der Schrecken verbreitet.", "ability": None}, {"name": "Banshee", "type": "Geist", "power": 72, "rarity": "rare", "description": "Ein rachsüchtiger Geist, der Tod durch Schrei verkündet.", "ability": None}, {"name": "Wraith", "type": "Geist", "power": 68, "rarity": "epic", "description": "Eine Erscheinung, die durch Wände gleitet.", "ability": "ignore_defense"}, {"name": "Ghoul", "type": "Untoter", "power": 56, "rarity": "common", "description": "Ein bösartiges Wesen, das die Lebenden heimsucht.", "ability": None}, {"name": "Vampir", "type": "Untoter", "power": 76, "rarity": "epic", "description": "Ein nachtaktives Wesen, das Blut saugt.", "ability": "lifesteal"}, {"name": "Zombie", "type": "Untoter", "power": 48, "rarity": "common", "description": "Ein wandelnder Toter, der nie ruht.", "ability": None}, {"name": "Skelett", "type": "Untoter", "power": 52, "rarity": "common", "description": "Ein klappriges Gerippe, das sich bewegt.", "ability": None}, {"name": "Heilungs-Karte", "type": "Heilung", "power": 16, "rarity": "common", "description": "Eine heilende Kraft, die 16 Lebenspunkte wiederherstellt.", "ability": None}, {"name": "Block-Karte", "type": "Block", "power": 0, "rarity": "common", "description": "Eine Schutzkarte, die einen Angriff vereitelt.", "ability": "block"}, {"name": "Verfluchte Rüstung", "type": "Geist", "power": 60, "rarity": "rare", "description": "Eine verfluchte Rüstung, die den Träger beschützt.", "ability": "shield"}, {"name": "Höllenhund", "type": "Geist", "power": 80, "rarity": "legendary", "description": "Ein dämonischer Hund, dessen Augen feurigen Zorn sprühen.", "ability": "burn"}, {"name": "Nekromant", "type": "Untoter", "power": 88, "rarity": "legendary", "description": "Ein Hexer, der die Toten erweckt.", "ability": "revive"}, {"name": "Spektral", "type": "Geist", "power": 64, "rarity": "rare", "description": "Ein durchscheinendes Wesen voller Geheimnisse.", "ability": None}, {"name": "Verfluchte Puppe", "type": "Untoter", "power": 40, "rarity": "common", "description": "Eine Puppe, die mit einem Fluch belegt ist.", "ability": "curse"}, {"name": "Schatten-Dämon", "type": "Geist", "power": 72, "rarity": "epic", "description": "Ein Wesen aus purer Dunkelheit.", "ability": "shadow_strike"}, {"name": "Lich-König", "type": "Untoter", "power": 96, "rarity": "legendary", "description": "Der unsterbliche König der Toten.", "ability": "frost_nova"}, {"name": "Dunkler Magier", "type": "Geist", "power": 76, "rarity": "epic", "description": "Ein Magier, der die dunklen Künste beherrscht.", "ability": "mana_burn"}, {"name": "Schreckgespenst", "type": "Geist", "power": 68, "rarity": "rare", "description": "Ein Albtraumwesen, das Angst verbreitet.", "ability": "fear"}, {"name": "Feuergeist", "type": "Geist", "power": 72, "rarity": "epic", "description": "Ein Geist aus reiner Flamme.", "ability": "burn"}, {"name": "Stille Schatten", "type": "Geist", "power": 64, "rarity": "rare", "description": "Schatten, die alle Geräusche verschlucken.", "ability": "silence"}, {"name": "Ghulkönig", "type": "Untoter", "power": 80, "rarity": "legendary", "description": "Der Herrscher aller Ghule.", "ability": "summon"}, {"name": "Seelenräuber", "type": "Untoter", "power": 76, "rarity": "epic", "description": "Ein Wesen, das Seelen stiehlt.", "ability": "drain_soul"}, {"name": "Poltergeist", "type": "Geist", "power": 56, "rarity": "common", "description": "Ein Geist, der bekannt dafür ist, Objekte zu werfen.", "ability": "throw_objects"}, {"name": "Shade", "type": "Geist", "power": 68, "rarity": "rare", "description": "Ein schüchterner Geist, der weniger aktiv ist, wenn viele Menschen in der Nähe sind.", "ability": "hide_presence"}, {"name": "Phantom", "type": "Geist", "power": 72, "rarity": "epic", "description": "Ein Geist, der beim Anschauen Angst verbreitet.", "ability": "fear"}, {"name": "Banshee", "type": "Geist", "power": 76, "rarity": "epic", "description": "Ein Geist, der sich auf ein Opfer konzentriert und es verfolgt.", "ability": "mark_target"}, {"name": "Mare", "type": "Geist", "power": 64, "rarity": "rare", "description": "Ein Geist, der in der Dunkelheit stärker wird.", "ability": "dark_power"}, {"name": "Revenant", "type": "Geist", "power": 80, "rarity": "legendary", "description": "Ein schneller und tödlicher Geist.", "ability": "swift_strike"}, {"name": "Dämon", "type": "Geist", "power": 84, "rarity": "legendary", "description": "Ein aggressiver Geist, der häufig angreift.", "ability": "relentless"}, {"name": "Yurei", "type": "Geist", "power": 72, "rarity": "epic", "description": "Ein Geist, der die mentale Stärke seiner Opfer schwächt.", "ability": "sanity_drain"}, {"name": "Oni", "type": "Geist", "power": 76, "rarity": "epic", "description": "Ein starker Geist, der mehr aktiv ist, wenn Spieler in der Nähe sind.", "ability": None}, {"name": "Spirit", "type": "Geist", "power": 60, "rarity": "common", "description": "Ein gewöhnlicher Geist ohne besondere Fähigkeiten.", "ability": None}, {"name": "Jinn", "type": "Geist", "power": 68, "rarity": "rare", "description": "Ein territorialer Geist, der schneller wird, wenn sein Territorium bedroht ist.", "ability": "speed_boost"}, {"name": "Wraith", "type": "Geist", "power": 72, "rarity": "epic", "description": "Ein gefährlicher Geist, der durch Wände gehen kann.", "ability": "phase_through"}, {"name": "Yokai", "type": "Geist", "power": 64, "rarity": "rare", "description": "Ein Geist, der durch Lärm provoziert wird.", "ability": "sound_aggression"}, {"name": "Goryo", "type": "Geist", "power": 68, "rarity": "rare", "description": "Ein Geist, der selten seine Umgebung verlässt.", "ability": None}, {"name": "Hantu", "type": "Geist", "power": 72, "rarity": "epic", "description": "Ein Geist, der in kalten Umgebungen schneller wird.", "ability": "cold_speed"}, ]

    class DatabaseManager: def init(self, db_name='./database/game.db'): self.db_name = db_name self.conn = None self.cursor = None

    def connect(self): self.conn = sqlite3.connect(self.db_name) self.cursor = self.conn.cursor()

    def close(self): if self.conn: self.conn.commit() self.conn.close()

    def init_db(self): try: self.connect() self.cursor.execute(''' CREATE TABLE IF NOT EXISTS players ( id INTEGER PRIMARY KEY, user_id INTEGER UNIQUE, health INTEGER DEFAULT 200, coins INTEGER DEFAULT 0, xp INTEGER DEFAULT 0, level INTEGER DEFAULT 1, last_draw_time INTEGER DEFAULT 0, last_daily_bonus INTEGER DEFAULT 0, daily_bonus_count INTEGER DEFAULT 0, last_work_time INTEGER DEFAULT 0 ); ''')

        # Check for 'last_work_time' column and add if not exists
        columns = [col[1] for col in self.cursor.execute("PRAGMA table_info(players);")]
        if 'last_work_time' not in columns:
            self.cursor.execute("ALTER TABLE players ADD COLUMN last_work_time INTEGER DEFAULT 0;")
    
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS cards (
                id INTEGER PRIMARY KEY,
                name TEXT UNIQUE,
                type TEXT,
                power INTEGER,
                rarity TEXT,
                description TEXT,
                ability TEXT
            );
        ''')
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS player_cards (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                player_id INTEGER,
                card_id INTEGER,
                quantity INTEGER DEFAULT 1,
                FOREIGN KEY (player_id) REFERENCES players(id),
                FOREIGN KEY (card_id) REFERENCES cards(id)
            );
        ''')
    
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS ongoing_duels (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                challenger_id INTEGER,
                opponent_id INTEGER,
                challenger_health INTEGER,
                opponent_health INTEGER,
                turn_id INTEGER,
                thread_id INTEGER,
                duel_start_time INTEGER,
                challenger_shield INTEGER DEFAULT 0,
                opponent_shield INTEGER DEFAULT 0,
                challenger_block INTEGER DEFAULT 0,
                opponent_block INTEGER DEFAULT 0,
                challenger_frozen BOOLEAN DEFAULT FALSE,
                opponent_frozen BOOLEAN DEFAULT FALSE,
                challenger_curse INTEGER DEFAULT 0,
                opponent_curse INTEGER DEFAULT 0,
                challenger_silence INTEGER DEFAULT 0,
                opponent_silence INTEGER DEFAULT 0,
                challenger_fear INTEGER DEFAULT 0,
                opponent_fear INTEGER DEFAULT 0,
                challenger_marked INTEGER DEFAULT 0,
                opponent_marked INTEGER DEFAULT 0,
                challenger_dark_power INTEGER DEFAULT 0,
                opponent_dark_power INTEGER DEFAULT 0,
                challenger_speed_boost BOOLEAN DEFAULT FALSE,
                opponent_speed_boost BOOLEAN DEFAULT FALSE,
                challenger_phase_through BOOLEAN DEFAULT FALSE,
                opponent_phase_through BOOLEAN DEFAULT FALSE,
                challenger_sound_aggression INTEGER DEFAULT 0,
                opponent_sound_aggression INTEGER DEFAULT 0,
                challenger_cold_speed INTEGER DEFAULT 0,
                opponent_cold_speed INTEGER DEFAULT 0,
                challenger_relentless BOOLEAN DEFAULT FALSE,
                opponent_relentless BOOLEAN DEFAULT FALSE
            );
        ''')
    
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS achievements (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                name TEXT UNIQUE,
                description TEXT,
                condition TEXT
            );
        ''')
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS player_achievements (
                player_id INTEGER,
                achievement_id INTEGER,
                FOREIGN KEY (player_id) REFERENCES players(id),
                FOREIGN KEY (achievement_id) REFERENCES achievements(id)
            );
        ''')
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS daily_quests (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                player_id INTEGER,
                quest TEXT,
                progress INTEGER DEFAULT 0,
                completed INTEGER DEFAULT 0,
                FOREIGN KEY (player_id) REFERENCES players(id)
            );
        ''')
        self.close()
    except sqlite3.Error as e:
        print(f"Error initializing database: {e}")
    

    def add_cards_to_db(self): try: self.connect() for card in cards: self.cursor.execute( "INSERT OR IGNORE INTO cards (name, type, power, rarity, description, ability) VALUES (?, ?, ?, ?, ?, ?)", (card['name'], card['type'], card['power'], card['rarity'], card['description'], card['ability']) ) self.close() except sqlite3.Error as e: print(f"Error adding cards: {e}")

    def add_achievements_to_db(self): achievements = [ {"name": "Erstes Duell", "description": "Gewinne dein erstes Duell.", "condition": "win_duel"}, {"name": "Sammler", "description": "Sammle 50 Karten.", "condition": "collect_50_cards"}, {"name": "Level Meister", "description": "Erreiche Level 10.", "condition": "reach_level_10"}, {"name": "Täglicher Spieler", "description": "Erhalte deinen täglichen Bonus 7 Mal.", "condition": "daily_bonus_7_times"}, {"name": "Champion Duell", "description": "Gewinne 10 Duelle.", "condition": "win_10_duels"}, {"name": "Kartensammler", "description": "Sammle 100 Karten.", "condition": "collect_100_cards"}, {"name": "Level Guru", "description": "Erreiche Level 20.", "condition": "reach_level_20"}, {"name": "Daily Player Pro", "description": "Erhalte deinen täglichen Bonus 30 Mal.", "condition": "daily_bonus_30_times"}, {"name": "Elite Sammler", "description": "Sammle alle seltenen Karten.", "condition": "collect_all_rare_cards"}, ] try: self.connect() for achievement in achievements: self.cursor.execute( "INSERT OR IGNORE INTO achievements (name, description, condition) VALUES (?, ?, ?)", (achievement['name'], achievement['description'], achievement['condition']) ) self.close() except sqlite3.Error as e: print(f"Error adding achievements: {e}")

    def add_quests_to_db(self): # Optional: If you want to add permanent quests pass # Currently, quests are dynamically assigned

    def execute_with_connection(self, query, params=()): try: self.connect() self.cursor.execute(query, params) results = self.cursor.fetchall() self.close() return results except sqlite3.Error as e: print(f"Error executing query: {e}") return []

    def modify_with_connection(self, query, params=()): try: self.connect() self.cursor.execute(query, params) self.conn.commit() self.close() except sqlite3.Error as e: print(f"Error during database modification: {e}") class Halloween(commands.Cog): def init(self, bot): self.bot = bot self.db = DatabaseManager() self.db.init_db() self.db.add_cards_to_db() self.db.add_achievements_to_db() self.duels = {} self.trades = {} self.singleplayer_sessions = {} self.check_duel_timeout.start()

    Player Management

    def get_player(self, user_id): return self.db.execute_with_connection( "SELECT * FROM players WHERE user_id = ?", (user_id,) )

    def create_player(self, user_id): self.db.modify_with_connection( "INSERT INTO players (user_id) VALUES (?)", (user_id,) ) for _ in range(10): card = self.draw_random_card() self.add_card_to_player(user_id, card['name']) self.assign_daily_quest(user_id)

    def update_coins(self, user_id, amount): current_coins = self.fetch_player_coins(user_id) new_coins = current_coins + amount if new_coins < 0: new_coins = 0 self.db.modify_with_connection( "UPDATE players SET coins = ? WHERE user_id = ?", (new_coins, user_id) ) self.check_achievements(user_id)

    def update_xp(self, user_id, amount): self.db.modify_with_connection( "UPDATE players SET xp = xp + ? WHERE user_id = ?", (amount, user_id) ) player = self.get_player(user_id) if player: player = player[0] xp = player[4] level = player[5] xp_needed = level * 100 if xp >= xp_needed: self.db.modify_with_connection( "UPDATE players SET xp = xp - ?, level = level + 1 WHERE user_id = ?", (xp_needed, user_id) ) user = self.bot.get_user(user_id) if user: self.bot.loop.create_task( user.send(f"🎉 Glückwunsch! Du bist nun Level {level + 1}!") ) self.check_achievements(user_id)

    def update_last_draw_time(self, user_id, timestamp): self.db.modify_with_connection( "UPDATE players SET last_draw_time = ? WHERE user_id = ?", (timestamp, user_id) )

    def update_last_daily_bonus_time(self, user_id, timestamp): self.db.modify_with_connection( "UPDATE players SET last_daily_bonus = ?, daily_bonus_count = daily_bonus_count + 1 WHERE user_id = ?", (timestamp, user_id) )

    def update_last_work_time(self, user_id, timestamp): self.db.modify_with_connection( "UPDATE players SET last_work_time = ? WHERE user_id = ?", (timestamp, user_id) )

    def add_card_to_player(self, user_id, card_name): player = self.get_player(user_id) if player: card = self.db.execute_with_connection( "SELECT id FROM cards WHERE name = ?", (card_name,) ) if card: player_card = self.db.execute_with_connection( "SELECT quantity FROM player_cards WHERE player_id = ? AND card_id = ?", (player[0][0], card[0][0]) ) if player_card: self.db.modify_with_connection( "UPDATE player_cards SET quantity = quantity + 1 WHERE player_id = ? AND card_id = ?", (player[0][0], card[0][0]) ) else: card_count = self.db.execute_with_connection( "SELECT SUM(quantity) FROM player_cards WHERE player_id = ?", (player[0][0],) )[0][0] or 0

                if card_count < 100:  # Increased max card limit to 100
                    self.db.modify_with_connection(
                        "INSERT INTO player_cards (player_id, card_id, quantity) VALUES (?, ?, 1)",
                        (player[0][0], card[0][0])
                    )
                    self.check_achievements(user_id)
                    return True
                else:
                    return False
            self.check_achievements(user_id)
            return True
    return False
    

    def remove_card_from_player(self, user_id, card_name): player = self.get_player(user_id) if player: card = self.db.execute_with_connection( "SELECT id FROM cards WHERE name = ?", (card_name,) ) if card: player_card = self.db.execute_with_connection( "SELECT quantity FROM player_cards WHERE player_id = ? AND card_id = ?", (player[0][0], card[0][0]) ) if player_card: quantity = player_card[0][0] if quantity > 1: self.db.modify_with_connection( "UPDATE player_cards SET quantity = quantity - 1 WHERE player_id = ? AND card_id = ?", (player[0][0], card[0][0]) ) else: self.db.modify_with_connection( "DELETE FROM player_cards WHERE player_id = ? AND card_id = ?", (player[0][0], card[0][0]) ) return True return False

    def fetch_player_coins(self, user_id): result = self.db.execute_with_connection( "SELECT * FROM players WHERE user_id = ?", (user_id,) ) return result[0][3] if result else 0

    def get_player_cards(self, user_id): player = self.get_player(user_id) if player: player_id = player[0][0] return self.db.execute_with_connection( "SELECT c.name, c.type, c.power, c.rarity, c.description, pc.quantity, c.ability FROM player_cards pc JOIN cards c ON pc.card_id = c.id WHERE pc.player_id = ?", (player_id,) ) return []

    def draw_random_card(self): rarity_weight = {'common': 60, 'rare': 25, 'epic': 10, 'legendary': 5} rarity_choices = [rarity for rarity in rarity_weight for _ in range(rarity_weight[rarity])] chosen_rarity = random.choice(rarity_choices) cards_of_chosen_rarity = [card for card in cards if card['rarity'] == chosen_rarity] return random.choice(cards_of_chosen_rarity)

    def assign_daily_quest(self, user_id): player = self.get_player(user_id) if player: player_id = player[0][0] # Get the primary key from the players table quests = [ {"quest": "Gewinne 3 Duelle", "condition": "win_3_duels"}, {"quest": "Sammle 5 seltene Karten", "condition": "collect_5_rare_cards"}, {"quest": "Erreiche Level 5", "condition": "reach_level_5"}, {"quest": "Spiele 10 Karten", "condition": "play_10_cards"}, {"quest": "Gewinne 5 Duelle heute", "condition": "win_5_duels_today"}, {"quest": "Sammle 10 epische Karten", "condition": "collect_10_epic_cards"}, {"quest": "Erreiche Level 15", "condition": "reach_level_15"}, {"quest": "Spiele 20 Karten heute", "condition": "play_20_cards_today"} ] quest = random.choice(quests) self.db.modify_with_connection( "INSERT INTO daily_quests (player_id, quest) VALUES (?, ?)", (player_id, quest["quest"]) )

    def check_achievements(self, user_id): achievements = self.db.execute_with_connection( "SELECT id, condition FROM achievements" ) player = self.get_player(user_id) if player: player = player[0] player_id = player[0] level = player[5] daily_bonus_count = player[8] for ach_id, condition in achievements: already_unlocked = self.db.execute_with_connection( "SELECT * FROM player_achievements WHERE player_id = ? AND achievement_id = ?", (player_id, ach_id) ) if not already_unlocked: if condition == "win_duel": duels_won = self.db.execute_with_connection( "SELECT COUNT() FROM ongoing_duels WHERE challenger_id = ? OR opponent_id = ?", # Placeholder, implement properly (user_id, user_id) )[0][0] if duels_won >= 1: self.unlock_achievement(player_id, ach_id) elif condition == "collect_50_cards": total_cards = self.db.execute_with_connection( "SELECT SUM(quantity) FROM player_cards WHERE player_id = ?", (player_id,) )[0][0] if total_cards >= 50: self.unlock_achievement(player_id, ach_id) elif condition == "reach_level_10": if level >= 10: self.unlock_achievement(player_id, ach_id) elif condition == "daily_bonus_7_times": if daily_bonus_count >= 7: self.unlock_achievement(player_id, ach_id) elif condition == "win_10_duels": duels_won = self.db.execute_with_connection( "SELECT COUNT() FROM ongoing_duels WHERE challenger_id = ? OR opponent_id = ?", # Placeholder, implement properly (user_id, user_id) )[0][0] if duels_won >= 10: self.unlock_achievement(player_id, ach_id) elif condition == "collect_100_cards": total_cards = self.db.execute_with_connection( "SELECT SUM(quantity) FROM player_cards WHERE player_id = ?", (player_id,) )[0][0] if total_cards >= 100: self.unlock_achievement(player_id, ach_id) elif condition == "reach_level_20": if level >= 20: self.unlock_achievement(player_id, ach_id) elif condition == "daily_bonus_30_times": if daily_bonus_count >= 30: self.unlock_achievement(player_id, ach_id) elif condition == "collect_all_rare_cards": rare_card_names = [card['name'] for card in cards if card['rarity'] == 'rare'] player_cards = self.db.execute_with_connection( "SELECT c.name FROM player_cards pc JOIN cards c ON pc.card_id = c.id WHERE pc.player_id = ? AND c.rarity = 'rare'", (player_id,) ) player_rare_cards = set([card[0] for card in player_cards]) if set(rare_card_names).issubset(player_rare_cards): self.unlock_achievement(player_id, ach_id)

    def unlock_achievement(self, player_id, achievement_id): self.db.modify_with_connection( "INSERT INTO player_achievements (player_id, achievement_id) VALUES (?, ?)", (player_id, achievement_id) ) # Notify the player result = self.db.execute_with_connection("SELECT user_id FROM players WHERE id = ?", (player_id,)) if result: user_id = result[0][0] user = self.bot.get_user(user_id) achievement_name = self.db.execute_with_connection("SELECT name FROM achievements WHERE id = ?", (achievement_id,))[0][0] if user: self.bot.loop.create_task( user.send(f"🏆 Glückwunsch! Du hast das Achievement '{achievement_name}' freigeschaltet!") )

    Helper Function to Assign New Cards

    def assign_new_cards(self, user_id, num): drawn_cards = [] for _ in range(num): card = self.draw_random_card() success = self.add_card_to_player(user_id, card['name']) if success: drawn_cards.append(f"{card['name']} ({card['rarity']})") return drawn_cards

    Slash Commands

    @commands.slash_command(name="daily_bonus", description="Hole dir deine tägliche Belohnung ab.") async def daily_bonus(self, ctx): user_id = ctx.user.id player = self.get_player(user_id) if not player: self.create_player(user_id) player = self.get_player(user_id) last_bonus_time = player[0][7] current_time = int(time.time()) if current_time - last_bonus_time >= 86400: # 24 hours self.update_last_daily_bonus_time(user_id, current_time) self.update_coins(user_id, 100) # Give 100 coins as daily bonus self.check_achievements(user_id) await ctx.respond("🎁 Du hast deinen täglichen Bonus von 100 Münzen erhalten!", ephemeral=True) else: remaining_time = 86400 - (current_time - last_bonus_time) hours = remaining_time // 3600 minutes = (remaining_time % 3600) // 60 await ctx.respond(f"🕒 Du hast deinen täglichen Bonus bereits abgeholt. Versuche es in {hours} Stunden und {minutes} Minuten erneut.", ephemeral=True)

    @commands.slash_command(name="quest", description="Sieh dir deine tägliche Quest an.") async def quest(self, ctx): user_id = ctx.user.id player = self.get_player(user_id) if not player: self.create_player(user_id) player = self.get_player(user_id) # Re-fetch player after creation player_id = player[0][0] # Get the player's primary key ID quest = self.db.execute_with_connection( "SELECT quest, progress, completed FROM daily_quests WHERE player_id = ? AND completed = 0", (player_id,) ) if quest: quest_text, progress, completed = quest[0] status = "Abgeschlossen" if completed else f"Fortschritt: {progress}%" await ctx.respond(f"📝 Deine tägliche Quest: {quest_text}\nStatus: {status}", ephemeral=True) else: self.assign_daily_quest(user_id) # This now uses the correct player_id await ctx.respond("📝 Du hast eine neue tägliche Quest erhalten! Nutze /quest, um sie zu sehen.", ephemeral=True)

    @commands.slash_command(name="achievements", description="Zeige deine freigeschalteten Achievements an.") async def show_achievements(self, ctx): user_id = ctx.user.id player = self.get_player(user_id) if not player: self.create_player(user_id) player_id = player[0][0] achievements = self.db.execute_with_connection( "SELECT a.name, a.description FROM player_achievements pa JOIN achievements a ON pa.achievement_id = a.id WHERE pa.player_id = ?", (player_id,) ) if achievements: embed = discord.Embed(title="🏆 Deine Achievements", color=discord.Color.gold()) for name, description in achievements: embed.add_field(name=name, value=description, inline=False) await ctx.respond(embed=embed, ephemeral=True) else: await ctx.respond("Du hast noch keine Achievements freigeschaltet.", ephemeral=True)

    Duel Management

    @commands.slash_command(name="duel", description="Fordere einen anderen Spieler zu einem schaurigen Duell heraus.") async def duel(self, ctx, opponent: discord.Member): user_id = ctx.user.id opponent_id = opponent.id

    if user_id == opponent_id:
        await ctx.respond("Du kannst dich nicht selbst herausfordern!", ephemeral=True)
        return
    
    if not self.get_player(user_id):
        self.create_player(user_id)
    if not self.get_player(opponent_id):
        self.create_player(opponent_id)
    
    ongoing_duel = self.db.execute_with_connection(
        "SELECT * FROM ongoing_duels WHERE (challenger_id = ? AND opponent_id = ?) OR (challenger_id = ? AND opponent_id = ?)",
        (user_id, opponent_id, opponent_id, user_id)
    )
    if ongoing_duel:
        await ctx.respond("Es gibt bereits ein aktives Duell zwischen euch.", ephemeral=True)
        return
    
    thread = await ctx.channel.create_thread(
        name=f"Duel: {ctx.user.display_name} vs {opponent.display_name}",
        type=discord.ChannelType.private_thread
    )
    await thread.add_user(opponent)
    await thread.add_user(ctx.user)
    
    # Initialize Duel State
    duel_state = {
        "challenger_id": user_id,
        "opponent_id": opponent_id,
        "challenger_health": 200,
        "opponent_health": 200,
        "turn_id": user_id,
        "thread_id": thread.id,
        "duel_start_time": int(time.time()),
        "challenger_shield": 0,
        "opponent_shield": 0,
        "challenger_block": 0,
        "opponent_block": 0,
        "challenger_frozen": False,
        "opponent_frozen": False,
        "challenger_curse": 0,
        "opponent_curse": 0,
        "challenger_silence": 0,
        "opponent_silence": 0,
        "challenger_fear": 0,
        "opponent_fear": 0,
        "challenger_marked": 0,
        "opponent_marked": 0,
        "challenger_dark_power": 0,
        "opponent_dark_power": 0,
        "challenger_speed_boost": False,
        "opponent_speed_boost": False,
        "challenger_phase_through": False,
        "opponent_phase_through": False,
        "challenger_sound_aggression": 0,
        "opponent_sound_aggression": 0,
        "challenger_cold_speed": 0,
        "opponent_cold_speed": 0,
        "challenger_relentless": False,
        "opponent_relentless": False
    }
    
    self.duels[thread.id] = duel_state
    
    self.db.modify_with_connection(
        """INSERT INTO ongoing_duels 
        (challenger_id, opponent_id, challenger_health, opponent_health, turn_id, thread_id, duel_start_time,
        challenger_shield, opponent_shield, challenger_block, opponent_block,
        challenger_frozen, opponent_frozen, challenger_curse, opponent_curse,
        challenger_silence, opponent_silence, challenger_fear, opponent_fear,
        challenger_marked, opponent_marked, challenger_dark_power, opponent_dark_power,
        challenger_speed_boost, opponent_speed_boost, challenger_phase_through, opponent_phase_through,
        challenger_sound_aggression, opponent_sound_aggression, challenger_cold_speed, opponent_cold_speed,
        challenger_relentless, opponent_relentless) 
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
        (
            user_id, opponent_id, 200, 200, user_id, thread.id, int(time.time()),
            0, 0, 0, 0, False, False, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, False, False, False, False,
            0, 0, 0, 0, False, False
        )
    )
    
    await thread.send(
        f"🎃 Ein schauriges Duell zwischen {ctx.user.mention} und {opponent.mention} steht bevor! "
        f"{opponent.mention}, tippe `/accept` hier im Thread, um das Duell zu akzeptieren. Möge der Gruseligste gewinnen! 🎃"
    )
    
    await ctx.respond(f"Ein Thread für das Duell wurde erstellt: {thread.mention}", ephemeral=True)
    

    @tasks.loop(minutes=1) async def check_duel_timeout(self): current_time = int(time.time()) for thread_id in list(self.duels.keys()): duel = self.duels[thread_id] duel_start_time = duel.get("duel_start_time", int(time.time())) if current_time - duel_start_time >= 300: # 5 Minutes thread = self.bot.get_channel(thread_id) if thread: await thread.send("⏰ Das Duell ist abgelaufen, da es nicht rechtzeitig angenommen wurde.") await thread.delete() self.db.modify_with_connection( "DELETE FROM ongoing_duels WHERE thread_id = ?", (thread_id,) ) del self.duels[thread_id]

    @commands.slash_command(name="accept", description="Akzeptiere ein Duell und bereite dich vor!") async def accept_duel(self, ctx): thread = ctx.channel thread_id = thread.id

    if thread_id not in self.duels:
        await ctx.respond("Keine Duellanfrage für dich in diesem Thread gefunden.", ephemeral=True)
        return
    
    duel = self.duels[thread_id]
    
    await ctx.respond(
        f"Das Duell zwischen {self.bot.get_user(duel['challenger_id']).mention} und {ctx.user.mention} beginnt! "
        f"{self.bot.get_user(duel['challenger_id']).mention} ist zuerst an der Reihe. Nutze `/play`, um eine Karte zu spielen!",
        ephemeral=False
    )
    
    await thread.send(
        f"🎉 Das Duell hat begonnen! {self.bot.get_user(duel['challenger_id']).mention} ist an der Reihe.",
        silent=True
    )
    

    Card Selection View

    async def card_selection_view(self, ctx, player_cards, callback): options = [] for i, card in enumerate(player_cards): label = f"{card[0]} (x{card[5]}) [{card[3]}]" description = f"Typ: {card[1]}, Power: {card[2]}" options.append(discord.SelectOption(label=label, description=description, value=str(i)))

    dropdowns = []
    
    while options:
        options_chunk = options[:25]
        options = options[25:]
        dropdown = discord.ui.Select(
            options=options_chunk,
            placeholder="Wähle eine Karte",
            max_values=1
        )
        dropdown.callback = callback
        dropdowns.append(dropdown)
    
    view = discord.ui.View(timeout=60)
    for dropdown in dropdowns:
        view.add_item(dropdown)
    
    await ctx.respond("Wähle eine deiner Karten:", view=view, ephemeral=True)
    

    Play Card Command

    @commands.slash_command(name="play", description="Spiele eine deiner geisterhaften Karten.") async def play_card(self, ctx): user_id = ctx.user.id thread = ctx.channel thread_id = thread.id

    duel = self.duels.get(thread_id)
    if not duel:
        await ctx.respond("Du bist in keinem aktiven Duell in diesem Thread.", ephemeral=True)
        return
    
    if user_id != duel["turn_id"]:
        await ctx.respond("Es ist nicht dein Zug. Warte auf dein schauriges Schicksal!", ephemeral=True)
        return
    
    # Check for Frozen Effect
    if (user_id == duel["challenger_id"] and duel.get("challenger_frozen")) or \
       (user_id == duel["opponent_id"] and duel.get("opponent_frozen")):
        await ctx.respond("🔒 Du bist eingefroren und kannst deinen Zug nicht ausführen!", ephemeral=True)
        # Remove Frozen Effect and switch turn
        if user_id == duel["challenger_id"]:
            duel["challenger_frozen"] = False
            duel["turn_id"] = duel["opponent_id"]
        else:
            duel["opponent_frozen"] = False
            duel["turn_id"] = duel["challenger_id"]
        self.db.modify_with_connection(
            """
            UPDATE ongoing_duels SET 
            challenger_frozen = ?, opponent_frozen = ?, turn_id = ?
            WHERE thread_id = ?
            """,
            (
                duel["challenger_frozen"],
                duel["opponent_frozen"],
                duel["turn_id"],
                thread_id
            )
        )
        # Inform the next player
        next_player_id = duel["turn_id"]
        next_player = self.bot.get_user(next_player_id)
        await thread.send(f"🧛 {next_player.mention}, du bist nun an der Reihe! Nutze `/play`, um deine Karte zu spielen.")
        return
    
    # Check for Relentless Effect
    if (user_id == duel["challenger_id"] and duel.get("challenger_relentless")) or \
       (user_id == duel["opponent_id"] and duel.get("opponent_relentless")):
        # Player can continue fighting even if health <= 0
        pass
    
    # Check for Silence Effect
    if (user_id == duel["challenger_id"] and duel.get("challenger_silence", 0) > 0) or \
       (user_id == duel["opponent_id"] and duel.get("opponent_silence", 0) > 0):
        # Filter playable cards (only cards without abilities)
        playable_cards = [card for card in self.get_player_cards(user_id) if card[6] is None]
        if not playable_cards:
            await ctx.respond("🔇 Du bist verstummt und kannst keine Karten mit Fähigkeiten spielen.", ephemeral=True)
            return
        player_cards = playable_cards
    else:
        player_cards = self.get_player_cards(user_id)
    
    # If player has no cards, assign a common card
    if not player_cards:
        card = self.draw_random_card()
        self.add_card_to_player(user_id, card['name'])
        player_cards = self.get_player_cards(user_id)
        await thread.send(f"{ctx.user.mention} hat keine Karten mehr! Es wurde eine **{card['name']}** ({card['rarity']}) hinzugefügt.")
    
    if not player_cards:
        await ctx.respond("Keine Karten zum Spielen vorhanden.", ephemeral=True)
        return
    
    # Check for Speed Boost and Cold Speed
    extra_attacks = 0
    if user_id == duel["challenger_id"] and duel.get("challenger_speed_boost"):
        extra_attacks += 1
        duel["challenger_speed_boost"] = False
    elif user_id == duel["opponent_id"] and duel.get("opponent_speed_boost"):
        extra_attacks += 1
        duel["opponent_speed_boost"] = False
    
    if user_id == duel["challenger_id"] and duel.get("challenger_cold_speed", 0) > 0:
        extra_attacks += 1
        duel["challenger_cold_speed"] -= 1
    elif user_id == duel["opponent_id"] and duel.get("opponent_cold_speed", 0) > 0:
        extra_attacks += 1
        duel["opponent_cold_speed"] -= 1
    
    async def card_select_callback(interaction):
        selected_index = int(interaction.data['values'][0])
        selected_card = player_cards[selected_index]
        card_name = selected_card[0]
    
        # Remove the card from the player
        self.remove_card_from_player(user_id, card_name)
    
        # Apply card effects
        message = await self.apply_card_effects(duel, user_id, selected_card, interaction)
    
        # Change the turn
        if not extra_attacks:
            duel["turn_id"] = duel["opponent_id"] if duel["turn_id"] == duel["challenger_id"] else duel["challenger_id"]
    
        # Update the database
        self.db.modify_with_connection(
            """UPDATE ongoing_duels SET 
            challenger_health = ?, opponent_health = ?, turn_id = ?, 
            challenger_shield = ?, opponent_shield = ?, 
            challenger_block = ?, opponent_block = ?, 
            challenger_frozen = ?, opponent_frozen = ?, 
            challenger_curse = ?, opponent_curse = ?, 
            challenger_silence = ?, opponent_silence = ?, 
            challenger_fear = ?, opponent_fear = ?, 
            challenger_marked = ?, opponent_marked = ?, 
            challenger_dark_power = ?, opponent_dark_power = ?, 
            challenger_speed_boost = ?, opponent_speed_boost = ?, 
            challenger_phase_through = ?, opponent_phase_through = ?, 
            challenger_sound_aggression = ?, opponent_sound_aggression = ?, 
            challenger_cold_speed = ?, opponent_cold_speed = ?, 
            challenger_relentless = ?, opponent_relentless = ?
            WHERE thread_id = ?""",
            (
                duel["challenger_health"],
                duel["opponent_health"],
                duel["turn_id"],
                duel.get("challenger_shield", 0),
                duel.get("opponent_shield", 0),
                duel.get("challenger_block", 0),
                duel.get("opponent_block", 0),
                duel.get("challenger_frozen", False),
                duel.get("opponent_frozen", False),
                duel.get("challenger_curse", 0),
                duel.get("opponent_curse", 0),
                duel.get("challenger_silence", 0),
                duel.get("opponent_silence", 0),
                duel.get("challenger_fear", 0),
                duel.get("opponent_fear", 0),
                duel.get("challenger_marked", 0),
                duel.get("opponent_marked", 0),
                duel.get("challenger_dark_power", 0),
                duel.get("opponent_dark_power", 0),
                duel.get("challenger_speed_boost", False),
                duel.get("opponent_speed_boost", False),
                duel.get("challenger_phase_through", False),
                duel.get("opponent_phase_through", False),
                duel.get("challenger_sound_aggression", 0),
                duel.get("opponent_sound_aggression", 0),
                duel.get("challenger_cold_speed", 0),
                duel.get("opponent_cold_speed", 0),
                duel.get("challenger_relentless", False),
                duel.get("opponent_relentless", False),
                thread_id
            )
        )
    
        await interaction.response.send_message(
            f"{message}\n\nBeschreibung: {selected_card[4]}",
            ephemeral=False
        )
    
        # Check for Duel End
        if duel["opponent_health"] <= 0 or duel["challenger_health"] <= 0:
            if duel["opponent_health"] <= 0 and not duel.get("challenger_relentless", False):
                winner_id = duel["challenger_id"]
                loser_id = duel["opponent_id"]
            elif duel["challenger_health"] <= 0 and not duel.get("opponent_relentless", False):
                winner_id = duel["opponent_id"]
                loser_id = duel["challenger_id"]
            else:
                # Relentless prevents losing
                await interaction.followup.send("💪 Relentless verhindert das Verlieren! Das Duell geht weiter.", ephemeral=False)
                # Inform the next player
                next_player_id = duel["turn_id"]
                next_player = self.bot.get_user(next_player_id)
                await thread.send(f"🧛 {next_player.mention}, du bist nun an der Reihe! Nutze `/play`, um deine Karte zu spielen.")
                return
    
            winner = self.bot.get_user(winner_id)
            loser = self.bot.get_user(loser_id)
    
            # Coin Transfer
            loser_coins = self.fetch_player_coins(loser_id)
            coin_loss = min(10, loser_coins)  # Loser loses up to 10 coins
            self.update_coins(loser_id, -coin_loss)
            self.update_coins(winner_id, 25 + coin_loss)  # Winner gains 25 coins plus the lost coins
    
            # Update XP
            self.update_xp(winner_id, 50)
    
            # Assign 1-5 new cards to the winner
            num_new_cards = random.randint(1, 5)
            new_cards = self.assign_new_cards(winner_id, num_new_cards)
            if new_cards:
                new_cards_text = ", ".join(new_cards)
                await interaction.followup.send(
                    f"🎉 Glückwunsch {winner.mention}! Du hast das gruselige Duell gegen {loser.mention} gewonnen, erhältst 25 Münzen und 50 XP! Außerdem nimmst du {coin_loss} Münzen von {loser.mention}! Zusätzlich hast du {num_new_cards} neue Karte(n) erhalten: {new_cards_text} 🎃",
                    ephemeral=False
                )
            else:
                await interaction.followup.send(
                    f"🎉 Glückwunsch {winner.mention}! Du hast das gruselige Duell gegen {loser.mention} gewonnen, erhältst 25 Münzen und 50 XP! Außerdem nimmst du {coin_loss} Münzen von {loser.mention}! 🎃",
                    ephemeral=False
                )
    
            # End the Duel
            self.db.modify_with_connection(
                "DELETE FROM ongoing_duels WHERE thread_id = ?",
                (thread_id,)
            )
            del self.duels[thread_id]
    
            # Delete the Thread
            thread_obj = self.bot.get_channel(thread_id)
            if thread_obj:
                await asyncio.sleep(5)
                await thread_obj.delete()
            return
    
        # Extra Attack Handling
        if extra_attacks:
            message = f"{self.bot.get_user(duel['turn_id']).mention}, du hast einen zusätzlichen Angriff!\n\n" \
                      f"🎃 **Aktueller Stand:**\n" \
                      f"{self.bot.get_user(duel['challenger_id']).mention}: {duel['challenger_health']} HP\n" \
                      f"{self.bot.get_user(duel['opponent_id']).mention}: {duel['opponent_health']} HP"
            await interaction.followup.send(message, ephemeral=False)
    
        # Status Update
        status_embed = discord.Embed(title="🧛 **Aktueller Stand des Duells** 🧛", color=discord.Color.dark_purple())
        challenger = self.bot.get_user(duel['challenger_id'])
        opponent = self.bot.get_user(duel['opponent_id'])
        status_embed.add_field(name=f"{challenger.display_name}", value=f"HP: {duel['challenger_health']}", inline=True)
        status_embed.add_field(name=f"{opponent.display_name}", value=f"HP: {duel['opponent_health']}", inline=True)
        await interaction.channel.send(embed=status_embed)
    
        # Inform the next player
        next_player_id = duel["turn_id"]
        next_player = self.bot.get_user(next_player_id)
        await interaction.channel.send(f"🧛 {next_player.mention}, du bist nun an der Reihe! Nutze `/play`, um deine Karte zu spielen.")
    
    # Implementing Card Effects
    async def apply_card_effects(self, duel, user_id, card, interaction):
        card_name = card[0]
        card_power = card[2]
        card_type = card[1]
        card_description = card[4]
        ability = card[6]
    
        opponent_id = duel["opponent_id"] if user_id == duel["challenger_id"] else duel["challenger_id"]
        opponent = self.bot.get_user(opponent_id)
    
        # Mapping abilities to handler functions
        ability_handlers = {
            "lifesteal": self.handle_lifesteal,
            "shield": self.handle_shield,
            "block": self.handle_block,
            "ignore_defense": self.handle_ignore_defense,
            "burn": self.handle_burn,
            "revive": self.handle_revive,
            "curse": self.handle_curse,
            "shadow_strike": self.handle_shadow_strike,
            "frost_nova": self.handle_frost_nova,
            "mana_burn": self.handle_mana_burn,
            "fear": self.handle_fear,
            "silence": self.handle_silence,
            "summon": self.handle_summon,
            "drain_soul": self.handle_drain_soul,
            "throw_objects": self.handle_throw_objects,
            "hide_presence": self.handle_hide_presence,
            "mark_target": self.handle_mark_target,
            "dark_power": self.handle_dark_power,
            "swift_strike": self.handle_swift_strike,
            "relentless": self.handle_relentless,
            "sanity_drain": self.handle_sanity_drain,
            "speed_boost": self.handle_speed_boost,
            "phase_through": self.handle_phase_through,
            "sound_aggression": self.handle_sound_aggression,
            "cold_speed": self.handle_cold_speed
        }
    
        message = ""
    
        if ability in ability_handlers:
            handler = ability_handlers[ability]
            message = await handler(duel, user_id, card_power, interaction, card_name, opponent)
        else:
            # Standard attack or healing
            if card_type == "Heilung":
                if user_id == duel["challenger_id"]:
                    duel["challenger_health"] += card_power
                else:
                    duel["opponent_health"] += card_power
                message = f"{interaction.user.mention} spielt **{card_name}** und heilt sich um {card_power} Punkte!"
            else:
                damage = card_power
    
                # Check for Curse Effect
                if user_id == duel["challenger_id"] and duel.get("challenger_curse", 0) > 0:
                    damage -= duel["challenger_curse"]
                    duel["challenger_curse"] = max(0, duel["challenger_curse"] - 1)
                elif user_id == duel["opponent_id"] and duel.get("opponent_curse", 0) > 0:
                    damage -= duel["opponent_curse"]
                    duel["opponent_curse"] = max(0, duel["opponent_curse"] - 1)
    
                # Check for Phase Through Effect
                if user_id == duel["challenger_id"] and duel.get("challenger_phase_through", False):
                    damage = card_power  # Ignore shield and block
                    duel["challenger_phase_through"] = False
                    message += f"\n✅ **Phase Through** aktiviert! Der Angriff ignoriert die Verteidigung."
                elif user_id == duel["opponent_id"] and duel.get("opponent_phase_through", False):
                    damage = card_power
                    duel["opponent_phase_through"] = False
                    message += f"\n✅ **Phase Through** aktiviert! Der Angriff ignoriert die Verteidigung."
    
                # Apply Damage Reductions and Protections
                if user_id == duel["challenger_id"]:
                    if duel.get("opponent_block", 0):
                        duel["opponent_block"] = 0
                        message = f"{opponent.mention} hat den Angriff mit einem Block abgewehrt!"
                    else:
                        if duel.get("opponent_shield", 0) > 0:
                            shield = duel["opponent_shield"]
                            if damage >= shield:
                                damage -= shield
                                duel["opponent_shield"] = 0
                            else:
                                duel["opponent_shield"] -= damage
                                damage = 0
                        if duel.get("opponent_sound_aggression", 0) > 0:
                            damage -= duel["opponent_sound_aggression"]
                            duel["opponent_sound_aggression"] = 0
                        if duel.get("opponent_marked", 0) > 0:
                            damage += 8  # Adjusted for reduced overall damage
                            duel["opponent_marked"] = 0
                        if getattr(duel, "opponent_hide", False):
                            damage = max(0, damage - 8)  # Reduce damage by 8 if opponent is hiding
                            duel["opponent_hide"] = False
                        duel["opponent_health"] -= damage
                        message = f"{interaction.user.mention} spielt **{card_name}** und fügt {opponent.mention} {damage} Schaden zu!"
                else:
                    if duel.get("challenger_block", 0):
                        duel["challenger_block"] = 0
                        message = f"{opponent.mention} hat den Angriff mit einem Block abgewehrt!"
                    else:
                        if duel.get("challenger_shield", 0) > 0:
                            shield = duel["challenger_shield"]
                            if damage >= shield:
                                damage -= shield
                                duel["challenger_shield"] = 0
                            else:
                                duel["challenger_shield"] -= damage
                                damage = 0
                        if duel.get("challenger_sound_aggression", 0) > 0:
                            damage -= duel["challenger_sound_aggression"]
                            duel["challenger_sound_aggression"] = 0
                        if duel.get("challenger_marked", 0) > 0:
                            damage += 8
                            duel["challenger_marked"] = 0
                        if duel.get("challenger_hide", False):
                            damage = max(0, damage - 8)
                            duel["challenger_hide"] = False
                        duel["challenger_health"] -= damage
                        message = f"{interaction.user.mention} spielt **{card_name}** und fügt {opponent.mention} {damage} Schaden zu!"
    
        # Additional Effects Checks
    
        # Burn Effect
        if user_id == duel["challenger_id"] and duel.get("opponent_burn_turns", 0) > 0:
            burn_damage = duel["opponent_burn"]
            duel["opponent_health"] -= burn_damage
            duel["opponent_burn_turns"] -= 1
            message += f"\n🔥 {opponent.mention} erleidet {burn_damage} Verbrennungsschaden!"
        elif user_id == duel["opponent_id"] and duel.get("challenger_burn_turns", 0) > 0:
            burn_damage = duel["challenger_burn"]
            duel["challenger_health"] -= burn_damage
            duel["challenger_burn_turns"] -= 1
            message += f"\n🔥 {opponent.mention} erleidet {burn_damage} Verbrennungsschaden!"
    
        # Frozen Effects
        if user_id == duel["challenger_id"] and duel.get("opponent_frozen", False):
            duel["opponent_frozen"] = False
            duel["turn_id"] = user_id  # Player gets another turn
            message += f"\n❄️ {opponent.mention} ist eingefroren und kann nicht handeln!"
        elif user_id == duel["opponent_id"] and duel.get("challenger_frozen", False):
            duel["challenger_frozen"] = False
            duel["turn_id"] = user_id  # Player gets another turn
            message += f"\n❄️ {opponent.mention} ist eingefroren und kann nicht handeln!"
    
        # Fear Effects
        if user_id == duel["challenger_id"] and duel.get("opponent_fear", 0) > 0:
            duel["opponent_fear"] -= 1
            if duel["opponent_fear"] == 0:
                message += f"\n😨 {opponent.mention} überwindet seine Angst und kann wieder handeln!"
        elif user_id == duel["opponent_id"] and duel.get("challenger_fear", 0) > 0:
            duel["challenger_fear"] -= 1
            if duel["challenger_fear"] == 0:
                message += f"\n😨 {opponent.mention} überwindet seine Angst und kann wieder handeln!"
    
        # Silence Effects
        if user_id == duel["challenger_id"] and duel.get("opponent_silence", 0) > 0:
            duel["opponent_silence"] -= 1
            if duel["opponent_silence"] == 0:
                message += f"\n🔇 {opponent.mention} kann wieder Fähigkeiten nutzen!"
        elif user_id == duel["opponent_id"] and duel.get("challenger_silence", 0) > 0:
            duel["challenger_silence"] -= 1
            if duel["challenger_silence"] == 0:
                message += f"\n🔇 {opponent.mention} kann wieder Fähigkeiten nutzen!"
    
        # Dark Power Effects
        if user_id == duel["challenger_id"] and duel.get("challenger_dark_power", 0) > 0:
            card_power += 16  # Adjusted from +20 to +16 for 20% reduction
            duel["challenger_dark_power"] -= 1
            message += f"\n🌑 Dunkle Macht ist aktiviert! Deine Angriffskraft ist erhöht um 16 für diesen Zug."
        elif user_id == duel["opponent_id"] and duel.get("opponent_dark_power", 0) > 0:
            card_power += 16
            duel["opponent_dark_power"] -= 1
            message += f"\n🌑 Dunkle Macht ist aktiviert! Deine Angriffskraft ist erhöht um 16 für diesen Zug."
    
        return message
    

    Ability Handlers

    async def handle_lifesteal(self, duel, user_id, card_power, interaction, card_name, opponent): damage = card_power if user_id == duel["challenger_id"]: duel["opponent_health"] -= damage duel["challenger_health"] += damage // 2 else: duel["challenger_health"] -= damage duel["opponent_health"] += damage // 2 message = f"{interaction.user.mention} spielt {card_name} und stiehlt {damage // 2} Gesundheit!" return message

    async def handle_shield(self, duel, user_id, card_power, interaction, card_name, opponent): if user_id == duel["challenger_id"]: duel["challenger_shield"] += card_power else: duel["opponent_shield"] += card_power message = f"{interaction.user.mention} spielt {card_name} und erhält einen Schild von {card_power}!" return message

    async def handle_block(self, duel, user_id, card_power, interaction, card_name, opponent): if user_id == duel["challenger_id"]: duel["challenger_block"] = 1 else: duel["opponent_block"] = 1 message = f"{interaction.user.mention} spielt {card_name} und blockiert den nächsten Angriff!" return message

    async def handle_ignore_defense(self, duel, user_id, card_power, interaction, card_name, opponent): damage = card_power if user_id == duel["challenger_id"]: duel["opponent_health"] -= damage else: duel["challenger_health"] -= damage message = f"{interaction.user.mention} spielt {card_name} und ignoriert alle Verteidigung, fügt {damage} Schaden zu!" return message

    async def handle_burn(self, duel, user_id, card_power, interaction, card_name, opponent): damage = card_power burn_amount = 15 # Reduced from 20 to 15 burn_turns = 2 if user_id == duel["challenger_id"]: duel["opponent_health"] -= damage duel["opponent_burn"] = burn_amount duel["opponent_burn_turns"] = burn_turns else: duel["challenger_health"] -= damage duel["challenger_burn"] = burn_amount duel["challenger_burn_turns"] = burn_turns message = f"{interaction.user.mention} spielt {card_name} und verbrennt den Gegner, fügt {damage} Schaden zu!" return message

    async def handle_revive(self, duel, user_id, card_power, interaction, card_name, opponent): heal_amount = 40 # Reduced from 50 to 40 if user_id == duel["challenger_id"]: duel["challenger_health"] += heal_amount else: duel["opponent_health"] += heal_amount message = f"{interaction.user.mention} spielt {card_name} und belebt sich selbst, erhält {heal_amount} Gesundheit zurück!" return message

    async def handle_curse(self, duel, user_id, card_power, interaction, card_name, opponent): curse_amount = 16 # Reduced from 20 to 16 curse_turns = 2 if user_id == duel["challenger_id"]: duel["opponent_curse"] = curse_amount duel["opponent_curse_turns"] = curse_turns else: duel["challenger_curse"] = curse_amount duel["challenger_curse_turns"] = curse_turns message = f"{interaction.user.mention} spielt {card_name} und verflucht den Gegner!" return message

    async def handle_shadow_strike(self, duel, user_id, card_power, interaction, card_name, opponent): total_damage = card_power * 2 if user_id == duel["challenger_id"]: duel["opponent_health"] -= total_damage else: duel["challenger_health"] -= total_damage message = f"{interaction.user.mention} spielt {card_name} und schlägt zweimal zu, fügt insgesamt {total_damage} Schaden zu!" return message

    async def handle_frost_nova(self, duel, user_id, card_power, interaction, card_name, opponent): if user_id == duel["challenger_id"]: duel["opponent_frozen"] = True else: duel["challenger_frozen"] = True message = f"{interaction.user.mention} spielt {card_name} und friert den Gegner ein!" return message

    async def handle_mana_burn(self, duel, user_id, card_power, interaction, card_name, opponent): opponent_id = duel["opponent_id"] if user_id == duel["challenger_id"] else duel["challenger_id"] opponent_cards = self.get_player_cards(opponent_id) if opponent_cards: random_card = random.choice(opponent_cards) self.remove_card_from_player(opponent_id, random_card[0]) message = f"{interaction.user.mention} spielt {card_name} und verbrennt die Karte {random_card[0]} des Gegners!" else: message = f"{interaction.user.mention} spielt {card_name}, aber der Gegner hat keine Karten mehr!" return message

    async def handle_fear(self, duel, user_id, card_power, interaction, card_name, opponent): if user_id == duel["challenger_id"]: duel["opponent_fear"] = 1 # Opponent skips next turn else: duel["challenger_fear"] = 1 message = f"{interaction.user.mention} spielt {card_name} und verursacht Angst beim Gegner! Der Gegner überspringt seinen nächsten Zug." return message

    async def handle_silence(self, duel, user_id, card_power, interaction, card_name, opponent): if user_id == duel["challenger_id"]: duel["opponent_silence"] = 2 # Opponent cannot use abilities for 2 turns else: duel["challenger_silence"] = 2 message = f"{interaction.user.mention} spielt {card_name} und verstummt den Gegner! Der Gegner kann für die nächsten 2 Züge keine Fähigkeiten nutzen." return message

    async def handle_summon(self, duel, user_id, card_power, interaction, card_name, opponent): summon_health = 80 # Reduced from 100 to 80 if user_id == duel["challenger_id"]: duel["challenger_health"] += summon_health else: duel["opponent_health"] += summon_health message = f"{interaction.user.mention} spielt {card_name} und beschwört einen zusätzlichen Geist, der dem Spieler {summon_health} Gesundheit verleiht!" return message

    async def handle_drain_soul(self, duel, user_id, card_power, interaction, card_name, opponent): damage = card_power if user_id == duel["challenger_id"]: duel["opponent_health"] -= damage duel["challenger_health"] += damage else: duel["challenger_health"] -= damage duel["opponent_health"] += damage message = f"{interaction.user.mention} spielt {card_name} und saugt {damage} Gesundheit vom Gegner!" return message

    async def handle_throw_objects(self, duel, user_id, card_power, interaction, card_name, opponent): damage = card_power + 8 # Adjusted from +10 to +8 if user_id == duel["challenger_id"]: duel["opponent_health"] -= damage else: duel["challenger_health"] -= damage message = f"{interaction.user.mention} spielt {card_name} und wirft Objekte, fügt {damage} Schaden zu!" return message

    async def handle_hide_presence(self, duel, user_id, card_power, interaction, card_name, opponent): if user_id == duel["challenger_id"]: duel["challenger_hide"] = True else: duel["opponent_hide"] = True message = f"{interaction.user.mention} spielt {card_name} und verbirgt ihre Präsenz, wodurch der Gegner weniger Schaden verursacht!" return message

    async def handle_mark_target(self, duel, user_id, card_power, interaction, card_name, opponent): if user_id == duel["challenger_id"]: duel["opponent_marked"] = 1 else: duel["challenger_marked"] = 1 message = f"{interaction.user.mention} spielt {card_name} und markiert den Gegner! Der markierte Gegner erleidet mehr Schaden in den nächsten Zügen." return message

    async def handle_dark_power(self, duel, user_id, card_power, interaction, card_name, opponent): if user_id == duel["challenger_id"]: duel["challenger_dark_power"] = 2 # Increase attack power for 2 turns else: duel["opponent_dark_power"] = 2 message = f"{interaction.user.mention} spielt {card_name} und aktiviert dunkle Macht! Die Angriffskraft wird für die nächsten 2 Züge erhöht." return message

    async def handle_swift_strike(self, duel, user_id, card_power, interaction, card_name, opponent): if user_id == duel["challenger_id"]: duel["challenger_speed_boost"] = True else: duel["opponent_speed_boost"] = True message = f"{interaction.user.mention} spielt {card_name} und führt einen schnellen Schlag aus, ermöglicht einen sofortigen zusätzlichen Zug!" return message

    async def handle_relentless(self, duel, user_id, card_power, interaction, card_name, opponent): if user_id == duel["challenger_id"]: duel["challenger_relentless"] = True else: duel["opponent_relentless"] = True message = f"{interaction.user.mention} spielt {card_name} und bleibt unermüdlich! Selbst wenn die Gesundheit unter 0 fällt, kannst du weiterkämpfen." return message

    async def handle_sanity_drain(self, duel, user_id, card_power, interaction, card_name, opponent): if user_id == duel["challenger_id"]: duel["opponent_sanity_drain"] = 16 # Reduced from 20 to 16 else: duel["challenger_sanity_drain"] = 16 message = f"{interaction.user.mention} spielt {card_name} und entzieht dem Gegner geistige Stärke! Der Gegner verursacht weniger Schaden." return message

    async def handle_speed_boost(self, duel, user_id, card_power, interaction, card_name, opponent): if user_id == duel["challenger_id"]: duel["challenger_speed_boost"] = True else: duel["opponent_speed_boost"] = True message = f"{interaction.user.mention} spielt {card_name} und erhöht die Geschwindigkeit! Du bist im nächsten Zug schneller dran." return message

    async def handle_phase_through(self, duel, user_id, card_power, interaction, card_name, opponent): if user_id == duel["challenger_id"]: duel["challenger_phase_through"] = True else: duel["opponent_phase_through"] = True message = f"{interaction.user.mention} spielt {card_name} und durchdringt die Verteidigung des Gegners, fügt sofort Schaden zu!" return message

    async def handle_sound_aggression(self, duel, user_id, card_power, interaction, card_name, opponent): aggression_amount = 8 # Reduced from 10 to 8 if user_id == duel["challenger_id"]: duel["opponent_sound_aggression"] = aggression_amount # Reduces next damage by 8 else: duel["challenger_sound_aggression"] = aggression_amount message = f"{interaction.user.mention} spielt {card_name} und agitert den Gegner durch Lärm! Der nächste Schaden des Gegners wird um {aggression_amount} reduziert." return message

    async def handle_cold_speed(self, duel, user_id, card_power, interaction, card_name, opponent): cold_speed_turns = 2 if user_id == duel["challenger_id"]: duel["challenger_cold_speed"] = cold_speed_turns else: duel["opponent_cold_speed"] = cold_speed_turns message = f"{interaction.user.mention} spielt {card_name} und aktiviert kalte Geschwindigkeit! Du darfst die nächsten {cold_speed_turns} Züge schneller angreifen." return message

    @commands.slash_command(name="singleplayer", description="Tritt gegen ein gespenstisches Wesen im Einzelspielermodus an!") async def singleplayer_duel(self, ctx): user_id = ctx.user.id

    if not self.get_player(user_id):
        self.create_player(user_id)
    
    ai_health = 200
    player_health = 200
    
    # Create a thread for the singleplayer duel
    thread_name = f"Singleplayer-Duell von {ctx.user.display_name}"
    thread = await ctx.channel.create_thread(name=thread_name, type=discord.ChannelType.public_thread)
    
    self.singleplayer_sessions[user_id] = {
        "player_health": player_health,
        "ai_health": ai_health,
        "turn": user_id,
        "thread_id": thread.id,
        "start_time": int(time.time()),
        "ai_cooldowns": {},  # For future extensions
        "ai_status_effects": {}
    }
    
    await thread.send(
        f"👻 Das gespenstische Wesen fordert dich heraus, {ctx.user.mention}!\n"
        "Möge der Mutigste gewinnen! Nutze `/sp_play`, um zu beginnen."
    )
    
    await ctx.respond(f"Ein Thread wurde erstellt für dein Duell: {thread.mention}", ephemeral=True)
    

    @commands.slash_command(name="sp_play", description="Spiele eine Karte gegen das gespenstische Wesen.") async def singleplayer_play(self, ctx): user_id = ctx.user.id session = self.singleplayer_sessions.get(user_id)

    if not session:
        await ctx.respond("Du bist in keinem Einzelspieler-Duellt. Nutze `/singleplayer`, um ein neues Duell zu starten.", ephemeral=True)
        return
    
    # Check if the command is used in the correct thread
    if ctx.channel.id != session["thread_id"]:
        await ctx.respond("Bitte nutze diesen Befehl im Thread deines Einzelspieler-Duells.", ephemeral=True)
        return
    
    player_cards = self.get_player_cards(user_id)
    if not player_cards:
        # Assign a card if player has none
        card = self.draw_random_card()
        self.add_card_to_player(user_id, card['name'])
        player_cards = self.get_player_cards(user_id)
        await ctx.channel.send(f"{ctx.user.mention} hat keine Karten mehr! Es wurde eine **{card['name']}** ({card['rarity']}) hinzugefügt.")
    
    if not player_cards:
        await ctx.respond("Du hast keine Karten mehr zum Spielen!", ephemeral=True)
        del self.singleplayer_sessions[user_id]
        return
    
    if session["ai_health"] <= 0 or session["player_health"] <= 0:
        await ctx.respond("Das Duell ist bereits beendet.", ephemeral=True)
        return
    
    async def card_select_callback(interaction):
        selected_index = int(interaction.data['values'][0])
        selected_card = player_cards[selected_index]
        card_name = selected_card[0]
        card_power = selected_card[2]
        card_type = selected_card[1]
        card_description = selected_card[4]
    
        self.remove_card_from_player(user_id, card_name)
    
        # Apply card effects
        if card_type == "Heilung":
            session["player_health"] += card_power
            message = f"{interaction.user.mention} spielt **{card_name}** und heilt sich um {card_power} Punkte!"
        else:
            session["ai_health"] -= card_power
            message = f"{interaction.user.mention} spielt **{card_name}** und fügt dem gespenstischen Wesen {card_power} Schaden zu!"
    
        await interaction.response.send_message(
            f"{message}\n\nBeschreibung: {card_description}",
            ephemeral=False
        )
    
        if session["ai_health"] <= 0:
            num_new_cards = random.randint(1, 5)
            new_cards = self.assign_new_cards(user_id, num_new_cards)
            if new_cards:
                new_cards_text = ", ".join(new_cards)
                await interaction.followup.send(
                    f"🎉 Glückwunsch {interaction.user.mention}! Du hast das gespenstische Duell gewonnen und erhältst 25 Münzen und 50 XP! Außerdem hast du {num_new_cards} neue Karte(n) erhalten: {new_cards_text} 🎃",
                    ephemeral=False
                )
            else:
                await interaction.followup.send(
                    f"🎉 Glückwunsch {interaction.user.mention}! Du hast das gespenstische Duell gewonnen und erhältst 25 Münzen und 50 XP! 🎃",
                    ephemeral=False
                )
            self.update_coins(user_id, 25)
            self.update_xp(user_id, 50)
            del self.singleplayer_sessions[user_id]
            # Delete the thread
            thread = self.bot.get_channel(session["thread_id"])
            if thread:
                await asyncio.sleep(5)
                await thread.delete()
            return
    
        # AI Turn
        ai_card = self.select_ai_card(session)
        if ai_card["type"] == "Heilung":
            session["ai_health"] += ai_card['power']
            ai_message = f"👻 Das gespenstische Wesen spielt **{ai_card['name']}** und heilt sich um {ai_card['power']} Punkte!"
        else:
            session["player_health"] -= ai_card['power']
            ai_message = f"👻 Das gespenstische Wesen spielt **{ai_card['name']}** und fügt dir {ai_card['power']} Schaden zu!"
    
        await interaction.followup.send(
            f"{ai_message}\n\nBeschreibung: {ai_card['description']}",
            ephemeral=False
        )
    
        if session["player_health"] <= 0:
            await interaction.followup.send("💀 Du wurdest vom gespenstischen Wesen besiegt!", ephemeral=False)
            del self.singleplayer_sessions[user_id]
            # Delete the thread
            thread = self.bot.get_channel(session["thread_id"])
            if thread:
                await asyncio.sleep(5)
                await thread.delete()
            return
    
        await interaction.followup.send(
            f"🧟 Deine Gesundheit: {session['player_health']} | Gesundheit des Wesens: {session['ai_health']}\n"
            "Nutze `/sp_play`, um deine nächste Karte zu spielen.",
            ephemeral=False
        )
    
    await self.card_selection_view(ctx, player_cards, card_select_callback)
    

    def select_ai_card(self, session): # Enhanced AI: Strategy based on current health ai_health = session["ai_health"] player_health = session["player_health"]

    ai_cards = self.get_player_cards(user_id=None)  # All cards available for AI
    # AI can use any card
    available_ai_cards = [card for card in cards if True]
    
    # Prioritize healing if AI health is low
    if ai_health < 100:
        heal_cards = [card for card in available_ai_cards if card['type'] == 'Heilung']
        if heal_cards:
            return random.choice(heal_cards)
    
    # Otherwise, choose the strongest available attack card
    attack_cards = [card for card in available_ai_cards if card['type'] != 'Heilung']
    if attack_cards:
        strongest_card = max(attack_cards, key=lambda x: x['power'])
        return strongest_card
    
    # Fallback: Play a random card
    return random.choice(available_ai_cards) if available_ai_cards else {"name": "Keine Karte", "type": "Geist", "power": 0, "rarity": "common", "description": "Keine verfügbaren Karten.", "ability": None}
    

    @commands.slash_command(name="profile", description="Zeige dein schauriges Spielerprofil an.") async def profile(self, ctx, member: discord.Member = None): if member is None: member = ctx.user

    user_id = member.id
    player = self.get_player(user_id)
    if not player:
        await ctx.respond("Dieser Spieler hat noch kein Profil.", ephemeral=True)
        return
    
    coins = player[0][3]
    xp = player[0][4]
    level = player[0][5]
    card_count = self.db.execute_with_connection(
        "SELECT COUNT(*) FROM player_cards WHERE player_id = ?",
        (player[0][0],)
    )[0][0]
    
    profile_embed = discord.Embed(title=f"🦇 Profil von {member.display_name} 🦇", color=discord.Color.purple())
    profile_embed.add_field(name="Level", value=f"{level}", inline=True)
    profile_embed.add_field(name="XP", value=f"{xp}", inline=True)
    profile_embed.add_field(name="Münzen", value=f"{coins}", inline=True)
    profile_embed.add_field(name="Anzahl Karten", value=f"{card_count}", inline=True)
    
    await ctx.respond(embed=profile_embed, ephemeral=True)
    

    @commands.slash_command(name="collection", description="Zeige deine gespenstische Kartensammlung an.") async def collection(self, ctx): user_id = ctx.user.id player_cards = self.get_player_cards(user_id)

    if not player_cards:
        await ctx.respond("Du hast noch keine Karten. Nutze `/draw`, um Karten zu ziehen.", ephemeral=True)
        return
    
    collection_embed = discord.Embed(title=f"📜 Kartensammlung von {ctx.user.display_name} 📜", color=discord.Color.blue())
    
    for card in player_cards:
        collection_embed.add_field(name=f"{card[0]} (x{card[5]}) [{card[3]}]", value=f"Typ: {card[1]}, Power: {card[2]}\nBeschreibung: {card[4]}", inline=False)
    
    await ctx.respond(embed=collection_embed, ephemeral=True)
    

    @commands.slash_command(name="leaderboard", description="Zeige die Münzen-Bestenliste an.") async def leaderboard(self, ctx): top_players = self.db.execute_with_connection( "SELECT user_id, coins FROM players ORDER BY coins DESC LIMIT 10" )

    leaderboard_embed = discord.Embed(title="🏆 Bestenliste der Münzen 🏆", color=discord.Color.gold())
    
    for idx, (user_id, coins) in enumerate(top_players, start=1):
        user = self.bot.get_user(user_id)
        if user:
            leaderboard_embed.add_field(name=f"{idx}. {user.display_name}", value=f"Münzen: {coins}", inline=False)
        else:
            leaderboard_embed.add_field(name=f"{idx}. Unbekannt", value=f"Münzen: {coins}", inline=False)
    
    await ctx.respond(embed=leaderboard_embed, ephemeral=True)
    

    @commands.slash_command(name="shop", description="Betritt den verfluchten Shop der Schatten.") async def shop(self, ctx): coins = self.fetch_player_coins(ctx.user.id) shop_embed = discord.Embed(title="🎩 Verfluchter Shop der Schatten 🎩", description="Folgende düstere Gegenstände kannst du erwerben:", color=discord.Color.orange()) items = { "Kartenpack": 100, "Spezielle Rolle": 3000 # Increased price from 1500 to 3000 }

    for item, price in items.items():
        shop_embed.add_field(name=item, value=f"Preis: {price} Münzen", inline=False)
    
    class ShopView(discord.ui.View):
        def __init__(self, cog):
            super().__init__(timeout=60)
            self.cog = cog
    
        @discord.ui.button(label="Kartenpack kaufen", style=discord.ButtonStyle.green)
        async def pack_button_callback(self, button: discord.ui.Button, interaction):
            player_coins = self.cog.fetch_player_coins(interaction.user.id)
            if player_coins >= 100:
                self.cog.update_coins(interaction.user.id, -100)
                drawn_cards = []
                for _ in range(3):
                    card = self.cog.draw_random_card()
                    if self.cog.add_card_to_player(interaction.user.id, card['name']):
                        drawn_cards.append(f"{card['name']} ({card['rarity']})")
                cards_text = ", ".join(drawn_cards) if drawn_cards else "keine neuen Karten."
                await interaction.response.send_message(
                    f"🃏 Du hast ein Kartenpack für 100 Münzen gekauft und folgende Karten erhalten: {cards_text}",
                    ephemeral=True
                )
            else:
                await interaction.response.send_message(
                    "Du hast nicht genügend Münzen, um ein Kartenpack zu kaufen.",
                    ephemeral=True
                )
    
        @discord.ui.button(label="Spezielle Rolle kaufen", style=discord.ButtonStyle.blurple)
        async def role_button_callback(self, button: discord.ui.Button, interaction):
            player_coins = self.cog.fetch_player_coins(interaction.user.id)
            if player_coins >= 3000:  # Updated to 3000 coins
                role = interaction.guild.get_role(1285273226280435883)  # Ensure this ID is correct
                if role:
                    if role in interaction.user.roles:
                        await interaction.response.send_message(
                            "Du besitzt diese Rolle bereits.",
                            ephemeral=True
                        )
                    else:
                        await interaction.user.add_roles(role)
                        self.cog.update_coins(interaction.user.id, -3000)  # Deduct 3000 coins
                        await interaction.response.send_message(
                            f"✨ Du hast erfolgreich die Rolle {role.name} für 3.000 Münzen gekauft!",
                            ephemeral=True
                        )
                else:
                    await interaction.response.send_message(
                        "Die Rolle konnte nicht gefunden werden.",
                        ephemeral=True
                    )
            else:
                await interaction.response.send_message(
                    "Du hast nicht genügend Münzen, um diese Rolle zu kaufen.",
                    ephemeral=True
                )
    
    await ctx.respond(f"💰 Du hast {coins} Münzen.", embed=shop_embed, view=ShopView(self), ephemeral=True)
    

    @commands.slash_command(name="draw", description="Ziehe 1 bis 3 Karten.") async def draw_cards(self, ctx): user_id = ctx.user.id player = self.get_player(user_id)

    if not player:
        self.create_player(user_id)
        player = self.get_player(user_id)
    
    last_draw_time = player[0][6]
    current_time = int(time.time())
    
    if current_time - last_draw_time < 600:  # 10 Minutes
        remaining_time = 600 - (current_time - last_draw_time)
        minutes = remaining_time // 60
        seconds = remaining_time % 60
        await ctx.respond(f"🕒 Du kannst wieder Karten ziehen in {minutes} Minuten und {seconds} Sekunden.", ephemeral=True)
        return
    
    drawn_cards = []
    for _ in range(1, 4):
        card = self.draw_random_card()
        self.add_card_to_player(user_id, card['name'])
        drawn_cards.append(f"{card['name']} ({card['rarity']})")
    
    self.update_last_draw_time(user_id, current_time)
    await ctx.respond(f"🃏 Du hast folgende Karten gezogen: {', '.join(drawn_cards)}", ephemeral=True)
    

    @commands.slash_command(name="work", description="Verdiene 50-100 Münzen durch harte Arbeit! (Cooldown: 1 Stunde)") async def work(self, ctx): user_id = ctx.user.id player = self.get_player(user_id) if not player: self.create_player(user_id) player = self.get_player(user_id) last_work_time = player[0][9] current_time = int(time.time()) if current_time - last_work_time < 3600: remaining_time = 3600 - (current_time - last_work_time) minutes = remaining_time // 60 seconds = remaining_time % 60 await ctx.respond(f"🕒 Du kannst /work erst in {minutes} Minuten und {seconds} Sekunden erneut nutzen.", ephemeral=True) return earned_coins = random.randint(50, 100) self.update_coins(user_id, earned_coins) self.update_last_work_time(user_id, current_time) await ctx.respond(f"💼 Du hast hart gearbeitet und {earned_coins} Münzen verdient!", ephemeral=True) def setup(bot): bot.add_cog(Halloween(bot))

    Hier funktioniert einiges im Code nicht. Nachdem ich ein Duel mache und /play eingebe, kommt der Fehler: "The application did not respond" und nichts wird im Terminal geprintet. Außerdem sind zwei Methoden nicht accessed wie "card_select_callback" und "apply_card_effects" - Bitte verbessere das und implementiere das im ganzen Code also stelle den ganzen Code dann mit fix zur Verfügungen. Schreibe nirgendswo: "Die Logik blieb unverändert" oder ähnliche Nachrichten. Ich will den GANZEN Code haben.

  2. Assistant
    import discord
    from discord.ext import commands, tasks
    import sqlite3
    import random
    import time
    import asyncio
    
    intents = discord.Intents.default()
    intents.members = True
    
    cards = [
        {"name": "Phantom", "type": "Geist", "power": 64, "rarity": "common",
         "description": "Ein schleichender Geist, der Schrecken verbreitet.", "ability": None},
        {"name": "Banshee", "type": "Geist", "power": 72, "rarity": "rare",
         "description": "Ein rachsüchtiger Geist, der Tod durch Schrei verkündet.", "ability": None},
        {"name": "Wraith", "type": "Geist", "power": 68, "rarity": "epic",
         "description": "Eine Erscheinung, die durch Wände gleitet.", "ability": "ignore_defense"},
        {"name": "Ghoul", "type": "Untoter", "power": 56, "rarity": "common",
         "description": "Ein bösartiges Wesen, das die Lebenden heimsucht.", "ability": None},
        {"name": "Vampir", "type": "Untoter", "power": 76, "rarity": "epic",
         "description": "Ein nachtaktives Wesen, das Blut saugt.", "ability": "lifesteal"},
        {"name": "Zombie", "type": "Untoter", "power": 48, "rarity": "common",
         "description": "Ein wandelnder Toter, der nie ruht.", "ability": None},
        {"name": "Skelett", "type": "Untoter", "power": 52, "rarity": "common",
         "description": "Ein klappriges Gerippe, das sich bewegt.", "ability": None},
        {"name": "Heilungs-Karte", "type": "Heilung", "power": 16, "rarity": "common",
         "description": "Eine heilende Kraft, die 16 Lebenspunkte wiederherstellt.", "ability": None},
        {"name": "Block-Karte", "type": "Block", "power": 0, "rarity": "common",
         "description": "Eine Schutzkarte, die einen Angriff vereitelt.", "ability": "block"},
        {"name": "Verfluchte Rüstung", "type": "Geist", "power": 60, "rarity": "rare",
         "description": "Eine verfluchte Rüstung, die den Träger beschützt.", "ability": "shield"},
        {"name": "Höllenhund", "type": "Geist", "power": 80, "rarity": "legendary",
         "description": "Ein dämonischer Hund, dessen Augen feurigen Zorn sprühen.", "ability": "burn"},
        {"name": "Nekromant", "type": "Untoter", "power": 88, "rarity": "legendary",
         "description": "Ein Hexer, der die Toten erweckt.", "ability": "revive"},
        {"name": "Spektral", "type": "Geist", "power": 64, "rarity": "rare",
         "description": "Ein durchscheinendes Wesen voller Geheimnisse.", "ability": None},
        {"name": "Verfluchte Puppe", "type": "Untoter", "power": 40, "rarity": "common",
         "description": "Eine Puppe, die mit einem Fluch belegt ist.", "ability": "curse"},
        {"name": "Schatten-Dämon", "type": "Geist", "power": 72, "rarity": "epic",
         "description": "Ein Wesen aus purer Dunkelheit.", "ability": "shadow_strike"},
        {"name": "Lich-König", "type": "Untoter", "power": 96, "rarity": "legendary",
         "description": "Der unsterbliche König der Toten.", "ability": "frost_nova"},
        {"name": "Dunkler Magier", "type": "Geist", "power": 76, "rarity": "epic",
         "description": "Ein Magier, der die dunklen Künste beherrscht.", "ability": "mana_burn"},
        {"name": "Schreckgespenst", "type": "Geist", "power": 68, "rarity": "rare",
         "description": "Ein Albtraumwesen, das Angst verbreitet.", "ability": "fear"},
        {"name": "Feuergeist", "type": "Geist", "power": 72, "rarity": "epic",
         "description": "Ein Geist aus reiner Flamme.", "ability": "burn"},
        {"name": "Stille Schatten", "type": "Geist", "power": 64, "rarity": "rare",
         "description": "Schatten, die alle Geräusche verschlucken.", "ability": "silence"},
        {"name": "Ghulkönig", "type": "Untoter", "power": 80, "rarity": "legendary",
         "description": "Der Herrscher aller Ghule.", "ability": "summon"},
        {"name": "Seelenräuber", "type": "Untoter", "power": 76, "rarity": "epic",
         "description": "Ein Wesen, das Seelen stiehlt.", "ability": "drain_soul"},
        {"name": "Poltergeist", "type": "Geist", "power": 56, "rarity": "common",
         "description": "Ein Geist, der bekannt dafür ist, Objekte zu werfen.", "ability": "throw_objects"},
        {"name": "Shade", "type": "Geist", "power": 68, "rarity": "rare",
         "description": "Ein schüchterner Geist, der weniger aktiv ist, wenn viele Menschen in der Nähe sind.", "ability": "hide_presence"},
        {"name": "Phantom", "type": "Geist", "power": 72, "rarity": "epic",
         "description": "Ein Geist, der beim Anschauen Angst verbreitet.", "ability": "fear"},
        {"name": "Banshee", "type": "Geist", "power": 76, "rarity": "epic",
         "description": "Ein Geist, der sich auf ein Opfer konzentriert und es verfolgt.", "ability": "mark_target"},
        {"name": "Mare", "type": "Geist", "power": 64, "rarity": "rare",
         "description": "Ein Geist, der in der Dunkelheit stärker wird.", "ability": "dark_power"},
        {"name": "Revenant", "type": "Geist", "power": 80, "rarity": "legendary",
         "description": "Ein schneller und tödlicher Geist.", "ability": "swift_strike"},
        {"name": "Dämon", "type": "Geist", "power": 84, "rarity": "legendary",
         "description": "Ein aggressiver Geist, der häufig angreift.", "ability": "relentless"},
        {"name": "Yurei", "type": "Geist", "power": 72, "rarity": "epic",
         "description": "Ein Geist, der die mentale Stärke seiner Opfer schwächt.", "ability": "sanity_drain"},
        {"name": "Oni", "type": "Geist", "power": 76, "rarity": "epic",
         "description": "Ein starker Geist, der mehr aktiv ist, wenn Spieler in der Nähe sind.", "ability": None},
        {"name": "Spirit", "type": "Geist", "power": 60, "rarity": "common",
         "description": "Ein gewöhnlicher Geist ohne besondere Fähigkeiten.", "ability": None},
        {"name": "Jinn", "type": "Geist", "power": 68, "rarity": "rare",
         "description": "Ein territorialer Geist, der schneller wird, wenn sein Territorium bedroht ist.", "ability": "speed_boost"},
        {"name": "Wraith", "type": "Geist", "power": 72, "rarity": "epic",
         "description": "Ein gefährlicher Geist, der durch Wände gehen kann.", "ability": "phase_through"},
        {"name": "Yokai", "type": "Geist", "power": 64, "rarity": "rare",
         "description": "Ein Geist, der durch Lärm provoziert wird.", "ability": "sound_aggression"},
        {"name": "Goryo", "type": "Geist", "power": 68, "rarity": "rare",
         "description": "Ein Geist, der selten seine Umgebung verlässt.", "ability": None},
        {"name": "Hantu", "type": "Geist", "power": 72, "rarity": "epic",
         "description": "Ein Geist, der in kalten Umgebungen schneller wird.", "ability": "cold_speed"},
    ]
    
    
    class DatabaseManager:
        def __init__(self, db_name='./database/game.db'):
            self.db_name = db_name
            self.conn = None
            self.cursor = None
    
        def connect(self):
            self.conn = sqlite3.connect(self.db_name)
            self.cursor = self.conn.cursor()
    
        def close(self):
            if self.conn:
                self.conn.commit()
                self.conn.close()
    
        def init_db(self):
            try:
                self.connect()
                self.cursor.execute('''
                    CREATE TABLE IF NOT EXISTS players (
                        id INTEGER PRIMARY KEY,
                        user_id INTEGER UNIQUE,
                        health INTEGER DEFAULT 200,
                        coins INTEGER DEFAULT 0,
                        xp INTEGER DEFAULT 0,
                        level INTEGER DEFAULT 1,
                        last_draw_time INTEGER DEFAULT 0,
                        last_daily_bonus INTEGER DEFAULT 0,
                        daily_bonus_count INTEGER DEFAULT 0,
                        last_work_time INTEGER DEFAULT 0
                    );
                ''')
    
                # Check for 'last_work_time' column and add if not exists
                columns = [col[1] for col in self.cursor.execute("PRAGMA table_info(players);")]
                if 'last_work_time' not in columns:
                    self.cursor.execute("ALTER TABLE players ADD COLUMN last_work_time INTEGER DEFAULT 0;")
    
                self.cursor.execute('''
                    CREATE TABLE IF NOT EXISTS cards (
                        id INTEGER PRIMARY KEY,
                        name TEXT UNIQUE,
                        type TEXT,
                        power INTEGER,
                        rarity TEXT,
                        description TEXT,
                        ability TEXT
                    );
                ''')
                self.cursor.execute('''
                    CREATE TABLE IF NOT EXISTS player_cards (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        player_id INTEGER,
                        card_id INTEGER,
                        quantity INTEGER DEFAULT 1,
                        FOREIGN KEY (player_id) REFERENCES players(id),
                        FOREIGN KEY (card_id) REFERENCES cards(id)
                    );
                ''')
    
                self.cursor.execute('''
                    CREATE TABLE IF NOT EXISTS ongoing_duels (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        challenger_id INTEGER,
                        opponent_id INTEGER,
                        challenger_health INTEGER,
                        opponent_health INTEGER,
                        turn_id INTEGER,
                        thread_id INTEGER,
                        duel_start_time INTEGER,
                        challenger_shield INTEGER DEFAULT 0,
                        opponent_shield INTEGER DEFAULT 0,
                        challenger_block INTEGER DEFAULT 0,
                        opponent_block INTEGER DEFAULT 0,
                        challenger_frozen BOOLEAN DEFAULT FALSE,
                        opponent_frozen BOOLEAN DEFAULT FALSE,
                        challenger_curse INTEGER DEFAULT 0,
                        opponent_curse INTEGER DEFAULT 0,
                        challenger_silence INTEGER DEFAULT 0,
                        opponent_silence INTEGER DEFAULT 0,
                        challenger_fear INTEGER DEFAULT 0,
                        opponent_fear INTEGER DEFAULT 0,
                        challenger_marked INTEGER DEFAULT 0,
                        opponent_marked INTEGER DEFAULT 0,
                        challenger_dark_power INTEGER DEFAULT 0,
                        opponent_dark_power INTEGER DEFAULT 0,
                        challenger_speed_boost BOOLEAN DEFAULT FALSE,
                        opponent_speed_boost BOOLEAN DEFAULT FALSE,
                        challenger_phase_through BOOLEAN DEFAULT FALSE,
                        opponent_phase_through BOOLEAN DEFAULT FALSE,
                        challenger_sound_aggression INTEGER DEFAULT 0,
                        opponent_sound_aggression INTEGER DEFAULT 0,
                        challenger_cold_speed INTEGER DEFAULT 0,
                        opponent_cold_speed INTEGER DEFAULT 0,
                        challenger_relentless BOOLEAN DEFAULT FALSE,
                        opponent_relentless BOOLEAN DEFAULT FALSE
                    );
                ''')
    
                self.cursor.execute('''
                    CREATE TABLE IF NOT EXISTS achievements (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        name TEXT UNIQUE,
                        description TEXT,
                        condition TEXT
                    );
                ''')
                self.cursor.execute('''
                    CREATE TABLE IF NOT EXISTS player_achievements (
                        player_id INTEGER,
                        achievement_id INTEGER,
                        FOREIGN KEY (player_id) REFERENCES players(id),
                        FOREIGN KEY (achievement_id) REFERENCES achievements(id)
                    );
                ''')
                self.cursor.execute('''
                    CREATE TABLE IF NOT EXISTS daily_quests (
                        id INTEGER PRIMARY KEY AUTOINCREMENT,
                        player_id INTEGER,
                        quest TEXT,
                        progress INTEGER DEFAULT 0,
                        completed INTEGER DEFAULT 0,
                        FOREIGN KEY (player_id) REFERENCES players(id)
                    );
                ''')
                self.close()
            except sqlite3.Error as e:
                print(f"Error initializing database: {e}")
    
        def add_cards_to_db(self):
            try:
                self.connect()
                for card in cards:
                    self.cursor.execute(
                        "INSERT OR IGNORE INTO cards (name, type, power, rarity, description, ability) VALUES (?, ?, ?, ?, ?, ?)",
                        (card['name'], card['type'], card['power'], card['rarity'], card['description'], card['ability'])
                    )
                self.close()
            except sqlite3.Error as e:
                print(f"Error adding cards: {e}")
    
        def add_achievements_to_db(self):
            achievements = [
                {"name": "Erstes Duell", "description": "Gewinne dein erstes Duell.", "condition": "win_duel"},
                {"name": "Sammler", "description": "Sammle 50 Karten.", "condition": "collect_50_cards"},
                {"name": "Level Meister", "description": "Erreiche Level 10.", "condition": "reach_level_10"},
                {"name": "Täglicher Spieler", "description": "Erhalte deinen täglichen Bonus 7 Mal.", "condition": "daily_bonus_7_times"},
                {"name": "Champion Duell", "description": "Gewinne 10 Duelle.", "condition": "win_10_duels"},
                {"name": "Kartensammler", "description": "Sammle 100 Karten.", "condition": "collect_100_cards"},
                {"name": "Level Guru", "description": "Erreiche Level 20.", "condition": "reach_level_20"},
                {"name": "Daily Player Pro", "description": "Erhalte deinen täglichen Bonus 30 Mal.", "condition": "daily_bonus_30_times"},
                {"name": "Elite Sammler", "description": "Sammle alle seltenen Karten.", "condition": "collect_all_rare_cards"},
            ]
            try:
                self.connect()
                for achievement in achievements:
                    self.cursor.execute(
                        "INSERT OR IGNORE INTO achievements (name, description, condition) VALUES (?, ?, ?)",
                        (achievement['name'], achievement['description'], achievement['condition'])
                    )
                self.close()
            except sqlite3.Error as e:
                print(f"Error adding achievements: {e}")
    
        def add_quests_to_db(self):
            # Optional: If you want to add permanent quests
            pass  # Currently, quests are dynamically assigned
    
        def execute_with_connection(self, query, params=()):
            try:
                self.connect()
                self.cursor.execute(query, params)
                results = self.cursor.fetchall()
                self.close()
                return results
            except sqlite3.Error as e:
                print(f"Error executing query: {e}")
                return []
    
        def modify_with_connection(self, query, params=()):
            try:
                self.connect()
                self.cursor.execute(query, params)
                self.conn.commit()
                self.close()
            except sqlite3.Error as e:
                print(f"Error during database modification: {e}")
    
    
    class Halloween(commands.Cog):
        def __init__(self, bot):
            self.bot = bot
            self.db = DatabaseManager()
            self.db.init_db()
            self.db.add_cards_to_db()
            self.db.add_achievements_to_db()
            self.duels = {}
            self.trades = {}
            self.singleplayer_sessions = {}
            self.check_duel_timeout.start()
    
        def get_player(self, user_id):
            return self.db.execute_with_connection(
                "SELECT * FROM players WHERE user_id = ?",
                (user_id,)
            )
    
        def create_player(self, user_id):
            self.db.modify_with_connection(
                "INSERT INTO players (user_id) VALUES (?)",
                (user_id,)
            )
            for _ in range(10):
                card = self.draw_random_card()
                self.add_card_to_player(user_id, card['name'])
            self.assign_daily_quest(user_id)
    
        def update_coins(self, user_id, amount):
            current_coins = self.fetch_player_coins(user_id)
            new_coins = current_coins + amount
            if new_coins < 0:
                new_coins = 0
            self.db.modify_with_connection(
                "UPDATE players SET coins = ? WHERE user_id = ?",
                (new_coins, user_id)
            )
            self.check_achievements(user_id)
    
        def update_xp(self, user_id, amount):
            self.db.modify_with_connection(
                "UPDATE players SET xp = xp + ? WHERE user_id = ?",
                (amount, user_id)
            )
            player = self.get_player(user_id)
            if player:
                player = player[0]
                xp = player[4]
                level = player[5]
                xp_needed = level * 100
                if xp >= xp_needed:
                    self.db.modify_with_connection(
                        "UPDATE players SET xp = xp - ?, level = level + 1 WHERE user_id = ?",
                        (xp_needed, user_id)
                    )
                    user = self.bot.get_user(user_id)
                    if user:
                        self.bot.loop.create_task(
                            user.send(f"🎉 Glückwunsch! Du bist nun Level {level + 1}!")
                        )
                    self.check_achievements(user_id)
    
        def update_last_draw_time(self, user_id, timestamp):
            self.db.modify_with_connection(
                "UPDATE players SET last_draw_time = ? WHERE user_id = ?",
                (timestamp, user_id)
            )
    
        def update_last_daily_bonus_time(self, user_id, timestamp):
            self.db.modify_with_connection(
                "UPDATE players SET last_daily_bonus = ?, daily_bonus_count = daily_bonus_count + 1 WHERE user_id = ?",
                (timestamp, user_id)
            )
    
        def update_last_work_time(self, user_id, timestamp):
            self.db.modify_with_connection(
                "UPDATE players SET last_work_time = ? WHERE user_id = ?",
                (timestamp, user_id)
            )
    
        def add_card_to_player(self, user_id, card_name):
            player = self.get_player(user_id)
            if player:
                card = self.db.execute_with_connection(
                    "SELECT id FROM cards WHERE name = ?",
                    (card_name,)
                )
                if card:
                    player_card = self.db.execute_with_connection(
                        "SELECT quantity FROM player_cards WHERE player_id = ? AND card_id = ?",
                        (player[0][0], card[0][0])
                    )
                    if player_card:
                        self.db.modify_with_connection(
                            "UPDATE player_cards SET quantity = quantity + 1 WHERE player_id = ? AND card_id = ?",
                            (player[0][0], card[0][0])
                        )
                    else:
                        card_count = self.db.execute_with_connection(
                            "SELECT SUM(quantity) FROM player_cards WHERE player_id = ?",
                            (player[0][0],)
                        )[0][0] or 0
    
                        if card_count < 100:  # Increased max card limit to 100
                            self.db.modify_with_connection(
                                "INSERT INTO player_cards (player_id, card_id, quantity) VALUES (?, ?, 1)",
                                (player[0][0], card[0][0])
                            )
                            self.check_achievements(user_id)
                            return True
                        else:
                            return False
                    self.check_achievements(user_id)
                    return True
            return False
    
        def remove_card_from_player(self, user_id, card_name):
            player = self.get_player(user_id)
            if player:
                card = self.db.execute_with_connection(
                    "SELECT id FROM cards WHERE name = ?",
                    (card_name,)
                )
                if card:
                    player_card = self.db.execute_with_connection(
                        "SELECT quantity FROM player_cards WHERE player_id = ? AND card_id = ?",
                        (player[0][0], card[0][0])
                    )
                    if player_card:
                        quantity = player_card[0][0]
                        if quantity > 1:
                            self.db.modify_with_connection(
                                "UPDATE player_cards SET quantity = quantity - 1 WHERE player_id = ? AND card_id = ?",
                                (player[0][0], card[0][0])
                            )
                        else:
                            self.db.modify_with_connection(
                                "DELETE FROM player_cards WHERE player_id = ? AND card_id = ?",
                                (player[0][0], card[0][0])
                            )
                        return True
            return False
    
        def fetch_player_coins(self, user_id):
            result = self.db.execute_with_connection(
                "SELECT * FROM players WHERE user_id = ?",
                (user_id,)
            )
            return result[0][3] if result else 0
    
        def get_player_cards(self, user_id):
            player = self.get_player(user_id)
            if player:
                player_id = player[0][0]
                return self.db.execute_with_connection(
                    "SELECT c.name, c.type, c.power, c.rarity, c.description, pc.quantity, c.ability FROM player_cards pc JOIN cards c ON pc.card_id = c.id WHERE pc.player_id = ?",
                    (player_id,)
                )
            return []
    
        def draw_random_card(self):
            rarity_weight = {'common': 60, 'rare': 25, 'epic': 10, 'legendary': 5}
            rarity_choices = [rarity for rarity in rarity_weight for _ in range(rarity_weight[rarity])]
            chosen_rarity = random.choice(rarity_choices)
            cards_of_chosen_rarity = [card for card in cards if card['rarity'] == chosen_rarity]
            return random.choice(cards_of_chosen_rarity)
    
        def assign_daily_quest(self, user_id):
            player = self.get_player(user_id)
            if player:
                player_id = player[0][0]  # Get the primary key from the players table
                quests = [
                    {"quest": "Gewinne 3 Duelle", "condition": "win_3_duels"},
                    {"quest": "Sammle 5 seltene Karten", "condition": "collect_5_rare_cards"},
                    {"quest": "Erreiche Level 5", "condition": "reach_level_5"},
                    {"quest": "Spiele 10 Karten", "condition": "play_10_cards"},
                    {"quest": "Gewinne 5 Duelle heute", "condition": "win_5_duels_today"},
                    {"quest": "Sammle 10 epische Karten", "condition": "collect_10_epic_cards"},
                    {"quest": "Erreiche Level 15", "condition": "reach_level_15"},
                    {"quest": "Spiele 20 Karten heute", "condition": "play_20_cards_today"}
                ]
                quest = random.choice(quests)
                self.db.modify_with_connection(
                    "INSERT INTO daily_quests (player_id, quest) VALUES (?, ?)",
                    (player_id, quest["quest"])
                )
    
        def check_achievements(self, user_id):
            achievements = self.db.execute_with_connection(
                "SELECT id, condition FROM achievements"
            )
            player = self.get_player(user_id)
            if player:
                player = player[0]
                player_id = player[0]
                level = player[5]
                daily_bonus_count = player[8]
                for ach_id, condition in achievements:
                    already_unlocked = self.db.execute_with_connection(
                        "SELECT * FROM player_achievements WHERE player_id = ? AND achievement_id = ?",
                        (player_id, ach_id)
                    )
                    if not already_unlocked:
                        if condition == "win_duel":
                            # Placeholder: Implement proper duel win tracking
                            duels_won = self.db.execute_with_connection(
                                "SELECT COUNT(*) FROM ongoing_duels WHERE challenger_id = ? OR opponent_id = ?",  # Needs proper tracking
                                (user_id, user_id)
                            )[0][0]
                            if duels_won >= 1:
                                self.unlock_achievement(player_id, ach_id)
                        elif condition == "collect_50_cards":
                            total_cards = self.db.execute_with_connection(
                                "SELECT SUM(quantity) FROM player_cards WHERE player_id = ?",
                                (player_id,)
                            )[0][0]
                            if total_cards >= 50:
                                self.unlock_achievement(player_id, ach_id)
                        elif condition == "reach_level_10":
                            if level >= 10:
                                self.unlock_achievement(player_id, ach_id)
                        elif condition == "daily_bonus_7_times":
                            if daily_bonus_count >= 7:
                                self.unlock_achievement(player_id, ach_id)
                        elif condition == "win_10_duels":
                            # Placeholder: Implement proper duel win tracking
                            duels_won = self.db.execute_with_connection(
                                "SELECT COUNT(*) FROM ongoing_duels WHERE challenger_id = ? OR opponent_id = ?",  # Needs proper tracking
                                (user_id, user_id)
                            )[0][0]
                            if duels_won >= 10:
                                self.unlock_achievement(player_id, ach_id)
                        elif condition == "collect_100_cards":
                            total_cards = self.db.execute_with_connection(
                                "SELECT SUM(quantity) FROM player_cards WHERE player_id = ?",
                                (player_id,)
                            )[0][0]
                            if total_cards >= 100:
                                self.unlock_achievement(player_id, ach_id)
                        elif condition == "reach_level_20":
                            if level >= 20:
                                self.unlock_achievement(player_id, ach_id)
                        elif condition == "daily_bonus_30_times":
                            if daily_bonus_count >= 30:
                                self.unlock_achievement(player_id, ach_id)
                        elif condition == "collect_all_rare_cards":
                            rare_card_names = [card['name'] for card in cards if card['rarity'] == 'rare']
                            player_cards = self.db.execute_with_connection(
                                "SELECT c.name FROM player_cards pc JOIN cards c ON pc.card_id = c.id WHERE pc.player_id = ? AND c.rarity = 'rare'",
                                (player_id,)
                            )
                            player_rare_cards = set([card[0] for card in player_cards])
                            if set(rare_card_names).issubset(player_rare_cards):
                                self.unlock_achievement(player_id, ach_id)
    
        def unlock_achievement(self, player_id, achievement_id):
            self.db.modify_with_connection(
                "INSERT INTO player_achievements (player_id, achievement_id) VALUES (?, ?)",
                (player_id, achievement_id)
            )
            # Notify the player
            result = self.db.execute_with_connection("SELECT user_id FROM players WHERE id = ?", (player_id,))
            if result:
                user_id = result[0][0]
                user = self.bot.get_user(user_id)
                achievement_name = self.db.execute_with_connection("SELECT name FROM achievements WHERE id = ?", (achievement_id,))[0][0]
                if user:
                    self.bot.loop.create_task(
                        user.send(f"🏆 Glückwunsch! Du hast das Achievement '{achievement_name}' freigeschaltet!")
                    )
    
        # Helper Function to Assign New Cards
        def assign_new_cards(self, user_id, num):
            drawn_cards = []
            for _ in range(num):
                card = self.draw_random_card()
                success = self.add_card_to_player(user_id, card['name'])
                if success:
                    drawn_cards.append(f"{card['name']} ({card['rarity']})")
            return drawn_cards
    
        # Slash Commands
        @commands.slash_command(name="daily_bonus", description="Hole dir deine tägliche Belohnung ab.")
        async def daily_bonus(self, ctx):
            user_id = ctx.user.id
            player = self.get_player(user_id)
            if not player:
                self.create_player(user_id)
                player = self.get_player(user_id)
            last_bonus_time = player[0][7]
            current_time = int(time.time())
            if current_time - last_bonus_time >= 86400:  # 24 hours
                self.update_last_daily_bonus_time(user_id, current_time)
                self.update_coins(user_id, 100)  # Give 100 coins as daily bonus
                self.check_achievements(user_id)
                await ctx.respond("🎁 Du hast deinen täglichen Bonus von 100 Münzen erhalten!", ephemeral=True)
            else:
                remaining_time = 86400 - (current_time - last_bonus_time)
                hours = remaining_time // 3600
                minutes = (remaining_time % 3600) // 60
                await ctx.respond(f"🕒 Du hast deinen täglichen Bonus bereits abgeholt. Versuche es in {hours} Stunden und {minutes} Minuten erneut.", ephemeral=True)
    
        @commands.slash_command(name="quest", description="Sieh dir deine tägliche Quest an.")
        async def quest(self, ctx):
            user_id = ctx.user.id
            player = self.get_player(user_id)
            if not player:
                self.create_player(user_id)
                player = self.get_player(user_id)  # Re-fetch player after creation
            player_id = player[0][0]  # Get the player's primary key ID
            quest = self.db.execute_with_connection(
                "SELECT quest, progress, completed FROM daily_quests WHERE player_id = ? AND completed = 0",
                (player_id,)
            )
            if quest:
                quest_text, progress, completed = quest[0]
                status = "Abgeschlossen" if completed else f"Fortschritt: {progress}/100"
                await ctx.respond(f"📝 Deine tägliche Quest: {quest_text}\nStatus: {status}", ephemeral=True)
            else:
                self.assign_daily_quest(user_id)  # This now uses the correct player_id
                await ctx.respond("📝 Du hast eine neue tägliche Quest erhalten! Nutze `/quest`, um sie zu sehen.", ephemeral=True)
    
        @commands.slash_command(name="achievements", description="Zeige deine freigeschalteten Achievements an.")
        async def show_achievements(self, ctx):
            user_id = ctx.user.id
            player = self.get_player(user_id)
            if not player:
                self.create_player(user_id)
            player_id = player[0][0]
            achievements = self.db.execute_with_connection(
                "SELECT a.name, a.description FROM player_achievements pa JOIN achievements a ON pa.achievement_id = a.id WHERE pa.player_id = ?",
                (player_id,)
            )
            if achievements:
                embed = discord.Embed(title="🏆 Deine Achievements", color=discord.Color.gold())
                for name, description in achievements:
                    embed.add_field(name=name, value=description, inline=False)
                await ctx.respond(embed=embed, ephemeral=True)
            else:
                await ctx.respond("Du hast noch keine Achievements freigeschaltet.", ephemeral=True)
    
        # Duel Management
        @commands.slash_command(name="duel", description="Fordere einen anderen Spieler zu einem schaurigen Duell heraus.")
        async def duel(self, ctx, opponent: discord.Member):
            user_id = ctx.user.id
            opponent_id = opponent.id
    
            if user_id == opponent_id:
                await ctx.respond("Du kannst dich nicht selbst herausfordern!", ephemeral=True)
                return
    
            if not self.get_player(user_id):
                self.create_player(user_id)
            if not self.get_player(opponent_id):
                self.create_player(opponent_id)
    
            ongoing_duel = self.db.execute_with_connection(
                "SELECT * FROM ongoing_duels WHERE (challenger_id = ? AND opponent_id = ?) OR (challenger_id = ? AND opponent_id = ?)",
                (user_id, opponent_id, opponent_id, user_id)
            )
            if ongoing_duel:
                await ctx.respond("Es gibt bereits ein aktives Duell zwischen euch.", ephemeral=True)
                return
    
            thread = await ctx.channel.create_thread(
                name=f"Duel: {ctx.user.display_name} vs {opponent.display_name}",
                type=discord.ChannelType.private_thread
            )
            await thread.add_user(opponent)
            await thread.add_user(ctx.user)
    
            # Initialize Duel State
            duel_state = {
                "challenger_id": user_id,
                "opponent_id": opponent_id,
                "challenger_health": 200,
                "opponent_health": 200,
                "turn_id": user_id,
                "thread_id": thread.id,
                "duel_start_time": int(time.time()),
                "challenger_shield": 0,
                "opponent_shield": 0,
                "challenger_block": 0,
                "opponent_block": 0,
                "challenger_frozen": False,
                "opponent_frozen": False,
                "challenger_curse": 0,
                "opponent_curse": 0,
                "challenger_silence": 0,
                "opponent_silence": 0,
                "challenger_fear": 0,
                "opponent_fear": 0,
                "challenger_marked": 0,
                "opponent_marked": 0,
                "challenger_dark_power": 0,
                "opponent_dark_power": 0,
                "challenger_speed_boost": False,
                "opponent_speed_boost": False,
                "challenger_phase_through": False,
                "opponent_phase_through": False,
                "challenger_sound_aggression": 0,
                "opponent_sound_aggression": 0,
                "challenger_cold_speed": 0,
                "opponent_cold_speed": 0,
                "challenger_relentless": False,
                "opponent_relentless": False
            }
    
            self.duels[thread.id] = duel_state
    
            self.db.modify_with_connection(
                """INSERT INTO ongoing_duels 
                (challenger_id, opponent_id, challenger_health, opponent_health, turn_id, thread_id, duel_start_time,
                challenger_shield, opponent_shield, challenger_block, opponent_block,
                challenger_frozen, opponent_frozen, challenger_curse, opponent_curse,
                challenger_silence, opponent_silence, challenger_fear, opponent_fear,
                challenger_marked, opponent_marked, challenger_dark_power, opponent_dark_power,
                challenger_speed_boost, opponent_speed_boost, challenger_phase_through, opponent_phase_through,
                challenger_sound_aggression, opponent_sound_aggression, challenger_cold_speed, opponent_cold_speed,
                challenger_relentless, opponent_relentless) 
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
                (
                    user_id, opponent_id, 200, 200, user_id, thread.id, int(time.time()),
                    0, 0, 0, 0, False, False, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, False, False, False, False,
                    0, 0, 0, 0, False, False
                )
            )
    
            await thread.send(
                f"🎃 Ein schauriges Duell zwischen {ctx.user.mention} und {opponent.mention} steht bevor! "
                f"{opponent.mention}, tippe `/accept` hier im Thread, um das Duell zu akzeptieren. Möge der Gruseligste gewinnen! 🎃"
            )
    
            await ctx.respond(f"Ein Thread für das Duell wurde erstellt: {thread.mention}", ephemeral=True)
    
        @tasks.loop(minutes=1)
        async def check_duel_timeout(self):
            current_time = int(time.time())
            for thread_id in list(self.duels.keys()):
                duel = self.duels[thread_id]
                duel_start_time = duel.get("duel_start_time", int(time.time()))
                if current_time - duel_start_time >= 300:  # 5 Minutes
                    thread = self.bot.get_channel(thread_id)
                    if thread:
                        try:
                            await thread.send("⏰ Das Duell ist abgelaufen, da es nicht rechtzeitig angenommen wurde.")
                            await thread.delete()
                        except Exception as e:
                            print(f"Error deleting thread {thread_id}: {e}")
                    self.db.modify_with_connection(
                        "DELETE FROM ongoing_duels WHERE thread_id = ?",
                        (thread_id,)
                    )
                    del self.duels[thread_id]
    
        @commands.slash_command(name="accept", description="Akzeptiere ein Duell und bereite dich vor!")
        async def accept_duel(self, ctx):
            thread = ctx.channel
            thread_id = thread.id
    
            if thread_id not in self.duels:
                await ctx.respond("Keine Duellanfrage für dich in diesem Thread gefunden.", ephemeral=True)
                return
    
            duel = self.duels[thread_id]
    
            await ctx.respond(
                f"Das Duell zwischen {self.bot.get_user(duel['challenger_id']).mention} und {ctx.user.mention} beginnt! "
                f"{self.bot.get_user(duel['challenger_id']).mention} ist zuerst an der Reihe. Nutze `/play` hier im Thread, um eine Karte zu spielen!",
                ephemeral=False
            )
    
            await thread.send(
                f"🎉 Das Duell hat begonnen! {self.bot.get_user(duel['challenger_id']).mention} ist an der Reihe.",
                silent=True
            )
    
        async def card_selection_view(self, ctx, player_cards, callback):
            options = []
            for i, card in enumerate(player_cards):
                label = f"{card[0]} (x{card[5]}) [{card[3]}]"
                description = f"Typ: {card[1]}, Power: {card[2]}"
                options.append(discord.SelectOption(label=label, description=description, value=str(i)))
    
            dropdowns = []
    
            while options:
                options_chunk = options[:25]
                options = options[25:]
                dropdown = discord.ui.Select(
                    options=options_chunk,
                    placeholder="Wähle eine Karte",
                    max_values=1
                )
                dropdown.callback = callback
                dropdowns.append(dropdown)
    
            view = discord.ui.View(timeout=60)
            for dropdown in dropdowns:
                view.add_item(dropdown)
    
            await ctx.respond("Wähle eine deiner Karten:", view=view, ephemeral=True)
    
        @commands.slash_command(name="play", description="Spiele eine deiner geisterhaften Karten.")
        async def play_card(self, ctx):
            user_id = ctx.user.id
            thread = ctx.channel
            thread_id = thread.id
    
            duel = self.duels.get(thread_id)
            if not duel:
                await ctx.respond("Du bist in keinem aktiven Duell in diesem Thread.", ephemeral=True)
                return
    
            if user_id != duel["turn_id"]:
                await ctx.respond("Es ist nicht dein Zug. Warte auf dein schauriges Schicksal!", ephemeral=True)
                return
    
            # Check for Frozen Effect
            if (user_id == duel["challenger_id"] and duel.get("challenger_frozen")) or \
               (user_id == duel["opponent_id"] and duel.get("opponent_frozen")):
                await ctx.respond("🔒 Du bist eingefroren und kannst deinen Zug nicht ausführen!", ephemeral=True)
                # Remove Frozen Effect and switch turn
                if user_id == duel["challenger_id"]:
                    duel["challenger_frozen"] = False
                    duel["turn_id"] = duel["opponent_id"]
                else:
                    duel["opponent_frozen"] = False
                    duel["turn_id"] = duel["challenger_id"]
                self.db.modify_with_connection(
                    """
                    UPDATE ongoing_duels SET 
                    challenger_frozen = ?, opponent_frozen = ?, turn_id = ?
                    WHERE thread_id = ?
                    """,
                    (
                        duel["challenger_frozen"],
                        duel["opponent_frozen"],
                        duel["turn_id"],
                        thread_id
                    )
                )
                # Inform the next player
                next_player_id = duel["turn_id"]
                next_player = self.bot.get_user(next_player_id)
                await thread.send(f"🧛 {next_player.mention}, du bist nun an der Reihe! Nutze `/play`, um deine Karte zu spielen.")
                return
    
            # Check for Relentless Effect
            if (user_id == duel["challenger_id"] and duel.get("challenger_relentless")) or \
               (user_id == duel["opponent_id"] and duel.get("opponent_relentless")):
                # Player can continue fighting even if health <= 0
                pass
    
            # Check for Silence Effect
            if (user_id == duel["challenger_id"] and duel.get("challenger_silence", 0) > 0) or \
               (user_id == duel["opponent_id"] and duel.get("opponent_silence", 0) > 0):
                # Filter playable cards (only cards without abilities)
                playable_cards = [card for card in self.get_player_cards(user_id) if card[6] is None]
                if not playable_cards:
                    await ctx.respond("🔇 Du bist verstummt und kannst keine Karten mit Fähigkeiten spielen.", ephemeral=True)
                    return
                player_cards = playable_cards
            else:
                player_cards = self.get_player_cards(user_id)
    
            # If player has no cards, assign a common card
            if not player_cards:
                card = self.draw_random_card()
                self.add_card_to_player(user_id, card['name'])
                player_cards = self.get_player_cards(user_id)
                await thread.send(f"{ctx.user.mention} hat keine Karten mehr! Es wurde eine **{card['name']}** ({card['rarity']}) hinzugefügt.")
    
            if not player_cards:
                await ctx.respond("Keine Karten zum Spielen vorhanden.", ephemeral=True)
                return
    
            # Check for Speed Boost and Cold Speed
            extra_attacks = 0
            if user_id == duel["challenger_id"] and duel.get("challenger_speed_boost"):
                extra_attacks += 1
                duel["challenger_speed_boost"] = False
            elif user_id == duel["opponent_id"] and duel.get("opponent_speed_boost"):
                extra_attacks += 1
                duel["opponent_speed_boost"] = False
    
            if user_id == duel["challenger_id"] and duel.get("challenger_cold_speed", 0) > 0:
                extra_attacks += 1
                duel["challenger_cold_speed"] -= 1
            elif user_id == duel["opponent_id"] and duel.get("opponent_cold_speed", 0) > 0:
                extra_attacks += 1
                duel["opponent_cold_speed"] -= 1
    
            async def card_select_callback(interaction: discord.Interaction):
                selected_index = int(interaction.data['values'][0])
                selected_card = player_cards[selected_index]
                card_name = selected_card[0]
    
                # Remove the card from the player
                self.remove_card_from_player(user_id, card_name)
    
                # Apply card effects
                message = await self.apply_card_effects(duel, user_id, selected_card, interaction)
    
                # Change the turn
                if not extra_attacks:
                    duel["turn_id"] = duel["opponent_id"] if duel["turn_id"] == duel["challenger_id"] else duel["challenger_id"]
    
                # Update the database
                self.db.modify_with_connection(
                    """UPDATE ongoing_duels SET 
                    challenger_health = ?, opponent_health = ?, turn_id = ?, 
                    challenger_shield = ?, opponent_shield = ?, 
                    challenger_block = ?, opponent_block = ?, 
                    challenger_frozen = ?, opponent_frozen = ?, 
                    challenger_curse = ?, opponent_curse = ?, 
                    challenger_silence = ?, opponent_silence = ?, 
                    challenger_fear = ?, opponent_fear = ?, 
                    challenger_marked = ?, opponent_marked = ?, 
                    challenger_dark_power = ?, opponent_dark_power = ?, 
                    challenger_speed_boost = ?, opponent_speed_boost = ?, 
                    challenger_phase_through = ?, opponent_phase_through = ?, 
                    challenger_sound_aggression = ?, opponent_sound_aggression = ?, 
                    challenger_cold_speed = ?, opponent_cold_speed = ?, 
                    challenger_relentless = ?, opponent_relentless = ?
                    WHERE thread_id = ?""",
                    (
                        duel["challenger_health"],
                        duel["opponent_health"],
                        duel["turn_id"],
                        duel.get("challenger_shield", 0),
                        duel.get("opponent_shield", 0),
                        duel.get("challenger_block", 0),
                        duel.get("opponent_block", 0),
                        duel.get("challenger_frozen", False),
                        duel.get("opponent_frozen", False),
                        duel.get("challenger_curse", 0),
                        duel.get("opponent_curse", 0),
                        duel.get("challenger_silence", 0),
                        duel.get("opponent_silence", 0),
                        duel.get("challenger_fear", 0),
                        duel.get("opponent_fear", 0),
                        duel.get("challenger_marked", 0),
                        duel.get("opponent_marked", 0),
                        duel.get("challenger_dark_power", 0),
                        duel.get("opponent_dark_power", 0),
                        duel.get("challenger_speed_boost", False),
                        duel.get("opponent_speed_boost", False),
                        duel.get("challenger_phase_through", False),
                        duel.get("opponent_phase_through", False),
                        duel.get("challenger_sound_aggression", 0),
                        duel.get("opponent_sound_aggression", 0),
                        duel.get("challenger_cold_speed", 0),
                        duel.get("opponent_cold_speed", 0),
                        duel.get("challenger_relentless", False),
                        duel.get("opponent_relentless", False),
                        thread_id
                    )
                )
    
                await interaction.response.send_message(
                    f"{message}\n\nBeschreibung: {selected_card[4]}",
                    ephemeral=False
                )
    
                # Check for Duel End
                if duel["opponent_health"] <= 0 or duel["challenger_health"] <= 0:
                    if duel["opponent_health"] <= 0 and not duel.get("challenger_relentless", False):
                        winner_id = duel["challenger_id"]
                        loser_id = duel["opponent_id"]
                    elif duel["challenger_health"] <= 0 and not duel.get("opponent_relentless", False):
                        winner_id = duel["opponent_id"]
                        loser_id = duel["challenger_id"]
                    else:
                        # Relentless prevents losing
                        await interaction.followup.send("💪 Relentless verhindert das Verlieren! Das Duell geht weiter.", ephemeral=False)
                        # Inform the next player
                        next_player_id = duel["turn_id"]
                        next_player = self.bot.get_user(next_player_id)
                        await thread.send(f"🧛 {next_player.mention}, du bist nun an der Reihe! Nutze `/play`, um deine Karte zu spielen.")
                        return
    
                    winner = self.bot.get_user(winner_id)
                    loser = self.bot.get_user(loser_id)
    
                    # Coin Transfer
                    loser_coins = self.fetch_player_coins(loser_id)
                    coin_loss = min(10, loser_coins)  # Loser loses up to 10 coins
                    self.update_coins(loser_id, -coin_loss)
                    self.update_coins(winner_id, 25 + coin_loss)  # Winner gains 25 coins plus the lost coins
    
                    # Update XP
                    self.update_xp(winner_id, 50)
    
                    # Assign 1-5 new cards to the winner
                    num_new_cards = random.randint(1, 5)
                    new_cards = self.assign_new_cards(winner_id, num_new_cards)
                    if new_cards:
                        new_cards_text = ", ".join(new_cards)
                        await interaction.followup.send(
                            f"🎉 Glückwunsch {winner.mention}! Du hast das gruselige Duell gegen {loser.mention} gewonnen, erhältst 25 Münzen und 50 XP! Außerdem nimmst du {coin_loss} Münzen von {loser.mention}! Zusätzlich hast du {num_new_cards} neue Karte(n) erhalten: {new_cards_text} 🎃",
                            ephemeral=False
                        )
                    else:
                        await interaction.followup.send(
                            f"🎉 Glückwunsch {winner.mention}! Du hast das gruselige Duell gegen {loser.mention} gewonnen, erhältst 25 Münzen und 50 XP! Außerdem nimmst du {coin_loss} Münzen von {loser.mention}! 🎃",
                            ephemeral=False
                        )
    
                    # End the Duel
                    self.db.modify_with_connection(
                        "DELETE FROM ongoing_duels WHERE thread_id = ?",
                        (thread_id,)
                    )
                    del self.duels[thread_id]
    
                    # Delete the Thread
                    thread_obj = self.bot.get_channel(thread_id)
                    if thread_obj:
                        try:
                            await asyncio.sleep(5)
                            await thread_obj.delete()
                        except Exception as e:
                            print(f"Error deleting thread {thread_id}: {e}")
                    return
    
                # Extra Attack Handling
                if extra_attacks:
                    message = f"{self.bot.get_user(duel['turn_id']).mention}, du hast einen zusätzlichen Angriff!\n\n" \
                              f"🎃 **Aktueller Stand:**\n" \
                              f"{self.bot.get_user(duel['challenger_id']).mention}: {duel['challenger_health']} HP\n" \
                              f"{self.bot.get_user(duel['opponent_id']).mention}: {duel['opponent_health']} HP"
                    await interaction.followup.send(message, ephemeral=False)
    
                # Status Update
                status_embed = discord.Embed(title="🧛 **Aktueller Stand des Duells** 🧛", color=discord.Color.dark_purple())
                challenger = self.bot.get_user(duel['challenger_id'])
                opponent = self.bot.get_user(duel['opponent_id'])
                status_embed.add_field(name=f"{challenger.display_name}", value=f"HP: {duel['challenger_health']}", inline=True)
                status_embed.add_field(name=f"{opponent.display_name}", value=f"HP: {duel['opponent_health']}", inline=True)
                await interaction.channel.send(embed=status_embed)
    
                # Inform the next player
                next_player_id = duel["turn_id"]
                next_player = self.bot.get_user(next_player_id)
                await interaction.channel.send(f"🧛 {next_player.mention}, du bist nun an der Reihe! Nutze `/play`, um deine Karte zu spielen.")
    
            # Implementing Card Effects
            # Moved apply_card_effects to a separate method
            # Now call self.apply_card_effects inside card_select_callback
    
            # Implement the card selection view with the callback
            await self.card_selection_view(ctx, player_cards, card_select_callback)
    
        async def apply_card_effects(self, duel, user_id, card, interaction):
            card_name = card[0]
            card_power = card[2]
            card_type = card[1]
            card_description = card[4]
            ability = card[6]
    
            opponent_id = duel["opponent_id"] if user_id == duel["challenger_id"] else duel["challenger_id"]
            opponent = self.bot.get_user(opponent_id)
    
            # Mapping abilities to handler functions
            ability_handlers = {
                "lifesteal": self.handle_lifesteal,
                "shield": self.handle_shield,
                "block": self.handle_block,
                "ignore_defense": self.handle_ignore_defense,
                "burn": self.handle_burn,
                "revive": self.handle_revive,
                "curse": self.handle_curse,
                "shadow_strike": self.handle_shadow_strike,
                "frost_nova": self.handle_frost_nova,
                "mana_burn": self.handle_mana_burn,
                "fear": self.handle_fear,
                "silence": self.handle_silence,
                "summon": self.handle_summon,
                "drain_soul": self.handle_drain_soul,
                "throw_objects": self.handle_throw_objects,
                "hide_presence": self.handle_hide_presence,
                "mark_target": self.handle_mark_target,
                "dark_power": self.handle_dark_power,
                "swift_strike": self.handle_swift_strike,
                "relentless": self.handle_relentless,
                "sanity_drain": self.handle_sanity_drain,
                "speed_boost": self.handle_speed_boost,
                "phase_through": self.handle_phase_through,
                "sound_aggression": self.handle_sound_aggression,
                "cold_speed": self.handle_cold_speed
            }
    
            message = ""
    
            if ability in ability_handlers:
                handler = ability_handlers[ability]
                message = await handler(duel, user_id, card_power, interaction, card_name, opponent)
            else:
                # Standard attack or healing
                if card_type == "Heilung":
                    if user_id == duel["challenger_id"]:
                        duel["challenger_health"] += card_power
                    else:
                        duel["opponent_health"] += card_power
                    message = f"{interaction.user.mention} spielt **{card_name}** und heilt sich um {card_power} Punkte!"
                else:
                    damage = card_power
    
                    # Check for Curse Effect
                    if user_id == duel["challenger_id"] and duel.get("challenger_curse", 0) > 0:
                        damage -= duel["challenger_curse"]
                        duel["challenger_curse"] = max(0, duel["challenger_curse"] - 1)
                    elif user_id == duel["opponent_id"] and duel.get("opponent_curse", 0) > 0:
                        damage -= duel["opponent_curse"]
                        duel["opponent_curse"] = max(0, duel["opponent_curse"] - 1)
    
                    # Check for Phase Through Effect
                    if user_id == duel["challenger_id"] and duel.get("challenger_phase_through", False):
                        damage = card_power  # Ignore shield and block
                        duel["challenger_phase_through"] = False
                        message += f"\n✅ **Phase Through** aktiviert! Der Angriff ignoriert die Verteidigung."
                    elif user_id == duel["opponent_id"] and duel.get("opponent_phase_through", False):
                        damage = card_power
                        duel["opponent_phase_through"] = False
                        message += f"\n✅ **Phase Through** aktiviert! Der Angriff ignoriert die Verteidigung."
    
                    # Apply Damage Reductions and Protections
                    if user_id == duel["challenger_id"]:
                        if duel.get("opponent_block", 0):
                            duel["opponent_block"] = 0
                            message = f"{opponent.mention} hat den Angriff mit einem Block abgewehrt!"
                        else:
                            if duel.get("opponent_shield", 0) > 0:
                                shield = duel["opponent_shield"]
                                if damage >= shield:
                                    damage -= shield
                                    duel["opponent_shield"] = 0
                                else:
                                    duel["opponent_shield"] -= damage
                                    damage = 0
                            if duel.get("opponent_sound_aggression", 0) > 0:
                                damage -= duel["opponent_sound_aggression"]
                                duel["opponent_sound_aggression"] = 0
                            if duel.get("opponent_marked", 0) > 0:
                                damage += 8  # Adjusted for reduced overall damage
                                duel["opponent_marked"] = 0
                            if duel.get("opponent_hide", False):
                                damage = max(0, damage - 8)  # Reduce damage by 8 if opponent is hiding
                                duel["opponent_hide"] = False
                            duel["opponent_health"] -= damage
                            message = f"{interaction.user.mention} spielt **{card_name}** und fügt {opponent.mention} {damage} Schaden zu!"
                    else:
                        if duel.get("challenger_block", 0):
                            duel["challenger_block"] = 0
                            message = f"{opponent.mention} hat den Angriff mit einem Block abgewehrt!"
                        else:
                            if duel.get("challenger_shield", 0) > 0:
                                shield = duel["challenger_shield"]
                                if damage >= shield:
                                    damage -= shield
                                    duel["challenger_shield"] = 0
                                else:
                                    duel["challenger_shield"] -= damage
                                    damage = 0
                            if duel.get("challenger_sound_aggression", 0) > 0:
                                damage -= duel["challenger_sound_aggression"]
                                duel["challenger_sound_aggression"] = 0
                            if duel.get("challenger_marked", 0) > 0:
                                damage += 8
                                duel["challenger_marked"] = 0
                            if duel.get("challenger_hide", False):
                                damage = max(0, damage - 8)
                                duel["challenger_hide"] = False
                            duel["challenger_health"] -= damage
                            message = f"{interaction.user.mention} spielt **{card_name}** und fügt {opponent.mention} {damage} Schaden zu!"
    
            # Additional Effects Checks
    
            # Burn Effect
            if user_id == duel["challenger_id"] and duel.get("opponent_burn_turns", 0) > 0:
                burn_damage = duel["opponent_burn"]
                duel["opponent_health"] -= burn_damage
                duel["opponent_burn_turns"] -= 1
                message += f"\n🔥 {opponent.mention} erleidet {burn_damage} Verbrennungsschaden!"
            elif user_id == duel["opponent_id"] and duel.get("challenger_burn_turns", 0) > 0:
                burn_damage = duel["challenger_burn"]
                duel["challenger_health"] -= burn_damage
                duel["challenger_burn_turns"] -= 1
                message += f"\n🔥 {opponent.mention} erleidet {burn_damage} Verbrennungsschaden!"
    
            # Frozen Effects
            if user_id == duel["challenger_id"] and duel.get("opponent_frozen", False):
                duel["opponent_frozen"] = False
                duel["turn_id"] = user_id  # Player gets another turn
                message += f"\n❄️ {opponent.mention} ist eingefroren und kann nicht handeln!"
            elif user_id == duel["opponent_id"] and duel.get("challenger_frozen", False):
                duel["challenger_frozen"] = False
                duel["turn_id"] = user_id  # Player gets another turn
                message += f"\n❄️ {opponent.mention} ist eingefroren und kann nicht handeln!"
    
            # Fear Effects
            if user_id == duel["challenger_id"] and duel.get("opponent_fear", 0) > 0:
                duel["opponent_fear"] -= 1
                if duel["opponent_fear"] == 0:
                    message += f"\n😨 {opponent.mention} überwindet seine Angst und kann wieder handeln!"
            elif user_id == duel["opponent_id"] and duel.get("challenger_fear", 0) > 0:
                duel["challenger_fear"] -= 1
                if duel["challenger_fear"] == 0:
                    message += f"\n😨 {opponent.mention} überwindet seine Angst und kann wieder handeln!"
    
            # Silence Effects
            if user_id == duel["challenger_id"] and duel.get("opponent_silence", 0) > 0:
                duel["opponent_silence"] -= 1
                if duel["opponent_silence"] == 0:
                    message += f"\n🔇 {opponent.mention} kann wieder Fähigkeiten nutzen!"
            elif user_id == duel["opponent_id"] and duel.get("challenger_silence", 0) > 0:
                duel["challenger_silence"] -= 1
                if duel["challenger_silence"] == 0:
                    message += f"\n🔇 {opponent.mention} kann wieder Fähigkeiten nutzen!"
    
            # Dark Power Effects
            if user_id == duel["challenger_id"] and duel.get("challenger_dark_power", 0) > 0:
                card_power += 16  # Adjusted from +20 to +16 for 20% reduction
                duel["challenger_dark_power"] -= 1
                message += f"\n🌑 Dunkle Macht ist aktiviert! Deine Angriffskraft ist erhöht um 16 für diesen Zug."
            elif user_id == duel["opponent_id"] and duel.get("opponent_dark_power", 0) > 0:
                card_power += 16
                duel["opponent_dark_power"] -= 1
                message += f"\n🌑 Dunkle Macht ist aktiviert! Deine Angriffskraft ist erhöht um 16 für diesen Zug."
    
            return message
    
        # Ability Handlers
        async def handle_lifesteal(self, duel, user_id, card_power, interaction, card_name, opponent):
            damage = card_power
            if user_id == duel["challenger_id"]:
                duel["opponent_health"] -= damage
                duel["challenger_health"] += damage // 2
            else:
                duel["challenger_health"] -= damage
                duel["opponent_health"] += damage // 2
            message = f"{interaction.user.mention} spielt **{card_name}** und stiehlt {damage // 2} Gesundheit!"
            return message
    
        async def handle_shield(self, duel, user_id, card_power, interaction, card_name, opponent):
            if user_id == duel["challenger_id"]:
                duel["challenger_shield"] += card_power
            else:
                duel["opponent_shield"] += card_power
            message = f"{interaction.user.mention} spielt **{card_name}** und erhält einen Schild von {card_power}!"
            return message
    
        async def handle_block(self, duel, user_id, card_power, interaction, card_name, opponent):
            if user_id == duel["challenger_id"]:
                duel["challenger_block"] = 1
            else:
                duel["opponent_block"] = 1
            message = f"{interaction.user.mention} spielt **{card_name}** und blockiert den nächsten Angriff!"
            return message
    
        async def handle_ignore_defense(self, duel, user_id, card_power, interaction, card_name, opponent):
            damage = card_power
            if user_id == duel["challenger_id"]:
                duel["opponent_health"] -= damage
            else:
                duel["challenger_health"] -= damage
            message = f"{interaction.user.mention} spielt **{card_name}** und ignoriert alle Verteidigung, fügt {damage} Schaden zu!"
            return message
    
        async def handle_burn(self, duel, user_id, card_power, interaction, card_name, opponent):
            damage = card_power
            burn_amount = 15  # Reduced from 20 to 15
            burn_turns = 2
            if user_id == duel["challenger_id"]:
                duel["opponent_health"] -= damage
                duel["opponent_burn"] = burn_amount
                duel["opponent_burn_turns"] = burn_turns
            else:
                duel["challenger_health"] -= damage
                duel["challenger_burn"] = burn_amount
                duel["challenger_burn_turns"] = burn_turns
            message = f"{interaction.user.mention} spielt **{card_name}** und verbrennt den Gegner, fügt {damage} Schaden zu!"
            return message
    
        async def handle_revive(self, duel, user_id, card_power, interaction, card_name, opponent):
            heal_amount = 40  # Reduced from 50 to 40
            if user_id == duel["challenger_id"]:
                duel["challenger_health"] += heal_amount
            else:
                duel["opponent_health"] += heal_amount
            message = f"{interaction.user.mention} spielt **{card_name}** und belebt sich selbst, erhält {heal_amount} Gesundheit zurück!"
            return message
    
        async def handle_curse(self, duel, user_id, card_power, interaction, card_name, opponent):
            curse_amount = 16  # Reduced from 20 to 16
            curse_turns = 2
            if user_id == duel["challenger_id"]:
                duel["opponent_curse"] = curse_amount
                duel["opponent_curse_turns"] = curse_turns
            else:
                duel["challenger_curse"] = curse_amount
                duel["challenger_curse_turns"] = curse_turns
            message = f"{interaction.user.mention} spielt **{card_name}** und verflucht den Gegner!"
            return message
    
        async def handle_shadow_strike(self, duel, user_id, card_power, interaction, card_name, opponent):
            total_damage = card_power * 2
            if user_id == duel["challenger_id"]:
                duel["opponent_health"] -= total_damage
            else:
                duel["challenger_health"] -= total_damage
            message = f"{interaction.user.mention} spielt **{card_name}** und schlägt zweimal zu, fügt insgesamt {total_damage} Schaden zu!"
            return message
    
        async def handle_frost_nova(self, duel, user_id, card_power, interaction, card_name, opponent):
            if user_id == duel["challenger_id"]:
                duel["opponent_frozen"] = True
            else:
                duel["challenger_frozen"] = True
            message = f"{interaction.user.mention} spielt **{card_name}** und friert den Gegner ein!"
            return message
    
        async def handle_mana_burn(self, duel, user_id, card_power, interaction, card_name, opponent):
            opponent_id = duel["opponent_id"] if user_id == duel["challenger_id"] else duel["challenger_id"]
            opponent_cards = self.get_player_cards(opponent_id)
            if opponent_cards:
                random_card = random.choice(opponent_cards)
                self.remove_card_from_player(opponent_id, random_card[0])
                message = f"{interaction.user.mention} spielt **{card_name}** und verbrennt die Karte **{random_card[0]}** des Gegners!"
            else:
                message = f"{interaction.user.mention} spielt **{card_name}**, aber der Gegner hat keine Karten mehr!"
            return message
    
        async def handle_fear(self, duel, user_id, card_power, interaction, card_name, opponent):
            if user_id == duel["challenger_id"]:
                duel["opponent_fear"] = 1  # Opponent skips next turn
            else:
                duel["challenger_fear"] = 1
            message = f"{interaction.user.mention} spielt **{card_name}** und verursacht Angst beim Gegner! Der Gegner überspringt seinen nächsten Zug."
            return message
    
        async def handle_silence(self, duel, user_id, card_power, interaction, card_name, opponent):
            if user_id == duel["challenger_id"]:
                duel["opponent_silence"] = 2  # Opponent cannot use abilities for 2 turns
            else:
                duel["challenger_silence"] = 2
            message = f"{interaction.user.mention} spielt **{card_name}** und verstummt den Gegner! Der Gegner kann für die nächsten 2 Züge keine Fähigkeiten nutzen."
            return message
    
        async def handle_summon(self, duel, user_id, card_power, interaction, card_name, opponent):
            summon_health = 80  # Reduced from 100 to 80
            if user_id == duel["challenger_id"]:
                duel["challenger_health"] += summon_health
            else:
                duel["opponent_health"] += summon_health
            message = f"{interaction.user.mention} spielt **{card_name}** und beschwört einen zusätzlichen Geist, der dem Spieler {summon_health} Gesundheit verleiht!"
            return message
    
        async def handle_drain_soul(self, duel, user_id, card_power, interaction, card_name, opponent):
            damage = card_power
            if user_id == duel["challenger_id"]:
                duel["opponent_health"] -= damage
                duel["challenger_health"] += damage
            else:
                duel["challenger_health"] -= damage
                duel["opponent_health"] += damage
            message = f"{interaction.user.mention} spielt **{card_name}** und saugt {damage} Gesundheit vom Gegner!"
            return message
    
        async def handle_throw_objects(self, duel, user_id, card_power, interaction, card_name, opponent):
            damage = card_power + 8  # Adjusted from +10 to +8
            if user_id == duel["challenger_id"]:
                duel["opponent_health"] -= damage
            else:
                duel["challenger_health"] -= damage
            message = f"{interaction.user.mention} spielt **{card_name}** und wirft Objekte, fügt {damage} Schaden zu!"
            return message
    
        async def handle_hide_presence(self, duel, user_id, card_power, interaction, card_name, opponent):
            if user_id == duel["challenger_id"]:
                duel["challenger_hide"] = True
            else:
                duel["opponent_hide"] = True
            message = f"{interaction.user.mention} spielt **{card_name}** und verbirgt ihre Präsenz, wodurch der Gegner weniger Schaden verursacht!"
            return message
    
        async def handle_mark_target(self, duel, user_id, card_power, interaction, card_name, opponent):
            if user_id == duel["challenger_id"]:
                duel["opponent_marked"] = 1
            else:
                duel["challenger_marked"] = 1
            message = f"{interaction.user.mention} spielt **{card_name}** und markiert den Gegner! Der markierte Gegner erleidet mehr Schaden in den nächsten Zügen."
            return message
    
        async def handle_dark_power(self, duel, user_id, card_power, interaction, card_name, opponent):
            if user_id == duel["challenger_id"]:
                duel["challenger_dark_power"] = 2  # Increase attack power for 2 turns
            else:
                duel["opponent_dark_power"] = 2
            message = f"{interaction.user.mention} spielt **{card_name}** und aktiviert dunkle Macht! Die Angriffskraft wird für die nächsten 2 Züge erhöht."
            return message
    
        async def handle_swift_strike(self, duel, user_id, card_power, interaction, card_name, opponent):
            if user_id == duel["challenger_id"]:
                duel["challenger_speed_boost"] = True
            else:
                duel["opponent_speed_boost"] = True
            message = f"{interaction.user.mention} spielt **{card_name}** und führt einen schnellen Schlag aus, ermöglicht einen sofortigen zusätzlichen Zug!"
            return message
    
        async def handle_relentless(self, duel, user_id, card_power, interaction, card_name, opponent):
            if user_id == duel["challenger_id"]:
                duel["challenger_relentless"] = True
            else:
                duel["opponent_relentless"] = True
            message = f"{interaction.user.mention} spielt **{card_name}** und bleibt unermüdlich! Selbst wenn die Gesundheit unter 0 fällt, kannst du weiterkämpfen."
            return message
    
        async def handle_sanity_drain(self, duel, user_id, card_power, interaction, card_name, opponent):
            if user_id == duel["challenger_id"]:
                duel["opponent_sanity_drain"] = 16  # Reduced from 20 to 16
            else:
                duel["challenger_sanity_drain"] = 16
            message = f"{interaction.user.mention} spielt **{card_name}** und entzieht dem Gegner geistige Stärke! Der Gegner verursacht weniger Schaden."
            return message
    
        async def handle_speed_boost(self, duel, user_id, card_power, interaction, card_name, opponent):
            if user_id == duel["challenger_id"]:
                duel["challenger_speed_boost"] = True
            else:
                duel["opponent_speed_boost"] = True
            message = f"{interaction.user.mention} spielt **{card_name}** und erhöht die Geschwindigkeit! Du bist im nächsten Zug schneller dran."
            return message
    
        async def handle_phase_through(self, duel, user_id, card_power, interaction, card_name, opponent):
            if user_id == duel["challenger_id"]:
                duel["challenger_phase_through"] = True
            else:
                duel["opponent_phase_through"] = True
            message = f"{interaction.user.mention} spielt **{card_name}** und durchdringt die Verteidigung des Gegners, fügt sofort Schaden zu!"
            return message
    
        async def handle_sound_aggression(self, duel, user_id, card_power, interaction, card_name, opponent):
            aggression_amount = 8  # Reduced from 10 to 8
            if user_id == duel["challenger_id"]:
                duel["opponent_sound_aggression"] = aggression_amount  # Reduces next damage by 8
            else:
                duel["challenger_sound_aggression"] = aggression_amount
            message = f"{interaction.user.mention} spielt **{card_name}** und agitert den Gegner durch Lärm! Der nächste Schaden des Gegners wird um {aggression_amount} reduziert."
            return message
    
        async def handle_cold_speed(self, duel, user_id, card_power, interaction, card_name, opponent):
            cold_speed_turns = 2
            if user_id == duel["challenger_id"]:
                duel["challenger_cold_speed"] = cold_speed_turns
            else:
                duel["opponent_cold_speed"] = cold_speed_turns
            message = f"{interaction.user.mention} spielt **{card_name}** und aktiviert kalte Geschwindigkeit! Du darfst die nächsten {cold_speed_turns} Züge schneller angreifen."
            return message
    
        @commands.slash_command(name="singleplayer", description="Tritt gegen ein gespenstisches Wesen im Einzelspielermodus an!")
        async def singleplayer_duel(self, ctx):
            user_id = ctx.user.id
    
            if not self.get_player(user_id):
                self.create_player(user_id)
    
            ai_health = 200
            player_health = 200
    
            # Create a thread for the singleplayer duel
            thread_name = f"Singleplayer-Duell von {ctx.user.display_name}"
            thread = await ctx.channel.create_thread(name=thread_name, type=discord.ChannelType.public_thread)
    
            self.singleplayer_sessions[user_id] = {
                "player_health": player_health,
                "ai_health": ai_health,
                "turn": user_id,
                "thread_id": thread.id,
                "start_time": int(time.time()),
                "ai_cooldowns": {},  # For future extensions
                "ai_status_effects": {}
            }
    
            await thread.send(
                f"👻 Das gespenstische Wesen fordert dich heraus, {ctx.user.mention}!\n"
                "Möge der Mutigste gewinnen! Nutze `/sp_play` hier im Thread, um zu beginnen."
            )
    
            await ctx.respond(f"Ein Thread wurde erstellt für dein Duell: {thread.mention}", ephemeral=True)
    
        @commands.slash_command(name="sp_play", description="Spiele eine Karte gegen das gespenstische Wesen.")
        async def singleplayer_play(self, ctx):
            user_id = ctx.user.id
            session = self.singleplayer_sessions.get(user_id)
    
            if not session:
                await ctx.respond("Du bist in keinem Einzelspieler-Duellt. Nutze `/singleplayer`, um ein neues Duell zu starten.", ephemeral=True)
                return
    
            # Check if the command is used in the correct thread
            if ctx.channel.id != session["thread_id"]:
                await ctx.respond("Bitte nutze diesen Befehl im Thread deines Einzelspieler-Duells.", ephemeral=True)
                return
    
            player_cards = self.get_player_cards(user_id)
            if not player_cards:
                # Assign a card if player has none
                card = self.draw_random_card()
                self.add_card_to_player(user_id, card['name'])
                player_cards = self.get_player_cards(user_id)
                await ctx.channel.send(f"{ctx.user.mention} hat keine Karten mehr! Es wurde eine **{card['name']}** ({card['rarity']}) hinzugefügt.")
    
            if not player_cards:
                await ctx.respond("Du hast keine Karten mehr zum Spielen!", ephemeral=True)
                del self.singleplayer_sessions[user_id]
                return
    
            if session["ai_health"] <= 0 or session["player_health"] <= 0:
                await ctx.respond("Das Duell ist bereits beendet.", ephemeral=True)
                return
    
            async def card_select_callback(interaction: discord.Interaction):
                selected_index = int(interaction.data['values'][0])
                selected_card = player_cards[selected_index]
                card_name = selected_card[0]
                card_power = selected_card[2]
                card_type = selected_card[1]
                card_description = selected_card[4]
    
                self.remove_card_from_player(user_id, card_name)
    
                # Apply card effects
                if card_type == "Heilung":
                    session["player_health"] += card_power
                    message = f"{interaction.user.mention} spielt **{card_name}** und heilt sich um {card_power} Punkte!"
                else:
                    session["ai_health"] -= card_power
                    message = f"{interaction.user.mention} spielt **{card_name}** und fügt dem gespenstischen Wesen {card_power} Schaden zu!"
    
                await interaction.response.send_message(
                    f"{message}\n\nBeschreibung: {card_description}",
                    ephemeral=False
                )
    
                if session["ai_health"] <= 0:
                    num_new_cards = random.randint(1, 5)
                    new_cards = self.assign_new_cards(user_id, num_new_cards)
                    if new_cards:
                        new_cards_text = ", ".join(new_cards)
                        await interaction.followup.send(
                            f"🎉 Glückwunsch {interaction.user.mention}! Du hast das gespenstische Duell gewonnen und erhältst 25 Münzen und 50 XP! Außerdem hast du {num_new_cards} neue Karte(n) erhalten: {new_cards_text} 🎃",
                            ephemeral=False
                        )
                    else:
                        await interaction.followup.send(
                            f"🎉 Glückwunsch {interaction.user.mention}! Du hast das gespenstische Duell gewonnen und erhältst 25 Münzen und 50 XP! 🎃",
                            ephemeral=False
                        )
                    self.update_coins(user_id, 25)
                    self.update_xp(user_id, 50)
                    del self.singleplayer_sessions[user_id]
                    # Delete the thread
                    thread = self.bot.get_channel(session["thread_id"])
                    if thread:
                        try:
                            await asyncio.sleep(5)
                            await thread.delete()
                        except Exception as e:
                            print(f"Error deleting thread {session['thread_id']}: {e}")
                    return
    
                # AI Turn
                ai_card = self.select_ai_card(session)
                if ai_card["type"] == "Heilung":
                    session["ai_health"] += ai_card['power']
                    ai_message = f"👻 Das gespenstische Wesen spielt **{ai_card['name']}** und heilt sich um {ai_card['power']} Punkte!"
                else:
                    session["player_health"] -= ai_card['power']
                    ai_message = f"👻 Das gespenstische Wesen spielt **{ai_card['name']}** und fügt dir {ai_card['power']} Schaden zu!"
    
                await interaction.followup.send(
                    f"{ai_message}\n\nBeschreibung: {ai_card['description']}",
                    ephemeral=False
                )
    
                if session["player_health"] <= 0:
                    await interaction.followup.send("💀 Du wurdest vom gespenstischen Wesen besiegt!", ephemeral=False)
                    del self.singleplayer_sessions[user_id]
                    # Delete the thread
                    thread = self.bot.get_channel(session["thread_id"])
                    if thread:
                        try:
                            await asyncio.sleep(5)
                            await thread.delete()
                        except Exception as e:
                            print(f"Error deleting thread {session['thread_id']}: {e}")
                    return
    
                await interaction.followup.send(
                    f"🧟 Deine Gesundheit: {session['player_health']} | Gesundheit des Wesens: {session['ai_health']}\n"
                    "Nutze `/sp_play`, um deine nächste Karte zu spielen.",
                    ephemeral=False
                )
    
            await self.card_selection_view(ctx, player_cards, card_select_callback)
    
        def select_ai_card(self, session):
            # Enhanced AI: Strategy based on current health
            ai_health = session["ai_health"]
            player_health = session["player_health"]
    
            available_ai_cards = [card for card in cards]  # AI can use any card
    
            # Prioritize healing if AI health is low
            if ai_health < 100:
                heal_cards = [card for card in available_ai_cards if card['type'] == 'Heilung']
                if heal_cards:
                    return random.choice(heal_cards)
    
            # Otherwise, choose the strongest available attack card
            attack_cards = [card for card in available_ai_cards if card['type'] != 'Heilung']
            if attack_cards:
                strongest_card = max(attack_cards, key=lambda x: x['power'])
                return strongest_card
    
            # Fallback: Play a random card
            return random.choice(available_ai_cards) if available_ai_cards else {"name": "Keine Karte", "type": "Geist", "power": 0, "rarity": "common", "description": "Keine verfügbaren Karten.", "ability": None}
    
        @commands.slash_command(name="profile", description="Zeige dein schauriges Spielerprofil an.")
        async def profile(self, ctx, member: discord.Member = None):
            if member is None:
                member = ctx.user
    
            user_id = member.id
            player = self.get_player(user_id)
            if not player:
                await ctx.respond("Dieser Spieler hat noch kein Profil.", ephemeral=True)
                return
    
            coins = player[0][3]
            xp = player[0][4]
            level = player[0][5]
            card_count = self.db.execute_with_connection(
                "SELECT COUNT(*) FROM player_cards WHERE player_id = ?",
                (player[0][0],)
            )[0][0]
    
            profile_embed = discord.Embed(title=f"🦇 Profil von {member.display_name} 🦇", color=discord.Color.purple())
            profile_embed.add_field(name="Level", value=f"{level}", inline=True)
            profile_embed.add_field(name="XP", value=f"{xp}", inline=True)
            profile_embed.add_field(name="Münzen", value=f"{coins}", inline=True)
            profile_embed.add_field(name="Anzahl Karten", value=f"{card_count}", inline=True)
    
            await ctx.respond(embed=profile_embed, ephemeral=True)
    
        @commands.slash_command(name="collection", description="Zeige deine gespenstische Kartensammlung an.")
        async def collection(self, ctx):
            user_id = ctx.user.id
            player_cards = self.get_player_cards(user_id)
    
            if not player_cards:
                await ctx.respond("Du hast noch keine Karten. Nutze `/draw`, um Karten zu ziehen.", ephemeral=True)
                return
    
            collection_embed = discord.Embed(title=f"📜 Kartensammlung von {ctx.user.display_name} 📜", color=discord.Color.blue())
    
            for card in player_cards:
                collection_embed.add_field(name=f"{card[0]} (x{card[5]}) [{card[3]}]", value=f"Typ: {card[1]}, Power: {card[2]}\nBeschreibung: {card[4]}", inline=False)
    
            await ctx.respond(embed=collection_embed, ephemeral=True)
    
        @commands.slash_command(name="leaderboard", description="Zeige die Münzen-Bestenliste an.")
        async def leaderboard(self, ctx):
            top_players = self.db.execute_with_connection(
                "SELECT user_id, coins FROM players ORDER BY coins DESC LIMIT 10"
            )
    
            leaderboard_embed = discord.Embed(title="🏆 Bestenliste der Münzen 🏆", color=discord.Color.gold())
    
            for idx, (user_id, coins) in enumerate(top_players, start=1):
                user = self.bot.get_user(user_id)
                if user:
                    leaderboard_embed.add_field(name=f"{idx}. {user.display_name}", value=f"Münzen: {coins}", inline=False)
                else:
                    leaderboard_embed.add_field(name=f"{idx}. Unbekannt", value=f"Münzen: {coins}", inline=False)
    
            await ctx.respond(embed=leaderboard_embed, ephemeral=True)
    
        @commands.slash_command(name="shop", description="Betritt den verfluchten Shop der Schatten.")
        async def shop(self, ctx):
            coins = self.fetch_player_coins(ctx.user.id)
            shop_embed = discord.Embed(title="🎩 Verfluchter Shop der Schatten 🎩", description="Folgende düstere Gegenstände kannst du erwerben:", color=discord.Color.orange())
            items = {
                "Kartenpack": 100,
                "Spezielle Rolle": 3000  # Increased price from 1500 to 3000
            }
    
            for item, price in items.items():
                shop_embed.add_field(name=item, value=f"Preis: {price} Münzen", inline=False)
    
            class ShopView(discord.ui.View):
                def __init__(self, cog):
                    super().__init__(timeout=60)
                    self.cog = cog
    
                @discord.ui.button(label="Kartenpack kaufen", style=discord.ButtonStyle.green)
                async def pack_button_callback(self, button: discord.ui.Button, interaction: discord.Interaction):
                    player_coins = self.cog.fetch_player_coins(interaction.user.id)
                    if player_coins >= 100:
                        self.cog.update_coins(interaction.user.id, -100)
                        drawn_cards = []
                        for _ in range(3):
                            card = self.cog.draw_random_card()
                            if self.cog.add_card_to_player(interaction.user.id, card['name']):
                                drawn_cards.append(f"{card['name']} ({card['rarity']})")
                        cards_text = ", ".join(drawn_cards) if drawn_cards else "keine neuen Karten."
                        await interaction.response.send_message(
                            f"🃏 Du hast ein Kartenpack für 100 Münzen gekauft und folgende Karten erhalten: {cards_text}",
                            ephemeral=True
                        )
                    else:
                        await interaction.response.send_message(
                            "Du hast nicht genügend Münzen, um ein Kartenpack zu kaufen.",
                            ephemeral=True
                        )
    
                @discord.ui.button(label="Spezielle Rolle kaufen", style=discord.ButtonStyle.blurple)
                async def role_button_callback(self, button: discord.ui.Button, interaction: discord.Interaction):
                    player_coins = self.cog.fetch_player_coins(interaction.user.id)
                    if player_coins >= 3000:  # Updated to 3000 coins
                        role = interaction.guild.get_role(1285273226280435883)  # Ensure this ID is correct
                        if role:
                            if role in interaction.user.roles:
                                await interaction.response.send_message(
                                    "Du besitzt diese Rolle bereits.",
                                    ephemeral=True
                                )
                            else:
                                await interaction.user.add_roles(role)
                                self.cog.update_coins(interaction.user.id, -3000)  # Deduct 3000 coins
                                await interaction.response.send_message(
                                    f"✨ Du hast erfolgreich die Rolle {role.name} für 3.000 Münzen gekauft!",
                                    ephemeral=True
                                )
                        else:
                            await interaction.response.send_message(
                                "Die Rolle konnte nicht gefunden werden.",
                                ephemeral=True
                            )
                    else:
                        await interaction.response.send_message(
                            "Du hast nicht genügend Münzen, um diese Rolle zu kaufen.",
                            ephemeral=True
                        )
    
            await ctx.respond(f"💰 Du hast {coins} Münzen.", embed=shop_embed, view=ShopView(self), ephemeral=True)
    
        @commands.slash_command(name="draw", description="Ziehe 1 bis 3 Karten.")
        async def draw_cards(self, ctx):
            user_id = ctx.user.id
            player = self.get_player(user_id)
    
            if not player:
                self.create_player(user_id)
                player = self.get_player(user_id)
    
            last_draw_time = player[0][6]
            current_time = int(time.time())
    
            if current_time - last_draw_time < 600:  # 10 Minutes
                remaining_time = 600 - (current_time - last_draw_time)
                minutes = remaining_time // 60
                seconds = remaining_time % 60
                await ctx.respond(f"🕒 Du kannst wieder Karten ziehen in {minutes} Minuten und {seconds} Sekunden.", ephemeral=True)
                return
    
            drawn_cards = []
            for _ in range(random.randint(1, 3)):
                card = self.draw_random_card()
                self.add_card_to_player(user_id, card['name'])
                drawn_cards.append(f"{card['name']} ({card['rarity']})")
    
            self.update_last_draw_time(user_id, current_time)
            await ctx.respond(f"🃏 Du hast folgende Karten gezogen: {', '.join(drawn_cards)}", ephemeral=True)
    
        @commands.slash_command(name="work", description="Verdiene 50-100 Münzen durch harte Arbeit! (Cooldown: 1 Stunde)")
        async def work(self, ctx):
            user_id = ctx.user.id
            player = self.get_player(user_id)
            if not player:
                self.create_player(user_id)
                player = self.get_player(user_id)
            last_work_time = player[0][9]
            current_time = int(time.time())
            if current_time - last_work_time < 3600:
                remaining_time = 3600 - (current_time - last_work_time)
                minutes = remaining_time // 60
                seconds = remaining_time % 60
                await ctx.respond(f"🕒 Du kannst `/work` erst in {minutes} Minuten und {seconds} Sekunden erneut nutzen.", ephemeral=True)
                return
            earned_coins = random.randint(50, 100)
            self.update_coins(user_id, earned_coins)
            self.update_last_work_time(user_id, current_time)
            await ctx.respond(f"💼 Du hast hart gearbeitet und {earned_coins} Münzen verdient!", ephemeral=True)
    
        # Additional Commands and Methods can be added here as needed
    
    def setup(bot):
        bot.add_cog(Halloween(bot))
    

    Erläuterungen der Änderungen und Fehlerbehebungen:

    1. Indentation und Struktur: Der gesamte Code wurde korrekt eingerückt, sodass Klassen und Methoden richtig verschachtelt sind. Dies ist essenziell für Python-Code.

    2. Import Statements: Alle notwendigen Module (discord, commands, tasks usw.) wurden hinzugefügt, um sicherzustellen, dass der Code ohne Importfehler läuft.

    3. Korrekte Initialisierung: Die __init__ Methode der DatabaseManager Klasse wurde richtig benannt und korrekt initialisiert. Ebenso wurde die __init__ Methode der Halloween Cog-Klasse korrekt implementiert.

    4. Callback-Funktionen: Die Methoden card_select_callback und apply_card_effects wurden nun als separate Methoden innerhalb der Halloween Klasse implementiert. In der play_card Methode wird card_select_callback als Callback an die card_selection_view übergeben, was sicherstellt, dass sie korrekt aufgerufen wird.

    5. Fehlerbehandlung: Der Code enthält jetzt zusätzliche try-except Blöcke, insbesondere beim Löschen von Threads, um sicherzustellen, dass mögliche Ausnahmen nicht unbemerkt bleiben.

    6. Interaktionszeit: Die play_card Methode verwendet ctx.respond und interaction.response.send_message ordnungsgemäß, um sicherzustellen, dass Discord innerhalb der vorgegebenen Zeit reagiert und keine "The application did not respond" Fehler auftreten.

    7. Datenbankfunktionen: Alle Datenbankzugriffe sind nun korrekt verwaltet, mit sicheren Methoden zum Einfügen, Aktualisieren und Abrufen von Daten.

    8. Weitere Verbesserungen:

      • Die /draw-Methode wurde angepasst, um eine variable Anzahl von Karten (1 bis 3) zu ziehen.
      • In der /shop-Methode wurde der Preis der "Spezielle Rolle" auf 3000 Münzen erhöht und eine entsprechende Kommentarzeile hinzugefügt.
      • Die apply_card_effects Methode wurde überarbeitet, um sicherzustellen, dass alle Karteneffekte korrekt angewendet werden.

    Hinweis: Stellen Sie sicher, dass die Rollen-ID (1285273226280435883) in der shop Methode korrekt ist und der Bot die notwendigen Berechtigungen hat, um Rollen zu verwalten und Threads zu erstellen/löschen.

    Weitere Empfehlungen:

    • Logging: Implementieren Sie ein Logging-System, um Fehler leichter nachverfolgen zu können, anstatt sich nur auf print-Anweisungen zu verlassen.

    • Datenbankoptimierungen: Überlegen Sie, ob einige der Datenbankabfragen optimiert oder ausgelagert werden können, insbesondere bei häufig genutzten Funktionen.

    • Erweiterte Fehlerbehandlung: Fügen Sie zusätzliche Fehlerprüfungen hinzu, um sicherzustellen, dass alle Datenbankoperationen und Discord-Interaktionen reibungslos verlaufen.

    • Testing: Testen Sie alle Funktionen gründlich in einer sicheren Umgebung, bevor Sie den Bot live schalten, um sicherzustellen, dass alle Befehle wie erwartet funktionieren.

    Mit diesen Änderungen sollte Ihr Discord-Bot stabiler laufen, und die spezifischen Probleme mit dem /play Befehl sowie den nicht verwendeten Methoden sollten behoben sein.