private boolean moveToPath() throws GameActionException {
if (dstar == null) {
dstar = new DStar(outPath, distances, currentLocation);
}
if (!dstar.arrived(currentLocation)) {
dstar.compute(7000);
}
if (!RC.isActive()) return true;
Direction dir = Direction.NORTH, best = null;
int min = Integer.MAX_VALUE;
for (int i = 0; i < 8; i++) {
int d = RC.canMove(dir) ? dstar.getDistance(currentLocation.add(dir)) : Integer.MAX_VALUE;
if (d < min) {
min = d;
best = dir;
}
dir = dir.rotateRight();
}
if (best != null && move(best)) {
RC.setIndicatorString(1, "Moving to outPath");
return true;
} else {
return false;
}
}
private boolean move(Direction dir) throws GameActionException {
if (!RC.isActive() || !RC.canMove(dir)) return false;
switch (movementType) {
case SNEAK:
RC.sneak(dir);
break;
case RUN:
RC.move(dir);
break;
}
return true;
}
/** Called every round. */
@Override
public void run() throws GameActionException {
while (!RC.isActive()) {
RC.yield();
}
Robot[] robots = Utils.RC.senseNearbyGameObjects(Robot.class, 35, ENEMY_TEAM);
Utils.RC.setIndicatorString(1, "" + robots.length);
for (int i = 0; i < robots.length; ++i) {
messagingSystem.writeAttackMessage(Utils.RC.senseRobotInfo(robots[i]).location);
messagingSystem.writeMicroMessage(Utils.RC.senseRobotInfo(robots[i]).location, 1);
}
makeSomeNoise();
}
/**
* Try to move.
*
* @param sneak:
* @return
*/
public void execute(int sneak) {
// int bc = Clock.getBytecodesLeft();
// RC.setIndicatorString(1, "my x = " + Integer.toString(RC.getLocation().x) + ", my y = " +
// Integer.toString(RC.getLocation().y)
// + "x = " + Integer.toString(dest.x) + ", y = " + Integer.toString(dest.y));
// RC.setIndicatorString(2, Clock.getRoundNum() + " | dest = " + dest + ", navtype = " +
// navType);
if (arrived()) return;
if (RC.isActive()) {
Direction d;
d = navAlg.getNextDir();
if (d != null && d != Direction.NONE && d != Direction.OMNI) {
if (RC.canMove(d)) {
try {
switch (sneak) {
case SNEAK:
// RC.setIndicatorString(2, dest.x + ", " + dest.y + ": sneak");
RC.sneak(d);
break;
case RUN:
// RC.setIndicatorString(2, dest.x + ", " + dest.y + ": run");
RC.move(d);
break;
case PUSH_HOME:
// RC.setIndicatorString(2, dest.x + ", " + dest.y + ": push_home");
Direction awayFromHome = currentLocation.directionTo(ALLY_HQ).opposite();
if (d == awayFromHome
|| d == awayFromHome.rotateLeft()
|| d == awayFromHome.rotateRight()) {
RC.sneak(d);
} else {
RC.move(d);
}
break;
default:
break;
}
} catch (GameActionException e) {
e.printStackTrace();
}
} else if (currentLocation.distanceSquaredTo(dest) <= 2) {
setTarget(currentLocation);
}
}
}
// System.out.println("Bytecodes used by Mover.execute() = " +
// Integer.toString(bc-Clock.getBytecodesLeft()));
}
public NoiseTowerBehavior() {
for (int i = 7; i >= 0; i--) {
int lastdir = (i + 4) % 8;
int at = 1;
paths[i][0] = currentLocation;
int lastcow = 0;
for (int j = 1; j < 30; j++) {
if (i < 7 && RC.isActive()) {
try {
makeSomeNoise();
} catch (GameActionException e1) {
e1.printStackTrace();
}
}
int k = lastdir + 2;
k %= 8;
int bestscore = -1;
MapLocation bestplace = currentLocation;
while (k != (lastdir + 6) % 8) {
int score = Math.abs(i - k);
if (score < 4) score = 8 - score;
score *= score * score;
MapLocation here = paths[i][j - 1].add(directions[k]);
double cows;
try {
cows = Utils.COW_GROWTH[here.x][here.y];
if (cows > 0) lastcow = j;
score =
(here.add(directions[k])).distanceSquaredTo(currentLocation) > 300
|| RC.senseTerrainTile(here) == TerrainTile.VOID
? -10
: cows == 0.0 ? 30 : score + (int) (cows) * 0 + 30;
} catch (Exception e) {
score = -2;
}
if (score > bestscore) {
bestscore = score;
bestplace = here;
}
k++;
if (k == 8) k = 0;
}
if (!bestplace.equals(currentLocation)) {
paths[i][j] = bestplace;
} else {
break;
}
}
pathat[i] = lastcow;
while (paths[i][pathat[i]] == null && pathat[i] > 0) pathat[i]--;
if (lastcow < 29) lastcow++;
}
skip[0] = false;
double[] d = new double[8];
int[] dist = new int[8];
MapLocation[] toconsider = new MapLocation[8];
for (int i = 7; i >= 0; i--) {
if (pathat[i] == 0) {
d[i] = 0;
dist[i] = 0;
} else {
toconsider[i] = paths[i][pathat[i] - 1];
d[i] = Math.atan2(toconsider[i].y - curY, toconsider[i].x - curX);
dist[i] = currentLocation.distanceSquaredTo(toconsider[i]);
}
}
for (int i = 7; i >= 0; i--) {
if (dist[i] == 0) skip[i] = true;
else {
for (int j = i - 1; j >= 0; j--) {
if (i == j || dist[j] == 0) continue;
if (Math.abs(d[i] - d[j]) < 0.4 && pathbetween(toconsider[i], toconsider[j])) {
if (dist[i] < dist[j]) skip[i] = true;
else skip[j] = true;
}
}
}
}
}
public BFSNoiseTower() throws GameActionException {
System.out.println("start " + Clock.getBytecodeNum());
queue[0] = currentLocation;
dir[17][17] = Direction.OMNI;
for (int i = 7; i >= 0; i--) {
Direction d = directions[i];
MapLocation loc = currentLocation.add(d);
TerrainTile there = RC.senseTerrainTile(loc);
if (!there.isTraversableAtHeight(RobotLevel.ON_GROUND)) continue;
int x = loc.x - currentLocation.x;
int y = loc.y - currentLocation.y;
dir[x + 17][y + 17] = d.opposite();
queue[at] = loc;
at++;
}
for (int s = 1; s < at; s++) {
if (s % 30 == 0 && RC.isActive()) {
if (target == null
|| target.distanceSquaredTo(ALLY_PASTR_COUNT > 0 ? ALLY_PASTR_LOCS[0] : currentLocation)
<= 5) {
earlyNearbyCows();
}
MapLocation realTarget = target.add(currentLocation.directionTo(target), 3);
if (RC.canAttackSquare(realTarget)) RC.attackSquare(realTarget);
target = target.add(target.directionTo(currentLocation));
}
Direction initD =
dir[queue[s].x - currentLocation.x + 17][queue[s].y - currentLocation.y + 17];
Direction aD;
Direction bD;
if (initD.isDiagonal()) {
aD = initD.rotateLeft().rotateLeft();
bD = initD.rotateRight();
} else {
aD = initD.rotateLeft().rotateLeft().rotateLeft();
bD = initD.rotateRight().rotateRight();
}
for (Direction d = aD; d != bD; d = d.rotateLeft()) {
MapLocation loc = queue[s].add(d);
TerrainTile there = RC.senseTerrainTile(loc);
if (!there.isTraversableAtHeight(RobotLevel.ON_GROUND)) continue;
int x = loc.x - currentLocation.x;
int y = loc.y - currentLocation.y;
if (x * x + y * y > 200) continue;
if (dir[x + 17][y + 17] == null) {
dir[x + 17][y + 17] = d.opposite();
queue[at] = loc;
at++;
}
}
}
System.out.println("end " + Clock.getBytecodeNum());
System.out.println("at " + at);
}
@Override
public void run() throws GameActionException {
if (luge()) { // luge = micro
// set mode to ATTACK or something
return;
// send message?
} else if (mode != Mode.ENGAGE
&& mode != Mode.ACQUIRE_TARGET
&& mode != Mode.BIRTH_DECIDE_MODE
&& mode != Mode.FIND_PASTR_LOC
&& mode != Mode.BUILD_PASTR) {
if (ENEMY_MILK - ALLY_MILK > 50000 || ENEMY_PASTR_COUNT > ALLY_PASTR_COUNT) {
changeMode(Mode.ACQUIRE_TARGET);
} else {
// try to build pastures if late in game
// probably deprecated (doesn't happen)
if (currentRound > 1800 && ENEMY_PASTR_COUNT > ALLY_PASTR_COUNT && !panicPastrBuilding) {
if (currentCowsHere < 150) {
panicPastrBuilding = true;
dest = ALLY_HQ.subtract(ALLY_HQ.directionTo(ENEMY_HQ));
mover.setTarget(dest);
sneakToBuildingLoc = 1;
changeMode(Mode.FIND_PASTR_LOC);
} else if (currentCowsHere < 400) {
panicPastrBuilding = true;
mover.setTarget(ALLY_HQ);
changeMode(Mode.RETURN_HOME);
}
} else if (!initialSweep) {
// stand on rich squares
MapLocation loc = findRichSquare();
if (loc != null) {
mover.setTarget(loc);
changeMode(Mode.STAND_RICH_LOC);
}
}
}
}
switch (mode) {
case BIRTH_DECIDE_MODE:
int robotNum = RC.senseRobotCount();
if (ENEMY_PASTR_COUNT > ALLY_PASTR_COUNT + 1
|| (robotNum + currentRound / 100 > 22 && ENEMY_PASTR_COUNT > ALLY_PASTR_COUNT)) {
roleIndex = ALLY_PASTR_COUNT % 4;
role = Role.PASTR;
changeMode(Mode.FIND_PASTR_LOC);
dest =
new MapLocation(
(ALLY_HQ.x + roleLocList[roleIndex].x) / 2,
(ALLY_HQ.y + roleLocList[roleIndex].y) / 2);
} else {
roleIndex = robotNum % 4;
role = roleList[roleIndex];
changeMode(Mode.SWEEP_OUT);
dest = roleLocList[roleIndex];
initialSweep = true;
}
mover.setTarget(dest);
mover.move();
break;
case GOING_TO_MIDDLE:
if (mover.arrived()) {
decideNextMode();
} else {
mover.movePushHome();
}
break;
case SWEEP_OUT:
if (mover.arrived()) {
dest =
new MapLocation(
(2 * ALLY_HQ.x + roleLocList[roleIndex].x) / 3,
(2 * ALLY_HQ.y + roleLocList[roleIndex].y) / 3);
mover.setTarget(dest);
changeMode(Mode.RETURN_HOME);
} else {
mover.movePushHome();
}
break;
case RETURN_HOME:
if (mover.arrived()) {
dest = roleLocList[roleIndex];
mover.setTarget(dest);
changeMode(Mode.SWEEP_OUT);
initialSweep = false;
} else {
mover.movePushHome();
}
break;
case STAND_RICH_LOC:
if (!mover.arrived()) {
mover.sneak();
} else {
RC.setIndicatorString(1, "cows here: " + currentCowsHere);
if (currentCowsHere < 500) {
mover.setTarget(roleLocList[roleIndex]);
changeMode(Mode.SWEEP_OUT);
}
}
break;
case FIND_PASTR_LOC:
if (mover.arrived()) {
changeMode(Mode.BUILD_PASTR);
} else {
mover.execute(sneakToBuildingLoc);
}
break;
case BUILD_PASTR:
if (!RC.isConstructing() && RC.isActive()) {
RC.construct(RobotType.PASTR);
}
if (RC.getConstructingRounds() == 0) {
buildingFinished = true;
}
break;
case ACQUIRE_TARGET:
int mindistance = 10000000;
MapLocation pastrTarget = null;
for (MapLocation pastrLoc : ENEMY_PASTR_LOCS) {
int d = currentLocation.distanceSquaredTo(pastrLoc);
if (d < mindistance) {
mindistance = d;
pastrTarget = pastrLoc;
}
}
if (pastrTarget == null) {
mover.setTarget(ALLY_HQ);
changeMode(Mode.RETURN_HOME);
} else {
mover.setTarget(pastrTarget);
changeMode(Mode.ENGAGE);
mover.move();
}
break;
case ENGAGE:
if (mover.arrived()) {
changeMode(Mode.RETURN_HOME);
} else {
mover.move();
}
break;
default:
break;
}
}