Jump to content
  • 0
Sign in to follow this  
doctorgetsum

Rune Evo 4 Drop Editor Error

Question

Hello Everyone, I would like to start off by saying that I'm new to java development. Me and a couple friends are just fooling around on Rune Evo 4 trying to learn how code works while playing our favorite game.

So we recently started using Rune Evo 4. If you don't already know, Rune Evo 4 doesn't use the unpacked drops/spawns/prices like previous rune evo's. Instead you have to use these tools which allow you to edit prices, drops, ect. I have ran into a problem when attempting to run these tools...

First is the DropEditor.bat. When I try to just run the bat I get this error:

[QUOTE]Error: Could not find or load main class DropEditor.java
Press any key to continue...[/QUOTE]

If I attempt to run the DropEditor.java through eclipse then I get this error:

[QUOTE]Exception in thread "AWT-EventQueue-0" java.lang.ExceptionInInitializerError
at com.foxtrot.utils.tools.DropEditor.<init>(DropEditor.java:67)
at com.foxtrot.utils.tools.DropEditor$17.run(DropEditor.java:695)
at java.awt.event.InvocationEvent.dispatch(Unknown Source)
at java.awt.EventQueue.dispatchEventImpl(Unknown Source)
at java.awt.EventQueue.access$500(Unknown Source)
at java.awt.EventQueue$3.run(Unknown Source)
at java.awt.EventQueue$3.run(Unknown Source)
at java.security.AccessController.doPrivileged(Native Method)
at java.security.ProtectionDomain$1.doIntersectionPrivilege(Unknown Source)
at java.awt.EventQueue.dispatchEvent(Unknown Source)
at java.awt.EventDispatchThread.pumpOneEventForFilters(Unknown Source)
at java.awt.EventDispatchThread.pumpEventsForFilter(Unknown Source)
at java.awt.EventDispatchThread.pumpEventsForHierarchy(Unknown Source)
at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
at java.awt.EventDispatchThread.pumpEvents(Unknown Source)
at java.awt.EventDispatchThread.run(Unknown Source)
Caused by: java.lang.NullPointerException
at com.foxtrot.Server.getSavePath(Server.java:145)
at com.foxtrot.utils.NPCDrops.<clinit>(NPCDrops.java:17)
... 16 more[/QUOTE]


This is quite frustrating because I can't edit any prices or drops...
If anyone could please explain to me what I am doing wrong I would really appreciate it. I have attempted to google around and look at the code myself the past couple days but as I said I am newbie...

Thank you to anyone who takes the time to read this.

PS. I posted the DropEditor.java below if you wish to view it.


[CODE]package com.foxtrot.utils.tools;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Enumeration;
import java.util.Map.Entry;
import java.util.Random;
import java.util.SortedMap;
import java.util.TreeMap;

import javax.swing.GroupLayout;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JProgressBar;
import javax.swing.JScrollPane;
import javax.swing.JSeparator;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.JTree;
import javax.swing.LayoutStyle;
import javax.swing.SwingConstants;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.WindowConstants;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;
import javax.swing.table.DefaultTableModel;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;

import com.foxtrot.Server;
import com.foxtrot.cache.Cache;
import com.foxtrot.cache.loaders.ItemDefinitions;
import com.foxtrot.cache.loaders.NPCDefinitions;
import com.foxtrot.game.npc.Drop;
import com.foxtrot.utils.NPCDrops;
import com.foxtrot.utils.Utils;




