Update sportbet.py

sportbet.py

@@ -1,217 +1,325 @@
 import discord
 from discord import app_commands
 import aiohttp
+import random
+import time
 import asyncio
-from datetime import datetime, timezone
-from cash import user_cash
 
-user_bets = {}
-
-async def fetch_nhl_scores():
-    async with aiohttp.ClientSession() as session:
-        async with session.get("https://nhl-score-api.herokuapp.com/api/scores/latest") as response:
-            return await response.json()
-
-class GameSelect(discord.ui.Select):
-    def __init__(self, games):
-        options = [
-            discord.SelectOption(
-                label=f"{game['teams']['away']['teamName']} vs {game['teams']['home']['teamName']}",
-                value=f"{game['teams']['away']['abbreviation']}_{game['teams']['home']['abbreviation']}",
-                description=f"Start time: <t:{int(datetime.fromisoformat(game['startTime'].replace('Z', '+00:00')).timestamp())}:R>"
-            ) for game in games
-        ]
-        super().__init__(placeholder="Select a game", options=options)
-
-class TeamSelect(discord.ui.Select):
-    def __init__(self, away_team, home_team):
-        options = [
-            discord.SelectOption(label=away_team['teamName'], value=away_team['abbreviation']),
-            discord.SelectOption(label=home_team['teamName'], value=home_team['abbreviation'])
-        ]
-        super().__init__(placeholder="Select a team to bet on", options=options)
-
-class BetModal(discord.ui.Modal, title="Place Your Bet"):
-    bet_amount = discord.ui.TextInput(label="Bet Amount", placeholder="Enter bet amount")
-
-    def __init__(self, team, user_id, game_data):
-        super().__init__()
-        self.team = team
-        self.user_id = user_id
-        self.game_data = game_data
-
-    async def on_submit(self, interaction: discord.Interaction):
-        try:
-            bet_amount = int(self.bet_amount.value)
-            if bet_amount <= 0:
-                raise ValueError("Bet more than 0 dollars")
-            if bet_amount > user_cash.get(self.user_id, 0):
-                raise ValueError("You are too poor. Check your balance and try again")
-
-            user_cash[self.user_id] -= bet_amount
-            await interaction.response.send_message(f"Bet placed on {self.team} for ${bet_amount}")
-            
-            user = await interaction.client.fetch_user(self.user_id)
-            embed = discord.Embed(title="Bet Placed", color=0x787878)
-            embed.add_field(name="Team", value=self.team, inline=False)
-            embed.add_field(name="Amount", value=f"${bet_amount}", inline=False)
-            embed.add_field(name="Game", value=f"{self.game_data['teams']['away']['teamName']} vs {self.game_data['teams']['home']['teamName']}", inline=False)
-            embed.add_field(name="Start Time", value=f"<t:{int(datetime.fromisoformat(self.game_data['startTime'].replace('Z', '+00:00')).timestamp())}:R>", inline=False)
-            await user.send(embed=embed)
-
-            if self.user_id not in user_bets:
-                user_bets[self.user_id] = []
-            user_bets[self.user_id].append({
-                "team": self.team,
-                "amount": bet_amount,
-                "game_data": self.game_data
-            })
-            
-            asyncio.create_task(self.monitor_game(interaction, bet_amount))
-        except ValueError as e:
-            await interaction.response.send_message(str(e), ephemeral=True)
+from cash import user_cash
 
-    async def monitor_game(self, interaction, bet_amount):
-        game_start = datetime.fromisoformat(self.game_data['startTime'].replace('Z', '+00:00'))
-        await asyncio.sleep((game_start - datetime.now(timezone.utc)).total_seconds())
+luck_multipliers = {}
+luck_expiration = {}
+luck_opportunities = {}
+used_luck_opportunities = {}
+first_luck_claimed = set()
+auto_roll_users = set()
 
-        user = await interaction.client.fetch_user(self.user_id)
-        await user.send(f"Your team {self.team} has started playing!")
+async def perform_roll(interaction: discord.Interaction):
+    async def fetch_data(url):
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as response:
+                if response.status == 200:
+                    return await response.json()
+                return None
 
