Clique aqui e veja todas as aulas

Detectando as Bordas da Arena

No calor da batalha, é fácil para um robô se empolgar e acabar esbarrando nas paredes. Mas não se preocupe, vamos ensinar seu robô a identificar os limites da arena e evitar esses constrangimentos robóticos.

1. Entendendo as Coordenadas da Arena

• A arena no Robocode é um espaço bidimensional, onde cada ponto tem uma coordenada X (horizontal) e Y (vertical).
• O ponto (0,0) está no canto inferior esquerdo, enquanto o ponto máximo está no canto superior direito, dependendo do tamanho da arena.

2. Obtendo a Posição Atual do Robô

Use os métodos a seguir para saber onde seu robô está:

• getX(): Retorna a posição X atual do robô.
• getY(): Retorna a posição Y atual do robô.

Exemplo:

double posX = getX();
double posY = getY();

3. Conhecendo o Tamanho da Arena

Para obter as dimensões da arena:

• getBattleFieldWidth(): Retorna a largura da arena.
• getBattleFieldHeight(): Retorna a altura da arena.

Exemplo:

double largura = getBattleFieldWidth();
double altura = getBattleFieldHeight();

Técnicas para Não Ficar Preso nas Paredes

Agora que seu robô sabe onde está e o tamanho da arena, podemos programá-lo para evitar as paredes.

1. Definindo uma Margem de Segurança

Estabeleça uma distância mínima das bordas para que seu robô não chegue muito perto das paredes.

Exemplo:

double margem = 50; // Margem de segurança de 50 pixels

2. Verificando a Proximidade das Bordas

Antes de avançar, faça seu robô verificar se a movimentação o levará muito perto da parede.

Exemplo:

public void run() {
    while (true) {
        if (pertoDaParede()) {
            virarParaCentro();
        }
        ahead(100);
    }
}
public boolean pertoDaParede() {
    double margem = 50;
    double posX = getX();
    double posY = getY();
    double largura = getBattleFieldWidth();
    double altura = getBattleFieldHeight();
    return (posX <= margem || posX >= largura - margem || posY <= margem || posY >= altura - margem);
}

3. Virando o Robô para o Centro da Arena

Se o robô estiver perto da parede, podemos fazê-lo virar em direção ao centro para evitar colisões.

Exemplo:

public void virarParaCentro() {
    double centroX = getBattleFieldWidth() / 2;
    double centroY = getBattleFieldHeight() / 2;
    double anguloParaCentro = Math.toDegrees(Math.atan2(centroX - getX(), centroY - getY()));
    double anguloAjuste = anguloParaCentro - getHeading();
    turnRight(normalizarAngulo(anguloAjuste));
}
public double normalizarAngulo(double angulo) {
    while (angulo <= -180) angulo += 360;
    while (angulo > 180) angulo -= 360;
    return angulo;
}

Programando Movimentos Seguros

Além de evitar paredes, é importante que o robô se mova de forma inteligente para escapar de situações complicadas.

1. Movimentos Aleatórios dentro de Limites Seguros

Faça o robô se mover aleatoriamente, mas sempre dentro de uma margem segura das paredes.

Exemplo:

import java.util.Random;
public void run() {
    Random random = new Random();
    double margem = 50;
    while (true) {
        double destinoX = margem + (getBattleFieldWidth() - 2 * margem) * random.nextDouble();
        double destinoY = margem + (getBattleFieldHeight() - 2 * margem) * random.nextDouble();
        moverPara(destinoX, destinoY);
    }
}
public void moverPara(double x, double y) {
    double angulo = Math.toDegrees(Math.atan2(x - getX(), y - getY()));
    double anguloAjuste = angulo - getHeading();
    turnRight(normalizarAngulo(anguloAjuste));
    double distancia = Math.hypot(x - getX(), y - getY());
    ahead(distancia);
}
public double normalizarAngulo(double angulo) {
    while (angulo <= -180) angulo += 360;
    while (angulo > 180) angulo -= 360;
    return angulo;
}

2. Implementando Movimentos Ondulares

Movimentos ondulares podem dificultar que os inimigos acertem seu robô, e ajudam a evitar paredes.

Exemplo Simplificado:

public void run() {
    setTurnRight(90);
    setAhead(5000); // Move-se para frente por uma longa distância
    execute();
    while (true) {
        if (getVelocity() == 0) {
            setTurnRight(90);
            setAhead(5000);
            execute();
        }
    }
}

Desafios Práticos

Desafio 1: Melhore a função pertoDaParede() para considerar a direção que o robô está se movendo, evitando colisões antes que aconteçam.

Desafio 2: Crie um método que faça o robô seguir ao longo das paredes sem colidir com elas, podendo ser útil como estratégia evasiva.

Desafio 3: Combine a detecção de paredes com a detecção de inimigos para criar movimentos que evitem tanto as paredes quanto os ataques adversários.

Dicas para Movimentação Eficiente

• Antecipe as Paredes: Sempre verifique a posição antes de se mover.
• Use Margens Adequadas: Ajuste a margem de segurança de acordo com o comportamento desejado.
• Teste Diferentes Estratégias: O que funciona para um robô pode não funcionar para outro. Experimente!

Resumo da Aula

Nesta aula, aprendemos como evitar que nosso robô fique preso nas paredes e obstáculos da arena. Exploramos técnicas para detectar as bordas, implementamos movimentos seguros e garantimos que nosso robô se mova de forma inteligente durante as batalhas.

O que vem a seguir?

Na próxima aula, vamos abordar estratégias defensivas no Robocode. Aprenderemos como programar movimentos evasivos, minimizar danos e nos defender de ataques adversários. Prepare-se para tornar seu robô um mestre na arte da defesa!