test: juice checks; deterministic save-free boot, robust presses/teleports

Author: splch

tests/test_juice.py

@@ -0,0 +1,181 @@
+"""Tier 1 combat-juice tests: hit flash, sinking animation, splash, muzzle
+smoke, screen shake + damage flash, and the harbor bell / port music.
+
+J1  enemy blinks when hit (wEnemyFlash) and slides under when sunk (wSinkT)
+J2  firing the cannon puffs smoke; a dying ball splashes
+J3  taking a hit shakes the screen and flashes the palette
+J4  docking rings the bell and plays the port music (was dead content)
+"""
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from test_regress import (boot, new_game, w16, set16, seed16, syms, tile,
+                          press3, teleport)
+
+teleport_verified = lambda pb, mem, tx, ty: teleport(pb, tx, ty)
+
+
+def open_sea_enemy_spot(mem, s16):
+    """A water pixel 24 px from the ship (enemy holds at cheb <= 40)."""
+    sx, sy = w16(mem, "wShipX"), w16(mem, "wShipY")
+    for dx, dy in ((24, 0), (-24, 0), (0, 24), (0, -24), (24, 24), (-24, -24)):
+        ex, ey = sx + dx, sy + dy
+        if tile(ex >> 3, ey >> 3, s16) < 3:
+            return ex, ey
+    raise AssertionError("no open-sea enemy spot near spawn")
+
+
+def place_enemy(mem, ex, ey, hp):
+    set16(mem, "wEnemyX", ex << 4)
+    set16(mem, "wEnemyY", ey << 4)
+    mem[syms["wEnemyHP"]] = hp
+    mem[syms["wEnemyFireCool"]] = 75
+    mem[syms["wIsGuardian"]] = 0
+    mem[syms["wLosT"]] = 16
+    mem[syms["wNoLOS"]] = 0
+    mem[syms["wEnemyActive"]] = 1
+
+
+def place_ball_on_enemy(mem):
+    mem[syms["wBallPX"]] = mem[syms["wBallPX"]]  # keep linters honest
+    for dst, src in (("wBallPX", "wEnemyX"), ("wBallPY", "wEnemyY")):
+        mem[syms[dst]] = mem[syms[src]]
+        mem[syms[dst] + 1] = mem[syms[src] + 1]
+    mem[syms["wBallPVX"]] = 0
+    mem[syms["wBallPVY"]] = 0
+    mem[syms["wBallPLife"]] = 30
+    mem[syms["wBallPActive"]] = 1
+
+
+def j1_hit_flash_and_sink():
+    pb = boot()
+    mem = pb.memory
+    new_game(pb)
+    s16 = seed16(mem)
+    ex, ey = open_sea_enemy_spot(mem, s16)
+    place_enemy(mem, ex, ey, 3)
+    place_ball_on_enemy(mem)
+    pb.tick()
+    assert mem[syms["wEnemyHP"]] == 2, "ball didn't damage the enemy"
+    assert mem[syms["wEnemyFlash"]] > 0, "no hit flash on a damaged enemy"
+    # now sink her
+    mem[syms["wEnemyHP"]] = 1
+    place_ball_on_enemy(mem)
+    pb.tick()
+    assert not mem[syms["wEnemyActive"]], "enemy survived 0 HP"
+    assert mem[syms["wSinkT"]] > 0, "sinking animation never started"
+    for _ in range(30):
+        pb.tick()
+    assert mem[syms["wSinkT"]] == 0, "sinking animation never finished"
+    pb.stop()
+    print("J1 enemy hit flash + sinking animation: OK")
+
+
+def j2_smoke_and_splash():
+    pb = boot()
+    mem = pb.memory
+    new_game(pb)
+    pb.button_press("a")             # fire ahead (open ocean: no dock)
+    pb.tick()
+    pb.button_release("a")
+    pb.tick()
+    assert mem[syms["wBallPActive"]] == 1, "cannon didn't fire"
+    assert mem[syms["wSmokeT"]] > 0, "no muzzle smoke on firing"
+    # let the ball die in place two frames from now
+    mem[syms["wBallPVX"]] = 0
+    mem[syms["wBallPVY"]] = 0
+    mem[syms["wBallPLife"]] = 2
+    for _ in range(4):
+        pb.tick()
+    assert not mem[syms["wBallPActive"]], "ball never died"
+    assert mem[syms["wSplashT"]] > 0, "no splash where the ball fell"
+    pb.stop()
+    print("J2 muzzle smoke + ball splash: OK")
+
+
+def j3_shake_and_flash_on_hit():
+    pb = boot()
+    mem = pb.memory
+    new_game(pb)
+    hull0 = mem[syms["wHull"]]
+    # enemy ball parked on the ship
+    mem[syms["wBallEX"]] = mem[syms["wPosX"]]
+    mem[syms["wBallEX"] + 1] = mem[syms["wPosX"] + 1]
+    mem[syms["wBallEY"]] = mem[syms["wPosY"]]
+    mem[syms["wBallEY"] + 1] = mem[syms["wPosY"] + 1]
+    mem[syms["wBallEVX"]] = 0
+    mem[syms["wBallEVY"]] = 0
+    mem[syms["wBallELife"]] = 30
+    mem[syms["wDmgCool"]] = 0
+    mem[syms["wBallEActive"]] = 1
+    pb.tick()
+    assert mem[syms["wHull"]] == hull0 - 1, "enemy ball didn't hit"
+    assert mem[syms["wShakeT"]] > 0, "no screen shake on hull damage"
+    assert mem[syms["wHitFlashT"]] > 0, "no palette flash on hull damage"
+    pb.stop()
+    print("J3 screen shake + damage flash: OK")
+
+
+def j4_harbor_bell_and_port_music():
+    pb = boot()
+    mem = pb.memory
+    new_game(pb)
+    s16 = seed16(mem)
+    # find any port district with a dockable beach (the boot save's seed
+    # varies, so don't hardcode one). A beach counts only if some water
+    # tile's first land neighbor in TryDock's N,S,W,E order IS that beach
+    # and the beach's district is this one.
+    from test_regress import has_port
+
+    def dock_from(dx, dy):
+        for ty in range(dy * 4, dy * 4 + 4):
+            for tx in range(dx * 4, dx * 4 + 4):
+                if tile(tx, ty, s16) < 3:
+                    continue
+                for ddx, ddy in ((0, 1), (0, -1), (1, 0), (-1, 0)):
+                    nx, ny = tx + ddx, ty + ddy
+                    if not (0 <= nx < 320 and 0 <= ny < 288):
+                        continue
+                    if tile(nx, ny, s16) >= 3:
+                        continue
+                    for pdx, pdy in ((0, -1), (0, 1), (-1, 0), (1, 0)):
+                        if tile(nx + pdx, ny + pdy, s16) >= 3:
+                            if (nx + pdx, ny + pdy) == (tx, ty):
+                                return (nx, ny)
+                            break
+        return None
+
+    target = None
+    for dy in range(72):
+        for dx in range(80):
+            if has_port(dx, dy, s16):
+                spot = dock_from(dx, dy)
+                if spot:
+                    target = spot
+                    break
+        if target:
+            break
+    assert target, "no port district with a dockable beach in this sea"
+    docked = False
+    if teleport_verified(pb, mem, *target):
+        set16(mem, "wStormT", 0)     # no storm may drift us off the beach
+        mem[syms["wEnemyActive"]] = 0
+        pb.tick()
+        press3(pb, "a")             # dock, catching the bell mid-ring
+        pb.tick()
+        pb.tick()
+        docked = mem[syms["wState"]] == 4
+    assert docked, f"docking failed from {target}"
+    assert mem[syms["wSfx1T"]] > 0, "harbor bell not ringing on dock"
+    assert mem[syms["wSongID"]] == 3, \
+        f"port music not playing (song {mem[syms['wSongID']]}, want 3)"
+    pb.stop()
+    print("J4 harbor bell + port music: OK")
+
+
+if __name__ == "__main__":
+    for fn in (j1_hit_flash_and_sink, j2_smoke_and_splash,
+               j3_shake_and_flash_on_hit, j4_harbor_bell_and_port_music):
+        fn()
+    print("ALL JUICE CHECKS PASSED")

