Shield a boss until it can shoot back, and add a release workflow

A boss holds fire for the length of its name card. The player does not, and a
ship parked underneath lands every shot: measured, 5 to 25% of the boss's hull
was gone before it acted -- 25% against a stock ship at sector 1, less against
a maxed one only because boss hit points scale with the guns brought to the
fight. Free damage against something that cannot answer is a gap in the rules,
not a reward for skill.

The boss is now untouchable for that window. The constant is 2.0s, and combat
widens it to cover the whole card: a shield that lapses while the boss is still
holding fire only moves the gap a second later. Pods are covered too, or the
same trick just relocates to BULWARK and WARDEN.

It draws as a circle. A rectangle bracket already means "pods armouring the
core" and corner ticks mean "venting" -- three states that change what your
shots do, three shapes.

test_boss_entrance walks all five bosses with a stock and a maxed loadout and
requires the core and every pod to finish the entrance at full hit points.
Verified against the bug: with the shield removed it reports the boss losing 14
hull before it acted.

Release workflow: push a v* tag and it verifies both editions, builds NOVA.exe
on Windows and a Linux binary, bundles dist/ for the calculator, and publishes
the release with notes. Nothing can be released past a red suite, and what
ships is exactly what the tag points at.

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

Author: softpython2884

.github/RELEASE_NOTES.md

@@ -0,0 +1,84 @@
+**NOVA** — un rogue-lite spatial qui tourne sur une calculatrice NumWorks *et*
+sur PC. Même jeu, deux éditions : 32 Ko de tas MicroPython d'un côté, pygame de
+l'autre.
+
+## Télécharger
+
+| | |
+|---|---|
+| **`NOVA-windows.exe`** | Windows, un seul fichier. Double-clic, rien à installer. |
+| **`NOVA-linux`** | Linux, un seul fichier. `chmod +x NOVA-linux && ./NOVA-linux` |
+| **`nova-numworks.zip`** | L'édition calculatrice : les cinq fichiers à coller dans [workshop.numworks.com](https://workshop.numworks.com), plus les instructions. |
+
+Depuis les sources : `pc/play.sh` (ou `pc/play.cmd`) installe et lance tout seul.
+
+## Ce qu'apporte la 1.1
+
+### Les boss sont devenus des combats
+
+Cinq boss, cinq mécaniques, et un vocabulaire commun : **murs à un seul trou**,
+spirales tournantes, **peignes de rayons** qui balaient l'arène, pluie, et des
+**canons destructibles sur les murs** — parce qu'un combat avec un coin sûr est
+un combat qu'on gagne en s'y asseyant.
+
+Rien n'est aléatoire : même spirale à chaque tour, toujours exactement un trou,
+rayon fixé là où il visait au début de la charge. Dense, mais fait pour être lu.
+
+Et surtout, ils **respirent** : une tempête de 3 à 4,4 s, puis une fenêtre où
+tout se tait, signalée par quatre coins cyan. Sans cette pause le combat n'était
+pas plus dur, juste plus long — 60 secondes d'esquive à grignoter le boss entre
+deux frôlements.
+
+| | avant | 1.1 |
+|---|---|---|
+| Dégâts pris par boss | 0,6 | **4,9** |
+| Combats finis sans une égratignure | 57 % | **14 %** |
+
+Un boss est aussi **intouchable pendant sa carte de présentation**. Il retenait
+son tir ; le joueur non, et 5 à 25 % de sa coque partaient avant qu'il ait le
+droit de répondre.
+
+### La carte est enfin un choix
+
+Les nœuds spéciaux étaient posés par colonne entière : toutes les routes
+croisaient le marchand *et* l'atelier, et le dernier nœud avant le boss rendait
+la coque à neuf. Un atelier n'apparaît plus que dans **54 % des secteurs**, sur
+une seule branche, **jamais avant le boss** — et quand marchand et atelier sont
+tous les deux là, ils sont dans la même colonne : cristaux **ou** coque.
+
+### Le son
+
+Le tir est automatique, donc il sonne pendant toute la partie. Il est
+**14 dB plus discret** et tourne sur trois hauteurs, pour ne jamais rejouer deux
+fois le même échantillon. `M` fait le tour de trois réglages — tout, **canon
+coupé**, silence — parce que vouloir se passer du canon n'est pas vouloir se
+passer du son.
+
+### Le reste
+
+- **Toutes les résolutions horizontales**, sans bandes noires : 1080p,
+  3440×1440, 1366×768. Zoom toujours entier, arène de taille fixe.
+- **Manettes** : sticks, croix, branchement à chaud, deux manettes en coop,
+  clavier et manette actifs en même temps.
+- **Scripts d'installation** `.sh` / `.cmd` qui installent pygame-ce et lancent.
+- Musique chiptune synthétisée au démarrage, une boucle par secteur. Aucun
+  fichier audio dans le dépôt.
+- **Une graine reproduit une partie.** Elle ne le faisait pas : la même graine
+  gagnait puis perdait deux fois, et tous les chiffres d'équilibrage mesuraient
+  du bruit.
+
+## Difficulté mesurée
+
+Sur 24 graines, avec un pilote automatique à réaction parfaite et sans mémoire
+des motifs — un humain est l'inverse :
+
+| | Cadet | Pilote | As |
+|---|---|---|---|
+| Parties gagnées | 15/24 | 10/24 | 5/24 |
+
+Détail par boss, banc de mesure et raisonnement complet dans
+[`pc/README.md`](../pc/README.md).
+
+## Licence
+
+MIT.

