static void init(RobotController rc) {
int roundLimit = rc.getRoundLimit();
Common.rc = rc;
rand = new Random(rc.getID());
id = rc.getID();
myTeam = rc.getTeam();
enemyTeam = myTeam.opponent();
history = new MapLocation[roundLimit];
robotType = rc.getType();
enrollment = rc.getRoundNum();
if (robotType != RobotType.ARCHON) birthday = enrollment - robotType.buildTurns - BUILD_LAG;
hometown = rc.getLocation();
sightRadius = robotType.sensorRadiusSquared;
straightSight = (int) Math.sqrt(sightRadius);
canMessageSignal = robotType.canMessageSignal();
Signals.buildTarget = new MapLocation[roundLimit];
Signals.buildStrategy = new SignalStrategy[roundLimit];
try {
addInfo(rc.senseRobot(id));
myArchonHometowns = rc.getInitialArchonLocations(myTeam);
enemyArchonHometowns = rc.getInitialArchonLocations(enemyTeam);
int coordinates[] = new int[MAP_MAX];
int x = 0;
int y = 0;
for (int i = enemyArchonHometowns.length - 1; i >= 0; --i) {
MapLocation loc = enemyArchonHometowns[i];
twiceCenterX += loc.x;
twiceCenterY += loc.y;
coordinates[loc.y] *= MAP_MAX;
coordinates[loc.y] += loc.x + 1;
}
for (int i = 0; i < myArchonHometowns.length; ++i) {
MapLocation loc = myArchonHometowns[i];
twiceCenterX += loc.x;
twiceCenterY += loc.y;
x += loc.x;
y += loc.y;
}
twiceCenterX /= myArchonHometowns.length;
twiceCenterY /= myArchonHometowns.length;
x /= myArchonHometowns.length;
y /= myArchonHometowns.length;
for (int i = 0; i < myArchonHometowns.length; ++i) {
MapLocation loc = myArchonHometowns[i];
int xCoord = coordinates[loc.y] - 1;
coordinates[loc.y] /= MAP_MAX;
if (loc.x != twiceCenterX - xCoord) rotation = true;
}
Archon.center = new MapLocation(x, y);
myBase = new MapLocation(twiceCenterX / 2, twiceCenterY / 2).directionTo(Archon.center);
enemyBase = myBase.opposite();
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
}
public Robot(RobotController rc) {
this.rc = rc;
rand = new Random(rc.getID());
team = rc.getTeam();
enemy = team.opponent();
currentLocation = rc.getLocation();
RobotType type = rc.getType();
senseRadius = type.sensorRadiusSquared;
attackRadius = type.attackRadiusSquared;
}
// Beavers
private static void runBeaver() {
strategy = new BuildStrategy(rc);
rand = new Random(rc.getID());
while (true) {
threats.update();
myLoc = rc.getLocation();
if (rc.isCoreReady()) {
RobotType build = strategy.getBuildOrder();
if (build != null) tryBuild(rc.getLocation().directionTo(threats.enemyHQ), build);
}
// Attack if there is an enemy in sight
if (rc.isWeaponReady()) attackWeakest();
double ore = rc.senseOre(rc.getLocation());
// Move if we can and want to
if (rc.isCoreReady()) {
boolean ignoreThreat = overwhelms();
if (!ignoreThreat && shouldRetreat()) {
doRetreatMove(); // Pull back if in range of the enemy guns
} else {
doMinerMove();
if (ore == 0 && rc.isCoreReady()) { // We didn't find ore nearby
doSearchMove();
}
}
}
// Mine if possible
if (rc.isCoreReady() && ore > 0) {
try {
rc.mine();
} catch (GameActionException e) {
System.out.println("Mining Exception");
// e.printStackTrace();
}
}
doTransfer();
rc.yield();
}
}
/** @param rc */
public static void run(RobotController rc) {
rand = new Random(rc.getID());
myTeam = rc.getTeam();
while (true) {
if (rc.getType() == RobotType.ARCHON) {
archon(rc);
} else if (rc.getType() == RobotType.SCOUT) {
scout(rc);
} else if (rc.getType().equals(RobotType.TURRET)) {
turret(rc);
} else if (rc.getType().equals(RobotType.TTM)) {
ttm(rc);
} else if (rc.getType() == RobotType.SOLDIER) {
soldier(rc);
} else if (rc.getType() == RobotType.GUARD) {
guard(rc);
} else if (rc.getType() == RobotType.VIPER) {
viper(rc);
}
}
}
/*
* Beavers and miners without ore do this
*/
private static void doSearchMove() {
// We keep moving in the direction we were going
// When blocked we turn left or right depending on our unique ID
rc.setIndicatorString(2, "Mining: No ore - searching");
if (lastMove == null || rand.nextInt(10) == 1)
lastMove = directions[rand.nextInt(directions.length)];
Direction startDir = lastMove;
while (!rc.canMove(lastMove) || threats.isThreatened(myLoc.add(lastMove))) {
if (rc.getID() % 2 == 0) lastMove = lastMove.rotateLeft();
else lastMove = lastMove.rotateRight();
if (lastMove == startDir) // We are trapped
return;
}
try {
rc.move(lastMove);
} catch (GameActionException e) {
System.out.println("Move exception");
// e.printStackTrace();
}
}
public void run(final RobotController robotController) throws GameActionException {
final MapInfoModule mapInfoModule = new MapInfoModule();
final CombatModule combatModule = new CombatModule();
final CommunicationModule communicationModule = new CommunicationModule(mapInfoModule);
final DirectionModule directionModule = new DirectionModule(robotController.getID());
final MovementModule movementModule = new MovementModule();
final RubbleModule rubbleModule = new RubbleModule();
final Team currentTeam = robotController.getTeam();
int turnsStuck = 0;
while (true) {
RobotType type = robotController.getType();
MapLocation currentLocation = robotController.getLocation();
// update communication
communicationModule.processIncomingSignals(robotController);
// let's verify existing information
communicationModule.verifyCommunicationsInformation(robotController, null, false);
if (type == RobotType.TTM) {
// MOVE
// let's get the best assignment
CommunicationModuleSignal objectiveSignal = null;
int closestObjectiveLocationDistance = Integer.MAX_VALUE;
final Enumeration<CommunicationModuleSignal> zombieDenCommunicationModuleSignals =
communicationModule.zombieDens.elements();
while (zombieDenCommunicationModuleSignals.hasMoreElements()) {
final CommunicationModuleSignal signal =
zombieDenCommunicationModuleSignals.nextElement();
final int distance = signal.location.distanceSquaredTo(currentLocation);
if (distance < closestObjectiveLocationDistance) {
objectiveSignal = signal;
closestObjectiveLocationDistance = distance;
}
}
final Enumeration<CommunicationModuleSignal> enemyArchonCommunicationModuleSignals =
communicationModule.enemyArchons.elements();
while (enemyArchonCommunicationModuleSignals.hasMoreElements()) {
final CommunicationModuleSignal signal =
enemyArchonCommunicationModuleSignals.nextElement();
final int distance =
signal.location.distanceSquaredTo(currentLocation)
* 6; // multiplying by 6 to prioritize the dens
if (distance < closestObjectiveLocationDistance) {
objectiveSignal = signal;
closestObjectiveLocationDistance = distance;
}
}
final Enumeration<CommunicationModuleSignal> enemyTurretCommunicationModuleSignals =
communicationModule.enemyTurrets.elements();
while (enemyTurretCommunicationModuleSignals.hasMoreElements()) {
final CommunicationModuleSignal signal =
enemyTurretCommunicationModuleSignals.nextElement();
final int distance = signal.location.distanceSquaredTo(currentLocation) * 20;
if (distance < closestObjectiveLocationDistance) {
objectiveSignal = signal;
closestObjectiveLocationDistance = distance;
}
}
boolean shouldMove = true;
Direction desiredMovementDirection = null;
Direction targetRubbleClearanceDirection = null;
// check to make sure we are safe
final RobotInfo[] enemies =
robotController.senseHostileRobots(
currentLocation, robotController.getType().sensorRadiusSquared);
if (robotController.isCoreReady() && enemies.length > 0) {
final Direction fleeDirection =
directionModule.averageDirectionTowardDangerousRobotsAndOuterBounds(
robotController, enemies);
if (fleeDirection != null) {
final Direction fleeMovementDirection =
directionModule.recommendedMovementDirectionForDirection(
fleeDirection.opposite(), robotController, false);
if (fleeMovementDirection != null) {
robotController.move(fleeMovementDirection);
currentLocation = robotController.getLocation();
robotController.setIndicatorString(
1, fleeDirection.name() + " " + fleeMovementDirection.name());
}
}
}
// check if there are nearby signals
if (desiredMovementDirection == null) {
int closestSignalDistance = Integer.MAX_VALUE;
MapLocation closestSignalLocation = null;
final ArrayList<Signal> notifications = communicationModule.notifications;
for (int i = 0; i < notifications.size(); i++) {
final Signal signal = notifications.get(i);
final int distance = currentLocation.distanceSquaredTo(signal.getLocation());
if (distance < closestSignalDistance) {
closestSignalDistance = distance;
closestSignalLocation = signal.getLocation();
}
}
if (closestSignalLocation != null) {
desiredMovementDirection = currentLocation.directionTo(closestSignalLocation);
}
}
// now let's try move toward an assignment
if (robotController.isCoreReady()
&& communicationModule.initialInformationReceived
&& shouldMove) {
// check if we have an objective
if (desiredMovementDirection == null) {
if (objectiveSignal != null) {
final MapLocation objectiveLocation = objectiveSignal.location;
if (objectiveLocation.distanceSquaredTo(currentLocation) >= 8) {
desiredMovementDirection = currentLocation.directionTo(objectiveLocation);
}
}
}
// try move towards archon starting positions
if (desiredMovementDirection == null) {
int closestArchonDistance = Integer.MAX_VALUE;
MapLocation closestArchonLocation = null;
final MapLocation[] archonLocations =
robotController.getInitialArchonLocations(robotController.getTeam().opponent());
for (int i = 0; i < archonLocations.length; i++) {
final MapLocation location = archonLocations[i];
final int distance = currentLocation.distanceSquaredTo(location);
if (distance < closestArchonDistance) {
closestArchonDistance = distance;
closestArchonLocation = location;
}
}
if (closestArchonLocation != null) {
desiredMovementDirection = currentLocation.directionTo(closestArchonLocation);
}
}
// process movement
if (desiredMovementDirection != null) {
final Direction recommendedMovementDirection =
directionModule.recommendedMovementDirectionForDirection(
desiredMovementDirection, robotController, false);
final MapLocation recommendedMovementLocation =
recommendedMovementDirection != null
? currentLocation.add(recommendedMovementDirection)
: null;
if (recommendedMovementDirection != null
&& !movementModule.isMovementLocationRepetitive(
recommendedMovementLocation, robotController)) {
robotController.move(recommendedMovementDirection);
movementModule.addMovementLocation(recommendedMovementLocation, robotController);
currentLocation = robotController.getLocation();
turnsStuck = 0;
}
}
}
// unpack if we're safe
RobotInfo[] nearbyTeammates = robotController.senseNearbyRobots(8, currentTeam);
RobotInfo[] nearbySoldiers =
combatModule.robotsOfTypesFromRobots(
nearbyTeammates, new RobotType[] {RobotType.SOLDIER});
if (nearbySoldiers.length > 2) {
robotController.unpack();
}
} else {
// ATTACK
final RobotInfo[] enemies =
robotController.senseHostileRobots(
currentLocation, robotController.getType().attackRadiusSquared);
RobotInfo bestEnemy = this.getBestEnemyToAttackFromEnemies(robotController, enemies);
// handle attacking
if (bestEnemy != null) {
if (robotController.isWeaponReady()) {
// we can attack the enemy
robotController.attackLocation(bestEnemy.location);
if (bestEnemy.type != RobotType.ZOMBIEDEN) {
communicationModule.broadcastSignal(
robotController,
CommunicationModule.maximumFreeBroadcastRangeForRobotType(
robotController.getType()));
}
}
}
// pack if we aren't near soldiers
RobotInfo[] nearbyTeammates =
robotController.senseNearbyRobots(type.sensorRadiusSquared, currentTeam);
RobotInfo[] nearbySoldiers =
combatModule.robotsOfTypesFromRobots(
nearbyTeammates, new RobotType[] {RobotType.SOLDIER});
if (nearbySoldiers.length < 3) {
robotController.pack();
}
}
Clock.yield();
}
}
public static void run() throws GameActionException {
rc = RobotPlayer.rc;
rand = new Random(rc.getID());
// build scouts right away
buildRobot(RobotType.SCOUT);
while (true) {
/*
* INPUT
*/
if (rc.getLocation().equals(goal)) {
goal = null; // you made it to the goal
past10Locations =
new ArrayList<MapLocation>(); // delete the slug trail after you reach your goal
}
// sense locations around you
nearbyMapLocations =
MapLocation.getAllMapLocationsWithinRadiusSq(
rc.getLocation(), rc.getType().sensorRadiusSquared);
// parts locations
nearbyPartsLocations = rc.sensePartLocations(RobotType.ARCHON.sensorRadiusSquared);
// find the nearest mapLocation with the most parts
double maxParts = 0;
MapLocation nearbyLocationWithMostParts = null;
for (MapLocation loc : nearbyPartsLocations) {
// add to locationsWithParts arraylist
if (locationsWithParts.contains(loc) == false) {
locationsWithParts.add(loc);
}
// find the location with the most parts
double partsAtLoc = rc.senseParts(loc);
if (partsAtLoc > maxParts) {
maxParts = partsAtLoc;
nearbyLocationWithMostParts = loc;
}
}
// read signals
Signal[] signals = rc.emptySignalQueue();
for (Signal signal : signals) {
// check if the signal has parts at the location
int[] message = signal.getMessage();
if (message != null && message[0] == Utility.PARTS_CODE) {
// add that location to the locationsWithParts arraylist
locationsWithParts.add(signal.getLocation());
}
}
// sense robots
MapLocation myLoc = rc.getLocation();
robots = rc.senseNearbyRobots();
foes = new ArrayList<RobotInfo>();
foesWithinAttackRange = new ArrayList<RobotInfo>();
for (RobotInfo robot : robots) {
if (robot.team == Team.ZOMBIE
|| robot.team == rc.getTeam().opponent()) // if the robot is a foe
{
foes.add(robot);
if (myLoc.distanceSquaredTo(robot.location) < robot.type.attackRadiusSquared) {
foesWithinAttackRange.add(robot);
}
}
}
int nearbyFoes = foes.size();
int nearbyFoesInAttackRange = foesWithinAttackRange.size();
/*//check stats
double health = rc.getHealth();
int infectedTurns = rc.getInfectedTurns();
int robotsAlive = rc.getRobotCount();
*/
/*
* OUPUT
*/
// what to do
if (nearbyFoes == 0) // if there are no foes in sight
{
if (rc.getTeamParts() >= RobotType.TURRET.partCost) // build if you can
{
buildRobots();
} else {
if (maxParts > 0 && goal == null) // if there are parts nearby
{
// make that the goal
goal = nearbyLocationWithMostParts;
} else if (goal == null) // if there aren't and there is no goal
{
// build something or find new parts
// 80% build, 20% new parts
if (locationsWithParts.size() > 0 && rand.nextFloat() > .8) {
goal = locationsWithParts.get(0);
locationsWithParts.remove(0);
goalIsASafeLocation = false;
}
// calculate the next goal - maybe a new parts location you got via signal
} else if (goal != null) // if there is a goal, move there
{
moveToLocation(goal);
}
}
} else // there are foes nearby
{
// message for help!
if (Math.random() < probSignal) {
rc.broadcastSignal(archonInTroubleSignalRadiusSquared);
}
if (nearbyFoesInAttackRange > 0) {
goal = findSaferLocation();
rc.setIndicatorString(0, "" + goal.x + " " + goal.y);
goalIsASafeLocation = true;
moveToLocation(goal);
}
}
Clock.yield();
}
}
/**
* run() is the method that is called when a robot is instantiated in the Battlecode world. If
* this method returns, the robot dies!
*/
@SuppressWarnings("unused")
public static void run(RobotController rc) {
// You can instantiate variables here.
Direction[] directions = {
Direction.NORTH,
Direction.NORTH_EAST,
Direction.EAST,
Direction.SOUTH_EAST,
Direction.SOUTH,
Direction.SOUTH_WEST,
Direction.WEST,
Direction.NORTH_WEST
};
RobotType[] robotTypes = {
RobotType.SCOUT,
RobotType.SOLDIER,
RobotType.SOLDIER,
RobotType.SOLDIER,
RobotType.GUARD,
RobotType.GUARD,
RobotType.VIPER,
RobotType.TURRET
};
Random rand = new Random(rc.getID());
int myAttackRange = 0;
Team myTeam = rc.getTeam();
Team enemyTeam = myTeam.opponent();
if (rc.getType() == RobotType.ARCHON) {
try {
// Any code here gets executed exactly once at the beginning of the game.
} catch (Exception e) {
// Throwing an uncaught exception makes the robot die, so we need to catch exceptions.
// Caught exceptions will result in a bytecode penalty.
System.out.println(e.getMessage());
e.printStackTrace();
}
while (true) {
/*
// This is a loop to prevent the run() method from returning. Because of the Clock.yield()
// at the end of it, the loop will iterate once per game round.
try {
int fate = rand.nextInt(1000);
// Check if this ARCHON's core is ready
if (fate % 10 == 2) {
// Send a message signal containing the data (6370, 6147)
rc.broadcastMessageSignal(6370, 6147, 80);
}
Signal[] signals = rc.emptySignalQueue();
if (signals.length > 0) {
// Set an indicator string that can be viewed in the client
rc.setIndicatorString(0, "I received a signal this turn!");
} else {
rc.setIndicatorString(0, "I don't any signal buddies");
}
if (rc.isCoreReady()) {
if (fate < 800) {
// Choose a random direction to try to move in
Direction dirToMove = directions[fate % 8];
// Check the rubble in that direction
if (rc.senseRubble(rc.getLocation().add(dirToMove)) >= GameConstants.RUBBLE_OBSTRUCTION_THRESH) {
// Too much rubble, so I should clear it
rc.clearRubble(dirToMove);
// Check if I can move in this direction
} else if (rc.canMove(dirToMove)) {
// Move
rc.move(dirToMove);
}
} else {
// Choose a random unit to build
RobotType typeToBuild = robotTypes[fate % 8];
// Check for sufficient parts
if (rc.hasBuildRequirements(typeToBuild)) {
// Choose a random direction to try to build in
Direction dirToBuild = directions[rand.nextInt(8)];
for (int i = 0; i < 8; i++) {
// If possible, build in this direction
if (rc.canBuild(dirToBuild, typeToBuild)) {
rc.build(dirToBuild, typeToBuild);
break;
} else {
// Rotate the direction to try
dirToBuild = dirToBuild.rotateLeft();
}
}
}
}
}
Clock.yield();
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
*/
}
} else if (rc.getType() != RobotType.TURRET) {
try {
// Any code here gets executed exactly once at the beginning of the game.
myAttackRange = rc.getType().attackRadiusSquared;
} catch (Exception e) {
// Throwing an uncaught exception makes the robot die, so we need to catch exceptions.
// Caught exceptions will result in a bytecode penalty.
System.out.println(e.getMessage());
e.printStackTrace();
}
while (true) {
// This is a loop to prevent the run() method from returning. Because of the Clock.yield()
// at the end of it, the loop will iterate once per game round.
try {
int fate = rand.nextInt(1000);
if (fate % 5 == 3) {
// Send a normal signal
rc.broadcastSignal(80);
}
boolean shouldAttack = false;
// If this robot type can attack, check for enemies within range and attack one
if (myAttackRange > 0) {
RobotInfo[] enemiesWithinRange = rc.senseNearbyRobots(myAttackRange, enemyTeam);
RobotInfo[] zombiesWithinRange = rc.senseNearbyRobots(myAttackRange, Team.ZOMBIE);
if (enemiesWithinRange.length > 0) {
shouldAttack = true;
// Check if weapon is ready
if (rc.isWeaponReady()) {
rc.attackLocation(
enemiesWithinRange[rand.nextInt(enemiesWithinRange.length)].location);
}
} else if (zombiesWithinRange.length > 0) {
shouldAttack = true;
// Check if weapon is ready
if (rc.isWeaponReady()) {
rc.attackLocation(
zombiesWithinRange[rand.nextInt(zombiesWithinRange.length)].location);
}
}
}
if (!shouldAttack) {
if (rc.isCoreReady()) {
if (fate < 600) {
// Choose a random direction to try to move in
Direction dirToMove = directions[fate % 8];
// Check the rubble in that direction
if (rc.senseRubble(rc.getLocation().add(dirToMove))
>= GameConstants.RUBBLE_OBSTRUCTION_THRESH) {
// Too much rubble, so I should clear it
rc.clearRubble(dirToMove);
// Check if I can move in this direction
} else if (rc.canMove(dirToMove)) {
// Move
rc.move(dirToMove);
}
}
}
}
Clock.yield();
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
}
} else if (rc.getType() == RobotType.TURRET) {
try {
myAttackRange = rc.getType().attackRadiusSquared;
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
while (true) {
// This is a loop to prevent the run() method from returning. Because of the Clock.yield()
// at the end of it, the loop will iterate once per game round.
try {
// If this robot type can attack, check for enemies within range and attack one
if (rc.isWeaponReady()) {
RobotInfo[] enemiesWithinRange = rc.senseNearbyRobots(myAttackRange, enemyTeam);
RobotInfo[] zombiesWithinRange = rc.senseNearbyRobots(myAttackRange, Team.ZOMBIE);
if (enemiesWithinRange.length > 0) {
for (RobotInfo enemy : enemiesWithinRange) {
// Check whether the enemy is in a valid attack range (turrets have a minimum range)
if (rc.canAttackLocation(enemy.location)) {
rc.attackLocation(enemy.location);
break;
}
}
} else if (zombiesWithinRange.length > 0) {
for (RobotInfo zombie : zombiesWithinRange) {
if (rc.canAttackLocation(zombie.location)) {
rc.attackLocation(zombie.location);
break;
}
}
}
}
Clock.yield();
} catch (Exception e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
}
}
}