API Repair

.run/headlessBotRun.run.xml

@@ -0,0 +1,13 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="headlessBotRun" type="Application" factoryName="Application">
+    <option name="ALTERNATIVE_JRE_PATH" value="17" />
+    <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="true" />
+    <option name="MAIN_CLASS_NAME" value="net.runelite.rsb.botLauncher.Application" />
+    <module name="OSRSBot.main" />
+    <option name="PROGRAM_PARAMETERS" value="--bot-runelite --headless --developer-mode" />
+    <option name="VM_PARAMETERS" value="-debug" />
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
+</component>

src/main/java/net/runelite/client/modified/RuneLite.java

@@ -135,7 +135,7 @@ public class RuneLite extends net.runelite.client.RuneLite {
      * @param args      The args for the program (plus any extras added on)
      * @throws Exception Any exception the client or RuneLite might throw
      */
-    public static void launch(String[] args) throws Exception {
+    public void launch(String[] args) throws Exception {
         Locale.setDefault(Locale.ENGLISH);
         OptionParser parser = new OptionParser();
         ArgumentAcceptingOptionSpec<?>[] optionSpecs = handleParsing(parser);

src/main/java/net/runelite/rsb/botLauncher/Application.java

@@ -10,15 +10,13 @@
 
 import java.io.File;
 import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Scanner;
+import java.util.*;
 
 @Slf4j
 public class Application {
 
 	static BotLiteInterface[] bots = new BotLiteInterface[]{};
-	static String[] programArgs = new String[]{};
+	static ArgumentPreParser preParser;
 
 	/**
 	 * Parses the command-line arguments and then passes the parsed arguments in the form of the parser, optionSpecs,
@@ -28,32 +26,11 @@ public class Application {
 	 * @throws Throwable	Any error that might be thrown
 	 */
 	public static void main(final String[] args) throws Throwable {
-		ArrayList<String> argList = new ArrayList<>(Arrays.asList(args));
-		if (argList.contains("--bot-runelite")) {
-			argList.remove("--bot-runelite");
-			programArgs = argList.toArray(new String[]{});
-			addBot(argList.contains("--headless"));
+		preParser = new ArgumentPreParser(args);
+		if (preParser.contains("--bot-runelite")) {
+			addBot(preParser.contains("--headless"));
 			checkForCacheAndLoad();
-				new Thread(() -> {
-					Scanner input = new Scanner(System.in);
-					while(input.hasNext()) {
-						String[] command = input.nextLine().split(" ");
-						System.out.println(Arrays.toString(command));
-						if (command[0].equalsIgnoreCase("runScript")) {
-							BotLiteInterface botInterface = Application.getBots()[Integer.parseInt(command[1])];
-							botInterface.runScript(command[2], command[3]);
-
-						}
-						if (command[0].equalsIgnoreCase("addBot")) {
-							addBot(true);
-						}
-						if (command[0].equalsIgnoreCase("checkState")) {
-							for (BotLiteInterface botInstance : bots) {
-								System.out.println(botInstance.getClass().getClassLoader());
-							}
-						}
-					}
-				}).start();
+			CLIHandler.handleCLI();
 		} else {
 			net.runelite.client.RuneLite.main(args);
 		}
@@ -98,8 +75,6 @@ private static void checkForCacheAndLoad() throws IOException {
 
 	public static void setBot(int index) {
 		BotLiteInterface bot = getBots()[index];
-
-
 	}
 
 	/**
@@ -125,30 +100,28 @@ public static BotLiteInterface getBot(Object o) {
 	 * @param headless To run the bot headless or not
 	 */
 	public static void addBot(boolean headless) {
-		BotLiteInterface bot;
-		String[] args = new String[programArgs.length + 1];
-		if (headless) {
-			System.arraycopy(programArgs, 0, args, 0, programArgs.length);
-			args[programArgs.length] = "--headless";
-		}
-		else {
-			args = programArgs;
-		}
-		BotClassLoader loader = new BotClassLoader("BotLoader" + bots.length);
-		// Class<?> c;
+		BotLiteInterface bot = null;
+
 		try {
-			// c = loader.loadClass("net.runelite.client.modified.RuneLite");
-			// bot = (BotLiteInterface) c.getConstructor().newInstance();
-			BotLite.launch(args);
-			BotLiteInterface[] update = new BotLiteInterface[bots.length + 1];
-			for (int i = 0; i < bots.length; i++) {
-				update[i] = bots[i];
+			if (headless) {
+				preParser.add("--headless");
+				BotClassLoader loader = new BotClassLoader("BotLoader" + bots.length + 1);
+				Class<?> c;
+				c = loader.loadClass("net.runelite.rsb.botLauncher.BotLite");
+				bot = (BotLiteInterface) c.getConstructor().newInstance();
+			} else {
+				preParser.remove("--headless");
+				bot = new BotLite();
 			}
-			update[bots.length] = BotLite.getInjector().getInstance(BotLite.class);
-			bots = update;
+			bot.launch(preParser.asArgs());
 		} catch (Exception e) {
 			log.error("Error while starting bot", e);
 		}
+
+		BotLiteInterface[] update = new BotLiteInterface[bots.length + 1];
+		System.arraycopy(bots, 0, update, 0, bots.length);
+		update[bots.length] = bot;
+		bots = update;
 	}
 
 	/**
@@ -159,4 +132,41 @@ public static BotLiteInterface[] getBots() {
 		return bots;
 	}
 
+	/**
+	 * A class to handle bot related arguments before passing them off to RuneLite
+	 */
+	private static class ArgumentPreParser extends ArrayList<String> {
+
+		/**
+		 * Creates a handler for the arguments before they're sent off to build the bot instance of RuneLite
+		 * @param args			The command line arguments for the program
+		 */
+		public ArgumentPreParser(String[] args) {
+			super(List.of(args));
+		}
+
+		/**
+		 * Returns the program argument ArrayList as a built-in array
+		 * @return	a built-in String array containing program arguments
+		 */
+		public String[] asArgs() {
+			return this.toArray(new String[0]);
+		}
+
+		/**
+		 * Modifies the contains function to remove elements upon checking if they exist within, but return the whether
+		 * they did before-hand.
+		 * As CLI args for the bot will be used once this will only pass to RuneLite arguments meant for it.
+		 */
+		@Override
+		public boolean contains(Object o) {
+			int index = indexOf(o);
+			boolean within = index >= 0;
+			if (within)
+				this.remove(index);
+			return within;
+		}
+
+	}
+
 }

src/main/java/net/runelite/rsb/botLauncher/BotClassLoader.java

@@ -4,10 +4,7 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URL;
-import java.util.Enumeration;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
+import java.util.*;
 
 public class BotClassLoader extends ClassLoader {
 
@@ -57,7 +54,7 @@ public Class<?> findClass(String name) throws ClassNotFoundException
             Class<?> loaded = realParent.findLoaded(name);
             if( loaded != null )
                 return realParent.findClass(name);
-            if (name.contains("java.")) {
+            if (name.startsWith("java.")) {
                 return ClassLoader.getPlatformClassLoader().loadClass(name);
             }
             try {

src/main/java/net/runelite/rsb/botLauncher/BotLite.java

@@ -302,33 +302,28 @@ public void init(boolean startClientBare) throws Exception {
 
     public BotLite() throws Exception {
         im = new InputManager(this);
-        Executors.newSingleThreadScheduledExecutor().submit(() -> {
-            while(this.getClient() == null){}
-            if (getPanelSize() != null) {
-                final Dimension size = getPanelSize();
-                backBuffer = new BufferedImage(size.width, size.height, BufferedImage.TYPE_INT_RGB);
-                image = new BufferedImage(size.width, size.height, BufferedImage.TYPE_INT_RGB);
-            }
-        });
         psh = new PassiveScriptHandler(this);
         eventManager = new EventManager();
         sh = new ScriptHandler(this);
         bh = new BreakHandler(this);
         paintEvent = new PaintEvent();
         textPaintEvent = new TextPaintEvent();
         listeners = new TreeMap<>();
-        // Botplugin botplugin = new Botplugin(injector);
-        // pluginManager.add(botplugin);
-        setMethodContext();
-
         eventManager.start();
-
-
+        Executors.newSingleThreadScheduledExecutor().submit(() -> {
+            while(this.getClient() == null){}
+            setMethodContext();
+            sh.init();
+            if (getPanelSize() != null) {
+                final Dimension size = getPanelSize();
+                backBuffer = new BufferedImage(size.width, size.height, BufferedImage.TYPE_INT_RGB);
+                image = new BufferedImage(size.width, size.height, BufferedImage.TYPE_INT_RGB);
+            }
+        });
     }
 
     public void runScript(String account, String scriptName) {
         getInjectorInstance().setAccount(account);
-        System.out.println(getInjectorInstance().getAccountName());
         ScriptSelector ss = new ScriptSelector(getInjectorInstance());
         ss.load();
         ScriptDefinition def = ss.getScripts().stream().filter(x -> x.name.replace(" ", "").equals(scriptName)).findFirst().get();
@@ -339,4 +334,8 @@ public void runScript(String account, String scriptName) {
         }
     }
 
+    public void stopScript() {
+        sh.stopScript();
+    }
+
 }

src/main/java/net/runelite/rsb/botLauncher/BotLiteInterface.java

@@ -4,7 +4,9 @@ public interface BotLiteInterface {
 
     void runScript(String account, String scriptName);
 
-    // void launch(String[]s) throws Exception;
+    void stopScript();
+
+    void launch(String[] args) throws Exception;
 
     void init(boolean startClientBare) throws Exception;
 

src/main/java/net/runelite/rsb/botLauncher/CLIHandler.java

@@ -0,0 +1,56 @@
+package net.runelite.rsb.botLauncher;
+
+import java.util.Arrays;
+import java.util.Scanner;
+import java.util.Set;
+
+import static net.runelite.rsb.botLauncher.Application.*;
+
+public class CLIHandler {
+
+    /**
+     * Starts a new thread which handles the command line arguments passed while the program is running.
+     * The switch case provides an easy-to-read implementation in which commands are available for usage.
+     */
+    public static void handleCLI() {
+        Scanner input = new Scanner(System.in);
+        new Thread(() -> {
+            while(input.hasNext()) {
+                BotLiteInterface botInterface;
+                String[] command = input.nextLine().split(" ");
+                System.out.println(Arrays.toString(command));
+                switch (command[0].toLowerCase()) {
+                    case "runscript":
+                        botInterface = Application.getBots()[Integer.parseInt(command[1])];
+                        botInterface.runScript(command[2], command[3]);
+                        break;
+                    case "stopscript":
+                        botInterface = Application.getBots()[Integer.parseInt(command[1])];
+                        botInterface.stopScript();
+                        break;
+                    case "addbot":
+                        addBot(false);
+                        break;
+                    case "checkstate":
+                        for (BotLiteInterface botInstance : bots) {
+                            System.out.println(Application.class.getClassLoader());
+                            System.out.println(botInstance.getClass().getClassLoader());
+                            /*
+                            Set<Thread> threadSet
+                                    = Thread.getAllStackTraces().keySet();
+                            // iterating over the threads to get the names of
+                            // all the active threads
+                            for (Thread x : threadSet) {
+                                System.out.println(x.getName());
+                            }
+                             */
+                        }
+                        break;
+                    default:
+                        System.out.println("Invalid command");
+                        break;
+                }
+            }
+        }).start();
+    }
+}

src/main/java/net/runelite/rsb/plugin/ScriptSelector.java

@@ -173,12 +173,10 @@ public void load() {
 		scripts.clear();
 		File testFile = new File(GlobalConfiguration.Paths.getScriptsSourcesDirectory());
 		FileScriptSource test = new FileScriptSource(testFile);
-		test.list().forEach(System.out::println);
 		deleteTemporaryFiles();
 		scripts.addAll(SRC_BUNDLED.list());
 		scripts.addAll(SRC_PRECOMPILED.list());
 		scripts.addAll(SRC_SOURCES.list());
-		scripts.forEach(System.out::println);
 		//generateTestScripts();
 		//scripts.addAll(SRC_TEST.list());
 		if (search != null)

src/main/java/net/runelite/rsb/service/FileScriptSource.java

@@ -57,10 +57,9 @@ public List<ScriptDefinition> list() {
 
 
 	public Script load(ScriptDefinition def) throws ServiceException {
-		if (!(def instanceof FileScriptDefinition)) {
+		if (!(def instanceof FileScriptDefinition fsd)) {
 			throw new IllegalArgumentException("Invalid definition!");
 		}
-		FileScriptDefinition fsd = (FileScriptDefinition) def;
 		try {
 			return fsd.clazz.asSubclass(Script.class).newInstance();
 		} catch (Exception ex) {
@@ -84,15 +83,11 @@ private void load(ClassLoader loader, LinkedList<ScriptDefinition> scripts, File
 		if (file.isDirectory()) {
 			if (!file.getName().startsWith(".")) {
 				for (File f : file.listFiles()) {
-					System.out.println("TEST1");
-					System.out.println(file.toURI());
 					load(loader, scripts, f, prefix + file.getName() + ".");
 				}
 			}
 		} else {
 			String name = prefix + file.getName();
-			System.out.println("TEST2");
-			System.out.println(file.toURI());
 			String ext = ".class";
 			if (name.endsWith(ext) && !name.startsWith(".") && !name.contains("!") && !name.contains("$")) {
 				name = name.substring(0, name.length() - ext.length());

src/main/java/net/runelite/rsb/service/ScriptClassLoader.java

@@ -5,16 +5,17 @@
 import java.io.InputStream;
 import java.net.MalformedURLException;
 import java.net.URL;
-import java.util.*;
+import java.net.URLClassLoader;
 
 /**
  * @author GigiaJ
  */
-class ScriptClassLoader extends ClassLoader {
+class ScriptClassLoader extends URLClassLoader {
 
 	private final URL base;
 
 	public ScriptClassLoader(URL url) {
+		super(new URL[]{url}, ScriptClassLoader.class.getClassLoader());
 		this.base = url;
 	}