'''
else:
@@ -6587,7 +6826,8 @@ class PetBotRequestHandler(BaseHTTPRequestHandler):
pet_previews = '
Empty
' * 6
status_text = f"{config['pet_count']}/6 pets" if config['pet_count'] > 0 else "Empty team"
- active_class = "active" if config['slot'] == 1 else "" # Default to team 1 as active
+ active_class = "active" if config['slot'] == current_active_slot else ""
+ is_active = config['slot'] == current_active_slot
team_cards_html += f'''
@@ -6598,9 +6838,12 @@ class PetBotRequestHandler(BaseHTTPRequestHandler):
{pet_previews}
-
- {'π’ Currently Editing' if config['slot'] == 1 else f'π Edit {config["name"]}'}
-
+
+
+ π Edit {config["name"]}
+
+ {'π’ Active Team ' if is_active else f'π Make Active '}
+
'''
@@ -7256,12 +7499,12 @@ class PetBotRequestHandler(BaseHTTPRequestHandler):
if (!currentEditingTeam) return;
try {{
- const response = await fetch(`/testteambuilder/{nickname}/save`, {{
+ const response = await fetch(`/teambuilder/{nickname}/save`, {{
method: 'POST',
headers: {{ 'Content-Type': 'application/json' }},
body: JSON.stringify({{
- team_slot: currentEditingTeam,
- team_data: currentTeamData
+ teamSlot: currentEditingTeam,
+ teamData: currentTeamData
}})
}});
@@ -7285,7 +7528,7 @@ class PetBotRequestHandler(BaseHTTPRequestHandler):
}}
try {{
- const response = await fetch(`/testteambuilder/{nickname}/verify`, {{
+ const response = await fetch(`/teambuilder/{nickname}/verify`, {{
method: 'POST',
headers: {{ 'Content-Type': 'application/json' }},
body: JSON.stringify({{ pin: pin }})
@@ -7417,6 +7660,10 @@ class PetBotRequestHandler(BaseHTTPRequestHandler):
team_data = save_data
team_slot = 1
+ # Validate team slot
+ if not isinstance(team_slot, int) or team_slot < 1 or team_slot > 3:
+ return {"success": False, "error": "Invalid team slot. Must be 1, 2, or 3"}
+
# Get player
player = await self.database.get_player(nickname)
if not player:
@@ -7770,6 +8017,48 @@ class PetBotRequestHandler(BaseHTTPRequestHandler):
print(f"Error in _handle_team_config_apply_async: {e}")
return {"success": False, "error": str(e)}
+ def handle_team_swap_request(self, nickname, slot):
+ """Handle team swap request to change active team"""
+ try:
+ # Validate slot number
+ try:
+ slot_num = int(slot)
+ if slot_num < 1 or slot_num > 3:
+ self.send_json_response({"success": False, "error": "Slot must be 1, 2, or 3"}, 400)
+ return
+ except ValueError:
+ self.send_json_response({"success": False, "error": "Invalid slot number"}, 400)
+ return
+
+ # Run async operations
+ import asyncio
+ result = asyncio.run(self._handle_team_swap_async(nickname, slot_num))
+
+ if result["success"]:
+ self.send_json_response(result, 200)
+ else:
+ self.send_json_response(result, 404 if "not found" in result.get("error", "") else 400)
+
+ except Exception as e:
+ print(f"Error in handle_team_swap_request: {e}")
+ self.send_json_response({"success": False, "error": "Internal server error"}, 500)
+
+ async def _handle_team_swap_async(self, nickname, slot_num):
+ """Async handler for team swapping"""
+ try:
+ # Get player
+ player = await self.database.get_player(nickname)
+ if not player:
+ return {"success": False, "error": "Player not found"}
+
+ # Set the new active team slot
+ result = await self.database.set_active_team_slot(player["id"], slot_num)
+ return result
+
+ except Exception as e:
+ print(f"Error in _handle_team_swap_async: {e}")
+ return {"success": False, "error": str(e)}
+
def handle_test_team_save(self, nickname):
"""Handle test team builder save request and generate PIN"""
try:
@@ -7787,8 +8076,9 @@ class PetBotRequestHandler(BaseHTTPRequestHandler):
team_slot = data.get('team_slot')
team_data = data.get('team_data', {})
- if not team_slot or team_slot not in [1, 2, 3]:
- self.send_json_response({"success": False, "error": "Invalid team slot"}, 400)
+ # Validate team slot
+ if not isinstance(team_slot, int) or team_slot < 1 or team_slot > 3:
+ self.send_json_response({"success": False, "error": "Invalid team slot. Must be 1, 2, or 3"}, 400)
return
except json.JSONDecodeError:
@@ -7901,6 +8191,167 @@ class PetBotRequestHandler(BaseHTTPRequestHandler):
print(f"Error in _handle_test_team_verify_async: {e}")
return {"success": False, "error": str(e)}
+ def handle_individual_team_save(self, nickname, team_slot):
+ """Handle individual team save request and generate PIN"""
+ try:
+ # Get POST data
+ content_length = int(self.headers.get('Content-Length', 0))
+ if content_length == 0:
+ self.send_json_response({"success": False, "error": "No data provided"}, 400)
+ return
+
+ post_data = self.rfile.read(content_length).decode('utf-8')
+
+ try:
+ import json
+ data = json.loads(post_data)
+ team_identifier = data.get('team_identifier', team_slot)
+ is_active_team = data.get('is_active_team', False)
+ pets = data.get('pets', [])
+
+ # Validate team slot
+ if team_slot not in ['1', '2', '3', 'active']:
+ self.send_json_response({"success": False, "error": "Invalid team slot"}, 400)
+ return
+
+ # Convert team_slot to numeric for database operations
+ if team_slot == 'active':
+ team_slot_num = 1
+ is_active_team = True
+ else:
+ team_slot_num = int(team_slot)
+
+ except json.JSONDecodeError:
+ self.send_json_response({"success": False, "error": "Invalid JSON data"}, 400)
+ return
+
+ # Run async operations
+ import asyncio
+ result = asyncio.run(self._handle_individual_team_save_async(nickname, team_slot_num, pets, is_active_team))
+
+ if result["success"]:
+ self.send_json_response({"requires_pin": True, "message": "PIN sent to IRC"}, 200)
+ else:
+ self.send_json_response(result, 400)
+
+ except Exception as e:
+ print(f"Error in handle_individual_team_save: {e}")
+ self.send_json_response({"success": False, "error": "Internal server error"}, 500)
+
+ async def _handle_individual_team_save_async(self, nickname, team_slot, pets, is_active_team):
+ """Async handler for individual team save"""
+ try:
+ # Get player
+ player = await self.server.database.get_player(nickname)
+
+ if not player:
+ return {"success": False, "error": "Player not found"}
+
+ # Validate pets exist and belong to player
+ if pets:
+ player_pets = await self.server.database.get_player_pets(player['id'])
+ player_pet_ids = [pet['id'] for pet in player_pets]
+
+ for pet_data in pets:
+ pet_id = pet_data.get('pet_id')
+ if not pet_id:
+ continue
+
+ # Convert pet_id to int for comparison with database IDs
+ try:
+ pet_id_int = int(pet_id)
+ except (ValueError, TypeError):
+ return {"success": False, "error": f"Invalid pet ID: {pet_id}"}
+
+ # Check if pet belongs to player
+ if pet_id_int not in player_pet_ids:
+ return {"success": False, "error": f"Pet {pet_id} not found or doesn't belong to you"}
+
+ # Convert pets array to the expected format for database
+ # Expected format: {"pet_id": position, "pet_id": position, ...}
+ team_changes = {}
+ if pets: # Ensure pets is not None or empty
+ for pet_data in pets:
+ if isinstance(pet_data, dict): # Ensure pet_data is a dictionary
+ pet_id = str(pet_data.get('pet_id')) # Ensure pet_id is string
+ position = pet_data.get('position', False) # Position or False for inactive
+ if pet_id and pet_id != 'None': # Only add valid pet IDs
+ team_changes[pet_id] = position
+
+
+ # Generate PIN and store pending change
+ import json
+ team_data = {
+ 'teamSlot': int(team_slot), # Convert to int and use expected key name
+ 'teamData': team_changes, # Use the dictionary format expected by database
+ 'is_active_team': is_active_team
+ }
+
+ # Generate PIN
+ pin_result = await self.server.database.generate_verification_pin(player["id"], "team_change", json.dumps(team_data))
+ pin_code = pin_result.get("pin_code")
+
+ # Send PIN via IRC
+ self.send_pin_via_irc(nickname, pin_code)
+
+ return {"success": True, "requires_pin": True}
+
+ except Exception as e:
+ print(f"Error in _handle_individual_team_save_async: {e}")
+ return {"success": False, "error": str(e)}
+
+ def handle_individual_team_verify(self, nickname, team_slot):
+ """Handle individual team PIN verification"""
+ try:
+ # Get PIN from request body
+ content_length = int(self.headers['Content-Length'])
+ post_data = self.rfile.read(content_length)
+
+ import json
+ try:
+ data = json.loads(post_data.decode('utf-8'))
+ pin_code = data.get('pin', '').strip()
+ except json.JSONDecodeError:
+ self.send_json_response({"success": False, "error": "Invalid request data"}, 400)
+ return
+
+ if not pin_code or len(pin_code) != 6:
+ self.send_json_response({"success": False, "error": "PIN must be 6 digits"}, 400)
+ return
+
+ # Run async verification
+ import asyncio
+ result = asyncio.run(self._handle_individual_team_verify_async(nickname, pin_code))
+
+ if result["success"]:
+ self.send_json_response(result, 200)
+ else:
+ self.send_json_response(result, 400)
+
+ except Exception as e:
+ print(f"Error in handle_individual_team_verify: {e}")
+ self.send_json_response({"success": False, "error": "Internal server error"}, 500)
+
+ async def _handle_individual_team_verify_async(self, nickname, pin_code):
+ """Async handler for individual team PIN verification"""
+ try:
+ # Get player
+ player = await self.server.database.get_player(nickname)
+ if not player:
+ return {"success": False, "error": "Player not found"}
+
+ # Verify PIN and apply changes using simplified method
+ result = await self.server.database.apply_individual_team_change(player["id"], pin_code)
+
+ if result["success"]:
+ return {"success": True, "message": "Team saved successfully!"}
+ else:
+ return {"success": False, "error": result.get("error", "Invalid PIN")}
+
+ except Exception as e:
+ print(f"Error in _handle_individual_team_verify_async: {e}")
+ return {"success": False, "error": str(e)}
+
def handle_pet_rename_request(self, nickname):
"""Handle pet rename request and generate PIN"""
try:
@@ -9927,6 +10378,1327 @@ class PetBotRequestHandler(BaseHTTPRequestHandler):
print(f"Error resetting rate limits: {e}")
self.send_json_response({"success": False, "error": str(e)}, 500)
+ # ================================================================
+ # NEW TEAM BUILDER METHODS - Separated Team Management
+ # ================================================================
+
+ def serve_team_selection_hub(self, nickname):
+ """Serve the team selection hub showing all teams with swap options."""
+ try:
+ # Get database and bot from server
+ database = self.server.database if hasattr(self.server, 'database') else None
+ bot = self.server.bot if hasattr(self.server, 'bot') else None
+
+ if not database:
+ self.send_error(500, "Database not available")
+ return
+
+ # Get team management service
+ if not hasattr(self, 'team_service'):
+ from src.team_management import TeamManagementService
+ from src.pin_authentication import PinAuthenticationService
+ pin_service = PinAuthenticationService(database, bot)
+ self.team_service = TeamManagementService(database, pin_service)
+
+ # Get team overview
+ import asyncio
+ loop = asyncio.new_event_loop()
+ asyncio.set_event_loop(loop)
+ try:
+ player = loop.run_until_complete(database.get_player(nickname))
+ if not player:
+ self.send_error(404, "Player not found")
+ return
+
+ team_overview = loop.run_until_complete(self.team_service.get_team_overview(player["id"]))
+ if not team_overview["success"]:
+ self.send_error(500, f"Failed to load teams: {team_overview['error']}")
+ return
+
+ teams = team_overview["teams"]
+ finally:
+ loop.close()
+
+ # Generate team hub HTML
+ content = self.generate_team_hub_content(nickname, teams)
+ full_page = self.get_page_template(f"Team Management - {nickname}", content, "teambuilder")
+
+ self.send_response(200)
+ self.send_header('Content-type', 'text/html; charset=utf-8')
+ self.end_headers()
+ self.wfile.write(full_page.encode('utf-8'))
+
+ except Exception as e:
+ print(f"Error serving team selection hub: {e}")
+ self.send_error(500, "Internal server error")
+
+ def serve_individual_team_editor(self, nickname, team_identifier):
+ """Serve individual team editor page."""
+ try:
+ # Get database and bot from server
+ database = self.server.database if hasattr(self.server, 'database') else None
+ bot = self.server.bot if hasattr(self.server, 'bot') else None
+
+ if not database:
+ self.send_error(500, "Database not available")
+ return
+
+ # Get team management service
+ if not hasattr(self, 'team_service'):
+ from src.team_management import TeamManagementService
+ from src.pin_authentication import PinAuthenticationService
+ pin_service = PinAuthenticationService(database, bot)
+ self.team_service = TeamManagementService(database, pin_service)
+
+ # Get team data
+ import asyncio
+ loop = asyncio.new_event_loop()
+ asyncio.set_event_loop(loop)
+ try:
+ player = loop.run_until_complete(database.get_player(nickname))
+ if not player:
+ self.send_error(404, "Player not found")
+ return
+
+ team_data = loop.run_until_complete(
+ self.team_service.get_individual_team_data(player["id"], team_identifier)
+ )
+ if not team_data["success"]:
+ self.send_error(500, f"Failed to load team: {team_data['error']}")
+ return
+
+ # Get player's pets for the editor
+ player_pets = loop.run_until_complete(database.get_player_pets(player["id"]))
+ finally:
+ loop.close()
+
+ # Generate individual team editor HTML
+ content = self.generate_individual_team_editor_content(nickname, team_identifier, team_data, player_pets)
+ full_page = self.get_page_template(f"{team_data['team_name']} - {nickname}", content, "teambuilder")
+
+ self.send_response(200)
+ self.send_header('Content-type', 'text/html; charset=utf-8')
+ self.end_headers()
+ self.wfile.write(full_page.encode('utf-8'))
+
+ except Exception as e:
+ print(f"Error serving individual team editor: {e}")
+ self.send_error(500, "Internal server error")
+
+ def generate_team_hub_content(self, nickname, teams):
+ """Generate HTML content for team selection hub."""
+ return f'''
+
+
+
+
+
β‘ Current Battle Team
+
+ {self._generate_active_team_display(teams.get('active', {}), nickname)}
+
+
+
+
+
πΎ Saved Team Configurations
+
+ {self._generate_team_preview(teams.get('slot_1', {}), '1')}
+ {self._generate_team_preview(teams.get('slot_2', {}), '2')}
+ {self._generate_team_preview(teams.get('slot_3', {}), '3')}
+
+
+
+
+
+
+
+ '''
+
+ def _generate_team_preview(self, team_data, team_identifier):
+ """Generate preview for a single team."""
+ team_name = team_data.get('name', f'Team {team_identifier}')
+ pet_count = team_data.get('count', 0)
+ is_active = team_data.get('is_active', False)
+
+ if is_active:
+ actions = f'''
+
+ βοΈ Edit Active Team
+
+ '''
+ else:
+ actions = f'''
+
+ βοΈ Edit Team {team_identifier}
+
+
+ π Make Active
+
+ '''
+
+ status = "π ACTIVE TEAM" if is_active else f"πΎ Saved Team"
+
+ return f'''
+
+
{team_name}
+
{status}
+
πΎ {pet_count} pets
+
+ {actions}
+
+
+ '''
+
+ def _generate_active_team_display(self, active_team_data, nickname):
+ """Generate detailed display for active team with individual pet cards."""
+ pets_dict = active_team_data.get('pets', {})
+ pet_count = active_team_data.get('count', 0)
+
+ # Convert dictionary format to list for consistent processing
+ pets = []
+ if isinstance(pets_dict, dict):
+ # Active team format: {"1": {pet_data}, "2": {pet_data}}
+ for position, pet_data in pets_dict.items():
+ if pet_data:
+ pet_data['team_order'] = int(position)
+ pets.append(pet_data)
+ elif isinstance(pets_dict, list):
+ # Saved team format: [{pet_data}, {pet_data}]
+ pets = pets_dict
+
+ if not pets or pet_count == 0:
+ return f'''
+
+
π Active Team
+
No pets in active team
+
+
+ '''
+
+ # Generate individual pet cards for active team
+ pet_cards = []
+ for pet in pets:
+ # Handle both active team format and saved team format
+ name = pet.get('nickname') or pet.get('name') or pet.get('species_name', 'Unknown')
+ level = pet.get('level', 1)
+ hp = pet.get('hp', 0)
+ max_hp = pet.get('max_hp', 0)
+ attack = pet.get('attack', 0)
+ defense = pet.get('defense', 0)
+ speed = pet.get('speed', 0)
+ happiness = pet.get('happiness', 50)
+ species_name = pet.get('species_name', 'Unknown')
+
+ # Handle type field variations between active and saved teams
+ type1 = (pet.get('type1') or pet.get('type_primary') or
+ pet.get('type1', 'Normal'))
+ type2 = (pet.get('type2') or pet.get('type_secondary') or
+ pet.get('type2'))
+
+ team_order = pet.get('team_order', 0)
+
+ # Calculate HP percentage for health bar
+ hp_percent = (hp / max_hp) * 100 if max_hp > 0 else 0
+ hp_color = "#4CAF50" if hp_percent > 60 else "#FF9800" if hp_percent > 25 else "#f44336"
+
+ # Happiness emoji
+ if happiness >= 80:
+ happiness_emoji = "π"
+ elif happiness >= 60:
+ happiness_emoji = "π"
+ elif happiness >= 40:
+ happiness_emoji = "π"
+ elif happiness >= 20:
+ happiness_emoji = "π"
+ else:
+ happiness_emoji = "π’"
+
+ # Type display
+ type_display = type1
+ if type2:
+ type_display += f"/{type2}"
+
+ pet_card = f'''
+
+
+
{species_name}
+
{type_display}
+
+
+
+ HP
+ {hp}/{max_hp}
+
+
+
+
+
+
+ ATK
+ {attack}
+
+
+ DEF
+ {defense}
+
+
+ SPD
+ {speed}
+
+
+
+
+ {happiness_emoji}
+ Happiness: {happiness}/100
+
+
+ '''
+ pet_cards.append(pet_card)
+
+ pets_html = "".join(pet_cards)
+
+ return f'''
+
+
+
+
+
+ '''
+
+ def generate_individual_team_editor_content(self, nickname, team_identifier, team_data, player_pets):
+ """Generate HTML content for individual team editor."""
+ team_name = team_data.get('team_name', 'Unknown Team')
+ is_active_team = team_data.get('is_active_team', False)
+ team_pets = team_data.get('pets', [])
+
+ # Separate pets into team and storage
+ team_pet_ids = [p['id'] for p in team_pets]
+ storage_pets = [p for p in player_pets if p['id'] not in team_pet_ids]
+
+ # Helper function to create detailed pet card
+ def make_pet_card(pet, in_team=False):
+ name = pet.get('nickname') or pet.get('species_name', 'Unknown')
+ pet_id = pet.get('id', 0)
+ level = pet.get('level', 1)
+ species = pet.get('species_name', 'Unknown')
+
+ # Type info
+ type_str = pet.get('type1', 'Normal')
+ if pet.get('type2'):
+ type_str += f"/{pet['type2']}"
+
+ # HP calculation
+ hp = pet.get('hp', 0)
+ max_hp = pet.get('max_hp', 1)
+ hp_percent = (hp / max_hp * 100) if max_hp > 0 else 0
+ hp_color = "#4CAF50" if hp_percent > 60 else "#FF9800" if hp_percent > 25 else "#f44336"
+
+ # Get pet moves
+ moves = pet.get('moves', [])
+ moves_html = ''
+ if moves:
+ moves_html = '
Moves: ' + ', '.join([m.get('name', 'Unknown') for m in moves[:4]]) + '
'
+
+ return f"""
+
+
+
{species}
+
{type_str}
+
+
+
+ HP
+ {hp}/{max_hp}
+
+
+
+
+
+
+ ATK
+ {pet.get('attack', 0)}
+
+
+ DEF
+ {pet.get('defense', 0)}
+
+
+ SPD
+ {pet.get('speed', 0)}
+
+
+
+ {moves_html}
+
+
+ {'π' if pet.get('happiness', 50) > 70 else 'π' if pet.get('happiness', 50) > 40 else 'π'}
+ Happiness: {pet.get('happiness', 50)}/100
+
+
+ """
+
+ # Create team slots (6 slots)
+ team_slots_html = ''
+ for i in range(1, 7):
+ # Find pet in this slot
+ slot_pet = None
+ for pet in team_pets:
+ if pet.get('team_order') == i or (i == 1 and not any(p.get('team_order') == 1 for p in team_pets) and team_pets and pet == team_pets[0]):
+ slot_pet = pet
+ break
+
+ if slot_pet:
+ team_slots_html += f"""
+
+
#{i}
+ {make_pet_card(slot_pet, True)}
+
+ """
+ else:
+ team_slots_html += f"""
+
+
#{i}
+
+ β
+ Drop pet here
+
+
+ """
+
+ # Create storage pet cards
+ storage_cards_html = ''.join([make_pet_card(pet, False) for pet in storage_pets])
+
+ if not storage_cards_html:
+ storage_cards_html = '
No pets in storage. All your pets are in teams!
'
+
+ return f'''
+
+
+
+
+
+
π Team Composition
+
+ {team_slots_html}
+
+
+ πΎ Save Team
+ π Reset Changes
+
+
+
π Enter Verification PIN
+
Check your IRC private messages for the PIN
+
+
Verify
+
+
+
+
+
πΎ Pet Storage ({len(storage_pets)} available)
+
+ {storage_cards_html}
+
+
+
+
+
+
+
+
+ '''
+
class PetBotWebServer:
"""Standalone web server for PetBot"""
@@ -9976,7 +11748,7 @@ def run_standalone():
print('Usage: python webserver.py [port]')
sys.exit(1)
- server = PetBotWebServer(port)
+ server = PetBotWebServer(port=port)
print('π PetBot Web Server')
print('=' * 50)
@@ -10003,6 +11775,106 @@ def run_standalone():
except KeyboardInterrupt:
print('\nβ
Web server stopped')
+
+
+class PetBotWebServer:
+ """Standalone web server for PetBot"""
+
+ def __init__(self, database=None, port=8080, bot=None):
+ self.database = database or Database()
+ self.port = port
+ self.bot = bot
+ self.server = None
+
+ def run(self):
+ """Start the web server"""
+ self.server = HTTPServer(('0.0.0.0', self.port), PetBotRequestHandler)
+ self.server.database = self.database
+ self.server.bot = self.bot
+
+ 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}')
+ print('')
+
+ try:
+ self.server.serve_forever()
+ except KeyboardInterrupt:
+ print('\nπ Server stopped')
+ finally:
+ self.server.server_close()
+
+ def start_in_thread(self):
+ """Start the web server in a separate thread"""
+ import threading
+
+ def run_server():
+ self.server = HTTPServer(('0.0.0.0', self.port), PetBotRequestHandler)
+ self.server.database = self.database
+ self.server.bot = self.bot
+
+ try:
+ self.server.serve_forever()
+ except Exception as e:
+ print(f"Web server error: {e}")
+ finally:
+ self.server.server_close()
+
+ self.server_thread = threading.Thread(target=run_server, daemon=True)
+ self.server_thread.start()
+
+ def stop(self):
+ """Stop the web server"""
+ if self.server:
+ print('π Stopping web server...')
+ self.server.shutdown()
+ self.server.server_close()
+
+
+def run_standalone():
+ """Run the web server in standalone mode"""
+ import sys
+
+ port = 8080
+ if len(sys.argv) > 1:
+ try:
+ port = int(sys.argv[1])
+ except ValueError:
+ print('Usage: python webserver.py [port]')
+ sys.exit(1)
+
+ server = PetBotWebServer(port=port)
+
+ print('π PetBot Web Server')
+ print('=' * 50)
+ print(f'Port: {port}')
+ print('')
+ print('π Local URLs:')
+ print(f' http://localhost:{port}/ - Game Hub (local)')
+ print(f' http://localhost:{port}/help - Command Help (local)')
+ print(f' http://localhost:{port}/players - Player List (local)')
+ print(f' http://localhost:{port}/leaderboard - Leaderboard (local)')
+ print(f' http://localhost:{port}/locations - Locations (local)')
+ print('')
+ print('π Public URLs:')
+ print(' http://petz.rdx4.com/ - Game Hub')
+ print(' http://petz.rdx4.com/help - Command Help')
+ print(' http://petz.rdx4.com/players - Player List')
+ print(' http://petz.rdx4.com/leaderboard - Leaderboard')
+ print(' http://petz.rdx4.com/locations - Locations')
+ print('')
+ print('π± Example Player Profile:')
+ print(' http://petz.rdx4.com/player/megasconed')
+ print('')
+ print('βοΈ Press Ctrl+C to stop the server')
+ print('')
+
+ try:
+ server.run()
+ except KeyboardInterrupt:
+ print('\nπ Shutting down web server...')
+ server.stop()
+
+
if __name__ == '__main__':
run_standalone()
-