.github/workflows/release.yml

@@ -0,0 +1,104 @@
+name: Release
+
+# Tag a commit v1.1 (or any v*) and push the tag; this builds the binaries and
+# publishes the release. Nothing here can be run by hand against a dirty tree,
+# which is the point: what ships is exactly what the tag points at.
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Existing tag to build and publish"
+        required: true
+
+permissions:
+  contents: write
+
+jobs:
+  # A release that fails its own test suite is worse than no release.
+  verify:
+    runs-on: ubuntu-latest
+    env:
+      SDL_VIDEODRIVER: dummy
+      SDL_AUDIODRIVER: dummy
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.inputs.tag || github.ref }}
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - name: Calculator edition
+        run: |
+          python3 tools/lint_globals.py src/nova*.py
+          python3 tools/fiximports.py --check
+          python3 tools/build.py
+          git diff --exit-code -- dist/
+          python3 tests/run_all.py
+      - name: PC edition
+        run: |
+          pip install pygame-ce numpy
+          python3 pc/tests/run_all.py
+
+  build:
+    needs: verify
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-latest
+            asset: NOVA-windows.exe
+            built: pc/dist/NOVA.exe
+          - os: ubuntu-latest
+            asset: NOVA-linux
+            built: pc/dist/NOVA
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.inputs.tag || github.ref }}
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - name: Install
+        run: pip install pygame-ce numpy pyinstaller
+      - name: Draw the icon
+        working-directory: pc
+        run: python tools/make_icon.py
+      - name: Build
+        working-directory: pc
+        run: pyinstaller --noconfirm --clean nova.spec
+      - name: Name it for the platform
+        shell: bash
+        run: mv "${{ matrix.built }}" "${{ matrix.asset }}"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.asset }}
+          path: ${{ matrix.asset }}
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.inputs.tag || github.ref }}
+      - uses: actions/download-artifact@v4
+        with:
+          merge-multiple: true
+      - name: Bundle the calculator edition
+        run: |
+          mkdir -p nova-numworks
+          cp dist/*.py nova-numworks/
+          cp docs/INSTALL.md nova-numworks/
+          zip -r nova-numworks.zip nova-numworks
+      - name: Publish
+        env:
+          GH_TOKEN: ${{ github.token }}
+          TAG: ${{ github.event.inputs.tag || github.ref_name }}
+        run: |
+          gh release create "$TAG" \
+            --title "NOVA $TAG" \
+            --notes-file .github/RELEASE_NOTES.md \
+            NOVA-windows.exe NOVA-linux nova-numworks.zip

pc/nova/boss.py

@@ -194,6 +194,17 @@ def _clamp(v, lo, hi):
 
 
 class Boss:
+    # How long the boss is untouchable when it arrives.
+    #
+    # It holds fire while its name card is up, and the player does not: a
+    # maxed ship stands under it and lands every shot for the whole entrance,
+    # so the fight could begin with the boss already at half hull. Free damage
+    # against something that cannot answer is not a reward for skill, it is a
+    # gap in the rules. Combat widens this to cover the whole card, because a
+    # shield that expires while the boss is still holding fire only moves the
+    # gap later.
+    SPAWN_SHIELD = 2.0
+
     def __init__(self, index, sector, hp, x, y, fire_bonus=0.0, rng=None):
         self.index = index % BOSS_COUNT
         self.sector = sector
@@ -226,6 +237,7 @@ def __init__(self, index, sector, hp, x, y, fire_bonus=0.0, rng=None):
         self.storming = True
         self.burst_t = self.STORM[0][0]
         self.spin = self.rng.uniform(0.0, math.tau)
+        self.shield_t = self.SPAWN_SHIELD
         self.stream_t = 0.0
         if self.index in (BULWARK, WARDEN):
             pod_hp = max(8, hp // 6)
@@ -255,8 +267,19 @@ def live_pods(self):
     def live_turrets(self):
         return [t for t in self.turrets if t.alive]
 
+    def tick_shield(self, dt):
+        """Runs during the entrance too, where `update` does not."""
+        if self.shield_t > 0:
+            self.shield_t -= dt
+
+    @property
+    def invulnerable(self):
+        return self.shield_t > 0
+
     def take_hit(self, dmg):
         """Returns the damage actually dealt."""
+        if self.invulnerable:
+            return 0
         if self.shielded:
             dmg = max(1, dmg // 4)
         self.hp -= dmg
@@ -267,6 +290,7 @@ def take_hit(self, dmg):
     def update(self, dt, combat):
         self.t += dt
         self.state_t += dt
+        self.tick_shield(dt)
         if self.flash > 0:
             self.flash -= dt
 
@@ -646,3 +670,11 @@ def draw(self, surf, art):
             pygame.draw.rect(surf, data.BLUE,
                              (int(r[0]) - 2, int(r[1]) - 2,
                               int(r[2]) + 4, int(r[3]) + 4), 1)
+        if self.invulnerable:
+            # A circle, deliberately: a bracket already means "pods armouring
+            # the core" and corner ticks mean "venting". Three states that
+            # change what your shots do, three shapes.
+            rad = 23 + int(4 * abs(math.sin(self.shield_t * 5.0)))
+            colour = data.CYAN_D if int(self.shield_t * 12) % 2 else data.BLUE
+            pygame.draw.circle(surf, colour,
+                               (int(self.x), int(self.y)), rad, 1)

pc/nova/combat.py

@@ -81,6 +81,11 @@ def __init__(self, run, kind, art, audio=None):
                                       data.TOP - 20, run.fire_bonus, self.rng)
             self.tag = self.boss.name
             self.intro_t = 2.6
+            # Cover the whole name card, not just the boss's own two seconds:
+            # the window that needs closing is exactly the one where the boss
+            # is holding fire, and a shield that lapses first just moves the
+            # free damage a second later.
+            self.boss.shield_t = max(self.boss.SPAWN_SHIELD, self.intro_t)
             self.audio.play("boss_warn")
         else:
             self.tag = "S%d-%d" % (sector + 1, run.node + 1)
@@ -267,6 +272,7 @@ def update(self, dt, inputs):
                 # hold fire while the name card is up
                 self.intro_t -= dt
                 self.boss.move(dt, self)
+                self.boss.tick_shield(dt)
                 self.boss.t = 0.0
             else:
                 self.boss.update(dt, self)
@@ -325,6 +331,14 @@ def collide_boss(self):
                         hit = turret
                         break
             if hit is not None:
+                if b.invulnerable:
+                    # bounces off the entrance shield, same as the core
+                    self.audio.play("hit", 0.3, throttle=0.04)
+                    self.particles.burst(shot.x, shot.y, 2, 90,
+                                         (data.BLUE,), 0.2, 1)
+                    if not shot.pierce:
+                        shot.y = -999
+                    continue
                 hit.hp -= shot.dmg
                 hit.flash = 0.08
                 self.audio.play("hit", 0.5, throttle=0.03)

pc/tests/test_run.py

@@ -154,6 +154,47 @@ def run_once(seed, players=1, difficulty=1):
             "fights": d.fights, "minutes": d.frames * DT / 60.0, "log": d.log}
 
 
+def test_boss_entrance():
+    """A boss must not be damageable while it is holding fire.
+
+    It keeps its guns quiet for the length of its name card, and the player's
+    do not stop: a ship parked underneath landed 5 to 25% of the boss's hull
+    before the fight began, depending on sector and loadout. Free damage
+    against something that cannot answer is a gap in the rules, not a reward.
+
+    Pods count. Shielding the core and leaving BULWARK's turrets exposed would
+    just move the same trick onto two of the five bosses.
+    """
+    from nova.art import Art
+    from nova.combat import Combat
+    from nova.run import Run
+    art = Art()
+    art.load_fonts()
+    loadouts = ({}, {data.U_SPREAD: 3, data.U_RATE: 3, data.U_DMG: 3,
+                     data.U_PIERCE: 1})
+    for sector in range(5):
+        for ups in loadouts:
+            run = Run(1, 1, seed=5)
+            run.sector = sector
+            for u, v in ups.items():
+                run.upgrades[u] = v
+            c = Combat(run, data.N_BOSS, art)
+            start = c.boss.max_hp
+            pods = [p.hp for p in c.boss.pods]
+            p = c.players[0]
+            while c.intro_t > 0 and c.boss is not None:
+                p.x = c.boss.x          # parked underneath, holding fire
+                c.update(DT, {"move0": (0, 0), "bomb": False})
+            assert c.boss is not None, "boss died during its own entrance"
+            assert c.boss.hp == start, (
+                "sector %d: boss lost %d hull before it acted"
+                % (sector + 1, start - c.boss.hp))
+            assert [p.hp for p in c.boss.pods] == pods, (
+                "sector %d: a pod was damaged before the boss acted" % (sector + 1))
+    print("  boss entrance: shielded until it can answer")
+    return True
+
+
 def test_maxed_trader():
     """A fully upgraded ship must not break the shop.
 
@@ -207,6 +248,7 @@ def main():
 
     print()
     print("=== edge cases ===")
+    test_boss_entrance()
     test_maxed_trader()
     print("  fully-upgraded ship: trader and salvage both handled")