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

refactor overlay to use text mode

Browse Source 
- update assetmanager on resume
This commit is contained in:
Anthony Calosa
2022-07-10 16:44:59 +08:00
parent a744758823
commit 8cb8fb2bba
19 changed files with 826 additions and 1367 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
forge-gui-mobile/src/forge/Forge.java
View File

@@ -79,6 +79,7 @@ public class Forge implements ApplicationListener {
protected static TransitionScreen transitionScreen; protected static TransitionScreen transitionScreen;
public static KeyInputAdapter keyInputAdapter; public static KeyInputAdapter keyInputAdapter;
private static boolean exited; private static boolean exited;
private boolean needsUpdate = false;
public static boolean safeToClose = true; public static boolean safeToClose = true;
public static boolean magnify = false; public static boolean magnify = false;
public static boolean magnifyToggle = true; public static boolean magnifyToggle = true;
@@ -785,6 +786,10 @@ public class Forge implements ApplicationListener {
try { try {
ImageCache.allowSingleLoad(); ImageCache.allowSingleLoad();
ForgeAnimation.advanceAll(); ForgeAnimation.advanceAll();
if (needsUpdate) {
if (getAssets().manager.update())
needsUpdate = false;
}
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT); // Clear the screen. Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT); // Clear the screen.
@@ -922,6 +927,7 @@ public class Forge implements ApplicationListener {
@Override @Override
public void resume() { public void resume() {
Texture.setAssetManager(getAssets().manager); Texture.setAssetManager(getAssets().manager);
needsUpdate = true;
if (MatchController.getHostedMatch() != null) { if (MatchController.getHostedMatch() != null) {
MatchController.getHostedMatch().resume(); MatchController.getHostedMatch().resume();
} }

677
forge-gui-mobile/src/forge/deck/FDeckChooser.java
View File

@@ -131,75 +131,59 @@ public class FDeckChooser extends FScreen {
lstDecks = new DeckManager(gameType0); lstDecks = new DeckManager(gameType0);
isAi = isAi0; isAi = isAi0;
lstDecks.setItemActivateHandler(new FEventHandler() { lstDecks.setItemActivateHandler(event -> {
@Override if (lstDecks.getGameType() == GameType.DeckManager) {
public void handleEvent(FEvent e) { //for Deck Editor, edit deck instead of accepting
if (lstDecks.getGameType() == GameType.DeckManager) {
//for Deck Editor, edit deck instead of accepting
editSelectedDeck();
return;
}
accept();
}
});
btnNewDeck.setCommand(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
createNewDeck();
}
});
btnEditDeck.setCommand(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
editSelectedDeck(); editSelectedDeck();
return;
}
accept();
});
btnNewDeck.setCommand(event -> createNewDeck());
btnEditDeck.setCommand(event -> editSelectedDeck());
btnViewDeck.setCommand(event -> {
if (selectedDeckType != DeckType.STANDARD_COLOR_DECK && selectedDeckType != DeckType.STANDARD_CARDGEN_DECK
&& selectedDeckType != DeckType.PIONEER_CARDGEN_DECK && selectedDeckType != DeckType.HISTORIC_CARDGEN_DECK
&& selectedDeckType != DeckType.MODERN_CARDGEN_DECK && selectedDeckType != DeckType.LEGACY_CARDGEN_DECK
&& selectedDeckType != DeckType.VINTAGE_CARDGEN_DECK && selectedDeckType != DeckType.MODERN_COLOR_DECK &&
selectedDeckType != DeckType.COLOR_DECK && selectedDeckType != DeckType.THEME_DECK
&& selectedDeckType != DeckType.RANDOM_COMMANDER_DECK && selectedDeckType != DeckType.RANDOM_CARDGEN_COMMANDER_DECK) {
FDeckViewer.show(getDeck(), false, DeckType.DRAFT_DECK.equals(selectedDeckType));
} }
}); });
btnViewDeck.setCommand(new FEventHandler() { btnRandom.setCommand(event -> {
@Override if (lstDecks.getGameType() == GameType.DeckManager) {
public void handleEvent(FEvent e) { //for Deck Editor, test deck instead of randomly selecting deck
if (selectedDeckType != DeckType.STANDARD_COLOR_DECK && selectedDeckType != DeckType.STANDARD_CARDGEN_DECK testSelectedDeck();
&& selectedDeckType != DeckType.PIONEER_CARDGEN_DECK && selectedDeckType != DeckType.HISTORIC_CARDGEN_DECK return;
&& selectedDeckType != DeckType.MODERN_CARDGEN_DECK && selectedDeckType != DeckType.LEGACY_CARDGEN_DECK
&& selectedDeckType != DeckType.VINTAGE_CARDGEN_DECK && selectedDeckType != DeckType.MODERN_COLOR_DECK &&
selectedDeckType != DeckType.COLOR_DECK && selectedDeckType != DeckType.THEME_DECK
&& selectedDeckType != DeckType.RANDOM_COMMANDER_DECK && selectedDeckType != DeckType.RANDOM_CARDGEN_COMMANDER_DECK) {
FDeckViewer.show(getDeck(), false, DeckType.DRAFT_DECK.equals(selectedDeckType));
}
} }
}); if (selectedDeckType == DeckType.COLOR_DECK || selectedDeckType == DeckType.STANDARD_COLOR_DECK
btnRandom.setCommand(new FEventHandler() { || selectedDeckType == DeckType.MODERN_COLOR_DECK) {
@Override DeckgenUtil.randomSelectColors(lstDecks);
public void handleEvent(FEvent e) { }
if (lstDecks.getGameType() == GameType.DeckManager) { else if (selectedDeckType == DeckType.STANDARD_CARDGEN_DECK){
//for Deck Editor, test deck instead of randomly selecting deck DeckgenUtil.randomSelect(lstDecks);
testSelectedDeck(); }
return; else if (selectedDeckType == DeckType.PIONEER_CARDGEN_DECK){
} DeckgenUtil.randomSelect(lstDecks);
if (selectedDeckType == DeckType.COLOR_DECK || selectedDeckType == DeckType.STANDARD_COLOR_DECK }
|| selectedDeckType == DeckType.MODERN_COLOR_DECK) { else if (selectedDeckType == DeckType.HISTORIC_CARDGEN_DECK){
DeckgenUtil.randomSelectColors(lstDecks); DeckgenUtil.randomSelect(lstDecks);
} }
else if (selectedDeckType == DeckType.STANDARD_CARDGEN_DECK){ else if (selectedDeckType == DeckType.MODERN_CARDGEN_DECK){
DeckgenUtil.randomSelect(lstDecks); DeckgenUtil.randomSelect(lstDecks);
} }
else if (selectedDeckType == DeckType.PIONEER_CARDGEN_DECK){ else if (selectedDeckType == DeckType.LEGACY_CARDGEN_DECK){
DeckgenUtil.randomSelect(lstDecks); DeckgenUtil.randomSelect(lstDecks);
} }
else if (selectedDeckType == DeckType.HISTORIC_CARDGEN_DECK){ else if (selectedDeckType == DeckType.VINTAGE_CARDGEN_DECK){
DeckgenUtil.randomSelect(lstDecks); DeckgenUtil.randomSelect(lstDecks);
} }
else if (selectedDeckType == DeckType.MODERN_CARDGEN_DECK){ else {
DeckgenUtil.randomSelect(lstDecks); int size = 0;
} try {
else if (selectedDeckType == DeckType.LEGACY_CARDGEN_DECK){
DeckgenUtil.randomSelect(lstDecks);
}
else if (selectedDeckType == DeckType.VINTAGE_CARDGEN_DECK){
DeckgenUtil.randomSelect(lstDecks);
}
else {
int size = 0;
if (isAi && !isGeneratedDeck(selectedDeckType) && Forge.autoAIDeckSelection) { if (isAi && !isGeneratedDeck(selectedDeckType) && Forge.autoAIDeckSelection) {
btnRandom.setEnabled(false);
AIDecks = lstDecks.getPool().toFlatList().parallelStream().filter(deckProxy -> deckProxy.getAI().inMainDeck == 0).collect(Collectors.toList()); AIDecks = lstDecks.getPool().toFlatList().parallelStream().filter(deckProxy -> deckProxy.getAI().inMainDeck == 0).collect(Collectors.toList());
size = AIDecks.size(); size = AIDecks.size();
} }
@@ -207,9 +191,12 @@ public class FDeckChooser extends FScreen {
lstDecks.setSelectedItem(AIDecks.get(MyRandom.getRandom().nextInt(size))); lstDecks.setSelectedItem(AIDecks.get(MyRandom.getRandom().nextInt(size)));
else else
DeckgenUtil.randomSelect(lstDecks); DeckgenUtil.randomSelect(lstDecks);
} catch (Exception ee) {
DeckgenUtil.randomSelect(lstDecks);
} }
accept();
} }
btnRandom.setEnabled(true);
accept();
}); });
switch (lstDecks.getGameType()) { switch (lstDecks.getGameType()) {
case Constructed: case Constructed:
@@ -371,32 +358,29 @@ public class FDeckChooser extends FScreen {
} else { } else {
editor = new FDeckEditor(getEditorType(), "", false); editor = new FDeckEditor(getEditorType(), "", false);
} }
editor.setSaveHandler(new FEventHandler() { editor.setSaveHandler(event -> {
@Override //ensure user returns to proper deck type and that list is refreshed if new deck is saved
public void handleEvent(FEvent e) { if (!needRefreshOnActivate) {
//ensure user returns to proper deck type and that list is refreshed if new deck is saved needRefreshOnActivate = true;
if (!needRefreshOnActivate) { if (lstDecks.getGameType() == GameType.DeckManager) {
needRefreshOnActivate = true; switch (selectedDeckType) {
if (lstDecks.getGameType() == GameType.DeckManager) { case COMMANDER_DECK:
switch (selectedDeckType) { case OATHBREAKER_DECK:
case COMMANDER_DECK: case TINY_LEADERS_DECK:
case OATHBREAKER_DECK: case BRAWL_DECK:
case TINY_LEADERS_DECK: case SCHEME_DECK:
case BRAWL_DECK: case PLANAR_DECK:
case SCHEME_DECK: case DRAFT_DECK:
case PLANAR_DECK: case SEALED_DECK:
case DRAFT_DECK: break;
case SEALED_DECK: default:
break; setSelectedDeckType(DeckType.CONSTRUCTED_DECK);
default: break;
setSelectedDeckType(DeckType.CONSTRUCTED_DECK);
break;
}
}
else {
setSelectedDeckType(DeckType.CUSTOM_DECK);
} }
} }
else {
setSelectedDeckType(DeckType.CUSTOM_DECK);
}
} }
}); });
Forge.openScreen(editor); Forge.openScreen(editor);
@@ -624,249 +608,205 @@ public class FDeckChooser extends FScreen {
cmbDeckTypes.setAlignment(Align.center); cmbDeckTypes.setAlignment(Align.center);
restoreSavedState(); restoreSavedState();
cmbDeckTypes.setChangedHandler(new FEventHandler() { cmbDeckTypes.setChangedHandler(event -> {
@Override final DeckType deckType = cmbDeckTypes.getSelectedItem();
public void handleEvent(final FEvent e) { if (!refreshingDeckType&&(deckType == DeckType.NET_DECK || deckType == DeckType.NET_COMMANDER_DECK)) {
final DeckType deckType = cmbDeckTypes.getSelectedItem(); //needed for loading net decks
FThreads.invokeInBackgroundThread(() -> {
GameType gameType = lstDecks.getGameType();
if (gameType == GameType.DeckManager) {
gameType = deckType == DeckType.NET_COMMANDER_DECK ? GameType.Commander : GameType.Constructed;
}
final NetDeckCategory category = NetDeckCategory.selectAndLoad(gameType);
if (!refreshingDeckType&&(deckType == DeckType.NET_DECK || deckType == DeckType.NET_COMMANDER_DECK)) { FThreads.invokeInEdtLater(() -> {
FThreads.invokeInBackgroundThread(new Runnable() { //needed for loading net decks if (category == null) {
@Override cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
public void run() { if (selectedDeckType == deckType && netDeckCategory != null) {
GameType gameType = lstDecks.getGameType(); cmbDeckTypes.setText(netDeckCategory.getDeckType());
if (gameType == GameType.DeckManager) {
gameType = deckType == DeckType.NET_COMMANDER_DECK ? GameType.Commander : GameType.Constructed;
} }
final NetDeckCategory category = NetDeckCategory.selectAndLoad(gameType); return;
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
if (category == null) {
cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
if (selectedDeckType == deckType && netDeckCategory != null) {
cmbDeckTypes.setText(netDeckCategory.getDeckType());
}
return;
}
netDeckCategory = category;
refreshDecksList(deckType, true, e);
}
});
} }
netDeckCategory = category;
refreshDecksList(deckType, true, event);
}); });
return; });
} return;
if (!refreshingDeckType&&(deckType == DeckType.NET_ARCHIVE_STANDARD_DECK)) {
FThreads.invokeInBackgroundThread(new Runnable() { //needed for loading net decks
@Override
public void run() {
GameType gameType = lstDecks.getGameType();
if (gameType == GameType.DeckManager) {
gameType = GameType.Constructed;
}
final NetDeckArchiveStandard category = NetDeckArchiveStandard.selectAndLoad(gameType);
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
if (category == null) {
cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
if (selectedDeckType == deckType && NetDeckArchiveStandard != null) {
cmbDeckTypes.setText(NetDeckArchiveStandard.getDeckType());
}
return;
}
NetDeckArchiveStandard = category;
refreshDecksList(deckType, true, e);
}
});
}
});
return;
}
if (!refreshingDeckType&&(deckType == DeckType.NET_ARCHIVE_PIONEER_DECK)) {
FThreads.invokeInBackgroundThread(new Runnable() { //needed for loading net decks
@Override
public void run() {
GameType gameType = lstDecks.getGameType();
if (gameType == GameType.DeckManager) {
gameType = GameType.Constructed;
}
final NetDeckArchivePioneer category = NetDeckArchivePioneer.selectAndLoad(gameType);
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
if (category == null) {
cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
if (selectedDeckType == deckType && NetDeckArchivePioneer != null) {
cmbDeckTypes.setText(NetDeckArchivePioneer.getDeckType());
}
return;
}
NetDeckArchivePioneer = category;
refreshDecksList(deckType, true, e);
}
});
}
});
return;
}
if (!refreshingDeckType&&(deckType == DeckType.NET_ARCHIVE_MODERN_DECK)) {
FThreads.invokeInBackgroundThread(new Runnable() { //needed for loading net decks
@Override
public void run() {
GameType gameType = lstDecks.getGameType();
if (gameType == GameType.DeckManager) {
gameType = GameType.Constructed;
}
final NetDeckArchiveModern category = NetDeckArchiveModern.selectAndLoad(gameType);
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
if (category == null) {
cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
if (selectedDeckType == deckType && NetDeckArchiveModern != null) {
cmbDeckTypes.setText(NetDeckArchiveModern.getDeckType());
}
return;
}
NetDeckArchiveModern = category;
refreshDecksList(deckType, true, e);
}
});
}
});
return;
}
if (!refreshingDeckType&&(deckType == DeckType.NET_ARCHIVE_PAUPER_DECK)) {
FThreads.invokeInBackgroundThread(new Runnable() { //needed for loading net decks
@Override
public void run() {
GameType gameType = lstDecks.getGameType();
if (gameType == GameType.DeckManager) {
gameType = GameType.Constructed;
}
final NetDeckArchivePauper category = NetDeckArchivePauper.selectAndLoad(gameType);
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
if (category == null) {
cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
if (selectedDeckType == deckType && NetDeckArchivePauper != null) {
cmbDeckTypes.setText(NetDeckArchivePauper.getDeckType());
}
return;
}
NetDeckArchivePauper = category;
refreshDecksList(deckType, true, e);
}
});
}
});
return;
}
if (!refreshingDeckType&&(deckType == DeckType.NET_ARCHIVE_LEGACY_DECK)) {
FThreads.invokeInBackgroundThread(new Runnable() { //needed for loading net decks
@Override
public void run() {
GameType gameType = lstDecks.getGameType();
if (gameType == GameType.DeckManager) {
gameType = GameType.Constructed;
}
final NetDeckArchiveLegacy category = NetDeckArchiveLegacy.selectAndLoad(gameType);
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
if (category == null) {
cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
if (selectedDeckType == deckType && NetDeckArchiveLegacy != null) {
cmbDeckTypes.setText(NetDeckArchiveLegacy.getDeckType());
}
return;
}
NetDeckArchiveLegacy = category;
refreshDecksList(deckType, true, e);
}
});
}
});
return;
}
if (!refreshingDeckType&&(deckType == DeckType.NET_ARCHIVE_VINTAGE_DECK)) {
FThreads.invokeInBackgroundThread(new Runnable() { //needed for loading net decks
@Override
public void run() {
GameType gameType = lstDecks.getGameType();
if (gameType == GameType.DeckManager) {
gameType = GameType.Constructed;
}
final NetDeckArchiveVintage category = NetDeckArchiveVintage.selectAndLoad(gameType);
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
if (category == null) {
cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
if (selectedDeckType == deckType && NetDeckArchiveVintage != null) {
cmbDeckTypes.setText(NetDeckArchiveVintage.getDeckType());
}
return;
}
NetDeckArchiveVintage = category;
refreshDecksList(deckType, true, e);
}
});
}
});
return;
}
if (!refreshingDeckType&&(deckType == DeckType.NET_ARCHIVE_BLOCK_DECK)) {
FThreads.invokeInBackgroundThread(new Runnable() { //needed for loading net decks
@Override
public void run() {
GameType gameType = lstDecks.getGameType();
if (gameType == GameType.DeckManager) {
gameType = GameType.Constructed;
}
final NetDeckArchiveBlock category = NetDeckArchiveBlock.selectAndLoad(gameType);
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
if (category == null) {
cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
if (selectedDeckType == deckType && NetDeckArchiveBlock != null) {
cmbDeckTypes.setText(NetDeckArchiveBlock.getDeckType());
}
return;
}
NetDeckArchiveBlock = category;
refreshDecksList(deckType, true, e);
}
});
}
});
return;
}
refreshDecksList(deckType, false, e);
} }
if (!refreshingDeckType&&(deckType == DeckType.NET_ARCHIVE_STANDARD_DECK)) {
//needed for loading net decks
FThreads.invokeInBackgroundThread(() -> {
GameType gameType = lstDecks.getGameType();
if (gameType == GameType.DeckManager) {
gameType = GameType.Constructed;
}
final NetDeckArchiveStandard category = NetDeckArchiveStandard.selectAndLoad(gameType);
FThreads.invokeInEdtLater(() -> {
if (category == null) {
cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
if (selectedDeckType == deckType && NetDeckArchiveStandard != null) {
cmbDeckTypes.setText(NetDeckArchiveStandard.getDeckType());
}
return;
}
NetDeckArchiveStandard = category;
refreshDecksList(deckType, true, event);
});
});
return;
}
if (!refreshingDeckType&&(deckType == DeckType.NET_ARCHIVE_PIONEER_DECK)) {
//needed for loading net decks
FThreads.invokeInBackgroundThread(() -> {
GameType gameType = lstDecks.getGameType();
if (gameType == GameType.DeckManager) {
gameType = GameType.Constructed;
}
final NetDeckArchivePioneer category = NetDeckArchivePioneer.selectAndLoad(gameType);
FThreads.invokeInEdtLater(() -> {
if (category == null) {
cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
if (selectedDeckType == deckType && NetDeckArchivePioneer != null) {
cmbDeckTypes.setText(NetDeckArchivePioneer.getDeckType());
}
return;
}
NetDeckArchivePioneer = category;
refreshDecksList(deckType, true, event);
});
});
return;
}
if (!refreshingDeckType&&(deckType == DeckType.NET_ARCHIVE_MODERN_DECK)) {
//needed for loading net decks
FThreads.invokeInBackgroundThread(() -> {
GameType gameType = lstDecks.getGameType();
if (gameType == GameType.DeckManager) {
gameType = GameType.Constructed;
}
final NetDeckArchiveModern category = NetDeckArchiveModern.selectAndLoad(gameType);
FThreads.invokeInEdtLater(() -> {
if (category == null) {
cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
if (selectedDeckType == deckType && NetDeckArchiveModern != null) {
cmbDeckTypes.setText(NetDeckArchiveModern.getDeckType());
}
return;
}
NetDeckArchiveModern = category;
refreshDecksList(deckType, true, event);
});
});
return;
}
if (!refreshingDeckType&&(deckType == DeckType.NET_ARCHIVE_PAUPER_DECK)) {
//needed for loading net decks
FThreads.invokeInBackgroundThread(() -> {
GameType gameType = lstDecks.getGameType();
if (gameType == GameType.DeckManager) {
gameType = GameType.Constructed;
}
final NetDeckArchivePauper category = NetDeckArchivePauper.selectAndLoad(gameType);
FThreads.invokeInEdtLater(() -> {
if (category == null) {
cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
if (selectedDeckType == deckType && NetDeckArchivePauper != null) {
cmbDeckTypes.setText(NetDeckArchivePauper.getDeckType());
}
return;
}
NetDeckArchivePauper = category;
refreshDecksList(deckType, true, event);
});
});
return;
}
if (!refreshingDeckType&&(deckType == DeckType.NET_ARCHIVE_LEGACY_DECK)) {
//needed for loading net decks
FThreads.invokeInBackgroundThread(() -> {
GameType gameType = lstDecks.getGameType();
if (gameType == GameType.DeckManager) {
gameType = GameType.Constructed;
}
final NetDeckArchiveLegacy category = NetDeckArchiveLegacy.selectAndLoad(gameType);
FThreads.invokeInEdtLater(() -> {
if (category == null) {
cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
if (selectedDeckType == deckType && NetDeckArchiveLegacy != null) {
cmbDeckTypes.setText(NetDeckArchiveLegacy.getDeckType());
}
return;
}
NetDeckArchiveLegacy = category;
refreshDecksList(deckType, true, event);
});
});
return;
}
if (!refreshingDeckType&&(deckType == DeckType.NET_ARCHIVE_VINTAGE_DECK)) {
//needed for loading net decks
FThreads.invokeInBackgroundThread(() -> {
GameType gameType = lstDecks.getGameType();
if (gameType == GameType.DeckManager) {
gameType = GameType.Constructed;
}
final NetDeckArchiveVintage category = NetDeckArchiveVintage.selectAndLoad(gameType);
FThreads.invokeInEdtLater(() -> {
if (category == null) {
cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
if (selectedDeckType == deckType && NetDeckArchiveVintage != null) {
cmbDeckTypes.setText(NetDeckArchiveVintage.getDeckType());
}
return;
}
NetDeckArchiveVintage = category;
refreshDecksList(deckType, true, event);
});
});
return;
}
if (!refreshingDeckType&&(deckType == DeckType.NET_ARCHIVE_BLOCK_DECK)) {
//needed for loading net decks
FThreads.invokeInBackgroundThread(() -> {
GameType gameType = lstDecks.getGameType();
if (gameType == GameType.DeckManager) {
gameType = GameType.Constructed;
}
final NetDeckArchiveBlock category = NetDeckArchiveBlock.selectAndLoad(gameType);
FThreads.invokeInEdtLater(() -> {
if (category == null) {
cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
if (selectedDeckType == deckType && NetDeckArchiveBlock != null) {
cmbDeckTypes.setText(NetDeckArchiveBlock.getDeckType());
}
return;
}
NetDeckArchiveBlock = category;
refreshDecksList(deckType, true, event);
});
});
return;
}
refreshDecksList(deckType, false, event);
}); });
add(cmbDeckTypes); add(cmbDeckTypes);
add(lstDecks); add(lstDecks);
@@ -888,11 +828,11 @@ public class FDeckChooser extends FScreen {
saveState(); saveState();
} }
private void refreshDecksList(DeckType deckType, boolean forceRefresh, FEvent e) { private void refreshDecksList(DeckType deckType, boolean forceRefresh, FEvent event) {
if (selectedDeckType == deckType && !forceRefresh) { return; } if (selectedDeckType == deckType && !forceRefresh) { return; }
selectedDeckType = deckType; selectedDeckType = deckType;
if (e == null) { if (event == null) {
refreshingDeckType = true; refreshingDeckType = true;
cmbDeckTypes.setSelectedItem(deckType); cmbDeckTypes.setSelectedItem(deckType);
refreshingDeckType = false; refreshingDeckType = false;
@@ -1186,7 +1126,7 @@ public class FDeckChooser extends FScreen {
btnRandom.setLeft(getWidth() - PADDING - btnRandom.getWidth()); btnRandom.setLeft(getWidth() - PADDING - btnRandom.getWidth());
if (e != null) { //set default list selection if from combo box change event if (event != null) { //set default list selection if from combo box change event
if (deckType == DeckType.COLOR_DECK) { if (deckType == DeckType.COLOR_DECK) {
// default selection = basic two color deck // default selection = basic two color deck
lstDecks.setSelectedIndices(new Integer[]{0, 1}); lstDecks.setSelectedIndices(new Integer[]{0, 1});
@@ -1510,36 +1450,26 @@ public class FDeckChooser extends FScreen {
return; return;
} }
FThreads.invokeInBackgroundThread(new Runnable() { //needed for loading net decks //needed for loading net decks
@Override FThreads.invokeInBackgroundThread(() -> {
public void run() { final NetDeckCategory netCat;
final NetDeckCategory netCat; if (allowedDeckTypes.contains(DeckType.NET_DECK)) {
if (allowedDeckTypes.contains(DeckType.NET_DECK)) { netCat = NetDeckCategory.selectAndLoad(GameType.Constructed);
netCat = NetDeckCategory.selectAndLoad(GameType.Constructed); } else {
} else { netCat = null;
netCat = null;
}
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), new Runnable() {
@Override
public void run() {
GauntletData gauntlet = GauntletUtil.createQuickGauntlet(userDeck, numOpponents, allowedDeckTypes, netCat);
FModel.setGauntletData(gauntlet);
List<RegisteredPlayer> players = new ArrayList<>();
RegisteredPlayer humanPlayer = new RegisteredPlayer(userDeck).setPlayer(GamePlayerUtil.getGuiPlayer());
players.add(humanPlayer);
players.add(new RegisteredPlayer(gauntlet.getDecks().get(gauntlet.getCompleted())).setPlayer(GamePlayerUtil.createAiPlayer()));
gauntlet.startRound(players, humanPlayer);
}
});
}
});
} }
FThreads.invokeInEdtLater(() -> LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), true, () -> {
GauntletData gauntlet = GauntletUtil.createQuickGauntlet(userDeck, numOpponents, allowedDeckTypes, netCat);
FModel.setGauntletData(gauntlet);
List<RegisteredPlayer> players = new ArrayList<>();
RegisteredPlayer humanPlayer = new RegisteredPlayer(userDeck).setPlayer(GamePlayerUtil.getGuiPlayer());
players.add(humanPlayer);
players.add(new RegisteredPlayer(gauntlet.getDecks().get(gauntlet.getCompleted())).setPlayer(GamePlayerUtil.createAiPlayer()));
gauntlet.startRound(players, humanPlayer);
}));
}); });
} }
}); });
@@ -1554,26 +1484,23 @@ public class FDeckChooser extends FScreen {
public void run(final Deck aiDeck) { public void run(final Deck aiDeck) {
if (aiDeck == null) { return; } if (aiDeck == null) { return; }
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), new Runnable() { LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), true, () -> {
@Override Set<GameType> appliedVariants = new HashSet<>();
public void run() { appliedVariants.add(variant);
Set<GameType> appliedVariants = new HashSet<>();
appliedVariants.add(variant);
List<RegisteredPlayer> players = new ArrayList<>(); List<RegisteredPlayer> players = new ArrayList<>();
RegisteredPlayer humanPlayer = RegisteredPlayer.forVariants(2, appliedVariants, userDeck, null, false, null, null); RegisteredPlayer humanPlayer = RegisteredPlayer.forVariants(2, appliedVariants, userDeck, null, false, null, null);
humanPlayer.setPlayer(GamePlayerUtil.getGuiPlayer()); humanPlayer.setPlayer(GamePlayerUtil.getGuiPlayer());
RegisteredPlayer aiPlayer = RegisteredPlayer.forVariants(2, appliedVariants, aiDeck, null, false, null, null); RegisteredPlayer aiPlayer = RegisteredPlayer.forVariants(2, appliedVariants, aiDeck, null, false, null, null);
aiPlayer.setPlayer(GamePlayerUtil.createAiPlayer()); aiPlayer.setPlayer(GamePlayerUtil.createAiPlayer());
players.add(humanPlayer); players.add(humanPlayer);
players.add(aiPlayer); players.add(aiPlayer);
final Map<RegisteredPlayer, IGuiGame> guiMap = new HashMap<>(); final Map<RegisteredPlayer, IGuiGame> guiMap = new HashMap<>();
guiMap.put(humanPlayer, MatchController.instance); guiMap.put(humanPlayer, MatchController.instance);
final HostedMatch hostedMatch = GuiBase.getInterface().hostMatch(); final HostedMatch hostedMatch = GuiBase.getInterface().hostMatch();
hostedMatch.startMatch(GameType.Constructed, appliedVariants, players, guiMap); hostedMatch.startMatch(GameType.Constructed, appliedVariants, players, guiMap);
}
}); });
} }
}); });

