Merge pull request #1 from JavaBWAPI/approx_sim

Added approx attacking behavior. No movement or range checks. Added A…

Author: Bytekeeper

src/jmh/java/org/bk/ass/SimulatorBenchmark.java

@@ -1,5 +1,7 @@
 package org.bk.ass;
 
+import org.bk.ass.sim.AgentUtil;
+import org.bk.ass.sim.ApproxAttackBehavior;
 import org.bk.ass.sim.BWAPI4JAgentFactory;
 import org.bk.ass.sim.Simulator;
 import org.bk.ass.sim.Simulator.Builder;
@@ -16,21 +18,28 @@ public static class MyState {
 
     Simulator simulator;
     Simulator simulatorFS4;
+    Simulator approxSim;
     BWAPI4JAgentFactory factory = new BWAPI4JAgentFactory(null);
 
     @Setup(Level.Invocation)
     public void setup() {
       simulator = new Builder().build();
       simulatorFS4 = new Builder().withFrameSkip(4).build();
+      approxSim = new Builder().withFrameSkip(37).withPlayerABehavior(new ApproxAttackBehavior()).withPlayerABehavior(new ApproxAttackBehavior()).build();
 
       for (int i = 0; i < 30; i++) {
         simulator.addAgentA(factory.of(UnitType.Zerg_Mutalisk));
         simulatorFS4.addAgentA(factory.of(UnitType.Zerg_Mutalisk));
+        approxSim.addAgentA(factory.of(UnitType.Zerg_Mutalisk));
       }
       for (int i = 0; i < 30; i++) {
         simulator.addAgentB(factory.of(UnitType.Zerg_Hydralisk));
         simulatorFS4.addAgentB(factory.of(UnitType.Zerg_Hydralisk));
+        approxSim.addAgentB(factory.of(UnitType.Zerg_Hydralisk));
       }
+
+      AgentUtil.randomizePositions(approxSim.getAgentsA(), 0, 0, 32, 32);
+      AgentUtil.randomizePositions(approxSim.getAgentsB(), 32, 0, 64, 64);
     }
   }
 
@@ -52,6 +61,11 @@ public int _30MutasVs30Hydras_fs4(MyState state) {
     return state.simulatorFS4.simulate(-1);
   }
 
