external-repos/forge
1
0
Fork 0
mirror of https://github.com/Card-Forge/forge.git synced 2025-11-19 12:18:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merged changes from trunk to GuiRefactoring: 27239-27260

Browse Source
This commit is contained in:
elcnesh
2014-09-09 09:30:57 +00:00
parent 0222c64b62
commit ecdd2b2995
33 changed files with 1154 additions and 1019 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
forge-gui-desktop/src/main/java/forge/screens/home/quest/QuestPreferencesHandler.java
View File

@@ -213,6 +213,9 @@ public class QuestPreferencesHandler extends SkinnedPanel {
pnlShop.add(new FLabel.Builder().text("Maximum Packs").build(), constraints2);
pnlShop.add(new PrefInput(QPref.SHOP_MAX_PACKS, ErrType.SHOP), constraints1);
pnlShop.add(new FLabel.Builder().text("Minimum Packs").build(), constraints2);
pnlShop.add(new PrefInput(QPref.SHOP_MIN_PACKS, ErrType.SHOP), constraints1);
pnlShop.add(new FLabel.Builder().text("Starting Packs").build(), constraints2);
pnlShop.add(new PrefInput(QPref.SHOP_STARTING_PACKS, ErrType.SHOP), constraints1);

3
forge-gui-desktop/src/main/java/forge/screens/home/quest/VSubmenuQuestPrefs.java
View File

@@ -351,6 +351,9 @@ public enum VSubmenuQuestPrefs implements IVSubmenu<CSubmenuQuestPrefs> {
pnlShop.add(new FLabel.Builder().text("Maximum Packs").fontAlign(SwingConstants.RIGHT).build(), constraints2);
pnlShop.add(new PrefInput(QPref.SHOP_MAX_PACKS, QuestPreferencesErrType.SHOP), constraints1);
pnlShop.add(new FLabel.Builder().text("Minimum Packs").fontAlign(SwingConstants.RIGHT).build(), constraints2);
pnlShop.add(new PrefInput(QPref.SHOP_MIN_PACKS, QuestPreferencesErrType.SHOP), constraints1);
pnlShop.add(new FLabel.Builder().text("Starting Packs").fontAlign(SwingConstants.RIGHT).build(), constraints2);
pnlShop.add(new PrefInput(QPref.SHOP_STARTING_PACKS, QuestPreferencesErrType.SHOP), constraints1);

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

@@ -54,104 +54,103 @@ public enum CSubmenuConstructed implements ICDoc, IMenuProvider {
*/
@Override
public void update() {
MenuUtil.setMenuProvider(this);
SwingUtilities.invokeLater(new Runnable() {
@Override public void run() {
final CardCollections cColl = FModel.getDecks();
FList<Object> deckList;
Vector<Object> listData;
Object val;
@Override public void run() {
final CardCollections cColl = FModel.getDecks();
FList<Object> deckList;
Vector<Object> listData;
Object val;
for (int i = 0; i < 8; i++) {
// Commander: reinit deck list and restore last selections (if any)
deckList = view.getCommanderDeckLists().get(i);
listData = new Vector<Object>();
listData.add("Generate");
if (cColl.getCommander().size() > 0) {
listData.add("Random");
for (Deck comDeck : cColl.getCommander()) {
listData.add(comDeck);
}
}
val = deckList.getSelectedValue();
deckList.setListData(listData);
if (null != val) {
deckList.setSelectedValue(val, true);
}
if (-1 == deckList.getSelectedIndex()) {
deckList.setSelectedIndex(0);
} // End Commander
for (int i = 0; i < 8; i++) {
// Commander: reinit deck list and restore last selections (if any)
deckList = view.getCommanderDeckLists().get(i);
listData = new Vector<Object>();
listData.add("Generate");
if (cColl.getCommander().size() > 0) {
listData.add("Random");
for (Deck comDeck : cColl.getCommander()) {
listData.add(comDeck);
}
}
val = deckList.getSelectedValue();
deckList.setListData(listData);
if (null != val) {
deckList.setSelectedValue(val, true);
}
if (-1 == deckList.getSelectedIndex()) {
deckList.setSelectedIndex(0);
} // End Commander
// Archenemy: reinit deck list and restore last selections (if any)
deckList = view.getSchemeDeckLists().get(i);
listData = new Vector<Object>();
listData.add("Use deck's scheme section (random if unavailable)");
listData.add("Generate");
if (cColl.getScheme().size() > 0) {
listData.add("Random");
for (Deck schemeDeck : cColl.getScheme()) {
listData.add(schemeDeck);
}
}
val = deckList.getSelectedValue();
deckList.setListData(listData);
if (null != val) {
deckList.setSelectedValue(val, true);
}
if (-1 == deckList.getSelectedIndex()) {
deckList.setSelectedIndex(0);
} // End Archenemy
// Archenemy: reinit deck list and restore last selections (if any)
deckList = view.getSchemeDeckLists().get(i);
listData = new Vector<Object>();
listData.add("Use deck's scheme section (random if unavailable)");
listData.add("Generate");
if (cColl.getScheme().size() > 0) {
listData.add("Random");
for (Deck schemeDeck : cColl.getScheme()) {
listData.add(schemeDeck);
}
}
val = deckList.getSelectedValue();
deckList.setListData(listData);
if (null != val) {
deckList.setSelectedValue(val, true);
}
if (-1 == deckList.getSelectedIndex()) {
deckList.setSelectedIndex(0);
} // End Archenemy
// Planechase: reinit deck lists and restore last selections (if any)
deckList = view.getPlanarDeckLists().get(i);
listData = new Vector<Object>();
// Planechase: reinit deck lists and restore last selections (if any)
deckList = view.getPlanarDeckLists().get(i);
listData = new Vector<Object>();
listData.add("Use deck's planes section (random if unavailable)");
listData.add("Generate");
if (cColl.getPlane().size() > 0) {
listData.add("Random");
for (Deck planarDeck : cColl.getPlane()) {
listData.add(planarDeck);
}
}
listData.add("Use deck's planes section (random if unavailable)");
listData.add("Generate");
if (cColl.getPlane().size() > 0) {
listData.add("Random");
for (Deck planarDeck : cColl.getPlane()) {
listData.add(planarDeck);
}
}
val = deckList.getSelectedValue();
deckList.setListData(listData);
if (null != val) {
deckList.setSelectedValue(val, true);
}
val = deckList.getSelectedValue();
deckList.setListData(listData);
if (null != val) {
deckList.setSelectedValue(val, true);
}
if (-1 == deckList.getSelectedIndex()) {
deckList.setSelectedIndex(0);
} // End Planechase
if (-1 == deckList.getSelectedIndex()) {
deckList.setSelectedIndex(0);
} // End Planechase
view.updateVanguardList(i);
}
view.updateVanguardList(i);
}
// General updates when switching back to this view
view.updatePlayersFromPrefs();
view.getBtnStart().requestFocusInWindow();
}
// General updates when switching back to this view
view.updatePlayersFromPrefs();
view.getBtnStart().requestFocusInWindow();
}
});
}
/* (non-Javadoc)
* @see forge.gui.home.ICSubmenu#initialize()
*/
@Override
@Override
public void initialize() {
view.getDeckChooser(0).initialize(FPref.CONSTRUCTED_P1_DECK_STATE, DeckType.PRECONSTRUCTED_DECK);
view.getDeckChooser(1).initialize(FPref.CONSTRUCTED_P2_DECK_STATE, DeckType.COLOR_DECK);
view.getDeckChooser(2).initialize(FPref.CONSTRUCTED_P3_DECK_STATE, DeckType.COLOR_DECK);
view.getDeckChooser(3).initialize(FPref.CONSTRUCTED_P4_DECK_STATE, DeckType.COLOR_DECK);
view.getDeckChooser(4).initialize(FPref.CONSTRUCTED_P5_DECK_STATE, DeckType.COLOR_DECK);
view.getDeckChooser(5).initialize(FPref.CONSTRUCTED_P6_DECK_STATE, DeckType.COLOR_DECK);
view.getDeckChooser(6).initialize(FPref.CONSTRUCTED_P7_DECK_STATE, DeckType.COLOR_DECK);
view.getDeckChooser(7).initialize(FPref.CONSTRUCTED_P8_DECK_STATE, DeckType.COLOR_DECK);
view.getDeckChooser(0).initialize(FPref.CONSTRUCTED_P1_DECK_STATE, DeckType.PRECONSTRUCTED_DECK);
view.getDeckChooser(1).initialize(FPref.CONSTRUCTED_P2_DECK_STATE, DeckType.COLOR_DECK);
view.getDeckChooser(2).initialize(FPref.CONSTRUCTED_P3_DECK_STATE, DeckType.COLOR_DECK);
view.getDeckChooser(3).initialize(FPref.CONSTRUCTED_P4_DECK_STATE, DeckType.COLOR_DECK);
view.getDeckChooser(4).initialize(FPref.CONSTRUCTED_P5_DECK_STATE, DeckType.COLOR_DECK);
view.getDeckChooser(5).initialize(FPref.CONSTRUCTED_P6_DECK_STATE, DeckType.COLOR_DECK);
view.getDeckChooser(6).initialize(FPref.CONSTRUCTED_P7_DECK_STATE, DeckType.COLOR_DECK);
view.getDeckChooser(7).initialize(FPref.CONSTRUCTED_P8_DECK_STATE, DeckType.COLOR_DECK);
// Start button event handling
// Start button event handling
view.getBtnStart().addActionListener(new ActionListener() {
@Override
public void actionPerformed(final ActionEvent arg0) {
@@ -184,171 +183,196 @@ public enum CSubmenuConstructed implements ICDoc, IMenuProvider {
/** Starts a match with the applied variants. */
private void startGame(final Set<GameType> variantTypes) {
if (!view.isEnoughTeams()) {
FOptionPane.showMessageDialog("There are not enough teams! Please adjust team allocations.");
return;
}
if (!view.isEnoughTeams()) {
FOptionPane.showMessageDialog("There are not enough teams! Please adjust team allocations.");
return;
}
for (final int i : view.getParticipants()) {
if (view.getDeckChooser(i).getPlayer() == null) {
if (view.getDeckChooser(i).getPlayer() == null) {
FOptionPane.showMessageDialog("Please specify a deck for " + view.getPlayerName(i));
return;
}
} // Is it even possible anymore? I think current implementation assigns decks automatically.
boolean checkLegality = FModel.getPreferences().getPrefBoolean(FPref.ENFORCE_DECK_LEGALITY);
if (checkLegality && !variantTypes.contains(GameType.Commander)) { //Commander deck replaces regular deck and is checked later
for (final int i : view.getParticipants()) {
String name = view.getPlayerName(i);
String errMsg = GameType.Constructed.getDeckFormat().getDeckConformanceProblem(view.getDeckChooser(i).getPlayer().getDeck());
if (null != errMsg) {
FOptionPane.showErrorDialog(name + "'s deck " + errMsg, "Invalid Deck");
return;
}
}
GameType autoGenerateVariant = null;
boolean isCommanderMatch = false;
if (!variantTypes.isEmpty()) {
isCommanderMatch = variantTypes.contains(GameType.Commander);
if (!isCommanderMatch) {
for (GameType variant : variantTypes) {
if (variant.isAutoGenerated()) {
autoGenerateVariant = variant;
break;
}
}
}
}
boolean checkLegality = FModel.getPreferences().getPrefBoolean(FPref.ENFORCE_DECK_LEGALITY);
//Auto-generated decks don't need to be checked here
//Commander deck replaces regular deck and is checked later
if (checkLegality && autoGenerateVariant == null && !isCommanderMatch) {
for (final int i : view.getParticipants()) {
String name = view.getPlayerName(i);
String errMsg = GameType.Constructed.getDeckFormat().getDeckConformanceProblem(view.getDeckChooser(i).getPlayer().getDeck());
if (null != errMsg) {
FOptionPane.showErrorDialog(name + "'s deck " + errMsg, "Invalid Deck");
return;
}
}
}
IGuiBase fc = GuiBase.getInterface();
List<RegisteredPlayer> players = new ArrayList<RegisteredPlayer>();
for (final int i : view.getParticipants()) {
String name = view.getPlayerName(i);
String name = view.getPlayerName(i);
LobbyPlayer lobbyPlayer = view.isPlayerAI(i)
? fc.createAiPlayer(name, view.getPlayerAvatar(i))
: fc.getGuiPlayer();
? fc.createAiPlayer(name, view.getPlayerAvatar(i))
: fc.getGuiPlayer();
RegisteredPlayer rp = view.getDeckChooser(i).getPlayer();
if (variantTypes.isEmpty()) {
rp.setTeamNumber(view.getTeam(i));
players.add(rp.setPlayer(lobbyPlayer));
} else {
}
else {
Deck deck = null;
boolean isCommanderMatch = variantTypes.contains(GameType.Commander);
if (isCommanderMatch) {
PaperCard vanguardAvatar = null;
if (isCommanderMatch) {
Object selected = view.getCommanderDeckLists().get(i).getSelectedValue();
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);
deck = Aggregates.random(comDecks);
}
} else {
deck = (Deck) selected;
}
else {
deck = (Deck) selected;
}
if (deck == null) { //Can be null if player deselects the list selection or chose Generate
deck = DeckgenUtil.generateCommanderDeck(view.isPlayerAI(i));
deck = DeckgenUtil.generateCommanderDeck(view.isPlayerAI(i));
}
if (checkLegality) {
String errMsg = GameType.Commander.getDeckFormat().getDeckConformanceProblem(deck);
String errMsg = GameType.Commander.getDeckFormat().getDeckConformanceProblem(deck);
if (null != errMsg) {
FOptionPane.showErrorDialog(name + "'s deck " + errMsg, "Invalid Commander Deck");
return;
}
}
}
}
else if (autoGenerateVariant != null) {
deck = autoGenerateVariant.autoGenerateDeck(rp);
CardPool avatarPool = deck.get(DeckSection.Avatar);
if (avatarPool != null) {
vanguardAvatar = avatarPool.get(0);
}
}
// Initialise variables for other variants
deck = deck == null ? rp.getDeck() : deck;
Iterable<PaperCard> schemes = null;
boolean playerIsArchenemy = view.isPlayerArchenemy(i);
Iterable<PaperCard> planes = null;
PaperCard vanguardAvatar = null;
// Initialise variables for other variants
deck = deck == null ? rp.getDeck() : deck;
Iterable<PaperCard> schemes = null;
boolean playerIsArchenemy = view.isPlayerArchenemy(i);
Iterable<PaperCard> planes = null;
//Archenemy
if (variantTypes.contains(GameType.ArchenemyRumble)
//Archenemy
if (variantTypes.contains(GameType.ArchenemyRumble)
|| (variantTypes.contains(GameType.Archenemy) && playerIsArchenemy)) {
Object selected = view.getSchemeDeckLists().get(i).getSelectedValue();
CardPool schemePool = null;
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";
}
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);
schemePool = Aggregates.random(sDecks).get(DeckSection.Schemes);
}
} else {
schemePool = ((Deck) selected).get(DeckSection.Schemes);
schemePool = ((Deck) selected).get(DeckSection.Schemes);
}
if (schemePool == null) { //Can be null if player deselects the list selection or chose Generate
schemePool = DeckgenUtil.generateSchemePool();
schemePool = DeckgenUtil.generateSchemePool();
}
if (checkLegality) {
String errMsg = GameType.Archenemy.getDeckFormat().getSchemeSectionConformanceProblem(schemePool);
String errMsg = GameType.Archenemy.getDeckFormat().getSchemeSectionConformanceProblem(schemePool);
if (null != errMsg) {
FOptionPane.showErrorDialog(name + "'s deck " + errMsg, "Invalid Scheme Deck");
return;
}
}
schemes = schemePool.toFlatList();
}
}
//Planechase
if (variantTypes.contains(GameType.Planechase)) {
//Planechase
if (variantTypes.contains(GameType.Planechase)) {
Object selected = view.getPlanarDeckLists().get(i).getSelectedValue();
CardPool planePool = null;
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";
}
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);
planePool = Aggregates.random(pDecks).get(DeckSection.Planes);
}
} else {
planePool = ((Deck) selected).get(DeckSection.Planes);
planePool = ((Deck) selected).get(DeckSection.Planes);
}
if (planePool == null) { //Can be null if player deselects the list selection or chose Generate
planePool = DeckgenUtil.generatePlanarPool();
planePool = DeckgenUtil.generatePlanarPool();
}
if (checkLegality) {
String errMsg = GameType.Planechase.getDeckFormat().getPlaneSectionConformanceProblem(planePool);
String errMsg = GameType.Planechase.getDeckFormat().getPlaneSectionConformanceProblem(planePool);
if (null != errMsg) {
FOptionPane.showErrorDialog(name + "'s deck " + errMsg, "Invalid Planar Deck");
return;
}
}
planes = planePool.toFlatList();
}
}
//Vanguard
if (variantTypes.contains(GameType.Vanguard)) {
//Vanguard
if (variantTypes.contains(GameType.Vanguard)) {
Object selected = view.getVanguardLists().get(i).getSelectedValue();
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);
vanguardAvatar = deck.get(DeckSection.Avatar).get(0);
} else { //Only other string is "Random"
if (!view.isPlayerAI(i)) { //Human
vanguardAvatar = Aggregates.random(view.getNonRandomHumanAvatars());
} else { //AI
vanguardAvatar = Aggregates.random(view.getNonRandomAiAvatars());
}
if (!view.isPlayerAI(i)) { //Human
vanguardAvatar = Aggregates.random(view.getNonRandomHumanAvatars());
} else { //AI
vanguardAvatar = Aggregates.random(view.getNonRandomAiAvatars());
}
}
} else {
vanguardAvatar = (PaperCard)selected;
vanguardAvatar = (PaperCard)selected;
}
if (vanguardAvatar == null) { //ERROR! null if avatar deselected on list
GuiDialog.message("No Vanguard avatar selected for " + name
+ ". Please choose one or disable the Vanguard variant");
+ ". Please choose one or disable the Vanguard variant");
return;
}
}
}
rp = RegisteredPlayer.forVariants(variantTypes, deck, schemes, playerIsArchenemy, planes, vanguardAvatar);
rp.setTeamNumber(view.getTeam(i));
players.add(rp.setPlayer(lobbyPlayer));
}
view.getDeckChooser(i).saveState();
rp = RegisteredPlayer.forVariants(variantTypes, deck, schemes, playerIsArchenemy, planes, vanguardAvatar);
rp.setTeamNumber(view.getTeam(i));
players.add(rp.setPlayer(lobbyPlayer));
}
view.getDeckChooser(i).saveState();
}
Singletons.getControl().startMatch(GameType.Constructed, variantTypes, players);