tests/test_regress.py

@@ -113,7 +113,14 @@ def snap_dir(dx, dy):
 # ---------------------------------------------------------------- helpers
 
 def boot(garbage=False):
-    pb = PyBoy(ROM, window="null")
+    # Boot a save-free copy of the ROM: PyBoy loads <rom>.ram next to the
+    # ROM path and writes it back on stop(), so reusing one path makes every
+    # later boot inherit an earlier boot's save. A fresh copy per boot keeps
+    # every test on the deterministic default-seed boot, like CI.
+    import shutil, tempfile
+    path = str(Path(tempfile.mkdtemp()) / "pf.gb")
+    shutil.copy(ROM, path)
+    pb = PyBoy(path, window="null")
     pb.set_emulation_speed(0)
     if garbage:
         # simulate power-on WRAM garbage BEFORE the first tick (PyBoy zeroes
@@ -155,6 +162,38 @@ def new_game(pb, seed=None):
     for _ in range(30):
         pb.tick()
 
+def wait_state(pb, state, frames=180):
+    """Tick until wState == state (screen rebuilds take several frames)."""
+    mem = pb.memory
+    for _ in range(frames):
+        pb.tick()
+        if mem[syms["wState"]] == state:
+            return True
+    return False
+
+
+def press3(pb, btn):
+    """Hold a button for 3 frames. A 1-tick press can land between the
+    game's joypad reads (PyBoy writes hit mid-frame) and vanish."""
+    pb.button_press(btn)
+    for _ in range(3):
+        pb.tick()
+    pb.button_release(btn)
+
+
+def teleport(pb, tx, ty, tries=8):
+    """Teleport to a tile, surviving torn mid-frame position writes (the
+    collision check can revert a torn write). Returns success."""
+    mem = pb.memory
+    for _ in range(tries):
+        set16(mem, "wPosX", (tx * 8) << 4)
+        set16(mem, "wPosY", (ty * 8) << 4)
+        pb.tick()
+        if (w16(mem, "wShipX") >> 3, w16(mem, "wShipY") >> 3) == (tx, ty):
+            return True
+    return False
+
+
 def w16(mem, n):
     return mem[syms[n]] | mem[syms[n] + 1] << 8
 
