WartHog

java.lang.Object
- AdvancedRobot
- - com.oroup.robocode.WartHog

```
public class WartHog
extends AdvancedRobot
```
This is a tank for Robocode.

The latest version should be available at https://oroup.com/pub/warthog/

The source code is available at https://oroup.com/pub/warthog/WartHog.java

The javadoc is available at https://oroup.com/pub/warthog/javadoc/com/oroup/robocode/WartHog.html

This tank takes the basic strategy of always moving, trying to maintain a fixed range from the best target and firing on it when it thinks it can hit. In case you're wondering, the WartHog is what people call the American A-10 Tank Killer airplane.
TODO:
- The tank sometimes gets stuck against the walls. The movement algorithm could be much smarter.
- The constants are just first guesses and not tuned at all. I should write statistics gathering routines to help tune those values or make them dynamic.
- If the tank can't detect any enemies (on a big field) the wandering algorithm should be smarter.
- If there are multiple enemies still present, we could go into "lurk" mode to let everyone else fight it out, and then face the victor fresh.
Author:

Oliver Roup oroup@oroup.com

Constructor Summary

Constructors
Constructor and Description

WartHog()

Constructors
Constructor and Description
`WartHog()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`double`	`bearing(com.oroup.robocode.WartHog.Point p)` Calculates the bearing from the tank to the point.
`double`	`bulletFlightTime(double distance, double force)` Calculate how long a bullet will take to fly a certain distance.
`double`	`bulletVelocity(double force)`
`double`	`computeForce(com.oroup.robocode.WartHog.Enemy enemy)` Compute how hard to fire at an enemy.
`double`	`distance(com.oroup.robocode.WartHog.Point p)` Calculates the distance from the tank to the point.
`com.oroup.robocode.WartHog.Enemy`	`getBestEnemy()` Find the juiciest target to shoot at.
`com.oroup.robocode.WartHog.Point`	`getPoint()` Returns the current position of the tank as a point.
`com.oroup.robocode.WartHog.Point`	`getRadDelt(double dist, double heading)` Given a distance and a direction, compute the point we will arrive at.
`double`	`gunBearingTolerance(com.oroup.robocode.WartHog.Point target, double gunBearing)` Given a target point, and a gun bearing, figure out how close the bullet will come to the target.
`static void`	`main(java.lang.String[] args)`
`double`	`normalizeAngle(double angle)` Converts any angle to be between -180 and 180.
`void`	`onHitRobot(HitRobotEvent e)` If we hit a robot, change directions if that will get us away from what we hit.
`void`	`onHitWall(HitWallEvent e)` If we hit a wall change directions.
`void`	`onRobotDeath(RobotDeathEvent e)` If a robot dies, remove it from our list so we don't go after dead enemies.
`void`	`onScannedRobot(ScannedRobotEvent e)` If we see an enemy, figure out where it is and store it's data away.
`void`	`run()` The tank execution loop: Spin the radar.
`void`	`setGunHeading(double heading)` Turn the gun to the heading supplied using whichever direction is faster.
`void`	`setHeading(double heading)` Turns the tank to the supplied heading, using whichever direction is fastest.
`double`	`triangulate(double distToTarget, double rangeToKeep, double distanceToCover)` There is a point we want to target, but we want to keep a certain distance from it, and there's a certain amount of distance we can cover this turn.
`void`	`updateEnemyData(java.lang.String name, com.oroup.robocode.WartHog.Point point, double heading, double velocity, long time)` Save away all the data about enemies that we see.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - WartHog
```
public WartHog()
```
- Method Detail
  - run
```
public void run()
```
    The tank execution loop:
    1. Spin the radar.
    2. Find the best target.
    3. Move to the correct range from the enemy.
    4. Compute a firing solution.
    5. Aim the gun.
    6. If we can hit, fire.
  - onScannedRobot
```
public void onScannedRobot(ScannedRobotEvent e)
```
    If we see an enemy, figure out where it is and store it's data away.
    
    Parameters:
    
    e - ScannedRobotEvent
  - onHitRobot
```
public void onHitRobot(HitRobotEvent e)
```
    If we hit a robot, change directions if that will get us away from what we hit.
    
    Parameters:
    
    e - HitRobotEvent
  - onHitWall
```
public void onHitWall(HitWallEvent e)
```
    If we hit a wall change directions.
    
    Parameters:
    
    e - HitWallEvent
  - onRobotDeath
```
public void onRobotDeath(RobotDeathEvent e)
```
    If a robot dies, remove it from our list so we don't go after dead enemies.
    
    Parameters:
    
    e - RobotDeathEvent
  - getBestEnemy
```
public com.oroup.robocode.WartHog.Enemy getBestEnemy()
```
    Find the juiciest target to shoot at.
    
    Returns:
    
    The best target
  - computeForce
```
public double computeForce(com.oroup.robocode.WartHog.Enemy enemy)
```
    Compute how hard to fire at an enemy.
    
    Parameters:
    
    enemy - The enemy to calculate force for
    
    Returns:
    
    The force we should fire at.
  - bulletFlightTime
```
public double bulletFlightTime(double distance,
                               double force)
