Radar

The radar is one of the most vital components of your robot. Without it, targeting is effectively impossible and movement is purely random. Just as with movement and targeting, there are many simple and complex algorithms for radar control. In most robots the radar takes up the smallest portion of code.

In robots that do a lot of processing, it is best to place the radar code near the beginning of the processing loop for each tick, as this will allow the radar to avoid slipping if the robot skips a turn due to too much processing.

Technical Information

A radar in Robocode has a maximum of 45° or π/4^rad in a single tick. The radar can scan robots up to 1200 units away. The angle the radar rotates between two ticks creates a radar arc, and every robot detected within the arc is sent to the onScannedRobot() method in order of distance from the scanning bot - the closest bot is detected first, while the furthest bot is detected last. By default, the onScannedRobot() method has the lowest event priority of all the event handlers in Robocode, so it is the last one to be triggered each tick.

1-vs-1 Radars

1-vs-1 radars are the smallest of the bunch and many can get a scan in every turn, producing a perfect lock.

Spinning radar

A simple spin of the radar, this is very ineffective in one on one, but still used in NanoBots.

Here is an example of this type of radar:

public void run() {
    // ...

    do {
        turnRadarRightRadians(Double.POSITIVE_INFINITY);
    } while (true);
}

The infinity lock

The infinity lock is the simplest radar lock and it is used frequently in NanoBots. It has the disadvantage of "slipping" and losing its lock frequently.

Here is an example of this type of radar:

public void run() {
    // ...
    turnRadarRightRadians(Double.POSITIVE_INFINITY);
}

public void onScannedRobot(ScannedRobotEvent e) {
    // ...
    setTurnRadarLeftRadians(getRadarTurnRemainingRadians());
}

Perfect radar locks

There are several "perfect" radar locks that will not slip once they have a lock.

Narrow lock

Point the radar at the enemy's last known location. This results in a thin beam which follows the enemy around the battlefield. It works because most of the time, the enemy isn't able to move entirely outside our radar beam in the space of a single turn. This might not be true in some extreme cases, and radar lock can occasionally be lost.

Here is an example of this kind of radar:

import robocode.util.Utils;

public void run() {
    // ...

    turnRadarRightRadians(Double.POSITIVE_INFINITY);
    do {
        scan();
    } while (true);
}

public void onScannedRobot(ScannedRobotEvent e) {
    double absoluteBearing = getHeadingRadians() + e.getBearingRadians();
    double radarTurn = absoluteBearing - getRadarHeadingRadians();
    setTurnRadarRightRadians(Utils.normalRelativeAngle(radarTurn));

    // ...
}

Wide lock

The wide radar locks are used to avoid the rare slipping of the narrow lock. They scan a wider portion of the battlefield and will not slip. This type of lock is generally the largest of the 1-vs-1 radars.

Here is an example of this type of radar:

import robocode.util.Utils;

public void run() {
    // ...

    while(true) {
        turnRadarRightRadians(Double.POSITIVE_INFINITY);
    }
}

public void onScannedRobot(ScannedRobotEvent e) {
    double absoluteBearing = getHeadingRadians() + e.getBearingRadians();
    double radarTurn = Utils.normalRelativeAngle(absoluteBearing - getRadarHeadingRadians());

    // Width of the bot, plus twice the arc it can move in a tick, limit it to the max turn
    double arcToScan = Math.min(Math.atan(36.0 / e.getDistance()), PI/4.0);

    // We want to sent the radar even further in the direction it's moving
    radarTurn += (radarTurn < 0) ? -arcToScan : arcToScan;
    setTurnRadarRightRadians(radarTurn);

    // ...
}

Melee radars

Melee radars are more complex and take up considerable more room inside a robot. Since the field of opponents does not usually fall within a 45° area, compromises must be made between frequent data of one bot (e.g., the firing target) and consistently updated data of all bots.

Spinning radar

Just as with one on one, there is the generic spinning radar. This is the most used melee radar as it is by far the easiest to implement.

public void run() {
    // ...

    do {
        turnRadarRightRadians(Double.POSITIVE_INFINITY);
    } while (true);
}

Corner Arc

A variation on the spinning radar, if the robot is in a corner it scans back and forth across the 90 degree arc away from the corner, as not to waste time scanning where there cannot be any robots.

Oldest Scanned

This type of melee radar spins towards the robot it hasn't seen in the longest amount of time.

Notes

For most of these radar locks, you will need to add one of the following to your run() method:

setAdjustRadarForRobotTurn(true);
setAdjustGunForRobotTurn(true);
setAdjustRadarForGunTurn(true);