-        previous_scores = {self.game_data['teams']['away']['abbreviation']: 0, self.game_data['teams']['home']['abbreviation']: 0}
+    rap_data = await fetch_data("https://rapapi.deno.dev/")
+    collection_data = await fetch_data("https://petsapi.deno.dev/")
 
-        while True:
-            scores = await fetch_nhl_scores()
-            game = next((g for g in scores['games'] if g['teams']['away']['abbreviation'] == self.game_data['teams']['away']['abbreviation'] and 
-                         g['teams']['home']['abbreviation'] == self.game_data['teams']['home']['abbreviation']), None)
-            
-            if game is None or game['status']['state'] == 'PREVIEW':
-                await asyncio.sleep(60)
-                continue
+    if not rap_data or not collection_data:
+        return None
 
-            current_scores = game['scores']
-            
-            for team in [self.game_data['teams']['away']['abbreviation'], self.game_data['teams']['home']['abbreviation']]:
-                if current_scores[team] > previous_scores[team]:
-                    team_name = game['teams']['away']['teamName'] if team == game['teams']['away']['abbreviation'] else game['teams']['home']['teamName']
-                    await user.send(f"{team_name} SCORED! Current score: {current_scores[self.game_data['teams']['away']['abbreviation']]} - {current_scores[self.game_data['teams']['home']['abbreviation']]}")
-            
-            previous_scores = current_scores.copy()
-            
-            if game['status']['state'] == 'FINAL':
-                winner = self.game_data['teams']['away']['abbreviation'] if current_scores[self.game_data['teams']['away']['abbreviation']] > current_scores[self.game_data['teams']['home']['abbreviation']] else self.game_data['teams']['home']['abbreviation']
-                if winner == self.team:
-                    winnings = bet_amount * 2
-                    user_cash[self.user_id] += winnings
-                    await user.send(f"Congratulations! Your team won. You won ${winnings}!")
-                else:
-                    await user.send(f"Sorry, your team lost. Better luck next time!")
-                
-                user_bets[self.user_id] = [bet for bet in user_bets[self.user_id] if bet['game_data'] != self.game_data]
-                break
-            
-            await asyncio.sleep(60)  # Check for updates every minute
+    pets = [pet for pet in collection_data['data'] if pet['configName'] in [p['configData']['id'] for p in rap_data['data']]]
+    
+    if not pets:
+        return None
 
-class SportBetView(discord.ui.View):
-    def __init__(self):
-        super().__init__()
+    user_id = interaction.user.id
+    luck_multiplier = luck_multipliers.get(user_id, 1)
+    
+    sorted_pets = sorted(pets, key=lambda x: x['configData']['difficulty'])
+    
+    max_index = len(sorted_pets) - 1
+    index = int(max_index * (luck_multiplier - 1) / 9)
+    
+    rolled_pet = random.choice(sorted_pets[:index+1])
 
-    @discord.ui.button(label="Bet Again", style=discord.ButtonStyle.primary)
-    async def bet_again(self, interaction: discord.Interaction, button: discord.ui.Button):
-        await show_game_selection(interaction)
+    pet_rap = next((pet for pet in rap_data['data'] if pet['configData']['id'] == rolled_pet['configName']), None)
 
-    @discord.ui.button(label="View Bets", style=discord.ButtonStyle.secondary)
-    async def view_bets(self, interaction: discord.Interaction, button: discord.ui.Button):
-        await show_current_bets(interaction)
+    if not pet_rap:
+        return None
 
-async def show_game_selection(interaction: discord.Interaction):
-    scores = await fetch_nhl_scores()
-    upcoming_games = [game for game in scores['games'] if game['status']['state'] == 'PREVIEW']
+    rap_value = pet_rap['value']
+    thumbnail_id = rolled_pet['configData']['thumbnail'].split('://')[1]
+    thumbnail_url = f"https://api.rbxgleaks1.workers.dev/asset/{thumbnail_id}"
 
