Update app.py

app.py

@@ -1,129 +1,117 @@
-#!/usr/bin/env python3
-"""
-MMORPG Application - HuggingFace Space Version
-Simplified version for HuggingFace deployment with fallback imports
-"""
-
 import gradio as gr
 import asyncio
-import os
-import sys
+import threading
 from typing import Optional
 
-# Add current directory to Python path for HF Spaces
-current_dir = os.path.dirname(os.path.abspath(__file__))
-if current_dir not in sys.path:
-    sys.path.insert(0, current_dir)
+# Import our clean architecture components
+from src.core.game_engine import GameEngine
+from src.facades.game_facade import GameFacade
+from src.ui.huggingface_ui import HuggingFaceUI
+from src.ui.improved_interface_manager import ImprovedInterfaceManager
+from src.mcp.mcp_tools import GradioMCPTools
 
-def create_fallback_interface():
-    """Create a fallback interface if main components fail to load."""
+class MMORPGApplication:
+    """Main application class that orchestrates the MMORPG game."""
     
-    # Try to import the simple SearchHF interface
-    try:
-        from simple_searchhf import create_searchhf_interface
-        return create_searchhf_interface()
-    except ImportError:
-        pass
+    def __init__(self):
+        """Initialize the application with all necessary components."""
+        # Initialize core game engine (singleton)
+        self.game_engine = GameEngine()
+        
+        # Initialize game facade for simplified operations
+        self.game_facade = GameFacade()        # Initialize UI components
+        self.ui = HuggingFaceUI(self.game_facade)
+        self.interface_manager = ImprovedInterfaceManager(self.game_facade, self.ui)
+        
+        # Initialize MCP tools for AI agent integration
+        self.mcp_tools = GradioMCPTools(self.game_facade)
+          # Gradio interface reference
+        self.gradio_interface: Optional[gr.Blocks] = None
+        
+        # Background tasks
+        self._cleanup_task = None
+        self._auto_refresh_task = None
+        
+    def create_gradio_interface(self) -> gr.Blocks:
+        """Create and configure the Gradio interface."""
+        # Use the ImprovedInterfaceManager to create the complete interface with proper event handling
+        self.gradio_interface = self.interface_manager.create_interface()
+        return self.gradio_interface
     
-    # Create basic fallback if even simple interface fails
-    with gr.Blocks(title="MMORPG - Limited Mode") as interface:
-        gr.Markdown("""
-        # 🎮 MMORPG Application - Limited Mode
+    def start_background_tasks(self):
+        """Start background tasks for game maintenance."""
         
-        **Note:** Running in limited mode due to import issues.
+        def cleanup_task():
+            """Background task for cleaning up inactive players."""
+            while True:
+                try:
+                    self.game_facade.cleanup_inactive_players()
+                    threading.Event().wait(30)  # Wait 30 seconds
+                except Exception as e:
+                    print(f"Error in cleanup task: {e}")
+                    threading.Event().wait(5)  # Wait before retry
         
-        This is a simplified version that focuses on core functionality.
-        """)
+        def auto_refresh_task():
+            """Background task for auto-refreshing game state."""
+            while True:
+                try:
+                    # Trigger refresh for active sessions
+                    # This would need session tracking for real implementation
+                    threading.Event().wait(2)  # Refresh every 2 seconds
+                except Exception as e:
+                    print(f"Error in auto-refresh task: {e}")
+                    threading.Event().wait(5)  # Wait before retry
         
