NP/Source Code
< NP
Jump to navigation
Jump to search
- NP Sub-pages:
- NP - Version History - Source Code
Code For NP 1.3
Code size: 745 bytes
package nat.micro;
import robocode.AdvancedRobot;
import robocode.BulletHitEvent;
import robocode.Condition;
import robocode.HitByBulletEvent;
import robocode.HitWallEvent;
import robocode.ScannedRobotEvent;
import robocode.util.Utils;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
/**
*
* NP - Nat Pavasant
*
* A micro-bot by Nat Pavasant; named after the author. This robot perform a
* Wave Surfing-like movement called Velocity Surfing and fire using a very
* simple GuessFactor targeting.
*
* Gun base on Falcon, by PEZ and Kawigi; Movement base on WaveSnake, by Kev.
*/
public class NP extends AdvancedRobot {
// //////////////////////////////////////////
// Falcon's Gun
static final double BULLET_POWER = 2.5; // 2.5 is the best by the way =)
static final double BULLET_VELOCITY = 12.5; // bullet velocity for 2.5-size
// bullet
static final int BINS = 31; // 31 bins is fine for non-smoothed array.
static final int MIDDLE_BIN = 15; // middle gin
static final double MEA = 0.694498266 / MIDDLE_BIN; // hard-coded for 2.5
// bullet power
static double _enemyX; // enemy location
static double _enemyY; // enemy location
static int _enemyDirection = 1;
static double distance;
// Segment: Lateral Velocity
// static int[][][] _gunStats = new int[6][4][BINS];
static int[][][][] _gunStats = new int[6][4][2][BINS];
// static int[][][][][] _gunStats = new int[6][4][2][3][BINS];
// Gun
// //////////////////////////////////////////
// //////////////////////////////////////////
// Movement
// Distance controller constant
static final double PREFERRED_DISTANCE = 180d;
static final double CLOSING_FACTOR = 10000d;
static double _moveFactor = 20; // length to move, store the direction as
// sign
static double _enemyEnergy; // keep track of enemy energy
static int _currentVelocity;
static int _myLateralVelocity;
static int _myLatVel, _distance;
static int[][][] _surfStats = new int[4][5][9];
public void run() {
setAdjustRadarForGunTurn(true);
// setAdjustGunForRobotTurn(true); // not enough codesize
do {
turnRadarRightRadians(1);
} while (true);
}
public void onScannedRobot(ScannedRobotEvent e) {
Wave wave;
double enemyAbsoluteBearing;
int mostVisited = MIDDLE_BIN, i = BINS;
// /////////////////////////////////////
// Wave (Velocity) Surfing movement
// Base loosely on WaveSnake, by Kev
//
// Turn Perpendicular with distance controller
setTurnRightRadians(Math
.cos((enemyAbsoluteBearing = e.getBearingRadians())
- ((NP.distance = e.getDistance()) - PREFERRED_DISTANCE)
* _moveFactor / CLOSING_FACTOR));
if (_enemyEnergy > (_enemyEnergy = e.getEnergy())) {
int testVel = 8;
do {
if (_surfStats[_distance][_myLatVel][testVel] < _surfStats[_distance][_myLatVel][_currentVelocity]) {
_currentVelocity = testVel;
}
if (testVel == 5)
testVel = 3;
} while (testVel-- > 0);
if (_currentVelocity < 4) {
onHitWall(null);
}
}
setMaxVelocity(2 * (_currentVelocity - 4));
setAhead(_moveFactor);
// /////////////////////////////////////
// /////////////////////////////////////
// GuessFactor targeting gun
// Base loosely on Falcon gun.
//
addCustomEvent(wave = new Wave());
_enemyX = (wave.wGunX = getX())
+ Math.sin(enemyAbsoluteBearing += getHeadingRadians())
* distance;
_enemyY = (wave.wGunY = getY()) + Math.cos(enemyAbsoluteBearing)
* distance;
double enemyLatVel;
// check for enemy movement direction, preserve old direction if current
// velocity is 0
int direction;
if ((direction = (int) Math.signum(enemyLatVel = e.getVelocity()
* Math.sin(e.getHeadingRadians() - (wave.wBearing = enemyAbsoluteBearing)))) != 0)
_enemyDirection = direction;
// Segment: lateralVelocity and forwardWall
// wave.stats = _gunStats[(Math.abs(enemyLatVel) >= 7.75) ? 4 : (int)
// (1.4427 * Math
// .log(Math.abs(enemyLatVel) + 1.75))][gunWallDistance(0.18247367367) ?
// (gunWallDistance(0.36494734735) ? (gunWallDistance(0.63865785787) ? 3
// : 2) : 1) : 0];
wave.stats = _gunStats[(Math.abs(enemyLatVel) >= 7.75) ? 4 : (int) (1.4427 * Math
.log(Math.abs(enemyLatVel) + 1.75))][gunWallDistance(
0.18247367367, enemyAbsoluteBearing) ? (gunWallDistance(
0.36494734735, enemyAbsoluteBearing) ? (gunWallDistance(
0.63865785787, enemyAbsoluteBearing) ? 3 : 2) : 1) : 0][gunWallDistance(
-0.36494734735, enemyAbsoluteBearing) ? 0 : 1];
do {
i--;
if (wave.stats[i] > wave.stats[mostVisited])
mostVisited = i;
} while (i > 0);
setTurnGunRightRadians(Utils.normalRelativeAngle(enemyAbsoluteBearing
- getGunHeadingRadians()
+ (wave.wBearingDirection = (MEA * _enemyDirection))
* (mostVisited - MIDDLE_BIN)));
wave.weight = setFireBullet(BULLET_POWER) != null ? 4 : 1;
// /////////////////////////////////////////
_distance = (int) (Math.min((distance + 50) / 200, 3));
_myLatVel = (int) ((Math.abs(getVelocity()
* Math.sin(e.getBearingRadians())) + 1) / 2);
setTurnRadarRightRadians(Utils
.normalRelativeAngle(enemyAbsoluteBearing
- getRadarHeadingRadians()) * 2);
}
static class Wave extends Condition {
double wGunX;
double wGunY;
double wBearing;
double wBearingDirection;
double wDistance;
int weight;
int[] stats;
public boolean test() {
if (Math.abs((wDistance += BULLET_VELOCITY)
- Point2D.distance(wGunX, wGunY, _enemyX, _enemyY)) <= BULLET_VELOCITY / 2) {
stats[(int) ((Utils.normalRelativeAngle(Math.atan2(_enemyX
- wGunX, _enemyY - wGunY)
- wBearing)) / wBearingDirection)
+ MIDDLE_BIN] += weight;
// removeCustomEvent(this);
}
return false;
}
}
public void onBulletHit(BulletHitEvent e) {
_enemyEnergy -= 12.5;
}
public void onHitByBullet(HitByBulletEvent e) {
_surfStats[_distance][_myLatVel][_currentVelocity]++;
}
public void onHitWall(HitWallEvent e) {
_moveFactor = -_moveFactor;
}
// inject the absBearing here is good since it on the register, but inject
// the distance isn't good since it out of register now.
private static boolean gunWallDistance(double wallDistance, double ab) {
double angle;
return (new Rectangle2D.Double(18, 18, 764, 564))
.contains(new Point2D.Double(_enemyX
+ Math.sin(angle = ab
+ (_enemyDirection * wallDistance)) * distance,
_enemyY + Math.cos(angle) * distance));
}
}