NP/Source Code

NP Sub-pages:

NP - Version History - Source Code

Below is the code for more shrank version 1.0. Codesize: 747 bytes. Not yet squeezed.

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; // hard-coded for 2.5 bullet power
	
	static double _enemyX; // enemy location
	static double _enemyY; // enemy location
	static int _enemyDirection = 1;
	
	static double distance, absBearing;
	
	// Segment: Lateral Velocity
	static int[][][][] _gunStats = new int[6][4][2][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, story 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);
		
		do {
			turnRadarRightRadians(1);
		} while (true);
	}
	
	public void onScannedRobot(ScannedRobotEvent e) {
		Wave wave;
		double enemyAbsoluteBearing;
		
		// /////////////////////////////////////
		// 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[_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 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;
		
		// Codesize-trick: Hardcoded MEA.
		wave.wBearingDirection = MEA * _enemyDirection / MIDDLE_BIN;
		
		// 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))][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
		int i = BINS;
		
		do {
			i--;
			if (wave.stats[i] > wave.stats[mostVisited])
				mostVisited = i;
		} while (i > 0);
		
		setTurnGunRightRadians(Utils
				.normalRelativeAngle((NP.absBearing = enemyAbsoluteBearing)
						- getGunHeadingRadians() + wave.wBearingDirection
						* (mostVisited - MIDDLE_BIN)));
		setFire(BULLET_POWER);
		// /////////////////////////////////////////
		
		_distance = (int) (Math.min((distance + 50) / 200, 3));
		_myLatVel = (int) ((Math.abs(getVelocity()
				* Math.sin(enemyAbsoluteBearing)) + 1) / 2);
	}
	
	static class Wave extends Condition {
		double wGunX;
		double wGunY;
		double wBearing;
		double wBearingDirection;
		double wDistance;
		
		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]++;
				// 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;
	}
	
	// UTIL
	private static Point2D.Double project(double a, double b, double angle,
			double length) {
		return new Point2D.Double(a + Math.sin(angle) * length, b
				+ Math.cos(angle) * length);
	}
	
	private static boolean gunWallDistance(double wallDistance) {
		return (new Rectangle2D.Double(18, 18, 764, 564)).contains(project(
				_enemyX, _enemyY,
				absBearing + (_enemyDirection * wallDistance), distance));
	}
}