MyCommander.java

package commander;

import java.util.*;

import com.aisandbox.cmd.*;
import com.aisandbox.cmd.info.*;
import com.aisandbox.cmd.cmds.*;
import com.aisandbox.util.*;


/**
 * Sample "balanced" commander for the AI sandbox.
 * One bot attacking, one defending and the rest randomly searching the level for enemies.
 *
 * @author Matthias F. Brandstetter
 */
public class MyCommander extends SandboxCommander {
    private String myTeam;
    private String enemyTeam;

    private int myTeamSize;

    private Vector2 middle;
    private Vector2 left;
    private Vector2 right;
    private Vector2 front;

    private Vector2 myFlagSpawnLocation;
    private Vector2 enemyFlagSpawnLocation;

    private Vector2 myScoreLocation;
    private Vector2 enemyScoreLocation;

    private BotInfo attacker;
    private BotInfo defender;

    private ArrayList<BotInfo> attackers;
    private ArrayList<BotInfo> defenders;
    private ArrayList<BotInfo> scouts;
    private ArrayList<BotInfo> avengers;


    /**
     * Custom commander class construtor.
     */
    public MyCommander() {
        name = "JavaCmd";

        attacker = null;
        defender = null;



    }

    /**
     * Called when the server sends the "initialize" message to the commander.
     * Use this function to setup your bot before the game starts.
     * You can also set this.verbose = true to get more information about each bot visually.
     */
    @Override
    public void initialize() {
        // set the name of our and the enemy teams
        myTeam = gameInfo.getTeam();
        enemyTeam = gameInfo.getEnemyTeam();

        myTeamSize = gameInfo.getMyTeamInfo().getMembers().size();

        /**
         * Throwing EXCEPTIONS!!!!!!!!!!!!
         */
        attackers = new ArrayList<BotInfo>();
        defenders = new ArrayList<BotInfo>();
        scouts = new ArrayList<BotInfo>();
        avengers = new ArrayList<BotInfo>();
        // Calculate flag positions and store the middle.
        Vector2 ours = gameInfo.getMyFlagInfo().getPosition();
        Vector2 theirs = gameInfo.getEnemyFlagInfo().getPosition();
        middle = new Vector2((ours.getX() + theirs.getX()) / 2, (ours.getY() + theirs.getY()) / 2);

        //get flag spawn locations
        myFlagSpawnLocation = levelInfo.getFlagSpawnLocations().get(myTeam);
        enemyFlagSpawnLocation = levelInfo.getFlagSpawnLocations().get(enemyTeam);

        //get flag score locations
        myScoreLocation = levelInfo.getFlagScoreLocations().get(myTeam);
        enemyScoreLocation = levelInfo.getFlagScoreLocations().get(enemyTeam);

        // Now figure out the flaking directions, assumed perpendicular.
        Vector2 d = new Vector2(ours);
        d.sub(theirs);
        left = new Vector2(-d.getY(), d.getX()).normalize();
        right = new Vector2(d.getY(), -d.getX()).normalize();
        front = new Vector2(d.getX(), d.getY()).normalize();

        // display the command descriptions next to the bot labels
        verbose = true;
    }

    /**
     * Called when the server sends a "tick" message to the commander.
     * Override this function for your own bots.  Here you can access all the information in this.gameInfo,
     * which includes game information, and this.levelInfo which includes information about the level.
     * You can send commands to your bots using the issue() method in this class.
     */
    @Override
    public void tick() {
        if (attacker != null && attacker.getHealth() <= 0)
            attacker = null; // the attacker is dead we'll pick another when available

        if (defender != null && defender.getHealth() <= 0)
            defender = null; // the defender is dead we'll pick another when available

        /**
         * Throwing EXCEPTIONS!!!!!!!!!!!!
         */
        /*
        for (List<List<BotInfo>> List : botList) {
            for (List<BotInfo> List1 : List)
                for (BotInfo bot : List1)
                    if (bot.getHealth() <= 0) List1.remove(bot);

        }
        */
        if (attackers != null)
            for (BotInfo bot : attackers) {
                System.out.println("attacker checked, bot has " + bot.getHealth() + " hp");
                if (bot.getHealth() <= 0){ attackers.remove(bot);
                    System.out.println("attacker removed from list");}
                else{
                    break;
                }
            }
        if (defenders != null)
            for (BotInfo bot : defenders) {
                if (bot.getHealth() <= 0) defenders.remove(bot);

            }
        if (scouts != null)
            for (BotInfo bot : scouts) {
                if (bot.getHealth() <= 0) scouts.remove(bot);

            }
        if (avengers != null)
            for (BotInfo bot : avengers) {
                if (bot.getHealth() <= 0) avengers.remove(bot);

            }

        // loop through all living bots without orders
        for (BotInfo bot : gameInfo.botsAvailable()) {


            determineRoles(bot);
            attackerBehavior(bot);

                                  /*
                if ((defender == null || defender.equals(bot)) && !bot.hasFlag()) {
                    defender = bot;

                    // Stand on a random position in a box of 4m around the flag.
                    Vector2 targetPosition = levelInfo.getFlagSpawnLocations().get(myTeam);
                    Vector2 targetMin = targetPosition.sub(new Vector2(2f, 2f));
                    Vector2 targetMax = targetPosition.add(new Vector2(2f, 2f));
                    Vector2 goal = levelInfo.findRandomFreePositionInBox(new Area(targetMin, targetMax));

                    if (goal.sub(defender.getPosition()).length() > 8f)
                        issue(new ChargeCmd(defender.getName(), goal, "running to defend"));
                    else {
                        List<FacingDirection> dirs = new ArrayList<FacingDirection>();
                        dirs.add(new FacingDirection(left.sub(defender.getPosition()), 1));
                        dirs.add(new FacingDirection(middle.sub(defender.getPosition()), 1));
                        issue(new DefendCmd(defender.getName(), dirs, "turning to defend"));
                    }
                } else if (attacker == null || attacker.equals(bot) || bot.hasFlag()) {
                    attacker = bot;

                    if (attacker.hasFlag()) {
                        // tell the flag carrier to run home
                        Vector2 target = levelInfo.getFlagScoreLocations().get(myTeam);
                        issue(new MoveCmd(attacker.getName(), target, "running home"));
                    } else {
                        Vector2 target = gameInfo.getEnemyFlagInfo().getPosition();
                        Vector2 flank = getFlankingPosition(attacker, target);
                        if (target.sub(flank).length() > attacker.getPosition().sub(target).length())
                            issue(new AttackCmd(attacker.getName(), target, null, "attack from flank"));
                        else {
                            flank = levelInfo.findNearestFreePosition(flank);
                            issue(new MoveCmd(attacker.getName(), flank, "running to flank"));
                        }
                    }
                }

                // All our other (random) bots
                else {
                    // pick a random position in the level to move to
                    Vector2 target = levelInfo.findRandomFreePositionInBox(levelInfo.getLevelArea());
                    if (target != null)
                        issue(new AttackCmd(bot.getName(), target, null, "random patrol"));
                }      */
        }
    }