/**
* @author Marvin
*/
public class DropEditor extends JFrame {

private static final long serialVersionUID = 1L;
private DefaultMutableTreeNode dropsNode = new DefaultMutableTreeNode("Drops");
private DefaultTreeModel dropsTreeModel = new DefaultTreeModel(dropsNode);
private NPCDrops loader = new NPCDrops();
Random random = new Random();
private JMenuItem dumpSpecificDropMenuItem;
private JProgressBar progressBar;
private JPopupMenu tablePopup;
private JMenuItem testItem;

/**
* Creates new form DropEditor
*/
public DropEditor() {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (ClassNotFoundException | InstantiationException
| IllegalAccessException | UnsupportedLookAndFeelException ex) {
}
try {
Cache.init();
NPCDrops.init();
} catch (IOException e) {
e.printStackTrace();
}

SortedMap<Integer, ArrayList<Drop>> values = new TreeMap<Integer, ArrayList<Drop>>(
new Comparator<Integer>() {

[MENTION=15855]Over[/MENTION]ride
public int compare(Integer o1, Integer o2) {
if (o1 > o2) {
return 1;
} else if (o1 < o2) {
return -1;
}
return 0;
}
});

values.putAll(loader.getDropArray());

loader.getDropArray().putAll(values);

for (Entry<Integer, ArrayList<Drop>> s : loader.getDropArray().entrySet()) {
dropsNode.add(new DefaultMutableTreeNode(s.getKey()));
}
initComponents();
}

/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/

// <editor-fold defaultstate="collapsed"
// desc="Generated Code">//GEN-BEGIN:initComponents
private void initComponents() {

treeScroll = new JScrollPane();
dropsTree = new JTree();
searchField = new JTextField();
searchIdLabel = new JLabel();
middleSeparator = new JSeparator();
dropsPanel = new JPanel();
dropsForLabel = new JLabel();
headerSeparator = new JSeparator();
npcIdLabel = new JLabel();
tableScroll = new JScrollPane();
dropTable = new JTable();
tablePopup = new JPopupMenu();
testItem = new JMenuItem("Test Rate");
addNew = new JButton();
deleteSelected = new JButton();
repackDrop = new JButton();
scanButton = new JButton();
addNewButton = new JButton();
removeDrop = new JButton();
fileMenu = new JMenuBar();
jMenu1 = new JMenu();
scan = new JMenuItem();
dumpDropMenuItem = new JMenuItem();
dumpSpecificDropMenuItem = new JMenuItem();
progressBar = new JProgressBar(-1, Utils.getNPCDefinitionsSize());
progressBar.setStringPainted(true);

setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
setIconImage(new ImageIcon("./data/tools/icon.png").getImage());
setTitle(Server.getConfig().getServerName() + " Drop Editor");

dropsTree.setModel(dropsTreeModel);
dropsTree.addTreeSelectionListener(new TreeSelectionListener() {
public void valueChanged(TreeSelectionEvent evt) {
dropsTreeValueChanged(evt);
}
});
treeScroll.setViewportView(dropsTree);

searchField.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {
searchFieldActionPerformed(evt);
}
});

searchIdLabel.setFont(new java.awt.Font("Tahoma", 0, 12)); // NOI18N
searchIdLabel.setText("Search ID:");

middleSeparator.setOrientation(SwingConstants.VERTICAL);

dropsForLabel.setFont(new java.awt.Font("Tahoma", 0, 14)); // NOI18N
dropsForLabel.setText("Drops for NPC ID:");

npcIdLabel.setFont(new java.awt.Font("Tahoma", 0, 14)); // NOI18N
npcIdLabel.setText(" ");

dropTable.setModel(new DefaultTableModel(new Object[][] {}, new String[] {}));
testItem.addActionListener(new ActionListener() {

[MENTION=15855]Over[/MENTION]ride
public void actionPerformed(ActionEvent arg0) {
testDropRate(arg0);

}
});
tablePopup.add(testItem);

dropTable.addMouseListener(new MouseListener() {

[MENTION=15855]Over[/MENTION]ride
public void mouseClicked(MouseEvent arg0) {
if (arg0.getButton() == MouseEvent.BUTTON3) {
int row = dropTable.rowAtPoint(arg0.getPoint());
dropTable.changeSelection(row, dropTable.getSelectedColumn(), false, false);
tablePopup.show(dropTable, arg0.getX(), arg0.getY());
}

}

[MENTION=15855]Over[/MENTION]ride
public void mouseEntered(MouseEvent arg0) {
// TODO Auto-generated method stub
}

[MENTION=15855]Over[/MENTION]ride
public void mouseExited(MouseEvent arg0) {
// TODO Auto-generated method stub
}

[MENTION=15855]Over[/MENTION]ride
public void mousePressed(MouseEvent arg0) {
// TODO Auto-generated method stub
}

[MENTION=15855]Over[/MENTION]ride
public void mouseReleased(MouseEvent arg0) {
// TODO Auto-generated method stub
}
});
tableScroll.setViewportView(dropTable);

