From 9cbc746ba64396a33e99b76d9f538e5800d063ee Mon Sep 17 00:00:00 2001
From: Noone <noone@nowhere.com>
Date: Thu, 28 May 2026 00:01:10 -0400
Subject: [PATCH 1/2] feat(adventure): Add deck import/export and inventory
 management to Adventure mode

Adds multi-format deck import (Arena, MTGO, native .dck), collection export
in Arena format, and a mark-for-sale workflow. Available via both console
commands and new UI buttons in the deck selection screen.

Console commands:
- load deck <path>       Import deck, auto-give missing cards
- load deck buy <path>   Import deck, purchase missing cards with gold
- check deck <path>      Report which cards are missing
- save deck <path>       Export selected deck as .dck
- export collection <path>  Export full collection in Arena format
- mark sell <path>       Mark listed cards for auto-sell

UI (DeckSelectScene):
- Import Deck button with 3-mode dialog (free/buy/check-only)
- Export Deck, Export Collection, Mark for Sale buttons

Cross-platform file path handling (Unix/Mac/Windows) with ~ expansion.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../adventure/player/AdventurePlayer.java     |  34 +++
 .../adventure/scene/DeckSelectScene.java      | 140 +++++++++++
 .../stage/ConsoleCommandInterpreter.java      |  59 +++++
 .../src/forge/adventure/util/CardUtil.java    | 237 ++++++++++++++++++
 4 files changed, 470 insertions(+)

diff --git a/forge-gui-mobile/src/forge/adventure/player/AdventurePlayer.java b/forge-gui-mobile/src/forge/adventure/player/AdventurePlayer.java
index c7cfba8e1bf..b1d33bb3fa6 100644
--- a/forge-gui-mobile/src/forge/adventure/player/AdventurePlayer.java
+++ b/forge-gui-mobile/src/forge/adventure/player/AdventurePlayer.java
@@ -1587,6 +1587,40 @@ public int copyDeck() {
         return -1;
     }
 
