NP/Source Code - Revision history

RednaxelaBot: Using .

2010-07-01T08:29:51Z

Using <syntaxhighlight>.

Nat: NP 1.3 update

2009-06-21T09:30:11Z

NP 1.3 update

Nat: NP 1.2

2009-06-21T07:31:42Z

NP 1.2

Nat at 05:16, 21 June 2009

2009-06-21T05:16:30Z

Nat: update the code

2009-06-21T05:11:26Z

update the code

Nat: update 1.0

2009-06-20T14:42:06Z

update 1.0

Nat at 18:18, 19 June 2009

2009-06-19T18:18:11Z

Nat at 18:16, 19 June 2009

2009-06-19T18:16:42Z

Nat: add the code

2009-06-19T18:16:15Z

add the code

New page

Below is the code for more shrank prototype2. Codesize: 532 bytes. 217 bytes to play with.

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

/**
*
* 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 final double MAX_PASSED_DISTANCE = 12.5 / 2;

static double _enemyX; // enemy location
static double _enemyY; // enemy location
static int _enemyDirection = 1;

// Segment: Lateral Velocity
static int[][] _gunStats = new int[6][BINS];

// Gun
// //////////////////////////////////////////

// //////////////////////////////////////////
// Movement

// Distance controller constant
static final double PREFERRED_DISTANCE = 150d;
static final double CLOSING_FACTOR = 7500d;

static double _moveFactor = 20; // length to move, story the direction as
// sign
static double _enemyEnergy; // keep track of enemy energy
static int _currentVelocity;
static int _myLateralVelocity;
static int[] _surfStats = new int[9];

public void run() {
setAdjustRadarForGunTurn(true);
setAdjustGunForRobotTurn(true);

do {
turnRadarRightRadians(1);
} while (true);
}

public void onScannedRobot(ScannedRobotEvent e) {
Wave wave;
double enemyAbsoluteBearing;
double distance;

// /////////////////////////////////////
// Wave (Velocity) Surfing movement
// Base loosly on WaveSnake, by Kev
//

// Turn Perpendicular with distance controller
setTurnRightRadians(Math.cos((enemyAbsoluteBearing = e
.getBearingRadians())
- ((distance = e.getDistance()) - PREFERRED_DISTANCE)
* _moveFactor / CLOSING_FACTOR));

if (_enemyEnergy > (_enemyEnergy = e.getEnergy())) {
int testVel = 8;
do {
if (_surfStats[testVel] < _surfStats[_currentVelocity]) {
_currentVelocity = testVel;
}

// Prevent robot to move at velocity 0 and 2
if (testVel == 6)
testVel = 3;
} while (testVel-- > 0);

if (_currentVelocity < 4) {
onHitWall(null);
}
}

setMaxVelocity(2 * (_currentVelocity - 4));
setAhead(_moveFactor);
// /////////////////////////////////////

// /////////////////////////////////////
// GuessFactor targeting gun
// Base loosly 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() - enemyAbsoluteBearing))) != 0)
_enemyDirection = direction;

// Radar - add here due the codesize shrinking
setTurnRadarRightRadians(Utils
.normalRelativeAngle((wave.wBearing = enemyAbsoluteBearing)
- getRadarHeadingRadians()) * 2);

// Segment: lateralVelocity
wave.stats = _gunStats[(Math.abs(enemyLatVel) >= 7.75) ? 4 : (int) (1.4427 * Math
.log(Math.abs(enemyLatVel) + 1.75))];

int mostVisited = MIDDLE_BIN; // default at head-on
int i = BINS;

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)));
setFire(BULLET_POWER);
// /////////////////////////////////////////
}

static class Wave extends Condition {
double wGunX;
double wGunY;
// Point2D.Double gunLocation;
double wBearing;
double wBearingDirection;
double wDistance;

int[] stats;

public boolean test() {
if (Math.abs((wDistance += BULLET_VELOCITY)
- Point2D.distance(wGunX, wGunY, _enemyX, _enemyY)) <= MAX_PASSED_DISTANCE) {
stats[(int) ((Utils.normalRelativeAngle(Math.atan2(_enemyX
- wGunY, _enemyY - wGunX)
- wBearing)) / wBearingDirection)
+ MIDDLE_BIN]++;
// removeCustomEvent(this);
}

return false;
}
}

public void onBulletHit(BulletHitEvent e) {
_enemyEnergy -= 12.5;
}

public void onHitByBullet(HitByBulletEvent e) {
_surfStats[_currentVelocity]++;
}

public void onHitWall(HitWallEvent e) {
_moveFactor = -_moveFactor;
}
}
</pre>

@@ Line 9: / Line 9: @@
 [[Code size]]: 745 bytes
-<pre>
+<syntaxhighlight>
 package nat.micro;
@@ Line 222: / Line 222: @@
+	}
+}
-</pre>
+</syntaxhighlight>

@@ Line 6: / Line 6: @@
 }}
-== Code For NP 1.2 ==
+== Code For NP 1.3 ==
 [[Code size]]: 745 bytes
@@ Line 77: / Line 77: @@
 	public void run() {
 		setAdjustRadarForGunTurn(true);
-		setAdjustGunForRobotTurn(true);
+//		setAdjustGunForRobotTurn(true); // not enough codesize
 		do {
@@ Line 86: / Line 86: @@
 	public void onScannedRobot(ScannedRobotEvent e) {
 		Wave wave;
-		double enemyAbsoluteBearing, distance;
+		double enemyAbsoluteBearing;
 		int mostVisited = MIDDLE_BIN, i = BINS;
 		// /////////////////////////////////////
 		// Wave (Velocity) Surfing movement
-		// Base loosly on WaveSnake, by Kev
+		// Base loosely on WaveSnake, by Kev
 		//
@@ Line 97: / Line 97: @@
 		setTurnRightRadians(Math
 				.cos((enemyAbsoluteBearing = e.getBearingRadians())
-						- ((NP.distance = distance = e.getDistance()) - PREFERRED_DISTANCE)
+						- ((NP.distance = e.getDistance()) - PREFERRED_DISTANCE)
 						* _moveFactor / CLOSING_FACTOR));
@@ Line 106: / Line 106: @@
 					_currentVelocity = testVel;
+				}
-				// if (testVel == 5)
+				 if (testVel == 5)
-				// testVel = 3;
+				 testVel = 3;
 			} while (testVel-- > 0);
@@ Line 115: / Line 115: @@
+		}
-		setMaxVelocity(2 * (_currentVelocity - 3.5));
+		setMaxVelocity(2 * (_currentVelocity - 4));
 		setAhead(_moveFactor);
 		// /////////////////////////////////////
@@ Line 121: / Line 121: @@
 		// /////////////////////////////////////
 		// GuessFactor targeting gun
-		// Base loosly on Falcon gun.
+		// Base loosely on Falcon gun.
 		//
 		addCustomEvent(wave = new Wave());
@@ Line 137: / Line 137: @@
 		int direction;
 		if ((direction = (int) Math.signum(enemyLatVel = e.getVelocity()
-				* Math.sin(e.getHeadingRadians() - enemyAbsoluteBearing))) != 0)
+				* Math.sin(e.getHeadingRadians() - (wave.wBearing = enemyAbsoluteBearing)))) != 0)
 			_enemyDirection = direction;
 		// Segment: lateralVelocity and forwardWall
@@ Line 164: / Line 159: @@
 		} while (i > 0);
-		setTurnGunRightRadians(Utils.normalRelativeAngle((enemyAbsoluteBearing)
+		setTurnGunRightRadians(Utils.normalRelativeAngle(enemyAbsoluteBearing
 				- getGunHeadingRadians()
 				+ (wave.wBearingDirection = (MEA * _enemyDirection))
@@ Line 174: / Line 169: @@
 		_myLatVel = (int) ((Math.abs(getVelocity()
 				* Math.sin(e.getBearingRadians())) + 1) / 2);
+	}

@@ Line 6: / Line 6: @@
 }}
-Below is the code for overextended code of NP, cost 758 bytes.
+== Code For NP 1.2 ==
 <pre>
@@ Line 43: / Line 44: @@
 	static final int MIDDLE_BIN = 15; // middle gin
 	static final double MEA = 0.694498266 / MIDDLE_BIN; // hard-coded for 2.5
-														// bullet power
+	// bullet power
 	static double _enemyX; // enemy location
@@ Line 49: / Line 50: @@
 	static int _enemyDirection = 1;
-	static double distance, absBearing;
+	static double distance;
 	// Segment: Lateral Velocity
-	//static int[][][] _gunStats = new int[6][4][BINS];
+	// 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];
+	// static int[][][][][] _gunStats = new int[6][4][2][3][BINS];
 	// Gun
@@ Line 66: / Line 67: @@
 	static final double CLOSING_FACTOR = 10000d;
-	static double _moveFactor = 20; // length to move, story the direction as
+	static double _moveFactor = 20; // length to move, store the direction as
 	// sign
 	static double _enemyEnergy; // keep track of enemy energy
@@ Line 85: / Line 86: @@
 	public void onScannedRobot(ScannedRobotEvent e) {
 		Wave wave;
-		double enemyAbsoluteBearing;
+		double enemyAbsoluteBearing, distance;
 		// /////////////////////////////////////
@@ Line 93: / Line 95: @@
 		// Turn Perpendicular with distance controller
-		setTurnRightRadians(Math.cos((enemyAbsoluteBearing = e
+		setTurnRightRadians(Math
-				.getBearingRadians())
+				.cos((enemyAbsoluteBearing = e.getBearingRadians())
-				- ((distance = e.getDistance()) - PREFERRED_DISTANCE)
+						- ((NP.distance = distance = e.getDistance()) - PREFERRED_DISTANCE)
-				* _moveFactor / CLOSING_FACTOR));
+						* _moveFactor / CLOSING_FACTOR));
 		if (_enemyEnergy > (_enemyEnergy = e.getEnergy())) {
@@ Line 104: / Line 106: @@
 					_currentVelocity = testVel;
+				}
-				if (testVel == 5)
+				// if (testVel == 5)
-					testVel = 3;
+				// testVel = 3;
 			} while (testVel-- > 0);
@@ Line 113: / Line 115: @@
+		}
-		setMaxVelocity(2 * (_currentVelocity - 4));
+		setMaxVelocity(2 * (_currentVelocity - 3.5));
 		setAhead(_moveFactor);
 		// /////////////////////////////////////
@@ Line 144: / Line 146: @@
 		// Segment: lateralVelocity and forwardWall
-//		wave.stats = _gunStats[(Math.abs(enemyLatVel) >= 7.75) ? 4 : (int) (1.4427 * Math
+		// wave.stats = _gunStats[(Math.abs(enemyLatVel) >= 7.75) ? 4 : (int)
-//				.log(Math.abs(enemyLatVel) + 1.75))][gunWallDistance(0.18247367367) ? (gunWallDistance(0.36494734735) ? (gunWallDistance(0.63865785787) ? 3 : 2) : 1) : 0];
+		// (1.4427 * Math
 		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][gunWallDistance(-0.36494734735) ? 0 : 1];
+				.log(Math.abs(enemyLatVel) + 1.75))][gunWallDistance(
+.18247367367, enemyAbsoluteBearing) ? (gunWallDistance(
-		int mostVisited = MIDDLE_BIN; // default at head-on
+.36494734735, enemyAbsoluteBearing) ? (gunWallDistance(
-		int i = BINS;
+.63865785787, enemyAbsoluteBearing) ? 3 : 2) : 1) : 0][gunWallDistance(
 		do {
@@ Line 158: / Line 164: @@
 		} while (i > 0);
-		setTurnGunRightRadians(Utils
+		setTurnGunRightRadians(Utils.normalRelativeAngle((enemyAbsoluteBearing)
-				.normalRelativeAngle((NP.absBearing = enemyAbsoluteBearing)
+				- getGunHeadingRadians()
-						- getGunHeadingRadians()
+				+ (wave.wBearingDirection = (MEA * _enemyDirection))
-						+ (wave.wBearingDirection = (MEA * _enemyDirection))
+				* (mostVisited - MIDDLE_BIN)));
 		wave.weight = setFireBullet(BULLET_POWER) != null ? 4 : 1;
 		// /////////////////////////////////////////
@@ Line 183: / Line 188: @@
 			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)
@@ Line 206: / Line 212: @@
+	}
-	// UTIL
+	// inject the absBearing here is good since it on the register, but inject
-	private static Point2D.Double project(double a, double b, double angle,
+	// the distance isn't good since it out of register now.
-			double length) {
+	private static boolean gunWallDistance(double wallDistance, double ab) {
-		return new Point2D.Double(a + Math.sin(angle) * length, b
+		double angle;
-				+ Math.cos(angle) * length);
+		return (new Rectangle2D.Double(18, 18, 764, 564))
+				.contains(new Point2D.Double(_enemyX
+						+ Math.sin(angle = ab
-	private static boolean gunWallDistance(double wallDistance) {
+								+ (_enemyDirection * wallDistance)) * distance,
-		return (new Rectangle2D.Double(18, 18, 764, 564)).contains(project(
+						_enemyY + Math.cos(angle) * distance));
+	}
+}
 </pre>

@@ Line 6: / Line 6: @@
 }}
-Below is the code for overextended code of NP, cost 759 bytes.
+Below is the code for overextended code of NP, cost 758 bytes.
 <pre>
@@ Line 163: / Line 163: @@
 						+ (wave.wBearingDirection = (MEA * _enemyDirection))
 						* (mostVisited - MIDDLE_BIN)));
-		if (setFireBullet(BULLET_POWER) != null)
+		wave.weight = setFireBullet(BULLET_POWER) != null ? 4 : 1;
 		// /////////////////////////////////////////
@@ Line 178: / Line 177: @@
 		double wBearingDirection;
 		double wDistance;
-		int weight = 1;
+		int weight;
 		int[] stats;

@@ Line 6: / Line 6: @@
 }}
-Below is the code for more shrank version 1.0. Codesize: 747 bytes. Not yet squeezed.
+Below is the code for overextended code of NP, cost 759 bytes.
 <pre>
@@ Line 42: / Line 42: @@
 	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; // hard-coded for 2.5 bullet power
+	static final double MEA = 0.694498266 / MIDDLE_BIN; // hard-coded for 2.5
 	static double _enemyX; // enemy location
@@ Line 51: / Line 52: @@
 	// Segment: Lateral Velocity
 	static int[][][][] _gunStats = new int[6][4][2][BINS];
 	// Gun
@@ Line 134: / Line 137: @@
 				* Math.sin(e.getHeadingRadians() - enemyAbsoluteBearing))) != 0)
 			_enemyDirection = direction;
 		// Radar - add here due the codesize shrinking
@@ Line 143: / Line 143: @@
 						- getRadarHeadingRadians()) * 2);
-		// Segment: lateralVelocity
+		// 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][gunWallDistance(-0.36494734735) ? 0 : 1];
@@ Line 158: / Line 160: @@
 		setTurnGunRightRadians(Utils
 				.normalRelativeAngle((NP.absBearing = enemyAbsoluteBearing)
-						- getGunHeadingRadians() + wave.wBearingDirection
+						- getGunHeadingRadians()
 						* (mostVisited - MIDDLE_BIN)));
-		setFire(BULLET_POWER);
+		if (setFireBullet(BULLET_POWER) != null)
 		// /////////////////////////////////////////
 		_distance = (int) (Math.min((distance + 50) / 200, 3));
 		_myLatVel = (int) ((Math.abs(getVelocity()
-				* Math.sin(enemyAbsoluteBearing)) + 1) / 2);
+				* Math.sin(e.getBearingRadians())) + 1) / 2);
+	}
@@ Line 174: / Line 178: @@
 		double wBearingDirection;
 		double wDistance;
+		int weight = 1;
 		int[] stats;
@@ Line 183: / Line 187: @@
 						- wGunX, _enemyY - wGunY)
 						- wBearing)) / wBearingDirection)
-						+ MIDDLE_BIN]++;
+						+ MIDDLE_BIN] += weight;
 				// removeCustomEvent(this);
+			}
@@ Line 216: / Line 220: @@
+	}
+}
 </pre>

@@ Line 6: / Line 6: @@
 }}
-Below is the code for more shrank prototype2. Codesize: 532 bytes. 217 bytes to play with.
+Below is the code for more shrank version 1.0. Codesize: 747 bytes. Not yet squeezed.
 <pre>
@@ Line 20: / Line 20: @@
 import java.awt.geom.Point2D;
 /**
@@ Line 41: / Line 42: @@
 	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 final double MEA = 0.694498266; // hard-coded for 2.5 bullet power
 	static double _enemyX; // enemy location
 	static double _enemyY; // enemy location
 	static int _enemyDirection = 1;
 	// Segment: Lateral Velocity
-	static int[][] _gunStats = new int[6][BINS];
+	static int[][][][] _gunStats = new int[6][4][2][BINS];
 	// Gun
@@ Line 58: / Line 60: @@
 	// Distance controller constant
-	static final double PREFERRED_DISTANCE = 150d;
+	static final double PREFERRED_DISTANCE = 180d;
-	static final double CLOSING_FACTOR = 7500d;
+	static final double CLOSING_FACTOR = 10000d;
 	static double _moveFactor = 20; // length to move, story the direction as
@@ Line 66: / Line 68: @@
 	static int _currentVelocity;
 	static int _myLateralVelocity;
-	static int[] _surfStats = new int[9];
+	static int _myLatVel, _distance;
 	public void run() {
@@ Line 80: / Line 83: @@
 		Wave wave;
 		double enemyAbsoluteBearing;
 		// /////////////////////////////////////
@@ Line 96: / Line 98: @@
 			int testVel = 8;
 			do {
-				if (_surfStats[testVel] < _surfStats[_currentVelocity]) {
+				if (_surfStats[_distance][_myLatVel][testVel] < _surfStats[_distance][_myLatVel][_currentVelocity]) {
 					_currentVelocity = testVel;
+				}
+				if (testVel == 5)
 					testVel = 3;
 			} while (testVel-- > 0);
@@ Line 134: / Line 134: @@
 				* Math.sin(e.getHeadingRadians() - enemyAbsoluteBearing))) != 0)
 			_enemyDirection = direction;
 		// Radar - add here due the codesize shrinking
@@ Line 142: / Line 145: @@
 		// Segment: lateralVelocity
 		wave.stats = _gunStats[(Math.abs(enemyLatVel) >= 7.75) ? 4 : (int) (1.4427 * Math
-				.log(Math.abs(enemyLatVel) + 1.75))];
+				.log(Math.abs(enemyLatVel) + 1.75))][gunWallDistance(0.18247367367) ? (gunWallDistance(0.36494734735) ? (gunWallDistance(0.63865785787) ? 3 : 2) : 1) : 0][gunWallDistance(-0.36494734735) ? 0 : 1];
 		int mostVisited = MIDDLE_BIN; // default at head-on
@@ Line 153: / Line 156: @@
 		} while (i > 0);
-		setTurnGunRightRadians(Utils.normalRelativeAngle(enemyAbsoluteBearing
+		setTurnGunRightRadians(Utils
-				- getGunHeadingRadians()
+				.normalRelativeAngle((NP.absBearing = enemyAbsoluteBearing)
-				+ (wave.wBearingDirection = MEA * _enemyDirection)
+						- getGunHeadingRadians() + wave.wBearingDirection
-				* (mostVisited - MIDDLE_BIN)));
+						* (mostVisited - MIDDLE_BIN)));
 		setFire(BULLET_POWER);
 		// /////////////////////////////////////////
+	}
@@ Line 164: / Line 171: @@
 		double wGunX;
 		double wGunY;
 		double wBearing;
 		double wBearingDirection;
@@ Line 173: / Line 179: @@
 		public boolean test() {
 			if (Math.abs((wDistance += BULLET_VELOCITY)
-					- Point2D.distance(wGunX, wGunY, _enemyX, _enemyY)) <= MAX_PASSED_DISTANCE) {
+					- Point2D.distance(wGunX, wGunY, _enemyX, _enemyY)) <= BULLET_VELOCITY / 2) {
 				stats[(int) ((Utils.normalRelativeAngle(Math.atan2(_enemyX
-						- wGunY, _enemyY - wGunX)
+						- wGunX, _enemyY - wGunY)
 						- wBearing)) / wBearingDirection)
 						+ MIDDLE_BIN]++;
@@ Line 190: / Line 196: @@
 	public void onHitByBullet(HitByBulletEvent e) {
-		_surfStats[_currentVelocity]++;
+		_surfStats[_distance][_myLatVel][_currentVelocity]++;
+	}
 	public void onHitWall(HitWallEvent e) {
 		_moveFactor = -_moveFactor;
+	}
+}
 </pre>

@@ Line 1: / Line 1: @@
 {{Navbox small
 | title = NP Sub-pages
 | page1 = Version History
 | page2 = Source Code

← Older revision		Revision as of 18:16, 19 June 2009
Line 1:		Line 1:
		+
		+	{{Navbox small
		+	\| title = NP Sub-pages
		+	\| page1 = Version History
		+	\| page2 = Source Code
		+	}}
		+
	Below is the code for more shrank prototype2. Codesize: 532 bytes. 217 bytes to play with.		Below is the code for more shrank prototype2. Codesize: 532 bytes. 217 bytes to play with.