addNew.setText("Add New Drop");
addNew.addActionListener(new ActionListener() {

[MENTION=15855]Over[/MENTION]ride
public void actionPerformed(ActionEvent evt) {
addNewActionPerformed(evt);
}
});

deleteSelected.setText("Delete Selected Drop");
deleteSelected.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent evt) {
deleteSelectedActionPerformed(evt);
}
});

repackDrop.setText("Repack");
repackDrop.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent evt) {
repackDropActionPerformed(evt);
}
});

scanButton.setText("Scan");
scanButton.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {
scanListActionPerformed(evt);
}
});

GroupLayout dropsPanelLayout = new GroupLayout(dropsPanel);
dropsPanel.setLayout(dropsPanelLayout);
dropsPanelLayout
.setHorizontalGroup(dropsPanelLayout
.createParallelGroup(
GroupLayout.Alignment.LEADING)
.addGroup(
GroupLayout.Alignment.TRAILING,
dropsPanelLayout
.createSequentialGroup()
.addContainerGap()
.addGroup(
dropsPanelLayout
.createParallelGroup(
GroupLayout.Alignment.TRAILING)
.addComponent(
headerSeparator,
GroupLayout.Alignment.LEADING,
GroupLayout.DEFAULT_SIZE,
424,
Short.MAX_VALUE)
.addGroup(GroupLayout.Alignment.LEADING, dropsPanelLayout.createSequentialGroup().addComponent(dropsForLabel)
.addPreferredGap(LayoutStyle.ComponentPlacement.UNRELATED)
.addComponent(npcIdLabel, GroupLayout.PREFERRED_SIZE, 200, GroupLayout.PREFERRED_SIZE))
.addComponent( tableScroll, GroupLayout.Alignment.LEADING, GroupLayout.DEFAULT_SIZE, 424, Short.MAX_VALUE)
.addGroup(GroupLayout.Alignment.LEADING,dropsPanelLayout.createSequentialGroup()
.addComponent(addNew, GroupLayout.DEFAULT_SIZE, 101, Short.MAX_VALUE)
.addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)
.addComponent(deleteSelected,GroupLayout.DEFAULT_SIZE,101,Short.MAX_VALUE)
.addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)
.addComponent(repackDrop, GroupLayout.DEFAULT_SIZE, 101, Short.MAX_VALUE)
.addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)
//.addComponent(scanButton, GroupLayout.DEFAULT_SIZE, 101, Short.MAX_VALUE)
//.addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)
.addContainerGap()))));
dropsPanelLayout
.setVerticalGroup(dropsPanelLayout
.createParallelGroup(
GroupLayout.Alignment.LEADING)
.addGroup(
dropsPanelLayout
.createSequentialGroup()
.addGroup(
dropsPanelLayout
.createParallelGroup(
GroupLayout.Alignment.BASELINE)
.addComponent(
dropsForLabel)
.addComponent(
npcIdLabel))
.addPreferredGap(
LayoutStyle.ComponentPlacement.RELATED)
.addComponent(
headerSeparator,
GroupLayout.PREFERRED_SIZE,
9,
GroupLayout.PREFERRED_SIZE)
.addPreferredGap(
LayoutStyle.ComponentPlacement.UNRELATED)
.addComponent(
tableScroll,
GroupLayout.DEFAULT_SIZE,
327, Short.MAX_VALUE)
.addPreferredGap(
LayoutStyle.ComponentPlacement.RELATED)
.addGroup(
dropsPanelLayout
.createParallelGroup(
GroupLayout.Alignment.BASELINE)
.addComponent(addNew)
.addComponent(
deleteSelected)
.addComponent(
repackDrop))
.addContainerGap()));

