Update app.py

app.py

@@ -1,8 +1,8 @@
-# app.py - Versión corregida y optimizada
+# app.py - Versión corregida para HuggingFace Spaces
 import gradio as gr
 import time
 import math
-from PIL import Image
+from PIL import Image, ImageDraw
 import io
 from game_engine import GauchoCharacter, PhysicsEngine, WorldGenerator, Vector2D
 
@@ -13,33 +13,61 @@ class CosmicGauchoGame:
         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)
     
-    def update_game_state(self, user_input: dict):
-        # Implementación básica de movimiento
+    def update_game_state(self, movement: str = "none"):
+        # Sistema de movimiento simplificado
         acceleration = Vector2D(0, 0)
+        speed = 3.0
         
-        if user_input.get('left'):
-            acceleration.x = -5
-        if user_input.get('right'):
-            acceleration.x = 5
-        if user_input.get('up'):
-            acceleration.y = -5
-        if user_input.get('down'):
-            acceleration.y = 5
+        if movement == "left":
+            acceleration.x = -speed
+        elif movement == "right":
+            acceleration.x = speed
+        elif movement == "up":
+            acceleration.y = -speed
+        elif movement == "down":
+            acceleration.y = speed
             
         self.player.velocity = self.physics.apply_momentum(
             self.player.velocity,
             acceleration,
-            dt=0.033
+            dt=0.1
         )
-        self.player.position += self.player.velocity * 0.033
+        
+        # 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.x = max(50, min(new_x, self.game_width - 50))
+        self.player.position.y = max(50, min(new_y, self.game_height - 50))
     
     def render_frame(self) -> Image.Image:
-        img = Image.new('RGB', (800, 600), (30, 30, 30))
+        # Crear canvas del juego
+        img = Image.new('RGB', (self.game_width, self.game_height), (20, 40, 60))
+        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))
+        
+        # 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)
+        
+        # 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)
+        
         return img
 
 # Clase mejorada con optimizaciones
@@ -48,62 +76,88 @@ class EnhancedCosmicGaucho(CosmicGauchoGame):
         super().__init__()
         self.last_frame_time = time.time()
     
-    def optimized_render(self) -> Image.Image:
-        current_time = time.time()
-        delta_time = current_time - self.last_frame_time
-        self.last_frame_time = current_time
-        
-        frame = self.render_frame()
-        return frame
+    def get_game_status(self):
+        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())
+        }
 
 def create_game_interface():
     game = EnhancedCosmicGaucho()
     
-    with gr.Blocks(title="El Gaucho Cósmico", theme=gr.themes.Base(
-        primary_hue="blue",
-        secondary_hue="teal",
-        font=["Helvetica", "Arial", "sans-serif"]
-    )) as interface:
+    with gr.Blocks(
+        title="🎮 El Gaucho Cósmico - Preservando la Identidad Argentina 🇦🇷",
+        theme=gr.themes.Monochrome()
+    ) as interface:
+        
+        gr.Markdown("""
+        # 🌟 El Gaucho Cósmico
+        ### Aventura Épica de Identidad Cultural Argentina
+        *Año 2088 - La Pampa Cósmica te necesita, che!*
+        """)
         
         with gr.Row():
-            game_display = gr.Image(label="Pampa Cósmica", shape=(800, 600), interactive=False)
-            
-            with gr.Column():
-                gr.Markdown("## Controles Gaucho-Hacker")
-                with gr.Row():
-                    left_btn = gr.Button("←", variant="secondary")
-                    right_btn = gr.Button("→", variant="secondary")
+            with gr.Column(scale=2):
+                game_display = gr.Image(
+                    label="🌌 Pampa Cósmica", 
+                    interactive=False,
+                    width=800,
+                    height=600
+                )
+                
                 with gr.Row():
-                    up_btn = gr.Button("↑", variant="secondary")
-                    down_btn = gr.Button("↓", variant="secondary")
+                    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")
+            
+            with gr.Column(scale=1):
+                gr.Markdown("### 🎯 Estado del Gaucho")
+                status_display = gr.JSON(label="📊 Datos del Personaje")
                 
-                gr.Markdown("## Estado del Jugador")
-                debug_panel = gr.DataFrame(
-                    headers=["Atributo", "Valor"],
-                    datatype=["str", "str"],
+                gr.Markdown("### 🗣️ Sabiduría Gaucha")
+                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
                 )
         
-        def update_frame():
-            game.update_game_state({
-                'left': False,
-                'right': False,
-                'up': False,
-                'down': False
-            })
-            return game.optimized_render(), [
-                ["Posición", f"{game.player.position.x:.1f}, {game.player.position.y:.1f}"],
-                ["Velocidad", f"{game.player.velocity.x:.1f}, {game.player.velocity.y:.1f}"]
-            ]
+        def move_and_update(direction):
+            game.update_game_state(direction)
+            return game.render_frame(), game.get_game_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]
+        )
         
+        # Cargar estado inicial
         interface.load(
-            fn=update_frame,
-            outputs=[game_display, debug_panel],
-            every=0.033
+            fn=lambda: (game.render_frame(), game.get_game_status()),
+            outputs=[game_display, status_display]
         )
     
     return interface
 
 if __name__ == "__main__":
     interface = create_game_interface()
-    interface.launch()
+    interface.launch(
+        share=True,
+        show_error=True,
+        debug=True
+    )