Update app.py

app.py

@@ -1,301 +1,507 @@
-# app.py - VERSIÓN ÉPICA SIN ERRORES DE NUMPY
+# app.py - EL GAUCHO CÓSMICO ÉPICO VERSION 2.0
 import gradio as gr
 import time
 import math
-from PIL import Image, ImageDraw
 import random
+from PIL import Image, ImageDraw, ImageFont
 from game_engine import GauchoCharacter, PhysicsEngine, WorldGenerator, Vector2D
 
-class EpicGauchoRenderer:
-    """Renderer épico para un gaucho que se respete"""
+class EpicGameEngine:
     def __init__(self):
-        self.particle_systems = []
-        self.background_stars = self._generate_stars(200)
-        self.world_tiles = self._create_epic_tiles()
-    
-    def _generate_stars(self, count):
-        """Genera estrellas sin usar numpy.choice con tuplas"""
-        star_colors = [(255, 255, 255), (200, 200, 255), (255, 255, 200), (255, 200, 255)]
-        return [(
-            random.randint(0, 800),
-            random.randint(0, 600),
-            random.choice([1, 2, 3]),
-            random.choice(star_colors)  # Usamos random de Python, no numpy
-        ) for _ in range(count)]
-    
-    def _create_epic_tiles(self):
-        """Crea texturas épicas para cada tipo de terreno"""
-        tiles = {}
+        self.width = 800
+        self.height = 600
+        self.player = GauchoCharacter()
+        self.player.position = Vector2D(100, 400)
+        self.physics = PhysicsEngine()
         
-        # Pampa cósmica con gradientes épicos
-        pampa_base = Image.new('RGB', (100, 100), (20, 40, 80))
-        draw = ImageDraw.Draw(pampa_base)
+        # Sistema de juego épico
+        self.scroll_x = 0
+        self.enemies = []
+        self.projectiles = []
+        self.crystals = []
+        self.particles = []
+        self.combo_meter = 0
+        self.cultural_power = 100
         
-        # Crear patrón de campo energético
-        for i in range(0, 100, 20):
-            for j in range(0, 100, 20):
-                intensity = int(50 * math.sin(i/10) * math.cos(j/10)) + 100
-                color = (20, 40 + intensity//3, 80 + intensity//2)
-                draw.rectangle([i, j, i+18, j+18], fill=color, outline=(0, 255, 150), width=1)
+        # Estados de juego
+        self.game_state = "playing"  # playing, dialogue, victory
+        self.current_level = 1
+        self.boss_fight = False
         
-        tiles['pampa'] = pampa_base
-        return tiles
+        # 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 draw_epic_gaucho(self, draw, x, y, velocity):
-        """Dibuja al gaucho con toda la épica que se merece"""
-        # Estela de movimiento
-        trail_length = min(30, abs(velocity.x) + abs(velocity.y))
-        if trail_length > 5:
-            trail_x = int(x - velocity.x * 3)
-            trail_y = int(y - velocity.y * 3)
-            draw.ellipse([trail_x-10, trail_y-10, trail_x+10, trail_y+10], 
-                        fill=(100, 200, 255))
+    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)]
         
-        # Cuerpo del gaucho (más épico)
-        x, y = int(x), int(y)
-        draw.ellipse([x-25, y-25, x+25, y+25], 
-                    fill=(139, 69, 19), outline=(101, 67, 33), width=3)
+        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
         
-        # Poncho tecnológico
-        poncho_points = [
-            (x-30, y-10), (x-20, y-35), (x+20, y-35), (x+30, y-10),
-            (x+25, y+15), (x-25, y+15)
-        ]
-        draw.polygon(poncho_points, fill=(0, 100, 200), outline=(0, 150, 255), width=2)
+        # Actualizar jugador
+        self._update_player(action, dt)
         
-        # Patrón del poncho
-        for i in range(-20, 25, 10):
-            draw.line([(x+i, y-30), (x+i, y+10)], fill=(255, 255, 100), width=2)
+        # Actualizar mundo
+        self._update_scroll()
+        self._update_enemies(dt)
+        self._update_projectiles(dt)
+        self._update_particles(dt)
+        self._check_collisions()
         
-        # Sombrero gaucho épico
-        draw.ellipse([x-20, y-35, x+20, y-25], fill=(50, 25, 0), outline=(80, 40, 0), width=3)
-        draw.ellipse([x-35, y-30, x+35, y-28], fill=(40, 20, 0), outline=(60, 30, 0), width=2)
+        # 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
         
