# BasicGTSurfer/Code

BasicGTSurfer Sub-pages:
BasicGTSurferCode

```package wiki.tutorial;

import robocode.*;
import robocode.util.Utils;
import java.awt.geom.*;     // for Point2D's
import java.lang.*;         // for Double and Integer objects
import java.util.ArrayList; // for collection of waves
import java.awt.*;

public class BasicGTSurfer extends AdvancedRobot {
public static int BINS = 47;
public static double _surfStats[] = new double[BINS]; // we'll use 47 bins
public Point2D.Double _myLocation;     // our bot's location
public Point2D.Double _enemyLocation;  // enemy bot's location

public Point2D.Double _lastGoToPoint;
public double direction = 1;

public ArrayList _enemyWaves;
public ArrayList _surfDirections;
public ArrayList _surfAbsBearings;

// We must keep track of the enemy's energy level to detect EnergyDrop,
// indicating a bullet is fired
public static double _oppEnergy = 100.0;

// This is a rectangle that represents an 800x600 battle field,
// used for a simple, iterative WallSmoothing method (by Kawigi).
// If you're not familiar with WallSmoothing, the wall stick indicates
// the amount of space we try to always have on either end of the tank
// (extending straight out the front or back) before touching a wall.
public static Rectangle2D.Double _fieldRect
= new java.awt.geom.Rectangle2D.Double(18, 18, 764, 564);
public static double WALL_STICK = 160;

public void run() {
_enemyWaves = new ArrayList();
_surfDirections = new ArrayList();
_surfAbsBearings = new ArrayList();

do {
} while (true);
}

public void onScannedRobot(ScannedRobotEvent e) {
_myLocation = new Point2D.Double(getX(), getY());

new Integer((lateralVelocity >= 0) ? 1 : -1));

double bulletPower = _oppEnergy - e.getEnergy();
if (bulletPower < 3.01 && bulletPower > 0.09
&& _surfDirections.size() > 2) {
EnemyWave ew = new EnemyWave();
ew.fireTime = getTime() - 1;
ew.bulletVelocity = bulletVelocity(bulletPower);
ew.distanceTraveled = bulletVelocity(bulletPower);
ew.direction = ((Integer)_surfDirections.get(2)).intValue();
ew.directAngle = ((Double)_surfAbsBearings.get(2)).doubleValue();
ew.fireLocation = (Point2D.Double)_enemyLocation.clone(); // last tick

}

_oppEnergy = e.getEnergy();

// update after EnemyWave detection, because that needs the previous
// enemy location as the source of the wave
_enemyLocation = project(_myLocation, absBearing, e.getDistance());

updateWaves();
doSurfing();

// gun code would go here...
}

public void updateWaves() {
for (int x = 0; x < _enemyWaves.size(); x++) {
EnemyWave ew = (EnemyWave)_enemyWaves.get(x);

ew.distanceTraveled = (getTime() - ew.fireTime) * ew.bulletVelocity;
if (ew.distanceTraveled >
_myLocation.distance(ew.fireLocation) + 50) {
_enemyWaves.remove(x);
x--;
}
}
}

public EnemyWave getClosestSurfableWave() {
double closestDistance = 50000; // I juse use some very big number here
EnemyWave surfWave = null;

for (int x = 0; x < _enemyWaves.size(); x++) {
EnemyWave ew = (EnemyWave)_enemyWaves.get(x);
double distance = _myLocation.distance(ew.fireLocation)
- ew.distanceTraveled;

if (distance > ew.bulletVelocity && distance < closestDistance) {
surfWave = ew;
closestDistance = distance;
}
}

return surfWave;
}

// Given the EnemyWave that the bullet was on, and the point where we
// were hit, calculate the index into our stat array for that factor.
public static int getFactorIndex(EnemyWave ew, Point2D.Double targetLocation) {
double offsetAngle = (absoluteBearing(ew.fireLocation, targetLocation)
- ew.directAngle);
double factor = Utils.normalRelativeAngle(offsetAngle)
/ maxEscapeAngle(ew.bulletVelocity) * ew.direction;

return (int)limit(0,
(factor * ((BINS - 1) / 2)) + ((BINS - 1) / 2),
BINS - 1);
}

// Given the EnemyWave that the bullet was on, and the point where we
// were hit, update our stat array to reflect the danger in that area.
public void logHit(EnemyWave ew, Point2D.Double targetLocation) {
int index = getFactorIndex(ew, targetLocation);

for (int x = 0; x < BINS; x++) {
// for the spot bin that we were hit on, add 1;
// for the bins next to it, add 1 / 2;
// the next one, add 1 / 5; and so on...
_surfStats[x] += 1.0 / (Math.pow(index - x, 2) + 1);
}
}

public void onHitByBullet(HitByBulletEvent e) {
// If the _enemyWaves collection is empty, we must have missed the
// detection of this wave somehow.
if (!_enemyWaves.isEmpty()) {
Point2D.Double hitBulletLocation = new Point2D.Double(
e.getBullet().getX(), e.getBullet().getY());
EnemyWave hitWave = null;

// look through the EnemyWaves, and find one that could've hit us.
for (int x = 0; x < _enemyWaves.size(); x++) {
EnemyWave ew = (EnemyWave)_enemyWaves.get(x);

if (Math.abs(ew.distanceTraveled -
_myLocation.distance(ew.fireLocation)) < 50
&& Math.abs(bulletVelocity(e.getBullet().getPower())
- ew.bulletVelocity) < 0.001) {
hitWave = ew;
break;
}
}

if (hitWave != null) {
logHit(hitWave, hitBulletLocation);

// We can remove this wave now, of course.
_enemyWaves.remove(_enemyWaves.lastIndexOf(hitWave));
}
}
}

// CREDIT: mini sized predictor from Apollon, by rozu
// http://robowiki.net?Apollon
public ArrayList predictPositions(EnemyWave surfWave, int direction) {
Point2D.Double predictedPosition = (Point2D.Double)_myLocation.clone();
double predictedVelocity = getVelocity();
double maxTurning, moveAngle, moveDir;
ArrayList traveledPoints = new ArrayList();

int counter = 0; // number of ticks in the future
boolean intercepted = false;

do {
double distance = predictedPosition.distance(surfWave.fireLocation);
double offset = Math.PI/2 - 1 + distance/400;

moveAngle =
wallSmoothing(predictedPosition, absoluteBearing(surfWave.fireLocation,
predictedPosition) + (direction * (offset)), direction)
moveDir = 1;

if(Math.cos(moveAngle) < 0) {
moveAngle += Math.PI;
moveDir = -1;
}

moveAngle = Utils.normalRelativeAngle(moveAngle);

// maxTurning is built in like this, you can't turn more then this in one tick
maxTurning = Math.PI/720d*(40d - 3d*Math.abs(predictedVelocity));
+ limit(-maxTurning, moveAngle, maxTurning));

// this one is nice ;). if predictedVelocity and moveDir have
// different signs you want to breack down
// otherwise you want to accelerate (look at the factor "2")
predictedVelocity += (predictedVelocity * moveDir < 0 ? 2*moveDir : moveDir);
predictedVelocity = limit(-8, predictedVelocity, 8);

// calculate the new predicted position

//add this point the our prediction

counter++;

if (predictedPosition.distance(surfWave.fireLocation) - 20 <
surfWave.distanceTraveled + (counter * surfWave.bulletVelocity)
//   + surfWave.bulletVelocity
) {
intercepted = true;
}
} while(!intercepted && counter < 500);

//we can't get the the last point, because we need to slow down
if(traveledPoints.size() > 1)
traveledPoints.remove(traveledPoints.size() - 1);

return traveledPoints;
}

public double checkDanger(EnemyWave surfWave, Point2D.Double position) {
int index = getFactorIndex(surfWave, position);
double distance = position.distance(surfWave.fireLocation);
return _surfStats[index]/distance;
}

public Point2D.Double getBestPoint(EnemyWave surfWave){
if(surfWave.safePoints == null){
ArrayList forwardPoints = predictPositions(surfWave, 1);
ArrayList reversePoints = predictPositions(surfWave, -1);
int FminDangerIndex = 0;
int RminDangerIndex = 0;
double FminDanger = Double.POSITIVE_INFINITY;
double RminDanger = Double.POSITIVE_INFINITY;
for(int i = 0, k = forwardPoints.size(); i < k; i++){
double thisDanger = checkDanger(surfWave, (Point2D.Double)(forwardPoints.get(i)));
if(thisDanger <= FminDanger){
FminDangerIndex = i;
FminDanger = thisDanger;
}
}
for(int i = 0, k = reversePoints.size(); i < k; i++){
double thisDanger = checkDanger(surfWave, (Point2D.Double)(reversePoints.get(i)));
if(thisDanger <= RminDanger){
RminDangerIndex = i;
RminDanger = thisDanger;
}
}
ArrayList bestPoints;
int minDangerIndex;

if(FminDanger < RminDanger ){
bestPoints = forwardPoints;
minDangerIndex = FminDangerIndex;
}
else {
bestPoints = reversePoints;
minDangerIndex = RminDangerIndex;
}

Point2D.Double bestPoint = (Point2D.Double)bestPoints.get(minDangerIndex);

while(bestPoints.indexOf(bestPoint) != -1)
bestPoints.remove(bestPoints.size() - 1);

surfWave.safePoints = bestPoints;

//debugging - so that we should always be on top of the last point

}
else
if(surfWave.safePoints.size() > 1)
surfWave.safePoints.remove(0);

if(surfWave.safePoints.size() >= 1){
for(int i = 0,k=surfWave.safePoints.size(); i < k; i++){
Point2D.Double goToPoint = (Point2D.Double)surfWave.safePoints.get(i);
if(goToPoint.distanceSq(_myLocation) > 20*20*1.1)
//if it's not 20 units away we won't reach max velocity
return goToPoint;
}
//if we don't find a point 20 units away, return the end point
return (Point2D.Double)surfWave.safePoints.get(surfWave.safePoints.size() - 1);

}

return null;
}

public void doSurfing() {
EnemyWave surfWave = getClosestSurfableWave();
double distance = _enemyLocation.distance(_myLocation);
if (surfWave == null || distance < 50) {
//do 'away' movement  best distance of 400 - modified from RaikoNano
double absBearing = absoluteBearing(_myLocation, _enemyLocation);
double stick = 160;//Math.min(160,distance);
double  v2, offset = Math.PI/2 + 1 - distance/400;

while(!_fieldRect.
contains(project(_myLocation,v2 = absBearing + direction*(offset -= 0.02), stick)

// 	getX() + stick * Math.sin(v2 = absBearing + direction * (offset -= .02)), getY() + stick * Math.cos(v2)
));

if( offset < Math.PI/3 )
direction = -direction;

}
else
goTo(getBestPoint(surfWave));
}
private void goTo(Point2D.Double destination) {
if(destination == null){
if(_lastGoToPoint != null)
destination = _lastGoToPoint;
else
return;
}

_lastGoToPoint = destination;
Point2D.Double location = new Point2D.Double(getX(), getY());
double distance = location.distance(destination);
if (Math.abs(angle) > Math.PI/2) {
distance = -distance;
if (angle > 0) {
angle -= Math.PI;
}
else {
angle += Math.PI;
}
}

//this is hacked so that the bot doesn't turn once we get to our destination

}

// This can be defined as an inner class if you want.
class EnemyWave {
Point2D.Double fireLocation;
long fireTime;
double bulletVelocity, directAngle, distanceTraveled;
int direction;
ArrayList safePoints;

public EnemyWave() { }
}

// CREDIT: Iterative WallSmoothing by Kawigi
//   - return absolute angle to move at after account for WallSmoothing
// robowiki.net?WallSmoothing
public double wallSmoothing(Point2D.Double botLocation, double angle, int orientation) {
while (!_fieldRect.contains(project(botLocation, angle, 160))) {
angle += orientation*0.05;
}
return angle;
}

// CREDIT: from CassiusClay, by PEZ
//   - returns point length away from sourceLocation, at angle
// robowiki.net?CassiusClay
public static Point2D.Double project(Point2D.Double sourceLocation, double angle, double length) {
return new Point2D.Double(sourceLocation.x + Math.sin(angle) * length,
sourceLocation.y + Math.cos(angle) * length);
}

// got this from RaikoMicro, by Jamougha, but I think it's used by many authors
//  - returns the absolute angle (in radians) from source to target points
public static double absoluteBearing(Point2D.Double source, Point2D.Double target) {
return Math.atan2(target.x - source.x, target.y - source.y);
}

public static double limit(double min, double value, double max) {
return Math.max(min, Math.min(value, max));
}

public static double bulletVelocity(double power) {
return (20D - (3D*power));
}

public static double maxEscapeAngle(double velocity) {
return Math.asin(8.0/velocity);
}

public static void setBackAsFront(AdvancedRobot robot, double goAngle) {
double angle =
if (Math.abs(angle) > (Math.PI/2)) {
if (angle < 0) {
}
else {
}
robot.setBack(100);
}
else {
if (angle < 0) {
}
else {
}
}
}

public void onPaint(java.awt.Graphics2D g) {
g.setColor(Color.red);
for(int i = 0; i < _enemyWaves.size(); i++){
EnemyWave w = (EnemyWave)(_enemyWaves.get(i));
Point2D.Double center = w.fireLocation;

//int radius = (int)(w.distanceTraveled + w.bulletVelocity);
//hack to make waves line up visually, due to execution sequence in robocode engine
//use this only if you advance waves in the event handlers (eg. in onScannedRobot())
//NB! above hack is now only necessary for robocode versions before 1.4.2
//otherwise use: