Merge pull request #128 from battlecode/release-1.3.0

Release 1.3.0

Author: andywang02

build.gradle

@@ -69,6 +69,7 @@ task headless(type: JavaExec, dependsOn: [':engine:build', ':example-bots:build'
     '-Dbc.game.team-b.package=' + (project.findProperty('packageNameB') ?: project.property('teamB')),
     '-Dbc.game.maps=' + project.property('maps'),
     '-Dbc.server.validate-maps=' + project.property('validateMaps'),
+    '-Dbc.server.alternate-order=' + project.property('alternateOrder'),
     '-Dbc.server.save-file=' + (project.findProperty('replay') ?: defaultReplay),
   ]
 }

client/visualizer/src/config.ts

@@ -154,7 +154,7 @@ export enum Mode {
 export function defaults(supplied?: any): Config {
   let year = "2023"
   let conf: Config = {
-    gameVersion: "1.2.4", //TODO: Change this on each release!
+    gameVersion: "1.3.0", //TODO: Change this on each release!
     year: year,
     map_extension: 'map'+year.substring(2),
     game_extension: 'bc'+year.substring(2),

client/visualizer/src/main/scaffold.ts

@@ -166,6 +166,7 @@ export default class ScaffoldCommunicator {
       `-PteamB=${teamB}`,
       `-Pmaps=${maps.join(',')}`,
       `-PvalidateMaps=false`,
+      `-PalternateOrder=false`,
       `-PenableProfiler=${enableProfiler}`,
     ];
     const proc = child_process.spawn(

engine/src/main/battlecode/common/GameConstants.java

@@ -10,7 +10,7 @@ public class GameConstants {
     /**
      * The current spec version the server compiles with.
      */
-    public static final String SPEC_VERSION = "1.2.4";
+    public static final String SPEC_VERSION = "1.3.0";
 
     // *********************************
     // ****** MAP CONSTANTS ************

engine/src/main/battlecode/common/RobotController.java

@@ -162,11 +162,10 @@ public strictfp interface RobotController {
      *
      * @param loc the location to check
      * @return true if the location is on the map; false otherwise
-     * @throws GameActionException if the location is not within vision range
      *
      * @battlecode.doc.costlymethod
      */
-    boolean onTheMap(MapLocation loc) throws GameActionException;
+    boolean onTheMap(MapLocation loc);
 
     /**
      * Checks whether the given location is within the robot's vision range, and if it is on the map.
@@ -459,6 +458,55 @@ public strictfp interface RobotController {
      */
     Anchor senseAnchor(int islandIdx) throws GameActionException;
 
+    /**
+     * Sense if location has cloud.
+     *
+     * @param loc to sense cloud at
+     * @return if location has cloud
+     * @throws GameActionException if location can not be sensed
+     *
+     * @battlecode.doc.costlymethod
+     */
+    boolean senseCloud(MapLocation loc) throws GameActionException;
+
+    /**
+     * Return all clouds.
+     *
+     * @return all locations within vision radius that contain clouds
+     *
+     * @battlecode.doc.costlymethod
+     */
+    MapLocation[] senseNearbyCloudLocations();
+
+    /**
+     * Return all locations with clouds within a specified radius of a center location.
+     * If radiusSquared is larger than the robot's vision radius, uses the robot's
+     * vision radius instead. If -1 is passed, all locations within vision radius
+     * are returned.
+     *
+     * @param radiusSquared the squared radius of all locations to be returned
+     * @return all locations that contain clouds within the radius
+     * @throws GameActionException if the radius is negative (and not -1)
+     *
+     * @battlecode.doc.costlymethod
+     */
+    MapLocation[] senseNearbyCloudLocations(int radiusSquared) throws GameActionException;
+
+    /**
+     * Return all nearby locations with clouds within a specified radius of a center location.
+     * If radiusSquared is larger than the robot's vision radius, uses the robot's
+     * vision radius instead. If -1 is passed, all locations within vision radius
+     * are returned.
+     *
+     * @param center the center of the search area
+     * @param radiusSquared the squared radius of all locations to be returned
+     * @return all locations that contain clouds within the radius
+     * @throws GameActionException if the radius is negative (and not -1)
+     *
+     * @battlecode.doc.costlymethod
+     */
+    MapLocation[] senseNearbyCloudLocations(MapLocation center, int radiusSquared) throws GameActionException;
+
     /**
      * Sense well at location.
      *

engine/src/main/battlecode/instrumenter/bytecode/resources/MethodCosts.txt

@@ -86,6 +86,8 @@ battlecode/common/RobotController/senseNearbyRobots                     100  tru
 battlecode/common/RobotController/senseRobot                            25   true
 battlecode/common/RobotController/senseRobotAtLocation                  25   true
 battlecode/common/RobotController/sensePassability                      5    true
+battlecode/common/RobotController/senseCloud                            5    true
+battlecode/common/RobotController/senseNearbyCloudLocations             100  true
 battlecode/common/RobotController/senseWell                             5    true
 battlecode/common/RobotController/senseNearbyWells                      100  true
 battlecode/common/RobotController/senseMapInfo                          10   true

engine/src/main/battlecode/server/Config.java

@@ -50,6 +50,8 @@ public class Config {
         defaults.setProperty("bc.server.throttle-count", "15");
         defaults.setProperty("bc.server.output-xml", "true");
         defaults.setProperty("bc.server.validate-maps", "true");
+        defaults.setProperty("bc.server.alternate-order", "false");
+
 
 
         // Whether to write robot player output to match files / system out

engine/src/main/battlecode/server/ErrorReporter.java

@@ -53,7 +53,7 @@ private static void printThingsToTry(String thingsToTry) {
     private static void printReportString() {
         Server.warn(String.format("java version \"%s\"\n", System.getProperty("java.version")));
         Server.warn(String.format("%s (build %s, %s)\n\n", System.getProperty("java.vm.name"), System.getProperty("java.vm.version"), System.getProperty("java.vm.info")));
-        Server.warn("Please report this to the 6.370 devs, by posting to the forum\n"
+        Server.warn("Please report this to the 6.9610 devs, by posting to the forum\n"
                 + "under the \"bugs\" thread.  Include a copy of this printout and\n"
                 + "a brief description of the bug, including whether it's consistent\n"
                 + "or sporadic.  Thanks!");

engine/src/main/battlecode/server/Server.java

@@ -14,6 +14,8 @@
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
+import java.util.ArrayList;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.BlockingQueue;
@@ -165,16 +167,18 @@ public void run() {
             final RobotControlProvider prov = createControlProvider(currentGame, gameMaker, profilingEnabled);
 
             final boolean checkMapGuarantees = options.getBoolean("bc.server.validate-maps");
+            final boolean alternateOrder = options.getBoolean("bc.server.alternate-order");
 
             // Count wins
             int aWins = 0, bWins = 0;
 
             // Loop through the maps in the current game
+            boolean teamsReversed = false;
             for (int matchIndex = 0; matchIndex < currentGame.getMaps().length; matchIndex++) {
-
                 Team winner;
                 try {
-                    winner = runMatch(currentGame, matchIndex, prov, gameMaker, checkMapGuarantees);
+                    winner = runMatch(currentGame, matchIndex, prov, gameMaker, checkMapGuarantees, teamsReversed);
+                    if (alternateOrder) {teamsReversed = !teamsReversed;}
                 } catch (Exception e) {
                     ErrorReporter.report(e);
                     this.state = ServerState.ERROR;
@@ -222,6 +226,20 @@ public MapLocation indexToLocation(LiveMap liveMap, int idx) {
         return new MapLocation(idx % liveMap.getWidth(),
                                idx / liveMap.getWidth());
     }
+
+    private void extendOut(LiveMap liveMap, MapLocation mapLocation, Set<MapLocation> seenLocations) {
+        int[] islandArray = liveMap.getIslandArray();
+        int currValue = islandArray[locationToIndex(liveMap, mapLocation)];
+        seenLocations.add(mapLocation);
+        for (Direction dir : Direction.cardinalDirections()) {
+            MapLocation newLocation = mapLocation.add(dir);
+            if (seenLocations.contains(newLocation)) {continue;}
+            if (islandArray[locationToIndex(liveMap, newLocation)] == currValue) {
+                extendOut(liveMap, newLocation, seenLocations);
+            }
+        }
+    }
+
     private void validateMapOnGuarantees(LiveMap liveMap) {
         // Check map dimensions
         if (liveMap.getWidth() > GameConstants.MAP_MAX_WIDTH) {
@@ -280,18 +298,25 @@ private void validateMapOnGuarantees(LiveMap liveMap) {
             if ((liveMap.getResourceArray()[i] != 0) && (robotArray[i] != null))
                 throw new RuntimeException("Wells can't be on same square as headquarters");
 
+            //assert that wells are not on same square as currents
+            if ((liveMap.getResourceArray()[i] != 0) && (liveMap.getCurrentArray()[i] != 0))
+                throw new RuntimeException("Wells can't be on same square as currents");
+
             //assert that currents are not on same square as headquarters
             if (liveMap.getCurrentArray()[i] != 0 && robotArray[i] != null)
                 throw new RuntimeException("Currents can't be on same square as headquarters");
         }
 
-        //assert that island guarantees are met (atleast 4 islands, none of which are larger than 20 units)
-        Map<Integer, Integer> islandToAreaMapping = new HashMap<>();
-        for (int i : liveMap.getIslandArray()) {
-            if (i == 0) {
+        //assert that island guarantees are met (at least 4 islands, none of which are larger than 20 units, all connected)
+        Map<Integer, List<MapLocation>> islandToAreaMapping = new HashMap<>();
+        for (int i = 0; i < liveMap.getIslandArray().length; i++) {
+            int islandId = liveMap.getIslandArray()[i];
+            if (islandId == 0) {
                 continue; // No island
             } else {
-                islandToAreaMapping.put(i, islandToAreaMapping.getOrDefault(i, 0) + 1);
+                List<MapLocation> islandAreas = islandToAreaMapping.getOrDefault(islandId, new ArrayList<MapLocation>());
+                islandAreas.add(indexToLocation(liveMap, i));
+                islandToAreaMapping.put(islandId, islandAreas);
             }
         }
         if (islandToAreaMapping.size() < GameConstants.MIN_NUMBER_ISLANDS) {
@@ -300,10 +325,18 @@ private void validateMapOnGuarantees(LiveMap liveMap) {
         if (islandToAreaMapping.size() > GameConstants.MAX_NUMBER_ISLANDS) {
             throw new RuntimeException("Islands num of " + islandToAreaMapping.size() + " ABOVE GameConstants.MAX_NUMBER_ISLANDS");
         }
-        for (int i : islandToAreaMapping.values()) {
-            if (i > GameConstants.MAX_ISLAND_AREA) {
+        Set<MapLocation> seenIslands = new HashSet<>();
+        int sumIslandSquares = 0;
+        for (int islandId : islandToAreaMapping.keySet()) {
+            List<MapLocation> islandLocs = islandToAreaMapping.get(islandId);
+            if (islandLocs.size() > GameConstants.MAX_ISLAND_AREA) {
                 throw new RuntimeException("Island exceeds max allowable area");
             }
+            sumIslandSquares += islandLocs.size();
+            extendOut(liveMap, islandLocs.get(0), seenIslands);
+        }
+        if (seenIslands.size() != sumIslandSquares) {
+            throw new RuntimeException("Islands are not continous");
         }
 
 
@@ -402,6 +435,9 @@ private void validateMapOnGuarantees(LiveMap liveMap) {
             }
         }
     }
+    private Team runMatch(GameInfo currentGame, int matchIndex, RobotControlProvider prov, GameMaker gameMaker, boolean checkMapGuarantees) throws Exception {
+        return runMatch(currentGame, matchIndex, prov, gameMaker, checkMapGuarantees, false);
+    }
 
     /**
      * @return the winner of the match
@@ -410,7 +446,7 @@ private void validateMapOnGuarantees(LiveMap liveMap) {
     private Team runMatch(GameInfo currentGame,
                           int matchIndex,
                           RobotControlProvider prov,
-                          GameMaker gameMaker, boolean checkMapGuarantees) throws Exception {
+                          GameMaker gameMaker, boolean checkMapGuarantees, boolean teamsReversed) throws Exception {
 
         final String mapName = currentGame.getMaps()[matchIndex];
         final LiveMap loadedMap;
@@ -423,7 +459,7 @@ private Team runMatch(GameInfo currentGame,
         }
 
         // Create the game world!
-        currentWorld = new GameWorld(loadedMap, prov, gameMaker.getMatchMaker());
+        currentWorld = new GameWorld(loadedMap, prov, gameMaker.getMatchMaker(), teamsReversed);
 
         if (checkMapGuarantees) {
             // Validate the map

engine/src/main/battlecode/world/GameWorld.java

@@ -52,9 +52,12 @@ public strictfp class GameWorld {
     private Random rand;
     private final GameMaker.MatchMaker matchMaker;
 
+    public GameWorld(LiveMap gm, RobotControlProvider cp, GameMaker.MatchMaker matchMaker) {
+        this(gm, cp, matchMaker, false);
+    }
 
     @SuppressWarnings("unchecked")
-    public GameWorld(LiveMap gm, RobotControlProvider cp, GameMaker.MatchMaker matchMaker) {
+    public GameWorld(LiveMap gm, RobotControlProvider cp, GameMaker.MatchMaker matchMaker, boolean reverseTeams) {
         this.walls = gm.getWallArray();
         this.clouds = gm.getCloudArray();
         this.islandIds = gm.getIslandArray();
@@ -83,8 +86,26 @@ public GameWorld(LiveMap gm, RobotControlProvider cp, GameMaker.MatchMaker match
 
         // Add the robots contained in the LiveMap to this world.
         RobotInfo[] initialBodies = this.gameMap.getInitialBodies();
+        RobotInfo[] bodiesToUse = initialBodies;
+        RobotInfo[] reversedBodies = new RobotInfo[initialBodies.length];
         for (int i = 0; i < initialBodies.length; i++) {
             RobotInfo robot = initialBodies[i];
+            Inventory inv = new Inventory();
+            for (ResourceType rType : ResourceType.values()) {
+                if (rType == ResourceType.NO_RESOURCE) {
+                    continue;
+                }
+                inv.addResource(rType, robot.getResourceAmount(rType));
+            }
+            reversedBodies[i] = new RobotInfo(robot.ID, robot.team.opponent(), robot.type, inv, robot.health, robot.location);
+        }
+
+        if (reverseTeams) {
+            bodiesToUse = reversedBodies;
+        }
+
+        for (int i = 0; i < bodiesToUse.length; i++) {
+            RobotInfo robot = bodiesToUse[i];
             MapLocation newLocation = robot.location.translate(gm.getOrigin().x, gm.getOrigin().y);
             spawnRobot(robot.ID, robot.type, newLocation, robot.team);
         }
@@ -175,9 +196,6 @@ public synchronized GameState runRound() {
                         }
                         hq.addResourceAmount(ResourceType.ADAMANTIUM, GameConstants.INITIAL_AD_AMOUNT);
                         hq.addResourceAmount(ResourceType.MANA, GameConstants.INITIAL_MN_AMOUNT);
-                        // Add initial amounts of resource
-                        this.teamInfo.addAdamantium(hq.getTeam(), GameConstants.INITIAL_AD_AMOUNT);                        
-                        this.teamInfo.addMana(hq.getTeam(), GameConstants.INITIAL_MN_AMOUNT);
                         return true;
                     } else {
                         throw new RuntimeException("non-robot body registered as dynamic");
@@ -694,7 +712,7 @@ public void processEndOfRound() {
                         //deal damage
                         InternalRobot robot = getRobot(loc);
                         if (robot != null && robot.getTeam().ordinal() == teamIndex) {
-                            robot.addHealth(-1*robot.getType().damage);
+                            robot.addHealth(-1*RobotType.DESTABILIZER.damage);
                         }
                         //update multiplier if no longer being destabilized
                         if (curDestabilize.size() <= GameConstants.MAX_DESTABILIZE_STACKS) {
@@ -843,6 +861,9 @@ public void destroyRobot(int id, boolean checkArchonDeath) {
         controlProvider.robotKilled(robot);
         objectInfo.destroyRobot(id);
 
+        for (ResourceType rType : ResourceType.values()) {
+            robot.addResourceAmount(rType, -1*robot.getResource(rType));
+        }
         matchMaker.addDied(id);
     }