Update ccc.py

ccc.py

@@ -3,6 +3,8 @@ import discord
 from discord.ext import commands
 import asyncio
 import re
+from collections import deque
+from datetime import datetime, timedelta
 import os
 
 TOKEN = os.environ['TOKEN']
@@ -18,6 +20,23 @@ bot = commands.Bot(command_prefix='!', intents=intents)
 pet_images = {}
 pet_difficulties = {}
 pet_raps = {}
+pet_changes = {}
+
+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 update_rap_values():
     try:
@@ -25,26 +44,43 @@ async def update_rap_values():
         if response.status_code == 200:
             data = response.json()
             if data['status'] == 'ok':
-                # Clear existing RAP values
                 pet_raps.clear()
-                
-                # Process each pet in the list
                 for pet_data in data['data']:
                     config_data = pet_data['configData']
                     pet_id = config_data['id']
                     value = pet_data['value']
-                    
-                    # Check if it's a shiny pet
                     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")
     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)
@@ -60,10 +96,8 @@ async def get_huge_secret_pets():
                         huge_secret_pets.append(pet_name)
                         huge_secret_pets.append(f"Shiny {pet_name}")
                         
-                        # Store difficulty value
                         difficulty = config_data.get('difficulty', 'Unknown')
                         pet_difficulties[pet_name] = difficulty
-                        # Shiny pets are 100x harder
                         pet_difficulties[f"Shiny {pet_name}"] = difficulty * 100
                         
                         if 'thumbnail' in config_data:
@@ -71,50 +105,50 @@ async def get_huge_secret_pets():
                             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
-            else:
-                print("API response status not OK")
-                return []  # Return empty list instead of None
-    except Exception as e:
-        print(f"Error fetching pets list: {e}")
-        return []  # Return empty list instead of None
     except Exception as e:
         print(f"Error fetching pets list: {e}")
-        return []
+    return []
 
 async def send_embed_message(channel, pet_name, previous_value, current_value, is_change=False):
     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 RAP value with commas
-    if isinstance(rap_value, (int, float)):
-        rap_display = f"{rap_value:,}"
-    else:
-        rap_display = rap_value
+    # 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
+    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
     
-    # Format difficulty with commas
-    if isinstance(difficulty, (int, float)):
-        difficulty_display = f"{difficulty:,}"
-    else:
-        difficulty_display = difficulty
-        
-    # Format exist counts with commas
-    if isinstance(current_value, (int, float)):
-        current_display = f"{current_value:,}"
-    else:
-        current_display = current_value
-        
-    if isinstance(previous_value, (int, float)):
-        previous_display = f"{previous_value:,}"
+    # Check if the pet is shiny
+    is_shiny = pet_name.startswith("Shiny ")
+    
+    # Format the title based on whether the pet is shiny
+    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
     else:
-        previous_display = previous_value
+        # For regular pets: use dice emoji
+        title = f"🎲 A {pet_name} was rolled! 🎲"
+        embed_color = discord.Color.blue() if not is_change else discord.Color.orange()
     
     embed = discord.Embed(
-        title=f"🎲 A {pet_name} was rolled! 🎲",
-        description=f"{pet_name} exists: **{current_display}**\nDifficulty: **1 in {difficulty_display}**\nRAP Value: **{rap_display}**",
-        color=discord.Color.blue() if not is_change else discord.Color.orange(),
+        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",
+        color=embed_color
     )
     
     if pet_image_url:
@@ -164,7 +198,7 @@ async def main_loop():
         return
 
     tracked_pets = await get_huge_secret_pets()
-    if not tracked_pets:  # If we get an empty list, wait and retry
+    if not tracked_pets:
         print("No pets fetched, retrying in 60 seconds...")
         await asyncio.sleep(60)
         return
@@ -175,10 +209,9 @@ async def main_loop():
     while True:
         try:
             if not tracked_pets:
-                tracked_pets = await get_huge_secret_pets() or []  # Ensure we always have a list
+                tracked_pets = await get_huge_secret_pets() or []
                 lastknown.update({pet: None for pet in tracked_pets if pet not in lastknown})
             
-            # Update RAP values periodically
             await update_rap_values()
             
             vvalues = await petdata(tracked_pets)
@@ -187,13 +220,18 @@ async def main_loop():
                     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 []  # Ensure we always have a list
-            if new_pets and set(new_pets) != set(tracked_pets):  # Only compare if new_pets is not empty
+            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})
@@ -202,7 +240,7 @@ async def main_loop():
             
         except Exception as e:
             print(f"Error in main loop: {e}")
-            await asyncio.sleep(60)  # Wait before retrying if there's an error
+            await asyncio.sleep(60)
 
 @bot.event
 async def on_ready():