-    if not upcoming_games:
-        await interaction.response.send_message("No games available for betting.")
-        return
+    def format_difficulty(difficulty):
+        if difficulty >= 1_000_000_000:
+            return f"{difficulty / 1_000_000_000:.1f}B ({difficulty:,})"
+        elif difficulty >= 1_000_000:
+            return f"{difficulty / 1_000_000:.1f}M ({difficulty:,})"
+        elif difficulty >= 1_000:
+            return f"{difficulty / 1_000:.1f}K ({difficulty:,})"
+        else:
+            return f"{difficulty} ({difficulty:,})"
 
-    view = discord.ui.View()
-    game_select = GameSelect(upcoming_games)
-    view.add_item(game_select)
+    embed = discord.Embed(title=f"{interaction.user.name} rolled: {rolled_pet['configData']['name']}", color=0x787878)
+    embed.add_field(name="Value", value=f"{rap_value:,} diamonds", inline=True)
+    embed.add_field(name="Difficulty", value=format_difficulty(rolled_pet['configData']['difficulty']), inline=True)
+    embed.add_field(name="Category", value=rolled_pet['category'], inline=True)
+    embed.set_thumbnail(url=thumbnail_url)
+    
+    luck_text = ""
+    if user_id in luck_expiration:
+        remaining_time = int(luck_expiration[user_id] - time.time())
+        if remaining_time > 0:
+            luck_percentage = (luck_multiplier - 1) * 100
+            luck_text = f"\nYou have {remaining_time // 60} minutes and {remaining_time % 60} seconds of luck left! ({luck_percentage}% luck)"
+        else:
+            del luck_multipliers[user_id]
+            del luck_expiration[user_id]
+    
+    embed.set_footer(text=f"Click 'Roll Again' to roll again!{luck_text}")
 
-    await interaction.response.send_message("Select a game to bet on:", view=view)
+    roll_again_button = discord.ui.Button(style=discord.ButtonStyle.primary, label="Roll Again", custom_id="roll_again")
+    
+    async def roll_again_callback(interaction: discord.Interaction):
+        await interaction.response.defer()
+        result = await perform_roll(interaction)
+        if result:
+            await interaction.followup.send(embed=result[0], view=result[1])
+        else:
+            await interaction.followup.send("An error occurred.")
 
-    async def game_callback(interaction: discord.Interaction):
-        selected_game = next(game for game in upcoming_games if f"{game['teams']['away']['abbreviation']}_{game['teams']['home']['abbreviation']}" == game_select.values[0])
-        
-        team_view = discord.ui.View()
-        team_select = TeamSelect(selected_game['teams']['away'], selected_game['teams']['home'])
-        team_view.add_item(team_select)
+    roll_again_button.callback = roll_again_callback
 
-        await interaction.response.edit_message(content="Select a team to bet on:", view=team_view)
+    view = discord.ui.View()
+    view.add_item(roll_again_button)
 
-        async def team_callback(interaction: discord.Interaction):
-            selected_team = team_select.values[0]
-            await interaction.response.send_modal(BetModal(selected_team, interaction.user.id, selected_game))
+    sell_button = discord.ui.Button(style=discord.ButtonStyle.success, label=f"Sell Pet for ${rap_value}", custom_id="sell_pet")
 
-        team_select.callback = team_callback
+    async def sell_pet_callback(interaction: discord.Interaction):
+        if interaction.user.id != user_id:
+            await interaction.response.send_message("You cannot sell this pet.", ephemeral=True)
+            return
 
-    game_select.callback = game_callback
+        sell_value = rap_value
+        user_cash[user_id] = user_cash.get(user_id, 0) + sell_value
+        await interaction.response.send_message(f"You sold the pet for ${sell_value}. Your new balance is ${user_cash[user_id]}.", ephemeral=True)
+        for item in view.children:
+            if item.custom_id == "sell_pet":
+                view.remove_item(item)
+                break
+        await interaction.message.edit(view=view)
 
