Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py - SIMCIUDAD ARGENTINA FUNCIONAL Y ÉPICO
+# app.py - SIMCIUDAD ARGENTINA FUNCIONAL COMPLETA
 import gradio as gr
 import time
 import math
@@ -7,587 +7,1021 @@ import os
 from PIL import Image, ImageDraw
 import json
 
-# Groq AI Integration
+# Groq AI Integration (mejorada)
 try:
     from groq import Groq
     GROQ_AVAILABLE = True
-    groq_client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+    groq_client = Groq(api_key=os.getenv("GROQ_API_KEY")) if os.getenv("GROQ_API_KEY") else None
 except ImportError:
     GROQ_AVAILABLE = False
     groq_client = None
 
 class AIUrbanPlanner:
-    """IA para planificación urbana argentina"""
+    """IA para planificación urbana argentina con Groq"""
     def __init__(self):
         self.enabled = GROQ_AVAILABLE and groq_client is not None
         
     def generate_city_advice(self, city_state):
-        """Genera consejos de planificación urbana"""
+        """Genera consejos de planificación urbana inteligentes"""
         if not self.enabled:
-            return "Construí más plazas para aumentar la felicidad de los vecinos."
+            fallback_advice = [
+                "Construí más plazas para aumentar la felicidad vecinal.",
+                "Las parrillas mejoran la cultura y la moral del barrio.",
+                "Balanceá viviendas con servicios públicos.",
+                "Las canchas de fútbol son clave para la identidad argentina."
+            ]
+            return random.choice(fallback_advice)
         
         try:
             prompt = f"""
             Sos un urbanista argentino experto. Analizá esta ciudad y dá consejos breves:
             
-            Población: {city_state.get('population', 0)}
+            Población: {city_state.get('population', 0)} habitantes
             Felicidad: {city_state.get('happiness', 0)}%
-            Presupuesto: ${city_state.get('budget', 0)}
+            Presupuesto: ${city_state.get('budget', 0):,}
             Edificios: {city_state.get('buildings', 0)}
+            Identidad Cultural: {city_state.get('culture', 80)}%
             
-            Dá UN consejo específico y argentino en 1-2 líneas máximo.
+            Dá UN consejo específico y argentino en máximo 2 líneas.
+            Usá jerga porteña cuando sea apropiado.
             """
             
             response = groq_client.chat.completions.create(
                 messages=[{"role": "user", "content": prompt}],
                 model="llama-3.1-8b-instant",
-                temperature=0.7,
-                max_tokens=80
+                temperature=0.8,
+                max_tokens=100
             )
             
             return response.choices[0].message.content.strip()
-        except:
-            return "La ciudad necesita más espacios verdes para el bienestar."
+        except Exception as e:
+            print(f"Error Groq: {e}")
+            return "La ciudad necesita más espacios verdes y culturales para prosperar."
 
-class ArgentineCityEngine:
-    """Motor de la ciudad argentina"""
+class ArgentineCityBuilder:
+    """SimCity Argentino con mecánicas revolucionarias"""
     def __init__(self):
-        # Estado básico de la ciudad
-        self.population = 150
+        self.width, self.height = 1000, 700
+        self.grid_size = 20
+        self.city_grid = {}  # Coordenadas -> tipo de edificio
+        self.population = 100
         self.happiness = 75
-        self.budget = 25000
-        self.buildings = {}
-        self.grid_size = 30
+        self.economy = 1000
+        self.inflation = 1.0
+        self.cultural_identity = 90
+        
+        # Sistemas dinámicos
+        self.neighborhoods = {}
+        self.transport_network = {}
+        self.cultural_centers = {}
+        self.businesses = {}
         
-        # Recursos
+        # Recursos complejos (CORREGIDO - todos los recursos necesarios)
         self.resources = {
+            'presupuesto': 50000,
             'energia': 100,
             'agua': 100,
             'seguridad': 70,
             'educacion': 60,
             'salud': 65,
             'cultura': 80,
-            'empleo': 75
+            'empleo': 75,
+            'vivienda': 50,
+            'transport': 60,  # AGREGADO
+            'pollution': 0    # AGREGADO
         }
         
-        # Tipos de edificios
+        # Edificios disponibles (CORREGIDOS - todos los efectos)
         self.building_types = {
-            'casa': {'cost': 1000, 'color': (139, 69, 19), 'pop': 4, 'happiness': 2},
-            'villa': {'cost': 500, 'color': (255, 150, 100), 'pop': 8, 'happiness': -2},
-            'edificio': {'cost': 5000, 'color': (150, 150, 200), 'pop': 20, 'happiness': 1},
-            'escuela': {'cost': 8000, 'color': (255, 255, 100), 'educacion': 20, 'happiness': 10},
-            'hospital': {'cost': 15000, 'color': (255, 100, 100), 'salud': 30, 'happiness': 15},
-            'cancha': {'cost': 3000, 'color': (100, 255, 100), 'happiness': 25, 'cultura': 10},
-            'parrilla': {'cost': 2000, 'color': (200, 100, 50), 'happiness': 20, 'cultura': 15},
-            'plaza': {'cost': 1500, 'color': (150, 255, 150), 'happiness': 15, 'cultura': 5},
-            'fabrica': {'cost': 12000, 'color': (150, 100, 100), 'empleo': 30, 'happiness': -5}
+            'casa': {'cost': 1000, 'pop': 4, 'happiness': 2, 'vivienda': 5},
+            'villa': {'cost': 500, 'pop': 8, 'happiness': -2, 'solidarity': 15, 'vivienda': 8},
+            'edificio': {'cost': 5000, 'pop': 20, 'happiness': 1, 'vivienda': 15},
+            'escuela': {'cost': 8000, 'educacion': 20, 'happiness': 10},
+            'hospital': {'cost': 15000, 'salud': 30, 'happiness': 15},
+            'cancha': {'cost': 3000, 'happiness': 25, 'cultura': 10},
+            'parrilla': {'cost': 2000, 'happiness': 20, 'cultura': 15},
+            'centro_cultural': {'cost': 10000, 'cultura': 40, 'educacion': 10},
+            'fabrica': {'cost': 12000, 'empleo': 30, 'pollution': -10, 'happiness': -5},
+            'plaza': {'cost': 1500, 'happiness': 15, 'cultura': 5},
+            'subte': {'cost': 20000, 'transport': 50, 'happiness': 10},
+            'comisaria': {'cost': 7000, 'seguridad': 25, 'happiness': -5},
+            'kiosco': {'cost': 800, 'happiness': 5, 'empleo': 2}
         }
         
-        # Inicializar con algunos edificios
-        self._initialize_city()
-        
-    def _initialize_city(self):
-        """Inicializa la ciudad con edificios básicos"""
-        initial_buildings = [
-            (15, 15, 'plaza'),
-            (12, 12, 'casa'),
-            (18, 12, 'casa'),
-            (12, 18, 'casa'),
-            (18, 18, 'casa'),
-            (10, 15, 'escuela')
-        ]
+        # Inicializar ciudad base
+        self._initialize_base_city()
+        
+    def _initialize_base_city(self):
+        """Crea la ciudad inicial con algunos edificios"""
+        # Plaza central
+        self.city_grid[(25, 17)] = 'plaza'
+        
+        # Algunas casas iniciales
+        initial_houses = [(20, 15), (30, 15), (25, 12), (25, 22)]
+        for pos in initial_houses:
+            self.city_grid[pos] = 'casa'
         
-        for x, y, building_type in initial_buildings:
-            self.buildings[(x, y)] = building_type
+        # Una escuela inicial
+        self.city_grid[(15, 20)] = 'escuela'
 
-class CityRenderer:
-    """Renderizador de la ciudad"""
+class AdvancedCityRenderer:
+    """Renderizador avanzado con gráficos isométricos COMPLETO"""
     def __init__(self):
-        self.tile_size = 25
         self.animation_time = 0
+        self.tile_size = 20
         
-    def render_city(self, city_engine) -> Image.Image:
-        """Renderiza la ciudad completa"""
-        width, height = 1000, 700
-        img = Image.new('RGB', (width, height), (30, 50, 30))
+    def render_city_frame(self, city_builder) -> Image.Image:
+        """Renderiza la ciudad con vista isométrica mejorada"""
+        img = Image.new('RGB', (city_builder.width, city_builder.height), (20, 40, 20))
         draw = ImageDraw.Draw(img)
         
         self.animation_time += 0.1
         
-        # Fondo de la ciudad
-        self._draw_background(draw, width, height, city_engine)
+        # Fondo: Cielo dinámico según felicidad
+        self._draw_dynamic_sky(draw, city_builder)
         
-        # Grid de calles
-        self._draw_streets(draw, width, height)
+        # Grid base de la ciudad
+        self._draw_city_grid(draw, city_builder)
         
