#!/usr/bin/env python3
"""
PetBot Web Server
Provides web interface for bot data including help, player stats, and pet collections
"""
import os
import sys
import asyncio
from http.server import HTTPServer, BaseHTTPRequestHandler
from urllib.parse import urlparse, parse_qs
from threading import Thread
import time
# Add the project directory to the path
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
from src.database import Database
class PetBotRequestHandler(BaseHTTPRequestHandler):
"""HTTP request handler for PetBot web server"""
def do_GET(self):
"""Handle GET requests"""
parsed_path = urlparse(self.path)
path = parsed_path.path
# Route handling
if path == '/':
self.serve_index()
elif path == '/help':
self.serve_help()
elif path == '/players':
self.serve_players()
elif path.startswith('/player/'):
nickname = path[8:] # Remove '/player/' prefix
self.serve_player_profile(nickname)
elif path == '/leaderboard':
self.serve_leaderboard()
elif path == '/locations':
self.serve_locations()
else:
self.send_error(404, "Page not found")
def serve_index(self):
"""Serve the main index page"""
html = """
PetBot Game Hub
🤖 Bot Status: Online and ready for commands!
Use !help in #petz for quick command reference
"""
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(html.encode())
def serve_help(self):
"""Serve the help page"""
try:
with open('help.html', 'r') as f:
content = f.read()
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(content.encode())
except FileNotFoundError:
self.send_error(404, "Help file not found")
def serve_players(self):
"""Serve the players page with real data"""
# Get database instance from the server class
database = self.server.database if hasattr(self.server, 'database') else None
if not database:
self.serve_error_page("Players", "Database not available")
return
# Fetch players data
try:
import asyncio
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
players_data = loop.run_until_complete(self.fetch_players_data(database))
loop.close()
self.serve_players_data(players_data)
except Exception as e:
print(f"Error fetching players data: {e}")
self.serve_error_page("Players", f"Error loading players: {str(e)}")
async def fetch_players_data(self, database):
"""Fetch all players data from database"""
try:
import aiosqlite
async with aiosqlite.connect(database.db_path) as db:
# Get all players with basic stats
cursor = await db.execute("""
SELECT p.nickname, p.level, p.experience, p.money, p.created_at,
l.name as location_name,
(SELECT COUNT(*) FROM pets WHERE player_id = p.id) as pet_count,
(SELECT COUNT(*) FROM pets WHERE player_id = p.id AND is_active = 1) as active_pets,
(SELECT COUNT(*) FROM player_achievements WHERE player_id = p.id) as achievement_count
FROM players p
LEFT JOIN locations l ON p.current_location_id = l.id
ORDER BY p.level DESC, p.experience DESC
""")
rows = await cursor.fetchall()
# Convert SQLite rows to dictionaries properly
players = []
for row in rows:
player_dict = {
'nickname': row[0],
'level': row[1],
'experience': row[2],
'money': row[3],
'created_at': row[4],
'location_name': row[5],
'pet_count': row[6],
'active_pets': row[7],
'achievement_count': row[8]
}
players.append(player_dict)
return players
except Exception as e:
print(f"Database error fetching players: {e}")
return []
def serve_players_data(self, players_data):
"""Serve players page with real data"""
# Build players table HTML
if players_data:
players_html = ""
for i, player in enumerate(players_data, 1):
rank_emoji = {"1": "🥇", "2": "🥈", "3": "🥉"}.get(str(i), f"{i}.")
players_html += f"""
| {rank_emoji} |
{player['nickname']} |
{player['level']} |
{player['experience']} |
${player['money']} |
{player['pet_count']} |
{player['active_pets']} |
{player['achievement_count']} |
{player.get('location_name', 'Unknown')} |
"""
else:
players_html = """
|
No players found. Be the first to use !start in #petz!
|
"""
html = f"""
PetBot - Players
← Back to Game Hub
{len(players_data)}
Total Players
{sum(p['pet_count'] for p in players_data)}
Total Pets Caught
{sum(p['achievement_count'] for p in players_data)}
Total Achievements
{max((p['level'] for p in players_data), default=0)}
Highest Level
| Rank |
Player |
Level |
Experience |
Money |
Pets |
Active |
Achievements |
Location |
{players_html}
💡 Click on any player name to view their detailed profile
"""
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(html.encode())
def serve_error_page(self, page_name, error_msg):
"""Serve a generic error page"""
html = f"""
PetBot - Error
← Back to Game Hub
Unable to load page
{error_msg}
Please try again later or contact an administrator.
"""
self.send_response(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(html.encode())
def serve_leaderboard(self):
"""Serve the leaderboard page - redirect to players for now"""
# For now, leaderboard is the same as players page since they're ranked
# In the future, this could have different categories
self.send_response(302) # Temporary redirect
self.send_header('Location', '/players')
self.end_headers()
def serve_locations(self):
"""Serve the locations page with real data"""
# Get database instance from the server class
database = self.server.database if hasattr(self.server, 'database') else None
if not database:
self.serve_error_page("Locations", "Database not available")
return
# Fetch locations data
try:
import asyncio
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
locations_data = loop.run_until_complete(self.fetch_locations_data(database))
loop.close()
self.serve_locations_data(locations_data)
except Exception as e:
print(f"Error fetching locations data: {e}")
self.serve_error_page("Locations", f"Error loading locations: {str(e)}")
async def fetch_locations_data(self, database):
"""Fetch all locations and their spawn data from database"""
try:
import aiosqlite
async with aiosqlite.connect(database.db_path) as db:
# Get all locations
cursor = await db.execute("""
SELECT l.*,
GROUP_CONCAT(ps.name || ' (' || ps.type1 ||
CASE WHEN ps.type2 IS NOT NULL THEN '/' || ps.type2 ELSE '' END || ')') as spawns
FROM locations l
LEFT JOIN location_spawns ls ON l.id = ls.location_id
LEFT JOIN pet_species ps ON ls.species_id = ps.id
GROUP BY l.id
ORDER BY l.id
""")
rows = await cursor.fetchall()
# Convert SQLite rows to dictionaries properly
locations = []
for row in rows:
location_dict = {
'id': row[0],
'name': row[1],
'description': row[2],
'level_min': row[3],
'level_max': row[4],
'spawns': row[5] if len(row) > 5 else None
}
locations.append(location_dict)
return locations
except Exception as e:
print(f"Database error fetching locations: {e}")
return []
def serve_locations_data(self, locations_data):
"""Serve locations page with real data"""
# Build locations HTML
locations_html = ""
if locations_data:
for location in locations_data:
spawns = location.get('spawns', 'No pets found')
if not spawns or spawns == 'None':
spawns = "No pets spawn here yet"
# Split spawns into a readable list
spawn_list = spawns.split(',') if spawns != "No pets spawn here yet" else []
spawn_badges = ""
for spawn in spawn_list[:6]: # Limit to first 6 for display
spawn_badges += f'{spawn.strip()}'
if len(spawn_list) > 6:
spawn_badges += f'+{len(spawn_list) - 6} more'
if not spawn_badges:
spawn_badges = 'No pets spawn here yet'
locations_html += f"""
{location['description']}
Level Range: {location['level_min']}-{location['level_max']}
Wild Pets:
{spawn_badges}
"""
else:
locations_html = """
No game locations are configured yet.
"""
html = f"""
PetBot - Locations
← Back to Game Hub
🎯 How Locations Work
Travel: Use !travel <location> to move between areas
Explore: Use !explore to find wild pets in your current location
Unlock: Some locations require achievements - catch specific pet types to unlock new areas!
Weather: Check !weather for conditions that boost certain pet spawn rates
{locations_html}
💡 Use !wild <location> in #petz to see what pets spawn in a specific area
"""
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(html.encode())
def serve_player_profile(self, nickname):
"""Serve individual player profile page"""
# URL decode the nickname in case it has special characters
from urllib.parse import unquote
nickname = unquote(nickname)
# Get database instance from the server class
database = self.server.database if hasattr(self.server, 'database') else None
if not database:
self.serve_player_error(nickname, "Database not available")
return
# Fetch player data
try:
import asyncio
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
player_data = loop.run_until_complete(self.fetch_player_data(database, nickname))
loop.close()
if player_data is None:
self.serve_player_not_found(nickname)
return
self.serve_player_data(nickname, player_data)
except Exception as e:
print(f"Error fetching player data for {nickname}: {e}")
self.serve_player_error(nickname, f"Error loading player data: {str(e)}")
return
async def fetch_player_data(self, database, nickname):
"""Fetch all player data from database"""
try:
# Get player info
import aiosqlite
async with aiosqlite.connect(database.db_path) as db:
# Get player basic info
cursor = await db.execute("""
SELECT p.*, l.name as location_name, l.description as location_desc
FROM players p
LEFT JOIN locations l ON p.current_location_id = l.id
WHERE p.nickname = ?
""", (nickname,))
player = await cursor.fetchone()
if not player:
return None
# Convert to dict manually
player_dict = {
'id': player[0],
'nickname': player[1],
'created_at': player[2],
'last_active': player[3],
'level': player[4],
'experience': player[5],
'money': player[6],
'current_location_id': player[7],
'location_name': player[8],
'location_desc': player[9]
}
# Get player pets
cursor = await db.execute("""
SELECT p.*, ps.name as species_name, ps.type1, ps.type2
FROM pets p
JOIN pet_species ps ON p.species_id = ps.id
WHERE p.player_id = ?
ORDER BY p.is_active DESC, p.level DESC, p.id ASC
""", (player_dict['id'],))
pets_rows = await cursor.fetchall()
pets = []
for row in pets_rows:
pet_dict = {
'id': row[0], 'player_id': row[1], 'species_id': row[2],
'nickname': row[3], 'level': row[4], 'experience': row[5],
'hp': row[6], 'max_hp': row[7], 'attack': row[8],
'defense': row[9], 'speed': row[10], 'happiness': row[11],
'caught_at': row[12], 'is_active': row[13],
'species_name': row[14], 'type1': row[15], 'type2': row[16]
}
pets.append(pet_dict)
# Get player achievements
cursor = await db.execute("""
SELECT pa.*, a.name as achievement_name, a.description as achievement_desc
FROM player_achievements pa
JOIN achievements a ON pa.achievement_id = a.id
WHERE pa.player_id = ?
ORDER BY pa.completed_at DESC
""", (player_dict['id'],))
achievements_rows = await cursor.fetchall()
achievements = []
for row in achievements_rows:
achievement_dict = {
'id': row[0], 'player_id': row[1], 'achievement_id': row[2],
'completed_at': row[3], 'achievement_name': row[4], 'achievement_desc': row[5]
}
achievements.append(achievement_dict)
return {
'player': player_dict,
'pets': pets,
'achievements': achievements
}
except Exception as e:
print(f"Database error fetching player {nickname}: {e}")
return None
def serve_player_not_found(self, nickname):
"""Serve player not found page"""
html = f"""
PetBot - Player Not Found
← Back to Game Hub
Player "{nickname}" not found
This player hasn't started their journey yet or doesn't exist.
Players can use !start in #petz to begin their adventure!
"""
self.send_response(404)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(html.encode())
def serve_player_error(self, nickname, error_msg):
"""Serve player error page"""
html = f"""
PetBot - Error
← Back to Game Hub
Unable to load player data
{error_msg}
Please try again later or contact an administrator.
"""
self.send_response(500)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(html.encode())
def serve_player_data(self, nickname, player_data):
"""Serve player profile page with real data"""
player = player_data['player']
pets = player_data['pets']
achievements = player_data['achievements']
# Calculate stats
active_pets = [pet for pet in pets if pet['is_active']]
total_pets = len(pets)
active_count = len(active_pets)
# Build pets table HTML
pets_html = ""
if pets:
for pet in pets:
status = "⭐ Active" if pet['is_active'] else "📦 Storage"
status_class = "pet-active" if pet['is_active'] else "pet-stored"
name = pet['nickname'] or pet['species_name']
type_str = pet['type1']
if pet['type2']:
type_str += f"/{pet['type2']}"
pets_html += f"""
| {status} |
{name} |
{pet['species_name']} |
{type_str} |
{pet['level']} |
{pet['hp']}/{pet['max_hp']} |
ATK: {pet['attack']} | DEF: {pet['defense']} | SPD: {pet['speed']} |
"""
else:
pets_html = """
|
No pets found. Use !explore and !catch to start your collection!
|
"""
# Build achievements HTML
achievements_html = ""
if achievements:
for achievement in achievements:
achievements_html += f"""
🏆 {achievement['achievement_name']}
{achievement['achievement_desc']}
Earned: {achievement['completed_at']}
"""
else:
achievements_html = """
No achievements yet. Keep exploring and catching pets to earn achievements!
"""
html = f"""
PetBot - {nickname}'s Profile
← Back to Game Hub
{player['experience']}
Experience
{active_count}
Active Pets
{len(achievements)}
Achievements
| Status |
Name |
Species |
Type |
Level |
HP |
Stats |
{pets_html}
"""
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(html.encode())
def log_message(self, format, *args):
"""Override to reduce logging noise"""
pass
class PetBotWebServer:
def __init__(self, database, port=8080):
self.database = database
self.port = port
self.server = None
def run(self):
"""Start the HTTP web server"""
print(f"🌐 Starting PetBot web server on http://0.0.0.0:{self.port}")
print(f"📡 Accessible from WSL at: http://172.27.217.61:{self.port}")
print(f"📡 Accessible from Windows at: http://localhost:{self.port}")
self.server = HTTPServer(('0.0.0.0', self.port), PetBotRequestHandler)
# Pass database to the server so handlers can access it
self.server.database = self.database
self.server.serve_forever()
def start_in_thread(self):
"""Start the web server in a background thread"""
thread = Thread(target=self.run, daemon=True)
thread.start()
print(f"✅ Web server started at http://localhost:{self.port}")
return thread
def run_standalone():
"""Run the web server standalone for testing"""
print("🐾 PetBot Web Server (Standalone Mode)")
print("=" * 40)
# Initialize database
database = Database()
# Note: In standalone mode, we can't easily run async init
# This is mainly for testing the web routes
# Start web server
server = PetBotWebServer(database)
print("🚀 Starting web server...")
print("📝 Available routes:")
print(" http://localhost:8080/ - Game Hub")
print(" http://localhost:8080/help - Command Help")
print(" http://localhost:8080/players - Player List")
print(" http://localhost:8080/leaderboard - Leaderboard")
print(" http://localhost:8080/locations - Locations")
print("")
print("Press Ctrl+C to stop")
try:
server.run()
except KeyboardInterrupt:
print("\n✅ Web server stopped")
if __name__ == "__main__":
run_standalone()