Let the STAT line dip between mode-0 and the next line's LYC term

Ken Griffey Jr.'s Slugfest (issue #68) paces a per-band palette engine
with chained STAT interrupts: an LYC interrupt at the band line arms a
mode-0 interrupt, whose handler streams the next 8-line band's palettes
during HBlank, reprograms LYC and re-arms. The game keeps both sources
enabled across the frame start, so the chain relies on the LYC interrupt
of the band line firing while the previous line's mode-0 term is still
enabled.

Our STAT interrupt line never dipped there: the mode-0 term stays high
through the last tick of a line and the coincidence term went high at
tick 0 of the next line, so the line stayed high across the boundary and
the rising edge - and with it the LYC interrupt - was swallowed. The
game's engine then aborted, leaving an interrupt storm (a mode-0 int on
all 143 other lines) and only the static VBlank palette load, which
painted the perspective-warped field with the wrong per-band colours -
the "garbled crowd". On hardware the comparator output feeding the
interrupt line settles one machine cycle after the line-start latch, so
the line dips for 4 ticks and the LYC edge fires.

The readable STAT.2 flag keeps the existing timing (valid at tick 0,
pinned by lcdon_timing-GS); only the interrupt-line term gets the 4-tick
settling delay. Lines 0 and 153 are excluded, preserving the single
LYC=0 interrupt per frame across the 153->0 transition (Altered Space)
and the short LYC=153 window.

Verified: the palette engine now runs on every frame (408 mid-frame BGPD
writes, matching SameBoy exactly); the Home Run Derby field renders
pixel-clean. Full battery (unit, mooneye 98, dmg-acid2, blargg 46+8,
mealybug 24, controller 12) green; Bug's Life, Altered Space and Zerd no
Densetsu re-verified by screenshot.

Fixes #68

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

Author: trekawek

core/src/main/java/eu/rekawek/coffeegb/core/gpu/StatRegister.java

@@ -38,6 +38,10 @@ public class StatRegister implements AddressSpace, Originator<StatRegister> {
 
     private boolean coincidence;
 
+    // the coincidence term feeding the interrupt line; unlike the readable flag it stays
+    // low for the first 4 ticks of a line while the comparator output settles
+    private boolean intCoincidence;
+
     private boolean intLine;
 
     public StatRegister(InterruptManager interruptManager) {
@@ -67,6 +71,21 @@ public void tick() {
                 // interrupt fires only once per frame there
                 coincidence = false;
             }
+            intCoincidence = coincidence;
+            if (ticksInLine < 4 && gpu.getLine() != 0 && gpu.getLine() != 153) {
+                // the coincidence term feeding the interrupt line settles one machine
+                // cycle after the line-start latch (the readable flag is already valid
+                // at tick 0, lcdon_timing-GS). This guarantees the STAT interrupt line
+                // dips between the previous line's mode-0 term (high until the line
+                // ends) and the new line's LY=LYC term, so an enabled mode-0 interrupt
+                // cannot swallow the LYC interrupt of the following line (Ken Griffey's
+                // Slugfest chains LYC and HBlank interrupts for its per-band palette
+                // engine, issue #68). Lines 0 and 153 keep the existing model: LY=0 is
+                // registered at tick 8 of line 153 and stays valid into line 0 (single
+                // LYC=0 interrupt per frame, Altered Space), and LYC=153 has only the
+                // tl=0..3 window.
+                intCoincidence = false;
+            }
 
             if (gpu.getLine() == 144 && ticksInLine == 0) {
                 interruptManager.requestInterrupt(InterruptType.VBlank);
@@ -81,7 +100,7 @@ public void onLcdEnabled() {
     }
 
     private boolean computeIntLine(int enable) {
-        boolean line = (enable & 0b01000000) != 0 && coincidence;
+        boolean line = (enable & 0b01000000) != 0 && intCoincidence;
         if (gpu.isLcdEnabled()) {
             line |= (enable & 0b00001000) != 0 && gpu.isMode0IntWindow();
             line |= (enable & 0b00010000) != 0 && gpu.getVisibleStatMode() == 1;
@@ -119,7 +138,7 @@ public int getByte(int address) {
 
     @Override
     public Memento<StatRegister> saveToMemento() {
-        return new StatRegisterMemento(enableBits, registeredLy, coincidence, intLine);
+        return new StatRegisterMemento(enableBits, registeredLy, coincidence, intCoincidence, intLine);
     }
 
     @Override
@@ -130,10 +149,11 @@ public void restoreFromMemento(Memento<StatRegister> memento) {
         this.enableBits = mem.enableBits;
         this.registeredLy = mem.registeredLy;
         this.coincidence = mem.coincidence;
+        this.intCoincidence = mem.intCoincidence;
         this.intLine = mem.intLine;
     }
 
     private record StatRegisterMemento(int enableBits, int registeredLy, boolean coincidence,
-                                       boolean intLine) implements Memento<StatRegister> {
+                                       boolean intCoincidence, boolean intLine) implements Memento<StatRegister> {
     }
 }