-        # Mate tecnológico
-        mate_x, mate_y = x + 15, y - 5
-        draw.ellipse([mate_x-8, mate_y-8, mate_x+8, mate_y+8], 
-                    fill=(150, 75, 0), outline=(255, 200, 0), width=2)
-        # Bombilla láser
-        draw.line([(mate_x, mate_y-8), (mate_x, mate_y-15)], fill=(0, 255, 0), width=3)
+        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()
         
-        # Ojos determinados
-        draw.ellipse([x-8, y-8, x-3, y-3], fill=(255, 255, 255))
-        draw.ellipse([x+3, y-8, x+8, y-3], fill=(255, 255, 255))
-        draw.ellipse([x-6, y-6, x-5, y-5], fill=(0, 0, 0))
-        draw.ellipse([x+5, y-6, x+6, y-5], fill=(0, 0, 0))
-
-class CosmicGauchoEpic:
-    def __init__(self):
-        self.player = GauchoCharacter()
-        self.player.position = Vector2D(400, 300)  # Centro de la pantalla
-        self.physics = PhysicsEngine()
-        self.renderer = EpicGauchoRenderer()
-        self.camera_offset = Vector2D(0, 0)
-        self.crystals = self._spawn_crystals()
-        self.enemies = []
-        self.particles = []
-        self.game_time = 0
+        # Aplicar física fluida
+        self.player.velocity = self.physics.apply_momentum(
+            self.player.velocity, acceleration, dt
+        )
         
-    def _spawn_crystals(self):
-        """Genera cristales de valores argentinos"""
-        crystal_types = ['Solidaridad', 'Familia', 'Amistad', 'Respeto', 'Creatividad']
-        crystals = []
-        for i, crystal_type in enumerate(crystal_types):
-            crystals.append({
-                'type': crystal_type,
-                'position': Vector2D(200 + i * 150, 200 + (i % 2) * 200),
-                'collected': False,
-                'pulse': i * math.pi / 3  # Desfase para que no pulsen todos juntos
+        # Movimiento suave
+        self.player.position += self.player.velocity * dt * 60
+        
+        # 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': []
             })
-        return crystals
+            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)
     
-    def update_game_state(self, movement: str = "none"):
-        self.game_time += 0.1
+    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 _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)
+        }
+        return colors.get(particle_type, (255, 255, 255))
+    
+    def render_epic_frame(self) -> Image.Image:
+        """Renderizado épico con múltiples capas"""
+        img = Image.new('RGB', (self.width, self.height), (10, 15, 35))
+        draw = ImageDraw.Draw(img)
         
-        acceleration = Vector2D(0, 0)
-        speed = 4.0
+        # Capa 1: Fondo estrellado con parallax
+        self._draw_starfield(draw)
         
-        if movement == "left":
-            acceleration.x = -speed
-        elif movement == "right":
-            acceleration.x = speed
-        elif movement == "up":
-            acceleration.y = -speed * 0.8  # Gravedad simulada
-        elif movement == "down":
-            acceleration.y = speed
+        # Capa 2: Montañas distantes
+        self._draw_mountains(draw)
         
-        # Momentum más fluido
-        self.player.velocity = self.player.velocity * 0.95  # Fricción
-        self.player.velocity = self.physics.apply_momentum(
-            self.player.velocity, acceleration, dt=0.1
-        )
+        # Capa 3: Terreno principal
+        self._draw_terrain(draw)
+        
+        # Capa 4: Cristales con efectos
+        self._draw_crystals(draw)
         
-        self.player.position += self.player.velocity * 0.1
+        # Capa 5: Enemigos animados
+        self._draw_enemies(draw)
         
-        # Límites del mundo expandido
-        self.player.position.x = max(50, min(self.player.position.x, 1500))
-        self.player.position.y = max(50, min(self.player.position.y, 1200))
+        # Capa 6: Proyectiles con trails
+        self._draw_projectiles(draw)
         
-        # Cámara que sigue al jugador
-        self.camera_offset.x = self.player.position.x - 400
-        self.camera_offset.y = self.player.position.y - 300
+        # Capa 7: Gaucho protagonista
+        self._draw_epic_gaucho(draw)
         
-        # Recolectar cristales
-        self._check_crystal_collection()
+        # Capa 8: Partículas
+        self._draw_particles(draw)
+        
+        # Capa 9: UI épica
+        self._draw_ui(draw)
+        
+        return img
     
-    def _check_crystal_collection(self):
-        for crystal in self.crystals:
-            if not crystal['collected']:
-                distance = ((self.player.position.x - crystal['position'].x) ** 2 + 
-                           (self.player.position.y - crystal['position'].y) ** 2) ** 0.5
-                if distance < 40:
-                    crystal['collected'] = True
-                    self.player.inventory['cristales'][crystal['type']] = True
+    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))
     
