2015.06 AI

What I learned:

This class used java to run the robot war with classmates,

My robot final rank was 3rd, I put my strategy and code below!

Magic Robot – ChenHan,Tsai
Strategy
1. For its radar, it will always focus on the enemy
cite from https://www.youtube.com/watch?v=4TUwwjP4KNk
2. While scan, it will detect whether enemy shoot bullet, based on the delta enegy from enemy, and do
the dodge bullet action.
cite from from http://www.ibm.com/developerworks/library/j-dodge/3
3. It will fire the bullet based on the enegy amount, basically I always shoot power 3 only while my
energy is low, I shoot power 0.5 bullet. If the distance is near and my energy is more, I will ramp attack.
4. At beginning, it will record the battle field height and width, and while it near the wall, it will go to
opposite direction to avoid wall.
5. While enemy’s energy is low or my energy is more than a margin, my Magic Robot will stop move, and
Only shoot, let the enemy waste its energy and win.
6. If hit by robot, based on my energy, I will ramp or step back
7. If hit by bullet, based on the energy, I will step back or stand there.

package fs_student;

import robocode.*;
import robocode.util.Utils;

import java.awt.*;
import java.awt.geom.Arc2D;

import static robocode.util.Utils.normalRelativeAngleDegrees;

public class Magic extends TeamRobot
{

    private enum state{flee,attack,ramp,search};
    private state m_State;

    private double m_radarTurn = 0;
    private double m_gunTurn = 0;

    private  class RobotData
    {
        private double m_Distance;
        private double m_HereToOpponentDir;
        private double m_life;
        private double m_enegy = 100;
    }

    private RobotData m_oppoent = new RobotData();

    private double preEnegy = 100;


    private int movementDir = 1;

    private double m_BattleW;
    private double m_BattleH;

    private static double direction;	//1 for clockwise or -1 for counterclockwise

    @Override
    public void run()
    {
        setBodyColor(Color.red);
        setGunColor(Color.yellow);
        setBulletColor(Color.MAGENTA);
        setRadarColor(Color.green);

        m_State = state.search;

        setAdjustGunForRobotTurn(true); // Keep the gun still when we turn

        setAdjustRadarForGunTurn(true);


        m_BattleW = getBattleFieldWidth();
         m_BattleH = getBattleFieldHeight();

        // Loop forever
        while (true)
        {
            if(getRadarTurnRemaining() == 0)
                setTurnRadarRight(360);

            m_State = state.attack;

            switch (m_State)
            {
                case flee:
                    back(100);
                    break;

                case attack:
                    trapFire();
                    break;
            }
            execute();
        }
    }

    private void fireSetting()
    {
        if(m_oppoent.m_enegy<20 || (getEnergy()-m_oppoent.m_enegy)>10)
            setFire(0.5);
       else if(getEnergy()>=10)
            setFire(3);
        else

           setFire(0.5);
    }

    private void trapFire()
    {
        //far distance
        if(m_oppoent.m_Distance>300)
        {
            fireSetting();

        }else if(m_oppoent.m_Distance<50)
        {
            if(m_oppoent.m_enegy < getEnergy())
                ramp();

            fireSetting();
        }else
        {
            if(m_oppoent.m_enegy +10< getEnergy())
                ramp();

            fireSetting();
        }
    }

    private void  ramp()
    {
        double degree = -getHeading()+ m_oppoent.m_HereToOpponentDir;
        if(m_oppoent.m_HereToOpponentDir>=0)
            setTurnRight( m_oppoent.m_HereToOpponentDir );
        else
            setTurnLeft( m_oppoent.m_HereToOpponentDir );

        setAhead(m_oppoent.m_Distance);
    }


    @Override
    public void onScannedRobot(robocode.ScannedRobotEvent event)
    {

        m_oppoent.m_Distance = event.getDistance();
        m_oppoent.m_HereToOpponentDir = event.getBearing();
        m_oppoent.m_enegy = event.getEnergy();

        //cite from https://www.youtube.com/watch?v=4TUwwjP4KNk
        double face = getHeading();
        double angleToEnemy = getHeading()+ event.getBearing();
        double radarTurn = Utils.normalRelativeAngleDegrees(angleToEnemy - getRadarHeading());
        double myRadarDegree = getRadarHeading();
        double myGunDegree = getGunHeading();
        double extraTurn = Math.min(Math.atan(36.0 / event.getDistance()), Rules.RADAR_TURN_RATE);

        if(radarTurn > 0)
            radarTurn += extraTurn;
        else
            radarTurn -= extraTurn;


        setTurnRadarRight(radarTurn);

        setTurnGunRight(-getGunHeading() + getRadarHeading());

        double testResult = preEnegy -   m_oppoent.m_enegy;

        preEnegy = m_oppoent.m_enegy;

        if(m_oppoent.m_enegy<20 || (getEnergy()-m_oppoent.m_enegy)>10)
        {
            return;
        }
        if(testResult >0 &&testResult <=3)
        {
            Dodge();
            detectWall();
            return;
        }

        detectWall();

        return;
    }

    private double dodgeWallDist = 150;
    private double warnMargin = 20;
    private  boolean detectWall()
    {
        double x = getX();
        double y = getY();

        double headDir = getHeading();
        if(x<warnMargin )
        {
            if(headDir >180)
                setBack(dodgeWallDist);
            else
                setAhead(dodgeWallDist);

            return true;
        }

        if(x> (m_BattleW - warnMargin) )
        {
            if(headDir >180)
                setAhead(dodgeWallDist);
            else
                setBack(dodgeWallDist);

            return true;
        }

        if(y< warnMargin)
        {
            if(headDir < 90 && headDir>270)
                setAhead(dodgeWallDist);
            else
                setBack(dodgeWallDist);

            return true;
        }

        if(y> (m_BattleH-warnMargin))
        {
            if(headDir >90 && headDir<270)
                setAhead(dodgeWallDist);
            else
                setBack(dodgeWallDist);

            return true;
        }
        return false;
    }

    //cite from http://www.ibm.com/developerworks/library/j-dodge/
    private void Dodge()
    {
        if(m_oppoent.m_enegy<20 || (getEnergy()-m_oppoent.m_enegy)>10)
        {
            return;
        }
        movementDir = -movementDir;
        setTurnRight(m_oppoent.m_HereToOpponentDir + 90 - 30 * movementDir);
        setAhead((m_oppoent.m_Distance / 3+25)*movementDir);
    }

    @Override
    public void onHitByBullet(robocode.HitByBulletEvent event)
    {
        if(m_oppoent.m_enegy<20 || (getEnergy()-m_oppoent.m_enegy)>10)
        {
            return;
        }
        setBack(200);
    }

    @Override
    public void onHitRobot(HitRobotEvent event) {
    //    super.onHitRobot(event);
        if(event.getEnergy() < getEnergy())
        {
            ramp();
            return;
        }

        setBack(200);
    }

    @Override
    public void onHitWall(robocode.HitWallEvent event)
    {

        double degree = event.getBearing();
        double v = getVelocity();
        double head = getHeading();
        //toward center
        double x = getBattleFieldWidth()/2 - getX();
        double y = -getBattleFieldHeight()/2 + ( getBattleFieldHeight()-getY());
        double degreeCenter = Math.atan2(y,x);
         setTurnRight(degree);
        setAhead(300);

    }
}