save monster and geenrate monster fixed

app.py

@@ -71,31 +71,45 @@ def generate_monster(oauth_profile: gr.OAuthProfile | None, audio_input=None, te
         monster = game_mechanics.create_monster(result, {
             "training_focus": training_focus,
             "care_level": care_level
-        })
+        }, user_id)
         
         # Save to persistent storage
         state_manager.save_monster(user_id, monster)
         
         # Prepare response
-        return {
+        response_dict = {
             "message": f"✨ {monster.name} has been created!",
             "image": result.get('image'),
             "model_3d": result.get('model_3d'),
             "stats": monster.get_stats_display(),
             "dialogue": result.get('dialogue', "🤖💚1️⃣0️⃣0️⃣")
         }
+        return (
+            response_dict["message"],
+            response_dict["image"],
+            response_dict["model_3d"],
+            response_dict["stats"],
+            response_dict["dialogue"]
+        )
         
     except Exception as e:
         print(f"Error generating monster: {str(e)}")
         # Use fallback generation
         fallback_result = pipeline.fallback_generation(text_input or "friendly digital creature")
-        return {
+        fallback_dict = {
             "message": "⚡ Created using quick generation mode",
             "image": fallback_result.get('image'),
             "model_3d": None,
             "stats": fallback_result.get('stats'),
             "dialogue": "🤖❓9️⃣9️⃣"
         }
+        return (
+            fallback_dict["message"],
+            fallback_dict["image"],
+            fallback_dict["model_3d"],
+            fallback_dict["stats"],
+            fallback_dict["dialogue"]
+        )
 
 # Training function
 def train_monster(oauth_profile: gr.OAuthProfile | None, training_type, intensity):

core/game_mechanics.py

@@ -4,6 +4,8 @@ from datetime import datetime, timedelta
 from typing import Dict, List, Any, Optional
 from dataclasses import dataclass, asdict
 import numpy as np
+from PIL import Image
+import os
 
 @dataclass
 class Monster:
@@ -135,7 +137,7 @@ class GameMechanics:
             }
         }
     
-    def create_monster(self, generation_result: Dict[str, Any], user_preferences: Dict = None) -> Monster:
+    def create_monster(self, generation_result: Dict[str, Any], user_preferences: Dict = None, user_id: str = "unknown") -> Monster:
         """Create a new monster from AI generation results"""
         
         traits = generation_result.get('traits', {})
@@ -158,6 +160,10 @@ class GameMechanics:
         # Create monster name
         name = traits.get('name', self._generate_name(traits))
         
+        # Convert PIL Images to file paths
+        image_path = self._convert_image_to_path(generation_result.get('image'), user_id, name)
+        model_3d_path = self._convert_image_to_path(generation_result.get('model_3d'), user_id, name)
+        
         # Create monster instance
         monster = Monster(
             name=name,
@@ -167,12 +173,42 @@ class GameMechanics:
             care_state=care_state,
             personality=personality,
             birth_time=datetime.now(),
-            image_path=generation_result.get('image'),
-            model_3d_path=generation_result.get('model_3d')
+            image_path=image_path,
+            model_3d_path=model_3d_path
         )
         
         return monster
     
+    def _convert_image_to_path(self, image_data, user_id: str, monster_name: str) -> Optional[str]:
+        """Convert PIL Image to file path for storage"""
+        if image_data is None:
+            return None
+            
+        # If it's already a string path, return it
+        if isinstance(image_data, str):
+            return image_data
+            
+        # If it's a PIL Image, save it to a file
+        if hasattr(image_data, 'save'):  # PIL Image check
+            try:
+                # Create user-specific monsters directory
+                monsters_dir = Path("./data/monsters") / user_id
+                monsters_dir.mkdir(parents=True, exist_ok=True)
+                
+                # Generate unique filename
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                image_path = monsters_dir / f"{monster_name}_{timestamp}.png"
+                
+                # Save the image
+                image_data.save(image_path)
+                return str(image_path)
+                
+            except Exception as e:
+                print(f"Error saving image: {e}")
+                return None
+                
+        return None
+    
     def _generate_base_stats(self, traits: Dict, focus: str) -> Dict[str, int]:
         """Generate base stats based on traits and focus"""
         # Base values