NP/Source Code

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