[Home]Komarious/Code

Robo Home | Komarious | Changes | Preferences | AllPages

Difference (from prior major revision) (minor diff, author diff)

Changed: 1c1
This is the code to Komarious 1.59. Code size is 1359 when compiled with Jikes (no colors).
This is the code to Komarious 1.712. Code size is 1492 when compiled with Jikes (3 colors = 13 bytes).

Added: 11a12
import java.awt.Color;

Added: 30a32
private static double _nextSurfSegment?[];

Changed: 44c46



Changed: 47c49



Changed: 66c68,69
static double[][][][][] _gunStats = new double[5][3][4][3][GF_ONE+1];
static double[][][][][][] _gunStats = new double[6][4][4][2][3][GF_ONE+1];
static final double LOG_BASE_E_TO_2_CONVERSION_CONSTANT = 1.4427;

Changed: 71c74
// setColors(Color.black, null, Color.white);
setColors(Color.black, Color.black, Color.white);

Changed: 94c97
w.waveGuessFactors = _surfStats[(int)(Math.min((_lastDistance+50)/200, 3))][(int)((Math.abs(_lastLatVel?)+1)/2)];
w.waveGuessFactors = _nextSurfSegment?;

Added: 96a100
_nextSurfSegment? = _surfStats[(int)(Math.min((_lastDistance+50)/200, 3))][(int)((Math.abs(_lastLatVel?)+1)/2)];

Changed: 140c144,145
_lastGunOrientation? = w.orientation = sign((e.getVelocity())*Math.sin(e.getHeadingRadians() - _enemyAbsoluteBearing?));
double enemyLatVel?;
_lastGunOrientation? = w.orientation = sign(enemyLatVel? = (e.getVelocity())*Math.sin(e.getHeadingRadians() - _enemyAbsoluteBearing?));

Changed: 142,143c147,148
int bestGF = Math.min(2, (int)(Math.sqrt(153D*lastVChangeTime?++/_lastDistance)));
// int bestGF = Math.min(2, (int)(Math.sqrt(120D*lastVChangeTime?++/_lastDistance))); // TC
int bestGF = Math.min(3, (int)(Math.pow(280*lastVChangeTime?++/_lastDistance, .7)));
// int bestGF = Math.min(3, (int)(Math.sqrt(220D*lastVChangeTime?++/_lastDistance))); // TC