-        with gr.Tab("🔍 SearchHF Oracle"):
-            gr.Markdown("""
-            ## 🔍 SearchHF Oracle
-            
-            Advanced Hugging Face search using MCP integration.
-            """)
-            
-            query_input = gr.Textbox(
-                label="Search Query", 
-                placeholder="e.g., 'text-generation models'"
-            )
-            search_btn = gr.Button("🔍 Search", variant="primary")
-            search_output = gr.Textbox(
-                label="Search Results",
-                lines=10,
-                interactive=False
-            )
-            
-            def simple_search(query):
-                if not query.strip():
-                    return "❌ Please enter a search query"
-                return f"🔍 **Search Results for:** {query}\n\n⚠️ Full MCP integration not available in this environment.\n\nTo use full functionality, please run locally."
-            
-            search_btn.click(
-                simple_search,
-                inputs=[query_input],
-                outputs=[search_output]
-            )
+        # Start cleanup task
+        self._cleanup_task = threading.Thread(target=cleanup_task, daemon=True)
+        self._cleanup_task.start()
         
-        with gr.Tab("ℹ️ About"):
-            gr.Markdown("""
-            # About MMORPG Application
-            
-            This is an AI-powered MMORPG with:
-            - **MCP Integration** - Model Context Protocol for AI agents
-            - **Dynamic NPCs** - AI-powered non-player characters  
-            - **Plugin System** - Extensible addon architecture
-            - **Real-time Chat** - Multi-channel communication
-            - **Trading System** - Virtual economy
-            
-            ## 🚀 Full Version
-            
-            For the complete experience with all features, please run the application locally.
-            
-            ## 🔧 Technical Details
-            
-            - **Framework:** Gradio + Python
-            - **AI Integration:** MCP (Model Context Protocol)
-            - **Architecture:** Clean architecture with dependency injection
-            """)
+        # Start auto-refresh task
+        self._auto_refresh_task = threading.Thread(target=auto_refresh_task, daemon=True)
+        self._auto_refresh_task.start()
     
-    return interface
-
-def main():
-    """Main application entry point for HuggingFace Spaces."""
-    try:
-        # Try to import the full application
-        from src.core.game_engine import GameEngine
-        from src.facades.game_facade import GameFacade
-        from src.ui.huggingface_ui import HuggingFaceUI
-        from src.ui.improved_interface_manager import ImprovedInterfaceManager
-        from src.mcp.mcp_tools import GradioMCPTools
+    def run(self, share: bool = False, server_port: int = 7860):
+        """Run the MMORPG application."""
+        print("🎮 Starting MMORPG Application...")
+        print("🏗️  Initializing game engine...")
+          # Initialize game world and services
+        if not self.game_engine.start():
+            print("❌ Failed to start game engine")
+            return
         
-        # Initialize full application
-        game_engine = GameEngine()
-        game_facade = GameFacade()
-        ui = HuggingFaceUI(game_facade)
-        interface_manager = ImprovedInterfaceManager(game_facade, ui)
+        print("🎨 Creating user interface...")
         
-        # Create the complete interface
-        interface = interface_manager.create_interface()
+        # Create Gradio interface
+        interface = self.create_gradio_interface()
         
-        print("✅ Full MMORPG application loaded successfully!")
+        print("🔧 Starting background tasks...")
         
-    except Exception as e:
-        print(f"⚠️ Failed to load full application: {e}")
-        print("🔄 Falling back to limited mode...")
+        # Start background maintenance tasks
+        self.start_background_tasks()
         
-        # Create fallback interface
-        interface = create_fallback_interface()
-    
-    # Launch the interface
-    interface.launch(
-        #server_name="0.0.0.0",
-        #server_port=7860,  # Standard HF port
-        share=True,
-        debug=True,
-       # quiet=False
-    )
+        print("🚀 Launching server...")
+        print(f"🌐 Server will be available at: http://localhost:{server_port}")
+        
+        if share:
+            print("🔗 Public URL will be generated...")
+        
+        # Launch the interface
+        interface.launch(
+            share=True, #override
+            debug=True,
+           # server_port=server_port,
+            mcp_server=True,  # Enable MCP server integration
+            show_error=True,
+            quiet=False
+        )
+
+def main():
+    """Main entry point for the application."""
+    # Create and run the application
+    app = MMORPGApplication()
+    # Run with default settings
+    # Change share=True to make it publicly accessible
+    app.run(share=True, server_port=7869)
 
 if __name__ == "__main__":
     main()