41
forge-gui-mobile/src/forge/screens/LoadingOverlay.java
View File

@@ -22,39 +22,25 @@ public class LoadingOverlay extends FOverlay {
private static final FSkinFont FONT = FSkinFont.get(22); private static final FSkinFont FONT = FSkinFont.get(22);
private static final FSkinColor BACK_COLOR = FSkinColor.get(Colors.CLR_ACTIVE).alphaColor(0.75f); private static final FSkinColor BACK_COLOR = FSkinColor.get(Colors.CLR_ACTIVE).alphaColor(0.75f);
private static final FSkinColor FORE_COLOR = FSkinColor.get(Colors.CLR_TEXT); private static final FSkinColor FORE_COLOR = FSkinColor.get(Colors.CLR_TEXT);
public static void show(String caption0, final Runnable runnable) { public static void show(String caption0, final Runnable runnable) {
final LoadingOverlay loader = new LoadingOverlay(caption0); show(caption0, false, runnable);
}
public static void show(String caption0, boolean textMode, final Runnable runnable) {
final LoadingOverlay loader = new LoadingOverlay(caption0, textMode);
loader.show(); //show loading overlay then delay running remaining logic so UI can respond loader.show(); //show loading overlay then delay running remaining logic so UI can respond
ThreadUtil.invokeInGameThread(new Runnable() { ThreadUtil.invokeInGameThread(() -> FThreads.invokeInEdtLater(() -> {
@Override runnable.run();
public void run() { loader.hide();
FThreads.invokeInEdtLater(new Runnable() { loader.finishedloading(); //setLoadingaMatch to false
@Override }));
public void run() {
runnable.run();
loader.hide();
loader.finishedloading(); //setLoadingaMatch to false
}
});
}
});
} }
public static void runBackgroundTask(String caption0, final Runnable task) { public static void runBackgroundTask(String caption0, final Runnable task) {
final LoadingOverlay loader = new LoadingOverlay(caption0); final LoadingOverlay loader = new LoadingOverlay(caption0, true);
loader.show(); loader.show();
FThreads.invokeInBackgroundThread(new Runnable() { FThreads.invokeInBackgroundThread(() -> {
@Override task.run();
public void run() { FThreads.invokeInEdtLater(() -> loader.hide());
task.run();
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
loader.hide();
}
});
}
}); });
} }
@@ -63,6 +49,7 @@ public class LoadingOverlay extends FOverlay {
public LoadingOverlay(String caption0) { public LoadingOverlay(String caption0) {
caption = caption0; caption = caption0;
textMode = false;
} }
public LoadingOverlay(String caption0, boolean textOnly) { public LoadingOverlay(String caption0, boolean textOnly) {

158
forge-gui-mobile/src/forge/screens/constructed/LobbyScreen.java
View File

@@ -111,23 +111,20 @@ public abstract class LobbyScreen extends LaunchScreen implements ILobbyView {
cbPlayerCount.addItem(i); cbPlayerCount.addItem(i);
} }
cbPlayerCount.setSelectedItem(2); cbPlayerCount.setSelectedItem(2);
cbPlayerCount.setChangedHandler(new FEventHandler() { cbPlayerCount.setChangedHandler(event -> {
@Override int numPlayers = getNumPlayers();
public void handleEvent(FEvent e) { while(lobby.getNumberOfSlots() < getNumPlayers()){
int numPlayers = getNumPlayers(); lobby.addSlot();
while(lobby.getNumberOfSlots() < getNumPlayers()){
lobby.addSlot();
}
while(lobby.getNumberOfSlots() > getNumPlayers()){
lobby.removeSlot(lobby.getNumberOfSlots()-1);
}
for (int i = 0; i < MAX_PLAYERS; i++) {
if(i<playerPanels.size()) {
playerPanels.get(i).setVisible(i < numPlayers);
}
}
playersScroll.revalidate();
} }
while(lobby.getNumberOfSlots() > getNumPlayers()){
lobby.removeSlot(lobby.getNumberOfSlots()-1);
}
for (int i = 0; i < MAX_PLAYERS; i++) {
if(i<playerPanels.size()) {
playerPanels.get(i).setVisible(i < numPlayers);
}
}
playersScroll.revalidate();
}); });
initLobby(lobby0); initLobby(lobby0);
@@ -139,12 +136,7 @@ public abstract class LobbyScreen extends LaunchScreen implements ILobbyView {
cbGamesInMatch.addItem("3"); cbGamesInMatch.addItem("3");
cbGamesInMatch.addItem("5"); cbGamesInMatch.addItem("5");
cbGamesInMatch.setSelectedItem(FModel.getPreferences().getPref((FPref.UI_MATCHES_PER_GAME))); cbGamesInMatch.setSelectedItem(FModel.getPreferences().getPref((FPref.UI_MATCHES_PER_GAME)));
cbGamesInMatch.setChangedHandler(new FEventHandler() { cbGamesInMatch.setChangedHandler(event -> FModel.getPreferences().setPref(FPref.UI_MATCHES_PER_GAME, cbGamesInMatch.getSelectedItem()));
@Override
public void handleEvent(FEvent e) {
FModel.getPreferences().setPref(FPref.UI_MATCHES_PER_GAME, cbGamesInMatch.getSelectedItem());
}
});
add(lblVariants); add(lblVariants);
add(cbVariants); add(cbVariants);
@@ -161,31 +153,28 @@ public abstract class LobbyScreen extends LaunchScreen implements ILobbyView {
cbVariants.addItem(GameType.Archenemy); cbVariants.addItem(GameType.Archenemy);
cbVariants.addItem(GameType.ArchenemyRumble); cbVariants.addItem(GameType.ArchenemyRumble);
cbVariants.addItem(Forge.getLocalizer().getMessage("lblMore")); cbVariants.addItem(Forge.getLocalizer().getMessage("lblMore"));
cbVariants.setChangedHandler(new FEventHandler() { cbVariants.setChangedHandler(event -> {
@Override if (cbVariants.getSelectedIndex() <= 0) {
public void handleEvent(FEvent e) { lobby.clearVariants();
if (cbVariants.getSelectedIndex() <= 0) { updateLayoutForVariants();
lobby.clearVariants(); Set<GameType> gameTypes = new HashSet<>();
updateLayoutForVariants(); FModel.getPreferences().setGameType(FPref.UI_APPLIED_VARIANTS, gameTypes);
Set<GameType> gameTypes = new HashSet<>(); FModel.getPreferences().save();
FModel.getPreferences().setGameType(FPref.UI_APPLIED_VARIANTS, gameTypes); }
FModel.getPreferences().save(); else if (cbVariants.getSelectedIndex() == cbVariants.getItemCount() - 1) {
} Forge.openScreen(new MultiVariantSelect());
else if (cbVariants.getSelectedIndex() == cbVariants.getItemCount() - 1) { updateVariantSelection();
Forge.openScreen(new MultiVariantSelect()); }
updateVariantSelection(); else {
} lobby.clearVariants();
else { lobby.applyVariant((GameType)cbVariants.getSelectedItem());
lobby.clearVariants(); updateLayoutForVariants();
lobby.applyVariant((GameType)cbVariants.getSelectedItem()); Set<GameType> gameTypes = new HashSet<>();
updateLayoutForVariants(); for (GameType variant: lobby.getAppliedVariants()) {
Set<GameType> gameTypes = new HashSet<>(); gameTypes.add(variant);
for (GameType variant: lobby.getAppliedVariants()) {
gameTypes.add(variant);
}
FModel.getPreferences().setGameType(FPref.UI_APPLIED_VARIANTS, gameTypes);
FModel.getPreferences().save();
} }
FModel.getPreferences().setGameType(FPref.UI_APPLIED_VARIANTS, gameTypes);
FModel.getPreferences().save();
} }
}); });
@@ -195,40 +184,34 @@ public abstract class LobbyScreen extends LaunchScreen implements ILobbyView {
updatePlayersFromPrefs(); updatePlayersFromPrefs();
FThreads.invokeInBackgroundThread(new Runnable() { FThreads.invokeInBackgroundThread(() -> {
@Override playerPanels.get(0).initialize(FPref.CONSTRUCTED_P1_DECK_STATE, FPref.COMMANDER_P1_DECK_STATE, FPref.OATHBREAKER_P1_DECK_STATE, FPref.TINY_LEADER_P1_DECK_STATE, FPref.BRAWL_P1_DECK_STATE, DeckType.PRECONSTRUCTED_DECK);
public void run() { playerPanels.get(1).initialize(FPref.CONSTRUCTED_P2_DECK_STATE, FPref.COMMANDER_P2_DECK_STATE, FPref.OATHBREAKER_P2_DECK_STATE, FPref.TINY_LEADER_P2_DECK_STATE, FPref.BRAWL_P2_DECK_STATE, DeckType.COLOR_DECK);
playerPanels.get(0).initialize(FPref.CONSTRUCTED_P1_DECK_STATE, FPref.COMMANDER_P1_DECK_STATE, FPref.OATHBREAKER_P1_DECK_STATE, FPref.TINY_LEADER_P1_DECK_STATE, FPref.BRAWL_P1_DECK_STATE, DeckType.PRECONSTRUCTED_DECK); try {
playerPanels.get(1).initialize(FPref.CONSTRUCTED_P2_DECK_STATE, FPref.COMMANDER_P2_DECK_STATE, FPref.OATHBREAKER_P2_DECK_STATE, FPref.TINY_LEADER_P2_DECK_STATE, FPref.BRAWL_P2_DECK_STATE, DeckType.COLOR_DECK); if (getNumPlayers() > 2) {
try { playerPanels.get(2).initialize(FPref.CONSTRUCTED_P3_DECK_STATE, FPref.COMMANDER_P3_DECK_STATE, FPref.OATHBREAKER_P3_DECK_STATE, FPref.TINY_LEADER_P3_DECK_STATE, FPref.BRAWL_P3_DECK_STATE, DeckType.COLOR_DECK);
if (getNumPlayers() > 2) { }
playerPanels.get(2).initialize(FPref.CONSTRUCTED_P3_DECK_STATE, FPref.COMMANDER_P3_DECK_STATE, FPref.OATHBREAKER_P3_DECK_STATE, FPref.TINY_LEADER_P3_DECK_STATE, FPref.BRAWL_P3_DECK_STATE, DeckType.COLOR_DECK); if (getNumPlayers() > 3) {
} playerPanels.get(3).initialize(FPref.CONSTRUCTED_P4_DECK_STATE, FPref.COMMANDER_P4_DECK_STATE, FPref.OATHBREAKER_P3_DECK_STATE, FPref.TINY_LEADER_P4_DECK_STATE, FPref.BRAWL_P4_DECK_STATE, DeckType.COLOR_DECK);
if (getNumPlayers() > 3) { }
playerPanels.get(3).initialize(FPref.CONSTRUCTED_P4_DECK_STATE, FPref.COMMANDER_P4_DECK_STATE, FPref.OATHBREAKER_P3_DECK_STATE, FPref.TINY_LEADER_P4_DECK_STATE, FPref.BRAWL_P4_DECK_STATE, DeckType.COLOR_DECK); } catch (Exception e) {}
} /*playerPanels.get(4).initialize(FPref.CONSTRUCTED_P5_DECK_STATE, DeckType.COLOR_DECK);
} catch (Exception e) {} playerPanels.get(5).initialize(FPref.CONSTRUCTED_P6_DECK_STATE, DeckType.COLOR_DECK);
/*playerPanels.get(4).initialize(FPref.CONSTRUCTED_P5_DECK_STATE, DeckType.COLOR_DECK); playerPanels.get(6).initialize(FPref.CONSTRUCTED_P7_DECK_STATE, DeckType.COLOR_DECK);
playerPanels.get(5).initialize(FPref.CONSTRUCTED_P6_DECK_STATE, DeckType.COLOR_DECK); playerPanels.get(7).initialize(FPref.CONSTRUCTED_P8_DECK_STATE, DeckType.COLOR_DECK);*/ //TODO: Improve performance of loading this screen by using background thread
playerPanels.get(6).initialize(FPref.CONSTRUCTED_P7_DECK_STATE, DeckType.COLOR_DECK);
playerPanels.get(7).initialize(FPref.CONSTRUCTED_P8_DECK_STATE, DeckType.COLOR_DECK);*/ //TODO: Improve performance of loading this screen by using background thread
FThreads.invokeInEdtLater(new Runnable() { FThreads.invokeInEdtLater(() -> {
@Override btnStart.setEnabled(lobby.hasControl());
public void run() {
btnStart.setEnabled(lobby.hasControl());
Set<GameType> gameTypes = FModel.getPreferences().getGameType(FPref.UI_APPLIED_VARIANTS); Set<GameType> gameTypes = FModel.getPreferences().getGameType(FPref.UI_APPLIED_VARIANTS);
if (!gameTypes.isEmpty()) { if (!gameTypes.isEmpty()) {
for (GameType gameType : gameTypes) { for (GameType gameType : gameTypes) {
lobby.applyVariant(gameType); lobby.applyVariant(gameType);
}
updateVariantSelection();
updateLayoutForVariants();
}
} }
}); updateVariantSelection();
} updateLayoutForVariants();
}
});
}); });
lblPlayers.setEnabled(true); lblPlayers.setEnabled(true);
@@ -351,20 +334,13 @@ public abstract class LobbyScreen extends LaunchScreen implements ILobbyView {
updateName(0, GamePlayerUtil.getGuiPlayer().getName()); updateName(0, GamePlayerUtil.getGuiPlayer().getName());
} }
} }
FThreads.invokeInBackgroundThread(new Runnable() { //must call startGame in background thread in case there are alerts //must call startGame in background thread in case there are alerts
@Override FThreads.invokeInBackgroundThread(() -> {
public void run() { final Runnable startGame = lobby.startGame();
final Runnable startGame = lobby.startGame(); if (startGame != null) {
if (startGame != null) { //set this so we cant get any multi/rapid tap on start button
//set this so we cant get any multi/rapid tap on start button Forge.setLoadingaMatch(true);
Forge.setLoadingaMatch(true); FThreads.invokeInEdtLater(() -> LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), true, startGame));
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), startGame);
}
});
}
} }
}); });
} }

