Update app.py

app.py

@@ -1,811 +1,590 @@
-# app.py - SIMCIUDAD ARGENTINA: REVOLUCIÓN GRÁFICA
+# app.py - SIMCIUDAD ARGENTINA FUNCIONAL Y ÉPICO
 import gradio as gr
 import time
 import math
 import random
 import os
-from PIL import Image, ImageDraw, ImageFont
+from PIL import Image, ImageDraw
 import json
 
+# Groq AI Integration
 try:
     from groq import Groq
     GROQ_AVAILABLE = True
+    groq_client = Groq(api_key=os.getenv("GROQ_API_KEY"))
 except ImportError:
     GROQ_AVAILABLE = False
+    groq_client = None
 
-class ArgentineCityBuilder:
-    """SimCity Argentino con mecánicas revolucionarias"""
+class AIUrbanPlanner:
+    """IA para planificación urbana argentina"""
     def __init__(self):
-        self.width, self.height = 1000, 700
-        self.grid_size = 20
-        self.city_grid = {}  # Coordenadas -> tipo de edificio
-        self.population = 100
-        self.happiness = 75
-        self.economy = 1000
-        self.inflation = 1.0
-        self.cultural_identity = 90
+        self.enabled = GROQ_AVAILABLE and groq_client is not None
+        
+    def generate_city_advice(self, city_state):
+        """Genera consejos de planificación urbana"""
+        if not self.enabled:
+            return "Construí más plazas para aumentar la felicidad de los vecinos."
         
-        # Sistemas dinámicos
-        self.neighborhoods = {}
-        self.transport_network = {}
-        self.cultural_centers = {}
-        self.businesses = {}
+        try:
+            prompt = f"""
+            Sos un urbanista argentino experto. Analizá esta ciudad y dá consejos breves:
+            
+            Población: {city_state.get('population', 0)}
+            Felicidad: {city_state.get('happiness', 0)}%
+            Presupuesto: ${city_state.get('budget', 0)}
+            Edificios: {city_state.get('buildings', 0)}
+            
+            Dá UN consejo específico y argentino en 1-2 líneas máximo.
+            """
+            
+            response = groq_client.chat.completions.create(
+                messages=[{"role": "user", "content": prompt}],
+                model="llama-3.1-8b-instant",
+                temperature=0.7,
+                max_tokens=80
+            )
+            
+            return response.choices[0].message.content.strip()
+        except:
+            return "La ciudad necesita más espacios verdes para el bienestar."
+
+class ArgentineCityEngine:
+    """Motor de la ciudad argentina"""
+    def __init__(self):
+        # Estado básico de la ciudad
+        self.population = 150
+        self.happiness = 75
+        self.budget = 25000
+        self.buildings = {}
+        self.grid_size = 30
         
-        # Recursos complejos
+        # Recursos
         self.resources = {
-            'presupuesto': 50000,
             'energia': 100,
             'agua': 100,
             'seguridad': 70,
             'educacion': 60,
             'salud': 65,
             'cultura': 80,
-            'empleo': 75,
-            'vivienda': 50
+            'empleo': 75
         }
         
-        # Edificios disponibles
+        # Tipos de edificios
         self.building_types = {
-            'casa': {'cost': 1000, 'pop': 4, 'happiness': 2},
-            'villa': {'cost': 500, 'pop': 8, 'happiness': -2, 'solidarity': 15},
-            'edificio': {'cost': 5000, 'pop': 20, 'happiness': 1},
-            'escuela': {'cost': 8000, 'education': 20, 'happiness': 10},
-            'hospital': {'cost': 15000, 'health': 30, 'happiness': 15},
-            'cancha': {'cost': 3000, 'happiness': 25, 'culture': 10},
-            'parrilla': {'cost': 2000, 'happiness': 20, 'culture': 15},
-            'centro_cultural': {'cost': 10000, 'culture': 40, 'education': 10},
-            'fabrica': {'cost': 12000, 'employment': 30, 'pollution': -10},
-            'plaza': {'cost': 1500, 'happiness': 15, 'culture': 5},
-            'subte': {'cost': 20000, 'transport': 50, 'happiness': 10},
-            'comisaria': {'cost': 7000, 'security': 25, 'happiness': -5},
-            'kiosco': {'cost': 800, 'happiness': 5, 'employment': 2}
+            '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}
         }
         
