Add the Sachen MMC multicart mapper and unknown-type fallbacks

- Sachen MMC1/MMC2 multicarts (the 4B-xxx 4-in-1 collections and the
  Rocket Games two-in-one carts) get a mapper with the base/mask/bank
  register scheme: the switchable window's bank is
  (base & mask) | (bank & ~mask), the fixed window maps the base bank.
  Detected by their scrambled boot logo (MMC2 carts hide a valid CGB
  half-logo at a later bank's header, which is also their power-on base
  bank). The real cart's header-descrambling lockout is not modelled;
  the boot falls back to the post-boot presets. 4 more of the 8
  attached 4B collections now reach their menus and play (issues
  #73/#74/#75).

- An unknown cartridge-type byte (Pocket Voice's 0xBE and friends)
  falls back to MBC5 banking instead of refusing to load; Pocket Voice
  V2.0 now boots to its recorder UI (issue #71).

- The Wisdom Tree heuristic no longer grabs type-0 dumps under 128 KB:
  those are treated as plain 32 KB ROMs like on hardware (issue #76).

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

@@ -35,6 +35,8 @@ public Cartridge(Rom rom, Battery battery) {
             addressSpace = new Mmm01(rom, battery, false);
         } else if (isDuzMulticart(rom)) {
             addressSpace = new DuzMulticart(rom, battery);
+        } else if (sachenBase(rom) >= 0) {
+            addressSpace = new SachenMmc(rom, sachenBase(rom));
         } else if (type.isHuc1()) {
             addressSpace = new Huc1(rom, battery);
         } else if (type.isHuc3()) {
@@ -60,9 +62,10 @@ public Cartridge(Rom rom, Battery battery) {
             // bad Nintendo logo (the ASIC swaps it after the boot check on hardware) and
             // banking registers at 0x7FE0/0x7FE1 (issue #66)
             addressSpace = new Datel(rom, battery);
-        } else if (rom.getRom().length > 0x8000) {
-            // "ROM only" carts larger than 32 KB are Wisdom Tree style unlicensed
-            // mappers with a single switchable 32 KB window (issue #61)
+        } else if (rom.getRom().length >= 0x20000) {
+            // "ROM only" carts of 128 KB and more are Wisdom Tree style unlicensed
+            // mappers with a single switchable 32 KB window (issue #61); smaller
+            // oversized type-0 dumps are treated as plain 32 KB ROMs like on hardware
             addressSpace = new WisdomTree(rom);
         } else {
             addressSpace = new BasicRom(rom);
@@ -122,6 +125,38 @@ private static boolean isDuzMulticart(Rom rom) {
         return false;
     }
 
+    /**
+     * Detects the Sachen MMC1/MMC2 multicarts (issues #73/#74/#75) and returns the
+     * power-on base bank, or -1 for regular carts. The 4B collections have a header
+     * logo that starts with the first logo byte but is otherwise scrambled (the real
+     * mapper unscrambles it for the boot ROM); the MMC2 carts hide a valid (CGB,
+     * half-checked) logo at the header of a later bank, which is also their boot base.
+     */
+    private static int sachenBase(Rom rom) {
+        int[] data = rom.getRom();
+        if (hasValidLogo(rom) || data.length < 0x10000) {
+            return -1;
+        }
+        // MMC2: a bank >0 carries the real (half) logo
+        for (int bank = 1; bank * 0x4000 + 0x134 <= data.length; bank++) {
+            boolean match = true;
+            for (int i = 0; i < NINTENDO_LOGO.length / 2; i++) {
+                if (data[bank * 0x4000 + 0x104 + i] != NINTENDO_LOGO[i]) {
+                    match = false;
+                    break;
+                }
+            }
+            if (match) {
+                return bank;
+            }
+        }
+        // MMC1 (4B-xxx): scrambled logo that keeps the first byte
+        if (data[0x104] == 0xce && data[0x105] != 0xed) {
+            return 0;
+        }
+        return -1;
+    }
+
     private static boolean hasValidLogo(Rom rom) {
         int[] data = rom.getRom();
         for (int i = 0; i < NINTENDO_LOGO.length; i++) {

core/src/main/java/eu/rekawek/coffeegb/core/memory/cart/Rom.java

@@ -47,7 +47,17 @@ public Rom(byte[] romByteArray, File romFile) throws IOException {
             rom[i] = romByteArray[i] & 0xFF;
         }
 
-        cartridgeType = CartridgeType.getById(rom[0x0147]);
+        CartridgeType type;
+        try {
+            type = CartridgeType.getById(rom[0x0147]);
+        } catch (IllegalArgumentException e) {
+            // unknown/custom mapper byte (unlicensed carts like Pocket Voice, Sachen):
+            // fall back to MBC5 banking instead of refusing to load (issue #71)
+            LOG.warn("Unsupported cartridge type {}, falling back to MBC5",
+                    Integer.toHexString(rom[0x0147]));
+            type = CartridgeType.getById(0x19);
+        }
+        cartridgeType = type;
         title = getTitle(rom);
         LOG.debug("Cartridge {}, type: {}", title, cartridgeType);
         gameboyColorFlag = GameboyColorFlag.getFlag(rom[0x0143]);

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

@@ -0,0 +1,90 @@
+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 Sachen MMC1/MMC2 multicart mapper ("4B-xxx" 4-in-1 collections and the two-game
+ * MMC2 carts, issues #73/#74/#75). Three registers control the mapping:
+ *
+ * <ul>
+ *   <li>{@code 0x2000-0x3FFF} - ROM bank of the switchable 0x4000-0x7FFF window;</li>
+ *   <li>{@code 0x4000-0x5FFF} - ROM bank mask: bits set in the mask come from the base
+ *       register, the rest from the bank register (the multicart "cage");</li>
+ *   <li>{@code 0x6000-0x7FFF} - base ROM bank, also mapped at 0x0000-0x3FFF.</li>
+ * </ul>
+ *
+ * <p>The header-scrambling lockout of the real cart (which presents a fake logo to the
+ * boot ROM) is not modelled; the FAST_FORWARD boot timeout falls back to the post-boot
+ * presets instead. MMC2 carts boot with a base of 0x10, where their (CGB, half-size)
+ * boot logo lives.
+ */
+public class SachenMmc implements MemoryController {
+
+    private final int[] rom;
+
+    private final int romBanks;
+
+    private int bank = 1;
+
+    private int mask;
+
+    private int base;
+
+    public SachenMmc(Rom rom, int initialBase) {
+        this.rom = rom.getRom();
+        this.romBanks = Math.max(2, this.rom.length / 0x4000);
+        this.base = initialBase;
+    }
+
+    @Override
+    public boolean accepts(int address) {
+        return address >= 0x0000 && address < 0x8000;
+    }
+
+    @Override
+    public void setByte(int address, int value) {
+        if (address >= 0x2000 && address < 0x4000) {
+            bank = value & 0xff;
+        } else if (address >= 0x4000 && address < 0x6000) {
+            mask = value & 0xff;
+        } else if (address >= 0x6000 && address < 0x8000) {
+            base = value & 0xff;
+        }
+    }
+
+    @Override
+    public int getByte(int address) {
+        if (address < 0x4000) {
+            return rom[(base % romBanks) * 0x4000 + address];
+        } else if (address < 0x8000) {
+            int b = bank == 0 ? 1 : bank;
+            int effective = ((base & mask) | (b & ~mask)) % romBanks;
+            return rom[effective * 0x4000 + (address - 0x4000)];
+        }
+        return 0xff;
+    }
+
+    @Override
+    public void flushRam() {
+    }
+
+    @Override
+    public Memento<MemoryController> saveToMemento() {
+        return new SachenMemento(bank, mask, base);
+    }
+
+    @Override
+    public void restoreFromMemento(Memento<MemoryController> memento) {
+        if (!(memento instanceof SachenMemento mem)) {
+            throw new IllegalArgumentException("Invalid memento type");
+        }
+        this.bank = mem.bank;
+        this.mask = mem.mask;
+        this.base = mem.base;
+    }
+
+    private record SachenMemento(int bank, int mask, int base) implements Memento<MemoryController> {
+    }
+}