diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d0fb017 --- /dev/null +++ b/.gitignore @@ -0,0 +1,29 @@ +################# +## Eclipse +################# + +*.pydevproject +.project +.metadata +bin/ +tmp/ +*.tmp +*.bak +*.swp +*~.nib +local.properties +.classpath +.settings/ +.loadpath + +# External tool builders +.externalToolBuilders/ + +# Locally stored "Eclipse launch configurations" +*.launch + +# CDT-specific +.cproject + +# PDT-specific +.buildpath \ No newline at end of file diff --git a/forms-1.3.0-src.zip b/forms-1.3.0-src.zip new file mode 100644 index 0000000..b7673af Binary files /dev/null and b/forms-1.3.0-src.zip differ diff --git a/forms-1.3.0.jar b/forms-1.3.0.jar new file mode 100644 index 0000000..0bd8c3e Binary files /dev/null and b/forms-1.3.0.jar differ diff --git a/miglayout-src.zip b/miglayout-src.zip new file mode 100644 index 0000000..9c51c32 Binary files /dev/null and b/miglayout-src.zip differ diff --git a/miglayout15-swing.jar b/miglayout15-swing.jar new file mode 100644 index 0000000..d1d962c Binary files /dev/null and b/miglayout15-swing.jar differ diff --git a/msb.jar b/msb.jar new file mode 100644 index 0000000..8877132 Binary files /dev/null and b/msb.jar differ diff --git a/src/waveTools/msb/MobileScriptBuilder.java b/src/waveTools/msb/MobileScriptBuilder.java new file mode 100644 index 0000000..c01af29 --- /dev/null +++ b/src/waveTools/msb/MobileScriptBuilder.java @@ -0,0 +1,1343 @@ +package waveTools.msb; + +import java.awt.Cursor; +import java.awt.EventQueue; + +import javax.swing.JFileChooser; +import javax.swing.JFrame; +import javax.swing.JMenuBar; +import javax.swing.JMenuItem; +import javax.swing.JMenu; + +import java.awt.event.ActionListener; +import java.awt.event.ActionEvent; + +import javax.swing.JTree; + +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.io.PrintWriter; +import java.nio.file.Files; +import java.text.DecimalFormat; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Properties; +import java.util.Vector; + +import javax.swing.text.NumberFormatter; +import javax.swing.tree.DefaultMutableTreeNode; +import javax.swing.tree.DefaultTreeModel; +import javax.swing.tree.TreeSelectionModel; + +import waveTools.msb.secondaryWindows.CreatureTemplateDialog; +import waveTools.msb.secondaryWindows.Settings; +import waveTools.msb.secondaryWindows.WeaponTemplateDialog; + +import javax.swing.JScrollPane; + +import java.awt.Label; + +import javax.swing.DefaultListModel; +import javax.swing.JPanel; +import javax.swing.JButton; +import javax.swing.JTabbedPane; +import javax.swing.JTextField; +import javax.swing.JList; +import javax.swing.AbstractListModel; +import javax.swing.SwingWorker; +import javax.swing.UIManager; +import javax.swing.JComboBox; +import javax.swing.DefaultComboBoxModel; + +import waveTools.msb.resources.Helpers; +import waveTools.msb.resources.Mobile; +import waveTools.msb.resources.Weapon; + +import java.awt.Color; + +import javax.swing.border.BevelBorder; + +import java.awt.Font; + +import javax.swing.JFormattedTextField; +import javax.swing.event.TreeSelectionListener; +import javax.swing.event.TreeSelectionEvent; +import javax.swing.JLabel; + +import waveTools.msb.resources.enums.Difficulty; +import waveTools.msb.resources.enums.WeaponType; + +import javax.swing.JProgressBar; +import javax.swing.JCheckBox; +import javax.swing.event.ListSelectionListener; +import javax.swing.event.ListSelectionEvent; +import javax.swing.filechooser.FileFilter; +import javax.swing.filechooser.FileNameExtensionFilter; +import javax.swing.JPopupMenu; + +import java.awt.Component; +import java.awt.event.MouseAdapter; +import java.awt.event.MouseEvent; +import java.beans.PropertyChangeListener; +import java.beans.PropertyChangeEvent; +import java.awt.GridBagLayout; +import java.awt.GridBagConstraints; +import java.awt.Insets; +import java.awt.GridLayout; + +import com.jgoodies.forms.layout.FormLayout; +import com.jgoodies.forms.layout.ColumnSpec; +import com.jgoodies.forms.layout.RowSpec; + +import javax.swing.GroupLayout; +import javax.swing.GroupLayout.Alignment; +import javax.swing.border.CompoundBorder; +import javax.swing.border.LineBorder; +import javax.swing.border.EtchedBorder; +import javax.swing.border.SoftBevelBorder; +import java.awt.event.ItemListener; +import java.awt.event.ItemEvent; + +public class MobileScriptBuilder { + + private JFrame frmPswgToolsMbs; + private JTree mobilesTree; + private JTextField tbCreatureName; + private JTextField tbScriptLocation; + private JFormattedTextField tbCreatureLevel; + private DefaultMutableTreeNode rootMobileTreeNode; + + private String coreLocation = ""; + private JComboBox cmbDifficulty; + + private Mobile activeMobile; + + private JButton btnSave; + private JList listCreatureTemps; + private JList listWeaponTemps; + private JFormattedTextField tbAttackRange; + + private JFormattedTextField tbAttackSpeed; + private JList listAttacks; + + private boolean mobilesLoaded; + private JComboBox cmbWeaponType; + private Properties config; + private JProgressBar prgMobilesLoading; + private JComboBox cmbDefaultAttack; + private JFormattedTextField tbMinLevel; + + private JFormattedTextField tbMaxLevel; + + private JCheckBox chckbxDeathblowEnabled; + + private Vector modifiedTemplates = new Vector(); + @SuppressWarnings("rawtypes") + private DefaultListModel weaponTemps; + @SuppressWarnings("rawtypes") + private DefaultListModel creatureTemps; + @SuppressWarnings("rawtypes") + private DefaultListModel attacks; + private JButton btnBuildAll; + private JButton btnBuildCurrent; + + public static MobileScriptBuilder instance; + private WeaponTemplateDialog weaponTempDialog; + private JButton btnRemoveWeapTemp; + private JButton btnAddNewCreatureTemp; + private JButton btnAddNewWeapTemp; + private JButton btnEditWeapTemp; + private JButton btnRemoveCreatureTemp; + private JButton btnEditCreatureTemp; + private JTextField tbSocialGroup; + private JFormattedTextField tbMinSpawnDistance; + private JFormattedTextField tbMaxSpawnDistance; + private JFormattedTextField tbRespawnTime; + private JComboBox cmbFaction; + private JComboBox cmbFactionStatus; + private JFormattedTextField tbAssistRange; + private JCheckBox chckbxStalker; + private JPanel tpResourceSettings; + private JCheckBox chckbxHarvestable; + private JCheckBox chckbxAgressive; + private JCheckBox chckbxAttackable; + private JCheckBox chckbxInvulnerable; + + + public static void main(String[] args) { + try { + UIManager.setLookAndFeel("javax.swing.plaf.nimbus.NimbusLookAndFeel"); + } catch (Throwable e) { + e.printStackTrace(); + } + EventQueue.invokeLater(new Runnable() { + @Override + public void run() { + try { + MobileScriptBuilder window = new MobileScriptBuilder(); + window.frmPswgToolsMbs.setVisible(true); + } catch (Exception e) { + e.printStackTrace(); + } + } + }); + } + + public MobileScriptBuilder() { + initialize(); + + // Perform these after UI setup + try { createDependencies(); } catch (Exception e) { Helpers.showExceptionError(frmPswgToolsMbs, e.getLocalizedMessage());} + + // Populate Default Attacks combobox + Vector defaultAttacks = new Vector(); + try(BufferedReader br = new BufferedReader(new FileReader("./defaultAttacks.txt"))) { + for(String line; (line = br.readLine()) != null; ) { + if (line.equals("") || line.equals(" ")) + continue; + + defaultAttacks.add(line); + } + } catch (Exception e) { Helpers.showExceptionError(frmPswgToolsMbs, e.getLocalizedMessage());} + + cmbDefaultAttack.setModel(new DefaultComboBoxModel(defaultAttacks)); + + // Populate Mobiles Tree + if (coreLocation != null && coreLocation != "" && !mobilesLoaded) { populateMobilesTree(new File(coreLocation + "\\scripts\\mobiles")); } + + instance = this; + + // Load additional UI's + weaponTempDialog = new WeaponTemplateDialog(); + + } + + private void createDependencies() throws Exception { + // Generate Configuration File + config = new Properties(); + File configFile = new File("./config.cfg"); + + if (!configFile.exists()) { + Helpers.showMessageBox(frmPswgToolsMbs, "No config file detected. You must setup your settings to generate one (File -> Settings)"); + } else { + try { + FileInputStream configInput = new FileInputStream(configFile); + config.load(configInput); + configInput.close(); + + coreLocation = config.getProperty("CoreLocation"); + } catch (Exception e) { Helpers.showExceptionError(frmPswgToolsMbs, e.getLocalizedMessage()); } + } + + // Generate defaultAttacks.txt file + File dAttacksFile = new File("./defaultAttacks.txt"); + if (!dAttacksFile.exists()) { + dAttacksFile.createNewFile(); + PrintWriter writer = new PrintWriter(dAttacksFile, "UTF-8"); + Vector dAttacks = new Vector(Arrays.asList(new String[] { + "creatureMeleeAttack", "creatureRangedAttack", "meleeHit", "rangedShot", "saberHit" + })); + + dAttacks.stream().forEach(a -> writer.println(a)); + writer.close(); + } + } + + public int fileCount(File folder, int count) { + for (File file : folder.listFiles()) { + if (file.isFile()) + count++; + else + count = fileCount(file, count); + } + return count; + } + + public Mobile getActiveMobile() { + return activeMobile; + } + + public Properties getConfig() { + return config; + } + + public String getCoreLocation() { + return coreLocation; + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + private void initialize() { + NumberFormatter basicIntFormat = new NumberFormatter(); + //basicIntFormat.setAllowsInvalid(false); + basicIntFormat.setCommitsOnValidEdit(true); + + NumberFormatter decFormat = new NumberFormatter(new DecimalFormat()); + decFormat.setCommitsOnValidEdit(true); + + frmPswgToolsMbs = new JFrame(); + frmPswgToolsMbs.setResizable(false); + frmPswgToolsMbs.setTitle("PSWGTools - Mobile Script Builder by Waverunner"); + frmPswgToolsMbs.setBounds(100, 100, 643, 499); + frmPswgToolsMbs.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); + + JMenuBar menuBar = new JMenuBar(); + frmPswgToolsMbs.setJMenuBar(menuBar); + + JMenu mnFile = new JMenu("File"); + menuBar.add(mnFile); + + JMenuItem mntmLoadMobiles = new JMenuItem("Load Mobiles..."); + mntmLoadMobiles.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent arg0) { + + JFileChooser mobilesFolderSelect = new JFileChooser(); + mobilesFolderSelect.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY); + mobilesFolderSelect.setDialogTitle("Select directory containing mobile scripts"); + if (coreLocation != null && !coreLocation.equals(" ") && !coreLocation.equals("")) + mobilesFolderSelect.setCurrentDirectory(new File(coreLocation + "\\scripts")); + + int success = mobilesFolderSelect.showOpenDialog(frmPswgToolsMbs); + + if (success == JFileChooser.APPROVE_OPTION) { + if (mobilesFolderSelect.getSelectedFile().getName().equals("mobiles")) + populateMobilesTree(mobilesFolderSelect.getSelectedFile()); + else + Helpers.showMessageBox(frmPswgToolsMbs, "Not a valid mobiles folder!"); + //mntmLoadMobiles.setEnabled(false); + } + } + }); + mnFile.add(mntmLoadMobiles); + + JMenuItem mntmSettings = new JMenuItem("Settings.."); + mntmSettings.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent arg0) { + Settings sDialog = new Settings(); + sDialog.setVisible(true); + } + }); + mnFile.add(mntmSettings); + + JMenu mnHelp = new JMenu("Help"); + menuBar.add(mnHelp); + + JMenuItem mntmAbout = new JMenuItem("About..."); + mnHelp.add(mntmAbout); + + frmPswgToolsMbs.getContentPane().setLayout(null); + + JScrollPane mobilesScrollPane = new JScrollPane(); + mobilesScrollPane.setBounds(12, 6, 200, 400); + frmPswgToolsMbs.getContentPane().add(mobilesScrollPane); + + rootMobileTreeNode = new DefaultMutableTreeNode("No mobiles loaded"); + + mobilesTree = new JTree(rootMobileTreeNode); + mobilesTree.addTreeSelectionListener(new TreeSelectionListener() { + @Override + public void valueChanged(TreeSelectionEvent e) { + if (e.getNewLeadSelectionPath() == null || e.getNewLeadSelectionPath().getLastPathComponent() == null) + return; + + DefaultMutableTreeNode node = (DefaultMutableTreeNode) e.getNewLeadSelectionPath().getLastPathComponent(); + DefaultMutableTreeNode priorNode = null; + + if (e.getOldLeadSelectionPath() != null) + priorNode = (DefaultMutableTreeNode) e.getOldLeadSelectionPath().getLastPathComponent(); + + if (priorNode != null && priorNode.isLeaf() && priorNode.getUserObject() instanceof Mobile) { + //System.out.println("Prior selected node was " + ((Mobile)priorNode.getUserObject()).getCreatureName()); + } + + if (node != null && node.isLeaf() && node.getUserObject() instanceof Mobile) { + Mobile mobile = (Mobile) node.getUserObject(); + populateScriptCreator(mobile); + activeMobile = mobile; + + tbAttackRange.setEnabled(true); + tbCreatureLevel.setEnabled(true); + tbCreatureName.setEnabled(true); + tbAttackSpeed.setEnabled(true); + tbMaxLevel.setEnabled(true); + tbMinLevel.setEnabled(true); + cmbDifficulty.setEnabled(true); + cmbWeaponType.setEnabled(true); + cmbDefaultAttack.setEnabled(true); + chckbxDeathblowEnabled.setEnabled(true); + + btnAddNewCreatureTemp.setEnabled(true); + btnAddNewWeapTemp.setEnabled(true); + } + } + }); + mobilesTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION); + + mobilesScrollPane.setViewportView(mobilesTree); + + JPopupMenu popupMenu = new JPopupMenu(); + addPopup(mobilesTree, popupMenu); + + JMenuItem mntmRefreshMobiles = new JMenuItem("Refresh Mobiles"); + mntmRefreshMobiles.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent arg0) { + if (mobilesLoaded) + populateMobilesTree(new File(coreLocation + "\\scripts\\mobiles")); + } + }); + popupMenu.add(mntmRefreshMobiles); + + JPanel buttonsPane = new JPanel(); + buttonsPane.setBorder(new SoftBevelBorder(BevelBorder.RAISED, null, null, null, null)); + buttonsPane.setBounds(224, 400, 391, 42); + frmPswgToolsMbs.getContentPane().add(buttonsPane); + + JButton btnAddMobile = new JButton("New Mobile"); + btnAddMobile.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent event) { + if (!mobilesLoaded) { + Helpers.showMessageBox(frmPswgToolsMbs, "You cannot do that because you have not loaded the mobiles folder yet!"); + return; + } + FileFilter pyFilter = new FileNameExtensionFilter("Mobile Script File", "py"); + JFileChooser newMobileDialog = new JFileChooser(); + newMobileDialog.setFileSelectionMode(JFileChooser.FILES_ONLY); + newMobileDialog.setDialogTitle("Select where to save the mobile script"); + newMobileDialog.setCurrentDirectory(new File(coreLocation + "\\scripts\\mobiles")); + newMobileDialog.setDialogType(JFileChooser.SAVE_DIALOG); + newMobileDialog.setFileFilter(pyFilter); + int selectedIndex = newMobileDialog.showSaveDialog(frmPswgToolsMbs); + if (selectedIndex == JFileChooser.APPROVE_OPTION) { + File file = newMobileDialog.getSelectedFile(); + + if (!file.getAbsolutePath().endsWith(".py")) { + file = new File(file.getAbsolutePath() + ".py"); + } + if (file.exists()) { + Helpers.showMessageBox(frmPswgToolsMbs, "That script already exists! Please choose a different name!"); + return; + } + try { + file.createNewFile(); + populateMobilesTree(new File(coreLocation + "\\scripts\\mobiles")); + } catch (IOException e) { + Helpers.showExceptionError(frmPswgToolsMbs, e.getLocalizedMessage()); + } + } + /*DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode) mobilesTree.getLeadSelectionPath().getLastPathComponent(); + + if (currentNode.getUserObject() instanceof Mobile) { + Mobile currentMobile = (Mobile) currentNode.getUserObject(); + + String path = currentMobile.getScriptLocation(); + newMobile.setScriptLocation(path); + + DefaultMutableTreeNode newNode = new DefaultMutableTreeNode(); + newNode.setUserObject(newMobile); + ((DefaultMutableTreeNode)currentNode.getParent()).add(newNode); + mobilesTree.updateUI(); + }*/ + } + }); + buttonsPane.add(btnAddMobile); + + btnSave = new JButton("Save"); + btnSave.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent arg0) { + saveCurrentValues(); + } + }); + btnSave.setEnabled(false); + buttonsPane.add(btnSave); + + btnBuildCurrent = new JButton("Build"); + btnBuildCurrent.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent arg0) { + DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode) mobilesTree.getSelectionPath().getLastPathComponent(); + if (currentNode == null || !(currentNode.getUserObject() instanceof Mobile)) + return; + + buildMobileScript((Mobile) currentNode.getUserObject()); + + Helpers.showMessageBox(frmPswgToolsMbs, "Successfully Built (1) Mobile Script."); + } + }); + btnBuildCurrent.setEnabled(false); + buttonsPane.add(btnBuildCurrent); + + btnBuildAll = new JButton("Build All"); + btnBuildAll.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent arg0) { + modifiedTemplates.stream().forEach(mobile -> { buildMobileScript(mobile); }); + Helpers.showMessageBox(frmPswgToolsMbs, "Successfully Built (" + modifiedTemplates.size() + ") Mobile Scripts."); + } + }); + btnBuildAll.setEnabled(false); + buttonsPane.add(btnBuildAll); + + JTabbedPane tabbedPane = new JTabbedPane(); + tabbedPane.setBounds(224, 6, 391, 392); + frmPswgToolsMbs.getContentPane().add(tabbedPane); + + JPanel tpGenSettings = new JPanel(); + tpGenSettings.setBorder(new EtchedBorder(EtchedBorder.RAISED, null, null)); + tpGenSettings.setForeground(Color.BLACK); + tabbedPane.addTab("General Settings", null, tpGenSettings, null); + tpGenSettings.setLayout(null); + + Label label = new Label("Creature Name"); + label.setBounds(10, 55, 90, 23); + tpGenSettings.add(label); + + Label label_1 = new Label("Script Location"); + label_1.setBounds(10, 18, 90, 23); + tpGenSettings.add(label_1); + + tbCreatureName = new JTextField(); + tbCreatureName.setEnabled(false); + tbCreatureName.setFont(new Font("SansSerif", Font.PLAIN, 12)); + tbCreatureName.setBounds(106, 53, 279, 28); + tpGenSettings.add(tbCreatureName); + tbCreatureName.setColumns(10); + + tbScriptLocation = new JTextField(); + tbScriptLocation.setFont(new Font("SansSerif", Font.PLAIN, 12)); + tbScriptLocation.setEnabled(false); + tbScriptLocation.setBounds(106, 13, 279, 28); + tpGenSettings.add(tbScriptLocation); + tbScriptLocation.setColumns(10); + + Label label_2 = new Label("Level"); + label_2.setBounds(10, 86, 33, 23); + tpGenSettings.add(label_2); + + Label label_3 = new Label("Difficulty"); + label_3.setBounds(10, 120, 47, 23); + tpGenSettings.add(label_3); + + cmbDifficulty = new JComboBox(); + cmbDifficulty.setEnabled(false); + cmbDifficulty.setModel(new DefaultComboBoxModel(Difficulty.values())); + cmbDifficulty.setSelectedIndex(0); + cmbDifficulty.setBounds(59, 118, 74, 26); + tpGenSettings.add(cmbDifficulty); + + tbCreatureLevel = new JFormattedTextField(basicIntFormat); + tbCreatureLevel.setEnabled(false); + tbCreatureLevel.setBounds(49, 84, 33, 28); + tpGenSettings.add(tbCreatureLevel); + + JLabel lblAttackRange = new JLabel("Attack Range"); + lblAttackRange.setBounds(10, 161, 81, 16); + tpGenSettings.add(lblAttackRange); + + tbAttackRange = new JFormattedTextField(decFormat); + tbAttackRange.setEnabled(false); + tbAttackRange.setBounds(88, 155, 33, 28); + tpGenSettings.add(tbAttackRange); + + JLabel lblAttackSpeed = new JLabel("Attack Speed"); + lblAttackSpeed.setBounds(133, 161, 74, 16); + tpGenSettings.add(lblAttackSpeed); + + tbAttackSpeed = new JFormattedTextField(decFormat); + tbAttackSpeed.setEnabled(false); + tbAttackSpeed.setBounds(205, 155, 33, 28); + tpGenSettings.add(tbAttackSpeed); + + JScrollPane scrollPane_Attacks = new JScrollPane(); + scrollPane_Attacks.setBounds(10, 211, 207, 124); + tpGenSettings.add(scrollPane_Attacks); + + listAttacks = new JList(); + listAttacks.setEnabled(false); + listAttacks.setModel(new DefaultListModel()); + scrollPane_Attacks.setViewportView(listAttacks); + + JLabel lblAttacks = new JLabel("Attacks:"); + lblAttacks.setBounds(10, 189, 55, 16); + tpGenSettings.add(lblAttacks); + + JButton btnAddAttack = new JButton("Add Attack"); + btnAddAttack.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent arg0) { + } + }); + btnAddAttack.setEnabled(false); + btnAddAttack.setBounds(220, 221, 114, 28); + tpGenSettings.add(btnAddAttack); + + JButton btnRemoveAttack = new JButton("Remove Attack"); + btnRemoveAttack.setEnabled(false); + btnRemoveAttack.setBounds(220, 256, 114, 28); + tpGenSettings.add(btnRemoveAttack); + + JLabel lblDefaultAttack = new JLabel("Default Attack"); + lblDefaultAttack.setBounds(150, 122, 81, 16); + tpGenSettings.add(lblDefaultAttack); + + JLabel lblWeaponType = new JLabel("Weapon Type"); + lblWeaponType.setBounds(160, 189, 90, 16); + tpGenSettings.add(lblWeaponType); + + cmbWeaponType = new JComboBox(); + cmbWeaponType.setEnabled(false); + cmbWeaponType.setModel(new DefaultComboBoxModel(WeaponType.values())); + cmbWeaponType.setBounds(244, 184, 141, 26); + tpGenSettings.add(cmbWeaponType); + + cmbDefaultAttack = new JComboBox(); + cmbDefaultAttack.setEnabled(false); + cmbDefaultAttack.setEditable(true); + cmbDefaultAttack.setBounds(230, 117, 155, 26); + tpGenSettings.add(cmbDefaultAttack); + + tbMinLevel = new JFormattedTextField(basicIntFormat); + tbMinLevel.setEnabled(false); + tbMinLevel.setBounds(150, 84, 33, 28); + tpGenSettings.add(tbMinLevel); + + tbMaxLevel = new JFormattedTextField(basicIntFormat); + tbMaxLevel.setEnabled(false); + tbMaxLevel.setBounds(254, 84, 33, 28); + tpGenSettings.add(tbMaxLevel); + + JLabel lblMinLevel = new JLabel("Min. Level"); + lblMinLevel.setBounds(94, 86, 55, 23); + tpGenSettings.add(lblMinLevel); + + JLabel lblMaxLevel = new JLabel("Max Level"); + lblMaxLevel.setBounds(195, 86, 55, 23); + tpGenSettings.add(lblMaxLevel); + + chckbxDeathblowEnabled = new JCheckBox("Deathblow Enabled"); + chckbxDeathblowEnabled.setEnabled(false); + chckbxDeathblowEnabled.setSelected(true); + chckbxDeathblowEnabled.setBounds(250, 160, 135, 18); + tpGenSettings.add(chckbxDeathblowEnabled); + + JPanel tpCreatureTemplates = new JPanel(); + tpCreatureTemplates.setBorder(new EtchedBorder(EtchedBorder.RAISED, null, null)); + tabbedPane.addTab("Creature Temps", null, tpCreatureTemplates, null); + tpCreatureTemplates.setLayout(null); + + JScrollPane scrollPane_CreatureTemps = new JScrollPane(); + scrollPane_CreatureTemps.setBounds(10, 10, 375, 234); + tpCreatureTemplates.add(scrollPane_CreatureTemps); + + creatureTemps = new DefaultListModel(); + listCreatureTemps = new JList(); + listCreatureTemps.addListSelectionListener(new ListSelectionListener() { + public void valueChanged(ListSelectionEvent event) { + try { + if (creatureTemps.get(event.getFirstIndex()) != null) { + btnRemoveCreatureTemp.setEnabled(true); + btnEditCreatureTemp.setEnabled(true); + } + } catch (ArrayIndexOutOfBoundsException e) { + btnRemoveCreatureTemp.setEnabled(false); + btnEditCreatureTemp.setEnabled(false); + } + } + }); + listCreatureTemps.setModel(creatureTemps); + scrollPane_CreatureTemps.setViewportView(listCreatureTemps); + + JPanel panelCreatureTempBtns = new JPanel(); + panelCreatureTempBtns.setBounds(6, 255, 379, 42); + tpCreatureTemplates.add(panelCreatureTempBtns); + + btnAddNewCreatureTemp = new JButton("Add"); + panelCreatureTempBtns.add(btnAddNewCreatureTemp); + btnAddNewCreatureTemp.setEnabled(false); + + btnRemoveCreatureTemp = new JButton("Remove"); + panelCreatureTempBtns.add(btnRemoveCreatureTemp); + btnRemoveCreatureTemp.setEnabled(false); + + btnEditCreatureTemp = new JButton("Edit"); + btnEditCreatureTemp.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent arg0) { + CreatureTemplateDialog dialog = new CreatureTemplateDialog(); + String template = listCreatureTemps.getSelectedValue(); + dialog.setTbCreatureTempNameText(template); + + dialog.setVisible(true); + } + }); + btnEditCreatureTemp.setEnabled(false); + panelCreatureTempBtns.add(btnEditCreatureTemp); + btnRemoveCreatureTemp.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent arg0) { + int index = listCreatureTemps.getSelectedIndex(); + creatureTemps.remove(index); + } + }); + btnAddNewCreatureTemp.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent arg0) { + CreatureTemplateDialog dialog = new CreatureTemplateDialog(); + dialog.setVisible(true); + } + }); + + JPanel tpWeaponTemplates = new JPanel(); + tpWeaponTemplates.setBorder(new EtchedBorder(EtchedBorder.RAISED, null, null)); + tabbedPane.addTab("Weapon Temps", null, tpWeaponTemplates, null); + tpWeaponTemplates.setLayout(null); + + JScrollPane scrollPane_WeaponTemps = new JScrollPane(); + scrollPane_WeaponTemps.setBounds(6, 6, 375, 234); + tpWeaponTemplates.add(scrollPane_WeaponTemps); + + weaponTemps = new DefaultListModel(); + listWeaponTemps = new JList(); + listWeaponTemps.addListSelectionListener(new ListSelectionListener() { + public void valueChanged(ListSelectionEvent event) { + try { + if (weaponTemps.get(event.getFirstIndex()) != null) { + btnRemoveWeapTemp.setEnabled(true); + btnEditWeapTemp.setEnabled(true); + } + } catch (ArrayIndexOutOfBoundsException e) { + btnRemoveWeapTemp.setEnabled(false); + btnEditWeapTemp.setEnabled(false); + } + } + }); + listWeaponTemps.setModel(weaponTemps); + scrollPane_WeaponTemps.setViewportView(listWeaponTemps); + + JPanel wpTmpBtnsPanel = new JPanel(); + wpTmpBtnsPanel.setBounds(6, 252, 375, 43); + tpWeaponTemplates.add(wpTmpBtnsPanel); + + btnAddNewWeapTemp = new JButton("Add"); + btnAddNewWeapTemp.setEnabled(false); + wpTmpBtnsPanel.add(btnAddNewWeapTemp); + + btnRemoveWeapTemp = new JButton("Remove"); + btnRemoveWeapTemp.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent arg0) { + int index = listWeaponTemps.getSelectedIndex(); + + try { + weaponTemps.remove(index); + } catch (Exception e) { Helpers.showExceptionError(frmPswgToolsMbs, e.getLocalizedMessage());} + } + }); + btnRemoveWeapTemp.setEnabled(false); + wpTmpBtnsPanel.add(btnRemoveWeapTemp); + + btnEditWeapTemp = new JButton("Edit"); + btnEditWeapTemp.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent arg0) { + String base = listWeaponTemps.getSelectedValue(); + String[] values = base.replace(" ", "").split(","); + + weaponTempDialog.getTbWeaponTemp().setText(values[0]); + weaponTempDialog.getCmbWeaponType().setSelectedIndex(Integer.valueOf(values[1])); + weaponTempDialog.getTbAttackSpeed().setText(values[2]); + + weaponTempDialog.setEditMode(true); + + weaponTempDialog.setVisible(true); + } + }); + btnEditWeapTemp.setEnabled(false); + wpTmpBtnsPanel.add(btnEditWeapTemp); + + JPanel tpMiscSettings = new JPanel(); + tpMiscSettings.setBorder(new EtchedBorder(EtchedBorder.RAISED, null, null)); + tabbedPane.addTab("Misc. Settings", null, tpMiscSettings, null); + tpMiscSettings.setLayout(null); + + JPanel panelSpawnSettings = new JPanel(); + panelSpawnSettings.setBorder(new EtchedBorder(EtchedBorder.LOWERED, null, null)); + panelSpawnSettings.setBounds(18, 27, 324, 127); + tpMiscSettings.add(panelSpawnSettings); + panelSpawnSettings.setLayout(null); + + JLabel lblMinSpawnDistance = new JLabel("Min. Spawn Distance"); + lblMinSpawnDistance.setBounds(6, 16, 120, 16); + panelSpawnSettings.add(lblMinSpawnDistance); + + JLabel lblMaxSpawnDistance = new JLabel("Max. Spawn Distance"); + lblMaxSpawnDistance.setBounds(6, 46, 120, 16); + panelSpawnSettings.add(lblMaxSpawnDistance); + + tbMinSpawnDistance = new JFormattedTextField(); + tbMinSpawnDistance.setBounds(129, 10, 36, 28); + panelSpawnSettings.add(tbMinSpawnDistance); + + tbMaxSpawnDistance = new JFormattedTextField(); + tbMaxSpawnDistance.setBounds(129, 40, 36, 28); + panelSpawnSettings.add(tbMaxSpawnDistance); + + JLabel lblSocialGroup = new JLabel("Social Group"); + lblSocialGroup.setBounds(6, 74, 79, 16); + panelSpawnSettings.add(lblSocialGroup); + + tbSocialGroup = new JTextField(); + tbSocialGroup.setBounds(82, 68, 98, 28); + panelSpawnSettings.add(tbSocialGroup); + tbSocialGroup.setColumns(10); + + JLabel lblRespawnTime = new JLabel("Respawn Time"); + lblRespawnTime.setBounds(6, 102, 89, 16); + panelSpawnSettings.add(lblRespawnTime); + + tbRespawnTime = new JFormattedTextField(); + tbRespawnTime.setBounds(92, 96, 51, 28); + panelSpawnSettings.add(tbRespawnTime); + + chckbxStalker = new JCheckBox("Follows Enemy"); + chckbxStalker.setBounds(195, 15, 112, 18); + panelSpawnSettings.add(chckbxStalker); + + JLabel lblAssistRange = new JLabel("Assist Range"); + lblAssistRange.setBounds(187, 46, 79, 16); + panelSpawnSettings.add(lblAssistRange); + + tbAssistRange = new JFormattedTextField(); + tbAssistRange.setBounds(266, 40, 41, 28); + panelSpawnSettings.add(tbAssistRange); + + JLabel lblSpawnSettings = new JLabel("Spawn Settings"); + lblSpawnSettings.setBounds(18, 6, 94, 16); + tpMiscSettings.add(lblSpawnSettings); + lblSpawnSettings.setFont(new Font("SansSerif", Font.BOLD | Font.ITALIC, 12)); + + JLabel lblFactionSettings = new JLabel("Faction Settings"); + lblFactionSettings.setFont(new Font("SansSerif", Font.BOLD | Font.ITALIC, 12)); + lblFactionSettings.setBounds(18, 161, 94, 16); + tpMiscSettings.add(lblFactionSettings); + + JPanel panelFactionSettings = new JPanel(); + panelFactionSettings.setBorder(new EtchedBorder(EtchedBorder.LOWERED, null, null)); + panelFactionSettings.setBounds(18, 178, 177, 75); + tpMiscSettings.add(panelFactionSettings); + panelFactionSettings.setLayout(null); + + JLabel lblFaction = new JLabel("Faction"); + lblFaction.setBounds(6, 12, 40, 16); + panelFactionSettings.add(lblFaction); + + cmbFaction = new JComboBox(); + cmbFaction.setBounds(53, 7, 115, 26); + cmbFaction.setModel(new DefaultComboBoxModel(new String[] {"Imperial", "Rebel", "Neutral"})); + panelFactionSettings.add(cmbFaction); + + JLabel lblFactionStatus = new JLabel("Status"); + lblFactionStatus.setBounds(6, 43, 56, 16); + panelFactionSettings.add(lblFactionStatus); + + cmbFactionStatus = new JComboBox(); + cmbFactionStatus.setBounds(53, 40, 115, 26); + cmbFactionStatus.setModel(new DefaultComboBoxModel(new String[] {"On Leave", "Combatant", "Special Forces"})); + panelFactionSettings.add(cmbFactionStatus); + + JLabel lblOptions = new JLabel("Options"); + lblOptions.setFont(new Font("SansSerif", Font.BOLD | Font.ITALIC, 12)); + lblOptions.setBounds(218, 161, 56, 16); + tpMiscSettings.add(lblOptions); + + JPanel panel = new JPanel(); + panel.setBorder(new EtchedBorder(EtchedBorder.LOWERED, null, null)); + panel.setBounds(218, 178, 124, 117); + tpMiscSettings.add(panel); + + chckbxHarvestable = new JCheckBox("Harvestable"); + panel.add(chckbxHarvestable); + + chckbxAgressive = new JCheckBox("Agressive"); + chckbxAgressive.setEnabled(false); + panel.add(chckbxAgressive); + + chckbxAttackable = new JCheckBox("Attackable"); + chckbxAttackable.setEnabled(false); + chckbxAttackable.setSelected(true); + panel.add(chckbxAttackable); + + chckbxInvulnerable = new JCheckBox("Invulnerable"); + chckbxInvulnerable.setEnabled(false); + panel.add(chckbxInvulnerable); + + tpResourceSettings = new JPanel(); + tabbedPane.addTab("Resource Settings", null, tpResourceSettings, null); + tabbedPane.setEnabledAt(4, false); + btnAddNewWeapTemp.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent arg0) { + weaponTempDialog.getTbWeaponTemp().setText(""); + weaponTempDialog.getCmbWeaponType().setSelectedIndex(0); + weaponTempDialog.getTbAttackSpeed().setText(""); + + weaponTempDialog.setVisible(true); + } + }); + + prgMobilesLoading = new JProgressBar(); + prgMobilesLoading.setBounds(12, 410, 200, 26); + frmPswgToolsMbs.getContentPane().add(prgMobilesLoading); + } + private void populateMobileObject(Mobile baseMobile, File script) { + try(BufferedReader br = new BufferedReader(new FileReader(script))) { + for(String line; (line = br.readLine()) != null; ) { + line = line.replaceAll("\\s", ""); + if (line.isEmpty() || line.equals("") || line.equals("\treturn") || line.startsWith("from") || line.startsWith("import") || line.startsWith("def")) + continue; + else if (line.startsWith("mobileTemplate.setCreatureName")) { baseMobile.setCreatureName(line.replace("mobileTemplate.setCreatureName('", "").replace("')", "")); } + else if (line.startsWith("mobileTemplate.setLevel")) { baseMobile.setLevel(Integer.valueOf(line.replace("mobileTemplate.setLevel(", "").replace(")", ""))); } + else if (line.startsWith("mobileTemplate.setMinLevel")) { baseMobile.setMinLevel(Integer.valueOf(line.replace("mobileTemplate.setMinLevel(", "").replace(")", ""))); } + else if (line.startsWith("mobileTemplate.setMaxLevel")) { baseMobile.setMinLevel(Integer.valueOf(line.replace("mobileTemplate.setMaxLevel(", "").replace(")", ""))); } + else if (line.startsWith("mobileTemplate.setDifficulty")) { baseMobile.setDifficulty(Integer.valueOf(line.replace("mobileTemplate.setDifficulty(", "").replace(")", ""))); } + else if (line.startsWith("mobileTemplate.setAttackRange")) { baseMobile.setAttackRange(Integer.valueOf(line.replace("mobileTemplate.setAttackRange(", "").replace(")", ""))); } + else if (line.startsWith("mobileTemplate.setAttackSpeed")) { baseMobile.setAttackSpeed(Float.valueOf(line.replace("mobileTemplate.setAttackSpeed(", "").replace(")", ""))); } + else if (line.startsWith("mobileTemplate.setWeaponType")) { baseMobile.setWeaponType(Integer.valueOf(line.replace("mobileTemplate.setWeaponType(", "").replace(")", ""))); } + else if (line.startsWith("mobileTemplate.setMinSpawnDistance")) { baseMobile.setMinSpawnDistance(Integer.valueOf(line.replace("mobileTemplate.setMinSpawnDistance(", "").replace(")", ""))); } + else if (line.startsWith("mobileTemplate.setMaxSpawnDistance")) { baseMobile.setMaxSpawnDistance(Integer.valueOf(line.replace("mobileTemplate.setMaxSpawnDistance(", "").replace(")", ""))); } + else if (line.startsWith("mobileTemplate.setDeathblow")) { + switch(line.replace("mobileTemplate.setDeathblow(", "").replace(")", "")) { + case "True": + baseMobile.setDeathblowEnabled(true); + break; + case "False": + baseMobile.setDeathblowEnabled(false); + break; + } + } + //mobileTemplate.setScale + //else if (line.startsWith("mobileTemplate.setMeatType(\"")) { baseMobile.setMeatType(line.replace("mobileTemplate.setMeatType(\"", "").replace("\")", "")); } + //else if (line.startsWith("mobileTemplate.setMeatAmount(")) { baseMobile.setMeatAmount(Integer.valueOf(line.replace("mobileTemplate.setMeatAmount(", "").replace(")", ""))); } + //else if (line.startsWith("mobileTemplate.setHideType(\"")) { baseMobile.setHideType(line.replace("mobileTemplate.setHideType(\"", "").replace("\")", "")); } + //else if (line.startsWith("mobileTemplate.setHideAmount(")) { baseMobile.setHideAmount(Integer.valueOf(line.replace("mobileTemplate.setHideAmount(", "").replace(")", ""))); } + //else if (line.startsWith("mobileTemplate.setBoneType(\"")) { baseMobile.setBoneType(line.replace("mobileTemplate.setBoneType(\"", "").replace("\")", "")); } + //else if (line.startsWith("mobileTemplate.setBoneAmount(")) { baseMobile.setBoneAmount(Integer.valueOf(line.replace("mobileTemplate.setBoneAmount(", "").replace(")", ""))); } + + else if (line.startsWith("mobileTemplate.setSocialGroup(\"")) { baseMobile.setSocialGroup(line.replace("mobileTemplate.setSocialGroup(\"", "").replace("\")", "")); } + else if (line.startsWith("mobileTemplate.setAssistRange")) { baseMobile.setAssistRange(Integer.valueOf(line.replace("mobileTemplate.setAssistRange(", "").replace(")", ""))); } + else if (line.startsWith("mobileTemplate.setRespawnTime")) { baseMobile.setRespawnTime(Integer.valueOf(line.replace("mobileTemplate.setRespawnTime(", "").replace(")", ""))); } + + else if (line.startsWith("mobileTemplate.setStalker")) { + switch(line.replace("mobileTemplate.setStalker(", "").replace(")", "")) { + case "True": + baseMobile.setStalker(true); + break; + case "False": + baseMobile.setStalker(false); + break; + } + } + else if (line.startsWith("templates.add")) { baseMobile.addCreatureTemplate(line.replace("templates.add('", "").replace("')", "")); } + else if (line.startsWith("weapontemplate=WeaponTemplate")) { + String baseTemp = line.replace("weapontemplate=WeaponTemplate('", "").replace("'", "").replace(")", ""); + String[] values = baseTemp.split(","); + baseMobile.getWeaponTemplates().add(new Weapon(values[0], Integer.valueOf(values[1]), Float.valueOf(values[2]))); + } + else if (line.startsWith("attacks.add")) { baseMobile.addAttack(line.replace("attacks.add('", "")); } + else if (line.startsWith("mobileTemplate.setDefaultAttack('")) { baseMobile.setDefaultAttack(line.replace("mobileTemplate.setDefaultAttack('", "").replace("')", "")); } + } + } catch (IOException e) { + Helpers.showExceptionError(frmPswgToolsMbs, e.getLocalizedMessage()); + } + } + + // TODO: Progress bar updating + public void populateMobilesTree(File mobilesDirectory) { + if (mobilesDirectory.isFile()) + return; + rootMobileTreeNode.removeAllChildren(); + + SwingWorker task = new SwingWorker() { + + @Override + public DefaultMutableTreeNode doInBackground() throws Exception { + DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode(); + DefaultMutableTreeNode node = null; + rootNode.setUserObject("Mobile Scripts"); + + frmPswgToolsMbs.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR)); + + int fileCount = fileCount(mobilesDirectory, 0); + System.out.println("File count: " + fileCount); + int currentFileNumber = 0; + for (File file : mobilesDirectory.listFiles()) { + + if (file.isFile()) { + Mobile mobile = new Mobile(file.getName().split(".py")[0], file.getPath()); + node = new DefaultMutableTreeNode(mobile); + rootNode.add(node); + setProgress(currentFileNumber++); + } else if (file.isDirectory()) { + String folderName = file.getName(); + if (folderName.equals("spawnareas") || folderName.equals("lairs") || folderName.equals("lairgroups") || folderName.equals("dynamicgroups")) + continue; + node = new DefaultMutableTreeNode(file.getName()); + rootNode.add(node); + + populateSubFolders(node, file); + } + } + return rootNode; + } + @Override + public void done() { + frmPswgToolsMbs.setCursor(null); + + try { + mobilesTree.setModel(new DefaultTreeModel(get())); + } catch (Exception e) { + e.printStackTrace(); + } + mobilesTree.updateUI(); + + mobilesLoaded = true; + } + private void populateSubFolders(DefaultMutableTreeNode parentNode, File directory) { + + DefaultMutableTreeNode node = null; + + for (File file : directory.listFiles()) { + + if (file.isFile()) { + if (!file.getAbsolutePath().endsWith(".py")) + continue; + + Mobile mobile = new Mobile(file.getName().replace(".py", ""), file.getPath()); + //System.out.println("Path for mobile is " + mobile.getScriptLocation()); + populateMobileObject(mobile, file); + + node = new DefaultMutableTreeNode(mobile); + + parentNode.add(node); + } else if (file.isDirectory()) { + node = new DefaultMutableTreeNode(file.getName()); + parentNode.add(node); + + populateSubFolders(node, file); + } + } + } + }; + task.execute(); + } + + @SuppressWarnings({ "unchecked", "rawtypes", "serial" }) + private void populateScriptCreator(Mobile mobileTemplate) { + creatureTemps.clear(); + + tbCreatureName.setText(mobileTemplate.getCreatureName()); + tbScriptLocation.setText(mobileTemplate.getScriptLocation()); + tbCreatureLevel.setValue(mobileTemplate.getLevel()); + tbMinLevel.setValue(mobileTemplate.getMinLevel()); + tbMaxLevel.setValue(mobileTemplate.getMaxLevel()); + tbMinSpawnDistance.setValue(mobileTemplate.getMinSpawnDistance()); + tbMaxSpawnDistance.setValue(mobileTemplate.getMaxSpawnDistance()); + tbAttackRange.setValue(mobileTemplate.getAttackRange()); + tbAttackSpeed.setValue(mobileTemplate.getAttackSpeed()); + tbAssistRange.setValue(mobileTemplate.getAssistRange()); + tbSocialGroup.setText(mobileTemplate.getSocialGroup()); + tbRespawnTime.setValue(mobileTemplate.getRespawnTime()); + cmbDefaultAttack.setSelectedItem(mobileTemplate.getDefaultAttack()); + cmbDifficulty.setSelectedIndex(mobileTemplate.getDifficulty()); + cmbWeaponType.setSelectedIndex(mobileTemplate.getWeaponType()); + cmbFaction.setSelectedItem(mobileTemplate.getFaction()); + cmbFactionStatus.setSelectedIndex(mobileTemplate.getFactionStatus()); + + chckbxDeathblowEnabled.setSelected(mobileTemplate.isDeathblowEnabled()); + chckbxStalker.setSelected(mobileTemplate.isStalker()); + + if (mobileTemplate.getCreatureTemplates().size() != 0) { + for (String s : mobileTemplate.getCreatureTemplates()) { creatureTemps.addElement(s); } + listCreatureTemps.setModel(creatureTemps); + } + else { + listCreatureTemps.setModel(new AbstractListModel() { + String[] values = new String[] {"No Creature Templates found."}; + public int getSize() { + return values.length; + } + public Object getElementAt(int index) { + return values[index]; + } + }); + } + + updateWeaponTemplatesList(mobileTemplate); + + if (mobileTemplate.getAttacks().size() != 0) + listAttacks.setListData(mobileTemplate.getAttacks()); + else + listAttacks.setListData(new String[] { "Template has no attacks." }); + + btnSave.setEnabled(true); + } + + private void buildMobileScript(Mobile mobile) { + try { + + tryBackup(new File(mobile.getScriptLocation()), 1); + + BufferedWriter writer = new BufferedWriter(new FileWriter(mobile.getScriptLocation())); + writer.write("import sys\n"); + writer.write("from services.spawn import MobileTemplate\n"); + if (mobile.getWeaponTemplates().size() > 0) + writer.write("from services.spawn import WeaponTemplate\n"); + writer.write("from java.util import Vector\n"); + writer.newLine(); + + writer.write("def addTemplate(core):\n"); + writer.write("\tmobileTemplate = MobileTemplate()\n"); + writer.newLine(); + + writer.write("\tmobileTemplate.setCreatureName('" + mobile.getCreatureName() + "')\n"); + writer.write("\tmobileTemplate.setLevel(" + String.valueOf(mobile.getLevel()) + ")\n"); + writer.write("\tmobileTemplate.setDifficulty(" + String.valueOf(mobile.getDifficulty()) + ")\n"); + writer.write("\tmobileTemplate.setAttackRange(" + String.valueOf(mobile.getAttackRange()) + ")\n"); + writer.write("\tmobileTemplate.setAttackSpeed(" + String.valueOf(mobile.getAttackSpeed()) + ")\n"); + writer.write("\tmobileTemplate.setWeaponType(" + String.valueOf(mobile.getWeaponType()) + ")\n"); + writer.write("\tmobileTemplate.setMinSpawnDistance(" + String.valueOf(mobile.getMinSpawnDistance()) + ")\n"); + writer.write("\tmobileTemplate.setMaxSpawnDistance(" + String.valueOf(mobile.getMaxSpawnDistance()) + ")\n"); + writer.write("\tmobileTemplate.setDeathblow(" + (mobile.isDeathblowEnabled() ? "True" : "False") + ")\n"); + //writer.write("\tmobileTemplate.setScale(" + 1 + ")\n"); + if (mobile.getSocialGroup() != null && !mobile.getSocialGroup().isEmpty()) + writer.write("\tmobileTemplate.setSocialGroup('" + mobile.getSocialGroup() + "')\n"); + writer.write("\tmobileTemplate.setAssistRange(" + String.valueOf(mobile.getAssistRange()) + ")\n"); + writer.write("\tmobileTemplate.setStalker(" + (mobile.isStalker() ? "True" : "False") + ")\n"); + + if (mobile.getFaction() != null && !mobile.getFaction().equals("") && !mobile.getFaction().equalsIgnoreCase("neutral")) { + writer.write("\tmobileTemplate.setFaction('" + mobile.getFaction().toLowerCase() + "')\n"); + writer.write("\tmobileTemplate.setFactionStatus(" + String.valueOf(mobile.getFactionStatus()) + ")\n"); + } + writer.newLine(); + + writer.write("\ttemplates = new Vector()\n"); + if (mobile.getCreatureTemplates().size() > 0) { + for (String temp : mobile.getCreatureTemplates()) { + writer.write("\ttemplates.add('" + temp + "')\n"); + } + } + writer.write("\tmobileTemplate.setTemplates(templates)\n"); + writer.newLine(); + + writer.write("\tweaponTemplates = Vector()\n"); + if (mobile.getWeaponTemplates().size() > 0) { + for (Weapon weapon : mobile.getWeaponTemplates()) { + writer.write("\tweapontemplate = WeaponTemplate('" + weapon.getTemplate() + "', " + weapon.getWeaponType() + ", " + + weapon.getAttackSpeed() +")\n"); + writer.write("\tweaponTemplates.add(weapontemplate)\n"); + } + } + writer.write("\tmobileTemplate.setWeaponTemplateVector(weaponTemplates)\n"); + writer.newLine(); + + writer.write("\tattacks = new Vector()\n"); + if (mobile.getAttacks().size() > 0) { + for (String attack : mobile.getAttacks()) { + writer.write("\tattacks.add('" + attack + "')\n"); + } + } + writer.write("\tmobileTemplate.setDefaultAttack('" + mobile.getDefaultAttack() + "')\n"); + writer.write("\tmobileTemplate.setAttacks(attacks)"); + writer.newLine(); + + writer.write("\tcore.spawnService.addMobileTemplate('" + mobile.getTemplateName() + "', mobileTemplate)\n\treturn"); + + writer.close(); + + mobile.setDirty(false); + mobilesTree.updateUI(); + } catch (Exception e) { + Helpers.showExceptionError(frmPswgToolsMbs, e.getLocalizedMessage()); + e.printStackTrace(); + } + } + + private void saveCurrentValues() { + try { + Mobile mobileTemplate = (Mobile) ((DefaultMutableTreeNode) mobilesTree.getSelectionPath().getLastPathComponent()).getUserObject(); + + mobileTemplate.setCreatureName(tbCreatureName.getText()); + mobileTemplate.setScriptLocation(tbScriptLocation.getText()); + + mobileTemplate.setLevel((int) tbCreatureLevel.getValue()); + mobileTemplate.setMinLevel(Integer.valueOf(tbMinLevel.getText())); + mobileTemplate.setMaxLevel(Integer.valueOf(tbMaxLevel.getText())); + mobileTemplate.setAttackRange(Integer.valueOf(tbAttackRange.getText())); + mobileTemplate.setAttackSpeed(Float.valueOf(tbAttackSpeed.getText())); + mobileTemplate.setAssistRange(Integer.valueOf(tbAssistRange.getText())); + + mobileTemplate.setDifficulty(cmbDifficulty.getSelectedIndex()); + mobileTemplate.setDefaultAttack((String) cmbDefaultAttack.getSelectedItem()); + mobileTemplate.setWeaponType(cmbWeaponType.getSelectedIndex()); + + mobileTemplate.setSocialGroup(tbSocialGroup.getText()); + mobileTemplate.setFaction((String) cmbFaction.getSelectedItem()); + mobileTemplate.setFactionStatus(cmbFactionStatus.getSelectedIndex()); + mobileTemplate.setMinSpawnDistance(Integer.valueOf(tbMinSpawnDistance.getText())); + mobileTemplate.setMaxSpawnDistance(Integer.valueOf(tbMaxSpawnDistance.getText())); + + mobileTemplate.setDeathblowEnabled(chckbxDeathblowEnabled.isSelected()); + mobileTemplate.setStalker(chckbxStalker.isSelected()); + mobileTemplate.setHarvestable(chckbxHarvestable.isSelected()); + + if (creatureTemps.getSize() > 0) { + Object[] objArray = creatureTemps.toArray(); + String[] stringArray = Arrays.copyOf(objArray, objArray.length, String[].class); + Vector creatureTemplates = new Vector(Arrays.asList(stringArray)); + mobileTemplate.setCreatureTemplates(creatureTemplates); + } else { + mobileTemplate.setCreatureTemplates(new Vector()); + } + + if (weaponTemps.size() > 0) { + Object[] objArray = weaponTemps.toArray(); + String[] stringArray = Arrays.copyOf(objArray, objArray.length, String[].class); + Vector updatedWeaponTemps = new Vector(); + + for (String temp : stringArray) { + String[] values = temp.replace(" ", "").split(","); + updatedWeaponTemps.add(new Weapon(values[0], Integer.valueOf(values[1]), Float.valueOf(values[2]))); + } + + mobileTemplate.setWeaponTemplates(updatedWeaponTemps); + } else { + mobileTemplate.setWeaponTemplates(new Vector()); + } + + /* + if (mobileTemplate.getAttacks().size() != 0) + listAttacks.setListData(mobileTemplate.getAttacks()); + else + listAttacks.setListData(new String[] { "Template has no attacks." });*/ + + mobileTemplate.setDirty(true); + + if (!btnBuildCurrent.isEnabled()) + btnBuildCurrent.setEnabled(true); + + modifiedTemplates.add(mobileTemplate); + + if (modifiedTemplates.size() >= 2 && !btnBuildAll.isEnabled()) + btnBuildAll.setEnabled(true); + + mobilesTree.updateUI(); // Show Asterisk + System.out.println("Saved values for Template: " + mobileTemplate.getCreatureName()); + } catch (Exception e) { Helpers.showExceptionError(frmPswgToolsMbs, e.getLocalizedMessage());} + + } + + @SuppressWarnings({ "unchecked", "rawtypes", "serial" }) + public void updateWeaponTemplatesList(Mobile mobileTemplate) { + weaponTemps.clear(); + + if (mobileTemplate.getWeaponTemplates().size() != 0) { + + for (Weapon weapon : mobileTemplate.getWeaponTemplates()) + weaponTemps.addElement(weapon.toString()); + + listWeaponTemps.setModel(weaponTemps); + }else { + listWeaponTemps.setModel(new AbstractListModel() { + String[] values = new String[] {"No Weapon Templates found."}; + public int getSize() { + return values.length; + } + public Object getElementAt(int index) { + return values[index]; + } + }); + } + } + + private void tryBackup(File file, int count) throws IOException { + File backup = new File(file.getAbsolutePath() + ".bak." + String.valueOf(count)); + if (!backup.exists()) + Files.copy(file.toPath(), backup.toPath()); + else + tryBackup(backup, count++); + } + public void setActiveMobile(Mobile activeMobile) { + this.activeMobile = activeMobile; + } + + public void setConfig(Properties config) { + this.config = config; + } + + public void setCoreLocation(String coreLocation) { + this.coreLocation = coreLocation; + } + + public static MobileScriptBuilder getInstance() { + return instance; + } + + @SuppressWarnings("unchecked") + public DefaultListModel getWeaponTemps() { + return weaponTemps; + } + + @SuppressWarnings("unchecked") + public DefaultListModel getCreatureTemps() { + return creatureTemps; + } + + public void setWeaponTemps(DefaultListModel weaponTemps) { + this.weaponTemps = weaponTemps; + } + + public void setCreatureTemps(DefaultListModel creatureTemps) { + this.creatureTemps = creatureTemps; + } + + public JList getListWeaponTemps() { + return listWeaponTemps; + } + + public void setListWeaponTemps(JList listWeaponTemps) { + this.listWeaponTemps = listWeaponTemps; + } + + public JList getListCreatureTemps() { + return listCreatureTemps; + } + + public DefaultListModel getAttacks() { + return attacks; + } + + public void setAttacks(DefaultListModel attacks) { + this.attacks = attacks; + } + + public JTree getMobilesTree() { + return mobilesTree; + } + private static void addPopup(Component component, final JPopupMenu popup) { + component.addMouseListener(new MouseAdapter() { + public void mousePressed(MouseEvent e) { + if (e.isPopupTrigger()) { + showMenu(e); + } + } + public void mouseReleased(MouseEvent e) { + if (e.isPopupTrigger()) { + showMenu(e); + } + } + private void showMenu(MouseEvent e) { + popup.show(e.getComponent(), e.getX(), e.getY()); + } + }); + } +} diff --git a/src/waveTools/msb/resources/Helpers.java b/src/waveTools/msb/resources/Helpers.java new file mode 100644 index 0000000..cde4822 --- /dev/null +++ b/src/waveTools/msb/resources/Helpers.java @@ -0,0 +1,15 @@ +package waveTools.msb.resources; + +import java.awt.Component; + +import javax.swing.JOptionPane; + +public class Helpers { + public static void showMessageBox(Component parent, String message) { + JOptionPane.showMessageDialog(parent, message, "Mobile Script Builder", JOptionPane.INFORMATION_MESSAGE, null); + } + + public static void showExceptionError(Component parent, String stackTrace) { + JOptionPane.showMessageDialog(parent, "ERROR " + stackTrace, "Mobile Script Builder - ERROR", JOptionPane.ERROR_MESSAGE, null); + } +} diff --git a/src/waveTools/msb/resources/Mobile.java b/src/waveTools/msb/resources/Mobile.java new file mode 100644 index 0000000..ef95ea5 --- /dev/null +++ b/src/waveTools/msb/resources/Mobile.java @@ -0,0 +1,389 @@ +package waveTools.msb.resources; + +import java.util.Vector; + +public class Mobile { + + @SuppressWarnings("unused") + private static final long serialVersionUID = 1L; + + private String scriptLocation; + private String templateName; + private String creatureName; + + private String defaultAttack; + private String socialGroup; + private int level; + private int minLevel; + private int maxLevel; + private int difficulty; + private int attackRange; + private int weaponType; + private int minSpawnDistance; + private int maxSpawnDistance; + private int assistRange; + private int respawnTime; + private boolean harvestable; + private boolean stalker; + private String faction; + private int factionStatus; + private float attackSpeed; + private boolean deathblowEnabled; + private String meatType, milkType, boneType, hideType; + private int meatAmount, milkAmount, boneAmount, hideAmount; + private Vector creatureTemplates = new Vector(); + private Vector weaponTemplates = new Vector(); + private Vector attacks = new Vector(); + private boolean dirty; + + public Mobile(String template, String scriptLocation) { + this.templateName = template; + this.scriptLocation = scriptLocation; + } + + + public Mobile() { } + + + public String getScriptLocation() { + return scriptLocation; + } + + + public void setScriptLocation(String scriptLocation) { + this.scriptLocation = scriptLocation; + } + + + public String getCreatureName() { + return creatureName; + } + + + public void setCreatureName(String creatureName) { + this.creatureName = creatureName; + } + + + public Vector getCreatureTemplates() { + return creatureTemplates; + } + + + public void setCreatureTemplates(Vector creatureTemplates) { + this.creatureTemplates = creatureTemplates; + } + + + public Vector getWeaponTemplates() { + return weaponTemplates; + } + + + public Vector getAttacks() { + return attacks; + } + + + public void setWeaponTemplates(Vector weaponTemplates) { + this.weaponTemplates = weaponTemplates; + } + + public int getLevel() { + return level; + } + + + public void setLevel(int level) { + this.level = level; + } + + + public int getMinLevel() { + return minLevel; + } + + + public void setMinLevel(int minLevel) { + this.minLevel = minLevel; + } + + + public int getMaxLevel() { + return maxLevel; + } + + + public void setMaxLevel(int maxLevel) { + this.maxLevel = maxLevel; + } + + + public float getAttackSpeed() { + return attackSpeed; + } + + + public void setAttackSpeed(float attackSpeed) { + this.attackSpeed = attackSpeed; + } + + + public int getAttackRange() { + return attackRange; + } + + + public void setAttackRange(int attackRange) { + this.attackRange = attackRange; + } + + + public int getWeaponType() { + return weaponType; + } + + + public void setWeaponType(int weaponType) { + this.weaponType = weaponType; + } + + + public int getDifficulty() { + return difficulty; + } + + + public void setDifficulty(int difficulty) { + this.difficulty = difficulty; + } + + + public String getDefaultAttack() { + return defaultAttack; + } + + + public void setDefaultAttack(String defaultAttack) { + this.defaultAttack = defaultAttack; + } + + + public boolean isDirty() { + return dirty; + } + + + public void setDirty(boolean dirty) { + this.dirty = dirty; + } + + public boolean isDeathblowEnabled() { + return deathblowEnabled; + } + + + public void setDeathblowEnabled(boolean deathblowEnabled) { + this.deathblowEnabled = deathblowEnabled; + } + + + public String getSocialGroup() { + return socialGroup; + } + + + public void setSocialGroup(String socialGroup) { + this.socialGroup = socialGroup; + } + + + public int getMinSpawnDistance() { + return minSpawnDistance; + } + + + public void setMinSpawnDistance(int minSpawnDistance) { + this.minSpawnDistance = minSpawnDistance; + } + + + public int getMaxSpawnDistance() { + return maxSpawnDistance; + } + + + public void setMaxSpawnDistance(int maxSpawnDistance) { + this.maxSpawnDistance = maxSpawnDistance; + } + + + public int getAssistRange() { + return assistRange; + } + + + public void setAssistRange(int assistRange) { + this.assistRange = assistRange; + } + + + public int getRespawnTime() { + return respawnTime; + } + + + public void setRespawnTime(int respawnTime) { + this.respawnTime = respawnTime; + } + + + public boolean isHarvestable() { + return harvestable; + } + + + public void setHarvestable(boolean harvestable) { + this.harvestable = harvestable; + } + + + public String getFaction() { + return faction; + } + + + public void setFaction(String faction) { + this.faction = faction; + } + + + public int getFactionStatus() { + return factionStatus; + } + + + public void setFactionStatus(int factionStatus) { + this.factionStatus = factionStatus; + } + + + public String getMeatType() { + return meatType; + } + + + public void setMeatType(String meatType) { + this.meatType = meatType; + } + + + public String getMilkType() { + return milkType; + } + + + public void setMilkType(String milkType) { + this.milkType = milkType; + } + + + public String getBoneType() { + return boneType; + } + + + public void setBoneType(String boneType) { + this.boneType = boneType; + } + + + public String getHideType() { + return hideType; + } + + + public void setHideType(String hideType) { + this.hideType = hideType; + } + + + public int getMeatAmount() { + return meatAmount; + } + + + public void setMeatAmount(int meatAmount) { + this.meatAmount = meatAmount; + } + + + public int getMilkAmount() { + return milkAmount; + } + + + public void setMilkAmount(int milkAmount) { + this.milkAmount = milkAmount; + } + + + public int getBoneAmount() { + return boneAmount; + } + + + public void setBoneAmount(int boneAmount) { + this.boneAmount = boneAmount; + } + + + public int getHideAmount() { + return hideAmount; + } + + + public void setHideAmount(int hideAmount) { + this.hideAmount = hideAmount; + } + + + public void setAttacks(Vector attacks) { + this.attacks = attacks; + } + + + public void addCreatureTemplate(String template) { + creatureTemplates.add(template); + } + + public void addAttack(String attack) { + attacks.add(attack); + } + public boolean isStalker() { + return stalker; + } + + + public void setStalker(boolean stalker) { + this.stalker = stalker; + } + + + @Override + public String toString() { + if (dirty) + return "*" + templateName; + else return templateName; + } + + + public String getTemplateName() { + return templateName; + } + + + public void setTemplateName(String templateName) { + this.templateName = templateName; + } +} diff --git a/src/waveTools/msb/resources/Weapon.java b/src/waveTools/msb/resources/Weapon.java new file mode 100644 index 0000000..86daf21 --- /dev/null +++ b/src/waveTools/msb/resources/Weapon.java @@ -0,0 +1,42 @@ +package waveTools.msb.resources; + +public class Weapon { + private String template; + private int weaponType; + private float attackSpeed; + + public Weapon(String template, int weaponType, float attackSpeed) { + this.template = template; + this.weaponType = weaponType; + this.attackSpeed = attackSpeed; + } + + public String getTemplate() { + return template; + } + + public void setTemplate(String template) { + this.template = template; + } + + public int getWeaponType() { + return weaponType; + } + + public void setWeaponType(int weaponType) { + this.weaponType = weaponType; + } + + public float getAttackSpeed() { + return attackSpeed; + } + + public void setAttackSpeed(float attackSpeed) { + this.attackSpeed = attackSpeed; + } + + @Override + public String toString() { + return template + ", " + String.valueOf(weaponType) + ", " + String.valueOf(attackSpeed); + } +} diff --git a/src/waveTools/msb/resources/enums/Difficulty.java b/src/waveTools/msb/resources/enums/Difficulty.java new file mode 100644 index 0000000..8922a40 --- /dev/null +++ b/src/waveTools/msb/resources/enums/Difficulty.java @@ -0,0 +1,25 @@ +package waveTools.msb.resources.enums; + +public enum Difficulty { + NORMAL(0), ELITE(1), BOSS(2); + + @SuppressWarnings("unused") + private int difficulty; + + private Difficulty(int difficulty) { + this.difficulty = difficulty; + } + + @Override + public String toString() { + switch(this) { + case NORMAL: + return "Normal"; + case ELITE: + return "Elite"; + case BOSS: + return "Boss"; + } + return null; + } +} diff --git a/src/waveTools/msb/resources/enums/WeaponType.java b/src/waveTools/msb/resources/enums/WeaponType.java new file mode 100644 index 0000000..9be1c82 --- /dev/null +++ b/src/waveTools/msb/resources/enums/WeaponType.java @@ -0,0 +1,45 @@ +package waveTools.msb.resources.enums; + +public enum WeaponType { + RIFLE(0), CARBINE(1), PISTOL(2), ONEHANDEDMELEE(4), TWOHANDEDMELEE(5), UNARMED(6), POLEARMMELEE(7), THROWN(8), + ONEHANDEDSABER(9), TWOHANDEDSABER(10), POLEARMSABER(11), HEAVYWEAPON(12), FLAMETHROWER(13); + + private int weaponType; + + private WeaponType(int weaponType) { + this.weaponType = weaponType; + } + + @Override + public String toString() { + switch(this) { + case RIFLE: + return "Rifle"; + case CARBINE: + return "Carbine"; + case PISTOL: + return "Pistol"; + case ONEHANDEDMELEE: + return "1H - Melee"; + case TWOHANDEDMELEE: + return "2H - Melee"; + case UNARMED: + return "Unarmed"; + case POLEARMMELEE: + return "Polearm - Melee"; + case THROWN: + return "Thrown"; + case ONEHANDEDSABER: + return "1H - Saber"; + case TWOHANDEDSABER: + return "2H - Saber"; + case POLEARMSABER: + return "Polearm - Saber"; + case HEAVYWEAPON: + return "Heavy Weapon"; + case FLAMETHROWER: + return "Flame Thrower"; + } + return null; + } +} diff --git a/src/waveTools/msb/secondaryWindows/CreatureTemplateDialog.java b/src/waveTools/msb/secondaryWindows/CreatureTemplateDialog.java new file mode 100644 index 0000000..b64ce71 --- /dev/null +++ b/src/waveTools/msb/secondaryWindows/CreatureTemplateDialog.java @@ -0,0 +1,122 @@ +package waveTools.msb.secondaryWindows; + +import java.awt.BorderLayout; +import java.awt.FlowLayout; + +import javax.swing.DefaultListModel; +import javax.swing.JButton; +import javax.swing.JDialog; +import javax.swing.JPanel; +import javax.swing.border.EmptyBorder; + +import java.awt.GridBagLayout; + +import javax.swing.JLabel; + +import java.awt.GridBagConstraints; + +import javax.swing.JTextField; + +import waveTools.msb.MobileScriptBuilder; +import waveTools.msb.resources.Helpers; + +import java.awt.Insets; +import java.awt.event.ActionListener; +import java.awt.event.ActionEvent; + +public class CreatureTemplateDialog extends JDialog { + + private final JPanel contentPanel = new JPanel(); + private MobileScriptBuilder mainWnd = MobileScriptBuilder.getInstance(); + private JTextField tbCreatureTempName; + + /** + * Launch the application. + */ + public static void main(String[] args) { + try { + CreatureTemplateDialog dialog = new CreatureTemplateDialog(); + dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE); + dialog.setVisible(true); + } catch (Exception e) { + e.printStackTrace(); + } + } + + /** + * Create the dialog. + */ + public CreatureTemplateDialog() { + setTitle("Creature Template Editor - MSB"); + setBounds(100, 100, 294, 110); + getContentPane().setLayout(new BorderLayout()); + contentPanel.setBorder(new EmptyBorder(5, 5, 5, 5)); + getContentPane().add(contentPanel, BorderLayout.CENTER); + GridBagLayout gbl_contentPanel = new GridBagLayout(); + gbl_contentPanel.columnWidths = new int[]{0, 0, 0}; + gbl_contentPanel.rowHeights = new int[]{33, 0}; + gbl_contentPanel.columnWeights = new double[]{0.0, 1.0, Double.MIN_VALUE}; + gbl_contentPanel.rowWeights = new double[]{0.0, Double.MIN_VALUE}; + contentPanel.setLayout(gbl_contentPanel); + { + JLabel lblCreatureTemplate = new JLabel("Creature Template"); + GridBagConstraints gbc_lblCreatureTemplate = new GridBagConstraints(); + gbc_lblCreatureTemplate.insets = new Insets(0, 0, 0, 5); + gbc_lblCreatureTemplate.anchor = GridBagConstraints.EAST; + gbc_lblCreatureTemplate.gridx = 0; + gbc_lblCreatureTemplate.gridy = 0; + contentPanel.add(lblCreatureTemplate, gbc_lblCreatureTemplate); + } + { + tbCreatureTempName = new JTextField(); + GridBagConstraints gbc_tbCreatureTempName = new GridBagConstraints(); + gbc_tbCreatureTempName.fill = GridBagConstraints.HORIZONTAL; + gbc_tbCreatureTempName.gridx = 1; + gbc_tbCreatureTempName.gridy = 0; + contentPanel.add(tbCreatureTempName, gbc_tbCreatureTempName); + tbCreatureTempName.setColumns(10); + } + { + JPanel buttonPane = new JPanel(); + buttonPane.setLayout(new FlowLayout(FlowLayout.CENTER)); + getContentPane().add(buttonPane, BorderLayout.SOUTH); + { + JButton okButton = new JButton("OK"); + okButton.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent arg0) { + String template = tbCreatureTempName.getText(); + + if (!template.startsWith("object/mobile/") || !template.endsWith(".iff")) { + Helpers.showMessageBox(contentPanel, template + " is an invalid weapon template."); + return; + } + + if (mainWnd.getCreatureTemps() != null && mainWnd.getCreatureTemps().size() == 0) { + DefaultListModel model = new DefaultListModel(); + model.addElement(template); + mainWnd.setCreatureTemps(model); + mainWnd.getListWeaponTemps().setModel(model); + } else if (mainWnd.getCreatureTemps().contains(template)) { + // Nothing changed, nothing needs to be done. + } else { + mainWnd.getCreatureTemps().addElement(template); + } + dispose(); + } + }); + okButton.setActionCommand("OK"); + buttonPane.add(okButton); + getRootPane().setDefaultButton(okButton); + } + { + JButton cancelButton = new JButton("Cancel"); + cancelButton.setActionCommand("Cancel"); + buttonPane.add(cancelButton); + } + } + } + + public void setTbCreatureTempNameText(String text) { + this.tbCreatureTempName.setText(text); + } +} diff --git a/src/waveTools/msb/secondaryWindows/Settings.java b/src/waveTools/msb/secondaryWindows/Settings.java new file mode 100644 index 0000000..44dd6af --- /dev/null +++ b/src/waveTools/msb/secondaryWindows/Settings.java @@ -0,0 +1,181 @@ +package waveTools.msb.secondaryWindows; + +import java.awt.BorderLayout; +import java.awt.FlowLayout; + +import javax.swing.JButton; +import javax.swing.JDialog; +import javax.swing.JFileChooser; +import javax.swing.JPanel; +import javax.swing.border.EmptyBorder; +import javax.swing.JLabel; +import javax.swing.JTextField; + +import waveTools.msb.MobileScriptBuilder; +import waveTools.msb.resources.Helpers; + +import java.awt.event.ActionListener; +import java.awt.event.ActionEvent; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.PrintWriter; +import java.util.Properties; + +@SuppressWarnings("serial") +public class Settings extends JDialog { + + private final JPanel contentPanel = new JPanel(); + + private boolean dirty; + private JTextField tbCore2Location; + private Properties config; + private MobileScriptBuilder mainWindow = MobileScriptBuilder.getInstance(); + + public Settings() { + setTitle("MobileScriptBuilder - Settings"); + setBounds(100, 100, 540, 128); + getContentPane().setLayout(new BorderLayout()); + contentPanel.setBorder(new EmptyBorder(5, 5, 5, 5)); + getContentPane().add(contentPanel, BorderLayout.CENTER); + contentPanel.setLayout(null); + { + JLabel lblNgecoreLocation = new JLabel("NGECore2 Location"); + lblNgecoreLocation.setBounds(12, 23, 120, 15); + contentPanel.add(lblNgecoreLocation); + } + + tbCore2Location = new JTextField(); + tbCore2Location.setBounds(227, 16, 287, 28); + contentPanel.add(tbCore2Location); + tbCore2Location.setColumns(10); + + String coreLocation = mainWindow.getCoreLocation(); + if (coreLocation != null && !coreLocation.equals("") && !coreLocation.equals(" ")) { + tbCore2Location.setText(coreLocation); + } + + JButton btnBrowse = new JButton("Browse.."); + btnBrowse.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent arg0) { + openCoreLocationWindow(); + } + }); + btnBrowse.setBounds(127, 16, 90, 28); + contentPanel.add(btnBrowse); + { + JPanel buttonPane = new JPanel(); + buttonPane.setLayout(new FlowLayout(FlowLayout.RIGHT)); + getContentPane().add(buttonPane, BorderLayout.SOUTH); + { + JButton okButton = new JButton("OK"); + okButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent arg0) { + if (dirty) { + + Helpers.showMessageBox(contentPanel, "Settings updated!"); + mainWindow.setCoreLocation(tbCore2Location.getText()); + mainWindow.populateMobilesTree(new File(tbCore2Location.getText() + "\\scripts\\mobiles")); + + try { + FileOutputStream out = new FileOutputStream("./config.cfg"); + + config.setProperty("CoreLocation", tbCore2Location.getText()); + + config.store(out, null); + out.close(); + } catch (Exception e) { Helpers.showExceptionError(contentPanel, e.getLocalizedMessage()); } + + //setVisible(false); + setDirty(false); + } else { + //setVisible(false); + } + + dispose(); + } + }); + okButton.setActionCommand("OK"); + buttonPane.add(okButton); + getRootPane().setDefaultButton(okButton); + } + { + JButton cancelButton = new JButton("Cancel"); + cancelButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(ActionEvent arg0) { + if (dirty) { } // TODO: You have unsaved changes, are you sure you want to cancel? + //setVisible(false); + dispose(); + } + + }); + cancelButton.setActionCommand("Cancel"); + buttonPane.add(cancelButton); + } + } + setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE); + postLoad(); + } + private void postLoad() { + config = mainWindow.getConfig(); + if (config == null) { + File configFile = new File("./config.cfg"); + + if (!configFile.exists()) { + try { + configFile.createNewFile(); + PrintWriter writer = new PrintWriter(configFile, "UTF-8"); + writer.print("CoreLocation="); + writer.close(); + } catch (Exception e) { Helpers.showExceptionError(contentPanel, e.getLocalizedMessage()); } + } + try { + FileInputStream inputStream = new FileInputStream(configFile); + config.load(inputStream); + tbCore2Location.setText(config.getProperty("CoreLocation")); + inputStream.close(); + } catch (Exception e) { Helpers.showExceptionError(contentPanel, e.getLocalizedMessage()); } + mainWindow.setConfig(config); + } + } + private void openCoreLocationWindow() { + JFileChooser coreFolderSelect = new JFileChooser(); + coreFolderSelect.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY); + coreFolderSelect.setDialogTitle("Select NGECore2 folder"); + int success = coreFolderSelect.showOpenDialog(contentPanel); + + if (success == JFileChooser.APPROVE_OPTION) { + File selectedDirectory = coreFolderSelect.getSelectedFile(); + String corePath = selectedDirectory.getAbsolutePath(); + if (!selectedDirectory.getName().equals("NGECore2")) { + File[] childrenFolders = selectedDirectory.listFiles(); + String coreFolder = ""; + for (File childrenFolder : childrenFolders) { + if (childrenFolder.getName().equals("NGECore2")) { + coreFolder = childrenFolder.getAbsolutePath(); + break; + } + } + if (coreFolder.equals("")) { + Helpers.showMessageBox(coreFolderSelect, "Could not find NGECore2 in the directory " + selectedDirectory.getAbsolutePath()); + openCoreLocationWindow(); + return; + } else { corePath = coreFolder; } + } + tbCore2Location.setText(corePath); + + if (!dirty) + dirty = true; + } + } + + public boolean isDirty() { + return dirty; + } + + private void setDirty(boolean dirty) { + this.dirty = dirty; + } +} diff --git a/src/waveTools/msb/secondaryWindows/WeaponTemplateDialog.java b/src/waveTools/msb/secondaryWindows/WeaponTemplateDialog.java new file mode 100644 index 0000000..522b55a --- /dev/null +++ b/src/waveTools/msb/secondaryWindows/WeaponTemplateDialog.java @@ -0,0 +1,183 @@ +package waveTools.msb.secondaryWindows; + +import java.awt.BorderLayout; +import java.awt.FlowLayout; +import java.text.DecimalFormat; + +import javax.swing.JButton; +import javax.swing.JDialog; +import javax.swing.JPanel; +import javax.swing.border.EmptyBorder; +import javax.swing.text.NumberFormatter; +import javax.swing.UIManager; + +import com.jgoodies.forms.layout.FormLayout; +import com.jgoodies.forms.layout.ColumnSpec; +import com.jgoodies.forms.layout.RowSpec; +import com.jgoodies.forms.factories.FormFactory; + +import javax.swing.DefaultListModel; +import javax.swing.JLabel; +import javax.swing.JTextField; +import javax.swing.JComboBox; +import javax.swing.DefaultComboBoxModel; + +import waveTools.msb.MobileScriptBuilder; +import waveTools.msb.resources.Helpers; +import waveTools.msb.resources.Weapon; +import waveTools.msb.resources.enums.WeaponType; + +import javax.swing.JFormattedTextField; + +import java.awt.event.ActionListener; +import java.awt.event.ActionEvent; + +public class WeaponTemplateDialog extends JDialog { + + private static final long serialVersionUID = 1L; + private final JPanel contentPanel = new JPanel(); + private JTextField tbWeaponTemp; + private MobileScriptBuilder mainWnd = MobileScriptBuilder.getInstance(); + private JFormattedTextField tbAttackSpeed; + private JComboBox cmbWeaponType; + private boolean editMode; + /** + * Launch the application. + */ + public static void main(String[] args) { + try { + UIManager.setLookAndFeel("javax.swing.plaf.nimbus.NimbusLookAndFeel"); + } catch (Throwable e) { + e.printStackTrace(); + } + try { + WeaponTemplateDialog dialog = new WeaponTemplateDialog(); + dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE); + dialog.setVisible(true); + } catch (Exception e) { + e.printStackTrace(); + } + } + + /** + * Create the dialog. + */ + @SuppressWarnings({ "unchecked", "rawtypes" }) + public WeaponTemplateDialog() { + setTitle("MobileScriptBuilder - Edit Weapon Template"); + setBounds(100, 100, 356, 187); + getContentPane().setLayout(new BorderLayout()); + contentPanel.setBorder(new EmptyBorder(5, 5, 5, 5)); + getContentPane().add(contentPanel, BorderLayout.CENTER); + contentPanel.setLayout(new FormLayout(new ColumnSpec[] { + FormFactory.RELATED_GAP_COLSPEC, + FormFactory.DEFAULT_COLSPEC, + FormFactory.RELATED_GAP_COLSPEC, + ColumnSpec.decode("default:grow"),}, + new RowSpec[] { + FormFactory.RELATED_GAP_ROWSPEC, + FormFactory.DEFAULT_ROWSPEC, + FormFactory.RELATED_GAP_ROWSPEC, + FormFactory.DEFAULT_ROWSPEC, + FormFactory.RELATED_GAP_ROWSPEC, + FormFactory.DEFAULT_ROWSPEC,})); + { + JLabel lblWeaponTemplateIff = new JLabel("Weapon Template IFF"); + contentPanel.add(lblWeaponTemplateIff, "2, 2, right, default"); + } + { + tbWeaponTemp = new JTextField(); + contentPanel.add(tbWeaponTemp, "4, 2, fill, default"); + tbWeaponTemp.setColumns(10); + } + { + JLabel lblWeaponType = new JLabel("Weapon Type"); + contentPanel.add(lblWeaponType, "2, 4, right, default"); + } + { + cmbWeaponType = new JComboBox(); + cmbWeaponType.setModel(new DefaultComboBoxModel(WeaponType.values())); + contentPanel.add(cmbWeaponType, "4, 4, fill, default"); + } + { + JLabel lblAttackSpeed = new JLabel("Attack Speed"); + contentPanel.add(lblAttackSpeed, "2, 6, right, default"); + } + { + tbAttackSpeed = new JFormattedTextField(new NumberFormatter(new DecimalFormat())); + contentPanel.add(tbAttackSpeed, "4, 6, fill, default"); + } + { + JPanel buttonPane = new JPanel(); + buttonPane.setLayout(new FlowLayout(FlowLayout.RIGHT)); + getContentPane().add(buttonPane, BorderLayout.SOUTH); + { + JButton okButton = new JButton("OK"); + okButton.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent arg0) { + String weaponTemp = tbWeaponTemp.getText(); + if (!weaponTemp.startsWith("object/weapon/") || !weaponTemp.endsWith(".iff")) { + Helpers.showMessageBox(contentPanel, weaponTemp + " is an invalid weapon template."); + return; + } + String attackSpeed = ""; + if (tbAttackSpeed.getText() == null || tbAttackSpeed.getText().isEmpty() || tbAttackSpeed.getText() == "" || tbAttackSpeed.getText() == " ") { + attackSpeed = "0.0"; + } else { + attackSpeed = tbAttackSpeed.getText(); + } + Weapon weapon = new Weapon(weaponTemp, cmbWeaponType.getSelectedIndex(), Float.valueOf(attackSpeed)); + + if (mainWnd.getWeaponTemps() != null && mainWnd.getWeaponTemps().size() == 0) { + DefaultListModel model = new DefaultListModel(); + model.addElement(weapon.toString()); + mainWnd.setWeaponTemps(model); + mainWnd.getListWeaponTemps().setModel(model); + } else if (mainWnd.getWeaponTemps().contains(weapon.toString())) { + // Nothing changed, nothing needs to be done. + } else if (editMode && mainWnd.getListWeaponTemps().getSelectedValue() != null) { + mainWnd.getWeaponTemps().removeElement(mainWnd.getListWeaponTemps().getSelectedValue()); + mainWnd.getWeaponTemps().addElement(weapon.toString()); + editMode = false; + } else { + mainWnd.getWeaponTemps().addElement(weapon.toString()); + } + + setVisible(false); + } + }); + okButton.setActionCommand("OK"); + buttonPane.add(okButton); + getRootPane().setDefaultButton(okButton); + } + { + JButton cancelButton = new JButton("Cancel"); + cancelButton.addActionListener(new ActionListener() { + public void actionPerformed(ActionEvent arg0) { + setVisible(false); + } + }); + cancelButton.setActionCommand("Cancel"); + buttonPane.add(cancelButton); + } + } + } + + public JTextField getTbWeaponTemp() { + return tbWeaponTemp; + } + public JComboBox getCmbWeaponType() { + return cmbWeaponType; + } + public JFormattedTextField getTbAttackSpeed() { + return tbAttackSpeed; + } + + public boolean isEditMode() { + return editMode; + } + + public void setEditMode(boolean editMode) { + this.editMode = editMode; + } +}