-        # 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'
+        # 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')
+        ]
         
-        # Una escuela inicial
-        self.city_grid[(15, 20)] = 'escuela'
+        for x, y, building_type in initial_buildings:
+            self.buildings[(x, y)] = building_type
 
-class AdvancedCityRenderer:
-    """Renderizador avanzado con gráficos isométricos"""
+class CityRenderer:
+    """Renderizador de la ciudad"""
     def __init__(self):
+        self.tile_size = 25
         self.animation_time = 0
-        self.tile_size = 20
         
-    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))
+    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))
         draw = ImageDraw.Draw(img)
         
         self.animation_time += 0.1
         
-        # Fondo: Cielo dinámico según felicidad
-        self._draw_dynamic_sky(draw, city_builder)
+        # Fondo de la ciudad
+        self._draw_background(draw, width, height, city_engine)
         
-        # Grid base de la ciudad
-        self._draw_city_grid(draw, city_builder)
+        # Grid de calles
+        self._draw_streets(draw, width, height)
         
-        # Edificios con perspectiva isométrica
-        self._draw_isometric_buildings(draw, city_builder)
+        # Edificios
+        self._draw_buildings(draw, city_engine)
         
-        # 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)
+        # Efectos dinámicos
+        self._draw_city_effects(draw, city_engine, width, height)
         
         return img
     
-    def _draw_dynamic_sky(self, draw, city):
-        """Cielo que cambia según el estado de la ciudad"""
+    def _draw_background(self, draw, width, height, city):
+        """Fondo dinámico según felicidad"""
         happiness = city.happiness
         
-        # Color base del cielo
+        # Color del cielo según felicidad
         if happiness > 80:
-            sky_color = (135, 206, 250)  # Azul cielo feliz
+            sky_start = (135, 206, 250)
+            sky_end = (100, 149, 237)
         elif happiness > 60:
-            sky_color = (176, 196, 222)  # Azul grisáceo
-        elif happiness > 40:
-            sky_color = (119, 136, 153)  # Gris claro
+            sky_start = (119, 136, 153)
+            sky_end = (105, 105, 105)
         else:
-            sky_color = (105, 105, 105)  # Gris oscuro
+            sky_start = (70, 70, 70)
+            sky_end = (50, 50, 50)
         
         # Gradiente de cielo
         for y in range(200):
-            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)
+            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)
         
-        # 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)
+        # Base verde
+        draw.rectangle([0, 200, width, height], fill=(40, 80, 40))
     
-    def _draw_cloud(self, draw, x, y, happiness):
-        """Dibuja nube con forma según felicidad"""
-        cloud_color = (255, 255, 255, 180) if happiness > 50 else (200, 200, 200, 150)
+    def _draw_streets(self, draw, width, height):
+        """Calles de la ciudad"""
+        street_color = (80, 80, 80)
         
-        # 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[:3])
-    
-    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)
+        # Calles horizontales
+        for y in range(200, height, self.tile_size * 3):
+            draw.rectangle([0, y, width, y + self.tile_size], fill=street_color)
         
-        # Grid horizontal
-        for y in range(0, city.height, self.tile_size):
-            draw.line([0, y, city.width, y], fill=grid_color, width=1)
+        # Calles verticales
+        for x in range(0, width, self.tile_size * 3):
+            draw.rectangle([x, 200, x + self.tile_size, height], fill=street_color)
         
-        # Grid vertical
-        for x in range(0, city.width, self.tile_size):
-            draw.line([x, 0, x, city.height], fill=grid_color, width=1)
+        # 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)
+        
+        for x in range(0, width, self.tile_size):
+            draw.line([(x, 200), (x, height)], fill=(60, 80, 60), width=1)
     
-    def _draw_isometric_buildings(self, draw, city):
-        """Edificios con perspectiva isométrica"""
-        for (grid_x, grid_y), building_type in city.city_grid.items():
+    def _draw_buildings(self, draw, city):
+        """Dibuja todos los edificios"""
+        for (grid_x, grid_y), building_type in city.buildings.items():
             screen_x = grid_x * self.tile_size
-            screen_y = grid_y * self.tile_size
+            screen_y = 200 + grid_y * self.tile_size
             
-            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)
+            if building_type in city.building_types:
+                self._draw_single_building(draw, screen_x, screen_y, building_type, city)
     
