Pomoc w udoskonaleniu robota- Robocode

Mam takiego robota. Wiekszosc na podstawie tutoriali, niestety nie mam pomyslu na to jak mialby sie poruszac. Gdybyscie mogli pomoc, bylbym wdzieczny

package pg;
import robocode.*;
import java.awt.Color;

import java.awt.geom.Point2D;

/**
 * Die_suckers - a robot by (Przemek)
 */
public class Die_suckers extends AdvancedRobot {
	private byte moveDirection = 1;
	private int tooCloseToWall = 10;
	public void onHitWall(HitWallEvent e) { moveDirection *= -1; }
	public void onHitRobot(HitRobotEvent e) { moveDirection *= -1; }
	private AdvancedEnemyBot enemy = new AdvancedEnemyBot();
	
	public void run() {
		
		setAdjustRadarForRobotTurn(true);
		enemy.reset();
		
		setBodyColor(new Color(255, 0, 0));
		setGunColor(new Color(255, 255, 255));
		setRadarColor(new Color(255, 0, 0));
		setBulletColor(new Color(255, 255, 100));
		setScanColor(new Color(255, 200, 200));
		
		while(true) {
			
			int i=0;
			if (i == 0) { 
				turnRadarRight(360);
				i++;
			 }
			
			//ahead(100);
			//setTurnRadarRight(360);
			
			doMove();
			//execute();

		}
	}

	public void doMove() {		
		// always square off against our enemy, turning slightly toward him
		setTurnRight(enemy.getBearing() + 90 - (10 * moveDirection));

		// if we're close to the wall, eventually, we'll move away
		if (tooCloseToWall > 0) tooCloseToWall--;

		// normal movement: switch directions if we've stopped
		if (getVelocity() == 0) {
		moveDirection *= -1;
		setAhead(100 * moveDirection);
		}
	//execute();
	}

	public void onScannedRobot(ScannedRobotEvent e) {
		if ( enemy.none() || e.getDistance() < enemy.getDistance() - 70 ||
			e.getName().equals(enemy.getName())) {
			enemy.update(e, this);}
			
		double firePower = Math.min(500 / enemy.getDistance(), 3);
		double bulletSpeed = 20 - firePower * 3;
		long time = (long)(enemy.getDistance() / bulletSpeed);	

		// calculate gun turn to predicted x,y location
		double futureX = enemy.getFutureX(time);
		double futureY = enemy.getFutureY(time);
		double absDeg = absoluteBearing(getX(), getY(), futureX, futureY);
		
		// turn the gun to the predicted x,y location
		setTurnGunRight(normalizeBearing(absDeg - getGunHeading()));
		setTurnRadarRight((getHeading() + e.getBearing() - getRadarHeading()) * 1.6);

		//setTurnRadarRight(getHeading() - getRadarHeading() + e.getBearing());			
		if (getGunHeat() == 0 && Math.abs(getGunTurnRemaining()) < 30)
		setFire(Math.min(400 / enemy.getDistance(), 3));

		
		//execute();
			
	}


	/**
	 * onHitByBullet: What to do when you're hit by a bullet
	 */
	public void onHitByBullet(HitByBulletEvent e) {
		turnLeft(90 - e.getBearing());
	}

	public void onRobotDeath(RobotDeathEvent e) {
		if (e.getName().equals(enemy.getName())) 
		enemy.reset();
	}
	
	// normalizes a bearing to between +180 and -180
	double normalizeBearing(double angle) {
		while (angle >  180) angle -= 360;
		while (angle < -180) angle += 360;
	return angle;
	}
	
	// computes the absolute bearing between two points
	double absoluteBearing(double x1, double y1, double x2, double y2) {
		double xo = x2-x1;
		double yo = y2-y1;
		double hyp = Point2D.distance(x1, y1, x2, y2);
		double arcSin = Math.toDegrees(Math.asin(xo / hyp));
		double bearing = 0;

		if (xo > 0 && yo > 0) { // both pos: lower-Left
			bearing = arcSin;
		} else if (xo < 0 && yo > 0) { // x neg, y pos: lower-right
			bearing = 360 + arcSin; // arcsin is negative here, actuall 360 - ang
		} else if (xo > 0 && yo < 0) { // x pos, y neg: upper-left
			bearing = 180 - arcSin;
		} else if (xo < 0 && yo < 0) { // both neg: upper-right
			bearing = 180 - arcSin; // arcsin is negative here, actually 180 + ang
		}
	return bearing;
	}	

	
}

Klasa AdvancedEnemyBot:

package pg;

import robocode.*;

/**
 * AdvancedEnemyBot - a class by (Przemek)
 */

public class AdvancedEnemyBot extends EnemyBot {
    private double x, y;

    public AdvancedEnemyBot() {
        this.reset();
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }

    public void update(ScannedRobotEvent e, Robot robot) {
        super.update(e);
       
        double absBearingDeg = (robot.getHeading() + e.getBearing());
       
        if (absBearingDeg < 0) {
            absBearingDeg += 360;
        }
       
        x = robot.getX() + Math.sin(Math.toRadians(absBearingDeg)) * e.getDistance();
       
        y = robot.getY() + Math.cos(Math.toRadians(absBearingDeg)) * e.getDistance();
    }

    public double getFutureX(long when) {
        return x + Math.sin(Math.toRadians(getHeading())) * getVelocity() * when;
    }

    public double getFutureY(long when) {
        return y + Math.cos(Math.toRadians(getHeading())) * getVelocity() * when;
    }

    public void reset() {
        super.reset();
        x = 0;
        y = 0;
    }

}

Klasa EnemyBot:

package pg;
import robocode.*;

/**
 * EnemyBot - a class by (Przemek)
 */

public class EnemyBot {
    private double bearing, distance, energy, heading, velocity;
    private String name;

    public EnemyBot() {
        reset();
    }

    public double getBearing() {
        return bearing;
    }
	
	double normalizeBearing(double angle) {
	while (angle >  180) angle -= 360;
	while (angle < -180) angle += 360;
	return angle;
	}

	
    public double getDistance() {
        return distance;
    }

    public double getEnergy() {
        return energy;
    }

    public double getHeading() {
        return heading;
    }

    public double getVelocity() {
        return velocity;
    }

    public String getName() {
        return name;
    }

    public void update(ScannedRobotEvent srEvt) {
        bearing = srEvt.getBearing();
        distance = srEvt.getDistance();
        energy = srEvt.getEnergy();
        heading = srEvt.getHeading();
        velocity = srEvt.getVelocity();
        name = srEvt.getName();
    }

    public void reset() {
        bearing = 0.0;
        distance = 0.0;
        energy = 0.0;
        heading = 0.0;
        velocity = 0.0;
        name = "";
    }

    public boolean none() {
        return name.length() == 0;
    }
}