Three enemies out of the boss fights, and late sectors that keep growing

The roster was `min(2 + sector, 5)`: everything unlocked by sector 3, so
sectors 4 and 5 introduced nothing at all and the last third of a run was the
first third with bigger numbers. It grows the whole way now, one new kind a
sector, and each of the three additions takes a mechanic off a boss and bolts
it to something mortal -- a boss teaches an attack once, then the attack comes
back on a ship you can shoot down.

  LANCER   sector 3    LANCE's beam. Aims, charges for 0.85s, fires. The beam
                       locks where it aimed, and killing the lancer mid-charge
                       takes the beam with it: a target priority rather than a
                       weather condition.
  SPINNER  sector 5    SENTINEL's rings. The only thing in the roster that does
                       not care where you are, which is what makes it awkward
                       beside everything that does.
  PHANTOM  the Void    Dashes backwards and sideways. The trigger is you lining
                       up underneath, so parking below one and holding the
                       trigger -- what a maxed rate of fire teaches you to do by
                       then -- is exactly what fails.

Density: the budget slope goes from +10 to +13 a sector and its cap from 104 to
150, but the real brake was elsewhere -- a flat ceiling of 14 enemies in the air
at once, unchanged since sector 1. It now rises with the sector, to 20.

The test pilot sees lancer beams. Without that it would have rated the enemy by
how invisible it is to a heuristic rather than by how dangerous it is, which is
the exact mistake the old repulsion-field pilot made and the reason it had to be
rewritten.

Worst frame measured: 1.76 ms p99 against 16.7, with 305 entities live.
Full suite green.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AKLqS4PgnCXrzKHDH8Cnzy

Author: softpython2884

pc/nova/combat.py

@@ -66,12 +66,15 @@ def __init__(self, run, kind, art, audio=None):
 
         sector = run.sector
         self.is_boss = kind == data.N_BOSS
-        budget = (16 + sector * 10 + run.node * 3) * run.budget_mult
+        budget = (16 + sector * 13 + run.node * 3) * run.budget_mult
         # Capped: past this an uncapped budget makes waves longer, not harder.
-        self.budget = min(budget, 104)
+        # The cap and the slope both went up for the late game, where sectors
+        # 4 and 5 were running the same wave sizes as sector 3 and going past
+        # in the same few minutes.
+        self.budget = min(budget, 150)
         if kind == data.N_ELITE:
             self.budget *= 1.5
-        self.pool = min(2 + sector, 5)
+        self.pool = data.roster(sector)
 
         if self.is_boss:
             self.budget = 0
@@ -116,12 +119,14 @@ def nearest_player_pos(self, x):
         return best.x, best.y
 
     def spawn_wave(self, dt):
-        if self.budget <= 0 or len(self.enemies) > 14:
+        # How many can be in the air at once, not just how many arrive: a flat
+        # ceiling of 14 was what actually held the late sectors down.
+        if self.budget <= 0 or len(self.enemies) >= min(20, 13 + self.run.sector):
             return
         self.spawn_t -= dt
         if self.spawn_t > 0:
             return
-        kind = self.rng.randrange(self.pool)
+        kind = self.rng.choice(self.pool)
         self.budget -= data.ENEMY_COST[kind]
         hp = data.ENEMY_HP[kind] + self.run.sector
         x = self.rng.uniform(data.PLAY_L + 24, data.PLAY_R - 24)
@@ -260,7 +265,11 @@ def update(self, dt, inputs):
             s.update(dt)
         for e in self.enemies:
             tx, ty = self.nearest_player_pos(e.x)
+            had_beam = e.beam is not None
             e.update(dt, tx)