```
    Calculate how long a bullet will take to fly a certain distance.
    
    Parameters:
    
    distance - The distance for the bullet to travel
    
    force - The force of the bullet.
    
    Returns:
    
    The time the bullet will take to travel.
  - bulletVelocity
```
public double bulletVelocity(double force)
```
  - gunBearingTolerance
```
public double gunBearingTolerance(com.oroup.robocode.WartHog.Point target,
                                  double gunBearing)
```
    Given a target point, and a gun bearing, figure out how close the bullet will come to the target.
    
    Parameters:
    
    target - The point we are shooting at.
    
    gunBearing - The actual bearing of our gun.
    
    Returns:
    
    The distance the bullet will come to the target.
  - updateEnemyData
```
public void updateEnemyData(java.lang.String name,
                            com.oroup.robocode.WartHog.Point point,
                            double heading,
                            double velocity,
                            long time)
```
    Save away all the data about enemies that we see.
    
    Parameters:
    
    name - The name of the enemy.
    
    point - The position of the enemy.
    
    heading - The enemy heading
    
    velocity - The enemy velocity
    
    time - The time we saw this enemy.
  - setHeading
```
public void setHeading(double heading)
```
    Turns the tank to the supplied heading, using whichever direction is fastest.
    
    Parameters:
    
    heading - The heading for the tank to assume
  - setGunHeading
```
public void setGunHeading(double heading)
```
    Turn the gun to the heading supplied using whichever direction is faster.
    
    Parameters:
    
    heading - The heading for the gun to assume.
  - distance
```
public double distance(com.oroup.robocode.WartHog.Point p)
```
    Calculates the distance from the tank to the point.
    
    Parameters:
    
    p - The point
    
    Returns:
    
    The distance
  - bearing
```
public double bearing(com.oroup.robocode.WartHog.Point p)
```
    Calculates the bearing from the tank to the point.
    
    Parameters:
    
    p - The point
    
    Returns:
    
    The bearing
  - normalizeAngle
```
public double normalizeAngle(double angle)
```
    Converts any angle to be between -180 and 180.
    
    Parameters:
    
    angle - The supplied angle.
    
    Returns:
    
    The normalized angle
  - getPoint
```
public com.oroup.robocode.WartHog.Point getPoint()
```
    Returns the current position of the tank as a point.
    
    Returns:
    
    The current position of the tank
  - getRadDelt
```
public com.oroup.robocode.WartHog.Point getRadDelt(double dist,
                                                   double heading)
```
    Given a distance and a direction, compute the point we will arrive at.
    
    Parameters:
    
    dist - The distance
    
    heading - The heading
    
    Returns:
    
    The point
  - triangulate
```
public double triangulate(double distToTarget,
                          double rangeToKeep,
                          double distanceToCover)
```
    There is a point we want to target, but we want to keep a certain distance from it, and there's a certain amount of distance we can cover this turn. This function uses the law of cosines to compute which direction to head relative to the target bearing so that we maintain the range from the target. Law of cosines: c^2 = a^2 + b^2 - 2ab cos(C); Not currently used.
    
    Parameters:
    
    distToTarget - Distance to target
    
    rangeToKeep - Range to keep
    
    distanceToCover - Distance to cover
    
    Returns:
    
    Angle to target
  - main
```
public static void main(java.lang.String[] args)
                 throws java.lang.Throwable
```
    Throws:
    
    java.lang.Throwable

Class WartHog

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

WartHog

Method Detail

run

onScannedRobot

onHitRobot

onHitWall

onRobotDeath

getBestEnemy

computeForce

bulletFlightTime

bulletVelocity

gunBearingTolerance

updateEnemyData

setHeading

setGunHeading

distance

bearing

normalizeAngle

getPoint

getRadDelt

triangulate

main