-        # Edificios
-        self._draw_buildings(draw, city_engine)
+        # Edificios con perspectiva isométrica
+        self._draw_isometric_buildings(draw, city_builder)
         
-        # Efectos dinámicos
-        self._draw_city_effects(draw, city_engine, width, height)
+        # Sistemas dinámicos (tráfico, personas, etc.)
+        self._draw_city_life(draw, city_builder)
+        
+        # UI avanzada
+        self._draw_advanced_ui(draw, city_builder)
+        
+        # Efectos especiales
+        self._draw_special_effects(draw, city_builder)
         
         return img
     
-    def _draw_background(self, draw, width, height, city):
-        """Fondo dinámico según felicidad"""
+    def _draw_dynamic_sky(self, draw, city):
+        """Cielo que cambia según el estado de la ciudad"""
         happiness = city.happiness
         
-        # Color del cielo según felicidad
+        # Color base del cielo
         if happiness > 80:
-            sky_start = (135, 206, 250)
-            sky_end = (100, 149, 237)
+            sky_color = (135, 206, 250)  # Azul cielo feliz
         elif happiness > 60:
-            sky_start = (119, 136, 153)
-            sky_end = (105, 105, 105)
+            sky_color = (176, 196, 222)  # Azul grisáceo
+        elif happiness > 40:
+            sky_color = (119, 136, 153)  # Gris claro
         else:
-            sky_start = (70, 70, 70)
-            sky_end = (50, 50, 50)
+            sky_color = (105, 105, 105)  # Gris oscuro
         
         # Gradiente de cielo
         for y in range(200):
-            ratio = y / 200
-            color = tuple(int(start * (1 - ratio) + end * ratio) 
-                         for start, end in zip(sky_start, sky_end))
-            draw.rectangle([0, y, width, y + 1], fill=color)
+            alpha = 1.0 - (y / 400)
+            color = tuple(int(c * alpha + 20 * (1-alpha)) for c in sky_color)
+            draw.rectangle([0, y, city.width, y+2], fill=color)
         
-        # Base verde
-        draw.rectangle([0, 200, width, height], fill=(40, 80, 40))
+        # Nubes dinámicas
+        cloud_offset = int(self.animation_time * 20) % city.width
+        for i in range(3):
+            x = (i * 300 + cloud_offset) % (city.width + 100)
+            y = 50 + i * 30
+            self._draw_cloud(draw, x, y, happiness)
     
-    def _draw_streets(self, draw, width, height):
-        """Calles de la ciudad"""
-        street_color = (80, 80, 80)
-        
-        # Calles horizontales
-        for y in range(200, height, self.tile_size * 3):
-            draw.rectangle([0, y, width, y + self.tile_size], fill=street_color)
+    def _draw_cloud(self, draw, x, y, happiness):
+        """Dibuja nube con forma según felicidad"""
+        cloud_color = (255, 255, 255) if happiness > 50 else (200, 200, 200)
         
-        # Calles verticales
-        for x in range(0, width, self.tile_size * 3):
-            draw.rectangle([x, 200, x + self.tile_size, height], fill=street_color)
+        # Forma de nube
+        for i in range(5):
+            offset_x = i * 15 + random.randint(-5, 5)
+            offset_y = random.randint(-8, 8)
+            size = 20 + random.randint(-5, 10)
+            draw.ellipse([x + offset_x - size//2, y + offset_y - size//2, 
+                         x + offset_x + size//2, y + offset_y + size//2], 
+                        fill=cloud_color)
+    
+    def _draw_city_grid(self, draw, city):
+        """Grid isométrico de la ciudad"""
+        grid_color = (60, 80, 60) if city.cultural_identity > 50 else (80, 80, 80)
         
-        # Líneas divisorias
-        line_color = (255, 255, 255)
-        for y in range(200, height, self.tile_size):
-            draw.line([(0, y), (width, y)], fill=(60, 80, 60), width=1)
+        # Grid horizontal
+        for y in range(0, city.height, self.tile_size):
+            draw.line([0, y, city.width, y], fill=grid_color, width=1)
         
-        for x in range(0, width, self.tile_size):
-            draw.line([(x, 200), (x, height)], fill=(60, 80, 60), width=1)
+        # Grid vertical
+        for x in range(0, city.width, self.tile_size):
+            draw.line([x, 0, x, city.height], fill=grid_color, width=1)
     
-    def _draw_buildings(self, draw, city):
-        """Dibuja todos los edificios"""
-        for (grid_x, grid_y), building_type in city.buildings.items():
+    def _draw_isometric_buildings(self, draw, city):
+        """Edificios con perspectiva isométrica - TODOS LOS TIPOS"""
+        for (grid_x, grid_y), building_type in city.city_grid.items():
             screen_x = grid_x * self.tile_size
-            screen_y = 200 + grid_y * self.tile_size
+            screen_y = grid_y * self.tile_size
             
-            if building_type in city.building_types:
-                self._draw_single_building(draw, screen_x, screen_y, building_type, city)
-    
-    def _draw_single_building(self, draw, x, y, building_type, city):
-        """Dibuja un edificio específico"""
-        building_info = city.building_types[building_type]
-        color = building_info['color']
-        
-        if building_type == 'casa':
-            self._draw_house(draw, x, y, color)
-        elif building_type == 'villa':
-            self._draw_villa(draw, x, y, color)
-        elif building_type == 'edificio':
-            self._draw_apartment(draw, x, y, color)
-        elif building_type == 'escuela':
-            self._draw_school(draw, x, y, color)
-        elif building_type == 'hospital':
-            self._draw_hospital(draw, x, y, color)
-        elif building_type == 'cancha':
-            self._draw_field(draw, x, y, color)
-        elif building_type == 'parrilla':
-            self._draw_grill(draw, x, y, color)
-        elif building_type == 'plaza':
-            self._draw_plaza(draw, x, y, color)
-        elif building_type == 'fabrica':
-            self._draw_factory(draw, x, y, color)
+            # TODOS los tipos de edificios implementados
+            if building_type == 'casa':
+                self._draw_house_isometric(draw, screen_x, screen_y, city.happiness)
+            elif building_type == 'villa':
+                self._draw_villa_house(draw, screen_x, screen_y, city.cultural_identity)
+            elif building_type == 'edificio':
+                self._draw_apartment_building(draw, screen_x, screen_y, city.economy)
+            elif building_type == 'escuela':
+                self._draw_school(draw, screen_x, screen_y, city.resources['educacion'])
+            elif building_type == 'hospital':
+                self._draw_hospital(draw, screen_x, screen_y, city.resources['salud'])
+            elif building_type == 'cancha':
+                self._draw_soccer_field(draw, screen_x, screen_y, city.happiness)
+            elif building_type == 'parrilla':
+                self._draw_parrilla(draw, screen_x, screen_y, city.cultural_identity)
+            elif building_type == 'plaza':
+                self._draw_plaza(draw, screen_x, screen_y, city.happiness)
+            elif building_type == 'fabrica':
+                self._draw_factory(draw, screen_x, screen_y, city.resources['empleo'])
+            elif building_type == 'centro_cultural':
+                self._draw_cultural_center(draw, screen_x, screen_y, city.resources['cultura'])
+            elif building_type == 'kiosco':
+                self._draw_kiosco(draw, screen_x, screen_y, city.economy)
+            elif building_type == 'subte':
+                self._draw_subway(draw, screen_x, screen_y, city.resources['transport'])
+            elif building_type == 'comisaria':
+                self._draw_police_station(draw, screen_x, screen_y, city.resources['seguridad'])
     
-    def _draw_house(self, draw, x, y, color):
-        """Casa argentina típica"""
-        # Base
-        draw.rectangle([x + 2, y + 8, x + 22, y + 23], fill=color, outline=(0, 0, 0), width=1)
-        # Techo
-        draw.polygon([(x + 1, y + 8), (x + 12, y + 2), (x + 23, y + 8)], 
-                    fill=(160, 82, 45), outline=(100, 50, 25))
+    # TODOS los métodos de dibujo de edificios (implementados completamente)
+    def _draw_house_isometric(self, draw, x, y, happiness):
+        """Casa con perspectiva isométrica"""
+        house_color = (139, 69, 19) if happiness > 60 else (101, 67, 33)
+        
+        # Paredes
+        wall_points = [(x + 2, y + 15), (x + 18, y + 15), (x + 18, y + 2), (x + 2, y + 2)]
+        draw.polygon(wall_points, fill=house_color, outline=(80, 40, 0), width=1)
+        
+        # Techo isométrico
+        roof_color = (160, 82, 45) if happiness > 70 else (120, 60, 30)
+        roof_points = [(x, y), (x + 10, y - 5), (x + 20, y), (x + 10, y + 5)]
+        draw.polygon(roof_points, fill=roof_color, outline=(100, 50, 25))
+        
         # Puerta
-        draw.rectangle([x + 10, y + 15, x + 14, y + 23], fill=(101, 67, 33))
-        # Ventanas
-        draw.rectangle([x + 5, y + 12, x + 8, y + 15], fill=(200, 200, 255), outline=(0, 0, 0))
-        draw.rectangle([x + 16, y + 12, x + 19, y + 15], fill=(200, 200, 255), outline=(0, 0, 0))
+        draw.rectangle([x + 8, y + 10, x + 12, y + 15], fill=(101, 67, 33))
+        
+        # Ventanas con luz según felicidad
+        window_color = (255, 255, 200) if happiness > 50 else (150, 150, 150)
+        draw.rectangle([x + 4, y + 8, x + 7, y + 11], fill=window_color, outline=(0, 0, 0))
+        draw.rectangle([x + 13, y + 8, x + 16, y + 11], fill=window_color, outline=(0, 0, 0))
+        
+        # Jardincito si hay alta felicidad
+        if happiness > 80:
+            for i in range(3):
+                flower_x = x + 2 + i * 4
+                flower_y = y + 16
+                draw.ellipse([flower_x, flower_y, flower_x + 2, flower_y + 2], fill=(255, 100, 150))
     
-    def _draw_villa(self, draw, x, y, color):
-        """Casa de villa colorida"""
+    def _draw_villa_house(self, draw, x, y, cultural_identity):
+        """Casa de villa con colores vibrantes"""
+        villa_colors = [(255, 100, 100), (100, 255, 100), (100, 100, 255), (255, 255, 100), (255, 100, 255)]
+        color = random.choice(villa_colors)
+        
         # Casa principal
-        draw.rectangle([x + 1, y + 10, x + 23, y + 23], fill=color, outline=(0, 0, 0), width=2)
+        draw.rectangle([x, y + 5, x + 20, y + 18], fill=color, outline=(0, 0, 0), width=2)
+        
         # Techo de chapa
-        draw.polygon([(x, y + 10), (x + 12, y + 5), (x + 24, y + 10)], fill=(150, 150, 150))
-        # Extensión
-        draw.rectangle([x + 18, y + 15, x + 24, y + 23], fill=color, outline=(0, 0, 0))
-        # Antena
-        draw.line([(x + 20, y + 5), (x + 20, y + 1)], fill=(200, 200, 200), width=2)
-        draw.ellipse([x + 18, y + 1, x + 22, y + 3], outline=(200, 200, 200))
+        draw.polygon([(x-2, y+5), (x+10, y-2), (x+22, y+5)], fill=(150, 150, 150))
+        
+        # Extensión autoconstruida
+        if cultural_identity > 60:
+            draw.rectangle([x + 16, y + 12, x + 25, y + 18], fill=color, outline=(0, 0, 0))
+        
+        # Antena parabólica
+        draw.ellipse([x + 15, y - 1, x + 18, y + 2], outline=(200, 200, 200), width=2)
+        
+        # Tendedero con ropa
+        draw.line([(x + 2, y + 3), (x + 18, y + 3)], fill=(100, 100, 100), width=1)
+        for i in range(3):
+            cloth_x = x + 4 + i * 5
+            draw.rectangle([cloth_x, y + 3, cloth_x + 3, y + 8], 
+                          fill=random.choice([(255, 0, 0), (0, 255, 0), (0, 0, 255)]))
     
-    def _draw_apartment(self, draw, x, y, color):
+    def _draw_apartment_building(self, draw, x, y, economy):
         """Edificio de departamentos"""
+        building_color = (120, 120, 160) if economy > 5000 else (100, 100, 140)
+        
         # Estructura principal más alta
-        draw.rectangle([x + 1, y + 0, x + 23, y + 23], fill=color, outline=(0, 0, 0), width=1)
+        draw.rectangle([x + 1, y - 10, x + 23, y + 18], fill=building_color, outline=(0, 0, 0), width=1)
+        
         # Ventanas en pisos
-        for floor in range(3):
-            floor_y = y + 5 + floor * 6
+        for floor in range(4):
+            floor_y = y - 5 + floor * 6
             for window in range(3):
                 window_x = x + 4 + window * 6
+                light_on = economy > 3000 and random.random() < 0.7
+                window_color = (255, 255, 200) if light_on else (100, 100, 120)
                 draw.rectangle([window_x, floor_y, window_x + 3, floor_y + 3], 
-                              fill=(255, 255, 200), outline=(0, 0, 0))
+                              fill=window_color, outline=(0, 0, 0))
     