-async def show_current_bets(interaction: discord.Interaction):
-    user_id = interaction.user.id
-    if user_id not in user_bets or not user_bets[user_id]:
-        await interaction.response.send_message("You have no active bets.")
-        return
+    sell_button.callback = sell_pet_callback
+    view.add_item(sell_button)
 
-    embed = discord.Embed(title="Your Current Bets", color=0x787878)
-    scores = await fetch_nhl_scores()
+    if user_id not in first_luck_claimed:
+        first_luck_button = discord.ui.Button(style=discord.ButtonStyle.success, label="Claim 100% Luck Forever", custom_id="first_luck")
+        
+        async def first_luck_callback(interaction: discord.Interaction):
+            if interaction.user.id != user_id:
+                await interaction.response.send_message("You cannot use this button.", ephemeral=True)
+                return
+            
+            luck_multipliers[user_id] = 10  # 100% luck
+            first_luck_claimed.add(user_id)
+            
+            await interaction.response.send_message("You've claimed 100% luck forever!", ephemeral=True)
+            
+            for item in view.children:
+                if item.custom_id == "first_luck":
+                    view.remove_item(item)
+                    break
+            await interaction.message.edit(view=view)
+        
+        first_luck_button.callback = first_luck_callback
+        view.add_item(first_luck_button)
     
-    for i, bet in enumerate(user_bets[user_id]):
-        game = next((g for g in scores['games'] if g['teams']['away']['abbreviation'] == bet['game_data']['teams']['away']['abbreviation'] and 
-                     g['teams']['home']['abbreviation'] == bet['game_data']['teams']['home']['abbreviation']), None)
+    elif random.random() < 0.6 and luck_opportunities.get(user_id, 0) < 4:
+        luck_opportunities[user_id] = luck_opportunities.get(user_id, 0) + 1
+        increase_luck_button = discord.ui.Button(style=discord.ButtonStyle.success, label="Increase Luck", custom_id=f"increase_luck_{luck_opportunities[user_id]}")
         
-        start_time = datetime.fromisoformat(bet['game_data']['startTime'].replace('Z', '+00:00'))
-        current_time = datetime.now(timezone.utc)
+        async def increase_luck_callback(interaction: discord.Interaction):
+            if interaction.user.id != user_id:
+                await interaction.response.send_message("You cannot use this button.", ephemeral=True)
+                return
+            
+            if user_id in used_luck_opportunities and len(used_luck_opportunities[user_id]) >= 4:
+                await interaction.response.send_message("You have already used all your luck opportunities.", ephemeral=True)
+                return
+
+            current_luck = luck_multipliers.get(user_id, 1)
+            new_luck = min(current_luck + 1, 10)
+            luck_multipliers[user_id] = new_luck
+            luck_expiration[user_id] = time.time() + 1800
+            
+            if user_id not in used_luck_opportunities:
+                used_luck_opportunities[user_id] = set()
+            used_luck_opportunities[user_id].add(luck_opportunities[user_id])
+            
+            luck_percentage = (new_luck - 1) * 100
+            await interaction.response.send_message(f"Your luck has been increased to {luck_percentage}% for 30 minutes!", ephemeral=True)
+            
+            for item in view.children:
+                if item.custom_id == interaction.custom_id:
+                    view.remove_item(item)
+                    break
+            await interaction.message.edit(view=view)
+
+            # Schedule the next luck opportunity
+            asyncio.create_task(schedule_next_luck_opportunity(interaction, user_id))
         
-        if current_time < start_time:
-            status = f"Starts <t:{int(start_time.timestamp())}:R>"
-            score = "N/A"
-        else:
-            status = game['status']['state'] if game else "Unknown"
-            score = f"{game['scores'][bet['game_data']['teams']['away']['abbreviation']]} - {game['scores'][bet['game_data']['teams']['home']['abbreviation']]}" if game and 'scores' in game else "Unknown"
-        
-        embed.add_field(name=f"Bet {i+1}", value=(
-            f"Team: {bet['team']}\n"
-            f"Amount: ${bet['amount']}\n"
-            f"Game: {bet['game_data']['teams']['away']['teamName']} vs {bet['game_data']['teams']['home']['teamName']}\n"
-            f"Status: {status}\n"
-            f"Current Score: {score}\n"
-            f"Start Time: <t:{int(start_time.timestamp())}:F>"
-        ), inline=False)
+        increase_luck_button.callback = increase_luck_callback
+        view.add_item(increase_luck_button)
 
