Difference between revisions of "Radar"

From Robowiki
Jump to navigation Jump to search
(miscellaneous cleanup)
(fixing a few name, shortening wide lock code a bit)
Line 61: Line 61:
 
public void onScannedRobot(ScannedRobotEvent e) {
 
public void onScannedRobot(ScannedRobotEvent e) {
 
     double absoluteBearing = getHeadingRadians() + e.getBearingRadians();
 
     double absoluteBearing = getHeadingRadians() + e.getBearingRadians();
 
 
     double radarTurn = absoluteBearing - getRadarHeadingRadians();
 
     double radarTurn = absoluteBearing - getRadarHeadingRadians();
 
     setTurnRadarRightRadians(Utils.normalRelativeAngle(radarTurn));
 
     setTurnRadarRightRadians(Utils.normalRelativeAngle(radarTurn));
Line 70: Line 69:
  
 
==== Wide lock ====
 
==== Wide lock ====
The wide radar locks are used to avoid the rare slipping of the thin 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.
+
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:
 
Here is an example of this type of radar:
 
<pre>
 
<pre>
 
import robocode.util.Utils;
 
import robocode.util.Utils;
 
private int ticksSinceLastScan = 0;
 
  
 
public void run() {
 
public void run() {
 
     // ...
 
     // ...
  
     do {
+
     while(true) {
        if (ticksSinceLastScan++ > 2) {
+
        turnRadarRightRadians(Double.POSITIVE_INFINITY);
            setTurnRadarRightRadians(Double.POSITIVE_INFINITY);
+
     }
        }
 
 
 
        execute();
 
     } while (true);
 
 
}
 
}
  
Line 94: Line 87:
 
     double radarTurn = Utils.normalRelativeAngle(absoluteBearing - getRadarHeadingRadians());
 
     double radarTurn = Utils.normalRelativeAngle(absoluteBearing - getRadarHeadingRadians());
  
     // Width of the bot, plus twice the arc it can move in a tick
+
     // Width of the bot, plus twice the arc it can move in a tick, limit it to the max turn
     double arcToScan = atan(36.0 / e.getDistance());
+
     double arcToScan = Math.min(Math.atan(36.0 / e.getDistance()), PI/4.0);
 
 
    // Limit this so that we don't overshoot
 
    if (arcToScan > PI / 4.0) arcToScan = PI / 4.0;
 
  
 
     // We want to sent the radar even further in the direction it's moving
 
     // We want to sent the radar even further in the direction it's moving
 
     radarTurn += (radarTurn < 0) ? -arcToScan : arcToScan;
 
     radarTurn += (radarTurn < 0) ? -arcToScan : arcToScan;
 
     setTurnRadarRightRadians(radar);
 
     setTurnRadarRightRadians(radar);
 
    ticksSinceLastScan = 0;
 
  
 
     // ...
 
     // ...

Revision as of 15:38, 12 November 2007

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 π/4rad in a single tick. The distance moved between two ticks creates a radar arc. The radar scans a distance of 1200. 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

This type of lock is thin and follows the robot around the battlefield.

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(radar);

    // ...
}

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