addNewButton.setText("Add New NPC Drop");
addNewButton.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {
addNewButtonActionPerformed(evt);
}
});

removeDrop.setText("Remove NPC Drop");
removeDrop.setToolTipText("Removes the currently Selected NPC Drop");
removeDrop.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {
removeDropActionPerformed(evt);
}
});

jMenu1.setText("File");

scan.setText("Scan for High Amounts");
scan.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent evt) {
scanListActionPerformed(evt);
}
});
jMenu1.add(scan);
dumpDropMenuItem.setText("Dump all monster drops");
dumpDropMenuItem.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {
dumpDropMenuItemActionPerformed(evt);
}
});
jMenu1.add(dumpDropMenuItem);
dumpSpecificDropMenuItem.setText("Dump specific monster drop");
dumpSpecificDropMenuItem
.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {
dumpSpecificDropMenuItemActionPerformed(evt);
}
});
jMenu1.add(dumpSpecificDropMenuItem);

fileMenu.add(jMenu1);

setJMenuBar(fileMenu);

GroupLayout layout = new GroupLayout(
getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(layout
.createParallelGroup(GroupLayout.Alignment.LEADING)
.addGroup(
layout.createSequentialGroup()
.addContainerGap()
.addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING,
false)
.addComponent(
removeDrop,
GroupLayout.DEFAULT_SIZE,
GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE)
.addGroup(
layout.createSequentialGroup()
.addComponent(
searchIdLabel)
.addPreferredGap(
LayoutStyle.ComponentPlacement.UNRELATED)
.addComponent(
searchField,
GroupLayout.PREFERRED_SIZE,
67,
GroupLayout.PREFERRED_SIZE))
.addComponent(
progressBar,
GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE)
.addComponent(
treeScroll,
GroupLayout.DEFAULT_SIZE,
134, Short.MAX_VALUE)
.addComponent(
addNewButton,
GroupLayout.DEFAULT_SIZE,
GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE))
.addPreferredGap(
LayoutStyle.ComponentPlacement.UNRELATED)
.addComponent(middleSeparator,
GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE)
.addGap(18, 18, 18)
.addComponent(dropsPanel,
GroupLayout.DEFAULT_SIZE,
GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE).addContainerGap()));
layout.setVerticalGroup(layout
.createParallelGroup(GroupLayout.Alignment.LEADING)
.addGroup(
layout.createSequentialGroup()
.addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.TRAILING)
.addGroup(
GroupLayout.Alignment.LEADING,
layout.createSequentialGroup()
.addContainerGap()
.addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.LEADING)
.addComponent(
dropsPanel,
GroupLayout.Alignment.TRAILING,
GroupLayout.DEFAULT_SIZE,
GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE)
.addComponent(
middleSeparator,
GroupLayout.DEFAULT_SIZE,
410,
Short.MAX_VALUE)))
.addGroup(
layout.createSequentialGroup()
.addGap(15, 15,
15)
.addComponent(
treeScroll)
.addPreferredGap(
LayoutStyle.ComponentPlacement.RELATED)
.addComponent(
addNewButton)
.addPreferredGap(
LayoutStyle.ComponentPlacement.RELATED)
.addComponent(
removeDrop)
.addPreferredGap(
LayoutStyle.ComponentPlacement.RELATED)
.addGroup(
layout.createParallelGroup(
GroupLayout.Alignment.TRAILING)
.addComponent(
searchIdLabel)
.addComponent(
searchField,
GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE))
.addPreferredGap(
LayoutStyle.ComponentPlacement.RELATED)
.addComponent(
progressBar,
GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE,
GroupLayout.PREFERRED_SIZE)))
.addContainerGap()));

pack();
}// </editor-fold>//GEN-END:initComponents

