Update app.py

app.py

@@ -1,507 +1,592 @@
-# app.py - EL GAUCHO CÓSMICO ÉPICO VERSION 2.0
+# main_game.py - CRISIS Y CORAJE: EL JUEGO ARGENTINO DEFINITIVO
 import gradio as gr
 import time
 import math
 import random
-from PIL import Image, ImageDraw, ImageFont
-from game_engine import GauchoCharacter, PhysicsEngine, WorldGenerator, Vector2D
+from PIL import Image, ImageDraw
+from typing import Dict, List, Tuple
 
-class EpicGameEngine:
+class ArgentinaGameEngine:
     def __init__(self):
-        self.width = 800
-        self.height = 600
-        self.player = GauchoCharacter()
-        self.player.position = Vector2D(100, 400)
-        self.physics = PhysicsEngine()
-        
-        # Sistema de juego épico
-        self.scroll_x = 0
-        self.enemies = []
-        self.projectiles = []
-        self.crystals = []
-        self.particles = []
-        self.combo_meter = 0
-        self.cultural_power = 100
-        
-        # Estados de juego
-        self.game_state = "playing"  # playing, dialogue, victory
-        self.current_level = 1
-        self.boss_fight = False
-        
-        # Inicializar mundo épico
-        self._spawn_initial_world()
-        self._spawn_enemies()
-        self._spawn_crystals()
-    
-    def _spawn_initial_world(self):
-        """Crea un mundo side-scrolling épico"""
-        self.terrain = []
-        for x in range(0, 2000, 50):
-            height = 450 + 50 * math.sin(x / 100)
-            self.terrain.append((x, int(height)))
-    
-    def _spawn_enemies(self):
-        """Genera enemigos algorítmicos épicos"""
-        enemy_types = ['homogenizer', 'cultural_eraser', 'identity_fragmenter']
-        for i in range(5):
-            self.enemies.append({
-                'type': random.choice(enemy_types),
-                'position': Vector2D(300 + i * 200, 350),
-                'health': 3,
-                'pattern': 'patrol',
-                'attack_timer': 0,
-                'animation_frame': 0
-            })
-    
-    def _spawn_crystals(self):
-        """Cristales de valores argentinos distribuidos épicamente"""
-        values = ['Solidaridad', 'Familia', 'Amistad', 'Respeto', 'Creatividad']
-        colors = [(255, 100, 100), (100, 255, 100), (100, 100, 255), (255, 255, 100), (255, 100, 255)]
-        
-        for i, (value, color) in enumerate(zip(values, colors)):
-            self.crystals.append({
-                'type': value,
-                'position': Vector2D(200 + i * 300, 200 + random.randint(-100, 100)),
-                'color': color,
-                'collected': False,
-                'pulse': 0,
-                'floating_offset': random.random() * math.pi
-            })
-    
-    def update_game(self, action):
-        """Motor de juego principal"""
-        dt = 0.016  # 60 FPS target
-        
-        # Actualizar jugador
-        self._update_player(action, dt)
-        
-        # Actualizar mundo
-        self._update_scroll()
-        self._update_enemies(dt)
-        self._update_projectiles(dt)
-        self._update_particles(dt)
-        self._check_collisions()
-        
-        # Sistemas de juego
-        self._update_combo_system()
-        self._check_victory_condition()
-    
-    def _update_player(self, action, dt):
-        """Sistema de movimiento fluido del gaucho"""
-        acceleration = Vector2D(0, 0.5)  # Gravedad
-        
-        if action == "left":
-            acceleration.x = -8
-            self.player.facing = "left"
-        elif action == "right":
-            acceleration.x = 8
-            self.player.facing = "right"
-        elif action == "jump":
-            if self.player.on_ground:
-                self.player.velocity.y = -12
-                self.player.on_ground = False
-                self._create_particles(self.player.position, "jump", 5)
-        elif action == "attack":
-            self._throw_boleadoras()
-        elif action == "special":
-            self._use_mate_power()
-        
-        # Aplicar física fluida
-        self.player.velocity = self.physics.apply_momentum(
-            self.player.velocity, acceleration, dt
-        )
+        # Core del juego
+        self.width, self.height = 900, 600
+        self.player = ArgentineCharacter()
+        self.world = ArgentineWorld()
         
-        # Movimiento suave
-        self.player.position += self.player.velocity * dt * 60
+        # Sistema de supervivencia argentino
+        self.resources = {
+            'pesos': 1000,
+            'dolares': 50,
+            'comida': 80,
+            'esperanza': 100,
+            'solidaridad': 90,
+            'trabajo': 70
+        }
         
-        # Colisión con terreno
-        self._handle_terrain_collision()
-    
-    def _update_scroll(self):
-        """Cámara que sigue al jugador dinámicamente"""
-        target_scroll = self.player.position.x - 200
-        self.scroll_x += (target_scroll - self.scroll_x) * 0.1  # Smooth following
-    
-    def _throw_boleadoras(self):
-        """Sistema de combate con boleadoras cuánticas"""
-        if len(self.projectiles) < 3:  # Máximo 3 boleadoras activas
-            direction = 1 if self.player.facing == "right" else -1
-            self.projectiles.append({
-                'position': Vector2D(self.player.position.x, self.player.position.y - 20),
-                'velocity': Vector2D(direction * 15, -2),
-                'type': 'boleadoras',
-                'lifetime': 2.0,
-                'trail': []
-            })
-            self._create_particles(self.player.position, "boleadoras", 3)
-    
-    def _use_mate_power(self):
-        """Poder especial del mate tecnológico"""
-        if self.cultural_power >= 50:
-            self.cultural_power -= 50
-            self.combo_meter += 20
-            
-            # Efecto de área que afecta enemigos cercanos
-            for enemy in self.enemies:
-                distance = ((self.player.position.x - enemy['position'].x) ** 2 + 
-                           (self.player.position.y - enemy['position'].y) ** 2) ** 0.5
-                if distance < 150:
-                    enemy['health'] -= 2
-                    self._create_particles(enemy['position'], "mate_effect", 8)
+        # Mecánicas únicas argentinas
+        self.inflation_rate = 1.0
+        self.social_network = []
+        self.cultural_events = []
+        self.crisis_level = 1
+        
+        # Estados del juego dinámicos
+        self.day = 1
+        self.season = "verano"
+        self.current_crisis = "corralito_2001"
+        self.neighborhood_mood = "esperanzado"
+        
+        self.initialize_argentina()
     