130
forge-gui-mobile/src/forge/screens/gauntlet/LoadGauntletScreen.java
View File

@@ -53,26 +53,11 @@ public class LoadGauntletScreen extends LaunchScreen {
super(null, LoadGameMenu.getMenu()); super(null, LoadGameMenu.getMenu());
btnNewGauntlet.setFont(FSkinFont.get(16)); btnNewGauntlet.setFont(FSkinFont.get(16));
btnNewGauntlet.setCommand(new FEventHandler() { btnNewGauntlet.setCommand(event -> NewGameScreen.Gauntlet.open());
@Override
public void handleEvent(FEvent e) {
NewGameScreen.Gauntlet.open();
}
});
btnRenameGauntlet.setFont(btnNewGauntlet.getFont()); btnRenameGauntlet.setFont(btnNewGauntlet.getFont());
btnRenameGauntlet.setCommand(new FEventHandler() { btnRenameGauntlet.setCommand(event -> renameGauntlet(lstGauntlets.getSelectedGauntlet()));
@Override
public void handleEvent(FEvent e) {
renameGauntlet(lstGauntlets.getSelectedGauntlet());
}
});
btnDeleteGauntlet.setFont(btnNewGauntlet.getFont()); btnDeleteGauntlet.setFont(btnNewGauntlet.getFont());
btnDeleteGauntlet.setCommand(new FEventHandler() { btnDeleteGauntlet.setCommand(event -> deleteGauntlet(lstGauntlets.getSelectedGauntlet()));
@Override
public void handleEvent(FEvent e) {
deleteGauntlet(lstGauntlets.getSelectedGauntlet());
}
});
} }
public void onActivate() { public void onActivate() {
@@ -136,81 +121,69 @@ public class LoadGauntletScreen extends LaunchScreen {
return; return;
} }
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), new Runnable() { LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), true, () -> {
@Override final GauntletData gauntlet1 = FModel.getGauntletData();
public void run() { List<RegisteredPlayer> players = new ArrayList<>();
final GauntletData gauntlet = FModel.getGauntletData(); RegisteredPlayer humanPlayer = new RegisteredPlayer(gauntlet1.getUserDeck()).setPlayer(GamePlayerUtil.getGuiPlayer());
List<RegisteredPlayer> players = new ArrayList<>(); players.add(humanPlayer);
RegisteredPlayer humanPlayer = new RegisteredPlayer(gauntlet.getUserDeck()).setPlayer(GamePlayerUtil.getGuiPlayer()); players.add(new RegisteredPlayer(gauntlet1.getDecks().get(gauntlet1.getCompleted())).setPlayer(GamePlayerUtil.createAiPlayer()));
players.add(humanPlayer); gauntlet1.startRound(players, humanPlayer);
players.add(new RegisteredPlayer(gauntlet.getDecks().get(gauntlet.getCompleted())).setPlayer(GamePlayerUtil.createAiPlayer()));
gauntlet.startRound(players, humanPlayer);
}
}); });
} }
private void renameGauntlet(final GauntletData gauntlet) { private void renameGauntlet(final GauntletData gauntlet) {
if (gauntlet == null) { return; } if (gauntlet == null) { return; }
ThreadUtil.invokeInGameThread(new Runnable() { ThreadUtil.invokeInGameThread(() -> {
@Override String gauntletName;
public void run() { String oldGauntletName = gauntlet.getName();
String gauntletName; while (true) {
String oldGauntletName = gauntlet.getName(); gauntletName = SOptionPane.showInputDialog(Forge.getLocalizer().getMessage("lblEnterNewGauntletGameName"), Forge.getLocalizer().getMessage("lblRenameGauntlet"), null, oldGauntletName);
while (true) { if (gauntletName == null) { return; }
gauntletName = SOptionPane.showInputDialog(Forge.getLocalizer().getMessage("lblEnterNewGauntletGameName"), Forge.getLocalizer().getMessage("lblRenameGauntlet"), null, oldGauntletName);
if (gauntletName == null) { return; }
gauntletName = QuestUtil.cleanString(gauntletName); gauntletName = QuestUtil.cleanString(gauntletName);
if (gauntletName.equals(oldGauntletName)) { return; } //quit if chose same name if (gauntletName.equals(oldGauntletName)) { return; } //quit if chose same name
if (gauntletName.isEmpty()) { if (gauntletName.isEmpty()) {
SOptionPane.showMessageDialog(Forge.getLocalizer().getMessage("lblPleaseSpecifyGauntletName")); SOptionPane.showMessageDialog(Forge.getLocalizer().getMessage("lblPleaseSpecifyGauntletName"));
continue; continue;
}
boolean exists = false;
for (GauntletData gauntletData : lstGauntlets) {
if (gauntletData.getName().equalsIgnoreCase(gauntletName)) {
exists = true;
break;
}
}
if (exists) {
SOptionPane.showMessageDialog(Forge.getLocalizer().getMessage("lblGauntletNameExistsPleasePickAnotherName"));
continue;
}
break;
} }
final String newGauntletName = gauntletName;
FThreads.invokeInEdtLater(new Runnable() { boolean exists = false;
@Override for (GauntletData gauntletData : lstGauntlets) {
public void run() { if (gauntletData.getName().equalsIgnoreCase(gauntletName)) {
gauntlet.rename(newGauntletName); exists = true;
lstGauntlets.refresh(); break;
lstGauntlets.setSelectedGauntlet(gauntlet);
} }
}); }
if (exists) {
SOptionPane.showMessageDialog(Forge.getLocalizer().getMessage("lblGauntletNameExistsPleasePickAnotherName"));
continue;
}
break;
} }
final String newGauntletName = gauntletName;
FThreads.invokeInEdtLater(() -> {
gauntlet.rename(newGauntletName);
lstGauntlets.refresh();
lstGauntlets.setSelectedGauntlet(gauntlet);
});
}); });
} }
private void deleteGauntlet(final GauntletData gauntlet) { private void deleteGauntlet(final GauntletData gauntlet) {
if (gauntlet == null) { return; } if (gauntlet == null) { return; }
ThreadUtil.invokeInGameThread(new Runnable() { ThreadUtil.invokeInGameThread(() -> {
@Override if (!SOptionPane.showConfirmDialog(
public void run() { Forge.getLocalizer().getMessage("lblAreYouSuerDeleteGauntlet", gauntlet.getName()),
if (!SOptionPane.showConfirmDialog( Forge.getLocalizer().getMessage("lblDeleteGauntlet"), Forge.getLocalizer().getMessage("lblDelete"), Forge.getLocalizer().getMessage("lblCancel"))) {
Forge.getLocalizer().getMessage("lblAreYouSuerDeleteGauntlet", gauntlet.getName()), return;
Forge.getLocalizer().getMessage("lblDeleteGauntlet"), Forge.getLocalizer().getMessage("lblDelete"), Forge.getLocalizer().getMessage("lblCancel"))) {
return;
}
GauntletIO.getGauntletFile(gauntlet).delete();
lstGauntlets.removeGauntlet(gauntlet);
} }
GauntletIO.getGauntletFile(gauntlet).delete();
lstGauntlets.removeGauntlet(gauntlet);
}); });
} }
@@ -299,12 +272,7 @@ public class LoadGauntletScreen extends LaunchScreen {
public void refresh() { public void refresh() {
List<GauntletData> sorted = new ArrayList<>(); List<GauntletData> sorted = new ArrayList<>();
sorted.addAll(gauntlets); sorted.addAll(gauntlets);
Collections.sort(sorted, new Comparator<GauntletData>() { Collections.sort(sorted, (x, y) -> x.getName().toLowerCase().compareTo(y.getName().toLowerCase()));
@Override
public int compare(final GauntletData x, final GauntletData y) {
return x.getName().toLowerCase().compareTo(y.getName().toLowerCase());
}
});
setListData(sorted); setListData(sorted);
} }

45
forge-gui-mobile/src/forge/screens/home/puzzle/PuzzleScreen.java
View File

@@ -60,39 +60,26 @@ public class PuzzleScreen extends LaunchScreen {
@Override @Override
public void run(final Puzzle chosen) { public void run(final Puzzle chosen) {
if (chosen != null) { if (chosen != null) {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingThePuzzle"), new Runnable() { LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingThePuzzle"), true, () -> {
@Override // Load selected puzzle
public void run() { final HostedMatch hostedMatch = GuiBase.getInterface().hostMatch();
// Load selected puzzle hostedMatch.setStartGameHook(() -> chosen.applyToGame(hostedMatch.getGame()));
final HostedMatch hostedMatch = GuiBase.getInterface().hostMatch();
hostedMatch.setStartGameHook(new Runnable() {
@Override
public final void run() {
chosen.applyToGame(hostedMatch.getGame());
}
});
hostedMatch.setEndGameHook((new Runnable() { hostedMatch.setEndGameHook((() -> chosen.savePuzzleSolve(hostedMatch.getGame().getOutcome().isWinner(GamePlayerUtil.getGuiPlayer()))));
@Override
public void run() {
chosen.savePuzzleSolve(hostedMatch.getGame().getOutcome().isWinner(GamePlayerUtil.getGuiPlayer()));
}
}));
final List<RegisteredPlayer> players = new ArrayList<>(); final List<RegisteredPlayer> players = new ArrayList<>();
final RegisteredPlayer human = new RegisteredPlayer(new Deck()).setPlayer(GamePlayerUtil.getGuiPlayer()); final RegisteredPlayer human = new RegisteredPlayer(new Deck()).setPlayer(GamePlayerUtil.getGuiPlayer());
human.setStartingHand(0); human.setStartingHand(0);
players.add(human); players.add(human);
final RegisteredPlayer ai = new RegisteredPlayer(new Deck()).setPlayer(GamePlayerUtil.createAiPlayer()); final RegisteredPlayer ai = new RegisteredPlayer(new Deck()).setPlayer(GamePlayerUtil.createAiPlayer());
ai.setStartingHand(0); ai.setStartingHand(0);
players.add(ai); players.add(ai);
GameRules rules = new GameRules(GameType.Puzzle); GameRules rules = new GameRules(GameType.Puzzle);
rules.setGamesPerMatch(1); rules.setGamesPerMatch(1);
hostedMatch.startMatch(rules, null, players, human, GuiBase.getInterface().getNewGuiGame()); hostedMatch.startMatch(rules, null, players, human, GuiBase.getInterface().getNewGuiGame());
FOptionPane.showMessageDialog(chosen.getGoalDescription(), chosen.getName()); FOptionPane.showMessageDialog(chosen.getGoalDescription(), chosen.getName());
}
}); });
} }
} }

