User:Chase-san/NewTech/KakeruCode

Code for version MC25

package cs;

/*
 * Dear Future Chase,
 * 
 * I cannot even begin to express how deeply sorry I am.
 * But I assure you, at the time, I (probably) knew what I was doing.
 * 
 * -Chase
 * 
 * P.S. I am trying to leave comments,
 *      but you know how bad I am at those.
 */

import java.awt.Color;
import java.util.Iterator;
import java.util.LinkedList;

import robocode.Bullet;
import robocode.BulletHitBulletEvent;
import robocode.BulletHitEvent;
import robocode.Event;
import robocode.HitByBulletEvent;
import robocode.Rules;
import robocode.ScannedRobotEvent;
import robocode.util.Utils;

import cs.geom.*;
import cs.util.Simulate;
import cs.util.Wave;

/**
 * Movement
 * <br/><br/>
 * In Japanese, Kakeru means "Dash"
 * @author Chase
 */
public abstract class Kakeru extends Chikaku {
	//Dear Future Chase,
	//
	// 
	// But please 
	//
	// Cheers,
	// Current Chase
	
	private static class TurnEntry {
		public Vector myPosition;
		public Vector enemyPosition;
		public double myLateralVelocity;
	}
	
	private static class DriveData {
		double angleToTurn = 0;
		double maxVelocity = Rules.MAX_VELOCITY;
		int direction = 1;
	}
	
	private static class DangerData {
		double danger;
		double maxVelocity;
		int orbitDirection;
	}
	
	/**
	 * Time needed to turn a quarter circle if we are not moving, the actual movement
	 * should be against the current velocity for this, but since we stop moving when
	 * we goto turn its only 4 turns to stop moving and we have some time usually before
	 * the first bullet gets to us
	 */
	private static final double turnsNeededToTurnQuarter = (Math.PI/2.0)/Rules.MAX_TURN_RATE_RADIANS;
	
	public LinkedList<TurnEntry> history = new LinkedList<TurnEntry>();
	public LinkedList<Wave> enemyWaves = new LinkedList<Wave>();
	public static LinkedList<Double> hitFactors = new LinkedList<Double>();
	public static LinkedList<Double> enemyBulletPower = new LinkedList<Double>();
	public double enemyGunHeat = 0;
	
	/**
	 * <pre>
	 *  1 = clockwise
	 * -1 = counter-clockwise
	 * </pre>
	 */
	public int orbitDirection = 1;
	
	public Vector lastEnemyPosition = new Vector();
	public double lastEnemyEnergy = 100;
	
	public void onBattleStarted(Event e) {
		hitFactors.addLast((Double)0.0);
		enemyBulletPower.addLast((Double)3.0);
	}
	
	public void onRoundStarted(Event e) {
		super.onRoundStarted(e);
		
		println("hitFactors: " + hitFactors.size());
		
		firstScan = true;
	}
	
	private boolean imaginaryFired = false;
	private boolean firstScan = false;
	public void onScannedRobot(ScannedRobotEvent e) {
		super.onScannedRobot(e);
		
		enemyGunHeat -= peer.getGunCoolingRate();
		if(enemyGunHeat <= 0)
			enemyGunHeat = 0;
		
		if(firstScan) {
			enemyGunHeat = status.getGunHeat();
			firstScan = false;
		}
		
		/*
		 * Setup current history
		 */
		double angleToEnemy = e.getBearingRadians() + status.getHeadingRadians();
		
		TurnEntry entry = new TurnEntry();
		entry.myPosition = myPosition;
		entry.enemyPosition = myPosition.projectNew(angleToEnemy, e.getDistance());
		entry.myLateralVelocity = status.getVelocity()*Math.sin(e.getBearingRadians());
		
		orbitDirection = Tools.sign(entry.myLateralVelocity);
		
		history.addFirst(entry);
		


		/*
		 * Check for new enemy wave
		 */
		double enemyEnergy = e.getEnergy();
		double energyDelta = lastEnemyEnergy - enemyEnergy;
		if(energyDelta > 0 && energyDelta <= 3.0) {
			enemyGunHeat += Rules.getGunHeat(energyDelta);
			imaginaryFired = false;
			
			Wave wave = new Wave();
			wave.set(lastEnemyPosition);
			wave.fireTime = time - 1;
			wave.power = energyDelta;
			wave.speed = Rules.getBulletSpeed(energyDelta);
			
			TurnEntry stat = history.get(2);
			wave.directAngle = stat.enemyPosition.angleTo(stat.myPosition);
			
			int direction = Tools.sign(stat.myLateralVelocity);
			wave.escapeAngle = Math.asin(8.0/wave.speed) * direction;
			
			enemyBulletPower.addLast(energyDelta);
			if(enemyBulletPower.size() == 5) {
				enemyBulletPower.removeFirst();
			}
			
			enemyWaves.add(wave);
		}
		
		/*
		 * Setup data for next round.
		 */
		lastEnemyPosition.set(entry.enemyPosition);
		lastEnemyEnergy = enemyEnergy;
		
		g.setColor(Color.YELLOW);
		g.drawLine((int)myPosition.x, (int)myPosition.y, (int)lastEnemyPosition.x, (int)lastEnemyPosition.y);
		
		g.setColor(Color.RED);
		Vector v = myPosition.copy();
		v.add(lastEnemyPosition);
		v.scale(0.5);
		
		g.drawString(""+e.getDistance(), (int)v.x, (int)v.y);
		
		/**
		 * Calculate imaginary wave
		 */
		if(!imaginaryFired && enemyGunHeat <= peer.getGunCoolingRate()*2.0) {
			imaginaryFired = true;
			//add up average bullet power
			double power = 0;
			for(Double p : enemyBulletPower) {
				power += p;
			}
			power /= enemyBulletPower.size();
			
			//Add virtual wave :D
			Wave wave = new Wave();
			
			//lastEnemyPosition
			
			wave.set(simulatedEnemyPosition);
			wave.fireTime = time + 1;
			wave.power = power;
			wave.speed = Rules.getBulletSpeed(power);
			
			wave.directAngle = entry.enemyPosition.angleTo(entry.myPosition);
			
			int direction = Tools.sign(entry.myLateralVelocity);
			wave.escapeAngle = Math.asin(8.0/wave.speed) * direction;
			wave.imaginary = true;
			
			enemyWaves.add(wave);
		}
	}
	
