Update app.py

app.py

@@ -1,163 +1,314 @@
-# app.py - Versión corregida para HuggingFace Spaces
+# app.py - VERSIÓN ÉPICA GAUCHO CÓSMICO
 import gradio as gr
 import time
 import math
-from PIL import Image, ImageDraw
+from PIL import Image, ImageDraw, ImageFont
 import io
+import numpy as np
 from game_engine import GauchoCharacter, PhysicsEngine, WorldGenerator, Vector2D
 
-# Clase base del juego
-class CosmicGauchoGame:
+class EpicGauchoRenderer:
+    """Renderer épico para un gaucho que se respete"""
+    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):
+        return [(
+            np.random.randint(0, 800),
+            np.random.randint(0, 600),
+            np.random.choice([1, 2, 3]),
+            np.random.choice([(255, 255, 255), (200, 200, 255), (255, 255, 200)])
+        ) for _ in range(count)]
+    
+    def _create_epic_tiles(self):
+        """Crea texturas épicas para cada tipo de terreno"""
+        tiles = {}
+        
+        # Pampa cósmica con gradientes épicos
+        pampa_base = Image.new('RGB', (100, 100), (20, 40, 80))
+        draw = ImageDraw.Draw(pampa_base)
+        
+        # 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)
+        
+        tiles['pampa'] = pampa_base
+        return tiles
+    
+    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 = x - velocity.x * 3
+            trail_y = y - velocity.y * 3
+            draw.ellipse([trail_x-10, trail_y-10, trail_x+10, trail_y+10], 
+                        fill=(100, 200, 255, 128))
+        
+        # Cuerpo del gaucho (más épico)
+        draw.ellipse([x-25, y-25, x+25, y+25], 
+                    fill=(139, 69, 19), outline=(101, 67, 33), width=3)
+        
+        # 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)
+        
+        # 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)
+        
+        # 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)
+        
+        # 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)
+        
+        # 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.world = WorldGenerator()
-        self.current_chunk = None
-        self.game_width = 800
-        self.game_height = 600
-        self.load_initial_world()
-    
-    def load_initial_world(self):
-        self.current_chunk = self.world.generate_chunk('pampa', 16)
+        self.renderer = EpicGauchoRenderer()
+        self.camera_offset = Vector2D(0, 0)
+        self.crystals = self._spawn_crystals()
+        self.enemies = []
+        self.particles = []
+        
+    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': 0
+            })
+        return crystals
     
     def update_game_state(self, movement: str = "none"):
-        # Sistema de movimiento simplificado
         acceleration = Vector2D(0, 0)
-        speed = 3.0
+        speed = 4.0
         
         if movement == "left":
             acceleration.x = -speed
         elif movement == "right":
             acceleration.x = speed
         elif movement == "up":
-            acceleration.y = -speed
+            acceleration.y = -speed * 0.8  # Gravedad simulada
         elif movement == "down":
             acceleration.y = speed
-            
+        
+        # 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
+            self.player.velocity, acceleration, dt=0.1
         )
         
-        # Actualizar posición con límites de pantalla
-        new_x = self.player.position.x + self.player.velocity.x
-        new_y = self.player.position.y + self.player.velocity.y
+        self.player.position += self.player.velocity * 0.1
         
-        self.player.position.x = max(50, min(new_x, self.game_width - 50))
-        self.player.position.y = max(50, min(new_y, self.game_height - 50))
+        # 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))
+        
+        # Cámara que sigue al jugador
+        self.camera_offset.x = self.player.position.x - 400
+        self.camera_offset.y = self.player.position.y - 300
+        
+        # Recolectar cristales
+        self._check_crystal_collection()
+    
+    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 render_frame(self) -> Image.Image:
-        # Crear canvas del juego
-        img = Image.new('RGB', (self.game_width, self.game_height), (20, 40, 60))
+    def render_epic_frame(self) -> Image.Image:
+        img = Image.new('RGB', (800, 600), (5, 5, 20))
         draw = ImageDraw.Draw(img)
         
