cache constant values

Author: JasperGeurtz

src/main/java/bwapi/Force.java

@@ -6,20 +6,23 @@
 import java.util.stream.Collectors;
 
 public class Force {
-    private final ForceData forceData;
     private final Game game;
 
+    private final int id;
+    private final String name;
+
     Force(final ForceData forceData, final Game game) {
-        this.forceData = forceData;
         this.game = game;
+        this.id = forceData.id();
+        this.name = forceData.name();
     }
 
     public int getID() {
-        return forceData.id();
+        return id;
     }
 
     public String getName() {
-        return forceData.name();
+        return name;
     }
 
     public Set<Player> getPlayers() {

src/main/java/bwapi/Game.java

@@ -33,6 +33,27 @@ public class Game {
     private final Map<Integer, Unit> units = new HashMap<>();
     private final Set<Integer> visibleUnits = new HashSet<>();
 
+    //CACHED
+    private int randomSeed;
+    private int revision;
+    private boolean  debug;
+    private Player self;
+    private Player enemy;
+    private Player neutral;
+    private boolean replay;
+    private boolean multiplayer;
+    private boolean battleNet;
+    private List<TilePosition> startLocations;
+    private int mapWidth;
+    private int mapHeight;
+    private String mapFileName;
+    private String mapPathName;
+    private String mapName;
+    private String mapHash;
+
+    private boolean[][] buildable;
+    private boolean[][] walkable;
+
     // USER DEFINED
     private TextSize textSize = TextSize.Default;
 
@@ -93,6 +114,38 @@ private void init() {
                 staticNeutralUnits.add(unit);
             }
         }
+
+        randomSeed = gameData.randomSeed();
+        revision = gameData.getRevision();
+        debug = gameData.isDebug();
+        self = players.get(gameData.self());
+        enemy = players.get(gameData.enemy());
+        neutral = players.get(gameData.neutral());
+        replay = gameData.isReplay();
+        multiplayer = gameData.isMultiplayer();
+        battleNet = gameData.isBattleNet();
+        startLocations = IntStream.range(0, gameData.startLocationCount())
+                .mapToObj(i -> new TilePosition(gameData.startLocationX(i), gameData.startLocationY(i)))
+                .collect(Collectors.toList());
+        mapWidth = gameData.mapWidth();
+        mapHeight = gameData.mapHeight();
+        mapFileName = gameData.mapFileName();
+        mapPathName = gameData.mapPathName();
+        mapName = gameData.mapName();
+        mapHash = gameData.mapHash();
+
+        buildable = new boolean[mapWidth][mapHeight];
+        for (int i=0; i < mapWidth; i++) {
+            for (int j=0; j < mapHeight; j++) {
+                buildable[i][j] = gameData.buildable(i, j);
+            }
+        }
+        walkable = new boolean[mapWidth*4][mapHeight*4];
+        for (int i = 0; i < mapWidth * 4; i++) {
+            for (int j=0; j < mapHeight * 4; j++) {
+                walkable[i][j] = gameData.walkable(i, j);
+            }
+        }
     }
 
     void unitShow(final int id) {
@@ -282,14 +335,11 @@ public Set<Unit> getUnitsInRectangle(final Position leftTop, final Position righ
     }
 
      public Set<Unit> getUnitsInRadius(final int x, final int y, final int radius, final UnitFilter filter) {
-        return new HashSet<>();
+        return getUnitsInRadius(new Position(x, y), radius, filter);
      }
 
      public Set<Unit> getUnitsInRadius(final Position center, final int radius, final UnitFilter filter) {
-         return getAllUnits().stream().filter( u -> {
-             final Position p = u.getPosition();
-             return center.getApproxDistance(u.getPosition()) <= radius && filter.operation(u);
-         }).collect(Collectors.toSet());
+         return getAllUnits().stream().filter( u -> center.getApproxDistance(u.getPosition()) <= radius && filter.operation(u)).collect(Collectors.toSet());
      }
 
      public Unit getClosestUnitInRectangle(final Position center, final int left, final int top, final int right, final int bottom, final UnitFilter filter) {
@@ -303,27 +353,27 @@ public Unit getClosestUnitInRadius(final Position center, final int radius, fina
      }
 
      public int mapWidth() {
-        return gameData.mapWidth();
+        return mapWidth;
      }
 
      public int mapHeight() {
-        return gameData.mapHeight();
+        return mapHeight;
      }
 
      public String mapFileName() {
-        return gameData.mapFileName();
+        return mapFileName;
      }
 
      public String mapPathName() {
-        return gameData.mapPathName();
+        return mapPathName;
      }
 
      public String mapName() {
-        return gameData.mapName();
+        return mapName;
      }
 
      public String mapHash() {
-        return gameData.mapHash();
+        return mapHash;
      }
 
      public boolean isWalkable(final int walkX, final int walkY) {
@@ -334,7 +384,7 @@ public boolean isWalkable(final WalkPosition position) {
         if (!position.isValid(this)) {
             return false;
         }
-        return gameData.walkable(position.x, position.y);
+        return walkable[position.x][position.y];
      }
 
      public int getGroundHeight(final int tileX, final int tileY) {
@@ -364,7 +414,7 @@ public boolean isBuildable(final TilePosition position, final boolean includeBui
         if (!position.isValid(this)) {
             return false;
         }
-        return gameData.buildable(position.x, position.y) && ( includeBuildings ? !gameData.occupied(position.x,  position.y) : true );
+        return buildable[position.x][position.y] && ( includeBuildings ? !gameData.occupied(position.x,  position.y) : true );
      }
 
      public boolean isVisible(final int tileX, final int tileY) {
@@ -839,9 +889,7 @@ public boolean canUpgrade(final UpgradeType type, final Unit unit, final boolean
      }
 
      public List<TilePosition> getStartLocations() {
-         return IntStream.range(0, gameData.startLocationCount())
-                 .mapToObj(i -> new TilePosition(gameData.startLocationX(i), gameData.startLocationY(i)))
-                 .collect(Collectors.toList());
+         return new ArrayList<>(startLocations);
      }
 
 
@@ -862,19 +910,19 @@ public boolean isInGame() {
      }
 
      public boolean isMultiplayer() {
-         return gameData.isMultiplayer();
+         return multiplayer;
      }
 
      public boolean isBattleNet() {
-         return gameData.isBattleNet();
+         return battleNet;
      }
 
      public boolean isPaused() {
          return gameData.isPaused();
      }
 
      public boolean isReplay() {
-         return gameData.isReplay();
+         return replay;
      }
 
      public void pauseGame() {
@@ -911,16 +959,16 @@ public Set<Unit> getSelectedUnits() {
      }
 
     public Player self() {
-        return players.get(gameData.self());
+        return self;
     }
 
 
     public Player enemy() {
-        return players.get(gameData.enemy());
+        return enemy;
     }
 
     public Player neutral() {
-        return players.get(gameData.neutral());
+        return neutral;
     }
 
 
@@ -1279,11 +1327,11 @@ public int getRemainingLatencyTime() {
     }
 
     public int getRevision() {
-        return gameData.getRevision();
+        return revision;
     }
 
     public boolean isDebug() {
-        return gameData.isDebug();
+        return debug;
     }
 
     public boolean isLatComEnabled() {
@@ -1429,6 +1477,6 @@ public int getDamageTo(final UnitType toType, final UnitType fromType, final Pla
 
     //Since 4.2.0
     public int getRandomSeed() {
-        return gameData.randomSeed();
+        return randomSeed;
     }
 }

src/main/java/bwapi/Player.java

@@ -18,18 +18,33 @@
 public class Player {
     private final PlayerData playerData;
     private final Game game;
+    private final int id;
+    private final String name;
+    private final Race race;
+    private final PlayerType playerType;
+    private final Force force;
+    private final boolean neutral;
+    private final TilePosition startLocation;
 
     Player(final PlayerData playerData, final Game game) {
         this.playerData = playerData;
         this.game = game;
+
+        this.id = playerData.id();
+        this.name = playerData.name();
+        this.race = Race.races[playerData.race()];
+        this.playerType = PlayerType.playerTypes[playerData.type()];
+        this.force = game.getForce(playerData.force());
+        this.neutral = equals(game.neutral());
+        this.startLocation = new TilePosition(playerData.startLocationX(), playerData.startLocationY());
     }
 
     public int getID() {
-        return playerData.id();
+        return id;
     }
 
     public String getName() {
-        return playerData.name();
+        return name;
     }
 
     public Set<Unit> getUnits() {
@@ -39,15 +54,15 @@ public Set<Unit> getUnits() {
     }
 
     public Race getRace() {
-        return Race.races[playerData.race()];
+        return race;
     }
 
     public PlayerType getType() {
-        return PlayerType.playerTypes[playerData.type()];
+        return playerType;
     }
 
     public Force getForce() {
-        return game.getForce(playerData.force());
+        return force;
     }
 
     public boolean isAlly(final Player player) {
@@ -60,11 +75,11 @@ public boolean isEnemy(final Player player) {
     }
 
     public boolean isNeutral() {
-        return equals(game.neutral());
+        return neutral;
     }
 
     public TilePosition getStartLocation() {
-        return new TilePosition(playerData.startLocationX(), playerData.startLocationY());
+        return startLocation;
     }
 
     public boolean isVictorious() {