-    def _draw_school(self, draw, x, y, color):
+    def _draw_school(self, draw, x, y, education_level):
         """Escuela con bandera argentina"""
+        school_color = (255, 255, 100) if education_level > 70 else (200, 200, 80)
+        
         # Edificio principal
-        draw.rectangle([x + 1, y + 8, x + 23, y + 23], fill=color, outline=(0, 0, 0), width=2)
+        draw.rectangle([x + 1, y + 8, x + 23, y + 18], fill=school_color, outline=(0, 0, 0), width=2)
+        
         # Bandera argentina
         draw.rectangle([x + 20, y + 2, x + 22, y + 8], fill=(100, 150, 255))  # Azul
         draw.rectangle([x + 20, y + 4, x + 22, y + 6], fill=(255, 255, 255))  # Blanco
+        
         # Asta
         draw.line([(x + 22, y + 8), (x + 22, y + 2)], fill=(139, 69, 19), width=2)
-        # Patio
-        draw.rectangle([x + 5, y + 12, x + 19, y + 20], fill=(200, 200, 200), outline=(150, 150, 150))
+        
+        # Patio escolar
+        draw.rectangle([x + 5, y + 12, x + 19, y + 16], fill=(200, 200, 200), outline=(150, 150, 150))
+        
+        # Niños en el patio si alta educación
+        if education_level > 60:
+            for i in range(3):
+                child_x = x + 7 + i * 4
+                child_y = y + 13
+                draw.ellipse([child_x, child_y, child_x + 2, child_y + 3], fill=(180, 140, 100))
     
-    def _draw_hospital(self, draw, x, y, color):
+    def _draw_hospital(self, draw, x, y, health_level):
         """Hospital con cruz roja"""
+        hospital_color = (255, 100, 100) if health_level > 70 else (200, 80, 80)
+        
         # Edificio
-        draw.rectangle([x + 1, y + 5, x + 23, y + 23], fill=color, outline=(0, 0, 0), width=2)
+        draw.rectangle([x + 1, y + 5, x + 23, y + 18], fill=hospital_color, outline=(0, 0, 0), width=2)
+        
         # Cruz roja
-        draw.rectangle([x + 10, y + 8, x + 14, y + 18], fill=(255, 0, 0))
-        draw.rectangle([x + 7, y + 11, x + 17, y + 15], fill=(255, 0, 0))
-        # Ambulancia
-        draw.rectangle([x + 2, y + 19, x + 10, y + 23], fill=(255, 255, 255), outline=(0, 0, 0))
-        draw.ellipse([x + 3, y + 21, x + 5, y + 23], fill=(0, 0, 0))
-        draw.ellipse([x + 7, y + 21, x + 9, y + 23], fill=(0, 0, 0))
+        draw.rectangle([x + 10, y + 8, x + 14, y + 15], fill=(255, 0, 0))
+        draw.rectangle([x + 7, y + 10, x + 17, y + 13], fill=(255, 0, 0))
+        
+        # Ambulancia si hospital activo
+        if health_level > 50:
+            draw.rectangle([x + 2, y + 15, x + 10, y + 18], fill=(255, 255, 255), outline=(0, 0, 0))
+            draw.ellipse([x + 3, y + 16, x + 5, y + 18], fill=(0, 0, 0))
+            draw.ellipse([x + 7, y + 16, x + 9, y + 18], fill=(0, 0, 0))
     
-    def _draw_field(self, draw, x, y, color):
-        """Cancha de fútbol"""
+    def _draw_soccer_field(self, draw, x, y, happiness):
+        """Cancha de fútbol con actividad"""
         # Césped
-        draw.rectangle([x, y + 5, x + 24, y + 23], fill=color, outline=(255, 255, 255), width=2)
-        # Línea del medio
-        draw.line([(x + 12, y + 5), (x + 12, y + 23)], fill=(255, 255, 255), width=2)
-        # Círculo central
-        draw.ellipse([x + 8, y + 11, x + 16, y + 17], outline=(255, 255, 255), width=2)
+        grass_color = (50, 150, 50) if happiness > 60 else (80, 120, 80)
+        draw.rectangle([x, y, x + 40, y + 25], fill=grass_color, outline=(255, 255, 255), width=2)
+        
+        # Líneas de la cancha
+        draw.line([(x + 20, y), (x + 20, y + 25)], fill=(255, 255, 255), width=2)
+        draw.ellipse([x + 15, y + 10, x + 25, y + 15], outline=(255, 255, 255), width=2)
+        
         # Arcos