+    /**
+     * Finds the first empty deck slot, expanding if needed.
+     * Returns -1 only if all 99 slots are occupied.
+     */
+    public int findFirstEmptySlot() {
+        for (int i = 0; i < maxDeckCount; i++) {
+            if (i >= getDeckCount()) addDeck();
+            if (isEmptyDeck(i)) return i;
+        }
+        if (getDeckCount() < 99) {
+            maxDeckCount = Math.min(maxDeckCount + 1, 99);
+            addDeck();
+            return getDeckCount() - 1;
+        }
+        return -1;
+    }
+
+    /**
+     * Replaces the contents of a deck slot with an imported deck.
+     * Clears all existing sections and copies from the source.
+     */
+    public void importIntoSlot(int slot, Deck importedDeck) {
+        Deck target = getDeck(slot);
+        for (DeckSection section : DeckSection.values()) {
+            if (target.has(section)) target.get(section).clear();
+        }
+        for (java.util.Map.Entry<DeckSection, CardPool> entry : importedDeck) {
+            target.getOrCreate(entry.getKey()).addAll(entry.getValue());
+        }
+        if (importedDeck.getName() != null && !importedDeck.getName().isEmpty()) {
+            target.setName(importedDeck.getName());
+        }
+    }
+
     private void ensureDeckLoadoutsSize() {
         while (deckLoadouts.size() < getDeckCount()) {
             deckLoadouts.add(null);
diff --git a/forge-gui-mobile/src/forge/adventure/scene/DeckSelectScene.java b/forge-gui-mobile/src/forge/adventure/scene/DeckSelectScene.java
index d2dfad086c0..75bf04bb77f 100644
--- a/forge-gui-mobile/src/forge/adventure/scene/DeckSelectScene.java
+++ b/forge-gui-mobile/src/forge/adventure/scene/DeckSelectScene.java
@@ -11,14 +11,20 @@
 import forge.Forge;
 import forge.adventure.player.AdventurePlayer;
 import forge.adventure.stage.GameHUD;
+import forge.adventure.util.CardUtil;
 import forge.adventure.util.Controls;
 import forge.adventure.util.Current;
+import forge.deck.io.DeckSerializer;
+import forge.util.FileUtil;
+
+import java.io.File;
 
 public class DeckSelectScene extends UIScene {
     private final IntMap<TextraButton> buttons = new IntMap<>();
     private final IntMap<Label> labels = new IntMap<>();
     Color defColor;
     TextField textInput;
+    TextField filePathInput;
     Table layout;
     TextraLabel header;
     TextraButton back, edit, rename, add;
@@ -49,6 +55,17 @@ public DeckSelectScene() {
         this.layoutDeckButtons();
 
         textInput = Controls.newTextField("");
+        filePathInput = Controls.newTextField("");
+
+        root.row();
+        Table fileOpsTable = new Table();
+        fileOpsTable.add(Controls.newTextButton("Import Deck", this::importDeck)).pad(2).expandX().fillX();
+        fileOpsTable.add(Controls.newTextButton("Export Deck", this::exportDeck)).pad(2).expandX().fillX();
+        fileOpsTable.row();
+        fileOpsTable.add(Controls.newTextButton("Export Collection", this::exportCollection)).pad(2).expandX().fillX();
+        fileOpsTable.add(Controls.newTextButton("Mark for Sale", this::markForSale)).pad(2).expandX().fillX();
+        root.add(fileOpsTable).colspan(2).fillX();
+
         back = ui.findActor("return");
         edit = ui.findActor("edit");
         rename = ui.findActor("rename");
@@ -242,4 +259,127 @@ private void edit() {
         editScene.loadEvent(null);
         Forge.switchScene(editScene);
     }
+
+    private void importDeck() {
+        Dialog modeDialog = new Dialog("Import Deck", Controls.getSkin());
+        modeDialog.getContentTable().add(Controls.newTextraLabel("Choose import mode:"));
+        modeDialog.button(Controls.newTextButton("Give missing (free)", () -> {
+            removeDialog();
+            showFilePathDialog("Import Deck - File Path", path -> {
+                File file = CardUtil.resolveFilePath(path);
+                if (!file.exists()) {
+                    showResultDialog("Import Deck", "File not found: " + file.getAbsolutePath());
+                    return;
+                }
+                CardUtil.ImportResult result = CardUtil.importDeckFromFile(file, Current.player(), CardUtil.ImportMode.GIVE_MISSING);
+                if (!result.success) {
+                    showResultDialog("Import Deck", "Import failed: " + result.message);
+                } else {
+                    refreshDeckButtons();
+                    select(result.slot);
+                    showResultDialog("Import Deck", String.format("Imported '%s' into slot %d (%d cards added to collection)",
+                        result.deckName, result.slot + 1, result.cardsAdded));
+                }
+            });
+        }));
+        modeDialog.button(Controls.newTextButton("Buy missing cards", () -> {
+            removeDialog();
+            showFilePathDialog("Import Deck - File Path", path -> {
+                File file = CardUtil.resolveFilePath(path);
+                if (!file.exists()) {
+                    showResultDialog("Import Deck", "File not found: " + file.getAbsolutePath());
+                    return;
+                }
+                CardUtil.ImportResult result = CardUtil.importDeckFromFile(file, Current.player(), CardUtil.ImportMode.BUY_MISSING);
+                if (!result.success) {
+                    showResultDialog("Import Deck", "Import failed: " + result.message);
+                } else {
+                    refreshDeckButtons();
+                    select(result.slot);
+                    showResultDialog("Import Deck", String.format("Imported '%s' into slot %d (%d cards purchased)",
+                        result.deckName, result.slot + 1, result.cardsAdded));
+                }
+            });
+        }));
+        modeDialog.button(Controls.newTextButton("Check only (report)", () -> {
+            removeDialog();
+            showFilePathDialog("Import Deck - File Path", path -> {
+                File file = CardUtil.resolveFilePath(path);
+                if (!file.exists()) {
+                    showResultDialog("Import Deck", "File not found: " + file.getAbsolutePath());
+                    return;
+                }
+                CardUtil.ImportResult result = CardUtil.importDeckFromFile(file, Current.player(), CardUtil.ImportMode.REPORT_ONLY);
+                showResultDialog("Import Deck", result.formatMissingReport());
+            });
+        }));
+        showDialog(modeDialog);
+    }
+
+    private void exportDeck() {
+        showFilePathDialog("Export Deck - Save Path", path -> {
+            File file = CardUtil.resolveFilePath(path);
+            try {
+                DeckSerializer.writeDeck(Current.player().getSelectedDeck(), file);
+                showResultDialog("Export Deck", "Saved deck to " + file.getAbsolutePath());
+            } catch (Exception e) {
+                showResultDialog("Export Deck", "Save failed: " + e.getMessage());
+            }
+        });
+    }
+
+    private void exportCollection() {
+        showFilePathDialog("Export Collection - Save Path", path -> {
+            File file = CardUtil.resolveFilePath(path);
+            try {
+                String arenaList = CardUtil.exportCollectionAsArena(Current.player());
+                FileUtil.writeFile(file, arenaList);
+                showResultDialog("Export Collection", String.format("Exported %d unique cards to %s (Arena format)",
+                    Current.player().getCards().countDistinct(), file.getAbsolutePath()));
+            } catch (Exception e) {
+                showResultDialog("Export Collection", "Export failed: " + e.getMessage());
+            }
+        });
+    }
+
+    private void markForSale() {
+        showFilePathDialog("Mark for Sale - File Path", path -> {
+            File file = CardUtil.resolveFilePath(path);
+            if (!file.exists()) {
+                showResultDialog("Mark for Sale", "File not found: " + file.getAbsolutePath());
+                return;
+            }
+            CardUtil.MarkSellResult result = CardUtil.markCardsForSale(file, Current.player());
+            if (!result.success) {
+                showResultDialog("Mark for Sale", "Mark failed: " + result.message);
+            } else {
+                showResultDialog("Mark for Sale", String.format("Marked %d cards for sale (%d skipped: in decks/already marked/not owned)",
+                    result.marked, result.skipped));
+            }
+        });
+    }
+
+    private void showFilePathDialog(String title, java.util.function.Consumer<String> onConfirm) {
+        filePathInput.setText("");
+        Dialog dialog = createGenericDialog(title, null,
+            Forge.getLocalizer().getMessage("lblOK"),
+            Forge.getLocalizer().getMessage("lblAbort"), () -> {
+                String path = filePathInput.getText();
+                removeDialog();
+                if (path != null && !path.trim().isEmpty()) {
+                    onConfirm.accept(path.trim());
+                }
+            }, this::removeDialog);
+        dialog.getContentTable().add(Controls.newLabel("File path:")).align(Align.left).colspan(2);
+        dialog.getContentTable().row();
+        dialog.getContentTable().add(filePathInput).fillX().expandX().colspan(2);
+        dialog.getContentTable().row();
+        showDialog(dialog);
+    }
+
+    private void showResultDialog(String title, String message) {
+        Dialog dialog = createGenericDialog(title, message,
+            Forge.getLocalizer().getMessage("lblOK"), null, this::removeDialog, null);
+        showDialog(dialog);
+    }
 }
diff --git a/forge-gui-mobile/src/forge/adventure/stage/ConsoleCommandInterpreter.java b/forge-gui-mobile/src/forge/adventure/stage/ConsoleCommandInterpreter.java
index 73a433a9d32..b083df10dd8 100644
--- a/forge-gui-mobile/src/forge/adventure/stage/ConsoleCommandInterpreter.java
+++ b/forge-gui-mobile/src/forge/adventure/stage/ConsoleCommandInterpreter.java
@@ -27,8 +27,11 @@
 import forge.model.CardBlock;
 import forge.model.FModel;
 import forge.screens.CoverScreen;
+import forge.deck.io.DeckSerializer;
 import forge.util.Aggregates;
+import forge.util.FileUtil;
 
+import java.io.File;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -561,5 +564,61 @@ private ConsoleCommandInterpreter() {
             
             return "Exit the map to reset it.";
         });
+        registerCommand(new String[]{"load", "deck"}, s -> {
+            if (s.length < 1) return "Command needs 1 parameter: file path.";
+            File file = CardUtil.resolveFilePath(s[0]);
+            if (!file.exists()) return "File not found: " + file.getAbsolutePath();
+            CardUtil.ImportResult result = CardUtil.importDeckFromFile(file, Current.player(), CardUtil.ImportMode.GIVE_MISSING);
+            if (!result.success) return "Import failed: " + result.message;
+            return String.format("Imported '%s' into slot %d (%d cards added to collection)",
+                result.deckName, result.slot + 1, result.cardsAdded);
+        });
+        registerCommand(new String[]{"load", "deck", "buy"}, s -> {
+            if (s.length < 1) return "Command needs 1 parameter: file path.";
+            File file = CardUtil.resolveFilePath(s[0]);
+            if (!file.exists()) return "File not found: " + file.getAbsolutePath();
+            CardUtil.ImportResult result = CardUtil.importDeckFromFile(file, Current.player(), CardUtil.ImportMode.BUY_MISSING);
+            if (!result.success) return "Import failed: " + result.message;
+            return String.format("Imported '%s' into slot %d (%d cards purchased)",
+                result.deckName, result.slot + 1, result.cardsAdded);
+        });
+        registerCommand(new String[]{"check", "deck"}, s -> {
+            if (s.length < 1) return "Command needs 1 parameter: file path.";
+            File file = CardUtil.resolveFilePath(s[0]);
+            if (!file.exists()) return "File not found: " + file.getAbsolutePath();
+            CardUtil.ImportResult result = CardUtil.importDeckFromFile(file, Current.player(), CardUtil.ImportMode.REPORT_ONLY);
+            return result.formatMissingReport();
+        });
+        registerCommand(new String[]{"save", "deck"}, s -> {
+            if (s.length < 1) return "Command needs 1 parameter: file path.";
+            File file = CardUtil.resolveFilePath(s[0]);
+            try {
+                DeckSerializer.writeDeck(Current.player().getSelectedDeck(), file);
+                return "Saved deck to " + file.getAbsolutePath();
+            } catch (Exception e) {
+                return "Save failed: " + e.getMessage();
+            }
+        });
+        registerCommand(new String[]{"export", "collection"}, s -> {
+            if (s.length < 1) return "Command needs 1 parameter: file path.";
+            File file = CardUtil.resolveFilePath(s[0]);
+            try {
+                String arenaList = CardUtil.exportCollectionAsArena(Current.player());
+                FileUtil.writeFile(file, arenaList);
+                return String.format("Exported %d unique cards to %s (Arena format)",
+                    Current.player().getCards().countDistinct(), file.getAbsolutePath());
+            } catch (Exception e) {
+                return "Export failed: " + e.getMessage();
+            }
+        });
+        registerCommand(new String[]{"mark", "sell"}, s -> {
+            if (s.length < 1) return "Command needs 1 parameter: file path.";
+            File file = CardUtil.resolveFilePath(s[0]);
+            if (!file.exists()) return "File not found: " + file.getAbsolutePath();
+            CardUtil.MarkSellResult result = CardUtil.markCardsForSale(file, Current.player());
+            if (!result.success) return "Mark failed: " + result.message;
+            return String.format("Marked %d cards for sale (%d skipped: in decks/already marked/not owned)",
+                result.marked, result.skipped);
+        });
     }
 }
