Create ccc.py

ccc.py

@@ -0,0 +1,705 @@
+import requests
+import discord
+from discord.ext import commands
+import asyncio
+import json
+import re
+from collections import defaultdict
+from collections import deque
+from datetime import datetime, timedelta
+import pytz
+import os
+
+TOKEN = os.environ['TOKEN']
+CHANNEL_ID = 1298830206387228682
+MONITORED_ITEMS_CHANNEL_ID = 1307752080139878500
+AUTHORIZED_USER_ID = 1219416244806094883
+
+PETS_API = 'https://petsapi.deno.dev/'
+EXISTS_API = 'https://existsapi.deno.dev/'
+RAP_API = 'https://rapapi.deno.dev/'
+
+last_rap_values = {
+    "Crystal Key": None,
+    "Huge Shiba": None,
+    "Huge Dragon": None,
+    "Huge Inferno Cat": None,
+    "Autumn God Potion": None
+}
+
+LIMITED_PETS = {
+    "Huge Shiba": 15000,
+    "Huge Dragon": 7500,
+    "Huge Nightmare Corgi": 15000,
+    "Huge Jelly Axolotl": 5000
+}
+
+JELLY_LEAVE_TIMES = {
+    "Huge Pilgrim Turkey": datetime.strptime('2024-12-06 12:00:00', '%Y-%m-%d %H:%M:%S').replace(tzinfo=pytz.timezone('US/Eastern')),
+    "Acorn": datetime.strptime('2024-12-06 12:00:00', '%Y-%m-%d %H:%M:%S').replace(tzinfo=pytz.timezone('US/Eastern'))
+}
+
+intents = discord.Intents.default()
+intents.message_content = True 
+bot = commands.Bot(command_prefix='!', intents=intents)
+
+pet_images = {}
+pet_difficulties = {}
+pet_raps = {}
+pet_changes = {}
+recent_notifications = defaultdict(lambda: deque(maxlen=5))
+
+async def fetch_exists_data():
+    try:
+        response = requests.get('https://biggamesexists.deno.dev')
+        if response.status_code == 200:
+            return response.json().get('data', [])
+    except Exception as e:
+        print(f"Error fetching exists data: {e}")
+    return []
+
+def format_number(number):
+    if not isinstance(number, (int, float)):
+        return str(number)
+    
+    abs_number = abs(number)
+    if abs_number < 1000:
+        return str(number)
+    elif abs_number < 1000000:
+        return f"{number/1000:.1f}k"
+    elif abs_number < 1000000000:
+        return f"{number/1000000:.1f}m"
+    elif abs_number < 1000000000000:
+        return f"{number/1000000000:.1f}b"
+    else:
+        return f"{number/1000000000000:.1f}t"
+    
+async def fetch_pet_collection_data(pet_name):
+    try:
+        response = requests.get('https://collectionpet.deno.dev')
+        if response.status_code == 200:
+            data = response.json().get('data', [])
+            for pet in data:
+                if pet.get('configName', '').lower() == pet_name.lower():
+                    return pet
+    except Exception as e:
+        print(f"Error fetching pet collection data: {e}")
+    return None
+
+async def fetch_pet_exists_data(pet_name):
+    try:
+        response = requests.get('https://biggamesexists.deno.dev')
+        if response.status_code == 200:
+            data = response.json().get('data', [])
+            variants = {
+                'Normal': 0,
+                'Golden': 0,
+                'Rainbow': 0,
+                'Shiny': 0,
+                'Shiny Golden': 0,
+                'Shiny Rainbow': 0
+            }
+            
+            for pet_data in data:
+                config_data = pet_data.get('configData', {})
+                value = pet_data.get('value', 0)
+                
+                pet_id = config_data.get('id', '')
+                is_shiny = config_data.get('sh', False)
+                pt_value = config_data.get('pt', 0)
+                
+                if pet_id.lower() == pet_name.lower():
+                    if is_shiny and pt_value == 1:
+                        variants['Shiny Golden'] = max(variants['Shiny Golden'], value)
+                    elif is_shiny and pt_value == 2:
+                        variants['Shiny Rainbow'] = max(variants['Shiny Rainbow'], value)
+                    elif is_shiny:
+                        variants['Shiny'] = max(variants['Shiny'], value)
+                    elif pt_value == 1:
+                        variants['Golden'] = max(variants['Golden'], value)
+                    elif pt_value == 2:
+                        variants['Rainbow'] = max(variants['Rainbow'], value)
+                    else:
+                        variants['Normal'] = max(variants['Normal'], value)
+            
+            return variants
+    except Exception as e:
+        print(f"Error fetching exists data: {e}")
+    return None
+
+@bot.command(name='petdata')
+async def pet_data(ctx, *, pet_name):
+    collection_data = await fetch_pet_collection_data(pet_name)
+    
+    exists_data = await fetch_pet_exists_data(pet_name)
+    
+    if not collection_data or not exists_data:
+        await ctx.send("Pet does not exist!")
+        return
+    
+    embed = discord.Embed(
+        title=collection_data.get('configName', 'Unknown Pet'),
+        color=int('11ff00', 16)
+    )
+    
+    config_data = collection_data.get('configData', {})
+    
+    description = f"**Index Description:** {config_data.get('indexDesc', 'N/A')}\n"
+    description += f"**Obtainable in Index:** {config_data.get('indexObtainable', 'N/A')}"
+    embed.description = description
+    
+    total_exists = sum(exists_data.values())
+    
+    exists_text = "\n".join([
+        f"{variant}: **{count:,}**"
+        for variant, count in exists_data.items() if count > 0
+    ])
+    exists_text += f"\n\n**Total Exist: {total_exists:,}**"
+    
+    embed.add_field(name="**Pet Exists:**", value=exists_text, inline=False)
+    
+    thumbnail_url = config_data.get('thumbnail')
+    if thumbnail_url:
+        if thumbnail_url.startswith('rbxassetid://'):
+            asset_id = re.search(r'\d+', thumbnail_url.replace('rbxassetid://', '')).group(0)
+            thumbnail_url = f"https://rbxgleaks.pythonanywhere.com/asset/{asset_id}"
+        
+        embed.set_image(url=thumbnail_url)
+    
+    await ctx.send(embed=embed)
+
+@bot.command(name='commonhuges')
+async def common_huge_pets(ctx, count: int = 10):
+    if ctx.author.id != AUTHORIZED_USER_ID:
+        await ctx.send("You are not authorized to use this command.")
+        return
+
+    count = max(1, min(count, 25))
+
+    exists_data = await fetch_exists_data()
+    if not exists_data:
+        await ctx.send("Could not retrieve pet data. Please try again later.")
+        return
+
+    huge_pet_counts = defaultdict(int)
+    
+    for pet in exists_data:
+        config_data = pet.get('configData', {})
+        value = pet.get('value', 0)
+        
+        if config_data.get('id', '').startswith('Huge'):
+            pet_name = config_data.get('id', 'Unknown')
+            
+            is_shiny = config_data.get('sh', False)
+            pt_value = config_data.get('pt', 0)
+            
+            if is_shiny and pt_value == 1:
+                variant_key = f"Shiny Golden {pet_name}"
+            elif is_shiny and pt_value == 2:
+                variant_key = f"Shiny Rainbow {pet_name}"
+            elif is_shiny:
+                variant_key = f"Shiny {pet_name}"
+            elif pt_value == 1:
+                variant_key = f"Golden {pet_name}"
+            elif pt_value == 2:
+                variant_key = f"Rainbow {pet_name}"
+            else:
+                variant_key = f"Normal {pet_name}"
+            
+            huge_pet_counts[variant_key] = max(huge_pet_counts[variant_key], value)
+
+    sorted_huge_pets = sorted(huge_pet_counts.items(), key=lambda x: x[1], reverse=True)
+
+    embed = discord.Embed(title=f"Top {count} Most Common Huge Pets", color=discord.Color.blue())
+    
+    if sorted_huge_pets:
+        for i, (pet_name, count_value) in enumerate(sorted_huge_pets[:count], 1):
+            embed.add_field(
+                name=f"{i}. {pet_name}", 
+                value=f"Exists: **{format_number(count_value)}**", 
+                inline=False
+            )
+    else:
+        embed.description = "No huge pets found in the data."
+
+    await ctx.send(embed=embed)
+
+@bot.command(name='commontitanics')
+async def common_titanic_pets(ctx, count: int = 10):
+    if ctx.author.id != AUTHORIZED_USER_ID:
+        await ctx.send("You are not authorized to use this command.")
+        return
+
+    count = max(1, min(count, 25))
+
+    exists_data = await fetch_exists_data()
+    if not exists_data:
+        await ctx.send("Could not retrieve pet data. Please try again later.")
+        return
+
+    huge_pet_counts = defaultdict(int)
+    
+    for pet in exists_data:
+        config_data = pet.get('configData', {})
+        value = pet.get('value', 0)
+        
+        if config_data.get('id', '').startswith('Titanic'):
+            pet_name = config_data.get('id', 'Unknown')
+            
+            is_shiny = config_data.get('sh', False)
+            pt_value = config_data.get('pt', 0)
+            
+            if is_shiny and pt_value == 1:
+                variant_key = f"Shiny Golden {pet_name}"
+            elif is_shiny and pt_value == 2:
+                variant_key = f"Shiny Rainbow {pet_name}"
+            elif is_shiny:
+                variant_key = f"Shiny {pet_name}"
+            elif pt_value == 1:
+                variant_key = f"Golden {pet_name}"
+            elif pt_value == 2:
+                variant_key = f"Rainbow {pet_name}"
+            else:
+                variant_key = f"Normal {pet_name}"
+            
+            huge_pet_counts[variant_key] = max(huge_pet_counts[variant_key], value)
+
+    sorted_huge_pets = sorted(huge_pet_counts.items(), key=lambda x: x[1], reverse=True)
+
+    embed = discord.Embed(title=f"Top {count} Most Common Titanic Pets", color=discord.Color.blue())
+    
+    if sorted_huge_pets:
+        for i, (pet_name, count_value) in enumerate(sorted_huge_pets[:count], 1):
+            embed.add_field(
+                name=f"{i}. {pet_name}", 
+                value=f"Exists: **{format_number(count_value)}**", 
+                inline=False
+            )
+    else:
+        embed.description = "No titanic pets found in the data."
+
+    await ctx.send(embed=embed)
+
+@bot.command(name='leastcommonhuges')
+async def least_common_huge_pets(ctx, count: int = 10):
+    if ctx.author.id != AUTHORIZED_USER_ID:
+        await ctx.send("You are not authorized to use this command.")
+        return
+
+    count = max(1, min(count, 25))
+
+    exists_data = await fetch_exists_data()
+    if not exists_data:
+        await ctx.send("Could not retrieve pet data. Please try again later.")
+        return
+
+    huge_pet_counts = defaultdict(int)
+    
+    for pet in exists_data:
+        config_data = pet.get('configData', {})
+        value = pet.get('value', 0)
+        
+        if config_data.get('id', '').startswith('Huge'):
+            pet_name = config_data.get('id', 'Unknown')
+            
+            is_shiny = config_data.get('sh', False)
+            pt_value = config_data.get('pt', 0)
+            
+            if is_shiny and pt_value == 1:
+                variant_key = f"Shiny Golden {pet_name}"
+            elif is_shiny and pt_value == 2:
+                variant_key = f"Shiny Rainbow {pet_name}"
+            elif is_shiny:
+                variant_key = f"Shiny {pet_name}"
+            elif pt_value == 1:
+                variant_key = f"Golden {pet_name}"
+            elif pt_value == 2:
+                variant_key = f"Rainbow {pet_name}"
+            else:
+                variant_key = f"Normal {pet_name}"
+            
+            huge_pet_counts[variant_key] = max(huge_pet_counts[variant_key], value)
+
+    sorted_huge_pets = sorted(huge_pet_counts.items(), key=lambda x: x[1])
+
+    embed = discord.Embed(title=f"Top {count} Least Common Huge Pets", color=discord.Color.dark_red())
+    
+    if sorted_huge_pets:
+        for i, (pet_name, count_value) in enumerate(sorted_huge_pets[:count], 1):
+            embed.add_field(
+                name=f"{i}. {pet_name}", 
+                value=f"Exists: **{format_number(count_value)}**", 
+                inline=False
+            )
+    else:
+        embed.description = "No huge pets found in the data."
+
+    await ctx.send(embed=embed)
+
+@bot.command(name='leastcommontitanics')
+async def least_common_titanic_pets(ctx, count: int = 10):
+    if ctx.author.id != AUTHORIZED_USER_ID:
+        await ctx.send("You are not authorized to use this command.")
+        return
+
+    count = max(1, min(count, 25))
+
+    exists_data = await fetch_exists_data()
+    if not exists_data:
+        await ctx.send("Could not retrieve pet data. Please try again later.")
+        return
+
+    titanic_pet_counts = defaultdict(int)
+    
+    for pet in exists_data:
+        config_data = pet.get('configData', {})
+        value = pet.get('value', 0)
+        
+        if config_data.get('id', '').startswith('Titanic'):
+            pet_name = config_data.get('id', 'Unknown')
+            
+            is_shiny = config_data.get('sh', False)
+            pt_value = config_data.get('pt', 0)
+            
+            if is_shiny and pt_value == 1:
+                variant_key = f"Shiny Golden {pet_name}"
+            elif is_shiny and pt_value == 2:
+                variant_key = f"Shiny Rainbow {pet_name}"
+            elif is_shiny:
+                variant_key = f"Shiny {pet_name}"
+            elif pt_value == 1:
+                variant_key = f"Golden {pet_name}"
+            elif pt_value == 2:
+                variant_key = f"Rainbow {pet_name}"
+            else:
+                variant_key = f"Normal {pet_name}"
+            
+            titanic_pet_counts[variant_key] = max(titanic_pet_counts[variant_key], value)
+
+    sorted_titanic_pets = sorted(titanic_pet_counts.items(), key=lambda x: x[1])
+
+    embed = discord.Embed(title=f"Top {count} Least Common Titanic Pets", color=discord.Color.dark_red())
+    
+    if sorted_titanic_pets:
+        for i, (pet_name, count_value) in enumerate(sorted_titanic_pets[:count], 1):
+            embed.add_field(
+                name=f"{i}. {pet_name}", 
+                value=f"Exists: **{format_number(count_value)}**", 
+                inline=False
+            )
+    else:
+        embed.description = "No titanic pets found in the data."
+
+    await ctx.send(embed=embed)
+
+def calculate_jelly_prediction(pet_name, current_value, hourly_rate):
+    if pet_name not in JELLY_LEAVE_TIMES:
+        return None
+        
+    current_time = datetime.now(pytz.timezone('US/Eastern'))
+    leave_time = JELLY_LEAVE_TIMES[pet_name]
+    
+    if current_time >= leave_time:
+        return None
+        
+    time_diff = leave_time - current_time
+    hours_remaining = time_diff.total_seconds() / 3600
+    predicted_increase = hourly_rate * hours_remaining
+    predicted_final = current_value + predicted_increase
+    
+    return {
+        'predicted_value': int(predicted_final),
+        'hours_remaining': round(hours_remaining, 1)
+    }
+
+def calculate_time_until_limited(pet_name, current_value, hourly_rate):
+    if pet_name not in LIMITED_PETS or hourly_rate <= 0:
+        return None
+        
+    limit = LIMITED_PETS[pet_name]
+    remaining = limit - current_value
+    
+    if remaining <= 0:
+        return "Already Limited!"
+        
+    hours = remaining / hourly_rate
+    if hours < 0:
+        return "Error calculating time"
+        
+    days = hours // 24
+    remaining_hours = hours % 24
+    
+    if days > 0:
+        return f"~{int(days)}d {int(remaining_hours)}h"
+    else:
+        return f"~{int(remaining_hours)}h"
+
+async def send_rap_change_notification(channel, item_name, previous_rap, current_rap):
+    percent_change = ((current_rap - previous_rap) / previous_rap) * 100
+    
+    if current_rap > previous_rap:
+        message = f"🚀 {item_name} RAP ROSE BY {percent_change:.2f}%!\n" + \
+                 f"Previous RAP: {previous_rap:,}\n" + \
+                 f"Current RAP: {current_rap:,}"
+        await channel.send(message)
+    else:
+        message = f"📉 {item_name} RAP DROPPED BY {abs(percent_change):.2f}%!\n" + \
+                 f"Previous RAP: {previous_rap:,}\n" + \
+                 f"Current RAP: {current_rap:,}"
+        await channel.send(message)
+
+async def update_rap_values():
+    try:
+        response = requests.get(RAP_API)
+        if response.status_code == 200:
+            data = response.json()
+            if data['status'] == 'ok':
+                pet_raps.clear()
+                
+                monitored_channel = bot.get_channel(MONITORED_ITEMS_CHANNEL_ID)
+                if monitored_channel:
+                    for pet_data in data['data']:
+                        config_data = pet_data['configData']
+                        pet_id = config_data['id']
+                        value = pet_data['value']
+                        is_shiny = config_data.get('sh', False)
+                        
+                        monitored_key = f"Shiny {pet_id}" if is_shiny else pet_id
+                        
+                        if monitored_key in last_rap_values:
+                            current_rap = value
+                            previous_rap = last_rap_values[monitored_key]
+                            
+                            if previous_rap is not None and current_rap != previous_rap:
+                                await send_rap_change_notification(monitored_channel, monitored_key, previous_rap, current_rap)
+                            
+                            last_rap_values[monitored_key] = current_rap
+                        
+                        if is_shiny:
+                            pet_raps[f"Shiny {pet_id}"] = value
+                        else:
+                            pet_raps[pet_id] = value
+                
+                print(f"Updated RAP values for {len(data['data'])} pets and items")
+    except Exception as e:
+        print(f"Error fetching RAP values: {e}")
+
+def calculate_hourly_rate(pet_name):
+    if pet_name not in pet_changes:
+        return 0
+    
+    changes = pet_changes[pet_name]
+    if not changes:
+        return 0
+        
+    current_time = datetime.now()
+    one_hour_ago = current_time - timedelta(hours=1)
+    
+    recent_changes = [change for change in changes if change['timestamp'] > one_hour_ago]
+    
+    if not recent_changes:
+        return 0
+        
+    if len(recent_changes) >= 2:
+        earliest_value = recent_changes[0]['value']
+        latest_value = recent_changes[-1]['value']
+        return latest_value - earliest_value
+    
+    return 1
+
+async def get_huge_secret_pets():
+    try:
+        response = requests.get(PETS_API)
+        if response.status_code == 200:
+            data = response.json()
+            if data['status'] == 'ok':
+                huge_secret_pets = []
+                
+                for pet in data['data']:
+                    config_data = pet['configData']
+                    if config_data.get('huge') or config_data.get('secret'):
+                        pet_name = config_data['name']
+                        huge_secret_pets.append(pet_name)
+                        huge_secret_pets.append(f"Shiny {pet_name}")
+                        
+                        difficulty = config_data.get('difficulty', 'Unknown')
+                        pet_difficulties[pet_name] = difficulty
+                        pet_difficulties[f"Shiny {pet_name}"] = difficulty * 100
+                        
+                        if 'thumbnail' in config_data:
+                            pet_images[pet_name] = config_data['thumbnail']
+                            pet_images[f"Shiny {pet_name}"] = config_data['thumbnail']
+                            print(f"Stored image URL for {pet_name}: {config_data['thumbnail']}")
+                
+                for pet_name in huge_secret_pets:
+                    if pet_name not in pet_changes:
+                        pet_changes[pet_name] = deque(maxlen=100)
+                
+                print(f"Found {len(huge_secret_pets)} pets to track (including shiny versions)")
+                return huge_secret_pets
+    except Exception as e:
+        print(f"Error fetching pets list: {e}")
+    return []
+
+async def send_embed_message(channel, pet_name, previous_value, current_value, is_change=False):
+    notification_key = f"{pet_name}_{previous_value}_{current_value}"
+    
+    if notification_key in recent_notifications.get(pet_name, []):
+        print(f"Skipping duplicate notification for {pet_name}")
+        return
+    
+    if pet_name not in recent_notifications:
+        recent_notifications[pet_name] = []
+    recent_notifications[pet_name].append(notification_key)
+
+    pet_image_url = pet_images.get(pet_name, None)
+    difficulty = pet_difficulties.get(pet_name, "Unknown")
+    rap_value = pet_raps.get(pet_name, "No RAP")
+    hourly_rate = calculate_hourly_rate(pet_name)
+
+    difficulty_display = format_number(difficulty) if isinstance(difficulty, (int, float)) else difficulty
+    rap_display = format_number(rap_value) if isinstance(rap_value, (int, float)) else rap_value
+    current_display = f"{current_value:,}" if isinstance(current_value, (int, float)) else current_value
+    previous_display = format_number(previous_value) if isinstance(previous_value, (int, float)) else previous_value
+    hourly_rate_display = format_number(hourly_rate) if isinstance(hourly_rate, (int, float)) else hourly_rate
+
+    is_shiny = pet_name.startswith("Shiny ")
+    base_name = pet_name.replace("Shiny ", "") if is_shiny else pet_name
+
+    time_until_limited = None
+    if base_name in LIMITED_PETS:
+        time_until_limited = calculate_time_until_limited(base_name, current_value, hourly_rate)
+
+    jelly_prediction = None
+    if base_name in JELLY_LEAVE_TIMES:
+        jelly_prediction = calculate_jelly_prediction(base_name, current_value, hourly_rate)
+
+    value_change = current_value - previous_value if previous_value is not None else current_value
+
+    if is_shiny:
+        title = f"✨ {f'A **SHINY** {base_name} was' if value_change == 1 else f'{value_change} **SHINY** {base_name}s were'} rolled! ✨"
+        embed_color = discord.Color.from_rgb(255, 255, 255)
+    else:
+        title = f"🎲 {f'A {pet_name}' if value_change == 1 else f'{value_change} {pet_name}s'} were rolled! 🎲"
+        embed_color = discord.Color.blue() if not is_change else discord.Color.orange()
+
+    description = f"{pet_name} exists: **{current_display}**\n" \
+                  f"Difficulty: **1 in {difficulty_display}**\n" \
+                  f"RAP Value: **{rap_display}**\n" \
+                  f"Hourly Rate: **{hourly_rate_display}/h**"
+
+    if time_until_limited is not None:
+        description += f"\nTime Remaining Until Limited: **{time_until_limited}**"
+        
+        if base_name in LIMITED_PETS:
+            limit = LIMITED_PETS[base_name]
+            remaining = limit - current_value
+            if remaining > 0:
+                description += f"\nQuantity Remaining: **{remaining:,}**"
+
+    if jelly_prediction is not None:
+        description += f"\nEstimated Final Count: **{jelly_prediction['predicted_value']:,}**"
+        description += f"\nGoing Limited In: **{jelly_prediction['hours_remaining']}h**"
+
+    embed = discord.Embed(
+        title=title,
+        description=description,
+        color=embed_color
+    )
+
+    if pet_image_url:
+        if isinstance(pet_image_url, str):
+            if pet_image_url.startswith('rbxassetid://'):
+                asset_id = re.search(r'^\d+', pet_image_url.replace('rbxassetid://', '')).group(0)
+                pet_image_url = f"https://rbxgleaks.pythonanywhere.com/asset/{asset_id}"
+            
+            print(f"Using image URL for {pet_name}: {pet_image_url}")
+            embed.set_thumbnail(url=pet_image_url)
+
+    try:
+        await channel.send(embed=embed)
+    except discord.HTTPException as e:
+        print(f"Failed to send embed for {pet_name}: {e}")
+        await channel.send(f"🎲 {'A' if value_change == 1 else value_change} {pet_name} was rolled! Exists: {current_display} (Previous: {previous_display})")
+
+async def petdata(tracked_pets):
+    try:
+        response = requests.get(EXISTS_API)
+        if response.status_code == 200:
+            data = response.json()
+            if data['status'] == 'ok':
+                pet_values = {pet: 0 for pet in tracked_pets}
+
+                for pet in data['data']:
+                    pet_id = pet['configData']['id']
+                    is_shiny = pet['configData'].get('sh', False)
+                    value = pet['value']
+
+                    pet_name = f"Shiny {pet_id}" if is_shiny else pet_id
+                    if pet_name in pet_values:
+                        print(f"Found pet: {pet_name} with exist count {value}")
+                        pet_values[pet_name] = value
+
+                return pet_values
+        print(f"Error code: {response.status_code}")
+    except Exception as e:
+        print(f"Error: {e}")
+    return None
+
+async def main_loop():
+    channel = bot.get_channel(CHANNEL_ID)
+    if channel is None:
+        print("Invalid channel ID. Please check your channel ID.")
+        return
+
+    tracked_pets = await get_huge_secret_pets()
+    if not tracked_pets:
+        print("No pets fetched, retrying in 60 seconds...")
+        await asyncio.sleep(60)
+        return
+    
+    lastknown = {pet: None for pet in tracked_pets}
+    print(f"Initially tracking {len(tracked_pets)} pets")
+    
+    while True:
+        try:
+            
+            if not tracked_pets:
+                tracked_pets = await get_huge_secret_pets() or []
+                lastknown.update({pet: None for pet in tracked_pets if pet not in lastknown})
+            
+            await update_rap_values()
+            
+            vvalues = await petdata(tracked_pets)
+            if vvalues is not None:
+                for pet, value in vvalues.items():
+                    if lastknown[pet] is None:
+                        print(f"Initial value for {pet}: {value}")
+                    elif value != lastknown[pet]:
+                        pet_changes[pet].append({
+                            'timestamp': datetime.now(),
+                            'value': value,
+                            'previous': lastknown[pet]
+                        })
+                        await send_embed_message(channel, pet, lastknown[pet], value, is_change=True)
+                    lastknown[pet] = value
+            else:
+                print("Broken check")
+                
+            new_pets = await get_huge_secret_pets() or []
+            if new_pets and set(new_pets) != set(tracked_pets):
+                print("Pet list updated!")
+                tracked_pets = new_pets
+                lastknown.update({pet: None for pet in tracked_pets if pet not in lastknown})
+                
+            await asyncio.sleep(60)
+            
+        except Exception as e:
+            print(f"Error in main loop: {e}")
+            await asyncio.sleep(60)
+
+@bot.event
+async def on_ready():
+    print(f'Logged in as {bot.user.name}')
+    bot.loop.create_task(main_loop())
+bot.run(TOKEN)