-        draw.rectangle([x, y + 10, x + 3, y + 18], outline=(255, 255, 255), width=2)
-        draw.rectangle([x + 21, y + 10, x + 24, y + 18], outline=(255, 255, 255), width=2)
+        draw.rectangle([x, y + 8, x + 3, y + 17], outline=(255, 255, 255), width=2)
+        draw.rectangle([x + 37, y + 8, x + 40, y + 17], outline=(255, 255, 255), width=2)
+        
+        # Jugadores animados
+        if happiness > 70:
+            for i in range(6):
+                player_x = x + 5 + i * 6 + int(3 * math.sin(self.animation_time + i))
+                player_y = y + 8 + int(2 * math.cos(self.animation_time + i * 1.5))
+                draw.ellipse([player_x, player_y, player_x + 3, player_y + 5], fill=(180, 140, 100))
+        
         # Pelota animada
-        ball_x = x + 12 + int(5 * math.sin(self.animation_time))
-        ball_y = y + 14
-        draw.ellipse([ball_x, ball_y, ball_x + 2, ball_y + 2], fill=(255, 255, 255), outline=(0, 0, 0))
+        ball_x = x + 20 + int(10 * math.sin(self.animation_time * 2))
+        ball_y = y + 12 + int(5 * math.cos(self.animation_time * 2))
+        draw.ellipse([ball_x, ball_y, ball_x + 3, ball_y + 3], fill=(255, 255, 255), outline=(0, 0, 0))
     
-    def _draw_grill(self, draw, x, y, color):
-        """Parrilla con humo"""
+    def _draw_parrilla(self, draw, x, y, cultural_identity):
+        """Parrilla argentina con humo"""
         # Base de la parrilla
-        draw.rectangle([x + 8, y + 15, x + 16, y + 23], fill=(50, 50, 50), outline=(100, 100, 100))
-        # Humo animado
+        draw.rectangle([x + 5, y + 10, x + 15, y + 18], fill=(50, 50, 50), outline=(100, 100, 100))
+        
+        # Parrilla
         for i in range(3):