+  @Benchmark
+  public int _30MutasVs30Hydras_approx(MyState state) {
+    return state.approxSim.simulate(-1);
+  }
+
   @Benchmark
   public int clearCollisionMaps(MyState state) {
     state.simulator.reset();

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

@@ -1,7 +1,6 @@
 package org.bk.ass.sim;
 
-import org.bk.ass.collection.UnorderedCollection;
-
+import java.util.Collection;
 import java.util.SplittableRandom;
 
 import static java.lang.Math.*;
@@ -45,99 +44,6 @@ public static int distanceSquared(Agent a, Agent b) {
     return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
   }
 
-  /** Deal splash damage to enemies and allies */
-  public static void dealRadialSplashDamage(
-      Weapon weapon,
-      Agent mainTarget,
-      UnorderedCollection<Agent> allies,
-      UnorderedCollection<Agent> enemies) {
-    for (int i = allies.size() - 1; i >= 0; i--) {
-      Agent ally = allies.get(i);
-      applySplashDamage(weapon, mainTarget, ally);
-    }
-    for (int i = enemies.size() - 1; i >= 0; i--) {
-      Agent enemy = enemies.get(i);
-      applySplashDamage(weapon, mainTarget, enemy);
-    }
-  }
-
-  private static void applySplashDamage(Weapon weapon, Agent mainTarget, Agent splashTarget) {
-    if (splashTarget == mainTarget || splashTarget.isFlyer != mainTarget.isFlyer) {
-      return;
-    }
-
-    int distanceSquared = distanceSquared(splashTarget, mainTarget);
-    if (distanceSquared <= weapon.innerSplashRadiusSquared) {
-      applyDamage(splashTarget, weapon.damageType, weapon.damageShifted, weapon.hits);
-    } else if (!splashTarget.burrowed) {
-      if (distanceSquared <= weapon.medianSplashRadiusSquared) {
-        applyDamage(splashTarget, weapon.damageType, weapon.damageShifted / 2, weapon.hits);
-      } else if (distanceSquared <= weapon.outerSplashRadiusSquared) {
-        applyDamage(splashTarget, weapon.damageType, weapon.damageShifted / 4, weapon.hits);
-      }
-    }
-  }
-
-  /** Deal splash damage to enemies only */
-  public static void dealRadialSplashDamage(
-      Weapon weapon, Agent mainTarget, UnorderedCollection<Agent> enemies) {
-    for (int i = enemies.size() - 1; i >= 0; i--) {
-      Agent enemy = enemies.get(i);
-      applySplashDamage(weapon, mainTarget, enemy);
-    }
-  }
-
-  public static void dealLineSplashDamage(
-      Agent source, Weapon weapon, Agent mainTarget, UnorderedCollection<Agent> enemies) {
-    int dx = mainTarget.x - source.x;
-    int dy = mainTarget.y - source.y;
-    // Same spot, chose "random" direction
-    if (dx == 0 && dy == 0) {
-      dx = 1;
-    }
-    int dxDistSq = dx * dx + dy * dy;
-    int rangeWithSplashSquared =
-        weapon.maxRangeSquared
-            + 2 * weapon.maxRange * weapon.innerSplashRadius
-            + weapon.innerSplashRadiusSquared;
-    for (int i = enemies.size() - 1; i >= 0; i--) {
-      Agent enemy = enemies.get(i);
-      if (enemy == mainTarget || enemy.isFlyer != mainTarget.isFlyer) {
-        continue;
-      }
-      int enemyDistSq = distanceSquared(enemy, source);
-      if (enemyDistSq <= rangeWithSplashSquared) {
-        int dot = (enemy.x - source.x) * dx + (enemy.y - source.y) * dy;
-        if (dot >= 0) {
-          int projdx = source.x + dot * dx / dxDistSq - enemy.x;
-          int projdy = source.y + dot * dy / dxDistSq - enemy.y;
-          int projDistSq = projdx * projdx + projdy * projdy;
-          if (projDistSq <= weapon.innerSplashRadiusSquared) {
-            applyDamage(enemy, weapon.damageType, weapon.damageShifted, weapon.hits);
-          }
-        }
-      }
-    }
-  }
-
-  public static void dealBounceDamage(
-      Weapon weapon, Agent lastTarget, UnorderedCollection<Agent> enemies) {
-    int remainingBounces = 2;
-    int damage = weapon.damageShifted / 3;
-    for (int i = enemies.size() - 1; i >= 0 && remainingBounces > 0; i--) {
-      Agent enemy = enemies.get(i);
-      if (enemy != lastTarget
-              && enemy.healthShifted > 0
-              && abs(enemy.x - lastTarget.x) <= 96
-              && abs(enemy.y - lastTarget.y) <= 96) {
-        lastTarget = enemy;
-        applyDamage(enemy, weapon.damageType, damage, weapon.hits);
-        damage /= 3;
-        remainingBounces--;
-      }
-    }
-  }
-
   public static void dealDamage(Agent agent, Weapon wpn, Agent target) {
     int remainingDamage = wpn.damageShifted;
 
@@ -156,7 +62,7 @@ public static void dealDamage(Agent agent, Weapon wpn, Agent target) {
     applyDamage(target, wpn.damageType, remainingDamage, wpn.hits);
   }
 
-  private static void applyDamage(Agent target, DamageType damageType, int damage, int hits) {
+  public static void applyDamage(Agent target, DamageType damageType, int damage, int hits) {
     int shields = min(target.maxShieldsShifted, target.shieldsShifted) - damage + target.shieldUpgrades;
     if (shields > 0) {
       target.shieldsShifted = shields;
@@ -194,27 +100,18 @@ public static int reduceDamageByTargetSizeAndDamageType(
     return damageShifted;
   }
 
-  public static void attack(Agent agent, Weapon selectedWeapon, Agent selectedEnemy, UnorderedCollection<Agent> allies, UnorderedCollection<Agent> enemies) {
-    dealDamage(agent, selectedWeapon, selectedEnemy);
-    switch (selectedWeapon.splashType) {
-      case BOUNCE:
-        dealBounceDamage(selectedWeapon, selectedEnemy, enemies);
-        break;
-      case RADIAL_SPLASH:
-        dealRadialSplashDamage(selectedWeapon, selectedEnemy, allies, enemies);
-        break;
-      case RADIAL_ENEMY_SPLASH:
-        dealRadialSplashDamage(selectedWeapon, selectedEnemy, enemies);
-        break;
-      case LINE_SPLASH:
-        dealLineSplashDamage(agent, selectedWeapon, selectedEnemy, enemies);
-        break;
-      default:
-        // No splash
-    }
-    agent.cooldown = agent.maxCooldown;
-    if (agent.remainingStimFrames > 0) {
-      agent.cooldown /= 2;
+  /**
+   * Sets random positions for the given agents within the given rectangle.
+   * The positions are <em>stable</em>: Calling this with the same arguments twice will not change any position
+   * on the second invocation. More precisely, any {@link Agent} with position i in the collection will always
+   * get the same position. Be sure to use different rectangles for different {@link Agent} collections, to
+   * prevent them from getting assigned the same positions.
+   */
+  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);
     }
   }
 }

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

@@ -0,0 +1,56 @@
+package org.bk.ass.sim;
+
+import org.bk.ass.collection.UnorderedCollection;
+import org.bk.ass.sim.Simulator.Behavior;
+
+import static org.bk.ass.sim.AttackerBehavior.*;
+
+public class ApproxAttackBehavior implements Behavior {
+    @Override
+    public boolean simUnit(int frameSkip, Agent agent, UnorderedCollection<Agent> allies, UnorderedCollection<Agent> enemies) {
+        int i = enemies.size() - 1;
+        while (agent.cooldown <= 0 && i >= 0) {
+            Agent enemy = enemies.get(i);
+            Weapon wpn = agent.weaponVs(enemy);
+            if (enemy.healthShifted > 0
+                    && wpn.damageShifted != 0
+                    && enemy.detected
+                    && !enemy.isStasised) {
+                if (agent.canStim
+                        && agent.remainingStimFrames <= 0
+                        && agent.healthShifted >= agent.maxHealthShifted / 2) {
+                    agent.stim();
+                }
+                attack(agent, wpn, enemy, allies, enemies);
+            } else
+                i--;
+        }
+
+        return agent.cooldown > 0;
+    }
+
+    public static void attack(Agent agent, Weapon weapon, Agent enemy, UnorderedCollection<Agent> allies, UnorderedCollection<Agent> enemies) {
+        AgentUtil.dealDamage(agent, weapon, enemy);
+        switch (weapon.splashType) {
+            case BOUNCE:
+                dealBounceDamage(weapon, enemy, enemies);
+                break;
+            case RADIAL_SPLASH:
+                dealRadialSplashDamage(weapon, enemy, allies, enemies);
+                break;
+            case RADIAL_ENEMY_SPLASH:
+                dealRadialSplashDamage(weapon, enemy, enemies);
+                break;
+            case LINE_SPLASH:
+                dealLineSplashDamage(agent, weapon, enemy, enemies);
+                break;
+            default:
+                // No splash
+        }
+
+        if (agent.remainingStimFrames <= 0)
+            agent.cooldown += agent.maxCooldown;
+        else
+            agent.cooldown += agent.maxCooldown / 2;
+    }
+}