Disabled latency compensation in async mode.

Author: dgant

src/main/java/bwapi/BWClientConfiguration.java

@@ -75,6 +75,8 @@ int getMaxFrameDurationMs() {
      * returns control to StarCraft, allowing the game to proceed while the bot continues to step in the background. This increases the likelihood of meeting
      * real-time performance requirements, while not fully guaranteeing it (subject to the whims of the JVM thread scheduler), at a cost of the bot possibly
      * issuing commands later than intended, and a marginally larger memory footprint.
+     *
+     * Asynchronous mode is not compatible with latency compensation. Enabling asynchronous mode automatically disables latency compensation.
      */
     public BWClientConfiguration withAsync(boolean value) {
         throwIfLocked();

src/main/java/bwapi/BotWrapper.java

@@ -36,6 +36,7 @@ void startNewGame(WrappedBuffer liveData, PerformanceMetrics performanceMetrics)
         }
         this.performanceMetrics = performanceMetrics;
         botGame = new Game();
+        botGame.setConfiguration(configuration);
         botGame.botClientData().setBuffer(liveData);
         liveClientData.setBuffer(liveData);
         this.liveData = liveData;

src/main/java/bwapi/Game.java

@@ -95,6 +95,7 @@ public final class Game {
     // USER DEFINED
 
     private Text.Size textSize = Text.Size.Default;
+    private BWClientConfiguration configuration = new BWClientConfiguration();
     private boolean latcom = true;
 
     final SideEffectQueue sideEffects = new SideEffectQueue();
@@ -103,6 +104,10 @@ public final class Game {
         clientData = new ClientData();
     }
 
+    void setConfiguration(BWClientConfiguration configuration) {
+        this.configuration = configuration;
+    }
+
     ClientData botClientData() {
         return clientData;
     }
@@ -270,7 +275,7 @@ void init() {
             observers = playerSet.stream().filter(p -> !p.equals(self()) && p.isObserver())
                     .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
         }
-        setLatCom(true);
+        setLatCom(!configuration.getAsync());
     }
 
     void unitCreate(final int id) {
@@ -2171,6 +2176,9 @@ final public boolean isLatComEnabled() {
      * @see #isLatComEnabled
      */
     public void setLatCom(final boolean isEnabled) {
+        if (isEnabled && configuration.getAsync()) {
+            throw new IllegalStateException("Latency compensation is not compatible with JBWAPI asynchronous mode.");
+        }
         //update shared memory
         gameData().setHasLatCom(isEnabled);
         //update internal memory
@@ -2654,35 +2662,49 @@ public int getRandomSeed() {
      * Convenience method for adding a unit command from raw arguments.
      */
     void addUnitCommand(final int type, final int unit, final int target, final int x, final int y, final int extra) {
-        sideEffects.enqueue(SideEffect.addUnitCommand(type, unit, target, x, y, extra));
+        enqueueOrDo(SideEffect.addUnitCommand(type, unit, target, x, y, extra));
     }
 
     /**
      * Convenience method for adding a game command from raw arguments.
      */
     void addCommand(final CommandType type, final int value1, final int value2) {
-        sideEffects.enqueue(SideEffect.addCommand(type, value1, value2));
+        enqueueOrDo(SideEffect.addCommand(type, value1, value2));
     }
 
     /**
      * Convenience method for adding a game command from raw arguments.
      */
     void addCommand(final CommandType type, final String value1, final int value2) {
-        sideEffects.enqueue(SideEffect.addCommand(type, value1, value2));
+        enqueueOrDo(SideEffect.addCommand(type, value1, value2));
     }
 
     /**
      * Convenience method for adding a shape from raw arguments.
      */
     void addShape(final ShapeType type, final CoordinateType coordType, final int x1, final int y1, final int x2, final int y2, final int extra1, final int extra2, final int color, final boolean isSolid) {
-        sideEffects.enqueue(SideEffect.addShape(type, coordType, x1, y1, x2, y2, extra1, extra2, color, isSolid));
+        enqueueOrDo(SideEffect.addShape(type, coordType, x1, y1, x2, y2, extra1, extra2, color, isSolid));
     }
 
     /**
      * Convenience method for adding a shape from raw arguments.
      */
     void addShape(final ShapeType type, final CoordinateType coordType, final int x1, final int y1, final int x2, final int y2, final String text, final int extra2, final int color, final boolean isSolid) {
-        sideEffects.enqueue(SideEffect.addShape(type, coordType, x1, y1, x2, y2, text, extra2, color, isSolid));
+        enqueueOrDo(SideEffect.addShape(type, coordType, x1, y1, x2, y2, text, extra2, color, isSolid));
+    }
+
+    /**
+     * Applies a side effect, either immediately (if operating synchronously)
+     * or by enqueuing it for later execution (if operating asynchronously).
+     *
+     * @param sideEffect
+     */
+    void enqueueOrDo(SideEffect sideEffect) {
+        if (configuration.getAsync()) {
+            sideEffects.enqueue(sideEffect);
+        } else {
+            sideEffect.apply(gameData());
+        }
     }
 
     void setAllUnits(List<Unit> units) {

src/test/java/bwapi/SynchronizationTest.java

@@ -284,4 +284,18 @@ public void async_MeasurePerformance_IntentionallyBlocking() {
         });
         environment.runGame(3);
     }
+
+    @Test
+    public void async_DisablesLatencyCompensation() {
+        SynchronizationEnvironment environmentSync = new SynchronizationEnvironment();
+        environmentSync.configuration.withAsync(false);
+        environmentSync.onFrame(1, () -> { assertTrue(environmentSync.bwClient.getGame().isLatComEnabled()); });
+        environmentSync.runGame(2);
+
+        SynchronizationEnvironment environmentAsync = new SynchronizationEnvironment();
+        environmentAsync.configuration.withAsync(true).withAsyncFrameBufferCapacity(2);
+        environmentAsync.onFrame(1, () -> { assertFalse(environmentAsync.bwClient.getGame().isLatComEnabled()); });
+        environmentAsync.onFrame(2, () -> { assertThrows(IllegalStateException.class, () -> environmentAsync.bwClient.getGame().setLatCom(true)); });
+        environmentAsync.runGame(3);
+    }
 }