protected void testDropRate(ActionEvent arg0) {
ArrayList<Drop> drops = loader.getDropArray().get(
Integer.parseInt(dropsTree.getLastSelectedPathComponent().toString()));
Drop drop = drops.get(dropTable.getSelectedRow());
String testAmount = JOptionPane.showInputDialog(this, "Enter the amount of times you want to test(0 to test till it drops)");
int testAmt = 0;
try {
testAmt = Integer.parseInt(testAmount);
} catch (Exception e) {
testAmt = 0;
}
if (testAmt > 0) {
int successfullDrops = 0;
for (int i = 0; i < testAmt; i++) {
int chance = random.nextInt(100);
if (chance <= drop.getRate()) {
successfullDrops++;
}
}
JOptionPane.showMessageDialog(this, "Received the drop " + successfullDrops + " out of " + testAmt + " times");
} else {
boolean didntReceive = true;
int times = 0;
while (didntReceive) {
int chance = random.nextInt(100);
if (chance <= drop.getRate()) {
didntReceive = false;
} else {
times++;
}
}
JOptionPane.showMessageDialog(this, "Received the drop after "
+ times + " times");
}

}

protected void dumpSpecificDropMenuItemActionPerformed(ActionEvent evt) {
try {
//dump(Integer.parseInt(JOptionPane.showInputDialog(this, "Enter the NPC ID")));
} catch (Exception e) {
e.printStackTrace();
}
}

protected void dumpDropMenuItemActionPerformed(ActionEvent evt) {
Thread dumpThread = new Thread() {

int index = -1;

public void run() {
while (index < Utils.getNPCDefinitionsSize()) {
try {
progressBar.setString(NPCDefinitions.getNPCDefinitions(index).name);
//dump(index);
index++;
progressBar.setValue(index);
Thread.sleep(1);
} catch (Exception e) {
System.out.println("Problem with npc id " + index + ".");
index++;
progressBar.setValue(index);
}
}
packFile();
progressBar.setString("");
progressBar.setValue(-1);
}
};
dumpThread.start();
}

public DefaultMutableTreeNode searchNode(String nodeStr) {
DefaultMutableTreeNode nodeToSearch = null;
Enumeration<?> e = dropsNode.breadthFirstEnumeration();
while (e.hasMoreElements()) {
nodeToSearch = (DefaultMutableTreeNode) e.nextElement();
if (nodeStr.equals(nodeToSearch.getUserObject().toString())) {
return nodeToSearch;
}
}
return null;
}

private void searchFieldActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_searchFieldActionPerformed
try {
DefaultMutableTreeNode n = searchNode(searchField.getText());
TreePath path = new TreePath(dropsTreeModel.getPathToRoot(n));
dropsTree.scrollPathToVisible(path);
dropsTree.setSelectionPath(path);
} catch (Exception e) {
JOptionPane.showMessageDialog(this, "Could not find the item.");
}
}// GEN-LAST:event_searchFieldActionPerformed

private void dropsTreeValueChanged(TreeSelectionEvent evt) {// GEN-FIRST:event_dropsTreeValueChanged
if (dropsTree.getLastSelectedPathComponent() != null
&& !"Drops".equals(dropsTree.getLastSelectedPathComponent()
.toString())) {
loadDrop(Integer.parseInt(dropsTree.getLastSelectedPathComponent()
.toString()));
}
}// GEN-LAST:event_dropsTreeValueChanged

private void deleteSelectedActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_deleteSelectedActionPerformed
try {
int npcID = Integer.parseInt(dropsTree
.getLastSelectedPathComponent().toString());
ArrayList<Drop> drops = loader.getDropArray().get(npcID);
drops.remove(dropTable.getSelectedRow());
Drop[] d = new Drop[drops.size()];
drops.toArray(d);
loader.getDropMap().put(npcID, d);

loadDrop(Integer.parseInt(dropsTree.getLastSelectedPathComponent()
.toString()));
} catch (NullPointerException e) {
JOptionPane.showMessageDialog(this, "Please select a drop first!");
}
}// GEN-LAST:event_deleteSelectedActionPerformed