diff --git a/forge-gui-mobile/src/forge/adventure/util/CardUtil.java b/forge-gui-mobile/src/forge/adventure/util/CardUtil.java
index 3484e3bd46c..b4423b07a07 100644
--- a/forge-gui-mobile/src/forge/adventure/util/CardUtil.java
+++ b/forge-gui-mobile/src/forge/adventure/util/CardUtil.java
@@ -12,10 +12,15 @@
 import forge.card.DeckHints.Type;
 import forge.card.mana.ManaCost;
 import forge.card.mana.ManaCostShard;
+import forge.adventure.player.AdventurePlayer;
+import forge.deck.CardPool;
 import forge.deck.Deck;
+import forge.deck.DeckRecognizer;
 import forge.deck.DeckSection;
 import forge.deck.DeckgenUtil;
 import forge.deck.io.DeckSerializer;
+import forge.util.FileUtil;
+import forge.util.ItemPool;
 import forge.game.GameFormat;
 import forge.game.GameType;
 import forge.item.BoosterPack;
@@ -27,6 +32,7 @@
 import forge.util.Aggregates;
 import forge.util.IterableUtil;
 import forge.card.MagicColor;
+import java.io.File;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -977,4 +983,235 @@ public static PaperCard ensureAllowedEdition(PaperCard card) {
         }
         return card;
     }