	public void onTurnEnded(Event e) {
		super.onTurnEnded(e);
		
		/*
		 * Don't move if we are scanning, this is mostly start
		 * of round fast radar finding protection
		 */
		if(initialTick != 0)
			return;
		
		checkWaves();
		
		doMovement();
	}
	
	/**
	 * Run our actual movement
	 */
	public void doMovement() {
		//find the wave soonest to hit us
		Wave wave = null;
		double bestETA = Double.POSITIVE_INFINITY;
		for(Wave check : enemyWaves) {
			double distance = myPosition.distance(check) - check.getRadius(time);
			double ETA = distance / check.speed;
			
			if(ETA < bestETA) {
				//If we are already surfing a strong wave
				//that will hit at almost the same time
				//do not switch to this wave, more powerful
				//waves are slower and thus will always be
				//shot first for this to occur, which is why
				//we don't need an else on the ETA < bestETA
				
				//This is mostly just a hack for some score
				if(wave != null && ETA > bestETA - 3) {
					if(check.power > wave.power) {
						wave = check;
						bestETA = ETA;
					}
				} else {
					wave = check;
					bestETA = ETA;
				}
			}
			
		}
		
		double heading = status.getHeadingRadians();
		double velocity = status.getVelocity();
		
		//There is no wave for us to surf!
		if(wave == null) {
			double safeTurns = status.getGunHeat()/peer.getGunCoolingRate();
			
			//Do we have enough time to move around before they can start firing?
			if(safeTurns > turnsNeededToTurnQuarter) {
				//No waves movement
				
				//Here we drive away from the enemy as best as we can
				
				double travelAngle = lastEnemyPosition.angleTo(myPosition);
				
				//TODO better wall smoothing
				while(!field.contains(myPosition.projectNew(travelAngle, 140))) {
					travelAngle += 0.08*orbitDirection;
				}
				
				double angleToTurn = Utils.normalRelativeAngle(travelAngle - status.getHeadingRadians());
				int direction = 1;
				
				if(Math.abs(angleToTurn) > Math.PI/2.0) {
					angleToTurn = Utils.normalRelativeAngle(angleToTurn - Math.PI);
					direction = -1;
				}
				
				
				//Slow down so we do not ram head long into the walls and can instead turn to avoid them
				//FIXME We only have to do this because of the wall smoothing, fix that to get rid of this!
				double maxVelocity = Rules.MAX_VELOCITY;
				
				if(!field.contains(myPosition.projectNew(heading, velocity*3.25)))
					maxVelocity = 0;
				
				if(!field.contains(myPosition.projectNew(heading, velocity*5)))
					maxVelocity = 4;
				
				
				peer.setMaxVelocity(maxVelocity);
				peer.setTurnBody(angleToTurn);
				peer.setMove(100*direction);
			} else {
				//turn to face perpendicular to the enemy while we have time to do so!
				DriveData data = doDrive(myPosition,lastEnemyPosition,
						status.getHeadingRadians(),status.getVelocity(),orbitDirection);
				peer.setTurnBody(data.angleToTurn);
				peer.setMaxVelocity(0);
			}
			
			return;
		}
		
		//Do the actual surfing and such
		
		g.setColor(Color.ORANGE);
		
		peer.setMaxVelocity(Rules.MAX_VELOCITY);
		
		//DONE make the direction data a class instead
		DangerData[] directions = new DangerData[] {
			calculateDanger(wave,orbitDirection,0),
			calculateDanger(wave,orbitDirection,Rules.MAX_VELOCITY),
			calculateDanger(wave,-orbitDirection,Rules.MAX_VELOCITY),
		};
		
		int bestIndex = 0;
		double leastDanger = Double.POSITIVE_INFINITY;
		for(int i = 0; i < directions.length; ++i) {	
			if(directions[i].danger < leastDanger) {
				bestIndex = i;
				leastDanger = directions[i].danger;
			}
		}
				
		DriveData driver = doDrive(myPosition,lastEnemyPosition,
				status.getHeadingRadians(),status.getVelocity(),
				directions[bestIndex].orbitDirection );
		
		double forward = 100;
		
		peer.setMaxVelocity(Math.min(directions[bestIndex].maxVelocity,driver.maxVelocity));
		peer.setTurnBody(driver.angleToTurn);
		peer.setMove(forward*driver.direction);
		peer.setCall();
	}
	