-    def _draw_house_isometric(self, draw, x, y, happiness):
-        """Casa con perspectiva isométrica"""
-        # Base de la casa
-        house_color = (139, 69, 19) if happiness > 60 else (101, 67, 33)
-        
-        # Paredes (vista isométrica)
-        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))
-        
+    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)
+    
+    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))
         # Puerta
-        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))
+        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))
     
-    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 más grande
-        draw.rectangle([x, y + 5, x + 20, y + 18], fill=color, outline=(0, 0, 0), width=2)
-        
+    def _draw_villa(self, draw, x, y, color):
+        """Casa de villa colorida"""
+        # Casa principal
+        draw.rectangle([x + 1, y + 10, x + 23, y + 23], fill=color, outline=(0, 0, 0), width=2)
         # Techo de chapa
-        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)]))
+        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))
+    
+    def _draw_apartment(self, draw, x, y, color):
+        """Edificio de departamentos"""
+        # Estructura principal más alta
+        draw.rectangle([x + 1, y + 0, x + 23, y + 23], fill=color, outline=(0, 0, 0), width=1)
+        # Ventanas en pisos
+        for floor in range(3):
+            floor_y = y + 5 + floor * 6
+            for window in range(3):
+                window_x = x + 4 + window * 6
+                draw.rectangle([window_x, floor_y, window_x + 3, floor_y + 3], 
+                              fill=(255, 255, 200), outline=(0, 0, 0))
+    
+    def _draw_school(self, draw, x, y, color):
+        """Escuela con bandera argentina"""
+        # Edificio principal
+        draw.rectangle([x + 1, y + 8, x + 23, y + 23], fill=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))
     
-    def _draw_soccer_field(self, draw, x, y, happiness):
-        """Cancha de fútbol con actividad"""
+    def _draw_hospital(self, draw, x, y, color):
+        """Hospital con cruz roja"""
+        # Edificio
+        draw.rectangle([x + 1, y + 5, x + 23, y + 23], fill=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))
+    
+    def _draw_field(self, draw, x, y, color):
+        """Cancha de fútbol"""
         # Césped
-        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)
-        
+        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)
         # Arcos
-        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))
-        
+        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)
         # Pelota animada
-        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))
+        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))
     
-    def _draw_parrilla(self, draw, x, y, cultural_identity):
-        """Parrilla argentina con humo"""
+    def _draw_grill(self, draw, x, y, color):
+        """Parrilla con humo"""
         # Base de la parrilla
-        draw.rectangle([x + 5, y + 10, x + 15, y + 18], fill=(50, 50, 50), outline=(100, 100, 100))
-        
-        # Parrilla
-        for i in range(3):
-            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))
-        
+        draw.rectangle([x + 8, y + 15, x + 16, y + 23], fill=(50, 50, 50), outline=(100, 100, 100))
         # 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, 150 - i * 30))
-        
-        # 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))
+        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))
     
-    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))
-        
+    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))
         # Senderos
-        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))
-        
+        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)
         # Árboles
-        for tree_pos in [(x + 5, y + 5), (x + 25, y + 5), (x + 5, y + 25), (x + 25, y + 25)]:
+        tree_positions = [(x + 5, y + 11), (x + 19, y + 11), (x + 5, y + 19), (x + 19, y + 19)]
+        for tree_x, tree_y in tree_positions:
             # Tronco
-            draw.rectangle([tree_pos[0], tree_pos[1] + 5, tree_pos[0] + 2, tree_pos[1] + 10], 
-                          fill=(101, 67, 33))
+            draw.rectangle([tree_x, tree_y + 3, tree_x + 2, tree_y + 8], fill=(101, 67, 33))
             # Copa
-            draw.ellipse([tree_pos[0] - 3, tree_pos[1], tree_pos[0] + 5, tree_pos[1] + 8], 
-                        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))
+            draw.ellipse([tree_x - 2, tree_y, tree_x + 4, tree_y + 6], fill=(50, 150, 50))
     