-    def render_epic_frame(self) -> Image.Image:
-        img = Image.new('RGB', (800, 600), (5, 5, 20))
-        draw = ImageDraw.Draw(img)
+    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_terrain(self, draw):
+        """Terreno orgánico y fluido"""
+        terrain_points = [(0, self.height)]
         
-        # Fondo estrellado épico
-        for star_x, star_y, size, color in self.renderer.background_stars:
-            # Parallax scrolling
-            scroll_x = int(star_x - self.camera_offset.x * 0.3)
-            scroll_y = int(star_y - self.camera_offset.y * 0.3)
-            if 0 <= scroll_x <= 800 and 0 <= scroll_y <= 600:
-                draw.ellipse([scroll_x-size, scroll_y-size, scroll_x+size, scroll_y+size], fill=color)
+        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))
         
-        # Grid energético de la pampa cósmica
-        grid_size = 100
-        for x in range(-200, 1000, grid_size):
-            for y in range(-200, 800, grid_size):
-                screen_x = int(x - self.camera_offset.x)
-                screen_y = int(y - self.camera_offset.y)
-                if -100 <= screen_x <= 900 and -100 <= screen_y <= 700:
-                    # Campo energético
-                    alpha = int(50 + 30 * math.sin(self.game_time + x/100))
-                    color = (0, 50 + alpha//2, 100 + alpha)
-                    draw.rectangle([screen_x, screen_y, screen_x+90, screen_y+90], 
-                                 fill=color, outline=(0, 150, 255), width=1)
+        terrain_points.append((self.width, self.height))
+        draw.polygon(terrain_points, fill=(20, 60, 40), outline=(40, 120, 80))
+    
+    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)
         
-        # Cristales épicos
+        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)
+            
+            # 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)
+            
+            # 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)
+            
+            # 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)
+            
+            # 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)
+            
+            # 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)
+            
+            # 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']:
-                crystal_x = int(crystal['position'].x - self.camera_offset.x)
-                crystal_y = int(crystal['position'].y - self.camera_offset.y)
+                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 0 <= crystal_x <= 800 and 0 <= crystal_y <= 600:
-                    # Efecto de pulso
-                    pulse = math.sin(self.game_time * 3 + crystal['pulse']) * 10
-                    size = int(20 + pulse)
+                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'])
                     
-                    # Aura del cristal
-                    draw.ellipse([crystal_x-size-5, crystal_y-size-5, 
-                                crystal_x+size+5, crystal_y+size+5], 
-                               fill=(100, 100, 100))
+                    # 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)
                     
-                    # Cristal
-                    crystal_colors = {
-                        'Solidaridad': (255, 100, 100),
-                        'Familia': (100, 255, 100),
-                        'Amistad': (100, 100, 255),
-                        'Respeto': (255, 255, 100),
-                        'Creatividad': (255, 100, 255)
-                    }
-                    crystal_color = crystal_colors.get(crystal['type'], (255, 255, 255))
+                    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)
                     
-                    draw.polygon([
-                        (crystal_x, crystal_y-size),
-                        (crystal_x-int(size*0.7), crystal_y),
-                        (crystal_x, crystal_y+size),
-                        (crystal_x+int(size*0.7), crystal_y)
-                    ], fill=crystal_color, outline=(255, 255, 255), width=2)
-        
-        # Gaucho épico (siempre centrado)
-        player_screen_x = 400
-        player_screen_y = 300
-        self.renderer.draw_epic_gaucho(draw, player_screen_x, player_screen_y, self.player.velocity)
+                    # 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'])
+    
+    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))
         
-        return img
+        # 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))
+
+class GauchoCosmicGame:
+    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'
+        }
+    
+    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 get_epic_status(self):
-        cristales_obtenidos = sum(self.player.inventory['cristales'].values())
+    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 get_status(self):
+        """Estado épico del juego"""
         return {
-            "🗺️ Coordenadas": f"({self.player.position.x:.0f}, {self.player.position.y:.0f})",
-            "⚡ Momentum": f"({self.player.velocity.x:.1f}, {self.player.velocity.y:.1f})",
-            "💎 Cristales": f"{cristales_obtenidos}/5",
-            "🎯 Misión": "Recuperar la identidad argentina" if cristales_obtenidos < 5 else "¡MISIÓN CUMPLIDA!",
-            "🔥 Épica": "MÁXIMA"
+            "🗺️ 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']
         }
 