	private DangerData calculateDanger(Wave wave, int orbitDirection, double maxVelocity) {
		//Here we just propagate the stuff we got from the input
		//so that we do not have to write it again in the array somehow
		DangerData data = new DangerData();
		data.orbitDirection = orbitDirection;
		data.maxVelocity = maxVelocity;
		
		//Simulate ahead a single step, no need to calculate for a position 
		// (that is our current one) that we can do nothing about
		Simulate sim = createSimulator();
		sim.maxVelocity = maxVelocity;
		sim.direction = orbitDirection;
		doDrive(sim,wave,orbitDirection);
		
		sim.step();
		sim.maxVelocity = maxVelocity;
		
		//Originally I divided by this, at the moment I do not anymore
		int intersected = 0;
		
		long timeOffset = 1;
		double danger = 0;
		
		//Reset the factors for the wave we are surfing, don't need old
		// data messing up our calculations, now do we?
		wave.resetFactors();
		
		while(true) {
			//DRAW DANGER MOVEMENT
			g.drawOval((int)sim.position.x-3, (int)sim.position.y-3, 6, 6);
			
			//Every time we intersect iterate
			if(wave.doesIntersect(sim.position, time+timeOffset)) {
				++intersected;
				
			} else if(intersected > 0) {
				//After the intersection is complete calculate the danger
				//for the entire span we intersected
				double intersectDanger = 0;
				
				double factorCenter = (wave.minFactor + wave.maxFactor) / 2.0;
				
				for(Double d : hitFactors) {
					intersectDanger += 0.1/(1.0+Math.abs(d-factorCenter));
					if(wave.minFactor < d && wave.maxFactor > d) {
						intersectDanger += 1.0;
					}
				}
				
				danger += intersectDanger;
				
				intersected = -1;
				break;
			}
			
			//Use our driving method to determine where we will go next
			doDrive(sim,wave,orbitDirection);
			sim.step();
			sim.maxVelocity = maxVelocity;
			
			if(++timeOffset > 24)
				break;
		}
		
		data.danger = danger;
		return data;
	}

	private void doDrive(Simulate sim, Wave wave, int orbitDirection) {
		DriveData data = doDrive(sim.position,wave,
				sim.heading,sim.velocity,orbitDirection);
		
		sim.angleToTurn = data.angleToTurn;
		sim.direction = data.direction;
		sim.maxVelocity = Math.min(sim.maxVelocity, data.maxVelocity);
	}
	
	/**
	 * Calculate the driving
	 */
	private DriveData doDrive(Vector myPosition, Vector orbitCenter,
			double myHeading, double myVelocity, int orbitDirection) {
		DriveData data = new DriveData();
		
		double angleToRobot = orbitCenter.angleTo(myPosition);
		
		//if the orbit direction is clockwise/counter, we want to try and point
		//our robot in that direction, which is why we multiply by it
		double travelAngle = angleToRobot + (Math.PI/2.0) * orbitDirection;
		
		//DONE add distancing to drive method
		//TODO add a better distancing method
		double distance = myPosition.distance(orbitCenter);
		final double best = 500.0;
		double distancing = ((distance-best)/best);
		
		travelAngle += distancing*orbitDirection;
		
		//DONE add a wall smoothing method
		//TODO add a better wall smoothing method
		while(!field.contains(myPosition.projectNew(travelAngle, 140))) {
			travelAngle += 0.08*orbitDirection;
		}
		
		data.angleToTurn = Utils.normalRelativeAngle(travelAngle - myHeading);
		data.direction = 1;
		
		//If our backend is closer to direction, use that instead, and inform
		//the caller that we are going to be going in reverse instead
		if(Math.abs(data.angleToTurn) > Math.PI/2.0) {
			data.angleToTurn = Utils.normalRelativeAngle(data.angleToTurn - Math.PI);
			data.direction = -1;
		}
		
		//Slow down so we do not ram head long into the walls and can instead turn to avoid them
		//FIXME We only have to do this because of the wall smoothing, fix that to get rid of this!
		if(!field.contains(myPosition.projectNew(myHeading, myVelocity*3.25)))
			data.maxVelocity = 0;
		
		if(!field.contains(myPosition.projectNew(myHeading, myVelocity*5)))
			data.maxVelocity = 4;
		
		return data;
	}
	