-        # Dibujar fondo de pampa cósmica
-        for i in range(0, self.game_width, 100):
-            for j in range(0, self.game_height, 100):
-                color = (30 + i//10, 50 + j//10, 80)
-                draw.rectangle([i, j, i+90, j+90], fill=color, outline=(100, 150, 200))
+        # Fondo estrellado épico
+        for star_x, star_y, size, color in self.renderer.background_stars:
+            # Parallax scrolling
+            scroll_x = star_x - self.camera_offset.x * 0.3
+            scroll_y = 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)
         
-        # Dibujar al gaucho (círculo simple por ahora)
-        player_x = int(self.player.position.x)
-        player_y = int(self.player.position.y)
-        draw.ellipse([player_x-20, player_y-20, player_x+20, player_y+20], 
-                    fill=(255, 200, 100), outline=(200, 150, 50), width=3)
+        # 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 = x - self.camera_offset.x
+                screen_y = y - self.camera_offset.y
+                if -100 <= screen_x <= 900 and -100 <= screen_y <= 700:
+                    # Campo energético
+                    alpha = int(50 + 30 * math.sin(time.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)
+        
+        # Cristales épicos
+        for crystal in self.crystals:
+            if not crystal['collected']:
+                crystal_x = crystal['position'].x - self.camera_offset.x
+                crystal_y = crystal['position'].y - self.camera_offset.y
+                
+                if 0 <= crystal_x <= 800 and 0 <= crystal_y <= 600:
+                    # Efecto de pulso
+                    pulse = math.sin(time.time() * 3 + crystal['pulse']) * 10
+                    size = 20 + pulse
+                    
+                    # Aura del cristal
+                    draw.ellipse([crystal_x-size-5, crystal_y-size-5, 
+                                crystal_x+size+5, crystal_y+size+5], 
+                               fill=(255, 255, 255, 50))
+                    
+                    # Cristal
+                    crystal_color = {
+                        'Solidaridad': (255, 100, 100),
+                        'Familia': (100, 255, 100),
+                        'Amistad': (100, 100, 255),
+                        'Respeto': (255, 255, 100),
+                        'Creatividad': (255, 100, 255)
+                    }.get(crystal['type'], (255, 255, 255))
+                    
+                    draw.polygon([
+                        (crystal_x, crystal_y-size),
+                        (crystal_x-size*0.7, crystal_y),
+                        (crystal_x, crystal_y+size),
+                        (crystal_x+size*0.7, crystal_y)
+                    ], fill=crystal_color, outline=(255, 255, 255), width=2)
         
-        # Dibujar sombrero gaucho
-        draw.ellipse([player_x-15, player_y-25, player_x+15, player_y-15], 
-                    fill=(100, 50, 0), outline=(80, 40, 0), width=2)
+        # Gaucho épico
+        player_screen_x = 400  # Siempre centrado
+        player_screen_y = 300
+        self.renderer.draw_epic_gaucho(draw, player_screen_x, player_screen_y, self.player.velocity)
         
         return img
-
-# Clase mejorada con optimizaciones
-class EnhancedCosmicGaucho(CosmicGauchoGame):
-    def __init__(self):
-        super().__init__()
-        self.last_frame_time = time.time()
     
-    def get_game_status(self):
+    def get_epic_status(self):
+        cristales_obtenidos = sum(self.player.inventory['cristales'].values())
         return {
-            "position": f"({self.player.position.x:.1f}, {self.player.position.y:.1f})",
-            "velocity": f"({self.player.velocity.x:.1f}, {self.player.velocity.y:.1f})",
-            "cristales": sum(self.player.inventory['cristales'].values()),
-            "habilidades": sum(self.player.abilities.values())
+            "🗺️ 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}/7",
+            "🎯 Misión": "Recuperar la identidad argentina" if cristales_obtenidos < 7 else "¡MISIÓN CUMPLIDA!",
+            "🔥 Épica": "MÁXIMA"
         }
 
-def create_game_interface():
-    game = EnhancedCosmicGaucho()
+def create_epic_interface():
+    game = CosmicGauchoEpic()
+    
+    custom_css = """
+    .epic-title { 
+        background: linear-gradient(45deg, #FF6B6B, #4ECDC4, #45B7D1, #96CEB4, #FFEAA7);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        font-size: 3em !important;
+        font-weight: bold;
+        text-align: center;
+    }
+    .epic-container {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        border-radius: 15px;
+        padding: 20px;
+    }
+    """
     
     with gr.Blocks(
-        title="🎮 El Gaucho Cósmico - Preservando la Identidad Argentina 🇦🇷",
-        theme=gr.themes.Monochrome()
+        title="🚀 EL GAUCHO CÓSMICO ÉPICO 🇦🇷",
+        css=custom_css,
+        theme=gr.themes.Soft()
     ) as interface:
         
-        gr.Markdown("""
-        # 🌟 El Gaucho Cósmico
-        ### Aventura Épica de Identidad Cultural Argentina
-        *Año 2088 - La Pampa Cósmica te necesita, che!*
+        gr.HTML("""
+        <div class="epic-title">
+            🌟 EL GAUCHO CÓSMICO 🌟<br>
+            <span style="font-size: 0.6em; color: #FFD700;">
+                AVENTURA ÉPICA DE IDENTIDAD CULTURAL ARGENTINA
+            </span>
+        </div>
         """)
         
         with gr.Row():
-            with gr.Column(scale=2):
+            with gr.Column(scale=2, elem_classes="epic-container"):
                 game_display = gr.Image(
-                    label="🌌 Pampa Cósmica", 
+                    label="🌌 LA PAMPA CÓSMICA ÉPICA",
                     interactive=False,
                     width=800,
                     height=600
                 )
                 
                 with gr.Row():
-                    left_btn = gr.Button("⬅️ Izquierda", variant="secondary")
-                    up_btn = gr.Button("⬆️ Arriba", variant="secondary") 
-                    down_btn = gr.Button("⬇️ Abajo", variant="secondary")
-                    right_btn = gr.Button("➡️ Derecha", variant="secondary")
+                    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")
             
             with gr.Column(scale=1):
-                gr.Markdown("### 🎯 Estado del Gaucho")
-                status_display = gr.JSON(label="📊 Datos del Personaje")
+                gr.Markdown("### 🎯 ESTADO ÉPICO DEL GAUCHO")
+                status_display = gr.JSON(label="📊 DATOS DE MARTÍN 'EL MATE'", elem_classes="epic-container")
+                
+                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("### 🗣️ Sabiduría Gaucha")
+                import random
                 wisdom_display = gr.Textbox(
-                    value="'Che, en esta pampa cósmica, la tradición y la tecnología van de la mano!'",
-                    label="💭 Reflexión Cultural",
-                    interactive=False
+                    value=random.choice(wisdom_quotes),
+                    label="💭 Sabiduría del Gaucho",
+                    interactive=False,
+                    elem_classes="epic-container"
                 )
         
-        def move_and_update(direction):
+        def epic_move_and_update(direction):
             game.update_game_state(direction)
-            return game.render_frame(), game.get_game_status()
+            return game.render_epic_frame(), game.get_epic_status()
         
-        # Conectar botones de movimiento
-        left_btn.click(
-            fn=lambda: move_and_update("left"),
-            outputs=[game_display, status_display]
-        )
-        right_btn.click(
-            fn=lambda: move_and_update("right"),
-            outputs=[game_display, status_display]
-        )
-        up_btn.click(
-            fn=lambda: move_and_update("up"),
-            outputs=[game_display, status_display]
-        )
-        down_btn.click(
-            fn=lambda: move_and_update("down"),
-            outputs=[game_display, status_display]
-        )
+        # 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])
         
-        # Cargar estado inicial
+        # Estado inicial épico
         interface.load(
-            fn=lambda: (game.render_frame(), game.get_game_status()),
+            fn=lambda: (game.render_epic_frame(), game.get_epic_status()),
             outputs=[game_display, status_display]
         )
     
     return interface
 
 if __name__ == "__main__":
-    interface = create_game_interface()
-    interface.launch(
-        share=True,
-        show_error=True,
-        debug=True
-    )
+    interface = create_epic_interface()
+    interface.launch(share=True, show_error=True, debug=True)