-    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_factory(self, draw, x, y, color):
+        """Fábrica con chimeneas"""
+        # Edificio principal
+        draw.rectangle([x + 1, y + 8, x + 23, y + 23], fill=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_animated_traffic(self, draw, city):
-        """Tráfico animado en las calles"""
-        # Autobuses y colectivos
-        for i in range(3):
-            bus_x = (100 + i * 300 + int(self.animation_time * 50)) % city.width
-            bus_y = 200 + i * 100
+    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))
+
+class SimCityGame:
+    """Juego principal"""
+    def __init__(self):
+        self.city = ArgentineCityEngine()
+        self.renderer = CityRenderer()
+        self.ai_planner = AIUrbanPlanner()
+        self.day = 1
+        
+    def place_building(self, building_type, grid_x, grid_y):
+        """Coloca un edificio"""
+        try:
+            grid_x, grid_y = int(grid_x), int(grid_y)
             
-            # Colectivo argentino
-            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))
+            if building_type not in self.city.building_types:
+                return "Tipo de edificio inválido", self.get_status(), "Error en tipo de edificio"
             
-            # Persona simple
-            draw.ellipse([person_x, person_y, person_x + 4, person_y + 8], 
-                        fill=(180, 140, 100))
+            if (grid_x, grid_y) in self.city.buildings:
+                return "Ya hay un edificio ahí", self.get_status(), "Posición ocupada"
             
-            # 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_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(200 * (1 - i/panel_height))
-            draw.rectangle([10, 10 + i, 10 + panel_width, 11 + i], 
-                          fill=(0, 0, 0, alpha))
-        
-        # Borde elegante
-        draw.rectangle([10, 10, 10 + panel_width, 10 + panel_height], 
-                      outline=(100, 150, 255), width=3)
-        
-        # Información de la ciudad
-        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"
-        ]
-        
-        for info in city_info:
-            # Sombra del texto
-            info_y += 20
-        
-        # 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)
-        }
-        
-        y_offset = start_y
-        for resource, value in resources.items():
-            if resource == 'presupuesto':
-                # Presupuesto se muestra diferente
-                budget_text = f"💰 ${value:,}"
-                y_offset += 25
-                continue
+            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"
             
-            # Normalizar valor para barra (0-100)
-            normalized_value = max(0, min(100, value)) if isinstance(value, (int, float)) else 50
+            # Construir
+            self.city.budget -= cost
+            self.city.buildings[(grid_x, grid_y)] = building_type
             
-            # 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))
+            # 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))
             
-            # Barra de valor con gradiente
-            fill_width = int((normalized_value / 100) * (bar_width - 4))
-            color = resource_colors.get(resource, (150, 150, 150))
+            # 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)
+            })
             
-            # 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)
+            frame = self.renderer.render_city(self.city)
+            status = self.get_status()
+            message = f"✅ {building_type.title()} construido por ${cost:,}"
             
-            # Etiqueta del recurso
-            resource_names = {
-                'energia': '⚡ Energía', 'agua': '💧 Agua', 'seguridad': '🛡️ Seguridad',
-                'educacion': '📚 Educación', 'salud': '🏥 Salud', 'cultura': '🎭 Cultura',
-                'empleo': '💼 Empleo', 'vivienda': '🏠 Vivienda'
-            }
+            return frame, status, f"{message}\n\n🤖 IA: {advice}"
             
-            y_offset += 22
+        except Exception as e:
+            return "Error en construcción", self.get_status(), f"Error: {str(e)}"
     
-    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
+    def simulate_day(self):
+        """Simula un día"""
+        try:
+            self.day += 1
             
-            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)
-            }
+            # Ingresos
+            daily_income = self.city.population * 15 + len(self.city.buildings) * 200
+            self.city.budget += daily_income
             
