Refactor deck chooser and editor to support variants

.gitattributes

@@ -1124,6 +1124,7 @@ forge-gui-mobile/src/forge/deck/AddBasicLandsDialog.java -text
 forge-gui-mobile/src/forge/deck/FDeckChooser.java -text
 forge-gui-mobile/src/forge/deck/FDeckEditor.java -text
 forge-gui-mobile/src/forge/deck/FDeckViewer.java -text
+forge-gui-mobile/src/forge/deck/FVanguardChooser.java -text
 forge-gui-mobile/src/forge/error/BugReportDialog.java -text
 forge-gui-mobile/src/forge/itemmanager/CardManager.java -text
 forge-gui-mobile/src/forge/itemmanager/DeckManager.java -text

forge-gui-desktop/src/main/java/forge/deckchooser/FDeckChooser.java

@@ -79,7 +79,7 @@ public class FDeckChooser extends JPanel implements IDecksComboBoxListener {
     private void updateCustom() {
         lstDecks.setAllowMultipleSelections(false);
 
-        lstDecks.setPool(DeckProxy.getAllConstructedDecks(FModel.getDecks().getConstructed()));
+        lstDecks.setPool(DeckProxy.getAllConstructedDecks());
         lstDecks.setup(ItemManagerConfig.CONSTRUCTED_DECKS);
 
         btnRandom.setText("Random Deck");
@@ -300,6 +300,8 @@ public class FDeckChooser extends JPanel implements IDecksComboBoxListener {
         case PRECONSTRUCTED_DECK:
             updatePrecons();
             break;
+        default:
+            break;
         }
     }
 

forge-gui-desktop/src/main/java/forge/screens/deckeditor/controllers/CAllDecks.java

@@ -4,7 +4,6 @@ import forge.UiCommand;
 import forge.deck.DeckProxy;
 import forge.gui.framework.ICDoc;
 import forge.itemmanager.ItemManagerConfig;
-import forge.model.FModel;
 import forge.screens.deckeditor.views.VAllDecks;
 
 /** 
@@ -36,7 +35,7 @@ public enum CAllDecks implements ICDoc {
     }
 
     public void refresh() {
-        VAllDecks.SINGLETON_INSTANCE.getLstDecks().setPool(DeckProxy.getAllConstructedDecks(FModel.getDecks().getConstructed()));
+        VAllDecks.SINGLETON_INSTANCE.getLstDecks().setPool(DeckProxy.getAllConstructedDecks());
     }
 
     /* (non-Javadoc)

forge-gui-desktop/src/main/java/forge/screens/home/sanctioned/CSubmenuConstructed.java

@@ -275,7 +275,7 @@ public enum CSubmenuConstructed implements ICDoc, IMenuProvider {
                     	schemePool = ((Deck) selected).get(DeckSection.Schemes);
                     }
                     if (schemePool == null) { //Can be null if player deselects the list selection or chose Generate
-                    	schemePool = DeckgenUtil.generateSchemeDeck();
+                    	schemePool = DeckgenUtil.generateSchemePool();
                     }
                     if (checkLegality) {
                     	String errMsg = GameType.Archenemy.getDecksFormat().getSchemeSectionConformanceProblem(schemePool);
@@ -308,7 +308,7 @@ public enum CSubmenuConstructed implements ICDoc, IMenuProvider {
                     	planePool = ((Deck) selected).get(DeckSection.Planes);
                     }
                     if (planePool == null) { //Can be null if player deselects the list selection or chose Generate
-                    	planePool = DeckgenUtil.generatePlanarDeck();
+                    	planePool = DeckgenUtil.generatePlanarPool();
                     }
                     if (checkLegality) {
                     	String errMsg = GameType.Planechase.getDecksFormat().getPlaneSectionConformanceProblem(planePool);

forge-gui-mobile/src/forge/deck/FDeckChooser.java

@@ -21,6 +21,7 @@ import forge.toolbox.FComboBox;
 import forge.toolbox.FEvent;
 import forge.toolbox.FEvent.FEventHandler;
 import forge.toolbox.FOptionPane;
+import forge.util.Aggregates;
 import forge.util.Callback;
 import forge.util.Utils;
 import forge.util.storage.IStorage;
@@ -40,7 +41,7 @@ public class FDeckChooser extends FScreen {
     private DeckType selectedDeckType;
     private boolean needRefreshOnActivate;
 
-    private final DeckManager lstDecks = new DeckManager(GameType.Constructed);
+    private final DeckManager lstDecks;
     private final FButton btnNewDeck = new FButton("New Deck");
     private final FButton btnEditDeck = new FButton("Edit Deck");
     private final FButton btnViewDeck = new FButton("View Deck");
@@ -51,8 +52,9 @@ public class FDeckChooser extends FScreen {
     private final ForgePreferences prefs = FModel.getPreferences();
     private FPref stateSetting = null;
 
-    public FDeckChooser(boolean isAi0) {
+    public FDeckChooser(GameType gameType0, boolean isAi0) {
         super("");
+        lstDecks = new DeckManager(gameType0);
         isAi = isAi0;
 
         lstDecks.setItemActivateHandler(new FEventHandler() {
@@ -82,8 +84,23 @@ public class FDeckChooser extends FScreen {
                     }
                     break;
                 default:
+                    switch (lstDecks.getGameType()) {
+                    case Constructed:
                         editor = new FDeckEditor(EditorType.Constructed, "", false);
                         break;
+                    case Commander:
+                        editor = new FDeckEditor(EditorType.Commander, "", false);
+                        break;
+                    case Archenemy:
+                        editor = new FDeckEditor(EditorType.Archenemy, "", false);
+                        break;
+                    case Planechase:
+                        editor = new FDeckEditor(EditorType.Planechase, "", false);
+                        break;
+                    default:
+                        return;
+                    }
+                    break;
                 }
                 editor.setSaveHandler(new FEventHandler() {
                     @Override
@@ -120,6 +137,9 @@ public class FDeckChooser extends FScreen {
                 }
             }
         });
+        if (gameType0 != GameType.Constructed) { //delay initialize for constructed until saved decks can be reloaded
+            initialize(null, DeckType.RANDOM_DECK);
+        }
     }
 
     @Override
@@ -145,7 +165,7 @@ public class FDeckChooser extends FScreen {
         Deck existingDeck = decks.get(deck.getName());
         if (existingDeck != null) {
             setSelectedDeckType(DeckType.CUSTOM_DECK);
-            editDeck(new DeckProxy(existingDeck, "Constructed", GameType.Constructed, decks));
+            editDeck(new DeckProxy(existingDeck, "Constructed", lstDecks.getGameType(), decks));
             return;
         }
 
@@ -175,7 +195,18 @@ public class FDeckChooser extends FScreen {
         selectedDeckType = defaultDeckType;
 
         if (cmbDeckTypes == null) { //initialize components with delayed initialization the first time this is populated
-            cmbDeckTypes = new FComboBox<DeckType>(DeckType.values());
+            cmbDeckTypes = new FComboBox<DeckType>();
+            if (lstDecks.getGameType() == GameType.Constructed) {
+                cmbDeckTypes.addItem(DeckType.CUSTOM_DECK);
+                cmbDeckTypes.addItem(DeckType.PRECONSTRUCTED_DECK);
+                cmbDeckTypes.addItem(DeckType.QUEST_OPPONENT_DECK);
+                cmbDeckTypes.addItem(DeckType.COLOR_DECK);
+                cmbDeckTypes.addItem(DeckType.THEME_DECK);
+            }
+            else {
+                cmbDeckTypes.addItem(DeckType.CUSTOM_DECK);
+                cmbDeckTypes.addItem(DeckType.RANDOM_DECK);
+            }
             cmbDeckTypes.setAlignment(HAlignment.CENTER);
             restoreSavedState();
             cmbDeckTypes.setChangedHandler(new FEventHandler() {
@@ -240,8 +271,26 @@ public class FDeckChooser extends FScreen {
     private void updateCustom() {
         lstDecks.setSelectionSupport(1, 1);
 
-        lstDecks.setPool(DeckProxy.getAllConstructedDecks(FModel.getDecks().getConstructed()));
+        switch (lstDecks.getGameType()) {
+        case Constructed:
+            lstDecks.setPool(DeckProxy.getAllConstructedDecks());
             lstDecks.setup(ItemManagerConfig.CONSTRUCTED_DECKS);
+            break;
+        case Commander:
+            lstDecks.setPool(DeckProxy.getAllCommanderDecks());
+            lstDecks.setup(ItemManagerConfig.COMMANDER_DECKS);
+            break;
+        case Archenemy:
+            lstDecks.setPool(DeckProxy.getAllSchemeDecks());
+            lstDecks.setup(ItemManagerConfig.SCHEME_DECKS);
+            break;
+        case Planechase:
+            lstDecks.setPool(DeckProxy.getAllPlanarDecks());
+            lstDecks.setup(ItemManagerConfig.PLANAR_DECKS);
+            break;
+        default:
+            break;
+        }
 
         btnNewDeck.setText("New Deck");
         btnNewDeck.setWidth(btnEditDeck.getWidth());
@@ -266,7 +315,7 @@ public class FDeckChooser extends FScreen {
         public ColorDeckGenerator(String name0, int index0) {
             super();
             name = name0;
-            this.index = index0;
+            index = index0;
         }
 
         @Override
@@ -281,7 +330,7 @@ public class FDeckChooser extends FScreen {
 
         @Override
         public int compareTo(final ColorDeckGenerator d) {
-            return d instanceof ColorDeckGenerator ? Integer.compare(this.index, ((ColorDeckGenerator)d).index) : 1;
+            return d instanceof ColorDeckGenerator ? Integer.compare(index, ((ColorDeckGenerator)d).index) : 1;
         }
 
         @Override
@@ -353,6 +402,97 @@ public class FDeckChooser extends FScreen {
         });
     }
 
+    private class RandomDeckGenerator extends DeckProxy implements Comparable<RandomDeckGenerator> {
+        private String name;
+        private int index;
+
+        public RandomDeckGenerator(String name0, int index0) {
+            super();
+            name = name0;
+            index = index0;
+        }
+
+        @Override
+        public String getName() {
+            return name;
+        }
+
+        @Override
+        public String toString() {
+            return name;
+        }
+
+        @Override
+        public int compareTo(final RandomDeckGenerator d) {
+            return d instanceof RandomDeckGenerator ? Integer.compare(index, ((RandomDeckGenerator)d).index) : 1;
+        }
+
+        @Override
+        public Deck getDeck() {
+            String sel = lstDecks.getSelectedItem().getName();
+            switch (lstDecks.getGameType()) {
+            case Commander:
+                if (sel.equals("Random")) {
+                    IStorage<Deck> decks = FModel.getDecks().getCommander();
+                    if (decks.size() > 0) {
+                        return Aggregates.random(decks);
+                    }
+                }
+                return DeckgenUtil.generateCommanderDeck(isAi);
+            case Archenemy:
+                if (sel.equals("Random")) {
+                    IStorage<Deck> decks = FModel.getDecks().getScheme();
+                    if (decks.size() > 0) {
+                        return Aggregates.random(decks);
+                    }
+                }
+                return DeckgenUtil.generateSchemeDeck();
+            case Planechase:
+                if (sel.equals("Random")) {
+                    IStorage<Deck> decks = FModel.getDecks().getPlane();
+                    if (decks.size() > 0) {
+                        return Aggregates.random(decks);
+                    }
+                }
+                return DeckgenUtil.generatePlanarDeck();
+            default:
+                break;
+            }
+            return null;
+        }
+
+        @Override
+        public boolean isGeneratedDeck() {
+            return true;
+        }
+    }
+
+    private void updateRandom() {
+        lstDecks.setSelectionSupport(1, 1);
+
+        ArrayList<DeckProxy> decks = new ArrayList<DeckProxy>();
+        decks.add(new RandomDeckGenerator("Random Generated Deck", 0));
+        decks.add(new RandomDeckGenerator("Random User Deck", 1));
+
+        lstDecks.setPool(decks);
+        lstDecks.setup(ItemManagerConfig.STRING_ONLY);
+
+        btnNewDeck.setText("Generate New Deck");
+        btnNewDeck.setWidth(getWidth() - 2 * PADDING);
+        btnEditDeck.setVisible(false);
+
+        btnViewDeck.setVisible(false);
+        btnRandom.setText("Random Deck");
+        btnRandom.setWidth(btnNewDeck.getWidth());
+        btnRandom.setLeft(getWidth() - PADDING - btnRandom.getWidth());
+        btnRandom.setCommand(new FEventHandler() {
+            @Override
+            public void handleEvent(FEvent e) {
+                DeckgenUtil.randomSelect(lstDecks);
+            }
+        });
+    }
+
     private void updatePrecons() {
         lstDecks.setSelectionSupport(1, 1);
 
@@ -399,6 +539,7 @@ public class FDeckChooser extends FScreen {
 
     public Deck getDeck() {
         DeckProxy proxy = lstDecks.getSelectedItem();
+        if (proxy == null) { return null; }
         return proxy.getDeck();
     }
 
@@ -425,7 +566,7 @@ public class FDeckChooser extends FScreen {
     }
 
     public void setIsAi(boolean isAiDeck) {
-        this.isAi = isAiDeck;
+        isAi = isAiDeck;
     }
 
     private void refreshDecksList(DeckType deckType, boolean forceRefresh, FEvent e) {
@@ -453,6 +594,9 @@ public class FDeckChooser extends FScreen {
         case PRECONSTRUCTED_DECK:
             updatePrecons();
             break;
+        case RANDOM_DECK:
+            updateRandom();
+            break;
         }
 
         if (e != null) { //set default list selection if from combo box change event

forge-gui-mobile/src/forge/deck/FVanguardChooser.java

@@ -0,0 +1,106 @@
+package forge.deck;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import forge.Forge;
+import forge.item.PaperCard;
+import forge.itemmanager.CardManager;
+import forge.itemmanager.ItemManagerConfig;
+import forge.model.FModel;
+import forge.screens.FScreen;
+import forge.toolbox.FButton;
+import forge.toolbox.FEvent;
+import forge.toolbox.FEvent.FEventHandler;
+import forge.util.Aggregates;
+import forge.util.Utils;
+
+public class FVanguardChooser extends FScreen {
+    public static final float PADDING = Utils.scaleMin(5);
+
+    private static final List<PaperCard> allHumanAvatars = new ArrayList<PaperCard>();
+    private static final List<PaperCard> allAiAvatars = new ArrayList<PaperCard>();
+    private static final List<PaperCard> nonRandomHumanAvatars = new ArrayList<PaperCard>();
+    private static final List<PaperCard> nonRandomAiAvatars = new ArrayList<PaperCard>();
+    
+    static {
+        for (PaperCard c : FModel.getMagicDb().getVariantCards().getAllCards()) {
+            if (c.getRules().getType().isVanguard()) {
+                allHumanAvatars.add(c);
+                if (!c.getRules().getAiHints().getRemRandomDecks()) {
+                    nonRandomHumanAvatars.add(c);
+                }
+                if (!c.getRules().getAiHints().getRemAIDecks()) {
+                    allAiAvatars.add(c);
+                    if (!c.getRules().getAiHints().getRemRandomDecks()) {
+                        nonRandomAiAvatars.add(c);
+                    }
+                }
+            }
+        }
+    }
+
+    private final CardManager lstVanguards = new CardManager(true);
+    private final FButton btnRandom = new FButton("Random Avatar");
+    private boolean isAi;
+
+    public FVanguardChooser(boolean isAi0) {
+        super("");
+        isAi = isAi0;
+        lstVanguards.setItemActivateHandler(new FEventHandler() {
+            @Override
+            public void handleEvent(FEvent e) {
+                Forge.back();
+            }
+        });
+        btnRandom.setCommand(new FEventHandler() {
+            @Override
+            public void handleEvent(FEvent e) {
+                if (isAi) {
+                    lstVanguards.setSelectedItem(Aggregates.random(nonRandomAiAvatars));
+                }
+                else {
+                    lstVanguards.setSelectedItem(Aggregates.random(nonRandomHumanAvatars));
+                }
+            }
+        });
+        lstVanguards.setup(ItemManagerConfig.VANGUARDS);
+        lstVanguards.setPool(isAi ? allAiAvatars : allHumanAvatars);
+        if (lstVanguards.getItemCount() > 0) {
+            lstVanguards.setSelectedIndex(0);
+        }
+    }
+    
+    public void setIsAi(boolean isAi0) {
+        if (isAi == isAi0) { return; }
+        isAi = isAi0;
+
+        PaperCard lastSelection = lstVanguards.getSelectedItem();
+
+        lstVanguards.setPool(isAi ? allAiAvatars : allHumanAvatars);
+
+        if (lastSelection != null) {
+            lstVanguards.setSelectedItem(lastSelection);
+        }
+        if (lstVanguards.getSelectedIndex() == -1 && lstVanguards.getItemCount() > 0) {
+            lstVanguards.setSelectedIndex(0);
+        }
+    }
+
+    public PaperCard getVanguard() {
+        return lstVanguards.getSelectedItem();
+    }
+
+    @Override
+    protected void doLayout(float startY, float width, float height) {
+        float x = PADDING;
+        float y = startY + PADDING;
+        width -= 2 * x;
+
+        float buttonHeight = Utils.AVG_FINGER_HEIGHT;
+        lstVanguards.setBounds(x, y, width, height - y - buttonHeight - PADDING); //leave room for buttons at bottom
+
+        y += lstVanguards.getHeight() + PADDING;
+        btnRandom.setBounds(x, y, width, buttonHeight);
+    }
+}

forge-gui-mobile/src/forge/itemmanager/DeckManager.java

@@ -42,7 +42,7 @@ import java.util.Set;
  *
  */
 public final class DeckManager extends ItemManager<DeckProxy> {
-    private final GameType gametype;
+    private final GameType gameType;
     private FEventHandler cmdDelete;
 
     /**
@@ -53,7 +53,7 @@ public final class DeckManager extends ItemManager<DeckProxy> {
      */
     public DeckManager(final GameType gt) {
         super(DeckProxy.class, true);
-        gametype = gt;
+        gameType = gt;
 
         setItemActivateHandler(new FEventHandler() {
             @Override
@@ -65,6 +65,10 @@ public final class DeckManager extends ItemManager<DeckProxy> {
         setCaption("Decks");
     }
 
+    public GameType getGameType() {
+        return gameType;
+    }
+
     @Override
     public void setup(ItemManagerConfig config0) {
         boolean wasStringOnly = (getConfig() == ItemManagerConfig.STRING_ONLY);
@@ -224,7 +228,7 @@ public final class DeckManager extends ItemManager<DeckProxy> {
                         if (!result) { return; }
 
                         // consider using deck proxy's method to delete deck
-                        switch(gametype) {
+                        switch(gameType) {
                             case Constructed:
                             case Draft:
                             case Sealed:
@@ -235,7 +239,7 @@ public final class DeckManager extends ItemManager<DeckProxy> {
                                 //FModel.getQuest().save();
                                 break;
                             default:
-                                throw new UnsupportedOperationException("Delete not implemneted for game type = " + gametype.toString());
+                                throw new UnsupportedOperationException("Delete not implemneted for game type = " + gameType.toString());
                         }
 
                         removeItem(deck, 1);

forge-gui-mobile/src/forge/screens/constructed/ConstructedScreen.java

@@ -22,12 +22,11 @@ import forge.deck.Deck;
 import forge.deck.DeckProxy;
 import forge.deck.DeckSection;
 import forge.deck.DeckType;
-import forge.deck.DeckgenUtil;
 import forge.deck.FDeckChooser;
+import forge.deck.FVanguardChooser;
 import forge.game.GameType;
 import forge.game.player.RegisteredPlayer;
 import forge.item.PaperCard;
-import forge.model.CardCollections;
 import forge.model.FModel;
 import forge.properties.ForgePreferences;
 import forge.properties.ForgePreferences.FPref;
@@ -44,12 +43,10 @@ import forge.toolbox.FLabel;
 import forge.toolbox.FOptionPane;
 import forge.toolbox.FScrollPane;
 import forge.toolbox.FTextField;
-import forge.util.Aggregates;
 import forge.util.Callback;
 import forge.util.Lang;
 import forge.util.NameGenerator;
 import forge.util.Utils;
-import forge.util.storage.IStorage;
 
 public class ConstructedScreen extends LaunchScreen {
     private static final FSkinColor PLAYER_BORDER_COLOR = FSkinColor.get(Colors.CLR_BORDERS).alphaColor(0.8f);
@@ -91,13 +88,7 @@ public class ConstructedScreen extends LaunchScreen {
     };
 
     // Variants
-    private final List<PaperCard> vgdAllAvatars = new ArrayList<PaperCard>();
-    private final List<PaperCard> vgdAllAiAvatars = new ArrayList<PaperCard>();
-    private final List<PaperCard> nonRandomHumanAvatars = new ArrayList<PaperCard>();
-    private final List<PaperCard> nonRandomAiAvatars = new ArrayList<PaperCard>();
     private int lastArchenemy = 0;
-    private Vector<Object> humanListData = new Vector<Object>();
-    private Vector<Object> aiListData = new Vector<Object>();
 
     public ConstructedScreen() {
         super("Constructed");
@@ -294,20 +285,7 @@ public class ConstructedScreen extends LaunchScreen {
                 Deck deck = null;
                 boolean isCommanderMatch = appliedVariants.contains(GameType.Commander);
                 if (isCommanderMatch) {
-                    Object selected = playerPanel.lstCommanderDecks.getSelectedValue();
+                    deck = playerPanel.lstCommanderDecks.getDeck();
-                    if (selected instanceof String) {
-                        String sel = (String) selected;
-                        IStorage<Deck> comDecks = FModel.getDecks().getCommander();
-                        if (sel.equals("Random") && comDecks.size() > 0) {
-                            deck = Aggregates.random(comDecks);                            
-                        }
-                    }
-                    else {
-                        deck = (Deck) selected;
-                    }
-                    if (deck == null) { //Can be null if player deselects the list selection or chose Generate
-                        deck = DeckgenUtil.generateCommanderDeck(isPlayerAI(i));
-                    }
                     if (checkLegality) {
                         String errMsg = GameType.Commander.getDecksFormat().getDeckConformanceProblem(deck);
                         if (errMsg != null) {
@@ -327,29 +305,8 @@ public class ConstructedScreen extends LaunchScreen {
                 //Archenemy
                 if (appliedVariants.contains(GameType.ArchenemyRumble)
                         || (appliedVariants.contains(GameType.Archenemy) && playerIsArchenemy)) {
-                    Object selected = playerPanel.lstSchemeDecks.getSelectedValue();
+                    Deck schemeDeck = playerPanel.lstSchemeDecks.getDeck();
-                    CardPool schemePool = null;
+                    CardPool schemePool = schemeDeck.get(DeckSection.Schemes);
-                    if (selected instanceof String) {
-                        String sel = (String) selected;
-                        if (sel.contains("Use deck's scheme section")) {
-                            if (deck.has(DeckSection.Schemes)) {
-                                schemePool = deck.get(DeckSection.Schemes);
-                            }
-                            else {
-                                sel = "Random";
-                            }
-                        }
-                        IStorage<Deck> sDecks = FModel.getDecks().getScheme();
-                        if (sel.equals("Random") && sDecks.size() != 0) {
-                            schemePool = Aggregates.random(sDecks).get(DeckSection.Schemes);                            
-                        }
-                    }
-                    else {
-                        schemePool = ((Deck) selected).get(DeckSection.Schemes);
-                    }
-                    if (schemePool == null) { //Can be null if player deselects the list selection or chose Generate
-                        schemePool = DeckgenUtil.generateSchemeDeck();
-                    }
                     if (checkLegality) {
                         String errMsg = GameType.Archenemy.getDecksFormat().getSchemeSectionConformanceProblem(schemePool);
                         if (errMsg != null) {
@@ -362,28 +319,8 @@ public class ConstructedScreen extends LaunchScreen {
 
                 //Planechase
                 if (appliedVariants.contains(GameType.Planechase)) {
-                    Object selected = playerPanel.lstPlanarDecks.getSelectedValue();
+                    Deck planarDeck = playerPanel.lstPlanarDecks.getDeck();
-                    CardPool planePool = null;
+                    CardPool planePool = planarDeck.get(DeckSection.Planes);
-                    if (selected instanceof String) {
-                        String sel = (String) selected;
-                        if (sel.contains("Use deck's planes section")) {
-                            if (deck.has(DeckSection.Planes)) {
-                                planePool = deck.get(DeckSection.Planes);
-                            } else {
-                                sel = "Random";
-                            }
-                        }
-                        IStorage<Deck> pDecks = FModel.getDecks().getPlane();
-                        if (sel.equals("Random") && pDecks.size() != 0) {
-                            planePool = Aggregates.random(pDecks).get(DeckSection.Planes);                            
-                        }
-                    }
-                    else {
-                        planePool = ((Deck) selected).get(DeckSection.Planes);
-                    }
-                    if (planePool == null) { //Can be null if player deselects the list selection or chose Generate
-                        planePool = DeckgenUtil.generatePlanarDeck();
-                    }
                     if (checkLegality) {
                         String errMsg = GameType.Planechase.getDecksFormat().getPlaneSectionConformanceProblem(planePool);
                         if (null != errMsg) {
@@ -396,24 +333,7 @@ public class ConstructedScreen extends LaunchScreen {
 
                 //Vanguard
                 if (appliedVariants.contains(GameType.Vanguard)) {
-                    Object selected = playerPanel.lstVanguardAvatars.getSelectedValue();
+                    vanguardAvatar = playerPanel.lstVanguardAvatars.getVanguard();
-                    if (selected instanceof String) {
-                        String sel = (String) selected;
-                        if (sel.contains("Use deck's default avatar") && deck.has(DeckSection.Avatar)) {
-                            vanguardAvatar = deck.get(DeckSection.Avatar).get(0);
-                        }
-                        else { //Only other string is "Random"
-                            if (!isPlayerAI(i)) { //Human
-                                vanguardAvatar = Aggregates.random(getNonRandomHumanAvatars());
-                            }
-                            else { //AI
-                                vanguardAvatar = Aggregates.random(getNonRandomAiAvatars());
-                            }
-                        }
-                    }
-                    else {
-                        vanguardAvatar = (PaperCard)selected;
-                    }
                     if (vanguardAvatar == null) {
                         FOptionPane.showErrorDialog("No Vanguard avatar selected for " + name
                                 + ". Please choose one or disable the Vanguard variant");
@@ -446,20 +366,21 @@ public class ConstructedScreen extends LaunchScreen {
         private FComboBox<Object> cbArchenemyTeam = new FComboBox<Object>();
 
         private final FLabel btnDeck           = new FLabel.ButtonBuilder().text("Loading Deck...").build();
-        private final FLabel btnSchemeDeck     = new FLabel.ButtonBuilder().text("Scheme Deck: (None)").build();
+        private final FLabel btnSchemeDeck     = new FLabel.ButtonBuilder().text("Scheme Deck: Random").build();
-        private final FLabel btnCommanderDeck  = new FLabel.ButtonBuilder().text("Commander Deck: (None)").build();
+        private final FLabel btnCommanderDeck  = new FLabel.ButtonBuilder().text("Commander Deck: Random").build();
-        private final FLabel btnPlanarDeck     = new FLabel.ButtonBuilder().text("Planar Deck: (None)").build();
+        private final FLabel btnPlanarDeck     = new FLabel.ButtonBuilder().text("Planar Deck: Random").build();
-        private final FLabel btnVanguardAvatar = new FLabel.ButtonBuilder().text("Vanguard Avatar: (None)").build();
+        private final FLabel btnVanguardAvatar = new FLabel.ButtonBuilder().text("Vanguard Avatar: Random").build();
 
-        private final FDeckChooser deckChooser;
+        private final FDeckChooser deckChooser, lstSchemeDecks, lstCommanderDecks, lstPlanarDecks;
-        private final DeckList lstSchemeDecks, lstCommanderDecks, lstPlanarDecks, lstVanguardAvatars;
+        private final FVanguardChooser lstVanguardAvatars;
 
         public PlayerPanel(final int index0) {
             super();
             index = index0;
             playerIsArchenemy = index == 0;
             btnDeck.setEnabled(false); //disable deck button until done loading decks
-            deckChooser = new FDeckChooser(isPlayerAI());
+            boolean isAi = isPlayerAI();
+            deckChooser = new FDeckChooser(GameType.Constructed, isAi);
             deckChooser.getLstDecks().setSelectionChangedHandler(new FEventHandler() {
                 @Override
                 public void handleEvent(FEvent e) {
@@ -468,10 +389,10 @@ public class ConstructedScreen extends LaunchScreen {
                             Lang.joinHomogenous(deckChooser.getLstDecks().getSelectedItems(), DeckProxy.FN_GET_NAME));
                 }
             });
-            lstSchemeDecks = new DeckList();
+            lstSchemeDecks = new FDeckChooser(GameType.Archenemy, isAi);
-            lstCommanderDecks = new DeckList();
+            lstCommanderDecks = new FDeckChooser(GameType.Commander, isAi);
-            lstPlanarDecks = new DeckList();
+            lstPlanarDecks = new FDeckChooser(GameType.Planechase, isAi);
-            lstVanguardAvatars = new DeckList();
+            lstVanguardAvatars = new FVanguardChooser(isAi);
 
             createAvatar();
             add(avatarLabel);
@@ -506,70 +427,37 @@ public class ConstructedScreen extends LaunchScreen {
             btnCommanderDeck.setCommand(new FEventHandler() {
                 @Override
                 public void handleEvent(FEvent e) {
-                    deckChooser.setHeaderCaption("Select Commander Deck for " + txtPlayerName.getText());
+                    lstCommanderDecks.setHeaderCaption("Select Commander Deck for " + txtPlayerName.getText());
-                    Forge.openScreen(deckChooser);
+                    Forge.openScreen(lstCommanderDecks);
                 }
             });
             add(btnSchemeDeck);
             btnSchemeDeck.setCommand(new FEventHandler() {
                 @Override
                 public void handleEvent(FEvent e) {
-                    deckChooser.setHeaderCaption("Select Scheme Deck for " + txtPlayerName.getText());
+                    lstSchemeDecks.setHeaderCaption("Select Scheme Deck for " + txtPlayerName.getText());
-                    Forge.openScreen(deckChooser);
+                    Forge.openScreen(lstSchemeDecks);
                 }
             });
             add(btnPlanarDeck);
             btnPlanarDeck.setCommand(new FEventHandler() {
                 @Override
                 public void handleEvent(FEvent e) {
-                    deckChooser.setHeaderCaption("Select Planar Deck for " + txtPlayerName.getText());
+                    lstPlanarDecks.setHeaderCaption("Select Planar Deck for " + txtPlayerName.getText());
-                    Forge.openScreen(deckChooser);
+                    Forge.openScreen(lstPlanarDecks);
                 }
             });
             add(btnVanguardAvatar);
             btnVanguardAvatar.setCommand(new FEventHandler() {
                 @Override
                 public void handleEvent(FEvent e) {
-                    deckChooser.setHeaderCaption("Select Vanguard Avatar for " + txtPlayerName.getText());
+                    lstVanguardAvatars.setHeaderCaption("Select Vanguard Avatar for " + txtPlayerName.getText());
-                    Forge.openScreen(deckChooser);
+                    Forge.openScreen(lstVanguardAvatars);
                 }
             });
 
             updateVariantControlsVisibility();
 
-            final CardCollections decks = FModel.getDecks();
-            
-            lstCommanderDecks.list.addItem("Generate");
-            if (decks.getCommander().size() > 0) {
-                lstCommanderDecks.list.addItem("Random");
-                for (Deck comDeck : decks.getCommander()) {
-                    lstCommanderDecks.list.addItem(comDeck);
-                }
-            }
-            lstCommanderDecks.setSelectedIndex(0);
-
-            lstSchemeDecks.list.addItem("Use deck's scheme section (random if unavailable)");
-            lstSchemeDecks.list.addItem("Generate");
-            if (decks.getScheme().size() > 0) {
-                lstSchemeDecks.list.addItem("Random");
-                for (Deck schemeDeck : decks.getScheme()) {
-                    lstSchemeDecks.list.addItem(schemeDeck);
-                }
-            }
-            lstSchemeDecks.setSelectedIndex(0);
-
-            lstPlanarDecks.list.addItem("Use deck's planes section (random if unavailable)");
-            lstPlanarDecks.list.addItem("Generate");
-            if (decks.getPlane().size() > 0) {
-                lstPlanarDecks.list.addItem("Random");
-                for (Deck planarDeck : decks.getPlane()) {
-                    lstPlanarDecks.list.addItem(planarDeck);
-                }                
-            }
-            lstPlanarDecks.setSelectedIndex(0);
-
-            updateVanguardList();
-
             //disable team combo boxes for now
             cbTeam.setEnabled(false);
         }
@@ -650,7 +538,7 @@ public class ConstructedScreen extends LaunchScreen {
         private final FEventHandler humanAiSwitched = new FEventHandler() {
             @Override
             public void handleEvent(FEvent e) {
-                updateVanguardList();
+                lstVanguardAvatars.setIsAi(isPlayerAI());
             }
         };
 
@@ -710,10 +598,6 @@ public class ConstructedScreen extends LaunchScreen {
             return humanAiSwitch.isToggled();
         }
 
-        public void setVanguardButtonText(String text) {
-            btnVanguardAvatar.setText(text);
-        }
-
         private void populateTeamsComboBoxes() {
             cbArchenemyTeam.addItem("Archenemy");
             cbArchenemyTeam.addItem("Heroes");
@@ -831,50 +715,6 @@ public class ConstructedScreen extends LaunchScreen {
         public String getPlayerName() {
             return txtPlayerName.getText();
         }
-
-        /** update vanguard list. */
-        public void updateVanguardList() {
-            Object lastSelection = lstVanguardAvatars.getSelectedValue();
-            lstVanguardAvatars.setSelectedIndex(-1);
-            lstVanguardAvatars.list.setListData(isPlayerAI() ? aiListData : humanListData);
-            if (lastSelection != null) {
-                lstVanguardAvatars.setSelectedValue(lastSelection);
-            }
-            if (lstVanguardAvatars.getSelectedIndex() == -1) {
-                lstVanguardAvatars.setSelectedIndex(0);
-            }
-        }
-
-        private class DeckList extends FScreen {
-            private final FList<Object> list;
-            private int selectedIndex;
-
-            private DeckList() {
-                super("");
-                list = new FList<Object>();
-            }
-
-            public int getSelectedIndex() {
-                return selectedIndex;
-            }
-
-            public void setSelectedIndex(int index) {
-                selectedIndex = index;
-            }
-
-            public Object getSelectedValue() {
-                return list.getItemAt(selectedIndex);
-            }
-
-            public void setSelectedValue(Object value) {
-                selectedIndex = list.getIndexOf(value);
-            }
-
-            @Override
-            protected void doLayout(float startY, float width, float height) {
-                list.setBounds(0, startY, width, height - startY);
-            }
-        }
     }
 
     /** Saves avatar prefs for players one and two. */
@@ -1199,52 +1039,4 @@ public class ConstructedScreen extends LaunchScreen {
     public boolean isPlayerArchenemy(final int playernum) {
         return playerPanels.get(playernum).playerIsArchenemy;
     }
-
-    /** Return all the Vanguard avatars. */
-    public Iterable<PaperCard> getAllAvatars() {
-        if (vgdAllAvatars.isEmpty()) {
-            for (PaperCard c : FModel.getMagicDb().getVariantCards().getAllCards()) {
-                if (c.getRules().getType().isVanguard()) {
-                    vgdAllAvatars.add(c);
-                }
-            }
-        }
-        return vgdAllAvatars;
-    }
-
-    /** Return the Vanguard avatars not flagged RemAIDeck. */
-    public List<PaperCard> getAllAiAvatars() {
-        return vgdAllAiAvatars;
-    }
-
-    /** Return the Vanguard avatars not flagged RemRandomDeck. */
-    public List<PaperCard> getNonRandomHumanAvatars() {
-        return nonRandomHumanAvatars;
-    }
-
-    /** Return the Vanguard avatars not flagged RemAIDeck or RemRandomDeck. */
-    public List<PaperCard> getNonRandomAiAvatars() {
-        return nonRandomAiAvatars;
-    }
-
-    /** Populate vanguard lists. */
-    private void populateVanguardLists() {
-        humanListData.add("Use deck's default avatar (random if unavailable)");
-        humanListData.add("Random");
-        aiListData.add("Use deck's default avatar (random if unavailable)");
-        aiListData.add("Random");
-        for (PaperCard cp : getAllAvatars()) {
-            humanListData.add(cp);
-            if (!cp.getRules().getAiHints().getRemRandomDecks()) {
-                nonRandomHumanAvatars.add(cp);
-            }
-            if (!cp.getRules().getAiHints().getRemAIDecks()) {
-                aiListData.add(cp);
-                vgdAllAiAvatars.add(cp);
-                if (!cp.getRules().getAiHints().getRemRandomDecks()) {
-                    nonRandomAiAvatars.add(cp);
-                }
-            }
-        }
-    }
 }

forge-gui/src/main/java/forge/deck/DeckProxy.java

@@ -258,9 +258,27 @@ public class DeckProxy implements InventoryItem {
     }
 
     // TODO: The methods below should not take the decks collections from singletons, instead they are supposed to use data passed in parameters
-    public static Iterable<DeckProxy> getAllConstructedDecks(IStorage<Deck> storageRoot) {
+    public static Iterable<DeckProxy> getAllConstructedDecks() {
         List<DeckProxy> result = new ArrayList<DeckProxy>();
-        addDecksRecursivelly("Constructed", GameType.Constructed, result, "", storageRoot);
+        addDecksRecursivelly("Constructed", GameType.Constructed, result, "", FModel.getDecks().getConstructed());
+        return result;
+    }
+
+    public static Iterable<DeckProxy> getAllCommanderDecks() {
+        List<DeckProxy> result = new ArrayList<DeckProxy>();
+        addDecksRecursivelly("Commander", GameType.Commander, result, "", FModel.getDecks().getCommander());
+        return result;
+    }
+
+    public static Iterable<DeckProxy> getAllSchemeDecks() {
+        List<DeckProxy> result = new ArrayList<DeckProxy>();
+        addDecksRecursivelly("Scheme", GameType.Archenemy, result, "", FModel.getDecks().getScheme());
+        return result;
+    }
+
+    public static Iterable<DeckProxy> getAllPlanarDecks() {
+        List<DeckProxy> result = new ArrayList<DeckProxy>();
+        addDecksRecursivelly("Plane", GameType.Planechase, result, "", FModel.getDecks().getPlane());
         return result;
     }
 

forge-gui/src/main/java/forge/deck/DeckType.java

@@ -5,7 +5,8 @@ public enum DeckType {
     PRECONSTRUCTED_DECK("Preconstructed Decks"),
     QUEST_OPPONENT_DECK ("Quest Opponent Decks"),
     COLOR_DECK ("Random Color Decks"),
-    THEME_DECK ("Random Theme Decks");
+    THEME_DECK ("Random Theme Decks"),
+    RANDOM_DECK ("Random Decks");
 
     private String value;
     private DeckType(String value) {

forge-gui/src/main/java/forge/deck/DeckgenUtil.java

@@ -195,7 +195,13 @@ public class DeckgenUtil {
         return result;
     }
 
-    public static CardPool generateSchemeDeck() {
+    public static Deck generateSchemeDeck() {
+        Deck deck = new Deck("");
+        deck.putSection(DeckSection.Schemes, generateSchemePool());
+        return deck;
+    }
+
+    public static CardPool generateSchemePool() {
         CardPool schemes = new CardPool();
         List<PaperCard> allSchemes = new ArrayList<PaperCard>();
         for (PaperCard c : FModel.getMagicDb().getVariantCards().getAllCards()) {
@@ -221,7 +227,13 @@ public class DeckgenUtil {
         return schemes;
     }
 
-    public static CardPool generatePlanarDeck() {
+    public static Deck generatePlanarDeck() {
+        Deck deck = new Deck("");
+        deck.putSection(DeckSection.Planes, generatePlanarPool());
+        return deck;
+    }
+
+    public static CardPool generatePlanarPool() {
         CardPool res = new CardPool();
         List<PaperCard> allPlanars = new ArrayList<PaperCard>();
         for (PaperCard c : FModel.getMagicDb().getVariantCards().getAllCards()) {

forge-gui/src/main/java/forge/itemmanager/ItemManagerConfig.java

@@ -54,6 +54,14 @@ public enum ItemManagerConfig {
             GroupDef.DEFAULT, ColumnDef.CMC, 4, 1),
     CONSTRUCTED_DECKS(SColumnUtil.getDecksDefaultColumns(true, true), false, false, false,
             null, null, 3, 0),
+    COMMANDER_DECKS(SColumnUtil.getDecksDefaultColumns(true, false), false, false, false,
+            null, null, 3, 0),
+    PLANAR_DECKS(SColumnUtil.getDecksDefaultColumns(true, false), false, false, false,
+            null, null, 3, 0),
+    SCHEME_DECKS(SColumnUtil.getDecksDefaultColumns(true, false), false, false, false,
+            null, null, 3, 0),
+    VANGUARDS(SColumnUtil.getDecksDefaultColumns(true, false), false, false, false,
+            null, null, 3, 0),
     DRAFT_DECKS(SColumnUtil.getDecksDefaultColumns(true, false), false, false, false,
             null, null, 3, 0),
     SEALED_DECKS(SColumnUtil.getDecksDefaultColumns(true, false), false, false, false,