-    def _create_particles(self, position, particle_type, count):
-        """Sistema de partículas épico"""
-        for _ in range(count):
-            self.particles.append({
-                'position': Vector2D(position.x + random.randint(-10, 10), 
-                                   position.y + random.randint(-10, 10)),
-                'velocity': Vector2D(random.randint(-3, 3), random.randint(-5, 0)),
-                'color': self._get_particle_color(particle_type),
-                'lifetime': random.uniform(0.5, 1.5),
-                'type': particle_type
-            })
+    def initialize_argentina(self):
+        """Inicializa el mundo argentino auténtico"""
+        self.create_neighborhoods()
+        self.spawn_cultural_events()
+        self.setup_crisis_timeline()
+
+class ArgentineCharacter:
+    def __init__(self):
+        self.name = "Carlos"
+        self.profession = random.choice(["albañil", "docente", "comerciante", "empleado_publico"])
+        self.position = [450, 300]  # Centro de CABA
+        self.family = {
+            'spouse': True,
+            'children': random.randint(1, 3),
+            'elderly_parents': random.choice([True, False])
+        }
+        
+        # Skills argentinos únicos
+        self.skills = {
+            'rebusque': 70,
+            'mate_sharing': 90,
+            'asado_expertise': 80,
+            'crisis_survival': 60,
+            'soccer_knowledge': 95,
+            'political_debate': 75
+        }
+        
+        self.current_strategy = "supervivencia_diaria"
+        self.stress_level = 30
+        self.community_reputation = 50
+
+class CrisisManager:
+    """Sistema que simula las crisis argentinas reales"""
+    def __init__(self):
+        self.crisis_timeline = {
+            2001: {
+                'name': 'Corralito',
+                'effects': {'peso_devaluation': 300, 'unemployment': 25, 'social_unrest': 80},
+                'opportunities': ['trueque', 'economia_popular', 'solidaridad_vecinal']
+            },
+            2008: {
+                'name': 'Crisis Mundial',
+                'effects': {'export_drop': 40, 'inflation': 25},
+                'opportunities': ['mercado_interno', 'cooperativas']
+            },
+            2018: {
+                'name': 'Crisis Cambiaria',
+                'effects': {'peso_devaluation': 100, 'inflation': 50},
+                'opportunities': ['dolarizacion_popular', 'emprendedurismo']
+            },
+            2020: {
+                'name': 'Pandemia',
+                'effects': {'lockdown': 90, 'unemployment': 15, 'solidarity_boost': 120},
+                'opportunities': ['delivery', 'remote_work', 'community_support']
+            }
+        }
     
