Only use utility of un-finished children; more documentation

Author: Bytekeeper

src/main/java/org/bk/ass/bt/CompoundNode.java

@@ -29,7 +29,11 @@ protected void execChild(TreeNode child, ExecutionContext context) {
   }
 
   protected void abortRunningChildren() {
-    children.stream().filter(it -> it.status == NodeStatus.RUNNING).forEach(TreeNode::abort);
+    for (TreeNode it : children) {
+      if (it.status == NodeStatus.RUNNING) {
+        it.abort();
+      }
+    }
   }
 
   @Override
@@ -44,9 +48,14 @@ public void close() {
     children.forEach(TreeNode::close);
   }
 
+  /**
+   * Will return the highest utility of all children which are still running or not yet executed.
+   */
   @Override
   public double getUtility() {
-    return children.stream().mapToDouble(TreeNode::getUtility).max().orElseGet(super::getUtility);
+    return children.stream()
+        .filter(it -> it.status == NodeStatus.INITIAL || it.status == NodeStatus.RUNNING)
+        .mapToDouble(TreeNode::getUtility).max().orElseGet(super::getUtility);
   }
 
   @Override

src/main/java/org/bk/ass/bt/Parallel.java

@@ -2,6 +2,11 @@
 
 import org.bk.ass.StopWatch;
 
+/**
+ * Using a {@link Policy}, a behavior similar to {@link Sequence} or {@link Selector}. But Parallel
+ * will not wait for a {@link NodeStatus#RUNNING} node to complete and just {@link
+ * #exec(ExecutionContext)} the next child node.
+ */
 public class Parallel extends CompoundNode {
 
   private Policy policy;

src/main/java/org/bk/ass/bt/Selector.java

@@ -2,6 +2,13 @@
 
 import org.bk.ass.StopWatch;
 
+/**
+ * Reactive Selector node: Every time {@link #exec(ExecutionContext)} is called all nodes are
+ * executed in order. Even if they are in a non-running state. {@link NodeStatus#SUCCESS} will be
+ * returned, as soon as any child node succeeds.
+ *
+ * <p>In case it succeeds, all children in state {@link NodeStatus#RUNNING} will get aborted.
+ */
 public class Selector extends CompoundNode {
 
   public Selector(TreeNode... children) {

src/main/java/org/bk/ass/bt/Sequence.java

@@ -2,6 +2,14 @@
 
 import org.bk.ass.StopWatch;
 
+/**
+ * Reactive Sequence node: Every time {@link #exec(ExecutionContext)} is called all nodes are
+ * executed in order. Even if they are in a non-running state. {@link NodeStatus#SUCCESS} will only
+ * be returned, if all child nodes return that value.
+ *
+ * <p>If any child fails, the Sequence will also fail. In that case, all children in state {@link
+ * NodeStatus#RUNNING} will get aborted.
+ */
 public class Sequence extends CompoundNode {
 
   public Sequence(TreeNode... children) {

src/main/java/org/bk/ass/bt/TreeNode.java

@@ -1,6 +1,7 @@
 package org.bk.ass.bt;
 
 public abstract class TreeNode {
+
   String name = getClass().getSimpleName();
   NodeStatus status;
 
@@ -16,6 +17,11 @@ public void exec(ExecutionContext executionContext) {
 
   public abstract void exec();
 
+  /**
+   * Used by {@link CompoundNode}s to determine order of execution. Generally, nodes with {@link
+   * Selector} like behavior will run children in decreasing order of utility. Nodes with {@link
+   * Sequence} like behavior will not change the order of children unless explicitly stated.
+   */
   public double getUtility() {
     return 0;
   }

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

@@ -0,0 +1,85 @@
+package org.bk.ass.bt;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class CompoundNodeTest {
+
+  @Test
+  void shouldReturnUtilityOfChildInInitialState() {
+    // GIVEN
+    DummyCompound sut = new DummyCompound(
+        new NodeWithUtility(1.0, NodeStatus.SUCCESS),
+        new NodeWithUtility(0.5, NodeStatus.INITIAL)
+    );
+
+    // WHEN
+    double utility = sut.getUtility();
+
+    // THEN
+    assertThat(utility).isEqualTo(0.5);
+  }
+
+  @Test
+  void shouldReturnUtilityOfChildInRunningState() {
+    // GIVEN
+    DummyCompound sut = new DummyCompound(
+        new NodeWithUtility(1.0, NodeStatus.SUCCESS),
+        new NodeWithUtility(0.5, NodeStatus.RUNNING)
+    );
+
+    // WHEN
+    double utility = sut.getUtility();
+
+    // THEN
+    assertThat(utility).isEqualTo(0.5);
+  }
+
+  @Test
+  void shouldReturnHighestUtilityOfChildren() {
+    // GIVEN
+    DummyCompound sut = new DummyCompound(
+        new NodeWithUtility(1.0, NodeStatus.INITIAL),
+        new NodeWithUtility(0.5, NodeStatus.RUNNING)
+    );
+
+    // WHEN
+    double utility = sut.getUtility();
+
+    // THEN
+    assertThat(utility).isEqualTo(1.0);
+  }
+
+  private static class DummyCompound extends CompoundNode {
+
+    public DummyCompound(TreeNode... children) {
+      super(children);
+    }
+
+    @Override
+    public void exec(ExecutionContext context) {
+
+    }
+  }
+
+  private static class NodeWithUtility extends TreeNode {
+
+    private final double utility;
+
+    NodeWithUtility(double utility, NodeStatus status) {
+      this.utility = utility;
+      this.status = status;
+    }
+
+    @Override
+    public double getUtility() {
+      return utility;
+    }
+
+    @Override
+    public void exec() {
+
+    }
+  }
+}

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

@@ -519,7 +519,29 @@ void _8DragoonsVs6Hydras() {
     simulator.simulate(-1);
 
     // THEN
-    assertThat(simulator.getAgentsA()).size().isLessThanOrEqualTo(3);
+    assertThat(simulator.getAgentsA()).hasSizeLessThanOrEqualTo(3);
+    assertThat(simulator.getAgentsB()).isEmpty();
+  }
+
+  @Test
+  void _8DragoonsWithRangeUpgradeVs6Hydras() {
+    // GIVEN
+    for (int i = 0; i < 8; i++) {
+      simulator.addAgentA(factory.of(UnitType.Protoss_Dragoon, 0, 0, 64, 64, false, false, false).setX(1000 + i * 8).setY(800));
+    }
+    for (int i = 0; i < 6; i++) {
+      simulator.addAgentB(
+          factory
+              .of(UnitType.Zerg_Hydralisk, 0, 0, 0, 0, false, false, false)
+              .setX(1000 + i * 8)
+              .setY(1200));
+    }
+
+    // WHEN
+    simulator.simulate(-1);
+
+    // THEN
+    assertThat(simulator.getAgentsA()).hasSize(8);
     assertThat(simulator.getAgentsB()).isEmpty();
   }