Feature/11167: Randomizer mode for Adventure

forge-core/src/main/java/forge/item/AdventurePaperCard.java

@@ -0,0 +1,33 @@
+package forge.item;
+
+import forge.card.CardRarity;
+import forge.card.CardRules;
+
+/// Extension of the PaperCard class with features specific to Adventure mode so as not to pollute the model used for the classic game mode.
+public class AdventurePaperCard extends PaperCard {
+    private transient boolean isLocked;
+
+    public AdventurePaperCard(CardRules rules0, String edition0, CardRarity rarity0) {
+        super(rules0, edition0, rarity0);
+    }
+
+    public AdventurePaperCard(PaperCard copyFrom, PaperCardFlags flags) {
+        super(copyFrom, flags);
+    }
+
+    public AdventurePaperCard(CardRules rules0, String edition0, CardRarity rarity0, int artIndex0, boolean foil0, String collectorNumber0, String artist0, String functionalVariant) {
+        super(rules0, edition0, rarity0, artIndex0, foil0, collectorNumber0, artist0, functionalVariant);
+    }
+
+    protected AdventurePaperCard(CardRules rules, String edition, CardRarity rarity, int artIndex, boolean foil, String collectorNumber, String artist, String functionalVariant, PaperCardFlags flags) {
+        super(rules, edition, rarity, artIndex, foil, collectorNumber, artist, functionalVariant, flags);
+    }
+
+    public boolean isLocked() {
+        return isLocked;
+    }
+
+    public void setLocked(boolean locked) {
+        isLocked = locked;
+    }
+}

forge-gui-mobile/src/forge/adventure/archipelago/ArchipelagoCheckTypes.java

@@ -0,0 +1,8 @@
+package forge.adventure.archipelago;
+
+public enum ArchipelagoCheckTypes {
+    COLORLESS_BATTLE_WON, WHITE_BATTLE_WON, BLUE_BATTLE_WON, BLACK_BATTLE_WON, RED_BATTLE_WON, GREEN_BATTLE_WON,
+    COLORLESS_TOWN_QUESTS, WHITE_TOWN_QUESTS, BLUE_TOWN_QUESTS, BLACK_TOWN_QUESTS, RED_TOWN_QUESTS, GREEN_TOWN_QUESTS,
+    COLORLESS_TOWN_EVENTS, WHITE_TOWN_EVENTS, BLUE_TOWN_EVENTS, BLACK_TOWN_EVENTS, RED_TOWN_EVENTS, GREEN_TOWN_EVENTS,
+    TOTAL_CARDS_EARNED
+}

forge-gui-mobile/src/forge/adventure/archipelago/ArchipelagoColors.java

@@ -0,0 +1,8 @@
+package forge.adventure.archipelago;
+
+public class ArchipelagoColors {
+    public static final String Cyan = "{COLOR=#00CCCC}";
+    public static final String Plum = "{COLOR=#AF99EF}";
+    public static final String Salmon = "{COLOR=#FA8072}";
+    public static final String Green = "{COLOR=#00b359}";
+}

forge-gui-mobile/src/forge/adventure/archipelago/ArchipelagoMode.java

@@ -0,0 +1,6 @@
+package forge.adventure.archipelago;
+
+public enum ArchipelagoMode {
+    disabled,
+    solo_randomizer
+}

forge-gui-mobile/src/forge/adventure/archipelago/ArchipelagoUtil.java