122
forge-gui-mobile/src/forge/screens/limited/LoadDraftScreen.java
View File

@@ -54,12 +54,7 @@ public class LoadDraftScreen extends LaunchScreen {
cbMode.addItem(Forge.getLocalizer().getMessage("lblSingleMatch")); cbMode.addItem(Forge.getLocalizer().getMessage("lblSingleMatch"));
lstDecks.setup(ItemManagerConfig.DRAFT_DECKS); lstDecks.setup(ItemManagerConfig.DRAFT_DECKS);
lstDecks.setItemActivateHandler(new FEventHandler() { lstDecks.setItemActivateHandler(event -> editSelectedDeck());
@Override
public void handleEvent(FEvent e) {
editSelectedDeck();
}
});
} }
@Override @Override
@@ -96,80 +91,63 @@ public class LoadDraftScreen extends LaunchScreen {
@Override @Override
protected void startMatch() { protected void startMatch() {
FThreads.invokeInBackgroundThread(new Runnable() { FThreads.invokeInBackgroundThread(() -> {
@Override final DeckProxy humanDeck = lstDecks.getSelectedItem();
public void run() { if (humanDeck == null) {
final DeckProxy humanDeck = lstDecks.getSelectedItem(); FOptionPane.showErrorDialog(Forge.getLocalizer().getMessage("lblYouMustSelectExistingDeck"), Forge.getLocalizer().getMessage("lblNoDeck"));
if (humanDeck == null) { return;
FOptionPane.showErrorDialog(Forge.getLocalizer().getMessage("lblYouMustSelectExistingDeck"), Forge.getLocalizer().getMessage("lblNoDeck")); }
// TODO: if booster draft tournaments are supported in the future, add the possibility to choose them here
final boolean gauntlet = cbMode.getSelectedItem().equals(Forge.getLocalizer().getMessage("lblGauntlet"));
if (gauntlet) {
final Integer rounds = SGuiChoose.getInteger(Forge.getLocalizer().getMessage("lblHowManyOpponents"),
1, FModel.getDecks().getDraft().get(humanDeck.getName()).getAiDecks().size());
if (rounds == null) {
return; return;
} }
// TODO: if booster draft tournaments are supported in the future, add the possibility to choose them here FThreads.invokeInEdtLater(() -> {
final boolean gauntlet = cbMode.getSelectedItem().equals(Forge.getLocalizer().getMessage("lblGauntlet")); if (!checkDeckLegality(humanDeck)) {
if (gauntlet) {
final Integer rounds = SGuiChoose.getInteger(Forge.getLocalizer().getMessage("lblHowManyOpponents"),
1, FModel.getDecks().getDraft().get(humanDeck.getName()).getAiDecks().size());
if (rounds == null) {
return; return;
} }
FThreads.invokeInEdtLater(new Runnable() { LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), true, () -> {
@Override FModel.getGauntletMini().resetGauntletDraft();
public void run() { FModel.getGauntletMini().launch(rounds, humanDeck.getDeck(), GameType.Draft);
if (!checkDeckLegality(humanDeck)) {
return;
}
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), new Runnable() {
@Override
public void run() {
FModel.getGauntletMini().resetGauntletDraft();
FModel.getGauntletMini().launch(rounds, humanDeck.getDeck(), GameType.Draft);
}
});
}
});
} else {
final Integer aiIndex = SGuiChoose.getInteger(Forge.getLocalizer().getMessage("lblWhichOpponentWouldYouLikeToFace"),
1, FModel.getDecks().getDraft().get(humanDeck.getName()).getAiDecks().size());
if (aiIndex == null) {
return; // Cancel was pressed
}
final DeckGroup opponentDecks = FModel.getDecks().getDraft().get(humanDeck.getName());
final Deck aiDeck = opponentDecks.getAiDecks().get(aiIndex - 1);
if (aiDeck == null) {
throw new IllegalStateException("Draft: Computer deck is null!");
}
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), new Runnable() {
@Override
public void run() {
if (!checkDeckLegality(humanDeck)) {
return;
}
final List<RegisteredPlayer> starter = new ArrayList<>();
final RegisteredPlayer human = new RegisteredPlayer(humanDeck.getDeck()).setPlayer(GamePlayerUtil.getGuiPlayer());
starter.add(human);
starter.add(new RegisteredPlayer(aiDeck).setPlayer(GamePlayerUtil.createAiPlayer()));
for (final RegisteredPlayer pl : starter) {
pl.assignConspiracies();
}
FModel.getGauntletMini().resetGauntletDraft();
final HostedMatch hostedMatch = GuiBase.getInterface().hostMatch();
hostedMatch.startMatch(GameType.Draft, null, starter, human, GuiBase.getInterface().getNewGuiGame());
}
});
}
}); });
});
} else {
final Integer aiIndex = SGuiChoose.getInteger(Forge.getLocalizer().getMessage("lblWhichOpponentWouldYouLikeToFace"),
1, FModel.getDecks().getDraft().get(humanDeck.getName()).getAiDecks().size());
if (aiIndex == null) {
return; // Cancel was pressed
} }
final DeckGroup opponentDecks = FModel.getDecks().getDraft().get(humanDeck.getName());
final Deck aiDeck = opponentDecks.getAiDecks().get(aiIndex - 1);
if (aiDeck == null) {
throw new IllegalStateException("Draft: Computer deck is null!");
}
FThreads.invokeInEdtLater(() -> LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), true, () -> {
if (!checkDeckLegality(humanDeck)) {
return;
}
final List<RegisteredPlayer> starter = new ArrayList<>();
final RegisteredPlayer human = new RegisteredPlayer(humanDeck.getDeck()).setPlayer(GamePlayerUtil.getGuiPlayer());
starter.add(human);
starter.add(new RegisteredPlayer(aiDeck).setPlayer(GamePlayerUtil.createAiPlayer()));
for (final RegisteredPlayer pl : starter) {
pl.assignConspiracies();
}
FModel.getGauntletMini().resetGauntletDraft();
final HostedMatch hostedMatch = GuiBase.getInterface().hostMatch();
hostedMatch.startMatch(GameType.Draft, null, starter, human, GuiBase.getInterface().getNewGuiGame());
}));
} }
}); });
} }

