Add MCP support to the game and integrate NL-to-MCP translation capabilities

app.py

@@ -24,7 +24,6 @@ import uuid
 # Import localization and AI systems
 from localization import LOCALIZATION
 from ai_analysis import get_ai_analyzer, get_model_download_status
-from nl_to_mcp_translator import translate_nl_to_mcp  # Add NL translation import
 
 # Game Constants
 TILE_SIZE = 40
@@ -1084,309 +1083,452 @@ class ConnectionManager:
                     pass
     
     async def launch_nuke(self, player_id: int, target: Position):
-        """
-        Launch a nuclear missile at the target location.
+        """Launch nuclear strike at target location"""
+        # Damage radius: 200 pixels = 5 tiles
+        NUKE_DAMAGE_RADIUS = 200.0
+        NUKE_MAX_DAMAGE = 200  # Maximum damage at center
         
-        Args:
-            player_id (int): The ID of the player launching the nuke.
-            target (Position): The target location for the nuke.
-        """
-        # Check if player has superweapon ready
-        player = self.game_state.players.get(player_id)
-        if not player or not player.superweapon_ready:
-            return {"success": False, "error": "Superweapon not ready"}
+        # Damage all units within radius
+        units_to_remove = []
+        for unit_id, unit in self.game_state.units.items():
+            distance = unit.position.distance_to(target)
+            if distance <= NUKE_DAMAGE_RADIUS:
+                # Damage decreases with distance (full damage at center, 50% at edge)
+                damage_factor = 1.0 - (distance / NUKE_DAMAGE_RADIUS) * 0.5
+                damage = int(NUKE_MAX_DAMAGE * damage_factor)
+                
+                unit.health -= damage
+                if unit.health <= 0:
+                    units_to_remove.append(unit_id)
         
-        # Find all units in the target area (5x5 tiles)
-        affected_units = []
-        for unit in self.game_state.units.values():
-            if unit.position.x >= target.x - TILE_SIZE and unit.position.x <= target.x + TILE_SIZE and \
-               unit.position.y >= target.y - TILE_SIZE and unit.position.y <= target.y + TILE_SIZE:
-                affected_units.append(unit)
+        # Remove destroyed units
+        for unit_id in units_to_remove:
+            del self.game_state.units[unit_id]
         
-        # Find all buildings in the target area
-        affected_buildings = []
-        for building in self.game_state.buildings.values():
-            if building.position.x >= target.x - TILE_SIZE and building.position.x <= target.x + TILE_SIZE and \
-               building.position.y >= target.y - TILE_SIZE and building.position.y <= target.y + TILE_SIZE:
-                affected_buildings.append(building)
+        # Damage buildings within radius
+        buildings_to_remove = []
+        for building_id, building in self.game_state.buildings.items():
+            distance = building.position.distance_to(target)
+            if distance <= NUKE_DAMAGE_RADIUS:
+                # Damage decreases with distance
+                damage_factor = 1.0 - (distance / NUKE_DAMAGE_RADIUS) * 0.5
+                damage = int(NUKE_MAX_DAMAGE * damage_factor)
+                
+                building.health -= damage
+                if building.health <= 0:
+                    buildings_to_remove.append(building_id)
         
-        # Deal damage to units (50% chance to destroy each unit)
-        for unit in affected_units:
-            if random.random() < 0.5:
-                # Destroyed
-                del self.game_state.units[unit.id]
-            else:
-                # Damaged (survived)
-                unit.health = max(1, unit.health - 50)
+        # Remove destroyed buildings
+        for building_id in buildings_to_remove:
+            del self.game_state.buildings[building_id]
         
-        # Destroy buildings (except HQ, which cannot be destroyed by nukes)
-        for building in affected_buildings:
-            if building.type != BuildingType.HQ:
-                del self.game_state.buildings[building.id]
+        print(f"💥 NUKE launched by player {player_id} at ({target.x:.0f}, {target.y:.0f})")
+        print(f"   Destroyed {len(units_to_remove)} units and {len(buildings_to_remove)} buildings")
+    
+    async def handle_command(self, command: dict):
+        """Handle game commands from clients"""
+        cmd_type = command.get("type")
         