@@ -0,0 +1,112 @@
+package forge.adventure.archipelago;
+
+import com.badlogic.gdx.graphics.Color;
+import com.badlogic.gdx.graphics.g2d.Batch;
+import com.badlogic.gdx.graphics.g2d.TextureRegion;
+import com.badlogic.gdx.utils.Array;
+import forge.Graphics;
+import forge.adventure.data.RewardData;
+import forge.adventure.util.Config;
+import forge.adventure.util.Reward;
+import forge.assets.FImage;
+import forge.assets.FSkinImage;
+
+public class ArchipelagoUtil {
+    private static final FImage CARD_LOCKED_ICON = FSkinImage.LOCK;
+    public static final int TOTAL_AMOUNT_OF_SET_UNLOCK_CHECKS = 100;
+    public static final String[] REGION_NAMES = {"waste", "white", "blue", "black", "red", "green"};
+    public static void drawLockedCardOverlay(
+            Batch batch, float x, float y, float w, float h) {
+        // Draw lock icon
+        // Normalize bounds (works for flipped cards too)
+        float drawX = Math.min(x, x + w);
+        float drawY = Math.min(y, y + h);
+        float drawW = Math.abs(w);
+        float drawH = Math.abs(h);
+
+        // Lock size
+        float lockSize = drawW * 0.25f;
+
+        // Centered horizontally, near visual top
+        float lockX = drawX + (drawW - lockSize) / 2f;
+        float lockY = drawY + drawH - lockSize - (drawH * 0.05f);
+
+        // Draw lock
+        TextureRegion lockIcon = FSkinImage.LOCK.getTextureRegion();
+        batch.draw(lockIcon, lockX, lockY, lockSize, lockSize);
+    }
+
+    public static void drawLockedCardOverlay(Graphics g, float x, float y, float w, float h) {
+        float lockSize = w * 0.25f;
+        float lockX = x + (w - lockSize) / 2f;
+        float lockY = y + h * 0.05f;
+        CARD_LOCKED_ICON.draw(g, lockX, lockY, lockSize, lockSize);
+
+        // Draw the card darker than the rest to show it's not unlocked.
+        float oldalpha = g.getfloatAlphaComposite();
+        g.setAlphaComposite(0.25f);
+        g.fillRect(Color.BLACK, x, y, w, h);
+        g.setAlphaComposite(oldalpha);
+    }
+
+    private static TextureRegion getRegionRune(String regionName) {
+        return switch (regionName.toLowerCase()) {
+            case "white" -> Config.instance().getItemSprite("WhiteRune");
+            case "blue" -> Config.instance().getItemSprite("BlueRune");
+            case "black" -> Config.instance().getItemSprite("BlackRune");
+            case "red" -> Config.instance().getItemSprite("RedRune");
+            case "green" -> Config.instance().getItemSprite("GreenRune");
+            default -> null;
+        };
+    }
+
+    public static void updateLastTraversedRegionOnTeleport(String command) {
+        String loweredCommand = command.toLowerCase();
+        ArchipelagoData apData = ArchipelagoData.getInstance();
+        if (loweredCommand.contains("spawn")) { apData.setLastTraversedRegion("waste"); }
+        if (loweredCommand.contains("plains")) { apData.setLastTraversedRegion("white"); }
+        if (loweredCommand.contains("island")) { apData.setLastTraversedRegion("blue"); }
+        if (loweredCommand.contains("swamp")) { apData.setLastTraversedRegion("black"); }
+        if (loweredCommand.contains("mountain")) { apData.setLastTraversedRegion("red"); }
+        if (loweredCommand.contains("forest")) { apData.setLastTraversedRegion("green"); }
+    }
+
+    public static void drawLockedRegionOverhead(Batch batch, String regionName, float centerX, float baseY, float alpha) {
+        TextureRegion rune = getRegionRune(regionName);
+        if (rune == null)
+            return;
+
+        float size = 24f; // world-space size; tweak if needed
+        float x = centerX - size / 2f;
+        float y = baseY + 16f; // slightly above head
+
+        Color old = new Color(batch.getColor());
+
+        // Draw rune
+        batch.setColor(1f, 1f, 1f, alpha);
+        batch.draw(rune, x, y, size, size);
+
+        // Draw red cross overlay
+        TextureRegion cross = FSkinImage.WARNING.getTextureRegion();
+        batch.draw(cross, x, y, size / 2, size / 2);
+
+        batch.setColor(old);
+    }
+
+    public static RewardData generateRewardData(String type, int count, String itemName) {
+        RewardData data = new RewardData();
+        data.type = type;
+        data.count = count;
+        data.itemName = itemName;
+        return  data;
+    }
+
+    public static Reward generateReward(String type, int count, String itemName) {
+        RewardData data = generateRewardData(type, count, itemName);
+        Array<Reward> replacedAPReward = data.generate(false, true);
+        if (replacedAPReward != null &&  !replacedAPReward.isEmpty()) {
+            return replacedAPReward.get(0);
+        }
+        return null;
+    }
+}