112
forge-gui-mobile/src/forge/screens/limited/LoadSealedScreen.java
View File

@@ -54,12 +54,7 @@ public class LoadSealedScreen extends LaunchScreen {
cbMode.addItem(Forge.getLocalizer().getMessage("lblSingleMatch")); cbMode.addItem(Forge.getLocalizer().getMessage("lblSingleMatch"));
lstDecks.setup(ItemManagerConfig.SEALED_DECKS); lstDecks.setup(ItemManagerConfig.SEALED_DECKS);
lstDecks.setItemActivateHandler(new FEventHandler() { lstDecks.setItemActivateHandler(event -> editSelectedDeck());
@Override
public void handleEvent(FEvent e) {
editSelectedDeck();
}
});
} }
@Override @Override
@@ -95,74 +90,59 @@ public class LoadSealedScreen extends LaunchScreen {
@Override @Override
protected void startMatch() { protected void startMatch() {
FThreads.invokeInBackgroundThread(new Runnable() { FThreads.invokeInBackgroundThread(() -> {
@Override final DeckProxy humanDeck = lstDecks.getSelectedItem();
public void run() { if (humanDeck == null) {
final DeckProxy humanDeck = lstDecks.getSelectedItem(); FOptionPane.showErrorDialog(Forge.getLocalizer().getMessage("lblYouMustSelectExistingSealedPool"), Forge.getLocalizer().getMessage("lblNoDeck"));
if (humanDeck == null) { return;
FOptionPane.showErrorDialog(Forge.getLocalizer().getMessage("lblYouMustSelectExistingSealedPool"), Forge.getLocalizer().getMessage("lblNoDeck")); }
return;
}
final boolean gauntlet = cbMode.getSelectedItem().equals(Forge.getLocalizer().getMessage("lblGauntlet")); final boolean gauntlet = cbMode.getSelectedItem().equals(Forge.getLocalizer().getMessage("lblGauntlet"));
if (gauntlet) { if (gauntlet) {
FThreads.invokeInEdtLater(new Runnable() { FThreads.invokeInEdtLater(() -> {
@Override if (!checkDeckLegality(humanDeck)) {
public void run() { return;
if (!checkDeckLegality(humanDeck)) {
return;
}
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), new Runnable() {
@Override
public void run() {
final int matches = FModel.getDecks().getSealed().get(humanDeck.getName()).getAiDecks().size();
FModel.getGauntletMini().launch(matches, humanDeck.getDeck(), GameType.Sealed);
}
});
}
});
} else {
final Integer aiIndex = SGuiChoose.getInteger(Forge.getLocalizer().getMessage("lblWhichOpponentWouldYouLikeToFace"),
1, FModel.getDecks().getSealed().get(humanDeck.getName()).getAiDecks().size());
if (aiIndex == null) {
return; // Cancel was pressed
} }
final DeckGroup opponentDecks = FModel.getDecks().getSealed().get(humanDeck.getName()); LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), true, () -> {
final Deck aiDeck = opponentDecks.getAiDecks().get(aiIndex - 1); final int matches = FModel.getDecks().getSealed().get(humanDeck.getName()).getAiDecks().size();
if (aiDeck == null) { FModel.getGauntletMini().launch(matches, humanDeck.getDeck(), GameType.Sealed);
throw new IllegalStateException("Draft: Computer deck is null!"); });
});
} else {
final Integer aiIndex = SGuiChoose.getInteger(Forge.getLocalizer().getMessage("lblWhichOpponentWouldYouLikeToFace"),
1, FModel.getDecks().getSealed().get(humanDeck.getName()).getAiDecks().size());
if (aiIndex == null) {
return; // Cancel was pressed
}
final DeckGroup opponentDecks = FModel.getDecks().getSealed().get(humanDeck.getName());
final Deck aiDeck = opponentDecks.getAiDecks().get(aiIndex - 1);
if (aiDeck == null) {
throw new IllegalStateException("Draft: Computer deck is null!");
}
FThreads.invokeInEdtLater(() -> {
if (!checkDeckLegality(humanDeck)) {
return;
} }
FThreads.invokeInEdtLater(new Runnable() { LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), true, () -> {
@Override final List<RegisteredPlayer> starter = new ArrayList<>();
public void run() { final RegisteredPlayer human = new RegisteredPlayer(humanDeck.getDeck()).setPlayer(GamePlayerUtil.getGuiPlayer());
if (!checkDeckLegality(humanDeck)) { starter.add(human);
return; starter.add(new RegisteredPlayer(aiDeck).setPlayer(GamePlayerUtil.createAiPlayer()));
} for (final RegisteredPlayer pl : starter) {
pl.assignConspiracies();
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), new Runnable() {
@Override
public void run() {
final List<RegisteredPlayer> starter = new ArrayList<>();
final RegisteredPlayer human = new RegisteredPlayer(humanDeck.getDeck()).setPlayer(GamePlayerUtil.getGuiPlayer());
starter.add(human);
starter.add(new RegisteredPlayer(aiDeck).setPlayer(GamePlayerUtil.createAiPlayer()));
for (final RegisteredPlayer pl : starter) {
pl.assignConspiracies();
}
FModel.getGauntletMini().resetGauntletDraft();
final HostedMatch hostedMatch = GuiBase.getInterface().hostMatch();
hostedMatch.startMatch(GameType.Sealed, null, starter, human, GuiBase.getInterface().getNewGuiGame());
}
});
} }
FModel.getGauntletMini().resetGauntletDraft();
final HostedMatch hostedMatch = GuiBase.getInterface().hostMatch();
hostedMatch.startMatch(GameType.Sealed, null, starter, human, GuiBase.getInterface().getNewGuiGame());
}); });
} });
} }
}); });
} }

26
forge-gui-mobile/src/forge/screens/limited/NewDraftScreen.java
View File

@@ -41,27 +41,15 @@ public class NewDraftScreen extends LaunchScreen {
@Override @Override
protected void startMatch() { protected void startMatch() {
ThreadUtil.invokeInGameThread(new Runnable() { //must run in game thread to prevent blocking UI thread //must run in game thread to prevent blocking UI thread
@Override ThreadUtil.invokeInGameThread(() -> {
public void run() { final LimitedPoolType poolType = SGuiChoose.oneOrNone(Forge.getLocalizer().getMessage("lblChooseDraftFormat"), LimitedPoolType.values());
final LimitedPoolType poolType = SGuiChoose.oneOrNone(Forge.getLocalizer().getMessage("lblChooseDraftFormat"), LimitedPoolType.values()); if (poolType == null) { return; }
if (poolType == null) { return; }
final BoosterDraft draft = BoosterDraft.createDraft(poolType); final BoosterDraft draft = BoosterDraft.createDraft(poolType);
if (draft == null) { return; } if (draft == null) { return; }
FThreads.invokeInEdtLater(new Runnable() { FThreads.invokeInEdtLater(() -> LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewDraft"), true, () -> Forge.openScreen(new DraftingProcessScreen(draft, EditorType.Draft, null))));
@Override
public void run() {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewDraft"), new Runnable() {
@Override
public void run() {
Forge.openScreen(new DraftingProcessScreen(draft, EditorType.Draft, null));
}
});
}
});
}
}); });
} }
} }

87
forge-gui-mobile/src/forge/screens/online/OnlineLobbyScreen.java
View File

@@ -56,18 +56,15 @@ public class OnlineLobbyScreen extends LobbyScreen implements IOnlineLobby {
clearGameLobby(); clearGameLobby();
Forge.back(); Forge.back();
if (msg.length() > 0) { if (msg.length() > 0) {
FThreads.invokeInBackgroundThread(new Runnable() { FThreads.invokeInBackgroundThread(() -> {
@Override final boolean callBackAlwaysTrue = SOptionPane.showOptionDialog(msg, Forge.getLocalizer().getMessage("lblError"), FSkinProp.ICO_WARNING, ImmutableList.of(Forge.getLocalizer().getMessage("lblOk")), 1) == 0;
public void run() { if (callBackAlwaysTrue) { //to activate online menu popup when player press play online
final boolean callBackAlwaysTrue = SOptionPane.showOptionDialog(msg, Forge.getLocalizer().getMessage("lblError"), FSkinProp.ICO_WARNING, ImmutableList.of(Forge.getLocalizer().getMessage("lblOk")), 1) == 0; GuiBase.setInterrupted(false);
if (callBackAlwaysTrue) { //to activate online menu popup when player press play online
GuiBase.setInterrupted(false);
if(FServerManager.getInstance() != null) if(FServerManager.getInstance() != null)
FServerManager.getInstance().stopServer(); FServerManager.getInstance().stopServer();
if(getfGameClient() != null) if(getfGameClient() != null)
closeClient(); closeClient();
}
} }
}); });
} }
@@ -93,51 +90,37 @@ public class OnlineLobbyScreen extends LobbyScreen implements IOnlineLobby {
if (getGameLobby() == null) { if (getGameLobby() == null) {
setGameLobby(getLobby()); setGameLobby(getLobby());
//prompt to connect to server when offline lobby activated //prompt to connect to server when offline lobby activated
FThreads.invokeInBackgroundThread(new Runnable() { FThreads.invokeInBackgroundThread(() -> {
@Override final String url = NetConnectUtil.getServerUrl();
public void run() { FThreads.invokeInEdtLater(() -> {
final String url = NetConnectUtil.getServerUrl(); if (url == null) {
FThreads.invokeInEdtLater(new Runnable() { closeConn(""); //go back to previous screen if user cancels connection
@Override return;
public void run() { }
if (url == null) {
closeConn(""); //go back to previous screen if user cancels connection final boolean joinServer = url.length() > 0;
final String caption = joinServer ? Forge.getLocalizer().getMessage("lblConnectingToServer") : Forge.getLocalizer().getMessage("lblStartingServer");
LoadingOverlay.show(caption, true, () -> {
final ChatMessage result;
final IOnlineChatInterface chatInterface = (IOnlineChatInterface)OnlineScreen.Chat.getScreen();
if (joinServer) {
result = NetConnectUtil.join(url, OnlineLobbyScreen.this, chatInterface);
if (result.getMessage() == ForgeConstants.CLOSE_CONN_COMMAND) { //this message is returned via netconnectutil on exception
closeConn(Forge.getLocalizer().getMessage("lblDetectedInvalidHostAddress", url));
return; return;
} }
final boolean joinServer = url.length() > 0;
final String caption = joinServer ? Forge.getLocalizer().getMessage("lblConnectingToServer") : Forge.getLocalizer().getMessage("lblStartingServer");
LoadingOverlay.show(caption, new Runnable() {
@Override
public void run() {
final ChatMessage result;
final IOnlineChatInterface chatInterface = (IOnlineChatInterface)OnlineScreen.Chat.getScreen();
if (joinServer) {
result = NetConnectUtil.join(url, OnlineLobbyScreen.this, chatInterface);
if (result.getMessage() == ForgeConstants.CLOSE_CONN_COMMAND) { //this message is returned via netconnectutil on exception
closeConn(Forge.getLocalizer().getMessage("lblDetectedInvalidHostAddress", url));
return;
}
}
else {
result = NetConnectUtil.host(OnlineLobbyScreen.this, chatInterface);
}
chatInterface.addMessage(result);
if (!joinServer) {
FThreads.invokeInBackgroundThread(new Runnable() {
@Override
public void run() {
NetConnectUtil.copyHostedServerUrl();
}
});
}
//update menu buttons
OnlineScreen.Lobby.update();
}
});
} }
else {
result = NetConnectUtil.host(OnlineLobbyScreen.this, chatInterface);
}
chatInterface.addMessage(result);
if (!joinServer) {
FThreads.invokeInBackgroundThread(() -> NetConnectUtil.copyHostedServerUrl());
}
//update menu buttons
OnlineScreen.Lobby.update();
}); });
} });
}); });
} }
} }

87
forge-gui-mobile/src/forge/screens/planarconquest/ConquestMenu.java
View File

