public void evaluateDistancingControl() {
double powerTwoHitPercentageThreshold;
if (_robot.getRoundNum() < 2) {
_desiredDistance = 420;
_fearDistance = 175;
_smoothAwayDistance = 75;
} else if (normalizedEnemyHitPercentage() > (powerTwoHitPercentageThreshold = 7.5)) {
_desiredDistance = 525 + (Math.max((ScanLog.avgEnemyPower() - 2), 0) * 165);
_fearDistance = 250;
_smoothAwayDistance = 75;
} else if (normalizedEnemyHitPercentage() > (powerTwoHitPercentageThreshold = 3)) {
_desiredDistance = 450 + (Math.max((ScanLog.avgEnemyPower() - 2), 0) * 150);
_fearDistance = 175;
_smoothAwayDistance = 75;
} else {
_desiredDistance = 420;
_fearDistance = 0;
_smoothAwayDistance = 0;
}
if (_robot.getRoundNum() < 2 || normalizedEnemyHitPercentage() > 7.5) {
_currentDistancer = _aggressiveDistancer;
} else {
_currentDistancer = _subtleDistancer;
}
}
public void fireWave(boolean isFiringWave) {
int timeSinceEnemyFired = (int) ScanLog.getLastFireOffset();
double bulletPower = ScanLog.getLastEnemyBulletPower();
try {
Point2D.Double myTargetLocation = ScanLog.getLocation(timeSinceEnemyFired);
Point2D.Double enemyFireLocation = ScanLog.getEnemyLocation(timeSinceEnemyFired);
BotScan enemySegmentationScan = ScanLog.getEnemyScan(timeSinceEnemyFired + 1);
Wave enemyWave =
new Wave(
enemySegmentationScan,
enemyFireLocation,
myTargetLocation,
_robot.getTime() - timeSinceEnemyFired,
isFiringWave ? Wave.FIRING_WAVE : Wave.NON_FIRING_WAVE,
enemySegmentationScan.getAbsBearingRadians(),
bulletPower,
"Surf Wave",
Wave.TRADITIONAL_MAX_ESCAPE_ANGLE,
enemySegmentationScan.getHeadingRadians(),
enemySegmentationScan.getVelocity(),
_lastEnemyWaveOrientation,
SURF_ORIENTATION_VELOCITY_THRESHOLD);
_waves.add(enemyWave);
_lastEnemyWaveOrientation = enemyWave.orientation;
} catch (IndexOutOfBoundsException noScanDataYet) {
}
}
public Wave findSurfableWave(int waveIndex) {
int searchWaveIndex = 0;
long currentTime = _robot.getTime();
for (int x = 0; x < _waves.size(); x++) {
Wave w = (Wave) _waves.get(x);
double distanceToWaveSource = ScanLog.myLocation().distance(w.sourceLocation);
double distanceToWave = distanceToWaveSource - w.distanceTraveled(currentTime);
if (w.firingWave && !w.processedBulletHit && distanceToWave > w.bulletVelocity()) {
if (searchWaveIndex == waveIndex) {
// drawCircle(w.sourceLocation,
// w.distanceTraveled(currentTime + 1), Color.green);
// drawLine(w.sourceLocation,
// DUtils.project(w.sourceLocation, w.absBearingRadians,
// w.distanceTraveled(currentTime + 1)),
// Color.blue);
return w;
} else {
searchWaveIndex++;
}
}
}
return null;
}
public void processWave(Wave w) {
GuessFactorWindowSet gfWindow = w.guessFactorWindow(ScanLog.myLocation());
int gfBin = w.guessFactorIndex(gfWindow.guessFactor);
int gfBinLow = w.guessFactorIndex(gfWindow.guessFactorLow);
int gfBinHigh = w.guessFactorIndex(gfWindow.guessFactorHigh);
BotScan enemyScan = w.targetScan.getInverseScan();
for (int x = 0; x < _waveRegisters.size(); x++) {
WaveRegister wr = (WaveRegister) _waveRegisters.get(x);
wr.registerWaveHit(
w.targetScan,
enemyScan,
w.bulletPower,
gfWindow.guessFactor,
gfBin,
gfBinLow,
gfBinHigh,
w.firingWave,
w.fireTime,
w.orientation,
w.escapeAngleRange());
}
w.processedWaveBreak = true;
}
public void reset(AdvancedRobot robot) {
_robot = robot;
_waves.clear();
_renderables.clear();
_weightedEnemyShotsFiredThisRound = 0;
_weightedEnemyShotsHitThisRound = 0;
ScanLog.reset();
}
public void onBulletHitBullet(BulletHitBulletEvent e) {
ScanLog.onBulletHitBullet(e);
processBulletReturnFiringWave(e.getHitBullet(), e.getTime());
_weightedEnemyShotsFired--;
_weightedEnemyShotsFiredThisRound--;
// (firingDistance
// / DUtils.bulletVelocity(e.getBullet().getPower()))
// / (TYPICAL_DISTANCE / POWER_TWO_BULLET_VELOCITY);
}
public void onHitByBullet(HitByBulletEvent e) {
ScanLog.onHitByBullet(e);
Wave hitWave = processBulletReturnFiringWave(e.getBullet(), e.getTime());
if (hitWave != NO_WAVE_FOUND) {
double thisHit =
(hitWave.targetScan.getDistance() / TYPICAL_DISTANCE)
* (hitWave.escapeAngleRange() / TYPICAL_ESCAPE_RANGE);
_weightedEnemyShotsHit += thisHit;
_weightedEnemyShotsHitThisRound += thisHit;
}
}
public Wave findNonSurfableWave(double minDistanceToWave) {
long currentTime = _robot.getTime();
for (int x = 0; x < _waves.size(); x++) {
Wave w = (Wave) _waves.get(x);
double distanceToWaveSource = ScanLog.myLocation().distance(w.sourceLocation);
double distanceToWave = distanceToWaveSource - w.distanceTraveled(currentTime);
if (!w.firingWave && distanceToWave > minDistanceToWave) {
return w;
}
}
return null;
}
public void onScannedRobot(ScannedRobotEvent e) {
ScanLog.onScannedRobot(_robot, e);
evaluateDistancingControl();
evaluateWallStick();
evaluateFlattener();
boolean realShotFired;
if (ScanLog.enemyFired(e.getTime())) {
realShotFired = true;
_weightedEnemyShotsFired++;
_weightedEnemyShotsFiredThisRound++;
// (e.getDistance()
// / DUtils.bulletVelocity(ScanLog.getLastEnemyBulletPower()))
// / (TYPICAL_DISTANCE / POWER_TWO_BULLET_VELOCITY);
} else {
realShotFired = false;
}
fireWave(realShotFired ? Wave.FIRING_WAVE : Wave.NON_FIRING_WAVE);
checkActiveWaves();
surf();
}
public void roundOver() {
_lastRoundNormalizedHitPercentage = normalizedEnemyHitPercentageThisRound();
System.out.println();
System.out.println(
"Enemy's hit % this round: "
+ ((int) ScanLog.getEnemyBulletHitsThisRound())
+ " / "
+ ((int) ScanLog.getEnemyBulletsFiredThisRound())
+ ", "
+ DUtils.round(ScanLog.getEnemyHitPercentageThisRound(), 2));
System.out.println(
"Enemy's normalized hit % this round: "
+ DUtils.round(_weightedEnemyShotsHitThisRound, 2)
+ " / "
+ DUtils.round(_weightedEnemyShotsFiredThisRound, 0)
+ ", "
+ DUtils.round(_lastRoundNormalizedHitPercentage, 2));
System.out.println(
"Enemy's cumulative hit %: "
+ ((int) ScanLog.getEnemyBulletHits())
+ " / "
+ ((int) ScanLog.getEnemyBulletsFired())
+ ", "
+ DUtils.round(ScanLog.getEnemyHitPercentage(), 2));
System.out.println(
"Enemy's normalized cum hit %: "
+ DUtils.round(_weightedEnemyShotsHit, 2)
+ " / "
+ DUtils.round(_weightedEnemyShotsFired, 0)
+ ", "
+ DUtils.round(normalizedEnemyHitPercentage(), 2));
System.out.println("Curve Flattener: " + ((_flattenerEnabled) ? "Enabled" : "Disabled"));
System.out.println("Total damage taken: " + DUtils.round(ScanLog.getBulletDamageTaken(), 2));
if (_mcMode) {
System.out.println();
System.out.println(
"MC score: "
+ DUtils.round(
(100.0 - (ScanLog.getBulletDamageTaken() / (_robot.getRoundNum() + 1.0))), 3));
}
}
public void checkActiveWaves() {
long currentTime = _robot.getTime();
Point2D.Double myLocation = ScanLog.myLocation();
for (int x = 0; x < _waves.size(); x++) {
Wave w = (Wave) _waves.get(x);
if (w.processedWaveBreak) {
if (w.wavePassed(myLocation, currentTime, Wave.INACTIVE_WAVE_OFFSET)) {
_waves.remove(x--);
}
} else {
if (w.wavePassed(myLocation, currentTime)) {
processWave(w);
}
}
}
}
public void evaluateWallStick() {
_wallStick = (ScanLog.enemyIsRammer()) ? RAMMER_WALL_STICK : DEFAULT_WALL_STICK;
}
public void onWin(WinEvent e) {
ScanLog.onWin(e);
roundOver();
}
public void surf() {
RobotState currentState =
new RobotState(
ScanLog.myLocation(),
_robot.getHeadingRadians(),
_robot.getVelocity(),
_robot.getTime());
boolean goingClockwise = (_lastMovementChoice == CLOCKWISE_OPTION);
double orbitCounterClockwiseDanger =
checkDanger(
currentState, COUNTERCLOCKWISE_OPTION, goingClockwise, FIRST_WAVE, WAVES_TO_SURF);
double stopDanger =
checkDanger(currentState, STOP_OPTION, goingClockwise, FIRST_WAVE, WAVES_TO_SURF);
double orbitClockwiseDanger =
checkDanger(currentState, CLOCKWISE_OPTION, goingClockwise, FIRST_WAVE, WAVES_TO_SURF);
int goOrientation = _lastMovementChoice;
Wave orbitWave = findSurfableWave(FIRST_WAVE);
double orbitAbsBearing, distanceToClosestWaveSource;
try {
distanceToClosestWaveSource = ScanLog.myLocation().distance(orbitWave.sourceLocation);
orbitAbsBearing = DUtils.absoluteBearing(orbitWave.sourceLocation, ScanLog.myLocation());
} catch (NullPointerException noSurfableWaves) {
distanceToClosestWaveSource = ScanLog.getLastDistance();
orbitAbsBearing = ScanLog.getLastEnemyScan().getAbsBearingRadians();
}
double goAngle, attackAngle;
if (stopDanger == NO_SURFABLE_WAVES) {
attackAngle = -1.047;
_robot.setMaxVelocity(8);
double goAngleCcw =
orbitAbsBearing + (COUNTERCLOCKWISE_OPTION * ((Math.PI / 2) + attackAngle));
goAngleCcw =
wallSmoothing(
ScanLog.myLocation(),
goAngleCcw,
COUNTERCLOCKWISE_OPTION,
distanceToClosestWaveSource);
double goAngleCw = orbitAbsBearing + (CLOCKWISE_OPTION * ((Math.PI / 2) + attackAngle));
goAngleCw =
wallSmoothing(
ScanLog.myLocation(), goAngleCw, CLOCKWISE_OPTION, distanceToClosestWaveSource);
if (Math.abs(Utils.normalRelativeAngle(goAngleCw - orbitAbsBearing))
< Math.abs(Utils.normalRelativeAngle(goAngleCcw - orbitAbsBearing))) {
goOrientation = CLOCKWISE_OPTION;
goAngle = goAngleCw;
} else {
goOrientation = COUNTERCLOCKWISE_OPTION;
goAngle = goAngleCcw;
}
} else {
_robot.setMaxVelocity(8);
attackAngle = _currentDistancer.attackAngle(distanceToClosestWaveSource, _desiredDistance);
if (ScanLog.enemyIsRammer()
&& ScanLog.getLastDistance() < 300
&& orbitWave != NO_WAVE_FOUND) {
if (Utils.normalRelativeAngle(
DUtils.absoluteBearing(ScanLog.myLocation(), orbitWave.sourceLocation)
- ScanLog.getLastScan().getAbsBearingRadians())
> 0) {
goOrientation = -1;
} else {
goOrientation = 1;
}
} else if (stopDanger <= orbitCounterClockwiseDanger
&& stopDanger <= orbitClockwiseDanger
&& !ScanLog.enemyIsRammer()) {
_robot.setMaxVelocity(0);
} else {
if (orbitClockwiseDanger < orbitCounterClockwiseDanger) {
goOrientation = CLOCKWISE_OPTION;
} else {
goOrientation = COUNTERCLOCKWISE_OPTION;
}
}
goAngle = orbitAbsBearing + (goOrientation * ((Math.PI / 2) + attackAngle));
goAngle =
wallSmoothing(ScanLog.myLocation(), goAngle, goOrientation, distanceToClosestWaveSource);
}
DUtils.setBackAsFront(_robot, goAngle);
_lastMovementChoice = goOrientation;
}
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;
}
public void onDeath(DeathEvent e) {
ScanLog.onDeath(e);
roundOver();
}
public void onBulletMissed(BulletMissedEvent e) {
ScanLog.onBulletMissed(e);
}
public void onBulletHit(BulletHitEvent e) {
ScanLog.onBulletHit(e);
}