Changed: 145c150
if (enemyVelocity != (newVelocity = (int)(Math.abs(e.getVelocity())))) {
if (enemyVelocity != (newVelocity = (int)(enemyLatVel? = Math.abs(enemyLatVel?)))) {

Changed: 147c152
bestGF = 3;
bestGF = 4;

Changed: 149c154
bestGF = 4;
bestGF = 5;

Added: 151a157,158
enemyVelocity = newVelocity;


Removed: 153,157d159
w.bulletVelocity = 14D;
w.distance = -21;
// w.bulletVelocity = 11D; // TC
// w.distance = -16.5;


Changed: 160,161c162,163
w.waveGuessFactors = _gunStats[bestGF][(int)((enemyVelocity = newVelocity)/3)][gunWallDistance(0.15206139473) ? (gunWallDistance(0.30412278946) ? (gunWallDistance(0.45618418419) ? 3 : 2) : 1) : 0][(int)Math.min(2, _lastDistance/200)];
// w.waveGuessFactors = _gunStats[bestGF][(int)((enemyVelocity = newVelocity)/3)][gunWallDistance(.20358498553) ? (gunWallDistance(0.40716997107) ? (gunWallDistance(0.61075495659) ? 3 : 2) : 1) : 0][(int)Math.min(2, _lastDistance/200)]; // TC
w.waveGuessFactors = _gunStats[bestGF][(int)(LOG_BASE_E_TO_2_CONVERSION_CONSTANT * Math.log(enemyLatVel? + 1.5))][gunWallDistance(0.18247367367) ? (gunWallDistance(0.36494734735) ? (gunWallDistance(0.63865785787) ? 3 : 2) : 1) : 0][gunWallDistance(-0.36494734735) ? 0 : 1][(int)limit(0, (_lastDistance-75)/200, 2)];
// w.waveGuessFactors = _gunStats[bestGF][(int)(LOG_BASE_E_TO_2_CONVERSION_CONSTANT * Math.log(enemyLatVel? + 1.5))][gunWallDistance(0.24430198263) ? (gunWallDistance(0.48860396528) ? (gunWallDistance(0.85505693924) ? 3 : 2) : 1) : 0][gunWallDistance(-0.48860396528) ? 0 : 1][(int)limit(0, (_lastDistance-75)/200, 2)]; // TC

Changed: 169c171,175
setTurnGunRightRadians?(Utils.normalRelativeAngle(_enemyAbsoluteBearing? - getGunHeadingRadians?() + ((_lastGunOrientation?*.02644545995)*(bestGF-GF_ZERO)) ));
double power = 2 - Math.max(0, (30 - getEnergy()) / 16);
// double power = 3; // TC
w.distance = -1.5 * (w.bulletVelocity = (20 - 3*power));

setTurnGunRightRadians?(Utils.normalRelativeAngle(_enemyAbsoluteBearing? - getGunHeadingRadians?() + ((_lastGunOrientation?*(Math.asin(8/w.bulletVelocity)/GF_ZERO))*(bestGF-GF_ZERO)) ));

Changed: 172c178
if (getEnergy() > 2 && Math.abs(getGunTurnRemaining?()) < 3 && setFireBullet(2 + (_ramCounter / (3*getRoundNum?()+1))) != null) {
if (Math.abs(getGunTurnRemaining?()) < 3 && setFireBullet(power + (_ramCounter / (3*getRoundNum?()+1))) != null) {

Added: 184a191
_oppEnergy += e.getBullet().getPower() * 3;

Added: 192a200,205

public void onBulletHit?(BulletHitEvent? e) {
double bulletPower;
_oppEnergy -= (bulletPower = e.getBullet().getPower()) * 4 +
(Math.max(0, bulletPower - 1) * 2);
}

Removed: 342d354


This is the code to Komarious 1.712. Code size is 1492 when compiled with Jikes (3 colors = 13 bytes).


package voidious.mini;

import robocode.*;
import robocode.util.Utils;
import java.awt.geom.*;
import java.util.LinkedList;
import java.awt.Color;

/**
 * Komarious - a MiniBot by Voidious
 *
 * She's a duelist, and assumes it's a 1 on 1. This is a first attempt by
 * Voidious at making a mini-WaveSurfer.
 *
 * CREDITS:
 *   Jamougha - gun based on RaikoMicro 1.44
 *   rozu - mini-sized PrecisePrediction from Apollon
 *   Iiley - small codesize BackAsFront method
 *   PEZ - iterative WallSmoothing algorithm
 *
 * Code is open source, released under the RoboWiki Public Code License:
 * http://robowiki.net/cgi-bin/robowiki?RWPCL
 */

public class Komarious extends AdvancedRobot {
    private static double _surfStats[][][] = new double[4][5][47];
    private static double _nextSurfSegment[];
    public static Point2D.Double _myLocation;
    public static Point2D.Double _enemyLocation;
    public static LinkedList _enemyWaves;
    private static double _oppEnergy;

    private static Wave _surfWave;
    private static double _lastDistance;

    private static int _lastLastOrientation;
    private static double _lastLatVel;
    private static double _lastLastAbsBearingRadians;
    private static double _lastAbsBearingRadians;
    private static double _lastPredictedDistance;
    
    private static double _goAngle;
    private static int _ramCounter;
    
    private static java.awt.geom.Rectangle2D.Double _fieldRect
        = new java.awt.geom.Rectangle2D.Double(18, 18, 764, 564);

    // Math.PI/2 would be perpendicular movement, less will keep moving
    // further away
    static final double A_LITTLE_LESS_THAN_HALF_PI = 1.25;
    static final double WALL_STICK = 140;

    static final int GF_ZERO = 23;
    static final int GF_ONE = 46;
    private static double _enemyAbsoluteBearing;
    private static int _lastGunOrientation;
    
    ////////////////////////////////////////////////////////
    // RaikoMicro's gun

    static double lastVChangeTime;
    static int enemyVelocity;
    static double[][][][][][] _gunStats = new double[6][4][4][2][3][GF_ONE+1];
    static final double LOG_BASE_E_TO_2_CONVERSION_CONSTANT = 1.4427;

    ////////////////////////////////////////////////////////

    public void run() {
        setColors(Color.black, Color.black, Color.white);

        _enemyWaves = new LinkedList();
        setAdjustGunForRobotTurn(true);
        setAdjustRadarForGunTurn(true);

        do {
            turnRadarRightRadians(Double.POSITIVE_INFINITY);
        } while (true);

    }

    public void onScannedRobot(ScannedRobotEvent e) {
        Wave w;

        double bulletPower;
        if ((bulletPower = _oppEnergy - e.getEnergy()) <= 3
            && bulletPower > 0) {
            addCustomEvent(w = new Wave());
            w.bulletVelocity = (20D - (bulletPower*3));
            w.directAngle = _lastLastAbsBearingRadians;
            w.sourceLocation = _enemyLocation;
            w.orientation = _lastLastOrientation;
            w.waveGuessFactors = _nextSurfSegment;
            _enemyWaves.addLast(w);
        }
        _nextSurfSegment = _surfStats[(int)(Math.min((_lastDistance+50)/200, 3))][(int)((Math.abs(_lastLatVel)+1)/2)];

//        _oppEnergy = e.getEnergy(); // MC (done in gun normally)

        addCustomEvent(w = new Wave());
        setTurnRadarRightRadians(Utils.normalRelativeAngle((w.directAngle = _enemyAbsoluteBearing = getHeadingRadians() + e.getBearingRadians()) - getRadarHeadingRadians()) * 2);

        _enemyLocation =
            project((w.sourceLocation = _myLocation = new Point2D.Double(getX(), getY())),
            _enemyAbsoluteBearing, _lastDistance = e.getDistance());

        // WaveSurfing /////////////////////////////////////////////////////////
        int direction = (_lastLastOrientation = sign(_lastLatVel));
        try {
            _goAngle = (_surfWave = (Wave)(_enemyWaves.getFirst()))
            	.absoluteBearing(_myLocation) +
            	A_LITTLE_LESS_THAN_HALF_PI * 
                	(direction = (sign(checkDanger(-1) - checkDanger(1))));
        } catch (Exception ex) { }

        // CREDIT: code by Iiley,
        // http://robowiki.net?BackAsFront
        double angle = Utils.normalRelativeAngle(
        	wallSmoothing(_myLocation, _goAngle, direction) - getHeadingRadians());
        double turnAngle;
        setTurnRightRadians(turnAngle = Math.atan(Math.tan(angle)));
        setAhead((angle == turnAngle) ? 100 : -100);

        ////////////////////////////////////////////////////////
        // CREDIT: RaikoMicro's gun, by Jamougha
        // http://robowiki.net?RaikoMicro

        /////
        // TC
/*
        Wave w;
        addCustomEvent(w = new Wave());
        _enemyLocation =
            project((w.sourceLocation = _myLocation = new Point2D.Double(getX(), getY())),
            _enemyAbsoluteBearing, _lastDistance = e.getDistance());
*/
        /////

        // ------------- Fire control -------
        double enemyLatVel;
        _lastGunOrientation = w.orientation = sign(enemyLatVel = (e.getVelocity())*Math.sin(e.getHeadingRadians() - _enemyAbsoluteBearing));

        int bestGF = Math.min(3, (int)(Math.pow(280*lastVChangeTime++/_lastDistance, .7)));
//        int bestGF = Math.min(3, (int)(Math.sqrt(220D*lastVChangeTime++/_lastDistance))); // TC
        int newVelocity;
        if (enemyVelocity != (newVelocity = (int)(enemyLatVel = Math.abs(enemyLatVel)))) {
            lastVChangeTime = 0;
            bestGF = 4;
            if (enemyVelocity > newVelocity) {
            	bestGF = 5;
            }            
        }
        enemyVelocity = newVelocity;
        
        
//        w.sourceLocation = _myLocation;
//        w.directAngle = _enemyAbsoluteBearing;
        w.waveGuessFactors = _gunStats[bestGF][(int)(LOG_BASE_E_TO_2_CONVERSION_CONSTANT * Math.log(enemyLatVel + 1.5))][gunWallDistance(0.18247367367) ? (gunWallDistance(0.36494734735) ? (gunWallDistance(0.63865785787) ? 3 : 2) : 1) : 0][gunWallDistance(-0.36494734735) ? 0 : 1][(int)limit(0, (_lastDistance-75)/200, 2)];
//        w.waveGuessFactors = _gunStats[bestGF][(int)(LOG_BASE_E_TO_2_CONVERSION_CONSTANT * Math.log(enemyLatVel + 1.5))][gunWallDistance(0.24430198263) ? (gunWallDistance(0.48860396528) ? (gunWallDistance(0.85505693924) ? 3 : 2) : 1) : 0][gunWallDistance(-0.48860396528) ? 0 : 1][(int)limit(0, (_lastDistance-75)/200, 2)]; // TC

        bestGF = GF_ZERO;

        for (int gf = GF_ONE; gf >= 0 && (_oppEnergy = e.getEnergy()) > 0; gf--) // Jamougha: Saves one byte compared to going up, weird
            if (w.waveGuessFactors[gf] > w.waveGuessFactors[bestGF])
                bestGF = gf;

        double power = 2 - Math.max(0, (30 - getEnergy()) / 16);
//      double power = 3; // TC
        w.distance = -1.5 * (w.bulletVelocity = (20 - 3*power));

        setTurnGunRightRadians(Utils.normalRelativeAngle(_enemyAbsoluteBearing - getGunHeadingRadians() + ((_lastGunOrientation*(Math.asin(8/w.bulletVelocity)/GF_ZERO))*(bestGF-GF_ZERO)) ));
//        setTurnGunRightRadians(Utils.normalRelativeAngle(_enemyAbsoluteBearing - getGunHeadingRadians() + ((_lastGunOrientation*.035406)*(bestGF-GF_ZERO)) )); // TC

        if (Math.abs(getGunTurnRemaining()) < 3 && setFireBullet(power + (_ramCounter / (3*getRoundNum()+1))) != null) {
//        if (Math.abs(getGunTurnRemaining()) < 3 && setFireBullet(3) != null) { // TC
            w.weight = 4;
        }

        ////////////////////////////////////////////////////////

        _lastLatVel = getVelocity()*Math.sin(e.getBearingRadians());
        _lastLastAbsBearingRadians = _lastAbsBearingRadians;
        _goAngle = _lastAbsBearingRadians = _enemyAbsoluteBearing + Math.PI;
    }

    public void onHitByBullet(HitByBulletEvent e) {
    	_oppEnergy += e.getBullet().getPower() * 3;
    	if (_surfWave.distanceToPoint(_myLocation) - _surfWave.distance < 100) {

            // The waves are removed quickly enough that it's possible
            // I could be hit by a bullet on a wave that's been removed...
            // logging that could really screw up the stats.
            logHit(_surfWave, _myLocation, 0.7);
        }
    }
    
    public void onBulletHit(BulletHitEvent e) {
    	double bulletPower;
    	_oppEnergy -= (bulletPower = e.getBullet().getPower()) * 4 +
    		(Math.max(0, bulletPower - 1) * 2);
    }

    public void onHitRobot(HitRobotEvent event) {
        _ramCounter++;
    }

    public void onCustomEvent(CustomEvent e) {
    	removeCustomEvent(e.getCondition());
    }
    
    public static void logHit(Wave w, Point2D.Double targetLocation, double rollingDepth) {
        for (int x = 46; x >= 0; x--) {
            w.waveGuessFactors[x] = ((w.waveGuessFactors[x] * rollingDepth)
                + ((1 + w.weight) / (Math.pow(x - getFactorIndex(w, targetLocation), 2) + 1)))
                / (rollingDepth + 1 + w.weight);
        }
    }

    private static int getFactorIndex(Wave w, Point2D.Double botLocation) {
        return (int)limit(0,
            ((((Utils.normalRelativeAngle(
            w.absoluteBearing(botLocation)
            - w.directAngle) * w.orientation)
            / Math.asin(8.0/w.bulletVelocity))
            * (GF_ZERO)) + (GF_ZERO)), 46);
    }

    private double checkDanger(int direction) {
        int index = getFactorIndex(_surfWave, predictPosition(direction));

        return (_surfWave.waveGuessFactors[index]
            + .01 / (Math.abs(index - GF_ZERO) + 1))
            / Math.pow(_lastPredictedDistance, 4);
    }

    // CREDIT: mini sized predictor from Apollon, by rozu
    // http://robowiki.net?Apollon
    private Point2D.Double predictPosition(int direction) {
        Point2D.Double predictedPosition = (Point2D.Double)_myLocation;
        double predictedVelocity = getVelocity();
        double predictedHeading = getHeadingRadians();
        double maxTurning, moveAngle, moveDir;

        // - actual distance traveled so far needs +bullet_velocity,
        //    because it's detected one after being fired
        // - another +bullet_velocity b/c bullet advances before collisions
        // ...So start the counter at 2.
        // - another +bullet_velocity to approximate a bot's half width
        // ...So start the counter at 3.
        int counter = 3;

        do {
            moveDir = 1;

            if (Math.cos(moveAngle =
                wallSmoothing(predictedPosition, _surfWave.absoluteBearing(
                        predictedPosition) + (direction * A_LITTLE_LESS_THAN_HALF_PI), direction)
                        - predictedHeading) < 0) {
                moveAngle += Math.PI;
                moveDir = -1;
            }

            // rozu comment:
            // 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 + (predictedVelocity * moveDir < 0 ? 2*moveDir : moveDir),
//                8);

            // rozu comment:
            // calculate the new predicted position
            predictedPosition = project(predictedPosition, 
            	predictedHeading = Utils.normalRelativeAngle(predictedHeading + 
            		limit(-(maxTurning = Math.PI/720d*(40d - 
            		3d*Math.abs(predictedVelocity))), 
            		Utils.normalRelativeAngle(moveAngle), maxTurning)),
                (predictedVelocity = limit(-8,
                predictedVelocity + (predictedVelocity * moveDir < 0 ? 2*moveDir : moveDir),
                8)));

            if ((_lastPredictedDistance =
            	_surfWave.distanceToPoint(predictedPosition)) <
                _surfWave.distance + ((++counter) * _surfWave.bulletVelocity)) {
                return predictedPosition;
            }
    	} while (true);
    }

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

    // CREDIT: ganked from CassiusClay, by PEZ
    // http://robowiki.net?CassiusClay
    private 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);
    }

    private static int sign(double d) {
    	if (d < 0) { return -1; }
    	return 1;
    }

    // CREDIT: Iterative WallSmoothing by PEZ
    // http://robowiki.net?WallSmoothing
    private static double wallSmoothing(Point2D.Double botLocation, double angle, int orientation) {
        while (!_fieldRect.contains(project(botLocation, angle, WALL_STICK))) {
            angle += orientation*0.05;
        }
        return angle;
    }
    
    private static boolean gunWallDistance(double wallDistance) {
    	return _fieldRect.contains(project(_myLocation, _enemyAbsoluteBearing + (_lastGunOrientation*wallDistance), _lastDistance));
    }
}

class Wave extends Condition {
    Point2D.Double sourceLocation;
    double[] waveGuessFactors;
    double bulletVelocity, directAngle, distance;
    int orientation, weight;
    
    public double distanceToPoint(Point2D.Double p) {
    	return sourceLocation.distance(p);
    }
    
    public double absoluteBearing(Point2D.Double target) {
        return Math.atan2(target.x - sourceLocation.x, target.y - sourceLocation.y);
    }

    public boolean test() {
    	boolean isSurfed;
        if (distanceToPoint((isSurfed=Komarious._enemyWaves.contains(this))?
        	Komarious._myLocation:Komarious._enemyLocation)
            <= (distance+=bulletVelocity) + (2*bulletVelocity)) {
//            logHit((Wave)_enemyWaves.removeFirst(),
//                Komarious._myLocation, 500);
        	if (!isSurfed) {
                Komarious.logHit(this, Komarious._enemyLocation, 600);
        	}
        	Komarious._enemyWaves.remove(this);

        	return true;
        }
        return false;
    }
}

Robo Home | Komarious | Changes | Preferences | AllPages
Edit text of this page | View other revisions
Last edited January 10, 2007 6:55 EST by Voidious (diff)
Search: