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:

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;
    }
}

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

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);
    }
}

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.

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
    }
}