+
+    // ===== Deck Import/Export Feature =====
+
+    public enum ImportMode {
+        GIVE_MISSING,
+        BUY_MISSING,
+        REPORT_ONLY
+    }
+
+    public static class MissingCard {
+        public final PaperCard card;
+        public final int quantity;
+        public MissingCard(PaperCard card, int quantity) {
+            this.card = card;
+            this.quantity = quantity;
+        }
+    }
+
+    public static class ImportResult {
+        public final boolean success;
+        public final String message;
+        public final String deckName;
+        public final int slot;
+        public final int cardsAdded;
+        public final List<MissingCard> missingCards;
+
+        private ImportResult(boolean success, String message, String deckName, int slot, int cardsAdded, List<MissingCard> missingCards) {
+            this.success = success;
+            this.message = message;
+            this.deckName = deckName;
+            this.slot = slot;
+            this.cardsAdded = cardsAdded;
+            this.missingCards = missingCards != null ? missingCards : new ArrayList<>();
+        }
+
+        public static ImportResult success(int slot, String deckName, int cardsAdded) {
+            return new ImportResult(true, null, deckName, slot, cardsAdded, null);
+        }
+
+        public static ImportResult failure(String message) {
+            return new ImportResult(false, message, null, -1, 0, null);
+        }
+
+        public static ImportResult reportOnly(String deckName, List<MissingCard> missing) {
+            return new ImportResult(true, null, deckName, -1, 0, missing);
+        }
+
+        public String formatMissingReport() {
+            if (missingCards.isEmpty()) return "You own all cards in this deck!";
+            StringBuilder sb = new StringBuilder();
+            sb.append("Missing cards for \"").append(deckName != null ? deckName : "Unknown").append("\":\n");
+            for (MissingCard mc : missingCards) {
+                sb.append(mc.quantity).append("x ").append(mc.card.getName()).append('\n');
+            }
+            sb.append("(").append(missingCards.size()).append(" unique cards missing)");
+            return sb.toString();
+        }
+    }
+
+    public static class MarkSellResult {
+        public final boolean success;
+        public final String message;
+        public final int marked;
+        public final int skipped;
+
+        private MarkSellResult(boolean success, String message, int marked, int skipped) {
+            this.success = success;
+            this.message = message;
+            this.marked = marked;
+            this.skipped = skipped;
+        }
+
+        public static MarkSellResult success(int marked, int skipped) {
+            return new MarkSellResult(true, null, marked, skipped);
+        }
+
+        public static MarkSellResult failure(String message) {
+            return new MarkSellResult(false, message, 0, 0);
+        }
+    }
+
+    public static File resolveFilePath(String rawPath) {
+        String normalized = rawPath.replace('\\', File.separatorChar)
+                                   .replace('/', File.separatorChar);
+        if (normalized.startsWith("~" + File.separator) || normalized.equals("~")) {
+            normalized = System.getProperty("user.home") + normalized.substring(1);
+        }
+        File file = new File(normalized);
+        if (!file.isAbsolute()) {
+            file = new File(System.getProperty("user.home"), normalized);
+        }
+        return file;
+    }
+
+    public static Deck parseDeckFile(File file) {
+        if (!file.exists()) return null;
+        List<String> lines = FileUtil.readFile(file);
+        if (lines == null || lines.isEmpty()) return null;
+
+        boolean isNativeDck = lines.stream().anyMatch(l ->
+            l.trim().equals("[metadata]") || l.trim().equals("[Main]"));
+
+        if (isNativeDck) {
+            return DeckSerializer.fromFile(file);
+        }
+
+        DeckRecognizer recognizer = new DeckRecognizer();
+        List<DeckRecognizer.Token> tokens = recognizer.parseCardList(
+            lines.toArray(new String[0]));
+
+        Deck deck = new Deck();
+        for (DeckRecognizer.Token t : tokens) {
+            if (t.getType() == DeckRecognizer.TokenType.DECK_NAME) {
+                deck.setName(t.getText());
+            } else if (t.isTokenForDeck()) {
+                deck.getOrCreate(t.getTokenSection()).add(t.getCard(), t.getQuantity());
+            }
+        }
+
+        if (deck.getName() == null || deck.getName().isEmpty()) {
+            String fname = file.getName();
+            int dot = fname.lastIndexOf('.');
+            deck.setName(dot > 0 ? fname.substring(0, dot) : fname);
+        }
+        return deck;
+    }
+
+    public static ImportResult importDeckFromFile(File file, AdventurePlayer player, ImportMode mode) {
+        Deck importedDeck = parseDeckFile(file);
+        if (importedDeck == null) return ImportResult.failure("Could not parse file");
+
+        List<MissingCard> missingCards = new ArrayList<>();
+        for (java.util.Map.Entry<DeckSection, CardPool> entry : importedDeck) {
+            for (java.util.Map.Entry<PaperCard, Integer> cardEntry : entry.getValue()) {
+                PaperCard card = cardEntry.getKey();
+                int needed = cardEntry.getValue();
+                int owned = player.getCards().count(card);
+                if (owned < needed) {
+                    missingCards.add(new MissingCard(card, needed - owned));
+                }
+            }
+        }
+
+        if (mode == ImportMode.REPORT_ONLY) {
+            return ImportResult.reportOnly(importedDeck.getName(), missingCards);
+        }
+
+        if (mode == ImportMode.BUY_MISSING) {
+            int totalCost = 0;
+            for (MissingCard mc : missingCards) {
+                totalCost += player.cardSellPrice(mc.card) * mc.quantity;
+            }
+            if (player.getGold() < totalCost) {
+                return ImportResult.failure(String.format(
+                    "Not enough gold. Need %d, have %d. Missing %d cards.",
+                    totalCost, player.getGold(), missingCards.size()));
+            }
+            player.giveGold(-totalCost);
+        }
+
+        int cardsAdded = 0;
+        for (MissingCard mc : missingCards) {
+            player.addCard(mc.card, mc.quantity);
+            cardsAdded += mc.quantity;
+        }
+
+        int slot = player.findFirstEmptySlot();
+        if (slot == -1) return ImportResult.failure("All deck slots full (max 99)");
+        player.importIntoSlot(slot, importedDeck);
+
+        return ImportResult.success(slot, importedDeck.getName(), cardsAdded);
+    }
+
+    public static MarkSellResult markCardsForSale(File file, AdventurePlayer player) {
+        Deck parsed = parseDeckFile(file);
+        if (parsed == null) return MarkSellResult.failure("Could not parse file");
+
+        int marked = 0;
+        int skipped = 0;
+        CardPool collection = player.getCards();
+        ItemPool<PaperCard> autoSell = player.getAutoSellCards();
+
+        for (java.util.Map.Entry<DeckSection, CardPool> entry : parsed) {
+            for (java.util.Map.Entry<PaperCard, Integer> cardEntry : entry.getValue()) {
+                PaperCard card = cardEntry.getKey();
+                int requestedQty = cardEntry.getValue();
+
+                int owned = collection.count(card);
+                int inDecks = player.getCopiesUsedInDecks(card);
+                int alreadyMarked = autoSell.count(card);
+                int canMark = owned - inDecks - alreadyMarked;
+
+                if (card.getMarkedFlags() != null && card.getMarkedFlags().noSellValue) {
+                    skipped += requestedQty;
+                    continue;
+                }
+
+                int toMark = Math.min(requestedQty, Math.max(canMark, 0));
+                if (toMark > 0) {
+                    autoSell.add(card, toMark);
+                    marked += toMark;
+                }
+                skipped += (requestedQty - toMark);
+            }
+        }
+
+        return MarkSellResult.success(marked, skipped);
+    }
+
+    public static String exportCollectionAsArena(AdventurePlayer player) {
+        StringBuilder sb = new StringBuilder();
+        CardPool collection = player.getCards();
+        List<java.util.Map.Entry<PaperCard, Integer>> sorted = new ArrayList<>();
+        for (java.util.Map.Entry<PaperCard, Integer> e : collection) sorted.add(e);
+        sorted.sort(java.util.Comparator.comparing(e -> e.getKey().getName()));
+        for (java.util.Map.Entry<PaperCard, Integer> entry : sorted) {
+            PaperCard card = entry.getKey();
+            int count = entry.getValue();
+            String set = card.getEdition();
+            String collNum = card.getCollectorNumber();
+            sb.append(count).append(' ').append(card.getName());
+            if (set != null && !set.isEmpty()) {
+                sb.append(" (").append(set).append(')');
+                if (collNum != null && !collNum.isEmpty()) {
+                    sb.append(' ').append(collNum);
+                }
+            }
+            sb.append('\n');
+        }
+        return sb.toString();
+    }
 }

