Untitled

import discord
from discord.ext import commands
from discord.ui import Button, Modal, TextInput
import asyncio
import random
import os
import json
from together import Together
from points_manager import PointsManager

class SubmissionModal(Modal):
    def __init__(self, clash_cog):
        super().__init__(title="Submit Your Creation")
        self.clash_cog = clash_cog
        self.creation_input = TextInput(
            label="Your Creation",
            placeholder="Enter your creation's name and key features",
            style=discord.TextStyle.long,
            max_length=200,
            required=True
        )
        self.add_item(self.creation_input)

    async def on_submit(self, interaction: discord.Interaction):
        creation = self.creation_input.value.strip()
        if not creation:
            await interaction.response.send_message("Creation cannot be empty!", ephemeral=True)
            return

        if interaction.user.id in self.clash_cog.submissions:
            await interaction.response.send_message("You've already submitted a creation!", ephemeral=True)
            return

        self.clash_cog.submissions[interaction.user.id] = {
            'name': creation,
            'power': random.randint(60, 100),
            'special_moves': random.randint(1, 3),
            'durability': random.randint(70, 100)
        }
        
        await interaction.response.send_message(
            f"✅ Your creation **{creation}** has been registered for battle!", 
            ephemeral=True
        )

class BattleSystem:
    def __init__(self):
        self.status_effects = ['stunned', 'powered_up', 'weakened']
        self.critical_threshold = 85

    def calculate_damage(self, attacker, defender, is_comeback=False):
        base_damage = attacker['power'] * random.uniform(0.8, 1.2)
        
        if random.randint(1, 100) > self.critical_threshold:
            base_damage *= 1.5
            
        if is_comeback:
            base_damage *= 1.3
            
        defense = defender['durability'] * random.uniform(0.7, 1.0)
        return max(int(base_damage - defense), 10)

    def generate_battle_stats(self, creation1, creation2):
        return {
            'rounds': random.randint(2, 4),
            'status_effects': random.sample(self.status_effects, 1)[0],
            'special_move_chance': 0.3
        }

