""" Interface Manager Module This module manages the complete user interface for the MMORPG application, connecting the HuggingFace-style UI with the game services and handling all user interactions and event bindings. """ import gradio as gr import asyncio import time from typing import Dict, Any, List, Optional, Tuple from dataclasses import asdict from ..core.game_engine import GameEngine from ..core.player import Player from ..core.world import GameWorld from ..facades.game_facade import GameFacade from .huggingface_ui import HuggingFaceUI class InterfaceManager: """Manages the complete user interface and event handling for the MMORPG.""" def __init__(self, game_facade: GameFacade, ui: HuggingFaceUI): from ..core.game_engine import get_game_engine self.game_engine = get_game_engine() self.game_facade = game_facade self.ui = ui # reference to UI for HTML generation # Interface state self.interface = None # Auto-refresh timers self.auto_refresh_interval = 2.0 # seconds # Entity name to ID mapping for private chat self.entity_name_to_id = {} # Current player tracking for enhanced features self.current_player_id = None def create_interface(self) -> gr.Blocks: """Create and configure the complete interface with event handlers.""" # Create the interface with all event handlers properly wired self._create_interface_with_events() return self.interface def _create_interface_with_events(self) -> None: """Create the interface with all event handlers properly wired.""" # Get keyboard script for head injection (critical for working keyboard controls) keyboard_js = self.ui.get_keyboard_script() with gr.Blocks( title="๐ŸŽฎ MMORPG with MCP Integration", theme=self.ui.theme, css=self.ui.custom_css, head=keyboard_js ) as interface: # Hero section self.ui.create_hero_section() # Keyboard status keyboard_status = self.ui.create_keyboard_status() # Player state management player_state = gr.State({}) with gr.Tabs(): # Main Game Tab with gr.Tab("๐ŸŒ Game World"): with gr.Row(): with gr.Column(scale=2): # Player registration with gr.Group(): gr.Markdown("### ๐ŸŽฎ Join the Adventure") with gr.Row(): player_name = gr.Textbox( label="Player Name", placeholder="Enter your character name", scale=3 ) join_btn = gr.Button("Join Game", variant="primary", scale=1) leave_btn = gr.Button("Leave Game", variant="secondary", scale=1) # Enhanced controls info # gr.Markdown(""" # ### โŒจ๏ธ Enhanced Controls # **Mouse:** Click movement buttons below # **Keyboard:** Use **WASD** or **Arrow Keys** for movement # **Action:** **Spacebar** for special action # ๐Ÿ’ก *Keyboard controls automatically activate when buttons are ready* # """) # Game world view with bigger map (800x600) game_view = gr.HTML( value=self.ui._generate_world_html(800, 600), label="๐ŸŒ Game World" ) # Enhanced movement controls with gr.Group(): gr.Markdown("### ๐Ÿ•น๏ธ Movement Controls") gr.Markdown("**Keyboard:** WASD or Arrow Keys | **Mouse:** Click buttons below") with gr.Row(): gr.HTML("") move_up = gr.Button("โ†‘", size="lg") gr.HTML("") with gr.Row(): move_left = gr.Button("โ†", size="lg") action_btn = gr.Button("โš”๏ธ", size="lg", variant="secondary") move_right = gr.Button("โ†’", size="lg") with gr.Row(): gr.HTML("") move_down = gr.Button("โ†“", size="lg") gr.HTML("") with gr.Column(scale=1): # Player stats player_info = gr.JSON( label="๐Ÿงโ€โ™‚๏ธ Player Stats", value={"status": "Not connected", "info": "Join the game to see your stats"} ) # Online players online_players = gr.Dataframe( headers=["Name", "Type", "Level"], label="๐Ÿ‘ฅ Online Players" ) # World events world_events = gr.Textbox( label="๐ŸŒ World Events & NPC Interactions", lines=4, interactive=False, placeholder="World events will appear here...

