Assigning the asynchronous bot perspective to Game

Author: dgant

src/main/java/bwapi/BWClient.java

@@ -7,7 +7,7 @@
  */
 public class BWClient {
     private final BWEventListener eventListener;
-    private EventHandler handler;
+    private BotWrapper botWrapper;
 
     public BWClient(final BWEventListener eventListener) {
         Objects.requireNonNull(eventListener);
@@ -16,9 +16,10 @@ public BWClient(final BWEventListener eventListener) {
 
     /**
      * Get the {@link Game} instance of the currently running game.
+     * When running in asynchronous mode, this is the game from the bot's perspective, eg. potentially a previous frame.
      */
     public Game getGame() {
-        return handler == null ? null : handler.getGame();
+        return botWrapper == null ? null : botWrapper.getGame();
     }
 
     public void startGame() {
@@ -47,21 +48,44 @@ public void startGame(BWClientConfiguration configuration) {
         configuration.validate();
         Client client = new Client(configuration);
         client.reconnect();
-        handler = new EventHandler(eventListener, client);
 
         do {
-            BotWrapper botWrapper;
+            long lastUpdateTimestampMillis = 0;
+            System.out.println("Client: Starting game");
             while (!getGame().isInGame()) {
                 if (!client.isConnected()) {
                     return;
                 }
+                System.out.println("Client: connected.");
+                lastUpdateTimestampMillis = System.currentTimeMillis();
                 client.update();
             }
 
-            botWrapper = new BotWrapper(configuration, client.mapFile(), client.clientData(), handler);
+            System.out.println("Client: Creating bot wrapper");
+            BotWrapper botWrapper = new BotWrapper(configuration, eventListener, client.mapFile());
 
             while (getGame().isInGame()) {
+                System.out.println("Client: Stepping bot wrapper");
                 botWrapper.step();
+                System.out.println("Client: Waiting for idle bot or frame duration");
+
+                // Proceed immediately once framebuffer is empty
+                // Otherwise, wait for bot to catch up
+                // TODO: Replace with a wait instead of a sleep
+                // TODO: Respect configuration.asyncWaitOnFrameZero
+                while ( ! botWrapper.botIdle()) {
+                    long frameDuration = System.currentTimeMillis() - lastUpdateTimestampMillis;
+                    if (frameDuration > configuration.asyncFrameDurationMillis && (client.clientData().gameData().getFrameCount() > 0 || ! configuration.asyncWaitOnFrameZero)) {
+                        System.out.println("Client: Exceeded frame duration while waiting for bot: " + frameDuration + "ms on frame " + client.clientData().gameData().getFrameCount());
+                        break;
+                    }
+                    try {
+                        Thread.sleep(1);
+                    } catch (InterruptedException ignored) {}
+                }
+
+                System.out.println("Client: Ending frame. Frames buffered: ");
+                lastUpdateTimestampMillis = System.currentTimeMillis();
                 client.update();
                 if (!client.isConnected()) {
                     System.out.println("Reconnecting...");

src/main/java/bwapi/BWClientConfiguration.java

@@ -29,10 +29,10 @@ public class BWClientConfiguration {
     public boolean async = false;
 
     /**
-     * If JBWAPI detects that this much time (in nanoseconds) has passed since a bot's event handlers began, returns control back to BWAPI.
+     * If JBWAPI detects that this much time (in milliseconds) has passed since a bot's event handlers began, returns control back to BWAPI.
      * Real-time human play typically uses the "fastest" game speed, which has 42.86ms (42,860ns) between frames.
      */
-    public int asyncFrameDurationNanos = 40000;
+    public int asyncFrameDurationMillis = 40000;
 
     /**
      * The maximum number of frames to buffer while waiting on a bot.
@@ -53,8 +53,8 @@ public class BWClientConfiguration {
      * Checks that the configuration is in a valid state. Throws an IllegalArgumentException if it isn't.
      */
     public void validate() {
-        if (async && asyncFrameDurationNanos < 0) {
-            throw new IllegalArgumentException("asyncFrameDurationNanos needs to be a non-negative number (it's how long JBWAPI waits for a bot response before returning control to BWAPI).");
+        if (async && asyncFrameDurationMillis < 0) {
+            throw new IllegalArgumentException("asyncFrameDurationMillis needs to be a non-negative number (it's how long JBWAPI waits for a bot response before returning control to BWAPI).");
         }
         if (async && asyncFrameBufferSize < 1) {
             throw new IllegalArgumentException("asyncFrameBufferSize needs to be a positive number (There needs to be at least one frame buffer).");

src/main/java/bwapi/BotWrapper.java

@@ -26,63 +26,74 @@ of this software and associated documentation files (the "Software"), to deal
 package bwapi;
 
 import java.nio.ByteBuffer;
+import java.util.EventListener;
 
 /**
  * Manages invocation of bot event handlers
  */
 class BotWrapper {
     private final BWClientConfiguration configuration;
-    private final ByteBuffer sharedMemory;
-    private final ClientData clientData;
-    private final EventHandler eventHandler;
+    private final BWEventListener eventListener;
+    private final Game game;
     private final FrameBuffer frameBuffer;
     private final Thread botThread;
 
-    BotWrapper(
-            BWClientConfiguration configuration,
-            ByteBuffer sharedMemory,
-            ClientData clientData,
-            EventHandler eventHandler) {
+    BotWrapper(BWClientConfiguration configuration, BWEventListener eventListener, ByteBuffer dataSource) {
         this.configuration = configuration;
-        this.sharedMemory = sharedMemory;
-        this.clientData = clientData;
-        this.eventHandler = eventHandler;
+        this.eventListener = eventListener;
+
+        ClientData currentClientData = new ClientData();
+        currentClientData.setBuffer(dataSource);
+        game = new Game(currentClientData);
 
         if (configuration.async) {
-            frameBuffer = new FrameBuffer(configuration.asyncFrameBufferSize);
+            frameBuffer = new FrameBuffer(configuration.asyncFrameBufferSize, dataSource);
             botThread = new Thread(() -> {
                 while(true) {
-                    while(frameBuffer.empty()) try {
-                        frameBuffer.wait();
-                    } catch (InterruptedException ignored) {}
+                    while(frameBuffer.empty()) try { Thread.sleep(0, 100); } catch (InterruptedException ignored) {}
+
+                    System.out.println("Bot thread: Dequeuing frame. There are " + frameBuffer.framesBuffered() + " frames buffered.");
+                    game.clientData().setBuffer(frameBuffer.dequeueFrame());
 
-                    frameBuffer.dequeueFrame(clientData);
+                    System.out.println("Bot thread: Handling events.");
                     handleEvents();
-                    if (!clientData.new GameData(0).isInGame()) {
+                    if (!game.clientData().gameData().isInGame()) {
+                        System.out.println("Bot thread: Exiting.");
                         return;
+                    } else {
+                        System.out.println("Bot thread: Handled events.");
                     }
                 }
             });
+            botThread.setName("JBWAPI Bot");
+            botThread.start();
         } else {
             frameBuffer = null;
             botThread = null;
         }
     }
 
+    Game getGame() {
+        return game;
+    }
+
+    boolean botIdle() {
+        // TODO: This returns true if the bot is still processing the newest frame, leaving the bot permanently one frame behind
+        return frameBuffer.empty();
+    }
+
     void step() {
         if (configuration.async) {
-            frameBuffer.enqueueFrame(sharedMemory);
-            frameBuffer.notifyAll();
+            frameBuffer.enqueueFrame();
         } else {
             handleEvents();
         }
     }
 
     private void handleEvents() {
-        for (int i = 0; i < clientData.new GameData(0).getEventCount(); i++) {
-            eventHandler.operation(clientData.new GameData(0).getEvents(i));
+        ClientData.GameData gameData = game.clientData().gameData();
+        for (int i = 0; i < gameData.getEventCount(); i++) {
+            EventHandler.operation(eventListener, game, gameData.getEvents(i));
         }
     }
-
-
 }

src/main/java/bwapi/Client.java

@@ -41,15 +41,10 @@ interface MappingKernel extends Kernel32 {
         HANDLE OpenFileMapping(int desiredAccess, boolean inherit, String name);
     }
 
-    public interface EventHandler {
-        void operation(ClientData.Event event);
-    }
-
     private static final int READ_WRITE = 0x1 | 0x2 | 0x4;
     private static final int SUPPORTED_BWAPI_VERSION = 10003;
 
     private ClientData clientData;
-    private ClientData.GameData gameData;
     private boolean connected = false;
     private RandomAccessFile pipeObjectHandle = null;
     private ByteBuffer gameTableFileHandle = null;
@@ -67,17 +62,12 @@ public interface EventHandler {
     Client(ByteBuffer buffer) {
         clientData = new ClientData();
         clientData.setBuffer(buffer);
-        gameData = clientData.new GameData(0);
     }
 
     ClientData clientData() {
         return clientData;
     }
 
-    GameData gameData() {
-        return gameData;
-    }
-
     ByteBuffer mapFile() {
         return mapFileHandle;
     }
@@ -92,7 +82,7 @@ void reconnect() {
         }
     }
 
-    void disconnect() {
+    private void disconnect() {
         if (configuration.debugConnection) {
             System.err.print("Disconnect called by: ");
             System.err.println(Thread.currentThread().getStackTrace()[2]);
@@ -113,7 +103,7 @@ void disconnect() {
 
         gameTableFileHandle = null;
         mapFileHandle = null;
-        gameData = null;
+        clientData = null;
         connected = false;
     }
 
@@ -204,7 +194,6 @@ boolean connect() {
         try {
             clientData = new ClientData();
             clientData.setBuffer(mapFileHandle);
-            gameData = clientData.new GameData(0);
         }
         catch (Exception e) {
             System.err.println("Unable to map game data.");
@@ -214,10 +203,10 @@ boolean connect() {
             return false;
         }
 
-        if (SUPPORTED_BWAPI_VERSION != gameData.getClient_version()) {
+        if (SUPPORTED_BWAPI_VERSION != clientData.gameData().getClient_version()) {
             System.err.println("Error: Client and Server are not compatible!");
             System.err.println("Client version: " + SUPPORTED_BWAPI_VERSION);
-            System.err.println("Server version: " + gameData.getClient_version());
+            System.err.println("Server version: " + clientData.gameData().getClient_version());
             disconnect();
             sleep(2000);
             return false;