New utilities: Reservation-Implementations for GMS and "things" (ie. TilePositions)

Author: Bytekeeper

src/main/java/org/bk/ass/manage/GMS.java

@@ -6,6 +6,7 @@
 import bwapi.TechType;
 import bwapi.UnitType;
 import bwapi.UpgradeType;
+import java.util.Objects;
 
 /** Representing gas + minerals + supply */
 public final class GMS {
@@ -56,11 +57,15 @@ public GMS add(GMS gms) {
     return new GMS(gas + gms.gas, minerals + gms.minerals, supply + gms.supply);
   }
 
+  public GMS multiply(int factor) {
+    return new GMS(gas * factor, minerals * factor, supply * factor);
+  }
+
   /**
    * If all components (gas, minerals, supply) of this value are non-negative, returns true if all
    * are >= that of the given value. If a component is negative, returns false if the given
-   * value's component is &gt;= 0. <br>
-   * Usually all components are &gt;= 0 and this can be used to check if a price could be payed
+   * value's component is &gt;= 0. <br> Usually all components are &gt;= 0 and this can be used to
+   * check if a price could be payed
    * <em>now</em>. <br>
    * If planning ahead is used, components could already be negative. But if the cost (ie. supply)
    * is 0, it might still be possible to purchase it immediately.
@@ -75,4 +80,23 @@ && max(0, minerals) >= gms.minerals
   public String toString() {
     return "gas: " + gas + ", minerals: " + minerals + ", supply: " + supply;
   }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    GMS gms = (GMS) o;
+    return gas == gms.gas &&
+        minerals == gms.minerals &&
+        supply == gms.supply;
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(gas, minerals, supply);
+  }
 }

src/main/java/org/bk/ass/manage/GMSReservation.java

@@ -0,0 +1,49 @@
+package org.bk.ass.manage;
+
+import java.util.function.IntFunction;
+
+/**
+ * {@link Reservation} implementation for {@link GMS}. Can be used for tracking the remaining
+ * available resources. (Ie. start each frame by {@link #setGms(GMS)} using the current amount of
+ * resources, then use {@link GMS-}{@link Lock}s to track reservations.)
+ */
+public class GMSReservation implements Reservation<GMS> {
+
+  private GMS gms = GMS.ZERO;
+  private final IntFunction<GMS> gmsPrediction;
+
+  public GMSReservation(
+      IntFunction<GMS> gmsPrediction) {
+    this.gmsPrediction = gmsPrediction;
+  }
+
+  public GMSReservation() {
+    this(unused -> GMS.ZERO);
+  }
+
+  public void setGms(GMS gms) {
+    this.gms = gms;
+  }
+
+  public GMS getGms() {
+    return gms;
+  }
+
+  @Override
+  public boolean reserve(Lock<GMS> lock, GMS gmsToReserve) {
+    boolean success = gms.canAfford(gmsToReserve);
+    gms = gms.subtract(gmsToReserve);
+    return success;
+  }
+
+  @Override
+  public boolean itemAvailableInFuture(Lock<GMS> lock, GMS futureItem, int futureFrames) {
+    GMS futureGMS = gmsPrediction.apply(futureFrames).add(gms);
+    return futureGMS.canAfford(futureItem);
+  }
+
+  @Override
+  public void release(Lock<GMS> lock, GMS gmsToRelease) {
+    gms = gms.add(gmsToRelease);
+  }
+}

src/main/java/org/bk/ass/manage/SetReservation.java

@@ -0,0 +1,29 @@
+package org.bk.ass.manage;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Simple {@link Reservation} that allows only one item of the given type to be reserved at a time.
+ *
+ * @param <T>
+ */
+public class SetReservation<T> implements Reservation<T> {
+
+  private final Set<T> reservedItems = new HashSet<>();
+
+  public void setReservedItems(Set<T> reservedItems) {
+    this.reservedItems.clear();
+    this.reservedItems.addAll(reservedItems);
+  }
+
+  @Override
+  public boolean reserve(Lock<T> lock, T item) {
+    return reservedItems.add(item);
+  }
+
+  @Override
+  public void release(Lock<T> lock, T item) {
+    reservedItems.remove(item);
+  }
+}

src/test/java/org/bk/ass/manage/GMSReservationTest.java

@@ -0,0 +1,51 @@
+package org.bk.ass.manage;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class GMSReservationTest {
+
+  @Test
+  void shouldReserveSuccessfullyIfAffordable() {
+    // GIVEN
+    GMSReservation sut = new GMSReservation();
+    sut.setGms(new GMS(1, -1, 0));
+
+    // WHEN
+    boolean reserved = sut.reserve(null, new GMS(1, 0, 0));
+
+    // THEN
+    assertThat(reserved).isTrue();
+    assertThat(sut.getGms()).isEqualTo(new GMS(0, -1, 0));
+  }
+
+  @Test
+  void shouldBlockResourcesIfNotAffordable() {
+    // GIVEN
+    GMSReservation sut = new GMSReservation();
+    sut.setGms(new GMS(-1, -1, 0));
+
+    // WHEN
+    boolean reserved = sut.reserve(null, new GMS(1, 1, 0));
+
+    // THEN
+    assertThat(reserved).isFalse();
+    assertThat(sut.getGms()).isEqualTo(new GMS(-2, -2, 0));
+  }
+
+  @Test
+  void shouldBeAvailableInFuture() {
+    // GIVEN
+    GMSReservation sut = new GMSReservation(frames -> new GMS(1, 1, 1).multiply(frames));
+    GMS initialGMS = new GMS(-10, -10, -10);
+    sut.setGms(initialGMS);
+
+    // WHEN
+    boolean reserved = sut.itemAvailableInFuture(null, new GMS(1, 1, 1), 11);
+
+    // THEN
+    assertThat(reserved).isTrue();
+    assertThat(sut.getGms()).isEqualTo(initialGMS);
+  }
+}