[!] [FEATURE] Added new Random system, to have different type of Randoms

This is a breaking change for old randoms

Related to issue #144

src/main/java/org/parabot/core/Context.java

@@ -14,8 +14,8 @@ import org.parabot.core.ui.listeners.PBKeyListener;
 import org.parabot.environment.api.interfaces.Paintable;
 import org.parabot.environment.input.Keyboard;
 import org.parabot.environment.input.Mouse;
+import org.parabot.environment.randoms.RandomHandler;
 import org.parabot.environment.scripts.Script;
-import org.parabot.environment.scripts.randoms.RandomHandler;
 import org.parabot.environment.servers.ServerProvider;
 
 import java.applet.Applet;

src/main/java/org/parabot/core/ui/BotUI.java

@@ -6,12 +6,11 @@ import org.parabot.core.Directories;
 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.listeners.PBKeyListener;
 import org.parabot.core.ui.utils.SwingUtil;
 import org.parabot.environment.OperatingSystem;
 import org.parabot.environment.api.utils.StringUtils;
+import org.parabot.environment.randoms.Random;
 import org.parabot.environment.scripts.Script;
-import org.parabot.environment.scripts.randoms.Random;
 
 import javax.imageio.ImageIO;
 import javax.swing.*;

src/main/java/org/parabot/core/ui/RandomUI.java

@@ -2,7 +2,7 @@ package org.parabot.core.ui;
 
 import org.parabot.core.Context;
 import org.parabot.core.Core;
-import org.parabot.environment.scripts.randoms.Random;
+import org.parabot.environment.randoms.Random;
 
 import javax.swing.*;
 import java.awt.event.ActionEvent;

src/main/java/org/parabot/environment/randoms/Random.java

@@ -0,0 +1,41 @@
+package org.parabot.environment.randoms;
+
+/**
+ * @author JKetelaar
+ */
+public interface Random {
+
+    /**
+     * Determines whether this random should activate
+     *
+     * @return <b>true</b> if this random should be activate
+     */
+    public boolean activate();
+
+    /**
+     * Executes this random
+     */
+    public void execute();
+
+    /**
+     * Returns the name of the random
+     *
+     * @return Name of the random
+     */
+    public String getName();
+
+    /**
+     * Returns the name of the server which the random is made for
+     *
+     * @return Name of the server
+     */
+    public String getServer();
+
+    /**
+     * Returns the RandomType of the random
+     *
+     * @return The RandomType of the random
+     */
+    public RandomType getRandomType();
+
+}

src/main/java/org/parabot/environment/randoms/RandomHandler.java

