Update app.py

app.py

@@ -6,12 +6,13 @@ import math
 from scipy.special import comb
 import time
 
-# --- Funções Matemáticas (Inalteradas) ---
+# --- Funções Matemáticas ---
+
 def bernstein_poly(i, n, t):
     return comb(n, i) * (t**(i)) * ((1 - t)**(n - i))
 
-# --- MUDANÇA #1: VELOCIDADE AUMENTADA (Menos Vetores) ---
-def bezier_curve_3d(points, n_times=24): # De 60 para 40 vetores por ciclo
+# --- MUDANÇA #1: CICLOS ULTRA-RÁPIDOS (Menos Vetores) ---
+def bezier_curve_3d(points, n_times=20): # Apenas 20 vetores por ciclo!
     n_points = len(points)
     x_points, y_points, z_points = np.array([p[0] for p in points]), np.array([p[1] for p in points]), np.array([p[2] for p in points])
     t = np.linspace(0.0, 1.0, n_times)
@@ -24,37 +25,38 @@ def aprender_com_o_eco_3d(pontos_do_eco: list):
     p1, p2 = np.array(pontos_do_eco[0]), np.array(pontos_do_eco[-1])
     return {"velocity_vector": p2 - p1}
 
-# --- Função Principal do Gradio (Motor de Alta Velocidade) ---
+# --- Função Principal do Gradio (Motor Hyperdrive) ---
 
 def motor_da_simulacao_infinita(angulo_camera: int):
     """
-    Motor da simulação que roda em um loop infinito, com um universo expandido
-    e maior velocidade de movimento.
+    Motor da simulação que roda em um loop infinito, com um universo compacto
+    e velocidade de movimento extrema.
     """
-    ponto_a = np.array([-40., 20., 10.])
-    vetor_inercia = np.array([30., 90., -120.])
+    ponto_a = np.array([0., 0., 0.])
+    vetor_inercia = np.array([10., 10., 10.])
     historico_rastro = [ponto_a.tolist()]
 
-    fig = plt.figure(figsize=(32, 32)); ax = fig.add_subplot(111, projection='3d')
+    fig = plt.figure(figsize=(8, 8)); ax = fig.add_subplot(111, projection='3d')
     cor_fundo = '#0a0a0a'; fig.patch.set_facecolor(cor_fundo); ax.set_facecolor(cor_fundo)
 
     ciclo_num = 0
     while True:
         ciclo_num += 1
         
-        # --- MUDANÇA #2: UNIVERSO EXPANDIDO (Alvos Mais Distantes) ---
-        ponto_b = np.random.rand(3) * 240 - 80 # Agora de -100 a 100 em cada eixo
+        # --- MUDANÇA #2: UNIVERSO COMPACTO ---
+        # Alvos aleatórios em um espaço de -25 a 25 (4x menor que o anterior)
+        ponto_b = np.random.rand(3) * 50 - 25
 
         ponto_controle = ponto_a + vetor_inercia
         pontos_curva = [ponto_a, ponto_controle, ponto_b]
-        x_ciclo, y_ciclo, z_ciclo = bezier_curve_3d(pontos_curva) # Gera 40 vetores
+        x_ciclo, y_ciclo, z_ciclo = bezier_curve_3d(pontos_curva)
 
         novos_pontos_rastro = list(zip(x_ciclo, y_ciclo, z_ciclo))
         historico_rastro.extend(novos_pontos_rastro)
-        max_rastro = 8 # Rastro um pouco menor para dar sensação de velocidade
+        max_rastro = 150 # Rastro mais curto para um visual mais limpo
         historico_rastro = historico_rastro[-max_rastro:]
         
-        tamanho_eco = 15
+        tamanho_eco = 10 # Eco menor para trajetórias mais curtas
         pontos_eco = list(zip(x_ciclo[-tamanho_eco:], y_ciclo[-tamanho_eco:], z_ciclo[-tamanho_eco:]))
         vetor_inercia = aprender_com_o_eco_3d(pontos_eco)["velocity_vector"]
 
@@ -64,10 +66,10 @@ def motor_da_simulacao_infinita(angulo_camera: int):
             ax.cla()
             ax.xaxis.pane.fill = False; ax.yaxis.pane.fill = False; ax.zaxis.pane.fill = False
             ax.grid(color='#222222', linestyle='--')
-            ax.view_init(elev=30., azim=angulo_camera + (len(historico_rastro) - len(x_ciclo) + frame) * 0.2) # Rotação de câmera um pouco mais rápida
+            ax.view_init(elev=25., azim=angulo_camera + (len(historico_rastro) - len(x_ciclo) + frame) * 0.5) # Rotação de câmera mais rápida
             
-            # --- MUDANÇA #2 (Continuação): Ajusta os limites do gráfico para o novo universo ---
-            ax.set_xlim(-110, 110); ax.set_ylim(-110, 110); ax.set_zlim(-110, 110)
+            # --- MUDANÇA #2 (Continuação): Limites do gráfico para o universo compacto ---
+            ax.set_xlim(-30, 30); ax.set_ylim(-30, 30); ax.set_zlim(-30, 30)
             ax.set_xticklabels([]); ax.set_yticklabels([]); ax.set_zticklabels([])
 
             ax.scatter(*ponto_a, s=150, c='lime', alpha=0.7)
@@ -82,25 +84,26 @@ def motor_da_simulacao_infinita(angulo_camera: int):
             ax.text2D(0.05, 0.95, info_texto, transform=ax.transAxes, color='white', fontsize=10)
             
             yield fig
-            time.sleep(0.005)
+            # --- MUDANÇA #3: ATUALIZAÇÃO MAIS RÁPIDA ---
+            time.sleep(0.01) # Pausa mínima para a UI respirar
 
         ponto_a = ponto_b
 
     plt.close(fig)
 
-# --- Interface Gradio (Inalterada) ---
-with gr.Blocks(theme=gr.themes.Base(primary_hue="yellow")) as demo:
+# --- Interface Gradio ---
+with gr.Blocks(theme=gr.themes.Base(primary_hue="red")) as demo:
     gr.Markdown(
         """
-        # 🚀 Simulador Autônomo 3D (Alta Velocidade)
-        Clique em "Iniciar" para dar partida no motor da simulação. O agente (bola) irá navegar
-        em alta velocidade por um universo expandido, gerando novos alvos aleatórios em um loop infinito.
+        # ⚡ Simulador Autônomo 3D (Modo Hyperdrive)
+        Clique em "Iniciar" para dar partida no motor da simulação. O agente irá navegar em **velocidade extrema**
+        por um universo compacto, gerando novos alvos aleatórios em um loop infinito.
         """
     )
     with gr.Row():
         with gr.Column(scale=1):
             angulo_camera_slider = gr.Slider(-180, 180, value=45, label="Ângulo Inicial da Câmera")
-            start_btn = gr.Button("🚀 Iniciar Simulação Infinita", variant="primary")
+            start_btn = gr.Button("🚀 Iniciar Simulação (Hyperdrive)", variant="primary")
         with gr.Column(scale=2):
             plot_output = gr.Plot(label="Visualização em Tempo Real")