@@ -415,6 +454,35 @@ def r8_final_wave_returned():
 
 # ------------------------------------------------------ R9/R10: tavern rumors
 
+def find_dockable_port(s16):
+    """A port district with a beach the game will actually accept: some
+    water tile whose FIRST land neighbor in TryDock's N,S,W,E order is a
+    beach inside this district. Seed-independent (unlike the old
+    hardcoded (10,34), which is not a port district under DEADBEEF)."""
+    for dy in range(72):
+        for dx in range(80):
+            if not has_port(dx, dy, s16):
+                continue
+            for ty in range(dy * 4, dy * 4 + 4):
+                for tx in range(dx * 4, dx * 4 + 4):
+                    if tile(tx, ty, s16) < 3:
+                        continue
+                    for ddx, ddy in ((0, 1), (0, -1), (1, 0), (-1, 0)):
+                        nx, ny = tx + ddx, ty + ddy
+                        if not (0 <= nx < 320 and 0 <= ny < 288):
+                            continue
+                        if tile(nx, ny, s16) >= 3:
+                            continue
+                        for pdx, pdy in ((0, -1), (0, 1), (-1, 0), (1, 0)):
+                            if not (0 <= nx + pdx < 320 and 0 <= ny + pdy < 288):
+                                continue
+                            if tile(nx + pdx, ny + pdy, s16) >= 3:
+                                if (nx + pdx, ny + pdy) == (tx, ty):
+                                    return (dx, dy)
+                                break
+    raise AssertionError("no dockable port district in this sea")
+
+
 def dock_at_district(pb, s16, dx, dy):
     """Teleport next to a beach in port district (dx,dy) and dock."""
     mem = pb.memory
@@ -424,13 +492,21 @@ def dock_at_district(pb, s16, dx, dy):
                 continue
             for ddx, ddy in ((0, 1), (0, -1), (1, 0), (-1, 0)):
                 nx, ny = tx + ddx, ty + ddy
+                if not (0 <= nx < 320 and 0 <= ny < 288):
+                    continue
                 if tile(nx, ny, s16) >= 3:
                     continue
                 set16(mem, "wPosX", (nx * 8) << 4)
                 set16(mem, "wPosY", (ny * 8) << 4)
                 for _ in range(5):
                     pb.tick()
-                press(pb, "a", 30)
+                # a 1-tick press can land between joypad reads: hold for 3
+                pb.button_press("a")
+                for _ in range(3):
+                    pb.tick()
+                pb.button_release("a")
+                for _ in range(30):
+                    pb.tick()
                 if mem[syms["wState"]] == 4:
                     return
     raise AssertionError(f"no dockable beach in district ({dx},{dy})")
@@ -440,7 +516,7 @@ def r9_r10_tavern():
     mem = pb.memory
     new_game(pb)
     s16 = seed16(mem)
-    dock_at_district(pb, s16, 10, 34)       # the port test_m3 uses
+    dock_at_district(pb, s16, *find_dockable_port(s16))
     press(pb, "down", 2)
     press(pb, "down", 2)
     press(pb, "a", 30)                       # TAVERN