@@ -26,54 +26,14 @@ public class ConquestMenu extends FPopupMenu {
private static final ConquestStatsScreen statsScreen = new ConquestStatsScreen(); private static final ConquestStatsScreen statsScreen = new ConquestStatsScreen();
private static final ConquestPrefsScreen prefsScreen = new ConquestPrefsScreen(); private static final ConquestPrefsScreen prefsScreen = new ConquestPrefsScreen();
private static final FMenuItem multiverseItem = new FMenuItem(Forge.getLocalizer().getMessage("lblTheMultiverse"), FSkinImage.MULTIVERSE, new FEventHandler() { private static final FMenuItem multiverseItem = new FMenuItem(Forge.getLocalizer().getMessage("lblTheMultiverse"), FSkinImage.MULTIVERSE, event -> setCurrentScreen(multiverseScreen));
@Override private static final FMenuItem aetherItem = new FMenuItem(Forge.getLocalizer().getMessage("lblTheAether"), FSkinImage.AETHER_SHARD, event -> setCurrentScreen(aetherScreen));
public void handleEvent(FEvent e) { private static final FMenuItem commandersItem = new FMenuItem(Forge.getLocalizer().getMessage("lblCommanders"), FSkinImage.COMMANDER, event -> setCurrentScreen(commandersScreen));
setCurrentScreen(multiverseScreen); private static final FMenuItem planeswalkersItem = new FMenuItem(Forge.getLocalizer().getMessage("lblPlaneswalkers"), FSkinImage.PLANESWALKER, event -> setCurrentScreen(planeswalkersScreen));
} private static final FMenuItem collectionItem = new FMenuItem(Forge.getLocalizer().getMessage("lblCollection"), FSkinImage.SPELLBOOK, event -> setCurrentScreen(collectionScreen));
}); private static final FMenuItem statsItem = new FMenuItem(Forge.getLocalizer().getMessage("lblStatistics"), FSkinImage.MENU_STATS, event -> setCurrentScreen(statsScreen));
private static final FMenuItem aetherItem = new FMenuItem(Forge.getLocalizer().getMessage("lblTheAether"), FSkinImage.AETHER_SHARD, new FEventHandler() { private static final FMenuItem planeswalkItem = new FMenuItem(Forge.getLocalizer().getMessage("lblPlaneswalk"), FSkinImage.PW_BADGE_COMMON, event -> setCurrentScreen(planeswalkScreen));
@Override private static final FMenuItem prefsItem = new FMenuItem(Forge.getLocalizer().getMessage("Preferences"), Forge.hdbuttons ? FSkinImage.HDPREFERENCE : FSkinImage.SETTINGS, event -> setCurrentScreen(prefsScreen));
public void handleEvent(FEvent e) {
setCurrentScreen(aetherScreen);
}
});
private static final FMenuItem commandersItem = new FMenuItem(Forge.getLocalizer().getMessage("lblCommanders"), FSkinImage.COMMANDER, new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
setCurrentScreen(commandersScreen);
}
});
private static final FMenuItem planeswalkersItem = new FMenuItem(Forge.getLocalizer().getMessage("lblPlaneswalkers"), FSkinImage.PLANESWALKER, new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
setCurrentScreen(planeswalkersScreen);
}
});
private static final FMenuItem collectionItem = new FMenuItem(Forge.getLocalizer().getMessage("lblCollection"), FSkinImage.SPELLBOOK, new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
setCurrentScreen(collectionScreen);
}
});
private static final FMenuItem statsItem = new FMenuItem(Forge.getLocalizer().getMessage("lblStatistics"), FSkinImage.MENU_STATS, new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
setCurrentScreen(statsScreen);
}
});
private static final FMenuItem planeswalkItem = new FMenuItem(Forge.getLocalizer().getMessage("lblPlaneswalk"), FSkinImage.PW_BADGE_COMMON, new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
setCurrentScreen(planeswalkScreen);
}
});
private static final FMenuItem prefsItem = new FMenuItem(Forge.getLocalizer().getMessage("Preferences"), Forge.hdbuttons ? FSkinImage.HDPREFERENCE : FSkinImage.SETTINGS, new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
setCurrentScreen(prefsScreen);
}
});
private static void setCurrentScreen(FScreen screen0) { private static void setCurrentScreen(FScreen screen0) {
//make it so pressing Back from any screen besides Multiverse screen always goes to Multiverse screen //make it so pressing Back from any screen besides Multiverse screen always goes to Multiverse screen
@@ -84,12 +44,7 @@ public class ConquestMenu extends FPopupMenu {
static { static {
//the first time planarconquest mode is launched, add button for it if in Landscape mode //the first time planarconquest mode is launched, add button for it if in Landscape mode
if (Forge.isLandscapeMode()) { if (Forge.isLandscapeMode()) {
HomeScreen.instance.addButtonForMode("-"+Forge.getLocalizer().getMessage("lblPlanarConquest"), new FEventHandler() { HomeScreen.instance.addButtonForMode("-"+Forge.getLocalizer().getMessage("lblPlanarConquest"), event -> launchPlanarConquest(LaunchReason.StartPlanarConquest));
@Override
public void handleEvent(FEvent e) {
launchPlanarConquest(LaunchReason.StartPlanarConquest);
}
});
} }
} }
@@ -108,20 +63,16 @@ public class ConquestMenu extends FPopupMenu {
public static void launchPlanarConquest(final LaunchReason reason) { public static void launchPlanarConquest(final LaunchReason reason) {
Forge.lastButtonIndex = 7; Forge.lastButtonIndex = 7;
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingCurrentConquest"), new Runnable() { LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingCurrentConquest"), true, () -> {
@Override ((DeckController<Deck>)EditorType.PlanarConquest.getController()).setRootFolder(FModel.getConquest().getDecks());
@SuppressWarnings("unchecked") if (reason == LaunchReason.StartPlanarConquest) {
public void run() { Forge.openScreen(multiverseScreen);
((DeckController<Deck>)EditorType.PlanarConquest.getController()).setRootFolder(FModel.getConquest().getDecks()); }
if (reason == LaunchReason.StartPlanarConquest) { else {
Forge.openScreen(multiverseScreen); multiverseScreen.update();
} Forge.openScreen(multiverseScreen);
else { if (reason == LaunchReason.NewConquest) {
multiverseScreen.update(); LoadGameScreen.PlanarConquest.setAsBackScreen(true);
Forge.openScreen(multiverseScreen);
if (reason == LaunchReason.NewConquest) {
LoadGameScreen.PlanarConquest.setAsBackScreen(true);
}
} }
} }
}); });

34
forge-gui-mobile/src/forge/screens/planarconquest/ConquestMultiverseScreen.java
View File

@@ -260,29 +260,18 @@ public class ConquestMultiverseScreen extends FScreen {
} }
private void launchEvent() { private void launchEvent() {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblStartingBattle"), new Runnable() { LoadingOverlay.show(Forge.getLocalizer().getMessage("lblStartingBattle"), true, () -> {
@Override ConquestLocation loc = model.getCurrentLocation();
public void run() { activeBattle = loc.getEvent().createBattle(loc, 0);
ConquestLocation loc = model.getCurrentLocation(); FModel.getConquest().startBattle(activeBattle);
activeBattle = loc.getEvent().createBattle(loc, 0);
FModel.getConquest().startBattle(activeBattle);
}
}); });
} }
private void launchChaosBattle() { private void launchChaosBattle() {
FThreads.invokeInEdtNowOrLater(new Runnable() { FThreads.invokeInEdtNowOrLater(() -> LoadingOverlay.show(Forge.getLocalizer().getMessage("lblChaosApproaching"), true, () -> {
@Override activeBattle = new ConquestChaosBattle();
public void run() { FModel.getConquest().startBattle(activeBattle);
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblChaosApproaching"), new Runnable() { }));
@Override
public void run() {
activeBattle = new ConquestChaosBattle();
FModel.getConquest().startBattle(activeBattle);
}
});
}
});
} }
@Override @Override
@@ -678,12 +667,7 @@ public class ConquestMultiverseScreen extends FScreen {
private BattleBar() { private BattleBar() {
playerAvatar = add(new AvatarDisplay(false)); playerAvatar = add(new AvatarDisplay(false));
opponentAvatar = add(new AvatarDisplay(true)); opponentAvatar = add(new AvatarDisplay(true));
btnBattle = add(new FButton(Forge.getLocalizer().getMessage("lblBattle"), new FEventHandler() { btnBattle = add(new FButton(Forge.getLocalizer().getMessage("lblBattle"), event -> launchEvent()));
@Override
public void handleEvent(FEvent e) {
launchEvent();
}
}));
btnBattle.setFont(FSkinFont.get(20)); btnBattle.setFont(FSkinFont.get(20));
} }

35
forge-gui-mobile/src/forge/screens/planarconquest/NewConquestScreen.java
View File

@@ -37,12 +37,7 @@ public class NewConquestScreen extends MultiStepWizardScreen<NewConquestScreenMo
@Override @Override
protected void finish() { protected void finish() {
//create new quest in game thread so option panes can wait for input //create new quest in game thread so option panes can wait for input
ThreadUtil.invokeInGameThread(new Runnable() { ThreadUtil.invokeInGameThread(() -> newConquest());
@Override
public void run() {
newConquest();
}
});
} }
private void newConquest() { private void newConquest() {
@@ -52,26 +47,18 @@ public class NewConquestScreen extends MultiStepWizardScreen<NewConquestScreenMo
} }
private void startNewConquest(final String conquestName) { private void startNewConquest(final String conquestName) {
FThreads.invokeInEdtLater(new Runnable() { FThreads.invokeInEdtLater(() -> LoadingOverlay.show(Forge.getLocalizer().getMessage("lblStartingNewConquest"), true, () -> {
@Override ConquestController qc = FModel.getConquest();
public void run() { qc.setModel(new ConquestData(conquestName, model.startingPlane, model.startingPlaneswalker, model.startingCommander));
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblStartingNewConquest"), new Runnable() { qc.getDecks().add(Iterables.getFirst(qc.getModel().getCommanders(), null).getDeck()); //ensure starting deck is saved
@Override qc.getModel().saveData();
public void run() {
ConquestController qc = FModel.getConquest();
qc.setModel(new ConquestData(conquestName, model.startingPlane, model.startingPlaneswalker, model.startingCommander));
qc.getDecks().add(Iterables.getFirst(qc.getModel().getCommanders(), null).getDeck()); //ensure starting deck is saved
qc.getModel().saveData();
// Save in preferences. // Save in preferences.
FModel.getConquestPreferences().setPref(CQPref.CURRENT_CONQUEST, conquestName); FModel.getConquestPreferences().setPref(CQPref.CURRENT_CONQUEST, conquestName);
FModel.getConquestPreferences().save(); FModel.getConquestPreferences().save();
ConquestMenu.launchPlanarConquest(LaunchReason.NewConquest); ConquestMenu.launchPlanarConquest(LaunchReason.NewConquest);
} }));
});
}
});
} }
private static class SelectStartingPlaneStep extends WizardStep<NewConquestScreenModel> { private static class SelectStartingPlaneStep extends WizardStep<NewConquestScreenModel> {

165
forge-gui-mobile/src/forge/screens/quest/NewQuestScreen.java
View File

@@ -186,17 +186,9 @@ public class NewQuestScreen extends FScreen {
private final FCheckBox cbCommander = scroller.add(new FCheckBox(Forge.getLocalizer().getMessage("rbCommanderSubformat"))); private final FCheckBox cbCommander = scroller.add(new FCheckBox(Forge.getLocalizer().getMessage("rbCommanderSubformat")));
private final FLabel btnEmbark = add(new FLabel.ButtonBuilder() private final FLabel btnEmbark = add(new FLabel.ButtonBuilder()
.font(FSkinFont.get(22)).text(Forge.getLocalizer().getMessage("lblEmbark")).icon(FSkinImage.QUEST_ZEP).command(new FEventHandler() { .font(FSkinFont.get(22)).text(Forge.getLocalizer().getMessage("lblEmbark")).icon(FSkinImage.QUEST_ZEP).command(event -> {
@Override //create new quest in game thread so option panes can wait for input
public void handleEvent(FEvent e) { ThreadUtil.invokeInGameThread(() -> newQuest());
//create new quest in game thread so option panes can wait for input
ThreadUtil.invokeInGameThread(new Runnable() {
@Override
public void run() {
newQuest();
}
});
}
}).build()); }).build());
public NewQuestScreen() { public NewQuestScreen() {
@@ -209,24 +201,18 @@ public class NewQuestScreen extends FScreen {
cbxStartingPool.addItem(StartingPoolType.DraftDeck); cbxStartingPool.addItem(StartingPoolType.DraftDeck);
cbxStartingPool.addItem(StartingPoolType.SealedDeck); cbxStartingPool.addItem(StartingPoolType.SealedDeck);
cbxStartingPool.addItem(StartingPoolType.Cube); cbxStartingPool.addItem(StartingPoolType.Cube);
cbxStartingPool.setChangedHandler(new FEventHandler() { cbxStartingPool.setChangedHandler(event -> {
@Override updateStartingPoolOptions();
public void handleEvent(FEvent e) { scroller.revalidate();
updateStartingPoolOptions();
scroller.revalidate();
}
}); });
cbxPrizedCards.addItem(Forge.getLocalizer().getMessage("lblSameAsStartingPool")); cbxPrizedCards.addItem(Forge.getLocalizer().getMessage("lblSameAsStartingPool"));
cbxPrizedCards.addItem(StartingPoolType.Complete); cbxPrizedCards.addItem(StartingPoolType.Complete);
cbxPrizedCards.addItem(StartingPoolType.Sanctioned); cbxPrizedCards.addItem(StartingPoolType.Sanctioned);
cbxPrizedCards.addItem(StartingPoolType.Casual); cbxPrizedCards.addItem(StartingPoolType.Casual);
cbxPrizedCards.setChangedHandler(new FEventHandler() { cbxPrizedCards.setChangedHandler(event -> {
@Override updatePrizeOptions();
public void handleEvent(FEvent e) { scroller.revalidate();
updatePrizeOptions();
scroller.revalidate();
}
}); });
for (GameFormat gf : FModel.getFormats().getSanctionedList()) { for (GameFormat gf : FModel.getFormats().getSanctionedList()) {
@@ -243,18 +229,15 @@ public class NewQuestScreen extends FScreen {
numberOfBoostersField.setEnabled(false); numberOfBoostersField.setEnabled(false);
@SuppressWarnings("serial") @SuppressWarnings("serial")
UiCommand colorBoxEnabler = new UiCommand() { UiCommand colorBoxEnabler = () -> {
@Override cbBlack.setEnabled(radBalanced.isSelected());
public void run() { cbBlue.setEnabled(radBalanced.isSelected());
cbBlack.setEnabled(radBalanced.isSelected()); cbGreen.setEnabled(radBalanced.isSelected());
cbBlue.setEnabled(radBalanced.isSelected()); cbRed.setEnabled(radBalanced.isSelected());
cbGreen.setEnabled(radBalanced.isSelected()); cbWhite.setEnabled(radBalanced.isSelected());
cbRed.setEnabled(radBalanced.isSelected()); cbColorless.setEnabled(radBalanced.isSelected());
cbWhite.setEnabled(radBalanced.isSelected()); cbIncludeArtifacts.setEnabled(!radSurpriseMe.isSelected());
cbColorless.setEnabled(radBalanced.isSelected()); numberOfBoostersField.setEnabled(radBoosters.isSelected());
cbIncludeArtifacts.setEnabled(!radSurpriseMe.isSelected());
numberOfBoostersField.setEnabled(radBoosters.isSelected());
}
}; };
radBalanced.setCommand(colorBoxEnabler); radBalanced.setCommand(colorBoxEnabler);
@@ -268,12 +251,7 @@ public class NewQuestScreen extends FScreen {
// Default to 'Main world' // Default to 'Main world'
cbxStartingWorld.setSelectedItem(FModel.getWorlds().get("Main world")); cbxStartingWorld.setSelectedItem(FModel.getWorlds().get("Main world"));
cbxStartingWorld.setChangedHandler(new FEventHandler() { cbxStartingWorld.setChangedHandler(event -> updateEnabledFormats());
@Override
public void handleEvent(FEvent e) {
updateEnabledFormats();
}
});
updateStartingPoolOptions(); updateStartingPoolOptions();
updatePrizeOptions(); updatePrizeOptions();
@@ -298,59 +276,44 @@ public class NewQuestScreen extends FScreen {
unselectableSets.add("ARC"); unselectableSets.add("ARC");
unselectableSets.add("PC2"); unselectableSets.add("PC2");
btnSelectFormat.setCommand(new FEventHandler() { btnSelectFormat.setCommand(event -> {
@Override ArchivedFormatSelect archivedFormatSelect = new ArchivedFormatSelect();
public void handleEvent(FEvent e) { archivedFormatSelect.setOnCloseCallBack(() -> {
ArchivedFormatSelect archivedFormatSelect = new ArchivedFormatSelect(); customFormatCodes.clear();
archivedFormatSelect.setOnCloseCallBack(new Runnable() { btnSelectFormat.setText(archivedFormatSelect.getSelectedFormat().getName());
@Override List<String> setsToAdd = archivedFormatSelect.getSelectedFormat().getAllowedSetCodes();
public void run() { for (String setName:setsToAdd){
customFormatCodes.clear(); if(!unselectableSets.contains(setName)){
btnSelectFormat.setText(archivedFormatSelect.getSelectedFormat().getName()); customFormatCodes.add(setName);
List<String> setsToAdd = archivedFormatSelect.getSelectedFormat().getAllowedSetCodes();
for (String setName:setsToAdd){
if(!unselectableSets.contains(setName)){
customFormatCodes.add(setName);
}
}
} }
}); }
Forge.openScreen(archivedFormatSelect); });
} Forge.openScreen(archivedFormatSelect);
}); });
btnPrizeSelectFormat.setCommand(new FEventHandler() { btnPrizeSelectFormat.setCommand(event -> {
@Override ArchivedFormatSelect archivedFormatSelect = new ArchivedFormatSelect();
public void handleEvent(FEvent e) { archivedFormatSelect.setOnCloseCallBack(() -> {
ArchivedFormatSelect archivedFormatSelect = new ArchivedFormatSelect(); customPrizeFormatCodes.clear();
archivedFormatSelect.setOnCloseCallBack(new Runnable() { btnPrizeSelectFormat.setText(archivedFormatSelect.getSelectedFormat().getName());
@Override List<String> setsToAdd = archivedFormatSelect.getSelectedFormat().getAllowedSetCodes();
public void run() { for (String setName:setsToAdd){
customPrizeFormatCodes.clear(); if(!unselectableSets.contains(setName)){
btnPrizeSelectFormat.setText(archivedFormatSelect.getSelectedFormat().getName()); customPrizeFormatCodes.add(setName);
List<String> setsToAdd = archivedFormatSelect.getSelectedFormat().getAllowedSetCodes();
for (String setName:setsToAdd){
if(!unselectableSets.contains(setName)){
customPrizeFormatCodes.add(setName);
}
}
} }
}); }
Forge.openScreen(archivedFormatSelect); });
} Forge.openScreen(archivedFormatSelect);
}); });
// Fantasy box enabled by Default // Fantasy box enabled by Default
cbFantasy.setSelected(true); cbFantasy.setSelected(true);
cbFantasy.setEnabled(true); cbFantasy.setEnabled(true);
cbCommander.setSelected(false); cbCommander.setSelected(false);
cbCommander.setCommand(new FEventHandler() { cbCommander.setCommand(event -> {
@Override if (!isCommander())
public void handleEvent(FEvent e) { return;
if (!isCommander()) cbxStartingWorld.setSelectedItem(FModel.getWorlds().get("Random Commander"));
return;
cbxStartingWorld.setSelectedItem(FModel.getWorlds().get("Random Commander"));
}
}); });
} }
@@ -644,30 +607,22 @@ public class NewQuestScreen extends FScreen {
} }
private void startNewQuest(final String questName, final GameFormat fmtPrizes, final Deck dckStartPool, final GameFormat fmtStartPool) { private void startNewQuest(final String questName, final GameFormat fmtPrizes, final Deck dckStartPool, final GameFormat fmtStartPool) {
FThreads.invokeInEdtLater(new Runnable() { FThreads.invokeInEdtLater(() -> LoadingOverlay.show(Forge.getLocalizer().getMessage("lblCreatingNewQuest"), true, () -> {
@Override final QuestMode mode = isFantasy() ? QuestMode.Fantasy : QuestMode.Classic;
public void run() { final StartingPoolPreferences userPrefs =
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblCreatingNewQuest"), new Runnable() { new StartingPoolPreferences(getPoolType(), getPreferredColors(), cbIncludeArtifacts.isSelected(), startWithCompleteSet(), allowDuplicateCards(), numberOfBoostersField.getValue());
@Override QuestController qc = FModel.getQuest();
public void run() {
final QuestMode mode = isFantasy() ? QuestMode.Fantasy : QuestMode.Classic;
final StartingPoolPreferences userPrefs =
new StartingPoolPreferences(getPoolType(), getPreferredColors(), cbIncludeArtifacts.isSelected(), startWithCompleteSet(), allowDuplicateCards(), numberOfBoostersField.getValue());
QuestController qc = FModel.getQuest();
DeckConstructionRules dcr = isCommander() ? DeckConstructionRules.Commander: DeckConstructionRules.Default; DeckConstructionRules dcr = isCommander() ? DeckConstructionRules.Commander: DeckConstructionRules.Default;
qc.newGame(questName, getSelectedDifficulty(), mode, fmtPrizes, isUnlockSetsAllowed(), dckStartPool, fmtStartPool, getStartingWorldName(), userPrefs, dcr); qc.newGame(questName, getSelectedDifficulty(), mode, fmtPrizes, isUnlockSetsAllowed(), dckStartPool, fmtStartPool, getStartingWorldName(), userPrefs, dcr);
qc.save(); qc.save();
// Save in preferences. // Save in preferences.
FModel.getQuestPreferences().setPref(QPref.CURRENT_QUEST, questName + ".dat"); FModel.getQuestPreferences().setPref(QPref.CURRENT_QUEST, questName + ".dat");
FModel.getQuestPreferences().save(); FModel.getQuestPreferences().save();
QuestMenu.launchQuestMode(LaunchReason.NewQuest, isCommander()); //launch quest mode for new quest QuestMenu.launchQuestMode(LaunchReason.NewQuest, isCommander()); //launch quest mode for new quest
} }));
});
}
});
} }
} }

33
forge-gui-mobile/src/forge/screens/quest/QuestDuelsScreen.java
View File

@@ -33,12 +33,7 @@ public class QuestDuelsScreen extends QuestLaunchScreen {
public QuestDuelsScreen() { public QuestDuelsScreen() {
super(); super();
pnlDuels.setActivateHandler(new FEventHandler() { pnlDuels.setActivateHandler(event -> startMatch());
@Override
public void handleEvent(FEvent e) {
startMatch();
}
});
} }
@Override @Override
@@ -74,23 +69,15 @@ public class QuestDuelsScreen extends QuestLaunchScreen {
} }
private void generateDuels() { private void generateDuels() {
FThreads.invokeInEdtLater(new Runnable() { FThreads.invokeInEdtLater(() -> LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingCurrentQuest"), true, () -> {
@Override pnlDuels.clear();
public void run() { List<QuestEventDuel> duels = FModel.getQuest().getDuelsManager().generateDuels();
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingCurrentQuest"), new Runnable() { if (duels != null) {
@Override for (QuestEventDuel duel : duels) {
public void run() { pnlDuels.add(new QuestEventPanel(duel, pnlDuels));
pnlDuels.clear(); }
List<QuestEventDuel> duels = FModel.getQuest().getDuelsManager().generateDuels();
if (duels != null) {
for (QuestEventDuel duel : duels) {
pnlDuels.add(new QuestEventPanel(duel, pnlDuels));
}
}
pnlDuels.revalidate();
}
});
} }
}); pnlDuels.revalidate();
}));
} }
} }

