a1

README.md

@@ -1,13 +1,50 @@
 ---
-title: Java Air Combat
-emoji: 🏃
-colorFrom: indigo
-colorTo: indigo
+title: sentiment-analysis-committee
+emoji: 👥
+colorFrom: blue
+colorTo: green
 sdk: gradio
-sdk_version: 5.31.0
+sdk_version: "4.12.0"
 app_file: app.py
 pinned: false
-license: ecl-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# Sentiment Analysis Committee
+
+A comprehensive sentiment analysis tool using multiple methods, including BERT (Base and Large), DistilBERT, SiEBERT, TextBlob, VADER, and AFINN.
+
+## How to Use
+
+Enter text into the interface to receive sentiment analyses from various methods. The committee's decision is based on the majority of votes among the methods.
+
+## Technical Details
+
+This project leverages various natural language processing models to evaluate the sentiment of entered text:
+
+- **BERT Base and BERT Large**: Transformer-based models providing sentiment scores and labels. BERT Large is a larger variant of BERT with more layers, potentially offering more nuanced sentiment analysis.
+- **DistilBERT**: A distilled version of BERT, optimized for speed and efficiency.
+- **SiEBERT**: A RoBERTa-based model fine-tuned for sentiment analysis.
+- **TextBlob**: Utilizes Naive Bayes classifiers, offering straightforward sentiment evaluations.
+- **VADER**: Designed for social media and short texts, giving a compound sentiment score.
+- **AFINN**: A lexical method assigning scores to words, indicating sentiment intensity.
+
+The final decision of the committee is determined by a majority vote approach, providing a balanced sentiment analysis.
+
+## Additional Information
+
+- Developed by Ramon Mayor Martins (2023)
+- E-mail: [[email protected]](mailto:[email protected])
+- Homepage: [https://rmayormartins.github.io/](https://rmayormartins.github.io/)
+- Twitter: [@rmayormartins](https://twitter.com/rmayormartins)
+- GitHub: [https://github.com/rmayormartins](https://github.com/rmayormartins)
+
+## Notes
+
+- The committee's decision is democratic, based on the majority vote from the utilized methods.
+- The project is implemented in Python and hosted on Hugging Face Spaces.
+
+
+
+
+

app.py

@@ -0,0 +1,665 @@
+import gradio as gr
+import os
+import subprocess
+import time
+from collections import deque
+
+# Criar pasta para armazenar as classes Java
+os.makedirs("combat_classes", exist_ok=True)
+
+# Templates de código para as aeronaves com altura dinâmica e novos atributos
+TEAM1_TEMPLATE = '''import java.util.ArrayList;
+import java.util.Random;
+
+/**
+ * Time 1 - Configure sua aeronave!
+ *
+ * SISTEMA DE PONTOS:
+ * - Você tem 100 pontos para distribuir entre os atributos
+ * - Escolha com sabedoria para criar uma aeronave competitiva
+ *
+ * ATRIBUTOS:
+ * - speed: Velocidade da aeronave (1-10) - Afeta quão rápido sua aeronave pode se mover
+ * - fireRate: Taxa de disparo (1-10) - Controla com que frequência sua aeronave pode atirar
+ * - maneuverability: Manobrabilidade (1-10) - Facilita mudanças de altitude e esquivas
+ * - shotPower: Poder do tiro normal (5-20) - Dano causado por tiros normais
+ * - supersonicPower: Poder do tiro supersônico (10-30) - Dano causado por tiros supersônicos
+ * - missilePower: Poder do míssil (15-40) - Dano causado pelo míssil especial
+ * - defense: Defesa (5-25) - Reduz o dano recebido
+ * - stealthChance: Chance de furtividade (0-20) - Probabilidade de evitar ataques
+ * - radar: Radar (0-10) - Capacidade de detectar projéteis inimigos
+ * - doubleShot: Tiro duplo (0-10) - Permite disparar em duas altitudes diferentes
+ * - nuclearPower: Poder nuclear (0-10) - Poder do míssil nuclear (dano massivo)
+ */
+public class Team1Aircraft extends Aircraft {
+    private Random random = new Random();
+    private int maxAltitude; // Armazena a altura máxima do campo
+
+    public Team1Aircraft() {
+        super(
+            // DISTRIBUA 100 PONTOS ENTRE ESSES ATRIBUTOS
+            5,  // Velocidade (1-10)
+            5,  // Taxa de fogo (1-10)
+            5,  // Manobrabilidade (1-10)
+            15, // Dano do tiro normal (5-20)
+            20, // Dano do tiro supersônico (10-30)
+            25, // Dano do míssil (15-40)
+            15, // Defesa (5-25)
+            5,  // Chance de furtividade (0-20)
+            2,  // Radar (0-10)
+            2,  // Tiro duplo (0-10)
+            1,  // Poder nuclear (0-10)
+            "▶" // Símbolo da aeronave (não altere)
+        );
+
+        // IMPORTANTE: A soma de todos os atributos deve ser <= 100
+        // Exemplo: 5+5+5+15+20+25+15+5+2+2+1 = 100
+
+        // Verifica dinamicamente a altura do campo (será definida pelo BattleMain)
+        try {
+            String heightEnv = System.getProperty("battlefield.height", "3");
+            maxAltitude = Integer.parseInt(heightEnv) - 1;
+        } catch (Exception e) {
+            maxAltitude = 2; // Valor padrão se não conseguir ler
+        }
+    }
+
+    /**
+     * Controla o movimento da aeronave.
+     * Valor padrão: Movimento aleatório baseado na velocidade
+     * Dica: Você pode personalizar para criar padrões de movimento mais inteligentes
+     */
+    @Override
+    public int move() {
+        // Retorna um número entre -speed/2 e +speed
+        return random.nextInt(speed + 1) - speed / 2;
+    }
+
+    /**
+     * Controla a mudança de altitude da aeronave.
+     * Valor padrão: Mudança aleatória entre subir, descer ou manter altitude
+     * Dica: Uma boa estratégia pode aumentar suas chances de esquiva
+     */
+    @Override
+    public int changeAltitude() {
+        int direction = random.nextInt(3) - 1; // -1 (descer), 0 (manter), 1 (subir)
+        this.posY = Math.max(0, Math.min(maxAltitude, posY + direction));
+        return direction;
+    }
+
+    /**
+     * Tiro normal - mais frequente, menos dano
+     */
+    @Override
+    public Projectile shoot(int posX, int direction) {
+        return new Projectile(posX, this.posY, direction, 1, "->");
+    }
+
+    /**
+     * Tiro supersônico - mais rápido, mais dano
+     */
+    @Override
+    public Projectile shootSupersonic(int posX, int direction) {
+        return new Projectile(posX, this.posY, direction, 2, ">>");
+    }
+
+    /**
+     * Míssil especial - muito dano, com cooldown
+     */
+    @Override
+    public Projectile specialMissile(int posX, int direction) {
+        if (missileCooldown == 0) {
+            missileCooldown = 3; // Espera 3 turnos para usar novamente
+            return new Projectile(posX, this.posY, direction, 1, "=>");
+        }
+        missileCooldown--;
+        return null;
+    }
+
+    /**
+     * Tiro duplo - ataca em duas altitudes diferentes
+     */
+    @Override
+    public Projectile doubleShot(int posX, int direction) {
+        // Define a segunda altitude para o tiro (diferente da atual)
+        int currentAlt = this.posY;
+        int secondAlt = (currentAlt + 1) % (maxAltitude + 1);
+
+        // Guarda essa altitude para ser usada pelo BattleMain
+        this.secondShotAltitude = secondAlt;
+
+        // Retorna o projétil principal
+        return new Projectile(posX, this.posY, direction, 1, "⇉");
+    }
+
+    /**
+     * Míssil nuclear - dano massivo
+     */
+    @Override
+    public Projectile nuclearMissile(int posX, int direction) {
+        if (missileCooldown == 0) {
+            missileCooldown = 5; // Longo cooldown para o poder nuclear
+            return new Projectile(posX, this.posY, direction, 1, "-]=>");
+        }
+        return null;
+    }
+
+    /**
+     * Radar - detecta projéteis inimigos
+     */
+    @Override
+    public void radarScan(ArrayList<Projectile> projectiles, int enemyPosX, int enemyPosY) {
+        // Implementação básica: apenas detecta projéteis próximos
+        // Em uma implementação mais avançada, você poderia usar essas informações
+        // para ajustar seu movimento e evitar projéteis
+    }
+}'''
+
+TEAM2_TEMPLATE = '''import java.util.ArrayList;
+import java.util.Random;
+
+/**
+ * Time 2 - Configure sua aeronave!
+ *
+ * SISTEMA DE PONTOS:
+ * - Você tem 100 pontos para distribuir entre os atributos
+ * - Escolha com sabedoria para criar uma aeronave competitiva
+ *
+ * ATRIBUTOS:
+ * - speed: Velocidade da aeronave (1-10) - Afeta quão rápido sua aeronave pode se mover
+ * - fireRate: Taxa de disparo (1-10) - Controla com que frequência sua aeronave pode atirar
+ * - maneuverability: Manobrabilidade (1-10) - Facilita mudanças de altitude e esquivas
+ * - shotPower: Poder do tiro normal (5-20) - Dano causado por tiros normais
+ * - supersonicPower: Poder do tiro supersônico (10-30) - Dano causado por tiros supersônicos
+ * - missilePower: Poder do míssil (15-40) - Dano causado pelo míssil especial
+ * - defense: Defesa (5-25) - Reduz o dano recebido
+ * - stealthChance: Chance de furtividade (0-20) - Probabilidade de evitar ataques
+ * - radar: Radar (0-10) - Capacidade de detectar projéteis inimigos
+ * - doubleShot: Tiro duplo (0-10) - Permite disparar em duas altitudes diferentes
+ * - nuclearPower: Poder nuclear (0-10) - Poder do míssil nuclear (dano massivo)
+ */
+public class Team2Aircraft extends Aircraft {
+    private Random random = new Random();
+    private int maxAltitude; // Armazena a altura máxima do campo
+
+    public Team2Aircraft() {
+        super(
+            // DISTRIBUA 100 PONTOS ENTRE ESSES ATRIBUTOS
+            5,  // Velocidade (1-10)
+            5,  // Taxa de fogo (1-10)
+            5,  // Manobrabilidade (1-10)
+            15, // Dano do tiro normal (5-20)
+            20, // Dano do tiro supersônico (10-30)
+            25, // Dano do míssil (15-40)
+            15, // Defesa (5-25)
+            5,  // Chance de furtividade (0-20)
+            2,  // Radar (0-10)
+            2,  // Tiro duplo (0-10)
+            1,  // Poder nuclear (0-10)
+            "◀" // Símbolo da aeronave (não altere)
+        );
+
+        // IMPORTANTE: A soma de todos os atributos deve ser <= 100
+        // Exemplo: 5+5+5+15+20+25+15+5+2+2+1 = 100
+
+        // Verifica dinamicamente a altura do campo (será definida pelo BattleMain)
+        try {
+            String heightEnv = System.getProperty("battlefield.height", "3");
+            maxAltitude = Integer.parseInt(heightEnv) - 1;
+        } catch (Exception e) {
+            maxAltitude = 2; // Valor padrão se não conseguir ler
+        }
+    }
+
+    /**
+     * Controla o movimento da aeronave.
+     * Valor padrão: Movimento aleatório baseado na velocidade
+     * Dica: Você pode personalizar para criar padrões de movimento mais inteligentes
+     */
+    @Override
+    public int move() {
+        // Retorna um número entre -speed/2 e +speed
+        return random.nextInt(speed + 1) - speed / 2;
+    }
+
+    /**
+     * Controla a mudança de altitude da aeronave.
+     * Valor padrão: Mudança aleatória entre subir, descer ou manter altitude
+     * Dica: Uma boa estratégia pode aumentar suas chances de esquiva
+     */
+    @Override
+    public int changeAltitude() {
+        int direction = random.nextInt(3) - 1; // -1 (descer), 0 (manter), 1 (subir)
+        this.posY = Math.max(0, Math.min(maxAltitude, posY + direction));
+        return direction;
+    }
+
+    /**
+     * Tiro normal - mais frequente, menos dano
+     */
+    @Override
+    public Projectile shoot(int posX, int direction) {
+        return new Projectile(posX, this.posY, direction, 1, "<-");
+    }
+
+    /**
+     * Tiro supersônico - mais rápido, mais dano
+     */
+    @Override
+    public Projectile shootSupersonic(int posX, int direction) {
+        return new Projectile(posX, this.posY, direction, 2, "<<");
+    }
+
+    /**
+     * Míssil especial - muito dano, com cooldown
+     */
+    @Override
+    public Projectile specialMissile(int posX, int direction) {
+        if (missileCooldown == 0) {
+            missileCooldown = 3; // Espera 3 turnos para usar novamente
+            return new Projectile(posX, this.posY, direction, 1, "<=");
+        }
+        missileCooldown--;
+        return null;
+    }
+
+    /**
+     * Tiro duplo - ataca em duas altitudes diferentes
+     */
+    @Override
+    public Projectile doubleShot(int posX, int direction) {
+        // Define a segunda altitude para o tiro (diferente da atual)
+        int currentAlt = this.posY;
+        int secondAlt = (currentAlt + 1) % (maxAltitude + 1);
+
+        // Guarda essa altitude para ser usada pelo BattleMain
+        this.secondShotAltitude = secondAlt;
+
+        // Retorna o projétil principal
+        return new Projectile(posX, this.posY, direction, 1, "⇇");
+    }
+
+    /**
+     * Míssil nuclear - dano massivo
+     */
+    @Override
+    public Projectile nuclearMissile(int posX, int direction) {
+        if (missileCooldown == 0) {
+            missileCooldown = 5; // Longo cooldown para o poder nuclear
+            return new Projectile(posX, this.posY, direction, 1, "<[=-");
+        }
+        return null;
+    }
+
+    /**
+     * Radar - detecta projéteis inimigos
+     */
+    @Override
+    public void radarScan(ArrayList<Projectile> projectiles, int enemyPosX, int enemyPosY) {
+        // Implementação básica: apenas detecta projéteis próximos
+        // Em uma implementação mais avançada, você poderia usar essas informações
+        // para ajustar seu movimento e evitar projéteis
+    }
+}'''
+
+# Código base das classes Aircraft e Projectile
+aircraft_code = """
+import java.util.ArrayList;
+
+public abstract class Aircraft {
+    protected int health;  // Agora definido externamente
+    protected int speed;
+    protected int fireRate;
+    protected int maneuverability;
+    protected int shotPower;
+    protected int supersonicPower;
+    protected int missilePower;
+    protected int defense;
+    protected int stealthChance;
+    protected int radar;
+    protected int doubleShot;
+    protected int doubleShotPower;
+    protected int nuclearPower;
+    protected int secondShotAltitude = -1;
+    protected int missileCooldown = 0;
+    protected int posY = 1;
+    protected String symbol;
+    protected static final int TOTAL_POINTS = 100;
+
+    public Aircraft(int speed, int fireRate, int maneuverability, int shotPower, int supersonicPower,
+                    int missilePower, int defense, int stealthChance, int radar, int doubleShot,
+                    int nuclearPower, String symbol) {
+        this.health = 100;  // Valor padrão que será substituído
+        this.speed = speed;
+        this.fireRate = fireRate;
+        this.maneuverability = maneuverability;
+        this.shotPower = shotPower;
+        this.supersonicPower = supersonicPower;
+        this.missilePower = missilePower;
+        this.defense = defense;
+        this.stealthChance = stealthChance;
+        this.radar = radar;
+        this.doubleShot = doubleShot;
+        this.doubleShotPower = doubleShot;
+        this.nuclearPower = nuclearPower;
+        this.symbol = symbol;
+
+        validateAttributes();
+    }
+
+    public void setInitialHealth(int health) {
+        this.health = health;
+    }
+
+    private void validateAttributes() {
+        int total = speed + fireRate + maneuverability + shotPower + supersonicPower +
+                   missilePower + defense + stealthChance + radar + doubleShot + nuclearPower;
+        if (total > TOTAL_POINTS) {
+            throw new IllegalArgumentException("Erro: A soma dos atributos excede " + TOTAL_POINTS + " pontos! Total: " + total);
+        }
+    }
+
+    public abstract int move();
+    public abstract int changeAltitude();
+    public abstract Projectile shoot(int posX, int direction);
+    public abstract Projectile shootSupersonic(int posX, int direction);
+    public abstract Projectile specialMissile(int posX, int direction);
+    public abstract Projectile doubleShot(int posX, int direction);
+    public abstract Projectile nuclearMissile(int posX, int direction);
+    public abstract void radarScan(ArrayList<Projectile> projectiles, int enemyPosX, int enemyPosY);
+
+    public int getHealth() {
+        return health;
+    }
+
+    public void takeDamage(int damage) {
+        this.health -= Math.max(0, damage - (defense / 10));
+    }
+
+    public boolean isAlive() {
+        return health > 0;
+    }
+
+    public int getPositionY() {
+        return posY;
+    }
+
+    public int getSecondShotAltitude() {
+        int alt = secondShotAltitude;
+        secondShotAltitude = -1; // Reset após uso
+        return alt;
+    }
+}
+"""
+
+projectile_code = """
+public class Projectile {
+    int posX;
+    int posY;
+    int direction;
+    int speed;
+    String symbol;
+    int power = 0;  // Poder do projétil, usado para dano personalizado
+
+    public Projectile(int posX, int posY, int direction, int speed, String symbol) {
+        this.posX = posX;
+        this.posY = posY;
+        this.direction = direction;
+        this.speed = speed;
+        this.symbol = symbol;
+    }
+
+    public Projectile(int posX, int posY, int direction, int speed, String symbol, int power) {
+        this(posX, posY, direction, speed, symbol);
+        this.power = power;
+    }
+
+    public void move() {
+        posX += direction * speed;
+    }
+
+    public boolean isOutOfBounds(int screenWidth) {
+        return (posX < 0 || posX >= screenWidth);
+    }
+
+    public int getPower() {
+        return power;
+    }
+}
+"""
+
+def run_battle(code1, code2, screen_width, battlefield_height, p1_start_pos, p2_start_pos, team1_health, team2_health):
+    # Caminhos dos arquivos Java
+    aircraft_path = "combat_classes/Aircraft.java"
+    projectile_path = "combat_classes/Projectile.java"
+    class1_path = "combat_classes/Team1Aircraft.java"
+    class2_path = "combat_classes/Team2Aircraft.java"
+    main_path = "combat_classes/BattleMain.java"
+
+    # Gerar o código do BattleMain com os parâmetros configuráveis
+    battle_main_code = f"""
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Random;
+
+public class BattleMain {{
+    public static void main(String[] args) {{
+        // Definir a altura do campo como propriedade do sistema
+        System.setProperty("battlefield.height", "{battlefield_height}");
+
+        Aircraft team1 = new Team1Aircraft();
+        Aircraft team2 = new Team2Aircraft();
+
+        // Definir a vida inicial de cada aeronave
+        team1.setInitialHealth({team1_health});
+        team2.setInitialHealth({team2_health});
+
+        Random random = new Random();
+
+        int p1PosX = {p1_start_pos};
+        int p2PosX = {p2_start_pos};
+        int screenWidth = {screen_width};
+        int battlefieldHeight = {battlefield_height};
+        ArrayList<Projectile> projectiles = new ArrayList<>();
+
+        // Inicializar as altitudes das naves em uma posição média do campo
+        team1.posY = battlefieldHeight / 2;
+        team2.posY = battlefieldHeight / 2;
+
+        while (team1.isAlive() && team2.isAlive()) {{
+            System.out.println("\\n=== NOVO TURNO ===");
+            System.out.flush();
+
+            String[][] battlefield = new String[battlefieldHeight][screenWidth];
+            for (int row = 0; row < battlefieldHeight; row++) {{
+                for (int i = 0; i < screenWidth; i++) {{
+                    battlefield[row][i] = " ";
+                }}
+            }}
+
+            // Radar scan para detectar projéteis
+            team1.radarScan(projectiles, p2PosX, team2.getPositionY());
+            team2.radarScan(projectiles, p1PosX, team1.getPositionY());
+
+            // Movimento das aeronaves
+            p1PosX += team1.move();
+            p2PosX += team2.move();
+            p1PosX = Math.max(0, Math.min(screenWidth - 1, p1PosX));
+            p2PosX = Math.max(0, Math.min(screenWidth - 1, p2PosX));
+
+            // Mudança de altitude
+            team1.changeAltitude();
+            team2.changeAltitude();
+            // Garantir que a altitude não exceda o novo tamanho do campo de batalha
+            team1.posY = Math.min(team1.posY, battlefieldHeight - 1);
+            team2.posY = Math.min(team2.posY, battlefieldHeight - 1);
+
+            // Atirar para Time 1
+            if (random.nextInt(10) < team1.fireRate) {{
+                Projectile shot = null;
+                int shotType = random.nextInt(100);
+
+                // Escolha aleatória do tipo de tiro baseado na probabilidade
+                if (shotType < 5 && team1.nuclearPower > 0) {{
+                    // Tiro nuclear (baixa probabilidade)
+                    shot = team1.nuclearMissile(p1PosX, 1);
+                    if (shot != null) {{
+                        System.out.println("☢️ Time 1 lançou um MÍSSIL NUCLEAR!");
+                    }}
+                }} else if (shotType < 15 && team1.doubleShot > 0) {{
+                    // Tiro duplo
+                    shot = team1.doubleShot(p1PosX, 1);
+                    if (shot != null) {{
+                        System.out.println("➡️ Time 1 disparou um TIRO DUPLO!");
+                        // Adicionar o segundo projétil em uma altitude diferente
+                        int secAlt = team1.getSecondShotAltitude();
+                        if (secAlt >= 0 && secAlt < battlefieldHeight) {{
+                            projectiles.add(new Projectile(p1PosX, secAlt, 1, 1, "->", team1.doubleShotPower));
+                        }}
+                    }}
+                }} else if (shotType < 30) {{
+                    // Míssil especial
+                    shot = team1.specialMissile(p1PosX, 1);
+                }} else if (shotType < 60) {{
+                    // Tiro supersônico
+                    shot = team1.shootSupersonic(p1PosX, 1);
+                }} else {{
+                    // Tiro normal
+                    shot = team1.shoot(p1PosX, 1);
+                }}
+
+                if (shot != null) {{
+                    // Garantir que a altitude do projétil não exceda o campo de batalha
+                    shot.posY = Math.min(shot.posY, battlefieldHeight - 1);
+                    projectiles.add(shot);
+                }}
+            }}
+
+            // Atirar para Time 2
+            if (random.nextInt(10) < team2.fireRate) {{
+                Projectile shot = null;
+                int shotType = random.nextInt(100);
+
+                // Escolha aleatória do tipo de tiro baseado na probabilidade
+                if (shotType < 5 && team2.nuclearPower > 0) {{
+                    // Tiro nuclear (baixa probabilidade)
+                    shot = team2.nuclearMissile(p2PosX, -1);
+                    if (shot != null) {{
+                        System.out.println("☢️ Time 2 lançou um MÍSSIL NUCLEAR!");
+                    }}
+                }} else if (shotType < 15 && team2.doubleShot > 0) {{
+                    // Tiro duplo
+                    shot = team2.doubleShot(p2PosX, -1);
+                    if (shot != null) {{
+                        System.out.println("⬅️ Time 2 disparou um TIRO DUPLO!");
+                        // Adicionar o segundo projétil em uma altitude diferente
+                        int secAlt = team2.getSecondShotAltitude();
+                        if (secAlt >= 0 && secAlt < battlefieldHeight) {{
+                            projectiles.add(new Projectile(p2PosX, secAlt, -1, 1, "<-", team2.doubleShotPower));
+                        }}
+                    }}
+                }} else if (shotType < 30) {{
+                    // Míssil especial
+                    shot = team2.specialMissile(p2PosX, -1);
+                }} else if (shotType < 60) {{
+                    // Tiro supersônico
+                    shot = team2.shootSupersonic(p2PosX, -1);
+                }} else {{
+                    // Tiro normal
+                    shot = team2.shoot(p2PosX, -1);
+                }}
+
+                if (shot != null) {{
+                    // Garantir que a altitude do projétil não exceda o campo de batalha
+                    shot.posY = Math.min(shot.posY, battlefieldHeight - 1);
+                    projectiles.add(shot);
+                }}
+            }}
+
+            // 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
+
+            // Mover projéteis e verificar colisões
+            Iterator<Projectile> iterator = projectiles.iterator();
+            while (iterator.hasNext()) {{
+                Projectile p = iterator.next();
+                p.move();
+
+                // Verificar colisões com Time 1
+                if (p.posX == p1PosX && p.posY == team1.getPositionY()) {{
+                    int damage = 0;
+
+                    // Verificar se o projétil tem poder personalizado
+                    if (p.getPower() > 0) {{
+                        damage = p.getPower();
+                    }} else if (p.symbol.contains("<[=-")) {{ // Míssil nuclear do Time 2
+                        damage = team2.nuclearPower * 2;
+                        System.out.println("💥💥💥 MÍSSIL NUCLEAR do Time 2 atingiu o Time 1!");
+                    }} else if (p.symbol.contains("⇇")) {{ // Tiro duplo do Time 2
+                        damage = team2.doubleShotPower;
+                    }} else if (p.symbol.equals("<=")) {{
+                        damage = team2.missilePower;
+                    }} else if (p.symbol.equals("<<")) {{
+                        damage = team2.supersonicPower;
+                    }} else {{
+                        damage = team2.shotPower;
+                    }}
+
+                    if (random.nextInt(100) >= team1.stealthChance) {{
+                        team1.takeDamage(damage);
+                        System.out.println("💥 Aeronave do Time 1 atingida! -" + damage + " pontos");
+                    }} else {{
+                        System.out.println("👻 Aeronave do Time 1 esquivou!");
+                        if (team1.radar > 0) {{
+                            System.out.println("📡 Radar do Time 1 detectou o projétil!");
+                        }}
+                    }}
+                    iterator.remove();
+                    continue;
+                }}
+
+                // Verificar colisões com Time 2
+                if (p.posX == p2PosX && p.posY == team2.getPositionY()) {{
+                    int damage = 0;
+
+                    // Verificar se o projétil tem poder personalizado
+                    if (p.getPower() > 0) {{
+                        damage = p.getPower();
+                    }} else if (p.symbol.contains("-]=>")) {{ // Míssil nuclear do Time 1
+                        damage = team1.nuclearPower * 2;
+                        System.out.println("💥💥💥 MÍSSIL NUCLEAR do Time 1 atingiu o Time 2!");
+                    }} else if (p.symbol.contains("⇉")) {{ // Tiro duplo do Time 1
+                        damage = team1.doubleShotPower;
+                    }} else if (p.symbol.equals("=>")) {{
+                        damage = team1.missilePower;
+                    }} else if (p.symbol.equals(">>")) {{
+                        damage = team1.supersonicPower;
+                    }} else {{
+                        damage = team1.shotPower;
+                    }}
+
+                    if (random.nextInt(100) >= team2.stealthChance) {{
+                        team2.takeDamage(damage);
+                        System.out.println("💥 Aeronave do Time 2 atingida! -" + damage + " pontos");
+                    }} else {{
+                        System.out.println("👻 Aeronave do Time 2 esquivou!");
+                        if (team2.radar > 0) {{
+                            System.out.println("📡 Radar do Time 2 detectou o projétil!");
+                        }}
+                    }}
+                    iterator.remove();
+                    continue;
+                }}
+
+                // Remover projéteis fora dos limites
+                if (p.isOutOfBounds(screenWidth)) {{
+                    iterator.remove();
+                    continue;
+                }}
+
+                // Mostrar projéteis no campo de batalha com cores
+                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]

requirements.txt

@@ -0,0 +1 @@
+gradio==4.44.0