v good

src/game-loop/agent-population.ts

@@ -18,7 +18,6 @@ const ADAPTIVE_CAP_DECREASE_AGENTS_PER_SECOND =
 
 export class AgentPopulation {
   private activeCount = 0;
-  private targetBudget = appConfig.simulation.budget.initialTargetAgentBudget;
   private replacementCursor = 0;
   private canExpandAdaptiveCap = true;
   private shouldCompactAfterErase = false;
@@ -33,24 +32,16 @@ export class AgentPopulation {
     return this.activeCount;
   }
 
-  public get targetAgentBudget(): number {
-    return this.targetBudget;
-  }
-
   public get maxAgentCount(): number {
     return this.pipeline.maxAgentCount;
   }
 
   public initializeIntroAgents(canvasSize: vec2): void {
     settings.agentBudgetMax = this.clampAdaptiveCap(settings.agentBudgetMax);
-    this.targetBudget = Math.min(
-      this.pipeline.maxAgentCount,
-      settings.agentBudgetMax,
-      INITIAL_AGENT_COUNT
-    );
+    const introAgentCount = Math.min(settings.agentBudgetMax, INITIAL_AGENT_COUNT);
     this.writeAgentBatch(
       createIntroTitleAgents({
-        count: this.targetBudget,
+        count: introAgentCount,
         width: canvasSize[0],
         height: canvasSize[1],
       })
@@ -59,11 +50,7 @@ export class AgentPopulation {
 
   public onVibeChanged(): void {
     settings.agentBudgetMax = this.clampAdaptiveCap(settings.agentBudgetMax);
-    this.targetBudget = Math.min(
-      this.targetBudget,
-      settings.agentBudgetMax,
-      this.pipeline.maxAgentCount
-    );
+    this.trimActiveCountToBudget();
   }
 
   public growBudget(
@@ -72,18 +59,6 @@ export class AgentPopulation {
     refreshTargetFps: number
   ): void {
     this.updateAdaptiveCap(deltaTime, smoothedFps, refreshTargetFps);
-
-    const cap = this.clampAdaptiveCap(settings.agentBudgetMax);
-    if (
-      this.targetBudget < cap &&
-      smoothedFps > refreshTargetFps * appConfig.simulation.budget.fpsHeadroom
-    ) {
-      this.targetBudget = Math.min(
-        cap,
-        this.targetBudget +
-          Math.ceil(appConfig.simulation.budget.rampAgentsPerSecond * deltaTime)
-      );
-    }
   }
 
   public resizeAgents(scale: vec2): void {
@@ -110,7 +85,6 @@ export class AgentPopulation {
       this.activeCount = compactedAgentCount;
       this.replacementCursor =
         compactedAgentCount === 0 ? 0 : this.replacementCursor % compactedAgentCount;
-      this.targetBudget = Math.max(this.targetBudget, compactedAgentCount);
     } finally {
       this.isCompacting = false;
     }
@@ -157,7 +131,7 @@ export class AgentPopulation {
     const count = data.length / AGENT_FLOAT_COUNT;
     this.expandAdaptiveCapForPendingAgents(count);
 
-    const available = Math.max(0, this.targetBudget - this.activeCount);
+    const available = Math.max(0, settings.agentBudgetMax - this.activeCount);
     const appendCount = Math.min(count, available);
 
     if (appendCount > 0) {
@@ -196,10 +170,12 @@ export class AgentPopulation {
   ): void {
     const previousCap = this.clampAdaptiveCap(settings.agentBudgetMax);
     this.canExpandAdaptiveCap =
+      refreshTargetFps <= 0 ||
       smoothedFps >= refreshTargetFps * appConfig.simulation.budget.fpsHeadroom;
 
     if (this.canExpandAdaptiveCap) {
       settings.agentBudgetMax = previousCap;
+      this.trimActiveCountToBudget();
       return;
     }
 
@@ -209,33 +185,31 @@ export class AgentPopulation {
     );
     const nextCap = this.clampAdaptiveCap(previousCap - decrease);
     settings.agentBudgetMax = nextCap;
-    this.targetBudget = Math.min(this.targetBudget, nextCap);
-
-    if (this.activeCount > this.targetBudget) {
-      this.activeCount = Math.max(this.targetBudget, this.activeCount - decrease);
-      this.replacementCursor =
-        this.activeCount === 0 ? 0 : this.replacementCursor % this.activeCount;
-    }
+    this.trimActiveCountToBudget(decrease);
   }
 
   private expandAdaptiveCapForPendingAgents(requestedAgentCount: number): void {
-    const available = Math.max(0, this.targetBudget - this.activeCount);
+    const available = Math.max(0, settings.agentBudgetMax - this.activeCount);
     if (requestedAgentCount <= available || !this.canExpandAdaptiveCap) {
       return;
     }
 
     const currentCap = this.clampAdaptiveCap(settings.agentBudgetMax);
-    if (this.targetBudget < currentCap) {
+    const pendingAgentCount = requestedAgentCount - available;
+    settings.agentBudgetMax = this.clampAdaptiveCap(currentCap + pendingAgentCount);
+  }
+
+  private trimActiveCountToBudget(maxDecrease = Number.POSITIVE_INFINITY): void {
+    if (this.activeCount <= settings.agentBudgetMax) {
       return;
     }
 
-    const pendingAgentCount = requestedAgentCount - available;
-    const nextCap = this.clampAdaptiveCap(currentCap + pendingAgentCount);
-    settings.agentBudgetMax = nextCap;
-    this.targetBudget = Math.max(
-      this.targetBudget,
-      Math.min(nextCap, this.activeCount + requestedAgentCount)
+    this.activeCount = Math.max(
+      settings.agentBudgetMax,
+      this.activeCount - Math.max(1, Math.ceil(maxDecrease))
     );
+    this.replacementCursor =
+      this.activeCount === 0 ? 0 : this.replacementCursor % this.activeCount;
   }
 
   private clampAdaptiveCap(value: number): number {