Some firebat related tweaks for the evaluator.

Author: Bytekeeper

build.gradle.kts

@@ -6,7 +6,7 @@ plugins {
 }
 
 group = "org.bk"
-version = "1.1"
+version = "1.2"
 
 java {
     sourceCompatibility = JavaVersion.VERSION_1_8

src/main/java/org/bk/ass/StopWatch.java

@@ -0,0 +1,25 @@
+package org.bk.ass;
+
+import org.bk.ass.bt.ExecutionContext;
+import org.bk.ass.bt.TreeNode;
+
+public class StopWatch {
+  private long started = System.nanoTime();
+  private long stopped = Long.MIN_VALUE;
+
+  public long stop() {
+    long now = System.nanoTime();
+    if (stopped < started) {
+      stopped = now;
+    }
+    return stopped;
+  }
+
+  public int ms() {
+    return (int) ((stop() - started) / 1_000_000);
+  }
+
+  public void registerWith(ExecutionContext context, TreeNode node) {
+    context.registerExecutionTime(node, ms());
+  }
+}

src/main/java/org/bk/ass/sim/AgentUtil.java

@@ -116,8 +116,8 @@ public static int reduceDamageByTargetSizeAndDamageType(
   public static void randomizePositions(Collection<Agent> agents, int ax, int ay, int bx, int by) {
     SplittableRandom posRnd = new SplittableRandom(1337L);
     for (Agent agent : agents) {
-      agent.x = posRnd.nextInt(ax, bx - ax + 1);
-      agent.y = posRnd.nextInt(ay, by - ay + 1);
+      agent.x = posRnd.nextInt(ax, bx + 1);
+      agent.y = posRnd.nextInt(ay, by + 1);
     }
   }
 }

src/main/java/org/bk/ass/sim/Evaluator.java

@@ -93,7 +93,8 @@ public EvalWithAgents optimizeEval(Collection<Agent> agentsA, Collection<Agent>
     for (Agent a : agentsA) {
       agentsToBeat.remove(a);
       EvaluationResult eval = evaluate(agentsToBeat, agentsB);
-      if (eval.value > evalToBeat.value || eval.value == evalToBeat.value && evalToBeat == EVAL_NO_COMBAT) {
+      if (eval.value > evalToBeat.value
+          || eval.value == evalToBeat.value && evalToBeat == EVAL_NO_COMBAT) {
         evalToBeat = eval;
       } else {
         agentsToBeat.add(a);
@@ -295,13 +296,13 @@ public Parameters(double[] source) {
     public Parameters() {
       this(
           new double[] {
-            2.0608350462547205,
-            8.19938619214691,
-            0.19223277374228906,
-            7.706789576045348,
-            6.154650149331842,
-            5.884458141154542,
-            0.8991451082849068
+            3.6326962940790546,
+            6.831398819548727,
+            0.22335278133755543,
+            2.9421377239626465,
+            8.546407556172563,
+            9.522322351571518,
+            3.0851183828490942
           });
     }
   }

src/test/java/org/bk/ass/bt/ExecutionContextTest.java

@@ -0,0 +1,33 @@
+package org.bk.ass.bt;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.jupiter.api.Test;
+
+class ExecutionContextTest {
+  @Test
+  void shouldFillUpStackTrace() {
+    // GIVEN
+    AtomicReference<List<TreeNode>> trace = new AtomicReference<>();
+    TreeNode leafNode =
+        new TreeNode() {
+          @Override
+          public void exec() {}
+
+          @Override
+          public void exec(ExecutionContext executionContext) {
+            trace.set(executionContext.getNodeStack());
+          }
+        };
+    Sequence level1Sequence = new Sequence(leafNode);
+    Sequence sut = new Sequence(level1Sequence);
+
+    // WHEN
+    sut.exec(new ExecutionContext());
+
+    // THEN
+    assertThat(trace.get()).containsExactly(level1Sequence, leafNode);
+  }
+}

src/test/java/org/bk/ass/sim/EvaluatorTest.java

@@ -473,4 +473,40 @@ void optimizeAwayLingsVsZealotsWithEnoughMutas() {
     // THEN
     assertThat(result.agents).allMatch(it -> it.isFlyer);
   }
+
+  @Test
+  void _5firebatsVs9ZZealotsAreDead() {
+    // GIVEN
+    List<Agent> a =
+        IntRange.of(0, 5).stream()
+            .mapToObj(unused -> factory.of(UnitType.Terran_Firebat))
+            .collect(Collectors.toList());
+    List<Agent> b =
+            IntRange.of(0, 9).stream().mapToObj(unused -> factory.of(UnitType.Protoss_Zealot))
+            .collect(Collectors.toList());
+
+    // WHEN
+    EvaluationResult result = evaluator.evaluate(a, b);
+
+    // THEN
+    assertThat(result.value).isLessThan(0.2);
+  }
+
+  @Test
+  void _9firebatsVs9ZZealotsAreEvenlyMatched() {
+    // GIVEN
+    List<Agent> a =
+        IntRange.of(0, 9).stream()
+            .mapToObj(unused -> factory.of(UnitType.Terran_Firebat))
+            .collect(Collectors.toList());
+    List<Agent> b =
+            IntRange.of(0, 9).stream().mapToObj(unused -> factory.of(UnitType.Protoss_Zealot))
+            .collect(Collectors.toList());
+
+    // WHEN
+    EvaluationResult result = evaluator.evaluate(a, b);
+
+    // THEN
+    assertThat(result.value).isBetween(0.4, 0.6);
+  }
 }