From 18bc7b7070fcf7b0ede780445770c7707378dc11 Mon Sep 17 00:00:00 2001 From: Eric-Turner Date: Wed, 18 May 2016 06:13:18 -0400 Subject: [PATCH] Added cache removal menu option --- BotUI.java | 314 +++++++++++++++++++++++++++++++++++++++++++ Context.java | 372 +++++++++++++++++++++++++++++++++++++++++++++++++++ trash.png | Bin 0 -> 3615 bytes 3 files changed, 686 insertions(+) create mode 100644 BotUI.java create mode 100644 Context.java create mode 100644 trash.png diff --git a/BotUI.java b/BotUI.java new file mode 100644 index 0000000..7b170da --- /dev/null +++ b/BotUI.java @@ -0,0 +1,314 @@ +package org.parabot.core.ui; + +import org.parabot.core.Context; +import org.parabot.core.ui.components.GamePanel; +import org.parabot.core.ui.components.VerboseLoader; +import org.parabot.core.ui.images.Images; +import org.parabot.core.ui.utils.SwingUtil; +import org.parabot.environment.OperatingSystem; +import org.parabot.environment.scripts.Script; +import org.parabot.environment.scripts.randoms.Random; + +import javax.swing.*; +import java.awt.*; +import java.awt.event.*; +import java.io.File; +import java.util.ArrayList; + +/** + * The bot user interface + * + * @author Dane, Everel, Paradox + */ +public class BotUI extends JFrame implements ActionListener, ComponentListener, WindowListener { + + private static final long serialVersionUID = -2126184292879805519L; + private static BotUI instance; + private static JDialog dialog; + + private JMenuItem run, pause, stop, cacheClear; + private boolean runScript, pauseScript; + + public BotUI(String username, String password) { + if (instance != null) { + throw new IllegalStateException("BotUI already created"); + } + instance = this; + //WebLookAndFeel.install(); + JPopupMenu.setDefaultLightWeightPopupEnabled(false); + + setTitle("Parabot"); + setResizable(false); + setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); + createMenu(); + + setLayout(new BorderLayout()); + addComponentListener(this); + addWindowListener(this); + + add(GamePanel.getInstance()); + GamePanel.getInstance().add(VerboseLoader.get(username, password), BorderLayout.CENTER); + add(Logger.getInstance(), BorderLayout.SOUTH); + + SwingUtil.setParabotIcons(this); + + pack(); + setLocationRelativeTo(null); + BotDialog.getInstance(this); + + if (!OperatingSystem.getOS().equals(OperatingSystem.WINDOWS)) { + BotDialog.getInstance().setVisible(false); + } + } + + public static BotUI getInstance() { + return instance; + } + + public static boolean deleteDirectory(File directory) { + if (directory.exists()) { + File[] files = directory.listFiles(); + if (files != null) { + for (int i = 0; i < files.length; i++) { + if (files[i].isDirectory()) { + deleteDirectory(files[i]); + } else { + files[i].delete(); + } + } + } + } + return (directory.delete()); + } + + public static void createDirectory(File directory) { + if (!directory.exists()) { + directory.mkdir(); + } + } + + private void createMenu() { + JMenuBar menuBar = new JMenuBar(); + + JMenu file = new JMenu("File"); + JMenu scripts = new JMenu("Script"); + JMenu features = new JMenu("Features"); + + JMenuItem screenshot = new JMenuItem("Create screenshot"); + JMenuItem proxy = new JMenuItem("Network"); + JMenuItem randoms = new JMenuItem("Randoms"); + JMenuItem dialog = new JCheckBoxMenuItem("Disable dialog"); + JMenuItem logger = new JCheckBoxMenuItem("Logger"); + + if (!OperatingSystem.getOS().equals(OperatingSystem.WINDOWS)) { + dialog.setSelected(true); + } + + JMenuItem explorer = new JMenuItem("Reflection explorer"); + JMenuItem exit = new JMenuItem("Exit"); + + run = new JMenuItem("Run"); + run.setIcon(new ImageIcon(Images.getResource("/storage/images/run.png"))); + + pause = new JMenuItem("Pause"); + pause.setEnabled(false); + pause.setIcon(new ImageIcon(Images.getResource("/storage/images/pause.png"))); + + stop = new JMenuItem("Stop"); + stop.setEnabled(false); + stop.setIcon(new ImageIcon(Images.getResource("/storage/images/stop.png"))); + + cacheClear = new JMenuItem("Clear cache"); + cacheClear.setIcon(new ImageIcon(Images.getResource("/storage/images/trash.png"))); + + screenshot.addActionListener(this); + proxy.addActionListener(this); + randoms.addActionListener(this); + dialog.addActionListener(this); + logger.addActionListener(this); + explorer.addActionListener(this); + exit.addActionListener(this); + cacheClear.addActionListener(this); + + run.addActionListener(this); + pause.addActionListener(this); + stop.addActionListener(this); + + file.add(screenshot); + file.add(proxy); + file.add(randoms); + file.add(dialog); + file.add(logger); + file.add(explorer); + file.add(exit); + + scripts.add(run); + scripts.add(pause); + scripts.add(stop); + + features.add(cacheClear); + + menuBar.add(file); + menuBar.add(scripts); + menuBar.add(features); + + + setJMenuBar(menuBar); + } + + @Override + public void actionPerformed(ActionEvent e) { + String command = e.getActionCommand(); + + switch (command) { + case "Create screenshot": + JOptionPane.showMessageDialog(this, "We are still working on this..."); + break; + case "Exit": + System.exit(0); + break; + case "Network": + NetworkUI.getInstance().setVisible(true); + break; + case "Randoms": + ArrayList randoms = new ArrayList<>(); + for (Random r : Context.getInstance().getRandomHandler().getRandoms()) { + randoms.add(r.getName()); + } + RandomUI.getInstance().openFrame(randoms); + break; + case "Reflection explorer": + new ReflectUI().setVisible(true); + break; + case "Run": + if (pauseScript) { + pauseScript = false; + pause.setEnabled(true); + run.setEnabled(false); + setScriptState(Script.STATE_RUNNING); + break; + } + new ScriptSelector().setVisible(true); + break; + case "Pause": + setScriptState(Script.STATE_PAUSE); + pause.setEnabled(false); + run.setEnabled(true); + pauseScript = true; + break; + case "Stop": + setScriptState(Script.STATE_STOPPED); + break; + case "Logger": + Logger.getInstance().setVisible(!Logger.getInstance().isVisible()); + BotUI.getInstance().pack(); + BotUI.getInstance().revalidate(); + if (!Logger.getInstance().isClearable()) { + Logger.getInstance().setClearable(); + } else if (Logger.getInstance().isClearable() && !Logger.getInstance().isVisible()) { + Logger.clearLogger(); + Logger.addMessage("Logger started", false); + } + break; + case "Disable dialog": + BotDialog.getInstance().setVisible(!dialog.isVisible()); + break; + case "Clear cache": + deleteDirectory(new File("C:/Users/Eric/Documents/Parabot/cache")); + createDirectory(new File("C:/Users/Eric/Documents/Parabot/cache")); + break; + default: + System.out.println("Invalid command: " + command); + } + } + + protected void setDialog(JDialog dialog) { + BotUI.dialog = dialog; + } + + @Override + public void componentMoved(ComponentEvent e) { + if (dialog == null || !isVisible()) { + return; + } + Point gameLocation = GamePanel.getInstance().getLocationOnScreen(); + dialog.setLocation(gameLocation.x, gameLocation.y); + } + + public void toggleRun() { + runScript = !runScript; + if (runScript) { + scriptRunning(); + } else { + scriptStopped(); + } + } + + private void scriptRunning() { + run.setEnabled(false); + pause.setEnabled(true); + stop.setEnabled(true); + } + + private void scriptStopped() { + run.setEnabled(true); + pause.setEnabled(false); + stop.setEnabled(false); + } + + private void setScriptState(int state) { + if (Context.getInstance().getRunningScript() != null) { + Context.getInstance().getRunningScript().setState(state); + } + } + + @Override + public void componentResized(ComponentEvent e) { + if (isVisible()) { + BotDialog.getInstance().setSize(getSize()); + } + } + + @Override + public void componentShown(ComponentEvent e) { + } + + @Override + public void componentHidden(ComponentEvent e) { + } + + @Override + public void windowActivated(WindowEvent arg0) { + } + + @Override + public void windowClosed(WindowEvent arg0) { + } + + @Override + public void windowClosing(WindowEvent e) { + } + + @Override + public void windowDeactivated(WindowEvent arg0) { + + } + + @Override + public void windowDeiconified(WindowEvent arg0) { + if (isVisible()) { + BotDialog.getInstance().setVisible(false); + BotDialog.getInstance().setVisible(true); + } + } + + @Override + public void windowIconified(WindowEvent arg0) { + + } + + @Override + public void windowOpened(WindowEvent arg0) { + } + +} diff --git a/Context.java b/Context.java new file mode 100644 index 0000000..532955c --- /dev/null +++ b/Context.java @@ -0,0 +1,372 @@ +package org.parabot.core; + +import org.json.simple.parser.JSONParser; +import org.parabot.core.asm.ASMClassLoader; +import org.parabot.core.classpath.ClassPath; +import org.parabot.core.desc.ServerProviderInfo; +import org.parabot.core.paint.PaintDebugger; +import org.parabot.core.parsers.hooks.HookParser; +import org.parabot.core.ui.BotDialog; +import org.parabot.core.ui.BotUI; +import org.parabot.core.ui.components.GamePanel; +import org.parabot.environment.api.interfaces.Paintable; +import org.parabot.environment.input.Keyboard; +import org.parabot.environment.input.Mouse; +import org.parabot.environment.scripts.Script; +import org.parabot.environment.scripts.randoms.RandomHandler; +import org.parabot.environment.scripts.uliratha.UlirathaClient; +import org.parabot.environment.servers.ServerProvider; + +import java.applet.Applet; +import java.awt.*; +import java.io.File; +import java.io.PrintStream; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.TimerTask; + +/** + * Game context + * + * @author Everel, JKetelaar, Matt + */ +public class Context { + public static final HashMap threadGroups = new HashMap(); + private static ArrayList paintables = new ArrayList(); + + private static Context instance; + private static String username; + + private ASMClassLoader classLoader; + private ClassPath classPath; + private ServerProvider serverProvider; + private Applet gameApplet; + private HookParser hookParser; + private Script runningScript; + private RandomHandler randomHandler; + private Object clientInstance; + private PaintDebugger paintDebugger; + private Mouse mouse; + private Keyboard keyboard; + private ServerProviderInfo providerInfo; + private UlirathaClient ulirathaClient; + private JSONParser jsonParser; + + private PrintStream defaultOut; + private PrintStream defaultErr = System.err; + + private Context(final ServerProvider serverProvider) { + threadGroups.put(Thread.currentThread().getThreadGroup(), this); + + System.setProperty("sun.java.command", ""); + this.serverProvider = serverProvider; + this.paintDebugger = new PaintDebugger(); + this.classPath = new ClassPath(); + this.classLoader = new ASMClassLoader(classPath); + this.randomHandler = new RandomHandler(); + + this.jsonParser = new JSONParser(); + + this.defaultOut = System.out; + this.defaultErr = System.err; + } + + public static Context getInstance(ServerProvider serverProvider) { + return instance == null ? instance = new Context(serverProvider) : instance; + } + + public static Context getInstance() { + return getInstance(null); + } + + /** + * Sets the main client instance + */ + public void setClientInstance(Object object) { + this.clientInstance = object; + } + + /** + * Sets the hook parser + * + * @param hookParser + */ + public void setHookParser(final HookParser hookParser) { + this.hookParser = hookParser; + } + + /** + * Sets the mouse + * + * @param mouse + */ + public void setMouse(final Mouse mouse) { + this.mouse = mouse; + } + + /** + * Gets the mouse + * + * @return mouse + */ + public Mouse getMouse() { + return mouse; + } + + + /** + * Sets the keyboard + * + * @param keyboard + */ + public void setKeyboard(final Keyboard keyboard) { + this.keyboard = keyboard; + } + + /** + * Gets the keyboard + * + * @return keyboard + */ + public Keyboard getKeyboard() { + return keyboard; + } + + /** + * ClassPath + * + * @return classpath + */ + public ClassPath getClassPath() { + return classPath; + } + + /** + * Determines if applet has been set + * + * @return true if set + */ + public boolean appletSet() { + return gameApplet != null; + } + + /** + * Gets game applet + * + * @return applet + */ + public Applet getApplet() { + return gameApplet; + } + + /** + * Loads the game + */ + public void load() { + BotUI.getInstance().getJMenuBar().remove(2); + Core.verbose("Parsing server jar..."); + serverProvider.init(); + serverProvider.parseJar(); + Core.verbose("Done."); + Core.verbose("Injecting hooks..."); + serverProvider.injectHooks(); + Core.verbose("Done."); + Core.verbose("Fetching game applet..."); + if(Core.shouldDump()) { + Core.verbose("Dumping injected client..."); + classPath.dump(new File(Directories.getWorkspace(), "dump.jar")); + Core.verbose("Done."); + } + Applet applet = serverProvider.fetchApplet(); + // if applet is null the server provider will call setApplet itself + if(applet != null) { + setApplet(applet); + } + } + + /** + * Sets the bot target applet + * @param applet + */ + public void setApplet(final Applet applet) { + gameApplet = applet; + + if (getClient() == null) { + setClientInstance(gameApplet); + } + + Core.verbose("Applet fetched."); + + final GamePanel panel = GamePanel.getInstance(); + final Dimension appletSize = serverProvider.getGameDimensions(); + + panel.setPreferredSize(appletSize); + serverProvider.addMenuItems(BotUI.getInstance().getJMenuBar()); + BotUI.getInstance().pack(); + BotUI.getInstance().validate(); + + panel.removeComponents(); + gameApplet.setSize(appletSize); + panel.add(gameApplet); + panel.validate(); + + gameApplet.init(); + gameApplet.start(); + + java.util.Timer t = new java.util.Timer(); + t.schedule(new TimerTask() { + @Override + public void run() { + gameApplet.setBounds(0, 0, appletSize.width, appletSize.height); + } + }, 1000); + + Core.verbose("Initializing mouse..."); + serverProvider.initMouse(); + Core.verbose("Done."); + Core.verbose("Initializing keyboard..."); + serverProvider.initKeyboard(); + Core.verbose("Done."); + + BotDialog.getInstance().validate(); + System.setOut(this.defaultOut); + System.setErr(this.defaultErr); + } + + /** + * Gets the server prodiver belonging to this context + * + * @return server provider + */ + public ServerProvider getServerProvider() { + return serverProvider; + } + + /** + * + * Sets provider info of this context + * + * @param providerInfo + */ + public void setProviderInfo(ServerProviderInfo providerInfo) { + this.providerInfo = providerInfo; + } + + /** + * Gets ServerProvider info + * Can be null if this is not a public server provider + * @return info about this provider + */ + public ServerProviderInfo getServerProviderInfo() { + return this.providerInfo; + } + + /** + * Gets class loader of server from this context + * + * @return class loader + */ + public ASMClassLoader getASMClassLoader() { + return classLoader; + } + + /** + * Adds a paintable instance to the paintables + * + * @param paintable + */ + public void addPaintable(Paintable paintable) { + paintables.add(paintable); + } + + /** + * Removes a paintable instance from the paintables + * + * @param paintable + */ + public void removePaintable(Paintable paintable) { + paintables.remove(paintable); + } + + /** + * Gets the paintable instances + * + * @return array of paintable instances + */ + public Paintable[] getPaintables() { + return paintables.toArray(new Paintable[paintables.size()]); + } + + /** + * The client debug painter + * + * @return debug painter + */ + public PaintDebugger getPaintDebugger() { + return paintDebugger; + } + + /** + * Gets the main/client instance + * + * @return instance of the the client + */ + public Object getClient() { + return this.clientInstance; + } + + /** + * Gets the hook parser, may be null if injection is not used or a custom hook parser is used for injecting + * + * @return hook parser + */ + public HookParser getHookParser() { + return hookParser; + } + + /** + * Sets the current running script, if a script stops it will call this method with a null argument + * + * @param script + */ + public void setRunningScript(final Script script) { + this.runningScript = script; + } + + /** + * Gets the current running script + * + * @return script + */ + public Script getRunningScript() { + return this.runningScript; + } + + /** + * Gets the random handler + * @return random handler + */ + public RandomHandler getRandomHandler() { + return this.randomHandler; + } + + public static String getUsername() { + return username; + } + + public UlirathaClient getUlirathaClient() { + return ulirathaClient; + } + + public void setUlirathaClient(UlirathaClient ulirathaClient) { + this.ulirathaClient = ulirathaClient; + } + + public static void setUsername(String username) { + Context.username = username; + } + + public JSONParser getJsonParser() { + return jsonParser; + } +} diff --git a/trash.png b/trash.png new file mode 100644 index 0000000000000000000000000000000000000000..53867b6548c245ee1d6b52ba1696eb075a313081 GIT binary patch literal 3615 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 literal 0 HcmV?d00001