diff options
Diffstat (limited to 'src/com/sneed/pkrandom/newgui/NewRandomizerGUI.java')
-rw-r--r-- | src/com/sneed/pkrandom/newgui/NewRandomizerGUI.java | 3758 |
1 files changed, 3758 insertions, 0 deletions
diff --git a/src/com/sneed/pkrandom/newgui/NewRandomizerGUI.java b/src/com/sneed/pkrandom/newgui/NewRandomizerGUI.java new file mode 100644 index 0000000..7a8e8ca --- /dev/null +++ b/src/com/sneed/pkrandom/newgui/NewRandomizerGUI.java @@ -0,0 +1,3758 @@ +package com.sneed.pkrandom.newgui; + +/*----------------------------------------------------------------------------*/ +/*-- NewRandomizerGUI.java - the main GUI for the randomizer, containing --*/ +/*-- the various options available and such --*/ +/*-- --*/ +/*-- Part of "Universal Pokemon Randomizer ZX" by the UPR-ZX team --*/ +/*-- Originally part of "Universal Pokemon Randomizer" by sneed --*/ +/*-- Pokemon and any associated names and the like are --*/ +/*-- trademark and (C) Nintendo 1996-2020. --*/ +/*-- --*/ +/*-- The custom code written here is licensed under the terms of the GPL: --*/ +/*-- --*/ +/*-- This program is free software: you can redistribute it and/or modify --*/ +/*-- it under the terms of the GNU General Public License as published by --*/ +/*-- the Free Software Foundation, either version 3 of the License, or --*/ +/*-- (at your option) any later version. --*/ +/*-- --*/ +/*-- This program is distributed in the hope that it will be useful, --*/ +/*-- but WITHOUT ANY WARRANTY; without even the implied warranty of --*/ +/*-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the --*/ +/*-- GNU General Public License for more details. --*/ +/*-- --*/ +/*-- You should have received a copy of the GNU General Public License --*/ +/*-- along with this program. If not, see <http://www.gnu.org/licenses/>. --*/ +/*----------------------------------------------------------------------------*/ + +import com.sneed.pkrandom.*; +import com.sneed.pkrandom.cli.CliRandomizer; +import com.sneed.pkrandom.constants.GlobalConstants; +import com.sneed.pkrandom.exceptions.EncryptedROMException; +import com.sneed.pkrandom.exceptions.InvalidSupplementFilesException; +import com.sneed.pkrandom.exceptions.RandomizationException; +import com.sneed.pkrandom.pokemon.ExpCurve; +import com.sneed.pkrandom.pokemon.GenRestrictions; +import com.sneed.pkrandom.pokemon.Pokemon; +import com.sneed.pkrandom.romhandlers.*; + +import javax.swing.*; +import javax.swing.border.TitledBorder; +import java.awt.*; +import java.awt.event.*; +import java.awt.image.BufferedImage; +import java.io.*; +import java.net.HttpURLConnection; +import java.net.URI; +import java.net.URL; +import java.text.SimpleDateFormat; +import java.util.*; +import java.util.List; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.stream.Collectors; + +public class NewRandomizerGUI { + private JTabbedPane tabbedPane1; + private JCheckBox raceModeCheckBox; + private JButton openROMButton; + private JButton randomizeSaveButton; + private JButton premadeSeedButton; + private JButton settingsButton; + private JButton loadSettingsButton; + private JButton saveSettingsButton; + private JPanel mainPanel; + private JRadioButton pbsUnchangedRadioButton; + private JRadioButton pbsShuffleRadioButton; + private JRadioButton pbsRandomRadioButton; + private JRadioButton pbsLegendariesSlowRadioButton; + private JRadioButton pbsStrongLegendariesSlowRadioButton; + private JRadioButton pbsAllMediumFastRadioButton; + private JCheckBox pbsStandardizeEXPCurvesCheckBox; + private JCheckBox pbsFollowEvolutionsCheckBox; + private JCheckBox pbsUpdateBaseStatsCheckBox; + private JCheckBox ptIsDualTypeCheckBox; + private JRadioButton ptUnchangedRadioButton; + private JRadioButton ptRandomFollowEvolutionsRadioButton; + private JRadioButton ptRandomCompletelyRadioButton; + private JRadioButton paUnchangedRadioButton; + private JRadioButton paRandomRadioButton; + private JCheckBox paAllowWonderGuardCheckBox; + private JCheckBox paFollowEvolutionsCheckBox; + private JCheckBox paTrappingAbilitiesCheckBox; + private JCheckBox paNegativeAbilitiesCheckBox; + private JCheckBox paBadAbilitiesCheckBox; + private JRadioButton peUnchangedRadioButton; + private JRadioButton peRandomRadioButton; + private JCheckBox peSimilarStrengthCheckBox; + private JCheckBox peSameTypingCheckBox; + private JCheckBox peLimitEvolutionsToThreeCheckBox; + private JCheckBox peForceChangeCheckBox; + private JCheckBox peChangeImpossibleEvosCheckBox; + private JCheckBox peMakeEvolutionsEasierCheckBox; + private JRadioButton spUnchangedRadioButton; + private JRadioButton spCustomRadioButton; + private JRadioButton spRandomCompletelyRadioButton; + private JRadioButton spRandomTwoEvosRadioButton; + private JComboBox<String> spComboBox1; + private JComboBox<String> spComboBox2; + private JComboBox<String> spComboBox3; + private JCheckBox spRandomizeStarterHeldItemsCheckBox; + private JCheckBox spBanBadItemsCheckBox; + private JRadioButton stpUnchangedRadioButton; + private JRadioButton stpSwapLegendariesSwapStandardsRadioButton; + private JRadioButton stpRandomCompletelyRadioButton; + private JRadioButton stpRandomSimilarStrengthRadioButton; + private JCheckBox stpLimitMainGameLegendariesCheckBox; + private JCheckBox stpRandomize600BSTCheckBox; + private JRadioButton igtUnchangedRadioButton; + private JRadioButton igtRandomizeGivenPokemonOnlyRadioButton; + private JRadioButton igtRandomizeBothRequestedGivenRadioButton; + private JCheckBox igtRandomizeNicknamesCheckBox; + private JCheckBox igtRandomizeOTsCheckBox; + private JCheckBox igtRandomizeIVsCheckBox; + private JCheckBox igtRandomizeItemsCheckBox; + private JCheckBox mdRandomizeMovePowerCheckBox; + private JCheckBox mdRandomizeMoveAccuracyCheckBox; + private JCheckBox mdRandomizeMovePPCheckBox; + private JCheckBox mdRandomizeMoveTypesCheckBox; + private JCheckBox mdRandomizeMoveCategoryCheckBox; + private JCheckBox mdUpdateMovesCheckBox; + private JCheckBox mdLegacyCheckBox; + private JRadioButton pmsUnchangedRadioButton; + private JRadioButton pmsRandomPreferringSameTypeRadioButton; + private JRadioButton pmsRandomCompletelyRadioButton; + private JRadioButton pmsMetronomeOnlyModeRadioButton; + private JCheckBox pmsGuaranteedLevel1MovesCheckBox; + private JCheckBox pmsReorderDamagingMovesCheckBox; + private JCheckBox pmsNoGameBreakingMovesCheckBox; + private JCheckBox pmsForceGoodDamagingCheckBox; + private JSlider pmsGuaranteedLevel1MovesSlider; + private JSlider pmsForceGoodDamagingSlider; + private JCheckBox tpRivalCarriesStarterCheckBox; + private JCheckBox tpSimilarStrengthCheckBox; + private JCheckBox tpWeightTypesCheckBox; + private JCheckBox tpDontUseLegendariesCheckBox; + private JCheckBox tpNoEarlyWonderGuardCheckBox; + private JCheckBox tpRandomizeTrainerNamesCheckBox; + private JCheckBox tpRandomizeTrainerClassNamesCheckBox; + private JCheckBox tpForceFullyEvolvedAtCheckBox; + private JSlider tpForceFullyEvolvedAtSlider; + private JSlider tpPercentageLevelModifierSlider; + private JCheckBox tpEliteFourUniquePokemonCheckBox; + private JSpinner tpEliteFourUniquePokemonSpinner; + private JCheckBox tpPercentageLevelModifierCheckBox; + private JRadioButton wpUnchangedRadioButton; + private JRadioButton wpRandomRadioButton; + private JRadioButton wpArea1To1RadioButton; + private JRadioButton wpGlobal1To1RadioButton; + private JRadioButton wpARNoneRadioButton; + private JRadioButton wpARSimilarStrengthRadioButton; + private JRadioButton wpARCatchEmAllModeRadioButton; + private JRadioButton wpARTypeThemeAreasRadioButton; + private JCheckBox wpUseTimeBasedEncountersCheckBox; + private JCheckBox wpDontUseLegendariesCheckBox; + private JCheckBox wpSetMinimumCatchRateCheckBox; + private JCheckBox wpRandomizeHeldItemsCheckBox; + private JCheckBox wpBanBadItemsCheckBox; + private JCheckBox wpBalanceShakingGrassPokemonCheckBox; + private JCheckBox wpPercentageLevelModifierCheckBox; + private JSlider wpPercentageLevelModifierSlider; + private JSlider wpSetMinimumCatchRateSlider; + private JRadioButton tmUnchangedRadioButton; + private JRadioButton tmRandomRadioButton; + private JCheckBox tmFullHMCompatibilityCheckBox; + private JCheckBox tmLevelupMoveSanityCheckBox; + private JCheckBox tmKeepFieldMoveTMsCheckBox; + private JCheckBox tmForceGoodDamagingCheckBox; + private JSlider tmForceGoodDamagingSlider; + private JRadioButton thcUnchangedRadioButton; + private JRadioButton thcRandomPreferSameTypeRadioButton; + private JRadioButton thcRandomCompletelyRadioButton; + private JRadioButton thcFullCompatibilityRadioButton; + private JRadioButton mtUnchangedRadioButton; + private JRadioButton mtRandomRadioButton; + private JCheckBox mtLevelupMoveSanityCheckBox; + private JCheckBox mtKeepFieldMoveTutorsCheckBox; + private JCheckBox mtForceGoodDamagingCheckBox; + private JSlider mtForceGoodDamagingSlider; + private JRadioButton mtcUnchangedRadioButton; + private JRadioButton mtcRandomPreferSameTypeRadioButton; + private JRadioButton mtcRandomCompletelyRadioButton; + private JRadioButton mtcFullCompatibilityRadioButton; + private JRadioButton fiUnchangedRadioButton; + private JRadioButton fiShuffleRadioButton; + private JRadioButton fiRandomRadioButton; + private JRadioButton fiRandomEvenDistributionRadioButton; + private JCheckBox fiBanBadItemsCheckBox; + private JRadioButton shUnchangedRadioButton; + private JRadioButton shShuffleRadioButton; + private JRadioButton shRandomRadioButton; + private JCheckBox shBanOverpoweredShopItemsCheckBox; + private JCheckBox shBanBadItemsCheckBox; + private JCheckBox shBanRegularShopItemsCheckBox; + private JCheckBox shBalanceShopItemPricesCheckBox; + private JCheckBox shGuaranteeEvolutionItemsCheckBox; + private JCheckBox shGuaranteeXItemsCheckBox; + private JCheckBox miscBWExpPatchCheckBox; + private JCheckBox miscNerfXAccuracyCheckBox; + private JCheckBox miscFixCritRateCheckBox; + private JCheckBox miscFastestTextCheckBox; + private JCheckBox miscRunningShoesIndoorsCheckBox; + private JCheckBox miscRandomizePCPotionCheckBox; + private JCheckBox miscAllowPikachuEvolutionCheckBox; + private JCheckBox miscGiveNationalDexAtCheckBox; + private JCheckBox miscUpdateTypeEffectivenessCheckBox; + private JCheckBox miscLowerCasePokemonNamesCheckBox; + private JCheckBox miscRandomizeCatchingTutorialCheckBox; + private JCheckBox miscBanLuckyEggCheckBox; + private JCheckBox miscNoFreeLuckyEggCheckBox; + private JCheckBox miscBanBigMoneyManiacCheckBox; + private JPanel pokemonAbilitiesPanel; + private JPanel moveTutorPanel; + private JPanel mtMovesPanel; + private JPanel mtCompatPanel; + private JLabel mtNoExistLabel; + private JPanel shopItemsPanel; + private JLabel mtNoneAvailableLabel; + private JPanel miscTweaksPanel; + private JLabel gameMascotLabel; + private JPanel baseTweaksPanel; + private JLabel romNameLabel; + private JLabel romCodeLabel; + private JLabel romSupportLabel; + private JCheckBox tmNoGameBreakingMovesCheckBox; + private JCheckBox mtNoGameBreakingMovesCheckBox; + private JCheckBox limitPokemonCheckBox; + private JButton limitPokemonButton; + private JCheckBox tpAllowAlternateFormesCheckBox; + private JLabel versionLabel; + private JCheckBox pbsFollowMegaEvosCheckBox; + private JCheckBox paFollowMegaEvosCheckBox; + private JCheckBox ptFollowMegaEvosCheckBox; + private JCheckBox spAllowAltFormesCheckBox; + private JCheckBox stpAllowAltFormesCheckBox; + private JCheckBox stpSwapMegaEvosCheckBox; + private JCheckBox tpSwapMegaEvosCheckBox; + private JCheckBox wpAllowAltFormesCheckBox; + private JCheckBox tpDoubleBattleModeCheckBox; + private JCheckBox tpBossTrainersCheckBox; + private JCheckBox tpImportantTrainersCheckBox; + private JCheckBox tpRegularTrainersCheckBox; + private JSpinner tpBossTrainersSpinner; + private JSpinner tpImportantTrainersSpinner; + private JSpinner tpRegularTrainersSpinner; + private JLabel tpAdditionalPokemonForLabel; + private JCheckBox peAllowAltFormesCheckBox; + private JCheckBox miscSOSBattlesCheckBox; + private JCheckBox tpRandomShinyTrainerPokemonCheckBox; + private JRadioButton totpUnchangedRadioButton; + private JRadioButton totpRandomRadioButton; + private JRadioButton totpRandomSimilarStrengthRadioButton; + private JRadioButton totpAllyUnchangedRadioButton; + private JRadioButton totpAllyRandomRadioButton; + private JRadioButton totpAllyRandomSimilarStrengthRadioButton; + private JPanel totpAllyPanel; + private JPanel totpAuraPanel; + private JRadioButton totpAuraUnchangedRadioButton; + private JRadioButton totpAuraRandomRadioButton; + private JRadioButton totpAuraRandomSameStrengthRadioButton; + private JCheckBox totpPercentageLevelModifierCheckBox; + private JSlider totpPercentageLevelModifierSlider; + private JCheckBox totpRandomizeHeldItemsCheckBox; + private JCheckBox totpAllowAltFormesCheckBox; + private JPanel totpPanel; + private JCheckBox pmsEvolutionMovesCheckBox; + private JComboBox<String> pbsUpdateComboBox; + private JComboBox<String> mdUpdateComboBox; + private JCheckBox paWeighDuplicatesTogetherCheckBox; + private JCheckBox miscBalanceStaticLevelsCheckBox; + private JCheckBox miscRetainAltFormesCheckBox; + private JComboBox pbsEXPCurveComboBox; + private JCheckBox miscRunWithoutRunningShoesCheckBox; + private JCheckBox peRemoveTimeBasedEvolutionsCheckBox; + private JCheckBox tmFollowEvolutionsCheckBox; + private JCheckBox mtFollowEvolutionsCheckBox; + private JCheckBox stpPercentageLevelModifierCheckBox; + private JSlider stpPercentageLevelModifierSlider; + private JCheckBox stpFixMusicCheckBox; + private JCheckBox miscFasterHPAndEXPBarsCheckBox; + private JCheckBox tpBossTrainersItemsCheckBox; + private JCheckBox tpImportantTrainersItemsCheckBox; + private JCheckBox tpRegularTrainersItemsCheckBox; + private JLabel tpHeldItemsLabel; + private JCheckBox tpConsumableItemsOnlyCheckBox; + private JCheckBox tpSensibleItemsCheckBox; + private JCheckBox tpHighestLevelGetsItemCheckBox; + private JPanel pickupItemsPanel; + private JRadioButton puUnchangedRadioButton; + private JRadioButton puRandomRadioButton; + private JCheckBox puBanBadItemsCheckBox; + private JCheckBox miscForceChallengeModeCheckBox; + private JCheckBox pbsAssignEvoStatsRandomlyCheckBox; + private JCheckBox noIrregularAltFormesCheckBox; + private JRadioButton peRandomEveryLevelRadioButton; + private JCheckBox miscFastDistortionWorldCheckBox; + private JComboBox tpComboBox; + + private static JFrame frame; + + private static String launcherInput = ""; + public static boolean usedLauncher = false; + + private GenRestrictions currentRestrictions; + private OperationDialog opDialog; + + private ResourceBundle bundle; + protected RomHandler.Factory[] checkHandlers; + private RomHandler romHandler; + + private boolean presetMode = false; + private boolean initialPopup = true; + private boolean showInvalidRomPopup = true; + + private List<JCheckBox> tweakCheckBoxes; + private JPanel liveTweaksPanel = new JPanel(); + + private JFileChooser romOpenChooser = new JFileChooser(); + private JFileChooser romSaveChooser = new JFileChooser(); + private JFileChooser qsOpenChooser = new JFileChooser(); + private JFileChooser qsSaveChooser = new JFileChooser(); + private JFileChooser qsUpdateChooser = new JFileChooser(); + private JFileChooser gameUpdateChooser = new JFileChooser(); + + private JPopupMenu settingsMenu; + private JMenuItem customNamesEditorMenuItem; + private JMenuItem loadGetSettingsMenuItem; + private JMenuItem keepOrUnloadGameAfterRandomizingMenuItem; + + private ImageIcon emptyIcon = new ImageIcon(getClass().getResource("/com/sneed/pkrandom/newgui/emptyIcon.png")); + private boolean haveCheckedCustomNames, unloadGameOnSuccess; + private Map<String, String> gameUpdates = new TreeMap<>(); + + private List<String> trainerSettings = new ArrayList<>(); + private List<String> trainerSettingToolTips = new ArrayList<>(); + private final int TRAINER_UNCHANGED = 0, TRAINER_RANDOM = 1, TRAINER_RANDOM_EVEN = 2, TRAINER_RANDOM_EVEN_MAIN = 3, + TRAINER_TYPE_THEMED = 4, TRAINER_TYPE_THEMED_ELITE4_GYMS = 5; + + public NewRandomizerGUI() { + ToolTipManager.sharedInstance().setInitialDelay(400); + ToolTipManager.sharedInstance().setDismissDelay(Integer.MAX_VALUE); + bundle = ResourceBundle.getBundle("com/sneed/pkrandom/newgui/Bundle"); + testForRequiredConfigs(); + checkHandlers = new RomHandler.Factory[] { new Gen1RomHandler.Factory(), new Gen2RomHandler.Factory(), + new Gen3RomHandler.Factory(), new Gen4RomHandler.Factory(), new Gen5RomHandler.Factory(), + new Gen6RomHandler.Factory(), new Gen7RomHandler.Factory() }; + + haveCheckedCustomNames = false; + attemptReadConfig(); + initExplicit(); + initTweaksPanel(); + initFileChooserDirectories(); + + boolean canWrite = attemptWriteConfig(); + if (!canWrite) { + JOptionPane.showMessageDialog(null, bundle.getString("GUI.cantWriteConfigFile")); + } + + if (!haveCheckedCustomNames) { + checkCustomNames(); + } + + new Thread(() -> { + String latestVersionString = "???"; + + try { + + URL url = new URL(SysConstants.API_URL_ZX); + HttpURLConnection conn = (HttpURLConnection) url.openConnection(); + conn.setRequestMethod("GET"); + conn.setRequestProperty("Accept", "application/json"); + conn.setConnectTimeout(2000); + conn.setReadTimeout(2000); + + BufferedReader br = new BufferedReader(new InputStreamReader((conn.getInputStream()))); + + String output; + while ((output = br.readLine()) != null) { + String[] a = output.split("tag_name\":\""); + if (a.length > 1) { + latestVersionString = a[1].split("\",")[0]; + } + } + + conn.disconnect(); + + } catch (Exception e) { + e.printStackTrace(); + } + }).run(); + + frame.setTitle(String.format(bundle.getString("GUI.windowTitle"),Version.VERSION_STRING)); + + openROMButton.addActionListener(e -> loadROM()); + pbsUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + pbsShuffleRadioButton.addActionListener(e -> enableOrDisableSubControls()); + pbsRandomRadioButton.addActionListener(e -> enableOrDisableSubControls()); + pbsFollowMegaEvosCheckBox.addActionListener(e -> enableOrDisableSubControls()); + pbsFollowEvolutionsCheckBox.addActionListener(e -> enableOrDisableSubControls()); + pbsStandardizeEXPCurvesCheckBox.addActionListener(e -> enableOrDisableSubControls()); + paUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + paRandomRadioButton.addActionListener(e -> enableOrDisableSubControls()); + peUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + peRandomRadioButton.addActionListener(e -> enableOrDisableSubControls()); + peRandomEveryLevelRadioButton.addActionListener(e -> enableOrDisableSubControls()); + peAllowAltFormesCheckBox.addActionListener(e -> enableOrDisableSubControls()); + spUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + spCustomRadioButton.addActionListener(e -> enableOrDisableSubControls()); + spRandomCompletelyRadioButton.addActionListener(e -> enableOrDisableSubControls()); + spRandomTwoEvosRadioButton.addActionListener(e -> enableOrDisableSubControls()); + stpUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + stpSwapLegendariesSwapStandardsRadioButton.addActionListener(e -> enableOrDisableSubControls()); + stpRandomCompletelyRadioButton.addActionListener(e -> enableOrDisableSubControls()); + stpRandomSimilarStrengthRadioButton.addActionListener(e -> enableOrDisableSubControls()); + stpPercentageLevelModifierCheckBox.addActionListener(e -> enableOrDisableSubControls()); + igtUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + igtRandomizeGivenPokemonOnlyRadioButton.addActionListener(e -> enableOrDisableSubControls()); + igtRandomizeBothRequestedGivenRadioButton.addActionListener(e -> enableOrDisableSubControls()); + pmsUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + pmsRandomPreferringSameTypeRadioButton.addActionListener(e -> enableOrDisableSubControls()); + pmsRandomCompletelyRadioButton.addActionListener(e -> enableOrDisableSubControls()); + pmsMetronomeOnlyModeRadioButton.addActionListener(e -> enableOrDisableSubControls()); + pmsGuaranteedLevel1MovesCheckBox.addActionListener(e -> enableOrDisableSubControls()); + pmsForceGoodDamagingCheckBox.addActionListener(e -> enableOrDisableSubControls()); + tpForceFullyEvolvedAtCheckBox.addActionListener(e -> enableOrDisableSubControls()); + tpPercentageLevelModifierCheckBox.addActionListener(e -> enableOrDisableSubControls()); + tpEliteFourUniquePokemonCheckBox.addActionListener(e -> enableOrDisableSubControls()); + wpUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + wpRandomRadioButton.addActionListener(e -> enableOrDisableSubControls()); + wpArea1To1RadioButton.addActionListener(e -> enableOrDisableSubControls()); + wpGlobal1To1RadioButton.addActionListener(e -> enableOrDisableSubControls()); + wpSetMinimumCatchRateCheckBox.addActionListener(e -> enableOrDisableSubControls()); + wpRandomizeHeldItemsCheckBox.addActionListener(e -> enableOrDisableSubControls()); + wpPercentageLevelModifierCheckBox.addActionListener(e -> enableOrDisableSubControls()); + tmUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + tmRandomRadioButton.addActionListener(e -> enableOrDisableSubControls()); + tmForceGoodDamagingCheckBox.addActionListener(e -> enableOrDisableSubControls()); + thcUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + thcRandomPreferSameTypeRadioButton.addActionListener(e -> enableOrDisableSubControls()); + thcRandomCompletelyRadioButton.addActionListener(e -> enableOrDisableSubControls()); + thcFullCompatibilityRadioButton.addActionListener(e -> enableOrDisableSubControls()); + mtUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + mtRandomRadioButton.addActionListener(e -> enableOrDisableSubControls()); + mtForceGoodDamagingCheckBox.addActionListener(e -> enableOrDisableSubControls()); + mtcUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + mtcRandomPreferSameTypeRadioButton.addActionListener(e -> enableOrDisableSubControls()); + mtcRandomCompletelyRadioButton.addActionListener(e -> enableOrDisableSubControls()); + mtcFullCompatibilityRadioButton.addActionListener(e -> enableOrDisableSubControls()); + fiUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + fiShuffleRadioButton.addActionListener(e -> enableOrDisableSubControls()); + fiRandomRadioButton.addActionListener(e -> enableOrDisableSubControls()); + fiRandomEvenDistributionRadioButton.addActionListener(e -> enableOrDisableSubControls()); + shUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + shShuffleRadioButton.addActionListener(e -> enableOrDisableSubControls()); + shRandomRadioButton.addActionListener(e -> enableOrDisableSubControls()); + puUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + puRandomRadioButton.addActionListener(e -> enableOrDisableSubControls()); + randomizeSaveButton.addActionListener(e -> saveROM()); + premadeSeedButton.addActionListener(e -> presetLoader()); + loadSettingsButton.addActionListener(e -> loadQS()); + saveSettingsButton.addActionListener(e -> saveQS()); + settingsButton.addActionListener(e -> settingsMenu.show(settingsButton,0,settingsButton.getHeight())); + customNamesEditorMenuItem.addActionListener(e -> new CustomNamesEditorDialog(frame)); + loadGetSettingsMenuItem.addActionListener(e -> loadGetSettingsMenuItemActionPerformed()); + keepOrUnloadGameAfterRandomizingMenuItem.addActionListener(e -> keepOrUnloadGameAfterRandomizingMenuItemActionPerformed()); + limitPokemonButton.addActionListener(e -> { + NewGenerationLimitDialog gld = new NewGenerationLimitDialog(frame, currentRestrictions, + romHandler.generationOfPokemon(), romHandler.forceSwapStaticMegaEvos()); + if (gld.pressedOK()) { + currentRestrictions = gld.getChoice(); + if (currentRestrictions != null && !currentRestrictions.allowTrainerSwapMegaEvolvables( + romHandler.forceSwapStaticMegaEvos(), isTrainerSetting(TRAINER_TYPE_THEMED))) { + tpSwapMegaEvosCheckBox.setEnabled(false); + tpSwapMegaEvosCheckBox.setSelected(false); + } + } + }); + limitPokemonCheckBox.addActionListener(e -> enableOrDisableSubControls()); + tpAllowAlternateFormesCheckBox.addActionListener(e -> enableOrDisableSubControls()); + tpBossTrainersCheckBox.addActionListener(e -> enableOrDisableSubControls()); + tpImportantTrainersCheckBox.addActionListener(e -> enableOrDisableSubControls()); + tpRegularTrainersCheckBox.addActionListener(e -> enableOrDisableSubControls()); + tpBossTrainersItemsCheckBox.addActionListener(e -> enableOrDisableSubControls()); + tpImportantTrainersItemsCheckBox.addActionListener(e -> enableOrDisableSubControls()); + tpRegularTrainersItemsCheckBox.addActionListener(e -> enableOrDisableSubControls()); + totpUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + totpRandomRadioButton.addActionListener(e -> enableOrDisableSubControls()); + totpRandomSimilarStrengthRadioButton.addActionListener(e -> enableOrDisableSubControls()); + totpAllyUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + totpAllyRandomRadioButton.addActionListener(e -> enableOrDisableSubControls()); + totpAllyRandomSimilarStrengthRadioButton.addActionListener(e -> enableOrDisableSubControls()); + totpPercentageLevelModifierCheckBox.addActionListener(e -> enableOrDisableSubControls()); + pbsUpdateBaseStatsCheckBox.addActionListener(e -> enableOrDisableSubControls()); + mdUpdateMovesCheckBox.addActionListener(e -> enableOrDisableSubControls()); + frame.addComponentListener(new ComponentListener() { + @Override + public void componentResized(ComponentEvent e) { + + } + + @Override + public void componentMoved(ComponentEvent e) { + + } + + @Override + public void componentShown(ComponentEvent e) { + showInitialPopup(); + } + + @Override + public void componentHidden(ComponentEvent e) { + + } + }); + ptUnchangedRadioButton.addActionListener(e -> enableOrDisableSubControls()); + ptRandomFollowEvolutionsRadioButton.addActionListener(e -> enableOrDisableSubControls()); + ptRandomCompletelyRadioButton.addActionListener(e -> enableOrDisableSubControls()); + spRandomizeStarterHeldItemsCheckBox.addActionListener(e -> enableOrDisableSubControls()); + tmLevelupMoveSanityCheckBox.addActionListener(e -> enableOrDisableSubControls()); + mtLevelupMoveSanityCheckBox.addActionListener(e -> enableOrDisableSubControls()); + noIrregularAltFormesCheckBox.addActionListener(e -> enableOrDisableSubControls()); + ptIsDualTypeCheckBox.addActionListener(e->enableOrDisableSubControls()); + tpComboBox.addItemListener(e -> { + if (e.getStateChange() == ItemEvent.SELECTED) { + enableOrDisableSubControls(); + } + }); + } + + private void showInitialPopup() { + if (!usedLauncher) { + String message = bundle.getString("GUI.pleaseUseTheLauncher"); + Object[] messages = {message}; + JOptionPane.showMessageDialog(frame, messages); + } + } + + private void showInvalidRomPopup() { + if (showInvalidRomPopup) { + String message = String.format(bundle.getString("GUI.invalidRomMessage")); + JLabel label = new JLabel("<html><b>Randomizing ROM hacks or bad ROM dumps is not supported and may cause issues.</b>"); + JCheckBox checkbox = new JCheckBox("Don't show this again"); + Object[] messages = {message, label, checkbox}; + Object[] options = {"OK"}; + JOptionPane.showOptionDialog(frame, + messages, + "Invalid ROM detected", + JOptionPane.OK_OPTION, + JOptionPane.WARNING_MESSAGE, + null, + options, + null); + showInvalidRomPopup = !checkbox.isSelected(); + attemptWriteConfig(); + } + } + + private void initFileChooserDirectories() { + romOpenChooser.setCurrentDirectory(new File(SysConstants.ROOT_PATH)); + romSaveChooser.setCurrentDirectory(new File(SysConstants.ROOT_PATH)); + if (new File(SysConstants.ROOT_PATH + "settings/").exists()) { + qsOpenChooser.setCurrentDirectory(new File(SysConstants.ROOT_PATH + "settings/")); + qsSaveChooser.setCurrentDirectory(new File(SysConstants.ROOT_PATH + "settings/")); + qsUpdateChooser.setCurrentDirectory(new File(SysConstants.ROOT_PATH + "settings/")); + } else { + qsOpenChooser.setCurrentDirectory(new File(SysConstants.ROOT_PATH)); + qsSaveChooser.setCurrentDirectory(new File(SysConstants.ROOT_PATH)); + qsUpdateChooser.setCurrentDirectory(new File(SysConstants.ROOT_PATH)); + } + } + + private void initExplicit() { + + versionLabel.setText(String.format(bundle.getString("GUI.versionLabel.text"), Version.VERSION_STRING)); + mtNoExistLabel.setVisible(false); + mtNoneAvailableLabel.setVisible(false); + baseTweaksPanel.add(liveTweaksPanel); + liveTweaksPanel.setVisible(false); + + romOpenChooser.setFileFilter(new ROMFilter()); + + romSaveChooser.setDialogType(javax.swing.JFileChooser.SAVE_DIALOG); + romSaveChooser.setFileFilter(new ROMFilter()); + + qsOpenChooser.setFileFilter(new QSFileFilter()); + + qsSaveChooser.setDialogType(javax.swing.JFileChooser.SAVE_DIALOG); + qsSaveChooser.setFileFilter(new QSFileFilter()); + + qsUpdateChooser.setFileFilter(new QSFileFilter()); + + settingsMenu = new JPopupMenu(); + + SpinnerModel bossTrainerModel = new SpinnerNumberModel( + 1, + 1, + 5, + 1 + ); + SpinnerModel importantTrainerModel = new SpinnerNumberModel( + 1, + 1, + 5, + 1 + ); + SpinnerModel regularTrainerModel = new SpinnerNumberModel( + 1, + 1, + 5, + 1 + ); + + SpinnerModel eliteFourUniquePokemonModel = new SpinnerNumberModel( + 1, + 1, + 2, + 1 + ); + + List<String> keys = new ArrayList<>(bundle.keySet()); + Collections.sort(keys); + for (String k: keys) { + if (k.matches("^GUI\\.tpMain.*\\.text$")) { + trainerSettings.add(bundle.getString(k)); + trainerSettingToolTips.add(k.replace("text","toolTipText")); + } + } + + tpBossTrainersSpinner.setModel(bossTrainerModel); + tpImportantTrainersSpinner.setModel(importantTrainerModel); + tpRegularTrainersSpinner.setModel(regularTrainerModel); + tpEliteFourUniquePokemonSpinner.setModel(eliteFourUniquePokemonModel); + + customNamesEditorMenuItem = new JMenuItem(); + customNamesEditorMenuItem.setText(bundle.getString("GUI.customNamesEditorMenuItem.text")); + settingsMenu.add(customNamesEditorMenuItem); + + loadGetSettingsMenuItem = new JMenuItem(); + loadGetSettingsMenuItem.setText(bundle.getString("GUI.loadGetSettingsMenuItem.text")); + settingsMenu.add(loadGetSettingsMenuItem); + + keepOrUnloadGameAfterRandomizingMenuItem = new JMenuItem(); + if (this.unloadGameOnSuccess) { + keepOrUnloadGameAfterRandomizingMenuItem.setText(bundle.getString("GUI.keepGameLoadedAfterRandomizingMenuItem.text")); + } else { + keepOrUnloadGameAfterRandomizingMenuItem.setText(bundle.getString("GUI.unloadGameAfterRandomizingMenuItem.text")); + } + settingsMenu.add(keepOrUnloadGameAfterRandomizingMenuItem); + } + + private void loadROM() { + romOpenChooser.setSelectedFile(null); + int returnVal = romOpenChooser.showOpenDialog(mainPanel); + if (returnVal == JFileChooser.APPROVE_OPTION) { + final File fh = romOpenChooser.getSelectedFile(); + try { + Utils.validateRomFile(fh); + } catch (Utils.InvalidROMException e) { + switch (e.getType()) { + case LENGTH: + JOptionPane.showMessageDialog(mainPanel, + String.format(bundle.getString("GUI.tooShortToBeARom"), fh.getName())); + return; + case ZIP_FILE: + JOptionPane.showMessageDialog(mainPanel, + String.format(bundle.getString("GUI.openedZIPfile"), fh.getName())); + return; + case RAR_FILE: + JOptionPane.showMessageDialog(mainPanel, + String.format(bundle.getString("GUI.openedRARfile"), fh.getName())); + return; + case IPS_FILE: + JOptionPane.showMessageDialog(mainPanel, + String.format(bundle.getString("GUI.openedIPSfile"), fh.getName())); + return; + case UNREADABLE: + JOptionPane.showMessageDialog(mainPanel, + String.format(bundle.getString("GUI.unreadableRom"), fh.getName())); + return; + } + } + + for (RomHandler.Factory rhf : checkHandlers) { + if (rhf.isLoadable(fh.getAbsolutePath())) { + this.romHandler = rhf.create(RandomSource.instance()); + if (!usedLauncher && this.romHandler instanceof Abstract3DSRomHandler) { + String message = bundle.getString("GUI.pleaseUseTheLauncher"); + Object[] messages = {message}; + JOptionPane.showMessageDialog(frame, messages); + this.romHandler = null; + return; + } + opDialog = new OperationDialog(bundle.getString("GUI.loadingText"), frame, true); + Thread t = new Thread(() -> { + boolean romLoaded = false; + SwingUtilities.invokeLater(() -> opDialog.setVisible(true)); + try { + this.romHandler.loadRom(fh.getAbsolutePath()); + if (gameUpdates.containsKey(this.romHandler.getROMCode())) { + this.romHandler.loadGameUpdate(gameUpdates.get(this.romHandler.getROMCode())); + } + romLoaded = true; + } catch (EncryptedROMException ex) { + JOptionPane.showMessageDialog(mainPanel, + String.format(bundle.getString("GUI.encryptedRom"), fh.getAbsolutePath())); + } catch (Exception ex) { + attemptToLogException(ex, "GUI.loadFailed", "GUI.loadFailedNoLog", null, null); + } + final boolean loadSuccess = romLoaded; + SwingUtilities.invokeLater(() -> { + this.opDialog.setVisible(false); + this.initialState(); + if (loadSuccess) { + this.romLoaded(); + } + }); + }); + t.start(); + + return; + } + } + JOptionPane.showMessageDialog(mainPanel, + String.format(bundle.getString("GUI.unsupportedRom"), fh.getName())); + } + } + + private void saveROM() { + if (romHandler == null) { + return; // none loaded + } + if (raceModeCheckBox.isSelected() && isTrainerSetting(TRAINER_UNCHANGED) && wpUnchangedRadioButton.isSelected()) { + JOptionPane.showMessageDialog(frame, bundle.getString("GUI.raceModeRequirements")); + return; + } + if (limitPokemonCheckBox.isSelected() + && (this.currentRestrictions == null || this.currentRestrictions.nothingSelected())) { + JOptionPane.showMessageDialog(frame, bundle.getString("GUI.pokeLimitNotChosen")); + return; + } + SaveType outputType = askForSaveType(); + romSaveChooser.setSelectedFile(null); + boolean allowed = false; + File fh = null; + if (outputType == SaveType.FILE) { + romSaveChooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES); + int returnVal = romSaveChooser.showSaveDialog(frame); + if (returnVal == JFileChooser.APPROVE_OPTION) { + fh = romSaveChooser.getSelectedFile(); + // Fix or add extension + List<String> extensions = new ArrayList<>(Arrays.asList("sgb", "gbc", "gba", "nds", "cxi")); + extensions.remove(this.romHandler.getDefaultExtension()); + fh = FileFunctions.fixFilename(fh, this.romHandler.getDefaultExtension(), extensions); + allowed = true; + if (this.romHandler instanceof AbstractDSRomHandler || this.romHandler instanceof Abstract3DSRomHandler) { + String currentFN = this.romHandler.loadedFilename(); + if (currentFN.equals(fh.getAbsolutePath())) { + JOptionPane.showMessageDialog(frame, bundle.getString("GUI.cantOverwriteDS")); + allowed = false; + } + } + } + } else if (outputType == SaveType.DIRECTORY) { + romSaveChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY); + int returnVal = romSaveChooser.showSaveDialog(frame); + if (returnVal == JFileChooser.APPROVE_OPTION) { + fh = romSaveChooser.getSelectedFile(); + allowed = true; + } + } + + if (allowed && fh != null) { + // Get a seed + long seed = RandomSource.pickSeed(); + // Apply it + RandomSource.seed(seed); + presetMode = false; + + try { + CustomNamesSet cns = FileFunctions.getCustomNames(); + performRandomization(fh.getAbsolutePath(), seed, cns, outputType == SaveType.DIRECTORY); + } catch (IOException ex) { + JOptionPane.showMessageDialog(frame, bundle.getString("GUI.cantLoadCustomNames")); + } + + } + } + + private void loadQS() { + if (this.romHandler == null) { + return; + } + qsOpenChooser.setSelectedFile(null); + int returnVal = qsOpenChooser.showOpenDialog(frame); + if (returnVal == JFileChooser.APPROVE_OPTION) { + File fh = qsOpenChooser.getSelectedFile(); + try { + FileInputStream fis = new FileInputStream(fh); + Settings settings = Settings.read(fis); + fis.close(); + + SwingUtilities.invokeLater(() -> { + // load settings + initialState(); + romLoaded(); + Settings.TweakForROMFeedback feedback = settings.tweakForRom(this.romHandler); + if (feedback.isChangedStarter() && settings.getStartersMod() == Settings.StartersMod.CUSTOM) { + JOptionPane.showMessageDialog(frame, bundle.getString("GUI.starterUnavailable")); + } + this.restoreStateFromSettings(settings); + + if (settings.isUpdatedFromOldVersion()) { + // show a warning dialog, but load it + JOptionPane.showMessageDialog(frame, bundle.getString("GUI.settingsFileOlder")); + } + + JOptionPane.showMessageDialog(frame, + String.format(bundle.getString("GUI.settingsLoaded"), fh.getName())); + }); + } catch (UnsupportedOperationException ex) { + ex.printStackTrace(); + JOptionPane.showMessageDialog(frame, ex.getMessage()); + } catch (IllegalArgumentException ex) { + ex.printStackTrace(); + JOptionPane.showMessageDialog(frame, bundle.getString("GUI.invalidSettingsFile")); + } catch (IOException ex) { + ex.printStackTrace(); + JOptionPane.showMessageDialog(frame, bundle.getString("GUI.settingsLoadFailed")); + } + } + } + + private void saveQS() { + if (this.romHandler == null) { + return; + } + qsSaveChooser.setSelectedFile(null); + int returnVal = qsSaveChooser.showSaveDialog(frame); + if (returnVal == JFileChooser.APPROVE_OPTION) { + File fh = qsSaveChooser.getSelectedFile(); + // Fix or add extension + fh = FileFunctions.fixFilename(fh, "rnqs"); + // Save now? + try { + FileOutputStream fos = new FileOutputStream(fh); + getCurrentSettings().write(fos); + fos.close(); + } catch (IOException ex) { + JOptionPane.showMessageDialog(frame, bundle.getString("GUI.settingsSaveFailed")); + } + } + } + + private void performRandomization(final String filename, final long seed, CustomNamesSet customNames, boolean saveAsDirectory) { + final Settings settings = createSettingsFromState(customNames); + final boolean raceMode = settings.isRaceMode(); + // Setup verbose log + final ByteArrayOutputStream baos = new ByteArrayOutputStream(); + PrintStream log; + try { + log = new PrintStream(baos, false, "UTF-8"); + } catch (UnsupportedEncodingException e) { + log = new PrintStream(baos); + } + + final PrintStream verboseLog = log; + + try { + final AtomicInteger finishedCV = new AtomicInteger(0); + opDialog = new OperationDialog(bundle.getString("GUI.savingText"), frame, true); + Thread t = new Thread(() -> { + SwingUtilities.invokeLater(() -> opDialog.setVisible(true)); + boolean succeededSave = false; + try { + romHandler.setLog(verboseLog); + finishedCV.set(new Randomizer(settings, romHandler, bundle, saveAsDirectory).randomize(filename, + verboseLog, seed)); + succeededSave = true; + } catch (RandomizationException ex) { + attemptToLogException(ex, "GUI.saveFailedMessage", + "GUI.saveFailedMessageNoLog", true, settings.toString(), Long.toString(seed)); + if (verboseLog != null) { + verboseLog.close(); + } + } catch (Exception ex) { + attemptToLogException(ex, "GUI.saveFailedIO", "GUI.saveFailedIONoLog", settings.toString(), Long.toString(seed)); + if (verboseLog != null) { + verboseLog.close(); + } + } + if (succeededSave) { + SwingUtilities.invokeLater(() -> { + opDialog.setVisible(false); + // Log? + verboseLog.close(); + byte[] out = baos.toByteArray(); + + if (raceMode) { + JOptionPane.showMessageDialog(frame, + String.format(bundle.getString("GUI.raceModeCheckValuePopup"), + finishedCV.get())); + } else { + int response = JOptionPane.showConfirmDialog(frame, + bundle.getString("GUI.saveLogDialog.text"), + bundle.getString("GUI.saveLogDialog.title"), + JOptionPane.YES_NO_OPTION); + if (response == JOptionPane.YES_OPTION) { + try { + FileOutputStream fos = new FileOutputStream(filename + ".log"); + fos.write(0xEF); + fos.write(0xBB); + fos.write(0xBF); + fos.write(out); + fos.close(); + } catch (IOException e) { + JOptionPane.showMessageDialog(frame, + bundle.getString("GUI.logSaveFailed")); + return; + } + JOptionPane.showMessageDialog(frame, + String.format(bundle.getString("GUI.logSaved"), filename)); + } + } + if (presetMode) { + JOptionPane.showMessageDialog(frame, + bundle.getString("GUI.randomizationDone")); + // Done + if (this.unloadGameOnSuccess) { + romHandler = null; + initialState(); + } else { + reinitializeRomHandler(); + } + } else { + // Compile a config string + try { + String configString = getCurrentSettings().toString(); + // Show the preset maker + new PresetMakeDialog(frame, seed, configString); + } catch (IOException ex) { + JOptionPane.showMessageDialog(frame, + bundle.getString("GUI.cantLoadCustomNames")); + } + + // Done + if (this.unloadGameOnSuccess) { + romHandler = null; + initialState(); + } else { + reinitializeRomHandler(); + } + } + }); + } else { + SwingUtilities.invokeLater(() -> { + opDialog.setVisible(false); + romHandler = null; + initialState(); + }); + } + }); + t.start(); + } catch (Exception ex) { + attemptToLogException(ex, "GUI.saveFailed", "GUI.saveFailedNoLog", settings.toString(), Long.toString(seed)); + if (verboseLog != null) { + verboseLog.close(); + } + } + } + + private void presetLoader() { + PresetLoadDialog pld = new PresetLoadDialog(this,frame); + if (pld.isCompleted()) { + // Apply it + long seed = pld.getSeed(); + String config = pld.getConfigString(); + this.romHandler = pld.getROM(); + if (gameUpdates.containsKey(this.romHandler.getROMCode())) { + this.romHandler.loadGameUpdate(gameUpdates.get(this.romHandler.getROMCode())); + } + this.romLoaded(); + Settings settings; + try { + settings = Settings.fromString(config); + settings.tweakForRom(this.romHandler); + this.restoreStateFromSettings(settings); + } catch (UnsupportedEncodingException | IllegalArgumentException e) { + // settings load failed + e.printStackTrace(); + this.romHandler = null; + initialState(); + } + SaveType outputType = askForSaveType(); + romSaveChooser.setSelectedFile(null); + boolean allowed = false; + File fh = null; + if (outputType == SaveType.FILE) { + romSaveChooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES); + int returnVal = romSaveChooser.showSaveDialog(frame); + if (returnVal == JFileChooser.APPROVE_OPTION) { + fh = romSaveChooser.getSelectedFile(); + // Fix or add extension + List<String> extensions = new ArrayList<>(Arrays.asList("sgb", "gbc", "gba", "nds", "cxi")); + extensions.remove(this.romHandler.getDefaultExtension()); + fh = FileFunctions.fixFilename(fh, this.romHandler.getDefaultExtension(), extensions); + allowed = true; + if (this.romHandler instanceof AbstractDSRomHandler || this.romHandler instanceof Abstract3DSRomHandler) { + String currentFN = this.romHandler.loadedFilename(); + if (currentFN.equals(fh.getAbsolutePath())) { + JOptionPane.showMessageDialog(frame, bundle.getString("GUI.cantOverwriteDS")); + allowed = false; + } + } + } else { + this.romHandler = null; + initialState(); + } + } else if (outputType == SaveType.DIRECTORY) { + romSaveChooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY); + int returnVal = romSaveChooser.showSaveDialog(frame); + if (returnVal == JFileChooser.APPROVE_OPTION) { + fh = romSaveChooser.getSelectedFile(); + allowed = true; + } else { + this.romHandler = null; + initialState(); + } + } + + if (allowed && fh != null) { + // Apply the seed we were given + RandomSource.seed(seed); + presetMode = true; + performRandomization(fh.getAbsolutePath(), seed, pld.getCustomNames(), outputType == SaveType.DIRECTORY); + } + } + + } + + + private enum SaveType { + FILE, DIRECTORY, INVALID + } + + private SaveType askForSaveType() { + SaveType saveType = SaveType.FILE; + if (romHandler.hasGameUpdateLoaded()) { + String text = bundle.getString("GUI.savingWithGameUpdate"); + String url = "https://github.com/Ajarmar/universal-pokemon-randomizer-zx/wiki/Randomizing-the-3DS-games#managing-game-updates"; + showMessageDialogWithLink(text, url); + saveType = SaveType.DIRECTORY; + } else if (romHandler.generationOfPokemon() == 6 || romHandler.generationOfPokemon() == 7) { + Object[] options3DS = {"CXI", "LayeredFS"}; + String question = "Would you like to output your 3DS game as a CXI file or as a LayeredFS directory?"; + JLabel label = new JLabel("<html><a href=\"https://github.com/Ajarmar/universal-pokemon-randomizer-zx/wiki/Randomizing-the-3DS-games#changes-to-saving-a-rom-when-working-with-3ds-games\">For more information, click here.</a>"); + label.addMouseListener(new MouseAdapter() { + @Override + public void mouseClicked(MouseEvent e) { + Desktop desktop = java.awt.Desktop.getDesktop(); + try { + desktop.browse(new URI("https://github.com/Ajarmar/universal-pokemon-randomizer-zx/wiki/Randomizing-the-3DS-games#changes-to-saving-a-rom-when-working-with-3ds-games")); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + }); + label.setCursor(new java.awt.Cursor(Cursor.HAND_CURSOR)); + Object[] messages = {question,label}; + int returnVal3DS = JOptionPane.showOptionDialog(frame, + messages, + "3DS Output Choice", + JOptionPane.YES_NO_OPTION, + JOptionPane.QUESTION_MESSAGE, + null, + options3DS, + null); + if (returnVal3DS < 0) { + saveType = SaveType.INVALID; + } else { + saveType = SaveType.values()[returnVal3DS]; + } + } + return saveType; + } + + private void applyGameUpdateMenuItemActionPerformed() { + + if (romHandler == null) return; + + gameUpdateChooser.setSelectedFile(null); + gameUpdateChooser.setFileFilter(new GameUpdateFilter()); + int returnVal = gameUpdateChooser.showOpenDialog(frame); + if (returnVal == JFileChooser.APPROVE_OPTION) { + File fh = gameUpdateChooser.getSelectedFile(); + + // On the 3DS, the update has the same title ID as the base game, save for the 8th character, + // which is 'E' instead of '0'. We can use this to detect if the update matches the game. + String actualUpdateTitleId = Abstract3DSRomHandler.getTitleIdFromFile(fh.getAbsolutePath()); + if (actualUpdateTitleId == null) { + // Error: couldn't find a title ID in the update + JOptionPane.showMessageDialog(frame, String.format(bundle.getString("GUI.invalidGameUpdate"), fh.getName())); + return; + } + Abstract3DSRomHandler ctrRomHandler = (Abstract3DSRomHandler) romHandler; + String baseGameTitleId = ctrRomHandler.getTitleIdFromLoadedROM(); + char[] baseGameTitleIdChars = baseGameTitleId.toCharArray(); + baseGameTitleIdChars[7] = 'E'; + String expectedUpdateTitleId = String.valueOf(baseGameTitleIdChars); + if (actualUpdateTitleId.equals(expectedUpdateTitleId)) { + try { + romHandler.loadGameUpdate(fh.getAbsolutePath()); + } catch (EncryptedROMException ex) { + JOptionPane.showMessageDialog(mainPanel, + String.format(bundle.getString("GUI.encryptedRom"), fh.getAbsolutePath())); + return; + } + gameUpdates.put(romHandler.getROMCode(), fh.getAbsolutePath()); + attemptWriteConfig(); + setRomNameLabel(); + String text = String.format(bundle.getString("GUI.gameUpdateApplied"), romHandler.getROMName()); + String url = "https://github.com/Ajarmar/universal-pokemon-randomizer-zx/wiki/Randomizing-the-3DS-games#3ds-game-updates"; + showMessageDialogWithLink(text, url); + } else { + // Error: update is not for the correct game + JOptionPane.showMessageDialog(frame, String.format(bundle.getString("GUI.nonMatchingGameUpdate"), fh.getName(), romHandler.getROMName())); + } + } + } + + private void loadGetSettingsMenuItemActionPerformed() { + + if (romHandler == null) return; + + String currentSettingsString = "Current Settings String:"; + JTextField currentSettingsStringField = new JTextField(); + currentSettingsStringField.setEditable(false); + try { + String theSettingsString = Version.VERSION + getCurrentSettings().toString(); + currentSettingsStringField.setColumns(Settings.LENGTH_OF_SETTINGS_DATA * 2); + currentSettingsStringField.setText(theSettingsString); + } catch (IOException e) { + e.printStackTrace(); + } + String loadSettingsString = "Load Settings String:"; + JTextField loadSettingsStringField = new JTextField(); + Object[] messages = {currentSettingsString,currentSettingsStringField,loadSettingsString,loadSettingsStringField}; + Object[] options = {"Load","Cancel"}; + int choice = JOptionPane.showOptionDialog( + frame, + messages, + "Get/Load Settings String", + JOptionPane.YES_NO_OPTION, + JOptionPane.QUESTION_MESSAGE, + null, + options, + null + ); + if (choice == 0) { + String configString = loadSettingsStringField.getText().trim(); + if (configString.length() > 0) { + if (configString.length() < 3) { + JOptionPane.showMessageDialog(frame,bundle.getString("GUI.invalidSettingsString")); + } else { + try { + int settingsStringVersionNumber = Integer.parseInt(configString.substring(0, 3)); + if (settingsStringVersionNumber < Version.VERSION) { + JOptionPane.showMessageDialog(frame,bundle.getString("GUI.settingsStringOlder")); + String updatedSettingsString = new SettingsUpdater().update(settingsStringVersionNumber, configString.substring(3)); + Settings settings = Settings.fromString(updatedSettingsString); + settings.tweakForRom(this.romHandler); + restoreStateFromSettings(settings); + JOptionPane.showMessageDialog(frame,bundle.getString("GUI.settingsStringLoaded")); + } else if (settingsStringVersionNumber > Version.VERSION) { + JOptionPane.showMessageDialog(frame,bundle.getString("GUI.settingsStringTooNew")); + } else { + Settings settings = Settings.fromString(configString.substring(3)); + settings.tweakForRom(this.romHandler); + restoreStateFromSettings(settings); + JOptionPane.showMessageDialog(frame,bundle.getString("GUI.settingsStringLoaded")); + } + } catch (UnsupportedEncodingException | IllegalArgumentException ex) { + JOptionPane.showMessageDialog(frame,bundle.getString("GUI.invalidSettingsString")); + } + } + + } + } + } + + private void keepOrUnloadGameAfterRandomizingMenuItemActionPerformed() { + this.unloadGameOnSuccess = !this.unloadGameOnSuccess; + if (this.unloadGameOnSuccess) { + JOptionPane.showMessageDialog(frame, bundle.getString("GUI.unloadGameAfterRandomizing")); + keepOrUnloadGameAfterRandomizingMenuItem.setText(bundle.getString("GUI.keepGameLoadedAfterRandomizingMenuItem.text")); + } else { + JOptionPane.showMessageDialog(frame, bundle.getString("GUI.keepGameLoadedAfterRandomizing")); + keepOrUnloadGameAfterRandomizingMenuItem.setText(bundle.getString("GUI.unloadGameAfterRandomizingMenuItem.text")); + } + attemptWriteConfig(); + } + + private void showMessageDialogWithLink(String text, String url) { + JLabel label = new JLabel("<html><a href=\"" + url + "\">For more information, click here.</a>"); + label.addMouseListener(new MouseAdapter() { + @Override + public void mouseClicked(MouseEvent e) { + Desktop desktop = java.awt.Desktop.getDesktop(); + try { + desktop.browse(new URI(url)); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + }); + label.setCursor(new java.awt.Cursor(Cursor.HAND_CURSOR)); + Object[] messages = {text,label}; + JOptionPane.showMessageDialog(frame, messages); + } + + // This is only intended to be used with the "Keep Game Loaded After Randomizing" setting; it assumes that + // the game has already been loaded once, and we just need to reload the same game to reinitialize the + // RomHandler. Don't use this for other purposes unless you know what you're doing. + private void reinitializeRomHandler() { + String currentFN = this.romHandler.loadedFilename(); + for (RomHandler.Factory rhf : checkHandlers) { + if (rhf.isLoadable(currentFN)) { + this.romHandler = rhf.create(RandomSource.instance()); + opDialog = new OperationDialog(bundle.getString("GUI.loadingText"), frame, true); + Thread t = new Thread(() -> { + SwingUtilities.invokeLater(() -> opDialog.setVisible(true)); + try { + this.romHandler.loadRom(currentFN); + if (gameUpdates.containsKey(this.romHandler.getROMCode())) { + this.romHandler.loadGameUpdate(gameUpdates.get(this.romHandler.getROMCode())); + } + } catch (Exception ex) { + attemptToLogException(ex, "GUI.loadFailed", "GUI.loadFailedNoLog", null, null); + } + SwingUtilities.invokeLater(() -> { + this.opDialog.setVisible(false); + }); + }); + t.start(); + + return; + } + } + } + + private void restoreStateFromSettings(Settings settings) { + + limitPokemonCheckBox.setSelected(settings.isLimitPokemon()); + currentRestrictions = settings.getCurrentRestrictions(); + if (currentRestrictions != null) { + currentRestrictions.limitToGen(romHandler.generationOfPokemon()); + } + noIrregularAltFormesCheckBox.setSelected(settings.isBanIrregularAltFormes()); + raceModeCheckBox.setSelected(settings.isRaceMode()); + + peChangeImpossibleEvosCheckBox.setSelected(settings.isChangeImpossibleEvolutions()); + mdUpdateMovesCheckBox.setSelected(settings.isUpdateMoves()); + mdUpdateComboBox.setSelectedIndex(Math.max(0,settings.getUpdateMovesToGeneration() - (romHandler.generationOfPokemon()+1))); + tpRandomizeTrainerNamesCheckBox.setSelected(settings.isRandomizeTrainerNames()); + tpRandomizeTrainerClassNamesCheckBox.setSelected(settings.isRandomizeTrainerClassNames()); + ptIsDualTypeCheckBox.setSelected(settings.isDualTypeOnly()); + + pbsRandomRadioButton.setSelected(settings.getBaseStatisticsMod() == Settings.BaseStatisticsMod.RANDOM); + pbsShuffleRadioButton.setSelected(settings.getBaseStatisticsMod() == Settings.BaseStatisticsMod.SHUFFLE); + pbsUnchangedRadioButton.setSelected(settings.getBaseStatisticsMod() == Settings.BaseStatisticsMod.UNCHANGED); + pbsFollowEvolutionsCheckBox.setSelected(settings.isBaseStatsFollowEvolutions()); + pbsUpdateBaseStatsCheckBox.setSelected(settings.isUpdateBaseStats()); + pbsUpdateComboBox.setSelectedIndex(Math.max(0,settings.getUpdateBaseStatsToGeneration() - (Math.max(6,romHandler.generationOfPokemon()+1)))); + pbsStandardizeEXPCurvesCheckBox.setSelected(settings.isStandardizeEXPCurves()); + pbsLegendariesSlowRadioButton.setSelected(settings.getExpCurveMod() == Settings.ExpCurveMod.LEGENDARIES); + pbsStrongLegendariesSlowRadioButton.setSelected(settings.getExpCurveMod() == Settings.ExpCurveMod.STRONG_LEGENDARIES); + pbsAllMediumFastRadioButton.setSelected(settings.getExpCurveMod() == Settings.ExpCurveMod.ALL); + ExpCurve[] expCurves = getEXPCurvesForGeneration(romHandler.generationOfPokemon()); + int index = 0; + for (int i = 0; i < expCurves.length; i++) { + if (expCurves[i] == settings.getSelectedEXPCurve()) { + index = i; + } + } + pbsEXPCurveComboBox.setSelectedIndex(index); + pbsFollowMegaEvosCheckBox.setSelected(settings.isBaseStatsFollowMegaEvolutions()); + pbsAssignEvoStatsRandomlyCheckBox.setSelected(settings.isAssignEvoStatsRandomly()); + + paUnchangedRadioButton.setSelected(settings.getAbilitiesMod() == Settings.AbilitiesMod.UNCHANGED); + paRandomRadioButton.setSelected(settings.getAbilitiesMod() == Settings.AbilitiesMod.RANDOMIZE); + paAllowWonderGuardCheckBox.setSelected(settings.isAllowWonderGuard()); + paFollowEvolutionsCheckBox.setSelected(settings.isAbilitiesFollowEvolutions()); + paTrappingAbilitiesCheckBox.setSelected(settings.isBanTrappingAbilities()); + paNegativeAbilitiesCheckBox.setSelected(settings.isBanNegativeAbilities()); + paBadAbilitiesCheckBox.setSelected(settings.isBanBadAbilities()); + paFollowMegaEvosCheckBox.setSelected(settings.isAbilitiesFollowMegaEvolutions()); + paWeighDuplicatesTogetherCheckBox.setSelected(settings.isWeighDuplicateAbilitiesTogether()); + + ptRandomFollowEvolutionsRadioButton.setSelected(settings.getTypesMod() == Settings.TypesMod.RANDOM_FOLLOW_EVOLUTIONS); + ptRandomCompletelyRadioButton.setSelected(settings.getTypesMod() == Settings.TypesMod.COMPLETELY_RANDOM); + ptUnchangedRadioButton.setSelected(settings.getTypesMod() == Settings.TypesMod.UNCHANGED); + ptFollowMegaEvosCheckBox.setSelected(settings.isTypesFollowMegaEvolutions()); + pmsNoGameBreakingMovesCheckBox.setSelected(settings.doBlockBrokenMoves()); + + peMakeEvolutionsEasierCheckBox.setSelected(settings.isMakeEvolutionsEasier()); + peRemoveTimeBasedEvolutionsCheckBox.setSelected(settings.isRemoveTimeBasedEvolutions()); + + spCustomRadioButton.setSelected(settings.getStartersMod() == Settings.StartersMod.CUSTOM); + spRandomCompletelyRadioButton.setSelected(settings.getStartersMod() == Settings.StartersMod.COMPLETELY_RANDOM); + spUnchangedRadioButton.setSelected(settings.getStartersMod() == Settings.StartersMod.UNCHANGED); + spRandomTwoEvosRadioButton.setSelected(settings.getStartersMod() == Settings.StartersMod.RANDOM_WITH_TWO_EVOLUTIONS); + spRandomizeStarterHeldItemsCheckBox.setSelected(settings.isRandomizeStartersHeldItems()); + spBanBadItemsCheckBox.setSelected(settings.isBanBadRandomStarterHeldItems()); + spAllowAltFormesCheckBox.setSelected(settings.isAllowStarterAltFormes()); + + int[] customStarters = settings.getCustomStarters(); + spComboBox1.setSelectedIndex(customStarters[0] - 1); + spComboBox2.setSelectedIndex(customStarters[1] - 1); + spComboBox3.setSelectedIndex(customStarters[2] - 1); + + peUnchangedRadioButton.setSelected(settings.getEvolutionsMod() == Settings.EvolutionsMod.UNCHANGED); + peRandomRadioButton.setSelected(settings.getEvolutionsMod() == Settings.EvolutionsMod.RANDOM); + peRandomEveryLevelRadioButton.setSelected(settings.getEvolutionsMod() == Settings.EvolutionsMod.RANDOM_EVERY_LEVEL); + peSimilarStrengthCheckBox.setSelected(settings.isEvosSimilarStrength()); + peSameTypingCheckBox.setSelected(settings.isEvosSameTyping()); + peLimitEvolutionsToThreeCheckBox.setSelected(settings.isEvosMaxThreeStages()); + peForceChangeCheckBox.setSelected(settings.isEvosForceChange()); + peAllowAltFormesCheckBox.setSelected(settings.isEvosAllowAltFormes()); + + mdRandomizeMoveAccuracyCheckBox.setSelected(settings.isRandomizeMoveAccuracies()); + mdRandomizeMoveCategoryCheckBox.setSelected(settings.isRandomizeMoveCategory()); + mdRandomizeMovePowerCheckBox.setSelected(settings.isRandomizeMovePowers()); + mdRandomizeMovePPCheckBox.setSelected(settings.isRandomizeMovePPs()); + mdRandomizeMoveTypesCheckBox.setSelected(settings.isRandomizeMoveTypes()); + + pmsRandomCompletelyRadioButton.setSelected(settings.getMovesetsMod() == Settings.MovesetsMod.COMPLETELY_RANDOM); + pmsRandomPreferringSameTypeRadioButton.setSelected(settings.getMovesetsMod() == Settings.MovesetsMod.RANDOM_PREFER_SAME_TYPE); + pmsUnchangedRadioButton.setSelected(settings.getMovesetsMod() == Settings.MovesetsMod.UNCHANGED); + pmsMetronomeOnlyModeRadioButton.setSelected(settings.getMovesetsMod() == Settings.MovesetsMod.METRONOME_ONLY); + pmsGuaranteedLevel1MovesCheckBox.setSelected(settings.isStartWithGuaranteedMoves()); + pmsGuaranteedLevel1MovesSlider.setValue(settings.getGuaranteedMoveCount()); + pmsReorderDamagingMovesCheckBox.setSelected(settings.isReorderDamagingMoves()); + pmsForceGoodDamagingCheckBox.setSelected(settings.isMovesetsForceGoodDamaging()); + pmsForceGoodDamagingSlider.setValue(settings.getMovesetsGoodDamagingPercent()); + pmsNoGameBreakingMovesCheckBox.setSelected(settings.isBlockBrokenMovesetMoves()); + pmsEvolutionMovesCheckBox.setSelected(settings.isEvolutionMovesForAll()); + + tpSimilarStrengthCheckBox.setSelected(settings.isTrainersUsePokemonOfSimilarStrength()); + tpComboBox.setSelectedItem(trainerSettings.get(settings.getTrainersMod().ordinal())); + tpRivalCarriesStarterCheckBox.setSelected(settings.isRivalCarriesStarterThroughout()); + tpWeightTypesCheckBox.setSelected(settings.isTrainersMatchTypingDistribution()); + tpDontUseLegendariesCheckBox.setSelected(settings.isTrainersBlockLegendaries()); + tpNoEarlyWonderGuardCheckBox.setSelected(settings.isTrainersBlockEarlyWonderGuard()); + tpForceFullyEvolvedAtCheckBox.setSelected(settings.isTrainersForceFullyEvolved()); + tpForceFullyEvolvedAtSlider.setValue(settings.getTrainersForceFullyEvolvedLevel()); + tpPercentageLevelModifierCheckBox.setSelected(settings.isTrainersLevelModified()); + tpPercentageLevelModifierSlider.setValue(settings.getTrainersLevelModifier()); + tpEliteFourUniquePokemonCheckBox.setSelected(settings.getEliteFourUniquePokemonNumber() > 0); + tpEliteFourUniquePokemonSpinner.setValue(settings.getEliteFourUniquePokemonNumber() > 0 ? settings.getEliteFourUniquePokemonNumber() : 1); + tpAllowAlternateFormesCheckBox.setSelected(settings.isAllowTrainerAlternateFormes()); + tpSwapMegaEvosCheckBox.setSelected(settings.isSwapTrainerMegaEvos()); + tpDoubleBattleModeCheckBox.setSelected(settings.isDoubleBattleMode()); + tpBossTrainersCheckBox.setSelected(settings.getAdditionalBossTrainerPokemon() > 0); + tpBossTrainersSpinner.setValue(settings.getAdditionalBossTrainerPokemon() > 0 ? settings.getAdditionalBossTrainerPokemon() : 1); + tpImportantTrainersCheckBox.setSelected(settings.getAdditionalImportantTrainerPokemon() > 0); + tpImportantTrainersSpinner.setValue(settings.getAdditionalImportantTrainerPokemon() > 0 ? settings.getAdditionalImportantTrainerPokemon() : 1); + tpRegularTrainersCheckBox.setSelected(settings.getAdditionalRegularTrainerPokemon() > 0); + tpRegularTrainersSpinner.setValue(settings.getAdditionalRegularTrainerPokemon() > 0 ? settings.getAdditionalRegularTrainerPokemon() : 1); + tpBossTrainersItemsCheckBox.setSelected(settings.isRandomizeHeldItemsForBossTrainerPokemon()); + tpImportantTrainersItemsCheckBox.setSelected(settings.isRandomizeHeldItemsForImportantTrainerPokemon()); + tpRegularTrainersItemsCheckBox.setSelected(settings.isRandomizeHeldItemsForRegularTrainerPokemon()); + tpConsumableItemsOnlyCheckBox.setSelected(settings.isConsumableItemsOnlyForTrainers()); + tpSensibleItemsCheckBox.setSelected(settings.isSensibleItemsOnlyForTrainers()); + tpHighestLevelGetsItemCheckBox.setSelected(settings.isHighestLevelGetsItemsForTrainers()); + + tpRandomShinyTrainerPokemonCheckBox.setSelected(settings.isShinyChance()); + + totpUnchangedRadioButton.setSelected(settings.getTotemPokemonMod() == Settings.TotemPokemonMod.UNCHANGED); + totpRandomRadioButton.setSelected(settings.getTotemPokemonMod() == Settings.TotemPokemonMod.RANDOM); + totpRandomSimilarStrengthRadioButton.setSelected(settings.getTotemPokemonMod() == Settings.TotemPokemonMod.SIMILAR_STRENGTH); + totpAllyUnchangedRadioButton.setSelected(settings.getAllyPokemonMod() == Settings.AllyPokemonMod.UNCHANGED); + totpAllyRandomRadioButton.setSelected(settings.getAllyPokemonMod() == Settings.AllyPokemonMod.RANDOM); + totpAllyRandomSimilarStrengthRadioButton.setSelected(settings.getAllyPokemonMod() == Settings.AllyPokemonMod.SIMILAR_STRENGTH); + totpAuraUnchangedRadioButton.setSelected(settings.getAuraMod() == Settings.AuraMod.UNCHANGED); + totpAuraRandomRadioButton.setSelected(settings.getAuraMod() == Settings.AuraMod.RANDOM); + totpAuraRandomSameStrengthRadioButton.setSelected(settings.getAuraMod() == Settings.AuraMod.SAME_STRENGTH); + totpRandomizeHeldItemsCheckBox.setSelected(settings.isRandomizeTotemHeldItems()); + totpAllowAltFormesCheckBox.setSelected(settings.isAllowTotemAltFormes()); + totpPercentageLevelModifierCheckBox.setSelected(settings.isTotemLevelsModified()); + totpPercentageLevelModifierSlider.setValue(settings.getTotemLevelModifier()); + + wpARCatchEmAllModeRadioButton + .setSelected(settings.getWildPokemonRestrictionMod() == Settings.WildPokemonRestrictionMod.CATCH_EM_ALL); + wpArea1To1RadioButton.setSelected(settings.getWildPokemonMod() == Settings.WildPokemonMod.AREA_MAPPING); + wpARNoneRadioButton.setSelected(settings.getWildPokemonRestrictionMod() == Settings.WildPokemonRestrictionMod.NONE); + wpARTypeThemeAreasRadioButton + .setSelected(settings.getWildPokemonRestrictionMod() == Settings.WildPokemonRestrictionMod.TYPE_THEME_AREAS); + wpGlobal1To1RadioButton.setSelected(settings.getWildPokemonMod() == Settings.WildPokemonMod.GLOBAL_MAPPING); + wpRandomRadioButton.setSelected(settings.getWildPokemonMod() == Settings.WildPokemonMod.RANDOM); + wpUnchangedRadioButton.setSelected(settings.getWildPokemonMod() == Settings.WildPokemonMod.UNCHANGED); + wpUseTimeBasedEncountersCheckBox.setSelected(settings.isUseTimeBasedEncounters()); + + wpSetMinimumCatchRateCheckBox.setSelected(settings.isUseMinimumCatchRate()); + wpSetMinimumCatchRateSlider.setValue(settings.getMinimumCatchRateLevel()); + wpDontUseLegendariesCheckBox.setSelected(settings.isBlockWildLegendaries()); + wpARSimilarStrengthRadioButton + .setSelected(settings.getWildPokemonRestrictionMod() == Settings.WildPokemonRestrictionMod.SIMILAR_STRENGTH); + wpRandomizeHeldItemsCheckBox.setSelected(settings.isRandomizeWildPokemonHeldItems()); + wpBanBadItemsCheckBox.setSelected(settings.isBanBadRandomWildPokemonHeldItems()); + wpBalanceShakingGrassPokemonCheckBox.setSelected(settings.isBalanceShakingGrass()); + wpPercentageLevelModifierCheckBox.setSelected(settings.isWildLevelsModified()); + wpPercentageLevelModifierSlider.setValue(settings.getWildLevelModifier()); + wpAllowAltFormesCheckBox.setSelected(settings.isAllowWildAltFormes()); + + stpUnchangedRadioButton.setSelected(settings.getStaticPokemonMod() == Settings.StaticPokemonMod.UNCHANGED); + stpSwapLegendariesSwapStandardsRadioButton.setSelected(settings.getStaticPokemonMod() == Settings.StaticPokemonMod.RANDOM_MATCHING); + stpRandomCompletelyRadioButton + .setSelected(settings.getStaticPokemonMod() == Settings.StaticPokemonMod.COMPLETELY_RANDOM); + stpRandomSimilarStrengthRadioButton + .setSelected(settings.getStaticPokemonMod() == Settings.StaticPokemonMod.SIMILAR_STRENGTH); + stpLimitMainGameLegendariesCheckBox.setSelected(settings.isLimitMainGameLegendaries()); + stpRandomize600BSTCheckBox.setSelected(settings.isLimit600()); + stpAllowAltFormesCheckBox.setSelected(settings.isAllowStaticAltFormes()); + stpSwapMegaEvosCheckBox.setSelected(settings.isSwapStaticMegaEvos()); + stpPercentageLevelModifierCheckBox.setSelected(settings.isStaticLevelModified()); + stpPercentageLevelModifierSlider.setValue(settings.getStaticLevelModifier()); + stpFixMusicCheckBox.setSelected(settings.isCorrectStaticMusic()); + + thcRandomCompletelyRadioButton + .setSelected(settings.getTmsHmsCompatibilityMod() == Settings.TMsHMsCompatibilityMod.COMPLETELY_RANDOM); + thcRandomPreferSameTypeRadioButton + .setSelected(settings.getTmsHmsCompatibilityMod() == Settings.TMsHMsCompatibilityMod.RANDOM_PREFER_TYPE); + thcUnchangedRadioButton + .setSelected(settings.getTmsHmsCompatibilityMod() == Settings.TMsHMsCompatibilityMod.UNCHANGED); + tmRandomRadioButton.setSelected(settings.getTmsMod() == Settings.TMsMod.RANDOM); + tmUnchangedRadioButton.setSelected(settings.getTmsMod() == Settings.TMsMod.UNCHANGED); + tmLevelupMoveSanityCheckBox.setSelected(settings.isTmLevelUpMoveSanity()); + tmKeepFieldMoveTMsCheckBox.setSelected(settings.isKeepFieldMoveTMs()); + thcFullCompatibilityRadioButton.setSelected(settings.getTmsHmsCompatibilityMod() == Settings.TMsHMsCompatibilityMod.FULL); + tmFullHMCompatibilityCheckBox.setSelected(settings.isFullHMCompat()); + tmForceGoodDamagingCheckBox.setSelected(settings.isTmsForceGoodDamaging()); + tmForceGoodDamagingSlider.setValue(settings.getTmsGoodDamagingPercent()); + tmNoGameBreakingMovesCheckBox.setSelected(settings.isBlockBrokenTMMoves()); + tmFollowEvolutionsCheckBox.setSelected(settings.isTmsFollowEvolutions()); + + mtcRandomCompletelyRadioButton + .setSelected(settings.getMoveTutorsCompatibilityMod() == Settings.MoveTutorsCompatibilityMod.COMPLETELY_RANDOM); + mtcRandomPreferSameTypeRadioButton + .setSelected(settings.getMoveTutorsCompatibilityMod() == Settings.MoveTutorsCompatibilityMod.RANDOM_PREFER_TYPE); + mtcUnchangedRadioButton + .setSelected(settings.getMoveTutorsCompatibilityMod() == Settings.MoveTutorsCompatibilityMod.UNCHANGED); + mtRandomRadioButton.setSelected(settings.getMoveTutorMovesMod() == Settings.MoveTutorMovesMod.RANDOM); + mtUnchangedRadioButton.setSelected(settings.getMoveTutorMovesMod() == Settings.MoveTutorMovesMod.UNCHANGED); + mtLevelupMoveSanityCheckBox.setSelected(settings.isTutorLevelUpMoveSanity()); + mtKeepFieldMoveTutorsCheckBox.setSelected(settings.isKeepFieldMoveTutors()); + mtcFullCompatibilityRadioButton + .setSelected(settings.getMoveTutorsCompatibilityMod() == Settings.MoveTutorsCompatibilityMod.FULL); + mtForceGoodDamagingCheckBox.setSelected(settings.isTutorsForceGoodDamaging()); + mtForceGoodDamagingSlider.setValue(settings.getTutorsGoodDamagingPercent()); + mtNoGameBreakingMovesCheckBox.setSelected(settings.isBlockBrokenTutorMoves()); + mtFollowEvolutionsCheckBox.setSelected(settings.isTutorFollowEvolutions()); + + igtRandomizeBothRequestedGivenRadioButton + .setSelected(settings.getInGameTradesMod() == Settings.InGameTradesMod.RANDOMIZE_GIVEN_AND_REQUESTED); + igtRandomizeGivenPokemonOnlyRadioButton.setSelected(settings.getInGameTradesMod() == Settings.InGameTradesMod.RANDOMIZE_GIVEN); + igtRandomizeItemsCheckBox.setSelected(settings.isRandomizeInGameTradesItems()); + igtRandomizeIVsCheckBox.setSelected(settings.isRandomizeInGameTradesIVs()); + igtRandomizeNicknamesCheckBox.setSelected(settings.isRandomizeInGameTradesNicknames()); + igtRandomizeOTsCheckBox.setSelected(settings.isRandomizeInGameTradesOTs()); + igtUnchangedRadioButton.setSelected(settings.getInGameTradesMod() == Settings.InGameTradesMod.UNCHANGED); + + fiRandomRadioButton.setSelected(settings.getFieldItemsMod() == Settings.FieldItemsMod.RANDOM); + fiRandomEvenDistributionRadioButton.setSelected(settings.getFieldItemsMod() == Settings.FieldItemsMod.RANDOM_EVEN); + fiShuffleRadioButton.setSelected(settings.getFieldItemsMod() == Settings.FieldItemsMod.SHUFFLE); + fiUnchangedRadioButton.setSelected(settings.getFieldItemsMod() == Settings.FieldItemsMod.UNCHANGED); + fiBanBadItemsCheckBox.setSelected(settings.isBanBadRandomFieldItems()); + + shRandomRadioButton.setSelected(settings.getShopItemsMod() == Settings.ShopItemsMod.RANDOM); + shShuffleRadioButton.setSelected(settings.getShopItemsMod() == Settings.ShopItemsMod.SHUFFLE); + shUnchangedRadioButton.setSelected(settings.getShopItemsMod() == Settings.ShopItemsMod.UNCHANGED); + shBanBadItemsCheckBox.setSelected(settings.isBanBadRandomShopItems()); + shBanRegularShopItemsCheckBox.setSelected(settings.isBanRegularShopItems()); + shBanOverpoweredShopItemsCheckBox.setSelected(settings.isBanOPShopItems()); + shBalanceShopItemPricesCheckBox.setSelected(settings.isBalanceShopPrices()); + shGuaranteeEvolutionItemsCheckBox.setSelected(settings.isGuaranteeEvolutionItems()); + shGuaranteeXItemsCheckBox.setSelected(settings.isGuaranteeXItems()); + + puUnchangedRadioButton.setSelected(settings.getPickupItemsMod() == Settings.PickupItemsMod.UNCHANGED); + puRandomRadioButton.setSelected(settings.getPickupItemsMod() == Settings.PickupItemsMod.RANDOM); + puBanBadItemsCheckBox.setSelected(settings.isBanBadRandomPickupItems()); + + int mtsSelected = settings.getCurrentMiscTweaks(); + int mtCount = MiscTweak.allTweaks.size(); + + for (int mti = 0; mti < mtCount; mti++) { + MiscTweak mt = MiscTweak.allTweaks.get(mti); + JCheckBox mtCB = tweakCheckBoxes.get(mti); + mtCB.setSelected((mtsSelected & mt.getValue()) != 0); + } + + this.enableOrDisableSubControls(); + } + + private Settings createSettingsFromState(CustomNamesSet customNames) { + Settings settings = new Settings(); + settings.setRomName(this.romHandler.getROMName()); + + settings.setLimitPokemon(limitPokemonCheckBox.isSelected() && limitPokemonCheckBox.isVisible()); + settings.setCurrentRestrictions(currentRestrictions); + settings.setBanIrregularAltFormes(noIrregularAltFormesCheckBox.isSelected() && noIrregularAltFormesCheckBox.isVisible()); + settings.setRaceMode(raceModeCheckBox.isSelected()); + + settings.setChangeImpossibleEvolutions(peChangeImpossibleEvosCheckBox.isSelected() && peChangeImpossibleEvosCheckBox.isVisible()); + settings.setUpdateMoves(mdUpdateMovesCheckBox.isSelected() && mdUpdateMovesCheckBox.isVisible()); + settings.setUpdateMovesToGeneration(mdUpdateComboBox.getSelectedIndex() + (romHandler.generationOfPokemon()+1)); + settings.setRandomizeTrainerNames(tpRandomizeTrainerNamesCheckBox.isSelected()); + settings.setRandomizeTrainerClassNames(tpRandomizeTrainerClassNamesCheckBox.isSelected()); + + settings.setBaseStatisticsMod(pbsUnchangedRadioButton.isSelected(), pbsShuffleRadioButton.isSelected(), + pbsRandomRadioButton.isSelected()); + settings.setBaseStatsFollowEvolutions(pbsFollowEvolutionsCheckBox.isSelected()); + settings.setUpdateBaseStats(pbsUpdateBaseStatsCheckBox.isSelected() && pbsUpdateBaseStatsCheckBox.isVisible()); + settings.setUpdateBaseStatsToGeneration(pbsUpdateComboBox.getSelectedIndex() + (Math.max(6,romHandler.generationOfPokemon()+1))); + settings.setStandardizeEXPCurves(pbsStandardizeEXPCurvesCheckBox.isSelected()); + settings.setExpCurveMod(pbsLegendariesSlowRadioButton.isSelected(), pbsStrongLegendariesSlowRadioButton.isSelected(), + pbsAllMediumFastRadioButton.isSelected()); + ExpCurve[] expCurves = getEXPCurvesForGeneration(romHandler.generationOfPokemon()); + settings.setSelectedEXPCurve(expCurves[pbsEXPCurveComboBox.getSelectedIndex()]); + settings.setBaseStatsFollowMegaEvolutions(pbsFollowMegaEvosCheckBox.isSelected() && pbsFollowMegaEvosCheckBox.isVisible()); + settings.setAssignEvoStatsRandomly(pbsAssignEvoStatsRandomlyCheckBox.isSelected() && pbsAssignEvoStatsRandomlyCheckBox.isVisible()); + + settings.setAbilitiesMod(paUnchangedRadioButton.isSelected(), paRandomRadioButton.isSelected()); + settings.setAllowWonderGuard(paAllowWonderGuardCheckBox.isSelected()); + settings.setAbilitiesFollowEvolutions(paFollowEvolutionsCheckBox.isSelected()); + settings.setBanTrappingAbilities(paTrappingAbilitiesCheckBox.isSelected()); + settings.setBanNegativeAbilities(paNegativeAbilitiesCheckBox.isSelected()); + settings.setBanBadAbilities(paBadAbilitiesCheckBox.isSelected()); + settings.setAbilitiesFollowMegaEvolutions(paFollowMegaEvosCheckBox.isSelected()); + settings.setWeighDuplicateAbilitiesTogether(paWeighDuplicatesTogetherCheckBox.isSelected()); + + settings.setTypesMod(ptUnchangedRadioButton.isSelected(), ptRandomFollowEvolutionsRadioButton.isSelected(), + ptRandomCompletelyRadioButton.isSelected()); + settings.setTypesFollowMegaEvolutions(ptFollowMegaEvosCheckBox.isSelected() && ptFollowMegaEvosCheckBox.isVisible()); + settings.setBlockBrokenMovesetMoves(pmsNoGameBreakingMovesCheckBox.isSelected()); + settings.setDualTypeOnly(ptIsDualTypeCheckBox.isSelected()); + + settings.setMakeEvolutionsEasier(peMakeEvolutionsEasierCheckBox.isSelected()); + settings.setRemoveTimeBasedEvolutions(peRemoveTimeBasedEvolutionsCheckBox.isSelected()); + + settings.setStartersMod(spUnchangedRadioButton.isSelected(), spCustomRadioButton.isSelected(), spRandomCompletelyRadioButton.isSelected(), + spRandomTwoEvosRadioButton.isSelected()); + settings.setRandomizeStartersHeldItems(spRandomizeStarterHeldItemsCheckBox.isSelected() && spRandomizeStarterHeldItemsCheckBox.isVisible()); + settings.setBanBadRandomStarterHeldItems(spBanBadItemsCheckBox.isSelected() && spBanBadItemsCheckBox.isVisible()); + settings.setAllowStarterAltFormes(spAllowAltFormesCheckBox.isSelected() && spAllowAltFormesCheckBox.isVisible()); + + int[] customStarters = new int[] { spComboBox1.getSelectedIndex() + 1, + spComboBox2.getSelectedIndex() + 1, spComboBox3.getSelectedIndex() + 1 }; + settings.setCustomStarters(customStarters); + + settings.setEvolutionsMod(peUnchangedRadioButton.isSelected(), peRandomRadioButton.isSelected(), peRandomEveryLevelRadioButton.isSelected()); + settings.setEvosSimilarStrength(peSimilarStrengthCheckBox.isSelected()); + settings.setEvosSameTyping(peSameTypingCheckBox.isSelected()); + settings.setEvosMaxThreeStages(peLimitEvolutionsToThreeCheckBox.isSelected()); + settings.setEvosForceChange(peForceChangeCheckBox.isSelected()); + settings.setEvosAllowAltFormes(peAllowAltFormesCheckBox.isSelected() && peAllowAltFormesCheckBox.isVisible()); + + settings.setRandomizeMoveAccuracies(mdRandomizeMoveAccuracyCheckBox.isSelected()); + settings.setRandomizeMoveCategory(mdRandomizeMoveCategoryCheckBox.isSelected()); + settings.setRandomizeMovePowers(mdRandomizeMovePowerCheckBox.isSelected()); + settings.setRandomizeMovePPs(mdRandomizeMovePPCheckBox.isSelected()); + settings.setRandomizeMoveTypes(mdRandomizeMoveTypesCheckBox.isSelected()); + + settings.setMovesetsMod(pmsUnchangedRadioButton.isSelected(), pmsRandomPreferringSameTypeRadioButton.isSelected(), + pmsRandomCompletelyRadioButton.isSelected(), pmsMetronomeOnlyModeRadioButton.isSelected()); + settings.setStartWithGuaranteedMoves(pmsGuaranteedLevel1MovesCheckBox.isSelected() && pmsGuaranteedLevel1MovesCheckBox.isVisible()); + settings.setGuaranteedMoveCount(pmsGuaranteedLevel1MovesSlider.getValue()); + settings.setReorderDamagingMoves(pmsReorderDamagingMovesCheckBox.isSelected()); + + settings.setMovesetsForceGoodDamaging(pmsForceGoodDamagingCheckBox.isSelected()); + settings.setMovesetsGoodDamagingPercent(pmsForceGoodDamagingSlider.getValue()); + settings.setBlockBrokenMovesetMoves(pmsNoGameBreakingMovesCheckBox.isSelected()); + settings.setEvolutionMovesForAll(pmsEvolutionMovesCheckBox.isSelected()); + + settings.setTrainersMod(isTrainerSetting(TRAINER_UNCHANGED), isTrainerSetting(TRAINER_RANDOM), + isTrainerSetting(TRAINER_RANDOM_EVEN), isTrainerSetting(TRAINER_RANDOM_EVEN_MAIN), + isTrainerSetting(TRAINER_TYPE_THEMED), isTrainerSetting(TRAINER_TYPE_THEMED_ELITE4_GYMS)); + settings.setTrainersUsePokemonOfSimilarStrength(tpSimilarStrengthCheckBox.isSelected()); + settings.setRivalCarriesStarterThroughout(tpRivalCarriesStarterCheckBox.isSelected()); + settings.setTrainersMatchTypingDistribution(tpWeightTypesCheckBox.isSelected()); + settings.setTrainersBlockLegendaries(tpDontUseLegendariesCheckBox.isSelected()); + settings.setTrainersBlockEarlyWonderGuard(tpNoEarlyWonderGuardCheckBox.isSelected()); + settings.setTrainersForceFullyEvolved(tpForceFullyEvolvedAtCheckBox.isSelected()); + settings.setTrainersForceFullyEvolvedLevel(tpForceFullyEvolvedAtSlider.getValue()); + settings.setTrainersLevelModified(tpPercentageLevelModifierCheckBox.isSelected()); + settings.setTrainersLevelModifier(tpPercentageLevelModifierSlider.getValue()); + settings.setEliteFourUniquePokemonNumber(tpEliteFourUniquePokemonCheckBox.isVisible() && tpEliteFourUniquePokemonCheckBox.isSelected() ? (int)tpEliteFourUniquePokemonSpinner.getValue() : 0); + settings.setAllowTrainerAlternateFormes(tpAllowAlternateFormesCheckBox.isSelected() && tpAllowAlternateFormesCheckBox.isVisible()); + settings.setSwapTrainerMegaEvos(tpSwapMegaEvosCheckBox.isSelected() && tpSwapMegaEvosCheckBox.isVisible()); + settings.setDoubleBattleMode(tpDoubleBattleModeCheckBox.isVisible() && tpDoubleBattleModeCheckBox.isSelected()); + settings.setAdditionalBossTrainerPokemon(tpBossTrainersCheckBox.isVisible() && tpBossTrainersCheckBox.isSelected() ? (int)tpBossTrainersSpinner.getValue() : 0); + settings.setAdditionalImportantTrainerPokemon(tpImportantTrainersCheckBox.isVisible() && tpImportantTrainersCheckBox.isSelected() ? (int)tpImportantTrainersSpinner.getValue() : 0); + settings.setAdditionalRegularTrainerPokemon(tpRegularTrainersCheckBox.isVisible() && tpRegularTrainersCheckBox.isSelected() ? (int)tpRegularTrainersSpinner.getValue() : 0); + settings.setShinyChance(tpRandomShinyTrainerPokemonCheckBox.isVisible() && tpRandomShinyTrainerPokemonCheckBox.isSelected()); + settings.setRandomizeHeldItemsForBossTrainerPokemon(tpBossTrainersItemsCheckBox.isVisible() && tpBossTrainersItemsCheckBox.isSelected()); + settings.setRandomizeHeldItemsForImportantTrainerPokemon(tpImportantTrainersItemsCheckBox.isVisible() && tpImportantTrainersItemsCheckBox.isSelected()); + settings.setRandomizeHeldItemsForRegularTrainerPokemon(tpRegularTrainersItemsCheckBox.isVisible() && tpRegularTrainersItemsCheckBox.isSelected()); + settings.setConsumableItemsOnlyForTrainers(tpConsumableItemsOnlyCheckBox.isVisible() && tpConsumableItemsOnlyCheckBox.isSelected()); + settings.setSensibleItemsOnlyForTrainers(tpSensibleItemsCheckBox.isVisible() && tpSensibleItemsCheckBox.isSelected()); + settings.setHighestLevelGetsItemsForTrainers(tpHighestLevelGetsItemCheckBox.isVisible() && tpHighestLevelGetsItemCheckBox.isSelected()); + + settings.setTotemPokemonMod(totpUnchangedRadioButton.isSelected(), totpRandomRadioButton.isSelected(), totpRandomSimilarStrengthRadioButton.isSelected()); + settings.setAllyPokemonMod(totpAllyUnchangedRadioButton.isSelected(), totpAllyRandomRadioButton.isSelected(), totpAllyRandomSimilarStrengthRadioButton.isSelected()); + settings.setAuraMod(totpAuraUnchangedRadioButton.isSelected(), totpAuraRandomRadioButton.isSelected(), totpAuraRandomSameStrengthRadioButton.isSelected()); + settings.setRandomizeTotemHeldItems(totpRandomizeHeldItemsCheckBox.isSelected()); + settings.setAllowTotemAltFormes(totpAllowAltFormesCheckBox.isSelected()); + settings.setTotemLevelsModified(totpPercentageLevelModifierCheckBox.isSelected()); + settings.setTotemLevelModifier(totpPercentageLevelModifierSlider.getValue()); + + settings.setWildPokemonMod(wpUnchangedRadioButton.isSelected(), wpRandomRadioButton.isSelected(), wpArea1To1RadioButton.isSelected(), + wpGlobal1To1RadioButton.isSelected()); + settings.setWildPokemonRestrictionMod(wpARNoneRadioButton.isSelected(), wpARSimilarStrengthRadioButton.isSelected(), + wpARCatchEmAllModeRadioButton.isSelected(), wpARTypeThemeAreasRadioButton.isSelected()); + settings.setUseTimeBasedEncounters(wpUseTimeBasedEncountersCheckBox.isSelected()); + settings.setUseMinimumCatchRate(wpSetMinimumCatchRateCheckBox.isSelected()); + settings.setMinimumCatchRateLevel(wpSetMinimumCatchRateSlider.getValue()); + settings.setBlockWildLegendaries(wpDontUseLegendariesCheckBox.isSelected()); + settings.setRandomizeWildPokemonHeldItems(wpRandomizeHeldItemsCheckBox.isSelected() && wpRandomizeHeldItemsCheckBox.isVisible()); + settings.setBanBadRandomWildPokemonHeldItems(wpBanBadItemsCheckBox.isSelected() && wpBanBadItemsCheckBox.isVisible()); + settings.setBalanceShakingGrass(wpBalanceShakingGrassPokemonCheckBox.isSelected() && wpBalanceShakingGrassPokemonCheckBox.isVisible()); + settings.setWildLevelsModified(wpPercentageLevelModifierCheckBox.isSelected()); + settings.setWildLevelModifier(wpPercentageLevelModifierSlider.getValue()); + settings.setAllowWildAltFormes(wpAllowAltFormesCheckBox.isSelected() && wpAllowAltFormesCheckBox.isVisible()); + + settings.setStaticPokemonMod(stpUnchangedRadioButton.isSelected(), stpSwapLegendariesSwapStandardsRadioButton.isSelected(), + stpRandomCompletelyRadioButton.isSelected(), stpRandomSimilarStrengthRadioButton.isSelected()); + settings.setLimitMainGameLegendaries(stpLimitMainGameLegendariesCheckBox.isSelected() && stpLimitMainGameLegendariesCheckBox.isVisible()); + settings.setLimit600(stpRandomize600BSTCheckBox.isSelected()); + settings.setAllowStaticAltFormes(stpAllowAltFormesCheckBox.isSelected() && stpAllowAltFormesCheckBox.isVisible()); + settings.setSwapStaticMegaEvos(stpSwapMegaEvosCheckBox.isSelected() && stpSwapMegaEvosCheckBox.isVisible()); + settings.setStaticLevelModified(stpPercentageLevelModifierCheckBox.isSelected()); + settings.setStaticLevelModifier(stpPercentageLevelModifierSlider.getValue()); + settings.setCorrectStaticMusic(stpFixMusicCheckBox.isSelected() && stpFixMusicCheckBox.isVisible()); + + settings.setTmsMod(tmUnchangedRadioButton.isSelected(), tmRandomRadioButton.isSelected()); + + settings.setTmsHmsCompatibilityMod(thcUnchangedRadioButton.isSelected(), thcRandomPreferSameTypeRadioButton.isSelected(), + thcRandomCompletelyRadioButton.isSelected(), thcFullCompatibilityRadioButton.isSelected()); + settings.setTmLevelUpMoveSanity(tmLevelupMoveSanityCheckBox.isSelected()); + settings.setKeepFieldMoveTMs(tmKeepFieldMoveTMsCheckBox.isSelected()); + settings.setFullHMCompat(tmFullHMCompatibilityCheckBox.isSelected() && tmFullHMCompatibilityCheckBox.isVisible()); + settings.setTmsForceGoodDamaging(tmForceGoodDamagingCheckBox.isSelected()); + settings.setTmsGoodDamagingPercent(tmForceGoodDamagingSlider.getValue()); + settings.setBlockBrokenTMMoves(tmNoGameBreakingMovesCheckBox.isSelected()); + settings.setTmsFollowEvolutions(tmFollowEvolutionsCheckBox.isSelected()); + + settings.setMoveTutorMovesMod(mtUnchangedRadioButton.isSelected(), mtRandomRadioButton.isSelected()); + settings.setMoveTutorsCompatibilityMod(mtcUnchangedRadioButton.isSelected(), mtcRandomPreferSameTypeRadioButton.isSelected(), + mtcRandomCompletelyRadioButton.isSelected(), mtcFullCompatibilityRadioButton.isSelected()); + settings.setTutorLevelUpMoveSanity(mtLevelupMoveSanityCheckBox.isSelected()); + settings.setKeepFieldMoveTutors(mtKeepFieldMoveTutorsCheckBox.isSelected()); + settings.setTutorsForceGoodDamaging(mtForceGoodDamagingCheckBox.isSelected()); + settings.setTutorsGoodDamagingPercent(mtForceGoodDamagingSlider.getValue()); + settings.setBlockBrokenTutorMoves(mtNoGameBreakingMovesCheckBox.isSelected()); + settings.setTutorFollowEvolutions(mtFollowEvolutionsCheckBox.isSelected()); + + settings.setInGameTradesMod(igtUnchangedRadioButton.isSelected(), igtRandomizeGivenPokemonOnlyRadioButton.isSelected(), igtRandomizeBothRequestedGivenRadioButton.isSelected()); + settings.setRandomizeInGameTradesItems(igtRandomizeItemsCheckBox.isSelected()); + settings.setRandomizeInGameTradesIVs(igtRandomizeIVsCheckBox.isSelected()); + settings.setRandomizeInGameTradesNicknames(igtRandomizeNicknamesCheckBox.isSelected()); + settings.setRandomizeInGameTradesOTs(igtRandomizeOTsCheckBox.isSelected()); + + settings.setFieldItemsMod(fiUnchangedRadioButton.isSelected(), fiShuffleRadioButton.isSelected(), fiRandomRadioButton.isSelected(), fiRandomEvenDistributionRadioButton.isSelected()); + settings.setBanBadRandomFieldItems(fiBanBadItemsCheckBox.isSelected()); + + settings.setShopItemsMod(shUnchangedRadioButton.isSelected(), shShuffleRadioButton.isSelected(), shRandomRadioButton.isSelected()); + settings.setBanBadRandomShopItems(shBanBadItemsCheckBox.isSelected()); + settings.setBanRegularShopItems(shBanRegularShopItemsCheckBox.isSelected()); + settings.setBanOPShopItems(shBanOverpoweredShopItemsCheckBox.isSelected()); + settings.setBalanceShopPrices(shBalanceShopItemPricesCheckBox.isSelected()); + settings.setGuaranteeEvolutionItems(shGuaranteeEvolutionItemsCheckBox.isSelected()); + settings.setGuaranteeXItems(shGuaranteeXItemsCheckBox.isSelected()); + + settings.setPickupItemsMod(puUnchangedRadioButton.isSelected(), puRandomRadioButton.isSelected()); + settings.setBanBadRandomPickupItems(puBanBadItemsCheckBox.isSelected()); + + int currentMiscTweaks = 0; + int mtCount = MiscTweak.allTweaks.size(); + + for (int mti = 0; mti < mtCount; mti++) { + MiscTweak mt = MiscTweak.allTweaks.get(mti); + JCheckBox mtCB = tweakCheckBoxes.get(mti); + if (mtCB.isSelected()) { + currentMiscTweaks |= mt.getValue(); + } + } + + settings.setCurrentMiscTweaks(currentMiscTweaks); + + settings.setCustomNames(customNames); + + return settings; + } + + private Settings getCurrentSettings() throws IOException { + return createSettingsFromState(FileFunctions.getCustomNames()); + } + + private void attemptToLogException(Exception ex, String baseMessageKey, String noLogMessageKey, + String settingsString, String seedString) { + attemptToLogException(ex, baseMessageKey, noLogMessageKey, false, settingsString, seedString); + } + + private void attemptToLogException(Exception ex, String baseMessageKey, String noLogMessageKey, boolean showMessage, + String settingsString, String seedString) { + + // Make sure the operation dialog doesn't show up over the error + // dialog + SwingUtilities.invokeLater(() -> NewRandomizerGUI.this.opDialog.setVisible(false)); + + Date now = new Date(); + SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss"); + try { + String errlog = "error_" + ft.format(now) + ".txt"; + PrintStream ps = new PrintStream(new FileOutputStream(errlog)); + ps.println("Randomizer Version: " + Version.VERSION_STRING); + if (seedString != null) { + ps.println("Seed: " + seedString); + } + if (settingsString != null) { + ps.println("Settings String: " + Version.VERSION + settingsString); + } + ps.println("Java Version: " + System.getProperty("java.version") + ", " + System.getProperty("java.vm.name")); + PrintStream e1 = System.err; + System.setErr(ps); + if (this.romHandler != null) { + try { + ps.println("ROM: " + romHandler.getROMName()); + ps.println("Code: " + romHandler.getROMCode()); + ps.println("Reported Support Level: " + romHandler.getSupportLevel()); + ps.println(); + } catch (Exception ex2) { + // Do nothing, just don't fail + } + } + ex.printStackTrace(); + ps.println(); + ps.println("--ROM Diagnostics--"); + if (!romHandler.isRomValid()) { + ps.println(bundle.getString("Log.InvalidRomLoaded")); + } + romHandler.printRomDiagnostics(ps); + System.setErr(e1); + ps.close(); + if (showMessage) { + JOptionPane.showMessageDialog(mainPanel, + String.format(bundle.getString(baseMessageKey), ex.getMessage(), errlog)); + } else { + JOptionPane.showMessageDialog(mainPanel, String.format(bundle.getString(baseMessageKey), errlog)); + } + } catch (Exception logex) { + if (showMessage) { + JOptionPane.showMessageDialog(mainPanel, String.format(bundle.getString(noLogMessageKey), ex.getMessage())); + } else { + JOptionPane.showMessageDialog(mainPanel, bundle.getString(noLogMessageKey)); + } + } + } + + public String getValidRequiredROMName(String config, CustomNamesSet customNames) + throws UnsupportedEncodingException, InvalidSupplementFilesException { + try { + Utils.validatePresetSupplementFiles(config, customNames); + } catch (InvalidSupplementFilesException e) { + switch (e.getType()) { + case CUSTOM_NAMES: + JOptionPane.showMessageDialog(null, bundle.getString("GUI.presetDifferentCustomNames")); + break; + default: + throw e; + } + } + byte[] data = Base64.getDecoder().decode(config); + + int nameLength = data[Settings.LENGTH_OF_SETTINGS_DATA] & 0xFF; + if (data.length != Settings.LENGTH_OF_SETTINGS_DATA + 9 + nameLength) { + return null; // not valid length + } + return new String(data, Settings.LENGTH_OF_SETTINGS_DATA + 1, nameLength, "US-ASCII"); + } + + private void initialState() { + + romNameLabel.setText(bundle.getString("GUI.noRomLoaded")); + romCodeLabel.setText(""); + romSupportLabel.setText(""); + + gameMascotLabel.setIcon(emptyIcon); + + limitPokemonCheckBox.setVisible(true); + limitPokemonCheckBox.setEnabled(false); + limitPokemonCheckBox.setSelected(false); + limitPokemonButton.setVisible(true); + limitPokemonButton.setEnabled(false); + noIrregularAltFormesCheckBox.setVisible(true); + noIrregularAltFormesCheckBox.setEnabled(false); + noIrregularAltFormesCheckBox.setSelected(false); + raceModeCheckBox.setVisible(true); + raceModeCheckBox.setEnabled(false); + raceModeCheckBox.setSelected(false); + + currentRestrictions = null; + + openROMButton.setVisible(true); + openROMButton.setEnabled(true); + openROMButton.setSelected(false); + randomizeSaveButton.setVisible(true); + randomizeSaveButton.setEnabled(true); + randomizeSaveButton.setSelected(false); + premadeSeedButton.setVisible(true); + premadeSeedButton.setEnabled(true); + premadeSeedButton.setSelected(false); + settingsButton.setVisible(true); + settingsButton.setEnabled(true); + settingsButton.setSelected(false); + + loadSettingsButton.setVisible(true); + loadSettingsButton.setEnabled(false); + loadSettingsButton.setSelected(false); + saveSettingsButton.setVisible(true); + saveSettingsButton.setEnabled(false); + saveSettingsButton.setSelected(false); + pbsUnchangedRadioButton.setVisible(true); + pbsUnchangedRadioButton.setEnabled(false); + pbsUnchangedRadioButton.setSelected(false); + pbsShuffleRadioButton.setVisible(true); + pbsShuffleRadioButton.setEnabled(false); + pbsShuffleRadioButton.setSelected(false); + pbsRandomRadioButton.setVisible(true); + pbsRandomRadioButton.setEnabled(false); + pbsRandomRadioButton.setSelected(false); + pbsLegendariesSlowRadioButton.setVisible(true); + pbsLegendariesSlowRadioButton.setEnabled(false); + pbsLegendariesSlowRadioButton.setSelected(false); + pbsStrongLegendariesSlowRadioButton.setVisible(true); + pbsStrongLegendariesSlowRadioButton.setEnabled(false); + pbsStrongLegendariesSlowRadioButton.setSelected(false); + pbsAllMediumFastRadioButton.setVisible(true); + pbsAllMediumFastRadioButton.setEnabled(false); + pbsAllMediumFastRadioButton.setSelected(false); + pbsStandardizeEXPCurvesCheckBox.setVisible(true); + pbsStandardizeEXPCurvesCheckBox.setEnabled(false); + pbsStandardizeEXPCurvesCheckBox.setSelected(false); + pbsEXPCurveComboBox.setVisible(true); + pbsEXPCurveComboBox.setEnabled(false); + pbsEXPCurveComboBox.setSelectedIndex(0); + pbsEXPCurveComboBox.setModel(new DefaultComboBoxModel<>(new String[] { "Medium Fast" })); + pbsFollowEvolutionsCheckBox.setVisible(true); + pbsFollowEvolutionsCheckBox.setEnabled(false); + pbsFollowEvolutionsCheckBox.setSelected(false); + pbsUpdateBaseStatsCheckBox.setVisible(true); + pbsUpdateBaseStatsCheckBox.setEnabled(false); + pbsUpdateBaseStatsCheckBox.setSelected(false); + pbsFollowMegaEvosCheckBox.setVisible(true); + pbsFollowMegaEvosCheckBox.setEnabled(false); + pbsFollowMegaEvosCheckBox.setSelected(false); + pbsUpdateComboBox.setVisible(true); + pbsUpdateComboBox.setEnabled(false); + pbsUpdateComboBox.setSelectedIndex(0); + pbsUpdateComboBox.setModel(new DefaultComboBoxModel<>(new String[] { "--" })); + pbsAssignEvoStatsRandomlyCheckBox.setVisible(true); + pbsAssignEvoStatsRandomlyCheckBox.setEnabled(false); + pbsAssignEvoStatsRandomlyCheckBox.setSelected(false); + ptUnchangedRadioButton.setVisible(true); + ptUnchangedRadioButton.setEnabled(false); + ptUnchangedRadioButton.setSelected(false); + ptRandomFollowEvolutionsRadioButton.setVisible(true); + ptRandomFollowEvolutionsRadioButton.setEnabled(false); + ptRandomFollowEvolutionsRadioButton.setSelected(false); + ptRandomCompletelyRadioButton.setVisible(true); + ptRandomCompletelyRadioButton.setEnabled(false); + ptRandomCompletelyRadioButton.setSelected(false); + ptFollowMegaEvosCheckBox.setVisible(true); + ptFollowMegaEvosCheckBox.setEnabled(false); + ptFollowMegaEvosCheckBox.setSelected(false); + ptIsDualTypeCheckBox.setVisible(true); + ptIsDualTypeCheckBox.setEnabled(false); + ptIsDualTypeCheckBox.setSelected(false); + pokemonAbilitiesPanel.setVisible(true); + paUnchangedRadioButton.setVisible(true); + paUnchangedRadioButton.setEnabled(false); + paUnchangedRadioButton.setSelected(false); + paRandomRadioButton.setVisible(true); + paRandomRadioButton.setEnabled(false); + paRandomRadioButton.setSelected(false); + paAllowWonderGuardCheckBox.setVisible(true); + paAllowWonderGuardCheckBox.setEnabled(false); + paAllowWonderGuardCheckBox.setSelected(false); + paFollowEvolutionsCheckBox.setVisible(true); + paFollowEvolutionsCheckBox.setEnabled(false); + paFollowEvolutionsCheckBox.setSelected(false); + paTrappingAbilitiesCheckBox.setVisible(true); + paTrappingAbilitiesCheckBox.setEnabled(false); + paTrappingAbilitiesCheckBox.setSelected(false); + paNegativeAbilitiesCheckBox.setVisible(true); + paNegativeAbilitiesCheckBox.setEnabled(false); + paNegativeAbilitiesCheckBox.setSelected(false); + paBadAbilitiesCheckBox.setVisible(true); + paBadAbilitiesCheckBox.setEnabled(false); + paBadAbilitiesCheckBox.setSelected(false); + paFollowMegaEvosCheckBox.setVisible(true); + paFollowMegaEvosCheckBox.setEnabled(false); + paFollowMegaEvosCheckBox.setSelected(false); + paWeighDuplicatesTogetherCheckBox.setVisible(true); + paWeighDuplicatesTogetherCheckBox.setEnabled(false); + paWeighDuplicatesTogetherCheckBox.setSelected(false); + peUnchangedRadioButton.setVisible(true); + peUnchangedRadioButton.setEnabled(false); + peUnchangedRadioButton.setSelected(false); + peRandomRadioButton.setVisible(true); + peRandomRadioButton.setEnabled(false); + peRandomRadioButton.setSelected(false); + peRandomEveryLevelRadioButton.setVisible(true); + peRandomEveryLevelRadioButton.setEnabled(false); + peRandomEveryLevelRadioButton.setSelected(false); + peSimilarStrengthCheckBox.setVisible(true); + peSimilarStrengthCheckBox.setEnabled(false); + peSimilarStrengthCheckBox.setSelected(false); + peSameTypingCheckBox.setVisible(true); + peSameTypingCheckBox.setEnabled(false); + peSameTypingCheckBox.setSelected(false); + peLimitEvolutionsToThreeCheckBox.setVisible(true); + peLimitEvolutionsToThreeCheckBox.setEnabled(false); + peLimitEvolutionsToThreeCheckBox.setSelected(false); + peForceChangeCheckBox.setVisible(true); + peForceChangeCheckBox.setEnabled(false); + peForceChangeCheckBox.setSelected(false); + peChangeImpossibleEvosCheckBox.setVisible(true); + peChangeImpossibleEvosCheckBox.setEnabled(false); + peChangeImpossibleEvosCheckBox.setSelected(false); + peMakeEvolutionsEasierCheckBox.setVisible(true); + peMakeEvolutionsEasierCheckBox.setEnabled(false); + peMakeEvolutionsEasierCheckBox.setSelected(false); + peRemoveTimeBasedEvolutionsCheckBox.setVisible(true); + peRemoveTimeBasedEvolutionsCheckBox.setEnabled(false); + peRemoveTimeBasedEvolutionsCheckBox.setSelected(false); + peAllowAltFormesCheckBox.setVisible(true); + peAllowAltFormesCheckBox.setEnabled(false); + peAllowAltFormesCheckBox.setSelected(false); + spUnchangedRadioButton.setVisible(true); + spUnchangedRadioButton.setEnabled(false); + spUnchangedRadioButton.setSelected(false); + spCustomRadioButton.setVisible(true); + spCustomRadioButton.setEnabled(false); + spCustomRadioButton.setSelected(false); + spRandomCompletelyRadioButton.setVisible(true); + spRandomCompletelyRadioButton.setEnabled(false); + spRandomCompletelyRadioButton.setSelected(false); + spRandomTwoEvosRadioButton.setVisible(true); + spRandomTwoEvosRadioButton.setEnabled(false); + spRandomTwoEvosRadioButton.setSelected(false); + spComboBox1.setVisible(true); + spComboBox1.setEnabled(false); + spComboBox1.setSelectedIndex(0); + spComboBox1.setModel(new DefaultComboBoxModel<>(new String[] { "--" })); + spComboBox2.setVisible(true); + spComboBox2.setEnabled(false); + spComboBox2.setSelectedIndex(0); + spComboBox2.setModel(new DefaultComboBoxModel<>(new String[] { "--" })); + spComboBox3.setVisible(true); + spComboBox3.setEnabled(false); + spComboBox3.setSelectedIndex(0); + spComboBox3.setModel(new DefaultComboBoxModel<>(new String[] { "--" })); + spRandomizeStarterHeldItemsCheckBox.setVisible(true); + spRandomizeStarterHeldItemsCheckBox.setEnabled(false); + spRandomizeStarterHeldItemsCheckBox.setSelected(false); + spBanBadItemsCheckBox.setVisible(true); + spBanBadItemsCheckBox.setEnabled(false); + spBanBadItemsCheckBox.setSelected(false); + spAllowAltFormesCheckBox.setVisible(true); + spAllowAltFormesCheckBox.setEnabled(false); + spAllowAltFormesCheckBox.setSelected(false); + stpUnchangedRadioButton.setVisible(true); + stpUnchangedRadioButton.setEnabled(false); + stpUnchangedRadioButton.setSelected(false); + stpSwapLegendariesSwapStandardsRadioButton.setVisible(true); + stpSwapLegendariesSwapStandardsRadioButton.setEnabled(false); + stpSwapLegendariesSwapStandardsRadioButton.setSelected(false); + stpRandomCompletelyRadioButton.setVisible(true); + stpRandomCompletelyRadioButton.setEnabled(false); + stpRandomCompletelyRadioButton.setSelected(false); + stpRandomSimilarStrengthRadioButton.setVisible(true); + stpRandomSimilarStrengthRadioButton.setEnabled(false); + stpRandomSimilarStrengthRadioButton.setSelected(false); + stpPercentageLevelModifierCheckBox.setVisible(true); + stpPercentageLevelModifierCheckBox.setEnabled(false); + stpPercentageLevelModifierCheckBox.setSelected(false); + stpPercentageLevelModifierSlider.setVisible(true); + stpPercentageLevelModifierSlider.setEnabled(false); + stpPercentageLevelModifierSlider.setValue(0); + stpLimitMainGameLegendariesCheckBox.setVisible(true); + stpLimitMainGameLegendariesCheckBox.setEnabled(false); + stpLimitMainGameLegendariesCheckBox.setSelected(false); + stpRandomize600BSTCheckBox.setVisible(true); + stpRandomize600BSTCheckBox.setEnabled(false); + stpRandomize600BSTCheckBox.setSelected(false); + stpAllowAltFormesCheckBox.setVisible(true); + stpAllowAltFormesCheckBox.setEnabled(false); + stpAllowAltFormesCheckBox.setSelected(false); + stpSwapMegaEvosCheckBox.setVisible(true); + stpSwapMegaEvosCheckBox.setEnabled(false); + stpSwapMegaEvosCheckBox.setSelected(false); + stpFixMusicCheckBox.setVisible(true); + stpFixMusicCheckBox.setEnabled(false); + stpFixMusicCheckBox.setSelected(false); + igtUnchangedRadioButton.setVisible(true); + igtUnchangedRadioButton.setEnabled(false); + igtUnchangedRadioButton.setSelected(false); + igtRandomizeGivenPokemonOnlyRadioButton.setVisible(true); + igtRandomizeGivenPokemonOnlyRadioButton.setEnabled(false); + igtRandomizeGivenPokemonOnlyRadioButton.setSelected(false); + igtRandomizeBothRequestedGivenRadioButton.setVisible(true); + igtRandomizeBothRequestedGivenRadioButton.setEnabled(false); + igtRandomizeBothRequestedGivenRadioButton.setSelected(false); + igtRandomizeNicknamesCheckBox.setVisible(true); + igtRandomizeNicknamesCheckBox.setEnabled(false); + igtRandomizeNicknamesCheckBox.setSelected(false); + igtRandomizeOTsCheckBox.setVisible(true); + igtRandomizeOTsCheckBox.setEnabled(false); + igtRandomizeOTsCheckBox.setSelected(false); + igtRandomizeIVsCheckBox.setVisible(true); + igtRandomizeIVsCheckBox.setEnabled(false); + igtRandomizeIVsCheckBox.setSelected(false); + igtRandomizeItemsCheckBox.setVisible(true); + igtRandomizeItemsCheckBox.setEnabled(false); + igtRandomizeItemsCheckBox.setSelected(false); + mdRandomizeMovePowerCheckBox.setVisible(true); + mdRandomizeMovePowerCheckBox.setEnabled(false); + mdRandomizeMovePowerCheckBox.setSelected(false); + mdRandomizeMoveAccuracyCheckBox.setVisible(true); + mdRandomizeMoveAccuracyCheckBox.setEnabled(false); + mdRandomizeMoveAccuracyCheckBox.setSelected(false); + mdRandomizeMovePPCheckBox.setVisible(true); + mdRandomizeMovePPCheckBox.setEnabled(false); + mdRandomizeMovePPCheckBox.setSelected(false); + mdRandomizeMoveTypesCheckBox.setVisible(true); + mdRandomizeMoveTypesCheckBox.setEnabled(false); + mdRandomizeMoveTypesCheckBox.setSelected(false); + mdRandomizeMoveCategoryCheckBox.setVisible(true); + mdRandomizeMoveCategoryCheckBox.setEnabled(false); + mdRandomizeMoveCategoryCheckBox.setSelected(false); + mdUpdateMovesCheckBox.setVisible(true); + mdUpdateMovesCheckBox.setEnabled(false); + mdUpdateMovesCheckBox.setSelected(false); + mdUpdateComboBox.setVisible(true); + mdUpdateComboBox.setEnabled(false); + mdUpdateComboBox.setSelectedIndex(0); + mdUpdateComboBox.setModel(new DefaultComboBoxModel<>(new String[] { "--" })); + pmsUnchangedRadioButton.setVisible(true); + pmsUnchangedRadioButton.setEnabled(false); + pmsUnchangedRadioButton.setSelected(false); + pmsRandomPreferringSameTypeRadioButton.setVisible(true); + pmsRandomPreferringSameTypeRadioButton.setEnabled(false); + pmsRandomPreferringSameTypeRadioButton.setSelected(false); + pmsRandomCompletelyRadioButton.setVisible(true); + pmsRandomCompletelyRadioButton.setEnabled(false); + pmsRandomCompletelyRadioButton.setSelected(false); + pmsMetronomeOnlyModeRadioButton.setVisible(true); + pmsMetronomeOnlyModeRadioButton.setEnabled(false); + pmsMetronomeOnlyModeRadioButton.setSelected(false); + pmsGuaranteedLevel1MovesCheckBox.setVisible(true); + pmsGuaranteedLevel1MovesCheckBox.setEnabled(false); + pmsGuaranteedLevel1MovesCheckBox.setSelected(false); + pmsReorderDamagingMovesCheckBox.setVisible(true); + pmsReorderDamagingMovesCheckBox.setEnabled(false); + pmsReorderDamagingMovesCheckBox.setSelected(false); + pmsNoGameBreakingMovesCheckBox.setVisible(true); + pmsNoGameBreakingMovesCheckBox.setEnabled(false); + pmsNoGameBreakingMovesCheckBox.setSelected(false); + pmsForceGoodDamagingCheckBox.setVisible(true); + pmsForceGoodDamagingCheckBox.setEnabled(false); + pmsForceGoodDamagingCheckBox.setSelected(false); + pmsGuaranteedLevel1MovesSlider.setVisible(true); + pmsGuaranteedLevel1MovesSlider.setEnabled(false); + pmsGuaranteedLevel1MovesSlider.setValue(pmsGuaranteedLevel1MovesSlider.getMinimum()); + pmsForceGoodDamagingSlider.setVisible(true); + pmsForceGoodDamagingSlider.setEnabled(false); + pmsForceGoodDamagingSlider.setValue(pmsForceGoodDamagingSlider.getMinimum()); + pmsEvolutionMovesCheckBox.setVisible(true); + pmsEvolutionMovesCheckBox.setEnabled(false); + pmsEvolutionMovesCheckBox.setSelected(false); + tpComboBox.setVisible(true); + tpComboBox.setEnabled(false); + tpComboBox.setModel(new DefaultComboBoxModel<>(new String[] { "Unchanged" })); + tpRivalCarriesStarterCheckBox.setVisible(true); + tpRivalCarriesStarterCheckBox.setEnabled(false); + tpRivalCarriesStarterCheckBox.setSelected(false); + tpSimilarStrengthCheckBox.setVisible(true); + tpSimilarStrengthCheckBox.setEnabled(false); + tpSimilarStrengthCheckBox.setSelected(false); + tpWeightTypesCheckBox.setVisible(true); + tpWeightTypesCheckBox.setEnabled(false); + tpWeightTypesCheckBox.setSelected(false); + tpDontUseLegendariesCheckBox.setVisible(true); + tpDontUseLegendariesCheckBox.setEnabled(false); + tpDontUseLegendariesCheckBox.setSelected(false); + tpNoEarlyWonderGuardCheckBox.setVisible(true); + tpNoEarlyWonderGuardCheckBox.setEnabled(false); + tpNoEarlyWonderGuardCheckBox.setSelected(false); + tpRandomizeTrainerNamesCheckBox.setVisible(true); + tpRandomizeTrainerNamesCheckBox.setEnabled(false); + tpRandomizeTrainerNamesCheckBox.setSelected(false); + tpRandomizeTrainerClassNamesCheckBox.setVisible(true); + tpRandomizeTrainerClassNamesCheckBox.setEnabled(false); + tpRandomizeTrainerClassNamesCheckBox.setSelected(false); + tpForceFullyEvolvedAtCheckBox.setVisible(true); + tpForceFullyEvolvedAtCheckBox.setEnabled(false); + tpForceFullyEvolvedAtCheckBox.setSelected(false); + tpForceFullyEvolvedAtSlider.setVisible(true); + tpForceFullyEvolvedAtSlider.setEnabled(false); + tpForceFullyEvolvedAtSlider.setValue(tpForceFullyEvolvedAtSlider.getMinimum()); + tpPercentageLevelModifierSlider.setVisible(true); + tpPercentageLevelModifierSlider.setEnabled(false); + tpPercentageLevelModifierSlider.setValue(0); + tpPercentageLevelModifierCheckBox.setVisible(true); + tpPercentageLevelModifierCheckBox.setEnabled(false); + tpPercentageLevelModifierCheckBox.setSelected(false); + + tpEliteFourUniquePokemonCheckBox.setVisible(true); + tpEliteFourUniquePokemonCheckBox.setEnabled(false); + tpEliteFourUniquePokemonCheckBox.setSelected(false); + tpEliteFourUniquePokemonSpinner.setVisible(true); + tpEliteFourUniquePokemonSpinner.setEnabled(false); + tpEliteFourUniquePokemonSpinner.setValue(1); + + tpAllowAlternateFormesCheckBox.setVisible(true); + tpAllowAlternateFormesCheckBox.setEnabled(false); + tpAllowAlternateFormesCheckBox.setSelected(false); + tpSwapMegaEvosCheckBox.setVisible(true); + tpSwapMegaEvosCheckBox.setEnabled(false); + tpSwapMegaEvosCheckBox.setSelected(false); + tpDoubleBattleModeCheckBox.setVisible(true); + tpDoubleBattleModeCheckBox.setEnabled(false); + tpDoubleBattleModeCheckBox.setSelected(false); + tpBossTrainersCheckBox.setVisible(true); + tpBossTrainersCheckBox.setEnabled(false); + tpBossTrainersCheckBox.setSelected(false); + tpImportantTrainersCheckBox.setVisible(true); + tpImportantTrainersCheckBox.setEnabled(false); + tpImportantTrainersCheckBox.setSelected(false); + tpRegularTrainersCheckBox.setVisible(true); + tpRegularTrainersCheckBox.setEnabled(false); + tpRegularTrainersCheckBox.setSelected(false); + tpBossTrainersSpinner.setVisible(true); + tpBossTrainersSpinner.setEnabled(false); + tpBossTrainersSpinner.setValue(1); + tpImportantTrainersSpinner.setVisible(true); + tpImportantTrainersSpinner.setEnabled(false); + tpImportantTrainersSpinner.setValue(1); + tpRegularTrainersSpinner.setVisible(true); + tpRegularTrainersSpinner.setEnabled(false); + tpRegularTrainersSpinner.setValue(1); + tpAdditionalPokemonForLabel.setVisible(true); + tpHeldItemsLabel.setVisible(true); + tpBossTrainersItemsCheckBox.setVisible(true); + tpBossTrainersItemsCheckBox.setEnabled(false); + tpBossTrainersItemsCheckBox.setSelected(false); + tpImportantTrainersItemsCheckBox.setVisible(true); + tpImportantTrainersItemsCheckBox.setEnabled(false); + tpImportantTrainersItemsCheckBox.setSelected(false); + tpRegularTrainersItemsCheckBox.setVisible(true); + tpRegularTrainersItemsCheckBox.setEnabled(false); + tpRegularTrainersItemsCheckBox.setSelected(false); + tpConsumableItemsOnlyCheckBox.setVisible(true); + tpConsumableItemsOnlyCheckBox.setEnabled(false); + tpConsumableItemsOnlyCheckBox.setSelected(false); + tpSensibleItemsCheckBox.setVisible(true); + tpSensibleItemsCheckBox.setEnabled(false); + tpSensibleItemsCheckBox.setSelected(false); + tpHighestLevelGetsItemCheckBox.setVisible(true); + tpHighestLevelGetsItemCheckBox.setEnabled(false); + tpHighestLevelGetsItemCheckBox.setSelected(false); + tpRandomShinyTrainerPokemonCheckBox.setVisible(true); + tpRandomShinyTrainerPokemonCheckBox.setEnabled(false); + totpPanel.setVisible(true); + totpAllyPanel.setVisible(true); + totpAuraPanel.setVisible(true); + totpUnchangedRadioButton.setVisible(true); + totpUnchangedRadioButton.setEnabled(false); + totpUnchangedRadioButton.setSelected(true); + totpRandomRadioButton.setVisible(true); + totpRandomRadioButton.setEnabled(false); + totpRandomRadioButton.setSelected(false); + totpRandomSimilarStrengthRadioButton.setVisible(true); + totpRandomSimilarStrengthRadioButton.setEnabled(false); + totpRandomSimilarStrengthRadioButton.setSelected(false); + totpAllyUnchangedRadioButton.setVisible(true); + totpAllyUnchangedRadioButton.setEnabled(false); + totpAllyUnchangedRadioButton.setSelected(true); + totpAllyRandomRadioButton.setVisible(true); + totpAllyRandomRadioButton.setEnabled(false); + totpAllyRandomRadioButton.setSelected(false); + totpAllyRandomSimilarStrengthRadioButton.setVisible(true); + totpAllyRandomSimilarStrengthRadioButton.setEnabled(false); + totpAllyRandomSimilarStrengthRadioButton.setSelected(false); + totpAuraUnchangedRadioButton.setVisible(true); + totpAuraUnchangedRadioButton.setEnabled(false); + totpAuraUnchangedRadioButton.setSelected(true); + totpAuraRandomRadioButton.setVisible(true); + totpAuraRandomRadioButton.setEnabled(false); + totpAuraRandomRadioButton.setSelected(false); + totpAuraRandomSameStrengthRadioButton.setVisible(true); + totpAuraRandomSameStrengthRadioButton.setEnabled(false); + totpAuraRandomSameStrengthRadioButton.setSelected(false); + totpPercentageLevelModifierCheckBox.setVisible(true); + totpPercentageLevelModifierCheckBox.setEnabled(false); + totpPercentageLevelModifierCheckBox.setSelected(false); + totpPercentageLevelModifierSlider.setVisible(true); + totpPercentageLevelModifierSlider.setEnabled(false); + totpPercentageLevelModifierSlider.setValue(0); + totpRandomizeHeldItemsCheckBox.setVisible(true); + totpRandomizeHeldItemsCheckBox.setEnabled(false); + totpRandomizeHeldItemsCheckBox.setSelected(false); + totpAllowAltFormesCheckBox.setVisible(true); + totpAllowAltFormesCheckBox.setEnabled(false); + totpAllowAltFormesCheckBox.setSelected(false); + wpUnchangedRadioButton.setVisible(true); + wpUnchangedRadioButton.setEnabled(false); + wpUnchangedRadioButton.setSelected(false); + wpRandomRadioButton.setVisible(true); + wpRandomRadioButton.setEnabled(false); + wpRandomRadioButton.setSelected(false); + wpArea1To1RadioButton.setVisible(true); + wpArea1To1RadioButton.setEnabled(false); + wpArea1To1RadioButton.setSelected(false); + wpGlobal1To1RadioButton.setVisible(true); + wpGlobal1To1RadioButton.setEnabled(false); + wpGlobal1To1RadioButton.setSelected(false); + wpARNoneRadioButton.setVisible(true); + wpARNoneRadioButton.setEnabled(false); + wpARNoneRadioButton.setSelected(false); + wpARSimilarStrengthRadioButton.setVisible(true); + wpARSimilarStrengthRadioButton.setEnabled(false); + wpARSimilarStrengthRadioButton.setSelected(false); + wpARCatchEmAllModeRadioButton.setVisible(true); + wpARCatchEmAllModeRadioButton.setEnabled(false); + wpARCatchEmAllModeRadioButton.setSelected(false); + wpARTypeThemeAreasRadioButton.setVisible(true); + wpARTypeThemeAreasRadioButton.setEnabled(false); + wpARTypeThemeAreasRadioButton.setSelected(false); + wpUseTimeBasedEncountersCheckBox.setVisible(true); + wpUseTimeBasedEncountersCheckBox.setEnabled(false); + wpUseTimeBasedEncountersCheckBox.setSelected(false); + wpDontUseLegendariesCheckBox.setVisible(true); + wpDontUseLegendariesCheckBox.setEnabled(false); + wpDontUseLegendariesCheckBox.setSelected(false); + wpSetMinimumCatchRateCheckBox.setVisible(true); + wpSetMinimumCatchRateCheckBox.setEnabled(false); + wpSetMinimumCatchRateCheckBox.setSelected(false); + wpRandomizeHeldItemsCheckBox.setVisible(true); + wpRandomizeHeldItemsCheckBox.setEnabled(false); + wpRandomizeHeldItemsCheckBox.setSelected(false); + wpBanBadItemsCheckBox.setVisible(true); + wpBanBadItemsCheckBox.setEnabled(false); + wpBanBadItemsCheckBox.setSelected(false); + wpBalanceShakingGrassPokemonCheckBox.setVisible(true); + wpBalanceShakingGrassPokemonCheckBox.setEnabled(false); + wpBalanceShakingGrassPokemonCheckBox.setSelected(false); + wpPercentageLevelModifierCheckBox.setVisible(true); + wpPercentageLevelModifierCheckBox.setEnabled(false); + wpPercentageLevelModifierCheckBox.setSelected(false); + wpPercentageLevelModifierSlider.setVisible(true); + wpPercentageLevelModifierSlider.setEnabled(false); + wpPercentageLevelModifierSlider.setValue(0); + wpSetMinimumCatchRateSlider.setVisible(true); + wpSetMinimumCatchRateSlider.setEnabled(false); + wpSetMinimumCatchRateSlider.setValue(wpSetMinimumCatchRateSlider.getMinimum()); + wpAllowAltFormesCheckBox.setVisible(true); + wpAllowAltFormesCheckBox.setEnabled(false); + wpAllowAltFormesCheckBox.setSelected(false); + tmUnchangedRadioButton.setVisible(true); + tmUnchangedRadioButton.setEnabled(false); + tmUnchangedRadioButton.setSelected(false); + tmRandomRadioButton.setVisible(true); + tmRandomRadioButton.setEnabled(false); + tmRandomRadioButton.setSelected(false); + tmNoGameBreakingMovesCheckBox.setVisible(true); + tmNoGameBreakingMovesCheckBox.setEnabled(false); + tmNoGameBreakingMovesCheckBox.setSelected(false); + tmFullHMCompatibilityCheckBox.setVisible(true); + tmFullHMCompatibilityCheckBox.setEnabled(false); + tmFullHMCompatibilityCheckBox.setSelected(false); + tmLevelupMoveSanityCheckBox.setVisible(true); + tmLevelupMoveSanityCheckBox.setEnabled(false); + tmLevelupMoveSanityCheckBox.setSelected(false); + tmKeepFieldMoveTMsCheckBox.setVisible(true); + tmKeepFieldMoveTMsCheckBox.setEnabled(false); + tmKeepFieldMoveTMsCheckBox.setSelected(false); + tmForceGoodDamagingCheckBox.setVisible(true); + tmForceGoodDamagingCheckBox.setEnabled(false); + tmForceGoodDamagingCheckBox.setSelected(false); + tmForceGoodDamagingSlider.setVisible(true); + tmForceGoodDamagingSlider.setEnabled(false); + tmForceGoodDamagingSlider.setValue(tmForceGoodDamagingSlider.getMinimum()); + tmFollowEvolutionsCheckBox.setVisible(true); + tmFollowEvolutionsCheckBox.setEnabled(false); + tmFollowEvolutionsCheckBox.setSelected(false); + thcUnchangedRadioButton.setVisible(true); + thcUnchangedRadioButton.setEnabled(false); + thcUnchangedRadioButton.setSelected(false); + thcRandomPreferSameTypeRadioButton.setVisible(true); + thcRandomPreferSameTypeRadioButton.setEnabled(false); + thcRandomPreferSameTypeRadioButton.setSelected(false); + thcRandomCompletelyRadioButton.setVisible(true); + thcRandomCompletelyRadioButton.setEnabled(false); + thcRandomCompletelyRadioButton.setSelected(false); + thcFullCompatibilityRadioButton.setVisible(true); + thcFullCompatibilityRadioButton.setEnabled(false); + thcFullCompatibilityRadioButton.setSelected(false); + mtUnchangedRadioButton.setVisible(true); + mtUnchangedRadioButton.setEnabled(false); + mtUnchangedRadioButton.setSelected(false); + mtRandomRadioButton.setVisible(true); + mtRandomRadioButton.setEnabled(false); + mtRandomRadioButton.setSelected(false); + mtNoGameBreakingMovesCheckBox.setVisible(true); + mtNoGameBreakingMovesCheckBox.setEnabled(false); + mtNoGameBreakingMovesCheckBox.setSelected(false); + mtLevelupMoveSanityCheckBox.setVisible(true); + mtLevelupMoveSanityCheckBox.setEnabled(false); + mtLevelupMoveSanityCheckBox.setSelected(false); + mtKeepFieldMoveTutorsCheckBox.setVisible(true); + mtKeepFieldMoveTutorsCheckBox.setEnabled(false); + mtKeepFieldMoveTutorsCheckBox.setSelected(false); + mtForceGoodDamagingCheckBox.setVisible(true); + mtForceGoodDamagingCheckBox.setEnabled(false); + mtForceGoodDamagingCheckBox.setSelected(false); + mtForceGoodDamagingSlider.setVisible(true); + mtForceGoodDamagingSlider.setEnabled(false); + mtForceGoodDamagingSlider.setValue(mtForceGoodDamagingSlider.getMinimum()); + mtFollowEvolutionsCheckBox.setVisible(true); + mtFollowEvolutionsCheckBox.setEnabled(false); + mtFollowEvolutionsCheckBox.setSelected(false); + mtcUnchangedRadioButton.setVisible(true); + mtcUnchangedRadioButton.setEnabled(false); + mtcUnchangedRadioButton.setSelected(false); + mtcRandomPreferSameTypeRadioButton.setVisible(true); + mtcRandomPreferSameTypeRadioButton.setEnabled(false); + mtcRandomPreferSameTypeRadioButton.setSelected(false); + mtcRandomCompletelyRadioButton.setVisible(true); + mtcRandomCompletelyRadioButton.setEnabled(false); + mtcRandomCompletelyRadioButton.setSelected(false); + mtcFullCompatibilityRadioButton.setVisible(true); + mtcFullCompatibilityRadioButton.setEnabled(false); + mtcFullCompatibilityRadioButton.setSelected(false); + fiUnchangedRadioButton.setVisible(true); + fiUnchangedRadioButton.setEnabled(false); + fiUnchangedRadioButton.setSelected(false); + fiShuffleRadioButton.setVisible(true); + fiShuffleRadioButton.setEnabled(false); + fiShuffleRadioButton.setSelected(false); + fiRandomRadioButton.setVisible(true); + fiRandomRadioButton.setEnabled(false); + fiRandomRadioButton.setSelected(false); + fiRandomEvenDistributionRadioButton.setVisible(true); + fiRandomEvenDistributionRadioButton.setEnabled(false); + fiRandomEvenDistributionRadioButton.setSelected(false); + fiBanBadItemsCheckBox.setVisible(true); + fiBanBadItemsCheckBox.setEnabled(false); + fiBanBadItemsCheckBox.setSelected(false); + shUnchangedRadioButton.setVisible(true); + shUnchangedRadioButton.setEnabled(false); + shUnchangedRadioButton.setSelected(false); + shShuffleRadioButton.setVisible(true); + shShuffleRadioButton.setEnabled(false); + shShuffleRadioButton.setSelected(false); + shRandomRadioButton.setVisible(true); + shRandomRadioButton.setEnabled(false); + shRandomRadioButton.setSelected(false); + shBanOverpoweredShopItemsCheckBox.setVisible(true); + shBanOverpoweredShopItemsCheckBox.setEnabled(false); + shBanOverpoweredShopItemsCheckBox.setSelected(false); + shBanBadItemsCheckBox.setVisible(true); + shBanBadItemsCheckBox.setEnabled(false); + shBanBadItemsCheckBox.setSelected(false); + shBanRegularShopItemsCheckBox.setVisible(true); + shBanRegularShopItemsCheckBox.setEnabled(false); + shBanRegularShopItemsCheckBox.setSelected(false); + shBalanceShopItemPricesCheckBox.setVisible(true); + shBalanceShopItemPricesCheckBox.setEnabled(false); + shBalanceShopItemPricesCheckBox.setSelected(false); + shGuaranteeEvolutionItemsCheckBox.setVisible(true); + shGuaranteeEvolutionItemsCheckBox.setEnabled(false); + shGuaranteeEvolutionItemsCheckBox.setSelected(false); + shGuaranteeXItemsCheckBox.setVisible(true); + shGuaranteeXItemsCheckBox.setEnabled(false); + shGuaranteeXItemsCheckBox.setSelected(false); + puUnchangedRadioButton.setVisible(true); + puUnchangedRadioButton.setEnabled(false); + puUnchangedRadioButton.setSelected(false); + puRandomRadioButton.setVisible(true); + puRandomRadioButton.setEnabled(false); + puRandomRadioButton.setSelected(false); + puBanBadItemsCheckBox.setVisible(true); + puBanBadItemsCheckBox.setEnabled(false); + puBanBadItemsCheckBox.setSelected(false); + miscBWExpPatchCheckBox.setVisible(true); + miscBWExpPatchCheckBox.setEnabled(false); + miscBWExpPatchCheckBox.setSelected(false); + miscNerfXAccuracyCheckBox.setVisible(true); + miscNerfXAccuracyCheckBox.setEnabled(false); + miscNerfXAccuracyCheckBox.setSelected(false); + miscFixCritRateCheckBox.setVisible(true); + miscFixCritRateCheckBox.setEnabled(false); + miscFixCritRateCheckBox.setSelected(false); + miscFastestTextCheckBox.setVisible(true); + miscFastestTextCheckBox.setEnabled(false); + miscFastestTextCheckBox.setSelected(false); + miscRunningShoesIndoorsCheckBox.setVisible(true); + miscRunningShoesIndoorsCheckBox.setEnabled(false); + miscRunningShoesIndoorsCheckBox.setSelected(false); + miscRandomizePCPotionCheckBox.setVisible(true); + miscRandomizePCPotionCheckBox.setEnabled(false); + miscRandomizePCPotionCheckBox.setSelected(false); + miscAllowPikachuEvolutionCheckBox.setVisible(true); + miscAllowPikachuEvolutionCheckBox.setEnabled(false); + miscAllowPikachuEvolutionCheckBox.setSelected(false); + miscGiveNationalDexAtCheckBox.setVisible(true); + miscGiveNationalDexAtCheckBox.setEnabled(false); + miscGiveNationalDexAtCheckBox.setSelected(false); + miscUpdateTypeEffectivenessCheckBox.setVisible(true); + miscUpdateTypeEffectivenessCheckBox.setEnabled(false); + miscUpdateTypeEffectivenessCheckBox.setSelected(false); + miscLowerCasePokemonNamesCheckBox.setVisible(true); + miscLowerCasePokemonNamesCheckBox.setEnabled(false); + miscLowerCasePokemonNamesCheckBox.setSelected(false); + miscRandomizeCatchingTutorialCheckBox.setVisible(true); + miscRandomizeCatchingTutorialCheckBox.setEnabled(false); + miscRandomizeCatchingTutorialCheckBox.setSelected(false); + miscBanLuckyEggCheckBox.setVisible(true); + miscBanLuckyEggCheckBox.setEnabled(false); + miscBanLuckyEggCheckBox.setSelected(false); + miscNoFreeLuckyEggCheckBox.setVisible(true); + miscNoFreeLuckyEggCheckBox.setEnabled(false); + miscNoFreeLuckyEggCheckBox.setSelected(false); + miscBanBigMoneyManiacCheckBox.setVisible(true); + miscBanBigMoneyManiacCheckBox.setEnabled(false); + miscBanBigMoneyManiacCheckBox.setSelected(false); + mtNoExistLabel.setVisible(false); + mtNoneAvailableLabel.setVisible(false); + + liveTweaksPanel.setVisible(false); + miscTweaksPanel.setVisible(true); + } + + private void romLoaded() { + + try { + int pokemonGeneration = romHandler.generationOfPokemon(); + + setRomNameLabel(); + romCodeLabel.setText(romHandler.getROMCode()); + romSupportLabel.setText(bundle.getString("GUI.romSupportPrefix") + " " + + this.romHandler.getSupportLevel()); + + limitPokemonCheckBox.setVisible(true); + limitPokemonCheckBox.setEnabled(true); + limitPokemonButton.setVisible(true); + + noIrregularAltFormesCheckBox.setVisible(pokemonGeneration >= 4); + noIrregularAltFormesCheckBox.setEnabled(pokemonGeneration >= 4); + + raceModeCheckBox.setEnabled(true); + + loadSettingsButton.setEnabled(true); + saveSettingsButton.setEnabled(true); + + // Pokemon Traits + + // Pokemon Base Statistics + pbsUnchangedRadioButton.setEnabled(true); + pbsUnchangedRadioButton.setSelected(true); + pbsShuffleRadioButton.setEnabled(true); + pbsRandomRadioButton.setEnabled(true); + + pbsStandardizeEXPCurvesCheckBox.setEnabled(true); + pbsLegendariesSlowRadioButton.setSelected(true); + pbsUpdateBaseStatsCheckBox.setEnabled(pokemonGeneration < 8); + pbsFollowMegaEvosCheckBox.setVisible(romHandler.hasMegaEvolutions()); + pbsUpdateComboBox.setVisible(pokemonGeneration < 8); + ExpCurve[] expCurves = getEXPCurvesForGeneration(pokemonGeneration); + String[] expCurveNames = new String[expCurves.length]; + for (int i = 0; i < expCurves.length; i++) { + expCurveNames[i] = expCurves[i].toString(); + } + pbsEXPCurveComboBox.setModel(new DefaultComboBoxModel<>(expCurveNames)); + pbsEXPCurveComboBox.setSelectedIndex(0); + + // Pokemon Types + ptUnchangedRadioButton.setEnabled(true); + ptUnchangedRadioButton.setSelected(true); + ptRandomFollowEvolutionsRadioButton.setEnabled(true); + ptRandomCompletelyRadioButton.setEnabled(true); + ptFollowMegaEvosCheckBox.setVisible(romHandler.hasMegaEvolutions()); + ptIsDualTypeCheckBox.setEnabled(false); + + // Pokemon Abilities + if (pokemonGeneration >= 3) { + paUnchangedRadioButton.setEnabled(true); + paUnchangedRadioButton.setSelected(true); + paRandomRadioButton.setEnabled(true); + + paAllowWonderGuardCheckBox.setEnabled(false); + paFollowEvolutionsCheckBox.setEnabled(false); + paTrappingAbilitiesCheckBox.setEnabled(false); + paNegativeAbilitiesCheckBox.setEnabled(false); + paBadAbilitiesCheckBox.setEnabled(false); + paFollowMegaEvosCheckBox.setVisible(romHandler.hasMegaEvolutions()); + paWeighDuplicatesTogetherCheckBox.setEnabled(false); + } else { + pokemonAbilitiesPanel.setVisible(false); + } + + // Pokemon Evolutions + peUnchangedRadioButton.setEnabled(true); + peUnchangedRadioButton.setSelected(true); + peRandomRadioButton.setEnabled(true); + peRandomEveryLevelRadioButton.setVisible(pokemonGeneration >= 3); + peRandomEveryLevelRadioButton.setEnabled(pokemonGeneration >= 3); + peChangeImpossibleEvosCheckBox.setEnabled(true); + peMakeEvolutionsEasierCheckBox.setEnabled(true); + peRemoveTimeBasedEvolutionsCheckBox.setEnabled(true); + peAllowAltFormesCheckBox.setVisible(pokemonGeneration >= 7); + + // Starters, Statics & Trades + + // Starter Pokemon + spUnchangedRadioButton.setEnabled(true); + spUnchangedRadioButton.setSelected(true); + + spCustomRadioButton.setEnabled(true); + spRandomCompletelyRadioButton.setEnabled(true); + spRandomTwoEvosRadioButton.setEnabled(true); + spAllowAltFormesCheckBox.setVisible(romHandler.hasStarterAltFormes()); + if (romHandler.isYellow()) { + spComboBox3.setVisible(false); + } + populateDropdowns(); + + boolean hasStarterHeldItems = (pokemonGeneration == 2 || pokemonGeneration == 3); + spRandomizeStarterHeldItemsCheckBox.setEnabled(hasStarterHeldItems); + spRandomizeStarterHeldItemsCheckBox.setVisible(hasStarterHeldItems); + spBanBadItemsCheckBox.setEnabled(false); + spBanBadItemsCheckBox.setVisible(hasStarterHeldItems); + + stpUnchangedRadioButton.setEnabled(true); + stpUnchangedRadioButton.setSelected(true); + if (romHandler.canChangeStaticPokemon()) { + stpSwapLegendariesSwapStandardsRadioButton.setEnabled(true); + stpRandomCompletelyRadioButton.setEnabled(true); + stpRandomSimilarStrengthRadioButton.setEnabled(true); + stpLimitMainGameLegendariesCheckBox.setVisible(romHandler.hasMainGameLegendaries()); + stpLimitMainGameLegendariesCheckBox.setEnabled(false); + stpAllowAltFormesCheckBox.setVisible(romHandler.hasStaticAltFormes()); + stpSwapMegaEvosCheckBox.setVisible(pokemonGeneration == 6 && !romHandler.forceSwapStaticMegaEvos()); + stpPercentageLevelModifierCheckBox.setVisible(true); + stpPercentageLevelModifierCheckBox.setEnabled(true); + stpPercentageLevelModifierSlider.setVisible(true); + stpPercentageLevelModifierSlider.setEnabled(false); + stpFixMusicCheckBox.setVisible(romHandler.hasStaticMusicFix()); + stpFixMusicCheckBox.setEnabled(false); + } else { + stpSwapLegendariesSwapStandardsRadioButton.setVisible(false); + stpRandomCompletelyRadioButton.setVisible(false); + stpRandomSimilarStrengthRadioButton.setVisible(false); + stpRandomize600BSTCheckBox.setVisible(false); + stpLimitMainGameLegendariesCheckBox.setVisible(false); + stpPercentageLevelModifierCheckBox.setVisible(false); + stpPercentageLevelModifierSlider.setVisible(false); + stpFixMusicCheckBox.setVisible(false); + } + + igtUnchangedRadioButton.setEnabled(true); + igtUnchangedRadioButton.setSelected(true); + igtRandomizeGivenPokemonOnlyRadioButton.setEnabled(true); + igtRandomizeBothRequestedGivenRadioButton.setEnabled(true); + + igtRandomizeNicknamesCheckBox.setEnabled(false); + igtRandomizeOTsCheckBox.setEnabled(false); + igtRandomizeIVsCheckBox.setEnabled(false); + igtRandomizeItemsCheckBox.setEnabled(false); + + if (pokemonGeneration == 1) { + igtRandomizeOTsCheckBox.setVisible(false); + igtRandomizeIVsCheckBox.setVisible(false); + igtRandomizeItemsCheckBox.setVisible(false); + } + + // Move Data + mdRandomizeMovePowerCheckBox.setEnabled(true); + mdRandomizeMoveAccuracyCheckBox.setEnabled(true); + mdRandomizeMovePPCheckBox.setEnabled(true); + mdRandomizeMoveTypesCheckBox.setEnabled(true); + mdRandomizeMoveCategoryCheckBox.setEnabled(romHandler.hasPhysicalSpecialSplit()); + mdRandomizeMoveCategoryCheckBox.setVisible(romHandler.hasPhysicalSpecialSplit()); + mdUpdateMovesCheckBox.setEnabled(pokemonGeneration < 8); + mdUpdateMovesCheckBox.setVisible(pokemonGeneration < 8); + + // Pokemon Movesets + pmsUnchangedRadioButton.setEnabled(true); + pmsUnchangedRadioButton.setSelected(true); + pmsRandomPreferringSameTypeRadioButton.setEnabled(true); + pmsRandomCompletelyRadioButton.setEnabled(true); + pmsMetronomeOnlyModeRadioButton.setEnabled(true); + + pmsGuaranteedLevel1MovesCheckBox.setVisible(romHandler.supportsFourStartingMoves()); + pmsGuaranteedLevel1MovesSlider.setVisible(romHandler.supportsFourStartingMoves()); + pmsEvolutionMovesCheckBox.setVisible(pokemonGeneration >= 7); + + tpComboBox.setEnabled(true); + tpAllowAlternateFormesCheckBox.setVisible(romHandler.hasFunctionalFormes()); + tpForceFullyEvolvedAtCheckBox.setEnabled(true); + tpPercentageLevelModifierCheckBox.setEnabled(true); + tpSwapMegaEvosCheckBox.setVisible(romHandler.hasMegaEvolutions()); + tpDoubleBattleModeCheckBox.setVisible(pokemonGeneration >= 3); + + boolean additionalPokemonAvailable = pokemonGeneration >= 3; + + tpAdditionalPokemonForLabel.setVisible(additionalPokemonAvailable); + tpBossTrainersCheckBox.setVisible(additionalPokemonAvailable); + tpBossTrainersCheckBox.setEnabled(false); + tpBossTrainersSpinner.setVisible(additionalPokemonAvailable); + tpImportantTrainersCheckBox.setVisible(additionalPokemonAvailable); + tpImportantTrainersCheckBox.setEnabled(false); + tpImportantTrainersSpinner.setVisible(additionalPokemonAvailable); + tpRegularTrainersCheckBox.setVisible(additionalPokemonAvailable); + tpRegularTrainersCheckBox.setEnabled(false); + tpRegularTrainersSpinner.setVisible(additionalPokemonAvailable); + + boolean trainersHeldItemSupport = pokemonGeneration >= 3; + tpHeldItemsLabel.setVisible(trainersHeldItemSupport); + tpBossTrainersItemsCheckBox.setVisible(trainersHeldItemSupport); + tpBossTrainersItemsCheckBox.setEnabled(false); + tpImportantTrainersItemsCheckBox.setVisible(trainersHeldItemSupport); + tpImportantTrainersItemsCheckBox.setEnabled(false); + tpRegularTrainersItemsCheckBox.setVisible(trainersHeldItemSupport); + tpRegularTrainersItemsCheckBox.setEnabled(false); + tpConsumableItemsOnlyCheckBox.setVisible(trainersHeldItemSupport); + tpConsumableItemsOnlyCheckBox.setEnabled(false); + tpSensibleItemsCheckBox.setVisible(trainersHeldItemSupport); + tpSensibleItemsCheckBox.setEnabled(false); + tpHighestLevelGetsItemCheckBox.setVisible(trainersHeldItemSupport); + tpHighestLevelGetsItemCheckBox.setEnabled(false); + + tpEliteFourUniquePokemonCheckBox.setVisible(pokemonGeneration >= 3); + tpEliteFourUniquePokemonSpinner.setVisible(pokemonGeneration >= 3); + + tpRandomizeTrainerNamesCheckBox.setEnabled(true); + tpRandomizeTrainerClassNamesCheckBox.setEnabled(true); + tpNoEarlyWonderGuardCheckBox.setVisible(pokemonGeneration >= 3); + tpRandomShinyTrainerPokemonCheckBox.setVisible(pokemonGeneration >= 7); + + totpPanel.setVisible(pokemonGeneration == 7); + if (totpPanel.isVisible()) { + totpUnchangedRadioButton.setEnabled(true); + totpRandomRadioButton.setEnabled(true); + totpRandomSimilarStrengthRadioButton.setEnabled(true); + + totpAllyPanel.setVisible(pokemonGeneration == 7); + totpAllyUnchangedRadioButton.setEnabled(true); + totpAllyRandomRadioButton.setEnabled(true); + totpAllyRandomSimilarStrengthRadioButton.setEnabled(true); + + totpAuraPanel.setVisible(pokemonGeneration == 7); + totpAuraUnchangedRadioButton.setEnabled(true); + totpAuraRandomRadioButton.setEnabled(true); + totpAuraRandomSameStrengthRadioButton.setEnabled(true); + + totpRandomizeHeldItemsCheckBox.setEnabled(true); + totpAllowAltFormesCheckBox.setEnabled(false); + totpPercentageLevelModifierCheckBox.setEnabled(true); + totpPercentageLevelModifierSlider.setEnabled(false); + } + + // Wild Pokemon + wpUnchangedRadioButton.setEnabled(true); + wpUnchangedRadioButton.setSelected(true); + wpRandomRadioButton.setEnabled(true); + wpArea1To1RadioButton.setEnabled(true); + wpGlobal1To1RadioButton.setEnabled(true); + + wpARNoneRadioButton.setSelected(true); + + wpUseTimeBasedEncountersCheckBox.setVisible(romHandler.hasTimeBasedEncounters()); + wpSetMinimumCatchRateCheckBox.setEnabled(true); + wpRandomizeHeldItemsCheckBox.setEnabled(true); + wpRandomizeHeldItemsCheckBox.setVisible(pokemonGeneration != 1); + wpBanBadItemsCheckBox.setVisible(pokemonGeneration != 1); + wpBalanceShakingGrassPokemonCheckBox.setVisible(pokemonGeneration == 5); + wpPercentageLevelModifierCheckBox.setEnabled(true); + wpAllowAltFormesCheckBox.setVisible(romHandler.hasWildAltFormes()); + + tmUnchangedRadioButton.setEnabled(true); + tmUnchangedRadioButton.setSelected(true); + tmRandomRadioButton.setEnabled(true); + tmFullHMCompatibilityCheckBox.setVisible(pokemonGeneration < 7); + if (tmFullHMCompatibilityCheckBox.isVisible()) { + tmFullHMCompatibilityCheckBox.setEnabled(true); + } + + thcUnchangedRadioButton.setEnabled(true); + thcUnchangedRadioButton.setSelected(true); + thcRandomPreferSameTypeRadioButton.setEnabled(true); + thcRandomCompletelyRadioButton.setEnabled(true); + thcFullCompatibilityRadioButton.setEnabled(true); + + if (romHandler.hasMoveTutors()) { + mtMovesPanel.setVisible(true); + mtCompatPanel.setVisible(true); + mtNoExistLabel.setVisible(false); + + mtUnchangedRadioButton.setEnabled(true); + mtUnchangedRadioButton.setSelected(true); + mtRandomRadioButton.setEnabled(true); + + mtcUnchangedRadioButton.setEnabled(true); + mtcUnchangedRadioButton.setSelected(true); + mtcRandomPreferSameTypeRadioButton.setEnabled(true); + mtcRandomCompletelyRadioButton.setEnabled(true); + mtcFullCompatibilityRadioButton.setEnabled(true); + } else { + mtMovesPanel.setVisible(false); + mtCompatPanel.setVisible(false); + mtNoExistLabel.setVisible(true); + } + + fiUnchangedRadioButton.setEnabled(true); + fiUnchangedRadioButton.setSelected(true); + fiShuffleRadioButton.setEnabled(true); + fiRandomRadioButton.setEnabled(true); + fiRandomEvenDistributionRadioButton.setEnabled(true); + + shopItemsPanel.setVisible(romHandler.hasShopRandomization()); + shUnchangedRadioButton.setEnabled(true); + shUnchangedRadioButton.setSelected(true); + shShuffleRadioButton.setEnabled(true); + shRandomRadioButton.setEnabled(true); + + pickupItemsPanel.setVisible(romHandler.abilitiesPerPokemon() > 0); + puUnchangedRadioButton.setEnabled(true); + puUnchangedRadioButton.setSelected(true); + puRandomRadioButton.setEnabled(true); + + int mtsAvailable = romHandler.miscTweaksAvailable(); + int mtCount = MiscTweak.allTweaks.size(); + List<JCheckBox> usableCheckBoxes = new ArrayList<>(); + + for (int mti = 0; mti < mtCount; mti++) { + MiscTweak mt = MiscTweak.allTweaks.get(mti); + JCheckBox mtCB = tweakCheckBoxes.get(mti); + mtCB.setSelected(false); + if ((mtsAvailable & mt.getValue()) != 0) { + mtCB.setVisible(true); + mtCB.setEnabled(true); + usableCheckBoxes.add(mtCB); + } else { + mtCB.setVisible(false); + mtCB.setEnabled(false); + } + } + + if (usableCheckBoxes.size() > 0) { + setTweaksPanel(usableCheckBoxes); + //tabbedPane1.setComponentAt(7,makeTweaksLayout(usableCheckBoxes)); + //miscTweaksPanel.setLayout(makeTweaksLayout(usableCheckBoxes)); + } else { + mtNoneAvailableLabel.setVisible(true); + liveTweaksPanel.setVisible(false); + miscTweaksPanel.setVisible(true); + //miscTweaksPanel.setLayout(noTweaksLayout); + } + + gameMascotLabel.setIcon(makeMascotIcon()); + + if (romHandler instanceof AbstractDSRomHandler) { + ((AbstractDSRomHandler) romHandler).closeInnerRom(); + } else if (romHandler instanceof Abstract3DSRomHandler) { + ((Abstract3DSRomHandler) romHandler).closeInnerRom(); + } + } catch (Exception e) { + attemptToLogException(e, "GUI.processFailed","GUI.processFailedNoLog", null, null); + romHandler = null; + initialState(); + } + } + + private void setRomNameLabel() { + if (romHandler.hasGameUpdateLoaded()) { + romNameLabel.setText(romHandler.getROMName() + " (" + romHandler.getGameUpdateVersion() + ")"); + } else { + romNameLabel.setText(romHandler.getROMName()); + } + if (!romHandler.isRomValid()) { + romNameLabel.setForeground(Color.RED); + romNameLabel.setText(romNameLabel.getText() + " [Bad CRC32]"); + showInvalidRomPopup(); + } else { + romNameLabel.setForeground(Color.BLACK); + } + } + + private void setTweaksPanel(List<JCheckBox> usableCheckBoxes) { + mtNoneAvailableLabel.setVisible(false); + miscTweaksPanel.setVisible(false); + baseTweaksPanel.remove(liveTweaksPanel); + makeTweaksLayout(usableCheckBoxes); + GridBagConstraints c = new GridBagConstraints(); + c.fill = GridBagConstraints.BOTH; + c.weightx = 0.1; + c.weighty = 0.1; + c.gridx = 1; + c.gridy = 1; + baseTweaksPanel.add(liveTweaksPanel,c); + liveTweaksPanel.setVisible(true); + } + + private void enableOrDisableSubControls() { + + if (limitPokemonCheckBox.isSelected()) { + limitPokemonButton.setEnabled(true); + } else { + limitPokemonButton.setEnabled(false); + } + + boolean followEvolutionControlsEnabled = !peRandomEveryLevelRadioButton.isSelected(); + boolean followMegaEvolutionControlsEnabled = !(peRandomEveryLevelRadioButton.isSelected() && !noIrregularAltFormesCheckBox.isSelected() && peAllowAltFormesCheckBox.isSelected()); + + if (peRandomEveryLevelRadioButton.isSelected()) { + // If Evolve Every Level is enabled, unselect all "Follow Evolutions" controls + pbsFollowEvolutionsCheckBox.setSelected(false); + ptRandomFollowEvolutionsRadioButton.setEnabled(false); + if (ptRandomFollowEvolutionsRadioButton.isSelected()) { + ptRandomFollowEvolutionsRadioButton.setSelected(false); + ptRandomCompletelyRadioButton.setSelected(true); + } + spRandomTwoEvosRadioButton.setEnabled(false); + if (spRandomTwoEvosRadioButton.isSelected()) { + spRandomTwoEvosRadioButton.setSelected(false); + spRandomCompletelyRadioButton.setSelected(true); + } + paFollowEvolutionsCheckBox.setSelected(false); + tmFollowEvolutionsCheckBox.setSelected(false); + mtFollowEvolutionsCheckBox.setSelected(false); + + // If the Follow Mega Evolution controls should be disabled, deselect them here too + if (!followMegaEvolutionControlsEnabled) { + pbsFollowMegaEvosCheckBox.setSelected(false); + ptFollowMegaEvosCheckBox.setSelected(false); + paFollowMegaEvosCheckBox.setSelected(false); + } + + // Also disable/unselect all the settings that make evolutions easier/possible, + // since they aren't relevant in this scenario at all. + peChangeImpossibleEvosCheckBox.setEnabled(false); + peChangeImpossibleEvosCheckBox.setSelected(false); + peMakeEvolutionsEasierCheckBox.setEnabled(false); + peMakeEvolutionsEasierCheckBox.setSelected(false); + peRemoveTimeBasedEvolutionsCheckBox.setEnabled(false); + peRemoveTimeBasedEvolutionsCheckBox.setSelected(false); + + // Disable "Force Fully Evolved" Trainer Pokemon + tpForceFullyEvolvedAtCheckBox.setSelected(false); + tpForceFullyEvolvedAtCheckBox.setEnabled(false); + tpForceFullyEvolvedAtSlider.setEnabled(false); + tpForceFullyEvolvedAtSlider.setValue(tpForceFullyEvolvedAtSlider.getMinimum()); + } else { + // All other "Follow Evolutions" controls get properly set/unset below + // except this one, so manually enable it again. + ptRandomFollowEvolutionsRadioButton.setEnabled(true); + spRandomTwoEvosRadioButton.setEnabled(true); + + // The controls that make evolutions easier/possible, however, + // need to all be manually re-enabled. + peChangeImpossibleEvosCheckBox.setEnabled(true); + peMakeEvolutionsEasierCheckBox.setEnabled(true); + peRemoveTimeBasedEvolutionsCheckBox.setEnabled(true); + + // Re-enable "Force Fully Evolved" Trainer Pokemon + tpForceFullyEvolvedAtCheckBox.setEnabled(true); + } + + if (pbsUnchangedRadioButton.isSelected()) { + pbsFollowEvolutionsCheckBox.setEnabled(false); + pbsFollowEvolutionsCheckBox.setSelected(false); + pbsFollowMegaEvosCheckBox.setEnabled(false); + pbsFollowMegaEvosCheckBox.setSelected(false); + } else { + pbsFollowEvolutionsCheckBox.setEnabled(followEvolutionControlsEnabled); + pbsFollowMegaEvosCheckBox.setEnabled(followMegaEvolutionControlsEnabled); + } + + if (pbsRandomRadioButton.isSelected()) { + if (pbsFollowEvolutionsCheckBox.isSelected() || pbsFollowMegaEvosCheckBox.isSelected()) { + pbsAssignEvoStatsRandomlyCheckBox.setEnabled(true); + } else { + pbsAssignEvoStatsRandomlyCheckBox.setEnabled(false); + pbsAssignEvoStatsRandomlyCheckBox.setSelected(false); + } + } else { + pbsAssignEvoStatsRandomlyCheckBox.setEnabled(false); + pbsAssignEvoStatsRandomlyCheckBox.setSelected(false); + } + + if (pbsStandardizeEXPCurvesCheckBox.isSelected()) { + pbsLegendariesSlowRadioButton.setEnabled(true); + pbsStrongLegendariesSlowRadioButton.setEnabled(true); + pbsAllMediumFastRadioButton.setEnabled(true); + pbsEXPCurveComboBox.setEnabled(true); + } else { + pbsLegendariesSlowRadioButton.setEnabled(false); + pbsLegendariesSlowRadioButton.setSelected(true); + pbsStrongLegendariesSlowRadioButton.setEnabled(false); + pbsAllMediumFastRadioButton.setEnabled(false); + pbsEXPCurveComboBox.setEnabled(false); + } + + if (pbsUpdateBaseStatsCheckBox.isSelected()) { + pbsUpdateComboBox.setEnabled(true); + } else { + pbsUpdateComboBox.setEnabled(false); + } + + if (ptUnchangedRadioButton.isSelected()) { + ptFollowMegaEvosCheckBox.setEnabled(false); + ptFollowMegaEvosCheckBox.setSelected(false); + ptIsDualTypeCheckBox.setEnabled(false); + ptIsDualTypeCheckBox.setSelected(false); + } else { + ptFollowMegaEvosCheckBox.setEnabled(followMegaEvolutionControlsEnabled); + ptIsDualTypeCheckBox.setEnabled(true); + } + + if (paRandomRadioButton.isSelected()) { + paAllowWonderGuardCheckBox.setEnabled(true); + paFollowEvolutionsCheckBox.setEnabled(followEvolutionControlsEnabled); + paFollowMegaEvosCheckBox.setEnabled(followMegaEvolutionControlsEnabled); + paTrappingAbilitiesCheckBox.setEnabled(true); + paNegativeAbilitiesCheckBox.setEnabled(true); + paBadAbilitiesCheckBox.setEnabled(true); + paWeighDuplicatesTogetherCheckBox.setEnabled(true); + } else { + paAllowWonderGuardCheckBox.setEnabled(false); + paAllowWonderGuardCheckBox.setSelected(false); + paFollowEvolutionsCheckBox.setEnabled(false); + paFollowEvolutionsCheckBox.setSelected(false); + paTrappingAbilitiesCheckBox.setEnabled(false); + paTrappingAbilitiesCheckBox.setSelected(false); + paNegativeAbilitiesCheckBox.setEnabled(false); + paNegativeAbilitiesCheckBox.setSelected(false); + paBadAbilitiesCheckBox.setEnabled(false); + paBadAbilitiesCheckBox.setSelected(false); + paFollowMegaEvosCheckBox.setEnabled(false); + paFollowMegaEvosCheckBox.setSelected(false); + paWeighDuplicatesTogetherCheckBox.setEnabled(false); + paWeighDuplicatesTogetherCheckBox.setSelected(false); + } + + if (peRandomRadioButton.isSelected()) { + peSimilarStrengthCheckBox.setEnabled(true); + peSameTypingCheckBox.setEnabled(true); + peLimitEvolutionsToThreeCheckBox.setEnabled(true); + peForceChangeCheckBox.setEnabled(true); + peAllowAltFormesCheckBox.setEnabled(true); + } else if (peRandomEveryLevelRadioButton.isSelected()) { + peSimilarStrengthCheckBox.setEnabled(false); + peSimilarStrengthCheckBox.setSelected(false); + peSameTypingCheckBox.setEnabled(true); + peLimitEvolutionsToThreeCheckBox.setEnabled(false); + peLimitEvolutionsToThreeCheckBox.setSelected(false); + peForceChangeCheckBox.setEnabled(true); + peAllowAltFormesCheckBox.setEnabled(true); + } else { + peSimilarStrengthCheckBox.setEnabled(false); + peSimilarStrengthCheckBox.setSelected(false); + peSameTypingCheckBox.setEnabled(false); + peSameTypingCheckBox.setSelected(false); + peLimitEvolutionsToThreeCheckBox.setEnabled(false); + peLimitEvolutionsToThreeCheckBox.setSelected(false); + peForceChangeCheckBox.setEnabled(false); + peForceChangeCheckBox.setSelected(false); + peAllowAltFormesCheckBox.setEnabled(false); + peAllowAltFormesCheckBox.setSelected(false); + } + + boolean spCustomStatus = spCustomRadioButton.isSelected(); + spComboBox1.setEnabled(spCustomStatus); + spComboBox2.setEnabled(spCustomStatus); + spComboBox3.setEnabled(spCustomStatus); + + if (spUnchangedRadioButton.isSelected()) { + spAllowAltFormesCheckBox.setEnabled(false); + spAllowAltFormesCheckBox.setSelected(false); + } else { + spAllowAltFormesCheckBox.setEnabled(true); + } + + if (spRandomizeStarterHeldItemsCheckBox.isSelected()) { + spBanBadItemsCheckBox.setEnabled(true); + } else { + spBanBadItemsCheckBox.setEnabled(false); + spBanBadItemsCheckBox.setSelected(false); + } + + if (stpUnchangedRadioButton.isSelected()) { + stpRandomize600BSTCheckBox.setEnabled(false); + stpRandomize600BSTCheckBox.setSelected(false); + stpAllowAltFormesCheckBox.setEnabled(false); + stpAllowAltFormesCheckBox.setSelected(false); + stpSwapMegaEvosCheckBox.setEnabled(false); + stpSwapMegaEvosCheckBox.setSelected(false); + stpFixMusicCheckBox.setEnabled(false); + stpFixMusicCheckBox.setSelected(false); + } else { + stpRandomize600BSTCheckBox.setEnabled(true); + stpAllowAltFormesCheckBox.setEnabled(true); + stpSwapMegaEvosCheckBox.setEnabled(true); + stpFixMusicCheckBox.setEnabled(true); + } + + if (stpRandomSimilarStrengthRadioButton.isSelected()) { + stpLimitMainGameLegendariesCheckBox.setEnabled(stpLimitMainGameLegendariesCheckBox.isVisible()); + } else { + stpLimitMainGameLegendariesCheckBox.setEnabled(false); + stpLimitMainGameLegendariesCheckBox.setSelected(false); + } + + if (stpPercentageLevelModifierCheckBox.isSelected()) { + stpPercentageLevelModifierSlider.setEnabled(true); + } else { + stpPercentageLevelModifierSlider.setEnabled(false); + stpPercentageLevelModifierSlider.setValue(0); + } + + if (igtUnchangedRadioButton.isSelected()) { + igtRandomizeItemsCheckBox.setEnabled(false); + igtRandomizeItemsCheckBox.setSelected(false); + igtRandomizeIVsCheckBox.setEnabled(false); + igtRandomizeIVsCheckBox.setSelected(false); + igtRandomizeNicknamesCheckBox.setEnabled(false); + igtRandomizeNicknamesCheckBox.setSelected(false); + igtRandomizeOTsCheckBox.setEnabled(false); + igtRandomizeOTsCheckBox.setSelected(false); + } else { + igtRandomizeItemsCheckBox.setEnabled(true); + igtRandomizeIVsCheckBox.setEnabled(true); + igtRandomizeNicknamesCheckBox.setEnabled(true); + igtRandomizeOTsCheckBox.setEnabled(true); + } + + if (mdUpdateMovesCheckBox.isSelected()) { + mdUpdateComboBox.setEnabled(true); + } else { + mdUpdateComboBox.setEnabled(false); + } + + if (pmsMetronomeOnlyModeRadioButton.isSelected() || pmsUnchangedRadioButton.isSelected()) { + pmsGuaranteedLevel1MovesCheckBox.setEnabled(false); + pmsGuaranteedLevel1MovesCheckBox.setSelected(false); + pmsForceGoodDamagingCheckBox.setEnabled(false); + pmsForceGoodDamagingCheckBox.setSelected(false); + pmsReorderDamagingMovesCheckBox.setEnabled(false); + pmsReorderDamagingMovesCheckBox.setSelected(false); + pmsNoGameBreakingMovesCheckBox.setEnabled(false); + pmsNoGameBreakingMovesCheckBox.setSelected(false); + pmsEvolutionMovesCheckBox.setEnabled(false); + pmsEvolutionMovesCheckBox.setSelected(false); + } else { + pmsGuaranteedLevel1MovesCheckBox.setEnabled(true); + pmsForceGoodDamagingCheckBox.setEnabled(true); + pmsReorderDamagingMovesCheckBox.setEnabled(true); + pmsNoGameBreakingMovesCheckBox.setEnabled(true); + pmsEvolutionMovesCheckBox.setEnabled(true); + } + + if (pmsGuaranteedLevel1MovesCheckBox.isSelected()) { + pmsGuaranteedLevel1MovesSlider.setEnabled(true); + } else { + pmsGuaranteedLevel1MovesSlider.setEnabled(false); + pmsGuaranteedLevel1MovesSlider.setValue(pmsGuaranteedLevel1MovesSlider.getMinimum()); + } + + if (pmsForceGoodDamagingCheckBox.isSelected()) { + pmsForceGoodDamagingSlider.setEnabled(true); + } else { + pmsForceGoodDamagingSlider.setEnabled(false); + pmsForceGoodDamagingSlider.setValue(pmsForceGoodDamagingSlider.getMinimum()); + } + + if (isTrainerSetting(TRAINER_UNCHANGED)) { + tpSimilarStrengthCheckBox.setEnabled(false); + tpSimilarStrengthCheckBox.setSelected(false); + tpDontUseLegendariesCheckBox.setEnabled(false); + tpDontUseLegendariesCheckBox.setSelected(false); + tpNoEarlyWonderGuardCheckBox.setEnabled(false); + tpNoEarlyWonderGuardCheckBox.setSelected(false); + tpAllowAlternateFormesCheckBox.setEnabled(false); + tpAllowAlternateFormesCheckBox.setSelected(false); + tpSwapMegaEvosCheckBox.setEnabled(false); + tpSwapMegaEvosCheckBox.setSelected(false); + tpRandomShinyTrainerPokemonCheckBox.setEnabled(false); + tpRandomShinyTrainerPokemonCheckBox.setSelected(false); + tpDoubleBattleModeCheckBox.setEnabled(false); + tpDoubleBattleModeCheckBox.setSelected(false); + tpBossTrainersCheckBox.setEnabled(false); + tpBossTrainersCheckBox.setSelected(false); + tpImportantTrainersCheckBox.setEnabled(false); + tpImportantTrainersCheckBox.setSelected(false); + tpRegularTrainersCheckBox.setEnabled(false); + tpRegularTrainersCheckBox.setSelected(false); + tpBossTrainersItemsCheckBox.setEnabled(false); + tpBossTrainersItemsCheckBox.setSelected(false); + tpImportantTrainersItemsCheckBox.setEnabled(false); + tpImportantTrainersItemsCheckBox.setSelected(false); + tpRegularTrainersItemsCheckBox.setEnabled(false); + tpRegularTrainersItemsCheckBox.setSelected(false); + tpConsumableItemsOnlyCheckBox.setEnabled(false); + tpConsumableItemsOnlyCheckBox.setSelected(false); + tpSensibleItemsCheckBox.setEnabled(false); + tpSensibleItemsCheckBox.setSelected(false); + tpHighestLevelGetsItemCheckBox.setEnabled(false); + tpHighestLevelGetsItemCheckBox.setSelected(false); + tpEliteFourUniquePokemonCheckBox.setEnabled(false); + tpEliteFourUniquePokemonCheckBox.setSelected(false); + } else { + tpSimilarStrengthCheckBox.setEnabled(true); + tpDontUseLegendariesCheckBox.setEnabled(true); + tpNoEarlyWonderGuardCheckBox.setEnabled(true); + tpAllowAlternateFormesCheckBox.setEnabled(true); + if (currentRestrictions == null || currentRestrictions.allowTrainerSwapMegaEvolvables( + romHandler.forceSwapStaticMegaEvos(), isTrainerSetting(TRAINER_TYPE_THEMED))) { + tpSwapMegaEvosCheckBox.setEnabled(true); + } else { + tpSwapMegaEvosCheckBox.setEnabled(false); + tpSwapMegaEvosCheckBox.setSelected(false); + } + tpRandomShinyTrainerPokemonCheckBox.setEnabled(true); + tpDoubleBattleModeCheckBox.setEnabled(tpDoubleBattleModeCheckBox.isVisible()); + tpBossTrainersCheckBox.setEnabled(tpBossTrainersCheckBox.isVisible()); + tpImportantTrainersCheckBox.setEnabled(tpImportantTrainersCheckBox.isVisible()); + tpRegularTrainersCheckBox.setEnabled(tpRegularTrainersCheckBox.isVisible()); + tpBossTrainersItemsCheckBox.setEnabled(tpBossTrainersItemsCheckBox.isVisible()); + tpImportantTrainersItemsCheckBox.setEnabled(tpImportantTrainersItemsCheckBox.isVisible()); + tpRegularTrainersItemsCheckBox.setEnabled(tpRegularTrainersItemsCheckBox.isVisible()); + tpEliteFourUniquePokemonCheckBox.setEnabled(tpEliteFourUniquePokemonCheckBox.isVisible()); + } + + if (tpForceFullyEvolvedAtCheckBox.isSelected()) { + tpForceFullyEvolvedAtSlider.setEnabled(true); + } else { + tpForceFullyEvolvedAtSlider.setEnabled(false); + tpForceFullyEvolvedAtSlider.setValue(tpForceFullyEvolvedAtSlider.getMinimum()); + } + + if (tpPercentageLevelModifierCheckBox.isSelected()) { + tpPercentageLevelModifierSlider.setEnabled(true); + } else { + tpPercentageLevelModifierSlider.setEnabled(false); + tpPercentageLevelModifierSlider.setValue(0); + } + + if (tpBossTrainersCheckBox.isSelected()) { + tpBossTrainersSpinner.setEnabled(true); + } else { + tpBossTrainersSpinner.setEnabled(false); + tpBossTrainersSpinner.setValue(1); + } + + if (tpImportantTrainersCheckBox.isSelected()) { + tpImportantTrainersSpinner.setEnabled(true); + } else { + tpImportantTrainersSpinner.setEnabled(false); + tpImportantTrainersSpinner.setValue(1); + } + + if (tpRegularTrainersCheckBox.isSelected()) { + tpRegularTrainersSpinner.setEnabled(true); + } else { + tpRegularTrainersSpinner.setEnabled(false); + tpRegularTrainersSpinner.setValue(1); + } + + if (tpBossTrainersItemsCheckBox.isSelected() || tpImportantTrainersItemsCheckBox.isSelected() || + tpRegularTrainersItemsCheckBox.isSelected()) { + tpConsumableItemsOnlyCheckBox.setEnabled(true); + tpSensibleItemsCheckBox.setEnabled(true); + tpHighestLevelGetsItemCheckBox.setEnabled(true); + } else { + tpConsumableItemsOnlyCheckBox.setEnabled(false); + tpSensibleItemsCheckBox.setEnabled(false); + tpHighestLevelGetsItemCheckBox.setEnabled(false); + } + + if (!spUnchangedRadioButton.isSelected() || !isTrainerSetting(TRAINER_UNCHANGED)) { + tpRivalCarriesStarterCheckBox.setEnabled(true); + } else { + tpRivalCarriesStarterCheckBox.setEnabled(false); + tpRivalCarriesStarterCheckBox.setSelected(false); + } + + if (isTrainerSetting(TRAINER_TYPE_THEMED)) { + tpWeightTypesCheckBox.setEnabled(true); + } else { + tpWeightTypesCheckBox.setEnabled(false); + tpWeightTypesCheckBox.setSelected(false); + } + + if (tpEliteFourUniquePokemonCheckBox.isSelected()) { + tpEliteFourUniquePokemonSpinner.setEnabled(true); + } else { + tpEliteFourUniquePokemonSpinner.setEnabled(false); + tpEliteFourUniquePokemonSpinner.setValue(1); + } + + if (!totpUnchangedRadioButton.isSelected() || !totpAllyUnchangedRadioButton.isSelected()) { + totpAllowAltFormesCheckBox.setEnabled(true); + } else { + totpAllowAltFormesCheckBox.setEnabled(false); + totpAllowAltFormesCheckBox.setSelected(false); + } + + if (totpPercentageLevelModifierCheckBox.isSelected()) { + totpPercentageLevelModifierSlider.setEnabled(true); + } else { + totpPercentageLevelModifierSlider.setEnabled(false); + totpPercentageLevelModifierSlider.setValue(0); + } + + if (wpRandomRadioButton.isSelected()) { + wpARNoneRadioButton.setEnabled(true); + wpARSimilarStrengthRadioButton.setEnabled(true); + wpARCatchEmAllModeRadioButton.setEnabled(true); + wpARTypeThemeAreasRadioButton.setEnabled(true); + wpBalanceShakingGrassPokemonCheckBox.setEnabled(true); + } else if (wpArea1To1RadioButton.isSelected()) { + wpARNoneRadioButton.setEnabled(true); + wpARSimilarStrengthRadioButton.setEnabled(true); + wpARCatchEmAllModeRadioButton.setEnabled(true); + wpARTypeThemeAreasRadioButton.setEnabled(true); + wpBalanceShakingGrassPokemonCheckBox.setEnabled(false); + } else if (wpGlobal1To1RadioButton.isSelected()) { + if (wpARCatchEmAllModeRadioButton.isSelected() || wpARTypeThemeAreasRadioButton.isSelected()) { + wpARNoneRadioButton.setSelected(true); + } + wpARNoneRadioButton.setEnabled(true); + wpARSimilarStrengthRadioButton.setEnabled(true); + wpARCatchEmAllModeRadioButton.setEnabled(false); + wpARTypeThemeAreasRadioButton.setEnabled(false); + wpBalanceShakingGrassPokemonCheckBox.setEnabled(false); + } else { + wpARNoneRadioButton.setEnabled(false); + wpARNoneRadioButton.setSelected(true); + wpARSimilarStrengthRadioButton.setEnabled(false); + wpARCatchEmAllModeRadioButton.setEnabled(false); + wpARTypeThemeAreasRadioButton.setEnabled(false); + wpBalanceShakingGrassPokemonCheckBox.setEnabled(false); + } + + if (wpUnchangedRadioButton.isSelected()) { + wpUseTimeBasedEncountersCheckBox.setEnabled(false); + wpUseTimeBasedEncountersCheckBox.setSelected(false); + wpDontUseLegendariesCheckBox.setEnabled(false); + wpDontUseLegendariesCheckBox.setSelected(false); + wpAllowAltFormesCheckBox.setEnabled(false); + wpAllowAltFormesCheckBox.setSelected(false); + } else { + wpUseTimeBasedEncountersCheckBox.setEnabled(true); + wpDontUseLegendariesCheckBox.setEnabled(true); + wpAllowAltFormesCheckBox.setEnabled(true); + } + + if (wpRandomizeHeldItemsCheckBox.isSelected() + && wpRandomizeHeldItemsCheckBox.isVisible() + && wpRandomizeHeldItemsCheckBox.isEnabled()) { // ??? why all three + wpBanBadItemsCheckBox.setEnabled(true); + } else { + wpBanBadItemsCheckBox.setEnabled(false); + wpBanBadItemsCheckBox.setSelected(false); + } + + if (wpSetMinimumCatchRateCheckBox.isSelected()) { + wpSetMinimumCatchRateSlider.setEnabled(true); + } else { + wpSetMinimumCatchRateSlider.setEnabled(false); + wpSetMinimumCatchRateSlider.setValue(0); + } + + if (wpPercentageLevelModifierCheckBox.isSelected()) { + wpPercentageLevelModifierSlider.setEnabled(true); + } else { + wpPercentageLevelModifierSlider.setEnabled(false); + wpPercentageLevelModifierSlider.setValue(0); + } + + if (pmsMetronomeOnlyModeRadioButton.isSelected()) { + tmUnchangedRadioButton.setEnabled(false); + tmRandomRadioButton.setEnabled(false); + tmUnchangedRadioButton.setSelected(true); + + mtUnchangedRadioButton.setEnabled(false); + mtRandomRadioButton.setEnabled(false); + mtUnchangedRadioButton.setSelected(true); + + tmLevelupMoveSanityCheckBox.setEnabled(false); + tmLevelupMoveSanityCheckBox.setSelected(false); + tmKeepFieldMoveTMsCheckBox.setEnabled(false); + tmKeepFieldMoveTMsCheckBox.setSelected(false); + tmForceGoodDamagingCheckBox.setEnabled(false); + tmForceGoodDamagingCheckBox.setSelected(false); + tmNoGameBreakingMovesCheckBox.setEnabled(false); + tmNoGameBreakingMovesCheckBox.setSelected(false); + tmFollowEvolutionsCheckBox.setEnabled(false); + tmFollowEvolutionsCheckBox.setSelected(false); + + mtLevelupMoveSanityCheckBox.setEnabled(false); + mtLevelupMoveSanityCheckBox.setSelected(false); + mtKeepFieldMoveTutorsCheckBox.setEnabled(false); + mtKeepFieldMoveTutorsCheckBox.setSelected(false); + mtForceGoodDamagingCheckBox.setEnabled(false); + mtForceGoodDamagingCheckBox.setSelected(false); + mtNoGameBreakingMovesCheckBox.setEnabled(false); + mtNoGameBreakingMovesCheckBox.setSelected(false); + mtFollowEvolutionsCheckBox.setEnabled(false); + mtFollowEvolutionsCheckBox.setSelected(false); + } else { + tmUnchangedRadioButton.setEnabled(true); + tmRandomRadioButton.setEnabled(true); + + mtUnchangedRadioButton.setEnabled(true); + mtRandomRadioButton.setEnabled(true); + + if (!(pmsUnchangedRadioButton.isSelected()) || !(tmUnchangedRadioButton.isSelected()) + || !(thcUnchangedRadioButton.isSelected())) { + tmLevelupMoveSanityCheckBox.setEnabled(true); + } else { + tmLevelupMoveSanityCheckBox.setEnabled(false); + tmLevelupMoveSanityCheckBox.setSelected(false); + } + + if ((!thcUnchangedRadioButton.isSelected()) || (tmLevelupMoveSanityCheckBox.isSelected())) { + tmFollowEvolutionsCheckBox.setEnabled(followEvolutionControlsEnabled); + } + else { + tmFollowEvolutionsCheckBox.setEnabled(false); + tmFollowEvolutionsCheckBox.setSelected(false); + } + + if (!(tmUnchangedRadioButton.isSelected())) { + tmKeepFieldMoveTMsCheckBox.setEnabled(true); + tmForceGoodDamagingCheckBox.setEnabled(true); + tmNoGameBreakingMovesCheckBox.setEnabled(true); + } else { + tmKeepFieldMoveTMsCheckBox.setEnabled(false); + tmKeepFieldMoveTMsCheckBox.setSelected(false); + tmForceGoodDamagingCheckBox.setEnabled(false); + tmForceGoodDamagingCheckBox.setSelected(false); + tmNoGameBreakingMovesCheckBox.setEnabled(false); + tmNoGameBreakingMovesCheckBox.setSelected(false); + } + + if (romHandler.hasMoveTutors() + && (!(pmsUnchangedRadioButton.isSelected()) || !(mtUnchangedRadioButton.isSelected()) + || !(mtcUnchangedRadioButton.isSelected()))) { + mtLevelupMoveSanityCheckBox.setEnabled(true); + } else { + mtLevelupMoveSanityCheckBox.setEnabled(false); + mtLevelupMoveSanityCheckBox.setSelected(false); + } + + if (!(mtcUnchangedRadioButton.isSelected()) || (mtLevelupMoveSanityCheckBox.isSelected())) { + mtFollowEvolutionsCheckBox.setEnabled(followEvolutionControlsEnabled); + } + else { + mtFollowEvolutionsCheckBox.setEnabled(false); + mtFollowEvolutionsCheckBox.setSelected(false); + } + + if (romHandler.hasMoveTutors() && !(mtUnchangedRadioButton.isSelected())) { + mtKeepFieldMoveTutorsCheckBox.setEnabled(true); + mtForceGoodDamagingCheckBox.setEnabled(true); + mtNoGameBreakingMovesCheckBox.setEnabled(true); + } else { + mtKeepFieldMoveTutorsCheckBox.setEnabled(false); + mtKeepFieldMoveTutorsCheckBox.setSelected(false); + mtForceGoodDamagingCheckBox.setEnabled(false); + mtForceGoodDamagingCheckBox.setSelected(false); + mtNoGameBreakingMovesCheckBox.setEnabled(false); + mtNoGameBreakingMovesCheckBox.setSelected(false); + } + } + + if (tmForceGoodDamagingCheckBox.isSelected()) { + tmForceGoodDamagingSlider.setEnabled(true); + } else { + tmForceGoodDamagingSlider.setEnabled(false); + tmForceGoodDamagingSlider.setValue(tmForceGoodDamagingSlider.getMinimum()); + } + + if (mtForceGoodDamagingCheckBox.isSelected()) { + mtForceGoodDamagingSlider.setEnabled(true); + } else { + mtForceGoodDamagingSlider.setEnabled(false); + mtForceGoodDamagingSlider.setValue(mtForceGoodDamagingSlider.getMinimum()); + } + + tmFullHMCompatibilityCheckBox.setEnabled(!thcFullCompatibilityRadioButton.isSelected()); + + if (fiRandomRadioButton.isSelected() && fiRandomRadioButton.isVisible() && fiRandomRadioButton.isEnabled()) { + fiBanBadItemsCheckBox.setEnabled(true); + } else if (fiRandomEvenDistributionRadioButton.isSelected() && fiRandomEvenDistributionRadioButton.isVisible() + && fiRandomEvenDistributionRadioButton.isEnabled()) { + fiBanBadItemsCheckBox.setEnabled(true); + } else { + fiBanBadItemsCheckBox.setEnabled(false); + fiBanBadItemsCheckBox.setSelected(false); + } + + if (shRandomRadioButton.isSelected() && shRandomRadioButton.isVisible() && shRandomRadioButton.isEnabled()) { + shBanBadItemsCheckBox.setEnabled(true); + shBanRegularShopItemsCheckBox.setEnabled(true); + shBanOverpoweredShopItemsCheckBox.setEnabled(true); + shBalanceShopItemPricesCheckBox.setEnabled(true); + shGuaranteeEvolutionItemsCheckBox.setEnabled(true); + shGuaranteeXItemsCheckBox.setEnabled(true); + } else { + shBanBadItemsCheckBox.setEnabled(false); + shBanBadItemsCheckBox.setSelected(false); + shBanRegularShopItemsCheckBox.setEnabled(false); + shBanRegularShopItemsCheckBox.setSelected(false); + shBanOverpoweredShopItemsCheckBox.setEnabled(false); + shBanOverpoweredShopItemsCheckBox.setSelected(false); + shBalanceShopItemPricesCheckBox.setEnabled(false); + shBalanceShopItemPricesCheckBox.setSelected(false); + shGuaranteeEvolutionItemsCheckBox.setEnabled(false); + shGuaranteeEvolutionItemsCheckBox.setSelected(false); + shGuaranteeXItemsCheckBox.setEnabled(false); + shGuaranteeXItemsCheckBox.setSelected(false); + } + + if (puRandomRadioButton.isSelected() && puRandomRadioButton.isVisible() && puRandomRadioButton.isEnabled()) { + puBanBadItemsCheckBox.setEnabled(true); + } else { + puBanBadItemsCheckBox.setEnabled(false); + puBanBadItemsCheckBox.setSelected(false); + } + } + + private void initTweaksPanel() { + tweakCheckBoxes = new ArrayList<>(); + int numTweaks = MiscTweak.allTweaks.size(); + for (int i = 0; i < numTweaks; i++) { + MiscTweak ct = MiscTweak.allTweaks.get(i); + JCheckBox tweakBox = new JCheckBox(); + tweakBox.setText(ct.getTweakName()); + tweakBox.setToolTipText(ct.getTooltipText()); + tweakCheckBoxes.add(tweakBox); + } + } + + private void makeTweaksLayout(List<JCheckBox> tweaks) { + liveTweaksPanel = new JPanel(new GridBagLayout()); + TitledBorder border = BorderFactory.createTitledBorder("Misc. Tweaks"); + border.setTitleFont(border.getTitleFont().deriveFont(Font.BOLD)); + liveTweaksPanel.setBorder(border); + + int numTweaks = tweaks.size(); + Iterator<JCheckBox> tweaksIterator = tweaks.iterator(); + + GridBagConstraints c = new GridBagConstraints(); + c.anchor = GridBagConstraints.FIRST_LINE_START; + c.insets = new Insets(5,5,0,5); + + int TWEAK_COLS = 4; + int numCols = Math.min(TWEAK_COLS, numTweaks); + + for (int row = 0; row <= numTweaks / numCols; row++) { + for (int col = 0; col < numCols; col++) { + if (!tweaksIterator.hasNext()) break; + c.gridx = col; + c.gridy = row; + liveTweaksPanel.add(tweaksIterator.next(),c); + } + } + + // Pack the checkboxes together + + GridBagConstraints horizontalC = new GridBagConstraints(); + horizontalC.gridx = numCols; + horizontalC.gridy = 0; + horizontalC.weightx = 0.1; + + GridBagConstraints verticalC = new GridBagConstraints(); + verticalC.gridx = 0; + verticalC.gridy = (numTweaks / numCols) + 1; + verticalC.weighty = 0.1; + + liveTweaksPanel.add(new JSeparator(SwingConstants.HORIZONTAL),horizontalC); + liveTweaksPanel.add(new JSeparator(SwingConstants.VERTICAL),verticalC); + } + + private void populateDropdowns() { + List<Pokemon> currentStarters = romHandler.getStarters(); + List<Pokemon> allPokes = + romHandler.generationOfPokemon() >= 6 ? + romHandler.getPokemonInclFormes() + .stream() + .filter(pk -> pk == null || !pk.actuallyCosmetic) + .collect(Collectors.toList()) : + romHandler.getPokemon(); + String[] pokeNames = new String[allPokes.size() - 1]; + for (int i = 1; i < allPokes.size(); i++) { + pokeNames[i - 1] = allPokes.get(i).fullName(); + } + spComboBox1.setModel(new DefaultComboBoxModel<>(pokeNames)); + spComboBox1.setSelectedIndex(allPokes.indexOf(currentStarters.get(0)) - 1); + spComboBox2.setModel(new DefaultComboBoxModel<>(pokeNames)); + spComboBox2.setSelectedIndex(allPokes.indexOf(currentStarters.get(1)) - 1); + if (!romHandler.isYellow()) { + spComboBox3.setModel(new DefaultComboBoxModel<>(pokeNames)); + spComboBox3.setSelectedIndex(allPokes.indexOf(currentStarters.get(2)) - 1); + } + + String[] baseStatGenerationNumbers = new String[Math.min(3, GlobalConstants.HIGHEST_POKEMON_GEN - romHandler.generationOfPokemon())]; + int j = Math.max(6,romHandler.generationOfPokemon() + 1); + for (int i = 0; i < baseStatGenerationNumbers.length; i++) { + baseStatGenerationNumbers[i] = String.valueOf(j); + j++; + } + pbsUpdateComboBox.setModel(new DefaultComboBoxModel<>(baseStatGenerationNumbers)); + + String[] moveGenerationNumbers = new String[GlobalConstants.HIGHEST_POKEMON_GEN - romHandler.generationOfPokemon()]; + j = romHandler.generationOfPokemon() + 1; + for (int i = 0; i < moveGenerationNumbers.length; i++) { + moveGenerationNumbers[i] = String.valueOf(j); + j++; + } + mdUpdateComboBox.setModel(new DefaultComboBoxModel<>(moveGenerationNumbers)); + + + tpComboBox.setModel(new DefaultComboBoxModel<>(getTrainerSettingsForGeneration(romHandler.generationOfPokemon()))); + tpComboBox.setRenderer(new DefaultListCellRenderer() { + @Override + public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) { + JComponent comp = (JComponent) super.getListCellRendererComponent(list, + value, index, isSelected, cellHasFocus); + + if (index >= 0 && value != null) { + list.setToolTipText(bundle.getString(trainerSettingToolTips.get(trainerSettings.indexOf(value)))); + } + return comp; + } + }); + } + + private ImageIcon makeMascotIcon() { + try { + BufferedImage handlerImg = romHandler.getMascotImage(); + + if (handlerImg == null) { + return emptyIcon; + } + + BufferedImage nImg = new BufferedImage(128, 128, BufferedImage.TYPE_INT_ARGB); + int hW = handlerImg.getWidth(); + int hH = handlerImg.getHeight(); + nImg.getGraphics().drawImage(handlerImg, 64 - hW / 2, 64 - hH / 2, frame); + return new ImageIcon(nImg); + } catch (Exception ex) { + return emptyIcon; + } + } + + private void checkCustomNames() { + String[] cnamefiles = new String[] { SysConstants.tnamesFile, SysConstants.tclassesFile, + SysConstants.nnamesFile }; + + boolean foundFile = false; + for (int file = 0; file < 3; file++) { + File currentFile = new File(SysConstants.ROOT_PATH + cnamefiles[file]); + if (currentFile.exists()) { + foundFile = true; + break; + } + } + + if (foundFile) { + int response = JOptionPane.showConfirmDialog(frame, + bundle.getString("GUI.convertNameFilesDialog.text"), + bundle.getString("GUI.convertNameFilesDialog.title"), JOptionPane.YES_NO_OPTION); + if (response == JOptionPane.YES_OPTION) { + try { + CustomNamesSet newNamesData = CustomNamesSet.importOldNames(); + byte[] data = newNamesData.getBytes(); + FileFunctions.writeBytesToFile(SysConstants.customNamesFile, data); + } catch (IOException ex) { + JOptionPane.showMessageDialog(frame, bundle.getString("GUI.convertNameFilesFailed")); + } + } + + haveCheckedCustomNames = true; + attemptWriteConfig(); + } + + } + + private void attemptReadConfig() { + // Things that should be true by default should be manually set here + unloadGameOnSuccess = true; + File fh = new File(SysConstants.ROOT_PATH + "config.ini"); + if (!fh.exists() || !fh.canRead()) { + return; + } + + try { + Scanner sc = new Scanner(fh, "UTF-8"); + boolean isReadingUpdates = false; + while (sc.hasNextLine()) { + String q = sc.nextLine().trim(); + if (q.contains("//")) { + q = q.substring(0, q.indexOf("//")).trim(); + } + if (q.equals("[Game Updates]")) { + isReadingUpdates = true; + continue; + } + if (!q.isEmpty()) { + String[] tokens = q.split("=", 2); + if (tokens.length == 2) { + String key = tokens[0].trim(); + if (isReadingUpdates) { + gameUpdates.put(key, tokens[1]); + } + if (key.equalsIgnoreCase("checkedcustomnames172")) { + haveCheckedCustomNames = Boolean.parseBoolean(tokens[1].trim()); + } + if (key.equals("firststart")) { + String val = tokens[1]; + if (val.equals(Version.VERSION_STRING)) { + initialPopup = false; + } + } + if (key.equals("unloadgameonsuccess")) { + unloadGameOnSuccess = Boolean.parseBoolean(tokens[1].trim()); + } + if (key.equals("showinvalidrompopup")) { + showInvalidRomPopup = Boolean.parseBoolean(tokens[1].trim()); + } + } + } else if (isReadingUpdates) { + isReadingUpdates = false; + } + } + sc.close(); + } catch (IOException ex) { + ex.printStackTrace(); + } + } + + private boolean attemptWriteConfig() { + File fh = new File(SysConstants.ROOT_PATH + "config.ini"); + if (fh.exists() && !fh.canWrite()) { + return false; + } + + try { + PrintStream ps = new PrintStream(new FileOutputStream(fh), true, "UTF-8"); + ps.println("checkedcustomnames=true"); + ps.println("checkedcustomnames172=" + haveCheckedCustomNames); + ps.println("unloadgameonsuccess=" + unloadGameOnSuccess); + ps.println("showinvalidrompopup=" + showInvalidRomPopup); + if (!initialPopup) { + ps.println("firststart=" + Version.VERSION_STRING); + } + if (gameUpdates.size() > 0) { + ps.println(); + ps.println("[Game Updates]"); + for (Map.Entry<String, String> update : gameUpdates.entrySet()) { + ps.format("%s=%s", update.getKey(), update.getValue()); + ps.println(); + } + } + ps.close(); + return true; + } catch (IOException e) { + return false; + } + + } + + private void testForRequiredConfigs() { + try { + Utils.testForRequiredConfigs(); + } catch (FileNotFoundException e) { + JOptionPane.showMessageDialog(null, + String.format(bundle.getString("GUI.configFileMissing"), e.getMessage())); + System.exit(1); + } + } + + private ExpCurve[] getEXPCurvesForGeneration(int generation) { + ExpCurve[] result; + if (generation < 3) { + result = new ExpCurve[]{ ExpCurve.MEDIUM_FAST, ExpCurve.MEDIUM_SLOW, ExpCurve.FAST, ExpCurve.SLOW }; + } else { + result = new ExpCurve[]{ ExpCurve.MEDIUM_FAST, ExpCurve.MEDIUM_SLOW, ExpCurve.FAST, ExpCurve.SLOW, ExpCurve.ERRATIC, ExpCurve.FLUCTUATING }; + } + return result; + } + + private String[] getTrainerSettingsForGeneration(int generation) { + List<String> result = new ArrayList<>(trainerSettings); + if (generation != 5) { + result.remove(bundle.getString("GUI.tpMain3RandomEvenDistributionMainGame.text")); + } + return result.toArray(new String[0]); + } + + private boolean isTrainerSetting(int setting) { + return trainerSettings.indexOf(tpComboBox.getSelectedItem()) == setting; + } + + public static void main(String[] args) { + String firstCliArg = args.length > 0 ? args[0] : ""; + // invoke as CLI program + if (firstCliArg.equals("cli")) { + // snip the "cli" flag arg off the args array and invoke command + String[] commandArgs = Arrays.copyOfRange(args, 1, args.length); + int exitCode = CliRandomizer.invoke(commandArgs); + System.exit(exitCode); + } else { + launcherInput = firstCliArg; + if (launcherInput.equals("please-use-the-launcher")) usedLauncher = true; + SwingUtilities.invokeLater(() -> { + frame = new JFrame("NewRandomizerGUI"); + try { + String lafName = javax.swing.UIManager.getSystemLookAndFeelClassName(); + // NEW: Only set Native LaF on windows. + if (lafName.equalsIgnoreCase("com.sun.java.swing.plaf.windows.WindowsLookAndFeel")) { + javax.swing.UIManager.setLookAndFeel(lafName); + } + } catch (ClassNotFoundException | InstantiationException | UnsupportedLookAndFeelException | IllegalAccessException ex) { + java.util.logging.Logger.getLogger(NewRandomizerGUI.class.getName()).log(java.util.logging.Level.SEVERE, null, + ex); + } + frame.setContentPane(new NewRandomizerGUI().mainPanel); + frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); + frame.pack(); + frame.setVisible(true); + }); + } + } +} |