-            smoke_x = x + 12 + random.randint(-2, 2)
-            smoke_y = y + 15 - i * 5 + int(2 * math.sin(self.animation_time + i))
-            size = 2 + i
-            draw.ellipse([smoke_x - size, smoke_y - size, smoke_x + size, smoke_y + size], 
-                        fill=(180, 180, 180))
-        # Personas alrededor
-        for person_pos in [(x + 4, y + 18), (x + 18, y + 18)]:
-            draw.ellipse([person_pos[0], person_pos[1], person_pos[0] + 3, person_pos[1] + 5], 
-                        fill=(180, 140, 100))
+            draw.line([(x + 6 + i * 3, y + 12), (x + 6 + i * 3, y + 16)], fill=(150, 150, 150), width=2)
+        
+        # Carne en la parrilla
+        if cultural_identity > 70:
+            for i in range(2):
+                meat_x = x + 7 + i * 4
+                meat_y = y + 13
+                draw.ellipse([meat_x, meat_y, meat_x + 3, meat_y + 2], fill=(139, 69, 19))
+        
+        # Humo animado
+        for i in range(4):
+            smoke_x = x + 10 + random.randint(-3, 3)
+            smoke_y = y + 8 - i * 4 + int(2 * math.sin(self.animation_time * 2 + i))
+            size = 3 + i
+            draw.ellipse([smoke_x - size//2, smoke_y - size//2, smoke_x + size//2, smoke_y + size//2], 
+                        fill=(200, 200, 200))
+        
+        # Gente alrededor
+        if cultural_identity > 60:
+            for i in range(3):
+                person_x = x + 2 + i * 8
+                person_y = y + 15
+                draw.ellipse([person_x, person_y, person_x + 4, person_y + 8], fill=(180, 140, 100))
     
-    def _draw_plaza(self, draw, x, y, color):
-        """Plaza con árboles"""
-        # Base verde
-        draw.rectangle([x + 1, y + 8, x + 23, y + 23], fill=color, outline=(100, 150, 100))
+    def _draw_plaza(self, draw, x, y, happiness):
+        """Plaza con actividades"""
+        # Base verde de la plaza
+        plaza_color = (100, 180, 100) if happiness > 50 else (120, 140, 120)
+        draw.rectangle([x, y, x + 30, y + 30], fill=plaza_color, outline=(80, 120, 80))
+        
         # Senderos
-        draw.line([(x + 1, y + 15), (x + 23, y + 15)], fill=(160, 140, 120), width=3)
-        draw.line([(x + 12, y + 8), (x + 12, y + 23)], fill=(160, 140, 120), width=3)
+        draw.line([(x, y + 15), (x + 30, y + 15)], fill=(160, 140, 120), width=3)
+        draw.line([(x + 15, y), (x + 15, y + 30)], fill=(160, 140, 120), width=3)
+        
+        # Monumento central
+        draw.rectangle([x + 12, y + 12, x + 18, y + 18], fill=(180, 180, 180), outline=(120, 120, 120))
+        
         # Árboles
-        tree_positions = [(x + 5, y + 11), (x + 19, y + 11), (x + 5, y + 19), (x + 19, y + 19)]
+        tree_positions = [(x + 5, y + 5), (x + 25, y + 5), (x + 5, y + 25), (x + 25, y + 25)]
         for tree_x, tree_y in tree_positions:
             # Tronco
             draw.rectangle([tree_x, tree_y + 3, tree_x + 2, tree_y + 8], fill=(101, 67, 33))
             # Copa
             draw.ellipse([tree_x - 2, tree_y, tree_x + 4, tree_y + 6], fill=(50, 150, 50))
+        
+        # Actividades según felicidad
+        if happiness > 70:
+            # Ronda de mate
+            for i in range(4):
+                angle = i * (math.pi / 2)
+                person_x = x + 15 + int(8 * math.cos(angle))
+                person_y = y + 15 + int(8 * math.sin(angle))
+                draw.ellipse([person_x, person_y, person_x + 3, person_y + 5], fill=(180, 140, 100))
     
-    def _draw_factory(self, draw, x, y, color):
+    def _draw_factory(self, draw, x, y, employment_level):
         """Fábrica con chimeneas"""
+        factory_color = (150, 100, 100) if employment_level > 60 else (120, 80, 80)
+        
         # Edificio principal
-        draw.rectangle([x + 1, y + 8, x + 23, y + 23], fill=color, outline=(0, 0, 0), width=2)
+        draw.rectangle([x + 1, y + 8, x + 23, y + 18], fill=factory_color, outline=(0, 0, 0), width=2)
+        
         # Chimeneas
         for chimney_x in [x + 6, x + 12, x + 18]:
             draw.rectangle([chimney_x, y + 2, chimney_x + 3, chimney_x + 8], fill=(80, 80, 80))
             # Humo
             smoke_y = y + 2 - int(3 * math.sin(self.animation_time))
             draw.ellipse([chimney_x, smoke_y - 2, chimney_x + 3, smoke_y + 1], fill=(150, 150, 150))
+        
         # Ventanas industriales
         for window_x in range(x + 4, x + 20, 4):
             draw.rectangle([window_x, y + 12, window_x + 2, window_x + 15], 
                           fill=(255, 200, 100), outline=(0, 0, 0))
     
-    def _draw_city_effects(self, draw, city, width, height):
-        """Efectos dinámicos de la ciudad"""
-        # Tráfico en las calles
-        if city.happiness > 50:
-            for i in range(3):
-                car_x = (100 + i * 200 + int(self.animation_time * 30)) % width
-                car_y = 220 + i * 75
-                # Auto simple
-                draw.rectangle([car_x, car_y, car_x + 15, car_y + 8], 
-                              fill=(200, 100, 100), outline=(0, 0, 0))
-                # Ruedas
-                draw.ellipse([car_x + 2, car_y + 6, car_x + 5, car_y + 9], fill=(50, 50, 50))
-                draw.ellipse([car_x + 10, car_y + 6, car_x + 13, car_y + 9], fill=(50, 50, 50))
+    def _draw_cultural_center(self, draw, x, y, culture_level):
+        """Centro cultural"""
+        center_color = (255, 140, 0) if culture_level > 70 else (200, 100, 0)
+        
+        # Edificio principal
+        draw.rectangle([x + 1, y + 5, x + 23, y + 18], fill=center_color, outline=(0, 0, 0), width=2)
+        
+        # Cartelera cultural
+        draw.rectangle([x + 5, y + 8, x + 19, y + 15], fill=(255, 255, 255), outline=(0, 0, 0))
+        
+        # Máscaras de teatro
+        draw.ellipse([x + 7, y + 10, x + 11, y + 13], fill=(255, 255, 255), outline=(0, 0, 0))
+        draw.ellipse([x + 13, y + 10, x + 17, y + 13], fill=(255, 255, 255), outline=(0, 0, 0))
+    
+    def _draw_kiosco(self, draw, x, y, economy):
+        """Kiosco de barrio"""
+        kiosco_color = (200, 150, 100) if economy > 2000 else (150, 100, 80)
+        
+        # Estructura pequeña
+        draw.rectangle([x + 5, y + 10, x + 15, y + 18], fill=kiosco_color, outline=(0, 0, 0), width=2)
+        
+        # Cartel
+        draw.rectangle([x + 7, y + 8, x + 13, y + 10], fill=(255, 0, 0))
+        
+        # Productos en ventana
+        for i in range(3):
+            product_x = x + 6 + i * 3
+            draw.rectangle([product_x, y + 12, product_x + 2, y + 15], 
+                          fill=random.choice([(255, 0, 0), (0, 255, 0), (0, 0, 255)]))
+    
+    def _draw_subway(self, draw, x, y, transport_level):
+        """Estación de subte"""
+        # Entrada subterránea
+        draw.rectangle([x + 5, y + 10, x + 15, y + 18], fill=(100, 100, 100), outline=(0, 0, 0), width=2)
+        
+        # Cartel de subte
+        draw.rectangle([x + 7, y + 5, x + 13, y + 8], fill=(0, 100, 200))
+        
+        # Escaleras
+        for i in range(3):
+            step_y = y + 12 + i * 2
+            draw.line([(x + 6, step_y), (x + 14, step_y)], fill=(150, 150, 150), width=1)
+    
+    def _draw_police_station(self, draw, x, y, security_level):
+        """Comisaría"""
+        station_color = (100, 100, 150) if security_level > 70 else (80, 80, 120)
+        
+        # Edificio
+        draw.rectangle([x + 1, y + 5, x + 23, y + 18], fill=station_color, outline=(0, 0, 0), width=2)
+        
+        # Escudo policial
+        draw.ellipse([x + 10, y + 8, x + 14, y + 12], fill=(255, 255, 255), outline=(0, 0, 0))
+        
+        # Patrullero
+        if security_level > 50:
+            draw.rectangle([x + 16, y + 15, x + 22, y + 18], fill=(255, 255, 255), outline=(0, 0, 0))
+            draw.ellipse([x + 17, y + 17, x + 19, y + 19], fill=(0, 0, 0))
+            draw.ellipse([x + 20, y + 17, x + 22, y + 19], fill=(0, 0, 0))
+    
+    def _draw_city_life(self, draw, city):
+        """Sistemas dinámicos de vida urbana"""
+        # Tráfico animado en calles principales
+        if city.resources['transport'] > 30:
+            self._draw_animated_traffic(draw, city)
+        
+        # Personas caminando
+        if city.happiness > 40:
+            self._draw_pedestrians(draw, city)
+        
+        # Efectos de contaminación
+        if city.resources.get('pollution', 0) < -20:
+            self._draw_pollution_effects(draw, city)
+    
+    def _draw_animated_traffic(self, draw, city):
+        """Tráfico animado en las calles"""
+        # Colectivos argentinos
+        for i in range(3):
+            bus_x = (100 + i * 300 + int(self.animation_time * 50)) % city.width
+            bus_y = 200 + i * 100
+            
+            # Colectivo
+            draw.rectangle([bus_x, bus_y, bus_x + 25, bus_y + 12], 
+                          fill=(255, 200, 0), outline=(0, 0, 0), width=2)
+            # Ventanas
+            for window in range(3):
+                draw.rectangle([bus_x + 3 + window * 6, bus_y + 2, 
+                               bus_x + 8 + window * 6, bus_y + 7], 
+                              fill=(150, 200, 255))
+            # Ruedas
+            draw.ellipse([bus_x + 2, bus_y + 10, bus_x + 6, bus_y + 14], fill=(50, 50, 50))
+            draw.ellipse([bus_x + 19, bus_y + 10, bus_x + 23, bus_y + 14], fill=(50, 50, 50))
+    
+    def _draw_pedestrians(self, draw, city):
+        """Peatones animados"""
+        for i in range(8):
+            person_x = (50 + i * 120 + int(self.animation_time * 30 + i * 50)) % city.width
+            person_y = 300 + i * 40 + int(5 * math.sin(self.animation_time + i))
+            
+            # Persona simple
+            draw.ellipse([person_x, person_y, person_x + 4, person_y + 8], fill=(180, 140, 100))
+            
+            # Mate en la mano si alta cultura
+            if city.cultural_identity > 70 and i % 3 == 0:
+                draw.ellipse([person_x + 3, person_y + 2, person_x + 6, person_y + 5], fill=(100, 50, 0))
+    
+    def _draw_pollution_effects(self, draw, city):
+        """Efectos de contaminación"""
+        pollution_level = abs(city.resources.get('pollution', 0))
+        if pollution_level > 20:
+            # Smog gris
+            for i in range(int(pollution_level / 5)):
+                smog_x = random.randint(0, city.width)
+                smog_y = random.randint(100, 300)
+                size = random.randint(10, 30)
+                draw.ellipse([smog_x - size, smog_y - size, smog_x + size, smog_y + size], 
+                            fill=(120, 120, 120))
+    
+    def _draw_advanced_ui(self, draw, city):
+        """UI avanzada con gráficos informativos"""
+        # Panel principal con transparencia
+        panel_width = 300
+        panel_height = 200
+        
+        # Panel de fondo con gradiente
+        for i in range(panel_height):
+            alpha = int(180 - i)
+            color = (0, 0, 0) if alpha > 0 else (20, 20, 20)
+            draw.rectangle([10, 10 + i, 10 + panel_width, 11 + i], fill=color)
+        
+        # Borde elegante
+        draw.rectangle([10, 10, 10 + panel_width, 10 + panel_height], 
+                      outline=(100, 150, 255), width=3)
+        
+        # Información de la ciudad (texto simplificado por limitaciones de PIL)
+        info_y = 25
+        city_info = [
+            f"Población: {city.population:,}",
+            f"Felicidad: {city.happiness}%",
+            f"Economía: ${city.economy:,}",
+            f"Identidad: {city.cultural_identity}%",
+            f"Inflación: {city.inflation:.1f}x"
+        ]
+        
+        # Barras de recursos en el lado derecho
+        self._draw_resource_bars(draw, city, city.width - 250, 20)
+        
+        # Mini mapa en esquina inferior derecha
+        self._draw_mini_map(draw, city, city.width - 150, city.height - 120)
+    
+    def _draw_resource_bars(self, draw, city, start_x, start_y):
+        """Barras de recursos con efectos visuales"""
+        resources = city.resources
+        bar_width = 200
+        bar_height = 15
+        
+        resource_colors = {
+            'presupuesto': (255, 215, 0), 'energia': (255, 255, 0),
+            'agua': (0, 191, 255), 'seguridad': (255, 99, 71),
+            'educacion': (147, 112, 219), 'salud': (255, 20, 147),
+            'cultura': (255, 140, 0), 'empleo': (50, 205, 50),
+            'vivienda': (139, 69, 19), 'transport': (100, 149, 237),
+            'pollution': (120, 120, 120)
+        }
+        
+        y_offset = start_y
+        for resource, value in resources.items():
+            if resource == 'presupuesto':
+                # Presupuesto se muestra diferente
+                y_offset += 25
+                continue
+            
+            # Normalizar valor para barra (0-100)
+            if resource == 'pollution':
+                normalized_value = max(0, min(100, abs(value)))
+            else:
+                normalized_value = max(0, min(100, value)) if isinstance(value, (int, float)) else 50
+            
+            # Barra de fondo
+            draw.rectangle([start_x, y_offset, start_x + bar_width, y_offset + bar_height], 
+                          fill=(40, 40, 40), outline=(100, 100, 100))
+            
+            # Barra de valor con gradiente
+            fill_width = int((normalized_value / 100) * (bar_width - 4))
+            color = resource_colors.get(resource, (150, 150, 150))
+            
+            # Efecto de brillo
+            for i in range(fill_width):
+                brightness = 0.7 + 0.3 * math.sin(self.animation_time + i/10)
+                bright_color = tuple(int(c * brightness) for c in color)
+                draw.rectangle([start_x + 2 + i, y_offset + 2, 
+                               start_x + 3 + i, y_offset + bar_height - 2], 
+                              fill=bright_color)
+            
+            y_offset += 22
+    
+    def _draw_mini_map(self, draw, city, start_x, start_y):
+        """Mini mapa de la ciudad"""
+        map_width, map_height = 120, 100
+        
+        # Fondo del mini mapa
+        draw.rectangle([start_x, start_y, start_x + map_width, start_y + map_height], 
+                      fill=(20, 20, 20), outline=(150, 150, 150), width=2)
+        
+        # Edificios en el mini mapa
+        scale = 2
+        for (grid_x, grid_y), building_type in city.city_grid.items():
+            mini_x = start_x + (grid_x * scale) % map_width
+            mini_y = start_y + (grid_y * scale) % map_height
+            
+            building_colors = {
+                'casa': (100, 150, 100), 'villa': (255, 150, 100),
+                'edificio': (150, 150, 200), 'escuela': (200, 200, 100),
+                'hospital': (255, 100, 100), 'cancha': (100, 255, 100),
+                'plaza': (150, 255, 150), 'fabrica': (150, 100, 100),
+                'centro_cultural': (255, 140, 0), 'kiosco': (200, 150, 100),
+                'subte': (100, 149, 237), 'comisaria': (100, 100, 150),
+                'parrilla': (200, 100, 50)
+            }
+            
+            color = building_colors.get(building_type, (100, 100, 100))
+            draw.rectangle([mini_x, mini_y, mini_x + scale, mini_y + scale], fill=color)
+    
+    def _draw_special_effects(self, draw, city):
+        """Efectos especiales adicionales"""
+        # Efectos de festivales si alta cultura
+        if city.resources['cultura'] > 80:
+            for i in range(5):
+                firework_x = random.randint(100, city.width - 100)
+                firework_y = random.randint(50, 150)
+                size = random.randint(3, 8)
+                color = random.choice([(255, 100, 100), (100, 255, 100), (100, 100, 255), (255, 255, 100)])
+                draw.ellipse([firework_x - size, firework_y - size, 
+                             firework_x + size, firework_y + size], fill=color)
 
-class SimCityGame:
-    """Juego principal"""
+class EnhancedCityGame:
+    """Juego de ciudad argentino mejorado COMPLETO"""
     def __init__(self):
-        self.city = ArgentineCityEngine()
-        self.renderer = CityRenderer()
+        self.city = ArgentineCityBuilder()
+        self.renderer = AdvancedCityRenderer()
         self.ai_planner = AIUrbanPlanner()
+        self.selected_building = None
+        self.game_speed = 1
+        self.events_log = []
         self.day = 1
         
     def place_building(self, building_type, grid_x, grid_y):
-        """Coloca un edificio"""
+        """Coloca un edificio en la ciudad - CORREGIDO"""
         try:
             grid_x, grid_y = int(grid_x), int(grid_y)
             
             if building_type not in self.city.building_types:
-                return "Tipo de edificio inválido", self.get_status(), "Error en tipo de edificio"
+                return "Tipo de edificio inválido", self.get_city_status(), "Error: Tipo de edificio no válido"
             
-            if (grid_x, grid_y) in self.city.buildings:
-                return "Ya hay un edificio ahí", self.get_status(), "Posición ocupada"
+            if (grid_x, grid_y) in self.city.city_grid:
+                return "Ya hay un edificio ahí", self.get_city_status(), "Error: Posición ocupada"
             
-            cost = self.city.building_types[building_type]['cost']
-            if self.city.budget < cost:
-                return f"No tenés suficiente presupuesto (${cost:,})", self.get_status(), "Sin presupuesto"
+            building_info = self.city.building_types[building_type]
+            cost = building_info['cost']
             
-            # Construir
-            self.city.budget -= cost
-            self.city.buildings[(grid_x, grid_y)] = building_type
+            if self.city.resources['presupuesto'] < cost:
+                return f"No tenés suficiente presupuesto (${cost:,})", self.get_city_status(), "Error: Sin presupuesto"
             
-            # Aplicar efectos
-            building_info = self.city.building_types[building_type]
-            for effect, value in building_info.items():
-                if effect == 'pop':
-                    self.city.population += value
-                elif effect == 'happiness':
-                    self.city.happiness = max(0, min(100, self.city.happiness + value))
-                elif effect in self.city.resources:
-                    self.city.resources[effect] = max(0, min(100, self.city.resources[effect] + value))
+            # Construir edificio
+            self.city.resources['presupuesto'] -= cost
+            self.city.city_grid[(grid_x, grid_y)] = building_type
+            
+            # Aplicar efectos CORREGIDOS
+            self._apply_building_effects(building_type, building_info)
+            
+            # Actualizar estadísticas
+            self._update_city_stats()
             
             # Generar consejo IA
             advice = self.ai_planner.generate_city_advice({
                 'population': self.city.population,
                 'happiness': self.city.happiness,
-                'budget': self.city.budget,
-                'buildings': len(self.city.buildings)
+                'budget': self.city.resources['presupuesto'],
+                'buildings': len(self.city.city_grid),
+                'culture': self.city.cultural_identity
             })
             
-            frame = self.renderer.render_city(self.city)
-            status = self.get_status()
-            message = f"✅ {building_type.title()} construido por ${cost:,}"
+            frame = self.renderer.render_city_frame(self.city)
+            status = self.get_city_status()
+            message = f"✅ {building_type.replace('_', ' ').title()} construido por ${cost:,}"
             
-            return frame, status, f"{message}\n\n🤖 IA: {advice}"
+            return frame, status, f"{message}\n\n🤖 IA Urbana: {advice}"
             
         except Exception as e:
-            return "Error en construcción", self.get_status(), f"Error: {str(e)}"
+            print(f"Error en construcción: {e}")
+            return self.renderer.render_city_frame(self.city), self.get_city_status(), f"Error: {str(e)}"
+    
+    def _apply_building_effects(self, building_type, building_info):
+        """Aplica los efectos de un edificio a la ciudad - CORREGIDO"""
+        for effect, value in building_info.items():
+            if effect == 'cost':
+                continue
+            elif effect == 'pop':
+                self.city.population += value
+            elif effect == 'happiness':
+                self.city.happiness = min(100, max(0, self.city.happiness + value))
+            elif effect == 'solidarity':
+                self.city.cultural_identity = min(100, max(0, self.city.cultural_identity + value))
+            elif effect in self.city.resources:
+                if effect == 'pollution':
+                    # Pollution es negativa, así que sumamos el valor negativo
+                    self.city.resources[effect] += value
+                else:
+                    current_value = self.city.resources[effect]
+                    self.city.resources[effect] = min(100, max(0, current_value + value))
+    
+    def _update_city_stats(self):
+        """Actualiza estadísticas generales de la ciudad"""
+        # Calcular economía basada en edificios
+        economy_buildings = ['fabrica', 'kiosco', 'centro_cultural', 'subte']
+        economy_bonus = sum(5000 for pos, building in self.city.city_grid.items() 
+                           if building in economy_buildings)
+        self.city.economy = 1000 + economy_bonus + self.city.population * 30
+        
+        # Inflación aumenta con el tiempo y población
+        self.city.inflation += 0.005 + (len(self.city.city_grid) * 0.001)
+        
+        # Felicidad general basada en múltiples factores
+        happiness_factors = [
+            self.city.resources.get('cultura', 50),
+            self.city.resources.get('seguridad', 50),
+            self.city.resources.get('empleo', 50),
+            self.city.resources.get('salud', 50),
+            self.city.resources.get('educacion', 50),
+            self.city.cultural_identity
+        ]
+        self.city.happiness = sum(happiness_factors) // len(happiness_factors)
+        
+        # Limitar felicidad
+        self.city.happiness = max(0, min(100, self.city.happiness))
     
     def simulate_day(self):
-        """Simula un día"""
+        """Simula un día en la ciudad"""
         try:
             self.day += 1
             
-            # Ingresos
-            daily_income = self.city.population * 15 + len(self.city.buildings) * 200
-            self.city.budget += daily_income
+            # Ingresos diarios
+            base_income = self.city.population * 12
+            economy_bonus = self.city.economy * 0.008
+            daily_income = int(base_income + economy_bonus)
+            self.city.resources['presupuesto'] += daily_income
             
             # Gastos de mantenimiento
-            maintenance = len(self.city.buildings) * 50
-            self.city.budget -= maintenance
+            maintenance_cost = len(self.city.city_grid) * 80
+            self.city.resources['presupuesto'] -= maintenance_cost
+            
+            # Efectos de la inflación (más realista)
+            inflation_impact = int(self.city.resources['presupuesto'] * 0.01)
+            self.city.resources['presupuesto'] -= inflation_impact
             
             # Eventos aleatorios
             event_message = ""
-            if random.random() < 0.3:
-                events = [
-                    ("🎉 Festival de Tango", "cultura", 15, "happiness", 10),
-                    ("⚽ Clásico River-Boca", "happiness", 20, "cultura", 5),
-                    ("🌧️ Lluvia beneficiosa", "agua", 20, "happiness", 5),
-                    ("💼 Nueva inversión", "budget", 5000, "empleo", 10),
-                    ("📚 Programa educativo", "educacion", 15, "happiness", 8)
-                ]
-                
-                event_name, res1, val1, res2, val2 = random.choice(events)
-                event_message = f"📰 {event_name}"
-                
-                # Aplicar efectos
-                if res1 == 'budget':
-                    self.city.budget += val1
-                elif res1 == 'happiness':
-                    self.city.happiness = max(0, min(100, self.city.happiness + val1))
-                elif res1 in self.city.resources:
-                    self.city.resources[res1] = max(0, min(100, self.city.resources[res1] + val1))
-                
-                if res2 == 'happiness':
-                    self.city.happiness = max(0, min(100, self.city.happiness + val2))
-                elif res2 in self.city.resources:
-                    self.city.resources[res2] = max(0, min(100, self.city.resources[res2] + val2))
+            if random.random() < 0.25:
+                event_message = self._trigger_city_event()
+            
+            # Actualizar todo
+            self._update_city_stats()
+            
+            # Generar análisis IA del día
+            ai_analysis = self.ai_planner.generate_city_advice({
+                'population': self.city.population,
+                'happiness': self.city.happiness,
+                'budget': self.city.resources['presupuesto'],
+                'buildings': len(self.city.city_grid),
+                'culture': self.city.cultural_identity
+            })
             
-            frame = self.renderer.render_city(self.city)
-            status = self.get_status()
+            frame = self.renderer.render_city_frame(self.city)
+            status = self.get_city_status()
             
-            message = f"📅 Día {self.day} simulado\n💰 Ingresos: ${daily_income:,}\n💸 Gastos: ${maintenance:,}"
+            message = f"📅 Día {self.day} completado\n💰 Ingresos: ${daily_income:,}\n💸 Gastos: ${maintenance_cost:,}"
             if event_message:
-                message += f"\n{event_message}"
+                message += f"\n📰 {event_message}"
+            message += f"\n\n🤖 Análisis IA: {ai_analysis}"
             
             return frame, status, message
             
         except Exception as e:
-            return "Error en simulación", self.get_status(), f"Error: {str(e)}"
+            print(f"Error en simulación: {e}")
+            return self.renderer.render_city_frame(self.city), self.get_city_status(), f"Error: {str(e)}"
+    
+    def _trigger_city_event(self):
+        """Eventos aleatorios de la ciudad - MEJORADOS"""
+        events = [
+            ("🎉 Festival de Tango en San Telmo", "cultura", 15, "happiness", 20),
+            ("⚽ Superclásico River vs Boca", "happiness", 30, "cultura", 10),
+            ("🏭 Inversión extranjera en fábrica", "empleo", 20, "presupuesto", 8000),
+            ("🌧️ Lluvia beneficiosa para la ciudad", "agua", 25, "energia", -5),
+            ("📚 Programa nacional de alfabetización", "educacion", 18, "cultura", 12),
+            ("🏥 Campaña de vacunación masiva", "salud", 25, "happiness", 15),
+            ("💸 Crisis económica menor", "presupuesto", -5000, "happiness", -8),
+            ("🎭 Inauguración de centro cultural", "cultura", 30, "educacion", 15),
+            ("🚌 Mejoras en transporte público", "transport", 20, "happiness", 12),
+            ("🛡️ Operativo de seguridad exitoso", "seguridad", 15, "happiness", 8),
+            ("🏠 Programa de vivienda social", "vivienda", 25, "happiness", 18),
+            ("🔥 Festival del Asado Argentino", "cultura", 20, "happiness", 25)
+        ]
+        
+        event_name, res1, val1, res2, val2 = random.choice(events)
+        
+        # Aplicar efectos
+        if res1 == 'presupuesto':
+            self.city.resources[res1] += val1
+        elif res1 == 'happiness':
+            self.city.happiness = min(100, max(0, self.city.happiness + val1))
+        elif res1 in self.city.resources:
+            self.city.resources[res1] = min(100, max(0, self.city.resources[res1] + val1))
+        
+        if res2 == 'presupuesto':
+            self.city.resources[res2] += val2
+        elif res2 == 'happiness':
+            self.city.happiness = min(100, max(0, self.city.happiness + val2))
+        elif res2 in self.city.resources:
+            self.city.resources[res2] = min(100, max(0, self.city.resources[res2] + val2))
+        
+        self.events_log.append(event_name)
+        return event_name
     
-    def get_status(self):
-        """Estado actual de la ciudad"""
+    def get_city_status(self):
+        """Status completo de la ciudad"""
         try:
-            building_count = len(self.city.buildings)
+            building_count = len(self.city.city_grid)
             return {
                 "🏙️ Población": f"{self.city.population:,} habitantes",
                 "😊 Felicidad": f"{self.city.happiness}%",
-                "💰 Presupuesto": f"${self.city.budget:,}",
+                "💰 Presupuesto": f"${self.city.resources['presupuesto']:,}",
+                "📊 Economía": f"${self.city.economy:,}",
+                "🇦🇷 Identidad": f"{self.city.cultural_identity}%",
+                "📈 Inflación": f"{self.city.inflation:.2f}x",
                 "🏗️ Edificios": f"{building_count} construidos",
                 "📅 Día": self.day,
                 "⚡ Energía": f"{self.city.resources['energia']}%",
                 "💧 Agua": f"{self.city.resources['agua']}%",
-                "🎓 Educación": f"{self.city.resources['educacion']}%"
+                "🎓 Educación": f"{self.city.resources['educacion']}%",
+                "🏥 Salud": f"{self.city.resources['salud']}%",
+                "🎭 Cultura": f"{self.city.resources['cultura']}%",
+                "💼 Empleo": f"{self.city.resources['empleo']}%"
             }
         except Exception as e:
             return {"Error": str(e)}
 
 def create_simcity_interface():
-    """Interfaz principal del juego"""
-    game = SimCityGame()
+    """Interfaz del SimCity Argentino COMPLETA"""
+    game = EnhancedCityGame()
     
     with gr.Blocks(
-        title="🇦🇷 SIMCIUDAD ARGENTINA",
-        theme=gr.themes.Soft()
+        title="🇦🇷 SIMCIUDAD ARGENTINA - Construcción Épica",
+        theme=gr.themes.Glass(),
+        css="""
+        .building-btn { font-size: 1.0em; padding: 8px; margin: 2px; }
+        .city-header { background: linear-gradient(45deg, #74b9ff, #0984e3, #00b894); }
+        .status-panel { background: #2d3436; border-radius: 10px; }
+        """
     ) as interface:
         
         gr.HTML("""
-        <div style="background: linear-gradient(135deg, #74b9ff 0%, #0984e3 50%, #00b894 100%); 
-                    padding: 25px; text-align: center; border-radius: 15px; margin: 15px;">
-            <h1 style="color: white; font-size: 2.5em; margin: 0; text-shadow: 2px 2px 4px rgba(0,0,0,0.7);">
+        <div class="city-header" style="padding: 25px; text-align: center; border-radius: 15px; margin: 15px;">
+            <h1 style="color: white; font-size: 2.8em; margin: 0; text-shadow: 3px 3px 6px rgba(0,0,0,0.7);">
                 🏙️ SIMCIUDAD ARGENTINA 🇦🇷
             </h1>
-            <p style="color: #f1f2f6; font-size: 1.1em; margin: 10px 0;">
-                Construí la Ciudad Argentina de tus Sueños • Gráficos Isométricos • Mecánicas Realistas • Cultura Auténtica
+            <h2 style="color: #ddd; font-size: 1.2em; margin: 10px 0;">
+                Construí la Ciudad Argentina de tus Sueños con IA
+            </h2>
+            <p style="color: #f1f2f6; font-size: 1.0em;">
+                Gráficos Isométricos • Mecánicas Realistas • Cultura Auténtica • Powered by Groq AI
             </p>
         </div>
         """)
         
         with gr.Row():
             with gr.Column(scale=2):
-                # Pantalla principal del juego
                 city_display = gr.Image(
                     label="🌆 Tu Ciudad Argentina",
                     width=1000,
                     height=700,
-                    value=game.renderer.render_city(game.city)
+                    value=game.renderer.render_city_frame(game.city)
                 )
                 
                 gr.Markdown("### 🏗️ HERRAMIENTAS DE CONSTRUCCIÓN")
+                with gr.Row():
+                    grid_x_input = gr.Number(label="Coordenada X", value=20, minimum=0, maximum=45)
+                    grid_y_input = gr.Number(label="Coordenada Y", value=20, minimum=0, maximum=30)
                 
+                # Edificios residenciales
+                gr.Markdown("#### 🏠 RESIDENCIALES")
                 with gr.Row():
-                    grid_x = gr.Number(label="Coordenada X", value=10, minimum=0, maximum=30)
-                    grid_y = gr.Number(label="Coordenada Y", value=10, minimum=0, maximum=20)
+                    house_btn = gr.Button("🏠 CASA ($1K)", variant="secondary", elem_classes="building-btn")
+                    villa_btn = gr.Button("🏘️ VILLA ($500)", variant="secondary", elem_classes="building-btn")
+                    building_btn = gr.Button("🏢 EDIFICIO ($5K)", variant="primary", elem_classes="building-btn")
+                    kiosco_btn = gr.Button("🏪 KIOSCO ($800)", variant="secondary", elem_classes="building-btn")
                 
-                # Botones de construcción
+                # Servicios públicos
+                gr.Markdown("#### 🏛️ SERVICIOS PÚBLICOS")
                 with gr.Row():
-                    casa_btn = gr.Button("🏠 CASA ($1,000)", variant="secondary")
-                    villa_btn = gr.Button("🏘️ VILLA ($500)", variant="secondary") 
-                    edificio_btn = gr.Button("🏢 EDIFICIO ($5,000)", variant="primary")
+                    school_btn = gr.Button("🏫 ESCUELA ($8K)", variant="primary", elem_classes="building-btn")
+                    hospital_btn = gr.Button("🏥 HOSPITAL ($15K)", variant="stop", elem_classes="building-btn")
+                    police_btn = gr.Button("🛡️ COMISARÍA ($7K)", variant="stop", elem_classes="building-btn")
+                    subway_btn = gr.Button("🚇 SUBTE ($20K)", variant="primary", elem_classes="building-btn")
                 
+                # Cultura y entretenimiento
+                gr.Markdown("#### 🎭 CULTURA Y ENTRETENIMIENTO")
                 with gr.Row():
-                    escuela_btn = gr.Button("🏫 ESCUELA ($8,000)", variant="primary")
-                    hospital_btn = gr.Button("🏥 HOSPITAL ($15,000)", variant="stop")
-                    cancha_btn = gr.Button("⚽ CANCHA ($3,000)", variant="secondary")
+                    field_btn = gr.Button("⚽ CANCHA ($3K)", variant="secondary", elem_classes="building-btn")
+                    grill_btn = gr.Button("🔥 PARRILLA ($2K)", variant="stop", elem_classes="building-btn")
+                    cultural_btn = gr.Button("🎭 C.CULTURAL ($10K)", variant="primary", elem_classes="building-btn")
+                    plaza_btn = gr.Button("🌳 PLAZA ($1.5K)", variant="secondary", elem_classes="building-btn")
                 
+                # Industria
+                gr.Markdown("#### 🏭 INDUSTRIA")
                 with gr.Row():
-                    parrilla_btn = gr.Button("🔥 PARRILLA ($2,000)", variant="stop")
-                    plaza_btn = gr.Button("🌳 PLAZA ($1,500)", variant="secondary")
-                    fabrica_btn = gr.Button("🏭 FÁBRICA ($12,000)", variant="primary")
+                    factory_btn = gr.Button("🏭 FÁBRICA ($12K)", variant="primary", elem_classes="building-btn")
                 
-                # Botón de simulación
+                # Simulación
                 with gr.Row():
-                    simular_btn = gr.Button("⏭️ SIMULAR DÍA", variant="primary", size="lg")
+                    simulate_btn = gr.Button("⏭️ SIMULAR DÍA", variant="primary", size="lg")
             
             with gr.Column(scale=1):
-                # Estado de la ciudad
                 gr.Markdown("### 📊 ESTADO DE LA CIUDAD")
-                status_display = gr.JSON(
-                    label="📈 Estadísticas",
-                    value=game.get_status()
+                city_status = gr.JSON(
+                    label="📈 Estadísticas Completas",
+                    value=game.get_city_status()
                 )
                 
-                # Eventos y noticias
-                gr.Markdown("### 📰 EVENTOS RECIENTES")
-                news_display = gr.Textbox(
-                    label="📺 Noticias Urbanas",
-                    value="🎮 ¡Bienvenido al SimCity Argentino! Empezá construyendo casas y servicios para tu comunidad.",
-                    lines=5,
+                gr.Markdown("### 📰 NOTICIAS Y EVENTOS")
+                events_display = gr.Textbox(
+                    value="🎮 ¡Bienvenido al SimCity Argentino con IA! Construí tu ciudad con identidad nacional. La IA te dará consejos de planificación urbana en tiempo real.",
+                    label="📺 Canal de Noticias Urbanas",
+                    lines=6,
                     interactive=False
                 )
                 
-                # Info de construcción
                 gr.Markdown("### 💰 GUÍA DE CONSTRUCCIÓN")
                 gr.HTML("""
-                <div style="background: #2d3436; color: white; padding: 15px; border-radius: 10px; font-size: 0.9em;">
-                    <p><strong>🏗️ Efectos de Edificios:</strong></p>
+                <div style="background: #2d3436; color: white; padding: 15px; border-radius: 10px; font-size: 0.85em;">
+                    <p><strong>💵 Precios y Efectos:</strong></p>
                     <ul style="margin: 5px 0; padding-left: 15px;">
-                        <li>🏠 Casa: +4 población, +2 felicidad</li>
-                        <li>🏘️ Villa: +8 población, -2 felicidad</li>
-                        <li>🏢 Edificio: +20 población, +1 felicidad</li>
-                        <li>🏫 Escuela: +20 educación, +10 felicidad</li>
-                        <li>🏥 Hospital: +30 salud, +15 felicidad</li>
-                        <li>⚽ Cancha: +25 felicidad, +10 cultura</li>
-                        <li>🔥 Parrilla: +20 felicidad, +15 cultura</li>
-                        <li>🌳 Plaza: +15 felicidad, +5 cultura</li>
-                        <li>🏭 Fábrica: +30 empleo, -5 felicidad</li>
+                        <li>🏠 Casa: $1,000 (+4 pop, +2 felicidad)</li>
+                        <li>🏘️ Villa: $500 (+8 pop, -2 felicidad, +15 solidaridad)</li>
+                        <li>🏢 Edificio: $5,000 (+20 pop, +1 felicidad)</li>
+                        <li>🏫 Escuela: $8,000 (+20 educación)</li>
+                        <li>🏥 Hospital: $15,000 (+30 salud)</li>
+                        <li>⚽ Cancha: $3,000 (+25 felicidad, +10 cultura)</li>
+                        <li>🔥 Parrilla: $2,000 (+20 felicidad, +15 cultura)</li>
+                        <li>🌳 Plaza: $1,500 (+15 felicidad, +5 cultura)</li>
+                        <li>🏭 Fábrica: $12,000 (+30 empleo, -10 pollution)</li>
+                        <li>🎭 C.Cultural: $10,000 (+40 cultura)</li>
+                        <li>🛡️ Comisaría: $7,000 (+25 seguridad)</li>
+                        <li>🚇 Subte: $20,000 (+50 transporte)</li>
+                        <li>🏪 Kiosco: $800 (+5 felicidad, +2 empleo)</li>
                     </ul>
                 </div>
                 """)
         
-        # Conectar funciones
+        # Funciones de construcción mejoradas
         def build_structure(building_type, x, y):
             return game.place_building(building_type, x, y)
         
-        # Conectar botones
-        casa_btn.click(fn=lambda x, y: build_structure("casa", x, y), 
-                      inputs=[grid_x, grid_y], outputs=[city_display, status_display, news_display])
-        villa_btn.click(fn=lambda x, y: build_structure("villa", x, y), 
-                       inputs=[grid_x, grid_y], outputs=[city_display, status_display, news_display])
-        edificio_btn.click(fn=lambda x, y: build_structure("edificio", x, y), 
-                          inputs=[grid_x, grid_y], outputs=[city_display, status_display, news_display])
-        escuela_btn.click(fn=lambda x, y: build_structure("escuela", x, y), 
-                         inputs=[grid_x, grid_y], outputs=[city_display, status_display, news_display])
-        hospital_btn.click(fn=lambda x, y: build_structure("hospital", x, y), 
-                          inputs=[grid_x, grid_y], outputs=[city_display, status_display, news_display])
-        cancha_btn.click(fn=lambda x, y: build_structure("cancha", x, y), 
-                        inputs=[grid_x, grid_y], outputs=[city_display, status_display, news_display])
-        parrilla_btn.click(fn=lambda x, y: build_structure("parrilla", x, y), 
-                          inputs=[grid_x, grid_y], outputs=[city_display, status_display, news_display])
-        plaza_btn.click(fn=lambda x, y: build_structure("plaza", x, y), 
-                       inputs=[grid_x, grid_y], outputs=[city_display, status_display, news_display])
-        fabrica_btn.click(fn=lambda x, y: build_structure("fabrica", x, y), 
-                         inputs=[grid_x, grid_y], outputs=[city_display, status_display, news_display])
-        
-        # Simulación
-        simular_btn.click(fn=game.simulate_day, outputs=[city_display, status_display, news_display])
-    
-    return interface
-
-if __name__ == "__main__":
-    interface = create_simcity_interface()
-    interface.launch(share=True, show_error=True)
+        # Conectar TODOS los botones
+        house_btn.click(fn=lambda x, y: build_structure("casa", x, y), 
+                       inputs=[grid_x_input, grid_y_input],