21
forge-gui-mobile/src/forge/screens/quest/QuestLaunchScreen.java
View File

@@ -22,23 +22,10 @@ public abstract class QuestLaunchScreen extends LaunchScreen {
@Override @Override
protected void startMatch() { protected void startMatch() {
FThreads.invokeInBackgroundThread(new Runnable() { FThreads.invokeInBackgroundThread(() -> {
@Override if (QuestUtil.canStartGame()) {
public void run() { FThreads.invokeInEdtLater(() -> LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), true, () -> QuestUtil.finishStartingGame()));
if (QuestUtil.canStartGame()) { return;
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), new Runnable() {
@Override
public void run() {
QuestUtil.finishStartingGame();
}
});
}
});
return;
}
} }
}); });
} }

161
forge-gui-mobile/src/forge/screens/quest/QuestMenu.java
View File

@@ -42,88 +42,28 @@ public class QuestMenu extends FPopupMenu implements IVQuestStats {
private static final QuestStatsScreen statsScreen = new QuestStatsScreen(); private static final QuestStatsScreen statsScreen = new QuestStatsScreen();
private static final QuestTournamentsScreen tournamentsScreen = new QuestTournamentsScreen(); private static final QuestTournamentsScreen tournamentsScreen = new QuestTournamentsScreen();
private static final FMenuItem duelsItem = new FMenuItem(Forge.getLocalizer().getMessage("lblDuels"), FSkinImage.QUEST_BIG_SWORD, new FEventHandler() { private static final FMenuItem duelsItem = new FMenuItem(Forge.getLocalizer().getMessage("lblDuels"), FSkinImage.QUEST_BIG_SWORD, event -> setCurrentScreen(duelsScreen));
@Override private static final FMenuItem challengesItem = new FMenuItem(Forge.getLocalizer().getMessage("lblChallenges"), FSkinImage.QUEST_HEART, event -> setCurrentScreen(challengesScreen));
public void handleEvent(FEvent e) { private static final FMenuItem tournamentsItem = new FMenuItem(Forge.getLocalizer().getMessage("lblTournaments"), FSkinImage.QUEST_BIG_SHIELD, event -> setCurrentScreen(tournamentsScreen));
setCurrentScreen(duelsScreen); private static final FMenuItem decksItem = new FMenuItem(Forge.getLocalizer().getMessage("lblQuestDecks"), FSkinImage.QUEST_BIG_BAG, event -> setCurrentScreen(decksScreen));
} private static final FMenuItem spellShopItem = new FMenuItem(Forge.getLocalizer().getMessage("lblSpellShop"), FSkinImage.QUEST_BOOK, event -> setCurrentScreen(spellShopScreen));
private static final FMenuItem bazaarItem = new FMenuItem(Forge.getLocalizer().getMessage("lblBazaar"), FSkinImage.QUEST_BOTTLES, event -> setCurrentScreen(bazaarScreen));
private static final FMenuItem statsItem = new FMenuItem(Forge.getLocalizer().getMessage("lblStatistics"), FSkinImage.MENU_STATS, event -> setCurrentScreen(statsScreen));
private static final FMenuItem unlockSetsItem = new FMenuItem(Forge.getLocalizer().getMessage("btnUnlockSets"), FSkinImage.QUEST_MAP, event -> {
//invoke in background thread so prompts can work
ThreadUtil.invokeInGameThread(() -> {
QuestUtil.chooseAndUnlockEdition();
FThreads.invokeInEdtLater(() -> updateCurrentQuestScreen());
});
}); });
private static final FMenuItem challengesItem = new FMenuItem(Forge.getLocalizer().getMessage("lblChallenges"), FSkinImage.QUEST_HEART, new FEventHandler() { private static final FMenuItem travelItem = new FMenuItem(Forge.getLocalizer().getMessage("btnTravel"), FSkinImage.QUEST_MAP, event -> {
@Override //invoke in background thread so prompts can work
public void handleEvent(FEvent e) { ThreadUtil.invokeInGameThread(() -> {
setCurrentScreen(challengesScreen); QuestUtil.travelWorld();
} FThreads.invokeInEdtLater(() -> updateCurrentQuestScreen());
}); });
private static final FMenuItem tournamentsItem = new FMenuItem(Forge.getLocalizer().getMessage("lblTournaments"), FSkinImage.QUEST_BIG_SHIELD, new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
setCurrentScreen(tournamentsScreen);
}
});
private static final FMenuItem decksItem = new FMenuItem(Forge.getLocalizer().getMessage("lblQuestDecks"), FSkinImage.QUEST_BIG_BAG, new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
setCurrentScreen(decksScreen);
}
});
private static final FMenuItem spellShopItem = new FMenuItem(Forge.getLocalizer().getMessage("lblSpellShop"), FSkinImage.QUEST_BOOK, new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
setCurrentScreen(spellShopScreen);
}
});
private static final FMenuItem bazaarItem = new FMenuItem(Forge.getLocalizer().getMessage("lblBazaar"), FSkinImage.QUEST_BOTTLES, new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
setCurrentScreen(bazaarScreen);
}
});
private static final FMenuItem statsItem = new FMenuItem(Forge.getLocalizer().getMessage("lblStatistics"), FSkinImage.MENU_STATS, new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
setCurrentScreen(statsScreen);
}
});
private static final FMenuItem unlockSetsItem = new FMenuItem(Forge.getLocalizer().getMessage("btnUnlockSets"), FSkinImage.QUEST_MAP, new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
ThreadUtil.invokeInGameThread(new Runnable() { //invoke in background thread so prompts can work
@Override
public void run() {
QuestUtil.chooseAndUnlockEdition();
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
updateCurrentQuestScreen();
}
});
}
});
}
});
private static final FMenuItem travelItem = new FMenuItem(Forge.getLocalizer().getMessage("btnTravel"), FSkinImage.QUEST_MAP, new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
ThreadUtil.invokeInGameThread(new Runnable() { //invoke in background thread so prompts can work
@Override
public void run() {
QuestUtil.travelWorld();
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
updateCurrentQuestScreen();
}
});
}
});
}
});
private static final FMenuItem prefsItem = new FMenuItem(Forge.getLocalizer().getMessage("Preferences"), Forge.hdbuttons ? FSkinImage.HDPREFERENCE : FSkinImage.SETTINGS, new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
setCurrentScreen(prefsScreen);
}
}); });
private static final FMenuItem prefsItem = new FMenuItem(Forge.getLocalizer().getMessage("Preferences"), Forge.hdbuttons ? FSkinImage.HDPREFERENCE : FSkinImage.SETTINGS, event -> setCurrentScreen(prefsScreen));
static { static {
statsScreen.addTournamentResultsLabels(tournamentsScreen); statsScreen.addTournamentResultsLabels(tournamentsScreen);
@@ -159,12 +99,7 @@ public class QuestMenu extends FPopupMenu implements IVQuestStats {
static { static {
//the first time quest mode is launched, add button for it if in Landscape mode //the first time quest mode is launched, add button for it if in Landscape mode
if (Forge.isLandscapeMode()) { if (Forge.isLandscapeMode()) {
HomeScreen.instance.addButtonForMode("-"+Forge.getLocalizer().getMessage("lblQuestMode"), new FEventHandler() { HomeScreen.instance.addButtonForMode("-"+Forge.getLocalizer().getMessage("lblQuestMode"), event -> launchQuestMode(LaunchReason.StartQuestMode, HomeScreen.instance.getQuestCommanderMode()));
@Override
public void handleEvent(FEvent e) {
launchQuestMode(LaunchReason.StartQuestMode, HomeScreen.instance.getQuestCommanderMode());
}
});
} }
} }
@@ -190,40 +125,36 @@ public class QuestMenu extends FPopupMenu implements IVQuestStats {
final String questname = FModel.getQuestPreferences().getPref(QPref.CURRENT_QUEST); final String questname = FModel.getQuestPreferences().getPref(QPref.CURRENT_QUEST);
final File data = new File(dirQuests.getPath(), questname); final File data = new File(dirQuests.getPath(), questname);
if (data.exists()) { if (data.exists()) {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingCurrentQuest"), new Runnable() { LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingCurrentQuest"), true, () -> {
@Override try {
@SuppressWarnings("unchecked") FModel.getQuest().load(QuestDataIO.loadData(data));
public void run() { } catch (IOException e) {
try { System.err.println(String.format("Failed to load quest '%s'", questname));
FModel.getQuest().load(QuestDataIO.loadData(data)); // Failed to load last quest, don't continue with quest loading stuff
} catch (IOException e) { return;
System.err.println(String.format("Failed to load quest '%s'", questname)); }
// Failed to load last quest, don't continue with quest loading stuff
return;
}
((DeckController<Deck>)EditorType.Quest.getController()).setRootFolder(FModel.getQuest().getMyDecks()); ((DeckController<Deck>)EditorType.Quest.getController()).setRootFolder(FModel.getQuest().getMyDecks());
((DeckController<DeckGroup>)EditorType.QuestDraft.getController()).setRootFolder(FModel.getQuest().getDraftDecks()); ((DeckController<DeckGroup>)EditorType.QuestDraft.getController()).setRootFolder(FModel.getQuest().getDraftDecks());
if (reason == LaunchReason.StartQuestMode) { if (reason == LaunchReason.StartQuestMode) {
if (QuestUtil.getCurrentDeck() == null) { if (QuestUtil.getCurrentDeck() == null) {
Forge.openScreen(decksScreen); //if quest doesn't have a deck specified, open decks screen by default Forge.openScreen(decksScreen); //if quest doesn't have a deck specified, open decks screen by default
}
else {
Forge.openScreen(duelsScreen); //TODO: Consider opening most recent quest view
}
} }
else { else {
duelsScreen.update(); Forge.openScreen(duelsScreen); //TODO: Consider opening most recent quest view
challengesScreen.update();
tournamentsScreen.update();
decksScreen.refreshDecks();
Forge.openScreen(duelsScreen);
if (reason == LaunchReason.NewQuest) {
LoadGameScreen.QuestMode.setAsBackScreen(true);
}
} }
HomeScreen.instance.updateQuestWorld(FModel.getQuest().getWorld() == null ? "" : FModel.getQuest().getWorld().toString());
} }
else {
duelsScreen.update();
challengesScreen.update();
tournamentsScreen.update();
decksScreen.refreshDecks();
Forge.openScreen(duelsScreen);
if (reason == LaunchReason.NewQuest) {
LoadGameScreen.QuestMode.setAsBackScreen(true);
}
}
HomeScreen.instance.updateQuestWorld(FModel.getQuest().getWorld() == null ? "" : FModel.getQuest().getWorld().toString());
}); });
return; return;
} }