    private Vector2 getFlankingPosition(BotInfo bot, Vector2 target) {
        List<Vector2> options = new ArrayList<Vector2>();
        Vector2 l = levelInfo.findNearestFreePosition(left.scale(16f).add(target));
        if (l != null) options.add(l);
        Vector2 r = levelInfo.findNearestFreePosition(right.scale(16f).add(target));
        if (r != null) options.add(r);

        if (options.size() > 0) {
            Collections.sort(options);
            return options.get(0);
        } else
            return target;
    }

    //check if bot is assigned to a list
    private boolean isBotAssigned(BotInfo bot) {
        String botName = bot.getName();
        if (attackers != null) {
            for(BotInfo bot2 : attackers)
            if(bot2.getName().equals(botName)){
                System.out.println("Bot is assigned");
           return true;
            }
        }
        System.out.println("Bot is not assigned");
        return false;
    }

    private void removeFromList(ArrayList<BotInfo> list, BotInfo bot){
        String checkBotName = bot.getName();
        for (BotInfo botList : list){
             if (botList.getName().equals(checkBotName))
             {
                 System.out.println("Match found for removal");
                 list.remove(bot);
             }
        }
    }

    //add bots to lists
    private void determineRoles(BotInfo bot) {

        addAttackers(bot);
       /* addDefenders(bot);
        addScouts(bot);
        addAvengers(bot);
        */
    }

    //adds to attacker list
    private void addAttackers(BotInfo bot) {
        if (!isBotAssigned(bot)) {
            String botName = bot.getName();
           if (botName != null){
            attackers.add (bot);
            System.out.println("attacker" + botName +" added to list");
           }
        }
            else {
        }
    }

    //adds to defender list
    private void addDefenders(BotInfo bot) {
        if (!isBotAssigned(bot))
            defenders.add(bot);
        else {
        }
    }

    //adds to scout list
    private void addScouts(BotInfo bot) {
        if (!isBotAssigned(bot))
            scouts.add(bot);
        else {
        }
    }

    //adds to avenger list
    private void addAvengers(BotInfo bot) {
        if (!isBotAssigned(bot))
            avengers.add(bot);
        else {
        }
    }

    private void attackerBehavior(BotInfo bot) {
        System.out.println("attack method called");
        if (attackers.contains(bot)) {
            System.out.println("bot is in attackers list");
            if (bot.hasFlag()) {
                // tell the flag carrier to run home
                Vector2 target = levelInfo.getFlagScoreLocations().get(myTeam);
                issue(new MoveCmd(bot.getName(), target, "running home"));
            } else {
                Vector2 target = gameInfo.getEnemyFlagInfo().getPosition();
                Vector2 flank = getFlankingPosition(bot, target);
                if (target.sub(flank).length() > bot.getPosition().sub(target).length())
                    issue(new AttackCmd(bot.getName(), target, null, "attack from flank"));
                else {
                    flank = levelInfo.findNearestFreePosition(flank);
                    issue(new MoveCmd(bot.getName(), flank, "running to flank"));
                }
            }
        }
    }


    private void defenderBehavior(BotInfo bot) {
        if (defenders.contains(bot)) {

        }

    }

    private void scoutBehavior(BotInfo bot) {
        if (scouts.contains(bot)) {

        }

    }

    private void avengerBehavior(BotInfo bot) {
        if (avengers.contains(bot)) {

        }

    }

    /**
     * Called when the server sends the "shutdown" message to the commander.
     * Use this function to teardown your bot after the game is over.
     */
    @Override
    public void shutdown() {
        System.out.println("<shutdown> message received from server");
    }
}