From 7a3a86fab6155ceb75196a4ad64780ee7e4f531c Mon Sep 17 00:00:00 2001
From: Noone <noone@nowhere.com>
Date: Thu, 28 May 2026 02:22:01 -0400
Subject: [PATCH 2/2] =?UTF-8?q?fix:=20Veil=20of=20Summer=20crash=20?=
 =?UTF-8?q?=E2=80=94=20use=20Hexproof=20keyword=20instance=20instead=20of?=
 =?UTF-8?q?=20raw=20string=20parsing?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PlayerFactoryUtil.addStaticAbility() crashed with ArrayIndexOutOfBoundsException
when processing "Hexproof:Black" (2-part format) because it expected a 3-part
"Hexproof:<validSource>:<description>" format.

Now uses instanceof Hexproof pattern matching to access getValidType() and
getTitle() directly, consistent with CardFactoryUtil's approach for card hexproof.

Fixes crash when Veil of Summer resolves giving player hexproof from black/blue.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../forge/game/player/PlayerFactoryUtil.java  | 28 +++++++++++--------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/forge-game/src/main/java/forge/game/player/PlayerFactoryUtil.java b/forge-game/src/main/java/forge/game/player/PlayerFactoryUtil.java
index 34933815924..4876d433533 100644
--- a/forge-game/src/main/java/forge/game/player/PlayerFactoryUtil.java
+++ b/forge-game/src/main/java/forge/game/player/PlayerFactoryUtil.java
@@ -2,6 +2,7 @@
 
 import forge.game.card.Card;
 import forge.game.card.CardFactoryUtil;