-    view = discord.ui.View()
-    cancel_select = discord.ui.Select(placeholder="Select a bet to cancel", options=[
-        discord.SelectOption(label=f"Bet {i+1}", value=str(i)) for i in range(len(user_bets[user_id]))
-    ])
-    view.add_item(cancel_select)
+    auto_roll_button = discord.ui.Button(
+        style=discord.ButtonStyle.primary if user_id not in auto_roll_users else discord.ButtonStyle.danger,
+        label="Auto Roll" if user_id not in auto_roll_users else "Stop Auto Roll",
+        custom_id="auto_roll"
+    )
 
-    async def cancel_callback(interaction: discord.Interaction):
+    async def auto_roll_callback(interaction: discord.Interaction):
         if interaction.user.id != user_id:
-            await interaction.response.send_message("You cannot cancel other users' bets.", ephemeral=True)
+            await interaction.response.send_message("You cannot use this button.", ephemeral=True)
             return
 
-        bet_index = int(cancel_select.values[0])
-        cancelled_bet = user_bets[user_id].pop(bet_index)
-        user_cash[user_id] += cancelled_bet['amount']
-        await interaction.response.send_message(f"Bet cancelled. ${cancelled_bet['amount']} has been refunded")
+        if user_id in auto_roll_users:
+            auto_roll_users.remove(user_id)
+            auto_roll_button.style = discord.ButtonStyle.primary
+            auto_roll_button.label = "Auto Roll"
+            await interaction.response.send_message("Auto roll stopped.", ephemeral=True)
+        else:
+            auto_roll_users.add(user_id)
+            auto_roll_button.style = discord.ButtonStyle.danger
+            auto_roll_button.label = "Stop Auto Roll"
+            await interaction.response.send_message("Auto roll started.", ephemeral=True)
+            asyncio.create_task(auto_roll(interaction))
+
+        await interaction.message.edit(view=view)
+
+    auto_roll_button.callback = auto_roll_callback
+    view.add_item(auto_roll_button)
+
+    return embed, view
+
+async def schedule_next_luck_opportunity(interaction: discord.Interaction, user_id: int):
+    await asyncio.sleep(1800)  # Wait for 30 minutes
+    luck_opportunities[user_id] = luck_opportunities.get(user_id, 0) + 1
+    increase_luck_button = discord.ui.Button(style=discord.ButtonStyle.success, label="Increase Luck", custom_id=f"increase_luck_{luck_opportunities[user_id]}")
+    
+    async def increase_luck_callback(interaction: discord.Interaction):
+        if interaction.user.id != user_id:
+            await interaction.response.send_message("You cannot use this button.", ephemeral=True)
+            return
+        
+        if user_id in used_luck_opportunities and len(used_luck_opportunities[user_id]) >= 4:
+            await interaction.response.send_message("You have already used all your luck opportunities.", ephemeral=True)
+            return
 
-    cancel_select.callback = cancel_callback
+        current_luck = luck_multipliers.get(user_id, 1)
+        new_luck = min(current_luck + 1, 10)
+        luck_multipliers[user_id] = new_luck
+        luck_expiration[user_id] = time.time() + 1800
+        
+        if user_id not in used_luck_opportunities:
+            used_luck_opportunities[user_id] = set()
+        used_luck_opportunities[user_id].add(luck_opportunities[user_id])
+        
+        luck_percentage = (new_luck - 1) * 100
+        await interaction.response.send_message(f"Your luck has been increased to {luck_percentage}% for 30 minutes!", ephemeral=True)
+        
+        view = interaction.message.components[0]
+        for item in view.children:
+            if item.custom_id == interaction.custom_id:
+                view.remove_item(item)
+                break
+        await interaction.message.edit(view=view)
 