-            color = building_colors.get(building_type, (100, 100, 100))
-            draw.rectangle([mini_x, mini_y, mini_x + scale, mini_y + scale], fill=color)
-
-class EnhancedCityGame:
-    """Juego de ciudad argentino mejorado"""
-    def __init__(self):
-        self.city = ArgentineCityBuilder()
-        self.renderer = AdvancedCityRenderer()
-        self.selected_building = None
-        self.game_speed = 1
-        self.events_log = []
-        
-    def place_building(self, building_type, grid_x, grid_y):
-        """Coloca un edificio en la ciudad"""
-        if building_type not in self.city.building_types:
-            return "Tipo de edificio inválido"
-        
-        building_info = self.city.building_types[building_type]
-        cost = building_info['cost']
-        
-        # Verificar si se puede pagar
-        if self.city.resources['presupuesto'] < cost:
-            return f"No tenés suficiente presupuesto. Necesitás ${cost:,}"
-        
-        # Verificar si la posición está libre
-        if (grid_x, grid_y) in self.city.city_grid:
-            return "Ya hay un edificio en esa posición"
-        
-        # Construir edificio
-        self.city.resources['presupuesto'] -= cost
-        self.city.city_grid[(grid_x, grid_y)] = building_type
-        
-        # Aplicar efectos del edificio
-        self._apply_building_effects(building_type, building_info)
-        
-        # Actualizar estadísticas de la ciudad
-        self._update_city_stats()
-        
-        return f"✅ {building_type.replace('_', ' ').title()} construido por ${cost:,}"
-    
-    def _apply_building_effects(self, building_type, building_info):
-        """Aplica los efectos de un edificio a la ciudad"""
-        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:
-                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']
-        economy_bonus = sum(10000 for pos, building in self.city.city_grid.items() 
-                           if building in economy_buildings)
-        self.city.economy = 1000 + economy_bonus + self.city.population * 50
-        
-        # Inflación aumenta con el tiempo y población
-        self.city.inflation += 0.01 + (len(self.city.city_grid) * 0.001)
-        
-        # Felicidad general
-        happiness_factors = [
-            self.city.resources.get('cultura', 50),
-            self.city.resources.get('seguridad', 50),
-            self.city.resources.get('empleo', 50),
-            self.city.cultural_identity
-        ]
-        self.city.happiness = sum(happiness_factors) // len(happiness_factors)
-    
-    def simulate_day(self):
-        """Simula un día en la ciudad"""
-        # Ingresos diarios
-        daily_income = self.city.population * 10 + self.city.economy * 0.01
-        self.city.resources['presupuesto'] += int(daily_income)
-        
-        # Gastos de mantenimiento
-        maintenance_cost = len(self.city.city_grid) * 100
-        self.city.resources['presupuesto'] -= maintenance_cost
-        
-        # Efectos de la inflación
-        self.city.resources['presupuesto'] = int(self.city.resources['presupuesto'] / self.city.inflation)
-        
-        # Eventos aleatorios
-        if random.random() < 0.2:
-            self._trigger_city_event()
-        
-        # Actualizar todo
-        self._update_city_stats()
-        
-        return f"💰 Ingresos: ${daily_income:,.0f} | 💸 Gastos: ${maintenance_cost:,} | 📈 Inflación: {self.city.inflation:.2f}x"
-    
-    def _trigger_city_event(self):
-        """Eventos aleatorios de la ciudad"""
-        events = [
-            ("🎉 Festival de Tango", "cultura", 15, "happiness", 20),
-            ("⚽ River vs Boca", "happiness", 30, "cultura", 10),
-            ("🏭 Nueva fábrica privada", "empleo", 20, "presupuesto", 5000),
-            ("🌧️ Lluvia torrencial", "agua", 25, "energia", -10),
-            ("📚 Programa de alfabetización", "educacion", 15, "cultura", 10),
-            ("🏥 Campaña de vacunación", "salud", 20, "happiness", 15),
-            ("💸 Crisis económica menor", "presupuesto", -3000, "happiness", -10),
-            ("🎭 Nuevo centro cultural", "cultura", 25, "educacion", 10)
-        ]
-        
-        event_name, res1, val1, res2, val2 = random.choice(events)
-        
-        # Aplicar efectos
-        if res1 == 'presupuesto':
-            self.city.resources[res1] += val1
-        else:
-            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))
-        else:
-            self.city.resources[res2] = min(100, max(0, self.city.resources[res2] + val2))
-        
-        self.events_log.append(event_name)
-        return event_name
+            # Gastos de mantenimiento
+            maintenance = len(self.city.buildings) * 50
+            self.city.budget -= maintenance
+            
+            # 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))
+            
+            frame = self.renderer.render_city(self.city)
+            status = self.get_status()
+            
+            message = f"📅 Día {self.day} simulado\n💰 Ingresos: ${daily_income:,}\n💸 Gastos: ${maintenance:,}"
+            if event_message:
+                message += f"\n{event_message}"
+            
+            return frame, status, message
+            
+        except Exception as e:
+            return "Error en simulación", self.get_status(), f"Error: {str(e)}"
     