158
forge-gui-mobile/src/forge/screens/quest/QuestSpellShopScreen.java
View File

@@ -49,36 +49,25 @@ public class QuestSpellShopScreen extends TabPageScreen<QuestSpellShopScreen> {
inventoryPage = ((InventoryPage)tabPages[1]); inventoryPage = ((InventoryPage)tabPages[1]);
btnBuySellMultiple.setVisible(false); //hide unless in multi-select mode btnBuySellMultiple.setVisible(false); //hide unless in multi-select mode
btnBuySellMultiple.setCommand(new FEventHandler() { btnBuySellMultiple.setCommand(event -> {
@Override final SpellShopManager itemManager = ((SpellShopBasePage)getSelectedPage()).itemManager;
public void handleEvent(FEvent e) { final ItemPool<InventoryItem> items = itemManager.getSelectedItemPool();
final SpellShopManager itemManager = ((SpellShopBasePage)getSelectedPage()).itemManager;
final ItemPool<InventoryItem> items = itemManager.getSelectedItemPool();
if (items.isEmpty()) { if (items.isEmpty()) {
//toggle off multi-select mode if no items selected //toggle off multi-select mode if no items selected
itemManager.toggleMultiSelectMode(-1); itemManager.toggleMultiSelectMode(-1);
return; return;
}
FThreads.invokeInBackgroundThread(new Runnable() {
@Override
public void run() {
if (getSelectedPage() == spellShopPage) {
spellShopPage.activateItems(items);
}
else {
inventoryPage.activateItems(items);
}
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
updateCreditsLabel();
}
});
}
});
} }
FThreads.invokeInBackgroundThread(() -> {
if (getSelectedPage() == spellShopPage) {
spellShopPage.activateItems(items);
}
else {
inventoryPage.activateItems(items);
}
FThreads.invokeInEdtLater(() -> updateCreditsLabel());
});
}); });
} }
@@ -190,28 +179,17 @@ public class QuestSpellShopScreen extends TabPageScreen<QuestSpellShopScreen> {
parentScreen.tabHeader.setVisible(!multiSelectMode); parentScreen.tabHeader.setVisible(!multiSelectMode);
} }
}); });
itemManager.setItemActivateHandler(new FEventHandler() { itemManager.setItemActivateHandler(event -> {
@Override
public void handleEvent(FEvent e) {
}
}); });
itemManager.setContextMenuBuilder(new ContextMenuBuilder<InventoryItem>() { itemManager.setContextMenuBuilder(new ContextMenuBuilder<InventoryItem>() {
@Override @Override
public void buildMenu(final FDropDownMenu menu, final InventoryItem item) { public void buildMenu(final FDropDownMenu menu, final InventoryItem item) {
menu.addItem(new FMenuItem(getVerb(), getVerbIcon(), new FEventHandler() { menu.addItem(new FMenuItem(getVerb(), getVerbIcon(), event -> activateSelectedItem()));
@Override
public void handleEvent(FEvent e) {
activateSelectedItem();
}
}));
} }
}); });
itemManager.setSelectionChangedHandler(new FEventHandler() { itemManager.setSelectionChangedHandler(event -> {
@Override if (itemManager.getMultiSelectMode()) {
public void handleEvent(FEvent e) { parentScreen.updateBuySellButtonCaption();
if (itemManager.getMultiSelectMode()) {
parentScreen.updateBuySellButtonCaption();
}
} }
}); });
add(lblCredits); add(lblCredits);
@@ -235,19 +213,11 @@ public class QuestSpellShopScreen extends TabPageScreen<QuestSpellShopScreen> {
if (result == null || result <= 0) { return; } if (result == null || result <= 0) { return; }
//invoke in background thread so other dialogs can be shown properly //invoke in background thread so other dialogs can be shown properly
FThreads.invokeInBackgroundThread(new Runnable() { FThreads.invokeInBackgroundThread(() -> {
@Override ItemPool<InventoryItem> items = new ItemPool<>(InventoryItem.class);
public void run() { items.add(item, result);
ItemPool<InventoryItem> items = new ItemPool<>(InventoryItem.class); activateItems(items);
items.add(item, result); FThreads.invokeInEdtLater(() -> parentScreen.updateCreditsLabel());
activateItems(items);
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
parentScreen.updateCreditsLabel();
}
});
}
}); });
} }
}; };
@@ -290,22 +260,14 @@ public class QuestSpellShopScreen extends TabPageScreen<QuestSpellShopScreen> {
@Override @Override
protected void refresh() { protected void refresh() {
FThreads.invokeInEdtLater(new Runnable() { FThreads.invokeInEdtLater(() -> LoadingOverlay.show(Forge.getLocalizer().getInstance().getMessage("lblLoading"), true, () -> {
@Override Map<ColumnDef, ItemColumn> colOverrides = new HashMap<>();
public void run() { ItemColumn.addColOverride(ItemManagerConfig.SPELL_SHOP, colOverrides, ColumnDef.PRICE, QuestSpellShop.fnPriceCompare, QuestSpellShop.fnPriceGet);
LoadingOverlay.show(Forge.getLocalizer().getInstance().getMessage("lblLoading"), new Runnable() { ItemColumn.addColOverride(ItemManagerConfig.SPELL_SHOP, colOverrides, ColumnDef.OWNED, FModel.getQuest().getCards().getFnOwnedCompare(), FModel.getQuest().getCards().getFnOwnedGet());
@Override itemManager.setup(ItemManagerConfig.SPELL_SHOP, colOverrides);
public void run() {
Map<ColumnDef, ItemColumn> colOverrides = new HashMap<>();
ItemColumn.addColOverride(ItemManagerConfig.SPELL_SHOP, colOverrides, ColumnDef.PRICE, QuestSpellShop.fnPriceCompare, QuestSpellShop.fnPriceGet);
ItemColumn.addColOverride(ItemManagerConfig.SPELL_SHOP, colOverrides, ColumnDef.OWNED, FModel.getQuest().getCards().getFnOwnedCompare(), FModel.getQuest().getCards().getFnOwnedGet());
itemManager.setup(ItemManagerConfig.SPELL_SHOP, colOverrides);
itemManager.setPool(FModel.getQuest().getCards().getShopList()); itemManager.setPool(FModel.getQuest().getCards().getShopList());
} }));
});
}
});
} }
@Override @Override
@@ -337,47 +299,25 @@ public class QuestSpellShopScreen extends TabPageScreen<QuestSpellShopScreen> {
private static class InventoryPage extends SpellShopBasePage { private static class InventoryPage extends SpellShopBasePage {
protected FLabel lblSellExtras = add(new FLabel.Builder().text(Forge.getLocalizer().getMessage("lblSellAllExtras")) protected FLabel lblSellExtras = add(new FLabel.Builder().text(Forge.getLocalizer().getMessage("lblSellAllExtras"))
.icon(Forge.hdbuttons ? FSkinImage.HDMINUS : FSkinImage.MINUS).iconScaleFactor(1f).align(Align.right).font(FSkinFont.get(16)) .icon(Forge.hdbuttons ? FSkinImage.HDMINUS : FSkinImage.MINUS).iconScaleFactor(1f).align(Align.right).font(FSkinFont.get(16))
.command(new FEventHandler() { .command(event -> {
@Override //invoke in background thread so other dialogs can be shown properly
public void handleEvent(FEvent e) { FThreads.invokeInBackgroundThread(() -> {
//invoke in background thread so other dialogs can be shown properly
FThreads.invokeInBackgroundThread(new Runnable() {
@Override
public void run() {
QuestSpellShop.sellExtras(parentScreen.spellShopPage.itemManager, itemManager); QuestSpellShop.sellExtras(parentScreen.spellShopPage.itemManager, itemManager);
FThreads.invokeInEdtLater(new Runnable() { FThreads.invokeInEdtLater(() -> parentScreen.updateCreditsLabel());
@Override });
public void run() { }).build());
parentScreen.updateCreditsLabel();
}
});
}
});
}
}).build());
protected FLabel lblSelectAll = add(new FLabel.Builder().text(Forge.getLocalizer().getMessage("lblSelectAllCards")) protected FLabel lblSelectAll = add(new FLabel.Builder().text(Forge.getLocalizer().getMessage("lblSelectAllCards"))
.icon(Forge.hdbuttons ? FSkinImage.HDSTAR_FILLED : FSkinImage.STAR_FILLED).iconScaleFactor(1f).align(Align.right).font(FSkinFont.get(16)) .icon(Forge.hdbuttons ? FSkinImage.HDSTAR_FILLED : FSkinImage.STAR_FILLED).iconScaleFactor(1f).align(Align.right).font(FSkinFont.get(16))
.command(new FEventHandler() { .command(event -> {
@Override //invoke in background thread so other dialogs can be shown properly
public void handleEvent(FEvent e) { FThreads.invokeInBackgroundThread(() -> {
//invoke in background thread so other dialogs can be shown properly if (!itemManager.getMultiSelectMode()) {
FThreads.invokeInBackgroundThread(new Runnable() { itemManager.toggleMultiSelectMode(0);
@Override }
public void run() { itemManager.selectAll();
if (!itemManager.getMultiSelectMode()) { FThreads.invokeInEdtLater(() -> parentScreen.updateCreditsLabel());
itemManager.toggleMultiSelectMode(0); });
}
itemManager.selectAll();
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
parentScreen.updateCreditsLabel();
}
});
}
});
}
}).build()); }).build());
private InventoryPage() { private InventoryPage() {

95
forge-gui-mobile/src/forge/screens/quest/QuestTournamentsScreen.java
View File

@@ -84,52 +84,21 @@ public class QuestTournamentsScreen extends QuestLaunchScreen implements IQuestT
public QuestTournamentsScreen() { public QuestTournamentsScreen() {
super(); super();
controller = new QuestTournamentController(this); controller = new QuestTournamentController(this);
btnSpendToken.setCommand(new FEventHandler() { btnSpendToken.setCommand(event -> {
@Override //must run in background thread to handle alerts
public void handleEvent(FEvent e) { FThreads.invokeInBackgroundThread(() -> controller.spendToken());
FThreads.invokeInBackgroundThread(new Runnable() { //must run in background thread to handle alerts
@Override
public void run() {
controller.spendToken();
}
});
}
}); });
btnEditDeck.setCommand(new FEventHandler() { btnEditDeck.setCommand(event -> editDeck(true));
@Override btnLeaveTournament.setCommand(event -> {
public void handleEvent(FEvent e) { //must run in background thread to handle alerts
editDeck(true); FThreads.invokeInBackgroundThread(() -> controller.endTournamentAndAwardPrizes());
}
});
btnLeaveTournament.setCommand(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
FThreads.invokeInBackgroundThread(new Runnable() { //must run in background thread to handle alerts
@Override
public void run() {
controller.endTournamentAndAwardPrizes();
}
});
}
}); });
// TODO: is it possible to somehow reuse the original btnEditDeck/btnLeaveTournament // TODO: is it possible to somehow reuse the original btnEditDeck/btnLeaveTournament
btnEditDeckInTourn.setCommand(new FEventHandler() { btnEditDeckInTourn.setCommand(event -> editDeck(true));
@Override btnLeaveTournamentInTourn.setCommand(event -> {
public void handleEvent(FEvent e) { //must run in background thread to handle alerts
editDeck(true); FThreads.invokeInBackgroundThread(() -> controller.endTournamentAndAwardPrizes());
}
});
btnLeaveTournamentInTourn.setCommand(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
FThreads.invokeInBackgroundThread(new Runnable() { //must run in background thread to handle alerts
@Override
public void run() {
controller.endTournamentAndAwardPrizes();
}
});
}
}); });
pnlPrepareDeck.add(btnEditDeck); pnlPrepareDeck.add(btnEditDeck);
@@ -231,17 +200,7 @@ public class QuestTournamentsScreen extends QuestLaunchScreen implements IQuestT
@Override @Override
public void startDraft(BoosterDraft draft) { public void startDraft(BoosterDraft draft) {
FThreads.invokeInEdtLater(new Runnable() { FThreads.invokeInEdtLater(() -> LoadingOverlay.show("Loading Quest Tournament", true, () -> Forge.openScreen(new DraftingProcessScreen(draft, EditorType.QuestDraft, controller))));
@Override
public void run() {
LoadingOverlay.show("Loading Quest Tournament", new Runnable() {
@Override
public void run() {
Forge.openScreen(new DraftingProcessScreen(draft, EditorType.QuestDraft, controller));
}
});
}
});
} }
private Deck getDeck() { private Deck getDeck() {
@@ -276,22 +235,20 @@ public class QuestTournamentsScreen extends QuestLaunchScreen implements IQuestT
return; return;
} }
FThreads.invokeInBackgroundThread(new Runnable() { //must run in background thread to handle alerts //must run in background thread to handle alerts
@Override FThreads.invokeInBackgroundThread(() -> {
public void run() { switch (mode) {
switch (mode) { case SELECT_TOURNAMENT:
case SELECT_TOURNAMENT: controller.startDraft();
controller.startDraft(); break;
break; case PREPARE_DECK:
case PREPARE_DECK: controller.startTournament();
controller.startTournament(); break;
break; case TOURNAMENT_ACTIVE:
case TOURNAMENT_ACTIVE: controller.startNextMatch();
controller.startNextMatch(); break;
break; default:
default: break;
break;
}
} }
}); });
} }