-def create_epic_interface():
-    game = CosmicGauchoEpic()
+def create_ultimate_interface():
+    game = GauchoCosmicGame()
     
     with gr.Blocks(
-        title="🚀 EL GAUCHO CÓSMICO ÉPICO 🇦🇷",
-        theme=gr.themes.Soft()
+        title="🎮 EL GAUCHO CÓSMICO - ULTIMATE EDITION 🇦🇷",
+        theme=gr.themes.Glass()
     ) as interface:
         
         gr.HTML("""
-        <div style="text-align: center; color: #FFD700; font-size: 2.5em; font-weight: bold; margin: 20px;">
-            🌟 EL GAUCHO CÓSMICO 🌟<br>
-            <span style="font-size: 0.6em; color: #87CEEB;">
-                AVENTURA ÉPICA DE IDENTIDAD CULTURAL ARGENTINA
-            </span>
+        <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 🌟
+            </h1>
+            <p style="font-size: 1.2em; margin: 10px 0;">
+                AVENTURA SIDE-SCROLLING DE IDENTIDAD CULTURAL ARGENTINA
+            </p>
         </div>
         """)
         
         with gr.Row():
-            with gr.Column(scale=2):
+            with gr.Column(scale=3):
                 game_display = gr.Image(
-                    label="🌌 LA PAMPA CÓSMICA ÉPICA",
+                    label="🌌 PAMPA CÓSMICA ÉPICA",
                     interactive=False,
                     width=800,
                     height=600
                 )
                 
+                gr.Markdown("### 🎮 CONTROLES ÉPICOS")
                 with gr.Row():
-                    left_btn = gr.Button("⬅️ IZQUIERDA", variant="primary", size="lg")
-                    up_btn = gr.Button("⬆️ SALTAR", variant="secondary", size="lg") 
-                    down_btn = gr.Button("⬇️ AGACHAR", variant="secondary", size="lg")
-                    right_btn = gr.Button("➡️ DERECHA", variant="primary", size="lg")
+                    left_btn = gr.Button("⬅️ IZQUIERDA", variant="primary")
+                    right_btn = gr.Button("➡️ DERECHA", variant="primary")
+                    jump_btn = gr.Button("⬆️ SALTAR", variant="secondary")
+                    
+                with gr.Row():
+                    attack_btn = gr.Button("🪃 BOLEADORAS", variant="stop")
+                    special_btn = gr.Button("🧉 MATE POWER", variant="stop")
             
             with gr.Column(scale=1):
-                gr.Markdown("### 🎯 ESTADO ÉPICO DEL GAUCHO")
-                status_display = gr.JSON(label="📊 DATOS DE MARTÍN 'EL MATE'")
+                gr.Markdown("### 📊 ESTADO ÉPICO")
+                status_display = gr.JSON(
+                    label="🎯 MÉTRICAS DE MARTÍN 'EL MATE'",
+                    value=game.get_status()
+                )
                 
-                gr.Markdown("### 🗣️ FILOSOFÍA GAUCHA CÓSMICA")
-                wisdom_quotes = [
-                    "¡La tradición no se negocia, che!",
-                    "En esta pampa cósmica, somos resistencia pura",
-                    "Cada cristal recuperado fortalece nuestra alma",
-                    "El mate une dimensiones, hermano",
-                    "¡Vamos a mostrarles qué es ser argentino!"
-                ]
+                gr.Markdown("### 🎵 SOUNDTRACK")
+                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>
+                """)
                 
-                wisdom_display = gr.Textbox(
-                    value=random.choice(wisdom_quotes),
-                    label="💭 Sabiduría del Gaucho",
-                    interactive=False
+                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
                 )
         
-        def epic_move_and_update(direction):
-            game.update_game_state(direction)
-            return game.render_epic_frame(), game.get_epic_status()
-        
-        # Conectar controles épicos
-        left_btn.click(fn=lambda: epic_move_and_update("left"), outputs=[game_display, status_display])
-        right_btn.click(fn=lambda: epic_move_and_update("right"), outputs=[game_display, status_display])
-        up_btn.click(fn=lambda: epic_move_and_update("up"), outputs=[game_display, status_display])
-        down_btn.click(fn=lambda: epic_move_and_update("down"), outputs=[game_display, status_display])
+        # 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])
         
-        # Estado inicial épico
+        # Inicialización
         interface.load(
-            fn=lambda: (game.render_epic_frame(), game.get_epic_status()),
+            fn=lambda: (game.engine.render_epic_frame(), game.get_status()),
             outputs=[game_display, status_display]
         )
     
     return interface
 
 if __name__ == "__main__":
-    interface = create_epic_interface()
-    interface.launch(share=True, show_error=True, debug=True)
+    interface = create_ultimate_interface()
+    interface.launch(share=True, show_error=True)