external-repos/forge
1
0
Fork 0
mirror of https://github.com/Card-Forge/forge.git synced 2025-11-16 18:58: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;
public static KeyInputAdapter keyInputAdapter;
private static boolean exited;
private boolean needsUpdate = false;
public static boolean safeToClose = true;
public static boolean magnify = false;
public static boolean magnifyToggle = true;
@@ -785,6 +786,10 @@ public class Forge implements ApplicationListener {
try {
ImageCache.allowSingleLoad();
ForgeAnimation.advanceAll();
if (needsUpdate) {
if (getAssets().manager.update())
needsUpdate = false;
}
Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT); // Clear the screen.
@@ -922,6 +927,7 @@ public class Forge implements ApplicationListener {
@Override
public void resume() {
Texture.setAssetManager(getAssets().manager);
needsUpdate = true;
if (MatchController.getHostedMatch() != null) {
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);
isAi = isAi0;
lstDecks.setItemActivateHandler(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
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) {
lstDecks.setItemActivateHandler(event -> {
if (lstDecks.getGameType() == GameType.DeckManager) {
//for Deck Editor, edit deck instead of accepting
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() {
@Override
public void handleEvent(FEvent e) {
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));
}
btnRandom.setCommand(event -> {
if (lstDecks.getGameType() == GameType.DeckManager) {
//for Deck Editor, test deck instead of randomly selecting deck
testSelectedDeck();
return;
}
});
btnRandom.setCommand(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
if (lstDecks.getGameType() == GameType.DeckManager) {
//for Deck Editor, test deck instead of randomly selecting deck
testSelectedDeck();
return;
}
if (selectedDeckType == DeckType.COLOR_DECK || selectedDeckType == DeckType.STANDARD_COLOR_DECK
|| selectedDeckType == DeckType.MODERN_COLOR_DECK) {
DeckgenUtil.randomSelectColors(lstDecks);
}
else if (selectedDeckType == DeckType.STANDARD_CARDGEN_DECK){
DeckgenUtil.randomSelect(lstDecks);
}
else if (selectedDeckType == DeckType.PIONEER_CARDGEN_DECK){
DeckgenUtil.randomSelect(lstDecks);
}
else if (selectedDeckType == DeckType.HISTORIC_CARDGEN_DECK){
DeckgenUtil.randomSelect(lstDecks);
}
else if (selectedDeckType == DeckType.MODERN_CARDGEN_DECK){
DeckgenUtil.randomSelect(lstDecks);
}
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 (selectedDeckType == DeckType.COLOR_DECK || selectedDeckType == DeckType.STANDARD_COLOR_DECK
|| selectedDeckType == DeckType.MODERN_COLOR_DECK) {
DeckgenUtil.randomSelectColors(lstDecks);
}
else if (selectedDeckType == DeckType.STANDARD_CARDGEN_DECK){
DeckgenUtil.randomSelect(lstDecks);
}
else if (selectedDeckType == DeckType.PIONEER_CARDGEN_DECK){
DeckgenUtil.randomSelect(lstDecks);
}
else if (selectedDeckType == DeckType.HISTORIC_CARDGEN_DECK){
DeckgenUtil.randomSelect(lstDecks);
}
else if (selectedDeckType == DeckType.MODERN_CARDGEN_DECK){
DeckgenUtil.randomSelect(lstDecks);
}
else if (selectedDeckType == DeckType.LEGACY_CARDGEN_DECK){
DeckgenUtil.randomSelect(lstDecks);
}
else if (selectedDeckType == DeckType.VINTAGE_CARDGEN_DECK){
DeckgenUtil.randomSelect(lstDecks);
}
else {
int size = 0;
try {
if (isAi && !isGeneratedDeck(selectedDeckType) && Forge.autoAIDeckSelection) {
btnRandom.setEnabled(false);
AIDecks = lstDecks.getPool().toFlatList().parallelStream().filter(deckProxy -> deckProxy.getAI().inMainDeck == 0).collect(Collectors.toList());
size = AIDecks.size();
}
@@ -207,9 +191,12 @@ public class FDeckChooser extends FScreen {
lstDecks.setSelectedItem(AIDecks.get(MyRandom.getRandom().nextInt(size)));
else
DeckgenUtil.randomSelect(lstDecks);
} catch (Exception ee) {
DeckgenUtil.randomSelect(lstDecks);
}
accept();
}
btnRandom.setEnabled(true);
accept();
});
switch (lstDecks.getGameType()) {
case Constructed:
@@ -371,32 +358,29 @@ public class FDeckChooser extends FScreen {
} else {
editor = new FDeckEditor(getEditorType(), "", false);
}
editor.setSaveHandler(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
//ensure user returns to proper deck type and that list is refreshed if new deck is saved
if (!needRefreshOnActivate) {
needRefreshOnActivate = true;
if (lstDecks.getGameType() == GameType.DeckManager) {
switch (selectedDeckType) {
case COMMANDER_DECK:
case OATHBREAKER_DECK:
case TINY_LEADERS_DECK:
case BRAWL_DECK:
case SCHEME_DECK:
case PLANAR_DECK:
case DRAFT_DECK:
case SEALED_DECK:
break;
default:
setSelectedDeckType(DeckType.CONSTRUCTED_DECK);
break;
}
}
else {
setSelectedDeckType(DeckType.CUSTOM_DECK);
editor.setSaveHandler(event -> {
//ensure user returns to proper deck type and that list is refreshed if new deck is saved
if (!needRefreshOnActivate) {
needRefreshOnActivate = true;
if (lstDecks.getGameType() == GameType.DeckManager) {
switch (selectedDeckType) {
case COMMANDER_DECK:
case OATHBREAKER_DECK:
case TINY_LEADERS_DECK:
case BRAWL_DECK:
case SCHEME_DECK:
case PLANAR_DECK:
case DRAFT_DECK:
case SEALED_DECK:
break;
default:
setSelectedDeckType(DeckType.CONSTRUCTED_DECK);
break;
}
}
else {
setSelectedDeckType(DeckType.CUSTOM_DECK);
}
}
});
Forge.openScreen(editor);
@@ -624,249 +608,205 @@ public class FDeckChooser extends FScreen {
cmbDeckTypes.setAlignment(Align.center);
restoreSavedState();
cmbDeckTypes.setChangedHandler(new FEventHandler() {
@Override
cmbDeckTypes.setChangedHandler(event -> {
final DeckType deckType = cmbDeckTypes.getSelectedItem();
public void handleEvent(final FEvent e) {
final DeckType deckType = cmbDeckTypes.getSelectedItem();
if (!refreshingDeckType&&(deckType == DeckType.NET_DECK || deckType == DeckType.NET_COMMANDER_DECK)) {
//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.invokeInBackgroundThread(new Runnable() { //needed for loading net decks
@Override
public void run() {
GameType gameType = lstDecks.getGameType();
if (gameType == GameType.DeckManager) {
gameType = deckType == DeckType.NET_COMMANDER_DECK ? GameType.Commander : GameType.Constructed;
FThreads.invokeInEdtLater(() -> {
if (category == null) {
cmbDeckTypes.setSelectedItem(selectedDeckType); //restore old selection if user cancels
if (selectedDeckType == deckType && netDeckCategory != null) {
cmbDeckTypes.setText(netDeckCategory.getDeckType());
}
final NetDeckCategory category = NetDeckCategory.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 && netDeckCategory != null) {
cmbDeckTypes.setText(netDeckCategory.getDeckType());
}
return;
}
netDeckCategory = category;
refreshDecksList(deckType, true, e);
}
});
return;
}
netDeckCategory = category;
refreshDecksList(deckType, true, event);
});
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);
});
return;
}
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(lstDecks);
@@ -888,11 +828,11 @@ public class FDeckChooser extends FScreen {
saveState();
}
private void refreshDecksList(DeckType deckType, boolean forceRefresh, FEvent e) {
private void refreshDecksList(DeckType deckType, boolean forceRefresh, FEvent event) {
if (selectedDeckType == deckType && !forceRefresh) { return; }
selectedDeckType = deckType;
if (e == null) {
if (event == null) {
refreshingDeckType = true;
cmbDeckTypes.setSelectedItem(deckType);
refreshingDeckType = false;
@@ -1186,7 +1126,7 @@ public class FDeckChooser extends FScreen {
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) {
// default selection = basic two color deck
lstDecks.setSelectedIndices(new Integer[]{0, 1});
@@ -1510,36 +1450,26 @@ public class FDeckChooser extends FScreen {
return;
}
FThreads.invokeInBackgroundThread(new Runnable() { //needed for loading net decks
@Override
public void run() {
final NetDeckCategory netCat;
if (allowedDeckTypes.contains(DeckType.NET_DECK)) {
netCat = NetDeckCategory.selectAndLoad(GameType.Constructed);
} else {
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);
}
});
}
});
//needed for loading net decks
FThreads.invokeInBackgroundThread(() -> {
final NetDeckCategory netCat;
if (allowedDeckTypes.contains(DeckType.NET_DECK)) {
netCat = NetDeckCategory.selectAndLoad(GameType.Constructed);
} else {
netCat = null;
}
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) {
if (aiDeck == null) { return; }
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), new Runnable() {
@Override
public void run() {
Set<GameType> appliedVariants = new HashSet<>();
appliedVariants.add(variant);
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), true, () -> {
Set<GameType> appliedVariants = new HashSet<>();
appliedVariants.add(variant);
List<RegisteredPlayer> players = new ArrayList<>();
RegisteredPlayer humanPlayer = RegisteredPlayer.forVariants(2, appliedVariants, userDeck, null, false, null, null);
humanPlayer.setPlayer(GamePlayerUtil.getGuiPlayer());
RegisteredPlayer aiPlayer = RegisteredPlayer.forVariants(2, appliedVariants, aiDeck, null, false, null, null);
aiPlayer.setPlayer(GamePlayerUtil.createAiPlayer());
players.add(humanPlayer);
players.add(aiPlayer);
List<RegisteredPlayer> players = new ArrayList<>();
RegisteredPlayer humanPlayer = RegisteredPlayer.forVariants(2, appliedVariants, userDeck, null, false, null, null);
humanPlayer.setPlayer(GamePlayerUtil.getGuiPlayer());
RegisteredPlayer aiPlayer = RegisteredPlayer.forVariants(2, appliedVariants, aiDeck, null, false, null, null);
aiPlayer.setPlayer(GamePlayerUtil.createAiPlayer());
players.add(humanPlayer);
players.add(aiPlayer);
final Map<RegisteredPlayer, IGuiGame> guiMap = new HashMap<>();
guiMap.put(humanPlayer, MatchController.instance);
final Map<RegisteredPlayer, IGuiGame> guiMap = new HashMap<>();
guiMap.put(humanPlayer, MatchController.instance);
final HostedMatch hostedMatch = GuiBase.getInterface().hostMatch();
hostedMatch.startMatch(GameType.Constructed, appliedVariants, players, guiMap);
}
final HostedMatch hostedMatch = GuiBase.getInterface().hostMatch();
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 FSkinColor BACK_COLOR = FSkinColor.get(Colors.CLR_ACTIVE).alphaColor(0.75f);
private static final FSkinColor FORE_COLOR = FSkinColor.get(Colors.CLR_TEXT);
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
ThreadUtil.invokeInGameThread(new Runnable() {
@Override
public void run() {
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
runnable.run();
loader.hide();
loader.finishedloading(); //setLoadingaMatch to false
}
});
}
});
ThreadUtil.invokeInGameThread(() -> FThreads.invokeInEdtLater(() -> {
runnable.run();
loader.hide();
loader.finishedloading(); //setLoadingaMatch to false
}));
}
public static void runBackgroundTask(String caption0, final Runnable task) {
final LoadingOverlay loader = new LoadingOverlay(caption0);
final LoadingOverlay loader = new LoadingOverlay(caption0, true);
loader.show();
FThreads.invokeInBackgroundThread(new Runnable() {
@Override
public void run() {
task.run();
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
loader.hide();
}
});
}
FThreads.invokeInBackgroundThread(() -> {
task.run();
FThreads.invokeInEdtLater(() -> loader.hide());
});
}
@@ -63,6 +49,7 @@ public class LoadingOverlay extends FOverlay {
public LoadingOverlay(String caption0) {
caption = caption0;
textMode = false;
}
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.setSelectedItem(2);
cbPlayerCount.setChangedHandler(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
int numPlayers = getNumPlayers();
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();
cbPlayerCount.setChangedHandler(event -> {
int numPlayers = getNumPlayers();
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();
});
initLobby(lobby0);
@@ -139,12 +136,7 @@ public abstract class LobbyScreen extends LaunchScreen implements ILobbyView {
cbGamesInMatch.addItem("3");
cbGamesInMatch.addItem("5");
cbGamesInMatch.setSelectedItem(FModel.getPreferences().getPref((FPref.UI_MATCHES_PER_GAME)));
cbGamesInMatch.setChangedHandler(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
FModel.getPreferences().setPref(FPref.UI_MATCHES_PER_GAME, cbGamesInMatch.getSelectedItem());
}
});
cbGamesInMatch.setChangedHandler(event -> FModel.getPreferences().setPref(FPref.UI_MATCHES_PER_GAME, cbGamesInMatch.getSelectedItem()));
add(lblVariants);
add(cbVariants);
@@ -161,31 +153,28 @@ public abstract class LobbyScreen extends LaunchScreen implements ILobbyView {
cbVariants.addItem(GameType.Archenemy);
cbVariants.addItem(GameType.ArchenemyRumble);
cbVariants.addItem(Forge.getLocalizer().getMessage("lblMore"));
cbVariants.setChangedHandler(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
if (cbVariants.getSelectedIndex() <= 0) {
lobby.clearVariants();
updateLayoutForVariants();
Set<GameType> gameTypes = new HashSet<>();
FModel.getPreferences().setGameType(FPref.UI_APPLIED_VARIANTS, gameTypes);
FModel.getPreferences().save();
}
else if (cbVariants.getSelectedIndex() == cbVariants.getItemCount() - 1) {
Forge.openScreen(new MultiVariantSelect());
updateVariantSelection();
}
else {
lobby.clearVariants();
lobby.applyVariant((GameType)cbVariants.getSelectedItem());
updateLayoutForVariants();
Set<GameType> gameTypes = new HashSet<>();
for (GameType variant: lobby.getAppliedVariants()) {
gameTypes.add(variant);
}
FModel.getPreferences().setGameType(FPref.UI_APPLIED_VARIANTS, gameTypes);
FModel.getPreferences().save();
cbVariants.setChangedHandler(event -> {
if (cbVariants.getSelectedIndex() <= 0) {
lobby.clearVariants();
updateLayoutForVariants();
Set<GameType> gameTypes = new HashSet<>();
FModel.getPreferences().setGameType(FPref.UI_APPLIED_VARIANTS, gameTypes);
FModel.getPreferences().save();
}
else if (cbVariants.getSelectedIndex() == cbVariants.getItemCount() - 1) {
Forge.openScreen(new MultiVariantSelect());
updateVariantSelection();
}
else {
lobby.clearVariants();
lobby.applyVariant((GameType)cbVariants.getSelectedItem());
updateLayoutForVariants();
Set<GameType> gameTypes = new HashSet<>();
for (GameType variant: lobby.getAppliedVariants()) {
gameTypes.add(variant);
}
FModel.getPreferences().setGameType(FPref.UI_APPLIED_VARIANTS, gameTypes);
FModel.getPreferences().save();
}
});
@@ -195,40 +184,34 @@ public abstract class LobbyScreen extends LaunchScreen implements ILobbyView {
updatePlayersFromPrefs();
FThreads.invokeInBackgroundThread(new Runnable() {
@Override
public void run() {
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);
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);
try {
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);
}
} catch (Exception e) {}
/*playerPanels.get(4).initialize(FPref.CONSTRUCTED_P5_DECK_STATE, DeckType.COLOR_DECK);
playerPanels.get(5).initialize(FPref.CONSTRUCTED_P6_DECK_STATE, DeckType.COLOR_DECK);
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.invokeInBackgroundThread(() -> {
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);
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);
try {
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);
}
} catch (Exception e) {}
/*playerPanels.get(4).initialize(FPref.CONSTRUCTED_P5_DECK_STATE, DeckType.COLOR_DECK);
playerPanels.get(5).initialize(FPref.CONSTRUCTED_P6_DECK_STATE, DeckType.COLOR_DECK);
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() {
@Override
public void run() {
btnStart.setEnabled(lobby.hasControl());
FThreads.invokeInEdtLater(() -> {
btnStart.setEnabled(lobby.hasControl());
Set<GameType> gameTypes = FModel.getPreferences().getGameType(FPref.UI_APPLIED_VARIANTS);
if (!gameTypes.isEmpty()) {
for (GameType gameType : gameTypes) {
lobby.applyVariant(gameType);
}
updateVariantSelection();
updateLayoutForVariants();
}
Set<GameType> gameTypes = FModel.getPreferences().getGameType(FPref.UI_APPLIED_VARIANTS);
if (!gameTypes.isEmpty()) {
for (GameType gameType : gameTypes) {
lobby.applyVariant(gameType);
}
});
}
updateVariantSelection();
updateLayoutForVariants();
}
});
});
lblPlayers.setEnabled(true);
@@ -351,20 +334,13 @@ public abstract class LobbyScreen extends LaunchScreen implements ILobbyView {
updateName(0, GamePlayerUtil.getGuiPlayer().getName());
}
}
FThreads.invokeInBackgroundThread(new Runnable() { //must call startGame in background thread in case there are alerts
@Override
public void run() {
final Runnable startGame = lobby.startGame();
if (startGame != null) {
//set this so we cant get any multi/rapid tap on start button
Forge.setLoadingaMatch(true);
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), startGame);
}
});
}
//must call startGame in background thread in case there are alerts
FThreads.invokeInBackgroundThread(() -> {
final Runnable startGame = lobby.startGame();
if (startGame != null) {
//set this so we cant get any multi/rapid tap on start button
Forge.setLoadingaMatch(true);
FThreads.invokeInEdtLater(() -> LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), true, 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());
btnNewGauntlet.setFont(FSkinFont.get(16));
btnNewGauntlet.setCommand(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
NewGameScreen.Gauntlet.open();
}
});
btnNewGauntlet.setCommand(event -> NewGameScreen.Gauntlet.open());
btnRenameGauntlet.setFont(btnNewGauntlet.getFont());
btnRenameGauntlet.setCommand(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
renameGauntlet(lstGauntlets.getSelectedGauntlet());
}
});
btnRenameGauntlet.setCommand(event -> renameGauntlet(lstGauntlets.getSelectedGauntlet()));
btnDeleteGauntlet.setFont(btnNewGauntlet.getFont());
btnDeleteGauntlet.setCommand(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
deleteGauntlet(lstGauntlets.getSelectedGauntlet());
}
});
btnDeleteGauntlet.setCommand(event -> deleteGauntlet(lstGauntlets.getSelectedGauntlet()));
}
public void onActivate() {
@@ -136,81 +121,69 @@ public class LoadGauntletScreen extends LaunchScreen {
return;
}
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), new Runnable() {
@Override
public void run() {
final GauntletData gauntlet = FModel.getGauntletData();
List<RegisteredPlayer> players = new ArrayList<>();
RegisteredPlayer humanPlayer = new RegisteredPlayer(gauntlet.getUserDeck()).setPlayer(GamePlayerUtil.getGuiPlayer());
players.add(humanPlayer);
players.add(new RegisteredPlayer(gauntlet.getDecks().get(gauntlet.getCompleted())).setPlayer(GamePlayerUtil.createAiPlayer()));
gauntlet.startRound(players, humanPlayer);
}
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), true, () -> {
final GauntletData gauntlet1 = FModel.getGauntletData();
List<RegisteredPlayer> players = new ArrayList<>();
RegisteredPlayer humanPlayer = new RegisteredPlayer(gauntlet1.getUserDeck()).setPlayer(GamePlayerUtil.getGuiPlayer());
players.add(humanPlayer);
players.add(new RegisteredPlayer(gauntlet1.getDecks().get(gauntlet1.getCompleted())).setPlayer(GamePlayerUtil.createAiPlayer()));
gauntlet1.startRound(players, humanPlayer);
});
}
private void renameGauntlet(final GauntletData gauntlet) {
if (gauntlet == null) { return; }
ThreadUtil.invokeInGameThread(new Runnable() {
@Override
public void run() {
String gauntletName;
String oldGauntletName = gauntlet.getName();
while (true) {
gauntletName = SOptionPane.showInputDialog(Forge.getLocalizer().getMessage("lblEnterNewGauntletGameName"), Forge.getLocalizer().getMessage("lblRenameGauntlet"), null, oldGauntletName);
if (gauntletName == null) { return; }
ThreadUtil.invokeInGameThread(() -> {
String gauntletName;
String oldGauntletName = gauntlet.getName();
while (true) {
gauntletName = SOptionPane.showInputDialog(Forge.getLocalizer().getMessage("lblEnterNewGauntletGameName"), Forge.getLocalizer().getMessage("lblRenameGauntlet"), null, oldGauntletName);
if (gauntletName == null) { return; }
gauntletName = QuestUtil.cleanString(gauntletName);
if (gauntletName.equals(oldGauntletName)) { return; } //quit if chose same name
gauntletName = QuestUtil.cleanString(gauntletName);
if (gauntletName.equals(oldGauntletName)) { return; } //quit if chose same name
if (gauntletName.isEmpty()) {
SOptionPane.showMessageDialog(Forge.getLocalizer().getMessage("lblPleaseSpecifyGauntletName"));
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;
if (gauntletName.isEmpty()) {
SOptionPane.showMessageDialog(Forge.getLocalizer().getMessage("lblPleaseSpecifyGauntletName"));
continue;
}
final String newGauntletName = gauntletName;
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
gauntlet.rename(newGauntletName);
lstGauntlets.refresh();
lstGauntlets.setSelectedGauntlet(gauntlet);
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(() -> {
gauntlet.rename(newGauntletName);
lstGauntlets.refresh();
lstGauntlets.setSelectedGauntlet(gauntlet);
});
});
}
private void deleteGauntlet(final GauntletData gauntlet) {
if (gauntlet == null) { return; }
ThreadUtil.invokeInGameThread(new Runnable() {
@Override
public void run() {
if (!SOptionPane.showConfirmDialog(
Forge.getLocalizer().getMessage("lblAreYouSuerDeleteGauntlet", gauntlet.getName()),
Forge.getLocalizer().getMessage("lblDeleteGauntlet"), Forge.getLocalizer().getMessage("lblDelete"), Forge.getLocalizer().getMessage("lblCancel"))) {
return;
}
GauntletIO.getGauntletFile(gauntlet).delete();
lstGauntlets.removeGauntlet(gauntlet);
ThreadUtil.invokeInGameThread(() -> {
if (!SOptionPane.showConfirmDialog(
Forge.getLocalizer().getMessage("lblAreYouSuerDeleteGauntlet", gauntlet.getName()),
Forge.getLocalizer().getMessage("lblDeleteGauntlet"), Forge.getLocalizer().getMessage("lblDelete"), Forge.getLocalizer().getMessage("lblCancel"))) {
return;
}
GauntletIO.getGauntletFile(gauntlet).delete();
lstGauntlets.removeGauntlet(gauntlet);
});
}
@@ -299,12 +272,7 @@ public class LoadGauntletScreen extends LaunchScreen {
public void refresh() {
List<GauntletData> sorted = new ArrayList<>();
sorted.addAll(gauntlets);
Collections.sort(sorted, new Comparator<GauntletData>() {
@Override
public int compare(final GauntletData x, final GauntletData y) {
return x.getName().toLowerCase().compareTo(y.getName().toLowerCase());
}
});
Collections.sort(sorted, (x, y) -> x.getName().toLowerCase().compareTo(y.getName().toLowerCase()));
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
public void run(final Puzzle chosen) {
if (chosen != null) {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingThePuzzle"), new Runnable() {
@Override
public void run() {
// Load selected puzzle
final HostedMatch hostedMatch = GuiBase.getInterface().hostMatch();
hostedMatch.setStartGameHook(new Runnable() {
@Override
public final void run() {
chosen.applyToGame(hostedMatch.getGame());
}
});
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingThePuzzle"), true, () -> {
// Load selected puzzle
final HostedMatch hostedMatch = GuiBase.getInterface().hostMatch();
hostedMatch.setStartGameHook(() -> chosen.applyToGame(hostedMatch.getGame()));
hostedMatch.setEndGameHook((new Runnable() {
@Override
public void run() {
chosen.savePuzzleSolve(hostedMatch.getGame().getOutcome().isWinner(GamePlayerUtil.getGuiPlayer()));
}
}));
hostedMatch.setEndGameHook((() -> chosen.savePuzzleSolve(hostedMatch.getGame().getOutcome().isWinner(GamePlayerUtil.getGuiPlayer()))));
final List<RegisteredPlayer> players = new ArrayList<>();
final RegisteredPlayer human = new RegisteredPlayer(new Deck()).setPlayer(GamePlayerUtil.getGuiPlayer());
human.setStartingHand(0);
players.add(human);
final List<RegisteredPlayer> players = new ArrayList<>();
final RegisteredPlayer human = new RegisteredPlayer(new Deck()).setPlayer(GamePlayerUtil.getGuiPlayer());
human.setStartingHand(0);
players.add(human);
final RegisteredPlayer ai = new RegisteredPlayer(new Deck()).setPlayer(GamePlayerUtil.createAiPlayer());
ai.setStartingHand(0);
players.add(ai);
final RegisteredPlayer ai = new RegisteredPlayer(new Deck()).setPlayer(GamePlayerUtil.createAiPlayer());
ai.setStartingHand(0);
players.add(ai);
GameRules rules = new GameRules(GameType.Puzzle);
rules.setGamesPerMatch(1);
hostedMatch.startMatch(rules, null, players, human, GuiBase.getInterface().getNewGuiGame());
FOptionPane.showMessageDialog(chosen.getGoalDescription(), chosen.getName());
}
GameRules rules = new GameRules(GameType.Puzzle);
rules.setGamesPerMatch(1);
hostedMatch.startMatch(rules, null, players, human, GuiBase.getInterface().getNewGuiGame());
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"));
lstDecks.setup(ItemManagerConfig.DRAFT_DECKS);
lstDecks.setItemActivateHandler(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
editSelectedDeck();
}
});
lstDecks.setItemActivateHandler(event -> editSelectedDeck());
}
@Override
@@ -96,80 +91,63 @@ public class LoadDraftScreen extends LaunchScreen {
@Override
protected void startMatch() {
FThreads.invokeInBackgroundThread(new Runnable() {
@Override
public void run() {
final DeckProxy humanDeck = lstDecks.getSelectedItem();
if (humanDeck == null) {
FOptionPane.showErrorDialog(Forge.getLocalizer().getMessage("lblYouMustSelectExistingDeck"), Forge.getLocalizer().getMessage("lblNoDeck"));
FThreads.invokeInBackgroundThread(() -> {
final DeckProxy humanDeck = lstDecks.getSelectedItem();
if (humanDeck == null) {
FOptionPane.showErrorDialog(Forge.getLocalizer().getMessage("lblYouMustSelectExistingDeck"), Forge.getLocalizer().getMessage("lblNoDeck"));
return;
}
// 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;
}
// 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) {
FThreads.invokeInEdtLater(() -> {
if (!checkDeckLegality(humanDeck)) {
return;
}
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
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());
}
});
}
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), true, () -> {
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(() -> 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"));
lstDecks.setup(ItemManagerConfig.SEALED_DECKS);
lstDecks.setItemActivateHandler(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
editSelectedDeck();
}
});
lstDecks.setItemActivateHandler(event -> editSelectedDeck());
}
@Override
@@ -95,74 +90,59 @@ public class LoadSealedScreen extends LaunchScreen {
@Override
protected void startMatch() {
FThreads.invokeInBackgroundThread(new Runnable() {
@Override
public void run() {
final DeckProxy humanDeck = lstDecks.getSelectedItem();
if (humanDeck == null) {
FOptionPane.showErrorDialog(Forge.getLocalizer().getMessage("lblYouMustSelectExistingSealedPool"), Forge.getLocalizer().getMessage("lblNoDeck"));
return;
}
FThreads.invokeInBackgroundThread(() -> {
final DeckProxy humanDeck = lstDecks.getSelectedItem();
if (humanDeck == null) {
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) {
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
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
if (gauntlet) {
FThreads.invokeInEdtLater(() -> {
if (!checkDeckLegality(humanDeck)) {
return;
}
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!");
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), true, () -> {
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());
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() {
@Override
public void run() {
if (!checkDeckLegality(humanDeck)) {
return;
}
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());
}
});
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), true, () -> {
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());
});
}
});
}
});
}

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

@@ -41,27 +41,15 @@ public class NewDraftScreen extends LaunchScreen {
@Override
protected void startMatch() {
ThreadUtil.invokeInGameThread(new Runnable() { //must run in game thread to prevent blocking UI thread
@Override
public void run() {
final LimitedPoolType poolType = SGuiChoose.oneOrNone(Forge.getLocalizer().getMessage("lblChooseDraftFormat"), LimitedPoolType.values());
if (poolType == null) { return; }
//must run in game thread to prevent blocking UI thread
ThreadUtil.invokeInGameThread(() -> {
final LimitedPoolType poolType = SGuiChoose.oneOrNone(Forge.getLocalizer().getMessage("lblChooseDraftFormat"), LimitedPoolType.values());
if (poolType == null) { return; }
final BoosterDraft draft = BoosterDraft.createDraft(poolType);
if (draft == null) { return; }
final BoosterDraft draft = BoosterDraft.createDraft(poolType);
if (draft == null) { return; }
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewDraft"), new Runnable() {
@Override
public void run() {
Forge.openScreen(new DraftingProcessScreen(draft, EditorType.Draft, null));
}
});
}
});
}
FThreads.invokeInEdtLater(() -> LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewDraft"), true, () -> 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();
Forge.back();
if (msg.length() > 0) {
FThreads.invokeInBackgroundThread(new Runnable() {
@Override
public void run() {
final boolean callBackAlwaysTrue = SOptionPane.showOptionDialog(msg, Forge.getLocalizer().getMessage("lblError"), FSkinProp.ICO_WARNING, ImmutableList.of(Forge.getLocalizer().getMessage("lblOk")), 1) == 0;
if (callBackAlwaysTrue) { //to activate online menu popup when player press play online
GuiBase.setInterrupted(false);
FThreads.invokeInBackgroundThread(() -> {
final boolean callBackAlwaysTrue = SOptionPane.showOptionDialog(msg, Forge.getLocalizer().getMessage("lblError"), FSkinProp.ICO_WARNING, ImmutableList.of(Forge.getLocalizer().getMessage("lblOk")), 1) == 0;
if (callBackAlwaysTrue) { //to activate online menu popup when player press play online
GuiBase.setInterrupted(false);
if(FServerManager.getInstance() != null)
FServerManager.getInstance().stopServer();
if(getfGameClient() != null)
closeClient();
}
if(FServerManager.getInstance() != null)
FServerManager.getInstance().stopServer();
if(getfGameClient() != null)
closeClient();
}
});
}
@@ -93,51 +90,37 @@ public class OnlineLobbyScreen extends LobbyScreen implements IOnlineLobby {
if (getGameLobby() == null) {
setGameLobby(getLobby());
//prompt to connect to server when offline lobby activated
FThreads.invokeInBackgroundThread(new Runnable() {
@Override
public void run() {
final String url = NetConnectUtil.getServerUrl();
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
if (url == null) {
closeConn(""); //go back to previous screen if user cancels connection
FThreads.invokeInBackgroundThread(() -> {
final String url = NetConnectUtil.getServerUrl();
FThreads.invokeInEdtLater(() -> {
if (url == null) {
closeConn(""); //go back to previous screen if user cancels connection
return;
}
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;
}
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 ConquestPrefsScreen prefsScreen = new ConquestPrefsScreen();
private static final FMenuItem multiverseItem = new FMenuItem(Forge.getLocalizer().getMessage("lblTheMultiverse"), FSkinImage.MULTIVERSE, new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
setCurrentScreen(multiverseScreen);
}
});
private static final FMenuItem aetherItem = new FMenuItem(Forge.getLocalizer().getMessage("lblTheAether"), FSkinImage.AETHER_SHARD, new FEventHandler() {
@Override
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 final FMenuItem multiverseItem = new FMenuItem(Forge.getLocalizer().getMessage("lblTheMultiverse"), FSkinImage.MULTIVERSE, event -> setCurrentScreen(multiverseScreen));
private static final FMenuItem aetherItem = new FMenuItem(Forge.getLocalizer().getMessage("lblTheAether"), FSkinImage.AETHER_SHARD, event -> setCurrentScreen(aetherScreen));
private static final FMenuItem commandersItem = new FMenuItem(Forge.getLocalizer().getMessage("lblCommanders"), FSkinImage.COMMANDER, event -> setCurrentScreen(commandersScreen));
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 planeswalkItem = new FMenuItem(Forge.getLocalizer().getMessage("lblPlaneswalk"), FSkinImage.PW_BADGE_COMMON, event -> setCurrentScreen(planeswalkScreen));
private static final FMenuItem prefsItem = new FMenuItem(Forge.getLocalizer().getMessage("Preferences"), Forge.hdbuttons ? FSkinImage.HDPREFERENCE : FSkinImage.SETTINGS, event -> setCurrentScreen(prefsScreen));
private static void setCurrentScreen(FScreen screen0) {
//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 {
//the first time planarconquest mode is launched, add button for it if in Landscape mode
if (Forge.isLandscapeMode()) {
HomeScreen.instance.addButtonForMode("-"+Forge.getLocalizer().getMessage("lblPlanarConquest"), new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
launchPlanarConquest(LaunchReason.StartPlanarConquest);
}
});
HomeScreen.instance.addButtonForMode("-"+Forge.getLocalizer().getMessage("lblPlanarConquest"), event -> launchPlanarConquest(LaunchReason.StartPlanarConquest));
}
}
@@ -108,20 +63,16 @@ public class ConquestMenu extends FPopupMenu {
public static void launchPlanarConquest(final LaunchReason reason) {
Forge.lastButtonIndex = 7;
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingCurrentConquest"), new Runnable() {
@Override
@SuppressWarnings("unchecked")
public void run() {
((DeckController<Deck>)EditorType.PlanarConquest.getController()).setRootFolder(FModel.getConquest().getDecks());
if (reason == LaunchReason.StartPlanarConquest) {
Forge.openScreen(multiverseScreen);
}
else {
multiverseScreen.update();
Forge.openScreen(multiverseScreen);
if (reason == LaunchReason.NewConquest) {
LoadGameScreen.PlanarConquest.setAsBackScreen(true);
}
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingCurrentConquest"), true, () -> {
((DeckController<Deck>)EditorType.PlanarConquest.getController()).setRootFolder(FModel.getConquest().getDecks());
if (reason == LaunchReason.StartPlanarConquest) {
Forge.openScreen(multiverseScreen);
}
else {
multiverseScreen.update();
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() {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblStartingBattle"), new Runnable() {
@Override
public void run() {
ConquestLocation loc = model.getCurrentLocation();
activeBattle = loc.getEvent().createBattle(loc, 0);
FModel.getConquest().startBattle(activeBattle);
}
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblStartingBattle"), true, () -> {
ConquestLocation loc = model.getCurrentLocation();
activeBattle = loc.getEvent().createBattle(loc, 0);
FModel.getConquest().startBattle(activeBattle);
});
}
private void launchChaosBattle() {
FThreads.invokeInEdtNowOrLater(new Runnable() {
@Override
public void run() {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblChaosApproaching"), new Runnable() {
@Override
public void run() {
activeBattle = new ConquestChaosBattle();
FModel.getConquest().startBattle(activeBattle);
}
});
}
});
FThreads.invokeInEdtNowOrLater(() -> LoadingOverlay.show(Forge.getLocalizer().getMessage("lblChaosApproaching"), true, () -> {
activeBattle = new ConquestChaosBattle();
FModel.getConquest().startBattle(activeBattle);
}));
}
@Override
@@ -678,12 +667,7 @@ public class ConquestMultiverseScreen extends FScreen {
private BattleBar() {
playerAvatar = add(new AvatarDisplay(false));
opponentAvatar = add(new AvatarDisplay(true));
btnBattle = add(new FButton(Forge.getLocalizer().getMessage("lblBattle"), new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
launchEvent();
}
}));
btnBattle = add(new FButton(Forge.getLocalizer().getMessage("lblBattle"), event -> launchEvent()));
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
protected void finish() {
//create new quest in game thread so option panes can wait for input
ThreadUtil.invokeInGameThread(new Runnable() {
@Override
public void run() {
newConquest();
}
});
ThreadUtil.invokeInGameThread(() -> newConquest());
}
private void newConquest() {
@@ -52,26 +47,18 @@ public class NewConquestScreen extends MultiStepWizardScreen<NewConquestScreenMo
}
private void startNewConquest(final String conquestName) {
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblStartingNewConquest"), new Runnable() {
@Override
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();
FThreads.invokeInEdtLater(() -> LoadingOverlay.show(Forge.getLocalizer().getMessage("lblStartingNewConquest"), true, () -> {
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.
FModel.getConquestPreferences().setPref(CQPref.CURRENT_CONQUEST, conquestName);
FModel.getConquestPreferences().save();
// Save in preferences.
FModel.getConquestPreferences().setPref(CQPref.CURRENT_CONQUEST, conquestName);
FModel.getConquestPreferences().save();
ConquestMenu.launchPlanarConquest(LaunchReason.NewConquest);
}
});
}
});
ConquestMenu.launchPlanarConquest(LaunchReason.NewConquest);
}));
}
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 FLabel btnEmbark = add(new FLabel.ButtonBuilder()
.font(FSkinFont.get(22)).text(Forge.getLocalizer().getMessage("lblEmbark")).icon(FSkinImage.QUEST_ZEP).command(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
//create new quest in game thread so option panes can wait for input
ThreadUtil.invokeInGameThread(new Runnable() {
@Override
public void run() {
newQuest();
}
});
}
.font(FSkinFont.get(22)).text(Forge.getLocalizer().getMessage("lblEmbark")).icon(FSkinImage.QUEST_ZEP).command(event -> {
//create new quest in game thread so option panes can wait for input
ThreadUtil.invokeInGameThread(() -> newQuest());
}).build());
public NewQuestScreen() {
@@ -209,24 +201,18 @@ public class NewQuestScreen extends FScreen {
cbxStartingPool.addItem(StartingPoolType.DraftDeck);
cbxStartingPool.addItem(StartingPoolType.SealedDeck);
cbxStartingPool.addItem(StartingPoolType.Cube);
cbxStartingPool.setChangedHandler(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
updateStartingPoolOptions();
scroller.revalidate();
}
cbxStartingPool.setChangedHandler(event -> {
updateStartingPoolOptions();
scroller.revalidate();
});
cbxPrizedCards.addItem(Forge.getLocalizer().getMessage("lblSameAsStartingPool"));
cbxPrizedCards.addItem(StartingPoolType.Complete);
cbxPrizedCards.addItem(StartingPoolType.Sanctioned);
cbxPrizedCards.addItem(StartingPoolType.Casual);
cbxPrizedCards.setChangedHandler(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
updatePrizeOptions();
scroller.revalidate();
}
cbxPrizedCards.setChangedHandler(event -> {
updatePrizeOptions();
scroller.revalidate();
});
for (GameFormat gf : FModel.getFormats().getSanctionedList()) {
@@ -243,18 +229,15 @@ public class NewQuestScreen extends FScreen {
numberOfBoostersField.setEnabled(false);
@SuppressWarnings("serial")
UiCommand colorBoxEnabler = new UiCommand() {
@Override
public void run() {
cbBlack.setEnabled(radBalanced.isSelected());
cbBlue.setEnabled(radBalanced.isSelected());
cbGreen.setEnabled(radBalanced.isSelected());
cbRed.setEnabled(radBalanced.isSelected());
cbWhite.setEnabled(radBalanced.isSelected());
cbColorless.setEnabled(radBalanced.isSelected());
cbIncludeArtifacts.setEnabled(!radSurpriseMe.isSelected());
numberOfBoostersField.setEnabled(radBoosters.isSelected());
}
UiCommand colorBoxEnabler = () -> {
cbBlack.setEnabled(radBalanced.isSelected());
cbBlue.setEnabled(radBalanced.isSelected());
cbGreen.setEnabled(radBalanced.isSelected());
cbRed.setEnabled(radBalanced.isSelected());
cbWhite.setEnabled(radBalanced.isSelected());
cbColorless.setEnabled(radBalanced.isSelected());
cbIncludeArtifacts.setEnabled(!radSurpriseMe.isSelected());
numberOfBoostersField.setEnabled(radBoosters.isSelected());
};
radBalanced.setCommand(colorBoxEnabler);
@@ -268,12 +251,7 @@ public class NewQuestScreen extends FScreen {
// Default to 'Main world'
cbxStartingWorld.setSelectedItem(FModel.getWorlds().get("Main world"));
cbxStartingWorld.setChangedHandler(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
updateEnabledFormats();
}
});
cbxStartingWorld.setChangedHandler(event -> updateEnabledFormats());
updateStartingPoolOptions();
updatePrizeOptions();
@@ -298,59 +276,44 @@ public class NewQuestScreen extends FScreen {
unselectableSets.add("ARC");
unselectableSets.add("PC2");
btnSelectFormat.setCommand(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
ArchivedFormatSelect archivedFormatSelect = new ArchivedFormatSelect();
archivedFormatSelect.setOnCloseCallBack(new Runnable() {
@Override
public void run() {
customFormatCodes.clear();
btnSelectFormat.setText(archivedFormatSelect.getSelectedFormat().getName());
List<String> setsToAdd = archivedFormatSelect.getSelectedFormat().getAllowedSetCodes();
for (String setName:setsToAdd){
if(!unselectableSets.contains(setName)){
customFormatCodes.add(setName);
}
}
btnSelectFormat.setCommand(event -> {
ArchivedFormatSelect archivedFormatSelect = new ArchivedFormatSelect();
archivedFormatSelect.setOnCloseCallBack(() -> {
customFormatCodes.clear();
btnSelectFormat.setText(archivedFormatSelect.getSelectedFormat().getName());
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() {
@Override
public void handleEvent(FEvent e) {
ArchivedFormatSelect archivedFormatSelect = new ArchivedFormatSelect();
archivedFormatSelect.setOnCloseCallBack(new Runnable() {
@Override
public void run() {
customPrizeFormatCodes.clear();
btnPrizeSelectFormat.setText(archivedFormatSelect.getSelectedFormat().getName());
List<String> setsToAdd = archivedFormatSelect.getSelectedFormat().getAllowedSetCodes();
for (String setName:setsToAdd){
if(!unselectableSets.contains(setName)){
customPrizeFormatCodes.add(setName);
}
}
btnPrizeSelectFormat.setCommand(event -> {
ArchivedFormatSelect archivedFormatSelect = new ArchivedFormatSelect();
archivedFormatSelect.setOnCloseCallBack(() -> {
customPrizeFormatCodes.clear();
btnPrizeSelectFormat.setText(archivedFormatSelect.getSelectedFormat().getName());
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
cbFantasy.setSelected(true);
cbFantasy.setEnabled(true);
cbCommander.setSelected(false);
cbCommander.setCommand(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
if (!isCommander())
return;
cbxStartingWorld.setSelectedItem(FModel.getWorlds().get("Random Commander"));
}
cbCommander.setCommand(event -> {
if (!isCommander())
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) {
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblCreatingNewQuest"), new Runnable() {
@Override
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();
FThreads.invokeInEdtLater(() -> LoadingOverlay.show(Forge.getLocalizer().getMessage("lblCreatingNewQuest"), true, () -> {
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.save();
qc.newGame(questName, getSelectedDifficulty(), mode, fmtPrizes, isUnlockSetsAllowed(), dckStartPool, fmtStartPool, getStartingWorldName(), userPrefs, dcr);
qc.save();
// Save in preferences.
FModel.getQuestPreferences().setPref(QPref.CURRENT_QUEST, questName + ".dat");
FModel.getQuestPreferences().save();
// Save in preferences.
FModel.getQuestPreferences().setPref(QPref.CURRENT_QUEST, questName + ".dat");
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() {
super();
pnlDuels.setActivateHandler(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
startMatch();
}
});
pnlDuels.setActivateHandler(event -> startMatch());
}
@Override
@@ -74,23 +69,15 @@ public class QuestDuelsScreen extends QuestLaunchScreen {
}
private void generateDuels() {
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingCurrentQuest"), new Runnable() {
@Override
public void run() {
pnlDuels.clear();
List<QuestEventDuel> duels = FModel.getQuest().getDuelsManager().generateDuels();
if (duels != null) {
for (QuestEventDuel duel : duels) {
pnlDuels.add(new QuestEventPanel(duel, pnlDuels));
}
}
pnlDuels.revalidate();
}
});
FThreads.invokeInEdtLater(() -> LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingCurrentQuest"), true, () -> {
pnlDuels.clear();
List<QuestEventDuel> duels = FModel.getQuest().getDuelsManager().generateDuels();
if (duels != null) {
for (QuestEventDuel duel : duels) {
pnlDuels.add(new QuestEventPanel(duel, pnlDuels));
}
}
});
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
protected void startMatch() {
FThreads.invokeInBackgroundThread(new Runnable() {
@Override
public void run() {
if (QuestUtil.canStartGame()) {
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), new Runnable() {
@Override
public void run() {
QuestUtil.finishStartingGame();
}
});
}
});
return;
}
FThreads.invokeInBackgroundThread(() -> {
if (QuestUtil.canStartGame()) {
FThreads.invokeInEdtLater(() -> LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingNewGame"), true, () -> 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 QuestTournamentsScreen tournamentsScreen = new QuestTournamentsScreen();
private static final FMenuItem duelsItem = new FMenuItem(Forge.getLocalizer().getMessage("lblDuels"), FSkinImage.QUEST_BIG_SWORD, new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
setCurrentScreen(duelsScreen);
}
private static final FMenuItem duelsItem = new FMenuItem(Forge.getLocalizer().getMessage("lblDuels"), FSkinImage.QUEST_BIG_SWORD, event -> setCurrentScreen(duelsScreen));
private static final FMenuItem challengesItem = new FMenuItem(Forge.getLocalizer().getMessage("lblChallenges"), FSkinImage.QUEST_HEART, event -> setCurrentScreen(challengesScreen));
private static final FMenuItem tournamentsItem = new FMenuItem(Forge.getLocalizer().getMessage("lblTournaments"), FSkinImage.QUEST_BIG_SHIELD, event -> setCurrentScreen(tournamentsScreen));
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() {
@Override
public void handleEvent(FEvent e) {
setCurrentScreen(challengesScreen);
}
});
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 travelItem = new FMenuItem(Forge.getLocalizer().getMessage("btnTravel"), FSkinImage.QUEST_MAP, event -> {
//invoke in background thread so prompts can work
ThreadUtil.invokeInGameThread(() -> {
QuestUtil.travelWorld();
FThreads.invokeInEdtLater(() -> updateCurrentQuestScreen());
});
});
private static final FMenuItem prefsItem = new FMenuItem(Forge.getLocalizer().getMessage("Preferences"), Forge.hdbuttons ? FSkinImage.HDPREFERENCE : FSkinImage.SETTINGS, event -> setCurrentScreen(prefsScreen));
static {
statsScreen.addTournamentResultsLabels(tournamentsScreen);
@@ -159,12 +99,7 @@ public class QuestMenu extends FPopupMenu implements IVQuestStats {
static {
//the first time quest mode is launched, add button for it if in Landscape mode
if (Forge.isLandscapeMode()) {
HomeScreen.instance.addButtonForMode("-"+Forge.getLocalizer().getMessage("lblQuestMode"), new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
launchQuestMode(LaunchReason.StartQuestMode, HomeScreen.instance.getQuestCommanderMode());
}
});
HomeScreen.instance.addButtonForMode("-"+Forge.getLocalizer().getMessage("lblQuestMode"), event -> 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 File data = new File(dirQuests.getPath(), questname);
if (data.exists()) {
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingCurrentQuest"), new Runnable() {
@Override
@SuppressWarnings("unchecked")
public void run() {
try {
FModel.getQuest().load(QuestDataIO.loadData(data));
} catch (IOException e) {
System.err.println(String.format("Failed to load quest '%s'", questname));
// Failed to load last quest, don't continue with quest loading stuff
return;
}
LoadingOverlay.show(Forge.getLocalizer().getMessage("lblLoadingCurrentQuest"), true, () -> {
try {
FModel.getQuest().load(QuestDataIO.loadData(data));
} catch (IOException e) {
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<DeckGroup>)EditorType.QuestDraft.getController()).setRootFolder(FModel.getQuest().getDraftDecks());
if (reason == LaunchReason.StartQuestMode) {
if (QuestUtil.getCurrentDeck() == null) {
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
}
((DeckController<Deck>)EditorType.Quest.getController()).setRootFolder(FModel.getQuest().getMyDecks());
((DeckController<DeckGroup>)EditorType.QuestDraft.getController()).setRootFolder(FModel.getQuest().getDraftDecks());
if (reason == LaunchReason.StartQuestMode) {
if (QuestUtil.getCurrentDeck() == null) {
Forge.openScreen(decksScreen); //if quest doesn't have a deck specified, open decks screen by default
}
else {
duelsScreen.update();
challengesScreen.update();
tournamentsScreen.update();
decksScreen.refreshDecks();
Forge.openScreen(duelsScreen);
if (reason == LaunchReason.NewQuest) {
LoadGameScreen.QuestMode.setAsBackScreen(true);
}
Forge.openScreen(duelsScreen); //TODO: Consider opening most recent quest view
}
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;
}

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]);
btnBuySellMultiple.setVisible(false); //hide unless in multi-select mode
btnBuySellMultiple.setCommand(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
final SpellShopManager itemManager = ((SpellShopBasePage)getSelectedPage()).itemManager;
final ItemPool<InventoryItem> items = itemManager.getSelectedItemPool();
btnBuySellMultiple.setCommand(event -> {
final SpellShopManager itemManager = ((SpellShopBasePage)getSelectedPage()).itemManager;
final ItemPool<InventoryItem> items = itemManager.getSelectedItemPool();
if (items.isEmpty()) {
//toggle off multi-select mode if no items selected
itemManager.toggleMultiSelectMode(-1);
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();
}
});
}
});
if (items.isEmpty()) {
//toggle off multi-select mode if no items selected
itemManager.toggleMultiSelectMode(-1);
return;
}
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);
}
});
itemManager.setItemActivateHandler(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
}
itemManager.setItemActivateHandler(event -> {
});
itemManager.setContextMenuBuilder(new ContextMenuBuilder<InventoryItem>() {
@Override
public void buildMenu(final FDropDownMenu menu, final InventoryItem item) {
menu.addItem(new FMenuItem(getVerb(), getVerbIcon(), new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
activateSelectedItem();
}
}));
menu.addItem(new FMenuItem(getVerb(), getVerbIcon(), event -> activateSelectedItem()));
}
});
itemManager.setSelectionChangedHandler(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
if (itemManager.getMultiSelectMode()) {
parentScreen.updateBuySellButtonCaption();
}
itemManager.setSelectionChangedHandler(event -> {
if (itemManager.getMultiSelectMode()) {
parentScreen.updateBuySellButtonCaption();
}
});
add(lblCredits);
@@ -235,19 +213,11 @@ public class QuestSpellShopScreen extends TabPageScreen<QuestSpellShopScreen> {
if (result == null || result <= 0) { return; }
//invoke in background thread so other dialogs can be shown properly
FThreads.invokeInBackgroundThread(new Runnable() {
@Override
public void run() {
ItemPool<InventoryItem> items = new ItemPool<>(InventoryItem.class);
items.add(item, result);
activateItems(items);
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
parentScreen.updateCreditsLabel();
}
});
}
FThreads.invokeInBackgroundThread(() -> {
ItemPool<InventoryItem> items = new ItemPool<>(InventoryItem.class);
items.add(item, result);
activateItems(items);
FThreads.invokeInEdtLater(() -> parentScreen.updateCreditsLabel());
});
}
};
@@ -290,22 +260,14 @@ public class QuestSpellShopScreen extends TabPageScreen<QuestSpellShopScreen> {
@Override
protected void refresh() {
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
LoadingOverlay.show(Forge.getLocalizer().getInstance().getMessage("lblLoading"), new Runnable() {
@Override
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);
FThreads.invokeInEdtLater(() -> LoadingOverlay.show(Forge.getLocalizer().getInstance().getMessage("lblLoading"), true, () -> {
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
@@ -337,47 +299,25 @@ public class QuestSpellShopScreen extends TabPageScreen<QuestSpellShopScreen> {
private static class InventoryPage extends SpellShopBasePage {
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))
.command(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
//invoke in background thread so other dialogs can be shown properly
FThreads.invokeInBackgroundThread(new Runnable() {
@Override
public void run() {
.command(event -> {
//invoke in background thread so other dialogs can be shown properly
FThreads.invokeInBackgroundThread(() -> {
QuestSpellShop.sellExtras(parentScreen.spellShopPage.itemManager, itemManager);
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
parentScreen.updateCreditsLabel();
}
});
}
});
}
}).build());
FThreads.invokeInEdtLater(() -> parentScreen.updateCreditsLabel());
});
}).build());
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))
.command(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
//invoke in background thread so other dialogs can be shown properly
FThreads.invokeInBackgroundThread(new Runnable() {
@Override
public void run() {
if (!itemManager.getMultiSelectMode()) {
itemManager.toggleMultiSelectMode(0);
}
itemManager.selectAll();
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
parentScreen.updateCreditsLabel();
}
});
}
});
}
.command(event -> {
//invoke in background thread so other dialogs can be shown properly
FThreads.invokeInBackgroundThread(() -> {
if (!itemManager.getMultiSelectMode()) {
itemManager.toggleMultiSelectMode(0);
}
itemManager.selectAll();
FThreads.invokeInEdtLater(() -> parentScreen.updateCreditsLabel());
});
}).build());
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() {
super();
controller = new QuestTournamentController(this);
btnSpendToken.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.spendToken();
}
});
}
btnSpendToken.setCommand(event -> {
//must run in background thread to handle alerts
FThreads.invokeInBackgroundThread(() -> controller.spendToken());
});
btnEditDeck.setCommand(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
editDeck(true);
}
});
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();
}
});
}
btnEditDeck.setCommand(event -> editDeck(true));
btnLeaveTournament.setCommand(event -> {
//must run in background thread to handle alerts
FThreads.invokeInBackgroundThread(() -> controller.endTournamentAndAwardPrizes());
});
// TODO: is it possible to somehow reuse the original btnEditDeck/btnLeaveTournament
btnEditDeckInTourn.setCommand(new FEventHandler() {
@Override
public void handleEvent(FEvent e) {
editDeck(true);
}
});
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();
}
});
}
btnEditDeckInTourn.setCommand(event -> editDeck(true));
btnLeaveTournamentInTourn.setCommand(event -> {
//must run in background thread to handle alerts
FThreads.invokeInBackgroundThread(() -> controller.endTournamentAndAwardPrizes());
});
pnlPrepareDeck.add(btnEditDeck);
@@ -231,17 +200,7 @@ public class QuestTournamentsScreen extends QuestLaunchScreen implements IQuestT
@Override
public void startDraft(BoosterDraft draft) {
FThreads.invokeInEdtLater(new Runnable() {
@Override
public void run() {
LoadingOverlay.show("Loading Quest Tournament", new Runnable() {
@Override
public void run() {
Forge.openScreen(new DraftingProcessScreen(draft, EditorType.QuestDraft, controller));
}
});
}
});
FThreads.invokeInEdtLater(() -> LoadingOverlay.show("Loading Quest Tournament", true, () -> Forge.openScreen(new DraftingProcessScreen(draft, EditorType.QuestDraft, controller))));
}
private Deck getDeck() {
@@ -276,22 +235,20 @@ public class QuestTournamentsScreen extends QuestLaunchScreen implements IQuestT
return;
}
FThreads.invokeInBackgroundThread(new Runnable() { //must run in background thread to handle alerts
@Override
public void run() {
switch (mode) {
case SELECT_TOURNAMENT:
controller.startDraft();
break;
case PREPARE_DECK:
controller.startTournament();
break;
case TOURNAMENT_ACTIVE:
controller.startNextMatch();
break;
default:
break;
}
//must run in background thread to handle alerts
FThreads.invokeInBackgroundThread(() -> {
switch (mode) {
case SELECT_TOURNAMENT:
controller.startDraft();
break;
case PREPARE_DECK:
controller.startTournament();
break;
case TOURNAMENT_ACTIVE:
controller.startNextMatch();
break;
default:
break;
}
});
}