+import forge.game.keyword.Hexproof;
 import forge.game.keyword.KeywordInterface;
 import forge.game.replacement.ReplacementEffect;
 import forge.game.replacement.ReplacementHandler;
@@ -12,23 +13,28 @@ public class PlayerFactoryUtil {
     public static void addStaticAbility(final KeywordInterface inst, final Player player) {
         String keyword = inst.getOriginal();
 
-        if (keyword.startsWith("Hexproof")) {
-            final StringBuilder sbDesc = new StringBuilder("Hexproof");
+        if (keyword.startsWith("Hexproof")
+                && inst instanceof Hexproof hexproof) {
             final StringBuilder sbValid = new StringBuilder();
 
-            if (!keyword.equals("Hexproof")) {
-                final String[] k = keyword.split(":");
-
-                sbDesc.append(" from ").append(k[2]);
-                sbValid.append("| ValidSource$ ").append(k[1]);
+            if (!hexproof.getValidType().isEmpty()) {
+                sbValid.append("| ValidSource$ ")
+                    .append(hexproof.getValidType());
             }
 
-            String effect = "Mode$ CantTarget | ValidTarget$ Player.You | Secondary$ True "
-                    + sbValid.toString() + " | Activator$ Opponent | EffectZone$ Command | Description$ "
-                    + sbDesc.toString() + " (" + inst.getReminderText() + ")";
+            String effect = "Mode$ CantTarget"
+                + " | ValidTarget$ Player.You"
+                + " | Secondary$ True "
+                + sbValid
+                + " | Activator$ Opponent"
+                + " | EffectZone$ Command"
+                + " | Description$ "
+                + inst.getTitle()
+                + " (" + inst.getReminderText() + ")";
 
             final Card card = player.getKeywordCard();
-            inst.addStaticAbility(StaticAbility.create(effect, card, card.getCurrentState(), false));
+            inst.addStaticAbility(StaticAbility.create(
+                effect, card, card.getCurrentState(), false));
         } else if (keyword.equals("Shroud")) {
             String effect = "Mode$ CantTarget | ValidTarget$ Player.You | Secondary$ True "
                     + "| EffectZone$ Command | Description$ Shroud (" + inst.getReminderText() + ")";