213
forge-gui-desktop/src/main/java/forge/screens/home/sanctioned/VSubmenuConstructed.java
View File

@@ -110,13 +110,12 @@ public enum VSubmenuConstructed implements IVSubmenu<CSubmenuConstructed> {
// Variants frame and variables
private final Set<GameType> appliedVariants = new TreeSet<GameType>();
private final FPanel variantsPanel = new FPanel(new MigLayout("insets 10, gapx 10"));
private final FCheckBox vntVanguard = new FCheckBox("Vanguard");
private final FCheckBox vntCommander = new FCheckBox("Commander");
private final FCheckBox vntPlanechase = new FCheckBox("Planechase");
private final FCheckBox vntArchenemy = new FCheckBox("Archenemy");
private String archenemyType = "Classic";
private final FComboBoxWrapper<String> comboArchenemy = new FComboBoxWrapper<String>(new String[]{
"Archenemy (Classic - One player is the Archenemy)", "Supervillan Rumble (All players are Archenemies)"});
private final VariantCheckBox vntVanguard = new VariantCheckBox(GameType.Vanguard);
private final VariantCheckBox vntMomirBasic = new VariantCheckBox(GameType.MomirBasic);
private final VariantCheckBox vntCommander = new VariantCheckBox(GameType.Commander);
private final VariantCheckBox vntPlanechase = new VariantCheckBox(GameType.Planechase);
private final VariantCheckBox vntArchenemy = new VariantCheckBox(GameType.Archenemy);
private final VariantCheckBox vntArchenemyRumble = new VariantCheckBox(GameType.ArchenemyRumble);
// Player frame elements
private final JPanel playersFrame = new JPanel(new MigLayout("insets 0, gap 0 5, wrap, hidemode 3"));
@@ -160,22 +159,14 @@ public enum VSubmenuConstructed implements IVSubmenu<CSubmenuConstructed> {
////////////////////////////////////////////////////////
//////////////////// Variants Panel ////////////////////
// Populate and add variants panel
vntVanguard.addItemListener(iListenerVariants);
vntCommander.addItemListener(iListenerVariants);
vntPlanechase.addItemListener(iListenerVariants);
vntArchenemy.addItemListener(iListenerVariants);
comboArchenemy.setSelectedIndex(0);
comboArchenemy.setEnabled(vntArchenemy.isSelected());
comboArchenemy.addActionListener(aeComboListener);
variantsPanel.setOpaque(false);
variantsPanel.add(newLabel("Variants:"));
variantsPanel.add(vntVanguard);
variantsPanel.add(vntMomirBasic);
variantsPanel.add(vntCommander);
variantsPanel.add(vntPlanechase);
variantsPanel.add(vntArchenemy);
comboArchenemy.addTo(variantsPanel);
variantsPanel.add(vntArchenemyRumble);
constructedFrame.add(new FScrollPane(variantsPanel, false, true,
ScrollPaneConstants.VERTICAL_SCROLLBAR_NEVER,
@@ -459,6 +450,8 @@ public enum VSubmenuConstructed implements IVSubmenu<CSubmenuConstructed> {
container.validate();
container.repaint();
}
changePlayerFocus(playerWithFocus, currentGameMode);
}
/** @return {@link javax.swing.JButton} */
@@ -682,29 +675,62 @@ public enum VSubmenuConstructed implements IVSubmenu<CSubmenuConstructed> {
};
public void updateVariantControlsVisibility() {
// Commander deck replaces basic deck, so hide that
deckLabel.setVisible(!appliedVariants.contains(GameType.Commander));
deckBtn.setVisible(!appliedVariants.contains(GameType.Commander));
cmdDeckSelectorBtn.setVisible(appliedVariants.contains(GameType.Commander));
cmdDeckEditor.setVisible(appliedVariants.contains(GameType.Commander));
cmdLabel.setVisible(appliedVariants.contains(GameType.Commander));
boolean isCommanderApplied = false;
boolean isPlanechaseApplied = false;
boolean isVanguardApplied = false;
boolean isArchenemyApplied = false;
boolean archenemyVisiblity = false;
boolean isDeckBuildingAllowed = true;
for (GameType variant : appliedVariants) {
switch (variant) {
case Archenemy:
isArchenemyApplied = true;
if (playerIsArchenemy) {
archenemyVisiblity = true;
}
break;
case ArchenemyRumble:
archenemyVisiblity = true;
break;
case Commander:
isCommanderApplied = true;
isDeckBuildingAllowed = false; //Commander deck replaces basic deck, so hide that
break;
case Planechase:
isPlanechaseApplied = true;
break;
case Vanguard:
isVanguardApplied = true;
break;
default:
if (variant.isAutoGenerated()) {
isDeckBuildingAllowed = false;
}
break;
}
}
boolean archenemyVisiblity = appliedVariants.contains(GameType.ArchenemyRumble)
|| (appliedVariants.contains(GameType.Archenemy) && playerIsArchenemy);
scmDeckSelectorBtn.setVisible(archenemyVisiblity);
deckLabel.setVisible(isDeckBuildingAllowed);
deckBtn.setVisible(isDeckBuildingAllowed);
cmdDeckSelectorBtn.setVisible(isCommanderApplied);
cmdDeckEditor.setVisible(isCommanderApplied);
cmdLabel.setVisible(isCommanderApplied);
scmDeckSelectorBtn.setVisible(archenemyVisiblity);
scmDeckEditor.setVisible(archenemyVisiblity);
scmLabel.setVisible(archenemyVisiblity);
teamComboBox.setVisible(!appliedVariants.contains(GameType.Archenemy));
aeTeamComboBox.setVisible(appliedVariants.contains(GameType.Archenemy));
aeTeamComboBox.setEnabled(!(appliedVariants.contains(GameType.Archenemy) && playerIsArchenemy));
teamComboBox.setVisible(!isArchenemyApplied);
aeTeamComboBox.setVisible(isArchenemyApplied);
aeTeamComboBox.setEnabled(!(isArchenemyApplied && playerIsArchenemy));
pchDeckSelectorBtn.setVisible(appliedVariants.contains(GameType.Planechase));
pchDeckEditor.setVisible(appliedVariants.contains(GameType.Planechase));
pchLabel.setVisible(appliedVariants.contains(GameType.Planechase));
pchDeckSelectorBtn.setVisible(isPlanechaseApplied);
pchDeckEditor.setVisible(isPlanechaseApplied);
pchLabel.setVisible(isPlanechaseApplied);
vgdSelectorBtn.setVisible(appliedVariants.contains(GameType.Vanguard));
vgdLabel.setVisible(appliedVariants.contains(GameType.Vanguard));
vgdSelectorBtn.setVisible(isVanguardApplied);
vgdLabel.setVisible(isVanguardApplied);
}
@Override
@@ -779,7 +805,8 @@ public enum VSubmenuConstructed implements IVSubmenu<CSubmenuConstructed> {
public void toggleIsPlayerArchenemy() {
if (appliedVariants.contains(GameType.Archenemy)) {
playerIsArchenemy = lastArchenemy == index;
} else {
}
else {
playerIsArchenemy = appliedVariants.contains(GameType.ArchenemyRumble);
}
updateVariantControlsVisibility();
@@ -793,7 +820,7 @@ public enum VSubmenuConstructed implements IVSubmenu<CSubmenuConstructed> {
scmDeckSelectorBtn.setCommand(new Runnable() {
@Override
public void run() {
currentGameMode = archenemyType.contains("Classic") ? GameType.Archenemy : GameType.ArchenemyRumble;
currentGameMode = vntArchenemy.isSelected() ? GameType.Archenemy : GameType.ArchenemyRumble;
scmDeckSelectorBtn.requestFocusInWindow();
changePlayerFocus(index, currentGameMode);
}
@@ -802,7 +829,7 @@ public enum VSubmenuConstructed implements IVSubmenu<CSubmenuConstructed> {
scmDeckEditor.setCommand(new UiCommand() {
@Override
public void run() {
currentGameMode = archenemyType.contains("Classic") ? GameType.Archenemy : GameType.ArchenemyRumble;
currentGameMode = vntArchenemy.isSelected() ? GameType.Archenemy : GameType.ArchenemyRumble;
Predicate<PaperCard> predSchemes = new Predicate<PaperCard>() {
@Override
public boolean apply(PaperCard arg0) {
@@ -1139,73 +1166,61 @@ public enum VSubmenuConstructed implements IVSubmenu<CSubmenuConstructed> {
/////////////////////////////////////////////
//========== Various listeners in build order
/** This listener unlocks the relevant buttons for players
* and enables/disables archenemy combobox as appropriate. */
private ItemListener iListenerVariants = new ItemListener() {
@Override
public void itemStateChanged(ItemEvent arg0) {
FCheckBox cb = (FCheckBox) arg0.getSource();
GameType variantType = null;
@SuppressWarnings("serial")
private class VariantCheckBox extends FCheckBox {
private final GameType variantType;
if (cb == vntVanguard) {
variantType = GameType.Vanguard;
}
else if (cb == vntCommander) {
variantType = GameType.Commander;
}
else if (cb == vntPlanechase) {
variantType = GameType.Planechase;
}
else if (cb == vntArchenemy) {
variantType = archenemyType.contains("Classic") ? GameType.Archenemy : GameType.ArchenemyRumble;
comboArchenemy.setEnabled(vntArchenemy.isSelected());
if (arg0.getStateChange() != ItemEvent.SELECTED) {
appliedVariants.remove(GameType.Archenemy);
appliedVariants.remove(GameType.ArchenemyRumble);
}
}
private VariantCheckBox(GameType variantType0) {
super(variantType0.toString());
if (null != variantType) {
if (arg0.getStateChange() == ItemEvent.SELECTED) {
appliedVariants.add(variantType);
currentGameMode = variantType;
}
else {
appliedVariants.remove(variantType);
if (currentGameMode == variantType) {
currentGameMode = GameType.Constructed;
variantType = variantType0;
setToolTipText(variantType.getDescription());
addItemListener(new ItemListener() {
@Override
public void itemStateChanged(ItemEvent e) {
if (e.getStateChange() == ItemEvent.SELECTED) {
appliedVariants.add(variantType);
currentGameMode = variantType;
//ensure other necessary variants are unchecked
switch (variantType) {
case Archenemy:
vntArchenemyRumble.setSelected(false);
break;
case ArchenemyRumble:
vntArchenemy.setSelected(false);
break;
case Commander:
vntMomirBasic.setSelected(false);
break;
case Vanguard:
vntMomirBasic.setSelected(false);
break;
case MomirBasic:
vntCommander.setSelected(false);
vntVanguard.setSelected(false);
break;
default:
break;
}
}
else {
appliedVariants.remove(variantType);
if (currentGameMode == variantType) {
currentGameMode = GameType.Constructed;
}
}
for (PlayerPanel pp : playerPanels) {
pp.toggleIsPlayerArchenemy();
}
changePlayerFocus(playerWithFocus, currentGameMode);
}
}
for (PlayerPanel pp : playerPanels) {
pp.toggleIsPlayerArchenemy();
pp.updateVariantControlsVisibility();
}
changePlayerFocus(playerWithFocus, currentGameMode);
});
}
};
// Listens to the archenemy combo box
private ActionListener aeComboListener = new ActionListener() {
@SuppressWarnings("unchecked")
@Override
public void actionPerformed(ActionEvent e) {
FComboBox<String> cb = (FComboBox<String>)e.getSource();
archenemyType = (String)cb.getSelectedItem();
GameType mode = archenemyType.contains("Classic") ? GameType.Archenemy : GameType.ArchenemyRumble;
appliedVariants.remove(GameType.Archenemy);
appliedVariants.remove(GameType.ArchenemyRumble);
appliedVariants.add(mode);
currentGameMode = mode;
for (PlayerPanel pp : playerPanels) {
pp.toggleIsPlayerArchenemy();
pp.updateVariantControlsVisibility();
}
changePlayerFocus(playerWithFocus, currentGameMode);
}
};
}
private ActionListener nameListener = new ActionListener() {
@Override