LuminariousDuo/Code
Jump to navigation
Jump to search
- LuminariousDuo Sub-pages:
- LuminariousDuo - Version History - Code
This is the code for LuminariousDuo 1.0591. The teammate just extends Luminarious with no changes.
package voidious.team;
import robocode.*;
import robocode.util.Utils;
import java.util.HashMap;
import java.util.ArrayList;
import java.awt.geom.Point2D;
import java.awt.Color;
import java.io.Serializable;
import java.util.Random;
public class Luminarious extends TeamRobot {
protected static final double RADAR_TRACK_AMOUNT = Math.PI/4;
protected static Point2D.Double _myLocation;
protected static HashMap _enemyLocationsByName = new HashMap();
protected static Point2D.Double _teammateLocation;
protected ArrayList _recentLocations;
protected static Random _rand = new Random();
protected String _lastEnemySeen;
protected static long _scanReversalTick;
protected static int _radarDirection = 1;
protected static double _radarRangeTracker;
protected static double _lastRadarRangeTracker;
protected static java.awt.geom.Rectangle2D.Double _fieldRect;
protected int _teammatesAlive = 1;
/* For now, we are assuming our enemies will use the same or similar
* movement, which is probably pretty likely.
*/
protected static final double WAVE_BULLET_POWER = 1.9;
protected static final double WAVE_BULLET_VELOCITY = 14.3;
protected static final double WAVE_MAX_ESCAPE_ANGLE = 0.62;
protected static double _bulletPower;
static final int GF_ZERO = 18;
static final int GF_ONE = 36;
static long[][][][][] _gunStats = new long[2][3][4][5][GF_ONE+1];
protected double _targetDistance = Double.POSITIVE_INFINITY;
protected static String _targetName = "";
protected static double _randomDirChangeAmount;
protected long _timeSinceDirChangeCounter;
protected static double _lastHeading;
protected static double _enemyAbsoluteBearing;
protected static int _lastGunOrientation;
protected static double _lastDistance;
protected static double _lastBulletPower = 1;
protected static int _resumeRadarDirection = 1;
protected static boolean _tempRadarLock = false;
public void run() {
_fieldRect = new java.awt.geom.Rectangle2D.Double(30, 30,
getBattleFieldWidth() - 60, getBattleFieldHeight() - 60);
_recentLocations = new ArrayList();
setAdjustGunForRobotTurn(true);
setAdjustRadarForGunTurn(true);
setColors(Color.black, Color.black, new Color(80, 150, 80));
do {
try {
broadcastMessage(new LuminariLocation(getX(), getY()));;
} catch (Exception ex) { }
setTurnRadarRightRadians(RADAR_TRACK_AMOUNT * _radarDirection);
_radarRangeTracker += RADAR_TRACK_AMOUNT;
if (Math.abs(getGunTurnRemaining()) < 4) {
if (setFireBullet(_bulletPower) != null) {
_radarDirection = _resumeRadarDirection;
_tempRadarLock = false;
}
}
move();
execute();
} while (true);
}
public void onScannedRobot(ScannedRobotEvent e) {
String eName = e.getName();
double eDistance = _lastDistance = e.getDistance();
double eEnergy = e.getEnergy();
double eVelocity = e.getVelocity();
if (isTeammate(eName)) { return; }
////////////////////////////////////////////////
// General data stuff
////////////////////////////////////////////////
_enemyAbsoluteBearing = e.getBearingRadians() + getHeadingRadians();
double enemyLatVel = (e.getVelocity()) *
Math.sin(e.getHeadingRadians() - _enemyAbsoluteBearing);
if (!_enemyLocationsByName.containsKey(eName)) {
_enemyLocationsByName.put(eName, new EnemyData());
}
EnemyData eData = (EnemyData)_enemyLocationsByName.get(eName);
eData.name = eName;
eData.setLocation(project(_myLocation, _enemyAbsoluteBearing, eDistance));
double absSinRelativeHeading =
Math.abs(Math.sin(e.getHeadingRadians() - _enemyAbsoluteBearing));
eData.energy = eEnergy;
eData.heading = e.getHeadingRadians();
eData.velocity = eVelocity;
////////////////////////////////////////////////
// Radar
////////////////////////////////////////////////
if (_lastEnemySeen == null) {
_lastEnemySeen = eName;
}
if (getOthers() - _teammatesAlive == 1) {
_resumeRadarDirection = (_radarDirection *= -1);
} else if (
getGunHeat() <= (Math.min(Math.PI, _lastRadarRangeTracker) / 5) /
RADAR_TRACK_AMOUNT && _targetName.equals(eName)) {
_radarDirection *= -1;
if (!_tempRadarLock) {
_resumeRadarDirection = _radarDirection;
if (_radarRangeTracker > Math.PI) {
_resumeRadarDirection *= -1;
}
}
_tempRadarLock = true;
_radarRangeTracker = 0;
} else if (!_lastEnemySeen.equals(eName)) {
if (_radarRangeTracker <= Math.PI &&
_scanReversalTick != e.getTime()) {
_scanReversalTick = e.getTime();
_radarDirection *= -1;
_lastRadarRangeTracker = _radarRangeTracker;
}
_radarRangeTracker = 0;
}
_lastEnemySeen = eName;
////////////////////////////////////////////////
// Gun wave creation
////////////////////////////////////////////////
MicroWave w;
addCustomEvent(w = new MicroWave());
w.targetName = eName;
w.sourceLocation = _myLocation;
w.directAngle = _enemyAbsoluteBearing;
w.orientation = _lastGunOrientation = sign((eVelocity)
* Math.sin(e.getHeadingRadians() - _enemyAbsoluteBearing));
w.waveGuessFactors =
_gunStats[gunWallDistance(0.38591195687) ? 1 : 0]
[(int)Math.min(2, 3 * Math.asin(absSinRelativeHeading) / (Math.PI / 2))]
[(int)(eDistance / 275)][(int)((Math.abs(enemyLatVel)+1) / 2)];
////////////////////////////////////////////////
// Target selection and actual firing.
////////////////////////////////////////////////
if (eDistance < _targetDistance || _targetName.equals(eName)) {
_targetName = eName;
_targetDistance = eDistance;
}
if (!_targetName.equals(eName)) {
return;
}
int bestGF = GF_ZERO;
double bestGFRank = 0;
for (int x = 0; x < GF_ONE; x++) {
if (w.waveGuessFactors[x] > bestGFRank) {
bestGFRank = w.waveGuessFactors[x];
bestGF = x;
}
}
_bulletPower = 1.9;
if (eDistance > 750) {
_bulletPower = 1.59;
}
if (eDistance < 300) {
_bulletPower = 2.39;
}
if (eDistance < 150) {
_bulletPower = 3;
}
if ((getEnergy() < eEnergy && _teammatesAlive == 0) ||
(getEnergy() < 25)) {
_bulletPower = Math.min(_bulletPower,
1.9 - Math.max(0, (35 - getEnergy()) / 18));
}
setTurnGunRightRadians(Utils.normalRelativeAngle(
_enemyAbsoluteBearing - getGunHeadingRadians() +
(e.getEnergy() > 0 ?
(w.orientation
* (maxEscapeAngle(bulletVelocity(_bulletPower)) / GF_ZERO)
* (bestGF - GF_ZERO)) : 0)));
}
public void onMessageReceived(MessageEvent e) {
LuminariLocation loc = (LuminariLocation)e.getMessage();
_teammateLocation = new Point2D.Double(loc.x, loc.y);
}
public void onRobotDeath(RobotDeathEvent e) {
String eName = e.getName();
if (isTeammate(eName)) {
_teammatesAlive--;
}
if (_targetName.equals(eName)) {
_targetName = "";
_targetDistance = Double.POSITIVE_INFINITY;
}
_enemyLocationsByName.remove(eName);
}
public void onHitByBullet(HitByBulletEvent e) {
_lastBulletPower = e.getPower();
}
public void onHitWall(HitWallEvent e) {
_timeSinceDirChangeCounter = 0;
}
protected void move() {
_myLocation = new Point2D.Double(getX(), getY());
if (Math.random() > 0.9) {
_recentLocations.add(0, _myLocation);
}
double bestRisk = Double.POSITIVE_INFINITY;
double bestAngle = 0;
double currentHeading =
getHeadingRadians() + (getVelocity() < 0?Math.PI:0);
Object[] enemies =
(_enemyLocationsByName.values().toArray());
if (Math.abs(Utils.normalRelativeAngle(currentHeading - _lastHeading))
< Math.PI / 3) {
_timeSinceDirChangeCounter++;
} else {
_timeSinceDirChangeCounter = 0;
_randomDirChangeAmount =
Math.max(4, 2 * Math.random() * Math.random()
* (_targetDistance) / bulletVelocity(_lastBulletPower));
}
for (double x = 0; x < 2; x += .04) {
double testAngle = x * Math.PI;
Point2D.Double testPoint = project(_myLocation, testAngle,
50 + Math.random() * 200);
if (_fieldRect.contains(testPoint)) {
double testRisk = 0;
double[] enemyBearings = new double[2];
for (int y = 0; y < enemies.length; y++) {
EnemyData eData = ((EnemyData)enemies[y]);
double bearingToTeammate =
absoluteBearing(eData, _teammateLocation);
double bearingToMe = enemyBearings[y] =
absoluteBearing(eData, testPoint);
double distSquaredToEnemy =
testPoint.distanceSq(eData);
// double distSquaredTeammateToEnemy =
// _teammateLocation.distanceSq(eData);
testRisk +=
((limit(0.1, (eData.energy / getEnergy()), 2)
/ distSquaredToEnemy)
+ ((2 * _teammatesAlive)
/ testPoint.distanceSq(_teammateLocation))
)
// * (_teammatesAlive == 0?1:(
// (Math.max(1, distSquaredToEnemy / distSquaredTeammateToEnemy))))
* (1 + square(Math.cos(absoluteBearing(
_myLocation, eData) - testAngle)))
// * (2 + square(Math.sin(absoluteBearing(
// testPoint, eData) - eData.heading)))
* (_teammatesAlive==0?1:(1 +
square(Math.cos(bearingToTeammate - bearingToMe))))
;
}
try {
if (getOthers() - _teammatesAlive == 2) {
testRisk *= (1 + square(Math.sin(enemyBearings[0]
- enemyBearings[1])));
}
} catch (Exception e) { }
if (Math.abs(Utils.normalRelativeAngle(currentHeading
- testAngle)) < (Math.PI / 3)) {
if (_timeSinceDirChangeCounter > _randomDirChangeAmount) {
testRisk *= 10;
} else {
testRisk /= 2;
}
}
try {
for (int z = 0; z < Math.min(6, _recentLocations.size()); z++) {
testRisk *= (1 + (((1000) - (100 * z))
/ (testPoint.distanceSq(
(Point2D.Double)_recentLocations.get(z)))));
}
} catch (Exception e) { }
if (testRisk < bestRisk) {
bestRisk = testRisk;
bestAngle = x * Math.PI;
}
}
}
_lastHeading = currentHeading;
moveWithBackAsFront(bestAngle);
}
// CREDIT: code by Iiley,
// http://robowiki.net?BackAsFront
void moveWithBackAsFront(double bearing) {
double angle = Utils.normalRelativeAngle(bearing - getHeadingRadians());
double turnAngle;
setTurnRightRadians(turnAngle = Math.atan(Math.tan(angle)));
setAhead((angle == turnAngle) ? 100 : -100);
}
protected static Point2D.Double project(Point2D.Double sourceLocation,
double angle, double length) {
return new Point2D.Double(sourceLocation.x + Math.sin(angle) * length,
sourceLocation.y + Math.cos(angle) * length);
}
private static double absoluteBearing(Point2D.Double source, Point2D.Double target) {
return Math.atan2(target.x - source.x, target.y - source.y);
}
static int sign(double d) {
if (d >= 0) return 1;
return-1;
}
static double square(double d) {
return d * d;
}
private static double maxEscapeAngle(double velocity) {
return Math.asin(8.0/velocity);
}
protected static double bulletVelocity(double power) {
return (20.0 - (3.0*power));
}
protected static double limit(double min, double value, double max) {
return Math.max(min, Math.min(value, max));
}
protected static boolean gunWallDistance(double wallDistance) {
return _fieldRect.contains(project(_myLocation, _enemyAbsoluteBearing
+ (_lastGunOrientation*wallDistance), _lastDistance));
}
protected static double pythago(double x, double y) {
return Math.sqrt(square(x) + square(y));
}
class MicroWave extends Condition {
String targetName;
Point2D.Double sourceLocation;
long[] waveGuessFactors;
double bulletVelocity, directAngle, distance;
int orientation;
public boolean test(){
try {
Point2D.Double enemyLocation =
((EnemyData)_enemyLocationsByName.get(targetName));
if ((enemyLocation).distance(sourceLocation)
<= (distance+=WAVE_BULLET_VELOCITY) + (WAVE_BULLET_VELOCITY/2)) {
try {
double guessFactor = (Utils.normalRelativeAngle(
absoluteBearing(sourceLocation, enemyLocation)
- directAngle) * orientation) / WAVE_MAX_ESCAPE_ANGLE;
int guessFactorIndex = (int)((guessFactor * GF_ZERO) + GF_ZERO);
waveGuessFactors[guessFactorIndex]++;
} catch (Exception e) { }
removeCustomEvent(this);
}
} catch (Exception e) { }
return false;
}
}
}
class EnemyData extends Point2D.Double {
String name;
double energy, velocity, heading;
}
class LuminariLocation implements Serializable {
public double x;
public double y;
public LuminariLocation(double newX, double newY) {
x = newX;
y = newY;
}
}