-    def _get_particle_color(self, particle_type):
-        colors = {
-            'jump': (100, 200, 255),
-            'boleadoras': (255, 200, 100),
-            'mate_effect': (0, 255, 100),
-            'explosion': (255, 100, 100),
-            'crystal': (255, 255, 255)
+    def apply_crisis_effects(self, game_state, current_year):
+        """Aplica efectos realistas de las crisis"""
+        if current_year in self.crisis_timeline:
+            crisis = self.crisis_timeline[current_year]
+            return self.modify_game_state(game_state, crisis)
+        return game_state
+
+class NeighborhoodSystem:
+    """Sistema de barrios argentinos dinámicos"""
+    def __init__(self):
+        self.neighborhoods = {
+            'villa_31': {
+                'solidarity': 95, 'resources': 30, 'creativity': 90,
+                'challenges': ['infraestructura', 'estigma_social'],
+                'strengths': ['union_vecinal', 'cultura_popular']
+            },
+            'palermo': {
+                'solidarity': 60, 'resources': 85, 'creativity': 75,
+                'challenges': ['gentrificacion', 'burbuja_social'],
+                'strengths': ['startups', 'vida_nocturna']
+            },
+            'san_telmo': {
+                'solidarity': 80, 'resources': 70, 'creativity': 95,
+                'challenges': ['turismo_masivo'],
+                'strengths': ['tango', 'arte', 'historia']
+            },
+            'mataderos': {
+                'solidarity': 90, 'resources': 50, 'creativity': 85,
+                'challenges': ['infraestructura'],
+                'strengths': ['folklore', 'tradicion_gaucha']
+            }
         }
-        return colors.get(particle_type, (255, 255, 255))
+
+class GameRenderer:
+    def __init__(self):
+        self.current_view = "neighborhood"
+        self.animation_frame = 0
     
-    def render_epic_frame(self) -> Image.Image:
-        """Renderizado épico con múltiples capas"""
-        img = Image.new('RGB', (self.width, self.height), (10, 15, 35))
+    def render_argentina_frame(self, game_state) -> Image.Image:
+        """Renderiza Argentina de manera épica y auténtica"""
+        img = Image.new('RGB', (900, 600), (20, 30, 60))
         draw = ImageDraw.Draw(img)
         
-        # Capa 1: Fondo estrellado con parallax
-        self._draw_starfield(draw)
+        # Fondo: Skyline de Buenos Aires
+        self.draw_buenos_aires_skyline(draw, game_state)
         
-        # Capa 2: Montañas distantes
-        self._draw_mountains(draw)
+        # Primer plano: Vecindario actual
+        self.draw_neighborhood(draw, game_state)
         
-        # Capa 3: Terreno principal
-        self._draw_terrain(draw)
+        # Personajes: Vecinos interactuando
+        self.draw_community_life(draw, game_state)
         
-        # Capa 4: Cristales con efectos
-        self._draw_crystals(draw)
+        # UI: Información de supervivencia
+        self.draw_survival_ui(draw, game_state)
         
-        # Capa 5: Enemigos animados
-        self._draw_enemies(draw)
+        # Efectos especiales: Crisis o celebraciones
+        self.draw_dynamic_effects(draw, game_state)
         
-        # Capa 6: Proyectiles con trails
-        self._draw_projectiles(draw)
-        
-        # Capa 7: Gaucho protagonista
-        self._draw_epic_gaucho(draw)
+        return img
+    
+    def draw_buenos_aires_skyline(self, draw, game_state):
+        """Dibuja el skyline icónico de Buenos Aires"""
+        # Río de la Plata
+        draw.rectangle([0, 400, 900, 600], fill=(30, 60, 120))
         
-        # Capa 8: Partículas
-        self._draw_particles(draw)
+        # Puerto Madero
+        for i in range(5):
+            building_height = 250 + random.randint(-50, 50)
+            draw.rectangle([700 + i*30, 600-building_height, 720 + i*30, 600], 
+                          fill=(40, 40, 60), outline=(80, 80, 100))
         
-        # Capa 9: UI épica
-        self._draw_ui(draw)
+        # Microcentro
+        for i in range(8):
+            building_height = 200 + random.randint(-100, 100)
+            draw.rectangle([200 + i*40, 600-building_height, 230 + i*40, 600], 
+                          fill=(60, 60, 80), outline=(100, 100, 120))
         
-        return img
-    
-    def _draw_starfield(self, draw):
-        """Fondo estrellado con parallax scrolling"""
-        for i in range(100):
-            star_x = (i * 47 + self.scroll_x * 0.2) % self.width
-            star_y = (i * 31) % self.height
-            brightness = 100 + (i % 155)
-            draw.ellipse([star_x-1, star_y-1, star_x+1, star_y+1], 
-                        fill=(brightness, brightness, brightness))
+        # Obelisco (si estamos en el centro)
+        if game_state.get('location') == 'microcentro':
+            draw.polygon([(450, 150), (445, 400), (455, 400)], 
+                        fill=(200, 200, 200), outline=(255, 255, 255))
     
-    def _draw_mountains(self, draw):
-        """Montañas de fondo con profundidad"""
-        for i in range(0, self.width + 100, 100):
-            mountain_x = i - (self.scroll_x * 0.5) % 100
-            mountain_height = 200 + 50 * math.sin((mountain_x + self.scroll_x) / 150)
-            draw.polygon([
-                (mountain_x, self.height),
-                (mountain_x + 50, mountain_height),
-                (mountain_x + 100, self.height)
-            ], fill=(30, 40, 80), outline=(50, 60, 120))
+    def draw_neighborhood(self, draw, game_state):
+        """Dibuja el barrio actual con detalles auténticos"""
+        neighborhood = game_state.get('current_neighborhood', 'villa_31')
+        
+        if neighborhood == 'villa_31':
+            self.draw_villa_scene(draw, game_state)
+        elif neighborhood == 'palermo':
+            self.draw_palermo_scene(draw, game_state)
+        elif neighborhood == 'san_telmo':
+            self.draw_san_telmo_scene(draw, game_state)
     
-    def _draw_terrain(self, draw):
-        """Terreno orgánico y fluido"""
-        terrain_points = [(0, self.height)]
+    def draw_villa_scene(self, draw, game_state):
+        """Villa 31: Casas coloridas, solidaridad, creatividad"""
+        # Casas de chapa coloridas
+        colors = [(255, 100, 100), (100, 255, 100), (100, 100, 255), (255, 255, 100)]
+        for i in range(6):
+            x = 50 + i * 120
+            y = 350 + random.randint(-30, 30)
+            color = random.choice(colors)
+            
+            # Casa principal
+            draw.rectangle([x, y, x+80, y+80], fill=color, outline=(0, 0, 0), width=2)
+            
+            # Techo de chapa
+            draw.polygon([(x-5, y), (x+40, y-20), (x+85, y)], 
+                        fill=(150, 150, 150), outline=(100, 100, 100))
+            
+            # Antena parabólica
+            draw.ellipse([x+60, y-30, x+75, y-15], outline=(200, 200, 200), width=2)
         
-        for i in range(0, self.width, 20):
-            world_x = i + self.scroll_x
-            height = 450 + 30 * math.sin(world_x / 80) + 20 * math.cos(world_x / 120)
-            terrain_points.append((i, height))
+        # Cancha de fútbol improvisada
+        draw.rectangle([300, 450, 600, 550], fill=(100, 150, 50), outline=(255, 255, 255), width=3)
         
-        terrain_points.append((self.width, self.height))
-        draw.polygon(terrain_points, fill=(20, 60, 40), outline=(40, 120, 80))
+        # Arcos de fútbol
+        draw.rectangle([300, 480, 310, 520], outline=(255, 255, 255), width=3)
+        draw.rectangle([590, 480, 600, 520], outline=(255, 255, 255), width=3)
     
-    def _draw_epic_gaucho(self, draw):
-        """Gaucho protagonista con animaciones fluidas"""
-        screen_x = int(self.player.position.x - self.scroll_x)
-        screen_y = int(self.player.position.y)
-        
-        if 0 <= screen_x <= self.width:
-            # Sombra dinámica
-            draw.ellipse([screen_x-15, screen_y+20, screen_x+15, screen_y+25], 
-                        fill=(0, 0, 0, 100))
-            
-            # Cuerpo principal
-            body_color = (139, 69, 19)
-            draw.ellipse([screen_x-20, screen_y-30, screen_x+20, screen_y+10], 
-                        fill=body_color, outline=(101, 67, 33), width=2)
+    def draw_community_life(self, draw, game_state):
+        """Dibuja la vida comunitaria argentina"""
+        # Ronda de mate
+        mate_circle_x, mate_circle_y = 200, 500
+        for i in range(5):
+            angle = i * (math.pi * 2 / 5)
+            x = mate_circle_x + 40 * math.cos(angle)
+            y = mate_circle_y + 40 * math.sin(angle)
             
-            # Poncho tecnológico animado
-            poncho_wave = math.sin(time.time() * 5) * 3
-            poncho_points = [
-                (screen_x-25, screen_y-15 + poncho_wave),
-                (screen_x-15, screen_y-35),
-                (screen_x+15, screen_y-35),
-                (screen_x+25, screen_y-15 - poncho_wave),
-                (screen_x+20, screen_y+5),
-                (screen_x-20, screen_y+5)
-            ]
-            draw.polygon(poncho_points, fill=(0, 120, 200), outline=(0, 180, 255), width=2)
+            # Persona
+            draw.ellipse([x-8, y-15, x+8, y+10], fill=(150, 120, 90), outline=(100, 80, 60))
             
-            # Líneas energéticas del poncho
-            for i in range(-15, 20, 8):
-                line_alpha = int(255 * (0.5 + 0.5 * math.sin(time.time() * 3 + i)))
-                draw.line([(screen_x+i, screen_y-30), (screen_x+i, screen_y+5)], 
-                         fill=(255, 255, 100), width=1)
+            # Mate (persona central)
+            if i == 0:
+                draw.ellipse([x-3, y-5, x+3, y+2], fill=(100, 50, 0), outline=(150, 100, 50))
+        
+        # Parrilla/asado
+        if game_state.get('day_time') == 'tarde':
+            asado_x, asado_y = 700, 500
+            draw.rectangle([asado_x, asado_y, asado_x+60, asado_y+30], 
+                          fill=(50, 50, 50), outline=(100, 100, 100))
             
-            # Sombrero gaucho épico
-            hat_tilt = 2 if self.player.facing == "right" else -2
-            draw.ellipse([screen_x-18+hat_tilt, screen_y-45, screen_x+18+hat_tilt, screen_y-35], 
-                        fill=(50, 25, 0), outline=(100, 50, 0), width=2)
-            draw.ellipse([screen_x-30+hat_tilt, screen_y-40, screen_x+30+hat_tilt, screen_y-38], 
-                        fill=(40, 20, 0), outline=(80, 40, 0), width=1)
+            # Humo del asado
+            for i in range(5):
+                smoke_y = asado_y - 20 - i*15
+                smoke_x = asado_x + 30 + random.randint(-10, 10)
+                draw.ellipse([smoke_x-5, smoke_y-5, smoke_x+5, smoke_y+5], 
+                            fill=(200, 200, 200, 100))
+        
+        # Chicos jugando
+        for i in range(3):
+            child_x = 400 + i*50 + random.randint(-20, 20)
+            child_y = 470 + random.randint(-10, 10)
+            draw.ellipse([child_x-5, child_y-10, child_x+5, child_y+5], 
+                        fill=(180, 140, 100), outline=(120, 100, 80))
+        
+        # Pelota de fútbol
+        ball_x = 450 + 20 * math.sin(time.time() * 2)
+        draw.ellipse([ball_x-8, 485, ball_x+8, 501], 
+                    fill=(255, 255, 255), outline=(0, 0, 0), width=2)
+    
+    def draw_survival_ui(self, draw, game_state):
+        """UI de supervivencia argentina"""
+        # Panel principal
+        draw.rectangle([10, 10, 300, 150], fill=(0, 0, 0, 180), outline=(150, 150, 150))
+        
+        # Recursos
+        resources = game_state.get('resources', {})
+        y_offset = 25
+        
+        for resource, value in resources.items():
+            color = self.get_resource_color(resource, value)
             
-            # Mate tecnológico brillante
-            mate_x = screen_x + (12 if self.player.facing == "right" else -12)
-            mate_glow = int(100 + 50 * math.sin(time.time() * 4))
-            draw.ellipse([mate_x-6, screen_y-10, mate_x+6, screen_y+2], 
-                        fill=(150, 75, 0), outline=(255, mate_glow, 0), width=2)
+            # Barra de recurso
+            draw.rectangle([20, y_offset, 200, y_offset+15], fill=(50, 50, 50))
+            bar_width = int((value / 100) * 180)
+            draw.rectangle([20, y_offset, 20 + bar_width, y_offset+15], fill=color)
             
-            # Bombilla láser
-            laser_intensity = int(255 * (0.7 + 0.3 * math.sin(time.time() * 8)))
-            draw.line([(mate_x, screen_y-10), (mate_x, screen_y-18)], 
-                     fill=(0, laser_intensity, 0), width=3)
+            # Texto del recurso
+            resource_names = {
+                'pesos': '💰 Pesos', 'dolares': '💵 Dólares', 'comida': '🍖 Comida',
+                'esperanza': '💪 Esperanza', 'solidaridad': '🤝 Solidaridad', 'trabajo': '🔨 Trabajo'
+            }
+            # draw.text([210, y_offset], f"{resource_names.get(resource, resource)}: {value}", fill=(255, 255, 255))
             
-            # Ojos expresivos
-            eye_offset = 2 if self.player.facing == "right" else -2
-            draw.ellipse([screen_x-8+eye_offset, screen_y-25, screen_x-3+eye_offset, screen_y-20], 
-                        fill=(255, 255, 255))
-            draw.ellipse([screen_x+3+eye_offset, screen_y-25, screen_x+8+eye_offset, screen_y-20], 
-                        fill=(255, 255, 255))
-            draw.ellipse([screen_x-6+eye_offset, screen_y-23, screen_x-5+eye_offset, screen_y-22], 
-                        fill=(0, 0, 0))
-            draw.ellipse([screen_x+5+eye_offset, screen_y-23, screen_x+6+eye_offset, screen_y-22], 
-                        fill=(0, 0, 0))
-    
-    def _draw_crystals(self, draw):
-        """Cristales con efectos mágicos"""
-        for crystal in self.crystals:
-            if not crystal['collected']:
-                screen_x = int(crystal['position'].x - self.scroll_x)
-                screen_y = int(crystal['position'].y + 10 * math.sin(time.time() * 2 + crystal['floating_offset']))
-                
-                if -50 <= screen_x <= self.width + 50:
-                    # Aura brillante
-                    aura_size = 25 + 8 * math.sin(time.time() * 3 + crystal['pulse'])
-                    for i in range(3):
-                        alpha = 50 - i * 15
-                        draw.ellipse([screen_x-aura_size+i*5, screen_y-aura_size+i*5, 
-                                    screen_x+aura_size-i*5, screen_y+aura_size-i*5], 
-                                   outline=crystal['color'])
-                    
-                    # Cristal central
-                    crystal_size = 15 + 5 * math.sin(time.time() * 4 + crystal['pulse'])
-                    draw.polygon([
-                        (screen_x, screen_y-crystal_size),
-                        (screen_x-crystal_size*0.7, screen_y-crystal_size*0.3),
-                        (screen_x-crystal_size*0.7, screen_y+crystal_size*0.3),
-                        (screen_x, screen_y+crystal_size),
-                        (screen_x+crystal_size*0.7, screen_y+crystal_size*0.3),
-                        (screen_x+crystal_size*0.7, screen_y-crystal_size*0.3)
-                    ], fill=crystal['color'], outline=(255, 255, 255), width=2)
-    
-    def _draw_enemies(self, draw):
-        """Enemigos algorítmicos con IA visual"""
-        for enemy in self.enemies:
-            if enemy['health'] > 0:
-                screen_x = int(enemy['position'].x - self.scroll_x)
-                screen_y = int(enemy['position'].y)
-                
-                if -50 <= screen_x <= self.width + 50:
-                    # Forma algorítmica hostil
-                    if enemy['type'] == 'homogenizer':
-                        # Cubo gris hostil
-                        draw.rectangle([screen_x-15, screen_y-15, screen_x+15, screen_y+15], 
-                                     fill=(80, 80, 80), outline=(120, 120, 120), width=2)
-                        # Patrón de homogenización
-                        for i in range(-10, 15, 5):
-                            draw.line([(screen_x+i, screen_y-15), (screen_x+i, screen_y+15)], 
-                                     fill=(150, 150, 150), width=1)
-                    
-                    elif enemy['type'] == 'cultural_eraser':
-                        # Forma que "borra" la cultura
-                        draw.polygon([
-                            (screen_x, screen_y-20),
-                            (screen_x-15, screen_y),
-                            (screen_x, screen_y+20),
-                            (screen_x+15, screen_y)
-                        ], fill=(100, 50, 50), outline=(150, 100, 100), width=2)
-                    
-                    # Barras de vida
-                    health_width = (enemy['health'] / 3) * 30
-                    draw.rectangle([screen_x-15, screen_y-25, screen_x+15, screen_y-22], 
-                                 fill=(50, 50, 50))
-                    draw.rectangle([screen_x-15, screen_y-25, screen_x-15+health_width, screen_y-22], 
-                                 fill=(255, 100, 100))
-    
-    def _draw_particles(self, draw):
-        """Sistema de partículas dinámico"""
-        for particle in self.particles:
-            if particle['lifetime'] > 0:
-                screen_x = int(particle['position'].x - self.scroll_x)
-                screen_y = int(particle['position'].y)
-                
-                if 0 <= screen_x <= self.width and 0 <= screen_y <= self.height:
-                    alpha = int(255 * (particle['lifetime'] / 1.5))
-                    size = max(1, int(3 * particle['lifetime']))
-                    draw.ellipse([screen_x-size, screen_y-size, screen_x+size, screen_y+size], 
-                               fill=particle['color'])
+            y_offset += 20
+        
+        # Indicador de crisis
+        crisis_intensity = game_state.get('crisis_level', 1)
+        crisis_color = (255, 255 - crisis_intensity * 50, 255 - crisis_intensity * 50)
+        draw.rectangle([320, 10, 500, 40], fill=crisis_color, outline=(255, 255, 255))
+        
+        # Día y situación
+        day = game_state.get('day', 1)
+        draw.rectangle([320, 50, 500, 80], fill=(20, 20, 20), outline=(100, 100, 100))
     
-    def _draw_ui(self, draw):
-        """Interfaz épica superpuesta"""
-        # Barra de poder cultural
-        draw.rectangle([20, 20, 220, 40], fill=(50, 50, 50), outline=(150, 150, 150), width=2)
-        cultural_width = int((self.cultural_power / 100) * 200)
-        draw.rectangle([20, 20, 20 + cultural_width, 40], fill=(0, 200, 100))
-        
-        # Combo meter
-        if self.combo_meter > 0:
-            combo_height = min(100, self.combo_meter * 2)
-            draw.rectangle([self.width - 50, self.height - 120, self.width - 30, self.height - 20], 
-                         fill=(50, 50, 50), outline=(200, 200, 200), width=2)
-            draw.rectangle([self.width - 50, self.height - 20 - combo_height, 
-                          self.width - 30, self.height - 20], fill=(255, 200, 0))
+    def get_resource_color(self, resource, value):
+        """Colores dinámicos según el estado del recurso"""
+        if value > 70:
+            return (100, 255, 100)  # Verde
+        elif value > 30:
+            return (255, 255, 100)  # Amarillo
+        else:
+            return (255, 100, 100)  # Rojo
 
-class GauchoCosmicGame:
+class CrisisYCorajeGame:
     def __init__(self):
-        self.engine = EpicGameEngine()
-        self.last_action = "none"
-        self.game_stats = {
-            'crystals_collected': 0,
-            'enemies_defeated': 0,
-            'cultural_combos': 0,
-            'epic_level': 'MÁXIMO'
+        self.engine = ArgentinaGameEngine()
+        self.renderer = GameRenderer()
+        self.crisis_manager = CrisisManager()
+        self.neighborhood_system = NeighborhoodSystem()
+        
+        # Estado del juego
+        self.game_state = {
+            'resources': self.engine.resources.copy(),
+            'day': 1,
+            'current_neighborhood': 'villa_31',
+            'crisis_level': 1,
+            'location': 'villa_31',
+            'day_time': 'mañana'
         }
+        
+        # Eventos dinámicos
+        self.active_events = []
+        self.decisions_made = []
     
-    def process_input(self, action):
-        """Procesa input del jugador"""
-        self.last_action = action
-        self.engine.update_game(action)
-        self._update_stats()
-        return self.engine.render_epic_frame(), self.get_status()
+    def process_action(self, action):
+        """Procesa las acciones del jugador con consecuencias reales"""
+        if action == "trabajar":
+            return self.work_day()
+        elif action == "ayudar_vecinos":
+            return self.help_neighbors()
+        elif action == "buscar_rebusque":
+            return self.find_rebusque()
+        elif action == "organizar_comunitario":
+            return self.organize_community()
+        elif action == "ahorrar_dolares":
+            return self.save_dollars()
+        elif action == "hacer_asado":
+            return self.make_asado()
+        
+        return self.advance_day()
     
-    def _update_stats(self):
-        """Actualiza estadísticas del juego"""
-        self.game_stats['crystals_collected'] = sum(
-            1 for crystal in self.engine.crystals if crystal['collected']
-        )
-        self.game_stats['cultural_combos'] = self.engine.combo_meter // 10
+    def work_day(self):
+        """Simula un día de trabajo con variables argentinas"""
+        profession = self.engine.player.profession
+        base_income = {
+            'albañil': random.randint(2000, 4000),
+            'docente': random.randint(1500, 2500),
+            'comerciante': random.randint(1000, 8000),
+            'empleado_publico': random.randint(1800, 2200)
+        }
+        
+        income = base_income.get(profession, 2000)
+        
+        # Efectos de la inflación
+        real_income = income / self.engine.inflation_rate
+        
+        self.game_state['resources']['pesos'] += real_income
+        self.game_state['resources']['trabajo'] = min(100, self.game_state['resources']['trabajo'] + 10)
+        
+        # Stress por la crisis
+        if self.game_state['crisis_level'] > 3:
+            self.engine.player.stress_level += 5
+            self.game_state['resources']['esperanza'] -= 5
+        
+        return self.advance_day(), f"Trabajaste como {profession}. Ganaste ${real_income:.0f} pesos (inflación: {self.engine.inflation_rate:.1f}x)"
+    
+    def help_neighbors(self):
+        """Ayudar a los vecinos - mecánica clave argentina"""
+        solidarity_gain = random.randint(10, 20)
+        self.game_state['resources']['solidaridad'] += solidarity_gain
+        self.game_state['resources']['esperanza'] += 5
+        
+        # Costo en recursos pero ganancia en red social
+        self.game_state['resources']['comida'] -= 10
+        self.game_state['resources']['pesos'] -= 200
+        
+        # Chance de reciprocidad
+        if random.random() < 0.3:
+            favor_returned = random.choice([
+                "Te devolvieron un favor con trabajo",
+                "Te invitaron a un asado",
+                "Te prestaron herramientas",
+                "Te cuidaron a los chicos"
+            ])
+            self.game_state['resources']['trabajo'] += 15
+            return self.advance_day(), f"Ayudaste a tus vecinos. {favor_returned}."
+        
+        return self.advance_day(), f"Ayudaste a tus vecinos. Ganaste {solidarity_gain} puntos de solidaridad."
+    
+    def find_rebusque(self):
+        """Rebusque - supervivencia argentina pura"""
+        rebusque_skill = self.engine.player.skills['rebusque']
+        success_chance = rebusque_skill / 100
+        
+        if random.random() < success_chance:
+            rebusque_options = [
+                "Vendiste empanadas caseras",
+                "Arreglaste celulares",
+                "Hiciste changas de albañilería", 
+                "Vendiste en la feria",
+                "Diste clases particulares"
+            ]
+            
+            chosen_rebusque = random.choice(rebusque_options)
+            income = random.randint(500, 2000)
+            self.game_state['resources']['pesos'] += income
+            self.engine.player.skills['rebusque'] += 2
+            
+            return self.advance_day(), f"{chosen_rebusque}. Ganaste ${income} pesos!"
+        else:
+            self.game_state['resources']['esperanza'] -= 10
+            return self.advance_day(), "El rebusque no funcionó hoy. Seguí intentando."
+    
+    def make_asado(self):
+        """Hacer asado - tradición argentina que mejora la moral"""
+        if self.game_state['resources']['pesos'] >= 1500:
+            self.game_state['resources']['pesos'] -= 1500
+            self.game_state['resources']['solidaridad'] += 25
+            self.game_state['resources']['esperanza'] += 20
+            
+            # Bonus de comunidad
+            self.engine.player.community_reputation += 10
+            
+            return self.advance_day(), "Hiciste un asado bárbaro. Todo el barrio vino, mejoró la moral general!"
+        else:
+            return self.advance_day(), "No tenés suficiente plata para el asado. Seguí juntando."
     
-    def get_status(self):
-        """Estado épico del juego"""
+    def advance_day(self):
+        """Avanza el día con eventos dinámicos"""
+        self.game_state['day'] += 1
+        
+        # Inflación diaria
+        self.engine.inflation_rate += random.uniform(0.01, 0.05)
+        
+        # Consumo diario
+        daily_costs = {
+            'comida': random.randint(5, 15),
+            'pesos': random.randint(100, 500)
+        }
+        
+        for resource, cost in daily_costs.items():
+            self.game_state['resources'][resource] -= cost
+            self.game_state['resources'][resource] = max(0, self.game_state['resources'][resource])
+        
+        # Eventos random
+        if random.random() < 0.2:
+            self.trigger_random_event()
+        
+        # Cambio de estación
+        if self.game_state['day'] % 90 == 0:
+            self.change_season()
+        
+        return self.renderer.render_argentina_frame(self.game_state)
+    
+    def trigger_random_event(self):
+        """Eventos aleatorios argentinos"""
+        events = [
+            "Piquete en 9 de Julio - no pudiste trabajar",
+            "Encontraste $500 en el subte",
+            "El almacenero te fió hasta fin de mes",
+            "Ganaste en la quiniela",
+            "Se rompió el colectivo - llegaste tarde",
+            "Apareció laburo extra en el barrio"
+        ]
+        
+        event = random.choice(events)
+        self.active_events.append(event)
+        
+        # Aplicar efectos del evento
+        if "Piquete" in event:
+            self.game_state['resources']['trabajo'] -= 20
+        elif "Encontraste $500" in event:
+            self.game_state['resources']['pesos'] += 500
+        elif "quiniela" in event:
+            self.game_state['resources']['pesos'] += random.randint(1000, 5000)
+            self.game_state['resources']['esperanza'] += 30
+    
+    def get_game_status(self):
+        """Estado completo del juego"""
         return {
-            "🗺️ Posición": f"X: {self.engine.player.position.x:.0f}",
-            "⚡ Velocidad": f"{abs(self.engine.player.velocity.x):.1f} km/h",
-            "💎 Cristales": f"{self.game_stats['crystals_collected']}/5",
-            "🔥 Poder Cultural": f"{self.engine.cultural_power:.0f}%",
-            "🎯 Combos": self.game_stats['cultural_combos'],
-            "🚀 Épica": self.game_stats['epic_level']
+            "📅 Día": self.game_state['day'],
+            "🏠 Barrio": self.game_state['current_neighborhood'].replace('_', ' ').title(),
+            "💰 Pesos": f"${self.game_state['resources']['pesos']:.0f}",
+            "💵 Dólares": f"US${self.game_state['resources']['dolares']:.0f}",
+            "🍖 Comida": f"{self.game_state['resources']['comida']:.0f}%",
+            "💪 Esperanza": f"{self.game_state['resources']['esperanza']:.0f}%",
+            "🤝 Solidaridad": f"{self.game_state['resources']['solidaridad']:.0f}%",
+            "📈 Inflación": f"{self.engine.inflation_rate:.2f}x",
+            "🎯 Crisis": f"Nivel {self.game_state['crisis_level']}/5"
         }
 
-def create_ultimate_interface():
-    game = GauchoCosmicGame()
+def create_revolutionary_interface():
+    game = CrisisYCorajeGame()
     
     with gr.Blocks(
-        title="🎮 EL GAUCHO CÓSMICO - ULTIMATE EDITION 🇦🇷",
-        theme=gr.themes.Glass()
+        title="🇦🇷 CRISIS Y CORAJE - El Juego Argentino Definitivo",
+        theme=gr.themes.Soft()
     ) as interface:
         
         gr.HTML("""
-        <div style="text-align: center; background: linear-gradient(45deg, #FF6B6B, #4ECDC4); 
-                    color: white; padding: 20px; border-radius: 10px; margin: 10px;">
-            <h1 style="font-size: 3em; margin: 0; text-shadow: 2px 2px 4px rgba(0,0,0,0.5);">
-                🌟 EL GAUCHO CÓSMICO 🌟
+        <div style="background: linear-gradient(135deg, #74b9ff, #0984e3, #fdcb6e); 
+                    padding: 25px; text-align: center; border-radius: 15px; margin: 15px;">
+            <h1 style="color: white; font-size: 3em; text-shadow: 2px 2px 4px rgba(0,0,0,0.7); margin: 0;">
+                🇦🇷 CRISIS Y CORAJE
             </h1>
-            <p style="font-size: 1.2em; margin: 10px 0;">
-                AVENTURA SIDE-SCROLLING DE IDENTIDAD CULTURAL ARGENTINA
+            <h2 style="color: #ffffff; font-size: 1.3em; margin: 10px 0;">
+                Supervivencia, Solidaridad y Cultura en la Argentina Real
+            </h2>
+            <p style="color: #f1f2f6; font-size: 1.1em; margin: 5px 0;">
+                Navegá las crisis económicas mientras preservás lo que nos hace argentinos
             </p>
         </div>
         """)
         
         with gr.Row():
-            with gr.Column(scale=3):
+            with gr.Column(scale=2):
                 game_display = gr.Image(
-                    label="🌌 PAMPA CÓSMICA ÉPICA",
-                    interactive=False,
-                    width=800,
+                    label="🌆 Tu Barrio en Argentina",
+                    width=900,
                     height=600
                 )
                 
-                gr.Markdown("### 🎮 CONTROLES ÉPICOS")
+                gr.Markdown("### 🎮 ACCIONES ARGENTINAS")
                 with gr.Row():
-                    left_btn = gr.Button("⬅️ IZQUIERDA", variant="primary")
-                    right_btn = gr.Button("➡️ DERECHA", variant="primary")
-                    jump_btn = gr.Button("⬆️ SALTAR", variant="secondary")
-                    
+                    work_btn = gr.Button("💼 TRABAJAR", variant="primary", size="lg")
+                    help_btn = gr.Button("🤝 AYUDAR VECINOS", variant="secondary", size="lg")
+                    rebusque_btn = gr.Button("💡 REBUSQUE", variant="stop", size="lg")
+                
                 with gr.Row():
-                    attack_btn = gr.Button("🪃 BOLEADORAS", variant="stop")
-                    special_btn = gr.Button("🧉 MATE POWER", variant="stop")
+                    organize_btn = gr.Button("📢 ORGANIZAR", variant="secondary", size="lg")
+                    save_btn = gr.Button("💵 AHORRAR", variant="primary", size="lg")
+                    asado_btn = gr.Button("🔥 HACER ASADO", variant="stop", size="lg")
             
             with gr.Column(scale=1):
-                gr.Markdown("### 📊 ESTADO ÉPICO")
+                gr.Markdown("### 📊 ESTADO DE SUPERVIVENCIA")
                 status_display = gr.JSON(
-                    label="🎯 MÉTRICAS DE MARTÍN 'EL MATE'",
-                    value=game.get_status()
+                    label="🎯 Tu Situación",
+                    value=game.get_game_status()
                 )
                 
-                gr.Markdown("### 🎵 SOUNDTRACK")
+                gr.Markdown("### 📰 ÚLTIMAS NOTICIAS")
+                news_display = gr.Textbox(
+                    value="Bienvenido a tu barrio. La crisis está, pero la solidaridad también. ¿Cómo vas a sobrevivir hoy?",
+                    label="📺 Canal de Noticias",
+                    lines=4,
+                    interactive=False
+                )
+                
+                gr.Markdown("### 🎯 TUTORIAL RÁPIDO")
                 gr.HTML("""
-                <div style="background: #2C3E50; padding: 15px; border-radius: 8px; color: white;">
-                    <p>🎼 <strong>Ahora sonando:</strong></p>
-                    <p style="font-style: italic;">"Pampa Cósmica - Tema Principal"</p>
-                    <p>🎸 Género: Folklectrónica Argentina</p>
+                <div style="background: #2d3436; color: white; padding: 15px; border-radius: 10px;">
+                    <p><strong>🎮 Cómo Jugar:</strong></p>
+                    <ul style="margin: 10px 0; padding-left: 20px;">
+                        <li>💼 <strong>Trabajá</strong> para ganar pesos</li>
+                        <li>🤝 <strong>Ayudá</strong> para aumentar solidaridad</li>
+                        <li>💡 <strong>Rebuscátelas</strong> en crisis</li>
+                        <li>🔥 <strong>Hacé asados</strong> para la moral</li>
+                        <li>💵 <strong>Ahorrá dólares</strong> contra inflación</li>
+                    </ul>
+                    <p><em>¡Sobreviví con creatividad argentina!</em></p>
                 </div>
                 """)
-                
-                gr.Markdown("### 💬 DIÁLOGOS ÉPICOS")
-                dialogue_box = gr.Textbox(
-                    value="¡Che! ¿Viste esos algoritmos tratando de borrar nuestra cultura? ¡Ni en pedo se la llevo!",
-                    label="🗨️ Martín 'El Mate' habla",
-                    interactive=False,
-                    max_lines=3
-                )
         
-        # Conectar controles
-        left_btn.click(fn=lambda: game.process_input("left"), outputs=[game_display, status_display])
-        right_btn.click(fn=lambda: game.process_input("right"), outputs=[game_display, status_display])
-        jump_btn.click(fn=lambda: game.process_input("jump"), outputs=[game_display, status_display])
-        attack_btn.click(fn=lambda: game.process_input("attack"), outputs=[game_display, status_display])
-        special_btn.click(fn=lambda: game.process_input("special"), outputs=[game_display, status_display])
+        # Conectar acciones
+        def handle_action(action_name):
+            frame, message = game.process_action(action_name)
+            status = game.get_game_status()
+            return frame, status, message
+        
+        work_btn.click(fn=lambda: handle_action("trabajar"), 
+                      outputs=[game_display, status_display, news_display])
+        help_btn.click(fn=lambda: handle_action("ayudar_vecinos"), 
+                      outputs=[game_display, status_display, news_display])
+        rebusque_btn.click(fn=lambda: handle_action("buscar_rebusque"), 
+                          outputs=[game_display, status_display, news_display])
+        organize_btn.click(fn=lambda: handle_action("organizar_comunitario"), 
+                          outputs=[game_display, status_display, news_display])
+        save_btn.click(fn=lambda: handle_action("ahorrar_dolares"), 
+                      outputs=[game_display, status_display, news_display])
+        asado_btn.click(fn=lambda: handle_action("hacer_asado"), 
+                       outputs=[game_display, status_display, news_display])
         
         # Inicialización
         interface.load(
-            fn=lambda: (game.engine.render_epic_frame(), game.get_status()),
-            outputs=[game_display, status_display]
+            fn=lambda: (game.renderer.render_argentina_frame(game.game_state), 
+                       game.get_game_status(),
+                       "¡Arrancó el juego! Tomate tu tiempo para pensar cada decisión."),
+            outputs=[game_display, status_display, news_display]
         )
     
     return interface
 
 if __name__ == "__main__":
-    interface = create_ultimate_interface()
+    interface = create_revolutionary_interface()
     interface.launch(share=True, show_error=True)