public void logScore(double score, double weight) {
_rating =
(double)
((_rating * Math.min(_shots, _rollingDepth) + (score * weight))
/ (Math.min(_shots, _rollingDepth) + weight));
_shots += weight;
}
public void onScannedRobot(ScannedRobotEvent e) {
robotLocation = new Point2D.Double(getX(), getY());
enemyAbsoluteBearing = getHeadingRadians() + e.getBearingRadians();
enemyDistance = e.getDistance();
enemyLocation = vectorToLocation(enemyAbsoluteBearing, enemyDistance, robotLocation);
// Change direction at random
if (Math.random() < 0.015) {
movementLateralAngle *= -1;
}
move();
execute();
// radar
setTurnRadarRightRadians(
Utils.normalRelativeAngle(enemyAbsoluteBearing - getRadarHeadingRadians()) * 2);
/*
* Circular Gun from wiki
*/
double absBearing = e.getBearingRadians() + getHeadingRadians();
// Finding the heading and heading change.
double enemyHeading = e.getHeadingRadians();
double enemyHeadingChange = enemyHeading - oldEnemyHeading;
oldEnemyHeading = enemyHeading;
double deltaTime = 0;
double predictedX = getX() + e.getDistance() * Math.sin(absBearing);
double predictedY = getY() + e.getDistance() * Math.cos(absBearing);
while ((++deltaTime) * BULLET_SPEED
< Point2D.Double.distance(getX(), getY(), predictedX, predictedY)) {
// Add the movement we think our enemy will make to our enemy's current X and Y
predictedX += Math.sin(enemyHeading) * (e.getVelocity());
predictedY += Math.cos(enemyHeading) * (e.getVelocity());
// Find our enemy's heading changes.
enemyHeading += enemyHeadingChange;
// If our predicted coordinates are outside the walls, put them 18
// distance units away from the walls as we know
// that that is the closest they can get to the wall (Bots are
// non-rotating 36*36 squares).
predictedX = Math.max(Math.min(predictedX, getBattleFieldWidth() - 18), 18);
predictedY = Math.max(Math.min(predictedY, getBattleFieldHeight() - 18), 18);
}
// Find the bearing of our predicted coordinates from us.
double aim = Utils.normalAbsoluteAngle(Math.atan2(predictedX - getX(), predictedY - getY()));
// Aim and fire.
setTurnGunRightRadians(Utils.normalRelativeAngle(aim - getGunHeadingRadians()));
setFire(BULLET_POWER);
setTurnRadarRightRadians(Utils.normalRelativeAngle(absBearing - getRadarHeadingRadians()) * 2);
}
public void onScannedRobot(ScannedRobotEvent e) {
// ...
// if(getRadarHeadingRadians() - getGunHeading() == 0)
// fire(1);
// Absolute angle towards target
double angleToEnemy = getHeadingRadians() + e.getBearingRadians();
// Subtract current radar heading to get the turn required to face the enemy, be sure it is
// normalized
double radarTurn = Utils.normalRelativeAngle(angleToEnemy - getRadarHeadingRadians());
// Distance we want to scan from middle of enemy to either side
// The 36.0 is how many units from the center of the enemy robot it scans.
double extraTurn = Math.min(Math.atan(5.0 / e.getDistance()), Rules.RADAR_TURN_RATE_RADIANS);
// Adjust the radar turn so it goes that much further in the direction it is going to turn
// Basically if we were going to turn it left, turn it even more left, if right, turn more
// right.
// This allows us to overshoot our enemy so that we get a good sweep that will not slip.
radarTurn += (radarTurn < 0 ? -extraTurn : extraTurn);
// Turn the radar
setTurnRadarRightRadians(radarTurn);
// is the enemy left or right of us
double distance = getRadarHeading() - getGunHeading();
double[] wert = {distance};
// setTurnGunLeft(encog.Adjust.predict(NETWORK, wert));
if (distance < 0) setTurnGunRight(distance);
if (distance >= 0) setTurnGunRight(distance);
// System.out.println(distance);
// if enemy is within fire range -> fire
// if (getGunHeading() > getRadarHeading()-2 && getGunHeading() < getRadarHeading()+2)
setFire(1);
System.out.println("gunheat:" + getGunHeat());
if (getGunHeat() == 1.2) {
LIST.add(getTime());
System.out.println("distance: " + LIST);
// int shouldHit = (int) (getTime() + (e.getDistance() / 17));
// System.out.println("when should it hit: " + shouldHit);
}
if (LIST.size() != 0) {
if (LIST.get(0) + (getTime() - LIST.get(0)) * VELOCITY > e.getDistance()) {
System.out.println("did you hit?: " + getTime());
LIST.remove(0);
}
}
execute();
}
public void onScannedRobot(ScannedRobotEvent e) {
// track if we have no enemy, the one we found is significantly
// closer, or we scanned the one we've been tracking.
if (enemy.none()
|| e.getDistance() < enemy.getDistance() - 70
|| e.getName().equals(enemy.getName())) {
// track him
enemy.update(e);
// if the gun is cool and we're pointed at the target, shoot!
// Note: we can put the firing code before the turning code
// because we're testing to see if we're aiming at our enemy
if (getGunHeat() == 0 && Math.abs(getGunTurnRemaining()) < 10)
setFire(Math.min(400 / enemy.getDistance(), 3));
// calculate gun turn toward enemy
double turn = getHeading() - getGunHeading() + e.getBearing();
// normalize the turn to take the shortest path there
setTurnGunRight(normalizeBearing(turn));
}
}
private double minWall() {
return Math.min(
Math.min(getX(), getBattleFieldWidth() - getX()),
Math.min(getY(), getBattleFieldHeight() - getY()));
}
/** Computes a value within min and max */
public static double limit(double min, double val, double max) {
return Math.max(min, Math.min(val, max));
}
public static int getTimeSegment(long time) {
int index = (int) Math.min(time / 10.0, MOVE_TIMES - 1);
return index;
}
public static int getBearingSegment(double bearing) {
int index = (int) (bearing / (2 * Math.PI) * (BEARINGS));
return Math.max(0, Math.min(BEARINGS - 1, index));
}
public double checkDanger(
RobotState startState,
int movementOption,
boolean previouslyMovingClockwise,
int surfableWaveIndex,
int recursionLevels) {
if (surfableWaveIndex >= recursionLevels) {
return 0;
}
boolean predictClockwiseOrNot;
if (movementOption == CLOCKWISE_OPTION) {
predictClockwiseOrNot = true;
} else if (movementOption == COUNTERCLOCKWISE_OPTION) {
predictClockwiseOrNot = false;
} else {
predictClockwiseOrNot = previouslyMovingClockwise;
}
Wave surfWave = findSurfableWave(surfableWaveIndex);
if (surfWave == null) {
if (surfableWaveIndex == FIRST_WAVE) {
double nonSurfableWaveDistance = 150;
surfWave = findNonSurfableWave(nonSurfableWaveDistance);
}
if (surfWave == null) {
return NO_SURFABLE_WAVES;
}
}
/*
Color drawColor = Color.white;
if (surfableWaveIndex != 0 || movementOption == STOP_OPTION) {
drawColor = Color.blue;
}
*/
double waveHitInterceptOffset = surfWave.bulletVelocity() + BOT_HALF_WIDTH;
double wavePassedInterceptOffset = surfWave.bulletVelocity();
RobotState predictedState = startState;
RobotState dangerState = startState;
boolean wavePassed = false;
boolean waveHit = false;
double maxVelocity = (movementOption == STOP_OPTION) ? 0 : 8;
do {
double orbitAbsBearing =
DUtils.absoluteBearing(surfWave.sourceLocation, predictedState.location);
double orbitDistance = surfWave.sourceLocation.distance(predictedState.location);
double attackAngle = _currentDistancer.attackAngle(orbitDistance, _desiredDistance);
boolean clockwiseSmoothing = predictClockwiseOrNot;
if (orbitDistance < _smoothAwayDistance) {
clockwiseSmoothing = !clockwiseSmoothing;
}
predictedState =
DUtils.nextPerpendicularWallSmoothedLocation(
predictedState.location,
orbitAbsBearing,
predictedState.velocity,
maxVelocity,
predictedState.heading,
attackAngle,
clockwiseSmoothing,
predictedState.time,
DUtils.battleField,
DUtils.battleFieldWidth,
DUtils.battleFieldHeight,
_wallStick,
DUtils.OBSERVE_WALL_HITS);
if (!waveHit
&& surfWave.wavePassed(
predictedState.location, predictedState.time, waveHitInterceptOffset)) {
dangerState = predictedState;
waveHit = true;
}
if (!wavePassed
&& surfWave.wavePassed(
predictedState.location, predictedState.time, wavePassedInterceptOffset)) {
wavePassed = true;
}
} while (!wavePassed);
// drawPoint(predictedState.location, drawColor);
double danger = getBinScore(surfWave, dangerState.location);
danger *= DUtils.bulletDamage(surfWave.bulletPower);
double currentDistanceToWaveSource = ScanLog.myLocation().distance(surfWave.sourceLocation);
double currentDistanceToWave =
currentDistanceToWaveSource - surfWave.distanceTraveled(_robot.getTime());
double timeToImpact = currentDistanceToWave / DUtils.bulletVelocity(surfWave.bulletPower);
if (_flattenerEnabled) {
danger /= DUtils.square(timeToImpact);
} else {
danger /= timeToImpact;
}
double nextCounterClockwiseDanger =
checkDanger(
predictedState,
COUNTERCLOCKWISE_OPTION,
predictClockwiseOrNot,
surfableWaveIndex + 1,
recursionLevels);
double nextStopDanger =
checkDanger(
predictedState,
STOP_OPTION,
predictClockwiseOrNot,
surfableWaveIndex + 1,
recursionLevels);
double nextClockwiseDanger =
checkDanger(
predictedState,
CLOCKWISE_OPTION,
predictClockwiseOrNot,
surfableWaveIndex + 1,
recursionLevels);
danger += Math.min(nextCounterClockwiseDanger, Math.min(nextStopDanger, nextClockwiseDanger));
// danger += Math.min(nextCounterClockwiseDanger, nextClockwiseDanger);
if (surfableWaveIndex == FIRST_WAVE) {
double predictedDistanceToWaveSource =
surfWave.sourceLocation.distance(predictedState.location);
double predictedDistanceToEnemy = ScanLog.enemyLocation().distance(predictedState.location);
double shorterDistance = Math.min(predictedDistanceToWaveSource, predictedDistanceToEnemy);
double distancingDangerBase = Math.max(currentDistanceToWaveSource / shorterDistance, .99);
double distancingDangerExponent =
shorterDistance > _fearDistance
? NORMAL_DISTANCING_EXPONENT
: FEARFUL_DISTANCING_EXPONENT;
danger *= Math.pow(distancingDangerBase, distancingDangerExponent);
}
return danger;
}