a2

app.py

@@ -577,8 +577,8 @@ public class BattleMain {{
             }}
 
             // Posicionar aeronaves no campo de batalha com cores
-            battlefield[team1.getPositionY()][p1PosX] = "\u001B[34m" + team1.symbol + "\u001B[0m";  // Azul para Time 1
-            battlefield[team2.getPositionY()][p2PosX] = "\u001B[31m" + team2.symbol + "\u001B[0m";  // Vermelho para Time 2
+            battlefield[team1.getPositionY()][p1PosX] = "\\u001B[34m" + team1.symbol + "\\u001B[0m";  // Azul para Time 1
+            battlefield[team2.getPositionY()][p2PosX] = "\\u001B[31m" + team2.symbol + "\\u001B[0m";  // Vermelho para Time 2
 
             // Mover projéteis e verificar colisões
             Iterator<Projectile> iterator = projectiles.iterator();
@@ -662,4 +662,306 @@ public class BattleMain {{
                 if (p.posX >= 0 && p.posX < screenWidth && p.posY >= 0 && p.posY < battlefieldHeight) {{
                     // Adicionar cores aos projéteis baseado na direção
                     if (p.direction > 0) {{
-                        battlefield[p.posY][p.posX]
+                        battlefield[p.posY][p.posX] = "\\u001B[34m" + p.symbol + "\\u001B[0m";  // Azul para Time 1
+                    }} else {{
+                        battlefield[p.posY][p.posX] = "\\u001B[31m" + p.symbol + "\\u001B[0m";  // Vermelho para Time 2
+                    }}
+                }}
+            }}
+
+            // Mostrar campo de batalha
+            for (int row = 0; row < battlefieldHeight; row++) {{
+                for (int i = 0; i < screenWidth; i++) {{
+                    System.out.print(battlefield[row][i]);
+                }}
+                System.out.println();
+            }}
+
+            // Mostrar status de vida
+            System.out.println("❤️ Vida Time 1: " + team1.getHealth() + " | ❤️ Vida Time 2: " + team2.getHealth());
+            System.out.flush();
+
+            // Pausa para visualização
+            try {{
+                Thread.sleep(200);
+            }} catch (InterruptedException e) {{
+                System.err.println("Erro na pausa: " + e.getMessage());
+            }}
+        }}
+
+        if (team1.isAlive()) {{
+            System.out.println("🏆 Time 1 venceu!");
+        }} else {{
+            System.out.println("🏆 Time 2 venceu!");
+        }}
+        System.out.flush();
+    }}
+}}"""
+
+    # Salvar os arquivos Java
+    with open(aircraft_path, "w") as f:
+        f.write(aircraft_code)
+    with open(projectile_path, "w") as f:
+        f.write(projectile_code)
+    with open(class1_path, "w") as f1:
+        f1.write(code1)
+    with open(class2_path, "w") as f2:
+        f2.write(code2)
+    with open(main_path, "w") as f_main:
+        f_main.write(battle_main_code)
+
+    try:
+        # Compilar os arquivos Java
+        for java_file in [aircraft_path, projectile_path, class1_path, class2_path, main_path]:
+            compile_result = subprocess.run(["javac", "-cp", "combat_classes", "-d", "combat_classes", java_file], capture_output=True, text=True)
+            if compile_result.returncode != 0:
+                return f"❌ Erro na compilação:\\n{compile_result.stderr}"
+
+        # Executar a simulação
+        process = subprocess.Popen(
+            ["java", "-cp", "combat_classes", "BattleMain"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1
+        )
+
+        # Usar deque para manter os últimos turnos na visualização
+        turnos = deque(maxlen=4)  # Últimos 4 turnos para visualização fluida
+
+        # Guardar saída completa
+        saida_completa = ""
+        turno_atual = ""
+        coletando_turno = False
+        resultado_final = None
+
+        for line in iter(process.stdout.readline, ""):
+            saida_completa += line
+
+            # Detectar novo turno
+            if "=== NOVO TURNO ===" in line:
+                if turno_atual:
+                    turnos.append(turno_atual)
+                turno_atual = line
+                coletando_turno = True
+            elif coletando_turno:
+                turno_atual += line
+
+            # Verificar se é o resultado final
+            if "venceu" in line:
+                resultado_final = line
+
+            # Atualizar a cada turno
+            texto = "".join(list(turnos)) + turno_atual
+
+            # Conversão de cores
+            formatted_texto = texto.replace("\\033[31m", "<span style='color:red;'>")
+            formatted_texto = formatted_texto.replace("\\033[34m", "<span style='color:blue;'>")
+            formatted_texto = formatted_texto.replace("\\033[32m", "<span style='color:green;'>")
+            formatted_texto = formatted_texto.replace("\\033[0m", "</span>")
+
+            # Script de scroll
+            scroll_js = """
+            <script>
+            (function() {
+                function forceScrollBottom() {
+                    const container = document.getElementById('battle-container');
+                    if (container) {
+                        container.scrollTop = container.scrollHeight * 10;
+                        setTimeout(() => {
+                            container.scrollTop = container.scrollHeight * 10;
+                        }, 50);
+                    }
+                }
+                forceScrollBottom();
+                const scrollInterval = setInterval(forceScrollBottom, 100);
+                setTimeout(() => { clearInterval(scrollInterval); }, 2000);
+            })();
+            </script>
+            """
+
+            html_output = f"""
+            <div id="battle-container" style="height:400px; overflow:auto; border:1px solid #ccc; padding:10px;
+                                             font-family:monospace; white-space:pre; background-color:#f8f8f8;">
+                {formatted_texto}
+            </div>
+            {scroll_js}
+            """
+
+            yield html_output
+            time.sleep(0.05)
+
+        # Ao final, mostrar resultado destacado
+        if resultado_final:
+            formatted_saida = saida_completa.replace("\\033[31m", "<span style='color:red;'>")
+            formatted_saida = formatted_saida.replace("\\033[34m", "<span style='color:blue;'>")
+            formatted_saida = formatted_saida.replace("\\033[32m", "<span style='color:green;'>")
+            formatted_saida = formatted_saida.replace("\\033[0m", "</span>")
+
+            vencedor = "Time 1" if "Time 1 venceu" in resultado_final else "Time 2"
+            cor = "blue" if vencedor == "Time 1" else "red"
+
+            final_scroll_js = """
+            <script>
+            (function() {
+                function finalForceScroll() {
+                    const container = document.querySelector('#historico-completo');
+                    if (container) {
+                        container.scrollTop = container.scrollHeight * 20;
+                    }
+                }
+                finalForceScroll();
+                for (let i = 1; i <= 20; i++) {
+                    setTimeout(finalForceScroll, i * 100);
+                }
+                const scrollInterval = setInterval(finalForceScroll, 200);
+                setTimeout(() => { clearInterval(scrollInterval); }, 5000);
+            })();
+            </script>
+            """
+
+            final_html = f"""
+            <div>
+                <div style="padding:15px; background-color:#e9f7e9; border:2px solid #4CAF50;
+                            margin:15px 0; text-align:center; border-radius:5px;">
+                    <h3 style="color:{cor}; margin:0; font-size:24px;">🏆 {vencedor} VENCEU! 🏆</h3>
+                </div>
+
+                <h4>Histórico Completo da Batalha:</h4>
+
+                <div id="historico-completo" style="height:500px; overflow:auto; border:1px solid #ccc; padding:10px;
+                           font-family:monospace; white-space:pre; background-color:#f8f8f8;">
+                    {formatted_saida}
+                </div>
+                {final_scroll_js}
+            </div>
+            """
+
+            yield final_html
+
+    except Exception as e:
+        yield f"⚠ Erro inesperado: {str(e)}"
+
+# Funções para carregar templates
+def load_team1_template():
+    return TEAM1_TEMPLATE
+
+def load_team2_template():
+    return TEAM2_TEMPLATE
+
+# Função para preparar e executar a batalha
+def prepare_battle(code1, code2, width, height, p1_pos, p2_auto, p2_pos, t1_health, t2_health):
+    # Se a posição do Time 2 é automática, calcule-a com base na largura
+    final_p2_pos = width - 2 if p2_auto else p2_pos
+    # Executar a simulação e retornar o iterador
+    for output in run_battle(code1, code2, width, height, p1_pos, final_p2_pos, t1_health, t2_health):
+        yield output
+
+# Interface Gradio
+with gr.Blocks(title="Java Air Combat", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# ⯐🛦🛧 JAVA-Aircraft-Combat - Time 1 vs Time 2")
+
+    gr.Markdown("""
+    ## Instruções Rápidas
+
+    1. Use os botões "Carregar Template" para obter um modelo editável para cada time
+    2. Personalize os atributos da aeronave (máximo de 100 pontos)
+    3. Configure a arena no painel de configurações abaixo se desejar
+    4. Clique em "🔥 Combate!" para iniciar a batalha
+
+    **NOVIDADES**: Agora suas aeronaves podem ter radar para detectar projéteis, tiro duplo para atacar em duas altitudes diferentes e até mísseis nucleares para dano massivo!
+    """)
+
+    with gr.Row():
+        with gr.Column():
+            team1_code = gr.Textbox(label="🟦 Código Time 1", lines=20, placeholder="Clique em 'Carregar Template Time 1' para começar")
+            team1_template_btn = gr.Button("📝 Carregar Template Time 1", variant="secondary")
+
+        with gr.Column():
+            team2_code = gr.Textbox(label="🟥 Código Time 2", lines=20, placeholder="Clique em 'Carregar Template Time 2' para começar")
+            team2_template_btn = gr.Button("📝 Carregar Template Time 2", variant="secondary")
+
+    # Conectar botões às funções
+    team1_template_btn.click(load_team1_template, inputs=[], outputs=team1_code)
+    team2_template_btn.click(load_team2_template, inputs=[], outputs=team2_code)
+
+    with gr.Accordion("⚙️ Configurações da Arena", open=False):
+        with gr.Row():
+            screen_width = gr.Slider(minimum=50, maximum=200, value=100, step=10,
+                                   label="Largura da Tela", info="Define a largura do campo de batalha")
+            battlefield_height = gr.Slider(minimum=3, maximum=7, value=3, step=1,
+                                        label="Altura do Campo", info="Define o número de linhas no campo de batalha")
+
+        with gr.Row():
+            p1_start_pos = gr.Slider(minimum=0, maximum=49, value=2, step=1,
+                                   label="Posição Inicial Time 1", info="Define onde o Time 1 começa na arena")
+            p2_start_pos_auto = gr.Checkbox(label="Posicionar Time 2 automaticamente",
+                                          info="Se marcado, o Time 2 será posicionado no lado oposto", value=True)
+            p2_start_pos = gr.Slider(minimum=51, maximum=200, value=98, step=1,
+                                   label="Posição Inicial Time 2", info="Define onde o Time 2 começa na arena",
+                                   visible=False)
+
+        with gr.Row():
+            team1_health = gr.Slider(minimum=50, maximum=500, value=100, step=10,
+                                    label="❤️ Vida Time 1", info="Define a vida inicial da aeronave do Time 1")
+            team2_health = gr.Slider(minimum=50, maximum=500, value=100, step=10,
+                                    label="❤️ Vida Time 2", info="Define a vida inicial da aeronave do Time 2")
+
+        # Botão para equalizar as vidas
+        def equalize_health(health_value):
+            return health_value, health_value
+
+        equalize_btn = gr.Button("🔄 Igualar Vidas", variant="secondary")
+        equalize_btn.click(fn=equalize_health, inputs=team1_health, outputs=[team1_health, team2_health])
+
+        # Lógica para mostrar/esconder a posição do Time 2
+        def toggle_p2_pos(auto_checked):
+            return {"visible": not auto_checked}
+
+        p2_start_pos_auto.change(toggle_p2_pos, inputs=p2_start_pos_auto, outputs=p2_start_pos)
+
+        # Atualizar posição do Time 2 automaticamente com base na largura da tela
+        def update_p2_pos(width):
+            return width - 2
+
+        screen_width.change(update_p2_pos, inputs=screen_width, outputs=p2_start_pos)
+
+    btn = gr.Button("🔥 Combate!", variant="primary", size="lg")
+    
+    # Configurar o componente HTML
+    css = """
+    <style>
+    #battle-result .prose {
+        padding: 0 !important;
+        margin: 0 !important;
+        display: block !important;
+        visibility: visible !important;
+    }
+    </style>
+    """
+
+    output = gr.HTML(label="Resultado do Combate", elem_id="battle-result", value=css)
+    
+    # Conectar o botão à função
+    btn.click(fn=prepare_battle,
+              inputs=[team1_code, team2_code, screen_width, battlefield_height,
+                     p1_start_pos, p2_start_pos_auto, p2_start_pos,
+                     team1_health, team2_health],
+              outputs=output)
+
+    # Adicionar informações de rodapé
+    gr.Markdown("""
+    ### Dicas
+    - Equilibre seus pontos! Uma distribuição balanceada geralmente é melhor.
+    - Lembre que cada atributo tem limites (indicados nos comentários).
+    - O radar permite detectar projéteis inimigos e realizar manobras evasivas automáticas.
+    - O tiro duplo ataca em duas altitudes ao mesmo tempo, aumentando suas chances de acerto.
+    - O míssil nuclear causa dano massivo, mas tem um longo cooldown de 5 turnos.
+    - Use toda a altura do campo (configure nas opções) para estratégias mais interessantes!
+    - Agora você pode ajustar a vida inicial das aeronaves para batalhas mais longas ou equilibrar times desiguais!
+
+    Desenvolvido para a disciplina de Programação. Bons combates!
+    """)
+
+if __name__ == "__main__":
+    app.launch()