@@ -0,0 +1,140 @@
+package org.parabot.environment.randoms;
+
+import com.sun.javaws.exceptions.InvalidArgumentException;
+import org.parabot.core.Core;
+import org.parabot.core.parsers.randoms.RandomParser;
+import org.parabot.core.ui.Logger;
+
+import java.util.ArrayList;
+
+/**
+ * @author JKetelaar
+ */
+public class RandomHandler {
+    private ArrayList<Random> randoms;
+
+    /**
+     * The randoms that will actually run
+     */
+    private ArrayList<Random> activeRandoms;
+
+    public RandomHandler() {
+        this.randoms = new ArrayList<>();
+        this.activeRandoms = new ArrayList<>();
+    }
+
+    public void init() {
+        RandomParser.enable();
+        checkAndRun(RandomType.ON_SERVER_START);
+    }
+
+    /**
+     * Adds a random to the random list
+     *
+     * @param random The random that will be added to the arraylist
+     */
+    public void addRandom(Random random) {
+        if (random == null) {
+            throw new NullPointerException("Null random");
+        }
+        for (Random r : randoms) {
+            if (r.getClass() == random.getClass()) {
+                Core.verbose("Ignored added random, duplicate.");
+                return;
+            }
+        }
+        randoms.add(random);
+        setActive(random);
+    }
+
+    /**
+     * @param random
+     * @deprecated
+     */
+    @Deprecated
+    public void addRandom(org.parabot.environment.scripts.randoms.Random random) {
+        new InvalidArgumentException(new String[]{"This type of random is deprecated"}).printStackTrace();
+    }
+
+    /**
+     * Adds a random to the active randoms
+     *
+     * @param random
+     */
+    public void setActive(Random random) {
+        this.activeRandoms.add(random);
+    }
+
+    /**
+     * Adds a random to the active randoms
+     *
+     * @param random
+     */
+    public void setActive(String random) {
+        for (Random r : this.randoms) {
+            if (r.getName().equalsIgnoreCase(random.toLowerCase())) {
+                this.activeRandoms.add(r);
+            }
+        }
+    }
+
+    /**
+     * Sets the whole random arraylist to the arraylist given as argument
+     *
+     * @param randoms The new random arraylist
+     */
+    public void setRandoms(ArrayList<Random> randoms) {
+        this.randoms = randoms;
+    }
+
+    /**
+     * Clears all added randoms
+     */
+    public void clearRandoms() {
+        this.randoms.clear();
+    }
+
+    /**
+     * Clears all active randoms
+     */
+    public void clearActiveRandoms() {
+        this.activeRandoms.clear();
+    }
+
+    /**
+     * Checks if random occurs and runs it
+     *
+     * @return returns <b>true</b> if a random has been executed, otherwise <b>false</b>
+     */
+    public boolean checkAndRun(RandomType type) {
+        for (Random r : this.activeRandoms) {
+            if (r.getRandomType().getId() == type.getId() && r.activate()) {
+                Logger.addMessage("Running random '" + r.getName() + "'", true);
+                r.execute();
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Checks if random occurs and runs it
+     *
+     * @return returns <b>true</b> if a random has been executed, otherwise <b>false</b>
+     * @see RandomHandler#checkAndRun(RandomType)
+     * @deprecated
+     */
+    @Deprecated
+    public boolean checkAndRun() {
+        new InvalidArgumentException(new String[]{"This method is deprecated"}).printStackTrace();
+        return false;
+    }
+
+    public ArrayList<Random> getRandoms() {
+        return this.randoms;
+    }
+
+    public ArrayList<Random> getActiveRandoms() {
+        return this.activeRandoms;
+    }
+}

src/main/java/org/parabot/environment/randoms/RandomType.java

@@ -0,0 +1,32 @@
+package org.parabot.environment.randoms;
+
+/**
+ * @author JKetelaar
+ */
+public enum RandomType {
+
+    SCRIPT(0, "Script"),
+    ON_SCRIPT_START(0, "On script start"),
+    ON_SERVER_START(0, "On server start"),
+    ON_SCRIPT_FINISH(0, "On script finish");
+
+    private int id;
+    private String name;
+
+    RandomType(int id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public static RandomType getDefault() {
+        return SCRIPT;
+    }
+}

src/main/java/org/parabot/environment/scripts/Script.java

@@ -6,6 +6,7 @@ import org.parabot.core.ui.BotUI;
 import org.parabot.core.ui.Logger;
 import org.parabot.environment.api.utils.PBPreferences;
 import org.parabot.environment.api.utils.Time;
+import org.parabot.environment.randoms.RandomType;
 import org.parabot.environment.scripts.framework.*;
 import org.parabot.environment.scripts.framework.Frameworks;
 import org.parabot.environment.scripts.randoms.Random;
@@ -13,170 +14,173 @@ import org.parabot.environment.scripts.randoms.Random;
 import java.util.Collection;
 
 /**
- *
  * Script template, scripts are 'add-ons' which executes various tasks in-game
  *
  * @author Everel
- *
  */
 public class Script implements Runnable {
-	public static final int TYPE_STRATEGY = 0;
+    public static final int TYPE_STRATEGY = 0;
-	public static final int TYPE_LOOP = 1;
+    public static final int TYPE_LOOP = 1;
-	public static final int TYPE_OTHER = 2;
+    public static final int TYPE_OTHER = 2;
 
-	public static final int STATE_RUNNING = 0;
+    public static final int STATE_RUNNING = 0;
-	public static final int STATE_PAUSE = 1;
+    public static final int STATE_PAUSE = 1;
-	public static final int STATE_STOPPED = 2;
+    public static final int STATE_STOPPED = 2;
 
-	private Collection<Strategy> strategies;
+    private Collection<Strategy> strategies;
-	private PBPreferences preferences;
+    private PBPreferences preferences;
-	private AbstractFramework frameWork;
+    private AbstractFramework frameWork;
-	private int state;
+    private int state;
-	private int frameWorkType;
+    private int frameWorkType;
-	private int scriptID;
+    private int scriptID;
 
-	public boolean onExecute() {
+    public boolean onExecute() {
-		return true;
+        return true;
-	}
+    }
 
-	public void onFinish() {
+    public void onFinish() {
 
-	}
+    }
 
-	public final void provide(final Collection<Strategy> strategies) {
+    public final void provide(final Collection<Strategy> strategies) {
-		this.strategies = strategies;
+        this.strategies = strategies;
-	}
+    }
 
-	public final int getFrameWorkType() {
+    public final int getFrameWorkType() {
-		return frameWorkType;
+        return frameWorkType;
-	}
+    }
 
-	public final void setFrameWork(int frameWorkType) {
+    public final void setFrameWork(int frameWorkType) {
-		if(frameWorkType < 0 || frameWorkType > 2) {
+        if (frameWorkType < 0 || frameWorkType > 2) {
-			throw new RuntimeException("Invalid framework type");
+            throw new RuntimeException("Invalid framework type");
-		}
+        }
-		this.frameWorkType = frameWorkType;
+        this.frameWorkType = frameWorkType;
-	}
+    }
 
-	public final void setAbstractFrameWork(AbstractFramework f) {
+    public final void setAbstractFrameWork(AbstractFramework f) {
-		this.frameWork = f;
+        this.frameWork = f;
-	}
+    }
 
-	public final void addRandom(Random random) {
+    public final void addRandom(Random random) {
-		Context.getInstance().getRandomHandler().addRandom(random);
+        Context.getInstance().getRandomHandler().addRandom(random);
-	}
+    }
 
-	@Override
+    @Override
-	public final void run() {
+    public final void run() {
-		Context context = Context.getInstance();
+        Context context = Context.getInstance();
 
-		Core.verbose("Initializing script...");
+        Core.verbose("Initializing script...");
-		context.getServerProvider().initScript(this);
+        context.getServerProvider().initScript(this);
-		Core.verbose("Done.");
+        Core.verbose("Done.");
 
-		if(!onExecute()) {
+        if (!onExecute()) {
-			Core.verbose("Script#onExecute returned false, unloading and stopping script...");
+            Core.verbose("Script#onExecute returned false, unloading and stopping script...");
-			context.getServerProvider().unloadScript(this);
+            context.getServerProvider().unloadScript(this);
-			this.state = STATE_STOPPED;
+            this.state = STATE_STOPPED;
-			Core.verbose("Done.");
+            Core.verbose("Done.");
-			return;
+            return;
-		}
+        }
 
-		Core.verbose("Detecting script framework...");
+        context.getRandomHandler().checkAndRun(RandomType.ON_SCRIPT_START);
-		context.setRunningScript(this);
-		BotUI.getInstance().toggleRun();
-		if(this instanceof LoopTask) {
-			Core.verbose("Script framework detected: LoopTask");
-			frameWorkType = TYPE_LOOP;
-			frameWork = Frameworks.getLooper((LoopTask) this);
-		} else if(strategies != null && !strategies.isEmpty()) {
-			Core.verbose("Script framework detected: Strategies");
-			frameWorkType = TYPE_STRATEGY;
-			frameWork = Frameworks.getStrategyWorker(strategies);
-		} else {
-			Core.verbose("Unknown script framework: Other");
-			frameWorkType = TYPE_OTHER;
-		}
-		Core.verbose("Running script...");
-		Logger.addMessage("Script started.", true);
-		try {
-			while(this.state != STATE_STOPPED) {
-				if(context.getRandomHandler().checkAndRun()) {
-					continue;
-				}
 
-				if(this.state == STATE_PAUSE) {
+        Core.verbose("Detecting script framework...");
-					sleep(500);
+        context.setRunningScript(this);
-					continue;
+        BotUI.getInstance().toggleRun();
-				}
+        if (this instanceof LoopTask) {
-				if(!frameWork.execute()) {
+            Core.verbose("Script framework detected: LoopTask");
-					break;
+            frameWorkType = TYPE_LOOP;
-				}
+            frameWork = Frameworks.getLooper((LoopTask) this);
-			}
+        } else if (strategies != null && !strategies.isEmpty()) {
-		} catch (Throwable t) {
+            Core.verbose("Script framework detected: Strategies");
-			t.printStackTrace();
+            frameWorkType = TYPE_STRATEGY;
-		}
+            frameWork = Frameworks.getStrategyWorker(strategies);
-		Core.verbose("Script stopped/finished, unloading and stopping...");
+        } else {
-		onFinish();
+            Core.verbose("Unknown script framework: Other");
-		Logger.addMessage("Script stopped.", false);
+            frameWorkType = TYPE_OTHER;
-		context.getServerProvider().unloadScript(this);
+        }
-		this.state = STATE_STOPPED;
+        Core.verbose("Running script...");
-		context.setRunningScript(null);
+        Logger.addMessage("Script started.", true);
+        try {
+            while (this.state != STATE_STOPPED) {
+                if (context.getRandomHandler().checkAndRun(RandomType.SCRIPT)) {
+                    continue;
+                }
 
-		Core.verbose("Resetting key bindings...");
+                if (this.state == STATE_PAUSE) {
-		Context.getInstance().getPbKeyListener().resetBindings();
+                    sleep(500);
+                    continue;
+                }
+                if (!frameWork.execute()) {
+                    break;
+                }
+            }
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
+        Core.verbose("Script stopped/finished, unloading and stopping...");
+        onFinish();
 
-		BotUI.getInstance().toggleRun();
+        context.getRandomHandler().checkAndRun(RandomType.ON_SCRIPT_FINISH);
-		Core.verbose("Done.");
-	}
 
-	/**
+        Logger.addMessage("Script stopped.", false);
-	 * Sleeps until the SleepCondition is valid.
+        context.getServerProvider().unloadScript(this);
-	 *
+        this.state = STATE_STOPPED;
-	 * <B>DEPRECATED!</b> use {@link Time#sleep(SleepCondition, int)}
+        context.setRunningScript(null);
-	 *
-	 * @param conn
-	 *            the condition.
-	 * @param timeout
-	 *            the time in miliseconds before it stops sleeping.
-	 * @return whether it ran successfully without timing out.
-	 */
-	@Deprecated
-	public final boolean sleep(SleepCondition conn, int timeout) {
-		return Time.sleep(conn, timeout);
-	}
 
-	/**
+        Core.verbose("Resetting key bindings...");
-	 * Sets the script's state
+        Context.getInstance().getPbKeyListener().resetBindings();
-	 * @param state
-	 */
-	public final void setState(final int state) {
-		if(state < 0 || state > 2) {
-			throw new IllegalArgumentException("Illegal state");
-		}
-		this.state = state;
-	}
 
-	/**
+        BotUI.getInstance().toggleRun();
-	 * Sleeps for an amount of milliseconds
+        Core.verbose("Done.");
-	 * @param ms
+    }
-	 */
-	public final void sleep(int ms) {
-		Time.sleep(ms);
-	}
 
-	public int getState() {
+    /**
-		return state;
+     * Sleeps until the SleepCondition is valid.
-	}
+     * <p>
+     * <B>DEPRECATED!</b> use {@link Time#sleep(SleepCondition, int)}
+     *
+     * @param conn    the condition.
+     * @param timeout the time in miliseconds before it stops sleeping.
+     * @return whether it ran successfully without timing out.
+     */
+    @Deprecated
+    public final boolean sleep(SleepCondition conn, int timeout) {
+        return Time.sleep(conn, timeout);
+    }
 
-	public PBPreferences getPreferences(){
+    /**
-		if (this.preferences == null){
+     * Sets the script's state
-			this.preferences = new PBPreferences(scriptID);
+     *
-		}
+     * @param state
-		return this.preferences;
+     */
-	}
+    public final void setState(final int state) {
+        if (state < 0 || state > 2) {
+            throw new IllegalArgumentException("Illegal state");
+        }
+        this.state = state;
+    }
 
-	public void setScriptID(int scriptID){
+    /**
-		this.scriptID = scriptID;
+     * Sleeps for an amount of milliseconds
-	}
+     *
+     * @param ms
+     */
+    public final void sleep(int ms) {
+        Time.sleep(ms);
+    }
+
+    public int getState() {
+        return state;
+    }
+
+    public PBPreferences getPreferences() {
+        if (this.preferences == null) {
+            this.preferences = new PBPreferences(scriptID);
+        }
+        return this.preferences;
+    }
+
+    public void setScriptID(int scriptID) {
+        this.scriptID = scriptID;
+    }
 }

src/main/java/org/parabot/environment/scripts/randoms/Random.java

@@ -1,18 +1,19 @@
 package org.parabot.environment.scripts.randoms;
 
 /**
- * 
  * @author Everel
- *
+ * @deprecated
+ * @see org.parabot.environment.randoms.Random
  */
+@Deprecated
 public interface Random {
-	
+
 	/**
 	 * Determines whether this random should activate
 	 * @return <b>true</b> if this random should activate
 	 */
 	public boolean activate();
-	
+
 	/**
 	 * Executes this random
 	 */

src/main/java/org/parabot/environment/scripts/randoms/RandomHandler.java

@@ -1,108 +1,11 @@
 package org.parabot.environment.scripts.randoms;
 
-import org.parabot.core.Core;
-import org.parabot.core.ui.Logger;
-
-import java.util.ArrayList;
-
 /**
- * 
  * @author Everel
- *
+ * @deprecated
+ * @see org.parabot.environment.randoms.RandomHandler
  */
-public class RandomHandler {
+@Deprecated
-    private ArrayList<Random> randoms;
+public class RandomHandler extends org.parabot.environment.randoms.RandomHandler {
 
-    /**
-     * The randoms that will actually run
-     */
-    private ArrayList<Random> activeRandoms;
-    
-    public RandomHandler() {
-    	this.randoms = new ArrayList<>();
-        this.activeRandoms = new ArrayList<>();
-    }
-
-    /**
-     * Adds a random to the random list
-     * @param random The random that will be added to the arraylist
-     */
-    public void addRandom(Random random) {
-    	if(random == null) {
-    		throw new NullPointerException("Null random");
-    	}
-    	for(Random r : randoms) {
-    		if(r.getClass() == random.getClass()) {
-    			Core.verbose("Ignored added random, duplicate.");
-    			return;
-    		}
-    	}
-        randoms.add(random);
-        setActive(random);
-    }
-
-    /**
-     * Adds a random to the active randoms
-     * @param random
-     */
-    public void setActive(Random random){
-        this.activeRandoms.add(random);
-    }
-
-    /**
-     * Adds a random to the active randoms
-     * @param random
-     */
-    public void setActive(String random){
-        for (Random r : this.randoms){
-            if (r.getName().equalsIgnoreCase(random.toLowerCase())){
-                this.activeRandoms.add(r);
-            }
-        }
-    }
-
-    /**
-     * Sets the whole random arraylist to the arraylist given as argument
-     * @param randoms The new random arraylist
-     */
-    public void setRandoms(ArrayList<Random> randoms){
-        this.randoms = randoms;
-    }
-    
-    /**
-     * Clears all added randoms
-     */
-    public void clearRandoms() {
-    	this.randoms.clear();
-    }
-
-    /**
-     * Clears all active randoms
-     */
-    public void clearActiveRandoms(){
-        this.activeRandoms.clear();
-    }
-
-    /**
-     * Checks if random occurs and runs it
-     * @return returns <b>true</b> if a random has been executed, otherwise <b>false</b>
-     */
-    public boolean checkAndRun() {
-        for(Random r : this.activeRandoms) {
-            if(r.activate()) {
-                Logger.addMessage("Running random '" + r.getName() + "'", true);
-                r.execute();
-                return true;
-            }
-        }
-        return false;
-    }
-
-    public ArrayList<Random> getRandoms(){
-        return this.randoms;
-    }
-
-    public ArrayList<Random> getActiveRandoms(){
-        return this.activeRandoms;
-    }
 }

src/main/java/org/parabot/environment/servers/executers/ServerExecuter.java

@@ -27,7 +27,8 @@ public abstract class ServerExecuter {
 					Context context = Context.getInstance(provider);
 					context.load();
 					PaintComponent.getInstance().startPainting(context);
-					RandomParser.enable();
+
+					Context.getInstance().getRandomHandler().init();
 				} catch (Throwable t) {
 					t.printStackTrace();
 				}