K4B

package pk;
//este robo tenta acerta o robo inimigo baseado na velocidade e na Distancia, enquanto desvia do disparo adversario
import java.awt.Color;
import java.awt.geom.Point2D;

import robocode.AdvancedRobot;
import robocode.BattleEndedEvent;
import robocode.BulletHitBulletEvent;
import robocode.BulletHitEvent;
import robocode.BulletMissedEvent;
import robocode.DeathEvent;
import robocode.HitByBulletEvent;
import robocode.HitRobotEvent;
import robocode.HitWallEvent;
import robocode.RobotDeathEvent;
import robocode.ScannedRobotEvent;
import robocode.WinEvent;
import robocode.util.Utils;

public class Cabecadepika extends AdvancedRobot {
	// Estas são constantes. Uma vantagem disso é que a lógica neles (como 20-3 * BULLET POWER)
	// não usa o espaço de códigos, tornando-os mais baratos do que colocar a lógica no código real.
		final static double BULLET_POWER=3;//Our bulletpower.
		final static double BULLET_DAMAGE=BULLET_POWER*4;//Formula for bullet damage.
		final static double BULLET_SPEED=20-3*BULLET_POWER;//Formula for bullet speed.

		//variavel
		static double dir=1;
		static double oldEnemyHeading;
		static double enemyEnergy;



	boolean correLadrao = true;
	double previousEnergy = 100;
	int movementDirection = 1;

	// Quando a batalha começar, execute as instruções abaixo
	@Override
	public void run() {

		// BODY => Corpo => Move para frente, trás, gira para a esquerda e
		// direita
		// GUN => Arma => Responsável por realizar os disparos, gira para
		// esquerda e direita
		// RADAR => Localiza os inimigos, gira para esquerda e direita
		// SCAN => Varredura
		// BULLET => Bala
		// TURN => Virar
		// RIGHT => Direita
		// LEFT => Esquerda

		// Cor da arma do robô
		setGunColor(new Color(255, 0, 0));
		// Cor do radar do robô
		setRadarColor(new Color(0, 0, 0));
		// Cor do corpo do robô
		setBodyColor(new Color(0, 0, 0));
		// Cor do scanner do robô
		setScanColor(new Color(42, 0, 255));
		// Cor da bala do robô
		setBulletColor(new Color(255, 255, 255));


		// CADA PARTE DO ROBÔ SE MOVE LIVREMENTE
		setAdjustRadarForRobotTurn(true);
		setAdjustGunForRobotTurn(true);
		setAdjustRadarForGunTurn(true);




		while(true){
			turnRadarLeft(360);
			setAhead(200);
			turnRight(300);
			execute();
		}
	}

