Only copy active units in FrameBuffer

Author: Jasper Geurtz

src/main/java/bwapi/FrameBuffer.java

@@ -12,6 +12,16 @@
  */
 class FrameBuffer {
     static final int BUFFER_SIZE = PackedWrappedBuffer.BUFFER_SIZE;
+
+    static final int INITIAL_UNIT_COUNT_OFFSET = 69648;
+    static final int UNITS_START = 69656;
+    static final int MAX_UNITS = 10000;
+    static final int UNITS_END = UNITS_START + MAX_UNITS * ClientData.UnitData.SIZE;
+
+    static final int EVENT_COUNT_OFFSET = 10586620;
+    static final int EVENTS_START = 10586624;
+    static final int MAX_EVENTS = 10000;
+
     private static final Unsafe unsafe = UnsafeTools.getUnsafe();
 
     private WrappedBuffer liveData;
@@ -20,6 +30,7 @@ class FrameBuffer {
     private final int capacity;
     private int stepGame = 0;
     private int stepBot = 0;
+    private int maxUnitCount = 0;
     private final ArrayList<WrappedBuffer> dataBuffer = new ArrayList<>();
 
     private final Lock lockWrite = new ReentrantLock();
@@ -42,6 +53,7 @@ void initialize(WrappedBuffer liveData, PerformanceMetrics performanceMetrics) {
         this.performanceMetrics = performanceMetrics;
         stepGame = 0;
         stepBot = 0;
+        maxUnitCount = 0;
     }
 
     /**
@@ -151,9 +163,46 @@ void dequeue() {
         } finally { lockSize.unlock(); }
     }
 
+    int getMaxUnitCount() {
+        return maxUnitCount;
+    }
+
+    private static int clamp(int value, int min, int max) {
+        return Math.max(min, Math.min(max, value));
+    }
+
+    private int updateMaxUnitCount(WrappedBuffer source) {
+        int initialUnits = clamp(source.getInt(INITIAL_UNIT_COUNT_OFFSET), 0, MAX_UNITS);
+        if (initialUnits > maxUnitCount) {
+            maxUnitCount = initialUnits;
+        }
+
+        int eventCount = clamp(source.getInt(EVENT_COUNT_OFFSET), 0, MAX_EVENTS);
+        for (int i = 0; i < eventCount; i++) {
+            int eventOffset = EVENTS_START + i * ClientData.Event.SIZE;
+            if (source.getInt(eventOffset) == EventType.UnitDiscover.id) {
+                int unitId = source.getInt(eventOffset + 4);
+                if (unitId >= 0 && unitId < MAX_UNITS && unitId + 1 > maxUnitCount) {
+                    maxUnitCount = unitId + 1;
+                }
+            }
+        }
+        return maxUnitCount;
+    }
+
     void copyBuffer(WrappedBuffer source, WrappedBuffer destination) {
-        unsafe.copyMemory(source.getAddress() + 0, destination.getAddress() + PackedWrappedBuffer.DEST_SLICE1_OFFSET, PackedWrappedBuffer.DYNAMIC_SLICE1_SIZE);
-        unsafe.copyMemory(source.getAddress() + PackedWrappedBuffer.STATICTILES_END, destination.getAddress() + PackedWrappedBuffer.DEST_SLICE2_OFFSET, PackedWrappedBuffer.DYNAMIC_SLICE2_SIZE);
-        unsafe.copyMemory(source.getAddress() + PackedWrappedBuffer.REGION_END, destination.getAddress() + PackedWrappedBuffer.DEST_SLICE3_OFFSET, PackedWrappedBuffer.DYNAMIC_SLICE3_SIZE);
+        long srcAddr = source.getAddress();
+        long dstAddr = destination.getAddress();
+        int activeUnits = updateMaxUnitCount(source);
+
+        // Slice 1a: header, forces, players, initialUnitCount, and active units [0 .. maxUnitCount)
+        int slice1ActiveUnitsEnd = UNITS_START + activeUnits * ClientData.UnitData.SIZE;
+        unsafe.copyMemory(srcAddr, dstAddr + PackedWrappedBuffer.DEST_SLICE1_OFFSET, slice1ActiveUnitsEnd);
+        // Slice 1b: unitArray, bullets, nukeDots, frameCount, and other post-unit Slice 1 fields
+        unsafe.copyMemory(srcAddr + UNITS_END, dstAddr + PackedWrappedBuffer.DEST_SLICE1_OFFSET + UNITS_END, PackedWrappedBuffer.STATICTILES_START - UNITS_END);
+        // Slice 2: dynamic tile flags
+        unsafe.copyMemory(srcAddr + PackedWrappedBuffer.STATICTILES_END, dstAddr + PackedWrappedBuffer.DEST_SLICE2_OFFSET, PackedWrappedBuffer.DYNAMIC_SLICE2_SIZE);
+        // Slice 3: dynamic game state, events, and eventStrings
+        unsafe.copyMemory(srcAddr + PackedWrappedBuffer.REGION_END, dstAddr + PackedWrappedBuffer.DEST_SLICE3_OFFSET, PackedWrappedBuffer.DYNAMIC_SLICE3_SIZE);
     }
 }

src/test/java/bwapi/AsyncClientDataTest.java

@@ -213,4 +213,39 @@ public void asyncClientDataWorksWithFullUnpackedBuffer() {
         assertTrue(asyncData.gameData().isVisible(10, 20));
         assertTrue(asyncData.gameData().isInGame());
     }
+
+    @Test
+    public void copyBufferTracksMaxUnitsAndOnlyCopiesActiveUnits() {
+        WrappedBuffer mainBuffer = new WrappedBuffer(ClientData.GameData.SIZE);
+        PackedWrappedBuffer packedBuffer = new PackedWrappedBuffer();
+
+        ClientData mainData = new ClientData();
+        mainData.setBuffer(mainBuffer);
+
+        // Set initialUnitCount = 3 and populate unit #2 and unit #50 (beyond initialUnitCount)
+        mainData.gameData().setInitialUnitCount(3);
+        mainData.gameData().getUnits(2).setHitPoints(100);
+        mainData.gameData().getUnits(50).setHitPoints(250);
+
+        FrameBuffer frameBuffer = new FrameBuffer(
+                new BWClientConfiguration.Builder().withAsyncFrameBufferCapacity(1).build());
+        frameBuffer.copyBuffer(mainBuffer, packedBuffer);
+
+        AsyncClientData asyncData = new AsyncClientData(mainBuffer);
+        asyncData.setBuffer(packedBuffer);
+
+        assertEquals(3, frameBuffer.getMaxUnitCount());
+        assertEquals(100, asyncData.gameData().getUnits(2).getHitPoints());
+        // Unit #50 was beyond maxUnitCount, so it was skipped
+        assertEquals(0, asyncData.gameData().getUnits(50).getHitPoints());
+
+        // Now fire UnitDiscover for unit #50 on the next frame
+        mainData.gameData().setEventCount(1);
+        mainData.gameData().getEvents(0).setType(EventType.UnitDiscover);
+        mainData.gameData().getEvents(0).setV1(50);
+        frameBuffer.copyBuffer(mainBuffer, packedBuffer);
+
+        assertEquals(51, frameBuffer.getMaxUnitCount());
+        assertEquals(250, asyncData.gameData().getUnits(50).getHitPoints());
+    }
 }