-        # Reset superweapon charge
-        player.superweapon_charge = 0
-        player.superweapon_ready = False
+        if cmd_type == "move_unit":
+            unit_ids = command.get("unit_ids", [])
+            target = command.get("target")
+            if target and "x" in target and "y" in target:
+                base_target = Position(target["x"], target["y"])
+                
+                # If multiple units, spread them in a formation
+                if len(unit_ids) > 1:
+                    # Formation pattern: circular spread around target
+                    radius = 30.0  # Distance between units in formation
+                    for idx, uid in enumerate(unit_ids):
+                        if uid in self.game_state.units:
+                            unit = self.game_state.units[uid]
+                            
+                            # Calculate offset position in circular formation
+                            angle = (idx * 360.0 / len(unit_ids)) * (3.14159 / 180.0)
+                            offset_x = radius * (1 + idx // 8) * 0.707106781 * ((idx % 2) * 2 - 1)
+                            offset_y = radius * (1 + idx // 8) * 0.707106781 * (((idx + 1) % 2) * 2 - 1)
+                            
+                            unit.target = Position(
+                                base_target.x + offset_x,
+                                base_target.y + offset_y
+                            )
+                            
+                            # FIX: Clear combat target and set manual order flag
+                            unit.target_unit_id = None
+                            unit.manual_order = True
+                            
+                            # If it's a Harvester, enable manual control to override AI
+                            if unit.type == UnitType.HARVESTER:
+                                unit.manual_control = True
+                                # Clear AI state
+                                unit.gathering = False
+                                unit.returning = False
+                                unit.ore_target = None
+                else:
+                    # Single unit - move to exact target
+                    for uid in unit_ids:
+                        if uid in self.game_state.units:
+                            unit = self.game_state.units[uid]
+                            unit.target = base_target
+                            
+                            # FIX: Clear combat target and set manual order flag
+                            unit.target_unit_id = None
+                            unit.manual_order = True
+                            
+                            # If it's a Harvester, enable manual control to override AI
+                            if unit.type == UnitType.HARVESTER:
+                                unit.manual_control = True
+                                # Clear AI state
+                                unit.gathering = False
+                                unit.returning = False
+                                unit.ore_target = None
         
-        # Broadcast nuke launch event
-        await self.broadcast({
-            "type": "nuke_launched",
-            "player_id": player_id,
-            "target": target.to_dict(),
-            "affected_units": [u.to_dict() for u in affected_units],
-            "affected_buildings": [b.to_dict() for b in affected_buildings]
-        })
+        elif cmd_type == "attack_unit":
+            attacker_ids = command.get("attacker_ids", [])
+            target_id = command.get("target_id")
+            
+            for uid in attacker_ids:
+                if uid in self.game_state.units and target_id in self.game_state.units:
+                    attacker = self.game_state.units[uid]
+                    attacker.target_unit_id = target_id
+                    attacker.target_building_id = None  # Clear building target
+                    attacker.manual_order = True  # Set manual order flag
         
-        return {"success": True, "message": "Nuclear missile launched"}
-    
-    async def execute_mcp_call(self, mcp_call: dict) -> dict:
-        """Execute an MCP tool call on the game state"""
-        tool = mcp_call.get("tool")
-        args = mcp_call.get("args", {})
+        elif cmd_type == "attack_building":
+            attacker_ids = command.get("attacker_ids", [])
+            target_id = command.get("target_id")
+            
+            for uid in attacker_ids:
+                if uid in self.game_state.units and target_id in self.game_state.buildings:
+                    attacker = self.game_state.units[uid]
+                    attacker.target_building_id = target_id
+                    attacker.target_unit_id = None  # Clear unit target
+                    attacker.manual_order = True  # Set manual order flag
         
-        try:
-            if tool == "get_game_state":
-                return {
-                    "action": "get_game_state",
-                    "data": self.game_state.to_dict()
-                }
+        elif cmd_type == "build_unit":
+            unit_type_str = command.get("unit_type")
+            player_id = command.get("player_id", 0)
+            preferred_building_id = command.get("building_id")  # optional: choose production building
             
-            elif tool == "move_units":
-                unit_ids = args.get("unit_ids", [])
-                target_x = args.get("target_x", 0)
-                target_y = args.get("target_y", 0)
-                
-                # Find units by type or ID
-                moved_units = []
-                for unit_id, unit in self.game_state.units.items():
-                    if unit.player_id == 0:  # Player units
-                        if unit.type.name.lower() in unit_ids or unit_id in unit_ids:
-                            unit.target = Position(target_x, target_y)
-                            moved_units.append(unit_id)
-                
-                return {
-                    "action": "move_units",
-                    "units_moved": len(moved_units),
-                    "target": (target_x, target_y)
-                }
+            if not unit_type_str:
+                return
             
-            elif tool == "attack_unit":
-                attacker_ids = args.get("attacker_ids", [])
-                target_id = args.get("target_id", "")
-                
-                # Find target unit
-                target_unit = None
-                for unit_id, unit in self.game_state.units.items():
-                    if unit.player_id == 1 and (unit_id == target_id or str(unit.type).lower() == target_id.lower()):
-                        target_unit = unit
-                        break
-                
-                if target_unit:
-                    # Set attackers to target this unit
-                    attackers_set = 0
-                    for unit_id, unit in self.game_state.units.items():
-                        if unit.player_id == 0:  # Player units
-                            if unit.type.name.lower() in attacker_ids or unit_id in attacker_ids:
-                                unit.target_unit_id = target_unit.id
-                                attackers_set += 1
-                    
-                    return {
-                        "action": "attack_unit",
-                        "target": target_id,
-                        "attackers": attackers_set
-                    }
-                else:
-                    return {
-                        "action": "attack_unit",
-                        "error": f"Target unit {target_id} not found"
-                    }
+            try:
+                unit_type = UnitType(unit_type_str)
+            except ValueError:
+                return
             
-            elif tool == "build_building":
-                building_type = args.get("building_type", "")
-                position_x = args.get("position_x", 0)
-                position_y = args.get("position_y", 0)
-                player_id = args.get("player_id", 0)
-                
-                # Map building type string to enum
-                building_map = {
-                    "hq": BuildingType.HQ,
-                    "power_plant": BuildingType.POWER_PLANT,
-                    "barracks": BuildingType.BARRACKS,
-                    "war_factory": BuildingType.WAR_FACTORY,
-                    "refinery": BuildingType.REFINERY,
-                    "defense_turret": BuildingType.DEFENSE_TURRET
-                }
-                
-                building_enum = building_map.get(building_type.lower())
-                if building_enum:
-                    # Check if player has enough credits
-                    player = self.game_state.players.get(player_id)
-                    building_cost = {
-                        BuildingType.HQ: 0,  # Can't build HQ
-                        BuildingType.POWER_PLANT: 300,
-                        BuildingType.BARRACKS: 500,
-                        BuildingType.WAR_FACTORY: 800,
-                        BuildingType.REFINERY: 600,
-                        BuildingType.DEFENSE_TURRET: 400
-                    }
-                    
-                    cost = building_cost.get(building_enum, 1000)
-                    if player and player.credits >= cost:
-                        player.credits -= cost
-                        building_id = str(uuid.uuid4())
-                        
-                        self.game_state.buildings[building_id] = Building(
-                            id=building_id,
-                            type=building_enum,
-                            player_id=player_id,
-                            position=Position(position_x, position_y),
-                            health=500,
-                            max_health=500,
-                            production_queue=[],
-                            production_progress=0
-                        )
-                        
-                        return {
-                            "action": "build_building",
-                            "building": building_type,
-                            "position": (position_x, position_y),
-                            "cost": cost
-                        }
-                    else:
-                        return {
-                            "action": "build_building",
-                            "error": f"Not enough credits. Need {cost}, have {player.credits if player else 0}"
-                        }
-                else:
-                    return {
-                        "action": "build_building",
-                        "error": f"Unknown building type: {building_type}"
-                    }
+            # RED ALERT: Check cost!
+            cost = UNIT_COSTS.get(unit_type, 0)
+            player_language = self.game_state.players[player_id].language if player_id in self.game_state.players else "en"
+            current_credits = self.game_state.players[player_id].credits if player_id in self.game_state.players else 0
             
-            elif tool == "get_ai_analysis":
-                language = args.get("language", "fr")
-                # Use the existing AI analysis system
-                from ai_analysis import get_ai_analyzer
-                analyzer = get_ai_analyzer()
-                if analyzer:
-                    analysis = analyzer.summarize_combat_situation(self.game_state.to_dict(), language)
-                    return {
-                        "action": "get_ai_analysis",
-                        "analysis": analysis
-                    }
-                else:
-                    return {
-                        "action": "get_ai_analysis",
-                        "error": "AI analyzer not available"
-                    }
+            if current_credits < cost:
+                # Not enough credits! (translated)
+                message = LOCALIZATION.translate(
+                    player_language, 
+                    "notification.insufficient_credits", 
+                    cost=cost, 
+                    current=current_credits
+                )
+                await self.broadcast({
+                    "type": "notification",
+                    "message": message,
+                    "level": "error"
+                })
+                return
             
-            else:
-                return {
-                    "action": "unknown_tool",
-                    "error": f"Unknown MCP tool: {tool}"
-                }
-                
-        except Exception as e:
-            return {
-                "action": "error",
-                "error": str(e)
-            }
-    
-    async def handle_nl_command(self, websocket: WebSocket, command: str):
-        """Handle natural language commands from users"""
-        try:
-            # Translate NL to MCP
-            translation_result = translate_nl_to_mcp(command)
+            # Find required building type
+            required_building = PRODUCTION_REQUIREMENTS.get(unit_type)
+            
+            if not required_building:
+                return
+            
+            # If provided, use preferred building if valid
+            suitable_building = None
+            if preferred_building_id and preferred_building_id in self.game_state.buildings:
+                b = self.game_state.buildings[preferred_building_id]
+                if b.player_id == player_id and b.type == required_building:
+                    suitable_building = b
             
-            if translation_result.get("success"):
-                mcp_call = translation_result["translation"]
+            # Otherwise choose least busy eligible building
+            if not suitable_building:
+                eligible = [
+                    b for b in self.game_state.buildings.values()
+                    if b.player_id == player_id and b.type == required_building
+                ]
+                if eligible:
+                    suitable_building = min(eligible, key=lambda b: len(b.production_queue))
+            
+            if suitable_building:
+                # RED ALERT: Deduct credits!
+                self.game_state.players[player_id].credits -= cost
                 
-                # Execute the MCP call
-                result = await self.execute_mcp_call(mcp_call)
+                # Add to production queue
+                suitable_building.production_queue.append(unit_type_str)
                 
-                # Send response back to user
-                await websocket.send_json({
-                    "type": "nl_command_response",
-                    "original_command": command,
-                    "translation": mcp_call,
-                    "result": result,
-                    "success": True
+                # Translated notification
+                unit_name = LOCALIZATION.translate(player_language, f"unit.{unit_type_str}")
+                message = LOCALIZATION.translate(player_language, "notification.unit_training", unit=unit_name)
+                await self.broadcast({
+                    "type": "notification",
+                    "message": message,
+                    "level": "success"
                 })
             else:
-                # Send error response
-                await websocket.send_json({
-                    "type": "nl_command_response",
-                    "original_command": command,
-                    "error": translation_result.get("error", "Translation failed"),
-                    "clarification": translation_result.get("clarification", ""),
-                    "success": False
+                # Translated requirement message
+                unit_name = LOCALIZATION.translate(player_language, f"unit.{unit_type_str}")
+                building_name = LOCALIZATION.translate(player_language, f"building.{required_building.value}")
+                message = LOCALIZATION.translate(
+                    player_language, 
+                    "notification.unit_requires", 
+                    unit=unit_name, 
+                    requirement=building_name
+                )
+                await self.broadcast({
+                    "type": "notification",
+                    "message": message,
+                    "level": "error"
                 })
+        
+        elif cmd_type == "build_building":
+            building_type_str = command.get("building_type")
+            position = command.get("position")
+            player_id = command.get("player_id", 0)
+            
+            if not building_type_str or not position:
+                return
+            
+            try:
+                building_type = BuildingType(building_type_str)
+            except ValueError:
+                return
+            
+            # RED ALERT: Check cost!
+            cost = BUILDING_COSTS.get(building_type, 0)
+            player_language = self.game_state.players[player_id].language if player_id in self.game_state.players else "en"
+            current_credits = self.game_state.players[player_id].credits if player_id in self.game_state.players else 0
+            
+            if current_credits < cost:
+                # Not enough credits! (translated)
+                message = LOCALIZATION.translate(
+                    player_language, 
+                    "notification.insufficient_credits", 
+                    cost=cost, 
+                    current=current_credits
+                )
+                await self.broadcast({
+                    "type": "notification",
+                    "message": message,
+                    "level": "error"
+                })
+                return
+            
+            # Rule: limit multiple same-type buildings if disabled
+            if not ALLOW_MULTIPLE_SAME_BUILDING and building_type != BuildingType.HQ:
+                for b in self.game_state.buildings.values():
+                    if b.player_id == player_id and b.type == building_type:
+                        message = LOCALIZATION.translate(player_language, "notification.building_limit_one", building=LOCALIZATION.translate(player_language, f"building.{building_type_str}"))
+                        await self.broadcast({"type":"notification","message":message,"level":"error"})
+                        return
+            
+            # Enforce HQ build radius
+            # Find player's HQ
+            hq = None
+            for b in self.game_state.buildings.values():
+                if b.player_id == player_id and b.type == BuildingType.HQ:
+                    hq = b
+                    break
+            if hq and position and "x" in position and "y" in position:
+                max_dist = HQ_BUILD_RADIUS_TILES * TILE_SIZE
+                dx = position["x"] - hq.position.x
+                dy = position["y"] - hq.position.y
+                if (dx*dx + dy*dy) ** 0.5 > max_dist:
+                    message = LOCALIZATION.translate(player_language, "notification.building_too_far_from_hq")
+                    await self.broadcast({"type":"notification","message":message,"level":"error"})
+                    return
+            
+            # RED ALERT: Deduct credits!
+            self.game_state.players[player_id].credits -= cost
+            
+            if position and "x" in position and "y" in position:
+                self.game_state.create_building(
+                    building_type,
+                    player_id,
+                    Position(position["x"], position["y"])
+                )
                 
-        except Exception as e:
-            await websocket.send_json({
-                "type": "nl_command_response",
-                "original_command": command,
-                "error": f"Command processing error: {str(e)}",
-                "success": False
-            })
-    
-    async def handle_message(self, websocket: WebSocket, message: dict):
-        """Handle incoming WebSocket messages"""
-        try:
-            if message["type"] == "nl_command":
-                # Handle natural language command
-                nl_text = message.get("text", "")
-                language = message.get("language", "fr")
-                
-                if not nl_text.strip():
-                    await websocket.send_json({
-                        "type": "nl_command_response",
-                        "status": "error",
-                        "message": "Empty command received"
+                # Translated notification
+                building_name = LOCALIZATION.translate(player_language, f"building.{building_type_str}")
+                message = LOCALIZATION.translate(player_language, "notification.building_placed", building=building_name)
+                await self.broadcast({
+                    "type": "notification",
+                    "message": message,
+                    "level": "success"
+                })
+        
+        elif cmd_type == "stop_units":
+            unit_ids = command.get("unit_ids", [])
+            for uid in unit_ids:
+                if uid in self.game_state.units:
+                    self.game_state.units[uid].target = None
+        
+        elif cmd_type == "prepare_nuke":
+            player_id = command.get("player_id", 0)
+            if player_id in self.game_state.players:
+                player = self.game_state.players[player_id]
+                if player.superweapon_ready:
+                    player.nuke_preparing = True
+                    await self.broadcast({
+                        "type": "nuke_preparing",
+                        "player_id": player_id
                     })
-                    return
+        
+        elif cmd_type == "cancel_nuke":
+            player_id = command.get("player_id", 0)
+            if player_id in self.game_state.players:
+                self.game_state.players[player_id].nuke_preparing = False
+        
+        elif cmd_type == "launch_nuke":
+            player_id = command.get("player_id", 0)
+            target = command.get("target")
+            
+            if player_id in self.game_state.players and target:
+                player = self.game_state.players[player_id]
                 
-                # Translate natural language to MCP
-                try:
-                    from nl_to_mcp_translator import translate_nl_to_mcp
-                    mcp_call = translate_nl_to_mcp(nl_text, language)
+                if player.superweapon_ready and player.nuke_preparing:
+                    target_pos = Position(target["x"], target["y"])
                     
-                    if mcp_call.get("error"):
-                        await websocket.send_json({
-                            "type": "nl_command_response",
-                            "status": "error",
-                            "message": f"Translation error: {mcp_call['error']}",
-                            "original_text": nl_text
-                        })
-                        return
+                    # Launch nuke effect
+                    await self.launch_nuke(player_id, target_pos)
                     
-                    # Execute the MCP call
-                    result = await self.execute_mcp_call(mcp_call)
+                    # Reset superweapon state
+                    player.superweapon_ready = False
+                    player.superweapon_charge = 0
+                    player.nuke_preparing = False
                     
-                    # Send response back to client
-                    await websocket.send_json({
-                        "type": "nl_command_response",
-                        "status": "success",
-                        "message": f"Command executed: {result.get('action', 'unknown')}",
-                        "result": result,
-                        "original_text": nl_text,
-                        "translated_call": mcp_call
-                    })
-                    
-                    # Broadcast game state update to all clients
-                    state_dict = self.game_state.to_dict()
+                    # Broadcast nuke launch
                     await self.broadcast({
-                        "type": "state_update",
-                        "state": state_dict
+                        "type": "nuke_launched",
+                        "player_id": player_id,
+                        "target": {"x": target_pos.x, "y": target_pos.y}
                     })
+        
+        elif cmd_type == "change_language":
+            player_id = command.get("player_id", 0)
+            language = command.get("language", "en")
+            
+            if player_id in self.game_state.players:
+                # Validate language
+                supported = list(LOCALIZATION.get_supported_languages())
+                if language in supported:
+                    self.game_state.players[player_id].language = language
+                    
+                    # Trigger immediate AI analysis in new language
+                    self.last_ai_analysis_time = 0
                     
-                except Exception as e:
-                    await websocket.send_json({
-                        "type": "nl_command_response",
-                        "status": "error",
-                        "message": f"Command execution failed: {str(e)}",
-                        "original_text": nl_text
+                    await self.broadcast({
+                        "type": "notification",
+                        "message": f"Language changed to {LOCALIZATION.get_display_name(language)}",
+                        "level": "info"
                     })
+        
+        elif cmd_type == "request_ai_analysis":
+            # Force immediate AI analysis
+            await self.run_ai_analysis()
+            
+            await self.broadcast({
+                "type": "ai_analysis_update",
+                "analysis": self.last_ai_analysis
+            })
+
+# Global connection manager
+manager = ConnectionManager()
+
+# Routes
+@app.get("/")
+async def get_home():
+    """Serve the main game interface"""
+    return HTMLResponse(content=open("static/index.html").read())
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint for HuggingFace Spaces"""
+    return {
+        "status": "healthy",
+        "players": len(manager.game_state.players),
+        "units": len(manager.game_state.units),
+        "buildings": len(manager.game_state.buildings),
+        "active_connections": len(manager.active_connections),
+        "ai_available": manager.ai_analyzer.model_available,
+        "supported_languages": list(LOCALIZATION.get_supported_languages())
+    }
+
+@app.get("/api/languages")
+async def get_languages():
+    """Get supported languages"""
+    languages = []
+    for lang_code in LOCALIZATION.get_supported_languages():
+        languages.append({
+            "code": lang_code,
+            "name": LOCALIZATION.get_display_name(lang_code)
+        })
+    return {"languages": languages}
+
+@app.get("/api/translations/{language}")
+async def get_translations(language: str):
+    """Get all translations for a language"""
+    from localization import TRANSLATIONS
+    if language not in TRANSLATIONS:
+        language = "en"
+    return {"translations": TRANSLATIONS[language], "language": language}
+
+@app.post("/api/player/{player_id}/language")
+async def set_player_language(player_id: int, language: str):
+    """Set player's preferred language"""
+    if player_id in manager.game_state.players:
+        manager.game_state.players[player_id].language = language
+        return {"success": True, "language": language}
+    return {"success": False, "error": "Player not found"}
+
+@app.get("/api/ai/status")
+async def get_ai_status():
+    """Get AI analyzer status"""
+    return {
+        "available": manager.ai_analyzer.model_available,
+        "model_path": manager.ai_analyzer.model_path if manager.ai_analyzer.model_available else None,
+        "last_analysis": manager.last_ai_analysis
+    }
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    """WebSocket endpoint for real-time game communication"""
+    await manager.connect(websocket)
+    
+    try:
+        # Send initial state
+        await websocket.send_json({
+            "type": "init",
+            "state": manager.game_state.to_dict()
+        })
+        
+        # Handle incoming messages
+        while True:
+            data = await websocket.receive_json()
+            await manager.handle_command(data)
+    
+    except WebSocketDisconnect:
+        manager.disconnect(websocket)
+    except Exception as e:
+        print(f"WebSocket error: {e}")
+        manager.disconnect(websocket)
+
+# Mount static files (will be created next)
+try:
+    app.mount("/static", StaticFiles(directory="static"), name="static")
+except:
+    pass
 
-            # Handle other message types here...
-            # ...existing code...
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

todos.txt

@@ -1,2 +1,2 @@
-1. Evaluate SLMs on MCP capability
-2. Integrate the best one into app to perform NL-to-MCP translation
+0. Bring MCP support to the game
+1. Integrate the best one into app to perform NL-to-MCP translation