๐Ÿ’ก Tip: Walk near NPCs (๐Ÿ“ฎ๐Ÿช๐ŸŒค๏ธ) to interact with them!
Then visit the 'NPC Add-ons' tab to use their features." ) # Enhanced chat system with gr.Row(): with gr.Column(scale=4): chat_display = gr.Chatbot( label="๐Ÿ’ฌ Game Chat", height=300, type='messages', value=[{"role": "assistant", "content": "Welcome! Join the game to start chatting!"}] ) with gr.Row(): chat_input = gr.Textbox( placeholder="Type your message... (use /help for commands)", scale=4, container=False ) chat_send = gr.Button("Send", scale=1, variant="primary") # Private chat system with gr.Column(scale=2): # Auto-refresh toggle with gr.Row(): auto_refresh_enabled = gr.Checkbox( label="Auto-refresh (2s)", value=True, info="Toggle to preserve manual selections" ) proximity_info = gr.HTML( value="
๐Ÿ” Move near NPCs or players to chat privately
", label="๐Ÿ“ฑ Nearby Entities" ) # Private chat interface with multi-tab support with gr.Group(visible=False) as private_chat_group: nearby_entities = gr.Dropdown( label="๐Ÿ’ฌ Start new chat with", choices=[], interactive=True ) with gr.Row(): start_chat_btn = gr.Button("Start Chat", variant="primary", scale=1) clear_all_tabs_btn = gr.Button("Clear All", variant="secondary", scale=1) # Chat tabs display chat_tabs_state = gr.State({}) active_tabs_display = gr.HTML( value="
No active chats
", label="Active Chats" ) # Current chat display current_chat_display = gr.Chatbot( label="๐Ÿ”’ Private Messages", height=200, type='messages', value=[], visible=False ) with gr.Row(visible=False) as chat_input_row: private_message_input = gr.Textbox( placeholder="Type private message...", scale=4, container=False ) private_send_btn = gr.Button("Send", scale=1, variant="secondary") # Documentation Tab with gr.Tab("๐Ÿ“š Documentation"): self.ui._create_documentation_content() # NPC Add-ons Tab with gr.Tab("๐Ÿค– NPC Add-ons"): self.ui._create_npc_addons_content() # Plugin System Tab with gr.Tab("๐Ÿ”Œ Plugin System"): self.ui._create_plugin_system_content() # MCP Integration Tab with gr.Tab("๐Ÿ”— MCP Integration"): self.ui._create_mcp_integration_content() # AI Agent Testing Tab with gr.Tab("๐Ÿงช AI Agent Testing"): gr.Markdown("## ๐Ÿงช Test AI Agent Integration") gr.Markdown("*Use this to simulate AI agent connections for testing*") with gr.Row(): ai_name = gr.Textbox( label="AI Agent Name", placeholder="Claude the Explorer", scale=3 ) register_ai_btn = gr.Button("Register AI Agent", variant="primary", scale=1) with gr.Row(): ai_action = gr.Dropdown( choices=["move up", "move down", "move left", "move right", "chat"], label="AI Action", scale=2 ) ai_message = gr.Textbox( label="AI Message (for chat)", placeholder="Hello humans!", scale=3 ) execute_ai_btn = gr.Button("Execute AI Action", variant="secondary") ai_result = gr.Textbox(label="AI Action Result", interactive=False, lines=5) # Raw Data Testing Section gr.Markdown("### ๐Ÿงช Test Raw Data Access") gr.Markdown("*Test accessing comprehensive world data without HTML parsing*") with gr.Row(): test_raw_data_btn = gr.Button("Get Raw World Data", variant="secondary") test_available_npcs_btn = gr.Button("Get Available NPCs", variant="secondary") raw_data_result = gr.JSON(label="Raw Data Output", visible=True) # Architecture Tab with gr.Tab("๐Ÿ—๏ธ Architecture"): self.ui._create_architecture_content() # ================================================================= # EVENT HANDLERS # ================================================================= # Join/Leave game handlers # Join game handler with name and state inputs join_btn.click( self._handle_join_game, inputs=[player_name, player_state], outputs=[player_state, player_info, online_players, game_view] ) # Leave game handler with state input leave_btn.click( self._handle_leave_game, inputs=[player_state], outputs=[player_state, player_info, online_players, game_view] ) # Movement handlers move_up.click( self._handle_movement, inputs=[gr.State("up"), player_state], outputs=[player_state, game_view, world_events] ) move_down.click( self._handle_movement, inputs=[gr.State("down"), player_state], outputs=[player_state, game_view, world_events] ) move_left.click( self._handle_movement, inputs=[gr.State("left"), player_state], outputs=[player_state, game_view, world_events] ) move_right.click( self._handle_movement, inputs=[gr.State("right"), player_state], outputs=[player_state, game_view, world_events] ) action_btn.click( self._handle_action, inputs=[player_state], outputs=[world_events] ) # Chat handlers chat_send.click( self._handle_chat_message, inputs=[chat_input, player_state], outputs=[chat_display, chat_input] ) chat_input.submit( self._handle_chat_message, inputs=[chat_input, player_state], outputs=[chat_display, chat_input] ) # Private chat handlers start_chat_btn.click( self._handle_start_chat, inputs=[nearby_entities, chat_tabs_state, player_state], outputs=[chat_tabs_state, active_tabs_display, current_chat_display, chat_input_row] ) private_send_btn.click( self._handle_private_message, inputs=[private_message_input, chat_tabs_state, player_state], outputs=[current_chat_display, private_message_input] ) # Clear all private chat tabs clear_all_tabs_btn.click( self._handle_clear_all_chats, inputs=[chat_tabs_state], outputs=[chat_tabs_state, active_tabs_display, current_chat_display, chat_input_row] ) # AI Agent Testing handlers register_ai_btn.click( self._handle_register_ai_agent, inputs=[ai_name], outputs=[ai_result] ) execute_ai_btn.click( self._handle_execute_ai_action, inputs=[ai_action, ai_message], outputs=[ai_result] ) # Raw Data Testing handlers test_raw_data_btn.click( self._handle_test_raw_world_data, inputs=[], outputs=[raw_data_result] ) test_available_npcs_btn.click( self._handle_test_available_npcs, inputs=[], outputs=[raw_data_result] ) # Auto-refresh handlers via Timer (Gradio v3+) refresh_timer = gr.Timer(value=self.auto_refresh_interval) refresh_timer.tick( self._auto_refresh_game_state, inputs=[player_state, auto_refresh_enabled], outputs=[player_info, online_players, game_view, proximity_info, nearby_entities, private_chat_group, chat_display, world_events] ) self.interface = interface # ================================================================= # EVENT HANDLER METHODS # ================================================================= def _handle_join_game(self, name: str, current_state: Dict) -> Tuple[Dict, Dict, List[List[str]], str]: """Handle player joining the game.""" # Validate name if not name or not name.strip(): return current_state, {"error": "Please enter a valid name"}, [], self.ui._generate_world_html(800, 600) # Attempt to join via facade player_id = self.game_facade.join_game(name.strip()) if not player_id: return current_state, {"error": "Failed to join game"}, [], self.ui._generate_world_html(800, 600) # Update state current_state.update({"player_id": player_id, "joined": True, "name": name.strip()}) # Set current player ID for enhanced features (glow effect, etc.) self.current_player_id = player_id # Build UI outputs status = {"player_id": player_id, "status": f"Joined as {name.strip()}"} rows = self._get_online_players_data() world_html = self._generate_world_html_with_players() return current_state, status, rows, world_html def _handle_leave_game(self, current_state: Dict) -> Tuple[Dict, Dict, List[List[str]], str]: """Handle player leaving the game: clear state and return updated UI components.""" # Get player_id from current state player_id = current_state.get("player_id") # Attempt to leave via facade success = self.game_facade.leave_game(player_id) # Reset state and clear current player tracking new_state: Dict = {} self.current_player_id = None # Build UI outputs status = {"status": "Left game" if success else "Leave failed"} rows = self._get_online_players_data() world_html = self._generate_world_html_with_players() return new_state, status, rows, world_html def _handle_movement(self, direction: str, current_state: Dict) -> Tuple[Dict, str, str]: """Handle player movement with enhanced collision detection.""" if not current_state.get("joined"): return current_state, self._generate_world_html_with_players(), "Join the game to move!" try: player_id = current_state.get("player_id") success, new_position, events = self.game_facade.move_player(player_id, direction) if success: current_state.update(new_position) world_html = self._generate_world_html_with_players() event_text = "
".join(events) if events else f"Moved {direction}" return current_state, world_html, event_text else: return current_state, self._generate_world_html_with_players(), f"Cannot move {direction} - blocked by obstacle!" except Exception as e: return current_state, self._generate_world_html_with_players(), f"Movement error: {str(e)}" def _handle_action(self, current_state: Dict) -> str: """Handle special action button.""" if not current_state.get("joined"): return "Join the game to use actions!" try: player_id = current_state.get("player_id") result = self.game_facade.handle_action(player_id) return result except Exception as e: return f"Action error: {str(e)}" def _handle_chat_message(self, message: str, current_state: Dict) -> Tuple[List[Dict], str]: """Handle public chat messages with state context.""" # Validate message and join status if not message or not message.strip() or not current_state.get("joined"): return [], "" try: player_id = current_state.get("player_id") # Send message via facade self.game_facade.send_chat_message(player_id, message.strip()) # Get recent history history = self.game_facade.get_chat_history(20) formatted = self._format_chat_messages(history) # Clear input after sending return formatted, "" except Exception: return [{"role": "assistant", "content": "Chat error"}], "" def _handle_start_chat(self, entity_selection: str, chat_tabs_state: Dict, current_state: Dict) -> Tuple[Dict, str, gr.Chatbot, gr.Group]: """Handle starting a private chat.""" if not entity_selection or not current_state.get("joined"): return chat_tabs_state, gr.update(value=self._generate_chat_tabs_html(chat_tabs_state)), gr.update(visible=False), gr.update(visible=False) try: # Convert display name back to entity ID using the stored mapping entity_id = self.entity_name_to_id.get(entity_selection, entity_selection) entity_name = entity_selection # We already have the display name if entity_id not in chat_tabs_state: chat_tabs_state[entity_id] = { "name": entity_name, "active": True, "pinned": False, "unread": 0 } # Set as active for tab_id in chat_tabs_state: chat_tabs_state[tab_id]["active"] = (tab_id == entity_id) # Get chat messages for this entity player_id = current_state.get("player_id") messages = self.game_facade.get_private_messages(player_id, entity_id) tabs_html = self._generate_chat_tabs_html(chat_tabs_state) return chat_tabs_state, gr.update(value=tabs_html), gr.update(value=messages, visible=True), gr.update(visible=True) except Exception as e: return chat_tabs_state, gr.update(value=f"Error: {str(e)}"), gr.update(visible=False), gr.update(visible=False) def _handle_private_message(self, message: str, chat_tabs_state: Dict, current_state: Dict) -> Tuple[List[Dict], str]: """Handle private chat messages.""" # Validate input and state if not message or not message.strip() or not current_state.get("joined"): return [], "" # Determine active entity for private chat entity_id = next((eid for eid, info in chat_tabs_state.items() if info.get("active")), None) if not entity_id: return [], "" print(f"[InterfaceManager] Sending private message from {current_state.get('player_id')} to {entity_id}: '{message.strip()}'") # Send private message via game facade player_id = current_state.get("player_id") player_name = current_state.get("name", "Unknown") # Get player name from state success = self.game_facade.send_private_message(player_id, player_name, entity_id, message.strip()) if success: # Fetch updated messages messages = self.game_facade.get_private_messages(player_id, entity_id) # Format messages for Gradio Chatbot (using backup version formatting) formatted = [] for msg in messages[-20:]: # last 20 messages # Determine role based on sender_id vs current player role = "user" if msg.get("sender_id") == player_id else "assistant" # Convert newlines to HTML breaks for proper display message_content = msg.get('message', '').replace('\n', '
') content = f"[{msg.get('timestamp', '')}] {msg.get('sender', 'Unknown')}: {message_content}" formatted.append({"role": role, "content": content}) print(f"[InterfaceManager] Formatted {len(formatted)} private messages for display") return formatted, "" else: print(f"[InterfaceManager] Failed to send private message") return [], "" def _handle_clear_all_chats(self, chat_tabs_state: Dict) -> Tuple[Dict, str, gr.Chatbot, gr.Group]: """Handle clearing all private chat tabs.""" chat_tabs_state.clear() tabs_html = self._generate_chat_tabs_html(chat_tabs_state) return chat_tabs_state, tabs_html, gr.update(visible=False), gr.update(visible=False) def _handle_register_ai_agent(self, ai_name: str) -> str: """Handle AI agent registration.""" if not ai_name or not ai_name.strip(): return "โŒ Please enter a valid AI agent name" try: # Generate a unique agent ID import uuid agent_id = f"test_agent_{uuid.uuid4().hex[:8]}" # Register AI agent via game facade result = self.game_facade.register_ai_agent(agent_id, ai_name.strip()) if result: # Store the agent ID for later use if not hasattr(self, 'registered_agents'): self.registered_agents = {} self.registered_agents[agent_id] = ai_name.strip() return f"โœ… AI agent '{ai_name.strip()}' registered successfully!\nAgent ID: {agent_id}" else: return f"โŒ Failed to register AI agent '{ai_name.strip()}'" except Exception as e: return f"โŒ Error registering AI agent: {str(e)}" def _handle_execute_ai_action(self, action: str, message: str) -> str: """Handle AI agent action execution.""" if not hasattr(self, 'registered_agents') or not self.registered_agents: return "โŒ No AI agents registered. Please register an AI agent first!" if not action: return "โŒ Please select an action to execute" try: # Use the first registered agent for demo purposes agent_id = list(self.registered_agents.keys())[0] agent_name = self.registered_agents[agent_id] if action.startswith("move"): # Extract direction from action (e.g., "move up" -> "up") direction = action.split()[1] if len(action.split()) > 1 else action result = self.game_facade.move_ai_agent(agent_id, direction) if result.get("success"): position = result.get("position", {}) return f"๐Ÿค– {agent_name} moved {direction} successfully!\nNew position: ({position.get('x', '?')}, {position.get('y', '?')})" else: error_msg = result.get("error", "Movement failed") return f"โŒ {agent_name} movement failed: {error_msg}" elif action == "chat": if not message or not message.strip(): return "โŒ Please enter a chat message" result = self.game_facade.ai_agent_chat(agent_id, message.strip()) if result.get("success"): return f"๐Ÿ’ฌ {agent_name} sent chat message: '{message.strip()}'" else: error_msg = result.get("error", "Chat failed") return f"โŒ {agent_name} chat failed: {error_msg}" else: return f"โ“ Unknown action: {action}" except Exception as e: return f"โŒ Error executing AI action: {str(e)}" def _handle_test_raw_world_data(self) -> Dict: """Handle testing raw world data access.""" try: raw_data = self.game_facade.get_raw_world_data() return raw_data except Exception as e: return {"error": f"Failed to get raw world data: {str(e)}"} def _handle_test_available_npcs(self) -> List[Dict]: """Handle testing available NPCs data access.""" try: npcs_data = self.game_facade.get_available_npcs() return npcs_data except Exception as e: return [{"error": f"Failed to get NPCs data: {str(e)}"}] def _auto_refresh_game_state(self, current_state: Dict, auto_refresh: bool): """Auto-refresh game state and UI elements with update objects.""" # If auto-refresh disabled or not joined, clear updates if not auto_refresh or not current_state.get("joined"): return ( gr.update(), # player_info gr.update(), # online_players gr.update(), # game_view gr.update(), # proximity_info gr.update(), # nearby_entities gr.update(visible=False), # private_chat_group gr.update(), # chat_display gr.update(), # world_events ) try: # Get updated data player_id = current_state.get("player_id") # Get updated player stats via facade player_info_data = self.game_facade.get_player_stats(player_id) online_players_data = self._get_online_players_data() world_html = self._generate_world_html_with_players() proximity_html, nearby_choices, show_private_chat = self._get_proximity_info(player_id) # Get updated chat messages chat_history = self.game_facade.get_chat_history(20) formatted_chat = self._format_chat_messages(chat_history) # Get formatted world events for display world_events_data = self._get_formatted_world_events() # Return update objects for each component return ( gr.update(value=player_info_data), # player_info gr.update(value=online_players_data), # online_players gr.update(value=world_html), # game_view gr.update(value=proximity_html), # proximity_info gr.update(choices=nearby_choices), # nearby_entities gr.update(visible=show_private_chat), # private_chat_group gr.update(value=formatted_chat), # chat_display gr.update(value=world_events_data), # world_events ) except Exception as e: print(f"Auto-refresh error: {e}") return ( gr.update(), # player_info gr.update(), # online_players gr.update(), # game_view gr.update(), # proximity_info gr.update(), # nearby_entities gr.update(visible=False), # private_chat_group gr.update(), # chat_display gr.update(), # world_events ) # ================================================================= # HELPER METHODS # ================================================================= def _get_online_players_data(self) -> List[List[str]]: """Get formatted online players data.""" try: players_data = [] # Use facade to get current players for player in self.game_facade.get_all_players().values(): players_data.append([ player.name, "๐Ÿค– AI" if player.type == "ai_agent" else "๐Ÿ‘ค Human", str(player.level) ]) return players_data except Exception: return [] def _generate_world_html_with_players(self) -> str: """Generate world HTML with current player positions, glow effects, and player names.""" try: # Get base world HTML base_html = self.ui._generate_world_html(800, 600) # Get current player ID for glow effect current_player_id = getattr(self, 'current_player_id', None) # Add players to the world with enhanced features players_html = "" all_players = self.game_facade.get_all_players() for player in all_players.values(): player_icon = "๐Ÿค–" if player.type == "ai_agent" else "๐Ÿง‘โ€๐Ÿฆฐ" is_current = player.id == current_player_id # Player glow effect implementation border_style = "border: 2px solid yellow; border-radius: 50%;" if is_current else "" # Player sprite with glow effect players_html += f'''
{player_icon}
''' # Player name display implementation name_background = "rgba(255,215,0,0.9)" if is_current else "rgba(255,215,0,0.6)" players_html += f'''
{player.name} (Lv.{player.level})
''' # Status line implementation import time player_count = len(all_players) current_time = time.strftime('%H:%M:%S') # Get width and height from the world HTML or set defaults width, height = 800, 600 status_html = f'''
๐ŸŒ Fantasy Realm | Players: {player_count}/20 | Last Update: {current_time}

๐Ÿง‘โ€๐Ÿฆฐ Players | ๐Ÿ“ฎ๐Ÿช๐Ÿšถ๐Ÿง™๐ŸŒค๏ธ NPCs | ๐ŸŒณ Trees
''' # Insert enhanced content into the world HTML enhanced_content = players_html + status_html if enhanced_content: base_html = base_html.replace( '
', f'
{enhanced_content}
' ) return base_html except Exception as e: print(f"Error generating world HTML: {e}") return self.ui._generate_world_html(800, 600) def _format_chat_messages(self, messages: List[Dict]) -> List[Dict]: """Format chat messages for Gradio chatbot.""" formatted = [] for msg in messages[-20:]: # Show last 20 messages role = "assistant" if msg.get("sender") == "System" else "user" # Convert newlines to HTML breaks for proper display message_content = msg.get('message', '').replace('\n', '
') content = f"[{msg.get('timestamp', '')}] {msg.get('sender', 'Unknown')}: {message_content}" formatted.append({"role": role, "content": content}) return formatted def _generate_chat_tabs_html(self, chat_tabs_state: Dict) -> str: """Generate HTML for chat tabs display.""" if not chat_tabs_state: return "
No active chats
" tabs_html = "
" for entity_id, tab_info in chat_tabs_state.items(): active_class = "active" if tab_info.get('active') else "" pin_icon = "๐Ÿ“Œ" if tab_info.get('pinned') else "" unread_badge = f" ({tab_info.get('unread', 0)})" if tab_info.get('unread', 0) > 0 else "" tabs_html += f'''
{tab_info['name']}{unread_badge} {pin_icon} ร—
''' tabs_html += "
" return tabs_html def _get_entity_name(self, entity_id: str) -> str: """Get display name for an entity.""" try: world = self.game_engine.get_world() # Check NPCs npc = world.npcs.get(entity_id) if npc: return npc.get("name", entity_id) # Check players player = world.players.get(entity_id) if player: return player.name return entity_id except Exception: return entity_id def _get_proximity_info(self, player_id: str) -> Tuple[str, List[str], bool]: """Get proximity information and nearby entities.""" try: proximity_data = self.game_facade.get_proximity_info(player_id) nearby_entities = proximity_data.get("nearby_entities", []) if nearby_entities: proximity_html = f"
๐Ÿ“ก Found {len(nearby_entities)} nearby entities
" # Create choices with human-readable names and maintain ID mapping choices = [] self.entity_name_to_id = {} # Reset and store mapping for later use for entity in nearby_entities: entity_id = entity['id'] entity_name = self._get_entity_name(entity_id) # Store the mapping for reverse lookup self.entity_name_to_id[entity_name] = entity_id choices.append(entity_name) return proximity_html, choices, True else: proximity_html = "
๐Ÿ” Move near NPCs or players to chat privately
" return proximity_html, [], False except Exception as e: return f"
Error: {str(e)}
", [], False def _get_formatted_world_events(self) -> str: """Get formatted world events for display.""" try: # Get world events from the game engine world_events = self.game_facade.get_world_events() if not world_events: return "No recent world events...\n\n๐Ÿ’ก Tip: Walk near NPCs (๐Ÿ“ฎ๐Ÿช๐ŸŒค๏ธ) to interact with them!\nThen visit the 'NPC Add-ons' tab to use their features." # Format events with HTML line breaks formatted_events = [] for event in world_events[-10:]: # Show last 10 events timestamp = event.get('timestamp', '') event_text = event.get('event', '') formatted_events.append(f"[{timestamp}] {event_text}") return "\n".join(formatted_events) except Exception as e: print(f"Error formatting world events: {e}") return "Error loading world events..."