@@ -506,7 +582,7 @@ def r11_r12_menu_and_gold():
     mem = pb.memory
     new_game(pb)
     s16 = seed16(mem)
-    dock_at_district(pb, s16, 10, 34)
+    dock_at_district(pb, s16, *find_dockable_port(s16))
     press(pb, "up", 5)
     assert mem[syms["wPortMenu"]] == 5, \
         f"UP from top item -> {mem[syms['wPortMenu']]}, want 5"
@@ -558,13 +634,14 @@ def r14_dig_no_cannon():
         if spot:
             break
     assert spot, "no beach-adjacent water in isle 0's cell"
-    set16(mem, "wPosX", (spot[0] * 8) << 4)
-    set16(mem, "wPosY", (spot[1] * 8) << 4)
-    for _ in range(5):
+    assert teleport(pb, *spot), "teleport never stuck"
+    for _ in range(4):
         pb.tick()
     assert (mem[syms["wShipCX"]], mem[syms["wShipCY"]]) == (ix, iy)
     mem[syms["wGuardMask"]] = 1          # isle 0's guardian already sunk
-    press(pb, "a", 30)                   # dig up the fragment
+    press3(pb, "a")                      # dig up the fragment
+    for _ in range(30):
+        pb.tick()
     assert mem[syms["wState"]] == 5, f"state {mem[syms['wState']]}, want DIG"
     assert not mem[syms["wBallPActive"]], "digging fired a cannonball"
     pb.stop()
@@ -573,24 +650,20 @@ def r14_dig_no_cannon():
 # ---------------------- R15: SaveGame sets wHasSave (continue without reset)
 
 def r15_save_sets_has_save():
-    import shutil, tempfile
-    # a ROM path with no .ram next to it: guaranteed no-save boot
-    tmp = Path(tempfile.mkdtemp()) / "pf_nosave.gb"
-    shutil.copy(ROM, tmp)
-    pb = PyBoy(str(tmp), window="null")
-    pb.set_emulation_speed(0)
-    for _ in range(150):
-        pb.tick()
+    pb = boot()                       # save-free boot (see boot())
     mem = pb.memory
     assert mem[syms["wHasSave"]] == 0, "fresh cart reported a save"
     new_game(pb)
     s16 = seed16(mem)
-    dock_at_district(pb, s16, 10, 34)     # autosaves on dock
+    dock_at_district(pb, s16, *find_dockable_port(s16))  # autosaves on dock
     assert mem[syms["wHasSave"]] == 1, "wHasSave not set after autosave"
-    press(pb, "b", 30)                    # set sail
-    press(pb, "b", 5)                     # arm quit confirm
-    press(pb, "b", 30)                    # confirm: quit to the editor
-    assert mem[syms["wState"]] == 0, "did not return to the editor"
+    press3(pb, "b")                      # set sail
+    assert wait_state(pb, 2), "never set sail"
+    press3(pb, "b")                       # arm quit confirm
+    for _ in range(5):                    # B must be seen released...
+        pb.tick()
+    press3(pb, "b")                       # ...before the confirming edge
+    assert wait_state(pb, 0), "did not return to the editor"
     hint = read_text(mem, 0x9800 + 5 * 32 + 5, 11)
     assert hint == "A  NEW GAME", f"editor hint {hint!r}, want 'A  NEW GAME'"
     pb.stop()
@@ -612,16 +685,21 @@ def f1_quit_confirm():
     pb = boot()
     mem = pb.memory
     new_game(pb)
-    press(pb, "b", 5)
+    press3(pb, "b")
+    for _ in range(5):
+        pb.tick()
     assert mem[syms["wState"]] == 2, "single B press quit without confirm"
     assert mem[syms["wQuitCfm"]] > 0, "confirm window not armed"
     for _ in range(200):                  # let the window expire
         pb.tick()
     assert mem[syms["wQuitCfm"]] == 0, "confirm window never expired"
     assert mem[syms["wState"]] == 2, "expired confirm still quit"
-    press(pb, "b", 5)                     # re-arm
-    press(pb, "b", 10)                    # confirm
-    assert mem[syms["wState"]] == 0, "second B press did not quit"
+    press3(pb, "b")                       # re-arm
+    for _ in range(5):
+        pb.tick()
+    assert mem[syms["wQuitCfm"]] > 0, "confirm window not re-armed"
+    press3(pb, "b")                       # confirm
+    assert wait_state(pb, 0), "second B press did not quit"
     pb.stop()
     print("F1 B-at-sea quit confirm: OK")