private void addNewActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_addNewActionPerformed
// try {
int npcid = Integer.parseInt(dropsTree.getLastSelectedPathComponent()
.toString());
// ArrayList<Drop> drops = loader.getDropArray().get(npcid);
loader.insertDrop(npcid, Drop.create(Integer.parseInt(JOptionPane
.showInputDialog("Please enter the item ID for this drop.")),
(int) 100.0, 1, 1, false));

loadDrop(npcid);
// } catch (NullPointerException e) {

// JOptionPane.showMessageDialog(this, "Please select a drop first!");
// }
}// GEN-LAST:event_addNewActionPerformed

private void addNewButtonActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_addNewButtonActionPerformed
String id = JOptionPane
.showInputDialog("Please enter the NPC ID for this drop.");
if (id == null) {
id = "0";
}
loader.getDropArray().put(Integer.parseInt(id), new ArrayList<Drop>());
packFile();
}// GEN-LAST:event_addNewButtonActionPerformed

private void removeDropActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_removeDropActionPerformed
try {
if (!dropsTree.getLastSelectedPathComponent().toString().equals("")) {
loader.getDropMap().remove(
Integer.parseInt(dropsTree
.getLastSelectedPathComponent().toString()));
packFile();
}
} catch (NullPointerException e) {
JOptionPane.showMessageDialog(this, "Please select a drop first!");
}
}// GEN-LAST:event_removeDropActionPerformed

private void repackDropActionPerformed(java.awt.event.ActionEvent evt) {// GEN-FIRST:event_repackDropActionPerformed
packFile();
}// GEN-LAST:event_repackDropActionPerformed

private void scanListActionPerformed(ActionEvent evt) {
System.out.println("Started Scanning.");

final int amountToFind = 100;

java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
for (Entry<Integer, ArrayList<Drop>> e : loader.getDropArray().entrySet()) {
int npcId = e.getKey();
for (Drop d : e.getValue()) {
if (d.getMinAmount()> amountToFind && d.getMaxAmount() > amountToFind) {
System.out.println("NPC Id:"+npcId+"");
System.out.println("Item Id: "+d.getItemId()+"");
System.out.println("Min Amount: "+Utils.formatNumber(d.getMinAmount())+"");
System.out.println("Max Amount: "+Utils.formatNumber(d.getMaxAmount())+"");
System.out.println("---------------------------------------------------------------------------------------");
}
}
}
System.out.println("Scanning Completed.");
}
});
}

/**
* [MENTION=75098]Para[/MENTION]m args
* the command line arguments
*/
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new DropEditor().setVisible(true);
}
});
}

// Variables declaration - do not modify//GEN-BEGIN:variables
private JButton addNew;
private JButton addNewButton;
private JButton deleteSelected;
private JTable dropTable;
private JLabel dropsForLabel;
private JPanel dropsPanel;
private JTree dropsTree;
private JMenuItem scan;
private JMenuItem dumpDropMenuItem;
private JMenuBar fileMenu;
private JSeparator headerSeparator;
private JMenu jMenu1;
private JSeparator middleSeparator;
private JLabel npcIdLabel;
private JButton removeDrop;
private JButton repackDrop;
private JButton scanButton;
private JTextField searchField;
private JLabel searchIdLabel;
private JScrollPane tableScroll;
private JScrollPane treeScroll;

// End of variables declaration//GEN-END:variables