class Clash(commands.Cog):
    def __init__(self, bot):
        self.bot = bot
        self.together_client = Together(api_key="")
        self.submissions = {}
        self.battle_system = BattleSystem()
        self.points_manager = PointsManager()
        self.winners = self.load_json("winners.json")
        self.game_active = False
        self.current_round = 0
        self.eliminated_players = []
        self.battle_logs = []

    def load_json(self, filename):
        if os.path.exists(filename):
            with open(filename, "r") as file:
                return json.load(file)
        return {}

    def save_json(self, filename, data):
        with open(filename, "w") as file:
            json.dump(data, file, indent=4)

    async def generate_battle_narrative(self, attacker, defender, damage, battle_stats):
        base_prompts = [
            f"{attacker['name']} unleashes a devastating attack on {defender['name']}, dealing {damage} damage!",
            f"In a brilliant display of power, {attacker['name']} strikes {defender['name']} for {damage} points!",
            f"{attacker['name']} executes a perfect maneuver against {defender['name']}, causing {damage} damage!"
        ]
        
        if damage > 50:
            base_prompts.append(f"An extraordinary move by {attacker['name']} deals a massive {damage} damage to {defender['name']}!")
        
        if battle_stats['status_effects'] == 'powered_up':
            base_prompts.append(f"{attacker['name']} enters a powered-up state, enhancing their next attack!")
            
        return random.choice(base_prompts)

    async def process_battle(self, ctx, battle_entries):
        self.current_round += 1
        next_round = []
        eliminated_this_round = []

        round_embed = discord.Embed(
            title=f"⚔️ Round {self.current_round}",
            description=f"**{len(battle_entries)} Creations Remain**",
            color=discord.Color.gold()
        )
        await ctx.send(embed=round_embed)

        for i in range(0, len(battle_entries) - 1, 2):
            user1, creation1 = battle_entries[i]
            user2, creation2 = battle_entries[i + 1]
            
            battle_stats = self.battle_system.generate_battle_stats(creation1, creation2)
            hp1, hp2 = 100, 100
            battle_log = []

            while hp1 > 0 and hp2 > 0:
                for attacker, defender, atk_hp, def_hp in [(creation1, creation2, hp1, hp2), (creation2, creation1, hp2, hp1)]:
                    if atk_hp <= 0:
                        continue
                        
                    damage = self.battle_system.calculate_damage(attacker, defender)
                    narrative = await self.generate_battle_narrative(attacker, defender, damage, battle_stats)
                    battle_log.append(narrative)
                    
                    if attacker == creation1:
                        hp2 -= damage
                    else:
                        hp1 -= damage

            winner = (user1, creation1) if hp1 > hp2 else (user2, creation2)
            loser = (user2, creation2) if hp1 > hp2 else (user1, creation1)
            
            battle_embed = discord.Embed(
                title=f"⚔️ {creation1['name']} vs {creation2['name']}",
                description="\n".join(battle_log[-3:]),
                color=discord.Color.blue()
            )
            battle_embed.add_field(name="Winner", value=f"🏆 {winner[1]['name']}", inline=False)
            await ctx.send(embed=battle_embed)
            
            next_round.append(winner)
            eliminated_this_round.append(loser)

            await asyncio.sleep(2)

        comeback_chance = 0.3 if self.current_round > 1 else 0
        if random.random() < comeback_chance and eliminated_this_round:
            comeback_fighter = random.choice(eliminated_this_round)
            comeback_embed = discord.Embed(
                title="🔥 Dramatic Comeback!",
                description=f"**{comeback_fighter[1]['name']}** refuses to give up!",
                color=discord.Color.red()
            )
            await ctx.send(embed=comeback_embed)
            next_round.append(comeback_fighter)

        return next_round

    async def start_submission_phase(self, ctx, duration=120):
        embed = discord.Embed(
            title="🎮 Creation Submission Phase",
            description="Click below to submit your creation!",
            color=discord.Color.blue()
        )
        
        view = discord.ui.View(timeout=duration)
        submit_button = Button(
            label="Submit Creation",
            style=discord.ButtonStyle.primary,
            emoji="⚔️"
        )

        async def button_callback(interaction):
            if interaction.user.id in self.submissions:
                await interaction.response.send_message("You've already submitted!", ephemeral=True)
                return
            await interaction.response.send_modal(SubmissionModal(self))

        submit_button.callback = button_callback
        view.add_item(submit_button)
        
        await ctx.send(embed=embed, view=view)
        await asyncio.sleep(duration)
        
        return len(self.submissions) >= 2

    @commands.command()
    async def clash(self, ctx):
        if self.game_active:
            await ctx.send("❌ A clash is already in progress!")
            return

        self.game_active = True
        self.submissions.clear()
        self.current_round = 0
        self.eliminated_players.clear()
        self.battle_logs.clear()

        start_embed = discord.Embed(
            title="🎮 Clash of Creations",
            description="The tournament is about to begin!\nSubmit your creation to participate!",
            color=discord.Color.green()
        )
        await ctx.send(embed=start_embed)

        if not await self.start_submission_phase(ctx):
            await ctx.send("Not enough participants to start the clash!")
            self.game_active = False
            return

        battle_entries = [(user, self.submissions[user.id]) for user in ctx.guild.members if user.id in self.submissions]
        random.shuffle(battle_entries)

        while len(battle_entries) > 1:
            battle_entries = await self.process_battle(ctx, battle_entries)

        if battle_entries:
            winner = battle_entries[0]
            prize = 100 + (self.current_round * 20)
            
            winner_embed = discord.Embed(
                title="🏆 Champion of the Clash!",
                description=f"**{winner[1]['name']}** emerges victorious!",
                color=discord.Color.gold()
            )
            winner_embed.add_field(name="Prize", value=f"{prize} points")
            await ctx.send(embed=winner_embed)
            
            self.points_manager.add_points(ctx.guild.id, winner[0].id, prize)
            
            winner_id = str(winner[0].id)
            self.winners[winner_id] = self.winners.get(winner_id, 0) + 1
            self.save_json("winners.json", self.winners)

        self.game_active = False

    @commands.command()
    async def clash_stats(self, ctx):
        if not self.winners:
            await ctx.send("No clash statistics available yet!")
            return

        stats_embed = discord.Embed(
            title="Clash Statistics",
            color=discord.Color.blue()
        )
        
        sorted_winners = sorted(self.winners.items(), key=lambda x: x[1], reverse=True)
        
        for i, (user_id, wins) in enumerate(sorted_winners[:5], 1):
            user = await self.bot.fetch_user(int(user_id))
            stats_embed.add_field(
                name=f"#{i} {user.name}",
                value=f"Wins: {wins}",
                inline=False
            )

        await ctx.send(embed=stats_embed)

async def setup(bot):
    await bot.add_cog(Clash(bot))