+            if e.beam is not None and not had_beam:
+                # the telegraph needs a sound as well as a line
+                self.audio.play("boss_warn", 0.35, throttle=0.2)
             if e.y > data.TOP - 4 and e.wants_to_fire(
                     dt, 1.0 + self.run.fire_bonus):
                 self.shots.extend(e.volley(tx, ty, self.run.difficulty
@@ -432,6 +441,9 @@ def collide(self):
                     s.y = 1e9
                     break
             for e in self.enemies:
+                if e.beam is not None and e.beam.firing and \
+                        ent.overlaps(pr, e.beam.rect()):
+                    self.hurt_player(p)
                 if e.hp > 0 and ent.overlaps(pr, e.rect()):
                     self.hurt_player(p)
                     if e.kind != data.BOSS_ID:
@@ -468,6 +480,9 @@ def draw(self, surf):
                 surf.blit(img, (int(pk.x) - img.get_width() // 2,
                                 int(pk.y) - img.get_height() // 2))
 
+        for e in self.enemies:
+            if e.beam is not None:
+                e.beam.draw(surf)
         for e in self.enemies:
             img = a.enemy_surface(sector, e.kind, e.flash > 0)
             surf.blit(img, (int(e.x) - img.get_width() // 2,

pc/nova/data.py

@@ -363,16 +363,83 @@ def SEC_ACCENT(sector):
 CRYSTAL_PAL = {"w": WHITE, "c": CYAN}
 REPAIR_PAL = {"w": WHITE, "g": GREEN}
 
+# The three late arrivals. Each takes a mechanic off a boss and bolts it to
+# something mortal, which is the point: a boss teaches you an attack once, and
+# then the attack comes back on a ship you can actually shoot down.
+LANCER = """
+..aaaa
+.aaaaa
+aaaaaa
+aawwwa
+aaaaaa
+.aaaaa
+..aaaa
+...ddd
+....dd
+....dd
+""".strip("\n")
+
+SPINNER = """
+.....a
+....aa
+...aaa
+..aaaa
+.aaaaa
+..awwa
+.aaaaa
+..aaaa
+...aaa
+....aa
+.....a
+""".strip("\n")
+
+PHANTOM = """
+.....a
+....aa
+...aaa
+..awwa
+..awwa
+.aaaaa
+.aa.aa
+aa...a
+a....a
+""".strip("\n")
+
 # Enemies are tinted per sector at load time: 'a' is the accent, 'd' its dark
 # shade, 'w' stays white.
-GRUNT_ID, WEAVER_ID, TURRET_ID, RUSHER_ID, TANK_ID, BOSS_ID = range(6)
-ENEMY_ART = (GRUNT, WEAVER, TURRET, RUSHER, TANK, BOSS_SENTINEL)
-
-ENEMY_HP = (2, 2, 6, 2, 12, 1)
-ENEMY_SCORE = (10, 15, 25, 20, 40, 500)
-ENEMY_SPEED = (46, 42, 40, 118, 22, 0)      # pixels per second
-ENEMY_FIRE = (2.6, 0.0, 1.4, 0.0, 1.9, 0.8)  # seconds between shots, 0 = never
-ENEMY_COST = (1, 2, 3, 2, 5, 0)             # threat budget
+(GRUNT_ID, WEAVER_ID, TURRET_ID, RUSHER_ID, TANK_ID, BOSS_ID,
+ LANCER_ID, SPINNER_ID, PHANTOM_ID) = range(9)
+ENEMY_ART = (GRUNT, WEAVER, TURRET, RUSHER, TANK, BOSS_SENTINEL,
+             LANCER, SPINNER, PHANTOM)
+
+ENEMY_HP = (2, 2, 6, 2, 12, 1, 4, 5, 4)
+ENEMY_SCORE = (10, 15, 25, 20, 40, 500, 35, 40, 55)
+ENEMY_SPEED = (46, 42, 40, 118, 22, 0, 34, 30, 40)   # pixels per second
+# seconds between shots, 0 = never (the lancer answers with a beam instead)
+ENEMY_FIRE = (2.6, 0.0, 1.4, 0.0, 1.9, 0.8, 0.0, 2.2, 1.5)
+ENEMY_COST = (1, 2, 3, 2, 5, 0, 4, 4, 4)             # threat budget
+
+# When each kind starts showing up, by sector index (0 = sector 1).
+#
+# The roster used to be `min(2 + sector, 5)`: everything was unlocked by
+# sector 3, so sectors 4 and 5 introduced nothing at all and the last third of
+# a run was the first third with bigger numbers. It grows the whole way now,
+# and the Void gets something of its own.
+ENEMY_UNLOCK = {
+    GRUNT_ID: 0,
+    WEAVER_ID: 0,
+    RUSHER_ID: 1,
+    TURRET_ID: 2,
+    LANCER_ID: 2,       # the beam, first met on LANCE at sector 3
+    TANK_ID: 3,
+    SPINNER_ID: 4,      # SENTINEL's rings, on something that comes to you
+    PHANTOM_ID: 5,      # the Void only
+}
+
+
+def roster(sector):
+    """Which enemy kinds a sector can field."""
+    return [k for k, first in sorted(ENEMY_UNLOCK.items()) if first <= sector]
 
 # --- upgrades ------------------------------------------------------------
 # All twelve are back: the calculator build could only afford eight.

pc/nova/entities.py

@@ -56,6 +56,64 @@ def alive(self):
                 and data.PLAY_L - 20 < self.x < data.PLAY_R + 20)
 
 
+class EnemyBeam:
+    """A lancer's beam: LANCE's mechanic, bolted to something you can kill.
+
+    Same contract as the boss's -- it locks where it aimed when the charge
+    began, so it is always dodgeable and never arbitrary -- but it hangs off a
+    mortal ship. Kill the lancer mid-charge and the beam goes with it, which is
+    the whole reason for putting a boss attack on a regular enemy: it turns
+    into a target priority instead of a weather condition.
+    """
+
+    CHARGE = 0.85
+    FIRE = 0.5
+    FADE = 0.2
+    WIDTH = 9
+
+    __slots__ = ("x", "y", "t")
+
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+        self.t = 0.0
+
+    def update(self, dt):
+        self.t += dt
+
+    @property
+    def firing(self):
+        return self.CHARGE <= self.t < self.CHARGE + self.FIRE
+
+    @property
+    def done(self):
+        return self.t >= self.CHARGE + self.FIRE + self.FADE
+
+    def rect(self):
+        half = self.WIDTH / 2
+        return (self.x - half, self.y, self.WIDTH, data.BOT - self.y)
+
+    def draw(self, surf):
+        top = int(self.y)
+        h = data.BOT - top
+        if h <= 0:
+            return
+        if self.t < self.CHARGE:
+            frac = self.t / self.CHARGE
+            if int(self.t * (7 + 20 * frac)) % 2:
+                w = max(1, int(1 + frac * 3))
+                surf.fill(data.ORANGE, (int(self.x - w / 2), top, w, h))
+            return
+        if self.firing:
+            w = self.WIDTH
+            surf.fill(data.ORANGE, (int(self.x - w / 2), top, w, h))
+            surf.fill(data.WHITE, (int(self.x - 2), top, 4, h))
+            return
+        frac = 1.0 - (self.t - self.CHARGE - self.FIRE) / self.FADE
+        w = max(1, int(self.WIDTH * frac * 0.5))
+        surf.fill(data.ORANGE, (int(self.x - w / 2), top, w, h))
+
+
 class Pickup:
     """Crystals and hull patches, back from the calculator's cutting-room floor."""
 
@@ -184,7 +242,8 @@ def take_hit(self):
 
 class Enemy:
     __slots__ = ("x", "y", "kind", "hp", "max_hp", "t", "fire_t", "anchor",
-                 "drift", "w", "h", "flash", "phase", "score", "rng")
+                 "drift", "w", "h", "flash", "phase", "score", "rng",
+                 "beam", "dash_t", "dash_vx", "dash_vy")
 
     def __init__(self, kind, x, y, hp, sector, rng=None):
         self.kind = kind
@@ -202,6 +261,10 @@ def __init__(self, kind, x, y, hp, sector, rng=None):
         self.phase = 0
         self.score = data.ENEMY_SCORE[kind]
         self.w, self.h = ENEMY_SIZE[kind]
+        self.beam = None                 # lancers only
+        self.dash_t = 0.0                # phantoms only
+        self.dash_vx = 0.0
+        self.dash_vy = 0.0
 
     def rect(self):
         return (self.x - self.w / 2, self.y - self.h / 2, self.w, self.h)
@@ -225,6 +288,57 @@ def update(self, dt, target_x):
                 self.anchor += 11 * dt
                 self.y += 11 * dt
                 self.x += math.sin(self.t * 1.1) * 26 * dt
+        elif k == data.LANCER_ID:
+            # Slides to its station, then works a charge-fire cycle. It never
+            # descends past the anchor: a beam is only fair if you can see
+            # where it will be, and one falling on top of you is not that.
+            if self.y < self.anchor:
+                self.y += speed * dt
+            else:
+                self.x += math.sin(self.t * 0.9) * 22 * dt
+                self.anchor += 6 * dt
+                self.y += 6 * dt
+            if self.beam is not None:
+                # The beam does not follow the ship: it stays where it aimed
+                # when the charge began, which is the whole telegraph.
+                self.beam.update(dt)
+                if self.beam.done:
+                    self.beam = None
+                    self.fire_t = self.rng.uniform(1.3, 2.1)
+            else:
+                self.fire_t -= dt
+                if self.fire_t <= 0 and self.y > data.TOP + 8:
+                    self.beam = EnemyBeam(target_x, self.y + 6)
+        elif k == data.SPINNER_ID:
+            # Drifts in slowly and turns. Its rings are the one attack in the
+            # roster that does not care where you are, which is what makes it
+            # awkward next to everything that does.
+            self.y += speed * dt
+            self.x += math.sin(self.t * 1.6) * 34 * dt
+        elif k == data.PHANTOM_ID:
+            # The Void's answer to a maxed rate of fire: it will not stand
+            # still to be hit. Lining up under it is the trigger, so parking
+            # beneath one and holding the trigger -- which is what a stock
+            # shmup rewards by then -- is exactly what does not work.
+            if self.dash_t > 0:
+                self.dash_t -= dt
+                self.x += self.dash_vx * dt
+                self.y += self.dash_vy * dt
+            else:
+                self.y += speed * dt
+                lined_up = abs(self.x - target_x) < 26
+                self.fire_t -= dt * (2.2 if lined_up else 1.0)
+                if lined_up and self.t > 0.7:
+                    self.t = 0.0
+                    self.dash_t = 0.24
+                    if self.rng.random() < 0.45:
+                        # backwards, out of the firing lane entirely
+                        self.dash_vy = -260.0
+                        self.dash_vx = self.rng.choice((-1, 1)) * 90.0
+                    else:
+                        away = 1.0 if self.x > target_x else -1.0
+                        self.dash_vx = away * 300.0
+                        self.dash_vy = -40.0
         elif k == data.BOSS_ID:
             self.x += self.drift * dt
             if self.x < data.PLAY_L + 60 or self.x > data.PLAY_R - 60:
@@ -239,6 +353,10 @@ def update(self, dt, target_x):
         else:
             self.y += speed * dt
         self.x = max(data.PLAY_L + 6, min(data.PLAY_R - 6, self.x))
+        if k == data.PHANTOM_ID:
+            # A dash backwards must not park it off the top, where nothing can
+            # reach it and it stops being a fight.
+            self.y = max(data.TOP + 10, self.y)
 
     def wants_to_fire(self, dt, haste=1.0):
         """`haste` is the difficulty tier's contribution.
@@ -288,6 +406,19 @@ def volley(self, tx, ty, difficulty):
                     out.append(EnemyBullet(self.x, self.y + 6,
                                            math.cos(a) * base * 0.8,
                                            math.sin(a) * base * 0.8, 2))
+        elif k == data.SPINNER_ID:
+            spin = self.t * 1.7
+            for i in range(6):
+                a = spin + i * (math.tau / 6)
+                out.append(EnemyBullet(self.x, self.y,
+                                       math.cos(a) * base * 0.66,
+                                       math.sin(a) * base * 0.66, 2))
+        elif k == data.PHANTOM_ID:
+            for i in (-1, 1):
+                a = ang + i * 0.1
+                out.append(EnemyBullet(self.x, self.y + 4,
+                                       math.cos(a) * base * 1.15,
+                                       math.sin(a) * base * 1.15, 2))
         elif k == data.TANK_ID:
             for i in (-1, 1):
                 a = ang + i * 0.16
@@ -306,7 +437,8 @@ def alive(self):
         return self.kind == data.BOSS_ID or self.y < data.BOT + 30
 
 
-ENEMY_SIZE = ((11, 11), (11, 11), (11, 12), (11, 13), (17, 13), (37, 17))
+ENEMY_SIZE = ((11, 11), (11, 11), (11, 12), (11, 13), (17, 13), (37, 17),
+              (11, 10), (11, 11), (11, 9))
 
 
 def overlaps(a, b):

pc/tests/bot.py

@@ -64,6 +64,13 @@ def threats(self, me):
                 # stationary threat sitting at the player's own height
                 if beam.t > beam.CHARGE * 0.45:
                     out.append((beam.x, me.y, 0.0, 0.0, beam.width * 0.5 + 8.0))
+        # Lancers carry the same attack on a killable ship. A pilot that cannot
+        # see them would rate the enemy by how invisible it is to a heuristic,
+        # which is exactly the mistake the repulsion field made.
+        for e in self.c.enemies:
+            b = e.beam
+            if b is not None and b.t > b.CHARGE * 0.45 and b.y < me.y:
+                out.append((b.x, me.y, 0.0, 0.0, b.WIDTH * 0.5 + 8.0))
         return out
 
     def cost(self, px, py, vx, vy, threats):

pc/tools/balance.py

@@ -158,6 +158,18 @@ def main(argv):
     print("  traders per sector        : %.2f" % m["shop_per_map"])
     print("  every route crosses one   : %.0f%%" % m["forced_shop"])
 
+    names = ("GRUNT", "WEAVER", "TURRET", "RUSHER", "TANK", "BOSS",
+             "LANCER", "SPINNER", "PHANTOM")
+    print("\n=== the roster, sector by sector ===")
+    seen = set()
+    for sec in range(7):
+        kinds = set(data.roster(sec))
+        fresh = sorted(kinds - seen)
+        seen = kinds
+        print("  %-8s %2d kinds   new: %s"
+              % ("VOID %d" % (sec - 4) if sec > 4 else "sector %d" % (sec + 1),
+                 len(kinds), ", ".join(names[k] for k in fresh) or "-"))
+
     print("\n=== fights (%d seeds per tier) ===" % len(seeds))
     print("%-7s %6s %8s %9s %8s %10s %8s" %
           ("tier", "won", "boss hp", "dmg taken", "no dmg", "boss secs",