|
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) |