-    await interaction.response.send_message(embed=embed, view=view)
+        # Schedule the next luck opportunity
+        asyncio.create_task(schedule_next_luck_opportunity(interaction, user_id))
+    
+    increase_luck_button.callback = increase_luck_callback
+    
+    view = interaction.message.components[0]
+    view.add_item(increase_luck_button)
+    await interaction.message.edit(view=view)
 
-@app_commands.command(name="sportbet", description="Bet on sports games")
-async def sportbet(interaction: discord.Interaction):
+async def auto_roll(interaction: discord.Interaction):
     user_id = interaction.user.id
-    if user_id in user_bets and user_bets[user_id]:
-        view = SportBetView()
-        await interaction.response.send_message("?", view=view)
+    while user_id in auto_roll_users:
+        result = await perform_roll(interaction)
+        if result:
+            await interaction.followup.send(embed=result[0], view=result[1])
+        else:
+            await interaction.followup.send("An error occurred.")
+        await asyncio.sleep(5)  # Wait for 5 seconds between rolls
+
+@app_commands.command(name="petroll", description="Roll for a random pet")
+async def petroll(interaction: discord.Interaction):
+    await interaction.response.defer()
+    result = await perform_roll(interaction)
+    if result:
+        await interaction.followup.send(embed=result[0], view=result[1])
     else:
-        await show_game_selection(interaction)
+        await interaction.followup.send("errer")
+
+@app_commands.command(name="balance", description="Check your current balance")
+async def balance(interaction: discord.Interaction):
+    user_id = interaction.user.id
+    current_balance = user_cash.get(user_id, 0)
+    await interaction.response.send_message(f"Your current balance is ${current_balance}.", ephemeral=True)
+
+@app_commands.command(name="dice", description="Roll the dice and bet")
+async def dice(interaction: discord.Interaction, bet: int):
+    await roll_dice(interaction, bet)
+
+async def roll_dice(interaction: discord.Interaction, bet: int):
+    user_id = interaction.user.id
+    balance = user_cash.get(user_id, 0)
+    
+    if bet <= 0:
+        await interaction.response.send_message("Bet Higher than 0 Idiot.")
+        return
+    
+    if bet > balance:
+        await interaction.response.send_message(f"You don't have enough cash. Your current balance is ${balance:.2f}")
+        return
+    
+    embed = discord.Embed(title="Dice Roll", description=f"{interaction.user.name} is betting ${bet:.2f}", color=0x787878)
+    embed.add_field(name="Current Balance", value=f"${balance:.2f}", inline=False)
+    
+    roll_button = discord.ui.Button(style=discord.ButtonStyle.primary, label="Roll the Dice", custom_id="roll_dice")
+    
+    async def roll_dice_callback(interaction: discord.Interaction):
+        nonlocal balance
+        result = random.choice(["win", "lose"])
+        
+        if result == "win":
+            winnings = bet
+            balance += winnings
+            result_text = f"You won ${winnings:.2f}!"
+        else:
+            balance -= bet
+            result_text = f"You lost ${bet:.2f}."
+        
+        user_cash[user_id] = balance
+        
+        embed.clear_fields()
+        embed.add_field(name="Result", value=result_text, inline=False)
+        embed.add_field(name="New Balance", value=f"${balance:.2f}", inline=False)
+        
+        roll_again_button = discord.ui.Button(style=discord.ButtonStyle.primary, label="Roll Again", custom_id="roll_again")
+        
+        async def roll_again_callback(interaction: discord.Interaction):
+            if interaction.user.id == user_id:
+                await roll_dice(interaction, bet)
+            else:
+                await interaction.response.send_message("you cant roll this", ephemeral=True)
+        
+        roll_again_button.callback = roll_again_callback
+        
+        new_view = discord.ui.View()
+        new_view.add_item(roll_again_button)
+        
+        await interaction.response.edit_