Zoom Radar
Zoom radar is a precise lock radar with a minimum cost feature for melee. Created by Frolicking Zombie.
| Mathematics | Explanation |
|---|---|
| RoboCode Java | |
|
<MATH>\angle\text{targetHeading} = \tan ^{-1}\left(\frac{\text{targetY}-\text{myY}}{\text{targetX}-\text{myX}}\right)</MATH>
|
Find the last known heading to the target and then our radar's bearing to that heading. Robocode trigonometry has <MATH>\tan \theta = \frac{\cos \theta}{\sin \theta}</MATH> |
double targetHeading = Math.atan2(targetX - myX, targetY – myY);
double radarBearing = getRadarHeadingRadians() - targetHeading;
while(radarBearing <= -Math.Pi) {
radarBearing += 2 * Math.PI;
}
while(radarBearing > Math.Pi) {
radarBearing -= 2 * Math.PI;
}
|
|
|
<MATH>\text{targetError} = (\text{currentTime} - \text{lastScanTime} + 1)\times 8 + 18</MATH>
|
Calculate the maximum distance the enemy can possibly move according to the physics. |
double targetError = (currentTime - targetLastScan + 1) * 8 + 18;
double targetErrorFinal = targetError + 8
|
|
|
<MATH>\text{targetDistance} = \sqrt{(\text{targetX} - \text{myX})^2+(\text{targetY}-\text{myY})^2}</MATH>
|
Standard Euclidean distance formula for our distance to target. |
double targetDistance = Math.sqrt(
(targetX - myX) * (targetX - myX) + (targetY - myY) * (targetY - myY)
);
double targetDistanceFinal = targetDistance + 8;
|
|
|
<MATH>\text{x = }\pm \frac{1}{2} \sqrt{4 \text{targetError}^2-\frac{\text{targetError}^4}{\text{targetDistance}^2}}</MATH>
|
The maximum angle that the enemy could have traveled is the intersection of the targetError and targetDistance circles. |
double x = Math.sqrt(
targetError * targetError - (targetError * targetError * targetError * targetError)
/ (targetDistance * targetDistance)) / 2;
double y = (2 * targetDistance * targetDistance - targetError * targetError)
/ (2 * targetDistance);
|
|
|
<MATH>\angle\theta = \tan ^{-1}\left(\frac{x}{y}\right)</MATH> |
Calculate the maximum bearing that the enemy could have traveled. This is our bounding bearing range. |
double thetaBounding = Math.atan2(y,x);
|
|
|
<MATH>\text{x = }\pm \frac{1}{2} \sqrt{4 \text{targetErrorFinal}^2-\frac{\text{targetErrorFinal}^4}{\text{targetDistanceFinal}^2}}</MATH>
|
The maximum angle that the enemy could have traveled is the intersection of the targetErrorFinal and targetDistanceFinal circles. |
x = Math.sqrt(
targetErrorFinal * targetErrorFinal - (targetErrorFinal * targetErrorFinal * targetErrorFinal * targetErrorFinal)
/ (targetDistanceFinal * targetDistanceFinal)) / 2;
y = (2 * targetDistanceFinal * targetDistanceFinal - targetErrorFinal * targetErrorFinal)
/ (2 * targetDistanceFinal);
|
|
|
<MATH>\angle\theta = \tan ^{-1}\left(\frac{x}{y}\right)</MATH> |
Calculate the maximum bearing that the enemy may travel after our next turn. This is our final bearing range. |
double thetaFinal = Math.atan2(y,x);
|
|
  | Graphic explanation of mathematics. |
When the radar's bearing is between the thetaBounding and thetaFinal bearings, this signals the completion of the scan in the corresponding direction. The scan direction should be reversed to (re)cover the target area. When a target has been scanned, the radar must reverse direction to ensure a scan on the next subsequent turn. This enables a precision lock on the target. The variable lastScanDirection should be initialized with the value that corresponds to the direction (1 = CW, -1 = CCW) of the scan used to find all targets. The variable scanDirection should be initialized with 0 to force a new search. When initiating a new search, if it is determined that the CW and CCW scans will be equal, the direction of search should be the one that will scan the most targets along the path to the desired target.
// Bearings are negative in the CCW direction.
if(scanDirection == -1) {
// Check to see if we have completed our move.
if(radarBearing >= -thetaFinal && radarBearing <= -thetaBounding) {
// Should have scanned target by now. Resume in opposite direction
scanDirection = 1;
}
else {
// Continue in the CCW direction.
scanDirection = -1;
}
}
else if(scanDirection == 1) {
// Check to see if we have completed our move.
if(radarBearing <= thetaFinal && radarBearing >= thetaBounding) {
// Should have scanned target by now. Resume in opposite direction
scanDirection = -1;
}
else {
// Continue in the CW direction.
scanDirection = 1;
}
}
// Set scanDirection = 0 if we just scanned the target we were looking for so that we can continue scanning in the most manner.
else {
// Check to see if we are within bounds.
if(radarBearing >= -thetaBounding && radarBearing <= thetaBounding) {
// Start scanning in the opposite direction to ensure that we scan the target on this turn.
scanDirection = lastScanDirection * -1;
}
// Check to see if the CW bound is closer.
else if(Math.abs(thetaFinal - radarBearing) < Math.abs((-thetaFinal) - radarBearing)) {
// Scan in the CCW direction ending at the CCW bound.
scanDirection = -1;
}
// Check to see if the CCW bound is closer.
else if(Math.abs(thetaFinal - radarBearing) > Math.abs((-thetaFinal) - radarBearing)) {
// Scan in the CW direction ending at the CW bound.
scanDirection = 1;
}
// Both bounds are equal.
else {
// Add code here....
// Just count the number of targets you expect to scan along the CW and CCW directions and start scanning in the most advantageous direction.
if(targetsCW >= targetsCCW) {
scanDirection = 1;
}
else {
scanDirection = -1;
}
}
}
setTurnRadarRightRadians((scanDirection * thetaFinal) – radarBearing);
lastScanDirection = scanDirection;
If <MATH>2 \times \text{targetDistanceFinal} < \text{targetErrorFinal}</MATH> then it will be impossible to resolve bearings that the target may not be at. It is best to continue scanning in the same direction as previous, but with no bounds.
if(2 * targetDistanceFinal < targetErrorFinal) {
scanDirection = lastScanDirection;
setTurnRadarRightRadians(scanDirection * 2* Math.PI);
}
