====== Tracking ======

Für viele Techniken ist es wichtig, Informationen über die Roboter zu haben. Dazu werden die Informationen, welche beim Scannen der Roboter mittels <javadoc robocode>robocode.Robot#onScannedRobot(robocode.ScannedRobotEvent)|onScannedRobot()</javadoc> anfallen, in geeigneter Weise zwischengespeichert.

Die Klasse ''EnemyRobot'' speichert die Information (Position) eines Roboters:

<code java>
import robocode.*;
import robocode.util.*;

public class EnemyRobot
{
    private Robot ownRobot;
    private String name;
    private double velocity;
    private double x;
    private double y;

    public EnemyRobot(Robot ownRobot, String name) {
        this.ownRobot = ownRobot;
        this.name = name;
    }

    public void update(ScannedRobotEvent e) {
        double headingToRobot = ownRobot.getHeading() + e.getBearing();
        velocity = e.getVelocity();
        x = ownRobot.getX() + e.getDistance() * Math.sin(Math.toRadians(headingToRobot));
        y = ownRobot.getY() + e.getDistance() * Math.cos(Math.toRadians(headingToRobot));
    }

    public double getDistance() {
        double dx = x - ownRobot.getX();
        double dy = y - ownRobot.getY();
        return Math.sqrt(dx*dx + dy*dy);
    }

    public double getHeading() {
        return Utils.normalAbsoluteAngleDegrees(Math.toDegrees(Math.atan2(x - ownRobot.getX(), y - ownRobot.getY())));
    }

    public String getName() {
        return name;
    }

    public double getVelocity() {
        return velocity;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }
}
</code>

Die Klasse ''EnemyTracker'' führt eine Liste aller bekannten Roboter und aktualisiert diese.

<code java>
import java.util.*;
import robocode.*;

public class EnemyTracker
{
    private Map<String, EnemyRobot> enemies;
    private Robot ownRobot;

    public EnemyTracker(Robot ownRobot) {
        enemies = new HashMap<String, EnemyRobot>();
        this.ownRobot = ownRobot;
    }

    // Idea by Michael Marti
    public EnemyRobot getClosestEnemy() {
        EnemyRobot closest = null;
        for (EnemyRobot enemy : getEnemies()) {
            if (closest == null || enemy.getDistance() < closest.getDistance()) {
                closest = enemy;
            }
		}

        return closest;
    }

    public Collection<EnemyRobot> getEnemies() {
        return enemies.values();
    }

    public void update(ScannedRobotEvent e) {
        if (!enemies.containsKey(e.getName())) {
            // Gegner noch nicht bekannt
            enemies.put(e.getName(), new EnemyRobot(ownRobot, e.getName()));
        }

        enemies.get(e.getName()).update(e);
    }
}
</code>

Im eigenen Roboter wird ein ''EnemyTracker''-Objekt erzeugt. Bei jedem Aufruf von <javadoc robocode>robocode.Robot#onScannedRobot(robocode.ScannedRobotEvent)|onScannedRobot()</javadoc> wird die ''update()''-Methode des ''EnemyTracker'' aufgerufen.

<code java>
public class MyRobot extends Robot {

    private EnemyTracker enemyTracker;

    public void run() {
        enemyTracker = new EnemyTracker(this);
        // Weitere Aktionen
    }
    
    public void onScannedRobot(ScannedRobotEvent e) {
        enemyTracker.update(e);
        // Weitere Aktionen
    }
}
</code>