-    def get_city_status(self):
-        """Status completo de la ciudad"""
-        return {
-            "🏙️ Población": f"{self.city.population:,} habitantes",
-            "😊 Felicidad": f"{self.city.happiness}%",
-            "💰 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"{len(self.city.city_grid)} construidos",
-            "⚡ Recursos": f"Energía {self.city.resources['energia']}% | Agua {self.city.resources['agua']}%"
-        }
+    def get_status(self):
+        """Estado actual de la ciudad"""
+        try:
+            building_count = len(self.city.buildings)
+            return {
+                "🏙️ Población": f"{self.city.population:,} habitantes",
+                "😊 Felicidad": f"{self.city.happiness}%",
+                "💰 Presupuesto": f"${self.city.budget:,}",
+                "🏗️ 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']}%"
+            }
+        except Exception as e:
+            return {"Error": str(e)}
 
 def create_simcity_interface():
-    """Interfaz del SimCity Argentino"""
-    game = EnhancedCityGame()
+    """Interfaz principal del juego"""
+    game = SimCityGame()
     
     with gr.Blocks(
-        title="🇦🇷 SIMCIUDAD ARGENTINA - Construcción Épica",
-        theme=gr.themes.Glass(),
-        css="""
-        .building-btn { font-size: 1.1em; padding: 10px; margin: 3px; }
-        .city-header { background: linear-gradient(45deg, #74b9ff, #0984e3, #00b894); }
-        """
+        title="🇦🇷 SIMCIUDAD ARGENTINA",
+        theme=gr.themes.Soft()
     ) as interface:
         
         gr.HTML("""
-        <div class="city-header" style="padding: 25px; text-align: center; border-radius: 15px; margin: 15px;">
-            <h1 style="color: white; font-size: 3em; margin: 0; text-shadow: 3px 3px 6px rgba(0,0,0,0.7);">
+        <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);">
                 🏙️ SIMCIUDAD ARGENTINA 🇦🇷
             </h1>
-            <h2 style="color: #ddd; font-size: 1.3em; margin: 10px 0;">
-                Construí la Ciudad Argentina de tus Sueños
-            </h2>
-            <p style="color: #f1f2f6; font-size: 1.1em;">
-                Gráficos Isométricos • Mecánicas Realistas • Cultura Auténtica
+            <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
             </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
+                    height=700,
+                    value=game.renderer.render_city(game.city)
                 )
                 
                 gr.Markdown("### 🏗️ HERRAMIENTAS DE CONSTRUCCIÓN")
+                
                 with gr.Row():
-                    # Coordenadas para construcción
-                    grid_x_input = gr.Number(label="Coordenada X", value=20, minimum=0, maximum=50)
-                    grid_y_input = gr.Number(label="Coordenada Y", value=20, minimum=0, maximum=35)
+                    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)
                 
+                # Botones de construcción
                 with gr.Row():
-                    house_btn = gr.Button("🏠 CASA", variant="secondary", elem_classes="building-btn")
-                    villa_btn = gr.Button("🏘️ VILLA", variant="secondary", elem_classes="building-btn")
-                    building_btn = gr.Button("🏢 EDIFICIO", variant="primary", elem_classes="building-btn")
+                    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")
                 
                 with gr.Row():
-                    school_btn = gr.Button("🏫 ESCUELA", variant="primary", elem_classes="building-btn")
-                    hospital_btn = gr.Button("🏥 HOSPITAL", variant="stop", elem_classes="building-btn")
-                    field_btn = gr.Button("⚽ CANCHA", variant="secondary", elem_classes="building-btn")
+                    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")
                 
                 with gr.Row():
-                    grill_btn = gr.Button("🔥 PARRILLA", variant="stop", elem_classes="building-btn")
-                    plaza_btn = gr.Button("🌳 PLAZA", variant="secondary", elem_classes="building-btn")
-                    factory_btn = gr.Button("🏭 FÁBRICA", variant="primary", elem_classes="building-btn")
+                    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")
                 
+                # Botón de simulación
                 with gr.Row():
-                    simulate_btn = gr.Button("⏭️ SIMULAR DÍA", variant="primary", size="lg")
+                    simular_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")
-                city_status = gr.JSON(
+                status_display = gr.JSON(
                     label="📈 Estadísticas",
-                    value=game.get_city_status()
+                    value=game.get_status()
                 )
                 
+                # Eventos y noticias
                 gr.Markdown("### 📰 EVENTOS RECIENTES")
-                events_display = gr.Textbox(
-                    value="🎮 ¡Bienvenido al SimCity Argentino! Construí tu ciudad con identidad nacional.",
+                news_display = gr.Textbox(
                     label="📺 Noticias Urbanas",
+                    value="🎮 ¡Bienvenido al SimCity Argentino! Empezá construyendo casas y servicios para tu comunidad.",
                     lines=5,
                     interactive=False
                 )
                 
-                gr.Markdown("### 💰 COSTOS DE CONSTRUCCIÓN")
+                # Info de construcción
+                gr.Markdown("### 💰 GUÍA DE CONSTRUCCIÓN")
                 gr.HTML("""
-                <div style="background: #2d3436; color: white; padding: 15px; border-radius: 10px;">
-                    <p><strong>💵 Precios:</strong></p>
-                    <ul style="font-size: 0.9em; margin: 5px 0; padding-left: 15px;">
-                        <li>🏠 Casa: $1,000</li>
-                        <li>🏘️ Villa: $500</li>
-                        <li>🏢 Edificio: $5,000</li>
-                        <li>🏫 Escuela: $8,000</li>
-                        <li>🏥 Hospital: $15,000</li>
-                        <li>⚽ Cancha: $3,000</li>
-                        <li>🔥 Parrilla: $2,000</li>
-                        <li>🌳 Plaza: $1,500</li>
-                        <li>🏭 Fábrica: $12,000</li>
+                <div style="background: #2d3436; color: white; padding: 15px; border-radius: 10px; font-size: 0.9em;">
+                    <p><strong>🏗️ Efectos de Edificios:</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>
                     </ul>
                 </div>
                 """)
         
-        # Funciones de construcción
+        # Conectar funciones
         def build_structure(building_type, x, y):
-            message = game.place_building(building_type, int(x), int(y))
-            frame = game.renderer.render_city_frame(game.city)
-            status = game.get_city_status()
-            return frame, status, message
+            return game.place_building(building_type, x, y)
         
         # Conectar botones
-        house_btn.click(
-            fn=lambda x, y: build_structure("casa", x, y),
-            inputs=[grid_x_input, grid_y_input],
-            outputs=[city_display, city_status, events_display]
-        )
-        villa_btn.click(
-            fn=lambda x, y: build_structure("villa", x, y),
-            inputs=[grid_x_input, grid_y_input],
-            outputs=[city_display, city_status, events_display]
-        )
-        building_btn.click(
-            fn=lambda x, y: build_structure("edificio", x, y),
-            inputs=[grid_x_input, grid_y_input],
-            outputs=[city_display, city_status, events_display]
-        )
-        school_btn.click(
-            fn=lambda x, y: build_structure("escuela", x, y),
-            inputs=[grid_x_input, grid_y_input],
-            outputs=[city_display, city_status, events_display]
-        )
-        hospital_btn.click(
-            fn=lambda x, y: build_structure("hospital", x, y),
-            inputs=[grid_x_input, grid_y_input],
-            outputs=[city_display, city_status, events_display]
-        )
-        field_btn.click(
-            fn=lambda x, y: build_structure("cancha", x, y),
-            inputs=[grid_x_input, grid_y_input],
-            outputs=[city_display, city_status, events_display]
-        )
-        grill_btn.click(
-            fn=lambda x, y: build_structure("parrilla", x, y),
-            inputs=[grid_x_input, grid_y_input],
-            outputs=[city_display, city_status, events_display]
-        )
-        plaza_btn.click(
-            fn=lambda x, y: build_structure("plaza", x, y),
-            inputs=[grid_x_input, grid_y_input],
-            outputs=[city_display, city_status, events_display]
-        )
-        factory_btn.click(
-            fn=lambda x, y: build_structure("fabrica", x, y),
-            inputs=[grid_x_input, grid_y_input],
-            outputs=[city_display, city_status, events_display]
-        )
-        
-        # Simulación de día
-        simulate_btn.click(
-            fn=lambda: (
-                game.renderer.render_city_frame(game.city),
-                game.get_city_status(),
-                game.simulate_day()
-            ),
-            outputs=[city_display, city_status, events_display]
-        )
-        
-        # Estado inicial
-        interface.load(
-            fn=lambda: (
-                game.renderer.render_city_frame(game.city),
-                game.get_city_status(),
-                "🎮 ¡SimCiudad Argentina iniciado! Empezá construyendo casas y escuelas."
-            ),
-            outputs=[city_display, city_status, events_display]
-        )
+        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