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