	/**
	 * Account for our bullets hitting the enemy
	 */
	public void onBulletHit(BulletHitEvent e) {
		super.onBulletHit(e);
		
		//get the power of the bullet of ours that hit
		double bulletPower = e.getBullet().getPower();
		
		//determine how much damage our bullet does to the enemy
		//and adjust our stored copy to reflect the amount lost
		lastEnemyEnergy -= Rules.getBulletDamage(bulletPower);
	}
	
	/**
	 * Account for one of our bullets hitting an enemy bullet.
	 */
	public void onBulletHitBullet(BulletHitBulletEvent e) {
		super.onBulletHitBullet(e);
		
		handleBullet(e.getHitBullet());
	}
	
	/**
	 * Account for one of the enemies bullets hitting us.
	 */
	public void onHitByBullet(HitByBulletEvent e) {
		super.onHitByBullet(e);
		
		//increase the enemy energy based on how powerful the bullet that hit us was
		//this is so we can get reliable energy drop detection
		lastEnemyEnergy += Rules.getBulletHitBonus(e.getPower());
		
		handleBullet(e.getBullet());
	}
	
	/**
	 * Handle an actual enemy bullet
	 */
	private void handleBullet(Bullet b) {
		Vector bulletPosition = new Vector(b.getX(),b.getY());
		
		//Find the matching wave
		Iterator<Wave> waveIterator = enemyWaves.iterator();
		while(waveIterator.hasNext()) {
			Wave wave = waveIterator.next();
			
			//the current distance of the wave
			double radius = wave.speed*(time - wave.fireTime);
			
			//check if the power is close enough to be our wave
			//this margin is small, only to allow room for rounding errors
			if(Math.abs(b.getPower()-wave.power) < 0.001) {
				
				//check if the bullets distance from the center of the wave is
				//close to our waves radius.
				
				//this margin is small, only to allow room for rounding errors
				if(Math.abs(wave.distanceSq(bulletPosition)-radius*radius) < 0.1) {
					//FIXME extensively test this detection method
					
					//Alternate method, but why recalculate something? Could be used as an extra check.
					//double angleToBullet = wave.angleTo(bulletPosition);
					
					double angleToBullet = b.getHeadingRadians();
					double angleOffsetFromBase =
						Utils.normalRelativeAngle(angleToBullet - wave.directAngle);
					
					double bulletGuessfactor = angleOffsetFromBase / wave.escapeAngle;
					
					debug("Hit @ GF " + bulletGuessfactor);
					
					hitFactors.addLast(bulletGuessfactor);
					
					//FIXME Temporary, only allow 17 factors to be in the buffer at a time
					if(hitFactors.size() == 17) {
						hitFactors.removeFirst();
					}
					
					waveIterator.remove();
					
					break;
				}
			}
		}
	}
	
	/**
	 * Check waves to be removed after they pass
	 */
	private void checkWaves() {
		Iterator<Wave> waveIterator = enemyWaves.iterator();
		while(waveIterator.hasNext()) {
			Wave wave = waveIterator.next();
			
			double radius = wave.getRadius(time);
			
			///////////////////////
			//DRAW WAVE
			if(wave.imaginary) {
				g.setColor(new Color(32,32,32));
			} else {
				g.setColor(new Color(128,128,128));
			}
			double escape = Math.abs(wave.escapeAngle);
			g.drawArc(
					(int)(wave.x - radius), (int)(wave.y - radius),
					(int)(radius*2), (int)(radius*2),
					(int)Math.toDegrees(wave.directAngle-escape),
					(int)Math.toDegrees(escape*2));
			//END DRAW WAVE
			///////////////////////
			
			if(wave.imaginary) {
				//if the wave is imaginary (a heat wave)
				//we should remove it automatically after
				//2 ticks which is when we will detect their
				//actual wave, if they fire
				if(time - wave.fireTime > 2) {
					waveIterator.remove();
				}
			} else
			
			/*
			 * Clean up waves that can no longer hit us
			 */
			if(wave.didIntersect(myPosition, time)) {
				waveIterator.remove();
			}
		}
	}
}