private void loadDrop(final int npcId) {
npcIdLabel.setText(Integer.toString(npcId) + " " + NPCDefinitions.getNPCDefinitions(npcId).name);
ArrayList<Drop> drops = loader.getDropArray().get(npcId);
DefaultTableModel model = new DefaultTableModel();
model.addTableModelListener(new TableModelListener() {

public void tableChanged(TableModelEvent e) {
try {
if (e.getColumn() != -1) {
if (dropTable.getValueAt(dropTable.getSelectedRow(), 0).equals("Rare")) {
loader.getDropArray().get(npcId).get(dropTable.getSelectedRow()).setItemId((short) -1);
loader.getDropArray().get(npcId).get(dropTable.getSelectedRow()).setRate(-1);
loader.getDropArray().get(npcId).get(dropTable.getSelectedRow()).setMinAmount(1);
loader.getDropArray().get(npcId).get(dropTable.getSelectedRow()).setMaxAmount(1);

} else {
loader.getDropArray().get(npcId).get(dropTable.getSelectedRow()).setItemId(Short.parseShort((String) dropTable.getValueAt(dropTable.getSelectedRow(), 0).toString()));
loader.getDropArray().get(npcId).get(dropTable.getSelectedRow()).setRate(Double.parseDouble((String) dropTable.getValueAt(dropTable.getSelectedRow(),1).toString()));
String amount = (String) dropTable.getValueAt(dropTable.getSelectedRow(), 2);
if (amount.contains("-")) {
loader.getDropArray().get(npcId).get(dropTable.getSelectedRow()).setMinAmount(Integer.parseInt(amount.substring(0, amount.indexOf("-"))));
loader.getDropArray().get(npcId).get(dropTable.getSelectedRow()).setMaxAmount(Integer.parseInt(amount.substring(amount.indexOf("-") + 1)));
} else {
loader.getDropArray().get(npcId).get(dropTable.getSelectedRow()).setMinAmount(Integer.parseInt(amount));
loader.getDropArray().get(npcId).get(dropTable.getSelectedRow()).setMaxAmount(Integer.parseInt(amount));

}
}
}
} catch (Exception f) {
f.printStackTrace();
}
}
});
model.addColumn("Item ID");
model.addColumn("Percent Chance");
model.addColumn("Amount");
for (Drop d : drops) {
if (d == null) {
continue;
}
if (!d.isFromRareTable()) {
model.addRow(new Object[] { (d.getItemId()), Double.toString(d.getRate()), Integer.toString(d.getMinAmount()) + (d.getMinAmount() == d.getMaxAmount() || d.getMaxAmount() == 0 ? "" : "-" + d.getMaxAmount()) });
} else {
model.addRow(new Object[] { "Rare", "100.0", "1" });
}
}
dropTable.setModel(model);
}

private void packFile() {
try { // //drops.bin
RandomAccessFile raf = new RandomAccessFile("data/npcs/packedDrops.d", "rw");
raf.writeShort(loader.getDropMap().size());
for (Entry<Integer, ArrayList<Drop>> e : loader.getDropArray().entrySet()) {
raf.writeShort(e.getKey());
raf.writeShort(e.getValue().size());
for (Drop d : e.getValue()) {

raf.writeByte(d.isFromRareTable() ? 1 : 0);
if (!d.isFromRareTable()) {
int itemID = d.getItemId();
if (ItemDefinitions.getItemDefinitions(itemID).getName().equals("Coins")) {
itemID = 995;
}
raf.writeShort(itemID);
raf.writeDouble(d.getRate());
if (d.getMinAmount() > d.getMaxAmount()) {
int min = d.getMinAmount();
d.setMinAmount(d.getMaxAmount());
d.setMaxAmount(min);
}
raf.writeInt(d.getMinAmount());
raf.writeInt(d.getMaxAmount());
}
}
}
raf.close();
System.out.println("Repacking succesful!");
} catch (IOException ex) {
System.err.println(ex);
}
reload();
}

private void reload() {
dropsNode.removeAllChildren();
// loader = new NPCDropLoader();
// loader.load();
for (Entry<Integer, ArrayList<Drop>> s : loader.getDropArray()
.entrySet()) {
dropsNode.add(new DefaultMutableTreeNode(s.getKey()));
}
dropsTreeModel.reload(dropsNode);
}
}
[/CODE]

Share this post


Link to post
Share on other sites

0 answers to this question

Recommended Posts

There have been no answers to this question yet

Sign in to follow this  

×