Add the Mani 32K-block multicart mapper (TETRIS SET)

The "Mani 4 in 1 - Tetris + Alleyway + Yakuman + Tennis" cart is a menu
plus four unmodified 32 KB games; writing the 32 KB block number to
0x4000-0x5FFF drives the upper ROM address lines, switching the whole
0x0000-0x7FFF window. It carried an MBC3 header and got misdetected as
a Duz multicart (whose sub-games are banked); the new detection keys on
the sub-games' plain-ROM type bytes. All four games launch from the
menu now.

Fixes #74

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/memory/cart/Cartridge.java

@@ -33,6 +33,8 @@ public Cartridge(Rom rom, Battery battery) {
             addressSpace = new Mmm01(rom, battery, true);
         } else if (isHiddenMmm01(rom)) {
             addressSpace = new Mmm01(rom, battery, false);
+        } else if (isMani32kMulticart(rom)) {
+            addressSpace = new Mani32kMulticart(rom);
         } else if (isDuzMulticart(rom)) {
             addressSpace = new DuzMulticart(rom, battery);
         } else if (sachenBase(rom) >= 0) {
@@ -105,6 +107,39 @@ public void flushBattery() {
      * individual games each carry their own Nintendo logo at a 16 KB boundary past bank 0.
      * A normal single-game cart has exactly one logo.
      */
+    /**
+     * The Mani "TETRIS SET" style multicart (issue #74): a menu in the first 32 KB block
+     * followed by plain 32 KB games, each with a valid logo and a plain-ROM (0x00) type
+     * byte in its own header. The Duz multicarts also duplicate logos at 32 KB blocks,
+     * but their sub-games are banked (non-zero type bytes).
+     */
+    private static boolean isMani32kMulticart(Rom rom) {
+        int[] data = rom.getRom();
+        if (rom.getType() == CartridgeType.ROM || data.length < 0x10000) {
+            return false;
+        }
+        int subGames = 0;
+        for (int block = 1; block * 0x8000 + 0x150 <= data.length; block++) {
+            int base = block * 0x8000;
+            boolean logo = true;
+            for (int i = 0; i < NINTENDO_LOGO.length; i++) {
+                if (data[base + 0x104 + i] != NINTENDO_LOGO[i]) {
+                    logo = false;
+                    break;
+                }
+            }
+            if (!logo) {
+                // trailing blocks may be pad filler; games are contiguous from block 1
+                break;
+            }
+            if (data[base + 0x147] != 0x00) {
+                return false;
+            }
+            subGames++;
+        }
+        return subGames >= 2;
+    }
+
     private static boolean isDuzMulticart(Rom rom) {
         int[] data = rom.getRom();
         if (!rom.getType().isMbc3() || data.length < 0x10000) {

core/src/main/java/eu/rekawek/coffeegb/core/memory/cart/type/Mani32kMulticart.java

@@ -0,0 +1,62 @@
+package eu.rekawek.coffeegb.core.memory.cart.type;
+
+import eu.rekawek.coffeegb.core.memento.Memento;
+import eu.rekawek.coffeegb.core.memory.cart.MemoryController;
+import eu.rekawek.coffeegb.core.memory.cart.Rom;
+
+/**
+ * The Mani "TETRIS SET" style 4-in-1 multicart (issue #74): a menu program in the first
+ * 32 KB followed by unmodified 32 KB games, each with its own header. The menu selects a
+ * game by writing its 32 KB block number to 0x4000-0x5FFF; the register drives the upper
+ * ROM address lines directly, so the whole 0x0000-0x7FFF window switches to the chosen
+ * block and the plain-ROM game runs unmapped. Power-on maps block 0 (the menu).
+ */
+public class Mani32kMulticart implements MemoryController {
+
+    private final int[] rom;
+
+    private final int blocks;
+
+    private int block;
+
+    public Mani32kMulticart(Rom rom) {
+        this.rom = rom.getRom();
+        this.blocks = Math.max(1, this.rom.length / 0x8000);
+    }
+
+    @Override
+    public boolean accepts(int address) {
+        return (address >= 0x0000 && address < 0x8000) || (address >= 0xa000 && address < 0xc000);
+    }
+
+    @Override
+    public void setByte(int address, int value) {
+        if (address >= 0x4000 && address < 0x6000) {
+            block = value % blocks;
+        }
+    }
+
+    @Override
+    public int getByte(int address) {
+        if (address < 0x8000) {
+            return rom[block * 0x8000 + address];
+        }
+        return 0xff;
+    }
+
+    @Override
+    public Memento<MemoryController> saveToMemento() {
+        return new Mani32kMemento(block);
+    }
+
+    @Override
+    public void restoreFromMemento(Memento<MemoryController> memento) {
+        if (!(memento instanceof Mani32kMemento mem)) {
+            throw new IllegalArgumentException("Invalid memento type");
+        }
+        this.block = mem.block;
+    }
+
+    private record Mani32kMemento(int block) implements Memento<MemoryController> {
+    }
+}