Update ccc.py

ccc.py

@@ -2,25 +2,61 @@ 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://biggamesapi.io/api/exists')
+        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)):
@@ -30,13 +66,387 @@ def format_number(number):
     if abs_number < 1000:
         return str(number)
     elif abs_number < 1000000:
-        return f"{number/1000:.1f}K"
+        return f"{number/1000:.1f}k"
     elif abs_number < 1000000000:
-        return f"{number/1000000:.1f}M"
+        return f"{number/1000000:.1f}m"
     elif abs_number < 1000000000000:
-        return f"{number/1000000000:.1f}B"
+        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://ps99.biggamesapi.io/api/collection/Pets')
+        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://biggamesapi.io/api/exists')
+        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:
-        return f"{number/1000000000000:.1f}T"
+        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:
@@ -45,16 +455,32 @@ async def update_rap_values():
             data = response.json()
             if data['status'] == 'ok':
                 pet_raps.clear()
-                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)
-                    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")
+                
+                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}")
 
@@ -116,56 +542,85 @@ async def get_huge_secret_pets():
     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)
-    
-    # Format values with abbreviations
+
     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 = format_number(current_value) if isinstance(current_value, (int, float)) else current_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
-    
-    # Check if the pet is shiny
+
     is_shiny = pet_name.startswith("Shiny ")
-    
-    # Format the title based on whether the pet is 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:
-        # For shiny pets: use sparkles and format "SHINY" in bold and italic
-        base_name = pet_name.replace("Shiny ", "")
-        title = f"✨ ***SHINY*** {base_name} was rolled! ✨"
-        embed_color = discord.Color.from_rgb(255, 255, 255)  # White color for shiny pets
+        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:
-        # For regular pets: use dice emoji
-        title = f"🎲 A {pet_name} was rolled! 🎲"
+        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=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}** per hour",
+        description=description,
         color=embed_color
     )
-    
+
     if pet_image_url:
         if isinstance(pet_image_url, str):
             if pet_image_url.startswith('rbxassetid://'):
-                asset_id = pet_image_url.replace('rbxassetid://', '')
-                asset_id = re.search(r'^\d+', asset_id).group(0)
+                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 {pet_name} was rolled! Exists: {current_display} (Previous: {previous_display})")
+        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:
@@ -208,6 +663,7 @@ async def main_loop():
     
     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})
@@ -246,5 +702,4 @@ async def main_loop():
 async def on_ready():
     print(f'Logged in as {bot.user.name}')
     bot.loop.create_task(main_loop())
-
 bot.run(TOKEN)