	// Quando o roboInimigo for detectado
	@Override
	public void onScannedRobot(ScannedRobotEvent e) {
		//tenta prever onde o robo inimigo vai estar



		double absBearing=e.getBearingRadians()+getHeadingRadians();

		// Isso faz com que a quantidade que queremos se torne perpendicular ao inimigo.
		double turn=absBearing+Math.PI/2;

		// Esta fórmula é usada porque o 1 / e.getDistance () significa que, à medida que nos aproximarmos do inimigo, nos voltaremos mais rapidamente para eles.
		// Queremos fazer isso porque reduz nossas chances de ser derrotado antes de alcançar o robô inimigo.
		turn-=Math.max(0.5,(1/e.getDistance())*100)*dir;

		setTurnRightRadians(Utils.normalRelativeAngle(turn-getHeadingRadians()));



		// Encontrando a mudança de título e título.
		double enemyHeading = e.getHeadingRadians();
		double enemyHeadingChange = enemyHeading - oldEnemyHeading;
		oldEnemyHeading = enemyHeading;

		/* Este método de segmentação é conhecido como segmentação circular; você assume que seu inimigo irá
		* continue movendo-se com a mesma velocidade e taxa de rotação que ele está usando no horário de incêndio.
		* código base vem do wiki.
		*/
		double deltaTime = 0;
		double predictedX = getX()+e.getDistance()*Math.sin(absBearing);
		double predictedY = getY()+e.getDistance()*Math.cos(absBearing);
		while((++deltaTime) * BULLET_SPEED <  Point2D.Double.distance(getX(), getY(), predictedX, predictedY)){

			// Adicione o movimento que pensamos que nosso inimigo fará aos nossos inimigos atuais X e Y
			predictedX += Math.sin(enemyHeading) * e.getVelocity();
			predictedY += Math.cos(enemyHeading) * e.getVelocity();


			// Encontre as mudanças de cabeçalho do seu inimigo.
			enemyHeading += enemyHeadingChange;

			// Se as nossas coordenadas previstas estão fora das paredes, coloque-as a 18 unidades de distância longe das paredes, como sabemos
			// que é o mais próximo que podem chegar à parede (os Bots não são roatentos 36 * 36 quadrados).
			predictedX=Math.max(Math.min(predictedX,getBattleFieldWidth()-18),18);
			predictedY=Math.max(Math.min(predictedY,getBattleFieldHeight()-18),18);

		}
		// Encontre o porte de nossas coordenadas projetadas de nós.
		double aim = Utils.normalAbsoluteAngle(Math.atan2(  predictedX - getX(), predictedY - getY()));

		// Apontar e disparar.
		setTurnGunRightRadians(Utils.normalRelativeAngle(aim - getGunHeadingRadians()));
		setFire(BULLET_POWER);

		setTurnRadarRightRadians(Utils.normalRelativeAngle(absBearing-getRadarHeadingRadians())*2);

	//tenta desvia das balas

		// Mantenha-se em ângulo reto para o oponente
	     setTurnRight(e.getBearing()+90 + 30*movementDirection);

	           // Se o bot tiver uma pequena queda de energia,
	          // assuma que disparou
		    double changeInEnergy =previousEnergy-e.getEnergy();


		    if (changeInEnergy > 0 &&changeInEnergy <= 3) {
		         // esquivar!
		         movementDirection =-movementDirection;
		         setAhead((e.getDistance()/4+25)-movementDirection);
		     }

		 // Rastreie o nível de energia
		    previousEnergy = e.getEnergy();

		  }

	// Quando o seu robô bater com o outro
	@Override
	public void onHitRobot(HitRobotEvent e) {
		   saidaFrente();
		   tiroMortal(e.getBearing(), e.getEnergy(), getEnergy());

	    }
	//método para sair das paredes e colisão com robos
	public void saidaFrente() {
		if (this.correLadrao) {
			setBack(500);
			this.correLadrao = false;
		} else {
			setAhead(150);
			this.correLadrao = true;
		}
	}


	    public void tiroMortal(double dist, double energiaIni, double minhaEnergia) {

	  	  double Coordenadas = getHeading() + dist - getGunHeading();

	  	  double PontoQuarenta = (energiaIni / 4) + .1;

	  	  if (!(Coordenadas > -180 && Coordenadas <= 180)) {
	  	     while (Coordenadas <= -180) {
	  	        Coordenadas += 360;
	  		 }
	  		 while (Coordenadas > 180) {
	  	        Coordenadas -= 360;
	  	     }
	  	  }

	  	  turnGunRight(Coordenadas);
	  	  fire(PontoQuarenta);

	     }

	//É executado quando seu robô colide com a parede
	public void onHitWall(HitWallEvent e) {
		 saidaFrente();
	   }



	// É executado quando seu tiro acerta um adversário
	@Override
	public void onBulletHit(BulletHitEvent event) {

	}

	// É executado quando uma de suas balas colide com outra bala
	@Override
	public void onBulletHitBullet(BulletHitBulletEvent event) {

	}

	// É executado quando uma de suas balas colide com a parede(erra o tiro)
	@Override
	public void onBulletMissed(BulletMissedEvent event) {

	}

	// É executado se seu robô morrer
	@Override
	public void onDeath(DeathEvent event) {

	}

	// É executado quando seu robô leva um tiro
	@Override
	public void onHitByBullet(HitByBulletEvent e) {

	}

	// É executado quando morre um adversário
	@Override
	public void onRobotDeath(RobotDeathEvent event) {

	}

	// É executado quando seu robô ganha o round
	@Override
	public void onWin(WinEvent event) {

	}

	// Evento disparado quando uma rodada ou batalha é finalizada,
	// respectivamente
	@Override
	public void onBattleEnded(BattleEndedEvent event) {

	}
}