Added frame skipping to simulator

Author: Bytekeeper

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

@@ -20,24 +20,26 @@ private AgentUtil() {
     // Utility class
   }
 
-  public static void moveToward(Agent agent, Agent target, float distance) {
-    if (distance <= agent.speed) {
+  public static void moveToward(int frames, Agent agent, Agent target, float distance) {
+    float travelled = frames * agent.speed;
+    if (distance <= travelled) {
       agent.vx = target.x - agent.x;
       agent.vy = target.y - agent.y;
     } else {
-      agent.vx = (int) ((target.x - agent.x) * agent.speed / distance);
-      agent.vy = (int) ((target.y - agent.y) * agent.speed / distance);
+      agent.vx = (int) ((target.x - agent.x) * travelled / distance);
+      agent.vy = (int) ((target.y - agent.y) * travelled / distance);
     }
   }
 
-  public static void moveAwayFrom(Agent agent, Agent target, float distance) {
+  public static void moveAwayFrom(int frames, Agent agent, Agent target, float distance) {
+    float travelled = frames * agent.speed;
     if (distance == 0) {
       double a = rnd.nextDouble(Math.PI * 2);
-      agent.vx = (int) (cos(a) * agent.speed);
-      agent.vy = (int) (sin(a) * agent.speed);
+      agent.vx = (int) (cos(a) * travelled);
+      agent.vy = (int) (sin(a) * travelled);
     } else {
-      agent.vx = (int) ((agent.x - target.x) * agent.speed / distance);
-      agent.vy = (int) ((agent.y - target.y) * agent.speed / distance);
+      agent.vx = (int) ((agent.x - target.x) * travelled / distance);
+      agent.vy = (int) ((agent.y - target.y) * travelled / distance);
     }
   }
 

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

@@ -11,7 +11,7 @@ public class AttackerBehavior implements Behavior {
 
   @Override
   public boolean simUnit(
-      Agent agent, UnorderedCollection<Agent> allies, UnorderedCollection<Agent> enemies) {
+          int frameSkip, Agent agent, UnorderedCollection<Agent> allies, UnorderedCollection<Agent> enemies) {
     if (agent.cooldown > agent.maxCooldown - agent.stopFrames) {
       return true;
     }
@@ -61,18 +61,18 @@ public boolean simUnit(
     agent.attackTarget = selectedEnemy;
 
     if (selectedEnemy == null) {
-      return !agent.burrowed && simFlee(agent, enemies);
+      return !agent.burrowed && simFlee(frameSkip, agent, enemies);
     }
 
     if (!agent.burrowed) {
-      simCombatMove(agent, selectedEnemy, selectedDistanceSquared, selectedWeapon);
+      simCombatMove(frameSkip, agent, selectedEnemy, selectedDistanceSquared, selectedWeapon);
     }
 
     if (agent.burrowedAttacker != agent.burrowed) {
       return false;
     }
 
-    if (agent.cooldown == 0
+    if (agent.cooldown <= 0
         && selectedDistanceSquared
             <= Math.max(Simulator.MIN_SIMULATION_RANGE, selectedWeapon.maxRangeSquared)) {
       simAttack(agent, allies, enemies, selectedEnemy, selectedWeapon);
@@ -88,7 +88,7 @@ private void simAttack(
       Agent selectedEnemy,
       Weapon selectedWeapon) {
     if (agent.canStim
-        && agent.remainingStimFrames == 0
+        && agent.remainingStimFrames <= 0
         && agent.healthShifted >= agent.maxHealthShifted / 2) {
       AgentUtil.stim(agent);
     }
@@ -116,7 +116,7 @@ private void simAttack(
   }
 
   private void simCombatMove(
-      Agent agent, Agent selectedEnemy, int selectedDistanceSquared, Weapon selectedWeapon) {
+          int frameSkip, Agent agent, Agent selectedEnemy, int selectedDistanceSquared, Weapon selectedWeapon) {
     boolean shouldKite =
         agent.isKiter
             && agent.cooldown > 0
@@ -125,10 +125,10 @@ private void simCombatMove(
     float distance = (float) sqrt(selectedDistanceSquared);
     if (shouldKite) {
       if (distance + agent.speed < selectedWeapon.maxRange) {
-        moveAwayFrom(agent, selectedEnemy, distance);
+        moveAwayFrom(frameSkip, agent, selectedEnemy, distance);
       }
     } else {
-      moveToward(agent, selectedEnemy, distance);
+      moveToward(frameSkip, agent, selectedEnemy, distance);
     }
   }
 }

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

@@ -3,6 +3,7 @@
 import org.bk.ass.collection.UnorderedCollection;
 import org.bk.ass.sim.Simulator.Behavior;
 
+import static java.lang.Math.min;
 import static org.bk.ass.sim.AgentUtil.distanceSquared;
 import static org.bk.ass.sim.AgentUtil.moveToward;
 
@@ -13,7 +14,7 @@ public class HealerBehavior implements Behavior {
 
   @Override
   public boolean simUnit(
-      Agent agent, UnorderedCollection<Agent> allies, UnorderedCollection<Agent> enemies) {
+          int frameSkip, Agent agent, UnorderedCollection<Agent> allies, UnorderedCollection<Agent> enemies) {
     if (agent.energyShifted < 256) {
       return true;
     }
@@ -58,16 +59,13 @@ public boolean simUnit(
       return false;
     }
 
-    moveToward(agent, selectedAlly, (float) Math.sqrt(selectedDistanceSquared));
+    moveToward(frameSkip, agent, selectedAlly, (float) Math.sqrt(selectedDistanceSquared));
     if (selectedDistanceSquared > MEDICS_HEAL_RANGE_SQUARED) {
       return true;
     }
-    agent.energyShifted -= 256;
+    agent.energyShifted -= 256 * frameSkip;
     selectedAlly.healedThisFrame = true;
-    selectedAlly.healthShifted += 150;
-    if (selectedAlly.healthShifted > selectedAlly.maxHealthShifted) {
-      selectedAlly.healthShifted = selectedAlly.maxHealthShifted;
-    }
+    selectedAlly.healthShifted = min(selectedAlly.maxHealthShifted, selectedAlly.healthShifted + 150 * frameSkip);
 
     return true;
   }

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

@@ -3,6 +3,7 @@
 import org.bk.ass.collection.UnorderedCollection;
 import org.bk.ass.sim.Simulator.Behavior;
 
+import static java.lang.Math.min;
 import static java.lang.Math.sqrt;
 import static org.bk.ass.sim.AgentUtil.distanceSquared;
 import static org.bk.ass.sim.AgentUtil.moveToward;
@@ -14,7 +15,7 @@ public class RepairerBehavior implements Behavior {
 
   @Override
   public boolean simUnit(
-      Agent agent, UnorderedCollection<Agent> allies, UnorderedCollection<Agent> enemies) {
+          int frameSkip, Agent agent, UnorderedCollection<Agent> allies, UnorderedCollection<Agent> enemies) {
     Agent selectedAlly = null;
     int selectedDistanceSquared = Integer.MAX_VALUE;
 
@@ -53,14 +54,11 @@ public boolean simUnit(
       return false;
     }
 
-    moveToward(agent, selectedAlly, (float) sqrt(selectedDistanceSquared));
+    moveToward(frameSkip, agent, selectedAlly, (float) sqrt(selectedDistanceSquared));
     if (selectedDistanceSquared > SCV_REPAIR_RANGE_SQUARED) {
       return true;
     }
-    selectedAlly.healthShifted += selectedAlly.hpConstructionRate;
-    if (selectedAlly.healthShifted > selectedAlly.maxHealthShifted) {
-      selectedAlly.healthShifted = selectedAlly.maxHealthShifted;
-    }
+    selectedAlly.healthShifted = min(selectedAlly.maxHealthShifted, selectedAlly.healthShifted + selectedAlly.hpConstructionRate * frameSkip);
 
     return true;
   }

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

@@ -11,11 +11,11 @@ public class RetreatBehavior implements Behavior {
 
   @Override
   public boolean simUnit(
-      Agent agent, UnorderedCollection<Agent> allies, UnorderedCollection<Agent> enemies) {
-    return simFlee(agent, enemies);
+          int frameSkip, Agent agent, UnorderedCollection<Agent> allies, UnorderedCollection<Agent> enemies) {
+    return simFlee(frameSkip, agent, enemies);
   }
 
-  static boolean simFlee(Agent agent, UnorderedCollection<Agent> enemies) {
+  static boolean simFlee(int frames, Agent agent, UnorderedCollection<Agent> enemies) {
     if (agent.burrowed || agent.isStasised || agent.isLockeddown) return false;
     Agent selectedEnemy = null;
     int selectedDistanceSquared = Integer.MAX_VALUE;
@@ -38,7 +38,7 @@ static boolean simFlee(Agent agent, UnorderedCollection<Agent> enemies) {
     if (selectedEnemy == null) {
       return false;
     }
-    moveAwayFrom(agent, selectedEnemy, (float) sqrt(selectedDistanceSquared));
+    moveAwayFrom(frames, agent, selectedEnemy, (float) sqrt(selectedDistanceSquared));
     return true;
   }
 }

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

@@ -5,8 +5,11 @@
 
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Objects;
 import java.util.function.ToIntFunction;
 
+import static java.lang.Math.min;
+
 /**
  * Used to simulate 2 groups of agents engaging each other. Either use the default constructor which
  * initialized the default behavior or customize the behaviors. Ie. if you want to simulate one
@@ -23,16 +26,12 @@
  * Be cautious when modifying {@link Agent}s after they have been added to the simulation.
  */
 public class Simulator {
-  /**
-   * Use to count health and shields as equal, maybe useful in PvP?
-   */
+  /** Use to count health and shields as equal, maybe useful in PvP? */
   public static final ToIntFunction<Agent> HEALTH_AND_SHIELD =
-          agent -> agent.getHealth() + agent.getShields();
-  /**
-   * Use to count shields as half the value of health.
-   */
+      agent -> agent.getHealth() + agent.getShields();
+  /** Use to count shields as half the value of health. */
   public static final ToIntFunction<Agent> HEALTH_AND_HALFED_SHIELD =
-          agent -> agent.getHealth() + agent.getShields() / 2;
+      agent -> agent.getHealth() + agent.getShields() / 2;
 
   private static final int MAX_MAP_DIMENSION = 8192;
   private static final int TILE_SIZE = 16;
@@ -46,14 +45,28 @@ public class Simulator {
   final byte[] collision = new byte[COLLISION_MAP_DIMENSION * COLLISION_MAP_DIMENSION];
   private final Behavior playerABehavior;
   private final Behavior playerBBehavior;
+  private final int frameSkip;
 
   public Simulator() {
-    this(new RoleBasedBehavior(), new RoleBasedBehavior());
+    this(1);
   }
 
   public Simulator(Behavior playerABehavior, Behavior playerBBehavior) {
+    this(1, playerABehavior, playerBBehavior);
+  }
+
+  public Simulator(int frameSkip) {
+    this(frameSkip, new RoleBasedBehavior(), new RoleBasedBehavior());
+  }
+
+  public Simulator(int frameSkip, Behavior playerABehavior, Behavior playerBBehavior) {
+    if (frameSkip < 1) throw new IllegalArgumentException("frameSkip must be >= 1");
+    Objects.requireNonNull(playerABehavior, "Behavior of player A must be set");
+    Objects.requireNonNull(playerBBehavior, "Behavior of player B must be set");
+
     this.playerABehavior = playerABehavior;
     this.playerBBehavior = playerBBehavior;
+    this.frameSkip = frameSkip;
   }
 
   public Simulator addAgentA(Agent agent) {
@@ -127,7 +140,9 @@ public int simulate() {
    * @return the actual number of frames simulated, usually the given number of frames
    */
   public int simulate(int frames) {
-    while (frames-- != 0 && !playerA.isEmpty() && !playerB.isEmpty()) {
+    if (frames > 0) frames = (frames + frameSkip - 1) / frameSkip;
+    while (frames != 0 && !playerA.isEmpty() && !playerB.isEmpty()) {
+      frames -= frameSkip;
       if (!step()) {
         break;
       }
@@ -166,14 +181,14 @@ private boolean step() {
       simRunning |=
           agent.isLockeddown
               || agent.isStasised
-              || playerABehavior.simUnit(agent, playerA, playerB);
+              || playerABehavior.simUnit(frameSkip, agent, playerA, playerB);
     }
     for (int i = playerB.size() - 1; i >= 0; i--) {
       Agent agent = playerB.get(i);
       simRunning |=
           agent.isLockeddown
               || agent.isStasised
-              || playerBBehavior.simUnit(agent, playerB, playerA);
+              || playerBBehavior.simUnit(frameSkip, agent, playerB, playerA);
     }
     removeDead(playerA);
     removeDead(playerB);
@@ -206,31 +221,14 @@ private void updateStats(UnorderedCollection<Agent> agents) {
       agent.vy = 0;
       agent.healedThisFrame = false;
 
-      if (agent.cooldown > 0) {
-        agent.cooldown--;
-      }
-      if (agent.shieldsShifted < agent.maxShieldsShifted) {
-        agent.shieldsShifted += 7;
-        if (agent.shieldsShifted > agent.maxShieldsShifted) {
-          agent.shieldsShifted = agent.maxShieldsShifted;
-        }
-      }
-      if (agent.plagueDamagePerFrameShifted < agent.healthShifted) {
-        agent.healthShifted -= agent.plagueDamagePerFrameShifted;
-      }
-      if (agent.remainingStimFrames > 0) {
-        agent.remainingStimFrames--;
-      }
-      if (agent.regeneratesHealth && agent.healthShifted < agent.maxHealthShifted) {
-        agent.healthShifted += 4;
-        if (agent.healthShifted > agent.maxHealthShifted) {
-          agent.healthShifted = agent.maxHealthShifted;
-        }
-      }
-      agent.energyShifted += 8;
-      if (agent.energyShifted > agent.maxEnergyShifted) {
-        agent.energyShifted = agent.maxEnergyShifted;
-      }
+      agent.cooldown = agent.cooldown - frameSkip;
+      agent.shieldsShifted = min(agent.maxShieldsShifted, agent.shieldsShifted + 7 * frameSkip);
+      if (agent.plagueDamagePerFrameShifted * frameSkip < agent.healthShifted)
+        agent.healthShifted -= agent.plagueDamagePerFrameShifted * frameSkip;
+      agent.remainingStimFrames = agent.remainingStimFrames - frameSkip;
+      if (agent.regeneratesHealth)
+        agent.healthShifted = min(agent.maxHealthShifted, agent.healthShifted + 4 * frameSkip);
+      agent.energyShifted = min(agent.energyShifted + 8 * frameSkip, agent.maxEnergyShifted);
     }
   }
 
@@ -290,18 +288,21 @@ public RoleBasedBehavior() {
 
     @Override
     public boolean simUnit(
-        Agent agent, UnorderedCollection<Agent> allies, UnorderedCollection<Agent> enemies) {
+        int frameSkip,
+        Agent agent,
+        UnorderedCollection<Agent> allies,
+        UnorderedCollection<Agent> enemies) {
       if (agent.isSuicider) {
-        return suiciderSimulator.simUnit(agent, allies, enemies);
+        return suiciderSimulator.simUnit(frameSkip, agent, allies, enemies);
       }
       if (agent.isHealer) {
-        return healerSimulator.simUnit(agent, allies, enemies);
+        return healerSimulator.simUnit(frameSkip, agent, allies, enemies);
       }
-      if (agent.isRepairer && repairerSimulator.simUnit(agent, allies, enemies)) {
+      if (agent.isRepairer && repairerSimulator.simUnit(frameSkip, agent, allies, enemies)) {
         return true;
         // Otherwise FIGHT, you puny SCV!
       }
-      return attackerSimulator.simUnit(agent, allies, enemies);
+      return attackerSimulator.simUnit(frameSkip, agent, allies, enemies);
     }
   }
 
@@ -312,7 +313,10 @@ public boolean simUnit(
   public interface Behavior {
 
     boolean simUnit(
-        Agent agent, UnorderedCollection<Agent> allies, UnorderedCollection<Agent> enemies);
+        int frameSkip,
+        Agent agent,
+        UnorderedCollection<Agent> allies,
+        UnorderedCollection<Agent> enemies);
   }
 
   public static class IntEvaluation {
@@ -333,7 +337,6 @@ public int delta() {
       return evalA - evalB;
     }
 
-
     public int dot(IntEvaluation other) {
       return evalA * other.evalA - evalB * other.evalB;
     }

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

@@ -3,14 +3,13 @@
 import org.bk.ass.collection.UnorderedCollection;
 import org.bk.ass.sim.Simulator.Behavior;
 
-import static org.bk.ass.sim.AgentUtil.dealDamage;
-import static org.bk.ass.sim.AgentUtil.distanceSquared;
+import static org.bk.ass.sim.AgentUtil.*;
 
 public class SuiciderBehavior implements Behavior {
 
   @Override
   public boolean simUnit(
-      Agent agent, UnorderedCollection<Agent> allies, UnorderedCollection<Agent> enemies) {
+          int frameSkip, Agent agent, UnorderedCollection<Agent> allies, UnorderedCollection<Agent> enemies) {
     // Don't check for lockdown - I believe there are no suiciders which can be locked down
     if (agent.isStasised) return false;
     Agent selectedEnemy = null;
@@ -36,6 +35,8 @@ public boolean simUnit(
       return false;
     }
 
+    moveToward(frameSkip, agent, selectedEnemy, (float) Math.sqrt(selectedDistanceSquared));
+
     if (selectedDistanceSquared <= agent.speedSquared) {
       dealDamage(agent, agent.weaponVs(selectedEnemy), selectedEnemy);
       agent.healthShifted = 0;