Added medic test and fixed overflows in Evaluator

Bytekeeper · Bytekeeper · commit be38023aaaad · 2019-09-05T15:42:18.000+02:00
diff --git a/src/main/java/org/bk/ass/Evaluator.java b/src/main/java/org/bk/ass/Evaluator.java
@@ -35,8 +35,9 @@ public double evaluate(Collection<Agent> agentsA, Collection<Agent> agentsB) {
     agentsB.forEach(a -> a.onDeathHandler.accept(a, finalAgentsB));
     finalAgentsA.addAll(agentsA);
     finalAgentsB.addAll(agentsB);
-    int damageToA = new DamageBoard(finalAgentsB).sumDamageTo(finalAgentsA);
-    int damageToB = new DamageBoard(finalAgentsA).sumDamageTo(finalAgentsB);
+    double damageToA = new DamageBoard(finalAgentsB).sumDamageTo(finalAgentsA);
+    double damageToB = new DamageBoard(finalAgentsA).sumDamageTo(finalAgentsB);
+
     int regenToA = regeneration(finalAgentsA);
     int regenToB = regeneration(finalAgentsB);
     damageToA -= regenToA;
@@ -48,14 +49,12 @@ public double evaluate(Collection<Agent> agentsA, Collection<Agent> agentsB) {
       damageToB = 0;
     }
     double evalA =
-        (double) damageToA
-            / (finalAgentsA.stream()
+            damageToA / (finalAgentsA.stream()
                     .mapToDouble(a -> a.getHealth() + a.getShields() * parameters.shieldScale)
                     .sum()
                 + EPS);
     double evalB =
-        (double) damageToB
-            / (finalAgentsB.stream()
+            damageToB / (finalAgentsB.stream()
                     .mapToDouble(a -> a.getHealth() + a.getShields() * parameters.shieldScale)
                     .sum()
                 + EPS);
@@ -74,12 +73,6 @@ private int regeneration(Collection<Agent> agents) {
         .mapToInt(
             a -> {
               int healed = 0;
-              if (a.regeneratesHealth) {
-                healed = parameters.healthRegen;
-              }
-              if (a.maxShieldsShifted > 0) {
-                healed += parameters.shieldRegen;
-              }
               if (a.isHealer) {
                 healed += healables * parameters.heal;
               }
@@ -126,12 +119,12 @@ private void sumGroundDamage(Agent agent) {
     }
 
     private void sumAirDamage(Agent agent) {
-      Weapon weapon = agent.groundWeapon;
+      Weapon weapon = agent.airWeapon;
       double damageToApply = calculateDamage(agent, weapon);
-      if (agent.airWeapon.damageType == DamageType.CONCUSSIVE) {
+      if (weapon.damageType == DamageType.CONCUSSIVE) {
         airConcussiveDamage += (int) damageToApply;
         airConcussiveHits += weapon.hits;
-      } else if (agent.airWeapon.damageType == DamageType.EXPLOSIVE) {
+      } else if (weapon.damageType == DamageType.EXPLOSIVE) {
         airExplosiveDamage += (int) damageToApply;
         airExplosiveHits += weapon.hits;
       } else {
@@ -141,23 +134,19 @@ private void sumAirDamage(Agent agent) {
     }
 
     private double calculateDamage(Agent attacker, Weapon weapon) {
-      double rangeFactor = 1.0 + weapon.maxRange * parameters.rangeScale;
-      double speedFactor = 1.0 + attacker.speed * parameters.speedScale;
-      double radialSplashFactor = weapon.splashType == SplashType.RADIAL_ENEMY_SPLASH || weapon.splashType == SplashType.RADIAL_SPLASH ? 1.0 + parameters.radialSplashFactor * weapon.innerSplashRadius : 1.0;
-      double lineSplashFactor = weapon.splashType == SplashType.LINE_SPLASH ? 1.0 + parameters.lineSplashFactor * weapon.innerSplashRadius : 1.0;
-      double bounceSplashFactor = weapon.splashType == SplashType.BOUNCE ? parameters.bounceSplashFactor : 1.0;
+      double rangeFactor = weapon.maxRange * parameters.rangeScale;
+      double speedFactor = attacker.burrowedAttacker ? 0.0 : attacker.speed * parameters.speedScale;
+      double radialSplashFactor = weapon.splashType == SplashType.RADIAL_ENEMY_SPLASH || weapon.splashType == SplashType.RADIAL_SPLASH ? parameters.radialSplashScale * weapon.innerSplashRadius : 0.0;
+      double lineSplashFactor = weapon.splashType == SplashType.LINE_SPLASH ? parameters.lineSplashScale * weapon.innerSplashRadius : 0.0;
+      double bounceSplashFactor = weapon.splashType == SplashType.BOUNCE ? parameters.bounceSplashFactor : 0.0;
 
       return weapon.damageShifted
-          * rangeFactor
-          * speedFactor
-          * radialSplashFactor
-          * lineSplashFactor
-          * bounceSplashFactor
+              * (1.0 + rangeFactor + speedFactor + radialSplashFactor + lineSplashFactor + bounceSplashFactor)
           / attacker.maxCooldown;
     }
 
-    int sumDamageTo(Collection<Agent> targets) {
-      int damageSum = 0;
+    double sumDamageTo(Collection<Agent> targets) {
+      double damageSum = 0;
       for (Agent target : targets) {
         if (!target.detected) {
           continue;
@@ -219,27 +208,23 @@ public static class Parameters {
     final double shieldScale;
     final double speedScale;
     final double rangeScale;
-    final double radialSplashFactor;
-    final double lineSplashFactor;
+    final double radialSplashScale;
+    final double lineSplashScale;
     final double bounceSplashFactor;
-    final int heal;
-    final int healthRegen;
-    final int shieldRegen;
+    final double heal;
 
     public Parameters(double[] source) {
       shieldScale = source[0];
       speedScale = source[1];
       rangeScale = source[2];
-      radialSplashFactor = source[3];
-      lineSplashFactor = source[4];
+      radialSplashScale = source[3];
+      lineSplashScale = source[4];
       bounceSplashFactor = source[5];
-      heal = (int) source[6];
-      healthRegen = (int) source[7];
-      shieldRegen = (int) source[8];
+      heal = source[6] * 500000;
     }
 
     public Parameters() {
-      this(new double[] {62.55550402780286, 455.5108652989783, 16.644298951231356, 0.0881036657313995, 534.3720029493211, 2.2237277860926357, 506.53351985609726, 780.675841755981, 778.571115050493});
+      this(new double[]{2.0608350462547205, 8.19938619214691, 0.19223277374228906, 7.706789576045348, 6.154650149331842, 5.884458141154542, 0.8991451082849068});
     }
   }
 }
diff --git a/src/test/java/org/bk/ass/EvaluatorParameterTuner.java b/src/test/java/org/bk/ass/EvaluatorParameterTuner.java
@@ -16,17 +16,18 @@
 import java.util.stream.Collectors;
 
 public class EvaluatorParameterTuner {
+  private static int PARAMS = 7;
 
   public static void main(String[] args) throws Exception {
     BWDataProvider.injectValues();
 
     SplittableRandom prng = new SplittableRandom();
     List<Par> candidates = new ArrayList<>();
-    int[] miss = new int[9];
+    int[] miss = new int[PARAMS];
     for (int i = 0; i < 20; i++) {
-      double[] d = new double[9];
+      double[] d = new double[PARAMS];
       for (int j = 0; j < d.length; j++) {
-        d[j] = prng.nextDouble(0.0001, 1000.0);
+        d[j] = prng.nextDouble(0.00001, 10.0);
       }
       Par e = new Par(d);
       if (e.score == TEST_METHODS.length) {
@@ -36,28 +37,28 @@ public static void main(String[] args) throws Exception {
       candidates.add(e);
     }
     int best = 0;
-    for (int i = 0; i < 5000000; i++) {
+    for (int i = 0; i < 100000; i++) {
       int ci = prng.nextInt(candidates.size() * 12 / 10);
       Par sub;
       if (ci < candidates.size()) {
         Par par = candidates.get(ci);
 
         int index = prng.nextInt(par.d.length);
 
-        sub = IntRange.of(0, 50).stream()
+        sub = IntRange.of(0, 5).stream()
                 .mapToObj(d -> {
                   double[] next = Arrays.copyOf(par.d, par.d.length);
-                  next[index] = prng.nextDouble(0.0001, 1000.0);
+                  next[index] = prng.nextDouble(0.0001, 10.0);
                   return new Par(next);
                 }).max(Comparator.comparingInt(p -> p.score)).get();
         if (sub.score == par.score) {
           miss[index]++;
           continue;
         }
       } else {
-        double[] d = new double[9];
+        double[] d = new double[PARAMS];
         for (int j = 0; j < d.length; j++) {
-          d[j] = prng.nextDouble(0.0001, 1000.0);
+          d[j] = prng.nextDouble(0.0001, 10.0);
         }
         sub = new Par(d);
       }
@@ -90,7 +91,7 @@ public static void main(String[] args) throws Exception {
     System.exit(0);
 
     Genotype<DoubleGene> genotype =
-        Genotype.of(DoubleChromosome.of(0.0001, 20.0, 6), DoubleChromosome.of(300, 1300, 3));
+            Genotype.of(DoubleChromosome.of(0.0001, 3.0, 6), DoubleChromosome.of(1, 1000, 1));
 
     Function<Genotype<DoubleGene>, Integer> eval =
         gt -> {
diff --git a/src/test/java/org/bk/ass/EvaluatorTest.java b/src/test/java/org/bk/ass/EvaluatorTest.java
@@ -11,6 +11,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -79,7 +80,7 @@ void _7MutasVs8Hydras() {
     double result = evaluator.evaluate(agentsA, agentsB);
 
     // THEN
-    assertThat(result).isGreaterThan(0.6);
+    assertThat(result).isBetween(0.4, 0.6);
   }
 
   @Test
@@ -133,7 +134,7 @@ void _7MutasVs14Marines() {
     double result = evaluator.evaluate(a, b);
 
     // THEN
-    assertThat(result).isLessThan(0.45);
+    assertThat(result).isLessThan(0.5);
   }
 
   @Test
@@ -155,7 +156,7 @@ void _2LurkersVs6Marines() {
     double result = evaluator.evaluate(a, b);
 
     // THEN
-    assertThat(result).isGreaterThan(0.7);
+    assertThat(result).isGreaterThan(0.6);
   }
 
   @Test
@@ -205,7 +206,7 @@ void _6MutasVs1Bunker() {
     double result = evaluator.evaluate(a, b);
 
     // THEN
-    assertThat(result).isGreaterThan(0.51);
+    assertThat(result).isGreaterThan(0.5);
   }
 
   @Test
@@ -250,7 +251,7 @@ void GoonVsTank() {
     double result = evaluator.evaluate(a, b);
 
     // THEN
-    assertThat(result).isGreaterThan(0.51);
+    assertThat(result).isGreaterThan(0.5);
   }
 
   @Test
@@ -306,7 +307,7 @@ void reaverVs12Lings() {
     double result = evaluator.evaluate(a, b);
 
     // THEN
-    assertThat(result).isBetween(0.2, 0.4);
+    assertThat(result).isBetween(0.2, 0.45);
   }
 
   @Test
@@ -321,6 +322,23 @@ void reaverVs9Lings() {
     double result = evaluator.evaluate(a, b);
 
     // THEN
-    assertThat(result).isBetween(0.6, 0.8);
+    assertThat(result).isBetween(0.5, 0.8);
+  }
+
+  @Test
+  void MvsMM() {
+    // GIVEN
+    List<Agent> a = IntRange.of(0, 4).stream().mapToObj(unused -> factory.of(UnitType.Terran_Marine)).collect(Collectors.toList());
+    List<Agent> b = Stream.concat(
+            IntRange.of(0, 3).stream().mapToObj(unused -> factory.of(UnitType.Terran_Marine)),
+            IntRange.of(0, 1).stream().mapToObj(unused -> factory.of(UnitType.Terran_Medic)))
+            .collect(Collectors.toList());
+
+
+    // WHEN
+    double result = evaluator.evaluate(a, b);
+
+    // THEN
+    assertThat(result).isLessThan(0.3);
   }
 }
diff --git a/src/test/java/org/bk/ass/SimulatorTest.java b/src/test/java/org/bk/ass/SimulatorTest.java
@@ -39,6 +39,26 @@ void stimmedVsUnstimmed() {
     assertThat(simulator.getAgentsB()).isNotEmpty();
   }
 
+  @Test
+  void mmVsM() {
+    // GIVEN
+    simulator.addAgentA(factory.of(UnitType.Terran_Marine));
+    simulator.addAgentA(factory.of(UnitType.Terran_Marine));
+    simulator.addAgentA(factory.of(UnitType.Terran_Marine));
+    simulator.addAgentA(factory.of(UnitType.Terran_Marine));
+    simulator.addAgentB(factory.of(UnitType.Terran_Marine));
+    simulator.addAgentB(factory.of(UnitType.Terran_Marine));
+    simulator.addAgentB(factory.of(UnitType.Terran_Medic));
+    simulator.addAgentB(factory.of(UnitType.Terran_Medic));
+
+    // WHEN
+    simulator.simulate(-1);
+
+    // THEN
+    assertThat(simulator.getAgentsA()).isEmpty();
+    assertThat(simulator.getAgentsB()).isNotEmpty();
+  }
+
   @Test
   void MMVsSunkens() {
     // GIVEN
